diff --git a/.dockerignore b/.dockerignore
index ab301e50..dccf35c3 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,9 +1,8 @@
 .git
 .github
 dist
-gui/build
-gui/frontend/node_modules
-gui/frontend/dist
+webui/node_modules
+webui/dist
 scripts
 documentation
 **/*_test.go
diff --git a/.github/workflows/build-binaries.yml b/.github/workflows/build-binaries.yml
index ec309489..b31c50d4 100644
--- a/.github/workflows/build-binaries.yml
+++ b/.github/workflows/build-binaries.yml
@@ -69,21 +69,21 @@ jobs:
         with:
           node-version: 24
           cache: pnpm
-          cache-dependency-path: gui/frontend/pnpm-lock.yaml
+          cache-dependency-path: webui/pnpm-lock.yaml
 
       - name: Install frontend dependencies
         shell: bash
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm install --frozen-lockfile
 
       - name: Build embedded web assets
         shell: bash
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run build:bundle
 
       - name: Sync embedded web assets
         shell: pwsh
-        run: pwsh -NoProfile -File ./scripts/sync-frontend-assets.ps1
+        run: pwsh -NoProfile -File ./scripts/sync-webui-assets.ps1
 
       - name: Build CLI
         shell: bash
@@ -168,181 +168,8 @@ jobs:
           path: dist/packages/upbrr-cli-*-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.goarm != '' && format('v{0}', matrix.goarm) || '' }}${{ matrix.goos == 'windows' && '.zip' || '.tar.gz' }}
           if-no-files-found: error
 
-  build-gui:
-    name: Build GUI (${{ matrix.platform }})
-    runs-on: ${{ matrix.runner }}
-    timeout-minutes: 45
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - runner: windows-latest
-            platform: windows/amd64
-            artifact: windows-x64
-          - runner: windows-latest
-            platform: windows/arm64
-            artifact: windows-arm64
-          - runner: ubuntu-24.04
-            platform: linux/amd64
-            artifact: linux-x64
-          - runner: ubuntu-24.04-arm
-            platform: linux/arm64
-            artifact: linux-arm64
-          - runner: macos-15-intel
-            platform: darwin/amd64
-            artifact: macos-x64
-          - runner: macos-15
-            platform: darwin/arm64
-            artifact: macos-arm64
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ inputs.release_tag || github.ref }}
-
-      - name: Setup Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-          cache: true
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10.27.0
-
-      - name: Setup Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: pnpm
-          cache-dependency-path: gui/frontend/pnpm-lock.yaml
-
-      - name: Install GUI frontend dependencies
-        shell: bash
-        working-directory: gui/frontend
-        run: pnpm install --frozen-lockfile
-
-      - name: Typecheck and build GUI frontend assets
-        shell: bash
-        working-directory: gui/frontend
-        run: |
-          set -euo pipefail
-          pnpm run typecheck &
-          typecheck_pid=$!
-          pnpm run build:bundle &
-          build_pid=$!
-          wait "$typecheck_pid"
-          wait "$build_pid"
-
-      - name: Sync embedded GUI assets
-        shell: pwsh
-        run: pwsh -NoProfile -File ./scripts/sync-frontend-assets.ps1
-
-      - name: Install Linux GUI dependencies
-        if: startsWith(matrix.platform, 'linux/')
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            build-essential \
-            libgtk-3-dev \
-            libwebkit2gtk-4.1-dev \
-            libglib2.0-dev \
-            libx11-dev \
-            libxkbcommon-dev \
-            libxrandr-dev \
-            libxinerama-dev \
-            libxcursor-dev \
-            libxi-dev \
-            pkg-config \
-            patchelf
-
-      - name: Install Wails CLI
-        shell: bash
-        run: go install github.com/wailsapp/wails/v2/cmd/wails@v2.12.0
-
-      - name: Build GUI
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ inputs.release_tag }}
-          REF_TYPE: ${{ github.ref_type }}
-          REF_NAME: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          version="$RELEASE_TAG"
-          if [[ -z "$version" && "$REF_TYPE" == "tag" ]]; then
-            version="$REF_NAME"
-          fi
-          if [[ -z "$version" ]]; then
-            version="dev"
-          fi
-          build_id="$(git rev-parse --short=12 HEAD)"
-          ldflags="-s -w -X main.version=${version} -X main.buildIdentifier=${build_id}"
-
-          cd gui
-          if [[ "${{ matrix.platform }}" == linux/* ]]; then
-            wails build -platform "${{ matrix.platform }}" -clean -trimpath -tags webkit2_41 -ldflags "$ldflags"
-          elif [[ "${{ matrix.platform }}" == "windows/arm64" ]]; then
-            # Wails bindings helper is built for target arch; skip on x64 runners for arm64 target.
-            wails build -platform "${{ matrix.platform }}" -clean -skipbindings -trimpath -ldflags "$ldflags"
-          else
-            wails build -platform "${{ matrix.platform }}" -clean -trimpath -ldflags "$ldflags"
-          fi
-
-      - name: Package GUI (Windows)
-        if: startsWith(matrix.platform, 'windows/')
-        shell: pwsh
-        env:
-          RELEASE_TAG: ${{ inputs.release_tag }}
-          REF_TYPE: ${{ github.ref_type }}
-          REF_NAME: ${{ github.ref_name }}
-        run: |
-          $version = $env:RELEASE_TAG
-          if (-not $version -and $env:REF_TYPE -eq "tag") {
-            $version = $env:REF_NAME
-          }
-          if (-not $version) {
-            $version = "dev"
-          }
-          New-Item -ItemType Directory -Force -Path dist/packages | Out-Null
-          $target = "${{ matrix.artifact }}"
-          $archive = "dist/packages/upbrr-gui-$version-$target.zip"
-          if (Test-Path $archive) {
-            Remove-Item $archive -Force
-          }
-          Compress-Archive -Path "gui/build/bin/*" -DestinationPath $archive -Force
-
-      - name: Package GUI (Linux/macOS)
-        if: ${{ !startsWith(matrix.platform, 'windows/') }}
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ inputs.release_tag }}
-          REF_TYPE: ${{ github.ref_type }}
-          REF_NAME: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          mkdir -p dist/packages
-          version="$RELEASE_TAG"
-          if [[ -z "$version" && "$REF_TYPE" == "tag" ]]; then
-            version="$REF_NAME"
-          fi
-          if [[ -z "$version" ]]; then
-            version="dev"
-          fi
-          target="${{ matrix.artifact }}"
-          archive="dist/packages/upbrr-gui-${version}-${target}.tar.gz"
-          tar -C gui/build/bin -czf "$archive" .
-
-      - name: Upload GUI artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: gui-${{ matrix.artifact }}
-          path: dist/packages/upbrr-gui-*-${{ matrix.artifact }}${{ startsWith(matrix.platform, 'windows/') && '.zip' || '.tar.gz' }}
-          if-no-files-found: error
-
   build-docker-amd64:
-    name: Build Docker Image (cli+gui linux/amd64)
+    name: Build Docker Image (CLI+WebUI linux/amd64)
     runs-on: ubuntu-latest
     timeout-minutes: 45
     permissions:
@@ -424,7 +251,7 @@ jobs:
           cache-to: type=gha,scope=build-docker-amd64,mode=min
 
   build-docker-arm64:
-    name: Build Docker Image (cli+gui linux/arm64)
+    name: Build Docker Image (CLI+WebUI linux/arm64)
     runs-on: ubuntu-24.04-arm
     timeout-minutes: 45
     permissions:
@@ -506,7 +333,7 @@ jobs:
           cache-to: type=gha,scope=build-docker-arm64,mode=min
 
   publish-docker-manifest:
-    name: Publish Docker Manifest (cli+gui)
+    name: Publish Docker Manifest (CLI+WebUI)
     runs-on: ubuntu-latest
     timeout-minutes: 20
     needs:
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 865a662b..8f3f7eb1 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -56,10 +56,10 @@ jobs:
         with:
           node-version: 24
           cache: pnpm
-          cache-dependency-path: gui/frontend/pnpm-lock.yaml
+          cache-dependency-path: webui/pnpm-lock.yaml
 
       - name: Install frontend dependencies
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm install --frozen-lockfile
 
       # Prettier keeps its own per-file cache keyed on Prettier's version and the
@@ -70,29 +70,29 @@ jobs:
         id: prettier-cache
         uses: actions/cache/restore@v4
         with:
-          path: gui/frontend/node_modules/.cache/prettier
-          key: prettier-${{ runner.os }}-${{ hashFiles('gui/frontend/package.json', 'gui/frontend/pnpm-lock.yaml', 'gui/frontend/.prettierrc*', 'gui/frontend/prettier.config.*') }}
+          path: webui/node_modules/.cache/prettier
+          key: prettier-${{ runner.os }}-${{ hashFiles('webui/package.json', 'webui/pnpm-lock.yaml', 'webui/.prettierrc*', 'webui/prettier.config.*') }}
           restore-keys: |
             prettier-${{ runner.os }}-
 
       - name: Run frontend lint
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run lint
 
       - name: Run frontend dead-code lint
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run lint:dead
 
       - name: Run frontend typecheck
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run typecheck
 
       - name: Run frontend unit tests
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run test:unit
 
       - name: Check frontend formatting
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm run format:check
 
       # Save only when the primary key wasn't an exact restore-hit so we don't retry
@@ -104,5 +104,5 @@ jobs:
         if: always() && steps.prettier-cache.outputs.cache-hit != 'true'
         uses: actions/cache/save@v4
         with:
-          path: gui/frontend/node_modules/.cache/prettier
+          path: webui/node_modules/.cache/prettier
           key: ${{ steps.prettier-cache.outputs.cache-primary-key }}
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 852eed4a..21371411 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -36,14 +36,14 @@ jobs:
         with:
           node-version: 24
           cache: pnpm
-          cache-dependency-path: gui/frontend/pnpm-lock.yaml
+          cache-dependency-path: webui/pnpm-lock.yaml
 
       - name: Install frontend dependencies
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm install --frozen-lockfile
 
       - name: Install Playwright browser
-        working-directory: gui/frontend
+        working-directory: webui
         run: pnpm exec playwright install --with-deps chromium
 
       - name: Run E2E
@@ -54,7 +54,7 @@ jobs:
         uses: actions/upload-artifact@v7
         with:
           name: playwright-report
-          path: gui/frontend/playwright-report
+          path: webui/playwright-report
           if-no-files-found: ignore
 
       - name: Upload Playwright traces
@@ -62,5 +62,5 @@ jobs:
         uses: actions/upload-artifact@v7
         with:
           name: playwright-test-results
-          path: gui/frontend/test-results
+          path: webui/test-results
           if-no-files-found: ignore
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 65314eaa..e8515b2f 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -12,8 +12,8 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  pathpolicy:
-    name: pathpolicy (${{ matrix.os }})
+  policies:
+    name: repository policies (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     timeout-minutes: 5
     strategy:
@@ -34,14 +34,20 @@ jobs:
           go-version-file: go.mod
           cache: true
 
+      - name: Run architecture ownership policy
+        run: go run ./cmd/architecturepolicy
+
       - name: Run path portability policy
         run: go run ./cmd/pathpolicy
 
+      - name: Run composite literal layout policy
+        run: go run ./cmd/literalpolicy
+
   golangci:
     name: golangci-lint
     runs-on: ubuntu-latest
     timeout-minutes: 10
-    needs: pathpolicy
+    needs: policies
 
     steps:
       - name: Checkout
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8f9f1675..153ed41d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -71,12 +71,6 @@ jobs:
           path: release-artifacts
           pattern: cli-*
 
-      - name: Download GUI artifacts
-        uses: actions/download-artifact@v5
-        with:
-          path: release-artifacts
-          pattern: gui-*
-
       - name: Publish release assets
         shell: bash
         env:
diff --git a/.github/workflows/vuln.yml b/.github/workflows/vuln.yml
index c732b401..6ccf948a 100644
--- a/.github/workflows/vuln.yml
+++ b/.github/workflows/vuln.yml
@@ -3,7 +3,7 @@ name: vuln
 on:
   workflow_dispatch:
   schedule:
-    - cron: '17 8 * * 1'
+    - cron: "17 8 * * 1"
 
 permissions:
   contents: read
@@ -37,4 +37,4 @@ jobs:
 
       - name: Run OSV dependency scan
         if: ${{ !cancelled() }}
-        run: go run github.com/google/osv-scanner/v2/cmd/osv-scanner@${OSV_SCANNER_VERSION} scan source --lockfile go.mod --lockfile gui/frontend/pnpm-lock.yaml
+        run: go run github.com/google/osv-scanner/v2/cmd/osv-scanner@${OSV_SCANNER_VERSION} scan source --lockfile go.mod --lockfile webui/pnpm-lock.yaml
diff --git a/.gitignore b/.gitignore
index fd43e7cb..b926385b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,9 @@
-gui/frontend/node_modules/
-gui/frontend/dist/
-gui/frontend/package.json.md5
-gui/frontend/tsconfig.tsbuildinfo
-gui/frontend/wailsjs/go/
-gui/build/bin/
-internal/webserver/assets/
-internal/guiapp/assets/*
-!internal/guiapp/assets/.keep
+webui/node_modules/
+webui/dist/
+webui/package.json.md5
+webui/tsconfig.tsbuildinfo
+internal/webserver/assets/*
+!internal/webserver/assets/.keep
 dist/
 docs/
 tmp/
@@ -19,8 +16,8 @@ tmp/
 /scripts/*.py
 
 # E2E / Playwright artifacts
-gui/frontend/playwright-report/
-gui/frontend/test-results/
+webui/playwright-report/
+webui/test-results/
 
 # Lefthook
 .lefthook-local.yml
@@ -28,8 +25,8 @@ gui/frontend/test-results/
 
 # Lint / formatter caches
 lint-report.json
-gui/frontend/.eslintcache
-gui/frontend/node_modules/.cache/prettier/
+webui/.eslintcache
+webui/node_modules/.cache/prettier/
 
 # App Configs
 /config/*.yaml
diff --git a/.golangci.yml b/.golangci.yml
index a9ab5a33..13cfa888 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -7,11 +7,22 @@ formatters:
   enable:
     - goimports
     - gofmt
+    - golines
 
   settings:
     goimports:
       local-prefixes:
         - github.com/autobrr/upbrr
+    golines:
+      max-len: 160
+      tab-len: 4
+      shorten-comments: false
+      reformat-tags: false
+      chain-split-dots: false
+
+  exclusions:
+    paths:
+      - _test\.go$
 
 linters:
   enable:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index a8396c6d..d72af7c1 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -11,17 +11,7 @@
       "cwd": "${workspaceFolder}"
     },
     {
-      "name": "CLI: Run with --gui",
-      "type": "go",
-      "request": "launch",
-      "mode": "debug",
-      "program": "${workspaceFolder}/cmd/upbrr",
-      "buildFlags": "-tags dev",
-      "args": ["--gui"],
-      "cwd": "${workspaceFolder}"
-    },
-    {
-      "name": "CLI: Serve (Web Mode)",
+      "name": "CLI: Serve WebUI",
       "type": "go",
       "request": "launch",
       "mode": "debug",
@@ -48,27 +38,6 @@
       "args": ["--dry-run", "${input:sourcePath}"],
       "cwd": "${workspaceFolder}"
     },
-    {
-      "name": "GUI: Run (Wails Entrypoint)",
-      "type": "go",
-      "request": "launch",
-      "mode": "auto",
-      "program": "${workspaceFolder}/gui",
-      "buildFlags": "-tags dev",
-      "cwd": "${workspaceFolder}"
-    },
-    {
-      "name": "GUI: Debug (Wails Build)",
-      "type": "go",
-      "request": "launch",
-      "mode": "exec",
-      "program": "${workspaceFolder}/gui/build/bin/upbrr-gui",
-      "windows": {
-        "program": "${workspaceFolder}/gui/build/bin/upbrr-gui.exe"
-      },
-      "preLaunchTask": "build-gui",
-      "cwd": "${workspaceFolder}"
-    },
     {
       "name": "Test: Current Package",
       "type": "go",
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 71e9d5df..cf9c0b4f 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -17,17 +17,17 @@
   },
   "npm.packageManager": "pnpm",
   "files.exclude": {
-    "gui/frontend/node_modules": true,
-    "gui/frontend/dist": true,
-    "gui/build/bin": true,
-    "internal/guiapp/assets": true,
+    "webui/node_modules": true,
+    "webui/dist": true,
+    "webui/playwright-report": true,
+    "internal/webserver/assets": true,
     "dist": true
   },
   "search.exclude": {
-    "gui/frontend/node_modules": true,
-    "gui/frontend/dist": true,
-    "gui/build/bin": true,
-    "internal/guiapp/assets": true,
+    "webui/node_modules": true,
+    "webui/dist": true,
+    "webui/playwright-report": true,
+    "internal/webserver/assets": true,
     "dist": true
   },
 
@@ -53,7 +53,7 @@
       "text": "Hard limit: the subject line (type + scope + subject) must be 115 characters or fewer. Aim for under 72 when the change is simple; use the extra headroom only when it genuinely helps."
     },
     {
-      "text": "Scope is optional. If used, keep it short (one word, an area like `config`, `ci`, `gui`, `cli`, or a tracker acronym like `bt`, `asc`). Uppercase tracker acronyms are acceptable."
+      "text": "Scope is optional. If used, keep it short (one word, an area like `config`, `ci`, `webui`, `cli`, or a tracker acronym like `bt`, `asc`). Uppercase tracker acronyms are acceptable."
     },
     {
       "text": "Body (optional, separated from subject by a blank line): explain *why* the change was made and any non-obvious context. Wrap body lines at ~115 characters. Do not restate what the diff already shows."
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 29ae5217..277c090a 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -9,29 +9,20 @@
       "windows": {
         "args": ["build", "-o", "dist/upbrr.exe", "./cmd/upbrr"]
       },
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "group": "build",
       "problemMatcher": ["$go"]
     },
-    {
-      "label": "build-gui",
-      "type": "shell",
-      "command": "go",
-      "args": [
-        "run",
-        "github.com/wailsapp/wails/v2/cmd/wails@v2.10.1",
-        "build"
-      ],
-      "options": { "cwd": "${workspaceFolder}/gui" },
-      "group": "build",
-      "problemMatcher": []
-    },
     {
       "label": "frontend-install",
       "type": "shell",
       "command": "pnpm",
       "args": ["install", "--frozen-lockfile"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "problemMatcher": []
     },
     {
@@ -39,7 +30,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "build"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "dependsOn": ["frontend-install"],
       "problemMatcher": []
     },
@@ -48,16 +41,20 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "dev"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "isBackground": true,
       "problemMatcher": []
     },
     {
       "label": "format-go",
       "type": "shell",
-      "command": "golangci-lint",
-      "args": ["fmt", "./..."],
-      "options": { "cwd": "${workspaceFolder}" },
+      "command": "make",
+      "args": ["fmt-go"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "problemMatcher": []
     },
     {
@@ -65,7 +62,9 @@
       "type": "shell",
       "command": "golangci-lint",
       "args": ["run", "--timeout=5m"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "group": "test",
       "problemMatcher": ["$go"]
     },
@@ -74,7 +73,9 @@
       "type": "shell",
       "command": "golangci-lint",
       "args": ["run", "--fix", "--timeout=5m"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "problemMatcher": ["$go"]
     },
     {
@@ -82,7 +83,51 @@
       "type": "shell",
       "command": "go",
       "args": ["run", "./cmd/logpolicy"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "group": "test",
+      "problemMatcher": {
+        "owner": "go",
+        "fileLocation": ["relative", "${workspaceFolder}"],
+        "pattern": {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      }
+    },
+    {
+      "label": "pathpolicy",
+      "type": "shell",
+      "command": "go",
+      "args": ["run", "./cmd/pathpolicy"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "group": "test",
+      "problemMatcher": {
+        "owner": "go",
+        "fileLocation": ["relative", "${workspaceFolder}"],
+        "pattern": {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      }
+    },
+    {
+      "label": "literalpolicy",
+      "type": "shell",
+      "command": "go",
+      "args": ["run", "./cmd/literalpolicy"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "group": "test",
       "problemMatcher": {
         "owner": "go",
@@ -101,7 +146,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "format"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "problemMatcher": []
     },
     {
@@ -109,7 +156,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "format:check"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "group": "test",
       "problemMatcher": []
     },
@@ -118,7 +167,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "lint"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "group": "test",
       "problemMatcher": ["$eslint-stylish"]
     },
@@ -127,7 +178,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "lint:fix"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "problemMatcher": ["$eslint-stylish"]
     },
     {
@@ -135,7 +188,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "typecheck"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "group": "test",
       "problemMatcher": ["$tsc"]
     },
@@ -144,7 +199,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "lint:dead"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "group": "test",
       "problemMatcher": []
     },
@@ -153,7 +210,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "lint:style"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "group": "test",
       "problemMatcher": []
     },
@@ -162,7 +221,9 @@
       "type": "shell",
       "command": "pnpm",
       "args": ["run", "lint:style:fix"],
-      "options": { "cwd": "${workspaceFolder}/gui/frontend" },
+      "options": {
+        "cwd": "${workspaceFolder}/webui"
+      },
       "problemMatcher": []
     },
     {
@@ -170,8 +231,13 @@
       "type": "shell",
       "command": "go",
       "args": ["test", "-v", "-timeout", "20m", "./..."],
-      "options": { "cwd": "${workspaceFolder}" },
-      "group": { "kind": "test", "isDefault": true },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
       "problemMatcher": {
         "owner": "go-test",
         "fileLocation": ["relative", "${workspaceFolder}"],
@@ -189,7 +255,9 @@
       "type": "shell",
       "command": "go",
       "args": ["run", "./cmd/upbrr", "serve"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "isBackground": true,
       "problemMatcher": {
         "owner": "go",
@@ -211,9 +279,14 @@
     },
     {
       "label": "build-all",
-      "dependsOn": ["build-cli", "build-gui"],
       "group": "build",
-      "problemMatcher": []
+      "problemMatcher": [],
+      "type": "shell",
+      "command": "make",
+      "args": ["build"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      }
     },
     {
       "label": "lint-all",
@@ -224,7 +297,9 @@
         "lint-style-frontend",
         "typecheck-frontend",
         "format-check-frontend",
-        "logpolicy"
+        "logpolicy",
+        "pathpolicy",
+        "literalpolicy"
       ],
       "group": "test",
       "problemMatcher": []
@@ -260,7 +335,9 @@
       "type": "shell",
       "command": "lefthook",
       "args": ["install"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "problemMatcher": []
     },
     {
@@ -268,7 +345,9 @@
       "type": "shell",
       "command": "lefthook",
       "args": ["run", "pre-commit", "--all-files"],
-      "options": { "cwd": "${workspaceFolder}" },
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
       "group": "test",
       "problemMatcher": []
     }
diff --git a/ADDING_TRACKERS.md b/ADDING_TRACKERS.md
new file mode 100644
index 00000000..69063a36
--- /dev/null
+++ b/ADDING_TRACKERS.md
@@ -0,0 +1,681 @@
+# Adding tracker support
+
+This guide covers two supported extension paths:
+
+- a Unit3D tracker under `internal/trackers/impl/unit3d/sites/<tracker>`
+- a standalone, non-Unit3D tracker under `internal/trackers/impl/standalone/<tracker>`
+
+AvistaZ-family (`azfamily`) trackers are intentionally out of scope.
+
+## Ownership rules
+
+- `internal/trackers/impl/registry.go` is the only complete supported-tracker manifest.
+- A Unit3D or standalone profile owns the tracker's default endpoint and typed
+  policies.
+- Every tracker declares one semantic shared upload-content mode. Unit3D inherits
+  `description` from its family definition; standalone profiles choose explicitly.
+- `internal/config/defaults/example.yaml` owns the ordered config/settings surface. It must not
+  contain tracker `url` fields.
+- A tracker is configured when at least one activation credential in its config stanza is
+  non-empty. Authentication readiness is a separate concern.
+- Tracker-specific behavior stays in the tracker package. Do not add tracker-name dispatch to
+  generic metadata, auth, image-hosting, torrent-client, config, or frontend code.
+- The backend tracker catalog drives the frontend. Adding a tracker that uses existing config
+  fields normally requires no tracker-specific frontend edit.
+- Every registered tracker must expose a `dupe.Factory`, even when duplicate search can only
+  return a typed not-run result.
+- Upload and dry-run must share payload preparation. Dry-run must not submit the upload or repeat
+  workflow-level discovery and duplicate checking.
+
+## Fast file checklist
+
+A standard Unit3D addition normally changes:
+
+1. `internal/trackers/impl/unit3d/sites/<tracker>/profile.go`
+2. `internal/trackers/impl/unit3d/sites/<tracker>/rules.go`, when site rules exist
+3. `internal/trackers/impl/registry.go`
+4. `internal/config/defaults/example.yaml`
+5. `internal/trackers/rules_test.go`, when rules exist
+6. a site-local `profile_test.go`, when mappings or callbacks differ from Unit3D defaults
+
+Static banned groups, custom naming/descriptions, image-host rules, and other policies add
+site-local files only.
+
+A standalone addition normally changes:
+
+1. a new `internal/trackers/impl/standalone/<tracker>` package containing `profile.go`, upload,
+   duplicate-search, and focused test code
+2. `internal/trackers/impl/registry.go`
+3. `internal/config/defaults/example.yaml`
+4. `internal/trackers/rules_test.go`, when rules exist
+5. shared config/frontend field contracts only when no existing `config.TrackerConfig` field fits
+
+## Choose the shared upload-content mode
+
+`trackers.UploadContentMode` tells generic preparation which tracker-scoped content object the
+adapter consumes. Choose by protocol behavior, not tracker identity:
+
+| Mode | Use when | Adapter input | Failure scope |
+| --- | --- | --- | --- |
+| `none` | The adapter builds its payload without shared descriptions or selected images | `PreparationInput.Assets` is `nil` | Shared content cannot block the tracker |
+| `screenshots` | The adapter consumes selected screenshots/menu images but no shared description | Ready screenshot assets, which may be empty | A failed screenshot object blocks only that tracker |
+| `description` | The adapter consumes the full shared description plus its image assets | Ready aggregate description assets, which may contain empty text | A failed description object or required image substep blocks only that tracker |
+
+Ready-empty content is valid and differs from failed content. Generic coordinators never infer a
+failure from empty text or zero selected images.
+
+All Unit3D and AvistaZ-family definitions currently declare `description` once at family level.
+Standalone profiles must set `UploadContentMode` explicitly. Current protocol examples are BTN/NBL
+for `none`, ANT/RTF for `screenshots`, and most other standalone trackers for `description`.
+Changing a standalone tracker's workflow later should require only its profile and tracker-local
+adapter implementation; do not add tracker-name branches to core or tracker orchestration.
+
+## Add a Unit3D tracker
+
+### 1. Confirm that shared Unit3D behavior fits
+
+The shared implementation already supplies:
+
+- bearer API-key auth
+- `/api/torrents/upload` uploads
+- `/api/torrents/filter` duplicate searches
+- standard Unit3D descriptions and multipart payloads
+- generic Unit3D metadata lookup
+- standard category, type, and resolution IDs
+- standard torrent identity matching from the profile base URL
+- required MediaInfo encode-setting validation
+
+If the site changes only rules, IDs, naming, description formatting, payload fields, or typed
+policies, keep it as a Unit3D profile. If it replaces the protocol substantially, implement it as
+a standalone tracker instead of filling shared Unit3D code with site-name branches.
+
+### 2. Create the site package
+
+Create:
+
+```text
+internal/trackers/impl/unit3d/sites/example/
+  profile.go
+  rules.go                 # when the site has release rules
+  banned_groups.go         # when the site has a static list
+  profile_test.go          # when profile behavior differs from defaults
+```
+
+Additional site-local files such as `name.go`, `description.go`, or `audio_policy.go` are useful
+when `profile.go` would otherwise become a collection of unrelated behavior.
+
+A minimal profile is:
+
+```go
+package example
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns EXAMPLE's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "EXAMPLE",
+		BaseURL: "https://tracker.example.invalid",
+		Rules:   Rules(),
+	}
+}
+```
+
+`Name` is the stable uppercase identifier. `BaseURL` is authoritative and must be a valid HTTPS
+origin. Do not add an endpoint override to config.
+
+### 3. Handle category, type, and resolution IDs
+
+Shared Unit3D upload mapping is:
+
+| Dimension  | Normalized value     | Default ID |
+| ---------- | -------------------- | ---------- |
+| Category   | `MOVIE`              | `1`        |
+| Category   | `TV`                 | `2`        |
+| Type       | `DISC`               | `1`        |
+| Type       | `REMUX`              | `2`        |
+| Type       | `ENCODE` or `DVDRIP` | `3`        |
+| Type       | `WEBDL`              | `4`        |
+| Type       | `WEBRIP`             | `5`        |
+| Type       | `HDTV`               | `6`        |
+| Resolution | `4320p`              | `1`        |
+| Resolution | `2160p`              | `2`        |
+| Resolution | `1080p` or `1440p`   | `3`        |
+| Resolution | `1080i`              | `4`        |
+| Resolution | `720p`               | `5`        |
+| Resolution | `576p` / `576i`      | `6` / `7`  |
+| Resolution | `480p` / `480i`      | `8` / `9`  |
+| Resolution | unknown or `8640p`   | `10`       |
+
+Use site-local `SiteProfile` callbacks when the site differs:
+
+```go
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "EXAMPLE",
+		BaseURL: "https://tracker.example.invalid",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			ResolveCategoryID:   categoryID,
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+		},
+	}
+}
+
+func categoryID(meta api.UploadSubject) string {
+	switch {
+	case strings.EqualFold(unit3d.Category(meta), "TV") && meta.TVPack:
+		return "9"
+	case strings.EqualFold(unit3d.Category(meta), "TV"):
+		return "2"
+	default:
+		return unit3d.DefaultCategoryID(meta)
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "10",
+		"REMUX":  "20",
+		"ENCODE": "30",
+		"WEBDL":  "40",
+	}[unit3d.InferType(meta)]
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	return map[string]string{
+		"2160p": "1",
+		"1080p": "2",
+		"720p":  "3",
+	}[unit3d.Resolution(meta)]
+}
+```
+
+Available upload callbacks are:
+
+| Callback                 | Use                                                                    |
+| ------------------------ | ---------------------------------------------------------------------- |
+| `BuildName`              | Replace shared release-name formatting                                 |
+| `BuildDescription`       | Replace shared Unit3D description rendering                            |
+| `ResolveKeywords`        | Filter or remap the `keywords` field                                   |
+| `ResolveTypeID`          | Map prepared release facts to a site type ID                           |
+| `ResolveResolutionID`    | Map prepared release facts to a site resolution ID                     |
+| `ResolveCategoryID`      | Map canonical category and site facts to a site category ID            |
+| `ApplyAdditionalPayload` | Add site-only upload fields after the common payload is built          |
+| `FinalizeDescription`    | Transform the completed shared description without replacing its build |
+
+An empty or `"0"` custom type ID is treated as unsupported and blocks payload preparation. Test
+every accepted type. Category and resolution callbacks should also return deliberate values for
+all supported inputs; do not let accidental empty IDs reach the API.
+
+#### Duplicate-search mappings can differ independently
+
+`SiteProfile.ResolveCategoryID`, `ResolveTypeID`, and `ResolveResolutionID` currently affect upload
+and dry-run payloads only. Unit3D duplicate search builds a separate filter query.
+
+If the new tracker uses nonstandard duplicate-search IDs, omits filters, changes the filter path,
+or searches pending torrents, treat that as a Unit3D family-contract extension:
+
+1. Add a typed duplicate-search callback/policy to the Unit3D profile contract.
+2. Pass the composed profile into the Unit3D duplicate adapter.
+3. Apply the callback in `dupe_params.go` or the Unit3D data client without adding a new
+   tracker-name conditional.
+4. Define the mapping in the new site's `profile.go` or a site-local `dupe.go`.
+5. Test the exact query parameters and response normalization.
+
+Do not assume that custom upload IDs are also correct for duplicate search. Do not copy existing
+legacy site-name exceptions as the pattern for new trackers.
+
+### 4. Add tracker rules
+
+Declare standard rules through `trackers.RuleSet`. Unit3D automatically enables
+`RequireValidMISetting`, so the site does not need to repeat it.
+
+An adult rule plus Aither-style language rule looks like:
+
+```go
+package example
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns EXAMPLE's release eligibility requirements.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:  true,
+		AdultMessage: "Adult content is not allowed at EXAMPLE.",
+		Language: &trackers.LanguageRule{
+			Languages:      []string{"english", "en", "eng"},
+			RequireAudio:   true,
+			RequireSubs:    true,
+			AllowOriginal:  true,
+			ApplyIfNonDisc: true,
+		},
+	}
+}
+```
+
+Other reusable `RuleSet` fields cover:
+
+- category restrictions: movie-only, TV-only, or movie-unless-TV-pack
+- disc-only, minimum resolution, HEVC, DVD rip, external subtitle, hardcoded subtitle, and scene
+  NFO constraints
+- blocked groups and group/type exceptions
+- single-file folders
+- structured language requirements
+
+Use `RuleSet.Check` when site-local policy cannot be expressed by the common fields. It returns
+one or more keyed `api.RuleFailure` values plus an operational error:
+
+```go
+Check: func(ctx context.Context, subject api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	if blocked(subject) {
+		return []api.RuleFailure{trackers.NewRuleFailure(
+			"stable_rule_key",
+			"Operator-facing reason.",
+			api.RuleDispositionWaivable,
+		)}, nil
+	}
+	return nil, nil
+},
+```
+
+Choose the disposition deliberately: `advisory` never blocks, `waivable` requires exact user
+authorization, and `strict` cannot be bypassed. Every predicate whose result depends on resolution,
+including a required but missing resolution, must be `strict`. Keep rule keys stable and unique
+within the tracker. Cancellation, malformed runtime state, and external failures return `error`;
+they are not rule failures.
+
+Site-local checks should consume `api.RuleSubject` and Unit3D helpers such as `RuleType`,
+`RuleResolution`, `RuleGroup`, `RuleGenres`, `RuleKeywords`, `Anime`, `Animation`, and
+`AdultContent`. Provider metadata must belong to the exact prepared source; do not introduce
+fallbacks to stale parser or provider state.
+
+Add behavior cases to the combined `internal/trackers/rules_test.go`. Use
+`EvaluateRulesWithRegistry` so tests include Unit3D-wide requirements. Add focused site tests only
+for site-local mapping or complex custom-check behavior.
+
+### 5. Add banned groups
+
+For a static list, keep the data beside the site:
+
+```go
+package example
+
+// BannedGroups returns EXAMPLE's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{"GROUP-A", "GROUP-B"}
+}
+```
+
+Attach it in `Profile()`:
+
+```go
+BannedGroups: BannedGroups(),
+```
+
+For a dynamic Unit3D blacklist, declare the endpoint in the profile:
+
+```go
+BannedPolicy: &trackers.BannedGroupPolicy{
+	EndpointPath:  "/api/blacklists/releasegroups",
+	RequireAPIKey: true,
+},
+```
+
+Use `DefaultEndpoint` only for a tracker-owned absolute endpoint that cannot derive from
+`BaseURL`. Use `TRaSHGuideURL` for an external TRaSH-compatible source. Set `RawAPIKeyFallback` only
+when the remote API requires that known alternate authorization form. Parsing or auth behavior not
+represented by `BannedGroupPolicy` needs a typed policy extension, not a tracker-name branch in
+`internal/trackers/banned.go`.
+
+### 6. Add other site-owned policies only when required
+
+`unit3d.Profile` can also declare:
+
+| Profile field      | Purpose                                                      |
+| ------------------ | ------------------------------------------------------------ |
+| `AudioPolicy`      | Multi-language/bloat policy beyond release eligibility rules |
+| `DupePolicy`       | Candidate-comparison semantics after duplicate search        |
+| `UploadArtifact`   | Torrent source/announce personalization                      |
+| `ImageHost`        | Accepted, private, or conditional image hosts                |
+| `TorrentIdentity`  | Extra announce/comment aliases and torrent reuse preferences |
+| `ClaimPolicy`      | Generic claim orchestration requirements                     |
+| `DescriptionGroup` | Site-specific saved description override group               |
+
+Keep construction in `profile.go`; move substantial policy logic or data into a clearly named
+site-local file. If a capability does not exist, extend the typed profile/definition contract once
+and keep the site decision in the site package.
+
+### 7. Register the profile
+
+In `internal/trackers/impl/registry.go`:
+
+1. Import the site package.
+2. Add `example.Profile()` to `unit3DDefinitions()`.
+
+Do not add package `init()` registration. Add the tracker to `SetPriorityOrder` only when it needs
+an intentional curated priority; otherwise remaining Unit3D trackers are appended automatically.
+
+### 8. Add the config/settings stanza
+
+Add the tracker in the intended display order in `internal/config/defaults/example.yaml`:
+
+```yaml
+EXAMPLE:
+  link_dir_name: ""
+  api_key: ""
+  anon: false
+  modq: false
+```
+
+Rules:
+
+- Include only fields the tracker consumes.
+- Never add `url`.
+- Standard Unit3D activation uses an empty `api_key` default.
+- Activation credentials must default to an empty string.
+- Recognized activation keys are `api_key`, `ApiUser`, `ApiKey`, `username`, `password`,
+  `passkey`, `announce_url`, and `my_announce_url`.
+- `link_dir_name`, `favicon_url`, `image_host`, and `torrent_client` are not activation
+  credentials.
+- Stanza field order becomes frontend field order.
+
+When every field already exists in `config.TrackerConfig`, no tracker-specific frontend table is
+needed. If the tracker requires a genuinely new config field, also update:
+
+- `config.TrackerConfig` and its YAML/JSON tags in `internal/config/config.go`
+- activation-key handling in `internal/config/tracker_catalog.go`, if the field configures the
+  tracker
+- secret encryption/decryption coverage in `internal/config/secrets.go`, if sensitive
+- generic frontend presentation metadata in `webui/src/settings/trackerFields.ts`
+- config persistence, catalog, and frontend settings tests
+
+Prefer an existing semantically correct field over adding an alias for the same credential.
+
+### 9. Unit3D tests
+
+At minimum, cover:
+
+- registry/config parity
+- profile endpoint and family
+- rule allow/deny cases in `internal/trackers/rules_test.go`
+- every nonstandard category/type/resolution mapping
+- additional payload fields and description/name transforms
+- static/dynamic banned-group behavior when present
+- duplicate-search query mapping when it differs from standard Unit3D
+- dry-run/live payload parity for site-specific fields
+
+Existing contract tests also enforce endpoint locality, absence of generic tracker dispatch, and a
+duplicate factory for every registered tracker.
+
+## Add a standalone non-Unit3D tracker
+
+### 1. Create a tracker-owned package
+
+Use a package such as:
+
+```text
+internal/trackers/impl/standalone/example/
+  profile.go
+  upload.go
+  dupe.go
+  rules.go                 # optional
+  banned_groups.go         # optional
+  auth.go                  # optional
+  data.go                  # optional dynamic lookup
+  claims.go                # optional dynamic claim checks
+  profile_test.go
+  upload_test.go
+  dupe_test.go
+```
+
+Keep all endpoint, payload, auth, parser, rule, and policy behavior in this package. Shared protocol
+helpers belong in a neutral package only when more than one implementation genuinely shares the
+same contract.
+
+### 2. Compose the tracker profile
+
+Every standalone package owns one `profile.go`. It composes identity, the default endpoint,
+preparation callbacks, duplicate-search factory, auth descriptor, and static typed policy:
+
+```go
+// Profile returns EXAMPLE's standalone tracker composition.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                 "EXAMPLE",
+		BaseURL:              "https://tracker.example.invalid",
+		UploadContentMode:    trackers.UploadContentModeDescription,
+		DescriptionGroup:     "example",
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  newDuplicateAdapter,
+		Rules:                rules(),
+		BannedGroups:         bannedGroups(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: "EXAMPLE",
+		},
+	}
+}
+
+// New returns a fresh EXAMPLE definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+```
+
+`standalone.Definition` normalizes and defensively copies the profile, reports
+`trackers.FamilyStandalone`, and exposes declared capabilities. Required fields are name, base URL,
+upload-content mode, upload preparer, and duplicate factory. `PrepareDescription` is required only
+for `description`; omit it for `none` and `screenshots`.
+
+Keep rules and banned groups in tracker-local files and pass their package functions into the
+profile. Fold one-method static policy files into `profile.go`. Keep complex auth/session, parser,
+description, data, and claim behavior in focused tracker-local files.
+
+### 3. Prepare one immutable upload operation
+
+For `description`, implement two preparation callbacks:
+
+- `prepareDescription`: build or pass through the description and return its group.
+- `prepareUpload`: build canonical payload/artifact state once and return a
+  `trackers.PreparedOperation` containing its sanitized preview and a submit closure over the
+  captured state.
+
+For `none` or `screenshots`, implement only `prepareUpload`. A screenshot-mode adapter reads
+`req.Assets.Screenshots`, `req.Assets.MenuImages`, and `req.Assets.Slots`; it must tolerate a ready
+empty object when its protocol allows zero images.
+
+```go
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "EXAMPLE",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "example",
+		Description:      state.description,
+		Endpoint:         state.endpoint,
+		Payload:          state.previewFields(), // secrets redacted
+		Files:            state.previewFiles(),
+	})
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, state)
+	}, state.release), nil
+}
+```
+
+Description-preview calls only the description preparer. Dry-run and upload-review prepare a
+preview but cannot submit. Upload submits the captured state once. A submit closure may acquire a
+short-lived CSRF token, but must not rebuild canonical fields, rerun image uploads, or reread
+mutable prepared-release inputs. `Release` owns temporary resources and is exact-once.
+
+### 4. Keep category/type handling local
+
+Map the standalone protocol's categories, types, resolutions, flags, and payload fields inside the
+tracker package. Consume finalized prepared contracts:
+
+- `api.UploadSubject` for upload/dry-run
+- `api.DuplicateSubject` for duplicate search
+- `api.RuleSubject` for rules
+
+Do not add the mapping to `internal/metadata/media_details.go` or another generic package. Upload
+and duplicate-search mappings are separate API contracts; test both when they differ.
+
+### 5. Implement duplicate search
+
+Every tracker must implement `dupe.Factory`:
+
+```go
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	return &duplicateSearcher{
+		cfg:    deps.TrackerConfig(),
+		http:   deps.HTTPClient(),
+		logger: deps.Logger(),
+	}
+}
+```
+
+The adapter's `Search` must return one structural result:
+
+- `dupe.Resolved` for a completed search, including zero matches
+- `dupe.NotRun` with a stable code and safe message for missing credentials/metadata,
+  unsupported content, manual checking, or unavailable implementation
+- `dupe.Failed` with a stable failure code, safe message, and diagnostic cause for attempted work
+  that failed
+
+Use only the dependency snapshot supplied to the factory. Do not read unrelated global config.
+Bound response bodies, sanitize remote diagnostics, and normalize entries into `api.DupeEntry`.
+
+### 6. Add rules and banned groups
+
+Standalone profiles use the same typed capabilities as Unit3D:
+
+```go
+func rules() *trackers.RuleSet { ... }
+func bannedGroups() []string { ... }
+
+// profile.go
+Rules:             rules(),
+BannedGroups:      bannedGroups(),
+BannedGroupPolicy: &trackers.BannedGroupPolicy{...},
+```
+
+Keep implementations in `rules.go` and `banned_groups.go`. Add combined rule behavior to
+`internal/trackers/rules_test.go`; add tracker-package tests for protocol-specific parsing or
+mapping.
+
+### 7. Add optional capabilities
+
+Declare static capabilities directly in `standalone.Profile`:
+
+| Profile field             | Typical supporting file | Purpose                                      |
+| ------------------------- | ----------------------- | -------------------------------------------- |
+| `AuthCapability`          | `auth.go`               | Declares API-key, passkey, cookie, login/2FA |
+| `AuthResolver`            | `auth.go`               | Validates or refreshes remote auth           |
+| `AuthPolicy`              | `profile.go`            | Auth coordinator semantics                   |
+| `AuthStateManager`        | `auth.go`               | Cleans tracker-owned persisted auth state    |
+| `Rules`                   | `rules.go`              | Release eligibility                          |
+| `MetadataPolicy`          | `profile.go`            | Required canonical/provider metadata         |
+| `ArtifactPolicy`          | `profile.go`            | Torrent size and piece-size limits           |
+| `UploadArtifactPolicy`    | `profile.go`            | Source/announce personalization              |
+| `BannedGroups` / policy   | `banned_groups.go`      | Static or dynamic blacklists                 |
+| `DupePolicy`              | `dupe.go`               | Candidate comparison semantics               |
+| `AudioPolicy`             | `profile.go`            | Multi-language/bloat constraints             |
+| `ImageHostPolicy`         | `profile.go`            | Allowed/private image hosts                  |
+| `TorrentIdentityPolicy`   | `profile.go`            | Announce/comment identity and reuse behavior |
+| `LocalizedMetadataLocale` | `profile.go`            | Locale-specific tracker rendering            |
+| `DescriptionGroup`        | `profile.go`            | Saved description override group             |
+| `DataPolicy`              | `profile.go`            | Lookup cooldown/defer behavior                |
+| `ClaimPolicy`             | `profile.go`            | Active-claim orchestration                    |
+
+Implement only capabilities the tracker needs. If new behavior cannot be expressed by an existing
+typed capability, extend the shared profile/registry contract; do not
+teach generic coordinators the tracker name.
+
+Rare dynamic interfaces stay on a small local wrapper embedding `*standalone.Definition`. Use this
+only for `NewDataLookup`, `DataLookupConfigured`, or `NewClaimChecker`; do not create an empty local
+definition type for static capabilities.
+
+For auth:
+
+- API-key/passkey-only trackers should expose an `AuthCapability` with the corresponding
+  `Requires...` flag.
+- Cookie/login trackers should expose `AuthCapability` and `AuthSessionResolver`.
+- Use `AuthPolicy` only for coordinator semantics that cannot be inferred from the public
+  capability.
+- Store and clean any tracker-specific auth material through an `AuthStateManager`.
+
+### 8. Register and configure the tracker
+
+In `internal/trackers/impl/registry.go`:
+
+1. Import `internal/trackers/impl/standalone/example`.
+2. Add `example.New()` to `standaloneDefinitions()`.
+
+Add an ordered stanza to `internal/config/defaults/example.yaml`. It must contain at least one
+empty activation credential such as `api_key`, `announce_url`, `username`, `password`, or
+`passkey`, depending on the tracker's real setup requirements. Do not add `url`.
+
+The registry/config parity test fails when either side is missing. Existing config fields render
+through the generic frontend catalog. Follow the additional config-field steps from the Unit3D
+section when a new field is unavoidable.
+
+### 9. Standalone tests
+
+At minimum, cover:
+
+- definition name, endpoint, family, and registered capabilities
+- config/catalog parity
+- upload payload construction and response parsing
+- dry-run/live payload parity and absence of dry-run network submission
+- duplicate request construction, result normalization, not-run states, and failures
+- category/type/resolution mapping
+- rule and banned-group behavior
+- auth status/login/session behavior when implemented
+- bounded response handling and sanitized diagnostics
+- torrent artifact and image-host behavior when declared
+
+## Validation checklist
+
+Start narrow, then run the shared tracker checks because registry and config changes affect all
+trackers:
+
+```powershell
+go test -race -v -timeout 20m ./internal/trackers/impl/unit3d/... ./internal/trackers/impl ./internal/trackers ./internal/config
+```
+
+For a standalone tracker, replace the Unit3D package with its package:
+
+```powershell
+go test -race -v -timeout 20m ./internal/trackers/impl/standalone/example ./internal/trackers/impl ./internal/trackers ./internal/config
+```
+
+Then run the repo-required checks appropriate to the change:
+
+```powershell
+make fmt-go
+make gofix-check-changed
+make lint
+make logpolicy
+make backend
+git diff --check
+```
+
+Run `make test-go` when shared Unit3D behavior, tracker orchestration, auth, config persistence, or
+other broad contracts changed. When a new config field changes the WebUI surface, also run:
+
+```powershell
+pnpm --dir webui run lint
+pnpm --dir webui run lint:dead
+pnpm --dir webui run typecheck
+pnpm --dir webui run test:unit
+pnpm --dir webui run format:check
+```
+
+Do not commit generated frontend assets, local binaries, Playwright output, or populated
+`internal/webserver/assets`.
diff --git a/AGENTS.md b/AGENTS.md
index 16bd0a7c..428b89ff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -4,7 +4,7 @@ Always-loaded repo rules for AI coding agents. Keep this file short; nearest sco
 
 ## Source Of Truth
 
-- Tool config wins: `Makefile`, `lefthook.yml`, `.golangci.yml`, `gui/frontend/package.json`, `.github/workflows/*`.
+- Tool config wins: `Makefile`, `lefthook.yml`, `.golangci.yml`, `webui/package.json`, `.github/workflows/*`.
 - Contributor setup and command detail: `CONTRIBUTING.md`.
 - Guidance disagrees with tools? Follow tools and update stale prose.
 
@@ -13,8 +13,8 @@ Always-loaded repo rules for AI coding agents. Keep this file short; nearest sco
 - Backend, Go, path/log policy, trackers/config/domain rules, runtime architecture, lint/check policy: `internal/AGENTS.md`.
 - CLI flags/prompts/unattended behavior: `cmd/upbrr/AGENTS.md`.
 - Shared API/runtime contracts: `pkg/api/AGENTS.md`.
-- Frontend, React, CSS, TypeScript, browser checks: `gui/frontend/AGENTS.md`.
-- Playwright E2E harness, fake services, reports, manual workflow: `gui/frontend/e2e/AGENTS.md`.
+- Frontend, React, CSS, TypeScript, browser checks: `webui/AGENTS.md`.
+- Playwright E2E harness, fake services, reports, manual workflow: `webui/e2e/AGENTS.md`.
 
 Read the scoped file before editing that area. For simple grep/read-only questions, avoid loading extra instructions unless needed.
 
@@ -25,32 +25,36 @@ make help                # supported targets
 make backend             # fast CLI build sanity
 make test-go             # full Go race tests
 make test-frontend       # frontend lint/dead-code/type/unit/format
-make lint                # path policy + full Go lint
+make lint                # architecture/path/literal policies + full Go lint
 make precommit           # strong local validation before commit; no Go tests
 make prepush             # Lefthook pre-push wrapper
 git diff --check         # whitespace/conflict markers
 ```
 
-Start narrow; expand checks for shared behavior, release, GUI/web parity, or safety-sensitive changes. Do not substitute hook wrappers for the area-specific checks below.
+Start narrow; expand checks for shared behavior, release, WebUI/API parity, or safety-sensitive changes. Do not substitute hook wrappers for the area-specific checks below.
 
 ## Area Checks
 
 - Backend/Go: focused `go test -race -v -timeout 20m <packages>` for touched packages; `make test-go` when shared core behavior or broad regressions are plausible; `make lint`; `make logpolicy` for logging/internal changes; `make pathpolicy` for path-handling changes.
 - CLI: `go test -race -v -timeout 20m ./cmd/upbrr ./internal/core ./pkg/api`; add touched service/tracker packages; run `make backend` for command/build sanity.
-- GUI/web/API parity: `go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/guishared ./pkg/api`; add frontend `typecheck`/unit checks when request/response shapes or runtime bridge code changes.
-- Frontend: `pnpm --dir gui/frontend run lint`, `lint:dead`, `typecheck`, `test:unit`, `format:check`; add `lint:style` for CSS and `build` for bundle/runtime issues.
-- E2E/browser: read `gui/frontend/e2e/AGENTS.md`; use embedded web checks, not Vite-only checks, for parity-sensitive UI/runtime changes.
+- WebUI/API: `go test -race -v -timeout 20m ./internal/webserver/... ./pkg/api`; add frontend `typecheck`/unit checks when request/response shapes or browser client code changes.
+- Frontend: `pnpm --dir webui run lint`, `lint:dead`, `typecheck`, `test:unit`, `format:check`; add `lint:style` for CSS and `build` for bundle/runtime issues.
+- E2E/browser: read `webui/e2e/AGENTS.md`; use embedded web checks, not Vite-only checks, for runtime-sensitive UI changes.
 
-Before commit, also run `git diff --check`, changed-package `make gofix-check-changed`, and the relevant hook commands if desired. If Go files, generated dirs, or scratch paths can affect package discovery, run `make lint` before commit.
+Before commit, also run `git diff --check`, changed-package `make gofix-check-changed`, and the relevant hook commands if desired. `make fmt-go` applies the 160-column formatter and expands keyed composite literals with three or more elements. If Go files, generated dirs, or scratch paths can affect package discovery, run `make lint` before commit.
 
 ## Repo Map
 
-- CLI `cmd/upbrr`; core `internal/core`; services `internal/services`; trackers `internal/trackers`; config `internal/config`.
-- Wails `gui`, `internal/guiapp`; embedded web/API `internal/webserver`; API contracts `pkg/api`; frontend `gui/frontend`.
+- CLI `cmd/upbrr`; workflow orchestration `internal/core`; config `internal/config`; remaining domain services `internal/services`.
+- Canonical prepared generations/display `internal/preparedrelease`; external identity `internal/externalidentity`; source resources `internal/sourcelayout`; torrent-client discovery `internal/clientdiscovery`.
+- Tracker contracts/orchestration `internal/trackers`; implementation families `internal/trackers/impl/{unit3d,azfamily,standalone}`; standalone trackers `internal/trackers/impl/standalone/<tracker>`; Unit3D sites `internal/trackers/impl/unit3d/sites/<tracker>`.
+- Tracker auth/dupe/data coordinators `internal/trackers/{auth,dupe,data}`; generic BBCode/description/image hosting `internal/{bbcode,description,imagehosting}`.
+- Paths `internal/pathing` with `layout` and checker-only `policy`; torrent clients `internal/torrentclient`; metainfo `internal/torrent/metainfo`; release policy `internal/releasepolicy`.
+- WebUI server/API and retained jobs `internal/webserver`; API contracts `pkg/api`; frontend release ownership `webui/src/releaseSession`; shared job coordination `webui/src/jobRegistry`.
 
 ## Logging Levels
 
-- Keep log levels purposeful across CLI, GUI, embedded web, frontend, tests, and tooling.
+- Keep log levels purposeful across CLI, WebUI, tests, and tooling.
 - Add logs for operator-visible progress and decision points, not just final errors. Good logs answer what operation started, what external/local check ran, what decision was made, and how many items were affected.
 - `INFO` should provide concise, relevant progress or outcome details for end users during uploads and other top-level workflows.
 - Warnings should cover failed or blocked outcomes that require attention.
@@ -61,9 +65,9 @@ Before commit, also run `git diff --check`, changed-package `make gofix-check-ch
 ## Non-Negotiables
 
 - Keep changes narrow; fix root cause; do not revert user changes.
-- Preserve CLI, Wails GUI, and embedded web parity.
+- Preserve CLI and WebUI behavior where they share workflows.
 - Preserve CLI `--unattended` / `--unattended_confirm` (`--uac`) safety: `--unattended` must not prompt; `--unattended_confirm` may ask required confirmation/manual inputs. No hidden prompts/confirms or ambiguous fallthrough.
 - Never log credentials/tokens/API keys/cookies/secret payloads; use repo redaction/logging policy.
 - Shareable examples, diagnostics, docs, and test fixtures must not use real release names, real movie/show titles, or real provider IDs. Use synthetic placeholders such as `Example Release 2026`, `Example.Release.2026.1080p-GRP`, and `tt1234567`. Prefer generic group tags such as `GRP` when the group is incidental; real group names are allowed when relevant to behavior. Production domain lists such as tracker banned groups may keep real values when those values are required behavior.
-- Do not commit generated/local output: `dist/`, `gui/frontend/dist/`, `gui/build/bin/`, populated `internal/guiapp/assets`, Playwright reports/results, repo-local `tmp/`.
+- Do not commit generated/local output: `dist/`, `webui/dist/`, populated `internal/webserver/assets`, Playwright reports/results, repo-local `tmp/`.
 - `.github/workflows/*.yml` files are active; `.yml22` files are disabled templates.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index dc50ca96..fa113de7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -21,15 +21,11 @@ Install the following on your machine:
 
 - [Git](https://git-scm.com/)
 - [Go](https://golang.org/dl/) — see [go.mod](./go.mod) for the required version
-- [Node.js](https://nodejs.org) (20 LTS or newer)
-- [pnpm](https://pnpm.io/installation) (10 or newer — version is pinned in `gui/frontend/package.json` via `packageManager`)
+- [Node.js](https://nodejs.org) (`^20.19.0`, `^22.13.0`, or `>=24`)
+- [pnpm](https://pnpm.io/installation) (10 or newer — version is pinned in `webui/package.json` via `packageManager`)
 - [GNU Make](https://www.gnu.org/software/make/) — top-level shortcuts for builds, checks, formatting, and hooks
 - [golangci-lint](https://golangci-lint.run/) — used by hooks and CI
 - [Lefthook](https://github.com/evilmartians/lefthook) — git hooks runner (see [Git hooks](#git-hooks-lefthook))
-- [Wails CLI](https://wails.io/) `v2.12.0` for desktop builds
-  - Build scripts invoke `go run github.com/wailsapp/wails/v2/cmd/wails@v2.12.0`
-
-On Linux, Wails builds also need GTK/WebKit development packages. The full list is in [`.github/workflows/build-binaries.yml`](./.github/workflows/build-binaries.yml) — key packages are `build-essential`, `libgtk-3-dev`, `libwebkit2gtk-4.1-dev`, `libglib2.0-dev`, and `pkg-config`. Builds using WebKitGTK 4.1 must pass the Go build tag `webkit2_41`.
 
 ### Supported platforms
 
@@ -50,7 +46,7 @@ Notes:
 - **Fork and clone:** [Fork the upbrr repository](https://github.com/autobrr/upbrr/fork) and clone it to start working on your changes.
 - **Branching:** Create a descriptively named branch.
   - Example: `git checkout -b fix/bt-dupe-check` or `git checkout -b feat/playlist-selection`
-- **Coding:** Keep changes narrow and match the surrounding style. For Go, follow the rules in [`AGENTS.md`](./AGENTS.md) and let `golangci-lint` drive. For frontend work, also see [`gui/frontend/AGENTS.md`](./gui/frontend/AGENTS.md) and let the Lefthook Prettier + ESLint hooks do the work.
+- **Coding:** Keep changes narrow and match the surrounding style. For Go, follow the rules in [`AGENTS.md`](./AGENTS.md) and let `golangci-lint` drive. For frontend work, also see [`webui/AGENTS.md`](./webui/AGENTS.md) and let the Lefthook Prettier + ESLint hooks do the work.
 - **Commit messages:** We enforce [Conventional Commits](https://www.conventionalcommits.org/) via a repo-local validator. See [Commit message format](#commit-message-format) below.
   - No need to force-push or rebase — we squash on merge.
 - **Pull requests:** Submit a PR with a clear description. Mark it _Draft_ if still in progress. Reference related issues.
@@ -66,15 +62,15 @@ go install github.com/evilmartians/lefthook/v2@v2.1.0
 lefthook install
 
 # Frontend / full-stack contributors:
-# `pnpm install` in gui/frontend/ brings in the Prettier + ESLint deps the hooks call.
-cd gui/frontend && pnpm install && cd ../..
+# `pnpm install` in webui/ brings in the Prettier + ESLint deps the hooks call.
+pnpm --dir webui install
 lefthook install
 ```
 
 What runs when Git invokes hooks:
 
-- `pre-commit` — on **staged files only**: `prettier --write` (gui/frontend), `eslint` (gui/frontend/src), `golangci-lint fmt` (Go), `go run ./cmd/logpolicy` (when `internal/**` Go files change), and `go run ./cmd/pathpolicy` (when Go files change). Formatters auto-re-stage their fixes.
-- `pre-push` — full-project TypeScript typecheck and `make lint`, which runs the path-portability checker before golangci-lint. CI mirrors the Go test/pathpolicy OS matrix and frontend checks for pull requests.
+- `pre-commit` — on **staged files only**: `prettier --write` (webui), `eslint` (webui/src), `golangci-lint fmt` (Go), the composite-literal layout policy, `go run ./cmd/logpolicy` (when `internal/**` Go files change), and `go run ./cmd/pathpolicy` (when Go files change). Formatters auto-re-stage their fixes.
+- `pre-push` — full-project TypeScript typecheck and `make lint`, which runs the architecture ownership, path-portability, and composite-literal layout checkers before golangci-lint. CI mirrors these Go policy checks and frontend checks for pull requests.
 - `commit-msg` — `go run ./cmd/commitmsgcheck` enforces [Conventional Commits](https://www.conventionalcommits.org/) without requiring Node.js or `pnpm install`.
 
 Makefile shortcuts:
@@ -103,7 +99,7 @@ Use [Conventional Commits](https://www.conventionalcommits.org/):
 ```
 
 - **Allowed types:** `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`.
-- **Scope** is optional (e.g. `config`, `ci`, `gui`, `cli`, or a tracker acronym like `bt`, `asc`).
+- **Scope** is optional (e.g. `config`, `ci`, `webui`, `cli`, or a tracker acronym like `bt`, `asc`).
 - **Subject** is imperative, lower-case, no trailing period, **115 characters max** (derived from history + 30% headroom).
 - **Breaking change:** append `!` after type/scope (`feat!: drop Go 1.19`) or add a `BREAKING CHANGE:` footer.
 
@@ -128,19 +124,19 @@ git clone https://github.com/<your-user>/upbrr && cd upbrr
 ### Frontend
 
 ```sh
-pnpm --dir gui/frontend install --frozen-lockfile
+pnpm --dir webui install --frozen-lockfile
 make dev-frontend      # Vite dev server
-pnpm --dir gui/frontend run lint
-pnpm --dir gui/frontend run lint:dead
-pnpm --dir gui/frontend run typecheck
-pnpm --dir gui/frontend run test:unit
-pnpm --dir gui/frontend run format:check
+pnpm --dir webui run lint
+pnpm --dir webui run lint:dead
+pnpm --dir webui run typecheck
+pnpm --dir webui run test:unit
+pnpm --dir webui run format:check
 
 # CSS changes:
-pnpm --dir gui/frontend run lint:style
+pnpm --dir webui run lint:style
 
 # Bundle/runtime changes:
-pnpm --dir gui/frontend run build
+pnpm --dir webui run build
 ```
 
 For embedded web visual checks, test the embedded build rather than the Vite-only server. Rebuild the frontend, sync it into embedded assets, rebuild the CLI, then run the auth-disabled embedded server on the main port:
@@ -166,21 +162,17 @@ go run ./cmd/upbrr serve
 # Run the embedded web server without web auth for local frontend development:
 go run ./cmd/upbrr serve --dev-no-auth
 
-# Launch the Wails desktop GUI:
-go run ./cmd/upbrr --gui
-# or the dedicated GUI entrypoint:
-go run ./gui
 ```
 
 ### Build
 
-Full build (CLI + Wails GUI + embedded frontend):
+Full build (CLI with embedded WebUI):
 
 ```sh
 make build
 ```
 
-`make build` runs the platform build script, installs frontend deps, builds the React frontend, syncs it into `internal/guiapp/assets`, then builds the CLI into `dist/` and the Wails GUI into `gui/build/bin/`.
+`make build` runs the platform build script, installs frontend deps, builds the React frontend, syncs it into `internal/webserver/assets`, then builds `dist/upbrr[.exe]`.
 
 Individual pieces:
 
@@ -188,7 +180,6 @@ Individual pieces:
 make backend          # CLI only
 make frontend         # Typecheck + frontend bundle
 make frontend-bundle  # Vite bundle only
-make gui              # Wails GUI with current embedded assets
 ```
 
 ## Tests and checks
@@ -203,18 +194,18 @@ go test -race -v -timeout 20m <package>
 go test -race -v -timeout 20m ./cmd/upbrr ./internal/core ./pkg/api
 make backend
 
-# Wails/web/API parity:
-go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/guishared ./pkg/api
+# WebUI/API contracts:
+go test -race -v -timeout 20m ./internal/webserver/... ./pkg/api
 
 # Frontend TS/TSX:
-pnpm --dir gui/frontend run lint
-pnpm --dir gui/frontend run lint:dead
-pnpm --dir gui/frontend run typecheck
-pnpm --dir gui/frontend run test:unit
-pnpm --dir gui/frontend run format:check
+pnpm --dir webui run lint
+pnpm --dir webui run lint:dead
+pnpm --dir webui run typecheck
+pnpm --dir webui run test:unit
+pnpm --dir webui run format:check
 
 # CSS:
-pnpm --dir gui/frontend run lint:style
+pnpm --dir webui run lint:style
 
 # Broad Go regression, lint, and policy sweeps:
 make test-go
@@ -229,19 +220,26 @@ Useful focused checks:
 go test -race -v -timeout 20m <package>
 make gofix-check-changed
 make gofix-changed
-pnpm --dir gui/frontend run lint:style
+pnpm --dir webui run lint:style
 ```
 
 Alternatively, `make precommit` and `make prepush` run the configured Lefthook checks.
-`make precommit` also runs stronger local validation: whitespace/conflict-marker checks, changed-package Go fix drift, full Go lint/path policy, log policy, and frontend lint/dead-code/type/unit/format checks. Hook wrappers do not replace focused Go tests, CSS Stylelint, embedded parity checks, or E2E checks when those areas changed.
+`make precommit` also runs stronger local validation: whitespace/conflict-marker checks, changed-package Go fix drift, full Go lint plus architecture/path/literal policies, log policy, and frontend lint/dead-code/type/unit/format checks. Hook wrappers do not replace focused Go tests, CSS Stylelint, embedded parity checks, or E2E checks when those areas changed.
 
 ## Project conventions
 
-- The frontend build output is embedded into the Go app from `internal/guiapp/assets`.
-- The GUI, CLI, and embedded web server share the same core services and config model under `internal/`.
-- Tracker-specific code lives primarily under `internal/trackers/impl`. Shared tracker behaviour goes in `internal/trackers`, not in the impls.
+- The frontend build output is embedded into the Go app from `internal/webserver/assets`.
+- The CLI and embedded WebUI share the same core services and config model under `internal/`.
+- Canonical prepared generations and display projections live under `internal/preparedrelease`; external identity, source-resource resolution, and torrent-client discovery live under `internal/externalidentity`, `internal/sourcelayout`, and `internal/clientdiscovery`.
+- WebUI runtime activation and retained background jobs live under `internal/webserver`; frontend release state and shared Job coordination live under `webui/src/releaseSession` and `webui/src/jobRegistry`.
+- Tracker implementations follow registry families: Unit3D protocol behavior and sites live under `internal/trackers/impl/unit3d`, AvistaZ-family behavior under `internal/trackers/impl/azfamily`, and every other tracker in its own `internal/trackers/impl/standalone/<tracker>` package.
+- The family-grouped supported manifest lives only in `internal/trackers/impl/registry.go`. Site profiles/definitions own default endpoints and policy; `internal/config/defaults/example.yaml` owns ordered credential/config fields and contains no tracker URL. A standard Unit3D addition should need only its site profile/rules, one manifest entry, one example-config stanza, and combined rule tests.
+- Standalone packages compose identity, preparation callbacks, duplicate factories, auth descriptors, and static policy in `profile.go`. Shared `standalone.Definition` supplies registry capabilities; only dynamic data/claim factories need a small local wrapper. Upload preparation captures one immutable operation used by preview and submission.
+- Shared tracker contracts and registry-driven orchestration live under `internal/trackers`; generic auth, dupe, and tracker-data coordinators are in its `auth`, `dupe`, and `data` subpackages.
+- Generic release/path/torrent-client infrastructure lives under `internal/releasepolicy`, `internal/pathing`, and `internal/torrentclient`. Torrent metainfo helpers live under `internal/torrent/metainfo`.
+- Generic BBCode, description, and image-hosting infrastructure lives under `internal/bbcode`, `internal/description`, and `internal/imagehosting`; tracker-specific policy stays with its tracker implementation.
 - `pkg/api` holds request/response types shared across surfaces.
-- The repo currently includes generated and built assets in a few locations; review changes carefully and avoid committing build output by accident.
+- Generated frontend bundles, populated embedded assets, Playwright output, and local binaries are ignored local artifacts. Do not commit them.
 
 ### Shareable fixtures and examples
 
@@ -281,22 +279,22 @@ upbrr targets Windows, Linux, and macOS. Do not assume POSIX path behavior in Go
 - Use `path` only for slash-delimited data formats, such as torrent-internal file names, URLs, or API payloads defined to use `/`.
 - At boundaries between torrent/API paths and local filesystem paths, normalize deliberately: validate slash paths first, then convert with `filepath.FromSlash`.
 - Security/path traversal checks must reject both POSIX and Windows absolute or escaping forms on every OS: leading `/`, leading `\`, drive-letter paths, UNC paths, and `..` segments.
-- Use `internal/pathutil.IsWithinRoot` and `internal/pathutil.SamePath` for local root containment and path equality. Do not add ad-hoc `filepath.Rel` plus string-prefix guards; `pathpolicy` rejects those helper names outside `internal/pathutil`.
+- Use `internal/pathing.IsWithinRoot` and `internal/pathing.SamePath` for local root containment and path equality. Do not add ad-hoc `filepath.Rel` plus string-prefix guards; `pathpolicy` rejects those helper names outside `internal/pathing`.
 - Tests should not assert raw `"/foo/"` substrings against local filesystem paths. Use `filepath.ToSlash(path)` for cross-platform assertions, or build expected paths with `filepath.Join`.
 - Tests should not pass hardcoded OS-rooted literals such as `C:\...`, `\\server\share`, or `/tmp/...` into `filepath` calls. Use `t.TempDir` or existing path variables.
 - Do not build local filesystem paths with string concatenation, `fmt.Sprintf`, or `strings.Join(..., "/")`. Use `filepath.Join`.
 - Use `path.Base`, `path.Ext`, and related `path` APIs for URL/API paths. Use `filepath.Base`, `filepath.Ext`, and related `filepath` APIs for local paths. Legit stdlib `path` imports need import-local `//nolint:depguard // <slash-data reason>`.
 
-`make pathpolicy` runs the repo-local AST checker for hardcoded OS-rooted literals in `filepath` calls, string-built local paths, wrong `path`/`filepath` package use, slash-data filesystem calls, slash assertions without `filepath.ToSlash`, and ad-hoc local path guard helpers outside `internal/pathutil`. Rare intentional checker exceptions need `//pathpolicy:allow <reason>` on the same or previous line. `make lint`, pre-commit, and pre-push run it automatically.
+`make pathpolicy` runs the repo-local AST checker for hardcoded OS-rooted literals in `filepath` calls, string-built local paths, wrong `path`/`filepath` package use, slash-data filesystem calls, slash assertions without `filepath.ToSlash`, and ad-hoc local path guard helpers outside `internal/pathing`. Rare intentional checker exceptions need `//pathpolicy:allow <reason>` on the same or previous line. `make lint`, pre-commit, and pre-push run it automatically.
 
 ## AI agent instructions
 
 This project uses [AGENTS.md](https://agents.md/) — an open standard for guiding AI coding agents. The root [`AGENTS.md`](./AGENTS.md) file contains always-loaded repo rules and routes agents to scoped references:
 
-- [`gui/frontend/AGENTS.md`](./gui/frontend/AGENTS.md) for frontend, React, CSS, TypeScript, and browser checks.
+- [`webui/AGENTS.md`](./webui/AGENTS.md) for frontend, React, CSS, TypeScript, and browser checks.
 - [`internal/AGENTS.md`](./internal/AGENTS.md) for Go, path/log policy, trackers/config/domain rules, runtime architecture, lint/check policy, and generated/scratch path risks.
 - [`cmd/upbrr/AGENTS.md`](./cmd/upbrr/AGENTS.md) for CLI flags, prompts, and unattended behavior.
 - [`pkg/api/AGENTS.md`](./pkg/api/AGENTS.md) for cross-entrypoint API/runtime contracts.
-- [`gui/frontend/e2e/AGENTS.md`](./gui/frontend/e2e/AGENTS.md) for Playwright E2E harness rules and commands.
+- [`webui/e2e/AGENTS.md`](./webui/e2e/AGENTS.md) for Playwright E2E harness rules and commands.
 
 Most modern AI coding tools support `AGENTS.md` natively or via simple configuration. `CLAUDE.md` files are symlinks to the same guidance for Claude Code.
diff --git a/Dockerfile b/Dockerfile
index 7b1a71e2..6ad36c9a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,12 +8,12 @@ ARG GO_VERSION=1.26.5
 
 FROM --platform=$BUILDPLATFORM node:20-alpine AS frontend
 
-WORKDIR /src/gui/frontend
+WORKDIR /src/webui
 
-COPY gui/frontend/package.json gui/frontend/pnpm-lock.yaml ./
+COPY webui/package.json webui/pnpm-lock.yaml ./
 RUN corepack enable && pnpm install --frozen-lockfile
 
-COPY gui/frontend/ ./
+COPY webui/ ./
 RUN pnpm run build:bundle
 
 FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS cli-builder
@@ -27,8 +27,8 @@ RUN --mount=type=cache,target=/go/pkg/mod \
 COPY . .
 
 # Embed the built web UI so `upbrr serve` can serve it. Mirrors
-# scripts/sync-frontend-assets.ps1 used by the binary release workflow.
-COPY --from=frontend /src/gui/frontend/dist/ ./internal/guiapp/assets/
+# scripts/sync-webui-assets.ps1 used by the binary release workflow.
+COPY --from=frontend /src/webui/dist/ ./internal/webserver/assets/
 
 ARG TARGETOS
 ARG TARGETARCH
diff --git a/Makefile b/Makefile
index 60459556..859121b2 100644
--- a/Makefile
+++ b/Makefile
@@ -1,39 +1,32 @@
-.PHONY: help build backend frontend frontend-bundle gui dev dev-frontend test test-go test-frontend e2e e2e-build e2e-web e2e-cli e2e-wails lint lint-json logpolicy pathpolicy precommit prepush fmt fmt-go fmt-frontend gofix gofix-check gofix-changed gofix-check-changed commitmsg-check clean
+.PHONY: help build backend frontend frontend-bundle dev dev-frontend test test-go test-frontend e2e e2e-build e2e-web e2e-cli lint lint-json logpolicy pathpolicy literalpolicy architecturepolicy literalpolicy-fix precommit prepush fmt fmt-go fmt-frontend gofix gofix-check gofix-changed gofix-check-changed commitmsg-check clean
 
 ifeq ($(OS),Windows_NT)
 EXE := .exe
 FULL_BUILD := powershell -NoProfile -ExecutionPolicy Bypass -File ./scripts/build.ps1
 MKDIR_DIST := powershell -NoProfile -Command "New-Item -ItemType Directory -Force -Path dist | Out-Null"
-RM_DIST := powershell -NoProfile -Command "Remove-Item -Recurse -Force dist, gui/frontend/dist, gui/build/bin -ErrorAction SilentlyContinue"
-WAILS_PLATFORM := windows/amd64
+RM_DIST := powershell -NoProfile -Command "Remove-Item -Recurse -Force dist, webui/dist -ErrorAction SilentlyContinue"
 BLANK := echo.
 else
 EXE :=
 FULL_BUILD := ./scripts/build.sh
 MKDIR_DIST := mkdir -p dist
-RM_DIST := rm -rf dist gui/frontend/dist gui/build/bin
-WAILS_PLATFORM :=
+RM_DIST := rm -rf dist webui/dist
 BLANK := echo
 endif
 
 CLI_OUT := dist/upbrr$(EXE)
 E2E_CLI_OUT := dist/upbrr-e2e$(EXE)
-WAILS_CLI := go run github.com/wailsapp/wails/v2/cmd/wails@v2.12.0
 GO_TEST_FLAGS := -race -v -timeout 20m
 GOLANGCI_FLAGS := --timeout=5m
-GO_CHANGED_FILES := $(shell git diff --name-only --diff-filter=ACMR HEAD -- '*.go')
-GO_CHANGED_PKGS := $(addprefix ./,$(sort $(patsubst %/,%,$(dir $(GO_CHANGED_FILES)))))
-
 help:
 	@echo Build
-	@echo   make build              Full build: frontend, embedded assets, CLI, Wails GUI
+	@echo   make build              Full build: WebUI, embedded assets, CLI
 	@echo   make backend            Build CLI binary only
 	@echo   make frontend           Typecheck and build frontend bundle
 	@echo   make frontend-bundle    Build frontend bundle only
-	@echo   make gui                Build Wails GUI with current embedded assets
 	@$(BLANK)
 	@echo Development
-	@echo   make dev                Start Wails dev mode
+	@echo   make dev                Start WebUI server without auth on loopback
 	@echo   make dev-frontend       Start Vite dev server only
 	@$(BLANK)
 	@echo Testing
@@ -43,10 +36,10 @@ help:
 	@echo   make e2e                Run all Playwright E2E projects
 	@echo   make e2e-web            Run embedded web E2E projects
 	@echo   make e2e-cli            Run CLI full-upload E2E project
-	@echo   make e2e-wails          Run Wails/backend parity E2E project
 	@$(BLANK)
 	@echo Linting
-	@echo   make lint               Run path policy and full Go lint
+	@echo   make lint               Run architecture/path/literal policies and full Go lint
+	@echo   make architecturepolicy Run architecture ownership policy check
 	@echo   make lint-json          Write Go lint JSON to lint-report.json
 	@echo   make logpolicy          Run logging policy check
 	@echo   make pathpolicy         Run path portability policy check
@@ -72,23 +65,16 @@ backend:
 	go build -o $(CLI_OUT) ./cmd/upbrr
 
 frontend:
-	pnpm --dir gui/frontend run build
+	pnpm --dir webui run build
 
 frontend-bundle:
-	pnpm --dir gui/frontend run build:bundle
-
-gui:
-ifeq ($(WAILS_PLATFORM),)
-	cd gui && $(WAILS_CLI) build
-else
-	cd gui && $(WAILS_CLI) build -platform $(WAILS_PLATFORM)
-endif
+	pnpm --dir webui run build:bundle
 
 dev:
-	cd gui && $(WAILS_CLI) dev
+	go run ./cmd/upbrr serve --dev-no-auth
 
 dev-frontend:
-	pnpm --dir gui/frontend run dev
+	pnpm --dir webui run dev
 
 test: test-go test-frontend
 
@@ -96,37 +82,33 @@ test-go:
 	go test $(GO_TEST_FLAGS) ./...
 
 test-frontend:
-	pnpm --dir gui/frontend run lint
-	pnpm --dir gui/frontend run lint:dead
-	pnpm --dir gui/frontend run typecheck
-	pnpm --dir gui/frontend run test:unit
-	pnpm --dir gui/frontend run format:check
+	pnpm --dir webui run lint
+	pnpm --dir webui run lint:dead
+	pnpm --dir webui run typecheck
+	pnpm --dir webui run test:unit
+	pnpm --dir webui run format:check
 
 e2e: e2e-build
-	pnpm --dir gui/frontend run test:e2e:full
+	pnpm --dir webui run test:e2e:full
 
 e2e-build:
-	pnpm --dir gui/frontend install --frozen-lockfile
-	pnpm --dir gui/frontend run build
+	pnpm --dir webui install --frozen-lockfile
+	pnpm --dir webui run build
 ifeq ($(OS),Windows_NT)
-	pwsh -NoProfile -File ./scripts/sync-frontend-assets.ps1
+	pwsh -NoProfile -File ./scripts/sync-webui-assets.ps1
 else
-	sh ./scripts/sync-frontend-assets.sh
+	sh ./scripts/sync-webui-assets.sh
 endif
 	$(MKDIR_DIST)
 	go build -tags e2e -o $(E2E_CLI_OUT) ./cmd/upbrr
 
 e2e-web: e2e-build
-	pnpm --dir gui/frontend run test:e2e:web
+	pnpm --dir webui run test:e2e:web
 
 e2e-cli: e2e-build
-	pnpm --dir gui/frontend exec playwright test --project=cli-full-upload
+	pnpm --dir webui exec playwright test --project=cli-full-upload
 
-e2e-wails:
-	pnpm --dir gui/frontend install --frozen-lockfile
-	pnpm --dir gui/frontend exec playwright test --project=wails-basic
-
-lint: pathpolicy
+lint: architecturepolicy pathpolicy literalpolicy
 	golangci-lint run $(GOLANGCI_FLAGS) ./...
 
 lint-json:
@@ -138,6 +120,16 @@ logpolicy:
 pathpolicy:
 	go run ./cmd/pathpolicy
 
+literalpolicy:
+	go run ./cmd/literalpolicy
+
+architecturepolicy:
+	go run ./cmd/architecturepolicy
+
+literalpolicy-fix:
+	go run ./cmd/literalpolicy -fix
+	golangci-lint fmt
+
 precommit:
 	lefthook run pre-commit
 	git diff --check
@@ -152,10 +144,11 @@ prepush:
 fmt: fmt-go fmt-frontend
 
 fmt-go:
+	go run ./cmd/literalpolicy -fix
 	golangci-lint fmt
 
 fmt-frontend:
-	pnpm --dir gui/frontend run format
+	pnpm --dir webui run format
 
 gofix:
 	go fix -omitzero=false ./...
@@ -164,18 +157,10 @@ gofix-check:
 	go fix -diff -omitzero=false ./...
 
 gofix-changed:
-ifeq ($(strip $(GO_CHANGED_PKGS)),)
-	@echo No changed Go files
-else
-	go fix -omitzero=false $(GO_CHANGED_PKGS)
-endif
+	go run ./cmd/gofixchanged -write
 
 gofix-check-changed:
-ifeq ($(strip $(GO_CHANGED_PKGS)),)
-	@echo No changed Go files
-else
-	go fix -diff -omitzero=false $(GO_CHANGED_PKGS)
-endif
+	go run ./cmd/gofixchanged
 
 commitmsg-check:
 	go run ./cmd/commitmsgcheck $(MSG)
diff --git a/README.md b/README.md
index 8c22844e..c4262b83 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ Have these ready:
       brew install ffmpeg
       ```
 
-      The CLI can find ffmpeg when your shell PATH includes Homebrew. If you start the GUI from Finder, macOS may not pass your shell PATH to the app, so the GUI may not see Homebrew's ffmpeg. Start the GUI from Terminal, or make ffmpeg available in the environment used to launch the app.
+      The CLI and WebUI server can find ffmpeg when their process environment includes Homebrew's bin directory.
     - Automatic DVD menu screenshots need an FFmpeg build whose `dvdvideo` demuxer exposes `menu`, `menu_lu`, `menu_vts`, `pgc`, and `pg`. A version number alone does not prove this capability. upbrr checks the selected FFmpeg at runtime; see [FFmpeg's dvdvideo documentation](https://ffmpeg.org/ffmpeg-formats.html#dvdvideo).
 
 - A TMDB API key is optional, but required for most trackers in upbrr.
@@ -82,7 +82,7 @@ The importer accepts:
 
 Read all warnings printed during import. Unknown legacy keys, unsupported tracker fields, or unsupported image-host settings may be skipped or adjusted.
 
-You can also import config files from the Settings page in the GUI or web UI.
+You can also import config files from the WebUI Settings page.
 
 ### Web UI Browse Access
 
@@ -120,12 +120,6 @@ Restart upbrr after copying cookies, then verify tracker login/session status be
 
 ## Running upbrr
 
-Desktop GUI:
-
-```powershell
-.\upbrr-gui.exe
-```
-
 Web UI:
 
 ```powershell
@@ -230,11 +224,11 @@ Useful CLI checks:
 
 ```powershell
 .\upbrr.exe --site-check --trackers BLU,OE "D:\releases\Some.Release"
-.\upbrr.exe --dry-run --trackers PTP,HDB "D:\releases\Some.Release"
+.\upbrr.exe --debug --trackers PTP,HDB "D:\releases\Example.Release.2026"
 .\upbrr.exe --queue "D:\upload-queue" --limit-queue 5
 ```
 
-NOTE: with cli `--debug` works as expected. Additionally, the printed feedback (even with debug) can be adjusted with `--log-level`. See `upbrr.exe --help`
+CLI `--debug` builds and prints the same non-submitting tracker payload preview as the WebUI dry run. It never submits to trackers. `--log-level debug` changes log verbosity only and does not select debug/dry-run behavior. See `upbrr.exe --help`.
 
 ### Automatic DVD Menu Screenshots
 
@@ -246,7 +240,7 @@ CLI example:
 .\upbrr.exe --get-dvd-menus "D:\releases\Example.Release.2026.DVD-GRP"
 ```
 
-In the GUI or web UI, fetch DVD metadata, then open **Disc Menus** and start automatic capture. Manual Disc Menu image import remains available for DVD, BDMV, and HDDVD sources. `screenshot_handling.max_menu_items` controls the maximum stored automatic menu images; the default is `6` and the supported range is `1` to `32`.
+In the WebUI, fetch DVD metadata, then open **Disc Menus** and start automatic capture. Manual Disc Menu image import remains available for DVD, BDMV, and HDDVD sources. `screenshot_handling.max_menu_items` controls the maximum stored automatic menu images; the default is `6` and the supported range is `1` to `32`.
 
 The FFmpeg capability check must find the `dvdvideo` demuxer and all required menu-coordinate options. If it does not, capture stops with an explicit capability error instead of sampling menu VOB files. Application Details shows the embedded Go DVD engine version, FFmpeg version, and menu-capability status without exposing local executable paths.
 
diff --git a/cmd/architecturepolicy/main.go b/cmd/architecturepolicy/main.go
new file mode 100644
index 00000000..6ebc71de
--- /dev/null
+++ b/cmd/architecturepolicy/main.go
@@ -0,0 +1,42 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/autobrr/upbrr/internal/architecturepolicy"
+)
+
+func main() {
+	os.Exit(run(os.Stdout, os.Stderr, os.Getwd, architecturepolicy.CheckRepository))
+}
+
+func run(
+	stdout io.Writer,
+	stderr io.Writer,
+	getwd func() (string, error),
+	check func(string) ([]architecturepolicy.Violation, error),
+) int {
+	root, err := getwd()
+	if err != nil {
+		fmt.Fprintf(stderr, "architecturepolicy: determine working directory: %v\n", err)
+		return 1
+	}
+	violations, err := check(root)
+	if err != nil {
+		fmt.Fprintf(stderr, "architecturepolicy: %v\n", err)
+		return 1
+	}
+	if len(violations) == 0 {
+		fmt.Fprintln(stdout, "architecturepolicy: no issues found")
+		return 0
+	}
+	for _, violation := range violations {
+		fmt.Fprintf(stderr, "%s:%d:%d: %s\n", violation.File, violation.Line, violation.Column, violation.Message)
+	}
+	return 1
+}
diff --git a/cmd/gofixchanged/main.go b/cmd/gofixchanged/main.go
new file mode 100644
index 00000000..a3d983ee
--- /dev/null
+++ b/cmd/gofixchanged/main.go
@@ -0,0 +1,224 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+)
+
+var errFixDrift = errors.New("changed Go files need go fix")
+
+func main() {
+	write := flag.Bool("write", false, "apply fixes to changed Go files")
+	flag.Parse()
+
+	if err := run(context.Background(), *write, os.Stdout); err != nil {
+		if !errors.Is(err, errFixDrift) {
+			fmt.Fprintln(os.Stderr, err)
+		}
+		os.Exit(1)
+	}
+}
+
+func run(ctx context.Context, write bool, stdout io.Writer) error {
+	root, err := gitOutput(ctx, "rev-parse", "--show-toplevel")
+	if err != nil {
+		return err
+	}
+	root = strings.TrimSpace(root)
+
+	changed, err := changedGoFiles(ctx, root)
+	if err != nil {
+		return err
+	}
+	if len(changed) == 0 {
+		_, err = fmt.Fprintln(stdout, "No changed Go files")
+		if err != nil {
+			return fmt.Errorf("print no-changes result: %w", err)
+		}
+		return nil
+	}
+
+	diff, fixErr := goFixDiff(ctx, root, changedPackages(root, changed))
+	filtered, err := filterDiff(diff, root, changed)
+	if err != nil {
+		return err
+	}
+	if len(filtered) == 0 {
+		if fixErr != nil && !errors.Is(fixErr, errFixDrift) {
+			return fixErr
+		}
+		return nil
+	}
+	if fixErr != nil && !errors.Is(fixErr, errFixDrift) {
+		return fixErr
+	}
+
+	if write {
+		return applyPatch(ctx, root, filtered)
+	}
+	if _, err := stdout.Write(filtered); err != nil {
+		return fmt.Errorf("print go fix diff: %w", err)
+	}
+	return errFixDrift
+}
+
+func gitOutput(ctx context.Context, args ...string) (string, error) {
+	cmd := exec.CommandContext(ctx, "git", args...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("git %s: %w: %s", strings.Join(args, " "), err, strings.TrimSpace(string(output)))
+	}
+	return string(output), nil
+}
+
+func changedGoFiles(ctx context.Context, root string) ([]string, error) {
+	tracked, err := gitFileList(ctx, root, "diff", "--name-only", "-z", "--diff-filter=ACMR", "HEAD", "--", "*.go")
+	if err != nil {
+		return nil, fmt.Errorf("list modified Go files: %w", err)
+	}
+	untracked, err := gitFileList(ctx, root, "ls-files", "--others", "--exclude-standard", "-z", "--", "*.go")
+	if err != nil {
+		return nil, fmt.Errorf("list untracked Go files: %w", err)
+	}
+	return append(tracked, untracked...), nil
+}
+
+func gitFileList(ctx context.Context, root string, args ...string) ([]string, error) {
+	cmdArgs := append([]string{"-C", root}, args...)
+	cmd := exec.CommandContext(ctx, "git", cmdArgs...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("git %s: %w: %s", strings.Join(args, " "), err, strings.TrimSpace(string(output)))
+	}
+	parts := bytes.Split(output, []byte{0})
+	files := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if len(part) > 0 {
+			files = append(files, filepath.ToSlash(string(part)))
+		}
+	}
+	return files, nil
+}
+
+func changedPackages(root string, files []string) []string {
+	seen := make(map[string]struct{}, len(files))
+	for _, file := range files {
+		dir := filepath.Dir(filepath.FromSlash(file))
+		seen[filepath.Join(root, dir)] = struct{}{}
+	}
+
+	packages := make([]string, 0, len(seen))
+	for pkg := range seen {
+		packages = append(packages, pkg)
+	}
+	sort.Strings(packages)
+	return packages
+}
+
+func goFixDiff(ctx context.Context, root string, packages []string) ([]byte, error) {
+	args := append([]string{"fix", "-diff", "-omitzero=false"}, packages...)
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = root
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if stderr.Len() > 0 {
+		return stdout.Bytes(), fmt.Errorf("go fix changed packages: %w: %s", err, strings.TrimSpace(stderr.String()))
+	}
+	if err != nil {
+		if stdout.Len() > 0 {
+			return stdout.Bytes(), errFixDrift
+		}
+		return nil, fmt.Errorf("go fix changed packages: %w", err)
+	}
+	return stdout.Bytes(), nil
+}
+
+func filterDiff(diff []byte, root string, changed []string) ([]byte, error) {
+	wanted := make(map[string]struct{}, len(changed))
+	for _, file := range changed {
+		wanted[normalizedPath(file)] = struct{}{}
+	}
+
+	lines := splitLines(diff)
+	var filtered bytes.Buffer
+	for i := 0; i < len(lines); {
+		if !bytes.HasPrefix(lines[i], []byte("--- ")) {
+			i++
+			continue
+		}
+		if i+1 >= len(lines) || !bytes.HasPrefix(lines[i+1], []byte("+++ ")) {
+			return nil, errors.New("parse go fix diff: missing new-file header")
+		}
+
+		end := i + 2
+		for end < len(lines) && !bytes.HasPrefix(lines[end], []byte("--- ")) {
+			end++
+		}
+		rel, err := diffRelativePath(root, string(lines[i+1]), "+++ ", " (new)")
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := wanted[normalizedPath(rel)]; ok {
+			fmt.Fprintf(&filtered, "--- a/%s\n+++ b/%s\n", filepath.ToSlash(rel), filepath.ToSlash(rel))
+			for _, line := range lines[i+2 : end] {
+				filtered.Write(line)
+			}
+		}
+		i = end
+	}
+	return filtered.Bytes(), nil
+}
+
+func splitLines(input []byte) [][]byte {
+	if len(input) == 0 {
+		return nil
+	}
+	lines := bytes.SplitAfter(input, []byte("\n"))
+	if len(lines[len(lines)-1]) == 0 {
+		return lines[:len(lines)-1]
+	}
+	return lines
+}
+
+func diffRelativePath(root, header, prefix, suffix string) (string, error) {
+	value := strings.TrimSuffix(strings.TrimSpace(strings.TrimPrefix(header, prefix)), suffix)
+	rel, err := filepath.Rel(root, value)
+	if err != nil {
+		return "", fmt.Errorf("resolve go fix diff path %q: %w", value, err)
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return "", fmt.Errorf("go fix diff path is outside repository: %s", value)
+	}
+	return filepath.ToSlash(rel), nil
+}
+
+func normalizedPath(value string) string {
+	value = filepath.ToSlash(filepath.Clean(filepath.FromSlash(value)))
+	if runtime.GOOS == "windows" {
+		return strings.ToLower(value)
+	}
+	return value
+}
+
+func applyPatch(ctx context.Context, root string, patch []byte) error {
+	cmd := exec.CommandContext(ctx, "git", "-C", root, "apply", "--whitespace=nowarn", "-")
+	cmd.Stdin = bytes.NewReader(patch)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("apply go fix changes: %w: %s", err, strings.TrimSpace(string(output)))
+	}
+	return nil
+}
diff --git a/cmd/gofixchanged/main_test.go b/cmd/gofixchanged/main_test.go
new file mode 100644
index 00000000..cc5ada53
--- /dev/null
+++ b/cmd/gofixchanged/main_test.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestChangedPackages(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	got := changedPackages(root, []string{
+		"internal/metadata/thexem/changed.go",
+		"internal/metadata/thexem/other.go",
+		"internal/services/trackericon/changed.go",
+	})
+	want := []string{
+		filepath.Join(root, "internal", "metadata", "thexem"),
+		filepath.Join(root, "internal", "services", "trackericon"),
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("changedPackages() = %v, want %v", got, want)
+	}
+}
+
+func TestFilterDiffKeepsOnlyChangedFiles(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	changedPath := filepath.Join(root, "internal", "metadata", "thexem", "changed.go")
+	unchangedPath := filepath.Join(root, "internal", "metadata", "thexem", "client.go")
+	diff := strings.Join([]string{
+		"--- " + changedPath + " (old)",
+		"+++ " + changedPath + " (new)",
+		"@@ -1 +1 @@",
+		"-old",
+		"+new",
+		"--- " + unchangedPath + " (old)",
+		"+++ " + unchangedPath + " (new)",
+		"@@ -1 +1 @@",
+		"-old runtime form",
+		"+modern runtime form",
+		"",
+	}, "\n")
+
+	got, err := filterDiff([]byte(diff), root, []string{"internal/metadata/thexem/changed.go"})
+	if err != nil {
+		t.Fatalf("filterDiff() error = %v", err)
+	}
+	gotText := string(got)
+	if !strings.Contains(gotText, "+++ b/internal/metadata/thexem/changed.go") {
+		t.Fatalf("filtered diff omitted changed file:\n%s", gotText)
+	}
+	if strings.Contains(gotText, "client.go") || strings.Contains(gotText, "modern runtime form") {
+		t.Fatalf("filtered diff retained unchanged file:\n%s", gotText)
+	}
+}
diff --git a/cmd/literalpolicy/main.go b/cmd/literalpolicy/main.go
new file mode 100644
index 00000000..76133437
--- /dev/null
+++ b/cmd/literalpolicy/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/autobrr/upbrr/internal/literalpolicy"
+)
+
+func main() {
+	fix := flag.Bool("fix", false, "rewrite inconsistent keyed composite literals")
+	flag.Parse()
+	root, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "literalpolicy: determine working directory: %v\n", err)
+		os.Exit(1)
+	}
+	if *fix {
+		fixed, fixErr := literalpolicy.FixRepository(root)
+		if fixErr != nil {
+			fmt.Fprintf(os.Stderr, "literalpolicy: %v\n", fixErr)
+			os.Exit(1)
+		}
+		fmt.Printf("literalpolicy: fixed %d files\n", fixed)
+		return
+	}
+	violations, err := literalpolicy.CheckRepository(root)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "literalpolicy: %v\n", err)
+		os.Exit(1)
+	}
+	for _, violation := range violations {
+		fmt.Println(violation.String())
+	}
+	if len(violations) != 0 {
+		os.Exit(1)
+	}
+	fmt.Println("literalpolicy: no issues found")
+}
diff --git a/cmd/pathpolicy/main.go b/cmd/pathpolicy/main.go
index 9cfff4c6..a8bf5fc5 100644
--- a/cmd/pathpolicy/main.go
+++ b/cmd/pathpolicy/main.go
@@ -5,7 +5,7 @@ import (
 	"io"
 	"os"
 
-	"github.com/autobrr/upbrr/internal/pathpolicy"
+	pathpolicy "github.com/autobrr/upbrr/internal/pathing/policy"
 )
 
 func main() {
diff --git a/cmd/pathpolicy/main_test.go b/cmd/pathpolicy/main_test.go
index 6d371a5a..d30c32e4 100644
--- a/cmd/pathpolicy/main_test.go
+++ b/cmd/pathpolicy/main_test.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/autobrr/upbrr/internal/pathpolicy"
+	pathpolicy "github.com/autobrr/upbrr/internal/pathing/policy"
 )
 
 func TestRunPrintsSuccessWhenNoIssuesFound(t *testing.T) {
diff --git a/cmd/upbrr/AGENTS.md b/cmd/upbrr/AGENTS.md
index 63c118ce..fe2a34dd 100644
--- a/cmd/upbrr/AGENTS.md
+++ b/cmd/upbrr/AGENTS.md
@@ -25,16 +25,16 @@ Add touched service/tracker/internal packages to focused `go test` runs.
 
 - Follow root log-level guidance for CLI logs and stdout/stderr.
 - User-facing stdout/stderr may be copied into issues. Do not print credentials, usernames, passwords, tokens, API keys, auth keys, passkeys, cookie values, 2FA codes, challenge IDs, refreshed API tokens, or secret payloads.
-- CLI dry-run stdout is shareable debug material: redact endpoints and payload values with the existing safe dry-run helpers before printing.
+- CLI debug payload stdout is shareable diagnostic material: redact endpoints and payload values with the existing safe dry-run helpers before printing.
 - Tracker-auth CLI logs should make the pre-dupe auth flow reconstructable without secrets: capability load count, auth-check start with tracker count, validation start per managed tracker with `tracker` and `auth_kind`, status result with `state`, cookie count, encrypted-storage availability and `needs_2fa`, per-tracker decision, and final ready/skipped counts.
 - Decision values should be stable and searchable: `ready`, `keep`, `skip`, `blocked`, `prompt_2fa`, or `prompt_2fa_again`.
 - Log unattended blocks as warnings with `unattended=true` and a stable reason such as `2fa_required`.
 - Log non-fatal filtering details, such as auth skipped because preview rule failures already excluded a tracker, at debug level.
 - Log prompt failures, blank 2FA submissions, failed 2FA submissions, and auth-not-ready skips at warning level.
 - Redact every free-form status/error field before logging. Keep empty fields readable with a stable value such as `none`.
-- Run `make logpolicy` when changing CLI dry-run output or auth-sensitive output/logging.
+- Run `make logpolicy` when changing CLI debug payload output or auth-sensitive output/logging.
 
 ## Parity
 
-- CLI request/options behavior shares contracts with Wails and embedded web.
-- Request-shape changes usually require checking `pkg/api`, `internal/core`, `internal/guiapp`, `internal/webserver`, and `gui/frontend/src`.
+- CLI request/options behavior shares contracts with WebUI workflows.
+- Request-shape changes usually require checking `pkg/api`, `internal/core`, `internal/webserver`, and `webui/src`.
diff --git a/cmd/upbrr/cli_options.go b/cmd/upbrr/cli_options.go
index 677c179c..f3250347 100644
--- a/cmd/upbrr/cli_options.go
+++ b/cmd/upbrr/cli_options.go
@@ -15,7 +15,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
+	imagehostpolicy "github.com/autobrr/upbrr/internal/imagehosting/policy"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -30,7 +31,6 @@ type cliOptions struct {
 	TrackersRemove        string
 	Debug                 bool
 	LogLevel              string
-	DryRun                bool
 	Screens               int
 	NoSeed                bool
 	SkipAutoTorrent       bool
@@ -164,7 +164,6 @@ func parseCLIOptions(args []string) (cliOptions, map[string]bool, []string, erro
 	fs.StringVar(&opts.TrackersRemove, "rtk", "", "Remove these trackers (comma-separated)")
 	fs.BoolVar(&opts.Debug, "debug", false, "Enable debug mode")
 	fs.StringVar(&opts.LogLevel, "log-level", "", "Set run log level (error, warn, info, debug, trace)")
-	fs.BoolVar(&opts.DryRun, "dry-run", false, "Run without uploading")
 	fs.IntVar(&opts.Screens, "screens", -1, "Number of screenshots to take")
 	fs.IntVar(&opts.Screens, "s", -1, "Number of screenshots to take")
 	fs.BoolVar(&opts.NoSeed, "no-seed", false, "Do not inject torrent into clients")
@@ -607,7 +606,7 @@ func cliHelpSections(name string) []helpSection {
 		{title: "Config", names: []string{"config", "export-config", "export-config-plaintext", "import-config", "create-auth"}},
 		{title: "Application", names: []string{"version", "cleanup"}},
 		{title: "Execution", names: []string{
-			"queue", "limit-queue", "site-check", "site-upload", "dry-run", "debug", "log-level", "upload-only",
+			"queue", "limit-queue", "site-check", "site-upload", "debug", "log-level", "upload-only",
 			"delete-tmp", "unattended", "unattended_confirm",
 		}},
 		{title: "Tracker Selection", names: []string{"trackers", "trackers-remove"}},
@@ -713,9 +712,12 @@ func buildCLIRequest(opts cliOptions, visited map[string]bool, paths []string, s
 		runLogLevel = normalized
 	}
 
+	sourcePath := ""
+	if len(paths) == 1 {
+		sourcePath = paths[0]
+	}
 	req := api.Request{
-		Paths: paths,
-		Mode:  api.ModeCLI,
+		SourcePath: sourcePath,
 		Execution: api.ExecutionOptions{
 			QueueName:         strings.TrimSpace(opts.QueueName),
 			QueueLimit:        opts.LimitQueue,
@@ -725,8 +727,6 @@ func buildCLIRequest(opts cliOptions, visited map[string]bool, paths []string, s
 		Trackers:       splitCSV(opts.Trackers),
 		TrackersRemove: splitCSV(opts.TrackersRemove),
 		Options: api.UploadOptions{
-			Debug:           opts.Debug,
-			DryRun:          opts.DryRun || opts.Debug || opts.SiteCheck,
 			RunLogLevel:     runLogLevel,
 			Screens:         screens,
 			NoSeed:          opts.NoSeed,
@@ -948,15 +948,51 @@ func buildTrackerIDOverrides(opts cliOptions, visited map[string]bool) (map[stri
 		tracker     string
 		value       string
 	}{
-		{visitedName: "ptp", tracker: "ptp", value: opts.PTP},
-		{visitedName: "blu", tracker: "blu", value: opts.BLU},
-		{visitedName: "aither", tracker: "aither", value: opts.Aither},
-		{visitedName: "lst", tracker: "lst", value: opts.LST},
-		{visitedName: "oe", tracker: "oe", value: opts.OE},
-		{visitedName: "hdb", tracker: "hdb", value: opts.HDB},
-		{visitedName: "btn", tracker: "btn", value: opts.BTN},
-		{visitedName: "bhd", tracker: "bhd", value: opts.BHD},
-		{visitedName: "ulcx", tracker: "ulcx", value: opts.ULCX},
+		{
+			visitedName: "ptp",
+			tracker:     "ptp",
+			value:       opts.PTP,
+		},
+		{
+			visitedName: "blu",
+			tracker:     "blu",
+			value:       opts.BLU,
+		},
+		{
+			visitedName: "aither",
+			tracker:     "aither",
+			value:       opts.Aither,
+		},
+		{
+			visitedName: "lst",
+			tracker:     "lst",
+			value:       opts.LST,
+		},
+		{
+			visitedName: "oe",
+			tracker:     "oe",
+			value:       opts.OE,
+		},
+		{
+			visitedName: "hdb",
+			tracker:     "hdb",
+			value:       opts.HDB,
+		},
+		{
+			visitedName: "btn",
+			tracker:     "btn",
+			value:       opts.BTN,
+		},
+		{
+			visitedName: "bhd",
+			tracker:     "bhd",
+			value:       opts.BHD,
+		},
+		{
+			visitedName: "ulcx",
+			tracker:     "ulcx",
+			value:       opts.ULCX,
+		},
 	}
 
 	overrides := make(map[string]string)
@@ -1078,8 +1114,11 @@ func parseInfoHash(raw string) (string, error) {
 
 func parseImageHost(raw string) (string, error) {
 	trimmed := strings.ToLower(strings.TrimSpace(raw))
-	if imagehostpolicy.IsUploadHost(trimmed) && imagehostpolicy.OwnerForHost(trimmed) == "" {
-		return trimmed, nil
+	if imagehostpolicy.IsUploadHost(trimmed) {
+		registry, err := trackerimpl.NewRegistry()
+		if err == nil && registry.OwnerForImageHost(trimmed) == "" {
+			return trimmed, nil
+		}
 	}
 	return "", fmt.Errorf("invalid imghost %q", raw)
 }
diff --git a/cmd/upbrr/cli_options_test.go b/cmd/upbrr/cli_options_test.go
index 33c47ec3..7a43230e 100644
--- a/cmd/upbrr/cli_options_test.go
+++ b/cmd/upbrr/cli_options_test.go
@@ -112,9 +112,21 @@ func TestParseServeOptionsPortUsesDecimalSyntax(t *testing.T) {
 		args []string
 		want int
 	}{
-		{name: "separate value", args: []string{"--port", "080"}, want: 80},
-		{name: "equals value", args: []string{"--port=010"}, want: 10},
-		{name: "leading zero nine", args: []string{"--port", "009"}, want: 9},
+		{
+			name: "separate value",
+			args: []string{"--port", "080"},
+			want: 80,
+		},
+		{
+			name: "equals value",
+			args: []string{"--port=010"},
+			want: 10,
+		},
+		{
+			name: "leading zero nine",
+			args: []string{"--port", "009"},
+			want: 9,
+		},
 	}
 
 	for _, tc := range cases {
@@ -170,10 +182,30 @@ func TestApplyServeOptionOverridesAddressMatrix(t *testing.T) {
 		host string
 		port int
 	}{
-		{name: "host port", addr: "localhost:9090", host: "localhost", port: 9090},
-		{name: "colon port shorthand", addr: ":9091", host: "0.0.0.0", port: 9091},
-		{name: "bracketed ipv6", addr: "[::1]:9092", host: "::1", port: 9092},
-		{name: "scoped ipv6", addr: "[fe80::1%zone]:9093", host: "fe80::1%zone", port: 9093},
+		{
+			name: "host port",
+			addr: "localhost:9090",
+			host: "localhost",
+			port: 9090,
+		},
+		{
+			name: "colon port shorthand",
+			addr: ":9091",
+			host: "0.0.0.0",
+			port: 9091,
+		},
+		{
+			name: "bracketed ipv6",
+			addr: "[::1]:9092",
+			host: "::1",
+			port: 9092,
+		},
+		{
+			name: "scoped ipv6",
+			addr: "[fe80::1%zone]:9093",
+			host: "fe80::1%zone",
+			port: 9093,
+		},
 	}
 
 	for _, tc := range cases {
@@ -255,16 +287,32 @@ func TestApplyServeEnvOverridesRejectsEmptyBaseURL(t *testing.T) {
 func TestApplyServeOptionOverridesCLIOverridesEnv(t *testing.T) {
 	envCfg, err := applyServeEnvOverrides(
 		webserver.DefaultCLIConfig(),
-		serveEnvOptions{Host: "0.0.0.0", Port: "9090", BaseURL: "/env/"},
-		map[string]bool{"host": true, "port": true, "base-url": true},
+		serveEnvOptions{
+			Host:    "0.0.0.0",
+			Port:    "9090",
+			BaseURL: "/env/",
+		},
+		map[string]bool{
+			"host":     true,
+			"port":     true,
+			"base-url": true,
+		},
 	)
 	if err != nil {
 		t.Fatalf("apply serve env overrides: %v", err)
 	}
 	cfg, err := applyServeOptionOverrides(
 		envCfg,
-		serveOptions{Host: "127.0.0.1", Port: 9191, BaseURL: "/cli/"},
-		map[string]bool{"host": true, "port": true, "base-url": true},
+		serveOptions{
+			Host:    "127.0.0.1",
+			Port:    9191,
+			BaseURL: "/cli/",
+		},
+		map[string]bool{
+			"host":     true,
+			"port":     true,
+			"base-url": true,
+		},
 	)
 	if err != nil {
 		t.Fatalf("apply serve option overrides: %v", err)
@@ -349,15 +397,60 @@ func TestApplyServeOptionOverridesRejectsInvalidValues(t *testing.T) {
 		visited map[string]bool
 		want    string
 	}{
-		{name: "addr with host", opts: serveOptions{Addr: "localhost:7480", Host: "localhost"}, visited: map[string]bool{"addr": true, "host": true}, want: "--addr cannot be used"},
-		{name: "empty host", opts: serveOptions{Host: " "}, visited: map[string]bool{"host": true}, want: "--host cannot be empty"},
-		{name: "host includes port", opts: serveOptions{Host: "localhost:7480"}, visited: map[string]bool{"host": true}, want: "--host cannot include a port"},
-		{name: "scoped ipv6 hostport", opts: serveOptions{Host: "fe80::1%zone:9090"}, visited: map[string]bool{"host": true}, want: "--host cannot include a port"},
-		{name: "invalid port", opts: serveOptions{Port: 70000}, visited: map[string]bool{"port": true}, want: "invalid port"},
-		{name: "invalid addr", opts: serveOptions{Addr: "localhost"}, visited: map[string]bool{"addr": true}, want: "--addr must be host:port"},
-		{name: "unbracketed ipv6 addr", opts: serveOptions{Addr: "::1:9090"}, visited: map[string]bool{"addr": true}, want: "--addr must be host:port"},
-		{name: "empty base url", opts: serveOptions{BaseURL: " "}, visited: map[string]bool{"base-url": true}, want: "--base-url cannot be empty"},
-		{name: "invalid base url", opts: serveOptions{BaseURL: "javascript:alert(1)"}, visited: map[string]bool{"base-url": true}, want: "http or https"},
+		{
+			name:    "addr with host",
+			opts:    serveOptions{Addr: "localhost:7480", Host: "localhost"},
+			visited: map[string]bool{"addr": true, "host": true},
+			want:    "--addr cannot be used",
+		},
+		{
+			name:    "empty host",
+			opts:    serveOptions{Host: " "},
+			visited: map[string]bool{"host": true},
+			want:    "--host cannot be empty",
+		},
+		{
+			name:    "host includes port",
+			opts:    serveOptions{Host: "localhost:7480"},
+			visited: map[string]bool{"host": true},
+			want:    "--host cannot include a port",
+		},
+		{
+			name:    "scoped ipv6 hostport",
+			opts:    serveOptions{Host: "fe80::1%zone:9090"},
+			visited: map[string]bool{"host": true},
+			want:    "--host cannot include a port",
+		},
+		{
+			name:    "invalid port",
+			opts:    serveOptions{Port: 70000},
+			visited: map[string]bool{"port": true},
+			want:    "invalid port",
+		},
+		{
+			name:    "invalid addr",
+			opts:    serveOptions{Addr: "localhost"},
+			visited: map[string]bool{"addr": true},
+			want:    "--addr must be host:port",
+		},
+		{
+			name:    "unbracketed ipv6 addr",
+			opts:    serveOptions{Addr: "::1:9090"},
+			visited: map[string]bool{"addr": true},
+			want:    "--addr must be host:port",
+		},
+		{
+			name:    "empty base url",
+			opts:    serveOptions{BaseURL: " "},
+			visited: map[string]bool{"base-url": true},
+			want:    "--base-url cannot be empty",
+		},
+		{
+			name:    "invalid base url",
+			opts:    serveOptions{BaseURL: "javascript:alert(1)"},
+			visited: map[string]bool{"base-url": true},
+			want:    "http or https",
+		},
 	}
 
 	for _, tc := range cases {
@@ -378,11 +471,31 @@ func TestParseServeHostRejectsMalformedBrackets(t *testing.T) {
 		host string
 		want string
 	}{
-		{name: "leading bracket only", host: "[::1", want: "invalid bracket syntax"},
-		{name: "trailing bracket only", host: "::1]", want: "invalid bracket syntax"},
-		{name: "nested brackets", host: "[[::1]]", want: "invalid bracket syntax"},
-		{name: "empty brackets", host: "[]", want: "invalid bracket syntax"},
-		{name: "bracketed hostname", host: "[localhost]", want: "IPv6 literals"},
+		{
+			name: "leading bracket only",
+			host: "[::1",
+			want: "invalid bracket syntax",
+		},
+		{
+			name: "trailing bracket only",
+			host: "::1]",
+			want: "invalid bracket syntax",
+		},
+		{
+			name: "nested brackets",
+			host: "[[::1]]",
+			want: "invalid bracket syntax",
+		},
+		{
+			name: "empty brackets",
+			host: "[]",
+			want: "invalid bracket syntax",
+		},
+		{
+			name: "bracketed hostname",
+			host: "[localhost]",
+			want: "IPv6 literals",
+		},
 	}
 
 	for _, tc := range cases {
@@ -442,12 +555,6 @@ func TestParseServeHostPreservesValidIPv6(t *testing.T) {
 	}
 }
 
-func TestParseCLIOptionsRejectsGUIFlag(t *testing.T) {
-	if _, _, _, err := parseCLIOptions([]string{"-gui"}); err == nil {
-		t.Fatal("expected gui flag to be rejected")
-	}
-}
-
 func TestParseCLIOptionsExportConfigPlaintext(t *testing.T) {
 	opts, visited, paths, err := parseCLIOptions([]string{"--export-config", "out.yaml", "--export-config-plaintext"})
 	if err != nil {
@@ -513,7 +620,7 @@ func TestParseCLIOptionsPythonAliases(t *testing.T) {
 	}
 }
 
-func TestBuildCLIRequestDebugImpliesDryRunAndOnlyID(t *testing.T) {
+func TestBuildCLIRequestKeepsDebugAdapterLocalAndPropagatesOnlyID(t *testing.T) {
 	opts, visited, paths, err := parseCLIOptions([]string{"--debug", "--onlyID", "movie.mkv"})
 	if err != nil {
 		t.Fatalf("parse: %v", err)
@@ -522,11 +629,8 @@ func TestBuildCLIRequestDebugImpliesDryRunAndOnlyID(t *testing.T) {
 	if err != nil {
 		t.Fatalf("build request: %v", err)
 	}
-	if !req.Options.Debug {
-		t.Fatalf("expected debug enabled, got %#v", req.Options)
-	}
-	if !req.Options.DryRun {
-		t.Fatalf("expected debug to imply dry run, got %#v", req.Options)
+	if !opts.Debug {
+		t.Fatal("expected CLI debug mode enabled")
 	}
 	if !req.Options.OnlyID {
 		t.Fatalf("expected onlyID to propagate, got %#v", req.Options)
@@ -550,12 +654,11 @@ func TestParseCLIOptionsFlagsAfterPath(t *testing.T) {
 	if !visited["debug"] || !visited["delete-tmp"] {
 		t.Fatalf("expected trailing flags visited, got %#v", visited)
 	}
-	req, err := buildCLIRequest(opts, visited, paths, 4)
-	if err != nil {
+	if _, err := buildCLIRequest(opts, visited, paths, 4); err != nil {
 		t.Fatalf("build request: %v", err)
 	}
-	if !req.Options.Debug || !req.Options.DryRun {
-		t.Fatalf("expected trailing debug to force dry run, got %#v", req.Options)
+	if !opts.Debug {
+		t.Fatal("expected trailing debug to remain adapter-local")
 	}
 }
 
@@ -596,8 +699,43 @@ func TestBuildCLIRequestPropagatesRunLogLevel(t *testing.T) {
 	if req.Options.RunLogLevel != "trace" {
 		t.Fatalf("expected run log level trace, got %q", req.Options.RunLogLevel)
 	}
-	if !req.Options.Debug {
-		t.Fatalf("expected debug enabled, got %#v", req.Options)
+	if !opts.Debug {
+		t.Fatal("expected CLI debug mode enabled")
+	}
+}
+
+func TestBuildCLIRequestPreservesCombinedDebugModifiers(t *testing.T) {
+	for _, test := range []struct {
+		name       string
+		args       []string
+		wantNoSeed bool
+	}{
+		{name: "default injection", args: []string{"--debug", "-siu", "-s", "0", "movie.mkv"}},
+		{
+name: "no seed",
+ args: []string{"--debug", "-ns", "-siu", "-s", "0", "movie.mkv"},
+ wantNoSeed: true,
+},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			opts, visited, paths, err := parseCLIOptions(test.args)
+			if err != nil {
+				t.Fatalf("parse: %v", err)
+			}
+			req, err := buildCLIRequest(opts, visited, paths, opts.Screens)
+			if err != nil {
+				t.Fatalf("build request: %v", err)
+			}
+			if !opts.Debug {
+				t.Fatal("expected debug to remain an adapter-local operation choice")
+			}
+			if req.Options.NoSeed != test.wantNoSeed || req.Options.Screens != 0 {
+				t.Fatalf("combined debug modifiers lost from upload options: %#v", req.Options)
+			}
+			if req.ImageHostOverrides.SkipUpload == nil || !*req.ImageHostOverrides.SkipUpload {
+				t.Fatalf("combined debug image-host override lost: %#v", req.ImageHostOverrides)
+			}
+		})
 	}
 }
 
@@ -676,14 +814,19 @@ func TestBuildCLIRequestExecutionOptions(t *testing.T) {
 	if req.Execution.SiteUploadTracker != "BLU" {
 		t.Fatalf("expected site upload tracker BLU, got %q", req.Execution.SiteUploadTracker)
 	}
-	if !req.Options.DryRun {
-		t.Fatalf("expected site-check to imply dry run, got %#v", req.Options)
-	}
 	if len(req.Trackers) != 1 || req.Trackers[0] != "BLU" {
 		t.Fatalf("expected site-upload tracker to override request trackers, got %#v", req.Trackers)
 	}
 }
 
+func TestParseCLIOptionsRejectsRemovedDryRunFlag(t *testing.T) {
+	t.Parallel()
+
+	if _, _, _, err := parseCLIOptions([]string{"--dry-run", "movie.mkv"}); err == nil {
+		t.Fatal("expected removed --dry-run flag to be rejected")
+	}
+}
+
 func TestParseCLIOptionsRejectsNegativeQueueLimit(t *testing.T) {
 	if _, _, _, err := parseCLIOptions([]string{"--limit-queue", "-1", "movie.mkv"}); err == nil {
 		t.Fatal("expected negative limit-queue to fail")
@@ -984,26 +1127,30 @@ func TestPrintMetadataPreviewShowsRichReleaseDetails(t *testing.T) {
 			SourcePath:  "C:\\path\\to\\Example.Release.2026.S01.1080p.WEB-DL-GRP",
 			ReleaseName: "Example Release 2026 S01 1080p WEB-DL H.264-GRP",
 			TrackerName: "LST",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				TMDBID:   123456,
 				IMDBID:   7654321,
 				TVDBID:   234567,
 				TVmazeID: 34567,
-				Category: "TV",
+				Category: api.CanonicalCategoryTV,
 			},
-			Warnings: []string{"Season pack contains mixed group tags (ALT, GRP); trackers with mixed-origin support will use Mixed."},
-			ExternalPreview: []api.ExternalPreview{{
-				Provider:     "tmdb",
-				ID:           123456,
-				Title:        "Example Release",
-				Year:         2026,
-				Overview:     "Example overview for a fictional series used in CLI preview output.",
-				Genres:       "Drama, Mystery",
-				Category:     "TV",
-				FirstAirDate: "2026-02-22",
-				Runtime:      55,
-				Rating:       7.9,
-				RatingCount:  1200,
+			Display: api.PreparedReleaseDisplay{Providers: []api.ProviderDisplay{{
+				Provider:         api.IdentityProviderTMDB,
+				ID:               123456,
+				SummaryAvailable: true,
+				Summary: api.ProviderDisplaySummary{
+					Title:          "Example Release",
+					Year:           2026,
+					Overview:       "Example overview for a fictional series used in CLI preview output.",
+					Genres:         "Drama, Mystery",
+					Category:       "TV",
+					Date:           "2026-02-22",
+					RuntimeMinutes: 55,
+				},
+			}}},
+			Diagnostics: []api.PreparationDiagnostic{{
+				Severity: api.DiagnosticSeverityWarning,
+				Message:  "Season pack contains mixed group tags (ALT, GRP); trackers with mixed-origin support will use Mixed.",
 			}},
 		}, true)
 	})
@@ -1020,13 +1167,12 @@ func TestPrintMetadataPreviewShowsRichReleaseDetails(t *testing.T) {
 		"Category: TV",
 		"Date: 2026-02-22",
 		"Runtime: 55 min",
-		"Rating: 7.9 (1200 votes)",
 		"Tracker data from: LST",
 		"External IDs",
-		"TMDB: https://www.themoviedb.org/tv/123456",
-		"IMDb: https://www.imdb.com/title/tt7654321",
-		"TVDB: https://www.thetvdb.com/?id=234567&tab=series",
-		"TVmaze: https://www.tvmaze.com/shows/34567",
+		"TMDB: 123456",
+		"IMDb: tt7654321",
+		"TVDB: 234567",
+		"TVmaze: 34567",
 		"Warnings:",
 		"- Season pack contains mixed group tags (ALT, GRP); trackers with mixed-origin support will use Mixed.",
 	} {
@@ -1048,8 +1194,16 @@ func TestPrintDryRunDetails(t *testing.T) {
 			entry: api.TrackerDryRunEntry{
 				Endpoint: "https://tracker.test/upload",
 				Files: []api.TrackerDryRunFile{
-					{Field: "torrent", Path: "C:\\Users\\Tester\\.upbrr\\tmp\\file.torrent", Present: true},
-					{Field: "nfo", Path: "", Present: false},
+					{
+						Field:   "torrent",
+						Path:    "C:\\Users\\Tester\\.upbrr\\tmp\\file.torrent",
+						Present: true,
+					},
+					{
+						Field:   "nfo",
+						Path:    "",
+						Present: false,
+					},
 				},
 				Payload: map[string]string{
 					"category":    "MOVIE",
@@ -1104,7 +1258,11 @@ func TestPrintDryRunDetails(t *testing.T) {
 						Title:    "BTN final upload payload after autofill",
 						Endpoint: "https://tracker.test/upload.php?api_key=secret-key",
 						Files: []api.TrackerDryRunFile{
-							{Field: "file_input", Path: "C:\\Users\\Tester\\.upbrr\\tmp\\file.torrent", Present: true},
+							{
+								Field:   "file_input",
+								Path:    "C:\\Users\\Tester\\.upbrr\\tmp\\file.torrent",
+								Present: true,
+							},
 						},
 						Payload: map[string]string{
 							"artist":       "Example Show",
diff --git a/cmd/upbrr/cli_tracker_auth_default.go b/cmd/upbrr/cli_tracker_auth_default.go
index 1086044c..613e63ca 100644
--- a/cmd/upbrr/cli_tracker_auth_default.go
+++ b/cmd/upbrr/cli_tracker_auth_default.go
@@ -7,11 +7,12 @@ package main
 
 import (
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 // newCLITrackerAuthService returns the production tracker-auth implementation.
 func newCLITrackerAuthService(cfg config.Config, logger api.Logger) cliTrackerAuthService {
-	return trackerauth.NewServiceWithLogger(cfg, logger)
+	return trackerauth.NewServiceWithRegistryAndLogger(cfg, trackerimpl.MustNewRegistry(), logger)
 }
diff --git a/cmd/upbrr/cli_tracker_auth_e2e.go b/cmd/upbrr/cli_tracker_auth_e2e.go
index fbe2a09b..c109a86c 100644
--- a/cmd/upbrr/cli_tracker_auth_e2e.go
+++ b/cmd/upbrr/cli_tracker_auth_e2e.go
@@ -11,7 +11,8 @@ import (
 	"strings"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -24,7 +25,7 @@ func newCLITrackerAuthService(cfg config.Config, logger api.Logger) cliTrackerAu
 	if value == "1" || strings.EqualFold(value, "true") {
 		return e2eCLITrackerAuthService{}
 	}
-	return trackerauth.NewServiceWithLogger(cfg, logger)
+	return trackerauth.NewServiceWithRegistryAndLogger(cfg, trackerimpl.MustNewRegistry(), logger)
 }
 
 // e2eCLITrackerAuthService treats tracker auth as configured without network IO.
diff --git a/cmd/upbrr/description_editor.go b/cmd/upbrr/description_editor.go
index 23fc4331..4b4a782b 100644
--- a/cmd/upbrr/description_editor.go
+++ b/cmd/upbrr/description_editor.go
@@ -19,22 +19,35 @@ import (
 
 var editCLIDescriptionFile = editDescriptionFile
 
-func maybeEditCLIDescriptions(ctx context.Context, coreSvc api.Core, reader *bufio.Reader, req api.Request, review api.UploadReview, opts cliOptions) (api.Request, api.UploadReview, error) {
+// cliDescriptionEditorCore owns description preview and persisted overrides.
+type cliDescriptionEditorCore interface {
+	FetchDescriptionBuilderPreview(context.Context, api.Request) (api.DescriptionBuilderPreview, error)
+	SaveDescriptionOverride(context.Context, api.Request, string) (api.DescriptionBuilderGroup, error)
+}
+
+func maybeEditCLIDescriptions(
+	ctx context.Context,
+	coreSvc cliDescriptionEditorCore,
+	reader *bufio.Reader,
+	req api.Request,
+	review api.UploadReview,
+	opts cliOptions,
+) (api.Request, error) {
 	if req.Options.OnlyID || opts.OnlyID {
-		return req, review, nil
+		return req, nil
 	}
 	if opts.Unattended && !opts.UnattendedConfirm {
-		return req, review, nil
+		return req, nil
 	}
 
 	preview, err := coreSvc.FetchDescriptionBuilderPreview(ctx, req)
 	if err != nil {
-		return req, review, fmt.Errorf("upbrr: description builder: %w", err)
+		return req, fmt.Errorf("upbrr: description builder: %w", err)
 	}
 	groups := filterEditableDescriptionGroups(preview.Groups, review)
 	if len(groups) == 0 {
 		fmt.Println("No generated descriptions available to edit.")
-		return req, review, nil
+		return req, nil
 	}
 	printCLIDescriptionPreview(groups)
 
@@ -48,7 +61,7 @@ func maybeEditCLIDescriptions(ctx context.Context, coreSvc api.Core, reader *buf
 		}
 		edit, err := promptYesNo(reader, prompt, false)
 		if err != nil {
-			return req, review, err
+			return req, err
 		}
 		if !edit {
 			continue
@@ -57,7 +70,7 @@ func maybeEditCLIDescriptions(ctx context.Context, coreSvc api.Core, reader *buf
 		fmt.Printf("Editing description %s\n", label)
 		edited, didChange, err := editCLIDescriptionFile(ctx, group.RawDescription)
 		if err != nil {
-			return req, review, fmt.Errorf("upbrr: edit description %s: %w", label, err)
+			return req, fmt.Errorf("upbrr: edit description %s: %w", label, err)
 		}
 		if !didChange {
 			fmt.Printf("Description %s unchanged.\n", label)
@@ -71,22 +84,18 @@ func maybeEditCLIDescriptions(ctx context.Context, coreSvc api.Core, reader *buf
 		}
 		updated, err := coreSvc.SaveDescriptionOverride(ctx, saveReq, edited)
 		if err != nil {
-			return req, review, fmt.Errorf("upbrr: save description %s: %w", label, err)
+			return req, fmt.Errorf("upbrr: save description %s: %w", label, err)
 		}
 		groups[idx] = mergeDescriptionGroupUpdate(group, updated)
 		changed = true
 		fmt.Printf("Description %s saved.\n", label)
 	}
 	if !changed {
-		return req, review, nil
+		return req, nil
 	}
 
 	req.DescriptionGroups = replaceDescriptionGroups(preview.Groups, groups)
-	updatedReview, err := coreSvc.BuildUploadReview(ctx, req)
-	if err != nil {
-		return req, review, fmt.Errorf("upbrr: rebuild upload review: %w", err)
-	}
-	return req, updatedReview, nil
+	return req, nil
 }
 
 func filterEditableDescriptionGroups(groups []api.DescriptionBuilderGroup, review api.UploadReview) []api.DescriptionBuilderGroup {
diff --git a/cmd/upbrr/interactive.go b/cmd/upbrr/interactive.go
index 4459bb57..3268346b 100644
--- a/cmd/upbrr/interactive.go
+++ b/cmd/upbrr/interactive.go
@@ -18,8 +18,9 @@ import (
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/logging"
 	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/trackerauth"
 	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -35,23 +36,132 @@ type cliTrackerAuthService interface {
 	Submit2FA(ctx context.Context, challengeID string, code string) (api.TrackerAuthStatus, error)
 }
 
-func runInteractiveCLIPath(ctx context.Context, coreSvc api.Core, opts cliOptions, visited map[string]bool, sourcePath string, cfg config.Config) error {
+// cliSiteCheckCore composes metadata preparation and review for site-check-only runs.
+type cliSiteCheckCore interface {
+	cliMetadataPreviewer
+	cliUploadReviewer
+}
+
+// cliScreenshotCore is the CLI-facing screenshot seam.
+type cliScreenshotCore interface {
+	FetchScreenshotPlan(context.Context, api.Request) (api.ScreenshotPlan, error)
+	GenerateScreenshots(context.Context, api.Request, []api.ScreenshotSelection, api.ScreenshotPurpose) (api.ScreenshotResult, error)
+	SaveFinalScreenshotSelections(context.Context, api.Request, []api.ScreenshotImage) error
+}
+
+type cliDupeChecker interface {
+	CheckDupes(context.Context, api.Request) (api.DupeCheckSummary, error)
+}
+
+// cliInteractiveCore composes only capabilities used by the interactive path.
+type cliInteractiveCore interface {
+	cliPreparedUploadRunner
+	cliAcceptedTrackerDryRunRunner
+	cliMetadataPreviewer
+	cliUploadReviewer
+	cliScreenshotCore
+	cliDVDMenuCore
+	cliDupeChecker
+	cliDescriptionEditorCore
+}
+
+func runInteractiveCLIPath(
+	ctx context.Context,
+	coreSvc cliInteractiveCore,
+	opts cliOptions,
+	visited map[string]bool,
+	sourcePath string,
+	cfg config.Config,
+) error {
 	return runInteractiveCLIPathWithInputAndLogger(ctx, coreSvc, nil, opts, visited, sourcePath, 1, cfg, os.Stdin, api.NopLogger{})
 }
 
-// runInteractiveCLIPathWithLogger runs one interactive CLI upload path and
-// sends CLI-only tracker auth decisions to logger.
-func runInteractiveCLIPathWithLogger(ctx context.Context, coreSvc api.Core, baseArgs []string, opts cliOptions, visited map[string]bool, sourcePath string, screens int, cfg config.Config, logger api.Logger) error {
-	return runInteractiveCLIPathWithInputAndLogger(ctx, coreSvc, baseArgs, opts, visited, sourcePath, screens, cfg, os.Stdin, logger)
+// runInteractiveCLIPathWithLoggerAndPlaylist runs the interactive workflow with
+// one pre-resolved playlist instruction and process stdin.
+func runInteractiveCLIPathWithLoggerAndPlaylist(
+	ctx context.Context,
+	coreSvc cliInteractiveCore,
+	baseArgs []string,
+	opts cliOptions,
+	visited map[string]bool,
+	sourcePath string,
+	playlist api.PlaylistInstruction,
+	screens int,
+	cfg config.Config,
+	logger api.Logger,
+) error {
+	return runInteractiveCLIPathWithInputLoggerAndPlaylist(
+		ctx,
+		coreSvc,
+		baseArgs,
+		opts,
+		visited,
+		sourcePath,
+		playlist,
+		screens,
+		cfg,
+		os.Stdin,
+		logger,
+	)
 }
 
-func runInteractiveCLIPathWithInput(ctx context.Context, coreSvc api.Core, opts cliOptions, visited map[string]bool, sourcePath string, screens int, cfg config.Config, stdin io.Reader) error {
+func runInteractiveCLIPathWithInput(
+	ctx context.Context,
+	coreSvc cliInteractiveCore,
+	opts cliOptions,
+	visited map[string]bool,
+	sourcePath string,
+	screens int,
+	cfg config.Config,
+	stdin io.Reader,
+) error {
 	return runInteractiveCLIPathWithInputAndLogger(ctx, coreSvc, nil, opts, visited, sourcePath, screens, cfg, stdin, api.NopLogger{})
 }
 
-// runInteractiveCLIPathWithInputAndLogger is the injectable form of
-// runInteractiveCLIPathWithLogger used when tests need controlled stdin.
-func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Core, baseArgs []string, opts cliOptions, visited map[string]bool, sourcePath string, screens int, cfg config.Config, stdin io.Reader, logger api.Logger) error {
+// runInteractiveCLIPathWithInputAndLogger is the injectable interactive runner
+// used when tests need controlled stdin and logging.
+func runInteractiveCLIPathWithInputAndLogger(
+	ctx context.Context,
+	coreSvc cliInteractiveCore,
+	baseArgs []string,
+	opts cliOptions,
+	visited map[string]bool,
+	sourcePath string,
+	screens int,
+	cfg config.Config,
+	stdin io.Reader,
+	logger api.Logger,
+) error {
+	return runInteractiveCLIPathWithInputLoggerAndPlaylist(
+		ctx,
+		coreSvc,
+		baseArgs,
+		opts,
+		visited,
+		sourcePath,
+		api.PlaylistInstruction{},
+		screens,
+		cfg,
+		stdin,
+		logger,
+	)
+}
+
+// runInteractiveCLIPathWithInputLoggerAndPlaylist owns the interactive retry
+// loop while preserving the source-specific playlist instruction across retries.
+func runInteractiveCLIPathWithInputLoggerAndPlaylist(
+	ctx context.Context,
+	coreSvc cliInteractiveCore,
+	baseArgs []string,
+	opts cliOptions,
+	visited map[string]bool,
+	sourcePath string,
+	playlist api.PlaylistInstruction,
+	screens int,
+	cfg config.Config,
+	stdin io.Reader,
+	logger api.Logger,
+) error {
 	logger = cliAuthLogger(logger)
 	reader := bufio.NewReader(stdin)
 	currentArgs := append([]string(nil), baseArgs...)
@@ -64,11 +174,19 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 		if err != nil {
 			return err
 		}
+		req.PlaylistInstruction = cloneCLIPlaylistInstruction(playlist)
 		preview, err := coreSvc.FetchMetadataPreview(ctx, req)
 		if err != nil {
 			var rescanErr *api.BDMVRescanRequiredError
 			if errors.As(err, &rescanErr) && currentOpts.interactionMode() != api.InteractionModeUnattended {
-				confirm, promptErr := promptYesNo(reader, fmt.Sprintf("Cached BDMV summaries exist, but selected playlist(s) %s require a rescan. Rescan now? [Y/n]: ", strings.Join(rescanErr.MissingPlaylists, ", ")), true)
+				confirm, promptErr := promptYesNo(
+					reader,
+					fmt.Sprintf(
+						"Cached BDMV summaries exist, but selected playlist(s) %s require a rescan. Rescan now? [Y/n]: ",
+						strings.Join(rescanErr.MissingPlaylists, ", "),
+					),
+					true,
+				)
 				if promptErr != nil {
 					return promptErr
 				}
@@ -128,14 +246,30 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 	if err != nil {
 		return err
 	}
+	req.PlaylistInstruction = cloneCLIPlaylistInstruction(playlist)
 
-	candidateTrackers, removalBase := resolveCLIUploadTrackers(currentVisited, req, metadataPreview, cfg)
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		return fmt.Errorf("upbrr: compose tracker registry: %w", err)
+	}
+	candidateTrackers, removalBase := resolveCLIUploadTrackers(currentVisited, req, metadataPreview, cfg, registry, currentOpts.Debug)
 	if len(candidateTrackers) == 0 {
 		fmt.Printf("No trackers configured for %s\n", formatPathLabel(sourcePath))
 		return nil
 	}
 	req.Trackers = candidateTrackers
 	req.TrackersRemove = appendTrackerRemovals(req.TrackersRemove, unselectedTrackers(removalBase, candidateTrackers)...)
+	if !currentOpts.Debug {
+		candidateTrackers, req.RuleAuthorizations, err = promptTrackerRuleReview(reader, req, candidateTrackers, metadataPreview)
+		if err != nil {
+			return err
+		}
+		if len(candidateTrackers) == 0 {
+			fmt.Printf("No trackers selected for %s\n", formatPathLabel(sourcePath))
+			return nil
+		}
+		req.Trackers = candidateTrackers
+	}
 
 	readyAuthTrackers, err := ensureCLITrackerAuthBeforeDupeCheckWithLogger(ctx, reader, cfg, req, candidateTrackers, metadataPreview, logger)
 	if err != nil {
@@ -153,14 +287,13 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 	if err != nil {
 		return err
 	}
-	var approved, ignoreDupesFor, ruleOverrides []string
-	if req.Options.Debug || req.Options.DryRun {
+	var approved, ignoreDupesFor []string
+	if currentOpts.Debug {
 		resultByTracker := mapDupeResultsByTracker(dupeSummary)
 		printUnattendedDupeReviewSummary(resultByTracker, candidateTrackers)
-		approved = debugDryRunApprovedTrackers(resultByTracker, candidateTrackers)
-		ignoreDupesFor = appendTrackerRemovals(nil, approved...)
+		approved = debugApprovedTrackers(resultByTracker, candidateTrackers)
 	} else {
-		approved, ignoreDupesFor, ruleOverrides, err = promptTrackerDupeReview(reader, dupeSummary, req, candidateTrackers, nil)
+		approved, ignoreDupesFor, err = promptTrackerDupeReview(reader, dupeSummary, req, candidateTrackers, nil)
 		if err != nil {
 			return err
 		}
@@ -173,13 +306,14 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 	req.Trackers = approved
 	req.TrackersRemove = appendTrackerRemovals(req.TrackersRemove, unselectedTrackers(candidateTrackers, approved)...)
 	req.IgnoreDupesFor = ignoreDupesFor
-	req.IgnoreTrackerRuleFailuresFor = ruleOverrides
 
 	if req.DoubleDupeCheck && len(approved) > 0 {
-		approved, err = runDoubleDupeCheck(ctx, reader, coreSvc, req, approved)
+		var recheckSummary api.DupeCheckSummary
+		approved, recheckSummary, err = runDoubleDupeCheck(ctx, reader, coreSvc, req, approved, currentOpts.Debug)
 		if err != nil {
 			return err
 		}
+		dupeSummary = recheckSummary
 		req.IgnoreDupesFor = appendTrackerRemovals(req.IgnoreDupesFor, approved...)
 		req.Trackers = approved
 		req.TrackersRemove = appendTrackerRemovals(req.TrackersRemove, unselectedTrackers(candidateTrackers, approved)...)
@@ -189,22 +323,52 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 		return nil
 	}
 
-	if req.Options.Debug || !req.Options.DryRun {
-		if err := runCLIScreenshotHandling(ctx, coreSvc, req); err != nil {
-			return err
-		}
+	if err := runCLIScreenshotHandling(ctx, coreSvc, req); err != nil {
+		return err
 	}
 	if err := prepareCLIImages(ctx, coreSvc, req, logger, false); err != nil {
 		return err
 	}
 
+	if currentOpts.Debug {
+		preview, err := runAcceptedCLIDebugDryRun(ctx, coreSvc, req, metadataPreview.Release, dupeSummary, true)
+		if err != nil {
+			return wrapUpbrrError(err)
+		}
+		review := cliReviewFromDryRunPreview(preview)
+		questionnaireAnswers, questionnaireChanged, err := promptTrackerQuestionnaires(reader, review, currentOpts)
+		if err != nil {
+			return err
+		}
+		if questionnaireChanged || len(questionnaireAnswers) > 0 {
+			req.TrackerQuestionnaireAnswers = questionnaireAnswers
+		}
+		if questionnaireChanged {
+			preview, err = runAcceptedCLIDebugDryRun(ctx, coreSvc, req, metadataPreview.Release, dupeSummary, true)
+			if err != nil {
+				return wrapUpbrrError(err)
+			}
+			review = cliReviewFromDryRunPreview(preview)
+		}
+		req, err = maybeEditCLIDescriptions(ctx, coreSvc, reader, req, review, currentOpts)
+		if err != nil {
+			return err
+		}
+		preview, err = runAcceptedCLIDebugDryRun(ctx, coreSvc, req, metadataPreview.Release, dupeSummary, false)
+		if err != nil {
+			return wrapUpbrrError(err)
+		}
+		printDebugTrackerDryRun(preview)
+		return nil
+	}
+
 	review, err := coreSvc.BuildUploadReview(ctx, req)
 	if err != nil {
 		return fmt.Errorf("upbrr: %w", err)
 	}
 
 	// Apply questionnaire answers before description editing and upload. When
-	// answers change, rebuild the review so printed dry-run/debug state matches
+	// answers change, rebuild the review so printed tracker-preview state matches
 	// the request that will be uploaded.
 	questionnaireAnswers, questionnaireChanged, err := promptTrackerQuestionnaires(reader, review, currentOpts)
 	if err != nil {
@@ -220,7 +384,7 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 		}
 	}
 
-	req, review, err = maybeEditCLIDescriptions(ctx, coreSvc, reader, req, review, currentOpts)
+	req, err = maybeEditCLIDescriptions(ctx, coreSvc, reader, req, review, currentOpts)
 	if err != nil {
 		return err
 	}
@@ -230,19 +394,78 @@ func runInteractiveCLIPathWithInputAndLogger(ctx context.Context, coreSvc api.Co
 		req.TrackerQuestionnaireAnswers = questionnaireAnswers
 	}
 
-	if req.Options.Debug {
-		printDebugUploadReview(review)
-		_, err = coreSvc.RunUploadPrepared(ctx, req)
-		return wrapUpbrrError(err)
+	_, err = coreSvc.RunUploadPrepared(ctx, req)
+	return wrapUpbrrError(err)
+}
+
+func runAcceptedCLIDebugDryRun(
+	ctx context.Context,
+	coreSvc cliAcceptedTrackerDryRunRunner,
+	req api.Request,
+	release api.ReleaseRef,
+	dupeSummary api.DupeCheckSummary,
+	previewOnly bool,
+) (api.TrackerDryRunPreview, error) {
+	input := api.TrackerDryRunInput{
+		Release:                release,
+		Trackers:               append([]string(nil), req.Trackers...),
+		IgnoreDupesFor:         append([]string(nil), req.IgnoreDupesFor...),
+		QuestionnaireAnswers:   cloneCLIQuestionnaireAnswers(req.TrackerQuestionnaireAnswers),
+		DescriptionGroups:      api.CloneDescriptionBuilderGroups(req.DescriptionGroups),
+		TrackerIDOverrides:     maps.Clone(req.TrackerIDOverrides),
+		TrackerConfigOverrides: req.TrackerConfigOverrides,
+		TrackerSiteOverrides:   req.TrackerSiteOverrides,
+		ClientOverrides:        req.ClientOverrides,
+		ImageHostOverrides:     req.ImageHostOverrides,
+		ScreenshotOverrides:    req.ScreenshotOverrides,
+		TorrentOverrides:       req.TorrentOverrides,
+		Options:                req.Options,
+	}
+	if previewOnly {
+		input.Options.NoSeed = true
+	}
+	preview, err := coreSvc.RunAcceptedTrackerDryRun(ctx, api.TrackerDryRunPlan{
+		Input:     input,
+		Duplicate: api.NewAcceptedDuplicateEvidence(release, input.Trackers, dupeSummary),
+	})
+	if err != nil {
+		return api.TrackerDryRunPreview{}, fmt.Errorf("run accepted tracker debug: %w", err)
+	}
+	return preview, nil
+}
+
+func cloneCLIQuestionnaireAnswers(source map[string]map[string]string) map[string]map[string]string {
+	if source == nil {
+		return nil
 	}
-	if req.Options.DryRun {
-		printDryRunUploadReview(review, req)
-		_, err = coreSvc.RunUploadPrepared(ctx, req)
-		return wrapUpbrrError(err)
+	cloned := make(map[string]map[string]string, len(source))
+	for tracker, answers := range source {
+		cloned[tracker] = maps.Clone(answers)
 	}
+	return cloned
+}
 
-	_, err = coreSvc.RunUploadPrepared(ctx, req)
-	return wrapUpbrrError(err)
+func cliReviewFromDryRunPreview(preview api.TrackerDryRunPreview) api.UploadReview {
+	review := api.UploadReview{SourcePath: preview.SourcePath, Trackers: make([]api.TrackerReview, 0, len(preview.Trackers))}
+	for _, entry := range preview.Trackers {
+		ruleFailures := make([]api.RuleFailure, 0, len(entry.Diagnostics.RuleDecisions))
+		for _, decision := range entry.Diagnostics.RuleDecisions {
+			ruleFailures = append(ruleFailures, api.RuleFailure{
+				Rule:        decision.Rule,
+				Reason:      decision.Reason,
+				Disposition: decision.Disposition,
+			})
+		}
+		review.Trackers = append(review.Trackers, api.TrackerReview{
+			Tracker:       entry.Tracker,
+			Banned:        entry.Banned,
+			BannedReason:  entry.BannedReason,
+			RuleFailures:  ruleFailures,
+			DryRun:        entry,
+			Questionnaire: entry.Questionnaire,
+		})
+	}
+	return review
 }
 
 func resolvedCLIMetadataSourcePath(input string, preview api.MetadataPreview) string {
@@ -252,15 +475,22 @@ func resolvedCLIMetadataSourcePath(input string, preview api.MetadataPreview) st
 	return input
 }
 
-func resolveCLIUploadTrackers(visited map[string]bool, req api.Request, preview api.MetadataPreview, cfg config.Config) ([]string, []string) {
+func resolveCLIUploadTrackers(
+	visited map[string]bool,
+	req api.Request,
+	preview api.MetadataPreview,
+	cfg config.Config,
+	registry *trackers.Registry,
+	debug bool,
+) ([]string, []string) {
 	remove := append([]string{}, req.TrackersRemove...)
-	if !req.Options.Debug && !req.Options.DryRun {
+	if !debug {
 		remove = append(remove, matchedPreviewTrackers(preview)...)
 	}
-	removalBase := trackers.ResolveTrackersWithDefaults(cfg, req.Trackers, remove, api.NopLogger{})
+	removalBase := trackers.ResolveTrackersWithDefaultsAndRegistry(cfg, req.Trackers, remove, api.NopLogger{}, registry)
 	available := removalBase
 	if visited["trackers"] || req.Execution.SiteUploadTracker != "" {
-		available = trackers.ResolveTrackers(cfg, req.Trackers, remove, api.NopLogger{})
+		available = trackers.ResolveTrackersWithRegistry(cfg, req.Trackers, remove, api.NopLogger{}, registry)
 	}
 	return available, removalBase
 }
@@ -283,22 +513,58 @@ func trackerRuleFailuresForPreview(preview api.MetadataPreview, tracker string)
 	return nil
 }
 
-// cliTrackerRuleFailuresIgnored reports whether a preview rule failure should
-// be bypassed for a tracker, using the global flag or a per-tracker override.
-func cliTrackerRuleFailuresIgnored(req api.Request, tracker string) bool {
-	if req.IgnoreTrackerRuleFailures {
-		return true
-	}
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" {
-		return false
-	}
-	for _, allowed := range req.IgnoreTrackerRuleFailuresFor {
-		if strings.EqualFold(strings.TrimSpace(allowed), name) {
-			return true
+// promptTrackerRuleReview applies strict rule blocks and records exact
+// authorizations for current waivable failures before auth and duplicate work.
+func promptTrackerRuleReview(
+	reader *bufio.Reader,
+	req api.Request,
+	trackerNames []string,
+	preview api.MetadataPreview,
+) ([]string, []api.RuleAuthorization, error) {
+	approved := make([]string, 0, len(trackerNames))
+	authorizations := make([]api.RuleAuthorization, 0)
+	for _, tracker := range trackerNames {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if name == "" {
+			continue
+		}
+		assessment, err := trackers.AssessRuleFailures(name, trackerRuleFailuresForPreview(preview, name), nil)
+		if err != nil {
+			return nil, nil, fmt.Errorf("upbrr: assess %s rules: %w", name, err)
+		}
+		if len(assessment.Failures) == 0 {
+			approved = append(approved, name)
+			continue
 		}
+		fmt.Printf("\n[%s Rules]\n", name)
+		printRuleFailures(assessment.Failures)
+		if len(assessment.Strict) > 0 {
+			fmt.Println("Strict rule failure: upload disabled for this tracker.")
+			continue
+		}
+		if len(assessment.Waivable) == 0 {
+			approved = append(approved, name)
+			continue
+		}
+		if isUnattendedNoConfirm(req) {
+			fmt.Printf("Unattended upload blocked for %s: waivable rule authorization required.\n", name)
+			continue
+		}
+		allow, err := promptYesNo(reader, fmt.Sprintf("Authorize current waivable rule failures for %s?", name), false)
+		if err != nil {
+			return nil, nil, err
+		}
+		if !allow {
+			continue
+		}
+		rules := make([]string, 0, len(assessment.Waivable))
+		for _, failure := range assessment.Waivable {
+			rules = append(rules, failure.Rule)
+		}
+		authorizations = append(authorizations, api.RuleAuthorization{Tracker: name, Rules: rules})
+		approved = append(approved, name)
 	}
-	return false
+	return approved, authorizations, nil
 }
 
 // removeUnreadyCLIAuthTrackers keeps only trackers marked ready to continue
@@ -331,7 +597,15 @@ func removeUnreadyCLIAuthTrackers(candidateTrackers []string, readyTrackers []st
 
 // ensureCLITrackerAuthBeforeDupeCheckWithLogger validates tracker auth using a
 // service that shares the CLI logger for service-level and CLI decision logs.
-func ensureCLITrackerAuthBeforeDupeCheckWithLogger(ctx context.Context, reader *bufio.Reader, cfg config.Config, req api.Request, trackerNames []string, preview api.MetadataPreview, logger api.Logger) ([]string, error) {
+func ensureCLITrackerAuthBeforeDupeCheckWithLogger(
+	ctx context.Context,
+	reader *bufio.Reader,
+	cfg config.Config,
+	req api.Request,
+	trackerNames []string,
+	preview api.MetadataPreview,
+	logger api.Logger,
+) ([]string, error) {
 	if len(trackerNames) == 0 {
 		return trackerNames, nil
 	}
@@ -341,16 +615,29 @@ func ensureCLITrackerAuthBeforeDupeCheckWithLogger(ctx context.Context, reader *
 
 // ensureCLITrackerAuthBeforeDupeCheckWithService is the injectable form of
 // ensureCLITrackerAuthBeforeDupeCheck used by tests.
-func ensureCLITrackerAuthBeforeDupeCheckWithService(ctx context.Context, reader *bufio.Reader, authSvc cliTrackerAuthService, req api.Request, trackerNames []string) ([]string, error) {
+func ensureCLITrackerAuthBeforeDupeCheckWithService(
+	ctx context.Context,
+	reader *bufio.Reader,
+	authSvc cliTrackerAuthService,
+	req api.Request,
+	trackerNames []string,
+) ([]string, error) {
 	return ensureCLITrackerAuthBeforeDupeCheckWithServiceAndLogger(ctx, reader, authSvc, req, trackerNames, api.MetadataPreview{}, api.NopLogger{})
 }
 
 // ensureCLITrackerAuthBeforeDupeCheckWithServiceAndLogger applies CLI-specific
 // keep/skip behavior and logs redacted outcomes for managed-auth trackers.
-// Preview rule failures suppress managed-auth checks only after capability
-// classification and leave those managed trackers out of the ready result, so
-// static API-key/passkey trackers stay quiet here.
-func ensureCLITrackerAuthBeforeDupeCheckWithServiceAndLogger(ctx context.Context, reader *bufio.Reader, authSvc cliTrackerAuthService, req api.Request, trackerNames []string, preview api.MetadataPreview, logger api.Logger) ([]string, error) {
+// Rule findings do not suppress auth diagnostics; static API-key/passkey
+// trackers remain outside managed-auth validation.
+func ensureCLITrackerAuthBeforeDupeCheckWithServiceAndLogger(
+	ctx context.Context,
+	reader *bufio.Reader,
+	authSvc cliTrackerAuthService,
+	req api.Request,
+	trackerNames []string,
+	_ api.MetadataPreview,
+	logger api.Logger,
+) ([]string, error) {
 	logger = cliAuthLogger(logger)
 
 	capabilities, err := authSvc.Capabilities(ctx)
@@ -383,10 +670,6 @@ func ensureCLITrackerAuthBeforeDupeCheckWithServiceAndLogger(ctx context.Context
 			readyByTracker[name] = struct{}{}
 			continue
 		}
-		if !cliTrackerRuleFailuresIgnored(req, name) && api.HasBlockingRuleFailures(trackerRuleFailuresForPreview(preview, name)) {
-			logger.Debugf("cli auth: tracker=%s skipped before auth due to rule failure", name)
-			continue
-		}
 		authCheckTrackers = append(authCheckTrackers, name)
 	}
 
@@ -444,7 +727,15 @@ func cliTrackerAuthApplies(capability api.TrackerAuthCapability) bool {
 
 // handleCLITrackerAuthStatusWithLogger converts one auth status into a CLI
 // decision and logs blocked, prompt, and skip outcomes without secret material.
-func handleCLITrackerAuthStatusWithLogger(ctx context.Context, reader *bufio.Reader, authSvc cliTrackerAuthService, capability api.TrackerAuthCapability, status api.TrackerAuthStatus, req api.Request, logger api.Logger) (api.TrackerAuthStatus, bool, error) {
+func handleCLITrackerAuthStatusWithLogger(
+	ctx context.Context,
+	reader *bufio.Reader,
+	authSvc cliTrackerAuthService,
+	capability api.TrackerAuthCapability,
+	status api.TrackerAuthStatus,
+	req api.Request,
+	logger api.Logger,
+) (api.TrackerAuthStatus, bool, error) {
 	logger = cliAuthLogger(logger)
 	if cliTrackerAuthReady(status) {
 		return status, true, nil
@@ -457,7 +748,10 @@ func handleCLITrackerAuthStatusWithLogger(ctx context.Context, reader *bufio.Rea
 	if status.Needs2FA && strings.TrimSpace(status.ChallengeID) != "" {
 		if isUnattendedNoConfirm(req) {
 			logger.Warnf("cli auth: tracker=%s decision=blocked reason=2fa_required unattended=true", trackerID)
-			return status, false, fmt.Errorf("upbrr: unattended no-prompt tracker auth %s requires manual 2FA code before dupe check; run without --unattended or use --unattended_confirm to enter 2FA", trackerID)
+			return status, false, fmt.Errorf(
+				"upbrr: unattended no-prompt tracker auth %s requires manual 2FA code before dupe check; run without --unattended or use --unattended_confirm to enter 2FA",
+				trackerID,
+			)
 		}
 		logger.Infof("cli auth: tracker=%s decision=prompt_2fa", trackerID)
 		return promptCLITrackerAuth2FAWithLogger(ctx, reader, authSvc, trackerID, status, logger)
@@ -474,7 +768,14 @@ func handleCLITrackerAuthStatusWithLogger(ctx context.Context, reader *bufio.Rea
 
 // promptCLITrackerAuth2FAWithLogger prompts for manual 2FA and logs only the
 // submitted outcome; it never logs codes or challenge identifiers.
-func promptCLITrackerAuth2FAWithLogger(ctx context.Context, reader *bufio.Reader, authSvc cliTrackerAuthService, trackerID string, status api.TrackerAuthStatus, logger api.Logger) (api.TrackerAuthStatus, bool, error) {
+func promptCLITrackerAuth2FAWithLogger(
+	ctx context.Context,
+	reader *bufio.Reader,
+	authSvc cliTrackerAuthService,
+	trackerID string,
+	status api.TrackerAuthStatus,
+	logger api.Logger,
+) (api.TrackerAuthStatus, bool, error) {
 	logger = cliAuthLogger(logger)
 	for {
 		fmt.Printf("\n[%s Auth]\n%s\n", trackerID, cliTrackerAuthStatusMessage(status))
@@ -574,7 +875,7 @@ func cliTrackerAuthReady(status api.TrackerAuthStatus) bool {
 
 // cliTrackerAuthStatusMessage renders the tracker auth status display contract:
 // Message is the stable summary and LastError is redacted detail displayed when
-// distinct, matching GUI/web auth cards.
+// distinct, matching WebUI auth cards.
 func cliTrackerAuthStatusMessage(status api.TrackerAuthStatus) string {
 	message := cliTrackerAuthDisplayField(status.Message)
 	detail := cliTrackerAuthDisplayField(status.LastError)
@@ -673,23 +974,7 @@ func appendTrackerRemovals(existing []string, extra ...string) []string {
 	return merged
 }
 
-func runCLIDupeCheck(ctx context.Context, coreSvc api.Core, req api.Request) (api.DupeCheckSummary, error) {
-	if req.SkipDupeCheck {
-		results := make([]api.DupeCheckResult, 0, len(req.Trackers))
-		for _, tracker := range req.Trackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name == "" {
-				continue
-			}
-			results = append(results, api.DupeCheckResult{
-				Tracker:    name,
-				Skipped:    true,
-				Status:     "skipped",
-				SkipReason: "dupe check skipped",
-			})
-		}
-		return api.DupeCheckSummary{Results: results}, nil
-	}
+func runCLIDupeCheck(ctx context.Context, coreSvc cliDupeChecker, req api.Request) (api.DupeCheckSummary, error) {
 	summary, err := coreSvc.CheckDupes(ctx, req)
 	if err != nil {
 		return api.DupeCheckSummary{}, fmt.Errorf("upbrr: %w", err)
@@ -697,14 +982,19 @@ func runCLIDupeCheck(ctx context.Context, coreSvc api.Core, req api.Request) (ap
 	return summary, nil
 }
 
-func promptTrackerDupeReview(reader *bufio.Reader, summary api.DupeCheckSummary, req api.Request, trackers []string, namePreview map[string]api.TrackerDryRunEntry) ([]string, []string, []string, error) {
+func promptTrackerDupeReview(
+	reader *bufio.Reader,
+	summary api.DupeCheckSummary,
+	req api.Request,
+	trackers []string,
+	namePreview map[string]api.TrackerDryRunEntry,
+) ([]string, []string, error) {
 	resultByTracker := mapDupeResultsByTracker(summary)
 	approved := make([]string, 0, len(trackers))
 	ignoreDupesFor := make([]string, 0)
-	ruleOverrides := make([]string, 0)
 	if isUnattendedNoConfirm(req) {
 		approved = append(approved, printUnattendedDupeReviewSummary(resultByTracker, trackers)...)
-		return approved, ignoreDupesFor, ruleOverrides, nil
+		return approved, ignoreDupesFor, nil
 	}
 
 	for _, tracker := range trackers {
@@ -732,7 +1022,7 @@ func promptTrackerDupeReview(reader *bufio.Reader, summary api.DupeCheckSummary,
 		}
 		allow, err := promptYesNo(reader, prompt, false)
 		if err != nil {
-			return nil, nil, nil, err
+			return nil, nil, err
 		}
 		if !allow {
 			continue
@@ -740,12 +1030,9 @@ func promptTrackerDupeReview(reader *bufio.Reader, summary api.DupeCheckSummary,
 		approved = append(approved, name)
 		if blocked {
 			ignoreDupesFor = append(ignoreDupesFor, name)
-			if result.Skipped || strings.Contains(strings.ToLower(result.SkipReason), "rule") || strings.Contains(strings.ToLower(result.Error), "rule") {
-				ruleOverrides = append(ruleOverrides, name)
-			}
 		}
 	}
-	return approved, ignoreDupesFor, ruleOverrides, nil
+	return approved, ignoreDupesFor, nil
 }
 
 type unattendedDupeReviewBlock struct {
@@ -800,37 +1087,20 @@ func printUnattendedDupeReviewSummary(resultByTracker map[string]api.DupeCheckRe
 	return approved
 }
 
-// debugDryRunApprovedTrackers keeps duplicate-hit trackers eligible for
-// debug/dry-run processing while preserving rule failures as terminal skips.
-func debugDryRunApprovedTrackers(resultByTracker map[string]api.DupeCheckResult, trackers []string) []string {
+// debugApprovedTrackers keeps every selected tracker eligible for payload
+// inspection without creating a duplicate override or waiver.
+func debugApprovedTrackers(_ map[string]api.DupeCheckResult, trackers []string) []string {
 	approved := make([]string, 0, len(trackers))
 	for _, tracker := range trackers {
 		name := strings.ToUpper(strings.TrimSpace(tracker))
 		if name == "" {
 			continue
 		}
-		if result, ok := resultByTracker[name]; ok && isRuleSkippedDupeResult(result) {
-			continue
-		}
 		approved = append(approved, name)
 	}
 	return approved
 }
 
-// isRuleSkippedDupeResult reports whether a skipped dupe result came from
-// tracker rule validation. These skips remain terminal even in debug/dry-run.
-func isRuleSkippedDupeResult(result api.DupeCheckResult) bool {
-	if !result.Skipped {
-		return false
-	}
-	for _, rule := range result.SkipRules {
-		if strings.TrimSpace(rule) != "" {
-			return true
-		}
-	}
-	return false
-}
-
 // dupeReviewBlockReason returns the operator-facing reason for a blocked dupe
 // review result, preferring structured skip/error fields over display notes.
 func dupeReviewBlockReason(result api.DupeCheckResult) string {
@@ -840,15 +1110,13 @@ func dupeReviewBlockReason(result api.DupeCheckResult) string {
 	if reason := strings.TrimSpace(result.Error); reason != "" {
 		return reason
 	}
-	if len(result.Notes) > 0 {
-		for _, note := range result.Notes {
-			note = strings.TrimSpace(note)
-			if note != "" {
-				return strings.TrimPrefix(note, "skip: ")
-			}
-		}
+	if code := strings.TrimSpace(result.SkipCode); code != "" {
+		return "duplicate search not run (" + code + ")"
 	}
-	return "skipped"
+	if strings.EqualFold(strings.TrimSpace(result.Status), "failed") {
+		return "duplicate search failed"
+	}
+	return "duplicate search not run"
 }
 
 // unattendedDupeSkipReasonLines groups skipped tracker names by exact reason so
@@ -898,19 +1166,12 @@ func buildTrackerUploadPrompt(tracker string, blocked bool, dryRun api.TrackerDr
 func mapDupeResultsByTracker(summary api.DupeCheckSummary) map[string]api.DupeCheckResult {
 	mapped := make(map[string]api.DupeCheckResult, len(summary.Results))
 	for _, result := range summary.Results {
-		trackers := splitCSV(strings.ReplaceAll(result.Tracker, ", ", ","))
-		if len(trackers) == 0 {
-			trackers = []string{result.Tracker}
-		}
-		for _, tracker := range trackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name == "" {
-				continue
-			}
-			copyResult := result
-			copyResult.Tracker = name
-			mapped[name] = copyResult
+		name := strings.ToUpper(strings.TrimSpace(result.Tracker))
+		if name == "" {
+			continue
 		}
+		result.Tracker = name
+		mapped[name] = result
 	}
 	return mapped
 }
@@ -925,30 +1186,18 @@ func dupeResultNeedsConfirmation(result api.DupeCheckResult, hasResult bool) boo
 	if result.HasDupes || result.Skipped {
 		return true
 	}
-	if strings.EqualFold(strings.TrimSpace(result.Status), "failed") {
-		return true
-	}
-	return strings.TrimSpace(result.Error) != ""
+	return strings.EqualFold(strings.TrimSpace(result.Status), "failed")
 }
 
 func dupeResultSkipsPrompt(result api.DupeCheckResult) bool {
-	return isPathedTorrentDupeResult(result)
-}
-
-func isPathedTorrentDupeResult(result api.DupeCheckResult) bool {
-	for _, note := range result.Notes {
-		if strings.EqualFold(strings.TrimSpace(note), "pathed torrent match found; skipping dupe search") {
-			return true
-		}
-	}
-	return false
+	return result.HasDupes && strings.EqualFold(strings.TrimSpace(result.Match.MatchedReason), "in_client")
 }
 
 func isUserRequestedDupeSkipResult(result api.DupeCheckResult) bool {
-	return result.Skipped && strings.EqualFold(strings.TrimSpace(result.SkipReason), "dupe check skipped")
+	return result.Skipped && strings.EqualFold(strings.TrimSpace(result.SkipCode), "user_requested")
 }
 
-func runCLIScreenshotHandling(ctx context.Context, coreSvc api.Core, req api.Request) error {
+func runCLIScreenshotHandling(ctx context.Context, coreSvc cliScreenshotCore, req api.Request) error {
 	plan, err := coreSvc.FetchScreenshotPlan(ctx, req)
 	if err != nil {
 		return fmt.Errorf("upbrr: screenshot plan: %w", err)
@@ -1058,17 +1307,33 @@ func formatScreenshotErrors(errorsList []api.ScreenshotError) string {
 	return strings.Join(parts, "; ")
 }
 
-func runSiteCheckCLIPath(ctx context.Context, coreSvc api.Core, opts cliOptions, visited map[string]bool, sourcePath string, screens int) error {
+// runSiteCheckCLIPath adapts a plain path to the source-scoped site-check item workflow.
+func runSiteCheckCLIPath(ctx context.Context, coreSvc cliSiteCheckCore, opts cliOptions, visited map[string]bool, sourcePath string, screens int) error {
+	return runSiteCheckCLIItem(ctx, coreSvc, opts, visited, cliPreparationItem{originalPath: sourcePath, resolvedPath: sourcePath}, screens)
+}
+
+// runSiteCheckCLIItem prepares and reviews one source while preserving its
+// playlist instruction and original display path.
+func runSiteCheckCLIItem(
+	ctx context.Context,
+	coreSvc cliSiteCheckCore,
+	opts cliOptions,
+	visited map[string]bool,
+	item cliPreparationItem,
+	screens int,
+) error {
+	sourcePath := item.originalPath
 	req, err := buildCLIRequest(opts, visited, []string{sourcePath}, screens)
 	if err != nil {
 		return err
 	}
+	req.PlaylistInstruction = cloneCLIPlaylistInstruction(item.playlistInstruction)
 
 	preview, err := coreSvc.FetchMetadataPreview(ctx, req)
 	if err != nil {
 		return fmt.Errorf("upbrr: %w", err)
 	}
-	req.Paths = []string{resolvedCLIMetadataSourcePath(sourcePath, preview)}
+	req.SourcePath = resolvedCLIMetadataSourcePath(sourcePath, preview)
 	review, err := coreSvc.BuildUploadReview(ctx, req)
 	if err != nil {
 		return fmt.Errorf("upbrr: %w", err)
@@ -1100,7 +1365,8 @@ func promptTrackerQuestionnaires(reader *bufio.Reader, review api.UploadReview,
 	answers := make(map[string]map[string]string)
 	changed := false
 	for _, tracker := range review.Trackers {
-		if tracker.Banned || api.HasBlockingRuleFailures(tracker.RuleFailures) || tracker.Questionnaire == nil || len(tracker.Questionnaire.Fields) == 0 {
+		if tracker.Banned || api.HasBlockingRuleFailures(tracker.RuleFailures) ||
+			tracker.Questionnaire == nil || len(tracker.Questionnaire.Fields) == 0 {
 			continue
 		}
 		trackerKey := strings.ToUpper(strings.TrimSpace(tracker.Tracker))
@@ -1114,11 +1380,19 @@ func promptTrackerQuestionnaires(reader *bufio.Reader, review api.UploadReview,
 			if opts.Unattended && !opts.UnattendedConfirm {
 				if field.Required && defaultValue == "" {
 					if opts.Debug {
-						fmt.Printf("Debug mode: %s questionnaire value missing for %s; continuing without prompt.\n", questionnaireFieldLabel(field), tracker.Tracker)
+						fmt.Printf(
+							"Debug mode: %s questionnaire value missing for %s; continuing without prompt.\n",
+							questionnaireFieldLabel(field),
+							tracker.Tracker,
+						)
 						values[field.Key] = ""
 						continue
 					}
-					return nil, false, fmt.Errorf("upbrr: unattended upload requires %s questionnaire value for %s", questionnaireFieldLabel(field), tracker.Tracker)
+					return nil, false, fmt.Errorf(
+						"upbrr: unattended upload requires %s questionnaire value for %s",
+						questionnaireFieldLabel(field),
+						tracker.Tracker,
+					)
 				}
 				values[field.Key] = defaultValue
 				continue
@@ -1160,12 +1434,19 @@ func questionnaireFieldLabel(field api.TrackerQuestionnaireField) string {
 	return strings.TrimSpace(field.Key)
 }
 
-func runDoubleDupeCheck(ctx context.Context, reader *bufio.Reader, coreSvc api.Core, req api.Request, trackers []string) ([]string, error) {
+func runDoubleDupeCheck(
+	ctx context.Context,
+	reader *bufio.Reader,
+	coreSvc cliDupeChecker,
+	req api.Request,
+	trackers []string,
+	debug bool,
+) ([]string, api.DupeCheckSummary, error) {
 	recheckReq := req
 	recheckReq.Trackers = trackers
 	summary, err := coreSvc.CheckDupes(ctx, recheckReq)
 	if err != nil {
-		return nil, fmt.Errorf("upbrr: %w", err)
+		return nil, api.DupeCheckSummary{}, fmt.Errorf("upbrr: %w", err)
 	}
 
 	resultByTracker := make(map[string]api.DupeCheckResult, len(summary.Results))
@@ -1186,7 +1467,7 @@ func runDoubleDupeCheck(ctx context.Context, reader *bufio.Reader, coreSvc api.C
 		}
 		fmt.Printf("\nDouble dupe check flagged %s:\n", tracker)
 		printDupeResult(result)
-		if req.Options.Debug {
+		if debug {
 			fmt.Printf("Debug mode: keeping %s despite second dupe check.\n", tracker)
 			filtered = append(filtered, tracker)
 			continue
@@ -1197,13 +1478,13 @@ func runDoubleDupeCheck(ctx context.Context, reader *bufio.Reader, coreSvc api.C
 		}
 		upload, err := promptYesNo(reader, fmt.Sprintf("Upload to %s anyway after second dupe check? [y/N]: ", tracker), false)
 		if err != nil {
-			return nil, err
+			return nil, api.DupeCheckSummary{}, err
 		}
 		if upload {
 			filtered = append(filtered, tracker)
 		}
 	}
-	return filtered, nil
+	return filtered, summary, nil
 }
 
 func buildQuestionnairePrompt(field api.TrackerQuestionnaireField) string {
@@ -1241,55 +1522,59 @@ func printMetadataPreview(preview api.MetadataPreview, debug bool) {
 	if preview.TrackerName != "" {
 		fmt.Printf("Tracker data from: %s\n", preview.TrackerName)
 	}
-	printMetadataExternalIDs(preview)
-	if len(preview.ExternalIDCandidates.TMDB) > 0 || len(preview.ExternalIDCandidates.IMDB) > 0 {
+	printMetadataExternalIdentity(preview)
+	if metadataPreviewHasCandidates(preview.Diagnostics) {
 		fmt.Println("Candidate IDs available; use override args if needed.")
 	}
-	if len(preview.Warnings) > 0 {
+	warnings := make([]string, 0)
+	for _, diagnostic := range preview.Diagnostics {
+		if diagnostic.Severity == api.DiagnosticSeverityWarning && strings.TrimSpace(diagnostic.Message) != "" {
+			warnings = append(warnings, diagnostic.Message)
+		}
+	}
+	if len(warnings) > 0 {
 		fmt.Println("Warnings:")
-		for _, warning := range preview.Warnings {
+		for _, warning := range warnings {
 			fmt.Printf("- %s\n", warning)
 		}
 	}
 }
 
-func printMetadataDatabaseInfo(external api.ExternalPreview, preview api.MetadataPreview) {
+func printMetadataDatabaseInfo(external api.ProviderDisplay, _ api.MetadataPreview) {
 	fmt.Println()
 	fmt.Println("Database info")
-	title := strings.TrimSpace(external.Title)
-	if title == "" {
-		title = strings.TrimSpace(preview.ReleaseName)
-	}
-	if title != "" && external.Year != 0 {
-		fmt.Printf("Title: %s (%d)\n", title, external.Year)
-	} else if title != "" {
-		fmt.Printf("Title: %s\n", title)
+	summary := external.Summary
+	if summary.Title != "" && summary.Year != 0 {
+		fmt.Printf("Title: %s (%d)\n", summary.Title, summary.Year)
+	} else if summary.Title != "" {
+		fmt.Printf("Title: %s\n", summary.Title)
 	}
-	if overview := summarizeMetadataText(external.Overview, 260); overview != "" {
+	if overview := summarizeMetadataText(summary.Overview, 260); overview != "" {
 		fmt.Printf("Overview: %s\n", overview)
 	}
-	if genres := strings.TrimSpace(external.Genres); genres != "" {
+	if genres := strings.TrimSpace(summary.Genres); genres != "" {
 		fmt.Printf("Genres: %s\n", genres)
 	}
-	if category := metadataPreviewCategory(external, preview); category != "" {
-		fmt.Printf("Category: %s\n", category)
+	if summary.Category != "" {
+		fmt.Printf("Category: %s\n", strings.ToUpper(summary.Category))
 	}
-	if date := metadataPreviewDate(external); date != "" {
-		fmt.Printf("Date: %s\n", date)
+	if summary.Date != "" {
+		fmt.Printf("Date: %s\n", summary.Date)
 	}
-	if runtime := metadataPreviewRuntime(external); runtime != "" {
-		fmt.Printf("Runtime: %s\n", runtime)
+	if summary.RuntimeMinutes != 0 {
+		fmt.Printf("Runtime: %d min\n", summary.RuntimeMinutes)
 	}
-	if external.Rating != 0 {
-		if external.RatingCount != 0 {
-			fmt.Printf("Rating: %.1f (%d votes)\n", external.Rating, external.RatingCount)
+	if summary.Rating != 0 {
+		if summary.RatingCount != 0 {
+			fmt.Printf("Rating: %.1f (%d votes)\n", summary.Rating, summary.RatingCount)
 		} else {
-			fmt.Printf("Rating: %.1f\n", external.Rating)
+			fmt.Printf("Rating: %.1f\n", summary.Rating)
 		}
 	}
 }
 
-func printMetadataExternalIDs(preview api.MetadataPreview) {
+func printMetadataExternalIdentity(preview api.MetadataPreview) {
+	identity := preview.Identity
 	printedHeader := false
 	printHeader := func() {
 		if printedHeader {
@@ -1299,117 +1584,44 @@ func printMetadataExternalIDs(preview api.MetadataPreview) {
 		fmt.Println("External IDs")
 		printedHeader = true
 	}
-	if preview.ExternalIDs.TMDBID != 0 {
+	if identity.TMDBID != 0 {
 		printHeader()
-		fmt.Printf("TMDB: %s\n", tmdbURL(preview.ExternalIDs.TMDBID, metadataPreviewTMDBCategory(preview)))
+		fmt.Printf("TMDB: %d\n", identity.TMDBID)
 	}
-	if preview.ExternalIDs.IMDBID != 0 {
+	if identity.IMDBID != 0 {
 		printHeader()
-		fmt.Printf("IMDb: https://www.imdb.com/title/tt%07d\n", preview.ExternalIDs.IMDBID)
+		fmt.Printf("IMDb: tt%07d\n", identity.IMDBID)
 	}
-	if preview.ExternalIDs.TVDBID != 0 {
+	if identity.TVDBID != 0 {
 		printHeader()
-		fmt.Printf("TVDB: https://www.thetvdb.com/?id=%d&tab=series\n", preview.ExternalIDs.TVDBID)
+		fmt.Printf("TVDB: %d\n", identity.TVDBID)
 	}
-	if preview.ExternalIDs.TVmazeID != 0 {
+	if identity.TVmazeID != 0 {
 		printHeader()
-		fmt.Printf("TVmaze: https://www.tvmaze.com/shows/%d\n", preview.ExternalIDs.TVmazeID)
+		fmt.Printf("TVmaze: %d\n", identity.TVmazeID)
 	}
-	if preview.ExternalIDs.MALID != 0 {
+	if identity.MALID != 0 {
 		printHeader()
-		fmt.Printf("MAL: https://myanimelist.net/anime/%d\n", preview.ExternalIDs.MALID)
+		fmt.Printf("MAL: %d\n", identity.MALID)
 	}
 }
 
-func primaryMetadataPreview(preview api.MetadataPreview) *api.ExternalPreview {
-	preferred := []string{"tmdb", "tvdb", "imdb", "tvmaze"}
-	for _, provider := range preferred {
-		for i := range preview.ExternalPreview {
-			external := &preview.ExternalPreview[i]
-			if strings.EqualFold(strings.TrimSpace(external.Provider), provider) && metadataPreviewHasDetails(*external) {
-				return external
-			}
-		}
-	}
-	for i := range preview.ExternalPreview {
-		if metadataPreviewHasDetails(preview.ExternalPreview[i]) {
-			return &preview.ExternalPreview[i]
+func primaryMetadataPreview(preview api.MetadataPreview) *api.ProviderDisplay {
+	for index := range preview.Display.Providers {
+		if preview.Display.Providers[index].SummaryAvailable {
+			return &preview.Display.Providers[index]
 		}
 	}
 	return nil
 }
 
-func metadataPreviewHasDetails(external api.ExternalPreview) bool {
-	return strings.TrimSpace(external.Title) != "" ||
-		strings.TrimSpace(external.Overview) != "" ||
-		strings.TrimSpace(external.Genres) != "" ||
-		external.Year != 0 ||
-		external.Rating != 0 ||
-		external.Runtime != 0 ||
-		external.RuntimeMinutes != 0
-}
-
-func metadataPreviewCategory(external api.ExternalPreview, preview api.MetadataPreview) string {
-	if category := strings.TrimSpace(external.Category); category != "" {
-		return strings.ToUpper(category)
-	}
-	if category := strings.TrimSpace(preview.ExternalIDs.Category); category != "" {
-		return strings.ToUpper(category)
-	}
-	if tmdbType := strings.TrimSpace(external.TMDBType); tmdbType != "" {
-		return strings.ToUpper(tmdbType)
-	}
-	if imdbType := strings.TrimSpace(external.IMDBType); imdbType != "" {
-		return strings.ToUpper(imdbType)
-	}
-	return ""
-}
-
-func metadataPreviewDate(external api.ExternalPreview) string {
-	for _, value := range []string{external.ReleaseDate, external.FirstAirDate, external.Premiered} {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func metadataPreviewRuntime(external api.ExternalPreview) string {
-	runtime := external.Runtime
-	if runtime == 0 {
-		runtime = external.RuntimeMinutes
-	}
-	if runtime == 0 {
-		return ""
-	}
-	return fmt.Sprintf("%d min", runtime)
-}
-
-func metadataPreviewTMDBCategory(preview api.MetadataPreview) string {
-	for _, external := range preview.ExternalPreview {
-		if !strings.EqualFold(strings.TrimSpace(external.Provider), "tmdb") {
-			continue
-		}
-		if category := strings.TrimSpace(external.Category); category != "" {
-			return category
-		}
-		if tmdbType := strings.TrimSpace(external.TMDBType); tmdbType != "" {
-			return tmdbType
+func metadataPreviewHasCandidates(diagnostics []api.PreparationDiagnostic) bool {
+	for _, diagnostic := range diagnostics {
+		if len(diagnostic.Candidates) > 0 {
+			return true
 		}
 	}
-	if category := strings.TrimSpace(preview.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return "movie"
-}
-
-func tmdbURL(id int, category string) string {
-	switch strings.ToLower(strings.TrimSpace(category)) {
-	case "tv", "series", "show":
-		return fmt.Sprintf("https://www.themoviedb.org/tv/%d", id)
-	default:
-		return fmt.Sprintf("https://www.themoviedb.org/movie/%d", id)
-	}
+	return false
 }
 
 func summarizeMetadataText(value string, limit int) string {
@@ -1425,9 +1637,13 @@ func summarizeMetadataText(value string, limit int) string {
 }
 
 func printDupeResult(result api.DupeCheckResult) {
-	fmt.Printf("Dupe check status: %s\n", result.Status)
+	writeDupeResult(os.Stdout, result)
+}
+
+func writeDupeResult(w io.Writer, result api.DupeCheckResult) {
+	fmt.Fprintf(w, "Dupe check status: %s\n", result.Status)
 	for _, note := range result.Notes {
-		fmt.Printf("- %s\n", note)
+		fmt.Fprintf(w, "- %s\n", note)
 	}
 	entries := result.Filtered
 	if len(entries) == 0 {
@@ -1441,7 +1657,7 @@ func printDupeResult(result api.DupeCheckResult) {
 		if entry.Link != "" {
 			line += " - " + entry.Link
 		}
-		fmt.Printf("- %s\n", line)
+		fmt.Fprintf(w, "- %s\n", line)
 	}
 }
 
@@ -1470,12 +1686,16 @@ func writeDryRunSummary(w io.Writer, entry api.TrackerDryRunEntry) {
 	if bannedCheckError := strings.TrimSpace(entry.BannedCheckError); bannedCheckError != "" {
 		fmt.Fprintf(w, "Banned group check: %s\n", bannedCheckError)
 	}
+	writeDryRunDiagnostics(w, entry.Diagnostics)
 	if change := trackerReleaseNameChangeLine(entry); change != "" {
 		fmt.Fprintf(w, "Tracker %s\n", change)
 	} else if entry.ReleaseName != "" {
 		fmt.Fprintf(w, "Tracker release name: %s\n", entry.ReleaseName)
 	}
-	if imageMessage := strings.TrimSpace(entry.ImageHost.Message); imageMessage != "" && (entry.ImageHost.Reuploaded || strings.EqualFold(entry.ImageHost.Status, "warning")) {
+	if imageMessage := strings.TrimSpace(
+		entry.ImageHost.Message,
+	); imageMessage != "" &&
+		(entry.ImageHost.Reuploaded || strings.EqualFold(entry.ImageHost.Status, "warning")) {
 		fmt.Fprintf(w, "Images: %s\n", imageMessage)
 	}
 	for _, warning := range entry.ImageHost.Warnings {
@@ -1496,6 +1716,27 @@ func writeDryRunSummary(w io.Writer, entry api.TrackerDryRunEntry) {
 	}
 }
 
+func writeDryRunDiagnostics(w io.Writer, diagnostics api.TrackerDryRunDiagnostics) {
+	for _, decision := range diagnostics.RuleDecisions {
+		disposition := api.NormalizeRuleDisposition(decision.Disposition)
+		fmt.Fprintf(w, "Rule [%s] %s: %s", disposition, decision.Rule, decision.Reason)
+		if decision.Authorized {
+			fmt.Fprint(w, " (authorized)")
+		}
+		fmt.Fprintln(w)
+	}
+	dupe := diagnostics.Duplicate
+	if strings.TrimSpace(dupe.Tracker) != "" || strings.TrimSpace(dupe.Status) != "" || dupe.HasDupes || dupe.Skipped || strings.TrimSpace(dupe.Error) != "" {
+		writeDupeResult(w, dupe)
+	}
+	if len(diagnostics.LiveEligibilityReasons) > 0 {
+		fmt.Fprintln(w, "Live upload blockers:")
+		for _, reason := range diagnostics.LiveEligibilityReasons {
+			fmt.Fprintf(w, "- %s: %s\n", reason.Code, reason.Message)
+		}
+	}
+}
+
 func printDebugUploadReview(review api.UploadReview) {
 	fmt.Printf("\n[Debug Dry Run] %s\n", formatPathLabel(review.SourcePath))
 	for _, group := range groupDebugPayloads(review.Trackers) {
@@ -1504,6 +1745,15 @@ func printDebugUploadReview(review api.UploadReview) {
 	}
 }
 
+// printDebugTrackerDryRun renders the shared dry-run result with CLI debug labels.
+func printDebugTrackerDryRun(preview api.TrackerDryRunPreview) {
+	review := api.UploadReview{SourcePath: preview.SourcePath, Trackers: make([]api.TrackerReview, 0, len(preview.Trackers))}
+	for _, entry := range preview.Trackers {
+		review.Trackers = append(review.Trackers, api.TrackerReview{Tracker: entry.Tracker, DryRun: entry})
+	}
+	printDebugUploadReview(review)
+}
+
 // debugPayloadGroup represents one rendered debug payload body and the trackers
 // that share it.
 type debugPayloadGroup struct {
@@ -1554,35 +1804,36 @@ func debugPayloadTrackerLabel(tracker api.TrackerReview) string {
 	return label
 }
 
-func printDryRunUploadReview(review api.UploadReview, req api.Request) {
-	fmt.Printf("\n[Dry Run] %s\n", formatPathLabel(review.SourcePath))
-	for _, tracker := range review.Trackers {
-		fmt.Printf("\n[%s]\n", tracker.Tracker)
-		if tracker.Banned && !tracker.DryRun.Banned {
-			fmt.Printf("Banned group: %s\n", tracker.BannedReason)
-		}
-		printRuleFailures(tracker.RuleFailures)
-		if !req.SkipDupeCheck && tracker.DupeCheck.HasDupes {
-			printDupeResult(tracker.DupeCheck)
+// printRuleFailures groups strict, waivable, and advisory results for CLI output.
+func printRuleFailures(failures []api.RuleFailure) {
+	strict := make([]api.RuleFailure, 0)
+	waivable := make([]api.RuleFailure, 0)
+	for _, failure := range failures {
+		switch api.NormalizeRuleDisposition(failure.Disposition) {
+		case api.RuleDispositionStrict:
+			strict = append(strict, failure)
+		case api.RuleDispositionWaivable:
+			waivable = append(waivable, failure)
+		case api.RuleDispositionAdvisory:
+		}
+	}
+	if len(strict) > 0 {
+		fmt.Println("Strict rule failures:")
+		for _, failure := range strict {
+			fmt.Printf("- %s: %s\n", failure.Rule, failure.Reason)
 		}
-		printDryRunSummary(tracker.DryRun)
 	}
-}
-
-// printRuleFailures groups blocking results and advisory warnings for CLI output.
-func printRuleFailures(failures []api.RuleFailure) {
-	blocking := api.BlockingRuleFailures(failures)
-	if len(blocking) > 0 {
-		fmt.Println("Rule failures:")
-		for _, failure := range blocking {
+	if len(waivable) > 0 {
+		fmt.Println("Waivable rule failures:")
+		for _, failure := range waivable {
 			fmt.Printf("- %s: %s\n", failure.Rule, failure.Reason)
 		}
 	}
-	warnings := api.WarningRuleFailures(failures)
-	if len(warnings) > 0 {
-		fmt.Println("Rule warnings:")
-		for _, warning := range warnings {
-			fmt.Printf("- %s: %s\n", warning.Rule, warning.Reason)
+	advisories := api.AdvisoryRuleFailures(failures)
+	if len(advisories) > 0 {
+		fmt.Println("Rule advisories:")
+		for _, advisory := range advisories {
+			fmt.Printf("- %s: %s\n", advisory.Rule, advisory.Reason)
 		}
 	}
 }
@@ -1747,7 +1998,19 @@ func payloadIncludesDescription(payload map[string]string) bool {
 
 func isDryRunBodyPayloadField(key string) bool {
 	switch normalizedDryRunPayloadKey(key) {
-	case "description", "desc", "descr", "release_desc", "album_desc", "mediainfo", "mediainfo[]", "media_info", "bdinfo", "bd_info", "techinfo", "technical_info", "technicaldetails":
+	case "description",
+		"desc",
+		"descr",
+		"release_desc",
+		"album_desc",
+		"mediainfo",
+		"mediainfo[]",
+		"media_info",
+		"bdinfo",
+		"bd_info",
+		"techinfo",
+		"technical_info",
+		"technicaldetails":
 		return true
 	default:
 		return false
diff --git a/cmd/upbrr/interactive_test.go b/cmd/upbrr/interactive_test.go
index 901b74a4..d5616c7c 100644
--- a/cmd/upbrr/interactive_test.go
+++ b/cmd/upbrr/interactive_test.go
@@ -11,18 +11,31 @@ import (
 	"maps"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 var errSyntheticDVDMenuCapture = errors.New("synthetic DVD menu capture failure")
 
+func newCLITrackerRegistryForTest(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
 func assertDVDMenuCaptureError(t *testing.T, err error) {
 	t.Helper()
 
@@ -65,7 +78,11 @@ func TestRunInteractiveCLIPathHandlesScreenshotsBeforeReview(t *testing.T) {
 			SuggestedSelections: []api.ScreenshotSelection{{Index: 1, TimestampSeconds: 60}},
 		},
 		screenshotResult: api.ScreenshotResult{
-			Images: []api.ScreenshotImage{{Index: 1, TimestampSeconds: 60, Path: "screen1.png"}},
+			Images: []api.ScreenshotImage{{
+				Index:            1,
+				TimestampSeconds: 60,
+				Path:             "screen1.png",
+			}},
 		},
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
@@ -135,7 +152,7 @@ func TestRunInteractiveCLIPathDVDMenuCaptureFailureStopsBeforeReview(t *testing.
 	}
 }
 
-func TestRunInteractiveCLIPathExplicitDryRunCapturesDVDMenus(t *testing.T) {
+func TestRunInteractiveCLIPathDebugCapturesDVDMenus(t *testing.T) {
 	t.Parallel()
 
 	discRoot := t.TempDir()
@@ -148,14 +165,18 @@ func TestRunInteractiveCLIPathExplicitDryRunCapturesDVDMenus(t *testing.T) {
 		},
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
-	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{Unattended: true, DryRun: true, GetDVDMenus: true}, map[string]bool{}, discRoot, config.Config{
+	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{
+		Unattended:  true,
+		Debug:       true,
+		GetDVDMenus: true,
+	}, map[string]bool{}, discRoot, config.Config{
 		Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
 	})
 	if err != nil {
 		t.Fatalf("runInteractiveCLIPath: %v", err)
 	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,capture-dvd-menus,review" {
-		t.Fatalf("dry-run capture order = %s", got)
+	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,capture-dvd-menus,debug,debug" {
+		t.Fatalf("debug capture order = %s", got)
 	}
 }
 
@@ -207,7 +228,11 @@ func TestRunInteractiveCLIPathDoubleDupeBeforeScreenshotAndReview(t *testing.T)
 			SuggestedSelections: []api.ScreenshotSelection{{Index: 1, TimestampSeconds: 60}},
 		},
 		screenshotResult: api.ScreenshotResult{
-			Images: []api.ScreenshotImage{{Index: 1, TimestampSeconds: 60, Path: "screen1.png"}},
+			Images: []api.ScreenshotImage{{
+				Index:            1,
+				TimestampSeconds: 60,
+				Path:             "screen1.png",
+			}},
 		},
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
@@ -222,7 +247,7 @@ func TestRunInteractiveCLIPathDoubleDupeBeforeScreenshotAndReview(t *testing.T)
 	}
 }
 
-func TestRunInteractiveCLIPathDryRunSkipsScreenshotSideEffects(t *testing.T) {
+func TestRunInteractiveCLIPathDebugRunsScreenshotSideEffects(t *testing.T) {
 	t.Parallel()
 
 	coreSvc := &cliCoreForTest{
@@ -230,38 +255,46 @@ func TestRunInteractiveCLIPathDryRunSkipsScreenshotSideEffects(t *testing.T) {
 			SuggestedSelections: []api.ScreenshotSelection{{Index: 1, TimestampSeconds: 60}},
 		},
 		screenshotResult: api.ScreenshotResult{
-			Images: []api.ScreenshotImage{{Index: 1, TimestampSeconds: 60, Path: "screen1.png"}},
+			Images: []api.ScreenshotImage{{
+				Index:            1,
+				TimestampSeconds: 60,
+				Path:             "screen1.png",
+			}},
 		},
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
-	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{Unattended: true, DryRun: true}, map[string]bool{}, "movie.mkv", config.Config{
+	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{Unattended: true, Debug: true}, map[string]bool{}, "movie.mkv", config.Config{
 		Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
 	})
 	if err != nil {
 		t.Fatalf("runInteractiveCLIPath: %v", err)
 	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,review" {
-		t.Fatalf("expected dry-run to skip screenshot side effects, got %s", got)
+	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,generate-screenshots,save-screenshots,debug,debug" {
+		t.Fatalf("expected debug to prepare screenshots before the dry-run module, got %s", got)
 	}
-	if len(coreSvc.savedFinalImages) != 0 {
-		t.Fatalf("expected dry-run to skip saved screenshots, got %#v", coreSvc.savedFinalImages)
+	if len(coreSvc.savedFinalImages) != 1 {
+		t.Fatalf("expected debug to retain generated screenshots, got %#v", coreSvc.savedFinalImages)
 	}
-	if coreSvc.runUploadPreparedCalls != 1 {
-		t.Fatalf("expected dry-run to run prepared injection path, got %d", coreSvc.runUploadPreparedCalls)
+	if coreSvc.runUploadPreparedCalls != 0 || coreSvc.runTrackerDryRunCalls != 2 {
+		t.Fatalf("expected debug dry-run only, upload=%d debug=%d", coreSvc.runUploadPreparedCalls, coreSvc.runTrackerDryRunCalls)
 	}
 	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
 	if uploadReq.Options.NoSeed {
-		t.Fatalf("expected dry-run prepared upload to preserve no-seed=false, got %#v", uploadReq.Options)
+		t.Fatalf("expected debug request to preserve no-seed=false, got %#v", uploadReq.Options)
 	}
 }
 
-func TestRunInteractiveCLIPathDryRunPreservesExplicitNoSeed(t *testing.T) {
+func TestRunInteractiveCLIPathDebugPreservesExplicitNoSeed(t *testing.T) {
 	t.Parallel()
 
 	coreSvc := &cliCoreForTest{
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
-	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{Unattended: true, DryRun: true, NoSeed: true}, map[string]bool{}, "movie.mkv", config.Config{
+	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{
+		Unattended: true,
+		Debug:      true,
+		NoSeed:     true,
+	}, map[string]bool{}, "movie.mkv", config.Config{
 		Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
 	})
 	if err != nil {
@@ -270,7 +303,7 @@ func TestRunInteractiveCLIPathDryRunPreservesExplicitNoSeed(t *testing.T) {
 
 	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
 	if !uploadReq.Options.NoSeed {
-		t.Fatalf("expected explicit dry-run no-seed to be preserved, got %#v", uploadReq.Options)
+		t.Fatalf("expected explicit debug no-seed to be preserved, got %#v", uploadReq.Options)
 	}
 }
 
@@ -282,7 +315,11 @@ func TestRunInteractiveCLIPathDebugHandlesScreenshotsBeforeReview(t *testing.T)
 			SuggestedSelections: []api.ScreenshotSelection{{Index: 1, TimestampSeconds: 60}},
 		},
 		screenshotResult: api.ScreenshotResult{
-			Images: []api.ScreenshotImage{{Index: 1, TimestampSeconds: 60, Path: "screen1.png"}},
+			Images: []api.ScreenshotImage{{
+				Index:            1,
+				TimestampSeconds: 60,
+				Path:             "screen1.png",
+			}},
 		},
 		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
 	}
@@ -292,14 +329,14 @@ func TestRunInteractiveCLIPathDebugHandlesScreenshotsBeforeReview(t *testing.T)
 	if err != nil {
 		t.Fatalf("runInteractiveCLIPath: %v", err)
 	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,generate-screenshots,save-screenshots,review" {
+	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,generate-screenshots,save-screenshots,debug,debug" {
 		t.Fatalf("expected debug to prepare screenshots before review, got %s", got)
 	}
 	if len(coreSvc.savedFinalImages) != 1 || coreSvc.savedFinalImages[0].Path != "screen1.png" {
 		t.Fatalf("expected debug to save generated final screenshot, got %#v", coreSvc.savedFinalImages)
 	}
-	if coreSvc.runUploadPreparedCalls != 1 {
-		t.Fatalf("expected debug to run prepared injection path, got %d", coreSvc.runUploadPreparedCalls)
+	if coreSvc.runUploadPreparedCalls != 0 || coreSvc.runTrackerDryRunCalls != 2 {
+		t.Fatalf("expected debug dry-run only, upload=%d debug=%d", coreSvc.runUploadPreparedCalls, coreSvc.runTrackerDryRunCalls)
 	}
 	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
 	if uploadReq.Options.NoSeed {
@@ -320,8 +357,18 @@ func TestRunInteractiveCLIPathDebugProcessesNonRuleCheckedTrackers(t *testing.T)
 		}},
 		dupeSummary: api.DupeCheckSummary{
 			Results: []api.DupeCheckResult{
-				{Tracker: "AITHER", Status: "completed", HasDupes: true},
-				{Tracker: "BLU", Status: "skipped", Skipped: true, SkipRules: []string{"require_movie_only"}},
+				{
+					Tracker:  "AITHER",
+					Status:   "completed",
+					HasDupes: true,
+				},
+				{
+					Tracker:    "BLU",
+					Status:     "skipped",
+					Skipped:    true,
+					SkipCode:   "missing_metadata",
+					SkipReason: "missing metadata",
+				},
 				{Tracker: "DP", Status: "completed"},
 			},
 		},
@@ -337,95 +384,33 @@ func TestRunInteractiveCLIPathDebugProcessesNonRuleCheckedTrackers(t *testing.T)
 	if err != nil {
 		t.Fatalf("runInteractiveCLIPath: %v", err)
 	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,review" {
-		t.Fatalf("expected debug to run checks and continue to review, got %s", got)
+	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,screenshot-plan,debug,debug" {
+		t.Fatalf("expected debug to reuse dupe evidence without upload review, got %s", got)
 	}
 	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
-	if got := strings.Join(uploadReq.Trackers, ","); got != "AITHER,DP" {
+	if got := strings.Join(uploadReq.Trackers, ","); got != "AITHER,BLU,DP" {
 		t.Fatalf("expected debug upload to keep all trackers, got %s", got)
 	}
-	if got := strings.Join(uploadReq.IgnoreDupesFor, ","); got != "AITHER,DP" {
-		t.Fatalf("expected debug upload to ignore dupe blocks for non-rule trackers, got %s", got)
+	if got := strings.Join(uploadReq.IgnoreDupesFor, ","); got != "" {
+		t.Fatalf("expected debug upload not to infer duplicate authorization, got %s", got)
 	}
-	if got := strings.Join(uploadReq.IgnoreTrackerRuleFailuresFor, ","); got != "" {
-		t.Fatalf("expected debug upload not to ignore rule blocks, got %s", got)
+	if len(uploadReq.RuleAuthorizations) != 0 {
+		t.Fatalf("expected debug upload not to authorize rule blocks, got %#v", uploadReq.RuleAuthorizations)
 	}
-}
-
-func TestRunInteractiveCLIPathDryRunProcessesNonRuleCheckedTrackers(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &cliCoreForTest{
-		previewResponses: []api.MetadataPreview{{
-			SourcePath: "Example.Release.2026.1080p-GRP",
-			TrackerData: []api.TrackerPreview{{
-				Tracker: "AITHER",
-				Matched: true,
-			}},
-		}},
-		dupeSummary: api.DupeCheckSummary{
-			Results: []api.DupeCheckResult{
-				{Tracker: "AITHER", Status: "completed", HasDupes: true},
-				{Tracker: "BLU", Status: "skipped", Skipped: true, SkipRules: []string{"require_movie_only"}},
-				{Tracker: "DP", Status: "completed"},
-			},
-		},
-		review: api.UploadReview{Trackers: []api.TrackerReview{
-			{Tracker: "AITHER"},
-			{Tracker: "BLU"},
-			{Tracker: "DP"},
-		}},
-	}
-	err := runInteractiveCLIPath(context.Background(), coreSvc, cliOptions{Unattended: true, DryRun: true}, map[string]bool{}, "Example.Release.2026.1080p-GRP", config.Config{
-		Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER", "BLU", "DP"}},
-	})
-	if err != nil {
-		t.Fatalf("runInteractiveCLIPath: %v", err)
-	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,dupes,review" {
-		t.Fatalf("expected dry-run to run dupe check and continue to review, got %s", got)
-	}
-	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
-	if got := strings.Join(uploadReq.Trackers, ","); got != "AITHER,DP" {
-		t.Fatalf("expected dry-run upload to keep all trackers, got %s", got)
-	}
-	if got := strings.Join(uploadReq.IgnoreDupesFor, ","); got != "AITHER,DP" {
-		t.Fatalf("expected dry-run upload to ignore dupe blocks for non-rule trackers, got %s", got)
-	}
-	if got := strings.Join(uploadReq.IgnoreTrackerRuleFailuresFor, ","); got != "" {
-		t.Fatalf("expected dry-run upload not to ignore rule blocks, got %s", got)
-	}
-}
-
-func TestIsRuleSkippedDupeResultUsesSkipRules(t *testing.T) {
-	t.Parallel()
-
-	if !isRuleSkippedDupeResult(api.DupeCheckResult{
-		Tracker:   "BLU",
-		Status:    "skipped",
-		Skipped:   true,
-		SkipRules: []string{"require_movie_only"},
-	}) {
-		t.Fatal("expected structured rule skip to remain terminal")
-	}
-	if isRuleSkippedDupeResult(api.DupeCheckResult{
-		Tracker:    "BLU",
-		Status:     "skipped",
-		Skipped:    true,
-		SkipReason: "rule check failed: category movie is not tv",
-	}) {
-		t.Fatal("expected text-only skip reason not to drive rule classification")
+	if len(coreSvc.dryRunPlans) != 2 {
+		t.Fatalf("accepted dry-run plans = %d, want 2", len(coreSvc.dryRunPlans))
 	}
-	if isRuleSkippedDupeResult(api.DupeCheckResult{
-		Tracker:   "BLU",
-		Status:    "completed",
-		SkipRules: []string{"require_movie_only"},
-	}) {
-		t.Fatal("expected non-skipped result not to be terminal")
+	for _, plan := range coreSvc.dryRunPlans {
+		if plan.Duplicate.Release != plan.Input.Release || plan.Duplicate.Release.Generation != 1 {
+			t.Fatalf("accepted duplicate release = %#v input=%#v", plan.Duplicate.Release, plan.Input.Release)
+		}
+		if len(plan.Duplicate.Results) != len(coreSvc.dupeSummary.Results) {
+			t.Fatalf("accepted duplicate results = %#v", plan.Duplicate.Results)
+		}
 	}
 }
 
-func TestRunInteractiveCLIPathQuestionnaireAnswerRebuildsDryRunReview(t *testing.T) {
+func TestRunInteractiveCLIPathQuestionnaireAnswerRebuildsReviewBeforeDebug(t *testing.T) {
 	coreSvc := &cliCoreForTest{
 		previewResponses: []api.MetadataPreview{{SourcePath: "Example.Release.2026.1080p-GRP"}},
 		dupeSummary: api.DupeCheckSummary{
@@ -450,9 +435,23 @@ func TestRunInteractiveCLIPathQuestionnaireAnswerRebuildsDryRunReview(t *testing
 				},
 			}}},
 		},
+		dryRunPreview: api.TrackerDryRunPreview{
+			SourcePath: "Example.Release.2026.1080p-GRP",
+			Trackers: []api.TrackerDryRunEntry{{
+				Tracker:     "ANT",
+				Status:      "ready",
+				ReleaseName: "Example.Release.2026.S01E01.1080p-GRP",
+				Questionnaire: &api.TrackerQuestionnaire{Fields: []api.TrackerQuestionnaireField{{
+					Key:      "type",
+					Label:    "Type",
+					Value:    "Feature",
+					Required: true,
+				}}},
+			}},
+		},
 	}
 	output := captureStdout(t, func() {
-		err := runInteractiveCLIPathWithInput(context.Background(), coreSvc, cliOptions{DryRun: true, OnlyID: true}, map[string]bool{}, "Example.Release.2026.1080p-GRP", 1, config.Config{
+		err := runInteractiveCLIPathWithInput(context.Background(), coreSvc, cliOptions{Debug: true, OnlyID: true}, map[string]bool{}, "Example.Release.2026.1080p-GRP", 1, config.Config{
 			Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"ANT"}},
 		}, strings.NewReader("y\nEpisode\n"))
 		if err != nil {
@@ -460,16 +459,20 @@ func TestRunInteractiveCLIPathQuestionnaireAnswerRebuildsDryRunReview(t *testing
 		}
 	})
 	reviewCalls := 0
+	dryRunCalls := 0
 	for _, call := range coreSvc.callOrder {
 		if call == "review" {
 			reviewCalls++
 		}
+		if call == "debug" {
+			dryRunCalls++
+		}
 	}
-	if reviewCalls != 2 {
-		t.Fatalf("expected questionnaire answer to rebuild review, got %d review call(s): %#v", reviewCalls, coreSvc.callOrder)
+	if reviewCalls != 0 || dryRunCalls != 3 {
+		t.Fatalf("expected questionnaire answer to rebuild dry-run payloads from retained evidence, review=%d dry_run=%d calls=%#v", reviewCalls, dryRunCalls, coreSvc.callOrder)
 	}
 	if !strings.Contains(output, "Tracker release name: Example.Release.2026.S01E01.1080p-GRP") {
-		t.Fatalf("expected dry-run output to use rebuilt questionnaire-aware review, got %q", output)
+		t.Fatalf("expected debug output to use questionnaire-aware dry run, got %q", output)
 	}
 	uploadReq := coreSvc.requests[len(coreSvc.requests)-1].req
 	if got := uploadReq.TrackerQuestionnaireAnswers["ANT"]["type"]; got != "Episode" {
@@ -502,8 +505,8 @@ func TestRunInteractiveCLIPathUsesResolvedPreviewSourceForPreparedUpload(t *test
 		if call.name == "preview" {
 			continue
 		}
-		if len(call.req.Paths) != 1 || call.req.Paths[0] != expectedPath {
-			t.Fatalf("expected %s to use resolved preview source %q, got %#v", call.name, expectedPath, call.req.Paths)
+		if call.req.SourcePath != expectedPath {
+			t.Fatalf("expected %s to use resolved preview source %q, got %q", call.name, expectedPath, call.req.SourcePath)
 		}
 		if call.req.TorrentOverrides.Rehash == nil || *call.req.TorrentOverrides.Rehash != rehash {
 			t.Fatalf("expected %s to preserve rehash override, got %#v", call.name, call.req.TorrentOverrides.Rehash)
@@ -583,7 +586,7 @@ func TestRunSiteCheckCLIPathSeedsMetadataBeforeReview(t *testing.T) {
 	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,review" {
 		t.Fatalf("expected preview before review, got %s", got)
 	}
-	if len(coreSvc.requests) != 2 || len(coreSvc.requests[1].req.Paths) != 1 || coreSvc.requests[1].req.Paths[0] != filepath.Join("folder", "movie.mkv") {
+	if len(coreSvc.requests) != 2 || coreSvc.requests[1].req.SourcePath != filepath.Join("folder", "movie.mkv") {
 		t.Fatalf("expected site-check review to use resolved preview source, got %#v", coreSvc.requests)
 	}
 }
@@ -668,6 +671,8 @@ func TestResolveCLIUploadTrackersExplicitTrackersSuppressDefaults(t *testing.T)
 		},
 		api.MetadataPreview{},
 		config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER", "BLU"}}},
+		newCLITrackerRegistryForTest(t),
+		false,
 	)
 	if len(selected) != 1 || selected[0] != "BLU" {
 		t.Fatalf("expected explicit BLU selection, got %#v", selected)
@@ -726,14 +731,31 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckValidatesApplicableTrackers(t *testi
 	}
 }
 
-func TestEnsureCLITrackerAuthBeforeDupeCheckLogsRuleFailureSkipOnlyForManagedAuth(t *testing.T) {
+func TestEnsureCLITrackerAuthBeforeDupeCheckDoesNotCoupleRuleDiagnostics(t *testing.T) {
 	t.Parallel()
 
 	authSvc := &cliTrackerAuthForTest{
 		capabilities: []api.TrackerAuthCapability{
-			{TrackerID: "MTV", AuthKind: "api_key_cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true, RequiresAPIKey: true},
-			{TrackerID: "NBL", AuthKind: "api_key", RequiresAPIKey: true},
-			{TrackerID: "PTP", AuthKind: "cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true},
+			{
+				TrackerID:          "MTV",
+				AuthKind:           "api_key_cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+				RequiresAPIKey:     true,
+			},
+			{
+				TrackerID:      "NBL",
+				AuthKind:       "api_key",
+				RequiresAPIKey: true,
+			},
+			{
+				TrackerID:          "PTP",
+				AuthKind:           "cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+			},
 		},
 		validateStatus: map[string]api.TrackerAuthStatus{
 			"PTP": {TrackerID: "PTP", State: trackerauth.StateConfigured},
@@ -748,7 +770,7 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckLogsRuleFailureSkipOnlyForManagedAut
 		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
 		[]string{"MTV", "NBL", "PTP"},
 		api.MetadataPreview{TrackerRuleFailures: map[string][]api.RuleFailure{
-			"MTV": {{Rule: "extra_check", Reason: "managed auth rule failure"}},
+			"MTV": {{Rule: "source_rule", Reason: "managed auth rule failure"}},
 			"NBL": {{Rule: "require_tv_only", Reason: "static api key rule failure"}},
 		}},
 		logger,
@@ -756,29 +778,39 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckLogsRuleFailureSkipOnlyForManagedAut
 	if err != nil {
 		t.Fatalf("ensureCLITrackerAuthBeforeDupeCheck: %v", err)
 	}
-	if strings.Join(got, ",") != "NBL,PTP" {
-		t.Fatalf("expected managed rule-failed tracker removed while static tracker remains eligible, got %#v", got)
+	if strings.Join(got, ",") != "MTV,NBL,PTP" {
+		t.Fatalf("expected rule diagnostics not to remove auth candidates, got %#v", got)
 	}
-	if strings.Join(authSvc.validated, ",") != "PTP" {
-		t.Fatalf("expected only rule-eligible managed auth tracker to validate, got %#v", authSvc.validated)
+	if strings.Join(authSvc.validated, ",") != "MTV,PTP" {
+		t.Fatalf("expected both managed auth trackers to validate, got %#v", authSvc.validated)
 	}
 
 	logs := strings.Join(append(append(append([]string{}, logger.debug...), logger.info...), logger.warn...), "\n")
-	if !strings.Contains(logs, "cli auth: tracker=MTV skipped before auth due to rule failure") {
-		t.Fatal("expected managed auth rule-failure skip log")
-	}
-	if strings.Contains(logs, "tracker=NBL skipped before auth due to rule failure") {
-		t.Fatal("static api-key tracker should not log auth rule-failure skip")
+	if strings.Contains(logs, "skipped before auth due to rule failure") {
+		t.Fatal("rule diagnostics must not suppress or relabel auth validation")
 	}
 }
 
-func TestEnsureCLITrackerAuthBeforeDupeCheckDryRunSkipsRuleFailedManagedAuth(t *testing.T) {
+func TestEnsureCLITrackerAuthBeforeDupeCheckValidatesRuleFailedManagedAuth(t *testing.T) {
 	t.Parallel()
 
 	authSvc := &cliTrackerAuthForTest{
 		capabilities: []api.TrackerAuthCapability{
-			{TrackerID: "MTV", AuthKind: "api_key_cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true, RequiresAPIKey: true},
-			{TrackerID: "PTP", AuthKind: "cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true},
+			{
+				TrackerID:          "MTV",
+				AuthKind:           "api_key_cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+				RequiresAPIKey:     true,
+			},
+			{
+				TrackerID:          "PTP",
+				AuthKind:           "cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+			},
 		},
 	}
 	logger := &cliAuthRecordingLogger{}
@@ -787,26 +819,26 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckDryRunSkipsRuleFailedManagedAuth(t *
 		context.Background(),
 		bufio.NewReader(strings.NewReader("")),
 		authSvc,
-		api.Request{Options: api.UploadOptions{DryRun: true, InteractionMode: api.InteractionModeInteractive}},
+		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
 		[]string{"MTV", "PTP"},
 		api.MetadataPreview{TrackerRuleFailures: map[string][]api.RuleFailure{
-			"MTV": {{Rule: "extra_check", Reason: "managed auth rule failure"}},
+			"MTV": {{Rule: "source_rule", Reason: "managed auth rule failure"}},
 		}},
 		logger,
 	)
 	if err != nil {
 		t.Fatalf("ensureCLITrackerAuthBeforeDupeCheck: %v", err)
 	}
-	if strings.Join(got, ",") != "PTP" {
-		t.Fatalf("expected dry-run to skip rule-failed managed auth tracker, got %#v", got)
+	if strings.Join(got, ",") != "MTV,PTP" {
+		t.Fatalf("expected rule diagnostics not to remove managed auth tracker, got %#v", got)
 	}
-	if strings.Join(authSvc.validated, ",") != "PTP" {
-		t.Fatalf("expected dry-run to validate only rule-eligible managed auth trackers, got %#v", authSvc.validated)
+	if strings.Join(authSvc.validated, ",") != "MTV,PTP" {
+		t.Fatalf("expected all managed auth trackers to be validated, got %#v", authSvc.validated)
 	}
 
 	logs := strings.Join(append(append(append([]string{}, logger.debug...), logger.info...), logger.warn...), "\n")
-	if !strings.Contains(logs, "tracker=MTV skipped before auth due to rule failure") {
-		t.Fatal("dry-run should skip managed auth due to rule failure")
+	if strings.Contains(logs, "skipped before auth due to rule failure") {
+		t.Fatal("rule diagnostics must not suppress auth validation")
 	}
 }
 
@@ -815,8 +847,20 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckHonorsPerTrackerRuleFailureOverride(
 
 	authSvc := &cliTrackerAuthForTest{
 		capabilities: []api.TrackerAuthCapability{
-			{TrackerID: "MTV", AuthKind: "api_key_cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true},
-			{TrackerID: "PTP", AuthKind: "cookies_login_manual_2fa", SupportsCookieFile: true, SupportsLogin: true, SupportsManual2FA: true},
+			{
+				TrackerID:          "MTV",
+				AuthKind:           "api_key_cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+			},
+			{
+				TrackerID:          "PTP",
+				AuthKind:           "cookies_login_manual_2fa",
+				SupportsCookieFile: true,
+				SupportsLogin:      true,
+				SupportsManual2FA:  true,
+			},
 		},
 	}
 	logger := &cliAuthRecordingLogger{}
@@ -825,13 +869,10 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckHonorsPerTrackerRuleFailureOverride(
 		context.Background(),
 		bufio.NewReader(strings.NewReader("")),
 		authSvc,
-		api.Request{
-			Options:                      api.UploadOptions{InteractionMode: api.InteractionModeInteractive},
-			IgnoreTrackerRuleFailuresFor: []string{" mtv "},
-		},
+		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
 		[]string{"MTV", "PTP"},
 		api.MetadataPreview{TrackerRuleFailures: map[string][]api.RuleFailure{
-			"mTv": {{Rule: "extra_check", Reason: "managed auth rule failure"}},
+			"mTv": {{Rule: "source_rule", Reason: "managed auth rule failure"}},
 		}},
 		logger,
 	)
@@ -839,7 +880,7 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckHonorsPerTrackerRuleFailureOverride(
 		t.Fatalf("ensureCLITrackerAuthBeforeDupeCheck: %v", err)
 	}
 	if strings.Join(got, ",") != "MTV,PTP" {
-		t.Fatalf("expected per-tracker rule-failure override to keep MTV eligible, got %#v", got)
+		t.Fatalf("expected rule diagnostics not to suppress auth, got %#v", got)
 	}
 	if strings.Join(authSvc.validated, ",") != "MTV,PTP" {
 		t.Fatalf("expected overridden managed tracker to validate, got %#v", authSvc.validated)
@@ -847,7 +888,7 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckHonorsPerTrackerRuleFailureOverride(
 
 	logs := strings.Join(append(append(append([]string{}, logger.debug...), logger.info...), logger.warn...), "\n")
 	if strings.Contains(logs, "tracker=MTV skipped before auth due to rule failure") {
-		t.Fatal("overridden tracker should not log auth rule-failure skip")
+		t.Fatal("rule diagnostics should not log an auth skip")
 	}
 }
 
@@ -894,7 +935,12 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckLogsRedactedDecisions(t *testing.T)
 			},
 		},
 		validateStatus: map[string]api.TrackerAuthStatus{
-			"PTP": {TrackerID: "PTP", State: trackerauth.StateConfigured, CookieCount: 2, EncryptedStorage: true},
+			"PTP": {
+				TrackerID:        "PTP",
+				State:            trackerauth.StateConfigured,
+				CookieCount:      2,
+				EncryptedStorage: true,
+			},
 			"HDB": {
 				TrackerID: "HDB",
 				State:     trackerauth.StateLoginRequired,
@@ -1195,12 +1241,22 @@ func TestEnsureCLITrackerAuthBeforeDupeCheckFailsUnattendedBTN2FA(t *testing.T)
 func TestPromptTrackerDupeReviewBuildsConfirmedTrackerList(t *testing.T) {
 	t.Parallel()
 
-	approved, ignoreDupes, ruleOverrides, err := promptTrackerDupeReview(
+	approved, ignoreDupes, err := promptTrackerDupeReview(
 		bufio.NewReader(strings.NewReader("y\nn\nn\n")),
 		api.DupeCheckSummary{Results: []api.DupeCheckResult{
-			{Tracker: "ANT", Status: "completed", HasDupes: true},
+			{
+				Tracker:  "ANT",
+				Status:   "completed",
+				HasDupes: true,
+			},
 			{Tracker: "BLU", Status: "completed"},
-			{Tracker: "NBL", Status: "skipped", Skipped: true, SkipReason: "rule check failed: category movie is not tv"},
+			{
+				Tracker:    "NBL",
+				Status:     "skipped",
+				Skipped:    true,
+				SkipReason: "missing metadata",
+				SkipCode:   "missing_metadata",
+			},
 		}},
 		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
 		[]string{"ANT", "BLU", "NBL"},
@@ -1215,68 +1271,148 @@ func TestPromptTrackerDupeReviewBuildsConfirmedTrackerList(t *testing.T) {
 	if strings.Join(ignoreDupes, ",") != "ANT" {
 		t.Fatalf("expected dupe ignores for approved blocked trackers, got %#v", ignoreDupes)
 	}
-	if len(ruleOverrides) != 0 {
-		t.Fatalf("expected no rule overrides for skipped rule result, got %#v", ruleOverrides)
-	}
 }
 
-func TestPromptTrackerDupeReviewSkipsPathedTorrentMatches(t *testing.T) {
+func TestPromptTrackerRuleReviewEnforcesStrictAndExactWaivableRules(t *testing.T) {
 	t.Parallel()
-
-	approved, ignoreDupes, ruleOverrides, err := promptTrackerDupeReview(
-		bufio.NewReader(strings.NewReader("y\n")),
-		api.DupeCheckSummary{Results: []api.DupeCheckResult{
+	preview := api.MetadataPreview{TrackerRuleFailures: map[string][]api.RuleFailure{
+		"STRICT": {
 			{
-				Tracker:  "BHD, DP",
-				Status:   "completed",
-				HasDupes: true,
-				Notes:    []string{"pathed torrent match found; skipping dupe search"},
-			},
-			{Tracker: "ANT", Status: "completed"},
-		}},
+Rule: "container",
+ Reason: "container rejected",
+ Disposition: api.RuleDispositionWaivable,
+},
+			{
+Rule: "resolution",
+ Reason: "resolution rejected",
+ Disposition: api.RuleDispositionStrict,
+},
+		},
+		"WAIVE": {{
+Rule: "language",
+ Reason: "language rejected",
+ Disposition: api.RuleDispositionWaivable,
+}},
+		"ADVICE": {{
+Rule: "recommended_id",
+ Reason: "ID recommended",
+ Disposition: api.RuleDispositionAdvisory,
+}},
+	}}
+	var approved []string
+	var authorizations []api.RuleAuthorization
+	var err error
+	approved, authorizations, err = promptTrackerRuleReview(
+		bufio.NewReader(strings.NewReader("y\n")),
 		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
-		[]string{"BHD", "DP", "ANT"},
-		nil,
+		[]string{"STRICT", "WAIVE", "ADVICE"},
+		preview,
 	)
 	if err != nil {
-		t.Fatalf("promptTrackerDupeReview: %v", err)
+		t.Fatalf("prompt rule review: %v", err)
 	}
-	if strings.Join(approved, ",") != "ANT" {
-		t.Fatalf("expected only ANT approved, got %#v", approved)
+	if !slices.Equal(approved, []string{"WAIVE", "ADVICE"}) {
+		t.Fatalf("approved = %#v", approved)
 	}
-	if len(ignoreDupes) != 0 {
-		t.Fatalf("expected no dupe ignores for skipped pathed matches, got %#v", ignoreDupes)
+	if len(authorizations) != 1 || authorizations[0].Tracker != "WAIVE" || !slices.Equal(authorizations[0].Rules, []string{"language"}) {
+		t.Fatalf("authorizations = %#v", authorizations)
+	}
+}
+
+func TestPromptTrackerRuleReviewUnattendedNeverPromptsForWaiver(t *testing.T) {
+	t.Parallel()
+	approved, authorizations, err := promptTrackerRuleReview(
+		bufio.NewReader(strings.NewReader("y\n")),
+		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeUnattended}},
+		[]string{"WAIVE"},
+		api.MetadataPreview{TrackerRuleFailures: map[string][]api.RuleFailure{
+			"WAIVE": {{Rule: "language", Disposition: api.RuleDispositionWaivable}},
+		}},
+	)
+	if err != nil {
+		t.Fatalf("prompt rule review: %v", err)
+	}
+	if len(approved) != 0 || len(authorizations) != 0 {
+		t.Fatalf("unattended review approved=%#v authorizations=%#v", approved, authorizations)
 	}
-	if len(ruleOverrides) != 0 {
-		t.Fatalf("expected no rule overrides for skipped pathed matches, got %#v", ruleOverrides)
+}
+
+func TestDebugPayloadRendersRuleAndDuplicateDiagnostics(t *testing.T) {
+	t.Parallel()
+	body := renderDebugPayloadBody(api.TrackerReview{Tracker: "EXAMPLE", DryRun: api.TrackerDryRunEntry{
+		Tracker: "EXAMPLE",
+		Status:  "ready",
+		Diagnostics: api.TrackerDryRunDiagnostics{
+			RuleDecisions: []api.RuleDecision{
+				{
+Rule: "resolution",
+ Reason: "resolution rejected",
+ Disposition: api.RuleDispositionStrict,
+},
+				{
+Rule: "container",
+ Reason: "container rejected",
+ Disposition: api.RuleDispositionWaivable,
+},
+				{
+Rule: "recommended_id",
+ Reason: "ID recommended",
+ Disposition: api.RuleDispositionAdvisory,
+},
+			},
+			Duplicate: api.DupeCheckResult{
+				Tracker:  "EXAMPLE",
+				Status:   "completed",
+				HasDupes: true,
+				Filtered: []api.DupeEntry{{Name: "Example.Release.2026.1080p-GRP"}},
+			},
+		},
+	}})
+	for _, want := range []string{
+		"Rule [strict] resolution: resolution rejected",
+		"Rule [waivable] container: container rejected",
+		"Rule [advisory] recommended_id: ID recommended",
+		"Dupe check status: completed",
+		"Example.Release.2026.1080p-GRP",
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("debug body missing %q:\n%s", want, body)
+		}
 	}
 }
 
-func TestPromptTrackerDupeReviewAllowsRuleCheckOverrides(t *testing.T) {
+func TestPromptTrackerDupeReviewNeverOffersInClientOverride(t *testing.T) {
 	t.Parallel()
 
-	approved, ignoreDupes, ruleOverrides, err := promptTrackerDupeReview(
-		bufio.NewReader(strings.NewReader("y\ny\ny\n")),
+	approved, ignoreDupes, err := promptTrackerDupeReview(
+		bufio.NewReader(strings.NewReader("y\n")),
 		api.DupeCheckSummary{Results: []api.DupeCheckResult{
-			{Tracker: "NBL", Status: "skipped", Skipped: true, SkipReason: "rule check failed: category movie is not tv"},
-			{Tracker: "OTW", Status: "skipped", Skipped: true, Error: "rule failed: Genre does not match Animation or Family for OTW."},
+			{
+				Tracker:  "BHD",
+				Status:   "completed",
+				HasDupes: true,
+				Match:    api.DupeMatch{MatchedReason: "in_client"},
+			},
+			{
+				Tracker:  "DP",
+				Status:   "completed",
+				HasDupes: true,
+				Match:    api.DupeMatch{MatchedReason: "in_client"},
+			},
 			{Tracker: "ANT", Status: "completed"},
 		}},
 		api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
-		[]string{"NBL", "OTW", "ANT"},
+		[]string{"BHD", "DP", "ANT"},
 		nil,
 	)
 	if err != nil {
 		t.Fatalf("promptTrackerDupeReview: %v", err)
 	}
-	if strings.Join(approved, ",") != "NBL,OTW,ANT" {
-		t.Fatalf("expected overridden rule-failed trackers approved, got %#v", approved)
-	}
-	if strings.Join(ignoreDupes, ",") != "NBL,OTW" {
-		t.Fatalf("expected dupe ignores for approved blocked rule violations, got %#v", ignoreDupes)
+	if strings.Join(approved, ",") != "ANT" {
+		t.Fatalf("expected only ANT approved, got %#v", approved)
 	}
-	if strings.Join(ruleOverrides, ",") != "NBL,OTW" {
-		t.Fatalf("expected rule overrides for approved rule violations, got %#v", ruleOverrides)
+	if len(ignoreDupes) != 0 {
+		t.Fatalf("expected no dupe ignores for in-client matches, got %#v", ignoreDupes)
 	}
 }
 
@@ -1288,12 +1424,31 @@ func TestPromptTrackerDupeReviewApprovesUserSkippedDupeChecksInUnattendedMode(t
 		Trackers:      []string{"ANT", "BLU"},
 		Options:       api.UploadOptions{InteractionMode: api.InteractionModeUnattended},
 	}
-	summary, err := runCLIDupeCheck(context.Background(), nil, req)
+	coreSvc := &cliCoreForTest{dupeSummary: api.DupeCheckSummary{Results: []api.DupeCheckResult{
+		{
+			Tracker:    "ANT",
+			Status:     "skipped",
+			Skipped:    true,
+			SkipCode:   "user_requested",
+			SkipReason: "duplicate search not run by request",
+		},
+		{
+			Tracker:    "BLU",
+			Status:     "skipped",
+			Skipped:    true,
+			SkipCode:   "user_requested",
+			SkipReason: "duplicate search not run by request",
+		},
+	}}}
+	summary, err := runCLIDupeCheck(context.Background(), coreSvc, req)
 	if err != nil {
 		t.Fatalf("runCLIDupeCheck: %v", err)
 	}
+	if len(coreSvc.requests) != 1 || coreSvc.requests[0].name != "dupes" || !coreSvc.requests[0].req.SkipDupeCheck {
+		t.Fatalf("expected SkipDupeCheck to be handled by Core, got %#v", coreSvc.requests)
+	}
 
-	approved, ignoreDupes, ruleOverrides, err := promptTrackerDupeReview(
+	approved, ignoreDupes, err := promptTrackerDupeReview(
 		bufio.NewReader(strings.NewReader("")),
 		summary,
 		req,
@@ -1309,9 +1464,6 @@ func TestPromptTrackerDupeReviewApprovesUserSkippedDupeChecksInUnattendedMode(t
 	if len(ignoreDupes) != 0 {
 		t.Fatalf("expected no dupe ignores for user-requested skip, got %#v", ignoreDupes)
 	}
-	if len(ruleOverrides) != 0 {
-		t.Fatalf("expected no rule overrides for user-requested skip, got %#v", ruleOverrides)
-	}
 }
 
 func TestPromptTrackerDupeReviewGroupsUnattendedOutput(t *testing.T) {
@@ -1334,7 +1486,8 @@ func TestPromptTrackerDupeReviewGroupsUnattendedOutput(t *testing.T) {
 				Tracker:    "ANT",
 				Status:     "skipped",
 				Skipped:    true,
-				SkipReason: "rule check failed: category tv is not movie",
+				SkipReason: "missing metadata",
+				SkipCode:   "missing_metadata",
 			},
 			{
 				Tracker:    "NBL",
@@ -1366,7 +1519,7 @@ func TestPromptTrackerDupeReviewGroupsUnattendedOutput(t *testing.T) {
 	var approved []string
 	var err error
 	output := captureStdout(t, func() {
-		approved, _, _, err = promptTrackerDupeReview(
+		approved, _, err = promptTrackerDupeReview(
 			bufio.NewReader(strings.NewReader("")),
 			summary,
 			req,
@@ -1382,7 +1535,7 @@ func TestPromptTrackerDupeReviewGroupsUnattendedOutput(t *testing.T) {
 	}
 	for _, expected := range []string{
 		"Dupe check summary:",
-		"Skipped: ANT (rule check failed: category tv is not movie)",
+		"Skipped: ANT (missing metadata)",
 		"Skipped: NBL (missing api_key for tracker)",
 		"Found potential dupes on: AITHER, MTV",
 		"Trackers passed all checks: DP, OTW",
@@ -1405,11 +1558,10 @@ func TestPromptTrackerDupeReviewGroupsUnattendedOutput(t *testing.T) {
 	}
 }
 
-func TestPromptTrackerDupeReviewSkipsAllRuleBlockedTrackersUnattended(t *testing.T) {
+func TestPromptTrackerDupeReviewSkipsAllUnavailableTrackersUnattended(t *testing.T) {
 	t.Parallel()
 
-	// When every selected tracker is rule-blocked (e.g. encodes missing
-	// MediaInfo encode settings), unattended review approves none. The caller
+	// When every selected tracker could not run, unattended review approves none. The caller
 	// relies on an empty approval list to skip the release before
 	// screenshots/torrent/upload, so this guards that early-skip path.
 	req := api.Request{
@@ -1418,12 +1570,24 @@ func TestPromptTrackerDupeReviewSkipsAllRuleBlockedTrackersUnattended(t *testing
 	}
 	summary := api.DupeCheckSummary{
 		Results: []api.DupeCheckResult{
-			{Tracker: "LST", Status: "skipped", Skipped: true, SkipReason: "rule check failed: missing MediaInfo encode settings"},
-			{Tracker: "RF", Status: "skipped", Skipped: true, SkipReason: "rule check failed: missing MediaInfo encode settings"},
+			{
+				Tracker:    "LST",
+				Status:     "skipped",
+				Skipped:    true,
+				SkipReason: "missing metadata",
+				SkipCode:   "missing_metadata",
+			},
+			{
+				Tracker:    "RF",
+				Status:     "skipped",
+				Skipped:    true,
+				SkipReason: "missing metadata",
+				SkipCode:   "missing_metadata",
+			},
 		},
 	}
 
-	approved, ignoreDupes, ruleOverrides, err := promptTrackerDupeReview(
+	approved, ignoreDupes, err := promptTrackerDupeReview(
 		bufio.NewReader(strings.NewReader("")),
 		summary,
 		req,
@@ -1434,16 +1598,16 @@ func TestPromptTrackerDupeReviewSkipsAllRuleBlockedTrackersUnattended(t *testing
 		t.Fatalf("promptTrackerDupeReview: %v", err)
 	}
 	if len(approved) != 0 {
-		t.Fatalf("expected no approved trackers when all are rule-blocked, got %#v", approved)
+		t.Fatalf("expected no approved trackers when all checks are unavailable, got %#v", approved)
 	}
-	if len(ignoreDupes) != 0 || len(ruleOverrides) != 0 {
-		t.Fatalf("expected no overrides in unattended mode, got ignoreDupes=%#v ruleOverrides=%#v", ignoreDupes, ruleOverrides)
+	if len(ignoreDupes) != 0 {
+		t.Fatalf("expected no duplicate overrides in unattended mode, got %#v", ignoreDupes)
 	}
 }
 
 func TestPromptTrackerDupeReviewShowsTrackerNamingChange(t *testing.T) {
 	output := captureStdout(t, func() {
-		approved, _, _, err := promptTrackerDupeReview(
+		approved, _, err := promptTrackerDupeReview(
 			bufio.NewReader(strings.NewReader("y\n")),
 			api.DupeCheckSummary{Results: []api.DupeCheckResult{{Tracker: "AITHER", Status: "completed"}}},
 			api.Request{Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive}},
@@ -1470,20 +1634,15 @@ func TestPromptTrackerDupeReviewShowsTrackerNamingChange(t *testing.T) {
 	}
 }
 
-func TestPrepareCLIUploadMetadataSeedsEachPath(t *testing.T) {
+func TestCLIPreparationBatchExpandsIndependentRequests(t *testing.T) {
 	t.Parallel()
 
-	coreSvc := &cliCoreForTest{}
-	req := api.Request{Paths: []string{"one.mkv", "two.mkv"}}
-	resolvedReq, err := prepareCLIUploadMetadata(context.Background(), coreSvc, req)
-	if err != nil {
-		t.Fatalf("prepareCLIUploadMetadata: %v", err)
-	}
-	if len(coreSvc.previewPaths) != 2 || coreSvc.previewPaths[0] != "one.mkv" || coreSvc.previewPaths[1] != "two.mkv" {
-		t.Fatalf("unexpected preview paths: %#v", coreSvc.previewPaths)
+	batch := newCLIPreparationBatch(api.Request{Trackers: []string{"BLU"}}, []string{"one.mkv", "two.mkv"})
+	if len(batch.items) != 2 {
+		t.Fatalf("expected two batch items, got %d", len(batch.items))
 	}
-	if strings.Join(resolvedReq.Paths, ",") != "one.mkv,two.mkv" {
-		t.Fatalf("unexpected resolved paths: %#v", resolvedReq.Paths)
+	if first, second := batch.request(0), batch.request(1); first.SourcePath != "one.mkv" || second.SourcePath != "two.mkv" {
+		t.Fatalf("unexpected independent request sources: %q, %q", first.SourcePath, second.SourcePath)
 	}
 }
 
@@ -1491,44 +1650,13 @@ func TestPrepareCLIUploadMetadataReturnsResolvedPreviewPaths(t *testing.T) {
 	t.Parallel()
 
 	coreSvc := &cliCoreForTest{previewSourcePath: filepath.Join("folder", "movie.mkv")}
-	req := api.Request{Paths: []string{"folder"}}
+	req := api.Request{SourcePath: "folder"}
 	resolvedReq, err := prepareCLIUploadMetadata(context.Background(), coreSvc, req)
 	if err != nil {
 		t.Fatalf("prepareCLIUploadMetadata: %v", err)
 	}
-	if len(resolvedReq.Paths) != 1 || resolvedReq.Paths[0] != filepath.Join("folder", "movie.mkv") {
-		t.Fatalf("expected resolved preview path, got %#v", resolvedReq.Paths)
-	}
-}
-
-func TestBuildCLIUploadDebugReviewsUsesPreparedResolvedPath(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &cliCoreForTest{
-		previewSourcePath: filepath.Join("folder", "movie.mkv"),
-		review:            api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
-	}
-	req := api.Request{Paths: []string{"folder"}}
-	resolvedReq, err := prepareCLIUploadMetadata(context.Background(), coreSvc, req)
-	if err != nil {
-		t.Fatalf("prepareCLIUploadMetadata: %v", err)
-	}
-
-	reviews, err := buildCLIUploadDebugReviews(context.Background(), coreSvc, req.Paths, resolvedReq)
-	if err != nil {
-		t.Fatalf("buildCLIUploadDebugReviews: %v", err)
-	}
-	if len(reviews) != 1 {
-		t.Fatalf("expected one debug review, got %d", len(reviews))
-	}
-	if reviews[0].SourcePath != "folder" {
-		t.Fatalf("expected debug review to retain original source label, got %q", reviews[0].SourcePath)
-	}
-	if len(coreSvc.requests) != 2 {
-		t.Fatalf("expected preview and review requests, got %#v", coreSvc.requests)
-	}
-	if got := coreSvc.requests[1]; got.name != "review" || len(got.req.Paths) != 1 || got.req.Paths[0] != filepath.Join("folder", "movie.mkv") {
-		t.Fatalf("expected debug review to use prepared resolved path, got %#v", got)
+	if resolvedReq.SourcePath != filepath.Join("folder", "movie.mkv") {
+		t.Fatalf("expected resolved preview path, got %q", resolvedReq.SourcePath)
 	}
 }
 
@@ -1578,6 +1706,43 @@ func TestPromptTrackerQuestionnairesSkipsRuleFailedTrackers(t *testing.T) {
 	}
 }
 
+func TestPromptTrackerQuestionnairesDebugStillSkipsIneligibleTrackers(t *testing.T) {
+	t.Parallel()
+
+	questionnaire := &api.TrackerQuestionnaire{Fields: []api.TrackerQuestionnaireField{{
+		Key:      "type",
+		Label:    "Type",
+		Required: true,
+	}}}
+	answers, changed, err := promptTrackerQuestionnaires(bufio.NewReader(strings.NewReader("eligible\n")), api.UploadReview{
+		Trackers: []api.TrackerReview{
+			{
+				Tracker:       "BANNED",
+				Banned:        true,
+				Questionnaire: questionnaire,
+			},
+			{
+				Tracker:      "BLOCKED",
+				RuleFailures: []api.RuleFailure{{Rule: "require_movie_only", Reason: "category tv is not movie"}},
+				Questionnaire: questionnaire,
+			},
+			{
+				Tracker:       "ELIGIBLE",
+				Questionnaire: questionnaire,
+			},
+		},
+	}, cliOptions{Debug: true})
+	if err != nil {
+		t.Fatalf("promptTrackerQuestionnaires: %v", err)
+	}
+	if !changed {
+		t.Fatal("expected eligible questionnaire answer to change")
+	}
+	if len(answers) != 1 || answers["ELIGIBLE"]["type"] != "eligible" {
+		t.Fatalf("expected only eligible questionnaire answers, got %#v", answers)
+	}
+}
+
 func TestPromptTrackerQuestionnairesDebugUnattendedAllowsBlankRequiredDefault(t *testing.T) {
 	t.Parallel()
 
@@ -1613,12 +1778,20 @@ func TestHandleBDMVPlaylistSelectionDoesNotPromptInUnattendedMode(t *testing.T)
 	coreSvc := &cliCoreForTest{
 		playlistSelectionErr: internalerrors.ErrNotFound,
 		playlists: []api.PlaylistInfo{
-			{File: "00001.mpls", Duration: 7200, Score: 1},
-			{File: "00002.mpls", Duration: 7100, Score: 0.9},
+			{
+				File:     "00001.mpls",
+				Duration: 7200,
+				Score:    1,
+			},
+			{
+				File:     "00002.mpls",
+				Duration: 7100,
+				Score:    0.9,
+			},
 		},
 	}
 
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{Unattended: true})
+	err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{}, cliOptions{Unattended: true})
 	if err == nil {
 		t.Fatal("expected unattended playlist selection error")
 	}
@@ -1638,14 +1811,22 @@ func TestHandleBDMVPlaylistSelectionAllowsUnattendedUseLargestPlaylist(t *testin
 	coreSvc := &cliCoreForTest{
 		playlistSelectionErr: internalerrors.ErrNotFound,
 		playlists: []api.PlaylistInfo{
-			{File: "00001.mpls", Duration: 7200, Score: 1},
-			{File: "00002.mpls", Duration: 7100, Score: 0.9},
+			{
+				File:     "00001.mpls",
+				Duration: 7200,
+				Score:    1,
+			},
+			{
+				File:     "00002.mpls",
+				Duration: 7100,
+				Score:    0.9,
+			},
 		},
 	}
 
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{
+	err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{
 		Metadata: config.MetadataConfig{UseLargestPlaylist: true},
-	}, api.NopLogger{}, cliOptions{Unattended: true})
+	}, cliOptions{Unattended: true})
 	if err != nil {
 		t.Fatalf("handleBDMVPlaylistSelection: %v", err)
 	}
@@ -1654,7 +1835,7 @@ func TestHandleBDMVPlaylistSelectionAllowsUnattendedUseLargestPlaylist(t *testin
 	}
 }
 
-func TestHandleBDMVPlaylistSelectionReturnsSaveErrorInUnattendedUseLargestPlaylist(t *testing.T) {
+func TestHandleBDMVPlaylistSelectionUsesDirectInstructionWhenRememberSaveFails(t *testing.T) {
 	t.Parallel()
 
 	saveErr := errors.New("save failed")
@@ -1666,20 +1847,28 @@ func TestHandleBDMVPlaylistSelectionReturnsSaveErrorInUnattendedUseLargestPlayli
 	coreSvc := &cliCoreForTest{
 		playlistSelectionErr: internalerrors.ErrNotFound,
 		playlists: []api.PlaylistInfo{
-			{File: "00001.mpls", Duration: 7200, Score: 1},
+			{
+				File:     "00001.mpls",
+				Duration: 7200,
+				Score:    1,
+			},
 		},
 		savePlaylistErr: saveErr,
 	}
 
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{
+	batch := newCLIPreparationBatch(api.Request{}, []string{root})
+	err := handleBDMVPlaylistSelection(context.Background(), &batch, coreSvc, config.Config{
 		Metadata: config.MetadataConfig{UseLargestPlaylist: true},
 	}, api.NopLogger{}, cliOptions{Unattended: true})
-	if !errors.Is(err, saveErr) {
-		t.Fatalf("expected save error, got %v", err)
+	if err != nil {
+		t.Fatalf("playlist selection: %v", err)
+	}
+	if got := batch.items[0].playlistInstruction; !got.Set || !slices.Equal(got.Selected, []string{"00001.mpls"}) {
+		t.Fatalf("playlist instruction = %#v", got)
 	}
 }
 
-func TestHandleBDMVPlaylistSelectionReturnsSaveErrorInUnattendedSinglePlaylist(t *testing.T) {
+func TestHandleBDMVPlaylistSelectionUsesSingleDirectInstructionWhenRememberSaveFails(t *testing.T) {
 	t.Parallel()
 
 	saveErr := errors.New("save failed")
@@ -1691,14 +1880,22 @@ func TestHandleBDMVPlaylistSelectionReturnsSaveErrorInUnattendedSinglePlaylist(t
 	coreSvc := &cliCoreForTest{
 		playlistSelectionErr: internalerrors.ErrNotFound,
 		playlists: []api.PlaylistInfo{
-			{File: "00001.mpls", Duration: 7200, Score: 1},
+			{
+				File:     "00001.mpls",
+				Duration: 7200,
+				Score:    1,
+			},
 		},
 		savePlaylistErr: saveErr,
 	}
 
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{Unattended: true})
-	if !errors.Is(err, saveErr) {
-		t.Fatalf("expected save error, got %v", err)
+	batch := newCLIPreparationBatch(api.Request{}, []string{root})
+	err := handleBDMVPlaylistSelection(context.Background(), &batch, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{Unattended: true})
+	if err != nil {
+		t.Fatalf("playlist selection: %v", err)
+	}
+	if got := batch.items[0].playlistInstruction; !got.Set || !slices.Equal(got.Selected, []string{"00001.mpls"}) {
+		t.Fatalf("playlist instruction = %#v", got)
 	}
 }
 
@@ -1717,16 +1914,20 @@ func TestHandleBDMVPlaylistSelectionGivesEachDiscFreshDeadline(t *testing.T) {
 	coreSvc := &cliCoreForTest{
 		playlistSelectionErr: internalerrors.ErrNotFound,
 		playlists: []api.PlaylistInfo{
-			{File: "00001.mpls", Duration: 7200, Score: 1},
+			{
+				File:     "00001.mpls",
+				Duration: 7200,
+				Score:    1,
+			},
 		},
 	}
 
 	start := time.Now()
 	// UseLargestPlaylist auto-selects without prompting, keeping discovery on the
 	// per-disc deadline path for every disc.
-	err := handleBDMVPlaylistSelection(context.Background(), roots, coreSvc, config.Config{
+	err := handleBDMVPlaylistSelectionForPaths(context.Background(), roots, coreSvc, config.Config{
 		Metadata: config.MetadataConfig{UseLargestPlaylist: true},
-	}, api.NopLogger{}, cliOptions{Unattended: true})
+	}, cliOptions{Unattended: true})
 	if err != nil {
 		t.Fatalf("handleBDMVPlaylistSelection: %v", err)
 	}
@@ -1793,13 +1994,21 @@ func TestHandleBDMVPlaylistSelectionReturnsOnPromptSaveCtxErr(t *testing.T) {
 			coreSvc := &cliCoreForTest{
 				playlistSelectionErr: internalerrors.ErrNotFound,
 				playlists: []api.PlaylistInfo{
-					{File: "00001.mpls", Duration: 7200, Score: 1},
-					{File: "00002.mpls", Duration: 7100, Score: 0.9},
+					{
+						File:     "00001.mpls",
+						Duration: 7200,
+						Score:    1,
+					},
+					{
+						File:     "00002.mpls",
+						Duration: 7100,
+						Score:    0.9,
+					},
 				},
 				savePlaylistErr: context.Canceled,
 			}
 
-			err = handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{})
+			err = handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{}, cliOptions{})
 			if !errors.Is(err, context.Canceled) {
 				t.Fatalf("expected prompt-loop save to surface context.Canceled, got %v", err)
 			}
@@ -1835,9 +2044,9 @@ func TestMaybeEditCLIDescriptionsSavesEditedGroupOnRequest(t *testing.T) {
 	}
 	defer func() { editCLIDescriptionFile = oldEditor }()
 
-	req := api.Request{Paths: []string{"movie.mkv"}, Trackers: []string{"AITHER"}}
+	req := api.Request{SourcePath: "movie.mkv", Trackers: []string{"AITHER"}}
 	review := coreSvc.review
-	updatedReq, _, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("y\n")), req, review, cliOptions{})
+	updatedReq, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("y\n")), req, review, cliOptions{})
 	if err != nil {
 		t.Fatalf("maybeEditCLIDescriptions: %v", err)
 	}
@@ -1850,9 +2059,10 @@ func TestMaybeEditCLIDescriptionsSavesEditedGroupOnRequest(t *testing.T) {
 	if len(updatedReq.DescriptionGroups) != 1 || updatedReq.DescriptionGroups[0].RawDescription != "edited description" {
 		t.Fatalf("expected edited request description group, got %#v", updatedReq.DescriptionGroups)
 	}
-	last := coreSvc.requests[len(coreSvc.requests)-1]
-	if last.name != "review" || len(last.req.DescriptionGroups) != 1 || last.req.DescriptionGroups[0].RawDescription != "edited description" {
-		t.Fatalf("expected rebuilt review with edited description group, got %#v", last)
+	for _, recorded := range coreSvc.requests {
+		if recorded.name == "review" {
+			t.Fatalf("expected final operation assessment to consume edited request without an intermediate review rebuild, got %#v", recorded)
+		}
 	}
 }
 
@@ -1889,8 +2099,8 @@ func TestMaybeEditCLIDescriptionsPromptsEachDescriptionGroup(t *testing.T) {
 	}
 	defer func() { editCLIDescriptionFile = oldEditor }()
 
-	req := api.Request{Paths: []string{"movie.mkv"}, Trackers: []string{"HDB", "HHD"}}
-	updatedReq, _, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("n\ny\n")), req, coreSvc.review, cliOptions{})
+	req := api.Request{SourcePath: "movie.mkv", Trackers: []string{"HDB", "HHD"}}
+	updatedReq, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("n\ny\n")), req, coreSvc.review, cliOptions{})
 	if err != nil {
 		t.Fatalf("maybeEditCLIDescriptions: %v", err)
 	}
@@ -1916,9 +2126,10 @@ func TestMaybeEditCLIDescriptionsPromptsEachDescriptionGroup(t *testing.T) {
 	if updatedReq.DescriptionGroups[1].RawDescription != "unit3d generated description edited" {
 		t.Fatalf("expected Unit3D group to be edited, got %#v", updatedReq.DescriptionGroups[1])
 	}
-	last := coreSvc.requests[len(coreSvc.requests)-1]
-	if last.name != "review" || len(last.req.DescriptionGroups) != 2 || last.req.DescriptionGroups[1].RawDescription != "unit3d generated description edited" {
-		t.Fatalf("expected rebuilt review with edited unit3d group, got %#v", last)
+	for _, recorded := range coreSvc.requests {
+		if recorded.name == "review" {
+			t.Fatalf("expected final operation assessment to consume edited groups without an intermediate review rebuild, got %#v", recorded)
+		}
 	}
 }
 
@@ -1933,11 +2144,11 @@ func TestMaybeEditCLIDescriptionsSkipsOnlyID(t *testing.T) {
 		}}},
 	}
 	req := api.Request{
-		Paths:    []string{"movie.mkv"},
-		Trackers: []string{"AITHER"},
-		Options:  api.UploadOptions{OnlyID: true},
+		SourcePath: "movie.mkv",
+		Trackers:   []string{"AITHER"},
+		Options:    api.UploadOptions{OnlyID: true},
 	}
-	updatedReq, _, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("y\n")), req, api.UploadReview{}, cliOptions{})
+	updatedReq, err := maybeEditCLIDescriptions(context.Background(), coreSvc, bufio.NewReader(strings.NewReader("y\n")), req, api.UploadReview{}, cliOptions{})
 	if err != nil {
 		t.Fatalf("maybeEditCLIDescriptions: %v", err)
 	}
@@ -1952,13 +2163,15 @@ func TestMaybeEditCLIDescriptionsSkipsOnlyID(t *testing.T) {
 type cliCoreForTest struct {
 	review                 api.UploadReview
 	reviewResponses        []api.UploadReview
-	dryRunPreview          api.TrackerDryRunPreview
 	callOrder              []string
 	requests               []cliCoreRequestForTest
 	previewPaths           []string
 	previewSourcePath      string
 	previewResponses       []api.MetadataPreview
 	runUploadPreparedCalls int
+	runTrackerDryRunCalls  int
+	dryRunPlans            []api.TrackerDryRunPlan
+	dryRunPreview          api.TrackerDryRunPreview
 	dupeSummary            api.DupeCheckSummary
 	screenshotPlan         api.ScreenshotPlan
 	screenshotResult       api.ScreenshotResult
@@ -2039,14 +2252,19 @@ type cliCoreRequestForTest struct {
 
 func (c *cliCoreForTest) recordRequest(name string, req api.Request) {
 	copyReq := req
-	copyReq.Paths = append([]string(nil), req.Paths...)
 	copyReq.Trackers = append([]string(nil), req.Trackers...)
 	copyReq.TrackersRemove = append([]string(nil), req.TrackersRemove...)
 	copyReq.IgnoreDupesFor = append([]string(nil), req.IgnoreDupesFor...)
-	copyReq.IgnoreTrackerRuleFailuresFor = append([]string(nil), req.IgnoreTrackerRuleFailuresFor...)
+	copyReq.RuleAuthorizations = make([]api.RuleAuthorization, len(req.RuleAuthorizations))
+	for idx, authorization := range req.RuleAuthorizations {
+		copyReq.RuleAuthorizations[idx] = api.RuleAuthorization{
+			Tracker: authorization.Tracker,
+			Rules:   append([]string(nil), authorization.Rules...),
+		}
+	}
 	copyReq.DescriptionGroups = api.CloneDescriptionBuilderGroups(req.DescriptionGroups)
 	copyReq.TrackerQuestionnaireAnswers = cloneCLIQuestionnaireAnswersForTest(req.TrackerQuestionnaireAnswers)
-	copyReq.ExternalIDSelections = cloneCLIExternalIDSelectionsForTest(req.ExternalIDSelections)
+	copyReq.PlaylistInstruction.Selected = append([]string(nil), req.PlaylistInstruction.Selected...)
 	c.requests = append(c.requests, cliCoreRequestForTest{name: name, req: copyReq})
 }
 
@@ -2061,10 +2279,6 @@ func cloneCLIQuestionnaireAnswersForTest(input map[string]map[string]string) map
 	return cloned
 }
 
-func (c *cliCoreForTest) RunUpload(context.Context, api.Request) (api.Result, error) {
-	return api.Result{}, nil
-}
-
 func (c *cliCoreForTest) RunUploadPrepared(ctx context.Context, req api.Request) (api.Result, error) {
 	c.recordRequest("upload", req)
 	c.runUploadPreparedCalls++
@@ -2074,6 +2288,39 @@ func (c *cliCoreForTest) RunUploadPrepared(ctx context.Context, req api.Request)
 	return api.Result{UploadedCount: 1}, nil
 }
 
+func (c *cliCoreForTest) RunAcceptedTrackerDryRun(_ context.Context, plan api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	c.dryRunPlans = append(c.dryRunPlans, plan)
+	input := plan.Input
+	req := api.Request{
+		SourcePath:                  input.Release.SourcePath,
+		Trackers:                    append([]string(nil), input.Trackers...),
+		IgnoreDupesFor:              append([]string(nil), input.IgnoreDupesFor...),
+		TrackerQuestionnaireAnswers: cloneCLIQuestionnaireAnswersForTest(input.QuestionnaireAnswers),
+		DescriptionGroups:           api.CloneDescriptionBuilderGroups(input.DescriptionGroups),
+		TrackerIDOverrides:          maps.Clone(input.TrackerIDOverrides),
+		TrackerConfigOverrides:      input.TrackerConfigOverrides,
+		TrackerSiteOverrides:        input.TrackerSiteOverrides,
+		ClientOverrides:             input.ClientOverrides,
+		ImageHostOverrides:          input.ImageHostOverrides,
+		ScreenshotOverrides:         input.ScreenshotOverrides,
+		TorrentOverrides:            input.TorrentOverrides,
+		Options:                     input.Options,
+	}
+	c.callOrder = append(c.callOrder, "debug")
+	c.recordRequest("debug", req)
+	c.runTrackerDryRunCalls++
+	preview := c.dryRunPreview
+	if strings.TrimSpace(preview.SourcePath) == "" {
+		preview.SourcePath = input.Release.SourcePath
+	}
+	if len(preview.Trackers) == 0 {
+		for _, tracker := range c.review.Trackers {
+			preview.Trackers = append(preview.Trackers, tracker.DryRun)
+		}
+	}
+	return preview, nil
+}
+
 func (c *cliCoreForTest) FetchMetadataPreview(ctx context.Context, req api.Request) (api.MetadataPreview, error) {
 	c.callOrder = append(c.callOrder, "preview")
 	c.recordRequest("preview", req)
@@ -2082,15 +2329,25 @@ func (c *cliCoreForTest) FetchMetadataPreview(ctx context.Context, req api.Reque
 	if err := ctx.Err(); err != nil {
 		return api.MetadataPreview{}, fmt.Errorf("preview: %w", err)
 	}
-	if len(req.Paths) > 0 {
-		c.previewPaths = append(c.previewPaths, req.Paths[0])
+	if req.SourcePath != "" {
+		c.previewPaths = append(c.previewPaths, req.SourcePath)
 	}
 	if len(c.previewResponses) > 0 {
 		preview := c.previewResponses[0]
 		c.previewResponses = c.previewResponses[1:]
+		if strings.TrimSpace(preview.SourcePath) == "" {
+			preview.SourcePath = req.SourcePath
+		}
+		if preview.Release.Generation == 0 {
+			preview.Release = api.ReleaseRef{SourcePath: preview.SourcePath, Generation: 1}
+		}
 		return preview, nil
 	}
-	return api.MetadataPreview{SourcePath: c.previewSourcePath}, nil
+	path := c.previewSourcePath
+	if strings.TrimSpace(path) == "" {
+		path = req.SourcePath
+	}
+	return api.MetadataPreview{SourcePath: path, Release: api.ReleaseRef{SourcePath: path, Generation: 1}}, nil
 }
 
 func (c *cliCoreForTest) FetchDescriptionBuilderPreview(_ context.Context, req api.Request) (api.DescriptionBuilderPreview, error) {
@@ -2106,12 +2363,6 @@ func (c *cliCoreForTest) FetchPreparationPreview(context.Context, api.Request) (
 	return api.PreparationPreview{}, nil
 }
 
-func (c *cliCoreForTest) FetchTrackerDryRunPreview(_ context.Context, req api.Request) (api.TrackerDryRunPreview, error) {
-	c.callOrder = append(c.callOrder, "dry-run")
-	c.recordRequest("dry-run", req)
-	return c.dryRunPreview, nil
-}
-
 func (c *cliCoreForTest) CheckDupes(_ context.Context, req api.Request) (api.DupeCheckSummary, error) {
 	c.callOrder = append(c.callOrder, "dupes")
 	c.recordRequest("dupes", req)
@@ -2172,15 +2423,6 @@ func (c *cliCoreForTest) UploadImages(context.Context, api.Request, string, []ap
 	return api.UploadImagesResult{}, nil
 }
 
-func cloneCLIExternalIDSelectionsForTest(input map[string]api.ExternalIDSelection) map[string]api.ExternalIDSelection {
-	if len(input) == 0 {
-		return nil
-	}
-	cloned := make(map[string]api.ExternalIDSelection, len(input))
-	maps.Copy(cloned, input)
-	return cloned
-}
-
 func (c *cliCoreForTest) DeleteUploadedImage(context.Context, api.Request, string, string) error {
 	return nil
 }
@@ -2213,6 +2455,14 @@ func (c *cliCoreForTest) DiscoverPlaylists(ctx context.Context, _ string) ([]api
 	return c.playlists, c.discoverPlaylistsErr
 }
 
+func (*cliCoreForTest) DetectDiscType(ctx context.Context, sourcePath string) (string, error) {
+	layout, err := sourcelayout.Resolve(ctx, sourcePath)
+	if err != nil {
+		return "", fmt.Errorf("resolve source layout: %w", err)
+	}
+	return layout.DiscType, nil
+}
+
 func (c *cliCoreForTest) SavePlaylistSelection(_ context.Context, _ string, playlists []string, _ bool) error {
 	c.savedPlaylists = append(c.savedPlaylists[:0], playlists...)
 	return c.savePlaylistErr
diff --git a/cmd/upbrr/main.go b/cmd/upbrr/main.go
index c7ee4af8..a6cd5b23 100644
--- a/cmd/upbrr/main.go
+++ b/cmd/upbrr/main.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"maps"
 	"net"
 	"net/netip"
 	"os"
@@ -58,7 +57,18 @@ func printTerminalError(err error) {
 	if err == nil {
 		return
 	}
-	fmt.Fprintf(os.Stderr, "error: %s\n", logging.SanitizeMessage(err.Error()))
+	fmt.Fprintf(os.Stderr, "error: %s\n", logging.SanitizeMessage(formatCLIError(err)))
+}
+
+func formatCLIError(err error) string {
+	if failure, ok := api.AsOperationFailure(err); ok {
+		message := logging.SanitizeMessage(failure.Message)
+		if failure.Recovery != "" && failure.Recovery != api.OperationRecoveryNone {
+			return fmt.Sprintf("%s (recovery: %s)", message, failure.Recovery)
+		}
+		return message
+	}
+	return logging.SanitizeMessage(err.Error())
 }
 
 // printTerminalWarning writes a sanitized CLI warning diagnostic to stderr.
@@ -115,12 +125,66 @@ const cliQueueGatherTimeout = 10 * time.Minute
 const cliDiscDiscoveryTimeout = 5 * time.Minute
 
 // cliUploadOnlyTimeoutCap bounds how many per-item allowances the non-queue
-// upload-only deadline may sum to. RunUploadPrepared processes every path in a
-// single core call (its abort-on-first-error semantics are shared/immutable), so
-// the deadline is budgeted by item count but capped so a huge --paths list cannot
-// produce an effectively unbounded run-wide timeout.
+// upload-only deadline may sum to. The deadline is budgeted by item count but
+// capped so a huge path list cannot produce an effectively unbounded run.
 const cliUploadOnlyTimeoutCap = 50
 
+// cliPreparedUploadRunner executes requests whose preparation state is already cached.
+type cliPreparedUploadRunner interface {
+	RunUploadPrepared(context.Context, api.Request) (api.Result, error)
+}
+
+// cliAcceptedTrackerDryRunRunner builds payloads from one retained explicit
+// duplicate-check outcome without repeating discovery or duplicate checks.
+type cliAcceptedTrackerDryRunRunner interface {
+	RunAcceptedTrackerDryRun(context.Context, api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error)
+}
+
+// cliMetadataPreviewer prepares metadata and resolves the upload source path.
+type cliMetadataPreviewer interface {
+	FetchMetadataPreview(context.Context, api.Request) (api.MetadataPreview, error)
+}
+
+// cliUploadReviewer builds the final tracker-facing review for one prepared request.
+type cliUploadReviewer interface {
+	BuildUploadReview(context.Context, api.Request) (api.UploadReview, error)
+}
+
+// cliDVDMenuCore owns the DVD-menu operations used immediately before review/upload.
+type cliDVDMenuCore interface {
+	ImportMenuImages(context.Context, api.Request, []string) error
+	CaptureDVDMenus(context.Context, api.Request) (api.DVDMenuCaptureResult, error)
+}
+
+// cliHistoryReleaseDeleter deletes stored history for one source path.
+type cliHistoryReleaseDeleter interface {
+	DeleteHistoryRelease(context.Context, string) error
+}
+
+// cliHistoryPurger deletes all stored release history.
+type cliHistoryPurger interface {
+	DeleteAllHistoryReleases(context.Context) (int, error)
+}
+
+// cliPlaylistSelectionCore owns the BDMV playlist operations used before upload.
+type cliPlaylistSelectionCore interface {
+	DetectDiscType(context.Context, string) (string, error)
+	DiscoverPlaylists(context.Context, string) ([]api.PlaylistInfo, error)
+	SavePlaylistSelection(context.Context, string, []string, bool) error
+	LoadPlaylistSelection(context.Context, string) (api.PlaylistSelection, error)
+}
+
+// cliUploadOnlyCore is the complete capability set for non-interactive upload-only runs.
+type cliUploadOnlyCore interface {
+	cliPreparedUploadRunner
+	cliAcceptedTrackerDryRunRunner
+	cliMetadataPreviewer
+	cliDVDMenuCore
+	cliDupeChecker
+}
+
+// run dispatches serve mode or the CLI workflow and converts parse/runtime
+// failures into stable process-exit errors for main.
 func run() error {
 	api.SetApplicationBuild(version, buildIdentifier)
 
@@ -263,7 +327,7 @@ func run() error {
 	}()
 
 	if opts.Cleanup {
-		deleted, err := coreSvc.DeleteAllHistoryReleases(setupCtx)
+		deleted, err := purgeCLIStoredReleases(setupCtx, coreSvc)
 		if err != nil {
 			return exitError(1, err)
 		}
@@ -301,7 +365,8 @@ func run() error {
 	// (not setupCtx): handleBDMVPlaylistSelection applies its own per-disc
 	// deadline internally and must keep the interactive prompt on an
 	// untimed-but-cancelable context.
-	if err := handleBDMVPlaylistSelection(ctx, paths, coreSvc, cfg, logger, opts); err != nil {
+	batch := newCLIPreparationBatch(api.Request{}, paths)
+	if err := handleBDMVPlaylistSelection(ctx, &batch, coreSvc, cfg, logger, opts); err != nil {
 		return exitError(1, err)
 	}
 
@@ -310,49 +375,69 @@ func run() error {
 		if err != nil {
 			return exitError(1, err)
 		}
+		batch = batch.withDefaults(uploadReq)
 		queueMode := strings.TrimSpace(opts.QueueName) != ""
 		if queueMode {
-			return runCLIUploadOnlyQueue(ctx, coreSvc, uploadReq, paths, opts.Debug, logger)
+			return runCLIUploadOnlyQueue(ctx, coreSvc, batch, opts.Debug, logger)
 		}
-		return runCLIUploadOnlyBatch(ctx, coreSvc, uploadReq, paths, opts.Debug, logger)
+		return runCLIUploadOnlyBatch(ctx, coreSvc, batch, opts.Debug, logger)
 	}
 
 	queueMode := strings.TrimSpace(opts.QueueName) != ""
-	return processCLIPaths(ctx, paths, queueMode, cliItemTimeout, logger, func(itemCtx context.Context, sourcePath string) error {
+	return processCLIPreparationItems(ctx, batch, queueMode, cliItemTimeout, logger, func(itemCtx context.Context, item cliPreparationItem) error {
 		if opts.SiteCheck {
-			return runSiteCheckCLIPath(itemCtx, coreSvc, opts, visitedFlags, sourcePath, screens)
-		}
-		return runInteractiveCLIPathWithLogger(itemCtx, coreSvc, os.Args[1:], opts, visitedFlags, sourcePath, screens, cfg, logger)
+			return runSiteCheckCLIItem(itemCtx, coreSvc, opts, visitedFlags, item, screens)
+		}
+		return runInteractiveCLIPathWithLoggerAndPlaylist(
+			itemCtx,
+			coreSvc,
+			os.Args[1:],
+			opts,
+			visitedFlags,
+			item.originalPath,
+			item.playlistInstruction,
+			screens,
+			cfg,
+			logger,
+		)
 	})
 }
 
-// runCLIUploadOnlyBatch runs upload-only over all paths in a single
-// RunUploadPrepared call (preserving its shared abort-on-first-error
-// semantics) under a deadline budgeted by item count but capped at
-// cliUploadOnlyTimeoutCap items so a large path list cannot create an
-// effectively unbounded run-wide timeout.
-func runCLIUploadOnlyBatch(ctx context.Context, coreSvc api.Core, uploadReq api.Request, paths []string, debug bool, logger api.Logger) error {
-	budgetItems := min(max(1, len(paths)), cliUploadOnlyTimeoutCap)
+// runCLIUploadOnlyBatch processes upload-only paths sequentially under one
+// capped deadline. Debug runs call only the shared tracker dry-run operation;
+// live runs call upload execution and stop on the first error.
+func runCLIUploadOnlyBatch(ctx context.Context, coreSvc cliUploadOnlyCore, batch cliPreparationBatch, debug bool, logger api.Logger) error {
+	budgetItems := min(max(1, len(batch.items)), cliUploadOnlyTimeoutCap)
 	uploadCtx, uploadCancel := context.WithTimeout(ctx, time.Duration(budgetItems)*cliItemTimeout)
 	defer uploadCancel()
-	preparedReq, err := prepareCLIUploadMetadata(uploadCtx, coreSvc, uploadReq)
-	if err != nil {
-		return exitError(1, err)
-	}
-	if err := prepareCLIImages(uploadCtx, coreSvc, preparedReq, logger, true); err != nil {
-		return exitError(1, err)
-	}
-	if debug {
-		reviews, err := buildCLIUploadDebugReviews(uploadCtx, coreSvc, paths, preparedReq)
+	for index := range batch.items {
+		itemReq := batch.request(index)
+		preparedReq, release, err := prepareCLIUploadMetadataWithRelease(uploadCtx, coreSvc, itemReq)
 		if err != nil {
 			return exitError(1, err)
 		}
-		for _, review := range reviews {
-			printDebugUploadReview(review)
+		batch.items[index].resolvedPath = preparedReq.SourcePath
+		if err := prepareCLIImages(uploadCtx, coreSvc, preparedReq, logger, true); err != nil {
+			return exitError(1, err)
+		}
+		if debug {
+			dupeSummary, err := coreSvc.CheckDupes(uploadCtx, preparedReq)
+			if err != nil {
+				return exitError(1, err)
+			}
+			preview, err := runAcceptedCLIDebugDryRun(uploadCtx, coreSvc, preparedReq, release, dupeSummary, false)
+			if err != nil {
+				return exitError(1, err)
+			}
+			if strings.TrimSpace(batch.items[index].originalPath) != "" {
+				preview.SourcePath = batch.items[index].originalPath
+			}
+			printDebugTrackerDryRun(preview)
+			continue
+		}
+		if _, err := coreSvc.RunUploadPrepared(uploadCtx, preparedReq); err != nil {
+			return exitError(1, err)
 		}
-	}
-	if _, err := coreSvc.RunUploadPrepared(uploadCtx, preparedReq); err != nil {
-		return exitError(1, err)
 	}
 	return nil
 }
@@ -360,15 +445,17 @@ func runCLIUploadOnlyBatch(ctx context.Context, coreSvc api.Core, uploadReq api.
 // runCLIUploadOnlyQueue runs upload-only in queue mode: each gathered path is
 // processed independently under its own cliItemTimeout via processCLIPaths, so a
 // single failing item is logged and skipped (continue-on-error) instead of
-// aborting the whole queue. Per item it prepares metadata, optionally prints the
-// debug review, and runs RunUploadPrepared for that one path, summing uploaded
-// counts across items.
-func runCLIUploadOnlyQueue(ctx context.Context, coreSvc api.Core, uploadReq api.Request, paths []string, debug bool, logger api.Logger) error {
+// aborting the whole queue. Per item it prepares metadata, then either runs and
+// prints the shared debug payload preview or executes a live upload. Live runs
+// sum accepted tracker uploads across items.
+func runCLIUploadOnlyQueue(ctx context.Context, coreSvc cliUploadOnlyCore, batch cliPreparationBatch, debug bool, logger api.Logger) error {
 	var uploaded int
-	err := processCLIPaths(ctx, paths, true, cliItemTimeout, logger, func(itemCtx context.Context, sourcePath string) error {
-		itemReq := uploadReq
-		itemReq.Paths = []string{sourcePath}
-		preparedReq, err := prepareCLIUploadMetadata(itemCtx, coreSvc, itemReq)
+	err := processCLIPreparationItems(ctx, batch, true, cliItemTimeout, logger, func(itemCtx context.Context, item cliPreparationItem) error {
+		itemReq := batch.defaults
+		itemReq.SourcePath = item.resolvedPath
+		itemReq.ExternalIDOverrides = item.externalIDs
+		itemReq.PlaylistInstruction = item.playlistInstruction
+		preparedReq, release, err := prepareCLIUploadMetadataWithRelease(itemCtx, coreSvc, itemReq)
 		if err != nil {
 			return err
 		}
@@ -376,24 +463,19 @@ func runCLIUploadOnlyQueue(ctx context.Context, coreSvc api.Core, uploadReq api.
 			return err
 		}
 		if debug {
-			// Single-path review: mirror the inline debug-review build rather than
-			// buildCLIUploadDebugReviews, whose Paths[idx] indexing is fragile when
-			// the request is already a single path.
-			resolvedPath := sourcePath
-			if len(preparedReq.Paths) > 0 && strings.TrimSpace(preparedReq.Paths[0]) != "" {
-				resolvedPath = preparedReq.Paths[0]
+			dupeSummary, err := coreSvc.CheckDupes(itemCtx, preparedReq)
+			if err != nil {
+				return fmt.Errorf("check duplicates for tracker debug %q: %w", preparedReq.SourcePath, err)
 			}
-			reviewReq := preparedReq
-			reviewReq.Paths = []string{resolvedPath}
-			reviewReq.ExternalIDSelections = cloneCLIExternalIDSelectionsForResolvedPath(preparedReq.ExternalIDSelections, sourcePath, resolvedPath)
-			review, err := coreSvc.BuildUploadReview(itemCtx, reviewReq)
+			preview, err := runAcceptedCLIDebugDryRun(itemCtx, coreSvc, preparedReq, release, dupeSummary, false)
 			if err != nil {
-				return fmt.Errorf("build upload review for %q: %w", resolvedPath, err)
+				return fmt.Errorf("run tracker debug for %q: %w", preparedReq.SourcePath, err)
 			}
-			if strings.TrimSpace(sourcePath) != "" {
-				review.SourcePath = sourcePath
+			if strings.TrimSpace(item.originalPath) != "" {
+				preview.SourcePath = item.originalPath
 			}
-			printDebugUploadReview(review)
+			printDebugTrackerDryRun(preview)
+			return nil
 		}
 		result, err := coreSvc.RunUploadPrepared(itemCtx, preparedReq)
 		// RunUploadPrepared can accept some tracker uploads and then fail on a
@@ -406,6 +488,10 @@ func runCLIUploadOnlyQueue(ctx context.Context, coreSvc api.Core, uploadReq api.
 		return nil
 	})
 	if logger != nil {
+		if debug {
+			logger.Infof("queue: upload-only debug completed, no tracker uploads submitted")
+			return err
+		}
 		// UploadedCount counts accepted tracker uploads, not queue items (one item
 		// may upload to several trackers), so report it as tracker uploads.
 		logger.Infof("queue: upload-only completed, %d tracker upload(s) accepted", uploaded)
@@ -414,76 +500,71 @@ func runCLIUploadOnlyQueue(ctx context.Context, coreSvc api.Core, uploadReq api.
 }
 
 // prepareCLIImages imports manual menu paths and optionally captures automatic
-// DVD menus for each request path before review or upload. Non-DVD paths are
-// skipped without invoking capture. Batch callers can continue after an empty
-// successful capture while retaining errors from CaptureDVDMenus.
-func prepareCLIImages(ctx context.Context, coreSvc api.Core, req api.Request, logger api.Logger, continueOnEmptyCapture bool) error {
+// DVD menus for one request source. Non-DVD paths are skipped without capture.
+func prepareCLIImages(ctx context.Context, coreSvc cliDVDMenuCore, req api.Request, logger api.Logger, continueOnEmptyCapture bool) error {
 	if coreSvc == nil {
 		return errors.New("upbrr: core service is required")
 	}
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
-	if len(req.Paths) == 0 {
+	if strings.TrimSpace(req.SourcePath) == "" {
 		return internalerrors.ErrInvalidInput
 	}
 
-	for _, sourcePath := range req.Paths {
-		singleReq := req
-		singleReq.Paths = []string{sourcePath}
-		if len(singleReq.ScreenshotOverrides.MenuPaths) > 0 {
-			if err := coreSvc.ImportMenuImages(ctx, singleReq, singleReq.ScreenshotOverrides.MenuPaths); err != nil {
-				return fmt.Errorf("upbrr: import menu images: %w", err)
-			}
-		}
-		if !singleReq.Options.CaptureDVDMenus {
-			continue
+	sourcePath := req.SourcePath
+	if len(req.ScreenshotOverrides.MenuPaths) > 0 {
+		if err := coreSvc.ImportMenuImages(ctx, req, req.ScreenshotOverrides.MenuPaths); err != nil {
+			return fmt.Errorf("upbrr: import menu images: %w", err)
 		}
+	}
+	if !req.Options.CaptureDVDMenus {
+		return nil
+	}
 
-		discType, err := filesystem.DetectDiscType(ctx, sourcePath)
-		if err != nil {
-			return fmt.Errorf("upbrr: detect DVD menu source: %w", err)
-		}
-		if !strings.EqualFold(strings.TrimSpace(discType), "DVD") {
-			label := strings.TrimSpace(discType)
-			if label == "" {
-				label = "none"
-			}
-			logger.Infof("DVD menus: capture skipped disc_type=%s decision=skip", label)
-			fmt.Printf("DVD menu capture skipped: %s is not a DVD\n", formatPathLabel(sourcePath))
-			continue
+	discType, err := filesystem.DetectDiscType(ctx, sourcePath)
+	if err != nil {
+		return fmt.Errorf("upbrr: detect DVD menu source: %w", err)
+	}
+	if !strings.EqualFold(strings.TrimSpace(discType), "DVD") {
+		label := strings.TrimSpace(discType)
+		if label == "" {
+			label = "none"
 		}
+		logger.Infof("DVD menus: capture skipped disc_type=%s decision=skip", label)
+		fmt.Printf("DVD menu capture skipped: %s is not a DVD\n", formatPathLabel(sourcePath))
+		return nil
+	}
 
-		result, err := coreSvc.CaptureDVDMenus(ctx, singleReq)
-		if err != nil {
-			return fmt.Errorf("upbrr: capture DVD menus: %w", err)
-		}
-		if len(result.Images) == 0 {
-			if !continueOnEmptyCapture {
-				return errors.New("upbrr: capture DVD menus: no menu images captured")
-			}
-			logger.Errorf(
-				"DVD menus: capture failed source=%s decision=continue reason=no_images",
-				formatPathLabel(sourcePath),
-			)
-			continue
-		}
-		if result.Partial {
-			logger.Warnf(
-				"DVD menus: capture incomplete captured=%d warnings=%d truncated=%t",
-				len(result.Images),
-				len(result.Warnings),
-				result.Truncated,
-			)
-			fmt.Printf("DVD menus ready: %d (capture incomplete)\n", len(result.Images))
-			continue
-		}
-		if result.Truncated {
-			fmt.Printf("DVD menus ready: %d (maximum reached)\n", len(result.Images))
-			continue
+	result, err := coreSvc.CaptureDVDMenus(ctx, req)
+	if err != nil {
+		return fmt.Errorf("upbrr: capture DVD menus: %w", err)
+	}
+	if len(result.Images) == 0 {
+		if !continueOnEmptyCapture {
+			return errors.New("upbrr: capture DVD menus: no menu images captured")
 		}
-		fmt.Printf("DVD menus ready: %d\n", len(result.Images))
+		logger.Errorf(
+			"DVD menus: capture failed source=%s decision=continue reason=no_images",
+			formatPathLabel(sourcePath),
+		)
+		return nil
+	}
+	if result.Partial {
+		logger.Warnf(
+			"DVD menus: capture incomplete captured=%d warnings=%d truncated=%t",
+			len(result.Images),
+			len(result.Warnings),
+			result.Truncated,
+		)
+		fmt.Printf("DVD menus ready: %d (capture incomplete)\n", len(result.Images))
+		return nil
 	}
+	if result.Truncated {
+		fmt.Printf("DVD menus ready: %d (maximum reached)\n", len(result.Images))
+		return nil
+	}
+	fmt.Printf("DVD menus ready: %d\n", len(result.Images))
 	return nil
 }
 
@@ -492,7 +573,14 @@ func prepareCLIImages(ctx context.Context, coreSvc api.Core, req api.Request, lo
 // of the queue still runs, with a summary error returned at the end if any item
 // failed. Outside queue mode the first failure aborts immediately, preserving
 // the original single/multi-path behavior.
-func processCLIPaths(ctx context.Context, paths []string, queueMode bool, itemTimeout time.Duration, logger api.Logger, process func(ctx context.Context, sourcePath string) error) error {
+func processCLIPaths(
+	ctx context.Context,
+	paths []string,
+	queueMode bool,
+	itemTimeout time.Duration,
+	logger api.Logger,
+	process func(ctx context.Context, sourcePath string) error,
+) error {
 	failed := make([]string, 0)
 	var firstErr error
 	// abortOnCancel returns a terminal error when the parent context is done (a
@@ -555,10 +643,15 @@ func processCLIPaths(ctx context.Context, paths []string, queueMode bool, itemTi
 // each queue item receives a full timeout budget rather than sharing one
 // run-wide deadline. The deadline is enforced cooperatively: itemCtx is threaded
 // into every core call (FetchMetadataPreview, CheckDupes, screenshot handling,
-// BuildUploadReview, RunUploadPrepared, etc.) and honored only when those calls
-// check ctx. A core operation that ignores ctx will run past itemTimeout; the
+// BuildUploadReview, RunAcceptedTrackerDryRun, RunUploadPrepared, etc.) and honored only
+// when those calls check ctx. A core operation that ignores ctx will run past itemTimeout; the
 // timeout cannot forcibly kill in-flight work.
-func runCLIPathWithTimeout(ctx context.Context, itemTimeout time.Duration, sourcePath string, process func(ctx context.Context, sourcePath string) error) error {
+func runCLIPathWithTimeout(
+	ctx context.Context,
+	itemTimeout time.Duration,
+	sourcePath string,
+	process func(ctx context.Context, sourcePath string) error,
+) error {
 	itemCtx, cancel := context.WithTimeout(ctx, itemTimeout)
 	defer cancel()
 	return process(itemCtx, sourcePath)
@@ -1235,7 +1328,15 @@ func normalizeCLIPaths(ctx context.Context, paths []string) ([]string, error) {
 	return normalized, nil
 }
 
-func deleteCLIStoredReleases(ctx context.Context, coreSvc api.Core, paths []string) error {
+func purgeCLIStoredReleases(ctx context.Context, coreSvc cliHistoryPurger) (int, error) {
+	count, err := coreSvc.DeleteAllHistoryReleases(ctx)
+	if err != nil {
+		return count, fmt.Errorf("purge stored releases: %w", err)
+	}
+	return count, nil
+}
+
+func deleteCLIStoredReleases(ctx context.Context, coreSvc cliHistoryReleaseDeleter, paths []string) error {
 	for _, sourcePath := range paths {
 		if err := coreSvc.DeleteHistoryRelease(ctx, sourcePath); err != nil {
 			return fmt.Errorf("delete stored data for %q: %w", sourcePath, err)
@@ -1245,36 +1346,137 @@ func deleteCLIStoredReleases(ctx context.Context, coreSvc api.Core, paths []stri
 	return nil
 }
 
-func prepareCLIUploadMetadata(ctx context.Context, coreSvc api.Core, req api.Request) (api.Request, error) {
-	resolvedReq := req
-	resolvedPaths := make([]string, 0, len(req.Paths))
-	resolvedSelections := req.ExternalIDSelections
-	for _, sourcePath := range req.Paths {
-		singleReq := req
-		singleReq.Paths = []string{sourcePath}
-		singleReq.ExternalIDSelections = resolvedSelections
-		preview, err := coreSvc.FetchMetadataPreview(ctx, singleReq)
+// cliPreparationItem keeps source-specific resolution, identity, and playlist
+// choices detached from batch defaults.
+type cliPreparationItem struct {
+	originalPath        string
+	resolvedPath        string
+	externalIDs         api.ExternalIDOverrides
+	playlistInstruction api.PlaylistInstruction
+}
+
+// cliPreparationBatch owns immutable request defaults plus isolated per-source instructions.
+type cliPreparationBatch struct {
+	defaults api.Request
+	items    []cliPreparationItem
+}
+
+// cloneCLIPlaylistInstruction detaches the selected-playlist slice.
+func cloneCLIPlaylistInstruction(value api.PlaylistInstruction) api.PlaylistInstruction {
+	value.Selected = append([]string(nil), value.Selected...)
+	return value
+}
+
+// cloneCLIExternalIDOverrides detaches all optional provider ID pointers.
+func cloneCLIExternalIDOverrides(value api.ExternalIDOverrides) api.ExternalIDOverrides {
+	return api.ExternalIDOverrides{
+		TMDBID:   cloneCLIInt(value.TMDBID),
+		IMDBID:   cloneCLIInt(value.IMDBID),
+		TVDBID:   cloneCLIInt(value.TVDBID),
+		TVmazeID: cloneCLIInt(value.TVmazeID),
+		MALID:    cloneCLIInt(value.MALID),
+	}
+}
+
+// cloneCLIInt copies an optional integer pointer.
+func cloneCLIInt(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+// newCLIPreparationBatch clones pointer- and slice-backed defaults for every source.
+func newCLIPreparationBatch(defaults api.Request, paths []string) cliPreparationBatch {
+	items := make([]cliPreparationItem, 0, len(paths))
+	for _, sourcePath := range paths {
+		items = append(items, cliPreparationItem{
+			originalPath:        sourcePath,
+			resolvedPath:        sourcePath,
+			externalIDs:         cloneCLIExternalIDOverrides(defaults.ExternalIDOverrides),
+			playlistInstruction: cloneCLIPlaylistInstruction(defaults.PlaylistInstruction),
+		})
+	}
+	defaults.SourcePath = ""
+	return cliPreparationBatch{defaults: defaults, items: items}
+}
+
+// withDefaults replaces shared defaults without overwriting an explicit
+// source-specific playlist instruction.
+func (b cliPreparationBatch) withDefaults(defaults api.Request) cliPreparationBatch {
+	defaults.SourcePath = ""
+	b.defaults = defaults
+	for index := range b.items {
+		b.items[index].externalIDs = cloneCLIExternalIDOverrides(defaults.ExternalIDOverrides)
+		if !b.items[index].playlistInstruction.Set {
+			b.items[index].playlistInstruction = cloneCLIPlaylistInstruction(defaults.PlaylistInstruction)
+		}
+	}
+	return b
+}
+
+// request materializes one request using the item's resolved source path and
+// source-specific identity and playlist choices.
+func (b cliPreparationBatch) request(index int) api.Request {
+	item := b.items[index]
+	request := b.defaults
+	request.SourcePath = item.resolvedPath
+	request.ExternalIDOverrides = cloneCLIExternalIDOverrides(item.externalIDs)
+	request.PlaylistInstruction = cloneCLIPlaylistInstruction(item.playlistInstruction)
+	return request
+}
+
+// processCLIPreparationItems delegates timeout and queue policy while preserving
+// each item's source-scoped instructions.
+func processCLIPreparationItems(
+	ctx context.Context,
+	batch cliPreparationBatch,
+	queueMode bool,
+	itemTimeout time.Duration,
+	logger api.Logger,
+	process func(context.Context, cliPreparationItem) error,
+) error {
+	paths := make([]string, 0, len(batch.items))
+	for _, item := range batch.items {
+		paths = append(paths, item.originalPath)
+	}
+	index := 0
+	return processCLIPaths(ctx, paths, queueMode, itemTimeout, logger, func(itemCtx context.Context, _ string) error {
+		item := batch.items[index]
+		index++
+		return process(itemCtx, item)
+	})
+}
+
+func prepareCLIUploadMetadata(ctx context.Context, coreSvc cliMetadataPreviewer, req api.Request) (api.Request, error) {
+	resolvedReq, _, err := prepareCLIUploadMetadataWithRelease(ctx, coreSvc, req)
+	return resolvedReq, err
+}
+
+func prepareCLIUploadMetadataWithRelease(
+	ctx context.Context,
+	coreSvc cliMetadataPreviewer,
+	req api.Request,
+) (api.Request, api.ReleaseRef, error) {
+	sourcePath := req.SourcePath
+	preview, err := coreSvc.FetchMetadataPreview(ctx, req)
+	if err != nil {
+		return api.Request{}, api.ReleaseRef{}, fmt.Errorf("upbrr: %w", err)
+	}
+	resolvedPath := resolvedCLIMetadataSourcePath(sourcePath, preview)
+	if shouldRefreshCLIResolvedMetadataPreview(req, sourcePath, resolvedPath) {
+		resolvedReq := req
+		resolvedReq.SourcePath = resolvedPath
+		preview, err = coreSvc.FetchMetadataPreview(ctx, resolvedReq)
 		if err != nil {
-			return api.Request{}, fmt.Errorf("upbrr: %w", err)
-		}
-		resolvedPath := resolvedCLIMetadataSourcePath(sourcePath, preview)
-		resolvedSelections = cloneCLIExternalIDSelectionsForResolvedPath(resolvedSelections, sourcePath, resolvedPath)
-		if shouldRefreshCLIResolvedMetadataPreview(singleReq, sourcePath, resolvedPath) {
-			resolvedReq := singleReq
-			resolvedReq.Paths = []string{resolvedPath}
-			resolvedReq.ExternalIDSelections = resolvedSelections
-			preview, err = coreSvc.FetchMetadataPreview(ctx, resolvedReq)
-			if err != nil {
-				return api.Request{}, fmt.Errorf("upbrr: %w", err)
-			}
-			resolvedPath = resolvedCLIMetadataSourcePath(resolvedPath, preview)
-			resolvedSelections = cloneCLIExternalIDSelectionsForResolvedPath(resolvedSelections, sourcePath, resolvedPath)
+			return api.Request{}, api.ReleaseRef{}, fmt.Errorf("upbrr: %w", err)
 		}
-		resolvedPaths = append(resolvedPaths, resolvedPath)
+		resolvedPath = resolvedCLIMetadataSourcePath(resolvedPath, preview)
 	}
-	resolvedReq.Paths = resolvedPaths
-	resolvedReq.ExternalIDSelections = resolvedSelections
-	return resolvedReq, nil
+	resolvedReq := req
+	resolvedReq.SourcePath = resolvedPath
+	return resolvedReq, preview.Release, nil
 }
 
 func shouldRefreshCLIResolvedMetadataPreview(req api.Request, sourcePath string, resolvedPath string) bool {
@@ -1286,11 +1488,7 @@ func shouldRefreshCLIResolvedMetadataPreview(req api.Request, sourcePath string,
 	if filepath.Clean(trimmedSourcePath) == filepath.Clean(trimmedResolvedPath) {
 		return false
 	}
-	if cliHasExternalIDOverrides(req.ExternalIDOverrides) {
-		return true
-	}
-	_, ok := resolveCLIExternalIDSelection(req.ExternalIDSelections, sourcePath)
-	return ok
+	return cliHasExternalIDOverrides(req.ExternalIDOverrides)
 }
 
 func cliHasExternalIDOverrides(overrides api.ExternalIDOverrides) bool {
@@ -1301,73 +1499,6 @@ func cliHasExternalIDOverrides(overrides api.ExternalIDOverrides) bool {
 		overrides.MALID != nil
 }
 
-// buildCLIUploadDebugReviews builds one review per original CLI source path,
-// preserving the original display path while using any prepared resolved path.
-func buildCLIUploadDebugReviews(ctx context.Context, coreSvc api.Core, sourcePaths []string, uploadReq api.Request) ([]api.UploadReview, error) {
-	reviews := make([]api.UploadReview, 0, len(sourcePaths))
-	for idx, sourcePath := range sourcePaths {
-		resolvedPath := sourcePath
-		if idx < len(uploadReq.Paths) && strings.TrimSpace(uploadReq.Paths[idx]) != "" {
-			resolvedPath = uploadReq.Paths[idx]
-		}
-		debugReq := uploadReq
-		debugReq.Paths = []string{resolvedPath}
-		debugReq.ExternalIDSelections = cloneCLIExternalIDSelectionsForResolvedPath(uploadReq.ExternalIDSelections, sourcePath, resolvedPath)
-		review, err := coreSvc.BuildUploadReview(ctx, debugReq)
-		if err != nil {
-			return nil, fmt.Errorf("build upload review for %q: %w", resolvedPath, err)
-		}
-		if strings.TrimSpace(sourcePath) != "" {
-			review.SourcePath = sourcePath
-		}
-		reviews = append(reviews, review)
-	}
-	return reviews, nil
-}
-
-func cloneCLIExternalIDSelectionsForResolvedPath(selections map[string]api.ExternalIDSelection, sourcePath string, resolvedPath string) map[string]api.ExternalIDSelection {
-	if len(selections) == 0 {
-		return selections
-	}
-	trimmedSourcePath := strings.TrimSpace(sourcePath)
-	trimmedResolvedPath := strings.TrimSpace(resolvedPath)
-	if trimmedResolvedPath == "" || trimmedSourcePath == "" {
-		return selections
-	}
-	if filepath.Clean(trimmedSourcePath) == filepath.Clean(trimmedResolvedPath) {
-		return selections
-	}
-	selected, ok := resolveCLIExternalIDSelection(selections, sourcePath)
-	if !ok {
-		return selections
-	}
-	// Current source-path selections must replace any stale resolved-path
-	// selections carried from a previous run or source change.
-	cloned := make(map[string]api.ExternalIDSelection, len(selections)+1)
-	maps.Copy(cloned, selections)
-	cloned[trimmedResolvedPath] = selected
-	return cloned
-}
-
-func resolveCLIExternalIDSelection(selections map[string]api.ExternalIDSelection, sourcePath string) (api.ExternalIDSelection, bool) {
-	if len(selections) == 0 {
-		return api.ExternalIDSelection{}, false
-	}
-	if selected, ok := selections[sourcePath]; ok {
-		return selected, true
-	}
-	cleanedSourcePath := filepath.Clean(sourcePath)
-	if selected, ok := selections[cleanedSourcePath]; ok {
-		return selected, true
-	}
-	for key, selected := range selections {
-		if filepath.Clean(key) == cleanedSourcePath {
-			return selected, true
-		}
-	}
-	return api.ExternalIDSelection{}, false
-}
-
 // isCtxErr reports whether err is a context cancellation/deadline error,
 // signalling the run-wide deadline or an explicit cancel has fired. BDMV
 // setup must abort (not skip the path) when this happens so cancellation is
@@ -1376,24 +1507,35 @@ func isCtxErr(err error) bool {
 	return errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)
 }
 
-// handleBDMVPlaylistSelection resolves playlist selections for each BDMV disc in
-// paths. ctx is the untimed-but-cancelable parent context; each disc gets its
+// handleBDMVPlaylistSelection resolves and attaches one playlist instruction to
+// each BDMV preparation item. ctx is the untimed-but-cancelable parent context; each disc gets its
 // own cliDiscDiscoveryTimeout for the timed detection/load/discover/save work so
 // one slow disc cannot starve the rest of the queue. The interactive playlist
 // prompt runs on the parent (cancelable, untimed) context, not the per-disc
 // deadline, so a long human wait does not abort.
-func handleBDMVPlaylistSelection(ctx context.Context, paths []string, coreSvc api.Core, cfg config.Config, logger api.Logger, opts cliOptions) error {
-	if len(paths) == 0 {
+func handleBDMVPlaylistSelection(
+	ctx context.Context,
+	batch *cliPreparationBatch,
+	coreSvc cliPlaylistSelectionCore,
+	cfg config.Config,
+	logger api.Logger,
+	opts cliOptions,
+) error {
+	if batch == nil || len(batch.items) == 0 {
 		return nil
 	}
 
-	for _, path := range paths {
+	for index := range batch.items {
+		path := batch.items[index].originalPath
 		discCtx, discCancel := context.WithTimeout(ctx, cliDiscDiscoveryTimeout)
-		err := handleBDMVDiscSelection(discCtx, ctx, path, coreSvc, cfg, logger, opts)
+		instruction, err := handleBDMVDiscSelection(discCtx, ctx, path, coreSvc, cfg, logger, opts)
 		discCancel()
 		if err != nil {
 			return err
 		}
+		if instruction.Set {
+			batch.items[index].playlistInstruction = instruction
+		}
 	}
 	return nil
 }
@@ -1405,19 +1547,27 @@ func handleBDMVPlaylistSelection(ctx context.Context, paths []string, coreSvc ap
 // human wait does not trip the per-disc deadline. A context error from any timed
 // operation aborts (returns) rather than skipping the path, surfacing
 // cancellation instead of swallowing it.
-func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context, path string, coreSvc api.Core, cfg config.Config, logger api.Logger, opts cliOptions) error {
-	// Check if this path is a BDMV folder
-	discType, err := filesystem.DetectDiscType(discCtx, path)
+func handleBDMVDiscSelection(
+	discCtx context.Context,
+	promptCtx context.Context,
+	path string,
+	coreSvc cliPlaylistSelectionCore,
+	cfg config.Config,
+	logger api.Logger,
+	opts cliOptions,
+) (api.PlaylistInstruction, error) {
+	// Classify the preparation source without requiring the CLI to derive its disc root.
+	discType, err := coreSvc.DetectDiscType(discCtx, path)
 	if err != nil {
 		if isCtxErr(err) {
-			return fmt.Errorf("upbrr: BDMV disc type detection cancelled for %s: %w", path, err)
+			return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV disc type detection cancelled for %s: %w", path, err)
 		}
 		logger.Debugf("cli: disc type detection failed for %s: %v", path, err)
-		return nil
+		return api.PlaylistInstruction{}, nil
 	}
 
 	if discType != "BDMV" {
-		return nil
+		return api.PlaylistInstruction{}, nil
 	}
 
 	logger.Infof("cli: BDMV disc detected at %s", path)
@@ -1426,22 +1576,26 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 	absPath, err := filepath.Abs(path)
 	if err != nil {
 		logger.Warnf("cli: resolve path %s: %v", path, err)
-		return nil
+		return api.PlaylistInstruction{}, nil
 	}
 
 	// Check if playlist selection is already persisted
-	_, err = coreSvc.LoadPlaylistSelection(discCtx, absPath)
+	remembered, err := coreSvc.LoadPlaylistSelection(discCtx, absPath)
 	if err == nil {
 		logger.Infof("cli: using previously saved playlist selection for %s", absPath)
-		return nil
+		return api.PlaylistInstruction{
+			Set:      true,
+			Selected: append([]string(nil), remembered.SelectedPlaylists...),
+			UseAll:   remembered.UseAll,
+		}, nil
 	}
 	if err != nil {
 		if isCtxErr(err) {
-			return fmt.Errorf("upbrr: BDMV playlist selection load cancelled for %s: %w", absPath, err)
+			return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection load cancelled for %s: %w", absPath, err)
 		}
 		if !errors.Is(err, internalerrors.ErrNotFound) {
 			logger.Warnf("cli: load playlist selection: %v", err)
-			return nil
+			return api.PlaylistInstruction{}, nil
 		}
 	}
 
@@ -1452,35 +1606,32 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 		playlists, err := coreSvc.DiscoverPlaylists(discCtx, absPath)
 		if err != nil {
 			if isCtxErr(err) {
-				return fmt.Errorf("upbrr: BDMV playlist discovery cancelled for %s: %w", absPath, err)
+				return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist discovery cancelled for %s: %w", absPath, err)
 			}
 			if opts.Unattended && !opts.UnattendedConfirm {
-				return fmt.Errorf("upbrr: unattended BDMV playlist discovery failed for %s: %w", absPath, err)
+				return api.PlaylistInstruction{}, fmt.Errorf("upbrr: unattended BDMV playlist discovery failed for %s: %w", absPath, err)
 			}
 			logger.Warnf("cli: discover playlists: %v", err)
-			return nil
+			return api.PlaylistInstruction{}, nil
 		}
 
 		if len(playlists) == 0 {
 			if opts.Unattended && !opts.UnattendedConfirm {
-				return fmt.Errorf("upbrr: unattended BDMV upload found no playlists for %s", absPath)
+				return api.PlaylistInstruction{}, fmt.Errorf("upbrr: unattended BDMV upload found no playlists for %s", absPath)
 			}
-			return nil
+			return api.PlaylistInstruction{}, nil
 		}
 		// Save the best (highest-scoring) playlist
 		selected := []string{playlists[0].File}
 		if err := coreSvc.SavePlaylistSelection(discCtx, absPath, selected, false); err != nil {
 			if isCtxErr(err) {
-				return fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
-			}
-			if opts.Unattended && !opts.UnattendedConfirm {
-				return fmt.Errorf("upbrr: unattended BDMV playlist selection save failed for %s: %w", absPath, err)
+				return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
 			}
 			logger.Warnf("cli: save playlist selection: %v", err)
 		} else {
 			logger.Infof("cli: auto-selected playlist %s (score: %.2f)", playlists[0].File, playlists[0].Score)
 		}
-		return nil
+		return api.PlaylistInstruction{Set: true, Selected: selected}, nil
 	}
 
 	// Interactive selection required
@@ -1488,26 +1639,29 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 	playlists, err := coreSvc.DiscoverPlaylists(discCtx, absPath)
 	if err != nil {
 		if isCtxErr(err) {
-			return fmt.Errorf("upbrr: BDMV playlist discovery cancelled for %s: %w", absPath, err)
+			return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist discovery cancelled for %s: %w", absPath, err)
 		}
 		if opts.Unattended && !opts.UnattendedConfirm {
-			return fmt.Errorf("upbrr: unattended BDMV playlist discovery failed for %s: %w", absPath, err)
+			return api.PlaylistInstruction{}, fmt.Errorf("upbrr: unattended BDMV playlist discovery failed for %s: %w", absPath, err)
 		}
 		logger.Warnf("cli: discover playlists: %v", err)
-		return nil
+		return api.PlaylistInstruction{}, nil
 	}
 
 	if len(playlists) == 0 {
 		if opts.Unattended && !opts.UnattendedConfirm {
-			return fmt.Errorf("upbrr: unattended BDMV upload found no playlists for %s", absPath)
+			return api.PlaylistInstruction{}, fmt.Errorf("upbrr: unattended BDMV upload found no playlists for %s", absPath)
 		}
 		logger.Warnf("cli: no playlists found for %s", absPath)
-		return nil
+		return api.PlaylistInstruction{}, nil
 	}
 
 	logger.Infof("cli: found %d playlists", len(playlists))
 	if opts.Unattended && !opts.UnattendedConfirm && len(playlists) > 1 {
-		return fmt.Errorf("upbrr: unattended BDMV upload requires a saved playlist selection or use_largest_playlist for %s", absPath)
+		return api.PlaylistInstruction{}, fmt.Errorf(
+			"upbrr: unattended BDMV upload requires a saved playlist selection or use_largest_playlist for %s",
+			absPath,
+		)
 	}
 
 	// Display top playlists and prompt user
@@ -1516,14 +1670,11 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 		fmt.Printf("[*] Auto-selecting...\n")
 		if err := coreSvc.SavePlaylistSelection(discCtx, absPath, []string{playlists[0].File}, false); err != nil {
 			if isCtxErr(err) {
-				return fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
-			}
-			if opts.Unattended && !opts.UnattendedConfirm {
-				return fmt.Errorf("upbrr: unattended BDMV playlist selection save failed for %s: %w", absPath, err)
+				return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
 			}
 			logger.Warnf("cli: save playlist selection: %v", err)
 		}
-		return nil
+		return api.PlaylistInstruction{Set: true, Selected: []string{playlists[0].File}}, nil
 	}
 
 	// Display top 5 playlists
@@ -1540,6 +1691,7 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 	// promptCtx (NOT discCtx) so a long human wait does not trip the per-disc
 	// deadline; the saves inside it are bounded by a fresh short deadline derived
 	// from promptCtx so they remain cancelable but the user-wait is not timed.
+	var instruction api.PlaylistInstruction
 	for {
 		fmt.Printf("\nEnter playlist numbers (comma-separated), 'ALL' to select all top %d, or press Enter to auto-select best: ", topCount)
 		var input string
@@ -1550,12 +1702,13 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 		}
 		if n == 0 || strings.TrimSpace(input) == "" {
 			// Auto-select best
+			instruction = api.PlaylistInstruction{Set: true, Selected: []string{playlists[0].File}}
 			saveCtx, saveCancel := context.WithTimeout(promptCtx, cliDiscDiscoveryTimeout)
 			err := coreSvc.SavePlaylistSelection(saveCtx, absPath, []string{playlists[0].File}, false)
 			saveCancel()
 			if err != nil {
 				if isCtxErr(err) {
-					return fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
+					return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
 				}
 				logger.Warnf("cli: save playlist selection: %v", err)
 			} else {
@@ -1570,12 +1723,17 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 			for i := range topCount {
 				selected = append(selected, playlists[i].File)
 			}
+			instruction = api.PlaylistInstruction{
+				Set:      true,
+				Selected: append([]string(nil), selected...),
+				UseAll:   true,
+			}
 			saveCtx, saveCancel := context.WithTimeout(promptCtx, cliDiscDiscoveryTimeout)
 			err := coreSvc.SavePlaylistSelection(saveCtx, absPath, selected, true)
 			saveCancel()
 			if err != nil {
 				if isCtxErr(err) {
-					return fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
+					return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
 				}
 				logger.Warnf("cli: save playlist selection: %v", err)
 			} else {
@@ -1601,12 +1759,13 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 		}
 
 		if valid && len(selected) > 0 {
+			instruction = api.PlaylistInstruction{Set: true, Selected: append([]string(nil), selected...)}
 			saveCtx, saveCancel := context.WithTimeout(promptCtx, cliDiscDiscoveryTimeout)
 			err := coreSvc.SavePlaylistSelection(saveCtx, absPath, selected, false)
 			saveCancel()
 			if err != nil {
 				if isCtxErr(err) {
-					return fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
+					return api.PlaylistInstruction{}, fmt.Errorf("upbrr: BDMV playlist selection save cancelled for %s: %w", absPath, err)
 				}
 				logger.Warnf("cli: save playlist selection: %v", err)
 			} else {
@@ -1617,7 +1776,7 @@ func handleBDMVDiscSelection(discCtx context.Context, promptCtx context.Context,
 
 		fmt.Printf("[!] Please try again.\n")
 	}
-	return nil
+	return instruction, nil
 }
 
 func formatDuration(seconds float64) string {
diff --git a/cmd/upbrr/main_test.go b/cmd/upbrr/main_test.go
index 5cf2ea53..428003f3 100644
--- a/cmd/upbrr/main_test.go
+++ b/cmd/upbrr/main_test.go
@@ -6,9 +6,11 @@ package main
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net"
 	"os"
 	"path/filepath"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -17,10 +19,64 @@ import (
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
 	"github.com/autobrr/upbrr/internal/webserver"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+func runCLIUploadOnlyQueueForPaths(
+	ctx context.Context,
+	coreSvc cliUploadOnlyCore,
+	request api.Request,
+	paths []string,
+) error {
+	return runCLIUploadOnlyQueue(ctx, coreSvc, newCLIPreparationBatch(request, paths), false, api.NopLogger{})
+}
+
+func TestCLIPreparationBatchOwnsPerSourceInstructions(t *testing.T) {
+	t.Parallel()
+
+	tmdbID := 1234567
+	defaults := api.Request{
+		ExternalIDOverrides: api.ExternalIDOverrides{TMDBID: &tmdbID},
+		PlaylistInstruction: api.PlaylistInstruction{Set: true, Selected: []string{"00001.mpls"}},
+	}
+	batch := newCLIPreparationBatch(defaults, []string{"one", "two"})
+	*defaults.ExternalIDOverrides.TMDBID = 7654321
+	defaults.PlaylistInstruction.Selected[0] = "99999.mpls"
+	*batch.items[0].externalIDs.TMDBID = 1111111
+	batch.items[0].playlistInstruction.Selected[0] = "00002.mpls"
+
+	if got := *batch.items[1].externalIDs.TMDBID; got != 1234567 {
+		t.Fatalf("second item TMDB ID = %d, want detached value", got)
+	}
+	if got := batch.items[1].playlistInstruction.Selected[0]; got != "00001.mpls" {
+		t.Fatalf("second item playlist = %q, want detached value", got)
+	}
+}
+
+func runCLIUploadOnlyBatchForPaths(
+	ctx context.Context,
+	coreSvc cliUploadOnlyCore,
+	request api.Request,
+	paths []string,
+	debug bool,
+	logger api.Logger,
+) error {
+	return runCLIUploadOnlyBatch(ctx, coreSvc, newCLIPreparationBatch(request, paths), debug, logger)
+}
+
+func handleBDMVPlaylistSelectionForPaths(
+	ctx context.Context,
+	paths []string,
+	coreSvc cliPlaylistSelectionCore,
+	cfg config.Config,
+	opts cliOptions,
+) error {
+	batch := newCLIPreparationBatch(api.Request{}, paths)
+	return handleBDMVPlaylistSelection(ctx, &batch, coreSvc, cfg, api.NopLogger{}, opts)
+}
+
 func TestProcessCLIPathsQueueModeContinuesOnError(t *testing.T) {
 	t.Parallel()
 
@@ -80,9 +136,11 @@ func TestProcessCLIPathsAppliesPerItemTimeout(t *testing.T) {
 	t.Parallel()
 
 	paths := []string{"slow", "fast"}
-	fastSawFreshDeadline := false
+	var slowDeadline time.Time
+	var fastDeadline time.Time
 	err := processCLIPaths(context.Background(), paths, true, 20*time.Millisecond, api.NopLogger{}, func(itemCtx context.Context, sourcePath string) error {
 		if sourcePath == "slow" {
+			slowDeadline, _ = itemCtx.Deadline()
 			// Exceed the per-item timeout; this item should be cancelled at
 			// ~20ms rather than running to completion.
 			select {
@@ -94,16 +152,14 @@ func TestProcessCLIPathsAppliesPerItemTimeout(t *testing.T) {
 		}
 		// The next item must receive a fresh per-item deadline, proving the
 		// timeout is not shared across the queue.
-		if deadline, ok := itemCtx.Deadline(); ok && time.Until(deadline) > 5*time.Millisecond {
-			fastSawFreshDeadline = true
-		}
+		fastDeadline, _ = itemCtx.Deadline()
 		return nil
 	})
 	if err == nil {
 		t.Fatal("expected a summary error because the slow item timed out")
 	}
-	if !fastSawFreshDeadline {
-		t.Fatal("expected the second item to get a fresh per-item deadline")
+	if slowDeadline.IsZero() || fastDeadline.IsZero() || !fastDeadline.After(slowDeadline) {
+		t.Fatalf("expected the second item to get a later per-item deadline: slow=%v fast=%v", slowDeadline, fastDeadline)
 	}
 }
 
@@ -394,9 +450,6 @@ func TestRunHelpFlagsPrintUsageAndSucceed(t *testing.T) {
 					t.Fatalf("expected output to contain %q, got %q", expected, output)
 				}
 			}
-			if strings.Contains(output, "-gui") {
-				t.Fatalf("expected GUI flag to be absent from help, got %q", output)
-			}
 		})
 	}
 }
@@ -451,7 +504,11 @@ func TestServePersistConfigListenOnlyClearsStoredBaseURL(t *testing.T) {
 	runtime.Port = 9090
 	runtime.BaseURL = "/temporary/"
 
-	persisted := servePersistConfig(stored, runtime, map[string]bool{"persist-listen": true, "addr": true, "base-url": true})
+	persisted := servePersistConfig(stored, runtime, map[string]bool{
+		"persist-listen": true,
+		"addr":           true,
+		"base-url":       true,
+	})
 	if persisted.Host != "0.0.0.0" || persisted.Port != 9090 {
 		t.Fatalf("listen settings not persisted: %#v", persisted)
 	}
@@ -464,21 +521,38 @@ func TestServePersistConfigListenOnlyClearsStoredBaseURL(t *testing.T) {
 }
 
 func TestServePersistConfigWebConfigPersistsBaseURL(t *testing.T) {
-	stored := webserver.CLIConfig{Host: "localhost", Port: 7480, BaseURL: "/stored/"}
+	stored := webserver.CLIConfig{
+		Host:    "localhost",
+		Port:    7480,
+		BaseURL: "/stored/",
+	}
 	runtime := stored
 	runtime.Host = "0.0.0.0"
 	runtime.Port = 9090
 	runtime.BaseURL = "/explicit/"
 
-	persisted := servePersistConfig(stored, runtime, map[string]bool{"persist-listen": true, "persist-web-config": true, "addr": true, "base-url": true})
+	persisted := servePersistConfig(stored, runtime, map[string]bool{
+		"persist-listen":     true,
+		"persist-web-config": true,
+		"addr":               true,
+		"base-url":           true,
+	})
 	if persisted.Host != "0.0.0.0" || persisted.Port != 9090 || persisted.BaseURL != "/explicit/" {
 		t.Fatalf("explicit web config not persisted: %#v", persisted)
 	}
 }
 
 func TestServePersistConfigListenOnlyPersistsExplicitListenFields(t *testing.T) {
-	stored := webserver.CLIConfig{Host: "localhost", Port: 7480, BaseURL: "/stored/"}
-	runtime := webserver.CLIConfig{Host: "0.0.0.0", Port: 9090, BaseURL: "/env/"}
+	stored := webserver.CLIConfig{
+		Host:    "localhost",
+		Port:    7480,
+		BaseURL: "/stored/",
+	}
+	runtime := webserver.CLIConfig{
+		Host:    "0.0.0.0",
+		Port:    9090,
+		BaseURL: "/env/",
+	}
 
 	persisted := servePersistConfig(stored, runtime, map[string]bool{"persist-listen": true, "port": true})
 	if persisted.Host != "localhost" || persisted.Port != 9090 || persisted.BaseURL != "" {
@@ -489,8 +563,16 @@ func TestServePersistConfigListenOnlyPersistsExplicitListenFields(t *testing.T)
 func TestServePersistConfigListenOnlyIgnoresInvalidStoredBaseURLWhenSaving(t *testing.T) {
 	tmpDir := t.TempDir()
 	dbPath := filepath.Join(tmpDir, "state", "upbrr.db")
-	stored := webserver.CLIConfig{Host: "localhost", Port: 7480, BaseURL: "javascript:alert(1)"}
-	runtime := webserver.CLIConfig{Host: "127.0.0.1", Port: 9090, BaseURL: "javascript:alert(1)"}
+	stored := webserver.CLIConfig{
+		Host:    "localhost",
+		Port:    7480,
+		BaseURL: "javascript:alert(1)",
+	}
+	runtime := webserver.CLIConfig{
+		Host:    "127.0.0.1",
+		Port:    9090,
+		BaseURL: "javascript:alert(1)",
+	}
 
 	persisted := servePersistConfig(stored, runtime, map[string]bool{"persist-listen": true, "host": true})
 	if err := webserver.SaveCLIConfig(dbPath, persisted); err != nil {
@@ -538,7 +620,7 @@ func TestRunServePersistListenBindFailureDoesNotWriteWebConfig(t *testing.T) {
 	defer listener.Close()
 
 	tmpDir := t.TempDir()
-	distPath := filepath.Join(tmpDir, "gui", "frontend", "dist")
+	distPath := filepath.Join(tmpDir, "webui", "dist")
 	if err := os.MkdirAll(distPath, 0o755); err != nil {
 		t.Fatalf("create web assets fixture: %v", err)
 	}
@@ -669,7 +751,7 @@ func TestRunExportConfigPlaintextExportsPlainSecrets(t *testing.T) {
 	}
 }
 
-func TestPrepareCLIUploadMetadataRefreshesResolvedPathForExternalSelections(t *testing.T) {
+func TestPrepareCLIUploadMetadataKeepsExternalOverridesAfterResolvedPath(t *testing.T) {
 	t.Parallel()
 
 	sourcePath := "folder"
@@ -684,10 +766,8 @@ func TestPrepareCLIUploadMetadataRefreshesResolvedPathForExternalSelections(t *t
 		},
 	}
 	req := api.Request{
-		Paths: []string{sourcePath},
-		ExternalIDSelections: map[string]api.ExternalIDSelection{
-			sourcePath: {TMDBID: &tmdbID, MALID: &malID},
-		},
+		SourcePath:          sourcePath,
+		ExternalIDOverrides: api.ExternalIDOverrides{TMDBID: &tmdbID, MALID: &malID},
 	}
 
 	resolvedReq, err := prepareCLIUploadMetadata(context.Background(), coreSvc, req)
@@ -697,65 +777,36 @@ func TestPrepareCLIUploadMetadataRefreshesResolvedPathForExternalSelections(t *t
 	if len(coreSvc.requests) != 2 {
 		t.Fatalf("expected 2 preview requests, got %#v", coreSvc.requests)
 	}
-	if len(coreSvc.requests[0].req.Paths) != 1 || coreSvc.requests[0].req.Paths[0] != sourcePath {
-		t.Fatalf("expected first preview for source path, got %#v", coreSvc.requests[0].req.Paths)
-	}
-	if len(coreSvc.requests[1].req.Paths) != 1 || coreSvc.requests[1].req.Paths[0] != resolvedPath {
-		t.Fatalf("expected second preview for resolved path, got %#v", coreSvc.requests[1].req.Paths)
+	if coreSvc.requests[0].req.SourcePath != sourcePath {
+		t.Fatalf("expected first preview for source path, got %q", coreSvc.requests[0].req.SourcePath)
 	}
-	if len(resolvedReq.Paths) != 1 || resolvedReq.Paths[0] != resolvedPath {
-		t.Fatalf("expected resolved upload path, got %#v", resolvedReq.Paths)
+	if coreSvc.requests[1].req.SourcePath != resolvedPath {
+		t.Fatalf("expected second preview for resolved path, got %q", coreSvc.requests[1].req.SourcePath)
 	}
-	selected, ok := resolveCLIExternalIDSelection(resolvedReq.ExternalIDSelections, resolvedPath)
-	if !ok || selected.TMDBID == nil || *selected.TMDBID != tmdbID {
-		t.Fatalf("expected resolved-path external selection, got %#v", resolvedReq.ExternalIDSelections)
+	if resolvedReq.SourcePath != resolvedPath {
+		t.Fatalf("expected resolved upload path, got %q", resolvedReq.SourcePath)
 	}
-	if selected.MALID == nil || *selected.MALID != malID {
-		t.Fatalf("expected resolved-path mal selection, got %#v", resolvedReq.ExternalIDSelections)
+	if resolvedReq.ExternalIDOverrides.TMDBID == nil || *resolvedReq.ExternalIDOverrides.TMDBID != tmdbID {
+		t.Fatalf("expected external TMDB override to remain source-local, got %#v", resolvedReq.ExternalIDOverrides)
 	}
-	secondSelected, ok := coreSvc.requests[1].req.ExternalIDSelections[resolvedPath]
-	if !ok || secondSelected.TMDBID == nil || *secondSelected.TMDBID != tmdbID {
-		t.Fatalf("expected resolved-path selection on second preview, got %#v", coreSvc.requests[1].req.ExternalIDSelections)
+	if resolvedReq.ExternalIDOverrides.MALID == nil || *resolvedReq.ExternalIDOverrides.MALID != malID {
+		t.Fatalf("expected MAL override to remain source-local, got %#v", resolvedReq.ExternalIDOverrides)
 	}
-	if secondSelected.MALID == nil || *secondSelected.MALID != malID {
-		t.Fatalf("expected second preview mal selection, got %#v", coreSvc.requests[1].req.ExternalIDSelections)
+	if second := coreSvc.requests[1].req.ExternalIDOverrides; second.TMDBID == nil || *second.TMDBID != tmdbID || second.MALID == nil || *second.MALID != malID {
+		t.Fatalf("expected second preview to retain source-local overrides, got %#v", second)
 	}
 }
 
-func TestPrepareCLIUploadMetadataRefreshesStaleResolvedPathExternalSelections(t *testing.T) {
+func TestCLIPreparationBatchKeepsSourceChoicesIndependent(t *testing.T) {
 	t.Parallel()
 
-	sourcePath := "folder"
-	resolvedPath := filepath.Join("folder", "movie.mkv")
-	currentTMDBID := 12345
-	staleTMDBID := 99999
-
-	coreSvc := &cliCoreForTest{
-		previewResponses: []api.MetadataPreview{
-			{SourcePath: resolvedPath},
-			{SourcePath: resolvedPath},
-		},
-	}
-	req := api.Request{
-		Paths: []string{sourcePath},
-		ExternalIDSelections: map[string]api.ExternalIDSelection{
-			sourcePath:   {TMDBID: &currentTMDBID},
-			resolvedPath: {TMDBID: &staleTMDBID},
-		},
-	}
-
-	resolvedReq, err := prepareCLIUploadMetadata(context.Background(), coreSvc, req)
-	if err != nil {
-		t.Fatalf("prepareCLIUploadMetadata: %v", err)
-	}
-
-	selected, ok := resolvedReq.ExternalIDSelections[resolvedPath]
-	if !ok || selected.TMDBID == nil || *selected.TMDBID != currentTMDBID {
-		t.Fatalf("expected resolved upload selection to refresh stale TMDB ID, got %#v", resolvedReq.ExternalIDSelections)
-	}
-	secondSelected, ok := coreSvc.requests[1].req.ExternalIDSelections[resolvedPath]
-	if !ok || secondSelected.TMDBID == nil || *secondSelected.TMDBID != currentTMDBID {
-		t.Fatalf("expected second preview to refresh stale TMDB ID, got %#v", coreSvc.requests[1].req.ExternalIDSelections)
+	firstID, secondID := 12345, 99999
+	batch := newCLIPreparationBatch(api.Request{}, []string{"one.mkv", "two.mkv"})
+	batch.items[0].externalIDs.TMDBID = &firstID
+	batch.items[1].externalIDs.TMDBID = &secondID
+	first, second := batch.request(0), batch.request(1)
+	if *first.ExternalIDOverrides.TMDBID != firstID || *second.ExternalIDOverrides.TMDBID != secondID {
+		t.Fatalf("source choices crossed batch items: first=%#v second=%#v", first.ExternalIDOverrides, second.ExternalIDOverrides)
 	}
 }
 
@@ -835,9 +886,9 @@ func TestRunCLIUploadOnlyQueueContinuesOnError(t *testing.T) {
 	uploadPaths := make([]string, 0)
 	coreSvc := &cliCoreForTest{
 		runUploadFunc: func(_ context.Context, req api.Request) (api.Result, error) {
-			if len(req.Paths) > 0 {
-				uploadPaths = append(uploadPaths, req.Paths[0])
-				if req.Paths[0] == failOn {
+			if req.SourcePath != "" {
+				uploadPaths = append(uploadPaths, req.SourcePath)
+				if req.SourcePath == failOn {
 					return api.Result{}, errors.New("upload boom")
 				}
 			}
@@ -845,7 +896,7 @@ func TestRunCLIUploadOnlyQueueContinuesOnError(t *testing.T) {
 		},
 	}
 	paths := []string{"good1", failOn, "good2"}
-	err := runCLIUploadOnlyQueue(context.Background(), coreSvc, api.Request{}, paths, false, api.NopLogger{})
+	err := runCLIUploadOnlyQueueForPaths(context.Background(), coreSvc, api.Request{}, paths)
 	if err == nil {
 		t.Fatal("expected a summary error when one queue item fails")
 	}
@@ -862,7 +913,7 @@ func TestRunCLIUploadOnlyQueueSumsUploadedCounts(t *testing.T) {
 
 	coreSvc := &cliCoreForTest{}
 	paths := []string{"a", "b", "c"}
-	err := runCLIUploadOnlyQueue(context.Background(), coreSvc, api.Request{}, paths, false, api.NopLogger{})
+	err := runCLIUploadOnlyQueueForPaths(context.Background(), coreSvc, api.Request{}, paths)
 	if err != nil {
 		t.Fatalf("expected no error for all-passing queue, got %v", err)
 	}
@@ -873,8 +924,8 @@ func TestRunCLIUploadOnlyQueueSumsUploadedCounts(t *testing.T) {
 		if r.name != "upload" {
 			continue
 		}
-		if len(r.req.Paths) != 1 {
-			t.Fatalf("expected single-path upload request per item, got %#v", r.req.Paths)
+		if strings.TrimSpace(r.req.SourcePath) == "" {
+			t.Fatal("expected nonblank single-source upload request per item")
 		}
 	}
 }
@@ -890,9 +941,9 @@ func TestRunCLIUploadOnlyQueueCapturesOnlyDVDItems(t *testing.T) {
 	coreSvc := &cliCoreForTest{dvdMenuResult: api.DVDMenuCaptureResult{
 		Images: []api.DVDMenuCaptureImage{{ScreenshotImage: api.ScreenshotImage{Path: "dvd-menu.png", Purpose: api.ScreenshotPurposeMenu}}},
 	}}
-	err := runCLIUploadOnlyQueue(context.Background(), coreSvc, api.Request{
+	err := runCLIUploadOnlyQueueForPaths(context.Background(), coreSvc, api.Request{
 		Options: api.UploadOptions{CaptureDVDMenus: true},
-	}, []string{dvdRoot, nonDiscRoot}, false, api.NopLogger{})
+	}, []string{dvdRoot, nonDiscRoot})
 	if err != nil {
 		t.Fatalf("upload-only queue: %v", err)
 	}
@@ -912,9 +963,9 @@ func TestRunCLIUploadOnlyQueueDVDMenuCaptureFailureStopsUpload(t *testing.T) {
 		t.Fatalf("create VIDEO_TS: %v", err)
 	}
 	coreSvc := &cliCoreForTest{dvdMenuErr: errSyntheticDVDMenuCapture}
-	err := runCLIUploadOnlyQueue(context.Background(), coreSvc, api.Request{
+	err := runCLIUploadOnlyQueueForPaths(context.Background(), coreSvc, api.Request{
 		Options: api.UploadOptions{CaptureDVDMenus: true},
-	}, []string{dvdRoot}, false, api.NopLogger{})
+	}, []string{dvdRoot})
 
 	assertDVDMenuCaptureError(t, err)
 	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,capture-dvd-menus" {
@@ -935,9 +986,9 @@ func TestRunCLIUploadOnlyQueueRecordsEachEmptyDVDMenuCapture(t *testing.T) {
 		}
 	}
 	coreSvc := &cliCoreForTest{}
-	err := runCLIUploadOnlyQueue(context.Background(), coreSvc, api.Request{
+	err := runCLIUploadOnlyQueueForPaths(context.Background(), coreSvc, api.Request{
 		Options: api.UploadOptions{CaptureDVDMenus: true},
-	}, paths, false, api.NopLogger{})
+	}, paths)
 	if err == nil {
 		t.Fatal("expected queue summary error for empty DVD menu captures")
 	}
@@ -967,7 +1018,7 @@ func TestRunCLIUploadOnlyBatchBoundsTimeoutByItemCap(t *testing.T) {
 	for i := range paths {
 		paths[i] = "p" + strconv.Itoa(i)
 	}
-	if err := runCLIUploadOnlyBatch(context.Background(), coreSvc, api.Request{Paths: paths}, paths, false, api.NopLogger{}); err != nil {
+	if err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, api.Request{}, paths, false, api.NopLogger{}); err != nil {
 		t.Fatalf("runCLIUploadOnlyBatch: %v", err)
 	}
 	if !sawDeadline {
@@ -980,8 +1031,8 @@ func TestRunCLIUploadOnlyBatchBoundsTimeoutByItemCap(t *testing.T) {
 	if remaining >= time.Duration(len(paths))*cliItemTimeout {
 		t.Fatalf("expected bounded deadline below len(paths)*cliItemTimeout, got %v", remaining)
 	}
-	if coreSvc.runUploadPreparedCalls != 1 {
-		t.Fatalf("expected a single batch RunUploadPrepared call, got %d", coreSvc.runUploadPreparedCalls)
+	if coreSvc.runUploadPreparedCalls != len(paths) {
+		t.Fatalf("expected one independent RunUploadPrepared call per source, got %d", coreSvc.runUploadPreparedCalls)
 	}
 }
 
@@ -1000,7 +1051,7 @@ func TestRunCLIUploadOnlyBatchSinglePathTimeout(t *testing.T) {
 		},
 	}
 	paths := []string{"only"}
-	if err := runCLIUploadOnlyBatch(context.Background(), coreSvc, api.Request{Paths: paths}, paths, false, api.NopLogger{}); err != nil {
+	if err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, api.Request{}, paths, false, api.NopLogger{}); err != nil {
 		t.Fatalf("runCLIUploadOnlyBatch: %v", err)
 	}
 	if !sawDeadline {
@@ -1014,7 +1065,7 @@ func TestRunCLIUploadOnlyBatchSinglePathTimeout(t *testing.T) {
 	}
 }
 
-func TestRunCLIUploadOnlyBatchCapturesBeforeDebugReviews(t *testing.T) {
+func TestRunCLIUploadOnlyBatchCapturesBeforeTrackerDebugRun(t *testing.T) {
 	t.Parallel()
 
 	dvdRoot := t.TempDir()
@@ -1025,18 +1076,89 @@ func TestRunCLIUploadOnlyBatchCapturesBeforeDebugReviews(t *testing.T) {
 		dvdMenuResult: api.DVDMenuCaptureResult{
 			Images: []api.DVDMenuCaptureImage{{ScreenshotImage: api.ScreenshotImage{Path: "dvd-menu.png", Purpose: api.ScreenshotPurposeMenu}}},
 		},
-		review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "BLU"}}},
+		dupeSummary: api.DupeCheckSummary{Results: []api.DupeCheckResult{{
+Tracker: "BLU",
+ Status: "completed",
+ Notes: []string{"retained"},
+}}},
 	}
 	paths := []string{dvdRoot}
-	if err := runCLIUploadOnlyBatch(context.Background(), coreSvc, api.Request{
-		Paths:   paths,
-		Options: api.UploadOptions{CaptureDVDMenus: true},
+	if err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, api.Request{
+		Trackers: []string{"BLU"},
+		Options:  api.UploadOptions{CaptureDVDMenus: true},
 	}, paths, true, api.NopLogger{}); err != nil {
 		t.Fatalf("upload-only batch: %v", err)
 	}
-	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,capture-dvd-menus,review" {
+	if got := strings.Join(coreSvc.callOrder, ","); got != "preview,capture-dvd-menus,dupes,debug" {
 		t.Fatalf("batch call order = %s", got)
 	}
+	if coreSvc.runUploadPreparedCalls != 0 || coreSvc.runTrackerDryRunCalls != 1 {
+		t.Fatalf("debug batch selected wrong operation: upload=%d debug=%d", coreSvc.runUploadPreparedCalls, coreSvc.runTrackerDryRunCalls)
+	}
+	if len(coreSvc.dryRunPlans) != 1 {
+		t.Fatalf("accepted dry-run plans = %d, want 1", len(coreSvc.dryRunPlans))
+	}
+	plan := coreSvc.dryRunPlans[0]
+	if plan.Duplicate.Release != plan.Input.Release || plan.Duplicate.Release.Generation != 1 {
+		t.Fatalf("accepted duplicate release = %#v input=%#v", plan.Duplicate.Release, plan.Input.Release)
+	}
+	if len(plan.Duplicate.Results) != 1 || plan.Duplicate.Results[0].Notes[0] != "retained" {
+		t.Fatalf("accepted duplicate results = %#v", plan.Duplicate.Results)
+	}
+}
+
+func TestRunCLIUploadOnlyBatchDebugLogLevelStillUploads(t *testing.T) {
+	t.Parallel()
+
+	coreSvc := &cliCoreForTest{}
+	request := api.Request{Options: api.UploadOptions{RunLogLevel: "debug"}}
+	if err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, request, []string{t.TempDir()}, false, api.NopLogger{}); err != nil {
+		t.Fatalf("upload-only batch: %v", err)
+	}
+	if coreSvc.runUploadPreparedCalls != 1 || coreSvc.runTrackerDryRunCalls != 0 {
+		t.Fatalf("debug log level changed operation: upload=%d debug=%d", coreSvc.runUploadPreparedCalls, coreSvc.runTrackerDryRunCalls)
+	}
+	var uploadRequest api.Request
+	for _, recorded := range coreSvc.requests {
+		if recorded.name == "upload" {
+			uploadRequest = recorded.req
+		}
+	}
+	if uploadRequest.Options.RunLogLevel != "debug" {
+		t.Fatalf("run log level = %q, want debug", uploadRequest.Options.RunLogLevel)
+	}
+}
+
+func TestRunCLIUploadOnlyQueueDebugUsesTrackerDryRun(t *testing.T) {
+	t.Parallel()
+
+	coreSvc := &cliCoreForTest{dupeSummary: api.DupeCheckSummary{Results: []api.DupeCheckResult{{Tracker: "BLU", Status: "completed"}}}}
+	paths := []string{t.TempDir(), t.TempDir()}
+	err := runCLIUploadOnlyQueue(
+		context.Background(),
+		coreSvc,
+		newCLIPreparationBatch(api.Request{Trackers: []string{"BLU"}}, paths),
+		true,
+		api.NopLogger{},
+	)
+	if err != nil {
+		t.Fatalf("upload-only queue: %v", err)
+	}
+	if coreSvc.runUploadPreparedCalls != 0 || coreSvc.runTrackerDryRunCalls != len(paths) {
+		t.Fatalf("debug queue selected wrong operation: upload=%d debug=%d", coreSvc.runUploadPreparedCalls, coreSvc.runTrackerDryRunCalls)
+	}
+	if len(coreSvc.dryRunPlans) != len(paths) {
+		t.Fatalf("debug queue accepted plans = %d, want %d", len(coreSvc.dryRunPlans), len(paths))
+	}
+	dupeCalls := 0
+	for _, call := range coreSvc.callOrder {
+		if call == "dupes" {
+			dupeCalls++
+		}
+	}
+	if dupeCalls != len(paths) {
+		t.Fatalf("debug queue duplicate checks = %d, want %d", dupeCalls, len(paths))
+	}
 }
 
 func TestRunCLIUploadOnlyBatchContinuesAfterEmptyDVDMenuCapture(t *testing.T) {
@@ -1050,8 +1172,7 @@ func TestRunCLIUploadOnlyBatchContinuesAfterEmptyDVDMenuCapture(t *testing.T) {
 	}
 	coreSvc := &cliCoreForTest{}
 	logger := &cliErrorCountingLogger{}
-	if err := runCLIUploadOnlyBatch(context.Background(), coreSvc, api.Request{
-		Paths:   paths,
+	if err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, api.Request{
 		Options: api.UploadOptions{CaptureDVDMenus: true},
 	}, paths, false, logger); err != nil {
 		t.Fatalf("upload-only batch: %v", err)
@@ -1062,8 +1183,8 @@ func TestRunCLIUploadOnlyBatchContinuesAfterEmptyDVDMenuCapture(t *testing.T) {
 	if logger.errors != len(paths) {
 		t.Fatalf("recorded capture failures = %d, want %d", logger.errors, len(paths))
 	}
-	if coreSvc.runUploadPreparedCalls != 1 {
-		t.Fatalf("upload calls = %d, want 1", coreSvc.runUploadPreparedCalls)
+	if coreSvc.runUploadPreparedCalls != len(paths) {
+		t.Fatalf("upload calls = %d, want %d", coreSvc.runUploadPreparedCalls, len(paths))
 	}
 }
 
@@ -1076,8 +1197,7 @@ func TestRunCLIUploadOnlyBatchDVDMenuCaptureFailureStopsReviewAndUpload(t *testi
 	}
 	coreSvc := &cliCoreForTest{dvdMenuErr: errSyntheticDVDMenuCapture}
 	paths := []string{dvdRoot}
-	err := runCLIUploadOnlyBatch(context.Background(), coreSvc, api.Request{
-		Paths:   paths,
+	err := runCLIUploadOnlyBatchForPaths(context.Background(), coreSvc, api.Request{
 		Options: api.UploadOptions{CaptureDVDMenus: true},
 	}, paths, true, api.NopLogger{})
 
@@ -1116,7 +1236,7 @@ func TestHandleBDMVPlaylistSelectionReturnsOnDetectDiscTypeCancel(t *testing.T)
 	root := newBDMVTempDir(t)
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
-	err := handleBDMVPlaylistSelection(ctx, []string{root}, &cliCoreForTest{}, config.Config{}, api.NopLogger{}, cliOptions{})
+	err := handleBDMVPlaylistSelectionForPaths(ctx, []string{root}, &cliCoreForTest{}, config.Config{}, cliOptions{})
 	if err == nil || !isCtxErr(err) {
 		t.Fatalf("expected a context error from DetectDiscType, got %v", err)
 	}
@@ -1127,7 +1247,7 @@ func TestHandleBDMVPlaylistSelectionReturnsOnLoadSelectionCtxErr(t *testing.T) {
 
 	root := newBDMVTempDir(t)
 	coreSvc := &cliCoreForTest{playlistSelectionErr: context.DeadlineExceeded}
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{})
+	err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{}, cliOptions{})
 	if !errors.Is(err, context.DeadlineExceeded) {
 		t.Fatalf("expected DeadlineExceeded from LoadPlaylistSelection, got %v", err)
 	}
@@ -1142,9 +1262,9 @@ func TestHandleBDMVPlaylistSelectionReturnsOnDiscoverPlaylistsCtxErr(t *testing.
 			playlistSelectionErr: internalerrors.ErrNotFound,
 			discoverPlaylistsErr: context.Canceled,
 		}
-		err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{
+		err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{
 			Metadata: config.MetadataConfig{UseLargestPlaylist: useLargest},
-		}, api.NopLogger{}, cliOptions{})
+		}, cliOptions{})
 		if !errors.Is(err, context.Canceled) {
 			t.Fatalf("UseLargestPlaylist=%v: expected Canceled from DiscoverPlaylists, got %v", useLargest, err)
 		}
@@ -1161,9 +1281,9 @@ func TestHandleBDMVPlaylistSelectionReturnsOnSaveSelectionCtxErr(t *testing.T) {
 			playlists:            []api.PlaylistInfo{{File: "00800.mpls", Score: 1}},
 			savePlaylistErr:      context.Canceled,
 		}
-		err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{
+		err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{
 			Metadata: config.MetadataConfig{UseLargestPlaylist: useLargest},
-		}, api.NopLogger{}, cliOptions{})
+		}, cliOptions{})
 		if !errors.Is(err, context.Canceled) {
 			t.Fatalf("UseLargestPlaylist=%v: expected Canceled from SavePlaylistSelection, got %v", useLargest, err)
 		}
@@ -1175,8 +1295,84 @@ func TestHandleBDMVPlaylistSelectionSkipsNonCtxErrors(t *testing.T) {
 
 	root := newBDMVTempDir(t)
 	coreSvc := &cliCoreForTest{playlistSelectionErr: errors.New("boom")}
-	err := handleBDMVPlaylistSelection(context.Background(), []string{root}, coreSvc, config.Config{}, api.NopLogger{}, cliOptions{})
+	err := handleBDMVPlaylistSelectionForPaths(context.Background(), []string{root}, coreSvc, config.Config{}, cliOptions{})
 	if err != nil {
 		t.Fatalf("expected non-ctx load error to be skipped (continue), got %v", err)
 	}
 }
+
+type perSourcePlaylistCore struct {
+	playlists map[string][]api.PlaylistInfo
+}
+
+func (*perSourcePlaylistCore) DetectDiscType(ctx context.Context, sourcePath string) (string, error) {
+	layout, err := sourcelayout.Resolve(ctx, sourcePath)
+	if err != nil {
+		return "", fmt.Errorf("resolve source layout: %w", err)
+	}
+	return layout.DiscType, nil
+}
+
+func (c *perSourcePlaylistCore) DiscoverPlaylists(_ context.Context, sourcePath string) ([]api.PlaylistInfo, error) {
+	return append([]api.PlaylistInfo(nil), c.playlists[filepath.Clean(sourcePath)]...), nil
+}
+
+func (*perSourcePlaylistCore) SavePlaylistSelection(context.Context, string, []string, bool) error {
+	return nil
+}
+
+func (*perSourcePlaylistCore) LoadPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
+	return api.PlaylistSelection{}, internalerrors.ErrNotFound
+}
+
+func TestCLITwoBDMVSourcesKeepIndependentPlaylistInstructions(t *testing.T) {
+	t.Parallel()
+
+	paths := []string{filepath.Join(t.TempDir(), "disc-one"), filepath.Join(t.TempDir(), "disc-two")}
+	for _, sourcePath := range paths {
+		if err := os.MkdirAll(filepath.Join(sourcePath, "BDMV"), 0o700); err != nil {
+			t.Fatalf("create BDMV source: %v", err)
+		}
+	}
+	selectionCore := &perSourcePlaylistCore{playlists: map[string][]api.PlaylistInfo{
+		filepath.Clean(paths[0]): {{File: "00001.mpls", Score: 2}},
+		filepath.Clean(paths[1]): {{File: "00002.mpls", Score: 2}},
+	}}
+	batch := newCLIPreparationBatch(api.Request{}, paths)
+	if err := handleBDMVPlaylistSelection(
+		context.Background(),
+		&batch,
+		selectionCore,
+		config.Config{Metadata: config.MetadataConfig{UseLargestPlaylist: true}},
+		api.NopLogger{},
+		cliOptions{Unattended: true},
+	); err != nil {
+		t.Fatalf("resolve playlist selections: %v", err)
+	}
+	if got := batch.items[0].playlistInstruction; !got.Set || !slices.Equal(got.Selected, []string{"00001.mpls"}) {
+		t.Fatalf("first instruction = %#v", got)
+	}
+	if got := batch.items[1].playlistInstruction; !got.Set || !slices.Equal(got.Selected, []string{"00002.mpls"}) {
+		t.Fatalf("second instruction = %#v", got)
+	}
+
+	workflowCore := &cliCoreForTest{}
+	if err := runCLIUploadOnlyBatch(context.Background(), workflowCore, batch, false, api.NopLogger{}); err != nil {
+		t.Fatalf("run upload-only batch: %v", err)
+	}
+	var uploads []api.Request
+	for _, recorded := range workflowCore.requests {
+		if recorded.name == "upload" {
+			uploads = append(uploads, recorded.req)
+		}
+	}
+	if len(uploads) != 2 {
+		t.Fatalf("upload requests = %d, want 2", len(uploads))
+	}
+	for index := range uploads {
+		if uploads[index].SourcePath != paths[index] ||
+			!slices.Equal(uploads[index].PlaylistInstruction.Selected, batch.items[index].playlistInstruction.Selected) {
+			t.Fatalf("upload %d = %#v", index, uploads[index])
+		}
+	}
+}
diff --git a/cmd/upbrr/operation_failure_test.go b/cmd/upbrr/operation_failure_test.go
new file mode 100644
index 00000000..daf87228
--- /dev/null
+++ b/cmd/upbrr/operation_failure_test.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package main
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestFormatCLIErrorUsesStableOperationFailure(t *testing.T) {
+	err := api.NewOperationError(api.OperationFailure{
+		Code:      api.OperationFailureConfirmationRequired,
+		Operation: api.OperationKindPreparation,
+		Message:   "Blu-ray playlist changes require confirmation before rescanning.",
+		Recovery:  api.OperationRecoveryConfirm,
+	}, errors.New("private database path and token"))
+
+	if got, want := formatCLIError(err), "Blu-ray playlist changes require confirmation before rescanning. (recovery: confirm)"; got != want {
+		t.Fatalf("formatCLIError() = %q, want %q", got, want)
+	}
+}
diff --git a/go.mod b/go.mod
index 427ac118..59e4984b 100644
--- a/go.mod
+++ b/go.mod
@@ -11,7 +11,6 @@ require (
 	github.com/frustra/bbcode v0.0.0-20201127003707-6ef347fbe1c8
 	github.com/moistari/rls v0.6.0
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
-	github.com/wailsapp/wails/v2 v2.12.0
 	golang.org/x/crypto v0.52.0
 	golang.org/x/net v0.55.0
 	golang.org/x/sync v0.20.0
@@ -27,29 +26,17 @@ replace github.com/moistari/rls => github.com/autobrr/rls v0.8.1
 replace github.com/anacrolix/dht/v2 => github.com/anacrolix/dht/v2 v2.24.0
 
 require (
-	git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 // indirect
 	github.com/Masterminds/semver v1.5.0 // indirect
 	github.com/anacrolix/generics v0.1.1-0.20251125230353-15d98d46693b // indirect
 	github.com/anacrolix/missinggo v1.3.0 // indirect
 	github.com/anacrolix/missinggo/v2 v2.10.0 // indirect
 	github.com/avast/retry-go v3.0.0+incompatible // indirect
-	github.com/bep/debounce v1.2.1 // indirect
 	github.com/bmatcuk/doublestar/v4 v4.10.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/fatih/color v1.19.0 // indirect
-	github.com/go-ole/go-ole v1.3.0 // indirect
-	github.com/godbus/dbus/v5 v5.2.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/huandu/xstrings v1.5.0 // indirect
-	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/labstack/echo/v4 v4.13.3 // indirect
-	github.com/labstack/gommon v0.4.2 // indirect
-	github.com/leaanthony/go-ansi-parser v1.6.1 // indirect
-	github.com/leaanthony/gosod v1.0.4 // indirect
-	github.com/leaanthony/slicer v1.6.0 // indirect
-	github.com/leaanthony/u v1.1.1 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/minio/sha256-simd v1.0.1 // indirect
@@ -61,14 +48,8 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/samber/lo v1.49.1 // indirect
 	github.com/schollz/progressbar/v3 v3.19.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/tkrajina/go-reflector v0.5.8 // indirect
-	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/valyala/fasttemplate v1.2.2 // indirect
-	github.com/wailsapp/go-webview2 v1.0.22 // indirect
-	github.com/wailsapp/mimetype v1.4.1 // indirect
 	golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 // indirect
 	lukechampine.com/blake3 v1.4.1 // indirect
 	modernc.org/libc v1.72.3 // indirect
diff --git a/go.sum b/go.sum
index a26d3e22..a84f390f 100644
--- a/go.sum
+++ b/go.sum
@@ -2,8 +2,6 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 crawshaw.io/iox v0.0.0-20181124134642-c51c3df30797/go.mod h1:sXBiorCo8c46JlQV3oXPKINnZ8mcqnye1EkVkqsectk=
 crawshaw.io/sqlite v0.3.2/go.mod h1:igAO5JulrQ1DbdZdtVq48mnZUBAPOeFzer7VhDWNtW4=
-git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 h1:N3IGoHHp9pb6mj1cbXbuaSXV/UMKwmbKLf53nQmtqMA=
-git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3/go.mod h1:QtOLZGz8olr4qH2vWK0QH0w0O4T9fEIjMuWpKUsH7nc=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
 github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
@@ -60,8 +58,6 @@ github.com/benbjohnson/immutable v0.2.0/go.mod h1:uc6OHo6PN2++n98KHLxW8ef4W42ylH
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
-github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
 github.com/bmatcuk/doublestar/v4 v4.10.0 h1:zU9WiOla1YA122oLM6i4EXvGW62DvKZVxIe6TYWexEs=
 github.com/bmatcuk/doublestar/v4 v4.10.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/bradfitz/iter v0.0.0-20140124041915-454541ec3da2/go.mod h1:PyRFw1Lt2wKX4ZVSQ2mk+PeDa1rxyObEDlApuIsUKuo=
@@ -103,13 +99,9 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
-github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
 github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/godbus/dbus/v5 v5.2.0 h1:3WexO+U+yg9T70v9FdHr9kCxYlazaAXUhx2VMkbfax8=
-github.com/godbus/dbus/v5 v5.2.0/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -145,8 +137,6 @@ github.com/gopherjs/gopherjs v0.0.0-20190309154008-847fc94819f9/go.mod h1:wJfORR
 github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
@@ -157,8 +147,6 @@ github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63
 github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
 github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
 github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
-github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
-github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
@@ -176,23 +164,6 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
-github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
-github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
-github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
-github.com/leaanthony/debme v1.2.1 h1:9Tgwf+kjcrbMQ4WnPcEIUcQuIZYqdWftzZkBr+i/oOc=
-github.com/leaanthony/debme v1.2.1/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA=
-github.com/leaanthony/go-ansi-parser v1.6.1 h1:xd8bzARK3dErqkPFtoF9F3/HgN8UQk0ed1YDKpEz01A=
-github.com/leaanthony/go-ansi-parser v1.6.1/go.mod h1:+vva/2y4alzVmmIEpk9QDhA7vLC5zKDTRwfZGOp3IWU=
-github.com/leaanthony/gosod v1.0.4 h1:YLAbVyd591MRffDgxUOU1NwLhT9T1/YiwjKZpkNFeaI=
-github.com/leaanthony/gosod v1.0.4/go.mod h1:GKuIL0zzPj3O1SdWQOdgURSuhkF+Urizzxh26t9f1cw=
-github.com/leaanthony/slicer v1.6.0 h1:1RFP5uiPJvT93TAHi+ipd3NACobkW53yUiBqZheE/Js=
-github.com/leaanthony/slicer v1.6.0/go.mod h1:o/Iz29g7LN0GqH3aMjWAe90381nyZlDNquK+mtH2Fj8=
-github.com/leaanthony/u v1.1.1 h1:TUFjwDGlNX+WuwVEzDqQwC2lOv0P4uhTQw7CMFdiK7M=
-github.com/leaanthony/u v1.1.1/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI=
-github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
-github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
-github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -253,14 +224,11 @@ github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46/go.mod h1:uAQ5PCi+MFsC7HjREoAz1BU+Mq60+05gifQSsHSDG/8=
-github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
-github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
 github.com/schollz/progressbar/v3 v3.19.0 h1:Ea18xuIRQXLAUidVDox3AbwfUhD0/1IvohyTutOIFoc=
 github.com/schollz/progressbar/v3 v3.19.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
@@ -282,18 +250,6 @@ github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tinylib/msgp v1.1.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
-github.com/tkrajina/go-reflector v0.5.8 h1:yPADHrwmUbMq4RGEyaOUpz2H90sRsETNVpjzo3DLVQQ=
-github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
-github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
-github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
-github.com/wailsapp/go-webview2 v1.0.22 h1:YT61F5lj+GGaat5OB96Aa3b4QA+mybD0Ggq6NZijQ58=
-github.com/wailsapp/go-webview2 v1.0.22/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc=
-github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs=
-github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o=
-github.com/wailsapp/wails/v2 v2.12.0 h1:BHO/kLNWFHYjCzucxbzAYZWUjub1Tvb4cSguQozHn5c=
-github.com/wailsapp/wails/v2 v2.12.0/go.mod h1:mo1bzK1DEJrobt7YrBjgxvb5Sihb1mhAY09hppbibQg=
 github.com/willf/bitset v1.1.9/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
@@ -322,7 +278,6 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
 golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -345,19 +300,14 @@ golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
 golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
 golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
 golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
diff --git a/gui/build/appicon.png b/gui/build/appicon.png
deleted file mode 100644
index cabc9c0a..00000000
Binary files a/gui/build/appicon.png and /dev/null differ
diff --git a/gui/build/windows/icon.ico b/gui/build/windows/icon.ico
deleted file mode 100644
index 97d4738f..00000000
Binary files a/gui/build/windows/icon.ico and /dev/null differ
diff --git a/gui/build/windows/info.json b/gui/build/windows/info.json
deleted file mode 100644
index 9727946b..00000000
--- a/gui/build/windows/info.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-	"fixed": {
-		"file_version": "{{.Info.ProductVersion}}"
-	},
-	"info": {
-		"0000": {
-			"ProductVersion": "{{.Info.ProductVersion}}",
-			"CompanyName": "{{.Info.CompanyName}}",
-			"FileDescription": "{{.Info.ProductName}}",
-			"LegalCopyright": "{{.Info.Copyright}}",
-			"ProductName": "{{.Info.ProductName}}",
-			"Comments": "{{.Info.Comments}}"
-		}
-	}
-}
\ No newline at end of file
diff --git a/gui/build/windows/wails.exe.manifest b/gui/build/windows/wails.exe.manifest
deleted file mode 100644
index 17e1a238..00000000
--- a/gui/build/windows/wails.exe.manifest
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
-    <assemblyIdentity type="win32" name="com.wails.{{.Name}}" version="{{.Info.ProductVersion}}.0" processorArchitecture="*"/>
-    <dependency>
-        <dependentAssembly>
-            <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
-        </dependentAssembly>
-    </dependency>
-    <asmv3:application>
-        <asmv3:windowsSettings>
-            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware> <!-- fallback for Windows 7 and 8 -->
-            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2,permonitor</dpiAwareness> <!-- falls back to per-monitor if per-monitor v2 is not supported -->
-        </asmv3:windowsSettings>
-    </asmv3:application>
-</assembly>
\ No newline at end of file
diff --git a/gui/frontend/AGENTS.md b/gui/frontend/AGENTS.md
deleted file mode 100644
index c3fe8010..00000000
--- a/gui/frontend/AGENTS.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Frontend Guidelines
-
-Scoped rules for `gui/frontend`. Root repo rules still apply.
-
-## Source Of Truth
-
-- Scripts and dependencies: `package.json`, `pnpm-lock.yaml`.
-- TypeScript config: `tsconfig*.json`, `vite.config.ts`, `vitest.config.ts`.
-- Lint/format behavior: ESLint, Prettier, Stylelint config files and Lefthook.
-- API/runtime contracts: `pkg/api`, `internal/guiapp`, `internal/webserver`, generated Wails bindings when present.
-
-## Commands
-
-```bash
-pnpm --dir gui/frontend run typecheck
-pnpm --dir gui/frontend run test:unit
-pnpm --dir gui/frontend run lint
-pnpm --dir gui/frontend run lint:style
-pnpm --dir gui/frontend run format:check
-pnpm --dir gui/frontend run build
-```
-
-## Check Selection
-
-- TS/TSX changes: `pnpm --dir gui/frontend run lint`, `lint:dead`, `typecheck`, `test:unit`, and `format:check`.
-- CSS changes: `pnpm --dir gui/frontend run lint:style`; also run `format:check`.
-- Runtime/API bridge or Wails binding changes: frontend `test:unit` + `typecheck`, plus backend/API parity tests from `internal/AGENTS.md` and `pkg/api/AGENTS.md`.
-- Bundle/import/env changes: `pnpm --dir gui/frontend run build`.
-- Visual/embedded behavior changes: rebuild/sync embedded assets and inspect `http://localhost:7480`; avoid Vite `5173` for parity.
-
-`make test-frontend` runs lint, dead-code, typecheck, unit, and format checks, but not Stylelint. Run Stylelint explicitly for CSS.
-
-## React / TypeScript
-
-- Keep TypeScript, ESLint, Stylelint, dead-code clean. Do not weaken rules.
-- `useEffect` only for external sync. Avoid derived state in effects; render or `useMemo` instead.
-- User-driven logic belongs in handlers. Fetch effects need cleanup/abort guards.
-- Preserve CLI, Wails, and embedded web parity when changing request shapes, upload options, prepared metadata, or runtime bridge behavior.
-- Match existing component state patterns before adding new abstraction.
-
-## Frontend Output / Logging
-
-- Follow root log-level guidance for browser-visible diagnostics and runtime bridge logging.
-- Do not expose credentials, tokens, API keys, passkeys, cookies, 2FA codes, challenge IDs, or secret payloads in console output, UI errors, toasts, test failure text, or debug panels.
-- Avoid permanent `console.*` diagnostics. If a diagnostic is intentionally kept, make it dev-scoped, concise, and redacted.
-- User-facing errors should be stable outcomes or next steps; detailed troubleshooting context belongs in developer diagnostics.
-
-## Styling
-
-- Prefer Tailwind utilities for touched local layout/spacing.
-- Keep CSS for shared/theme/cross-cutting selectors or JSX readability.
-- Do not make repo-wide format/style sweeps unless explicitly requested.
-- Text must fit containers across desktop/mobile; do not rely on viewport-width font scaling.
-
-## Embedded Web Checks
-
-- For embedded visual/runtime checks, rebuild frontend, sync embedded assets, rebuild CLI, then serve the embedded app:
-
-```bash
-pnpm --dir gui/frontend run build
-pwsh -NoProfile -File .\scripts\sync-frontend-assets.ps1
-go build -o .\dist\upbrr.exe .\cmd\upbrr
-.\dist\upbrr.exe serve --dev-no-auth
-```
-
-- Use `http://localhost:7480`.
-- Avoid Vite `5173` for embedded parity checks.
-- Stop local servers after inspection.
-
-## E2E
-
-For Playwright E2E work, read `e2e/AGENTS.md` first. E2E tests must use the embedded web UI, local fake services, isolated temp config/DB, and no real credentials.
diff --git a/gui/frontend/CLAUDE.md b/gui/frontend/CLAUDE.md
deleted file mode 120000
index c3170642..00000000
--- a/gui/frontend/CLAUDE.md
+++ /dev/null
@@ -1 +0,0 @@
-AGENTS.md
diff --git a/gui/frontend/e2e/AGENTS.md b/gui/frontend/e2e/AGENTS.md
deleted file mode 100644
index 0970bbb4..00000000
--- a/gui/frontend/e2e/AGENTS.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# E2E Guidelines
-
-Scoped rules for Playwright E2E under `gui/frontend/e2e`. Root and frontend rules still apply.
-
-## Commands
-
-```bash
-make e2e
-make e2e-web
-make e2e-cli
-make e2e-wails
-pnpm --dir gui/frontend run test:e2e:web
-pnpm --dir gui/frontend run test:e2e:full
-```
-
-`make e2e` is the preferred full local command. It installs frontend deps, builds the frontend, syncs embedded assets, builds `dist/upbrr-e2e.exe` with the `e2e` tag, and runs all Playwright projects.
-
-If Playwright browsers are missing:
-
-```bash
-pnpm --dir gui/frontend exec playwright install chromium
-```
-
-To open the HTML report from repo root:
-
-```bash
-pnpm --dir gui/frontend exec playwright show-report
-```
-
-## Projects
-
-- `web-smoke`: embedded server at `http://localhost:7480`, `--dev-no-auth`; nav/settings/invalid-input smoke coverage.
-- `web-full-upload`: metadata, screenshot/image upload, tracker dry-run, tracker upload, and history through embedded web UI.
-- `cli-full-upload`: full CLI upload path against local fakes and temp config/DB.
-- `wails-basic`: Go parity tests for Wails/web/shared API packages; no native desktop UI automation.
-
-## Harness Rules
-
-- Web UI E2E uses the embedded app as source of truth, not Vite.
-- Use isolated temp workspace per test: config YAML, SQLite DB, media/torrent/screenshot fixtures.
-- Use local fake tracker/image-host/torrent/metadata services only.
-- No real tracker, image host, torrent client, TMDB, or credentials in E2E.
-- Service seams must be test-only or config/test fixture driven; production defaults stay unchanged.
-- Process manager must clean up `dist/upbrr-e2e.exe serve --config <temp>\config.yaml --dev-no-auth`.
-
-## Generated Artifacts
-
-Ignored local outputs:
-
-- `gui/frontend/playwright-report/`
-- `gui/frontend/test-results/`
-
-Do not commit Playwright traces, videos, screenshots, reports, temp DBs, or `dist/upbrr-e2e.exe`.
-
-## CI
-
-Manual workflow only:
-
-- `.github/workflows/e2e.yml`
-- `workflow_dispatch`
-- Builds frontend + embedded assets + CLI.
-- Installs Playwright Chromium.
-- Runs `make e2e`.
-- Uploads report/traces on failure.
diff --git a/gui/frontend/e2e/CLAUDE.md b/gui/frontend/e2e/CLAUDE.md
deleted file mode 120000
index c3170642..00000000
--- a/gui/frontend/e2e/CLAUDE.md
+++ /dev/null
@@ -1 +0,0 @@
-AGENTS.md
diff --git a/gui/frontend/e2e/wails-basic.spec.ts b/gui/frontend/e2e/wails-basic.spec.ts
deleted file mode 100644
index cdc54d5d..00000000
--- a/gui/frontend/e2e/wails-basic.spec.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { spawn } from "node:child_process";
-import { expect, test } from "@playwright/test";
-import { repoRoot } from "./helpers/e2eHarness";
-
-test("Wails/backend parity Go tests pass", async () => {
-  const result = await run("go", [
-    "test",
-    "-race",
-    "-v",
-    "-timeout",
-    "20m",
-    "./internal/guiapp",
-    "./internal/webserver",
-    "./internal/guishared",
-    "./pkg/api",
-  ]);
-  expect(result.code, result.output).toBe(0);
-});
-
-function run(command: string, args: string[]): Promise<{ code: number | null; output: string }> {
-  return new Promise((resolve) => {
-    const child = spawn(command, args, {
-      cwd: repoRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-    });
-    const chunks: string[] = [];
-    child.stdout?.on("data", (chunk) => chunks.push(String(chunk)));
-    child.stderr?.on("data", (chunk) => chunks.push(String(chunk)));
-    child.on("close", (code) => resolve({ code, output: chunks.join("") }));
-  });
-}
diff --git a/gui/frontend/e2e/web-full-upload.spec.ts b/gui/frontend/e2e/web-full-upload.spec.ts
deleted file mode 100644
index 1d6c914b..00000000
--- a/gui/frontend/e2e/web-full-upload.spec.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { expect, test } from "@playwright/test";
-import { createE2EWorkspace, fetchMetadata, startApp, type AppServer } from "./helpers/e2eHarness";
-
-test("embedded web runs image upload, tracker dry run, tracker upload, and history", async ({
-  page,
-}) => {
-  const workspace = await createE2EWorkspace();
-  let app: AppServer | undefined;
-  try {
-    app = await startApp(workspace);
-    await fetchMetadata(page, app.url, workspace.sourcePath);
-
-    await page.getByRole("button", { name: "Dupe Checking" }).click();
-    await page.getByRole("button", { name: "Run dupe check" }).click();
-    await expect(page.getByText("BTN").first()).toBeVisible();
-    await expect(page.getByRole("button", { name: "Run dupe check" })).toBeEnabled();
-
-    await page.getByRole("button", { name: "Screenshots" }).click();
-    await page.getByRole("button", { name: "Generate screenshots" }).click();
-    await expect(
-      page
-        .getByText(
-          /Generated screenshots ready for upload\.|All requested screenshots already exist\./,
-        )
-        .first(),
-    ).toBeVisible();
-    await page.getByRole("button", { name: "Upload Images" }).click();
-    await expect(page.getByText("Available: 1")).toBeVisible();
-    await page.getByRole("button", { name: "Upload 1" }).click();
-    await expect.poll(() => workspace.fake.counters.imageUploads).toBe(1);
-    await expect(page.getByRole("link", { name: "Web URL" }).first()).toHaveAttribute(
-      "href",
-      /\/image\/1$/,
-    );
-
-    await page.getByRole("button", { name: "Description Builder" }).click();
-    await page.getByRole("button", { name: "Refresh descriptions" }).click();
-    await page.getByRole("button", { name: "Expand" }).click();
-    await expect(page.locator("textarea").first()).toHaveValue(/E2E description fixture\./);
-
-    await page.getByRole("button", { name: "Tracker Upload" }).click();
-    await expect(page.getByRole("heading", { name: "Upload Targets" })).toBeVisible();
-    await page.getByRole("button", { name: "Run Dry Run" }).click();
-    await page.getByText("Dry run data").click();
-    const dryRunDetails = page.locator("details[open]").filter({ hasText: "Dry run data" }).first();
-    await expect(dryRunDetails.getByText("E2E.Movie.2026.1080p.WEB-DL").first()).toBeVisible();
-    await expect(dryRunDetails.getByText("/upload").first()).toBeVisible();
-
-    await page.getByRole("button", { name: "Start Upload" }).click();
-    await expect.poll(() => workspace.fake.counters.trackerUploads).toBe(1);
-    await expect(page.getByText(/Uploaded:\s*1/)).toBeVisible();
-
-    await page.getByRole("button", { name: "History" }).click();
-    await expect(page.getByText("E2E.Movie.2026.1080p.WEB-DL").first()).toBeVisible();
-    await expect(page.getByText("BTN").first()).toBeVisible();
-  } finally {
-    await app?.stop();
-    await workspace.cleanup();
-  }
-});
diff --git a/gui/frontend/e2e/web-smoke.spec.ts b/gui/frontend/e2e/web-smoke.spec.ts
deleted file mode 100644
index 90a6093e..00000000
--- a/gui/frontend/e2e/web-smoke.spec.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { expect, test } from "@playwright/test";
-import { createE2EWorkspace, startApp, type AppServer } from "./helpers/e2eHarness";
-
-test("embedded web boots with dev auth, navigates core pages, and reports invalid paths", async ({
-  page,
-}) => {
-  const workspace = await createE2EWorkspace();
-  let app: AppServer | undefined;
-  try {
-    app = await startApp(workspace);
-    await page.goto(app.url);
-    await expect(page.getByRole("heading", { name: "Build Release Name" })).toBeVisible();
-
-    await page.getByRole("button", { name: "Settings" }).click();
-    await expect(page.getByRole("heading", { name: "Settings" })).toBeVisible();
-    await page.getByRole("button", { name: "Reload" }).click();
-    await expect(page.getByText("Configuration")).toBeVisible();
-
-    await page.getByRole("button", { name: "Logging" }).click();
-    await expect(page.getByRole("heading", { name: "Logging" })).toBeVisible();
-
-    await page.getByRole("button", { name: "History" }).click();
-    await expect(page.getByRole("heading", { name: "History" })).toBeVisible();
-
-    await page.getByRole("button", { name: "Input" }).click();
-    await page.getByLabel("Source path").fill("Z:\\missing\\e2e.mkv");
-    await page.getByRole("button", { name: "Fetch metadata" }).click();
-    await expect(page.locator(".error")).toContainText(/path|file|stat|missing/i);
-  } finally {
-    await app?.stop();
-    await workspace.cleanup();
-  }
-});
diff --git a/gui/frontend/package.json b/gui/frontend/package.json
deleted file mode 100644
index 761bbc4c..00000000
--- a/gui/frontend/package.json
+++ /dev/null
@@ -1,65 +0,0 @@
-{
-  "name": "upbrr-gui",
-  "private": true,
-  "version": "0.1.0",
-  "packageManager": "pnpm@10.27.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc -b && vite build",
-    "build:bundle": "vite build",
-    "preview": "vite preview",
-    "test:unit": "vitest run",
-    "test:unit:watch": "vitest",
-    "test:e2e:web": "playwright test --project=web-smoke --project=web-base-path-smoke --project=web-full-upload",
-    "test:e2e:full": "playwright test",
-    "lint": "eslint --cache \"src/**/*.{ts,tsx}\"",
-    "lint:fix": "eslint --cache --fix src --ext .ts,.tsx",
-    "lint:style": "stylelint \"src/**/*.css\"",
-    "lint:style:fix": "stylelint \"src/**/*.css\" --fix",
-    "lint:dead": "knip --include files,exports,dependencies --no-config-hints",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write --cache .",
-    "format:check": "prettier --check --cache ."
-  },
-  "dependencies": {
-    "@radix-ui/react-alert-dialog": "^1.1.15",
-    "@radix-ui/react-checkbox": "^1.3.3",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-switch": "^1.2.6",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.57.0",
-    "@testing-library/dom": "^10.4.1",
-    "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/react": "^16.3.2",
-    "@testing-library/user-event": "^14.6.1",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.58.2",
-    "@typescript-eslint/parser": "^8.58.2",
-    "@vitejs/plugin-react": "^6.0.2",
-    "autoprefixer": "^10.5.0",
-    "eslint": "^10.2.1",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-unused-imports": "^4.4.1",
-    "happy-dom": "^20.9.0",
-    "knip": "^6.4.1",
-    "postcss": "^8.5.15",
-    "prettier": "^3.8.2",
-    "stylelint": "^16.26.1",
-    "stylelint-config-recommended": "^17.0.0",
-    "tailwindcss": "^3.4.19",
-    "typescript": "^5.6.3",
-    "vite": "^8.0.16",
-    "vitest": "^4.1.8"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
-  }
-}
diff --git a/gui/frontend/src/app.test.ts b/gui/frontend/src/app.test.ts
deleted file mode 100644
index bdc2fd7c..00000000
--- a/gui/frontend/src/app.test.ts
+++ /dev/null
@@ -1,1378 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { createElement } from "react";
-import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import App, { hasExplicitEmptyReleaseTrackerSelection, ruleBlockingTrackerLabels } from "./app";
-import type {
-  DescriptionBuilderPreview,
-  DVDMenuCaptureSnapshot,
-  DupeCheckResult,
-  DupeCheckSnapshot,
-  DupeEntry,
-  DupeMatch,
-  HistoryEntry,
-  HistoryOverview,
-  MetadataPreview,
-  ScreenshotPlan,
-  TrackerUploadSnapshot,
-} from "./types";
-import { isRuntimePathCaseInsensitive, updateBrowserCSRFToken } from "./utils/runtime";
-import { hasFilteredEmptyUploadTrackerSelection } from "./utils/trackerSelection";
-
-vi.mock("../wailsjs/runtime/runtime", () => ({
-  EventsOn: vi.fn(() => () => undefined),
-  OnFileDrop: vi.fn(),
-  OnFileDropOff: vi.fn(),
-}));
-
-const defaultPathCaseInsensitive = isRuntimePathCaseInsensitive();
-
-afterEach(() => {
-  cleanup();
-  vi.useRealTimers();
-  vi.unstubAllGlobals();
-  updateBrowserCSRFToken("", defaultPathCaseInsensitive);
-  delete (globalThis as typeof globalThis & { go?: any }).go;
-});
-
-type FetchMetadata = (
-  sourcePath: string,
-  sourceLookupURL: string,
-  overrides: unknown,
-  nameOverrides: unknown,
-  trackers: string[],
-) => Promise<MetadataPreview>;
-
-type ResetMetadata = FetchMetadata;
-type SaveConfig = (config: string) => Promise<void>;
-type FetchScreenshotPlan = (sourcePath: string) => Promise<ScreenshotPlan>;
-type FetchDescriptionBuilder = (
-  sourcePath: string,
-  overrides: unknown,
-  nameOverrides: unknown,
-  trackers: string[],
-  ignoreDupesFor: string[],
-) => Promise<DescriptionBuilderPreview>;
-type FetchPreparation = (
-  sourcePath: string,
-  overrides: unknown,
-  nameOverrides: unknown,
-  trackers: string[],
-  ignoreDupesFor: string[],
-) => Promise<unknown>;
-type DetectDiscType = (sourcePath: string) => Promise<string>;
-type StartDupeCheck = (...args: unknown[]) => Promise<string>;
-type GetDupeCheckSnapshot = (jobID: string) => Promise<DupeCheckSnapshot>;
-type StartTrackerUpload = (...args: unknown[]) => Promise<string>;
-type RetryFailedTrackerUpload = (jobID: string) => Promise<string>;
-type CancelTrackerUpload = (jobID: string) => Promise<void>;
-type GetTrackerUploadSnapshot = (jobID: string) => Promise<TrackerUploadSnapshot>;
-type ListHistory = () => Promise<HistoryEntry[]>;
-type GetHistoryOverview = (sourcePath: string) => Promise<HistoryOverview>;
-type DeleteHistoryRelease = (sourcePath: string) => Promise<void>;
-type StartDVDMenuCapture = (...args: unknown[]) => Promise<string>;
-type GetDVDMenuCaptureSnapshot = (jobID: string) => Promise<DVDMenuCaptureSnapshot>;
-
-const createDeferred = <T>() => {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((resolvePromise) => {
-    resolve = resolvePromise;
-  });
-  return { promise, resolve };
-};
-
-const metadataPreview = (sourcePath: string): MetadataPreview => ({
-  SourcePath: sourcePath,
-  TrackerName: "AITHER",
-  ReleaseName: "Example.Release.2026.1080p",
-  Warnings: [],
-  ReleaseNameOverrides: {},
-  ExternalIDs: {
-    TMDBID: 1,
-    IMDBID: 0,
-    TVDBID: 0,
-    TVmazeID: 0,
-    MALID: 0,
-    Category: "movie",
-    SourceTMDB: "",
-    SourceIMDB: "",
-    SourceTVDB: "",
-    SourceTVmaze: "",
-    SourceMAL: "",
-  },
-  ExternalIDCandidates: {
-    TMDB: [],
-    IMDB: [],
-    TMDBAutoSelected: false,
-    IMDBAutoSelected: false,
-  },
-  ExternalIDInfo: [],
-  ExternalPreview: [],
-  TrackerData: [],
-});
-
-const screenshotPlan = (sourcePath: string): ScreenshotPlan => ({
-  SourcePath: sourcePath,
-  DiscType: "",
-  DurationSeconds: 60,
-  FrameRate: 24,
-  SuggestedSelections: [],
-  ExistingScreenshots: [],
-  ExistingTrackerScreenshots: [],
-  FinalSelections: [],
-  TrackerImageLinks: [],
-  PreviewImages: [],
-  MetadataTimestamp: "",
-  RequiresManualFrames: false,
-});
-
-const descriptionBuilderPreview = (sourcePath: string): DescriptionBuilderPreview => ({
-  SourcePath: sourcePath,
-  Groups: [],
-});
-
-const trackerUploadSnapshot = (
-  jobID: string,
-  status: string,
-  overrides: Partial<TrackerUploadSnapshot> = {},
-): TrackerUploadSnapshot => ({
-  jobID,
-  sourcePath: "C:\\media\\Example",
-  status,
-  currentTask: "",
-  currentTaskStatus: status,
-  currentMessage: "",
-  currentCompletedPieces: 0,
-  currentTotalPieces: 0,
-  currentPercent: 0,
-  currentHashRateMiB: 0,
-  trackers: [],
-  failedTrackers: [],
-  uploadedCount: status === "completed" ? 1 : 0,
-  error: "",
-  startedAt: "2026-06-17T00:00:00Z",
-  finishedAt: "",
-  ...overrides,
-});
-
-const emptyDupeMatch: DupeMatch = {
-  FilenameMatch: "",
-  FileCountMatch: 0,
-  SizeMatch: "",
-  TrumpableID: "",
-  MatchedID: "",
-  MatchedName: "",
-  MatchedLink: "",
-  MatchedDownload: "",
-  MatchedReason: "",
-  SeasonPackExists: false,
-  SeasonPackName: "",
-  SeasonPackLink: "",
-  SeasonPackID: "",
-  SeasonPackContainsEpisode: false,
-  MatchedEpisodeIDs: [],
-};
-
-const dupeEntry = (tracker: string): DupeEntry => ({
-  Name: `${tracker} duplicate`,
-  SizeBytes: 0,
-  SizeKnown: false,
-  SizeText: "",
-  Files: [],
-  FileCount: 0,
-  Trumpable: false,
-  Link: "",
-  Download: "",
-  Flags: [],
-  ID: "",
-  Type: "",
-  Res: "",
-  Internal: false,
-  BDInfo: "",
-  Description: "",
-});
-
-const dupeResult = (tracker: string, hasDupes: boolean): DupeCheckResult => ({
-  Tracker: tracker,
-  Raw: [],
-  Filtered: hasDupes ? [dupeEntry(tracker)] : [],
-  HasDupes: hasDupes,
-  ContentFail: false,
-  Match: emptyDupeMatch,
-  Notes: [],
-  Skipped: false,
-  SkipReason: "",
-  SkipCode: "",
-  SkipRules: [],
-  Status: "completed",
-  Error: "",
-  CheckedAt: "2026-06-17T00:00:00Z",
-});
-
-const dupeCheckSnapshot = (sourcePath = "C:\\media\\Example"): DupeCheckSnapshot => ({
-  jobID: "dupe-job-1",
-  sourcePath,
-  status: "completed",
-  trackers: [],
-  completedCount: 2,
-  totalCount: 2,
-  summary: {
-    SourcePath: sourcePath,
-    Results: [dupeResult("AITHER", false), dupeResult("BLU", true)],
-    Notes: [],
-  },
-  error: "",
-  startedAt: "2026-06-17T00:00:00Z",
-  finishedAt: "2026-06-17T00:00:01Z",
-});
-
-const dvdMenuCaptureSnapshot = (): DVDMenuCaptureSnapshot => ({
-  jobID: "dvd-job-1",
-  sourcePath: "C:\\media\\Example",
-  status: "completed",
-  phase: "complete",
-  message: "DVD menu capture finished.",
-  discoveredMenus: 1,
-  visitedStates: 2,
-  visitedButtons: 1,
-  capturedCount: 1,
-  warningCount: 0,
-  result: {
-    SourcePath: "C:\\media\\Example",
-    Images: [],
-    SelectedLanguage: "en",
-    Region: 0,
-    DiscoveredMenus: 1,
-    VisitedStates: 2,
-    VisitedButtons: 1,
-    MaxItems: 6,
-    Complete: true,
-    Partial: false,
-    Truncated: false,
-    Warnings: [],
-    Engine: {
-      EngineVersion: "phase0a-1",
-      SchemaVersion: 1,
-      SupportedFeatures: [],
-      FFmpegVersion: "8.0",
-      FFmpegDVDVideo: true,
-      MissingFFmpegOptions: [],
-    },
-  },
-  error: "",
-  startedAt: "2026-07-10T00:00:00Z",
-  finishedAt: "2026-07-10T00:00:01Z",
-});
-
-const historyEntry = (sourcePath: string): HistoryEntry => ({
-  SourcePath: sourcePath,
-  ReleaseTitle: "Example Release",
-  ReleaseSource: "WEB",
-  ReleaseResolution: "1080p",
-  MetadataUpdatedAt: "2026-06-17T00:00:00Z",
-  LatestUploadStatus: "",
-  LatestUploadAt: "",
-  RuleFailureCount: 0,
-});
-
-const historyOverview = (sourcePath: string): HistoryOverview => ({
-  SourcePath: sourcePath,
-  ReleaseTitle: "Example Release",
-  ReleaseSource: "WEB",
-  ReleaseResolution: "1080p",
-  MetadataUpdatedAt: "2026-06-17T00:00:00Z",
-  LatestUploadStatus: "",
-  LatestUploadAt: "",
-  StatusLabel: "Stored",
-  Metadata: {},
-  ExternalIDs: metadataPreview(sourcePath).ExternalIDs,
-  ExternalMetadata: {},
-  ReleaseNameOverrides: {},
-  DescriptionOverride: {
-    SourcePath: sourcePath,
-    GroupKey: "",
-    Description: "",
-    UpdatedAt: "",
-  },
-  DescriptionOverrides: [],
-  PlaylistSelection: {
-    SourcePath: sourcePath,
-    SelectedPlaylists: [],
-    UseAll: false,
-    UpdatedAt: "",
-  },
-  TrackerMetadata: [],
-  TrackerRuleFailures: [],
-  Screenshots: [],
-  FinalSelections: [],
-  UploadedImages: [],
-  UploadHistory: [],
-});
-
-const installAppBridge = (
-  fetchMetadata: FetchMetadata,
-  options: {
-    resetMetadata?: ResetMetadata;
-    saveConfig?: SaveConfig;
-    fetchScreenshotPlan?: FetchScreenshotPlan;
-    fetchDescriptionBuilder?: FetchDescriptionBuilder;
-    fetchPreparation?: FetchPreparation;
-    browseFolder?: () => Promise<string>;
-    startDupeCheck?: StartDupeCheck;
-    getDupeCheckSnapshot?: GetDupeCheckSnapshot;
-    detectDiscType?: DetectDiscType;
-    startTrackerUpload?: StartTrackerUpload;
-    retryFailedTrackerUpload?: RetryFailedTrackerUpload;
-    cancelTrackerUpload?: CancelTrackerUpload;
-    getTrackerUploadSnapshot?: GetTrackerUploadSnapshot;
-    listHistory?: ListHistory;
-    getHistoryOverview?: GetHistoryOverview;
-    deleteHistoryRelease?: DeleteHistoryRelease;
-    startDVDMenuCapture?: StartDVDMenuCapture;
-    getDVDMenuCaptureSnapshot?: GetDVDMenuCaptureSnapshot;
-  } = {},
-) => {
-  const storage = new Map<string, string>();
-  vi.stubGlobal("localStorage", {
-    getItem: (key: string) => storage.get(key) ?? null,
-    setItem: (key: string, value: string) => {
-      storage.set(key, value);
-    },
-    removeItem: (key: string) => {
-      storage.delete(key);
-    },
-  });
-  vi.stubGlobal("matchMedia", () => ({ matches: true }));
-  (globalThis as typeof globalThis & { go?: any }).go = {
-    guiapp: {
-      App: {
-        GetConfig: async () =>
-          JSON.stringify({
-            MainSettings: {
-              UseFavicons: false,
-            },
-            Trackers: {
-              DefaultTrackers: ["AITHER", "BLU"],
-              Trackers: {
-                AITHER: { APIKey: "configured" },
-                BLU: { APIKey: "configured" },
-              },
-            },
-            ScreenshotHandling: {
-              ProcessLimit: 1,
-              MaxMenuItems: 6,
-            },
-          }),
-        BrowseFolder: options.browseFolder ?? (async () => "C:\\media\\Example\\BDMV"),
-        GetDefaultConfig: async () => JSON.stringify({ Trackers: { Trackers: {} } }),
-        FetchMetadata: fetchMetadata,
-        DetectDiscType: options.detectDiscType,
-        ResetMetadata:
-          options.resetMetadata ?? (async (sourcePath: string) => metadataPreview(sourcePath)),
-        SaveConfig: options.saveConfig ?? (async () => undefined),
-        FetchScreenshotPlan:
-          options.fetchScreenshotPlan ?? (async (sourcePath: string) => screenshotPlan(sourcePath)),
-        FetchDescriptionBuilder:
-          options.fetchDescriptionBuilder ??
-          (async (sourcePath: string) => descriptionBuilderPreview(sourcePath)),
-        FetchPreparation: options.fetchPreparation ?? (async () => ({})),
-        ListUploadedImages: async () => [],
-        ListDVDMenuScreenshots: async () => [],
-        ReadScreenshotImage: async () => "data:image/png;base64,example",
-        StartDVDMenuCapture: options.startDVDMenuCapture ?? (async () => "dvd-job-1"),
-        GetDVDMenuCaptureSnapshot:
-          options.getDVDMenuCaptureSnapshot ?? (async () => dvdMenuCaptureSnapshot()),
-        CancelDVDMenuCapture: async () => undefined,
-        DeleteDVDMenuScreenshot: async () => undefined,
-        ImportMenuImages: async () => undefined,
-        DiscoverPlaylists: async () => [
-          {
-            file: "00001.mpls",
-            duration: 7200,
-            size: 0,
-            score: 1,
-            items: [{ path: "00001.m2ts", size: 1024 }],
-          },
-        ],
-        SavePlaylistSelection: async () => undefined,
-        StartDupeCheck: options.startDupeCheck ?? (async () => "dupe-job-1"),
-        GetDupeCheckSnapshot: options.getDupeCheckSnapshot ?? (async () => dupeCheckSnapshot()),
-        StartTrackerUpload: options.startTrackerUpload ?? (async () => "upload-job-1"),
-        RetryFailedTrackerUpload: options.retryFailedTrackerUpload ?? (async () => "upload-job-2"),
-        CancelTrackerUpload: options.cancelTrackerUpload ?? (async () => undefined),
-        GetTrackerUploadSnapshot:
-          options.getTrackerUploadSnapshot ??
-          (async (jobID: string) => trackerUploadSnapshot(jobID, "completed")),
-        ListHistory: options.listHistory ?? (async () => []),
-        GetHistoryOverview:
-          options.getHistoryOverview ?? (async (sourcePath: string) => historyOverview(sourcePath)),
-        DeleteHistoryRelease: options.deleteHistoryRelease ?? (async () => undefined),
-      },
-    },
-  };
-};
-
-const openTrackerUploadPage = async (
-  fetchMetadata: FetchMetadata,
-  options: Parameters<typeof installAppBridge>[1] = {},
-) => {
-  installAppBridge(fetchMetadata, options);
-
-  render(createElement(App));
-
-  fireEvent.change(screen.getByLabelText("Source path"), {
-    target: { value: "C:\\media\\Example" },
-  });
-  fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-  await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-  await screen.findByText("2/2");
-
-  fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-  fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-  await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-  fireEvent.click(screen.getByRole("button", { name: "Description Builder" }));
-  await screen.findByRole("button", { name: "Tracker Upload" });
-  fireEvent.click(screen.getByRole("button", { name: "Tracker Upload" }));
-  await screen.findByRole("heading", { name: "Upload Targets" });
-};
-
-describe("hasExplicitEmptyReleaseTrackerSelection", () => {
-  it("does not treat pre-selection state as deselect-all", () => {
-    expect(hasExplicitEmptyReleaseTrackerSelection([], {})).toBe(false);
-    expect(hasExplicitEmptyReleaseTrackerSelection([{ name: "AITHER" }], {})).toBe(false);
-  });
-
-  it("treats initialized all-false tracker state as explicit empty selection", () => {
-    expect(
-      hasExplicitEmptyReleaseTrackerSelection([{ name: "AITHER" }, { name: "BLU" }], {
-        AITHER: false,
-        BLU: false,
-      }),
-    ).toBe(true);
-  });
-
-  it("keeps nonempty tracker selections available", () => {
-    expect(
-      hasExplicitEmptyReleaseTrackerSelection([{ name: "AITHER" }, { name: "BLU" }], {
-        AITHER: true,
-        BLU: false,
-      }),
-    ).toBe(false);
-  });
-});
-
-describe("external ID edits", () => {
-  it("sends touched equal-value IDs plus edited and cleared MAL IDs", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath, _lookup, overrides) => {
-      const idOverrides = overrides as { TMDBID?: number; MALID?: number };
-      const result = metadataPreview(sourcePath);
-      return {
-        ...result,
-        ExternalIDs: {
-          ...result.ExternalIDs,
-          TMDBID: idOverrides.TMDBID ?? result.ExternalIDs.TMDBID,
-          MALID: idOverrides.MALID ?? result.ExternalIDs.MALID,
-        },
-      };
-    });
-    installAppBridge(fetchMetadata);
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-
-    fireEvent.click(screen.getByText("Edit Release Details"));
-    const tmdbInput = screen.getByLabelText("TMDB ID");
-    fireEvent.change(tmdbInput, { target: { value: "2" } });
-    fireEvent.change(tmdbInput, { target: { value: "1" } });
-    const malInput = screen.getByLabelText("MAL ID");
-    fireEvent.change(malInput, { target: { value: "5114" } });
-
-    const refreshButton = screen.getByRole("button", { name: "Refresh metadata" });
-    await waitFor(() => expect(refreshButton).not.toBeDisabled());
-    fireEvent.click(refreshButton);
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(2));
-    expect(fetchMetadata.mock.calls[1][2]).toEqual({ TMDBID: 1, MALID: 5114 });
-
-    await waitFor(() => expect(screen.getByLabelText("MAL ID")).toHaveValue("5114"));
-    fireEvent.change(screen.getByLabelText("MAL ID"), { target: { value: "" } });
-
-    await waitFor(() => expect(refreshButton).not.toBeDisabled());
-    fireEvent.click(refreshButton);
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(3));
-    expect(fetchMetadata.mock.calls[2][2]).toEqual({ TMDBID: 1, MALID: 0 });
-  });
-});
-
-describe("ruleBlockingTrackerLabels", () => {
-  const labelsFor = (result: Partial<DupeCheckResult> & Pick<DupeCheckResult, "Tracker">) =>
-    Array.from(
-      ruleBlockingTrackerLabels({
-        ...dupeResult(result.Tracker, false),
-        Skipped: true,
-        ...result,
-      }),
-    ).sort();
-
-  it("blocks skipped trackers", () => {
-    expect(labelsFor({ Tracker: "CZT" })).toEqual(["czt"]);
-    expect(labelsFor({ Tracker: "HDB", SkipCode: "legacy_code" })).toEqual(["hdb"]);
-  });
-
-  it("blocks each split tracker label", () => {
-    expect(labelsFor({ Tracker: "CZT, HDB", SkipCode: "legacy_code" })).toEqual([
-      "czt",
-      "czt, hdb",
-      "hdb",
-    ]);
-    expect(labelsFor({ Tracker: ", CZT,, ", SkipCode: "legacy_code" })).toEqual([", czt,,", "czt"]);
-  });
-});
-
-describe("hasFilteredEmptyUploadTrackerSelection", () => {
-  const trackerUploadItems = [
-    { name: "AITHER", config: {} },
-    { name: "BLU", config: {} },
-  ];
-
-  it("detects selected input trackers filtered out of upload eligibility", () => {
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: {
-          AITHER: false,
-          BLU: true,
-        },
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(["blu"]),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(true);
-  });
-
-  it("preserves missing-key startup and nonempty eligible selections", () => {
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: {},
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(false);
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: {
-          AITHER: true,
-        },
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(false);
-  });
-
-  it("does not treat disabled upload toggles as missing startup state", () => {
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: {
-          AITHER: true,
-          BLU: false,
-        },
-        uploadToggles: { AITHER: false, BLU: true },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(true);
-  });
-});
-
-describe("metadata tracker payloads", () => {
-  it("gates Disc Menus by detected disc type", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata, { detectDiscType: async () => "" });
-
-    render(createElement(App));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example.mkv" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledOnce());
-    await screen.findByText("2/2");
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    expect(screen.queryByRole("button", { name: "Menu Images" })).not.toBeInTheDocument();
-  });
-
-  it("ignores a fetch disc detection after the source path changes", async () => {
-    const detection = createDeferred<string>();
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const detectDiscType = vi.fn<DetectDiscType>(() => detection.promise);
-    installAppBridge(fetchMetadata, { detectDiscType });
-
-    render(createElement(App));
-    const sourcePath = screen.getByLabelText("Source path");
-    fireEvent.change(sourcePath, { target: { value: "C:\\media\\First" } });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(detectDiscType).toHaveBeenCalledWith("C:\\media\\First"));
-
-    fireEvent.change(sourcePath, { target: { value: "C:\\media\\Second.mkv" } });
-    await act(async () => detection.resolve("BDMV"));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledOnce());
-    await screen.findByText("2/2");
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    expect(screen.queryByRole("button", { name: "Menu Images" })).not.toBeInTheDocument();
-  });
-
-  it("ignores an older browse disc detection after a newer path selection", async () => {
-    const firstDetection = createDeferred<string>();
-    const secondDetection = createDeferred<string>();
-    const firstPath = "C:\\media\\First";
-    const secondPath = "C:\\media\\Second";
-    const browseFolder = vi
-      .fn<() => Promise<string>>()
-      .mockResolvedValueOnce(firstPath)
-      .mockResolvedValueOnce(secondPath);
-    const detectDiscType = vi.fn<DetectDiscType>((sourcePath) => {
-      if (sourcePath === firstPath) {
-        return firstDetection.promise;
-      }
-      if (sourcePath === secondPath) {
-        return secondDetection.promise;
-      }
-      return Promise.resolve("");
-    });
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata, { browseFolder, detectDiscType });
-
-    render(createElement(App));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example.mkv" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledOnce());
-    await screen.findByText("2/2");
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-    await waitFor(() => expect(detectDiscType).toHaveBeenCalledWith(firstPath));
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-    await waitFor(() => expect(detectDiscType).toHaveBeenCalledWith(secondPath));
-
-    await act(async () => secondDetection.resolve(""));
-    await act(async () => firstDetection.resolve("BDMV"));
-
-    expect(screen.getByLabelText("Source path")).toHaveValue(secondPath);
-    expect(screen.queryByRole("button", { name: "Menu Images" })).not.toBeInTheDocument();
-  });
-
-  it("invalidates Description Builder after DVD menu capture without auto-navigation", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchDescriptionBuilder = vi.fn<FetchDescriptionBuilder>(async (sourcePath) =>
-      descriptionBuilderPreview(sourcePath),
-    );
-    installAppBridge(fetchMetadata, {
-      detectDiscType: async () => "DVD",
-      fetchDescriptionBuilder,
-      startDVDMenuCapture: async () => "dvd-job-1",
-      getDVDMenuCaptureSnapshot: async () => dvdMenuCaptureSnapshot(),
-    });
-
-    render(createElement(App));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledOnce());
-    await screen.findByText("2/2");
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Description Builder" }));
-    await waitFor(() => expect(fetchDescriptionBuilder).toHaveBeenCalledTimes(1));
-    fireEvent.click(screen.getByRole("button", { name: "Menu Images" }));
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    expect(await screen.findByText("Captured 1 DVD menu image.")).toBeInTheDocument();
-    expect(screen.getByRole("heading", { name: "Menu Images" })).toBeInTheDocument();
-
-    fireEvent.click(screen.getByRole("button", { name: "Description Builder" }));
-    await waitFor(() => expect(fetchDescriptionBuilder).toHaveBeenCalledTimes(2));
-  });
-
-  it("excludes dupe-blocked upload targets from metadata fetches", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata);
-
-    render(createElement(App));
-
-    const sourcePath = screen.getByLabelText("Source path");
-    fireEvent.change(sourcePath, { target: { value: "C:\\media\\Example" } });
-
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(2));
-    expect(fetchMetadata.mock.calls[1][4]).toEqual(["AITHER", "BLU"]);
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(3));
-    expect(fetchMetadata.mock.calls[2][4]).toEqual(["AITHER"]);
-  });
-
-  it("restores dupe-ignored trackers for description builder requests", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchDescriptionBuilder = vi.fn<FetchDescriptionBuilder>(async (sourcePath) =>
-      descriptionBuilderPreview(sourcePath),
-    );
-    installAppBridge(fetchMetadata, { fetchDescriptionBuilder });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("switch", { name: "Ignore dupes for BLU" }));
-    await waitFor(() => expect(screen.getByText("Available for upload: 2")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Description Builder" }));
-
-    await waitFor(() => expect(fetchDescriptionBuilder).toHaveBeenCalledTimes(1));
-    expect(fetchDescriptionBuilder.mock.calls[0][3]).toEqual(["AITHER", "BLU"]);
-    expect(fetchDescriptionBuilder.mock.calls[0][4]).toEqual(["blu"]);
-  });
-
-  it("does not apply dupe blocks from a previous path to metadata fetches", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata);
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Other" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(2));
-    expect(fetchMetadata.mock.calls[1][0]).toBe("C:\\media\\Other");
-    expect(fetchMetadata.mock.calls[1][4]).toEqual(["AITHER", "BLU"]);
-  });
-
-  it("keeps current upload disables when stale dupe state came from another path", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata);
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Other" },
-    });
-    await waitFor(() =>
-      expect(screen.getByLabelText("Source path")).toHaveValue("C:\\media\\Other"),
-    );
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(2));
-    expect(fetchMetadata.mock.calls[1][4]).toEqual(["AITHER", "BLU"]);
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(await screen.findByRole("button", { name: "Description Builder" }));
-    fireEvent.click(await screen.findByRole("button", { name: "Tracker Upload" }));
-    await screen.findByRole("heading", { name: "Upload Targets" });
-    const aitherUploadSwitch = screen.getByRole("switch", { name: "Enable upload for AITHER" });
-    expect(aitherUploadSwitch).toHaveAttribute("aria-checked", "true");
-    fireEvent.click(aitherUploadSwitch);
-    await waitFor(() => expect(aitherUploadSwitch).toHaveAttribute("aria-checked", "false"));
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(3));
-    expect(fetchMetadata.mock.calls[2][0]).toBe("C:\\media\\Other");
-    expect(fetchMetadata.mock.calls[2][4]).toEqual(["BLU"]);
-  });
-
-  it("keeps input tracker selections after deleting the current history release", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const deletedPath = "C:\\media\\Example";
-    const listHistory = vi
-      .fn<ListHistory>()
-      .mockResolvedValueOnce([historyEntry(deletedPath)])
-      .mockResolvedValue([]);
-    const deleteHistoryRelease = vi.fn<DeleteHistoryRelease>(async () => undefined);
-    const confirm = vi.fn(() => true);
-    vi.stubGlobal("confirm", confirm);
-    installAppBridge(fetchMetadata, {
-      listHistory,
-      getHistoryOverview: async (sourcePath) => historyOverview(sourcePath),
-      deleteHistoryRelease,
-    });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: deletedPath },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(screen.getByRole("button", { name: "History" }));
-    await screen.findByRole("button", { name: /Example Release/ });
-    fireEvent.click(await screen.findByRole("button", { name: "Remove from database" }));
-    await waitFor(() => expect(deleteHistoryRelease).toHaveBeenCalledWith(deletedPath));
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Other" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(2));
-    expect(fetchMetadata.mock.calls[1][4]).toEqual(["AITHER", "BLU"]);
-    await screen.findByText("2/2");
-  });
-
-  it("blocks metadata fetch when all selected trackers are filtered out", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    installAppBridge(fetchMetadata);
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("checkbox", { name: "AITHER" }));
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("Select at least one tracker before fetching metadata."),
-      ).toBeInTheDocument(),
-    );
-    expect(fetchMetadata).toHaveBeenCalledTimes(1);
-  });
-
-  it("uses structured SkipRules for upload eligibility", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchPreparation = vi.fn<FetchPreparation>(async () => ({}));
-    installAppBridge(fetchMetadata, {
-      fetchPreparation,
-      getDupeCheckSnapshot: async () => ({
-        ...dupeCheckSnapshot(),
-        summary: {
-          SourcePath: "C:\\media\\Example",
-          Results: [
-            dupeResult("AITHER", false),
-            {
-              ...dupeResult("BLU", false),
-              Skipped: true,
-              Status: "skipped",
-              SkipRules: ["required_metadata"],
-            },
-          ],
-          Notes: [],
-        },
-      }),
-    });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-    fireEvent.click(await screen.findByRole("button", { name: "Confirm Selection" }));
-
-    await waitFor(() => expect(fetchPreparation).toHaveBeenCalledTimes(1));
-    expect(fetchPreparation.mock.calls[0][3]).toEqual(["AITHER"]);
-  });
-
-  it("blocks metadata reset when all selected trackers are filtered out", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const resetMetadata = vi.fn<ResetMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const confirm = vi.fn(() => true);
-    installAppBridge(fetchMetadata, { resetMetadata });
-    vi.stubGlobal("confirm", confirm);
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("checkbox", { name: "AITHER" }));
-    fireEvent.click(screen.getByRole("button", { name: "Reset data + refresh" }));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("Select at least one tracker before resetting metadata."),
-      ).toBeInTheDocument(),
-    );
-    expect(confirm).not.toHaveBeenCalled();
-    expect(resetMetadata).not.toHaveBeenCalled();
-  });
-
-  it("skips warm metadata fetch when all selected trackers are filtered out", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const saveConfig = vi.fn<SaveConfig>(async () => undefined);
-    installAppBridge(fetchMetadata, { saveConfig });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("checkbox", { name: "AITHER" }));
-    fireEvent.click(screen.getByRole("button", { name: "Screenshots" }));
-    fireEvent.click(screen.getByText("Screenshot settings"));
-    fireEvent.change(screen.getByLabelText("FFmpeg concurrency"), { target: { value: "2" } });
-    fireEvent.click(screen.getByRole("button", { name: "Apply settings" }));
-
-    await waitFor(() => expect(saveConfig).toHaveBeenCalledTimes(1));
-    expect(fetchMetadata).toHaveBeenCalledTimes(1);
-  });
-
-  it("uses upload-eligible trackers when preparing selected playlists", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchPreparation = vi.fn<FetchPreparation>(async () => ({}));
-    installAppBridge(fetchMetadata, { fetchPreparation });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-
-    fireEvent.click(await screen.findByRole("button", { name: "Confirm Selection" }));
-
-    await waitFor(() => expect(fetchPreparation).toHaveBeenCalledTimes(1));
-    expect(fetchPreparation.mock.calls[0][3]).toEqual(["AITHER"]);
-    expect(fetchPreparation.mock.calls[0][4]).toEqual([]);
-  });
-
-  it("does not apply previous path dupe blocks when preparing selected playlists", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchPreparation = vi.fn<FetchPreparation>(async () => ({}));
-    installAppBridge(fetchMetadata, {
-      browseFolder: async () => "C:\\media\\Other\\BDMV",
-      fetchPreparation,
-    });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-    fireEvent.click(await screen.findByRole("button", { name: "Confirm Selection" }));
-
-    await waitFor(() => expect(fetchPreparation).toHaveBeenCalledTimes(1));
-    expect(fetchPreparation.mock.calls[0][3]).toEqual(["AITHER", "BLU"]);
-    expect(fetchPreparation.mock.calls[0][4]).toEqual([]);
-  });
-
-  it.each([
-    {
-      name: "root to lowercase child",
-      dupeSourcePath: "C:\\media\\Example",
-      browsePath: "C:\\media\\Example\\bdmv",
-    },
-    {
-      name: "lowercase child to root",
-      dupeSourcePath: "C:\\media\\Example\\bdmv",
-      browsePath: "C:\\media\\Example",
-      detectDiscType: async () => "BDMV",
-    },
-    {
-      name: "trailing slash root to lowercase child",
-      dupeSourcePath: "C:\\media\\Example\\",
-      browsePath: "C:\\media\\Example\\bdmv\\",
-    },
-  ])("matches lowercase BDMV context for playlist preparation: $name", async (testCase) => {
-    updateBrowserCSRFToken("", false);
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const fetchPreparation = vi.fn<FetchPreparation>(async () => ({}));
-    installAppBridge(fetchMetadata, {
-      browseFolder: async () => testCase.browsePath,
-      getDupeCheckSnapshot: async () => dupeCheckSnapshot(testCase.dupeSourcePath),
-      detectDiscType: testCase.detectDiscType,
-      fetchPreparation,
-    });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: testCase.dupeSourcePath },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Input" }));
-    fireEvent.click(screen.getByRole("button", { name: "Browse folder" }));
-    fireEvent.click(await screen.findByRole("button", { name: "Confirm Selection" }));
-
-    await waitFor(() => expect(fetchPreparation).toHaveBeenCalledTimes(1));
-    expect(fetchPreparation.mock.calls[0][3]).toEqual(["AITHER"]);
-    expect(fetchPreparation.mock.calls[0][4]).toEqual([]);
-  });
-});
-
-describe("dupe check job tracking", () => {
-  it("honors fresh upload tracker toggles when starting dupe checks", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startDupeCheck = vi.fn<StartDupeCheck>(async () => "dupe-job-1");
-    installAppBridge(fetchMetadata, { startDupeCheck });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    const bluTrackerCheckbox = screen.getByRole("checkbox", { name: "BLU" });
-    expect(bluTrackerCheckbox).toHaveAttribute("aria-checked", "true");
-    fireEvent.click(bluTrackerCheckbox);
-    await waitFor(() => expect(bluTrackerCheckbox).toHaveAttribute("aria-checked", "false"));
-
-    fireEvent.click(screen.getByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(startDupeCheck).toHaveBeenCalledTimes(1));
-
-    expect(startDupeCheck.mock.calls[0][3]).toEqual(["AITHER"]);
-  });
-
-  it("reruns dupe checks without filtering previous dupe results", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startDupeCheck = vi.fn<StartDupeCheck>(async () => "dupe-job-1");
-    installAppBridge(fetchMetadata, { startDupeCheck });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(startDupeCheck).toHaveBeenCalledTimes(2));
-
-    expect(startDupeCheck.mock.calls[1][3]).toEqual(["AITHER", "BLU"]);
-  });
-
-  it("keeps previous dupe results when job creation fails", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startDupeCheck = vi
-      .fn<StartDupeCheck>()
-      .mockResolvedValueOnce("dupe-job-1")
-      .mockRejectedValueOnce(new Error("dupe check requires metadata preview"));
-    installAppBridge(fetchMetadata, { startDupeCheck });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-    await waitFor(() => expect(screen.getByText("1 blocked.")).toBeInTheDocument());
-
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-
-    await waitFor(() => expect(startDupeCheck).toHaveBeenCalledTimes(2));
-    await screen.findByText("Fetch metadata first to cache a preview before checking dupes.");
-    expect(screen.getByText("1 blocked.")).toBeInTheDocument();
-  });
-
-  it("shows metadata preview guidance when dupe job creation is blocked", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startDupeCheck = vi.fn<StartDupeCheck>(async () => {
-      throw new Error("dupe check requires metadata preview");
-    });
-    installAppBridge(fetchMetadata, { startDupeCheck });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-
-    await waitFor(() => expect(startDupeCheck).toHaveBeenCalledTimes(1));
-    await screen.findByText("Fetch metadata first to cache a preview before checking dupes.");
-  });
-
-  it("shows metadata preview guidance when an existing dupe job reports a cache miss", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const getDupeCheckSnapshot = vi.fn<GetDupeCheckSnapshot>(async () => ({
-      ...dupeCheckSnapshot(),
-      status: "failed",
-      summary: { SourcePath: "C:\\media\\Example", Results: [], Notes: [] },
-      error: "core: dupe check requires metadata preview",
-      finishedAt: "2026-06-17T00:00:01Z",
-    }));
-    installAppBridge(fetchMetadata, { getDupeCheckSnapshot });
-
-    render(createElement(App));
-
-    fireEvent.change(screen.getByLabelText("Source path"), {
-      target: { value: "C:\\media\\Example" },
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
-    await waitFor(() => expect(fetchMetadata).toHaveBeenCalledTimes(1));
-    await screen.findByText("2/2");
-
-    fireEvent.click(await screen.findByRole("button", { name: "Dupe Checking" }));
-    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
-
-    await waitFor(() => expect(getDupeCheckSnapshot).toHaveBeenCalledWith("dupe-job-1"));
-    await screen.findByText("Fetch metadata first to cache a preview before checking dupes.");
-  });
-});
-
-describe("tracker upload job tracking", () => {
-  it("keeps start upload tracking alive when bootstrap snapshot loading fails", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startTrackerUpload = vi.fn<StartTrackerUpload>(async () => "upload-job-1");
-    const getTrackerUploadSnapshot = vi
-      .fn<GetTrackerUploadSnapshot>()
-      .mockRejectedValueOnce(new Error("bootstrap failed"))
-      .mockResolvedValueOnce(trackerUploadSnapshot("upload-job-1", "running"));
-    await openTrackerUploadPage(fetchMetadata, { startTrackerUpload, getTrackerUploadSnapshot });
-
-    fireEvent.click(screen.getByRole("button", { name: "Start Upload" }));
-
-    await waitFor(() => expect(startTrackerUpload).toHaveBeenCalledTimes(1));
-    await waitFor(() => expect(getTrackerUploadSnapshot).toHaveBeenCalledWith("upload-job-1"));
-    await waitFor(() => expect(screen.getByRole("button", { name: "Cancel" })).toBeEnabled());
-    await waitFor(() => expect(getTrackerUploadSnapshot).toHaveBeenCalledTimes(2), {
-      timeout: 1500,
-    });
-    expect(getTrackerUploadSnapshot.mock.calls[1][0]).toBe("upload-job-1");
-  });
-
-  it("preserves start upload creation failures", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startTrackerUpload = vi.fn<StartTrackerUpload>(async () => {
-      throw new Error("start failed");
-    });
-    const getTrackerUploadSnapshot = vi.fn<GetTrackerUploadSnapshot>();
-    await openTrackerUploadPage(fetchMetadata, { startTrackerUpload, getTrackerUploadSnapshot });
-
-    fireEvent.click(screen.getByRole("button", { name: "Start Upload" }));
-
-    await waitFor(() => expect(screen.getByText("Error: start failed")).toBeInTheDocument());
-    expect(screen.getByRole("button", { name: "Cancel" })).toBeDisabled();
-    expect(getTrackerUploadSnapshot).not.toHaveBeenCalled();
-  });
-
-  it("keeps retry upload tracking alive when replacement bootstrap snapshot loading fails", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startTrackerUpload = vi.fn<StartTrackerUpload>(async () => "upload-job-1");
-    const retryFailedTrackerUpload = vi.fn<RetryFailedTrackerUpload>(async () => "upload-job-2");
-    const getTrackerUploadSnapshot = vi
-      .fn<GetTrackerUploadSnapshot>()
-      .mockResolvedValueOnce(
-        trackerUploadSnapshot("upload-job-1", "failed", {
-          failedTrackers: ["AITHER"],
-          error: "upload failed",
-          finishedAt: "2026-06-17T00:00:01Z",
-        }),
-      )
-      .mockRejectedValueOnce(new Error("retry bootstrap failed"))
-      .mockResolvedValueOnce(trackerUploadSnapshot("upload-job-2", "running"));
-    await openTrackerUploadPage(fetchMetadata, {
-      startTrackerUpload,
-      retryFailedTrackerUpload,
-      getTrackerUploadSnapshot,
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Start Upload" }));
-    await waitFor(() => expect(screen.getByRole("button", { name: "Retry Failed" })).toBeEnabled());
-
-    fireEvent.click(screen.getByRole("button", { name: "Retry Failed" }));
-
-    await waitFor(() => expect(retryFailedTrackerUpload).toHaveBeenCalledWith("upload-job-1"));
-    await waitFor(() => expect(getTrackerUploadSnapshot).toHaveBeenCalledWith("upload-job-2"));
-    await waitFor(() => expect(screen.getByRole("button", { name: "Cancel" })).toBeEnabled());
-    await waitFor(() => expect(getTrackerUploadSnapshot).toHaveBeenCalledTimes(3), {
-      timeout: 1500,
-    });
-    expect(getTrackerUploadSnapshot.mock.calls[2][0]).toBe("upload-job-2");
-  });
-
-  it("preserves retry creation failures", async () => {
-    const fetchMetadata = vi.fn<FetchMetadata>(async (sourcePath) => metadataPreview(sourcePath));
-    const startTrackerUpload = vi.fn<StartTrackerUpload>(async () => "upload-job-1");
-    const retryFailedTrackerUpload = vi.fn<RetryFailedTrackerUpload>(async () => {
-      throw new Error("retry failed");
-    });
-    const getTrackerUploadSnapshot = vi.fn<GetTrackerUploadSnapshot>().mockResolvedValueOnce(
-      trackerUploadSnapshot("upload-job-1", "failed", {
-        failedTrackers: ["AITHER"],
-        error: "upload failed",
-        finishedAt: "2026-06-17T00:00:01Z",
-      }),
-    );
-    await openTrackerUploadPage(fetchMetadata, {
-      startTrackerUpload,
-      retryFailedTrackerUpload,
-      getTrackerUploadSnapshot,
-    });
-    fireEvent.click(screen.getByRole("button", { name: "Start Upload" }));
-    await waitFor(() => expect(screen.getByRole("button", { name: "Retry Failed" })).toBeEnabled());
-
-    fireEvent.click(screen.getByRole("button", { name: "Retry Failed" }));
-
-    await waitFor(() => expect(screen.getByText("Error: retry failed")).toBeInTheDocument());
-    expect(screen.getByRole("button", { name: "Cancel" })).toBeDisabled();
-    expect(getTrackerUploadSnapshot).toHaveBeenCalledTimes(1);
-  });
-});
diff --git a/gui/frontend/src/app.tsx b/gui/frontend/src/app.tsx
deleted file mode 100644
index 563c028c..00000000
--- a/gui/frontend/src/app.tsx
+++ /dev/null
@@ -1,4822 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { KeyboardEvent as ReactKeyboardEvent } from "react";
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import * as Dialog from "@radix-ui/react-dialog";
-import { OnFileDrop, OnFileDropOff } from "../wailsjs/runtime/runtime";
-import {
-  EventsOn,
-  isBrowserMode,
-  isBrowserNativeBrowseAvailable,
-  isRuntimePathCaseInsensitive,
-  subscribeBrowserNativeBrowseAvailability,
-} from "./utils/runtime";
-import DescriptionBuilderPage from "./pages/description_builder";
-import BlurayCandidatesPage from "./pages/bluray_candidates";
-import DupeCheckPage from "./pages/dupe_check";
-import InputPage from "./pages/input";
-import HistoryPage from "./pages/history/index";
-import LoggingPage from "./pages/logging";
-import PlaylistSelectionPage from "./pages/playlist_selection";
-import ScreenshotsPage from "./pages/screenshots";
-import MenuImagesPage from "./pages/menu_images";
-import SettingsPage from "./pages/settings";
-import TrackerDataPage from "./pages/tracker_data";
-import TrackerUploadPage from "./pages/tracker_upload";
-import UploadImagesPage from "./pages/upload_images";
-import { useSettingsState } from "./hooks/useSettingsState";
-import { useScreenshots } from "./hooks/useScreenshots";
-import { useUploadImages } from "./hooks/useUploadImages";
-import { useTrackerIcons } from "./hooks/useTrackerIcons";
-import { cn } from "./utils/cn";
-import type {
-  ConfigMap,
-  ApplicationInfo,
-  BrowseDirectoryResponse,
-  DescriptionBuilderPreview,
-  DVDMenuCaptureSnapshot,
-  DupeCheckResult,
-  DupeCheckSnapshot,
-  DupeCheckSummary,
-  ExternalIDInfo,
-  ExternalIDOverrides,
-  ExternalIDs,
-  HistoryEntry,
-  HistoryOverview,
-  ImageHostPolicyMetadata,
-  MetadataPreview,
-  MetadataProgressUpdate,
-  PreparationPreview,
-  ReleaseNameEditState,
-  ReleaseNameOverrides,
-  ReleaseNameTouchedState,
-  ScreenshotImage,
-  ScreenshotPlan,
-  ScreenshotPreviewImage,
-  ScreenshotPurpose,
-  ScreenshotResult,
-  ScreenshotSelection,
-  TrackerQuestionnaire,
-  TrackerAuthCapability,
-  TrackerAuthLoginRequest,
-  TrackerAuthStatus,
-  TrackerDryRunPreview,
-  TrackerUploadSnapshot,
-  WebAuthStatus,
-  UploadedImageLink,
-  UploadImagesResult,
-  UploadProgressUpdate,
-} from "./types";
-import {
-  formatLabel,
-  isSkipAutoTorrentEnabled,
-  normalizeDefaultTrackerList,
-} from "./utils/settings";
-import {
-  addSourcePathHistoryEntry,
-  defaultInputHistoryLimit,
-  filterBrowseEntries,
-  inferSourcePathMode,
-  normalizeSourcePathHistory,
-  resolveInputHistoryLimit,
-  sameSourcePath,
-  type SourcePathHistoryEntry,
-  type SourcePathMode,
-  sourcePathHistoryStorageKey,
-} from "./utils/inputHistory";
-import { hasFetchedExternalPreviewData } from "./utils/externalPreview";
-import { handleExternalLinkClick } from "./utils/externalLinks";
-import { normalizeJobStatus } from "./utils/jobStatus";
-import { isMetadataProgressPathMatch } from "./utils/metadataProgress";
-import { dupeSkipReason, isRuleSkippedResult } from "./utils/dupeCheck";
-import {
-  hasFilteredEmptyUploadTrackerSelection as hasFilteredEmptyUploadTrackerSelectionState,
-  resolveSelectedUploadTrackers,
-} from "./utils/trackerSelection";
-
-const appLayoutClass =
-  "relative z-[1] block min-h-screen ml-[204px] max-[960px]:ml-0 max-[960px]:pb-[78px]";
-
-const sidebarClass =
-  "fixed left-0 top-0 z-[1000] flex h-screen w-[204px] flex-col gap-2.5 border-r border-white/10 bg-[var(--panel)]/95 p-2.5 backdrop-blur max-[960px]:bottom-0 max-[960px]:top-auto max-[960px]:h-auto max-[960px]:w-full max-[960px]:flex-row max-[960px]:items-center max-[960px]:gap-2 max-[960px]:border-r-0 max-[960px]:border-t max-[960px]:p-2";
-
-const sidebarGroupClass =
-  "grid gap-1 rounded-lg border border-[rgba(148,163,184,0.18)] bg-[rgba(148,163,184,0.08)] p-1.5 max-[960px]:flex max-[960px]:flex-wrap max-[960px]:gap-1 max-[960px]:p-1";
-
-const sidebarFooterClass = `${sidebarGroupClass} mt-auto max-[960px]:mt-0`;
-
-const navButtonClass = (active: boolean, nested = false) =>
-  cn(
-    "w-full rounded-md border border-transparent bg-transparent px-2 py-1.5 text-left text-[0.84rem] font-semibold leading-tight text-[var(--muted)] transition hover:bg-white/10 hover:text-[var(--text)] max-[960px]:w-auto max-[960px]:py-1.5",
-    nested && "pl-4 text-[0.8rem] font-medium max-[960px]:pl-2",
-    active &&
-      "border-[var(--sidebar-active-border)] bg-[var(--sidebar-active-bg)] text-[var(--sidebar-active-text)] shadow-[0_8px_22px_rgba(245,185,66,0.18)] hover:bg-[var(--sidebar-active-bg)] hover:text-[var(--sidebar-active-text)]",
-  );
-
-const sidebarButtonClass = (active = false) =>
-  cn(
-    "flex min-h-[30px] w-full items-center justify-start gap-1.5 rounded-md border border-transparent bg-transparent px-2 py-1.5 text-[0.84rem] font-semibold leading-tight text-[var(--muted)] transition hover:bg-white/10 hover:text-[var(--text)] max-[960px]:w-auto max-[960px]:min-h-7 max-[960px]:py-1",
-    active &&
-      "border-[var(--sidebar-active-border)] bg-[var(--sidebar-active-bg)] text-[var(--sidebar-active-text)] shadow-[0_8px_22px_rgba(245,185,66,0.18)] hover:bg-[var(--sidebar-active-bg)] hover:text-[var(--sidebar-active-text)]",
-  );
-
-const sidebarAppDetailsClass =
-  "mt-1 grid grid-cols-[1fr_auto] items-center gap-1.5 px-2 py-1.5 text-[0.72rem] leading-tight text-[var(--muted)] max-[960px]:hidden";
-
-type AppBridgeWithApplicationInfo = {
-  GetApplicationInfo?: () => Promise<ApplicationInfo>;
-};
-
-const emptyDupeSummary: DupeCheckSummary = {
-  SourcePath: "",
-  Results: [],
-  Notes: [],
-};
-
-const emptyPreview: MetadataPreview = {
-  SourcePath: "",
-  TrackerName: "",
-  ReleaseName: "",
-  Warnings: [],
-  ReleaseNameOverrides: {},
-  ExternalIDs: {
-    TMDBID: 0,
-    IMDBID: 0,
-    TVDBID: 0,
-    TVmazeID: 0,
-    MALID: 0,
-    Category: "",
-    SourceTMDB: "",
-    SourceIMDB: "",
-    SourceTVDB: "",
-    SourceTVmaze: "",
-    SourceMAL: "",
-  },
-  ExternalIDCandidates: {
-    TMDB: [],
-    IMDB: [],
-    TMDBAutoSelected: false,
-    IMDBAutoSelected: false,
-  },
-  ExternalIDInfo: [],
-  ExternalPreview: [],
-  Bluray: undefined,
-  TrackerData: [],
-  TrackerRuleFailures: {},
-};
-
-const emptyTrackerDryRun: TrackerDryRunPreview = {
-  SourcePath: "",
-  Trackers: [],
-};
-
-const cloneQuestionnaireAnswers = (input: Record<string, Record<string, string>>) =>
-  Object.fromEntries(
-    Object.entries(input).map(([tracker, values]) => [
-      tracker,
-      Object.fromEntries(
-        Object.entries(values || {}).map(([key, value]) => [key, String(value ?? "")]),
-      ),
-    ]),
-  );
-
-const buildQuestionnaireAnswerDefaults = (
-  questionnaire: TrackerQuestionnaire | null | undefined,
-  existing: Record<string, string> | undefined,
-) => {
-  const next: Record<string, string> = { ...(existing || {}) };
-  (questionnaire?.Fields || []).forEach((field) => {
-    if (next[field.Key] === undefined) {
-      next[field.Key] = field.Value || "";
-    }
-  });
-  return next;
-};
-
-const splitTrackerLabel = (value: string) =>
-  value
-    .split(",")
-    .map((entry) => entry.toLowerCase().trim())
-    .filter((entry) => entry.length > 0);
-
-/**
- * Returns every normalized tracker label represented by a duplicate-check row.
- * Grouped rule rows use comma-separated tracker labels, while ordinary rows use
- * a single tracker name; callers choose whether the row is a rule skip, generic
- * skip, dupe hit, or failure before applying the labels.
- */
-export const ruleBlockingTrackerLabels = (result: Pick<DupeCheckResult, "Tracker">) => {
-  const next = new Set<string>();
-  const normalized = result.Tracker.toLowerCase().trim();
-  const splitLabels = splitTrackerLabel(result.Tracker);
-
-  if (normalized) {
-    next.add(normalized);
-  }
-  splitLabels.forEach((tracker) => next.add(tracker));
-  return next;
-};
-
-const isFinishedDupeTrackerStatus = (status: string) => {
-  switch (status.toLowerCase().trim()) {
-    case "complete":
-    case "completed":
-    case "skipped":
-    case "failed":
-    case "canceled":
-      return true;
-    default:
-      return false;
-  }
-};
-
-/**
- * Converts a finished per-tracker job state into the same result shape used by
- * grouped summaries. Queued/running states without a concrete result are ignored
- * so upload eligibility is derived only from completed tracker outcomes.
- */
-const dupeResultFromTrackerState = (
-  state: DupeCheckSnapshot["trackers"][number],
-): DupeCheckResult | null => {
-  const resultTracker = String(state.result?.Tracker || "").trim();
-  const status = String(state.result?.Status || state.status || "").trim();
-  if (!resultTracker && !isFinishedDupeTrackerStatus(status)) return null;
-  const tracker = String(resultTracker || state.tracker || "").trim();
-  if (!tracker) return null;
-  return {
-    ...state.result,
-    Tracker: tracker,
-    Status: status,
-  };
-};
-
-/** Returns per-tracker dupe results from a snapshot, excluding unfinished placeholders. */
-const dupeResultsFromSnapshot = (snapshot: DupeCheckSnapshot | null) =>
-  (snapshot?.trackers || [])
-    .map(dupeResultFromTrackerState)
-    .filter((result): result is DupeCheckResult => Boolean(result));
-
-/** Maps backend metadata-cache misses to the same actionable dupe-check guidance. */
-const dupeCheckErrorMessage = (message: string) =>
-  message.includes("dupe check requires metadata preview")
-    ? "Fetch metadata first to cache a preview before checking dupes."
-    : message;
-
-const emptyDescriptionBuilder: DescriptionBuilderPreview = {
-  SourcePath: "",
-  Groups: [],
-};
-
-/**
- * Returns true when every available release tracker has an explicit false selection.
- *
- * Missing tracker keys are treated as uninitialized state, not user deselection.
- */
-export const hasExplicitEmptyReleaseTrackerSelection = (
-  trackerUploadItems: Array<{ name: string }>,
-  releasePageTrackerSelection: Record<string, boolean>,
-) => {
-  if (trackerUploadItems.length === 0) {
-    return false;
-  }
-  return trackerUploadItems.every(
-    (item) =>
-      Object.prototype.hasOwnProperty.call(releasePageTrackerSelection, item.name) &&
-      !releasePageTrackerSelection[item.name],
-  );
-};
-
-const hasOwnSelection = (value: Record<string, boolean>, key: string) =>
-  Object.prototype.hasOwnProperty.call(value, key);
-
-/**
- * Normalizes source paths for lightweight context comparisons.
- *
- * This keeps host path identity checks independent of slash direction and
- * trailing separators without replacing the runtime-aware same-path helper.
- */
-const normalizePathContext = (value: string, caseInsensitive: boolean) => {
-  let normalized = value.trim().replace(/\\/g, "/").replace(/\/+$/, "");
-  if (caseInsensitive) {
-    normalized = normalized.toLowerCase();
-  }
-  return normalized;
-};
-
-const normalizeBdmvPathContext = (value: string, caseInsensitive: boolean) =>
-  normalizePathContext(value, caseInsensitive).replace(/(^|\/)bdmv(?=\/|$)/gi, "$1BDMV");
-
-/**
- * Returns true when two source paths refer to the same eligibility context.
- *
- * A selected Blu-ray folder may be represented by either the release root or
- * its BDMV child folder; both must share dupe/rule tracker eligibility.
- */
-const isSourcePathContextMatch = (left: string, right: string, caseInsensitive: boolean) => {
-  if (sameSourcePath(left, right, caseInsensitive)) {
-    return true;
-  }
-  const normalizedLeft = normalizeBdmvPathContext(left, caseInsensitive);
-  const normalizedRight = normalizeBdmvPathContext(right, caseInsensitive);
-  if (!normalizedLeft || !normalizedRight) {
-    return false;
-  }
-  return (
-    normalizedLeft === `${normalizedRight}/BDMV` || normalizedRight === `${normalizedLeft}/BDMV`
-  );
-};
-
-const upsertBuilderGroup = (
-  preview: DescriptionBuilderPreview,
-  nextGroup: DescriptionBuilderPreview["Groups"][number],
-): DescriptionBuilderPreview => {
-  const nextGroups = [...(preview.Groups || [])];
-  const existingIndex = nextGroups.findIndex((group) => group.GroupKey === nextGroup.GroupKey);
-  if (existingIndex >= 0) {
-    nextGroups[existingIndex] = nextGroup;
-  } else {
-    nextGroups.push(nextGroup);
-  }
-  return {
-    ...preview,
-    Groups: nextGroups,
-  };
-};
-
-const bdinfoProgressEvent = "bdinfo:progress";
-const metadataProgressEvent = "metadata:progress";
-const dupeCheckEventPrefix = "dupe:job:";
-const trackerUploadEventPrefix = "upload:job:";
-const trackerUploadProgressEvent = "upload:progress";
-const runLogLevels = ["error", "warn", "info", "debug", "trace"] as const;
-
-type SourcePathSelection = {
-  path: string;
-  mode: SourcePathMode;
-  waitsForPlaylistSelection: boolean;
-};
-
-const progressUpdatePrefixes = new Set([
-  "scanning",
-  "initialize",
-  "playlist",
-  "clipinfo",
-  "stream",
-]);
-
-const progressLineKey = (line: string): string | null => {
-  const match = /^([A-Za-z_]+):\s+/.exec(line);
-  if (!match) {
-    return null;
-  }
-  const key = match[1].toLowerCase();
-  return progressUpdatePrefixes.has(key) ? key : null;
-};
-
-const appendBoundedProgressLine = (lines: string[], line: string) => {
-  if (lines.length >= 300) {
-    return [...lines.slice(-299), line];
-  }
-  return [...lines, line];
-};
-
-const upsertProgressLine = (lines: string[], line: string) => {
-  const key = progressLineKey(line);
-  if (!key) {
-    return appendBoundedProgressLine(lines, line);
-  }
-
-  const existingIndex = lines.findIndex((existing) => progressLineKey(existing) === key);
-  if (existingIndex < 0) {
-    return appendBoundedProgressLine(lines, line);
-  }
-
-  if (lines[existingIndex] === line) {
-    return lines;
-  }
-
-  const next = [...lines];
-  next[existingIndex] = line;
-  return next;
-};
-
-/** Returns whether a background job status should keep progress recovery active. */
-const isRunningJobStatus = (status: string) => {
-  const normalized = normalizeJobStatus(status);
-  return normalized === "queued" || normalized === "running";
-};
-
-declare global {
-  var go:
-    | {
-        guiapp?: {
-          App?: {
-            BrowsePath: () => Promise<string>;
-            BrowseFile: () => Promise<string>;
-            BrowseFiles: () => Promise<string[]>;
-            BrowseImageFiles: () => Promise<string[]>;
-            BrowseFolder: () => Promise<string>;
-            BrowseDirectory: (
-              path: string,
-              mode: "file" | "folder",
-            ) => Promise<BrowseDirectoryResponse>;
-            OpenExternalURL?: (url: string) => Promise<void>;
-            DetectDiscType: (path: string) => Promise<string>;
-            FetchMetadata: (
-              path: string,
-              sourceLookupURL: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-            ) => Promise<MetadataPreview>;
-            ResetMetadata: (
-              path: string,
-              sourceLookupURL: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-            ) => Promise<MetadataPreview>;
-            SelectBlurayCandidate: (path: string, releaseID: string) => Promise<MetadataPreview>;
-            FetchDescriptionBuilder: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-              ignoreDupesFor: string[],
-            ) => Promise<DescriptionBuilderPreview>;
-            FetchPreparation: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-              ignoreDupesFor: string[],
-            ) => Promise<PreparationPreview>;
-            FetchTrackerDryRun: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-              ignoreDupesFor: string[],
-              questionnaireAnswers: Record<string, Record<string, string>>,
-              descriptionGroups: DescriptionBuilderPreview["Groups"],
-              debug: boolean,
-              noSeed: boolean,
-              runLogLevel: string,
-            ) => Promise<TrackerDryRunPreview>;
-            CheckDupes: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-            ) => Promise<DupeCheckSummary>;
-            StartDupeCheck: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-            ) => Promise<string>;
-            CancelDupeCheck: (jobID: string) => Promise<void>;
-            GetDupeCheckSnapshot: (jobID: string) => Promise<DupeCheckSnapshot>;
-            FetchScreenshotPlan: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<ScreenshotPlan>;
-            GenerateScreenshots: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              selections: ScreenshotSelection[],
-              purpose: ScreenshotPurpose,
-            ) => Promise<ScreenshotResult>;
-            PreviewScreenshotFrame: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              timestampSeconds: number,
-            ) => Promise<string>;
-            DeleteScreenshot: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              imagePath: string,
-            ) => Promise<void>;
-            SaveFinalScreenshotSelections: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              images: ScreenshotImage[],
-            ) => Promise<void>;
-            ImportMenuImages: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              paths: string[],
-            ) => Promise<void>;
-            /** Starts background capture from prepared metadata and resolves to an opaque job ID. */
-            StartDVDMenuCapture: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<string>;
-            /** Returns the latest state for a background DVD menu capture job. */
-            GetDVDMenuCaptureSnapshot: (jobID: string) => Promise<DVDMenuCaptureSnapshot>;
-            /** Requests asynchronous cancellation of a background DVD menu capture job. */
-            CancelDVDMenuCapture: (jobID: string) => Promise<void>;
-            /** Lists persisted manual and automatic menu images for a prepared source path. */
-            ListDVDMenuScreenshots: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<ScreenshotImage[]>;
-            /** Removes one managed menu image and its local records. */
-            DeleteDVDMenuScreenshot: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              imagePath: string,
-            ) => Promise<void>;
-            ReadScreenshotImage: (path: string) => Promise<string>;
-            ListUploadCandidates: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<ScreenshotImage[]>;
-            ListUploadedImages: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<UploadedImageLink[]>;
-            UploadImages: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-              host: string,
-              images: ScreenshotImage[],
-            ) => Promise<UploadImagesResult>;
-            DeleteUploadedImage: (path: string, imagePath: string, host: string) => Promise<void>;
-            RenderDescription: (raw: string) => Promise<string>;
-            SaveDescriptionOverride: (
-              path: string,
-              groupKey: string,
-              raw: string,
-              trackers: string[],
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-            ) => Promise<DescriptionBuilderPreview["Groups"][number]>;
-            DiscoverPlaylists: (path: string) => Promise<any[]>;
-            SavePlaylistSelection: (
-              path: string,
-              playlists: string[],
-              useAll: boolean,
-            ) => Promise<void>;
-            LoadPlaylistSelection: (path: string) => Promise<any>;
-            GetConfig: () => Promise<string>;
-            GetDefaultConfig: () => Promise<string>;
-            GetWebAuthStatus: () => Promise<WebAuthStatus>;
-            CreateWebAuth: (username: string, password: string) => Promise<WebAuthStatus>;
-            SaveConfig: (payload: string) => Promise<void>;
-            ExportConfig: () => Promise<string>;
-            ImportConfig: () => Promise<{ message: string; warnings: string[] }>;
-            GetLogPath: () => Promise<string>;
-            GetRecentLogs: (limit: number) => Promise<any[]>;
-            StartLogStream: () => Promise<string>;
-            StopLogStream: (streamID: string) => Promise<void>;
-            GetLogExclusions: () => Promise<string[]>;
-            UpdateLogExclusions: (patterns: string[]) => Promise<void>;
-            ListKnownTrackers: () => Promise<string[]>;
-            ListTrackerAuthCapabilities?: () => Promise<TrackerAuthCapability[]>;
-            GetTrackerAuthStatus?: (tracker: string) => Promise<TrackerAuthStatus>;
-            ImportTrackerAuthCookies?: (tracker: string) => Promise<TrackerAuthStatus>;
-            ImportTrackerAuthCookieContent?: (
-              tracker: string,
-              fileName: string,
-              content: string,
-            ) => Promise<TrackerAuthStatus>;
-            TestTrackerAuth?: (tracker: string) => Promise<TrackerAuthStatus>;
-            LoginTrackerAuth?: (
-              tracker: string,
-              req: TrackerAuthLoginRequest,
-            ) => Promise<TrackerAuthStatus>;
-            SubmitTrackerAuth2FA?: (
-              challengeID: string,
-              code: string,
-            ) => Promise<TrackerAuthStatus>;
-            DeleteTrackerAuth?: (tracker: string) => Promise<TrackerAuthStatus>;
-            GetImageHostPolicyMetadata: () => Promise<ImageHostPolicyMetadata>;
-            ListHistory: () => Promise<HistoryEntry[]>;
-            GetHistoryOverview: (sourcePath: string) => Promise<HistoryOverview>;
-            DeleteHistoryRelease: (sourcePath: string) => Promise<void>;
-            StartTrackerUpload: (
-              path: string,
-              overrides: ExternalIDOverrides,
-              nameOverrides: ReleaseNameOverrides,
-              trackers: string[],
-              ignoreDupesFor: string[],
-              questionnaireAnswers: Record<string, Record<string, string>>,
-              descriptionGroups: DescriptionBuilderPreview["Groups"],
-              debug: boolean,
-              noSeed: boolean,
-              runLogLevel: string,
-            ) => Promise<string>;
-            CancelTrackerUpload: (jobID: string) => Promise<void>;
-            RetryFailedTrackerUpload: (jobID: string) => Promise<string>;
-            GetTrackerUploadSnapshot: (jobID: string) => Promise<TrackerUploadSnapshot>;
-            GetTrackerIcon?: (domain: string, customURL: string) => Promise<string>;
-          };
-        };
-      }
-    | undefined;
-}
-
-const parseIDInput = (provider: string, value: string) => {
-  const trimmed = value.trim();
-  if (!trimmed) return 0;
-  let normalized = trimmed;
-  if (provider === "imdb" && /^tt/i.test(trimmed)) {
-    normalized = trimmed.slice(2);
-  }
-  if (!/^\d+$/.test(normalized)) return null;
-  return Number(normalized);
-};
-
-const providerOrder = ["tmdb", "imdb", "tvdb", "tvmaze", "mal"] as const;
-
-const filterAndOrderExternalIDs = (info: ExternalIDInfo[]) => {
-  const orderIndex = new Map<string, number>(
-    providerOrder.map((provider, index) => [provider, index]),
-  );
-
-  return [...info].sort((left, right) => {
-    const leftIndex = orderIndex.get(left.Provider) ?? providerOrder.length;
-    const rightIndex = orderIndex.get(right.Provider) ?? providerOrder.length;
-    if (leftIndex !== rightIndex) return leftIndex - rightIndex;
-    return left.Provider.localeCompare(right.Provider);
-  });
-};
-
-const formatNumber = (value: number) => (value ? value.toString() : "");
-
-const buildIDEditState = (ids: ExternalIDs) => ({
-  tmdb: formatNumber(ids.TMDBID),
-  imdb: formatNumber(ids.IMDBID),
-  tvdb: formatNumber(ids.TVDBID),
-  tvmaze: formatNumber(ids.TVmazeID),
-  mal: formatNumber(ids.MALID),
-});
-
-type IDProviderKey = keyof ReturnType<typeof buildIDEditState>;
-
-const buildIDTouchedState = (): Record<IDProviderKey, boolean> => ({
-  tmdb: false,
-  imdb: false,
-  tvdb: false,
-  tvmaze: false,
-  mal: false,
-});
-
-const buildReleaseEditState = (overrides?: ReleaseNameOverrides): ReleaseNameEditState => ({
-  category: overrides?.Category ?? "",
-  type: overrides?.Type ?? "",
-  source: overrides?.Source ?? "",
-  resolution: overrides?.Resolution ?? "",
-  tag: overrides?.Tag ?? "",
-  service: overrides?.Service ?? "",
-  edition: overrides?.Edition ?? "",
-  season: overrides?.Season ?? "",
-  episode: overrides?.Episode ?? "",
-  episodeTitle: overrides?.EpisodeTitle ?? "",
-  manualYear: overrides?.ManualYear ? overrides.ManualYear.toString() : "",
-  manualDate: overrides?.ManualDate ?? "",
-  useSeasonEpisode: Boolean(overrides?.UseSeasonEpisode),
-  noSeason: Boolean(overrides?.NoSeason),
-  noYear: Boolean(overrides?.NoYear),
-  noAKA: Boolean(overrides?.NoAKA),
-  noTag: Boolean(overrides?.NoTag),
-  noEdition: Boolean(overrides?.NoEdition),
-  noDub: Boolean(overrides?.NoDub),
-  noDual: Boolean(overrides?.NoDual),
-  dualAudio: Boolean(overrides?.DualAudio),
-  region: overrides?.Region ?? "",
-});
-
-const buildReleaseTouchedState = (overrides?: ReleaseNameOverrides): ReleaseNameTouchedState => ({
-  category: overrides?.Category !== undefined && overrides?.Category !== null,
-  type: overrides?.Type !== undefined && overrides?.Type !== null,
-  source: overrides?.Source !== undefined && overrides?.Source !== null,
-  resolution: overrides?.Resolution !== undefined && overrides?.Resolution !== null,
-  tag: overrides?.Tag !== undefined && overrides?.Tag !== null,
-  service: overrides?.Service !== undefined && overrides?.Service !== null,
-  edition: overrides?.Edition !== undefined && overrides?.Edition !== null,
-  season: overrides?.Season !== undefined && overrides?.Season !== null,
-  episode: overrides?.Episode !== undefined && overrides?.Episode !== null,
-  episodeTitle: overrides?.EpisodeTitle !== undefined && overrides?.EpisodeTitle !== null,
-  manualYear: overrides?.ManualYear !== undefined && overrides?.ManualYear !== null,
-  manualDate: overrides?.ManualDate !== undefined && overrides?.ManualDate !== null,
-  useSeasonEpisode:
-    overrides?.UseSeasonEpisode !== undefined && overrides?.UseSeasonEpisode !== null,
-  noSeason: overrides?.NoSeason !== undefined && overrides?.NoSeason !== null,
-  noYear: overrides?.NoYear !== undefined && overrides?.NoYear !== null,
-  noAKA: overrides?.NoAKA !== undefined && overrides?.NoAKA !== null,
-  noTag: overrides?.NoTag !== undefined && overrides?.NoTag !== null,
-  noEdition: overrides?.NoEdition !== undefined && overrides?.NoEdition !== null,
-  noDub: overrides?.NoDub !== undefined && overrides?.NoDub !== null,
-  noDual: overrides?.NoDual !== undefined && overrides?.NoDual !== null,
-  dualAudio: overrides?.DualAudio !== undefined && overrides?.DualAudio !== null,
-  region: overrides?.Region !== undefined && overrides?.Region !== null,
-});
-
-const normalizeTag = (value: string) => {
-  const trimmed = value.trim();
-  if (!trimmed) return "";
-  if (trimmed.startsWith("-")) return trimmed;
-  return `-${trimmed}`;
-};
-
-const isValidManualDate = (value: string) => {
-  if (!value.trim()) return true;
-  return /^\d{4}-\d{2}-\d{2}$/.test(value.trim());
-};
-
-type ThemeMode = "light" | "dark" | "auto";
-
-const emptyWebAuthStatus: WebAuthStatus = {
-  path: "",
-  exists: false,
-  usable: false,
-  canCreate: false,
-  username: "",
-  allowUnencryptedExport: false,
-  browseRoot: "",
-  allowUnrestrictedBrowse: false,
-  encryptionEnabled: false,
-  message: "",
-};
-
-export default function App() {
-  const browserMode = isBrowserMode();
-  const browserNativeBrowseAvailable = useSyncExternalStore(
-    subscribeBrowserNativeBrowseAvailability,
-    isBrowserNativeBrowseAvailable,
-    () => true,
-  );
-  const [path, setPath] = useState("");
-  const [sourcePathHistory, setSourcePathHistory] = useState<SourcePathHistoryEntry[]>(() => {
-    try {
-      return normalizeSourcePathHistory(
-        JSON.parse(localStorage.getItem(sourcePathHistoryStorageKey) || "[]"),
-        defaultInputHistoryLimit,
-        isRuntimePathCaseInsensitive(),
-      );
-    } catch {
-      return [];
-    }
-  });
-  const [sourcePathMode, setSourcePathMode] = useState<SourcePathMode | undefined>();
-  const [currentDiscType, setCurrentDiscType] = useState("");
-  const [imageAssetsRevision, setImageAssetsRevision] = useState(0);
-  const [sourceLookupURL, setSourceLookupURL] = useState("");
-  const [loading, setLoading] = useState(false);
-  const [metadataResetting, setMetadataResetting] = useState(false);
-  const [error, setError] = useState("");
-  const [preview, setPreview] = useState<MetadataPreview>(emptyPreview);
-  const [idEdits, setIdEdits] = useState(() => buildIDEditState(emptyPreview.ExternalIDs));
-  const [idTouched, setIdTouched] = useState<Record<IDProviderKey, boolean>>(() =>
-    buildIDTouchedState(),
-  );
-  const [releaseEdits, setReleaseEdits] = useState(() =>
-    buildReleaseEditState(emptyPreview.ReleaseNameOverrides),
-  );
-  const [releaseTouched, setReleaseTouched] = useState(() =>
-    buildReleaseTouchedState(emptyPreview.ReleaseNameOverrides),
-  );
-  const [showExternalIDInputUI, setShowExternalIDInputUI] = useState(true);
-  const [selectedProvider, setSelectedProvider] = useState<string>("");
-  const [activeTab, setActiveTab] = useState("input");
-  const [theme, setTheme] = useState<ThemeMode>("auto");
-  const [renderedDescriptions, setRenderedDescriptions] = useState<Record<string, boolean>>({});
-  const [bluraySelecting, setBluraySelecting] = useState(false);
-  const [bluraySelectionError, setBluraySelectionError] = useState("");
-  const [lightboxImage, setLightboxImage] = useState<string>("");
-  const [lightboxAlt, setLightboxAlt] = useState<string>("");
-  const [lightboxFit, setLightboxFit] = useState<boolean>(true);
-  const [showPlaylistSelection, setShowPlaylistSelection] = useState(false);
-  const [playlistSelectionPath, setPlaylistSelectionPath] = useState("");
-  const [playlistAutoPreparing, setPlaylistAutoPreparing] = useState(false);
-  const [playlistPreparationError, setPlaylistPreparationError] = useState("");
-  const [playlistPreparationTrackerSnapshot, setPlaylistPreparationTrackerSnapshot] = useState<{
-    selectedTrackers: string[];
-    emptySelection: boolean;
-  } | null>(null);
-  const [bdinfoProgressLines, setBdinfoProgressLines] = useState<string[]>([]);
-  const bdinfoProgressActiveRef = useRef(false);
-  const [metadataProgressActive, setMetadataProgressActive] = useState(false);
-  const [metadataProgressUpdates, setMetadataProgressUpdates] = useState<MetadataProgressUpdate[]>(
-    [],
-  );
-  // Mirrors metadata progress state synchronously so events emitted during the
-  // same tick as a fetch/reset request are not dropped by a stale React closure.
-  const metadataProgressActiveRef = useRef(false);
-  const metadataProgressTargetRef = useRef("");
-  const discTypeRequestTokenRef = useRef(0);
-  const [dupeSummary, setDupeSummary] = useState<DupeCheckSummary>(emptyDupeSummary);
-  const [dupeLoading, setDupeLoading] = useState(false);
-  const [dupeError, setDupeError] = useState("");
-  const [dupeChecked, setDupeChecked] = useState(false);
-  const [dupeCheckJobID, setDupeCheckJobID] = useState("");
-  const [dupeCheckSnapshot, setDupeCheckSnapshot] = useState<DupeCheckSnapshot | null>(null);
-  const [dupeIgnore, setDupeIgnore] = useState<Record<string, boolean>>({});
-  const [dupeTrackerFlags, setDupeTrackerFlags] = useState<Record<string, boolean>>({});
-  const [builderPreview, setBuilderPreview] =
-    useState<DescriptionBuilderPreview>(emptyDescriptionBuilder);
-  const [builderRawByGroup, setBuilderRawByGroup] = useState<Record<string, string>>({});
-  const [builderRenderedByGroup, setBuilderRenderedByGroup] = useState<Record<string, string>>({});
-  const [builderExpandedGroups, setBuilderExpandedGroups] = useState<Record<string, boolean>>({});
-  const [builderLoading, setBuilderLoading] = useState(false);
-  const [builderError, setBuilderError] = useState("");
-  const [builderDirtyByGroup, setBuilderDirtyByGroup] = useState<Record<string, boolean>>({});
-  const [builderRenderLoading, setBuilderRenderLoading] = useState(false);
-  const [builderSaved, setBuilderSaved] = useState("");
-  const [builderSaving, setBuilderSaving] = useState(false);
-  const [builderRefreshing, setBuilderRefreshing] = useState(false);
-  const [builderProgressMessage, setBuilderProgressMessage] = useState("");
-  const builderProgressTimers = useRef<number[]>([]);
-  const [builderAutoRequestKey, setBuilderAutoRequestKey] = useState("");
-  const [uploadToggles, setUploadToggles] = useState<Record<string, boolean>>({});
-  /**
-   * Tracks upload toggles disabled by dupe hits so a later Ignore override can
-   * restore only automatic disables, not user-disabled upload targets.
-   */
-  const autoDisabledUploadTrackersRef = useRef<Set<string>>(new Set());
-  const [uploadSkipClientInjection, setUploadSkipClientInjection] = useState(false);
-  const [trackerUploadRunning, setTrackerUploadRunning] = useState(false);
-  const [trackerUploadError, setTrackerUploadError] = useState("");
-  const [trackerUploadJobID, setTrackerUploadJobID] = useState("");
-  const [trackerUploadSnapshot, setTrackerUploadSnapshot] = useState<TrackerUploadSnapshot | null>(
-    null,
-  );
-  const [trackerDryRunLoading, setTrackerDryRunLoading] = useState(false);
-  const [trackerDryRunError, setTrackerDryRunError] = useState("");
-  const [trackerDryRunPreview, setTrackerDryRunPreview] =
-    useState<TrackerDryRunPreview>(emptyTrackerDryRun);
-  const [trackerDryRunProgress, setTrackerDryRunProgress] = useState<UploadProgressUpdate | null>(
-    null,
-  );
-  const [trackerQuestionnaireAnswers, setTrackerQuestionnaireAnswers] = useState<
-    Record<string, Record<string, string>>
-  >({});
-  const [releasePageTrackerSelection, setReleasePageTrackerSelection] = useState<
-    Record<string, boolean>
-  >({});
-  const [runDebug, setRunDebug] = useState(false);
-  const [runLogLevel, setRunLogLevel] = useState("info");
-  const [runLogLevelTouched, setRunLogLevelTouched] = useState(false);
-  const [liveCaptureLoading, setLiveCaptureLoading] = useState(false);
-  const [finalDragIndex, setFinalDragIndex] = useState<number | null>(null);
-  const [settingsExporting, setSettingsExporting] = useState(false);
-  const [settingsImporting, setSettingsImporting] = useState(false);
-  const [importConfirmOpen, setImportConfirmOpen] = useState(false);
-  const [configOpStatus, setConfigOpStatus] = useState<{
-    type: "success" | "error" | "warning";
-    title: string;
-    message: string;
-    warnings?: string[];
-  } | null>(null);
-  const [webAuthStatus, setWebAuthStatus] = useState<WebAuthStatus | null>(null);
-  const [webAuthLoading, setWebAuthLoading] = useState(false);
-  const [webAuthCreating, setWebAuthCreating] = useState(false);
-  const [webAuthUsername, setWebAuthUsername] = useState("");
-  const [webAuthPassword, setWebAuthPassword] = useState("");
-  const [webAuthConfirm, setWebAuthConfirm] = useState("");
-  const [webAuthError, setWebAuthError] = useState("");
-  const [applicationInfo, setApplicationInfo] = useState<ApplicationInfo | null>(null);
-  const configOpTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const sourcePathDropHandlerRef = useRef<(paths: string[]) => void>(() => undefined);
-  const [hostBrowserMode, setHostBrowserMode] = useState<"file" | "folder" | null>(null);
-  const [hostBrowser, setHostBrowser] = useState<BrowseDirectoryResponse | null>(null);
-  const [hostBrowserLoading, setHostBrowserLoading] = useState(false);
-  const [hostBrowserError, setHostBrowserError] = useState("");
-  const [hostBrowserSearch, setHostBrowserSearch] = useState("");
-  const [debouncedHostBrowserSearch, setDebouncedHostBrowserSearch] = useState("");
-  const hostBrowserEntryRefs = useRef<Array<HTMLDivElement | null>>([]);
-
-  const builderDirty = useMemo(
-    () => Object.values(builderDirtyByGroup).some(Boolean),
-    [builderDirtyByGroup],
-  );
-  const builderReady = useMemo(() => {
-    const normalizedPath = path.trim();
-    if (!normalizedPath) {
-      return false;
-    }
-    return builderPreview.SourcePath === normalizedPath && builderPreview.Groups !== undefined;
-  }, [builderPreview.SourcePath, builderPreview.Groups, path]);
-
-  const {
-    configData,
-    settingsLoading,
-    settingsDirty,
-    settingsSaved,
-    settingsError,
-    settingsSection,
-    settingsSections,
-    showAdvancedToggle,
-    advancedOpen,
-    setSettingsSection,
-    setSettingsAdvanced,
-    loadSettings,
-    handleSaveSettings,
-    renderImageHostingSection,
-    renderTrackerSection,
-    renderTorrentClientsSection,
-    renderField,
-    sectionFieldMeta,
-    updateConfigValue,
-    updateScreenshotConfigValue,
-    configuredImageHosts,
-    screenshotConfig,
-    buildSavePayload,
-    clearSettingsStatus,
-    markSettingsSaved,
-    resolveImageHostLabel,
-    trackerSelectionNames,
-  } = useSettingsState({ activeTab });
-
-  const inputHistoryLimit = useMemo(() => {
-    const mainSettings = ((configData as ConfigMap | null)?.MainSettings ??
-      null) as ConfigMap | null;
-    return resolveInputHistoryLimit(mainSettings?.InputHistoryLimit);
-  }, [configData]);
-  const useFavicons = useMemo(() => {
-    const mainSettings = ((configData as ConfigMap | null)?.MainSettings ??
-      null) as ConfigMap | null;
-    return typeof mainSettings?.UseFavicons === "boolean" ? mainSettings.UseFavicons : true;
-  }, [configData]);
-  const faviconOnly = useMemo(() => {
-    const mainSettings = ((configData as ConfigMap | null)?.MainSettings ??
-      null) as ConfigMap | null;
-    return typeof mainSettings?.FaviconOnly === "boolean" ? mainSettings.FaviconOnly : false;
-  }, [configData]);
-  const maxMenuItems = useMemo(() => {
-    const value = screenshotConfig?.MaxMenuItems;
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 6;
-  }, [screenshotConfig]);
-
-  const persistSourcePathHistory = useCallback((entries: SourcePathHistoryEntry[]) => {
-    try {
-      if (entries.length === 0) {
-        localStorage.removeItem(sourcePathHistoryStorageKey);
-        return;
-      }
-      localStorage.setItem(sourcePathHistoryStorageKey, JSON.stringify(entries));
-    } catch {
-      // Storage may be unavailable in locked-down browser sessions.
-    }
-  }, []);
-
-  const rememberSourcePath = useCallback(
-    (value: string, mode?: SourcePathMode) => {
-      setSourcePathHistory((prev) => {
-        const next = addSourcePathHistoryEntry(
-          prev,
-          value,
-          mode ?? inferSourcePathMode(value),
-          inputHistoryLimit,
-          isRuntimePathCaseInsensitive(),
-        );
-        persistSourcePathHistory(next);
-        return next;
-      });
-    },
-    [inputHistoryLimit, persistSourcePathHistory],
-  );
-
-  const handleSourcePathChange = useCallback((value: string) => {
-    discTypeRequestTokenRef.current += 1;
-    setPath(value);
-    setSourcePathMode(undefined);
-    setCurrentDiscType("");
-  }, []);
-
-  useEffect(() => {
-    setSourcePathHistory((prev) => {
-      const next = normalizeSourcePathHistory(
-        prev,
-        inputHistoryLimit,
-        isRuntimePathCaseInsensitive(),
-      );
-      persistSourcePathHistory(next);
-      return next;
-    });
-  }, [inputHistoryLimit, persistSourcePathHistory]);
-
-  const configuredRunLogLevel = useMemo(() => {
-    const loggingSection = ((configData as ConfigMap | null)?.Logging ?? null) as ConfigMap | null;
-    const rawLevel = String(loggingSection?.Level ?? "info")
-      .toLowerCase()
-      .trim();
-    return runLogLevels.includes(rawLevel as (typeof runLogLevels)[number]) ? rawLevel : "info";
-  }, [configData]);
-
-  useEffect(() => {
-    if (runLogLevelTouched) {
-      return;
-    }
-    setRunLogLevel(runDebug ? "debug" : configuredRunLogLevel);
-  }, [configuredRunLogLevel, runDebug, runLogLevelTouched]);
-
-  // Initialize theme from localStorage and detect system preference
-  useEffect(() => {
-    const savedTheme = (localStorage.getItem("theme") as ThemeMode | null) || "auto";
-    setTheme(savedTheme);
-    applyTheme(savedTheme);
-  }, []);
-
-  // Apply theme to document
-  const applyTheme = (themeValue: ThemeMode) => {
-    const root = document.documentElement;
-    let effectiveTheme = themeValue;
-
-    if (themeValue === "auto") {
-      const prefersDark = globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
-      effectiveTheme = prefersDark ? "dark" : "light";
-    }
-
-    // Remove existing theme classes
-    root.classList.remove("light", "dark");
-    // Add the effective theme class
-    root.classList.add(effectiveTheme);
-  };
-
-  const handleThemeToggle = () => {
-    const themes: ThemeMode[] = ["auto", "light", "dark"];
-    const currentIndex = themes.indexOf(theme);
-    const nextTheme = themes[(currentIndex + 1) % themes.length];
-    setTheme(nextTheme);
-    localStorage.setItem("theme", nextTheme);
-    applyTheme(nextTheme);
-  };
-
-  useEffect(() => {
-    let cancelled = false;
-    const getter = (globalThis.go?.guiapp?.App as AppBridgeWithApplicationInfo | undefined)
-      ?.GetApplicationInfo;
-    if (!getter) {
-      return () => {
-        cancelled = true;
-      };
-    }
-
-    void getter()
-      .then((info) => {
-        if (!cancelled) {
-          setApplicationInfo(info);
-        }
-      })
-      .catch(() => undefined);
-
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-
-  useEffect(() => {
-    if (!lightboxImage) return;
-    setLightboxFit(true);
-  }, [lightboxImage]);
-
-  useEffect(() => {
-    // Keep BDInfo progress subscribed before preparation starts; the backend
-    // can emit first lines before React commits playlistAutoPreparing state.
-    const off = EventsOn(bdinfoProgressEvent, (payload: any) => {
-      if (!bdinfoProgressActiveRef.current) {
-        return;
-      }
-      const line = typeof payload === "string" ? payload : payload?.line;
-      if (typeof line !== "string") {
-        return;
-      }
-      const trimmed = line.trim();
-      if (!trimmed) {
-        return;
-      }
-      setBdinfoProgressLines((prev) => upsertProgressLine(prev, trimmed));
-    });
-
-    return () => {
-      if (typeof off === "function") {
-        off();
-      }
-    };
-  }, []);
-
-  useEffect(() => {
-    // Keep one stable metadata progress listener for the app lifetime; refs
-    // carry the active request state without resubscribing mid-fetch.
-    const off = EventsOn(metadataProgressEvent, (payload: any) => {
-      if (!metadataProgressActiveRef.current) {
-        return;
-      }
-      const eventPath = typeof payload?.path === "string" ? payload.path : "";
-      const progressTarget = metadataProgressTargetRef.current;
-      if (!isMetadataProgressPathMatch(eventPath, progressTarget)) {
-        return;
-      }
-
-      const update: MetadataProgressUpdate = {
-        path: eventPath,
-        phase: typeof payload?.phase === "string" ? payload.phase : "",
-        message: typeof payload?.message === "string" ? payload.message : "",
-        status: typeof payload?.status === "string" ? payload.status : "",
-        level: typeof payload?.level === "string" ? payload.level : "info",
-        timestamp: typeof payload?.timestamp === "string" ? payload.timestamp : "",
-      };
-
-      if (update.phase === "complete" && update.status === "completed") {
-        metadataProgressActiveRef.current = false;
-        metadataProgressTargetRef.current = "";
-        setMetadataProgressActive(false);
-        setMetadataProgressUpdates([]);
-        return;
-      }
-
-      setMetadataProgressUpdates((prev) => {
-        const next = [...prev, update];
-        return next.length > 100 ? next.slice(-100) : next;
-      });
-    });
-
-    return () => {
-      if (typeof off === "function") {
-        off();
-      }
-    };
-  }, []);
-
-  const getThemeIcon = () => {
-    if (theme === "auto") return "🔄";
-    if (theme === "light") return "☀️";
-    return "🌙";
-  };
-
-  const getThemeLabel = () => {
-    if (theme === "auto") return "Auto";
-    if (theme === "light") return "Light";
-    return "Dark";
-  };
-
-  const skipAutoTorrentEnabled = isSkipAutoTorrentEnabled(configData);
-  const hasTrackerData =
-    !skipAutoTorrentEnabled && preview.TrackerData && preview.TrackerData.length > 0;
-  const hasBlurayData = Boolean(preview.Bluray);
-  const hasPreview = Boolean(preview.SourcePath);
-
-  useEffect(() => {
-    if (skipAutoTorrentEnabled && activeTab === "tracker") {
-      setActiveTab("input");
-    }
-  }, [activeTab, skipAutoTorrentEnabled]);
-
-  const dupeEffectiveResults = useMemo(() => {
-    const trackerResults = dupeResultsFromSnapshot(dupeCheckSnapshot);
-    return trackerResults.length > 0 ? trackerResults : dupeSummary.Results || [];
-  }, [dupeCheckSnapshot, dupeSummary.Results]);
-
-  useEffect(() => {
-    setDupeIgnore((prev) => {
-      if (dupeEffectiveResults.length === 0) {
-        return prev;
-      }
-      let changed = false;
-      const next = { ...prev };
-      dupeEffectiveResults.forEach((result) => {
-        const tracker = result.Tracker;
-        if (!tracker) return;
-        if (next[tracker] === undefined) {
-          next[tracker] = false;
-          changed = true;
-        }
-      });
-      return changed ? next : prev;
-    });
-  }, [dupeEffectiveResults]);
-
-  useEffect(() => {
-    if (dupeEffectiveResults.length === 0) {
-      setDupeTrackerFlags({});
-      return;
-    }
-    const next: Record<string, boolean> = {};
-    dupeEffectiveResults.forEach((result) => {
-      const tracker = result.Tracker;
-      if (!tracker) return;
-      const ignored = dupeIgnore[tracker] ?? false;
-      const skipped = Boolean(result.Skipped);
-      next[tracker] = Boolean(result.HasDupes) && !ignored && !skipped;
-    });
-    setDupeTrackerFlags(next);
-  }, [dupeEffectiveResults, dupeIgnore]);
-
-  const dupedTrackerSet = useMemo(() => {
-    const next = new Set<string>();
-    Object.entries(dupeTrackerFlags).forEach(([tracker, hasDupes]) => {
-      if (!hasDupes) return;
-      const normalized = tracker.toLowerCase().trim();
-      if (normalized) next.add(normalized);
-      splitTrackerLabel(tracker).forEach((entry) => next.add(entry));
-    });
-    return next;
-  }, [dupeTrackerFlags]);
-
-  // Rule failures stay terminal even in debug/dry-run. Keep this set separate
-  // from generic skipped duplicate-check results so the UI can show the exact
-  // skip reason without labeling config/handler skips as rule failures.
-  const ruleSkippedTrackerSet = useMemo(() => {
-    const next = new Set<string>();
-    dupeEffectiveResults.forEach((result) => {
-      if (!result.Tracker || !isRuleSkippedResult(result)) return;
-      ruleBlockingTrackerLabels(result).forEach((tracker) => next.add(tracker));
-    });
-    return next;
-  }, [dupeEffectiveResults]);
-
-  // Any skipped duplicate-check result blocks upload eligibility; rule skips are
-  // also included here but their display copy comes from ruleSkipReasons.
-  const skippedDupeTrackerSet = useMemo(() => {
-    const next = new Set<string>();
-    dupeEffectiveResults.forEach((result) => {
-      if (!result.Tracker || !result.Skipped) return;
-      ruleBlockingTrackerLabels(result).forEach((tracker) => next.add(tracker));
-    });
-    return next;
-  }, [dupeEffectiveResults]);
-
-  const failedDupeTrackerSet = useMemo(() => {
-    const next = new Set<string>();
-    dupeEffectiveResults.forEach((result) => {
-      if (!result.Tracker) return;
-      const status = String(result.Status || "")
-        .toLowerCase()
-        .trim();
-      const hasError = Boolean(String(result.Error || "").trim());
-      if (status !== "failed" && !hasError) return;
-      const normalized = result.Tracker.toLowerCase().trim();
-      if (normalized) next.add(normalized);
-      splitTrackerLabel(result.Tracker).forEach((tracker) => next.add(tracker));
-    });
-    return next;
-  }, [dupeEffectiveResults]);
-
-  // Generic skipped reasons cover handler/config skips such as missing API keys.
-  // Rule-specific labels are derived separately to avoid misleading copy.
-  const skippedDupeReasons = useMemo(() => {
-    const next: Record<string, string> = {};
-    dupeEffectiveResults.forEach((result) => {
-      if (!result.Tracker || !result.Skipped) return;
-      const reason = dupeSkipReason(result) || "Skipped";
-      ruleBlockingTrackerLabels(result).forEach((tracker) => {
-        next[tracker] = reason;
-      });
-    });
-    return next;
-  }, [dupeEffectiveResults]);
-
-  const ruleSkipReasons = useMemo(() => {
-    const next: Record<string, string> = {};
-    dupeEffectiveResults.forEach((result) => {
-      if (!result.Tracker || !isRuleSkippedResult(result)) return;
-      const reason = dupeSkipReason(result);
-      ruleBlockingTrackerLabels(result).forEach((tracker) => {
-        next[tracker] = reason || "rule check failed";
-      });
-    });
-    return next;
-  }, [dupeEffectiveResults]);
-
-  const ignoredDupeTrackers = useMemo(() => {
-    const next = new Set<string>();
-    Object.entries(dupeIgnore).forEach(([tracker, ignored]) => {
-      if (!ignored) return;
-      const normalized = tracker.toLowerCase().trim();
-      if (normalized) next.add(normalized);
-      splitTrackerLabel(tracker).forEach((entry) => next.add(entry));
-    });
-    return Array.from(next);
-  }, [dupeIgnore]);
-
-  const trackerUploadItems = useMemo(() => {
-    if (!configData || !configData.Trackers || typeof configData.Trackers !== "object") {
-      return [];
-    }
-
-    const trackerRoot = configData.Trackers as ConfigMap;
-    const rawEntries = trackerRoot.Trackers;
-    const entriesRoot =
-      rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
-        ? (rawEntries as ConfigMap)
-        : {};
-    const entries = Object.entries(entriesRoot).filter(
-      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
-    ) as Array<[string, ConfigMap]>;
-    const visibleTrackerSet = new Set(trackerSelectionNames);
-
-    return entries
-      .filter(([name]) => visibleTrackerSet.has(name))
-      .map(([name, config]) => ({ name, config }))
-      .sort((left, right) => left.name.localeCompare(right.name));
-  }, [configData, trackerSelectionNames]);
-  const trackerIconSrcByName = useTrackerIcons(trackerUploadItems, useFavicons);
-
-  const defaultTrackerSet = useMemo(() => {
-    if (!configData || !configData.Trackers || typeof configData.Trackers !== "object") {
-      return new Set<string>();
-    }
-    const trackerRoot = configData.Trackers as ConfigMap;
-    const defaults = normalizeDefaultTrackerList(trackerRoot.DefaultTrackers);
-    return new Set(defaults.map((entry) => entry.toLowerCase()));
-  }, [configData]);
-
-  const idOverrideState = useMemo(() => {
-    const parsed = {
-      tmdb: parseIDInput("tmdb", idEdits.tmdb),
-      imdb: parseIDInput("imdb", idEdits.imdb),
-      tvdb: parseIDInput("tvdb", idEdits.tvdb),
-      tvmaze: parseIDInput("tvmaze", idEdits.tvmaze),
-      mal: parseIDInput("mal", idEdits.mal),
-    };
-
-    const invalid = Object.values(parsed).includes(null);
-    const overrides: ExternalIDOverrides = {
-      TMDBID: parsed.tmdb !== null && idTouched.tmdb ? parsed.tmdb : null,
-      IMDBID: parsed.imdb !== null && idTouched.imdb ? parsed.imdb : null,
-      TVDBID: parsed.tvdb !== null && idTouched.tvdb ? parsed.tvdb : null,
-      TVmazeID: parsed.tvmaze !== null && idTouched.tvmaze ? parsed.tvmaze : null,
-      MALID: parsed.mal !== null && idTouched.mal ? parsed.mal : null,
-    };
-    const dirty = Object.values(overrides).some((value) => value !== null);
-
-    return { overrides, dirty, invalid };
-  }, [idEdits, idTouched]);
-
-  const releaseOverrideState = useMemo(() => {
-    // Safety check: ensure state is initialized
-    if (!releaseEdits || !releaseTouched) {
-      return { overrides: {}, dirty: false, invalid: false };
-    }
-
-    const overrides: ReleaseNameOverrides = {};
-    const stored =
-      preview.ReleaseNameOverrides && typeof preview.ReleaseNameOverrides === "object"
-        ? preview.ReleaseNameOverrides
-        : {};
-    let invalid = false;
-
-    const readTrimmed = (value: string | null | undefined) => (value || "").trim();
-    const stringDirty = (
-      touched: boolean,
-      current: string | null | undefined,
-      storedValue?: string | null,
-    ) => {
-      if (!touched) return false;
-      if (storedValue === undefined || storedValue === null) return true;
-      return readTrimmed(current) !== readTrimmed(storedValue);
-    };
-    const boolDirty = (
-      touched: boolean,
-      current: boolean | null | undefined,
-      storedValue?: boolean | null,
-    ) => {
-      if (!touched) return false;
-      if (storedValue === undefined || storedValue === null) return true;
-      return Boolean(current) !== Boolean(storedValue);
-    };
-
-    if (releaseTouched.category) overrides.Category = readTrimmed(releaseEdits.category);
-    if (releaseTouched.type) overrides.Type = readTrimmed(releaseEdits.type);
-    if (releaseTouched.source) overrides.Source = readTrimmed(releaseEdits.source);
-    if (releaseTouched.resolution) overrides.Resolution = readTrimmed(releaseEdits.resolution);
-    if (releaseTouched.tag) overrides.Tag = normalizeTag(releaseEdits.tag);
-    if (releaseTouched.service) overrides.Service = readTrimmed(releaseEdits.service);
-    if (releaseTouched.edition) overrides.Edition = readTrimmed(releaseEdits.edition);
-    if (releaseTouched.season) overrides.Season = readTrimmed(releaseEdits.season);
-    if (releaseTouched.episode) overrides.Episode = readTrimmed(releaseEdits.episode);
-    if (releaseTouched.episodeTitle)
-      overrides.EpisodeTitle = readTrimmed(releaseEdits.episodeTitle);
-
-    if (releaseTouched.manualYear) {
-      const trimmed = readTrimmed(releaseEdits.manualYear);
-      if (!trimmed) {
-        overrides.ManualYear = 0;
-      } else if (!/^\d+$/.test(trimmed)) {
-        invalid = true;
-      } else {
-        overrides.ManualYear = Number(trimmed);
-      }
-    }
-
-    if (releaseTouched.manualDate) {
-      const trimmed = readTrimmed(releaseEdits.manualDate);
-      overrides.ManualDate = trimmed;
-      if (!isValidManualDate(trimmed)) {
-        invalid = true;
-      }
-    }
-
-    if (releaseTouched.useSeasonEpisode) {
-      overrides.UseSeasonEpisode = Boolean(releaseEdits.useSeasonEpisode);
-    }
-
-    if (releaseTouched.noSeason) overrides.NoSeason = releaseEdits.noSeason;
-    if (releaseTouched.noYear) overrides.NoYear = releaseEdits.noYear;
-    if (releaseTouched.noAKA) overrides.NoAKA = releaseEdits.noAKA;
-    if (releaseTouched.noTag) overrides.NoTag = releaseEdits.noTag;
-    if (releaseTouched.noEdition) overrides.NoEdition = releaseEdits.noEdition;
-    if (releaseTouched.noDub) overrides.NoDub = releaseEdits.noDub;
-    if (releaseTouched.noDual) overrides.NoDual = releaseEdits.noDual;
-    if (releaseTouched.dualAudio) overrides.DualAudio = releaseEdits.dualAudio;
-    if (releaseTouched.region) overrides.Region = readTrimmed(releaseEdits.region);
-
-    const dirty =
-      stringDirty(releaseTouched.category, releaseEdits.category, stored.Category) ||
-      stringDirty(releaseTouched.type, releaseEdits.type, stored.Type) ||
-      stringDirty(releaseTouched.source, releaseEdits.source, stored.Source) ||
-      stringDirty(releaseTouched.resolution, releaseEdits.resolution, stored.Resolution) ||
-      stringDirty(releaseTouched.tag, normalizeTag(releaseEdits.tag), stored.Tag) ||
-      stringDirty(releaseTouched.service, releaseEdits.service, stored.Service) ||
-      stringDirty(releaseTouched.edition, releaseEdits.edition, stored.Edition) ||
-      stringDirty(releaseTouched.season, releaseEdits.season, stored.Season) ||
-      stringDirty(releaseTouched.episode, releaseEdits.episode, stored.Episode) ||
-      stringDirty(releaseTouched.episodeTitle, releaseEdits.episodeTitle, stored.EpisodeTitle) ||
-      stringDirty(releaseTouched.manualDate, releaseEdits.manualDate, stored.ManualDate) ||
-      boolDirty(
-        releaseTouched.useSeasonEpisode,
-        releaseEdits.useSeasonEpisode,
-        stored.UseSeasonEpisode,
-      ) ||
-      boolDirty(releaseTouched.noSeason, releaseEdits.noSeason, stored.NoSeason) ||
-      boolDirty(releaseTouched.noYear, releaseEdits.noYear, stored.NoYear) ||
-      boolDirty(releaseTouched.noAKA, releaseEdits.noAKA, stored.NoAKA) ||
-      boolDirty(releaseTouched.noTag, releaseEdits.noTag, stored.NoTag) ||
-      boolDirty(releaseTouched.noEdition, releaseEdits.noEdition, stored.NoEdition) ||
-      boolDirty(releaseTouched.noDub, releaseEdits.noDub, stored.NoDub) ||
-      boolDirty(releaseTouched.noDual, releaseEdits.noDual, stored.NoDual) ||
-      boolDirty(releaseTouched.dualAudio, releaseEdits.dualAudio, stored.DualAudio) ||
-      stringDirty(releaseTouched.region, releaseEdits.region, stored.Region) ||
-      (() => {
-        if (!releaseTouched.manualYear) return false;
-        if (stored.ManualYear === undefined || stored.ManualYear === null) return true;
-        return readTrimmed(releaseEdits.manualYear) !== String(stored.ManualYear);
-      })();
-
-    return { overrides, dirty, invalid };
-  }, [releaseEdits, releaseTouched, preview.ReleaseNameOverrides]);
-
-  // Screenshot workflow hook (now idOverrideState/releaseOverrideState are defined)
-  const screenshots = useScreenshots({
-    path,
-    idOverrideState,
-    releaseOverrideState,
-  });
-
-  // Destructure commonly used screenshot variables
-  const {
-    livePreviewSeconds,
-    setLivePreviewSeconds,
-    livePreviewError,
-    setLivePreviewError,
-    livePreviewLoading,
-    setLivePreviewLoading,
-    livePreviewImage,
-    setLivePreviewImage,
-    livePreviewRequestId,
-    screenshotsSettingsSaving,
-    setScreenshotsSettingsSaving,
-    loadScreenshotPlan,
-    readScreenshotImage,
-    setExistingImages,
-    resetScreenshotState: resetScreenshots,
-    handleDeleteTrackerImageURL,
-  } = screenshots;
-
-  /**
-   * Resolves upload-eligible trackers for the requested source path.
-   *
-   * Dupe and rule-failure filters apply only when their snapshot source path
-   * matches the requested path context, preventing stale blocks from a previous
-   * source path from changing metadata fetch or playlist preparation payloads.
-   * Callers starting a fresh dupe check can disable dupe filters while keeping
-   * manual upload tracker toggles.
-   */
-  const resolveUploadTrackerEligibilityForPath = useCallback(
-    (sourcePath: string, options: { applyDupeFilters?: boolean } = {}) => {
-      const targetPath = sourcePath.trim();
-      const currentPath = path.trim();
-      const dupeSourcePath = String(
-        dupeSummary.SourcePath || dupeCheckSnapshot?.sourcePath || "",
-      ).trim();
-      const pathCaseInsensitive = isRuntimePathCaseInsensitive();
-      const applyDupeFilters = options.applyDupeFilters ?? true;
-      const dupeSourceMatchesTarget =
-        applyDupeFilters &&
-        targetPath !== "" &&
-        dupeSourcePath !== "" &&
-        isSourcePathContextMatch(dupeSourcePath, targetPath, pathCaseInsensitive);
-      const uploadTogglesMatchTarget =
-        targetPath === "" ||
-        currentPath === "" ||
-        isSourcePathContextMatch(currentPath, targetPath, pathCaseInsensitive);
-      const effectiveUploadToggles: Record<string, boolean> = {};
-
-      trackerUploadItems.forEach((item) => {
-        const normalized = item.name.toLowerCase().trim();
-        const ignoreAutoDisabledToggle =
-          !applyDupeFilters && autoDisabledUploadTrackersRef.current.has(normalized);
-        if (
-          uploadTogglesMatchTarget &&
-          hasOwnSelection(uploadToggles, item.name) &&
-          !ignoreAutoDisabledToggle
-        ) {
-          effectiveUploadToggles[item.name] = uploadToggles[item.name];
-          return;
-        }
-        if (hasOwnSelection(releasePageTrackerSelection, item.name)) {
-          effectiveUploadToggles[item.name] = releasePageTrackerSelection[item.name];
-          return;
-        }
-        effectiveUploadToggles[item.name] = defaultTrackerSet.has(normalized);
-      });
-
-      const emptyTrackerSet = new Set<string>();
-      const scopedDupedTrackerSet = dupeSourceMatchesTarget ? dupedTrackerSet : emptyTrackerSet;
-      const scopedSkippedDupeTrackerSet = dupeSourceMatchesTarget
-        ? skippedDupeTrackerSet
-        : emptyTrackerSet;
-      const scopedRuleSkippedTrackerSet = dupeSourceMatchesTarget
-        ? ruleSkippedTrackerSet
-        : emptyTrackerSet;
-      const scopedFailedDupeTrackerSet = dupeSourceMatchesTarget
-        ? failedDupeTrackerSet
-        : emptyTrackerSet;
-      const selectedTrackers = resolveSelectedUploadTrackers({
-        trackerUploadItems,
-        releasePageTrackerSelection,
-        uploadToggles: effectiveUploadToggles,
-        dupedTrackerSet: scopedDupedTrackerSet,
-        skippedDupeTrackerSet: scopedSkippedDupeTrackerSet,
-        ruleSkippedTrackerSet: scopedRuleSkippedTrackerSet,
-        failedDupeTrackerSet: scopedFailedDupeTrackerSet,
-      });
-
-      return {
-        selectedTrackers,
-        emptySelection:
-          hasExplicitEmptyReleaseTrackerSelection(
-            trackerUploadItems,
-            releasePageTrackerSelection,
-          ) ||
-          hasFilteredEmptyUploadTrackerSelectionState({
-            trackerUploadItems,
-            releasePageTrackerSelection,
-            uploadToggles: effectiveUploadToggles,
-            dupedTrackerSet: scopedDupedTrackerSet,
-            skippedDupeTrackerSet: scopedSkippedDupeTrackerSet,
-            ruleSkippedTrackerSet: scopedRuleSkippedTrackerSet,
-            failedDupeTrackerSet: scopedFailedDupeTrackerSet,
-          }),
-      };
-    },
-    [
-      defaultTrackerSet,
-      dupeCheckSnapshot?.sourcePath,
-      dupeSummary.SourcePath,
-      dupedTrackerSet,
-      failedDupeTrackerSet,
-      path,
-      releasePageTrackerSelection,
-      ruleSkippedTrackerSet,
-      skippedDupeTrackerSet,
-      trackerUploadItems,
-      uploadToggles,
-    ],
-  );
-
-  const selectedUploadTrackerEligibility = useMemo(
-    () => resolveUploadTrackerEligibilityForPath(path),
-    [path, resolveUploadTrackerEligibilityForPath],
-  );
-  const selectedUploadImageTrackers = selectedUploadTrackerEligibility.selectedTrackers;
-  const dupeFiltersMatchCurrentPath = useMemo(() => {
-    const currentPath = path.trim();
-    const dupeSourcePath = String(
-      dupeSummary.SourcePath || dupeCheckSnapshot?.sourcePath || "",
-    ).trim();
-    return (
-      currentPath !== "" &&
-      dupeSourcePath !== "" &&
-      isSourcePathContextMatch(dupeSourcePath, currentPath, isRuntimePathCaseInsensitive())
-    );
-  }, [dupeCheckSnapshot?.sourcePath, dupeSummary.SourcePath, path]);
-
-  // Upload images workflow hook
-  const uploadImages = useUploadImages({
-    path,
-    idOverrideState,
-    releaseOverrideState,
-    uploadCandidates: screenshots.uploadCandidates,
-    configuredImageHosts,
-    selectedTrackers: selectedUploadImageTrackers,
-  });
-  const {
-    refreshUploadedImages,
-    resetUploadState,
-    setUploadSelections,
-    setUploadHost,
-    uploadHost,
-    handleUploadImages: uploadSelectedImages,
-    handleDeleteUploadedImage: deleteUploadedImage,
-  } = uploadImages;
-
-  // Tracker image URL handling
-  const trackerImageURLs = useMemo(() => {
-    const urls = new Set<string>();
-    (preview.TrackerData || []).forEach((tracker) => {
-      (tracker.ImageURLs || []).forEach((url) => {
-        if (url) {
-          urls.add(url);
-        }
-      });
-    });
-    if (screenshots.deletedTrackerImages.length === 0) {
-      return Array.from(urls);
-    }
-    const deleted = new Set(screenshots.deletedTrackerImages);
-    return Array.from(urls).filter((url) => !deleted.has(url));
-  }, [preview.TrackerData, screenshots.deletedTrackerImages]);
-
-  const handleDeleteAllTrackerImageURLs = useCallback(async () => {
-    if (trackerImageURLs.length === 0) {
-      return;
-    }
-    if (!globalThis.confirm("Remove all tracker images from the list?")) {
-      return;
-    }
-    for (const url of trackerImageURLs) {
-      await handleDeleteTrackerImageURL(url);
-    }
-  }, [trackerImageURLs, handleDeleteTrackerImageURL]);
-
-  const uploadCandidatePaths = useMemo(() => {
-    return new Set(
-      screenshots.uploadCandidates
-        .map((item) => item.image.Path)
-        .filter((path): path is string => Boolean(path)),
-    );
-  }, [screenshots.uploadCandidates]);
-
-  const markImageAssetsChanged = useCallback(() => {
-    setImageAssetsRevision((revision) => revision + 1);
-  }, []);
-
-  const handleUploadImagesWithRevision = useCallback(
-    async (selected: ScreenshotPreviewImage[]) => {
-      await uploadSelectedImages(selected);
-      markImageAssetsChanged();
-    },
-    [markImageAssetsChanged, uploadSelectedImages],
-  );
-
-  const handleDeleteUploadedImageWithRevision = useCallback(
-    async (imagePath: string, host: string) => {
-      await deleteUploadedImage(imagePath, host);
-      markImageAssetsChanged();
-    },
-    [deleteUploadedImage, markImageAssetsChanged],
-  );
-
-  const resetScreenshotState = useCallback(() => {
-    resetScreenshots();
-    resetUploadState();
-    setUploadToggles({});
-    setFinalDragIndex(null);
-    setLiveCaptureLoading(false);
-  }, [resetScreenshots, resetUploadState]);
-
-  /**
-   * Clears release-specific workflow state after the loaded release is no longer current.
-   *
-   * Input tracker selections are intentionally preserved so the next metadata fetch keeps the
-   * user's configured/default tracker choices.
-   */
-  const resetFreshWorkflowState = useCallback(
-    (nextActiveTab = "input") => {
-      discTypeRequestTokenRef.current += 1;
-      setPath("");
-      setSourcePathMode(undefined);
-      setCurrentDiscType("");
-      setImageAssetsRevision(0);
-      setSourceLookupURL("");
-      setLoading(false);
-      setMetadataResetting(false);
-      setError("");
-      setPreview(emptyPreview);
-      setIdEdits(buildIDEditState(emptyPreview.ExternalIDs));
-      setIdTouched(buildIDTouchedState());
-      setReleaseEdits(buildReleaseEditState(emptyPreview.ReleaseNameOverrides));
-      setReleaseTouched(buildReleaseTouchedState(emptyPreview.ReleaseNameOverrides));
-      setShowExternalIDInputUI(true);
-      setSelectedProvider("");
-      setActiveTab(nextActiveTab);
-      setRenderedDescriptions({});
-      setLightboxImage("");
-      setLightboxAlt("");
-      setShowPlaylistSelection(false);
-      setPlaylistSelectionPath("");
-      setPlaylistAutoPreparing(false);
-      bdinfoProgressActiveRef.current = false;
-      setPlaylistPreparationError("");
-      setBdinfoProgressLines([]);
-      metadataProgressTargetRef.current = "";
-      metadataProgressActiveRef.current = false;
-      setMetadataProgressActive(false);
-      setMetadataProgressUpdates([]);
-      setDupeSummary(emptyDupeSummary);
-      setDupeLoading(false);
-      setDupeError("");
-      setDupeChecked(false);
-      setDupeCheckJobID("");
-      setDupeCheckSnapshot(null);
-      setDupeIgnore({});
-      setDupeTrackerFlags({});
-      autoDisabledUploadTrackersRef.current.clear();
-      setBuilderPreview(emptyDescriptionBuilder);
-      setBuilderRawByGroup({});
-      setBuilderRenderedByGroup({});
-      setBuilderExpandedGroups({});
-      setBuilderLoading(false);
-      setBuilderError("");
-      setBuilderDirtyByGroup({});
-      setBuilderRenderLoading(false);
-      setBuilderSaved("");
-      setBuilderSaving(false);
-      setBuilderRefreshing(false);
-      setBuilderAutoRequestKey("");
-      resetScreenshotState();
-      setTrackerUploadRunning(false);
-      setTrackerUploadError("");
-      setTrackerUploadJobID("");
-      setTrackerUploadSnapshot(null);
-      setTrackerDryRunLoading(false);
-      setTrackerDryRunError("");
-      setTrackerDryRunPreview(emptyTrackerDryRun);
-      setTrackerDryRunProgress(null);
-      setTrackerQuestionnaireAnswers({});
-      setRunDebug(false);
-      setRunLogLevel(configuredRunLogLevel);
-      setRunLogLevelTouched(false);
-      setLiveCaptureLoading(false);
-      setHostBrowserMode(null);
-      setHostBrowser(null);
-      setHostBrowserLoading(false);
-      setHostBrowserError("");
-    },
-    [configuredRunLogLevel, resetScreenshotState],
-  );
-
-  const handleHistoryReleaseDeleted = useCallback(
-    (deletedPath: string) => {
-      // The input path can be edited after loading history; reset based on the displayed release.
-      const loadedPath = (preview.SourcePath || path).trim();
-      if (!sameSourcePath(loadedPath, deletedPath, isRuntimePathCaseInsensitive())) {
-        return;
-      }
-      resetFreshWorkflowState("history");
-    },
-    [path, preview.SourcePath, resetFreshWorkflowState],
-  );
-
-  // Helper functions for screenshot management (not in the hook)
-  const handleDeleteExistingImage = (image: ScreenshotImage) => {
-    if (!image.Path) return;
-    const deletedPath = image.Path;
-    screenshots.setExistingImages((prev) =>
-      prev.filter((entry) => entry.image.Path !== deletedPath),
-    );
-    if (screenshots.finalImagesRef.current.length > 0) {
-      screenshots.saveFinalSelections(
-        screenshots.finalImagesRef.current.filter((entry) => entry.image.Path !== deletedPath),
-      );
-    }
-  };
-
-  const mergeFinalSelections = (
-    current: ScreenshotPreviewImage[],
-    additions: ScreenshotPreviewImage[],
-  ) => {
-    if (additions.length === 0) return current;
-    const seen = new Map<string, number>();
-    const merged = [...current];
-    merged.forEach((item, index) => {
-      if (item.image.Path) {
-        seen.set(item.image.Path, index);
-      }
-    });
-    additions.forEach((item) => {
-      const pathValue = item.image.Path;
-      if (!pathValue) return;
-      const existingIndex = seen.get(pathValue);
-      if (existingIndex === undefined) {
-        const ts = item.image.TimestampSeconds || 0;
-        if (ts > 0) {
-          const insertAt = merged.findIndex((entry) => {
-            const entryTs = entry.image.TimestampSeconds || 0;
-            return entryTs > 0 && entryTs > ts;
-          });
-          if (insertAt >= 0) {
-            merged.splice(insertAt, 0, item);
-            seen.clear();
-            merged.forEach((entry, idx) => {
-              if (entry.image.Path) {
-                seen.set(entry.image.Path, idx);
-              }
-            });
-            return;
-          }
-        }
-        seen.set(pathValue, merged.length);
-        merged.push(item);
-        return;
-      }
-      merged[existingIndex] = item;
-    });
-    return merged;
-  };
-
-  const reindexSelectionsByTimestamp = (selections: ScreenshotSelection[], targetIndex: number) => {
-    const resolveTimestamp = (entry: ScreenshotSelection) => {
-      if (Number.isFinite(entry.TimestampSeconds) && entry.TimestampSeconds > 0) {
-        return entry.TimestampSeconds;
-      }
-      if (Number.isFinite(entry.Frame) && entry.Frame > 0) {
-        return entry.Frame / previewFrameRate;
-      }
-      return 0;
-    };
-
-    const ordered = selections
-      .map((entry) => ({ entry, originalIndex: entry.Index, ts: resolveTimestamp(entry) }))
-      .sort((left, right) => {
-        if (left.ts !== right.ts) return left.ts - right.ts;
-        return left.originalIndex - right.originalIndex;
-      });
-
-    let resolvedIndex = -1;
-    const nextSelections = ordered.map((item, index) => {
-      if (item.originalIndex === targetIndex) {
-        resolvedIndex = index;
-      }
-      return item.entry;
-    });
-
-    return { selections: nextSelections, targetIndex: resolvedIndex };
-  };
-
-  const normalizeSelectionTimestamp = (entry: ScreenshotSelection) => {
-    if (Number.isFinite(entry.TimestampSeconds) && entry.TimestampSeconds > 0) {
-      return entry.TimestampSeconds;
-    }
-    if (Number.isFinite(entry.Frame) && entry.Frame > 0) {
-      return entry.Frame / previewFrameRate;
-    }
-    return 0;
-  };
-
-  const desiredScreenCount = () => {
-    if (
-      screenshotConfig &&
-      typeof screenshotConfig.Screens === "number" &&
-      screenshotConfig.Screens > 0
-    ) {
-      return screenshotConfig.Screens;
-    }
-    if (
-      screenshots.screenshotPlan &&
-      Array.isArray(screenshots.screenshotPlan.SuggestedSelections)
-    ) {
-      return screenshots.screenshotPlan.SuggestedSelections.length;
-    }
-    return 0;
-  };
-
-  const regenerateAutoSelections = (current: ScreenshotSelection[]) => {
-    const targetCount = desiredScreenCount();
-    if (targetCount <= 0) {
-      return current;
-    }
-
-    const manual = current.filter((entry) => (entry.Source || "auto").toLowerCase() !== "auto");
-    if (manual.length >= targetCount) {
-      return current.filter((entry) => (entry.Source || "auto").toLowerCase() !== "auto");
-    }
-
-    const candidates = (screenshots.screenshotPlan?.SuggestedSelections || []).filter((entry) => {
-      const source = (entry.Source || "auto").toLowerCase();
-      return source === "auto";
-    });
-
-    const tolerance = previewFrameRate > 0 ? 1 / previewFrameRate : 0;
-    const filtered = candidates.filter((entry) => {
-      const ts = normalizeSelectionTimestamp(entry);
-      return !manual.some(
-        (manualEntry) => Math.abs(normalizeSelectionTimestamp(manualEntry) - ts) <= tolerance,
-      );
-    });
-
-    const needed = Math.max(0, targetCount - manual.length);
-    const auto = filtered.slice(0, needed).map((entry) => ({
-      ...entry,
-      Source: "auto",
-    }));
-
-    return [...manual, ...auto];
-  };
-
-  const namingOverrides = useMemo(() => {
-    const stored =
-      preview.ReleaseNameOverrides && typeof preview.ReleaseNameOverrides === "object"
-        ? preview.ReleaseNameOverrides
-        : {};
-    const overrides = releaseOverrideState?.dirty
-      ? releaseOverrideState.overrides
-      : preview.ReleaseNameOverrides || {};
-    return Object.entries(overrides || {}).filter(([key, value]) => {
-      if (value === null || value === undefined) return false;
-      const storedValue = (stored as Record<string, unknown>)[key];
-      if (typeof value === "string") {
-        const current = value.trim();
-        const prev = typeof storedValue === "string" ? storedValue.trim() : "";
-        return current !== prev;
-      }
-      if (typeof value === "number") {
-        const prev = typeof storedValue === "number" ? storedValue : 0;
-        return value !== prev;
-      }
-      if (typeof value === "boolean") {
-        const prev = typeof storedValue === "boolean" ? storedValue : false;
-        return value !== prev;
-      }
-      return false;
-    });
-  }, [preview.ReleaseNameOverrides, releaseOverrideState]);
-
-  const refreshDisabled =
-    loading ||
-    !path.trim() ||
-    (!idOverrideState?.dirty && !releaseOverrideState?.dirty && !sourceLookupURL.trim()) ||
-    idOverrideState?.invalid ||
-    releaseOverrideState?.invalid;
-
-  const normalizeOverrides = (overrides: ExternalIDOverrides) => {
-    const payload: ExternalIDOverrides = {};
-    if (overrides.TMDBID !== null && overrides.TMDBID !== undefined) {
-      payload.TMDBID = overrides.TMDBID;
-    }
-    if (overrides.IMDBID !== null && overrides.IMDBID !== undefined) {
-      payload.IMDBID = overrides.IMDBID;
-    }
-    if (overrides.TVDBID !== null && overrides.TVDBID !== undefined) {
-      payload.TVDBID = overrides.TVDBID;
-    }
-    if (overrides.TVmazeID !== null && overrides.TVmazeID !== undefined) {
-      payload.TVmazeID = overrides.TVmazeID;
-    }
-    if (overrides.MALID !== null && overrides.MALID !== undefined) {
-      payload.MALID = overrides.MALID;
-    }
-    return payload;
-  };
-
-  const normalizeReleaseOverrides = (overrides: ReleaseNameOverrides) => {
-    const payload: ReleaseNameOverrides = {};
-    if (overrides.Category !== null && overrides.Category !== undefined) {
-      payload.Category = overrides.Category;
-    }
-    if (overrides.Type !== null && overrides.Type !== undefined) {
-      payload.Type = overrides.Type;
-    }
-    if (overrides.Source !== null && overrides.Source !== undefined) {
-      payload.Source = overrides.Source;
-    }
-    if (overrides.Resolution !== null && overrides.Resolution !== undefined) {
-      payload.Resolution = overrides.Resolution;
-    }
-    if (overrides.Tag !== null && overrides.Tag !== undefined) {
-      payload.Tag = overrides.Tag;
-    }
-    if (overrides.Service !== null && overrides.Service !== undefined) {
-      payload.Service = overrides.Service;
-    }
-    if (overrides.Edition !== null && overrides.Edition !== undefined) {
-      payload.Edition = overrides.Edition;
-    }
-    if (overrides.Season !== null && overrides.Season !== undefined) {
-      payload.Season = overrides.Season;
-    }
-    if (overrides.Episode !== null && overrides.Episode !== undefined) {
-      payload.Episode = overrides.Episode;
-    }
-    if (overrides.EpisodeTitle !== null && overrides.EpisodeTitle !== undefined) {
-      payload.EpisodeTitle = overrides.EpisodeTitle;
-    }
-    if (overrides.ManualYear !== null && overrides.ManualYear !== undefined) {
-      payload.ManualYear = overrides.ManualYear;
-    }
-    if (overrides.ManualDate !== null && overrides.ManualDate !== undefined) {
-      payload.ManualDate = overrides.ManualDate;
-    }
-    if (overrides.UseSeasonEpisode !== null && overrides.UseSeasonEpisode !== undefined) {
-      payload.UseSeasonEpisode = overrides.UseSeasonEpisode;
-    }
-    if (overrides.NoSeason !== null && overrides.NoSeason !== undefined) {
-      payload.NoSeason = overrides.NoSeason;
-    }
-    if (overrides.NoYear !== null && overrides.NoYear !== undefined) {
-      payload.NoYear = overrides.NoYear;
-    }
-    if (overrides.NoAKA !== null && overrides.NoAKA !== undefined) {
-      payload.NoAKA = overrides.NoAKA;
-    }
-    if (overrides.NoTag !== null && overrides.NoTag !== undefined) {
-      payload.NoTag = overrides.NoTag;
-    }
-    if (overrides.NoEdition !== null && overrides.NoEdition !== undefined) {
-      payload.NoEdition = overrides.NoEdition;
-    }
-    if (overrides.NoDub !== null && overrides.NoDub !== undefined) {
-      payload.NoDub = overrides.NoDub;
-    }
-    if (overrides.NoDual !== null && overrides.NoDual !== undefined) {
-      payload.NoDual = overrides.NoDual;
-    }
-    if (overrides.DualAudio !== null && overrides.DualAudio !== undefined) {
-      payload.DualAudio = overrides.DualAudio;
-    }
-    if (overrides.Region !== null && overrides.Region !== undefined) {
-      payload.Region = overrides.Region;
-    }
-    return payload;
-  };
-
-  const applyPreviewResult = (
-    result: MetadataPreview,
-    options: { switchToInput?: boolean; preserveIDTouches?: boolean } = {},
-  ) => {
-    const { switchToInput = true, preserveIDTouches = false } = options;
-    setPreview(result);
-    if (switchToInput) {
-      setActiveTab("input");
-    }
-    setIdEdits(buildIDEditState(result.ExternalIDs));
-    if (!preserveIDTouches) {
-      setIdTouched(buildIDTouchedState());
-    }
-    setReleaseEdits(buildReleaseEditState(result.ReleaseNameOverrides || {}));
-    setReleaseTouched(buildReleaseTouchedState(result.ReleaseNameOverrides || {}));
-    const fetchedProviders = new Set(
-      (result.ExternalPreview || [])
-        .filter(hasFetchedExternalPreviewData)
-        .map((item) => item.Provider),
-    );
-    const orderedIDs = filterAndOrderExternalIDs(result.ExternalIDInfo || []).filter((item) =>
-      fetchedProviders.has(item.Provider),
-    );
-    if (orderedIDs.length > 0) {
-      setSelectedProvider(orderedIDs[0].Provider);
-    } else {
-      setSelectedProvider("");
-    }
-    setDupeSummary(emptyDupeSummary);
-    setDupeError("");
-    setBuilderPreview(emptyDescriptionBuilder);
-    setBuilderRawByGroup({});
-    setBuilderRenderedByGroup({});
-    setBuilderExpandedGroups({});
-    setBuilderError("");
-    setBuilderDirtyByGroup({});
-    setBuilderSaved("");
-    setBuilderRefreshing(false);
-    setBuilderAutoRequestKey("");
-    resetScreenshotState();
-  };
-
-  const clearHostBrowserSearch = () => {
-    setHostBrowserSearch("");
-    setDebouncedHostBrowserSearch("");
-  };
-
-  const openHostBrowser = async (mode: "file" | "folder", startPath = "") => {
-    const browser = globalThis.go?.guiapp?.App?.BrowseDirectory;
-    if (!browser) {
-      setError("Browse is unavailable in this build.");
-      return;
-    }
-    setHostBrowserMode(mode);
-    setHostBrowserLoading(true);
-    setHostBrowserError("");
-    clearHostBrowserSearch();
-    try {
-      const selectedStart = startPath || path.trim();
-      const result = await browser(selectedStart, mode);
-      setHostBrowser(result);
-    } catch (err) {
-      setHostBrowserError(String(err));
-    } finally {
-      setHostBrowserLoading(false);
-    }
-  };
-
-  const runBrowse = async (mode: "file" | "folder") => {
-    setError("");
-    const app = globalThis.go?.guiapp?.App;
-    if (browserMode && app?.BrowseDirectory) {
-      await openHostBrowser(mode);
-      return;
-    }
-    const browse =
-      mode === "file" ? app?.BrowseFile || app?.BrowsePath : app?.BrowseFolder || app?.BrowsePath;
-    if (!browse) {
-      setError("Browse is unavailable in this build.");
-      return;
-    }
-    try {
-      const selected = await browse();
-      if (selected) {
-        await handlePathSelected(selected, mode);
-      }
-    } catch (err) {
-      setError(String(err));
-    }
-  };
-
-  const handleBrowseFile = async () => {
-    await runBrowse("file");
-  };
-
-  const handleBrowseFolder = async () => {
-    await runBrowse("folder");
-  };
-
-  const closeHostBrowser = () => {
-    setHostBrowserMode(null);
-    setHostBrowser(null);
-    setHostBrowserError("");
-    clearHostBrowserSearch();
-  };
-
-  useEffect(() => {
-    const timer = setTimeout(() => {
-      setDebouncedHostBrowserSearch(hostBrowserSearch);
-    }, 250);
-    return () => clearTimeout(timer);
-  }, [hostBrowserSearch]);
-
-  const hostBrowserEntries = useMemo(
-    () => filterBrowseEntries(hostBrowser?.entries || [], debouncedHostBrowserSearch),
-    [hostBrowser?.entries, debouncedHostBrowserSearch],
-  );
-
-  useEffect(() => {
-    hostBrowserEntryRefs.current = [];
-  }, [hostBrowserEntries]);
-
-  useEffect(() => {
-    if (!hostBrowserMode || hostBrowserLoading) {
-      return;
-    }
-
-    hostBrowserEntryRefs.current.find((entry) => entry !== null)?.focus();
-  }, [hostBrowser?.currentPath, hostBrowserLoading, hostBrowserMode]);
-
-  const browseHostDirectory = async (nextPath: string) => {
-    if (!hostBrowserMode) {
-      return;
-    }
-    await openHostBrowser(hostBrowserMode, nextPath);
-  };
-
-  const selectHostPath = async (selectedPath: string, isDir: boolean) => {
-    if (!hostBrowserMode) {
-      return;
-    }
-    if (hostBrowserMode === "folder") {
-      await handlePathSelected(selectedPath, "folder");
-      closeHostBrowser();
-      return;
-    }
-    if (isDir) {
-      await browseHostDirectory(selectedPath);
-      return;
-    }
-    await handlePathSelected(selectedPath, "file");
-    closeHostBrowser();
-  };
-
-  const moveHostBrowserEntryFocus = (currentIndex: number, direction: 1 | -1) => {
-    const entries = hostBrowserEntryRefs.current.filter((entry): entry is HTMLDivElement =>
-      Boolean(entry),
-    );
-    if (entries.length === 0) {
-      return;
-    }
-    const current = hostBrowserEntryRefs.current[currentIndex];
-    const resolvedIndex = current ? entries.indexOf(current) : -1;
-    const nextIndex =
-      resolvedIndex >= 0
-        ? (resolvedIndex + direction + entries.length) % entries.length
-        : direction > 0
-          ? 0
-          : entries.length - 1;
-    entries[nextIndex]?.focus();
-  };
-
-  const handleHostBrowserEntryKeyDown = (
-    event: ReactKeyboardEvent<HTMLDivElement>,
-    entry: BrowseDirectoryResponse["entries"][number],
-    index: number,
-  ) => {
-    if (event.key === "ArrowDown") {
-      event.preventDefault();
-      event.stopPropagation();
-      moveHostBrowserEntryFocus(index, 1);
-      return;
-    }
-    if (event.key === "ArrowUp") {
-      event.preventDefault();
-      event.stopPropagation();
-      moveHostBrowserEntryFocus(index, -1);
-      return;
-    }
-    if (event.key === "Enter") {
-      event.preventDefault();
-      event.stopPropagation();
-      void selectHostPath(entry.path, entry.isDir);
-    }
-  };
-
-  const detectDiscType = async (selectedPath: string): Promise<string> => {
-    const detector = globalThis.go?.guiapp?.App?.DetectDiscType;
-    if (detector) {
-      try {
-        const discType = await detector(selectedPath);
-        return discType.trim().toUpperCase();
-      } catch {
-        // Fall through to path heuristics when detection is unavailable.
-      }
-    }
-
-    const upperPath = selectedPath.replace(/\\/g, "/").toUpperCase();
-    if (/(^|\/)BDMV(\/|$)/.test(upperPath)) {
-      return "BDMV";
-    }
-    if (/(^|\/)VIDEO_TS(\/|$)/.test(upperPath)) {
-      return "DVD";
-    }
-    return "";
-  };
-
-  const updateCurrentDiscType = async (selectedPath: string): Promise<string | null> => {
-    const requestToken = ++discTypeRequestTokenRef.current;
-    const discType = await detectDiscType(selectedPath);
-    if (requestToken !== discTypeRequestTokenRef.current) {
-      return null;
-    }
-    setCurrentDiscType(discType);
-    return discType;
-  };
-
-  // Auto-detect BDMV and show playlist selection
-  const handlePathSelected = async (
-    selectedPath: string,
-    mode?: SourcePathMode,
-  ): Promise<SourcePathSelection | null> => {
-    const trimmedPath = selectedPath.trim();
-    if (!trimmedPath) {
-      return null;
-    }
-    const selectedMode = mode ?? inferSourcePathMode(trimmedPath);
-    setPath(trimmedPath);
-    setSourcePathMode(selectedMode);
-    rememberSourcePath(trimmedPath, selectedMode);
-    const discType = await updateCurrentDiscType(trimmedPath);
-    if (discType === null) {
-      return null;
-    }
-    setShowExternalIDInputUI(true);
-    setPlaylistPreparationError("");
-    setBdinfoProgressLines([]);
-    setPlaylistAutoPreparing(false);
-    bdinfoProgressActiveRef.current = false;
-
-    if (selectedMode === "file") {
-      setShowPlaylistSelection(false);
-      setPlaylistSelectionPath("");
-      setPlaylistPreparationTrackerSnapshot(null);
-      setActiveTab("input");
-      return { path: trimmedPath, mode: selectedMode, waitsForPlaylistSelection: false };
-    }
-
-    if (discType !== "BDMV") {
-      setShowPlaylistSelection(false);
-      setPlaylistSelectionPath("");
-      setPlaylistPreparationTrackerSnapshot(null);
-      setActiveTab("input");
-      return { path: trimmedPath, mode: selectedMode, waitsForPlaylistSelection: false };
-    }
-
-    const upperPath = trimmedPath.toUpperCase();
-    let bdmvPath = trimmedPath;
-
-    if (!upperPath.includes("\\BDMV") && !upperPath.includes("/BDMV")) {
-      bdmvPath = `${trimmedPath}/BDMV`;
-    }
-
-    const playlistTrackerEligibility = resolveUploadTrackerEligibilityForPath(trimmedPath);
-
-    // Set the path for playlist discovery (component will discover the playlists)
-    setPlaylistSelectionPath(bdmvPath);
-    setPlaylistPreparationTrackerSnapshot({
-      selectedTrackers: playlistTrackerEligibility.selectedTrackers,
-      emptySelection: playlistTrackerEligibility.emptySelection,
-    });
-    setShowPlaylistSelection(true);
-    return { path: trimmedPath, mode: selectedMode, waitsForPlaylistSelection: true };
-  };
-
-  const handleSourcePathHistorySelect = async (entry: SourcePathHistoryEntry) => {
-    setError("");
-    await handlePathSelected(entry.path, entry.mode);
-  };
-
-  const runPlaylistBDInfo = async () => {
-    setPlaylistPreparationError("");
-    const fetcher = globalThis.go?.guiapp?.App?.FetchPreparation;
-    if (!fetcher) {
-      setPlaylistPreparationError("Preparation preview is unavailable in this build.");
-      return false;
-    }
-    if (!path.trim()) {
-      setPlaylistPreparationError("Please select a file or folder.");
-      return false;
-    }
-    const selectedTrackers =
-      playlistPreparationTrackerSnapshot?.selectedTrackers ??
-      selectedUploadTrackerEligibility.selectedTrackers;
-    const emptySelection =
-      playlistPreparationTrackerSnapshot?.emptySelection ??
-      selectedUploadTrackerEligibility.emptySelection;
-    if (selectedTrackers.length === 0 && emptySelection) {
-      setPlaylistPreparationError("Select at least one tracker before preparing playlists.");
-      return false;
-    }
-    try {
-      await fetcher(path.trim(), {}, {}, selectedTrackers, []);
-      return true;
-    } catch (err) {
-      setPlaylistPreparationError(String(err));
-      return false;
-    }
-  };
-
-  const handlePlaylistSelectionComplete = async () => {
-    setPlaylistPreparationError("");
-    setBdinfoProgressLines([]);
-    bdinfoProgressActiveRef.current = true;
-    setPlaylistAutoPreparing(true);
-    const completed = await runPlaylistBDInfo();
-    bdinfoProgressActiveRef.current = false;
-    setPlaylistAutoPreparing(false);
-    if (completed) {
-      setShowPlaylistSelection(false);
-      setPlaylistSelectionPath("");
-      setPlaylistPreparationTrackerSnapshot(null);
-      setActiveTab("input");
-    }
-  };
-
-  const runFetch = async (
-    overrides: ExternalIDOverrides,
-    nameOverrides: ReleaseNameOverrides,
-    hideExternalIDInputUIOnSuccess = false,
-    options: { targetPath?: string; targetMode?: SourcePathMode; switchToInput?: boolean } = {},
-  ) => {
-    setError("");
-    setDupeChecked(false);
-    setDupeSummary(emptyDupeSummary);
-    setBuilderPreview(emptyDescriptionBuilder);
-    setBuilderRawByGroup({});
-    setBuilderRenderedByGroup({});
-    setBuilderExpandedGroups({});
-    setBuilderDirtyByGroup({});
-    setBluraySelectionError("");
-    const fetcher = globalThis.go?.guiapp?.App?.FetchMetadata;
-    if (!fetcher) {
-      setError("Fetch metadata is unavailable in this build.");
-      return;
-    }
-    const targetPath = (options.targetPath ?? path).trim();
-    if (!targetPath) {
-      setError("Please select a file or folder.");
-      return;
-    }
-    const trackerEligibility = resolveUploadTrackerEligibilityForPath(targetPath);
-    const selectedTrackers = trackerEligibility.selectedTrackers;
-    if (selectedTrackers.length === 0 && trackerEligibility.emptySelection) {
-      setError("Select at least one tracker before fetching metadata.");
-      return;
-    }
-    metadataProgressTargetRef.current = targetPath;
-    metadataProgressActiveRef.current = true;
-    setMetadataProgressUpdates([]);
-    setMetadataProgressActive(true);
-    setLoading(true);
-    try {
-      await updateCurrentDiscType(targetPath);
-      const result = await fetcher(
-        targetPath,
-        sourceLookupURL.trim(),
-        normalizeOverrides(overrides),
-        normalizeReleaseOverrides(nameOverrides),
-        selectedTrackers,
-      );
-      applyPreviewResult(result, {
-        switchToInput: options.switchToInput,
-        preserveIDTouches: Object.keys(normalizeOverrides(overrides)).length > 0,
-      });
-      rememberSourcePath(
-        targetPath,
-        options.targetMode ?? sourcePathMode ?? inferSourcePathMode(targetPath),
-      );
-      setShowExternalIDInputUI(!hideExternalIDInputUIOnSuccess);
-    } catch (err) {
-      setError(String(err));
-    } finally {
-      metadataProgressActiveRef.current = false;
-      setMetadataProgressActive(false);
-      setLoading(false);
-    }
-  };
-
-  const handleFetch = async () => {
-    await runFetch({}, {}, false);
-  };
-
-  const handleSourcePathDrop = async (paths: string[]) => {
-    if (loading) {
-      setError("Metadata fetch is already running.");
-      return;
-    }
-    const droppedPath = paths.find((candidate) => candidate.trim())?.trim() || "";
-    if (!droppedPath) {
-      setError("Dropped file path was empty.");
-      return;
-    }
-    setError("");
-    const selection = await handlePathSelected(droppedPath);
-    if (!selection || selection.waitsForPlaylistSelection) {
-      return;
-    }
-    await runFetch({}, {}, false, {
-      targetPath: selection.path,
-      targetMode: selection.mode,
-    });
-  };
-
-  sourcePathDropHandlerRef.current = (paths: string[]) => {
-    void handleSourcePathDrop(paths);
-  };
-
-  useEffect(() => {
-    const runtime = (
-      globalThis as typeof globalThis & {
-        runtime?: { OnFileDrop?: unknown; OnFileDropOff?: unknown };
-      }
-    ).runtime;
-    if (browserMode || typeof runtime?.OnFileDrop !== "function") {
-      return;
-    }
-    OnFileDrop((_x, _y, paths) => {
-      sourcePathDropHandlerRef.current(paths);
-    }, true);
-    return () => {
-      if (typeof runtime.OnFileDropOff === "function") {
-        OnFileDropOff();
-      }
-    };
-  }, [browserMode]);
-
-  const clearEditAttributesState = () => {
-    setIdEdits(buildIDEditState(emptyPreview.ExternalIDs));
-    setIdTouched(buildIDTouchedState());
-    setReleaseEdits(buildReleaseEditState({}));
-    setReleaseTouched(buildReleaseTouchedState({}));
-  };
-
-  const handleRefresh = async () => {
-    if (
-      (!idOverrideState?.dirty && !releaseOverrideState?.dirty && !sourceLookupURL.trim()) ||
-      idOverrideState?.invalid ||
-      releaseOverrideState?.invalid
-    ) {
-      return;
-    }
-    await runFetch(idOverrideState?.overrides || {}, releaseOverrideState?.overrides || {}, true);
-  };
-
-  const handleResetMetadata = async () => {
-    setError("");
-    const resetter = globalThis.go?.guiapp?.App?.ResetMetadata;
-    if (!resetter) {
-      setError("Metadata reset is unavailable in this build.");
-      return;
-    }
-    if (!path.trim()) {
-      setError("Please select a file or folder.");
-      return;
-    }
-    const selectedTrackers = selectedUploadImageTrackers;
-    if (selectedTrackers.length === 0 && selectedUploadTrackerEligibility.emptySelection) {
-      setError("Select at least one tracker before resetting metadata.");
-      return;
-    }
-    if (
-      !globalThis.confirm(
-        "Remove cached metadata and temporary files for this content, then refetch metadata?",
-      )
-    ) {
-      return;
-    }
-    const targetPath = path.trim();
-    clearEditAttributesState();
-    metadataProgressTargetRef.current = targetPath;
-    metadataProgressActiveRef.current = true;
-    setMetadataProgressUpdates([]);
-    setMetadataProgressActive(true);
-    setLoading(true);
-    setMetadataResetting(true);
-    try {
-      const result = await resetter(targetPath, sourceLookupURL.trim(), {}, {}, selectedTrackers);
-      applyPreviewResult(result);
-      setShowExternalIDInputUI(true);
-    } catch (err) {
-      setError(String(err));
-    } finally {
-      metadataProgressActiveRef.current = false;
-      setMetadataProgressActive(false);
-      setLoading(false);
-      setMetadataResetting(false);
-    }
-  };
-
-  const handleSelectBlurayCandidate = async (releaseID: string) => {
-    setBluraySelectionError("");
-    const selector = globalThis.go?.guiapp?.App?.SelectBlurayCandidate;
-    if (!selector) {
-      setBluraySelectionError("Blu-ray candidate selection is unavailable in this build.");
-      return;
-    }
-    const targetPath = (preview.SourcePath || path).trim();
-    if (!targetPath || !releaseID.trim()) {
-      setBluraySelectionError("Path and release candidate are required.");
-      return;
-    }
-    setBluraySelecting(true);
-    try {
-      const result = await selector(targetPath, releaseID.trim());
-      applyPreviewResult(result, { switchToInput: false });
-    } catch (err) {
-      setBluraySelectionError(String(err));
-    } finally {
-      setBluraySelecting(false);
-    }
-  };
-
-  const runDescriptionBuilder = useCallback(
-    async (overrides: ExternalIDOverrides, nameOverrides: ReleaseNameOverrides) => {
-      const clearBuilderProgressTimers = () => {
-        builderProgressTimers.current.forEach((timer) => window.clearTimeout(timer));
-        builderProgressTimers.current = [];
-      };
-      clearBuilderProgressTimers();
-      setBuilderError("");
-      setBuilderSaved("");
-      setBuilderProgressMessage("");
-      const fetcher = globalThis.go?.guiapp?.App?.FetchDescriptionBuilder;
-      if (!fetcher) {
-        setBuilderError("Description builder is unavailable in this build.");
-        return;
-      }
-      if (!path.trim()) {
-        setBuilderError("Please select a file or folder.");
-        return;
-      }
-      const selectedTrackers = selectedUploadImageTrackers;
-      if (
-        selectedTrackers.length === 0 &&
-        hasExplicitEmptyReleaseTrackerSelection(trackerUploadItems, releasePageTrackerSelection)
-      ) {
-        setBuilderError("Select at least one tracker before building descriptions.");
-        return;
-      }
-      if (selectedTrackers.length === 0) {
-        setBuilderError("Enable at least one tracker in Upload Targets.");
-        return;
-      }
-      setBuilderLoading(true);
-      setBuilderProgressMessage("Preparing metadata and tracker selection...");
-      builderProgressTimers.current = [
-        window.setTimeout(
-          () => setBuilderProgressMessage("Checking image-host requirements..."),
-          900,
-        ),
-        window.setTimeout(
-          () =>
-            setBuilderProgressMessage("Rehosting required comparison and description images..."),
-          2500,
-        ),
-        window.setTimeout(
-          () => setBuilderProgressMessage("Still rehosting images and building descriptions..."),
-          5000,
-        ),
-        window.setTimeout(
-          () => setBuilderProgressMessage("Large image upload still running..."),
-          15000,
-        ),
-        window.setTimeout(
-          () => setBuilderProgressMessage("Waiting for image hosts to finish..."),
-          30000,
-        ),
-      ];
-      try {
-        const result = await fetcher(
-          path.trim(),
-          normalizeOverrides(overrides),
-          normalizeReleaseOverrides(nameOverrides),
-          selectedTrackers,
-          ignoredDupeTrackers,
-        );
-        setBuilderPreview(result);
-        setBuilderRawByGroup(
-          Object.fromEntries(
-            (result.Groups || []).map((group) => [group.GroupKey, group.RawDescription || ""]),
-          ),
-        );
-        setBuilderRenderedByGroup(
-          Object.fromEntries(
-            (result.Groups || []).map((group) => [group.GroupKey, group.RawDescriptionHTML || ""]),
-          ),
-        );
-        setBuilderExpandedGroups((prev) => {
-          const next: Record<string, boolean> = {};
-          (result.Groups || []).forEach((group) => {
-            next[group.GroupKey] = prev[group.GroupKey] ?? false;
-          });
-          return next;
-        });
-        setBuilderDirtyByGroup({});
-        clearBuilderProgressTimers();
-        setBuilderProgressMessage("Refreshing uploaded image records...");
-        await refreshUploadedImages();
-      } catch (err) {
-        setBuilderError(String(err));
-      } finally {
-        clearBuilderProgressTimers();
-        setBuilderProgressMessage("");
-        setBuilderLoading(false);
-      }
-    },
-    [
-      path,
-      releasePageTrackerSelection,
-      trackerUploadItems,
-      selectedUploadImageTrackers,
-      ignoredDupeTrackers,
-      refreshUploadedImages,
-    ],
-  );
-
-  const refreshDescriptionBuilder = useCallback(async () => {
-    if (builderDirty) {
-      const shouldRefresh = window.confirm(
-        "Refreshing descriptions will discard unsaved description edits. Continue?",
-      );
-      if (!shouldRefresh) {
-        return;
-      }
-    }
-
-    setBuilderRefreshing(true);
-    try {
-      await runDescriptionBuilder(
-        idOverrideState?.overrides || {},
-        releaseOverrideState?.overrides || {},
-      );
-    } finally {
-      setBuilderRefreshing(false);
-    }
-  }, [builderDirty, idOverrideState, releaseOverrideState, runDescriptionBuilder]);
-
-  useEffect(() => {
-    return () => {
-      builderProgressTimers.current.forEach((timer) => window.clearTimeout(timer));
-      builderProgressTimers.current = [];
-    };
-  }, []);
-
-  const resetBuilderDescription = async (
-    groupKey: string,
-    overrides: ExternalIDOverrides,
-    nameOverrides: ReleaseNameOverrides,
-  ) => {
-    setBuilderError("");
-    setBuilderSaved("");
-    const saver = globalThis.go?.guiapp?.App?.SaveDescriptionOverride;
-    if (!saver) {
-      setBuilderError("Description saving is unavailable in this build.");
-      return;
-    }
-    if (!path.trim()) {
-      setBuilderError("Please select a file or folder.");
-      return;
-    }
-    const currentGroup = (builderPreview.Groups || []).find((group) => group.GroupKey === groupKey);
-    if (!currentGroup) {
-      setBuilderError("Description group not found.");
-      return;
-    }
-    setBuilderLoading(true);
-    try {
-      const updatedGroup = await saver(
-        path.trim(),
-        groupKey,
-        "",
-        currentGroup.Trackers || [],
-        normalizeOverrides(overrides),
-        normalizeReleaseOverrides(nameOverrides),
-      );
-      setBuilderPreview((prev) => upsertBuilderGroup(prev, updatedGroup));
-      setBuilderRawByGroup((prev) => ({ ...prev, [groupKey]: updatedGroup.RawDescription || "" }));
-      setBuilderRenderedByGroup((prev) => ({
-        ...prev,
-        [groupKey]: updatedGroup.RawDescriptionHTML || "",
-      }));
-      setBuilderDirtyByGroup((prev) => ({ ...prev, [groupKey]: false }));
-      setBuilderSaved("Description reset.");
-    } catch (err) {
-      setBuilderError(String(err));
-    } finally {
-      setBuilderLoading(false);
-    }
-  };
-
-  const renderBuilderDescription = async (groupKey: string) => {
-    setBuilderError("");
-    const renderer = globalThis.go?.guiapp?.App?.RenderDescription;
-    if (!renderer) {
-      setBuilderError("Description rendering is unavailable in this build.");
-      return;
-    }
-    const raw = builderRawByGroup[groupKey] || "";
-    if (!raw.trim()) {
-      setBuilderRenderedByGroup((prev) => ({ ...prev, [groupKey]: "" }));
-      return;
-    }
-    setBuilderRenderLoading(true);
-    try {
-      const html = await renderer(raw);
-      setBuilderRenderedByGroup((prev) => ({ ...prev, [groupKey]: html || "" }));
-    } catch (err) {
-      setBuilderError(String(err));
-    } finally {
-      setBuilderRenderLoading(false);
-    }
-  };
-
-  const saveBuilderDescription = async (groupKey: string) => {
-    setBuilderError("");
-    setBuilderSaved("");
-    const saver = globalThis.go?.guiapp?.App?.SaveDescriptionOverride;
-    if (!saver) {
-      setBuilderError("Description saving is unavailable in this build.");
-      return;
-    }
-    if (!path.trim()) {
-      setBuilderError("Please select a file or folder.");
-      return;
-    }
-    const currentGroup = (builderPreview.Groups || []).find((group) => group.GroupKey === groupKey);
-    if (!currentGroup) {
-      setBuilderError("Description group not found.");
-      return;
-    }
-    setBuilderSaving(true);
-    try {
-      const updatedGroup = await saver(
-        path.trim(),
-        groupKey,
-        builderRawByGroup[groupKey] || "",
-        currentGroup.Trackers || [],
-        normalizeOverrides(idOverrideState?.overrides || {}),
-        normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-      );
-      const nextPreview = upsertBuilderGroup(builderPreview, updatedGroup);
-      const shouldRefreshDryRun =
-        path.trim() === String(trackerDryRunPreview.SourcePath || "").trim() &&
-        (trackerDryRunPreview.Trackers || []).length > 0;
-
-      setBuilderPreview(nextPreview);
-      setBuilderRawByGroup((prev) => ({ ...prev, [groupKey]: updatedGroup.RawDescription || "" }));
-      setBuilderRenderedByGroup((prev) => ({
-        ...prev,
-        [groupKey]: updatedGroup.RawDescriptionHTML || "",
-      }));
-      setBuilderSaved("Description saved.");
-      setBuilderDirtyByGroup((prev) => ({ ...prev, [groupKey]: false }));
-
-      if (shouldRefreshDryRun) {
-        try {
-          await runTrackerDryRun(nextPreview.Groups || [], false);
-          setBuilderSaved("Description saved. Dry run refreshed.");
-        } catch (err) {
-          setTrackerDryRunError(`Description saved, but dry run refresh failed: ${String(err)}`);
-        }
-      }
-    } catch (err) {
-      setBuilderError(String(err));
-    } finally {
-      setBuilderSaving(false);
-    }
-  };
-
-  const runScreenshotCapture = async (
-    selections: ScreenshotSelection[],
-    purpose: ScreenshotPurpose,
-  ) => {
-    const runner = globalThis.go?.guiapp?.App?.GenerateScreenshots;
-    if (!runner) {
-      throw new Error("Screenshot capture is unavailable in this build.");
-    }
-    return runner(
-      path.trim(),
-      normalizeOverrides(idOverrideState?.overrides || {}),
-      normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-      selections,
-      purpose,
-    );
-  };
-
-  const warmMetadataCache = async () => {
-    const fetcher = globalThis.go?.guiapp?.App?.FetchMetadata;
-    if (!fetcher) {
-      return;
-    }
-    if (!path.trim()) {
-      return;
-    }
-    const selectedTrackers = selectedUploadImageTrackers;
-    if (selectedTrackers.length === 0 && selectedUploadTrackerEligibility.emptySelection) {
-      return;
-    }
-    await fetcher(
-      path.trim(),
-      sourceLookupURL.trim(),
-      normalizeOverrides(idOverrideState?.overrides || {}),
-      normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-      selectedTrackers,
-    );
-  };
-
-  const previewFrameRate = useMemo(() => {
-    const rate = screenshots.screenshotPlan?.FrameRate || 0;
-    return rate > 0 ? rate : 24;
-  }, [screenshots.screenshotPlan]);
-
-  const previewDuration = useMemo(
-    () => screenshots.screenshotPlan?.DurationSeconds || 0,
-    [screenshots.screenshotPlan],
-  );
-
-  const clampPreviewSeconds = useCallback(
-    (value: number) => {
-      if (!Number.isFinite(value)) return 0;
-      if (previewDuration > 0) {
-        return Math.min(Math.max(value, 0), previewDuration);
-      }
-      return Math.max(value, 0);
-    },
-    [previewDuration],
-  );
-
-  const livePreviewFrame = useMemo(() => {
-    if (previewFrameRate <= 0) return 0;
-    const seconds = clampPreviewSeconds(livePreviewSeconds);
-    const frame = Math.round(seconds * previewFrameRate);
-    return Number.isFinite(frame) ? frame : 0;
-  }, [livePreviewSeconds, previewFrameRate, clampPreviewSeconds]);
-
-  const runLivePreviewAt = async (timestampSeconds: number) => {
-    setLivePreviewError("");
-    if (!path.trim()) {
-      setLivePreviewError("Please select a file or folder.");
-      return;
-    }
-    if (!screenshots.screenshotPlan) {
-      setLivePreviewError("Load suggestions to enable live preview.");
-      return;
-    }
-
-    const previewer = globalThis.go?.guiapp?.App?.PreviewScreenshotFrame;
-    if (!previewer) {
-      setLivePreviewError("Live preview is unavailable in this build.");
-      return;
-    }
-
-    const requestId = livePreviewRequestId.current + 1;
-    livePreviewRequestId.current = requestId;
-    setLivePreviewLoading(true);
-    const timestamp = clampPreviewSeconds(timestampSeconds);
-    try {
-      const dataUri = await previewer(
-        path.trim(),
-        normalizeOverrides(idOverrideState?.overrides || {}),
-        normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        timestamp,
-      );
-      if (livePreviewRequestId.current !== requestId) {
-        return;
-      }
-      setLivePreviewImage(dataUri);
-    } catch (err) {
-      if (livePreviewRequestId.current !== requestId) {
-        return;
-      }
-      setLivePreviewError(String(err));
-    } finally {
-      if (livePreviewRequestId.current === requestId) {
-        setLivePreviewLoading(false);
-      }
-    }
-  };
-
-  const runLivePreview = async () => {
-    await runLivePreviewAt(livePreviewSeconds);
-  };
-
-  const stepLivePreview = (direction: number) => {
-    const step = 1 / previewFrameRate;
-    const next = clampPreviewSeconds(livePreviewSeconds + direction * step);
-    setLivePreviewSeconds(next);
-    void runLivePreviewAt(next);
-  };
-
-  const handlePreviewSelection = async (selection: ScreenshotSelection) => {
-    screenshots.setScreenshotsError("");
-    if (!path.trim()) {
-      screenshots.setScreenshotsError("Please select a file or folder.");
-      return;
-    }
-    screenshots.setPreviewLoadingIndex(selection.Index);
-    try {
-      const result = await runScreenshotCapture([selection], "preview");
-      const images = result.Images || [];
-      const previews = await Promise.all(images.map(screenshots.readScreenshotImage));
-      screenshots.setPreviewImages((prev) => {
-        const merged = new Map<string, ScreenshotPreviewImage>();
-        prev.forEach((item) => {
-          if (item.image.Path) {
-            merged.set(item.image.Path, item);
-          }
-        });
-        previews.forEach((item) => {
-          if (item.image.Path) {
-            merged.set(item.image.Path, item);
-          }
-        });
-        return Array.from(merged.values());
-      });
-    } catch (err) {
-      screenshots.setScreenshotsError(String(err));
-    } finally {
-      screenshots.setPreviewLoadingIndex(null);
-    }
-  };
-
-  const handleCapturePreviewFrame = async () => {
-    screenshots.setScreenshotsError("");
-    if (!path.trim()) {
-      screenshots.setScreenshotsError("Please select a file or folder.");
-      return;
-    }
-
-    const timestamp = clampPreviewSeconds(livePreviewSeconds);
-    const baseSelections =
-      screenshots.screenshotSelections.length > 0
-        ? screenshots.screenshotSelections
-        : screenshots.screenshotPlan?.SuggestedSelections || [];
-    if (baseSelections.length === 0) {
-      screenshots.setScreenshotsError("No screenshot selections available.");
-      return;
-    }
-
-    const autoSelections = baseSelections.filter((entry) => {
-      const source = (entry.Source || "auto").toLowerCase();
-      return source === "auto";
-    });
-    const candidates = autoSelections.length > 0 ? autoSelections : baseSelections;
-
-    const resolveTimestamp = (entry: ScreenshotSelection) => {
-      if (Number.isFinite(entry.TimestampSeconds) && entry.TimestampSeconds > 0) {
-        return entry.TimestampSeconds;
-      }
-      if (Number.isFinite(entry.Frame) && entry.Frame > 0) {
-        return entry.Frame / previewFrameRate;
-      }
-      return 0;
-    };
-
-    const closest = candidates.reduce(
-      (best, entry) => {
-        const currentDiff = Math.abs(resolveTimestamp(entry) - timestamp);
-        if (!best) return entry;
-        const bestDiff = Math.abs(resolveTimestamp(best) - timestamp);
-        if (currentDiff < bestDiff) return entry;
-        return best;
-      },
-      undefined as ScreenshotSelection | undefined,
-    );
-
-    if (!closest) {
-      screenshots.setScreenshotsError("No screenshot selections available.");
-      return;
-    }
-
-    const frame = Math.max(0, Math.round(timestamp * previewFrameRate));
-    const selection: ScreenshotSelection = {
-      Index: closest.Index,
-      TimestampSeconds: timestamp,
-      Frame: frame,
-      Source: "manual",
-    };
-
-    const updatedSelections = baseSelections.map((entry) =>
-      entry.Index === selection.Index ? selection : entry,
-    );
-    const regenerated = regenerateAutoSelections(updatedSelections);
-    const reindexed = reindexSelectionsByTimestamp(regenerated, selection.Index);
-    const tolerance = previewFrameRate > 0 ? 1 / previewFrameRate : 0.01;
-    const manualSelection = reindexed.selections.find((entry) => {
-      const source = (entry.Source || "").toLowerCase();
-      if (source !== "manual") return false;
-      const ts = resolveTimestamp(entry);
-      if (!Number.isFinite(ts) || ts <= 0) return false;
-      return Math.abs(ts - timestamp) <= tolerance;
-    });
-    const resolvedSelection =
-      manualSelection ||
-      (reindexed.targetIndex >= 0 ? reindexed.selections[reindexed.targetIndex] : undefined);
-    if (!resolvedSelection) {
-      screenshots.setScreenshotsError("Failed to resolve capture index.");
-      return;
-    }
-    screenshots.setScreenshotSelections(reindexed.selections);
-
-    const captureSelection: ScreenshotSelection = {
-      ...selection,
-      Index: resolvedSelection.Index,
-    };
-
-    setLiveCaptureLoading(true);
-    try {
-      const result = await runScreenshotCapture([captureSelection], "preview");
-      const images = result.Images || [];
-      const previews = await Promise.all(images.map(screenshots.readScreenshotImage));
-      screenshots.setPreviewImages((prev) => {
-        const merged = new Map<string, ScreenshotPreviewImage>();
-        prev.forEach((item) => {
-          if (item.image.Path) {
-            merged.set(item.image.Path, item);
-          }
-        });
-        previews.forEach((item) => {
-          if (item.image.Path) {
-            merged.set(item.image.Path, item);
-          }
-        });
-        return Array.from(merged.values());
-      });
-      if (previews.length > 0) {
-        const mergedFinals = mergeFinalSelections(screenshots.finalImagesRef.current, previews);
-        await screenshots.saveFinalSelections(mergedFinals);
-      }
-    } catch (err) {
-      screenshots.setScreenshotsError(String(err));
-    } finally {
-      setLiveCaptureLoading(false);
-    }
-  };
-
-  const buildExistingSelectionIndexSet = () => {
-    const indices = new Set<number>();
-    const addImages = (images: ScreenshotImage[] | undefined) => {
-      if (!images || images.length === 0) return;
-      images.forEach((image) => {
-        if (Number.isFinite(image.Index)) {
-          indices.add(image.Index);
-        }
-      });
-    };
-    addImages(screenshots.screenshotPlan?.ExistingScreenshots);
-    addImages(screenshots.existingImages.map((entry) => entry.image));
-    addImages(screenshots.finalImagesRef.current.map((entry) => entry.image));
-    return indices;
-  };
-
-  const handleGenerateScreenshots = async () => {
-    screenshots.setScreenshotsError("");
-    if (!path.trim()) {
-      screenshots.setScreenshotsError("Please select a file or folder.");
-      return;
-    }
-    let selections = screenshots.screenshotSelections;
-    if (selections.length === 0) {
-      const plan = await screenshots.loadScreenshotPlan(false);
-      selections = plan?.SuggestedSelections || [];
-    }
-    if (selections.length === 0) {
-      screenshots.setScreenshotsError("No screenshot selections available.");
-      return;
-    }
-    const existingIndices = buildExistingSelectionIndexSet();
-    const filteredSelections = selections.filter((entry) => !existingIndices.has(entry.Index));
-    if (filteredSelections.length === 0) {
-      screenshots.setScreenshotsError("All requested screenshots already exist.");
-      return;
-    }
-    screenshots.setScreenshotsLoading(true);
-    try {
-      const result = await runScreenshotCapture(filteredSelections, "final");
-      screenshots.setFinalResult(result);
-      const images = result.Images || [];
-      const previews = await Promise.all(images.map(screenshots.readScreenshotImage));
-      const merged = mergeFinalSelections(screenshots.finalImagesRef.current, previews);
-      await screenshots.saveFinalSelections(merged);
-    } catch (err) {
-      screenshots.setScreenshotsError(String(err));
-    } finally {
-      screenshots.setScreenshotsLoading(false);
-    }
-  };
-
-  const applyDupeCheckSnapshot = useCallback((snapshot: DupeCheckSnapshot) => {
-    setDupeCheckSnapshot(snapshot);
-    setDupeSummary(snapshot.summary || emptyDupeSummary);
-
-    const normalized = normalizeJobStatus(snapshot.status);
-    const running = isRunningJobStatus(normalized);
-    setDupeLoading(running);
-
-    if (normalized === "completed") {
-      setDupeChecked(true);
-      setDupeError("");
-    } else if (normalized === "completed_with_errors") {
-      setDupeChecked(true);
-      setDupeError(snapshot.error || "One or more tracker dupe checks failed.");
-    } else if (normalized === "failed" || normalized === "canceled") {
-      setDupeChecked(false);
-      setDupeError(snapshot.error ? dupeCheckErrorMessage(snapshot.error) : "Dupe check failed.");
-    }
-  }, []);
-
-  const handleDupeCheck = async () => {
-    setDupeError("");
-    const starter = globalThis.go?.guiapp?.App?.StartDupeCheck;
-    const snapshotLoader = globalThis.go?.guiapp?.App?.GetDupeCheckSnapshot;
-    if (!starter) {
-      setDupeError("Dupe checking is unavailable in this build.");
-      return;
-    }
-    if (!path.trim()) {
-      setDupeError("Please select a file or folder.");
-      return;
-    }
-    if (idOverrideState?.invalid || releaseOverrideState?.invalid) {
-      setDupeError("Fix invalid overrides before checking dupes.");
-      return;
-    }
-    const trackerEligibility = resolveUploadTrackerEligibilityForPath(path, {
-      applyDupeFilters: false,
-    });
-    const selectedTrackers = trackerEligibility.selectedTrackers.slice();
-    if (selectedTrackers.length === 0) {
-      setDupeError("Select at least one tracker before checking dupes.");
-      return;
-    }
-    setDupeLoading(true);
-    let jobID = "";
-    try {
-      jobID = await starter(
-        path.trim(),
-        normalizeOverrides(idOverrideState?.overrides || {}),
-        normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        selectedTrackers,
-      );
-    } catch (err) {
-      const message = String(err);
-      // Starter failures do not create a durable job, so stop polling without
-      // discarding the last completed summary.
-      setDupeLoading(false);
-      setDupeCheckJobID("");
-      setDupeError(dupeCheckErrorMessage(message));
-      return;
-    }
-    setDupeChecked(false);
-    setDupeSummary(emptyDupeSummary);
-    setDupeCheckSnapshot(null);
-    setDupeCheckJobID(jobID);
-    // The first snapshot is best-effort; once a job exists, events and fallback
-    // polling own lifecycle updates.
-    if (snapshotLoader) {
-      try {
-        const snapshot = await snapshotLoader(jobID);
-        applyDupeCheckSnapshot(snapshot);
-      } catch {
-        // Keep tracking the job even when this initial fetch is transiently unavailable.
-      }
-    }
-  };
-
-  useEffect(() => {
-    if (!dupeCheckJobID) {
-      return;
-    }
-
-    const eventName = `${dupeCheckEventPrefix}${dupeCheckJobID}`;
-    const off = EventsOn(eventName, (payload: any) => {
-      if (payload?.jobID !== dupeCheckJobID) {
-        return;
-      }
-      applyDupeCheckSnapshot(payload as DupeCheckSnapshot);
-    });
-
-    return () => {
-      if (typeof off === "function") {
-        off();
-      }
-    };
-  }, [applyDupeCheckSnapshot, dupeCheckJobID]);
-
-  useEffect(() => {
-    // Poll active jobs as a fallback for missed early job events; live events
-    // still drive updates when the runtime stream is healthy.
-    const currentStatus = String(dupeCheckSnapshot?.status || "");
-    if (!dupeCheckJobID || (!dupeLoading && !isRunningJobStatus(currentStatus))) {
-      return;
-    }
-    const snapshotLoader = globalThis.go?.guiapp?.App?.GetDupeCheckSnapshot;
-    if (!snapshotLoader) {
-      return;
-    }
-
-    let stopped = false;
-    let timer: number | undefined;
-    const loadSnapshot = async () => {
-      try {
-        const snapshot = await snapshotLoader(dupeCheckJobID);
-        if (!stopped) {
-          applyDupeCheckSnapshot(snapshot);
-        }
-      } catch {
-        // Event delivery remains primary; transient polling failures should not replace UI errors.
-      }
-      if (!stopped) {
-        timer = window.setTimeout(loadSnapshot, 1000);
-      }
-    };
-
-    timer = window.setTimeout(loadSnapshot, 1000);
-    return () => {
-      stopped = true;
-      if (timer !== undefined) {
-        window.clearTimeout(timer);
-      }
-    };
-  }, [applyDupeCheckSnapshot, dupeCheckJobID, dupeCheckSnapshot?.status, dupeLoading]);
-
-  useEffect(() => {
-    setCurrentDiscType("");
-    setImageAssetsRevision(0);
-    setDupeChecked(false);
-    setDupeCheckJobID("");
-    setDupeCheckSnapshot(null);
-    setDupeSummary(emptyDupeSummary);
-    setDupeIgnore({});
-    setDupeTrackerFlags({});
-    autoDisabledUploadTrackersRef.current.clear();
-    setBuilderPreview(emptyDescriptionBuilder);
-    setBuilderRawByGroup({});
-    setBuilderRenderedByGroup({});
-    setBuilderExpandedGroups({});
-    setBuilderError("");
-    setBuilderDirtyByGroup({});
-    setBuilderSaved("");
-    setBuilderRefreshing(false);
-    setBuilderAutoRequestKey("");
-    setTrackerUploadRunning(false);
-    setTrackerUploadError("");
-    setTrackerUploadJobID("");
-    setTrackerUploadSnapshot(null);
-    setTrackerDryRunLoading(false);
-    setTrackerDryRunError("");
-    setTrackerDryRunPreview(emptyTrackerDryRun);
-    setTrackerDryRunProgress(null);
-    bdinfoProgressActiveRef.current = false;
-    metadataProgressTargetRef.current = "";
-    metadataProgressActiveRef.current = false;
-    setMetadataProgressActive(false);
-    setMetadataProgressUpdates([]);
-    resetScreenshotState();
-  }, [path, resetScreenshotState]);
-
-  useEffect(() => {
-    if (activeTab !== "description_builder") return;
-    if (!dupeChecked) return;
-    if (builderLoading || builderSaving) return;
-    if (builderDirty) return;
-    const normalizedPath = path.trim();
-    if (!normalizedPath) return;
-    const requestKey = JSON.stringify({
-      path: normalizedPath,
-      external: normalizeOverrides(idOverrideState?.overrides || {}),
-      release: normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-      imageAssetsRevision,
-    });
-    if (builderAutoRequestKey === requestKey) return;
-    setBuilderAutoRequestKey(requestKey);
-    runDescriptionBuilder(idOverrideState?.overrides || {}, releaseOverrideState?.overrides || {});
-  }, [
-    activeTab,
-    dupeChecked,
-    builderLoading,
-    builderSaving,
-    builderDirty,
-    path,
-    idOverrideState,
-    releaseOverrideState,
-    builderAutoRequestKey,
-    imageAssetsRevision,
-    runDescriptionBuilder,
-  ]);
-
-  useEffect(() => {
-    if (activeTab !== "upload") return;
-    if (builderReady) return;
-    setActiveTab("description_builder");
-  }, [activeTab, builderReady]);
-
-  useEffect(() => {
-    if (activeTab !== "screenshots") return;
-    if (!dupeChecked) return;
-    if (screenshots.screenshotPlan || screenshots.screenshotsLoading) return;
-    loadScreenshotPlan();
-  }, [
-    activeTab,
-    dupeChecked,
-    screenshots.screenshotPlan,
-    screenshots.screenshotsLoading,
-    loadScreenshotPlan,
-  ]);
-
-  useEffect(() => {
-    if (activeTab !== "upload_images") return;
-    if (!dupeChecked) return;
-    if (screenshots.screenshotPlan || screenshots.screenshotsLoading) return;
-    loadScreenshotPlan();
-  }, [
-    activeTab,
-    dupeChecked,
-    screenshots.screenshotPlan,
-    screenshots.screenshotsLoading,
-    loadScreenshotPlan,
-  ]);
-
-  useEffect(() => {
-    if (activeTab !== "upload_images") return;
-    if (!path.trim()) return;
-    const loadUploadCandidates = async () => {
-      try {
-        const candidates = await globalThis.go?.guiapp?.App?.ListUploadCandidates(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        );
-        if (!candidates || candidates.length === 0) {
-          setExistingImages([]);
-          await refreshUploadedImages();
-          return;
-        }
-        const previews = await Promise.all(
-          candidates.map(async (image: ScreenshotImage) => {
-            try {
-              return await readScreenshotImage(image);
-            } catch {
-              return null;
-            }
-          }),
-        );
-        setExistingImages(
-          previews.filter((entry): entry is ScreenshotPreviewImage => Boolean(entry)),
-        );
-        await refreshUploadedImages();
-      } catch (err) {
-        console.error("Failed to load upload candidates:", err);
-      }
-    };
-    loadUploadCandidates();
-  }, [
-    activeTab,
-    path,
-    idOverrideState,
-    releaseOverrideState,
-    setExistingImages,
-    readScreenshotImage,
-    refreshUploadedImages,
-    imageAssetsRevision,
-  ]);
-
-  /**
-   * Synchronizes upload toggles with tracker selection and dupe eligibility.
-   *
-   * Dupe hits temporarily turn upload targets off. When the user ignores those
-   * dupes, the previous selected/default state is restored; hard failures and
-   * rule skips stay disabled until the blocking result changes.
-   */
-  useEffect(() => {
-    if (trackerUploadItems.length === 0) return;
-    const next = { ...uploadToggles };
-    const autoDisabled = new Set(autoDisabledUploadTrackersRef.current);
-    let changed = false;
-    const setToggle = (name: string, value: boolean) => {
-      if (next[name] !== value) {
-        next[name] = value;
-        changed = true;
-      }
-    };
-    const deleteToggle = (name: string) => {
-      if (Object.prototype.hasOwnProperty.call(next, name)) {
-        delete next[name];
-        changed = true;
-      }
-    };
-
-    trackerUploadItems.forEach((item) => {
-      const normalized = item.name.toLowerCase().trim();
-      const hasReleaseSelection = Object.prototype.hasOwnProperty.call(
-        releasePageTrackerSelection,
-        item.name,
-      );
-      if (hasReleaseSelection && !releasePageTrackerSelection[item.name]) {
-        autoDisabled.delete(normalized);
-        deleteToggle(item.name);
-        return;
-      }
-      if (dupeFiltersMatchCurrentPath && failedDupeTrackerSet.has(normalized)) {
-        autoDisabled.delete(normalized);
-        setToggle(item.name, false);
-        return;
-      }
-      if (dupeFiltersMatchCurrentPath && dupedTrackerSet.has(normalized)) {
-        if (next[item.name] !== false) {
-          autoDisabled.add(normalized);
-        }
-        setToggle(item.name, false);
-        return;
-      }
-      if (dupeFiltersMatchCurrentPath && ruleSkippedTrackerSet.has(normalized)) {
-        autoDisabled.delete(normalized);
-        setToggle(item.name, false);
-        return;
-      }
-      if (dupeFiltersMatchCurrentPath && skippedDupeTrackerSet.has(normalized)) {
-        autoDisabled.delete(normalized);
-        setToggle(item.name, false);
-        return;
-      }
-      if (autoDisabled.has(normalized)) {
-        setToggle(
-          item.name,
-          hasReleaseSelection
-            ? releasePageTrackerSelection[item.name]
-            : defaultTrackerSet.has(normalized),
-        );
-        autoDisabled.delete(normalized);
-        return;
-      }
-      if (next[item.name] === undefined) {
-        // Prioritize release page selection, then fall back to defaults
-        if (hasReleaseSelection) {
-          setToggle(item.name, releasePageTrackerSelection[item.name]);
-        } else {
-          setToggle(item.name, defaultTrackerSet.has(normalized));
-        }
-      }
-    });
-    const trackerNames = new Set(trackerUploadItems.map((item) => item.name));
-    Object.keys(next).forEach((name) => {
-      if (!trackerNames.has(name)) {
-        autoDisabled.delete(name.toLowerCase().trim());
-        deleteToggle(name);
-        return;
-      }
-      if (
-        Object.prototype.hasOwnProperty.call(releasePageTrackerSelection, name) &&
-        !releasePageTrackerSelection[name]
-      ) {
-        autoDisabled.delete(name.toLowerCase().trim());
-        deleteToggle(name);
-      }
-    });
-    autoDisabledUploadTrackersRef.current = autoDisabled;
-    if (changed) {
-      setUploadToggles(next);
-    }
-  }, [
-    trackerUploadItems,
-    defaultTrackerSet,
-    dupeFiltersMatchCurrentPath,
-    dupedTrackerSet,
-    ruleSkippedTrackerSet,
-    skippedDupeTrackerSet,
-    failedDupeTrackerSet,
-    releasePageTrackerSelection,
-    uploadToggles,
-  ]);
-
-  useEffect(() => {
-    if (screenshots.uploadCandidates.length === 0) {
-      setUploadSelections({});
-      return;
-    }
-    setUploadSelections((prev) => {
-      const next: Record<string, boolean> = { ...prev };
-      screenshots.uploadCandidates.forEach((item) => {
-        const pathValue = item.image.Path;
-        if (!pathValue) return;
-        if (next[pathValue] === undefined) {
-          next[pathValue] = true;
-        }
-      });
-      Object.keys(next).forEach((key) => {
-        if (!uploadCandidatePaths.has(key)) {
-          delete next[key];
-        }
-      });
-      return next;
-    });
-  }, [screenshots.uploadCandidates, uploadCandidatePaths, setUploadSelections]);
-
-  useEffect(() => {
-    if (uploadHost || configuredImageHosts.length === 0) return;
-    setUploadHost(configuredImageHosts[0]);
-  }, [configuredImageHosts, uploadHost, setUploadHost]);
-
-  // Initialize release page tracker selection when preview loads or trackers change
-  useEffect(() => {
-    if (trackerUploadItems.length === 0) {
-      setReleasePageTrackerSelection({});
-      return;
-    }
-    setReleasePageTrackerSelection((prev) => {
-      const next = { ...prev };
-      trackerUploadItems.forEach((item) => {
-        const normalized = item.name.toLowerCase();
-        if (next[item.name] === undefined) {
-          // Initialize from defaults
-          next[item.name] = defaultTrackerSet.has(normalized);
-        }
-      });
-      // Remove trackers no longer in the list
-      const trackerNames = trackerUploadItems.map((item) => item.name);
-      Object.keys(next).forEach((name) => {
-        if (!trackerNames.includes(name)) {
-          delete next[name];
-        }
-      });
-      return next;
-    });
-  }, [trackerUploadItems, defaultTrackerSet]);
-
-  useEffect(() => {
-    setTrackerQuestionnaireAnswers({});
-    setTrackerDryRunPreview(emptyTrackerDryRun);
-    setTrackerDryRunError("");
-    setTrackerDryRunProgress(null);
-  }, [path]);
-
-  const getSelectedUploadTrackers = useCallback(
-    () => selectedUploadImageTrackers,
-    [selectedUploadImageTrackers],
-  );
-
-  const updateTrackerQuestionnaireAnswer = useCallback(
-    (tracker: string, key: string, value: string) => {
-      setTrackerQuestionnaireAnswers((prev) => {
-        const trackerKey = tracker.toUpperCase().trim();
-        return {
-          ...prev,
-          [trackerKey]: {
-            ...(prev[trackerKey] || {}),
-            [key]: value,
-          },
-        };
-      });
-    },
-    [],
-  );
-
-  /** Applies an upload job snapshot from either live events or polling fallback. */
-  const applyTrackerUploadSnapshot = useCallback((snapshot: TrackerUploadSnapshot) => {
-    setTrackerUploadSnapshot(snapshot);
-    const normalized = normalizeJobStatus(snapshot.status);
-    const running = isRunningJobStatus(normalized);
-    setTrackerUploadRunning(running);
-    if (normalized === "completed") {
-      setTrackerUploadError("");
-    } else if (
-      normalized === "completed_with_errors" ||
-      normalized === "failed" ||
-      normalized === "canceled"
-    ) {
-      setTrackerUploadError(snapshot.error || "Upload finished with errors.");
-    }
-  }, []);
-
-  const handleStartTrackerUpload = useCallback(async () => {
-    setTrackerUploadError("");
-    const starter = globalThis.go?.guiapp?.App?.StartTrackerUpload;
-    const snapshotLoader = globalThis.go?.guiapp?.App?.GetTrackerUploadSnapshot;
-    if (!starter) {
-      setTrackerUploadError("Tracker upload is unavailable in this build.");
-      return;
-    }
-    if (!path.trim()) {
-      setTrackerUploadError("Please select a file or folder.");
-      return;
-    }
-    if (idOverrideState?.invalid || releaseOverrideState?.invalid) {
-      setTrackerUploadError("Fix invalid overrides before uploading.");
-      return;
-    }
-    const selectedTrackers = getSelectedUploadTrackers();
-    if (selectedTrackers.length === 0) {
-      setTrackerUploadError("Enable at least one tracker in Upload Targets.");
-      return;
-    }
-    const missingRequiredFields: string[] = [];
-    selectedTrackers.forEach((tracker) => {
-      const dryRunEntry = (trackerDryRunPreview.Trackers || []).find(
-        (entry) =>
-          String(entry?.Tracker || "")
-            .toLowerCase()
-            .trim() === tracker.toLowerCase().trim(),
-      );
-      const questionnaire = dryRunEntry?.Questionnaire;
-      if (!questionnaire?.Fields?.length) {
-        return;
-      }
-      const trackerAnswers = buildQuestionnaireAnswerDefaults(
-        questionnaire,
-        trackerQuestionnaireAnswers[tracker.toUpperCase().trim()],
-      );
-      questionnaire.Fields.forEach((field) => {
-        if (field.Required && !String(trackerAnswers[field.Key] || "").trim()) {
-          missingRequiredFields.push(`${tracker}: ${field.Label || field.Key}`);
-        }
-      });
-    });
-    if (missingRequiredFields.length > 0) {
-      setTrackerUploadError(
-        `Complete required questionnaire fields before uploading: ${missingRequiredFields.join(", ")}`,
-      );
-      return;
-    }
-    setTrackerUploadRunning(true);
-    setTrackerUploadSnapshot(null);
-    let jobID = "";
-    try {
-      jobID = await starter(
-        path.trim(),
-        normalizeOverrides(idOverrideState?.overrides || {}),
-        normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        selectedTrackers,
-        ignoredDupeTrackers,
-        cloneQuestionnaireAnswers(trackerQuestionnaireAnswers),
-        builderPreview.Groups || [],
-        runDebug,
-        uploadSkipClientInjection,
-        runLogLevel,
-      );
-    } catch (err) {
-      setTrackerUploadRunning(false);
-      setTrackerUploadError(String(err));
-      return;
-    }
-    setTrackerUploadJobID(jobID);
-    if (snapshotLoader) {
-      try {
-        const snapshot = await snapshotLoader(jobID);
-        applyTrackerUploadSnapshot(snapshot);
-      } catch {
-        // Events and polling continue tracking the started job when bootstrap refresh fails.
-      }
-    }
-  }, [
-    path,
-    idOverrideState,
-    releaseOverrideState,
-    getSelectedUploadTrackers,
-    ignoredDupeTrackers,
-    trackerDryRunPreview,
-    trackerQuestionnaireAnswers,
-    builderPreview,
-    runDebug,
-    uploadSkipClientInjection,
-    runLogLevel,
-    applyTrackerUploadSnapshot,
-  ]);
-
-  const runTrackerDryRun = useCallback(
-    async (descriptionGroups: DescriptionBuilderPreview["Groups"], surfaceError = true) => {
-      if (surfaceError) {
-        setTrackerDryRunError("");
-      }
-      const fetcher = globalThis.go?.guiapp?.App?.FetchTrackerDryRun;
-      if (!fetcher) {
-        const message = "Tracker dry run is unavailable in this build.";
-        if (surfaceError) {
-          setTrackerDryRunError(message);
-          return null;
-        }
-        throw new Error(message);
-      }
-      if (!path.trim()) {
-        const message = "Please select a file or folder.";
-        if (surfaceError) {
-          setTrackerDryRunError(message);
-          return null;
-        }
-        throw new Error(message);
-      }
-      if (idOverrideState?.invalid || releaseOverrideState?.invalid) {
-        const message = "Fix invalid overrides before running dry run.";
-        if (surfaceError) {
-          setTrackerDryRunError(message);
-          return null;
-        }
-        throw new Error(message);
-      }
-      const selectedTrackers = getSelectedUploadTrackers();
-      if (selectedTrackers.length === 0) {
-        const message = "Enable at least one tracker in Upload Targets.";
-        if (surfaceError) {
-          setTrackerDryRunError(message);
-          return null;
-        }
-        throw new Error(message);
-      }
-
-      setTrackerDryRunLoading(true);
-      setTrackerDryRunProgress({
-        sourcePath: path.trim(),
-        tracker: "",
-        task: "dry_run",
-        status: "running",
-        message: "Starting dry run",
-        completedPieces: 0,
-        totalPieces: 0,
-        percent: 0,
-        hashRateMiB: 0,
-        timestamp: new Date().toISOString(),
-      });
-      try {
-        const result = await fetcher(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-          selectedTrackers,
-          ignoredDupeTrackers,
-          cloneQuestionnaireAnswers(trackerQuestionnaireAnswers),
-          descriptionGroups,
-          runDebug,
-          uploadSkipClientInjection,
-          runLogLevel,
-        );
-        setTrackerDryRunPreview(result || emptyTrackerDryRun);
-        setTrackerQuestionnaireAnswers((prev) => {
-          const next = cloneQuestionnaireAnswers(prev);
-          (result?.Trackers || []).forEach((entry) => {
-            const trackerKey = String(entry?.Tracker || "")
-              .toUpperCase()
-              .trim();
-            if (!trackerKey) {
-              return;
-            }
-            next[trackerKey] = buildQuestionnaireAnswerDefaults(
-              entry.Questionnaire,
-              next[trackerKey],
-            );
-          });
-          return next;
-        });
-        return result || emptyTrackerDryRun;
-      } catch (err) {
-        if (surfaceError) {
-          setTrackerDryRunError(String(err));
-          return null;
-        }
-        throw err;
-      } finally {
-        setTrackerDryRunLoading(false);
-      }
-    },
-    [
-      path,
-      idOverrideState,
-      releaseOverrideState,
-      getSelectedUploadTrackers,
-      ignoredDupeTrackers,
-      trackerQuestionnaireAnswers,
-      runDebug,
-      uploadSkipClientInjection,
-      runLogLevel,
-    ],
-  );
-
-  const handleRunTrackerDryRun = useCallback(async () => {
-    await runTrackerDryRun(builderPreview.Groups || []);
-  }, [builderPreview, runTrackerDryRun]);
-
-  useEffect(() => {
-    const off = EventsOn(trackerUploadProgressEvent, (payload: any) => {
-      const update = payload as UploadProgressUpdate;
-      const updatePath = String(update?.sourcePath || "").trim();
-      if (updatePath && updatePath !== path.trim()) {
-        return;
-      }
-      setTrackerDryRunProgress(update);
-    });
-
-    return () => {
-      if (typeof off === "function") {
-        off();
-      }
-    };
-  }, [path]);
-
-  const handleCancelTrackerUpload = useCallback(async () => {
-    setTrackerUploadError("");
-    if (!trackerUploadJobID) {
-      return;
-    }
-    const cancel = globalThis.go?.guiapp?.App?.CancelTrackerUpload;
-    if (!cancel) {
-      setTrackerUploadError("Tracker upload cancel is unavailable in this build.");
-      return;
-    }
-    try {
-      await cancel(trackerUploadJobID);
-    } catch (err) {
-      setTrackerUploadError(String(err));
-    }
-  }, [trackerUploadJobID]);
-
-  const handleRetryFailedTrackerUpload = useCallback(async () => {
-    setTrackerUploadError("");
-    if (!trackerUploadJobID) {
-      return;
-    }
-    const retry = globalThis.go?.guiapp?.App?.RetryFailedTrackerUpload;
-    const snapshotLoader = globalThis.go?.guiapp?.App?.GetTrackerUploadSnapshot;
-    if (!retry) {
-      setTrackerUploadError("Tracker retry is unavailable in this build.");
-      return;
-    }
-    setTrackerUploadRunning(true);
-    let nextJobID = "";
-    try {
-      nextJobID = await retry(trackerUploadJobID);
-    } catch (err) {
-      setTrackerUploadRunning(false);
-      setTrackerUploadError(String(err));
-      return;
-    }
-    setTrackerUploadJobID(nextJobID);
-    setTrackerUploadSnapshot(null);
-    if (snapshotLoader) {
-      try {
-        const snapshot = await snapshotLoader(nextJobID);
-        applyTrackerUploadSnapshot(snapshot);
-      } catch {
-        // Events and polling continue tracking the replacement job when bootstrap refresh fails.
-      }
-    }
-  }, [applyTrackerUploadSnapshot, trackerUploadJobID]);
-
-  useEffect(() => {
-    if (!trackerUploadJobID) {
-      return;
-    }
-
-    const eventName = `${trackerUploadEventPrefix}${trackerUploadJobID}`;
-    const off = EventsOn(eventName, (payload: any) => {
-      if (payload?.jobID !== trackerUploadJobID) {
-        return;
-      }
-      applyTrackerUploadSnapshot(payload as TrackerUploadSnapshot);
-    });
-
-    return () => {
-      if (typeof off === "function") {
-        off();
-      }
-    };
-  }, [applyTrackerUploadSnapshot, trackerUploadJobID]);
-
-  useEffect(() => {
-    // Poll active upload jobs as a fallback for missed upload snapshot events.
-    const currentStatus = String(trackerUploadSnapshot?.status || "");
-    if (!trackerUploadJobID || (!trackerUploadRunning && !isRunningJobStatus(currentStatus))) {
-      return;
-    }
-    const snapshotLoader = globalThis.go?.guiapp?.App?.GetTrackerUploadSnapshot;
-    if (!snapshotLoader) {
-      return;
-    }
-
-    let stopped = false;
-    let timer: number | undefined;
-    const loadSnapshot = async () => {
-      try {
-        const snapshot = await snapshotLoader(trackerUploadJobID);
-        if (!stopped) {
-          applyTrackerUploadSnapshot(snapshot);
-        }
-      } catch {
-        // Event delivery remains primary; transient polling failures should not replace UI errors.
-      }
-      if (!stopped) {
-        timer = window.setTimeout(loadSnapshot, 1000);
-      }
-    };
-
-    timer = window.setTimeout(loadSnapshot, 1000);
-    return () => {
-      stopped = true;
-      if (timer !== undefined) {
-        window.clearTimeout(timer);
-      }
-    };
-  }, [
-    applyTrackerUploadSnapshot,
-    trackerUploadJobID,
-    trackerUploadRunning,
-    trackerUploadSnapshot?.status,
-  ]);
-
-  const markReleaseTouched = (key: keyof ReleaseNameTouchedState) => {
-    setReleaseTouched((prev) => ({ ...prev, [key]: true }));
-  };
-
-  const applyScreenshotSettings = async () => {
-    screenshots.setScreenshotsError("");
-    clearSettingsStatus();
-    const saveConfig = globalThis.go?.guiapp?.App?.SaveConfig;
-    if (!saveConfig) {
-      screenshots.setScreenshotsError("Settings are unavailable in this build.");
-      return;
-    }
-    const payload = buildSavePayload();
-    if (!payload) {
-      screenshots.setScreenshotsError("Settings are not loaded.");
-      return;
-    }
-    setScreenshotsSettingsSaving(true);
-    try {
-      await saveConfig(payload);
-      markSettingsSaved("Settings saved and applied.");
-      await warmMetadataCache();
-      await screenshots.loadScreenshotPlan();
-    } catch (err) {
-      screenshots.setScreenshotsError(String(err));
-    } finally {
-      setScreenshotsSettingsSaving(false);
-    }
-  };
-
-  const showConfigOpStatus = useCallback((status: NonNullable<typeof configOpStatus>) => {
-    if (configOpTimerRef.current) clearTimeout(configOpTimerRef.current);
-    setConfigOpStatus(status);
-    if (status.type === "success") {
-      configOpTimerRef.current = setTimeout(() => setConfigOpStatus(null), 8000);
-    }
-  }, []);
-
-  const dismissConfigOpStatus = useCallback(() => {
-    if (configOpTimerRef.current) clearTimeout(configOpTimerRef.current);
-    setConfigOpStatus(null);
-  }, []);
-
-  useEffect(() => {
-    return () => {
-      if (configOpTimerRef.current) clearTimeout(configOpTimerRef.current);
-    };
-  }, []);
-
-  const handleExportSettings = async () => {
-    clearSettingsStatus();
-    dismissConfigOpStatus();
-    const exportConfig = globalThis.go?.guiapp?.App?.ExportConfig;
-    if (!exportConfig) {
-      showConfigOpStatus({
-        type: "error",
-        title: "Export Failed",
-        message: "Settings export is unavailable in this build.",
-      });
-      return;
-    }
-
-    setSettingsExporting(true);
-    try {
-      const exportedPath = await exportConfig();
-      if (exportedPath?.trim()) {
-        showConfigOpStatus({
-          type: "success",
-          title: "Configuration Exported",
-          message: `Saved to ${exportedPath}`,
-        });
-      }
-    } catch (err) {
-      showConfigOpStatus({ type: "error", title: "Export Failed", message: String(err) });
-    } finally {
-      setSettingsExporting(false);
-    }
-  };
-
-  const handleImportConfigRequest = () => {
-    clearSettingsStatus();
-    dismissConfigOpStatus();
-    setImportConfirmOpen(true);
-  };
-
-  const handleImportConfigCancel = () => {
-    if (settingsImporting) return;
-    setImportConfirmOpen(false);
-  };
-
-  const handleImportConfigConfirm = async () => {
-    const importConfig = globalThis.go?.guiapp?.App?.ImportConfig;
-    if (!importConfig) {
-      setImportConfirmOpen(false);
-      showConfigOpStatus({
-        type: "error",
-        title: "Import Failed",
-        message: "Config import is unavailable in this build.",
-      });
-      return;
-    }
-
-    setSettingsImporting(true);
-    try {
-      const result = await importConfig();
-      const message = (result?.message ?? "").trim();
-      if (!message) {
-        return;
-      }
-      const warnings = result?.warnings ?? [];
-      if (warnings.length > 0) {
-        showConfigOpStatus({ type: "warning", title: "Imported with Warnings", message, warnings });
-      } else {
-        showConfigOpStatus({ type: "success", title: "Configuration Imported", message });
-      }
-      loadSettings();
-    } catch (err) {
-      showConfigOpStatus({ type: "error", title: "Import Failed", message: String(err) });
-    } finally {
-      setSettingsImporting(false);
-      setImportConfirmOpen(false);
-    }
-  };
-
-  const loadWebAuthStatus = useCallback(async () => {
-    const getWebAuthStatus = globalThis.go?.guiapp?.App?.GetWebAuthStatus;
-    if (!getWebAuthStatus) {
-      setWebAuthStatus(null);
-      setWebAuthError("");
-      return;
-    }
-
-    setWebAuthLoading(true);
-    setWebAuthError("");
-    try {
-      const status = await getWebAuthStatus();
-      setWebAuthStatus(status);
-    } catch (err) {
-      setWebAuthStatus({ ...emptyWebAuthStatus, message: "Unable to load web auth status." });
-      setWebAuthError(String(err));
-    } finally {
-      setWebAuthLoading(false);
-    }
-  }, []);
-
-  const handleCreateWebAuth = useCallback(async () => {
-    clearSettingsStatus();
-    dismissConfigOpStatus();
-    setWebAuthError("");
-
-    if (webAuthPassword !== webAuthConfirm) {
-      setWebAuthError("Passwords do not match.");
-      return;
-    }
-
-    const createWebAuth = globalThis.go?.guiapp?.App?.CreateWebAuth;
-    if (!createWebAuth) {
-      setWebAuthError("Web auth bootstrap is unavailable in this build.");
-      return;
-    }
-
-    setWebAuthCreating(true);
-    try {
-      const status = await createWebAuth(webAuthUsername, webAuthPassword);
-      setWebAuthStatus(status);
-      setWebAuthPassword("");
-      setWebAuthConfirm("");
-      markSettingsSaved("Web auth created. Future secret saves and exports can use encryption.");
-    } catch (err) {
-      setWebAuthError(String(err));
-    } finally {
-      setWebAuthCreating(false);
-    }
-  }, [
-    clearSettingsStatus,
-    dismissConfigOpStatus,
-    markSettingsSaved,
-    webAuthConfirm,
-    webAuthPassword,
-    webAuthUsername,
-  ]);
-
-  useEffect(() => {
-    if (activeTab !== "settings") {
-      return;
-    }
-    loadWebAuthStatus();
-  }, [activeTab, loadWebAuthStatus]);
-
-  const dupeProgressStatus = String(dupeCheckSnapshot?.status || "").toLowerCase();
-  const dupeCompletedCount = Number(dupeCheckSnapshot?.completedCount || 0);
-  const dupeTotalCount = Number(dupeCheckSnapshot?.totalCount || 0);
-
-  return (
-    <div className="app-shell">
-      <div className="gradient-orb orb-a" />
-      <div className="gradient-orb orb-b" />
-      <div className={appLayoutClass}>
-        <aside className={sidebarClass}>
-          <div className={sidebarGroupClass}>
-            <button
-              className={navButtonClass(activeTab === "input")}
-              type="button"
-              onClick={() => setActiveTab("input")}
-            >
-              Input
-            </button>
-            {hasTrackerData ? (
-              <button
-                className={navButtonClass(activeTab === "tracker", true)}
-                type="button"
-                onClick={() => setActiveTab("tracker")}
-              >
-                Tracker Data
-              </button>
-            ) : null}
-            {hasBlurayData ? (
-              <button
-                className={navButtonClass(activeTab === "bluray", true)}
-                type="button"
-                onClick={() => setActiveTab("bluray")}
-              >
-                Blu-ray.com
-              </button>
-            ) : null}
-            {hasPreview ? (
-              <button
-                className={navButtonClass(activeTab === "dupes", true)}
-                type="button"
-                onClick={() => setActiveTab("dupes")}
-              >
-                Dupe Checking
-              </button>
-            ) : null}
-            {dupeChecked ? (
-              <button
-                className={navButtonClass(activeTab === "screenshots", true)}
-                type="button"
-                onClick={() => setActiveTab("screenshots")}
-              >
-                Screenshots
-              </button>
-            ) : null}
-            {dupeChecked && ["BDMV", "DVD", "HDDVD"].includes(currentDiscType) ? (
-              <button
-                className={`subtab-button ${activeTab === "menu_images" ? "active" : ""}`}
-                type="button"
-                onClick={() => setActiveTab("menu_images")}
-              >
-                Menu Images
-              </button>
-            ) : null}
-            {dupeChecked ? (
-              <button
-                className={navButtonClass(activeTab === "upload_images", true)}
-                type="button"
-                onClick={() => setActiveTab("upload_images")}
-              >
-                Upload Images
-              </button>
-            ) : null}
-            {dupeChecked ? (
-              <button
-                className={navButtonClass(activeTab === "description_builder", true)}
-                type="button"
-                onClick={() => setActiveTab("description_builder")}
-              >
-                Description Builder
-              </button>
-            ) : null}
-            {builderReady ? (
-              <button
-                className={navButtonClass(activeTab === "upload", true)}
-                type="button"
-                onClick={() => setActiveTab("upload")}
-              >
-                Tracker Upload
-              </button>
-            ) : null}
-          </div>
-          <div className={sidebarFooterClass}>
-            <button
-              className={sidebarButtonClass(activeTab === "settings")}
-              type="button"
-              onClick={() => setActiveTab("settings")}
-            >
-              <span>Settings</span>
-            </button>
-            <button
-              className={sidebarButtonClass(activeTab === "logging")}
-              type="button"
-              onClick={() => setActiveTab("logging")}
-            >
-              <span>Logging</span>
-            </button>
-            <button
-              className={sidebarButtonClass(activeTab === "history")}
-              type="button"
-              onClick={() => setActiveTab("history")}
-            >
-              <span>History</span>
-            </button>
-            <button
-              className={cn(sidebarButtonClass(), "mt-0")}
-              type="button"
-              onClick={handleThemeToggle}
-            >
-              <span className="mr-0.5 text-base">{getThemeIcon()}</span>
-              <span>{getThemeLabel()}</span>
-            </button>
-            <div className={sidebarAppDetailsClass}>
-              <div className="grid min-w-0 gap-0.5">
-                {applicationInfo?.version ? (
-                  <span className="min-w-0 overflow-hidden text-ellipsis whitespace-nowrap font-semibold text-[var(--text)]">
-                    {applicationInfo.version}
-                  </span>
-                ) : null}
-                <span className="min-w-0 overflow-hidden text-ellipsis whitespace-nowrap">
-                  © 2026 autobrr
-                </span>
-              </div>
-              <a
-                className="inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-md border border-white/10 text-[var(--muted)] transition hover:border-[var(--accent)] hover:text-[var(--accent)]"
-                href="https://github.com/autobrr/upbrr"
-                target="_blank"
-                rel="noreferrer"
-                onAuxClick={handleExternalLinkClick}
-                onClick={handleExternalLinkClick}
-                aria-label="Open autobrr/upbrr on GitHub"
-                title="autobrr/upbrr"
-              >
-                <svg aria-hidden="true" viewBox="0 0 16 16" className="h-4 w-4" fill="currentColor">
-                  <path d="M8 0C3.58 0 0 3.67 0 8.2c0 3.62 2.29 6.69 5.47 7.78.4.08.55-.18.55-.4l-.01-1.4c-2.22.5-2.69-1.1-2.69-1.1-.36-.95-.89-1.2-.89-1.2-.73-.51.05-.5.05-.5.81.06 1.24.85 1.24.85.72 1.27 1.89.9 2.35.69.07-.53.28-.9.51-1.1-1.78-.21-3.64-.91-3.64-4.04 0-.89.31-1.62.82-2.19-.08-.21-.36-1.04.08-2.16 0 0 .68-.22 2.2.84A7.37 7.37 0 0 1 8 3.99c.68 0 1.36.09 2 .28 1.52-1.06 2.19-.84 2.19-.84.44 1.12.16 1.95.08 2.16.52.57.82 1.3.82 2.19 0 3.14-1.87 3.83-3.65 4.04.29.25.54.76.54 1.54l-.01 2.22c0 .22.14.48.55.4A8.13 8.13 0 0 0 16 8.2C16 3.67 12.42 0 8 0Z" />
-                </svg>
-              </a>
-            </div>
-          </div>
-        </aside>
-
-        <main className="content">
-          {showPlaylistSelection ? (
-            <PlaylistSelectionPage
-              path={playlistSelectionPath}
-              onBack={() => {
-                setShowPlaylistSelection(false);
-                setPlaylistPreparationTrackerSnapshot(null);
-              }}
-              onConfirm={handlePlaylistSelectionComplete}
-              preparing={playlistAutoPreparing}
-              progressLines={bdinfoProgressLines}
-              progressError={playlistPreparationError}
-            />
-          ) : activeTab === "settings" ? (
-            <SettingsPage
-              configData={configData}
-              settingsLoading={settingsLoading}
-              settingsExporting={settingsExporting}
-              settingsImporting={settingsImporting}
-              settingsDirty={settingsDirty}
-              settingsSaved={settingsSaved}
-              settingsError={settingsError}
-              configOpStatus={configOpStatus}
-              dismissConfigOpStatus={dismissConfigOpStatus}
-              settingsSection={settingsSection}
-              settingsSections={settingsSections}
-              trackerSelectionNames={trackerSelectionNames}
-              showAdvancedToggle={showAdvancedToggle}
-              advancedOpen={advancedOpen}
-              setSettingsSection={setSettingsSection}
-              setSettingsAdvanced={setSettingsAdvanced}
-              loadSettings={loadSettings}
-              handleExportSettings={handleExportSettings}
-              handleImportConfig={handleImportConfigRequest}
-              importConfirmOpen={importConfirmOpen}
-              handleImportConfigConfirm={handleImportConfigConfirm}
-              handleImportConfigCancel={handleImportConfigCancel}
-              handleSaveSettings={handleSaveSettings}
-              webAuthAvailable={Boolean(globalThis.go?.guiapp?.App?.GetWebAuthStatus)}
-              webAuthStatus={webAuthStatus}
-              webAuthLoading={webAuthLoading}
-              webAuthCreating={webAuthCreating}
-              webAuthUsername={webAuthUsername}
-              webAuthPassword={webAuthPassword}
-              webAuthConfirm={webAuthConfirm}
-              webAuthError={webAuthError}
-              setWebAuthUsername={setWebAuthUsername}
-              setWebAuthPassword={setWebAuthPassword}
-              setWebAuthConfirm={setWebAuthConfirm}
-              handleCreateWebAuth={handleCreateWebAuth}
-              renderImageHostingSection={renderImageHostingSection}
-              renderTrackerSection={renderTrackerSection}
-              renderTorrentClientsSection={renderTorrentClientsSection}
-              renderField={renderField}
-              sectionFieldMeta={sectionFieldMeta}
-            />
-          ) : activeTab === "logging" ? (
-            <LoggingPage
-              configData={configData}
-              settingsLoading={settingsLoading}
-              settingsDirty={settingsDirty}
-              settingsSaved={settingsSaved}
-              settingsError={settingsError}
-              loadSettings={loadSettings}
-              handleSaveSettings={handleSaveSettings}
-              renderField={renderField}
-              updateConfigValue={updateConfigValue}
-              sectionFieldMeta={sectionFieldMeta}
-            />
-          ) : activeTab === "history" ? (
-            <HistoryPage onReleaseDeleted={handleHistoryReleaseDeleted} />
-          ) : activeTab === "dupes" ? (
-            <DupeCheckPage
-              path={path}
-              dupeLoading={dupeLoading}
-              dupeError={dupeError}
-              dupeSummary={dupeSummary}
-              dupeTrackerStates={dupeCheckSnapshot?.trackers || []}
-              dupeTrackerFlags={dupeTrackerFlags}
-              dupeIgnore={dupeIgnore}
-              ruleSkippedTrackerSet={ruleSkippedTrackerSet}
-              skippedDupeReasons={skippedDupeReasons}
-              ruleSkipReasons={ruleSkipReasons}
-              dupeProgressStatus={dupeProgressStatus}
-              dupeCompletedCount={dupeCompletedCount}
-              dupeTotalCount={dupeTotalCount}
-              useFavicons={useFavicons}
-              faviconOnly={faviconOnly}
-              trackerIconSrcByName={trackerIconSrcByName}
-              handleDupeCheck={handleDupeCheck}
-              setDupeIgnore={setDupeIgnore}
-            />
-          ) : activeTab === "screenshots" ? (
-            <ScreenshotsPage
-              path={path}
-              screenshotPlan={screenshots.screenshotPlan}
-              screenshotsLoading={screenshots.screenshotsLoading}
-              screenshotsError={screenshots.screenshotsError}
-              loadScreenshotPlan={screenshots.loadScreenshotPlan}
-              handleGenerateScreenshots={handleGenerateScreenshots}
-              screenshotConfig={screenshotConfig}
-              updateScreenshotConfigValue={updateScreenshotConfigValue}
-              loadSettings={loadSettings}
-              settingsLoading={settingsLoading}
-              applyScreenshotSettings={applyScreenshotSettings}
-              settingsDirty={settingsDirty}
-              screenshotsSettingsSaving={screenshotsSettingsSaving}
-              livePreviewSeconds={livePreviewSeconds}
-              setLivePreviewSeconds={setLivePreviewSeconds}
-              livePreviewFrame={livePreviewFrame}
-              previewDuration={previewDuration}
-              previewFrameRate={previewFrameRate}
-              clampPreviewSeconds={clampPreviewSeconds}
-              stepLivePreview={stepLivePreview}
-              runLivePreview={runLivePreview}
-              livePreviewLoading={livePreviewLoading}
-              liveCaptureLoading={liveCaptureLoading}
-              handleCapturePreviewFrame={handleCapturePreviewFrame}
-              livePreviewError={livePreviewError}
-              livePreviewImage={livePreviewImage}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-              trackerImageURLs={trackerImageURLs}
-              handleDeleteAllTrackerImageURLs={handleDeleteAllTrackerImageURLs}
-              handleDeleteTrackerImage={screenshots.handleDeleteTrackerImage}
-              existingImages={screenshots.existingImages}
-              addFinalSelection={screenshots.addFinalSelection}
-              isFinalImageSelected={screenshots.isFinalImageSelected}
-              removeFinalSelection={screenshots.removeFinalSelection}
-              handleDeleteAllExistingImages={screenshots.handleDeleteAllExistingImages}
-              handleDeleteExistingImage={handleDeleteExistingImage}
-              existingTrackerImages={screenshots.existingTrackerImages}
-              handleDeleteAllTrackerImages={screenshots.handleDeleteAllTrackerImages}
-              showFrameSelections={screenshots.showFrameSelections}
-              screenshotSelections={screenshots.screenshotSelections}
-              updateSelectionTime={screenshots.updateSelectionTime}
-              updateSelectionFrame={screenshots.updateSelectionFrame}
-              handlePreviewSelection={handlePreviewSelection}
-              previewLoadingIndex={screenshots.previewLoadingIndex}
-              previewImages={screenshots.previewImages}
-              handleDeleteAllPreviewImages={screenshots.handleDeleteAllPreviewImages}
-              finalImages={screenshots.finalImages}
-              finalDragIndex={finalDragIndex}
-              setFinalDragIndex={setFinalDragIndex}
-              reorderFinalSelections={screenshots.reorderFinalSelections}
-              finalResult={screenshots.finalResult}
-              handleDeleteAllFinalImages={screenshots.handleDeleteAllFinalImages}
-            />
-          ) : activeTab === "menu_images" ? (
-            <MenuImagesPage
-              path={path}
-              overrides={idOverrideState?.overrides || {}}
-              nameOverrides={releaseOverrideState?.overrides || {}}
-              currentDiscType={currentDiscType}
-              maxMenuItems={maxMenuItems}
-              browseAvailable={browserNativeBrowseAvailable}
-              onImagesChanged={markImageAssetsChanged}
-              onContinue={() => setActiveTab("upload_images")}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-            />
-          ) : activeTab === "upload_images" ? (
-            <UploadImagesPage
-              path={path}
-              uploadHost={uploadImages.uploadHost}
-              setUploadHost={uploadImages.setUploadHost}
-              configuredImageHosts={configuredImageHosts}
-              resolveImageHostLabel={resolveImageHostLabel}
-              uploadImagesLoading={uploadImages.uploadImagesLoading}
-              uploadProgress={uploadImages.uploadProgress}
-              setAllUploadSelections={uploadImages.setAllUploadSelections}
-              handleUploadImages={handleUploadImagesWithRevision}
-              uploadImagesError={uploadImages.uploadImagesError}
-              uploadImageFailures={uploadImages.uploadImageFailures}
-              uploadCandidates={screenshots.uploadCandidates}
-              uploadSelections={uploadImages.uploadSelections}
-              toggleUploadSelection={uploadImages.toggleUploadSelection}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-              uploadedRecordByPath={uploadImages.uploadedRecordByPath}
-              uploadedImages={uploadImages.uploadedImages}
-              uploadedImageRecords={uploadImages.uploadedImageRecords}
-              trackerImageLinks={screenshots.trackerImageLinks}
-              trackerImageURLs={trackerImageURLs}
-              handleDeleteUploadedImage={handleDeleteUploadedImageWithRevision}
-              handleDeleteTrackerImage={screenshots.handleDeleteTrackerImage}
-            />
-          ) : activeTab === "bluray" ? (
-            <BlurayCandidatesPage
-              preview={preview}
-              selecting={bluraySelecting}
-              error={bluraySelectionError}
-              onSelect={(releaseID) => void handleSelectBlurayCandidate(releaseID)}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-            />
-          ) : activeTab === "description_builder" ? (
-            <DescriptionBuilderPage
-              path={path}
-              builderPreview={builderPreview}
-              builderRawByGroup={builderRawByGroup}
-              builderRenderedByGroup={builderRenderedByGroup}
-              builderExpandedGroups={builderExpandedGroups}
-              builderLoading={builderLoading}
-              builderSaving={builderSaving}
-              builderRenderLoading={builderRenderLoading}
-              builderRefreshing={builderRefreshing}
-              builderProgressMessage={builderProgressMessage}
-              builderError={builderError}
-              builderSaved={builderSaved}
-              useFavicons={useFavicons}
-              faviconOnly={faviconOnly}
-              trackerIconSrcByName={trackerIconSrcByName}
-              refreshDescriptionBuilder={refreshDescriptionBuilder}
-              setBuilderRawByGroup={setBuilderRawByGroup}
-              setBuilderDirtyByGroup={setBuilderDirtyByGroup}
-              setBuilderExpandedGroups={setBuilderExpandedGroups}
-              resetBuilderDescription={(groupKey) =>
-                resetBuilderDescription(
-                  groupKey,
-                  idOverrideState?.overrides || {},
-                  releaseOverrideState?.overrides || {},
-                )
-              }
-              renderBuilderDescription={renderBuilderDescription}
-              saveBuilderDescription={saveBuilderDescription}
-            />
-          ) : activeTab === "upload" ? (
-            <TrackerUploadPage
-              trackerUploadItems={trackerUploadItems}
-              releasePageTrackerSelection={releasePageTrackerSelection}
-              dupedTrackerSet={dupedTrackerSet}
-              skippedDupeReasons={skippedDupeReasons}
-              skippedDupeTrackerSet={skippedDupeTrackerSet}
-              ruleSkipReasons={ruleSkipReasons}
-              ruleSkippedTrackerSet={ruleSkippedTrackerSet}
-              failedDupeTrackerSet={failedDupeTrackerSet}
-              uploadToggles={uploadToggles}
-              setUploadToggles={setUploadToggles}
-              skipClientInjection={uploadSkipClientInjection}
-              setSkipClientInjection={setUploadSkipClientInjection}
-              namingOverrides={namingOverrides}
-              preview={preview}
-              formatLabel={formatLabel}
-              uploadRunning={trackerUploadRunning}
-              uploadError={trackerUploadError}
-              uploadSnapshot={trackerUploadSnapshot}
-              dryRunLoading={trackerDryRunLoading}
-              dryRunError={trackerDryRunError}
-              dryRunProgress={trackerDryRunProgress}
-              dryRunPreview={trackerDryRunPreview}
-              trackerQuestionnaireAnswers={trackerQuestionnaireAnswers}
-              useFavicons={useFavicons}
-              faviconOnly={faviconOnly}
-              trackerIconSrcByName={trackerIconSrcByName}
-              onQuestionnaireAnswerChange={updateTrackerQuestionnaireAnswer}
-              onRunDryRun={handleRunTrackerDryRun}
-              onStartUpload={handleStartTrackerUpload}
-              onCancelUpload={handleCancelTrackerUpload}
-              onRetryFailed={handleRetryFailedTrackerUpload}
-            />
-          ) : activeTab === "tracker" && hasTrackerData ? (
-            <TrackerDataPage
-              preview={preview}
-              renderedDescriptions={renderedDescriptions}
-              setRenderedDescriptions={setRenderedDescriptions}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-              useFavicons={useFavicons}
-              faviconOnly={faviconOnly}
-              trackerIconSrcByName={trackerIconSrcByName}
-            />
-          ) : (
-            <InputPage
-              path={path}
-              handleSourcePathChange={handleSourcePathChange}
-              sourcePathHistory={sourcePathHistory}
-              handleSourcePathHistorySelect={handleSourcePathHistorySelect}
-              sourceLookupURL={sourceLookupURL}
-              setSourceLookupURL={setSourceLookupURL}
-              browseAvailable={browserMode || browserNativeBrowseAvailable}
-              handleBrowseFile={handleBrowseFile}
-              handleBrowseFolder={handleBrowseFolder}
-              handleFetch={handleFetch}
-              handleRefresh={handleRefresh}
-              handleResetMetadata={handleResetMetadata}
-              loading={loading}
-              metadataResetting={metadataResetting}
-              metadataProgressActive={metadataProgressActive}
-              metadataProgressUpdates={metadataProgressUpdates}
-              error={error}
-              preview={preview}
-              trackerUploadItems={trackerUploadItems}
-              releasePageTrackerSelection={releasePageTrackerSelection}
-              setReleasePageTrackerSelection={setReleasePageTrackerSelection}
-              idEdits={idEdits}
-              setIdEdits={setIdEdits}
-              markIDTouched={(key) =>
-                setIdTouched((previous) => ({
-                  ...previous,
-                  [key]: true,
-                }))
-              }
-              releaseEdits={releaseEdits}
-              setReleaseEdits={setReleaseEdits}
-              markReleaseTouched={markReleaseTouched}
-              idOverrideState={idOverrideState}
-              releaseOverrideState={releaseOverrideState}
-              showExternalIDInputUI={showExternalIDInputUI}
-              refreshDisabled={refreshDisabled}
-              selectedProvider={selectedProvider}
-              setSelectedProvider={setSelectedProvider}
-              setLightboxImage={setLightboxImage}
-              setLightboxAlt={setLightboxAlt}
-              runDebug={runDebug}
-              setRunDebug={setRunDebug}
-              runLogLevel={runLogLevel}
-              setRunLogLevel={setRunLogLevel}
-              runLogLevelTouched={runLogLevelTouched}
-              setRunLogLevelTouched={setRunLogLevelTouched}
-              useFavicons={useFavicons}
-              faviconOnly={faviconOnly}
-              trackerIconSrcByName={trackerIconSrcByName}
-            />
-          )}
-        </main>
-        <Dialog.Root
-          open={Boolean(lightboxImage)}
-          onOpenChange={(open) => {
-            if (!open) {
-              setLightboxImage("");
-              setLightboxAlt("");
-            }
-          }}
-        >
-          <Dialog.Portal>
-            <Dialog.Overlay className="lightbox-overlay" />
-            <Dialog.Content className={`lightbox-content ${lightboxFit ? "fit" : "native"}`}>
-              <Dialog.Title className="sr-only">{lightboxAlt || "Preview"}</Dialog.Title>
-              <div className="lightbox-toolbar">
-                <button
-                  className="lightbox-toggle"
-                  type="button"
-                  onClick={() => setLightboxFit((prev) => !prev)}
-                >
-                  {lightboxFit ? "Actual size" : "Fit to screen"}
-                </button>
-              </div>
-              <img className="lightbox-image" src={lightboxImage} alt={lightboxAlt || "Preview"} />
-            </Dialog.Content>
-          </Dialog.Portal>
-        </Dialog.Root>
-        <Dialog.Root
-          open={Boolean(hostBrowserMode)}
-          onOpenChange={(open) => {
-            if (!open) closeHostBrowser();
-          }}
-        >
-          <Dialog.Portal>
-            <Dialog.Overlay className="host-browser-overlay" />
-            <Dialog.Content className="host-browser-dialog">
-              <div className="host-browser-header">
-                <div>
-                  <Dialog.Title asChild>
-                    <h2 className="label">Host browser</h2>
-                  </Dialog.Title>
-                  <Dialog.Description asChild>
-                    <p className="mono host-browser-path">
-                      {hostBrowser?.currentPath || "Computer"}
-                    </p>
-                  </Dialog.Description>
-                </div>
-                <Dialog.Close asChild>
-                  <button className="ghost" type="button">
-                    Close
-                  </button>
-                </Dialog.Close>
-              </div>
-              <div className="host-browser-toolbar">
-                <button
-                  className="ghost"
-                  type="button"
-                  disabled={hostBrowserLoading || !hostBrowser?.parentPath}
-                  onClick={() => void browseHostDirectory(hostBrowser?.parentPath || "")}
-                >
-                  Up
-                </button>
-                <button
-                  className="ghost"
-                  type="button"
-                  disabled={hostBrowserLoading}
-                  onClick={() => void browseHostDirectory("")}
-                >
-                  Roots
-                </button>
-                {hostBrowserMode === "folder" && hostBrowser?.currentPath ? (
-                  <button
-                    className="primary"
-                    type="button"
-                    disabled={hostBrowserLoading}
-                    onClick={() => void selectHostPath(hostBrowser.currentPath, true)}
-                  >
-                    Select folder
-                  </button>
-                ) : null}
-                <label className="host-browser-search" htmlFor="host-browser-search">
-                  <span>Search</span>
-                  <input
-                    id="host-browser-search"
-                    className="host-browser-search__input"
-                    value={hostBrowserSearch}
-                    onChange={(event) => setHostBrowserSearch(event.target.value)}
-                    placeholder="Filter current path"
-                    disabled={hostBrowserLoading || !hostBrowser}
-                  />
-                </label>
-              </div>
-              {hostBrowserError ? <p className="error">{hostBrowserError}</p> : null}
-              {hostBrowserLoading ? <p className="muted">Loading host paths...</p> : null}
-              {!hostBrowserLoading && hostBrowser ? (
-                <div className="host-browser-list">
-                  {hostBrowserEntries.length === 0 ? (
-                    <p className="muted host-browser-empty">No matching paths.</p>
-                  ) : (
-                    hostBrowserEntries.map((entry, index) => (
-                      <div
-                        key={entry.path}
-                        className="host-browser-entry"
-                        ref={(element) => {
-                          hostBrowserEntryRefs.current[index] = element;
-                        }}
-                        tabIndex={0}
-                        onKeyDown={(event) => handleHostBrowserEntryKeyDown(event, entry, index)}
-                        onDoubleClick={() => {
-                          if (entry.isDir) {
-                            void browseHostDirectory(entry.path);
-                            return;
-                          }
-                          void selectHostPath(entry.path, entry.isDir);
-                        }}
-                      >
-                        <span className="host-browser-entry__name">
-                          {entry.isDir ? "[DIR] " : ""}
-                          {entry.name}
-                        </span>
-                        <span className="host-browser-entry__meta">
-                          {entry.isDir
-                            ? "Folder"
-                            : `${Math.round(entry.size / 1024).toLocaleString()} KiB`}
-                        </span>
-                        <span className="host-browser-entry__actions">
-                          {entry.isDir ? (
-                            <button
-                              className="ghost"
-                              type="button"
-                              onClick={(event) => {
-                                event.stopPropagation();
-                                void browseHostDirectory(entry.path);
-                              }}
-                            >
-                              Open
-                            </button>
-                          ) : null}
-                          {(hostBrowserMode === "folder" && entry.isDir) ||
-                          (hostBrowserMode === "file" && !entry.isDir) ? (
-                            <button
-                              className="primary"
-                              type="button"
-                              onClick={(event) => {
-                                event.stopPropagation();
-                                void selectHostPath(entry.path, entry.isDir);
-                              }}
-                            >
-                              Select
-                            </button>
-                          ) : null}
-                        </span>
-                      </div>
-                    ))
-                  )}
-                </div>
-              ) : null}
-            </Dialog.Content>
-          </Dialog.Portal>
-        </Dialog.Root>
-      </div>
-    </div>
-  );
-}
diff --git a/gui/frontend/src/components/LogSettingsPanel.test.tsx b/gui/frontend/src/components/LogSettingsPanel.test.tsx
deleted file mode 100644
index 2243cff7..00000000
--- a/gui/frontend/src/components/LogSettingsPanel.test.tsx
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { screen, waitFor } from "@testing-library/dom";
-import { cleanup, render } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import LogSettingsPanel from "./LogSettingsPanel";
-import { EventsOn } from "../utils/runtime";
-
-vi.mock("../utils/runtime", () => ({
-  EventsOn: vi.fn(() => vi.fn()),
-}));
-
-const installGoAPI = () => {
-  (globalThis as any).go = {
-    guiapp: {
-      App: {
-        GetLogPath: vi.fn().mockResolvedValue("C:/logs/upbrr.log"),
-        GetRecentLogs: vi.fn().mockResolvedValue([]),
-        GetLogExclusions: vi.fn().mockResolvedValue([]),
-        StartLogStream: vi.fn().mockResolvedValue("stream-1"),
-        StopLogStream: vi.fn().mockResolvedValue(undefined),
-        UpdateLogExclusions: vi.fn().mockResolvedValue(undefined),
-      },
-    },
-  };
-};
-
-describe("LogSettingsPanel", () => {
-  afterEach(() => {
-    cleanup();
-    vi.restoreAllMocks();
-    delete (globalThis as any).go;
-  });
-
-  it("renders log path and updates logging level", async () => {
-    installGoAPI();
-    const updateConfigValue = vi.fn();
-
-    render(
-      <LogSettingsPanel
-        configData={{ Logging: { Level: "info" } }}
-        fieldMeta={{ Level: { label: "Verbosity" } }}
-        renderField={(label) => <div key={label}>{label}</div>}
-        updateConfigValue={updateConfigValue}
-      />,
-    );
-
-    await waitFor(() => expect(screen.getByText("C:/logs/upbrr.log")).toBeInTheDocument());
-
-    await userEvent.selectOptions(screen.getByLabelText("Verbosity"), "debug");
-
-    expect(updateConfigValue).toHaveBeenCalledWith(["Logging", "Level"], "debug");
-  });
-
-  it("keeps distinct rows when a restarted log stream reuses IDs", async () => {
-    installGoAPI();
-    const app = (globalThis as any).go.guiapp.App;
-    app.GetRecentLogs.mockResolvedValueOnce([
-      {
-        ID: 1,
-        Time: "2026-06-15T00:00:00.000Z",
-        Level: "info",
-        Message: "before restart",
-      },
-    ]);
-    app.GetRecentLogs.mockResolvedValueOnce([
-      {
-        ID: 1,
-        Time: "2026-06-15T00:01:00.000Z",
-        Level: "info",
-        Message: "after restart",
-      },
-    ]);
-
-    render(
-      <LogSettingsPanel
-        configData={{ Logging: { Level: "info" } }}
-        fieldMeta={{ Level: { label: "Verbosity" } }}
-        renderField={(label) => <div key={label}>{label}</div>}
-        updateConfigValue={vi.fn()}
-      />,
-    );
-
-    await waitFor(() => expect(screen.getByText("before restart")).toBeInTheDocument());
-    await waitFor(() => expect(screen.getByText("after restart")).toBeInTheDocument());
-  });
-
-  it("dedupes exact recent/live overlap rows", async () => {
-    installGoAPI();
-    const app = (globalThis as any).go.guiapp.App;
-    const row = {
-      ID: 2,
-      Time: "2026-06-15T00:00:00.000Z",
-      Level: "info",
-      Message: "overlap",
-    };
-    app.GetRecentLogs.mockResolvedValue([row]);
-    vi.mocked(EventsOn).mockImplementationOnce((_eventName, callback) => {
-      callback(row);
-      return vi.fn();
-    });
-
-    render(
-      <LogSettingsPanel
-        configData={{ Logging: { Level: "info" } }}
-        fieldMeta={{ Level: { label: "Verbosity" } }}
-        renderField={(label) => <div key={label}>{label}</div>}
-        updateConfigValue={vi.fn()}
-      />,
-    );
-
-    await waitFor(() => expect(EventsOn).toHaveBeenCalled());
-    await waitFor(() => expect(screen.getAllByText("overlap")).toHaveLength(1));
-  });
-
-  it("does not restart the log stream when auto-scroll changes", async () => {
-    installGoAPI();
-    const app = (globalThis as any).go.guiapp.App;
-
-    render(
-      <LogSettingsPanel
-        configData={{ Logging: { Level: "info" } }}
-        fieldMeta={{ Level: { label: "Verbosity" } }}
-        renderField={(label) => <div key={label}>{label}</div>}
-        updateConfigValue={vi.fn()}
-      />,
-    );
-
-    await waitFor(() => expect(app.StartLogStream).toHaveBeenCalledTimes(1));
-
-    await userEvent.click(screen.getByLabelText("Auto-scroll logs"));
-
-    expect(app.StopLogStream).not.toHaveBeenCalled();
-    expect(app.StartLogStream).toHaveBeenCalledTimes(1);
-  });
-
-  it("stops a started stream when event subscription fails", async () => {
-    installGoAPI();
-    const app = (globalThis as any).go.guiapp.App;
-    const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
-    vi.mocked(EventsOn).mockImplementationOnce(() => {
-      throw new Error("subscribe failed");
-    });
-
-    render(
-      <LogSettingsPanel
-        configData={{ Logging: { Level: "info" } }}
-        fieldMeta={{ Level: { label: "Verbosity" } }}
-        renderField={(label) => <div key={label}>{label}</div>}
-        updateConfigValue={vi.fn()}
-      />,
-    );
-
-    try {
-      await waitFor(() => expect(app.StopLogStream).toHaveBeenCalledWith("stream-1"));
-      expect(consoleError).toHaveBeenCalledWith("Failed to start log stream", expect.any(Error));
-    } finally {
-      consoleError.mockRestore();
-    }
-  });
-});
diff --git a/gui/frontend/src/components/RenderedDescription.test.tsx b/gui/frontend/src/components/RenderedDescription.test.tsx
deleted file mode 100644
index 44fc8b24..00000000
--- a/gui/frontend/src/components/RenderedDescription.test.tsx
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import RenderedDescription from "./RenderedDescription";
-
-describe("RenderedDescription external links", () => {
-  afterEach(() => {
-    cleanup();
-    vi.restoreAllMocks();
-    delete (globalThis as typeof globalThis & { go?: unknown }).go;
-  });
-
-  it("marks rendered links to open in a new tab", () => {
-    render(<RenderedDescription html='<a href="https://example.com/image">View image</a>' />);
-
-    const link = screen.getByRole("link", { name: "View image" });
-
-    expect(link).toHaveAttribute("target", "_blank");
-    expect(link).toHaveAttribute("rel", "noreferrer");
-  });
-
-  it("opens web UI links in a new tab", () => {
-    const open = vi.spyOn(window, "open").mockImplementation(() => null);
-    render(<RenderedDescription html='<a href="https://example.com/torrent">Torrent</a>' />);
-
-    fireEvent.click(screen.getByRole("link", { name: "Torrent" }));
-
-    expect(open).toHaveBeenCalledWith(
-      "https://example.com/torrent",
-      "_blank",
-      "noopener,noreferrer",
-    );
-  });
-
-  it("opens GUI links through the default-browser bridge", async () => {
-    const openExternalURL = vi.fn().mockResolvedValue(undefined);
-    (globalThis as any).go = {
-      guiapp: { App: { OpenExternalURL: openExternalURL } },
-    };
-    const open = vi.spyOn(window, "open").mockImplementation(() => null);
-    render(<RenderedDescription html='<a href="https://example.com/release">Release</a>' />);
-
-    fireEvent.click(screen.getByRole("link", { name: "Release" }));
-
-    await waitFor(() => {
-      expect(openExternalURL).toHaveBeenCalledWith("https://example.com/release");
-    });
-    expect(open).not.toHaveBeenCalled();
-  });
-
-  it("routes aux-clicks through the same external-link handling", async () => {
-    const openExternalURL = vi.fn().mockResolvedValue(undefined);
-    (globalThis as any).go = {
-      guiapp: { App: { OpenExternalURL: openExternalURL } },
-    };
-    render(<RenderedDescription html='<a href="https://example.com/raw">Raw URL</a>' />);
-
-    fireEvent(
-      screen.getByRole("link", { name: "Raw URL" }),
-      new MouseEvent("auxclick", { bubbles: true, button: 1 }),
-    );
-
-    await waitFor(() => {
-      expect(openExternalURL).toHaveBeenCalledWith("https://example.com/raw");
-    });
-  });
-
-  it("blocks relative links instead of opening them against the app origin", () => {
-    const openExternalURL = vi.fn().mockResolvedValue(undefined);
-    (globalThis as any).go = {
-      guiapp: { App: { OpenExternalURL: openExternalURL } },
-    };
-    const open = vi.spyOn(window, "open").mockImplementation(() => null);
-    render(<RenderedDescription html='<a href="/relative/release">Relative release</a>' />);
-
-    const event = new MouseEvent("click", { bubbles: true, cancelable: true });
-    const dispatched = screen.getByRole("link", { name: "Relative release" }).dispatchEvent(event);
-
-    expect(dispatched).toBe(false);
-    expect(event.defaultPrevented).toBe(true);
-    expect(openExternalURL).not.toHaveBeenCalled();
-    expect(open).not.toHaveBeenCalled();
-  });
-});
diff --git a/gui/frontend/src/hooks/useScreenshots.ts b/gui/frontend/src/hooks/useScreenshots.ts
deleted file mode 100644
index 757fe781..00000000
--- a/gui/frontend/src/hooks/useScreenshots.ts
+++ /dev/null
@@ -1,811 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useState, useRef, useCallback, useMemo } from "react";
-import type {
-  ScreenshotImage,
-  ScreenshotPlan,
-  ScreenshotSelection,
-  ScreenshotPreviewImage,
-  ScreenshotResult,
-  ScreenshotLinkedImage,
-  ExternalIDOverrides,
-  ReleaseNameOverrides,
-} from "../types";
-import { normalizeOverrides, normalizeReleaseOverrides } from "../utils";
-
-interface ScreenshotHookProps {
-  path: string;
-  idOverrideState?: { overrides?: ExternalIDOverrides };
-  releaseOverrideState?: { overrides?: ReleaseNameOverrides };
-}
-
-export const useScreenshots = ({
-  path,
-  idOverrideState,
-  releaseOverrideState,
-}: ScreenshotHookProps) => {
-  // State: Plan & suggestions
-  const [screenshotPlan, setScreenshotPlan] = useState<ScreenshotPlan | null>(null);
-  const [screenshotSelections, setScreenshotSelections] = useState<ScreenshotSelection[]>([]);
-
-  // State: UI controls
-  const [screenshotsLoading, setScreenshotsLoading] = useState(false);
-  const [screenshotsError, setScreenshotsError] = useState("");
-  const [screenshotsSettingsSaving, setScreenshotsSettingsSaving] = useState(false);
-  const [showFrameSelections, setShowFrameSelections] = useState(false);
-
-  // State: Live preview
-  const [livePreviewSeconds, setLivePreviewSeconds] = useState(0);
-  const [livePreviewImage, setLivePreviewImage] = useState("");
-  const [livePreviewLoading, setLivePreviewLoading] = useState(false);
-  const [livePreviewError, setLivePreviewError] = useState("");
-  const livePreviewRequestId = useRef(0);
-
-  // State: Image collections
-  const [previewLoadingIndex, setPreviewLoadingIndex] = useState<number | null>(null);
-  const [previewImages, setPreviewImages] = useState<ScreenshotPreviewImage[]>([]);
-  const [existingImages, setExistingImages] = useState<ScreenshotPreviewImage[]>([]);
-  const [existingTrackerImages, setExistingTrackerImages] = useState<ScreenshotPreviewImage[]>([]);
-  const [finalImages, setFinalImages] = useState<ScreenshotPreviewImage[]>([]);
-  const [finalResult, setFinalResult] = useState<ScreenshotResult | null>(null);
-
-  // Deletion tracking for UI updates
-  const [deletedTrackerImages, setDeletedTrackerImages] = useState<string[]>([]);
-
-  // Refs for state sync
-  const finalImagesRef = useRef<ScreenshotPreviewImage[]>([]);
-
-  // Memoized tracker image maps
-  const trackerImageURLs = useMemo(() => {
-    const urls = new Set<string>();
-    (screenshotPlan?.TrackerImageLinks || []).forEach((link) => {
-      if (link.URL && !deletedTrackerImages.includes(link.URL)) {
-        urls.add(link.URL);
-      }
-    });
-    return Array.from(urls);
-  }, [screenshotPlan?.TrackerImageLinks, deletedTrackerImages]);
-
-  const trackerLinkByPath = useMemo(() => {
-    const map = new Map<string, ScreenshotLinkedImage>();
-    (screenshotPlan?.TrackerImageLinks || []).forEach((link) => {
-      if (link.Path) {
-        map.set(link.Path, link);
-      }
-    });
-    return map;
-  }, [screenshotPlan?.TrackerImageLinks]);
-
-  const trackerLinkByURL = useMemo(() => {
-    const map = new Map<string, ScreenshotLinkedImage>();
-    (screenshotPlan?.TrackerImageLinks || []).forEach((link) => {
-      if (link.URL) {
-        map.set(link.URL, link);
-      }
-    });
-    return map;
-  }, [screenshotPlan?.TrackerImageLinks]);
-
-  // Helper: normalize image path (URI decoding)
-  const normalizeImagePath = useCallback((value: string) => {
-    if (!value) return "";
-    if (value.startsWith("file://")) {
-      const trimmed = value.replaceAll("file://", "");
-      try {
-        return decodeURIComponent(trimmed);
-      } catch {
-        return trimmed;
-      }
-    }
-    return value;
-  }, []);
-
-  // Helper: read screenshot image from backend
-  const readScreenshotImage = useCallback(
-    async (image: ScreenshotImage): Promise<ScreenshotPreviewImage> => {
-      const reader = globalThis.go?.guiapp?.App?.ReadScreenshotImage;
-      if (!reader) {
-        throw new Error("Screenshot preview is unavailable in this build.");
-      }
-      const dataUri = await reader(image.Path);
-      return { image, dataUri } as ScreenshotPreviewImage;
-    },
-    [],
-  );
-
-  // Load screenshot plan from backend
-  const loadScreenshotPlan = useCallback(
-    async (revealSelections = false): Promise<ScreenshotPlan | null> => {
-      setScreenshotsError("");
-      const fetcher = globalThis.go?.guiapp?.App?.FetchScreenshotPlan;
-      if (!fetcher) {
-        setScreenshotsError("Screenshot planning is unavailable in this build.");
-        return null;
-      }
-      if (!path.trim()) {
-        setScreenshotsError("Please select a file or folder.");
-        return null;
-      }
-
-      setScreenshotsLoading(true);
-      try {
-        const result = await fetcher(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        );
-        setScreenshotPlan(result);
-        setScreenshotSelections(result.SuggestedSelections || []);
-        setLivePreviewImage("");
-        setLivePreviewError("");
-
-        if (revealSelections) {
-          setShowFrameSelections(true);
-        }
-
-        if (!livePreviewSeconds && (result.SuggestedSelections || []).length > 0) {
-          const initial = result.SuggestedSelections[0]?.TimestampSeconds || 0;
-          setLivePreviewSeconds(initial);
-        }
-
-        setExistingImages([]);
-        setExistingTrackerImages([]);
-        setPreviewImages([]);
-        setFinalResult(null);
-
-        // Load existing screenshot previews
-        if (result.ExistingScreenshots && result.ExistingScreenshots.length > 0) {
-          const previews = await Promise.all(
-            result.ExistingScreenshots.map(async (image) => {
-              try {
-                return await readScreenshotImage(image);
-              } catch {
-                return null;
-              }
-            }),
-          );
-          setExistingImages(
-            previews.filter((entry): entry is ScreenshotPreviewImage => Boolean(entry)),
-          );
-        }
-
-        // Load existing tracker screenshot previews
-        if (result.ExistingTrackerScreenshots && result.ExistingTrackerScreenshots.length > 0) {
-          const previews = await Promise.all(
-            result.ExistingTrackerScreenshots.map(async (image) => {
-              try {
-                return await readScreenshotImage(image);
-              } catch {
-                return null;
-              }
-            }),
-          );
-          setExistingTrackerImages(
-            previews.filter((entry): entry is ScreenshotPreviewImage => Boolean(entry)),
-          );
-        }
-
-        // Load final selections
-        if (
-          result.FinalSelections &&
-          result.FinalSelections.length > 0 &&
-          finalImagesRef.current.length === 0
-        ) {
-          const previews = await Promise.all(
-            result.FinalSelections.map(async (image) => {
-              try {
-                return await readScreenshotImage(image);
-              } catch {
-                return null;
-              }
-            }),
-          );
-          setFinalImages(
-            previews.filter((entry): entry is ScreenshotPreviewImage => Boolean(entry)),
-          );
-        }
-
-        return result;
-      } catch (err) {
-        const message = String(err);
-        if (message.includes("screenshot plan requires metadata preview")) {
-          setScreenshotsError(
-            "Fetch metadata first to cache a preview before planning screenshots.",
-          );
-        } else {
-          setScreenshotsError(message);
-        }
-        return null;
-      } finally {
-        setScreenshotsLoading(false);
-      }
-    },
-    [path, idOverrideState, releaseOverrideState, livePreviewSeconds, readScreenshotImage],
-  );
-
-  // Save final selections
-  const saveFinalSelections = useCallback(
-    async (next: ScreenshotPreviewImage[]) => {
-      setFinalImages(next);
-      const saver = globalThis.go?.guiapp?.App?.SaveFinalScreenshotSelections;
-      if (!saver || !path.trim()) {
-        return;
-      }
-      try {
-        await saver(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-          next.map((entry) => entry.image),
-        );
-      } catch (err) {
-        setScreenshotsError(String(err));
-      }
-    },
-    [path, idOverrideState, releaseOverrideState],
-  );
-
-  // Update selection timestamp
-  const updateSelectionTime = useCallback((index: number, value: string) => {
-    const next = Number.parseFloat(value);
-    setScreenshotSelections((prev) => {
-      return prev.map((selection) =>
-        selection.Index === index
-          ? {
-              ...selection,
-              TimestampSeconds: Number.isFinite(next) ? next : 0,
-              Source: "manual",
-            }
-          : selection,
-      );
-    });
-  }, []);
-
-  // Update selection frame
-  const updateSelectionFrame = useCallback((index: number, value: string) => {
-    const next = Number.parseInt(value, 10);
-    setScreenshotSelections((prev) => {
-      return prev.map((selection) =>
-        selection.Index === index
-          ? {
-              ...selection,
-              Frame: Number.isFinite(next) ? next : 0,
-              Source: "manual",
-            }
-          : selection,
-      );
-    });
-  }, []);
-
-  // Check if final image is already selected
-  const isFinalImageSelected = useCallback((pathValue: string) => {
-    if (!pathValue) return false;
-    return finalImagesRef.current.some((entry) => entry.image.Path === pathValue);
-  }, []);
-
-  const updateFinalSelections = useCallback(
-    async (next: ScreenshotPreviewImage[], persist: boolean) => {
-      finalImagesRef.current = next;
-      setFinalImages(next);
-      if (persist) {
-        await saveFinalSelections(next);
-      }
-    },
-    [saveFinalSelections],
-  );
-
-  // Add image to final selections
-  const addFinalSelection = useCallback(
-    (image: ScreenshotPreviewImage) => {
-      if (!image.image.Path) return;
-      const updated = mergeFinalSelections(finalImagesRef.current, [image]);
-      void updateFinalSelections(updated, true);
-    },
-    [updateFinalSelections],
-  );
-
-  const removeFinalSelectionInternal = useCallback(
-    (pathValue: string, persist: boolean) => {
-      if (!pathValue) return false;
-      if (!finalImagesRef.current.some((entry) => entry.image.Path === pathValue)) {
-        return false;
-      }
-      const updated = finalImagesRef.current.filter((entry) => entry.image.Path !== pathValue);
-      void updateFinalSelections(updated, persist);
-      return true;
-    },
-    [updateFinalSelections],
-  );
-
-  // Remove image from final selections
-  const removeFinalSelection = useCallback(
-    (pathValue: string) => {
-      removeFinalSelectionInternal(pathValue, true);
-    },
-    [removeFinalSelectionInternal],
-  );
-
-  // Merge final selections intelligently
-  const mergeFinalSelections = (
-    current: ScreenshotPreviewImage[],
-    additions: ScreenshotPreviewImage[],
-  ): ScreenshotPreviewImage[] => {
-    if (additions.length === 0) return current;
-    const seen = new Map<string, number>();
-    const merged = [...current];
-    merged.forEach((item, index) => {
-      if (item.image.Path) {
-        seen.set(item.image.Path, index);
-      }
-    });
-
-    additions.forEach((item) => {
-      const pathValue = item.image.Path;
-      if (!pathValue) return;
-      const existingIndex = seen.get(pathValue);
-      if (existingIndex === undefined) {
-        const ts = item.image.TimestampSeconds || 0;
-        if (ts > 0) {
-          const insertAt = merged.findIndex((entry) => {
-            const entryTs = entry.image.TimestampSeconds || 0;
-            return entryTs > 0 && entryTs > ts;
-          });
-          if (insertAt >= 0) {
-            merged.splice(insertAt, 0, item);
-            seen.clear();
-            merged.forEach((entry, idx) => {
-              if (entry.image.Path) {
-                seen.set(entry.image.Path, idx);
-              }
-            });
-          } else {
-            merged.push(item);
-            seen.set(pathValue, merged.length - 1);
-          }
-        } else {
-          merged.push(item);
-          seen.set(pathValue, merged.length - 1);
-        }
-      }
-    });
-
-    return merged;
-  };
-
-  // Reorder final selections via drag
-  const reorderFinalSelections = (dragIndex: number, targetIndex: number) => {
-    if (dragIndex === targetIndex) return;
-    const updated = [...finalImagesRef.current];
-    const [dragged] = updated.splice(dragIndex, 1);
-    updated.splice(targetIndex, 0, dragged);
-    finalImagesRef.current = updated;
-    saveFinalSelections(updated);
-  };
-
-  // Delete a set of images
-  const deleteImageSet = useCallback(
-    async (images: ScreenshotImage[], label: string): Promise<ScreenshotImage[]> => {
-      if (images.length === 0) return [];
-      const deleter = globalThis.go?.guiapp?.App?.DeleteScreenshot;
-      if (!deleter || !path.trim()) {
-        return [] as ScreenshotImage[];
-      }
-      if (!globalThis.confirm(`Delete all ${label} images from the temp folder?`)) {
-        return [] as ScreenshotImage[];
-      }
-
-      const deleted: ScreenshotImage[] = [];
-      const failures: string[] = [];
-      for (const image of images) {
-        try {
-          await deleter(
-            path.trim(),
-            normalizeOverrides(idOverrideState?.overrides || {}),
-            normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-            image.Path,
-          );
-          deleted.push(image);
-        } catch (err) {
-          failures.push(String(err));
-        }
-      }
-
-      if (failures.length > 0) {
-        setScreenshotsError(failures[0]);
-      }
-      return deleted;
-    },
-    [path, idOverrideState, releaseOverrideState],
-  );
-
-  const deleteTrackerImageURL = useCallback(
-    async (url: string) => {
-      const deleter = (globalThis as any)?.go?.guiapp?.App?.DeleteTrackerImageURL;
-      if (!deleter || !path.trim() || !url) {
-        return;
-      }
-      try {
-        await deleter(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-          url,
-        );
-      } catch (err) {
-        setScreenshotsError(String(err));
-      }
-    },
-    [path, idOverrideState, releaseOverrideState],
-  );
-
-  const deleteTrackerImageFile = useCallback(
-    async (imagePath: string) => {
-      const deleter = globalThis.go?.guiapp?.App?.DeleteScreenshot;
-      if (!deleter || !path.trim() || !imagePath) {
-        return;
-      }
-      try {
-        await deleter(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-          imagePath,
-        );
-      } catch (err) {
-        setScreenshotsError(String(err));
-      }
-    },
-    [path, idOverrideState, releaseOverrideState],
-  );
-
-  const removeTrackerImageURLState = useCallback((url: string) => {
-    if (!url) return;
-    setDeletedTrackerImages((prev) => {
-      if (prev.includes(url)) {
-        return prev;
-      }
-      return [...prev, url];
-    });
-    setScreenshotPlan((prev) => {
-      if (!prev) return prev;
-      const trackerLinks = prev.TrackerImageLinks || [];
-      return {
-        ...prev,
-        TrackerImageLinks: trackerLinks.filter((entry) => entry.URL !== url),
-      };
-    });
-  }, []);
-
-  // Delete all existing images
-  const handleDeleteAllExistingImages = useCallback(async () => {
-    const images = screenshotPlan?.ExistingScreenshots?.length
-      ? screenshotPlan.ExistingScreenshots
-      : existingImages.map((entry) => entry.image);
-    const deleted = await deleteImageSet(images, "existing");
-    if (deleted.length === 0) return;
-    const deletedPaths = new Set(deleted.map((image) => image.Path));
-    setExistingImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-    if (finalImagesRef.current.length > 0) {
-      await saveFinalSelections(
-        finalImagesRef.current.filter((entry) => !deletedPaths.has(entry.image.Path)),
-      );
-    }
-    setScreenshotPlan((prev) => {
-      if (!prev) return prev;
-      const existing = prev.ExistingScreenshots || [];
-      return {
-        ...prev,
-        ExistingScreenshots: existing.filter((entry) => !deletedPaths.has(entry.Path)),
-      };
-    });
-  }, [screenshotPlan, existingImages, deleteImageSet, saveFinalSelections]);
-
-  // Delete all tracker images
-  const handleDeleteAllTrackerImages = useCallback(async () => {
-    const images = screenshotPlan?.ExistingTrackerScreenshots?.length
-      ? screenshotPlan.ExistingTrackerScreenshots
-      : existingTrackerImages.map((entry) => entry.image);
-    const deleted = await deleteImageSet(images, "tracker temp");
-    if (deleted.length === 0) return;
-    const deletedPaths = new Set(deleted.map((image) => image.Path));
-    const linkedURLs = deleted
-      .map((image) => trackerLinkByPath.get(image.Path))
-      .filter((link): link is ScreenshotLinkedImage => Boolean(link));
-    if (linkedURLs.length > 0) {
-      setDeletedTrackerImages((prev) => {
-        const next = new Set(prev);
-        linkedURLs.forEach((link) => {
-          if (link.URL) {
-            next.add(link.URL);
-          }
-        });
-        return Array.from(next);
-      });
-      for (const link of linkedURLs) {
-        if (!link.URL) {
-          continue;
-        }
-        await deleteTrackerImageURL(link.URL);
-      }
-    }
-
-    setExistingTrackerImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-    if (finalImagesRef.current.length > 0) {
-      await saveFinalSelections(
-        finalImagesRef.current.filter((entry) => !deletedPaths.has(entry.image.Path)),
-      );
-    }
-    setScreenshotPlan((prev) => {
-      if (!prev) return prev;
-      const trackerExisting = prev.ExistingTrackerScreenshots || [];
-      const trackerLinks = prev.TrackerImageLinks || [];
-      return {
-        ...prev,
-        ExistingTrackerScreenshots: trackerExisting.filter(
-          (entry) => !deletedPaths.has(entry.Path),
-        ),
-        TrackerImageLinks: trackerLinks.filter((entry) => !deletedPaths.has(entry.Path)),
-      };
-    });
-  }, [
-    screenshotPlan,
-    existingTrackerImages,
-    trackerLinkByPath,
-    deleteImageSet,
-    saveFinalSelections,
-    deleteTrackerImageURL,
-  ]);
-
-  // Delete all preview images
-  const handleDeleteAllPreviewImages = useCallback(async () => {
-    const images = previewImages.map((entry) => entry.image);
-    const deleted = await deleteImageSet(images, "preview");
-    if (deleted.length === 0) return;
-    const deletedPaths = new Set(deleted.map((image) => image.Path));
-    setPreviewImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-  }, [previewImages, deleteImageSet]);
-
-  // Delete all final images
-  const handleDeleteAllFinalImages = useCallback(async () => {
-    const images = finalImages.map((entry) => entry.image);
-    const deleted = await deleteImageSet(images, "final");
-    if (deleted.length === 0) return;
-    const deletedPaths = new Set(deleted.map((image) => image.Path));
-    const linkedURLs = deleted
-      .map((image) => trackerLinkByPath.get(image.Path))
-      .filter((link): link is ScreenshotLinkedImage => Boolean(link));
-    if (linkedURLs.length > 0) {
-      setDeletedTrackerImages((prev) => {
-        const next = new Set(prev);
-        linkedURLs.forEach((link) => {
-          if (link.URL) {
-            next.add(link.URL);
-          }
-        });
-        return Array.from(next);
-      });
-      for (const link of linkedURLs) {
-        if (!link.URL) {
-          continue;
-        }
-        await deleteTrackerImageURL(link.URL);
-      }
-    }
-    await saveFinalSelections(
-      finalImagesRef.current.filter((entry) => !deletedPaths.has(entry.image.Path)),
-    );
-    setExistingImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-    setExistingTrackerImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-    setPreviewImages((prev) => prev.filter((entry) => !deletedPaths.has(entry.image.Path)));
-    setScreenshotPlan((prev) => {
-      if (!prev) return prev;
-      const existing = prev.ExistingScreenshots || [];
-      const trackerExisting = prev.ExistingTrackerScreenshots || [];
-      const trackerLinks = prev.TrackerImageLinks || [];
-      return {
-        ...prev,
-        ExistingScreenshots: existing.filter((entry) => !deletedPaths.has(entry.Path)),
-        ExistingTrackerScreenshots: trackerExisting.filter(
-          (entry) => !deletedPaths.has(entry.Path),
-        ),
-        TrackerImageLinks: trackerLinks.filter((entry) => !deletedPaths.has(entry.Path)),
-      };
-    });
-  }, [finalImages, deleteImageSet, saveFinalSelections, trackerLinkByPath, deleteTrackerImageURL]);
-
-  const handleDeleteTrackerImageURL = useCallback(
-    async (url: string, persistFinal = true): Promise<boolean> => {
-      if (!url) return false;
-      const linked = trackerLinkByURL.get(url);
-      let removedFinal = false;
-      if (linked?.Path) {
-        await deleteTrackerImageFile(linked.Path);
-      }
-      await deleteTrackerImageURL(url);
-      removeTrackerImageURLState(url);
-      if (linked?.Path) {
-        removedFinal = removeFinalSelectionInternal(linked.Path, persistFinal);
-      }
-      return removedFinal;
-    },
-    [
-      deleteTrackerImageURL,
-      removeTrackerImageURLState,
-      trackerLinkByURL,
-      removeFinalSelectionInternal,
-      deleteTrackerImageFile,
-    ],
-  );
-
-  // Delete a specific tracker image
-  const handleDeleteTrackerImage = useCallback(
-    async (url: string) => {
-      setScreenshotsError("");
-      if (!url) {
-        setScreenshotsError("Tracker image URL is missing.");
-        return;
-      }
-      if (!globalThis.confirm("Remove this tracker image from the list?")) {
-        return;
-      }
-      await handleDeleteTrackerImageURL(url, true);
-    },
-    [handleDeleteTrackerImageURL],
-  );
-
-  // Delete all tracker image URLs
-  const handleDeleteAllTrackerImageURLs = useCallback(async () => {
-    const urls = trackerImageURLs;
-    if (urls.length === 0) return;
-    if (!globalThis.confirm("Remove all tracker images from the list?")) {
-      return;
-    }
-    let removedFinal = false;
-    for (const url of urls) {
-      const removed = await handleDeleteTrackerImageURL(url, false);
-      if (removed) {
-        removedFinal = true;
-      }
-    }
-    if (removedFinal) {
-      await saveFinalSelections(finalImagesRef.current);
-    }
-  }, [trackerImageURLs, handleDeleteTrackerImageURL, saveFinalSelections]);
-
-  // Reset all screenshot state
-  const resetScreenshotState = useCallback(() => {
-    setScreenshotPlan(null);
-    setScreenshotSelections([]);
-    setScreenshotsLoading(false);
-    setScreenshotsError("");
-    setShowFrameSelections(false);
-    setPreviewLoadingIndex(null);
-    setPreviewImages([]);
-    setExistingImages([]);
-    setExistingTrackerImages([]);
-    setFinalImages([]);
-    setFinalResult(null);
-    setLivePreviewSeconds(0);
-    setLivePreviewImage("");
-    setLivePreviewLoading(false);
-    setLivePreviewError("");
-    setDeletedTrackerImages([]);
-    finalImagesRef.current = [];
-  }, []);
-
-  // Sync finalImagesRef with finalImages state
-  useMemo(() => {
-    finalImagesRef.current = finalImages;
-  }, [finalImages]);
-
-  // Compute tracker image links from screenshot plan
-  const trackerImageLinks = useMemo(() => {
-    return screenshotPlan?.TrackerImageLinks || [];
-  }, [screenshotPlan?.TrackerImageLinks]);
-
-  // Compute merged upload candidates from all image sources
-  const uploadCandidates = useMemo(() => {
-    const merged = new Map<string, ScreenshotPreviewImage>();
-
-    const addImages = (items: ScreenshotPreviewImage[]) => {
-      items.forEach((item) => {
-        const pathValue = item.image.Path;
-        if (!pathValue) return;
-        const existing = merged.get(pathValue);
-        if (!existing || (item.image.Host && item.image.RawURL && !existing.image.Host)) {
-          // Prefer entries with upload metadata
-          merged.set(pathValue, item);
-        }
-      });
-    };
-
-    addImages(finalImages);
-    addImages(previewImages);
-    addImages(existingTrackerImages);
-    addImages(existingImages);
-
-    return Array.from(merged.values());
-  }, [finalImages, previewImages, existingTrackerImages, existingImages]);
-
-  // Compute set of upload candidate paths
-  const uploadCandidatePaths = useMemo(() => {
-    const paths = new Set<string>();
-    uploadCandidates.forEach((item) => {
-      if (item.image.Path) {
-        paths.add(item.image.Path);
-      }
-    });
-    return paths;
-  }, [uploadCandidates]);
-
-  return {
-    // State
-    screenshotPlan,
-    screenshotSelections,
-    screenshotsLoading,
-    screenshotsError,
-    screenshotsSettingsSaving,
-    showFrameSelections,
-    livePreviewSeconds,
-    livePreviewImage,
-    livePreviewLoading,
-    livePreviewError,
-    livePreviewRequestId,
-    previewLoadingIndex,
-    previewImages,
-    existingImages,
-    existingTrackerImages,
-    finalImages,
-    finalResult,
-    deletedTrackerImages,
-    trackerImageURLs,
-    trackerLinkByPath,
-    trackerLinkByURL,
-    trackerImageLinks,
-    uploadCandidates,
-    uploadCandidatePaths,
-
-    // Refs
-    finalImagesRef,
-
-    // Setters
-    setScreenshotPlan,
-    setScreenshotSelections,
-    setScreenshotsLoading,
-    setScreenshotsError,
-    setScreenshotsSettingsSaving,
-    setShowFrameSelections,
-    setLivePreviewSeconds,
-    setLivePreviewImage,
-    setLivePreviewLoading,
-    setLivePreviewError,
-    setPreviewLoadingIndex,
-    setPreviewImages,
-    setExistingImages,
-    setExistingTrackerImages,
-    setFinalImages,
-    setFinalResult,
-    setDeletedTrackerImages,
-
-    // Handlers & utilities
-    normalizeImagePath,
-    readScreenshotImage,
-    loadScreenshotPlan,
-    saveFinalSelections,
-    updateSelectionTime,
-    updateSelectionFrame,
-    isFinalImageSelected,
-    addFinalSelection,
-    removeFinalSelection,
-    reorderFinalSelections,
-    handleDeleteAllExistingImages,
-    handleDeleteAllTrackerImages,
-    handleDeleteAllPreviewImages,
-    handleDeleteAllFinalImages,
-    handleDeleteTrackerImage,
-    handleDeleteTrackerImageURL,
-    handleDeleteAllTrackerImageURLs,
-    resetScreenshotState,
-  };
-};
diff --git a/gui/frontend/src/hooks/useSettingsState.test.ts b/gui/frontend/src/hooks/useSettingsState.test.ts
deleted file mode 100644
index e479ae0c..00000000
--- a/gui/frontend/src/hooks/useSettingsState.test.ts
+++ /dev/null
@@ -1,1183 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { createElement } from "react";
-import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  nextQbitDirectState,
-  normalizeTorrentClientForSave,
-  normalizeTorrentClientsForSave,
-  useSettingsState,
-} from "./useSettingsState";
-
-afterEach(() => {
-  cleanup();
-  latestPayload = "";
-  delete (globalThis as typeof globalThis & { go?: any }).go;
-});
-
-describe("normalizeTorrentClientForSave", () => {
-  it("preserves watch client fields", () => {
-    expect(
-      normalizeTorrentClientForSave({
-        Type: "watch",
-        WatchFolder: "/watch",
-        StorageDir: "/storage",
-      }),
-    ).toEqual({
-      Type: "watch",
-      WatchFolder: "/watch",
-      StorageDir: "/storage",
-    });
-  });
-
-  it("migrates legacy qbit fields and removes aliases", () => {
-    expect(
-      normalizeTorrentClientForSave({
-        TorrentClient: "qbit",
-        URL: "http://localhost:8080",
-        Username: "user",
-        Password: "secret",
-        Category: "movies",
-        Tags: ["AITHER", "BLU"],
-      }),
-    ).toEqual({
-      QbitURL: "http://localhost:8080",
-      QbitUser: "user",
-      QbitPass: "secret",
-      QbitCategoryValue: "movies",
-      QbitTag: "AITHER,BLU",
-    });
-  });
-
-  it("maps legacy TLS skip verify to certificate verification before removing aliases", () => {
-    expect(
-      normalizeTorrentClientForSave({
-        TorrentClient: "qbit",
-        TLSSkipVerify: true,
-      }),
-    ).toEqual({
-      VerifyWebUICertificate: false,
-    });
-  });
-});
-
-describe("normalizeTorrentClientsForSave", () => {
-  it("normalizes each configured client without dropping watch-folder config", () => {
-    expect(
-      normalizeTorrentClientsForSave({
-        TorrentClients: {
-          qbit: {
-            Type: "qbit",
-            URL: "http://localhost:8080",
-            Username: "user",
-            Password: "secret",
-          },
-          watch: {
-            Type: "watch",
-            WatchFolder: "/watch",
-            StorageDir: "/storage",
-          },
-        },
-      }),
-    ).toEqual({
-      TorrentClients: {
-        qbit: {
-          QbitURL: "http://localhost:8080",
-          QbitUser: "user",
-          QbitPass: "secret",
-        },
-        watch: {
-          Type: "watch",
-          WatchFolder: "/watch",
-          StorageDir: "/storage",
-        },
-      },
-    });
-  });
-});
-
-describe("nextQbitDirectState", () => {
-  it("clears proxy and direct credentials when qbit direct is disabled", () => {
-    expect(
-      nextQbitDirectState(
-        {
-          QuiProxyURL: "http://proxy.local",
-          QbitURL: "http://localhost:8080",
-          QbitPort: 8080,
-          QbitUser: "user",
-          QbitPass: "secret",
-          URL: "http://legacy.local",
-          Username: "legacy-user",
-          Password: "legacy-pass",
-        },
-        false,
-      ),
-    ).toEqual({
-      QuiProxyURL: "",
-      QbitURL: "",
-      QbitPort: 0,
-      QbitUser: "",
-      QbitPass: "",
-      URL: "",
-      Username: "",
-      Password: "",
-    });
-  });
-});
-
-function TorrentClientsHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-
-  return createElement(
-    "div",
-    null,
-    state.renderTorrentClientsSection(false),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-function ClientSetupHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-  const clientSetup = state.configData?.ClientSetup;
-
-  if (!clientSetup || typeof clientSetup !== "object" || Array.isArray(clientSetup)) {
-    return createElement("div", null);
-  }
-
-  const meta = state.sectionFieldMeta.ClientSetup ?? {};
-
-  return createElement(
-    "div",
-    null,
-    ...Object.entries(clientSetup).map(([key, value]) =>
-      state.renderField(key, value, ["ClientSetup", key], meta[key]),
-    ),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-function TrackerSettingsHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-
-  return createElement(
-    "div",
-    null,
-    state.renderTrackerSection(false),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-function TrackerSettingsAdvancedHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-
-  return createElement(
-    "div",
-    null,
-    state.renderTrackerSection(true),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-function ImageHostingHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-
-  return createElement(
-    "div",
-    null,
-    state.renderImageHostingSection(),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-function ScreenshotSettingsHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-  const config = state.screenshotConfig;
-  if (!config) {
-    return createElement("div");
-  }
-  return createElement(
-    "div",
-    null,
-    state.renderField(
-      "MaxMenuItems",
-      config.MaxMenuItems,
-      ["ScreenshotHandling", "MaxMenuItems"],
-      state.sectionFieldMeta.ScreenshotHandling?.MaxMenuItems,
-    ),
-    createElement(PayloadCapture, { value: state.buildSavePayload() }),
-  );
-}
-
-let latestPayload = "";
-
-/** Captures save payloads without rendering secret-shaped values into DOM snapshots. */
-function PayloadCapture({ value }: { value: string | null }) {
-  latestPayload = value ?? "";
-  return null;
-}
-
-/** Parses the latest captured payload for focused assertions outside matcher output. */
-function readPayload<T>() {
-  return JSON.parse(latestPayload || "{}") as T;
-}
-
-function AdvancedFieldMetaHarness() {
-  const state = useSettingsState({ activeTab: "settings" });
-  const advancedBySection = Object.fromEntries(
-    Object.entries(state.sectionFieldMeta).map(([section, fields]) => [
-      section,
-      Object.values(fields)
-        .filter((field) => field.advanced)
-        .map((field) => field.key)
-        .sort(),
-    ]),
-  );
-
-  return createElement(
-    "pre",
-    { "data-testid": "advanced-fields" },
-    JSON.stringify(advancedBySection),
-  );
-}
-
-describe("settings advanced fields", () => {
-  it("matches the configured per-section advanced allowlist", () => {
-    render(createElement(AdvancedFieldMetaHarness));
-
-    const advancedBySection = JSON.parse(
-      screen.getByTestId("advanced-fields").textContent ?? "{}",
-    ) as Record<string, string[]>;
-
-    expect(advancedBySection.MainSettings).toEqual([]);
-    expect(advancedBySection.Metadata).toEqual([
-      "BTNAPI",
-      "BlurayScore",
-      "BluraySingleScore",
-      "CheckPredb",
-      "SkipAutoTorrent",
-      "SkipTrackerFilenameLookup",
-      "UserOverrides",
-    ]);
-    expect(advancedBySection.ScreenshotHandling).toEqual([
-      "Desat",
-      "FFmpegCompression",
-      "FFmpegLimit",
-      "MaxConcurrentUploads",
-      "ProcessLimit",
-      "TonemapAlgorithm",
-    ]);
-    expect(advancedBySection.Description).toEqual([
-      "CharLimit",
-      "CustomSignature",
-      "FileLimit",
-      "LogoLanguage",
-      "LogoSize",
-      "ProcessLimit",
-    ]);
-    expect(advancedBySection.PostUpload).toEqual(["InjectDelay", "MaxConcurrentTrackers"]);
-    expect(advancedBySection.TorrentCreation).toEqual([]);
-    expect(advancedBySection.TorrentClients).toEqual(["VerifyWebUICertificate"]);
-  });
-});
-
-describe("DVD menu screenshot settings", () => {
-  it("loads the default maximum and preserves edits in the save payload", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () => JSON.stringify({ ScreenshotHandling: { MaxMenuItems: 6 } }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(ScreenshotSettingsHarness));
-    const input = await screen.findByLabelText("Maximum DVD menu images");
-    expect(input).toHaveValue(6);
-    fireEvent.change(input, { target: { value: "8" } });
-    await waitFor(() => {
-      const payload = readPayload<{ ScreenshotHandling?: { MaxMenuItems?: number } }>();
-      expect(payload.ScreenshotHandling?.MaxMenuItems).toBe(8);
-    });
-  });
-});
-
-describe("renderTorrentClientsSection", () => {
-  it("renders watch client fields and preserves qbit clients on update", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              TorrentClients: {
-                watcher: {
-                  Type: "watch",
-                  WatchFolder: "/watch",
-                  StorageDir: "/storage",
-                },
-                qbit: {
-                  Type: "qbit",
-                  QbitURL: "http://localhost:8080",
-                  QbitUser: "user",
-                  QbitPass: "secret",
-                  AutomaticManagementPaths: ["/media"],
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TorrentClientsHarness));
-
-    await waitFor(() => expect(screen.getByText("watcher")).toBeInTheDocument());
-
-    const watchCard = screen.getByText("watcher").closest(".settings-card");
-    const qbitCard = screen.getByText("qbit").closest(".settings-card");
-    expect(watchCard).toBeTruthy();
-    expect(qbitCard).toBeTruthy();
-
-    const watchScope = within(watchCard as HTMLElement);
-    const qbitScope = within(qbitCard as HTMLElement);
-
-    expect(watchScope.getByLabelText("Type")).toHaveValue("watch");
-    expect(watchScope.getByLabelText("Watch folder")).toHaveValue("/watch");
-    expect(watchScope.getByLabelText("Storage directory")).toHaveValue("/storage");
-    expect(qbitScope.getByLabelText("qBit URL")).toHaveValue("http://localhost:8080");
-    expect(qbitScope.getByLabelText("Automatic management paths 1")).toHaveValue("/media");
-    expect(qbitScope.getByRole("button", { name: "Add Linked folder item" })).toBeInTheDocument();
-    expect(qbitScope.getByRole("button", { name: "Add Local path item" })).toBeInTheDocument();
-    expect(qbitScope.getByRole("button", { name: "Add Remote path item" })).toBeInTheDocument();
-    expect(
-      qbitScope.getByRole("button", { name: "Add Automatic management paths item" }),
-    ).toBeInTheDocument();
-    expect(qbitScope.getByLabelText("qBit direct")).toBeChecked();
-
-    fireEvent.change(watchScope.getByLabelText("Watch folder"), {
-      target: { value: "/watch/new" },
-    });
-
-    await waitFor(() =>
-      expect(watchScope.getByLabelText("Watch folder")).toHaveValue("/watch/new"),
-    );
-
-    const payload = readPayload<{
-      TorrentClients?: Record<string, Record<string, unknown>>;
-    }>();
-    expect(payload.TorrentClients?.watcher).toEqual({
-      Type: "watch",
-      WatchFolder: "/watch/new",
-      StorageDir: "/storage",
-    });
-    expect(payload.TorrentClients?.qbit).toMatchObject({
-      QbitURL: "http://localhost:8080",
-      QbitUser: "user",
-      QbitPass: "secret",
-      AutomaticManagementPaths: ["/media"],
-    });
-  });
-});
-
-describe("ClientSetup client selectors", () => {
-  it("renders default client empty option without a none sentinel", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ClientSetup: {
-                DefaultClient: "",
-              },
-              TorrentClients: {
-                qbit: {
-                  Type: "qbit",
-                  QbitURL: "http://localhost:8080",
-                  QbitUser: "user",
-                  QbitPass: "secret",
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(ClientSetupHarness));
-
-    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue(""));
-
-    const defaultClientSelect = screen.getByLabelText("Default client") as HTMLSelectElement;
-    expect(Array.from(defaultClientSelect.options).map((option) => option.value)).toEqual([
-      "",
-      "qbit",
-    ]);
-    expect(Array.from(defaultClientSelect.options).map((option) => option.textContent)).toEqual([
-      "",
-      "qbit",
-    ]);
-
-    fireEvent.change(defaultClientSelect, { target: { value: "qbit" } });
-    await waitFor(() => expect(defaultClientSelect).toHaveValue("qbit"));
-
-    fireEvent.change(defaultClientSelect, { target: { value: "" } });
-    await waitFor(() => expect(defaultClientSelect).toHaveValue(""));
-
-    const payload = readPayload<{
-      ClientSetup?: { DefaultClient?: string };
-    }>();
-    expect(payload.ClientSetup?.DefaultClient).toBe("");
-  });
-
-  it("renders default, injected, and searching clients as torrent client dropdowns", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ClientSetup: {
-                DefaultClient: "qbit",
-                InjectClients: ["qbit"],
-                SearchClients: ["watcher"],
-              },
-              TorrentClients: {
-                qbit: {
-                  Type: "qbit",
-                  QbitURL: "http://localhost:8080",
-                  QbitUser: "user",
-                  QbitPass: "secret",
-                },
-                watcher: {
-                  Type: "watch",
-                  WatchFolder: "/watch",
-                  StorageDir: "/storage",
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(ClientSetupHarness));
-
-    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue("qbit"));
-
-    expect(screen.getByLabelText("Injected clients 1")).toHaveValue("qbit");
-    expect(screen.getByLabelText("Searching clients 1")).toHaveValue("watcher");
-
-    fireEvent.change(screen.getByLabelText("Default client"), {
-      target: { value: "watcher" },
-    });
-    fireEvent.change(screen.getByLabelText("Injected clients 1"), {
-      target: { value: "watcher" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue("watcher"));
-
-    const payload = readPayload<{
-      ClientSetup?: {
-        DefaultClient?: string;
-        InjectClients?: string[];
-        SearchClients?: string[];
-      };
-    }>();
-    expect(payload.ClientSetup?.DefaultClient).toBe("watcher");
-    expect(payload.ClientSetup?.InjectClients).toEqual(["watcher"]);
-    expect(payload.ClientSetup?.SearchClients).toEqual(["watcher"]);
-  });
-});
-
-describe("Tracker client selectors", () => {
-  it("renders CZT passkey field without preserving stale URL or API key", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  CZT: {
-                    LinkDirName: "",
-                    URL: "https://czteam.example",
-                    APIKey: "service-token",
-                    AnnounceURL: "https://czteam.me/announce.php?passkey=stale",
-                    Passkey: "user-passkey",
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["CZT"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("CZT", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("CZT", { selector: ".settings-card__summary-name" }));
-
-    expect(screen.queryByLabelText("URL")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("API key")).not.toBeInTheDocument();
-    expect(screen.getByLabelText("Passkey")).toHaveValue("[REDACTED]");
-
-    const payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.CZT).toMatchObject({
-      Passkey: "user-passkey",
-    });
-    expect(payload.Trackers?.Trackers?.CZT?.URL).toBeUndefined();
-    expect(payload.Trackers?.Trackers?.CZT?.APIKey).toBeUndefined();
-    expect(payload.Trackers?.Trackers?.CZT?.AnnounceURL).toBeUndefined();
-  });
-
-  it("creates CZT entries with passkey defaults", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {},
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["CZT"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() => expect(screen.getAllByRole("combobox").length).toBeGreaterThan(0));
-
-    const trackerSelects = screen.getAllByRole("combobox");
-    const trackerSelect = trackerSelects[trackerSelects.length - 1] as HTMLSelectElement;
-    fireEvent.change(trackerSelect, { target: { value: "CZT" } });
-    fireEvent.click(screen.getByRole("button", { name: "Add entry" }));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("CZT", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-
-    const payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.CZT).toMatchObject({
-      Passkey: "",
-    });
-    expect(payload.Trackers?.Trackers?.CZT?.URL).toBeUndefined();
-    expect(payload.Trackers?.Trackers?.CZT?.APIKey).toBeUndefined();
-  });
-
-  it("renders tracker torrent client as a configured client dropdown", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  AITHER: {
-                    LinkDirName: "",
-                    APIKey: "",
-                    ImageHost: "",
-                    TorrentClient: "qbit",
-                    Anon: false,
-                  },
-                },
-              },
-              TorrentClients: {
-                qbit: {
-                  Type: "qbit",
-                  QbitURL: "http://localhost:8080",
-                  QbitUser: "user",
-                  QbitPass: "secret",
-                },
-                watcher: {
-                  Type: "watch",
-                  WatchFolder: "/watch",
-                  StorageDir: "/storage",
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["AITHER"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsAdvancedHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("AITHER", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("AITHER", { selector: ".settings-card__summary-name" }));
-
-    await waitFor(() => expect(screen.getByLabelText("Torrent client")).toHaveValue("qbit"));
-
-    const torrentClientSelect = screen.getByLabelText("Torrent client") as HTMLSelectElement;
-    expect(Array.from(torrentClientSelect.options).map((option) => option.textContent)).toEqual([
-      "",
-      "qbit",
-      "watcher",
-    ]);
-
-    fireEvent.change(screen.getByLabelText("Torrent client"), {
-      target: { value: "watcher" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("Torrent client")).toHaveValue("watcher"));
-
-    const payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.AITHER?.TorrentClient).toBe("watcher");
-  });
-
-  it("does not treat catalog tracker entries or default tracker membership as enabled config", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: ["AITHER", "BLU", "BHD"],
-                PreferredTracker: "",
-                Trackers: {
-                  AITHER: {
-                    URL: "https://aither.cc",
-                    APIKey: "",
-                    Anon: false,
-                  },
-                  BLU: {
-                    URL: "https://blutopia.cc",
-                    APIKey: "",
-                    Anon: false,
-                  },
-                  BHD: {
-                    URL: "https://beyond-hd.me",
-                    APIKey: "tracker-token",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: ["AITHER", "BLU", "BHD"],
-                PreferredTracker: "",
-                Trackers: {
-                  AITHER: {
-                    URL: "https://aither.cc",
-                    APIKey: "",
-                    Anon: false,
-                  },
-                  BLU: {
-                    URL: "https://blutopia.cc",
-                    APIKey: "",
-                    Anon: false,
-                  },
-                  BHD: {
-                    URL: "https://beyond-hd.me",
-                    APIKey: "",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          ListKnownTrackers: async () => ["AITHER", "BLU", "BHD"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("BHD", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-
-    expect(screen.queryByText("AITHER", { selector: ".settings-card__summary-name" })).toBeNull();
-    expect(screen.queryByText("BLU", { selector: ".settings-card__summary-name" })).toBeNull();
-    expect(screen.getByText("1/1")).toBeInTheDocument();
-  });
-
-  it("masks encrypted envelopes on tracker URL fields and preserves them for saves", async () => {
-    const encryptedURL = "upbrr-enc:v1:encrypted-btn-url";
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  BTN: {
-                    APIKey: "tracker-token",
-                    URL: encryptedURL,
-                    Username: "",
-                    Password: "",
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["BTN"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("BTN", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("BTN", { selector: ".settings-card__summary-name" }));
-
-    expect(screen.getByLabelText("URL")).toHaveValue("[REDACTED]");
-
-    let payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.BTN?.URL === encryptedURL).toBe(true);
-
-    fireEvent.change(screen.getByLabelText("URL"), {
-      target: { value: "https://btn.example" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("URL")).toHaveValue("https://btn.example"));
-
-    payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.BTN?.URL).toBe("https://btn.example");
-  });
-
-  it("renders BTN announce URL from tracker schema when stored config lacks the key", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  BTN: {
-                    APIKey: "tracker-token",
-                    URL: "https://backup.landof.tv",
-                    Username: "",
-                    Password: "",
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["BTN"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("BTN", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("BTN", { selector: ".settings-card__summary-name" }));
-
-    expect(screen.getByLabelText("Announce URL")).toHaveValue("");
-  });
-
-  it("shows Lostimg as an LST image host only when configured in image hosting", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {
-                LostimgEnabled: true,
-                LostimgAPI: "secret",
-              },
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  LST: {
-                    LinkDirName: "",
-                    APIKey: "tracker-token",
-                    ImageHost: "",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["LST"],
-          GetImageHostPolicyMetadata: async () => ({
-            TrackerUploadHosts: { LST: ["lostimg"] },
-            OwnedHosts: { lostimg: "LST" },
-          }),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("LST", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("LST", { selector: ".settings-card__summary-name" }));
-
-    const imageHostSelect = screen.getByLabelText("Image host") as HTMLSelectElement;
-    expect(Array.from(imageHostSelect.options).map((option) => option.value)).toContain("lostimg");
-  });
-
-  it("shows configured global hosts for LST when Lostimg is disabled", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {
-                Host1: "imgbb",
-                LostimgEnabled: false,
-                LostimgAPI: "",
-              },
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  LST: {
-                    LinkDirName: "",
-                    APIKey: "tracker-token",
-                    ImageHost: "",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["LST"],
-          GetImageHostPolicyMetadata: async () => ({
-            TrackerUploadHosts: { LST: ["lostimg"] },
-            OwnedHosts: { lostimg: "LST" },
-          }),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("LST", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("LST", { selector: ".settings-card__summary-name" }));
-
-    const values = Array.from(
-      (screen.getByLabelText("Image host") as HTMLSelectElement).options,
-    ).map((option) => option.value);
-    expect(values).toContain("imgbb");
-    expect(values).not.toContain("lostimg");
-  });
-
-  it("shows Reelflix as an RF image host and exposes RF image API", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {},
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  RF: {
-                    LinkDirName: "",
-                    APIKey: "",
-                    ImgAPI: "",
-                    ImageHost: "reelflix",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["RF"],
-          GetImageHostPolicyMetadata: async () => ({
-            TrackerUploadHosts: { RF: ["reelflix"] },
-            OwnedHosts: { reelflix: "RF" },
-          }),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsAdvancedHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("RF", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("RF", { selector: ".settings-card__summary-name" }));
-
-    const imageHostSelect = screen.getByLabelText("Image host") as HTMLSelectElement;
-    expect(Array.from(imageHostSelect.options).map((option) => option.value)).toContain("reelflix");
-
-    fireEvent.change(screen.getByLabelText("Image API"), {
-      target: { value: "secret" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("Image API")).toHaveValue("secret"));
-
-    const payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.RF?.ImgAPI).toBe("secret");
-  });
-
-  it("shows configured global hosts for RF when Reelflix is disabled", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {
-                Host1: "imgbb",
-              },
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  RF: {
-                    LinkDirName: "",
-                    APIKey: "tracker-token",
-                    ImgAPI: "",
-                    ImageHost: "",
-                    Anon: false,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["RF"],
-          GetImageHostPolicyMetadata: async () => ({
-            TrackerUploadHosts: { RF: ["reelflix"] },
-            OwnedHosts: { reelflix: "RF" },
-          }),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("RF", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("RF", { selector: ".settings-card__summary-name" }));
-
-    const values = Array.from(
-      (screen.getByLabelText("Image host") as HTMLSelectElement).options,
-    ).map((option) => option.value);
-    expect(values).toContain("imgbb");
-    expect(values).not.toContain("reelflix");
-  });
-});
-
-describe("tracker advanced fields", () => {
-  it("hides only the tracker advanced allowlist when advanced is closed", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              Trackers: {
-                DefaultTrackers: [],
-                PreferredTracker: "",
-                Trackers: {
-                  MTV: {
-                    FaviconURL: "https://example.test/favicon.ico",
-                    LinkDirName: "mtv",
-                    APIKey: "api-key",
-                    Username: "user",
-                    Password: "pass",
-                    AnnounceURL: "https://example.test/announce",
-                    Anon: false,
-                    OTPURI: "otpauth://totp/example",
-                    SkipIfRehash: true,
-                    PreferMTV: true,
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => ["MTV"],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(TrackerSettingsHarness));
-
-    await waitFor(() =>
-      expect(
-        screen.getByText("MTV", { selector: ".settings-card__summary-name" }),
-      ).toBeInTheDocument(),
-    );
-    fireEvent.click(screen.getByText("MTV", { selector: ".settings-card__summary-name" }));
-
-    expect(screen.queryByLabelText("Favicon URL")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("Link dir name")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("Skip if rehash")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("Prefer MTV torrent")).not.toBeInTheDocument();
-    expect(screen.getByLabelText("Announce URL")).toBeInTheDocument();
-    expect(screen.getByLabelText("OTP URI")).toBeInTheDocument();
-  });
-});
-
-describe("Image hosting settings", () => {
-  it("renders Lostimg as tracker-specific and keeps it out of global host priority", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {
-                Host1: "",
-                Host2: "",
-                Host3: "",
-                Host4: "",
-                Host5: "",
-                Host6: "",
-                LostimgEnabled: false,
-                LostimgAPI: "",
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(ImageHostingHarness));
-
-    await waitFor(() => expect(screen.getByLabelText("LST Lostimg")).toBeInTheDocument());
-
-    const hostOne = screen.getByLabelText("Host 1") as HTMLSelectElement;
-    expect(Array.from(hostOne.options).map((option) => option.value)).not.toContain("lostimg");
-
-    fireEvent.click(screen.getByLabelText("LST Lostimg"));
-    fireEvent.change(screen.getByLabelText("API key"), {
-      target: { value: "secret" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("LST Lostimg")).toBeChecked());
-
-    const payload = readPayload<{
-      ImageHosting?: {
-        LostimgEnabled?: boolean;
-        LostimgAPI?: string;
-      };
-    }>();
-    expect(payload.ImageHosting?.LostimgEnabled).toBe(true);
-    expect(payload.ImageHosting?.LostimgAPI).toBe("secret");
-  });
-
-  it("renders Reelflix as an RF image host in image hosting settings", async () => {
-    (globalThis as typeof globalThis & { go?: any }).go = {
-      guiapp: {
-        App: {
-          GetConfig: async () =>
-            JSON.stringify({
-              ImageHosting: {
-                Host1: "",
-                Host2: "",
-                Host3: "",
-                Host4: "",
-                Host5: "",
-                Host6: "",
-              },
-              Trackers: {
-                Trackers: {
-                  RF: {
-                    ImageHost: "",
-                    ImgAPI: "",
-                  },
-                },
-              },
-            }),
-          GetDefaultConfig: async () => JSON.stringify({}),
-          ListKnownTrackers: async () => [],
-          GetImageHostPolicyMetadata: async () => ({}),
-        },
-      },
-    };
-
-    render(createElement(ImageHostingHarness));
-
-    await waitFor(() => expect(screen.getByLabelText("RF Reelflix")).toBeInTheDocument());
-
-    const hostOne = screen.getByLabelText("Host 1") as HTMLSelectElement;
-    expect(Array.from(hostOne.options).map((option) => option.value)).not.toContain("reelflix");
-
-    fireEvent.click(screen.getByLabelText("RF Reelflix"));
-    fireEvent.change(screen.getByLabelText("Image API"), {
-      target: { value: "secret" },
-    });
-
-    await waitFor(() => expect(screen.getByLabelText("RF Reelflix")).toBeChecked());
-
-    const payload = readPayload<{
-      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
-    }>();
-    expect(payload.Trackers?.Trackers?.RF?.ImageHost).toBe("reelflix");
-    expect(payload.Trackers?.Trackers?.RF?.ImgAPI).toBe("secret");
-  });
-});
diff --git a/gui/frontend/src/hooks/useSettingsState.tsx b/gui/frontend/src/hooks/useSettingsState.tsx
deleted file mode 100644
index b45cbabd..00000000
--- a/gui/frontend/src/hooks/useSettingsState.tsx
+++ /dev/null
@@ -1,2591 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useCallback, useEffect, useMemo, useState } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import { Button } from "../components/ui/button";
-import { PillCheckbox } from "../components/ui/checkbox";
-import { Switch } from "../components/ui/switch";
-import type { ConfigMap, ConfigValue, FieldMeta, ImageHostPolicyMetadata } from "../types";
-import { formatLabel, normalizeDefaultTrackerList } from "../utils/settings";
-
-type SettingsSection = { key: string; jsonKey: string; label: string };
-
-const settingsInputClass =
-  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
-
-const settingsSelectClass = `${settingsInputClass} cursor-pointer`;
-type FieldOption = NonNullable<FieldMeta["options"]>[number];
-
-type UseSettingsStateOptions = {
-  activeTab: string;
-};
-
-type UseSettingsStateResult = {
-  configData: ConfigMap | null;
-  settingsLoading: boolean;
-  settingsDirty: boolean;
-  settingsSaved: string;
-  settingsError: string;
-  settingsSection: string;
-  settingsSections: SettingsSection[];
-  showAdvancedToggle: boolean;
-  advancedOpen: boolean;
-  setSettingsSection: Dispatch<SetStateAction<string>>;
-  setSettingsAdvanced: Dispatch<SetStateAction<Record<string, boolean>>>;
-  loadSettings: () => void;
-  handleSaveSettings: () => void;
-  renderImageHostingSection: () => JSX.Element | null;
-  renderTrackerSection: (advancedOpen: boolean) => JSX.Element | null;
-  renderTorrentClientsSection: (advancedOpen: boolean) => JSX.Element | null;
-  renderMapSection: (
-    sectionKey: string,
-    sectionValue: ConfigMap,
-    options?: {
-      entriesKey?: string;
-      defaultKey?: string;
-      fieldMeta?: Record<string, FieldMeta>;
-      advancedOpen?: boolean;
-    },
-  ) => JSX.Element;
-  renderField: (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => JSX.Element;
-  sectionFieldMeta: Record<string, Record<string, FieldMeta>>;
-  updateConfigValue: (path: string[], value: ConfigValue) => void;
-  updateScreenshotConfigValue: (key: string, value: ConfigValue) => void;
-  configuredImageHosts: string[];
-  screenshotConfig: ConfigMap | null;
-  buildSavePayload: () => string | null;
-  clearSettingsStatus: () => void;
-  markSettingsSaved: (message: string) => void;
-  setSettingsSavedMessage: (message: string) => void;
-  setSettingsErrorMessage: (message: string) => void;
-  resolveImageHostLabel: (value: string) => string;
-  knownTrackersLoading: boolean;
-  trackerSelectionNames: string[];
-};
-
-const settingsSections: SettingsSection[] = [
-  { key: "main_settings", jsonKey: "MainSettings", label: "Main" },
-  { key: "image_hosting", jsonKey: "ImageHosting", label: "Image Hosting" },
-  { key: "metadata", jsonKey: "Metadata", label: "Metadata" },
-  { key: "screenshot_handling", jsonKey: "ScreenshotHandling", label: "Screens" },
-  { key: "description_settings", jsonKey: "Description", label: "Description" },
-  { key: "arr_integration", jsonKey: "ArrIntegration", label: "Arr" },
-  { key: "post_upload", jsonKey: "PostUpload", label: "Post Upload" },
-  { key: "trackers", jsonKey: "Trackers", label: "Trackers" },
-  { key: "torrent_clients", jsonKey: "TorrentClients", label: "Torrent Clients" },
-  { key: "client_setup", jsonKey: "ClientSetup", label: "Client Handling" },
-  { key: "torrent_creation", jsonKey: "TorrentCreation", label: "Torrent Specific" },
-];
-
-const imageHostOptions = [
-  { value: "", label: "None" },
-  { value: "imgbb", label: "ImgBB" },
-  { value: "imgbox", label: "ImgBox" },
-  { value: "pixhost", label: "Pixhost" },
-  { value: "lensdump", label: "Lensdump" },
-  { value: "ptscreens", label: "PTScreens" },
-  { value: "onlyimage", label: "OnlyImage" },
-  { value: "dalexni", label: "Dalexni" },
-  { value: "zipline", label: "Zipline" },
-  { value: "passtheimage", label: "PassTheImage" },
-  { value: "seedpool_cdn", label: "Seedpool CDN" },
-  { value: "sharex", label: "ShareX" },
-  { value: "utppm", label: "UTPPM" },
-];
-
-const trackerImageHostOptions = [
-  ...imageHostOptions,
-  { value: "hdb", label: "HDB" },
-  { value: "lostimg", label: "Lostimg" },
-  { value: "reelflix", label: "Reelflix" },
-];
-const torrentClientTypeOptions = [
-  { value: "qbit", label: "qBit" },
-  { value: "watch", label: "Watch" },
-];
-const torrentClientLinkingOptions = [
-  { value: "", label: "None" },
-  { value: "hardlink", label: "Hardlink" },
-  { value: "reflink", label: "Reflink" },
-  { value: "symlink", label: "Symlink" },
-];
-const imageHostOptionLabels = new Map(
-  trackerImageHostOptions.map((option) => [option.value, option.label]),
-);
-const defaultOwnedImageHosts: Record<string, string> = {
-  hdb: "HDB",
-  lostimg: "LST",
-  reelflix: "RF",
-};
-const normalizeImageHostValue = (value: string) => value.trim().toLowerCase();
-const imageHostOptionFor = (host: string) => {
-  const value = normalizeImageHostValue(host);
-  return { value, label: imageHostOptionLabels.get(value) ?? value };
-};
-
-const imageHostKeyMap: Record<string, string[]> = {
-  imgbb: ["ImgBBAPI"],
-  lensdump: ["LensdumpAPI"],
-  ptscreens: ["PTScreensAPI"],
-  onlyimage: ["OnlyImageAPI"],
-  dalexni: ["DalexniAPI"],
-  zipline: ["ZiplineURL", "ZiplineAPIKey"],
-  passtheimage: ["PassTheImageAPI"],
-  seedpool_cdn: ["SeedpoolCDNAPI"],
-  sharex: ["ShareXURL", "ShareXAPIKey"],
-  utppm: ["UTPPMAPI"],
-};
-
-const stringField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
-  key,
-  type: "string",
-  ...meta,
-});
-const boolField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
-  key,
-  type: "boolean",
-  ...meta,
-});
-const numberField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
-  key,
-  type: "number",
-  ...meta,
-});
-
-const trackerFieldMeta: Record<string, FieldMeta> = {
-  LinkDirName: stringField("LinkDirName", { label: "Link dir name", advanced: true }),
-  APIKey: stringField("APIKey", { label: "API key", sensitive: true }),
-  ApiKey: stringField("ApiKey", { label: "API key", sensitive: true }),
-  ApiUser: stringField("ApiUser", { label: "API user", sensitive: true }),
-  Username: stringField("Username", { label: "Username" }),
-  Password: stringField("Password", { label: "Password", sensitive: true }),
-  Passkey: stringField("Passkey", { label: "Passkey", sensitive: true }),
-  AnnounceURL: stringField("AnnounceURL", {
-    label: "Announce URL",
-    sensitive: true,
-  }),
-  MyAnnounceURL: stringField("MyAnnounceURL", {
-    label: "My announce URL",
-    sensitive: true,
-  }),
-  URL: stringField("URL", { label: "URL" }),
-  FaviconURL: stringField("FaviconURL", { label: "Favicon URL", advanced: true }),
-  UploaderName: stringField("UploaderName", { label: "Uploader name" }),
-  UploaderStatus: boolField("UploaderStatus", { label: "Uploader status" }),
-  CustomLayout: stringField("CustomLayout", { label: "Custom layout" }),
-  TagForCustomRelease: stringField("TagForCustomRelease", { label: "Tag for custom release" }),
-  CheckForRules: boolField("CheckForRules", { label: "Check for rules" }),
-  ModQ: boolField("ModQ", { label: "Mod queue" }),
-  Draft: boolField("Draft", { label: "Draft" }),
-  DraftDefault: boolField("DraftDefault", { label: "Draft default" }),
-  Anon: boolField("Anon", { label: "Anonymous" }),
-  ShowGroupIfAnon: boolField("ShowGroupIfAnon", { label: "Show group if anon" }),
-  BhdRSSKey: stringField("BhdRSSKey", { label: "BHD RSS key", sensitive: true }),
-  CheckRequests: boolField("CheckRequests", { label: "Check requests" }),
-  FullMediainfo: boolField("FullMediainfo", { label: "Full mediainfo" }),
-  ImgRehost: boolField("ImgRehost", { label: "Image rehost" }),
-  ImageHost: stringField("ImageHost", {
-    label: "Image host",
-    options: imageHostOptions,
-  }),
-  TorrentClient: stringField("TorrentClient", { label: "Torrent client", advanced: true }),
-  UseSpanishTitle: boolField("UseSpanishTitle", { label: "Use Spanish title" }),
-  UseItalianTitle: boolField("UseItalianTitle", { label: "Use Italian title" }),
-  OTPURI: stringField("OTPURI", { label: "OTP URI", sensitive: true }),
-  SkipIfRehash: boolField("SkipIfRehash", { label: "Skip if rehash", advanced: true }),
-  PreferMTV: boolField("PreferMTV", { label: "Prefer MTV torrent", advanced: true }),
-  PTGenAPI: stringField("PTGenAPI", { label: "PTGen API", sensitive: true }),
-  AddWebSourceToDesc: boolField("AddWebSourceToDesc", {
-    label: "Add web source to desc",
-  }),
-  ImageCount: numberField("ImageCount", { label: "Image count" }),
-  Channel: stringField("Channel", { label: "Channel" }),
-  ImgAPI: stringField("ImgAPI", { label: "Image API", sensitive: true }),
-  PronfoAPIKey: stringField("PronfoAPIKey", {
-    label: "Pronfo API key",
-    sensitive: true,
-  }),
-  PronfoTheme: stringField("PronfoTheme", { label: "Pronfo theme" }),
-  PronfoRAPIID: stringField("PronfoRAPIID", { label: "Pronfo RAPI ID" }),
-  APIUpload: boolField("APIUpload", { label: "API upload" }),
-  Exclusive: boolField("Exclusive", { label: "Exclusive" }),
-  LoginQuestion: stringField("LoginQuestion", {
-    label: "Login question",
-    sensitive: true,
-  }),
-  LoginAnswer: stringField("LoginAnswer", {
-    label: "Login answer",
-    sensitive: true,
-  }),
-  UserID: stringField("UserID", { label: "User ID", sensitive: true }),
-  Filebrowser: stringField("Filebrowser", { label: "Filebrowser" }),
-};
-
-const trackerSchemas: Record<string, FieldMeta[]> = {
-  A4K: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  ACM: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  AITHER: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  ANT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  AR: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.AnnounceURL,
-  ],
-  ASC: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.UploaderStatus,
-    trackerFieldMeta.CustomLayout,
-    trackerFieldMeta.AnnounceURL,
-  ],
-  AZ: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.CheckForRules,
-  ],
-  BHD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.BhdRSSKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.DraftDefault,
-    trackerFieldMeta.Anon,
-  ],
-  BHDTV: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.MyAnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  BJS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ShowGroupIfAnon,
-  ],
-  BLU: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  BT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  BTN: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.URL,
-    trackerFieldMeta.OTPURI,
-  ],
-  CBR: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-    trackerFieldMeta.TagForCustomRelease,
-  ],
-  CZ: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.CheckForRules,
-  ],
-  CZT: [trackerFieldMeta.FaviconURL, trackerFieldMeta.LinkDirName, trackerFieldMeta.Passkey],
-  DC: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  DP: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  EMUW: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.UseSpanishTitle,
-  ],
-  FF: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.CheckRequests,
-    trackerFieldMeta.FullMediainfo,
-  ],
-  FL: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Passkey,
-    trackerFieldMeta.UploaderName,
-    trackerFieldMeta.Anon,
-  ],
-  FRIKI: [trackerFieldMeta.FaviconURL, trackerFieldMeta.LinkDirName, trackerFieldMeta.APIKey],
-  GPW: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-  ],
-  HDB: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Passkey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.ImgRehost,
-  ],
-  HDS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.FullMediainfo,
-  ],
-  HDT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.URL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.FullMediainfo,
-  ],
-  HHD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  IHD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  IS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  ITT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  LCD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.TagForCustomRelease,
-  ],
-  LDU: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  LST: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-    trackerFieldMeta.Draft,
-  ],
-  LT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  LUME: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  MNS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  MTV: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.OTPURI,
-    trackerFieldMeta.SkipIfRehash,
-    trackerFieldMeta.PreferMTV,
-  ],
-  NBL: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-  ],
-  OE: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  OTW: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.ModQ,
-    trackerFieldMeta.Anon,
-  ],
-  PHD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.CheckForRules,
-  ],
-  PT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  PTP: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.AddWebSourceToDesc,
-    trackerFieldMeta.ApiUser,
-    trackerFieldMeta.ApiKey,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.OTPURI,
-  ],
-  PTS: [trackerFieldMeta.FaviconURL, trackerFieldMeta.LinkDirName, trackerFieldMeta.AnnounceURL],
-  PTT: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  R4E: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  RAS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  RF: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.ImgAPI,
-    trackerFieldMeta.Anon,
-  ],
-  RTF: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  SAM: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.TagForCustomRelease,
-  ],
-  SHRI: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.UseItalianTitle,
-  ],
-  SP: [trackerFieldMeta.FaviconURL, trackerFieldMeta.LinkDirName, trackerFieldMeta.APIKey],
-  SPD: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Channel,
-  ],
-  STC: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  THR: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.Username,
-    trackerFieldMeta.Password,
-    trackerFieldMeta.ImgAPI,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.PronfoAPIKey,
-    trackerFieldMeta.PronfoTheme,
-    trackerFieldMeta.PronfoRAPIID,
-    trackerFieldMeta.Anon,
-  ],
-  TIK: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  TL: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIUpload,
-    trackerFieldMeta.Passkey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ImgRehost,
-    trackerFieldMeta.FullMediainfo,
-  ],
-  TLZ: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  TOS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.Exclusive,
-  ],
-  TTR: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  TVC: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.ImageCount,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.AnnounceURL,
-    trackerFieldMeta.Anon,
-  ],
-  ULCX: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  UTP: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  YUS: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-  ],
-  ZNTH: [
-    trackerFieldMeta.FaviconURL,
-    trackerFieldMeta.LinkDirName,
-    trackerFieldMeta.APIKey,
-    trackerFieldMeta.Anon,
-    trackerFieldMeta.ModQ,
-  ],
-  MANUAL: [trackerFieldMeta.FaviconURL, trackerFieldMeta.Filebrowser],
-};
-
-const trackerHasAdvancedFields = Object.values(trackerSchemas).some((fields) =>
-  fields.some((field) => field.advanced),
-);
-
-const REDACTED_VALUE = "[REDACTED]";
-const ENCRYPTED_SECRET_PREFIX = "upbrr-enc:v1:";
-const trackerActivationKeys = new Set([
-  "APIKey",
-  "ApiUser",
-  "ApiKey",
-  "Username",
-  "Password",
-  "Passkey",
-  "AnnounceURL",
-  "MyAnnounceURL",
-  "BhdRSSKey",
-  "OTPURI",
-  "PTGenAPI",
-  "ImageHost",
-  "ImgAPI",
-  "TorrentClient",
-  "PronfoAPIKey",
-  "LoginQuestion",
-  "LoginAnswer",
-  "UserID",
-  "Filebrowser",
-]);
-
-function hasConfiguredTrackerValue(
-  value: ConfigValue | undefined,
-  baseline: ConfigValue | undefined,
-): boolean {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return false;
-    }
-    return baseline !== value;
-  }
-  if (typeof value === "number") {
-    return value !== 0 && baseline !== value;
-  }
-  if (typeof value === "boolean") {
-    return value && baseline !== value;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return false;
-    }
-    if (Array.isArray(baseline) && JSON.stringify(value) === JSON.stringify(baseline)) {
-      return false;
-    }
-    return true;
-  }
-  if (value && typeof value === "object") {
-    if (Object.keys(value).length === 0) {
-      return false;
-    }
-    if (
-      baseline &&
-      typeof baseline === "object" &&
-      JSON.stringify(value) === JSON.stringify(baseline)
-    ) {
-      return false;
-    }
-    return true;
-  }
-  return false;
-}
-const sensitiveKeyHints = [
-  "password",
-  "passkey",
-  "token",
-  "api",
-  "key",
-  "secret",
-  "cookie",
-  "session",
-  "otp",
-  "announce_url",
-  "announceurl",
-];
-
-const sectionFieldMeta: Record<string, Record<string, FieldMeta>> = {
-  ImageHosting: {
-    LostimgAPI: stringField("LostimgAPI", { label: "API key", sensitive: true }),
-  },
-  MainSettings: {
-    InputHistoryLimit: { key: "InputHistoryLimit", label: "Input history limit", type: "number" },
-    UseFavicons: { key: "UseFavicons", label: "Use favicons" },
-    FaviconOnly: { key: "FaviconOnly", label: "Favicon only" },
-    SceneDetection: { key: "SceneDetection", label: "Scene detection (srrdb)" },
-  },
-  Metadata: {
-    BTNAPI: { key: "BTNAPI", advanced: true, sensitive: true },
-    SkipAutoTorrent: { key: "SkipAutoTorrent", advanced: true },
-    SkipTrackerFilenameLookup: { key: "SkipTrackerFilenameLookup", advanced: true },
-    UserOverrides: { key: "UserOverrides", advanced: true },
-    BlurayScore: { key: "BlurayScore", advanced: true },
-    BluraySingleScore: { key: "BluraySingleScore", advanced: true },
-    CheckPredb: { key: "CheckPredb", advanced: true },
-  },
-  ScreenshotHandling: {
-    MaxMenuItems: { key: "MaxMenuItems", label: "Maximum DVD menu images", type: "number" },
-    ProcessLimit: { key: "ProcessLimit", advanced: true },
-    MaxConcurrentUploads: { key: "MaxConcurrentUploads", advanced: true },
-    FFmpegLimit: { key: "FFmpegLimit", advanced: true },
-    FFmpegCompression: { key: "FFmpegCompression", advanced: true },
-    TonemapAlgorithm: { key: "TonemapAlgorithm", advanced: true },
-    Desat: { key: "Desat", advanced: true },
-  },
-  Description: {
-    LogoSize: { key: "LogoSize", advanced: true },
-    LogoLanguage: { key: "LogoLanguage", advanced: true },
-    CharLimit: { key: "CharLimit", advanced: true },
-    FileLimit: { key: "FileLimit", advanced: true },
-    ProcessLimit: { key: "ProcessLimit", advanced: true },
-    CustomSignature: { key: "CustomSignature", advanced: true },
-  },
-  ArrIntegration: {
-    SonarrURL1: { key: "SonarrURL1", advanced: true },
-    SonarrAPIKey1: { key: "SonarrAPIKey1", advanced: true, sensitive: true },
-    SonarrURL2: { key: "SonarrURL2", advanced: true },
-    SonarrAPIKey2: { key: "SonarrAPIKey2", advanced: true, sensitive: true },
-    SonarrURL3: { key: "SonarrURL3", advanced: true },
-    SonarrAPIKey3: { key: "SonarrAPIKey3", advanced: true, sensitive: true },
-    RadarrURL1: { key: "RadarrURL1", advanced: true },
-    RadarrAPIKey1: { key: "RadarrAPIKey1", advanced: true, sensitive: true },
-    RadarrURL2: { key: "RadarrURL2", advanced: true },
-    RadarrAPIKey2: { key: "RadarrAPIKey2", advanced: true, sensitive: true },
-    RadarrURL3: { key: "RadarrURL3", advanced: true },
-    RadarrAPIKey3: { key: "RadarrAPIKey3", advanced: true, sensitive: true },
-    EmbyDir: { key: "EmbyDir", advanced: true },
-    EmbyTVDir: { key: "EmbyTVDir", advanced: true },
-  },
-  TorrentCreation: {},
-  PostUpload: {
-    InjectDelay: { key: "InjectDelay", advanced: true },
-    MaxConcurrentTrackers: { key: "MaxConcurrentTrackers", advanced: true },
-  },
-  Logging: {},
-  TorrentClients: {
-    Type: stringField("Type", { label: "Type", options: torrentClientTypeOptions }),
-    WatchFolder: stringField("WatchFolder", { label: "Watch folder" }),
-    StorageDir: stringField("StorageDir", { label: "Storage directory" }),
-    QuiProxyURL: stringField("QuiProxyURL", { label: "Qui proxy URL", sensitive: true }),
-    QbitURL: stringField("QbitURL", { label: "qBit URL" }),
-    QbitPort: numberField("QbitPort", { label: "qBit port" }),
-    QbitUser: stringField("QbitUser", { label: "qBit user", sensitive: true }),
-    QbitPass: stringField("QbitPass", { label: "qBit pass", sensitive: true }),
-    QbitCategoryValue: stringField("QbitCategoryValue", { label: "qBit category" }),
-    QbitTag: stringField("QbitTag", { label: "qBit tag" }),
-    QbitCrossCategory: stringField("QbitCrossCategory", { label: "qBit cross category" }),
-    QbitCrossTag: stringField("QbitCrossTag", { label: "qBit cross tag" }),
-    UseTrackerAsTag: boolField("UseTrackerAsTag", { label: "Use tracker as tag" }),
-    Linking: stringField("Linking", {
-      label: "Linking",
-      options: torrentClientLinkingOptions,
-    }),
-    AllowFallback: boolField("AllowFallback", { label: "Allow link fallback" }),
-    LinkedFolder: stringField("LinkedFolder", { label: "Linked folder" }),
-    LocalPath: stringField("LocalPath", { label: "Local path" }),
-    RemotePath: stringField("RemotePath", { label: "Remote path" }),
-    AutomaticManagementPaths: stringField("AutomaticManagementPaths", {
-      label: "Automatic management paths",
-    }),
-    VerifyWebUICertificate: boolField("VerifyWebUICertificate", {
-      label: "Verify WebUI certificate",
-      advanced: true,
-    }),
-  },
-};
-
-const isSensitiveKeyName = (key: string) => {
-  const lower = key.toLowerCase();
-  return sensitiveKeyHints.some((hint) => lower.includes(hint));
-};
-
-const buildPathKey = (path: string[]) => path.join(".");
-
-const isEncryptedSecretEnvelope = (value: string) => value.startsWith(ENCRYPTED_SECRET_PREFIX);
-
-/** Masks secret-bearing config strings while retaining originals by config path for save payloads. */
-const maskSensitiveConfig = (input: ConfigMap) => {
-  const originals: Record<string, string> = {};
-  const walk = (value: ConfigValue, path: string[]): ConfigValue => {
-    if (value === null || value === undefined) return value;
-    if (Array.isArray(value)) {
-      return value.map((entry, index) => walk(entry, [...path, String(index)]));
-    }
-    if (typeof value === "object") {
-      const next: ConfigMap = {};
-      Object.entries(value).forEach(([key, child]) => {
-        next[key] = walk(child, [...path, key]);
-      });
-      return next;
-    }
-    if (typeof value === "string") {
-      const key = path[path.length - 1] || "";
-      if (value && (isSensitiveKeyName(key) || isEncryptedSecretEnvelope(value))) {
-        originals[buildPathKey(path)] = value;
-        return REDACTED_VALUE;
-      }
-      return value;
-    }
-    return value;
-  };
-
-  return { masked: walk(input, []) as ConfigMap, originals };
-};
-
-const restoreSensitiveConfig = (input: ConfigMap, originals: Record<string, string>) => {
-  const walk = (value: ConfigValue, path: string[]): ConfigValue => {
-    if (value === null || value === undefined) return value;
-    if (Array.isArray(value)) {
-      return value.map((entry, index) => walk(entry, [...path, String(index)]));
-    }
-    if (typeof value === "object") {
-      const next: ConfigMap = {};
-      Object.entries(value).forEach(([key, child]) => {
-        next[key] = walk(child, [...path, key]);
-      });
-      return next;
-    }
-    if (typeof value === "string") {
-      if (value === REDACTED_VALUE) {
-        const original = originals[buildPathKey(path)];
-        if (original !== undefined) {
-          return original;
-        }
-      }
-      return value;
-    }
-    return value;
-  };
-
-  return walk(input, []) as ConfigMap;
-};
-
-const legacyTorrentClientKeys = [
-  "Type",
-  "TorrentClient",
-  "URL",
-  "WatchFolder",
-  "StorageDir",
-  "Username",
-  "Password",
-  "Category",
-  "Tags",
-  "TLSSkipVerify",
-  "QbitTagsValue",
-];
-
-const qbitDefaultClient = (): ConfigMap => ({
-  Type: "qbit",
-  QuiProxyURL: "",
-  QbitCategoryValue: "",
-  QbitTag: "",
-  QbitCrossCategory: "",
-  QbitCrossTag: "",
-  UseTrackerAsTag: false,
-  Linking: "",
-  AllowFallback: true,
-  LinkedFolder: [],
-  LocalPath: [],
-  RemotePath: [],
-  AutomaticManagementPaths: [],
-  VerifyWebUICertificate: true,
-});
-
-const qbitDirectDisabledValues: Readonly<Record<string, ConfigValue>> = {
-  QbitURL: "",
-  QbitPort: 0,
-  QbitUser: "",
-  QbitPass: "",
-  URL: "",
-  Username: "",
-  Password: "",
-  QuiProxyURL: "",
-};
-
-const normalizeStringArray = (value: ConfigValue) => {
-  if (Array.isArray(value)) {
-    return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
-  }
-  if (typeof value === "string") {
-    return value
-      .split(",")
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  }
-  return [];
-};
-
-const normalizeTorrentClientType = (client: ConfigMap) => {
-  const directType = typeof client.Type === "string" ? client.Type.trim() : "";
-  if (directType) {
-    return directType.toLowerCase();
-  }
-  const legacyType = typeof client.TorrentClient === "string" ? client.TorrentClient.trim() : "";
-  if (legacyType) {
-    return legacyType.toLowerCase();
-  }
-  return "qbit";
-};
-
-/**
- * Normalizes a torrent client before save, migrating legacy qBit fields to the
- * canonical qBit keys while preserving non-qBit client configs.
- */
-export const normalizeTorrentClientForSave = (client: ConfigMap) => {
-  const next = { ...client };
-  if (normalizeTorrentClientType(next) !== "qbit") {
-    return next;
-  }
-
-  if (!next.QbitURL && typeof next.URL === "string") next.QbitURL = next.URL;
-  if (!next.QbitUser && typeof next.Username === "string") next.QbitUser = next.Username;
-  if (!next.QbitPass && typeof next.Password === "string") next.QbitPass = next.Password;
-  if (!next.QbitCategoryValue && typeof next.Category === "string") {
-    next.QbitCategoryValue = next.Category;
-  }
-  if (!next.QbitTag) {
-    if (Array.isArray(next.Tags)) {
-      next.QbitTag = normalizeStringArray(next.Tags).join(",");
-    } else if (Array.isArray(next.QbitTagsValue)) {
-      next.QbitTag = normalizeStringArray(next.QbitTagsValue).join(",");
-    }
-  }
-  if (next.VerifyWebUICertificate === undefined && typeof next.TLSSkipVerify === "boolean") {
-    next.VerifyWebUICertificate = !next.TLSSkipVerify;
-  }
-
-  legacyTorrentClientKeys.forEach((key) => {
-    delete next[key];
-  });
-
-  return next;
-};
-
-/**
- * Builds the next qBit direct-connection state for the settings toggle.
- * Enabling seeds host defaults; disabling clears direct, proxy, and legacy
- * credential fields so the client no longer attempts a direct qBit connection.
- */
-export const nextQbitDirectState = (client: ConfigMap, enabled: boolean): ConfigMap => {
-  if (enabled) {
-    return {
-      ...client,
-      QbitURL:
-        typeof client.QbitURL === "string" && client.QbitURL.trim() !== ""
-          ? client.QbitURL
-          : "http://127.0.0.1",
-      QbitPort: typeof client.QbitPort === "number" && client.QbitPort > 0 ? client.QbitPort : 8080,
-    };
-  }
-  return { ...client, ...qbitDirectDisabledValues };
-};
-
-/**
- * Normalizes all configured torrent client entries in a settings payload before
- * serializing it for the backend.
- */
-export const normalizeTorrentClientsForSave = (input: ConfigMap) => {
-  const clients = input.TorrentClients;
-  if (!clients || typeof clients !== "object" || Array.isArray(clients)) {
-    return input;
-  }
-
-  const nextClients: ConfigMap = {};
-  Object.entries(clients as ConfigMap).forEach(([name, value]) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return;
-    }
-    nextClients[name] = normalizeTorrentClientForSave(value as ConfigMap);
-  });
-
-  return { ...input, TorrentClients: nextClients };
-};
-
-const normalizeCZTTrackerForSave = (input: ConfigMap) => {
-  const trackerRoot = input.Trackers;
-  if (!trackerRoot || typeof trackerRoot !== "object" || Array.isArray(trackerRoot)) {
-    return input;
-  }
-  const trackerEntries = (trackerRoot as ConfigMap).Trackers;
-  if (!trackerEntries || typeof trackerEntries !== "object" || Array.isArray(trackerEntries)) {
-    return input;
-  }
-
-  let changed = false;
-  const nextEntries: ConfigMap = {};
-  Object.entries(trackerEntries as ConfigMap).forEach(([name, value]) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      nextEntries[name] = value;
-      return;
-    }
-    if (name.trim().toUpperCase() !== "CZT") {
-      nextEntries[name] = value;
-      return;
-    }
-    const next = { ...(value as ConfigMap) };
-    if ("APIKey" in next) {
-      delete next.APIKey;
-      changed = true;
-    }
-    if ("URL" in next) {
-      delete next.URL;
-      changed = true;
-    }
-    if ("AnnounceURL" in next) {
-      delete next.AnnounceURL;
-      changed = true;
-    }
-    nextEntries[name] = next;
-  });
-
-  if (!changed) {
-    return input;
-  }
-  return {
-    ...input,
-    Trackers: {
-      ...(trackerRoot as ConfigMap),
-      Trackers: nextEntries,
-    },
-  };
-};
-
-/**
- * Owns settings-screen state, Wails config loading, sensitive-value masking,
- * render helpers, and save payload construction for tabs that need config data.
- * Save payloads restore masked secrets before serialization.
- */
-export const useSettingsState = (options: UseSettingsStateOptions): UseSettingsStateResult => {
-  const { activeTab } = options;
-  const [configData, setConfigData] = useState<ConfigMap | null>(null);
-  const [defaultConfig, setDefaultConfig] = useState<ConfigMap | null>(null);
-  const [knownTrackers, setKnownTrackers] = useState<string[]>([]);
-  const [imageHostPolicyMetadata, setImageHostPolicyMetadata] =
-    useState<ImageHostPolicyMetadata | null>(null);
-  const [knownTrackersLoading, setKnownTrackersLoading] = useState(false);
-  const [trackerAddSelection, setTrackerAddSelection] = useState("");
-  const [manualTrackerEntries, setManualTrackerEntries] = useState<Record<string, boolean>>({});
-  const [settingsTrackerPanels, setSettingsTrackerPanels] = useState<Record<string, boolean>>({});
-  const [defaultTrackersPanelOpen, setDefaultTrackersPanelOpen] = useState(false);
-  const [settingsLoading, setSettingsLoading] = useState(false);
-  const [settingsError, setSettingsError] = useState("");
-  const [settingsSaved, setSettingsSaved] = useState("");
-  const [settingsDirty, setSettingsDirty] = useState(false);
-  const [settingsSection, setSettingsSection] = useState(settingsSections[0].key);
-  const [settingsAdvanced, setSettingsAdvanced] = useState<Record<string, boolean>>({});
-  const [sensitiveValues, setSensitiveValues] = useState<Record<string, string>>({});
-
-  const configuredImageHosts = useMemo(() => {
-    if (!configData || !configData.ImageHosting || typeof configData.ImageHosting !== "object") {
-      return [] as string[];
-    }
-    if (Array.isArray(configData.ImageHosting)) {
-      return [] as string[];
-    }
-    const imageCfg = configData.ImageHosting as ConfigMap;
-    const hostFields = ["Host1", "Host2", "Host3", "Host4", "Host5", "Host6"];
-    const hosts: string[] = [];
-    hostFields.forEach((field) => {
-      const value = String(imageCfg[field] ?? "").trim();
-      if (!value) return;
-      if (!hosts.includes(value)) {
-        hosts.push(value);
-      }
-    });
-    return hosts;
-  }, [configData]);
-
-  const screenshotConfig = useMemo(() => {
-    if (
-      !configData ||
-      !configData.ScreenshotHandling ||
-      typeof configData.ScreenshotHandling !== "object"
-    ) {
-      return null;
-    }
-    if (Array.isArray(configData.ScreenshotHandling)) {
-      return null;
-    }
-    return configData.ScreenshotHandling as ConfigMap;
-  }, [configData]);
-
-  const torrentClientOptions = useMemo<FieldOption[]>(() => {
-    if (
-      !configData ||
-      !configData.TorrentClients ||
-      typeof configData.TorrentClients !== "object" ||
-      Array.isArray(configData.TorrentClients)
-    ) {
-      return [];
-    }
-
-    return Object.entries(configData.TorrentClients as ConfigMap)
-      .filter(
-        ([name, value]) =>
-          name.trim() !== "" && value && typeof value === "object" && !Array.isArray(value),
-      )
-      .map(([name]) => ({ value: name, label: name }));
-  }, [configData]);
-
-  const effectiveSectionFieldMeta = useMemo<Record<string, Record<string, FieldMeta>>>(() => {
-    const clientOptions = [{ value: "", label: "" }, ...torrentClientOptions];
-    return {
-      ...sectionFieldMeta,
-      ClientSetup: {
-        ...(sectionFieldMeta.ClientSetup ?? {}),
-        DefaultClient: stringField("DefaultClient", {
-          label: "Default client",
-          options: clientOptions,
-        }),
-        InjectClients: stringField("InjectClients", {
-          label: "Injected clients",
-          options: clientOptions,
-        }),
-        SearchClients: stringField("SearchClients", {
-          label: "Searching clients",
-          options: clientOptions,
-        }),
-      },
-    };
-  }, [torrentClientOptions]);
-
-  const setSettingsErrorMessage = (message: string) => {
-    setSettingsError(message);
-  };
-
-  const clearSettingsStatus = useCallback(() => {
-    setSettingsError("");
-    setSettingsSaved("");
-  }, []);
-
-  const markSettingsSaved = (message: string) => {
-    setSettingsSaved(message);
-    setSettingsDirty(false);
-  };
-
-  const setSettingsSavedMessage = (message: string) => {
-    setSettingsSaved(message);
-  };
-
-  const buildSavePayload = () => {
-    if (!configData) {
-      return null;
-    }
-    const restored = normalizeCZTTrackerForSave(
-      normalizeTorrentClientsForSave(restoreSensitiveConfig(configData, sensitiveValues)),
-    );
-    return JSON.stringify(restored, null, 2);
-  };
-
-  const resolveImageHostLabel = (value: string) => {
-    return imageHostOptionLabels.get(value) ?? value;
-  };
-
-  const buildImageHostOptions = useCallback((hosts: string[]) => {
-    const allowed = new Set(
-      hosts.map((host) => normalizeImageHostValue(host)).filter((host) => host.length > 0),
-    );
-    const ordered = imageHostOptions.filter(
-      (option) => option.value === "" || allowed.has(option.value),
-    );
-    const known = new Set(ordered.map((option) => option.value));
-    const extras = Array.from(allowed)
-      .filter((host) => !known.has(host))
-      .sort((left, right) => left.localeCompare(right))
-      .map(imageHostOptionFor);
-    return [...ordered, ...extras];
-  }, []);
-
-  const trackerOptionsForImageHost = useCallback(
-    (trackerName: string) => {
-      const trackerKey = trackerName.trim().toUpperCase();
-      if (!imageHostPolicyMetadata) {
-        return trackerKey === "HDB" ? trackerImageHostOptions : imageHostOptions;
-      }
-
-      const policyHosts = imageHostPolicyMetadata.TrackerUploadHosts?.[trackerKey];
-      const fallbackHosts =
-        imageHostPolicyMetadata.UploadHosts?.map((host) => normalizeImageHostValue(host)) ??
-        imageHostOptions.filter((option) => option.value).map((option) => option.value);
-      const ownerByHost = imageHostPolicyMetadata.OwnedHosts ?? defaultOwnedImageHosts;
-      const imageCfg =
-        configData?.ImageHosting &&
-        typeof configData.ImageHosting === "object" &&
-        !Array.isArray(configData.ImageHosting)
-          ? (configData.ImageHosting as ConfigMap)
-          : null;
-      const trackerRoot =
-        configData?.Trackers &&
-        typeof configData.Trackers === "object" &&
-        !Array.isArray(configData.Trackers)
-          ? (configData.Trackers as ConfigMap)
-          : null;
-      const trackerEntries =
-        trackerRoot?.Trackers &&
-        typeof trackerRoot.Trackers === "object" &&
-        !Array.isArray(trackerRoot.Trackers)
-          ? (trackerRoot.Trackers as ConfigMap)
-          : null;
-      const trackerCfg =
-        trackerEntries?.[trackerKey] &&
-        typeof trackerEntries[trackerKey] === "object" &&
-        !Array.isArray(trackerEntries[trackerKey])
-          ? (trackerEntries[trackerKey] as ConfigMap)
-          : null;
-      const globalFallbackHosts = fallbackHosts.filter((host) => !ownerByHost[host]);
-      const globalHosts = (configuredImageHosts.length ? configuredImageHosts : globalFallbackHosts)
-        .map((host) => normalizeImageHostValue(host))
-        .filter((host) => host.length > 0 && !ownerByHost[host]);
-      const policyHostSet = new Set(
-        (policyHosts ?? []).map((host) => normalizeImageHostValue(host)).filter(Boolean),
-      );
-      const policyHasGlobalHosts = Array.from(policyHostSet).some((host) => !ownerByHost[host]);
-      const policyAllowsGlobalFallback =
-        policyHostSet.size === 0 ||
-        Array.from(policyHostSet).every((host) => host === "lostimg" || host === "reelflix");
-      const hosts = globalHosts.filter(
-        (host) => policyAllowsGlobalFallback || (policyHasGlobalHosts && policyHostSet.has(host)),
-      );
-
-      (policyHosts ?? []).forEach((host) => {
-        const normalizedHost = normalizeImageHostValue(host);
-        const owner = ownerByHost[normalizedHost];
-        if (!owner || owner.trim().toUpperCase() !== trackerKey) {
-          return;
-        }
-        if (normalizedHost === "lostimg" && !Boolean(imageCfg?.LostimgEnabled)) {
-          return;
-        }
-        if (
-          normalizedHost === "reelflix" &&
-          normalizeImageHostValue(String(trackerCfg?.ImageHost ?? "")) !== "reelflix"
-        ) {
-          return;
-        }
-        if (!hosts.includes(normalizedHost)) {
-          hosts.push(normalizedHost);
-        }
-      });
-
-      return buildImageHostOptions(hosts);
-    },
-    [buildImageHostOptions, configData, configuredImageHosts, imageHostPolicyMetadata],
-  );
-
-  const updateConfigValue = (path: string[], value: ConfigValue) => {
-    setConfigData((prev) => {
-      if (!prev) return prev;
-      const clone = structuredClone(prev) as ConfigMap;
-      let cursor: ConfigMap = clone;
-      for (let i = 0; i < path.length - 1; i += 1) {
-        const key = path[i];
-        const next = cursor[key];
-        if (!next || typeof next !== "object" || Array.isArray(next)) {
-          cursor[key] = {};
-        }
-        cursor = cursor[key] as ConfigMap;
-      }
-      cursor[path[path.length - 1]] = value;
-      setSettingsDirty(true);
-      return clone;
-    });
-
-    const key = path[path.length - 1] || "";
-    if (
-      typeof value === "string" &&
-      (isSensitiveKeyName(key) || sensitiveValues[buildPathKey(path)] !== undefined)
-    ) {
-      setSensitiveValues((prev) => {
-        const next = { ...prev };
-        const pathKey = buildPathKey(path);
-        if (value === REDACTED_VALUE) {
-          return prev;
-        }
-        if (!value) {
-          delete next[pathKey];
-          return next;
-        }
-        next[pathKey] = value;
-        return next;
-      });
-    }
-  };
-
-  const updateScreenshotConfigValue = (key: string, value: ConfigValue) => {
-    updateConfigValue(["ScreenshotHandling", key], value);
-  };
-
-  const removeConfigKey = (path: string[], key: string) => {
-    setConfigData((prev) => {
-      if (!prev) return prev;
-      const clone = structuredClone(prev) as ConfigMap;
-      let cursor: ConfigMap = clone;
-      for (let i = 0; i < path.length; i += 1) {
-        cursor = cursor[path[i]] as ConfigMap;
-        if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
-          return prev;
-        }
-      }
-      if (!Object.prototype.hasOwnProperty.call(cursor, key)) {
-        return prev;
-      }
-      delete cursor[key];
-      setSettingsDirty(true);
-      return clone;
-    });
-  };
-
-  const addConfigKey = (path: string[], key: string, value: ConfigValue) => {
-    if (!key.trim()) return;
-    setConfigData((prev) => {
-      if (!prev) return prev;
-      const clone = structuredClone(prev) as ConfigMap;
-      let cursor: ConfigMap = clone;
-      for (let i = 0; i < path.length; i += 1) {
-        const step = path[i];
-        const next = cursor[step];
-        if (!next || typeof next !== "object" || Array.isArray(next)) {
-          cursor[step] = {};
-        }
-        cursor = cursor[step] as ConfigMap;
-      }
-      if (cursor[key] !== undefined) return prev;
-      cursor[key] = value;
-      setSettingsDirty(true);
-      return clone;
-    });
-  };
-
-  const loadSettings = useCallback(async () => {
-    clearSettingsStatus();
-    const getConfig = globalThis.go?.guiapp?.App?.GetConfig;
-    if (!getConfig) {
-      setSettingsError("Settings are unavailable in this build.");
-      return;
-    }
-    setSettingsLoading(true);
-    try {
-      const result = await getConfig();
-      const parsed = JSON.parse(result) as ConfigMap;
-      const masked = maskSensitiveConfig(parsed);
-      setConfigData(masked.masked);
-      setSensitiveValues(masked.originals);
-      setManualTrackerEntries({});
-      setSettingsDirty(false);
-    } catch (err) {
-      setSettingsError(String(err));
-    } finally {
-      setSettingsLoading(false);
-    }
-  }, [clearSettingsStatus]);
-
-  const loadDefaultConfig = useCallback(async () => {
-    const getDefaultConfig = globalThis.go?.guiapp?.App?.GetDefaultConfig;
-    if (!getDefaultConfig) {
-      return;
-    }
-    try {
-      const result = await getDefaultConfig();
-      const parsed = JSON.parse(result) as ConfigMap;
-      setDefaultConfig(parsed);
-    } catch (_err) {
-      // Silently fail if we can't load default config; it's optional for tracker comparison
-    }
-  }, []);
-
-  const loadKnownTrackers = useCallback(async () => {
-    if (knownTrackersLoading) return;
-    const listKnown = globalThis.go?.guiapp?.App?.ListKnownTrackers;
-    if (!listKnown) return;
-    setKnownTrackersLoading(true);
-    try {
-      const result = await listKnown();
-      if (Array.isArray(result)) {
-        setKnownTrackers(result.map((entry) => String(entry)));
-      }
-    } catch (err) {
-      setSettingsError(String(err));
-    } finally {
-      setKnownTrackersLoading(false);
-    }
-  }, [knownTrackersLoading]);
-
-  const loadImageHostPolicyMetadata = useCallback(async () => {
-    const getMetadata = globalThis.go?.guiapp?.App?.GetImageHostPolicyMetadata;
-    if (!getMetadata) return;
-    try {
-      const result = await getMetadata();
-      if (result && typeof result === "object") {
-        setImageHostPolicyMetadata(result);
-      }
-    } catch (err) {
-      setSettingsError(String(err));
-    }
-  }, []);
-
-  const handleSaveSettings = async () => {
-    clearSettingsStatus();
-    const saveConfig = globalThis.go?.guiapp?.App?.SaveConfig;
-    if (!saveConfig) {
-      setSettingsError("Settings are unavailable in this build.");
-      return;
-    }
-    const payload = buildSavePayload();
-    if (!payload) {
-      setSettingsError("Settings are not loaded.");
-      return;
-    }
-    setSettingsLoading(true);
-    try {
-      await saveConfig(payload);
-      markSettingsSaved("Settings saved and applied.");
-    } catch (err) {
-      setSettingsError(String(err));
-    } finally {
-      setSettingsLoading(false);
-    }
-  };
-
-  useEffect(() => {
-    if (
-      (activeTab === "input" ||
-        activeTab === "tracker" ||
-        activeTab === "dupes" ||
-        activeTab === "settings" ||
-        activeTab === "logging" ||
-        activeTab === "upload" ||
-        activeTab === "upload_images") &&
-      !configData
-    ) {
-      loadSettings();
-    }
-  }, [activeTab, configData, loadSettings]);
-
-  useEffect(() => {
-    if (
-      (activeTab === "settings" || activeTab === "input" || activeTab === "upload") &&
-      !defaultConfig
-    ) {
-      loadDefaultConfig();
-    }
-  }, [activeTab, defaultConfig, loadDefaultConfig]);
-
-  useEffect(() => {
-    if (activeTab === "settings" && knownTrackers.length === 0 && !knownTrackersLoading) {
-      loadKnownTrackers();
-    }
-  }, [activeTab, knownTrackers.length, knownTrackersLoading, loadKnownTrackers]);
-
-  useEffect(() => {
-    if (activeTab === "settings" && !imageHostPolicyMetadata) {
-      loadImageHostPolicyMetadata();
-    }
-  }, [activeTab, imageHostPolicyMetadata, loadImageHostPolicyMetadata]);
-
-  useEffect(() => {
-    if ((activeTab === "screenshots" || activeTab === "upload_images") && !configData) {
-      loadSettings();
-    }
-  }, [activeTab, configData, loadSettings]);
-
-  const advancedOpen = settingsAdvanced[settingsSection] ?? false;
-  const showAdvancedToggle = (() => {
-    if (settingsSection === "trackers") return trackerHasAdvancedFields;
-    const section = settingsSections.find((item) => item.key === settingsSection);
-    if (!section) return false;
-    const meta = effectiveSectionFieldMeta[section.jsonKey];
-    if (!meta) return false;
-    return Object.values(meta).some((field) => field.advanced);
-  })();
-
-  const renderArrayEditor = (
-    value: ConfigValue[],
-    path: string[],
-    meta?: FieldMeta,
-    displayLabel?: string,
-  ) => {
-    const options = meta?.options ?? [];
-    const optionValueFor = (entry: ConfigValue) => (entry === null ? "" : String(entry ?? ""));
-    const optionsFor = (entry: ConfigValue) => {
-      const selected = optionValueFor(entry);
-      if (!selected || options.some((option) => option.value === selected)) {
-        return options;
-      }
-      return [...options, { value: selected, label: selected }];
-    };
-    const newItemValue = options.find((option) => option.value !== "")?.value ?? "";
-
-    return (
-      <div className="settings-array">
-        {value.map((entry, index) => (
-          <div className="settings-array-row" key={`${path.join(".")}-${index}`}>
-            {options.length > 0 ? (
-              <select
-                aria-label={displayLabel ? `${displayLabel} ${index + 1}` : undefined}
-                className={settingsSelectClass}
-                value={optionValueFor(entry)}
-                onChange={(event) => {
-                  const updated = [...value];
-                  updated[index] = event.target.value;
-                  updateConfigValue(path, updated);
-                }}
-              >
-                {optionsFor(entry).map((option) => (
-                  <option key={option.value} value={option.value}>
-                    {option.label}
-                  </option>
-                ))}
-              </select>
-            ) : (
-              <input
-                aria-label={displayLabel ? `${displayLabel} ${index + 1}` : undefined}
-                className={settingsInputClass}
-                value={optionValueFor(entry)}
-                onChange={(event) => {
-                  const updated = [...value];
-                  updated[index] = event.target.value;
-                  updateConfigValue(path, updated);
-                }}
-              />
-            )}
-            <Button
-              type="button"
-              onClick={() => {
-                const updated = [...value];
-                updated.splice(index, 1);
-                updateConfigValue(path, updated);
-              }}
-            >
-              Remove
-            </Button>
-          </div>
-        ))}
-        <Button
-          type="button"
-          aria-label={displayLabel ? `Add ${displayLabel} item` : "Add item"}
-          onClick={() => updateConfigValue(path, [...value, newItemValue])}
-        >
-          Add item
-        </Button>
-      </div>
-    );
-  };
-
-  const renderField = (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => {
-    const displayLabel = meta?.label ?? formatLabel(label);
-    const typeHint = meta?.type;
-    if (Array.isArray(value)) {
-      return (
-        <div className="settings-field" key={path.join(".")}>
-          <span>{displayLabel}</span>
-          {renderArrayEditor(value, path, meta, displayLabel)}
-        </div>
-      );
-    }
-    if (meta?.options && meta.options.length > 0) {
-      const selectedValue = value === null ? "" : String(value ?? "");
-      const options = meta.options.some((option) => option.value === selectedValue)
-        ? meta.options
-        : [...meta.options, { value: selectedValue, label: selectedValue }];
-      return (
-        <label className="settings-field" key={path.join(".")}>
-          <span>{displayLabel}</span>
-          <select
-            className={settingsSelectClass}
-            value={selectedValue}
-            onChange={(event) => updateConfigValue(path, event.target.value)}
-          >
-            {options.map((option) => (
-              <option key={option.value} value={option.value}>
-                {option.label}
-              </option>
-            ))}
-          </select>
-        </label>
-      );
-    }
-    if (typeHint === "boolean" || typeof value === "boolean") {
-      return (
-        <div className="settings-switch-row" key={path.join(".")}>
-          <span>{displayLabel}</span>
-          <Switch
-            aria-label={displayLabel}
-            checked={Boolean(value)}
-            onChange={(event) => updateConfigValue(path, event.target.checked)}
-          />
-        </div>
-      );
-    }
-    if (typeHint === "number" || typeof value === "number") {
-      const numericValue = typeof value === "number" && Number.isFinite(value) ? value : 0;
-      return (
-        <label className="settings-field" key={path.join(".")}>
-          <span>{displayLabel}</span>
-          <input
-            className={settingsInputClass}
-            type="number"
-            value={numericValue}
-            onChange={(event) => updateConfigValue(path, Number(event.target.value))}
-          />
-        </label>
-      );
-    }
-    if (value && typeof value === "object") {
-      return (
-        <div className="settings-subgroup" key={path.join(".")}>
-          <div className="settings-subgroup__title">{displayLabel}</div>
-          <div className="settings-grid">
-            {Object.entries(value).map(([childKey, childValue]) =>
-              renderField(childKey, childValue, [...path, childKey]),
-            )}
-          </div>
-        </div>
-      );
-    }
-
-    return (
-      <label className="settings-field" key={path.join(".")}>
-        <span>{displayLabel}</span>
-        <input
-          className={settingsInputClass}
-          value={value === null ? "" : String(value ?? "")}
-          onChange={(event) => updateConfigValue(path, event.target.value)}
-        />
-      </label>
-    );
-  };
-
-  const renderMapSection = (
-    sectionKey: string,
-    sectionValue: ConfigMap,
-    options?: {
-      entriesKey?: string;
-      defaultKey?: string;
-      fieldMeta?: Record<string, FieldMeta>;
-      advancedOpen?: boolean;
-    },
-  ) => {
-    const entriesRoot = options?.entriesKey
-      ? (sectionValue[options.entriesKey] as ConfigMap) || {}
-      : sectionValue;
-    const entries = Object.entries(entriesRoot).filter(
-      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
-    ) as Array<[string, ConfigMap]>;
-    const defaultKey = options?.defaultKey;
-    const fieldMeta = options?.fieldMeta || {};
-    const advancedOpen = options?.advancedOpen ?? false;
-
-    return (
-      <div className="settings-map">
-        {defaultKey ? (
-          <div className="settings-subgroup">
-            <div className="settings-subgroup__title">{formatLabel(defaultKey)}</div>
-            {renderField(defaultKey, sectionValue[defaultKey] as ConfigValue, [
-              sectionKey,
-              defaultKey,
-            ])}
-          </div>
-        ) : null}
-
-        <div className="settings-map__header">
-          <p className="label">Entries</p>
-          <Button
-            type="button"
-            onClick={() => {
-              const name = globalThis.prompt("New entry name");
-              if (!name) return;
-              if (options?.entriesKey) {
-                addConfigKey([sectionKey, options.entriesKey], name, {});
-                return;
-              }
-              addConfigKey([sectionKey], name, {});
-            }}
-          >
-            Add entry
-          </Button>
-        </div>
-
-        <div className="settings-map__grid">
-          {entries.length === 0 ? (
-            <p className="muted">No entries yet.</p>
-          ) : (
-            entries.map(([key, value]) => (
-              <div className="settings-card" key={`${sectionKey}-${key}`}>
-                <div className="settings-card__header">
-                  <p className="value">{key}</p>
-                  <Button
-                    type="button"
-                    onClick={() => {
-                      if (options?.entriesKey) {
-                        removeConfigKey([sectionKey, options.entriesKey], key);
-                        return;
-                      }
-                      removeConfigKey([sectionKey], key);
-                    }}
-                  >
-                    Remove
-                  </Button>
-                </div>
-                <div className="settings-grid">
-                  {Object.entries(value)
-                    .filter(([childKey]) => {
-                      const meta = fieldMeta[childKey];
-                      if (meta?.advanced && !advancedOpen) return false;
-                      return true;
-                    })
-                    .map(([childKey, childValue]) =>
-                      renderField(
-                        childKey,
-                        childValue,
-                        [sectionKey, options?.entriesKey || "", key, childKey].filter(Boolean),
-                        fieldMeta[childKey],
-                      ),
-                    )}
-                </div>
-              </div>
-            ))
-          )}
-        </div>
-      </div>
-    );
-  };
-
-  const renderTorrentClientsSection = (advancedOpen: boolean) => {
-    if (
-      !configData ||
-      !configData.TorrentClients ||
-      typeof configData.TorrentClients !== "object" ||
-      Array.isArray(configData.TorrentClients)
-    ) {
-      return null;
-    }
-
-    const clients = Object.entries(configData.TorrentClients as ConfigMap).filter(
-      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
-    ) as Array<[string, ConfigMap]>;
-    const meta = effectiveSectionFieldMeta.TorrentClients || {};
-    const valueFor = (client: ConfigMap, primary: string, fallback?: string) => {
-      const primaryValue = client[primary];
-      if (primaryValue !== undefined && primaryValue !== null && primaryValue !== "") {
-        return primaryValue;
-      }
-      return fallback ? client[fallback] : primaryValue;
-    };
-    const arrayFor = (client: ConfigMap, key: string) => {
-      const value = client[key];
-      return Array.isArray(value) ? value : [];
-    };
-    const qbitTagFor = (client: ConfigMap) => {
-      const direct = client.QbitTag;
-      if (typeof direct === "string" && direct.trim() !== "") return direct;
-      const qbitTags = normalizeStringArray(client.QbitTagsValue);
-      if (qbitTags.length > 0) return qbitTags.join(",");
-      return normalizeStringArray(client.Tags).join(",");
-    };
-    const hasDirectConfig = (client: ConfigMap) =>
-      ["QbitURL", "QbitPort", "QbitUser", "QbitPass", "URL", "Username", "Password"].some((key) => {
-        const value = client[key];
-        if (typeof value === "number") return value > 0;
-        return typeof value === "string" && value.trim() !== "";
-      });
-    const setQbitDirect = (name: string, enabled: boolean) => {
-      const client = clients.find(([clientName]) => clientName === name)?.[1];
-      if (!client) {
-        return;
-      }
-      const nextClient = nextQbitDirectState(client, enabled);
-      for (const key of [
-        "QbitURL",
-        "QbitPort",
-        "QbitUser",
-        "QbitPass",
-        "URL",
-        "Username",
-        "Password",
-        "QuiProxyURL",
-      ]) {
-        if (client[key] === nextClient[key]) {
-          continue;
-        }
-        updateConfigValue(["TorrentClients", name, key], nextClient[key]);
-      }
-    };
-
-    return (
-      <div className="settings-map">
-        <div className="settings-map__header">
-          <p className="label">Entries</p>
-          <Button
-            type="button"
-            onClick={() => {
-              const name = globalThis.prompt("New entry name");
-              if (!name) return;
-              addConfigKey(["TorrentClients"], name, qbitDefaultClient());
-            }}
-          >
-            Add entry
-          </Button>
-        </div>
-
-        <div className="settings-map__grid">
-          {clients.length === 0 ? (
-            <p className="muted">No entries yet.</p>
-          ) : (
-            clients.map(([name, client]) => {
-              const clientType = normalizeTorrentClientType(client);
-              const watchClient = clientType === "watch";
-              const directEnabled = !watchClient && hasDirectConfig(client);
-              return (
-                <div className="settings-card" key={`TorrentClients-${name}`}>
-                  <div className="settings-card__header">
-                    <p className="value">{name}</p>
-                    <Button type="button" onClick={() => removeConfigKey(["TorrentClients"], name)}>
-                      Remove
-                    </Button>
-                  </div>
-                  <div className="settings-grid">
-                    {renderField(
-                      "Type",
-                      valueFor(client, "Type", "TorrentClient") ?? "qbit",
-                      ["TorrentClients", name, "Type"],
-                      meta.Type,
-                    )}
-                    {watchClient
-                      ? renderField(
-                          "WatchFolder",
-                          client.WatchFolder ?? "",
-                          ["TorrentClients", name, "WatchFolder"],
-                          meta.WatchFolder,
-                        )
-                      : null}
-                    {watchClient
-                      ? renderField(
-                          "StorageDir",
-                          client.StorageDir ?? "",
-                          ["TorrentClients", name, "StorageDir"],
-                          meta.StorageDir,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "QuiProxyURL",
-                          client.QuiProxyURL ?? "",
-                          ["TorrentClients", name, "QuiProxyURL"],
-                          meta.QuiProxyURL,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "QbitCategoryValue",
-                          valueFor(client, "QbitCategoryValue", "Category") ?? "",
-                          ["TorrentClients", name, "QbitCategoryValue"],
-                          meta.QbitCategoryValue,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "QbitTag",
-                          qbitTagFor(client),
-                          ["TorrentClients", name, "QbitTag"],
-                          meta.QbitTag,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "QbitCrossCategory",
-                          client.QbitCrossCategory ?? "",
-                          ["TorrentClients", name, "QbitCrossCategory"],
-                          meta.QbitCrossCategory,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "QbitCrossTag",
-                          client.QbitCrossTag ?? "",
-                          ["TorrentClients", name, "QbitCrossTag"],
-                          meta.QbitCrossTag,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "UseTrackerAsTag",
-                          client.UseTrackerAsTag ?? false,
-                          ["TorrentClients", name, "UseTrackerAsTag"],
-                          meta.UseTrackerAsTag,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "Linking",
-                          client.Linking ?? "",
-                          ["TorrentClients", name, "Linking"],
-                          meta.Linking,
-                        )
-                      : null}
-                    {!watchClient ? (
-                      <div
-                        className="settings-switch-row"
-                        key={`TorrentClients-${name}-AllowFallback`}
-                      >
-                        <span>Allow link fallback</span>
-                        <Switch
-                          aria-label="Allow link fallback"
-                          checked={Boolean(client.AllowFallback ?? true)}
-                          onChange={(event) =>
-                            updateConfigValue(
-                              ["TorrentClients", name, "AllowFallback"],
-                              event.target.checked,
-                            )
-                          }
-                        />
-                      </div>
-                    ) : null}
-                    {!watchClient
-                      ? renderField(
-                          "LinkedFolder",
-                          arrayFor(client, "LinkedFolder"),
-                          ["TorrentClients", name, "LinkedFolder"],
-                          meta.LinkedFolder,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "LocalPath",
-                          arrayFor(client, "LocalPath"),
-                          ["TorrentClients", name, "LocalPath"],
-                          meta.LocalPath,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "RemotePath",
-                          arrayFor(client, "RemotePath"),
-                          ["TorrentClients", name, "RemotePath"],
-                          meta.RemotePath,
-                        )
-                      : null}
-                    {!watchClient
-                      ? renderField(
-                          "AutomaticManagementPaths",
-                          arrayFor(client, "AutomaticManagementPaths"),
-                          ["TorrentClients", name, "AutomaticManagementPaths"],
-                          meta.AutomaticManagementPaths,
-                        )
-                      : null}
-                    {!watchClient && advancedOpen
-                      ? renderField(
-                          "VerifyWebUICertificate",
-                          client.VerifyWebUICertificate ?? true,
-                          ["TorrentClients", name, "VerifyWebUICertificate"],
-                          meta.VerifyWebUICertificate,
-                        )
-                      : null}
-                  </div>
-
-                  {!watchClient ? (
-                    <div className="settings-switch-row">
-                      <span>qBit direct</span>
-                      <Switch
-                        aria-label="qBit direct"
-                        checked={directEnabled}
-                        onChange={(event) => setQbitDirect(name, event.target.checked)}
-                      />
-                    </div>
-                  ) : null}
-
-                  {!watchClient && directEnabled ? (
-                    <div className="settings-grid">
-                      {renderField(
-                        "QbitURL",
-                        valueFor(client, "QbitURL", "URL") ?? "",
-                        ["TorrentClients", name, "QbitURL"],
-                        meta.QbitURL,
-                      )}
-                      {renderField(
-                        "QbitPort",
-                        client.QbitPort ?? 0,
-                        ["TorrentClients", name, "QbitPort"],
-                        meta.QbitPort,
-                      )}
-                      {renderField(
-                        "QbitUser",
-                        valueFor(client, "QbitUser", "Username") ?? "",
-                        ["TorrentClients", name, "QbitUser"],
-                        meta.QbitUser,
-                      )}
-                      {renderField(
-                        "QbitPass",
-                        valueFor(client, "QbitPass", "Password") ?? "",
-                        ["TorrentClients", name, "QbitPass"],
-                        meta.QbitPass,
-                      )}
-                    </div>
-                  ) : null}
-                </div>
-              );
-            })
-          )}
-        </div>
-      </div>
-    );
-  };
-
-  /**
-   * Check if a tracker has user-supplied upload/auth config. Catalog defaults
-   * include every tracker and URL, so entry presence or default_tracker membership
-   * cannot mean the tracker is enabled.
-   */
-  const isTrackerConfigured = useCallback(
-    (trackerName: string, trackerValue: ConfigMap): boolean => {
-      if (!defaultConfig || typeof defaultConfig !== "object" || Array.isArray(defaultConfig)) {
-        return Object.entries(trackerValue).some(([key, value]) =>
-          trackerActivationKeys.has(key) ? hasConfiguredTrackerValue(value, undefined) : false,
-        );
-      }
-
-      const defaultTrackersCfg = defaultConfig.Trackers;
-      if (
-        !defaultTrackersCfg ||
-        typeof defaultTrackersCfg !== "object" ||
-        Array.isArray(defaultTrackersCfg)
-      ) {
-        return Object.entries(trackerValue).some(([key, value]) =>
-          trackerActivationKeys.has(key) ? hasConfiguredTrackerValue(value, undefined) : false,
-        );
-      }
-
-      const defaultTrackersMap = defaultTrackersCfg.Trackers;
-      if (
-        !defaultTrackersMap ||
-        typeof defaultTrackersMap !== "object" ||
-        Array.isArray(defaultTrackersMap)
-      ) {
-        return Object.entries(trackerValue).some(([key, value]) =>
-          trackerActivationKeys.has(key) ? hasConfiguredTrackerValue(value, undefined) : false,
-        );
-      }
-
-      const baselineTracker = (defaultTrackersMap as ConfigMap)[trackerName];
-      const baseline =
-        baselineTracker && typeof baselineTracker === "object" && !Array.isArray(baselineTracker)
-          ? (baselineTracker as ConfigMap)
-          : {};
-
-      for (const [key, currentValue] of Object.entries(trackerValue)) {
-        if (!trackerActivationKeys.has(key)) {
-          continue;
-        }
-        if (hasConfiguredTrackerValue(currentValue, baseline[key])) {
-          return true;
-        }
-      }
-
-      return false;
-    },
-    [defaultConfig],
-  );
-
-  const trackerSelectionNames = useMemo(() => {
-    if (
-      !configData ||
-      !configData.Trackers ||
-      typeof configData.Trackers !== "object" ||
-      Array.isArray(configData.Trackers)
-    ) {
-      return [] as string[];
-    }
-
-    const trackerRoot = configData.Trackers as ConfigMap;
-    const rawEntries = trackerRoot.Trackers;
-    const entriesRoot =
-      rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
-        ? (rawEntries as ConfigMap)
-        : {};
-    const allEntries = Object.entries(entriesRoot).filter(
-      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
-    ) as Array<[string, ConfigMap]>;
-    const manualTrackerSet = new Set(
-      Object.entries(manualTrackerEntries)
-        .filter(([, enabled]) => enabled)
-        .map(([name]) => name),
-    );
-
-    return allEntries
-      .filter(
-        ([trackerName, trackerValue]) =>
-          isTrackerConfigured(trackerName, trackerValue) || manualTrackerSet.has(trackerName),
-      )
-      .map(([trackerName]) => trackerName)
-      .sort((left, right) => left.localeCompare(right));
-  }, [configData, manualTrackerEntries, isTrackerConfigured]);
-
-  const renderTrackerSection = (advancedOpen: boolean) => {
-    try {
-      if (
-        !configData ||
-        !configData.Trackers ||
-        typeof configData.Trackers !== "object" ||
-        Array.isArray(configData.Trackers)
-      ) {
-        return null;
-      }
-
-      const trackerRoot = configData.Trackers as ConfigMap;
-      const defaultTrackers = (trackerRoot.DefaultTrackers as ConfigValue) ?? [];
-      const rawEntries = trackerRoot.Trackers;
-      const entriesRoot =
-        rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
-          ? (rawEntries as ConfigMap)
-          : {};
-
-      const allEntries = Object.entries(entriesRoot).filter(
-        ([, value]) => value && typeof value === "object" && !Array.isArray(value),
-      ) as Array<[string, ConfigMap]>;
-      const visibleTrackerSet = new Set(trackerSelectionNames);
-      const visibleEntries = allEntries.filter(([trackerName]) =>
-        visibleTrackerSet.has(trackerName),
-      );
-
-      const normalizedDefaultTrackers = normalizeDefaultTrackerList(defaultTrackers);
-      const preferredTrackerRaw = trackerRoot.PreferredTracker;
-      const preferredTracker =
-        typeof preferredTrackerRaw === "string" ? preferredTrackerRaw.trim() : "";
-      const trackerNames = trackerSelectionNames;
-      const normalizedTrackerNameSet = new Set(trackerNames.map((name) => name.toLowerCase()));
-      const selectedDefaultTrackerCount = normalizedDefaultTrackers.filter((name) =>
-        normalizedTrackerNameSet.has(name.toLowerCase()),
-      ).length;
-      const trackerOptions = (knownTrackers.length ? knownTrackers : Object.keys(trackerSchemas))
-        .filter((name) => typeof name === "string" && name.trim().length > 0)
-        .slice()
-        .sort((a, b) => a.localeCompare(b));
-      const allEntrySet = new Set(allEntries.map(([name]) => name));
-      const availableTrackers = trackerOptions.filter((name) => !visibleTrackerSet.has(name));
-      const trackerClientOptions = [{ value: "", label: "" }, ...torrentClientOptions];
-
-      const trackerFallbackSchema = [
-        trackerFieldMeta.LinkDirName,
-        trackerFieldMeta.ImageHost,
-        trackerFieldMeta.APIKey,
-        trackerFieldMeta.AnnounceURL,
-        trackerFieldMeta.Username,
-        trackerFieldMeta.Password,
-        trackerFieldMeta.Anon,
-      ];
-      const trackerSchemaFor = (name: string) => {
-        const imageHostField = {
-          ...trackerFieldMeta.ImageHost,
-          options: trackerOptionsForImageHost(name),
-        };
-        const torrentClientField = {
-          ...trackerFieldMeta.TorrentClient,
-          options: trackerClientOptions,
-        };
-        const base = trackerSchemas[name] || trackerFallbackSchema;
-        return [
-          imageHostField,
-          torrentClientField,
-          ...base.filter((meta) => meta.key !== "ImageHost" && meta.key !== "TorrentClient"),
-        ];
-      };
-
-      const buildDefault = (meta: FieldMeta) => {
-        if (meta.type === "boolean") return false;
-        if (meta.type === "number") return 0;
-        return "";
-      };
-
-      const buildTrackerDefaults = (schema: FieldMeta[]) => {
-        const defaults: ConfigMap = {};
-        schema.forEach((meta) => {
-          defaults[meta.key] = buildDefault(meta);
-        });
-        return defaults;
-      };
-
-      const toggleDefaultTracker = (name: string, enabled: boolean) => {
-        const current = normalizeDefaultTrackerList(defaultTrackers);
-        const next = current.filter((entry) => entry !== name);
-        if (enabled) {
-          next.push(name);
-        }
-        updateConfigValue(["Trackers", "DefaultTrackers"], next);
-      };
-
-      const updatePreferredTracker = (value: string) => {
-        updateConfigValue(["Trackers", "PreferredTracker"], value.trim());
-      };
-
-      return (
-        <div className="settings-map">
-          <details
-            className="settings-subgroup settings-subgroup--collapsible"
-            open={defaultTrackersPanelOpen}
-            onToggle={(event) => {
-              const target = event.currentTarget as HTMLDetailsElement;
-              setDefaultTrackersPanelOpen(target.open);
-            }}
-          >
-            <summary className="settings-subgroup__title tracker-summary-heading">
-              <span>Default trackers</span>
-              <span className="tracker-summary-count">
-                {selectedDefaultTrackerCount}/{trackerNames.length}
-              </span>
-            </summary>
-            <div className="tracker-defaults-body">
-              {trackerNames.length === 0 ? (
-                <p className="muted">Add tracker entries to select defaults.</p>
-              ) : (
-                <div className="tracker-selection-container">
-                  <div className="tracker-pills">
-                    {trackerNames.map((tracker) => (
-                      <PillCheckbox
-                        key={tracker}
-                        checked={normalizedDefaultTrackers.includes(tracker)}
-                        onCheckedChange={(checked) => toggleDefaultTracker(tracker, checked)}
-                      >
-                        {tracker}
-                      </PillCheckbox>
-                    ))}
-                  </div>
-                </div>
-              )}
-            </div>
-          </details>
-
-          <details className="settings-subgroup settings-subgroup--collapsible">
-            <summary className="settings-subgroup__title">Preferred tracker data source</summary>
-            <div style={{ paddingTop: "0.5rem" }}>
-              <div className="settings-map__controls">
-                <select
-                  className={settingsSelectClass}
-                  value={preferredTracker}
-                  onChange={(event) => updatePreferredTracker(event.target.value)}
-                >
-                  <option value="">None</option>
-                  {trackerOptions.map((name) => (
-                    <option key={name} value={name}>
-                      {name}
-                    </option>
-                  ))}
-                </select>
-                <Button
-                  type="button"
-                  disabled={preferredTracker === ""}
-                  onClick={() => updatePreferredTracker("")}
-                >
-                  Clear
-                </Button>
-              </div>
-              <p className="muted" style={{ marginTop: "0.5rem" }}>
-                Moves the selected tracker to the top of tracker-data lookup and qBit tracker
-                priority when present.
-              </p>
-            </div>
-          </details>
-
-          <div className="settings-map__header">
-            <p className="label">Entries</p>
-            <div className="settings-map__controls">
-              <select
-                className={settingsSelectClass}
-                value={trackerAddSelection}
-                onChange={(event) => setTrackerAddSelection(event.target.value)}
-                disabled={availableTrackers.length === 0}
-              >
-                <option value="">Select tracker</option>
-                {availableTrackers.map((name) => (
-                  <option key={name} value={name}>
-                    {name}
-                  </option>
-                ))}
-              </select>
-              <Button
-                type="button"
-                disabled={!trackerAddSelection}
-                onClick={() => {
-                  const name = trackerAddSelection.trim();
-                  if (!name) return;
-                  if (!allEntrySet.has(name)) {
-                    const schema = trackerSchemaFor(name);
-                    addConfigKey(["Trackers", "Trackers"], name, buildTrackerDefaults(schema));
-                  }
-                  setManualTrackerEntries((prev) => ({ ...prev, [name]: true }));
-                  setTrackerAddSelection("");
-                  setSettingsTrackerPanels((prev) => ({ ...prev, [name]: true }));
-                }}
-              >
-                Add entry
-              </Button>
-            </div>
-          </div>
-
-          <div className="settings-map__grid">
-            {visibleEntries.length === 0 ? (
-              <p className="muted">No configured entries yet.</p>
-            ) : (
-              visibleEntries.map(([key, value]) => {
-                const schema = trackerSchemaFor(key).filter((meta): meta is FieldMeta =>
-                  Boolean(meta),
-                );
-                return (
-                  <details
-                    className="settings-card settings-card--collapsible"
-                    key={`Trackers-${key}`}
-                    open={settingsTrackerPanels[key] ?? false}
-                    onToggle={(event) => {
-                      const target = event.currentTarget as HTMLDetailsElement;
-                      setSettingsTrackerPanels((prev) => ({ ...prev, [key]: target.open }));
-                    }}
-                  >
-                    <summary className="settings-card__summary">
-                      <span className="settings-card__summary-name">{key}</span>
-                      <Button
-                        type="button"
-                        onClick={(event) => {
-                          event.preventDefault();
-                          event.stopPropagation();
-                          removeConfigKey(["Trackers", "Trackers"], key);
-                          setManualTrackerEntries((prev) => {
-                            const next = { ...prev };
-                            delete next[key];
-                            return next;
-                          });
-                          setSettingsTrackerPanels((prev) => {
-                            const next = { ...prev };
-                            delete next[key];
-                            return next;
-                          });
-                        }}
-                      >
-                        Remove
-                      </Button>
-                    </summary>
-                    <div className="settings-card__body">
-                      <div className="settings-grid">
-                        {schema
-                          .filter((meta) => !(meta.advanced && !advancedOpen))
-                          .map((meta) =>
-                            renderField(
-                              meta.key,
-                              value[meta.key] ?? buildDefault(meta),
-                              ["Trackers", "Trackers", key, meta.key],
-                              meta,
-                            ),
-                          )}
-                      </div>
-                    </div>
-                  </details>
-                );
-              })
-            )}
-          </div>
-        </div>
-      );
-    } catch (err) {
-      return <p className="error">Unable to render tracker settings: {String(err)}</p>;
-    }
-  };
-
-  const renderImageHostingSection = () => {
-    if (!configData || !configData.ImageHosting || typeof configData.ImageHosting !== "object") {
-      return null;
-    }
-
-    const imageCfg = configData.ImageHosting as ConfigMap;
-    const trackersRoot =
-      configData.Trackers &&
-      typeof configData.Trackers === "object" &&
-      !Array.isArray(configData.Trackers)
-        ? (configData.Trackers as ConfigMap)
-        : null;
-    const trackerEntries =
-      trackersRoot?.Trackers &&
-      typeof trackersRoot.Trackers === "object" &&
-      !Array.isArray(trackersRoot.Trackers)
-        ? (trackersRoot.Trackers as ConfigMap)
-        : null;
-    const rfTrackerCfg =
-      trackerEntries?.RF &&
-      typeof trackerEntries.RF === "object" &&
-      !Array.isArray(trackerEntries.RF)
-        ? (trackerEntries.RF as ConfigMap)
-        : null;
-    const hostFields = ["Host1", "Host2", "Host3", "Host4", "Host5", "Host6"];
-    const requiredKeys = new Set<string>();
-    hostFields.forEach((field) => {
-      const selected = String(imageCfg[field] ?? "").trim();
-      if (!selected) return;
-      const keys = imageHostKeyMap[selected];
-      if (keys) {
-        keys.forEach((key) => requiredKeys.add(key));
-      }
-    });
-
-    return (
-      <div className="settings-form">
-        <div className="settings-subgroup">
-          <div className="settings-subgroup__title">Host Priority</div>
-          <div className="settings-grid">
-            {hostFields.map((field, index) => (
-              <label className="settings-field" key={field}>
-                <span>{`Host ${index + 1}`}</span>
-                <select
-                  className={settingsSelectClass}
-                  value={String(imageCfg[field] ?? "")}
-                  onChange={(event) =>
-                    updateConfigValue(["ImageHosting", field], event.target.value)
-                  }
-                >
-                  {imageHostOptions.map((option) => (
-                    <option key={option.value} value={option.value}>
-                      {option.label}
-                    </option>
-                  ))}
-                </select>
-              </label>
-            ))}
-          </div>
-        </div>
-
-        <div className="settings-subgroup">
-          <div className="settings-subgroup__title">API Keys</div>
-          {requiredKeys.size === 0 ? (
-            <p className="muted">Select an image host to edit its API keys.</p>
-          ) : (
-            <div className="settings-grid">
-              {Array.from(requiredKeys).map((key) =>
-                renderField(key, imageCfg[key] as ConfigValue, ["ImageHosting", key]),
-              )}
-            </div>
-          )}
-        </div>
-
-        <div className="settings-subgroup">
-          <div className="settings-subgroup__title">Tracker Image Hosts</div>
-          <div className="settings-grid">
-            <div className="settings-switch-row">
-              <span>LST Lostimg</span>
-              <Switch
-                aria-label="LST Lostimg"
-                checked={Boolean(imageCfg.LostimgEnabled)}
-                onChange={(event) =>
-                  updateConfigValue(["ImageHosting", "LostimgEnabled"], event.target.checked)
-                }
-              />
-            </div>
-            {renderField(
-              "LostimgAPI",
-              (imageCfg.LostimgAPI as ConfigValue) ?? "",
-              ["ImageHosting", "LostimgAPI"],
-              sectionFieldMeta.ImageHosting.LostimgAPI,
-            )}
-            <div className="settings-switch-row">
-              <span>RF Reelflix</span>
-              <Switch
-                aria-label="RF Reelflix"
-                checked={
-                  normalizeImageHostValue(String(rfTrackerCfg?.ImageHost ?? "")) === "reelflix"
-                }
-                onChange={(event) =>
-                  updateConfigValue(
-                    ["Trackers", "Trackers", "RF", "ImageHost"],
-                    event.target.checked ? "reelflix" : "",
-                  )
-                }
-              />
-            </div>
-            {renderField(
-              "ImgAPI",
-              (rfTrackerCfg?.ImgAPI as ConfigValue) ?? "",
-              ["Trackers", "Trackers", "RF", "ImgAPI"],
-              trackerFieldMeta.ImgAPI,
-            )}
-          </div>
-        </div>
-      </div>
-    );
-  };
-
-  return {
-    configData,
-    settingsLoading,
-    settingsDirty,
-    settingsSaved,
-    settingsError,
-    settingsSection,
-    settingsSections,
-    showAdvancedToggle,
-    advancedOpen,
-    setSettingsSection,
-    setSettingsAdvanced,
-    loadSettings,
-    handleSaveSettings,
-    renderImageHostingSection,
-    renderTrackerSection,
-    renderTorrentClientsSection,
-    renderMapSection,
-    renderField,
-    sectionFieldMeta: effectiveSectionFieldMeta,
-    updateConfigValue,
-    updateScreenshotConfigValue,
-    configuredImageHosts,
-    screenshotConfig,
-    buildSavePayload,
-    clearSettingsStatus,
-    markSettingsSaved,
-    setSettingsSavedMessage,
-    setSettingsErrorMessage,
-    resolveImageHostLabel,
-    knownTrackersLoading,
-    trackerSelectionNames,
-  };
-};
diff --git a/gui/frontend/src/hooks/useUploadImages.ts b/gui/frontend/src/hooks/useUploadImages.ts
deleted file mode 100644
index a611e2f3..00000000
--- a/gui/frontend/src/hooks/useUploadImages.ts
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useState, useCallback, useMemo, useEffect } from "react";
-import type {
-  ScreenshotPreviewImage,
-  UploadedImageLink,
-  UploadImageHostFailure,
-  ExternalIDOverrides,
-  ReleaseNameOverrides,
-} from "../types";
-import { normalizeOverrides, normalizeReleaseOverrides } from "../utils";
-
-interface UploadImagesHookProps {
-  path: string;
-  idOverrideState?: { overrides?: ExternalIDOverrides };
-  releaseOverrideState?: { overrides?: ReleaseNameOverrides };
-  uploadCandidates?: ScreenshotPreviewImage[];
-  configuredImageHosts?: string[];
-  selectedTrackers?: string[];
-}
-
-export const useUploadImages = ({
-  path,
-  idOverrideState,
-  releaseOverrideState,
-  uploadCandidates = [],
-  configuredImageHosts = [],
-  selectedTrackers = [],
-}: UploadImagesHookProps) => {
-  // State: Host & selection
-  const [uploadHost, setUploadHost] = useState<string>("");
-  const [uploadSelections, setUploadSelections] = useState<Record<string, boolean>>({});
-
-  // State: Upload progress & results
-  const [uploadImagesLoading, setUploadImagesLoading] = useState(false);
-  const [uploadImagesError, setUploadImagesError] = useState("");
-  const [uploadImageFailures, setUploadImageFailures] = useState<UploadImageHostFailure[]>([]);
-  const [uploadedImages, setUploadedImages] = useState<UploadedImageLink[]>([]);
-  const [uploadedImageRecords, setUploadedImageRecords] = useState<UploadedImageLink[]>([]);
-  const [uploadProgress, setUploadProgress] = useState<{ current: number; total: number }>({
-    current: 0,
-    total: 0,
-  });
-
-  // Build set of upload candidate paths for filtering
-  const uploadCandidatePaths = useMemo(
-    () => new Set(uploadCandidates.map((item) => item.image.Path)),
-    [uploadCandidates],
-  );
-
-  // Build record-by-path map for display
-  const uploadedRecordByPath = useMemo(() => {
-    const map = new Map<string, UploadedImageLink>();
-    uploadedImageRecords.forEach((record) => {
-      if (record.ImagePath) {
-        const existing = map.get(record.ImagePath);
-        if (existing) {
-          const existingTime = existing.UploadedAt ? Date.parse(existing.UploadedAt) : 0;
-          const recordTime = record.UploadedAt ? Date.parse(record.UploadedAt) : 0;
-          if (recordTime > existingTime) {
-            map.set(record.ImagePath, record);
-          }
-        } else {
-          map.set(record.ImagePath, record);
-        }
-      }
-    });
-    return map;
-  }, [uploadedImageRecords]);
-
-  // Initialize host if not set and candidates exist
-  useEffect(() => {
-    if (uploadHost || configuredImageHosts.length === 0) return;
-    setUploadHost(configuredImageHosts[0]);
-  }, [configuredImageHosts, uploadHost]);
-
-  // Initialize selections when candidates change
-  useEffect(() => {
-    if (uploadCandidates.length === 0) {
-      setUploadSelections({});
-      return;
-    }
-    setUploadSelections((prev) => {
-      const next: Record<string, boolean> = { ...prev };
-      uploadCandidates.forEach((item) => {
-        const pathValue = item.image.Path;
-        if (!pathValue) return;
-        if (next[pathValue] === undefined) {
-          next[pathValue] = true;
-        }
-      });
-      // Remove selections for paths no longer in candidates
-      Object.keys(next).forEach((key) => {
-        if (!uploadCandidatePaths.has(key)) {
-          delete next[key];
-        }
-      });
-      return next;
-    });
-  }, [uploadCandidates, uploadCandidatePaths]);
-
-  // Toggle selection of a single image
-  const toggleUploadSelection = useCallback((imagePath: string) => {
-    if (!imagePath) return;
-    setUploadSelections((prev) => ({
-      ...prev,
-      [imagePath]: prev[imagePath] === undefined ? false : !prev[imagePath],
-    }));
-  }, []);
-
-  // Set all selections to same state
-  const setAllUploadSelections = useCallback(
-    (value: boolean) => {
-      if (uploadCandidates.length === 0) return;
-      const next: Record<string, boolean> = {};
-      uploadCandidates.forEach((item) => {
-        if (item.image.Path) {
-          next[item.image.Path] = value;
-        }
-      });
-      setUploadSelections(next);
-    },
-    [uploadCandidates],
-  );
-
-  // Refresh uploaded images from backend
-  const refreshUploadedImages = useCallback(async () => {
-    const fetcher = globalThis.go?.guiapp?.App?.ListUploadedImages;
-    if (!fetcher) return;
-    if (!path.trim()) {
-      setUploadedImageRecords([]);
-      return;
-    }
-    try {
-      const records = await fetcher(
-        path.trim(),
-        normalizeOverrides(idOverrideState?.overrides || {}),
-        normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-      );
-      setUploadedImageRecords(records || []);
-    } catch (err) {
-      console.error("Failed to load uploaded images:", err);
-    }
-  }, [path, idOverrideState, releaseOverrideState]);
-
-  // Upload selected images to host
-  const handleUploadImages = useCallback(
-    async (selected: ScreenshotPreviewImage[]) => {
-      setUploadImagesError("");
-      setUploadImageFailures([]);
-      const uploader = globalThis.go?.guiapp?.App?.UploadImages;
-      if (!uploader) {
-        setUploadImagesError("Image uploading is unavailable in this build.");
-        return;
-      }
-      if (!path.trim()) {
-        setUploadImagesError("Please select a file or folder.");
-        return;
-      }
-      if (!uploadHost) {
-        setUploadImagesError("Select an image host to upload.");
-        return;
-      }
-
-      if (selected.length === 0) {
-        setUploadImagesError("Select at least one image to upload.");
-        return;
-      }
-
-      setUploadImagesLoading(true);
-      setUploadProgress({ current: 0, total: selected.length });
-      try {
-        const result = await uploader(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-          selectedTrackers,
-          uploadHost,
-          selected.map((entry) => entry.image),
-        );
-        const links = result?.Links || [];
-        const failures = result?.Failures || [];
-        const uploadedCount = new Set(links.map((link) => link.ImagePath).filter(Boolean)).size;
-        setUploadedImages(links);
-        setUploadImageFailures(failures);
-        if (failures.length > 0) {
-          const failedHosts = Array.from(
-            new Set(failures.map((failure) => failure.Host || "unknown host")),
-          ).join(", ");
-          setUploadImagesError(`Image upload failed for ${failedHosts}.`);
-        }
-        if (uploadedCount !== selected.length) {
-          console.error("Upload count mismatch", {
-            expectedCount: selected.length,
-            uploadedCount,
-          });
-          if (failures.length === 0) {
-            setUploadImagesError(
-              `Upload completed with an unexpected result count (expected ${selected.length}, got ${uploadedCount}).`,
-            );
-          }
-        }
-        setUploadProgress({
-          current: uploadedCount,
-          total: selected.length,
-        });
-        await refreshUploadedImages();
-      } catch (err) {
-        setUploadImagesError(String(err));
-        setUploadImageFailures([]);
-        setUploadProgress({ current: 0, total: selected.length });
-      } finally {
-        setUploadImagesLoading(false);
-      }
-    },
-    [
-      path,
-      idOverrideState,
-      releaseOverrideState,
-      selectedTrackers,
-      uploadHost,
-      refreshUploadedImages,
-    ],
-  );
-
-  // Delete a single uploaded image record
-  const handleDeleteUploadedImage = useCallback(
-    async (imagePath: string, host: string) => {
-      if (!imagePath || !path.trim() || !host) {
-        console.error("Cannot delete uploaded image: missing path, imagePath, or host");
-        return;
-      }
-
-      try {
-        await globalThis.go?.guiapp?.App?.DeleteUploadedImage(path.trim(), imagePath, host);
-        // Refresh existing images to reflect deletion
-        const refreshed = await globalThis.go?.guiapp?.App?.ListUploadCandidates(
-          path.trim(),
-          normalizeOverrides(idOverrideState?.overrides || {}),
-          normalizeReleaseOverrides(releaseOverrideState?.overrides || {}),
-        );
-
-        if (!refreshed || refreshed.length === 0) {
-          setUploadedImages((prev) =>
-            prev.filter(
-              (image) => !(image.ImagePath === imagePath && (image.Host || uploadHost) === host),
-            ),
-          );
-          await refreshUploadedImages();
-          return;
-        }
-
-        setUploadedImages((prev) =>
-          prev.filter(
-            (image) => !(image.ImagePath === imagePath && (image.Host || uploadHost) === host),
-          ),
-        );
-        await refreshUploadedImages();
-      } catch (err) {
-        console.error("Failed to delete uploaded image:", err);
-      }
-    },
-    [path, idOverrideState, releaseOverrideState, uploadHost, refreshUploadedImages],
-  );
-
-  // Reset upload state
-  const resetUploadState = useCallback(() => {
-    setUploadHost("");
-    setUploadSelections({});
-    setUploadImagesLoading(false);
-    setUploadImagesError("");
-    setUploadImageFailures([]);
-    setUploadedImages([]);
-    setUploadedImageRecords([]);
-    setUploadProgress({ current: 0, total: 0 });
-  }, []);
-
-  return {
-    // State
-    uploadHost,
-    uploadSelections,
-    uploadImagesLoading,
-    uploadImagesError,
-    uploadImageFailures,
-    uploadedImages,
-    uploadedImageRecords,
-    uploadedRecordByPath,
-    uploadProgress,
-
-    // Setters
-    setUploadHost,
-    setUploadSelections,
-    setUploadImagesLoading,
-    setUploadImagesError,
-    setUploadedImages,
-    setUploadedImageRecords,
-
-    // Handlers & utilities
-    toggleUploadSelection,
-    setAllUploadSelections,
-    refreshUploadedImages,
-    handleUploadImages,
-    handleDeleteUploadedImage,
-    resetUploadState,
-  };
-};
diff --git a/gui/frontend/src/pages/bluray_candidates/index.tsx b/gui/frontend/src/pages/bluray_candidates/index.tsx
deleted file mode 100644
index fcbf72ce..00000000
--- a/gui/frontend/src/pages/bluray_candidates/index.tsx
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { BlurayReleaseCandidate, MetadataPreview } from "../../types";
-import { handleExternalLinkClick } from "../../utils/externalLinks";
-
-type Props = {
-  preview: MetadataPreview;
-  selecting: boolean;
-  error: string;
-  onSelect: (releaseID: string) => void;
-  setLightboxImage: (url: string) => void;
-  setLightboxAlt: (alt: string) => void;
-};
-
-const scoreLabel = (candidate: BlurayReleaseCandidate) => `${candidate.Score.toFixed(1)}/100`;
-
-export default function BlurayCandidatesPage(props: Props) {
-  const { preview, selecting, error, onSelect, setLightboxImage, setLightboxAlt } = props;
-  const bluray = preview.Bluray;
-  const candidates = bluray?.Candidates || [];
-  const selectedID = bluray?.SelectedReleaseID || "";
-
-  return (
-    <section className="flex flex-col gap-3">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Blu-ray.com</p>
-        <h1>Release Candidates</h1>
-        <p className="subtitle">Best accepted match loads by score; select another release here.</p>
-      </header>
-
-      {error ? <p className="error">{error}</p> : null}
-
-      {!bluray ? (
-        <section className="panel">
-          <p className="muted">No Blu-ray.com lookup data available.</p>
-        </section>
-      ) : (
-        <>
-          <section className="panel grid gap-2 py-3">
-            <div className="grid grid-cols-[repeat(auto-fit,minmax(150px,1fr))] gap-2">
-              <div>
-                <p className="label">Best score</p>
-                <p className="value">{bluray.BestScore.toFixed(1)}</p>
-              </div>
-              <div>
-                <p className="label">Required score</p>
-                <p className="value">{bluray.Threshold.toFixed(1)}</p>
-              </div>
-              <div>
-                <p className="label">Auto-selected</p>
-                <p className="value">{bluray.AutoSelected ? "Yes" : "No"}</p>
-              </div>
-              <div>
-                <p className="label">Candidates</p>
-                <p className="value">{candidates.length}</p>
-              </div>
-            </div>
-            {bluray.SearchURL ? (
-              <a
-                className="tracker-link w-fit"
-                href={bluray.SearchURL}
-                target="_blank"
-                rel="noreferrer"
-                onAuxClick={handleExternalLinkClick}
-                onClick={handleExternalLinkClick}
-              >
-                Open search
-              </a>
-            ) : null}
-            {!selectedID && bluray.SelectionReason ? (
-              <p className="m-0 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100">
-                {bluray.SelectionReason}
-              </p>
-            ) : null}
-          </section>
-
-          {candidates.length === 0 ? (
-            <section className="panel">
-              <p className="muted">No release candidates found.</p>
-            </section>
-          ) : (
-            <div className="grid gap-3">
-              {candidates.map((candidate) => {
-                const selected = candidate.ReleaseID === selectedID || candidate.Accepted;
-                const hasReleaseID = Boolean(candidate.ReleaseID);
-                return (
-                  <section
-                    className={`panel grid gap-3 ${selected ? "border-[var(--sidebar-active-border)]" : ""}`}
-                    key={candidate.ReleaseID || candidate.URL}
-                  >
-                    <div className="flex flex-wrap items-start justify-between gap-3">
-                      <div className="min-w-0">
-                        <h2 className="[overflow-wrap:anywhere]">{candidate.Title || "-"}</h2>
-                        <p className="muted [overflow-wrap:anywhere]">
-                          {[candidate.MovieTitle, candidate.MovieYear].filter(Boolean).join(" ")}
-                        </p>
-                      </div>
-                      <button
-                        className={selected ? "primary" : "ghost"}
-                        type="button"
-                        disabled={selecting || selected || !hasReleaseID}
-                        onClick={() => {
-                          if (hasReleaseID) onSelect(candidate.ReleaseID);
-                        }}
-                      >
-                        {selected ? "Selected" : selecting ? "Selecting..." : "Select"}
-                      </button>
-                    </div>
-
-                    <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,1fr))] gap-2">
-                      <div>
-                        <p className="label">Score</p>
-                        <p className="value">{scoreLabel(candidate)}</p>
-                      </div>
-                      <div>
-                        <p className="label">Country</p>
-                        <p className="value">{candidate.Country || "-"}</p>
-                      </div>
-                      <div>
-                        <p className="label">Region</p>
-                        <p className="value">{candidate.Region || "-"}</p>
-                      </div>
-                      <div>
-                        <p className="label">Publisher</p>
-                        <p className="value">{candidate.Publisher || "-"}</p>
-                      </div>
-                      <div>
-                        <p className="label">Disc</p>
-                        <p className="value">{candidate.Specs?.Discs?.Format || "-"}</p>
-                      </div>
-                    </div>
-
-                    {candidate.URL ? (
-                      <a
-                        className="tracker-link w-fit"
-                        href={candidate.URL}
-                        target="_blank"
-                        rel="noreferrer"
-                        onAuxClick={handleExternalLinkClick}
-                        onClick={handleExternalLinkClick}
-                      >
-                        Open release
-                      </a>
-                    ) : null}
-
-                    <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
-                      <div>
-                        <p className="label">Video</p>
-                        <p className="value">
-                          {[candidate.Specs?.Video?.Codec, candidate.Specs?.Video?.Resolution]
-                            .filter(Boolean)
-                            .join(" ") || "-"}
-                        </p>
-                      </div>
-                      <div>
-                        <p className="label">Audio</p>
-                        <p className="value [overflow-wrap:anywhere]">
-                          {(candidate.Specs?.Audio || []).slice(0, 3).join("; ") || "-"}
-                        </p>
-                      </div>
-                      <div>
-                        <p className="label">Subtitles</p>
-                        <p className="value [overflow-wrap:anywhere]">
-                          {(candidate.Specs?.Subtitles || []).slice(0, 6).join(", ") || "-"}
-                        </p>
-                      </div>
-                    </div>
-
-                    {candidate.MatchNotes?.length ? (
-                      <div>
-                        <p className="label">Score notes</p>
-                        <p className="value [overflow-wrap:anywhere]">
-                          {candidate.MatchNotes.slice(0, 5).join(" | ")}
-                        </p>
-                      </div>
-                    ) : null}
-
-                    {candidate.CoverImages?.length ? (
-                      <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,160px))] gap-2">
-                        {candidate.CoverImages.map((image) => (
-                          <button
-                            className="cursor-pointer border-0 bg-transparent p-0"
-                            type="button"
-                            key={`${candidate.ReleaseID}-${image.Kind}-${image.URL}`}
-                            onClick={() => {
-                              setLightboxImage(image.URL);
-                              setLightboxAlt(`${candidate.Title} ${image.Kind}`);
-                            }}
-                          >
-                            <img
-                              className="w-full rounded-md border border-white/10"
-                              src={image.URL}
-                              alt={image.Kind || "Blu-ray cover"}
-                              loading="lazy"
-                            />
-                          </button>
-                        ))}
-                      </div>
-                    ) : null}
-                  </section>
-                );
-              })}
-            </div>
-          )}
-        </>
-      )}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/description_builder/index.test.tsx b/gui/frontend/src/pages/description_builder/index.test.tsx
deleted file mode 100644
index 1102add4..00000000
--- a/gui/frontend/src/pages/description_builder/index.test.tsx
+++ /dev/null
@@ -1,269 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { DescriptionBuilderPreview } from "../../types";
-import DescriptionBuilderPage from "./index";
-
-describe("DescriptionBuilderPage", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("does not decode sanitized attribute entities before rendering", () => {
-    const builderPreview = {
-      SourcePath: "C:/media/Movie.mkv",
-      Groups: [
-        {
-          GroupKey: "unit3d",
-          Trackers: ["BLU"],
-          Description: "",
-          DescriptionHTML: "",
-          RawDescription: "raw",
-          RawDescriptionHTML: `<img src="http://invalid.invalid/&#34; onerror=&#34;alert(1)" />`,
-          HasOverride: false,
-          ImageHost: { Status: "", SelectedHost: "", AllowedHosts: [], Warnings: [] },
-        },
-      ],
-    } as unknown as DescriptionBuilderPreview;
-
-    const { container } = render(
-      <DescriptionBuilderPage
-        path="C:/media/Movie.mkv"
-        builderPreview={builderPreview}
-        builderRawByGroup={{}}
-        builderRenderedByGroup={{}}
-        builderExpandedGroups={{ unit3d: true }}
-        builderLoading={false}
-        builderSaving={false}
-        builderRenderLoading={false}
-        builderRefreshing={false}
-        builderProgressMessage=""
-        builderError=""
-        builderSaved=""
-        refreshDescriptionBuilder={vi.fn()}
-        setBuilderRawByGroup={vi.fn()}
-        setBuilderDirtyByGroup={vi.fn()}
-        setBuilderExpandedGroups={vi.fn()}
-        resetBuilderDescription={vi.fn()}
-        renderBuilderDescription={vi.fn()}
-        saveBuilderDescription={vi.fn()}
-      />,
-    );
-
-    const image = container.querySelector(".tracker-description.rendered img");
-    expect(image).toBeInstanceOf(HTMLImageElement);
-    expect(image?.getAttribute("onerror")).toBeNull();
-    expect(image?.getAttribute("src")).toContain(`" onerror="alert(1)`);
-  });
-
-  it("renders final built content as the raw description preview", () => {
-    const builderPreview = {
-      SourcePath: "C:/media/Movie.mkv",
-      Groups: [
-        {
-          GroupKey: "unit3d",
-          Trackers: ["HHD"],
-          Description: "[img]https://img.example/final.png[/img]",
-          DescriptionHTML: `<div class="tracker-description"><img src="https://img.example/final.png" /></div>`,
-          RawDescription: "[img]https://img.example/final.png[/img]",
-          RawDescriptionHTML: `<div class="tracker-description"><img src="https://img.example/final.png" /></div>`,
-          HasOverride: false,
-          ImageHost: { Status: "", SelectedHost: "", AllowedHosts: [], Warnings: [] },
-        },
-      ],
-    } as unknown as DescriptionBuilderPreview;
-
-    const { container } = render(
-      <DescriptionBuilderPage
-        path="C:/media/Movie.mkv"
-        builderPreview={builderPreview}
-        builderRawByGroup={{}}
-        builderRenderedByGroup={{}}
-        builderExpandedGroups={{ unit3d: true }}
-        builderLoading={false}
-        builderSaving={false}
-        builderRenderLoading={false}
-        builderRefreshing={false}
-        builderProgressMessage=""
-        builderError=""
-        builderSaved=""
-        refreshDescriptionBuilder={vi.fn()}
-        setBuilderRawByGroup={vi.fn()}
-        setBuilderDirtyByGroup={vi.fn()}
-        setBuilderExpandedGroups={vi.fn()}
-        resetBuilderDescription={vi.fn()}
-        renderBuilderDescription={vi.fn()}
-        saveBuilderDescription={vi.fn()}
-      />,
-    );
-
-    expect(screen.queryByText("Built Description Preview")).not.toBeInTheDocument();
-    expect(
-      screen.getByDisplayValue("[img]https://img.example/final.png[/img]"),
-    ).toBeInTheDocument();
-    expect(container.querySelector('img[src="https://img.example/final.png"]')).toBeInstanceOf(
-      HTMLImageElement,
-    );
-  });
-
-  it("shows build progress while descriptions are loading", () => {
-    const builderPreview = {
-      SourcePath: "C:/media/Movie.mkv",
-      Groups: [],
-    } as unknown as DescriptionBuilderPreview;
-
-    render(
-      <DescriptionBuilderPage
-        path="C:/media/Movie.mkv"
-        builderPreview={builderPreview}
-        builderRawByGroup={{}}
-        builderRenderedByGroup={{}}
-        builderExpandedGroups={{}}
-        builderLoading
-        builderSaving={false}
-        builderRenderLoading={false}
-        builderRefreshing
-        builderProgressMessage="Rehosting required comparison and description images..."
-        builderError=""
-        builderSaved=""
-        refreshDescriptionBuilder={vi.fn()}
-        setBuilderRawByGroup={vi.fn()}
-        setBuilderDirtyByGroup={vi.fn()}
-        setBuilderExpandedGroups={vi.fn()}
-        resetBuilderDescription={vi.fn()}
-        renderBuilderDescription={vi.fn()}
-        saveBuilderDescription={vi.fn()}
-      />,
-    );
-
-    expect(
-      screen.getAllByText("Rehosting required comparison and description images...").length,
-    ).toBeGreaterThan(0);
-  });
-
-  it("renders each tracker favicon for multi-tracker groups", () => {
-    const builderPreview = {
-      SourcePath: "C:/media/Movie.mkv",
-      Groups: [
-        {
-          GroupKey: "unit3d|aither+blutopia|global",
-          Trackers: ["AITHER", "BLUTOPIA"],
-          Description: "",
-          DescriptionHTML: "",
-          RawDescription: "raw",
-          RawDescriptionHTML: "",
-          HasOverride: false,
-          ImageHost: { Status: "", SelectedHost: "", AllowedHosts: [], Warnings: [] },
-        },
-      ],
-    } as unknown as DescriptionBuilderPreview;
-
-    const { container } = render(
-      <DescriptionBuilderPage
-        path="C:/media/Movie.mkv"
-        builderPreview={builderPreview}
-        builderRawByGroup={{}}
-        builderRenderedByGroup={{}}
-        builderExpandedGroups={{}}
-        builderLoading={false}
-        builderSaving={false}
-        builderRenderLoading={false}
-        builderRefreshing={false}
-        builderProgressMessage=""
-        builderError=""
-        builderSaved=""
-        useFavicons={true}
-        faviconOnly={true}
-        trackerIconSrcByName={{
-          aither: "data:image/png;base64,iVBORw0KGgo=",
-          blutopia: "data:image/png;base64,iVBORw0KGgo=",
-        }}
-        refreshDescriptionBuilder={vi.fn()}
-        setBuilderRawByGroup={vi.fn()}
-        setBuilderDirtyByGroup={vi.fn()}
-        setBuilderExpandedGroups={vi.fn()}
-        resetBuilderDescription={vi.fn()}
-        renderBuilderDescription={vi.fn()}
-        saveBuilderDescription={vi.fn()}
-      />,
-    );
-
-    expect(screen.getByLabelText("AITHER, BLUTOPIA")).toBeTruthy();
-    expect(screen.queryByText("AITHER, BLUTOPIA")).toBeNull();
-    expect(container.querySelectorAll("img")).toHaveLength(2);
-  });
-
-  it("initializes rendered comparison controls in the builder preview", async () => {
-    const builderPreview = {
-      SourcePath: "C:/media/Movie.mkv",
-      Groups: [
-        {
-          GroupKey: "unit3d",
-          Trackers: ["HHD"],
-          Description: "",
-          DescriptionHTML: "",
-          RawDescription: "raw",
-          RawDescriptionHTML: `
-            <div class="comparison">
-              <details class="comparison__details">
-                <summary class="comparison__button">Show</summary>
-                <ul class="comparison__screenshots">
-                  <li><ul class="comparison__row">
-                    <li class="comparison__image-container"><figure><img class="comparison__image" src="https://img.example/a.png" /></figure></li>
-                    <li class="comparison__image-container"><figure><img class="comparison__image" src="https://img.example/b.png" /></figure></li>
-                    <li class="comparison__image-container"><figure><img class="comparison__image" src="https://img.example/c.png" /></figure></li>
-                  </ul></li>
-                </ul>
-              </details>
-            </div>`,
-          HasOverride: false,
-          ImageHost: { Status: "", SelectedHost: "", AllowedHosts: [], Warnings: [] },
-        },
-      ],
-    } as unknown as DescriptionBuilderPreview;
-
-    const { container } = render(
-      <DescriptionBuilderPage
-        path="C:/media/Movie.mkv"
-        builderPreview={builderPreview}
-        builderRawByGroup={{}}
-        builderRenderedByGroup={{}}
-        builderExpandedGroups={{ unit3d: true }}
-        builderLoading={false}
-        builderSaving={false}
-        builderRenderLoading={false}
-        builderRefreshing={false}
-        builderProgressMessage=""
-        builderError=""
-        builderSaved=""
-        refreshDescriptionBuilder={vi.fn()}
-        setBuilderRawByGroup={vi.fn()}
-        setBuilderDirtyByGroup={vi.fn()}
-        setBuilderExpandedGroups={vi.fn()}
-        resetBuilderDescription={vi.fn()}
-        renderBuilderDescription={vi.fn()}
-        saveBuilderDescription={vi.fn()}
-      />,
-    );
-
-    await waitFor(() => {
-      expect(container.querySelectorAll(".comparison__image-container--hidden")).toHaveLength(2);
-    });
-
-    const summary = container.querySelector(".comparison__button");
-    expect(summary).toBeInstanceOf(HTMLElement);
-    fireEvent.click(summary as HTMLElement);
-    fireEvent.mouseMove(window, { clientX: 900 });
-
-    await waitFor(() => {
-      const cells = Array.from(
-        container.querySelectorAll<HTMLElement>(".comparison__image-container"),
-      );
-      expect(cells[0].classList.contains("comparison__image-container--hidden")).toBe(true);
-      expect(cells[2].classList.contains("comparison__image-container--hidden")).toBe(false);
-    });
-  });
-});
diff --git a/gui/frontend/src/pages/description_builder/index.tsx b/gui/frontend/src/pages/description_builder/index.tsx
deleted file mode 100644
index 3549eef0..00000000
--- a/gui/frontend/src/pages/description_builder/index.tsx
+++ /dev/null
@@ -1,260 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { Dispatch, SetStateAction } from "react";
-import RenderedDescription from "../../components/RenderedDescription";
-import { TrackerIconImage } from "../../components/ui/tracker-icon";
-import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
-import { trackerIconFor } from "../../hooks/useTrackerIcons";
-import type { DescriptionBuilderPreview } from "../../types";
-
-type Props = {
-  path: string;
-  builderPreview: DescriptionBuilderPreview;
-  builderRawByGroup: Record<string, string>;
-  builderRenderedByGroup: Record<string, string>;
-  builderExpandedGroups: Record<string, boolean>;
-  builderLoading: boolean;
-  builderSaving: boolean;
-  builderRenderLoading: boolean;
-  builderRefreshing: boolean;
-  builderProgressMessage: string;
-  builderError: string;
-  builderSaved: string;
-  useFavicons?: boolean;
-  faviconOnly?: boolean;
-  trackerIconSrcByName?: TrackerIconCache;
-  refreshDescriptionBuilder: () => void;
-  setBuilderRawByGroup: Dispatch<SetStateAction<Record<string, string>>>;
-  setBuilderDirtyByGroup: Dispatch<SetStateAction<Record<string, boolean>>>;
-  setBuilderExpandedGroups: Dispatch<SetStateAction<Record<string, boolean>>>;
-  resetBuilderDescription: (groupKey: string) => void;
-  renderBuilderDescription: (groupKey: string) => void;
-  saveBuilderDescription: (groupKey: string) => void;
-};
-
-const groupLabel = (groupKey: string, trackers: string[]) => {
-  if (trackers.length > 0) return trackers.join(", ");
-  if (groupKey === "unit3d") return "Unit3D";
-  return groupKey || "Description";
-};
-
-export default function DescriptionBuilderPage(props: Props) {
-  const {
-    path,
-    builderPreview,
-    builderRawByGroup,
-    builderRenderedByGroup,
-    builderExpandedGroups,
-    builderLoading,
-    builderSaving,
-    builderRenderLoading,
-    builderRefreshing,
-    builderProgressMessage,
-    builderError,
-    builderSaved,
-    useFavicons = true,
-    faviconOnly = false,
-    trackerIconSrcByName = {},
-    refreshDescriptionBuilder,
-    setBuilderRawByGroup,
-    setBuilderDirtyByGroup,
-    setBuilderExpandedGroups,
-    resetBuilderDescription,
-    renderBuilderDescription,
-    saveBuilderDescription,
-  } = props;
-
-  const groups = builderPreview.Groups || [];
-
-  return (
-    <section className="flex flex-col gap-3">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Description Builder</p>
-        <h1>Customize Description</h1>
-        <p className="subtitle">
-          Edit tracker-group raw descriptions here. Tracker-specific formatting is applied from this
-          builder.
-        </p>
-      </header>
-
-      <section className="panel flex flex-wrap items-center justify-between gap-3 py-3">
-        <div className="min-w-0">
-          <p className="label">Source path</p>
-          <p className="value [overflow-wrap:anywhere] text-sm">{path || "No path selected"}</p>
-        </div>
-        <button
-          className="ghost"
-          type="button"
-          onClick={refreshDescriptionBuilder}
-          disabled={builderLoading || builderSaving || builderRenderLoading || !path.trim()}
-        >
-          {builderRefreshing ? "Refreshing..." : "Refresh descriptions"}
-        </button>
-        {builderProgressMessage ? (
-          <p className="m-0 basis-full text-right text-[0.82rem] text-[var(--muted)]">
-            {builderProgressMessage}
-          </p>
-        ) : null}
-      </section>
-
-      {builderError ? <p className="error">{builderError}</p> : null}
-      {builderSaved ? <p className="success">{builderSaved}</p> : null}
-
-      {builderLoading && groups.length === 0 ? (
-        <section className="panel">
-          <div className="mb-2 flex flex-col gap-1">
-            <h2>Building Descriptions</h2>
-          </div>
-          <p className="muted">
-            {builderProgressMessage ||
-              "Preparing tracker-group descriptions and image-host adjustments..."}
-          </p>
-        </section>
-      ) : groups.length === 0 ? (
-        <section className="panel">
-          <p className="muted">No tracker descriptions generated yet.</p>
-        </section>
-      ) : (
-        groups.map((group, i) => {
-          const groupKey = group.GroupKey;
-          const reactKey = groupKey || `default-${i}`;
-          const seededRaw = group.RawDescription || "";
-          const raw = builderRawByGroup[groupKey] ?? seededRaw;
-          const seededRendered = group.RawDescriptionHTML || "";
-          const renderedHTML = builderRenderedByGroup[groupKey] ?? seededRendered;
-          const expanded = builderExpandedGroups[groupKey] ?? false;
-          const trackers = (group.Trackers || []).map((tracker) => tracker.trim()).filter(Boolean);
-          const label = groupLabel(groupKey, trackers);
-          const hideTrackerNames = faviconOnly && useFavicons && trackers.length > 0;
-          const imageHostWarnings = group.ImageHost?.Warnings || [];
-
-          return (
-            <section className="panel grid gap-3" key={reactKey}>
-              <div className="mb-1 flex flex-wrap items-start justify-between gap-3">
-                <div>
-                  <h2>
-                    <span
-                      aria-label={hideTrackerNames ? label : undefined}
-                      className="inline-flex flex-wrap items-center gap-1.5"
-                    >
-                      {trackers.map((tracker) => (
-                        <TrackerIconImage
-                          tracker={tracker}
-                          iconSrc={trackerIconFor(trackerIconSrcByName, tracker)}
-                          enabled={useFavicons}
-                          key={`${groupKey}-${tracker}`}
-                        />
-                      ))}
-                      {hideTrackerNames ? null : label}
-                    </span>
-                  </h2>
-                  <p className="muted">
-                    {group.HasOverride
-                      ? "Saved override active for this group."
-                      : "Using generated raw description."}
-                  </p>
-                  {group.ImageHost?.Reuploaded && group.ImageHost?.Message ? (
-                    <p className="muted">{group.ImageHost.Message}</p>
-                  ) : null}
-                  {group.ImageHost?.Status === "warning" && group.ImageHost?.Message ? (
-                    <p className="m-0 mt-1 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100 [overflow-wrap:anywhere]">
-                      {group.ImageHost.Message}
-                    </p>
-                  ) : null}
-                  {imageHostWarnings.map((warning, index) => {
-                    const host = String(warning.Host || "").trim();
-                    const message = String(warning.Message || "").trim();
-                    if (!host && !message) return null;
-                    return (
-                      <p
-                        className="m-0 mt-1 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100 [overflow-wrap:anywhere]"
-                        key={`${host || "host"}-${index}`}
-                      >
-                        {host ? `${host} failed` : "Image host warning"}
-                        {message ? `: ${message}` : ""}
-                      </p>
-                    );
-                  })}
-                </div>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() =>
-                    setBuilderExpandedGroups((prev) => ({
-                      ...prev,
-                      [groupKey]: !expanded,
-                    }))
-                  }
-                >
-                  {expanded ? "Collapse" : "Expand"}
-                </button>
-              </div>
-
-              {expanded ? (
-                <>
-                  <div className="flex flex-wrap items-center gap-2">
-                    <button
-                      className="ghost"
-                      type="button"
-                      onClick={() => resetBuilderDescription(groupKey)}
-                      disabled={builderLoading || builderSaving || !path.trim()}
-                    >
-                      {builderLoading ? "Resetting..." : "Reset group"}
-                    </button>
-                    <button
-                      className="ghost"
-                      type="button"
-                      onClick={() => renderBuilderDescription(groupKey)}
-                      disabled={builderRenderLoading}
-                    >
-                      {builderRenderLoading ? "Rendering..." : "Render"}
-                    </button>
-                    <button
-                      className="primary"
-                      type="button"
-                      onClick={() => saveBuilderDescription(groupKey)}
-                      disabled={builderSaving || !path.trim()}
-                    >
-                      {builderSaving ? "Saving..." : "Save group"}
-                    </button>
-                  </div>
-
-                  <section className="panel">
-                    <div className="mb-2 flex flex-col gap-1">
-                      <h2>Raw Description</h2>
-                      <p className="muted">
-                        This final raw description is the upload source of truth for{" "}
-                        {hideTrackerNames ? "this group" : label}.
-                      </p>
-                    </div>
-                    <textarea
-                      className="min-h-[170px] w-full resize-y rounded-lg border border-white/10 bg-black/25 px-3 py-2 text-[0.95rem] leading-6 text-[var(--text)]"
-                      value={raw}
-                      onChange={(event) => {
-                        const nextValue = event.target.value;
-                        setBuilderRawByGroup((prev) => ({ ...prev, [groupKey]: nextValue }));
-                        setBuilderDirtyByGroup((prev) => ({ ...prev, [groupKey]: true }));
-                      }}
-                    />
-                  </section>
-
-                  <section className="panel">
-                    <div className="mb-2 flex flex-col gap-1">
-                      <h2>Rendered Raw Preview</h2>
-                    </div>
-                    {renderedHTML ? (
-                      <RenderedDescription html={renderedHTML} />
-                    ) : (
-                      <p className="muted">No rendered preview yet.</p>
-                    )}
-                  </section>
-                </>
-              ) : null}
-            </section>
-          );
-        })
-      )}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/dupe_check/index.test.tsx b/gui/frontend/src/pages/dupe_check/index.test.tsx
deleted file mode 100644
index 41debece..00000000
--- a/gui/frontend/src/pages/dupe_check/index.test.tsx
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { DupeCheckResult, DupeCheckSummary, DupeCheckTrackerState } from "../../types";
-import DupeCheckPage from "./index";
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  cleanup();
-});
-
-const dupeSummaryFor = (trackers: string[], notes: string[] = []) =>
-  ({
-    SourcePath: "C:\\Media\\Example.Movie.mkv",
-    Results: trackers.map((tracker) => ({
-      Tracker: tracker,
-      Raw: [],
-      Filtered: [],
-      HasDupes: false,
-      ContentFail: false,
-      Match: {},
-      Notes: notes,
-      Skipped: notes.length > 0,
-      SkipReason: "",
-      Status: "complete",
-      Error: "",
-      CheckedAt: "",
-    })),
-    Notes: [],
-  }) as unknown as DupeCheckSummary;
-
-const renderPage = (
-  dupeSummary: DupeCheckSummary,
-  options: {
-    faviconOnly?: boolean;
-    trackerIconSrcByName?: Record<string, string>;
-    dupeTrackerStates?: DupeCheckTrackerState[];
-    skippedDupeReasons?: Record<string, string>;
-  } = {},
-) =>
-  render(
-    <DupeCheckPage
-      path="C:\\Media\\Example.Movie.mkv"
-      dupeLoading={false}
-      dupeError=""
-      dupeSummary={dupeSummary}
-      dupeTrackerStates={options.dupeTrackerStates ?? []}
-      dupeTrackerFlags={{}}
-      dupeIgnore={{}}
-      ruleSkippedTrackerSet={new Set()}
-      skippedDupeReasons={options.skippedDupeReasons ?? {}}
-      ruleSkipReasons={{}}
-      dupeProgressStatus=""
-      dupeCompletedCount={0}
-      dupeTotalCount={0}
-      useFavicons={true}
-      faviconOnly={options.faviconOnly ?? false}
-      trackerIconSrcByName={options.trackerIconSrcByName ?? {}}
-      handleDupeCheck={vi.fn()}
-      setDupeIgnore={vi.fn()}
-    />,
-  );
-
-const ruleSkippedResult = (tracker: string, reason: string) =>
-  ({
-    Tracker: tracker,
-    Raw: [],
-    Filtered: [],
-    HasDupes: false,
-    ContentFail: false,
-    Match: {},
-    Notes: [],
-    Skipped: true,
-    SkipReason: reason,
-    SkipCode: "",
-    SkipRules: [],
-    Status: "skipped",
-    Error: "",
-    CheckedAt: "",
-  }) as unknown as DupeCheckResult;
-
-const completedResult = (tracker: string) =>
-  ({
-    ...ruleSkippedResult(tracker, ""),
-    Skipped: false,
-    Status: "completed",
-  }) as DupeCheckResult;
-
-const trackerStateFor = (result: DupeCheckResult): DupeCheckTrackerState => ({
-  tracker: result.Tracker,
-  status: result.Status,
-  message: result.SkipReason || "no dupes found",
-  result,
-  startedAt: "",
-  finishedAt: "",
-});
-
-describe("DupeCheckPage", () => {
-  it("hides full tracker names in favicon-only mode when cached icons are present", () => {
-    renderPage(dupeSummaryFor(["AITHER"]), {
-      faviconOnly: true,
-      trackerIconSrcByName: { aither: "data:image/png;base64,iVBORw0KGgo=" },
-    });
-
-    expect(screen.queryByText("AITHER")).toBeNull();
-  });
-
-  it("falls back to tracker abbreviation in favicon-only mode without cached icons", () => {
-    renderPage(dupeSummaryFor(["UNCONFIGURED"]), { faviconOnly: true });
-
-    expect(screen.queryByText("UNCONFIGURED")).toBeNull();
-    expect(screen.getAllByText("UNC").length).toBeGreaterThan(0);
-  });
-
-  it("does not attempt to fetch icons from the dupe page", () => {
-    const getTrackerIcon = vi.fn().mockResolvedValue("");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
-
-    renderPage(dupeSummaryFor(["AITHER"]));
-
-    expect(screen.getAllByText("AITHER").length).toBeGreaterThan(0);
-    expect(getTrackerIcon).not.toHaveBeenCalled();
-  });
-
-  it("uses abbreviation fallback on in-client dupe rows in favicon-only mode", () => {
-    renderPage(
-      dupeSummaryFor(["AITHER", "BLUTOPIA"], ["pathed torrent match found; skipping dupe search"]),
-      { faviconOnly: true },
-    );
-
-    expect(screen.getAllByText("In client")).toHaveLength(2);
-    expect(screen.queryByText("AITHER")).toBeNull();
-    expect(screen.queryByText("BLUTOPIA")).toBeNull();
-    expect(screen.getAllByText("AIT").length).toBeGreaterThan(0);
-    expect(screen.getAllByText("BLU").length).toBeGreaterThan(0);
-  });
-
-  it("renders each tracker favicon on combined in-client rows", () => {
-    const { container } = renderPage(
-      dupeSummaryFor(["AITHER, BLUTOPIA"], ["pathed torrent match found; skipping dupe search"]),
-      {
-        faviconOnly: true,
-        trackerIconSrcByName: {
-          aither: "data:image/png;base64,iVBORw0KGgo=",
-          blutopia: "data:image/png;base64,iVBORw0KGgo=",
-        },
-      },
-    );
-
-    expect(screen.getAllByText("In client")).toHaveLength(1);
-    expect(screen.getByLabelText("AITHER, BLUTOPIA")).toBeTruthy();
-    expect(container.querySelectorAll("img")).toHaveLength(2);
-  });
-
-  it("counts split tracker labels on grouped rule-failure rows", () => {
-    renderPage({
-      SourcePath: "C:\\Media\\Example.Movie.mkv",
-      Results: [
-        ruleSkippedResult("AITHER, DP", "rule check failed: missing language data"),
-        completedResult("ANT"),
-      ],
-      Notes: [],
-    });
-
-    expect(screen.getByText("Available for upload: 1")).toBeInTheDocument();
-    expect(screen.getByText("2 blocked.")).toBeInTheDocument();
-    expect(screen.getByText("AITHER, DP")).toBeInTheDocument();
-    expect(screen.getAllByText("AIT").length).toBeGreaterThan(0);
-    expect(screen.getAllByText("DP").length).toBeGreaterThan(0);
-  });
-
-  it("shows non-rule skipped reasons", () => {
-    renderPage({
-      SourcePath: "C:\\Media\\Example.Movie.mkv",
-      Results: [
-        {
-          ...completedResult("NBL"),
-          Status: "skipped",
-          Skipped: true,
-          SkipReason: "missing api_key for tracker",
-          Notes: ["skip: missing api_key for tracker"],
-        },
-        completedResult("ANT"),
-      ],
-      Notes: [],
-    });
-
-    expect(screen.getByText("Available for upload: 1")).toBeInTheDocument();
-    expect(screen.getByText("1 blocked.")).toBeInTheDocument();
-    expect(screen.getByText("Skipped")).toBeInTheDocument();
-    expect(screen.getByText("missing api_key for tracker")).toBeInTheDocument();
-    expect(screen.queryByText("Rule failed")).toBeNull();
-  });
-
-  it("labels tracker-auth preflight skips as auth required", () => {
-    renderPage({
-      SourcePath: "C:\\Media\\Example.Movie.mkv",
-      Results: [
-        {
-          ...completedResult("PTP"),
-          Status: "skipped",
-          Skipped: true,
-          SkipReason: "tracker auth not ready: manual 2FA required",
-          SkipCode: "tracker_auth_not_ready",
-        },
-        completedResult("ANT"),
-      ],
-      Notes: [],
-    });
-
-    expect(screen.getByText("Auth required")).toBeInTheDocument();
-    expect(screen.getByText("tracker auth not ready: manual 2FA required")).toBeInTheDocument();
-    expect(screen.queryByText("Skipped")).toBeNull();
-  });
-
-  it("uses structured SkipRules for rule-failure skipped results", () => {
-    renderPage({
-      SourcePath: "C:\\Media\\Example.Movie.mkv",
-      Results: [
-        {
-          ...completedResult("NBL"),
-          Status: "skipped",
-          Skipped: true,
-          SkipReason: "",
-          SkipRules: ["required_metadata"],
-        },
-        completedResult("ANT"),
-      ],
-      Notes: [],
-    });
-
-    expect(screen.getByText("Available for upload: 1")).toBeInTheDocument();
-    expect(screen.getByText("1 blocked.")).toBeInTheDocument();
-    expect(screen.getByText("Rule failed")).toBeInTheDocument();
-    expect(screen.queryByText("Skipped")).toBeNull();
-  });
-
-  it("uses threaded skipped reasons when SkipReason is empty", () => {
-    renderPage(
-      {
-        SourcePath: "C:\\Media\\Example.Movie.mkv",
-        Results: [
-          {
-            ...completedResult("NBL"),
-            Status: "skipped",
-            Skipped: true,
-            SkipReason: "",
-            Notes: ["skip: missing api_key for tracker"],
-          },
-          completedResult("ANT"),
-        ],
-        Notes: [],
-      },
-      { skippedDupeReasons: { nbl: "missing api_key for tracker" } },
-    );
-
-    expect(screen.getByText("Skipped")).toBeInTheDocument();
-    expect(screen.getByText("missing api_key for tracker")).toBeInTheDocument();
-    expect(screen.queryByText("Rule failed")).toBeNull();
-  });
-
-  it("prefers per-tracker snapshot results over grouped rule-failure summary rows", () => {
-    renderPage(
-      {
-        SourcePath: "C:\\Media\\Example.Movie.mkv",
-        Results: [
-          ruleSkippedResult(
-            "AITHER, DP",
-            "rule check failed: missing MediaInfo Unique ID; missing language data",
-          ),
-          completedResult("ANT"),
-        ],
-        Notes: [],
-      },
-      {
-        dupeTrackerStates: [
-          trackerStateFor(
-            ruleSkippedResult("AITHER", "rule check failed: missing MediaInfo Unique ID"),
-          ),
-          trackerStateFor(ruleSkippedResult("DP", "rule check failed: missing language data")),
-          trackerStateFor(completedResult("ANT")),
-        ],
-      },
-    );
-
-    expect(screen.getByText("Available for upload: 1")).toBeInTheDocument();
-    expect(screen.getByText("2 blocked.")).toBeInTheDocument();
-    expect(screen.queryByText("AITHER, DP")).toBeNull();
-    expect(screen.getAllByText("AITHER").length).toBeGreaterThan(0);
-    expect(screen.getAllByText("DP").length).toBeGreaterThan(0);
-    expect(screen.getByText("rule check failed: missing MediaInfo Unique ID")).toBeInTheDocument();
-    expect(screen.getByText("rule check failed: missing language data")).toBeInTheDocument();
-  });
-});
diff --git a/gui/frontend/src/pages/dupe_check/index.tsx b/gui/frontend/src/pages/dupe_check/index.tsx
deleted file mode 100644
index f5319d1e..00000000
--- a/gui/frontend/src/pages/dupe_check/index.tsx
+++ /dev/null
@@ -1,442 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { Dispatch, SetStateAction } from "react";
-import { Badge } from "../../components/ui/badge";
-import { Button } from "../../components/ui/button";
-import { Switch } from "../../components/ui/switch";
-import { TrackerIconImage } from "../../components/ui/tracker-icon";
-import type { DupeCheckResult, DupeCheckSummary, DupeCheckTrackerState } from "../../types";
-import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
-import { trackerIconFor } from "../../hooks/useTrackerIcons";
-import { cn } from "../../utils/cn";
-import { dupeSkipReason, isRuleSkippedResult } from "../../utils/dupeCheck";
-import { handleExternalLinkClick } from "../../utils/externalLinks";
-
-type Props = {
-  path: string;
-  dupeLoading: boolean;
-  dupeError: string;
-  dupeSummary: DupeCheckSummary;
-  dupeTrackerStates?: DupeCheckTrackerState[];
-  dupeTrackerFlags: Record<string, boolean>;
-  dupeIgnore: Record<string, boolean>;
-  ruleSkippedTrackerSet: Set<string>;
-  skippedDupeReasons: Record<string, string>;
-  ruleSkipReasons: Record<string, string>;
-  dupeProgressStatus: string;
-  dupeCompletedCount: number;
-  dupeTotalCount: number;
-  useFavicons?: boolean;
-  faviconOnly?: boolean;
-  trackerIconSrcByName: TrackerIconCache;
-  handleDupeCheck: () => void;
-  setDupeIgnore: Dispatch<SetStateAction<Record<string, boolean>>>;
-};
-
-const pathedNote = "pathed torrent match found; skipping dupe search";
-
-const splitTrackerLabel = (value: string) =>
-  value
-    .split(",")
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0);
-
-const isFinishedTrackerStatus = (status: string) => {
-  switch (status.toLowerCase().trim()) {
-    case "complete":
-    case "completed":
-    case "skipped":
-    case "failed":
-    case "canceled":
-      return true;
-    default:
-      return false;
-  }
-};
-
-/**
- * Converts a finished tracker job state into a displayable dupe result.
- * Pending states without backend results are skipped so progress snapshots do not
- * appear as upload-eligible tracker rows.
- */
-const resultFromTrackerState = (state: DupeCheckTrackerState): DupeCheckResult | null => {
-  const resultTracker = String(state.result?.Tracker || "").trim();
-  const status = String(state.result?.Status || state.status || "").trim();
-  if (!resultTracker && !isFinishedTrackerStatus(status)) return null;
-  const tracker = String(resultTracker || state.tracker || "").trim();
-  if (!tracker) return null;
-  return {
-    ...state.result,
-    Tracker: tracker,
-    Status: status,
-  };
-};
-
-/**
- * Prefers per-tracker snapshot results over grouped summary rows.
- *
- * The backend may group rule-failure skips by reason for compact summaries, but
- * the page needs individual tracker labels/icons/counts when job state is present.
- */
-const displayResultsFor = (
-  summaryResults: DupeCheckResult[],
-  trackerStates: DupeCheckTrackerState[] | undefined,
-) => {
-  const stateResults = (trackerStates || [])
-    .map(resultFromTrackerState)
-    .filter((result): result is DupeCheckResult => Boolean(result));
-  return stateResults.length > 0 ? stateResults : summaryResults;
-};
-
-/** Expands comma-grouped tracker labels while preserving normal single-tracker rows. */
-const trackerNamesForResult = (result: DupeCheckResult) => {
-  const splitNames = splitTrackerLabel(result.Tracker);
-  return splitNames.length > 0 && result.Tracker.includes(",") ? splitNames : [result.Tracker];
-};
-
-export default function DupeCheckPage(props: Readonly<Props>) {
-  const {
-    path,
-    dupeLoading,
-    dupeError,
-    dupeSummary,
-    dupeTrackerStates,
-    dupeTrackerFlags,
-    dupeIgnore,
-    ruleSkippedTrackerSet,
-    skippedDupeReasons,
-    ruleSkipReasons,
-    dupeProgressStatus,
-    dupeCompletedCount,
-    dupeTotalCount,
-    useFavicons = true,
-    faviconOnly = false,
-    trackerIconSrcByName,
-    handleDupeCheck,
-    setDupeIgnore,
-  } = props;
-
-  const dupeSummaryNotes = dupeSummary.Notes || [];
-  const hasDupeNotes = dupeSummaryNotes.length > 0;
-  const displayResults = displayResultsFor(dupeSummary.Results || [], dupeTrackerStates);
-  const hasDupeResults = displayResults.length > 0;
-  const dupeEmptyMessage = hasDupeNotes ? dupeSummaryNotes.join(" ") : "No dupe results yet.";
-  const showProgress =
-    dupeLoading || dupeProgressStatus === "running" || dupeProgressStatus === "queued";
-  const progressText =
-    dupeTotalCount > 0
-      ? `${Math.min(dupeCompletedCount, dupeTotalCount)}/${dupeTotalCount} trackers complete`
-      : "Preparing tracker search";
-  const sortedResults = displayResults.slice().sort((left, right) => {
-    const leftCount = left.Filtered?.length ?? 0;
-    const rightCount = right.Filtered?.length ?? 0;
-    const leftPathed = left.Notes?.includes(pathedNote) ?? false;
-    const rightPathed = right.Notes?.includes(pathedNote) ?? false;
-    const leftRuleSkip =
-      ruleSkippedTrackerSet.has(left.Tracker.toLowerCase().trim()) || isRuleSkippedResult(left);
-    const rightRuleSkip =
-      ruleSkippedTrackerSet.has(right.Tracker.toLowerCase().trim()) || isRuleSkippedResult(right);
-    const leftHasDupes = leftCount > 0;
-    const rightHasDupes = rightCount > 0;
-
-    if (leftHasDupes && rightHasDupes && rightCount !== leftCount) {
-      return rightCount - leftCount;
-    }
-    if (leftHasDupes !== rightHasDupes) {
-      return leftHasDupes ? -1 : 1;
-    }
-    if (leftPathed !== rightPathed) {
-      return leftPathed ? -1 : 1;
-    }
-    if (leftRuleSkip !== rightRuleSkip) {
-      return leftRuleSkip ? -1 : 1;
-    }
-    return left.Tracker.localeCompare(right.Tracker);
-  });
-  const availability = sortedResults.reduce(
-    (next, result) => {
-      const normalizedTracker = result.Tracker.toLowerCase().trim();
-      const status = String(result.Status || "")
-        .toLowerCase()
-        .trim();
-      const hasFailure = status === "failed" || Boolean(result.Error?.trim());
-      const hasPathedNote = result.Notes?.includes(pathedNote) ?? false;
-      const isUnavailable =
-        hasFailure ||
-        hasPathedNote ||
-        Boolean(result.Skipped) ||
-        Boolean(dupeTrackerFlags[result.Tracker]) ||
-        ruleSkippedTrackerSet.has(normalizedTracker);
-
-      trackerNamesForResult(result).forEach((tracker) => {
-        const normalized = tracker.toLowerCase().trim();
-        if (!normalized || next.seen.has(normalized)) return;
-        next.seen.add(normalized);
-        if (isUnavailable) {
-          next.unavailableCount += 1;
-        } else {
-          next.availableTrackers.push(tracker);
-        }
-      });
-      return next;
-    },
-    { availableTrackers: [] as string[], unavailableCount: 0, seen: new Set<string>() },
-  );
-  const availableTrackers = availability.availableTrackers;
-  const unavailableCount = availability.unavailableCount;
-  const hideTrackerNames = faviconOnly && useFavicons;
-
-  return (
-    <section className="flex flex-col gap-3">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Dupe Checking</p>
-        <h1>Check Trackers</h1>
-        <p className="subtitle">Scan selected trackers for potential dupes before upload.</p>
-      </header>
-
-      <section className="panel flex flex-wrap items-center justify-between gap-3 py-3">
-        <div className="min-w-0">
-          <p className="label">Source path</p>
-          <p className="value break-words text-sm">{path || "No path selected"}</p>
-          {hasDupeResults ? (
-            <div className="mt-2 flex flex-wrap items-center gap-1.5 text-xs text-[var(--muted)]">
-              <span className="font-semibold text-[var(--text)]">
-                Available for upload: {availableTrackers.length}
-              </span>
-              {availableTrackers.length ? (
-                availableTrackers.map((tracker) => {
-                  const iconSrc = trackerIconFor(trackerIconSrcByName, tracker);
-                  return (
-                    <Badge
-                      aria-label={hideTrackerNames ? tracker : undefined}
-                      className="text-[var(--text)] flex items-center gap-1"
-                      style={{
-                        backgroundColor: "color-mix(in srgb, var(--accent-2) 14%, transparent)",
-                        borderColor: "color-mix(in srgb, var(--accent-2) 42%, transparent)",
-                      }}
-                      key={`available-${tracker}`}
-                    >
-                      <TrackerIconImage tracker={tracker} iconSrc={iconSrc} enabled={useFavicons} />
-                      {hideTrackerNames ? null : tracker}
-                    </Badge>
-                  );
-                })
-              ) : (
-                <span>No trackers passed.</span>
-              )}
-              {unavailableCount > 0 ? <span>{unavailableCount} blocked.</span> : null}
-            </div>
-          ) : null}
-        </div>
-        <Button
-          className="ml-auto"
-          variant="primary"
-          type="button"
-          onClick={handleDupeCheck}
-          disabled={dupeLoading || !path.trim()}
-        >
-          {dupeLoading
-            ? `Checking ${dupeCompletedCount}/${dupeTotalCount || "?"}...`
-            : "Run dupe check"}
-        </Button>
-      </section>
-
-      {showProgress ? (
-        <p className="muted text-sm">Tracker search progress: {progressText}</p>
-      ) : null}
-
-      {dupeError ? <p className="error">{dupeError}</p> : null}
-
-      {hasDupeNotes ? (
-        <div className="flex flex-wrap gap-1.5">
-          {dupeSummaryNotes.map((note, index) => (
-            <Badge tone="info" key={`${note}-${index}`}>
-              {note}
-            </Badge>
-          ))}
-        </div>
-      ) : null}
-
-      {hasDupeResults ? (
-        <div className="overflow-hidden rounded-lg border border-white/10 bg-[rgba(12,16,26,0.76)]">
-          <div className="hidden grid-cols-[minmax(90px,140px)_58px_minmax(0,1fr)_116px] gap-3 border-b border-white/10 px-3 py-2 text-[11px] font-semibold uppercase tracking-[0.08em] text-[var(--muted)] md:grid">
-            <span>Tracker</span>
-            <span>Dupes</span>
-            <span>Matches</span>
-            <span>Action</span>
-          </div>
-          <div className="divide-y divide-white/10">
-            {sortedResults.map((result) => {
-              const dupeCount = result.Filtered?.length ?? 0;
-              const hasDupes = result.HasDupes ?? false;
-              const hasPathedNote = result.Notes?.includes(pathedNote) ?? false;
-              const status = String(result.Status || "")
-                .toLowerCase()
-                .trim();
-              const hasFailure = status === "failed" || Boolean(result.Error?.trim());
-              const normalizedTracker = result.Tracker.toLowerCase().trim();
-              const skipReason = dupeSkipReason(result);
-              const ruleSkipReason =
-                ruleSkipReasons[normalizedTracker] ||
-                (isRuleSkippedResult(result) ? skipReason || "rule check failed" : "");
-              const authRequired = result.SkipCode === "tracker_auth_not_ready";
-              const skippedReason =
-                result.Skipped && !ruleSkipReason && !authRequired
-                  ? skippedDupeReasons[normalizedTracker] || skipReason
-                  : "";
-              const visibleNotes =
-                result.Notes?.filter((note) => {
-                  if (note === pathedNote) return false;
-                  const normalizedNote = note.toLowerCase().trim();
-                  if (normalizedNote.startsWith("skip:")) return false;
-                  if (normalizedNote.startsWith("rule check failed")) return false;
-                  if (ruleSkipReason && note.trim() === ruleSkipReason) return false;
-                  if (skippedReason && note.trim() === skippedReason) return false;
-                  return true;
-                }) ?? [];
-              const showIgnoreToggle = !hasPathedNote && (hasDupes || dupeCount > 0);
-              const displayDupeCount =
-                (dupeTrackerFlags[result.Tracker] ?? hasDupes) ? dupeCount : 0;
-              const displayTrackers =
-                hasPathedNote || ruleSkipReason || authRequired || skippedReason
-                  ? trackerNamesForResult(result)
-                  : [];
-              const iconTrackers = displayTrackers.length > 0 ? displayTrackers : [result.Tracker];
-
-              return (
-                <article
-                  className="grid grid-cols-[minmax(72px,96px)_44px_minmax(0,1fr)] gap-2 px-2 py-2 text-sm md:grid-cols-[minmax(90px,140px)_58px_minmax(0,1fr)_116px] md:gap-3 md:px-3"
-                  key={result.Tracker}
-                >
-                  <div className="min-w-0 flex items-center gap-2">
-                    <div
-                      className="flex shrink-0 flex-wrap items-center gap-1"
-                      aria-label={hideTrackerNames ? iconTrackers.join(", ") : undefined}
-                    >
-                      {iconTrackers.map((tracker) => (
-                        <TrackerIconImage
-                          tracker={tracker}
-                          iconSrc={trackerIconFor(trackerIconSrcByName, tracker)}
-                          enabled={useFavicons}
-                          key={`${result.Tracker}-${tracker}`}
-                        />
-                      ))}
-                    </div>
-                    {hideTrackerNames ? null : (
-                      <p className="font-bold text-[var(--text)]">{result.Tracker}</p>
-                    )}
-                  </div>
-
-                  <p
-                    className={cn(
-                      "font-bold tabular-nums",
-                      displayDupeCount > 0 ? "text-[var(--accent)]" : "text-[var(--muted)]",
-                    )}
-                  >
-                    {displayDupeCount}
-                  </p>
-
-                  <div className="min-w-0">
-                    {hasPathedNote ||
-                    ruleSkipReason ||
-                    authRequired ||
-                    skippedReason ||
-                    hasFailure ||
-                    visibleNotes.length ? (
-                      <p className="mb-1 flex flex-wrap items-center gap-1 text-sm leading-5">
-                        {hasPathedNote ? <Badge tone="info">In client</Badge> : null}
-
-                        {ruleSkipReason ? (
-                          <>
-                            <Badge tone="danger">Rule failed</Badge>
-                            <span className="text-[var(--muted)]">{ruleSkipReason}</span>
-                          </>
-                        ) : null}
-
-                        {authRequired ? (
-                          <>
-                            <Badge tone="danger">Auth required</Badge>
-                            <span className="text-[var(--muted)]">{skipReason}</span>
-                          </>
-                        ) : null}
-
-                        {skippedReason ? (
-                          <>
-                            <Badge tone="info">Skipped</Badge>
-                            <span className="text-[var(--muted)]">{skippedReason}</span>
-                          </>
-                        ) : null}
-
-                        {hasFailure ? (
-                          <>
-                            <Badge tone="danger">Error</Badge>
-                            <span className="text-[var(--muted)]">
-                              {result.Error || "Tracker dupe check failed"}
-                            </span>
-                          </>
-                        ) : null}
-
-                        {visibleNotes.map((note, index) => (
-                          <Badge tone="info" key={`${note}-${index}`}>
-                            {note}
-                          </Badge>
-                        ))}
-                      </p>
-                    ) : null}
-
-                    {result.Filtered?.length ? (
-                      <p className="value text-sm leading-5">
-                        {result.Filtered.map((entry, index) => (
-                          <span className="inline" key={`${entry.Name}-${index}`}>
-                            {entry.Link ? (
-                              <a
-                                href={entry.Link}
-                                target="_blank"
-                                rel="noreferrer"
-                                className="tracker-link"
-                                onAuxClick={handleExternalLinkClick}
-                                onClick={handleExternalLinkClick}
-                              >
-                                {entry.Name}
-                              </a>
-                            ) : (
-                              <span>{entry.Name}</span>
-                            )}
-                            {index < result.Filtered.length - 1 ? (
-                              <span className="text-[var(--muted)]">, </span>
-                            ) : null}
-                          </span>
-                        ))}
-                      </p>
-                    ) : null}
-                  </div>
-
-                  <div className="col-span-3 md:col-span-1">
-                    {showIgnoreToggle ? (
-                      <div className="inline-flex items-center gap-2 text-xs font-semibold text-[var(--text)]">
-                        <span>Ignore</span>
-                        <Switch
-                          aria-label={`Ignore dupes for ${result.Tracker}`}
-                          checked={dupeIgnore[result.Tracker] ?? false}
-                          onChange={(event) =>
-                            setDupeIgnore((prev) => ({
-                              ...prev,
-                              [result.Tracker]: event.target.checked,
-                            }))
-                          }
-                        />
-                      </div>
-                    ) : null}
-                  </div>
-                </article>
-              );
-            })}
-          </div>
-        </div>
-      ) : (
-        <p className="muted">{dupeEmptyMessage}</p>
-      )}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/history/index.tsx b/gui/frontend/src/pages/history/index.tsx
deleted file mode 100644
index e3385ece..00000000
--- a/gui/frontend/src/pages/history/index.tsx
+++ /dev/null
@@ -1,430 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useEffect, useMemo, useState } from "react";
-import type { HistoryEntry, HistoryOverview } from "../../types";
-import { cn } from "../../utils/cn";
-
-const formatDate = (value: string) => {
-  if (!value) {
-    return "—";
-  }
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    return value;
-  }
-  return date.toLocaleString();
-};
-
-const isUploadedStatus = (value: string) => {
-  const normalized = value?.trim().toLowerCase();
-  return normalized === "uploaded" || normalized === "success" || normalized === "completed";
-};
-
-const formatLastUpload = (
-  latestUploadStatus: string,
-  statusLabel: string,
-  latestUploadAt: string,
-) => {
-  if (!isUploadedStatus(latestUploadStatus) && !isUploadedStatus(statusLabel)) {
-    return "never";
-  }
-  if (!latestUploadAt) {
-    return "never";
-  }
-  return formatDate(latestUploadAt);
-};
-
-const releaseLabel = (entry: HistoryEntry) => {
-  const title = entry.ReleaseTitle?.trim() || "Untitled release";
-  const source = entry.ReleaseSource?.trim();
-  const resolution = entry.ReleaseResolution?.trim();
-  const extras = [source, resolution].filter(Boolean).join(" • ");
-  return extras ? `${title} (${extras})` : title;
-};
-
-const releaseLabelFromOverview = (overview: HistoryOverview) => {
-  const title = overview.ReleaseTitle?.trim() || "Untitled release";
-  const source = overview.ReleaseSource?.trim();
-  const resolution = overview.ReleaseResolution?.trim();
-  const extras = [source, resolution].filter(Boolean).join(" • ");
-  return extras ? `${title} (${extras})` : title;
-};
-
-type Props = {
-  onReleaseDeleted?: (sourcePath: string) => void;
-};
-
-export default function HistoryPage({ onReleaseDeleted }: Props) {
-  const [entries, setEntries] = useState<HistoryEntry[]>([]);
-  const [selectedPath, setSelectedPath] = useState("");
-  const [searchQuery, setSearchQuery] = useState("");
-  const [overview, setOverview] = useState<HistoryOverview | null>(null);
-  const [loading, setLoading] = useState(false);
-  const [detailLoading, setDetailLoading] = useState(false);
-  const [deleting, setDeleting] = useState(false);
-  const [error, setError] = useState("");
-
-  useEffect(() => {
-    const listHistory = globalThis.go?.guiapp?.App?.ListHistory;
-    if (!listHistory) {
-      setError("History is unavailable in this build.");
-      return;
-    }
-
-    const load = async () => {
-      setLoading(true);
-      setError("");
-      try {
-        const result = await listHistory();
-        setEntries(result || []);
-        if (result?.length) {
-          setSelectedPath((current) => current || result[0].SourcePath);
-        } else {
-          setSelectedPath("");
-          setOverview(null);
-        }
-      } catch (err) {
-        setError(String(err));
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    void load();
-  }, []);
-
-  const filteredEntries = useMemo(() => {
-    const query = searchQuery.trim().toLowerCase();
-    if (!query) {
-      return entries;
-    }
-    return entries.filter((entry) => {
-      const title = entry.ReleaseTitle?.trim().toLowerCase() || "";
-      return title.includes(query);
-    });
-  }, [entries, searchQuery]);
-
-  useEffect(() => {
-    if (!filteredEntries.length) {
-      setSelectedPath("");
-      setOverview(null);
-      return;
-    }
-    const selectionStillVisible = filteredEntries.some(
-      (entry) => entry.SourcePath === selectedPath,
-    );
-    if (!selectionStillVisible) {
-      setSelectedPath(filteredEntries[0].SourcePath);
-    }
-  }, [filteredEntries, selectedPath]);
-
-  useEffect(() => {
-    if (!selectedPath) {
-      setOverview(null);
-      return;
-    }
-    const getHistoryOverview = globalThis.go?.guiapp?.App?.GetHistoryOverview;
-    if (!getHistoryOverview) {
-      setError("History overview is unavailable in this build.");
-      return;
-    }
-
-    const loadDetail = async () => {
-      setDetailLoading(true);
-      setError("");
-      try {
-        const next = await getHistoryOverview(selectedPath);
-        setOverview(next);
-      } catch (err) {
-        setError(String(err));
-      } finally {
-        setDetailLoading(false);
-      }
-    };
-
-    void loadDetail();
-  }, [selectedPath]);
-
-  const selectedEntry = useMemo(
-    () => entries.find((entry) => entry.SourcePath === selectedPath) || null,
-    [entries, selectedPath],
-  );
-
-  const descriptionOverrides = useMemo(() => {
-    if (!overview) {
-      return [];
-    }
-    return Array.isArray(overview.DescriptionOverrides) ? overview.DescriptionOverrides : [];
-  }, [overview]);
-
-  const handleDeleteRelease = async () => {
-    if (!selectedPath) {
-      return;
-    }
-    const deleteHistoryRelease = globalThis.go?.guiapp?.App?.DeleteHistoryRelease;
-    const listHistory = globalThis.go?.guiapp?.App?.ListHistory;
-    if (!deleteHistoryRelease || !listHistory) {
-      setError("Delete is unavailable in this build.");
-      return;
-    }
-    const confirmed = window.confirm("Remove this stored release and all associated stored files?");
-    if (!confirmed) {
-      return;
-    }
-
-    setDeleting(true);
-    setError("");
-    try {
-      const deletedPath = selectedPath;
-      await deleteHistoryRelease(deletedPath);
-      onReleaseDeleted?.(deletedPath);
-      const refreshed = (await listHistory()) || [];
-      setEntries(refreshed);
-      if (!refreshed.length) {
-        setSelectedPath("");
-        setOverview(null);
-      }
-    } catch (err) {
-      setError(String(err));
-    } finally {
-      setDeleting(false);
-    }
-  };
-
-  return (
-    <div className="content-stack">
-      <header className="hero">
-        <p className="eyebrow">upbrr</p>
-        <h1>History</h1>
-        <p className="subtitle">
-          Review previously processed releases stored in SQLite and inspect full stored details.
-        </p>
-      </header>
-
-      <section className="panel grid min-h-[560px] gap-3 lg:grid-cols-[minmax(260px,320px)_minmax(0,1fr)]">
-        <aside className="rounded-lg border border-white/10 bg-white/5 p-3">
-          <div className="mb-2">
-            <p className="label">Stored releases</p>
-            <p className="helper">Most recently updated first</p>
-            <label className="mt-2 grid gap-1.5">
-              <span className="label">Search by title</span>
-              <input
-                type="text"
-                value={searchQuery}
-                onChange={(event) => setSearchQuery(event.target.value)}
-                placeholder="Filter titles"
-              />
-            </label>
-          </div>
-
-          {loading ? <p className="muted">Loading history...</p> : null}
-          {!loading && entries.length === 0 ? (
-            <p className="muted">No stored releases found.</p>
-          ) : null}
-          {!loading && entries.length > 0 && filteredEntries.length === 0 ? (
-            <p className="muted">No releases match the current title filter.</p>
-          ) : null}
-
-          <div className="grid max-h-[520px] gap-1.5 overflow-y-auto">
-            {filteredEntries.map((entry) => (
-              <button
-                key={entry.SourcePath}
-                type="button"
-                className={cn(
-                  "grid w-full gap-1 rounded-md border px-3 py-2 text-left transition",
-                  entry.SourcePath === selectedPath
-                    ? "border-[var(--accent-2)] bg-[rgba(53,194,193,0.16)] text-[var(--text)] shadow-[inset_3px_0_0_var(--accent-2),0_0_16px_rgba(53,194,193,0.16)]"
-                    : "border-white/10 bg-black/15 text-[var(--muted)] hover:border-white/20 hover:bg-white/5 hover:text-[var(--text)]",
-                )}
-                onClick={() => setSelectedPath(entry.SourcePath)}
-              >
-                <span
-                  className={cn(
-                    "font-semibold",
-                    entry.SourcePath === selectedPath ? "text-[var(--text)]" : "text-inherit",
-                  )}
-                >
-                  {releaseLabel(entry)}
-                </span>
-                <span className="text-xs text-[var(--muted)]">
-                  {entry.LatestUploadStatus || "Stored"}
-                </span>
-                <span className="text-xs text-[var(--muted)]">
-                  Updated {formatDate(entry.MetadataUpdatedAt)}
-                </span>
-              </button>
-            ))}
-          </div>
-        </aside>
-
-        <div className="overflow-y-auto rounded-lg border border-white/10 bg-white/5 p-3">
-          {detailLoading ? <p className="muted">Loading overview...</p> : null}
-
-          {!detailLoading && !overview ? (
-            <p className="muted">Select a stored release to view details.</p>
-          ) : null}
-
-          {overview ? (
-            <div className="grid gap-3">
-              <div className="flex justify-end">
-                <button
-                  type="button"
-                  className="ghost border-red-400/45 text-[var(--danger)]"
-                  disabled={deleting || detailLoading || !selectedPath}
-                  onClick={() => {
-                    void handleDeleteRelease();
-                  }}
-                >
-                  {deleting ? "Removing..." : "Remove from database"}
-                </button>
-              </div>
-
-              <div className="summary">
-                <div>
-                  <p className="label">Release</p>
-                  <p className="value">
-                    {selectedEntry
-                      ? releaseLabel(selectedEntry)
-                      : releaseLabelFromOverview(overview)}
-                  </p>
-                </div>
-                <div>
-                  <p className="label">Status</p>
-                  <p className="value">{overview.StatusLabel || "Stored"}</p>
-                </div>
-                <div>
-                  <p className="label">Metadata Updated</p>
-                  <p className="value">{formatDate(overview.MetadataUpdatedAt)}</p>
-                </div>
-                <div>
-                  <p className="label">Last Upload</p>
-                  <p className="value">
-                    {formatLastUpload(
-                      overview.LatestUploadStatus,
-                      overview.StatusLabel,
-                      overview.LatestUploadAt,
-                    )}
-                  </p>
-                </div>
-              </div>
-
-              <div className="grid grid-cols-[repeat(auto-fit,minmax(220px,1fr))] gap-2 [&_h3]:mb-2 [&_h3]:mt-0 [&_h3]:text-sm">
-                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Path</h3>
-                  <p className="mono">{overview.SourcePath}</p>
-                </article>
-
-                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5 [&_p]:mb-1 [&_p]:mt-0">
-                  <h3>External IDs</h3>
-                  <p>TMDB: {overview.ExternalIDs?.TMDBID || 0}</p>
-                  <p>IMDb: {overview.ExternalIDs?.IMDBID || 0}</p>
-                  <p>TVDB: {overview.ExternalIDs?.TVDBID || 0}</p>
-                  <p>TVmaze: {overview.ExternalIDs?.TVmazeID || 0}</p>
-                </article>
-
-                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5 [&_p]:mb-1 [&_p]:mt-0">
-                  <h3>Counts</h3>
-                  <p>Tracker metadata: {overview.TrackerMetadata?.length || 0}</p>
-                  <p>
-                    Rule failures:{" "}
-                    {overview.TrackerRuleFailures?.filter(
-                      (failure) => String(failure.Severity || "blocking") !== "warning",
-                    ).length || 0}
-                  </p>
-                  <p>
-                    Rule warnings:{" "}
-                    {overview.TrackerRuleFailures?.filter(
-                      (failure) => String(failure.Severity || "blocking") === "warning",
-                    ).length || 0}
-                  </p>
-                  <p>Screenshots: {overview.Screenshots?.length || 0}</p>
-                  <p>Final selections: {overview.FinalSelections?.length || 0}</p>
-                  <p>Uploaded images: {overview.UploadedImages?.length || 0}</p>
-                  <p>Upload history: {overview.UploadHistory?.length || 0}</p>
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Description Overrides</h3>
-                  {descriptionOverrides.length ? (
-                    <ul className="m-0 grid gap-1 pl-4">
-                      {descriptionOverrides.map((override, index) => {
-                        const groupKey = override.GroupKey?.trim() || "default";
-                        return (
-                          <li key={`${groupKey}-${override.UpdatedAt}-${index}`}>
-                            <strong>{groupKey}</strong>
-                            <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
-                              {override.Description?.trim() || "(empty)"}
-                            </pre>
-                          </li>
-                        );
-                      })}
-                    </ul>
-                  ) : (
-                    <p className="muted">(none)</p>
-                  )}
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Upload History</h3>
-                  {overview.UploadHistory?.length ? (
-                    <ul className="m-0 grid gap-1 pl-4">
-                      {overview.UploadHistory.map((row, index) => (
-                        <li key={`${row.Tracker}-${row.CreatedAt}-${index}`}>
-                          <strong>{row.Tracker || "UNKNOWN"}</strong> — {row.Status || "unknown"} —{" "}
-                          {formatDate(row.CreatedAt)}
-                        </li>
-                      ))}
-                    </ul>
-                  ) : (
-                    <p className="muted">No upload records.</p>
-                  )}
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Tracker Rule Results</h3>
-                  {overview.TrackerRuleFailures?.length ? (
-                    <ul className="m-0 grid gap-1 pl-4">
-                      {overview.TrackerRuleFailures.map((failure, index) => (
-                        <li key={`${failure.Tracker}-${failure.Rule}-${index}`}>
-                          <strong>{failure.Tracker || "UNKNOWN"}</strong> [
-                          {failure.Severity || "blocking"}]: {failure.Rule}{" "}
-                          {failure.Reason ? `— ${failure.Reason}` : ""}
-                        </li>
-                      ))}
-                    </ul>
-                  ) : (
-                    <p className="muted">No tracker rule results stored.</p>
-                  )}
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>External Metadata (raw)</h3>
-                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
-                    {JSON.stringify(overview.ExternalMetadata || {}, null, 2)}
-                  </pre>
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Release Overrides (raw)</h3>
-                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
-                    {JSON.stringify(overview.ReleaseNameOverrides || {}, null, 2)}
-                  </pre>
-                </article>
-
-                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
-                  <h3>Metadata (raw)</h3>
-                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
-                    {JSON.stringify(overview.Metadata || {}, null, 2)}
-                  </pre>
-                </article>
-              </div>
-            </div>
-          ) : null}
-
-          {error ? <p className="error">{error}</p> : null}
-        </div>
-      </section>
-    </div>
-  );
-}
diff --git a/gui/frontend/src/pages/input/index.test.tsx b/gui/frontend/src/pages/input/index.test.tsx
deleted file mode 100644
index fc357103..00000000
--- a/gui/frontend/src/pages/input/index.test.tsx
+++ /dev/null
@@ -1,491 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useState } from "react";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { MetadataPreview, ReleaseNameEditState, ReleaseNameTouchedState } from "../../types";
-import InputPage from "./index";
-
-const preview: MetadataPreview = {
-  SourcePath: "C:\\media\\Example.mkv",
-  TrackerName: "AITHER",
-  ReleaseName: "Example.2026.1080p",
-  Warnings: [],
-  ReleaseNameOverrides: {},
-  ExternalIDs: {
-    TMDBID: 0,
-    IMDBID: 0,
-    TVDBID: 0,
-    TVmazeID: 0,
-    MALID: 0,
-    Category: "TV",
-    SourceTMDB: "",
-    SourceIMDB: "",
-    SourceTVDB: "",
-    SourceTVmaze: "",
-    SourceMAL: "",
-  },
-  ExternalIDCandidates: {
-    TMDB: [],
-    IMDB: [],
-    TMDBAutoSelected: false,
-    IMDBAutoSelected: false,
-  },
-  ExternalIDInfo: [],
-  ExternalPreview: [],
-  TrackerData: [],
-};
-
-const releaseEdits: ReleaseNameEditState = {
-  category: "",
-  type: "",
-  source: "",
-  resolution: "",
-  tag: "",
-  service: "",
-  edition: "",
-  season: "",
-  episode: "",
-  episodeTitle: "",
-  manualYear: "",
-  manualDate: "",
-  useSeasonEpisode: false,
-  noSeason: false,
-  noYear: false,
-  noAKA: false,
-  noTag: false,
-  noEdition: false,
-  noDub: false,
-  noDual: false,
-  dualAudio: false,
-  region: "",
-};
-
-describe("InputPage metadata progress", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("renders tracker data fallback progress updates", () => {
-    render(
-      <InputPage
-        path="C:\media\Example.mkv"
-        handleSourcePathChange={vi.fn()}
-        sourcePathHistory={[]}
-        handleSourcePathHistorySelect={vi.fn()}
-        sourceLookupURL=""
-        setSourceLookupURL={vi.fn()}
-        browseAvailable={false}
-        handleBrowseFile={vi.fn()}
-        handleBrowseFolder={vi.fn()}
-        handleFetch={vi.fn()}
-        handleRefresh={vi.fn()}
-        handleResetMetadata={vi.fn()}
-        loading={false}
-        metadataResetting={false}
-        metadataProgressActive={true}
-        metadataProgressUpdates={[
-          {
-            path: "C:\\media\\Example.mkv",
-            phase: "tracker-data-fallback",
-            message: "Retrying tracker data",
-            status: "running",
-            level: "info",
-            timestamp: "2026-06-29T00:00:00Z",
-          },
-        ]}
-        error=""
-        preview={preview}
-        trackerUploadItems={[]}
-        releasePageTrackerSelection={{}}
-        setReleasePageTrackerSelection={vi.fn()}
-        idEdits={{ tmdb: "", imdb: "", tvdb: "", tvmaze: "", mal: "" }}
-        setIdEdits={vi.fn()}
-        markIDTouched={vi.fn()}
-        releaseEdits={releaseEdits}
-        setReleaseEdits={vi.fn()}
-        markReleaseTouched={vi.fn<(key: keyof ReleaseNameTouchedState) => void>()}
-        idOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        releaseOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        showExternalIDInputUI={false}
-        refreshDisabled={false}
-        selectedProvider=""
-        setSelectedProvider={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        runDebug={false}
-        setRunDebug={vi.fn()}
-        runLogLevel=""
-        setRunLogLevel={vi.fn()}
-        runLogLevelTouched={false}
-        setRunLogLevelTouched={vi.fn()}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    expect(screen.getByText("Retry tracker data")).toBeInTheDocument();
-    expect(screen.getByText("Running")).toBeInTheDocument();
-  });
-});
-
-describe("InputPage external ID preview", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("hides metadata providers when an ID resolved without fetched provider data", () => {
-    render(
-      <InputPage
-        path="C:\\media\\Example.mkv"
-        handleSourcePathChange={vi.fn()}
-        sourcePathHistory={[]}
-        handleSourcePathHistorySelect={vi.fn()}
-        sourceLookupURL=""
-        setSourceLookupURL={vi.fn()}
-        browseAvailable={false}
-        handleBrowseFile={vi.fn()}
-        handleBrowseFolder={vi.fn()}
-        handleFetch={vi.fn()}
-        handleRefresh={vi.fn()}
-        handleResetMetadata={vi.fn()}
-        loading={false}
-        metadataResetting={false}
-        metadataProgressActive={false}
-        metadataProgressUpdates={[]}
-        error=""
-        preview={{
-          ...preview,
-          ExternalIDInfo: [{ Provider: "tmdb", ID: 123, Source: "tracker" }],
-          ExternalPreview: [
-            {
-              Provider: "tmdb",
-              ID: 123,
-              Source: "tracker",
-            } as MetadataPreview["ExternalPreview"][number],
-          ],
-        }}
-        trackerUploadItems={[]}
-        releasePageTrackerSelection={{}}
-        setReleasePageTrackerSelection={vi.fn()}
-        idEdits={{ tmdb: "", imdb: "", tvdb: "", tvmaze: "", mal: "" }}
-        setIdEdits={vi.fn()}
-        markIDTouched={vi.fn()}
-        releaseEdits={releaseEdits}
-        setReleaseEdits={vi.fn()}
-        markReleaseTouched={vi.fn<(key: keyof ReleaseNameTouchedState) => void>()}
-        idOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        releaseOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        showExternalIDInputUI={false}
-        refreshDisabled={false}
-        selectedProvider="tmdb"
-        setSelectedProvider={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        runDebug={false}
-        setRunDebug={vi.fn()}
-        runLogLevel=""
-        setRunLogLevel={vi.fn()}
-        runLogLevelTouched={false}
-        setRunLogLevelTouched={vi.fn()}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    expect(screen.queryByRole("button", { name: /TMDB/i })).not.toBeInTheDocument();
-    expect(screen.getByText("No external metadata details found.")).toBeInTheDocument();
-    expect(screen.queryByText("123")).not.toBeInTheDocument();
-  });
-
-  it("renders rich AniList metadata for selected MAL IDs", () => {
-    render(
-      <InputPage
-        path="C:\\media\\Example.mkv"
-        handleSourcePathChange={vi.fn()}
-        sourcePathHistory={[]}
-        handleSourcePathHistorySelect={vi.fn()}
-        sourceLookupURL=""
-        setSourceLookupURL={vi.fn()}
-        browseAvailable={false}
-        handleBrowseFile={vi.fn()}
-        handleBrowseFolder={vi.fn()}
-        handleFetch={vi.fn()}
-        handleRefresh={vi.fn()}
-        handleResetMetadata={vi.fn()}
-        loading={false}
-        metadataResetting={false}
-        metadataProgressActive={false}
-        metadataProgressUpdates={[]}
-        error=""
-        preview={{
-          ...preview,
-          ExternalIDInfo: [{ Provider: "mal", ID: 5114, Source: "tmdb" }],
-          ExternalPreview: [
-            {
-              Provider: "mal",
-              ID: 5114,
-              Source: "tmdb",
-              Title: "Example Anime",
-              Year: 2026,
-              Overview: "AniList overview",
-              PosterURL: "https://img.example/anilist-cover.jpg",
-              BackdropURL: "https://img.example/anilist-banner.jpg",
-              Category: "TV",
-              OriginalTitle: "Example Anime Romaji",
-              ReleaseDate: "2026-04-01",
-              FirstAirDate: "2026-04-01",
-              LastAirDate: "",
-              OriginalLanguage: "JP",
-              TMDBType: "TV",
-              Runtime: 24,
-              Genres: "Action, Drama",
-              Keywords: "",
-              YouTube: "",
-              IMDBType: "",
-              Rating: 8.2,
-              RatingCount: 12345,
-              RuntimeMinutes: 0,
-              Country: "",
-              Premiered: "",
-              IMDBID: 0,
-              TVDBID: 0,
-              AniList: {
-                AniListID: 1,
-                MALID: 5114,
-                SiteURL: "https://anilist.co/anime/1",
-                TitleRomaji: "Example Anime Romaji",
-                TitleEnglish: "Example Anime",
-                TitleNative: "例アニメ",
-                TitleUserPreferred: "Example Anime",
-                Description: "AniList overview",
-                Format: "TV",
-                Status: "FINISHED",
-                StartDate: "2026-04-01",
-                EndDate: "2026-06-24",
-                Season: "SPRING",
-                SeasonYear: 2026,
-                Episodes: 12,
-                Duration: 24,
-                CountryOfOrigin: "JP",
-                Source: "MANGA",
-                CoverExtraLarge: "https://img.example/anilist-cover.jpg",
-                CoverLarge: "",
-                CoverMedium: "",
-                CoverColor: "#abcdef",
-                BannerImage: "https://img.example/anilist-banner.jpg",
-                Genres: ["Action", "Drama"],
-                Synonyms: ["Example Alt"],
-                AverageScore: 82,
-                MeanScore: 80,
-                Popularity: 12345,
-                Favourites: 678,
-                IsAdult: false,
-                Tags: [
-                  {
-                    Name: "Visible Low Rank",
-                    Rank: 10,
-                    Category: "Theme",
-                    IsAdult: false,
-                    IsGeneralSpoiler: false,
-                    IsMediaSpoiler: false,
-                  },
-                  {
-                    Name: "Visible High Rank",
-                    Rank: 90,
-                    Category: "Theme",
-                    IsAdult: false,
-                    IsGeneralSpoiler: false,
-                    IsMediaSpoiler: false,
-                  },
-                  {
-                    Name: "Hidden Adult",
-                    Rank: 100,
-                    Category: "Theme",
-                    IsAdult: true,
-                    IsGeneralSpoiler: false,
-                    IsMediaSpoiler: false,
-                  },
-                  {
-                    Name: "Hidden Spoiler",
-                    Rank: 95,
-                    Category: "Theme",
-                    IsAdult: false,
-                    IsGeneralSpoiler: true,
-                    IsMediaSpoiler: false,
-                  },
-                ],
-                Studios: [
-                  { ID: 2, Name: "Example Studio", SiteURL: "https://anilist.co/studio/2" },
-                ],
-                Trailer: { ID: "abc123", Site: "youtube", Thumbnail: "" },
-                NextAiringEpisode: { AiringAt: 0, TimeUntilAiring: 0, Episode: 0 },
-                ExternalLinks: [
-                  {
-                    Site: "Official Site",
-                    URL: "https://example.invalid",
-                    Type: "INFO",
-                    Language: "en",
-                  },
-                ],
-              },
-            },
-          ],
-        }}
-        trackerUploadItems={[]}
-        releasePageTrackerSelection={{}}
-        setReleasePageTrackerSelection={vi.fn()}
-        idEdits={{ tmdb: "", imdb: "", tvdb: "", tvmaze: "", mal: "" }}
-        setIdEdits={vi.fn()}
-        markIDTouched={vi.fn()}
-        releaseEdits={releaseEdits}
-        setReleaseEdits={vi.fn()}
-        markReleaseTouched={vi.fn<(key: keyof ReleaseNameTouchedState) => void>()}
-        idOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        releaseOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-        showExternalIDInputUI={false}
-        refreshDisabled={false}
-        selectedProvider="mal"
-        setSelectedProvider={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        runDebug={false}
-        setRunDebug={vi.fn()}
-        runLogLevel=""
-        setRunLogLevel={vi.fn()}
-        runLogLevelTouched={false}
-        setRunLogLevelTouched={vi.fn()}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    expect(screen.getAllByText("Example Anime").length).toBeGreaterThan(0);
-    expect(screen.getByRole("img", { name: "Poster" })).toHaveAttribute(
-      "src",
-      "https://img.example/anilist-cover.jpg",
-    );
-    expect(screen.getByRole("img", { name: "Backdrop" })).toHaveAttribute(
-      "src",
-      "https://img.example/anilist-banner.jpg",
-    );
-    expect(screen.getByText("AniList ID")).toBeInTheDocument();
-    expect(screen.getByText("MAL URL")).toBeInTheDocument();
-    expect(screen.getByText("https://myanimelist.net/anime/5114")).toBeInTheDocument();
-    expect(screen.getByText("AniList URL")).toBeInTheDocument();
-    expect(screen.getByText("https://anilist.co/anime/1")).toBeInTheDocument();
-    expect(screen.getByText("Status")).toBeInTheDocument();
-    expect(screen.getByText("FINISHED")).toBeInTheDocument();
-    expect(screen.getByText("Start date")).toBeInTheDocument();
-    expect(screen.getByText("2026-04-01")).toBeInTheDocument();
-    expect(screen.getByText("End date")).toBeInTheDocument();
-    expect(screen.getByText("2026-06-24")).toBeInTheDocument();
-    expect(screen.getByText("Genres")).toBeInTheDocument();
-    expect(screen.getByText("Action, Drama")).toBeInTheDocument();
-    expect(screen.getByText("Average score")).toBeInTheDocument();
-    expect(screen.getByText("82%")).toBeInTheDocument();
-    expect(screen.getByText("Tags")).toBeInTheDocument();
-    expect(screen.getByText("Visible High Rank (90%), Visible Low Rank (10%)")).toBeInTheDocument();
-    expect(screen.queryByText(/Hidden Adult/)).not.toBeInTheDocument();
-    expect(screen.queryByText(/Hidden Spoiler/)).not.toBeInTheDocument();
-    expect(screen.getByText("Studios")).toBeInTheDocument();
-    expect(screen.getByText("Example Studio")).toBeInTheDocument();
-    expect(screen.getByText("External links")).toBeInTheDocument();
-    expect(screen.getByText("Official Site - https://example.invalid")).toBeInTheDocument();
-    expect(screen.getByText("Cover extra large")).toBeInTheDocument();
-    expect(screen.getByText("Banner URL")).toBeInTheDocument();
-  });
-});
-
-describe("InputPage tracker selection", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("selects and deselects all configured trackers", () => {
-    function Harness() {
-      const [releasePageTrackerSelection, setReleasePageTrackerSelection] = useState<
-        Record<string, boolean>
-      >({
-        AITHER: true,
-        BLU: false,
-      });
-
-      return (
-        <InputPage
-          path="C:\\media\\Example.mkv"
-          handleSourcePathChange={vi.fn()}
-          sourcePathHistory={[]}
-          handleSourcePathHistorySelect={vi.fn()}
-          sourceLookupURL=""
-          setSourceLookupURL={vi.fn()}
-          browseAvailable={false}
-          handleBrowseFile={vi.fn()}
-          handleBrowseFolder={vi.fn()}
-          handleFetch={vi.fn()}
-          handleRefresh={vi.fn()}
-          handleResetMetadata={vi.fn()}
-          loading={false}
-          metadataResetting={false}
-          metadataProgressActive={false}
-          metadataProgressUpdates={[]}
-          error=""
-          preview={preview}
-          trackerUploadItems={[
-            { name: "AITHER", config: {} },
-            { name: "BLU", config: {} },
-          ]}
-          releasePageTrackerSelection={releasePageTrackerSelection}
-          setReleasePageTrackerSelection={setReleasePageTrackerSelection}
-          idEdits={{ tmdb: "", imdb: "", tvdb: "", tvmaze: "", mal: "" }}
-          setIdEdits={vi.fn()}
-          markIDTouched={vi.fn()}
-          releaseEdits={releaseEdits}
-          setReleaseEdits={vi.fn()}
-          markReleaseTouched={vi.fn<(key: keyof ReleaseNameTouchedState) => void>()}
-          idOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-          releaseOverrideState={{ overrides: {}, dirty: false, invalid: false }}
-          showExternalIDInputUI={false}
-          refreshDisabled={false}
-          selectedProvider=""
-          setSelectedProvider={vi.fn()}
-          setLightboxImage={vi.fn()}
-          setLightboxAlt={vi.fn()}
-          runDebug={false}
-          setRunDebug={vi.fn()}
-          runLogLevel=""
-          setRunLogLevel={vi.fn()}
-          runLogLevelTouched={false}
-          setRunLogLevelTouched={vi.fn()}
-          trackerIconSrcByName={{}}
-        />
-      );
-    }
-
-    render(<Harness />);
-
-    expect(screen.getByText("1/2")).toBeInTheDocument();
-    expect(screen.getByRole("checkbox", { name: "AITHER" })).toHaveAttribute(
-      "aria-checked",
-      "true",
-    );
-    expect(screen.getByRole("checkbox", { name: "BLU" })).toHaveAttribute("aria-checked", "false");
-
-    fireEvent.click(screen.getByRole("button", { name: "Select all" }));
-
-    expect(screen.getByText("2/2")).toBeInTheDocument();
-    expect(screen.getByRole("checkbox", { name: "AITHER" })).toHaveAttribute(
-      "aria-checked",
-      "true",
-    );
-    expect(screen.getByRole("checkbox", { name: "BLU" })).toHaveAttribute("aria-checked", "true");
-
-    fireEvent.click(screen.getByRole("button", { name: "Deselect all" }));
-
-    expect(screen.getByText("0/2")).toBeInTheDocument();
-    expect(screen.getByRole("checkbox", { name: "AITHER" })).toHaveAttribute(
-      "aria-checked",
-      "false",
-    );
-    expect(screen.getByRole("checkbox", { name: "BLU" })).toHaveAttribute("aria-checked", "false");
-  });
-});
diff --git a/gui/frontend/src/pages/input/index.tsx b/gui/frontend/src/pages/input/index.tsx
deleted file mode 100644
index 35823d8c..00000000
--- a/gui/frontend/src/pages/input/index.tsx
+++ /dev/null
@@ -1,1902 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useEffect, useMemo, useRef, useState } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import { Button } from "../../components/ui/button";
-import { PillCheckbox } from "../../components/ui/checkbox";
-import { Switch } from "../../components/ui/switch";
-import { TrackerIconImage } from "../../components/ui/tracker-icon";
-import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
-import { trackerIconFor } from "../../hooks/useTrackerIcons";
-import type {
-  DetailBlock,
-  DetailItem,
-  ExternalIDCandidate,
-  ExternalIDInfo,
-  ExternalPreview,
-  IMDBAKA,
-  IMDBEditionDetail,
-  IMDBEpisode,
-  IMDBPerson,
-  IMDBReleaseDate,
-  IMDBSeasonSummary,
-  MetadataPreview,
-  MetadataProgressUpdate,
-  ReleaseNameEditState,
-  ReleaseNameTouchedState,
-  TMDBCompany,
-  TMDBCountry,
-  TMDBNetwork,
-  TrackerUploadItem,
-} from "../../types";
-import type { SourcePathHistoryEntry } from "../../utils/inputHistory";
-import { hasFetchedExternalPreviewData } from "../../utils/externalPreview";
-
-const compactInputClass =
-  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
-
-const formatProvider = (value: string) => value.toUpperCase();
-
-const formatID = (provider: string, id: number) => {
-  if (!id) return "";
-  if (provider === "imdb") return `tt${id.toString().padStart(7, "0")}`;
-  return id.toString();
-};
-
-const providerOrder = ["tmdb", "imdb", "tvdb", "tvmaze", "mal"] as const;
-
-const filterAndOrderExternalIDs = (info: ExternalIDInfo[]) => {
-  const orderIndex = new Map<string, number>(
-    providerOrder.map((provider, index) => [provider, index]),
-  );
-
-  return [...info].sort((left, right) => {
-    const leftIndex = orderIndex.get(left.Provider) ?? providerOrder.length;
-    const rightIndex = orderIndex.get(right.Provider) ?? providerOrder.length;
-    if (leftIndex !== rightIndex) return leftIndex - rightIndex;
-    return left.Provider.localeCompare(right.Provider);
-  });
-};
-
-const normalizeKey = (value: string) => value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
-
-const imdbTypeLabels: Record<string, string> = {
-  movie: "Movie",
-  tvseries: "TV series",
-  tvminiseries: "TV miniseries",
-  tvepisode: "TV episode",
-  tvmovie: "TV movie",
-  short: "Short",
-  video: "Video",
-  videogame: "Video game",
-};
-
-const formatIMDBType = (value: string) => {
-  if (!value) return "";
-  const key = normalizeKey(value);
-  return imdbTypeLabels[key] ?? value;
-};
-
-const formatRuntime = (minutes: number) => {
-  if (!minutes) return "";
-  const hours = Math.floor(minutes / 60);
-  const remainder = minutes % 60;
-  if (!hours) return `${minutes} min`;
-  if (!remainder) return `${hours}h`;
-  return `${hours}h ${remainder}m`;
-};
-
-const formatRating = (rating: number, count: number) => {
-  if (!rating) return "";
-  const score = rating.toFixed(1);
-  if (count) return `${score} (${count.toLocaleString()} votes)`;
-  return score;
-};
-
-const formatNumber = (value: number) => (value ? value.toString() : "");
-
-const formatSimilarity = (value: number) => {
-  if (!value) return "";
-  return `${Math.round(value * 100)}%`;
-};
-
-const formatBoolean = (value: boolean) => (value ? "Yes" : "No");
-
-const tmdbLogoBaseURL = "https://image.tmdb.org/t/p/original/";
-const tmdbLogoSize = 64;
-const malAnimeBaseURL = "https://myanimelist.net/anime/";
-
-const normalizeTMDBLogoURL = (path: string) => {
-  const trimmed = path?.trim();
-  if (!trimmed) return "";
-  if (/^https?:\/\//i.test(trimmed)) return trimmed;
-  return `${tmdbLogoBaseURL}${trimmed}`;
-};
-
-const formatNameList = (values?: string[] | null) => {
-  if (!values || values.length === 0) return "";
-  const cleaned = values.map((item) => item?.trim()).filter(Boolean);
-  if (cleaned.length === 0) return "";
-  return cleaned.join("\n");
-};
-
-const formatCommaList = (values?: string[] | null) => {
-  if (!values || values.length === 0) return "";
-  const cleaned = values.map((item) => item?.trim()).filter(Boolean);
-  if (cleaned.length === 0) return "";
-  return cleaned.join(", ");
-};
-
-// formatAniListScore renders AniList's 0-100 score fields as percentages.
-const formatAniListScore = (value: number) => {
-  if (!value) return "";
-  return `${value}%`;
-};
-
-// formatAniListTags hides adult and spoiler tags, sorts by AniList relevance,
-// and limits the preview so selected MAL details remain scannable.
-const formatAniListTags = (
-  values?:
-    | {
-        Name: string;
-        Rank: number;
-        IsAdult: boolean;
-        IsGeneralSpoiler: boolean;
-        IsMediaSpoiler: boolean;
-      }[]
-    | null,
-) => {
-  if (!values || values.length === 0) return "";
-  const cleaned = values
-    .filter((item) => item?.Name && !item.IsAdult && !item.IsGeneralSpoiler && !item.IsMediaSpoiler)
-    .sort((left, right) => right.Rank - left.Rank)
-    .slice(0, 10)
-    .map((item) => (item.Rank ? `${item.Name} (${item.Rank}%)` : item.Name));
-  if (cleaned.length === 0) return "";
-  return cleaned.join(", ");
-};
-
-// formatAniListStudios renders named studio nodes and skips empty placeholders.
-const formatAniListStudios = (values?: { Name: string }[] | null) => {
-  if (!values || values.length === 0) return "";
-  const cleaned = values.map((item) => item?.Name?.trim()).filter(Boolean);
-  if (cleaned.length === 0) return "";
-  return cleaned.join(", ");
-};
-
-// formatAniListExternalLinks preserves both provider labels and URLs because
-// AniList links may have one without the other.
-const formatAniListExternalLinks = (values?: { Site: string; URL: string }[] | null) => {
-  if (!values || values.length === 0) return "";
-  const lines = values
-    .map((item) => {
-      const site = item?.Site?.trim() ?? "";
-      const url = item?.URL?.trim() ?? "";
-      if (!site && !url) return "";
-      if (!site) return url;
-      if (!url) return site;
-      return `${site} - ${url}`;
-    })
-    .filter(Boolean)
-    .slice(0, 8);
-  if (lines.length === 0) return "";
-  return lines.join("\n");
-};
-
-// formatUnixSeconds renders AniList airing timestamps, which are Unix seconds.
-const formatUnixSeconds = (value: number) => {
-  if (!value) return "";
-  return new Date(value * 1000).toISOString();
-};
-
-type TVDBDisplayMode = "original" | "english";
-
-const isEnglishLanguageValue = (value: string) => {
-  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
-  if (!normalized) return false;
-  if (normalized === "en" || normalized === "eng" || normalized === "english") return true;
-  return normalized.startsWith("en-");
-};
-
-const hasTVDBEnglishDisplay = (preview: ExternalPreview) => {
-  if (preview.Provider !== "tvdb") return false;
-  const tvdb = preview.TVDB;
-  if (!tvdb) return false;
-  const originalLanguage = tvdb.OriginalLanguage || preview.OriginalLanguage;
-  if (isEnglishLanguageValue(originalLanguage)) return false;
-  if (!tvdb.HasEnglish) return false;
-  return Boolean(
-    tvdb.NameEnglish ||
-    tvdb.OverviewEnglish ||
-    tvdb.EpisodeNameEnglish ||
-    tvdb.EpisodeOverviewEnglish,
-  );
-};
-
-const pickTVDBText = (
-  mode: TVDBDisplayMode,
-  originalValue: string,
-  englishValue: string,
-  fallbackValue = "",
-) => {
-  if (mode === "english") {
-    return englishValue || originalValue || fallbackValue;
-  }
-  return originalValue || fallbackValue || englishValue;
-};
-
-const formatPeopleList = (values?: IMDBPerson[] | null) => {
-  if (!values || values.length === 0) return "";
-  const cleaned = values.map((item) => item?.Name?.trim()).filter(Boolean);
-  if (cleaned.length === 0) return "";
-  return cleaned.join("\n");
-};
-
-const formatIMDBAkas = (values?: IMDBAKA[] | null) => {
-  if (!values || values.length === 0) return "";
-  const lines = values
-    .map((item) => {
-      const title = item?.Title?.trim() ?? "";
-      const country = item?.Country?.trim() ?? "";
-      const language = item?.Language?.trim() ?? "";
-      const attrs = item?.Attributes?.filter(Boolean) ?? [];
-      if (!title && !country && !language) return "";
-      let line = title;
-      if (country) {
-        line = line ? `${line} - ${country}` : country;
-      }
-      if (language) {
-        line = line ? `${line} (${language})` : `(${language})`;
-      }
-      if (attrs.length > 0) {
-        line = `${line} [${attrs.join(", ")}]`;
-      }
-      return line;
-    })
-    .filter(Boolean);
-  if (lines.length === 0) return "";
-  return lines.join("\n");
-};
-
-const formatEditionDetails = (values?: Record<string, IMDBEditionDetail> | null) => {
-  if (!values) return "";
-  const entries = Object.entries(values);
-  if (entries.length === 0) return "";
-  entries.sort((left, right) => Number(left[0]) - Number(right[0]));
-  const lines = entries.map(([, detail]) => {
-    const name = detail.DisplayName?.trim() || "";
-    const minutes = detail.Minutes || 0;
-    const attrs = detail.Attributes?.filter(Boolean) ?? [];
-    let line = name;
-    if (minutes) {
-      line = line ? `${line} (${minutes} min)` : `${minutes} min`;
-    }
-    if (attrs.length > 0) {
-      line = `${line} [${attrs.join(", ")}]`;
-    }
-    return line;
-  });
-  const cleaned = lines.filter(Boolean);
-  if (cleaned.length === 0) return "";
-  return cleaned.join("\n");
-};
-
-const formatReleaseDate = (value?: IMDBReleaseDate) => {
-  if (!value || !value.Year) return "";
-  const month = value.Month ? String(value.Month).padStart(2, "0") : "";
-  const day = value.Day ? String(value.Day).padStart(2, "0") : "";
-  if (month && day) return `${value.Year}-${month}-${day}`;
-  if (month) return `${value.Year}-${month}`;
-  return value.Year.toString();
-};
-
-const formatEpisodes = (values?: IMDBEpisode[] | null) => {
-  if (!values || values.length === 0) return "";
-  const lines = values
-    .map((item) => {
-      const season = item.Season ? `S${item.Season}` : "";
-      const episode = item.EpisodeText ? `E${item.EpisodeText}` : "";
-      const header = `${season}${episode}`.trim();
-      const title = item.Title?.trim() ?? "";
-      const date = formatReleaseDate(item.ReleaseDate);
-      let line = [header, title].filter(Boolean).join(" - ");
-      if (date) {
-        line = line ? `${line} (${date})` : date;
-      }
-      return line;
-    })
-    .filter(Boolean);
-  if (lines.length === 0) return "";
-  return lines.join("\n");
-};
-
-const formatSeasonsSummary = (values?: IMDBSeasonSummary[] | null) => {
-  if (!values || values.length === 0) return "";
-  const lines = values
-    .map((item) => {
-      const year = item.YearRange || formatNumber(item.Year);
-      if (!year) return "";
-      return `Season ${item.Season}: ${year}`;
-    })
-    .filter(Boolean);
-  if (lines.length === 0) return "";
-  return lines.join("\n");
-};
-
-const formatTMDBCountries = (values?: TMDBCountry[] | null) => {
-  if (!values || values.length === 0) return "";
-  const lines = values.map((item) => item?.Name?.trim()).filter(Boolean);
-  if (lines.length === 0) return "";
-  return lines.join("\n");
-};
-
-const buildCompanyBlocks = (values?: TMDBCompany[] | null) => {
-  if (!values || values.length === 0) return [];
-  const blocks: DetailBlock[] = [];
-  for (const item of values) {
-    const name = item?.Name?.trim() ?? "";
-    const country = item?.OriginCountry?.trim() ?? "";
-    const logoURL = normalizeTMDBLogoURL(item?.LogoPath ?? "");
-    let text = name;
-    if (country) {
-      text = text ? `${text} - ${country}` : country;
-    }
-    if (!text && !logoURL) {
-      continue;
-    }
-    if (logoURL) {
-      blocks.push({ imageUrl: logoURL, imageAlt: name || "TMDb logo" });
-    }
-    if (text) {
-      blocks.push({ text });
-    }
-  }
-  return blocks;
-};
-
-const buildNetworkBlocks = (values?: TMDBNetwork[] | null) => {
-  if (!values || values.length === 0) return [];
-  const blocks: DetailBlock[] = [];
-  for (const item of values) {
-    const name = item?.Name?.trim() ?? "";
-    const country = item?.OriginCountry?.trim() ?? "";
-    const logoURL = normalizeTMDBLogoURL(item?.LogoPath ?? "");
-    let text = name;
-    if (country) {
-      text = text ? `${text} - ${country}` : country;
-    }
-    if (!text && !logoURL) {
-      continue;
-    }
-    if (logoURL) {
-      blocks.push({ imageUrl: logoURL, imageAlt: name || "TMDb logo" });
-    }
-    if (text) {
-      blocks.push({ text });
-    }
-  }
-  return blocks;
-};
-
-const buildPreviewDetails = (
-  preview: ExternalPreview,
-  tvdbDisplayMode: TVDBDisplayMode,
-): DetailItem[] => {
-  const baseID: DetailItem = {
-    label: `${formatProvider(preview.Provider)} ID`,
-    value: formatID(preview.Provider, preview.ID),
-    mono: true,
-  };
-
-  if (preview.Provider === "imdb") {
-    const imdb = preview.IMDB;
-    return [
-      baseID,
-      { label: "IMDb URL", value: imdb?.IMDbURL ?? "", mono: true },
-      { label: "AKA", value: imdb?.AKA ?? "" },
-      { label: "Type", value: formatIMDBType(imdb?.Type ?? preview.IMDBType) },
-      { label: "Year", value: formatNumber(imdb?.Year ?? preview.Year) },
-      { label: "End year", value: formatNumber(imdb?.EndYear ?? 0) },
-      { label: "TV year", value: formatNumber(imdb?.TVYear ?? 0) },
-      { label: "Original language", value: imdb?.OriginalLanguage ?? "" },
-      { label: "Country", value: imdb?.Country ?? preview.Country },
-      { label: "Country list", value: imdb?.CountryList ?? "" },
-      {
-        label: "Rating",
-        value: formatRating(
-          imdb?.Rating ?? preview.Rating,
-          imdb?.RatingCount ?? preview.RatingCount,
-        ),
-      },
-      { label: "Rating text", value: imdb?.RatingText ?? "" },
-      { label: "Rating count", value: formatNumber(imdb?.RatingCount ?? preview.RatingCount) },
-      { label: "Runtime", value: formatRuntime(imdb?.RuntimeMinutes ?? preview.RuntimeMinutes) },
-      { label: "Runtime text", value: imdb?.RuntimeText ?? "" },
-      { label: "Editions", value: formatCommaList(imdb?.Editions) },
-      { label: "Edition details", value: formatEditionDetails(imdb?.EditionDetails) },
-      { label: "Genres", value: imdb?.Genres ?? preview.Genres },
-      { label: "Sound mixes", value: formatNameList(imdb?.SoundMixes) },
-      { label: "Directors", value: formatPeopleList(imdb?.Directors) },
-      { label: "Creators", value: formatPeopleList(imdb?.Creators) },
-      { label: "Writers", value: formatPeopleList(imdb?.Writers) },
-      { label: "Stars", value: formatPeopleList(imdb?.Stars) },
-      { label: "AKA entries", value: formatIMDBAkas(imdb?.Akas) },
-      { label: "Season summary", value: formatSeasonsSummary(imdb?.SeasonsSummary) },
-      { label: "Episodes", value: formatEpisodes(imdb?.Episodes) },
-      { label: "Cover URL", value: imdb?.Cover ?? preview.PosterURL, mono: true },
-    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-  }
-
-  if (preview.Provider === "tmdb") {
-    const tmdb = preview.TMDB;
-    return [
-      baseID,
-      { label: "IMDB ID", value: formatID("imdb", tmdb?.IMDBID ?? preview.IMDBID), mono: true },
-      { label: "TVDB ID", value: formatNumber(tmdb?.TVDBID ?? preview.TVDBID), mono: true },
-      { label: "Original title", value: tmdb?.OriginalTitle ?? preview.OriginalTitle },
-      { label: "Type", value: tmdb?.TMDBType ?? preview.TMDBType },
-      { label: "Category", value: tmdb?.Category ?? preview.Category },
-      { label: "Year", value: formatNumber(tmdb?.Year ?? preview.Year) },
-      { label: "Release date", value: tmdb?.ReleaseDate ?? preview.ReleaseDate },
-      { label: "First air date", value: tmdb?.FirstAirDate ?? preview.FirstAirDate },
-      { label: "Last air date", value: tmdb?.LastAirDate ?? preview.LastAirDate },
-      { label: "Runtime", value: formatRuntime(tmdb?.Runtime ?? preview.Runtime) },
-      { label: "Genres", value: tmdb?.Genres ?? preview.Genres },
-      { label: "Genre IDs", value: tmdb?.GenreIDs ?? "" },
-      { label: "Keywords", value: tmdb?.Keywords ?? preview.Keywords },
-      { label: "YouTube", value: tmdb?.YouTube ?? preview.YouTube },
-      { label: "Certification", value: tmdb?.Certification ?? "" },
-      { label: "Creators", value: formatNameList(tmdb?.Creators) },
-      { label: "Directors", value: formatNameList(tmdb?.Directors) },
-      { label: "Cast", value: formatNameList(tmdb?.Cast) },
-      { label: "Origin countries", value: formatCommaList(tmdb?.OriginCountry) },
-      {
-        label: "Production companies",
-        value: "",
-        blocks: buildCompanyBlocks(tmdb?.ProductionCompanies),
-      },
-      { label: "Production countries", value: formatTMDBCountries(tmdb?.ProductionCountries) },
-      {
-        label: "Networks",
-        value: "",
-        blocks: buildNetworkBlocks(tmdb?.Networks),
-      },
-      { label: "Poster URL", value: tmdb?.Poster ?? preview.PosterURL, mono: true },
-      { label: "Poster path", value: tmdb?.TMDBPosterPath ?? "", mono: true },
-      { label: "Backdrop URL", value: tmdb?.Backdrop ?? preview.BackdropURL, mono: true },
-      { label: "Logo URL", value: tmdb?.Logo ?? "", mono: true },
-      { label: "Logo name", value: tmdb?.TMDBLogo ?? "" },
-      { label: "Original language", value: tmdb?.OriginalLanguage ?? preview.OriginalLanguage },
-      { label: "Anime", value: tmdb ? formatBoolean(tmdb.Anime) : "" },
-      { label: "MAL ID", value: formatNumber(tmdb?.MALID ?? 0), mono: true },
-      { label: "Demographic", value: tmdb?.Demographic ?? "" },
-      { label: "Retrieved AKA", value: tmdb?.RetrievedAKA ?? "" },
-      { label: "IMDb mismatch", value: tmdb ? formatBoolean(tmdb.IMDbMismatch) : "" },
-      { label: "Mismatched IMDb ID", value: formatNumber(tmdb?.MismatchedIMDbID ?? 0), mono: true },
-    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-  }
-
-  if (preview.Provider === "tvdb") {
-    const tvdb = preview.TVDB;
-    const displayName = pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.Name ?? preview.Title,
-      tvdb?.NameEnglish ?? "",
-      preview.Title,
-    );
-    const displayOverview = pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.Overview ?? preview.Overview,
-      tvdb?.OverviewEnglish ?? "",
-      preview.Overview,
-    );
-    const displayEpisodeName = pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.EpisodeName ?? "",
-      tvdb?.EpisodeNameEnglish ?? "",
-    );
-    const displayEpisodeOverview = pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.EpisodeOverview ?? "",
-      tvdb?.EpisodeOverviewEnglish ?? "",
-    );
-    const seasonNumber = tvdb?.EpisodeSeason ?? 0;
-    const episodeNumber = tvdb?.EpisodeNumber ?? 0;
-    const episodeTag =
-      seasonNumber > 0 && episodeNumber > 0
-        ? `S${String(seasonNumber).padStart(2, "0")}E${String(episodeNumber).padStart(2, "0")}`
-        : "";
-    return [
-      baseID,
-      { label: "Name", value: displayName },
-      { label: "Type", value: tvdb?.Type ?? preview.TMDBType },
-      { label: "Status", value: tvdb?.Status ?? "" },
-      { label: "Year", value: formatNumber(tvdb?.Year ?? preview.Year) },
-      { label: "First aired", value: tvdb?.FirstAired ?? preview.FirstAirDate },
-      { label: "Genres", value: tvdb?.Genres ?? preview.Genres },
-      { label: "Network", value: tvdb?.Network ?? "" },
-      { label: "Origin country", value: tvdb?.OriginalCountry ?? preview.Country },
-      { label: "Original language", value: tvdb?.OriginalLanguage ?? preview.OriginalLanguage },
-      { label: "Aliases", value: formatCommaList(tvdb?.Aliases) },
-      { label: "Episode", value: episodeTag },
-      { label: "Episode name", value: displayEpisodeName },
-      { label: "Episode aired", value: tvdb?.EpisodeAired ?? "" },
-      { label: "Episode overview", value: displayEpisodeOverview },
-      { label: "Overview", value: displayOverview },
-      { label: "Poster URL", value: tvdb?.Poster ?? preview.PosterURL, mono: true },
-    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-  }
-
-  if (preview.Provider === "tvmaze") {
-    const tvmaze = preview.TVmaze;
-    const network = tvmaze?.Network ?? "";
-    const webChannel = tvmaze?.WebChannel ?? "";
-    const networkText =
-      network && tvmaze?.NetworkCountry ? `${network} - ${tvmaze.NetworkCountry}` : network;
-    const webChannelText =
-      webChannel && tvmaze?.WebCountry ? `${webChannel} - ${tvmaze.WebCountry}` : webChannel;
-    return [
-      baseID,
-      { label: "IMDB ID", value: formatID("imdb", tvmaze?.IMDBID ?? preview.IMDBID), mono: true },
-      { label: "TVDB ID", value: formatNumber(tvmaze?.TVDBID ?? preview.TVDBID), mono: true },
-      { label: "Name", value: tvmaze?.Name ?? preview.Title },
-      { label: "Type", value: tvmaze?.Type ?? preview.TMDBType },
-      { label: "Status", value: tvmaze?.Status ?? "" },
-      { label: "Year", value: formatNumber(preview.Year) },
-      { label: "Premiered", value: tvmaze?.Premiered ?? preview.Premiered },
-      { label: "Ended", value: tvmaze?.Ended ?? "" },
-      { label: "Genres", value: tvmaze?.Genres ?? preview.Genres },
-      { label: "Language", value: tvmaze?.Language ?? preview.OriginalLanguage },
-      { label: "Country", value: tvmaze?.Country ?? preview.Country },
-      { label: "Runtime", value: formatRuntime(tvmaze?.Runtime ?? preview.Runtime) },
-      { label: "Average runtime", value: formatRuntime(tvmaze?.AverageRuntime ?? 0) },
-      {
-        label: "Rating",
-        value: formatRating(
-          tvmaze?.Rating ?? preview.Rating,
-          tvmaze?.Weight ?? preview.RatingCount,
-        ),
-      },
-      { label: "Score", value: formatNumber(tvmaze?.Weight ?? preview.RatingCount) },
-      { label: "Network", value: networkText },
-      { label: "Web channel", value: webChannelText },
-      { label: "Official site", value: tvmaze?.OfficialSite ?? "", mono: true },
-      { label: "Overview", value: tvmaze?.Summary ?? preview.Overview },
-      { label: "Poster URL", value: tvmaze?.Poster ?? preview.PosterURL, mono: true },
-      { label: "Poster medium", value: tvmaze?.PosterMedium ?? "", mono: true },
-      { label: "Backdrop URL", value: tvmaze?.Backdrop ?? preview.BackdropURL, mono: true },
-      { label: "Backdrop medium", value: tvmaze?.BackdropMedium ?? "", mono: true },
-      { label: "Network logo", value: tvmaze?.NetworkLogo ?? "", mono: true },
-      { label: "Web logo", value: tvmaze?.WebLogo ?? "", mono: true },
-    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-  }
-
-  if (preview.Provider === "mal") {
-    const anilist = preview.AniList;
-    const anilistURL =
-      anilist?.SiteURL ||
-      (anilist?.AniListID ? `https://anilist.co/anime/${anilist.AniListID}` : "");
-    return [
-      baseID,
-      { label: "AniList ID", value: formatNumber(anilist?.AniListID ?? 0), mono: true },
-      { label: "MAL URL", value: `${malAnimeBaseURL}${preview.ID}`, mono: true },
-      { label: "AniList URL", value: anilistURL, mono: true },
-      { label: "English title", value: anilist?.TitleEnglish ?? "" },
-      { label: "Romaji title", value: anilist?.TitleRomaji ?? preview.OriginalTitle },
-      { label: "Native title", value: anilist?.TitleNative ?? "" },
-      { label: "User preferred title", value: anilist?.TitleUserPreferred ?? "" },
-      { label: "Format", value: anilist?.Format ?? preview.Category },
-      { label: "Status", value: anilist?.Status ?? "" },
-      { label: "Season", value: anilist?.Season ?? "" },
-      { label: "Season year", value: formatNumber(anilist?.SeasonYear ?? preview.Year) },
-      { label: "Start date", value: anilist?.StartDate ?? preview.FirstAirDate },
-      { label: "End date", value: anilist?.EndDate ?? preview.LastAirDate },
-      { label: "Episodes", value: formatNumber(anilist?.Episodes ?? 0) },
-      { label: "Duration", value: formatRuntime(anilist?.Duration ?? preview.Runtime) },
-      { label: "Country of origin", value: anilist?.CountryOfOrigin ?? preview.OriginalLanguage },
-      { label: "Source", value: anilist?.Source ?? "" },
-      { label: "Genres", value: formatCommaList(anilist?.Genres) || preview.Genres },
-      { label: "Synonyms", value: formatCommaList(anilist?.Synonyms) },
-      { label: "Average score", value: formatAniListScore(anilist?.AverageScore ?? 0) },
-      { label: "Mean score", value: formatAniListScore(anilist?.MeanScore ?? 0) },
-      { label: "Popularity", value: formatNumber(anilist?.Popularity ?? preview.RatingCount) },
-      { label: "Favourites", value: formatNumber(anilist?.Favourites ?? 0) },
-      { label: "Tags", value: formatAniListTags(anilist?.Tags) },
-      { label: "Studios", value: formatAniListStudios(anilist?.Studios) },
-      {
-        label: "Trailer",
-        value: anilist?.Trailer?.ID ? `${anilist.Trailer.Site}: ${anilist.Trailer.ID}` : "",
-      },
-      {
-        label: "Next airing",
-        value: anilist?.NextAiringEpisode?.Episode
-          ? `Episode ${anilist.NextAiringEpisode.Episode} - ${formatUnixSeconds(anilist.NextAiringEpisode.AiringAt)}`
-          : "",
-      },
-      {
-        label: "External links",
-        value: formatAniListExternalLinks(anilist?.ExternalLinks),
-        mono: true,
-      },
-      { label: "Cover extra large", value: anilist?.CoverExtraLarge ?? "", mono: true },
-      { label: "Cover large", value: anilist?.CoverLarge ?? preview.PosterURL, mono: true },
-      { label: "Cover medium", value: anilist?.CoverMedium ?? "", mono: true },
-      { label: "Cover color", value: anilist?.CoverColor ?? "", mono: true },
-      { label: "Banner URL", value: anilist?.BannerImage ?? preview.BackdropURL, mono: true },
-      { label: "Adult", value: anilist ? formatBoolean(anilist.IsAdult) : "" },
-      { label: "Resolver source", value: preview.Source },
-    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-  }
-
-  return [baseID].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
-};
-
-const renderDetailValue = (item: DetailItem) => {
-  if (item.blocks && item.blocks.length > 0) {
-    return (
-      <div>
-        {item.blocks.map((block, index) => (
-          <div key={`${item.label}-${index}`} style={{ marginBottom: "0.35rem" }}>
-            {block.imageUrl ? (
-              <img
-                src={block.imageUrl}
-                alt={block.imageAlt || "Logo"}
-                loading="lazy"
-                style={{
-                  width: tmdbLogoSize,
-                  height: tmdbLogoSize,
-                  objectFit: "contain",
-                  display: "block",
-                }}
-              />
-            ) : null}
-            {block.text ? <span>{block.text}</span> : null}
-          </div>
-        ))}
-      </div>
-    );
-  }
-  const lines = item.value.split("\n");
-  if (lines.length === 1) return item.value;
-  return (
-    <>
-      {lines.map((line, index) => (
-        <span key={`${item.label}-${index}`}>
-          {line}
-          {index < lines.length - 1 ? <br /> : null}
-        </span>
-      ))}
-    </>
-  );
-};
-
-const PreviewDetailsList = ({ items }: { items: DetailItem[] }) => {
-  if (items.length === 0) return null;
-  return (
-    <div className="preview-details">
-      {items.map((item) => (
-        <div className="preview-detail" key={item.label}>
-          <p className="label">{item.label}</p>
-          <p className={`value preview-detail__value ${item.mono ? "mono" : ""}`}>
-            {renderDetailValue(item)}
-          </p>
-        </div>
-      ))}
-    </div>
-  );
-};
-
-type OverrideState<T> = {
-  overrides: T;
-  dirty: boolean;
-  invalid: boolean;
-};
-
-type IDEdits = {
-  tmdb: string;
-  imdb: string;
-  tvdb: string;
-  tvmaze: string;
-  mal: string;
-};
-
-type Props = Readonly<{
-  path: string;
-  handleSourcePathChange: (path: string) => void;
-  sourcePathHistory: SourcePathHistoryEntry[];
-  handleSourcePathHistorySelect: (entry: SourcePathHistoryEntry) => void;
-  sourceLookupURL: string;
-  setSourceLookupURL: Dispatch<SetStateAction<string>>;
-  browseAvailable: boolean;
-  handleBrowseFile: () => void;
-  handleBrowseFolder: () => void;
-  handleFetch: () => void;
-  handleRefresh: () => void;
-  handleResetMetadata: () => void;
-  loading: boolean;
-  metadataResetting: boolean;
-  metadataProgressActive: boolean;
-  metadataProgressUpdates: MetadataProgressUpdate[];
-  error: string;
-  preview: MetadataPreview;
-  trackerUploadItems: TrackerUploadItem[];
-  releasePageTrackerSelection: Record<string, boolean>;
-  setReleasePageTrackerSelection: Dispatch<SetStateAction<Record<string, boolean>>>;
-  idEdits: IDEdits;
-  setIdEdits: Dispatch<SetStateAction<IDEdits>>;
-  markIDTouched: (key: keyof IDEdits) => void;
-  releaseEdits: ReleaseNameEditState;
-  setReleaseEdits: Dispatch<SetStateAction<ReleaseNameEditState>>;
-  markReleaseTouched: (key: keyof ReleaseNameTouchedState) => void;
-  idOverrideState: OverrideState<Record<string, unknown>>;
-  releaseOverrideState: OverrideState<Record<string, unknown>>;
-  showExternalIDInputUI: boolean;
-  refreshDisabled: boolean;
-  selectedProvider: string;
-  setSelectedProvider: Dispatch<SetStateAction<string>>;
-  setLightboxImage: Dispatch<SetStateAction<string>>;
-  setLightboxAlt: Dispatch<SetStateAction<string>>;
-  runDebug: boolean;
-  setRunDebug: Dispatch<SetStateAction<boolean>>;
-  runLogLevel: string;
-  setRunLogLevel: Dispatch<SetStateAction<string>>;
-  runLogLevelTouched: boolean;
-  setRunLogLevelTouched: Dispatch<SetStateAction<boolean>>;
-  useFavicons?: boolean;
-  faviconOnly?: boolean;
-  trackerIconSrcByName: TrackerIconCache;
-}>;
-
-export default function InputPage(props: Props) {
-  const {
-    path,
-    handleSourcePathChange,
-    sourcePathHistory,
-    handleSourcePathHistorySelect,
-    sourceLookupURL,
-    setSourceLookupURL,
-    browseAvailable,
-    handleBrowseFile,
-    handleBrowseFolder,
-    handleFetch,
-    handleRefresh,
-    handleResetMetadata,
-    loading,
-    metadataResetting,
-    metadataProgressActive,
-    metadataProgressUpdates,
-    error,
-    preview,
-    trackerUploadItems,
-    releasePageTrackerSelection,
-    setReleasePageTrackerSelection,
-    idEdits,
-    setIdEdits,
-    markIDTouched,
-    releaseEdits,
-    setReleaseEdits,
-    markReleaseTouched,
-    idOverrideState,
-    releaseOverrideState,
-    showExternalIDInputUI,
-    refreshDisabled,
-    selectedProvider,
-    setSelectedProvider,
-    setLightboxImage,
-    setLightboxAlt,
-    runDebug,
-    setRunDebug,
-    runLogLevel,
-    setRunLogLevel,
-    runLogLevelTouched,
-    setRunLogLevelTouched,
-    useFavicons = true,
-    faviconOnly = false,
-    trackerIconSrcByName,
-  } = props;
-
-  const [sourcePathHistoryOpen, setSourcePathHistoryOpen] = useState(false);
-  const sourcePathHistoryRef = useRef<HTMLDivElement | null>(null);
-  const sourcePathHistoryAvailable = sourcePathHistory.length > 0;
-
-  useEffect(() => {
-    if (!sourcePathHistoryOpen) {
-      return;
-    }
-    const handlePointerDown = (event: PointerEvent) => {
-      const target = event.target;
-      if (!(target instanceof Node) || sourcePathHistoryRef.current?.contains(target)) {
-        return;
-      }
-      setSourcePathHistoryOpen(false);
-    };
-    document.addEventListener("pointerdown", handlePointerDown);
-    return () => document.removeEventListener("pointerdown", handlePointerDown);
-  }, [sourcePathHistoryOpen]);
-
-  useEffect(() => {
-    if (!sourcePathHistoryAvailable) {
-      setSourcePathHistoryOpen(false);
-    }
-  }, [sourcePathHistoryAvailable]);
-
-  const openSourcePathHistory = () => {
-    if (sourcePathHistoryAvailable) {
-      setSourcePathHistoryOpen(true);
-    }
-  };
-
-  const selectSourcePathHistory = (entry: SourcePathHistoryEntry) => {
-    setSourcePathHistoryOpen(false);
-    handleSourcePathHistorySelect(entry);
-  };
-
-  const hasPreview =
-    preview.ReleaseName || (preview.ExternalIDInfo && preview.ExternalIDInfo.length > 0);
-  const isTVEpisodePreview = (preview.ExternalIDs?.Category || "").trim().toUpperCase() === "TV";
-  const hasResolvedPrimaryExternalID =
-    (preview.ExternalIDs?.TMDBID || 0) > 0 || (preview.ExternalIDs?.IMDBID || 0) > 0;
-  const selectedTrackerCount = useMemo(
-    () =>
-      trackerUploadItems.reduce(
-        (count, tracker) => count + (releasePageTrackerSelection[tracker.name] ? 1 : 0),
-        0,
-      ),
-    [trackerUploadItems, releasePageTrackerSelection],
-  );
-  const allTrackersSelected =
-    trackerUploadItems.length > 0 && selectedTrackerCount === trackerUploadItems.length;
-
-  /**
-   * Applies one selection state to every currently configured input tracker.
-   *
-   * Existing selection entries for trackers outside the visible config list are left untouched.
-   */
-  const setAllTrackersSelected = (selected: boolean) => {
-    setReleasePageTrackerSelection((prev) => {
-      const next = { ...prev };
-      trackerUploadItems.forEach((tracker) => {
-        next[tracker.name] = selected;
-      });
-      return next;
-    });
-  };
-
-  const discHint = useMemo(() => {
-    const trimmed = path.trim();
-    if (!trimmed) return "";
-    const normalized = trimmed.replaceAll("\\", "/");
-    const upper = normalized.toUpperCase();
-    if (/(^|\/)BDMV(\/|$)/.test(upper)) {
-      return "Bluray disc folder detected (BDMV).";
-    }
-    if (/(^|\/)VIDEO_TS(\/|$)/.test(upper)) {
-      return "DVD disc folder detected (VIDEO_TS).";
-    }
-    return "";
-  }, [path]);
-
-  const orderedExternalIDs = useMemo(() => {
-    const fetchedProviders = new Set(
-      (preview.ExternalPreview || [])
-        .filter(hasFetchedExternalPreviewData)
-        .map((item) => item.Provider),
-    );
-    return filterAndOrderExternalIDs(preview.ExternalIDInfo || []).filter((item) =>
-      fetchedProviders.has(item.Provider),
-    );
-  }, [preview.ExternalIDInfo, preview.ExternalPreview]);
-
-  const tmdbCandidates = useMemo(
-    () => preview.ExternalIDCandidates?.TMDB || [],
-    [preview.ExternalIDCandidates?.TMDB],
-  );
-  const imdbCandidates = useMemo(
-    () => preview.ExternalIDCandidates?.IMDB || [],
-    [preview.ExternalIDCandidates?.IMDB],
-  );
-  const [candidatePreview, setCandidatePreview] = useState<{
-    provider: "tmdb" | "imdb";
-    candidate: ExternalIDCandidate;
-  } | null>(null);
-
-  const selectedCandidateID = (provider: "tmdb" | "imdb") => {
-    if (provider === "tmdb") {
-      const value = idEdits.tmdb.trim();
-      if (!value || !/^\d+$/.test(value)) return 0;
-      return Number(value);
-    }
-    const normalized = idEdits.imdb.trim().replace(/^tt/i, "");
-    if (!normalized || !/^\d+$/.test(normalized)) return 0;
-    return Number(normalized);
-  };
-
-  const applyCandidateID = (provider: "tmdb" | "imdb", candidate: ExternalIDCandidate) => {
-    if (!candidate?.ID) return;
-    const currentSelectedID = selectedCandidateID(provider);
-    if (currentSelectedID === candidate.ID) {
-      if (provider === "tmdb") {
-        setIdEdits((prev) => ({ ...prev, tmdb: "" }));
-        markIDTouched("tmdb");
-      } else {
-        setIdEdits((prev) => ({ ...prev, imdb: "" }));
-        markIDTouched("imdb");
-      }
-      if (
-        candidatePreview?.provider === provider &&
-        candidatePreview.candidate.ID === candidate.ID
-      ) {
-        setCandidatePreview(null);
-      }
-      return;
-    }
-    setCandidatePreview({ provider, candidate });
-    if (provider === "tmdb") {
-      setIdEdits((prev) => ({ ...prev, tmdb: candidate.ID.toString() }));
-      markIDTouched("tmdb");
-      return;
-    }
-    setIdEdits((prev) => ({ ...prev, imdb: `tt${candidate.ID.toString().padStart(7, "0")}` }));
-    markIDTouched("imdb");
-  };
-
-  useEffect(() => {
-    if (!showExternalIDInputUI) {
-      setCandidatePreview(null);
-    }
-  }, [showExternalIDInputUI]);
-
-  useEffect(() => {
-    if (!candidatePreview) return;
-    const providerCandidates =
-      candidatePreview.provider === "tmdb" ? tmdbCandidates : imdbCandidates;
-    const stillExists = providerCandidates.some(
-      (candidate) => candidate.ID === candidatePreview.candidate.ID,
-    );
-    if (!stillExists) {
-      setCandidatePreview(null);
-    }
-  }, [candidatePreview, tmdbCandidates, imdbCandidates]);
-
-  const selectedPreview = useMemo(() => {
-    if (!selectedProvider) return null;
-    return (
-      (preview.ExternalPreview || []).find(
-        (item) => item.Provider === selectedProvider && hasFetchedExternalPreviewData(item),
-      ) || null
-    );
-  }, [preview.ExternalPreview, selectedProvider]);
-
-  const [tvdbDisplayMode, setTVDBDisplayMode] = useState<TVDBDisplayMode>("original");
-
-  const tvdbToggleEnabled = useMemo(() => {
-    if (!selectedPreview) return false;
-    return hasTVDBEnglishDisplay(selectedPreview);
-  }, [selectedPreview]);
-
-  useEffect(() => {
-    if (selectedPreview?.Provider !== "tvdb") {
-      setTVDBDisplayMode("original");
-      return;
-    }
-    setTVDBDisplayMode(tvdbToggleEnabled ? "english" : "original");
-  }, [selectedPreview, tvdbToggleEnabled]);
-
-  const selectedPreviewTitle = useMemo(() => {
-    if (!selectedPreview) return "";
-    if (selectedPreview.Provider !== "tvdb") return selectedPreview.Title;
-    const tvdb = selectedPreview.TVDB;
-    return pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.Name ?? selectedPreview.Title,
-      tvdb?.NameEnglish ?? "",
-      selectedPreview.Title,
-    );
-  }, [selectedPreview, tvdbDisplayMode]);
-
-  const selectedPreviewOverview = useMemo(() => {
-    if (!selectedPreview) return "";
-    if (selectedPreview.Provider !== "tvdb") return selectedPreview.Overview;
-    const tvdb = selectedPreview.TVDB;
-    return pickTVDBText(
-      tvdbDisplayMode,
-      tvdb?.Overview ?? selectedPreview.Overview,
-      tvdb?.OverviewEnglish ?? "",
-      selectedPreview.Overview,
-    );
-  }, [selectedPreview, tvdbDisplayMode]);
-
-  const previewDetails = selectedPreview
-    ? buildPreviewDetails(selectedPreview, tvdbDisplayMode)
-    : [];
-
-  // Keep this aligned with the backend FetchMetadataPreview phase emissions so
-  // progress updates advance without skipping backend work, including fallback retries.
-  const metadataPhaseOrder = [
-    { key: "prepare", label: "Prepare metadata" },
-    { key: "tracker-data", label: "Get tracker data" },
-    { key: "tracker-data-fallback", label: "Retry tracker data" },
-    { key: "mediainfo-ids", label: "Apply MediaInfo IDs" },
-    { key: "arr", label: "Apply Sonarr/Radarr data" },
-    { key: "external-ids", label: "Resolve external IDs" },
-    { key: "media-details", label: "Apply media details" },
-    { key: "tracker-claims", label: "Check tracker claims" },
-    { key: "complete", label: "Complete" },
-  ];
-
-  const latestMetadataPhase = useMemo(() => {
-    const next = new Map<string, MetadataProgressUpdate>();
-    metadataProgressUpdates.forEach((entry) => {
-      if (!entry?.phase) {
-        return;
-      }
-      next.set(entry.phase, entry);
-    });
-    return next;
-  }, [metadataProgressUpdates]);
-
-  const metadataStatusLabel = (status: string) => {
-    if (status === "running") return "Running";
-    if (status === "completed") return "Done";
-    if (status === "failed") return "Failed";
-    return "Pending";
-  };
-
-  return (
-    <div className="content-stack">
-      <header className="hero">
-        <p className="eyebrow">upbrr</p>
-        <h1>Build Release Name</h1>
-        <p className="subtitle">
-          Build a release name and preview external metadata before you upload.
-        </p>
-      </header>
-
-      <section
-        className={`panel input-source-panel${
-          sourcePathHistoryOpen ? " input-source-panel--history-open" : ""
-        }`}
-      >
-        <div className="grid gap-3">
-          <div className="grid grid-cols-[minmax(0,1fr)_auto] items-end gap-3 max-[1100px]:grid-cols-1">
-            <div className="grid grid-cols-2 gap-3 max-[900px]:grid-cols-1">
-              <label
-                className="grid gap-1.5 text-sm text-[var(--muted)]"
-                htmlFor="source-lookup-url"
-              >
-                <span>Site URL override</span>
-                <input
-                  id="source-lookup-url"
-                  className={compactInputClass}
-                  value={sourceLookupURL}
-                  onChange={(event) => setSourceLookupURL(event.target.value)}
-                  placeholder="Paste tracker or media URL for ID lookup"
-                />
-                <span className="text-xs leading-tight text-[var(--muted)]">
-                  Metadata ID and tracker description/image lookup.
-                </span>
-              </label>
-
-              <div className="grid gap-1.5 text-sm text-[var(--muted)]" ref={sourcePathHistoryRef}>
-                <label htmlFor="source-path">Source path</label>
-                <div className="source-path-input-shell source-path-input-shell--drop-target">
-                  <input
-                    id="source-path"
-                    className={`${compactInputClass} source-path-input`}
-                    value={path}
-                    onChange={(event) => handleSourcePathChange(event.target.value)}
-                    onFocus={openSourcePathHistory}
-                    onClick={openSourcePathHistory}
-                    onKeyDown={(event) => {
-                      if (event.key === "Escape") {
-                        setSourcePathHistoryOpen(false);
-                      }
-                    }}
-                    placeholder="Select a file or folder"
-                    aria-autocomplete="list"
-                    aria-expanded={sourcePathHistoryOpen}
-                    aria-haspopup="listbox"
-                    aria-controls="source-path-history"
-                  />
-                  {sourcePathHistoryOpen ? (
-                    <div
-                      id="source-path-history"
-                      className="source-path-history"
-                      role="listbox"
-                      aria-label="Source path history"
-                    >
-                      {sourcePathHistory.map((entry) => (
-                        <button
-                          key={entry.path}
-                          className="source-path-history__item"
-                          type="button"
-                          role="option"
-                          onMouseDown={(event) => event.preventDefault()}
-                          onClick={() => selectSourcePathHistory(entry)}
-                        >
-                          <span className="mono">{entry.path}</span>
-                        </button>
-                      ))}
-                    </div>
-                  ) : null}
-                </div>
-                <span className="text-xs leading-tight text-[var(--muted)]">
-                  {discHint || "File, disc folder, or Season Pack folder."}
-                </span>
-              </div>
-            </div>
-
-            <div className="flex flex-wrap items-center justify-end gap-2 max-[1100px]:justify-start">
-              {browseAvailable ? (
-                <>
-                  <Button type="button" onClick={handleBrowseFile}>
-                    Browse file
-                  </Button>
-                  <Button type="button" onClick={handleBrowseFolder}>
-                    Browse folder
-                  </Button>
-                </>
-              ) : null}
-              <Button variant="primary" type="button" onClick={handleFetch} disabled={loading}>
-                {loading ? "Fetching..." : "Fetch metadata"}
-              </Button>
-            </div>
-          </div>
-
-          {!browseAvailable ? (
-            <p className="m-0 text-xs text-[var(--muted)]">
-              Native browse is only available from localhost. Remote sessions must enter the server
-              path manually.
-            </p>
-          ) : null}
-
-          <div className="flex flex-wrap items-center gap-3 rounded-lg border border-white/10 bg-white/[0.035] px-3 py-2">
-            <span className="text-sm font-semibold text-[var(--text)]">Run options</span>
-            <div className="inline-flex items-center gap-2 text-sm text-[var(--text)]">
-              <Switch
-                aria-label="Enable debug run"
-                checked={runDebug}
-                onChange={(event) => setRunDebug(event.target.checked)}
-              />
-              <span>Debug run</span>
-            </div>
-            <label
-              className="inline-flex items-center gap-2 text-sm text-[var(--muted)]"
-              htmlFor="run-log-level"
-            >
-              <span>Log level</span>
-              <select
-                id="run-log-level"
-                className={compactInputClass}
-                value={runLogLevel}
-                onChange={(event) => {
-                  setRunLogLevel(event.target.value);
-                  setRunLogLevelTouched(true);
-                }}
-              >
-                {["error", "warn", "info", "debug", "trace"].map((level) => (
-                  <option key={level} value={level}>
-                    {level}
-                  </option>
-                ))}
-              </select>
-            </label>
-            {runLogLevelTouched ? (
-              <Button type="button" onClick={() => setRunLogLevelTouched(false)}>
-                Reset log level
-              </Button>
-            ) : null}
-          </div>
-        </div>
-        {error ? <p className="error">{error}</p> : null}
-        {(preview.Warnings || []).map((warning) => (
-          <p key={warning} className="muted">
-            {warning}
-          </p>
-        ))}
-        {metadataProgressActive || metadataProgressUpdates.length > 0 ? (
-          <div className="metadata-progress">
-            <p className="label">Metadata progress</p>
-            <div className="metadata-progress__list">
-              {metadataPhaseOrder.map((phase) => {
-                const state = latestMetadataPhase.get(phase.key);
-                const status = state?.status || "pending";
-                return (
-                  <div
-                    key={phase.key}
-                    className={`metadata-progress__item metadata-progress__item--${status}`}
-                  >
-                    <span className="metadata-progress__phase">{phase.label}</span>
-                    <span className="metadata-progress__status">{metadataStatusLabel(status)}</span>
-                  </div>
-                );
-              })}
-            </div>
-          </div>
-        ) : null}
-      </section>
-
-      <section className="results">
-        {hasPreview ? (
-          <div className="summary">
-            <div>
-              <p className="label">Tracker used</p>
-              <p className="value">{preview.TrackerName || "No tracker used"}</p>
-            </div>
-            <div>
-              <p className="label">Release name</p>
-              <p className="value">{preview.ReleaseName || "No release name yet"}</p>
-            </div>
-          </div>
-        ) : null}
-
-        {hasPreview && showExternalIDInputUI && !hasResolvedPrimaryExternalID ? (
-          <div className="panel">
-            <div className="settings-subgroup">
-              <div className="settings-subgroup__title">External ID candidates</div>
-              <p className="muted path-helper">
-                Select a candidate to copy it into ID overrides, then refresh metadata.
-              </p>
-              {tmdbCandidates.length === 0 && imdbCandidates.length === 0 ? (
-                <p className="muted">No TMDB/IMDB candidates available for this search.</p>
-              ) : (
-                <div className="settings-grid">
-                  <div>
-                    <p className="label">TMDB</p>
-                    {tmdbCandidates.length === 0 ? (
-                      <p className="muted">No TMDB candidates</p>
-                    ) : (
-                      <div className="tracker-pills">
-                        {tmdbCandidates.slice(0, 5).map((candidate) => (
-                          <button
-                            key={`tmdb-${candidate.ID}`}
-                            type="button"
-                            className={`ghost candidate-selector ${selectedCandidateID("tmdb") === candidate.ID ? "active" : ""}`}
-                            onClick={() => applyCandidateID("tmdb", candidate)}
-                          >
-                            {candidate.Title || "(Untitled)"}
-                            {candidate.Year ? ` (${candidate.Year})` : ""}
-                            {formatSimilarity(candidate.Similarity)
-                              ? ` • ${formatSimilarity(candidate.Similarity)}`
-                              : ""}
-                          </button>
-                        ))}
-                      </div>
-                    )}
-                    {candidatePreview?.provider === "tmdb" ? (
-                      <div className="settings-subgroup candidate-preview">
-                        <p className="label">Selected TMDB candidate</p>
-                        <div className="candidate-preview__header">
-                          <div className="candidate-preview__text">
-                            <p className="value">
-                              {candidatePreview.candidate.Title || "(Untitled)"}
-                              {candidatePreview.candidate.Year
-                                ? ` (${candidatePreview.candidate.Year})`
-                                : ""}
-                            </p>
-                            <p className="muted">
-                              {candidatePreview.candidate.Category || "Unknown category"}
-                              {formatSimilarity(candidatePreview.candidate.Similarity)
-                                ? ` • ${formatSimilarity(candidatePreview.candidate.Similarity)}`
-                                : ""}
-                            </p>
-                          </div>
-                          {candidatePreview.candidate.PosterURL ? (
-                            <button
-                              className="candidate-preview__poster-button"
-                              type="button"
-                              onClick={() => {
-                                setLightboxImage(candidatePreview.candidate.PosterURL);
-                                setLightboxAlt("TMDB candidate poster");
-                              }}
-                            >
-                              <img
-                                className="candidate-preview__poster"
-                                src={candidatePreview.candidate.PosterURL}
-                                alt="TMDB candidate poster"
-                                loading="lazy"
-                              />
-                            </button>
-                          ) : null}
-                        </div>
-                        <p className="muted">
-                          {candidatePreview.candidate.Overview || "No overview available."}
-                        </p>
-                      </div>
-                    ) : null}
-                  </div>
-                  <div>
-                    <p className="label">IMDB</p>
-                    {imdbCandidates.length === 0 ? (
-                      <p className="muted">No IMDB candidates</p>
-                    ) : (
-                      <div className="tracker-pills">
-                        {imdbCandidates.slice(0, 5).map((candidate) => (
-                          <button
-                            key={`imdb-${candidate.ID}`}
-                            type="button"
-                            className={`ghost candidate-selector ${selectedCandidateID("imdb") === candidate.ID ? "active" : ""}`}
-                            onClick={() => applyCandidateID("imdb", candidate)}
-                          >
-                            {candidate.Title || "(Untitled)"}
-                            {candidate.Year ? ` (${candidate.Year})` : ""}
-                            {formatSimilarity(candidate.Similarity)
-                              ? ` • ${formatSimilarity(candidate.Similarity)}`
-                              : ""}
-                          </button>
-                        ))}
-                      </div>
-                    )}
-                    {candidatePreview?.provider === "imdb" ? (
-                      <div className="settings-subgroup candidate-preview">
-                        <p className="label">Selected IMDB candidate</p>
-                        <div className="candidate-preview__header">
-                          <div className="candidate-preview__text">
-                            <p className="value">
-                              {candidatePreview.candidate.Title || "(Untitled)"}
-                              {candidatePreview.candidate.Year
-                                ? ` (${candidatePreview.candidate.Year})`
-                                : ""}
-                            </p>
-                            <p className="muted">
-                              {candidatePreview.candidate.Category || "Unknown category"}
-                              {formatSimilarity(candidatePreview.candidate.Similarity)
-                                ? ` • ${formatSimilarity(candidatePreview.candidate.Similarity)}`
-                                : ""}
-                            </p>
-                          </div>
-                          {candidatePreview.candidate.PosterURL ? (
-                            <button
-                              className="candidate-preview__poster-button"
-                              type="button"
-                              onClick={() => {
-                                setLightboxImage(candidatePreview.candidate.PosterURL);
-                                setLightboxAlt("IMDB candidate poster");
-                              }}
-                            >
-                              <img
-                                className="candidate-preview__poster"
-                                src={candidatePreview.candidate.PosterURL}
-                                alt="IMDB candidate poster"
-                                loading="lazy"
-                              />
-                            </button>
-                          ) : null}
-                        </div>
-                        <p className="muted">
-                          {candidatePreview.candidate.Overview || "No overview available."}
-                        </p>
-                      </div>
-                    ) : null}
-                  </div>
-                </div>
-              )}
-              <div className="edit-actions">
-                <button
-                  className="primary"
-                  type="button"
-                  onClick={handleRefresh}
-                  disabled={refreshDisabled}
-                >
-                  {loading ? "Refreshing..." : "Refresh metadata"}
-                </button>
-              </div>
-            </div>
-          </div>
-        ) : null}
-
-        <div className="edit-controls">
-          {hasPreview ? (
-            <details className="edit-dropdown tracker-dropdown">
-              <summary>
-                <span>Select Trackers</span>
-                <span className="tracker-summary-count">
-                  {selectedTrackerCount}/{trackerUploadItems.length}
-                </span>
-              </summary>
-              <div className="edit-dropdown__body">
-                <div className="tracker-selection-container">
-                  {trackerUploadItems.length === 0 ? (
-                    <p className="muted">No configured tracker entries found.</p>
-                  ) : (
-                    <>
-                      <div className="mb-2 flex flex-wrap gap-2">
-                        <Button
-                          type="button"
-                          onClick={() => setAllTrackersSelected(true)}
-                          disabled={allTrackersSelected}
-                        >
-                          Select all
-                        </Button>
-                        <Button
-                          type="button"
-                          onClick={() => setAllTrackersSelected(false)}
-                          disabled={selectedTrackerCount === 0}
-                        >
-                          Deselect all
-                        </Button>
-                      </div>
-                      <div className="tracker-pills">
-                        {trackerUploadItems.map((tracker) => {
-                          const iconSrc = trackerIconFor(trackerIconSrcByName, tracker.name);
-                          return (
-                            <PillCheckbox
-                              aria-label={tracker.name}
-                              key={tracker.name}
-                              checked={Boolean(releasePageTrackerSelection[tracker.name])}
-                              onCheckedChange={(checked) =>
-                                setReleasePageTrackerSelection((prev) => ({
-                                  ...prev,
-                                  [tracker.name]: checked,
-                                }))
-                              }
-                            >
-                              <span className="flex items-center gap-1.5">
-                                <TrackerIconImage
-                                  tracker={tracker.name}
-                                  iconSrc={iconSrc}
-                                  enabled={useFavicons}
-                                />
-                                {faviconOnly && useFavicons ? null : tracker.name}
-                              </span>
-                            </PillCheckbox>
-                          );
-                        })}
-                      </div>
-                    </>
-                  )}
-                </div>
-              </div>
-            </details>
-          ) : null}
-          {hasPreview ? (
-            <p className="helper edit-helper">Edit external IDs and Release Name attributes.</p>
-          ) : null}
-          {hasPreview ? (
-            <details className="edit-dropdown">
-              <summary>Edit Release Details</summary>
-              <div className="edit-dropdown__body">
-                <div className="settings-subgroup">
-                  <div className="settings-subgroup__title">External IDs</div>
-                  <div className="id-editor settings-grid">
-                    <div className="settings-field">
-                      <label htmlFor="external-tmdb-id">TMDB ID</label>
-                      <input
-                        id="external-tmdb-id"
-                        value={idEdits.tmdb}
-                        onChange={(event) => {
-                          setIdEdits((prev) => ({ ...prev, tmdb: event.target.value }));
-                          markIDTouched("tmdb");
-                        }}
-                        placeholder="e.g. 550"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="external-imdb-id">IMDB ID</label>
-                      <input
-                        id="external-imdb-id"
-                        value={idEdits.imdb}
-                        onChange={(event) => {
-                          setIdEdits((prev) => ({ ...prev, imdb: event.target.value }));
-                          markIDTouched("imdb");
-                        }}
-                        placeholder="e.g. tt0137523"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="external-tvdb-id">TVDB ID</label>
-                      <input
-                        id="external-tvdb-id"
-                        value={idEdits.tvdb}
-                        onChange={(event) => {
-                          setIdEdits((prev) => ({ ...prev, tvdb: event.target.value }));
-                          markIDTouched("tvdb");
-                        }}
-                        placeholder="e.g. 80379"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="external-tvmaze-id">TVmaze ID</label>
-                      <input
-                        id="external-tvmaze-id"
-                        value={idEdits.tvmaze}
-                        onChange={(event) => {
-                          setIdEdits((prev) => ({ ...prev, tvmaze: event.target.value }));
-                          markIDTouched("tvmaze");
-                        }}
-                        placeholder="e.g. 82"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="external-mal-id">MAL ID</label>
-                      <input
-                        id="external-mal-id"
-                        value={idEdits.mal}
-                        onChange={(event) => {
-                          setIdEdits((prev) => ({ ...prev, mal: event.target.value }));
-                          markIDTouched("mal");
-                        }}
-                        placeholder="e.g. 5114"
-                      />
-                    </div>
-                  </div>
-                </div>
-                <div className="settings-subgroup">
-                  <div className="settings-subgroup__title">Release name overrides</div>
-                  <div className="settings-grid">
-                    <div className="settings-field">
-                      <label htmlFor="release-category">Category</label>
-                      <input
-                        id="release-category"
-                        value={releaseEdits?.category || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, category: event.target.value }));
-                          markReleaseTouched("category");
-                        }}
-                        placeholder="movie or tv"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-type">Type</label>
-                      <input
-                        id="release-type"
-                        value={releaseEdits?.type || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, type: event.target.value }));
-                          markReleaseTouched("type");
-                        }}
-                        placeholder="remux, encode, webdl"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-source">Source</label>
-                      <input
-                        id="release-source"
-                        value={releaseEdits?.source || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, source: event.target.value }));
-                          markReleaseTouched("source");
-                        }}
-                        placeholder="BluRay, WEB, DVD"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-resolution">Resolution</label>
-                      <input
-                        id="release-resolution"
-                        value={releaseEdits?.resolution || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, resolution: event.target.value }));
-                          markReleaseTouched("resolution");
-                        }}
-                        placeholder="2160p"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-tag">Tag</label>
-                      <input
-                        id="release-tag"
-                        value={releaseEdits?.tag || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, tag: event.target.value }));
-                          markReleaseTouched("tag");
-                        }}
-                        placeholder="GROUP"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-service">Service</label>
-                      <input
-                        id="release-service"
-                        value={releaseEdits?.service || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, service: event.target.value }));
-                          markReleaseTouched("service");
-                        }}
-                        placeholder="Netflix"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-edition">Edition</label>
-                      <input
-                        id="release-edition"
-                        value={releaseEdits?.edition || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, edition: event.target.value }));
-                          markReleaseTouched("edition");
-                        }}
-                        placeholder="Director's Cut"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-region">Region</label>
-                      <input
-                        id="release-region"
-                        value={releaseEdits?.region || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, region: event.target.value }));
-                          markReleaseTouched("region");
-                        }}
-                        placeholder="A, B, C"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-season">Season</label>
-                      <input
-                        id="release-season"
-                        value={releaseEdits?.season || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, season: event.target.value }));
-                          markReleaseTouched("season");
-                        }}
-                        placeholder="S01"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-episode">Episode</label>
-                      <input
-                        id="release-episode"
-                        value={releaseEdits?.episode || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, episode: event.target.value }));
-                          markReleaseTouched("episode");
-                        }}
-                        placeholder="E02"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-episode-title">Episode title</label>
-                      <input
-                        id="release-episode-title"
-                        value={releaseEdits?.episodeTitle || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({
-                            ...prev,
-                            episodeTitle: event.target.value,
-                          }));
-                          markReleaseTouched("episodeTitle");
-                        }}
-                        placeholder="Pilot"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-manual-year">Manual year</label>
-                      <input
-                        id="release-manual-year"
-                        type="number"
-                        value={releaseEdits?.manualYear || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, manualYear: event.target.value }));
-                          markReleaseTouched("manualYear");
-                        }}
-                        placeholder="2024"
-                      />
-                    </div>
-                    <div className="settings-field">
-                      <label htmlFor="release-manual-date">Manual date</label>
-                      <input
-                        id="release-manual-date"
-                        value={releaseEdits?.manualDate || ""}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, manualDate: event.target.value }));
-                          markReleaseTouched("manualDate");
-                        }}
-                        placeholder="YYYY-MM-DD"
-                      />
-                    </div>
-                    {isTVEpisodePreview ? (
-                      <div className="settings-toggle">
-                        <span>Use season/episode instead</span>
-                        <Switch
-                          aria-label="Use season/episode instead"
-                          checked={Boolean(releaseEdits?.useSeasonEpisode)}
-                          onChange={(event) => {
-                            setReleaseEdits((prev) => ({
-                              ...prev,
-                              useSeasonEpisode: event.target.checked,
-                            }));
-                            markReleaseTouched("useSeasonEpisode");
-                          }}
-                        />
-                      </div>
-                    ) : null}
-                  </div>
-                </div>
-                <div className="settings-subgroup">
-                  <div className="settings-subgroup__title">Flags</div>
-                  <div className="settings-grid">
-                    <div className="settings-toggle">
-                      <span>No season</span>
-                      <Switch
-                        aria-label="No season"
-                        checked={Boolean(releaseEdits?.noSeason)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noSeason: event.target.checked }));
-                          markReleaseTouched("noSeason");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No year</span>
-                      <Switch
-                        aria-label="No year"
-                        checked={Boolean(releaseEdits?.noYear)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noYear: event.target.checked }));
-                          markReleaseTouched("noYear");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No AKA</span>
-                      <Switch
-                        aria-label="No AKA"
-                        checked={Boolean(releaseEdits?.noAKA)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noAKA: event.target.checked }));
-                          markReleaseTouched("noAKA");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No tag</span>
-                      <Switch
-                        aria-label="No tag"
-                        checked={Boolean(releaseEdits?.noTag)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noTag: event.target.checked }));
-                          markReleaseTouched("noTag");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No edition</span>
-                      <Switch
-                        aria-label="No edition"
-                        checked={Boolean(releaseEdits?.noEdition)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noEdition: event.target.checked }));
-                          markReleaseTouched("noEdition");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No dub</span>
-                      <Switch
-                        aria-label="No dub"
-                        checked={Boolean(releaseEdits?.noDub)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noDub: event.target.checked }));
-                          markReleaseTouched("noDub");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>No dual-audio</span>
-                      <Switch
-                        aria-label="No dual-audio"
-                        checked={Boolean(releaseEdits?.noDual)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, noDual: event.target.checked }));
-                          markReleaseTouched("noDual");
-                        }}
-                      />
-                    </div>
-                    <div className="settings-toggle">
-                      <span>Force dual-audio</span>
-                      <Switch
-                        aria-label="Force dual-audio"
-                        checked={Boolean(releaseEdits?.dualAudio)}
-                        onChange={(event) => {
-                          setReleaseEdits((prev) => ({ ...prev, dualAudio: event.target.checked }));
-                          markReleaseTouched("dualAudio");
-                        }}
-                      />
-                    </div>
-                  </div>
-                </div>
-                {idOverrideState?.invalid ? (
-                  <p className="error">
-                    Enter numeric IDs only. IMDb supports an optional tt prefix.
-                  </p>
-                ) : null}
-                {releaseOverrideState?.invalid ? (
-                  <p className="error">
-                    Manual year must be numeric and manual date must be YYYY-MM-DD.
-                  </p>
-                ) : null}
-                <div className="edit-actions">
-                  <button
-                    className="ghost"
-                    type="button"
-                    onClick={handleResetMetadata}
-                    disabled={loading}
-                  >
-                    {metadataResetting ? "Resetting..." : "Reset data + refresh"}
-                  </button>
-                  <button
-                    className="primary"
-                    type="button"
-                    onClick={handleRefresh}
-                    disabled={refreshDisabled}
-                  >
-                    {loading ? "Refreshing..." : "Refresh metadata"}
-                  </button>
-                </div>
-              </div>
-            </details>
-          ) : null}
-        </div>
-
-        <div className={`details ${hasPreview ? "loaded" : ""}`}>
-          <div className="id-list">
-            <h2>External IDs</h2>
-            {orderedExternalIDs.length === 0 ? (
-              <p className="muted">No external metadata details found.</p>
-            ) : (
-              orderedExternalIDs.map((item) => (
-                <button
-                  key={item.Provider}
-                  className={`id-card ${selectedProvider === item.Provider ? "active" : ""}`}
-                  type="button"
-                  onClick={() => setSelectedProvider(item.Provider)}
-                >
-                  <span className="id-label">{formatProvider(item.Provider)}</span>
-                  <span className="id-value">{formatID(item.Provider, item.ID)}</span>
-                  <span className="id-source">Source: {item.Source}</span>
-                </button>
-              ))
-            )}
-          </div>
-
-          <div className="preview-panel">
-            <div className="preview-header">
-              <div>
-                <h2>Preview</h2>
-              </div>
-              {selectedPreview?.Provider === "tvdb" && tvdbToggleEnabled ? (
-                <fieldset className="preview-language-toggle" aria-label="TVDB language display">
-                  <button
-                    className={`ghost ${tvdbDisplayMode === "original" ? "toggle-active" : ""}`}
-                    type="button"
-                    onClick={() => setTVDBDisplayMode("original")}
-                  >
-                    Original
-                  </button>
-                  <button
-                    className={`ghost ${tvdbDisplayMode === "english" ? "toggle-active" : ""}`}
-                    type="button"
-                    onClick={() => setTVDBDisplayMode("english")}
-                  >
-                    English
-                  </button>
-                </fieldset>
-              ) : null}
-            </div>
-            {selectedPreview ? (
-              <div className="preview-content">
-                <div className="preview-text">
-                  <p className="title">{selectedPreviewTitle || "Untitled"}</p>
-                  <p className="meta">{selectedPreview.Year ? `${selectedPreview.Year}` : ""}</p>
-                  <p className="overview">{selectedPreviewOverview || "No overview available."}</p>
-                  <PreviewDetailsList items={previewDetails} />
-                </div>
-                <div className="preview-images">
-                  {selectedPreview.PosterURL ? (
-                    <img src={selectedPreview.PosterURL} alt="Poster" loading="lazy" />
-                  ) : null}
-                  {selectedPreview.BackdropURL ? (
-                    <img src={selectedPreview.BackdropURL} alt="Backdrop" loading="lazy" />
-                  ) : null}
-                </div>
-              </div>
-            ) : (
-              <p className="muted">Select an external ID to preview.</p>
-            )}
-          </div>
-        </div>
-      </section>
-    </div>
-  );
-}
diff --git a/gui/frontend/src/pages/menu_images/index.test.tsx b/gui/frontend/src/pages/menu_images/index.test.tsx
deleted file mode 100644
index 99f8257b..00000000
--- a/gui/frontend/src/pages/menu_images/index.test.tsx
+++ /dev/null
@@ -1,374 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { ComponentProps } from "react";
-
-import type { DVDMenuCaptureResult, DVDMenuCaptureSnapshot, ScreenshotImage } from "../../types";
-import MenuImagesPage from "./index";
-
-const menuImage = (path: string, index: number): ScreenshotImage => ({
-  Index: index,
-  TimestampSeconds: 0,
-  Path: path,
-  Purpose: "menu",
-  Width: 720,
-  Height: 480,
-  SizeBytes: 1024,
-});
-
-const captureResult = (overrides: Partial<DVDMenuCaptureResult> = {}): DVDMenuCaptureResult => ({
-  SourcePath: "C:/media/Example/VIDEO_TS",
-  Images: [],
-  SelectedLanguage: "en",
-  Region: 0,
-  DiscoveredMenus: 2,
-  VisitedStates: 4,
-  VisitedButtons: 3,
-  MaxItems: 6,
-  Complete: true,
-  Partial: false,
-  Truncated: false,
-  Warnings: [],
-  Engine: {
-    EngineVersion: "phase0a-1",
-    SchemaVersion: 1,
-    SupportedFeatures: [],
-    FFmpegVersion: "8.0",
-    FFmpegDVDVideo: true,
-    MissingFFmpegOptions: [],
-  },
-  ...overrides,
-});
-
-const captureSnapshot = (status: string, result = captureResult()): DVDMenuCaptureSnapshot => ({
-  jobID: "dvd-job-1",
-  sourcePath: result.SourcePath,
-  status,
-  phase: status === "completed" ? "complete" : "capturing",
-  message: status === "completed" ? "DVD menu capture finished." : "Rendering menus.",
-  discoveredMenus: result.DiscoveredMenus,
-  visitedStates: result.VisitedStates,
-  visitedButtons: result.VisitedButtons,
-  capturedCount: result.Images.length || 2,
-  warningCount: result.Warnings.length,
-  result,
-  error: "",
-  startedAt: "2026-07-10T00:00:00Z",
-  finishedAt: status === "completed" ? "2026-07-10T00:00:01Z" : "",
-});
-
-const deferred = <T,>() => {
-  let resolve!: (value: T) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise;
-    reject = rejectPromise;
-  });
-  return { promise, reject, resolve };
-};
-
-const installBridge = (overrides: Record<string, unknown> = {}) => {
-  const app = {
-    ListDVDMenuScreenshots: vi.fn(async () => [] as ScreenshotImage[]),
-    ReadScreenshotImage: vi.fn(async () => "data:image/png;base64,example"),
-    StartDVDMenuCapture: vi.fn(async () => "dvd-job-1"),
-    GetDVDMenuCaptureSnapshot: vi.fn(async () => captureSnapshot("completed")),
-    CancelDVDMenuCapture: vi.fn(async () => undefined),
-    DeleteDVDMenuScreenshot: vi.fn(async () => undefined),
-    ImportMenuImages: vi.fn(async () => undefined),
-    BrowseImageFiles: vi.fn(async () => [] as string[]),
-    ...overrides,
-  };
-  (globalThis as typeof globalThis & { go?: any }).go = { guiapp: { App: app } };
-  return app;
-};
-
-const pageProps = (
-  overrides: Partial<ComponentProps<typeof MenuImagesPage>> = {},
-): ComponentProps<typeof MenuImagesPage> => ({
-  path: "C:/media/Example/VIDEO_TS",
-  overrides: {},
-  nameOverrides: {},
-  currentDiscType: "DVD",
-  maxMenuItems: 6,
-  browseAvailable: true,
-  onImagesChanged: vi.fn(),
-  onContinue: vi.fn(),
-  setLightboxImage: vi.fn(),
-  setLightboxAlt: vi.fn(),
-  ...overrides,
-});
-
-const renderPage = (overrides: Partial<ComponentProps<typeof MenuImagesPage>> = {}) => {
-  const props = pageProps(overrides);
-  render(<MenuImagesPage {...props} />);
-  return props;
-};
-
-afterEach(() => {
-  cleanup();
-  delete (globalThis as typeof globalThis & { go?: any }).go;
-});
-
-describe("MenuImagesPage", () => {
-  it("loads persisted images and shows DVD-only capture controls with configured maximum", async () => {
-    const app = installBridge({
-      ListDVDMenuScreenshots: vi.fn(async () => [menuImage("menu-1.png", 0)]),
-    });
-    const props = renderPage({ maxMenuItems: 8 });
-
-    expect(screen.getByText("Capture up to 8 distinct DVD menu screens.")).toBeInTheDocument();
-    expect(screen.getByRole("button", { name: "Capture DVD menus" })).toBeInTheDocument();
-    expect(await screen.findByRole("button", { name: "Preview DVD menu 1" })).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Preview DVD menu 1" }));
-    expect(props.setLightboxAlt).toHaveBeenCalledWith("DVD menu 1");
-    expect(app.ListDVDMenuScreenshots).toHaveBeenCalledOnce();
-  });
-
-  it.each(["BDMV", "HDDVD"])("keeps %s in manual-only mode", (discType) => {
-    installBridge();
-    renderPage({ currentDiscType: discType });
-
-    expect(screen.queryByRole("button", { name: "Capture DVD menus" })).not.toBeInTheDocument();
-    expect(screen.getByRole("button", { name: "Add images" })).toBeInTheDocument();
-    expect(
-      screen.getByText(new RegExp(`Manual disc menu import remains available for ${discType}`)),
-    ).toBeInTheDocument();
-  });
-
-  it("shows progress and cancels an active capture", async () => {
-    const app = installBridge({
-      GetDVDMenuCaptureSnapshot: vi.fn(async () => captureSnapshot("running")),
-    });
-    renderPage();
-
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    expect(await screen.findByText("Rendering menus.")).toBeInTheDocument();
-    expect(screen.getByText(/States 4/)).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
-    await waitFor(() => expect(app.CancelDVDMenuCapture).toHaveBeenCalledWith("dvd-job-1"));
-    expect(
-      screen.getByRole("button", { name: "Capture DVD menus" }).closest("section"),
-    ).toHaveAttribute("aria-busy", "true");
-  });
-
-  it("cancels an active capture and ignores its late completion after a source change", async () => {
-    const oldPath = "C:/media/Example.Release.2026/VIDEO_TS";
-    const newPath = "C:/media/Example.Release.2027/VIDEO_TS";
-    const pendingSnapshot = deferred<DVDMenuCaptureSnapshot>();
-    const app = installBridge({
-      StartDVDMenuCapture: vi.fn(async () => "old-dvd-job"),
-      GetDVDMenuCaptureSnapshot: vi.fn(() => pendingSnapshot.promise),
-    });
-    const onImagesChanged = vi.fn();
-    const props = pageProps({ path: oldPath, onImagesChanged });
-    const view = render(<MenuImagesPage {...props} />);
-
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    await waitFor(() => expect(app.GetDVDMenuCaptureSnapshot).toHaveBeenCalledWith("old-dvd-job"));
-
-    view.rerender(<MenuImagesPage {...props} path={newPath} />);
-    await waitFor(() => expect(app.CancelDVDMenuCapture).toHaveBeenCalledWith("old-dvd-job"));
-
-    await act(async () => {
-      pendingSnapshot.resolve(captureSnapshot("completed", captureResult({ SourcePath: oldPath })));
-      await pendingSnapshot.promise;
-    });
-
-    expect(screen.queryByText("DVD menu capture finished.")).not.toBeInTheDocument();
-    expect(screen.getByRole("button", { name: "Capture DVD menus" })).toBeEnabled();
-    expect(onImagesChanged).not.toHaveBeenCalled();
-  });
-
-  it("gates duplicate starts synchronously and clears the pending state on rejection", async () => {
-    const pendingStart = deferred<string>();
-    const app = installBridge({
-      StartDVDMenuCapture: vi.fn(() => pendingStart.promise),
-    });
-    renderPage();
-
-    const captureButton = screen.getByRole("button", { name: "Capture DVD menus" });
-    fireEvent.click(captureButton);
-    fireEvent.click(captureButton);
-
-    expect(app.StartDVDMenuCapture).toHaveBeenCalledOnce();
-    expect(screen.getByRole("button", { name: "Starting..." })).toBeDisabled();
-
-    await act(async () => {
-      pendingStart.reject(new Error("DVD capture start failed"));
-      await pendingStart.promise.catch(() => undefined);
-    });
-
-    expect(await screen.findByRole("alert")).toHaveTextContent("DVD capture start failed");
-    expect(screen.getByRole("button", { name: "Capture DVD menus" })).toBeEnabled();
-  });
-
-  it.each([
-    {
-      name: "partial",
-      result: captureResult({
-        Complete: false,
-        Partial: true,
-        Warnings: [{ Code: "frame_decode", Message: "One menu could not be rendered." }],
-      }),
-      text: "Captured 2 DVD menu images.",
-    },
-    {
-      name: "truncated",
-      result: captureResult({ Complete: false, Truncated: true, MaxItems: 2 }),
-      text: "Maximum reached",
-    },
-  ])("shows $name completion state without navigating", async ({ result, text }) => {
-    installBridge({
-      GetDVDMenuCaptureSnapshot: vi.fn(async () => captureSnapshot("completed", result)),
-    });
-    const props = renderPage();
-
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    expect(await screen.findByText(text)).toBeInTheDocument();
-    expect(props.onImagesChanged).toHaveBeenCalledOnce();
-    expect(props.onContinue).not.toHaveBeenCalled();
-  });
-
-  it("hides internal navigation warnings while keeping basic capture feedback", async () => {
-    const hiddenWarnings = [
-      {
-        Code: "unsupported_post_link",
-        Message: "menu post-command target was not resolved",
-      },
-      {
-        Code: "structural_state",
-        Message: "structural menu candidate could not be classified",
-      },
-      {
-        Code: "structural_only",
-        Message: "visible menu was not reached through navigation",
-      },
-      {
-        Code: "nav_scan_limit",
-        Message: "menu NAV/SPU sector scan limit reached",
-      },
-      {
-        Code: "structural_discovery",
-        Message:
-          "Some menu screens were found through structural inventory rather than reachable navigation.",
-      },
-    ];
-    installBridge({
-      GetDVDMenuCaptureSnapshot: vi.fn(async () =>
-        captureSnapshot(
-          "completed",
-          captureResult({ Complete: false, Partial: true, Warnings: hiddenWarnings }),
-        ),
-      ),
-    });
-    renderPage();
-
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    expect(await screen.findByText("Captured 2 DVD menu images.")).toBeInTheDocument();
-    for (const warning of hiddenWarnings) {
-      expect(screen.queryByText(warning.Message)).not.toBeInTheDocument();
-    }
-    expect(screen.queryByText(/Warnings \d+/)).not.toBeInTheDocument();
-  });
-
-  it("shows hard capture failures in an alert region", async () => {
-    installBridge({
-      StartDVDMenuCapture: vi.fn(async () => {
-        throw new Error("Compatible FFmpeg DVD menu support is required");
-      }),
-    });
-    renderPage();
-
-    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
-    expect(await screen.findByRole("alert")).toHaveTextContent(
-      "Compatible FFmpeg DVD menu support is required",
-    );
-  });
-
-  it("imports without automatic navigation and exposes explicit continue", async () => {
-    const app = installBridge({
-      BrowseImageFiles: vi.fn(async () => ["C:/images/menu.png"]),
-    });
-    const props = renderPage();
-
-    fireEvent.click(screen.getByRole("button", { name: "Add images" }));
-    expect(await screen.findByText("C:/images/menu.png")).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Import images" }));
-    await waitFor(() => expect(app.ImportMenuImages).toHaveBeenCalledOnce());
-    expect(props.onImagesChanged).toHaveBeenCalledOnce();
-    expect(props.onContinue).not.toHaveBeenCalled();
-
-    fireEvent.click(screen.getByRole("button", { name: "Continue to Upload Images" }));
-    expect(props.onContinue).toHaveBeenCalledOnce();
-  });
-
-  it("removes one persisted image, preserves order, and focuses the next removal", async () => {
-    let persisted = [menuImage("menu-1.png", 0), menuImage("menu-2.png", 1)];
-    const app = installBridge({
-      ListDVDMenuScreenshots: vi.fn(async () => persisted),
-      DeleteDVDMenuScreenshot: vi.fn(async (_path, _overrides, _nameOverrides, imagePath) => {
-        persisted = persisted.filter((image) => image.Path !== imagePath);
-      }),
-    });
-    const props = renderPage();
-
-    expect(await screen.findByRole("button", { name: "Remove DVD menu 2" })).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Remove DVD menu 1" }));
-    await waitFor(() => expect(app.DeleteDVDMenuScreenshot).toHaveBeenCalledOnce());
-    await waitFor(() =>
-      expect(screen.getByRole("button", { name: "Remove DVD menu 1" })).toHaveFocus(),
-    );
-    expect(screen.queryByRole("button", { name: "Remove DVD menu 2" })).not.toBeInTheDocument();
-    expect(props.onImagesChanged).toHaveBeenCalledOnce();
-  });
-
-  it("keeps every concurrent deletion disabled until its own request completes", async () => {
-    let persisted = [menuImage("menu-1.png", 0), menuImage("menu-2.png", 1)];
-    const firstDelete = deferred<void>();
-    const secondDelete = deferred<void>();
-    const app = installBridge({
-      ListDVDMenuScreenshots: vi.fn(async () => persisted),
-      DeleteDVDMenuScreenshot: vi.fn(
-        async (_path, _overrides, _nameOverrides, imagePath: string) => {
-          if (imagePath === "menu-1.png") await firstDelete.promise;
-          else await secondDelete.promise;
-          persisted = persisted.filter((image) => image.Path !== imagePath);
-        },
-      ),
-    });
-    renderPage();
-
-    const firstButton = await screen.findByRole("button", { name: "Remove DVD menu 1" });
-    const secondButton = screen.getByRole("button", { name: "Remove DVD menu 2" });
-    fireEvent.click(firstButton);
-    fireEvent.click(secondButton);
-
-    expect(app.DeleteDVDMenuScreenshot).toHaveBeenCalledTimes(2);
-    expect(firstButton).toBeDisabled();
-    expect(secondButton).toBeDisabled();
-
-    await act(async () => {
-      secondDelete.resolve();
-      await secondDelete.promise;
-    });
-
-    await waitFor(() =>
-      expect(screen.queryByRole("button", { name: "Remove DVD menu 2" })).not.toBeInTheDocument(),
-    );
-    const stillPendingButton = screen.getByRole("button", { name: "Remove DVD menu 1" });
-    expect(stillPendingButton).toBeDisabled();
-    fireEvent.click(stillPendingButton);
-    expect(app.DeleteDVDMenuScreenshot).toHaveBeenCalledTimes(2);
-
-    await act(async () => {
-      firstDelete.resolve();
-      await firstDelete.promise;
-    });
-
-    expect(await screen.findByText("No saved menu images yet.")).toBeInTheDocument();
-    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
-  });
-});
diff --git a/gui/frontend/src/pages/menu_images/index.tsx b/gui/frontend/src/pages/menu_images/index.tsx
deleted file mode 100644
index 1f6e332d..00000000
--- a/gui/frontend/src/pages/menu_images/index.tsx
+++ /dev/null
@@ -1,514 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type {
-  DVDMenuCaptureSnapshot,
-  ExternalIDOverrides,
-  ReleaseNameOverrides,
-  ScreenshotImage,
-} from "../../types";
-
-type Props = Readonly<{
-  path: string;
-  overrides: ExternalIDOverrides;
-  nameOverrides: ReleaseNameOverrides;
-  currentDiscType: string;
-  maxMenuItems: number;
-  browseAvailable: boolean;
-  onImagesChanged: () => void;
-  onContinue: () => void;
-  setLightboxImage: (value: string) => void;
-  setLightboxAlt: (value: string) => void;
-}>;
-
-type MenuPreview = {
-  image: ScreenshotImage;
-  dataURI: string;
-};
-
-type CaptureJob = Readonly<{
-  id: string;
-  sourcePath: string;
-}>;
-
-type CaptureStart = Readonly<{
-  sourcePath: string;
-}>;
-
-type CaptureStatus = Readonly<{
-  sourcePath: string;
-  snapshot: DVDMenuCaptureSnapshot;
-}>;
-
-const terminalStatuses = new Set(["completed", "failed", "canceled"]);
-const hiddenCaptureWarningCodes = new Set([
-  "unsupported_post_link",
-  "structural_state",
-  "structural_only",
-  "nav_scan_limit",
-  "structural_discovery",
-]);
-
-const errorText = (error: unknown) =>
-  error instanceof Error && error.message ? error.message : String(error);
-
-/**
- * Manages manual disc-menu imports and background DVD menu capture for the
- * current prepared source. Persisted images can be previewed or deleted before
- * continuing to image-host selection. Concurrent deletions keep each affected
- * control pending until its own request settles.
- */
-export default function MenuImagesPage(props: Props) {
-  const {
-    path,
-    overrides,
-    nameOverrides,
-    currentDiscType,
-    maxMenuItems,
-    browseAvailable,
-    onImagesChanged,
-    onContinue,
-    setLightboxImage,
-    setLightboxAlt,
-  } = props;
-
-  const [menuPaths, setMenuPaths] = useState<string[]>([]);
-  const [images, setImages] = useState<MenuPreview[]>([]);
-  const [listLoading, setListLoading] = useState(false);
-  const [importing, setImporting] = useState(false);
-  const [deletingPaths, setDeletingPaths] = useState<ReadonlySet<string>>(() => new Set());
-  const [captureJob, setCaptureJob] = useState<CaptureJob | null>(null);
-  const [captureStart, setCaptureStart] = useState<CaptureStart | null>(null);
-  const [captureStatus, setCaptureStatus] = useState<CaptureStatus | null>(null);
-  const [error, setError] = useState("");
-  const [notice, setNotice] = useState("");
-  const removeButtonRefs = useRef(new Map<string, HTMLButtonElement>());
-  const deletingPathsRef = useRef(new Set<string>());
-  const captureButtonRef = useRef<HTMLButtonElement>(null);
-  const focusAfterRemovalRef = useRef<number | null>(null);
-  const captureJobRef = useRef<CaptureJob | null>(null);
-  const captureStartRef = useRef<CaptureStart | null>(null);
-  const previousSourcePathRef = useRef(path.trim());
-  const refreshRequestRef = useRef(0);
-
-  const sourcePath = path.trim();
-  const resolvedMaxMenuItems =
-    Number.isFinite(maxMenuItems) && maxMenuItems > 0 ? Math.trunc(maxMenuItems) : 6;
-  const automaticCaptureAvailable = currentDiscType.toUpperCase() === "DVD";
-  const currentCaptureJob = captureJob?.sourcePath === sourcePath ? captureJob : null;
-  const captureStarting = captureStart?.sourcePath === sourcePath;
-  const visibleSnapshot = captureStatus?.sourcePath === sourcePath ? captureStatus.snapshot : null;
-  const captureActive =
-    captureStarting ||
-    (currentCaptureJob !== null &&
-      (!visibleSnapshot ||
-        visibleSnapshot.status === "queued" ||
-        visibleSnapshot.status === "running"));
-
-  const refreshImages = useCallback(async () => {
-    const requestID = ++refreshRequestRef.current;
-    const app = globalThis.go?.guiapp?.App;
-    if (!app?.ListDVDMenuScreenshots || !sourcePath) {
-      setImages([]);
-      setListLoading(false);
-      return;
-    }
-    setListLoading(true);
-    try {
-      const persisted = await app.ListDVDMenuScreenshots(sourcePath, overrides, nameOverrides);
-      const previews = await Promise.all(
-        (persisted || []).map(async (image): Promise<MenuPreview | null> => {
-          if (!image.Path || !app.ReadScreenshotImage) return null;
-          try {
-            return { image, dataURI: await app.ReadScreenshotImage(image.Path) };
-          } catch {
-            return null;
-          }
-        }),
-      );
-      if (refreshRequestRef.current !== requestID) return;
-      setImages(previews.filter((item): item is MenuPreview => item !== null));
-    } catch (loadError) {
-      if (refreshRequestRef.current === requestID) setError(errorText(loadError));
-    } finally {
-      if (refreshRequestRef.current === requestID) setListLoading(false);
-    }
-  }, [nameOverrides, overrides, sourcePath]);
-
-  useEffect(() => {
-    void refreshImages();
-  }, [refreshImages]);
-
-  useEffect(() => {
-    const previousSourcePath = previousSourcePathRef.current;
-    if (previousSourcePath === sourcePath) return;
-    previousSourcePathRef.current = sourcePath;
-
-    setCaptureStatus(null);
-    setError("");
-    setNotice("");
-
-    const staleStart = captureStartRef.current;
-    if (staleStart && staleStart.sourcePath !== sourcePath) {
-      captureStartRef.current = null;
-      setCaptureStart((current) => (current === staleStart ? null : current));
-    }
-
-    const staleJob = captureJobRef.current;
-    if (staleJob && staleJob.sourcePath !== sourcePath) {
-      captureJobRef.current = null;
-      setCaptureJob((current) => (current === staleJob ? null : current));
-      const cancel = globalThis.go?.guiapp?.App?.CancelDVDMenuCapture;
-      if (cancel) void cancel(staleJob.id).catch(() => undefined);
-    }
-  }, [sourcePath]);
-
-  useEffect(() => {
-    const targetIndex = focusAfterRemovalRef.current;
-    if (targetIndex === null) return;
-    focusAfterRemovalRef.current = null;
-    const target = images[Math.min(targetIndex, Math.max(images.length - 1, 0))];
-    window.requestAnimationFrame(() => {
-      if (target?.image.Path) {
-        removeButtonRefs.current.get(target.image.Path)?.focus();
-      } else {
-        captureButtonRef.current?.focus();
-      }
-    });
-  }, [images]);
-
-  useEffect(() => {
-    if (!currentCaptureJob) return;
-    let disposed = false;
-    let timer: number | undefined;
-
-    const poll = async () => {
-      try {
-        const loader = globalThis.go?.guiapp?.App?.GetDVDMenuCaptureSnapshot;
-        if (!loader) throw new Error("DVD menu capture status is unavailable");
-        const next = await loader(currentCaptureJob.id);
-        if (disposed) return;
-        setCaptureStatus({ sourcePath: currentCaptureJob.sourcePath, snapshot: next });
-        if (terminalStatuses.has(next.status)) {
-          if (next.status === "completed") {
-            await refreshImages();
-            if (disposed) return;
-            onImagesChanged();
-          } else if (next.error) {
-            setError(next.error);
-          }
-          if (captureJobRef.current === currentCaptureJob) captureJobRef.current = null;
-          setCaptureJob((current) => (current === currentCaptureJob ? null : current));
-          return;
-        }
-        timer = window.setTimeout(poll, 300);
-      } catch (pollError) {
-        if (!disposed) {
-          if (captureJobRef.current === currentCaptureJob) captureJobRef.current = null;
-          setCaptureJob((current) => (current === currentCaptureJob ? null : current));
-          setError(errorText(pollError));
-        }
-      }
-    };
-
-    void poll();
-    return () => {
-      disposed = true;
-      if (timer !== undefined) window.clearTimeout(timer);
-    };
-  }, [currentCaptureJob, onImagesChanged, refreshImages]);
-
-  const handleBrowseImages = async () => {
-    setError("");
-    try {
-      const app = globalThis.go?.guiapp?.App;
-      if (!app) return;
-      const selected = app.BrowseImageFiles
-        ? await app.BrowseImageFiles()
-        : app.BrowseFiles
-          ? await app.BrowseFiles()
-          : app.BrowseFile
-            ? [await app.BrowseFile()]
-            : [];
-      const valid = selected.map((value) => value.trim()).filter(Boolean);
-      if (valid.length > 0) {
-        setMenuPaths((previous) => Array.from(new Set([...previous, ...valid])));
-        setNotice("");
-      }
-    } catch (browseError) {
-      setError(errorText(browseError));
-    }
-  };
-
-  const handleImport = async () => {
-    if (menuPaths.length === 0) return;
-    setImporting(true);
-    setError("");
-    setNotice("");
-    try {
-      const importImages = globalThis.go?.guiapp?.App?.ImportMenuImages;
-      if (!importImages) throw new Error("Menu image import is unavailable");
-      await importImages(path, overrides, nameOverrides, menuPaths);
-      setMenuPaths([]);
-      setNotice("Menu images imported successfully.");
-      await refreshImages();
-      onImagesChanged();
-    } catch (importError) {
-      setError(errorText(importError));
-    } finally {
-      setImporting(false);
-    }
-  };
-
-  const handleCapture = async () => {
-    if (!sourcePath || captureStartRef.current?.sourcePath === sourcePath) return;
-    if (captureJobRef.current?.sourcePath === sourcePath) return;
-
-    const request: CaptureStart = { sourcePath };
-    captureStartRef.current = request;
-    setCaptureStart(request);
-    setError("");
-    setNotice("");
-    setCaptureStatus(null);
-    try {
-      const start = globalThis.go?.guiapp?.App?.StartDVDMenuCapture;
-      if (!start) throw new Error("DVD menu capture is unavailable");
-      const nextJobID = await start(sourcePath, overrides, nameOverrides);
-      if (captureStartRef.current !== request) {
-        const cancel = globalThis.go?.guiapp?.App?.CancelDVDMenuCapture;
-        if (cancel) await cancel(nextJobID).catch(() => undefined);
-        return;
-      }
-      const nextJob: CaptureJob = { id: nextJobID, sourcePath };
-      captureJobRef.current = nextJob;
-      setCaptureJob(nextJob);
-    } catch (captureError) {
-      if (captureStartRef.current === request) setError(errorText(captureError));
-    } finally {
-      if (captureStartRef.current === request) {
-        captureStartRef.current = null;
-        setCaptureStart(null);
-      }
-    }
-  };
-
-  const handleCancel = async () => {
-    if (!currentCaptureJob) return;
-    try {
-      const cancel = globalThis.go?.guiapp?.App?.CancelDVDMenuCapture;
-      if (!cancel) throw new Error("DVD menu capture cancellation is unavailable");
-      await cancel(currentCaptureJob.id);
-    } catch (cancelError) {
-      setError(errorText(cancelError));
-    }
-  };
-
-  const handleDelete = async (imagePath: string, index: number) => {
-    if (deletingPathsRef.current.has(imagePath)) return;
-    deletingPathsRef.current.add(imagePath);
-    setDeletingPaths(new Set(deletingPathsRef.current));
-    setError("");
-    try {
-      const remove = globalThis.go?.guiapp?.App?.DeleteDVDMenuScreenshot;
-      if (!remove) throw new Error("DVD menu image removal is unavailable");
-      await remove(path, overrides, nameOverrides, imagePath);
-      focusAfterRemovalRef.current = index;
-      await refreshImages();
-      onImagesChanged();
-      setNotice("Menu image removed.");
-    } catch (deleteError) {
-      setError(errorText(deleteError));
-    } finally {
-      deletingPathsRef.current.delete(imagePath);
-      setDeletingPaths(new Set(deletingPathsRef.current));
-    }
-  };
-
-  const completionMessage = useMemo(() => {
-    if (visibleSnapshot?.status !== "completed") return "";
-    if (visibleSnapshot.result.Truncated) return "Maximum reached";
-    return `Captured ${visibleSnapshot.capturedCount} DVD menu image${visibleSnapshot.capturedCount === 1 ? "" : "s"}.`;
-  }, [visibleSnapshot]);
-  const visibleCaptureWarnings =
-    visibleSnapshot?.result.Warnings?.filter(
-      (warning) => !hiddenCaptureWarningCodes.has(warning.Code),
-    ) ?? [];
-
-  return (
-    <section className="grid gap-4">
-      <header>
-        <p className="eyebrow">Disc Menus</p>
-        <h1>Menu Images</h1>
-        <p className="subtitle">
-          Capture DVD menus or import existing disc menu images for upload and descriptions.
-        </p>
-      </header>
-
-      {automaticCaptureAvailable ? (
-        <section className="panel grid gap-3" aria-busy={captureActive}>
-          <div>
-            <h2>Automatic DVD capture</h2>
-            <p className="muted">Capture up to {resolvedMaxMenuItems} distinct DVD menu screens.</p>
-          </div>
-          <div className="flex flex-wrap gap-2">
-            <button
-              ref={captureButtonRef}
-              className="primary"
-              type="button"
-              onClick={handleCapture}
-              disabled={captureActive || importing || !path.trim()}
-            >
-              {captureStarting ? "Starting..." : "Capture DVD menus"}
-            </button>
-            {captureActive ? (
-              <button className="ghost" type="button" onClick={handleCancel}>
-                Cancel
-              </button>
-            ) : null}
-          </div>
-          {visibleSnapshot ? (
-            <div className="grid gap-1" role="status" aria-live="polite">
-              <p className="m-0 font-medium">{visibleSnapshot.message || visibleSnapshot.phase}</p>
-              <p className="muted m-0">
-                Menus {visibleSnapshot.discoveredMenus} · States {visibleSnapshot.visitedStates} ·
-                Buttons {visibleSnapshot.visitedButtons} · Captured {visibleSnapshot.capturedCount}
-                {visibleCaptureWarnings.length > 0
-                  ? ` · Warnings ${visibleCaptureWarnings.length}`
-                  : ""}
-              </p>
-              {completionMessage ? <p className="success m-0">{completionMessage}</p> : null}
-              {visibleSnapshot.result.Truncated ? (
-                <p className="muted m-0">Configured maximum: {visibleSnapshot.result.MaxItems}.</p>
-              ) : null}
-              {visibleCaptureWarnings.map((warning) => (
-                <p className="muted m-0" key={warning.Code}>
-                  {warning.Message}
-                </p>
-              ))}
-            </div>
-          ) : null}
-        </section>
-      ) : (
-        <section className="panel">
-          <p className="muted">
-            Automatic capture is available for DVD sources. Manual disc menu import remains
-            available for {currentDiscType || "this source"}.
-          </p>
-        </section>
-      )}
-
-      <section className="panel grid gap-3">
-        <div>
-          <h2>Import menu images</h2>
-          <p className="muted">Select PNG, JPEG, or WebP menu images from this computer.</p>
-        </div>
-        <div className="flex flex-wrap gap-2">
-          {browseAvailable ? (
-            <button
-              className="ghost"
-              type="button"
-              onClick={handleBrowseImages}
-              disabled={importing}
-            >
-              Add images
-            </button>
-          ) : (
-            <p className="muted">Native file browsing is only available locally.</p>
-          )}
-          <button
-            className="primary"
-            type="button"
-            onClick={handleImport}
-            disabled={importing || menuPaths.length === 0 || captureActive}
-          >
-            {importing ? "Importing..." : "Import images"}
-          </button>
-        </div>
-        {menuPaths.length > 0 ? (
-          <ul className="m-0 grid list-none gap-1 p-0">
-            {menuPaths.map((selectedPath) => (
-              <li
-                className="flex items-center justify-between gap-2 rounded border border-white/10 bg-white/5 p-2"
-                key={selectedPath}
-              >
-                <span className="min-w-0 break-all">{selectedPath}</span>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() =>
-                    setMenuPaths((previous) => previous.filter((item) => item !== selectedPath))
-                  }
-                >
-                  Remove
-                </button>
-              </li>
-            ))}
-          </ul>
-        ) : null}
-      </section>
-
-      {error ? (
-        <p className="error" role="alert">
-          {error}
-        </p>
-      ) : null}
-      {notice ? (
-        <p className="success" role="status" aria-live="polite">
-          {notice}
-        </p>
-      ) : null}
-
-      <section className="panel grid gap-3">
-        <div className="flex flex-wrap items-baseline justify-between gap-2">
-          <h2>Saved menu images</h2>
-          <p className="muted">{listLoading ? "Loading..." : `${images.length} saved`}</p>
-        </div>
-        {images.length > 0 ? (
-          <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-3">
-            {images.map((item, index) => {
-              const itemNumber = index + 1;
-              const deleting = deletingPaths.has(item.image.Path);
-              return (
-                <article className="grid gap-2" key={item.image.Path}>
-                  <button
-                    className="screens-thumb"
-                    type="button"
-                    aria-label={`Preview DVD menu ${itemNumber}`}
-                    onClick={() => {
-                      setLightboxImage(item.dataURI);
-                      setLightboxAlt(`DVD menu ${itemNumber}`);
-                    }}
-                  >
-                    <img src={item.dataURI} alt="" />
-                  </button>
-                  <button
-                    ref={(element) => {
-                      if (element) removeButtonRefs.current.set(item.image.Path, element);
-                      else removeButtonRefs.current.delete(item.image.Path);
-                    }}
-                    className="danger"
-                    type="button"
-                    aria-label={`Remove DVD menu ${itemNumber}`}
-                    disabled={deleting || captureActive}
-                    onClick={() => handleDelete(item.image.Path, index)}
-                  >
-                    {deleting ? "Removing..." : "Remove"}
-                  </button>
-                </article>
-              );
-            })}
-          </div>
-        ) : (
-          <p className="muted">No saved menu images yet.</p>
-        )}
-      </section>
-
-      <div className="flex justify-end">
-        <button className="primary" type="button" onClick={onContinue}>
-          Continue to Upload Images
-        </button>
-      </div>
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/playlist_selection/index.tsx b/gui/frontend/src/pages/playlist_selection/index.tsx
deleted file mode 100644
index f7235221..00000000
--- a/gui/frontend/src/pages/playlist_selection/index.tsx
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useCallback, useEffect, useState } from "react";
-import { Button } from "../../components/ui/button";
-import { Checkbox } from "../../components/ui/checkbox";
-import type { PlaylistInfo } from "../../types";
-
-interface PlaylistSelectionPageProps {
-  path: string;
-  onBack: () => void;
-  onConfirm: () => Promise<void>;
-  preparing: boolean;
-  progressLines: string[];
-  progressError: string;
-}
-
-const PlaylistSelectionPage = ({
-  path,
-  onBack,
-  onConfirm,
-  preparing,
-  progressLines,
-  progressError,
-}: PlaylistSelectionPageProps) => {
-  const [loading, setLoading] = useState(true);
-  const [playlists, setPlaylists] = useState<PlaylistInfo[]>([]);
-  const [selectedIndices, setSelectedIndices] = useState<Set<number>>(new Set());
-  const [useAll, setUseAll] = useState(false);
-  const [error, setError] = useState("");
-  const [saving, setSaving] = useState(false);
-
-  const discoverPlaylists = useCallback(async () => {
-    try {
-      setLoading(true);
-      setError("");
-      const discover = globalThis.go?.guiapp?.App?.DiscoverPlaylists;
-      if (!discover) {
-        throw new Error("DiscoverPlaylists API not available");
-      }
-      const discovered = await discover(path);
-      if (discovered) {
-        // Sort by score descending (highest first) and take top 10.
-        const sorted = discovered.sort((a, b) => (b.score || 0) - (a.score || 0)).slice(0, 10);
-        setPlaylists(sorted);
-        if (sorted.length === 1) {
-          setSelectedIndices(new Set([0]));
-        }
-      } else {
-        setPlaylists([]);
-      }
-    } catch (err) {
-      setError(`Failed to discover playlists: ${err instanceof Error ? err.message : String(err)}`);
-    } finally {
-      setLoading(false);
-    }
-  }, [path]);
-
-  useEffect(() => {
-    discoverPlaylists();
-  }, [discoverPlaylists]);
-
-  const handleTogglePlaylist = (index: number) => {
-    setUseAll(false);
-    const newSelected = new Set(selectedIndices);
-    if (newSelected.has(index)) {
-      newSelected.delete(index);
-    } else {
-      newSelected.add(index);
-    }
-    setSelectedIndices(newSelected);
-  };
-
-  const handleSelectAll = () => {
-    if (useAll) {
-      setUseAll(false);
-      setSelectedIndices(new Set());
-    } else {
-      setUseAll(true);
-      const all = new Set<number>();
-      for (let i = 0; i < playlists.length; i++) {
-        all.add(i);
-      }
-      setSelectedIndices(all);
-    }
-  };
-
-  const handleAutoSelect = () => {
-    setUseAll(false);
-    setSelectedIndices(new Set([0]));
-  };
-
-  const handleConfirm = async () => {
-    try {
-      setSaving(true);
-      setError("");
-
-      const selected = Array.from(selectedIndices)
-        .sort((a, b) => a - b)
-        .map((idx) => playlists[idx].file);
-
-      if (selected.length === 0) {
-        setError("Please select at least one playlist");
-        return;
-      }
-
-      const saveFn = globalThis.go?.guiapp?.App?.SavePlaylistSelection;
-      if (!saveFn) {
-        throw new Error("SavePlaylistSelection API not available");
-      }
-
-      await saveFn(path, selected, useAll);
-      await onConfirm();
-    } catch (err) {
-      setError(`Failed to save selection: ${err instanceof Error ? err.message : String(err)}`);
-    } finally {
-      setSaving(false);
-    }
-  };
-
-  const displayCount = playlists.length;
-
-  if (loading) {
-    return (
-      <div className="mx-auto max-w-2xl p-3">
-        <div className="panel">
-          <h2>Discovering Playlists</h2>
-          <p className="muted mt-1 text-sm">Scanning {path} for MPLS files...</p>
-        </div>
-      </div>
-    );
-  }
-
-  if (playlists.length === 0) {
-    return (
-      <div className="mx-auto max-w-2xl p-3">
-        <div className="panel">
-          <h2>No Playlists Found</h2>
-          <p className="muted mt-1 text-sm">No MPLS playlists were found in {path}</p>
-          <div className="mt-3 flex justify-end">
-            <Button onClick={onBack} type="button">
-              Back
-            </Button>
-          </div>
-        </div>
-      </div>
-    );
-  }
-
-  return (
-    <div className="mx-auto max-w-2xl p-3">
-      <div className="panel">
-        <h2>Select BDMV Playlists</h2>
-        <p className="muted mt-1 text-sm [overflow-wrap:anywhere]">
-          Choose which playlists to use for {path}
-        </p>
-
-        {error ? (
-          <div className="mt-3 rounded border-l-4 border-red-500 bg-red-500/10 px-3 py-2 text-sm text-red-100">
-            {error}
-          </div>
-        ) : null}
-        {progressError ? (
-          <div className="mt-3 rounded border-l-4 border-red-500 bg-red-500/10 px-3 py-2 text-sm text-red-100">
-            {progressError}
-          </div>
-        ) : null}
-
-        <div className="my-3 overflow-hidden rounded-md border border-white/10">
-          {playlists.slice(0, displayCount).map((playlist, index) => {
-            const totalSize = playlist.items?.reduce((sum, item) => sum + item.size, 0) || 0;
-            const fileCount = playlist.items?.length || 0;
-            const checkboxId = `playlist-${index}`;
-            return (
-              <div
-                key={playlist.file}
-                className="grid gap-1 border-b border-white/10 px-3 py-2 last:border-b-0 hover:bg-white/5"
-              >
-                <div className="flex select-none items-center gap-2">
-                  <Checkbox
-                    id={checkboxId}
-                    checked={selectedIndices.has(index)}
-                    onCheckedChange={() => handleTogglePlaylist(index)}
-                    disabled={saving}
-                  />
-                  <label
-                    className="cursor-pointer font-semibold text-[var(--text)]"
-                    htmlFor={checkboxId}
-                  >
-                    {playlist.file}
-                  </label>
-                </div>
-                <span className="ml-6 text-xs text-[var(--muted)]">
-                  {formatDuration(playlist.duration)} • {fileCount} files • {formatBytes(totalSize)}{" "}
-                  • Score: {playlist.score.toFixed(2)}
-                </span>
-              </div>
-            );
-          })}
-        </div>
-
-        {playlists.length > 1 ? (
-          <div className="my-3 flex flex-wrap gap-2">
-            <Button onClick={handleSelectAll} type="button" disabled={saving || displayCount === 0}>
-              {useAll ? "Deselect All" : `Select All Top ${displayCount}`}
-            </Button>
-            <Button onClick={handleAutoSelect} type="button" disabled={saving}>
-              Auto-Select Best
-            </Button>
-          </div>
-        ) : null}
-
-        <div className="mt-3 flex justify-end gap-2">
-          <Button onClick={onBack} type="button" disabled={saving}>
-            Back
-          </Button>
-          <Button
-            onClick={handleConfirm}
-            variant="primary"
-            type="button"
-            disabled={saving || selectedIndices.size === 0}
-          >
-            {saving ? (preparing ? "Preparing..." : "Saving...") : "Confirm Selection"}
-          </Button>
-        </div>
-
-        {preparing ? (
-          <div
-            className="mt-3 rounded-md border border-white/10 bg-white/5 p-2"
-            role="status"
-            aria-live="polite"
-          >
-            <h3 className="mb-1 text-sm font-semibold">BDInfo progress</h3>
-            <pre className="m-0 max-h-40 overflow-auto whitespace-pre-wrap text-xs text-[var(--muted)] [overflow-wrap:anywhere]">
-              {progressLines.length > 0 ? progressLines.join("\n") : "Starting BDInfo..."}
-            </pre>
-          </div>
-        ) : null}
-      </div>
-    </div>
-  );
-};
-
-export default PlaylistSelectionPage;
-
-const formatDuration = (seconds: number): string => {
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor((seconds % 3600) / 60);
-  const s = Math.floor(seconds % 60);
-
-  if (h > 0) {
-    return `${h}h ${m}m ${s}s`;
-  }
-  if (m > 0) {
-    return `${m}m ${s}s`;
-  }
-  return `${s}s`;
-};
-
-const formatBytes = (bytes: number): string => {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
-};
diff --git a/gui/frontend/src/pages/screenshots/index.tsx b/gui/frontend/src/pages/screenshots/index.tsx
deleted file mode 100644
index 65fc6faa..00000000
--- a/gui/frontend/src/pages/screenshots/index.tsx
+++ /dev/null
@@ -1,729 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { Dispatch, SetStateAction } from "react";
-import { Switch } from "../../components/ui/switch";
-import type {
-  ConfigMap,
-  ConfigValue,
-  ScreenshotImage,
-  ScreenshotPlan,
-  ScreenshotPreviewImage,
-  ScreenshotResult,
-  ScreenshotSelection,
-} from "../../types";
-
-type Props = Readonly<{
-  path: string;
-  screenshotPlan: ScreenshotPlan | null;
-  screenshotsLoading: boolean;
-  screenshotsError: string;
-  loadScreenshotPlan: (revealSelections?: boolean) => void;
-  handleGenerateScreenshots: () => void;
-  screenshotConfig: ConfigMap | null;
-  updateScreenshotConfigValue: (key: string, value: ConfigValue) => void;
-  loadSettings: () => void;
-  settingsLoading: boolean;
-  applyScreenshotSettings: () => void;
-  settingsDirty: boolean;
-  screenshotsSettingsSaving: boolean;
-  livePreviewSeconds: number;
-  setLivePreviewSeconds: Dispatch<SetStateAction<number>>;
-  livePreviewFrame: number;
-  previewDuration: number;
-  previewFrameRate: number;
-  clampPreviewSeconds: (value: number) => number;
-  stepLivePreview: (direction: number) => void;
-  runLivePreview: () => void;
-  livePreviewLoading: boolean;
-  liveCaptureLoading: boolean;
-  handleCapturePreviewFrame: () => void;
-  livePreviewError: string;
-  livePreviewImage: string;
-  setLightboxImage: Dispatch<SetStateAction<string>>;
-  setLightboxAlt: Dispatch<SetStateAction<string>>;
-  trackerImageURLs: string[];
-  handleDeleteAllTrackerImageURLs: () => void;
-  handleDeleteTrackerImage: (url: string) => void;
-  existingImages: ScreenshotPreviewImage[];
-  addFinalSelection: (item: ScreenshotPreviewImage) => void;
-  isFinalImageSelected: (pathValue: string) => boolean;
-  removeFinalSelection: (imagePath: string) => void;
-  handleDeleteAllExistingImages: () => void;
-  existingTrackerImages: ScreenshotPreviewImage[];
-  handleDeleteAllTrackerImages: () => void;
-  handleDeleteExistingImage: (image: ScreenshotImage) => void;
-  showFrameSelections: boolean;
-  screenshotSelections: ScreenshotSelection[];
-  updateSelectionTime: (index: number, value: string) => void;
-  updateSelectionFrame: (index: number, value: string) => void;
-  handlePreviewSelection: (selection: ScreenshotSelection) => void;
-  previewLoadingIndex: number | null;
-  previewImages: ScreenshotPreviewImage[];
-  handleDeleteAllPreviewImages: () => void;
-  finalImages: ScreenshotPreviewImage[];
-  finalDragIndex: number | null;
-  setFinalDragIndex: Dispatch<SetStateAction<number | null>>;
-  reorderFinalSelections: (fromIndex: number, toIndex: number) => void;
-  finalResult: ScreenshotResult | null;
-  handleDeleteAllFinalImages: () => void;
-}>;
-
-export default function ScreenshotsPage(props: Props) {
-  const {
-    path,
-    screenshotPlan,
-    screenshotsLoading,
-    screenshotsError,
-    loadScreenshotPlan,
-    handleGenerateScreenshots,
-    screenshotConfig,
-    updateScreenshotConfigValue,
-    loadSettings,
-    settingsLoading,
-    applyScreenshotSettings,
-    settingsDirty,
-    screenshotsSettingsSaving,
-    livePreviewSeconds,
-    setLivePreviewSeconds,
-    livePreviewFrame,
-    previewDuration,
-    previewFrameRate,
-    clampPreviewSeconds,
-    stepLivePreview,
-    runLivePreview,
-    livePreviewLoading,
-    liveCaptureLoading,
-    handleCapturePreviewFrame,
-    livePreviewError,
-    livePreviewImage,
-    setLightboxImage,
-    setLightboxAlt,
-    trackerImageURLs,
-    handleDeleteAllTrackerImageURLs,
-    handleDeleteTrackerImage,
-    existingImages,
-    addFinalSelection,
-    isFinalImageSelected,
-    removeFinalSelection,
-    handleDeleteAllExistingImages,
-    existingTrackerImages,
-    handleDeleteAllTrackerImages,
-    handleDeleteExistingImage,
-    showFrameSelections,
-    screenshotSelections,
-    updateSelectionTime,
-    updateSelectionFrame,
-    handlePreviewSelection,
-    previewLoadingIndex,
-    previewImages,
-    handleDeleteAllPreviewImages,
-    finalImages,
-    finalDragIndex,
-    setFinalDragIndex,
-    reorderFinalSelections,
-    finalResult,
-    handleDeleteAllFinalImages,
-  } = props;
-  const previewTimingDisabled = previewDuration <= 0 || previewFrameRate <= 0;
-
-  return (
-    <section className="screens-panel">
-      <header className="screens-header">
-        <p className="eyebrow">Screenshots</p>
-        <h1>Plan & Capture</h1>
-        <p className="subtitle">
-          Review tracker images, adjust frame times, and generate screenshots.
-        </p>
-      </header>
-
-      <section className="panel screens-actions">
-        <div>
-          <p className="label">Source path</p>
-          <p className="value dupe-path">{path || "No path selected"}</p>
-          {screenshotPlan ? (
-            <div className="screens-meta">
-              <p className="muted">Duration: {screenshotPlan.DurationSeconds.toFixed(1)}s</p>
-              <p className="muted">Frame rate: {screenshotPlan.FrameRate.toFixed(3)}</p>
-              {screenshotPlan.DiscType ? (
-                <p className="muted">Disc type: {screenshotPlan.DiscType}</p>
-              ) : null}
-            </div>
-          ) : null}
-        </div>
-        <div className="screens-actions__buttons">
-          <button
-            className="ghost"
-            type="button"
-            onClick={() => loadScreenshotPlan(true)}
-            disabled={screenshotsLoading || !path.trim()}
-          >
-            {screenshotsLoading ? "Loading..." : "Load suggestions"}
-          </button>
-          <button
-            className="primary"
-            type="button"
-            onClick={handleGenerateScreenshots}
-            disabled={screenshotsLoading || !path.trim()}
-          >
-            {screenshotsLoading ? "Capturing..." : "Generate screenshots"}
-          </button>
-        </div>
-      </section>
-
-      <section className="panel screens-settings">
-        <details>
-          <summary>Screenshot settings</summary>
-          {screenshotConfig ? (
-            <div className="screens-settings__grid">
-              <label className="settings-field">
-                <span>Screenshot count</span>
-                <input
-                  type="number"
-                  value={
-                    typeof screenshotConfig.Screens === "number" ? screenshotConfig.Screens : 0
-                  }
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("Screens", Number(event.target.value))
-                  }
-                />
-              </label>
-              <div className="settings-toggle">
-                <span>Tonemap HDR</span>
-                <Switch
-                  aria-label="Tonemap HDR"
-                  checked={Boolean(screenshotConfig.ToneMap)}
-                  onChange={(event) => updateScreenshotConfigValue("ToneMap", event.target.checked)}
-                />
-              </div>
-              <div className="settings-toggle">
-                <span>Use libplacebo</span>
-                <Switch
-                  aria-label="Use libplacebo"
-                  checked={Boolean(screenshotConfig.UseLibplacebo)}
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("UseLibplacebo", event.target.checked)
-                  }
-                />
-              </div>
-              <div className="settings-toggle">
-                <span>Frame overlay</span>
-                <Switch
-                  aria-label="Frame overlay"
-                  checked={Boolean(screenshotConfig.FrameOverlay)}
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("FrameOverlay", event.target.checked)
-                  }
-                />
-              </div>
-              <label className="settings-field">
-                <span>Overlay text size</span>
-                <input
-                  type="number"
-                  value={
-                    typeof screenshotConfig.OverlayTextSize === "number"
-                      ? screenshotConfig.OverlayTextSize
-                      : 0
-                  }
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("OverlayTextSize", Number(event.target.value))
-                  }
-                />
-              </label>
-              <label className="settings-field">
-                <span>FFmpeg compression</span>
-                <input
-                  type="number"
-                  value={
-                    typeof screenshotConfig.FFmpegCompression === "number"
-                      ? screenshotConfig.FFmpegCompression
-                      : 0
-                  }
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("FFmpegCompression", Number(event.target.value))
-                  }
-                />
-              </label>
-              <label className="settings-field">
-                <span>Tonemap algorithm</span>
-                <input
-                  type="text"
-                  value={
-                    typeof screenshotConfig.TonemapAlgorithm === "string"
-                      ? screenshotConfig.TonemapAlgorithm
-                      : ""
-                  }
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("TonemapAlgorithm", event.target.value)
-                  }
-                />
-              </label>
-              <label className="settings-field">
-                <span>Desat</span>
-                <input
-                  type="number"
-                  step="0.01"
-                  value={typeof screenshotConfig.Desat === "number" ? screenshotConfig.Desat : 0}
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("Desat", Number(event.target.value))
-                  }
-                />
-              </label>
-              <div className="settings-toggle">
-                <span>Limit ffmpeg concurrency</span>
-                <Switch
-                  aria-label="Limit ffmpeg concurrency"
-                  checked={Boolean(screenshotConfig.FFmpegLimit)}
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("FFmpegLimit", event.target.checked)
-                  }
-                />
-              </div>
-              <label className="settings-field">
-                <span>FFmpeg concurrency</span>
-                <input
-                  type="number"
-                  value={
-                    typeof screenshotConfig.ProcessLimit === "number"
-                      ? screenshotConfig.ProcessLimit
-                      : 1
-                  }
-                  onChange={(event) =>
-                    updateScreenshotConfigValue("ProcessLimit", Number(event.target.value))
-                  }
-                />
-              </label>
-            </div>
-          ) : (
-            <p className="muted">Load settings to edit screenshot handling.</p>
-          )}
-          <div className="screens-settings__actions">
-            <button
-              className="ghost"
-              type="button"
-              onClick={loadSettings}
-              disabled={settingsLoading}
-            >
-              {settingsLoading ? "Loading..." : "Reload settings"}
-            </button>
-            <button
-              className="primary"
-              type="button"
-              onClick={applyScreenshotSettings}
-              disabled={settingsLoading || screenshotsSettingsSaving || !settingsDirty}
-            >
-              {screenshotsSettingsSaving ? "Applying..." : "Apply settings"}
-            </button>
-          </div>
-        </details>
-      </section>
-
-      {screenshotsError ? <p className="error">{screenshotsError}</p> : null}
-
-      {screenshotPlan?.RequiresManualFrames ? (
-        <p className="muted">
-          Duration or frame rate is missing. Enter manual frame times before capturing.
-        </p>
-      ) : null}
-
-      <section className="panel screens-preview">
-        <div className="screens-gallery__header">
-          <h2>Live Preview</h2>
-          <p className="muted">Scrub the timeline and capture the current frame.</p>
-        </div>
-        {screenshotPlan ? (
-          <div className="screens-preview__body">
-            <div className="screens-preview__controls">
-              <label className="screens-field">
-                <span>Seconds</span>
-                <input
-                  type="number"
-                  step="0.1"
-                  value={Number.isFinite(livePreviewSeconds) ? livePreviewSeconds : 0}
-                  onChange={(event) =>
-                    setLivePreviewSeconds(clampPreviewSeconds(Number(event.target.value)))
-                  }
-                />
-              </label>
-              <label className="screens-field">
-                <span>Frame</span>
-                <input
-                  type="number"
-                  step="1"
-                  value={livePreviewFrame}
-                  onChange={(event) => {
-                    const nextFrame = Number(event.target.value);
-                    if (Number.isFinite(nextFrame) && previewFrameRate > 0) {
-                      setLivePreviewSeconds(clampPreviewSeconds(nextFrame / previewFrameRate));
-                    } else {
-                      setLivePreviewSeconds(0);
-                    }
-                  }}
-                />
-              </label>
-              <div className="screens-preview__slider">
-                <input
-                  type="range"
-                  min={0}
-                  max={Math.max(previewDuration, 0)}
-                  step={1 / previewFrameRate}
-                  value={clampPreviewSeconds(livePreviewSeconds)}
-                  onChange={(event) =>
-                    setLivePreviewSeconds(clampPreviewSeconds(Number(event.target.value)))
-                  }
-                  disabled={previewTimingDisabled}
-                />
-                <div className="screens-preview__meta">
-                  <span className="muted">Duration: {previewDuration.toFixed(1)}s</span>
-                  <span className="muted">FPS: {previewFrameRate.toFixed(3)}</span>
-                </div>
-              </div>
-              <div className="screens-preview__buttons">
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() => stepLivePreview(-1)}
-                  disabled={previewTimingDisabled}
-                >
-                  Prev frame
-                </button>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() => stepLivePreview(1)}
-                  disabled={previewTimingDisabled}
-                >
-                  Next frame
-                </button>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={runLivePreview}
-                  disabled={previewTimingDisabled || livePreviewLoading}
-                >
-                  {livePreviewLoading ? "Loading..." : "Run preview"}
-                </button>
-                <button
-                  className="primary"
-                  type="button"
-                  onClick={handleCapturePreviewFrame}
-                  disabled={previewTimingDisabled || liveCaptureLoading}
-                >
-                  {liveCaptureLoading ? "Capturing..." : "Capture preview"}
-                </button>
-              </div>
-            </div>
-            {livePreviewError ? <p className="error">{livePreviewError}</p> : null}
-            <div className="screens-preview__image">
-              {livePreviewImage ? (
-                <div style={{ position: "relative" }}>
-                  <button
-                    className="screens-thumb"
-                    type="button"
-                    onClick={() => {
-                      setLightboxImage(livePreviewImage);
-                      setLightboxAlt("Live preview");
-                    }}
-                    style={livePreviewLoading ? { opacity: 0.6 } : {}}
-                  >
-                    <img src={livePreviewImage} alt="Live preview" />
-                  </button>
-                  {livePreviewLoading && (
-                    <div
-                      style={{
-                        position: "absolute",
-                        top: "50%",
-                        left: "50%",
-                        transform: "translate(-50%, -50%)",
-                        pointerEvents: "none",
-                        color: "white",
-                        textShadow: "0 0 4px black",
-                        fontWeight: "bold",
-                      }}
-                    >
-                      Loading...
-                    </div>
-                  )}
-                </div>
-              ) : livePreviewLoading ? (
-                <p className="muted">Loading preview...</p>
-              ) : (
-                <p className="muted">No preview yet.</p>
-              )}
-            </div>
-          </div>
-        ) : (
-          <p className="muted">Load suggestions to enable live preview.</p>
-        )}
-      </section>
-
-      {trackerImageURLs.length > 0 ? (
-        <section className="panel screens-gallery">
-          <div className="screens-gallery__header">
-            <h2>Tracker Images</h2>
-            <p className="muted">Already available from tracker data.</p>
-            <button className="ghost" type="button" onClick={handleDeleteAllTrackerImageURLs}>
-              Delete all
-            </button>
-          </div>
-          <div className="screens-grid">
-            {trackerImageURLs.map((url, index) => (
-              <div className="screens-thumb-card" key={`${url}-${index}`}>
-                <button
-                  className="screens-thumb"
-                  type="button"
-                  onClick={() => {
-                    setLightboxImage(url);
-                    setLightboxAlt("Tracker image");
-                  }}
-                >
-                  <img src={url} alt="Tracker screenshot" loading="lazy" />
-                </button>
-                <button
-                  className="screens-thumb-delete"
-                  type="button"
-                  onClick={() => handleDeleteTrackerImage(url)}
-                >
-                  Delete
-                </button>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      {existingImages.length > 0 ? (
-        <section className="panel screens-gallery">
-          <div className="screens-gallery__header">
-            <h2>Existing Captures</h2>
-            <p className="muted">Previously generated screenshots in the temp folder.</p>
-            <button className="ghost" type="button" onClick={handleDeleteAllExistingImages}>
-              Delete all
-            </button>
-          </div>
-          <div className="screens-grid">
-            {existingImages.map((item) => (
-              <div
-                className="screens-thumb-card"
-                key={`existing-${item.image.Path || item.image.Index}`}
-              >
-                <button
-                  className="screens-thumb"
-                  type="button"
-                  onClick={() => {
-                    setLightboxImage(item.dataUri);
-                    setLightboxAlt(`Existing ${item.image.Index + 1}`);
-                  }}
-                >
-                  <img src={item.dataUri} alt={`Existing ${item.image.Index + 1}`} />
-                </button>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() => addFinalSelection(item)}
-                  disabled={isFinalImageSelected(item.image.Path)}
-                >
-                  {isFinalImageSelected(item.image.Path) ? "Added" : "Add to final"}
-                </button>
-                <button
-                  className="screens-thumb-delete"
-                  type="button"
-                  onClick={() => removeFinalSelection(item.image.Path)}
-                >
-                  Remove
-                </button>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      {existingTrackerImages.length > 0 ? (
-        <section className="panel screens-gallery">
-          <div className="screens-gallery__header">
-            <h2>Tracker Temp Images</h2>
-            <p className="muted">Images stored in tracker temp folders.</p>
-            <button className="ghost" type="button" onClick={handleDeleteAllTrackerImages}>
-              Delete all
-            </button>
-          </div>
-          <div className="screens-grid">
-            {existingTrackerImages.map((item) => (
-              <div
-                className="screens-thumb-card"
-                key={`tracker-${item.image.Path || item.image.Index}`}
-              >
-                <button
-                  className="screens-thumb"
-                  type="button"
-                  onClick={() => {
-                    setLightboxImage(item.dataUri);
-                    setLightboxAlt("Tracker temp image");
-                  }}
-                >
-                  <img src={item.dataUri} alt="Tracker temp screenshot" />
-                </button>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() => addFinalSelection(item)}
-                  disabled={isFinalImageSelected(item.image.Path)}
-                >
-                  {isFinalImageSelected(item.image.Path) ? "Added" : "Add to final"}
-                </button>
-                <button
-                  className="screens-thumb-delete"
-                  type="button"
-                  onClick={() => handleDeleteExistingImage(item.image)}
-                >
-                  Delete
-                </button>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      <section className="panel screens-list">
-        <div className="screens-gallery__header">
-          <h2>Frame Selection</h2>
-          <p className="muted">Adjust timestamps or frame numbers, then preview.</p>
-        </div>
-        {!showFrameSelections ? (
-          <p className="muted">Load suggestions to edit frame selections.</p>
-        ) : screenshotSelections.length === 0 ? (
-          <p className="muted">No selections available yet.</p>
-        ) : (
-          <div className="screens-rows">
-            {screenshotSelections.map((selection) => (
-              <div className="screens-row" key={`sel-${selection.Index}`}>
-                <div>
-                  <p className="label">Shot {selection.Index + 1}</p>
-                  <p className="muted">Source: {selection.Source || "auto"}</p>
-                </div>
-                <label className="screens-field">
-                  <span>Seconds</span>
-                  <input
-                    type="number"
-                    step="0.1"
-                    value={
-                      Number.isFinite(selection.TimestampSeconds) ? selection.TimestampSeconds : 0
-                    }
-                    onChange={(event) => updateSelectionTime(selection.Index, event.target.value)}
-                  />
-                </label>
-                <label className="screens-field">
-                  <span>Frame</span>
-                  <input
-                    type="number"
-                    step="1"
-                    value={Number.isFinite(selection.Frame) ? selection.Frame : 0}
-                    onChange={(event) => updateSelectionFrame(selection.Index, event.target.value)}
-                  />
-                </label>
-                <button
-                  className="ghost"
-                  type="button"
-                  onClick={() => handlePreviewSelection(selection)}
-                  disabled={previewLoadingIndex === selection.Index}
-                >
-                  {previewLoadingIndex === selection.Index ? "Previewing..." : "Preview"}
-                </button>
-              </div>
-            ))}
-          </div>
-        )}
-      </section>
-
-      {previewImages.length > 0 ? (
-        <section className="panel screens-gallery">
-          <div className="screens-gallery__header">
-            <h2>Preview Captures</h2>
-            <p className="muted">Click any image to view full size.</p>
-            <button className="ghost" type="button" onClick={handleDeleteAllPreviewImages}>
-              Delete all
-            </button>
-          </div>
-          <div className="screens-grid">
-            {previewImages.map((item) => (
-              <button
-                className="screens-thumb"
-                type="button"
-                key={`preview-${item.image.Index}`}
-                onClick={() => {
-                  setLightboxImage(item.dataUri);
-                  setLightboxAlt(`Preview ${item.image.Index + 1}`);
-                }}
-              >
-                <img src={item.dataUri} alt={`Preview ${item.image.Index + 1}`} />
-              </button>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      {finalImages.length > 0 ? (
-        <section className="panel screens-gallery">
-          <div className="screens-gallery__header">
-            <h2>Final Captures</h2>
-            <p className="muted">Generated screenshots ready for upload.</p>
-            <button className="ghost" type="button" onClick={handleDeleteAllFinalImages}>
-              Delete all
-            </button>
-          </div>
-          <div className="screens-grid">
-            {finalImages.map((item, index) => (
-              <div
-                className="screens-thumb-card"
-                key={`final-${item.image.Path || item.image.Index}`}
-              >
-                <button
-                  className="screens-thumb"
-                  type="button"
-                  draggable
-                  onDragStart={() => setFinalDragIndex(index)}
-                  onDragOver={(event) => event.preventDefault()}
-                  onDrop={(event) => {
-                    event.preventDefault();
-                    if (finalDragIndex === null) return;
-                    reorderFinalSelections(finalDragIndex, index);
-                    setFinalDragIndex(null);
-                  }}
-                  onDragEnd={() => setFinalDragIndex(null)}
-                  onClick={() => {
-                    setLightboxImage(item.dataUri);
-                    setLightboxAlt(`Screenshot ${index + 1}`);
-                  }}
-                >
-                  <img src={item.dataUri} alt={`Screenshot ${index + 1}`} />
-                </button>
-                <button
-                  className="screens-thumb-delete"
-                  type="button"
-                  onClick={() => handleDeleteExistingImage(item.image)}
-                >
-                  Delete
-                </button>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      {finalResult?.Errors?.length ? (
-        <section className="panel screens-errors">
-          <div className="screens-gallery__header">
-            <h2>Capture Warnings</h2>
-          </div>
-          <ul>
-            {finalResult.Errors.map((entry, index) => (
-              <li key={`err-${entry.Index}-${index}`}>
-                Shot {entry.Index + 1}: {entry.Message}
-              </li>
-            ))}
-          </ul>
-        </section>
-      ) : null}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/settings/index.test.tsx b/gui/frontend/src/pages/settings/index.test.tsx
deleted file mode 100644
index 2efe8da9..00000000
--- a/gui/frontend/src/pages/settings/index.test.tsx
+++ /dev/null
@@ -1,1237 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { screen, within } from "@testing-library/dom";
-import { cleanup, render, waitFor } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import SettingsPage from ".";
-import type { ConfigValue } from "../../types";
-
-const baseProps = {
-  configData: { MainSettings: { Instance: "default" }, Trackers: {} },
-  settingsLoading: false,
-  settingsExporting: false,
-  settingsImporting: false,
-  settingsDirty: false,
-  settingsSaved: "",
-  settingsError: "",
-  trackerSelectionNames: [
-    "AR",
-    "BTN",
-    "COOKIE",
-    "FAST",
-    "FF",
-    "FL",
-    "HDB",
-    "MTV",
-    "PTP",
-    "RTF",
-    "THR",
-    "SLOW",
-    "ASC",
-    "PLAINAPI",
-    "PLAINPASS",
-  ],
-  configOpStatus: null,
-  dismissConfigOpStatus: vi.fn(),
-  settingsSection: "main_settings",
-  settingsSections: [
-    { key: "main_settings", jsonKey: "MainSettings", label: "Main" },
-    { key: "trackers", jsonKey: "Trackers", label: "Trackers" },
-  ],
-  showAdvancedToggle: false,
-  advancedOpen: false,
-  setSettingsAdvanced: vi.fn(),
-  loadSettings: vi.fn(),
-  handleExportSettings: vi.fn(),
-  handleImportConfig: vi.fn(),
-  importConfirmOpen: false,
-  handleImportConfigConfirm: vi.fn(),
-  handleImportConfigCancel: vi.fn(),
-  handleSaveSettings: vi.fn(),
-  webAuthAvailable: false,
-  webAuthStatus: null,
-  webAuthLoading: false,
-  webAuthCreating: false,
-  webAuthUsername: "",
-  webAuthPassword: "",
-  webAuthConfirm: "",
-  webAuthError: "",
-  setWebAuthUsername: vi.fn(),
-  setWebAuthPassword: vi.fn(),
-  setWebAuthConfirm: vi.fn(),
-  handleCreateWebAuth: vi.fn(),
-  renderImageHostingSection: vi.fn(() => null),
-  renderTrackerSection: vi.fn(() => null),
-  renderTorrentClientsSection: vi.fn(() => null),
-  renderField: vi.fn((label: string, _value: ConfigValue, path: string[]) => (
-    <div key={path.join(".")}>{label}</div>
-  )),
-  sectionFieldMeta: {},
-};
-
-const trackerAuthCapability = {
-  trackerID: "MTV",
-  displayName: "MTV",
-  authKind: "api_key_cookies_login",
-  supportsCookieFile: true,
-  supportsLogin: true,
-  supportsAutoLogin: true,
-  supportsTOTP: true,
-  supportsManual2FA: true,
-  requiresAPIKey: true,
-  requiresPasskey: false,
-};
-
-const trackerAuthStatus = (message: string) => ({
-  trackerID: "MTV",
-  displayName: "MTV",
-  state: "configured",
-  cookieCount: 1,
-  lastCheckedAt: "",
-  lastError: "",
-  encryptedStorage: true,
-  needs2FA: false,
-  challengeID: "",
-  message,
-});
-
-const deferred = <T,>() => {
-  let resolve: (value: T) => void = () => undefined;
-  let reject: (reason?: unknown) => void = () => undefined;
-  const promise = new Promise<T>((promiseResolve, promiseReject) => {
-    resolve = promiseResolve;
-    reject = promiseReject;
-  });
-  return { promise, resolve, reject };
-};
-
-describe("SettingsPage", () => {
-  afterEach(() => {
-    cleanup();
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    delete (globalThis as any).go;
-  });
-
-  it("renders application details as the final tab", async () => {
-    const setSettingsSection = vi.fn();
-    const { container, rerender } = render(
-      <SettingsPage {...baseProps} setSettingsSection={setSettingsSection} />,
-    );
-    const settingsTags = container.querySelector(".settings-tags");
-
-    expect(settingsTags).not.toBeNull();
-    expect(
-      within(settingsTags as HTMLElement)
-        .getAllByRole("button")
-        .map((button) => button.textContent),
-    ).toEqual(["Main", "Trackers", "Application Details", "Tracker Auth"]);
-    expect(screen.queryByText("autobrr/upbrr")).not.toBeInTheDocument();
-
-    await userEvent.click(screen.getByRole("button", { name: "Application Details" }));
-
-    expect(setSettingsSection).toHaveBeenCalledWith("application_details");
-
-    rerender(
-      <SettingsPage
-        {...baseProps}
-        settingsSection="application_details"
-        setSettingsSection={setSettingsSection}
-      />,
-    );
-
-    expect(screen.getByText("autobrr/upbrr")).toBeInTheDocument();
-    expect(screen.queryByText("Copyright")).not.toBeInTheDocument();
-    expect(screen.queryByText("Copyright (c) 2026 autobrr")).not.toBeInTheDocument();
-  });
-
-  it("shows path-free DVD engine and FFmpeg capability diagnostics", async () => {
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          GetApplicationInfo: vi.fn().mockResolvedValue({
-            version: "dev",
-            buildIdentifier: "example-build",
-            goVersion: "go1.26.4",
-            goos: "windows",
-            goarch: "amd64",
-            uptime: "1s",
-            uptimeSeconds: 1,
-            dvdMenuEngine: {
-              EngineVersion: "phase0a-1",
-              SchemaVersion: 1,
-              SupportedFeatures: ["ifo_inventory"],
-              FFmpegVersion: "ffmpeg version example",
-              FFmpegDVDVideo: true,
-              MissingFFmpegOptions: [],
-            },
-            dvdMenuCapabilityStatus: "available",
-            dvdMenuCapabilityMessage: "Compatible FFmpeg dvdvideo menu support detected.",
-          }),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsSection="application_details"
-        setSettingsSection={vi.fn()}
-      />,
-    );
-
-    await waitFor(() => expect(screen.getByText("phase0a-1")).toBeInTheDocument());
-    expect(screen.getByText("Available")).toBeInTheDocument();
-    expect(screen.getByText("ffmpeg version example")).toBeInTheDocument();
-    expect(
-      screen.getByText("Compatible FFmpeg dvdvideo menu support detected."),
-    ).toBeInTheDocument();
-  });
-
-  it("renders tracker auth as the bottom tab", async () => {
-    const setSettingsSection = vi.fn();
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([]),
-          GetTrackerAuthStatus: vi.fn(),
-        },
-      },
-    });
-
-    render(<SettingsPage {...baseProps} setSettingsSection={setSettingsSection} />);
-
-    await userEvent.click(screen.getByRole("button", { name: "Tracker Auth" }));
-
-    expect(setSettingsSection).toHaveBeenCalledWith("tracker_auth");
-  });
-
-  it("shows Check Auth only for remote-validation tracker auth", async () => {
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
-            {
-              trackerID: "MTV",
-              displayName: "MTV",
-              authKind: "api_key_cookies_login",
-              supportsCookieFile: true,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: true,
-              supportsManual2FA: true,
-              requiresAPIKey: true,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "BTN",
-              displayName: "BTN",
-              authKind: "api_key_cookies_login_manual_2fa",
-              supportsCookieFile: true,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: true,
-              supportsManual2FA: true,
-              requiresAPIKey: true,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "AR",
-              displayName: "AR",
-              authKind: "cookies_login",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "HDB",
-              displayName: "HDB",
-              authKind: "passkey_cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: true,
-            },
-            {
-              trackerID: "FF",
-              displayName: "FF",
-              authKind: "cookies_login",
-              supportsCookieFile: true,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "FL",
-              displayName: "FL",
-              authKind: "cookies_login",
-              supportsCookieFile: true,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "RTF",
-              displayName: "RTF",
-              authKind: "api_key_credential_refresh",
-              supportsCookieFile: false,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: true,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "THR",
-              displayName: "THR",
-              authKind: "credential_login",
-              supportsCookieFile: false,
-              supportsLogin: true,
-              supportsAutoLogin: true,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "ASC",
-              displayName: "ASC",
-              authKind: "cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-          ]),
-          GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) =>
-            Promise.resolve({
-              trackerID,
-              displayName: trackerID,
-              state: "configured",
-              cookieCount: 0,
-              lastCheckedAt: "",
-              lastError: "",
-              encryptedStorage: true,
-              needs2FA: false,
-              challengeID: "",
-              message: "required config auth material is present",
-            }),
-          ),
-          TestTrackerAuth: vi.fn(),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    const mtvTitle = await screen.findByText("MTV");
-    const btnTitle = await screen.findByText("BTN");
-    const arTitle = await screen.findByText("AR");
-    const hdbTitle = await screen.findByText("HDB");
-    const ffTitle = await screen.findByText("FF");
-    const flTitle = await screen.findByText("FL");
-    const rtfTitle = await screen.findByText("RTF");
-    const thrTitle = await screen.findByText("THR");
-    const ascTitle = await screen.findByText("ASC");
-    const mtvCard = mtvTitle.closest(".tracker-auth-card");
-    const btnCard = btnTitle.closest(".tracker-auth-card");
-    const arCard = arTitle.closest(".tracker-auth-card");
-    const hdbCard = hdbTitle.closest(".tracker-auth-card");
-    const ffCard = ffTitle.closest(".tracker-auth-card");
-    const flCard = flTitle.closest(".tracker-auth-card");
-    const rtfCard = rtfTitle.closest(".tracker-auth-card");
-    const thrCard = thrTitle.closest(".tracker-auth-card");
-    const ascCard = ascTitle.closest(".tracker-auth-card");
-
-    expect(mtvCard).not.toBeNull();
-    expect(btnCard).not.toBeNull();
-    expect(arCard).not.toBeNull();
-    expect(hdbCard).not.toBeNull();
-    expect(ffCard).not.toBeNull();
-    expect(flCard).not.toBeNull();
-    expect(rtfCard).not.toBeNull();
-    expect(thrCard).not.toBeNull();
-    expect(ascCard).not.toBeNull();
-    expect(
-      within(mtvCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(btnCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(arCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(hdbCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(ffCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(flCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(rtfCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(thrCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    ).toBeInTheDocument();
-    expect(
-      within(ascCard as HTMLElement).queryByRole("button", { name: "Check Auth" }),
-    ).not.toBeInTheDocument();
-  });
-
-  it("renders tracker auth failure summary with distinct remote detail", async () => {
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue({
-            ...trackerAuthStatus("stored session expired or invalid"),
-            state: "login_required",
-            lastError: "remote auth test failed status=401",
-          }),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    const title = await screen.findByText("MTV");
-    const card = title.closest(".tracker-auth-card");
-    expect(card).not.toBeNull();
-    expect(
-      within(card as HTMLElement).getByText("stored session expired or invalid"),
-    ).toBeInTheDocument();
-    expect(
-      within(card as HTMLElement).getByText("remote auth test failed status=401"),
-    ).toBeInTheDocument();
-  });
-
-  it("does not render duplicate tracker auth failure detail", async () => {
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue({
-            ...trackerAuthStatus("stored session expired or invalid"),
-            state: "login_required",
-            lastError: "stored session expired or invalid",
-          }),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    const title = await screen.findByText("MTV");
-    const card = title.closest(".tracker-auth-card");
-    expect(card).not.toBeNull();
-    expect(
-      within(card as HTMLElement).getAllByText("stored session expired or invalid"),
-    ).toHaveLength(1);
-  });
-
-  it("renders fast tracker auth statuses before slow statuses resolve", async () => {
-    let resolveSlow: (value: unknown) => void = () => undefined;
-    const slowStatus = new Promise((resolve) => {
-      resolveSlow = resolve;
-    });
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
-            {
-              trackerID: "FAST",
-              displayName: "FAST",
-              authKind: "cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "SLOW",
-              displayName: "SLOW",
-              authKind: "cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-          ]),
-          GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) => {
-            if (trackerID === "SLOW") {
-              return slowStatus;
-            }
-            return Promise.resolve({
-              trackerID,
-              displayName: trackerID,
-              state: "configured",
-              cookieCount: 0,
-              lastCheckedAt: "",
-              lastError: "",
-              encryptedStorage: true,
-              needs2FA: false,
-              challengeID: "",
-              message: "fast ready",
-            });
-          }),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("fast ready")).toBeInTheDocument();
-    expect(screen.queryByText("slow ready")).not.toBeInTheDocument();
-
-    resolveSlow({
-      trackerID: "SLOW",
-      displayName: "SLOW",
-      state: "configured",
-      cookieCount: 0,
-      lastCheckedAt: "",
-      lastError: "",
-      encryptedStorage: true,
-      needs2FA: false,
-      challengeID: "",
-      message: "slow ready",
-    });
-
-    expect(await screen.findByText("slow ready")).toBeInTheDocument();
-  });
-
-  it("hides plain tracker auth capabilities before loading statuses", async () => {
-    const getStatus = vi.fn().mockImplementation((trackerID: string) =>
-      Promise.resolve({
-        trackerID,
-        displayName: trackerID,
-        state: "configured",
-        cookieCount: 0,
-        lastCheckedAt: "",
-        lastError: "",
-        encryptedStorage: true,
-        needs2FA: false,
-        challengeID: "",
-        message: `${trackerID} ready`,
-      }),
-    );
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
-            {
-              trackerID: "PLAINAPI",
-              displayName: "PLAINAPI",
-              authKind: "api_key",
-              supportsCookieFile: false,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: true,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "PLAINPASS",
-              displayName: "PLAINPASS",
-              authKind: "passkey",
-              supportsCookieFile: false,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: true,
-            },
-            {
-              trackerID: "COOKIE",
-              displayName: "COOKIE",
-              authKind: "cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            {
-              trackerID: "RTF",
-              displayName: "RTF",
-              authKind: "api_key_credential_refresh",
-              supportsCookieFile: false,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: true,
-              requiresPasskey: false,
-            },
-          ]),
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("COOKIE ready")).toBeInTheDocument();
-    expect(await screen.findByText("RTF ready")).toBeInTheDocument();
-    expect(screen.queryByText("PLAINAPI")).not.toBeInTheDocument();
-    expect(screen.queryByText("PLAINPASS")).not.toBeInTheDocument();
-    expect(getStatus).toHaveBeenCalledTimes(2);
-    expect(getStatus).toHaveBeenCalledWith("COOKIE");
-    expect(getStatus).toHaveBeenCalledWith("RTF");
-  });
-
-  it("hides managed tracker auth capabilities for trackers not configured in main trackers", async () => {
-    const getStatus = vi.fn().mockImplementation((trackerID: string) =>
-      Promise.resolve({
-        trackerID,
-        displayName: trackerID,
-        state: "configured",
-        cookieCount: 0,
-        lastCheckedAt: "",
-        lastError: "",
-        encryptedStorage: true,
-        needs2FA: false,
-        challengeID: "",
-        message: `${trackerID} ready`,
-      }),
-    );
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
-            {
-              trackerID: "ASC",
-              displayName: "ASC",
-              authKind: "cookies",
-              supportsCookieFile: true,
-              supportsLogin: false,
-              supportsAutoLogin: false,
-              supportsTOTP: false,
-              supportsManual2FA: false,
-              requiresAPIKey: false,
-              requiresPasskey: false,
-            },
-            trackerAuthCapability,
-          ]),
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsSection="tracker_auth"
-        trackerSelectionNames={["MTV"]}
-        setSettingsSection={vi.fn()}
-      />,
-    );
-
-    expect(await screen.findByText("MTV ready")).toBeInTheDocument();
-    expect(screen.queryByText("ASC")).not.toBeInTheDocument();
-    expect(getStatus).toHaveBeenCalledTimes(1);
-    expect(getStatus).toHaveBeenCalledWith("MTV");
-  });
-
-  it.each([
-    ["Import Cookies", "ImportTrackerAuthCookies"],
-    ["Check Auth", "TestTrackerAuth"],
-    ["Delete Auth", "DeleteTrackerAuth"],
-  ])(
-    "keeps newer %s status when initial status resolves late",
-    async (buttonName, bridgeMethod) => {
-      const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
-      vi.stubGlobal("go", {
-        guiapp: {
-          App: {
-            ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-            GetTrackerAuthStatus: vi.fn().mockReturnValue(initialStatus.promise),
-            ImportTrackerAuthCookies: vi.fn().mockResolvedValue(trackerAuthStatus("action ready")),
-            TestTrackerAuth: vi.fn().mockResolvedValue(trackerAuthStatus("action ready")),
-            DeleteTrackerAuth: vi.fn().mockResolvedValue(trackerAuthStatus("action ready")),
-          },
-        },
-      });
-
-      render(
-        <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-      );
-
-      expect(await screen.findByText("MTV")).toBeInTheDocument();
-      await userEvent.click(screen.getByRole("button", { name: buttonName }));
-
-      expect((globalThis as any).go.guiapp.App[bridgeMethod]).toHaveBeenCalledWith("MTV");
-      expect(await screen.findByText("action ready")).toBeInTheDocument();
-
-      initialStatus.resolve(trackerAuthStatus("initial stale"));
-
-      await waitFor(() => {
-        expect(screen.getByText("action ready")).toBeInTheDocument();
-        expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
-      });
-    },
-  );
-
-  it("stores the post-validation tracker auth status returned by Check Auth", async () => {
-    const testStatus = {
-      ...trackerAuthStatus("fresh validation ready"),
-      cookieCount: 3,
-      lastCheckedAt: "2026-07-08T00:00:00Z",
-      lastError: "",
-      encryptedStorage: true,
-    };
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue({
-            ...trackerAuthStatus("stale before validation"),
-            cookieCount: 1,
-          }),
-          TestTrackerAuth: vi.fn().mockResolvedValue(testStatus),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("stale before validation")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
-
-    await waitFor(() => {
-      expect(screen.getByText("fresh validation ready")).toBeInTheDocument();
-      expect(screen.getByText("Cookies: 3")).toBeInTheDocument();
-      expect(
-        screen.getByText((_content, element) =>
-          Boolean(
-            element?.textContent?.startsWith("Checked: ") &&
-            element.textContent !== "Checked: Never",
-          ),
-        ),
-      ).toBeInTheDocument();
-      expect(screen.queryByText("stale before validation")).not.toBeInTheDocument();
-    });
-  });
-
-  it("clears tracker auth cards when refresh fails after an action", async () => {
-    const list = vi
-      .fn()
-      .mockResolvedValueOnce([trackerAuthCapability])
-      .mockRejectedValueOnce(new Error("refresh failed"));
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("initial ready")),
-          ImportTrackerAuthCookies: vi.fn().mockResolvedValue(trackerAuthStatus("action ready")),
-        },
-      },
-    });
-
-    const { rerender } = render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Import Cookies" }));
-    expect(await screen.findByText("action ready")).toBeInTheDocument();
-
-    rerender(
-      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
-    );
-    rerender(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("Error: refresh failed")).toBeInTheDocument();
-    expect(screen.queryByText("MTV")).not.toBeInTheDocument();
-    expect(screen.queryByText("action ready")).not.toBeInTheDocument();
-  });
-
-  it("keeps stale tracker auth status failures from overwriting newer action state", async () => {
-    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: vi.fn().mockReturnValue(initialStatus.promise),
-          ImportTrackerAuthCookies: vi.fn().mockResolvedValue(trackerAuthStatus("action ready")),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("MTV")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Import Cookies" }));
-    expect(await screen.findByText("action ready")).toBeInTheDocument();
-
-    initialStatus.reject(new Error("stale failure"));
-
-    await waitFor(() => {
-      expect(screen.getByText("action ready")).toBeInTheDocument();
-      expect(screen.queryByText("Error: stale failure")).not.toBeInTheDocument();
-    });
-  });
-
-  it("reports tracker auth action failures only on the originating tracker", async () => {
-    const staleAction = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const newerCapability = { ...trackerAuthCapability, trackerID: "PTP", displayName: "PTP" };
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi
-            .fn()
-            .mockResolvedValue([trackerAuthCapability, newerCapability]),
-          GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) =>
-            Promise.resolve({
-              ...trackerAuthStatus(`${trackerID} initial ready`),
-              trackerID,
-              displayName: trackerID,
-            }),
-          ),
-          TestTrackerAuth: vi.fn().mockImplementation((trackerID: string) => {
-            if (trackerID === "MTV") {
-              return staleAction.promise;
-            }
-            return Promise.resolve({
-              ...trackerAuthStatus("new action ready"),
-              trackerID,
-              displayName: trackerID,
-            });
-          }),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    const mtvTitle = await screen.findByText("MTV");
-    const ptpTitle = await screen.findByText("PTP");
-    const mtvCard = mtvTitle.closest(".tracker-auth-card");
-    const ptpCard = ptpTitle.closest(".tracker-auth-card");
-
-    expect(mtvCard).not.toBeNull();
-    expect(ptpCard).not.toBeNull();
-    await userEvent.click(
-      within(mtvCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    );
-    await userEvent.click(
-      within(ptpCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    );
-    expect(await screen.findByText("new action ready")).toBeInTheDocument();
-
-    staleAction.reject(new Error("stale failure"));
-
-    await waitFor(() => {
-      expect(within(ptpCard as HTMLElement).getByText("new action ready")).toBeInTheDocument();
-      expect(within(mtvCard as HTMLElement).getByText("Error: stale failure")).toBeInTheDocument();
-      expect(
-        within(ptpCard as HTMLElement).queryByText("Error: stale failure"),
-      ).not.toBeInTheDocument();
-    });
-
-    await userEvent.click(
-      within(ptpCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
-    );
-
-    await waitFor(() => {
-      expect(within(mtvCard as HTMLElement).getByText("Error: stale failure")).toBeInTheDocument();
-      expect(
-        within(ptpCard as HTMLElement).queryByText("Error: stale failure"),
-      ).not.toBeInTheDocument();
-    });
-  });
-
-  it("ignores tracker auth action failures after leaving the tracker auth section", async () => {
-    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("initial ready")),
-          TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
-        },
-      },
-    });
-
-    const { rerender } = render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
-
-    rerender(
-      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
-    );
-    action.reject(new Error("late failure"));
-
-    await waitFor(() => {
-      expect(screen.queryByText("Error: late failure")).not.toBeInTheDocument();
-    });
-  });
-
-  it("clears tracker auth loading after leaving and reentering with old status pending", async () => {
-    const oldStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const getStatus = vi
-      .fn()
-      .mockReturnValueOnce(oldStatus.promise)
-      .mockResolvedValueOnce(trackerAuthStatus("after reenter"));
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    const { rerender } = render(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("MTV")).toBeInTheDocument();
-    expect(screen.getByText("Loading tracker auth...")).toBeInTheDocument();
-
-    rerender(
-      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
-    );
-    rerender(
-      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
-    );
-
-    expect(await screen.findByText("after reenter")).toBeInTheDocument();
-    oldStatus.resolve(trackerAuthStatus("old ready"));
-
-    await waitFor(() => {
-      expect(screen.queryByText("Loading tracker auth...")).not.toBeInTheDocument();
-      expect(screen.getByText("after reenter")).toBeInTheDocument();
-      expect(screen.queryByText("old ready")).not.toBeInTheDocument();
-    });
-  });
-
-  it("refreshes tracker auth after saving settings while tracker auth is selected", async () => {
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
-      .mockResolvedValueOnce(trackerAuthStatus("after save"));
-    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsDirty
-        settingsSection="tracker_auth"
-        setSettingsSection={vi.fn()}
-        handleSaveSettings={handleSaveSettings}
-      />,
-    );
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Save" }));
-
-    await waitFor(() => {
-      expect(handleSaveSettings).toHaveBeenCalledTimes(1);
-      expect(list).toHaveBeenCalledTimes(2);
-      expect(getStatus).toHaveBeenCalledTimes(2);
-      expect(screen.getByText("after save")).toBeInTheDocument();
-    });
-  });
-
-  it("keeps pending old tracker auth status from overwriting save reload status", async () => {
-    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockReturnValueOnce(initialStatus.promise)
-      .mockResolvedValueOnce(trackerAuthStatus("after save"));
-    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsDirty
-        settingsSection="tracker_auth"
-        setSettingsSection={vi.fn()}
-        handleSaveSettings={handleSaveSettings}
-      />,
-    );
-
-    expect(await screen.findByText("MTV")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Save" }));
-    expect(await screen.findByText("after save")).toBeInTheDocument();
-
-    initialStatus.resolve(trackerAuthStatus("initial stale"));
-
-    await waitFor(() => {
-      expect(screen.getByText("after save")).toBeInTheDocument();
-      expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
-      expect(list).toHaveBeenCalledTimes(2);
-      expect(getStatus).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  it("clears pending tracker auth action busy state after save reload", async () => {
-    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
-      .mockResolvedValueOnce(trackerAuthStatus("after save"));
-    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-          TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsDirty
-        settingsSection="tracker_auth"
-        setSettingsSection={vi.fn()}
-        handleSaveSettings={handleSaveSettings}
-      />,
-    );
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
-    expect(screen.getByRole("button", { name: "Checking..." })).toBeDisabled();
-
-    await userEvent.click(screen.getByRole("button", { name: "Save" }));
-    expect(await screen.findByText("after save")).toBeInTheDocument();
-
-    action.resolve(trackerAuthStatus("action stale"));
-
-    await waitFor(() => {
-      expect(screen.getByText("after save")).toBeInTheDocument();
-      expect(screen.queryByText("action stale")).not.toBeInTheDocument();
-      expect(screen.getByRole("button", { name: "Check Auth" })).toBeEnabled();
-    });
-  });
-
-  it("refreshes tracker auth after confirming config import while tracker auth is selected", async () => {
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
-      .mockResolvedValueOnce(trackerAuthStatus("after import"));
-    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsSection="tracker_auth"
-        setSettingsSection={vi.fn()}
-        importConfirmOpen
-        handleImportConfigConfirm={handleImportConfigConfirm}
-      />,
-    );
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
-
-    await waitFor(() => {
-      expect(handleImportConfigConfirm).toHaveBeenCalledTimes(1);
-      expect(list).toHaveBeenCalledTimes(2);
-      expect(getStatus).toHaveBeenCalledTimes(2);
-      expect(screen.getByText("after import")).toBeInTheDocument();
-    });
-  });
-
-  it("keeps pending old tracker auth status from overwriting import reload status", async () => {
-    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockReturnValueOnce(initialStatus.promise)
-      .mockResolvedValueOnce(trackerAuthStatus("after import"));
-    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsSection="tracker_auth"
-        setSettingsSection={vi.fn()}
-        importConfirmOpen
-        handleImportConfigConfirm={handleImportConfigConfirm}
-      />,
-    );
-
-    expect(await screen.findByText("MTV")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
-    expect(await screen.findByText("after import")).toBeInTheDocument();
-
-    initialStatus.resolve(trackerAuthStatus("initial stale"));
-
-    await waitFor(() => {
-      expect(screen.getByText("after import")).toBeInTheDocument();
-      expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
-      expect(list).toHaveBeenCalledTimes(2);
-      expect(getStatus).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  it("clears pending tracker auth action busy state after import reload", async () => {
-    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const getStatus = vi
-      .fn()
-      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
-      .mockResolvedValueOnce(trackerAuthStatus("after import"));
-    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: getStatus,
-          TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
-        },
-      },
-    });
-
-    const props = {
-      ...baseProps,
-      settingsSection: "tracker_auth",
-      setSettingsSection: vi.fn(),
-      handleImportConfigConfirm,
-    };
-    const { rerender } = render(<SettingsPage {...props} />);
-
-    expect(await screen.findByText("initial ready")).toBeInTheDocument();
-    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
-    expect(screen.getByRole("button", { name: "Checking..." })).toBeDisabled();
-
-    rerender(<SettingsPage {...props} importConfirmOpen />);
-
-    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
-    expect(await screen.findByText("after import")).toBeInTheDocument();
-
-    rerender(<SettingsPage {...props} />);
-
-    action.resolve(trackerAuthStatus("action stale"));
-
-    await waitFor(() => {
-      expect(screen.getByText("after import")).toBeInTheDocument();
-      expect(screen.queryByText("action stale")).not.toBeInTheDocument();
-      expect(screen.getByRole("button", { name: "Check Auth", hidden: true })).toBeEnabled();
-    });
-  });
-
-  it("keeps config save refresh lazy outside tracker auth", async () => {
-    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
-    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("go", {
-      guiapp: {
-        App: {
-          ListTrackerAuthCapabilities: list,
-          GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("ready")),
-        },
-      },
-    });
-
-    render(
-      <SettingsPage
-        {...baseProps}
-        settingsDirty
-        settingsSection="main_settings"
-        setSettingsSection={vi.fn()}
-        handleSaveSettings={handleSaveSettings}
-      />,
-    );
-
-    await userEvent.click(screen.getByRole("button", { name: "Save" }));
-
-    await waitFor(() => {
-      expect(handleSaveSettings).toHaveBeenCalledTimes(1);
-    });
-    expect(list).not.toHaveBeenCalled();
-  });
-});
diff --git a/gui/frontend/src/pages/settings/index.tsx b/gui/frontend/src/pages/settings/index.tsx
deleted file mode 100644
index e0021ffb..00000000
--- a/gui/frontend/src/pages/settings/index.tsx
+++ /dev/null
@@ -1,1198 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useCallback, useEffect, useRef, useState } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import * as AlertDialog from "@radix-ui/react-alert-dialog";
-import { Button } from "../../components/ui/button";
-import { Switch } from "../../components/ui/switch";
-import { cn } from "../../utils/cn";
-import { handleExternalLinkClick } from "../../utils/externalLinks";
-import type {
-  ApplicationInfo,
-  ConfigMap,
-  ConfigValue,
-  FieldMeta,
-  TrackerAuthCapability,
-  TrackerAuthStatus,
-  WebAuthStatus,
-} from "../../types";
-
-type SettingsSection = { key: string; jsonKey: string; label: string };
-
-const applicationDetailsSection = {
-  key: "application_details",
-  label: "Application Details",
-};
-
-const trackerAuthSection = {
-  key: "tracker_auth",
-  label: "Tracker Auth",
-};
-
-const settingsInputClass =
-  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
-// Tracker-supplied auth kinds can be long adapter descriptors; keep chips
-// wrapped inside the auth card on narrow screens.
-const trackerAuthChipClass =
-  "max-w-full whitespace-normal rounded-full border border-slate-400/20 bg-slate-950/35 px-[0.45rem] py-[0.2rem] text-[0.74rem] leading-none text-[var(--muted)] [overflow-wrap:anywhere]";
-const trackerAuthMetaClass = "m-0 text-[0.8rem] text-[var(--muted)]";
-
-/** Trackers with backend adapters that can perform a remote auth check. */
-const remoteAuthValidationTrackers = new Set([
-  "AR",
-  "BTN",
-  "FF",
-  "FL",
-  "HDB",
-  "MTV",
-  "PTP",
-  "RTF",
-  "THR",
-]);
-
-/** Builds the case-insensitive key shared by main tracker config and tracker auth rows. */
-const trackerNameKey = (name: string) => name.trim().toLowerCase();
-
-/**
- * Returns true for tracker auth capabilities that perform stored-cookie,
- * relogin, refresh, or 2FA handling beyond static API-key/passkey config.
- */
-const isManagedTrackerAuthCapability = (capability: TrackerAuthCapability) => {
-  const authKind = capability.authKind.toLowerCase();
-  return (
-    capability.supportsCookieFile ||
-    capability.supportsLogin ||
-    capability.supportsAutoLogin ||
-    capability.supportsTOTP ||
-    capability.supportsManual2FA ||
-    authKind.includes("refresh") ||
-    authKind.includes("2fa")
-  );
-};
-
-/** Returns tracker auth summary/detail text using the shared API display contract. */
-const trackerAuthStatusDisplay = (status?: TrackerAuthStatus) => {
-  const message = status?.message.trim() ?? "";
-  const lastError = status?.lastError.trim() ?? "";
-  return {
-    message,
-    lastError: lastError && lastError !== message ? lastError : "",
-  };
-};
-
-type ConfigOpStatus = {
-  type: "success" | "error" | "warning";
-  title: string;
-  message: string;
-  warnings?: string[];
-} | null;
-
-type AppBridgeWithApplicationInfo = {
-  GetApplicationInfo?: () => Promise<ApplicationInfo>;
-};
-
-type AppBridgeWithTrackerAuth = {
-  ListTrackerAuthCapabilities?: () => Promise<TrackerAuthCapability[]>;
-  GetTrackerAuthStatus?: (tracker: string) => Promise<TrackerAuthStatus>;
-  ImportTrackerAuthCookies?: (tracker: string) => Promise<TrackerAuthStatus>;
-  TestTrackerAuth?: (tracker: string) => Promise<TrackerAuthStatus>;
-  SubmitTrackerAuth2FA?: (challengeID: string, code: string) => Promise<TrackerAuthStatus>;
-  DeleteTrackerAuth?: (tracker: string) => Promise<TrackerAuthStatus>;
-};
-
-type Props = {
-  configData: ConfigMap | null;
-  settingsLoading: boolean;
-  settingsExporting: boolean;
-  settingsImporting: boolean;
-  settingsDirty: boolean;
-  settingsSaved: string;
-  settingsError: string;
-  configOpStatus: ConfigOpStatus;
-  dismissConfigOpStatus: () => void;
-  settingsSection: string;
-  settingsSections: SettingsSection[];
-  /** Tracker names already enabled by the main tracker settings panel. */
-  trackerSelectionNames: string[];
-  showAdvancedToggle: boolean;
-  advancedOpen: boolean;
-  setSettingsSection: Dispatch<SetStateAction<string>>;
-  setSettingsAdvanced: Dispatch<SetStateAction<Record<string, boolean>>>;
-  loadSettings: () => void;
-  handleExportSettings: () => void;
-  handleImportConfig: () => void;
-  importConfirmOpen: boolean;
-  handleImportConfigConfirm: () => void | Promise<void>;
-  handleImportConfigCancel: () => void;
-  handleSaveSettings: () => void | Promise<void>;
-  webAuthAvailable: boolean;
-  webAuthStatus: WebAuthStatus | null;
-  webAuthLoading: boolean;
-  webAuthCreating: boolean;
-  webAuthUsername: string;
-  webAuthPassword: string;
-  webAuthConfirm: string;
-  webAuthError: string;
-  setWebAuthUsername: Dispatch<SetStateAction<string>>;
-  setWebAuthPassword: Dispatch<SetStateAction<string>>;
-  setWebAuthConfirm: Dispatch<SetStateAction<string>>;
-  handleCreateWebAuth: () => void;
-  renderImageHostingSection: () => JSX.Element | null;
-  renderTrackerSection: (advancedOpen: boolean) => JSX.Element | null;
-  renderTorrentClientsSection: (advancedOpen: boolean) => JSX.Element | null;
-  renderField: (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => JSX.Element;
-  sectionFieldMeta: Record<string, Record<string, FieldMeta>>;
-};
-
-/**
- * Renders settings plus tracker auth controls with generation-gated async state
- * so config saves/imports, section changes, and per-tracker actions ignore
- * stale tracker auth responses.
- */
-export default function SettingsPage(props: Props) {
-  const {
-    configData,
-    settingsLoading,
-    settingsExporting,
-    settingsImporting,
-    settingsDirty,
-    settingsSaved,
-    settingsError,
-    configOpStatus,
-    dismissConfigOpStatus,
-    settingsSection,
-    settingsSections,
-    trackerSelectionNames,
-    showAdvancedToggle,
-    advancedOpen,
-    setSettingsSection,
-    setSettingsAdvanced,
-    loadSettings,
-    handleExportSettings,
-    handleImportConfig,
-    importConfirmOpen,
-    handleImportConfigConfirm,
-    handleImportConfigCancel,
-    handleSaveSettings,
-    webAuthAvailable,
-    webAuthStatus,
-    webAuthLoading,
-    webAuthCreating,
-    webAuthUsername,
-    webAuthPassword,
-    webAuthConfirm,
-    webAuthError,
-    setWebAuthUsername,
-    setWebAuthPassword,
-    setWebAuthConfirm,
-    handleCreateWebAuth,
-    renderImageHostingSection,
-    renderTrackerSection,
-    renderTorrentClientsSection,
-    renderField,
-    sectionFieldMeta,
-  } = props;
-
-  const [warningsExpanded, setWarningsExpanded] = useState(false);
-  const [applicationInfo, setApplicationInfo] = useState<ApplicationInfo | null>(null);
-  const [applicationInfoError, setApplicationInfoError] = useState("");
-  const [applicationInfoLoading, setApplicationInfoLoading] = useState(false);
-  const [applicationInfoFetchedAt, setApplicationInfoFetchedAt] = useState<number | null>(null);
-  const [uptimeTick, setUptimeTick] = useState(() => Date.now());
-  const [trackerAuthCapabilities, setTrackerAuthCapabilities] = useState<TrackerAuthCapability[]>(
-    [],
-  );
-  const [trackerAuthStatuses, setTrackerAuthStatuses] = useState<Record<string, TrackerAuthStatus>>(
-    {},
-  );
-  const [trackerAuthLoading, setTrackerAuthLoading] = useState(false);
-  const [trackerAuthError, setTrackerAuthError] = useState("");
-  const [trackerAuthActionErrors, setTrackerAuthActionErrors] = useState<Record<string, string>>(
-    {},
-  );
-  const [trackerAuthFilter, setTrackerAuthFilter] = useState("");
-  const [trackerAuthActions, setTrackerAuthActions] = useState<Record<string, string>>({});
-  const [trackerAuthCodes, setTrackerAuthCodes] = useState<Record<string, string>>({});
-  const [trackerAuthReloadRevision, setTrackerAuthReloadRevision] = useState(0);
-  const trackerAuthStatusVersions = useRef<Record<string, number>>({});
-  const trackerAuthActionSequences = useRef<Record<string, number>>({});
-  const trackerAuthLoadGeneration = useRef(0);
-  const trackerAuthSectionActiveRef = useRef(settingsSection === trackerAuthSection.key);
-
-  const invalidateTrackerAuthStatusVersions = useCallback(() => {
-    Object.keys(trackerAuthStatusVersions.current).forEach((trackerID) => {
-      trackerAuthStatusVersions.current[trackerID] =
-        (trackerAuthStatusVersions.current[trackerID] ?? 0) + 1;
-    });
-  }, []);
-
-  useEffect(() => {
-    const active = settingsSection === trackerAuthSection.key;
-    trackerAuthSectionActiveRef.current = active;
-    if (!active) {
-      invalidateTrackerAuthStatusVersions();
-      trackerAuthLoadGeneration.current += 1;
-      setTrackerAuthLoading(false);
-      setTrackerAuthActions({});
-      setTrackerAuthActionErrors({});
-    }
-  }, [invalidateTrackerAuthStatusVersions, settingsSection]);
-
-  useEffect(() => {
-    let cancelled = false;
-    const getter = (globalThis.go?.guiapp?.App as AppBridgeWithApplicationInfo | undefined)
-      ?.GetApplicationInfo;
-    if (!getter) {
-      setApplicationInfoError("Application details are unavailable in this build.");
-      return () => {
-        cancelled = true;
-      };
-    }
-
-    setApplicationInfoLoading(true);
-    setApplicationInfoError("");
-    void getter()
-      .then((info) => {
-        if (cancelled) {
-          return;
-        }
-        setApplicationInfo(info);
-        setApplicationInfoFetchedAt(Date.now());
-      })
-      .catch((error) => {
-        if (cancelled) {
-          return;
-        }
-        setApplicationInfoError(String(error));
-      })
-      .finally(() => {
-        if (!cancelled) {
-          setApplicationInfoLoading(false);
-        }
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-
-  useEffect(() => {
-    if (!applicationInfo) {
-      return undefined;
-    }
-    const timer = window.setInterval(() => {
-      setUptimeTick(Date.now());
-    }, 1000);
-    return () => window.clearInterval(timer);
-  }, [applicationInfo]);
-
-  useEffect(() => {
-    if (settingsSection !== trackerAuthSection.key) {
-      return undefined;
-    }
-    let cancelled = false;
-    const loadGeneration = trackerAuthLoadGeneration.current + 1;
-    trackerAuthLoadGeneration.current = loadGeneration;
-    const bridge = globalThis.go?.guiapp?.App as AppBridgeWithTrackerAuth | undefined;
-    const list = bridge?.ListTrackerAuthCapabilities;
-    const getStatus = bridge?.GetTrackerAuthStatus;
-    if (!list || !getStatus) {
-      setTrackerAuthError("Tracker auth is unavailable in this build.");
-      return () => {
-        cancelled = true;
-      };
-    }
-
-    setTrackerAuthLoading(true);
-    setTrackerAuthError("");
-    setTrackerAuthActionErrors({});
-    void list()
-      .then((capabilities) => {
-        if (cancelled) {
-          return;
-        }
-        const configuredTrackerNames = new Set(trackerSelectionNames.map(trackerNameKey));
-        const managedCapabilities = capabilities.filter(
-          (capability) =>
-            configuredTrackerNames.has(trackerNameKey(capability.trackerID)) &&
-            isManagedTrackerAuthCapability(capability),
-        );
-        setTrackerAuthCapabilities(managedCapabilities);
-        setTrackerAuthStatuses({});
-        if (managedCapabilities.length === 0) {
-          setTrackerAuthLoading(false);
-          return;
-        }
-        let pendingStatuses = managedCapabilities.length;
-        const markStatusComplete = () => {
-          pendingStatuses -= 1;
-          if (
-            pendingStatuses === 0 &&
-            !cancelled &&
-            trackerAuthLoadGeneration.current === loadGeneration
-          ) {
-            setTrackerAuthLoading(false);
-          }
-        };
-        managedCapabilities.forEach((capability) => {
-          const statusVersion = trackerAuthStatusVersions.current[capability.trackerID] ?? 0;
-          void getStatus(capability.trackerID)
-            .then((status) => {
-              if (
-                !cancelled &&
-                (trackerAuthStatusVersions.current[capability.trackerID] ?? 0) === statusVersion
-              ) {
-                setTrackerAuthStatuses((prev) => ({
-                  ...prev,
-                  [capability.trackerID]: status,
-                }));
-              }
-            })
-            .catch((error) => {
-              if (
-                !cancelled &&
-                (trackerAuthStatusVersions.current[capability.trackerID] ?? 0) === statusVersion
-              ) {
-                setTrackerAuthStatuses((prev) => ({
-                  ...prev,
-                  [capability.trackerID]: {
-                    trackerID: capability.trackerID,
-                    displayName: capability.displayName,
-                    state: "error",
-                    cookieCount: 0,
-                    lastCheckedAt: "",
-                    lastError: String(error),
-                    encryptedStorage: false,
-                    needs2FA: false,
-                    challengeID: "",
-                    message: "",
-                  },
-                }));
-              }
-            })
-            .finally(() => {
-              if (!cancelled) {
-                markStatusComplete();
-              }
-            });
-        });
-      })
-      .catch((error) => {
-        if (!cancelled) {
-          setTrackerAuthCapabilities([]);
-          setTrackerAuthStatuses({});
-          setTrackerAuthError(String(error));
-          setTrackerAuthLoading(false);
-        }
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [settingsSection, trackerAuthReloadRevision, trackerSelectionNames]);
-
-  const reloadTrackerAuthAfterConfigChange = useCallback(
-    async (handler: () => void | Promise<void>) => {
-      await handler();
-      invalidateTrackerAuthStatusVersions();
-      setTrackerAuthActions({});
-      setTrackerAuthActionErrors({});
-      setTrackerAuthReloadRevision((revision) => revision + 1);
-    },
-    [invalidateTrackerAuthStatusVersions],
-  );
-
-  const runTrackerAuthAction = async (
-    trackerID: string,
-    action: string,
-    fn: () => Promise<TrackerAuthStatus>,
-  ) => {
-    const actionVersion = (trackerAuthStatusVersions.current[trackerID] ?? 0) + 1;
-    trackerAuthStatusVersions.current[trackerID] = actionVersion;
-    const actionSequence = (trackerAuthActionSequences.current[trackerID] ?? 0) + 1;
-    trackerAuthActionSequences.current[trackerID] = actionSequence;
-    setTrackerAuthActions((prev) => ({ ...prev, [trackerID]: action }));
-    setTrackerAuthActionErrors((prev) => {
-      const next = { ...prev };
-      delete next[trackerID];
-      return next;
-    });
-    try {
-      const status = await fn();
-      if (
-        trackerAuthSectionActiveRef.current &&
-        trackerAuthStatusVersions.current[trackerID] === actionVersion
-      ) {
-        setTrackerAuthStatuses((prev) => ({ ...prev, [trackerID]: status }));
-      }
-    } catch (error) {
-      if (
-        trackerAuthSectionActiveRef.current &&
-        trackerAuthActionSequences.current[trackerID] === actionSequence &&
-        trackerAuthStatusVersions.current[trackerID] === actionVersion
-      ) {
-        setTrackerAuthActionErrors((prev) => ({ ...prev, [trackerID]: String(error) }));
-      }
-    } finally {
-      if (
-        trackerAuthSectionActiveRef.current &&
-        trackerAuthActionSequences.current[trackerID] === actionSequence
-      ) {
-        setTrackerAuthActions((prev) => ({ ...prev, [trackerID]: "" }));
-      }
-    }
-  };
-
-  const trackerAuthPanel = (() => {
-    const bridge = globalThis.go?.guiapp?.App as AppBridgeWithTrackerAuth | undefined;
-    const filter = trackerAuthFilter.trim().toLowerCase();
-    const capabilities = trackerAuthCapabilities.filter((capability) => {
-      if (!filter) return true;
-      return (
-        capability.trackerID.toLowerCase().includes(filter) ||
-        capability.authKind.toLowerCase().includes(filter)
-      );
-    });
-    const storageReady = Object.values(trackerAuthStatuses).some(
-      (status) => status.encryptedStorage,
-    );
-    return (
-      <div className="settings-form gap-4">
-        <div className="settings-subgroup">
-          <div className="settings-subgroup__title">Tracker Auth</div>
-          <div className="settings-auth-status">
-            <span className={`settings-auth-badge ${storageReady ? "is-ready" : "is-warning"}`}>
-              {storageReady
-                ? "Encrypted cookie storage ready"
-                : "Encrypted cookie storage unavailable"}
-            </span>
-            <p className="helper">
-              Import Netscape or JSON cookies, check local auth state, and confirm which trackers
-              can relogin automatically during unattended uploads.
-            </p>
-          </div>
-          <label className="settings-field max-w-[360px]">
-            <span>Filter trackers</span>
-            <input
-              className={settingsInputClass}
-              value={trackerAuthFilter}
-              onChange={(event) => setTrackerAuthFilter(event.target.value)}
-              placeholder="MTV, cookies, api"
-            />
-          </label>
-        </div>
-        {trackerAuthLoading ? <p className="muted">Loading tracker auth...</p> : null}
-        {trackerAuthError ? <p className="error">{trackerAuthError}</p> : null}
-        <div className="grid gap-[0.85rem]">
-          {capabilities.map((capability) => {
-            const status = trackerAuthStatuses[capability.trackerID];
-            const busy = trackerAuthActions[capability.trackerID] || "";
-            const actionError = trackerAuthActionErrors[capability.trackerID] || "";
-            const code = trackerAuthCodes[capability.trackerID] || "";
-            const statusDisplay = trackerAuthStatusDisplay(status);
-            const canTestAuth = remoteAuthValidationTrackers.has(
-              capability.trackerID.trim().toUpperCase(),
-            );
-            return (
-              <div
-                className="settings-card tracker-auth-card grid min-w-0 gap-3"
-                key={capability.trackerID}
-              >
-                <div className="flex min-w-0 flex-wrap items-center justify-between gap-[0.6rem]">
-                  <div className="min-w-0 flex-1">
-                    <p className="settings-detail-card__label">Tracker</p>
-                    <h2 className="m-0 mt-[0.1rem] text-[1.05rem] leading-tight [overflow-wrap:anywhere]">
-                      {capability.displayName || capability.trackerID}
-                    </h2>
-                  </div>
-                  <span className={`settings-auth-badge ${statusBadgeClass(status?.state)}`}>
-                    {formatTrackerAuthState(status?.state)}
-                  </span>
-                </div>
-                <div className="flex min-w-0 flex-wrap items-center gap-[0.6rem]">
-                  <span className={trackerAuthChipClass}>{capability.authKind}</span>
-                  {capability.supportsCookieFile ? (
-                    <span className={trackerAuthChipClass}>cookie import</span>
-                  ) : null}
-                  {capability.supportsLogin ? (
-                    <span className={trackerAuthChipClass}>login</span>
-                  ) : null}
-                  {capability.supportsAutoLogin ? (
-                    <span className={trackerAuthChipClass}>auto relogin</span>
-                  ) : null}
-                  {capability.supportsTOTP ? (
-                    <span className={trackerAuthChipClass}>TOTP</span>
-                  ) : null}
-                  {capability.supportsManual2FA ? (
-                    <span className={trackerAuthChipClass}>manual 2FA</span>
-                  ) : null}
-                  {capability.requiresAPIKey ? (
-                    <span className={trackerAuthChipClass}>API key</span>
-                  ) : null}
-                  {capability.requiresPasskey ? (
-                    <span className={trackerAuthChipClass}>passkey</span>
-                  ) : null}
-                </div>
-                <div className="flex flex-wrap items-center gap-[0.6rem]">
-                  <p className={trackerAuthMetaClass}>Cookies: {status?.cookieCount ?? 0}</p>
-                  <p className={trackerAuthMetaClass}>
-                    Checked: {formatTrackerAuthDate(status?.lastCheckedAt)}
-                  </p>
-                  <p className={trackerAuthMetaClass}>
-                    Storage: {status?.encryptedStorage ? "encrypted" : "unavailable"}
-                  </p>
-                </div>
-                {statusDisplay.message ? (
-                  <p className="helper [overflow-wrap:anywhere]">{statusDisplay.message}</p>
-                ) : null}
-                {statusDisplay.lastError ? (
-                  <p className="error [overflow-wrap:anywhere]">{statusDisplay.lastError}</p>
-                ) : null}
-                {actionError ? <p className="error">{actionError}</p> : null}
-                {(capability.notes ?? []).map((note) => (
-                  <p className="muted [overflow-wrap:anywhere]" key={note}>
-                    {note}
-                  </p>
-                ))}
-                {status?.needs2FA ? (
-                  <div className="flex flex-wrap items-center gap-[0.6rem]">
-                    <input
-                      className={`${settingsInputClass} w-36`}
-                      value={code}
-                      inputMode="numeric"
-                      autoComplete="one-time-code"
-                      onChange={(event) =>
-                        setTrackerAuthCodes((prev) => ({
-                          ...prev,
-                          [capability.trackerID]: event.target.value,
-                        }))
-                      }
-                      placeholder="2FA code"
-                    />
-                    <Button
-                      type="button"
-                      disabled={
-                        !bridge?.SubmitTrackerAuth2FA || !status.challengeID || !code.trim()
-                      }
-                      onClick={() =>
-                        runTrackerAuthAction(capability.trackerID, "2fa", () =>
-                          bridge!.SubmitTrackerAuth2FA!(status.challengeID, code),
-                        )
-                      }
-                    >
-                      Submit 2FA
-                    </Button>
-                  </div>
-                ) : null}
-                <div className="settings-auth-actions">
-                  {capability.supportsCookieFile ? (
-                    <Button
-                      type="button"
-                      disabled={!bridge?.ImportTrackerAuthCookies || Boolean(busy)}
-                      onClick={() =>
-                        runTrackerAuthAction(capability.trackerID, "import", () =>
-                          bridge!.ImportTrackerAuthCookies!(capability.trackerID),
-                        )
-                      }
-                    >
-                      {busy === "import" ? "Importing..." : "Import Cookies"}
-                    </Button>
-                  ) : null}
-                  {canTestAuth ? (
-                    <Button
-                      type="button"
-                      disabled={!bridge?.TestTrackerAuth || Boolean(busy)}
-                      onClick={() =>
-                        runTrackerAuthAction(capability.trackerID, "test", () =>
-                          bridge!.TestTrackerAuth!(capability.trackerID),
-                        )
-                      }
-                    >
-                      {busy === "test" ? "Checking..." : "Check Auth"}
-                    </Button>
-                  ) : null}
-                  <Button
-                    type="button"
-                    disabled={!bridge?.DeleteTrackerAuth || Boolean(busy)}
-                    onClick={() =>
-                      runTrackerAuthAction(capability.trackerID, "delete", () =>
-                        bridge!.DeleteTrackerAuth!(capability.trackerID),
-                      )
-                    }
-                  >
-                    {busy === "delete" ? "Deleting..." : "Delete Auth"}
-                  </Button>
-                </div>
-              </div>
-            );
-          })}
-        </div>
-      </div>
-    );
-  })();
-
-  const uptimeSeconds =
-    applicationInfo && applicationInfoFetchedAt !== null
-      ? applicationInfo.uptimeSeconds +
-        Math.max(0, Math.floor((uptimeTick - applicationInfoFetchedAt) / 1000))
-      : 0;
-  const uptimeValue = applicationInfo ? formatApplicationUptime(uptimeSeconds) : "";
-  const applicationDetailsPanel = (
-    <div className="settings-subgroup settings-subgroup--application">
-      <p className="helper">
-        Read-only build and runtime details for this install. Auth, bind, and storage paths are
-        intentionally excluded.
-      </p>
-      <div className="settings-details-grid">
-        <div className="settings-detail-card">
-          <p className="settings-detail-card__label">Project</p>
-          <p className="settings-detail-card__value">
-            <a
-              href="https://github.com/autobrr/upbrr"
-              target="_blank"
-              rel="noreferrer"
-              onAuxClick={handleExternalLinkClick}
-              onClick={handleExternalLinkClick}
-            >
-              autobrr/upbrr
-            </a>
-          </p>
-        </div>
-        {applicationInfo ? (
-          <>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">Version</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.version || "Unavailable"}
-              </p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">Build</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.buildIdentifier || "Unavailable"}
-              </p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">Go Runtime</p>
-              <p className="settings-detail-card__value mono">{applicationInfo.goVersion}</p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">DVD Menu Engine</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.dvdMenuEngine.EngineVersion || "Unavailable"}
-              </p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">FFmpeg DVD Menus</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.dvdMenuCapabilityStatus === "available"
-                  ? "Available"
-                  : applicationInfo.dvdMenuCapabilityStatus === "incompatible"
-                    ? "Incompatible"
-                    : "Unavailable"}
-              </p>
-              <p className="helper">{applicationInfo.dvdMenuCapabilityMessage}</p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">FFmpeg Version</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.dvdMenuEngine.FFmpegVersion || "Unavailable"}
-              </p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">Platform</p>
-              <p className="settings-detail-card__value mono">
-                {applicationInfo.goos}/{applicationInfo.goarch}
-              </p>
-            </div>
-            <div className="settings-detail-card">
-              <p className="settings-detail-card__label">Uptime</p>
-              <p className="settings-detail-card__value mono">
-                {uptimeValue || applicationInfo.uptime}
-              </p>
-            </div>
-          </>
-        ) : null}
-      </div>
-      {applicationInfoLoading ? <p className="muted">Loading application details...</p> : null}
-      {applicationInfoError ? <p className="error">{applicationInfoError}</p> : null}
-    </div>
-  );
-
-  return (
-    <div className="content-stack">
-      <header className="hero">
-        <p className="eyebrow">upbrr</p>
-        <h1>Settings</h1>
-        <p className="subtitle">
-          Edit settings by section. Changes apply immediately and are saved to SQLite.
-        </p>
-      </header>
-
-      <section className="panel">
-        <div className="settings-header">
-          <div className="settings-meta">
-            <p className="label">Configuration</p>
-            <p className="helper">Invalid changes will be rejected with a validation error.</p>
-          </div>
-          <div className="settings-actions">
-            <Button type="button" onClick={loadSettings} disabled={settingsLoading}>
-              Reload
-            </Button>
-            <Button
-              type="button"
-              onClick={handleExportSettings}
-              disabled={settingsLoading || settingsExporting || settingsImporting}
-            >
-              {settingsExporting ? "Exporting..." : "Export"}
-            </Button>
-            <Button
-              type="button"
-              onClick={handleImportConfig}
-              disabled={settingsLoading || settingsExporting || settingsImporting}
-            >
-              {settingsImporting ? "Importing..." : "Import"}
-            </Button>
-            <Button
-              variant="primary"
-              type="button"
-              onClick={() => {
-                void reloadTrackerAuthAfterConfigChange(handleSaveSettings);
-              }}
-              disabled={settingsLoading || settingsExporting || settingsImporting || !settingsDirty}
-            >
-              Save
-            </Button>
-          </div>
-        </div>
-
-        {configOpStatus ? (
-          <div className={`config-status-banner config-status-banner--${configOpStatus.type}`}>
-            <div className="config-status-banner__icon">
-              {configOpStatus.type === "success" ? (
-                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
-                  <path
-                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
-                    fill="currentColor"
-                    opacity=".15"
-                  />
-                  <path
-                    d="M6.5 10.5 8.5 12.5 13.5 7.5"
-                    stroke="currentColor"
-                    strokeWidth="1.5"
-                    strokeLinecap="round"
-                    strokeLinejoin="round"
-                  />
-                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
-                </svg>
-              ) : configOpStatus.type === "warning" ? (
-                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
-                  <path
-                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
-                    fill="currentColor"
-                    opacity=".15"
-                  />
-                  <path d="M10 7v4" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
-                  <circle cx="10" cy="13.5" r=".75" fill="currentColor" />
-                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
-                </svg>
-              ) : (
-                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
-                  <path
-                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
-                    fill="currentColor"
-                    opacity=".15"
-                  />
-                  <path
-                    d="M12.5 7.5 7.5 12.5M7.5 7.5l5 5"
-                    stroke="currentColor"
-                    strokeWidth="1.5"
-                    strokeLinecap="round"
-                  />
-                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
-                </svg>
-              )}
-            </div>
-            <div className="config-status-banner__body">
-              <p className="config-status-banner__title">{configOpStatus.title}</p>
-              <p className="config-status-banner__message">{configOpStatus.message}</p>
-              {configOpStatus.warnings && configOpStatus.warnings.length > 0 ? (
-                <div className="config-status-banner__warnings">
-                  <button
-                    type="button"
-                    className="config-status-banner__toggle"
-                    onClick={() => setWarningsExpanded((prev) => !prev)}
-                  >
-                    {warningsExpanded ? "Hide" : "Show"} {configOpStatus.warnings.length} warning
-                    {configOpStatus.warnings.length !== 1 ? "s" : ""}
-                  </button>
-                  {warningsExpanded ? (
-                    <ul className="config-status-banner__warning-list">
-                      {configOpStatus.warnings.map((w, i) => (
-                        <li key={i}>{w}</li>
-                      ))}
-                    </ul>
-                  ) : null}
-                </div>
-              ) : null}
-            </div>
-            <button
-              type="button"
-              className="config-status-banner__dismiss"
-              onClick={dismissConfigOpStatus}
-              aria-label="Dismiss"
-            >
-              <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
-                <path
-                  d="M10.5 3.5 3.5 10.5M3.5 3.5l7 7"
-                  stroke="currentColor"
-                  strokeWidth="1.5"
-                  strokeLinecap="round"
-                />
-              </svg>
-            </button>
-          </div>
-        ) : null}
-
-        <div className="settings-shell">
-          <div className="settings-tags">
-            {settingsSections.map((section) => (
-              <button
-                key={section.key}
-                type="button"
-                className={cn(
-                  "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
-                  settingsSection === section.key
-                    ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
-                    : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
-                )}
-                onClick={() => setSettingsSection(section.key)}
-              >
-                {section.label}
-              </button>
-            ))}
-            <button
-              key={applicationDetailsSection.key}
-              type="button"
-              className={cn(
-                "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
-                settingsSection === applicationDetailsSection.key
-                  ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
-                  : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
-              )}
-              onClick={() => setSettingsSection(applicationDetailsSection.key)}
-            >
-              {applicationDetailsSection.label}
-            </button>
-            <button
-              key={trackerAuthSection.key}
-              type="button"
-              className={cn(
-                "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
-                settingsSection === trackerAuthSection.key
-                  ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
-                  : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
-              )}
-              onClick={() => setSettingsSection(trackerAuthSection.key)}
-            >
-              {trackerAuthSection.label}
-            </button>
-          </div>
-
-          <div className="settings-body">
-            {settingsSection === applicationDetailsSection.key ? applicationDetailsPanel : null}
-            {settingsSection === trackerAuthSection.key ? trackerAuthPanel : null}
-            {settingsSection !== applicationDetailsSection.key &&
-            settingsSection !== trackerAuthSection.key &&
-            webAuthAvailable ? (
-              <details className="settings-subgroup settings-subgroup--collapsible settings-subgroup--auth">
-                <summary>Secret Encryption</summary>
-                <div>
-                  <p className="helper">
-                    Desktop installs can keep using plaintext secrets, or you can create
-                    <code> web-auth.json </code>
-                    to enable encrypted secret storage for future saves and exports.
-                  </p>
-                  <div className="settings-auth-status">
-                    <span
-                      className={`settings-auth-badge ${webAuthStatus?.usable ? "is-ready" : webAuthStatus?.exists ? "is-warning" : "is-idle"}`}
-                    >
-                      {webAuthLoading
-                        ? "Checking..."
-                        : webAuthStatus?.usable
-                          ? "Encryption enabled"
-                          : webAuthStatus?.exists
-                            ? "Auth file invalid"
-                            : "Plaintext fallback active"}
-                    </span>
-                    {webAuthStatus?.path ? (
-                      <p className="muted">Path: {webAuthStatus.path}</p>
-                    ) : null}
-                    {webAuthStatus?.message ? (
-                      <p className="muted">{webAuthStatus.message}</p>
-                    ) : null}
-                    {webAuthStatus?.usable && webAuthStatus.username ? (
-                      <p className="muted">Configured user: {webAuthStatus.username}</p>
-                    ) : null}
-                    {webAuthStatus?.browseRoot ? (
-                      <p className="muted">Web browse root: {webAuthStatus.browseRoot}</p>
-                    ) : null}
-                    {webAuthStatus?.allowUnrestrictedBrowse ? (
-                      <p className="muted">Web browse access: Unrestricted</p>
-                    ) : null}
-                  </div>
-                  {webAuthStatus?.canCreate ? (
-                    <div className="settings-grid">
-                      <label className="settings-field">
-                        <span>Username</span>
-                        <input
-                          className={settingsInputClass}
-                          value={webAuthUsername}
-                          onChange={(event) => setWebAuthUsername(event.target.value)}
-                          autoComplete="username"
-                        />
-                      </label>
-                      <label className="settings-field">
-                        <span>Password</span>
-                        <input
-                          className={settingsInputClass}
-                          type="password"
-                          value={webAuthPassword}
-                          onChange={(event) => setWebAuthPassword(event.target.value)}
-                          autoComplete="new-password"
-                        />
-                      </label>
-                      <label className="settings-field">
-                        <span>Confirm password</span>
-                        <input
-                          className={settingsInputClass}
-                          type="password"
-                          value={webAuthConfirm}
-                          onChange={(event) => setWebAuthConfirm(event.target.value)}
-                          autoComplete="new-password"
-                        />
-                      </label>
-                    </div>
-                  ) : null}
-                  <div className="settings-auth-actions">
-                    <Button
-                      variant="primary"
-                      type="button"
-                      onClick={handleCreateWebAuth}
-                      disabled={
-                        webAuthLoading ||
-                        webAuthCreating ||
-                        !webAuthStatus?.canCreate ||
-                        !webAuthUsername.trim() ||
-                        !webAuthPassword.trim() ||
-                        !webAuthConfirm.trim()
-                      }
-                    >
-                      {webAuthCreating ? "Creating..." : "Create web-auth.json"}
-                    </Button>
-                  </div>
-                  {webAuthError ? <p className="error">{webAuthError}</p> : null}
-                </div>
-              </details>
-            ) : null}
-            {settingsSection === applicationDetailsSection.key ||
-            settingsSection === trackerAuthSection.key ? null : configData ? (
-              <div className="settings-form">
-                {showAdvancedToggle ? (
-                  <div className="settings-switch-row">
-                    <span>Show advanced</span>
-                    <Switch
-                      aria-label="Show advanced"
-                      checked={advancedOpen}
-                      onChange={(event) =>
-                        setSettingsAdvanced((prev) => ({
-                          ...prev,
-                          [settingsSection]: event.target.checked,
-                        }))
-                      }
-                    />
-                  </div>
-                ) : null}
-                {settingsSection === "image_hosting" ? (
-                  renderImageHostingSection()
-                ) : settingsSection === "trackers" &&
-                  configData.Trackers &&
-                  typeof configData.Trackers === "object" &&
-                  !Array.isArray(configData.Trackers) ? (
-                  renderTrackerSection(advancedOpen)
-                ) : settingsSection === "torrent_clients" &&
-                  configData.TorrentClients &&
-                  typeof configData.TorrentClients === "object" ? (
-                  renderTorrentClientsSection(advancedOpen)
-                ) : (
-                  <div className="settings-grid">
-                    {(() => {
-                      const section = settingsSections.find((item) => item.key === settingsSection);
-                      if (!section) return null;
-                      const sectionData = configData[section.jsonKey];
-                      if (
-                        !sectionData ||
-                        typeof sectionData !== "object" ||
-                        Array.isArray(sectionData)
-                      ) {
-                        return null;
-                      }
-                      const meta = sectionFieldMeta[section.jsonKey] || {};
-                      return Object.entries(sectionData as ConfigMap)
-                        .filter(([key]) => {
-                          const fieldMeta = meta[key];
-                          if (fieldMeta?.advanced && !advancedOpen) return false;
-                          return true;
-                        })
-                        .map(([key, value]) =>
-                          renderField(key, value, [section.jsonKey, key], meta[key]),
-                        );
-                    })()}
-                  </div>
-                )}
-              </div>
-            ) : (
-              <p className="muted">Loading configuration...</p>
-            )}
-          </div>
-        </div>
-
-        {settingsSaved ? <p className="settings-saved">{settingsSaved}</p> : null}
-        {settingsError ? <p className="error">{settingsError}</p> : null}
-      </section>
-
-      <AlertDialog.Root
-        open={importConfirmOpen}
-        onOpenChange={(open) => {
-          if (!open) handleImportConfigCancel();
-        }}
-      >
-        <AlertDialog.Portal>
-          <AlertDialog.Overlay className="import-confirm-overlay" />
-          <AlertDialog.Content className="import-confirm-dialog">
-            <div className="import-confirm-dialog__icon">
-              <svg width="28" height="28" viewBox="0 0 24 24" fill="none">
-                <path d="M12 3 1.5 21h21L12 3Z" fill="currentColor" opacity=".12" />
-                <path
-                  d="M12 3 1.5 21h21L12 3Z"
-                  stroke="currentColor"
-                  strokeWidth="1.6"
-                  strokeLinejoin="round"
-                />
-                <path d="M12 10v5" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
-                <circle cx="12" cy="18" r="1" fill="currentColor" />
-              </svg>
-            </div>
-            <div className="import-confirm-dialog__body">
-              <AlertDialog.Title asChild>
-                <h2 className="import-confirm-dialog__title">Replace current configuration?</h2>
-              </AlertDialog.Title>
-              <AlertDialog.Description asChild>
-                <p className="import-confirm-dialog__message">
-                  Importing a configuration file will overwrite your current settings in the
-                  database. This action cannot be undone.
-                </p>
-              </AlertDialog.Description>
-              <p className="import-confirm-dialog__hint">
-                We strongly recommend exporting your current configuration first so you can restore
-                it if the imported file isn&apos;t what you expected.
-              </p>
-            </div>
-            <div className="import-confirm-dialog__actions">
-              <AlertDialog.Cancel asChild>
-                <Button type="button" disabled={settingsImporting}>
-                  Cancel
-                </Button>
-              </AlertDialog.Cancel>
-              <Button
-                type="button"
-                onClick={handleExportSettings}
-                disabled={settingsExporting || settingsImporting}
-              >
-                {settingsExporting ? "Exporting..." : "Export current config"}
-              </Button>
-              <AlertDialog.Action asChild>
-                <Button
-                  type="button"
-                  variant="primary"
-                  className="import-confirm-dialog__confirm"
-                  onClick={(event) => {
-                    event.preventDefault();
-                    void reloadTrackerAuthAfterConfigChange(handleImportConfigConfirm);
-                  }}
-                  disabled={settingsImporting}
-                >
-                  {settingsImporting ? "Importing..." : "Choose file & import"}
-                </Button>
-              </AlertDialog.Action>
-            </div>
-          </AlertDialog.Content>
-        </AlertDialog.Portal>
-      </AlertDialog.Root>
-    </div>
-  );
-}
-
-function formatApplicationUptime(totalSeconds: number) {
-  const days = Math.floor(totalSeconds / 86400);
-  const hours = Math.floor((totalSeconds % 86400) / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  const parts: string[] = [];
-  if (days > 0) {
-    parts.push(`${days}d`);
-  }
-  if (hours > 0 || parts.length > 0) {
-    parts.push(`${hours}h`);
-  }
-  if (minutes > 0 || parts.length > 0) {
-    parts.push(`${minutes}m`);
-  }
-  parts.push(`${seconds}s`);
-
-  return parts.join(" ");
-}
-
-function formatTrackerAuthState(state?: string) {
-  switch (state) {
-    case "configured":
-      return "Configured";
-    case "has_cookies":
-      return "Has cookies";
-    case "login_required":
-      return "Login required";
-    case "encrypted_storage_unavailable":
-      return "Storage unavailable";
-    case "error":
-      return "Error";
-    default:
-      return "Not configured";
-  }
-}
-
-function statusBadgeClass(state?: string) {
-  switch (state) {
-    case "configured":
-    case "has_cookies":
-      return "is-ready";
-    case "login_required":
-    case "encrypted_storage_unavailable":
-    case "error":
-      return "is-warning";
-    default:
-      return "is-idle";
-  }
-}
-
-function formatTrackerAuthDate(value?: string) {
-  if (!value) {
-    return "Never";
-  }
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    return value;
-  }
-  return date.toLocaleString();
-}
diff --git a/gui/frontend/src/pages/tracker_data/index.test.tsx b/gui/frontend/src/pages/tracker_data/index.test.tsx
deleted file mode 100644
index 86a0cf2d..00000000
--- a/gui/frontend/src/pages/tracker_data/index.test.tsx
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { MetadataPreview } from "../../types";
-import TrackerDataPage from "./index";
-
-describe("TrackerDataPage", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    cleanup();
-  });
-
-  it("does not decode sanitized attribute entities before rendering", () => {
-    const preview = {
-      TrackerData: [
-        {
-          Tracker: "BLU",
-          TrackerID: "1",
-          TorrentURL: "",
-          InfoHash: "",
-          TMDBID: 0,
-          IMDBID: 0,
-          TVDBID: 0,
-          MALID: 0,
-          Category: "",
-          Description: "raw",
-          DescriptionHTML: `<img src="http://invalid.invalid/&#34; onerror=&#34;alert(1)" />`,
-          ImageURLs: [],
-          Filename: "",
-          Matched: false,
-          UpdatedAt: "",
-        },
-      ],
-    } as unknown as MetadataPreview;
-
-    const { container } = render(
-      <TrackerDataPage
-        preview={preview}
-        renderedDescriptions={{ "BLU-0": true }}
-        setRenderedDescriptions={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    const image = container.querySelector(".tracker-description.rendered img");
-    expect(image).toBeInstanceOf(HTMLImageElement);
-    expect(image?.getAttribute("onerror")).toBeNull();
-  });
-
-  it("hides tracker names when favicon-only mode is enabled", () => {
-    const preview = {
-      TrackerData: [
-        {
-          Tracker: "BLUTOPIA",
-          TrackerID: "1",
-          TorrentURL: "",
-          InfoHash: "",
-          TMDBID: 0,
-          IMDBID: 0,
-          TVDBID: 0,
-          MALID: 0,
-          Category: "",
-          Description: "",
-          DescriptionHTML: "",
-          ImageURLs: [],
-          Filename: "",
-          Matched: false,
-          UpdatedAt: "",
-        },
-      ],
-    } as unknown as MetadataPreview;
-
-    render(
-      <TrackerDataPage
-        preview={preview}
-        renderedDescriptions={{}}
-        setRenderedDescriptions={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        useFavicons={true}
-        faviconOnly={true}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    expect(screen.queryByText("BLUTOPIA")).toBeNull();
-    expect(screen.getAllByText("BLU").length).toBeGreaterThan(0);
-  });
-
-  it("renders cached tracker icons without fetching from the page", () => {
-    const getTrackerIcon = vi.fn().mockResolvedValue("");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
-    const preview = {
-      TrackerData: [
-        {
-          Tracker: "BLU",
-          TrackerID: "1",
-          TorrentURL: "https://blutopia.cc/torrents/1",
-          InfoHash: "",
-          TMDBID: 0,
-          IMDBID: 0,
-          TVDBID: 0,
-          MALID: 0,
-          Category: "",
-          Description: "",
-          DescriptionHTML: "",
-          ImageURLs: [],
-          Filename: "",
-          Matched: false,
-          UpdatedAt: "",
-        },
-      ],
-    } as unknown as MetadataPreview;
-
-    const { container } = render(
-      <TrackerDataPage
-        preview={preview}
-        renderedDescriptions={{}}
-        setRenderedDescriptions={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        useFavicons={true}
-        trackerIconSrcByName={{ blu: "data:image/png;base64,iVBORw0KGgo=" }}
-      />,
-    );
-
-    expect(screen.getByText("Torrent ID: 1")).toBeTruthy();
-    expect(container.querySelector("img")).toBeInstanceOf(HTMLImageElement);
-    expect(getTrackerIcon).not.toHaveBeenCalled();
-  });
-
-  it("does not fetch favicons for trackers missing from the cache", () => {
-    const getTrackerIcon = vi.fn().mockResolvedValue("");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
-    const preview = {
-      TrackerData: [
-        {
-          Tracker: "UNCONFIGURED",
-          TrackerID: "1",
-          TorrentURL: "",
-          InfoHash: "",
-          TMDBID: 0,
-          IMDBID: 0,
-          TVDBID: 0,
-          MALID: 0,
-          Category: "",
-          Description: "",
-          DescriptionHTML: "",
-          ImageURLs: [],
-          Filename: "",
-          Matched: false,
-          UpdatedAt: "",
-        },
-      ],
-    } as unknown as MetadataPreview;
-
-    render(
-      <TrackerDataPage
-        preview={preview}
-        renderedDescriptions={{}}
-        setRenderedDescriptions={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        useFavicons={true}
-        faviconOnly={true}
-        trackerIconSrcByName={{}}
-      />,
-    );
-
-    expect(screen.queryByText("UNCONFIGURED")).toBeNull();
-    expect(screen.getAllByText("UNC").length).toBeGreaterThan(0);
-    expect(getTrackerIcon).not.toHaveBeenCalled();
-  });
-});
diff --git a/gui/frontend/src/pages/tracker_data/index.tsx b/gui/frontend/src/pages/tracker_data/index.tsx
deleted file mode 100644
index 0dc976ea..00000000
--- a/gui/frontend/src/pages/tracker_data/index.tsx
+++ /dev/null
@@ -1,246 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useMemo } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import RenderedDescription from "../../components/RenderedDescription";
-import { Button } from "../../components/ui/button";
-import { TrackerIconImage } from "../../components/ui/tracker-icon";
-import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
-import { trackerIconFor } from "../../hooks/useTrackerIcons";
-import type { MetadataPreview, TrackerPreview } from "../../types";
-import { handleExternalLinkClick } from "../../utils/externalLinks";
-
-type Props = {
-  preview: MetadataPreview;
-  renderedDescriptions: Record<string, boolean>;
-  setRenderedDescriptions: Dispatch<SetStateAction<Record<string, boolean>>>;
-  setLightboxImage: Dispatch<SetStateAction<string>>;
-  setLightboxAlt: Dispatch<SetStateAction<string>>;
-  useFavicons?: boolean;
-  faviconOnly?: boolean;
-  trackerIconSrcByName: TrackerIconCache;
-};
-
-export default function TrackerDataPage(props: Props) {
-  const {
-    preview,
-    renderedDescriptions,
-    setRenderedDescriptions,
-    setLightboxImage,
-    setLightboxAlt,
-    useFavicons = true,
-    faviconOnly = false,
-    trackerIconSrcByName,
-  } = props;
-
-  const trackerDataOrdered = useMemo(() => {
-    const items = preview.TrackerData || [];
-    if (items.length === 0) {
-      return { items: [], primaryIndex: -1 };
-    }
-    const hasActualData = (item: TrackerPreview) =>
-      Boolean(
-        item.Description ||
-        item.DescriptionHTML ||
-        (item.ImageURLs && item.ImageURLs.length > 0) ||
-        item.TMDBID ||
-        item.IMDBID ||
-        item.TVDBID ||
-        item.MALID ||
-        item.InfoHash ||
-        item.Category ||
-        item.Filename,
-      );
-    const primaryIndex = items.findIndex(hasActualData);
-    if (primaryIndex <= 0) {
-      return { items, primaryIndex };
-    }
-    const primary = items[primaryIndex];
-    const rest = items.filter((_, index) => index !== primaryIndex);
-    return { items: [primary, ...rest], primaryIndex: 0 };
-  }, [preview.TrackerData]);
-
-  return (
-    <section className="flex flex-col gap-3">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Tracker Data</p>
-        <h1>Input Metadata</h1>
-        <p className="subtitle">Tracker-provided metadata, descriptions, and images.</p>
-      </header>
-      {preview.TrackerData.length === 0 ? (
-        <p className="muted">No tracker data available.</p>
-      ) : (
-        <div className="grid gap-3">
-          {trackerDataOrdered.items.map((item, index) => {
-            const trackerKey = `${item.Tracker}-${index}`;
-            const isRendered =
-              Boolean(renderedDescriptions[trackerKey]) && Boolean(item.DescriptionHTML);
-            const renderedHTML = isRendered ? item.DescriptionHTML : "";
-            const isPrimary = index === trackerDataOrdered.primaryIndex;
-            const iconSrc = trackerIconFor(trackerIconSrcByName, item.Tracker);
-            const hideTrackerName = faviconOnly && useFavicons;
-            return (
-              <details
-                className="overflow-hidden rounded-lg border border-white/10 bg-[rgba(12,16,26,0.78)]"
-                key={trackerKey}
-                open={isPrimary}
-              >
-                <summary className="flex cursor-pointer list-none items-center justify-between gap-3 px-3 py-2 font-semibold marker:content-[''] [&::-webkit-details-marker]:hidden">
-                  <span
-                    aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
-                    className="flex items-center gap-2 min-w-0 overflow-hidden text-ellipsis whitespace-nowrap"
-                  >
-                    <TrackerIconImage
-                      tracker={item.Tracker}
-                      iconSrc={iconSrc}
-                      enabled={useFavicons}
-                    />
-                    {hideTrackerName ? null : item.Tracker || "Unknown"}
-                  </span>
-                  <span className="whitespace-nowrap text-sm font-medium text-[var(--muted)]">
-                    Torrent ID: {item.TrackerID || "-"}
-                  </span>
-                </summary>
-                <div className="grid gap-3 border-t border-white/10 px-3 pb-3 pt-2">
-                  <div className="grid grid-cols-[repeat(auto-fit,minmax(160px,1fr))] gap-2">
-                    <div>
-                      <p className="label">Tracker</p>
-                      {item.TorrentURL ? (
-                        <a
-                          className="tracker-link flex items-center gap-1.5"
-                          href={item.TorrentURL}
-                          aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
-                          target="_blank"
-                          rel="noreferrer"
-                          onAuxClick={handleExternalLinkClick}
-                          onClick={handleExternalLinkClick}
-                        >
-                          <TrackerIconImage
-                            tracker={item.Tracker}
-                            iconSrc={iconSrc}
-                            enabled={useFavicons}
-                          />
-                          {hideTrackerName ? null : item.Tracker || "Unknown"}
-                        </a>
-                      ) : (
-                        <div
-                          aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
-                          className="value flex items-center gap-1.5"
-                        >
-                          <TrackerIconImage
-                            tracker={item.Tracker}
-                            iconSrc={iconSrc}
-                            enabled={useFavicons}
-                          />
-                          {hideTrackerName ? null : <span>{item.Tracker || "Unknown"}</span>}
-                        </div>
-                      )}
-                    </div>
-                    <div>
-                      <p className="label">Matched</p>
-                      <p className="value">{item.Matched ? "Yes" : "No"}</p>
-                    </div>
-                    <div>
-                      <p className="label">Updated</p>
-                      <p className="value">{item.UpdatedAt || "-"}</p>
-                    </div>
-                  </div>
-                  <div className="grid grid-cols-[repeat(auto-fit,minmax(170px,1fr))] gap-2">
-                    <div className="min-w-0">
-                      <p className="label">Torrent ID</p>
-                      <p className="value mono [overflow-wrap:anywhere]">{item.TrackerID || "-"}</p>
-                    </div>
-                    <div className="min-w-0">
-                      <p className="label">Info Hash</p>
-                      <p className="value mono [overflow-wrap:anywhere]">{item.InfoHash || "-"}</p>
-                    </div>
-                    <div className="min-w-0">
-                      <p className="label">Category</p>
-                      <p className="value [overflow-wrap:anywhere]">{item.Category || "-"}</p>
-                    </div>
-                    <div className="min-w-0">
-                      <p className="label">Filename</p>
-                      <p className="value [overflow-wrap:anywhere]">{item.Filename || "-"}</p>
-                    </div>
-                  </div>
-                  <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,1fr))] gap-2">
-                    <div>
-                      <p className="label">TMDB</p>
-                      <p className="value mono">{item.TMDBID || 0}</p>
-                    </div>
-                    <div>
-                      <p className="label">IMDB</p>
-                      <p className="value mono">{item.IMDBID || 0}</p>
-                    </div>
-                    <div>
-                      <p className="label">TVDB</p>
-                      <p className="value mono">{item.TVDBID || 0}</p>
-                    </div>
-                    <div>
-                      <p className="label">MAL</p>
-                      <p className="value mono">{item.MALID || 0}</p>
-                    </div>
-                  </div>
-                  <div>
-                    <div className="flex items-center justify-between gap-2">
-                      <h2>Description</h2>
-                      {item.DescriptionHTML ? (
-                        <Button
-                          className="h-7 rounded-full px-2 text-xs"
-                          type="button"
-                          onClick={() =>
-                            setRenderedDescriptions((prev) => ({
-                              ...prev,
-                              [trackerKey]: !prev[trackerKey],
-                            }))
-                          }
-                        >
-                          {isRendered ? "Show raw" : "Render"}
-                        </Button>
-                      ) : null}
-                    </div>
-                    {isRendered ? (
-                      <RenderedDescription html={renderedHTML} />
-                    ) : (
-                      <p className="tracker-description">
-                        {item.Description || "No description provided."}
-                      </p>
-                    )}
-                  </div>
-                  <div>
-                    <h2>Images</h2>
-                    {item.ImageURLs.length === 0 ? (
-                      <p className="muted">No images provided.</p>
-                    ) : (
-                      <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
-                        {item.ImageURLs.map((url, imageIndex) => (
-                          <button
-                            className="cursor-pointer border-0 bg-transparent p-0"
-                            type="button"
-                            key={`${url}-${imageIndex}`}
-                            onClick={() => {
-                              setLightboxImage(url);
-                              setLightboxAlt(`${item.Tracker || "Tracker"} image`);
-                            }}
-                          >
-                            <img
-                              className="w-full rounded-lg border border-white/10"
-                              src={url}
-                              alt="Tracker"
-                              loading="lazy"
-                            />
-                          </button>
-                        ))}
-                      </div>
-                    )}
-                  </div>
-                </div>
-              </details>
-            );
-          })}
-        </div>
-      )}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/tracker_upload/index.test.tsx b/gui/frontend/src/pages/tracker_upload/index.test.tsx
deleted file mode 100644
index 1be4b9e8..00000000
--- a/gui/frontend/src/pages/tracker_upload/index.test.tsx
+++ /dev/null
@@ -1,376 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { act, cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import TrackerUploadPage from "./index";
-import type { MetadataPreview, TrackerDryRunPreview } from "../../types";
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.unstubAllGlobals();
-  cleanup();
-});
-
-const preview = {
-  SourcePath: "C:\\Media\\Example.Movie.mkv",
-  TrackerName: "",
-  ReleaseName: "Example Movie 2160p WEB-DL DD+ 5.1-GRP",
-  Warnings: [],
-  ReleaseNameOverrides: {},
-  ExternalIDs: {
-    TMDBID: 0,
-    IMDBID: 0,
-    TVDBID: 0,
-    TVmazeID: 0,
-    MALID: 0,
-    Category: "",
-    SourceTMDB: "",
-    SourceIMDB: "",
-    SourceTVDB: "",
-    SourceTVmaze: "",
-    SourceMAL: "",
-  },
-  ExternalIDCandidates: {
-    TMDB: [],
-    IMDB: [],
-    TMDBAutoSelected: false,
-    IMDBAutoSelected: false,
-  },
-  ExternalIDInfo: [],
-  ExternalPreview: [],
-  TrackerData: [],
-} satisfies MetadataPreview;
-
-const dryRunPreview: TrackerDryRunPreview = {
-  SourcePath: "C:\\Media\\Example.Movie.mkv",
-  Trackers: [
-    {
-      Tracker: "AITHER",
-      Status: "ready",
-      Message: "",
-      Banned: false,
-      BannedReason: "",
-      BannedCheckError: "",
-      ReleaseName: "Example.Movie.2160p.WEB-DL.DDP5.1-GRP",
-      OriginalReleaseName: "Example Movie 2160p WEB-DL DD+ 5.1-GRP",
-      UploadReleaseName: "Example.Movie.2160p.WEB-DL.DDP5.1-GRP",
-      ReleaseNameChanged: true,
-      ReleaseNameChangeReason: "tracker naming rules",
-      DescriptionGroup: "",
-      Description: "",
-      Endpoint: "",
-      Payload: {},
-      Files: [],
-      ImageHost: {
-        Status: "",
-        SelectedHost: "",
-        AllowedHosts: [],
-        Warnings: [],
-        Reuploaded: false,
-        Message: "",
-      },
-    },
-  ],
-};
-
-describe("TrackerUploadPage", () => {
-  const baseProps = {
-    trackerUploadItems: [{ name: "AITHER", config: {} }],
-    releasePageTrackerSelection: { AITHER: true },
-    dupedTrackerSet: new Set<string>(),
-    skippedDupeReasons: {},
-    skippedDupeTrackerSet: new Set<string>(),
-    ruleSkipReasons: {},
-    ruleSkippedTrackerSet: new Set<string>(),
-    failedDupeTrackerSet: new Set<string>(),
-    uploadToggles: { AITHER: true },
-    setUploadToggles: vi.fn(),
-    skipClientInjection: false,
-    setSkipClientInjection: vi.fn(),
-    namingOverrides: [],
-    preview,
-    formatLabel: (value: string) => value,
-    uploadRunning: false,
-    uploadError: "",
-    uploadSnapshot: null,
-    dryRunLoading: false,
-    dryRunError: "",
-    dryRunProgress: null,
-    dryRunPreview,
-    trackerQuestionnaireAnswers: {},
-    trackerIconSrcByName: {},
-    onQuestionnaireAnswerChange: vi.fn(),
-    onRunDryRun: vi.fn(),
-    onStartUpload: vi.fn(),
-    onCancelUpload: vi.fn(),
-    onRetryFailed: vi.fn(),
-  };
-
-  it("shows tracker-specific dry-run naming changes on the tracker tile", () => {
-    render(<TrackerUploadPage {...baseProps} />);
-
-    expect(screen.getByText("Name changed")).toBeTruthy();
-    expect(screen.getByText(/Original:/).textContent).toContain(
-      "Example Movie 2160p WEB-DL DD+ 5.1-GRP",
-    );
-    expect(screen.getByText(/Upload:/).textContent).toContain(
-      "Example.Movie.2160p.WEB-DL.DDP5.1-GRP",
-    );
-  });
-
-  it("does not show stale dry-run naming changes for disabled trackers", () => {
-    render(<TrackerUploadPage {...baseProps} uploadToggles={{ AITHER: false }} />);
-
-    expect(screen.queryByText("Name changed")).toBeNull();
-    expect(screen.queryByText(/Upload:/)).toBeNull();
-  });
-
-  it("shows rule warnings without blocking tracker eligibility", () => {
-    render(
-      <TrackerUploadPage
-        {...baseProps}
-        preview={{
-          ...preview,
-          TrackerRuleFailures: {
-            AITHER: [
-              {
-                Rule: "require_metadata_id",
-                Reason: "missing recommended IMDb ID",
-                Severity: "warning",
-              },
-            ],
-          },
-        }}
-      />,
-    );
-
-    expect(screen.getByText("Rule warning: missing recommended IMDb ID")).toBeTruthy();
-    expect(screen.queryByText("Blocked trackers (1)")).toBeNull();
-  });
-
-  it("renders cached tracker icons without fetching from the page", () => {
-    const getTrackerIcon = vi.fn().mockResolvedValue("");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
-
-    const { container } = render(
-      <TrackerUploadPage
-        {...baseProps}
-        trackerIconSrcByName={{ aither: "data:image/png;base64,iVBORw0KGgo=" }}
-      />,
-    );
-
-    expect(container.querySelector("img")).toBeInstanceOf(HTMLImageElement);
-    expect(getTrackerIcon).not.toHaveBeenCalled();
-  });
-
-  it("uses abbreviation fallback for blocked tracker icons without cached icons", () => {
-    render(<TrackerUploadPage {...baseProps} failedDupeTrackerSet={new Set(["aither"])} />);
-
-    expect(screen.getByText("AIT")).toBeTruthy();
-  });
-
-  it("blocks non-rule skipped trackers with the skip reason", () => {
-    render(
-      <TrackerUploadPage
-        {...baseProps}
-        skippedDupeReasons={{ aither: "missing api_key for tracker" }}
-        skippedDupeTrackerSet={new Set(["aither"])}
-      />,
-    );
-
-    expect(screen.getByText("Blocked trackers (1)")).toBeTruthy();
-    expect(screen.getByText("missing api_key for tracker")).toBeTruthy();
-    expect(screen.queryByText("Rule check failed")).toBeNull();
-  });
-
-  it("shows banned-group status and check error copy", () => {
-    render(
-      <TrackerUploadPage
-        {...baseProps}
-        dryRunPreview={{
-          ...dryRunPreview,
-          Trackers: [
-            {
-              ...dryRunPreview.Trackers[0],
-              Banned: true,
-              BannedReason: "",
-              BannedCheckError: "banned group check failed: cache unavailable",
-            },
-          ],
-        }}
-      />,
-    );
-
-    expect(screen.getByText("Banned group")).toBeTruthy();
-    expect(screen.getByText("Release group matched banned list.")).toBeTruthy();
-    expect(screen.getByText("Banned group check")).toBeTruthy();
-    expect(screen.getByText("banned group check failed: cache unavailable")).toBeTruthy();
-    expect(screen.queryByText("matched")).toBeNull();
-  });
-
-  it("hides full tracker names when favicon-only mode is enabled", () => {
-    render(<TrackerUploadPage {...baseProps} faviconOnly={true} useFavicons={true} />);
-
-    expect(screen.queryByText("AITHER")).toBeNull();
-    expect(screen.getAllByText("AIT").length).toBeGreaterThan(0);
-  });
-
-  it("does not lose a pending live dry-run refresh when the timer is cleaned up", () => {
-    vi.useFakeTimers();
-    const firstRun = vi.fn();
-    const secondRun = vi.fn();
-    const { rerender } = render(<TrackerUploadPage {...baseProps} onRunDryRun={firstRun} />);
-
-    rerender(
-      <TrackerUploadPage
-        {...baseProps}
-        namingOverrides={[["AITHER", "Example custom"]]}
-        onRunDryRun={firstRun}
-      />,
-    );
-    rerender(
-      <TrackerUploadPage
-        {...baseProps}
-        namingOverrides={[["AITHER", "Example custom"]]}
-        onRunDryRun={secondRun}
-      />,
-    );
-
-    act(() => {
-      vi.advanceTimersByTime(250);
-    });
-
-    expect(firstRun).not.toHaveBeenCalled();
-    expect(secondRun).toHaveBeenCalledTimes(1);
-    vi.useRealTimers();
-  });
-
-  it("defers live dry-run refresh while dry-run or upload work is running", () => {
-    vi.useFakeTimers();
-    const onRunDryRun = vi.fn();
-    const { rerender } = render(<TrackerUploadPage {...baseProps} onRunDryRun={onRunDryRun} />);
-
-    rerender(
-      <TrackerUploadPage
-        {...baseProps}
-        dryRunLoading={true}
-        namingOverrides={[["AITHER", "Example custom"]]}
-        onRunDryRun={onRunDryRun}
-      />,
-    );
-    act(() => {
-      vi.advanceTimersByTime(500);
-    });
-    expect(onRunDryRun).not.toHaveBeenCalled();
-
-    rerender(
-      <TrackerUploadPage
-        {...baseProps}
-        namingOverrides={[["AITHER", "Example custom"]]}
-        onRunDryRun={onRunDryRun}
-      />,
-    );
-    act(() => {
-      vi.advanceTimersByTime(250);
-    });
-
-    expect(onRunDryRun).toHaveBeenCalledTimes(1);
-    vi.useRealTimers();
-  });
-
-  it("redacts debug dry-run endpoints, payloads, and local file paths", () => {
-    render(
-      <TrackerUploadPage
-        {...baseProps}
-        dryRunPreview={{
-          ...dryRunPreview,
-          Trackers: [
-            {
-              ...dryRunPreview.Trackers[0],
-              DebugSections: [
-                {
-                  Title: "Tracker request",
-                  Endpoint:
-                    "https://tracker.example/upload?api_key=debug-value&name=Example.Release.2026.1080p-GRP",
-                  Files: [
-                    {
-                      Field: "torrent",
-                      Path: "C:\\path\\to\\Example.Release.2026.1080p-GRP.torrent",
-                      Present: true,
-                    },
-                  ],
-                  Payload: {
-                    api_key: "debug-value",
-                    description: "line 1\nline 2",
-                    name: "Example.Release.2026.1080p-GRP",
-                  },
-                },
-              ],
-            },
-          ],
-        }}
-      />,
-    );
-
-    expect(
-      screen.getByText(
-        "https://tracker.example/upload?api_key=[REDACTED]&name=Example.Release.2026.1080p-GRP",
-      ),
-    ).toBeTruthy();
-    expect(screen.getByText("[local path]")).toBeTruthy();
-    expect(screen.getByText("[13 bytes, 2 lines omitted]")).toBeTruthy();
-    expect(screen.getAllByText("[REDACTED]").length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("renders blocked debug dry-run top-level payload and files", () => {
-    render(
-      <TrackerUploadPage
-        {...baseProps}
-        dryRunPreview={{
-          ...dryRunPreview,
-          Trackers: [
-            {
-              ...dryRunPreview.Trackers[0],
-              Status: "blocked",
-              Message: "Manual confirmation required",
-              Payload: {
-                upload_name: "top-level-payload",
-              },
-              Files: [
-                {
-                  Field: "torrent",
-                  Path: ".upbrr/tmp/top-level.torrent",
-                  Present: true,
-                },
-              ],
-              DebugSections: [
-                {
-                  Title: "Debug payload",
-                  Endpoint: "",
-                  Files: [
-                    {
-                      Field: "torrent",
-                      Path: ".upbrr/tmp/debug.torrent",
-                      Present: true,
-                    },
-                  ],
-                  Payload: {
-                    upload_name: "debug-payload",
-                  },
-                },
-              ],
-            },
-          ],
-        }}
-      />,
-    );
-
-    expect(screen.getByText("blocked")).toBeTruthy();
-    expect(screen.getByText("Manual confirmation required")).toBeTruthy();
-    expect(screen.getByText("top-level-payload")).toBeTruthy();
-    expect(screen.getByText(".upbrr/tmp/top-level.torrent")).toBeTruthy();
-    expect(screen.getByText("debug-payload")).toBeTruthy();
-    expect(screen.getByText(".upbrr/tmp/debug.torrent")).toBeTruthy();
-  });
-});
diff --git a/gui/frontend/src/pages/tracker_upload/index.tsx b/gui/frontend/src/pages/tracker_upload/index.tsx
deleted file mode 100644
index c6626f61..00000000
--- a/gui/frontend/src/pages/tracker_upload/index.tsx
+++ /dev/null
@@ -1,927 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useEffect, useMemo, useRef } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import { Button } from "../../components/ui/button";
-import { Checkbox } from "../../components/ui/checkbox";
-import { Switch } from "../../components/ui/switch";
-import { TrackerIconImage } from "../../components/ui/tracker-icon";
-import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
-import { trackerIconFor } from "../../hooks/useTrackerIcons";
-import type {
-  MetadataPreview,
-  TrackerDryRunFile,
-  TrackerDryRunPreview,
-  TrackerUploadItem,
-  TrackerUploadSnapshot,
-  UploadProgressUpdate,
-} from "../../types";
-import { cn } from "../../utils/cn";
-
-type Props = {
-  trackerUploadItems: TrackerUploadItem[];
-  releasePageTrackerSelection: Record<string, boolean>;
-  dupedTrackerSet: Set<string>;
-  skippedDupeReasons: Record<string, string>;
-  skippedDupeTrackerSet: Set<string>;
-  ruleSkipReasons: Record<string, string>;
-  ruleSkippedTrackerSet: Set<string>;
-  failedDupeTrackerSet: Set<string>;
-  uploadToggles: Record<string, boolean>;
-  setUploadToggles: Dispatch<SetStateAction<Record<string, boolean>>>;
-  skipClientInjection: boolean;
-  setSkipClientInjection: Dispatch<SetStateAction<boolean>>;
-  namingOverrides: Array<[string, unknown]>;
-  preview: MetadataPreview;
-  formatLabel: (value: string) => string;
-  uploadRunning: boolean;
-  uploadError: string;
-  uploadSnapshot: TrackerUploadSnapshot | null;
-  dryRunLoading: boolean;
-  dryRunError: string;
-  dryRunProgress: UploadProgressUpdate | null;
-  dryRunPreview: TrackerDryRunPreview;
-  trackerQuestionnaireAnswers: Record<string, Record<string, string>>;
-  useFavicons?: boolean;
-  faviconOnly?: boolean;
-  trackerIconSrcByName: TrackerIconCache;
-  onQuestionnaireAnswerChange: (tracker: string, key: string, value: string) => void;
-  onRunDryRun: () => void;
-  onStartUpload: () => void;
-  onCancelUpload: () => void;
-  onRetryFailed: () => void;
-};
-
-const statusClass = (status: string) => {
-  const normalized = status.replaceAll("_", "-");
-  if (["running", "queued", "ready"].includes(normalized)) {
-    return "border-blue-400/45 text-blue-100";
-  }
-  if (["success", "completed"].includes(normalized)) {
-    return "border-emerald-400/45 text-emerald-100";
-  }
-  if (["failed", "completed-with-errors", "canceled", "blocked"].includes(normalized)) {
-    return "border-red-400/45 text-red-100";
-  }
-  return "border-white/15 text-[var(--muted)]";
-};
-
-const subtleBox = "rounded-md border border-white/10 bg-white/5 px-2 py-1.5";
-const blockReasonClass =
-  "inline-flex h-5 items-center rounded border border-red-400/30 bg-red-500/10 px-1.5 text-[11px] font-semibold leading-none text-red-700 dark:text-red-100";
-const formatStatusText = (value: string) => value.replaceAll("_", " ");
-const trimName = (value: unknown) => String(value || "").trim();
-const dryRunPayloadPreviewLimit = 240;
-
-const sensitiveDryRunPayloadKeys = new Set([
-  "anticsrftoken",
-  "accesstoken",
-  "apikey",
-  "apitoken",
-  "auth",
-  "authorization",
-  "authkey",
-  "authtoken",
-  "cookie",
-  "csrf",
-  "email",
-  "infohash",
-  "key",
-  "passkey",
-  "password",
-  "passwordconfirm",
-  "passwordconfirmation",
-  "popcron",
-  "refreshtoken",
-  "rsskey",
-  "secret",
-  "secretkey",
-  "sessionkey",
-  "sessiontoken",
-  "token",
-  "torrentpass",
-  "torrentpasskey",
-  "uid",
-  "user",
-  "userid",
-  "username",
-]);
-
-const normalizedDryRunPayloadKey = (key: string) => key.trim().toLowerCase();
-
-const normalizedSensitiveDryRunPayloadKey = (key: string) =>
-  key
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]/g, "");
-
-const isSensitiveDryRunPayloadField = (key: string) =>
-  sensitiveDryRunPayloadKeys.has(normalizedSensitiveDryRunPayloadKey(key));
-
-const isDryRunBodyPayloadField = (key: string) =>
-  new Set([
-    "description",
-    "desc",
-    "descr",
-    "release_desc",
-    "album_desc",
-    "mediainfo",
-    "mediainfo[]",
-    "media_info",
-    "bdinfo",
-    "bd_info",
-    "techinfo",
-    "technical_info",
-    "technicaldetails",
-  ]).has(normalizedDryRunPayloadKey(key));
-
-const redactDryRunSecretFragments = (value: string) =>
-  value
-    .replace(/([?&])([^=&#\s]+)=([^&#\s]*)/g, (match, separator, key) =>
-      isSensitiveDryRunPayloadField(String(key)) ? `${separator}${key}=[REDACTED]` : match,
-    )
-    .replace(
-      /(^|[\s,{])([A-Za-z][A-Za-z0-9_-]*(?:key|token|pass|password|cookie|auth|secret|csrf|uid|user))\s*[:=]\s*[^\s,;}]+/gi,
-      (_match, prefix, key) =>
-        isSensitiveDryRunPayloadField(String(key)) ? `${prefix}${key}=[REDACTED]` : _match,
-    );
-
-const summarizeDryRunBody = (value: string) => {
-  const trimmed = value.trim();
-  if (!trimmed) return "";
-  const lines = trimmed.split(/\r\n|\r|\n/).length;
-  return `[${trimmed.length} bytes, ${lines} lines omitted]`;
-};
-
-const formatDryRunPayloadValue = (key: string, value: unknown) => {
-  const trimmed = String(value ?? "").trim();
-  if (!trimmed) return "";
-  if (isSensitiveDryRunPayloadField(key)) return "[REDACTED]";
-
-  const redacted = redactDryRunSecretFragments(trimmed);
-  if (isDryRunBodyPayloadField(key)) return summarizeDryRunBody(redacted);
-
-  const compact = redacted.replace(/\s+/g, " ");
-  if (compact.length <= dryRunPayloadPreviewLimit) return compact;
-  return `${compact.slice(0, dryRunPayloadPreviewLimit)}... [${redacted.length} bytes total]`;
-};
-
-const formatDryRunFilePath = (value: string) => {
-  const trimmed = value.trim();
-  if (!trimmed) return "(none)";
-
-  const normalized = trimmed.replaceAll("\\", "/").toLowerCase();
-  const original = trimmed.replaceAll("\\", "/");
-  for (const marker of [".upbrr/tmp/", ".upbrr/cache/", ".upbrr/logs/"]) {
-    if (normalized.startsWith(marker)) return original;
-    const index = normalized.indexOf(`/${marker}`);
-    if (index >= 0) return original.slice(index + 1);
-  }
-  return "[local path]";
-};
-
-const dryRunFileKey = (file: TrackerDryRunFile) => `${file.Field}-${file.Path}`;
-
-export default function TrackerUploadPage(props: Readonly<Props>) {
-  const {
-    trackerUploadItems,
-    releasePageTrackerSelection,
-    dupedTrackerSet,
-    skippedDupeReasons,
-    skippedDupeTrackerSet,
-    ruleSkipReasons,
-    ruleSkippedTrackerSet,
-    failedDupeTrackerSet,
-    uploadToggles,
-    setUploadToggles,
-    skipClientInjection,
-    setSkipClientInjection,
-    namingOverrides,
-    preview,
-    formatLabel,
-    uploadRunning,
-    uploadError,
-    uploadSnapshot,
-    dryRunLoading,
-    dryRunError,
-    dryRunProgress,
-    dryRunPreview,
-    trackerQuestionnaireAnswers,
-    useFavicons = true,
-    faviconOnly = false,
-    trackerIconSrcByName,
-    onQuestionnaireAnswerChange,
-    onRunDryRun,
-    onStartUpload,
-    onCancelUpload,
-    onRetryFailed,
-  } = props;
-
-  const visibleTrackers = useMemo(
-    () => trackerUploadItems.filter((tracker) => releasePageTrackerSelection[tracker.name]),
-    [trackerUploadItems, releasePageTrackerSelection],
-  );
-
-  const ruleWarningsByTracker = useMemo(() => {
-    const warnings: Record<string, string[]> = {};
-    Object.entries(preview.TrackerRuleFailures || {}).forEach(([tracker, failures]) => {
-      const key = tracker.toLowerCase().trim();
-      const reasons = (failures || [])
-        .filter((failure) => String(failure.Severity || "").toLowerCase() === "warning")
-        .map((failure) => failure.Reason?.trim() || failure.Rule?.trim())
-        .filter((reason): reason is string => Boolean(reason));
-      if (key && reasons.length > 0) warnings[key] = reasons;
-    });
-    return warnings;
-  }, [preview.TrackerRuleFailures]);
-
-  const trackerBlockState = useMemo(() => {
-    const next: Record<string, { blocked: boolean; reasons: string[]; hardBlocked: boolean }> = {};
-    visibleTrackers.forEach((tracker) => {
-      const normalized = tracker.name.toLowerCase().trim();
-      const reasons: string[] = [];
-      const hasFailedDupe = failedDupeTrackerSet.has(normalized);
-      const hasDupes = dupedTrackerSet.has(normalized);
-      const hasRuleSkip = ruleSkippedTrackerSet.has(normalized);
-      const hasSkippedDupe = skippedDupeTrackerSet.has(normalized);
-      if (hasFailedDupe) {
-        reasons.push("Dupe check failed");
-      }
-      if (hasDupes) {
-        reasons.push("Dupes found");
-      }
-      if (hasRuleSkip) {
-        reasons.push(ruleSkipReasons[normalized] || "Rule check failed");
-      } else if (hasSkippedDupe) {
-        reasons.push(skippedDupeReasons[normalized] || "Dupe check skipped");
-      }
-      next[tracker.name] = {
-        blocked: reasons.length > 0,
-        reasons,
-        hardBlocked: hasFailedDupe,
-      };
-    });
-    return next;
-  }, [
-    visibleTrackers,
-    failedDupeTrackerSet,
-    dupedTrackerSet,
-    skippedDupeReasons,
-    skippedDupeTrackerSet,
-    ruleSkippedTrackerSet,
-    ruleSkipReasons,
-  ]);
-
-  const availableTrackers = useMemo(
-    () => visibleTrackers.filter((tracker) => !trackerBlockState[tracker.name]?.blocked),
-    [visibleTrackers, trackerBlockState],
-  );
-
-  const blockedTrackers = useMemo(
-    () => visibleTrackers.filter((tracker) => trackerBlockState[tracker.name]?.blocked),
-    [visibleTrackers, trackerBlockState],
-  );
-
-  const selectedTrackerCount = useMemo(
-    () =>
-      availableTrackers.filter((tracker) => {
-        const normalized = tracker.name.toLowerCase().trim();
-        if (!uploadToggles[tracker.name]) return false;
-        if (dupedTrackerSet.has(normalized)) return false;
-        if (skippedDupeTrackerSet.has(normalized)) return false;
-        if (ruleSkippedTrackerSet.has(normalized)) return false;
-        if (failedDupeTrackerSet.has(normalized)) return false;
-        return true;
-      }).length,
-    [
-      availableTrackers,
-      uploadToggles,
-      dupedTrackerSet,
-      skippedDupeTrackerSet,
-      ruleSkippedTrackerSet,
-      failedDupeTrackerSet,
-    ],
-  );
-
-  const trackerStatusMap = useMemo(() => {
-    const next: Record<
-      string,
-      {
-        status: string;
-        task: string;
-        taskStatus: string;
-        message: string;
-        percent: number;
-        totalPieces: number;
-      }
-    > = {};
-    (uploadSnapshot?.trackers || []).forEach((entry) => {
-      if (!entry?.tracker) return;
-      next[entry.tracker] = {
-        status: String(entry.status || "").toLowerCase(),
-        task: String(entry.task || "").toLowerCase(),
-        taskStatus: String(entry.taskStatus || "").toLowerCase(),
-        message: entry.message || "",
-        percent: Number(entry.percent || 0),
-        totalPieces: Number(entry.totalPieces || 0),
-      };
-    });
-    return next;
-  }, [uploadSnapshot]);
-
-  const uploadStatus = String(uploadSnapshot?.status || "").toLowerCase();
-  const activeProgress =
-    dryRunLoading && dryRunProgress
-      ? {
-          task: String(dryRunProgress.task || "").toLowerCase(),
-          status: String(dryRunProgress.status || "").toLowerCase(),
-          message: dryRunProgress.message || "",
-          percent: Number(dryRunProgress.percent || 0),
-          totalPieces: Number(dryRunProgress.totalPieces || 0),
-        }
-      : {
-          task: String(uploadSnapshot?.currentTask || "").toLowerCase(),
-          status: String(uploadSnapshot?.currentTaskStatus || "").toLowerCase(),
-          message: uploadSnapshot?.currentMessage || "",
-          percent: Number(uploadSnapshot?.currentPercent || 0),
-          totalPieces: Number(uploadSnapshot?.currentTotalPieces || 0),
-        };
-  const currentTask = activeProgress.task;
-  const currentTaskStatus = activeProgress.status;
-  const currentMessage = activeProgress.message;
-  const currentPercent = activeProgress.percent;
-  const currentTotalPieces = activeProgress.totalPieces;
-  const canRetry = !uploadRunning && (uploadSnapshot?.failedTrackers?.length || 0) > 0;
-  const lastDryRunSelectionKey = useRef("");
-  const dryRunMap = useMemo(() => {
-    const next: Record<string, (typeof dryRunPreview.Trackers)[number]> = {};
-    (dryRunPreview?.Trackers || []).forEach((entry) => {
-      const key = String(entry?.Tracker || "")
-        .toLowerCase()
-        .trim();
-      if (!key) return;
-      next[key] = entry;
-    });
-    return next;
-  }, [dryRunPreview]);
-  const selectedTrackerKey = useMemo(
-    () =>
-      availableTrackers
-        .filter((tracker) => Boolean(uploadToggles[tracker.name]))
-        .map((tracker) => tracker.name.toLowerCase().trim())
-        .sort()
-        .join("|"),
-    [availableTrackers, uploadToggles],
-  );
-  const namingOverrideKey = useMemo(() => JSON.stringify(namingOverrides), [namingOverrides]);
-
-  useEffect(() => {
-    const refreshKey = `${selectedTrackerKey}:${namingOverrideKey}`;
-    if (!dryRunPreview?.Trackers?.length || !selectedTrackerKey) {
-      lastDryRunSelectionKey.current = refreshKey;
-      return;
-    }
-    if (!lastDryRunSelectionKey.current) {
-      lastDryRunSelectionKey.current = refreshKey;
-      return;
-    }
-    if (lastDryRunSelectionKey.current === refreshKey) return;
-
-    if (dryRunLoading || uploadRunning) return;
-
-    const timeout = window.setTimeout(() => {
-      lastDryRunSelectionKey.current = refreshKey;
-      onRunDryRun();
-    }, 250);
-    return () => window.clearTimeout(timeout);
-  }, [
-    dryRunLoading,
-    dryRunPreview,
-    namingOverrideKey,
-    onRunDryRun,
-    selectedTrackerKey,
-    uploadRunning,
-  ]);
-
-  const renderQuestionnaireField = (
-    trackerName: string,
-    field: NonNullable<(typeof dryRunPreview.Trackers)[number]["Questionnaire"]>["Fields"][number],
-    value: string,
-  ) => {
-    if (field.Kind === "textarea") {
-      return (
-        <textarea
-          className="text-input min-h-24 w-full resize-y"
-          value={value}
-          placeholder={field.Placeholder || ""}
-          onChange={(event) =>
-            onQuestionnaireAnswerChange(trackerName, field.Key, event.target.value)
-          }
-          rows={4}
-        />
-      );
-    }
-
-    if (field.Kind === "select" && field.Options?.length) {
-      return (
-        <select
-          className="text-input w-full appearance-auto"
-          value={value}
-          onChange={(event) =>
-            onQuestionnaireAnswerChange(trackerName, field.Key, event.target.value)
-          }
-        >
-          <option value="">{field.Placeholder || "Select an option"}</option>
-          {field.Options.map((option) => (
-            <option key={option} value={option}>
-              {option}
-            </option>
-          ))}
-        </select>
-      );
-    }
-
-    if (field.Kind === "boolean") {
-      const checked = value === "true";
-      const checkboxId = `questionnaire-${trackerName}-${field.Key}`;
-      return (
-        <div className="inline-flex items-center gap-2 text-sm text-[var(--text)]">
-          <Checkbox
-            id={checkboxId}
-            checked={checked}
-            onCheckedChange={(nextChecked) =>
-              onQuestionnaireAnswerChange(trackerName, field.Key, nextChecked ? "true" : "false")
-            }
-          />
-          <label className="cursor-pointer" htmlFor={checkboxId}>
-            {field.Placeholder || "Enabled"}
-          </label>
-        </div>
-      );
-    }
-
-    return (
-      <input
-        className="text-input w-full"
-        type="text"
-        value={value}
-        placeholder={field.Placeholder || ""}
-        onChange={(event) =>
-          onQuestionnaireAnswerChange(trackerName, field.Key, event.target.value)
-        }
-      />
-    );
-  };
-
-  return (
-    <section className="flex flex-col gap-2.5">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Tracker Upload</p>
-        <h1>Upload Targets</h1>
-        <p className="subtitle">Toggle trackers and review naming changes before upload.</p>
-        <div className="mt-2 flex flex-wrap items-center gap-2">
-          <Button
-            type="button"
-            variant="primary"
-            onClick={onStartUpload}
-            disabled={uploadRunning || selectedTrackerCount === 0}
-          >
-            {uploadRunning ? "Uploading..." : "Start Upload"}
-          </Button>
-          <Button
-            type="button"
-            onClick={onRunDryRun}
-            disabled={dryRunLoading || uploadRunning || selectedTrackerCount === 0}
-          >
-            {dryRunLoading ? "Running Dry Run..." : "Run Dry Run"}
-          </Button>
-          <Button type="button" onClick={onCancelUpload} disabled={!uploadRunning}>
-            Cancel
-          </Button>
-          <Button type="button" onClick={onRetryFailed} disabled={!canRetry}>
-            Retry Failed
-          </Button>
-          <label
-            className="inline-flex items-center gap-2 text-sm text-[var(--text)]"
-            htmlFor="skip-client-injection"
-          >
-            <Checkbox
-              id="skip-client-injection"
-              checked={skipClientInjection}
-              disabled={uploadRunning}
-              onCheckedChange={setSkipClientInjection}
-            />
-            <span>Skip client injection</span>
-          </label>
-          <p className="m-0 text-xs text-[var(--muted)]">
-            Selected: {selectedTrackerCount} · Uploaded: {uploadSnapshot?.uploadedCount || 0}
-          </p>
-          {uploadStatus ? (
-            <p className="m-0 text-xs text-[var(--muted)]">
-              Job status: {formatStatusText(uploadStatus)}
-            </p>
-          ) : null}
-        </div>
-        {currentTask || currentMessage ? (
-          <div
-            className="mt-2 grid gap-1.5 rounded-md border border-white/10 bg-white/5 px-2.5 py-1.5 text-xs"
-            role="status"
-          >
-            <div className="flex flex-wrap items-center gap-2">
-              <span className="font-semibold text-[var(--text)]">Current task</span>
-              {currentTask ? (
-                <span
-                  className={cn(
-                    "inline-flex items-center rounded-full border px-2 py-0.5 capitalize",
-                    statusClass(currentTaskStatus || uploadStatus || "running"),
-                  )}
-                >
-                  {formatStatusText(currentTask)}
-                </span>
-              ) : null}
-              {currentMessage ? (
-                <span className="text-[var(--muted)] [overflow-wrap:anywhere]">
-                  {currentMessage}
-                </span>
-              ) : null}
-            </div>
-            {currentTotalPieces > 0 ? (
-              <div className="h-1.5 overflow-hidden rounded-full bg-white/10">
-                <div
-                  className="h-full rounded-full bg-[var(--accent)] transition-[width]"
-                  style={{ width: `${Math.max(0, Math.min(100, currentPercent))}%` }}
-                />
-              </div>
-            ) : null}
-          </div>
-        ) : null}
-        {uploadError ? <p className="error">{uploadError}</p> : null}
-        {dryRunError ? <p className="error">{dryRunError}</p> : null}
-      </header>
-
-      {visibleTrackers.length === 0 ? (
-        <p className="muted">No tracker entries with credentials or details were found.</p>
-      ) : (
-        <div className="grid gap-1.5">
-          {blockedTrackers.length > 0 ? (
-            <details className="rounded-lg border border-white/10 bg-white/5 px-2.5 py-2">
-              <summary className="cursor-pointer list-none text-sm font-semibold marker:content-[''] [&::-webkit-details-marker]:hidden">
-                Blocked trackers ({blockedTrackers.length})
-              </summary>
-              <div className="mt-2 grid gap-1">
-                {blockedTrackers.map((tracker) => {
-                  const state = trackerBlockState[tracker.name];
-                  const iconSrc = trackerIconFor(trackerIconSrcByName, tracker.name);
-                  return (
-                    <div
-                      className="flex flex-wrap items-center justify-between gap-2 rounded-md border border-white/10 bg-white/5 px-2 py-1.5"
-                      key={tracker.name}
-                    >
-                      <span className="value text-sm leading-5 flex items-center gap-1.5">
-                        <TrackerIconImage
-                          tracker={tracker.name}
-                          iconSrc={iconSrc}
-                          enabled={useFavicons}
-                        />
-                        {faviconOnly && useFavicons ? null : tracker.name}
-                      </span>
-                      <div className="flex flex-wrap items-center justify-end gap-1">
-                        {state?.reasons.map((reason) => (
-                          <span className={blockReasonClass} key={`${tracker.name}-${reason}`}>
-                            {reason}
-                          </span>
-                        ))}
-                        {state?.hardBlocked ? (
-                          <span className="text-xs text-[var(--muted)]">not uploadable</span>
-                        ) : null}
-                      </div>
-                    </div>
-                  );
-                })}
-              </div>
-            </details>
-          ) : null}
-
-          {availableTrackers.map((tracker) => {
-            const normalizedTrackerName = tracker.name.toLowerCase().trim();
-            const selected = Boolean(uploadToggles[tracker.name]);
-            const enabled = selected;
-            const trackerStatus = trackerStatusMap[tracker.name];
-            const dryRun = selected ? dryRunMap[normalizedTrackerName] : undefined;
-            const imageHost = dryRun?.ImageHost;
-            const imageHostWarnings = imageHost?.Warnings || [];
-            const ruleWarnings = ruleWarningsByTracker[normalizedTrackerName] || [];
-            const iconSrc = trackerIconFor(trackerIconSrcByName, tracker.name);
-            const imageHostStatus = String(imageHost?.Status || "").toLowerCase();
-            const questionnaire = dryRun?.Questionnaire;
-            const questionnaireAnswers =
-              trackerQuestionnaireAnswers[tracker.name.toUpperCase().trim()] || {};
-            const originalReleaseName = trimName(
-              dryRun?.OriginalReleaseName || preview.ReleaseName,
-            );
-            const uploadReleaseName = trimName(dryRun?.UploadReleaseName || dryRun?.ReleaseName);
-            const releaseNameChanged =
-              Boolean(dryRun?.ReleaseNameChanged) ||
-              (Boolean(originalReleaseName) &&
-                Boolean(uploadReleaseName) &&
-                originalReleaseName !== uploadReleaseName);
-            let statusLabel = trackerStatus?.status || "";
-            if (!statusLabel) {
-              statusLabel = enabled ? "ready" : "disabled";
-            }
-
-            return (
-              <article
-                className="grid gap-1.5 rounded-lg border border-white/10 bg-white/5 px-2.5 py-2"
-                key={tracker.name}
-              >
-                <div className="flex items-center justify-between gap-2">
-                  <div className="flex flex-wrap items-center gap-2">
-                    <TrackerIconImage
-                      tracker={tracker.name}
-                      iconSrc={iconSrc}
-                      enabled={useFavicons}
-                    />
-                    {faviconOnly && useFavicons ? null : (
-                      <p className="value text-base leading-5">{tracker.name}</p>
-                    )}
-                    <span
-                      className={cn(
-                        "inline-flex items-center rounded-full border px-2 py-0.5 text-xs capitalize",
-                        statusClass(statusLabel),
-                      )}
-                    >
-                      {formatStatusText(statusLabel)}
-                    </span>
-                  </div>
-                  <Switch
-                    aria-label={`Enable upload for ${tracker.name}`}
-                    checked={selected}
-                    onChange={(event) =>
-                      setUploadToggles((prev) => ({
-                        ...prev,
-                        [tracker.name]: event.target.checked,
-                      }))
-                    }
-                  />
-                </div>
-
-                {trackerStatus?.task || trackerStatus?.message ? (
-                  <div className="grid gap-1">
-                    <p className="m-0 flex flex-wrap items-center gap-1.5 text-xs text-[var(--muted)]">
-                      {trackerStatus.task ? (
-                        <span
-                          className={cn(
-                            "inline-flex items-center rounded border px-1.5 py-0.5 capitalize",
-                            statusClass(trackerStatus.taskStatus || trackerStatus.status),
-                          )}
-                        >
-                          {formatStatusText(trackerStatus.task)}
-                        </span>
-                      ) : null}
-                      {trackerStatus.message ? (
-                        <span className="[overflow-wrap:anywhere]">{trackerStatus.message}</span>
-                      ) : null}
-                    </p>
-                    {trackerStatus.totalPieces > 0 ? (
-                      <div className="h-1 overflow-hidden rounded-full bg-white/10">
-                        <div
-                          className="h-full rounded-full bg-[var(--accent)] transition-[width]"
-                          style={{
-                            width: `${Math.max(0, Math.min(100, trackerStatus.percent))}%`,
-                          }}
-                        />
-                      </div>
-                    ) : null}
-                  </div>
-                ) : null}
-                {imageHost?.Message &&
-                (imageHostWarnings.length > 0 || imageHostStatus === "warning") ? (
-                  <p className="m-0 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-xs text-amber-100 [overflow-wrap:anywhere]">
-                    {imageHost.Message}
-                  </p>
-                ) : null}
-                {imageHostWarnings.map((warning, index) => {
-                  const host = String(warning.Host || "").trim();
-                  const message = String(warning.Message || "").trim();
-                  if (!host && !message) return null;
-                  return (
-                    <p
-                      className="m-0 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-xs text-amber-100 [overflow-wrap:anywhere]"
-                      key={`${tracker.name}-${host || "host"}-${index}`}
-                    >
-                      {host ? `${host} failed` : "Image host warning"}
-                      {message ? `: ${message}` : ""}
-                    </p>
-                  );
-                })}
-                {ruleWarnings.map((warning, index) => (
-                  <p
-                    className="m-0 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-xs text-amber-100 [overflow-wrap:anywhere]"
-                    key={`${tracker.name}-rule-warning-${index}`}
-                  >
-                    Rule warning: {warning}
-                  </p>
-                ))}
-
-                {releaseNameChanged ? (
-                  <div className="grid gap-1 rounded-md border border-amber-300/55 bg-amber-300/12 px-2.5 py-2">
-                    <div className="flex flex-wrap items-center gap-1.5">
-                      <span className="inline-flex items-center rounded border border-amber-300/50 px-1.5 py-0.5 text-[11px] font-semibold uppercase leading-none text-amber-100">
-                        Name changed
-                      </span>
-                      {dryRun?.ReleaseNameChangeReason ? (
-                        <span className="text-xs text-amber-100/80">
-                          {dryRun.ReleaseNameChangeReason}
-                        </span>
-                      ) : null}
-                    </div>
-                    <div className="grid gap-1 text-xs">
-                      <p className="m-0 text-[var(--muted)] [overflow-wrap:anywhere]">
-                        Original:{" "}
-                        <span className="mono text-[var(--text)]">{originalReleaseName}</span>
-                      </p>
-                      <p className="m-0 text-amber-100 [overflow-wrap:anywhere]">
-                        Upload: <span className="mono font-semibold">{uploadReleaseName}</span>
-                      </p>
-                    </div>
-                  </div>
-                ) : null}
-
-                <details>
-                  <summary className="cursor-pointer list-none text-sm font-semibold marker:content-[''] [&::-webkit-details-marker]:hidden">
-                    Dry run data
-                  </summary>
-                  <div className="mt-2 grid gap-1.5">
-                    {dryRun ? (
-                      <>
-                        <div>
-                          <p className="label">Status</p>
-                          <p className="value mono">{dryRun.Status || "ready"}</p>
-                        </div>
-                        {dryRun.Message ? (
-                          <div>
-                            <p className="label">Message</p>
-                            <p className="value">{dryRun.Message}</p>
-                          </div>
-                        ) : null}
-                        {dryRun.Banned ? (
-                          <div>
-                            <p className="label">Banned group</p>
-                            <p className="value">
-                              {dryRun.BannedReason || "Release group matched banned list."}
-                            </p>
-                          </div>
-                        ) : null}
-                        {dryRun.BannedCheckError ? (
-                          <div>
-                            <p className="label">Banned group check</p>
-                            <p className="value">{dryRun.BannedCheckError}</p>
-                          </div>
-                        ) : null}
-                        {dryRun.ReleaseName ? (
-                          <div>
-                            <p className="label">Release name</p>
-                            <p className="value mono">{dryRun.ReleaseName}</p>
-                          </div>
-                        ) : null}
-                        {dryRun.DescriptionGroup ? (
-                          <div>
-                            <p className="label">Description group</p>
-                            <p className="value mono">{dryRun.DescriptionGroup}</p>
-                          </div>
-                        ) : null}
-                        {dryRun.Endpoint ? (
-                          <div>
-                            <p className="label">Endpoint</p>
-                            <p className="value mono">
-                              {formatDryRunPayloadValue("endpoint", dryRun.Endpoint)}
-                            </p>
-                          </div>
-                        ) : null}
-                        {dryRun.DebugSections?.length ? (
-                          <div className="grid gap-1.5">
-                            <p className="label">Debug sections</p>
-                            {dryRun.DebugSections.map((section, sectionIndex) => (
-                              <div
-                                className={subtleBox}
-                                key={`${section.Title || "debug"}-${sectionIndex}`}
-                              >
-                                <p className="label">{section.Title || "Debug section"}</p>
-                                {section.Endpoint ? (
-                                  <p className="value mono">
-                                    {formatDryRunPayloadValue("endpoint", section.Endpoint)}
-                                  </p>
-                                ) : null}
-                                {section.Files?.length ? (
-                                  <div className="mt-1 grid gap-1">
-                                    {section.Files.map((file) => (
-                                      <div key={dryRunFileKey(file)}>
-                                        <p className="label">File · {file.Field}</p>
-                                        <p className="value mono">
-                                          {formatDryRunFilePath(file.Path)}
-                                        </p>
-                                      </div>
-                                    ))}
-                                  </div>
-                                ) : null}
-                                {Object.keys(section.Payload || {}).length ? (
-                                  <div className="mt-1 grid gap-1">
-                                    {Object.entries(section.Payload)
-                                      .sort(([left], [right]) => left.localeCompare(right))
-                                      .map(([key, value]) => (
-                                        <div key={key}>
-                                          <p className="label">{key}</p>
-                                          <p className="value mono">
-                                            {formatDryRunPayloadValue(key, value)}
-                                          </p>
-                                        </div>
-                                      ))}
-                                  </div>
-                                ) : null}
-                              </div>
-                            ))}
-                          </div>
-                        ) : null}
-                        {dryRun.Files?.length ? (
-                          <div className="grid gap-1.5">
-                            {dryRun.Files.map((file) => (
-                              <div className={subtleBox} key={dryRunFileKey(file)}>
-                                <p className="label">File · {file.Field}</p>
-                                <p className="value mono">{formatDryRunFilePath(file.Path)}</p>
-                              </div>
-                            ))}
-                          </div>
-                        ) : null}
-                        {Object.keys(dryRun.Payload || {}).length ? (
-                          <div className="grid gap-1.5">
-                            {Object.entries(dryRun.Payload)
-                              .sort(([left], [right]) => left.localeCompare(right))
-                              .map(([key, value]) => (
-                                <div className={subtleBox} key={key}>
-                                  <p className="label">{key}</p>
-                                  <p className="value mono">
-                                    {formatDryRunPayloadValue(key, value)}
-                                  </p>
-                                </div>
-                              ))}
-                          </div>
-                        ) : null}
-                        {questionnaire?.Fields?.length ? (
-                          <div>
-                            <p className="label">Questionnaire</p>
-                            <div className="grid gap-1.5">
-                              {questionnaire.Fields.map((field) => (
-                                <label className={subtleBox} key={field.Key}>
-                                  <p className="label">
-                                    {field.Label || field.Key}
-                                    {field.Required ? " *" : ""}
-                                  </p>
-                                  {renderQuestionnaireField(
-                                    tracker.name,
-                                    field,
-                                    questionnaireAnswers[field.Key] ?? field.Value ?? "",
-                                  )}
-                                  {field.Help ? <p className="muted">{field.Help}</p> : null}
-                                </label>
-                              ))}
-                            </div>
-                          </div>
-                        ) : null}
-                      </>
-                    ) : (
-                      <p className="muted">Run dry run to generate tracker payload fields.</p>
-                    )}
-                  </div>
-                </details>
-
-                {namingOverrides.length > 0 ? (
-                  <details>
-                    <summary className="cursor-pointer list-none text-sm font-semibold marker:content-[''] [&::-webkit-details-marker]:hidden">
-                      Naming changes
-                    </summary>
-                    <div className="mt-2 grid gap-1.5">
-                      <div>
-                        <p className="label">Release name</p>
-                        <p className="value mono">{preview.ReleaseName || "No release name yet"}</p>
-                      </div>
-                      <div className="grid gap-1.5">
-                        {namingOverrides.map(([key, value]) => (
-                          <div className={subtleBox} key={key}>
-                            <p className="label">{formatLabel(key)}</p>
-                            <p className="value mono">{String(value)}</p>
-                          </div>
-                        ))}
-                      </div>
-                    </div>
-                  </details>
-                ) : null}
-              </article>
-            );
-          })}
-        </div>
-      )}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/pages/upload_images/index.test.tsx b/gui/frontend/src/pages/upload_images/index.test.tsx
deleted file mode 100644
index 4a466534..00000000
--- a/gui/frontend/src/pages/upload_images/index.test.tsx
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import UploadImagesPage from "./index";
-
-describe("UploadImagesPage", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("shows remote tracker image URLs without downloaded local artifacts", () => {
-    const trackerImageURL = "https://images.example/screen.png";
-
-    render(
-      <UploadImagesPage
-        path="C:/media/Movie.mkv"
-        uploadHost="imgbb"
-        setUploadHost={vi.fn()}
-        configuredImageHosts={["imgbb"]}
-        resolveImageHostLabel={(value) => value}
-        uploadImagesLoading={false}
-        uploadProgress={{ current: 0, total: 0 }}
-        setAllUploadSelections={vi.fn()}
-        handleUploadImages={vi.fn()}
-        uploadImagesError=""
-        uploadImageFailures={[]}
-        uploadCandidates={[]}
-        uploadSelections={{}}
-        toggleUploadSelection={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        uploadedRecordByPath={new Map()}
-        uploadedImages={[]}
-        uploadedImageRecords={[]}
-        trackerImageLinks={[]}
-        trackerImageURLs={[trackerImageURL]}
-        handleDeleteUploadedImage={vi.fn()}
-        handleDeleteTrackerImage={vi.fn()}
-      />,
-    );
-
-    expect(screen.getByText(trackerImageURL)).toBeInTheDocument();
-    expect(screen.getByRole("link", { name: "Raw URL" })).toHaveAttribute("href", trackerImageURL);
-  });
-
-  it("labels menu-purpose upload candidates", () => {
-    render(
-      <UploadImagesPage
-        path="C:/media/Example"
-        uploadHost="imgbb"
-        setUploadHost={vi.fn()}
-        configuredImageHosts={["imgbb"]}
-        resolveImageHostLabel={(value) => value}
-        uploadImagesLoading={false}
-        uploadProgress={{ current: 0, total: 0 }}
-        setAllUploadSelections={vi.fn()}
-        handleUploadImages={vi.fn()}
-        uploadImagesError=""
-        uploadImageFailures={[]}
-        uploadCandidates={[
-          {
-            image: {
-              Index: 0,
-              TimestampSeconds: 0,
-              Path: "C:/managed/menu.png",
-              Purpose: "menu",
-              Width: 720,
-              Height: 480,
-              SizeBytes: 1024,
-            },
-            dataUri: "data:image/png;base64,example",
-          },
-        ]}
-        uploadSelections={{}}
-        toggleUploadSelection={vi.fn()}
-        setLightboxImage={vi.fn()}
-        setLightboxAlt={vi.fn()}
-        uploadedRecordByPath={new Map()}
-        uploadedImages={[]}
-        uploadedImageRecords={[]}
-        trackerImageLinks={[]}
-        trackerImageURLs={[]}
-        handleDeleteUploadedImage={vi.fn()}
-        handleDeleteTrackerImage={vi.fn()}
-      />,
-    );
-
-    expect(screen.getByText("Disc menu")).toBeInTheDocument();
-  });
-});
diff --git a/gui/frontend/src/pages/upload_images/index.tsx b/gui/frontend/src/pages/upload_images/index.tsx
deleted file mode 100644
index 5fc99085..00000000
--- a/gui/frontend/src/pages/upload_images/index.tsx
+++ /dev/null
@@ -1,495 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { useMemo } from "react";
-import type { Dispatch, SetStateAction } from "react";
-import { Button } from "../../components/ui/button";
-import type {
-  ScreenshotLinkedImage,
-  ScreenshotPreviewImage,
-  UploadedImageLink,
-  UploadImageHostFailure,
-} from "../../types";
-import { cn } from "../../utils/cn";
-import { handleExternalLinkClick } from "../../utils/externalLinks";
-
-type UploadedByHost = { host: string; items: UploadedImageLink[] };
-
-type Props = Readonly<{
-  path: string;
-  uploadHost: string;
-  setUploadHost: Dispatch<SetStateAction<string>>;
-  configuredImageHosts: string[];
-  resolveImageHostLabel: (value: string) => string;
-  uploadImagesLoading: boolean;
-  uploadProgress: { current: number; total: number };
-  setAllUploadSelections: (value: boolean) => void;
-  handleUploadImages: (selected: ScreenshotPreviewImage[]) => void;
-  uploadImagesError: string;
-  uploadImageFailures: UploadImageHostFailure[];
-  uploadCandidates: ScreenshotPreviewImage[];
-  uploadSelections: Record<string, boolean>;
-  toggleUploadSelection: (imagePath: string) => void;
-  setLightboxImage: Dispatch<SetStateAction<string>>;
-  setLightboxAlt: Dispatch<SetStateAction<string>>;
-  uploadedRecordByPath: Map<string, UploadedImageLink>;
-  uploadedImages: UploadedImageLink[];
-  uploadedImageRecords: UploadedImageLink[];
-  trackerImageLinks: ScreenshotLinkedImage[];
-  trackerImageURLs: string[];
-  handleDeleteUploadedImage: (imagePath: string, host: string) => void;
-  handleDeleteTrackerImage: (url: string) => void;
-}>;
-
-export default function UploadImagesPage(props: Props) {
-  const {
-    path,
-    uploadHost,
-    setUploadHost,
-    configuredImageHosts,
-    resolveImageHostLabel,
-    uploadImagesLoading,
-    uploadProgress,
-    setAllUploadSelections,
-    handleUploadImages,
-    uploadImagesError,
-    uploadImageFailures,
-    uploadCandidates,
-    uploadSelections,
-    toggleUploadSelection,
-    setLightboxImage,
-    setLightboxAlt,
-    uploadedRecordByPath,
-    uploadedImages,
-    uploadedImageRecords,
-    trackerImageLinks,
-    trackerImageURLs,
-    handleDeleteUploadedImage,
-    handleDeleteTrackerImage,
-  } = props;
-
-  const uploadCandidateCount = uploadCandidates.length;
-
-  const selectedUploadCandidates = useMemo(() => {
-    return uploadCandidates.filter((item) => {
-      const pathValue = item.image.Path;
-      if (!pathValue) return false;
-      if (uploadSelections[pathValue] === undefined) return true;
-      return Boolean(uploadSelections[pathValue]);
-    });
-  }, [uploadCandidates, uploadSelections]);
-
-  const uploadSelectedCount = selectedUploadCandidates.length;
-
-  const previouslyUploadedImages = useMemo(() => {
-    return [...uploadedImageRecords].sort((left, right) => {
-      const leftTime = left.UploadedAt ? Date.parse(left.UploadedAt) : 0;
-      const rightTime = right.UploadedAt ? Date.parse(right.UploadedAt) : 0;
-      if (leftTime !== rightTime) return rightTime - leftTime;
-      return left.ImagePath.localeCompare(right.ImagePath);
-    });
-  }, [uploadedImageRecords]);
-
-  const previouslyUploadedByHost: UploadedByHost[] = useMemo(() => {
-    const grouped = new Map<string, UploadedImageLink[]>();
-
-    // Add actual uploaded images from database.
-    previouslyUploadedImages.forEach((img) => {
-      const hostKey = (img.Host || "unknown").trim() || "unknown";
-      const bucket = grouped.get(hostKey) || [];
-      bucket.push(img);
-      grouped.set(hostKey, bucket);
-    });
-
-    const trackerURLs = new Set<string>();
-
-    // Add downloaded tracker images as if they were previously uploaded.
-    trackerImageLinks.forEach((link) => {
-      if (link.URL) {
-        trackerURLs.add(link.URL);
-      }
-      const hostKey = (link.Host || "unknown").trim() || "unknown";
-      const bucket = grouped.get(hostKey) || [];
-      const uploadedFormat: UploadedImageLink = {
-        SourcePath: "",
-        ImagePath: link.Path,
-        Host: hostKey,
-        UsageScope: "global",
-        ImgURL: link.URL,
-        RawURL: link.URL,
-        WebURL: link.URL,
-        SizeBytes: 0,
-        UploadedAt: "",
-      };
-      bucket.push(uploadedFormat);
-      grouped.set(hostKey, bucket);
-    });
-
-    // Add remote tracker images even when local artifact download was rejected.
-    trackerImageURLs.forEach((url) => {
-      if (!url || trackerURLs.has(url)) {
-        return;
-      }
-      let hostKey = "tracker";
-      try {
-        hostKey = new URL(url).hostname || hostKey;
-      } catch {
-        // Keep generic tracker bucket for malformed URLs.
-      }
-      const bucket = grouped.get(hostKey) || [];
-      bucket.push({
-        SourcePath: "",
-        ImagePath: url,
-        Host: hostKey,
-        UsageScope: "global",
-        ImgURL: url,
-        RawURL: url,
-        WebURL: url,
-        SizeBytes: 0,
-        UploadedAt: "",
-      });
-      grouped.set(hostKey, bucket);
-    });
-
-    const hostIndex = new Map<string, number>();
-    configuredImageHosts.forEach((host, index) => {
-      hostIndex.set(host, index);
-    });
-    return Array.from(grouped.entries())
-      .map(([host, items]) => ({ host, items }))
-      .sort((left, right) => {
-        const leftRank = hostIndex.has(left.host)
-          ? hostIndex.get(left.host)!
-          : Number.MAX_SAFE_INTEGER;
-        const rightRank = hostIndex.has(right.host)
-          ? hostIndex.get(right.host)!
-          : Number.MAX_SAFE_INTEGER;
-        if (leftRank !== rightRank) return leftRank - rightRank;
-        return left.host.localeCompare(right.host);
-      });
-  }, [configuredImageHosts, previouslyUploadedImages, trackerImageLinks, trackerImageURLs]);
-
-  return (
-    <section className="grid gap-3">
-      <header className="max-w-3xl">
-        <p className="eyebrow">Image Hosting</p>
-        <h1>Upload Images</h1>
-        <p className="subtitle">
-          Select screenshots and upload to every host needed by the active trackers.
-        </p>
-      </header>
-
-      <section className="panel grid gap-2.5">
-        <div className="min-w-0">
-          <p className="label">Source path</p>
-          <p className="value [overflow-wrap:anywhere] text-sm">{path || "No path selected"}</p>
-        </div>
-        <div className="grid items-end gap-3 md:grid-cols-[minmax(220px,1fr)_auto]">
-          <label className="settings-field">
-            <span>Default upload host</span>
-            <select
-              value={uploadHost}
-              onChange={(event) => setUploadHost(event.target.value)}
-              disabled={configuredImageHosts.length === 0}
-            >
-              {configuredImageHosts.length === 0 ? (
-                <option value="">No hosts configured</option>
-              ) : null}
-              {configuredImageHosts.map((host) => (
-                <option key={host} value={host}>
-                  {resolveImageHostLabel(host)}
-                </option>
-              ))}
-            </select>
-          </label>
-          <div className="flex flex-wrap items-center gap-2">
-            <Button type="button" onClick={() => setAllUploadSelections(true)}>
-              Select all
-            </Button>
-            <Button type="button" onClick={() => setAllUploadSelections(false)}>
-              Select none
-            </Button>
-            <Button
-              variant="primary"
-              type="button"
-              onClick={() => handleUploadImages(selectedUploadCandidates)}
-              disabled={uploadImagesLoading || uploadSelectedCount === 0 || !uploadHost}
-            >
-              {uploadImagesLoading ? "Uploading..." : `Upload ${uploadSelectedCount}`}
-            </Button>
-          </div>
-        </div>
-        <div className="flex flex-wrap gap-3">
-          <span className="muted">Available: {uploadCandidateCount}</span>
-          <span className="muted">Selected: {uploadSelectedCount}</span>
-        </div>
-        {uploadImagesLoading && uploadProgress.total > 0 ? (
-          <div className="grid gap-1.5">
-            <div className="h-4 w-full overflow-hidden rounded-full border border-white/10 bg-white/10">
-              <div
-                className="h-full rounded-full bg-[var(--accent-2)] transition-[width]"
-                style={{
-                  width: `${Math.round((uploadProgress.current / uploadProgress.total) * 100)}%`,
-                }}
-              />
-            </div>
-            <p className="m-0 text-center text-sm text-[var(--muted)]">
-              Uploading... {uploadProgress.current} of {uploadProgress.total}
-            </p>
-          </div>
-        ) : null}
-        {uploadImagesError ? <p className="error">{uploadImagesError}</p> : null}
-        {uploadImageFailures.length > 0 ? (
-          <div className="grid gap-1">
-            {uploadImageFailures.map((failure, index) => {
-              const trackers = (failure.Trackers || []).filter(Boolean);
-              const trackerLabel = trackers.length > 0 ? ` Blocks: ${trackers.join(", ")}.` : "";
-              return (
-                <p className="error" key={`${failure.Host || "host"}-${index}`}>
-                  {failure.Host || "Image host"} failed: {failure.Message || "upload failed"}.
-                  {trackerLabel}
-                </p>
-              );
-            })}
-          </div>
-        ) : null}
-      </section>
-
-      {uploadCandidateCount === 0 ? (
-        <section className="panel">
-          <p className="muted">No screenshots available yet. Generate screenshots first.</p>
-        </section>
-      ) : (
-        <section className="panel grid gap-2.5">
-          <div className="flex flex-wrap items-baseline justify-between gap-2">
-            <h2>Available Images</h2>
-            <p className="muted">Click a thumbnail to preview. Toggle to include in upload.</p>
-          </div>
-          <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
-            {uploadCandidates.map((item) => {
-              const pathValue = item.image.Path;
-              const selected = pathValue ? uploadSelections[pathValue] !== false : false;
-              const record = pathValue ? uploadedRecordByPath.get(pathValue) : undefined;
-              const hostLabel = item.image.Host || record?.Host;
-              const imgLink = item.image.ImgURL || record?.ImgURL;
-              const rawLink = item.image.RawURL || record?.RawURL;
-              const isUploaded = Boolean(hostLabel && rawLink);
-              return (
-                <div
-                  className="relative grid gap-1.5"
-                  key={`upload-${pathValue || item.image.Index}`}
-                >
-                  <button
-                    className={cn(
-                      "screens-thumb",
-                      selected &&
-                        "border-[var(--accent-2)] shadow-[0_0_0_2px_rgba(53,194,193,0.2)]",
-                      isUploaded && "border-emerald-500/60 opacity-85",
-                    )}
-                    type="button"
-                    onClick={() => {
-                      setLightboxImage(item.dataUri);
-                      setLightboxAlt("Upload candidate");
-                    }}
-                  >
-                    <img src={item.dataUri} alt="Upload candidate" />
-                    {isUploaded ? (
-                      <span
-                        className="pointer-events-none absolute right-1.5 top-1.5 rounded bg-emerald-800 px-1.5 py-1 text-xs font-semibold text-slate-50"
-                        title={`Already uploaded to ${hostLabel}`}
-                      >
-                        Uploaded {hostLabel}
-                      </span>
-                    ) : null}
-                    {item.image.Purpose === "menu" ? (
-                      <span className="pointer-events-none absolute bottom-1.5 left-1.5 rounded bg-sky-900 px-1.5 py-1 text-xs font-semibold text-sky-50">
-                        Disc menu
-                      </span>
-                    ) : null}
-                  </button>
-                  <Button
-                    className={cn(
-                      "h-7 text-xs",
-                      selected && "border-[var(--accent-2)] bg-[rgba(53,194,193,0.18)]",
-                    )}
-                    type="button"
-                    onClick={() => pathValue && toggleUploadSelection(pathValue)}
-                  >
-                    {selected ? "Selected" : "Select"}
-                  </Button>
-                  {isUploaded && imgLink ? (
-                    <div className="flex justify-center gap-1.5">
-                      <a
-                        className="inline-flex h-7 items-center justify-center rounded-md border border-white/10 bg-white/5 px-2 text-xs no-underline hover:bg-white/10"
-                        href={imgLink}
-                        target="_blank"
-                        rel="noreferrer"
-                        onAuxClick={handleExternalLinkClick}
-                        title="View image"
-                        onClick={handleExternalLinkClick}
-                      >
-                        View
-                      </a>
-                    </div>
-                  ) : null}
-                </div>
-              );
-            })}
-          </div>
-        </section>
-      )}
-
-      {previouslyUploadedByHost.length > 0 ? (
-        <section className="panel grid gap-2.5">
-          <div className="flex flex-wrap items-baseline justify-between gap-2">
-            <h2>Previously Uploaded Images</h2>
-            <p className="muted">
-              Images from previous uploads and tracker descriptions. Click delete to remove from
-              database.
-            </p>
-          </div>
-          <div className="grid gap-3">
-            {previouslyUploadedByHost.map((group) => (
-              <div className="grid gap-2" key={`prev-host-${group.host}`}>
-                <h3 className="m-0 text-xs font-semibold uppercase tracking-[0.12em] text-[var(--text)]">
-                  {resolveImageHostLabel(group.host)}
-                </h3>
-                <div className="grid grid-cols-[repeat(auto-fit,minmax(220px,1fr))] gap-2">
-                  {group.items.map((img, index) => (
-                    <div
-                      className="grid min-w-0 gap-1 rounded-lg border border-white/10 bg-[rgba(12,16,26,0.78)] p-2 [&_.tracker-link]:[overflow-wrap:anywhere] [&_.value]:[overflow-wrap:anywhere]"
-                      key={`prev-uploaded-${img.ImagePath}-${img.Host}-${index}`}
-                    >
-                      <p className="label">Image</p>
-                      <p className="value mono">{img.ImagePath || "Unknown"}</p>
-                      {img.ImgURL ? (
-                        <a
-                          className="tracker-link"
-                          href={img.ImgURL}
-                          target="_blank"
-                          rel="noreferrer"
-                          onAuxClick={handleExternalLinkClick}
-                          onClick={handleExternalLinkClick}
-                        >
-                          View image
-                        </a>
-                      ) : null}
-                      {img.RawURL ? (
-                        <a
-                          className="tracker-link"
-                          href={img.RawURL}
-                          target="_blank"
-                          rel="noreferrer"
-                          onAuxClick={handleExternalLinkClick}
-                          onClick={handleExternalLinkClick}
-                        >
-                          Raw URL
-                        </a>
-                      ) : null}
-                      {img.WebURL ? (
-                        <a
-                          className="tracker-link"
-                          href={img.WebURL}
-                          target="_blank"
-                          rel="noreferrer"
-                          onAuxClick={handleExternalLinkClick}
-                          onClick={handleExternalLinkClick}
-                        >
-                          Web URL
-                        </a>
-                      ) : null}
-                      {img.SourcePath ? (
-                        <button
-                          className="danger justify-self-start"
-                          type="button"
-                          onClick={() => handleDeleteUploadedImage(img.ImagePath, img.Host)}
-                        >
-                          Delete
-                        </button>
-                      ) : (
-                        <button
-                          className="danger justify-self-start"
-                          type="button"
-                          onClick={() => handleDeleteTrackerImage(img.RawURL || img.ImgURL)}
-                        >
-                          Remove
-                        </button>
-                      )}
-                    </div>
-                  ))}
-                </div>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-
-      {uploadedImages.length > 0 ? (
-        <section className="panel grid gap-2.5">
-          <div className="flex flex-wrap items-baseline justify-between gap-2">
-            <h2>Upload Results</h2>
-            <p className="muted">Links returned from the image host.</p>
-          </div>
-          <div className="grid grid-cols-[repeat(auto-fit,minmax(220px,1fr))] gap-2">
-            {uploadedImages.map((image, index) => (
-              <div
-                className="grid min-w-0 gap-1 rounded-lg border border-white/10 bg-[rgba(12,16,26,0.78)] p-2 [&_.tracker-link]:[overflow-wrap:anywhere] [&_.value]:[overflow-wrap:anywhere]"
-                key={`uploaded-${image.ImagePath}-${index}`}
-              >
-                <p className="label">Image</p>
-                <p className="value mono">{image.ImagePath || "Unknown"}</p>
-                <p className="label">Host</p>
-                <p className="value mono">{image.Host || uploadHost}</p>
-                {image.ImgURL ? (
-                  <a
-                    className="tracker-link"
-                    href={image.ImgURL}
-                    target="_blank"
-                    rel="noreferrer"
-                    onAuxClick={handleExternalLinkClick}
-                    onClick={handleExternalLinkClick}
-                  >
-                    View image
-                  </a>
-                ) : null}
-                {image.RawURL ? (
-                  <a
-                    className="tracker-link"
-                    href={image.RawURL}
-                    target="_blank"
-                    rel="noreferrer"
-                    onAuxClick={handleExternalLinkClick}
-                    onClick={handleExternalLinkClick}
-                  >
-                    Raw URL
-                  </a>
-                ) : null}
-                {image.WebURL ? (
-                  <a
-                    className="tracker-link"
-                    href={image.WebURL}
-                    target="_blank"
-                    rel="noreferrer"
-                    onAuxClick={handleExternalLinkClick}
-                    onClick={handleExternalLinkClick}
-                  >
-                    Web URL
-                  </a>
-                ) : null}
-                <button
-                  className="danger justify-self-start"
-                  type="button"
-                  onClick={() =>
-                    handleDeleteUploadedImage(image.ImagePath, image.Host || uploadHost)
-                  }
-                >
-                  Delete
-                </button>
-              </div>
-            ))}
-          </div>
-        </section>
-      ) : null}
-    </section>
-  );
-}
diff --git a/gui/frontend/src/test/setup.ts b/gui/frontend/src/test/setup.ts
deleted file mode 100644
index 16ecc557..00000000
--- a/gui/frontend/src/test/setup.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import "@testing-library/jest-dom/vitest";
diff --git a/gui/frontend/src/types.ts b/gui/frontend/src/types.ts
deleted file mode 100644
index 3c7431ad..00000000
--- a/gui/frontend/src/types.ts
+++ /dev/null
@@ -1,1291 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-/** Resolved external IDs returned by metadata resolution for the current source path. */
-export type ExternalIDs = {
-  TMDBID: number;
-  IMDBID: number;
-  TVDBID: number;
-  TVmazeID: number;
-  /** Canonical anime identifier used for MAL and MAL/AniList-compatible tracker fields. */
-  MALID: number;
-  Category: string;
-  /** Resolver source labels for each provider ID, such as tracker, mediainfo, tmdb, or scene. */
-  SourceTMDB: string;
-  SourceIMDB: string;
-  SourceTVDB: string;
-  SourceTVmaze: string;
-  /** Resolver source label for MALID. */
-  SourceMAL: string;
-};
-
-/** External ID overrides use null/undefined for untouched fields and 0 for an explicit clear. */
-export type ExternalIDOverrides = {
-  TMDBID?: number | null;
-  IMDBID?: number | null;
-  TVDBID?: number | null;
-  TVmazeID?: number | null;
-  /** Canonical MAL/AniList-compatible anime identifier override. */
-  MALID?: number | null;
-};
-
-export type ReleaseNameOverrides = {
-  Category?: string | null;
-  Type?: string | null;
-  Source?: string | null;
-  Resolution?: string | null;
-  Tag?: string | null;
-  Service?: string | null;
-  Edition?: string | null;
-  Season?: string | null;
-  Episode?: string | null;
-  EpisodeTitle?: string | null;
-  ManualYear?: number | null;
-  ManualDate?: string | null;
-  UseSeasonEpisode?: boolean | null;
-  NoSeason?: boolean | null;
-  NoYear?: boolean | null;
-  NoAKA?: boolean | null;
-  NoTag?: boolean | null;
-  NoEdition?: boolean | null;
-  NoDub?: boolean | null;
-  NoDual?: boolean | null;
-  DualAudio?: boolean | null;
-  Region?: string | null;
-};
-
-export type ExternalIDInfo = {
-  Provider: string;
-  ID: number;
-  Source: string;
-};
-
-export type ExternalIDCandidate = {
-  Provider: string;
-  ID: number;
-  Title: string;
-  OriginalTitle: string;
-  Year: number;
-  Category: string;
-  MediaType: string;
-  Overview: string;
-  PosterURL: string;
-  Similarity: number;
-};
-
-export type ExternalIDCandidates = {
-  TMDB: ExternalIDCandidate[];
-  IMDB: ExternalIDCandidate[];
-  TMDBAutoSelected: boolean;
-  IMDBAutoSelected: boolean;
-};
-
-export type TMDBCompany = {
-  ID: number;
-  Name: string;
-  LogoPath: string;
-  OriginCountry: string;
-};
-
-export type TMDBCountry = {
-  ISO3166: string;
-  Name: string;
-};
-
-export type TMDBNetwork = {
-  ID: number;
-  Name: string;
-  LogoPath: string;
-  OriginCountry: string;
-};
-
-export type TMDBMetadata = {
-  TMDBID: number;
-  IMDBID: number;
-  TVDBID: number;
-  Category: string;
-  Title: string;
-  OriginalTitle: string;
-  Year: number;
-  ReleaseDate: string;
-  FirstAirDate: string;
-  LastAirDate: string;
-  OriginCountry: string[];
-  OriginalLanguage: string;
-  Overview: string;
-  Poster: string;
-  TMDBPosterPath: string;
-  Logo: string;
-  TMDBLogo: string;
-  Backdrop: string;
-  TMDBType: string;
-  Runtime: number;
-  Genres: string;
-  GenreIDs: string;
-  Creators: string[];
-  Directors: string[];
-  Cast: string[];
-  MALID: number;
-  Anime: boolean;
-  Demographic: string;
-  RetrievedAKA: string;
-  Keywords: string;
-  /** Maps TMDB translation language keys, such as "de" or "pt-BR", to localized titles. */
-  LocalizedTitles: Record<string, string>;
-  YouTube: string;
-  Certification: string;
-  ProductionCompanies: TMDBCompany[];
-  ProductionCountries: TMDBCountry[];
-  Networks: TMDBNetwork[];
-  IMDbMismatch: boolean;
-  MismatchedIMDbID: number;
-};
-
-export type IMDBPerson = {
-  ID: string;
-  Name: string;
-};
-
-export type IMDBEditionDetail = {
-  DisplayName: string;
-  Seconds: number;
-  Minutes: number;
-  Attributes: string[];
-};
-
-export type IMDBAKA = {
-  Title: string;
-  Country: string;
-  Language: string;
-  Attributes: string[];
-};
-
-export type IMDBReleaseDate = {
-  Year: number;
-  Month: number;
-  Day: number;
-};
-
-export type IMDBEpisode = {
-  ID: string;
-  Title: string;
-  ReleaseYear: number;
-  ReleaseDate: IMDBReleaseDate;
-  Season: number;
-  EpisodeText: string;
-};
-
-export type IMDBSeasonSummary = {
-  Season: number;
-  Year: number;
-  YearRange: string;
-};
-
-export type IMDBMetadata = {
-  IMDBID: number;
-  IMDbIDText: string;
-  IMDbURL: string;
-  Title: string;
-  Year: number;
-  EndYear: number;
-  AKA: string;
-  Type: string;
-  Plot: string;
-  Rating: number;
-  RatingCount: number;
-  RatingText: string;
-  RuntimeMinutes: number;
-  RuntimeText: string;
-  Genres: string;
-  Country: string;
-  CountryList: string;
-  Cover: string;
-  Directors: IMDBPerson[];
-  Creators: IMDBPerson[];
-  Writers: IMDBPerson[];
-  Stars: IMDBPerson[];
-  Editions: string[];
-  EditionDetails: Record<string, IMDBEditionDetail>;
-  Akas: IMDBAKA[];
-  Episodes: IMDBEpisode[];
-  SeasonsSummary: IMDBSeasonSummary[];
-  SoundMixes: string[];
-  TVYear: number;
-  OriginalLanguage: string;
-};
-
-export type TVDBMetadata = {
-  TVDBID: number;
-  Name: string;
-  NameEnglish: string;
-  Overview: string;
-  OverviewEnglish: string;
-  FirstAired: string;
-  Year: number;
-  /** True when Year is naming-eligible for TV release names. */
-  YearFromAlias: boolean;
-  /** TVDB source used for Year, such as first_aired, translation_name, translation_alias, extended_alias, or slug. */
-  YearSource: string;
-  /** "high" for explicit title or alias years; "low" for guarded slug-derived naming years. */
-  YearConfidence: string;
-  Type: string;
-  Status: string;
-  Network: string;
-  OriginalCountry: string;
-  OriginalLanguage: string;
-  HasEnglish: boolean;
-  Genres: string;
-  Poster: string;
-  Aliases: string[];
-  EpisodeSeason: number;
-  EpisodeNumber: number;
-  EpisodeName: string;
-  EpisodeNameEnglish: string;
-  EpisodeOverview: string;
-  EpisodeOverviewEnglish: string;
-  EpisodeAired: string;
-  /** Selected episode image URL when TVDB returned one. */
-  EpisodeImage: string;
-  /** Fetched TVDB episode entries, usually for the selected season. */
-  Episodes: TVDBEpisodeMetadata[];
-};
-
-/** One TVDB episode entry used by tracker descriptions. */
-export type TVDBEpisodeMetadata = {
-  ID: number;
-  SeasonNumber: number;
-  EpisodeNumber: number;
-  EpisodeName: string;
-  EpisodeNameEnglish: string;
-  EpisodeOverview: string;
-  EpisodeOverviewEnglish: string;
-  /** TVDB air date string used in tracker descriptions. */
-  EpisodeAired: string;
-  /** Episode image URL when TVDB returned one. */
-  EpisodeImage: string;
-};
-
-export type TVmazeMetadata = {
-  TVmazeID: number;
-  Name: string;
-  Premiered: string;
-  Ended: string;
-  Summary: string;
-  Status: string;
-  Type: string;
-  Language: string;
-  Genres: string;
-  Runtime: number;
-  AverageRuntime: number;
-  Rating: number;
-  Weight: number;
-  OfficialSite: string;
-  Country: string;
-  Network: string;
-  NetworkCountry: string;
-  NetworkLogo: string;
-  WebChannel: string;
-  WebCountry: string;
-  WebLogo: string;
-  Poster: string;
-  PosterMedium: string;
-  Backdrop: string;
-  BackdropMedium: string;
-  IMDBID: number;
-  TVDBID: number;
-};
-
-/** AniList media tag shown in the MAL/AniList preview. */
-export type AniListTag = {
-  Name: string;
-  /** AniList tag relevance percentage from 0 to 100. */
-  Rank: number;
-  Category: string;
-  /** Adult/spoiler markers used to hide sensitive tag labels in preview UI. */
-  IsAdult: boolean;
-  IsGeneralSpoiler: boolean;
-  IsMediaSpoiler: boolean;
-};
-
-/** Studio attached to an AniList media entry. */
-export type AniListStudio = {
-  ID: number;
-  Name: string;
-  /** AniList studio page URL. */
-  SiteURL: string;
-};
-
-/** Trailer reference returned by AniList. */
-export type AniListTrailer = {
-  ID: string;
-  Site: string;
-  /** Provider thumbnail URL when AniList supplies one. */
-  Thumbnail: string;
-};
-
-/** Next scheduled episode for an airing AniList media entry. */
-export type AniListAiringEpisode = {
-  /** Unix timestamp in seconds. */
-  AiringAt: number;
-  /** Seconds from AniList's response time until AiringAt. */
-  TimeUntilAiring: number;
-  Episode: number;
-};
-
-/** Public provider or official link attached to AniList media. */
-export type AniListExternalLink = {
-  Site: string;
-  /** Public provider or official URL. */
-  URL: string;
-  Type: string;
-  Language: string;
-};
-
-/**
- * AniList media snapshot used by the MAL/AniList metadata preview.
- *
- * Mirrors the shared Go API contract: date strings preserve AniList
- * fuzzy-date precision, score fields are 0-100 percentages, and airing
- * timestamps are Unix seconds.
- */
-export type AniListMetadata = {
-  /** AniList media ID used in AniList URLs. */
-  AniListID: number;
-  /** MyAnimeList media ID used as upbrr's canonical anime ID. */
-  MALID: number;
-  /** Canonical AniList media page URL. */
-  SiteURL: string;
-  /** Localized AniList title variants. */
-  TitleRomaji: string;
-  TitleEnglish: string;
-  TitleNative: string;
-  TitleUserPreferred: string;
-  /** Plain-text media description from AniList. */
-  Description: string;
-  /** AniList enum value such as TV, MOVIE, or OVA. */
-  Format: string;
-  /** AniList enum value such as FINISHED or RELEASING. */
-  Status: string;
-  /** YYYY, YYYY-MM, or YYYY-MM-DD depending on AniList precision. */
-  StartDate: string;
-  /** YYYY, YYYY-MM, or YYYY-MM-DD depending on AniList precision. */
-  EndDate: string;
-  /** AniList season enum such as WINTER or SPRING. */
-  Season: string;
-  SeasonYear: number;
-  Episodes: number;
-  /** Average episode duration in minutes. */
-  Duration: number;
-  CountryOfOrigin: string;
-  /** AniList source enum such as MANGA, ORIGINAL, or LIGHT_NOVEL. */
-  Source: string;
-  /** AniList image URLs and dominant cover color. */
-  CoverExtraLarge: string;
-  CoverLarge: string;
-  CoverMedium: string;
-  CoverColor: string;
-  BannerImage: string;
-  Genres: string[];
-  Synonyms: string[];
-  /** AniList percentage score from 0 to 100. */
-  AverageScore: number;
-  /** AniList percentage score from 0 to 100. */
-  MeanScore: number;
-  Popularity: number;
-  Favourites: number;
-  IsAdult: boolean;
-  /** Includes adult/spoiler markers so the UI can filter sensitive tags. */
-  Tags: AniListTag[];
-  Studios: AniListStudio[];
-  Trailer: AniListTrailer;
-  NextAiringEpisode: AniListAiringEpisode;
-  ExternalLinks: AniListExternalLink[];
-};
-
-export type WebAuthStatus = {
-  path: string;
-  exists: boolean;
-  usable: boolean;
-  canCreate: boolean;
-  username: string;
-  allowUnencryptedExport: boolean;
-  browseRoot: string;
-  allowUnrestrictedBrowse: boolean;
-  encryptionEnabled: boolean;
-  message: string;
-};
-
-/** Running build metadata plus path-free DVD menu capability diagnostics. */
-export type ApplicationInfo = {
-  version: string;
-  buildIdentifier: string;
-  goVersion: string;
-  goos: string;
-  goarch: string;
-  uptime: string;
-  uptimeSeconds: number;
-  /** Pure-Go engine and FFmpeg dvdvideo probe metadata. */
-  dvdMenuEngine: DVDMenuEngineInfo;
-  /** Stable capability state shown by settings diagnostics. */
-  dvdMenuCapabilityStatus: "available" | "incompatible" | "unavailable";
-  /** User-facing reason for dvdMenuCapabilityStatus. */
-  dvdMenuCapabilityMessage: string;
-};
-
-/** Tracker auth support metadata returned by the app bridge. */
-export type TrackerAuthCapability = {
-  /** Normalized tracker code used in tracker auth bridge calls. */
-  trackerID: string;
-  displayName: string;
-  /** Compact capability label such as "cookies", "credential_login", or "api_key_cookies_login". */
-  authKind: string;
-  supportsCookieFile: boolean;
-  supportsLogin: boolean;
-  supportsAutoLogin: boolean;
-  supportsTOTP: boolean;
-  supportsManual2FA: boolean;
-  requiresAPIKey: boolean;
-  requiresPasskey: boolean;
-  /** Optional tracker-specific UI notes; Go bridge may serialize a nil slice as null. */
-  notes?: string[] | null;
-};
-
-/**
- * Current tracker auth state returned after status, import, login, validation,
- * 2FA, or delete actions.
- *
- * Mirrors the shared Go API contract; browser routes and Wails bindings should
- * preserve every field so GUI surfaces show the same status and remediation.
- */
-export type TrackerAuthStatus = {
-  trackerID: string;
-  displayName: string;
-  /** Backend state string such as "configured", "has_cookies", or "login_required". */
-  state: string;
-  cookieCount: number;
-  /** RFC3339 UTC timestamp generated when the backend evaluated the status. */
-  lastCheckedAt: string;
-  /** Redacted failure detail from the most recent local or remote auth check. */
-  lastError: string;
-  encryptedStorage: boolean;
-  needs2FA: boolean;
-  /** Opaque manual-2FA continuation token; empty unless needs2FA is true. */
-  challengeID: string;
-  /** Stable user-facing status summary or next step. */
-  message: string;
-};
-
-/** Optional login data for tracker auth flows. */
-export type TrackerAuthLoginRequest = {
-  /** One-time 2FA code for adapters that accept it during login. */
-  code?: string;
-};
-
-export type ExternalPreview = {
-  Provider: string;
-  ID: number;
-  Source: string;
-  Title: string;
-  Year: number;
-  Overview: string;
-  PosterURL: string;
-  BackdropURL: string;
-  Category: string;
-  OriginalTitle: string;
-  ReleaseDate: string;
-  FirstAirDate: string;
-  LastAirDate: string;
-  OriginalLanguage: string;
-  TMDBType: string;
-  Runtime: number;
-  Genres: string;
-  Keywords: string;
-  YouTube: string;
-  IMDBType: string;
-  Rating: number;
-  RatingCount: number;
-  RuntimeMinutes: number;
-  Country: string;
-  Premiered: string;
-  IMDBID: number;
-  TVDBID: number;
-  TMDB?: TMDBMetadata;
-  IMDB?: IMDBMetadata;
-  TVDB?: TVDBMetadata;
-  TVmaze?: TVmazeMetadata;
-  /** Rich preview metadata when Provider is "mal". */
-  AniList?: AniListMetadata;
-};
-
-export type BlurayImage = {
-  Kind: string;
-  URL: string;
-};
-
-export type BluraySpecs = {
-  Video: {
-    Codec: string;
-    Resolution: string;
-  };
-  Audio: string[];
-  Subtitles: string[];
-  Discs: {
-    Type: string;
-    Count: number;
-    Format: string;
-  };
-  Playback: {
-    Region: string;
-    RegionNotes: string;
-  };
-};
-
-export type BlurayReleaseCandidate = {
-  ReleaseID: string;
-  ProductID: string;
-  MovieTitle: string;
-  MovieYear: string;
-  Title: string;
-  URL: string;
-  Price: string;
-  Publisher: string;
-  Country: string;
-  Region: string;
-  Score: number;
-  Accepted: boolean;
-  Warnings: string[];
-  MatchNotes: string[];
-  Specs: BluraySpecs;
-  CoverImages: BlurayImage[];
-  GenericDisc: boolean;
-  SpecsMissing: boolean;
-};
-
-export type BlurayMetadata = {
-  SourcePath: string;
-  IMDBID: number;
-  SearchURL: string;
-  SelectedReleaseID: string;
-  SelectedURL: string;
-  AutoSelected: boolean;
-  SelectionReason: string;
-  BestScore: number;
-  Threshold: number;
-  Candidates: BlurayReleaseCandidate[];
-  UpdatedAt: string;
-};
-
-export type TrackerPreview = {
-  Tracker: string;
-  TrackerID: string;
-  TorrentURL: string;
-  InfoHash: string;
-  TMDBID: number;
-  IMDBID: number;
-  TVDBID: number;
-  MALID: number;
-  Category: string;
-  Description: string;
-  DescriptionHTML: string;
-  ImageURLs: string[];
-  Filename: string;
-  Matched: boolean;
-  UpdatedAt: string;
-};
-
-/** Upload rule failure attached to a tracker before dupe checking or upload. */
-export type RuleFailure = {
-  Rule: string;
-  Reason: string;
-  /** Empty and unrecognized values are treated as blocking by backend APIs. */
-  Severity?: "blocking" | "warning" | string;
-};
-
-export type DupeEntry = {
-  Name: string;
-  SizeBytes: number;
-  SizeKnown: boolean;
-  SizeText: string;
-  Files: string[];
-  FileCount: number;
-  Trumpable: boolean;
-  Link: string;
-  Download: string;
-  Flags: string[];
-  ID: string;
-  Type: string;
-  Res: string;
-  Internal: boolean;
-  BDInfo: string;
-  Description: string;
-};
-
-export type DupeEpisodeMatch = {
-  ID: string;
-  Name: string;
-  Link: string;
-  Tracker: string;
-  Internal: boolean;
-};
-
-export type DupeMatch = {
-  FilenameMatch: string;
-  FileCountMatch: number;
-  SizeMatch: string;
-  TrumpableID: string;
-  MatchedID: string;
-  MatchedName: string;
-  MatchedLink: string;
-  MatchedDownload: string;
-  MatchedReason: string;
-  SeasonPackExists: boolean;
-  SeasonPackName: string;
-  SeasonPackLink: string;
-  SeasonPackID: string;
-  SeasonPackContainsEpisode: boolean;
-  MatchedEpisodeIDs: DupeEpisodeMatch[];
-};
-
-/**
- * Duplicate-search outcome for one tracker. Raw contains tracker results before
- * filtering, Filtered contains blocking matches, and skipped or failed checks
- * carry Status plus SkipReason or Error. SkipCode and SkipRules expose stable
- * backend skip metadata for typed UI callers.
- */
-export type DupeCheckResult = {
-  Tracker: string;
-  Raw: DupeEntry[];
-  Filtered: DupeEntry[];
-  HasDupes: boolean;
-  ContentFail: boolean;
-  Match: DupeMatch;
-  Notes: string[];
-  Skipped: boolean;
-  SkipReason: string;
-  /** Stable machine-readable skip reason emitted by the backend. */
-  SkipCode: string;
-  /** Upload rule keys that produced a rule-failure skip. */
-  SkipRules: string[];
-  Status: string;
-  Error: string;
-  CheckedAt: string;
-};
-
-export type DupeCheckSummary = {
-  SourcePath: string;
-  Results: DupeCheckResult[];
-  Notes: string[];
-};
-
-export type DupeCheckTrackerState = {
-  tracker: string;
-  status: string;
-  message: string;
-  result: DupeCheckResult;
-  startedAt: string;
-  finishedAt: string;
-};
-
-export type DupeCheckSnapshot = {
-  jobID: string;
-  sourcePath: string;
-  status: string;
-  trackers: DupeCheckTrackerState[];
-  completedCount: number;
-  totalCount: number;
-  summary: DupeCheckSummary;
-  error: string;
-  startedAt: string;
-  finishedAt: string;
-};
-
-export type MetadataPreview = {
-  SourcePath: string;
-  TrackerName: string;
-  ReleaseName: string;
-  Warnings: string[];
-  ReleaseNameOverrides: ReleaseNameOverrides;
-  ExternalIDs: ExternalIDs;
-  ExternalIDCandidates: ExternalIDCandidates;
-  ExternalIDInfo: ExternalIDInfo[];
-  ExternalPreview: ExternalPreview[];
-  Bluray?: BlurayMetadata;
-  TrackerData: TrackerPreview[];
-  /** Preview-time upload rule failures keyed by normalized tracker code. */
-  TrackerRuleFailures?: Record<string, RuleFailure[]>;
-};
-
-export type MetadataProgressUpdate = {
-  path: string;
-  phase: string;
-  message: string;
-  status: string;
-  level: string;
-  timestamp: string;
-};
-
-export type PreparationDescription = {
-  GroupKey: string;
-  Trackers: string[];
-  RawDescription: string;
-  RawDescriptionHTML: string;
-  Description: string;
-  DescriptionHTML: string;
-  HasOverride: boolean;
-  ImageHost: ImageHostFeedback;
-};
-
-export type PreparationPreview = {
-  SourcePath: string;
-  Descriptions: PreparationDescription[];
-};
-
-export type ImageHostFeedback = {
-  Status: string;
-  SelectedHost: string;
-  AllowedHosts: string[];
-  Warnings?: ImageHostWarning[];
-  Reuploaded: boolean;
-  Message: string;
-};
-
-export type ImageHostWarning = {
-  Host: string;
-  Message: string;
-};
-
-export type DescriptionBuilderGroup = {
-  GroupKey: string;
-  Trackers: string[];
-  Description: string;
-  DescriptionHTML: string;
-  RawDescription: string;
-  RawDescriptionHTML: string;
-  HasOverride: boolean;
-  ImageHost: ImageHostFeedback;
-};
-
-export type DescriptionBuilderPreview = {
-  SourcePath: string;
-  Groups: DescriptionBuilderGroup[];
-};
-
-/** Image category shared by capture, selection, upload, and menu workflows. */
-export type ScreenshotPurpose = "preview" | "final" | "menu";
-
-export type ScreenshotSelection = {
-  Index: number;
-  TimestampSeconds: number;
-  Frame: number;
-  Source: string;
-};
-
-export type ScreenshotImage = {
-  Index: number;
-  TimestampSeconds: number;
-  Path: string;
-  /** Distinguishes preview, normal final, and disc-menu images. */
-  Purpose: ScreenshotPurpose;
-  Width: number;
-  Height: number;
-  SizeBytes: number;
-  Host?: string;
-  ImgURL?: string;
-  RawURL?: string;
-  WebURL?: string;
-  UploadedAt?: string;
-};
-
-/** How the DVD navigation engine found a selected menu screen. */
-export type DVDMenuDiscovery = "reachable" | "structural";
-
-/** Stable, redacted diagnostic for incomplete DVD menu coverage. */
-export type DVDMenuCaptureWarning = {
-  /** Machine-readable warning identifier. */
-  Code: string;
-  /** User-facing path-free warning text. */
-  Message: string;
-};
-
-/** Path-free pure-Go engine and FFmpeg dvdvideo capability metadata. */
-export type DVDMenuEngineInfo = {
-  /** Bundled pure-Go engine implementation version. */
-  EngineVersion: string;
-  /** Capture metadata contract version. */
-  SchemaVersion: number;
-  /** Engine stages available in this build. */
-  SupportedFeatures: string[];
-  /** Bounded first line of FFmpeg version output. */
-  FFmpegVersion: string;
-  /** Whether FFmpeg exposes the required dvdvideo menu options. */
-  FFmpegDVDVideo: boolean;
-  /** Required dvdvideo options absent from the capability probe. */
-  MissingFFmpegOptions: string[];
-};
-
-/** Persisted menu image plus its navigation discovery source. */
-export type DVDMenuCaptureImage = ScreenshotImage & {
-  /** Whether navigation or structural inventory found the screen. */
-  Discovery: DVDMenuDiscovery;
-};
-
-/** Final or partial result of one bounded automatic DVD menu capture. */
-export type DVDMenuCaptureResult = {
-  /** Host filesystem path of the prepared DVD source. */
-  SourcePath: string;
-  /** Persisted automatic captures in display order. */
-  Images: DVDMenuCaptureImage[];
-  /** Menu language requested from the engine. */
-  SelectedLanguage: string;
-  /** DVD region override; zero means none. */
-  Region: number;
-  /** Number of structurally inventoried menu programs. */
-  DiscoveredMenus: number;
-  /** Number of distinct VM states evaluated. */
-  VisitedStates: number;
-  /** Number of authored button commands evaluated. */
-  VisitedButtons: number;
-  /** Configured upper bound on automatic captures. */
-  MaxItems: number;
-  /** True when every selected screen was captured without coverage warnings. */
-  Complete: boolean;
-  /** True when warnings prevented complete navigation or rendering coverage. */
-  Partial: boolean;
-  /** True when MaxItems excluded eligible screens. */
-  Truncated: boolean;
-  /** Deduplicated coverage diagnostics. */
-  Warnings: DVDMenuCaptureWarning[];
-  /** Engine and FFmpeg capability used for capture. */
-  Engine: DVDMenuEngineInfo;
-};
-
-/** Pollable frontend state for one background DVD menu capture job. */
-export type DVDMenuCaptureSnapshot = {
-  /** Opaque identifier used for polling and cancellation. */
-  jobID: string;
-  /** Host filesystem path associated with the prepared metadata. */
-  sourcePath: string;
-  /** Job lifecycle state: queued, running, completed, failed, or canceled. */
-  status: string;
-  /** Current capture stage within status. */
-  phase: string;
-  /** User-facing progress or terminal summary. */
-  message: string;
-  /** Latest structural inventory count. */
-  discoveredMenus: number;
-  /** Latest evaluated VM-state count. */
-  visitedStates: number;
-  /** Latest evaluated button-command count. */
-  visitedButtons: number;
-  /** Latest rendered or persisted image count. */
-  capturedCount: number;
-  /** Latest distinct coverage-warning count. */
-  warningCount: number;
-  /** Final or partial capture result when available. */
-  result: DVDMenuCaptureResult;
-  /** Terminal failure text; empty for successful jobs. */
-  error: string;
-  /** RFC3339 UTC job start time. */
-  startedAt: string;
-  /** RFC3339 UTC finish time, or empty while active. */
-  finishedAt: string;
-};
-
-export type ScreenshotError = {
-  Index: number;
-  Message: string;
-};
-
-export type ScreenshotResult = {
-  SourcePath: string;
-  Purpose: ScreenshotPurpose;
-  Images: ScreenshotImage[];
-  Tonemapped: boolean;
-  UsedLibplacebo: boolean;
-  Errors: ScreenshotError[];
-};
-
-export type ScreenshotPlan = {
-  SourcePath: string;
-  DiscType: string;
-  DurationSeconds: number;
-  FrameRate: number;
-  SuggestedSelections: ScreenshotSelection[];
-  ExistingScreenshots: ScreenshotImage[];
-  ExistingTrackerScreenshots: ScreenshotImage[];
-  FinalSelections: ScreenshotImage[];
-  TrackerImageLinks: ScreenshotLinkedImage[];
-  PreviewImages: ScreenshotImage[];
-  MetadataTimestamp: string;
-  RequiresManualFrames: boolean;
-};
-
-export type ScreenshotLinkedImage = {
-  Tracker: string;
-  URL: string;
-  Path: string;
-  Host?: string;
-};
-
-export type UploadedImageLink = {
-  SourcePath: string;
-  ImagePath: string;
-  Host: string;
-  UsageScope: string;
-  ImgURL: string;
-  RawURL: string;
-  WebURL: string;
-  SizeBytes: number;
-  UploadedAt: string;
-};
-
-export type UploadImageHostFailure = {
-  Host: string;
-  UsageScope: string;
-  Trackers: string[];
-  Message: string;
-};
-
-export type UploadImagesResult = {
-  Links: UploadedImageLink[];
-  Failures: UploadImageHostFailure[];
-};
-
-export type HistoryEntry = {
-  SourcePath: string;
-  ReleaseTitle: string;
-  ReleaseSource: string;
-  ReleaseResolution: string;
-  MetadataUpdatedAt: string;
-  LatestUploadStatus: string;
-  LatestUploadAt: string;
-  RuleFailureCount: number;
-  /** Number of explicitly advisory rule results; absent on older API responses. */
-  RuleWarningCount?: number;
-};
-
-export type HistoryUploadRecord = {
-  Tracker: string;
-  Status: string;
-  CreatedAt: string;
-  SourcePath: string;
-};
-
-export type HistoryTrackerMetadata = {
-  SourcePath: string;
-  Tracker: string;
-  TrackerID: string;
-  InfoHash: string;
-  TMDBID: number;
-  IMDBID: number;
-  TVDBID: number;
-  MALID: number;
-  Category: string;
-  Description: string;
-  ImageURLs: string[];
-  Filename: string;
-  Matched: boolean;
-  UpdatedAt: string;
-};
-
-export type HistoryRuleFailure = {
-  SourcePath: string;
-  Tracker: string;
-  Rule: string;
-  Reason: string;
-  /** Empty and unrecognized values represent blocking legacy results. */
-  Severity?: "blocking" | "warning" | string;
-  CreatedAt: string;
-};
-
-export type HistoryOverview = {
-  SourcePath: string;
-  ReleaseTitle: string;
-  ReleaseSource: string;
-  ReleaseResolution: string;
-  MetadataUpdatedAt: string;
-  LatestUploadStatus: string;
-  LatestUploadAt: string;
-  StatusLabel: string;
-  Metadata: Record<string, unknown>;
-  ExternalIDs: ExternalIDs;
-  ExternalMetadata: Record<string, unknown>;
-  ReleaseNameOverrides: ReleaseNameOverrides;
-  DescriptionOverride: {
-    SourcePath: string;
-    GroupKey: string;
-    Description: string;
-    UpdatedAt: string;
-  };
-  DescriptionOverrides: Array<{
-    SourcePath: string;
-    GroupKey: string;
-    Description: string;
-    UpdatedAt: string;
-  }>;
-  PlaylistSelection: {
-    SourcePath: string;
-    SelectedPlaylists: string[];
-    UseAll: boolean;
-    UpdatedAt: string;
-  };
-  TrackerMetadata: HistoryTrackerMetadata[];
-  TrackerRuleFailures: HistoryRuleFailure[];
-  Screenshots: Array<{
-    SourcePath: string;
-    ImagePath: string;
-    Purpose: string;
-    CapturedAt: string;
-  }>;
-  FinalSelections: Array<{
-    SourcePath: string;
-    ImagePath: string;
-    Order: number;
-    Source: string;
-    SelectedAt: string;
-  }>;
-  UploadedImages: UploadedImageLink[];
-  UploadHistory: HistoryUploadRecord[];
-};
-
-export type ScreenshotPreviewImage = {
-  image: ScreenshotImage;
-  dataUri: string;
-};
-
-export type TrackerUploadItem = {
-  name: string;
-  config: ConfigMap;
-};
-
-export type TrackerUploadTrackerState = {
-  tracker: string;
-  status: string;
-  task: string;
-  taskStatus: string;
-  message: string;
-  completedPieces: number;
-  totalPieces: number;
-  percent: number;
-  hashRateMiB: number;
-  uploadedCount: number;
-  startedAt: string;
-  finishedAt: string;
-};
-
-export type UploadProgressUpdate = {
-  sourcePath: string;
-  tracker: string;
-  task: string;
-  status: string;
-  message: string;
-  completedPieces: number;
-  totalPieces: number;
-  percent: number;
-  hashRateMiB: number;
-  timestamp: string;
-};
-
-export type TrackerUploadSnapshot = {
-  jobID: string;
-  sourcePath: string;
-  status: string;
-  currentTask: string;
-  currentTaskStatus: string;
-  currentMessage: string;
-  currentCompletedPieces: number;
-  currentTotalPieces: number;
-  currentPercent: number;
-  currentHashRateMiB: number;
-  trackers: TrackerUploadTrackerState[];
-  failedTrackers: string[];
-  uploadedCount: number;
-  error: string;
-  startedAt: string;
-  finishedAt: string;
-};
-
-export type TrackerDryRunFile = {
-  Field: string;
-  Path: string;
-  Present: boolean;
-};
-
-export type TrackerQuestionnaireField = {
-  Key: string;
-  Label: string;
-  Kind: string;
-  Options?: string[];
-  Value: string;
-  Placeholder: string;
-  Help: string;
-  Required: boolean;
-};
-
-export type TrackerQuestionnaire = {
-  Tracker: string;
-  Fields: TrackerQuestionnaireField[];
-};
-
-export type TrackerDryRunEntry = {
-  Tracker: string;
-  Status: string;
-  Message: string;
-  Banned: boolean;
-  BannedReason: string;
-  BannedCheckError: string;
-  ReleaseName: string;
-  OriginalReleaseName: string;
-  UploadReleaseName: string;
-  ReleaseNameChanged: boolean;
-  ReleaseNameChangeReason: string;
-  DescriptionGroup: string;
-  Description: string;
-  Endpoint: string;
-  Payload: Record<string, string>;
-  Files: TrackerDryRunFile[];
-  /** Optional staged diagnostics for trackers that expose intermediate dry-run payloads. */
-  DebugSections?: TrackerDryRunDebugSection[] | null;
-  Questionnaire?: TrackerQuestionnaire | null;
-  ImageHost: ImageHostFeedback;
-};
-
-/** One named diagnostic payload rendered inside a tracker dry-run preview. */
-export type TrackerDryRunDebugSection = {
-  Title: string;
-  Endpoint: string;
-  Payload: Record<string, string>;
-  Files: TrackerDryRunFile[];
-};
-
-export type TrackerDryRunPreview = {
-  SourcePath: string;
-  Trackers: TrackerDryRunEntry[];
-};
-
-export type ConfigValue = string | number | boolean | null | ConfigMap | ConfigValue[];
-export type ConfigMap = { [key: string]: ConfigValue };
-export type ImageHostPolicyMetadata = {
-  UploadHosts?: string[];
-  TrackerUploadHosts?: Record<string, string[]>;
-  OwnedHosts?: Record<string, string>;
-};
-export type FieldType = "string" | "number" | "boolean";
-export type FieldMeta = {
-  key: string;
-  label?: string;
-  type?: FieldType;
-  advanced?: boolean;
-  sensitive?: boolean;
-  options?: Array<{ value: string; label: string }>;
-};
-
-export type ReleaseNameEditState = {
-  category: string;
-  type: string;
-  source: string;
-  resolution: string;
-  tag: string;
-  service: string;
-  edition: string;
-  season: string;
-  episode: string;
-  episodeTitle: string;
-  manualYear: string;
-  manualDate: string;
-  useSeasonEpisode: boolean;
-  noSeason: boolean;
-  noYear: boolean;
-  noAKA: boolean;
-  noTag: boolean;
-  noEdition: boolean;
-  noDub: boolean;
-  noDual: boolean;
-  dualAudio: boolean;
-  region: string;
-};
-
-export type ReleaseNameTouchedState = {
-  category: boolean;
-  type: boolean;
-  source: boolean;
-  resolution: boolean;
-  tag: boolean;
-  service: boolean;
-  edition: boolean;
-  season: boolean;
-  episode: boolean;
-  episodeTitle: boolean;
-  manualYear: boolean;
-  manualDate: boolean;
-  useSeasonEpisode: boolean;
-  noSeason: boolean;
-  noYear: boolean;
-  noAKA: boolean;
-  noTag: boolean;
-  noEdition: boolean;
-  noDub: boolean;
-  noDual: boolean;
-  dualAudio: boolean;
-  region: boolean;
-};
-
-export type ReleaseNameIDEditState = {
-  tmdb: string;
-  imdb: string;
-  tvdb: string;
-  tvmaze: string;
-};
-
-export type DetailItem = {
-  label: string;
-  value: string;
-  mono?: boolean;
-  blocks?: DetailBlock[];
-};
-
-export type DetailBlock = {
-  text?: string;
-  imageUrl?: string;
-  imageAlt?: string;
-};
-
-export type PlaylistItem = {
-  file: string;
-  size: number;
-};
-
-export type PlaylistInfo = {
-  file: string;
-  duration: number;
-  items: PlaylistItem[];
-  score: number;
-  edition: string;
-};
-
-export type PlaylistSelection = {
-  SourcePath: string;
-  SelectedPlaylists: string[];
-  UseAll: boolean;
-  UpdatedAt: string;
-};
-
-export type BrowseDirectoryEntry = {
-  name: string;
-  path: string;
-  isDir: boolean;
-  size: number;
-  modifiedAt: string;
-};
-
-export type BrowseDirectoryResponse = {
-  currentPath: string;
-  parentPath: string;
-  mode: "file" | "folder";
-  entries: BrowseDirectoryEntry[];
-};
-
-export type BrowseDirectoryRequest = {
-  path: string;
-  mode: "file" | "folder";
-};
diff --git a/gui/frontend/src/utils/dupeCheck.ts b/gui/frontend/src/utils/dupeCheck.ts
deleted file mode 100644
index 86271f40..00000000
--- a/gui/frontend/src/utils/dupeCheck.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { DupeCheckResult } from "../types";
-
-type DupeSkipReasonSource = Pick<Partial<DupeCheckResult>, "SkipReason" | "Notes">;
-
-type DupeRuleSkipSource = DupeSkipReasonSource &
-  Pick<Partial<DupeCheckResult>, "Skipped" | "SkipRules">;
-
-const isRuleFailureReason = (reason: string) =>
-  reason.toLowerCase().trim().startsWith("rule check failed");
-
-/** Returns the displayable skip reason carried by a duplicate-check result. */
-export const dupeSkipReason = (result: DupeSkipReasonSource) =>
-  String(result.SkipReason || result.Notes?.join(" ") || "").trim();
-
-/** Reports rule-validation skips from structured SkipRules, with legacy reason text as fallback. */
-export const isRuleSkippedResult = (result: DupeRuleSkipSource) => {
-  if (!result.Skipped) return false;
-  if ((result.SkipRules || []).some((rule) => String(rule).trim() !== "")) {
-    return true;
-  }
-  return isRuleFailureReason(dupeSkipReason(result));
-};
diff --git a/gui/frontend/src/utils/externalLinks.ts b/gui/frontend/src/utils/externalLinks.ts
deleted file mode 100644
index 56f3378e..00000000
--- a/gui/frontend/src/utils/externalLinks.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { MouseEvent } from "react";
-
-type GoAppBridge = {
-  OpenExternalURL?: (url: string) => Promise<void>;
-};
-
-type GoBridgeWindow = Window & {
-  go?: {
-    guiapp?: {
-      App?: GoAppBridge;
-    };
-  };
-};
-
-const normalizeExternalHTTPURL = (value: string): string | null => {
-  const href = value.trim();
-  if (!href) return null;
-
-  let parsed: URL;
-  try {
-    parsed = new URL(href);
-  } catch {
-    return null;
-  }
-
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    return null;
-  }
-
-  return parsed.toString();
-};
-
-const openExternalURL = async (url: string) => {
-  const bridge = (window as GoBridgeWindow).go?.guiapp?.App;
-  if (!bridge?.OpenExternalURL) {
-    window.open(url, "_blank", "noopener,noreferrer");
-    return;
-  }
-
-  await bridge.OpenExternalURL(url);
-};
-
-export const handleExternalLinkClick = (event: MouseEvent<HTMLElement>) => {
-  const target = event.target;
-  if (!(target instanceof Element)) {
-    return;
-  }
-
-  const anchor = target.closest("a[href]");
-  if (!(anchor instanceof HTMLAnchorElement)) {
-    return;
-  }
-
-  const href = anchor.getAttribute("href");
-  if (!href) {
-    return;
-  }
-
-  const normalized = normalizeExternalHTTPURL(href);
-  if (!normalized) {
-    return;
-  }
-
-  event.preventDefault();
-  event.stopPropagation();
-  void openExternalURL(normalized);
-};
diff --git a/gui/frontend/src/utils/externalPreview.ts b/gui/frontend/src/utils/externalPreview.ts
deleted file mode 100644
index f905be28..00000000
--- a/gui/frontend/src/utils/externalPreview.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { ExternalPreview } from "../types";
-
-/**
- * Reports whether a preview contains its provider-specific fetched metadata payload.
- * Resolved IDs and shallow preview entries without that payload return false.
- */
-export const hasFetchedExternalPreviewData = (preview: ExternalPreview) => {
-  switch (preview.Provider) {
-    case "imdb":
-      return preview.IMDB != null;
-    case "tmdb":
-      return preview.TMDB != null;
-    case "tvdb":
-      return preview.TVDB != null;
-    case "tvmaze":
-      return preview.TVmaze != null;
-    case "mal":
-      return preview.AniList != null;
-    default:
-      return false;
-  }
-};
diff --git a/gui/frontend/src/utils/index.ts b/gui/frontend/src/utils/index.ts
deleted file mode 100644
index 51e54d25..00000000
--- a/gui/frontend/src/utils/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-export { normalizeOverrides, normalizeReleaseOverrides } from "./helpers";
diff --git a/gui/frontend/src/utils/metadataProgress.test.ts b/gui/frontend/src/utils/metadataProgress.test.ts
deleted file mode 100644
index bd5a4dbc..00000000
--- a/gui/frontend/src/utils/metadataProgress.test.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { describe, expect, it } from "vitest";
-
-import { isMetadataProgressPathMatch, normalizeMetadataProgressPath } from "./metadataProgress";
-
-describe("normalizeMetadataProgressPath", () => {
-  it("trims paths and normalizes separators", () => {
-    expect(normalizeMetadataProgressPath(" C:\\Media\\Movie.mkv ")).toBe("C:/Media/Movie.mkv");
-  });
-
-  it("cleans dot segments", () => {
-    expect(normalizeMetadataProgressPath("C:/Media/Extras/../Movie.mkv")).toBe(
-      "C:/Media/Movie.mkv",
-    );
-  });
-});
-
-describe("isMetadataProgressPathMatch", () => {
-  it("matches separator-normalized paths", () => {
-    expect(isMetadataProgressPathMatch("C:\\Media\\Movie.mkv", "C:/Media/Movie.mkv")).toBe(true);
-  });
-
-  it("matches Windows paths that differ by case", () => {
-    expect(isMetadataProgressPathMatch("c:/media/movie.mkv", "C:/Media/Movie.mkv")).toBe(true);
-  });
-
-  it("matches cleaned backend paths to request paths", () => {
-    expect(isMetadataProgressPathMatch("C:/Media/Extras/../Movie.mkv", "C:/Media/Movie.mkv")).toBe(
-      true,
-    );
-  });
-
-  it("keeps POSIX paths case-sensitive", () => {
-    expect(isMetadataProgressPathMatch("/media/movie.mkv", "/Media/Movie.mkv")).toBe(false);
-  });
-
-  it("rejects unrelated paths", () => {
-    expect(isMetadataProgressPathMatch("C:/Media/Other.mkv", "C:/Media/Movie.mkv")).toBe(false);
-  });
-
-  it("allows events when no progress target is active", () => {
-    expect(isMetadataProgressPathMatch("C:/Media/Movie.mkv", "")).toBe(true);
-  });
-});
diff --git a/gui/frontend/src/utils/metadataProgress.ts b/gui/frontend/src/utils/metadataProgress.ts
deleted file mode 100644
index 7291842b..00000000
--- a/gui/frontend/src/utils/metadataProgress.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-/**
- * Returns the comparable display form used for metadata progress paths.
- *
- * The value is trimmed, slash-normalized, and cleaned of `.`/`..` segments while
- * preserving case. Callers that need OS-specific identity rules should use
- * `isMetadataProgressPathMatch`.
- */
-export const normalizeMetadataProgressPath = (value: string) =>
-  cleanPath(value.trim().replaceAll("\\", "/"));
-
-const windowsDrivePathPattern = /^[a-z]:(?:\/|$)/i;
-
-const isWindowsPath = (value: string) =>
-  windowsDrivePathPattern.test(value) || value.startsWith("//");
-
-const cleanPath = (value: string) => {
-  if (!value) {
-    return "";
-  }
-
-  const isAbsolute = value.startsWith("/") || windowsDrivePathPattern.test(value);
-  const parts = value.split("/");
-  const cleanParts: string[] = [];
-
-  for (const part of parts) {
-    if (!part || part === ".") {
-      continue;
-    }
-    if (part === "..") {
-      const previous = cleanParts[cleanParts.length - 1];
-      if (previous && previous !== ".." && !previous.endsWith(":")) {
-        cleanParts.pop();
-      } else if (!isAbsolute) {
-        cleanParts.push(part);
-      }
-      continue;
-    }
-    cleanParts.push(part);
-  }
-
-  if (value.startsWith("//")) {
-    return `//${cleanParts.join("/")}`;
-  }
-  if (value.startsWith("/")) {
-    return `/${cleanParts.join("/")}`;
-  }
-  return cleanParts.join("/");
-};
-
-const metadataProgressPathIdentity = (value: string) => {
-  const normalized = normalizeMetadataProgressPath(value);
-  return isWindowsPath(normalized) ? normalized.toLocaleLowerCase("en-US") : normalized;
-};
-
-/**
- * Returns whether a progress event belongs to the active metadata request.
- *
- * Empty targets accept any event. Non-empty targets use the cleaned path form
- * plus Windows-aware case folding for drive and UNC paths, which lets
- * backend-canonical progress events attach to the active request without
- * accepting unrelated paths.
- */
-export const isMetadataProgressPathMatch = (eventPath: string, progressTarget: string) => {
-  const normalizedTarget = metadataProgressPathIdentity(progressTarget);
-  if (!normalizedTarget) {
-    return true;
-  }
-  return metadataProgressPathIdentity(eventPath) === normalizedTarget;
-};
diff --git a/gui/frontend/src/utils/runtime.test.ts b/gui/frontend/src/utils/runtime.test.ts
deleted file mode 100644
index c7d6d0f2..00000000
--- a/gui/frontend/src/utils/runtime.test.ts
+++ /dev/null
@@ -1,495 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { TrackerAuthStatus } from "../types";
-
-const jsonResponse = (payload: unknown, init?: ResponseInit) =>
-  new Response(JSON.stringify(payload), {
-    headers: { "Content-Type": "application/json" },
-    ...init,
-  });
-
-const eventStreamResponse = (payload: unknown, onCancel?: () => void) => {
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(
-        encoder.encode(`event: metadata:progress\ndata: ${JSON.stringify(payload)}\n\n`),
-      );
-    },
-    cancel() {
-      onCancel?.();
-    },
-  });
-  return new Response(stream, {
-    headers: { "Content-Type": "text/event-stream" },
-  });
-};
-
-describe("browser runtime bridge", () => {
-  beforeEach(() => {
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    delete window.__UPBRR_BASE_URL__;
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it("posts app calls with JSON and CSRF headers", async () => {
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ ok: true }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    const result = await (globalThis as any).go.guiapp.App.FetchScreenshotPlan(
-      "C:/media/movie.mkv",
-      { TMDBID: 1 },
-      { Category: "MOVIE" },
-    );
-
-    expect(result).toEqual({ ok: true });
-    expect(fetchMock).toHaveBeenCalledWith(
-      "/api/app/FetchScreenshotPlan",
-      expect.objectContaining({
-        method: "POST",
-        credentials: "include",
-        headers: {
-          "Content-Type": "application/json",
-          "X-CSRF-Token": "csrf-token",
-        },
-        body: JSON.stringify({
-          Path: "C:/media/movie.mkv",
-          Overrides: { TMDBID: 1 },
-          NameOverrides: { Category: "MOVIE" },
-        }),
-      }),
-    );
-  });
-
-  it("uses exact DVD menu capture and lifecycle payloads", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse("dvd-job-1"))
-      .mockResolvedValueOnce(jsonResponse({ jobID: "dvd-job-1", status: "running" }))
-      .mockResolvedValueOnce(jsonResponse({ ok: true }))
-      .mockResolvedValueOnce(jsonResponse([]))
-      .mockResolvedValueOnce(jsonResponse({ ok: true }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-    const app = (globalThis as any).go.guiapp.App;
-
-    await app.StartDVDMenuCapture("C:/media/Example", { TMDBID: 1 }, { Category: "MOVIE" });
-    await app.GetDVDMenuCaptureSnapshot("dvd-job-1");
-    await app.CancelDVDMenuCapture("dvd-job-1");
-    await app.ListDVDMenuScreenshots("C:/media/Example", { TMDBID: 1 }, { Category: "MOVIE" });
-    await app.DeleteDVDMenuScreenshot(
-      "C:/media/Example",
-      { TMDBID: 1 },
-      { Category: "MOVIE" },
-      "C:/managed/menu.png",
-    );
-
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      1,
-      "/api/app/StartDVDMenuCapture",
-      expect.objectContaining({
-        body: JSON.stringify({
-          Path: "C:/media/Example",
-          Overrides: { TMDBID: 1 },
-          NameOverrides: { Category: "MOVIE" },
-        }),
-      }),
-    );
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      2,
-      "/api/app/GetDVDMenuCaptureSnapshot",
-      expect.objectContaining({ body: JSON.stringify({ JobID: "dvd-job-1" }) }),
-    );
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      3,
-      "/api/app/CancelDVDMenuCapture",
-      expect.objectContaining({ body: JSON.stringify({ JobID: "dvd-job-1" }) }),
-    );
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      4,
-      "/api/app/ListDVDMenuScreenshots",
-      expect.objectContaining({
-        body: JSON.stringify({
-          Path: "C:/media/Example",
-          Overrides: { TMDBID: 1 },
-          NameOverrides: { Category: "MOVIE" },
-        }),
-      }),
-    );
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      5,
-      "/api/app/DeleteDVDMenuScreenshot",
-      expect.objectContaining({
-        body: JSON.stringify({
-          Path: "C:/media/Example",
-          Overrides: { TMDBID: 1 },
-          NameOverrides: { Category: "MOVIE" },
-          ImagePath: "C:/managed/menu.png",
-        }),
-      }),
-    );
-  });
-
-  it("preserves tracker auth status fields from browser app routes", async () => {
-    const status: TrackerAuthStatus = {
-      trackerID: "MTV",
-      displayName: "MTV",
-      state: "needs_2fa",
-      cookieCount: 2,
-      lastCheckedAt: "2026-07-08T01:02:03Z",
-      lastError: "tracker auth validation failed",
-      encryptedStorage: true,
-      needs2FA: true,
-      challengeID: "challenge-123",
-      message: "enter 2FA code",
-    };
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(status));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    const result = await (globalThis as any).go.guiapp.App.GetTrackerAuthStatus("MTV");
-
-    expect(result).toEqual(status);
-    expect(fetchMock).toHaveBeenCalledWith(
-      "/api/app/GetTrackerAuthStatus",
-      expect.objectContaining({
-        body: JSON.stringify({ Tracker: "MTV" }),
-      }),
-    );
-  });
-
-  it("preserves tracker auth app route error messages", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi
-        .fn()
-        .mockResolvedValue(
-          jsonResponse({ error: "tracker auth: validation failed" }, { status: 400 }),
-        ),
-    );
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    await expect((globalThis as any).go.guiapp.App.TestTrackerAuth("MTV")).rejects.toThrow(
-      "tracker auth: validation failed",
-    );
-  });
-
-  it("prefixes browser API calls with the injected base URL", async () => {
-    window.__UPBRR_BASE_URL__ = "/upbrr/";
-    const fetchMock = vi.fn().mockImplementation(() => Promise.resolve(jsonResponse({ ok: true })));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { browserAuth, initializeBrowserBridge, withBrowserBasePath } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    expect(withBrowserBasePath("/api/auth/status")).toBe("/upbrr/api/auth/status");
-
-    await browserAuth.status();
-    await (globalThis as any).go.guiapp.App.GetConfig();
-
-    expect(fetchMock).toHaveBeenNthCalledWith(1, "/upbrr/api/auth/status", {
-      credentials: "include",
-    });
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      2,
-      "/upbrr/api/app/GetConfig",
-      expect.objectContaining({
-        method: "POST",
-        credentials: "include",
-      }),
-    );
-  });
-
-  it("throws response errors from browser auth calls", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn().mockResolvedValue(jsonResponse({ error: "login required" }, { status: 401 })),
-    );
-
-    const { browserAuth } = await import("./runtime");
-
-    await expect(browserAuth.status()).rejects.toThrow("login required");
-  });
-
-  it("refreshes browser auth state and retries app calls once", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse({ error: "csrf validation failed" }, { status: 403 }))
-      .mockResolvedValueOnce(
-        jsonResponse({
-          authenticated: true,
-          csrfToken: "stale-csrf",
-          nativeBrowseEnabled: true,
-        }),
-      )
-      .mockResolvedValueOnce(jsonResponse("job-1"));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("stale-csrf", false);
-
-    const result = await (globalThis as any).go.guiapp.App.StartDupeCheck(
-      "C:/media/movie.mkv",
-      {},
-      {},
-      ["AITHER"],
-    );
-
-    expect(result).toBe("job-1");
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      1,
-      "/api/app/StartDupeCheck",
-      expect.objectContaining({
-        credentials: "include",
-        headers: expect.objectContaining({ "X-CSRF-Token": "stale-csrf" }),
-      }),
-    );
-    expect(fetchMock).toHaveBeenNthCalledWith(2, "/api/auth/status", {
-      credentials: "include",
-    });
-    expect(fetchMock).toHaveBeenNthCalledWith(
-      3,
-      "/api/app/StartDupeCheck",
-      expect.objectContaining({
-        credentials: "include",
-        headers: expect.objectContaining({ "X-CSRF-Token": "stale-csrf" }),
-      }),
-    );
-  });
-
-  it("does not adopt a different browser session during auth refresh", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse({ error: "csrf validation failed" }, { status: 403 }))
-      .mockResolvedValueOnce(
-        jsonResponse({
-          authenticated: true,
-          csrfToken: "other-session-csrf",
-          nativeBrowseEnabled: true,
-        }),
-      );
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("session-a-csrf", false);
-
-    await expect(
-      (globalThis as any).go.guiapp.App.StartDupeCheck("C:/media/movie.mkv", {}, {}, ["AITHER"]),
-    ).rejects.toThrow("Web session changed in another tab");
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("notifies listeners when auth refresh changes native browse availability", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse({ error: "csrf validation failed" }, { status: 403 }))
-      .mockResolvedValueOnce(
-        jsonResponse({
-          authenticated: true,
-          csrfToken: "stale-csrf",
-          nativeBrowseEnabled: true,
-        }),
-      )
-      .mockResolvedValueOnce(jsonResponse("job-1"));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const {
-      initializeBrowserBridge,
-      isBrowserNativeBrowseAvailable,
-      subscribeBrowserNativeBrowseAvailability,
-    } = await import("./runtime");
-    initializeBrowserBridge("stale-csrf", false);
-    const listener = vi.fn();
-    const unsubscribe = subscribeBrowserNativeBrowseAvailability(listener);
-
-    await (globalThis as any).go.guiapp.App.StartDupeCheck("C:/media/movie.mkv", {}, {}, [
-      "AITHER",
-    ]);
-
-    expect(listener).toHaveBeenCalledOnce();
-    expect(isBrowserNativeBrowseAvailable()).toBe(true);
-    unsubscribe();
-  });
-
-  it("opens browser events with the initialized session token header", async () => {
-    const cancelStream = vi.fn();
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValue(eventStreamResponse({ jobID: "job-1" }, cancelStream));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { EventsOn, initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-    const listener = vi.fn();
-    const off = EventsOn("metadata:progress", listener);
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      "/api/events",
-      expect.objectContaining({
-        method: "GET",
-        credentials: "include",
-        headers: { "X-CSRF-Token": "csrf-token" },
-      }),
-    );
-    await vi.waitFor(() => expect(listener).toHaveBeenCalledWith({ jobID: "job-1" }));
-    off();
-    await vi.waitFor(() => expect(cancelStream).toHaveBeenCalledOnce());
-  });
-
-  it("stores runtime path case sensitivity from bridge initialization", async () => {
-    const { initializeBrowserBridge, isRuntimePathCaseInsensitive } = await import("./runtime");
-
-    initializeBrowserBridge("csrf-token", true, true);
-    expect(isRuntimePathCaseInsensitive()).toBe(true);
-
-    initializeBrowserBridge("csrf-token", true, false);
-    expect(isRuntimePathCaseInsensitive()).toBe(false);
-  });
-
-  it("rejects oversized decoded tracker cookie content before posting", async () => {
-    const originalCreateElement = document.createElement.bind(document);
-    const input = document.createElement("input");
-    Object.defineProperty(input, "files", {
-      configurable: true,
-      value: [new File(["x"], "cookies.txt")],
-    });
-    vi.spyOn(input, "click").mockImplementation(() => {
-      input.dispatchEvent(new Event("change"));
-    });
-    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
-      if (tagName === "input") {
-        return input;
-      }
-      return originalCreateElement(tagName);
-    });
-    const readAsText = vi.fn();
-    vi.stubGlobal(
-      "FileReader",
-      vi.fn().mockImplementation(function (this: any) {
-        this.readAsText = readAsText.mockImplementation(() => {
-          Object.defineProperty(this, "result", {
-            configurable: true,
-            value: "x".repeat(1024 * 1024 + 1),
-          });
-          this.onload?.(new ProgressEvent("load"));
-        });
-      }),
-    );
-    const fetchMock = vi.fn();
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    await expect((globalThis as any).go.guiapp.App.ImportTrackerAuthCookies("PTP")).rejects.toThrow(
-      "cookie file content exceeds 1048576 byte limit",
-    );
-    expect(readAsText).toHaveBeenCalled();
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects oversized raw tracker cookie files before decoding", async () => {
-    const originalCreateElement = document.createElement.bind(document);
-    const input = document.createElement("input");
-    const file = new File(["x"], "cookies.txt");
-    Object.defineProperty(file, "size", { configurable: true, value: 1024 * 1024 + 1 });
-    Object.defineProperty(input, "files", {
-      configurable: true,
-      value: [file],
-    });
-    vi.spyOn(input, "click").mockImplementation(() => {
-      input.dispatchEvent(new Event("change"));
-    });
-    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
-      if (tagName === "input") {
-        return input;
-      }
-      return originalCreateElement(tagName);
-    });
-    const readAsText = vi.fn();
-    vi.stubGlobal(
-      "FileReader",
-      vi.fn().mockImplementation(function (this: any) {
-        this.readAsText = readAsText.mockImplementation(() => {
-          Object.defineProperty(this, "result", { configurable: true, value: "session=abc" });
-          this.onload?.(new ProgressEvent("load"));
-        });
-      }),
-    );
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ trackerID: "PTP" }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    await expect((globalThis as any).go.guiapp.App.ImportTrackerAuthCookies("PTP")).rejects.toThrow(
-      "cookie file content exceeds 1048576 byte limit",
-    );
-    expect(readAsText).not.toHaveBeenCalled();
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("posts valid tracker cookie files from the browser bridge", async () => {
-    const originalCreateElement = document.createElement.bind(document);
-    const input = document.createElement("input");
-    Object.defineProperty(input, "files", {
-      configurable: true,
-      value: [new File(["session=abc"], "cookies.txt")],
-    });
-    vi.spyOn(input, "click").mockImplementation(() => {
-      input.dispatchEvent(new Event("change"));
-    });
-    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
-      if (tagName === "input") {
-        return input;
-      }
-      return originalCreateElement(tagName);
-    });
-    vi.stubGlobal(
-      "FileReader",
-      vi.fn().mockImplementation(function (this: any) {
-        this.readAsText = vi.fn(() => {
-          Object.defineProperty(this, "result", { configurable: true, value: "session=abc" });
-          this.onload?.(new ProgressEvent("load"));
-        });
-      }),
-    );
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ trackerID: "PTP" }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const { initializeBrowserBridge } = await import("./runtime");
-    initializeBrowserBridge("csrf-token", true);
-
-    await expect(
-      (globalThis as any).go.guiapp.App.ImportTrackerAuthCookies("PTP"),
-    ).resolves.toEqual({
-      trackerID: "PTP",
-    });
-    expect(fetchMock).toHaveBeenCalledWith(
-      "/api/app/ImportTrackerAuthCookieContent",
-      expect.objectContaining({
-        body: JSON.stringify({
-          Tracker: "PTP",
-          FileName: "cookies.txt",
-          Content: "session=abc",
-        }),
-      }),
-    );
-  });
-});
diff --git a/gui/frontend/src/utils/runtime.ts b/gui/frontend/src/utils/runtime.ts
deleted file mode 100644
index eed0437c..00000000
--- a/gui/frontend/src/utils/runtime.ts
+++ /dev/null
@@ -1,826 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { EventsOn as wailsEventsOn } from "../../wailsjs/runtime/runtime";
-
-type EventCallback = (payload: unknown) => void;
-
-declare global {
-  interface Window {
-    __UPBRR_BASE_URL__?: string;
-  }
-}
-
-const callbackMap = new Map<string, Set<EventCallback>>();
-const nativeBrowseAvailabilityListeners = new Set<() => void>();
-let eventStreamController: AbortController | null = null;
-let eventStreamReconnectTimer: ReturnType<typeof setTimeout> | null = null;
-let browserMode = false;
-let csrfToken = "";
-let nativeBrowseEnabled = false;
-let caseInsensitivePaths = navigator.platform.toLowerCase().startsWith("win");
-
-// Mirrors trackerauth.MaxCookieImportContentBytes so browser imports reject
-// over-limit files before decode and over-limit decoded text before posting.
-const maxCookieImportContentBytes = 1024 * 1024;
-const encodedTextByteLength = (value: string) => new TextEncoder().encode(value).length;
-const sessionChangedMessage =
-  "Web session changed in another tab. Reload this tab to continue with the active login.";
-
-const isWebUIRuntime = () => {
-  const runtime = (window as typeof window & { runtime?: unknown }).runtime;
-  return (
-    !runtime && (window.location.protocol === "http:" || window.location.protocol === "https:")
-  );
-};
-
-const parseJSONResponse = async <T>(response: Response): Promise<T | null> => {
-  const text = await response.text();
-  if (!text.trim()) {
-    return null;
-  }
-  return JSON.parse(text) as T;
-};
-
-const isAuthFailureStatus = (status: number) => status === 401 || status === 403;
-
-const normalizeBrowserBaseURL = (value: unknown) => {
-  if (typeof value !== "string") {
-    return "/";
-  }
-  const trimmed = value.trim();
-  if (!trimmed || trimmed === "/") {
-    return "/";
-  }
-  const path = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  return path.endsWith("/") ? path : `${path}/`;
-};
-
-const browserBaseURL = () => normalizeBrowserBaseURL(window.__UPBRR_BASE_URL__);
-
-/**
- * Prefixes browser-mode API and event paths with the base URL injected by the
- * embedded web server. Root and Wails desktop runtimes resolve to root paths.
- */
-export const withBrowserBasePath = (path: string) => {
-  const baseURL = browserBaseURL();
-  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-  return `${baseURL}${normalizedPath}`;
-};
-
-const setNativeBrowseEnabled = (enabled: boolean) => {
-  if (nativeBrowseEnabled === enabled) {
-    return;
-  }
-  nativeBrowseEnabled = enabled;
-  nativeBrowseAvailabilityListeners.forEach((listener) => listener());
-};
-
-const setRuntimePathCaseSensitivity = (caseInsensitive: unknown) => {
-  if (typeof caseInsensitive === "boolean") {
-    caseInsensitivePaths = caseInsensitive;
-  }
-};
-
-/**
- * Refreshes browser auth state for a retry without switching this tab to a
- * different web session.
- */
-const refreshBrowserAuthState = async () => {
-  if (!browserMode) {
-    return false;
-  }
-  const response = await fetch(withBrowserBasePath("/api/auth/status"), { credentials: "include" });
-  const payload = await parseJSONResponse<
-    Record<string, unknown> & {
-      authenticated?: boolean;
-      csrfToken?: string;
-      nativeBrowseEnabled?: boolean;
-      caseInsensitivePaths?: boolean;
-    }
-  >(response);
-  if (!response.ok || !payload?.authenticated) {
-    return false;
-  }
-  const nextCSRFToken = String(payload.csrfToken || "");
-  if (csrfToken && nextCSRFToken && nextCSRFToken !== csrfToken) {
-    throw new Error(sessionChangedMessage);
-  }
-  csrfToken = nextCSRFToken;
-  setRuntimePathCaseSensitivity(payload.caseInsensitivePaths);
-  setNativeBrowseEnabled(Boolean(payload.nativeBrowseEnabled));
-  recreateEventSource();
-  return csrfToken !== "";
-};
-
-const addBrowserListener = (eventName: string, callback: EventCallback) => {
-  if (!callbackMap.has(eventName)) {
-    callbackMap.set(eventName, new Set());
-  }
-  const set = callbackMap.get(eventName)!;
-  set.add(callback);
-  ensureEventSource();
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) {
-      callbackMap.delete(eventName);
-    }
-    if (callbackMap.size === 0) {
-      closeEventSource();
-    }
-  };
-};
-
-const ensureEventSource = () => {
-  if (!browserMode || eventStreamController || !csrfToken || callbackMap.size === 0) {
-    return;
-  }
-  const controller = new AbortController();
-  eventStreamController = controller;
-  void runBrowserEventStream(controller);
-};
-
-const recreateEventSource = () => {
-  closeEventSource();
-  ensureEventSource();
-};
-
-const closeEventSource = () => {
-  if (eventStreamReconnectTimer) {
-    clearTimeout(eventStreamReconnectTimer);
-    eventStreamReconnectTimer = null;
-  }
-  if (eventStreamController) {
-    eventStreamController.abort();
-    eventStreamController = null;
-  }
-};
-
-const scheduleEventStreamReconnect = () => {
-  if (!browserMode || !csrfToken || callbackMap.size === 0 || eventStreamReconnectTimer) {
-    return;
-  }
-  eventStreamReconnectTimer = setTimeout(() => {
-    eventStreamReconnectTimer = null;
-    ensureEventSource();
-  }, 1000);
-};
-
-/**
- * Opens the browser-mode SSE stream with the same cookie-bound CSRF header as
- * app calls.
- *
- * Native EventSource cannot send CSRF headers, so fetch streaming is used to
- * avoid storing CSRF tokens in URLs while preserving reconnect behavior.
- */
-const runBrowserEventStream = async (controller: AbortController) => {
-  let reconnect = true;
-  try {
-    const response = await fetch(withBrowserBasePath("/api/events"), {
-      method: "GET",
-      credentials: "include",
-      headers: { "X-CSRF-Token": csrfToken },
-      signal: controller.signal,
-    });
-    if (!response.ok) {
-      if (isAuthFailureStatus(response.status)) {
-        reconnect = await refreshBrowserAuthState().catch(() => false);
-      }
-      return;
-    }
-    if (!response.body) {
-      throw new Error("Event stream response body is unavailable");
-    }
-    await readBrowserEventStream(response.body, controller.signal);
-  } catch (_err) {
-    if (!controller.signal.aborted) {
-      // Network interruptions should behave like EventSource reconnects.
-      scheduleEventStreamReconnect();
-    }
-    return;
-  } finally {
-    if (eventStreamController === controller) {
-      eventStreamController = null;
-      if (reconnect && !controller.signal.aborted) {
-        scheduleEventStreamReconnect();
-      }
-    }
-  }
-};
-
-/**
- * Reads browser-mode SSE frames until the stream ends or the supplied signal is
- * aborted. Aborts cancel the active reader so unsubscribe cannot leave a pending
- * read behind.
- */
-const readBrowserEventStream = async (body: ReadableStream<Uint8Array>, signal: AbortSignal) => {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const abortRead = () => {
-    void reader.cancel();
-  };
-  signal.addEventListener("abort", abortRead, { once: true });
-  try {
-    for (;;) {
-      if (signal.aborted) {
-        break;
-      }
-      const { value, done } = await reader.read();
-      if (done || signal.aborted) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split(/\r?\n\r?\n/);
-      buffer = parts.pop() || "";
-      for (const part of parts) {
-        dispatchBrowserEventBlock(part);
-      }
-    }
-  } finally {
-    signal.removeEventListener("abort", abortRead);
-    reader.releaseLock();
-  }
-};
-
-const dispatchBrowserEventBlock = (block: string) => {
-  let eventName = "message";
-  const data: string[] = [];
-  for (const line of block.split(/\r?\n/)) {
-    if (line.startsWith("event:")) {
-      eventName = line.slice("event:".length).trim();
-    } else if (line.startsWith("data:")) {
-      data.push(line.slice("data:".length).trimStart());
-    }
-  }
-  if (!callbackMap.has(eventName) || data.length === 0) {
-    return;
-  }
-  const payload = JSON.parse(data.join("\n"));
-  callbackMap.get(eventName)?.forEach((callback) => callback(payload));
-};
-
-const postJSON = async <T>(path: string, body?: unknown): Promise<T> => {
-  const requestInit = (): RequestInit => ({
-    method: "POST",
-    credentials: "include",
-    headers: {
-      "Content-Type": "application/json",
-      ...(csrfToken ? { "X-CSRF-Token": csrfToken } : {}),
-    },
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  let response = await fetch(withBrowserBasePath(path), requestInit());
-  let payload = await parseJSONResponse<T & { error?: string }>(response);
-  if (!response.ok && isAuthFailureStatus(response.status) && (await refreshBrowserAuthState())) {
-    response = await fetch(withBrowserBasePath(path), requestInit());
-    payload = await parseJSONResponse<T & { error?: string }>(response);
-  }
-  if (!response.ok) {
-    throw new Error(String(payload?.error || response.statusText || "Request failed"));
-  }
-  if (payload === null) {
-    throw new Error("Request returned an empty response");
-  }
-  return payload as T;
-};
-
-/**
- * Installs the browser-mode app bridge and pins app calls/events to token.
- *
- * runtimeCaseInsensitivePaths should come from the web server so browser path
- * comparisons match the host filesystem, not the client platform.
- */
-export const initializeBrowserBridge = (
-  token: string,
-  browseEnabled = false,
-  runtimeCaseInsensitivePaths?: boolean,
-) => {
-  browserMode = isWebUIRuntime();
-  setNativeBrowseEnabled(browseEnabled);
-  setRuntimePathCaseSensitivity(runtimeCaseInsensitivePaths);
-  if (!browserMode) {
-    return;
-  }
-  csrfToken = token;
-
-  const call = <T>(method: string, body?: unknown) => postJSON<T>(`/api/app/${method}`, body);
-
-  (globalThis as any).go = {
-    guiapp: {
-      App: {
-        BrowsePath: () => call<string>("BrowseFile"),
-        BrowseFile: () => call<string>("BrowseFile"),
-        BrowseImageFiles: () => call<string[]>("BrowseImageFiles"),
-        BrowseFolder: () => call<string>("BrowseFolder"),
-        BrowseDirectory: (path: string, mode: "file" | "folder") =>
-          call("BrowseDirectory", { path, mode }),
-        DetectDiscType: (path: string) => call<string>("DetectDiscType", { Path: path }),
-        FetchMetadata: (
-          path: string,
-          sourceLookupURL: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-        ) =>
-          call("FetchMetadata", {
-            Path: path,
-            SourceLookupURL: sourceLookupURL,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-          }),
-        ResetMetadata: (
-          path: string,
-          sourceLookupURL: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-        ) =>
-          call("ResetMetadata", {
-            Path: path,
-            SourceLookupURL: sourceLookupURL,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-          }),
-        SelectBlurayCandidate: (path: string, releaseID: string) =>
-          call("SelectBlurayCandidate", {
-            Path: path,
-            ReleaseID: releaseID,
-          }),
-        FetchDescriptionBuilder: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-          ignoreDupesFor: string[],
-        ) =>
-          call("FetchDescriptionBuilder", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-            IgnoreDupesFor: ignoreDupesFor,
-          }),
-        FetchPreparation: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-          ignoreDupesFor: string[],
-        ) =>
-          call("FetchPreparation", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-            IgnoreDupesFor: ignoreDupesFor,
-          }),
-        FetchTrackerDryRun: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-          ignoreDupesFor: string[],
-          questionnaireAnswers: Record<string, Record<string, string>>,
-          descriptionGroups: unknown,
-          debug: boolean,
-          noSeed: boolean,
-          runLogLevel: string,
-        ) =>
-          call("FetchTrackerDryRun", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-            IgnoreDupesFor: ignoreDupesFor,
-            QuestionnaireAnswers: questionnaireAnswers,
-            DescriptionGroups: descriptionGroups,
-            Debug: debug,
-            NoSeed: noSeed,
-            RunLogLevel: runLogLevel,
-          }),
-        CheckDupes: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-        ) =>
-          call("CheckDupes", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-          }),
-        StartDupeCheck: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-        ) =>
-          call("StartDupeCheck", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-          }),
-        CancelDupeCheck: (jobID: string) => call("CancelDupeCheck", { JobID: jobID }),
-        GetDupeCheckSnapshot: (jobID: string) => call("GetDupeCheckSnapshot", { JobID: jobID }),
-        FetchScreenshotPlan: (path: string, overrides: unknown, nameOverrides: unknown) =>
-          call("FetchScreenshotPlan", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        GenerateScreenshots: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          selections: unknown,
-          purpose: string,
-        ) =>
-          call("GenerateScreenshots", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Selections: selections,
-            Purpose: purpose,
-          }),
-        PreviewScreenshotFrame: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          timestampSeconds: number,
-        ) =>
-          call("PreviewScreenshotFrame", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            TimestampSeconds: timestampSeconds,
-          }),
-        DeleteScreenshot: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          imagePath: string,
-        ) =>
-          call("DeleteScreenshot", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            ImagePath: imagePath,
-          }),
-        SaveFinalScreenshotSelections: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          images: unknown,
-        ) =>
-          call("SaveFinalScreenshotSelections", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Images: images,
-          }),
-        ImportMenuImages: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          paths: string[],
-        ) =>
-          call("ImportMenuImages", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Paths: paths,
-          }),
-        StartDVDMenuCapture: (path: string, overrides: unknown, nameOverrides: unknown) =>
-          call("StartDVDMenuCapture", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        GetDVDMenuCaptureSnapshot: (jobID: string) =>
-          call("GetDVDMenuCaptureSnapshot", { JobID: jobID }),
-        CancelDVDMenuCapture: (jobID: string) => call("CancelDVDMenuCapture", { JobID: jobID }),
-        ListDVDMenuScreenshots: (path: string, overrides: unknown, nameOverrides: unknown) =>
-          call("ListDVDMenuScreenshots", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        DeleteDVDMenuScreenshot: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          imagePath: string,
-        ) =>
-          call("DeleteDVDMenuScreenshot", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            ImagePath: imagePath,
-          }),
-        ReadScreenshotImage: (path: string) => call("ReadScreenshotImage", { Path: path }),
-        ListUploadCandidates: (path: string, overrides: unknown, nameOverrides: unknown) =>
-          call("ListUploadCandidates", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        ListUploadedImages: (path: string, overrides: unknown, nameOverrides: unknown) =>
-          call("ListUploadedImages", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        UploadImages: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-          host: string,
-          images: unknown,
-        ) =>
-          call("UploadImages", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-            Host: host,
-            Images: images,
-          }),
-        DeleteUploadedImage: (path: string, imagePath: string, host: string) =>
-          call("DeleteUploadedImage", { Path: path, ImagePath: imagePath, Host: host }),
-        DeleteTrackerImageURL: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          url: string,
-        ) =>
-          call("DeleteTrackerImageURL", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            URL: url,
-          }),
-        RenderDescription: (raw: string) => call("RenderDescription", { Raw: raw }),
-        SaveDescriptionOverride: (
-          path: string,
-          groupKey: string,
-          raw: string,
-          trackers: string[],
-          overrides: unknown,
-          nameOverrides: unknown,
-        ) =>
-          call("SaveDescriptionOverride", {
-            Path: path,
-            GroupKey: groupKey,
-            Raw: raw,
-            Trackers: trackers,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-          }),
-        DiscoverPlaylists: (path: string) => call("DiscoverPlaylists", { Path: path }),
-        SavePlaylistSelection: (path: string, playlists: string[], useAll: boolean) =>
-          call("SavePlaylistSelection", { Path: path, Playlists: playlists, UseAll: useAll }),
-        LoadPlaylistSelection: (path: string) => call("LoadPlaylistSelection", { Path: path }),
-        GetConfig: () => call("GetConfig"),
-        GetApplicationInfo: () => call("GetApplicationInfo"),
-        GetDefaultConfig: () => call("GetDefaultConfig"),
-        SaveConfig: (payload: string) => call("SaveConfig", { Payload: payload }),
-        ExportConfig: async () => {
-          const payload = await call<string>("ExportConfig");
-          const blob = new Blob([payload], { type: "application/json" });
-          const url = URL.createObjectURL(blob);
-          const anchor = document.createElement("a");
-          anchor.href = url;
-          anchor.download = "upbrr-config.json";
-          anchor.click();
-          URL.revokeObjectURL(url);
-          return anchor.download;
-        },
-        ImportConfig: async () => {
-          const fileData = await new Promise<{ name: string; content: string }>(
-            (resolve, reject) => {
-              const input = document.createElement("input");
-              input.type = "file";
-              input.accept = ".py,.yaml,.yml,.json";
-              input.onchange = () => {
-                const file = input.files?.[0];
-                if (!file) {
-                  resolve({ name: "", content: "" });
-                  return;
-                }
-                const reader = new FileReader();
-                reader.onload = () =>
-                  resolve({ name: file.name, content: reader.result as string });
-                reader.onerror = () => reject(reader.error);
-                reader.readAsText(file);
-              };
-              input.addEventListener("cancel", () => resolve({ name: "", content: "" }));
-              input.click();
-            },
-          );
-          if (!fileData.name) return { message: "", warnings: [] };
-          const resp = await call<{ result: string; warnings: string[] }>("ImportConfig", {
-            FileName: fileData.name,
-            FileContent: fileData.content,
-          });
-          return { message: resp.result, warnings: resp.warnings ?? [] };
-        },
-        GetLogPath: () => call("GetLogPath"),
-        GetRecentLogs: (limit: number) => call("GetRecentLogs", { Limit: limit }),
-        StartLogStream: () => call("StartLogStream"),
-        StopLogStream: (streamID: string) => call("StopLogStream", { StreamID: streamID }),
-        GetLogExclusions: () => call("GetLogExclusions"),
-        UpdateLogExclusions: (patterns: string[]) =>
-          call("UpdateLogExclusions", { Patterns: patterns }),
-        ListKnownTrackers: () => call("ListKnownTrackers"),
-        ListTrackerAuthCapabilities: () => call("ListTrackerAuthCapabilities"),
-        GetTrackerAuthStatus: (tracker: string) =>
-          call("GetTrackerAuthStatus", { Tracker: tracker }),
-        ImportTrackerAuthCookies: async (tracker: string) => {
-          const fileData = await new Promise<{ name: string; content: string }>(
-            (resolve, reject) => {
-              const input = document.createElement("input");
-              input.type = "file";
-              input.accept = ".txt,.json";
-              input.onchange = () => {
-                const file = input.files?.[0];
-                if (!file) {
-                  resolve({ name: "", content: "" });
-                  return;
-                }
-                if (file.size > maxCookieImportContentBytes) {
-                  reject(
-                    new Error(
-                      `tracker auth: cookie file content exceeds ${maxCookieImportContentBytes} byte limit`,
-                    ),
-                  );
-                  return;
-                }
-                const reader = new FileReader();
-                reader.onload = () => {
-                  const content = reader.result as string;
-                  if (encodedTextByteLength(content) > maxCookieImportContentBytes) {
-                    reject(
-                      new Error(
-                        `tracker auth: cookie file content exceeds ${maxCookieImportContentBytes} byte limit`,
-                      ),
-                    );
-                    return;
-                  }
-                  resolve({ name: file.name, content });
-                };
-                reader.onerror = () => reject(reader.error);
-                reader.readAsText(file);
-              };
-              input.addEventListener("cancel", () => resolve({ name: "", content: "" }));
-              input.click();
-            },
-          );
-          if (!fileData.name) {
-            return call("GetTrackerAuthStatus", { Tracker: tracker });
-          }
-          return call("ImportTrackerAuthCookieContent", {
-            Tracker: tracker,
-            FileName: fileData.name,
-            Content: fileData.content,
-          });
-        },
-        ImportTrackerAuthCookieContent: (tracker: string, fileName: string, content: string) =>
-          call("ImportTrackerAuthCookieContent", {
-            Tracker: tracker,
-            FileName: fileName,
-            Content: content,
-          }),
-        TestTrackerAuth: (tracker: string) => call("TestTrackerAuth", { Tracker: tracker }),
-        LoginTrackerAuth: (tracker: string, login: unknown) =>
-          call("LoginTrackerAuth", { Tracker: tracker, Login: login }),
-        SubmitTrackerAuth2FA: (challengeID: string, code: string) =>
-          call("SubmitTrackerAuth2FA", { ChallengeID: challengeID, Code: code }),
-        DeleteTrackerAuth: (tracker: string) => call("DeleteTrackerAuth", { Tracker: tracker }),
-        GetImageHostPolicyMetadata: () => call("GetImageHostPolicyMetadata"),
-        ListHistory: () => call("ListHistory"),
-        GetHistoryOverview: (sourcePath: string) =>
-          call("GetHistoryOverview", { SourcePath: sourcePath }),
-        DeleteHistoryRelease: (sourcePath: string) =>
-          call("DeleteHistoryRelease", { SourcePath: sourcePath }),
-        StartTrackerUpload: (
-          path: string,
-          overrides: unknown,
-          nameOverrides: unknown,
-          trackers: string[],
-          ignoreDupesFor: string[],
-          questionnaireAnswers: Record<string, Record<string, string>>,
-          descriptionGroups: unknown,
-          debug: boolean,
-          noSeed: boolean,
-          runLogLevel: string,
-        ) =>
-          call("StartTrackerUpload", {
-            Path: path,
-            Overrides: overrides,
-            NameOverrides: nameOverrides,
-            Trackers: trackers,
-            IgnoreDupesFor: ignoreDupesFor,
-            QuestionnaireAnswers: questionnaireAnswers,
-            DescriptionGroups: descriptionGroups,
-            Debug: debug,
-            NoSeed: noSeed,
-            RunLogLevel: runLogLevel,
-          }),
-        CancelTrackerUpload: (jobID: string) => call("CancelTrackerUpload", { JobID: jobID }),
-        RetryFailedTrackerUpload: (jobID: string) =>
-          call("RetryFailedTrackerUpload", { JobID: jobID }),
-        GetTrackerUploadSnapshot: (jobID: string) =>
-          call("GetTrackerUploadSnapshot", { JobID: jobID }),
-        GetTrackerIcon: (domain: string, url: string) =>
-          call<string>("GetTrackerIcon", { Domain: domain, URL: url }),
-      },
-    },
-  };
-  recreateEventSource();
-};
-
-/** Returns whether app calls should use the browser HTTP bridge instead of Wails. */
-export const isBrowserMode = () => {
-  browserMode = isWebUIRuntime();
-  return browserMode;
-};
-
-/**
- * Reports whether browser-mode callers can use host-native browse dialogs.
- * Wails desktop mode always provides native browse support.
- */
-export const isBrowserNativeBrowseAvailable = () => {
-  if (!isBrowserMode()) {
-    return true;
-  }
-  return nativeBrowseEnabled;
-};
-
-/**
- * Reports whether the current runtime compares host filesystem paths
- * case-insensitively.
- */
-export const isRuntimePathCaseInsensitive = () => caseInsensitivePaths;
-
-/**
- * Subscribes to browser-mode native browse availability changes.
- */
-export const subscribeBrowserNativeBrowseAvailability = (listener: () => void) => {
-  nativeBrowseAvailabilityListeners.add(listener);
-  return () => {
-    nativeBrowseAvailabilityListeners.delete(listener);
-  };
-};
-
-/**
- * Updates the CSRF token used by browser-mode app calls and event streams.
- *
- * Passing runtimeCaseInsensitivePaths also refreshes the host path-comparison
- * contract carried by auth/status responses.
- */
-export const updateBrowserCSRFToken = (token: string, runtimeCaseInsensitivePaths?: boolean) => {
-  csrfToken = token;
-  setRuntimePathCaseSensitivity(runtimeCaseInsensitivePaths);
-  recreateEventSource();
-};
-
-/**
- * Browser-mode auth calls that share the injected base path and cookie-bound
- * CSRF handling used by the app bridge.
- */
-export const browserAuth = {
-  status: async () => {
-    const response = await fetch(withBrowserBasePath("/api/auth/status"), {
-      credentials: "include",
-    });
-    const payload = await parseJSONResponse<Record<string, unknown> & { error?: string }>(response);
-    if (!response.ok) {
-      throw new Error(String(payload?.error || response.statusText || "Request failed"));
-    }
-    return payload || {};
-  },
-  bootstrap: (username: string, password: string, retainLogin: boolean) =>
-    postJSON("/api/auth/bootstrap", { username, password, retainLogin }),
-  login: (username: string, password: string, retainLogin: boolean) =>
-    postJSON("/api/auth/login", { username, password, retainLogin }),
-  saveBrowsePolicy: (browseRoot: string, allowUnrestrictedBrowse: boolean) =>
-    postJSON("/api/auth/browse-policy", { browseRoot, allowUnrestrictedBrowse }),
-  logout: () => postJSON("/api/auth/logout"),
-};
-
-/**
- * Subscribes to Wails events in desktop mode or the cookie-bound web event
- * stream in browser mode.
- */
-export const EventsOn = (eventName: string, callback: EventCallback) => {
-  if (!browserMode) {
-    return wailsEventsOn(eventName, callback as any);
-  }
-  return addBrowserListener(eventName, callback);
-};
diff --git a/gui/frontend/src/utils/trackerSelection.test.ts b/gui/frontend/src/utils/trackerSelection.test.ts
deleted file mode 100644
index 1088e8c6..00000000
--- a/gui/frontend/src/utils/trackerSelection.test.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import { describe, expect, it } from "vitest";
-import {
-  hasFilteredEmptyUploadTrackerSelection,
-  resolveSelectedUploadTrackers,
-} from "./trackerSelection";
-import type { TrackerUploadItem } from "../types";
-
-describe("resolveSelectedUploadTrackers", () => {
-  const trackerUploadItems: TrackerUploadItem[] = [
-    { name: "AITHER", config: {} },
-    { name: "BLU", config: {} },
-  ];
-
-  it("excludes stale upload toggles for trackers deselected on the input page", () => {
-    expect(
-      resolveSelectedUploadTrackers({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true, BLU: false },
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toEqual(["AITHER"]);
-  });
-
-  it("excludes blocked selected trackers", () => {
-    expect(
-      resolveSelectedUploadTrackers({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true, BLU: true },
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(["blu"]),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toEqual(["AITHER"]);
-  });
-
-  it("excludes skipped selected trackers", () => {
-    expect(
-      resolveSelectedUploadTrackers({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true, BLU: true },
-        uploadToggles: { AITHER: true, BLU: true },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(["blu"]),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toEqual(["AITHER"]);
-  });
-
-  it("detects explicit release selections filtered to no upload trackers", () => {
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true, BLU: true },
-        uploadToggles: { AITHER: false, BLU: true },
-        dupedTrackerSet: new Set(["blu"]),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(true);
-  });
-
-  it("does not treat uninitialized toggles or eligible trackers as filtered empty", () => {
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true },
-        uploadToggles: {},
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(false);
-
-    expect(
-      hasFilteredEmptyUploadTrackerSelection({
-        trackerUploadItems,
-        releasePageTrackerSelection: { AITHER: true, BLU: true },
-        uploadToggles: { AITHER: true, BLU: false },
-        dupedTrackerSet: new Set(),
-        skippedDupeTrackerSet: new Set(),
-        ruleSkippedTrackerSet: new Set(),
-        failedDupeTrackerSet: new Set(),
-      }),
-    ).toBe(false);
-  });
-});
diff --git a/gui/frontend/src/utils/trackerSelection.ts b/gui/frontend/src/utils/trackerSelection.ts
deleted file mode 100644
index 4dfb2759..00000000
--- a/gui/frontend/src/utils/trackerSelection.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import type { TrackerUploadItem } from "../types";
-
-type ResolveSelectedUploadTrackersInput = {
-  trackerUploadItems: TrackerUploadItem[];
-  releasePageTrackerSelection: Record<string, boolean>;
-  uploadToggles: Record<string, boolean>;
-  dupedTrackerSet: Set<string>;
-  skippedDupeTrackerSet: Set<string>;
-  ruleSkippedTrackerSet: Set<string>;
-  failedDupeTrackerSet: Set<string>;
-};
-
-const hasOwn = (value: Record<string, boolean>, key: string) =>
-  Object.prototype.hasOwnProperty.call(value, key);
-
-/**
- * resolveSelectedUploadTrackers returns the trackers that may be sent to
- * metadata, upload, dry-run, and image-upload requests.
- *
- * A tracker must still be selected on the input page, enabled on the upload page,
- * configured in the current tracker list, and not blocked by duplicate hits,
- * skipped dupe checks, rule failures, or failed dupe checks. Blocked-tracker
- * sets use lower-case trimmed tracker names; returned names keep the upload
- * toggle keys used by the caller. Callers that pass the result to backend APIs
- * where an empty tracker list means defaults must guard filtered-empty selections
- * separately.
- */
-export const resolveSelectedUploadTrackers = ({
-  trackerUploadItems,
-  releasePageTrackerSelection,
-  uploadToggles,
-  dupedTrackerSet,
-  skippedDupeTrackerSet,
-  ruleSkippedTrackerSet,
-  failedDupeTrackerSet,
-}: ResolveSelectedUploadTrackersInput) => {
-  const validTrackers = new Set(trackerUploadItems.map((item) => item.name));
-  return Object.entries(uploadToggles)
-    .filter(([name, enabled]) => {
-      if (!enabled) return false;
-      if (!validTrackers.has(name)) return false;
-      if (!releasePageTrackerSelection[name]) return false;
-      const normalized = name.toLowerCase().trim();
-      if (!normalized) return false;
-      if (dupedTrackerSet.has(normalized)) return false;
-      if (skippedDupeTrackerSet.has(normalized)) return false;
-      if (ruleSkippedTrackerSet.has(normalized)) return false;
-      if (failedDupeTrackerSet.has(normalized)) return false;
-      return true;
-    })
-    .map(([name]) => name);
-};
-
-/**
- * hasFilteredEmptyUploadTrackerSelection returns true when the release page has
- * at least one explicit selected tracker, but upload eligibility filters remove
- * every selected tracker before the backend call.
- *
- * Missing upload toggle keys are treated as startup/uninitialized state, while
- * disabled toggles and duplicate, skipped, rule-failure, or failed dupe-check
- * blocks count as upload filters.
- */
-export const hasFilteredEmptyUploadTrackerSelection = ({
-  trackerUploadItems,
-  releasePageTrackerSelection,
-  uploadToggles,
-  dupedTrackerSet,
-  skippedDupeTrackerSet,
-  ruleSkippedTrackerSet,
-  failedDupeTrackerSet,
-}: ResolveSelectedUploadTrackersInput) => {
-  const selectedReleaseTrackers = trackerUploadItems.filter(
-    (item) => releasePageTrackerSelection[item.name] === true,
-  );
-  if (selectedReleaseTrackers.length === 0) {
-    return false;
-  }
-  return selectedReleaseTrackers.every((item) => {
-    const normalized = item.name.toLowerCase().trim();
-    if (!normalized) return true;
-    if (!hasOwn(uploadToggles, item.name)) return false;
-    if (!uploadToggles[item.name]) return true;
-    if (dupedTrackerSet.has(normalized)) return true;
-    if (skippedDupeTrackerSet.has(normalized)) return true;
-    if (ruleSkippedTrackerSet.has(normalized)) return true;
-    if (failedDupeTrackerSet.has(normalized)) return true;
-    return false;
-  });
-};
diff --git a/gui/frontend/wailsjs/runtime/package.json b/gui/frontend/wailsjs/runtime/package.json
deleted file mode 100644
index 1e7c8a5d..00000000
--- a/gui/frontend/wailsjs/runtime/package.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-  "name": "@wailsapp/runtime",
-  "version": "2.0.0",
-  "description": "Wails Javascript runtime library",
-  "main": "runtime.js",
-  "types": "runtime.d.ts",
-  "scripts": {
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/wailsapp/wails.git"
-  },
-  "keywords": [
-    "Wails",
-    "Javascript",
-    "Go"
-  ],
-  "author": "Lea Anthony <lea.anthony@gmail.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/wailsapp/wails/issues"
-  },
-  "homepage": "https://github.com/wailsapp/wails#readme"
-}
diff --git a/gui/frontend/wailsjs/runtime/runtime.d.ts b/gui/frontend/wailsjs/runtime/runtime.d.ts
deleted file mode 100644
index 3bbea848..00000000
--- a/gui/frontend/wailsjs/runtime/runtime.d.ts
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- _       __      _ __
-| |     / /___ _(_) /____
-| | /| / / __ `/ / / ___/
-| |/ |/ / /_/ / / (__  )
-|__/|__/\__,_/_/_/____/
-The electron alternative for Go
-(c) Lea Anthony 2019-present
-*/
-
-export interface Position {
-    x: number;
-    y: number;
-}
-
-export interface Size {
-    w: number;
-    h: number;
-}
-
-export interface Screen {
-    isCurrent: boolean;
-    isPrimary: boolean;
-    width : number
-    height : number
-}
-
-// Environment information such as platform, buildtype, ...
-export interface EnvironmentInfo {
-    buildType: string;
-    platform: string;
-    arch: string;
-}
-
-// [EventsEmit](https://wails.io/docs/reference/runtime/events#eventsemit)
-// emits the given event. Optional data may be passed with the event.
-// This will trigger any event listeners.
-export function EventsEmit(eventName: string, ...data: any): void;
-
-// [EventsOn](https://wails.io/docs/reference/runtime/events#eventson) sets up a listener for the given event name.
-export function EventsOn(eventName: string, callback: (...data: any) => void): () => void;
-
-// [EventsOnMultiple](https://wails.io/docs/reference/runtime/events#eventsonmultiple)
-// sets up a listener for the given event name, but will only trigger a given number times.
-export function EventsOnMultiple(eventName: string, callback: (...data: any) => void, maxCallbacks: number): () => void;
-
-// [EventsOnce](https://wails.io/docs/reference/runtime/events#eventsonce)
-// sets up a listener for the given event name, but will only trigger once.
-export function EventsOnce(eventName: string, callback: (...data: any) => void): () => void;
-
-// [EventsOff](https://wails.io/docs/reference/runtime/events#eventsoff)
-// unregisters the listener for the given event name.
-export function EventsOff(eventName: string, ...additionalEventNames: string[]): void;
-
-// [EventsOffAll](https://wails.io/docs/reference/runtime/events#eventsoffall)
-// unregisters all listeners.
-export function EventsOffAll(): void;
-
-// [LogPrint](https://wails.io/docs/reference/runtime/log#logprint)
-// logs the given message as a raw message
-export function LogPrint(message: string): void;
-
-// [LogTrace](https://wails.io/docs/reference/runtime/log#logtrace)
-// logs the given message at the `trace` log level.
-export function LogTrace(message: string): void;
-
-// [LogDebug](https://wails.io/docs/reference/runtime/log#logdebug)
-// logs the given message at the `debug` log level.
-export function LogDebug(message: string): void;
-
-// [LogError](https://wails.io/docs/reference/runtime/log#logerror)
-// logs the given message at the `error` log level.
-export function LogError(message: string): void;
-
-// [LogFatal](https://wails.io/docs/reference/runtime/log#logfatal)
-// logs the given message at the `fatal` log level.
-// The application will quit after calling this method.
-export function LogFatal(message: string): void;
-
-// [LogInfo](https://wails.io/docs/reference/runtime/log#loginfo)
-// logs the given message at the `info` log level.
-export function LogInfo(message: string): void;
-
-// [LogWarning](https://wails.io/docs/reference/runtime/log#logwarning)
-// logs the given message at the `warning` log level.
-export function LogWarning(message: string): void;
-
-// [WindowReload](https://wails.io/docs/reference/runtime/window#windowreload)
-// Forces a reload by the main application as well as connected browsers.
-export function WindowReload(): void;
-
-// [WindowReloadApp](https://wails.io/docs/reference/runtime/window#windowreloadapp)
-// Reloads the application frontend.
-export function WindowReloadApp(): void;
-
-// [WindowSetAlwaysOnTop](https://wails.io/docs/reference/runtime/window#windowsetalwaysontop)
-// Sets the window AlwaysOnTop or not on top.
-export function WindowSetAlwaysOnTop(b: boolean): void;
-
-// [WindowSetSystemDefaultTheme](https://wails.io/docs/next/reference/runtime/window#windowsetsystemdefaulttheme)
-// *Windows only*
-// Sets window theme to system default (dark/light).
-export function WindowSetSystemDefaultTheme(): void;
-
-// [WindowSetLightTheme](https://wails.io/docs/next/reference/runtime/window#windowsetlighttheme)
-// *Windows only*
-// Sets window to light theme.
-export function WindowSetLightTheme(): void;
-
-// [WindowSetDarkTheme](https://wails.io/docs/next/reference/runtime/window#windowsetdarktheme)
-// *Windows only*
-// Sets window to dark theme.
-export function WindowSetDarkTheme(): void;
-
-// [WindowCenter](https://wails.io/docs/reference/runtime/window#windowcenter)
-// Centers the window on the monitor the window is currently on.
-export function WindowCenter(): void;
-
-// [WindowSetTitle](https://wails.io/docs/reference/runtime/window#windowsettitle)
-// Sets the text in the window title bar.
-export function WindowSetTitle(title: string): void;
-
-// [WindowFullscreen](https://wails.io/docs/reference/runtime/window#windowfullscreen)
-// Makes the window full screen.
-export function WindowFullscreen(): void;
-
-// [WindowUnfullscreen](https://wails.io/docs/reference/runtime/window#windowunfullscreen)
-// Restores the previous window dimensions and position prior to full screen.
-export function WindowUnfullscreen(): void;
-
-// [WindowIsFullscreen](https://wails.io/docs/reference/runtime/window#windowisfullscreen)
-// Returns the state of the window, i.e. whether the window is in full screen mode or not.
-export function WindowIsFullscreen(): Promise<boolean>;
-
-// [WindowSetSize](https://wails.io/docs/reference/runtime/window#windowsetsize)
-// Sets the width and height of the window.
-export function WindowSetSize(width: number, height: number): void;
-
-// [WindowGetSize](https://wails.io/docs/reference/runtime/window#windowgetsize)
-// Gets the width and height of the window.
-export function WindowGetSize(): Promise<Size>;
-
-// [WindowSetMaxSize](https://wails.io/docs/reference/runtime/window#windowsetmaxsize)
-// Sets the maximum window size. Will resize the window if the window is currently larger than the given dimensions.
-// Setting a size of 0,0 will disable this constraint.
-export function WindowSetMaxSize(width: number, height: number): void;
-
-// [WindowSetMinSize](https://wails.io/docs/reference/runtime/window#windowsetminsize)
-// Sets the minimum window size. Will resize the window if the window is currently smaller than the given dimensions.
-// Setting a size of 0,0 will disable this constraint.
-export function WindowSetMinSize(width: number, height: number): void;
-
-// [WindowSetPosition](https://wails.io/docs/reference/runtime/window#windowsetposition)
-// Sets the window position relative to the monitor the window is currently on.
-export function WindowSetPosition(x: number, y: number): void;
-
-// [WindowGetPosition](https://wails.io/docs/reference/runtime/window#windowgetposition)
-// Gets the window position relative to the monitor the window is currently on.
-export function WindowGetPosition(): Promise<Position>;
-
-// [WindowHide](https://wails.io/docs/reference/runtime/window#windowhide)
-// Hides the window.
-export function WindowHide(): void;
-
-// [WindowShow](https://wails.io/docs/reference/runtime/window#windowshow)
-// Shows the window, if it is currently hidden.
-export function WindowShow(): void;
-
-// [WindowMaximise](https://wails.io/docs/reference/runtime/window#windowmaximise)
-// Maximises the window to fill the screen.
-export function WindowMaximise(): void;
-
-// [WindowToggleMaximise](https://wails.io/docs/reference/runtime/window#windowtogglemaximise)
-// Toggles between Maximised and UnMaximised.
-export function WindowToggleMaximise(): void;
-
-// [WindowUnmaximise](https://wails.io/docs/reference/runtime/window#windowunmaximise)
-// Restores the window to the dimensions and position prior to maximising.
-export function WindowUnmaximise(): void;
-
-// [WindowIsMaximised](https://wails.io/docs/reference/runtime/window#windowismaximised)
-// Returns the state of the window, i.e. whether the window is maximised or not.
-export function WindowIsMaximised(): Promise<boolean>;
-
-// [WindowMinimise](https://wails.io/docs/reference/runtime/window#windowminimise)
-// Minimises the window.
-export function WindowMinimise(): void;
-
-// [WindowUnminimise](https://wails.io/docs/reference/runtime/window#windowunminimise)
-// Restores the window to the dimensions and position prior to minimising.
-export function WindowUnminimise(): void;
-
-// [WindowIsMinimised](https://wails.io/docs/reference/runtime/window#windowisminimised)
-// Returns the state of the window, i.e. whether the window is minimised or not.
-export function WindowIsMinimised(): Promise<boolean>;
-
-// [WindowIsNormal](https://wails.io/docs/reference/runtime/window#windowisnormal)
-// Returns the state of the window, i.e. whether the window is normal or not.
-export function WindowIsNormal(): Promise<boolean>;
-
-// [WindowSetBackgroundColour](https://wails.io/docs/reference/runtime/window#windowsetbackgroundcolour)
-// Sets the background colour of the window to the given RGBA colour definition. This colour will show through for all transparent pixels.
-export function WindowSetBackgroundColour(R: number, G: number, B: number, A: number): void;
-
-// [ScreenGetAll](https://wails.io/docs/reference/runtime/window#screengetall)
-// Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.
-export function ScreenGetAll(): Promise<Screen[]>;
-
-// [BrowserOpenURL](https://wails.io/docs/reference/runtime/browser#browseropenurl)
-// Opens the given URL in the system browser.
-export function BrowserOpenURL(url: string): void;
-
-// [Environment](https://wails.io/docs/reference/runtime/intro#environment)
-// Returns information about the environment
-export function Environment(): Promise<EnvironmentInfo>;
-
-// [Quit](https://wails.io/docs/reference/runtime/intro#quit)
-// Quits the application.
-export function Quit(): void;
-
-// [Hide](https://wails.io/docs/reference/runtime/intro#hide)
-// Hides the application.
-export function Hide(): void;
-
-// [Show](https://wails.io/docs/reference/runtime/intro#show)
-// Shows the application.
-export function Show(): void;
-
-// [ClipboardGetText](https://wails.io/docs/reference/runtime/clipboard#clipboardgettext)
-// Returns the current text stored on clipboard
-export function ClipboardGetText(): Promise<string>;
-
-// [ClipboardSetText](https://wails.io/docs/reference/runtime/clipboard#clipboardsettext)
-// Sets a text on the clipboard
-export function ClipboardSetText(text: string): Promise<boolean>;
-
-// [OnFileDrop](https://wails.io/docs/reference/runtime/draganddrop#onfiledrop)
-// OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.
-export function OnFileDrop(callback: (x: number, y: number ,paths: string[]) => void, useDropTarget: boolean) :void
-
-// [OnFileDropOff](https://wails.io/docs/reference/runtime/draganddrop#dragandddropoff)
-// OnFileDropOff removes the drag and drop listeners and handlers.
-export function OnFileDropOff() :void
-
-// Check if the file path resolver is available
-export function CanResolveFilePaths(): boolean;
-
-// Resolves file paths for an array of files
-export function ResolveFilePaths(files: File[]): void
-
-// Notification types
-export interface NotificationOptions {
-    id: string;
-    title: string;
-    subtitle?: string; // macOS and Linux only
-    body?: string;
-    categoryId?: string;
-    data?: { [key: string]: any };
-}
-
-export interface NotificationAction {
-    id?: string;
-    title?: string;
-    destructive?: boolean; // macOS-specific
-}
-
-export interface NotificationCategory {
-    id?: string;
-    actions?: NotificationAction[];
-    hasReplyField?: boolean;
-    replyPlaceholder?: string;
-    replyButtonTitle?: string;
-}
-
-// [InitializeNotifications](https://wails.io/docs/reference/runtime/notification#initializenotifications)
-// Initializes the notification service for the application.
-// This must be called before sending any notifications.
-export function InitializeNotifications(): Promise<void>;
-
-// [CleanupNotifications](https://wails.io/docs/reference/runtime/notification#cleanupnotifications)
-// Cleans up notification resources and releases any held connections.
-export function CleanupNotifications(): Promise<void>;
-
-// [IsNotificationAvailable](https://wails.io/docs/reference/runtime/notification#isnotificationavailable)
-// Checks if notifications are available on the current platform.
-export function IsNotificationAvailable(): Promise<boolean>;
-
-// [RequestNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#requestnotificationauthorization)
-// Requests notification authorization from the user (macOS only).
-export function RequestNotificationAuthorization(): Promise<boolean>;
-
-// [CheckNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#checknotificationauthorization)
-// Checks the current notification authorization status (macOS only).
-export function CheckNotificationAuthorization(): Promise<boolean>;
-
-// [SendNotification](https://wails.io/docs/reference/runtime/notification#sendnotification)
-// Sends a basic notification with the given options.
-export function SendNotification(options: NotificationOptions): Promise<void>;
-
-// [SendNotificationWithActions](https://wails.io/docs/reference/runtime/notification#sendnotificationwithactions)
-// Sends a notification with action buttons. Requires a registered category.
-export function SendNotificationWithActions(options: NotificationOptions): Promise<void>;
-
-// [RegisterNotificationCategory](https://wails.io/docs/reference/runtime/notification#registernotificationcategory)
-// Registers a notification category that can be used with SendNotificationWithActions.
-export function RegisterNotificationCategory(category: NotificationCategory): Promise<void>;
-
-// [RemoveNotificationCategory](https://wails.io/docs/reference/runtime/notification#removenotificationcategory)
-// Removes a previously registered notification category.
-export function RemoveNotificationCategory(categoryId: string): Promise<void>;
-
-// [RemoveAllPendingNotifications](https://wails.io/docs/reference/runtime/notification#removeallpendingnotifications)
-// Removes all pending notifications from the notification center.
-export function RemoveAllPendingNotifications(): Promise<void>;
-
-// [RemovePendingNotification](https://wails.io/docs/reference/runtime/notification#removependingnotification)
-// Removes a specific pending notification by its identifier.
-export function RemovePendingNotification(identifier: string): Promise<void>;
-
-// [RemoveAllDeliveredNotifications](https://wails.io/docs/reference/runtime/notification#removealldeliverednotifications)
-// Removes all delivered notifications from the notification center.
-export function RemoveAllDeliveredNotifications(): Promise<void>;
-
-// [RemoveDeliveredNotification](https://wails.io/docs/reference/runtime/notification#removedeliverednotification)
-// Removes a specific delivered notification by its identifier.
-export function RemoveDeliveredNotification(identifier: string): Promise<void>;
-
-// [RemoveNotification](https://wails.io/docs/reference/runtime/notification#removenotification)
-// Removes a notification by its identifier (cross-platform convenience function).
-export function RemoveNotification(identifier: string): Promise<void>;
\ No newline at end of file
diff --git a/gui/frontend/wailsjs/runtime/runtime.js b/gui/frontend/wailsjs/runtime/runtime.js
deleted file mode 100644
index 556621ee..00000000
--- a/gui/frontend/wailsjs/runtime/runtime.js
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- _       __      _ __
-| |     / /___ _(_) /____
-| | /| / / __ `/ / / ___/
-| |/ |/ / /_/ / / (__  )
-|__/|__/\__,_/_/_/____/
-The electron alternative for Go
-(c) Lea Anthony 2019-present
-*/
-
-export function LogPrint(message) {
-    window.runtime.LogPrint(message);
-}
-
-export function LogTrace(message) {
-    window.runtime.LogTrace(message);
-}
-
-export function LogDebug(message) {
-    window.runtime.LogDebug(message);
-}
-
-export function LogInfo(message) {
-    window.runtime.LogInfo(message);
-}
-
-export function LogWarning(message) {
-    window.runtime.LogWarning(message);
-}
-
-export function LogError(message) {
-    window.runtime.LogError(message);
-}
-
-export function LogFatal(message) {
-    window.runtime.LogFatal(message);
-}
-
-export function EventsOnMultiple(eventName, callback, maxCallbacks) {
-    return window.runtime.EventsOnMultiple(eventName, callback, maxCallbacks);
-}
-
-export function EventsOn(eventName, callback) {
-    return EventsOnMultiple(eventName, callback, -1);
-}
-
-export function EventsOff(eventName, ...additionalEventNames) {
-    return window.runtime.EventsOff(eventName, ...additionalEventNames);
-}
-
-export function EventsOffAll() {
-  return window.runtime.EventsOffAll();
-}
-
-export function EventsOnce(eventName, callback) {
-    return EventsOnMultiple(eventName, callback, 1);
-}
-
-export function EventsEmit(eventName) {
-    let args = [eventName].slice.call(arguments);
-    return window.runtime.EventsEmit.apply(null, args);
-}
-
-export function WindowReload() {
-    window.runtime.WindowReload();
-}
-
-export function WindowReloadApp() {
-    window.runtime.WindowReloadApp();
-}
-
-export function WindowSetAlwaysOnTop(b) {
-    window.runtime.WindowSetAlwaysOnTop(b);
-}
-
-export function WindowSetSystemDefaultTheme() {
-    window.runtime.WindowSetSystemDefaultTheme();
-}
-
-export function WindowSetLightTheme() {
-    window.runtime.WindowSetLightTheme();
-}
-
-export function WindowSetDarkTheme() {
-    window.runtime.WindowSetDarkTheme();
-}
-
-export function WindowCenter() {
-    window.runtime.WindowCenter();
-}
-
-export function WindowSetTitle(title) {
-    window.runtime.WindowSetTitle(title);
-}
-
-export function WindowFullscreen() {
-    window.runtime.WindowFullscreen();
-}
-
-export function WindowUnfullscreen() {
-    window.runtime.WindowUnfullscreen();
-}
-
-export function WindowIsFullscreen() {
-    return window.runtime.WindowIsFullscreen();
-}
-
-export function WindowGetSize() {
-    return window.runtime.WindowGetSize();
-}
-
-export function WindowSetSize(width, height) {
-    window.runtime.WindowSetSize(width, height);
-}
-
-export function WindowSetMaxSize(width, height) {
-    window.runtime.WindowSetMaxSize(width, height);
-}
-
-export function WindowSetMinSize(width, height) {
-    window.runtime.WindowSetMinSize(width, height);
-}
-
-export function WindowSetPosition(x, y) {
-    window.runtime.WindowSetPosition(x, y);
-}
-
-export function WindowGetPosition() {
-    return window.runtime.WindowGetPosition();
-}
-
-export function WindowHide() {
-    window.runtime.WindowHide();
-}
-
-export function WindowShow() {
-    window.runtime.WindowShow();
-}
-
-export function WindowMaximise() {
-    window.runtime.WindowMaximise();
-}
-
-export function WindowToggleMaximise() {
-    window.runtime.WindowToggleMaximise();
-}
-
-export function WindowUnmaximise() {
-    window.runtime.WindowUnmaximise();
-}
-
-export function WindowIsMaximised() {
-    return window.runtime.WindowIsMaximised();
-}
-
-export function WindowMinimise() {
-    window.runtime.WindowMinimise();
-}
-
-export function WindowUnminimise() {
-    window.runtime.WindowUnminimise();
-}
-
-export function WindowSetBackgroundColour(R, G, B, A) {
-    window.runtime.WindowSetBackgroundColour(R, G, B, A);
-}
-
-export function ScreenGetAll() {
-    return window.runtime.ScreenGetAll();
-}
-
-export function WindowIsMinimised() {
-    return window.runtime.WindowIsMinimised();
-}
-
-export function WindowIsNormal() {
-    return window.runtime.WindowIsNormal();
-}
-
-export function BrowserOpenURL(url) {
-    window.runtime.BrowserOpenURL(url);
-}
-
-export function Environment() {
-    return window.runtime.Environment();
-}
-
-export function Quit() {
-    window.runtime.Quit();
-}
-
-export function Hide() {
-    window.runtime.Hide();
-}
-
-export function Show() {
-    window.runtime.Show();
-}
-
-export function ClipboardGetText() {
-    return window.runtime.ClipboardGetText();
-}
-
-export function ClipboardSetText(text) {
-    return window.runtime.ClipboardSetText(text);
-}
-
-/**
- * Callback for OnFileDrop returns a slice of file path strings when a drop is finished.
- *
- * @export
- * @callback OnFileDropCallback
- * @param {number} x - x coordinate of the drop
- * @param {number} y - y coordinate of the drop
- * @param {string[]} paths - A list of file paths.
- */
-
-/**
- * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.
- *
- * @export
- * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished.
- * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target)
- */
-export function OnFileDrop(callback, useDropTarget) {
-    return window.runtime.OnFileDrop(callback, useDropTarget);
-}
-
-/**
- * OnFileDropOff removes the drag and drop listeners and handlers.
- */
-export function OnFileDropOff() {
-    return window.runtime.OnFileDropOff();
-}
-
-export function CanResolveFilePaths() {
-    return window.runtime.CanResolveFilePaths();
-}
-
-export function ResolveFilePaths(files) {
-    return window.runtime.ResolveFilePaths(files);
-}
-
-export function InitializeNotifications() {
-    return window.runtime.InitializeNotifications();
-}
-
-export function CleanupNotifications() {
-    return window.runtime.CleanupNotifications();
-}
-
-export function IsNotificationAvailable() {
-    return window.runtime.IsNotificationAvailable();
-}
-
-export function RequestNotificationAuthorization() {
-    return window.runtime.RequestNotificationAuthorization();
-}
-
-export function CheckNotificationAuthorization() {
-    return window.runtime.CheckNotificationAuthorization();
-}
-
-export function SendNotification(options) {
-    return window.runtime.SendNotification(options);
-}
-
-export function SendNotificationWithActions(options) {
-    return window.runtime.SendNotificationWithActions(options);
-}
-
-export function RegisterNotificationCategory(category) {
-    return window.runtime.RegisterNotificationCategory(category);
-}
-
-export function RemoveNotificationCategory(categoryId) {
-    return window.runtime.RemoveNotificationCategory(categoryId);
-}
-
-export function RemoveAllPendingNotifications() {
-    return window.runtime.RemoveAllPendingNotifications();
-}
-
-export function RemovePendingNotification(identifier) {
-    return window.runtime.RemovePendingNotification(identifier);
-}
-
-export function RemoveAllDeliveredNotifications() {
-    return window.runtime.RemoveAllDeliveredNotifications();
-}
-
-export function RemoveDeliveredNotification(identifier) {
-    return window.runtime.RemoveDeliveredNotification(identifier);
-}
-
-export function RemoveNotification(identifier) {
-    return window.runtime.RemoveNotification(identifier);
-}
\ No newline at end of file
diff --git a/gui/main.go b/gui/main.go
deleted file mode 100644
index 38019633..00000000
--- a/gui/main.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-
-	"github.com/autobrr/upbrr/internal/guiapp"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	version         = "dev"
-	buildIdentifier = ""
-)
-
-func main() {
-	api.SetApplicationBuild(version, buildIdentifier)
-
-	configPath := flag.String("config", "", "Path to config file")
-	flag.Parse()
-
-	configFlagProvided := false
-	flag.CommandLine.Visit(func(f *flag.Flag) {
-		if f.Name == "config" {
-			configFlagProvided = true
-		}
-	})
-
-	if err := guiapp.Run(guiapp.RunOptions{
-		Assets:         nil,
-		ConfigPath:     *configPath,
-		ConfigProvided: configFlagProvided,
-	}); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %s\n", logging.SanitizeMessage(err.Error()))
-		os.Exit(1)
-	}
-}
diff --git a/gui/wails.json b/gui/wails.json
deleted file mode 100644
index 6fe540df..00000000
--- a/gui/wails.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "name": "upbrr-gui",
-  "outputfilename": "upbrr-gui",
-  "frontend:install": "pnpm install",
-  "frontend:build": "pnpm run build",
-  "frontend:dev:watcher": "pnpm run dev",
-  "frontend:dev:serverUrl": "http://localhost:5173",
-  "frontend:dev:serverPort": 5173,
-  "build": {
-    "frontend": "frontend",
-    "output": "build"
-  },
-  "author": {
-    "name": "Audionut"
-  },
-  "info": {
-    "companyName": "Audionut",
-    "productName": "upbrr"
-  }
-}
diff --git a/internal/AGENTS.md b/internal/AGENTS.md
index cb7946d9..fa7218d7 100644
--- a/internal/AGENTS.md
+++ b/internal/AGENTS.md
@@ -7,7 +7,7 @@ Scoped rules for backend Go under `internal/`. Root repo rules still apply.
 - Go lint config: `.golangci.yml`
 - Hook wiring: `lefthook.yml`
 - Make targets: `Makefile`
-- API/runtime contracts: `pkg/api`, `cmd/upbrr`, `internal/guiapp`, `internal/webserver`, `gui/frontend`
+- API/runtime contracts: `pkg/api`, `cmd/upbrr`, `internal/webserver`, `webui`
 
 Tool output and config win over prose.
 
@@ -21,7 +21,7 @@ make logpolicy
 make pathpolicy
 make gofix-check-changed
 go test -race -v -timeout 20m ./cmd/upbrr ./internal/core ./pkg/api
-go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/guishared ./pkg/api
+go test -race -v -timeout 20m ./internal/webserver/... ./pkg/api
 ```
 
 ## Check Selection
@@ -29,7 +29,7 @@ go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/
 - Touched Go package: `go test -race -v -timeout 20m <package>`.
 - CLI behavior/flags/prompts: `go test -race -v -timeout 20m ./cmd/upbrr ./internal/core ./pkg/api` plus touched services/trackers, then `make backend`.
 - Core upload flow, tracker orchestration, config, DB, or API contracts: run focused package tests, then add `make test-go` when shared behavior can regress broadly.
-- Wails/web/embedded API parity: `go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/guishared ./pkg/api`; add frontend `typecheck`/unit checks for request/response or bridge changes.
+- WebUI/API contracts: `go test -race -v -timeout 20m ./internal/webserver/... ./pkg/api`; add frontend `typecheck`/unit checks for request/response or browser-client changes.
 - Tracker changes: test the tracker impl package and touched shared tracker packages; include config/defaults and catalog tests when definitions or auth material change.
 - Logging/internal Go changes: `make logpolicy`.
 - Path handling/local FS changes: `make pathpolicy`; use `make lint` before commit.
@@ -37,22 +37,33 @@ go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/
 
 ## Runtime Flow
 
-1. Entrypoints build request/options from CLI args, Wails method input, or web route payload.
-2. `internal/core` prepares metadata, config, services, repository access, validation, screenshots/images, tracker review, and upload.
-3. Services under `internal/services` handle metadata, torrents, image hosts, dupe checks, screenshots, and tracker orchestration.
-4. Tracker implementations under `internal/trackers/impl` produce tracker-specific payloads and rule handling.
-5. DB/repository layers persist config, history, images, upload records, and status.
+1. Entrypoints build request/options from CLI args or WebUI route payloads.
+2. `internal/preparedrelease` owns immutable source-scoped prepared generations and display projections, using `internal/sourcelayout` and `internal/externalidentity` for source resources and canonical identity.
+3. `internal/core` consumes exact prepared generations and owns workflow orchestration, tracker eligibility, validation, screenshots/images, review, and upload.
+4. `internal/clientdiscovery` owns normalized source-scoped torrent-client search.
+5. `internal/webserver` owns browser transport, retained background jobs, and runtime activation through `RuntimeActivator`.
+6. Generic tracker orchestration under `internal/trackers` consumes typed registry capabilities; auth, dupe, and data coordinators live in dedicated subpackages.
+7. Tracker implementations are grouped by registry family: Unit3D sites under `internal/trackers/impl/unit3d/sites/<tracker>`, AvistaZ-family profiles under `internal/trackers/impl/azfamily`, and all other trackers under `internal/trackers/impl/standalone/<tracker>`. Tracker-local packages own endpoints, payloads, auth, lookup, rules, descriptions, and policy.
+8. DB/repository layers persist config, prepared generations, history, images, upload records, and status.
 
-Preserve behavior across CLI, Wails GUI, and embedded web unless intentionally changing an entrypoint.
+Preserve behavior across CLI and WebUI unless intentionally changing an entrypoint.
 
 ## Config / Runtime Ownership
 
-- Runtime config can change after `SaveConfig` / `applyConfig`.
-- Read Wails/web config/core/logger via `currentConfig()`, `requireRuntime()`, or snapshots.
-- Do not read `App.cfg` / `Backend.cfg` directly outside helpers.
+- Runtime config can change after `SaveConfig` delegates activation to `RuntimeActivator`.
+- Read WebUI config/core/logger via `currentConfig()`, `requireRuntime()`, or snapshots.
+- Do not read `Backend.cfg` directly outside helpers.
 - `Server.cfg` is startup-only.
 - Config schema changes need `internal/config.Config`, embedded defaults, import/export, env overrides where relevant, settings UI/web parity, and secret redaction/encryption review.
 
+## Canonical Release Ownership
+
+- Canonical preparation contracts are single-source and preserve the caller's interaction mode.
+- `PreparedRelease` contains typed, reusable source facts only. Do not retain workflow options, tracker choices, questionnaire answers, overrides, or outcomes in prepared state.
+- Operations consume owner-local inputs plus an exact `ReleaseRef`; workflow interfaces must not accept a broad `PreparedRelease` when a narrower contract suffices.
+- `PreparedReleaseDisplay` and `ProviderDisplay` construction belongs to `internal/preparedrelease`; `TrackerEligibility` construction belongs to `internal/core`.
+- Browser correlation IDs and event timestamps are transport concerns. Inject them under `internal/webserver`, not canonical preparation inputs or facts.
+
 ## Go Rules
 
 - Match repo style; keep changes narrow; fix root cause; keep tests for changed behavior.
@@ -80,7 +91,7 @@ Preserve behavior across CLI, Wails GUI, and embedded web unless intentionally c
 - Slash-data such as torrent paths, URLs, and API payload paths use `path` only with import-local `//nolint:depguard // <reason>`.
 - Slash-data -> local FS: validate slash path, then `filepath.FromSlash`.
 - Reject POSIX + Windows escapes on every OS: leading `/`, leading `\`, drive letters, UNC, `..`.
-- Use `internal/pathutil.IsWithinRoot` / `SamePath`; no ad-hoc `filepath.Rel` + prefix guards.
+- Use `internal/pathing.IsWithinRoot` / `SamePath`; no ad-hoc `filepath.Rel` + prefix guards.
 - Tests: `t.TempDir`, `filepath.Join`, `filepath.ToSlash`; no hardcoded OS-rooted literals/raw slash assertions for local FS.
 - `cmd/pathpolicy` flags wrong path APIs, string-built local paths, slash-data FS calls/assertions, and ad-hoc guards. Rare exceptions need `//pathpolicy:allow <reason>` same/previous line.
 
@@ -89,7 +100,7 @@ Preserve behavior across CLI, Wails GUI, and embedded web unless intentionally c
 - Pre-commit hook: Go format, log policy, path policy, frontend Prettier/ESLint on staged files.
 - Pre-push hook: `make lint` and frontend typecheck.
 - Do not rely on `make prepush` before a commit exists. Run relevant underlying checks before commit when the change can affect them.
-- `make lint` runs path policy plus full `golangci-lint run --timeout=5m ./...`.
+- `make lint` runs architecture, path, and literal policies plus full `golangci-lint run --timeout=5m ./...`.
 - Fix checker failures in the smallest relevant scope. Do not weaken checks, remove tests, or add broad `nolint` to hide failures.
 
 ## Generated / Scratch Path Risk
@@ -101,11 +112,14 @@ Preserve behavior across CLI, Wails GUI, and embedded web unless intentionally c
 - After creating generated dirs or broad Go tooling, run `make lint` before commit.
 - Keep generated artifacts out of commits unless the task explicitly updates generated output.
 
-Current expected local/generated ignores: `dist/`, `gui/frontend/dist/`, `gui/build/bin/`, `internal/guiapp/assets/*` except `.keep`, `gui/frontend/playwright-report/`, `gui/frontend/test-results/`, `tmp/`.
+Current expected local/generated ignores: `dist/`, `webui/dist/`, `internal/webserver/assets/*` except `.keep`, `webui/playwright-report/`, `webui/test-results/`, `tmp/`.
 
 ## Domain Guardrails
 
-- Tracker changes often touch `internal/trackers/impl/*`, `internal/trackers/impl/registry.go`, `internal/trackers/catalog.go`, `internal/trackers/unit3dmeta`, `internal/config/defaults/example.yaml`, and policy tests.
+- Standalone tracker behavior belongs in `internal/trackers/impl/standalone/<tracker>`; Unit3D site exceptions belong in `internal/trackers/impl/unit3d/sites/<tracker>`. Each standalone package composes identity and static capabilities in `profile.go`; dynamic data/claim factories may use a small local wrapper around `standalone.Definition`. Register definitions explicitly in `internal/trackers/impl/registry.go`; generic packages must not import individual implementations.
+- `internal/trackers/impl/registry.go` is the only complete supported-tracker composition list and groups definitions by family. Tracker profiles/definitions own endpoints and typed policy; `internal/config/defaults/example.yaml` owns ordered config surfaces/defaults. Generic metadata, auth, image-hosting, torrent-client, and frontend code must consume registry/catalog capabilities without tracker-name dispatch.
+- Upload preparation returns one immutable `trackers.PreparedOperation`: preview and submission must use the same captured canonical state. Submission may defer short-lived remote tokens, but must not rebuild payloads, reread mutable prepared inputs, or rerun image uploads. Dry-run and upload-review never receive a submittable plan.
+- Standard Unit3D additions require the site profile/rules, one Unit3D registry entry, one example-config stanza without `url`, and combined rule cases. Do not infer configured custom trackers; unsupported saved entries stay inert and preserve non-URL unknown fields.
 - DB schema changes use stable, additive, forward-only, idempotent SQLite migrations where practical; preserve `schema_migrations` and the legacy `user_version` bridge.
-- Runtime bridge changes involving `globalThis.go.guiapp.App` need matching Wails `internal/guiapp` methods, web `/api/app/*` routes, browser bridge request shapes, and unit/embedded browser verification.
-- Generated/built outputs are mostly ignored; do not commit populated `internal/guiapp/assets` unless deliberately updating generated artifacts.
+- WebUI client changes need matching `/api/app/*` routes, typed request shapes, and unit/embedded browser verification.
+- Generated/built outputs are mostly ignored; do not commit populated `internal/webserver/assets` unless deliberately updating generated artifacts.
diff --git a/internal/architecturepolicy/policy.go b/internal/architecturepolicy/policy.go
new file mode 100644
index 00000000..35863bcf
--- /dev/null
+++ b/internal/architecturepolicy/policy.go
@@ -0,0 +1,489 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package architecturepolicy enforces lasting ownership boundaries for the
+// canonical runtime and prepared-release architecture.
+package architecturepolicy
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strings"
+)
+
+// Violation is one source location that crosses a protected architecture boundary.
+type Violation struct {
+	File    string
+	Line    int
+	Column  int
+	Message string
+}
+
+var releasePageDirectories = map[string]struct{}{
+	"bluray_candidates":   {},
+	"description_builder": {},
+	"dupe_check":          {},
+	"input":               {},
+	"menu_images":         {},
+	"playlist_selection":  {},
+	"screenshots":         {},
+	"tracker_data":        {},
+	"tracker_upload":      {},
+	"upload_images":       {},
+}
+
+var messageRecoveryPattern = regexp.MustCompile(`(?i)(error|message)[A-Za-z0-9_?.]*(?:\.toLowerCase\(\))?\.(includes|startsWith|match)\(`)
+
+var frontendBDMVPathPattern = regexp.MustCompile(`(?i)(\$\{[^}]+\}[^\n]*[\\/]BDMV|[+][^\n]*["'\x60][\\/]?BDMV|BDMV[^\n]*\.slice\()`)
+
+var preparationIntentTrackersPattern = regexp.MustCompile(`(?s)export\s+type\s+PreparationIntent\s*=.*?\btrackers\b.*?};`)
+
+var workflowInterfaceMarkers = []string{"Capability", "Module", "Operation", "Runner", "Service", "Workflow"}
+
+var preparedStateFields = map[string]struct{}{
+	"BlockedTrackers":             {},
+	"ClientTorrentPath":           {},
+	"ClientOverrides":             {},
+	"CrossSeedTorrents":           {},
+	"DescriptionOverride":         {},
+	"DescriptionGroups":           {},
+	"ImageHostOverrides":          {},
+	"IgnoreDupesFor":              {},
+	"Mode":                        {},
+	"Options":                     {},
+	"QuestionnaireAnswers":        {},
+	"RuleAuthorizations":          {},
+	"ScreenshotOverrides":         {},
+	"TorrentOverrides":            {},
+	"TorrentPath":                 {},
+	"TrackerConfigOverrides":      {},
+	"TrackerQuestionnaireAnswers": {},
+	"TrackerRuleFailures":         {},
+	"Trackers":                    {},
+	"TrackersRemove":              {},
+	"TrackerSiteOverrides":        {},
+}
+
+var hostActivationFunctions = map[string]struct{}{
+	"applyConfig":            {},
+	"buildAndInstallRuntime": {},
+	"saveAndApplyConfig":     {},
+}
+
+// CheckRepository scans architecture-sensitive source without following generated,
+// dependency, build-output, or VCS directories. It returns violations sorted by
+// file, line, then column.
+func CheckRepository(root string) ([]Violation, error) {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		return nil, fmt.Errorf("resolve repository root: %w", err)
+	}
+	var violations []Violation
+	err = filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			if path != root && ignoredDirectory(entry.Name()) {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		relative, err := filepath.Rel(root, path)
+		if err != nil {
+			return fmt.Errorf("architecture policy: resolve relative path %q: %w", path, err)
+		}
+		relative = filepath.ToSlash(relative)
+		var found []Violation
+		switch filepath.Ext(path) {
+		case ".go":
+			if strings.HasSuffix(path, ".generated.go") {
+				return nil
+			}
+			found, err = checkGoFile(path, relative)
+		case ".ts", ".tsx":
+			found, err = checkFrontendFile(path, relative)
+		default:
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		violations = append(violations, found...)
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("scan repository: %w", err)
+	}
+	slices.SortFunc(violations, func(left, right Violation) int {
+		if result := strings.Compare(left.File, right.File); result != 0 {
+			return result
+		}
+		if left.Line != right.Line {
+			return left.Line - right.Line
+		}
+		return left.Column - right.Column
+	})
+	return violations, nil
+}
+
+func ignoredDirectory(name string) bool {
+	switch name {
+	case ".git", ".gocache", "dist", "node_modules", "tmp", "vendor":
+		return true
+	default:
+		return false
+	}
+}
+
+// checkGoFile enforces ownership boundaries that require Go syntax and type-name inspection.
+func checkGoFile(path string, relative string) ([]Violation, error) {
+	files := token.NewFileSet()
+	parsed, err := parser.ParseFile(files, path, nil, 0)
+	if err != nil {
+		return nil, fmt.Errorf("parse %s: %w", relative, err)
+	}
+	var violations []Violation
+	add := func(position token.Pos, message string) {
+		location := files.Position(position)
+		violations = append(violations, Violation{
+			File:    relative,
+			Line:    location.Line,
+			Column:  location.Column,
+			Message: message,
+		})
+	}
+	ast.Inspect(parsed, func(node ast.Node) bool {
+		if strings.HasSuffix(relative, "_test.go") {
+			return true
+		}
+		if call, ok := node.(*ast.CallExpr); ok {
+			if selector, ok := call.Fun.(*ast.SelectorExpr); ok && selector.Sel.Name == "SearchPathedTorrents" &&
+				!strings.HasPrefix(relative, "internal/clientdiscovery/") {
+				add(selector.Sel.Pos(), "production torrent-client search belongs to internal/clientdiscovery")
+			}
+		}
+		if selector, ok := node.(*ast.SelectorExpr); ok && strings.HasPrefix(relative, "internal/preparedrelease/") &&
+			selectedTypeName(selector.X) == "api" && selector.Sel.Name == "InteractionModeUnattended" {
+			add(selector.Pos(), "canonical preparation must preserve caller interaction mode")
+		}
+		literal, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return true
+		}
+		typeName := selectedTypeName(literal.Type)
+		switch {
+		case strings.HasPrefix(relative, "internal/preparedrelease/") && typeName == "Request" && selectedPackageName(literal.Type) == "api":
+			add(literal.Pos(), "canonical preparation cannot reconstruct broad api.Request values")
+		case (typeName == "PreparedReleaseDisplay" || typeName == "ProviderDisplay") &&
+			!strings.HasPrefix(relative, "internal/preparedrelease/"):
+			add(literal.Pos(), "prepared-release display construction belongs to internal/preparedrelease")
+		case typeName == "TrackerEligibility" &&
+			!strings.HasPrefix(relative, "internal/core/") &&
+			!strings.HasPrefix(relative, "pkg/api/"):
+			add(literal.Pos(), "tracker eligibility construction belongs to internal/core")
+		}
+		return true
+	})
+
+	for _, declaration := range parsed.Decls {
+		switch typed := declaration.(type) {
+		case *ast.FuncDecl:
+			if outsideRuntimeOwner(relative) {
+				if _, forbidden := hostActivationFunctions[typed.Name.Name]; forbidden {
+					add(typed.Name.Pos(), "runtime activation sequencing belongs to webserver.RuntimeActivator")
+				}
+			}
+		case *ast.GenDecl:
+			for _, specification := range typed.Specs {
+				typeSpec, ok := specification.(*ast.TypeSpec)
+				if !ok {
+					continue
+				}
+				if interfaceType, ok := typeSpec.Type.(*ast.InterfaceType); ok && workflowInterface(typeSpec.Name.Name) {
+					checkWorkflowInterface(interfaceType, add)
+				}
+				if relative == "pkg/api/prepared_release.go" {
+					checkCanonicalMaps(typeSpec.Type, add)
+					if typeSpec.Name.Name == "NamingFacts" {
+						checkCanonicalNamingFacts(typeSpec.Type, add)
+					}
+				}
+				if strings.HasPrefix(relative, "pkg/api/") {
+					checkSingleSourceContract(typeSpec.Name.Name, typeSpec.Type, add)
+				}
+				if strings.HasPrefix(relative, "internal/preparedrelease/") && (typeSpec.Name.Name == "Seed" || typeSpec.Name.Name == "envelope") {
+					checkPreparedState(typeSpec.Type, add)
+				}
+				if relative == "internal/preparedrelease/state/state.go" && typeSpec.Name.Name == "State" {
+					checkPreparedState(typeSpec.Type, add)
+				}
+			}
+		}
+	}
+	return violations, nil
+}
+
+// selectedPackageName returns the qualifier from a direct package selector expression.
+func selectedPackageName(value ast.Expr) string {
+	selector, ok := value.(*ast.SelectorExpr)
+	if !ok {
+		return ""
+	}
+	identifier, ok := selector.X.(*ast.Ident)
+	if !ok {
+		return ""
+	}
+	return identifier.Name
+}
+
+func selectedTypeName(value ast.Expr) string {
+	switch typed := value.(type) {
+	case *ast.Ident:
+		return typed.Name
+	case *ast.SelectorExpr:
+		return typed.Sel.Name
+	default:
+		return ""
+	}
+}
+
+// checkSingleSourceContract rejects fields that would let canonical operation
+// contracts represent multiple sources or carry presentation correlation.
+func checkSingleSourceContract(typeName string, value ast.Expr, add func(token.Pos, string)) {
+	var forbidden map[string]struct{}
+	switch typeName {
+	case "Request":
+		forbidden = map[string]struct{}{
+			"Paths":                    {},
+			"Mode":                     {},
+			"ExternalIDSelections":     {},
+			"PlaylistSelections":       {},
+			"PlaylistSelectionsUseAll": {},
+		}
+	case "PrepareInput":
+		forbidden = map[string]struct{}{"AdditionalPaths": {}, "CorrelationID": {}}
+	default:
+		return
+	}
+	structure, ok := value.(*ast.StructType)
+	if !ok {
+		return
+	}
+	for _, field := range structure.Fields.List {
+		for _, name := range field.Names {
+			if _, found := forbidden[name.Name]; found {
+				if name.Name == "CorrelationID" {
+					add(name.Pos(), "canonical preparation input cannot contain operation presentation correlation")
+					continue
+				}
+				add(name.Pos(), "canonical release operation contracts are single-source: "+typeName+"."+name.Name)
+			}
+		}
+	}
+}
+
+// checkFrontendFile enforces release-session ownership and rejects invalid
+// progress, Job, mutation, and BDMV path-derivation patterns.
+func checkFrontendFile(path string, relative string) ([]Violation, error) {
+	if !strings.HasPrefix(relative, "webui/src/") || strings.HasSuffix(relative, ".d.ts") {
+		return nil, nil
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read %s: %w", relative, err)
+	}
+	text := string(content)
+	var violations []Violation
+	add := func(offset int, message string) {
+		line, column := textPosition(text, offset)
+		violations = append(violations, Violation{
+			File:    relative,
+			Line:    line,
+			Column:  column,
+			Message: message,
+		})
+	}
+	if isReleasePage(relative) {
+		for offset, line := range sourceLines(text) {
+			if strings.Contains(line, " from ") && strings.Contains(line, "/api/") {
+				add(offset, "release pages must use a release-session facet, not production API clients")
+			}
+		}
+	}
+	if relative == "webui/src/releaseSession/types.ts" {
+		for _, marker := range []string{"Dispatch<", "SetStateAction", "MutableRefObject", "RefObject", "dispatch:"} {
+			if offset := strings.Index(text, marker); offset >= 0 {
+				add(offset, "release-session facets cannot expose React mutation primitives: "+marker)
+			}
+		}
+		if match := preparationIntentTrackersPattern.FindStringIndex(text); match != nil {
+			add(match[0], "frontend PreparationIntent cannot contain workflow tracker selection")
+		}
+	}
+	if !strings.HasPrefix(relative, "webui/src/releaseSession/") {
+		if offset := strings.Index(text, "preparation:progress"); offset >= 0 {
+			add(offset, "preparation progress subscription belongs to webui/src/releaseSession")
+		}
+	}
+	if !strings.HasPrefix(relative, "webui/src/jobRegistry/") && relative != "webui/src/api/app.ts" {
+		for _, marker := range []string{"jobsClient", "jobs:update"} {
+			if offset := strings.Index(text, marker); offset >= 0 {
+				add(offset, "duplicate/upload Job coordination belongs to webui/src/jobRegistry")
+			}
+		}
+	}
+	if !strings.HasPrefix(relative, "webui/src/releaseSession/") && !strings.HasPrefix(relative, "webui/src/jobRegistry/") {
+		if offset := strings.Index(text, "useReleaseJobs"); offset >= 0 {
+			add(offset, "active release Job access belongs behind useReleaseSession")
+		}
+	}
+	if strings.HasPrefix(relative, "webui/src/releaseSession/") ||
+		strings.HasPrefix(relative, "webui/src/jobRegistry/") ||
+		strings.HasPrefix(relative, "webui/src/api/") {
+		for offset, line := range sourceLines(text) {
+			if match := messageRecoveryPattern.FindStringIndex(line); match != nil {
+				add(offset+match[0], "operation recovery cannot be inferred from error-message substrings")
+			}
+		}
+	}
+	for offset, line := range sourceLines(text) {
+		if match := frontendBDMVPathPattern.FindStringIndex(line); match != nil {
+			add(offset+match[0], "frontend cannot derive BDMV resource paths from preparation sources")
+		}
+	}
+	return violations, nil
+}
+
+func isReleasePage(relative string) bool {
+	const prefix = "webui/src/pages/"
+	if !strings.HasPrefix(relative, prefix) {
+		return false
+	}
+	remainder := strings.TrimPrefix(relative, prefix)
+	directory, _, _ := strings.Cut(remainder, "/")
+	_, found := releasePageDirectories[directory]
+	return found
+}
+
+func sourceLines(value string) map[int]string {
+	lines := make(map[int]string)
+	offset := 0
+	for line := range strings.SplitSeq(value, "\n") {
+		lines[offset] = line
+		offset += len(line) + 1
+	}
+	return lines
+}
+
+func textPosition(value string, offset int) (int, int) {
+	line, column := 1, 1
+	for index := 0; index < offset && index < len(value); index++ {
+		if value[index] == '\n' {
+			line++
+			column = 1
+		} else {
+			column++
+		}
+	}
+	return line, column
+}
+
+func checkCanonicalNamingFacts(value ast.Expr, add func(token.Pos, string)) {
+	structure, ok := value.(*ast.StructType)
+	if !ok {
+		return
+	}
+	for _, field := range structure.Fields.List {
+		for _, name := range field.Names {
+			if name.Name == "Category" {
+				add(name.Pos(), "canonical top-level category belongs only to ExternalIdentity")
+			}
+		}
+	}
+}
+
+func workflowInterface(name string) bool {
+	for _, marker := range workflowInterfaceMarkers {
+		if strings.Contains(name, marker) {
+			return true
+		}
+	}
+	return false
+}
+
+func checkWorkflowInterface(value *ast.InterfaceType, add func(token.Pos, string)) {
+	for _, field := range value.Methods.List {
+		function, ok := field.Type.(*ast.FuncType)
+		if !ok || function.Params == nil {
+			continue
+		}
+		for _, parameter := range function.Params.List {
+			if typeNamesPreparedRelease(parameter.Type) {
+				add(parameter.Pos(), "workflow interfaces must accept owner-local inputs, not PreparedRelease")
+			}
+		}
+	}
+}
+
+func typeNamesPreparedRelease(value ast.Expr) bool {
+	switch typed := value.(type) {
+	case *ast.Ident:
+		return typed.Name == "PreparedRelease"
+	case *ast.SelectorExpr:
+		return typed.Sel.Name == "PreparedRelease"
+	case *ast.ArrayType:
+		return typeNamesPreparedRelease(typed.Elt)
+	case *ast.StarExpr:
+		return typeNamesPreparedRelease(typed.X)
+	default:
+		return false
+	}
+}
+
+func checkCanonicalMaps(value ast.Expr, add func(token.Pos, string)) {
+	ast.Inspect(value, func(node ast.Node) bool {
+		mapping, ok := node.(*ast.MapType)
+		if !ok {
+			return true
+		}
+		key, keyOK := mapping.Key.(*ast.Ident)
+		if keyOK && key.Name == "string" && isAny(mapping.Value) {
+			add(mapping.Pos(), "canonical prepared facts cannot use map[string]any")
+		}
+		return true
+	})
+}
+
+func isAny(value ast.Expr) bool {
+	if identifier, ok := value.(*ast.Ident); ok {
+		return identifier.Name == "any"
+	}
+	interfaceType, ok := value.(*ast.InterfaceType)
+	return ok && (interfaceType.Methods == nil || len(interfaceType.Methods.List) == 0)
+}
+
+func checkPreparedState(value ast.Expr, add func(token.Pos, string)) {
+	structure, ok := value.(*ast.StructType)
+	if !ok {
+		return
+	}
+	for _, field := range structure.Fields.List {
+		for _, name := range field.Names {
+			if _, forbidden := preparedStateFields[name.Name]; forbidden {
+				add(name.Pos(), "prepared release collection and transfer state cannot retain workflow state: "+name.Name)
+			}
+		}
+	}
+}
+
+func outsideRuntimeOwner(relative string) bool {
+	return !strings.HasPrefix(relative, "internal/webserver/")
+}
diff --git a/internal/architecturepolicy/policy_test.go b/internal/architecturepolicy/policy_test.go
new file mode 100644
index 00000000..c4c3cfe1
--- /dev/null
+++ b/internal/architecturepolicy/policy_test.go
@@ -0,0 +1,307 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package architecturepolicy
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCheckRepositoryAcceptsCanonicalRepository(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "canonical.go")
+	if err := os.WriteFile(path, []byte("package sample\ntype ExternalIdentity struct{}\n"), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func TestCheckRepositoryRejectsCategoryAliasInNamingFacts(t *testing.T) {
+	root := t.TempDir()
+	directory := filepath.Join(root, "pkg", "api")
+	if err := os.MkdirAll(directory, 0o700); err != nil {
+		t.Fatalf("create fixture directory: %v", err)
+	}
+	path := filepath.Join(directory, "prepared_release.go")
+	if err := os.WriteFile(path, []byte("package api\ntype NamingFacts struct { Category string }\n"), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 1 || !strings.Contains(violations[0].Message, "ExternalIdentity") {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func TestCheckRepositoryRejectsWorkflowStateInPreparationState(t *testing.T) {
+	root := t.TempDir()
+	directory := filepath.Join(root, "internal", "preparedrelease", "state")
+	if err := os.MkdirAll(directory, 0o700); err != nil {
+		t.Fatalf("create fixture directory: %v", err)
+	}
+	path := filepath.Join(directory, "state.go")
+	if err := os.WriteFile(path, []byte("package state\ntype State struct { Trackers []string }\n"), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 1 || !strings.Contains(violations[0].Message, "Trackers") {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func TestCheckRepositoryRejectsPreparedReleaseWorkflowInput(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "workflow.go")
+	fixture := "package sample\ntype UploadService interface { Run(PreparedRelease) error }\ntype PreparedRelease struct{}\n"
+	if err := os.WriteFile(path, []byte(fixture), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 1 || !strings.Contains(violations[0].Message, "owner-local inputs") {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func TestCheckRepositoryRejectsMultiSourceRequestField(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "pkg/api/core.go", "package api\ntype Request struct { Paths []string }\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "single-source")
+}
+
+func TestCheckRepositoryRejectsCorrelationInCanonicalPreparationInput(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "pkg/api/prepare.go", "package api\ntype PrepareInput struct { CorrelationID string }\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "operation presentation correlation")
+}
+
+func TestCheckRepositoryRejectsDisplayConstructionOutsidePreparedRelease(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "internal/core/display.go", "package core\nvar value = api.ProviderDisplay{}\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "display construction")
+}
+
+func TestCheckRepositoryRejectsEligibilityConstructionOutsideCore(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "internal/webserver/eligibility.go", "package webserver\nvar value = api.TrackerEligibility{}\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "eligibility construction")
+}
+
+func TestCheckRepositoryRejectsBroadRequestReconstructionInPreparedRelease(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"internal/preparedrelease/collector.go",
+		"package preparedrelease\nvar request = api.Request{}\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "broad api.Request")
+}
+
+func TestCheckRepositoryRejectsForcedUnattendedPreparation(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"internal/preparedrelease/collector.go",
+		"package preparedrelease\nvar mode = api.InteractionModeUnattended\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "caller interaction mode")
+}
+
+func TestCheckRepositoryRejectsDirectProductionClientSearch(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"internal/core/dupe.go",
+		"package core\nfunc search(client Client) { client.SearchPathedTorrents(nil, nil) }\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "internal/clientdiscovery")
+}
+
+func TestCheckRepositoryAcceptsOwnedClientSearch(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"internal/clientdiscovery/discovery.go",
+		"package clientdiscovery\nfunc search(client Client) { client.SearchPathedTorrents(nil, nil) }\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func TestCheckRepositoryRejectsFrontendBDMVPathDerivation(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"webui/src/releaseSession/layout.ts",
+		"const bdmv = `${sourcePath}/BDMV`;\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "derive BDMV resource paths")
+}
+
+func TestCheckRepositoryRejectsReleasePageProductionClientImport(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/pages/input/index.tsx", "import { preparationClient } from \"../../api/app\";\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "release-session facet")
+}
+
+func TestCheckRepositoryRejectsRawReleaseSessionMutationSurface(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/releaseSession/types.ts", "export type Facet = { update: Dispatch<string> };\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "React mutation primitives")
+}
+
+func TestCheckRepositoryRejectsPreparationProgressOutsideReleaseSession(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/app.tsx", "const event = \"preparation:progress\";\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "preparation progress subscription")
+}
+
+func TestCheckRepositoryRejectsTrackersInFrontendPreparationIntent(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(
+		t,
+		root,
+		"webui/src/releaseSession/types.ts",
+		"export type PreparationIntent = { sourcePath: string; trackers: readonly string[]; };\n",
+	)
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "cannot contain workflow tracker selection")
+}
+
+func TestCheckRepositoryRejectsJobCoordinationOutsideRegistry(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/releaseSession/jobs.ts", "const jobs = jobsClient.list();\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "Job coordination")
+}
+
+func TestCheckRepositoryRejectsMessageSubstringRecovery(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/releaseSession/errors.ts", "if (error.message.includes(\"stale\")) recover();\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "error-message substrings")
+}
+
+func TestCheckRepositoryRejectsReleaseJobHookOutsideSession(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/pages/input/jobs.ts", "const jobs = useReleaseJobs(release);\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	assertViolationContains(t, violations, "behind useReleaseSession")
+}
+
+func TestCheckRepositoryAcceptsOwnedFrontendBoundaries(t *testing.T) {
+	root := t.TempDir()
+	writePolicyFixture(t, root, "webui/src/jobRegistry/coordinator.ts", "const jobs = jobsClient.list();\nconst event = \"jobs:update\";\n")
+	writePolicyFixture(t, root, "webui/src/releaseSession/jobs.ts", "const jobs = useReleaseJobs(release);\n")
+	writePolicyFixture(t, root, "webui/src/pages/history/index.tsx", "import { historyClient } from \"../../api/app\";\n")
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check repository: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("violations = %#v", violations)
+	}
+}
+
+func writePolicyFixture(t *testing.T, root string, relative string, content string) {
+	t.Helper()
+	path := filepath.Join(root, filepath.FromSlash(relative))
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		t.Fatalf("create fixture directory: %v", err)
+	}
+	if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+}
+
+func assertViolationContains(t *testing.T, violations []Violation, message string) {
+	t.Helper()
+	for _, violation := range violations {
+		if strings.Contains(violation.Message, message) {
+			return
+		}
+	}
+	t.Fatalf("violations = %#v, want message containing %q", violations, message)
+}
diff --git a/internal/authmaterial/material.go b/internal/authmaterial/material.go
index 060b1694..f01e78f2 100644
--- a/internal/authmaterial/material.go
+++ b/internal/authmaterial/material.go
@@ -24,8 +24,12 @@ const (
 	WebAuthFileName = "web-auth.json"
 )
 
+// ErrUnavailable classifies missing, unusable, or insecurely permissioned web
+// auth material. Callers should test it with [errors.Is].
 var ErrUnavailable = errors.New("web auth material unavailable")
 
+// Material contains the web-auth values used to derive stable or legacy
+// encryption helpers. It does not contain the plaintext password.
 type Material struct {
 	Username               string `json:"username"`
 	PasswordHash           string `json:"password_hash"`
@@ -33,6 +37,8 @@ type Material struct {
 	AllowUnencryptedExport bool   `json:"allow_unencrypted_export,omitempty"`
 }
 
+// LoadFromDBPath loads usable auth material from web-auth.json beside dbPath.
+// Missing or incomplete material returns [ErrUnavailable].
 func LoadFromDBPath(dbPath string) (Material, error) {
 	record, err := LoadRecordFromDBPath(dbPath)
 	if err != nil {
@@ -46,6 +52,9 @@ func LoadFromDBPath(dbPath string) (Material, error) {
 	return material, nil
 }
 
+// LoadRecordFromDBPath loads the complete auth record from web-auth.json beside
+// dbPath. On non-Windows systems, only modes 0400, 0440, 0600, and 0640 are
+// accepted; unavailable or unusable records return [ErrUnavailable].
 func LoadRecordFromDBPath(dbPath string) (Record, error) {
 	dbPath = strings.TrimSpace(dbPath)
 	if dbPath == "" {
@@ -100,15 +109,19 @@ func validateWebAuthPermissions(authPath string, info os.FileInfo) error {
 	return fmt.Errorf("web auth file %q has insecure permissions %#o: %w", authPath, perm, ErrUnavailable)
 }
 
+// IsUsable reports whether both the username and password hash are non-blank.
 func (m Material) IsUsable() bool {
 	return strings.TrimSpace(m.Username) != "" && strings.TrimSpace(m.PasswordHash) != ""
 }
 
+// WithSeed returns a copy with a trimmed encryption-key seed.
 func (m Material) WithSeed(seed string) Material {
 	m.EncryptionKeySeed = strings.TrimSpace(seed)
 	return m
 }
 
+// PrimaryHelper returns the stable username-and-seed helper when available,
+// otherwise the legacy username-and-password-hash helper.
 func (m Material) PrimaryHelper() (string, string, error) {
 	if helper, fingerprint, ok := m.StableHelper(); ok {
 		return helper, fingerprint, nil
@@ -116,6 +129,8 @@ func (m Material) PrimaryHelper() (string, string, error) {
 	return m.LegacyHelper()
 }
 
+// StableHelper derives the preferred helper and its SHA-256 fingerprint. The
+// boolean is false when username or encryption-key seed is blank.
 func (m Material) StableHelper() (string, string, bool) {
 	username := strings.TrimSpace(m.Username)
 	seed := strings.TrimSpace(m.EncryptionKeySeed)
@@ -126,6 +141,8 @@ func (m Material) StableHelper() (string, string, bool) {
 	return helper, fingerprint(helper), true
 }
 
+// LegacyHelper derives the compatibility helper and its SHA-256 fingerprint
+// from username and password hash. Missing inputs return [ErrUnavailable].
 func (m Material) LegacyHelper() (string, string, error) {
 	username := strings.TrimSpace(m.Username)
 	passwordHash := strings.TrimSpace(m.PasswordHash)
@@ -136,6 +153,8 @@ func (m Material) LegacyHelper() (string, string, error) {
 	return helper, fingerprint(helper), nil
 }
 
+// GenerateSeed returns 32 cryptographically random bytes encoded as unpadded
+// URL-safe base64.
 func GenerateSeed() (string, error) {
 	buf := make([]byte, 32)
 	if _, err := rand.Read(buf); err != nil {
diff --git a/internal/authmaterial/store.go b/internal/authmaterial/store.go
index 78a29b58..4b6f5110 100644
--- a/internal/authmaterial/store.go
+++ b/internal/authmaterial/store.go
@@ -39,6 +39,8 @@ const (
 	legacyAuthArgon2KeyLen      = 32
 )
 
+// Record is the persisted web-auth state. PendingUpgrade makes auth-dependent
+// data rewrap resumable without replacing the active credentials early.
 type Record struct {
 	Username                string          `json:"username"`
 	PasswordHash            string          `json:"password_hash"`
@@ -50,6 +52,8 @@ type Record struct {
 	CreatedAt               time.Time       `json:"created_at"`
 }
 
+// PendingUpgrade stores the target auth record and the last completed rewrap
+// stage while the active record remains unchanged.
 type PendingUpgrade struct {
 	Stage     string    `json:"stage"`
 	Target    Record    `json:"target"`
@@ -62,11 +66,15 @@ const (
 	UpgradeStageDataRewrapped    = "data_rewrapped"
 )
 
+// Store serializes operations performed through one web-auth file handle.
+// Writes use a same-directory temporary file, sync it, set mode 0600, then
+// rename it over the active record.
 type Store struct {
 	path string
 	mu   sync.Mutex
 }
 
+// NewStore targets web-auth.json beside dbPath and creates its parent directory.
 func NewStore(dbPath string) (*Store, error) {
 	dir := filepath.Dir(strings.TrimSpace(dbPath))
 	if err := os.MkdirAll(dir, 0o755); err != nil {
@@ -75,10 +83,14 @@ func NewStore(dbPath string) (*Store, error) {
 	return &Store{path: filepath.Join(dir, WebAuthFileName)}, nil
 }
 
+// AuthFilePath returns the web-auth.json path beside dbPath without touching
+// the filesystem.
 func AuthFilePath(dbPath string) string {
 	return filepath.Join(filepath.Dir(strings.TrimSpace(dbPath)), WebAuthFileName)
 }
 
+// BootstrapAuthFile creates the initial auth record and refuses to overwrite
+// an existing record.
 func BootstrapAuthFile(dbPath string, username string, password string) error {
 	store, err := NewStore(dbPath)
 	if err != nil {
@@ -87,6 +99,7 @@ func BootstrapAuthFile(dbPath string, username string, password string) error {
 	return store.Bootstrap(username, password)
 }
 
+// Exists reports whether the store's auth file currently exists.
 func (s *Store) Exists() (bool, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -101,6 +114,8 @@ func (s *Store) Exists() (bool, error) {
 	return false, fmt.Errorf("web auth: stat auth file: %w", err)
 }
 
+// Load reads the persisted record without applying the stricter usability and
+// permission checks performed by [LoadRecordFromDBPath].
 func (s *Store) Load() (Record, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -116,6 +131,8 @@ func (s *Store) Load() (Record, error) {
 	return record, nil
 }
 
+// Bootstrap hashes the password, generates a stable encryption seed, and
+// creates a new record. It refuses to replace an existing auth file.
 func (s *Store) Bootstrap(username string, password string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -142,6 +159,8 @@ func (s *Store) Bootstrap(username string, password string) error {
 	return s.saveLocked(record)
 }
 
+// UpdatePasswordHash replaces only the hash when username matches the active
+// record.
 func (s *Store) UpdatePasswordHash(username string, passwordHash string) error {
 	return s.updateRecordLocked(func(record *Record) error {
 		if record.Username != strings.TrimSpace(username) {
@@ -152,6 +171,8 @@ func (s *Store) UpdatePasswordHash(username string, passwordHash string) error {
 	})
 }
 
+// UpdateRecord replaces mutable auth, export, browse, and upgrade fields while
+// preserving the active username and creation time.
 func (s *Store) UpdateRecord(updated Record) error {
 	return s.updateRecordLocked(func(record *Record) error {
 		if record.Username != strings.TrimSpace(updated.Username) {
@@ -168,6 +189,8 @@ func (s *Store) UpdateRecord(updated Record) error {
 	})
 }
 
+// BeginPendingUpgrade records target at the prepared stage only if current
+// still matches the active auth and browse settings.
 func (s *Store) BeginPendingUpgrade(current Record, target Record) error {
 	return s.updateRecordLocked(func(record *Record) error {
 		if record.Username != strings.TrimSpace(current.Username) {
@@ -191,6 +214,8 @@ func (s *Store) BeginPendingUpgrade(current Record, target Record) error {
 	})
 }
 
+// AdvancePendingUpgrade sets any recognized upgrade stage. It validates the
+// stage name but does not enforce forward-only transitions.
 func (s *Store) AdvancePendingUpgrade(username string, stage string) error {
 	stage = strings.TrimSpace(stage)
 	switch stage {
@@ -212,6 +237,8 @@ func (s *Store) AdvancePendingUpgrade(username string, stage string) error {
 	})
 }
 
+// FinalizePendingUpgrade replaces the active record with its pending target,
+// clears pending state, and preserves the original creation time.
 func (s *Store) FinalizePendingUpgrade(username string) (Record, error) {
 	var finalized Record
 
@@ -234,6 +261,8 @@ func (s *Store) FinalizePendingUpgrade(username string) (Record, error) {
 	return finalized, err
 }
 
+// ClearPendingUpgrade removes pending upgrade state without changing active
+// auth or browse settings.
 func (s *Store) ClearPendingUpgrade(username string) error {
 	return s.updateRecordLocked(func(record *Record) error {
 		if record.Username != strings.TrimSpace(username) {
@@ -264,6 +293,7 @@ func (s *Store) updateRecordLocked(apply func(record *Record) error) error {
 	return s.saveLocked(record)
 }
 
+// AuthMaterial returns a trimmed projection of the record's helper inputs.
 func (r Record) AuthMaterial() Material {
 	return Material{
 		Username:               strings.TrimSpace(r.Username),
@@ -311,6 +341,8 @@ func (s *Store) saveLocked(record Record) error {
 	return nil
 }
 
+// HashPassword validates the minimum length and returns an Argon2id encoded
+// hash with a new random salt.
 func HashPassword(password string) (string, error) {
 	password = strings.TrimSpace(password)
 	if len(password) < AuthPasswordMinLength {
@@ -339,11 +371,14 @@ func HashPassword(password string) (string, error) {
 	), nil
 }
 
+// VerifyPassword reports whether password matches a supported Argon2id encoding.
 func VerifyPassword(password string, encoded string) bool {
 	ok, _ := VerifyPasswordWithUpgrade(password, encoded)
 	return ok
 }
 
+// VerifyPasswordWithUpgrade reports both password validity and whether the
+// matched encoding uses the legacy three-part format.
 func VerifyPasswordWithUpgrade(password string, encoded string) (bool, bool) {
 	parts := strings.Split(encoded, "$")
 	if len(parts) < 3 || parts[0] != "argon2id" {
diff --git a/internal/bbcode/bbcode_test.go b/internal/bbcode/bbcode_test.go
new file mode 100644
index 00000000..c3ac77df
--- /dev/null
+++ b/internal/bbcode/bbcode_test.go
@@ -0,0 +1,325 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bbcode_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/bhd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/hdb"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ptp"
+)
+
+func TestCleanUnit3DDescription(t *testing.T) {
+	desc := "[url=https://blutopia.xyz/torrents/123]Title[/url]\n[img]https://example.com/a.jpg[/img]\n[img]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img]"
+	report := bbcode.CleanUnit3DDescription(desc, "https://blutopia.xyz")
+
+	if report.Description != "Title" {
+		t.Fatalf("expected description text to be preserved, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://example.com/a.jpg" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanUnit3DDescriptionPreservesFetchedTextWithoutScreenshotBlocks(t *testing.T) {
+	desc := "[center]Existing tracker description[/center]\n\n" +
+		"[center][url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url][/center]\n\n" +
+		"[right][url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url][/right]"
+	report := bbcode.CleanUnit3DDescription(desc, "https://example.org")
+
+	if report.Description != "[center]Existing tracker description[/center]\n\n[right][url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url][/right]" {
+		t.Fatalf("expected text body without screenshot block, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+}
+
+func TestCleanUnit3DDescriptionConvertsPixhostThumbRawURL(t *testing.T) {
+	desc := "[url=https://pixhost.to/show/11645/685417513_file-upload-0.png][img]https://t1.pixhost.to/thumbs/11645/685417513_file-upload-0.png[/img][/url]"
+	report := bbcode.CleanUnit3DDescription(desc, "https://example.org")
+
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].RawURL != "https://img1.pixhost.to/images/11645/685417513_file-upload-0.png" {
+		t.Fatalf("unexpected converted raw url %q", report.Images[0].RawURL)
+	}
+}
+
+func TestCleanUnit3DDescriptionRemovesOrphanedTonemapAndEmptyAlign(t *testing.T) {
+	desc := "[center][code] Screenshots have been tonemapped for reference [/code][/center]\n\n[align=center]\n[url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url]\n[/align]"
+	report := bbcode.CleanUnit3DDescription(desc, "https://example.org")
+
+	if report.Description != "" {
+		t.Fatalf("expected orphaned tonemap note to be discarded, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://img.example/a.jpg" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanUnit3DDescriptionKeepsFirstScreenshotSetAfterTMDBPoster(t *testing.T) {
+	desc := "[center][img=300]https://image.tmdb.org/t/p/original/poster.png[/img][/center]\n\n" +
+		"[center]Stranger.Things.S05E01[/center]\n\n" +
+		"[center]" +
+		"[url=https://imgbox.com/A][img=300]https://images2.imgbox.com/aa/aa/A_o.png[/img][/url] " +
+		"[url=https://imgbox.com/B][img=300]https://images2.imgbox.com/bb/bb/B_o.png[/img][/url] " +
+		"[url=https://imgbox.com/C][img=300]https://images2.imgbox.com/cc/cc/C_o.png[/img][/url]" +
+		"[/center]\n\n" +
+		"[center][spoiler=Other files]" +
+		"[url=https://imgbox.com/D][img=300]https://images2.imgbox.com/dd/dd/D_o.png[/img][/url]" +
+		"[/spoiler][/center]"
+
+	report := bbcode.CleanUnit3DDescription(desc, "https://example.org")
+
+	if report.Description != "[center]Stranger.Things.S05E01[/center]" {
+		t.Fatalf("expected non-screenshot text to be preserved, got %q", report.Description)
+	}
+	if len(report.Images) != 3 {
+		t.Fatalf("expected first screenshot set only (3 images), got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://images2.imgbox.com/aa/aa/A_o.png" {
+		t.Fatalf("unexpected first image %q", report.Images[0].ImgURL)
+	}
+	if report.Images[1].ImgURL != "https://images2.imgbox.com/bb/bb/B_o.png" {
+		t.Fatalf("unexpected second image %q", report.Images[1].ImgURL)
+	}
+	if report.Images[2].ImgURL != "https://images2.imgbox.com/cc/cc/C_o.png" {
+		t.Fatalf("unexpected third image %q", report.Images[2].ImgURL)
+	}
+}
+
+func TestCleanHDBDescription(t *testing.T) {
+	desc := "Text\n[url=https://imgbox.com/abc][img]https://thumbs2.imgbox.com/abc_t.png[/img][/url]\nhttps://hdbits.org/x"
+	report := hdb.CleanDescription(desc)
+
+	if report.Description != "Text" {
+		t.Fatalf("expected description to be cleaned, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].RawURL != "https://images2.imgbox.com/abc_o.png" {
+		t.Fatalf("expected raw url conversion, got %q", report.Images[0].RawURL)
+	}
+}
+
+func TestCleanHDBDescriptionRemovesEmptyURLTags(t *testing.T) {
+	desc := "Text\n[url=][/url] [url=][/url] [url=][/url] [url=][/url]"
+	report := hdb.CleanDescription(desc)
+	if report.Description != "Text" {
+		t.Fatalf("expected empty url tags removed, got %q", report.Description)
+	}
+}
+
+func TestCleanBHDDescription(t *testing.T) {
+	desc := "hello\n[url=https://example.com/full/a][img]https://example.com/a.png[/img][/url]\n[img]https://example.com/b.webp[/img]"
+	report := bhd.CleanDescription(desc, bhd.BBCodeOptions{Framestor: true, Flux: true})
+
+	if report.Description != "[code]hello[/code]" {
+		t.Fatalf("expected code block description, got %q", report.Description)
+	}
+	if len(report.Images) != 2 {
+		t.Fatalf("expected 2 images, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://example.com/a.png" || report.Images[0].WebURL != "https://example.com/full/a" {
+		t.Fatalf("unexpected first image %+v", report.Images[0])
+	}
+	if report.Images[1].ImgURL != "https://example.com/b.webp" {
+		t.Fatalf("unexpected second image %+v", report.Images[1])
+	}
+	if len(report.Artifacts) != 1 {
+		t.Fatalf("expected 1 artifact, got %d", len(report.Artifacts))
+	}
+	if report.Artifacts[0].Name != "bhd.nfo" {
+		t.Fatalf("unexpected artifact name %q", report.Artifacts[0].Name)
+	}
+}
+
+func TestCleanBHDDescriptionRemovesOrphanedEmptyAlign(t *testing.T) {
+	desc := "[center][code] Screenshots have been tonemapped for reference [/code][/center]\n\n[align=center]\n[url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url]\n[/align]"
+	report := bhd.CleanDescription(desc, bhd.BBCodeOptions{})
+
+	if report.Description != "" {
+		t.Fatalf("expected empty wrapper bbcode removed, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://img.example/a.jpg" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanBHDDescriptionRemovesKnownBotSignatures(t *testing.T) {
+	desc := strings.Join([]string{
+		"Body",
+		"[center][b]Uploaded Using [url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url] Auto Uploader[/b][/center]",
+		"[center][url=https://github.com/z-ink/uploadrr][img=300]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img][/url][/center]",
+		"[center][url=https://github.com/edge20200/Only-Uploader]Powered by Only-Uploader[/url][/center]",
+		"[center][url=/torrents?perPage=50&name=Example][/url][/center]",
+		"[right]Created by Upload Assistant[/right]",
+	}, "\n")
+	report := bhd.CleanDescription(desc, bhd.BBCodeOptions{})
+
+	if report.Description != "Body" {
+		t.Fatalf("expected bot signatures removed, got %q", report.Description)
+	}
+	if len(report.Images) != 0 {
+		t.Fatalf("expected bot images removed with signatures, got %d", len(report.Images))
+	}
+}
+
+func TestCleanBHDDescriptionKeepsCenteredScreenshotBeforeAitherFooter(t *testing.T) {
+	desc := strings.Join([]string{
+		"Body",
+		"[center][url=https://web.example/1][img=350]https://raw.example/1.png[/img][/url][/center]",
+		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
+	}, "\n\n")
+	report := bhd.CleanDescription(desc, bhd.BBCodeOptions{})
+
+	if report.Description != "Body" {
+		t.Fatalf("expected body preserved and footer stripped, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image retained, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://raw.example/1.png" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanPTPDescriptionRemovesKnownBotSignatures(t *testing.T) {
+	desc := strings.Join([]string{
+		"Body",
+		"[center][b]Uploaded Using [url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url] Auto Uploader[/b][/center]",
+		"[center][url=https://github.com/z-ink/uploadrr][img=300]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img][/url][/center]",
+		"[center][url=https://github.com/edge20200/Only-Uploader]Powered by Only-Uploader[/url][/center]",
+		"[center][url=/torrents?perPage=50&name=Example][/url][/center]",
+		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
+		"[right]Created by Upload Assistant[/right]",
+	}, "\n")
+	report := ptp.CleanDescription(desc, "")
+
+	if report.Description != "Body" {
+		t.Fatalf("expected bot signatures removed, got %q", report.Description)
+	}
+	if len(report.Images) != 0 {
+		t.Fatalf("expected bot images removed with signatures, got %d", len(report.Images))
+	}
+}
+
+func TestCleanPTPDescriptionKeepsCenteredScreenshotBeforeAitherFooter(t *testing.T) {
+	desc := strings.Join([]string{
+		"Body",
+		"[center][img]https://raw.example/1.png[/img][/center]",
+		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
+	}, "\n\n")
+	report := ptp.CleanDescription(desc, "")
+
+	if report.Description != "Body" {
+		t.Fatalf("expected body preserved and footer stripped, got %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image retained, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://raw.example/1.png" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanPTPDescription(t *testing.T) {
+	desc := "&bull; item\n[quote]x[/quote]\nhttps://example.com/test.jpg"
+	report := ptp.CleanDescription(desc, "")
+
+	if report.Description != "- item\n[code]x[/code]" {
+		t.Fatalf("unexpected description %q", report.Description)
+	}
+	if len(report.Images) != 1 {
+		t.Fatalf("expected 1 image, got %d", len(report.Images))
+	}
+	if report.Images[0].ImgURL != "https://example.com/test.jpg" {
+		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
+	}
+}
+
+func TestCleanPTPDescriptionRemovesWidthStyledImageBlocks(t *testing.T) {
+	desc := `[align=center]
+[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
+[/align]`
+	report := ptp.CleanDescription(desc, "")
+
+	if strings.Contains(report.Description, "[url=][img][/img][/url]") {
+		t.Fatalf("expected no orphaned empty image tags, got %q", report.Description)
+	}
+	if strings.TrimSpace(report.Description) != "" {
+		t.Fatalf("expected screenshot-only description to be removed, got %q", report.Description)
+	}
+}
+
+func TestNormalizeImageRawURLConvertsPixhostThumbURL(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "current domain",
+			in:   "https://t1.pixhost.cc/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://img1.pixhost.cc/images/11645/685417513_file-upload-0.png",
+		},
+		{
+			name: "mixed case current domain",
+			in:   "https://T1.PixHost.Cc/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://img1.pixhost.cc/images/11645/685417513_file-upload-0.png",
+		},
+		{
+			name: "legacy domain",
+			in:   "https://t1.pixhost.to/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://img1.pixhost.to/images/11645/685417513_file-upload-0.png",
+		},
+		{
+			name: "exact current host",
+			in:   "https://pixhost.cc/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://pixhost.cc/images/11645/685417513_file-upload-0.png",
+		},
+		{
+			name: "foreign suffix current domain",
+			in:   "https://t1.evilpixhost.cc/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://t1.evilpixhost.cc/thumbs/11645/685417513_file-upload-0.png",
+		},
+		{
+			name: "foreign suffix legacy domain",
+			in:   "https://t1.evilpixhost.to/thumbs/11645/685417513_file-upload-0.png",
+			want: "https://t1.evilpixhost.to/thumbs/11645/685417513_file-upload-0.png",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			value := bbcode.NormalizeImageRawURL(tt.in)
+			if value != tt.want {
+				t.Fatalf("unexpected normalized value %q", value)
+			}
+		})
+	}
+}
+
+func TestIsOnlyBBCode(t *testing.T) {
+	if !bbcode.IsOnlyTags("[b][/b]") {
+		t.Fatal("expected only bbcode to be true")
+	}
+	if bbcode.IsOnlyTags("text [b][/b]") {
+		t.Fatal("expected text to be false")
+	}
+}
diff --git a/internal/bbcode/common.go b/internal/bbcode/common.go
new file mode 100644
index 00000000..4972f8a4
--- /dev/null
+++ b/internal/bbcode/common.go
@@ -0,0 +1,396 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bbcode
+
+import (
+	"html"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var onlyBBCodePattern = regexp.MustCompile(`\[/?[a-zA-Z0-9]+(?:=[^\]]*)?\]`)
+
+func normalizeNewlines(value string) string {
+	value = html.UnescapeString(value)
+	return strings.ReplaceAll(value, "\r\n", "\n")
+}
+
+// NormalizeNewlines decodes HTML entities and normalizes CRLF line endings.
+func NormalizeNewlines(value string) string { return normalizeNewlines(value) }
+
+func isOnlyBBCode(value string) bool {
+	text := onlyBBCodePattern.ReplaceAllString(value, "")
+	return strings.TrimSpace(text) == ""
+}
+
+// IsOnlyTags reports whether value contains no text outside BBCode tags.
+func IsOnlyTags(value string) bool { return isOnlyBBCode(value) }
+
+func removeExtraLines(value string) string {
+	re := regexp.MustCompile(`\n{3,}`)
+	return re.ReplaceAllString(value, "\n\n")
+}
+
+// RemoveExtraLines collapses three or more consecutive newlines.
+func RemoveExtraLines(value string) string { return removeExtraLines(value) }
+
+func convertPreToCode(value string) string {
+	value = strings.ReplaceAll(value, "[pre]", "[code]")
+	value = strings.ReplaceAll(value, "[/pre]", "[/code]")
+	return value
+}
+
+// ConvertPreToCode changes pre tags to code tags.
+func ConvertPreToCode(value string) string { return convertPreToCode(value) }
+
+func convertCodeToPre(value string) string {
+	value = strings.ReplaceAll(value, "[code]", "[pre]")
+	value = strings.ReplaceAll(value, "[/code]", "[/pre]")
+	return value
+}
+
+// ConvertCodeToPre changes code tags to pre tags.
+func ConvertCodeToPre(value string) string { return convertCodeToPre(value) }
+
+func convertHideToSpoiler(value string) string {
+	value = strings.ReplaceAll(value, "[hide", "[spoiler")
+	value = strings.ReplaceAll(value, "[/hide]", "[/spoiler]")
+	return value
+}
+
+// ConvertHideToSpoiler changes hide tags to spoiler tags.
+func ConvertHideToSpoiler(value string) string { return convertHideToSpoiler(value) }
+
+func convertSpoilerToHide(value string) string {
+	value = strings.ReplaceAll(value, "[spoiler", "[hide")
+	value = strings.ReplaceAll(value, "[/spoiler]", "[/hide]")
+	return value
+}
+
+// ConvertSpoilerToHide changes spoiler tags to hide tags.
+func ConvertSpoilerToHide(value string) string { return convertSpoilerToHide(value) }
+
+func removeHide(value string) string {
+	value = strings.ReplaceAll(value, "[hide]", "")
+	value = strings.ReplaceAll(value, "[/hide]", "")
+	return value
+}
+
+// RemoveHide removes hide tags.
+func RemoveHide(value string) string { return removeHide(value) }
+
+func convertNamedSpoilerToNamedHide(value string) string {
+	re := regexp.MustCompile(`(?i)\[spoiler=([^]]+)]`)
+	value = re.ReplaceAllString(value, "[hide=$1]")
+	value = strings.ReplaceAll(value, "[/spoiler]", "[/hide]")
+	return value
+}
+
+// ConvertNamedSpoilerToNamedHide converts named spoilers to named hides.
+func ConvertNamedSpoilerToNamedHide(value string) string {
+	return convertNamedSpoilerToNamedHide(value)
+}
+
+func removeSpoiler(value string) string {
+	re := regexp.MustCompile(`(?i)\[/?spoiler[\s\S]*?\]`)
+	return re.ReplaceAllString(value, "")
+}
+
+// RemoveSpoiler removes spoiler tags.
+func RemoveSpoiler(value string) string { return removeSpoiler(value) }
+
+func removeColor(value string) string {
+	re := regexp.MustCompile(`(?i)\[/?color(?:=[^\]]*)?\]`)
+	return re.ReplaceAllString(value, "")
+}
+
+// RemoveColor removes color tags.
+func RemoveColor(value string) string { return removeColor(value) }
+
+func convertNamedSpoilerToNormalSpoiler(value string) string {
+	re := regexp.MustCompile(`(?i)(\[spoiler=[^]]+])`)
+	return re.ReplaceAllString(value, "[spoiler]")
+}
+
+// ConvertNamedSpoilerToNormalSpoiler removes spoiler titles.
+func ConvertNamedSpoilerToNormalSpoiler(value string) string {
+	return convertNamedSpoilerToNormalSpoiler(value)
+}
+
+func convertCodeToQuote(value string) string {
+	value = strings.ReplaceAll(value, "[code", "[quote")
+	value = strings.ReplaceAll(value, "[/code]", "[/quote]")
+	return value
+}
+
+// ConvertCodeToQuote changes code tags to quote tags.
+func ConvertCodeToQuote(value string) string { return convertCodeToQuote(value) }
+
+func removeImgResize(value string) string {
+	re := regexp.MustCompile(`(?i)\[img(?:[^\]]*)\]`)
+	return re.ReplaceAllString(value, "[img]")
+}
+
+// RemoveImageResize removes image tag attributes.
+func RemoveImageResize(value string) string { return removeImgResize(value) }
+
+func convertToAlign(value string) string {
+	reStart := regexp.MustCompile(`\[(right|center|left)\]`)
+	reEnd := regexp.MustCompile(`\[/(right|center|left)\]`)
+	value = reStart.ReplaceAllString(value, "[align=$1]")
+	value = reEnd.ReplaceAllString(value, "[/align]")
+	return value
+}
+
+// ConvertToAlign converts positional tags to align tags.
+func ConvertToAlign(value string) string { return convertToAlign(value) }
+
+func removeSup(value string) string {
+	value = strings.ReplaceAll(value, "[sup]", "")
+	value = strings.ReplaceAll(value, "[/sup]", "")
+	return value
+}
+
+// RemoveSup removes sup tags.
+func RemoveSup(value string) string { return removeSup(value) }
+
+func removeSub(value string) string {
+	value = strings.ReplaceAll(value, "[sub]", "")
+	value = strings.ReplaceAll(value, "[/sub]", "")
+	return value
+}
+
+// RemoveSub removes sub tags.
+func RemoveSub(value string) string { return removeSub(value) }
+
+func removeList(value string) string {
+	value = strings.ReplaceAll(value, "[list]", "")
+	value = strings.ReplaceAll(value, "[/list]", "")
+	return value
+}
+
+// RemoveList removes list container tags.
+func RemoveList(value string) string { return removeList(value) }
+
+func convertComparisonToCollapse(value string, maxWidth int) string {
+	re := regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
+	comparisons := re.FindAllString(value, -1)
+	for _, comp := range comparisons {
+		parts := strings.SplitN(comp, "]", 2)
+		if len(parts) < 2 {
+			continue
+		}
+		compSources := strings.ReplaceAll(parts[0], "[comparison=", "")
+		compSources = strings.ReplaceAll(compSources, " ", "")
+		sources := strings.Split(compSources, ",")
+		images := strings.ReplaceAll(parts[1], "[/comparison]", "")
+		images = strings.ReplaceAll(images, ",", "\n")
+		images = strings.ReplaceAll(images, " ", "\n")
+		imgRe := regexp.MustCompile(`(?i)(https?://.*\.(?:png|jpg))`)
+		compImages := imgRe.FindAllString(images, -1)
+		screensPerLine := len(sources)
+		if screensPerLine == 0 {
+			continue
+		}
+		imgSize := min(maxWidth/screensPerLine, 350)
+		line := make([]string, 0, screensPerLine)
+		output := make([]string, 0)
+		for _, img := range compImages {
+			img = strings.TrimSpace(img)
+			if img == "" {
+				continue
+			}
+			bb := "[url=" + img + "][img=" + itoa(imgSize) + "]" + img + "[/img][/url]"
+			line = append(line, bb)
+			if len(line) == screensPerLine {
+				output = append(output, strings.Join(line, ""))
+				line = line[:0]
+			}
+		}
+		outputStr := strings.Join(output, "\n")
+		newBB := "[spoiler=" + strings.Join(sources, " vs ") + "][center]" + strings.Join(sources, " | ") + "[/center]\n" + outputStr + "[/spoiler]"
+		value = strings.ReplaceAll(value, comp, newBB)
+	}
+	return value
+}
+
+// ConvertComparisonToCollapse converts comparison blocks to spoilers.
+func ConvertComparisonToCollapse(value string, maxWidth int) string {
+	return convertComparisonToCollapse(value, maxWidth)
+}
+
+func convertComparisonToCentered(value string, maxWidth int) string {
+	re := regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
+	comparisons := re.FindAllString(value, -1)
+	for _, comp := range comparisons {
+		parts := strings.SplitN(comp, "]", 2)
+		if len(parts) < 2 {
+			continue
+		}
+		compSources := strings.TrimSpace(strings.ReplaceAll(parts[0], "[comparison=", ""))
+		sources := regexp.MustCompile(`\s*,\s*`).Split(compSources, -1)
+		images := strings.ReplaceAll(parts[1], "[/comparison]", "")
+		images = strings.ReplaceAll(images, ",", "\n")
+		images = strings.ReplaceAll(images, " ", "\n")
+		imgRe := regexp.MustCompile(`(?i)(https?://.*\.(?:png|jpg))`)
+		compImages := imgRe.FindAllString(images, -1)
+		screensPerLine := len(sources)
+		if screensPerLine == 0 {
+			continue
+		}
+		imgSize := min(maxWidth/screensPerLine, 350)
+		line := make([]string, 0, screensPerLine)
+		output := make([]string, 0)
+		for _, img := range compImages {
+			img = strings.TrimSpace(img)
+			if img == "" {
+				continue
+			}
+			bb := "[url=" + img + "][img=" + itoa(imgSize) + "]" + img + "[/img][/url]"
+			line = append(line, bb)
+			if len(line) == screensPerLine {
+				output = append(output, strings.Join(line, ""))
+				line = line[:0]
+			}
+		}
+		outputStr := strings.Join(output, "\n")
+		newBB := "[center]" + strings.Join(sources, " | ") + "\n" + outputStr + "[/center]"
+		value = strings.ReplaceAll(value, comp, newBB)
+	}
+	return value
+}
+
+// ConvertComparisonToCentered renders comparison blocks as centered screenshots.
+func ConvertComparisonToCentered(value string, maxWidth int) string {
+	return convertComparisonToCentered(value, maxWidth)
+}
+
+func convertCollapseToComparison(value string, spoilerHide string, collapses []string) string {
+	if len(collapses) == 0 {
+		return value
+	}
+	imgTagRe := regexp.MustCompile(`(?i)\[img[\s\S]*?\[/img\]`)
+	imgURLRe := regexp.MustCompile(`(?i)\[img[\s\S]*\]`)
+	for _, tag := range collapses {
+		images := imgTagRe.FindAllString(tag, -1)
+		if len(images) < 6 {
+			continue
+		}
+		compImages := make([]string, 0, len(images))
+		for _, image := range images {
+			imageURL := imgURLRe.ReplaceAllString(strings.ReplaceAll(image, "[/img]", ""), "")
+			compImages = append(compImages, imageURL)
+		}
+		sources := ""
+		if spoilerHide == "spoiler" {
+			match := regexp.MustCompile(`(?i)\[spoiler[\s\S]*?\]`).FindString(tag)
+			if match == "" {
+				continue
+			}
+			sources = strings.TrimSuffix(strings.TrimPrefix(match, "[spoiler="), "]")
+		} else if spoilerHide == "hide" {
+			match := regexp.MustCompile(`(?i)\[hide[\s\S]*?\]`).FindString(tag)
+			if match == "" {
+				continue
+			}
+			sources = strings.TrimSuffix(strings.TrimPrefix(match, "[hide="), "]")
+		}
+		if sources == "" {
+			continue
+		}
+		sources = regexp.MustCompile(`(?i)comparison`).ReplaceAllString(sources, "")
+		for _, sep := range []string{"vs", ",", "|"} {
+			parts := strings.Split(sources, sep)
+			sources = strings.Join(parts, "$")
+		}
+		finalSources := strings.Split(sources, "$")
+		for i, source := range finalSources {
+			finalSources[i] = strings.TrimSpace(source)
+		}
+		compImagesStr := strings.Join(compImages, "\n")
+		finalSourcesStr := strings.Join(finalSources, ", ")
+		spoilToComp := "[comparison=" + finalSourcesStr + "]" + compImagesStr + "[/comparison]"
+		value = strings.ReplaceAll(value, tag, spoilToComp)
+	}
+	return value
+}
+
+// ConvertCollapseToComparison converts screenshot comparison collapses to BBCode comparisons.
+func ConvertCollapseToComparison(value string, spoilerHide string, collapses []string) string {
+	return convertCollapseToComparison(value, spoilerHide, collapses)
+}
+
+func itoa(value int) string {
+	return strconv.Itoa(value)
+}
+
+func normalizeImageRawURL(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	converted := convertImgboxThumbURL(trimmed)
+	converted = convertPixhostThumbURL(converted)
+	return converted
+}
+
+// NormalizeImageRawURL expands known image-host thumbnail URLs to original images.
+func NormalizeImageRawURL(value string) string { return normalizeImageRawURL(value) }
+
+func convertImgboxThumbURL(value string) string {
+	parsed, err := url.Parse(value)
+	if err != nil {
+		return value
+	}
+	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
+	if !strings.Contains(host, "imgbox.com") || !strings.Contains(host, "thumbs") {
+		return value
+	}
+	parsed.Host = strings.ReplaceAll(parsed.Host, "thumbs2.imgbox.com", "images2.imgbox.com")
+	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.png", "_o.png")
+	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.jpg", "_o.jpg")
+	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.jpeg", "_o.jpeg")
+	return parsed.String()
+}
+
+func convertPixhostThumbURL(value string) string {
+	parsed, err := url.Parse(value)
+	if err != nil {
+		return value
+	}
+	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
+	pathValue := strings.TrimSpace(parsed.Path)
+	if !isPixhostHost(host) || !strings.HasPrefix(pathValue, "/thumbs/") {
+		return value
+	}
+	replacePixhostThumbHost(parsed, host)
+	parsed.Path = strings.Replace(pathValue, "/thumbs/", "/images/", 1)
+	return parsed.String()
+}
+
+func replacePixhostThumbHost(parsed *url.URL, host string) {
+	hostParts := strings.SplitN(host, ".", 2)
+	if len(hostParts) != 2 {
+		return
+	}
+	first := hostParts[0]
+	if !strings.HasPrefix(first, "t") || len(first) == 1 {
+		return
+	}
+
+	port := parsed.Port()
+	parsed.Host = "img" + strings.TrimPrefix(first, "t") + "." + hostParts[1]
+	if port != "" {
+		parsed.Host += ":" + port
+	}
+}
+
+func isPixhostHost(host string) bool {
+	return host == "pixhost.cc" ||
+		host == "pixhost.to" ||
+		strings.HasSuffix(host, ".pixhost.cc") ||
+		strings.HasSuffix(host, ".pixhost.to")
+}
diff --git a/internal/bbcode/ptp.go b/internal/bbcode/ptp.go
new file mode 100644
index 00000000..2ec9641a
--- /dev/null
+++ b/internal/bbcode/ptp.go
@@ -0,0 +1,230 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bbcode
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
+)
+
+var (
+	ptpPTPURLPattern          = regexp.MustCompile(`(?i)(?:\[url(?:=|\])[^\]]*https?://passthepopcorn\.m[^\]]*\]|\bhttps?://passthepopcorn\.m[^\s]+)`)
+	ptpHDBURLPattern          = regexp.MustCompile(`(?i)(\[url[=]]https?://hdbits\.o[^\]]+)([^\[]+)(\[/url\])?`)
+	ptpComparePattern         = regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
+	ptpHidePattern            = regexp.MustCompile(`(?i)\[hide[\s\S]*?\[/hide\]`)
+	ptpImgPattern             = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\][\s\S]*?\[/img\]`)
+	ptpLooseImg               = regexp.MustCompile(`(?i)(https?://[^\s\[\]]+\.(?:png|jpg))`)
+	ptpQuotePattern           = regexp.MustCompile(`(?i)\[quote.*?\]`)
+	ptpAlignPattern           = regexp.MustCompile(`(?i)\[align=.*?\]`)
+	ptpURLTagPattern          = regexp.MustCompile(`(?i)(\[url[=]]https?://passthepopcorn\.m[^\]]+])`)
+	ptpHDBTagPattern          = regexp.MustCompile(`(?i)(\[url[=]]https?://hdbits\.o[^\]]+])`)
+	ptpMediaInfoPattern       = regexp.MustCompile(`(?i)\[mediainfo\][\s\S]*?\[/mediainfo\]`)
+	ptpGeneralUniquePattern   = regexp.MustCompile(`(?im)(^general\nunique)(.*?)^$`)
+	ptpGeneralCompletePattern = regexp.MustCompile(`(?im)(^general\ncomplete)(.*?)^$`)
+	ptpFormatPattern          = regexp.MustCompile(`(?im)(^(Format[\s]{2,}:))(.*?)^$`)
+	ptpTrackIDPattern         = regexp.MustCompile(`(?im)(^(video|audio|text)( #\d+)?\nid)(.*?)^$`)
+	ptpMenuPattern            = regexp.MustCompile(`(?im)(^(menu)( #\d+)?\n)(.*?)^$`)
+	ptpBoldMediaPattern       = regexp.MustCompile(
+		`(?is)\[b\](.*?)(Matroska|DTS|AVC|x264|Progressive|23\.976 fps|16:9|[0-9]+x[0-9]+|[0-9]+ MiB|[0-9]+ Kbps|[0-9]+ bits|cabac=.*?/ aq=.*?|\d+\.\d+ Mbps)\[/b\]`,
+	)
+	ptpMediaTokenPattern = regexp.MustCompile(
+		`(?is)(Matroska|DTS|AVC|x264|Progressive|23\.976 fps|16:9|[0-9]+x[0-9]+|[0-9]+ MiB|[0-9]+ Kbps|[0-9]+ bits|cabac=.*?/ aq=.*?|\d+\.\d+ Mbps|[0-9]+\s+channels|[0-9]+\.[0-9]+\s+KHz|[0-9]+ KHz|[0-9]+\s+bits)`,
+	)
+	ptpUnderlinedFieldPattern      = regexp.MustCompile(`(?i)\[u\](Format|Bitrate|Channels|Sampling Rate|Resolution):\[/u\]\s*\d*.*?`)
+	ptpNumericMediaLinePattern     = regexp.MustCompile(`(?im)^\s*\d+\s*(channels|KHz|bits)\s*$`)
+	ptpWhitespaceLinePattern       = regexp.MustCompile(`(?m)^\s+$`)
+	ptpMultiNewlinePattern         = regexp.MustCompile(`\n{2,}`)
+	ptpEmptyCenterPattern          = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
+	ptpSizePattern                 = regexp.MustCompile(`(?i)\[size=.*?\]`)
+	ptpVideoPattern                = regexp.MustCompile(`(?i)\[video\][\s\S]*?\[/video\]`)
+	ptpStaffPattern                = regexp.MustCompile(`(?i)\[staff[\s\S]*?\[/staff\]`)
+	ptpDiscInfoPattern             = regexp.MustCompile(`(?i)DISC INFO:[\s\S]*?(\n\n|$)`)
+	ptpDiscTitlePattern            = regexp.MustCompile(`(?i)Disc Title:[\s\S]*?(\n\n|$)`)
+	ptpDiscSizePattern             = regexp.MustCompile(`(?i)Disc Size:[\s\S]*?(\n\n|$)`)
+	ptpProtectionPattern           = regexp.MustCompile(`(?i)Protection:[\s\S]*?(\n\n|$)`)
+	ptpBDJavaPattern               = regexp.MustCompile(`(?i)BD-Java:[\s\S]*?(\n\n|$)`)
+	ptpBDInfoPattern               = regexp.MustCompile(`(?i)BDInfo:[\s\S]*?(\n\n|$)`)
+	ptpPlaylistReportPattern       = regexp.MustCompile(`(?i)PLAYLIST REPORT:[\s\S]*?(\n\n|$)`)
+	ptpNamePattern                 = regexp.MustCompile(`(?i)Name:[\s\S]*?(\n\n|$)`)
+	ptpLengthPattern               = regexp.MustCompile(`(?i)Length:[\s\S]*?(\n\n|$)`)
+	ptpSizeLinePattern             = regexp.MustCompile(`(?i)Size:[\s\S]*?(\n\n|$)`)
+	ptpTotalBitratePattern         = regexp.MustCompile(`(?i)Total Bitrate:[\s\S]*?(\n\n|$)`)
+	ptpVideoSectionPattern         = regexp.MustCompile(`(?i)VIDEO:[\s\S]*?(\n\n|$)`)
+	ptpAudioSectionPattern         = regexp.MustCompile(`(?i)AUDIO:[\s\S]*?(\n\n|$)`)
+	ptpSubtitlesSectionPattern     = regexp.MustCompile(`(?i)SUBTITLES:[\s\S]*?(\n\n|$)`)
+	ptpCodecBitratePattern         = regexp.MustCompile(`(?i)Codec\s+Bitrate\s+Description[\s\S]*?(\n\n|$)`)
+	ptpCodecLanguageBitratePattern = regexp.MustCompile(`(?i)Codec\s+Language\s+Bitrate\s+Description[\s\S]*?(\n\n|$)`)
+	ptpBotSignature                = regexp.MustCompile(
+		`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`,
+	)
+)
+
+// CleanPTPDescription removes tracker links, embedded MediaInfo, unsupported
+// blocks, and known uploader signatures from a PTP-style description. It
+// returns extracted images separately and omits a cleaned body that is blank or
+// contains only BBCode tags.
+func CleanPTPDescription(description string, discType string) Report {
+	desc := strings.ReplaceAll(description, "&bull;", "-")
+	desc = NormalizeNewlines(desc)
+	desc = ptpBotSignature.ReplaceAllString(desc, "")
+
+	urlTags := ptpPTPURLPattern.FindAllString(desc, -1)
+	hdbTags := ptpHDBURLPattern.FindAllString(desc, -1)
+	urlTags = append(urlTags, hdbTags...)
+	for _, urlTag := range urlTags {
+		cleaned := ptpURLTagPattern.ReplaceAllString(urlTag, "")
+		cleaned = ptpHDBTagPattern.ReplaceAllString(cleaned, "")
+		cleaned = strings.ReplaceAll(cleaned, "[/url]", "")
+		desc = strings.ReplaceAll(desc, urlTag, cleaned)
+	}
+
+	desc = strings.ReplaceAll(desc, "http://passthepopcorn.me", "PTP")
+	desc = strings.ReplaceAll(desc, "https://passthepopcorn.me", "PTP")
+	desc = strings.ReplaceAll(desc, "http://hdbits.org", "HDB")
+	desc = strings.ReplaceAll(desc, "https://hdbits.org", "HDB")
+
+	imagelist := make([]Image, 0)
+	excluded := make(map[string]struct{})
+
+	sourceEncode := regexp.MustCompile(`(?i)\[comparison=Source, Encode\][\s\S]*`).FindAllString(desc, -1)
+	sourceVs := regexp.MustCompile(`(?i)Source Vs Encode:[\s\S]*`).FindAllString(desc, -1)
+	for _, block := range append(sourceEncode, sourceVs...) {
+		urls := ptpLooseImg.FindAllString(block, -1)
+		for _, url := range urls {
+			excluded[url] = struct{}{}
+		}
+		desc = strings.ReplaceAll(desc, block, "")
+	}
+
+	comps := ptpComparePattern.FindAllString(desc, -1)
+	hides := ptpHidePattern.FindAllString(desc, -1)
+	comps = append(comps, hides...)
+	nocomp := desc
+	for url := range excluded {
+		nocomp = strings.ReplaceAll(nocomp, url, "")
+	}
+
+	compPlaceholders := make([]string, 0, len(comps))
+	for i, comp := range comps {
+		nocomp = strings.ReplaceAll(nocomp, comp, "")
+		placeholder := "COMPARISON_PLACEHOLDER-" + strconv.Itoa(i) + " "
+		desc = strings.ReplaceAll(desc, comp, placeholder)
+		compPlaceholders = append(compPlaceholders, comp)
+	}
+
+	var links []string
+
+	switch strings.ToUpper(strings.TrimSpace(discType)) {
+	case "DVD":
+		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
+	case "BDMV":
+		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
+		desc = ptpDiscInfoPattern.ReplaceAllString(desc, "")
+		desc = ptpDiscTitlePattern.ReplaceAllString(desc, "")
+		desc = ptpDiscSizePattern.ReplaceAllString(desc, "")
+		desc = ptpProtectionPattern.ReplaceAllString(desc, "")
+		desc = ptpBDJavaPattern.ReplaceAllString(desc, "")
+		desc = ptpBDInfoPattern.ReplaceAllString(desc, "")
+		desc = ptpPlaylistReportPattern.ReplaceAllString(desc, "")
+		desc = ptpNamePattern.ReplaceAllString(desc, "")
+		desc = ptpLengthPattern.ReplaceAllString(desc, "")
+		desc = ptpSizeLinePattern.ReplaceAllString(desc, "")
+		desc = ptpTotalBitratePattern.ReplaceAllString(desc, "")
+		desc = ptpVideoSectionPattern.ReplaceAllString(desc, "")
+		desc = ptpAudioSectionPattern.ReplaceAllString(desc, "")
+		desc = ptpSubtitlesSectionPattern.ReplaceAllString(desc, "")
+		desc = ptpCodecBitratePattern.ReplaceAllString(desc, "")
+		desc = ptpCodecLanguageBitratePattern.ReplaceAllString(desc, "")
+	default:
+		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
+		desc = ptpGeneralUniquePattern.ReplaceAllString(desc, "")
+		desc = ptpGeneralCompletePattern.ReplaceAllString(desc, "")
+		desc = ptpFormatPattern.ReplaceAllString(desc, "")
+		desc = ptpTrackIDPattern.ReplaceAllString(desc, "")
+		desc = ptpMenuPattern.ReplaceAllString(desc+"\n\n", "")
+
+		desc, links = protectLinks(desc)
+		desc = ptpBoldMediaPattern.ReplaceAllString(desc, "")
+		desc = ptpMediaTokenPattern.ReplaceAllString(desc, "")
+		desc = ptpUnderlinedFieldPattern.ReplaceAllString(desc, "")
+		desc = ptpNumericMediaLinePattern.ReplaceAllString(desc, "")
+		desc = ptpWhitespaceLinePattern.ReplaceAllString(desc, "")
+		desc = ptpMultiNewlinePattern.ReplaceAllString(desc, "\n")
+	}
+
+	desc = restoreLinks(desc, links)
+
+	desc = ptpQuotePattern.ReplaceAllString(desc, "[code]")
+	desc = strings.ReplaceAll(desc, "[/quote]", "[/code]")
+	desc = ptpAlignPattern.ReplaceAllString(desc, "")
+	desc = strings.ReplaceAll(desc, "[/align]", "")
+
+	desc = ptpSizePattern.ReplaceAllString(desc, "")
+	desc = strings.ReplaceAll(desc, "[/size]", "")
+	desc = ptpVideoPattern.ReplaceAllString(desc, "")
+	desc = ptpStaffPattern.ReplaceAllString(desc, "")
+
+	for _, tag := range []string{"[movie]", "[/movie]", "[artist]", "[/artist]", "[user]", "[/user]", "[indent]", "[/indent]", "[size]", "[/size]", "[hr]"} {
+		desc = strings.ReplaceAll(desc, tag, "")
+	}
+
+	desc = ptpImgPattern.ReplaceAllString(desc, "")
+
+	looseImages := ptpLooseImg.FindAllString(nocomp, -1)
+	for _, imgURL := range looseImages {
+		if _, ok := excluded[imgURL]; ok {
+			continue
+		}
+		host := imagehost.ExtractHost(imgURL)
+		rawURL := NormalizeImageRawURL(imgURL)
+		imagelist = append(imagelist, Image{
+			ImgURL: imgURL,
+			RawURL: rawURL,
+			WebURL: imgURL,
+			Host:   host,
+		})
+		desc = strings.ReplaceAll(desc, imgURL, "")
+	}
+
+	for i, comp := range compPlaceholders {
+		cleanComp := regexp.MustCompile(`(?i)\[/?img[\s\S]*?\]`).ReplaceAllString(comp, "")
+		desc = strings.ReplaceAll(desc, "COMPARISON_PLACEHOLDER-"+strconv.Itoa(i)+" ", cleanComp)
+	}
+
+	desc = ConvertCollapseToComparison(desc, "hide", hides)
+	desc = ptpEmptyCenterPattern.ReplaceAllString(desc, "")
+
+	desc = strings.Trim(desc, "\n")
+	desc = regexp.MustCompile(`\n\n+`).ReplaceAllString(desc, "\n\n")
+	for strings.HasPrefix(desc, "\n") {
+		desc = strings.TrimPrefix(desc, "\n")
+	}
+	desc = strings.Trim(desc, "\n")
+
+	if strings.TrimSpace(strings.ReplaceAll(desc, "\n", "")) == "" {
+		return Report{Images: imagelist}
+	}
+	if IsOnlyTags(desc) {
+		return Report{Images: imagelist}
+	}
+	return Report{Description: desc, Images: imagelist}
+}
+
+func protectLinks(value string) (string, []string) {
+	links := regexp.MustCompile(`https?://\S+`).FindAllString(value, -1)
+	for i, link := range links {
+		value = strings.ReplaceAll(value, link, "__LINK_PLACEHOLDER_"+strconv.Itoa(i)+"__")
+	}
+	return value, links
+}
+
+func restoreLinks(value string, links []string) string {
+	for i, link := range links {
+		value = strings.ReplaceAll(value, "__LINK_PLACEHOLDER_"+strconv.Itoa(i)+"__", link)
+	}
+	return value
+}
diff --git a/internal/bbcode/types.go b/internal/bbcode/types.go
new file mode 100644
index 00000000..80aa9f96
--- /dev/null
+++ b/internal/bbcode/types.go
@@ -0,0 +1,47 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package bbcode provides shared BBCode cleanup and normalization primitives.
+package bbcode
+
+// Image describes an image extracted while cleaning a BBCode description.
+type Image struct {
+	// ImgURL is the BBCode-ready image URL, which may point at a thumbnail.
+	ImgURL string
+	// RawURL is the direct image URL.
+	RawURL string
+	// WebURL is the image host's browser-facing page URL when available.
+	WebURL string
+	// Host is the normalized image-host name, such as "imgbb" or "pixhost".
+	Host string
+}
+
+// Note reports a non-fatal condition encountered while cleaning a description.
+type Note struct {
+	// Kind categorizes the note for downstream handling.
+	Kind string
+	// Message contains caller-visible detail about the condition.
+	Message string
+}
+
+// Artifact contains auxiliary content extracted from a description.
+type Artifact struct {
+	// Name is the suggested artifact filename.
+	Name string
+	// Kind categorizes the extracted artifact.
+	Kind string
+	// Content is the extracted artifact body.
+	Content string
+}
+
+// Report contains a cleaned description and content extracted during cleanup.
+type Report struct {
+	// Description is the normalized BBCode that remains after cleanup.
+	Description string
+	// Images contains images removed or identified during cleanup.
+	Images []Image
+	// Notes contains non-fatal cleanup diagnostics.
+	Notes []Note
+	// Artifacts contains auxiliary files extracted from the description.
+	Artifacts []Artifact
+}
diff --git a/internal/bbcode/unit3d.go b/internal/bbcode/unit3d.go
new file mode 100644
index 00000000..93fa1b22
--- /dev/null
+++ b/internal/bbcode/unit3d.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bbcode
+
+import descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+
+// CleanUnit3DDescription removes site-local links and image markup from a
+// Unit3D description, returning the first non-poster image set separately from
+// the cleaned body.
+func CleanUnit3DDescription(description string, site string) Report {
+	report := descriptionunit3d.CleanDescription(description, site)
+	return Report{
+		Description: report.Description,
+		Images:      convertUnit3DImages(report.Images),
+		Notes:       convertUnit3DNotes(report.Notes),
+	}
+}
+
+func convertUnit3DImages(images []descriptionunit3d.Image) []Image {
+	if len(images) == 0 {
+		return nil
+	}
+	converted := make([]Image, 0, len(images))
+	for _, image := range images {
+		converted = append(converted, Image{
+			ImgURL: image.ImgURL,
+			RawURL: image.RawURL,
+			WebURL: image.WebURL,
+			Host:   image.Host,
+		})
+	}
+	return converted
+}
+
+func convertUnit3DNotes(notes []descriptionunit3d.Note) []Note {
+	if len(notes) == 0 {
+		return nil
+	}
+	converted := make([]Note, 0, len(notes))
+	for _, note := range notes {
+		converted = append(converted, Note{
+			Kind:    note.Kind,
+			Message: note.Message,
+		})
+	}
+	return converted
+}
diff --git a/internal/clientdiscovery/discovery.go b/internal/clientdiscovery/discovery.go
new file mode 100644
index 00000000..401903be
--- /dev/null
+++ b/internal/clientdiscovery/discovery.go
@@ -0,0 +1,218 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package clientdiscovery owns normalized, source-scoped torrent-client
+// discovery for canonical preparation.
+package clientdiscovery
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// SearchInput contains only source facts and search choices needed for one
+// client-discovery operation.
+type SearchInput struct {
+	// SourcePath is the canonical local source path supplied to the client adapter.
+	SourcePath string
+	// FileList contains source-relative or local file evidence used for matching.
+	FileList []string
+	// DiscType identifies disc layouts whose files require client-specific matching.
+	DiscType string
+	// Policy controls skipping and optional client selection.
+	Policy api.ClientSearchPolicy
+	// ForceRecheck forwards an explicit hash-recheck choice to the selected client.
+	ForceRecheck *bool
+}
+
+// Disposition identifies whether a discovery request searched, was explicitly
+// skipped, or could not search because no client adapter exists.
+type Disposition string
+
+const (
+	DispositionSearched    Disposition = "searched"
+	DispositionSkipped     Disposition = "skipped"
+	DispositionUnavailable Disposition = "unavailable"
+)
+
+// Evidence is a detached normalized client snapshot. Callers decide which
+// fields become private preparation evidence or operation-local state.
+type Evidence struct {
+	// Disposition distinguishes an empty search result from no search.
+	Disposition Disposition
+	// InfoHash is the normalized hash of the matched local torrent.
+	InfoHash string
+	// TorrentPath is the reusable local metainfo path returned by the client search.
+	TorrentPath string
+	// TrackerIDs maps normalized tracker names to IDs extracted from the matched torrent.
+	TrackerIDs map[string]string
+	// FoundTrackerMatch reports whether any configured tracker matched.
+	FoundTrackerMatch bool
+	// TorrentComments contains detached tracker comment evidence.
+	TorrentComments []api.TorrentMatch
+	// PieceSizeConstraint carries any client-derived piece-size requirement.
+	PieceSizeConstraint string
+	// FoundPreferredPiece records the preferred reusable piece size when found.
+	FoundPreferredPiece string
+	// MatchedTrackers contains deduplicated, uppercase tracker names in sorted order.
+	MatchedTrackers []string
+}
+
+// Module hides client availability, skip semantics, normalization, and error
+// wrapping behind one operation-shaped interface.
+type Module struct {
+	clients api.ClientService
+	logger  api.Logger
+}
+
+// New constructs a client-discovery module. A nil client adapter represents a
+// runtime without local client discovery and produces unavailable evidence.
+func New(clients api.ClientService, logger api.Logger) *Module {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &Module{clients: clients, logger: logger}
+}
+
+// Discover obtains one current client snapshot and always reports why a search
+// did or did not execute.
+func (m *Module) Discover(ctx context.Context, input SearchInput) (Evidence, error) {
+	if m == nil {
+		return Evidence{}, errors.New("client discovery: module is not initialized")
+	}
+	if ctx == nil {
+		return Evidence{}, errors.New("client discovery: context is required")
+	}
+	if strings.TrimSpace(input.SourcePath) == "" {
+		return Evidence{}, fmt.Errorf("client discovery: source path is required: %w", internalerrors.ErrInvalidInput)
+	}
+	if err := ctx.Err(); err != nil {
+		return Evidence{}, fmt.Errorf("client discovery: canceled before search: %w", err)
+	}
+	if input.Policy.Skip {
+		m.logger.Debugf("client discovery: decision=skip reason=requested")
+		return Evidence{Disposition: DispositionSkipped}, nil
+	}
+	if m.clients == nil {
+		m.logger.Debugf("client discovery: decision=skip reason=client_unavailable")
+		return Evidence{Disposition: DispositionUnavailable}, nil
+	}
+
+	m.logger.Debugf("client discovery: decision=start files=%d disc=%t", len(input.FileList), strings.TrimSpace(input.DiscType) != "")
+	result, err := m.clients.SearchPathedTorrents(ctx, api.ClientSubject{
+		SourcePath: strings.TrimSpace(input.SourcePath),
+		FileList:   append([]string(nil), input.FileList...),
+		DiscType:   strings.TrimSpace(input.DiscType),
+		ClientOverrides: api.ClientOverrides{
+			Client:       cloneString(input.Policy.Client),
+			ForceRecheck: cloneBool(input.ForceRecheck),
+		},
+	})
+	if err != nil {
+		return Evidence{}, fmt.Errorf("client discovery: search pathed torrents: %w", err)
+	}
+	evidence := normalizeEvidence(result)
+	evidence.Disposition = DispositionSearched
+	m.logger.Debugf(
+		"client discovery: decision=complete matched=%t trackers=%d ids=%d reusable_torrent=%t",
+		evidence.FoundTrackerMatch,
+		len(evidence.MatchedTrackers),
+		len(evidence.TrackerIDs),
+		evidence.TorrentPath != "",
+	)
+	return evidence, nil
+}
+
+// normalizeEvidence detaches slices and maps from the client result and applies
+// the canonical tracker-name and whitespace normalization used by all callers.
+func normalizeEvidence(value api.ClientSearchResult) Evidence {
+	return Evidence{
+		InfoHash:            strings.TrimSpace(value.InfoHash),
+		TorrentPath:         strings.TrimSpace(value.TorrentPath),
+		TrackerIDs:          normalizeTrackerIDs(value.TrackerIDs),
+		FoundTrackerMatch:   value.FoundTrackerMatch,
+		TorrentComments:     cloneTorrentMatches(value.TorrentComments),
+		PieceSizeConstraint: strings.TrimSpace(value.PieceSizeConstraint),
+		FoundPreferredPiece: strings.TrimSpace(value.FoundPreferredPiece),
+		MatchedTrackers:     normalizeTrackers(value.MatchedTrackers),
+	}
+}
+
+// normalizeTrackerIDs lowercases tracker keys and drops blank keys and values.
+func normalizeTrackerIDs(values map[string]string) map[string]string {
+	if len(values) == 0 {
+		return nil
+	}
+	result := make(map[string]string, len(values))
+	for key, value := range values {
+		key = strings.ToLower(strings.TrimSpace(key))
+		value = strings.TrimSpace(value)
+		if key != "" && value != "" {
+			result[key] = value
+		}
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+// normalizeTrackers returns unique uppercase tracker names in deterministic order.
+func normalizeTrackers(values []string) []string {
+	seen := make(map[string]struct{}, len(values))
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		value = strings.ToUpper(strings.TrimSpace(value))
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		result = append(result, value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+// cloneTorrentMatches detaches nested tracker URL slices from client-owned results.
+func cloneTorrentMatches(values []api.TorrentMatch) []api.TorrentMatch {
+	if values == nil {
+		return nil
+	}
+	result := make([]api.TorrentMatch, len(values))
+	for index, value := range values {
+		result[index] = value
+		result[index].TrackerURLsRaw = append([]string(nil), value.TrackerURLsRaw...)
+		result[index].TrackerURLs = append([]api.TrackerMatch(nil), value.TrackerURLs...)
+	}
+	return result
+}
+
+// cloneString trims and detaches a non-empty optional client selector.
+func cloneString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	cloned := strings.TrimSpace(*value)
+	if cloned == "" {
+		return nil
+	}
+	return &cloned
+}
+
+// cloneBool detaches an optional boolean override.
+func cloneBool(value *bool) *bool {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
diff --git a/internal/clientdiscovery/discovery_test.go b/internal/clientdiscovery/discovery_test.go
new file mode 100644
index 00000000..558b9245
--- /dev/null
+++ b/internal/clientdiscovery/discovery_test.go
@@ -0,0 +1,123 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package clientdiscovery
+
+import (
+	"context"
+	"errors"
+	"slices"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type recordingClient struct {
+	calls  int
+	input  api.ClientSubject
+	result api.ClientSearchResult
+	err    error
+}
+
+func (*recordingClient) Inject(context.Context, api.ClientSubject, api.TorrentResult) error {
+	return nil
+}
+
+func (c *recordingClient) SearchPathedTorrents(_ context.Context, input api.ClientSubject) (api.ClientSearchResult, error) {
+	c.calls++
+	c.input = input
+	return c.result, c.err
+}
+
+func TestDiscoverNormalizesAndDetachesCurrentEvidence(t *testing.T) {
+	t.Parallel()
+
+	clientName := " qbit "
+	trackerName := " BTN "
+	force := true
+	client := &recordingClient{result: api.ClientSearchResult{
+		InfoHash:          " hash ",
+		TorrentPath:       " torrent/example.torrent ",
+		TrackerIDs:        map[string]string{trackerName: " 123 ", "empty": " "},
+		FoundTrackerMatch: true,
+		TorrentComments: []api.TorrentMatch{{
+			Name:           "Example.Release.2026",
+			TrackerURLsRaw: []string{"https://tracker.invalid/announce"},
+			TrackerURLs:    []api.TrackerMatch{{ID: "123", TrackerID: "btn"}},
+		}},
+		PieceSizeConstraint: " 4194304 ",
+		FoundPreferredPiece: " preferred ",
+		MatchedTrackers:     []string{" btn ", "AITHER", "BTN", ""},
+	}}
+	files := []string{"Example.Release.2026.mkv"}
+	evidence, err := New(client, api.NopLogger{}).Discover(context.Background(), SearchInput{
+		SourcePath:   " Example.Release.2026 ",
+		FileList:     files,
+		DiscType:     " BDMV ",
+		Policy:       api.ClientSearchPolicy{Client: &clientName},
+		ForceRecheck: &force,
+	})
+	if err != nil {
+		t.Fatalf("discover: %v", err)
+	}
+	if client.calls != 1 || client.input.SourcePath != "Example.Release.2026" || client.input.DiscType != "BDMV" {
+		t.Fatalf("client input = %#v calls=%d", client.input, client.calls)
+	}
+	if client.input.ClientOverrides.Client == nil || *client.input.ClientOverrides.Client != "qbit" {
+		t.Fatalf("client selector = %#v", client.input.ClientOverrides.Client)
+	}
+	if client.input.ClientOverrides.ForceRecheck == nil || !*client.input.ClientOverrides.ForceRecheck {
+		t.Fatalf("force recheck = %#v", client.input.ClientOverrides.ForceRecheck)
+	}
+	if evidence.InfoHash != "hash" || evidence.TorrentPath != "torrent/example.torrent" || evidence.TrackerIDs["btn"] != "123" {
+		t.Fatalf("evidence = %#v", evidence)
+	}
+	if !slices.Equal(evidence.MatchedTrackers, []string{"AITHER", "BTN"}) {
+		t.Fatalf("matched trackers = %#v", evidence.MatchedTrackers)
+	}
+	files[0] = "changed"
+	client.result.TrackerIDs["BTN"] = "changed"
+	client.result.TorrentComments[0].TrackerURLsRaw[0] = "changed"
+	client.result.TorrentComments[0].TrackerURLs[0].ID = "changed"
+	if client.input.FileList[0] != "Example.Release.2026.mkv" || evidence.TrackerIDs["btn"] != "123" ||
+		evidence.TorrentComments[0].TrackerURLsRaw[0] == "changed" || evidence.TorrentComments[0].TrackerURLs[0].ID == "changed" {
+		t.Fatalf("input/evidence aliases caller state: input=%#v evidence=%#v", client.input, evidence)
+	}
+}
+
+func TestDiscoverSkipAndUnavailableAreSuccessfulEmptySnapshots(t *testing.T) {
+	t.Parallel()
+
+	client := &recordingClient{}
+	evidence, err := New(client, api.NopLogger{}).Discover(context.Background(), SearchInput{
+		SourcePath: "Example.Release.2026.mkv",
+		Policy:     api.ClientSearchPolicy{Skip: true},
+	})
+	if err != nil || evidence.Disposition != DispositionSkipped || client.calls != 0 {
+		t.Fatalf("skip evidence=%#v err=%v calls=%d", evidence, err, client.calls)
+	}
+	evidence, err = New(nil, api.NopLogger{}).Discover(context.Background(), SearchInput{SourcePath: "Example.Release.2026.mkv"})
+	if err != nil || evidence.Disposition != DispositionUnavailable {
+		t.Fatalf("unavailable evidence=%#v err=%v", evidence, err)
+	}
+}
+
+func TestDiscoverPreservesSearchErrorsAndCancellation(t *testing.T) {
+	t.Parallel()
+
+	searchErr := errors.New("search failed")
+	_, err := New(&recordingClient{err: searchErr}, api.NopLogger{}).Discover(
+		context.Background(),
+		SearchInput{SourcePath: "Example.Release.2026.mkv"},
+	)
+	if !errors.Is(err, searchErr) {
+		t.Fatalf("search error = %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	client := &recordingClient{}
+	_, err = New(client, api.NopLogger{}).Discover(ctx, SearchInput{SourcePath: "Example.Release.2026.mkv"})
+	if !errors.Is(err, context.Canceled) || client.calls != 0 {
+		t.Fatalf("canceled error=%v calls=%d", err, client.calls)
+	}
+}
diff --git a/internal/clients/service.go b/internal/clients/service.go
deleted file mode 100644
index ea960a35..00000000
--- a/internal/clients/service.go
+++ /dev/null
@@ -1,705 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package clients
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-
-	qbittorrent "github.com/autobrr/go-qbittorrent"
-)
-
-type Service struct {
-	cfg    config.Config
-	logger api.Logger
-}
-
-// qbit injection HTTP uses a short, single-attempt client so a dead WebUI or
-// Qui proxy fails quickly without timing out local link staging first.
-const (
-	qbitInjectHTTPTimeout       = 30 * time.Second
-	qbitInjectHTTPRetryAttempts = 1
-	qbitLoginResponseMaxBytes   = 4 << 10
-)
-
-// qbitLoginValidatingTransport verifies direct qBittorrent login responses
-// before net/http can persist response cookies in the client's jar.
-type qbitLoginValidatingTransport struct {
-	base http.RoundTripper
-}
-
-// RoundTrip requires the exact qBittorrent success body for HTTP 200 login
-// responses. It bounds the body read and restores valid bodies for LoginCtx.
-func (t qbitLoginValidatingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	resp, err := t.base.RoundTrip(req)
-	if err != nil {
-		return nil, fmt.Errorf("qbit HTTP request: %w", err)
-	}
-	if !strings.HasSuffix(req.URL.Path, "/api/v2/auth/login") || resp.StatusCode != http.StatusOK {
-		return resp, nil
-	}
-
-	body, err := io.ReadAll(io.LimitReader(resp.Body, qbitLoginResponseMaxBytes+1))
-	if err != nil {
-		_ = resp.Body.Close()
-		return nil, fmt.Errorf("read qbit login response: %w", err)
-	}
-	if err := resp.Body.Close(); err != nil {
-		return nil, fmt.Errorf("close qbit login response: %w", err)
-	}
-	if len(body) > qbitLoginResponseMaxBytes {
-		return nil, errors.New("qbit login response exceeds limit")
-	}
-	if string(body) != "Ok." {
-		return nil, errors.New("qbit login response was not successful")
-	}
-	resp.Body = io.NopCloser(bytes.NewReader(body))
-	return resp, nil
-}
-
-func NewService(cfg config.Config, logger api.Logger) *Service {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	return &Service{cfg: cfg, logger: logger}
-}
-
-// Inject dispatches a prepared torrent to the configured injection clients.
-// URL-only torrents require a URL-capable client unless global/default fallback
-// can select one; explicit tracker or caller selections that resolve only to
-// watch-folder clients return [internalerrors.ErrInvalidInput] instead of a
-// successful no-op.
-func (s *Service) Inject(ctx context.Context, meta api.PreparedMetadata, torrent api.TorrentResult) (err error) {
-	defer func() {
-		if err != nil {
-			s.logger.Warnf("clients: injection blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	select {
-	case <-ctx.Done():
-		return fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	s.logger.Debugf("clients: injecting torrent for %s", meta.SourcePath)
-
-	torrentPath := strings.TrimSpace(torrent.Path)
-	torrentURL := strings.TrimSpace(torrent.URL)
-	if torrentPath == "" && torrentURL == "" {
-		s.logger.Debugf("clients: skipping injection for %s: no torrent file or URL", meta.SourcePath)
-		return internalerrors.ErrInvalidInput
-	}
-	s.logger.Tracef("clients: injection input source=%s tracker=%s has_file=%t has_url=%t configured_clients=%d", meta.SourcePath, strings.TrimSpace(torrent.Tracker), torrentPath != "", torrentURL != "", len(s.cfg.TorrentClients))
-
-	if len(s.cfg.TorrentClients) == 0 {
-		s.logger.Debugf("clients: no torrent clients configured, skipping injection")
-		return nil
-	}
-
-	clientOverrides := s.resolveInjectClientOverrides(meta.ClientOverrides, torrent.Tracker)
-	clients := resolveInjectClients(s.cfg, clientOverrides)
-	// Tracker-scoped torrent_client is an effective client override; URL
-	// fallback is only for global/default selections that cannot consume URLs.
-	effectiveClientOverride := clientOverrides.Client != nil && strings.TrimSpace(*clientOverrides.Client) != ""
-	if torrentPath == "" && torrentURL != "" && !effectiveClientOverride {
-		clients = withURLCapableInjectFallback(clients, s.cfg.TorrentClients)
-	}
-	if len(clients) == 0 {
-		s.logger.Debugf("clients: no matching torrent clients selected, skipping injection")
-		return nil
-	}
-	s.logger.Debugf("clients: selected %d torrent client(s) for injection", len(clients))
-
-	clientNames := make([]string, 0, len(clients))
-	for name := range clients {
-		clientNames = append(clientNames, name)
-	}
-	sort.Strings(clientNames)
-
-	injected := false
-	skippedURLOnlyClients := 0
-	for _, name := range clientNames {
-		client := applyClientOverrides(clients[name], clientOverrides)
-		clientType := strings.ToLower(strings.TrimSpace(client.ClientType()))
-		s.logger.Debugf("clients: processing client name=%s type=%s", name, clientType)
-		// Watch folders can still consume a local torrent file when URL metadata
-		// is also present. Skip only URL-only input before any injection delay so
-		// a skipped client cannot fail a successful URL add.
-		if clientType == "watch" && torrentPath == "" && torrentURL != "" {
-			s.logger.Debugf("clients: skipping watch folder client %s for URL injection", name)
-			skippedURLOnlyClients++
-			continue
-		}
-		if err := s.waitInjectDelay(ctx, torrent.Tracker); err != nil {
-			return err
-		}
-		switch clientType {
-		case "none", "disabled":
-			s.logger.Debugf("clients: skipping disabled client %s", name)
-			continue
-		case "watch":
-			if err := s.injectWatchFolder(ctx, name, client.WatchFolder, torrent.Path); err != nil {
-				return err
-			}
-			injected = true
-		case "qbit", "qbittorrent", "qui":
-			if err := s.injectQbit(ctx, name, client, meta, torrent); err != nil {
-				return err
-			}
-			injected = true
-		case "":
-			return fmt.Errorf("clients: %s type is required", name)
-		default:
-			return fmt.Errorf("clients: type %q not yet supported: %w", client.ClientType(), internalerrors.ErrNotImplemented)
-		}
-	}
-
-	if effectiveClientOverride && torrentPath == "" && torrentURL != "" && skippedURLOnlyClients > 0 && !injected {
-		return fmt.Errorf("clients: no selected torrent client supports URL injection: %w", internalerrors.ErrInvalidInput)
-	}
-
-	s.logger.Debugf("clients: injection dispatch complete for %s", meta.SourcePath)
-	return nil
-}
-
-func (s *Service) resolveInjectClientOverrides(overrides api.ClientOverrides, tracker string) api.ClientOverrides {
-	if overrides.Client != nil && strings.TrimSpace(*overrides.Client) != "" {
-		return overrides
-	}
-	trackerClient := s.trackerTorrentClient(tracker)
-	if trackerClient == "" {
-		return overrides
-	}
-	overrides.Client = &trackerClient
-	return overrides
-}
-
-func (s *Service) trackerTorrentClient(tracker string) string {
-	trackerCfg, ok := s.trackerConfig(tracker)
-	if !ok {
-		return ""
-	}
-	return strings.TrimSpace(trackerCfg.TorrentClient)
-}
-
-func (s *Service) trackerConfig(tracker string) (config.TrackerConfig, bool) {
-	trackerName := strings.TrimSpace(tracker)
-	if trackerName == "" {
-		return config.TrackerConfig{}, false
-	}
-	for name, trackerCfg := range s.cfg.Trackers.Trackers {
-		if strings.EqualFold(strings.TrimSpace(name), trackerName) {
-			return trackerCfg, true
-		}
-	}
-	return config.TrackerConfig{}, false
-}
-
-func (s *Service) waitInjectDelay(ctx context.Context, tracker string) error {
-	delay := s.cfg.PostUpload.InjectDelay
-	if trackerCfg, ok := s.trackerConfig(tracker); ok && trackerCfg.InjectDelay != nil {
-		delay = *trackerCfg.InjectDelay
-	}
-	if delay <= 0 {
-		return nil
-	}
-
-	s.logger.Debugf("clients: waiting %ds before injection for tracker %s", delay, strings.TrimSpace(tracker))
-	timer := time.NewTimer(time.Duration(delay) * time.Second)
-	defer timer.Stop()
-
-	select {
-	case <-ctx.Done():
-		return fmt.Errorf("context canceled: %w", ctx.Err())
-	case <-timer.C:
-		return nil
-	}
-}
-
-func (s *Service) injectWatchFolder(ctx context.Context, name, folder, torrentPath string) error {
-	if strings.TrimSpace(folder) == "" {
-		return fmt.Errorf("clients: %s watch_folder is required", name)
-	}
-	s.logger.Debugf("clients: writing torrent to watch folder for %s", name)
-
-	absTorrent, err := filepath.Abs(torrentPath)
-	if err != nil {
-		return fmt.Errorf("clients: %s torrent: %w", name, err)
-	}
-
-	info, err := os.Stat(folder)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return fmt.Errorf("clients: %s watch_folder: %w", name, internalerrors.ErrNotFound)
-		}
-		return fmt.Errorf("clients: %s watch_folder: %w", name, err)
-	}
-	if !info.IsDir() {
-		return fmt.Errorf("clients: %s watch_folder is not a directory", name)
-	}
-
-	select {
-	case <-ctx.Done():
-		return fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	source, err := os.Open(absTorrent)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return fmt.Errorf("clients: %s torrent: %w", name, internalerrors.ErrNotFound)
-		}
-		return fmt.Errorf("clients: %s torrent: %w", name, err)
-	}
-	defer source.Close()
-
-	destPath := filepath.Join(folder, filepath.Base(absTorrent))
-	dest, err := os.Create(destPath)
-	if err != nil {
-		return fmt.Errorf("clients: %s write torrent: %w", name, err)
-	}
-	defer func() {
-		_ = dest.Close()
-	}()
-
-	if _, err := io.Copy(dest, source); err != nil {
-		return fmt.Errorf("clients: %s write torrent: %w", name, err)
-	}
-	select {
-	case <-ctx.Done():
-		return fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	s.logger.Infof("clients: copied torrent to watch folder path=%s", destPath)
-	return nil
-}
-
-func (s *Service) injectQbit(ctx context.Context, name string, client config.TorrentClientConfig, meta api.PreparedMetadata, torrent api.TorrentResult) error {
-	host := strings.TrimSpace(client.QbitHost())
-	if host == "" {
-		return fmt.Errorf("clients: %s qbit host is required", name)
-	}
-	username := strings.TrimSpace(client.QbitUsername())
-	if username == "" && !client.UsesQuiProxy() {
-		return fmt.Errorf("clients: %s qbit username is required", name)
-	}
-	password := strings.TrimSpace(client.QbitPassword())
-	if password == "" && !client.UsesQuiProxy() {
-		return fmt.Errorf("clients: %s qbit password is required", name)
-	}
-
-	select {
-	case <-ctx.Done():
-		return fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	qbit := qbittorrent.NewClient(qbitInjectClientConfig(host, username, password, client))
-	qbitHTTP := qbit.GetHTTPClient()
-	baseTransport := qbitHTTP.Transport
-	if baseTransport == nil {
-		baseTransport = http.DefaultTransport
-	}
-	// The transport sees the response before http.Client stores Set-Cookie
-	// values, so a transient body cannot create an authenticated session.
-	qbitHTTP.Transport = qbitLoginValidatingTransport{base: baseTransport}
-
-	options := qbittorrent.TorrentAddOptions{}
-	s.logger.Debugf("clients: preparing qbit add options client=%s tracker=%s cross_seed=%t", name, strings.TrimSpace(torrent.Tracker), torrent.CrossSeed)
-	optionsStart := time.Now()
-	staging, err := s.prepareLinkStaging(ctx, name, client, meta, torrent)
-	if err != nil {
-		return err
-	}
-	options.SkipHashCheck = true
-	if staging.Linked {
-		options.SavePath = staging.SavePath
-		s.logger.Debugf("clients: qbit link staging selected client=%s tracker=%s files=%d layout_validated=%t save_path=%s", name, strings.TrimSpace(torrent.Tracker), staging.FileCount, staging.LayoutValidated, staging.SavePath)
-	} else {
-		// Without link staging, local_path/remote_path still controls where
-		// qBittorrent should save the injected torrent on the client host.
-		savePath, mapped, err := mappedQbitSavePathForSource(meta, client.LocalPath, client.RemotePath)
-		if err != nil {
-			return fmt.Errorf("clients: %s qbit path mapping: %w", name, err)
-		}
-		if mapped {
-			options.SavePath = savePath
-			s.logger.Debugf("clients: qbit path mapping ready client=%s save_path=%s", name, savePath)
-		}
-	}
-	if category := strings.TrimSpace(client.QbitCrossCategory); torrent.CrossSeed && category != "" {
-		options.Category = category
-	} else if category := strings.TrimSpace(client.QbitCategory()); category != "" {
-		options.Category = category
-	}
-	if tags := strings.TrimSpace(client.QbitCrossTag); torrent.CrossSeed && tags != "" {
-		options.Tags = tags
-	} else if tags := strings.TrimSpace(client.QbitTags()); tags != "" {
-		options.Tags = tags
-	} else if client.UseTrackerAsTag {
-		options.Tags = strings.TrimSpace(torrent.Tracker)
-	}
-	autoManagement := !staging.Linked && qbitAutomaticManagementEnabled(meta, client.AutomaticManagementPaths)
-	addOptions := options.Prepare()
-	addOptions["autoTMM"] = strconv.FormatBool(autoManagement)
-	s.logger.Debugf("clients: qbit add options ready client=%s auto_tmm=%t skip_hash_check=%t elapsed=%s", name, autoManagement, options.SkipHashCheck, time.Since(optionsStart).Round(time.Millisecond))
-
-	qbitCtx, cancel := context.WithTimeout(ctx, qbitInjectHTTPTimeout)
-	defer cancel()
-
-	s.logger.Debugf("clients: connecting to qbit %s timeout=%s retries=%d", redaction.RedactValue(host, nil), qbitInjectHTTPTimeout, qbitInjectHTTPRetryAttempts)
-	if !client.UsesQuiProxy() {
-		if err := qbit.LoginCtx(qbitCtx); err != nil {
-			s.cleanupFailedLinkStaging(name, torrent.Tracker, staging)
-			return fmt.Errorf("clients: %s qbit login: %w", name, err)
-		}
-		s.logger.Debugf("clients: connected to qbit client %s", name)
-	} else {
-		s.logger.Debugf("clients: using qbit proxy for client %s", name)
-	}
-
-	if torrentPath := strings.TrimSpace(torrent.Path); torrentPath != "" {
-		s.logger.Debugf("clients: adding torrent file to qbit client %s for %s", name, meta.SourcePath)
-		if _, err := qbit.AddTorrentFromFileCtx(qbitCtx, torrentPath, addOptions); err != nil {
-			s.cleanupFailedLinkStaging(name, torrent.Tracker, staging)
-			return fmt.Errorf("clients: %s qbit add torrent file: %w", name, err)
-		}
-
-		s.logger.Infof("clients: added torrent file to qbit client=%s tracker=%s linked=%t qbit_hash_check=%t source=%s", name, logTracker(torrent.Tracker), staging.Linked, !options.SkipHashCheck, meta.SourcePath)
-		return nil
-	}
-
-	if torrentURL := strings.TrimSpace(torrent.URL); torrentURL != "" {
-		s.logger.Debugf("clients: adding tracker torrent URL to qbit client %s for %s", name, meta.SourcePath)
-		if _, err := qbit.AddTorrentFromUrlCtx(qbitCtx, torrentURL, addOptions); err != nil {
-			s.cleanupFailedLinkStaging(name, torrent.Tracker, staging)
-			return fmt.Errorf("clients: %s qbit add torrent URL: %w", name, err)
-		}
-		s.logger.Infof("clients: added tracker torrent URL to qbit client=%s tracker=%s linked=%t qbit_hash_check=%t source=%s", name, logTracker(torrent.Tracker), staging.Linked, !options.SkipHashCheck, meta.SourcePath)
-		return nil
-	}
-
-	return internalerrors.ErrInvalidInput
-}
-
-// qbitAutomaticManagementEnabled reports whether the original local save path
-// is a configured automatic-management root or one of its descendants after
-// trimming and filepath cleaning. Containment uses host semantics: Windows
-// comparisons ignore case, while case-sensitive systems preserve it. Linked
-// staging is excluded by the caller.
-func qbitAutomaticManagementEnabled(meta api.PreparedMetadata, configuredPaths config.StringList) bool {
-	if len(configuredPaths) == 0 {
-		return false
-	}
-
-	source, err := sourcePathForQbitSavePath(meta)
-	if err != nil {
-		return false
-	}
-	localSavePath := filepath.Clean(filepath.Dir(source))
-	for _, configuredPath := range configuredPaths {
-		configuredPath = strings.TrimSpace(configuredPath)
-		if configuredPath == "" {
-			continue
-		}
-		configuredPath = filepath.Clean(configuredPath)
-		if pathutil.IsWithinRoot(configuredPath, localSavePath) {
-			return true
-		}
-	}
-	return false
-}
-
-func logTracker(tracker string) string {
-	tracker = strings.TrimSpace(tracker)
-	if tracker == "" {
-		return "none"
-	}
-	return tracker
-}
-
-// qbitInjectClientConfig preserves configured auth and TLS behavior while
-// applying the bounded HTTP policy used only for torrent injection requests.
-func qbitInjectClientConfig(host, username, password string, client config.TorrentClientConfig) qbittorrent.Config {
-	return qbittorrent.Config{
-		Host:          host,
-		Username:      username,
-		Password:      password,
-		TLSSkipVerify: client.QbitTLSSkipVerify(),
-		Timeout:       int(qbitInjectHTTPTimeout / time.Second),
-		RetryAttempts: qbitInjectHTTPRetryAttempts,
-	}
-}
-
-func (s *Service) cleanupFailedLinkStaging(clientName string, tracker string, staging linkStagingResult) {
-	if staging.Cleanup == nil {
-		return
-	}
-	if err := staging.Cleanup.Run(); err != nil {
-		s.logger.Warnf("clients: %s cleanup failed after qbit injection error tracker=%s: %v", clientName, strings.TrimSpace(tracker), err)
-		return
-	}
-	s.logger.Debugf("clients: %s cleaned staged links after qbit injection error tracker=%s", clientName, strings.TrimSpace(tracker))
-}
-
-// resolveInjectClients selects the configured torrent clients that should receive
-// an injected torrent. Explicit client overrides take precedence, then a
-// non-empty injecting_client_list, then default_torrent_client. Configured
-// selectors are authoritative: if a non-empty selector set resolves to no
-// clients, lower-priority fallbacks are skipped.
-func resolveInjectClients(cfg config.Config, overrides api.ClientOverrides) map[string]config.TorrentClientConfig {
-	clients := cfg.TorrentClients
-	if len(clients) == 0 {
-		return nil
-	}
-
-	if overrides.Client != nil && strings.TrimSpace(*overrides.Client) != "" {
-		if isDisableSelector(*overrides.Client) {
-			if selected := selectTorrentClients(clients, []string{*overrides.Client}); len(selected) > 0 {
-				return selected
-			}
-			return disabledTorrentClientSelection()
-		}
-		return selectTorrentClients(clients, []string{*overrides.Client})
-	}
-
-	if hasDisableOnlySelector(cfg.ClientSetup.InjectClients) {
-		return disabledTorrentClientSelection()
-	}
-	if hasNonBlankSelector(cfg.ClientSetup.InjectClients) {
-		return selectTorrentClients(clients, cfg.ClientSetup.InjectClients)
-	}
-
-	if strings.TrimSpace(cfg.ClientSetup.DefaultClient) != "" {
-		if isDisableSelector(cfg.ClientSetup.DefaultClient) {
-			return disabledTorrentClientSelection()
-		}
-		return selectTorrentClients(clients, []string{cfg.ClientSetup.DefaultClient})
-	}
-
-	if len(clients) == 1 {
-		for name, client := range clients {
-			return map[string]config.TorrentClientConfig{name: client}
-		}
-	}
-
-	return nil
-}
-
-// hasNonBlankSelector reports whether a selector list contains at least one
-// real client name. A lone "none" selector is handled separately as an
-// explicit disable sentinel.
-func hasNonBlankSelector(selected []string) bool {
-	for _, value := range selected {
-		if strings.TrimSpace(value) != "" && !isDisableSelector(value) {
-			return true
-		}
-	}
-	return false
-}
-
-// hasDisableOnlySelector reports whether the selector list contains only blank
-// values and "none", with at least one "none" entry.
-func hasDisableOnlySelector(selected []string) bool {
-	hasDisable := false
-	for _, value := range selected {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		if !isDisableSelector(trimmed) {
-			return false
-		}
-		hasDisable = true
-	}
-	return hasDisable
-}
-
-// isDisableSelector recognizes the literal selector used in config to disable
-// torrent injection or search fallback. Client configs with Type "disabled" are
-// detected later after a real client has been selected.
-func isDisableSelector(selected string) bool {
-	return strings.EqualFold(strings.TrimSpace(selected), "none")
-}
-
-// disabledTorrentClientSelection returns a synthetic selected client set that
-// carries the same no-op behavior as a configured client with Type "none".
-func disabledTorrentClientSelection() map[string]config.TorrentClientConfig {
-	return map[string]config.TorrentClientConfig{
-		"none": {Type: "none"},
-	}
-}
-
-// selectTorrentClients returns configured clients selected by name. Blank and
-// unknown selectors are ignored; ambiguous case-insensitive selectors are
-// ignored rather than letting map iteration order choose a target. Duplicate
-// selectors are collapsed only after they resolve to the same configured client,
-// so exact case-variant client names can both be selected.
-func selectTorrentClients(clients map[string]config.TorrentClientConfig, selected []string) map[string]config.TorrentClientConfig {
-	if len(clients) == 0 || len(selected) == 0 {
-		return nil
-	}
-
-	matches := make(map[string]config.TorrentClientConfig)
-	seenClients := make(map[string]struct{}, len(selected))
-	for _, value := range selected {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		name, client, ok := lookupTorrentClientConfig(clients, trimmed)
-		if !ok {
-			continue
-		}
-		if _, ok := seenClients[name]; ok {
-			continue
-		}
-		seenClients[name] = struct{}{}
-		matches[name] = client
-	}
-	if len(matches) == 0 {
-		return nil
-	}
-	return matches
-}
-
-// lookupTorrentClientConfig returns the configured client using the original map
-// key casing when selected matches exactly or has exactly one case-insensitive
-// match. Ambiguous exact or folded matches are rejected.
-func lookupTorrentClientConfig(clients map[string]config.TorrentClientConfig, selected string) (string, config.TorrentClientConfig, bool) {
-	trimmed := strings.TrimSpace(selected)
-	if trimmed == "" {
-		return "", config.TorrentClientConfig{}, false
-	}
-
-	exactMatches := make([]string, 0, 1)
-	foldMatches := make([]string, 0, 1)
-	for name := range clients {
-		nameTrimmed := strings.TrimSpace(name)
-		if nameTrimmed == trimmed {
-			exactMatches = append(exactMatches, name)
-			continue
-		}
-		if strings.EqualFold(nameTrimmed, trimmed) {
-			foldMatches = append(foldMatches, name)
-		}
-	}
-
-	switch len(exactMatches) {
-	case 1:
-		name := exactMatches[0]
-		return name, clients[name], true
-	case 0:
-	default:
-		return "", config.TorrentClientConfig{}, false
-	}
-
-	if len(foldMatches) == 1 {
-		name := foldMatches[0]
-		return name, clients[name], true
-	}
-	return "", config.TorrentClientConfig{}, false
-}
-
-// withURLCapableInjectFallback replaces empty or URL-incompatible global/default
-// selections with configured qbit/qui clients for URL-only injection. The
-// original selection is not merged into the fallback set, so unsupported client
-// types cannot fail an otherwise valid URL fallback. Selected none/disabled
-// clients are authoritative and suppress fallback fanout.
-func withURLCapableInjectFallback(selected, configured map[string]config.TorrentClientConfig) map[string]config.TorrentClientConfig {
-	if hasDisabledTorrentClient(selected) {
-		return selected
-	}
-	if hasURLCapableTorrentClient(selected) {
-		return selected
-	}
-
-	fallback := urlCapableTorrentClients(configured)
-	if len(fallback) == 0 {
-		return selected
-	}
-
-	return maps.Clone(fallback)
-}
-
-// hasDisabledTorrentClient reports whether the selected set explicitly disables
-// injection, which must not fan out into fallback clients.
-func hasDisabledTorrentClient(clients map[string]config.TorrentClientConfig) bool {
-	for _, client := range clients {
-		switch strings.ToLower(strings.TrimSpace(client.ClientType())) {
-		case "none", "disabled":
-			return true
-		}
-	}
-	return false
-}
-
-// hasURLCapableTorrentClient reports whether any selected client type can add a
-// torrent by URL.
-func hasURLCapableTorrentClient(clients map[string]config.TorrentClientConfig) bool {
-	for _, client := range clients {
-		if isURLCapableTorrentClient(client) {
-			return true
-		}
-	}
-	return false
-}
-
-// urlCapableTorrentClients returns every configured client that can add a
-// torrent by URL and permits fallback fanout.
-func urlCapableTorrentClients(clients map[string]config.TorrentClientConfig) map[string]config.TorrentClientConfig {
-	matches := make(map[string]config.TorrentClientConfig)
-	for name, client := range clients {
-		if client.FallbackAllowed() && isURLCapableTorrentClient(client) {
-			matches[name] = client
-		}
-	}
-	if len(matches) == 0 {
-		return nil
-	}
-	return matches
-}
-
-// isURLCapableTorrentClient reports whether a client type supports URL adds.
-func isURLCapableTorrentClient(client config.TorrentClientConfig) bool {
-	switch strings.ToLower(strings.TrimSpace(client.ClientType())) {
-	case "qbit", "qbittorrent", "qui":
-		return true
-	default:
-		return false
-	}
-}
-
-func applyClientOverrides(client config.TorrentClientConfig, overrides api.ClientOverrides) config.TorrentClientConfig {
-	if overrides.QbitCategory != nil {
-		client.Category = strings.TrimSpace(*overrides.QbitCategory)
-		client.QbitCategoryValue = strings.TrimSpace(*overrides.QbitCategory)
-	}
-	if overrides.QbitTag != nil {
-		trimmed := strings.TrimSpace(*overrides.QbitTag)
-		client.Tags = nil
-		client.QbitTagsValue = nil
-		client.QbitTag = trimmed
-	}
-	return client
-}
diff --git a/internal/clients/service_test.go b/internal/clients/service_test.go
deleted file mode 100644
index f599dfd1..00000000
--- a/internal/clients/service_test.go
+++ /dev/null
@@ -1,3110 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package clients
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type qbitAddCapture struct {
-	errCh        chan error
-	mu           sync.Mutex
-	addCalls     int
-	category     string
-	savePath     string
-	tags         string
-	autoTMM      string
-	skipChecking string
-}
-
-func newQbitAddCaptureServer(t *testing.T) (*httptest.Server, *qbitAddCapture) {
-	t.Helper()
-
-	capture := &qbitAddCapture{errCh: make(chan error, 1)}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
-				if err := r.ParseMultipartForm(10 << 20); err != nil {
-					capture.errCh <- err
-					w.WriteHeader(http.StatusBadRequest)
-					return
-				}
-			} else if err := r.ParseForm(); err != nil {
-				capture.errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			capture.mu.Lock()
-			capture.addCalls++
-			capture.category = r.FormValue("category")
-			capture.savePath = r.FormValue("savepath")
-			capture.tags = r.FormValue("tags")
-			capture.autoTMM = r.FormValue("autoTMM")
-			capture.skipChecking = r.FormValue("skip_checking")
-			capture.mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	t.Cleanup(server.Close)
-	return server, capture
-}
-
-func TestInjectWatchFolder(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	watch := filepath.Join(dir, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	torrentPath := filepath.Join(dir, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	copied := filepath.Join(watch, filepath.Base(torrentPath))
-	if _, err := os.Stat(copied); err != nil {
-		t.Fatalf("expected copied torrent: %v", err)
-	}
-}
-
-func TestInjectUnsupportedType(t *testing.T) {
-	t.Parallel()
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"rtorrent": {Type: "rtorrent", URL: "http://localhost"},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: "/tmp/file.torrent"})
-	if !errors.Is(err, internalerrors.ErrNotImplemented) {
-		t.Fatalf("expected not implemented error, got %v", err)
-	}
-}
-
-func TestInjectQbitClient(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	loginCalled := false
-	addCalled := false
-	var addCategory string
-	var addTags string
-	var addSkipChecking string
-	var addAutoTMM string
-	var fileCount int
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			mu.Lock()
-			loginCalled = true
-			mu.Unlock()
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCalled = true
-			addCategory = r.FormValue("category")
-			addTags = r.FormValue("tags")
-			addSkipChecking = r.FormValue("skip_checking")
-			addAutoTMM = r.FormValue("autoTMM")
-			if files, ok := r.MultipartForm.File["torrents"]; ok {
-				fileCount = len(files)
-			}
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-				Category: "ua",
-				Tags:     []string{"tag1", "tag2"},
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !loginCalled {
-		t.Fatalf("expected qbit login call")
-	}
-	if !addCalled {
-		t.Fatalf("expected qbit add call")
-	}
-	if addCategory != "ua" {
-		t.Fatalf("expected category ua, got %q", addCategory)
-	}
-	if addTags != "tag1,tag2" {
-		t.Fatalf("expected tags tag1,tag2, got %q", addTags)
-	}
-	if addSkipChecking != "true" {
-		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
-	}
-	if addAutoTMM != "false" {
-		t.Fatalf("expected autoTMM false, got %q", addAutoTMM)
-	}
-	if fileCount != 1 {
-		t.Fatalf("expected 1 torrent file, got %d", fileCount)
-	}
-}
-
-func TestInjectQbitClientRejectsCookieBearingNonOKLogin(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalls := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			http.SetCookie(w, &http.Cookie{Name: "SID", Value: "transient-session"})
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Try again."))
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalls++
-			mu.Unlock()
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	torrentPath := filepath.Join(t.TempDir(), "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "Example.Release.2026.mkv"}, api.TorrentResult{Path: torrentPath})
-	if err == nil {
-		t.Fatal("expected cookie-bearing non-Ok login rejection")
-	}
-	if !strings.Contains(err.Error(), "qbit login") {
-		t.Fatal("expected qbit login error")
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	if addCalls != 0 {
-		t.Fatalf("expected no qbit add attempt, got %d", addCalls)
-	}
-}
-
-func TestQbitInjectClientConfigCapsTimeoutAndRetries(t *testing.T) {
-	t.Parallel()
-
-	cfg := qbitInjectClientConfig("http://localhost:8080", "user", "pass", config.TorrentClientConfig{})
-	if cfg.Timeout != int(qbitInjectHTTPTimeout/time.Second) {
-		t.Fatalf("expected timeout %d, got %d", int(qbitInjectHTTPTimeout/time.Second), cfg.Timeout)
-	}
-	if cfg.RetryAttempts != qbitInjectHTTPRetryAttempts {
-		t.Fatalf("expected retry attempts %d, got %d", qbitInjectHTTPRetryAttempts, cfg.RetryAttempts)
-	}
-}
-
-func TestQbitAutomaticManagementEnabledUsesPathBoundaries(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	tests := []struct {
-		name       string
-		sourcePath string
-		configured string
-		want       bool
-	}{
-		{
-			name:       "configured root",
-			sourcePath: filepath.Join(root, "video.mkv"),
-			configured: root,
-			want:       true,
-		},
-		{
-			name:       "configured root child",
-			sourcePath: filepath.Join(root, "child", "video.mkv"),
-			configured: root,
-			want:       true,
-		},
-		{
-			name:       "sibling prefix",
-			sourcePath: filepath.Join(root+"-old", "video.mkv"),
-			configured: root,
-			want:       false,
-		},
-		{
-			name:       "case variant directory",
-			sourcePath: filepath.Join(root, "media", "video.mkv"),
-			configured: filepath.Join(root, "Media"),
-			want:       runtime.GOOS == "windows",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			meta := api.PreparedMetadata{SourcePath: tt.sourcePath}
-			if got := qbitAutomaticManagementEnabled(meta, config.StringList{tt.configured}); got != tt.want {
-				t.Fatalf("qbitAutomaticManagementEnabled() = %t, want %t", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestInjectQbitClientUsesPathMappingSavePath(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-
-	root := t.TempDir()
-	localRoot := filepath.Join(root, "local")
-	releaseDir := filepath.Join(localRoot, "Movies", "Fixture.Title.2024")
-	if err := os.MkdirAll(releaseDir, 0o700); err != nil {
-		t.Fatalf("mkdir release: %v", err)
-	}
-	source := filepath.Join(releaseDir, "video.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	remoteRoot := "/remote/media"
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:                     "qbit",
-				URL:                      server.URL,
-				Username:                 "user",
-				Password:                 "pass",
-				LocalPath:                config.StringList{"", localRoot},
-				RemotePath:               config.StringList{"/wrong/root", remoteRoot},
-				AutomaticManagementPaths: config.StringList{localRoot},
-			},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: source, FileList: []string{source}}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	wantSavePath := "/remote/media/Movies/Fixture.Title.2024/"
-	if capture.savePath != wantSavePath {
-		t.Fatalf("expected mapped savepath %q, got %q", wantSavePath, capture.savePath)
-	}
-	if capture.autoTMM != "true" {
-		t.Fatalf("expected autoTMM true, got %q", capture.autoTMM)
-	}
-}
-
-func TestInjectQbitClientUsesPathMappingSavePathWithoutSourceStat(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-
-	root := t.TempDir()
-	localRoot := filepath.Join(root, "local")
-	source := filepath.Join(localRoot, "Movies", "Fixture.Title.2024", "video.mkv")
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	remoteRoot := "/remote/media"
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:       "qbit",
-				URL:        server.URL,
-				Username:   "user",
-				Password:   "pass",
-				LocalPath:  config.StringList{localRoot},
-				RemotePath: config.StringList{remoteRoot},
-			},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: source, FileList: []string{source}}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	wantSavePath := "/remote/media/Movies/Fixture.Title.2024/"
-	if capture.savePath != wantSavePath {
-		t.Fatalf("expected mapped savepath %q, got %q", wantSavePath, capture.savePath)
-	}
-}
-
-func TestMappedRemotePathPreservesBlankPathPairAlignment(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	localRoot := filepath.Join(root, "local")
-	otherRoot := filepath.Join(root, "other")
-	source := filepath.Join(localRoot, "Movies", "Fixture.Title.2024", "video.mkv")
-
-	tests := []struct {
-		name    string
-		locals  config.StringList
-		remotes config.StringList
-	}{
-		{
-			name:    "blank local path",
-			locals:  config.StringList{"", localRoot},
-			remotes: config.StringList{"/wrong/root", "/remote/media"},
-		},
-		{
-			name:    "blank remote path",
-			locals:  config.StringList{otherRoot, localRoot},
-			remotes: config.StringList{"", "/remote/media"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, ok := mappedRemotePath(source, tt.locals, tt.remotes)
-			if !ok {
-				t.Fatal("expected mapped path")
-			}
-			want := filepath.Join("/remote/media", "Movies", "Fixture.Title.2024", "video.mkv")
-			if got != want {
-				t.Fatalf("expected mapped path %q, got %q", want, got)
-			}
-		})
-	}
-}
-
-func TestMappedRemotePathUsesMostSpecificRoot(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	linkedRoot := filepath.Join(root, "cross-seed")
-	source := filepath.Join(linkedRoot, "EXAMPLE", "Example.Release.2026.mkv")
-
-	got, ok := mappedRemotePath(
-		source,
-		config.StringList{root, linkedRoot},
-		config.StringList{"/remote/general", "/remote/cross-seed"},
-	)
-	if !ok {
-		t.Fatal("expected mapped path")
-	}
-	want := filepath.Join("/remote/cross-seed", "EXAMPLE", "Example.Release.2026.mkv")
-	if got != want {
-		t.Fatalf("expected most-specific mapped path %q, got %q", want, got)
-	}
-}
-
-func TestMappedRemotePathIsCaseInsensitiveOnWindows(t *testing.T) {
-	t.Parallel()
-
-	if runtime.GOOS != "windows" {
-		t.Skip("Windows path semantics")
-	}
-	root := t.TempDir()
-	source := filepath.Join(root, "CrossSeed", "EXAMPLE", "Example.Release.2026.mkv")
-	localRoot := strings.ToUpper(filepath.Join(root, "crossseed"))
-
-	got, ok := mappedRemotePath(source, config.StringList{localRoot}, config.StringList{"/remote/cross-seed"})
-	if !ok {
-		t.Fatal("expected case-insensitive mapped path")
-	}
-	want := filepath.Join("/remote/cross-seed", "EXAMPLE", "Example.Release.2026.mkv")
-	if got != want {
-		t.Fatalf("expected mapped path %q, got %q", want, got)
-	}
-}
-
-func TestInjectQbitClientUsesRequestOverrides(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	var addCategory string
-	var addTags string
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCategory = r.FormValue("category")
-			addTags = r.FormValue("tags")
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-				Category: "config-cat",
-				Tags:     []string{"config1", "config2"},
-			},
-		},
-	}, nil)
-
-	overrideCategory := "override-cat"
-	overrideTag := "override-tag"
-	meta := api.PreparedMetadata{
-		SourcePath: "video.mkv",
-		ClientOverrides: api.ClientOverrides{
-			QbitCategory: &overrideCategory,
-			QbitTag:      &overrideTag,
-		},
-	}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if addCategory != "override-cat" {
-		t.Fatalf("expected override category, got %q", addCategory)
-	}
-	if addTags != "override-tag" {
-		t.Fatalf("expected override tag, got %q", addTags)
-	}
-}
-
-func TestInjectQbitClientIgnoresCrossFieldsForNormalTorrent(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:              "qbit",
-				URL:               server.URL,
-				Username:          "user",
-				Password:          "pass",
-				Category:          "config-cat",
-				Tags:              []string{"config1", "config2"},
-				QbitCrossCategory: "cross-cat",
-				QbitCrossTag:      "cross-tag",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.category != "config-cat" {
-		t.Fatalf("expected config category, got %q", capture.category)
-	}
-	if capture.tags != "config1,config2" {
-		t.Fatalf("expected config tags, got %q", capture.tags)
-	}
-}
-
-func TestInjectQbitClientUsesCrossFieldsForCrossSeedTorrent(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:              "qbit",
-				URL:               server.URL,
-				Username:          "user",
-				Password:          "pass",
-				Category:          "config-cat",
-				Tags:              []string{"config1", "config2"},
-				QbitCrossCategory: "cross-cat",
-				QbitCrossTag:      "cross-tag",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER", CrossSeed: true}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.category != "cross-cat" {
-		t.Fatalf("expected cross category, got %q", capture.category)
-	}
-	if capture.tags != "cross-tag" {
-		t.Fatalf("expected cross tag, got %q", capture.tags)
-	}
-}
-
-func newQbitAddFailureServer(t *testing.T) (*httptest.Server, *qbitAddCapture) {
-	t.Helper()
-
-	capture := &qbitAddCapture{}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
-				if err := r.ParseMultipartForm(10 << 20); err != nil {
-					w.WriteHeader(http.StatusBadRequest)
-					return
-				}
-			} else {
-				if err := r.ParseForm(); err != nil {
-					w.WriteHeader(http.StatusBadRequest)
-					return
-				}
-			}
-			capture.mu.Lock()
-			capture.addCalls++
-			capture.mu.Unlock()
-			w.WriteHeader(http.StatusInternalServerError)
-			_, _ = w.Write([]byte("Fails."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	t.Cleanup(server.Close)
-	return server, capture
-}
-
-func TestInjectQbitClientCleansStagingAfterLoginFailure(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/v2/auth/login" {
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-		w.WriteHeader(http.StatusUnauthorized)
-		_, _ = w.Write([]byte("Fails."))
-	}))
-	t.Cleanup(server.Close)
-
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"EXAMPLE": {LinkDirName: "example-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
-	if err == nil {
-		t.Fatal("expected qbit login failure")
-	}
-
-	stagingDir := filepath.Join(linkRoot, "example-links")
-	if _, statErr := os.Stat(stagingDir); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected login failure to remove staging, stat err=%v", statErr)
-	}
-}
-
-func TestInjectQbitClientCleansStagingAfterFileAddFailure(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddFailureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"EXAMPLE": {LinkDirName: "example-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
-	if err == nil {
-		t.Fatal("expected qbit add failure")
-	}
-	capture.mu.Lock()
-	addCalls := capture.addCalls
-	capture.mu.Unlock()
-	if addCalls != 1 {
-		t.Fatalf("expected one qbit add attempt, got %d", addCalls)
-	}
-
-	stagedPath := filepath.Join(linkRoot, "example-links", filepath.Base(source))
-	if _, statErr := os.Stat(stagedPath); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected staged file cleanup, stat err=%v", statErr)
-	}
-	if _, statErr := os.Stat(filepath.Join(linkRoot, "example-links")); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected tracker staging dir cleanup, stat err=%v", statErr)
-	}
-}
-
-func TestInjectQbitClientURLLinkingFallsBackWithoutStaging(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{URL: "https://tracker.example/torrent/1", Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject URL fallback: %v", err)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	stagedPath := filepath.Join(linkRoot, "aither-links", filepath.Base(source))
-	if _, statErr := os.Stat(stagedPath); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected URL-only injection not to stage files, stat err=%v", statErr)
-	}
-	if _, statErr := os.Stat(filepath.Join(linkRoot, "aither-links")); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected URL-only injection not to create tracker staging, stat err=%v", statErr)
-	}
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.addCalls != 1 {
-		t.Fatalf("expected one qbit add attempt, got %d", capture.addCalls)
-	}
-	if capture.skipChecking != "true" {
-		t.Fatalf("expected URL fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
-	}
-}
-
-func TestInjectQbitClientInvalidLinkPlanFallbackSkipsHashCheck(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "Example.Release.2026.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "invalid.torrent")
-	if err := os.WriteFile(torrentPath, []byte("invalid metainfo"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{
-		SourcePath: source,
-		FileList:   []string{source},
-	}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
-	if err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.savePath != "" {
-		t.Fatalf("expected original-path fallback, got savepath %q", capture.savePath)
-	}
-	if capture.skipChecking != "true" {
-		t.Fatalf("expected fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
-	}
-}
-
-func TestInjectQbitClientHardlinksSourceAndUsesLinkedSavePath(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	var addSavePath string
-	var addTags string
-	var addAutoTMM string
-	var addSkipChecking string
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addSavePath = r.FormValue("savepath")
-			addTags = r.FormValue("tags")
-			addAutoTMM = r.FormValue("autoTMM")
-			addSkipChecking = r.FormValue("skip_checking")
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	torrentRoot := "Tracker.Name.2026.mkv"
-	writeQbitTestTorrent(t, torrentPath, torrentRoot, map[string]string{"source": source}, false)
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:                     "qbit",
-				URL:                      server.URL,
-				Username:                 "user",
-				Password:                 "pass",
-				Linking:                  "hardlink",
-				LinkedFolder:             config.StringList{linkRoot},
-				LocalPath:                config.StringList{root},
-				RemotePath:               config.StringList{"/remote/root"},
-				AutomaticManagementPaths: config.StringList{root},
-				UseTrackerAsTag:          true,
-			},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: source, FileList: []string{source}}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	linkedSource := filepath.Join(linkRoot, "aither-links", torrentRoot)
-	sourceInfo, err := os.Stat(source)
-	if err != nil {
-		t.Fatalf("stat source: %v", err)
-	}
-	linkedInfo, err := os.Stat(linkedSource)
-	if err != nil {
-		t.Fatalf("stat linked source: %v", err)
-	}
-	if !os.SameFile(sourceInfo, linkedInfo) {
-		t.Fatalf("expected linked file to share source file identity")
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	wantSavePath := "/remote/root/links/aither-links/"
-	if addSavePath != wantSavePath {
-		t.Fatalf("expected savepath %q, got %q", wantSavePath, addSavePath)
-	}
-	if addTags != "AITHER" {
-		t.Fatalf("expected tracker tag, got %q", addTags)
-	}
-	if addAutoTMM != "false" {
-		t.Fatalf("expected linked injection autoTMM false, got %q", addAutoTMM)
-	}
-	if addSkipChecking != "true" {
-		t.Fatalf("expected linked injection to skip hash checking, got skip_checking=%q", addSkipChecking)
-	}
-}
-
-func TestInjectQbitClientRejectsUnmappedLinkedSavePath(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	mediaRoot := filepath.Join(root, "media")
-	if err := os.MkdirAll(mediaRoot, 0o700); err != nil {
-		t.Fatalf("mkdir media: %v", err)
-	}
-	source := filepath.Join(mediaRoot, "Example.Release.2026.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "cross-seed")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"EXAMPLE": {LinkDirName: "example-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-				LocalPath:    config.StringList{mediaRoot},
-				RemotePath:   config.StringList{"/remote/media"},
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
-	if err == nil || !strings.Contains(err.Error(), "outside configured local_path roots") {
-		t.Fatal("expected linked staging path mapping error")
-	}
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.addCalls != 0 {
-		t.Fatal("expected mapping failure to prevent qBittorrent add")
-	}
-	if _, statErr := os.Stat(filepath.Join(linkRoot, "example-links")); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatal("expected mapping failure not to create tracker staging")
-	}
-}
-
-func TestInjectQbitClientRejectsUnsafeTrackerLinkDirName(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: filepath.Join("..", "escape")},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"})
-	if !errors.Is(err, internalerrors.ErrInvalidInput) {
-		t.Fatalf("expected invalid input for unsafe link dir name, got %v", err)
-	}
-	if _, statErr := os.Stat(filepath.Join(root, "escape")); !errors.Is(statErr, os.ErrNotExist) {
-		t.Fatalf("expected no escaped tracker directory, stat err=%v", statErr)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-}
-
-func TestInjectQbitClientRejectsStaleExistingHardlinkDest(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("fresh"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	trackerDir := filepath.Join(linkRoot, "aither-links")
-	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	dest := filepath.Join(trackerDir, filepath.Base(source))
-	if err := os.WriteFile(dest, []byte("stale"), 0o600); err != nil {
-		t.Fatalf("write stale dest: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-	allowFallback := false
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:          "qbit",
-				URL:           server.URL,
-				Username:      "user",
-				Password:      "pass",
-				Linking:       "hardlink",
-				LinkedFolder:  config.StringList{linkRoot},
-				AllowFallback: &allowFallback,
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"})
-	if !errors.Is(err, internalerrors.ErrInvalidInput) {
-		t.Fatalf("expected stale link dest to fail with invalid input, got %v", err)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-}
-
-func TestInjectQbitClientFailedLinkPlanFallbackSkipsHashCheck(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("fresh"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	trackerDir := filepath.Join(linkRoot, "example-links")
-	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	dest := filepath.Join(trackerDir, filepath.Base(source))
-	if err := os.WriteFile(dest, []byte("stale"), 0o600); err != nil {
-		t.Fatalf("write stale dest: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"EXAMPLE": {LinkDirName: "example-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"}); err != nil {
-		t.Fatalf("inject failed-link fallback: %v", err)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	if capture.addCalls != 1 {
-		t.Fatalf("expected one qbit add attempt, got %d", capture.addCalls)
-	}
-	if capture.savePath != "" {
-		t.Fatalf("expected original-path fallback, got savepath %q", capture.savePath)
-	}
-	if capture.skipChecking != "true" {
-		t.Fatalf("expected failed-link fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
-	}
-}
-
-func TestInjectQbitClientAllowsMatchingExistingHardlinkDest(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "links")
-	trackerDir := filepath.Join(linkRoot, "aither-links")
-	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	dest := filepath.Join(trackerDir, filepath.Base(source))
-	if err := os.Link(source, dest); err != nil {
-		t.Fatalf("precreate hardlink dest: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "hardlink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	wantSavePath := filepath.ToSlash(filepath.Join(linkRoot, "aither-links")) + "/"
-	if capture.savePath != wantSavePath {
-		t.Fatalf("expected savepath %q, got %q", wantSavePath, capture.savePath)
-	}
-}
-
-func TestInjectQbitClientTriesLaterLinkedFolderAfterFirstFails(t *testing.T) {
-	t.Parallel()
-
-	server, capture := newQbitAddCaptureServer(t)
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	firstLinkRoot := filepath.Join(root, "links-first")
-	secondLinkRoot := filepath.Join(root, "links-second")
-	firstTrackerDir := filepath.Join(firstLinkRoot, "aither-links")
-	if err := os.MkdirAll(firstTrackerDir, 0o700); err != nil {
-		t.Fatalf("mkdir first links: %v", err)
-	}
-	if err := os.MkdirAll(secondLinkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir second links: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(firstTrackerDir, filepath.Base(source)), []byte("stale"), 0o600); err != nil {
-		t.Fatalf("write stale first dest: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-	allowFallback := false
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-links"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:          "qbit",
-				URL:           server.URL,
-				Username:      "user",
-				Password:      "pass",
-				Linking:       "hardlink",
-				LinkedFolder:  config.StringList{firstLinkRoot, secondLinkRoot},
-				AllowFallback: &allowFallback,
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-	select {
-	case err := <-capture.errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-	capture.mu.Lock()
-	defer capture.mu.Unlock()
-	wantSavePath := filepath.ToSlash(filepath.Join(secondLinkRoot, "aither-links")) + "/"
-	if capture.savePath != wantSavePath {
-		t.Fatalf("expected second linked folder savepath %q, got %q", wantSavePath, capture.savePath)
-	}
-}
-
-func TestLinkedFolderCandidatesWindowsSymlinkDoesNotRepeatSameVolumeFolders(t *testing.T) {
-	t.Parallel()
-
-	if runtime.GOOS != "windows" {
-		t.Skip("windows-specific symlink ordering")
-	}
-
-	root := t.TempDir()
-	source := filepath.Join(root, "source.mkv")
-	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	firstLinkRoot := filepath.Join(root, "links-first")
-	secondLinkRoot := filepath.Join(root, "links-second")
-	if err := os.MkdirAll(firstLinkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir first links: %v", err)
-	}
-	if err := os.MkdirAll(secondLinkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir second links: %v", err)
-	}
-
-	got, err := linkedFolderCandidates(source, []string{firstLinkRoot, secondLinkRoot}, "symlink")
-	if err != nil {
-		t.Fatalf("linked folder candidates: %v", err)
-	}
-
-	wantFirst, err := absLocalPath("first linked folder", firstLinkRoot)
-	if err != nil {
-		t.Fatalf("first linked folder abs path: %v", err)
-	}
-	wantSecond, err := absLocalPath("second linked folder", secondLinkRoot)
-	if err != nil {
-		t.Fatalf("second linked folder abs path: %v", err)
-	}
-
-	if len(got) != 2 {
-		t.Fatalf("expected 2 unique candidates, got %d (%v)", len(got), got)
-	}
-	if got[0] != wantFirst || got[1] != wantSecond {
-		t.Fatalf("expected ordered unique candidates [%q %q], got %v", wantFirst, wantSecond, got)
-	}
-}
-
-func TestInjectQbitClientReflinksSourceAndUsesLinkedSavePath(t *testing.T) {
-	var mu sync.Mutex
-	var addSavePath string
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addSavePath = r.FormValue("savepath")
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	source := filepath.Join(root, "release")
-	nested := filepath.Join(source, "disc")
-	if err := os.MkdirAll(nested, 0o700); err != nil {
-		t.Fatalf("mkdir source: %v", err)
-	}
-	sourceFile := filepath.Join(nested, "movie.mkv")
-	if err := os.WriteFile(sourceFile, []byte("media"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	linkRoot := filepath.Join(root, "reflinks")
-	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
-		t.Fatalf("mkdir links: %v", err)
-	}
-	torrentPath := filepath.Join(root, "sample.torrent")
-	writeQbitTestTorrentForSource(t, torrentPath, source)
-
-	originalCreateReflink := createReflink
-	var cloneCalls []string
-	createReflink = func(src, dst string) error {
-		cloneCalls = append(cloneCalls, src+"->"+dst)
-		data, err := os.ReadFile(src)
-		if err != nil {
-			return fmt.Errorf("read reflink source: %w", err)
-		}
-		return os.WriteFile(dst, data, 0o600)
-	}
-	t.Cleanup(func() { createReflink = originalCreateReflink })
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {LinkDirName: "aither-reflinks"},
-		}},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:         "qbit",
-				URL:          server.URL,
-				Username:     "user",
-				Password:     "pass",
-				Linking:      "reflink",
-				LinkedFolder: config.StringList{linkRoot},
-			},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: source}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	linkedFile := filepath.Join(linkRoot, "aither-reflinks", filepath.Base(source), "disc", filepath.Base(sourceFile))
-	if _, err := os.Stat(linkedFile); err != nil {
-		t.Fatalf("expected reflinked source file: %v", err)
-	}
-	if len(cloneCalls) != 1 {
-		t.Fatalf("expected 1 reflink call, got %d (%v)", len(cloneCalls), cloneCalls)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	wantSavePath := filepath.ToSlash(filepath.Join(linkRoot, "aither-reflinks")) + "/"
-	if addSavePath != wantSavePath {
-		t.Fatalf("expected savepath %q, got %q", wantSavePath, addSavePath)
-	}
-}
-
-func TestInjectUsesSelectedClientOverride(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	firstWatch := filepath.Join(watchRoot, "first")
-	secondWatch := filepath.Join(watchRoot, "second")
-	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
-		t.Fatalf("mkdir first: %v", err)
-	}
-	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
-		t.Fatalf("mkdir second: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"first":  {Type: "watch", WatchFolder: firstWatch},
-			"second": {Type: "watch", WatchFolder: secondWatch},
-		},
-	}, nil)
-
-	selectedClient := "second"
-	meta := api.PreparedMetadata{
-		SourcePath: "video.mkv",
-		ClientOverrides: api.ClientOverrides{
-			Client: &selectedClient,
-		},
-	}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected first client untouched, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected second client copy, got %v", err)
-	}
-}
-
-func TestInjectUsesDefaultClientWhenNoInjectionListOrTrackerClient(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	defaultWatch := filepath.Join(watchRoot, "default")
-	otherWatch := filepath.Join(watchRoot, "other")
-	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
-		t.Fatalf("mkdir default: %v", err)
-	}
-	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
-		t.Fatalf("mkdir other: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "default",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"default": {Type: "watch", WatchFolder: defaultWatch},
-			"other":   {Type: "watch", WatchFolder: otherWatch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected default client copy, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected other client untouched, got %v", err)
-	}
-}
-
-func TestInjectUsesMultipleInjectionClients(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	firstWatch := filepath.Join(watchRoot, "first")
-	secondWatch := filepath.Join(watchRoot, "second")
-	thirdWatch := filepath.Join(watchRoot, "third")
-	for _, dir := range []string{firstWatch, secondWatch, thirdWatch} {
-		if err := os.MkdirAll(dir, 0o700); err != nil {
-			t.Fatalf("mkdir %s: %v", dir, err)
-		}
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "first",
-			InjectClients: config.CSVList{"second", "third"},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"first":  {Type: "watch", WatchFolder: firstWatch},
-			"second": {Type: "watch", WatchFolder: secondWatch},
-			"third":  {Type: "watch", WatchFolder: thirdWatch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected default client untouched, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected second client copy, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(thirdWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected third client copy, got %v", err)
-	}
-}
-
-func TestInjectUsesSingleInjectionClientBeforeDefaultClient(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	defaultWatch := filepath.Join(watchRoot, "default")
-	otherWatch := filepath.Join(watchRoot, "other")
-	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
-		t.Fatalf("mkdir default: %v", err)
-	}
-	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
-		t.Fatalf("mkdir other: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "default",
-			InjectClients: config.CSVList{"other"},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"default": {Type: "watch", WatchFolder: defaultWatch},
-			"other":   {Type: "watch", WatchFolder: otherWatch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected default client untouched, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected single injection client copy, got %v", err)
-	}
-}
-
-func TestInjectSkipsDefaultClientWhenInjectionClientUnknown(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	defaultWatch := filepath.Join(watchRoot, "default")
-	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
-		t.Fatalf("mkdir default: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "default",
-			InjectClients: config.CSVList{"missing"},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"default": {Type: "watch", WatchFolder: defaultWatch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected unknown injection selector to skip default fallback, got %v", err)
-	}
-}
-
-func TestInjectSkipsImplicitSingleClientWhenDefaultClientUnknown(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir watch: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "missing",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected unknown default selector to skip implicit fallback, got %v", err)
-	}
-}
-
-func TestInjectUnknownExplicitClientOverrideSkipsImplicitFallback(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir watch: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	missing := "missing"
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{
-		SourcePath: "video.mkv",
-		ClientOverrides: api.ClientOverrides{
-			Client: &missing,
-		},
-	}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected explicit unknown override to skip fallback, got %v", err)
-	}
-}
-
-func TestInjectUsesTrackerTorrentClient(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	firstWatch := filepath.Join(watchRoot, "first")
-	secondWatch := filepath.Join(watchRoot, "second")
-	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
-		t.Fatalf("mkdir first: %v", err)
-	}
-	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
-		t.Fatalf("mkdir second: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {TorrentClient: "second"},
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"first":  {Type: "watch", WatchFolder: firstWatch},
-			"second": {Type: "watch", WatchFolder: secondWatch},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: "video.mkv"}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "aither"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected first client untouched, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected second client copy, got %v", err)
-	}
-}
-
-func TestInjectClientOverrideWinsOverTrackerTorrentClient(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	firstWatch := filepath.Join(watchRoot, "first")
-	secondWatch := filepath.Join(watchRoot, "second")
-	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
-		t.Fatalf("mkdir first: %v", err)
-	}
-	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
-		t.Fatalf("mkdir second: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {TorrentClient: "second"},
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"first":  {Type: "watch", WatchFolder: firstWatch},
-			"second": {Type: "watch", WatchFolder: secondWatch},
-		},
-	}, nil)
-
-	selectedClient := "first"
-	meta := api.PreparedMetadata{
-		SourcePath: "video.mkv",
-		ClientOverrides: api.ClientOverrides{
-			Client: &selectedClient,
-		},
-	}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected first client copy, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected second client untouched, got %v", err)
-	}
-}
-
-func TestInjectTrackerTorrentClientURLOnlyWatchReturnsErrorWithoutFallback(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {TorrentClient: "watch"},
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{
-		URL:     "https://aither.cc/torrent/download/374352.382",
-		Tracker: "aither",
-	})
-	if !errors.Is(err, internalerrors.ErrInvalidInput) {
-		t.Fatalf("expected invalid input error, got %v", err)
-	}
-
-	entries, err := os.ReadDir(watch)
-	if err != nil {
-		t.Fatalf("read watch folder: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	if addCalled {
-		t.Fatalf("did not expect tracker-selected watch client to fall back to qbit")
-	}
-}
-
-func TestInjectTrackerTorrentClientCanSelectClientNamedNone(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	noneWatch := filepath.Join(watchRoot, "none")
-	otherWatch := filepath.Join(watchRoot, "other")
-	if err := os.MkdirAll(noneWatch, 0o700); err != nil {
-		t.Fatalf("mkdir none: %v", err)
-	}
-	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
-		t.Fatalf("mkdir other: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {TorrentClient: "none"},
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"none":  {Type: "watch", WatchFolder: noneWatch},
-			"other": {Type: "watch", WatchFolder: otherWatch},
-		},
-	}, nil)
-
-	meta := api.PreparedMetadata{SourcePath: "video.mkv"}
-	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(noneWatch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected none client copy, got %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected other client untouched, got %v", err)
-	}
-}
-
-func TestSelectTorrentClientsRejectsAmbiguousCaseInsensitiveNames(t *testing.T) {
-	t.Parallel()
-
-	clients := map[string]config.TorrentClientConfig{
-		"Qbit": {Type: "watch"},
-		"qbit": {Type: "qbit"},
-	}
-
-	matches := selectTorrentClients(clients, []string{"QBIT"})
-	if len(matches) != 0 {
-		t.Fatalf("expected ambiguous case-insensitive selector to be ignored, got %v", matches)
-	}
-
-	matches = selectTorrentClients(clients, []string{"qbit"})
-	if len(matches) != 1 {
-		t.Fatalf("expected exact selector match, got %v", matches)
-	}
-	if _, ok := matches["qbit"]; !ok {
-		t.Fatalf("expected exact lower-case client match, got %v", matches)
-	}
-
-	matches = selectTorrentClients(clients, []string{"QBIT", "qbit"})
-	if len(matches) != 1 {
-		t.Fatalf("expected later exact selector after ambiguous selector, got %v", matches)
-	}
-	if _, ok := matches["qbit"]; !ok {
-		t.Fatalf("expected exact lower-case client match after ambiguous selector, got %v", matches)
-	}
-}
-
-func TestSelectTorrentClientsDeduplicatesNormalizedSelectors(t *testing.T) {
-	t.Parallel()
-
-	clients := map[string]config.TorrentClientConfig{
-		"qbit": {Type: "qbit"},
-	}
-
-	matches := selectTorrentClients(clients, []string{"qbit", " QBIT ", "qbit"})
-	if len(matches) != 1 {
-		t.Fatalf("expected duplicate selector variants to select one client, got %v", matches)
-	}
-	if _, ok := matches["qbit"]; !ok {
-		t.Fatalf("expected qbit match, got %v", matches)
-	}
-}
-
-func TestSelectTorrentClientsKeepsExactCaseVariantClients(t *testing.T) {
-	t.Parallel()
-
-	clients := map[string]config.TorrentClientConfig{
-		"Qbit": {Type: "watch"},
-		"qbit": {Type: "qbit"},
-	}
-
-	matches := selectTorrentClients(clients, []string{"Qbit", "qbit"})
-	if len(matches) != 2 {
-		t.Fatalf("expected both exact case-variant clients, got %v", matches)
-	}
-	if _, ok := matches["Qbit"]; !ok {
-		t.Fatalf("expected exact upper-case client match, got %v", matches)
-	}
-	if _, ok := matches["qbit"]; !ok {
-		t.Fatalf("expected exact lower-case client match, got %v", matches)
-	}
-}
-
-func TestInjectDisabledClient(t *testing.T) {
-	t.Parallel()
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"disabled": {Type: "none"},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: "/tmp/file.torrent"}); err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-}
-
-func TestInjectQuiProxyClient(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	loginCalled := false
-	addCalled := false
-	var fileCount int
-	var addSkipChecking string
-	proxyPrefix := "/proxy/abc123"
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case proxyPrefix + "/api/v2/auth/login":
-			mu.Lock()
-			loginCalled = true
-			mu.Unlock()
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case proxyPrefix + "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCalled = true
-			addSkipChecking = r.FormValue("skip_checking")
-			if files, ok := r.MultipartForm.File["torrents"]; ok {
-				fileCount = len(files)
-			}
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:        "qbit",
-				QuiProxyURL: server.URL + proxyPrefix,
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if loginCalled {
-		t.Fatalf("did not expect qbit login call")
-	}
-	if !addCalled {
-		t.Fatalf("expected qbit add call")
-	}
-	if addSkipChecking != "true" {
-		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
-	}
-	if fileCount != 1 {
-		t.Fatalf("expected 1 torrent file, got %d", fileCount)
-	}
-}
-
-func TestInjectWatchFolderTempTorrent(t *testing.T) {
-	t.Parallel()
-
-	patterns := []string{
-		filepath.Join(os.TempDir(), "*.torrent"),
-		filepath.Join(os.TempDir(), "**", "*.torrent"),
-	}
-	var torrentPath string
-	for _, pattern := range patterns {
-		matches, err := filepath.Glob(pattern)
-		if err != nil {
-			continue
-		}
-		if len(matches) > 0 {
-			torrentPath = matches[0]
-			break
-		}
-	}
-	if torrentPath == "" {
-		t.Skip("no .torrent files found in temp directory")
-	}
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	copied := filepath.Join(watch, filepath.Base(torrentPath))
-	if _, err := os.Stat(copied); err != nil {
-		t.Fatalf("expected copied torrent: %v", err)
-	}
-}
-
-func TestInjectQbitClientFromURL(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	loginCalled := false
-	addCalled := false
-	var addedURLs string
-	var addSkipChecking string
-	var fileCount int
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			mu.Lock()
-			loginCalled = true
-			mu.Unlock()
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseForm(); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCalled = true
-			addedURLs = r.FormValue("urls")
-			addSkipChecking = r.FormValue("skip_checking")
-			fileCount = 0
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	injectURL := "https://aither.cc/torrent/download/374352.382"
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: injectURL, Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !loginCalled {
-		t.Fatalf("expected qbit login call")
-	}
-	if !addCalled {
-		t.Fatalf("expected qbit add call")
-	}
-	if addedURLs != injectURL {
-		t.Fatalf("expected injected URL %q, got %q", injectURL, addedURLs)
-	}
-	if addSkipChecking != "true" {
-		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
-	}
-	if fileCount != 0 {
-		t.Fatalf("expected 0 torrent files for URL add, got %d", fileCount)
-	}
-}
-
-func TestInjectQbitClientPrefersTorrentFileOverURL(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	var addedURLs string
-	var fileCount int
-	errCh := make(chan error, 1)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseMultipartForm(10 << 20); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCalled = true
-			addedURLs = r.FormValue("urls")
-			if r.MultipartForm != nil {
-				if files, ok := r.MultipartForm.File["torrents"]; ok {
-					fileCount = len(files)
-				}
-			}
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath, URL: "https://aither.cc/torrent/download/374352.382", Tracker: "AITHER"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit add call")
-	}
-	if fileCount != 1 {
-		t.Fatalf("expected 1 torrent file, got %d", fileCount)
-	}
-	if addedURLs != "" {
-		t.Fatalf("expected empty URL payload when path is provided, got %q", addedURLs)
-	}
-}
-
-func TestInjectURLSkipsWatchFolderClient(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "qbit",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	entries, err := os.ReadDir(watch)
-	if err != nil {
-		t.Fatalf("read watch folder: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectURLFallsBackToQbitWhenDefaultWatchCannotHandleURL(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "watch",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	entries, err := os.ReadDir(watch)
-	if err != nil {
-		t.Fatalf("read watch folder: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectURLFallbackIgnoresUnsupportedSelectedClient(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "rtorrent",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"rtorrent": {Type: "rtorrent"},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectURLDefaultDisabledDoesNotFallbackToQbit(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "disabled",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"disabled": {Type: "disabled"},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if addCalled {
-		t.Fatalf("did not expect disabled default client to fall back to qbit")
-	}
-}
-
-func TestInjectURLUnknownDefaultFallsBackToQbit(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "missing",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectURLUnknownInjectionListFallsBackToQbit(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "missing-default",
-			InjectClients: config.CSVList{
-				"missing-inject",
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectURLInjectionListDisabledDoesNotFallbackToQbit(t *testing.T) {
-	t.Parallel()
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "qbit",
-			InjectClients: config.CSVList{
-				"disabled",
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"disabled": {Type: "none"},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if addCalled {
-		t.Fatalf("did not expect disabled injection client to fall back to qbit")
-	}
-}
-
-func TestInjectURLFallbackSkipsQbitWhenFallbackDisallowed(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	allowFallback := false
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "watch",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:          "qbit",
-				URL:           server.URL,
-				Username:      "user",
-				Password:      "pass",
-				AllowFallback: &allowFallback,
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if addCalled {
-		t.Fatalf("did not expect qbit client with fallback disabled to receive URL fallback")
-	}
-}
-
-func TestInjectWatchFolderCopiesFileWhenURLAlsoPresent(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	torrentPath := filepath.Join(watchRoot, "sample.torrent")
-	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "watch",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{
-		Path: torrentPath,
-		URL:  "https://aither.cc/torrent/download/374352.382",
-	}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); err != nil {
-		t.Fatalf("expected watch client copy with file and URL, got %v", err)
-	}
-}
-
-func TestInjectURLFallbackSkipsWatchBeforeDelay(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCalled := false
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			mu.Lock()
-			addCalled = true
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			if flusher, ok := w.(http.Flusher); ok {
-				flusher.Flush()
-			}
-			go func() {
-				time.Sleep(100 * time.Millisecond)
-				cancel()
-			}()
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		PostUpload: config.PostUploadConfig{InjectDelay: 1},
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "watch",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	err := svc.Inject(ctx, api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"})
-	if err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !addCalled {
-		t.Fatalf("expected qbit URL add call")
-	}
-}
-
-func TestInjectCrossSeedURLFallbackPreservesQbitMetadata(t *testing.T) {
-	t.Parallel()
-
-	watchRoot := t.TempDir()
-	watch := filepath.Join(watchRoot, "watch")
-	if err := os.MkdirAll(watch, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-
-	var mu sync.Mutex
-	addCategory := ""
-	addTags := ""
-	errCh := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			if err := r.ParseForm(); err != nil {
-				errCh <- err
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-			mu.Lock()
-			addCategory = r.FormValue("category")
-			addTags = r.FormValue("tags")
-			mu.Unlock()
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		ClientSetup: config.ClientSetupConfig{
-			DefaultClient: "watch",
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"watch": {Type: "watch", WatchFolder: watch},
-			"qbit": {
-				Type:              "qbit",
-				URL:               server.URL,
-				Username:          "user",
-				Password:          "pass",
-				QbitCrossCategory: "cross-cat",
-				QbitCrossTag:      "cross-tag",
-			},
-		},
-	}, nil)
-
-	if err := svc.Inject(context.Background(), api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{
-		URL:       "https://aither.cc/torrent/download/374352.382",
-		Tracker:   "AITHER",
-		CrossSeed: true,
-	}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if addCategory != "cross-cat" {
-		t.Fatalf("expected cross category, got %q", addCategory)
-	}
-	if addTags != "cross-tag" {
-		t.Fatalf("expected cross tag, got %q", addTags)
-	}
-}
-
-func TestInjectHonorsGlobalDelayCancellation(t *testing.T) {
-	t.Parallel()
-
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			addCalled = true
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	svc := NewService(config.Config{
-		PostUpload: config.PostUploadConfig{InjectDelay: 1},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	err := svc.Inject(ctx, api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://tracker.example/download/1", Tracker: "AITHER"})
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Fatalf("expected deadline exceeded, got %v", err)
-	}
-	if addCalled {
-		t.Fatalf("did not expect qbit add call before delay elapsed")
-	}
-}
-
-func TestInjectTrackerDelayOverrideBeatsGlobalDelay(t *testing.T) {
-	t.Parallel()
-
-	addCalled := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v2/auth/login":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		case "/api/v2/torrents/add":
-			addCalled = true
-			w.Header().Set("Content-Type", "text/plain")
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("Ok."))
-			return
-		default:
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-	}))
-	defer server.Close()
-
-	overrideDelay := 0
-	svc := NewService(config.Config{
-		PostUpload: config.PostUploadConfig{InjectDelay: 1},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {InjectDelay: &overrideDelay},
-			},
-		},
-		TorrentClients: map[string]config.TorrentClientConfig{
-			"qbit": {
-				Type:     "qbit",
-				URL:      server.URL,
-				Username: "user",
-				Password: "pass",
-			},
-		},
-	}, nil)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	if err := svc.Inject(ctx, api.PreparedMetadata{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://tracker.example/download/1", Tracker: "aither"}); err != nil {
-		t.Fatalf("inject: %v", err)
-	}
-	if !addCalled {
-		t.Fatalf("expected qbit add call without global delay because tracker override is zero")
-	}
-}
diff --git a/internal/config/config.go b/internal/config/config.go
index 962530fb..69d7843a 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -18,10 +18,12 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
+	imagehostpolicy "github.com/autobrr/upbrr/internal/imagehosting/policy"
 	"github.com/autobrr/upbrr/internal/redaction"
 )
 
+// Config is the complete runtime and persistence configuration. Secret-aware
+// export and database APIs clone it before transforming secret fields.
 type Config struct {
 	MainSettings       MainSettingsConfig             `yaml:"main_settings"`
 	ImageHosting       ImageHostingConfig             `yaml:"image_hosting"`
@@ -262,12 +264,17 @@ type LoggingConfig struct {
 	MaxFiles       int    `yaml:"max_files"`
 }
 
+// TrackersConfig preserves ordered default selections, one preferred tracker,
+// and tracker settings keyed by configured tracker name.
 type TrackersConfig struct {
 	DefaultTrackers  CSVList                  `yaml:"default_trackers" json:"DefaultTrackers"`
 	PreferredTracker string                   `yaml:"preferred_tracker" json:"PreferredTracker"`
 	Trackers         map[string]TrackerConfig `yaml:"-" json:"Trackers"`
 }
 
+// TrackerConfig stores one tracker's supported settings. Unknown preserves
+// unsupported extension fields across load/save, excluding deprecated URL
+// fields and schema-known fields belonging to another tracker.
 type TrackerConfig struct {
 	LinkDirName         string         `yaml:"link_dir_name" json:"LinkDirName"`
 	APIKey              string         `yaml:"api_key" json:"APIKey"`
@@ -278,7 +285,6 @@ type TrackerConfig struct {
 	Passkey             string         `yaml:"passkey" json:"Passkey"`
 	AnnounceURL         string         `yaml:"announce_url" json:"AnnounceURL"`
 	MyAnnounceURL       string         `yaml:"my_announce_url" json:"MyAnnounceURL"`
-	URL                 string         `yaml:"url" json:"URL"`
 	FaviconURL          string         `yaml:"favicon_url" json:"FaviconURL"`
 	UploaderStatus      bool           `yaml:"uploader_status" json:"UploaderStatus"`
 	CustomLayout        string         `yaml:"custom_layout" json:"CustomLayout"`
@@ -316,7 +322,6 @@ type TrackerConfig struct {
 	LoginQuestion       string         `yaml:"login_question" json:"LoginQuestion"`
 	LoginAnswer         string         `yaml:"login_answer" json:"LoginAnswer"`
 	UserID              string         `yaml:"user_id" json:"UserID"`
-	Filebrowser         string         `yaml:"filebrowser" json:"Filebrowser"`
 	Internal            bool           `yaml:"internal" json:"Internal"`
 	InternalGroups      []string       `yaml:"internal_groups" json:"InternalGroups"`
 	Unknown             map[string]any `yaml:"-" json:"-"`
@@ -390,6 +395,7 @@ func trackerAllowedYAMLKeys(trackerName string) map[string]struct{} {
 	addGlobal := func(keys map[string]struct{}) map[string]struct{} {
 		keys["favicon_url"] = struct{}{}
 		keys["image_host"] = struct{}{}
+		keys["torrent_client"] = struct{}{}
 		return keys
 	}
 	if len(trackerSchema) == 0 {
@@ -443,6 +449,9 @@ func mergeUnknownKeys(target map[string]any, unknown map[string]any) {
 		return
 	}
 	for key, value := range unknown {
+		if strings.EqualFold(strings.TrimSpace(key), "url") {
+			continue
+		}
 		if _, exists := target[key]; exists {
 			continue
 		}
@@ -530,6 +539,9 @@ func extractTrackerUnknown(raw map[string]any) map[string]any {
 	initTrackerTagMetadata()
 	unknown := make(map[string]any)
 	for key, value := range raw {
+		if strings.EqualFold(strings.TrimSpace(key), "url") {
+			continue
+		}
 		if _, ok := trackerKnownJSONKeys[key]; ok {
 			continue
 		}
@@ -544,7 +556,16 @@ func extractTrackerUnknown(raw map[string]any) map[string]any {
 	return unknown
 }
 
+func stripDeprecatedTrackerURL(raw map[string]any) {
+	for key := range raw {
+		if strings.EqualFold(strings.TrimSpace(key), "url") {
+			delete(raw, key)
+		}
+	}
+}
+
 func decodeTrackerConfigFromJSON(raw map[string]any) (TrackerConfig, error) {
+	stripDeprecatedTrackerURL(raw)
 	payload, err := json.Marshal(raw)
 	if err != nil {
 		return TrackerConfig{}, fmt.Errorf("config: marshal tracker config from json: %w", err)
@@ -558,6 +579,7 @@ func decodeTrackerConfigFromJSON(raw map[string]any) (TrackerConfig, error) {
 }
 
 func decodeTrackerConfigFromYAML(raw map[string]any) (TrackerConfig, error) {
+	stripDeprecatedTrackerURL(raw)
 	payload, err := yaml.Marshal(raw)
 	if err != nil {
 		return TrackerConfig{}, fmt.Errorf("config: marshal tracker config from yaml: %w", err)
@@ -594,7 +616,11 @@ func (t TrackersConfig) MarshalJSON() ([]byte, error) {
 	}
 	preferredTracker := strings.TrimSpace(t.PreferredTracker)
 
-	payload, err := json.Marshal(trackersJSON{DefaultTrackers: defaultTrackers, PreferredTracker: preferredTracker, Trackers: trackers})
+	payload, err := json.Marshal(trackersJSON{
+		DefaultTrackers:  defaultTrackers,
+		PreferredTracker: preferredTracker,
+		Trackers:         trackers,
+	})
 	if err != nil {
 		return nil, fmt.Errorf("config: marshal trackers config: %w", err)
 	}
@@ -733,6 +759,9 @@ func (t *TrackersConfig) UnmarshalYAML(value *yaml.Node) error {
 	return nil
 }
 
+// TorrentClientConfig supports current qBittorrent/watch/qui fields plus
+// legacy aliases. Its resolver methods define field precedence, and marshaling
+// emits the resolved canonical values rather than duplicate aliases.
 type TorrentClientConfig struct {
 	Type          string     `yaml:"type"`
 	TorrentClient string     `yaml:"torrent_client"`
@@ -962,20 +991,6 @@ func (c Config) Validate() error {
 			if !imagehostpolicy.IsUploadHost(imageHost) {
 				return fmt.Errorf("config: trackers.%s.image_host %q is not supported", trackerName, trackerCfg.ImageHost)
 			}
-			if owner := imagehostpolicy.OwnerForHost(imageHost); owner != "" && !strings.EqualFold(strings.TrimSpace(trackerName), owner) {
-				return fmt.Errorf("config: trackers.%s.image_host %q is owned by %s", trackerName, trackerCfg.ImageHost, owner)
-			}
-			policy := imagehostpolicy.ForTracker(trackerName, trackerCfg.ImgRehost, trackerCfg.ImgAPI)
-			if len(policy.AllowedHosts) > 0 && !imagehostpolicy.HostAllowed(imageHost, policy.AllowedHosts) {
-				return fmt.Errorf("config: trackers.%s.image_host %q is not allowed for this tracker", trackerName, trackerCfg.ImageHost)
-			}
-		}
-		if !trackerCfg.ImgRehost {
-			continue
-		}
-		policy := imagehostpolicy.ForTracker(trackerName, true, trackerCfg.ImgAPI)
-		if len(policy.AllowedHosts) == 0 {
-			return fmt.Errorf("config: trackers.%s.img_rehost requires a tracker image-host policy, but none is defined", trackerName)
 		}
 	}
 
@@ -1048,29 +1063,6 @@ func lookupTorrentClient(clients map[string]TorrentClientConfig, selected string
 	return len(foldMatches) == 1
 }
 
-// DisableUnsupportedTrackerImageRehosts turns off img_rehost for trackers that
-// have no image-host policy and returns the tracker names that changed.
-func DisableUnsupportedTrackerImageRehosts(cfg *Config) []string {
-	if cfg == nil || len(cfg.Trackers.Trackers) == 0 {
-		return nil
-	}
-
-	disabled := make([]string, 0)
-	for trackerName, trackerCfg := range cfg.Trackers.Trackers {
-		if !trackerCfg.ImgRehost {
-			continue
-		}
-		policy := imagehostpolicy.ForTracker(trackerName, true, trackerCfg.ImgAPI)
-		if len(policy.AllowedHosts) != 0 {
-			continue
-		}
-		trackerCfg.ImgRehost = false
-		cfg.Trackers.Trackers[trackerName] = trackerCfg
-		disabled = append(disabled, trackerName)
-	}
-	return disabled
-}
-
 // ResolveBTNAPIToken returns the BTN tracker API key from ASCII case variants
 // of "BTN" before falling back to the legacy metadata-level token. Fuzzy or
 // Unicode-equivalent tracker names are not treated as aliases.
@@ -1106,7 +1098,7 @@ func trackerAPIKeyForExactName(trackers map[string]TrackerConfig, name string) s
 }
 
 // MergeMissingTrackerDefaults backfills tracker stubs from the embedded example
-// config so older saved configs can discover newly added trackers in the GUI.
+// config so older saved configs can discover newly added trackers in the WebUI.
 // Existing exact tracker names are preserved; ASCII case variants of "BTN" are
 // treated as the BTN entry so default backfill and legacy metadata tokens do not
 // create a duplicate canonical "BTN" entry.
@@ -1167,8 +1159,7 @@ func MergeMissingTrackerDefaultsWithReport(cfg *Config) (TrackerDefaultsMergeRep
 			continue
 		}
 		if asciiEqualFold(trackerName, "CZT") {
-			if strings.TrimSpace(existing.URL) != "" || strings.TrimSpace(existing.APIKey) != "" || strings.TrimSpace(existing.AnnounceURL) != "" {
-				existing.URL = ""
+			if strings.TrimSpace(existing.APIKey) != "" || strings.TrimSpace(existing.AnnounceURL) != "" {
 				existing.APIKey = ""
 				existing.AnnounceURL = ""
 				cfg.Trackers.Trackers[existingName] = existing
@@ -1176,11 +1167,6 @@ func MergeMissingTrackerDefaultsWithReport(cfg *Config) (TrackerDefaultsMergeRep
 			}
 			continue
 		}
-		if strings.TrimSpace(existing.URL) == "" && strings.TrimSpace(trackerCfg.URL) != "" {
-			existing.URL = trackerCfg.URL
-			cfg.Trackers.Trackers[existingName] = existing
-			report.markChanged("Trackers")
-		}
 	}
 	if token := strings.TrimSpace(cfg.Metadata.BTNAPI); token != "" {
 		if trackerAPIKeyByName(cfg.Trackers.Trackers, "BTN") == "" {
@@ -1201,11 +1187,10 @@ func MergeMissingTrackerDefaultsWithReport(cfg *Config) (TrackerDefaultsMergeRep
 		if !asciiEqualFold(trackerName, "CZT") {
 			continue
 		}
-		if strings.TrimSpace(trackerCfg.APIKey) == "" && strings.TrimSpace(trackerCfg.URL) == "" && strings.TrimSpace(trackerCfg.AnnounceURL) == "" {
+		if strings.TrimSpace(trackerCfg.APIKey) == "" && strings.TrimSpace(trackerCfg.AnnounceURL) == "" {
 			continue
 		}
 		trackerCfg.APIKey = ""
-		trackerCfg.URL = ""
 		trackerCfg.AnnounceURL = ""
 		cfg.Trackers.Trackers[trackerName] = trackerCfg
 		report.markChanged("Trackers")
@@ -1276,6 +1261,9 @@ func asciiEqualFold(value string, target string) bool {
 	return true
 }
 
+// QbitHost returns QuiProxyURL when set; otherwise it resolves QbitURL before
+// legacy URL, adds an http scheme when absent, and applies QbitPort when the
+// URL has no explicit port.
 func (c TorrentClientConfig) QbitHost() string {
 	if strings.TrimSpace(c.QuiProxyURL) != "" {
 		host := strings.TrimSpace(c.QuiProxyURL)
@@ -1304,6 +1292,7 @@ func (c TorrentClientConfig) QbitHost() string {
 	return parsed.String()
 }
 
+// ClientType resolves Type before legacy TorrentClient and defaults to "qbit".
 func (c TorrentClientConfig) ClientType() string {
 	if strings.TrimSpace(c.Type) != "" {
 		return strings.TrimSpace(c.Type)
@@ -1314,6 +1303,7 @@ func (c TorrentClientConfig) ClientType() string {
 	return "qbit"
 }
 
+// QbitUsername resolves QbitUser before legacy Username.
 func (c TorrentClientConfig) QbitUsername() string {
 	if strings.TrimSpace(c.QbitUser) != "" {
 		return strings.TrimSpace(c.QbitUser)
@@ -1321,6 +1311,7 @@ func (c TorrentClientConfig) QbitUsername() string {
 	return strings.TrimSpace(c.Username)
 }
 
+// QbitPassword resolves QbitPass before legacy Password.
 func (c TorrentClientConfig) QbitPassword() string {
 	if strings.TrimSpace(c.QbitPass) != "" {
 		return strings.TrimSpace(c.QbitPass)
@@ -1328,6 +1319,7 @@ func (c TorrentClientConfig) QbitPassword() string {
 	return strings.TrimSpace(c.Password)
 }
 
+// QbitCategory resolves QbitCategoryValue before legacy Category.
 func (c TorrentClientConfig) QbitCategory() string {
 	if strings.TrimSpace(c.QbitCategoryValue) != "" {
 		return strings.TrimSpace(c.QbitCategoryValue)
@@ -1335,6 +1327,8 @@ func (c TorrentClientConfig) QbitCategory() string {
 	return strings.TrimSpace(c.Category)
 }
 
+// QbitTags resolves QbitTag, then QbitTagsValue, then legacy Tags, removing
+// blank slice entries and joining multiple tags with commas.
 func (c TorrentClientConfig) QbitTags() string {
 	if strings.TrimSpace(c.QbitTag) != "" {
 		return strings.TrimSpace(c.QbitTag)
@@ -1364,6 +1358,7 @@ func (c TorrentClientConfig) QbitTags() string {
 	return ""
 }
 
+// LinkingMode returns a lowercase mode and normalizes "none" or "disabled" to empty.
 func (c TorrentClientConfig) LinkingMode() string {
 	mode := strings.ToLower(strings.TrimSpace(c.Linking))
 	switch mode {
@@ -1374,10 +1369,13 @@ func (c TorrentClientConfig) LinkingMode() string {
 	}
 }
 
+// FallbackAllowed defaults to true when AllowFallback is unset.
 func (c TorrentClientConfig) FallbackAllowed() bool {
 	return c.AllowFallback == nil || *c.AllowFallback
 }
 
+// QbitTLSSkipVerify resolves TLSSkipVerify first, then inverts the legacy
+// VerifyWebUICertificate value, and otherwise defaults to false.
 func (c TorrentClientConfig) QbitTLSSkipVerify() bool {
 	if c.TLSSkipVerify != nil {
 		return *c.TLSSkipVerify
@@ -1388,36 +1386,18 @@ func (c TorrentClientConfig) QbitTLSSkipVerify() bool {
 	return false
 }
 
+// UsesQuiProxy reports whether a non-blank QuiProxyURL is configured.
 func (c TorrentClientConfig) UsesQuiProxy() bool {
 	return strings.TrimSpace(c.QuiProxyURL) != ""
 }
 
-// ResolveTrackerDomain resolves a tracker name or raw domain into a domain name and its configured URL.
-func ResolveTrackerDomain(cfg *Config, trackerNameOrDomain string) (string, string) {
+// ResolveTrackerDomain preserves the trimmed tracker identifier in its first
+// result. Domain resolution is no longer performed, so the second result is empty.
+func ResolveTrackerDomain(_ *Config, trackerNameOrDomain string) (string, string) {
 	name := strings.TrimSpace(trackerNameOrDomain)
 	if name == "" {
 		return "", ""
 	}
-
-	if cfg != nil && cfg.Trackers.Trackers != nil {
-		for k, v := range cfg.Trackers.Trackers {
-			if strings.EqualFold(k, name) {
-				u := strings.TrimSpace(v.URL)
-				if u != "" {
-					// Prepend scheme if missing to allow url.Parse to extract hostname
-					urlString := u
-					if !strings.Contains(urlString, "://") {
-						urlString = "http://" + urlString
-					}
-					if parsed, err := url.Parse(urlString); err == nil && parsed.Hostname() != "" {
-						return parsed.Hostname(), u
-					}
-					return "", u
-				}
-			}
-		}
-	}
-
 	return name, ""
 }
 
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
index 742eea11..8b644671 100644
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -56,7 +56,12 @@ func TestValidate(t *testing.T) {
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 			},
 			wantErr: false,
@@ -72,7 +77,12 @@ func TestValidate(t *testing.T) {
 					SearchClients: CSVList{"QBIT"},
 				},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 			},
 			wantErr: false,
@@ -97,7 +107,12 @@ func TestValidate(t *testing.T) {
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				ClientSetup:        ClientSetupConfig{DefaultClient: "missing"},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 			},
 			wantErr: true,
@@ -109,7 +124,12 @@ func TestValidate(t *testing.T) {
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				ClientSetup:        ClientSetupConfig{SearchClients: CSVList{"missing"}},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 			},
 			wantErr: true,
@@ -121,7 +141,12 @@ func TestValidate(t *testing.T) {
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				ClientSetup:        ClientSetupConfig{InjectClients: CSVList{"missing"}},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 			},
 			wantErr: true,
@@ -145,7 +170,12 @@ func TestValidate(t *testing.T) {
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 				Trackers: TrackersConfig{
 					Trackers: map[string]TrackerConfig{
@@ -195,7 +225,12 @@ func TestValidate(t *testing.T) {
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 				Trackers: TrackersConfig{
 					Trackers: map[string]TrackerConfig{
@@ -211,7 +246,12 @@ func TestValidate(t *testing.T) {
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				TorrentClients: map[string]TorrentClientConfig{
-					"qbit": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"qbit": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 				Trackers: TrackersConfig{
 					Trackers: map[string]TrackerConfig{
@@ -227,7 +267,12 @@ func TestValidate(t *testing.T) {
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 				TorrentClients: map[string]TorrentClientConfig{
-					"none": {Type: "qbit", URL: "http://localhost", Username: "user", Password: "pass"},
+					"none": {
+						Type:     "qbit",
+						URL:      "http://localhost",
+						Username: "user",
+						Password: "pass",
+					},
 				},
 				Trackers: TrackersConfig{
 					Trackers: map[string]TrackerConfig{
@@ -274,7 +319,7 @@ func TestValidate(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name: "invalid img rehost tracker without policy",
+			name: "img rehost policy is validated at runtime",
 			cfg: Config{
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
@@ -284,7 +329,7 @@ func TestValidate(t *testing.T) {
 					},
 				},
 			},
-			wantErr: true,
+			wantErr: false,
 		},
 		{
 			name: "valid img rehost tracker with policy",
@@ -326,7 +371,7 @@ func TestValidate(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name: "invalid tracker image host outside tracker policy",
+			name: "tracker image host policy is validated at runtime",
 			cfg: Config{
 				MainSettings:       MainSettingsConfig{TMDBAPI: "x"},
 				ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
@@ -336,7 +381,7 @@ func TestValidate(t *testing.T) {
 					},
 				},
 			},
-			wantErr: true,
+			wantErr: false,
 		},
 		{
 			name: "valid owned RF tracker image host",
@@ -612,7 +657,6 @@ func TestTrackersConfigCZTPasskeyFieldsRoundTrip(t *testing.T) {
 			DefaultTrackers: CSVList{"CZT"},
 			Trackers: map[string]TrackerConfig{
 				"CZT": {
-					URL:         "https://czteam.example",
 					APIKey:      "service-token",
 					Passkey:     "user-passkey",
 					AnnounceURL: "https://should-not-be-here",
@@ -630,9 +674,6 @@ func TestTrackersConfigCZTPasskeyFieldsRoundTrip(t *testing.T) {
 		t.Fatalf("import json: %v", err)
 	}
 	jsonCZT := jsonRoundTrip.Trackers.Trackers["CZT"]
-	if jsonCZT.URL != "" {
-		t.Fatalf("json CZT should not include URL, got %q", jsonCZT.URL)
-	}
 	if jsonCZT.APIKey != "" {
 		t.Fatalf("json CZT should not include APIKey, got %q", jsonCZT.APIKey)
 	}
@@ -671,9 +712,6 @@ func TestTrackersConfigCZTPasskeyFieldsRoundTrip(t *testing.T) {
 		t.Fatalf("import yaml: %v", err)
 	}
 	yamlCZT := yamlRoundTrip.Trackers.Trackers["CZT"]
-	if yamlCZT.URL != "" {
-		t.Fatalf("yaml CZT should not include URL, got %q", yamlCZT.URL)
-	}
 	if yamlCZT.APIKey != "" {
 		t.Fatalf("yaml CZT should not include APIKey, got %q", yamlCZT.APIKey)
 	}
@@ -797,9 +835,6 @@ func TestMergeMissingTrackerDefaults(t *testing.T) {
 	if got := cfg.Trackers.Trackers["AITHER"].APIKey; got != "existing" {
 		t.Fatalf("expected existing tracker config to be preserved, got %q", got)
 	}
-	if got := cfg.Trackers.Trackers["AITHER"].URL; got != "https://aither.cc" {
-		t.Fatalf("expected AITHER URL to be backfilled, got %q", got)
-	}
 }
 
 func TestResolveBTNAPITokenPrefersTrackerConfig(t *testing.T) {
@@ -1036,9 +1071,6 @@ func TestMergeMissingTrackerDefaultsDoesNotBackfillLegacyBTNAPIOverLowercaseTrac
 	if _, ok := cfg.Trackers.Trackers["BTN"]; ok {
 		t.Fatalf("expected canonical BTN default not to duplicate lowercase btn tracker")
 	}
-	if got := cfg.Trackers.Trackers["btn"].URL; got != "https://backup.landof.tv" {
-		t.Fatalf("expected lowercase btn URL to be backfilled, got %q", got)
-	}
 }
 
 func TestMergeMissingTrackerDefaultsReconcilesLowercaseBTNWithoutToken(t *testing.T) {
@@ -1074,9 +1106,6 @@ func TestMergeMissingTrackerDefaultsReconcilesLowercaseBTNWithoutToken(t *testin
 	if btn.Username != "user" || btn.Password != "pass" {
 		t.Fatalf("expected lowercase btn non-token fields to be preserved, got username=%q password=%q", btn.Username, btn.Password)
 	}
-	if got := btn.URL; got != "https://backup.landof.tv" {
-		t.Fatalf("expected lowercase btn URL to be backfilled, got %q", got)
-	}
 }
 
 func TestMergeMissingTrackerDefaultsUsesASCIICaseBTNTrackerConfig(t *testing.T) {
@@ -1116,7 +1145,11 @@ func TestMergeMissingTrackerDefaultsClearsCZTSensitiveFields(t *testing.T) {
 	cfg := &Config{
 		Trackers: TrackersConfig{
 			Trackers: map[string]TrackerConfig{
-				"CZT":                {APIKey: "stale-token", URL: "https://stale.example", AnnounceURL: "https://czteam.me/announce.php?passkey=stale", Passkey: "passkey"},
+				"CZT": {
+					APIKey:      "stale-token",
+					AnnounceURL: "https://czteam.me/announce.php?passkey=stale",
+					Passkey:     "passkey",
+				},
 				"czt":                {AnnounceURL: "https://czteam.me/announce.php?passkey=lowercase"},
 				"\uFF23\uFF3A\uFF34": {AnnounceURL: "https://czteam.me/announce.php?passkey=fullwidth"},
 			},
@@ -1134,9 +1167,6 @@ func TestMergeMissingTrackerDefaultsClearsCZTSensitiveFields(t *testing.T) {
 	if czt.APIKey != "" {
 		t.Fatalf("expected CZT APIKey to be cleared, got %q", czt.APIKey)
 	}
-	if czt.URL != "" {
-		t.Fatalf("expected CZT URL to be cleared, got %q", czt.URL)
-	}
 	if czt.AnnounceURL != "" {
 		t.Fatalf("expected CZT AnnounceURL to be cleared, got %q", czt.AnnounceURL)
 	}
@@ -1220,8 +1250,16 @@ func TestTorrentClientConfigAutomaticManagementPathsAcceptsStringOrList(t *testi
 		value    string
 		expected StringList
 	}{
-		{name: "string", value: `media-root`, expected: StringList{"media-root"}},
-		{name: "list", value: "[media-root, archive-root]", expected: StringList{"media-root", "archive-root"}},
+		{
+			name:     "string",
+			value:    `media-root`,
+			expected: StringList{"media-root"},
+		},
+		{
+			name:     "list",
+			value:    "[media-root, archive-root]",
+			expected: StringList{"media-root", "archive-root"},
+		},
 	}
 
 	for _, tt := range tests {
@@ -1287,42 +1325,9 @@ func TestTorrentClientConfigQbitHostPrecedence(t *testing.T) {
 	}
 }
 
-func TestDisableUnsupportedTrackerImageRehosts(t *testing.T) {
-	t.Parallel()
-
-	cfg := Config{
-		Trackers: TrackersConfig{
-			Trackers: map[string]TrackerConfig{
-				"TL":  {ImgRehost: true},
-				"HDB": {ImgRehost: true},
-			},
-		},
-	}
-
-	disabled := DisableUnsupportedTrackerImageRehosts(&cfg)
-	if len(disabled) != 1 || disabled[0] != "TL" {
-		t.Fatalf("expected TL to be disabled, got %v", disabled)
-	}
-	if cfg.Trackers.Trackers["TL"].ImgRehost {
-		t.Fatal("expected TL img_rehost to be disabled")
-	}
-	if !cfg.Trackers.Trackers["HDB"].ImgRehost {
-		t.Fatal("expected HDB img_rehost to remain enabled")
-	}
-}
-
 func TestResolveTrackerDomain(t *testing.T) {
 	t.Parallel()
 
-	cfg := &Config{
-		Trackers: TrackersConfig{
-			Trackers: map[string]TrackerConfig{
-				"AITHER": {URL: "https://aither.cc"},
-				"BLU":    {URL: "blutopia.cc"}, // no scheme
-			},
-		},
-	}
-
 	cases := []struct {
 		name         string
 		input        string
@@ -1330,25 +1335,7 @@ func TestResolveTrackerDomain(t *testing.T) {
 		expectedURL  string
 	}{
 		{
-			name:         "exact match with scheme",
-			input:        "AITHER",
-			expectedHost: "aither.cc",
-			expectedURL:  "https://aither.cc",
-		},
-		{
-			name:         "case-insensitive match",
-			input:        "aither",
-			expectedHost: "aither.cc",
-			expectedURL:  "https://aither.cc",
-		},
-		{
-			name:         "match without scheme",
-			input:        "BLU",
-			expectedHost: "blutopia.cc",
-			expectedURL:  "blutopia.cc",
-		},
-		{
-			name:         "unconfigured tracker is treated as raw domain",
+			name:         "input is treated as raw domain",
 			input:        "my-random-domain.com",
 			expectedHost: "my-random-domain.com",
 			expectedURL:  "",
@@ -1364,7 +1351,7 @@ func TestResolveTrackerDomain(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			gotHost, gotURL := ResolveTrackerDomain(cfg, tc.input)
+			gotHost, gotURL := ResolveTrackerDomain(nil, tc.input)
 			if gotHost != tc.expectedHost {
 				t.Errorf("expected host %q, got %q", tc.expectedHost, gotHost)
 			}
diff --git a/internal/config/defaults.go b/internal/config/defaults.go
index 47171bc0..aabf27df 100644
--- a/internal/config/defaults.go
+++ b/internal/config/defaults.go
@@ -15,6 +15,7 @@ import (
 //go:embed defaults/example.yaml
 var embeddedExampleYAML []byte
 
+// EmbeddedExampleYAML returns a defensive copy of the embedded example config.
 func EmbeddedExampleYAML() []byte {
 	if len(embeddedExampleYAML) == 0 {
 		return nil
@@ -35,6 +36,8 @@ func loadEmbeddedDefaultConfigRaw() (*Config, error) {
 	return &cfg, nil
 }
 
+// LoadEmbeddedDefaultConfig parses the embedded example and backfills any
+// tracker defaults missing from its decoded shape.
 func LoadEmbeddedDefaultConfig() (*Config, error) {
 	cfg, err := loadEmbeddedDefaultConfigRaw()
 	if err != nil {
diff --git a/internal/config/defaults/example.yaml b/internal/config/defaults/example.yaml
index 59932788..d88116dc 100644
--- a/internal/config/defaults/example.yaml
+++ b/internal/config/defaults/example.yaml
@@ -135,43 +135,36 @@ trackers:
   A4K:
     link_dir_name: ""
     api_key: ""
-    url: "https://aura4k.net"
     image_host: ""
     anon: false
     modq: false
   ACM:
     link_dir_name: ""
     api_key: ""
-    url: "https://eiga.moi"
     announce_url: ""
     anon: false
   AITHER:
     link_dir_name: ""
     api_key: ""
-    url: "https://aither.cc"
     anon: false
     modq: false
   ANT:
     link_dir_name: ""
     api_key: ""
-    url: "https://anthelion.me"
     announce_url: ""
     anon: false
   AR:
     link_dir_name: ""
     username: ""
     password: ""
-    url: "https://alpharatio.cc"
     announce_url: ""
   ASC:
     link_dir_name: ""
     uploader_status: false
     custom_layout: "2"
-    url: "https://amigos-share.club"
     announce_url: ""
   AZ:
     link_dir_name: ""
-    url: "https://avistaz.to"
     announce_url: ""
     anon: false
     check_for_rules: true
@@ -179,31 +172,26 @@ trackers:
     link_dir_name: ""
     api_key: ""
     bhd_rss_key: ""
-    url: "https://beyond-hd.me"
     announce_url: ""
     draft_default: false
     anon: false
   BHDTV:
     link_dir_name: ""
     api_key: ""
-    url: "https://bit-hdtv.com"
     announce_url: ""
     my_announce_url: ""
     anon: false
   BJS:
     link_dir_name: ""
-    url: "https://bj-share.info"
     announce_url: ""
     anon: false
     show_group_if_anon: true
   BLU:
     link_dir_name: ""
     api_key: ""
-    url: "https://blutopia.cc"
     anon: false
   BT:
     link_dir_name: ""
-    url: "https://brasiltracker.org"
     announce_url: ""
     anon: false
   BTN:
@@ -212,18 +200,15 @@ trackers:
     announce_url: ""
     username: ""
     password: ""
-    url: "https://backup.landof.tv"
     otp_uri: ""
   CBR:
     link_dir_name: ""
     api_key: ""
-    url: "https://capybarabr.com"
     anon: false
     modq: false
     tag_for_custom_release: ""
   CZ:
     link_dir_name: ""
-    url: "https://cinemaz.to"
     announce_url: ""
     anon: false
     check_for_rules: true
@@ -233,26 +218,22 @@ trackers:
   DC:
     link_dir_name: ""
     api_key: ""
-    url: "https://digitalcore.club"
     anon: false
     use_metadata_name: false
   DP:
     link_dir_name: ""
     api_key: ""
-    url: "https://darkpeers.org"
     anon: false
     modq: false
   EMUW:
     link_dir_name: ""
     api_key: ""
-    url: "https://emuwarez.com"
     anon: false
     use_spanish_title: false
   FF:
     link_dir_name: ""
     username: ""
     password: ""
-    url: "https://funfile.org"
     announce_url: ""
     check_requests: false
     full_mediainfo: false
@@ -261,96 +242,79 @@ trackers:
     username: ""
     passkey: ""
     uploader_name: ""
-    url: "https://filelist.io"
     anon: false
   FRIKI:
     link_dir_name: ""
     api_key: ""
-    url: "https://frikibar.com"
   GPW:
     link_dir_name: ""
     api_key: ""
-    url: "https://greatposterwall.com"
     announce_url: ""
   HDB:
     link_dir_name: ""
     username: ""
     passkey: ""
-    url: "https://hdbits.org"
     announce_url: ""
     img_rehost: true
   HDS:
     link_dir_name: ""
-    url: "https://hd-space.org"
     announce_url: ""
     anon: false
     full_mediainfo: false
   HDT:
     link_dir_name: ""
-    url: "https://hd-torrents.me/"
     anon: false
     announce_url: ""
     full_mediainfo: false
   HHD:
     link_dir_name: ""
     api_key: ""
-    url: "https://homiehelpdesk.net"
     anon: false
   IHD:
     link_dir_name: ""
     api_key: ""
-    url: "https://infinityhd.net"
     anon: false
   IS:
     link_dir_name: ""
-    url: "https://immortalseed.me"
     announce_url: ""
     anon: false
   ITT:
     link_dir_name: ""
     api_key: ""
-    url: "https://itatorrents.xyz"
     anon: false
   LCD:
     link_dir_name: ""
     api_key: ""
-    url: "https://locadora.cc"
     anon: false
   LDU:
     link_dir_name: ""
     api_key: ""
-    url: "https://theldu.to"
     anon: false
   LST:
     link_dir_name: ""
     api_key: ""
-    url: "https://lst.gg"
     anon: false
     modq: false
     draft: false
   LT:
     link_dir_name: ""
     api_key: ""
-    url: "https://lat-team.com"
     anon: false
     modq: false
   LUME:
     link_dir_name: ""
     api_key: ""
-    url: "https://luminarr.me"
     anon: false
     modq: false
   MNS:
     link_dir_name: ""
     api_key: ""
-    url: "https://midnightscene.cc"
     anon: false
   MTV:
     link_dir_name: ""
     api_key: ""
     username: ""
     password: ""
-    url: "https://morethantv.me"
     announce_url: ""
     anon: false
     otp_uri: ""
@@ -359,29 +323,24 @@ trackers:
   NBL:
     link_dir_name: ""
     api_key: ""
-    url: "https://nebulance.io"
     announce_url: ""
   OE:
     link_dir_name: ""
     api_key: ""
-    url: "https://onlyencodes.cc"
     anon: false
   OTW:
     link_dir_name: ""
     api_key: ""
-    url: "https://oldtoons.world"
     modq: false
     anon: false
   PHD:
     link_dir_name: ""
-    url: "https://privatehd.to"
     announce_url: ""
     anon: false
     check_for_rules: true
   PT:
     link_dir_name: ""
     api_key: ""
-    url: "https://portugas.org"
     anon: false
   PTP:
     link_dir_name: ""
@@ -390,39 +349,32 @@ trackers:
     ApiKey: ""
     username: ""
     password: ""
-    url: "https://passthepopcorn.me"
     announce_url: ""
     otp_uri: ""
   PTS:
     link_dir_name: ""
-    url: "https://ptskit.org"
     announce_url: ""
   PTT:
     link_dir_name: ""
     api_key: ""
-    url: "https://polishtorrent.top"
     anon: false
   R4E:
     link_dir_name: ""
     api_key: ""
-    url: "https://racing4everyone.eu"
     announce_url: ""
     anon: false
   RAS:
     link_dir_name: ""
     api_key: ""
-    url: "https://rastastugan.org"
     anon: false
   RF:
     link_dir_name: ""
     api_key: ""
     img_api: ""
-    url: "https://reelflix.cc"
     anon: false
   RHD:
     link_dir_name: ""
     api_key: ""
-    url: "https://rocket-hd.cc"
     anon: false
     modq: false
   RTF:
@@ -430,41 +382,34 @@ trackers:
     username: ""
     password: ""
     api_key: ""
-    url: "https://retroflix.club"
     announce_url: ""
     anon: true
   SAM:
     link_dir_name: ""
     api_key: ""
-    url: "https://samaritano.cc"
     anon: false
     tag_for_custom_release: ""
   SHRI:
     link_dir_name: ""
     api_key: ""
-    url: "https://shareisland.org"
     anon: false
     use_italian_title: false
   SP:
     link_dir_name: ""
     api_key: ""
-    url: "https://seedpool.org"
   SPD:
     link_dir_name: ""
     api_key: ""
-    url: "https://speedapp.io"
     channel: ""
   STC:
     link_dir_name: ""
     api_key: ""
-    url: "https://skipthecommercials.xyz"
     anon: false
   THR:
     link_dir_name: ""
     username: ""
     password: ""
     img_api: ""
-    url: "https://torrenthr.org"
     announce_url: ""
     pronfo_api_key: ""
     pronfo_theme: ""
@@ -473,66 +418,53 @@ trackers:
   TIK:
     link_dir_name: ""
     api_key: ""
-    url: "https://cinematik.net"
     anon: false
   TL:
     link_dir_name: ""
     api_upload: true
     passkey: ""
-    url: "https://torrentleech.org"
     anon: false
     img_rehost: false
     full_mediainfo: false
   TLZ:
     link_dir_name: ""
     api_key: ""
-    url: "https://tlzdigital.com"
     anon: false
   TOS:
     link_dir_name: ""
     api_key: ""
-    url: "https://theoldschool.cc"
     announce_url: ""
     anon: false
     exclusive: false
   TTR:
     link_dir_name: ""
     api_key: ""
-    url: "https://torrenteros.org"
     anon: false
     modq: false
   TVC:
     link_dir_name: ""
     image_count: 2
     api_key: ""
-    url: "https://tvchaosuk.com"
     announce_url: ""
     anon: false
   ULCX:
     link_dir_name: ""
     api_key: ""
-    url: "https://upload.cx"
     anon: false
     modq: false
   UTP:
     link_dir_name: ""
     api_key: ""
-    url: "https://utp.to"
     anon: false
   YUS:
     link_dir_name: ""
     api_key: ""
-    url: "https://yu-scene.net"
     anon: false
   ZNTH:
     link_dir_name: ""
     api_key: ""
-    url: "https://znth.cx"
     anon: false
     modq: false
-  MANUAL:
-    filebrowser: ""
-
 torrent_clients:
   qbittorrent:
     qui_proxy_url: ""
diff --git a/internal/config/env.go b/internal/config/env.go
index 96c4ae79..8b4a6bd5 100644
--- a/internal/config/env.go
+++ b/internal/config/env.go
@@ -11,6 +11,9 @@ import (
 
 const envPrefix = "UA_"
 
+// ApplyEnvOverrides mutates cfg with supported non-blank UA_ environment
+// values. Invalid boolean and integer values are ignored, leaving the current
+// field unchanged.
 func ApplyEnvOverrides(cfg *Config) {
 	if cfg == nil {
 		return
diff --git a/internal/config/importer/importer.go b/internal/config/importer/importer.go
index 8b9ecd5d..ad2aa107 100644
--- a/internal/config/importer/importer.go
+++ b/internal/config/importer/importer.go
@@ -13,6 +13,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"slices"
 	"strings"
 
 	"gopkg.in/yaml.v3"
@@ -47,7 +48,7 @@ func ImportFromFile(path string) (*config.Config, []string, error) {
 	}
 
 	cfg, err := parseNative(filepath.Base(path), data)
-	return finalize(cfg, nil, err)
+	return finalize(cfg, deprecatedTrackerURLWarnings(filepath.Base(path), data), err)
 }
 
 // ImportFromContent parses raw file content. The filename is used only to
@@ -64,22 +65,14 @@ func ImportFromContent(filename string, data []byte) (*config.Config, []string,
 	}
 
 	cfg, err := parseNative(filename, data)
-	return finalize(cfg, nil, err)
+	return finalize(cfg, deprecatedTrackerURLWarnings(filename, data), err)
 }
 
-// finalize applies sanitization that should happen on every import regardless
-// of source format: disabling image rehosts for trackers that do not support
-// them. Disabled trackers are appended to the warning list so users see why
-// their setting changed.
+// finalize returns parser warnings after source-independent migration has run.
 func finalize(cfg *config.Config, warnings []string, err error) (*config.Config, []string, error) {
 	if err != nil {
 		return nil, nil, err
 	}
-	if disabled := config.DisableUnsupportedTrackerImageRehosts(cfg); len(disabled) > 0 {
-		for _, name := range disabled {
-			warnings = append(warnings, "disabled unsupported img_rehost for tracker: "+name)
-		}
-	}
 	return cfg, warnings, nil
 }
 
@@ -317,3 +310,53 @@ func torrentClientSchemaMap(path string) map[string]any {
 func isPythonFile(filename string) bool {
 	return strings.ToLower(filepath.Ext(filename)) == ".py"
 }
+
+func deprecatedTrackerURLWarnings(filename string, data []byte) []string {
+	root := map[string]any{}
+	switch strings.ToLower(filepath.Ext(filename)) {
+	case ".yaml", ".yml":
+		if yaml.Unmarshal(data, &root) != nil {
+			return nil
+		}
+		section := foldedMapValue(root, "trackers")
+		trackersRaw := foldedMapValue(section, "trackers")
+		return trackerURLWarnings(trackersRaw, "trackers.trackers")
+	case ".json":
+		if json.Unmarshal(data, &root) != nil {
+			return nil
+		}
+		section := foldedMapValue(root, "Trackers")
+		trackersRaw := foldedMapValue(section, "Trackers")
+		return trackerURLWarnings(trackersRaw, "Trackers.Trackers")
+	default:
+		return nil
+	}
+}
+
+func foldedMapValue(values map[string]any, key string) map[string]any {
+	for candidate, value := range values {
+		if !strings.EqualFold(strings.TrimSpace(candidate), key) {
+			continue
+		}
+		mapped, _ := value.(map[string]any)
+		return mapped
+	}
+	return nil
+}
+
+func trackerURLWarnings(entries map[string]any, prefix string) []string {
+	warnings := make([]string, 0)
+	for tracker, raw := range entries {
+		entry, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		for key := range entry {
+			if strings.EqualFold(strings.TrimSpace(key), "url") {
+				warnings = append(warnings, fmt.Sprintf("ignored deprecated tracker URL: %s.%s.%s", prefix, tracker, key))
+			}
+		}
+	}
+	slices.Sort(warnings)
+	return warnings
+}
diff --git a/internal/config/importer/importer_penetration_test.go b/internal/config/importer/importer_penetration_test.go
index 7ca49041..7d2ee89b 100644
--- a/internal/config/importer/importer_penetration_test.go
+++ b/internal/config/importer/importer_penetration_test.go
@@ -11,7 +11,7 @@ import (
 	"testing"
 )
 
-// The importer is the only interface the GUI and web upload path use to
+// The importer is the only interface the WebUI upload path uses to
 // ingest a user's old config. These tests make sure every bad input is
 // rejected with a clean error instead of crashing or partially-loading.
 
@@ -70,7 +70,7 @@ func TestImportFromContentYAMLWithBOM(t *testing.T) {
 	}
 }
 
-// An empty byte slice must be treated as "use defaults" so the GUI can
+// An empty byte slice must be treated as "use defaults" so the WebUI can
 // import a freshly-created empty file without crashing.
 func TestImportFromContentEmptyBytes(t *testing.T) {
 	t.Parallel()
@@ -176,10 +176,8 @@ func TestImportFromContentOverlayPreservesDefaults(t *testing.T) {
 	}
 }
 
-// A YAML overlay that sets img_rehost=true on a tracker without a policy must
-// be automatically disabled and a warning emitted — that warning is how users
-// find out they lost that setting.
-func TestImportFromContentWarnsOnImgRehostDisable(t *testing.T) {
+// Tracker image-host behavior is preserved for registry-owned runtime policy.
+func TestImportFromContentPreservesImgRehostForRegistryPolicy(t *testing.T) {
 	t.Parallel()
 
 	overlay := []byte("trackers:\n  trackers:\n    TL:\n      img_rehost: true\n")
@@ -187,22 +185,18 @@ func TestImportFromContentWarnsOnImgRehostDisable(t *testing.T) {
 	if err != nil {
 		t.Fatalf("import: %v", err)
 	}
-	if cfg.Trackers.Trackers["TL"].ImgRehost {
-		t.Fatalf("TL img_rehost should have been disabled")
+	if !cfg.Trackers.Trackers["TL"].ImgRehost {
+		t.Fatalf("TL img_rehost should remain enabled until runtime policy evaluation")
 	}
-	found := false
 	for _, w := range warnings {
 		if strings.Contains(w, "TL") {
-			found = true
+			t.Fatalf("unexpected config-layer tracker policy warning: %v", warnings)
 		}
 	}
-	if !found {
-		t.Fatalf("expected warning mentioning TL, got %v", warnings)
-	}
 }
 
 // Files that live under a symlinked parent directory must still be readable,
-// so GUI users working out of a symlinked workspace aren't locked out.
+// so WebUI users working out of a symlinked workspace aren't locked out.
 func TestImportFromFileThroughSymlink(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("symlink privilege on Windows requires elevation")
diff --git a/internal/config/importer/importer_test.go b/internal/config/importer/importer_test.go
index 237b7625..156c8f24 100644
--- a/internal/config/importer/importer_test.go
+++ b/internal/config/importer/importer_test.go
@@ -9,6 +9,7 @@ import (
 	"errors"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 
@@ -93,14 +94,50 @@ func TestImportFromContentRejectsDestructiveObjectOverlays(t *testing.T) {
 		payload []byte
 		wantErr bool
 	}{
-		{name: "yaml-null", file: "config.yaml", payload: []byte("main_settings: null\n")},
-		{name: "yaml-empty-map", file: "config.yaml", payload: []byte("main_settings: {}\n")},
-		{name: "yaml-empty-array", file: "config.yaml", payload: []byte("main_settings: []\n"), wantErr: true},
-		{name: "yaml-scalar", file: "config.yaml", payload: []byte("main_settings: nope\n"), wantErr: true},
-		{name: "json-null", file: "config.json", payload: []byte(`{"MainSettings":null}`)},
-		{name: "json-empty-map", file: "config.json", payload: []byte(`{"MainSettings":{}}`)},
-		{name: "json-empty-array", file: "config.json", payload: []byte(`{"MainSettings":[]}`), wantErr: true},
-		{name: "json-scalar", file: "config.json", payload: []byte(`{"MainSettings":"nope"}`), wantErr: true},
+		{
+			name:    "yaml-null",
+			file:    "config.yaml",
+			payload: []byte("main_settings: null\n"),
+		},
+		{
+			name:    "yaml-empty-map",
+			file:    "config.yaml",
+			payload: []byte("main_settings: {}\n"),
+		},
+		{
+			name:    "yaml-empty-array",
+			file:    "config.yaml",
+			payload: []byte("main_settings: []\n"),
+			wantErr: true,
+		},
+		{
+			name:    "yaml-scalar",
+			file:    "config.yaml",
+			payload: []byte("main_settings: nope\n"),
+			wantErr: true,
+		},
+		{
+			name:    "json-null",
+			file:    "config.json",
+			payload: []byte(`{"MainSettings":null}`),
+		},
+		{
+			name:    "json-empty-map",
+			file:    "config.json",
+			payload: []byte(`{"MainSettings":{}}`),
+		},
+		{
+			name:    "json-empty-array",
+			file:    "config.json",
+			payload: []byte(`{"MainSettings":[]}`),
+			wantErr: true,
+		},
+		{
+			name:    "json-scalar",
+			file:    "config.json",
+			payload: []byte(`{"MainSettings":"nope"}`),
+			wantErr: true,
+		},
 	}
 
 	for _, tt := range tests {
@@ -131,16 +168,56 @@ func TestImportFromContentRejectsUnknownTopLevelSections(t *testing.T) {
 		file    string
 		payload []byte
 	}{
-		{name: "yaml-scalar", file: "config.yaml", payload: []byte("unknown_section: nope\n")},
-		{name: "yaml-array", file: "config.yaml", payload: []byte("unknown_section: []\n")},
-		{name: "yaml-object", file: "config.yaml", payload: []byte("unknown_section:\n  nested: true\n")},
-		{name: "yaml-null", file: "config.yaml", payload: []byte("unknown_section: null\n")},
-		{name: "yaml-case-twin", file: "config.yaml", payload: []byte("MainSettings:\n  TMDBAPI: wrong\n")},
-		{name: "json-scalar", file: "config.json", payload: []byte(`{"UnknownSection":"nope"}`)},
-		{name: "json-array", file: "config.json", payload: []byte(`{"UnknownSection":[]}`)},
-		{name: "json-object", file: "config.json", payload: []byte(`{"UnknownSection":{"nested":true}}`)},
-		{name: "json-null", file: "config.json", payload: []byte(`{"UnknownSection":null}`)},
-		{name: "json-case-twin", file: "config.json", payload: []byte(`{"main_settings":{"tmdb_api":"wrong"}}`)},
+		{
+			name:    "yaml-scalar",
+			file:    "config.yaml",
+			payload: []byte("unknown_section: nope\n"),
+		},
+		{
+			name:    "yaml-array",
+			file:    "config.yaml",
+			payload: []byte("unknown_section: []\n"),
+		},
+		{
+			name:    "yaml-object",
+			file:    "config.yaml",
+			payload: []byte("unknown_section:\n  nested: true\n"),
+		},
+		{
+			name:    "yaml-null",
+			file:    "config.yaml",
+			payload: []byte("unknown_section: null\n"),
+		},
+		{
+			name:    "yaml-case-twin",
+			file:    "config.yaml",
+			payload: []byte("MainSettings:\n  TMDBAPI: wrong\n"),
+		},
+		{
+			name:    "json-scalar",
+			file:    "config.json",
+			payload: []byte(`{"UnknownSection":"nope"}`),
+		},
+		{
+			name:    "json-array",
+			file:    "config.json",
+			payload: []byte(`{"UnknownSection":[]}`),
+		},
+		{
+			name:    "json-object",
+			file:    "config.json",
+			payload: []byte(`{"UnknownSection":{"nested":true}}`),
+		},
+		{
+			name:    "json-null",
+			file:    "config.json",
+			payload: []byte(`{"UnknownSection":null}`),
+		},
+		{
+			name:    "json-case-twin",
+			file:    "config.json",
+			payload: []byte(`{"main_settings":{"tmdb_api":"wrong"}}`),
+		},
 	}
 
 	for _, tt := range tests {
@@ -554,25 +631,73 @@ func TestImportFromFileRejectsOversize(t *testing.T) {
 	}
 }
 
-func TestImportFromContentDisablesUnsupportedImageRehost(t *testing.T) {
+func TestImportFromContentPreservesTrackerImageRehostForRuntimePolicy(t *testing.T) {
 	yaml := []byte("trackers:\n  trackers:\n    TL:\n      img_rehost: true\n")
 
 	cfg, warnings, err := ImportFromContent("config.yaml", yaml)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if cfg.Trackers.Trackers["TL"].ImgRehost {
-		t.Fatal("expected TL img_rehost to be disabled during import")
+	if !cfg.Trackers.Trackers["TL"].ImgRehost {
+		t.Fatal("expected TL img_rehost to remain available for registry policy validation")
 	}
-	found := false
 	for _, w := range warnings {
 		if strings.Contains(w, "TL") && strings.Contains(w, "img_rehost") {
-			found = true
-			break
+			t.Fatalf("unexpected config-layer tracker policy warning: %v", warnings)
 		}
 	}
-	if !found {
-		t.Fatalf("expected warning about TL img_rehost, got %v", warnings)
+}
+
+func TestImportFromContentRemovesDeprecatedTrackerURLs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		filename string
+		payload  []byte
+		paths    []string
+	}{
+		{
+			name:     "yaml",
+			filename: "config.yaml",
+			payload:  []byte("trackers:\n  trackers:\n    BTN:\n      Url: https://btn.invalid\n      api_key: token\n    RETIRED:\n      uRL: https://retired.invalid\n      keep_me: retained\n"),
+			paths:    []string{"trackers.trackers.BTN.Url", "trackers.trackers.RETIRED.uRL"},
+		},
+		{
+			name:     "json",
+			filename: "config.json",
+			payload:  []byte(`{"Trackers":{"Trackers":{"BTN":{"uRl":"https://btn.invalid","APIKey":"token"},"RETIRED":{"URL":"https://retired.invalid","keep_me":"retained"}}}}`),
+			paths:    []string{"Trackers.Trackers.BTN.uRl", "Trackers.Trackers.RETIRED.URL"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			cfg, warnings, err := ImportFromContent(test.filename, test.payload)
+			if err != nil {
+				t.Fatalf("import: %v", err)
+			}
+			if got := cfg.Trackers.Trackers["BTN"].APIKey; got != "token" {
+				t.Fatalf("BTN APIKey = %q", got)
+			}
+			unsupported := cfg.Trackers.Trackers["RETIRED"]
+			if got := unsupported.Unknown["keep_me"]; got != "retained" {
+				t.Fatalf("unsupported field = %#v", got)
+			}
+			for key := range unsupported.Unknown {
+				if strings.EqualFold(strings.TrimSpace(key), "url") {
+					t.Fatalf("deprecated URL survived in Unknown as %q", key)
+				}
+			}
+			for _, path := range test.paths {
+				want := "ignored deprecated tracker URL: " + path
+				if !slices.Contains(warnings, want) {
+					t.Fatalf("missing warning %q in %#v", want, warnings)
+				}
+			}
+		})
 	}
 }
 
@@ -607,7 +732,6 @@ func importSecretConfig(dbPath string) *config.Config {
 			Trackers: map[string]config.TrackerConfig{
 				"BTN": {
 					APIKey: "plain-btn-api-key",
-					URL:    "https://secret.btn.example",
 				},
 			},
 		},
@@ -657,9 +781,6 @@ func assertImportedSecretValues(t *testing.T, cfg *config.Config) {
 	if cfg.Trackers.Trackers["BTN"].APIKey != "plain-btn-api-key" {
 		t.Fatalf("BTN APIKey: got %q", cfg.Trackers.Trackers["BTN"].APIKey)
 	}
-	if cfg.Trackers.Trackers["BTN"].URL != "https://secret.btn.example" {
-		t.Fatalf("BTN URL: got %q", cfg.Trackers.Trackers["BTN"].URL)
-	}
 	if cfg.TorrentClients["qbit"].QbitPass != "plain-qbit-pass" {
 		t.Fatalf("QbitPass: got %q", cfg.TorrentClients["qbit"].QbitPass)
 	}
@@ -676,9 +797,6 @@ func assertNoPlaintextSecretValues(t *testing.T, cfg *config.Config) {
 	if cfg.Trackers.Trackers["BTN"].APIKey == "plain-btn-api-key" {
 		t.Fatal("saved config leaked plaintext BTN APIKey")
 	}
-	if cfg.Trackers.Trackers["BTN"].URL == "https://secret.btn.example" {
-		t.Fatal("saved config leaked plaintext BTN URL")
-	}
 	if cfg.TorrentClients["qbit"].QbitPass == "plain-qbit-pass" {
 		t.Fatal("saved config leaked plaintext QbitPass")
 	}
diff --git a/internal/config/legacy/converter.go b/internal/config/legacy/converter.go
index e09b5944..6c8fbcaf 100644
--- a/internal/config/legacy/converter.go
+++ b/internal/config/legacy/converter.go
@@ -225,7 +225,16 @@ func migrateTrackers(legacyTrackers map[string]any, template *config.Config, out
 			continue
 		}
 		if !knownTrackers[trackerName] {
-			warnings = append(warnings, "skipped unknown tracker: "+trackerName)
+			unknown := make(map[string]any, len(trackerValues))
+			for key, value := range trackerValues {
+				if strings.EqualFold(strings.TrimSpace(key), "url") {
+					warnings = append(warnings, fmt.Sprintf("ignored deprecated tracker URL: trackers.%s.%s", trackerName, key))
+					continue
+				}
+				unknown[key] = value
+			}
+			out.Trackers.Trackers[trackerName] = config.TrackerConfig{Unknown: unknown}
+			warnings = append(warnings, "preserved unsupported tracker entry: "+trackerName)
 			continue
 		}
 
@@ -234,6 +243,10 @@ func migrateTrackers(legacyTrackers map[string]any, template *config.Config, out
 		outTracker := out.Trackers.Trackers[trackerName]
 
 		for key, value := range trackerValues {
+			if strings.EqualFold(strings.TrimSpace(key), "url") {
+				warnings = append(warnings, fmt.Sprintf("ignored deprecated tracker URL: trackers.%s.%s", trackerName, key))
+				continue
+			}
 			templateValue := getTrackerFieldTemplate(templateTracker, hasTemplate, key)
 			if templateValue == nil {
 				warnings = append(warnings, fmt.Sprintf("skipped unknown tracker key %s.%s", trackerName, key))
@@ -486,7 +499,7 @@ func getTrackerFieldTemplate(templateTracker config.TrackerConfig, hasTemplate b
 
 // getTrackerFieldValue returns the value of a TrackerConfig field by its YAML tag.
 func getTrackerFieldValue(tc config.TrackerConfig, yamlKey string) any {
-	t := reflect.TypeOf(tc)
+	t := reflect.TypeFor[config.TrackerConfig]()
 	v := reflect.ValueOf(tc)
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
@@ -500,9 +513,8 @@ func getTrackerFieldValue(tc config.TrackerConfig, yamlKey string) any {
 
 // getTrackerFieldDefault returns a zero-value for known tracker fields.
 func getTrackerFieldDefault(yamlKey string) any {
-	t := reflect.TypeOf(config.TrackerConfig{})
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
+	t := reflect.TypeFor[config.TrackerConfig]()
+	for field := range t.Fields() {
 		tag := strings.TrimSpace(strings.Split(field.Tag.Get("yaml"), ",")[0])
 		if tag == yamlKey {
 			return reflect.Zero(field.Type).Interface()
@@ -513,7 +525,7 @@ func getTrackerFieldDefault(yamlKey string) any {
 
 // setTrackerField sets a field on a TrackerConfig by its YAML tag name.
 func setTrackerField(tc *config.TrackerConfig, yamlKey string, value any) {
-	t := reflect.TypeOf(*tc)
+	t := reflect.TypeFor[config.TrackerConfig]()
 	v := reflect.ValueOf(tc).Elem()
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
@@ -536,7 +548,7 @@ func setTrackerField(tc *config.TrackerConfig, yamlKey string, value any) {
 // setTorrentClientField sets a field on a TorrentClientConfig by its YAML tag.
 // Returns false if the field is unknown.
 func setTorrentClientField(tc *config.TorrentClientConfig, yamlKey string, value any) bool {
-	t := reflect.TypeOf(*tc)
+	t := reflect.TypeFor[config.TorrentClientConfig]()
 	v := reflect.ValueOf(tc).Elem()
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
diff --git a/internal/config/legacy/converter_test.go b/internal/config/legacy/converter_test.go
index c4f5f048..bb4bcbf5 100644
--- a/internal/config/legacy/converter_test.go
+++ b/internal/config/legacy/converter_test.go
@@ -5,6 +5,7 @@ package legacy
 
 import (
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -447,6 +448,49 @@ config = {
 	}
 }
 
+func TestImportFromContentRemovesDeprecatedTrackerURLs(t *testing.T) {
+	t.Parallel()
+
+	input := []byte(`
+config = {
+    'TRACKERS': {
+        'BTN': {
+            'uRl': 'https://btn.invalid',
+            'api_key': 'token',
+        },
+        'RETIRED': {
+            'Url': 'https://retired.invalid',
+            'keep_me': 'retained',
+        },
+    },
+}
+`)
+
+	cfg, warnings, err := ImportFromContent(input)
+	if err != nil {
+		t.Fatalf("import: %v", err)
+	}
+	if got := cfg.Trackers.Trackers["BTN"].APIKey; got != "token" {
+		t.Fatalf("BTN APIKey = %q", got)
+	}
+	unsupported := cfg.Trackers.Trackers["RETIRED"]
+	if got := unsupported.Unknown["keep_me"]; got != "retained" {
+		t.Fatalf("unsupported field = %#v", got)
+	}
+	for key := range unsupported.Unknown {
+		if strings.EqualFold(strings.TrimSpace(key), "url") {
+			t.Fatalf("deprecated URL survived in Unknown as %q", key)
+		}
+	}
+	for _, path := range []string{"trackers.BTN.uRl", "trackers.RETIRED.Url"} {
+		want := "ignored deprecated tracker URL: " + path
+		found := slices.Contains(warnings, want)
+		if !found {
+			t.Fatalf("missing warning %q in %#v", want, warnings)
+		}
+	}
+}
+
 // marshalLegacyConfig creates a Python config.py format string from a
 // Config for testing purposes.
 func marshalLegacyConfig(lc *Config) []byte {
diff --git a/internal/config/list.go b/internal/config/list.go
index c2c8a50b..6861a12f 100644
--- a/internal/config/list.go
+++ b/internal/config/list.go
@@ -10,6 +10,8 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+// CSVList accepts either a YAML sequence or a comma-separated scalar. Scalar
+// items are trimmed and blanks removed; sequence values are preserved as read.
 type CSVList []string
 
 func (c *CSVList) UnmarshalYAML(value *yaml.Node) error {
@@ -38,6 +40,8 @@ func (c *CSVList) UnmarshalYAML(value *yaml.Node) error {
 	}
 }
 
+// StringList accepts one string or a string sequence in JSON and YAML. Unlike
+// [CSVList], a scalar is one item and is not split on commas.
 type StringList []string
 
 func (l *StringList) UnmarshalJSON(data []byte) error {
diff --git a/internal/config/loader.go b/internal/config/loader.go
index 5ef24b3c..161a1f8f 100644
--- a/internal/config/loader.go
+++ b/internal/config/loader.go
@@ -10,6 +10,8 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+// Load reads YAML, applies environment overrides, and validates the resulting
+// runtime config. It does not overlay embedded defaults.
 func Load(path string) (Config, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
diff --git a/internal/config/persistence.go b/internal/config/persistence.go
index 84b4ffc7..695064e7 100644
--- a/internal/config/persistence.go
+++ b/internal/config/persistence.go
@@ -26,12 +26,14 @@ const (
 	exportFormatJSON
 )
 
-// ExportToYAML writes the config to a YAML file.
+// ExportToYAML writes YAML with known secret fields encrypted. It creates the
+// parent directory and writes the destination with mode 0600.
 func ExportToYAML(cfg *Config, path string) error {
 	return exportToFile(cfg, path, exportFormatYAML, true)
 }
 
-// ExportToPlaintextYAML writes the config to a YAML file without encrypting secret fields.
+// ExportToPlaintextYAML writes YAML without encrypting secret fields. It still
+// uses mode 0600, but callers must treat the file as secret-bearing.
 func ExportToPlaintextYAML(cfg *Config, path string) error {
 	return exportToFile(cfg, path, exportFormatYAML, false)
 }
@@ -81,7 +83,9 @@ func exportToFile(cfg *Config, path string, format exportFormat, encryptSecrets
 	return nil
 }
 
-// ImportFromYAML reads the config from a YAML file.
+// ImportFromYAML reads YAML and decrypts recognized secret envelopes. It does
+// not overlay embedded defaults, apply environment overrides, or validate the
+// resulting config.
 func ImportFromYAML(path string) (*Config, error) {
 	if path == "" {
 		return nil, errors.New("config import: empty path")
@@ -108,12 +112,13 @@ func ImportFromYAML(path string) (*Config, error) {
 	return decryptedCfg, nil
 }
 
-// ExportToJSON serializes the config to a JSON string.
+// ExportToJSON returns indented JSON with known secret fields encrypted.
 func ExportToJSON(cfg *Config) (string, error) {
 	return exportToJSON(cfg, true)
 }
 
-// ExportToPlaintextJSON serializes the config to JSON without encrypting secret fields.
+// ExportToPlaintextJSON returns indented JSON without encrypting secret fields;
+// callers must treat the result as secret-bearing.
 func ExportToPlaintextJSON(cfg *Config) (string, error) {
 	return exportToJSON(cfg, false)
 }
@@ -169,8 +174,8 @@ func importFromJSON(payload string, decryptSecrets bool) (*Config, error) {
 	return decryptedCfg, nil
 }
 
-// BackupToYAML creates a timestamped YAML backup of the current config.
-// Returns the path to the backup file.
+// BackupToYAML writes an encrypted backup to backups/config.yaml below baseDir,
+// replacing any prior backup at that path, and returns the path.
 func BackupToYAML(cfg *Config, baseDir string) (string, error) {
 	if cfg == nil {
 		return "", internalerrors.ErrInvalidInput
@@ -248,6 +253,7 @@ type DatabaseRepairReport struct {
 	BackfilledDefaults bool
 	ChangedSections    []string
 	InvalidPaths       []string
+	DeprecatedPaths    []string
 }
 
 // LoadFromDatabaseWithRepairReport loads and decrypts full config from repo,
@@ -314,10 +320,12 @@ func loadFullConfigOverlayingDefaults(ctx context.Context, repo fullConfigLoader
 	if err := json.Unmarshal(merged, &cfg); err != nil {
 		return Config{}, DatabaseRepairReport{}, fmt.Errorf("config load from database: unmarshal merged defaults: %w", err)
 	}
+	sort.Strings(mergeReport.deprecatedPaths)
 	report := DatabaseRepairReport{
-		BackfilledDefaults: len(mergeReport.missingDefaultPaths) > 0 || len(mergeReport.invalidPaths) > 0,
+		BackfilledDefaults: len(mergeReport.missingDefaultPaths) > 0 || len(mergeReport.invalidPaths) > 0 || len(mergeReport.deprecatedPaths) > 0,
 		ChangedSections:    mergeReport.changedRootSections(),
 		InvalidPaths:       append([]string(nil), mergeReport.invalidPaths...),
+		DeprecatedPaths:    append([]string(nil), mergeReport.deprecatedPaths...),
 	}
 	return cfg, report, nil
 }
@@ -344,6 +352,7 @@ func configJSONMap(cfg *Config) (map[string]any, error) {
 type storedConfigMergeReport struct {
 	missingDefaultPaths []string
 	invalidPaths        []string
+	deprecatedPaths     []string
 	changedSections     map[string]struct{}
 	invalidSections     map[string]struct{}
 }
@@ -358,6 +367,7 @@ func newStoredConfigMergeReport() storedConfigMergeReport {
 func (r *storedConfigMergeReport) append(other storedConfigMergeReport) {
 	r.missingDefaultPaths = append(r.missingDefaultPaths, other.missingDefaultPaths...)
 	r.invalidPaths = append(r.invalidPaths, other.invalidPaths...)
+	r.deprecatedPaths = append(r.deprecatedPaths, other.deprecatedPaths...)
 	for section := range other.changedSections {
 		r.changedSections[section] = struct{}{}
 	}
@@ -404,6 +414,12 @@ func mergeStoredConfigMapWithReport(base map[string]any, overlay map[string]any,
 
 	overlayKeys := make([]string, 0, len(overlay))
 	for key := range overlay {
+		if isDeprecatedTrackerURLField(path, key) {
+			deprecatedPath := configMapPath(path, key)
+			report.deprecatedPaths = append(report.deprecatedPaths, deprecatedPath)
+			report.markChanged(deprecatedPath)
+			continue
+		}
 		if shouldDiscardStoredTrackerField(path, key, overlay) {
 			invalidPath := configMapPath(path, key)
 			report.invalidPaths = append(report.invalidPaths, invalidPath)
@@ -497,7 +513,18 @@ func mergeStoredDynamicConfigValue(base map[string]any, key string, overlayValue
 	}
 
 	if allowsStoredDynamicConfigEntry(path) {
-		if _, overlayOK := overlayValue.(map[string]any); !overlayOK {
+		overlayMap, overlayOK := overlayValue.(map[string]any)
+		if !overlayOK {
+			return report, nil
+		}
+		if usesASCIIStoredTrackerKeys(path) {
+			cleaned := map[string]any{}
+			childReport, err := mergeStoredConfigMapWithReport(cleaned, overlayMap, configMapPath(path, key))
+			if err != nil {
+				return report, err
+			}
+			base[key] = cleaned
+			report.append(childReport)
 			return report, nil
 		}
 	}
@@ -588,6 +615,12 @@ func shouldDiscardStoredTrackerField(path string, key string, values map[string]
 	return hasKnownFoldPeer
 }
 
+func isDeprecatedTrackerURLField(path string, key string) bool {
+	const trackerPathPrefix = "Trackers.Trackers."
+	trackerName, ok := strings.CutPrefix(path, trackerPathPrefix)
+	return ok && trackerName != "" && !strings.Contains(trackerName, ".") && strings.EqualFold(strings.TrimSpace(key), "URL")
+}
+
 // validateStoredOverlayKeys rejects duplicate stored keys that would fold into
 // the same tracker name or tracker field before mutation starts.
 func validateStoredOverlayKeys(base map[string]any, keys []string, path string) error {
@@ -741,6 +774,9 @@ func mergeStoredUnknownConfigValues(current, stored any, path string) error {
 		return nil
 	}
 	for key, storedValue := range storedMap {
+		if isDeprecatedTrackerURLField(path, key) {
+			continue
+		}
 		if shouldDiscardStoredTrackerField(path, key, storedMap) {
 			continue
 		}
@@ -978,7 +1014,8 @@ func encryptConfigSecretsForSectionsWithDBDir(cfg *Config, sections []string, ru
 	return encrypted, nil
 }
 
-// SaveToDatabase persists the config to the repository.
+// SaveToDatabase encrypts known secrets in a clone, then replaces the
+// repository's full config without mutating cfg.
 func SaveToDatabase(ctx context.Context, cfg *Config, repo interface {
 	SaveFullConfig(ctx context.Context, cfg any) error
 }) error {
@@ -1071,7 +1108,9 @@ func SaveSectionsToDatabase(ctx context.Context, cfg *Config, sections []string,
 	return nil
 }
 
-// SaveSectionToDatabase persists a single config section to the repository.
+// SaveSectionToDatabase writes one caller-supplied section verbatim. It does
+// not canonicalize the section name, encrypt secrets, or preserve unknown
+// stored fields; use [SaveSectionsToDatabase] for Config-owned persistence.
 func SaveSectionToDatabase(ctx context.Context, section string, data any, repo interface {
 	SaveConfigSection(ctx context.Context, section string, data any) error
 }) error {
@@ -1092,7 +1131,8 @@ func SaveSectionToDatabase(ctx context.Context, section string, data any, repo i
 	return nil
 }
 
-// LoadSectionFromDatabase retrieves a single config section from the repository.
+// LoadSectionFromDatabase decodes one raw section into dest without applying
+// defaults, decryption, environment overrides, or validation.
 func LoadSectionFromDatabase(ctx context.Context, section string, dest any, repo interface {
 	LoadConfigSection(ctx context.Context, section string, dest any) error
 }) error {
diff --git a/internal/config/persistence_penetration_test.go b/internal/config/persistence_penetration_test.go
index 890bb245..dc144f70 100644
--- a/internal/config/persistence_penetration_test.go
+++ b/internal/config/persistence_penetration_test.go
@@ -383,7 +383,7 @@ func TestImportFromJSONTypeMismatch(t *testing.T) {
 	}
 }
 
-// ExportToJSON must succeed on a fully-zero Config — the GUI calls this on
+// ExportToJSON must succeed on a fully-zero Config — the WebUI calls this on
 // first launch before the user has set anything.
 func TestExportToJSONZeroConfig(t *testing.T) {
 	t.Parallel()
diff --git a/internal/config/persistence_test.go b/internal/config/persistence_test.go
index e8c43360..155f332a 100644
--- a/internal/config/persistence_test.go
+++ b/internal/config/persistence_test.go
@@ -1236,8 +1236,87 @@ func TestLoadFromDatabaseMergesCaseInsensitiveStoredTrackerName(t *testing.T) {
 	if btn.APIKey != "stored-token" {
 		t.Fatalf("expected stored BTN API key, got %q", btn.APIKey)
 	}
-	if btn.URL != "https://stored.btn.example" {
-		t.Fatalf("expected stored BTN URL, got %q", btn.URL)
+	if _, ok := btn.Unknown["URL"]; ok {
+		t.Fatal("expected deprecated BTN URL to be removed")
+	}
+}
+
+func TestLoadFromDatabaseRemovesSupportedAndUnsupportedTrackerURLs(t *testing.T) {
+	t.Parallel()
+
+	raw := defaultDatabaseConfigMap(t)
+	trackerSection, ok := raw["Trackers"].(map[string]any)
+	if !ok {
+		t.Fatal("default database config Trackers section has unexpected shape")
+	}
+	trackerEntries, ok := trackerSection["Trackers"].(map[string]any)
+	if !ok {
+		t.Fatal("default database config tracker entries have unexpected shape")
+	}
+	btnEntry, ok := trackerEntries["BTN"].(map[string]any)
+	if !ok {
+		t.Fatal("default database config BTN entry has unexpected shape")
+	}
+	btnEntry["uRl"] = "https://btn.invalid"
+	trackerEntries["RETIRED"] = map[string]any{
+		"Url":     "https://retired.invalid",
+		"keep_me": "retained",
+	}
+
+	loaded, report, err := LoadFromDatabaseWithRepairReport(context.Background(), &rawConfigRepo{raw: raw})
+	if err != nil {
+		t.Fatalf("LoadFromDatabaseWithRepairReport: %v", err)
+	}
+	for _, path := range []string{"Trackers.Trackers.BTN.uRl", "Trackers.Trackers.RETIRED.Url"} {
+		if !slices.Contains(report.DeprecatedPaths, path) {
+			t.Fatalf("missing deprecated path %q in %#v", path, report.DeprecatedPaths)
+		}
+	}
+	if !slices.Contains(report.ChangedSections, "Trackers") {
+		t.Fatalf("expected Trackers repair section, got %#v", report.ChangedSections)
+	}
+	unsupported := loaded.Trackers.Trackers["RETIRED"]
+	if got := unsupported.Unknown["keep_me"]; got != "retained" {
+		t.Fatalf("unsupported field = %#v", got)
+	}
+	for key := range unsupported.Unknown {
+		if strings.EqualFold(strings.TrimSpace(key), "url") {
+			t.Fatalf("deprecated URL survived in Unknown as %q", key)
+		}
+	}
+}
+
+func TestTrackerURLCannotReappearThroughUnknownOrExport(t *testing.T) {
+	t.Parallel()
+
+	cfg := &Config{Trackers: TrackersConfig{Trackers: map[string]TrackerConfig{
+		"RETIRED": {Unknown: map[string]any{"UrL": "https://retired.invalid", "keep_me": "retained"}},
+	}}}
+
+	jsonPayload, err := ExportToPlaintextJSON(cfg)
+	if err != nil {
+		t.Fatalf("ExportToPlaintextJSON: %v", err)
+	}
+	if strings.Contains(strings.ToLower(jsonPayload), "retired.invalid") {
+		t.Fatalf("deprecated URL survived JSON export: %s", jsonPayload)
+	}
+	if !strings.Contains(jsonPayload, "keep_me") {
+		t.Fatalf("unrelated unknown field missing from JSON export: %s", jsonPayload)
+	}
+
+	yamlPath := filepath.Join(t.TempDir(), "config.yaml")
+	if err := ExportToPlaintextYAML(cfg, yamlPath); err != nil {
+		t.Fatalf("ExportToPlaintextYAML: %v", err)
+	}
+	yamlPayload, err := os.ReadFile(yamlPath)
+	if err != nil {
+		t.Fatalf("read YAML export: %v", err)
+	}
+	if strings.Contains(strings.ToLower(string(yamlPayload)), "retired.invalid") {
+		t.Fatalf("deprecated URL survived YAML export: %s", yamlPayload)
+	}
+	if !strings.Contains(string(yamlPayload), "keep_me") {
+		t.Fatalf("unrelated unknown field missing from YAML export: %s", yamlPayload)
 	}
 }
 
@@ -1320,7 +1399,6 @@ func TestMergeStoredConfigMapMergesCaseInsensitiveStoredTrackerField(t *testing.
 
 	base := map[string]any{
 		"APIKey": "",
-		"URL":    "https://default.example",
 	}
 	overlay := map[string]any{
 		"apikey": "stored-token",
@@ -1547,12 +1625,7 @@ func TestExportImportJSONEncryptsSecrets(t *testing.T) {
 		ArrIntegration: ArrIntegrationConfig{
 			SonarrAPIKey: "plain-sonarr-token",
 		},
-		Trackers: TrackersConfig{
-			Trackers: map[string]TrackerConfig{
-				"BTN": {URL: "https://secret.btn.example"},
-				"HDT": {URL: "https://public.hdt.example"},
-			},
-		},
+		Trackers:           TrackersConfig{Trackers: map[string]TrackerConfig{}},
 		ScreenshotHandling: ScreenshotHandlingConfig{Screens: 1},
 	}
 
@@ -1567,12 +1640,6 @@ func TestExportImportJSONEncryptsSecrets(t *testing.T) {
 	if strings.Contains(exported, "plain-sonarr-token") {
 		t.Fatalf("exported JSON leaked plaintext Sonarr key")
 	}
-	if strings.Contains(exported, "https://secret.btn.example") {
-		t.Fatalf("exported JSON leaked plaintext BTN URL")
-	}
-	if !strings.Contains(exported, "https://public.hdt.example") {
-		t.Fatalf("exported JSON should keep non-BTN tracker URL plaintext")
-	}
 	if !strings.Contains(exported, encryptedEnvelopePrefix) {
 		t.Fatalf("exported JSON did not contain encrypted secret envelopes")
 	}
@@ -1588,12 +1655,6 @@ func TestExportImportJSONEncryptsSecrets(t *testing.T) {
 	if imported.ArrIntegration.SonarrAPIKey != "plain-sonarr-token" {
 		t.Fatalf("Sonarr API key mismatch after round-trip: got %q", imported.ArrIntegration.SonarrAPIKey)
 	}
-	if imported.Trackers.Trackers["BTN"].URL != "https://secret.btn.example" {
-		t.Fatalf("BTN URL mismatch after round-trip: got %q", imported.Trackers.Trackers["BTN"].URL)
-	}
-	if imported.Trackers.Trackers["HDT"].URL != "https://public.hdt.example" {
-		t.Fatalf("HDT URL mismatch after round-trip: got %q", imported.Trackers.Trackers["HDT"].URL)
-	}
 }
 
 func TestSaveLoadDatabaseEncryptsSecrets(t *testing.T) {
diff --git a/internal/config/secrets.go b/internal/config/secrets.go
index b82cebfd..77afcbfb 100644
--- a/internal/config/secrets.go
+++ b/internal/config/secrets.go
@@ -440,13 +440,6 @@ func walkSecretFields(cfg *Config, visit func(path string, value *string) error)
 			{name: "PronfoRAPIID", field: &entry.PronfoRAPIID},
 			{name: "LoginQuestion", field: &entry.LoginQuestion},
 			{name: "LoginAnswer", field: &entry.LoginAnswer},
-			{name: "Filebrowser", field: &entry.Filebrowser},
-		}
-		if strings.EqualFold(strings.TrimSpace(name), "BTN") {
-			trackerSecrets = append(trackerSecrets, struct {
-				name  string
-				field *string
-			}{name: "URL", field: &entry.URL})
 		}
 		for _, item := range trackerSecrets {
 			if err := visit("Trackers."+name+"."+item.name, item.field); err != nil {
@@ -505,7 +498,12 @@ func resolveSecretHelper(cfg *Config) (string, error) {
 
 	// Enforce owner-only rw permissions on Unix-like systems.
 	if runtime.GOOS != "windows" && info.Mode().Perm()&^0o600 != 0 {
-		return "", fmt.Errorf("%w: %s must have permissions 0600 (owner read/write only), got %o", ErrSecretEncryptionHelperUnavailable, webAuthFileName, info.Mode().Perm())
+		return "", fmt.Errorf(
+			"%w: %s must have permissions 0600 (owner read/write only), got %o",
+			ErrSecretEncryptionHelperUnavailable,
+			webAuthFileName,
+			info.Mode().Perm(),
+		)
 	}
 
 	record, err := authmaterial.LoadFromDBPath(dbPath)
@@ -597,7 +595,11 @@ func decryptSecretString(value string, helper string) (string, error) {
 		return "", fmt.Errorf("secrets: decode auth tag: %w", err)
 	}
 
-	return decryptSecretValue(secretPayload{ciphertext: ciphertext, nonce: nonce, authTag: authTag}, key)
+	return decryptSecretValue(secretPayload{
+		ciphertext: ciphertext,
+		nonce:      nonce,
+		authTag:    authTag,
+	}, key)
 }
 
 func isSecretEnvelope(value string) bool {
diff --git a/internal/config/tracker_catalog.go b/internal/config/tracker_catalog.go
new file mode 100644
index 00000000..914d8001
--- /dev/null
+++ b/internal/config/tracker_catalog.go
@@ -0,0 +1,194 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package config
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"gopkg.in/yaml.v3"
+)
+
+// TrackerFieldSchema maps one ordered field between JSON and YAML, records its
+// embedded default, and marks whether a non-empty value activates configured state.
+type TrackerFieldSchema struct {
+	JSONKey    string
+	YAMLKey    string
+	Default    any
+	Activation bool
+}
+
+// TrackerSchema describes the ordered configuration surface for one supported tracker.
+type TrackerSchema struct {
+	Name   string
+	Fields []TrackerFieldSchema
+}
+
+var (
+	orderedTrackerSchemaOnce sync.Once
+	orderedTrackerSchemas    []TrackerSchema
+	errOrderedTrackerSchema  error
+)
+
+var trackerActivationYAMLKeys = map[string]struct{}{
+	"api_key":         {},
+	"ApiUser":         {},
+	"ApiKey":          {},
+	"username":        {},
+	"password":        {},
+	"passkey":         {},
+	"announce_url":    {},
+	"my_announce_url": {},
+}
+
+// OrderedTrackerSchemas returns a defensive copy of the tracker schemas declared
+// by the embedded example config, preserving tracker and field declaration order.
+func OrderedTrackerSchemas() ([]TrackerSchema, error) {
+	orderedTrackerSchemaOnce.Do(func() {
+		orderedTrackerSchemas, errOrderedTrackerSchema = parseOrderedTrackerSchemas(EmbeddedExampleYAML())
+	})
+	if errOrderedTrackerSchema != nil {
+		return nil, errOrderedTrackerSchema
+	}
+	return cloneTrackerSchemas(orderedTrackerSchemas), nil
+}
+
+// TrackerConfigured reports whether any schema activation field has a non-empty
+// value. Configured state is intentionally weaker than authentication readiness.
+func TrackerConfigured(cfg TrackerConfig, schema TrackerSchema) bool {
+	values, err := trackerConfigToJSONMap(cfg)
+	if err != nil {
+		return false
+	}
+	for _, field := range schema.Fields {
+		if !field.Activation {
+			continue
+		}
+		value, ok := values[field.JSONKey]
+		if ok && strings.TrimSpace(fmt.Sprint(value)) != "" {
+			return true
+		}
+	}
+	return false
+}
+
+func parseOrderedTrackerSchemas(data []byte) ([]TrackerSchema, error) {
+	var document yaml.Node
+	if err := yaml.Unmarshal(data, &document); err != nil {
+		return nil, fmt.Errorf("config: parse tracker catalog: %w", err)
+	}
+	root := document.Content
+	if len(root) != 1 || root[0].Kind != yaml.MappingNode {
+		return nil, errors.New("config: tracker catalog root must be a mapping")
+	}
+	trackersNode := mappingValue(root[0], "trackers")
+	if trackersNode == nil || trackersNode.Kind != yaml.MappingNode {
+		return nil, errors.New("config: tracker catalog is missing trackers mapping")
+	}
+
+	initTrackerTagMetadata()
+	schemas := make([]TrackerSchema, 0, len(trackersNode.Content)/2)
+	seen := make(map[string]struct{}, len(trackersNode.Content)/2)
+	for index := 0; index+1 < len(trackersNode.Content); index += 2 {
+		name := strings.ToUpper(strings.TrimSpace(trackersNode.Content[index].Value))
+		if name == "" || name == "DEFAULT_TRACKERS" || name == "PREFERRED_TRACKER" {
+			continue
+		}
+		if _, exists := seen[name]; exists {
+			return nil, fmt.Errorf("config: duplicate tracker catalog entry %q", name)
+		}
+		seen[name] = struct{}{}
+
+		entry := trackersNode.Content[index+1]
+		if entry.Kind != yaml.MappingNode {
+			return nil, fmt.Errorf("config: tracker catalog entry %s must be a mapping", name)
+		}
+		fields := make([]TrackerFieldSchema, 0, len(entry.Content)/2+2)
+		activationCount := 0
+		for fieldIndex := 0; fieldIndex+1 < len(entry.Content); fieldIndex += 2 {
+			yamlKey := strings.TrimSpace(entry.Content[fieldIndex].Value)
+			if strings.EqualFold(yamlKey, "url") {
+				return nil, fmt.Errorf("config: tracker catalog entry %s contains deprecated url field", name)
+			}
+			jsonKey, ok := trackerYAMLToJSON[yamlKey]
+			if !ok {
+				return nil, fmt.Errorf("config: tracker catalog entry %s has unknown field %q", name, yamlKey)
+			}
+			var defaultValue any
+			if err := entry.Content[fieldIndex+1].Decode(&defaultValue); err != nil {
+				return nil, fmt.Errorf("config: decode tracker catalog default %s.%s: %w", name, yamlKey, err)
+			}
+			_, activation := trackerActivationYAMLKeys[yamlKey]
+			if activation {
+				activationCount++
+				if value, ok := defaultValue.(string); !ok || value != "" {
+					return nil, fmt.Errorf("config: tracker catalog activation default %s.%s must be empty", name, yamlKey)
+				}
+			}
+			fields = append(fields, TrackerFieldSchema{
+				JSONKey:    jsonKey,
+				YAMLKey:    yamlKey,
+				Default:    defaultValue,
+				Activation: activation,
+			})
+		}
+		if activationCount == 0 {
+			return nil, fmt.Errorf("config: tracker catalog entry %s has no activation field", name)
+		}
+		fields = appendMissingGlobalTrackerFields(fields)
+		schemas = append(schemas, TrackerSchema{Name: name, Fields: fields})
+	}
+	return schemas, nil
+}
+
+func appendMissingGlobalTrackerFields(fields []TrackerFieldSchema) []TrackerFieldSchema {
+	present := make(map[string]struct{}, len(fields))
+	for _, field := range fields {
+		present[field.JSONKey] = struct{}{}
+	}
+	for _, field := range []TrackerFieldSchema{
+		{
+			JSONKey: "FaviconURL",
+			YAMLKey: "favicon_url",
+			Default: "",
+		},
+		{
+			JSONKey: "ImageHost",
+			YAMLKey: "image_host",
+			Default: "",
+		},
+		{
+			JSONKey: "TorrentClient",
+			YAMLKey: "torrent_client",
+			Default: "",
+		},
+	} {
+		if _, ok := present[field.JSONKey]; !ok {
+			fields = append(fields, field)
+		}
+	}
+	return fields
+}
+
+func mappingValue(mapping *yaml.Node, key string) *yaml.Node {
+	for index := 0; index+1 < len(mapping.Content); index += 2 {
+		if mapping.Content[index].Value == key {
+			return mapping.Content[index+1]
+		}
+	}
+	return nil
+}
+
+func cloneTrackerSchemas(schemas []TrackerSchema) []TrackerSchema {
+	cloned := make([]TrackerSchema, len(schemas))
+	for index, schema := range schemas {
+		cloned[index] = TrackerSchema{
+			Name:   schema.Name,
+			Fields: append([]TrackerFieldSchema(nil), schema.Fields...),
+		}
+	}
+	return cloned
+}
diff --git a/internal/config/tracker_catalog_test.go b/internal/config/tracker_catalog_test.go
new file mode 100644
index 00000000..810980ce
--- /dev/null
+++ b/internal/config/tracker_catalog_test.go
@@ -0,0 +1,92 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package config
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestOrderedTrackerSchemasPreserveExampleOrderAndActivation(t *testing.T) {
+	t.Parallel()
+
+	schemas, err := OrderedTrackerSchemas()
+	if err != nil {
+		t.Fatalf("OrderedTrackerSchemas() error = %v", err)
+	}
+	if len(schemas) == 0 {
+		t.Fatal("OrderedTrackerSchemas() returned no schemas")
+	}
+	if schemas[0].Name != "A4K" {
+		t.Fatalf("first schema = %q, want A4K", schemas[0].Name)
+	}
+	if slices.ContainsFunc(schemas, func(schema TrackerSchema) bool { return schema.Name == "MANUAL" }) {
+		t.Fatal("catalog contains removed MANUAL entry")
+	}
+	for _, schema := range schemas {
+		activationCount := 0
+		for _, field := range schema.Fields {
+			if field.Activation {
+				activationCount++
+			}
+			if field.YAMLKey == "url" {
+				t.Fatalf("schema %s contains deprecated url field", schema.Name)
+			}
+		}
+		if activationCount == 0 {
+			t.Fatalf("schema %s has no activation fields", schema.Name)
+		}
+	}
+}
+
+func TestTrackerConfiguredUsesOnlyActivationFields(t *testing.T) {
+	t.Parallel()
+
+	schema := TrackerSchema{
+		Name: "EXAMPLE",
+		Fields: []TrackerFieldSchema{
+			{
+JSONKey: "APIKey",
+ YAMLKey: "api_key",
+ Default: "",
+ Activation: true,
+},
+			{
+JSONKey: "ImageHost",
+ YAMLKey: "image_host",
+ Default: "",
+},
+		},
+	}
+	if TrackerConfigured(TrackerConfig{ImageHost: "imgbox"}, schema) {
+		t.Fatal("optional image host marked tracker configured")
+	}
+	if !TrackerConfigured(TrackerConfig{APIKey: "configured"}, schema) {
+		t.Fatal("non-empty activation field did not mark tracker configured")
+	}
+	if !TrackerConfigured(TrackerConfig{APIKey: "********"}, schema) {
+		t.Fatal("redacted activation field did not remain configured")
+	}
+
+	partialSchema := TrackerSchema{
+		Name: "PARTIAL",
+		Fields: []TrackerFieldSchema{
+			{
+JSONKey: "Username",
+ YAMLKey: "username",
+ Default: "",
+ Activation: true,
+},
+			{
+JSONKey: "Password",
+ YAMLKey: "password",
+ Default: "",
+ Activation: true,
+},
+		},
+	}
+	if !TrackerConfigured(TrackerConfig{Username: "configured", Password: ""}, partialSchema) {
+		t.Fatal("one non-empty activation field should mark tracker configured before readiness")
+	}
+}
diff --git a/internal/config/validate_penetration_test.go b/internal/config/validate_penetration_test.go
index 6fb909f4..92e8e74a 100644
--- a/internal/config/validate_penetration_test.go
+++ b/internal/config/validate_penetration_test.go
@@ -6,8 +6,6 @@ package config
 import (
 	"strings"
 	"testing"
-
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
 )
 
 // Validate is the CLI's fail-fast check. These tests target every failure
@@ -116,7 +114,11 @@ func TestValidateTorrentClientTypeDefaultsToQbit(t *testing.T) {
 
 	cfg := withBase(func(c *Config) {
 		c.TorrentClients = map[string]TorrentClientConfig{
-			"q": {QbitURL: "http://x", QbitUser: "u", QbitPass: "p"},
+			"q": {
+				QbitURL:  "http://x",
+				QbitUser: "u",
+				QbitPass: "p",
+			},
 		}
 	})
 	if err := cfg.Validate(); err != nil {
@@ -161,8 +163,18 @@ func TestValidateQbitHostAlternatives(t *testing.T) {
 		name   string
 		client TorrentClientConfig
 	}{
-		{"url", TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p"}},
-		{"qbit_url", TorrentClientConfig{Type: "qbit", QbitURL: "http://x", QbitUser: "u", QbitPass: "p"}},
+		{"url", TorrentClientConfig{
+			Type:     "qbit",
+			URL:      "http://x",
+			Username: "u",
+			Password: "p",
+		}},
+		{"qbit_url", TorrentClientConfig{
+			Type:     "qbit",
+			QbitURL:  "http://x",
+			QbitUser: "u",
+			QbitPass: "p",
+		}},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
@@ -212,9 +224,21 @@ func TestValidateQbitMissingCredentials(t *testing.T) {
 		client TorrentClientConfig
 		msg    string
 	}{
-		{"missing host", TorrentClientConfig{Type: "qbit", Username: "u", Password: "p"}, "url"},
-		{"missing user", TorrentClientConfig{Type: "qbit", URL: "http://x", Password: "p"}, "username"},
-		{"missing pass", TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u"}, "password"},
+		{"missing host", TorrentClientConfig{
+			Type:     "qbit",
+			Username: "u",
+			Password: "p",
+		}, "url"},
+		{"missing user", TorrentClientConfig{
+			Type:     "qbit",
+			URL:      "http://x",
+			Password: "p",
+		}, "username"},
+		{"missing pass", TorrentClientConfig{
+			Type:     "qbit",
+			URL:      "http://x",
+			Username: "u",
+		}, "password"},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -239,26 +263,58 @@ func TestValidateQbitLinking(t *testing.T) {
 		wantErr string
 	}{
 		{
-			name:    "hardlink requires linked folder",
-			client:  TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p", Linking: "hardlink"},
+			name: "hardlink requires linked folder",
+			client: TorrentClientConfig{
+				Type:     "qbit",
+				URL:      "http://x",
+				Username: "u",
+				Password: "p",
+				Linking:  "hardlink",
+			},
 			wantErr: "linked_folder",
 		},
 		{
-			name:   "symlink accepts linked folder",
-			client: TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p", Linking: "symlink", LinkedFolder: StringList{"D:\\Links"}},
+			name: "symlink accepts linked folder",
+			client: TorrentClientConfig{
+				Type:         "qbit",
+				URL:          "http://x",
+				Username:     "u",
+				Password:     "p",
+				Linking:      "symlink",
+				LinkedFolder: StringList{"D:\\Links"},
+			},
 		},
 		{
-			name:   "reflink accepts linked folder",
-			client: TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p", Linking: "reflink", LinkedFolder: StringList{"D:\\Links"}},
+			name: "reflink accepts linked folder",
+			client: TorrentClientConfig{
+				Type:         "qbit",
+				URL:          "http://x",
+				Username:     "u",
+				Password:     "p",
+				Linking:      "reflink",
+				LinkedFolder: StringList{"D:\\Links"},
+			},
 		},
 		{
-			name:    "reflink requires linked folder",
-			client:  TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p", Linking: "reflink"},
+			name: "reflink requires linked folder",
+			client: TorrentClientConfig{
+				Type:     "qbit",
+				URL:      "http://x",
+				Username: "u",
+				Password: "p",
+				Linking:  "reflink",
+			},
 			wantErr: "linked_folder",
 		},
 		{
-			name:    "invalid mode rejected",
-			client:  TorrentClientConfig{Type: "qbit", URL: "http://x", Username: "u", Password: "p", Linking: "copy"},
+			name: "invalid mode rejected",
+			client: TorrentClientConfig{
+				Type:     "qbit",
+				URL:      "http://x",
+				Username: "u",
+				Password: "p",
+				Linking:  "copy",
+			},
 			wantErr: "linking",
 		},
 	}
@@ -309,49 +365,3 @@ func TestValidateQuiRequiresProxy(t *testing.T) {
 		t.Fatalf("want qui_proxy_url error, got %v", err)
 	}
 }
-
-// Every known tracker with an image-rehost policy must accept img_rehost=true.
-// If the schema shrinks, at least one tracker from each policy should still
-// pass so we don't accidentally flip a whole group off.
-func TestValidateAllImageRehostPoliciesAccepted(t *testing.T) {
-	t.Parallel()
-
-	for trackerName := range imagehostpolicy.KnownTrackerPolicies() {
-		cfg := withBase(func(c *Config) {
-			trackerCfg := TrackerConfig{ImgRehost: true}
-			if strings.EqualFold(trackerName, "THR") {
-				trackerCfg.ImgAPI = "secret"
-			}
-			c.Trackers.Trackers = map[string]TrackerConfig{trackerName: trackerCfg}
-		})
-		if err := cfg.Validate(); err != nil {
-			t.Errorf("tracker %s img_rehost should validate: %v", trackerName, err)
-		}
-	}
-}
-
-// A tracker name that doesn't match any policy (even with mixed case) must be
-// rejected when img_rehost is requested.
-func TestValidateUnknownRehostPolicyRejected(t *testing.T) {
-	t.Parallel()
-
-	cfg := withBase(func(c *Config) {
-		c.Trackers.Trackers = map[string]TrackerConfig{"TL": {ImgRehost: true}}
-	})
-	err := cfg.Validate()
-	if err == nil || !strings.Contains(err.Error(), "TL") {
-		t.Fatalf("want TL rejection, got %v", err)
-	}
-}
-
-// Case insensitivity: "hdb" must resolve the same policy as "HDB".
-func TestValidateImageRehostTrackerNameCaseInsensitive(t *testing.T) {
-	t.Parallel()
-
-	cfg := withBase(func(c *Config) {
-		c.Trackers.Trackers = map[string]TrackerConfig{"hdb": {ImgRehost: true}}
-	})
-	if err := cfg.Validate(); err != nil {
-		t.Fatalf("lowercase tracker name should still resolve policy: %v", err)
-	}
-}
diff --git a/internal/configstore/dbloader.go b/internal/configstore/dbloader.go
index 45e62071..cf16f6fc 100644
--- a/internal/configstore/dbloader.go
+++ b/internal/configstore/dbloader.go
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 // Package configstore bridges the config package and the sqlite repository
-// so CLI, GUI, and webserver share a single implementation of the
+// so CLI and WebUI share a single implementation of the
 // open-database → migrate → load/save flow that used to be duplicated across
-// cmd/upbrr/main.go and internal/guiapp/config.go.
+// cmd/upbrr/main.go and internal/webserver runtime activation.
 package configstore
 
 import (
@@ -81,7 +81,7 @@ func LoadFromPathOrEmbedded(path string) (*config.Config, error) {
 // database, and applies environment overrides.
 //
 // Callers decide whether to validate the returned config — the CLI fails fast
-// while the web/GUI start with invalid config so users can fix it via the UI.
+// while the WebUI starts with invalid config so users can fix it via the UI.
 func LoadFromDBPath(ctx context.Context, dbPath string) (*config.Config, error) {
 	return loadFromDBPath(ctx, dbPath, true)
 }
@@ -111,11 +111,7 @@ func loadFromDBPath(ctx context.Context, dbPath string, applyEnv bool) (*config.
 		return nil, fmt.Errorf("config store: %w", err)
 	}
 	changedSections = append(changedSections, mergeReport.ChangedSections...)
-	sanitizedTrackers := len(config.DisableUnsupportedTrackerImageRehosts(loaded)) > 0
-	if sanitizedTrackers {
-		changedSections = append(changedSections, "Trackers")
-	}
-	if repairReport.BackfilledDefaults || mergeReport.Changed || sanitizedTrackers {
+	if repairReport.BackfilledDefaults || mergeReport.Changed {
 		if err := config.SaveSectionsToDatabase(ctx, loaded, changedSections, repo); err != nil {
 			return nil, fmt.Errorf("config store: %w", err)
 		}
@@ -151,6 +147,19 @@ func SaveToDBPath(ctx context.Context, cfg *config.Config, dbPath string) error
 // SaveToRepository persists cfg and cookie encryption auth metadata through one
 // repository transaction.
 func SaveToRepository(ctx context.Context, cfg *config.Config, repo *db.SQLiteRepository, dbPath string) error {
+	return SaveToRepositoryWithPreSave(ctx, cfg, repo, dbPath, nil)
+}
+
+// SaveToRepositoryWithPreSave persists cfg, cookie encryption auth metadata,
+// and preSave writes through one repository transaction. preSave receives the
+// current cookie encryption key, or nil when web auth material is unavailable.
+func SaveToRepositoryWithPreSave(
+	ctx context.Context,
+	cfg *config.Config,
+	repo *db.SQLiteRepository,
+	dbPath string,
+	preSave func(context.Context, *sql.Tx, []byte) error,
+) error {
 	if cfg == nil {
 		return internalerrors.ErrInvalidInput
 	}
@@ -164,9 +173,15 @@ func SaveToRepository(ctx context.Context, cfg *config.Config, repo *db.SQLiteRe
 	}
 
 	if err := repo.SaveFullConfigWithPreSave(ctx, encryptedCfg, func(ctx context.Context, tx *sql.Tx) error {
-		if err := syncCookieEncryptionBeforeConfigSaveTx(ctx, tx, dbPath); err != nil {
+		key, err := syncCookieEncryptionBeforeConfigSaveTx(ctx, tx, dbPath)
+		if err != nil {
 			return fmt.Errorf("cookie encryption sync before config save: %w", err)
 		}
+		if preSave != nil {
+			if err := preSave(ctx, tx, key); err != nil {
+				return fmt.Errorf("config pre-save: %w", err)
+			}
+		}
 		return nil
 	}); err != nil {
 		return fmt.Errorf("config save to database: %w", err)
@@ -178,14 +193,15 @@ func SaveToRepository(ctx context.Context, cfg *config.Config, repo *db.SQLiteRe
 // syncCookieEncryptionBeforeConfigSaveTx updates cookie encryption metadata in
 // the caller's config-save transaction, treating missing auth material as a
 // plaintext-cookie install rather than a save failure.
-func syncCookieEncryptionBeforeConfigSaveTx(ctx context.Context, tx *sql.Tx, dbPath string) error {
-	if err := cookies.SyncCookieEncryptionWithAuthTx(ctx, tx, dbPath); err != nil {
+func syncCookieEncryptionBeforeConfigSaveTx(ctx context.Context, tx *sql.Tx, dbPath string) ([]byte, error) {
+	key, err := cookies.InitializeEncryptionKeyTx(ctx, tx, dbPath)
+	if err != nil {
 		if errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			return nil
+			return nil, nil
 		}
-		return fmt.Errorf("sync cookie encryption with auth: %w", err)
+		return nil, fmt.Errorf("sync cookie encryption with auth: %w", err)
 	}
-	return nil
+	return key, nil
 }
 
 // Bootstrap resolves the effective config and database path at process
@@ -208,7 +224,12 @@ func Bootstrap(ctx context.Context, configPath string, configProvided, persistYA
 // so environment-only fixes cannot write a config that fails after env removal.
 // Without a hook, provided YAML/JSON is merged with stored DB config when
 // present and persisted only if the persisted candidate validates.
-func BootstrapWithValidator(ctx context.Context, configPath string, configProvided, persistYAML bool, validateBeforePersist func(*config.Config) error) (config.Config, string, error) {
+func BootstrapWithValidator(
+	ctx context.Context,
+	configPath string,
+	configProvided, persistYAML bool,
+	validateBeforePersist func(*config.Config) error,
+) (config.Config, string, error) {
 	if configProvided {
 		resolved, err := ResolveYAMLPath(configPath, configProvided)
 		if err != nil {
@@ -333,7 +354,13 @@ func validatePersistableConfig(cfg *config.Config, dbPath string, validate func(
 // prepareProvidedConfigForSave decides whether a provided config should replace
 // or merge with stored DB config. It uses the already-read providedData for
 // native YAML/JSON overlays so validation and persistence share one input.
-func prepareProvidedConfigForSave(ctx context.Context, configPath string, providedData []byte, imported *config.Config, dbPath string) (*config.Config, *config.Config, bool, error) {
+func prepareProvidedConfigForSave(
+	ctx context.Context,
+	configPath string,
+	providedData []byte,
+	imported *config.Config,
+	dbPath string,
+) (*config.Config, *config.Config, bool, error) {
 	stored, err := loadStoredConfigForProvidedMerge(ctx, dbPath)
 	storedLoaded := err == nil
 	if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
@@ -369,7 +396,8 @@ func prepareProvidedConfigForSave(ctx context.Context, configPath string, provid
 // disabled only in the returned copy so an invalid provided config cannot mutate
 // the database during validation.
 func loadStoredConfigForProvidedMerge(ctx context.Context, dbPath string) (*config.Config, error) {
-	if _, err := os.Stat(dbPath); err != nil { //nolint:gosec // Existence probe for resolved DB path avoids creating SQLite DB before provided config validates.
+	//nolint:gosec // Existence probe for resolved DB path avoids creating SQLite DB before provided config validates.
+	if _, err := os.Stat(dbPath); err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, internalerrors.ErrNotFound
 		}
@@ -393,7 +421,6 @@ func loadStoredConfigForProvidedMerge(ctx context.Context, dbPath string) (*conf
 	if _, err := config.MergeMissingTrackerDefaults(loaded); err != nil {
 		return nil, fmt.Errorf("config store: %w", err)
 	}
-	config.DisableUnsupportedTrackerImageRehosts(loaded)
 	return loaded, nil
 }
 
@@ -610,7 +637,6 @@ func finalizeMergedConfig(cfg *config.Config) (*config.Config, error) {
 	if _, err := config.MergeMissingTrackerDefaults(decrypted); err != nil {
 		return nil, fmt.Errorf("config store: merge tracker defaults: %w", err)
 	}
-	config.DisableUnsupportedTrackerImageRehosts(decrypted)
 	return decrypted, nil
 }
 
diff --git a/internal/configstore/dbloader_internal_test.go b/internal/configstore/dbloader_internal_test.go
index 0088cb37..720acfa6 100644
--- a/internal/configstore/dbloader_internal_test.go
+++ b/internal/configstore/dbloader_internal_test.go
@@ -72,14 +72,50 @@ func TestMergeNativeConfigObjectOverlayMatrix(t *testing.T) {
 		payload []byte
 		wantErr bool
 	}{
-		{name: "yaml-null", format: "yaml", payload: []byte("main_settings: null\n")},
-		{name: "yaml-empty-map", format: "yaml", payload: []byte("main_settings: {}\n")},
-		{name: "yaml-empty-array", format: "yaml", payload: []byte("main_settings: []\n"), wantErr: true},
-		{name: "yaml-scalar", format: "yaml", payload: []byte("main_settings: nope\n"), wantErr: true},
-		{name: "json-null", format: "json", payload: []byte(`{"MainSettings":null}`)},
-		{name: "json-empty-map", format: "json", payload: []byte(`{"MainSettings":{}}`)},
-		{name: "json-empty-array", format: "json", payload: []byte(`{"MainSettings":[]}`), wantErr: true},
-		{name: "json-scalar", format: "json", payload: []byte(`{"MainSettings":"nope"}`), wantErr: true},
+		{
+			name:    "yaml-null",
+			format:  "yaml",
+			payload: []byte("main_settings: null\n"),
+		},
+		{
+			name:    "yaml-empty-map",
+			format:  "yaml",
+			payload: []byte("main_settings: {}\n"),
+		},
+		{
+			name:    "yaml-empty-array",
+			format:  "yaml",
+			payload: []byte("main_settings: []\n"),
+			wantErr: true,
+		},
+		{
+			name:    "yaml-scalar",
+			format:  "yaml",
+			payload: []byte("main_settings: nope\n"),
+			wantErr: true,
+		},
+		{
+			name:    "json-null",
+			format:  "json",
+			payload: []byte(`{"MainSettings":null}`),
+		},
+		{
+			name:    "json-empty-map",
+			format:  "json",
+			payload: []byte(`{"MainSettings":{}}`),
+		},
+		{
+			name:    "json-empty-array",
+			format:  "json",
+			payload: []byte(`{"MainSettings":[]}`),
+			wantErr: true,
+		},
+		{
+			name:    "json-scalar",
+			format:  "json",
+			payload: []byte(`{"MainSettings":"nope"}`),
+			wantErr: true,
+		},
 	}
 
 	for _, tt := range tests {
@@ -190,8 +226,16 @@ func TestMergeNativeConfigTorrentClientCollectionNullKeepsStoredClients(t *testi
 		format  string
 		payload []byte
 	}{
-		{name: "yaml", format: "yaml", payload: []byte("torrent_clients: null\n")},
-		{name: "json", format: "json", payload: []byte(`{"TorrentClients":null}`)},
+		{
+			name:    "yaml",
+			format:  "yaml",
+			payload: []byte("torrent_clients: null\n"),
+		},
+		{
+			name:    "json",
+			format:  "json",
+			payload: []byte(`{"TorrentClients":null}`),
+		},
 	}
 
 	for _, tt := range tests {
@@ -232,10 +276,26 @@ func TestMergeNativeConfigRejectsInvalidDynamicTorrentClientEntries(t *testing.T
 		format  string
 		payload []byte
 	}{
-		{name: "yaml-scalar", format: "yaml", payload: []byte("torrent_clients:\n  watch-client: nope\n")},
-		{name: "yaml-array", format: "yaml", payload: []byte("torrent_clients:\n  watch-client: []\n")},
-		{name: "json-scalar", format: "json", payload: []byte(`{"TorrentClients":{"watch-client":"nope"}}`)},
-		{name: "json-array", format: "json", payload: []byte(`{"TorrentClients":{"watch-client":[]}}`)},
+		{
+			name:    "yaml-scalar",
+			format:  "yaml",
+			payload: []byte("torrent_clients:\n  watch-client: nope\n"),
+		},
+		{
+			name:    "yaml-array",
+			format:  "yaml",
+			payload: []byte("torrent_clients:\n  watch-client: []\n"),
+		},
+		{
+			name:    "json-scalar",
+			format:  "json",
+			payload: []byte(`{"TorrentClients":{"watch-client":"nope"}}`),
+		},
+		{
+			name:    "json-array",
+			format:  "json",
+			payload: []byte(`{"TorrentClients":{"watch-client":[]}}`),
+		},
 	}
 
 	for _, tt := range tests {
@@ -340,16 +400,56 @@ func TestMergeNativeConfigRejectsUnknownTopLevelSections(t *testing.T) {
 		format  string
 		payload []byte
 	}{
-		{name: "yaml-scalar", format: "yaml", payload: []byte("unknown_section: nope\n")},
-		{name: "yaml-array", format: "yaml", payload: []byte("unknown_section: []\n")},
-		{name: "yaml-object", format: "yaml", payload: []byte("unknown_section:\n  nested: true\n")},
-		{name: "yaml-null", format: "yaml", payload: []byte("unknown_section: null\n")},
-		{name: "yaml-case-twin", format: "yaml", payload: []byte("MainSettings:\n  TMDBAPI: wrong\n")},
-		{name: "json-scalar", format: "json", payload: []byte(`{"UnknownSection":"nope"}`)},
-		{name: "json-array", format: "json", payload: []byte(`{"UnknownSection":[]}`)},
-		{name: "json-object", format: "json", payload: []byte(`{"UnknownSection":{"nested":true}}`)},
-		{name: "json-null", format: "json", payload: []byte(`{"UnknownSection":null}`)},
-		{name: "json-case-twin", format: "json", payload: []byte(`{"main_settings":{"tmdb_api":"wrong"}}`)},
+		{
+			name:    "yaml-scalar",
+			format:  "yaml",
+			payload: []byte("unknown_section: nope\n"),
+		},
+		{
+			name:    "yaml-array",
+			format:  "yaml",
+			payload: []byte("unknown_section: []\n"),
+		},
+		{
+			name:    "yaml-object",
+			format:  "yaml",
+			payload: []byte("unknown_section:\n  nested: true\n"),
+		},
+		{
+			name:    "yaml-null",
+			format:  "yaml",
+			payload: []byte("unknown_section: null\n"),
+		},
+		{
+			name:    "yaml-case-twin",
+			format:  "yaml",
+			payload: []byte("MainSettings:\n  TMDBAPI: wrong\n"),
+		},
+		{
+			name:    "json-scalar",
+			format:  "json",
+			payload: []byte(`{"UnknownSection":"nope"}`),
+		},
+		{
+			name:    "json-array",
+			format:  "json",
+			payload: []byte(`{"UnknownSection":[]}`),
+		},
+		{
+			name:    "json-object",
+			format:  "json",
+			payload: []byte(`{"UnknownSection":{"nested":true}}`),
+		},
+		{
+			name:    "json-null",
+			format:  "json",
+			payload: []byte(`{"UnknownSection":null}`),
+		},
+		{
+			name:    "json-case-twin",
+			format:  "json",
+			payload: []byte(`{"main_settings":{"tmdb_api":"wrong"}}`),
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/internal/configstore/dbloader_penetration_test.go b/internal/configstore/dbloader_penetration_test.go
index 4ff17fd4..c4269318 100644
--- a/internal/configstore/dbloader_penetration_test.go
+++ b/internal/configstore/dbloader_penetration_test.go
@@ -18,7 +18,7 @@ import (
 	"github.com/autobrr/upbrr/internal/services/db"
 )
 
-// The configstore is the single entry point every surface (CLI, GUI, web)
+// The configstore is the single entry point every surface (CLI and WebUI)
 // uses to materialize config at startup. These tests drive the Bootstrap,
 // ResolveYAMLPath, LoadFromPathOrEmbedded, and SaveToDBPath contracts through
 // edge cases each surface relies on.
@@ -74,7 +74,7 @@ func TestResolveYAMLPathDefault(t *testing.T) {
 }
 
 // LoadFromPathOrEmbedded must return the embedded config when the path is
-// missing, not an error — this is how the GUI handles fresh installs.
+// missing, not an error — this is how the WebUI handles fresh installs.
 func TestLoadFromPathOrEmbeddedMissingFallsBack(t *testing.T) {
 	t.Parallel()
 
diff --git a/internal/configstore/dbloader_test.go b/internal/configstore/dbloader_test.go
index ab077281..7fd7639a 100644
--- a/internal/configstore/dbloader_test.go
+++ b/internal/configstore/dbloader_test.go
@@ -18,10 +18,10 @@ import (
 	"github.com/autobrr/upbrr/internal/webserver"
 )
 
-func TestLoadFromDBPathDisablesUnsupportedTrackerImageRehost(t *testing.T) {
+func TestLoadFromDBPathPreservesTrackerImageRehostForRuntimePolicyValidation(t *testing.T) {
 	t.Parallel()
 
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	repo, err := db.Open(dbPath)
 	if err != nil {
 		t.Fatalf("open repo: %v", err)
@@ -51,15 +51,15 @@ func TestLoadFromDBPathDisablesUnsupportedTrackerImageRehost(t *testing.T) {
 	if err != nil {
 		t.Fatalf("load config from database: %v", err)
 	}
-	if loaded.Trackers.Trackers["TL"].ImgRehost {
-		t.Fatal("expected unsupported TL img_rehost to be disabled on load")
+	if !loaded.Trackers.Trackers["TL"].ImgRehost {
+		t.Fatal("expected TL img_rehost to remain available for registry policy validation")
 	}
 }
 
 func TestLoadFromDBPathBackfillsMissingTrackerDefaults(t *testing.T) {
 	t.Parallel()
 
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	repo, err := db.Open(dbPath)
 	if err != nil {
 		t.Fatalf("open repo: %v", err)
@@ -96,11 +96,11 @@ func TestLoadFromDBPathRepairPersistsSecretsWithRuntimeDBPath(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	runtimeDBPath := filepath.Join(t.TempDir(), "runtime", "guiapp.db")
+	runtimeDBPath := filepath.Join(t.TempDir(), "runtime", "webui.db")
 	if err := webserver.BootstrapAuthFile(runtimeDBPath, "tester", "very-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile runtime: %v", err)
 	}
-	staleDBPath := filepath.Join(t.TempDir(), "old", "guiapp.db")
+	staleDBPath := filepath.Join(t.TempDir(), "old", "webui.db")
 	if err := webserver.BootstrapAuthFile(staleDBPath, "tester", "different-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile stale: %v", err)
 	}
@@ -177,7 +177,7 @@ func TestLoadFromDBPathPersistsMergedTrackerDefaults(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	repo, err := db.Open(dbPath)
 	if err != nil {
 		t.Fatalf("open repo: %v", err)
@@ -258,7 +258,7 @@ func TestLoadFromDBPathRollsBackMultiSectionRepairOnLaterFailure(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	repo, err := db.Open(dbPath)
 	if err != nil {
 		t.Fatalf("open repo: %v", err)
@@ -337,7 +337,7 @@ func TestLoadFromDBPathBackfillsMissingStoredOptions(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	repo, err := db.Open(dbPath)
 	if err != nil {
 		t.Fatalf("open repo: %v", err)
@@ -399,7 +399,7 @@ func TestSaveToDBPathSyncsCookieEncryptionStateWhenWebAuthExists(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	if err := webserver.BootstrapAuthFile(dbPath, "tester", "very-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile: %v", err)
 	}
@@ -469,7 +469,7 @@ func TestSaveToDBPathMalformedWebAuthFailsBeforeConfigSave(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	if err := os.WriteFile(webserver.AuthFilePath(dbPath), []byte(`{`), 0o600); err != nil {
 		t.Fatalf("write malformed auth file: %v", err)
 	}
@@ -513,7 +513,7 @@ func TestSaveToDBPathRollsBackCookieSyncWhenConfigSaveFails(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	if err := webserver.BootstrapAuthFile(dbPath, "tester", "very-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile: %v", err)
 	}
@@ -575,7 +575,7 @@ func TestSaveToDBPathCookieSyncRollsBackWhenConfigSaveFails(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	if err := webserver.BootstrapAuthFile(dbPath, "tester", "very-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile: %v", err)
 	}
@@ -606,7 +606,7 @@ func TestSaveToDBPathIncompleteWebAuthStillSavesConfig(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "guiapp.db")
+	dbPath := filepath.Join(t.TempDir(), "webui.db")
 	if err := os.WriteFile(webserver.AuthFilePath(dbPath), []byte(`{"username":"tester"}`), 0o600); err != nil {
 		t.Fatalf("write incomplete auth file: %v", err)
 	}
diff --git a/internal/cookies/init.go b/internal/cookies/init.go
index 79b60dac..c52ddd6b 100644
--- a/internal/cookies/init.go
+++ b/internal/cookies/init.go
@@ -35,33 +35,36 @@ func SyncCookieEncryptionWithAuth(ctx context.Context, db *sql.DB, dbPath string
 // existing transaction so callers can commit or roll back cookie metadata with
 // the surrounding database write.
 func SyncCookieEncryptionWithAuthTx(ctx context.Context, tx *sql.Tx, dbPath string) error {
+	_, err := InitializeEncryptionKeyTx(ctx, tx, dbPath)
+	return err
+}
+
+// InitializeEncryptionKeyTx derives the current cookie key and synchronizes
+// encrypted cookie state inside tx. The caller owns commit or rollback.
+func InitializeEncryptionKeyTx(ctx context.Context, tx *sql.Tx, dbPath string) ([]byte, error) {
 	if ctx == nil {
-		return errors.New("cookies: context is required")
+		return nil, errors.New("cookies: context is required")
 	}
 	if tx == nil {
-		return errors.New("cookies: transaction is required")
+		return nil, errors.New("cookies: transaction is required")
 	}
 
-	_, err := initializeEncryptionKey(ctx, tx, dbPath, func(ctx context.Context, oldKey, newKey []byte) error {
+	key, err := initializeEncryptionKey(ctx, tx, dbPath, func(ctx context.Context, oldKey, newKey []byte) error {
 		return reencryptCookiesTx(ctx, tx, oldKey, newKey)
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	return nil
+	return key, nil
 }
 
-// EnsureCookieMigration handles the automatic migration of cookies from file-based storage
-// to the encrypted database. It should be called early during app initialization.
-//
-// If old cookie files (.txt or .json) are found in the cookies directory, the function will:
-// 1. Initialize or retrieve the encryption key from existing web auth details
-// 2. Create a CookieStore instance
-// 3. Migrate all cookies from files to the encrypted database
-// 4. Delete the old cookie files
-//
-// If no old files are found, it returns immediately with no action.
+// EnsureCookieMigration imports top-level .txt and .json cookie files into the
+// encrypted database. Missing or unreadable legacy directories are treated as
+// having no files. Storage failures retain every legacy file but are logged
+// rather than returned. When at least one cookie is stored and no storage
+// failure occurs, all top-level .txt and .json files are removed; parse and
+// cleanup failures are logged rather than returned.
 func EnsureCookieMigration(ctx context.Context, db *sql.DB, dbPath string, cookiesDir string, logger api.Logger) error {
 	if ctx == nil {
 		return errors.New("cookies: context is required")
@@ -71,7 +74,7 @@ func EnsureCookieMigration(ctx context.Context, db *sql.DB, dbPath string, cooki
 	}
 
 	// Check if cookies directory exists and has any .txt or .json files
-	if !hasLegacyCookieFiles(cookiesDir) {
+	if !HasLegacyCookieFiles(cookiesDir) {
 		return nil
 	}
 
@@ -109,8 +112,9 @@ func EnsureCookieMigration(ctx context.Context, db *sql.DB, dbPath string, cooki
 	return nil
 }
 
-// hasLegacyCookieFiles checks if there are any .txt or .json cookie files in the directory.
-func hasLegacyCookieFiles(cookiesDir string) bool {
+// HasLegacyCookieFiles reports whether cookiesDir contains top-level .txt or
+// .json files eligible for legacy migration.
+func HasLegacyCookieFiles(cookiesDir string) bool {
 	info, err := os.Stat(cookiesDir)
 	if err != nil {
 		return false // Directory doesn't exist or can't be read
diff --git a/internal/cookies/keymanager.go b/internal/cookies/keymanager.go
index 1a178568..4e7eadaf 100644
--- a/internal/cookies/keymanager.go
+++ b/internal/cookies/keymanager.go
@@ -394,7 +394,12 @@ func storeAuthStateInDB(ctx context.Context, db cookieDBExecutor, state authStat
 		return fmt.Errorf("failed to marshal auth state: %w", err)
 	}
 
-	_, err = db.ExecContext(ctx, `INSERT OR REPLACE INTO config_settings (section, data, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)`, cookieAuthStateConfigSection, string(payload))
+	_, err = db.ExecContext(
+		ctx,
+		`INSERT OR REPLACE INTO config_settings (section, data, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)`,
+		cookieAuthStateConfigSection,
+		string(payload),
+	)
 	if err != nil {
 		return fmt.Errorf("failed to save auth state: %w", err)
 	}
diff --git a/internal/cookies/migration.go b/internal/cookies/migration.go
index 6add2241..052514ab 100644
--- a/internal/cookies/migration.go
+++ b/internal/cookies/migration.go
@@ -5,6 +5,7 @@ package cookies
 
 import (
 	"context"
+	"database/sql"
 	"errors"
 	"fmt"
 	"os"
@@ -17,16 +18,56 @@ import (
 )
 
 // FailedCookie identifies a tracker/cookie pair that could not be migrated.
+// CookieName is empty when the source file could not be parsed.
 type FailedCookie struct {
 	TrackerID  string
 	CookieName string
 }
 
-// MigrateFromFilesToDB imports cookies from file-based storage into the encrypted database.
-// It scans the cookiesDir for .txt and .json files, parses them, encrypts the values,
-// and stores them in the database. It returns the number of successfully migrated
-// cookies plus any tracker/cookie pairs that failed during storage.
+// MigrateFromFilesToDB imports top-level .txt and .json cookie files into the
+// encrypted database. It returns the stored-cookie count and all parse/storage
+// failures so callers can retain source files after any partial migration.
 func MigrateFromFilesToDB(ctx context.Context, cookiesDir string, store *CookieStore, key []byte, logger api.Logger) (int, []FailedCookie, error) {
+	if store == nil {
+		return 0, nil, errors.New("cookies: cookie store is required")
+	}
+	return migrateFromFilesToDB(ctx, cookiesDir, key, logger, store.SaveCookie)
+}
+
+// MigrateFromFilesToDBTx imports legacy cookie files through tx so callers can
+// commit or roll back the cookie writes with a surrounding database operation.
+func MigrateFromFilesToDBTx(
+	ctx context.Context,
+	cookiesDir string,
+	store *CookieStore,
+	tx *sql.Tx,
+	key []byte,
+	logger api.Logger,
+) (int, []FailedCookie, error) {
+	if store == nil {
+		return 0, nil, errors.New("cookies: cookie store is required")
+	}
+	if tx == nil {
+		return 0, nil, errors.New("cookies: transaction is required")
+	}
+	return migrateFromFilesToDB(ctx, cookiesDir, key, logger, func(
+		ctx context.Context,
+		trackerID, cookieName, cookieValue string,
+		key []byte,
+	) error {
+		return store.SaveCookieTx(ctx, tx, trackerID, cookieName, cookieValue, key)
+	})
+}
+
+type saveCookieFunc func(context.Context, string, string, string, []byte) error
+
+func migrateFromFilesToDB(
+	ctx context.Context,
+	cookiesDir string,
+	key []byte,
+	logger api.Logger,
+	saveCookie saveCookieFunc,
+) (int, []FailedCookie, error) {
 	if ctx == nil {
 		return 0, nil, errors.New("cookies: context is required")
 	}
@@ -105,6 +146,7 @@ func MigrateFromFilesToDB(ctx context.Context, cookiesDir string, store *CookieS
 		}
 
 		if parseErr != nil {
+			failedCookies = append(failedCookies, FailedCookie{TrackerID: trackerID})
 			logger.Warnf("cookies: failed to parse cookie file tracker=%s file=%s: %v", trackerID, filename, parseErr)
 			continue
 		}
@@ -115,7 +157,7 @@ func MigrateFromFilesToDB(ctx context.Context, cookiesDir string, store *CookieS
 
 		// Store each cookie in the database
 		for cookieName, cookieValue := range cookies {
-			if err := store.SaveCookie(ctx, trackerID, cookieName, cookieValue, key); err != nil {
+			if err := saveCookie(ctx, trackerID, cookieName, cookieValue, key); err != nil {
 				failedCookies = append(failedCookies, FailedCookie{TrackerID: trackerID, CookieName: cookieName})
 				redactedValue := redaction.RedactValue(cookieValue, nil)
 				logger.Warnf("cookies: failed to migrate cookie tracker=%s cookie=%s value=%v: %v", trackerID, cookieName, redactedValue, err)
@@ -129,8 +171,8 @@ func MigrateFromFilesToDB(ctx context.Context, cookiesDir string, store *CookieS
 	return migratedCount, failedCookies, nil
 }
 
-// DeleteMigratedCookieFiles removes all .txt and .json files from the cookies directory
-// after successful migration.
+// DeleteMigratedCookieFiles removes every top-level .txt and .json file from
+// cookiesDir. It does not verify that an individual file was migrated.
 func DeleteMigratedCookieFiles(cookiesDir string, logger api.Logger) error {
 	return deleteMigratedCookieFiles(cookiesDir, logger)
 }
diff --git a/internal/cookies/migration_test.go b/internal/cookies/migration_test.go
index 9d48ff8b..91f96131 100644
--- a/internal/cookies/migration_test.go
+++ b/internal/cookies/migration_test.go
@@ -94,3 +94,37 @@ func TestEnsureCookieMigrationKeepsLegacyFilesOnPartialFailure(t *testing.T) {
 		t.Fatalf("expected legacy cookie file to be preserved after partial failure: %v", err)
 	}
 }
+
+func TestEnsureCookieMigrationKeepsAllLegacyFilesOnMixedParseResult(t *testing.T) {
+	t.Parallel()
+
+	db := newTestCookieDB(t)
+	dbPath := writeWebAuthFile(t, "admin", "password-hash")
+	cookiesDir := t.TempDir()
+	validPath := filepath.Join(cookiesDir, "valid.json")
+	invalidPath := filepath.Join(cookiesDir, "invalid.json")
+	if err := os.WriteFile(validPath, []byte(`{"session":"cookie-value"}`), 0o600); err != nil {
+		t.Fatalf("write valid cookie file: %v", err)
+	}
+	if err := os.WriteFile(invalidPath, []byte(`{`), 0o600); err != nil {
+		t.Fatalf("write invalid cookie file: %v", err)
+	}
+
+	ctx := context.Background()
+	if err := EnsureCookieMigration(ctx, db, dbPath, cookiesDir, api.NopLogger{}); err != nil {
+		t.Fatalf("ensure cookie migration: %v", err)
+	}
+	for _, legacyPath := range []string{validPath, invalidPath} {
+		if _, err := os.Stat(legacyPath); err != nil {
+			t.Fatalf("expected every legacy file to remain after mixed parse result: %v", err)
+		}
+	}
+
+	var storedCount int
+	if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM tracker_cookies WHERE tracker_id = ?`, "valid").Scan(&storedCount); err != nil {
+		t.Fatalf("count migrated cookies: %v", err)
+	}
+	if storedCount != 1 {
+		t.Fatalf("expected valid cookie to migrate, got count=%d", storedCount)
+	}
+}
diff --git a/internal/cookies/storage.go b/internal/cookies/storage.go
index 3fee1059..3ee619ba 100644
--- a/internal/cookies/storage.go
+++ b/internal/cookies/storage.go
@@ -216,7 +216,9 @@ func (cs *CookieStore) deleteAllTrackerCookies(ctx context.Context, execer cooki
 	return nil
 }
 
-// RunInTransaction runs cookie store operations inside a single database transaction.
+// RunInTransaction commits the callback's cookie-store operations as one
+// transaction. Callback and commit failures trigger rollback; a rollback
+// failure is joined with the original error.
 func (cs *CookieStore) RunInTransaction(ctx context.Context, fn func(tx *sql.Tx) error) (err error) {
 	if ctx == nil {
 		return errors.New("RunInTransaction: context is required")
@@ -251,7 +253,7 @@ func (cs *CookieStore) RunInTransaction(ctx context.Context, fn func(tx *sql.Tx)
 	return nil
 }
 
-// HasCookies checks if a tracker has any cookies in the database.
+// HasCookies reports whether trackerID has at least one stored cookie.
 func (cs *CookieStore) HasCookies(ctx context.Context, trackerID string) (bool, error) {
 	if ctx == nil {
 		return false, errors.New("HasCookies: context is required")
diff --git a/internal/cookies/storage_test.go b/internal/cookies/storage_test.go
index 312d911a..e38ee8f7 100644
--- a/internal/cookies/storage_test.go
+++ b/internal/cookies/storage_test.go
@@ -64,8 +64,16 @@ func TestCookieStoreGetCookieRejectsEmptyTrackerOrName(t *testing.T) {
 		trackerID string
 		cookie    string
 	}{
-		{name: "empty tracker", trackerID: "", cookie: "session"},
-		{name: "empty cookie", trackerID: "tracker", cookie: ""},
+		{
+			name:      "empty tracker",
+			trackerID: "",
+			cookie:    "session",
+		},
+		{
+			name:      "empty cookie",
+			trackerID: "tracker",
+			cookie:    "",
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			_, err := store.GetCookie(context.Background(), tc.trackerID, tc.cookie, []byte("0123456789abcdef0123456789abcdef"))
@@ -93,8 +101,16 @@ func TestCookieStoreDeleteCookieRejectsEmptyTrackerOrName(t *testing.T) {
 		trackerID string
 		cookie    string
 	}{
-		{name: "empty tracker", trackerID: "", cookie: "session"},
-		{name: "empty cookie", trackerID: "tracker", cookie: ""},
+		{
+			name:      "empty tracker",
+			trackerID: "",
+			cookie:    "session",
+		},
+		{
+			name:      "empty cookie",
+			trackerID: "tracker",
+			cookie:    "",
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			err := store.DeleteCookie(context.Background(), tc.trackerID, tc.cookie)
diff --git a/internal/core/canonical_preview.go b/internal/core/canonical_preview.go
new file mode 100644
index 00000000..c33758bb
--- /dev/null
+++ b/internal/core/canonical_preview.go
@@ -0,0 +1,78 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// FetchAcceptedMetadataPreview projects one exact prepared generation and
+// current source-scoped tracker records into the transport preview model.
+func (c *Core) FetchAcceptedMetadataPreview(ctx context.Context, ref api.ReleaseRef) (preview api.MetadataPreview, err error) {
+	defer func() { err = classifyOperationError(api.OperationKindPreparation, err) }()
+	finishProgress := api.BeginPreparationProgress(ctx, api.PreparationPhasePreviewProjection, "Building metadata preview.")
+	defer func() { finishProgress(err) }()
+	if c == nil || c.preparedFacts == nil {
+		return api.MetadataPreview{}, errors.New("core: canonical preparation is not configured")
+	}
+	prepared, err := c.preparedFacts.ResolveResult(ctx, ref)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("core: resolve canonical metadata preview: %w", err)
+	}
+	display, err := c.preparedFacts.ResolveDisplay(ctx, ref)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("core: project canonical metadata preview: %w", err)
+	}
+	preview = api.MetadataPreview{
+		SourcePath:  prepared.Release.Source.SourcePath,
+		ReleaseName: prepared.Release.Naming.ReleaseName,
+		Release: api.ReleaseRef{
+			SourcePath: prepared.Release.Source.SourcePath,
+			Generation: prepared.Release.Generation,
+		},
+		Identity:    prepared.Release.Identity,
+		Display:     display,
+		Bluray:      prepared.Release.ProviderMetadata.Bluray,
+		Diagnostics: append([]api.PreparationDiagnostic(nil), prepared.Diagnostics...),
+	}
+	if c.upload != nil && c.upload.trackerRepo != nil {
+		records, loadErr := c.upload.trackerRepo.ListTrackerMetadataByPath(ctx, prepared.Release.Source.SourcePath)
+		if loadErr != nil && !errors.Is(loadErr, internalerrors.ErrNotFound) {
+			return api.MetadataPreview{}, fmt.Errorf("core: load tracker metadata preview: %w", loadErr)
+		}
+		preview.TrackerData = buildTrackerPreview(records, c.upload.cfg)
+	}
+	return preview, nil
+}
+
+// FetchAcceptedPreparationPreview builds description preparation for one exact
+// prepared generation without consulting mutable cache state.
+func (c *Core) FetchAcceptedPreparationPreview(ctx context.Context, input api.DescriptionInput) (api.PreparationPreview, error) {
+	preview, err := c.description.fetchAcceptedPreview(ctx, input)
+	if err != nil {
+		return api.PreparationPreview{}, classifyOperationError(api.OperationKindDescription, err)
+	}
+	result := api.PreparationPreview{
+		SourcePath:      preview.SourcePath,
+		ContentFailures: append([]api.TrackerContentFailure(nil), preview.ContentFailures...),
+	}
+	for _, group := range preview.Groups {
+		result.Descriptions = append(result.Descriptions, api.PreparationDescription{
+			GroupKey:           group.GroupKey,
+			Trackers:           append([]string(nil), group.Trackers...),
+			RawDescription:     group.RawDescription,
+			RawDescriptionHTML: group.RawDescriptionHTML,
+			Description:        group.Description,
+			DescriptionHTML:    group.DescriptionHTML,
+			HasOverride:        group.HasOverride,
+			ImageHost:          group.ImageHost,
+		})
+	}
+	return result, nil
+}
diff --git a/internal/core/canonical_request.go b/internal/core/canonical_request.go
new file mode 100644
index 00000000..431ca578
--- /dev/null
+++ b/internal/core/canonical_request.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func uploadReviewInputFromRequest(request api.Request, ref api.ReleaseRef) api.UploadReviewInput {
+	return api.UploadReviewInput{
+		Release:                ref,
+		Trackers:               append([]string(nil), request.Trackers...),
+		IgnoreDupesFor:         append([]string(nil), request.IgnoreDupesFor...),
+		RuleAuthorizations:     cloneRuleAuthorizations(request.RuleAuthorizations),
+		SkipDuplicateCheck:     request.SkipDupeCheck,
+		SkipDuplicateAsActual:  request.SkipDupeAsActual,
+		DoubleDuplicateCheck:   request.DoubleDupeCheck,
+		QuestionnaireAnswers:   cloneOperationQuestionnaireAnswers(request.TrackerQuestionnaireAnswers),
+		TrackerIDOverrides:     cloneStringMap(request.TrackerIDOverrides),
+		DescriptionGroups:      api.CloneDescriptionBuilderGroups(request.DescriptionGroups),
+		TrackerConfigOverrides: request.TrackerConfigOverrides,
+		TrackerSiteOverrides:   request.TrackerSiteOverrides,
+		ClientOverrides:        request.ClientOverrides,
+		ImageHostOverrides:     request.ImageHostOverrides,
+		ScreenshotOverrides:    request.ScreenshotOverrides,
+		TorrentOverrides:       request.TorrentOverrides,
+		Options:                request.Options,
+	}
+}
+
+// duplicateCheckInputFromRequest isolates operation choices from broad legacy
+// request state and binds them to one accepted prepared generation.
+func duplicateCheckInputFromRequest(request api.Request, ref api.ReleaseRef) api.DuplicateCheckInput {
+	return api.DuplicateCheckInput{
+		Release:      ref,
+		Trackers:     append([]string(nil), request.Trackers...),
+		Interaction:  request.Options.InteractionMode,
+		IgnoreFor:    append([]string(nil), request.IgnoreDupesFor...),
+		Skip:         request.SkipDupeCheck,
+		SkipAsActual: request.SkipDupeAsActual,
+		DoubleCheck:  request.DoubleDupeCheck,
+		TrackerIDs:   cloneStringMap(request.TrackerIDOverrides),
+	}
+}
+
+func (c *Core) canonicalPreparationEnabled() bool {
+	return c != nil && c.preparedFacts != nil
+}
+
+func (c *Core) prepareRequestRef(ctx context.Context, request api.Request, intent api.PreparationIntent) (api.ReleaseRef, error) {
+	if !c.canonicalPreparationEnabled() {
+		return api.ReleaseRef{}, errors.New("core: canonical preparation is not configured")
+	}
+	input, err := api.MapPreparationRequest(request, intent)
+	if err != nil {
+		return api.ReleaseRef{}, fmt.Errorf("core: map preparation request: %w", err)
+	}
+	prepared, err := c.preparedFacts.Prepare(ctx, input)
+	if err != nil {
+		return api.ReleaseRef{}, fmt.Errorf("core: prepare request release: %w", err)
+	}
+	return api.ReleaseRef{SourcePath: prepared.Release.Source.SourcePath, Generation: prepared.Release.Generation}, nil
+}
diff --git a/internal/core/copy_test.go b/internal/core/copy_test.go
deleted file mode 100644
index 4861dddd..00000000
--- a/internal/core/copy_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDeepCopyTMDBMetadataLocalizedMap(t *testing.T) {
-	t.Parallel()
-
-	source := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				TMDBID: 42,
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {
-						Title: "Original Localized Title",
-					},
-				},
-			},
-		},
-	}
-
-	copied := deepCopyPreparedMetadata(source)
-
-	// Mutate the copied map
-	copied.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-		Title: "Mutated Localized Title",
-	}
-
-	// Verify the source map is unchanged
-	origTitle := source.ExternalMetadata.TMDB.Localized["pt-BR"].Title
-	if origTitle != "Original Localized Title" {
-		t.Fatalf("source map was mutated! expected %q, got %q", "Original Localized Title", origTitle)
-	}
-
-	copiedTitle := copied.ExternalMetadata.TMDB.Localized["pt-BR"].Title
-	if copiedTitle != "Mutated Localized Title" {
-		t.Fatalf("copied map was not mutated! expected %q, got %q", "Mutated Localized Title", copiedTitle)
-	}
-}
diff --git a/internal/core/core.go b/internal/core/core.go
index c146f9f8..0d449bb1 100644
--- a/internal/core/core.go
+++ b/internal/core/core.go
@@ -5,70 +5,69 @@ package core
 
 import (
 	"context"
-	"crypto/sha256"
 	"database/sql"
 	"errors"
 	"fmt"
-	"io"
-	"maps"
-	"net/http"
 	"net/url"
-	"os"
 	"path" //nolint:depguard // Builds URL paths, not local filesystem paths.
 	"path/filepath"
-	"reflect"
 	"slices"
-	"sort"
-	"strconv"
 	"strings"
-	"sync"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/clients"
+	"github.com/autobrr/upbrr/internal/clientdiscovery"
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/dupechecking"
+	"github.com/autobrr/upbrr/internal/description"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/externalidentity"
 	"github.com/autobrr/upbrr/internal/filesystem"
+	"github.com/autobrr/upbrr/internal/imagehosting"
 	"github.com/autobrr/upbrr/internal/logging"
 	"github.com/autobrr/upbrr/internal/metadata"
-	"github.com/autobrr/upbrr/internal/paths"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/bdinfo"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/description"
 	"github.com/autobrr/upbrr/internal/services/dvdmenus"
-	"github.com/autobrr/upbrr/internal/services/imagehosting"
 	"github.com/autobrr/upbrr/internal/services/screenshots"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
 	"github.com/autobrr/upbrr/internal/torrent"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	"github.com/autobrr/upbrr/internal/torrentclient"
 	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
 	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Core composes the upload, prepared-release, duplicate-check, media,
+// description, and history capabilities over one dependency snapshot. It owns
+// the repository only when construction opened that repository internally.
+// Operation contexts are per call and are not retained by Core.
 type Core struct {
-	cfg       config.Config
-	logger    api.Logger
-	services  api.ServiceSet
-	repo      db.MetadataRepository
-	ownsRepo  bool
-	dupeMu    sync.RWMutex
-	dupeCache map[string]dupeCacheEntry
-}
+	logger     api.Logger
+	repoOwner  api.RepositoryOwner
+	selections api.ReleaseSelectionRepository
+	ownsRepo   bool
 
-type dupeCacheEntry struct {
-	meta             api.PreparedMetadata
-	dupeSummary      api.DupeCheckSummary
-	signature        string
-	updatedAt        time.Time
-	requestRefreshed bool
+	history       *historyModule
+	preparedFacts *preparedrelease.Module
+	description   *descriptionModule
+	media         *mediaModule
+	upload        *uploadModule
+	dupe          *dupeModule
 }
 
+// New constructs a Core using a background context for initialization. Call
+// [Core.Close] when finished; it closes only an internally opened repository.
 func New(deps api.CoreDependencies) (*Core, error) {
 	return newCore(context.Background(), deps)
 }
 
+// NewWithContext constructs a Core and applies ctx to initialization work such
+// as opening and migrating an internally created repository. The context is not
+// retained after construction.
 func NewWithContext(ctx context.Context, deps api.CoreDependencies) (*Core, error) {
 	if ctx == nil {
 		return nil, errors.New("core: context is required")
@@ -77,6 +76,34 @@ func NewWithContext(ctx context.Context, deps api.CoreDependencies) (*Core, erro
 }
 
 func newCore(ctx context.Context, deps api.CoreDependencies) (*Core, error) {
+	return newCoreWithHooks(ctx, deps, coreConstructionHooks{})
+}
+
+type coreConstructionHooks struct {
+	closeRepository func(api.RepositoryOwner) error
+}
+
+type metadataRepositoryView struct {
+	api.ReleaseStateRepository
+	api.ReleaseSelectionRepository
+	api.TrackerStateRepository
+}
+
+type trackerRepositoryView struct {
+	api.ReleaseSelectionRepository
+	api.UploadLedgerRepository
+	api.TrackerStateRepository
+	api.MediaAssetRepository
+}
+
+type mediaRepositoryView struct {
+	api.TrackerStateRepository
+	api.MediaAssetRepository
+}
+
+// newCoreWithHooks constructs the runtime graph and closes only repositories it
+// opened itself when construction fails. Hooks expose that cleanup to tests.
+func newCoreWithHooks(ctx context.Context, deps api.CoreDependencies, hooks coreConstructionHooks) (*Core, error) {
 	if ctx == nil {
 		return nil, errors.New("core: context is required")
 	}
@@ -105,47 +132,70 @@ func newCore(ctx context.Context, deps api.CoreDependencies) (*Core, error) {
 		return nil, fmt.Errorf("core: %w", err)
 	}
 
-	repo := deps.Repository
+	repositories := deps.Repository
+	repoOwner := deps.RepositoryOwner
 	ownsRepo := false
-	if repo == nil {
+	constructionSucceeded := false
+	defer func() {
+		if constructionSucceeded || !ownsRepo || repoOwner == nil {
+			return
+		}
+		if hooks.closeRepository != nil {
+			_ = hooks.closeRepository(repoOwner)
+			return
+		}
+		_ = repoOwner.Close()
+	}()
+	if repositories.IsZero() {
 		logger.Debugf("core: opening repository")
 		sqliteRepo, err := db.OpenWithLoggerContext(ctx, cfg.MainSettings.DBPath, logger)
 		if err != nil {
 			return nil, fmt.Errorf("core: %w", err)
 		}
+		repositories = sqliteRepo.RepositoryCapabilities()
+		repoOwner = sqliteRepo
+		ownsRepo = true
 		if err := sqliteRepo.MigrateContext(ctx); err != nil {
-			_ = sqliteRepo.Close()
 			return nil, fmt.Errorf("core: %w", err)
 		}
-
-		repo = sqliteRepo
-		ownsRepo = true
 	}
-	if sqliteRepo, ok := repo.(*db.SQLiteRepository); ok && !deps.SkipCookieMigration {
+	if err := repositories.Validate(); err != nil {
+		return nil, fmt.Errorf("core: repository capabilities: %w", err)
+	}
+	if sqliteRepo, ok := repoOwner.(*db.SQLiteRepository); ok && !deps.SkipCookieMigration {
 		if err := migrateLegacyCookies(ctx, sqliteRepo.RawDB(), cfg.MainSettings.DBPath, logger); err != nil {
 			logger.Warnf("core: cookie migration failed: %v (continuing)", err)
 		}
 	}
 
 	services := deps.Services
-	if err := maybeApplyE2EServices(ctx, &services, cfg, repo, logger); err != nil {
-		if ownsRepo {
-			if closer, ok := repo.(interface{ Close() error }); ok {
-				_ = closer.Close()
-			}
-		}
+	if err := maybeApplyE2EServices(ctx, &services, cfg, repositories, logger); err != nil {
 		return nil, err
 	}
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		return nil, fmt.Errorf("core: tracker registry: %w", err)
+	}
+	if services.Clients == nil {
+		services.Clients = torrentclient.NewServiceWithRegistry(cfg, logger, registry)
+	}
+	clientDiscovery := clientdiscovery.New(services.Clients, logger)
 	if services.Metadata == nil {
 		bdinfoService := bdinfo.New(logger)
 
 		services.Metadata = metadata.NewService(
-			repo,
+			metadataRepositoryView{
+				ReleaseStateRepository:     repositories.ReleaseState(),
+				ReleaseSelectionRepository: repositories.Selections(),
+				TrackerStateRepository:     repositories.Trackers(),
+			},
 			metadata.WithTagsPathFromDB(cfg.MainSettings.DBPath),
 			metadata.WithLogger(logger),
 			metadata.WithSRRDBPaths(cfg.MainSettings.DBPath),
 			metadata.WithConfig(cfg),
 			metadata.WithBDInfoService(bdinfoService),
+			metadata.WithTrackerRegistry(registry),
+			metadata.WithClientDiscovery(clientDiscovery),
 		)
 	}
 	if services.Torrents == nil {
@@ -153,337 +203,122 @@ func newCore(ctx context.Context, deps api.CoreDependencies) (*Core, error) {
 		if err != nil {
 			return nil, fmt.Errorf("core: tmp dir: %w", err)
 		}
-		services.Torrents = torrent.NewService(logger, tmpDir)
+		services.Torrents = torrent.NewServiceWithRegistry(logger, tmpDir, registry)
 	}
 	if services.Screenshots == nil {
 		tmpDir, err := db.Subdir(cfg.MainSettings.DBPath, "tmp")
 		if err != nil {
 			return nil, fmt.Errorf("core: tmp dir: %w", err)
 		}
-		services.Screenshots = screenshots.NewServiceWithRepo(cfg, logger, tmpDir, nil, repo)
+		services.Screenshots = screenshots.NewServiceWithRepo(
+			cfg,
+			logger,
+			tmpDir,
+			nil,
+			mediaRepositoryView{TrackerStateRepository: repositories.Trackers(), MediaAssetRepository: repositories.Media()},
+		)
 	}
 	if services.DVDMenus == nil {
 		tmpDir, err := db.Subdir(cfg.MainSettings.DBPath, "tmp")
 		if err != nil {
 			return nil, fmt.Errorf("core: tmp dir: %w", err)
 		}
-		services.DVDMenus = dvdmenus.NewService(logger, tmpDir, repo)
+		services.DVDMenus = dvdmenus.NewService(logger, tmpDir, repositories.Media())
 	}
 	if services.Images == nil {
-		services.Images = imagehosting.NewService(cfg, logger, repo)
+		services.Images = imagehosting.NewServiceWithRegistry(cfg, logger, repositories.Media(), registry)
 	}
 	if services.Trackers == nil {
-		registry, err := trackerimpl.NewRegistry()
-		if err != nil {
-			return nil, fmt.Errorf("core: tracker registry: %w", err)
-		}
-		services.Trackers = trackers.NewServiceWithRegistryAndImages(cfg, logger, repo, registry, services.Images)
-	}
-	if services.Clients == nil {
-		services.Clients = clients.NewService(cfg, logger)
+		services.Trackers = trackers.NewServiceWithRegistryAndImages(
+			cfg,
+			logger,
+			trackerRepositoryView{
+				ReleaseSelectionRepository: repositories.Selections(),
+				UploadLedgerRepository:     repositories.Uploads(),
+				TrackerStateRepository:     repositories.Trackers(),
+				MediaAssetRepository:       repositories.Media(),
+			},
+			registry,
+			services.Images,
+		)
 	}
 	if services.Filesystem == nil {
 		services.Filesystem = filesystem.NewValidatorWithLogger(logger)
 	}
 	if services.Dupes == nil {
-		services.Dupes = dupechecking.NewService(cfg, logger)
+		services.Dupes = dupechecking.NewServiceWithRegistry(cfg, logger, registry)
 	}
 	if services.TrackerAuth == nil {
-		services.TrackerAuth = trackerauth.NewServiceWithLogger(cfg, logger)
+		services.TrackerAuth = trackerauth.NewServiceWithRegistryAndLogger(cfg, registry, logger)
 	}
 	logger.Infof("core: initialized services")
-
-	return &Core{
-		cfg:       cfg,
-		logger:    logger,
-		services:  services,
-		repo:      repo,
-		ownsRepo:  ownsRepo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}, nil
-}
-
-func (c *Core) RunUpload(ctx context.Context, req api.Request) (api.Result, error) {
-	req = normalizeExecutionRequest(req)
-	c.logger.Debugf("core: upload request routed to upload-only handler")
-	return c.RunUploadPrepared(ctx, req)
-}
-
-// RunUploadPrepared uploads from cached prepared metadata for each requested path.
-// Explicit tracker selections that resolve empty return without tracker upload
-// side effects, while omitted tracker selections retain configured default behavior.
-// If a later path fails or the context is canceled after earlier uploads complete,
-// the returned result preserves the uploaded count accumulated before the error.
+	evidencePipeline, ok := services.Metadata.(preparedrelease.EvidencePipeline)
+	if !ok {
+		return nil, errors.New("core: metadata service does not implement canonical evidence collection")
+	}
+	collector, err := preparedrelease.NewEvidenceCollector(evidencePipeline)
+	if err != nil {
+		return nil, fmt.Errorf("core: canonical preparation collector: %w", err)
+	}
+	identityResolver, err := externalidentity.NewWithCandidateSource(repositories.ReleaseState(), collector)
+	if err != nil {
+		return nil, fmt.Errorf("core: canonical identity resolver: %w", err)
+	}
+	preparedFacts, err := preparedrelease.New(repositories.Prepared(), identityResolver, collector)
+	if err != nil {
+		return nil, fmt.Errorf("core: canonical preparation: %w", err)
+	}
+
+	core := &Core{
+		logger:        logger,
+		repoOwner:     repoOwner,
+		selections:    repositories.Selections(),
+		ownsRepo:      ownsRepo,
+		preparedFacts: preparedFacts,
+	}
+	core.history = newHistoryModule(repositories.History(), cfg.MainSettings.DBPath, logger)
+	core.history.preparedFacts = core.preparedFacts
+	core.description = newDescriptionModule(cfg, logger, services, repositories.Selections(), registry, core.preparedFacts)
+	core.media = newMediaModule(
+		cfg,
+		logger,
+		services,
+		mediaRepositoryView{TrackerStateRepository: repositories.Trackers(), MediaAssetRepository: repositories.Media()},
+		registry,
+		core.preparedFacts,
+	)
+	core.upload = newUploadModule(
+		cfg,
+		logger,
+		services,
+		repositories.ReleaseState(),
+		repositories.Trackers(),
+		registry,
+		core.preparedFacts,
+		core.description.resolveOverrideRequest,
+		core.description.resolveSubjectGroups,
+		core.ImportAcceptedMenuImages,
+	)
+	core.dupe = newDupeModule(cfg, logger, services, registry, core.preparedFacts)
+	constructionSucceeded = true
+	return core, nil
+}
+
+// RunUploadPrepared validates and prepares req.SourcePath, refreshes upload
+// review authority, and uploads only eligible trackers. Omitted tracker
+// selections expand configured defaults. If tracker upload or later client
+// injection fails after some uploads complete, Result.UploadedCount preserves
+// the completed count.
 func (c *Core) RunUploadPrepared(ctx context.Context, req api.Request) (result api.Result, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: upload prepared blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	req = normalizeExecutionRequest(req)
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.Result{}, err
-	}
-	req = resolvedReq
-
-	if len(req.Paths) == 0 {
-		return api.Result{}, internalerrors.ErrInvalidInput
-	}
-	c.logger.Debugf("core: upload-only request with %d paths", len(req.Paths))
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.Result{}, fmt.Errorf("core: %w", err)
-	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	c.logger.Debugf("core: upload-only processing %d unique paths", len(uniquePaths))
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.Result{}, err
-	}
-
-	var totalUploaded int
-	for _, path := range uniquePaths {
-		select {
-		case <-ctx.Done():
-			return api.Result{UploadedCount: totalUploaded}, fmt.Errorf("context canceled: %w", ctx.Err())
-		default:
-		}
-
-		singleReq := req
-		singleReq.Paths = []string{path}
-		singleReq.Options = options
-		singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-
-		signature := overrideSignature(singleReq.ExternalIDOverrides, singleReq.ReleaseNameOverrides, singleReq.MetadataOverrides, singleReq.TrackerConfigOverrides, singleReq.TrackerSiteOverrides, singleReq.ClientOverrides, singleReq.TorrentOverrides, singleReq.ImageHostOverrides, singleReq.ScreenshotOverrides)
-		meta, ok := c.getDupeCache(path, signature)
-		if req.Mode == api.ModeGUI {
-			meta, ok = c.getGUICachedMeta(path, signature, singleReq.ExternalIDOverrides)
-		}
-		if !ok {
-			return api.Result{UploadedCount: totalUploaded}, fmt.Errorf("core: upload-only requires prepared metadata for %s", path)
-		}
-
-		if len(singleReq.ScreenshotOverrides.MenuPaths) > 0 {
-			if err := c.ImportMenuImages(ctx, singleReq, singleReq.ScreenshotOverrides.MenuPaths); err != nil {
-				return api.Result{UploadedCount: totalUploaded}, fmt.Errorf("core: import menu images failed: %w", err)
-			}
-		}
-
-		uploaded, err := c.executePreparedUpload(ctx, singleReq, meta)
-		totalUploaded += uploaded
-		if err != nil {
-			return api.Result{UploadedCount: totalUploaded}, err
-		}
-	}
-
-	c.logger.Infof("core: upload-only complete uploaded=%d", totalUploaded)
-	return api.Result{UploadedCount: totalUploaded}, nil
-}
-
-// executePreparedUpload returns the number of tracker uploads accepted before any
-// later upload, injection, validation, or cancellation error.
-func (c *Core) executePreparedUpload(ctx context.Context, req api.Request, meta api.PreparedMetadata) (int, error) {
-	var err error
-	meta, err = c.applyRequestToCachedPreparedMeta(ctx, meta, req)
-	if err != nil {
-		return 0, err
-	}
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, trackerResolutionRemoveForRequest(meta, req), c.logger, false, false)
-	if explicitEmpty {
-		c.logger.Debugf("core: upload prepared explicit trackers resolved empty source=%s", meta.SourcePath)
-		return 0, nil
-	}
-
-	descriptionGroups, err := c.resolveCanonicalDescriptionGroups(ctx, meta, req)
-	if err != nil {
-		return 0, err
-	}
-	meta.DescriptionGroups = descriptionGroups
-
-	emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "torrent", "running", "Preparing torrent")
-	torrent, err := c.services.Torrents.Create(ctx, meta)
-	if err != nil {
-		return 0, fmt.Errorf("core: %w", err)
-	}
-	c.logger.Debugf("core: torrent ready for %s", meta.SourcePath)
-	meta.TorrentPath = torrent.Path
-
-	if c.repo != nil && torrent.InfoHash != "" {
-		select {
-		case <-ctx.Done():
-			return 0, fmt.Errorf("context canceled: %w", ctx.Err())
-		default:
-		}
-		if err := c.persistPreparedInfoHash(ctx, meta.SourcePath, torrent.InfoHash); err != nil {
-			return 0, fmt.Errorf("metadata: persist info hash: %w", err)
-		}
-	}
-
-	if req.Options.DryRun || req.Options.Debug {
-		if !meta.Options.NoSeed {
-			if len(resolvedTrackers) == 0 {
-				if err := c.injectPreparedTorrent(ctx, req, meta, torrent); err != nil {
-					return 0, err
-				}
-			} else {
-				dryRunMeta := trackerDryRunProcessingMeta(meta, req)
-				entries, err := c.services.Trackers.BuildUploadDryRun(ctx, dryRunMeta, resolvedTrackers)
-				if err != nil {
-					return 0, fmt.Errorf("core: %w", err)
-				}
-				annotateDryRunReleaseNames(dryRunMeta, entries)
-				if err := c.injectTrackerDryRunTorrents(ctx, req, dryRunMeta, entries, torrent); err != nil {
-					return 0, err
-				}
-			}
-		}
-		c.logger.Infof("core: dry-run or debug enabled, skipping tracker upload source=%s", meta.SourcePath)
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "upload", "completed", "Dry run complete")
-		return 0, nil
-	}
-
-	c.logger.Debugf("core: uploading to trackers for %s", meta.SourcePath)
-	emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "tracker_upload", "running", "Uploading to tracker")
-	summary, uploadErr := c.services.Trackers.Upload(ctx, meta)
-	if summary.Uploaded < 0 {
-		return 0, fmt.Errorf("upload summary invalid: %d", summary.Uploaded)
-	}
-	if uploadErr != nil && summary.Uploaded == 0 {
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "tracker_upload", "failed", "Tracker upload failed")
-		return 0, fmt.Errorf("core: %w", uploadErr)
-	}
-
-	if !meta.Options.NoSeed {
-		// Cross-seed torrents come from dupe matches and should be injected even when
-		// the tracker upload summary later reports no successful uploads.
-		if err := c.injectCrossSeedTorrents(ctx, req, meta); err != nil {
-			if uploadErr != nil {
-				emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "tracker_upload", "failed", "Tracker upload failed")
-				return summary.Uploaded, fmt.Errorf("core: %w", errors.Join(uploadErr, err))
-			}
-			return summary.Uploaded, err
-		}
-	}
-
-	if uploadErr != nil {
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "tracker_upload", "failed", "Tracker upload failed")
-		return summary.Uploaded, fmt.Errorf("core: %w", uploadErr)
-	}
-	emitPreparedUploadProgress(ctx, req, meta.SourcePath, "", "tracker_upload", "completed", "Tracker upload complete")
-
-	if !meta.Options.NoSeed {
-		if len(summary.UploadedTorrents) == 0 {
-			c.logger.Warnf("core: no tracker torrent artifacts available for injection for %s", meta.SourcePath)
-		} else {
-			for _, uploaded := range summary.UploadedTorrents {
-				torrentPath := strings.TrimSpace(uploaded.TorrentPath)
-				torrentURL := strings.TrimSpace(uploaded.DownloadURL)
-				if torrentPath == "" && torrentURL == "" {
-					continue
-				}
-				c.logger.Debugf("core: injecting tracker torrent for %s from %s", meta.SourcePath, uploaded.Tracker)
-				emitPreparedUploadProgress(ctx, req, meta.SourcePath, uploaded.Tracker, "client_injection", "running", "Injecting torrent into client")
-				if err := c.services.Clients.Inject(ctx, meta, api.TorrentResult{
-					Path:    torrentPath,
-					URL:     torrentURL,
-					Tracker: uploaded.Tracker,
-				}); err != nil {
-					emitPreparedUploadProgress(ctx, req, meta.SourcePath, uploaded.Tracker, "client_injection", "failed", "Client injection failed")
-					return summary.Uploaded, fmt.Errorf("core: %w", err)
-				}
-				emitPreparedUploadProgress(ctx, req, meta.SourcePath, uploaded.Tracker, "client_injection", "completed", "Client injection complete")
-			}
-		}
-	}
-
-	return summary.Uploaded, nil
-}
-
-// persistPreparedInfoHash stores the prepared torrent hash without replacing
-// existing release metadata used by history views.
-func (c *Core) persistPreparedInfoHash(ctx context.Context, sourcePath string, infoHash string) error {
-	if c == nil || c.repo == nil {
-		return nil
-	}
-	trimmedPath := strings.TrimSpace(sourcePath)
-	trimmedHash := strings.TrimSpace(infoHash)
-	if trimmedPath == "" || trimmedHash == "" {
-		return nil
-	}
-
-	metadata, err := c.repo.GetByPath(ctx, trimmedPath)
-	if err != nil {
-		if !errors.Is(err, internalerrors.ErrNotFound) {
-			return fmt.Errorf("lookup existing metadata: %w", err)
-		}
-		c.logger.Debugf("metadata: skip info hash persistence without stored metadata for %s", trimmedPath)
-		return nil
-	} else if strings.TrimSpace(metadata.Path) == "" {
-		metadata.Path = trimmedPath
-	}
-	metadata.InfoHash = trimmedHash
-	metadata.UpdatedAt = time.Now().UTC()
-	if err := c.repo.Save(ctx, metadata); err != nil {
-		return fmt.Errorf("save metadata: %w", err)
-	}
-	return nil
-}
-
-func (c *Core) injectCrossSeedTorrents(ctx context.Context, req api.Request, meta api.PreparedMetadata) error {
-	if !c.cfg.PostUpload.CrossSeeding || len(meta.CrossSeedTorrents) == 0 {
-		return nil
-	}
-	if c.services.Clients == nil {
-		return errors.New("core: client service not configured")
-	}
-	for _, crossSeed := range meta.CrossSeedTorrents {
-		torrentPath := strings.TrimSpace(crossSeed.TorrentPath)
-		torrentURL := strings.TrimSpace(crossSeed.DownloadURL)
-		if torrentPath == "" && torrentURL == "" {
-			continue
-		}
-		tracker := strings.ToUpper(strings.TrimSpace(crossSeed.Tracker))
-		c.logger.Debugf("core: injecting cross-seed torrent for %s from %s", meta.SourcePath, tracker)
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, tracker, "client_injection", "running", "Injecting cross-seed torrent into client")
-		if err := c.services.Clients.Inject(ctx, meta, api.TorrentResult{
-			Path:      torrentPath,
-			URL:       torrentURL,
-			Tracker:   tracker,
-			CrossSeed: true,
-		}); err != nil {
-			emitPreparedUploadProgress(ctx, req, meta.SourcePath, tracker, "client_injection", "failed", "Cross-seed client injection failed")
-			return fmt.Errorf("core: %w", err)
-		}
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, tracker, "client_injection", "completed", "Cross-seed client injection complete")
-	}
-	return nil
+	result, err = c.upload.runPrepared(ctx, req)
+	return result, classifyOperationError(api.OperationKindUploadExecute, err)
 }
 
-func (c *Core) injectPreparedTorrent(ctx context.Context, req api.Request, meta api.PreparedMetadata, torrent api.TorrentResult) error {
-	if c.services.Clients == nil {
-		return errors.New("core: client service not configured")
-	}
-	c.logger.Debugf("core: dry-run or debug enabled, injecting prepared torrent for %s", meta.SourcePath)
-	emitPreparedUploadProgress(ctx, req, meta.SourcePath, torrent.Tracker, "client_injection", "running", "Injecting torrent into client")
-	if err := c.services.Clients.Inject(ctx, meta, torrent); err != nil {
-		emitPreparedUploadProgress(ctx, req, meta.SourcePath, torrent.Tracker, "client_injection", "failed", "Client injection failed")
-		return fmt.Errorf("core: %w", err)
-	}
-	emitPreparedUploadProgress(ctx, req, meta.SourcePath, torrent.Tracker, "client_injection", "completed", "Client injection complete")
-	return nil
+// RunAcceptedUpload executes the eligible trackers from a reviewed outcome
+// against its exact prepared generation without rerunning upload review.
+func (c *Core) RunAcceptedUpload(ctx context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	result, err := c.upload.runAccepted(ctx, plan)
+	return classifyOperationResult(api.OperationKindUploadExecute, result, err)
 }
 
 func emitPreparedUploadProgress(ctx context.Context, req api.Request, sourcePath string, tracker string, task string, status string, message string) {
@@ -511,3426 +346,545 @@ func firstRequestedTracker(trackers []string) string {
 	return ""
 }
 
-func (c *Core) CheckDupes(ctx context.Context, req api.Request) (summary api.DupeCheckSummary, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: dupe check blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
+// CheckDupes prepares one source and checks its resolved tracker set. The
+// result includes eligibility derived from duplicate, auth, rule, and policy
+// evidence; it does not persist duplicate results into the prepared generation.
+func (c *Core) CheckDupes(ctx context.Context, req api.Request) (api.DupeCheckSummary, error) {
+	summary, err := c.dupe.check(ctx, req)
+	return summary, classifyOperationError(api.OperationKindDuplicateCheck, err)
+}
 
-	req = normalizeExecutionRequest(req)
-	if len(req.Paths) == 0 {
-		return api.DupeCheckSummary{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Dupes == nil {
-		return api.DupeCheckSummary{}, errors.New("core: dupe service not configured")
-	}
+// CheckAcceptedDupes executes duplicate checking against state imported and
+// validated for one exact accepted prepared generation.
+func (c *Core) CheckAcceptedDupes(ctx context.Context, input api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	summary, err := c.dupe.checkAccepted(ctx, input)
+	return summary, classifyOperationError(api.OperationKindDuplicateCheck, err)
+}
 
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
+// FetchScreenshotPlan prepares one source and builds its screenshot capture plan.
+func (c *Core) FetchScreenshotPlan(ctx context.Context, req api.Request) (api.ScreenshotPlan, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return api.ScreenshotPlan{}, err
 	}
+	return c.FetchAcceptedScreenshotPlan(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   req.Options.Screens,
+		Options: req.ScreenshotOverrides,
+	})
+}
 
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.DupeCheckSummary{}, internalerrors.ErrInvalidInput
-	}
+// FetchAcceptedScreenshotPlan plans screenshots for one exact prepared generation.
+func (c *Core) FetchAcceptedScreenshotPlan(ctx context.Context, input api.MediaPlanInput) (api.ScreenshotPlan, error) {
+	result, err := c.media.fetchAcceptedScreenshotPlan(ctx, input)
+	return classifyOperationResult(api.OperationKindMedia, result, err)
+}
 
-	options, err := c.applyDefaultOptions(req.Options)
+// GenerateScreenshots prepares one source and captures the selected frames.
+func (c *Core) GenerateScreenshots(
+	ctx context.Context,
+	req api.Request,
+	selections []api.ScreenshotSelection,
+	purpose api.ScreenshotPurpose,
+) (api.ScreenshotResult, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, err
-	}
-	cacheReq := req
-	cacheReq.Options = options
-
-	if req.Mode == api.ModeGUI || req.Mode == api.ModeCLI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, cacheReq, uniquePaths[0]); err != nil {
-			return api.DupeCheckSummary{}, err
-		} else if ok {
-			matchedTrackers := mergeTrackerRemovals(nil, cached.MatchedTrackers)
-			removeTrackers := mergeTrackerRemovals(nil, req.TrackersRemove)
-			checkMeta := cached
-			if dryRunOrDebug(req) {
-				checkMeta = dupeCheckDryRunProcessingMeta(cached)
-			} else {
-				removeTrackers = mergeTrackerRemovals(removeTrackers, matchedTrackers)
-			}
-			resolvedTrackers := trackers.ResolveTrackers(c.cfg, req.Trackers, removeTrackers, c.logger)
-			summary, err := c.checkGUIDupesWithAuth(ctx, req.Mode, checkMeta, resolvedTrackers)
-			if err != nil {
-				return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
-			}
-			if !dryRunOrDebug(req) {
-				summary = appendPathedDupeResults(summary, matchedTrackers)
-			}
-			applyDupeSummaryToPreparedMeta(&cached, summary)
-			c.storeRefreshedDupeCacheWithDupeSummary(cached.SourcePath, overrideSignature(cached.ExternalIDOverrides, cached.ReleaseNameOverrides, cached.MetadataOverrides, cached.TrackerConfigOverrides, cached.TrackerSiteOverrides, cached.ClientOverrides, cached.TorrentOverrides, cached.ImageHostOverrides, cached.ScreenshotOverrides), cached, summary)
-			return summary, nil
-		}
-		if req.Mode == api.ModeGUI {
-			return api.DupeCheckSummary{}, errors.New("core: dupe check requires metadata preview")
-		}
+		return api.ScreenshotResult{}, err
 	}
+	return c.GenerateAcceptedScreenshots(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   req.Options.Screens,
+		Purpose: purpose,
+		Options: req.ScreenshotOverrides,
+	}, selections)
+}
 
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-	singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-
-	if err := c.resetContentForExternalOverrides(ctx, uniquePaths[0], singleReq.ExternalIDOverrides); err != nil {
-		return api.DupeCheckSummary{}, err
-	}
+// GenerateAcceptedScreenshots captures selections for one exact prepared generation.
+func (c *Core) GenerateAcceptedScreenshots(
+	ctx context.Context,
+	input api.MediaPlanInput,
+	selections []api.ScreenshotSelection,
+) (api.ScreenshotResult, error) {
+	result, err := c.media.generateAcceptedScreenshots(ctx, input, selections)
+	return classifyOperationResult(api.OperationKindMedia, result, err)
+}
 
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
+// PreviewScreenshotFrame renders one frame at timestampSeconds for one
+// validated source without adding it to the final screenshot selection.
+func (c *Core) PreviewScreenshotFrame(ctx context.Context, req api.Request, timestampSeconds float64) (api.ScreenshotPreview, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return api.ScreenshotPreview{}, err
 	}
+	return c.PreviewAcceptedScreenshotFrame(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   req.Options.Screens,
+		Options: req.ScreenshotOverrides,
+	}, timestampSeconds)
+}
+
+// PreviewAcceptedScreenshotFrame renders one frame for an exact prepared generation.
+func (c *Core) PreviewAcceptedScreenshotFrame(
+	ctx context.Context,
+	input api.MediaPlanInput,
+	timestampSeconds float64,
+) (api.ScreenshotPreview, error) {
+	result, err := c.media.previewAcceptedScreenshotFrame(ctx, input, timestampSeconds)
+	return classifyOperationResult(api.OperationKindMedia, result, err)
+}
 
-	storedApplied, err := c.applyStoredTrackerData(ctx, &meta)
+// DeleteScreenshot removes a managed local screenshot and attempts cleanup of
+// its persisted records. The default screenshot service rejects paths outside
+// the release's managed temporary directory.
+func (c *Core) DeleteScreenshot(ctx context.Context, req api.Request, imagePath string) error {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, err
+		return err
 	}
-	runPathedSearch := func(applyTrackerData bool) error {
-		if meta.Options.SkipAutoTorrent {
-			c.logger.Debugf("core: skip_auto_torrent enabled, skipping pathed search for %s", meta.SourcePath)
-			return nil
-		}
-
-		searchResult, searchErr := c.services.Clients.SearchPathedTorrents(ctx, meta)
-		if searchErr != nil {
-			return fmt.Errorf("core: %w", searchErr)
-		}
-
-		if applyTrackerData {
-			resetPreparedClientData(&meta, singleReq)
-		}
-		meta.FoundTrackerMatch = meta.FoundTrackerMatch || searchResult.FoundTrackerMatch
-		meta.MatchedTrackers = mergeTrackerRemovals(meta.MatchedTrackers, searchResult.MatchedTrackers)
-		meta.TrackersRemove = mergeTrackerRemovals(meta.TrackersRemove, searchResult.MatchedTrackers)
-		markTrackerDataMatches(&meta, searchResult.MatchedTrackers)
+	return c.DeleteAcceptedScreenshot(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   req.Options.Screens,
+		Options: req.ScreenshotOverrides,
+	}, imagePath)
+}
 
-		if !applyTrackerData {
-			return nil
-		}
+// DeleteAcceptedScreenshot deletes one managed image for an exact prepared generation.
+func (c *Core) DeleteAcceptedScreenshot(ctx context.Context, input api.MediaPlanInput, imagePath string) error {
+	return classifyOperationError(api.OperationKindMedia, c.media.deleteAcceptedScreenshot(ctx, input, imagePath))
+}
 
-		if !applyPathedTorrentData(&meta, searchResult) {
-			return nil
-		}
-		return nil
+// DeleteTrackerImageURL removes url from persisted tracker metadata for one
+// validated source; it does not delete the remote image.
+func (c *Core) DeleteTrackerImageURL(ctx context.Context, req api.Request, url string) error {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
+	if err != nil {
+		return err
 	}
+	return c.DeleteAcceptedTrackerImageURL(ctx, api.ImageHostingInput{Release: ref}, url)
+}
 
-	switch {
-	case meta.SourceLookupActive:
-		c.logger.Debugf("core: running pathed search for tracker presence with source url override active for %s", meta.SourcePath)
-		if err := runPathedSearch(false); err != nil {
-			return api.DupeCheckSummary{}, err
-		}
-	case storedApplied:
-		c.logger.Debugf("core: running pathed search with stored tracker data present for %s", meta.SourcePath)
-		if err := runPathedSearch(true); err != nil {
-			return api.DupeCheckSummary{}, err
-		}
-	case meta.StoredDataFresh:
-		if meta.InfoHash == "" && meta.StoredInfoHash != "" {
-			meta.InfoHash = meta.StoredInfoHash
-			c.logger.Debugf("core: using stored infohash before pathed search for %s", meta.SourcePath)
-		} else {
-			c.logger.Debugf("core: running pathed search with fresh stored metadata snapshot for %s", meta.SourcePath)
-		}
-		if err := runPathedSearch(true); err != nil {
-			return api.DupeCheckSummary{}, err
-		}
-	default:
-		if meta.InfoHash == "" && len(meta.TrackerIDs) == 0 {
-			if err := runPathedSearch(true); err != nil {
-				return api.DupeCheckSummary{}, err
-			}
-		} else {
-			c.logger.Debugf("core: running pathed search for tracker presence with existing infohash/tracker IDs for %s", meta.SourcePath)
-			if err := runPathedSearch(false); err != nil {
-				return api.DupeCheckSummary{}, err
-			}
-		}
-	}
+// DeleteAcceptedTrackerImageURL removes one tracker image from an exact generation.
+func (c *Core) DeleteAcceptedTrackerImageURL(ctx context.Context, input api.ImageHostingInput, url string) error {
+	return classifyOperationError(api.OperationKindImageHosting, c.media.deleteAcceptedTrackerImageURL(ctx, input, url))
+}
 
-	meta, err = c.services.Metadata.EnrichTrackerData(ctx, meta)
-	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
-	}
-	meta, err = c.services.Metadata.ApplyMediaInfoIDs(ctx, meta)
+// SaveFinalScreenshotSelections validates and persists the non-menu final
+// screenshot selection for one source. Menu images in images are ignored.
+func (c *Core) SaveFinalScreenshotSelections(ctx context.Context, req api.Request, images []api.ScreenshotImage) error {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return err
 	}
-	meta, err = c.services.Metadata.ApplyArrData(ctx, meta)
+	return c.SaveAcceptedFinalScreenshotSelections(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   req.Options.Screens,
+		Options: req.ScreenshotOverrides,
+	}, images)
+}
+
+// SaveAcceptedFinalScreenshotSelections persists selections for an exact prepared generation.
+func (c *Core) SaveAcceptedFinalScreenshotSelections(ctx context.Context, input api.MediaPlanInput, images []api.ScreenshotImage) error {
+	return classifyOperationError(api.OperationKindMedia, c.media.saveAcceptedFinalScreenshotSelections(ctx, input, images))
+}
+
+// ImportMenuImages copies supported host-filesystem images into one release's
+// managed temporary directory and appends them to its final selection.
+func (c *Core) ImportMenuImages(ctx context.Context, req api.Request, importPaths []string) error {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return err
 	}
-	meta, err = c.services.Metadata.ResolveExternalIDs(ctx, meta)
+	return c.ImportAcceptedMenuImages(ctx, api.MediaPlanInput{Release: ref}, importPaths)
+}
+
+// ImportAcceptedMenuImages imports menu images for one exact prepared generation.
+func (c *Core) ImportAcceptedMenuImages(ctx context.Context, input api.MediaPlanInput, importPaths []string) error {
+	return classifyOperationError(api.OperationKindMedia, c.media.importAcceptedMenuImages(ctx, input, importPaths))
+}
+
+// ListUploadCandidates returns persisted normal and disc-menu images eligible
+// for image-host upload for one validated source.
+func (c *Core) ListUploadCandidates(ctx context.Context, req api.Request) ([]api.ScreenshotImage, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return nil, err
 	}
-	meta, err = c.services.Metadata.ApplyMediaDetails(ctx, meta)
+	return c.ListAcceptedUploadCandidates(ctx, api.ImageHostingInput{Release: ref})
+}
+
+// ListAcceptedUploadCandidates returns image-host candidates for an exact generation.
+func (c *Core) ListAcceptedUploadCandidates(ctx context.Context, input api.ImageHostingInput) ([]api.ScreenshotImage, error) {
+	result, err := c.media.listAcceptedUploadCandidates(ctx, input)
+	return classifyOperationResult(api.OperationKindImageHosting, result, err)
+}
+
+// ListUploadedImages returns persisted image-host links for one validated
+// source.
+func (c *Core) ListUploadedImages(ctx context.Context, req api.Request) ([]api.UploadedImageLink, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return nil, err
 	}
-	meta, err = c.services.Metadata.ApplyTrackerClaims(ctx, meta)
+	return c.ListAcceptedUploadedImages(ctx, api.ImageHostingInput{Release: ref})
+}
+
+// ListAcceptedUploadedImages returns persisted links for one exact generation.
+func (c *Core) ListAcceptedUploadedImages(ctx context.Context, input api.ImageHostingInput) ([]api.UploadedImageLink, error) {
+	result, err := c.media.listAcceptedUploadedImages(ctx, input)
+	return classifyOperationResult(api.OperationKindImageHosting, result, err)
+}
+
+// UploadImages uploads selected images to the requested host and any additional
+// hosts required by eligible trackers. Per-host failures are returned in the
+// result alongside successful links.
+func (c *Core) UploadImages(
+	ctx context.Context,
+	req api.Request,
+	host string,
+	images []api.ScreenshotImage,
+) (api.UploadImagesResult, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
+		return api.UploadImagesResult{}, err
 	}
+	return c.UploadAcceptedImages(ctx, api.ImageHostingInput{
+		Release:  ref,
+		Trackers: append([]string(nil), req.Trackers...),
+		Host:     host,
+	}, images)
+}
 
-	c.storeRefreshedDupeCache(meta.SourcePath, overrideSignature(meta.ExternalIDOverrides, meta.ReleaseNameOverrides, meta.MetadataOverrides, meta.TrackerConfigOverrides, meta.TrackerSiteOverrides, meta.ClientOverrides, meta.TorrentOverrides, meta.ImageHostOverrides, meta.ScreenshotOverrides), meta)
+// UploadAcceptedImages uploads selected images for an exact prepared generation.
+func (c *Core) UploadAcceptedImages(
+	ctx context.Context,
+	input api.ImageHostingInput,
+	images []api.ScreenshotImage,
+) (api.UploadImagesResult, error) {
+	result, err := c.media.uploadAcceptedImages(ctx, input, images)
+	return classifyOperationResult(api.OperationKindImageHosting, result, err)
+}
 
-	matchedTrackers := mergeTrackerRemovals(nil, meta.MatchedTrackers)
-	removeTrackers := mergeTrackerRemovals(nil, req.TrackersRemove)
-	checkMeta := meta
-	if dryRunOrDebug(req) {
-		checkMeta = dupeCheckDryRunProcessingMeta(meta)
-	} else {
-		removeTrackers = mergeTrackerRemovals(removeTrackers, matchedTrackers)
-	}
-	resolvedTrackers := trackers.ResolveTrackers(c.cfg, req.Trackers, removeTrackers, c.logger)
-	summary, err = c.checkGUIDupesWithAuth(ctx, req.Mode, checkMeta, resolvedTrackers)
+// DeleteUploadedImage removes one persisted image-host link. It does not delete
+// either the local image or the remote asset.
+func (c *Core) DeleteUploadedImage(ctx context.Context, req api.Request, imagePath string, host string) error {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
-		return api.DupeCheckSummary{}, fmt.Errorf("core: %w", err)
-	}
-	if !dryRunOrDebug(req) {
-		summary = appendPathedDupeResults(summary, matchedTrackers)
+		return err
 	}
-	applyDupeSummaryToPreparedMeta(&meta, summary)
-	c.storeRefreshedDupeCacheWithDupeSummary(meta.SourcePath, overrideSignature(meta.ExternalIDOverrides, meta.ReleaseNameOverrides, meta.MetadataOverrides, meta.TrackerConfigOverrides, meta.TrackerSiteOverrides, meta.ClientOverrides, meta.TorrentOverrides, meta.ImageHostOverrides, meta.ScreenshotOverrides), meta, summary)
-	return summary, nil
+	return c.DeleteAcceptedUploadedImage(ctx, api.ImageHostingInput{Release: ref}, imagePath, host)
 }
 
-func (c *Core) FetchScreenshotPlan(ctx context.Context, req api.Request) (api.ScreenshotPlan, error) {
-	if len(req.Paths) == 0 {
-		return api.ScreenshotPlan{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Screenshots == nil {
-		return api.ScreenshotPlan{}, errors.New("core: screenshots service not configured")
-	}
+// DeleteAcceptedUploadedImage removes one persisted link for an exact generation.
+func (c *Core) DeleteAcceptedUploadedImage(ctx context.Context, input api.ImageHostingInput, imagePath string, host string) error {
+	return classifyOperationError(api.OperationKindImageHosting, c.media.deleteAcceptedUploadedImage(ctx, input, imagePath, host))
+}
 
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
+// FetchMetadataPreview prepares and enriches metadata for one validated source,
+// emits metadata progress, and stores an isolated prepared-release snapshot.
+func (c *Core) FetchMetadataPreview(ctx context.Context, req api.Request) (preview api.MetadataPreview, err error) {
+	defer func() { err = classifyOperationError(api.OperationKindPreparation, err) }()
+	input, err := api.MapPreparationRequest(req, api.PreparationIntentPreview)
 	if err != nil {
-		return api.ScreenshotPlan{}, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
+		return api.MetadataPreview{}, fmt.Errorf("core: map metadata preparation request: %w", err)
 	}
-	if len(uniquePaths) != 1 {
-		return api.ScreenshotPlan{}, internalerrors.ErrInvalidInput
+	prepared, err := c.preparedFacts.Prepare(ctx, input)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("core: prepare metadata preview: %w", err)
 	}
+	preview, err = c.FetchAcceptedMetadataPreview(ctx, api.ReleaseRef{
+		SourcePath: prepared.Release.Source.SourcePath,
+		Generation: prepared.Release.Generation,
+	})
+	preview.ReleaseNameOverrides = req.ReleaseNameOverrides
+	return preview, err
+}
 
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.ScreenshotPlan{}, err
-		} else if ok {
-			return wrapCoreResult(c.services.Screenshots.Plan(ctx, cached, cached.Options.Screens))
-		}
-		return api.ScreenshotPlan{}, errors.New("core: screenshot plan requires metadata preview")
+// PrepareRelease returns one immutable canonical prepared-release generation.
+func (c *Core) PrepareRelease(ctx context.Context, input api.PrepareInput) (api.PrepareResult, error) {
+	result, err := c.preparedFacts.Prepare(ctx, input)
+	if err != nil {
+		return api.PrepareResult{}, classifyOperationError(api.OperationKindPreparation, fmt.Errorf("core: prepare release: %w", err))
 	}
+	return result, nil
+}
 
-	options, err := c.applyDefaultOptions(req.Options)
+// ExportReleaseSeed snapshots one exact canonical prepared generation.
+func (c *Core) ExportReleaseSeed(ctx context.Context, ref api.ReleaseRef) (preparedrelease.Seed, error) {
+	seed, err := c.preparedFacts.Export(ctx, ref)
 	if err != nil {
-		return api.ScreenshotPlan{}, err
+		return preparedrelease.Seed{}, fmt.Errorf("core: export release seed: %w", err)
 	}
+	return seed, nil
+}
 
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
+// ImportReleaseSeed validates and installs one exact canonical prepared generation.
+func (c *Core) ImportReleaseSeed(ctx context.Context, seed preparedrelease.Seed) (api.ReleaseRef, error) {
+	ref, err := c.preparedFacts.Import(ctx, seed)
 	if err != nil {
-		return api.ScreenshotPlan{}, fmt.Errorf("core: %w", err)
+		return api.ReleaseRef{}, fmt.Errorf("core: import release seed: %w", err)
 	}
-
-	return wrapCoreResult(c.services.Screenshots.Plan(ctx, meta, options.Screens))
+	return ref, nil
 }
 
-func (c *Core) GenerateScreenshots(ctx context.Context, req api.Request, selections []api.ScreenshotSelection, purpose api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	if len(req.Paths) == 0 {
-		return api.ScreenshotResult{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Screenshots == nil {
-		return api.ScreenshotResult{}, errors.New("core: screenshots service not configured")
-	}
-	if len(selections) == 0 {
-		return api.ScreenshotResult{}, internalerrors.ErrInvalidInput
+// FetchPreparationPreview builds tracker preparation data for one source,
+// reusing an exact compatible prepared generation when available.
+func (c *Core) FetchPreparationPreview(ctx context.Context, req api.Request) (preview api.PreparationPreview, err error) {
+	defer func() { err = classifyOperationError(api.OperationKindDescription, err) }()
+	input, err := api.MapPreparationRequest(req, api.PreparationIntentDescription)
+	if err != nil {
+		return api.PreparationPreview{}, fmt.Errorf("core: map description preparation request: %w", err)
 	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
+	prepared, err := c.preparedFacts.Prepare(ctx, input)
 	if err != nil {
-		return api.ScreenshotResult{}, fmt.Errorf("core: %w", err)
+		return api.PreparationPreview{}, fmt.Errorf("core: prepare description preview: %w", err)
 	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.ScreenshotResult{}, internalerrors.ErrInvalidInput
-	}
-
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.ScreenshotResult{}, err
-		} else if ok {
-			return wrapCoreResult(c.services.Screenshots.Capture(ctx, cached, selections, purpose))
-		}
-		return api.ScreenshotResult{}, errors.New("core: screenshot capture requires metadata preview")
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.ScreenshotResult{}, err
-	}
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return api.ScreenshotResult{}, fmt.Errorf("core: %w", err)
-	}
-
-	return wrapCoreResult(c.services.Screenshots.Capture(ctx, meta, selections, purpose))
-}
-
-func (c *Core) PreviewScreenshotFrame(ctx context.Context, req api.Request, timestampSeconds float64) (api.ScreenshotPreview, error) {
-	if len(req.Paths) == 0 {
-		return api.ScreenshotPreview{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Screenshots == nil {
-		return api.ScreenshotPreview{}, errors.New("core: screenshots service not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.ScreenshotPreview{}, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.ScreenshotPreview{}, internalerrors.ErrInvalidInput
-	}
-
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.ScreenshotPreview{}, err
-		} else if ok {
-			return wrapCoreResult(c.services.Screenshots.PreviewFrame(ctx, cached, timestampSeconds))
-		}
-		return api.ScreenshotPreview{}, errors.New("core: screenshot preview requires metadata preview")
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.ScreenshotPreview{}, err
-	}
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return api.ScreenshotPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	return wrapCoreResult(c.services.Screenshots.PreviewFrame(ctx, meta, timestampSeconds))
-}
-
-func (c *Core) DeleteScreenshot(ctx context.Context, req api.Request, imagePath string) error {
-	if len(req.Paths) == 0 {
-		return internalerrors.ErrInvalidInput
-	}
-	if c.services.Screenshots == nil {
-		return errors.New("core: screenshots service not configured")
-	}
-	if strings.TrimSpace(imagePath) == "" {
-		return internalerrors.ErrInvalidInput
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return internalerrors.ErrInvalidInput
-	}
-
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return err
-		} else if ok {
-			return wrapCoreError(c.services.Screenshots.Delete(ctx, cached, imagePath))
-		}
-		return errors.New("core: screenshot delete requires metadata preview")
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return err
-	}
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-
-	return wrapCoreError(c.services.Screenshots.Delete(ctx, meta, imagePath))
-}
-
-func (c *Core) DeleteTrackerImageURL(ctx context.Context, req api.Request, url string) error {
-	if len(req.Paths) == 0 {
-		return internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return errors.New("core: repository not configured")
-	}
-	trimmedURL := strings.TrimSpace(url)
-	if trimmedURL == "" {
-		return internalerrors.ErrInvalidInput
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return internalerrors.ErrInvalidInput
-	}
-
-	records, err := c.repo.ListTrackerMetadataByPath(ctx, uniquePaths[0])
-	if err != nil {
-		return fmt.Errorf("core: tracker metadata lookup: %w", err)
-	}
-
-	for _, record := range records {
-		if len(record.ImageURLs) == 0 {
-			continue
-		}
-		filtered := make([]string, 0, len(record.ImageURLs))
-		removed := false
-		for _, value := range record.ImageURLs {
-			if strings.TrimSpace(value) == trimmedURL {
-				removed = true
-				continue
-			}
-			filtered = append(filtered, value)
-		}
-		if !removed {
-			continue
-		}
-		record.ImageURLs = filtered
-		if strings.TrimSpace(record.SourcePath) == "" {
-			record.SourcePath = uniquePaths[0]
-		}
-		if err := c.repo.SaveTrackerMetadata(ctx, record); err != nil {
-			return fmt.Errorf("core: save tracker metadata: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (c *Core) SaveFinalScreenshotSelections(ctx context.Context, req api.Request, images []api.ScreenshotImage) error {
-	if len(req.Paths) == 0 {
-		return internalerrors.ErrInvalidInput
-	}
-	if c.services.Screenshots == nil {
-		return errors.New("core: screenshots service not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return internalerrors.ErrInvalidInput
-	}
-
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return err
-		} else if ok {
-			return wrapCoreError(c.services.Screenshots.SaveFinalSelections(ctx, cached, images))
-		}
-		return errors.New("core: screenshot selection save requires metadata preview")
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return err
-	}
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-
-	return wrapCoreError(c.services.Screenshots.SaveFinalSelections(ctx, meta, images))
-}
-
-// ImportMenuImages copies supported image files from host filesystem paths into
-// one prepared release's managed temp directory. Content-addressed names dedupe
-// repeated imports, and DB records/selections are appended atomically.
-func (c *Core) ImportMenuImages(ctx context.Context, req api.Request, importPaths []string) error {
-	if len(req.Paths) == 0 {
-		return internalerrors.ErrInvalidInput
-	}
-	if len(importPaths) == 0 {
-		return nil
-	}
-	if c.repo == nil {
-		return errors.New("core: repository not configured")
-	}
-	if c.services.Filesystem == nil {
-		return errors.New("core: filesystem service not configured")
-	}
-	lifecycle, ok := c.repo.(api.ScreenshotLifecycleRepository)
-	if !ok {
-		return errors.New("core: screenshot lifecycle repository not configured")
-	}
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return fmt.Errorf("core: validate menu paths: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return internalerrors.ErrInvalidInput
-	}
-	sourcePath := uniquePaths[0]
-
-	var expandedPaths []string
-	for _, p := range importPaths {
-		p = strings.TrimSpace(p)
-		if p == "" {
-			continue
-		}
-		info, err := os.Stat(p)
-		if err != nil {
-			return fmt.Errorf("stat menu path %s: %w", p, err)
-		}
-		if info.IsDir() {
-			entries, err := os.ReadDir(p)
-			if err != nil {
-				return fmt.Errorf("read menu dir %s: %w", p, err)
-			}
-			for _, entry := range entries {
-				if !entry.IsDir() {
-					ext := strings.ToLower(filepath.Ext(entry.Name()))
-					if isMenuImageExtension(ext) {
-						expandedPaths = append(expandedPaths, filepath.Join(p, entry.Name()))
-					}
-				}
-			}
-		} else {
-			ext := strings.ToLower(filepath.Ext(p))
-			if isMenuImageExtension(ext) {
-				expandedPaths = append(expandedPaths, p)
-			}
-		}
-	}
-
-	tmpRoot, err := db.Subdir(c.cfg.MainSettings.DBPath, "tmp")
-	if err != nil {
-		return fmt.Errorf("core: resolve tmp root: %w", err)
-	}
-
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, sourcePath)
-	if err != nil {
-		return fmt.Errorf("core: create release tmp dir: %w", err)
-	}
-
-	if len(expandedPaths) == 0 {
-		return nil
-	}
-
-	now := time.Now().UTC()
-	records := make([]api.Screenshot, 0, len(expandedPaths))
-	selections := make([]api.ScreenshotFinalSelection, 0, len(expandedPaths))
-	created := make([]string, 0, len(expandedPaths))
-	seen := make(map[string]struct{}, len(expandedPaths))
-	for _, sourceImage := range expandedPaths {
-		destPath, wasCreated, err := copyManagedMenuImage(tmpDir, sourceImage)
-		if err != nil {
-			removeMenuImportFiles(created)
-			return err
-		}
-		if _, exists := seen[destPath]; exists {
-			continue
-		}
-		seen[destPath] = struct{}{}
-		if wasCreated {
-			created = append(created, destPath)
-		}
-		records = append(records, api.Screenshot{
-			SourcePath: sourcePath,
-			ImagePath:  destPath,
-			Purpose:    api.ScreenshotPurposeMenu,
-			CapturedAt: now,
-		})
-		selections = append(selections, api.ScreenshotFinalSelection{
-			SourcePath: sourcePath,
-			ImagePath:  destPath,
-			Order:      len(selections),
-			Source:     api.ScreenshotSelectionSourceMenu,
-			SelectedAt: now,
-		})
-	}
-	if err := lifecycle.AppendManualMenuScreenshots(ctx, sourcePath, records, selections); err != nil {
-		removeMenuImportFiles(created)
-		return fmt.Errorf("core: save menu selections: %w", err)
-	}
-	return nil
-}
-
-func isMenuImageExtension(extension string) bool {
-	switch strings.ToLower(strings.TrimSpace(extension)) {
-	case ".png", ".jpg", ".jpeg", ".webp":
-		return true
-	default:
-		return false
-	}
-}
-
-// copyManagedMenuImage stages one import and assigns a content-addressed managed
-// name. The boolean result reports whether this call created the destination.
-func copyManagedMenuImage(tmpDir string, sourcePath string) (string, bool, error) {
-	source, err := os.Open(sourcePath)
-	if err != nil {
-		return "", false, fmt.Errorf("core: open menu image: %w", err)
-	}
-	defer source.Close()
-
-	staged, err := os.CreateTemp(tmpDir, ".manual-dvd-menu-*.partial")
-	if err != nil {
-		return "", false, fmt.Errorf("core: stage menu image: %w", err)
-	}
-	stagedPath := staged.Name()
-	cleanupStaged := true
-	defer func() {
-		if cleanupStaged {
-			_ = os.Remove(stagedPath)
-		}
-	}()
-
-	hash := sha256.New()
-	if _, err := io.Copy(io.MultiWriter(staged, hash), source); err != nil {
-		_ = staged.Close()
-		return "", false, fmt.Errorf("core: copy menu image: %w", err)
-	}
-	if err := staged.Close(); err != nil {
-		return "", false, fmt.Errorf("core: close staged menu image: %w", err)
-	}
-	extension := strings.ToLower(filepath.Ext(sourcePath))
-	destPath := filepath.Join(tmpDir, fmt.Sprintf("manual-dvd-menu-%x%s", hash.Sum(nil)[:8], extension))
-	if info, err := os.Stat(destPath); err == nil {
-		if info.IsDir() {
-			return "", false, internalerrors.ErrInvalidInput
-		}
-		return destPath, false, nil
-	} else if !errors.Is(err, os.ErrNotExist) {
-		return "", false, fmt.Errorf("core: inspect managed menu image: %w", err)
-	}
-	if err := os.Rename(stagedPath, destPath); err != nil {
-		if info, statErr := os.Stat(destPath); statErr == nil && !info.IsDir() {
-			return destPath, false, nil
-		}
-		return "", false, fmt.Errorf("core: finalize menu image: %w", err)
-	}
-	cleanupStaged = false
-	return destPath, true, nil
-}
-
-func removeMenuImportFiles(paths []string) {
-	for _, pathValue := range paths {
-		_ = os.Remove(pathValue)
-	}
-}
-
-// ListUploadCandidates returns persisted normal and disc-menu images eligible
-// for image-host upload for one prepared release.
-func (c *Core) ListUploadCandidates(ctx context.Context, req api.Request) ([]api.ScreenshotImage, error) {
-	if len(req.Paths) == 0 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-	if c.services.Images == nil {
-		return nil, errors.New("core: image hosting service not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-
-	var meta api.PreparedMetadata
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return nil, err
-		} else if ok {
-			meta = cached
-		} else {
-			meta = api.PreparedMetadata{SourcePath: uniquePaths[0]}
-		}
-	} else {
-		options, err := c.applyDefaultOptions(req.Options)
-		if err != nil {
-			return nil, err
-		}
-		singleReq := req
-		singleReq.Paths = []string{uniquePaths[0]}
-		singleReq.Options = options
-
-		preparedMeta, err := c.services.Metadata.Prepare(ctx, singleReq)
-		if err != nil {
-			return nil, fmt.Errorf("core: %w", err)
-		}
-		meta = preparedMeta
-	}
-
-	return wrapCoreResult(c.services.Images.ListCandidates(ctx, meta))
-}
-
-func (c *Core) ListUploadedImages(ctx context.Context, req api.Request) ([]api.UploadedImageLink, error) {
-	if len(req.Paths) == 0 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return nil, errors.New("core: repository not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-
-	return wrapCoreResult(c.repo.ListUploadedImagesByPath(ctx, uniquePaths[0]))
-}
-
-// UploadImages uploads one source's selected images to the requested global
-// host and any additional hosts required by its eligible trackers. Host uploads
-// run concurrently, tracker-owned hosts use tracker-scoped records, and
-// recoverable host failures are returned in [api.UploadImagesResult].
-func (c *Core) UploadImages(ctx context.Context, req api.Request, host string, images []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	if len(req.Paths) == 0 {
-		return api.UploadImagesResult{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Images == nil {
-		return api.UploadImagesResult{}, errors.New("core: image hosting service not configured")
-	}
-	if len(images) == 0 {
-		return api.UploadImagesResult{}, internalerrors.ErrInvalidInput
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.UploadImagesResult{}, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.UploadImagesResult{}, internalerrors.ErrInvalidInput
-	}
-
-	var meta api.PreparedMetadata
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.UploadImagesResult{}, err
-		} else if ok {
-			meta = cached
-		} else {
-			meta = api.PreparedMetadata{SourcePath: uniquePaths[0]}
-		}
-	} else {
-		options, err := c.applyDefaultOptions(req.Options)
-		if err != nil {
-			return api.UploadImagesResult{}, err
-		}
-		singleReq := req
-		singleReq.Paths = []string{uniquePaths[0]}
-		singleReq.Options = options
-
-		preparedMeta, err := c.services.Metadata.Prepare(ctx, singleReq)
-		if err != nil {
-			return api.UploadImagesResult{}, fmt.Errorf("core: %w", err)
-		}
-		meta = preparedMeta
-	}
-
-	targets, err := c.resolveImageUploadTargets(req, meta, host)
-	if err != nil {
-		return api.UploadImagesResult{}, err
-	}
-	return c.uploadImagesToTargetsWithFallback(ctx, meta, host, targets, images)
-}
-
-func (c *Core) resolveImageUploadTargets(req api.Request, meta api.PreparedMetadata, host string) ([]trackers.ImageUploadTarget, error) {
-	normalizedHost := strings.ToLower(strings.TrimSpace(host))
-	if normalizedHost == "" {
-		return nil, internalerrors.ErrInvalidInput
-	}
-
-	trackerCfg := c.cfg
-	trackerCfg.Trackers.DefaultTrackers = nil
-	resolvedTrackers := trackers.ResolveTrackers(trackerCfg, req.Trackers, req.TrackersRemove, c.logger)
-	resolvedTrackers = c.filterImageUploadTrackers(resolvedTrackers, meta)
-	targets, err := trackers.NeededImageUploadTargetsForMetadata(c.cfg, resolvedTrackers, normalizedHost, meta)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	if len(targets) == 0 {
-		return nil, fmt.Errorf("core: image host %q is tracker-scoped but no active tracker can use it", normalizedHost)
-	}
-	normalized := make([]trackers.ImageUploadTarget, 0, len(targets))
-	for _, target := range targets {
-		target = normalizeImageUploadTarget(target)
-		if target.Host == "" {
-			continue
-		}
-		normalized = append(normalized, target)
-	}
-	if len(normalized) == 0 {
-		return nil, fmt.Errorf("core: image host %q resolved image upload targets were filtered out after tracker eligibility and normalization", normalizedHost)
-	}
-	return normalized, nil
-}
-
-// filterImageUploadTrackers returns canonical tracker names that can receive
-// tracker-scoped image uploads, excluding blocked, rule-failed, or already matched trackers.
-func (c *Core) filterImageUploadTrackers(trackerNames []string, meta api.PreparedMetadata) []string {
-	filtered := make([]string, 0, len(trackerNames))
-	for _, tracker := range trackerNames {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		blockedReasons := blockedReasonsForTracker(meta.BlockedTrackers, name)
-		ruleFailures := ruleFailuresForTracker(meta.TrackerRuleFailures, name)
-		existingMatch := matchedTrackerForUpload(meta.MatchedTrackers, name)
-		if len(blockedReasons) > 0 || (!meta.IgnoreTrackerRuleFailures && api.HasBlockingRuleFailures(ruleFailures)) || existingMatch {
-			if c.logger != nil {
-				c.logger.Debugf("core: excluding blocked image upload tracker tracker=%s blocked_reasons=%v rule_failures=%d existing_match=%t", name, blockedReasons, len(ruleFailures), existingMatch)
-			}
-			continue
-		}
-		filtered = append(filtered, name)
-	}
-	return filtered
-}
-
-func matchedTrackerForUpload(matchedTrackers []string, tracker string) bool {
-	if len(matchedTrackers) == 0 {
-		return false
-	}
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" {
-		return false
-	}
-	for _, matched := range matchedTrackers {
-		for _, entry := range splitTrackerLabel(matched) {
-			if strings.EqualFold(strings.TrimSpace(entry), name) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func blockedReasonsForTracker(blocked map[string][]api.TrackerBlockReason, tracker string) []api.TrackerBlockReason {
-	if len(blocked) == 0 {
-		return nil
-	}
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if reasons, ok := blocked[name]; ok {
-		return reasons
-	}
-	for key, reasons := range blocked {
-		if strings.EqualFold(strings.TrimSpace(key), name) {
-			return reasons
-		}
-	}
-	return nil
-}
-
-func ruleFailuresForTracker(failures map[string][]api.RuleFailure, tracker string) []api.RuleFailure {
-	if len(failures) == 0 {
-		return nil
-	}
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if trackerFailures, ok := failures[name]; ok {
-		return trackerFailures
-	}
-	for key, trackerFailures := range failures {
-		if strings.EqualFold(strings.TrimSpace(key), name) {
-			return trackerFailures
-		}
-	}
-	return nil
-}
-
-func (c *Core) resolveFallbackImageUploadTargets(host string, trackerNames []string, excludedHosts []string, meta api.PreparedMetadata) ([]trackers.ImageUploadTarget, error) {
-	normalizedHost := strings.ToLower(strings.TrimSpace(host))
-	if normalizedHost == "" || len(trackerNames) == 0 {
-		return nil, nil
-	}
-	targets, err := trackers.NeededImageUploadTargetsForMetadataExcluding(c.cfg, trackerNames, normalizedHost, excludedHosts, meta)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	normalized := make([]trackers.ImageUploadTarget, 0, len(targets))
-	for _, target := range targets {
-		target = normalizeImageUploadTarget(target)
-		if target.Host == "" {
-			continue
-		}
-		normalized = append(normalized, target)
-	}
-	return normalized, nil
-}
-
-func (c *Core) uploadImagesToTargetsWithFallback(ctx context.Context, meta api.PreparedMetadata, host string, targets []trackers.ImageUploadTarget, images []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	allLinks := make([]api.UploadedImageLink, 0, len(images)*len(targets))
-	failedHosts := make(map[string]struct{}, len(targets))
-	currentTargets := targets
-	var failures []api.UploadImageHostFailure
-
-	for len(currentTargets) > 0 {
-		result := c.uploadImagesToTargets(ctx, meta, currentTargets, images)
-		allLinks = append(allLinks, result.Links...)
-		if len(result.Failures) == 0 {
-			return api.UploadImagesResult{Links: allLinks}, nil
-		}
-
-		failures = result.Failures
-		for _, failure := range result.Failures {
-			host := strings.ToLower(strings.TrimSpace(failure.Host))
-			if host != "" {
-				failedHosts[host] = struct{}{}
-			}
-		}
-
-		blockedTrackers := uploadFailureTrackers(failures)
-		fallbackTargets, err := c.resolveFallbackImageUploadTargets(host, blockedTrackers, sortedMapKeys(failedHosts), meta)
-		if err != nil {
-			return api.UploadImagesResult{}, err
-		}
-
-		var recoveredTrackers []string
-		nextTargets := make([]trackers.ImageUploadTarget, 0, len(fallbackTargets))
-		for _, target := range fallbackTargets {
-			if uploadedLinksCoverTarget(allLinks, target, len(images)) {
-				recoveredTrackers = append(recoveredTrackers, target.Trackers...)
-				continue
-			}
-			nextTargets = append(nextTargets, target)
-		}
-		failures = filterUploadFailuresForRecoveredTrackers(failures, recoveredTrackers)
-		if len(nextTargets) == 0 {
-			if len(failures) == 0 {
-				return api.UploadImagesResult{Links: allLinks}, nil
-			}
-			return api.UploadImagesResult{Links: allLinks, Failures: failures}, nil
-		}
-
-		c.logger.Warnf("core: retrying image uploads after host failures failed_hosts=%s fallback_hosts=%s trackers=%v", strings.Join(sortedMapKeys(failedHosts), ","), strings.Join(uploadTargetHosts(nextTargets), ","), uploadTargetTrackers(nextTargets))
-		currentTargets = nextTargets
-	}
-
-	return api.UploadImagesResult{Links: allLinks, Failures: failures}, nil
-}
-
-func uploadFailureTrackers(failures []api.UploadImageHostFailure) []string {
-	trackersList := make([]string, 0)
-	for _, failure := range failures {
-		for _, tracker := range failure.Trackers {
-			trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
-		}
-	}
-	return trackersList
-}
-
-func filterUploadFailuresForRecoveredTrackers(failures []api.UploadImageHostFailure, recoveredTrackers []string) []api.UploadImageHostFailure {
-	if len(failures) == 0 || len(recoveredTrackers) == 0 {
-		return failures
-	}
-	recovered := make(map[string]struct{}, len(recoveredTrackers))
-	for _, tracker := range recoveredTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name != "" {
-			recovered[name] = struct{}{}
-		}
-	}
-
-	filtered := make([]api.UploadImageHostFailure, 0, len(failures))
-	for _, failure := range failures {
-		remainingTrackers := make([]string, 0, len(failure.Trackers))
-		for _, tracker := range failure.Trackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name == "" {
-				continue
-			}
-			if _, ok := recovered[name]; ok {
-				continue
-			}
-			remainingTrackers = appendUniqueNormalizedTracker(remainingTrackers, name)
-		}
-		if len(failure.Trackers) > 0 && len(remainingTrackers) == 0 {
-			continue
-		}
-		failure.Trackers = remainingTrackers
-		filtered = append(filtered, failure)
-	}
-	return filtered
-}
-
-func uploadedLinksCoverTarget(links []api.UploadedImageLink, target trackers.ImageUploadTarget, expectedImages int) bool {
-	if expectedImages == 0 {
-		return false
-	}
-	host := strings.ToLower(strings.TrimSpace(target.Host))
-	scope := normalizeImageUploadUsageScope(target.UsageScope)
-	seenPaths := make(map[string]struct{}, expectedImages)
-	for _, link := range links {
-		if !strings.EqualFold(strings.TrimSpace(link.Host), host) {
-			continue
-		}
-		if normalizeImageUploadUsageScope(link.UsageScope) != scope {
-			continue
-		}
-		path := normalizedUploadImagePath(link.ImagePath)
-		if path == "" {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-	}
-	return len(seenPaths) >= expectedImages
-}
-
-func uploadTargetHosts(targets []trackers.ImageUploadTarget) []string {
-	hosts := make([]string, 0, len(targets))
-	seen := make(map[string]struct{}, len(targets))
-	for _, target := range targets {
-		host := strings.ToLower(strings.TrimSpace(target.Host))
-		if host == "" {
-			continue
-		}
-		if _, ok := seen[host]; ok {
-			continue
-		}
-		seen[host] = struct{}{}
-		hosts = append(hosts, host)
-	}
-	slices.Sort(hosts)
-	return hosts
-}
-
-func uploadTargetTrackers(targets []trackers.ImageUploadTarget) []string {
-	trackersList := make([]string, 0)
-	for _, target := range targets {
-		for _, tracker := range target.Trackers {
-			trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
-		}
-	}
-	slices.Sort(trackersList)
-	return trackersList
-}
-
-func sortedMapKeys(values map[string]struct{}) []string {
-	keys := make([]string, 0, len(values))
-	for key := range values {
-		if strings.TrimSpace(key) == "" {
-			continue
-		}
-		keys = append(keys, key)
-	}
-	slices.Sort(keys)
-	return keys
-}
-
-func (c *Core) uploadImagesToTargets(ctx context.Context, meta api.PreparedMetadata, targets []trackers.ImageUploadTarget, images []api.ScreenshotImage) api.UploadImagesResult {
-	type uploadResult struct {
-		index  int
-		target trackers.ImageUploadTarget
-		links  []api.UploadedImageLink
-		err    error
-	}
-
-	resultCh := make(chan uploadResult, len(targets))
-	var wg sync.WaitGroup
-	for idx, target := range targets {
-		wg.Add(1)
-		go func(idx int, target trackers.ImageUploadTarget) {
-			defer wg.Done()
-			uploaded, err := c.uploadImagesToTarget(ctx, meta, target, images)
-			resultCh <- uploadResult{
-				index:  idx,
-				target: normalizeImageUploadTarget(target),
-				links:  uploaded,
-				err:    err,
-			}
-		}(idx, target)
-	}
-	wg.Wait()
-	close(resultCh)
-
-	ordered := make([]uploadResult, len(targets))
-	for result := range resultCh {
-		ordered[result.index] = result
-	}
-
-	results := make([]api.UploadedImageLink, 0, len(images)*len(targets))
-	failures := make([]api.UploadImageHostFailure, 0)
-	failureMessages := make([]string, 0)
-	for _, result := range ordered {
-		results = append(results, result.links...)
-		if result.err != nil {
-			failure := api.UploadImageHostFailure{
-				Host:       result.target.Host,
-				UsageScope: result.target.UsageScope,
-				Trackers:   slices.Clone(result.target.Trackers),
-				Message:    logging.SanitizeMessage(uploadFailureMessage(result.err)),
-			}
-			failures = append(failures, failure)
-			failureMessages = append(failureMessages, fmt.Sprintf(
-				"host=%s trackers=%v err=%s",
-				result.target.Host,
-				result.target.Trackers,
-				redaction.RedactValue(failure.Message, nil),
-			))
-		}
-	}
-	if len(failures) == 0 {
-		return api.UploadImagesResult{Links: results}
-	}
-	result := api.UploadImagesResult{Links: results, Failures: failures}
-	if len(results) > 0 {
-		c.logger.Warnf("core: image uploads completed with %d host failures and %d successful links: %s", len(failures), len(results), strings.Join(failureMessages, "; "))
-		return result
-	}
-	c.logger.Warnf("core: image uploads failed for all hosts: %s", strings.Join(failureMessages, "; "))
-	return result
-}
-
-func normalizeImageUploadTarget(target trackers.ImageUploadTarget) trackers.ImageUploadTarget {
-	target.Host = strings.ToLower(strings.TrimSpace(target.Host))
-	target.UsageScope = normalizeImageUploadUsageScope(target.UsageScope)
-	trackersList := make([]string, 0, len(target.Trackers))
-	for _, tracker := range target.Trackers {
-		trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
-	}
-	target.Trackers = trackersList
-	return target
-}
-
-func appendUniqueNormalizedTracker(trackersList []string, tracker string) []string {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" {
-		return trackersList
-	}
-	if slices.Contains(trackersList, name) {
-		return trackersList
-	}
-	return append(trackersList, name)
-}
-
-func (c *Core) uploadImagesToTarget(ctx context.Context, meta api.PreparedMetadata, target trackers.ImageUploadTarget, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-	target.Host = strings.ToLower(strings.TrimSpace(target.Host))
-	target.UsageScope = normalizeImageUploadUsageScope(target.UsageScope)
-	if c.repo == nil {
-		c.logger.Tracef("core: uploading images host=%s tracker=%s scope=%s trackers=%v count=%d", target.Host, imageHostOwnerLogValue(target.Host), target.UsageScope, target.Trackers, len(images))
-		return wrapCoreResult(c.services.Images.Upload(ctx, meta, target.Host, target.UsageScope, images))
-	}
-
-	existing, err := c.repo.ListUploadedImagesByPath(ctx, meta.SourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	existingByPath := uploadedImagesByPathForTarget(existing, target)
-	results := make([]api.UploadedImageLink, 0, len(images))
-	missing := make([]api.ScreenshotImage, 0, len(images))
-	for _, image := range images {
-		key := normalizedUploadImagePath(image.Path)
-		if key == "" {
-			missing = append(missing, image)
-			continue
-		}
-		if link, ok := existingByPath[key]; ok {
-			results = append(results, link)
-			continue
-		}
-		missing = append(missing, image)
-	}
-	if len(missing) == 0 {
-		c.logger.Tracef("core: reusing uploaded images host=%s tracker=%s scope=%s trackers=%v count=%d", target.Host, imageHostOwnerLogValue(target.Host), target.UsageScope, target.Trackers, len(results))
-		return results, nil
-	}
-
-	c.logger.Debugf("core: uploading missing images host=%s tracker=%s scope=%s trackers=%v missing=%d reused=%d", target.Host, imageHostOwnerLogValue(target.Host), target.UsageScope, target.Trackers, len(missing), len(results))
-	uploaded, err := c.services.Images.Upload(ctx, meta, target.Host, target.UsageScope, missing)
-	results = append(results, uploaded...)
-	if err != nil {
-		return results, fmt.Errorf("core: %w", err)
-	}
-	return results, nil
-}
-
-func uploadFailureMessage(err error) string {
-	if err == nil {
-		return ""
-	}
-	if unwrapped := errors.Unwrap(err); unwrapped != nil {
-		return unwrapped.Error()
-	}
-	return err.Error()
-}
-
-func uploadedImagesByPathForTarget(images []api.UploadedImageLink, target trackers.ImageUploadTarget) map[string]api.UploadedImageLink {
-	matches := make(map[string]api.UploadedImageLink, len(images))
-	for _, image := range images {
-		if !strings.EqualFold(strings.TrimSpace(image.Host), target.Host) {
-			continue
-		}
-		if !strings.EqualFold(normalizeImageUploadUsageScope(image.UsageScope), normalizeImageUploadUsageScope(target.UsageScope)) {
-			continue
-		}
-		key := normalizedUploadImagePath(image.ImagePath)
-		if key == "" {
-			continue
-		}
-		matches[key] = image
-	}
-	return matches
-}
-
-func normalizedUploadImagePath(pathValue string) string {
-	trimmed := strings.TrimSpace(pathValue)
-	if trimmed == "" {
-		return ""
-	}
-	absPath, err := filepath.Abs(trimmed)
-	if err != nil {
-		return filepath.Clean(trimmed)
-	}
-	return filepath.Clean(absPath)
-}
-
-func normalizeImageUploadUsageScope(scope string) string {
-	trimmed := strings.TrimSpace(scope)
-	if trimmed == "" || strings.EqualFold(trimmed, "global") {
-		return "global"
-	}
-	if strings.HasPrefix(strings.ToLower(trimmed), "tracker:") {
-		tracker := strings.ToUpper(strings.TrimSpace(trimmed[len("tracker:"):]))
-		if tracker == "" {
-			return "global"
-		}
-		return "tracker:" + tracker
-	}
-	return trimmed
-}
-
-// imageHostOwnerLogValue identifies tracker-owned hosts in core upload logs.
-func imageHostOwnerLogValue(host string) string {
-	if tracker := trackers.TrackerForOwnedImageHost(host); tracker != "" {
-		return tracker
-	}
-	return "shared"
-}
-
-func (c *Core) DeleteUploadedImage(ctx context.Context, req api.Request, imagePath string, host string) error {
-	if len(req.Paths) == 0 {
-		return internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return errors.New("core: repository not configured")
-	}
-	if strings.TrimSpace(imagePath) == "" {
-		return internalerrors.ErrInvalidInput
-	}
-	if strings.TrimSpace(host) == "" {
-		return internalerrors.ErrInvalidInput
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return internalerrors.ErrInvalidInput
-	}
-
-	c.logger.Debugf("core: deleting uploaded image path=%s host=%s tracker=%s", imagePath, host, imageHostOwnerLogValue(host))
-	return wrapCoreError(c.repo.DeleteUploadedImage(ctx, uniquePaths[0], imagePath, host))
-}
-
-// FetchMetadataPreview prepares and enriches metadata for one validated source path,
-// emits metadata progress, and stores the refreshed prepared metadata cache entry.
-// An empty tracker request is not an explicit "no trackers" request; downstream
-// tracker resolution can still use configured defaults.
-func (c *Core) FetchMetadataPreview(ctx context.Context, req api.Request) (preview api.MetadataPreview, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: metadata preview blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	req = normalizeExecutionRequest(req)
-	if len(req.Paths) == 0 {
-		return api.MetadataPreview{}, internalerrors.ErrInvalidInput
-	}
-	c.logger.Debugf("core: metadata preview request with %d paths", len(req.Paths))
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.MetadataPreview{}, internalerrors.ErrInvalidInput
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.MetadataPreview{}, err
-	}
-
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-	singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-
-	if err := c.resetContentForExternalOverrides(ctx, uniquePaths[0], singleReq.ExternalIDOverrides); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	progressPath := uniquePaths[0]
-
-	emitProgress := func(phase string, status string, message string) {
-		api.EmitMetadataProgress(ctx, api.MetadataProgressUpdate{
-			Path:    progressPath,
-			Phase:   phase,
-			Status:  status,
-			Message: message,
-			Level:   "info",
-		})
-	}
-
-	emitPhase := func(phase string, message string, run func() error) error {
-		emitProgress(phase, "running", message)
-		if err := run(); err != nil {
-			emitProgress(phase, "failed", err.Error())
-			return err
-		}
-		emitProgress(phase, "completed", message)
-		return nil
-	}
-
-	var meta api.PreparedMetadata
-	if err := emitPhase("prepare", "Preparing metadata", func() error {
-		var prepareErr error
-		meta, prepareErr = c.services.Metadata.Prepare(ctx, singleReq)
-		if prepareErr == nil {
-			progressPath = meta.SourcePath
-		}
-		return wrapCoreError(prepareErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	c.logger.Debugf("core: metadata prepared for %s", meta.SourcePath)
-
-	storedApplied, err := c.applyStoredTrackerData(ctx, &meta)
-	if err != nil {
-		return api.MetadataPreview{}, err
-	}
-	runPathedSearch := func(applyTrackerData bool) error {
-		if meta.Options.SkipAutoTorrent {
-			c.logger.Debugf("core: skip_auto_torrent enabled, skipping pathed search for %s", meta.SourcePath)
-			return nil
-		}
-
-		c.logger.Debugf("core: running pathed search for %s", meta.SourcePath)
-		searchResult, searchErr := c.services.Clients.SearchPathedTorrents(ctx, meta)
-		if searchErr != nil {
-			return fmt.Errorf("core: %w", searchErr)
-		}
-		if applyTrackerData {
-			resetPreparedClientData(&meta, singleReq)
-		}
-		meta.FoundTrackerMatch = meta.FoundTrackerMatch || searchResult.FoundTrackerMatch
-		meta.MatchedTrackers = mergeTrackerRemovals(meta.MatchedTrackers, searchResult.MatchedTrackers)
-		meta.TrackersRemove = mergeTrackerRemovals(meta.TrackersRemove, searchResult.MatchedTrackers)
-		markTrackerDataMatches(&meta, searchResult.MatchedTrackers)
-		if !applyTrackerData {
-			c.logger.Debugf("core: pathed search merged tracker presence only for %s", meta.SourcePath)
-			return nil
-		}
-		if applyPathedTorrentData(&meta, searchResult) {
-			c.logger.Debugf("core: pathed torrents resolved for %s", meta.SourcePath)
-		} else {
-			c.logger.Debugf("core: pathed search returned no matches for %s", meta.SourcePath)
-		}
-		return nil
-	}
-
-	switch {
-	case meta.SourceLookupActive:
-		c.logger.Debugf("core: running pathed search for tracker presence with source url override active for %s", meta.SourcePath)
-		if err := runPathedSearch(false); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	case storedApplied:
-		c.logger.Debugf("core: running pathed search with stored tracker data present for %s", meta.SourcePath)
-		if err := runPathedSearch(true); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	case meta.StoredDataFresh:
-		if meta.InfoHash == "" && meta.StoredInfoHash != "" {
-			meta.InfoHash = meta.StoredInfoHash
-			c.logger.Debugf("core: using stored infohash before pathed search for %s", meta.SourcePath)
-		} else {
-			c.logger.Debugf("core: running pathed search with fresh stored metadata snapshot for %s", meta.SourcePath)
-		}
-		if err := runPathedSearch(true); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	case meta.InfoHash != "":
-		c.logger.Debugf("core: running pathed search for tracker presence with existing infohash for %s", meta.SourcePath)
-		if err := runPathedSearch(false); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	case len(meta.TrackerIDs) > 0:
-		c.logger.Debugf("core: running pathed search for tracker presence with existing tracker IDs for %s", meta.SourcePath)
-		if err := runPathedSearch(false); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	default:
-		if err := runPathedSearch(true); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	}
-
-	if err := emitPhase("tracker-data", "Enriching tracker data", func() error {
-		var enrichErr error
-		meta, enrichErr = c.services.Metadata.EnrichTrackerData(ctx, meta)
-		return wrapCoreError(enrichErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if meta.SourceLookupActive && strings.EqualFold(meta.SourceLookupMode, "tracker") && !sourceLookupTrackerHasUsableData(meta) {
-		meta.LookupWarnings = append(meta.LookupWarnings, "Source URL lookup returned no tracker data; fell back to default metadata lookup flow.")
-		meta.SourceLookupActive = false
-		meta.SourceLookupMode = ""
-		meta.SourceLookupTracker = ""
-		meta.SourceLookupTrackerID = ""
-		meta.Trackers = append([]string{}, singleReq.Trackers...)
-		meta.TrackerIDs = nil
-		meta.MatchedTrackers = nil
-		meta.TrackerData = nil
-		if err := runPathedSearch(true); err != nil {
-			return api.MetadataPreview{}, err
-		}
-		if err := emitPhase("tracker-data-fallback", "Retrying tracker data lookup", func() error {
-			var enrichErr error
-			meta, enrichErr = c.services.Metadata.EnrichTrackerData(ctx, meta)
-			return wrapCoreError(enrichErr)
-		}); err != nil {
-			return api.MetadataPreview{}, err
-		}
-	}
-	if err := emitPhase("mediainfo-ids", "Applying MediaInfo IDs", func() error {
-		var applyErr error
-		meta, applyErr = c.services.Metadata.ApplyMediaInfoIDs(ctx, meta)
-		return wrapCoreError(applyErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if err := emitPhase("arr", "Applying Sonarr/Radarr data", func() error {
-		var applyErr error
-		meta, applyErr = c.services.Metadata.ApplyArrData(ctx, meta)
-		return wrapCoreError(applyErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if err := emitPhase("external-ids", "Resolving external IDs", func() error {
-		var resolveErr error
-		meta, resolveErr = c.services.Metadata.ResolveExternalIDs(ctx, meta)
-		return wrapCoreError(resolveErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if err := emitPhase("media-details", "Applying media details", func() error {
-		var applyErr error
-		meta, applyErr = c.services.Metadata.ApplyMediaDetails(ctx, meta)
-		return wrapCoreError(applyErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if err := emitPhase("tracker-claims", "Checking tracker claims", func() error {
-		var applyErr error
-		meta, applyErr = c.services.Metadata.ApplyTrackerClaims(ctx, meta)
-		return wrapCoreError(applyErr)
-	}); err != nil {
-		return api.MetadataPreview{}, err
-	}
-
-	c.storeRefreshedDupeCache(meta.SourcePath, overrideSignature(meta.ExternalIDOverrides, meta.ReleaseNameOverrides, meta.MetadataOverrides, meta.TrackerConfigOverrides, meta.TrackerSiteOverrides, meta.ClientOverrides, meta.TorrentOverrides, meta.ImageHostOverrides, meta.ScreenshotOverrides), meta)
-
-	emitProgress("complete", "completed", "Metadata preview ready")
-
-	return buildMetadataPreview(meta, c.cfg), nil
-}
-
-// FetchPreparationPreview builds the tracker preparation preview for one validated
-// source path. Explicit tracker selections limit preparation to those trackers;
-// selections that resolve empty return an empty preview.
-func (c *Core) FetchPreparationPreview(ctx context.Context, req api.Request) (preview api.PreparationPreview, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: preparation preview blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.PreparationPreview{}, err
-	}
-	req = resolvedReq
-
-	if len(req.Paths) == 0 {
-		return api.PreparationPreview{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.PreparationPreview{}, errors.New("core: filesystem service not configured")
-	}
-	if c.services.Trackers == nil {
-		return api.PreparationPreview{}, errors.New("core: tracker service not configured")
-	}
-	c.logger.Debugf("core: preparation preview request with %d paths", len(req.Paths))
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.PreparationPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.PreparationPreview{}, internalerrors.ErrInvalidInput
-	}
-
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.PreparationPreview{}, err
-		} else if ok {
-			resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, requestPreparedMetaTrackersRemove(cached, req), c.logger, false, false)
-			if explicitEmpty {
-				c.logger.Debugf("core: preparation explicit trackers resolved empty source=%s", cached.SourcePath)
-				return api.PreparationPreview{SourcePath: cached.SourcePath}, nil
-			}
-			c.logger.Debugf("core: preparation resolved trackers %v", resolvedTrackers)
-			return wrapCoreResult(c.services.Trackers.BuildPreparation(ctx, cached, resolvedTrackers))
-		}
-		// No cache available; fall through to Prepare (e.g., after playlist selection)
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.PreparationPreview{}, err
-	}
-
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-	singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return api.PreparationPreview{}, fmt.Errorf("core: %w", err)
-	}
-	meta = applyRequestToPreparedMeta(meta, singleReq, c.cfg, c.logger)
-
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, meta.TrackersRemove, c.logger, false, false)
-	if explicitEmpty {
-		c.logger.Debugf("core: preparation explicit trackers resolved empty after prepare source=%s", meta.SourcePath)
-		return api.PreparationPreview{SourcePath: meta.SourcePath}, nil
-	}
-	if req.Mode == api.ModeGUI {
-		c.storeDupeCache(meta.SourcePath, overrideSignature(meta.ExternalIDOverrides, meta.ReleaseNameOverrides, meta.MetadataOverrides, meta.TrackerConfigOverrides, meta.TrackerSiteOverrides, meta.ClientOverrides, meta.TorrentOverrides, meta.ImageHostOverrides, meta.ScreenshotOverrides), meta)
-	}
-	c.logger.Debugf("core: preparation resolved trackers %v", resolvedTrackers)
-	return wrapCoreResult(c.services.Trackers.BuildPreparation(ctx, meta, resolvedTrackers))
-}
-
-// FetchTrackerDryRunPreview builds per-tracker dry-run upload entries from cached
-// prepared metadata, creating torrents and cache state only after selected trackers
-// resolve. Dry-run/debug processing still evaluates tracker prerequisites such
-// as banned-group matches, rule failures, and block state, but reports them
-// without suppressing payload generation or performing the tracker upload.
-func (c *Core) FetchTrackerDryRunPreview(ctx context.Context, req api.Request) (preview api.TrackerDryRunPreview, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: tracker dry-run blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	req = normalizeExecutionRequest(req)
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	req = resolvedReq
-
-	if len(req.Paths) == 0 {
-		return api.TrackerDryRunPreview{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.TrackerDryRunPreview{}, errors.New("core: filesystem service not configured")
-	}
-	if c.services.Metadata == nil {
-		return api.TrackerDryRunPreview{}, errors.New("core: metadata service not configured")
-	}
-	if c.services.Torrents == nil {
-		return api.TrackerDryRunPreview{}, errors.New("core: torrent service not configured")
-	}
-	if c.services.Trackers == nil {
-		return api.TrackerDryRunPreview{}, errors.New("core: tracker service not configured")
-	}
-
-	c.logger.Debugf("core: tracker dry-run preview request with %d paths", len(req.Paths))
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.TrackerDryRunPreview{}, internalerrors.ErrInvalidInput
-	}
-
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	options.DryRun = true
-	c.logger.Debugf("core: tracker dry-run options resolved path=%s debug=%t dry_run=%t no_seed=%t run_log_level=%s", uniquePaths[0], options.Debug, options.DryRun, options.NoSeed, options.RunLogLevel)
-
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-	singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-
-	signature := overrideSignature(singleReq.ExternalIDOverrides, singleReq.ReleaseNameOverrides, singleReq.MetadataOverrides, singleReq.TrackerConfigOverrides, singleReq.TrackerSiteOverrides, singleReq.ClientOverrides, singleReq.TorrentOverrides, singleReq.ImageHostOverrides, singleReq.ScreenshotOverrides)
-	meta, ok := c.getDupeCache(uniquePaths[0], signature)
-	if req.Mode == api.ModeGUI {
-		entry, _, found := c.lookupGUICachedMetaEntry(singleReq, uniquePaths[0])
-		if found {
-			ok = true
-			if _, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, requestPreparedMetaTrackersRemove(entry.meta, singleReq), c.logger, false, false); explicitEmpty {
-				c.logger.Debugf("core: tracker dry-run explicit trackers resolved empty source=%s", entry.meta.SourcePath)
-				return api.TrackerDryRunPreview{SourcePath: entry.meta.SourcePath, Trackers: []api.TrackerDryRunEntry{}}, nil
-			}
-			if entry.requestRefreshed && cachedPreparedMetaMatchesRequest(entry.meta, singleReq, uniquePaths[0]) {
-				meta = deepCopyPreparedMetadata(entry.meta)
-			} else {
-				meta, err = c.applyRequestToCachedPreparedMeta(ctx, entry.meta, singleReq)
-				if err != nil {
-					return api.TrackerDryRunPreview{}, err
-				}
-			}
-		}
-	} else {
-		if !ok {
-			return api.TrackerDryRunPreview{}, fmt.Errorf("core: tracker dry-run requires prepared metadata for %s", uniquePaths[0])
-		}
-		if _, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, requestPreparedMetaTrackersRemove(meta, singleReq), c.logger, false, false); explicitEmpty {
-			c.logger.Debugf("core: tracker dry-run explicit trackers resolved empty source=%s", meta.SourcePath)
-			return api.TrackerDryRunPreview{SourcePath: meta.SourcePath, Trackers: []api.TrackerDryRunEntry{}}, nil
-		}
-		meta, err = c.applyRequestToCachedPreparedMeta(ctx, meta, singleReq)
-		if err != nil {
-			return api.TrackerDryRunPreview{}, err
-		}
-	}
-	if !ok {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("core: tracker dry-run requires prepared metadata for %s", uniquePaths[0])
-	}
-	c.logger.Debugf("core: tracker dry-run using cached prepared metadata for %s meta_no_seed=%t req_no_seed=%t", uniquePaths[0], meta.Options.NoSeed, singleReq.Options.NoSeed)
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, trackerResolutionRemoveForRequest(meta, singleReq), c.logger, false, false)
-	if explicitEmpty {
-		c.logger.Debugf("core: tracker dry-run explicit trackers resolved empty source=%s", meta.SourcePath)
-		return api.TrackerDryRunPreview{SourcePath: meta.SourcePath, Trackers: []api.TrackerDryRunEntry{}}, nil
-	}
-	descriptionGroups, err := c.resolveCanonicalDescriptionGroups(ctx, meta, singleReq)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	meta.DescriptionGroups = descriptionGroups
-
-	torrent, err := c.services.Torrents.Create(ctx, meta)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("core: %w", err)
-	}
-	meta.TorrentPath = torrent.Path
-
-	dryRunMeta := trackerDryRunProcessingMeta(meta, singleReq)
-	entries, err := c.services.Trackers.BuildUploadDryRun(ctx, dryRunMeta, resolvedTrackers)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("core: %w", err)
-	}
-	annotateDryRunReleaseNames(dryRunMeta, entries)
-
-	c.logger.Debugf("core: tracker dry-run torrent ready for %s path=%s no_seed=%t", meta.SourcePath, torrent.Path, meta.Options.NoSeed)
-	if meta.Options.NoSeed {
-		c.logger.Debugf("core: tracker dry-run skipping client injection for %s: no-seed enabled", meta.SourcePath)
-	} else if err := c.injectTrackerDryRunTorrents(ctx, singleReq, dryRunMeta, entries, torrent); err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-
-	c.storeDupeCache(meta.SourcePath, overrideSignature(meta.ExternalIDOverrides, meta.ReleaseNameOverrides, meta.MetadataOverrides, meta.TrackerConfigOverrides, meta.TrackerSiteOverrides, meta.ClientOverrides, meta.TorrentOverrides, meta.ImageHostOverrides, meta.ScreenshotOverrides), meta)
-
-	return api.TrackerDryRunPreview{SourcePath: meta.SourcePath, Trackers: sanitizeTrackerDryRunEntries(entries)}, nil
-}
-
-func sanitizeTrackerDryRunEntries(entries []api.TrackerDryRunEntry) []api.TrackerDryRunEntry {
-	sanitized := make([]api.TrackerDryRunEntry, len(entries))
-	for index, entry := range entries {
-		entry.Message = logging.SanitizeMessage(entry.Message)
-		entry.BannedReason = logging.SanitizeMessage(entry.BannedReason)
-		entry.BannedCheckError = logging.SanitizeMessage(entry.BannedCheckError)
-		entry.Endpoint = logging.SanitizeMessage(entry.Endpoint)
-		entry.Payload = redactDryRunPayload(entry.Payload)
-		entry.Files = sanitizeTrackerDryRunFiles(entry.Files)
-		entry.DebugSections = sanitizeTrackerDryRunDebugSections(entry.DebugSections)
-		entry.ImageHost = sanitizeDryRunImageHostFeedback(entry.ImageHost)
-		sanitized[index] = entry
-	}
-	return sanitized
-}
-
-func redactDryRunPayload(payload map[string]string) map[string]string {
-	if payload == nil {
-		return nil
-	}
-	redacted := make(map[string]string, len(payload))
-	for key, value := range payload {
-		wrapped := map[string]any{key: value}
-		result, ok := redaction.RedactPrivateInfo(wrapped, nil).(map[string]any)
-		if !ok {
-			redacted[key] = "[REDACTED]"
-			continue
-		}
-		redactedValue, ok := result[key].(string)
-		if !ok {
-			redacted[key] = "[REDACTED]"
-			continue
-		}
-		redacted[key] = logging.SanitizeMessage(redactedValue)
-	}
-	return redacted
-}
-
-func sanitizeTrackerDryRunFiles(files []api.TrackerDryRunFile) []api.TrackerDryRunFile {
-	sanitized := slices.Clone(files)
-	for index := range sanitized {
-		sanitized[index].Path = logging.SanitizeMessage(sanitized[index].Path)
-	}
-	return sanitized
-}
-
-func sanitizeTrackerDryRunDebugSections(sections []api.TrackerDryRunDebugSection) []api.TrackerDryRunDebugSection {
-	sanitized := make([]api.TrackerDryRunDebugSection, len(sections))
-	for index, section := range sections {
-		section.Endpoint = logging.SanitizeMessage(section.Endpoint)
-		section.Payload = redactDryRunPayload(section.Payload)
-		section.Files = sanitizeTrackerDryRunFiles(section.Files)
-		sanitized[index] = section
-	}
-	return sanitized
-}
-
-func sanitizeDryRunImageHostFeedback(feedback api.ImageHostFeedback) api.ImageHostFeedback {
-	feedback.Message = logging.SanitizeMessage(feedback.Message)
-	feedback.Warnings = slices.Clone(feedback.Warnings)
-	for index := range feedback.Warnings {
-		feedback.Warnings[index].Message = logging.SanitizeMessage(feedback.Warnings[index].Message)
-	}
-	return feedback
-}
-
-// injectTrackerDryRunTorrents injects only ready dry-run tracker torrents into
-// configured clients so debug runs can exercise client handling without upload.
-func (c *Core) injectTrackerDryRunTorrents(ctx context.Context, req api.Request, meta api.PreparedMetadata, entries []api.TrackerDryRunEntry, fallback api.TorrentResult) error {
-	ready := make([]api.TrackerDryRunEntry, 0, len(entries))
-	for _, entry := range entries {
-		if strings.EqualFold(strings.TrimSpace(entry.Status), "ready") {
-			ready = append(ready, entry)
-		} else {
-			c.logger.Debugf("core: tracker dry-run skipping client injection for tracker=%s status=%s", strings.TrimSpace(entry.Tracker), strings.TrimSpace(entry.Status))
-		}
-	}
-	if len(ready) == 0 {
-		c.logger.Warnf("core: tracker dry-run found no ready tracker payloads for client injection for %s", meta.SourcePath)
-		return nil
-	}
-	c.logger.Debugf("core: tracker dry-run injecting %d ready tracker torrent(s) for %s", len(ready), meta.SourcePath)
-
-	for _, entry := range ready {
-		trackerName := strings.ToUpper(strings.TrimSpace(entry.Tracker))
-		torrentPath := trackerDryRunTorrentPath(entry)
-		injectMeta, err := c.prepareDryRunInjectionMeta(meta, trackerName, torrentPath)
-		if err != nil {
-			return err
-		}
-		injectTorrent := api.TorrentResult{Path: strings.TrimSpace(injectMeta.TorrentPath), InfoHash: fallback.InfoHash, Tracker: trackerName}
-		if injectTorrent.Path == "" {
-			injectTorrent.Path = strings.TrimSpace(fallback.Path)
-		}
-		if injectTorrent.Path == "" {
-			c.logger.Debugf("core: tracker dry-run skipping client injection for tracker=%s: no torrent file", trackerName)
-			continue
-		}
-		if injectTorrent.Path == strings.TrimSpace(fallback.Path) {
-			c.logger.Debugf("core: tracker dry-run injecting fallback torrent for tracker=%s path=%s", trackerName, injectTorrent.Path)
-		} else {
-			c.logger.Debugf("core: tracker dry-run injecting tracker torrent for tracker=%s path=%s", trackerName, injectTorrent.Path)
-		}
-		if err := c.injectPreparedTorrent(ctx, req, injectMeta, injectTorrent); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// prepareDryRunInjectionMeta returns metadata pointing at the tracker-specific
-// dry-run torrent artifact when one exists, preserving the base torrent as a
-// fallback for client injection.
-func (c *Core) prepareDryRunInjectionMeta(meta api.PreparedMetadata, trackerName string, torrentPath string) (api.PreparedMetadata, error) {
-	injectMeta := meta
-	if trimmed := strings.TrimSpace(torrentPath); trimmed != "" {
-		injectMeta.TorrentPath = trimmed
-	}
-	trackerCfg := config.TrackerConfig{}
-	for name, cfg := range c.cfg.Trackers.Trackers {
-		if strings.EqualFold(strings.TrimSpace(name), trackerName) {
-			trackerCfg = cfg
-			break
-		}
-	}
-	prepared, err := trackers.PrepareDryRunInjectionTorrent(injectMeta, c.cfg.MainSettings.DBPath, trackerName, trackerCfg)
-	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("core: tracker dry-run injection torrent artifact tracker=%s: %w", trackerName, err)
-	}
-	return prepared, nil
-}
-
-// trackerDryRunTorrentPath returns the present torrent file path advertised by
-// a dry-run payload, ignoring other upload file fields.
-func trackerDryRunTorrentPath(entry api.TrackerDryRunEntry) string {
-	for _, file := range entry.Files {
-		if strings.EqualFold(strings.TrimSpace(file.Field), "torrent") && file.Present {
-			return strings.TrimSpace(file.Path)
-		}
-	}
-	return ""
-}
-
-// annotateDryRunReleaseNames records whether each tracker-specific dry-run
-// upload name differs from the prepared release name.
-func annotateDryRunReleaseNames(meta api.PreparedMetadata, entries []api.TrackerDryRunEntry) {
-	original := strings.TrimSpace(meta.ReleaseName)
-	if original == "" {
-		original = strings.TrimSpace(meta.ReleaseNameNoTag)
-	}
-	if original == "" {
-		original = strings.TrimSpace(meta.Filename)
-	}
-	for idx := range entries {
-		uploadName := strings.TrimSpace(entries[idx].ReleaseName)
-		if uploadName == "" {
-			uploadName = original
-		}
-		entries[idx].OriginalReleaseName = original
-		entries[idx].UploadReleaseName = uploadName
-		entries[idx].ReleaseNameChanged = original != "" && uploadName != "" && uploadName != original
-		if entries[idx].ReleaseNameChanged && strings.TrimSpace(entries[idx].ReleaseNameChangeReason) == "" {
-			entries[idx].ReleaseNameChangeReason = "tracker naming rules"
-		}
-	}
-}
-
-// FetchDescriptionBuilderPreview builds editable description groups from cached
-// or freshly prepared metadata. When request trackers are provided, only that
-// selected set contributes groups; selections that resolve empty return an empty
-// preview instead of falling back to configured defaults.
-func (c *Core) FetchDescriptionBuilderPreview(ctx context.Context, req api.Request) (api.DescriptionBuilderPreview, error) {
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.DescriptionBuilderPreview{}, err
-	}
-	req = resolvedReq
-
-	if len(req.Paths) == 0 {
-		return api.DescriptionBuilderPreview{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.DescriptionBuilderPreview{}, errors.New("core: filesystem service not configured")
-	}
-	if c.services.Trackers == nil {
-		return api.DescriptionBuilderPreview{}, errors.New("core: tracker service not configured")
-	}
-	if c.repo == nil {
-		return api.DescriptionBuilderPreview{}, errors.New("core: repository not configured")
-	}
-	if req.Mode != api.ModeGUI && c.services.Metadata == nil {
-		return api.DescriptionBuilderPreview{}, errors.New("core: metadata service not configured")
-	}
-	c.logger.Debugf("core: description builder request with %d paths", len(req.Paths))
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.DescriptionBuilderPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.DescriptionBuilderPreview{}, internalerrors.ErrInvalidInput
-	}
-
-	storedOverrides, err := c.repo.ListDescriptionOverridesByPath(ctx, uniquePaths[0])
-	if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.DescriptionBuilderPreview{}, fmt.Errorf("core: description override: %w", err)
-	}
-	overrideByGroup := make(map[string]api.DescriptionOverride, len(storedOverrides))
-	for _, override := range storedOverrides {
-		overrideByGroup[normalizeDescriptionBuilderGroupKey(override.GroupKey, nil)] = override
-	}
-
-	var meta api.PreparedMetadata
-	storePreparedCache := false
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.DescriptionBuilderPreview{}, err
-		} else if ok {
-			c.logger.Debugf("core: description builder cache hit source=%s", uniquePaths[0])
-			meta = applyRequestToPreparedMetaWithDerivedFields(cached, req, c.cfg, c.logger, false)
-		}
-	}
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		if c.services.Metadata == nil {
-			c.logger.Warnf("core: description builder missing metadata service for source=%s", uniquePaths[0])
-			if len(overrideByGroup) > 0 {
-				groupKeys := make([]string, 0, len(overrideByGroup))
-				for groupKey := range overrideByGroup {
-					groupKeys = append(groupKeys, groupKey)
-				}
-				sort.Strings(groupKeys)
-				preview := api.DescriptionBuilderPreview{
-					SourcePath: uniquePaths[0],
-					Groups:     make([]api.DescriptionBuilderGroup, 0, len(groupKeys)),
-				}
-				for _, groupKey := range groupKeys {
-					override := overrideByGroup[groupKey]
-					preview.Groups = append(preview.Groups, api.DescriptionBuilderGroup{
-						GroupKey:           groupKey,
-						Trackers:           nil,
-						RawDescription:     override.Description,
-						RawDescriptionHTML: description.Render(override.Description),
-						HasOverride:        true,
-					})
-				}
-				return preview, nil
-			}
-			return api.DescriptionBuilderPreview{}, errors.New("core: metadata service not configured")
-		}
-		c.logger.Debugf("core: description builder preparing metadata source=%s", uniquePaths[0])
-		options, err := c.applyDefaultOptions(req.Options)
-		if err != nil {
-			return api.DescriptionBuilderPreview{}, err
-		}
-		singleReq := req
-		singleReq.Paths = []string{uniquePaths[0]}
-		singleReq.Options = options
-		singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-		meta, err = c.services.Metadata.Prepare(ctx, singleReq)
-		if err != nil {
-			return api.DescriptionBuilderPreview{}, fmt.Errorf("core: %w", err)
-		}
-		meta = applyRequestToPreparedMeta(meta, singleReq, c.cfg, c.logger)
-		storePreparedCache = req.Mode == api.ModeGUI
-	}
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, meta.TrackersRemove, c.logger, false, false)
-	if explicitEmpty {
-		c.logger.Debugf("core: description builder explicit trackers resolved empty source=%s", meta.SourcePath)
-		return api.DescriptionBuilderPreview{SourcePath: meta.SourcePath}, nil
-	}
-	needsDescriptionMetadata := c.services.Metadata != nil && descriptionBuilderNeedsExternalMetadata(c.cfg, meta, resolvedTrackers)
-	meta, err = c.ensureDescriptionBuilderMetadata(ctx, req, uniquePaths[0], meta, resolvedTrackers)
-	if err != nil {
-		return api.DescriptionBuilderPreview{}, err
-	}
-	if storePreparedCache && !needsDescriptionMetadata {
-		c.storeDescriptionBuilderPreparedCache(req, uniquePaths[0], meta)
-	}
-
-	prep, err := c.services.Trackers.BuildPreparation(ctx, meta, resolvedTrackers)
-	if err != nil {
-		c.logger.Errorf("core: description builder preparation failed source=%s: %v", meta.SourcePath, err)
-		return api.DescriptionBuilderPreview{}, fmt.Errorf("core: %w", err)
-	}
-
-	preview := api.DescriptionBuilderPreview{SourcePath: meta.SourcePath}
-	if len(prep.Descriptions) > 0 {
-		preview.Groups = make([]api.DescriptionBuilderGroup, 0, len(prep.Descriptions))
-		for _, entry := range prep.Descriptions {
-			preview.Groups = append(preview.Groups, buildDescriptionBuilderGroup(entry, overrideByGroup, meta, c.logger))
-		}
-	}
-	c.logger.Infof("core: description builder prepared source=%s groups=%d", preview.SourcePath, len(preview.Groups))
-	return preview, nil
-}
-
-func buildDescriptionBuilderGroup(entry api.PreparationDescription, overrideByGroup map[string]api.DescriptionOverride, _ api.PreparedMetadata, _ api.Logger) api.DescriptionBuilderGroup {
-	groupKey := normalizeDescriptionBuilderGroupKey(entry.GroupKey, entry.Trackers)
-	descriptionText := strings.TrimSpace(entry.Description)
-	if descriptionText == "" {
-		descriptionText = strings.TrimSpace(entry.RawDescription)
-	}
-	descriptionHTML := entry.DescriptionHTML
-	if strings.TrimSpace(descriptionHTML) == "" {
-		descriptionHTML = description.Render(descriptionText)
-	}
-	rawDescription := descriptionText
-	rawDescriptionHTML := descriptionHTML
-	if strings.TrimSpace(rawDescription) == "" {
-		rawDescription = strings.TrimSpace(entry.RawDescription)
-		if strings.TrimSpace(rawDescription) != "" {
-			rawDescriptionHTML = entry.RawDescriptionHTML
-		} else {
-			rawDescriptionHTML = ""
-		}
-	}
-	hasOverride := entry.HasOverride
-	if strings.TrimSpace(rawDescription) == "" {
-		if override, ok := overrideByGroup[groupKey]; ok && strings.TrimSpace(override.Description) != "" {
-			rawDescription = strings.TrimSpace(override.Description)
-			rawDescriptionHTML = description.Render(rawDescription)
-		}
-	}
-	if _, ok := overrideByGroup[groupKey]; ok && strings.TrimSpace(rawDescription) != "" {
-		hasOverride = true
-	}
-	if strings.TrimSpace(rawDescriptionHTML) == "" {
-		rawDescriptionHTML = description.Render(rawDescription)
-	}
-	return api.DescriptionBuilderGroup{
-		GroupKey:           groupKey,
-		Trackers:           append([]string{}, entry.Trackers...),
-		Description:        rawDescription,
-		DescriptionHTML:    rawDescriptionHTML,
-		RawDescription:     rawDescription,
-		RawDescriptionHTML: rawDescriptionHTML,
-		HasOverride:        hasOverride,
-		ImageHost:          entry.ImageHost,
-	}
-}
-
-// ensureDescriptionBuilderMetadata refreshes missing external metadata before
-// tracker description preparation, using the resolved tracker set for localized
-// pt-BR refreshes while preserving the original tracker list on returned
-// metadata. Cacheable GUI refreshes are stored as request-refreshed entries.
-func (c *Core) ensureDescriptionBuilderMetadata(ctx context.Context, req api.Request, path string, meta api.PreparedMetadata, resolvedTrackers []string) (api.PreparedMetadata, error) {
-	if c.services.Metadata == nil || !descriptionBuilderNeedsExternalMetadata(c.cfg, meta, resolvedTrackers) {
-		return meta, nil
-	}
-	resolveMeta := meta
-	restoreTrackers := false
-	if descriptionBuilderTrackersNeedPTBR(resolvedTrackers) && !descriptionBuilderTrackersNeedPTBR(resolveMeta.Trackers) {
-		resolveMeta.Trackers = append([]string{}, resolvedTrackers...)
-		restoreTrackers = true
-	}
-	resolved, err := c.services.Metadata.ResolveExternalIDs(ctx, resolveMeta)
-	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("core: %w", err)
-	}
-	if restoreTrackers {
-		resolved.Trackers = append([]string{}, meta.Trackers...)
-	}
-	if req.Mode == api.ModeGUI && cacheableGUIPreparedMetaRequest(req) {
-		overrides := mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-		signature := overrideSignature(overrides, req.ReleaseNameOverrides, req.MetadataOverrides, req.TrackerConfigOverrides, req.TrackerSiteOverrides, req.ClientOverrides, req.TorrentOverrides, req.ImageHostOverrides, req.ScreenshotOverrides)
-		c.storeRefreshedDupeCache(path, signature, resolved)
-	}
-	return resolved, nil
-}
-
-// storeDescriptionBuilderPreparedCache stores cacheable GUI description-builder
-// metadata that did not require an external metadata refresh.
-func (c *Core) storeDescriptionBuilderPreparedCache(req api.Request, path string, meta api.PreparedMetadata) {
-	if req.Mode != api.ModeGUI || !cacheableGUIPreparedMetaRequest(req) {
-		return
-	}
-	overrides := mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-	signature := overrideSignature(overrides, req.ReleaseNameOverrides, req.MetadataOverrides, req.TrackerConfigOverrides, req.TrackerSiteOverrides, req.ClientOverrides, req.TorrentOverrides, req.ImageHostOverrides, req.ScreenshotOverrides)
-	c.storeDupeCache(path, signature, meta)
-}
-
-// descriptionBuilderNeedsExternalMetadata reports whether tracker description
-// preparation needs metadata not present on the current prepared metadata.
-func descriptionBuilderNeedsExternalMetadata(cfg config.Config, meta api.PreparedMetadata, resolvedTrackers []string) bool {
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		return false
-	}
-	if cfg.Description.AddLogo {
-		if meta.ExternalMetadata.TMDB == nil || strings.TrimSpace(meta.ExternalMetadata.TMDB.Logo) == "" {
-			return true
-		}
-	}
-	if descriptionBuilderNeedsPTBRMetadata(meta, resolvedTrackers) {
-		return true
-	}
-	return cfg.Description.EpisodeOverview && strings.TrimSpace(meta.EpisodeOverview) == "" && descriptionBuilderEpisodeLike(meta)
-}
-
-// descriptionBuilderNeedsPTBRMetadata reports whether localized tracker
-// descriptions need a missing pt-BR TMDB metadata entry.
-func descriptionBuilderNeedsPTBRMetadata(meta api.PreparedMetadata, resolvedTrackers []string) bool {
-	if !descriptionBuilderTrackersNeedPTBR(resolvedTrackers) && !descriptionBuilderTrackersNeedPTBR(meta.Trackers) && !descriptionBuilderTrackersNeedPTBR(meta.MatchedTrackers) {
-		return false
-	}
-	if meta.ExternalMetadata.TMDB == nil || meta.ExternalMetadata.TMDB.Localized == nil {
-		return true
-	}
-	localized, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]
-	return !ok || !localizedPTBRComplete(meta, localized)
-}
-
-// descriptionBuilderTrackersNeedPTBR reports whether any tracker consumes pt-BR localized metadata.
-func descriptionBuilderTrackersNeedPTBR(trackersList []string) bool {
-	return trackers.AnyNeedsPTBRLocalizedMetadata(trackersList)
-}
-
-// descriptionBuilderEpisodeLike reports whether description generation should
-// require episode-scoped metadata when episode overview support is enabled.
-func descriptionBuilderEpisodeLike(meta api.PreparedMetadata) bool {
-	if meta.SeasonInt > 0 || meta.EpisodeInt > 0 {
-		return true
-	}
-	if strings.TrimSpace(meta.SeasonStr) != "" || strings.TrimSpace(meta.EpisodeStr) != "" || strings.TrimSpace(meta.DailyEpisodeDate) != "" {
-		return true
-	}
-	return strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV")
-}
-
-func normalizeDescriptionBuilderGroupKey(groupKey string, trackersList []string) string {
-	normalized := strings.ToLower(strings.TrimSpace(groupKey))
-	if normalized == "" && len(trackersList) > 0 {
-		normalized = strings.ToLower(strings.TrimSpace(trackersList[0]))
-	}
-	return normalized
-}
-
-// FetchDescriptionBuilderGroupPreview rebuilds one description group from cached
-// or freshly prepared metadata. Request trackers limit the rebuild to the
-// selected set while tracker removals still suppress removed selections.
-func (c *Core) FetchDescriptionBuilderGroupPreview(ctx context.Context, req api.Request) (api.DescriptionBuilderGroup, error) {
-	targetGroup := strings.TrimSpace(req.DescriptionOverrideGroup)
-	if targetGroup == "" && len(req.Trackers) > 0 {
-		targetGroup = trackers.DescriptionOverrideGroupForTracker(req.Trackers[0])
-	}
-	targetGroup = normalizeDescriptionBuilderGroupKey(targetGroup, req.Trackers)
-	if targetGroup == "" {
-		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
-	}
-
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.DescriptionBuilderGroup{}, err
-	}
-	req = resolvedReq
-
-	if len(req.Paths) == 0 {
-		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: filesystem service not configured")
-	}
-	if c.services.Trackers == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: tracker service not configured")
-	}
-	if c.repo == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: repository not configured")
-	}
-	if req.Mode != api.ModeGUI && c.services.Metadata == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: metadata service not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, candidate := range normalizedPaths {
-		if _, exists := seenPaths[candidate]; exists {
-			continue
-		}
-		seenPaths[candidate] = struct{}{}
-		uniquePaths = append(uniquePaths, candidate)
-	}
-	if len(uniquePaths) != 1 {
-		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
-	}
-
-	storedOverrides, err := c.repo.ListDescriptionOverridesByPath(ctx, uniquePaths[0])
-	if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: description override: %w", err)
-	}
-	overrideByGroup := make(map[string]api.DescriptionOverride, len(storedOverrides))
-	for _, override := range storedOverrides {
-		overrideByGroup[normalizeDescriptionBuilderGroupKey(override.GroupKey, nil)] = override
-	}
-
-	var meta api.PreparedMetadata
-	storePreparedCache := false
-	if req.Mode == api.ModeGUI {
-		if cached, ok, err := c.resolveGUICachedPreparedMeta(ctx, req, uniquePaths[0]); err != nil {
-			return api.DescriptionBuilderGroup{}, err
-		} else if ok {
-			meta = applyRequestToPreparedMetaWithDerivedFields(cached, req, c.cfg, c.logger, false)
-		}
-	}
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		if c.services.Metadata == nil {
-			if override, ok := overrideByGroup[targetGroup]; ok && strings.TrimSpace(override.Description) != "" {
-				return api.DescriptionBuilderGroup{
-					GroupKey:           targetGroup,
-					Trackers:           append([]string{}, req.Trackers...),
-					RawDescription:     override.Description,
-					RawDescriptionHTML: description.Render(override.Description),
-					HasOverride:        true,
-				}, nil
-			}
-			return api.DescriptionBuilderGroup{}, errors.New("core: metadata service not configured")
-		}
-		options, err := c.applyDefaultOptions(req.Options)
-		if err != nil {
-			return api.DescriptionBuilderGroup{}, err
-		}
-		singleReq := req
-		singleReq.Paths = []string{uniquePaths[0]}
-		singleReq.Options = options
-		singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
-		meta, err = c.services.Metadata.Prepare(ctx, singleReq)
-		if err != nil {
-			return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
-		}
-		meta = applyRequestToPreparedMeta(meta, singleReq, c.cfg, c.logger)
-		storePreparedCache = req.Mode == api.ModeGUI
-	}
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, meta.TrackersRemove, c.logger, false, false)
-	if explicitEmpty {
-		return api.DescriptionBuilderGroup{}, nil
-	}
-	needsDescriptionMetadata := c.services.Metadata != nil && descriptionBuilderNeedsExternalMetadata(c.cfg, meta, resolvedTrackers)
-	meta, err = c.ensureDescriptionBuilderMetadata(ctx, req, uniquePaths[0], meta, resolvedTrackers)
-	if err != nil {
-		return api.DescriptionBuilderGroup{}, err
-	}
-	if storePreparedCache && !needsDescriptionMetadata {
-		c.storeDescriptionBuilderPreparedCache(req, uniquePaths[0], meta)
-	}
-
-	prep, err := c.services.Trackers.BuildPreparation(ctx, meta, resolvedTrackers)
-	if err != nil {
-		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
-	}
-	for _, entry := range prep.Descriptions {
-		normalizedGroupKey := normalizeDescriptionBuilderGroupKey(entry.GroupKey, entry.Trackers)
-		if strings.EqualFold(normalizedGroupKey, targetGroup) {
-			group := buildDescriptionBuilderGroup(entry, overrideByGroup, meta, c.logger)
-			if len(group.Trackers) == 0 && len(resolvedTrackers) > 0 {
-				group.Trackers = append([]string{}, resolvedTrackers...)
-			}
-			return group, nil
-		}
-	}
-	return api.DescriptionBuilderGroup{}, internalerrors.ErrNotFound
-}
-
-func (c *Core) SelectBlurayCandidate(ctx context.Context, sourcePath string, releaseID string) (api.MetadataPreview, error) {
-	if err := ctx.Err(); err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("core: select blu-ray candidate canceled: %w", err)
-	}
-	if c.repo == nil {
-		return api.MetadataPreview{}, errors.New("core: repository not configured")
-	}
-	trimmedPath := strings.TrimSpace(sourcePath)
-	trimmedReleaseID := strings.TrimSpace(releaseID)
-	if trimmedPath == "" || trimmedReleaseID == "" {
-		return api.MetadataPreview{}, internalerrors.ErrInvalidInput
-	}
-	external, err := c.repo.GetExternalMetadata(ctx, trimmedPath)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("core: load blu-ray metadata: %w", err)
-	}
-	if external.Bluray == nil || !external.Bluray.SelectCandidate(trimmedReleaseID, false, "manual") {
-		return api.MetadataPreview{}, internalerrors.ErrNotFound
-	}
-	c.logger.Debugf("core: bluray candidate decision=selected source=%s release_id=%s", trimmedPath, trimmedReleaseID)
-	external.UpdatedAt = time.Now().UTC()
-	external.Bluray.UpdatedAt = external.UpdatedAt
-
-	c.dupeMu.Lock()
-	cachePath := trimmedPath
-	entry, ok := c.dupeCache[cachePath]
-	if !ok {
-		cleanedPath := filepath.Clean(trimmedPath)
-		for key, candidate := range c.dupeCache {
-			if filepath.Clean(key) == cleanedPath {
-				cachePath = key
-				entry = candidate
-				ok = true
-				break
-			}
-		}
-	}
-	if ok {
-		entry.meta.ExternalMetadata.Bluray = external.Bluray
-		entry.meta.ExternalMetadata.UpdatedAt = external.UpdatedAt
-		applyBlurayCandidateToPreparedMeta(&entry.meta)
-	}
-	c.dupeMu.Unlock()
-	if !ok {
-		return api.MetadataPreview{}, internalerrors.ErrNotFound
-	}
-
-	if c.services.Metadata != nil {
-		if refreshed, refreshErr := c.services.Metadata.RefreshPreparedMetadata(ctx, entry.meta); refreshErr == nil {
-			entry.meta = refreshed
-		} else if c.logger != nil {
-			c.logger.Warnf("core: refresh metadata after blu-ray selection failed: %v", refreshErr)
-		}
-	}
-
-	if err := c.repo.SaveExternalMetadata(ctx, external); err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("core: save blu-ray selection: %w", err)
-	}
-
-	c.dupeMu.Lock()
-	entry.updatedAt = time.Now().UTC()
-	entry.requestRefreshed = true
-	c.dupeCache[cachePath] = entry
-	c.dupeMu.Unlock()
-
-	return buildMetadataPreview(entry.meta, c.cfg), nil
-}
-
-func applyBlurayCandidateToPreparedMeta(meta *api.PreparedMetadata) {
-	if meta == nil || meta.ExternalMetadata.Bluray == nil {
-		return
-	}
-	candidate := meta.ExternalMetadata.Bluray.SelectedCandidate()
-	if candidate == nil {
-		return
-	}
-	if region := strings.TrimSpace(candidate.Region); region != "" {
-		meta.Region = region
-		meta.Release.Region = region
-	}
-	if publisher := strings.TrimSpace(candidate.Publisher); publisher != "" {
-		meta.Distributor = strings.ToUpper(publisher)
-	}
-}
-
-func (c *Core) storeDupeCache(path string, signature string, meta api.PreparedMetadata) {
-	c.storeDupeCacheEntry(path, signature, meta, false, api.DupeCheckSummary{})
-}
-
-func (c *Core) storeRefreshedDupeCache(path string, signature string, meta api.PreparedMetadata) {
-	c.storeDupeCacheEntry(path, signature, meta, true, api.DupeCheckSummary{})
-}
-
-func (c *Core) storeRefreshedDupeCacheWithDupeSummary(path string, signature string, meta api.PreparedMetadata, summary api.DupeCheckSummary) {
-	c.storeDupeCacheEntry(path, signature, meta, true, summary)
-}
-
-func (c *Core) storeDupeCacheEntry(path string, signature string, meta api.PreparedMetadata, requestRefreshed bool, summary api.DupeCheckSummary) {
-	if strings.TrimSpace(path) == "" {
-		return
-	}
-	c.dupeMu.Lock()
-	defer c.dupeMu.Unlock()
-	c.dupeCache[path] = dupeCacheEntry{meta: meta, dupeSummary: deepCopyDupeCheckSummary(summary), signature: signature, updatedAt: time.Now().UTC(), requestRefreshed: requestRefreshed}
-}
-
-func (c *Core) clearDupeCache(path string) {
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return
-	}
-	c.dupeMu.Lock()
-	defer c.dupeMu.Unlock()
-	delete(c.dupeCache, trimmedPath)
-}
-
-func (c *Core) resetContentForExternalOverrides(ctx context.Context, path string, overrides api.ExternalIDOverrides) error {
-	if !hasExternalIDOverrides(overrides) || c.repo == nil {
-		return nil
-	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return nil
-	}
-	if err := c.repo.PurgeContentData(ctx, trimmedPath); err != nil {
-		return fmt.Errorf("core: purge content data for external override %s: %w", trimmedPath, err)
-	}
-	c.clearDupeCache(trimmedPath)
-	c.logger.Debugf("core: purged content data for external override path=%s", trimmedPath)
-	return nil
-}
-
-func (c *Core) applyStoredTrackerData(ctx context.Context, meta *api.PreparedMetadata) (bool, error) {
-	if c.repo == nil || meta == nil {
-		return false, nil
-	}
-	if meta.Options.SkipAutoTorrent {
-		c.logger.Debugf("core: skip_auto_torrent enabled, ignoring stored tracker metadata for %s", meta.SourcePath)
-		return false, nil
-	}
-	path := strings.TrimSpace(meta.SourcePath)
-	if path == "" {
-		return false, nil
-	}
-	select {
-	case <-ctx.Done():
-		return false, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-	records, err := c.repo.ListTrackerMetadataByPath(ctx, path)
-	if err != nil {
-		return false, fmt.Errorf("core: tracker metadata lookup: %w", err)
-	}
-	if len(meta.Trackers) > 0 && len(records) > 0 {
-		allowed := make(map[string]struct{}, len(meta.Trackers))
-		for _, tracker := range meta.Trackers {
-			trimmed := strings.TrimSpace(tracker)
-			if trimmed == "" {
-				continue
-			}
-			allowed[strings.ToUpper(trimmed)] = struct{}{}
-		}
-		if len(allowed) > 0 {
-			filtered := records[:0]
-			for _, record := range records {
-				key := strings.ToUpper(strings.TrimSpace(record.Tracker))
-				if key == "" {
-					continue
-				}
-				if _, ok := allowed[key]; !ok {
-					continue
-				}
-				filtered = append(filtered, record)
-			}
-			records = filtered
-		}
-	}
-	if len(records) == 0 {
-		return false, nil
-	}
-
-	if len(meta.TrackerData) == 0 {
-		meta.TrackerData = append([]api.TrackerMetadata{}, records...)
-	} else {
-		seen := make(map[string]struct{}, len(meta.TrackerData))
-		for _, record := range meta.TrackerData {
-			key := strings.ToLower(strings.TrimSpace(record.Tracker))
-			if key == "" {
-				continue
-			}
-			seen[key] = struct{}{}
-		}
-		for _, record := range records {
-			key := strings.ToLower(strings.TrimSpace(record.Tracker))
-			if key == "" {
-				continue
-			}
-			if _, exists := seen[key]; exists {
-				continue
-			}
-			meta.TrackerData = append(meta.TrackerData, record)
-			seen[key] = struct{}{}
-		}
-	}
-
-	if meta.TrackerIDs == nil {
-		meta.TrackerIDs = make(map[string]string)
-	}
-	matched := make([]string, 0, len(records))
-	for _, record := range records {
-		key := strings.ToLower(strings.TrimSpace(record.Tracker))
-		if key != "" && strings.TrimSpace(record.TrackerID) != "" {
-			if _, exists := meta.TrackerIDs[key]; !exists {
-				meta.TrackerIDs[key] = strings.TrimSpace(record.TrackerID)
-			}
-		}
-		if meta.InfoHash == "" && strings.TrimSpace(record.InfoHash) != "" {
-			meta.InfoHash = strings.TrimSpace(record.InfoHash)
-		}
-		if record.Matched {
-			matched = append(matched, record.Tracker)
-		}
-	}
-	if len(matched) > 0 {
-		meta.MatchedTrackers = mergeTrackerRemovals(meta.MatchedTrackers, matched)
-		meta.FoundTrackerMatch = true
-		meta.TrackersRemove = mergeTrackerRemovals(meta.TrackersRemove, meta.MatchedTrackers)
-	}
-
-	return true, nil
-}
-
-func resetPreparedClientData(meta *api.PreparedMetadata, req api.Request) {
-	if meta == nil {
-		return
-	}
-	meta.FoundTrackerMatch = false
-	meta.MatchedTrackers = nil
-	meta.TrackersRemove = mergeTrackerRemovals(nil, req.TrackersRemove)
-	meta.TorrentComments = nil
-	meta.ClientTorrentPath = ""
-	meta.PieceSizeConstraint = ""
-	meta.FoundPreferredPiece = ""
-	meta.InfoHash = cachedInfoHash(*meta)
-	meta.TrackerIDs = cloneStringMap(req.TrackerIDOverrides)
-	applyTorrentOverridesToPreparedMeta(meta)
-	for idx := range meta.TrackerData {
-		meta.TrackerData[idx].Matched = false
-	}
-}
-
-func cachedInfoHash(meta api.PreparedMetadata) string {
-	if value := strings.TrimSpace(meta.StoredInfoHash); value != "" {
-		return value
-	}
-	for _, record := range meta.TrackerData {
-		if value := strings.TrimSpace(record.InfoHash); value != "" {
-			return value
-		}
-	}
-	return ""
-}
-
-func markTrackerDataMatches(meta *api.PreparedMetadata, matchedTrackers []string) {
-	if meta == nil || len(matchedTrackers) == 0 || len(meta.TrackerData) == 0 {
-		return
-	}
-	for idx := range meta.TrackerData {
-		if matchedTrackerForUpload(matchedTrackers, meta.TrackerData[idx].Tracker) {
-			meta.TrackerData[idx].Matched = true
-		}
-	}
-}
-
-func applyPathedTorrentData(meta *api.PreparedMetadata, searchResult api.ClientSearchResult) bool {
-	if meta == nil || !hasPathedTorrentData(searchResult) {
-		return false
-	}
-	if infoHash := strings.TrimSpace(searchResult.InfoHash); infoHash != "" {
-		meta.InfoHash = infoHash
-	}
-	if torrentPath := strings.TrimSpace(searchResult.TorrentPath); torrentPath != "" {
-		meta.ClientTorrentPath = torrentPath
-	}
-	if len(searchResult.TrackerIDs) > 0 {
-		meta.TrackerIDs = mergeTrackerIDOverrides(searchResult.TrackerIDs, meta.TrackerIDs)
-	}
-	if len(searchResult.TorrentComments) > 0 {
-		meta.TorrentComments = append([]api.TorrentMatch{}, searchResult.TorrentComments...)
-	}
-	meta.PieceSizeConstraint = searchResult.PieceSizeConstraint
-	meta.FoundPreferredPiece = searchResult.FoundPreferredPiece
-	meta.StoredDataFresh = false
-	return true
-}
-
-func hasPathedTorrentData(searchResult api.ClientSearchResult) bool {
-	return strings.TrimSpace(searchResult.InfoHash) != "" ||
-		strings.TrimSpace(searchResult.TorrentPath) != "" ||
-		len(searchResult.TrackerIDs) > 0 ||
-		len(searchResult.TorrentComments) > 0 ||
-		strings.TrimSpace(searchResult.PieceSizeConstraint) != "" ||
-		strings.TrimSpace(searchResult.FoundPreferredPiece) != ""
-}
-
-func (c *Core) getDupeCache(path string, signature string) (api.PreparedMetadata, bool) {
-	if strings.TrimSpace(path) == "" {
-		return api.PreparedMetadata{}, false
-	}
-	c.dupeMu.RLock()
-	defer c.dupeMu.RUnlock()
-	entry, ok := c.dupeCache[path]
-	if !ok {
-		return api.PreparedMetadata{}, false
-	}
-	if signature != "" && entry.signature != signature {
-		return api.PreparedMetadata{}, false
-	}
-	return entry.meta, true
-}
-
-func (c *Core) getGUICachedMetaEntry(path string, signature string, overrides api.ExternalIDOverrides) (dupeCacheEntry, bool) {
-	if strings.TrimSpace(signature) != "" {
-		c.dupeMu.RLock()
-		entry, ok := c.dupeCache[path]
-		c.dupeMu.RUnlock()
-		if ok && entry.signature == signature {
-			return entry, true
-		}
-	}
-	if hasExternalIDOverrides(overrides) {
-		return dupeCacheEntry{}, false
-	}
-	c.dupeMu.RLock()
-	defer c.dupeMu.RUnlock()
-	entry, ok := c.dupeCache[path]
-	if !ok || hasExternalIDOverrides(entry.meta.ExternalIDOverrides) {
-		return dupeCacheEntry{}, false
-	}
-	return entry, true
-}
-
-func (c *Core) getGUICachedMeta(path string, signature string, overrides api.ExternalIDOverrides) (api.PreparedMetadata, bool) {
-	entry, ok := c.getGUICachedMetaEntry(path, signature, overrides)
-	if !ok {
-		return api.PreparedMetadata{}, false
-	}
-	return entry.meta, true
-}
-
-func (c *Core) lookupGUICachedMetaEntry(req api.Request, path string) (dupeCacheEntry, string, bool) {
-	mergedOverrides := mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-	signature := overrideSignature(mergedOverrides, req.ReleaseNameOverrides, req.MetadataOverrides, req.TrackerConfigOverrides, req.TrackerSiteOverrides, req.ClientOverrides, req.TorrentOverrides, req.ImageHostOverrides, req.ScreenshotOverrides)
-	entry, ok := c.getGUICachedMetaEntry(path, signature, mergedOverrides)
-	return entry, signature, ok
-}
-
-func (c *Core) lookupGUICachedMeta(req api.Request, path string) (api.PreparedMetadata, bool) {
-	entry, _, ok := c.lookupGUICachedMetaEntry(req, path)
-	if !ok {
-		return api.PreparedMetadata{}, false
-	}
-	return entry.meta, true
-}
-
-func (c *Core) resolveGUICachedPreparedMeta(ctx context.Context, req api.Request, path string) (api.PreparedMetadata, bool, error) {
-	entry, signature, ok := c.lookupGUICachedMetaEntry(req, path)
-	if !ok {
-		return api.PreparedMetadata{}, false, nil
-	}
-	if entry.requestRefreshed && cachedPreparedMetaMatchesRequest(entry.meta, req, path) {
-		return deepCopyPreparedMetadata(entry.meta), true, nil
-	}
-	resolved, err := c.applyRequestToCachedPreparedMeta(ctx, entry.meta, req)
-	if err != nil {
-		return api.PreparedMetadata{}, false, err
-	}
-	if cacheableGUIPreparedMetaRequest(req) {
-		c.storeRefreshedDupeCache(path, signature, resolved)
-	}
-	return resolved, true, nil
-}
-
-func cachedPreparedMetaMatchesRequest(meta api.PreparedMetadata, req api.Request, path string) bool {
-	if strings.TrimSpace(meta.SourcePath) != strings.TrimSpace(path) {
-		return false
-	}
-	mergedOverrides := mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-	return meta.Mode == req.Mode &&
-		reflect.DeepEqual(meta.Options, req.Options) &&
-		requestedTrackersApplied(meta.Trackers, req.Trackers) &&
-		requestedTrackersRemoveApplied(meta.TrackersRemove, req.TrackersRemove) &&
-		requestedTrackerIDsApplied(meta.TrackerIDs, req.TrackerIDOverrides) &&
-		strings.TrimSpace(meta.DescriptionOverride) == strings.TrimSpace(req.DescriptionOverrideRaw) &&
-		reflect.DeepEqual(meta.MetadataOverrides, req.MetadataOverrides) &&
-		reflect.DeepEqual(meta.TrackerConfigOverrides, req.TrackerConfigOverrides) &&
-		reflect.DeepEqual(meta.TrackerSiteOverrides, req.TrackerSiteOverrides) &&
-		reflect.DeepEqual(meta.ClientOverrides, req.ClientOverrides) &&
-		reflect.DeepEqual(meta.ImageHostOverrides, req.ImageHostOverrides) &&
-		reflect.DeepEqual(meta.ScreenshotOverrides, req.ScreenshotOverrides) &&
-		reflect.DeepEqual(meta.TorrentOverrides, req.TorrentOverrides) &&
-		meta.IgnoreTrackerRuleFailures == req.IgnoreTrackerRuleFailures &&
-		len(req.IgnoreDupesFor) == 0 &&
-		reflect.DeepEqual(meta.ExternalIDOverrides, mergedOverrides) &&
-		reflect.DeepEqual(meta.ReleaseNameOverrides, req.ReleaseNameOverrides) &&
-		sameQuestionnaireAnswers(meta.TrackerQuestionnaireAnswers, req.TrackerQuestionnaireAnswers) &&
-		sameDescriptionGroups(meta.DescriptionGroups, req.DescriptionGroups)
-}
-
-func requestedTrackersApplied(metaTrackers []string, requested []string) bool {
-	if len(requested) == 0 {
-		return true
-	}
-	return sameTrackerSet(metaTrackers, requested)
-}
-
-func sameTrackerSet(left []string, right []string) bool {
-	leftCounts, leftTotal := trackerNameCounts(left)
-	rightCounts, rightTotal := trackerNameCounts(right)
-	if leftTotal != rightTotal {
-		return false
-	}
-	if len(leftCounts) != len(rightCounts) {
-		return false
-	}
-	for name, count := range leftCounts {
-		if rightCounts[name] != count {
-			return false
-		}
-	}
-	return true
-}
-
-func trackerNameCounts(trackers []string) (map[string]int, int) {
-	counts := make(map[string]int, len(trackers))
-	total := 0
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		counts[name]++
-		total++
-	}
-	return counts, total
-}
-
-// explicitTrackerSelectionResolvedEmpty reports whether a non-empty requested
-// tracker set was fully removed by tracker resolution.
-func explicitTrackerSelectionResolvedEmpty(requested []string, resolved []string) bool {
-	return len(requested) > 0 && len(resolved) == 0
-}
-
-// resolveTrackersPreservingExplicitEmpty resolves requested trackers while
-// preserving the difference between an omitted selection and an explicit
-// selection that was fully removed.
-//
-// includeDefaults adds configured defaults to non-empty explicit selections.
-// fallbackDefaultsWhenExplicitEmpty controls whether a removed explicit
-// selection may fall back to defaults instead of returning explicitEmpty.
-func resolveTrackersPreservingExplicitEmpty(
-	cfg config.Config,
-	requested []string,
-	remove []string,
-	logger api.Logger,
-	includeDefaults bool,
-	fallbackDefaultsWhenExplicitEmpty bool,
-) ([]string, bool) {
-	resolved := trackers.ResolveTrackers(cfg, requested, remove, logger)
-	if explicitTrackerSelectionResolvedEmpty(requested, resolved) {
-		if includeDefaults && fallbackDefaultsWhenExplicitEmpty {
-			defaults := trackers.ResolveTrackers(cfg, nil, remove, logger)
-			if len(defaults) > 0 {
-				return defaults, false
-			}
-		}
-		return nil, true
-	}
-	if includeDefaults && len(requested) > 0 {
-		return trackers.ResolveTrackersWithDefaults(cfg, requested, remove, logger), false
-	}
-	return resolved, false
-}
-
-func requestedTrackersRemoveApplied(metaTrackersRemove []string, requested []string) bool {
-	if len(requested) == 0 {
-		return true
-	}
-	seen := make(map[string]struct{}, len(metaTrackersRemove))
-	for _, tracker := range metaTrackersRemove {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name != "" {
-			seen[name] = struct{}{}
-		}
-	}
-	for _, tracker := range requested {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		if _, ok := seen[name]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-func requestedTrackerIDsApplied(metaTrackerIDs map[string]string, requested map[string]string) bool {
-	if len(requested) == 0 {
-		return true
-	}
-	for tracker, id := range requested {
-		name := strings.ToLower(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		got := ""
-		for metaTracker, metaID := range metaTrackerIDs {
-			if strings.EqualFold(strings.TrimSpace(metaTracker), name) {
-				got = metaID
-				break
-			}
-		}
-		if strings.TrimSpace(got) != strings.TrimSpace(id) {
-			return false
-		}
-	}
-	return true
-}
-
-func sameQuestionnaireAnswers(left map[string]map[string]string, right map[string]map[string]string) bool {
-	if len(left) == 0 && len(right) == 0 {
-		return true
-	}
-	return reflect.DeepEqual(left, right)
-}
-
-func sameDescriptionGroups(left []api.DescriptionBuilderGroup, right []api.DescriptionBuilderGroup) bool {
-	if len(left) == 0 && len(right) == 0 {
-		return true
-	}
-	return reflect.DeepEqual(left, right)
-}
-
-func cacheableGUIPreparedMetaRequest(req api.Request) bool {
-	return !req.SkipDupeCheck &&
-		len(req.IgnoreDupesFor) == 0 &&
-		len(req.IgnoreTrackerRuleFailuresFor) == 0 &&
-		strings.TrimSpace(req.DescriptionOverrideRaw) == "" &&
-		len(req.DescriptionGroups) == 0
-}
-
-// ExportGUICachedPreparedMeta exposes the resolved GUI prepared metadata cache entry
-// so callers can hand off metadata to isolated per-run cores.
-func (c *Core) ExportGUICachedPreparedMeta(ctx context.Context, req api.Request) (meta api.PreparedMetadata, ok bool, err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: gui prepared metadata export blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	if err := ctx.Err(); err != nil {
-		return api.PreparedMetadata{}, false, fmt.Errorf("core: export cached prepared metadata canceled: %w", err)
-	}
-	path, err := c.resolveSinglePreparedMetaPath(ctx, req.Paths)
-	if err != nil {
-		return api.PreparedMetadata{}, false, err
-	}
-	meta, ok = c.lookupGUICachedMeta(req, path)
-	if !ok {
-		c.logger.Debugf("core: gui prepared metadata export miss path=%s", path)
-		return api.PreparedMetadata{}, false, nil
-	}
-	c.logger.Debugf("core: gui prepared metadata export hit path=%s meta_no_seed=%t", path, meta.Options.NoSeed)
-	return deepCopyPreparedMetadata(meta), true, nil
-}
-
-// ImportPreparedMetadataForGUI stores prepared metadata on a per-run core so GUI dry-run
-// and upload-only flows can reuse metadata prepared on the long-lived GUI core.
-func (c *Core) ImportPreparedMetadataForGUI(ctx context.Context, req api.Request, meta api.PreparedMetadata) (err error) {
-	defer func() {
-		if err != nil {
-			c.logger.Warnf("core: gui prepared metadata import blocked err=%s", redaction.RedactValue(err.Error(), nil))
-		}
-	}()
-
-	if err := ctx.Err(); err != nil {
-		return fmt.Errorf("core: import prepared metadata canceled: %w", err)
-	}
-	path, err := c.resolveSinglePreparedMetaPath(ctx, req.Paths)
-	if err != nil {
-		return err
-	}
-	overrides := mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, path))
-	signature := overrideSignature(overrides, req.ReleaseNameOverrides, req.MetadataOverrides, req.TrackerConfigOverrides, req.TrackerSiteOverrides, req.ClientOverrides, req.TorrentOverrides, req.ImageHostOverrides, req.ScreenshotOverrides)
-	c.storeDupeCache(path, signature, deepCopyPreparedMetadata(meta))
-	c.logger.Debugf("core: gui prepared metadata import stored path=%s request_no_seed=%t meta_no_seed=%t", path, req.Options.NoSeed, meta.Options.NoSeed)
-	return nil
-}
-
-func (c *Core) resolveSinglePreparedMetaPath(ctx context.Context, paths []string) (string, error) {
-	if len(paths) == 0 {
-		return "", internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return "", errors.New("core: filesystem service not configured")
-	}
-
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, paths)
-	if err != nil {
-		return "", fmt.Errorf("core: %w", err)
-	}
-	if len(normalizedPaths) == 0 {
-		return "", internalerrors.ErrInvalidInput
-	}
-
-	first := normalizedPaths[0]
-	for _, path := range normalizedPaths[1:] {
-		if path != first {
-			return "", internalerrors.ErrInvalidInput
-		}
-	}
-	return first, nil
-}
-
-func deepCopyPreparedMetadata(meta api.PreparedMetadata) api.PreparedMetadata {
-	copyMeta := meta
-	copyMeta.LookupWarnings = append([]string(nil), meta.LookupWarnings...)
-	copyMeta.Paths = append([]string(nil), meta.Paths...)
-	copyMeta.FileList = append([]string(nil), meta.FileList...)
-	copyMeta.DescriptionGroups = api.CloneDescriptionBuilderGroups(meta.DescriptionGroups)
-	copyMeta.Trackers = append([]string(nil), meta.Trackers...)
-	copyMeta.TrackersRemove = append([]string(nil), meta.TrackersRemove...)
-	copyMeta.MatchedTrackers = append([]string(nil), meta.MatchedTrackers...)
-	copyMeta.Release = deepCopyReleaseInfo(meta.Release)
-	copyMeta.TagOverride = deepCopyTagOverride(meta.TagOverride)
-	copyMeta.MetadataOverrides = deepCopyMetadataOverrides(meta.MetadataOverrides)
-	copyMeta.TrackerConfigOverrides = deepCopyTrackerConfigOverrides(meta.TrackerConfigOverrides)
-	copyMeta.TrackerSiteOverrides = deepCopyTrackerSiteOverrides(meta.TrackerSiteOverrides)
-	copyMeta.ClientOverrides = deepCopyClientOverrides(meta.ClientOverrides)
-	copyMeta.ImageHostOverrides = deepCopyImageHostOverrides(meta.ImageHostOverrides)
-	copyMeta.ScreenshotOverrides = deepCopyScreenshotOverrides(meta.ScreenshotOverrides)
-	copyMeta.TorrentOverrides = deepCopyTorrentOverrides(meta.TorrentOverrides)
-	copyMeta.TrackerIDs = cloneStringMap(meta.TrackerIDs)
-	copyMeta.TorrentComments = deepCopyTorrentMatches(meta.TorrentComments)
-	copyMeta.TrackerData = deepCopyTrackerMetadata(meta.TrackerData)
-	copyMeta.CrossSeedTorrents = append([]api.UploadedTorrent(nil), meta.CrossSeedTorrents...)
-	copyMeta.ArrGenres = append([]string(nil), meta.ArrGenres...)
-	copyMeta.ExternalIDOverrides = deepCopyExternalIDOverrides(meta.ExternalIDOverrides)
-	copyMeta.ReleaseNameOverrides = deepCopyReleaseNameOverrides(meta.ReleaseNameOverrides)
-	copyMeta.TrackerQuestionnaireAnswers = deepCopyQuestionnaireAnswers(meta.TrackerQuestionnaireAnswers)
-	copyMeta.TVDBAirsDays = append([]string(nil), meta.TVDBAirsDays...)
-	copyMeta.SelectedBDMVPlaylists = deepCopyPlaylistInfos(meta.SelectedBDMVPlaylists)
-	copyMeta.ExternalIDCandidates = deepCopyExternalIDCandidates(meta.ExternalIDCandidates)
-	copyMeta.ExternalMetadata = deepCopyExternalMetadata(meta.ExternalMetadata)
-	copyMeta.AudioLanguages = append([]string(nil), meta.AudioLanguages...)
-	copyMeta.SubtitleLanguages = append([]string(nil), meta.SubtitleLanguages...)
-	copyMeta.ReleaseNameMissing = append([]string(nil), meta.ReleaseNameMissing...)
-	copyMeta.BlockedTrackers = deepCopyBlockedTrackers(meta.BlockedTrackers)
-	copyMeta.TrackerRuleFailures = deepCopyTrackerRuleFailures(meta.TrackerRuleFailures)
-	copyMeta.BDInfo = deepCopyStringInterfaceMap(meta.BDInfo)
-	return copyMeta
-}
-
-func deepCopyReleaseInfo(info api.ReleaseInfo) api.ReleaseInfo {
-	copyInfo := info
-	copyInfo.Codec = append([]string(nil), info.Codec...)
-	copyInfo.Audio = append([]string(nil), info.Audio...)
-	copyInfo.HDR = append([]string(nil), info.HDR...)
-	copyInfo.Language = append([]string(nil), info.Language...)
-	copyInfo.Edition = append([]string(nil), info.Edition...)
-	copyInfo.Other = append([]string(nil), info.Other...)
-	return copyInfo
-}
-
-func deepCopyTagOverride(tag *api.TagOverride) *api.TagOverride {
-	if tag == nil {
-		return nil
-	}
-	copyTag := *tag
-	return &copyTag
-}
-
-func deepCopyMetadataOverrides(overrides api.MetadataOverrides) api.MetadataOverrides {
-	return api.MetadataOverrides{
-		Distributor:      clonePtr(overrides.Distributor),
-		OriginalLanguage: clonePtr(overrides.OriginalLanguage),
-		PersonalRelease:  clonePtr(overrides.PersonalRelease),
-		Commentary:       clonePtr(overrides.Commentary),
-		WebDV:            clonePtr(overrides.WebDV),
-		StreamOptimized:  clonePtr(overrides.StreamOptimized),
-		Anime:            clonePtr(overrides.Anime),
-	}
-}
-
-func deepCopyTrackerConfigOverrides(overrides api.TrackerConfigOverrides) api.TrackerConfigOverrides {
-	return api.TrackerConfigOverrides{
-		Anon:    clonePtr(overrides.Anon),
-		Draft:   clonePtr(overrides.Draft),
-		ModQ:    clonePtr(overrides.ModQ),
-		Channel: clonePtr(overrides.Channel),
-	}
-}
-
-func deepCopyTrackerSiteOverrides(overrides api.TrackerSiteOverrides) api.TrackerSiteOverrides {
-	return api.TrackerSiteOverrides{
-		TIK: api.TIKOverrides{
-			Foreign:  clonePtr(overrides.TIK.Foreign),
-			Opera:    clonePtr(overrides.TIK.Opera),
-			Asian:    clonePtr(overrides.TIK.Asian),
-			DiscType: clonePtr(overrides.TIK.DiscType),
-		},
-	}
-}
-
-func deepCopyClientOverrides(overrides api.ClientOverrides) api.ClientOverrides {
-	return api.ClientOverrides{
-		Client:       clonePtr(overrides.Client),
-		QbitCategory: clonePtr(overrides.QbitCategory),
-		QbitTag:      clonePtr(overrides.QbitTag),
-		ForceRecheck: clonePtr(overrides.ForceRecheck),
-	}
-}
-
-func deepCopyImageHostOverrides(overrides api.ImageHostOverrides) api.ImageHostOverrides {
-	return api.ImageHostOverrides{
-		PreferredHost: clonePtr(overrides.PreferredHost),
-		SkipUpload:    clonePtr(overrides.SkipUpload),
-	}
-}
-
-func deepCopyScreenshotOverrides(overrides api.ScreenshotOverrides) api.ScreenshotOverrides {
-	return api.ScreenshotOverrides{
-		ManualFrames:           append([]int(nil), overrides.ManualFrames...),
-		ComparisonPaths:        append([]string(nil), overrides.ComparisonPaths...),
-		ComparisonPrimaryIndex: clonePtr(overrides.ComparisonPrimaryIndex),
-	}
-}
-
-func deepCopyTorrentOverrides(overrides api.TorrentOverrides) api.TorrentOverrides {
-	return api.TorrentOverrides{
-		InfoHash:        clonePtr(overrides.InfoHash),
-		MaxPieceSizeMiB: clonePtr(overrides.MaxPieceSizeMiB),
-		NoHash:          clonePtr(overrides.NoHash),
-		Rehash:          clonePtr(overrides.Rehash),
-	}
-}
-
-func deepCopyExternalIDOverrides(overrides api.ExternalIDOverrides) api.ExternalIDOverrides {
-	return api.ExternalIDOverrides{
-		TMDBID:   clonePtr(overrides.TMDBID),
-		IMDBID:   clonePtr(overrides.IMDBID),
-		TVDBID:   clonePtr(overrides.TVDBID),
-		TVmazeID: clonePtr(overrides.TVmazeID),
-		MALID:    clonePtr(overrides.MALID),
-	}
-}
-
-func deepCopyReleaseNameOverrides(overrides api.ReleaseNameOverrides) api.ReleaseNameOverrides {
-	return api.ReleaseNameOverrides{
-		Category:         clonePtr(overrides.Category),
-		Type:             clonePtr(overrides.Type),
-		Source:           clonePtr(overrides.Source),
-		Resolution:       clonePtr(overrides.Resolution),
-		Tag:              clonePtr(overrides.Tag),
-		Service:          clonePtr(overrides.Service),
-		Edition:          clonePtr(overrides.Edition),
-		Season:           clonePtr(overrides.Season),
-		Episode:          clonePtr(overrides.Episode),
-		EpisodeTitle:     clonePtr(overrides.EpisodeTitle),
-		ManualYear:       clonePtr(overrides.ManualYear),
-		ManualDate:       clonePtr(overrides.ManualDate),
-		UseSeasonEpisode: clonePtr(overrides.UseSeasonEpisode),
-		NoSeason:         clonePtr(overrides.NoSeason),
-		NoYear:           clonePtr(overrides.NoYear),
-		NoAKA:            clonePtr(overrides.NoAKA),
-		NoTag:            clonePtr(overrides.NoTag),
-		NoEdition:        clonePtr(overrides.NoEdition),
-		NoDub:            clonePtr(overrides.NoDub),
-		NoDual:           clonePtr(overrides.NoDual),
-		DualAudio:        clonePtr(overrides.DualAudio),
-		Region:           clonePtr(overrides.Region),
-	}
-}
-
-func deepCopyQuestionnaireAnswers(input map[string]map[string]string) map[string]map[string]string {
-	if len(input) == 0 {
-		return nil
-	}
-	cloned := make(map[string]map[string]string, len(input))
-	for tracker, values := range input {
-		inner := make(map[string]string, len(values))
-		maps.Copy(inner, values)
-		cloned[tracker] = inner
-	}
-	return cloned
-}
-
-func deepCopyPlaylistInfos(playlists []api.PlaylistInfo) []api.PlaylistInfo {
-	if len(playlists) == 0 {
-		return nil
-	}
-	cloned := make([]api.PlaylistInfo, len(playlists))
-	for idx, playlist := range playlists {
-		cloned[idx] = playlist
-		cloned[idx].Items = append([]api.PlaylistItem(nil), playlist.Items...)
-	}
-	return cloned
+	return c.FetchAcceptedPreparationPreview(ctx, api.DescriptionInput{
+		Release:  api.ReleaseRef{SourcePath: prepared.Release.Source.SourcePath, Generation: prepared.Release.Generation},
+		Trackers: append([]string(nil), req.Trackers...),
+		Options:  req.Options,
+	})
 }
 
-func deepCopyExternalIDCandidates(candidates api.ExternalIDCandidates) api.ExternalIDCandidates {
-	return api.ExternalIDCandidates{
-		TMDB:             append([]api.ExternalIDCandidate(nil), candidates.TMDB...),
-		IMDB:             append([]api.ExternalIDCandidate(nil), candidates.IMDB...),
-		TMDBAutoSelected: candidates.TMDBAutoSelected,
-		IMDBAutoSelected: candidates.IMDBAutoSelected,
-	}
+// RunAcceptedTrackerDryRun builds non-submitting tracker payloads for one exact
+// generation using completed duplicate evidence. Unless NoSeed is set, ready
+// payloads may produce tracker-specific torrents and inject them into the client.
+func (c *Core) RunAcceptedTrackerDryRun(ctx context.Context, plan api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	preview, err := c.upload.runAcceptedTrackerDryRun(ctx, plan)
+	return preview, classifyOperationError(api.OperationKindDryRun, err)
 }
 
-func deepCopyExternalMetadata(metadata api.ExternalMetadata) api.ExternalMetadata {
-	return api.ExternalMetadata{
-		SourcePath: metadata.SourcePath,
-		TMDB:       deepCopyTMDBMetadata(metadata.TMDB),
-		IMDB:       deepCopyIMDBMetadata(metadata.IMDB),
-		TVDB:       deepCopyTVDBMetadata(metadata.TVDB),
-		TVmaze:     deepCopyTVmazeMetadata(metadata.TVmaze),
-		AniList:    deepCopyAniListMetadata(metadata.AniList),
-		Bluray:     deepCopyBlurayMetadata(metadata.Bluray),
-		UpdatedAt:  metadata.UpdatedAt,
+func sanitizeTrackerDryRunEntries(entries []api.TrackerDryRunEntry) []api.TrackerDryRunEntry {
+	sanitized := make([]api.TrackerDryRunEntry, len(entries))
+	for index, entry := range entries {
+		entry.Message = logging.SanitizeMessage(entry.Message)
+		entry.BannedReason = logging.SanitizeMessage(entry.BannedReason)
+		entry.BannedCheckError = logging.SanitizeMessage(entry.BannedCheckError)
+		entry.Endpoint = logging.SanitizeMessage(entry.Endpoint)
+		entry.Payload = redactDryRunPayload(entry.Payload)
+		entry.Files = sanitizeTrackerDryRunFiles(entry.Files)
+		entry.DebugSections = sanitizeTrackerDryRunDebugSections(entry.DebugSections)
+		entry.ImageHost = sanitizeDryRunImageHostFeedback(entry.ImageHost)
+		for idx := range entry.Diagnostics.RuleDecisions {
+			entry.Diagnostics.RuleDecisions[idx].Reason = logging.SanitizeMessage(entry.Diagnostics.RuleDecisions[idx].Reason)
+		}
+		for idx := range entry.Diagnostics.LiveEligibilityReasons {
+			entry.Diagnostics.LiveEligibilityReasons[idx].Message = logging.SanitizeMessage(entry.Diagnostics.LiveEligibilityReasons[idx].Message)
+		}
+		entry.Diagnostics.Duplicate.Error = logging.SanitizeMessage(entry.Diagnostics.Duplicate.Error)
+		entry.Diagnostics.Duplicate.SkipReason = logging.SanitizeMessage(entry.Diagnostics.Duplicate.SkipReason)
+		sanitized[index] = entry
 	}
+	return sanitized
 }
 
-func deepCopyBlurayMetadata(metadata *api.BlurayMetadata) *api.BlurayMetadata {
-	if metadata == nil {
+func redactDryRunPayload(payload map[string]string) map[string]string {
+	if payload == nil {
 		return nil
 	}
-	cloned := *metadata
-	cloned.Candidates = make([]api.BlurayReleaseCandidate, len(metadata.Candidates))
-	for idx, candidate := range metadata.Candidates {
-		cloned.Candidates[idx] = candidate
-		cloned.Candidates[idx].Warnings = append([]string(nil), candidate.Warnings...)
-		cloned.Candidates[idx].MatchNotes = append([]string(nil), candidate.MatchNotes...)
-		cloned.Candidates[idx].Specs.Audio = append([]string(nil), candidate.Specs.Audio...)
-		cloned.Candidates[idx].Specs.Subtitles = append([]string(nil), candidate.Specs.Subtitles...)
-		cloned.Candidates[idx].CoverImages = append([]api.BlurayImage(nil), candidate.CoverImages...)
+	redacted := make(map[string]string, len(payload))
+	for key, value := range payload {
+		wrapped := map[string]any{key: value}
+		result, ok := redaction.RedactPrivateInfo(wrapped, nil).(map[string]any)
+		if !ok {
+			redacted[key] = "[REDACTED]"
+			continue
+		}
+		redactedValue, ok := result[key].(string)
+		if !ok {
+			redacted[key] = "[REDACTED]"
+			continue
+		}
+		redacted[key] = logging.SanitizeMessage(redactedValue)
 	}
-	return &cloned
+	return redacted
 }
 
-func deepCopyTMDBMetadata(metadata *api.TMDBMetadata) *api.TMDBMetadata {
-	if metadata == nil {
-		return nil
-	}
-	cloned := *metadata
-	cloned.OriginCountry = append([]string(nil), metadata.OriginCountry...)
-	cloned.Creators = append([]string(nil), metadata.Creators...)
-	cloned.Directors = append([]string(nil), metadata.Directors...)
-	cloned.Cast = append([]string(nil), metadata.Cast...)
-	cloned.LocalizedTitles = cloneStringMap(metadata.LocalizedTitles)
-	cloned.ProductionCompanies = append([]api.TMDBCompany(nil), metadata.ProductionCompanies...)
-	cloned.ProductionCountries = append([]api.TMDBCountry(nil), metadata.ProductionCountries...)
-	cloned.Networks = append([]api.TMDBNetwork(nil), metadata.Networks...)
-	if metadata.Localized != nil {
-		cloned.Localized = make(map[string]api.TMDBLocalizedData, len(metadata.Localized))
-		maps.Copy(cloned.Localized, metadata.Localized)
+func sanitizeTrackerDryRunFiles(files []api.TrackerDryRunFile) []api.TrackerDryRunFile {
+	sanitized := slices.Clone(files)
+	for index := range sanitized {
+		sanitized[index].Path = logging.SanitizeMessage(sanitized[index].Path)
 	}
-	return &cloned
+	return sanitized
 }
 
-func deepCopyIMDBMetadata(metadata *api.IMDBMetadata) *api.IMDBMetadata {
-	if metadata == nil {
-		return nil
+func sanitizeTrackerDryRunDebugSections(sections []api.TrackerDryRunDebugSection) []api.TrackerDryRunDebugSection {
+	sanitized := make([]api.TrackerDryRunDebugSection, len(sections))
+	for index, section := range sections {
+		section.Endpoint = logging.SanitizeMessage(section.Endpoint)
+		section.Payload = redactDryRunPayload(section.Payload)
+		section.Files = sanitizeTrackerDryRunFiles(section.Files)
+		sanitized[index] = section
 	}
-	cloned := *metadata
-	cloned.Directors = append([]api.IMDBPerson(nil), metadata.Directors...)
-	cloned.Creators = append([]api.IMDBPerson(nil), metadata.Creators...)
-	cloned.Writers = append([]api.IMDBPerson(nil), metadata.Writers...)
-	cloned.Stars = append([]api.IMDBPerson(nil), metadata.Stars...)
-	cloned.Editions = append([]string(nil), metadata.Editions...)
-	cloned.EditionDetails = deepCopyIMDBEditionDetails(metadata.EditionDetails)
-	cloned.Akas = deepCopyIMDBAKAs(metadata.Akas)
-	cloned.Episodes = append([]api.IMDBEpisode(nil), metadata.Episodes...)
-	cloned.SeasonsSummary = append([]api.IMDBSeasonSummary(nil), metadata.SeasonsSummary...)
-	cloned.SoundMixes = append([]string(nil), metadata.SoundMixes...)
-	return &cloned
+	return sanitized
 }
 
-func deepCopyTVDBMetadata(metadata *api.TVDBMetadata) *api.TVDBMetadata {
-	if metadata == nil {
-		return nil
+func sanitizeDryRunImageHostFeedback(feedback api.ImageHostFeedback) api.ImageHostFeedback {
+	feedback.Message = logging.SanitizeMessage(feedback.Message)
+	feedback.Warnings = slices.Clone(feedback.Warnings)
+	for index := range feedback.Warnings {
+		feedback.Warnings[index].Message = logging.SanitizeMessage(feedback.Warnings[index].Message)
 	}
-	cloned := *metadata
-	cloned.Aliases = append([]string(nil), metadata.Aliases...)
-	cloned.Episodes = append([]api.TVDBEpisodeMetadata(nil), metadata.Episodes...)
-	return &cloned
+	return feedback
 }
 
-func deepCopyTVmazeMetadata(metadata *api.TVmazeMetadata) *api.TVmazeMetadata {
-	if metadata == nil {
-		return nil
+// trackerDryRunTorrentPath returns the present torrent file path advertised by
+// a dry-run payload, ignoring other upload file fields.
+func trackerDryRunTorrentPath(entry api.TrackerDryRunEntry) string {
+	for _, file := range entry.Files {
+		if strings.EqualFold(strings.TrimSpace(file.Field), "torrent") && file.Present {
+			return strings.TrimSpace(file.Path)
+		}
 	}
-	cloned := *metadata
-	return &cloned
+	return ""
 }
 
-// deepCopyAniListMetadata clones rich anime metadata for prepared-metadata
-// snapshots so cached GUI/core state cannot alias mutable slice fields.
-func deepCopyAniListMetadata(metadata *api.AniListMetadata) *api.AniListMetadata {
-	if metadata == nil {
-		return nil
-	}
-	cloned := *metadata
-	cloned.Genres = append([]string(nil), metadata.Genres...)
-	cloned.Synonyms = append([]string(nil), metadata.Synonyms...)
-	cloned.Tags = append([]api.AniListTag(nil), metadata.Tags...)
-	cloned.Studios = append([]api.AniListStudio(nil), metadata.Studios...)
-	cloned.ExternalLinks = append([]api.AniListExternalLink(nil), metadata.ExternalLinks...)
-	return &cloned
+func annotateDryRunSubjectReleaseNames(subject api.UploadSubject, entries []api.TrackerDryRunEntry) {
+	annotateDryRunNames(subject.ReleaseName, subject.ReleaseNameNoTag, subject.Filename, entries)
 }
 
-func deepCopyTorrentMatches(matches []api.TorrentMatch) []api.TorrentMatch {
-	if len(matches) == 0 {
-		return nil
+func annotateDryRunNames(releaseName string, nameWithoutTag string, filename string, entries []api.TrackerDryRunEntry) {
+	original := strings.TrimSpace(releaseName)
+	if original == "" {
+		original = strings.TrimSpace(nameWithoutTag)
+	}
+	if original == "" {
+		original = strings.TrimSpace(filename)
 	}
-	cloned := make([]api.TorrentMatch, len(matches))
-	for idx, match := range matches {
-		cloned[idx] = match
-		cloned[idx].TrackerURLsRaw = append([]string(nil), match.TrackerURLsRaw...)
-		cloned[idx].TrackerURLs = append([]api.TrackerMatch(nil), match.TrackerURLs...)
+	for idx := range entries {
+		uploadName := strings.TrimSpace(entries[idx].ReleaseName)
+		if uploadName == "" {
+			uploadName = original
+		}
+		entries[idx].OriginalReleaseName = original
+		entries[idx].UploadReleaseName = uploadName
+		entries[idx].ReleaseNameChanged = original != "" && uploadName != "" && uploadName != original
+		if entries[idx].ReleaseNameChanged && strings.TrimSpace(entries[idx].ReleaseNameChangeReason) == "" {
+			entries[idx].ReleaseNameChangeReason = "tracker naming rules"
+		}
 	}
-	return cloned
 }
 
-func deepCopyTrackerMetadata(metadata []api.TrackerMetadata) []api.TrackerMetadata {
-	if len(metadata) == 0 {
-		return nil
-	}
-	cloned := make([]api.TrackerMetadata, len(metadata))
-	for idx, item := range metadata {
-		cloned[idx] = item
-		cloned[idx].ImageURLs = append([]string(nil), item.ImageURLs...)
+// FetchDescriptionBuilderPreview builds editable description groups for one
+// validated source and its resolved tracker set.
+func (c *Core) FetchDescriptionBuilderPreview(ctx context.Context, req api.Request) (api.DescriptionBuilderPreview, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentDescription)
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, err
 	}
-	return cloned
+	return c.FetchAcceptedDescriptionBuilderPreview(ctx, api.DescriptionInput{
+		Release:           ref,
+		Trackers:          append([]string(nil), req.Trackers...),
+		Groups:            api.CloneDescriptionBuilderGroups(req.DescriptionGroups),
+		ImageHost:         req.ImageHostOverrides,
+		QuestionnaireData: cloneOperationQuestionnaireAnswers(req.TrackerQuestionnaireAnswers),
+		Options:           req.Options,
+	})
 }
 
-func deepCopyBlockedTrackers(blocked map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
-	if len(blocked) == 0 {
-		return nil
-	}
-	cloned := make(map[string][]api.TrackerBlockReason, len(blocked))
-	for tracker, reasons := range blocked {
-		cloned[tracker] = append([]api.TrackerBlockReason(nil), reasons...)
-	}
-	return cloned
+// FetchAcceptedDescriptionBuilderPreview builds groups for one exact generation.
+func (c *Core) FetchAcceptedDescriptionBuilderPreview(ctx context.Context, input api.DescriptionInput) (api.DescriptionBuilderPreview, error) {
+	result, err := c.description.fetchAcceptedPreview(ctx, input)
+	return classifyOperationResult(api.OperationKindDescription, result, err)
 }
 
-func deepCopyTrackerRuleFailures(failures map[string][]api.RuleFailure) map[string][]api.RuleFailure {
-	if len(failures) == 0 {
-		return nil
-	}
-	cloned := make(map[string][]api.RuleFailure, len(failures))
-	for tracker, items := range failures {
-		cloned[tracker] = append([]api.RuleFailure(nil), items...)
+// FetchDescriptionBuilderGroupPreview builds one editable description group
+// selected by the request's group or first tracker.
+func (c *Core) FetchDescriptionBuilderGroupPreview(ctx context.Context, req api.Request) (api.DescriptionBuilderGroup, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentDescription)
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, err
 	}
-	return cloned
+	return c.FetchAcceptedDescriptionBuilderGroupPreview(ctx, api.DescriptionInput{
+		Release:           ref,
+		Trackers:          append([]string(nil), req.Trackers...),
+		GroupKey:          req.DescriptionOverrideGroup,
+		Groups:            api.CloneDescriptionBuilderGroups(req.DescriptionGroups),
+		ImageHost:         req.ImageHostOverrides,
+		QuestionnaireData: cloneOperationQuestionnaireAnswers(req.TrackerQuestionnaireAnswers),
+		Options:           req.Options,
+	})
 }
 
-func deepCopyIMDBEditionDetails(details map[string]api.IMDBEditionDetail) map[string]api.IMDBEditionDetail {
-	if len(details) == 0 {
-		return nil
-	}
-	cloned := make(map[string]api.IMDBEditionDetail, len(details))
-	for key, detail := range details {
-		copied := detail
-		copied.Attributes = append([]string(nil), detail.Attributes...)
-		cloned[key] = copied
-	}
-	return cloned
+// FetchAcceptedDescriptionBuilderGroupPreview builds one exact-generation group.
+func (c *Core) FetchAcceptedDescriptionBuilderGroupPreview(ctx context.Context, input api.DescriptionInput) (api.DescriptionBuilderGroup, error) {
+	result, err := c.description.fetchAcceptedGroupPreview(ctx, input)
+	return classifyOperationResult(api.OperationKindDescription, result, err)
 }
 
-func deepCopyIMDBAKAs(items []api.IMDBAKA) []api.IMDBAKA {
-	if len(items) == 0 {
-		return nil
-	}
-	cloned := make([]api.IMDBAKA, len(items))
-	for idx, item := range items {
-		cloned[idx] = item
-		cloned[idx].Attributes = append([]string(nil), item.Attributes...)
+// SelectBlurayCandidate publishes a new prepared generation containing the
+// selected Blu-ray candidate as a release-fact instruction.
+func (c *Core) SelectBlurayCandidate(ctx context.Context, sourcePath string, releaseID string) (api.MetadataPreview, error) {
+	trimmedPath := strings.TrimSpace(sourcePath)
+	trimmedID := strings.TrimSpace(releaseID)
+	if trimmedPath == "" || trimmedID == "" {
+		return api.MetadataPreview{}, classifyOperationError(api.OperationKindPreparation, internalerrors.ErrInvalidInput)
+	}
+	prepared, err := c.preparedFacts.Prepare(ctx, api.PrepareInput{
+		SourcePath: trimmedPath,
+		Intent:     api.PreparationIntentPreview,
+		Instructions: api.ReleaseFactInstructions{
+			BlurayReleaseID: trimmedID,
+		},
+		Force: true,
+	})
+	if err != nil {
+		return api.MetadataPreview{}, classifyOperationError(api.OperationKindPreparation, fmt.Errorf("core: select Blu-ray candidate: %w", err))
 	}
-	return cloned
+	return c.FetchAcceptedMetadataPreview(ctx, api.ReleaseRef{SourcePath: prepared.Release.Source.SourcePath, Generation: prepared.Release.Generation})
 }
 
-func deepCopyStringInterfaceMap(input map[string]any) map[string]any {
-	if len(input) == 0 {
-		return nil
-	}
-	cloned := make(map[string]any, len(input))
-	for key, value := range input {
-		cloned[key] = deepCopyInterfaceValue(value)
-	}
-	return cloned
+// explicitTrackerSelectionResolvedEmpty reports whether a non-empty requested
+// tracker set was fully removed by tracker resolution.
+func explicitTrackerSelectionResolvedEmpty(requested []string, resolved []string) bool {
+	return len(requested) > 0 && len(resolved) == 0
 }
 
-func deepCopyInterfaceValue(value any) any {
-	switch typed := value.(type) {
-	case map[string]any:
-		return deepCopyStringInterfaceMap(typed)
-	case []any:
-		cloned := make([]any, len(typed))
-		for idx, item := range typed {
-			cloned[idx] = deepCopyInterfaceValue(item)
+// resolveTrackersPreservingExplicitEmpty resolves requested trackers while
+// preserving the difference between an omitted selection and an explicit
+// selection that was fully removed.
+//
+// includeDefaults adds configured defaults to non-empty explicit selections.
+// fallbackDefaultsWhenExplicitEmpty controls whether a removed explicit
+// selection may fall back to defaults instead of returning explicitEmpty.
+func resolveTrackersPreservingExplicitEmpty(
+	cfg config.Config,
+	requested []string,
+	remove []string,
+	logger api.Logger,
+	registry *trackers.Registry,
+	includeDefaults bool,
+	fallbackDefaultsWhenExplicitEmpty bool,
+) ([]string, bool) {
+	resolved := trackers.ResolveTrackersWithRegistry(cfg, requested, remove, logger, registry)
+	if explicitTrackerSelectionResolvedEmpty(requested, resolved) {
+		if includeDefaults && fallbackDefaultsWhenExplicitEmpty {
+			defaults := trackers.ResolveTrackersWithRegistry(cfg, nil, remove, logger, registry)
+			if len(defaults) > 0 {
+				return defaults, false
+			}
 		}
-		return cloned
-	case []string:
-		return append([]string(nil), typed...)
-	case []int:
-		return append([]int(nil), typed...)
-	case []int64:
-		return append([]int64(nil), typed...)
-	case []float64:
-		return append([]float64(nil), typed...)
-	case []bool:
-		return append([]bool(nil), typed...)
-	default:
-		return typed
+		return nil, true
 	}
+	if includeDefaults && len(requested) > 0 {
+		return trackers.ResolveTrackersWithDefaultsAndRegistry(cfg, requested, remove, logger, registry), false
+	}
+	return resolved, false
 }
 
-func clonePtr[T any](value *T) *T {
-	if value == nil {
-		return nil
+// DetectDiscType classifies one preparation source through the canonical source-layout resolver.
+func (c *Core) DetectDiscType(ctx context.Context, sourcePath string) (string, error) {
+	if ctx == nil {
+		return "", internalerrors.ErrInvalidInput
+	}
+	layout, err := sourcelayout.Resolve(ctx, sourcePath)
+	if err != nil {
+		return "", classifyOperationError(api.OperationKindPreparation, fmt.Errorf("core: resolve source layout: %w", err))
 	}
-	cloned := *value
-	return &cloned
+	return layout.DiscType, nil
 }
 
+// DiscoverPlaylists scans the local source for Blu-ray playlists and returns
+// them by descending score. Durations are seconds and item sizes are bytes.
 func (c *Core) DiscoverPlaylists(ctx context.Context, sourcePath string) ([]api.PlaylistInfo, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("core: discover playlists canceled: %w", err)
@@ -3940,11 +894,21 @@ func (c *Core) DiscoverPlaylists(ctx context.Context, sourcePath string) ([]api.
 	}
 
 	c.logger.Debugf("core: discovering playlists in %q", sourcePath)
+	layout, err := sourcelayout.Resolve(ctx, sourcePath)
+	if err != nil {
+		return nil, classifyOperationError(api.OperationKindPreparation, fmt.Errorf("core: resolve playlist source: %w", err))
+	}
+	if strings.TrimSpace(layout.BDMVRoot) == "" {
+		return nil, classifyOperationError(api.OperationKindPreparation, &api.InvalidPlaylistSelectionError{
+			SourcePath: layout.SourcePath,
+			Reason:     "source is not a Blu-ray disc",
+		})
+	}
 
-	playlists, err := filesystem.DiscoverPlaylists(ctx, sourcePath)
+	playlists, err := filesystem.DiscoverPlaylists(ctx, layout.BDMVRoot)
 	if err != nil {
 		c.logger.Warnf("core: discover playlists failed: %v", err)
-		return nil, fmt.Errorf("core: %w", err)
+		return nil, classifyOperationError(api.OperationKindPreparation, fmt.Errorf("core: discover playlists: %w", err))
 	}
 
 	// Convert filesystem types to API types.
@@ -3970,6 +934,8 @@ func (c *Core) DiscoverPlaylists(ctx context.Context, sourcePath string) ([]api.
 	return result, nil
 }
 
+// SavePlaylistSelection persists selected playlist names, or the use-all flag,
+// under the source path's normalized slash-delimited database key.
 func (c *Core) SavePlaylistSelection(ctx context.Context, sourcePath string, playlists []string, useAll bool) error {
 	if err := ctx.Err(); err != nil {
 		return fmt.Errorf("core: save playlist selection canceled: %w", err)
@@ -3977,7 +943,7 @@ func (c *Core) SavePlaylistSelection(ctx context.Context, sourcePath string, pla
 	if strings.TrimSpace(sourcePath) == "" {
 		return internalerrors.ErrInvalidInput
 	}
-	if c.repo == nil {
+	if c.selections == nil {
 		return errors.New("core: repository not initialized")
 	}
 
@@ -3985,382 +951,115 @@ func (c *Core) SavePlaylistSelection(ctx context.Context, sourcePath string, pla
 	normalizedPath := filepath.ToSlash(filepath.Clean(sourcePath))
 	c.logger.Debugf("core: saving playlist selection for %q (normalized: %q): %d playlists, useAll=%v", sourcePath, normalizedPath, len(playlists), useAll)
 
-	if err := c.repo.SavePlaylistSelection(ctx, normalizedPath, playlists, useAll); err != nil {
+	if err := c.selections.SavePlaylistSelection(ctx, normalizedPath, playlists, useAll); err != nil {
 		c.logger.Warnf("core: save playlist selection failed: %v", err)
 		return fmt.Errorf("core: %w", err)
 	}
 
 	c.logger.Infof("core: playlist selection saved for %q", normalizedPath)
 	return nil
-}
-
-func (c *Core) LoadPlaylistSelection(ctx context.Context, sourcePath string) (api.PlaylistSelection, error) {
-	if err := ctx.Err(); err != nil {
-		return api.PlaylistSelection{}, fmt.Errorf("core: load playlist selection canceled: %w", err)
-	}
-	if strings.TrimSpace(sourcePath) == "" {
-		return api.PlaylistSelection{}, internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return api.PlaylistSelection{}, errors.New("core: repository not initialized")
-	}
-
-	normalizedPath := filepath.ToSlash(filepath.Clean(sourcePath))
-	c.logger.Debugf("core: loading playlist selection source=%q normalized=%q", sourcePath, normalizedPath)
-
-	selection, err := c.repo.GetPlaylistSelection(ctx, normalizedPath)
-	if err != nil {
-		if errors.Is(err, internalerrors.ErrNotFound) {
-			c.logger.Debugf("core: playlist selection decision=not_found source=%q", sourcePath)
-			return api.PlaylistSelection{}, internalerrors.ErrNotFound
-		}
-		c.logger.Warnf("core: load playlist selection failed: %v", err)
-		return api.PlaylistSelection{}, fmt.Errorf("core: %w", err)
-	}
-
-	c.logger.Debugf("core: playlist selection decision=loaded source=%q playlists=%d use_all=%v", sourcePath, len(selection.SelectedPlaylists), selection.UseAll)
-	return selection, nil
-}
-
-func (c *Core) ListHistory(ctx context.Context) ([]api.HistoryEntry, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("core: list history canceled: %w", err)
-	}
-	if c.repo == nil {
-		return nil, errors.New("core: repository not initialized")
-	}
-
-	entries, err := c.repo.ListHistoryEntries(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-
-	result := make([]api.HistoryEntry, 0, len(entries))
-	for _, entry := range entries {
-		entryCopy := entry
-		entryCopy.LatestUploadStatus = api.HistoryStatusLabel(entry.LatestUploadStatus, entry.RuleFailureCount)
-		result = append(result, entryCopy)
-	}
-
-	return result, nil
-}
-
-func (c *Core) GetHistoryOverview(ctx context.Context, sourcePath string) (api.HistoryOverview, error) {
-	if err := ctx.Err(); err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: get history overview canceled: %w", err)
-	}
-	trimmed := strings.TrimSpace(sourcePath)
-	if trimmed == "" {
-		return api.HistoryOverview{}, internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return api.HistoryOverview{}, errors.New("core: repository not initialized")
-	}
-
-	metadata, err := c.repo.GetByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	overview := api.HistoryOverview{
-		SourcePath:        metadata.Path,
-		ReleaseTitle:      metadata.Title,
-		ReleaseSource:     metadata.Source,
-		ReleaseResolution: metadata.Resolution,
-		MetadataUpdatedAt: metadata.UpdatedAt,
-		Metadata:          metadata,
-	}
-
-	externalIDs, err := c.repo.GetExternalIDs(ctx, trimmed)
-	if err == nil {
-		overview.ExternalIDs = externalIDs
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	externalMetadata, err := c.repo.GetExternalMetadata(ctx, trimmed)
-	if err == nil {
-		overview.ExternalMetadata = externalMetadata
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	releaseOverrides, err := c.repo.GetReleaseNameOverrides(ctx, trimmed)
-	if err == nil {
-		overview.ReleaseNameOverrides = releaseOverrides
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	descriptionOverrides, err := c.repo.ListDescriptionOverridesByPath(ctx, trimmed)
-	if err == nil {
-		overview.DescriptionOverrides = append([]api.DescriptionOverride(nil), descriptionOverrides...)
-		overview.DescriptionOverride = preferredHistoryDescriptionOverride(descriptionOverrides)
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	playlistSelection, err := c.repo.GetPlaylistSelection(ctx, trimmed)
-	if err == nil {
-		overview.PlaylistSelection = playlistSelection
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-
-	trackerMetadata, err := c.repo.ListTrackerMetadataByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.TrackerMetadata = trackerMetadata
-
-	ruleFailures, err := c.repo.ListTrackerRuleFailuresByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.TrackerRuleFailures = ruleFailures
-
-	screenshots, err := c.repo.ListScreenshotsByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.Screenshots = screenshots
-
-	finalSelections, err := c.repo.ListFinalSelections(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.FinalSelections = finalSelections
-
-	uploadedImages, err := c.repo.ListUploadedImagesByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.UploadedImages = uploadedImages
-
-	uploadHistory, err := c.repo.ListUploadHistoryByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
-	}
-	overview.UploadHistory = uploadHistory
-	if len(uploadHistory) > 0 {
-		overview.LatestUploadStatus = uploadHistory[0].Status
-		overview.LatestUploadAt = uploadHistory[0].CreatedAt
-	}
-	blockingRuleFailures := api.CountBlockingRuleFailures(ruleFailures)
-	overview.StatusLabel = api.HistoryStatusLabel(overview.LatestUploadStatus, blockingRuleFailures)
-
-	return overview, nil
-}
-
-func preferredHistoryDescriptionOverride(overrides []api.DescriptionOverride) api.DescriptionOverride {
-	if len(overrides) == 0 {
-		return api.DescriptionOverride{}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.GroupKey) == "" {
-			return override
-		}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.Description) != "" {
-			return override
-		}
-	}
-	return overrides[0]
-}
-
-func (c *Core) DeleteHistoryRelease(ctx context.Context, sourcePath string) error {
-	if err := ctx.Err(); err != nil {
-		return fmt.Errorf("core: delete history release canceled: %w", err)
-	}
-	trimmed := strings.TrimSpace(sourcePath)
-	if trimmed == "" {
-		return internalerrors.ErrInvalidInput
-	}
-	if c.repo == nil {
-		return errors.New("core: repository not initialized")
-	}
-
-	return c.deleteStoredRelease(ctx, trimmed)
-}
-
-func (c *Core) Close() error {
-	if c == nil || c.repo == nil || !c.ownsRepo {
-		return nil
-	}
-	closer, ok := c.repo.(interface{ Close() error })
-	if !ok {
-		return nil
-	}
-	return wrapCoreError(closer.Close())
-}
-
-func (c *Core) RenderDescription(ctx context.Context, raw string) (string, error) {
-	if err := ctx.Err(); err != nil {
-		return "", fmt.Errorf("core: render description canceled: %w", err)
-	}
-	return description.Render(raw), nil
-}
-
-func (c *Core) SaveDescriptionOverride(ctx context.Context, req api.Request, raw string) (api.DescriptionBuilderGroup, error) {
-	if len(req.Paths) == 0 {
-		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: filesystem service not configured")
-	}
-	if c.repo == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("core: repository not configured")
-	}
+}
 
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
-	if err != nil {
-		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
+// LoadPlaylistSelection returns the selection stored under the source path's
+// normalized slash-delimited database key. It returns
+// [internalerrors.ErrNotFound] when absent.
+func (c *Core) LoadPlaylistSelection(ctx context.Context, sourcePath string) (api.PlaylistSelection, error) {
+	if err := ctx.Err(); err != nil {
+		return api.PlaylistSelection{}, fmt.Errorf("core: load playlist selection canceled: %w", err)
 	}
-
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
+	if strings.TrimSpace(sourcePath) == "" {
+		return api.PlaylistSelection{}, internalerrors.ErrInvalidInput
 	}
-	if len(uniquePaths) != 1 {
-		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
+	if c.selections == nil {
+		return api.PlaylistSelection{}, errors.New("core: repository not initialized")
 	}
 
-	trimmed := strings.TrimSpace(raw)
-	groupKey := strings.TrimSpace(req.DescriptionOverrideGroup)
-	if trimmed == "" {
-		if err := c.repo.DeleteDescriptionOverride(ctx, uniquePaths[0], groupKey); err != nil {
-			return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
-		}
-		req.Paths = []string{uniquePaths[0]}
-		group, err := c.FetchDescriptionBuilderGroupPreview(ctx, req)
-		if err == nil {
-			return group, nil
-		}
+	normalizedPath := filepath.ToSlash(filepath.Clean(sourcePath))
+	c.logger.Debugf("core: loading playlist selection source=%q normalized=%q", sourcePath, normalizedPath)
+
+	selection, err := c.selections.GetPlaylistSelection(ctx, normalizedPath)
+	if err != nil {
 		if errors.Is(err, internalerrors.ErrNotFound) {
-			return api.DescriptionBuilderGroup{
-				GroupKey:    normalizeDescriptionBuilderGroupKey(groupKey, req.Trackers),
-				Trackers:    append([]string{}, req.Trackers...),
-				HasOverride: false,
-			}, nil
+			c.logger.Debugf("core: playlist selection decision=not_found source=%q", sourcePath)
+			return api.PlaylistSelection{}, internalerrors.ErrNotFound
 		}
-		return api.DescriptionBuilderGroup{}, err
+		c.logger.Warnf("core: load playlist selection failed: %v", err)
+		return api.PlaylistSelection{}, fmt.Errorf("core: %w", err)
 	}
 
-	if err := c.repo.SaveDescriptionOverride(ctx, api.DescriptionOverride{
-		SourcePath:  uniquePaths[0],
-		GroupKey:    groupKey,
-		Description: trimmed,
-		UpdatedAt:   time.Now().UTC(),
-	}); err != nil {
-		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
-	}
+	c.logger.Debugf(
+		"core: playlist selection decision=loaded source=%q playlists=%d use_all=%v",
+		sourcePath,
+		len(selection.SelectedPlaylists),
+		selection.UseAll,
+	)
+	return selection, nil
+}
 
-	return api.DescriptionBuilderGroup{
-		GroupKey:           normalizeDescriptionBuilderGroupKey(groupKey, req.Trackers),
-		Trackers:           append([]string{}, req.Trackers...),
-		RawDescription:     trimmed,
-		RawDescriptionHTML: description.Render(trimmed),
-		HasOverride:        true,
-	}, nil
+// ListHistory returns stored releases with their latest display status.
+func (c *Core) ListHistory(ctx context.Context) ([]api.HistoryEntry, error) {
+	return c.history.List(ctx)
 }
 
-func (c *Core) applyDefaultOptions(options api.UploadOptions) (api.UploadOptions, error) {
-	if options.InteractionMode == "" {
-		options.InteractionMode = api.InteractionModeInteractive
-	}
-	if options.Screens <= 0 {
-		options.Screens = c.cfg.ScreenshotHandling.Screens
-	}
-	if !options.OnlyID {
-		options.OnlyID = c.cfg.Metadata.OnlyID
-	}
-	if !options.SkipAutoTorrent {
-		options.SkipAutoTorrent = c.cfg.Metadata.SkipAutoTorrent
-	}
-	if !options.KeepImages {
-		options.KeepImages = c.cfg.Metadata.KeepImages
-	}
-	if options.Screens <= 0 {
-		return api.UploadOptions{}, internalerrors.ErrInvalidInput
-	}
-	return options, nil
+// GetHistoryOverview assembles persisted metadata, overrides, media, tracker
+// state, and upload history for one source path.
+func (c *Core) GetHistoryOverview(ctx context.Context, sourcePath string) (api.HistoryOverview, error) {
+	return c.history.Overview(ctx, sourcePath)
 }
 
-func (c *Core) resolveDescriptionOverrideRequest(ctx context.Context, req api.Request) (api.Request, error) {
-	if strings.TrimSpace(req.DescriptionOverrideRaw) != "" || strings.TrimSpace(req.DescriptionOverrideURL) == "" {
-		return req, nil
-	}
+// DeleteHistoryRelease purges a stored source and related stored child paths,
+// removing only artifacts validated beneath the configured tmp, cache, or nfo
+// roots.
+func (c *Core) DeleteHistoryRelease(ctx context.Context, sourcePath string) error {
+	return c.history.Delete(ctx, sourcePath)
+}
 
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimSpace(req.DescriptionOverrideURL), nil)
-	if err != nil {
-		return api.Request{}, fmt.Errorf("core: description override url: %w", err)
-	}
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.Request{}, fmt.Errorf("core: description override fetch: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return api.Request{}, fmt.Errorf("core: description override fetch: unexpected status %d", resp.StatusCode)
-	}
+// DeleteAllHistoryReleases deletes stored releases sequentially. On cancellation
+// or failure, the returned count includes releases deleted before the error.
+func (c *Core) DeleteAllHistoryReleases(ctx context.Context) (int, error) {
+	return c.history.DeleteAll(ctx)
+}
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return api.Request{}, fmt.Errorf("core: description override read: %w", err)
+// Close closes the repository only when this Core opened and owns it.
+func (c *Core) Close() error {
+	if c == nil {
+		return nil
 	}
-	if strings.TrimSpace(string(body)) == "" {
-		return api.Request{}, errors.New("core: description override fetch returned empty body")
+	if c.repoOwner == nil || !c.ownsRepo {
+		return nil
 	}
+	return wrapCoreError(c.repoOwner.Close())
+}
 
-	req.DescriptionOverrideRaw = string(body)
-	return req, nil
+// RenderDescription renders raw BBCode after rejecting a pre-canceled context.
+func (c *Core) RenderDescription(ctx context.Context, raw string) (string, error) {
+	result, err := c.description.render(ctx, raw)
+	return classifyOperationResult(api.OperationKindDescription, result, err)
 }
 
-func buildMetadataPreview(meta api.PreparedMetadata, cfg config.Config) api.MetadataPreview {
-	warnings := append([]string{}, meta.LookupWarnings...)
-	if notice, ok := metadata.SeasonPackMixedGroupTagNotice(meta); ok {
-		warnings = append(warnings, notice)
-	}
-	return api.MetadataPreview{
-		SourcePath:           meta.SourcePath,
-		TrackerName:          trackerNameForExternalIDs(meta),
-		ReleaseName:          meta.ReleaseName,
-		Warnings:             warnings,
-		ReleaseNameOverrides: meta.ReleaseNameOverrides,
-		ExternalIDs:          meta.ExternalIDs,
-		ExternalIDCandidates: meta.ExternalIDCandidates,
-		ExternalIDInfo:       buildExternalIDInfo(meta.ExternalIDs),
-		ExternalPreview:      buildExternalPreviews(meta.ExternalIDs, meta.ExternalMetadata),
-		Bluray:               deepCopyBlurayMetadata(meta.ExternalMetadata.Bluray),
-		TrackerData:          buildTrackerPreview(meta.TrackerData, cfg),
-		TrackerRuleFailures:  deepCopyTrackerRuleFailures(meta.TrackerRuleFailures),
+// SaveDescriptionOverride stores a trimmed override for one validated source
+// and group. Blank raw content deletes the existing override.
+func (c *Core) SaveDescriptionOverride(ctx context.Context, req api.Request, raw string) (api.DescriptionBuilderGroup, error) {
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentDescription)
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, err
 	}
+	return c.SaveAcceptedDescriptionOverride(ctx, api.DescriptionInput{
+		Release:  ref,
+		Trackers: append([]string(nil), req.Trackers...),
+		GroupKey: req.DescriptionOverrideGroup,
+		Options:  req.Options,
+	}, raw)
 }
 
-func sourceLookupTrackerHasUsableData(meta api.PreparedMetadata) bool {
-	tracker := strings.TrimSpace(meta.SourceLookupTracker)
-	if tracker == "" {
-		return false
-	}
-	for _, record := range meta.TrackerData {
-		if !strings.EqualFold(record.Tracker, tracker) {
-			continue
-		}
-		if record.TMDBID != 0 || record.IMDBID != 0 || record.TVDBID != 0 || record.MALID != 0 {
-			return true
-		}
-		if strings.TrimSpace(record.Description) != "" || len(record.ImageURLs) > 0 {
-			return true
-		}
-	}
-	return false
+// SaveAcceptedDescriptionOverride persists an override scoped to one exact generation.
+func (c *Core) SaveAcceptedDescriptionOverride(
+	ctx context.Context,
+	input api.DescriptionInput,
+	raw string,
+) (api.DescriptionBuilderGroup, error) {
+	result, err := c.description.saveAcceptedOverride(ctx, input, raw)
+	return classifyOperationResult(api.OperationKindDescription, result, err)
 }
 
 func buildTrackerPreview(records []api.TrackerMetadata, cfg config.Config) []api.TrackerPreview {
@@ -4429,236 +1128,6 @@ func buildTrackerPreview(records []api.TrackerMetadata, cfg config.Config) []api
 	return result
 }
 
-func overrideSignature(
-	idOverrides api.ExternalIDOverrides,
-	nameOverrides api.ReleaseNameOverrides,
-	metadataOverrides api.MetadataOverrides,
-	trackerOverrides api.TrackerConfigOverrides,
-	trackerSiteOverrides api.TrackerSiteOverrides,
-	clientOverrides api.ClientOverrides,
-	torrentOverrides api.TorrentOverrides,
-	imageHostOverrides api.ImageHostOverrides,
-	screenshotOverrides ...api.ScreenshotOverrides,
-) string {
-	parts := make([]string, 0, 64)
-	if idOverrides.TMDBID != nil {
-		parts = append(parts, fmt.Sprintf("tmdb=%d", *idOverrides.TMDBID))
-	}
-	if idOverrides.IMDBID != nil {
-		parts = append(parts, fmt.Sprintf("imdb=%d", *idOverrides.IMDBID))
-	}
-	if idOverrides.TVDBID != nil {
-		parts = append(parts, fmt.Sprintf("tvdb=%d", *idOverrides.TVDBID))
-	}
-	if idOverrides.TVmazeID != nil {
-		parts = append(parts, fmt.Sprintf("tvmaze=%d", *idOverrides.TVmazeID))
-	}
-	if idOverrides.MALID != nil {
-		parts = append(parts, fmt.Sprintf("mal=%d", *idOverrides.MALID))
-	}
-	if nameOverrides.Category != nil {
-		parts = append(parts, "category="+strings.TrimSpace(*nameOverrides.Category))
-	}
-	if nameOverrides.Type != nil {
-		parts = append(parts, "type="+strings.TrimSpace(*nameOverrides.Type))
-	}
-	if nameOverrides.Source != nil {
-		parts = append(parts, "source="+strings.TrimSpace(*nameOverrides.Source))
-	}
-	if nameOverrides.Resolution != nil {
-		parts = append(parts, "res="+strings.TrimSpace(*nameOverrides.Resolution))
-	}
-	if nameOverrides.Tag != nil {
-		parts = append(parts, "tag="+strings.TrimSpace(*nameOverrides.Tag))
-	}
-	if nameOverrides.Service != nil {
-		parts = append(parts, "service="+strings.TrimSpace(*nameOverrides.Service))
-	}
-	if nameOverrides.Edition != nil {
-		parts = append(parts, "edition="+strings.TrimSpace(*nameOverrides.Edition))
-	}
-	if nameOverrides.Season != nil {
-		parts = append(parts, "season="+strings.TrimSpace(*nameOverrides.Season))
-	}
-	if nameOverrides.Episode != nil {
-		parts = append(parts, "episode="+strings.TrimSpace(*nameOverrides.Episode))
-	}
-	if nameOverrides.EpisodeTitle != nil {
-		parts = append(parts, "episodeTitle="+strings.TrimSpace(*nameOverrides.EpisodeTitle))
-	}
-	if nameOverrides.ManualYear != nil {
-		parts = append(parts, fmt.Sprintf("manualYear=%d", *nameOverrides.ManualYear))
-	}
-	if nameOverrides.ManualDate != nil {
-		parts = append(parts, "manualDate="+strings.TrimSpace(*nameOverrides.ManualDate))
-	}
-	if nameOverrides.NoSeason != nil {
-		parts = append(parts, fmt.Sprintf("noSeason=%t", *nameOverrides.NoSeason))
-	}
-	if nameOverrides.NoYear != nil {
-		parts = append(parts, fmt.Sprintf("noYear=%t", *nameOverrides.NoYear))
-	}
-	if nameOverrides.NoAKA != nil {
-		parts = append(parts, fmt.Sprintf("noAKA=%t", *nameOverrides.NoAKA))
-	}
-	if nameOverrides.NoTag != nil {
-		parts = append(parts, fmt.Sprintf("noTag=%t", *nameOverrides.NoTag))
-	}
-	if nameOverrides.NoEdition != nil {
-		parts = append(parts, fmt.Sprintf("noEdition=%t", *nameOverrides.NoEdition))
-	}
-	if nameOverrides.NoDub != nil {
-		parts = append(parts, fmt.Sprintf("noDub=%t", *nameOverrides.NoDub))
-	}
-	if nameOverrides.NoDual != nil {
-		parts = append(parts, fmt.Sprintf("noDual=%t", *nameOverrides.NoDual))
-	}
-	if nameOverrides.DualAudio != nil {
-		parts = append(parts, fmt.Sprintf("dualAudio=%t", *nameOverrides.DualAudio))
-	}
-	if nameOverrides.Region != nil {
-		parts = append(parts, "region="+strings.TrimSpace(*nameOverrides.Region))
-	}
-	if metadataOverrides.Distributor != nil {
-		parts = append(parts, "distributor="+strings.TrimSpace(*metadataOverrides.Distributor))
-	}
-	if metadataOverrides.OriginalLanguage != nil {
-		parts = append(parts, "originalLanguage="+strings.TrimSpace(*metadataOverrides.OriginalLanguage))
-	}
-	if metadataOverrides.PersonalRelease != nil {
-		parts = append(parts, fmt.Sprintf("personalRelease=%t", *metadataOverrides.PersonalRelease))
-	}
-	if metadataOverrides.Commentary != nil {
-		parts = append(parts, fmt.Sprintf("commentary=%t", *metadataOverrides.Commentary))
-	}
-	if metadataOverrides.WebDV != nil {
-		parts = append(parts, fmt.Sprintf("webdv=%t", *metadataOverrides.WebDV))
-	}
-	if metadataOverrides.StreamOptimized != nil {
-		parts = append(parts, fmt.Sprintf("stream=%t", *metadataOverrides.StreamOptimized))
-	}
-	if metadataOverrides.Anime != nil {
-		parts = append(parts, fmt.Sprintf("anime=%t", *metadataOverrides.Anime))
-	}
-	if trackerOverrides.Anon != nil {
-		parts = append(parts, fmt.Sprintf("anon=%t", *trackerOverrides.Anon))
-	}
-	if trackerOverrides.Draft != nil {
-		parts = append(parts, fmt.Sprintf("draft=%t", *trackerOverrides.Draft))
-	}
-	if trackerOverrides.ModQ != nil {
-		parts = append(parts, fmt.Sprintf("modq=%t", *trackerOverrides.ModQ))
-	}
-	if trackerOverrides.Channel != nil {
-		parts = append(parts, "channel="+strings.TrimSpace(*trackerOverrides.Channel))
-	}
-	if trackerSiteOverrides.TIK.Foreign != nil {
-		parts = append(parts, fmt.Sprintf("tikForeign=%t", *trackerSiteOverrides.TIK.Foreign))
-	}
-	if trackerSiteOverrides.TIK.Opera != nil {
-		parts = append(parts, fmt.Sprintf("tikOpera=%t", *trackerSiteOverrides.TIK.Opera))
-	}
-	if trackerSiteOverrides.TIK.Asian != nil {
-		parts = append(parts, fmt.Sprintf("tikAsian=%t", *trackerSiteOverrides.TIK.Asian))
-	}
-	if trackerSiteOverrides.TIK.DiscType != nil {
-		parts = append(parts, "tikDiscType="+strings.TrimSpace(*trackerSiteOverrides.TIK.DiscType))
-	}
-	if clientOverrides.Client != nil {
-		parts = append(parts, "client="+strings.TrimSpace(*clientOverrides.Client))
-	}
-	if clientOverrides.QbitCategory != nil {
-		parts = append(parts, "qbitCategory="+strings.TrimSpace(*clientOverrides.QbitCategory))
-	}
-	if clientOverrides.QbitTag != nil {
-		parts = append(parts, "qbitTag="+strings.TrimSpace(*clientOverrides.QbitTag))
-	}
-	if clientOverrides.ForceRecheck != nil {
-		parts = append(parts, fmt.Sprintf("forceRecheck=%t", *clientOverrides.ForceRecheck))
-	}
-	if torrentOverrides.InfoHash != nil {
-		parts = append(parts, "infohash="+strings.ToLower(strings.TrimSpace(*torrentOverrides.InfoHash)))
-	}
-	if torrentOverrides.MaxPieceSizeMiB != nil {
-		parts = append(parts, fmt.Sprintf("maxPieceSizeMiB=%d", *torrentOverrides.MaxPieceSizeMiB))
-	}
-	if torrentOverrides.NoHash != nil {
-		parts = append(parts, fmt.Sprintf("nohash=%t", *torrentOverrides.NoHash))
-	}
-	if torrentOverrides.Rehash != nil {
-		parts = append(parts, fmt.Sprintf("rehash=%t", *torrentOverrides.Rehash))
-	}
-	if imageHostOverrides.PreferredHost != nil {
-		parts = append(parts, "imageHost="+strings.ToLower(strings.TrimSpace(*imageHostOverrides.PreferredHost)))
-	}
-	if imageHostOverrides.SkipUpload != nil {
-		parts = append(parts, fmt.Sprintf("skipImageHostUpload=%t", *imageHostOverrides.SkipUpload))
-	}
-	if len(screenshotOverrides) > 0 {
-		screenshot := screenshotOverrides[0]
-		if len(screenshot.ManualFrames) > 0 {
-			parts = append(parts, fmt.Sprintf("manualFrames=%v", screenshot.ManualFrames))
-		}
-		if len(screenshot.ComparisonPaths) > 0 {
-			parts = append(parts, "comparisonPaths="+strings.Join(screenshot.ComparisonPaths, ","))
-		}
-		if screenshot.ComparisonPrimaryIndex != nil {
-			parts = append(parts, fmt.Sprintf("comparisonPrimaryIndex=%d", *screenshot.ComparisonPrimaryIndex))
-		}
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return strings.Join(parts, "|")
-}
-
-func hasExternalIDOverrides(overrides api.ExternalIDOverrides) bool {
-	return overrides.TMDBID != nil ||
-		overrides.IMDBID != nil ||
-		overrides.TVDBID != nil ||
-		overrides.TVmazeID != nil ||
-		overrides.MALID != nil
-}
-
-func resolveExternalIDSelection(selections map[string]api.ExternalIDSelection, sourcePath string) api.ExternalIDSelection {
-	if len(selections) == 0 {
-		return api.ExternalIDSelection{}
-	}
-	if selected, ok := selections[sourcePath]; ok {
-		return selected
-	}
-	cleaned := filepath.Clean(sourcePath)
-	if selected, ok := selections[cleaned]; ok {
-		return selected
-	}
-	for key, selected := range selections {
-		if filepath.Clean(key) == cleaned {
-			return selected
-		}
-	}
-	return api.ExternalIDSelection{}
-}
-
-func mergeExternalIDOverrides(base api.ExternalIDOverrides, selection api.ExternalIDSelection) api.ExternalIDOverrides {
-	merged := base
-	if selection.TMDBID != nil {
-		merged.TMDBID = selection.TMDBID
-	}
-	if selection.IMDBID != nil {
-		merged.IMDBID = selection.IMDBID
-	}
-	if selection.TVDBID != nil {
-		merged.TVDBID = selection.TVDBID
-	}
-	if selection.TVmazeID != nil {
-		merged.TVmazeID = selection.TVmazeID
-	}
-	if selection.MALID != nil {
-		merged.MALID = selection.MALID
-	}
-	return merged
-}
-
 func trackerTorrentURL(cfg config.Config, tracker string, trackerID string) string {
 	if strings.TrimSpace(tracker) == "" || strings.TrimSpace(trackerID) == "" {
 		return ""
@@ -4704,393 +1173,13 @@ func baseFromAnnounce(announce string) string {
 	return parsed.String()
 }
 
-func buildExternalIDInfo(ids api.ExternalIDs) []api.ExternalIDInfo {
-	result := make([]api.ExternalIDInfo, 0, 5)
-	if ids.IMDBID != 0 {
-		result = append(result, api.ExternalIDInfo{Provider: "imdb", ID: ids.IMDBID, Source: ids.SourceIMDB})
-	}
-	if ids.TMDBID != 0 {
-		result = append(result, api.ExternalIDInfo{Provider: "tmdb", ID: ids.TMDBID, Source: ids.SourceTMDB})
-	}
-	if ids.TVDBID != 0 {
-		result = append(result, api.ExternalIDInfo{Provider: "tvdb", ID: ids.TVDBID, Source: ids.SourceTVDB})
-	}
-	if ids.TVmazeID != 0 {
-		result = append(result, api.ExternalIDInfo{Provider: "tvmaze", ID: ids.TVmazeID, Source: ids.SourceTVmaze})
-	}
-	if ids.MALID != 0 {
-		result = append(result, api.ExternalIDInfo{Provider: "mal", ID: ids.MALID, Source: ids.SourceMAL})
-	}
-	return result
-}
-
-// buildExternalPreviews returns previews only for resolved IDs with matching fetched provider data.
-func buildExternalPreviews(ids api.ExternalIDs, metadata api.ExternalMetadata) []api.ExternalPreview {
-	result := make([]api.ExternalPreview, 0, 4)
-	if ids.IMDBID != 0 && metadata.IMDB != nil {
-		preview := api.ExternalPreview{Provider: "imdb", ID: ids.IMDBID, Source: ids.SourceIMDB}
-		preview.Title = metadata.IMDB.Title
-		preview.Year = metadata.IMDB.Year
-		preview.Overview = metadata.IMDB.Plot
-		preview.PosterURL = metadata.IMDB.Cover
-		preview.IMDBType = metadata.IMDB.Type
-		preview.Rating = metadata.IMDB.Rating
-		preview.RatingCount = metadata.IMDB.RatingCount
-		preview.RuntimeMinutes = metadata.IMDB.RuntimeMinutes
-		preview.Genres = metadata.IMDB.Genres
-		preview.Country = metadata.IMDB.Country
-		preview.IMDB = metadata.IMDB
-		result = append(result, preview)
-	}
-	if ids.TMDBID != 0 && metadata.TMDB != nil {
-		preview := api.ExternalPreview{Provider: "tmdb", ID: ids.TMDBID, Source: ids.SourceTMDB}
-		preview.Title = metadata.TMDB.Title
-		preview.Year = metadata.TMDB.Year
-		preview.Overview = metadata.TMDB.Overview
-		preview.PosterURL = metadata.TMDB.Poster
-		preview.BackdropURL = metadata.TMDB.Backdrop
-		preview.Category = metadata.TMDB.Category
-		preview.OriginalTitle = metadata.TMDB.OriginalTitle
-		preview.ReleaseDate = metadata.TMDB.ReleaseDate
-		preview.FirstAirDate = metadata.TMDB.FirstAirDate
-		preview.LastAirDate = metadata.TMDB.LastAirDate
-		preview.OriginalLanguage = metadata.TMDB.OriginalLanguage
-		preview.TMDBType = metadata.TMDB.TMDBType
-		preview.Runtime = metadata.TMDB.Runtime
-		preview.Genres = metadata.TMDB.Genres
-		preview.Keywords = metadata.TMDB.Keywords
-		preview.YouTube = metadata.TMDB.YouTube
-		preview.IMDBID = metadata.TMDB.IMDBID
-		preview.TVDBID = metadata.TMDB.TVDBID
-		preview.TMDB = metadata.TMDB
-		result = append(result, preview)
-	}
-	if ids.TVDBID != 0 && metadata.TVDB != nil {
-		preview := api.ExternalPreview{Provider: "tvdb", ID: ids.TVDBID, Source: ids.SourceTVDB}
-		preview.Title = metadata.TVDB.Name
-		preview.Year = metadata.TVDB.Year
-		preview.Overview = metadata.TVDB.Overview
-		preview.PosterURL = metadata.TVDB.Poster
-		preview.FirstAirDate = metadata.TVDB.FirstAired
-		preview.TMDBType = metadata.TVDB.Type
-		preview.Country = metadata.TVDB.OriginalCountry
-		preview.OriginalLanguage = metadata.TVDB.OriginalLanguage
-		preview.Genres = metadata.TVDB.Genres
-		preview.TVDBID = metadata.TVDB.TVDBID
-		preview.TVDB = metadata.TVDB
-		result = append(result, preview)
-	}
-	if ids.TVmazeID != 0 && metadata.TVmaze != nil {
-		preview := api.ExternalPreview{Provider: "tvmaze", ID: ids.TVmazeID, Source: ids.SourceTVmaze}
-		preview.Title = metadata.TVmaze.Name
-		preview.Year = yearFromDate(metadata.TVmaze.Premiered)
-		preview.Overview = metadata.TVmaze.Summary
-		preview.PosterURL = metadata.TVmaze.Poster
-		preview.BackdropURL = metadata.TVmaze.Backdrop
-		preview.TMDBType = metadata.TVmaze.Type
-		preview.OriginalLanguage = metadata.TVmaze.Language
-		preview.Runtime = metadata.TVmaze.Runtime
-		preview.Genres = metadata.TVmaze.Genres
-		preview.Rating = metadata.TVmaze.Rating
-		preview.RatingCount = metadata.TVmaze.Weight
-		preview.Country = metadata.TVmaze.Country
-		preview.Premiered = metadata.TVmaze.Premiered
-		preview.IMDBID = metadata.TVmaze.IMDBID
-		preview.TVDBID = metadata.TVmaze.TVDBID
-		preview.TVmaze = metadata.TVmaze
-		result = append(result, preview)
-	}
-	if ids.MALID != 0 && metadata.AniList != nil {
-		preview := api.ExternalPreview{Provider: "mal", ID: ids.MALID, Source: ids.SourceMAL}
-		title := firstNonEmpty(
-			metadata.AniList.TitleEnglish,
-			metadata.AniList.TitleUserPreferred,
-			metadata.AniList.TitleRomaji,
-			metadata.AniList.TitleNative,
-		)
-		preview.Title = title
-		preview.Year = metadata.AniList.SeasonYear
-		preview.Overview = metadata.AniList.Description
-		preview.PosterURL = firstNonEmpty(
-			metadata.AniList.CoverExtraLarge,
-			metadata.AniList.CoverLarge,
-			metadata.AniList.CoverMedium,
-		)
-		preview.BackdropURL = metadata.AniList.BannerImage
-		preview.Category = metadata.AniList.Format
-		preview.OriginalTitle = metadata.AniList.TitleRomaji
-		preview.ReleaseDate = metadata.AniList.StartDate
-		preview.FirstAirDate = metadata.AniList.StartDate
-		preview.LastAirDate = metadata.AniList.EndDate
-		preview.OriginalLanguage = anilistPreviewOriginalLanguage(metadata.AniList)
-		preview.TMDBType = metadata.AniList.Format
-		preview.Runtime = metadata.AniList.Duration
-		preview.Genres = strings.Join(metadata.AniList.Genres, ", ")
-		preview.Rating = float64(metadata.AniList.AverageScore) / 10
-		preview.RatingCount = metadata.AniList.Popularity
-		preview.AniList = metadata.AniList
-		result = append(result, preview)
-	}
-	return result
-}
-
-func anilistPreviewOriginalLanguage(metadata *api.AniListMetadata) string {
-	if metadata == nil {
-		return ""
-	}
-	for _, link := range metadata.ExternalLinks {
-		if language := strings.TrimSpace(link.Language); language != "" {
-			return language
-		}
-	}
-	return ""
-}
-
-// firstNonEmpty returns the first non-blank value after trimming whitespace.
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func trackerNameForExternalIDs(meta api.PreparedMetadata) string {
-	if len(meta.TrackerData) == 0 {
-		return ""
-	}
-	ids := meta.ExternalIDs
-	if ids.SourceTMDB != "tracker" && ids.SourceIMDB != "tracker" && ids.SourceTVDB != "tracker" {
-		return ""
-	}
-	for _, record := range meta.TrackerData {
-		if record.Tracker == "" {
-			continue
-		}
-		if ids.SourceTMDB == "tracker" && record.TMDBID != 0 && record.TMDBID == ids.TMDBID {
-			return record.Tracker
-		}
-		if ids.SourceIMDB == "tracker" && record.IMDBID != 0 && record.IMDBID == ids.IMDBID {
-			return record.Tracker
-		}
-		if ids.SourceTVDB == "tracker" && record.TVDBID != 0 && record.TVDBID == ids.TVDBID {
-			return record.Tracker
-		}
-	}
-	for _, record := range meta.TrackerData {
-		if record.Tracker == "" {
-			continue
-		}
-		if record.TMDBID != 0 || record.IMDBID != 0 || record.TVDBID != 0 {
-			return record.Tracker
-		}
-	}
-	return ""
-}
-
-func yearFromDate(value string) int {
-	if len(value) < 4 {
-		return 0
-	}
-	year, err := strconv.Atoi(value[:4])
-	if err != nil {
-		return 0
-	}
-	return year
-}
-
-func mergeTrackerRemovals(existing []string, additions []string) []string {
-	if len(existing) == 0 && len(additions) == 0 {
-		return nil
-	}
-	merged := make([]string, 0, len(existing)+len(additions))
-	seen := make(map[string]struct{}, len(existing)+len(additions))
-	for _, value := range append(existing, additions...) {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		upper := strings.ToUpper(trimmed)
-		if _, ok := seen[upper]; ok {
-			continue
-		}
-		seen[upper] = struct{}{}
-		merged = append(merged, upper)
-	}
-	return merged
-}
-
-// requestPreparedMetaTrackersRemove returns the removal set that should be used
-// for pre-application explicit-empty checks. Request dupe bypasses are applied
-// first so ignored or skipped matched trackers can still resolve when selected.
-func requestPreparedMetaTrackersRemove(meta api.PreparedMetadata, req api.Request) []string {
-	if req.Options.Debug || req.Options.DryRun {
-		return mergeTrackerRemovals(nil, req.TrackersRemove)
-	}
-	metaRemove, matched := duplicateTrackerStateForRequest(meta, req)
-	remove := mergeTrackerRemovals(req.TrackersRemove, metaRemove)
-	return mergeTrackerRemovals(remove, matched)
-}
-
-// trackerResolutionRemoveForRequest returns the tracker removal set for final
-// tracker resolution. Debug and dry-run modes ignore duplicate/block removal
-// state so artifact and client dry-runs can still cover trackers that passed
-// rules; tracker rule failures remain terminal in every mode.
-func trackerResolutionRemoveForRequest(meta api.PreparedMetadata, req api.Request) []string {
-	if req.Options.Debug || req.Options.DryRun {
-		return mergeTrackerRemovals(nil, req.TrackersRemove)
-	}
-	return meta.TrackersRemove
-}
-
-func dryRunOrDebug(req api.Request) bool {
-	return req.Options.Debug || req.Options.DryRun
-}
-
-// dupeCheckDryRunProcessingMeta clears previous duplicate-match suppression
-// before the dupe service runs for dry-run/debug. Tracker rule failures stay in
-// place so rule-failed trackers remain skipped by the dupe check.
-func dupeCheckDryRunProcessingMeta(meta api.PreparedMetadata) api.PreparedMetadata {
-	meta = deepCopyPreparedMetadata(meta)
-	meta.TrackersRemove = removeReviewedTrackerNames(meta.TrackersRemove, meta.MatchedTrackers)
-	meta.MatchedTrackers = nil
-	meta.BlockedTrackers = removeTrackerDupeBlockReason(meta.BlockedTrackers)
-	meta.CrossSeedTorrents = nil
-	return meta
-}
-
-// trackerDryRunProcessingMeta clears suppressive duplicate/block state for
-// dry-run/debug artifact generation while leaving normal upload processing
-// unchanged. Rule failures stay terminal in every mode; dry-run/debug should
-// only bypass duplicate-hit state so operators can inspect what would have been
-// built for trackers that passed rules.
-func trackerDryRunProcessingMeta(meta api.PreparedMetadata, req api.Request) api.PreparedMetadata {
-	if !req.Options.Debug && !req.Options.DryRun {
-		return meta
-	}
-	meta.BlockedTrackers = nil
-	return meta
-}
-
 func normalizeExecutionRequest(req api.Request) api.Request {
-	if req.Execution.SiteCheck {
-		req.Options.DryRun = true
-	}
 	if strings.TrimSpace(req.Execution.SiteUploadTracker) != "" {
 		req.Trackers = []string{strings.ToUpper(strings.TrimSpace(req.Execution.SiteUploadTracker))}
 	}
 	return req
 }
 
-// resolveCanonicalDescriptionGroups returns request or cached description groups
-// before rebuilding groups from tracker preparation for the selected tracker set.
-// Explicit tracker selections constrain the rebuild and do not fall back to
-// configured defaults when they resolve empty.
-func (c *Core) resolveCanonicalDescriptionGroups(ctx context.Context, meta api.PreparedMetadata, req api.Request) ([]api.DescriptionBuilderGroup, error) {
-	if len(req.DescriptionGroups) > 0 {
-		return api.CloneDescriptionBuilderGroups(req.DescriptionGroups), nil
-	}
-	if len(meta.DescriptionGroups) > 0 {
-		return api.CloneDescriptionBuilderGroups(meta.DescriptionGroups), nil
-	}
-	if c.services.Trackers == nil {
-		return nil, errors.New("core: tracker service not configured")
-	}
-
-	resolvedTrackers, explicitEmpty := resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, trackerResolutionRemoveForRequest(meta, req), c.logger, false, false)
-	if explicitEmpty {
-		return nil, nil
-	}
-	prepMeta := trackerDryRunProcessingMeta(meta, req)
-	prep, err := c.services.Trackers.BuildPreparation(ctx, prepMeta, resolvedTrackers)
-	if err != nil {
-		return nil, fmt.Errorf("core: %w", err)
-	}
-	if len(prep.Descriptions) == 0 {
-		return nil, nil
-	}
-
-	overrideByGroup := make(map[string]api.DescriptionOverride)
-	if c.repo != nil && strings.TrimSpace(meta.SourcePath) != "" {
-		overrides, err := c.repo.ListDescriptionOverridesByPath(ctx, meta.SourcePath)
-		if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
-			return nil, fmt.Errorf("core: description override: %w", err)
-		}
-		for _, override := range overrides {
-			overrideByGroup[normalizeDescriptionBuilderGroupKey(override.GroupKey, nil)] = override
-		}
-	}
-
-	groups := make([]api.DescriptionBuilderGroup, 0, len(prep.Descriptions))
-	for _, entry := range prep.Descriptions {
-		groups = append(groups, buildDescriptionBuilderGroup(entry, overrideByGroup, meta, c.logger))
-	}
-	return groups, nil
-}
-
-func appendPathedDupeResults(summary api.DupeCheckSummary, matchedTrackers []string) api.DupeCheckSummary {
-	const pathedNote = "pathed torrent match found; skipping dupe search"
-
-	if len(matchedTrackers) == 0 && len(summary.Results) == 0 {
-		return summary
-	}
-
-	combinedTrackers := make(map[string]struct{}, len(matchedTrackers))
-	filteredResults := make([]api.DupeCheckResult, 0, len(summary.Results))
-	for _, result := range summary.Results {
-		if hasPathedNote(result.Notes, pathedNote) {
-			for _, tracker := range splitTrackerLabel(result.Tracker) {
-				combinedTrackers[tracker] = struct{}{}
-			}
-			continue
-		}
-		filteredResults = append(filteredResults, result)
-	}
-
-	for _, tracker := range mergeTrackerRemovals(nil, matchedTrackers) {
-		combinedTrackers[tracker] = struct{}{}
-	}
-
-	if len(combinedTrackers) == 0 {
-		summary.Results = filteredResults
-		return summary
-	}
-
-	trackers := make([]string, 0, len(combinedTrackers))
-	for tracker := range combinedTrackers {
-		trackers = append(trackers, tracker)
-	}
-	sort.Strings(trackers)
-
-	filteredResults = append(filteredResults, api.DupeCheckResult{
-		Tracker:   strings.Join(trackers, ", "),
-		HasDupes:  true,
-		Status:    "completed",
-		Notes:     []string{pathedNote},
-		CheckedAt: time.Now().UTC(),
-	})
-	summary.Results = filteredResults
-	return summary
-}
-
-func hasPathedNote(notes []string, pathedNote string) bool {
-	for _, note := range notes {
-		if strings.EqualFold(strings.TrimSpace(note), pathedNote) {
-			return true
-		}
-	}
-	return false
-}
-
-func splitTrackerLabel(value string) []string {
-	if strings.TrimSpace(value) == "" {
-		return nil
-	}
-	return mergeTrackerRemovals(nil, strings.Split(value, ","))
-}
-
 // migrateLegacyCookies performs automatic migration of cookies from file-based storage
 // to the encrypted database. This is called during core initialization if needed.
 func migrateLegacyCookies(ctx context.Context, sqliteDB *sql.DB, dbPath string, logger api.Logger) error {
diff --git a/internal/core/core_test.go b/internal/core/core_test.go
deleted file mode 100644
index 0181232c..00000000
--- a/internal/core/core_test.go
+++ /dev/null
@@ -1,4864 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"errors"
-	"os"
-	"path/filepath"
-	"reflect"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func containsCoreString(values []string, target string) bool {
-	for _, value := range values {
-		if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
-			return true
-		}
-	}
-	return false
-}
-
-func hasUploadProgress(updates []api.UploadProgressUpdate, task string, status string) bool {
-	for _, update := range updates {
-		if update.Task == task && update.Status == status {
-			return true
-		}
-	}
-	return false
-}
-
-func metadataProgressContainsOrdered(updates []api.MetadataProgressUpdate, want []api.MetadataProgressUpdate) bool {
-	if len(want) == 0 {
-		return true
-	}
-	next := 0
-	for _, update := range updates {
-		if update.Phase != want[next].Phase || update.Status != want[next].Status {
-			continue
-		}
-		next++
-		if next == len(want) {
-			return true
-		}
-	}
-	return false
-}
-
-func assertRequiresPreparedMetadata(t *testing.T, err error, path string) {
-	t.Helper()
-	if err == nil {
-		t.Fatalf("expected prepared metadata prerequisite error")
-	}
-	message := err.Error()
-	if !strings.Contains(message, "requires prepared metadata") {
-		t.Fatalf("expected prepared metadata prerequisite error, got %v", err)
-	}
-	if !strings.Contains(message, path) {
-		t.Fatalf("expected prepared metadata prerequisite error to name %q, got %v", path, err)
-	}
-}
-
-func TestFirstRequestedTracker(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		trackers []string
-		want     string
-	}{
-		{name: "nil", trackers: nil, want: ""},
-		{name: "empty first", trackers: []string{"", "BHD"}, want: "BHD"},
-		{name: "whitespace first", trackers: []string{" \t", " HDB "}, want: "HDB"},
-		{name: "all empty", trackers: []string{"", "  "}, want: ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := firstRequestedTracker(tt.trackers); got != tt.want {
-				t.Fatalf("expected %q, got %q", tt.want, got)
-			}
-		})
-	}
-}
-
-func TestEmitPreparedUploadProgressKeepsAggregateTrackerBlank(t *testing.T) {
-	t.Parallel()
-
-	var updates []api.UploadProgressUpdate
-	ctx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) {
-		updates = append(updates, update)
-	})
-
-	emitPreparedUploadProgress(ctx, api.Request{Trackers: []string{"AITHER", "BLU"}}, "/tmp/source", "", "tracker_upload", "running", "Uploading to tracker")
-
-	if len(updates) != 1 {
-		t.Fatalf("expected 1 progress update, got %d", len(updates))
-	}
-	if updates[0].Tracker != "" {
-		t.Fatalf("expected aggregate tracker to stay blank, got %q", updates[0].Tracker)
-	}
-}
-
-func TestEmitPreparedUploadProgressUsesSingleRequestedTracker(t *testing.T) {
-	t.Parallel()
-
-	var updates []api.UploadProgressUpdate
-	ctx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) {
-		updates = append(updates, update)
-	})
-
-	emitPreparedUploadProgress(ctx, api.Request{Trackers: []string{"BLU"}}, "/tmp/source", "", "tracker_upload", "running", "Uploading to tracker")
-
-	if len(updates) != 1 {
-		t.Fatalf("expected 1 progress update, got %d", len(updates))
-	}
-	if updates[0].Tracker != "BLU" {
-		t.Fatalf("expected single tracker progress to carry BLU, got %q", updates[0].Tracker)
-	}
-}
-
-func TestLoadPlaylistSelectionUsesNormalizedSourcePath(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name       string
-		sourcePath string
-	}{
-		{name: "native", sourcePath: filepath.Join("media", "Movie", "BDMV")},
-		{name: "posix", sourcePath: "media/Movie/BDMV"},
-		{name: "windows", sourcePath: `media\Movie\BDMV`},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			normalizedPath := filepath.ToSlash(filepath.Clean(tt.sourcePath))
-			repo := &playlistSelectionRepo{
-				selectionByPath: map[string]db.PlaylistSelection{
-					normalizedPath: {
-						SourcePath:        normalizedPath,
-						SelectedPlaylists: []string{"00001.mpls"},
-					},
-				},
-			}
-			core := &Core{repo: repo, logger: api.NopLogger{}}
-
-			selection, err := core.LoadPlaylistSelection(context.Background(), tt.sourcePath)
-			if err != nil {
-				t.Fatalf("LoadPlaylistSelection: %v", err)
-			}
-			if repo.loadedPath != normalizedPath {
-				t.Fatalf("expected normalized lookup path %q, got %q", normalizedPath, repo.loadedPath)
-			}
-			if len(selection.SelectedPlaylists) != 1 || selection.SelectedPlaylists[0] != "00001.mpls" {
-				t.Fatalf("unexpected playlist selection: %#v", selection)
-			}
-		})
-	}
-}
-
-type playlistSelectionRepo struct {
-	stubRepo
-	loadedPath      string
-	selectionByPath map[string]db.PlaylistSelection
-}
-
-func (r *playlistSelectionRepo) GetPlaylistSelection(_ context.Context, sourcePath string) (db.PlaylistSelection, error) {
-	r.loadedPath = sourcePath
-	selection, ok := r.selectionByPath[sourcePath]
-	if !ok {
-		return db.PlaylistSelection{}, internalerrors.ErrNotFound
-	}
-	return selection, nil
-}
-
-func TestBuildDescriptionBuilderGroupUsesFinalBuiltDescriptionAsRaw(t *testing.T) {
-	t.Parallel()
-
-	group := buildDescriptionBuilderGroup(api.PreparationDescription{
-		GroupKey:        "bhd",
-		Trackers:        []string{"BHD"},
-		RawDescription:  "",
-		Description:     "Generated BHD description",
-		DescriptionHTML: "Generated BHD description",
-	}, nil, api.PreparedMetadata{}, api.NopLogger{})
-
-	if !strings.Contains(group.RawDescriptionHTML, "Generated BHD description") {
-		t.Fatalf("expected generated description to remain in preview html, got %q", group.RawDescriptionHTML)
-	}
-	if group.Description != "Generated BHD description" {
-		t.Fatalf("expected generated description field, got %q", group.Description)
-	}
-	if !strings.Contains(group.DescriptionHTML, "Generated BHD description") {
-		t.Fatalf("expected generated description html, got %q", group.DescriptionHTML)
-	}
-}
-
-func TestBuildDescriptionBuilderGroupKeepsFinalBuiltDescriptionAsRaw(t *testing.T) {
-	t.Parallel()
-
-	group := buildDescriptionBuilderGroup(api.PreparationDescription{
-		GroupKey:    "hdb",
-		Trackers:    []string{"HDB"},
-		Description: "Generated HDB final description",
-	}, map[string]api.DescriptionOverride{
-		"hdb": {Description: "custom override"},
-	}, api.PreparedMetadata{}, api.NopLogger{})
-
-	if group.RawDescription != "Generated HDB final description" {
-		t.Fatalf("expected final built description, got %q", group.RawDescription)
-	}
-	if group.Description != group.RawDescription {
-		t.Fatalf("expected generated description to mirror raw, got %q", group.Description)
-	}
-}
-
-func TestGetHistoryOverviewIncludesGroupedDescriptionOverrides(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "core-history.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		if cerr := repo.Close(); cerr != nil {
-			t.Fatalf("close repo: %v", cerr)
-		}
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	sourcePath := filepath.Join(t.TempDir(), "Example.mkv")
-	updatedAt := time.Now().UTC().Add(-time.Hour)
-	groupedOverride := db.DescriptionOverride{
-		SourcePath:  sourcePath,
-		GroupKey:    "unit3d",
-		Description: "grouped override",
-		UpdatedAt:   time.Now().UTC(),
-	}
-
-	if err := repo.Save(context.Background(), db.FileMetadata{
-		Path:       sourcePath,
-		Title:      "Example",
-		Source:     "WEB",
-		Resolution: "2160p",
-		UpdatedAt:  updatedAt,
-	}); err != nil {
-		t.Fatalf("save metadata: %v", err)
-	}
-	if err := repo.SaveDescriptionOverride(context.Background(), groupedOverride); err != nil {
-		t.Fatalf("save description override: %v", err)
-	}
-
-	core := &Core{repo: repo, logger: api.NopLogger{}}
-
-	overview, err := core.GetHistoryOverview(context.Background(), sourcePath)
-	if err != nil {
-		t.Fatalf("get history overview: %v", err)
-	}
-	if len(overview.DescriptionOverrides) != 1 {
-		t.Fatalf("expected 1 grouped description override, got %d", len(overview.DescriptionOverrides))
-	}
-	if overview.DescriptionOverrides[0].GroupKey != "unit3d" {
-		t.Fatalf("expected grouped override key to be preserved, got %q", overview.DescriptionOverrides[0].GroupKey)
-	}
-	if overview.DescriptionOverride.GroupKey != "unit3d" {
-		t.Fatalf("expected preferred description override key to be unit3d, got %q", overview.DescriptionOverride.GroupKey)
-	}
-	if overview.DescriptionOverride.Description != "grouped override" {
-		t.Fatalf("expected preferred description override body to be preserved, got %q", overview.DescriptionOverride.Description)
-	}
-}
-
-func TestHistoryStatusLabelsUseBlockingRuleFailuresAcrossListAndOverview(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "history-status.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		if closeErr := repo.Close(); closeErr != nil {
-			t.Fatalf("close repo: %v", closeErr)
-		}
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	tests := []struct {
-		name             string
-		failures         []db.TrackerRuleFailure
-		wantStatus       string
-		wantFailureCount int
-		wantWarningCount int
-	}{
-		{
-			name: "warning only",
-			failures: []db.TrackerRuleFailure{
-				{Rule: "recommended_metadata", Severity: api.RuleFailureSeverityWarning},
-			},
-			wantStatus:       "Stored",
-			wantWarningCount: 1,
-		},
-		{
-			name: "blocking only",
-			failures: []db.TrackerRuleFailure{
-				{Rule: "required_metadata"},
-			},
-			wantStatus:       "Rule Issues",
-			wantFailureCount: 1,
-		},
-		{
-			name: "mixed",
-			failures: []db.TrackerRuleFailure{
-				{Rule: "required_metadata"},
-				{Rule: "recommended_metadata", Severity: api.RuleFailureSeverityWarning},
-			},
-			wantStatus:       "Rule Issues",
-			wantFailureCount: 1,
-			wantWarningCount: 1,
-		},
-	}
-
-	ctx := context.Background()
-	paths := make(map[string]string, len(tests))
-	for idx, tt := range tests {
-		sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026."+strconv.Itoa(idx)+".mkv")
-		paths[tt.name] = sourcePath
-		if err := repo.Save(ctx, db.FileMetadata{
-			Path:       sourcePath,
-			Title:      "Example Release 2026",
-			SourceSize: 1,
-			UpdatedAt:  time.Now().UTC().Add(time.Duration(idx) * time.Second),
-		}); err != nil {
-			t.Fatalf("%s: save metadata: %v", tt.name, err)
-		}
-		if err := repo.SaveTrackerRuleFailures(ctx, sourcePath, "EXAMPLE", tt.failures); err != nil {
-			t.Fatalf("%s: save rule results: %v", tt.name, err)
-		}
-	}
-
-	core := &Core{repo: repo, logger: api.NopLogger{}}
-	entries, err := core.ListHistory(ctx)
-	if err != nil {
-		t.Fatalf("list history: %v", err)
-	}
-	entriesByPath := make(map[string]api.HistoryEntry, len(entries))
-	for _, entry := range entries {
-		entriesByPath[entry.SourcePath] = entry
-	}
-
-	for _, tt := range tests {
-		sourcePath := paths[tt.name]
-		entry, ok := entriesByPath[sourcePath]
-		if !ok {
-			t.Fatalf("%s: history entry missing", tt.name)
-		}
-		if entry.LatestUploadStatus != tt.wantStatus || entry.RuleFailureCount != tt.wantFailureCount || entry.RuleWarningCount != tt.wantWarningCount {
-			t.Fatalf("%s: unexpected list history state: %#v", tt.name, entry)
-		}
-
-		overview, err := core.GetHistoryOverview(ctx, sourcePath)
-		if err != nil {
-			t.Fatalf("%s: get history overview: %v", tt.name, err)
-		}
-		if overview.StatusLabel != tt.wantStatus {
-			t.Fatalf("%s: list status %q differs from overview status %q", tt.name, entry.LatestUploadStatus, overview.StatusLabel)
-		}
-	}
-}
-
-func TestRunUploadMultiplePaths(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	svc := api.ServiceSet{
-		Filesystem: &stubFS{},
-		Metadata:   &stubMeta{},
-		Torrents:   &stubTorrent{},
-		Clients:    &stubClient{},
-		Trackers:   &stubTrackers{},
-	}
-
-	core, err := New(api.CoreDependencies{
-		Config:     config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services:   svc,
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-	core.storeDupeCache("/tmp/b", "", api.PreparedMetadata{SourcePath: "/tmp/b"})
-
-	result, err := core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/b"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if result.UploadedCount != 2 {
-		t.Fatalf("expected 2 uploads, got %d", result.UploadedCount)
-	}
-
-	metaSvc, ok := svc.Metadata.(*stubMeta)
-	if !ok {
-		t.Fatalf("expected metadata service type *stubMeta, got %T", svc.Metadata)
-	}
-	if metaCalls := metaSvc.calls; metaCalls != 0 {
-		t.Fatalf("expected 0 metadata calls, got %d", metaCalls)
-	}
-	trackerSvc, ok := svc.Trackers.(*stubTrackers)
-	if !ok {
-		t.Fatalf("expected tracker service type *stubTrackers, got %T", svc.Trackers)
-	}
-	if trackerCalls := trackerSvc.calls; trackerCalls != 2 {
-		t.Fatalf("expected 2 tracker calls, got %d", trackerCalls)
-	}
-}
-
-func TestRunUploadPreparedReturnsAccumulatedCountWhenContextCancelsBetweenPaths(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	tracker := &stubTrackers{
-		uploadFunc: func(context.Context, api.PreparedMetadata) (api.UploadSummary, error) {
-			cancel()
-			return api.UploadSummary{Uploaded: 1}, nil
-		},
-	}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-	core.storeDupeCache("/tmp/b", "", api.PreparedMetadata{SourcePath: "/tmp/b"})
-
-	result, err := core.RunUploadPrepared(ctx, api.Request{
-		Paths: []string{"/tmp/a", "/tmp/b"},
-		Mode:  api.ModeGUI,
-	})
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected cancellation error, got %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected first path upload to be counted, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected upload to stop before second tracker call, got %d calls", tracker.calls)
-	}
-}
-
-func TestRunUploadPreparedReturnsAccumulatedCountWhenLaterCacheMisses(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/b"},
-		Mode:  api.ModeGUI,
-	})
-	if err == nil || !strings.Contains(err.Error(), "requires prepared metadata") {
-		t.Fatalf("expected prepared metadata error, got %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected first path upload to be counted, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected only first path upload, got %d calls", tracker.calls)
-	}
-}
-
-func TestRunUploadPreparedReturnsAccumulatedCountWhenLaterMenuImportFails(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{}
-	repo := &menuImportRepo{failListOnCall: 2}
-	menuDir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(menuDir, "menu.png"), []byte("synthetic menu image"), 0o600); err != nil {
-		t.Fatalf("write menu image: %v", err)
-	}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: t.TempDir()},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-	core.storeDupeCache("/tmp/b", "", api.PreparedMetadata{SourcePath: "/tmp/b"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/b"},
-		Mode:  api.ModeGUI,
-		ScreenshotOverrides: api.ScreenshotOverrides{
-			MenuPaths: []string{menuDir},
-		},
-	})
-	if err == nil || !strings.Contains(err.Error(), "import menu images failed") {
-		t.Fatalf("expected menu import error, got %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected first path upload to be counted, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected second path to fail before upload, got %d tracker calls", tracker.calls)
-	}
-}
-
-func TestResolveGUICachedPreparedMetaReusesRequestRefreshedCache(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Metadata: metaSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	sourcePath := "/tmp/a"
-	req := api.Request{
-		Paths: []string{sourcePath},
-		Mode:  api.ModeGUI,
-	}
-	core.storeDupeCache(sourcePath, "", api.PreparedMetadata{SourcePath: sourcePath})
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), req, sourcePath); err != nil {
-		t.Fatalf("resolve cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata")
-	}
-	if metaSvc.refreshCalls != 1 {
-		t.Fatalf("expected first lookup to refresh once, got %d", metaSvc.refreshCalls)
-	}
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), req, sourcePath); err != nil {
-		t.Fatalf("resolve cached prepared metadata again: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata on second lookup")
-	}
-	if metaSvc.refreshCalls != 1 {
-		t.Fatalf("expected second lookup to reuse refreshed cache, got %d refreshes", metaSvc.refreshCalls)
-	}
-
-	edition := "Director's Cut"
-	editedReq := req
-	editedReq.ReleaseNameOverrides = api.ReleaseNameOverrides{Edition: &edition}
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), editedReq, sourcePath); err != nil {
-		t.Fatalf("resolve edited cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected fallback cache for edited request")
-	}
-	if metaSvc.refreshCalls != 2 {
-		t.Fatalf("expected edited request to refresh once, got %d refreshes", metaSvc.refreshCalls)
-	}
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), editedReq, sourcePath); err != nil {
-		t.Fatalf("resolve edited cached prepared metadata again: %v", err)
-	} else if !ok {
-		t.Fatal("expected exact edited cache on second lookup")
-	}
-	if metaSvc.refreshCalls != 2 {
-		t.Fatalf("expected repeated edited request to reuse refreshed cache, got %d refreshes", metaSvc.refreshCalls)
-	}
-}
-
-func TestResolveGUICachedPreparedMetaTreatsResolvedTrackerDataAsCacheMatch(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Metadata: metaSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	sourcePath := "/tmp/a"
-	req := api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER", "HDB"},
-	}
-	meta := api.PreparedMetadata{
-		SourcePath:     sourcePath,
-		Paths:          []string{sourcePath},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER", "HDB"},
-		TrackersRemove: []string{"HDB"},
-		TrackerIDs:     map[string]string{"hdb": "123"},
-	}
-	core.storeRefreshedDupeCache(sourcePath, "", meta)
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), req, sourcePath); err != nil {
-		t.Fatalf("resolve cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata")
-	}
-	if metaSvc.refreshCalls != 0 {
-		t.Fatalf("expected resolved tracker data to remain cacheable, got %d refreshes", metaSvc.refreshCalls)
-	}
-}
-
-func TestResolveGUICachedPreparedMetaMatchesTrackerSetIgnoringOrderAndCase(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Metadata: metaSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	sourcePath := "/tmp/a"
-	core.storeRefreshedDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath: sourcePath,
-		Paths:      []string{sourcePath},
-		Mode:       api.ModeGUI,
-		Trackers:   []string{"BLU", "AITHER"},
-	})
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"aither", "blu"},
-	}, sourcePath); err != nil {
-		t.Fatalf("resolve reordered cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata")
-	}
-	if metaSvc.refreshCalls != 0 {
-		t.Fatalf("expected reordered tracker set to reuse cache, got %d refreshes", metaSvc.refreshCalls)
-	}
-}
-
-func TestResolveGUICachedPreparedMetaRefreshesWhenIgnoringDupes(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Metadata: metaSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	sourcePath := "/tmp/a"
-	core.storeRefreshedDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath: sourcePath,
-		Paths:      []string{sourcePath},
-		Mode:       api.ModeGUI,
-		Trackers:   []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonDupe},
-		},
-	})
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths:          []string{sourcePath},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-	}, sourcePath); err != nil {
-		t.Fatalf("resolve ignored-dupe cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata")
-	}
-	if metaSvc.refreshCalls != 1 {
-		t.Fatalf("expected ignored-dupe request to refresh cache once, got %d", metaSvc.refreshCalls)
-	}
-}
-
-func TestResolveGUICachedPreparedMetaAllowsTrackerlessFollowUp(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Metadata: metaSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	sourcePath := "/tmp/a"
-	meta := api.PreparedMetadata{
-		SourcePath: sourcePath,
-		Paths:      []string{sourcePath},
-		Mode:       api.ModeGUI,
-		Trackers:   []string{"AITHER", "HDB"},
-	}
-	core.storeRefreshedDupeCache(sourcePath, "", meta)
-
-	if _, ok, err := core.resolveGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{sourcePath},
-		Mode:  api.ModeGUI,
-	}, sourcePath); err != nil {
-		t.Fatalf("resolve trackerless cached prepared metadata: %v", err)
-	} else if !ok {
-		t.Fatal("expected cached metadata")
-	}
-	if metaSvc.refreshCalls != 0 {
-		t.Fatalf("expected trackerless follow-up to reuse cache, got %d refreshes", metaSvc.refreshCalls)
-	}
-}
-
-func TestRunUploadPreparedDryRunInjectsClientAndSkipsTrackerUpload(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		Options: api.UploadOptions{
-			DryRun: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected 0 uploads, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker not called, got %d", tracker.calls)
-	}
-	if tracker.dryRunCalls != 0 {
-		t.Fatalf("expected tracker dry-run build not called without resolved trackers, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected client called once, got %d", client.calls)
-	}
-	if len(client.injected) != 1 || client.injected[0].Path != "/tmp/file.torrent" {
-		t.Fatalf("expected prepared torrent injection, got %#v", client.injected)
-	}
-}
-
-func TestRunUploadPreparedDryRunInjectsSelectedTrackers(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{
-		{
-			Tracker: "AITHER",
-			Status:  "ready",
-			Files:   []api.TrackerDryRunFile{{Field: "torrent", Path: "/tmp/aither.torrent", Present: true}},
-		},
-		{
-			Tracker: "BLU",
-			Status:  "ready",
-			Files:   []api.TrackerDryRunFile{{Field: "torrent", Path: "/tmp/blu.torrent", Present: true}},
-		},
-	}}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options: api.UploadOptions{
-			DryRun: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker upload not called, got %d", tracker.calls)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected tracker dry-run build called once, got %d", tracker.dryRunCalls)
-	}
-	if len(client.injected) != 2 {
-		t.Fatalf("expected one prepared torrent injection per selected tracker, got %#v", client.injected)
-	}
-	gotTrackers := []string{client.injected[0].Tracker, client.injected[1].Tracker}
-	if !reflect.DeepEqual(gotTrackers, []string{"AITHER", "BLU"}) {
-		t.Fatalf("expected selected tracker names on injected torrents, got %v", gotTrackers)
-	}
-	gotPaths := []string{client.injected[0].Path, client.injected[1].Path}
-	if !reflect.DeepEqual(gotPaths, []string{"/tmp/aither.torrent", "/tmp/blu.torrent"}) {
-		t.Fatalf("expected selected tracker torrent files on injected torrents, got %v", gotPaths)
-	}
-}
-
-func TestRunUploadPreparedDryRunBuildsSelectedTrackersDespiteSuppression(t *testing.T) {
-	t.Parallel()
-
-	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath:      sourcePath,
-		TrackersRemove:  []string{"AITHER"},
-		MatchedTrackers: []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{"AITHER": {api.TrackerBlockReasonDupe}, "BLU": {api.TrackerBlockReasonClaim}},
-	})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options:  api.UploadOptions{DryRun: true},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker upload not called, got %d", tracker.calls)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected tracker dry-run build called once, got %d", tracker.dryRunCalls)
-	}
-	if !reflect.DeepEqual(tracker.lastTrackers, []string{"AITHER", "BLU"}) {
-		t.Fatalf("expected dry-run to process selected trackers despite suppression, got %v", tracker.lastTrackers)
-	}
-	if len(tracker.lastMeta.BlockedTrackers) != 0 {
-		t.Fatalf("expected dry-run metadata to ignore blocks, got %#v", tracker.lastMeta.BlockedTrackers)
-	}
-	if tracker.lastMeta.IgnoreTrackerRuleFailures {
-		t.Fatalf("expected dry-run metadata to preserve rule-failure filtering")
-	}
-}
-
-func TestRunUploadPreparedDebugInjectsClientAndSkipsTrackerUpload(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-		Options: api.UploadOptions{
-			Debug: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected 0 uploads, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker not called, got %d", tracker.calls)
-	}
-	if tracker.dryRunCalls != 0 {
-		t.Fatalf("expected tracker dry-run build not called without resolved trackers, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected client called once, got %d", client.calls)
-	}
-	if len(client.injected) != 1 || client.injected[0].Path != "/tmp/file.torrent" {
-		t.Fatalf("expected prepared torrent injection, got %#v", client.injected)
-	}
-}
-
-func TestRunUploadPreparedSiteCheckForcesDryRun(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		Execution: api.ExecutionOptions{
-			SiteCheck: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected 0 uploads, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker not called, got %d", tracker.calls)
-	}
-	if tracker.dryRunCalls != 0 {
-		t.Fatalf("expected tracker dry-run build not called without resolved trackers, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected client called once, got %d", client.calls)
-	}
-	if len(client.injected) != 1 || client.injected[0].Path != "/tmp/file.torrent" {
-		t.Fatalf("expected prepared torrent injection, got %#v", client.injected)
-	}
-}
-
-func TestRunUploadPreparedDryRunNoSeedSkipsClient(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		Options: api.UploadOptions{
-			DryRun: true,
-			NoSeed: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected 0 uploads, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker not called, got %d", tracker.calls)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected client not called, got %d", client.calls)
-	}
-}
-
-func TestRunUploadNoSeedSkipsClient(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	result, err := core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-		Options: api.UploadOptions{
-			NoSeed: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected 1 upload, got %d", result.UploadedCount)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected tracker called once, got %d", tracker.calls)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected client not called, got %d", client.calls)
-	}
-}
-
-func TestRunUploadPreparedSiteUploadTrackerOverridesTrackers(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-		Execution: api.ExecutionOptions{
-			SiteUploadTracker: "BLU",
-		},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if len(tracker.lastMeta.Trackers) != 1 || tracker.lastMeta.Trackers[0] != "BLU" {
-		t.Fatalf("expected site upload tracker override, got %#v", tracker.lastMeta.Trackers)
-	}
-}
-
-func TestRunUploadPreparedReturnsEmptyWithoutSideEffectsWhenSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	repo := &recordingRepo{}
-	torrent := &recordingTorrent{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Torrents:   torrent,
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath:     "/tmp/a",
-		TrackersRemove: []string{"AITHER"},
-	}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected 0 uploads, got %d", result.UploadedCount)
-	}
-	if torrent.calls != 0 {
-		t.Fatalf("expected torrent creation skipped, got %d calls", torrent.calls)
-	}
-	if tracker.calls != 0 {
-		t.Fatalf("expected tracker upload skipped, got %d calls", tracker.calls)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected client injection skipped, got %d calls", client.calls)
-	}
-	if len(repo.saved) != 0 {
-		t.Fatalf("expected no metadata save, got %d", len(repo.saved))
-	}
-	cached, ok := core.getDupeCache("/tmp/a", "")
-	if !ok {
-		t.Fatal("expected prepared metadata to remain cached")
-	}
-	if !reflect.DeepEqual(cached, prepared) {
-		t.Fatalf("expected cache unchanged, got %#v", cached)
-	}
-}
-
-func TestRunUploadPreparedUploadsIgnoredMatchedTracker(t *testing.T) {
-	t.Parallel()
-
-	torrent := &recordingTorrent{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Torrents:   torrent,
-			Clients:    client,
-			Trackers:   tracker,
-		},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:      "/tmp/a",
-		TrackersRemove:  []string{"AITHER"},
-		MatchedTrackers: []string{"AITHER"},
-	})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:          []string{"/tmp/a"},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected one upload, got %d", result.UploadedCount)
-	}
-	if torrent.calls != 1 {
-		t.Fatalf("expected torrent creation, got %d calls", torrent.calls)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected tracker upload, got %d calls", tracker.calls)
-	}
-	if containsCoreString(tracker.lastMeta.TrackersRemove, "AITHER") {
-		t.Fatalf("expected ignored duplicate removal cleared before upload, got %v", tracker.lastMeta.TrackersRemove)
-	}
-	if containsCoreString(tracker.lastMeta.MatchedTrackers, "AITHER") {
-		t.Fatalf("expected ignored duplicate match cleared before upload, got %v", tracker.lastMeta.MatchedTrackers)
-	}
-}
-
-func TestRunUploadDefaultsScreens(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 5}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if tracker.lastMeta.Options.Screens != 5 {
-		t.Fatalf("expected screens default 5, got %d", tracker.lastMeta.Options.Screens)
-	}
-}
-
-func TestSaveFinalScreenshotSelectionsCLI(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	shots := &recordingScreenshots{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem:  &stubFS{},
-			Metadata:    &stubMeta{},
-			Screenshots: shots,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	images := []api.ScreenshotImage{{Path: "/tmp/a.png"}, {Path: "/tmp/b.png"}}
-	if err := core.SaveFinalScreenshotSelections(context.Background(), api.Request{Paths: []string{"/tmp/a"}, Mode: api.ModeCLI}, images); err != nil {
-		t.Fatalf("save final selections: %v", err)
-	}
-	if shots.calls != 1 {
-		t.Fatalf("expected 1 call, got %d", shots.calls)
-	}
-	if len(shots.lastImages) != 2 {
-		t.Fatalf("expected 2 images, got %d", len(shots.lastImages))
-	}
-
-	if err := core.SaveFinalScreenshotSelections(context.Background(), api.Request{Paths: []string{"/tmp/a"}, Mode: api.ModeCLI}, nil); err != nil {
-		t.Fatalf("clear final selections: %v", err)
-	}
-	if shots.calls != 2 {
-		t.Fatalf("expected 2 calls, got %d", shots.calls)
-	}
-}
-
-func TestNewRejectsZeroScreens(t *testing.T) {
-	t.Parallel()
-
-	_, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 0}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err == nil {
-		t.Fatalf("expected config validation error")
-	}
-	if !strings.Contains(err.Error(), "screenshot_handling.screens") {
-		t.Fatalf("expected screenshot validation error, got %v", err)
-	}
-}
-
-func TestRunUploadDedupesPaths(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if meta.calls != 0 {
-		t.Fatalf("expected 0 metadata calls, got %d", meta.calls)
-	}
-}
-
-func TestRunUploadSkipsPathedSearchWithStoredTrackerData(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   &stubTrackers{},
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped, got %d calls", client.searchCalls)
-	}
-}
-
-func TestRunUploadSkipsPathedSearchWithStoredInfoHash(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				StoredDataFresh: true,
-				StoredInfoHash:  "hash123",
-			}},
-			Torrents: &stubTorrent{},
-			Clients:  client,
-			Trackers: &stubTrackers{},
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped, got %d calls", client.searchCalls)
-	}
-}
-
-func TestRunUploadSkipsPathedSearchWithFreshStoredSnapshot(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				StoredDataFresh: true,
-			}},
-			Torrents: &stubTorrent{},
-			Clients:  client,
-			Trackers: &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped, got %d calls", client.searchCalls)
-	}
-}
-
-func TestFetchMetadataPreviewRunsPathedSearchWithStoredTrackerData(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		InfoHash: "abc123",
-		TrackerIDs: map[string]string{
-			"aither": "111",
-		},
-		FoundTrackerMatch: true,
-		TorrentComments: []api.TorrentMatch{{
-			Hash: "abc123",
-			Name: "Fixture Title 2024 BluRay 1080p DTS x264-FixtureGroup",
-		}},
-		MatchedTrackers: []string{"AITHER"},
-		TorrentPath:     "/downloads/Fixture Title",
-	}}
-	metaSvc := &stubMeta{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    client,
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once for fresh client data, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 1 {
-		t.Fatalf("expected tracker enrichment once, got %d calls", metaSvc.enrichCalls)
-	}
-	if got := metaSvc.enrichMeta.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected fresh AITHER tracker id, got %q", got)
-	}
-	if got := metaSvc.enrichMeta.TrackerIDs["blu"]; got != "" {
-		t.Fatalf("expected stale stored BLU tracker id cleared, got %q", got)
-	}
-	if containsCoreString(metaSvc.enrichMeta.MatchedTrackers, "BLU") {
-		t.Fatalf("expected stale stored BLU match cleared, got %v", metaSvc.enrichMeta.MatchedTrackers)
-	}
-	if !containsCoreString(metaSvc.enrichMeta.TrackersRemove, "AITHER") {
-		t.Fatalf("expected fresh AITHER removal, got %v", metaSvc.enrichMeta.TrackersRemove)
-	}
-}
-
-func TestFetchMetadataPreviewEmitsTrackerClaimsAfterMediaDetails(t *testing.T) {
-	t.Parallel()
-
-	var core *Core
-	metaSvc := &stubMeta{
-		applyTrackerClaims: func(meta api.PreparedMetadata) api.PreparedMetadata {
-			if _, ok := core.getDupeCache("/tmp/a", ""); ok {
-				t.Fatalf("expected metadata cache to be absent before tracker claims complete")
-			}
-			return meta
-		},
-	}
-	var err error
-	core, err = New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    &stubClient{},
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	updates := make([]api.MetadataProgressUpdate, 0)
-	ctx := api.WithMetadataProgressReporter(context.Background(), func(update api.MetadataProgressUpdate) {
-		updates = append(updates, update)
-	})
-	_, err = core.FetchMetadataPreview(ctx, api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if _, ok := core.getDupeCache("/tmp/a", ""); !ok {
-		t.Fatalf("expected metadata cache after completed metadata preview")
-	}
-
-	want := []api.MetadataProgressUpdate{
-		{Phase: "media-details", Status: "completed"},
-		{Phase: "tracker-claims", Status: "running"},
-		{Phase: "tracker-claims", Status: "completed"},
-		{Phase: "complete", Status: "completed"},
-	}
-	if !metadataProgressContainsOrdered(updates, want) {
-		t.Fatalf("expected ordered progress %v in %#v", want, updates)
-	}
-}
-
-func TestFetchMetadataPreviewSkipAutoTorrentSkipsPathedSearch(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    client,
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	preview, err := core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		Options: api.UploadOptions{
-			SkipAutoTorrent: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped, got %d calls", client.searchCalls)
-	}
-	if len(preview.TrackerData) != 0 {
-		t.Fatalf("expected stored tracker metadata ignored, got %#v", preview.TrackerData)
-	}
-}
-
-func TestFetchMetadataPreviewSkipAutoTorrentFromConfigSkipsPathedSearch(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			Metadata:           config.MetadataConfig{SkipAutoTorrent: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    client,
-		},
-		Repository: trackerRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	preview, err := core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped from config, got %d calls", client.searchCalls)
-	}
-	if len(preview.TrackerData) != 0 {
-		t.Fatalf("expected stored tracker metadata ignored, got %#v", preview.TrackerData)
-	}
-}
-
-func TestFetchMetadataPreviewRunsPathedSearchWithFreshStoredSnapshot(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				StoredDataFresh: true,
-			}},
-			Clients: client,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once for tracker presence, got %d calls", client.searchCalls)
-	}
-}
-
-func TestFetchMetadataPreviewUsesPathedTrackerDataWithFreshStoredSnapshot(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		InfoHash: "abc123",
-		TrackerIDs: map[string]string{
-			"aither": "111",
-		},
-		FoundTrackerMatch: true,
-		TorrentComments: []api.TorrentMatch{{
-			Hash: "abc123",
-			Name: "Fixture Title 2024 BluRay 1080p DTS x264-FixtureGroup",
-		}},
-		MatchedTrackers: []string{"AITHER"},
-		TorrentPath:     "/downloads/Fixture Title",
-	}}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		StoredDataFresh: true,
-	}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    client,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 1 {
-		t.Fatalf("expected tracker enrichment once, got %d calls", metaSvc.enrichCalls)
-	}
-	if metaSvc.enrichMeta.StoredDataFresh {
-		t.Fatalf("expected client torrent data to invalidate fresh snapshot for tracker enrichment")
-	}
-	if got := metaSvc.enrichMeta.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected pathed tracker id, got %q", got)
-	}
-	if got := metaSvc.enrichMeta.InfoHash; got != "abc123" {
-		t.Fatalf("expected pathed infohash, got %q", got)
-	}
-	if len(metaSvc.enrichMeta.TorrentComments) != 1 {
-		t.Fatalf("expected pathed torrent comments, got %d", len(metaSvc.enrichMeta.TorrentComments))
-	}
-	if !metaSvc.enrichMeta.FoundTrackerMatch {
-		t.Fatalf("expected tracker match flag")
-	}
-}
-
-func TestFetchMetadataPreviewUsesPathedPieceGuidanceWithFreshStoredSnapshot(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		PieceSizeConstraint: "16MiB",
-		FoundPreferredPiece: "16MiB",
-	}}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		StoredDataFresh: true,
-	}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    client,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 1 {
-		t.Fatalf("expected tracker enrichment once, got %d calls", metaSvc.enrichCalls)
-	}
-	if metaSvc.enrichMeta.StoredDataFresh {
-		t.Fatalf("expected piece guidance to invalidate fresh snapshot for tracker enrichment")
-	}
-	if got := metaSvc.enrichMeta.PieceSizeConstraint; got != "16MiB" {
-		t.Fatalf("expected piece size constraint from pathed search, got %q", got)
-	}
-	if got := metaSvc.enrichMeta.FoundPreferredPiece; got != "16MiB" {
-		t.Fatalf("expected preferred piece from pathed search, got %q", got)
-	}
-	if got := metaSvc.enrichMeta.InfoHash; got != "" {
-		t.Fatalf("expected no infohash required for piece guidance, got %q", got)
-	}
-	if len(metaSvc.enrichMeta.TrackerIDs) != 0 {
-		t.Fatalf("expected no tracker ids required for piece guidance, got %#v", metaSvc.enrichMeta.TrackerIDs)
-	}
-	if len(metaSvc.enrichMeta.TorrentComments) != 0 {
-		t.Fatalf("expected no torrent comments required for piece guidance, got %#v", metaSvc.enrichMeta.TorrentComments)
-	}
-}
-
-func TestApplyPathedTorrentDataAppliesPieceGuidanceOnly(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{StoredDataFresh: true}
-
-	if !applyPathedTorrentData(&meta, api.ClientSearchResult{
-		PieceSizeConstraint: "16MiB",
-		FoundPreferredPiece: "16MiB",
-	}) {
-		t.Fatalf("expected piece guidance to count as pathed torrent data")
-	}
-	if meta.StoredDataFresh {
-		t.Fatalf("expected piece guidance to invalidate stored snapshot")
-	}
-	if meta.PieceSizeConstraint != "16MiB" {
-		t.Fatalf("expected piece constraint copied, got %q", meta.PieceSizeConstraint)
-	}
-	if meta.FoundPreferredPiece != "16MiB" {
-		t.Fatalf("expected preferred piece copied, got %q", meta.FoundPreferredPiece)
-	}
-}
-
-func TestCheckDupesUsesPathedTrackerDataWithFreshStoredSnapshot(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		InfoHash: "abc123",
-		TrackerIDs: map[string]string{
-			"aither": "111",
-		},
-		FoundTrackerMatch: true,
-		TorrentComments: []api.TorrentMatch{{
-			Hash: "abc123",
-			Name: "Fixture Title 2024 BluRay 1080p DTS x264-FixtureGroup",
-		}},
-		MatchedTrackers: []string{"AITHER"},
-	}}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				StoredDataFresh: true,
-			}},
-			Clients: client,
-			Dupes:   dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.CheckDupes(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once, got %d calls", client.searchCalls)
-	}
-	if dupes.lastMeta.StoredDataFresh {
-		t.Fatalf("expected client torrent data to invalidate fresh snapshot for dupe metadata")
-	}
-	if got := dupes.lastMeta.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected pathed tracker id, got %q", got)
-	}
-	if got := dupes.lastMeta.InfoHash; got != "abc123" {
-		t.Fatalf("expected pathed infohash, got %q", got)
-	}
-}
-
-func TestCheckDupesAppliesTrackerClaimsBeforeDupeCheck(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{
-		applyTrackerClaims: func(meta api.PreparedMetadata) api.PreparedMetadata {
-			meta.BlockedTrackers = map[string][]api.TrackerBlockReason{
-				"AITHER": {api.TrackerBlockReasonClaim},
-			}
-			return meta
-		},
-	}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    &stubClient{},
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.CheckDupes(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-		Options: api.UploadOptions{
-			SkipAutoTorrent: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-	if metaSvc.trackerClaimsCalls != 1 {
-		t.Fatalf("expected tracker claims applied once, got %d calls", metaSvc.trackerClaimsCalls)
-	}
-	if got := dupes.lastMeta.BlockedTrackers["AITHER"]; len(got) != 1 || got[0] != api.TrackerBlockReasonClaim {
-		t.Fatalf("expected dupe check to receive claim-blocked metadata, got %#v", dupes.lastMeta.BlockedTrackers)
-	}
-}
-
-func TestCheckDupesReusesCLIMetadataPreviewCache(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		InfoHash:          "abc123",
-		MatchedTrackers:   []string{"AITHER"},
-		FoundTrackerMatch: true,
-		TrackerIDs: map[string]string{
-			"aither": "111",
-		},
-	}}
-	metaSvc := &stubMeta{}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    client,
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	req := api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BHD"},
-		Options: api.UploadOptions{
-			InteractionMode: api.InteractionModeInteractive,
-			Screens:         1,
-		},
-	}
-	if _, err := core.FetchMetadataPreview(context.Background(), req); err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if metaSvc.calls != 1 {
-		t.Fatalf("expected preview to prepare metadata once, got %d calls", metaSvc.calls)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected preview to run pathed search once, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 1 {
-		t.Fatalf("expected preview to enrich tracker data once, got %d calls", metaSvc.enrichCalls)
-	}
-
-	if _, err := core.CheckDupes(context.Background(), req); err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-	if metaSvc.calls != 1 {
-		t.Fatalf("expected cached dupe check to skip metadata prepare, got %d calls", metaSvc.calls)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected cached dupe check to skip pathed search, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 1 {
-		t.Fatalf("expected cached dupe check to skip tracker enrichment, got %d calls", metaSvc.enrichCalls)
-	}
-	if got := dupes.lastMeta.InfoHash; got != "abc123" {
-		t.Fatalf("expected cached infohash, got %q", got)
-	}
-	if got := dupes.lastMeta.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected cached tracker id, got %q", got)
-	}
-	if containsCoreString(dupes.lastTrackers, "AITHER") {
-		t.Fatalf("expected matched tracker excluded from dupe check, got %v", dupes.lastTrackers)
-	}
-	if !containsCoreString(dupes.lastTrackers, "BHD") {
-		t.Fatalf("expected unmatched tracker checked, got %v", dupes.lastTrackers)
-	}
-}
-
-func TestCheckDupesDryRunChecksPreviouslyMatchedTrackers(t *testing.T) {
-	t.Parallel()
-
-	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    &stubClient{},
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath:      sourcePath,
-		MatchedTrackers: []string{"AITHER"},
-		TrackersRemove:  []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonDupe},
-		},
-	})
-
-	summary, err := core.CheckDupes(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BHD"},
-		Options:  api.UploadOptions{DryRun: true},
-	})
-	if err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-	if !containsCoreString(dupes.lastTrackers, "AITHER") || !containsCoreString(dupes.lastTrackers, "BHD") {
-		t.Fatalf("expected dry-run dupe check to include matched and unmatched trackers, got %v", dupes.lastTrackers)
-	}
-	if len(dupes.lastMeta.MatchedTrackers) != 0 {
-		t.Fatalf("expected previous matched trackers cleared for dry-run dupe check, got %#v", dupes.lastMeta.MatchedTrackers)
-	}
-	if got := dupes.lastMeta.BlockedTrackers["AITHER"]; len(got) != 0 {
-		t.Fatalf("expected previous dupe block cleared for dry-run dupe check, got %#v", got)
-	}
-	if len(summary.Results) != 0 {
-		t.Fatalf("expected no synthetic pathed dupe result in dry-run check, got %#v", summary.Results)
-	}
-}
-
-func TestFetchPreparationPreviewUsesCachedClientDataForCachedMeta(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	metaSvc := &stubMeta{}
-	trackerSvc := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Clients:    client,
-			Trackers:   trackerSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	sourcePath := "/tmp/a"
-	core.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath:        sourcePath,
-		Paths:             []string{sourcePath},
-		Mode:              api.ModeGUI,
-		Trackers:          []string{"AITHER", "RF", "BLU"},
-		MatchedTrackers:   []string{"AITHER", "RF"},
-		TrackersRemove:    []string{"AITHER", "RF"},
-		FoundTrackerMatch: true,
-		TrackerIDs: map[string]string{
-			"aither": "111",
-			"rf":     "222",
-		},
-	})
-
-	_, err = core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER", "RF", "BLU"},
-	})
-	if err != nil {
-		t.Fatalf("fetch preparation preview: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected cached preparation to skip fresh client search, got %d calls", client.searchCalls)
-	}
-	if metaSvc.enrichCalls != 0 {
-		t.Fatalf("expected cached preparation to skip tracker enrichment, got %d calls", metaSvc.enrichCalls)
-	}
-	if trackerSvc.prepCalls != 1 {
-		t.Fatalf("expected preparation build once, got %d calls", trackerSvc.prepCalls)
-	}
-	if got := trackerSvc.lastMeta.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected cached AITHER tracker id, got %q", got)
-	}
-	if got := trackerSvc.lastMeta.TrackerIDs["rf"]; got != "222" {
-		t.Fatalf("expected cached RF tracker id, got %q", got)
-	}
-	if !containsCoreString(trackerSvc.lastMeta.MatchedTrackers, "AITHER") {
-		t.Fatalf("expected cached AITHER match, got %v", trackerSvc.lastMeta.MatchedTrackers)
-	}
-	if !containsCoreString(trackerSvc.lastMeta.MatchedTrackers, "RF") {
-		t.Fatalf("expected cached RF match, got %v", trackerSvc.lastMeta.MatchedTrackers)
-	}
-	if !containsCoreString(trackerSvc.lastMeta.TrackersRemove, "AITHER") {
-		t.Fatalf("expected cached AITHER removal, got %v", trackerSvc.lastMeta.TrackersRemove)
-	}
-	if !containsCoreString(trackerSvc.lastMeta.TrackersRemove, "RF") {
-		t.Fatalf("expected cached RF removal, got %v", trackerSvc.lastMeta.TrackersRemove)
-	}
-	if containsCoreString(trackerSvc.lastTrackers, "AITHER") {
-		t.Fatalf("expected matched tracker excluded from preparation, got %v", trackerSvc.lastTrackers)
-	}
-	if containsCoreString(trackerSvc.lastTrackers, "RF") {
-		t.Fatalf("expected RF excluded from preparation, got %v", trackerSvc.lastTrackers)
-	}
-}
-
-func TestCheckDupesRunsPathedSearchWithSourceURLOverride(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{MatchedTrackers: []string{"BLU"}, FoundTrackerMatch: true}}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				SourceLookupActive: true,
-				SourceLookupMode:   "media",
-			}},
-			Clients: client,
-			Dupes:   dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.CheckDupes(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"BLU", "HDB"},
-	})
-	if err != nil {
-		t.Fatalf("check duplicates: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once, got %d calls", client.searchCalls)
-	}
-	for _, tracker := range dupes.lastTrackers {
-		if tracker == "BLU" {
-			t.Fatalf("expected BLU to be removed from dupe check trackers, got %v", dupes.lastTrackers)
-		}
-	}
-}
-
-func TestCheckDupesSkipAutoTorrentSkipsPathedSearch(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    client,
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.CheckDupes(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-		Options: api.UploadOptions{
-			SkipAutoTorrent: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("check duplicates: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped, got %d calls", client.searchCalls)
-	}
-}
-
-func TestCheckDupesSkipAutoTorrentFromConfigSkipsPathedSearch(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			Metadata:           config.MetadataConfig{SkipAutoTorrent: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    client,
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.CheckDupes(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("check duplicates: %v", err)
-	}
-	if client.searchCalls != 0 {
-		t.Fatalf("expected pathed search skipped from config, got %d calls", client.searchCalls)
-	}
-}
-
-func TestAppendPathedDupeResultsCombinesTrackers(t *testing.T) {
-	t.Parallel()
-
-	summary := api.DupeCheckSummary{
-		Results: []api.DupeCheckResult{
-			{Tracker: "ANT", Status: "completed"},
-			{
-				Tracker: "BLU",
-				Status:  "completed",
-				Notes:   []string{"pathed torrent match found; skipping dupe search"},
-			},
-		},
-	}
-
-	updated := appendPathedDupeResults(summary, []string{"AITHER", "BLU", "ANTHELION"})
-
-	if len(updated.Results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(updated.Results))
-	}
-	if updated.Results[0].Tracker != "ANT" {
-		t.Fatalf("expected non-pathed result preserved, got %q", updated.Results[0].Tracker)
-	}
-
-	combined := updated.Results[1]
-	if combined.Tracker != "AITHER, ANTHELION, BLU" {
-		t.Fatalf("expected combined trackers, got %q", combined.Tracker)
-	}
-	if !combined.HasDupes {
-		t.Fatalf("expected combined result to be marked as dupe")
-	}
-	if combined.Status != "completed" {
-		t.Fatalf("expected combined status completed, got %q", combined.Status)
-	}
-	if len(combined.Notes) != 1 || combined.Notes[0] != "pathed torrent match found; skipping dupe search" {
-		t.Fatalf("expected pathed note preserved, got %v", combined.Notes)
-	}
-}
-
-func TestFetchMetadataPreviewRunsPathedSearchWithSourceURLOverride(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{searchResult: api.ClientSearchResult{
-		MatchedTrackers:   []string{"BLU"},
-		FoundTrackerMatch: true,
-		TrackerIDs: map[string]string{
-			"blu": "999",
-		},
-	}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				SourceLookupActive:    true,
-				SourceLookupMode:      "tracker",
-				SourceLookupTracker:   "AITHER",
-				SourceLookupTrackerID: "111",
-				TrackerIDs:            map[string]string{"aither": "111"},
-				MatchedTrackers:       []string{"AITHER"},
-				TrackerData: []api.TrackerMetadata{{
-					Tracker: "AITHER",
-					TMDBID:  100,
-				}},
-			}},
-			Clients: client,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if client.searchCalls != 1 {
-		t.Fatalf("expected pathed search to run once, got %d calls", client.searchCalls)
-	}
-
-	cached, ok := core.getDupeCache("/tmp/a", "")
-	if !ok {
-		t.Fatalf("expected metadata cache entry")
-	}
-	if got := cached.TrackerIDs["aither"]; got != "111" {
-		t.Fatalf("expected source lookup tracker id preserved, got %q", got)
-	}
-	foundBLU := slices.Contains(cached.MatchedTrackers, "BLU")
-	if !foundBLU {
-		t.Fatalf("expected BLU to be tracked as existing in client, got %v", cached.MatchedTrackers)
-	}
-}
-
-func TestRunUploadSkipsInfoHashPersistenceWithoutHistoryMetadata(t *testing.T) {
-	t.Parallel()
-
-	repo := &recordingRepo{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrentWithHash{hash: "hash123"},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if len(repo.saved) != 0 {
-		t.Fatalf("expected no placeholder metadata save, got %d", len(repo.saved))
-	}
-}
-
-func TestRunUploadPersistsInfoHashWithoutClearingHistoryMetadata(t *testing.T) {
-	t.Parallel()
-
-	repo := &recordingRepo{
-		existing: db.FileMetadata{
-			Path:       "/tmp/a",
-			Title:      "Fixture Title",
-			Source:     "BluRay",
-			Resolution: "1080p",
-			Year:       2026,
-		},
-	}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrentWithHash{hash: "hash123"},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUpload(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("run upload: %v", err)
-	}
-	if len(repo.saved) != 1 {
-		t.Fatalf("expected 1 metadata save, got %d", len(repo.saved))
-	}
-	if repo.saved[0].InfoHash != "hash123" {
-		t.Fatalf("expected info hash saved, got %q", repo.saved[0].InfoHash)
-	}
-	if repo.saved[0].Title != "Fixture Title" {
-		t.Fatalf("expected release title preserved, got %q", repo.saved[0].Title)
-	}
-	if repo.saved[0].Source != "BluRay" {
-		t.Fatalf("expected release source preserved, got %q", repo.saved[0].Source)
-	}
-	if repo.saved[0].Resolution != "1080p" {
-		t.Fatalf("expected release resolution preserved, got %q", repo.saved[0].Resolution)
-	}
-}
-
-func TestExportGUICachedPreparedMetaExactSignature(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath:           "/tmp/a",
-		ReleaseNameOverrides: api.ReleaseNameOverrides{Edition: new("Exact Match")},
-	}
-	req := api.Request{
-		Paths:                []string{"/tmp/a"},
-		Mode:                 api.ModeGUI,
-		ReleaseNameOverrides: api.ReleaseNameOverrides{Edition: new("Exact Match")},
-	}
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), req, prepared); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	exported, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), req)
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected cached metadata export to succeed")
-	}
-	if exported.ReleaseNameOverrides.Edition == nil || *exported.ReleaseNameOverrides.Edition != "Exact Match" {
-		t.Fatalf("expected exact-signature metadata, got %#v", exported.ReleaseNameOverrides)
-	}
-}
-
-func TestExportGUICachedPreparedMetaFallsBackForNonExternalSignedOverrides(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a"}
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, prepared); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	exported, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths:                []string{"/tmp/a"},
-		Mode:                 api.ModeGUI,
-		ReleaseNameOverrides: api.ReleaseNameOverrides{Edition: new("Later UI edit")},
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected non-external GUI override to fall back to cached metadata")
-	}
-	if exported.SourcePath != "/tmp/a" {
-		t.Fatalf("expected cached prepared metadata on fallback, got %q", exported.SourcePath)
-	}
-}
-
-func TestCheckDupesGUIFallbackReappliesReleaseOverrides(t *testing.T) {
-	t.Parallel()
-
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Release: api.ReleaseInfo{
-			Title:  "Example",
-			Source: "WEB",
-		},
-	}); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	category := "TV"
-	edition := "Hybrid"
-	if _, err := core.CheckDupes(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		ReleaseNameOverrides: api.ReleaseNameOverrides{
-			Category: &category,
-			Edition:  &edition,
-		},
-	}); err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-
-	if dupes.lastMeta.ReleaseNameOverrides.Category == nil || *dupes.lastMeta.ReleaseNameOverrides.Category != category {
-		t.Fatalf("expected dupe check to receive category override, got %#v", dupes.lastMeta.ReleaseNameOverrides)
-	}
-	if dupes.lastMeta.ReleaseNameOverrides.Edition == nil || *dupes.lastMeta.ReleaseNameOverrides.Edition != edition {
-		t.Fatalf("expected dupe check to receive edition override, got %#v", dupes.lastMeta.ReleaseNameOverrides)
-	}
-}
-
-func TestCheckDupesGUIExplicitTrackersDoNotMergeDefaults(t *testing.T) {
-	t.Parallel()
-
-	dupes := &stubDupes{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings: config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{
-				Screens: 1,
-			},
-			Trackers: config.TrackersConfig{
-				DefaultTrackers: config.CSVList{"BLU", "BHD"},
-			},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"}); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	if _, err := core.CheckDupes(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	}); err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-
-	if got, want := dupes.lastTrackers, []string{"AITHER"}; !slices.Equal(got, want) {
-		t.Fatalf("expected selected tracker only, got %v want %v", got, want)
-	}
-}
-
-func TestExportGUICachedPreparedMetaRequiresExactMatchForExternalOverrides(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"}); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	tmdbID := 1234
-
-	_, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		ExternalIDOverrides: api.ExternalIDOverrides{
-			TMDBID: &tmdbID,
-		},
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if ok {
-		t.Fatal("expected external ID override to require exact cache signature")
-	}
-}
-
-func TestExportGUICachedPreparedMetaReturnsIsolatedCopy(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER", "BLU"},
-		TrackerIDs: map[string]string{"AITHER": "111"},
-		TrackerQuestionnaireAnswers: map[string]map[string]string{
-			"AITHER": {"season": "1"},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "rule_a", Reason: "bad"}},
-		},
-		Release: api.ReleaseInfo{
-			Codec: []string{"x264"},
-		},
-		BDInfo: map[string]any{
-			"playlists": []any{"00001", "00002"},
-		},
-	}
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, prepared); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	exported, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected cached metadata export to succeed")
-	}
-
-	exported.Trackers[0] = "HDB"
-	exported.TrackerIDs["AITHER"] = "222"
-	exported.TrackerQuestionnaireAnswers["AITHER"]["season"] = "2"
-	exported.TrackerRuleFailures["AITHER"][0].Rule = "rule_b"
-	exported.Release.Codec[0] = "x265"
-	exportedPlaylists, ok := exported.BDInfo["playlists"].([]any)
-	if !ok {
-		t.Fatalf("expected exported BDInfo playlists to be []interface{}, got %T", exported.BDInfo["playlists"])
-	}
-	exportedPlaylists[0] = "99999"
-
-	cached, ok := core.getDupeCache("/tmp/a", "")
-	if !ok {
-		t.Fatal("expected cached metadata to remain available")
-	}
-	if cached.Trackers[0] != "AITHER" {
-		t.Fatalf("expected cached trackers to remain isolated, got %#v", cached.Trackers)
-	}
-	if cached.TrackerIDs["AITHER"] != "111" {
-		t.Fatalf("expected cached tracker ids to remain isolated, got %#v", cached.TrackerIDs)
-	}
-	if cached.TrackerQuestionnaireAnswers["AITHER"]["season"] != "1" {
-		t.Fatalf("expected cached questionnaire answers to remain isolated, got %#v", cached.TrackerQuestionnaireAnswers)
-	}
-	if cached.TrackerRuleFailures["AITHER"][0].Rule != "rule_a" {
-		t.Fatalf("expected cached rule failures to remain isolated, got %#v", cached.TrackerRuleFailures)
-	}
-	if cached.Release.Codec[0] != "x264" {
-		t.Fatalf("expected cached release info to remain isolated, got %#v", cached.Release)
-	}
-	cachedPlaylists, ok := cached.BDInfo["playlists"].([]any)
-	if !ok {
-		t.Fatalf("expected cached BDInfo playlists to be []interface{}, got %T", cached.BDInfo["playlists"])
-	}
-	if cachedPlaylists[0] != "00001" {
-		t.Fatalf("expected cached BDInfo to remain isolated, got %#v", cached.BDInfo)
-	}
-}
-
-func TestExportGUICachedPreparedMetaConcurrentCopiesStayIsolated(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER"},
-		TrackerIDs: map[string]string{"AITHER": "111"},
-		TrackerQuestionnaireAnswers: map[string]map[string]string{
-			"AITHER": {"season": "1"},
-		},
-	}); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	for idx := range 16 {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			exported, ok, exportErr := core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-				Paths: []string{"/tmp/a"},
-				Mode:  api.ModeGUI,
-			})
-			if exportErr != nil || !ok {
-				t.Errorf("export gui cached prepared meta: ok=%t err=%v", ok, exportErr)
-				return
-			}
-			exported.Trackers[0] = "TRACKER"
-			exported.TrackerIDs["AITHER"] = "mutated"
-			exported.TrackerQuestionnaireAnswers["AITHER"]["season"] = strconv.Itoa(i)
-		}(idx)
-	}
-	wg.Wait()
-
-	cached, ok := core.getDupeCache("/tmp/a", "")
-	if !ok {
-		t.Fatal("expected cached metadata to remain available")
-	}
-	if cached.Trackers[0] != "AITHER" {
-		t.Fatalf("expected cached trackers unchanged, got %#v", cached.Trackers)
-	}
-	if cached.TrackerIDs["AITHER"] != "111" {
-		t.Fatalf("expected cached tracker ids unchanged, got %#v", cached.TrackerIDs)
-	}
-	if cached.TrackerQuestionnaireAnswers["AITHER"]["season"] != "1" {
-		t.Fatalf("expected cached questionnaire answers unchanged, got %#v", cached.TrackerQuestionnaireAnswers)
-	}
-}
-
-func TestExportGUICachedPreparedMetaHonorsContextCancellation(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	_, ok, err := core.ExportGUICachedPreparedMeta(ctx, api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err == nil {
-		t.Fatal("expected context cancellation error")
-	}
-	if ok {
-		t.Fatal("expected canceled export to report no cached metadata")
-	}
-}
-
-func TestImportPreparedMetadataForGUIHonorsContextCancellation(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	err = core.ImportPreparedMetadataForGUI(ctx, api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"})
-	if err == nil {
-		t.Fatal("expected context cancellation error")
-	}
-	if _, ok := core.getDupeCache("/tmp/a", ""); ok {
-		t.Fatal("expected canceled import not to populate cache")
-	}
-}
-
-func TestExportGUICachedPreparedMetaReturnsFilesystemValidationError(t *testing.T) {
-	t.Parallel()
-
-	wantErr := errors.New("validate boom")
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: stubFS{err: wantErr},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, _, err = core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if !errors.Is(err, wantErr) {
-		t.Fatalf("expected filesystem validation error, got %v", err)
-	}
-}
-
-func TestImportPreparedMetadataForGUIReturnsFilesystemValidationError(t *testing.T) {
-	t.Parallel()
-
-	wantErr := errors.New("validate boom")
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: stubFS{err: wantErr},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	err = core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"})
-	if !errors.Is(err, wantErr) {
-		t.Fatalf("expected filesystem validation error, got %v", err)
-	}
-}
-
-func TestExportGUICachedPreparedMetaAllowsDuplicatePathsResolvingToOne(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: stubFS{normalized: []string{"/tmp/a", "/tmp/a"}},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	if err := core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"}); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-
-	_, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected duplicate normalized paths to resolve to one cache hit")
-	}
-}
-
-func TestImportPreparedMetadataForGUIAllowsDuplicatePathsResolvingToOne(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: stubFS{normalized: []string{"/tmp/a", "/tmp/a"}},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	err = core.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a", "/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, api.PreparedMetadata{SourcePath: "/tmp/a"})
-	if err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-	if _, ok := core.getDupeCache("/tmp/a", ""); !ok {
-		t.Fatal("expected duplicate normalized paths to import one cache entry")
-	}
-}
-
-func TestFetchMetadataPreviewPurgesContentForExternalOverrides(t *testing.T) {
-	t.Parallel()
-
-	repo := &recordingRepo{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    &stubClient{},
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	tmdbID := 123
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-		ExternalIDOverrides: api.ExternalIDOverrides{
-			TMDBID: &tmdbID,
-		},
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if repo.purgeCalls != 1 {
-		t.Fatalf("expected 1 purge call, got %d", repo.purgeCalls)
-	}
-	if len(repo.purgedPaths) != 1 || repo.purgedPaths[0] != "/tmp/a" {
-		t.Fatalf("unexpected purged paths: %v", repo.purgedPaths)
-	}
-}
-
-func TestFetchMetadataPreviewWithoutExternalOverridesDoesNotPurge(t *testing.T) {
-	t.Parallel()
-
-	repo := &recordingRepo{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Clients:    &stubClient{},
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchMetadataPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("fetch metadata preview: %v", err)
-	}
-	if repo.purgeCalls != 0 {
-		t.Fatalf("expected no purge calls, got %d", repo.purgeCalls)
-	}
-}
-
-func TestRunUploadPreparedUsesCachedMetadata(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER"}}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HDB"},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected 1 upload, got %d", result.UploadedCount)
-	}
-	if meta.calls != 0 {
-		t.Fatalf("expected no metadata prepare calls, got %d", meta.calls)
-	}
-	if tracker.calls != 1 {
-		t.Fatalf("expected tracker called once, got %d", tracker.calls)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected client inject called once, got %d", client.calls)
-	}
-	if len(tracker.lastMeta.Trackers) != 1 || tracker.lastMeta.Trackers[0] != "HDB" {
-		t.Fatalf("expected request tracker override applied, got %v", tracker.lastMeta.Trackers)
-	}
-}
-
-func TestRunUploadPreparedUsesOnlySelectedTrackers(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: dryRunPreviewRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"BLU", "AITHER"}})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected 1 upload, got %d", result.UploadedCount)
-	}
-	if !reflect.DeepEqual(tracker.lastMeta.Trackers, []string{"AITHER"}) {
-		t.Fatalf("expected only selected tracker in upload metadata, got %v", tracker.lastMeta.Trackers)
-	}
-}
-
-func TestRunUploadPreparedInjectsEachUploadedTrackerURL(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{
-		summary: api.UploadSummary{
-			Uploaded: 2,
-			UploadedTorrents: []api.UploadedTorrent{
-				{Tracker: "AITHER", DownloadURL: "https://aither.cc/torrent/download/111"},
-				{Tracker: "BLU", DownloadURL: "https://blutopia.cc/torrent/download/222"},
-			},
-		},
-	}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER", "BLU"}}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 2 {
-		t.Fatalf("expected 2 uploads, got %d", result.UploadedCount)
-	}
-	if client.calls != 2 {
-		t.Fatalf("expected client inject called twice, got %d", client.calls)
-	}
-}
-
-func TestRunUploadPreparedPreservesUploadedCountWhenTrackerInjectionFails(t *testing.T) {
-	t.Parallel()
-
-	injectErr := errors.New("inject failed")
-	tracker := &stubTrackers{
-		summary: api.UploadSummary{
-			Uploaded: 2,
-			UploadedTorrents: []api.UploadedTorrent{
-				{Tracker: "AITHER", DownloadURL: "https://aither.cc/torrent/download/111"},
-			},
-		},
-	}
-	client := &stubClient{injectErr: injectErr}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER"}})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if !errors.Is(err, injectErr) {
-		t.Fatalf("expected injection error, got %v", err)
-	}
-	if result.UploadedCount != 2 {
-		t.Fatalf("expected accepted uploads to be counted, got %d", result.UploadedCount)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected one injection attempt, got %d", client.calls)
-	}
-}
-
-func TestRunUploadPreparedPreservesUploadedCountWithCancellationError(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{
-		summary: api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "AITHER",
-				DownloadURL: "https://aither.cc/torrent/download/1234",
-			}},
-		},
-		uploadErr: context.Canceled,
-	}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER"}}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	var progress []api.UploadProgressUpdate
-	ctx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) {
-		progress = append(progress, update)
-	})
-	result, err := core.RunUploadPrepared(ctx, api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected cancellation error, got %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected completed upload to be counted, got %d", result.UploadedCount)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected no tracker artifact injection, got %d calls", client.calls)
-	}
-	if hasUploadProgress(progress, "tracker_upload", "completed") {
-		t.Fatalf("expected canceled tracker upload to skip completed progress, got %#v", progress)
-	}
-	if !hasUploadProgress(progress, "tracker_upload", "failed") {
-		t.Fatalf("expected canceled tracker upload to emit failed progress, got %#v", progress)
-	}
-	if hasUploadProgress(progress, "client_injection", "running") {
-		t.Fatalf("expected canceled tracker artifacts not to start client injection, got %#v", progress)
-	}
-}
-
-func TestRunUploadPreparedPreservesUploadedCountWhenCrossSeedInjectionFails(t *testing.T) {
-	t.Parallel()
-
-	injectErr := errors.New("cross-seed inject failed")
-	tracker := &stubTrackers{summary: api.UploadSummary{Uploaded: 1}}
-	client := &stubClient{injectErr: injectErr}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			PostUpload:         config.PostUploadConfig{CrossSeeding: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER"},
-		CrossSeedTorrents: []api.UploadedTorrent{{
-			Tracker:     "HDB",
-			DownloadURL: "https://hdbits.org/download.php/file?id=333&passkey=abc",
-		}},
-	})
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if !errors.Is(err, injectErr) {
-		t.Fatalf("expected cross-seed injection error, got %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected accepted upload to be counted, got %d", result.UploadedCount)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected one cross-seed injection attempt, got %d", client.calls)
-	}
-}
-
-func TestRunUploadPreparedForwardsTrackerTorrentPath(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{
-		summary: api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "HDB",
-				DownloadURL: "https://hdbits.org/download.php/file?id=333&passkey=abc",
-				TorrentPath: "/tmp/release.hdb.torrent",
-			}},
-		},
-	}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"HDB"}}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected 1 upload, got %d", result.UploadedCount)
-	}
-	if len(client.injected) != 1 {
-		t.Fatalf("expected one injection payload, got %d", len(client.injected))
-	}
-	if client.injected[0].Path != "/tmp/release.hdb.torrent" {
-		t.Fatalf("expected torrent path to be forwarded, got %q", client.injected[0].Path)
-	}
-	if client.injected[0].URL != "https://hdbits.org/download.php/file?id=333&passkey=abc" {
-		t.Fatalf("expected download URL to be forwarded, got %q", client.injected[0].URL)
-	}
-	if client.injected[0].CrossSeed {
-		t.Fatalf("expected uploaded tracker torrent injection to not be marked cross-seed")
-	}
-}
-
-func TestRunUploadPreparedInjectsDupeMatchedCrossSeedTorrents(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{summary: api.UploadSummary{Uploaded: 1}}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			PostUpload:         config.PostUploadConfig{CrossSeeding: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER"},
-		CrossSeedTorrents: []api.UploadedTorrent{{
-			Tracker:     "HDB",
-			DownloadURL: "https://hdbits.org/download.php/file?id=333&passkey=abc",
-		}},
-	}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if result.UploadedCount != 1 {
-		t.Fatalf("expected 1 upload, got %d", result.UploadedCount)
-	}
-	if len(client.injected) != 1 {
-		t.Fatalf("expected one cross-seed injection, got %#v", client.injected)
-	}
-	injected := client.injected[0]
-	if !injected.CrossSeed {
-		t.Fatalf("expected cross-seed injection")
-	}
-	if injected.Tracker != "HDB" {
-		t.Fatalf("expected HDB tracker, got %q", injected.Tracker)
-	}
-	if injected.URL != "https://hdbits.org/download.php/file?id=333&passkey=abc" {
-		t.Fatalf("expected cross-seed download URL, got %q", injected.URL)
-	}
-}
-
-func TestRunUploadPreparedRejectsNegativeUploadSummaryBeforeClientInjection(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	tracker := &stubTrackers{summary: api.UploadSummary{
-		Uploaded: -1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "AITHER",
-			DownloadURL: "https://aither.cc/torrent/download/1234",
-		}},
-	}}
-	client := &stubClient{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			PostUpload:         config.PostUploadConfig{CrossSeeding: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER"},
-		CrossSeedTorrents: []api.UploadedTorrent{{
-			Tracker:     "HDB",
-			DownloadURL: "https://hdbits.org/download.php/file?id=333&passkey=abc",
-		}},
-	}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	result, err := core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err == nil || !strings.Contains(err.Error(), "upload summary invalid: -1") {
-		t.Fatalf("expected invalid upload summary error, got %v", err)
-	}
-	if result.UploadedCount != 0 {
-		t.Fatalf("expected invalid summary not to count uploads, got %d", result.UploadedCount)
-	}
-	if len(client.injected) != 0 {
-		t.Fatalf("expected invalid summary to skip all client injection, got %#v", client.injected)
-	}
-}
-
-func TestRunUploadPreparedRequiresCachedMetadata(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	assertRequiresPreparedMetadata(t, err, "/tmp/a")
-}
-
-func TestFetchTrackerDryRunPreviewUsesCachedMetadata(t *testing.T) {
-	t.Parallel()
-
-	meta := &stubMeta{}
-	client := &stubClient{}
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{{
-		Tracker: "AITHER",
-		Status:  "ready",
-		Files: []api.TrackerDryRunFile{{
-			Field:   "torrent",
-			Path:    "/tmp/aither.torrent",
-			Present: true,
-		}},
-	}}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   meta,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{SourcePath: "/tmp/a", ReleaseName: "Example Movie 2160p WEB-DL DD+ 5.1-GRP"}
-	core.storeDupeCache("/tmp/a", "", prepared)
-
-	preview, err := core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if preview.SourcePath != "/tmp/a" {
-		t.Fatalf("expected source path /tmp/a, got %q", preview.SourcePath)
-	}
-	if meta.calls != 0 {
-		t.Fatalf("expected no metadata prepare calls, got %d", meta.calls)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected 1 dry-run build call, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 1 {
-		t.Fatalf("expected client injection during tracker dry-run preview, got %d", client.calls)
-	}
-	if len(client.injected) != 1 || client.injected[0].Tracker != "AITHER" || client.injected[0].Path != "/tmp/aither.torrent" {
-		t.Fatalf("expected tracker dry-run injection artifact, got %#v", client.injected)
-	}
-}
-
-func TestSanitizeTrackerDryRunEntriesRedactsBridgePayload(t *testing.T) {
-	t.Parallel()
-
-	entries := []api.TrackerDryRunEntry{{
-		Message:  `request failed: Get "https://tracker.example/upload?api_key=policy-secret"`,
-		Endpoint: "https://policy-user:policy-password@tracker.example/upload?api_key=policy-secret",
-		Payload: map[string]string{
-			"api_key":     "policy-secret",
-			"description": "kept",
-		},
-		Files: []api.TrackerDryRunFile{{Field: "torrent", Path: `C:\path\to\Example.Release.2026.1080p-GRP.torrent`, Present: true}},
-		DebugSections: []api.TrackerDryRunDebugSection{{
-			Endpoint: "https://tracker.example/debug?passkey=policy-passkey",
-			Payload:  map[string]string{"auth_key": "policy-auth", "name": "kept"},
-			Files:    []api.TrackerDryRunFile{{Field: "nfo", Path: `/media/releases/Example.Release.2026.1080p-GRP.nfo`, Present: true}},
-		}},
-		ImageHost: api.ImageHostFeedback{Warnings: []api.ImageHostWarning{{
-			Host:    "example",
-			Message: "failed for /media/releases/Example.Release.2026.1080p-GRP.png?token=policy-token",
-		}}},
-	}}
-
-	sanitized := sanitizeTrackerDryRunEntries(entries)
-	if len(sanitized) != 1 {
-		t.Fatal("expected one sanitized dry-run entry")
-	}
-	encoded := sanitized[0].Message + sanitized[0].Endpoint + strings.Join([]string{
-		sanitized[0].Payload["api_key"],
-		sanitized[0].Files[0].Path,
-		sanitized[0].DebugSections[0].Endpoint,
-		sanitized[0].DebugSections[0].Payload["auth_key"],
-		sanitized[0].DebugSections[0].Files[0].Path,
-		sanitized[0].ImageHost.Warnings[0].Message,
-	}, " ")
-	for _, marker := range []string{"policy-secret", "policy-user", "policy-password", "policy-passkey", "policy-auth", "policy-token", `C:\path\to`, "/media/releases/"} {
-		if strings.Contains(encoded, marker) {
-			t.Fatal("expected bridge dry-run payload to omit secrets and local paths")
-		}
-	}
-	if sanitized[0].Payload["description"] != "kept" || sanitized[0].DebugSections[0].Payload["name"] != "kept" {
-		t.Fatal("expected non-sensitive dry-run payload fields preserved")
-	}
-	if entries[0].Payload["api_key"] != "policy-secret" || entries[0].Files[0].Path == sanitized[0].Files[0].Path {
-		t.Fatal("expected sanitizer to clone nested dry-run data")
-	}
-}
-
-func TestRunUploadPreparedDebugDryRunIgnoresCheckBlocksForArtifacts(t *testing.T) {
-	t.Parallel()
-
-	source := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP")
-	aitherTorrent := filepath.Join(t.TempDir(), "aither.torrent")
-	bluTorrent := filepath.Join(t.TempDir(), "blu.torrent")
-	client := &stubClient{}
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{
-		{
-			Tracker: "AITHER",
-			Status:  "ready",
-			Files: []api.TrackerDryRunFile{{
-				Field:   "torrent",
-				Path:    aitherTorrent,
-				Present: true,
-			}},
-		},
-		{
-			Tracker: "BLU",
-			Status:  "ready",
-			Files: []api.TrackerDryRunFile{{
-				Field:   "torrent",
-				Path:    bluTorrent,
-				Present: true,
-			}},
-		},
-	}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache(source, "", api.PreparedMetadata{
-		SourcePath:     source,
-		TrackersRemove: []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonClaim},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "example_rule", Reason: "example reason"}},
-		},
-	})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:    []string{source},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options:  api.UploadOptions{Debug: true},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected one dry-run build, got %d", tracker.dryRunCalls)
-	}
-	if !slices.Equal(tracker.lastTrackers, []string{"AITHER", "BLU"}) {
-		t.Fatalf("expected debug dry-run for all trackers, got %#v", tracker.lastTrackers)
-	}
-	if tracker.lastMeta.IgnoreTrackerRuleFailures {
-		t.Fatalf("expected debug dry-run metadata to preserve rule-failure filtering")
-	}
-	if len(tracker.lastMeta.BlockedTrackers) != 0 {
-		t.Fatalf("expected debug dry-run metadata to ignore tracker blocks, got %#v", tracker.lastMeta.BlockedTrackers)
-	}
-	if got := len(client.injected); got != 2 {
-		t.Fatalf("expected client injection for both debug tracker torrents, got %d", got)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewNoSeedSkipsClient(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{{
-		Tracker: "AITHER",
-		Status:  "ready",
-		Files: []api.TrackerDryRunFile{{
-			Field:   "torrent",
-			Path:    "/tmp/aither.torrent",
-			Present: true,
-		}},
-	}}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-		Options:  api.UploadOptions{NoSeed: true},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected 1 dry-run build call, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected no client injection with no-seed, got %d", client.calls)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewEmitsInjectedTrackerProgress(t *testing.T) {
-	t.Parallel()
-
-	client := &stubClient{}
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{
-		{
-			Tracker: "AITHER",
-			Status:  "ready",
-			Files: []api.TrackerDryRunFile{{
-				Field:   "torrent",
-				Path:    "/tmp/aither.torrent",
-				Present: true,
-			}},
-		},
-		{
-			Tracker: "BLU",
-			Status:  "ready",
-			Files: []api.TrackerDryRunFile{{
-				Field:   "torrent",
-				Path:    "/tmp/blu.torrent",
-				Present: true,
-			}},
-		},
-	}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	var completedTrackers []string
-	ctx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) {
-		if update.Task == "client_injection" && update.Status == "completed" {
-			completedTrackers = append(completedTrackers, update.Tracker)
-		}
-	})
-	_, err = core.FetchTrackerDryRunPreview(ctx, api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER", "BLU"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if got, want := completedTrackers, []string{"AITHER", "BLU"}; !slices.Equal(got, want) {
-		t.Fatalf("expected injected tracker progress %v, got %v", want, got)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewAnnotatesReleaseNameChange(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{{
-		Tracker:     "AITHER",
-		ReleaseName: "Example.Movie.2160p.WEB-DL.DDP5.1-GRP",
-	}}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:  "/tmp/a",
-		ReleaseName: "Example Movie 2160p WEB-DL DD+ 5.1-GRP",
-		Trackers:    []string{"AITHER", "BLU"},
-	})
-
-	preview, err := core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if len(tracker.lastTrackers) != 1 || tracker.lastTrackers[0] != "AITHER" {
-		t.Fatalf("expected dry run for selected tracker only, got %#v", tracker.lastTrackers)
-	}
-	if len(preview.Trackers) != 1 {
-		t.Fatalf("expected one dry-run entry, got %d", len(preview.Trackers))
-	}
-	entry := preview.Trackers[0]
-	if !entry.ReleaseNameChanged {
-		t.Fatalf("expected release name change annotation, got %#v", entry)
-	}
-	if entry.OriginalReleaseName != "Example Movie 2160p WEB-DL DD+ 5.1-GRP" {
-		t.Fatalf("expected original release name, got %q", entry.OriginalReleaseName)
-	}
-	if entry.UploadReleaseName != "Example.Movie.2160p.WEB-DL.DDP5.1-GRP" {
-		t.Fatalf("expected upload release name, got %q", entry.UploadReleaseName)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewPreservesRuleFailuresForArtifacts(t *testing.T) {
-	t.Parallel()
-
-	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath: sourcePath,
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonClaim},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "example_rule", Reason: "example reason"}},
-		},
-	})
-
-	_, err = core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if tracker.lastMeta.IgnoreTrackerRuleFailures {
-		t.Fatalf("expected dry-run metadata to preserve tracker rule failures")
-	}
-	if len(tracker.lastMeta.BlockedTrackers) != 0 {
-		t.Fatalf("expected dry-run metadata to ignore tracker blocks, got %#v", tracker.lastMeta.BlockedTrackers)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewRequiresCachedMetadata(t *testing.T) {
-	t.Parallel()
-
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   &stubTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	_, err = core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	assertRequiresPreparedMetadata(t, err, "/tmp/a")
-}
-
-func TestFetchPreparationPreviewCreatesRuntimeCacheForDryRunReadiness(t *testing.T) {
-	t.Parallel()
-
-	metaSvc := &stubMeta{}
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	req := api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	}
-	if _, err = core.FetchPreparationPreview(context.Background(), req); err != nil {
-		t.Fatalf("fetch preparation preview: %v", err)
-	}
-	if _, ok := core.getDupeCache("/tmp/a", ""); !ok {
-		t.Fatalf("expected preparation preview to store prepared metadata prerequisite")
-	}
-
-	if _, err = core.FetchTrackerDryRunPreview(context.Background(), req); err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if metaSvc.calls != 1 {
-		t.Fatalf("expected dry-run readiness to reuse cached metadata, got %d prepare calls", metaSvc.calls)
-	}
-	if tracker.dryRunCalls != 1 {
-		t.Fatalf("expected one dry-run build call, got %d", tracker.dryRunCalls)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewReturnsEmptyWithoutSideEffectsWhenSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	client := &stubClient{}
-	metaSvc := &stubMeta{}
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{{Tracker: "BLU", Status: "ready"}}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metaSvc,
-			Torrents:   &stubTorrent{},
-			Clients:    client,
-			Trackers:   tracker,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	prepared := api.PreparedMetadata{
-		SourcePath: sourcePath,
-	}
-	core.storeDupeCache(sourcePath, "", prepared)
-
-	preview, err := core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:          []string{sourcePath},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"BLU"},
-		TrackersRemove: []string{"BLU"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if preview.SourcePath != sourcePath {
-		t.Fatalf("expected source path %q, got %q", sourcePath, preview.SourcePath)
-	}
-	if len(preview.Trackers) != 0 {
-		t.Fatalf("expected no dry-run entries, got %#v", preview.Trackers)
-	}
-	if tracker.dryRunCalls != 0 {
-		t.Fatalf("expected no dry-run build call, got %d", tracker.dryRunCalls)
-	}
-	if client.calls != 0 {
-		t.Fatalf("expected no client injection, got %d", client.calls)
-	}
-	if metaSvc.refreshCalls != 0 {
-		t.Fatalf("expected no metadata refresh, got %d", metaSvc.refreshCalls)
-	}
-	cached, ok := core.getDupeCache(sourcePath, "")
-	if !ok {
-		t.Fatal("expected cached prepared metadata")
-	}
-	if !reflect.DeepEqual(cached, prepared) {
-		t.Fatalf("expected cache to remain unchanged, got %#v", cached)
-	}
-}
-
-func TestFetchTrackerDryRunPreviewUsesIgnoredMatchedTracker(t *testing.T) {
-	t.Parallel()
-
-	tracker := &stubTrackers{dryRunEntries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}}}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: dryRunPreviewRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:      "/tmp/a",
-		TrackersRemove:  []string{"AITHER", "BLU"},
-		MatchedTrackers: []string{"AITHER", "BLU"},
-	})
-
-	preview, err := core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:          []string{"/tmp/a"},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("fetch tracker dry-run preview: %v", err)
-	}
-	if len(preview.Trackers) != 1 || preview.Trackers[0].Tracker != "AITHER" {
-		t.Fatalf("expected AITHER dry-run preview, got %#v", preview.Trackers)
-	}
-	if !reflect.DeepEqual(tracker.lastTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected ignored matched tracker without default fallback, got %v", tracker.lastTrackers)
-	}
-	if containsCoreString(tracker.lastMeta.TrackersRemove, "AITHER") || !containsCoreString(tracker.lastMeta.TrackersRemove, "BLU") {
-		t.Fatalf("expected only unignored duplicate removal to remain, got %v", tracker.lastMeta.TrackersRemove)
-	}
-	if containsCoreString(tracker.lastMeta.MatchedTrackers, "AITHER") || !containsCoreString(tracker.lastMeta.MatchedTrackers, "BLU") {
-		t.Fatalf("expected only unignored matched tracker to remain, got %v", tracker.lastMeta.MatchedTrackers)
-	}
-}
-
-func TestRunUploadPreparedPassesRuleFailureOverride(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:                     []string{"/tmp/a"},
-		Mode:                      api.ModeGUI,
-		Trackers:                  []string{"AITHER"},
-		IgnoreTrackerRuleFailures: true,
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if !tracker.lastMeta.IgnoreTrackerRuleFailures {
-		t.Fatalf("expected ignore tracker rule failures flag to be passed to upload")
-	}
-}
-
-func TestRunUploadPreparedFiltersRuleFailuresPerTracker(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubRepo{}
-	tracker := &stubTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Torrents:   &stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   tracker,
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	core.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "rule_a", Reason: "a"}},
-			"BLU":    {{Rule: "rule_b", Reason: "b"}},
-		},
-	})
-
-	_, err = core.RunUploadPrepared(context.Background(), api.Request{
-		Paths:                        []string{"/tmp/a"},
-		Mode:                         api.ModeCLI,
-		Trackers:                     []string{"AITHER", "BLU"},
-		IgnoreTrackerRuleFailuresFor: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("run upload prepared: %v", err)
-	}
-	if _, ok := tracker.lastMeta.TrackerRuleFailures["AITHER"]; ok {
-		t.Fatalf("expected AITHER rule failure removed from prepared meta")
-	}
-	if _, ok := tracker.lastMeta.TrackerRuleFailures["BLU"]; !ok {
-		t.Fatalf("expected BLU rule failure preserved")
-	}
-}
-
-type stubRepo struct{}
-
-type menuImportRepo struct {
-	stubRepo
-	listCalls      int
-	failListOnCall int
-}
-
-func (r *menuImportRepo) ListFinalSelections(context.Context, string) ([]db.ScreenshotFinalSelection, error) {
-	r.listCalls++
-	if r.failListOnCall > 0 && r.listCalls == r.failListOnCall {
-		return nil, errors.New("menu import list failed")
-	}
-	return nil, nil
-}
-
-func (r *menuImportRepo) SaveFinalSelections(context.Context, string, []db.ScreenshotFinalSelection) error {
-	return nil
-}
-
-func (r *menuImportRepo) ReplaceNormalFinalSelections(context.Context, string, []db.ScreenshotFinalSelection) error {
-	return nil
-}
-
-func (r *menuImportRepo) AppendManualMenuScreenshots(context.Context, string, []db.Screenshot, []db.ScreenshotFinalSelection) error {
-	r.listCalls++
-	if r.failListOnCall > 0 && r.listCalls == r.failListOnCall {
-		return errors.New("menu import append failed")
-	}
-	return nil
-}
-
-func (r *menuImportRepo) ReplaceDVDMenuScreenshots(context.Context, string, []db.Screenshot, []db.ScreenshotFinalSelection) ([]string, error) {
-	return nil, nil
-}
-
-func (r *menuImportRepo) DeleteDiscMenuScreenshot(context.Context, string, string) (api.DiscMenuDeleteResult, error) {
-	return api.DiscMenuDeleteResult{}, nil
-}
-
-func (r *menuImportRepo) RestoreDiscMenuScreenshot(context.Context, string, api.DiscMenuDeleteResult) error {
-	return nil
-}
-
-type dryRunPreviewRepo struct {
-	stubRepo
-}
-
-func (dryRunPreviewRepo) SaveTrackerRuleFailures(context.Context, string, string, []db.TrackerRuleFailure) error {
-	return nil
-}
-
-func (stubRepo) GetByPath(context.Context, string) (db.FileMetadata, error) {
-	return db.FileMetadata{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) Save(context.Context, db.FileMetadata) error {
-	return nil
-}
-
-func (stubRepo) GetExternalIDs(context.Context, string) (db.ExternalIDs, error) {
-	return db.ExternalIDs{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveExternalIDs(context.Context, db.ExternalIDs) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetExternalMetadata(context.Context, string) (db.ExternalMetadata, error) {
-	return db.ExternalMetadata{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveExternalMetadata(context.Context, db.ExternalMetadata) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetDVDMediaInfo(context.Context, string) (db.DVDMediaInfo, error) {
-	return db.DVDMediaInfo{}, internalerrors.ErrNotFound
-}
-
-func (stubRepo) SaveDVDMediaInfo(context.Context, db.DVDMediaInfo) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetReleaseNameOverrides(context.Context, string) (db.ReleaseNameOverrides, error) {
-	return db.ReleaseNameOverrides{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveReleaseNameOverrides(context.Context, string, db.ReleaseNameOverrides) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeleteReleaseNameOverrides(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetDescriptionOverride(context.Context, string, string) (db.DescriptionOverride, error) {
-	return db.DescriptionOverride{}, internalerrors.ErrNotImplemented
-}
-func (stubRepo) ListDescriptionOverridesByPath(context.Context, string) ([]db.DescriptionOverride, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveDescriptionOverride(context.Context, db.DescriptionOverride) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeleteDescriptionOverride(context.Context, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListHistoryEntries(context.Context) ([]db.HistoryEntry, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListUploadHistoryByPath(context.Context, string) ([]db.UploadRecord, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListPendingUploads(context.Context) ([]db.UploadRecord, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) CreateUploadRecord(context.Context, db.UploadRecord) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) UpdateLatestUploadRecordStatus(context.Context, string, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveTrackerRuleFailures(context.Context, string, string, []db.TrackerRuleFailure) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListTrackerRuleFailuresByPath(context.Context, string) ([]db.TrackerRuleFailure, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetTrackerTimestamp(context.Context, string) (time.Time, error) {
-	return time.Time{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveTrackerTimestamp(context.Context, db.TrackerTimestamp) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveTrackerMetadata(context.Context, db.TrackerMetadata) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListTrackerMetadataByPath(context.Context, string) ([]db.TrackerMetadata, error) {
-	return nil, nil
-}
-
-func (stubRepo) SaveScreenshot(context.Context, db.Screenshot) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListScreenshotsByPath(context.Context, string) ([]db.Screenshot, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeleteScreenshot(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveFinalSelections(context.Context, string, []db.ScreenshotFinalSelection) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListFinalSelections(context.Context, string) ([]db.ScreenshotFinalSelection, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeleteFinalSelection(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-func (stubRepo) ReplaceScreenshotSlots(context.Context, string, []db.ScreenshotSlot) error {
-	return internalerrors.ErrNotImplemented
-}
-func (stubRepo) ListScreenshotSlotsByPath(context.Context, string) ([]db.ScreenshotSlot, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-func (stubRepo) UpsertScreenshotSlotVariants(context.Context, string, []db.ScreenshotSlotVariant) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SaveUploadedImages(context.Context, string, string, []db.UploadedImageLink) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListUploadedImagesByPath(context.Context, string) ([]db.UploadedImageLink, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeleteUploadedImage(context.Context, string, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) GetPlaylistSelection(context.Context, string) (db.PlaylistSelection, error) {
-	return db.PlaylistSelection{}, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) SavePlaylistSelection(context.Context, string, []string, bool) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) DeletePlaylistSelection(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) ListStoredReleasePaths(context.Context) ([]string, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (stubRepo) PurgeContentData(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-type trackerRepo struct{ stubRepo }
-
-func (trackerRepo) ListTrackerMetadataByPath(context.Context, string) ([]db.TrackerMetadata, error) {
-	return []db.TrackerMetadata{{
-		SourcePath: "/tmp/a",
-		Tracker:    "BLU",
-		TrackerID:  "123",
-		InfoHash:   "hash123",
-		Matched:    true,
-	}}, nil
-}
-
-type recordingRepo struct {
-	saved       []db.FileMetadata
-	existing    db.FileMetadata
-	getErr      error
-	purgeCalls  int
-	purgedPaths []string
-}
-
-func (r *recordingRepo) GetByPath(context.Context, string) (db.FileMetadata, error) {
-	if r.getErr != nil {
-		return db.FileMetadata{}, r.getErr
-	}
-	if strings.TrimSpace(r.existing.Path) != "" {
-		return r.existing, nil
-	}
-	return db.FileMetadata{}, internalerrors.ErrNotFound
-}
-
-func (r *recordingRepo) Save(_ context.Context, metadata db.FileMetadata) error {
-	r.saved = append(r.saved, metadata)
-	return nil
-}
-
-func (r *recordingRepo) GetExternalIDs(context.Context, string) (db.ExternalIDs, error) {
-	return db.ExternalIDs{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveExternalIDs(context.Context, db.ExternalIDs) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) GetExternalMetadata(context.Context, string) (db.ExternalMetadata, error) {
-	return db.ExternalMetadata{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveExternalMetadata(context.Context, db.ExternalMetadata) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) GetDVDMediaInfo(context.Context, string) (db.DVDMediaInfo, error) {
-	return db.DVDMediaInfo{}, internalerrors.ErrNotFound
-}
-
-func (r *recordingRepo) SaveDVDMediaInfo(context.Context, db.DVDMediaInfo) error {
-	return nil
-}
-
-func (r *recordingRepo) GetReleaseNameOverrides(context.Context, string) (db.ReleaseNameOverrides, error) {
-	return db.ReleaseNameOverrides{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveReleaseNameOverrides(context.Context, string, db.ReleaseNameOverrides) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeleteReleaseNameOverrides(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) GetDescriptionOverride(context.Context, string, string) (db.DescriptionOverride, error) {
-	return db.DescriptionOverride{}, internalerrors.ErrNotImplemented
-}
-func (r *recordingRepo) ListDescriptionOverridesByPath(context.Context, string) ([]db.DescriptionOverride, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveDescriptionOverride(context.Context, db.DescriptionOverride) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeleteDescriptionOverride(context.Context, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListHistoryEntries(context.Context) ([]db.HistoryEntry, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListUploadHistoryByPath(context.Context, string) ([]db.UploadRecord, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListPendingUploads(context.Context) ([]db.UploadRecord, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) CreateUploadRecord(context.Context, db.UploadRecord) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) UpdateLatestUploadRecordStatus(context.Context, string, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveTrackerRuleFailures(context.Context, string, string, []db.TrackerRuleFailure) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListTrackerRuleFailuresByPath(context.Context, string) ([]db.TrackerRuleFailure, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) GetTrackerTimestamp(context.Context, string) (time.Time, error) {
-	return time.Time{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveTrackerTimestamp(context.Context, db.TrackerTimestamp) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveTrackerMetadata(context.Context, db.TrackerMetadata) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListTrackerMetadataByPath(context.Context, string) ([]db.TrackerMetadata, error) {
-	return nil, nil
-}
-
-func (r *recordingRepo) SaveScreenshot(context.Context, db.Screenshot) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListScreenshotsByPath(context.Context, string) ([]db.Screenshot, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeleteScreenshot(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveFinalSelections(context.Context, string, []db.ScreenshotFinalSelection) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListFinalSelections(context.Context, string) ([]db.ScreenshotFinalSelection, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeleteFinalSelection(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-func (r *recordingRepo) ReplaceScreenshotSlots(context.Context, string, []db.ScreenshotSlot) error {
-	return internalerrors.ErrNotImplemented
-}
-func (r *recordingRepo) ListScreenshotSlotsByPath(context.Context, string) ([]db.ScreenshotSlot, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-func (r *recordingRepo) UpsertScreenshotSlotVariants(context.Context, string, []db.ScreenshotSlotVariant) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SaveUploadedImages(context.Context, string, string, []db.UploadedImageLink) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListUploadedImagesByPath(context.Context, string) ([]db.UploadedImageLink, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeleteUploadedImage(context.Context, string, string, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) GetPlaylistSelection(context.Context, string) (db.PlaylistSelection, error) {
-	return db.PlaylistSelection{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) SavePlaylistSelection(context.Context, string, []string, bool) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) DeletePlaylistSelection(context.Context, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) ListStoredReleasePaths(context.Context) ([]string, error) {
-	return nil, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingRepo) PurgeContentData(_ context.Context, path string) error {
-	r.purgeCalls++
-	r.purgedPaths = append(r.purgedPaths, path)
-	return nil
-}
-
-type stubFS struct {
-	normalized []string
-	err        error
-}
-
-func (s stubFS) ValidatePaths(_ context.Context, paths []string) ([]string, error) {
-	if s.err != nil {
-		return nil, s.err
-	}
-	if s.normalized != nil {
-		return append([]string(nil), s.normalized...), nil
-	}
-	return paths, nil
-}
-
-type stubMeta struct {
-	calls              int
-	enrichCalls        int
-	refreshCalls       int
-	resolveCalls       int
-	trackerClaimsCalls int
-	options            api.UploadOptions
-	prepared           api.PreparedMetadata
-	enrichMeta         api.PreparedMetadata
-	enriched           api.PreparedMetadata
-	resolved           api.PreparedMetadata
-	// applyTrackerClaims lets tests inject the metadata mutation normally
-	// returned by claim checks.
-	applyTrackerClaims func(api.PreparedMetadata) api.PreparedMetadata
-}
-
-func (s *stubMeta) Prepare(_ context.Context, req api.Request) (api.PreparedMetadata, error) {
-	s.calls++
-	s.options = req.Options
-	meta := api.PreparedMetadata{SourcePath: req.Paths[0], Paths: req.Paths, Mode: req.Mode, Options: req.Options}
-	if s.prepared.SourcePath == "" {
-		s.prepared.SourcePath = req.Paths[0]
-	}
-	if len(s.prepared.Paths) == 0 {
-		s.prepared.Paths = req.Paths
-	}
-	if s.prepared.Mode == "" {
-		s.prepared.Mode = req.Mode
-	}
-	if s.prepared.Options == (api.UploadOptions{}) {
-		s.prepared.Options = req.Options
-	}
-	if s.prepared.SourcePath != "" {
-		meta = s.prepared
-	}
-	return meta, nil
-}
-
-func (s *stubMeta) RefreshPreparedMetadata(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	s.refreshCalls++
-	return meta, nil
-}
-
-func (s *stubMeta) EnrichTrackerData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	s.enrichCalls++
-	s.enrichMeta = meta
-	if strings.TrimSpace(s.enriched.SourcePath) != "" {
-		return s.enriched, nil
-	}
-	return meta, nil
-}
-
-func (s *stubMeta) ApplyMediaInfoIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (s *stubMeta) ApplyArrData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (s *stubMeta) ResolveExternalIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	s.resolveCalls++
-	if strings.TrimSpace(s.resolved.SourcePath) != "" {
-		return s.resolved, nil
-	}
-	return meta, nil
-}
-
-func (s *stubMeta) ApplyMediaDetails(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (s *stubMeta) ApplyTrackerClaims(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	s.trackerClaimsCalls++
-	if s.applyTrackerClaims != nil {
-		return s.applyTrackerClaims(meta), nil
-	}
-	return meta, nil
-}
-
-type recordingScreenshots struct {
-	calls      int
-	lastMeta   api.PreparedMetadata
-	lastImages []api.ScreenshotImage
-}
-
-func (r *recordingScreenshots) Plan(context.Context, api.PreparedMetadata, int) (api.ScreenshotPlan, error) {
-	return api.ScreenshotPlan{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingScreenshots) Capture(context.Context, api.PreparedMetadata, []api.ScreenshotSelection, api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	return api.ScreenshotResult{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingScreenshots) PreviewFrame(context.Context, api.PreparedMetadata, float64) (api.ScreenshotPreview, error) {
-	return api.ScreenshotPreview{}, internalerrors.ErrNotImplemented
-}
-
-func (r *recordingScreenshots) Delete(context.Context, api.PreparedMetadata, string) error {
-	return internalerrors.ErrNotImplemented
-}
-
-func (r *recordingScreenshots) SaveFinalSelections(_ context.Context, meta api.PreparedMetadata, images []api.ScreenshotImage) error {
-	r.calls++
-	r.lastMeta = meta
-	r.lastImages = images
-	return nil
-}
-
-type stubTorrent struct{}
-
-func (stubTorrent) Create(context.Context, api.PreparedMetadata) (api.TorrentResult, error) {
-	return api.TorrentResult{Path: "/tmp/file.torrent"}, nil
-}
-
-type stubTorrentWithHash struct {
-	hash string
-}
-
-func (s *stubTorrentWithHash) Create(context.Context, api.PreparedMetadata) (api.TorrentResult, error) {
-	return api.TorrentResult{Path: "/tmp/file.torrent", InfoHash: s.hash}, nil
-}
-
-type recordingTorrent struct {
-	calls int
-}
-
-func (r *recordingTorrent) Create(context.Context, api.PreparedMetadata) (api.TorrentResult, error) {
-	r.calls++
-	return api.TorrentResult{Path: "/tmp/file.torrent", InfoHash: "hash123"}, nil
-}
-
-type stubClient struct {
-	calls        int
-	searchCalls  int
-	searchResult api.ClientSearchResult
-	searchErr    error
-	injectErr    error
-	injected     []api.TorrentResult
-}
-
-func (s *stubClient) Inject(_ context.Context, _ api.PreparedMetadata, torrent api.TorrentResult) error {
-	s.calls++
-	s.injected = append(s.injected, torrent)
-	if s.injectErr != nil {
-		return s.injectErr
-	}
-	return nil
-}
-
-func (s *stubClient) SearchPathedTorrents(context.Context, api.PreparedMetadata) (api.ClientSearchResult, error) {
-	s.searchCalls++
-	if s.searchErr != nil {
-		return api.ClientSearchResult{}, s.searchErr
-	}
-	return s.searchResult, nil
-}
-
-type stubDupes struct {
-	lastTrackers []string
-	lastMeta     api.PreparedMetadata
-}
-
-func (s *stubDupes) Check(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.DupeCheckSummary, error) {
-	s.lastMeta = meta
-	s.lastTrackers = append([]string{}, trackers...)
-	return api.DupeCheckSummary{}, nil
-}
-
-type stubTrackers struct {
-	calls         int
-	prepCalls     int
-	dryRunCalls   int
-	lastMeta      api.PreparedMetadata
-	lastTrackers  []string
-	dryRunEntries []api.TrackerDryRunEntry
-	summary       api.UploadSummary
-	uploadErr     error
-	uploadFunc    func(context.Context, api.PreparedMetadata) (api.UploadSummary, error)
-}
-
-func (s *stubTrackers) Upload(ctx context.Context, meta api.PreparedMetadata) (api.UploadSummary, error) {
-	s.calls++
-	s.lastMeta = meta
-	if s.uploadFunc != nil {
-		return s.uploadFunc(ctx, meta)
-	}
-	if s.uploadErr != nil {
-		return s.summary, s.uploadErr
-	}
-	if s.summary.Uploaded == 0 {
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{
-				{
-					Tracker:     "AITHER",
-					TorrentID:   "1234",
-					DownloadURL: "https://aither.cc/torrent/download/1234",
-					TorrentURL:  "https://aither.cc/torrents/1234",
-				},
-			},
-		}, nil
-	}
-	return s.summary, nil
-}
-
-func (s *stubTrackers) BuildPreparation(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.PreparationPreview, error) {
-	s.prepCalls++
-	s.lastMeta = meta
-	s.lastTrackers = append([]string{}, trackers...)
-	return api.PreparationPreview{}, nil
-}
-
-func (s *stubTrackers) BuildUploadDryRun(_ context.Context, meta api.PreparedMetadata, trackers []string) ([]api.TrackerDryRunEntry, error) {
-	s.dryRunCalls++
-	s.lastMeta = meta
-	s.lastTrackers = append([]string{}, trackers...)
-	return append([]api.TrackerDryRunEntry{}, s.dryRunEntries...), nil
-}
diff --git a/internal/core/core_test_factory_test.go b/internal/core/core_test_factory_test.go
new file mode 100644
index 00000000..832689a6
--- /dev/null
+++ b/internal/core/core_test_factory_test.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// testCoreOptions describes the dependency snapshot for a package test. The
+// factory intentionally bypasses production config validation and default
+// service construction while preserving the production composition graph.
+type testCoreOptions struct {
+	cfg      config.Config
+	logger   api.Logger
+	services api.ServiceSet
+	repo     any
+	registry *trackers.Registry
+}
+
+func newTestCore(opts testCoreOptions) *Core {
+	logger := opts.logger
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+
+	repositories := api.RepositoryCapabilitiesFrom(opts.repo)
+	core := &Core{logger: logger, selections: repositories.Selections()}
+	core.history = newHistoryModule(repositories.History(), opts.cfg.MainSettings.DBPath, logger)
+	core.description = newDescriptionModule(opts.cfg, logger, opts.services, repositories.Selections(), opts.registry, core.preparedFacts)
+	var mediaRepo mediaRepository
+	if repositories.Trackers() != nil && repositories.Media() != nil {
+		mediaRepo = mediaRepositoryView{TrackerStateRepository: repositories.Trackers(), MediaAssetRepository: repositories.Media()}
+	}
+	core.media = newMediaModule(opts.cfg, logger, opts.services, mediaRepo, opts.registry, core.preparedFacts)
+	core.upload = newUploadModule(
+		opts.cfg,
+		logger,
+		opts.services,
+		repositories.ReleaseState(),
+		repositories.Trackers(),
+		opts.registry,
+		core.preparedFacts,
+		core.description.resolveOverrideRequest,
+		core.description.resolveSubjectGroups,
+		core.ImportAcceptedMenuImages,
+	)
+	core.dupe = newDupeModule(opts.cfg, logger, opts.services, opts.registry, core.preparedFacts)
+	return core
+}
+
+func TestNewTestCoreWiresCanonicalModules(t *testing.T) {
+	t.Parallel()
+
+	core := newTestCore(testCoreOptions{})
+	if core.history == nil || core.description == nil || core.media == nil || core.upload == nil || core.dupe == nil {
+		t.Fatal("test Core composition is incomplete")
+	}
+}
+
+type stubRepo struct{}
+
+func (stubRepo) ListHistoryEntries(context.Context) ([]api.HistoryEntry, error) {
+	return nil, internalerrors.ErrNotImplemented
+}
+
+func (stubRepo) LoadHistoryRecord(context.Context, string) (api.HistoryRecord, error) {
+	return api.HistoryRecord{}, internalerrors.ErrNotImplemented
+}
+
+func (stubRepo) LoadHistoryCleanupSnapshot(context.Context, string) (api.HistoryCleanupSnapshot, error) {
+	return api.HistoryCleanupSnapshot{}, internalerrors.ErrNotImplemented
+}
+
+func (stubRepo) ListStoredReleasePaths(context.Context) ([]string, error) {
+	return nil, internalerrors.ErrNotImplemented
+}
+
+func (stubRepo) PurgeContentData(context.Context, string) error {
+	return internalerrors.ErrNotImplemented
+}
diff --git a/internal/core/description.go b/internal/core/description.go
new file mode 100644
index 00000000..7861fe7f
--- /dev/null
+++ b/internal/core/description.go
@@ -0,0 +1,321 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/description"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// descriptionModule owns description preparation, rendering, override
+// persistence, and canonical group resolution. It borrows all dependencies;
+// Core retains resource lifetime.
+type descriptionModule struct {
+	cfg            config.Config
+	logger         api.Logger
+	trackerService api.TrackerService
+	repo           api.ReleaseSelectionRepository
+	registry       *trackers.Registry
+	preparedFacts  *preparedrelease.Module
+}
+
+func newDescriptionModule(
+	cfg config.Config,
+	logger api.Logger,
+	services api.ServiceSet,
+	repo api.ReleaseSelectionRepository,
+	registry *trackers.Registry,
+	preparedFacts *preparedrelease.Module,
+) *descriptionModule {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &descriptionModule{
+		cfg:            cfg,
+		logger:         logger,
+		trackerService: services.Trackers,
+		repo:           repo,
+		registry:       registry,
+		preparedFacts:  preparedFacts,
+	}
+}
+
+// fetchAcceptedPreview builds editable description groups from one exact
+// prepared generation and operation-owned choices.
+func (m *descriptionModule) fetchAcceptedPreview(ctx context.Context, input api.DescriptionInput) (api.DescriptionBuilderPreview, error) {
+	if m == nil || m.preparedFacts == nil {
+		return api.DescriptionBuilderPreview{}, errors.New("core: canonical preparation is not configured")
+	}
+	if m.trackerService == nil {
+		return api.DescriptionBuilderPreview{}, errors.New("core: tracker service not configured")
+	}
+	subject, err := m.preparedFacts.ResolveUploadSubject(ctx, api.UploadReviewInput{
+		Release:              input.Release,
+		Trackers:             append([]string(nil), input.Trackers...),
+		DescriptionGroups:    api.CloneDescriptionBuilderGroups(input.Groups),
+		ImageHostOverrides:   input.ImageHost,
+		QuestionnaireAnswers: cloneOperationQuestionnaireAnswers(input.QuestionnaireData),
+		Options:              input.Options,
+	})
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, fmt.Errorf("core: resolve upload subject for description preview: %w", err)
+	}
+	resolved, explicitEmpty := resolveTrackersPreservingExplicitEmpty(m.cfg, input.Trackers, nil, m.logger, m.registry, false, false)
+	if explicitEmpty {
+		return api.DescriptionBuilderPreview{SourcePath: subject.SourcePath}, nil
+	}
+	subject.Trackers = resolved
+	prepared, err := m.trackerService.BuildPreparation(ctx, api.NewDescriptionSubject(subject), resolved)
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, fmt.Errorf("core: %w", err)
+	}
+	overrideByGroup, err := m.descriptionOverrides(ctx, subject.SourcePath)
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, err
+	}
+	preview := api.DescriptionBuilderPreview{
+		SourcePath:      subject.SourcePath,
+		ContentFailures: append([]api.TrackerContentFailure(nil), prepared.ContentFailures...),
+	}
+	for _, entry := range prepared.Descriptions {
+		preview.Groups = append(preview.Groups, buildDescriptionBuilderGroup(entry, overrideByGroup))
+	}
+	return preview, nil
+}
+
+func (m *descriptionModule) fetchAcceptedGroupPreview(ctx context.Context, input api.DescriptionInput) (api.DescriptionBuilderGroup, error) {
+	preview, err := m.fetchAcceptedPreview(ctx, input)
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: resolve description subject: %w", err)
+	}
+	target := normalizeDescriptionBuilderGroupKey(input.GroupKey, input.Trackers)
+	if target == "" {
+		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
+	}
+	for _, group := range preview.Groups {
+		if normalizeDescriptionBuilderGroupKey(group.GroupKey, group.Trackers) == target {
+			return group, nil
+		}
+	}
+	return api.DescriptionBuilderGroup{}, internalerrors.ErrNotFound
+}
+
+func (m *descriptionModule) saveAcceptedOverride(
+	ctx context.Context,
+	input api.DescriptionInput,
+	raw string,
+) (api.DescriptionBuilderGroup, error) {
+	if m == nil || m.preparedFacts == nil {
+		return api.DescriptionBuilderGroup{}, errors.New("core: canonical preparation is not configured")
+	}
+	if m.repo == nil {
+		return api.DescriptionBuilderGroup{}, errors.New("core: repository not configured")
+	}
+	subject, err := m.preparedFacts.ResolveDescriptionSubject(ctx, input)
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: resolve description override subject: %w", err)
+	}
+	groupKey := normalizeDescriptionBuilderGroupKey(input.GroupKey, input.Trackers)
+	if groupKey == "" {
+		return api.DescriptionBuilderGroup{}, internalerrors.ErrInvalidInput
+	}
+	trimmed := strings.TrimSpace(raw)
+	if trimmed == "" {
+		if err := m.repo.DeleteDescriptionOverride(ctx, subject.SourcePath, groupKey); err != nil {
+			return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
+		}
+		group, err := m.fetchAcceptedGroupPreview(ctx, input)
+		if err == nil {
+			return group, nil
+		}
+		if errors.Is(err, internalerrors.ErrNotFound) {
+			return api.DescriptionBuilderGroup{GroupKey: groupKey, Trackers: append([]string(nil), input.Trackers...)}, nil
+		}
+		return api.DescriptionBuilderGroup{}, err
+	}
+	if err := m.repo.SaveDescriptionOverride(ctx, api.DescriptionOverride{
+		SourcePath:  subject.SourcePath,
+		GroupKey:    groupKey,
+		Description: trimmed,
+		UpdatedAt:   time.Now().UTC(),
+	}); err != nil {
+		return api.DescriptionBuilderGroup{}, fmt.Errorf("core: %w", err)
+	}
+	return api.DescriptionBuilderGroup{
+		GroupKey:           groupKey,
+		Trackers:           append([]string(nil), input.Trackers...),
+		RawDescription:     trimmed,
+		RawDescriptionHTML: description.Render(trimmed),
+		HasOverride:        true,
+	}, nil
+}
+
+func (m *descriptionModule) descriptionOverrides(ctx context.Context, sourcePath string) (map[string]api.DescriptionOverride, error) {
+	result := make(map[string]api.DescriptionOverride)
+	if m.repo == nil {
+		return result, nil
+	}
+	overrides, err := m.repo.ListDescriptionOverridesByPath(ctx, sourcePath)
+	if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
+		return nil, fmt.Errorf("core: description override: %w", err)
+	}
+	for _, override := range overrides {
+		result[normalizeDescriptionBuilderGroupKey(override.GroupKey, nil)] = override
+	}
+	return result, nil
+}
+
+// buildDescriptionBuilderGroup normalizes prepared description text and HTML,
+// using a persisted override only when prepared content is blank.
+func buildDescriptionBuilderGroup(
+	entry api.PreparationDescription,
+	overrideByGroup map[string]api.DescriptionOverride,
+) api.DescriptionBuilderGroup {
+	groupKey := normalizeDescriptionBuilderGroupKey(entry.GroupKey, entry.Trackers)
+	descriptionText := strings.TrimSpace(entry.Description)
+	if descriptionText == "" {
+		descriptionText = strings.TrimSpace(entry.RawDescription)
+	}
+	descriptionHTML := entry.DescriptionHTML
+	if strings.TrimSpace(descriptionHTML) == "" {
+		descriptionHTML = description.Render(descriptionText)
+	}
+	rawDescription := descriptionText
+	rawDescriptionHTML := descriptionHTML
+	if strings.TrimSpace(rawDescription) == "" {
+		rawDescription = strings.TrimSpace(entry.RawDescription)
+		if strings.TrimSpace(rawDescription) != "" {
+			rawDescriptionHTML = entry.RawDescriptionHTML
+		} else {
+			rawDescriptionHTML = ""
+		}
+	}
+	hasOverride := entry.HasOverride
+	if strings.TrimSpace(rawDescription) == "" {
+		if override, ok := overrideByGroup[groupKey]; ok && strings.TrimSpace(override.Description) != "" {
+			rawDescription = strings.TrimSpace(override.Description)
+			rawDescriptionHTML = description.Render(rawDescription)
+		}
+	}
+	if _, ok := overrideByGroup[groupKey]; ok && strings.TrimSpace(rawDescription) != "" {
+		hasOverride = true
+	}
+	if strings.TrimSpace(rawDescriptionHTML) == "" {
+		rawDescriptionHTML = description.Render(rawDescription)
+	}
+	return api.DescriptionBuilderGroup{
+		GroupKey:           groupKey,
+		Trackers:           append([]string{}, entry.Trackers...),
+		Description:        rawDescription,
+		DescriptionHTML:    rawDescriptionHTML,
+		RawDescription:     rawDescription,
+		RawDescriptionHTML: rawDescriptionHTML,
+		HasOverride:        hasOverride,
+		ImageHost:          entry.ImageHost,
+	}
+}
+
+func normalizeDescriptionBuilderGroupKey(groupKey string, trackersList []string) string {
+	normalized := strings.ToLower(strings.TrimSpace(groupKey))
+	if normalized == "" && len(trackersList) > 0 {
+		normalized = strings.ToLower(strings.TrimSpace(trackersList[0]))
+	}
+	return normalized
+}
+
+func (m *descriptionModule) render(ctx context.Context, raw string) (string, error) {
+	if err := ctx.Err(); err != nil {
+		return "", fmt.Errorf("core: render description canceled: %w", err)
+	}
+	return description.Render(raw), nil
+}
+
+func (m *descriptionModule) resolveOverrideRequest(ctx context.Context, req api.Request) (api.Request, error) {
+	if strings.TrimSpace(req.DescriptionOverrideRaw) != "" || strings.TrimSpace(req.DescriptionOverrideURL) == "" {
+		return req, nil
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimSpace(req.DescriptionOverrideURL), nil)
+	if err != nil {
+		return api.Request{}, fmt.Errorf("core: description override url: %w", err)
+	}
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.Request{}, fmt.Errorf("core: description override fetch: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return api.Request{}, fmt.Errorf("core: description override fetch: unexpected status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return api.Request{}, fmt.Errorf("core: description override read: %w", err)
+	}
+	if strings.TrimSpace(string(body)) == "" {
+		return api.Request{}, errors.New("core: description override fetch returned empty body")
+	}
+
+	req.DescriptionOverrideRaw = string(body)
+	return req, nil
+}
+
+// resolveSubjectGroups builds description groups directly from an exact
+// operation subject. It never imports mutable preparation state.
+func (m *descriptionModule) resolveSubjectGroups(
+	ctx context.Context,
+	subject api.UploadSubject,
+	input api.UploadReviewInput,
+) ([]api.DescriptionBuilderGroup, error) {
+	if len(input.DescriptionGroups) > 0 {
+		return api.CloneDescriptionBuilderGroups(input.DescriptionGroups), nil
+	}
+	if len(subject.DescriptionGroups) > 0 {
+		return api.CloneDescriptionBuilderGroups(subject.DescriptionGroups), nil
+	}
+	if m == nil || m.trackerService == nil {
+		return nil, errors.New("core: tracker service not configured")
+	}
+	if len(subject.Trackers) == 0 {
+		return nil, nil
+	}
+
+	preparation, err := m.trackerService.BuildPreparation(ctx, api.NewDescriptionSubject(subject), subject.Trackers)
+	if err != nil {
+		return nil, fmt.Errorf("core: %w", err)
+	}
+	if len(preparation.Descriptions) == 0 {
+		return nil, nil
+	}
+
+	overrideByGroup := make(map[string]api.DescriptionOverride)
+	if m.repo != nil && strings.TrimSpace(subject.SourcePath) != "" {
+		overrides, err := m.repo.ListDescriptionOverridesByPath(ctx, subject.SourcePath)
+		if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
+			return nil, fmt.Errorf("core: description override: %w", err)
+		}
+		for _, override := range overrides {
+			overrideByGroup[normalizeDescriptionBuilderGroupKey(override.GroupKey, nil)] = override
+		}
+	}
+
+	groups := make([]api.DescriptionBuilderGroup, 0, len(preparation.Descriptions))
+	for _, entry := range preparation.Descriptions {
+		groups = append(groups, buildDescriptionBuilderGroup(entry, overrideByGroup))
+	}
+	return groups, nil
+}
diff --git a/internal/core/description_builder_test.go b/internal/core/description_builder_test.go
deleted file mode 100644
index d5a0ecc1..00000000
--- a/internal/core/description_builder_test.go
+++ /dev/null
@@ -1,1373 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type stubDescriptionBuilderTrackers struct {
-	called          bool
-	prepareMeta     api.PreparedMetadata
-	prepareTrackers []string
-	preview         api.PreparationPreview
-	dryRunMeta      api.PreparedMetadata
-	uploadMeta      api.PreparedMetadata
-	dryRunItems     []api.TrackerDryRunEntry
-}
-
-func (s *stubDescriptionBuilderTrackers) Upload(_ context.Context, meta api.PreparedMetadata) (api.UploadSummary, error) {
-	s.uploadMeta = meta
-	return api.UploadSummary{Uploaded: 1}, nil
-}
-
-func (s *stubDescriptionBuilderTrackers) BuildPreparation(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.PreparationPreview, error) {
-	s.called = true
-	s.prepareMeta = meta
-	s.prepareTrackers = append([]string{}, trackers...)
-	if strings.TrimSpace(s.preview.SourcePath) == "" {
-		s.preview.SourcePath = meta.SourcePath
-	}
-	if len(s.preview.Descriptions) == 0 {
-		s.preview.Descriptions = []api.PreparationDescription{
-			{Trackers: trackers, RawDescription: meta.DescriptionTemplate, RawDescriptionHTML: "<p>ok</p>"},
-		}
-	}
-	return s.preview, nil
-}
-
-func (s *stubDescriptionBuilderTrackers) BuildUploadDryRun(_ context.Context, meta api.PreparedMetadata, _ []string) ([]api.TrackerDryRunEntry, error) {
-	s.dryRunMeta = meta
-	if len(s.dryRunItems) == 0 {
-		return []api.TrackerDryRunEntry{}, nil
-	}
-	return append([]api.TrackerDryRunEntry(nil), s.dryRunItems...), nil
-}
-
-type stubDescriptionRepo struct {
-	stubRepo
-	override db.DescriptionOverride
-	getErr   error
-	saved    []db.DescriptionOverride
-	deleted  []string
-}
-
-func (s *stubDescriptionRepo) GetDescriptionOverride(_ context.Context, _ string, groupKey string) (db.DescriptionOverride, error) {
-	if s.getErr != nil {
-		return db.DescriptionOverride{}, s.getErr
-	}
-	if strings.TrimSpace(groupKey) != strings.TrimSpace(s.override.GroupKey) {
-		return db.DescriptionOverride{}, internalerrors.ErrNotFound
-	}
-	if strings.TrimSpace(s.override.Description) == "" {
-		return db.DescriptionOverride{}, internalerrors.ErrNotFound
-	}
-	return s.override, nil
-}
-
-func (s *stubDescriptionRepo) ListDescriptionOverridesByPath(context.Context, string) ([]db.DescriptionOverride, error) {
-	if s.getErr != nil {
-		return nil, s.getErr
-	}
-	if strings.TrimSpace(s.override.Description) == "" {
-		return nil, internalerrors.ErrNotFound
-	}
-	return []db.DescriptionOverride{s.override}, nil
-}
-
-func (s *stubDescriptionRepo) SaveDescriptionOverride(_ context.Context, override db.DescriptionOverride) error {
-	s.saved = append(s.saved, override)
-	return nil
-}
-
-func (s *stubDescriptionRepo) DeleteDescriptionOverride(_ context.Context, path string, groupKey string) error {
-	s.deleted = append(s.deleted, path+"|"+groupKey)
-	return nil
-}
-
-func TestFetchDescriptionBuilderPreviewUsesOverride(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{override: db.DescriptionOverride{SourcePath: "/tmp/source", GroupKey: "aither", Description: "override desc"}}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{Paths: []string{"/tmp/source"}, Mode: api.ModeGUI})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Groups) != 1 {
-		t.Fatalf("expected one override group, got %d", len(preview.Groups))
-	}
-	if preview.Groups[0].RawDescription != "override desc" {
-		t.Fatalf("expected override description, got %q", preview.Groups[0].RawDescription)
-	}
-	if !preview.Groups[0].HasOverride {
-		t.Fatalf("expected override flag to be true")
-	}
-	if trackerSvc.called {
-		t.Fatalf("expected tracker service not called when override exists")
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewDoesNotApplyLegacyDefaultOverrideAcrossGroups(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{override: db.DescriptionOverride{SourcePath: "/tmp/source", Description: "legacy default desc"}}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "hdb", Trackers: []string{"HDB"}, RawDescription: "generated raw", RawDescriptionHTML: "<p>generated raw</p>"},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Groups) != 1 {
-		t.Fatalf("expected one description group, got %d", len(preview.Groups))
-	}
-	if preview.Groups[0].RawDescription != "generated raw" {
-		t.Fatalf("expected group-specific generated raw description, got %q", preview.Groups[0].RawDescription)
-	}
-	if preview.Groups[0].HasOverride {
-		t.Fatalf("expected legacy default override not to apply implicitly")
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewFallsBackToPrepareInGUI(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubPreparationTrackers{}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if metaSvc.calls != 1 {
-		t.Fatalf("expected metadata prepare to be called once, got %d", metaSvc.calls)
-	}
-	if !trackerSvc.called {
-		t.Fatalf("expected tracker preparation to be called")
-	}
-	if preview.SourcePath != "/tmp/source" {
-		t.Fatalf("expected source path to be set, got %q", preview.SourcePath)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewUsesOnlyExplicitTrackers(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Trackers:   []string{"BLU"},
-	}}
-	core := &Core{
-		cfg: config.Config{
-			Description:        config.DescriptionSettingsConfig{AddLogo: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	_, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-		Options:  api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if !reflect.DeepEqual(trackerSvc.prepareTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected explicit tracker only, got %v", trackerSvc.prepareTrackers)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewReturnsEmptyWhenSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		SourcePath:     "/tmp/source",
-		TrackersRemove: []string{"AITHER"},
-	}}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-		Options:  api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if trackerSvc.called {
-		t.Fatal("expected tracker preparation to be skipped when selected trackers resolve empty")
-	}
-	if metaSvc.resolveCalls != 0 {
-		t.Fatalf("expected external metadata refresh to be skipped when selected trackers resolve empty, got %d", metaSvc.resolveCalls)
-	}
-	if preview.SourcePath != "/tmp/source" {
-		t.Fatalf("expected source path to be preserved, got %q", preview.SourcePath)
-	}
-	if len(preview.Groups) != 0 {
-		t.Fatalf("expected no description groups, got %d", len(preview.Groups))
-	}
-	if _, ok := core.getDupeCache("/tmp/source", ""); ok {
-		t.Fatal("expected explicit-empty preview not to seed GUI cache")
-	}
-}
-
-func TestFetchDescriptionBuilderGroupPreviewReturnsEmptyWhenSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		SourcePath:     "/tmp/source",
-		TrackersRemove: []string{"AITHER"},
-	}}
-	core := &Core{
-		cfg: config.Config{
-			Description:        config.DescriptionSettingsConfig{AddLogo: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.FetchDescriptionBuilderGroupPreview(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		Trackers:                 []string{"AITHER"},
-		DescriptionOverrideGroup: "AITHER",
-		Options:                  api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if trackerSvc.called {
-		t.Fatal("expected tracker preparation to be skipped when selected trackers resolve empty")
-	}
-	if metaSvc.resolveCalls != 0 {
-		t.Fatalf("expected external metadata refresh to be skipped when selected trackers resolve empty, got %d", metaSvc.resolveCalls)
-	}
-	if !reflect.DeepEqual(group, api.DescriptionBuilderGroup{}) {
-		t.Fatalf("expected empty group, got %#v", group)
-	}
-	if _, ok := core.getDupeCache("/tmp/source", ""); ok {
-		t.Fatal("expected explicit-empty group preview not to seed GUI cache")
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewRefreshesMissingLogoMetadata(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Paths:      []string{"/tmp/source"},
-		Mode:       api.ModeGUI,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: "/tmp/source",
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/source",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42, Title: "Cached without logo"},
-		},
-	}
-	refreshed := prepared
-	refreshed.ExternalMetadata.TMDB = &api.TMDBMetadata{TMDBID: 42, Logo: "https://image.tmdb.org/t/p/original/logo.png"}
-	metaSvc := &stubMeta{prepared: prepared, resolved: refreshed}
-	core := &Core{
-		cfg: config.Config{
-			Description:        config.DescriptionSettingsConfig{AddLogo: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	_, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if metaSvc.resolveCalls != 1 {
-		t.Fatalf("expected description builder to refresh missing logo metadata, got %d calls", metaSvc.resolveCalls)
-	}
-	if trackerSvc.prepareMeta.ExternalMetadata.TMDB == nil || trackerSvc.prepareMeta.ExternalMetadata.TMDB.Logo == "" {
-		t.Fatalf("expected tracker preparation to receive refreshed logo metadata, got %#v", trackerSvc.prepareMeta.ExternalMetadata.TMDB)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewRefreshesLocalizedPTBRMetadata(t *testing.T) {
-	t.Parallel()
-
-	for _, tracker := range []string{"BJS", "BT", "ASC"} {
-		t.Run(tracker, func(t *testing.T) {
-			t.Parallel()
-
-			repo := &stubDescriptionRepo{}
-			trackerSvc := &stubDescriptionBuilderTrackers{}
-			prepared := api.PreparedMetadata{
-				SourcePath: "/tmp/source-" + strings.ToLower(tracker),
-				Paths:      []string{"/tmp/source-" + strings.ToLower(tracker)},
-				Mode:       api.ModeGUI,
-				ExternalIDs: api.ExternalIDs{
-					SourcePath: "/tmp/source-" + strings.ToLower(tracker),
-					TMDBID:     42,
-					Category:   "MOVIE",
-				},
-				ExternalMetadata: api.ExternalMetadata{
-					SourcePath: "/tmp/source-" + strings.ToLower(tracker),
-					TMDB:       &api.TMDBMetadata{TMDBID: 42, Logo: "https://image.tmdb.org/t/p/original/logo.png"},
-				},
-			}
-			refreshed := prepared
-			refreshed.ExternalMetadata.TMDB = &api.TMDBMetadata{
-				TMDBID: 42,
-				Logo:   "https://image.tmdb.org/t/p/original/logo.png",
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {Title: "Titulo " + tracker},
-				},
-			}
-			metaSvc := &stubMeta{prepared: prepared, resolved: refreshed}
-			core := &Core{
-				cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-				logger: api.NopLogger{},
-				services: api.ServiceSet{
-					Filesystem: stubFilesystem{paths: []string{prepared.SourcePath}},
-					Trackers:   trackerSvc,
-					Metadata:   metaSvc,
-				},
-				repo:      repo,
-				dupeCache: make(map[string]dupeCacheEntry),
-			}
-
-			_, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-				Paths:    []string{prepared.SourcePath},
-				Mode:     api.ModeGUI,
-				Trackers: []string{tracker},
-				Options:  api.UploadOptions{Screens: 1},
-			})
-			if err != nil {
-				t.Fatalf("expected no error, got %v", err)
-			}
-			if metaSvc.resolveCalls != 1 {
-				t.Fatalf("expected description builder to refresh pt-BR metadata for %s, got %d calls", tracker, metaSvc.resolveCalls)
-			}
-			got, ok := trackerSvc.prepareMeta.ExternalMetadata.TMDB.Localized["pt-BR"]
-			if !ok || got.Title == "" {
-				t.Fatalf("expected tracker preparation to receive refreshed pt-BR metadata, got %#v", trackerSvc.prepareMeta.ExternalMetadata.TMDB.Localized)
-			}
-		})
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewDocumentsRefreshAndPreparedCacheLineage(t *testing.T) {
-	t.Parallel()
-
-	req := api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"ASC"},
-		Options:  api.UploadOptions{Screens: 1},
-	}
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Paths:      []string{"/tmp/source"},
-		Mode:       api.ModeGUI,
-		Options:    api.UploadOptions{Screens: 1},
-		Trackers:   []string{"ASC"},
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: "/tmp/source",
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/source",
-			TMDB: &api.TMDBMetadata{
-				TMDBID: 42,
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {Title: "Titulo"},
-				},
-			},
-		},
-	}
-	refreshed := prepared
-	refreshed.ExternalMetadata.TMDB = &api.TMDBMetadata{
-		TMDBID: 42,
-		Localized: map[string]api.TMDBLocalizedData{
-			"pt-BR": {Title: "Titulo", Overview: "Resumo", Genres: "Drama"},
-		},
-	}
-
-	refreshMeta := &stubMeta{prepared: prepared, resolved: refreshed}
-	refreshTrackers := &stubDescriptionBuilderTrackers{}
-	refreshCore := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   refreshTrackers,
-			Metadata:   refreshMeta,
-		},
-		repo:      &stubDescriptionRepo{},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	if _, err := refreshCore.FetchDescriptionBuilderPreview(context.Background(), req); err != nil {
-		t.Fatalf("refreshing description preview: %v", err)
-	}
-	if refreshMeta.resolveCalls != 1 {
-		t.Fatalf("expected refresh path to resolve metadata once, got %d", refreshMeta.resolveCalls)
-	}
-	entry, _, ok := refreshCore.lookupGUICachedMetaEntry(req, "/tmp/source")
-	if !ok {
-		t.Fatal("expected refreshed GUI cache entry")
-	}
-	if !entry.requestRefreshed {
-		t.Fatal("expected refresh path to keep request-refreshed cache lineage")
-	}
-	if _, err := refreshCore.FetchDescriptionBuilderPreview(context.Background(), req); err != nil {
-		t.Fatalf("reopening refreshed description preview: %v", err)
-	}
-	if refreshMeta.resolveCalls != 1 {
-		t.Fatalf("expected refreshed cache reopen to avoid another resolve, got %d", refreshMeta.resolveCalls)
-	}
-
-	preparedMeta := &stubMeta{prepared: refreshed}
-	preparedCore := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   &stubDescriptionBuilderTrackers{},
-			Metadata:   preparedMeta,
-		},
-		repo:      &stubDescriptionRepo{},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	if _, err := preparedCore.FetchDescriptionBuilderPreview(context.Background(), req); err != nil {
-		t.Fatalf("prepared description preview: %v", err)
-	}
-	if preparedMeta.resolveCalls != 0 {
-		t.Fatalf("expected prepared path to skip metadata resolve, got %d", preparedMeta.resolveCalls)
-	}
-	entry, _, ok = preparedCore.lookupGUICachedMetaEntry(req, "/tmp/source")
-	if !ok {
-		t.Fatal("expected prepared GUI cache entry")
-	}
-	if entry.requestRefreshed {
-		t.Fatal("expected no-refresh path to store stable prepared cache lineage")
-	}
-}
-
-func TestDescriptionBuilderNeedsPTBRMetadataRequiresCompleteLocalizedFields(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				TMDBID: 42,
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {Title: "Titulo", Overview: "Resumo"},
-				},
-			},
-		},
-	}
-	if !descriptionBuilderNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected partial pt-BR metadata to need description-builder refresh")
-	}
-
-	meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-		Title:    "Titulo",
-		Overview: "Resumo",
-		Genres:   "Drama",
-	}
-	if descriptionBuilderNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected complete pt-BR metadata to skip description-builder refresh")
-	}
-
-	meta.ExternalIDs.Category = "TV"
-	meta.SeasonInt = 1
-	meta.EpisodeInt = 2
-	meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-		Title:           "Titulo",
-		Overview:        "Resumo da serie",
-		EpisodeOverview: "Resumo do episodio",
-		Genres:          "Drama",
-	}
-	if descriptionBuilderNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected complete episode pt-BR metadata to skip description-builder refresh")
-	}
-
-	meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-		Title:    "Titulo",
-		Overview: "Resumo da serie",
-		Genres:   "Drama",
-	}
-	if !descriptionBuilderNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected episode pt-BR metadata without scoped overview to need refresh")
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewSkipsLocalizedRefreshForNonlocalizedTracker(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	metaSvc := &stubMeta{prepared: api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Paths:      []string{"/tmp/source"},
-		Mode:       api.ModeGUI,
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/source",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42, Logo: "https://image.tmdb.org/t/p/original/logo.png"},
-		},
-	}}
-	core := &Core{
-		cfg: config.Config{
-			Description:        config.DescriptionSettingsConfig{AddLogo: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	_, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HDB"},
-		Options:  api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if metaSvc.resolveCalls != 0 {
-		t.Fatalf("expected nonlocalized tracker to skip external metadata refresh, got %d calls", metaSvc.resolveCalls)
-	}
-	if !trackerSvc.called {
-		t.Fatal("expected tracker preparation to run")
-	}
-}
-
-func TestSaveDescriptionOverrideDeleteRefreshesLocalizedPTBRMetadata(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "asc", Trackers: []string{"ASC"}, RawDescription: "generated raw", RawDescriptionHTML: "<p>generated raw</p>"},
-			},
-		},
-	}
-	prepared := api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Paths:      []string{"/tmp/source"},
-		Mode:       api.ModeGUI,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: "/tmp/source",
-			TMDBID:     42,
-			Category:   "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/source",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42, Logo: "https://image.tmdb.org/t/p/original/logo.png"},
-		},
-	}
-	refreshed := prepared
-	refreshed.ExternalMetadata.TMDB = &api.TMDBMetadata{
-		TMDBID: 42,
-		Logo:   "https://image.tmdb.org/t/p/original/logo.png",
-		Localized: map[string]api.TMDBLocalizedData{
-			"pt-BR": {Overview: "Resumo ASC"},
-		},
-	}
-	metaSvc := &stubMeta{prepared: prepared, resolved: refreshed}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.SaveDescriptionOverride(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: "asc",
-		Trackers:                 []string{"ASC"},
-		Options:                  api.UploadOptions{Screens: 1},
-	}, "  ")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if group.GroupKey != "asc" {
-		t.Fatalf("expected reset group key, got %q", group.GroupKey)
-	}
-	if len(repo.deleted) != 1 {
-		t.Fatalf("expected delete to be called, got %d", len(repo.deleted))
-	}
-	if metaSvc.resolveCalls != 1 {
-		t.Fatalf("expected description override reset to refresh pt-BR metadata, got %d calls", metaSvc.resolveCalls)
-	}
-	if got := trackerSvc.prepareMeta.ExternalMetadata.TMDB.Localized["pt-BR"].Overview; got != "Resumo ASC" {
-		t.Fatalf("expected tracker preparation to receive refreshed pt-BR overview, got %q", got)
-	}
-}
-
-func TestSaveDescriptionOverrideDeletesOnEmpty(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "blu", Trackers: []string{"BLU"}, RawDescription: "generated raw", RawDescriptionHTML: "<p>generated raw</p>"},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.SaveDescriptionOverride(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: "blu",
-		Trackers:                 []string{"BLU"},
-	}, "  ")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(repo.deleted) != 1 {
-		t.Fatalf("expected delete to be called, got %d", len(repo.deleted))
-	}
-	if group.GroupKey != "blu" {
-		t.Fatalf("expected reset group key, got %q", group.GroupKey)
-	}
-	if group.RawDescription != "generated raw" {
-		t.Fatalf("expected generated raw description after reset, got %q", group.RawDescription)
-	}
-}
-
-func TestSaveDescriptionOverrideDeleteReturnsEmptyGroupWhenPreviewGroupMissing(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath:   "/tmp/source",
-			Descriptions: []api.PreparationDescription{},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.SaveDescriptionOverride(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: "blu",
-		Trackers:                 []string{"BLU"},
-	}, "  ")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(repo.deleted) != 1 {
-		t.Fatalf("expected delete to be called, got %d", len(repo.deleted))
-	}
-	if group.GroupKey != "blu" {
-		t.Fatalf("expected reset group key, got %q", group.GroupKey)
-	}
-	if len(group.Trackers) != 1 || group.Trackers[0] != "BLU" {
-		t.Fatalf("expected trackers to be preserved, got %v", group.Trackers)
-	}
-	if group.HasOverride {
-		t.Fatalf("expected override flag to be false")
-	}
-	if group.RawDescription != "" {
-		t.Fatalf("expected empty raw description when preview group missing, got %q", group.RawDescription)
-	}
-	if group.RawDescriptionHTML != "" {
-		t.Fatalf("expected empty rendered description when preview group missing, got %q", group.RawDescriptionHTML)
-	}
-}
-
-func TestRenderDescriptionReturnsHTML(t *testing.T) {
-	t.Parallel()
-
-	core := &Core{logger: api.NopLogger{}}
-	value, err := core.RenderDescription(context.Background(), "[b]Example[/b]")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if !strings.Contains(value, "Example") {
-		t.Fatalf("expected rendered HTML to contain content, got %q", value)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewSkipsEmptyPreparationPlaceholder(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{Trackers: []string{"BTN"}, RawDescription: "", RawDescriptionHTML: ""},
-				{Trackers: []string{"BLU"}, RawDescription: "final description", RawDescriptionHTML: "<p>final description</p>"},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Groups) != 2 {
-		t.Fatalf("expected two description groups, got %d", len(preview.Groups))
-	}
-	if preview.Groups[1].RawDescription != "final description" {
-		t.Fatalf("expected non-empty raw description to be selected, got %q", preview.Groups[1].RawDescription)
-	}
-	if !strings.Contains(preview.Groups[1].RawDescriptionHTML, "final description") {
-		t.Fatalf("expected rendered raw description to contain content, got %q", preview.Groups[1].RawDescriptionHTML)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewSeedsRawDescriptionFromBuiltGroupText(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{
-					GroupKey:        "hdb",
-					Trackers:        []string{"HDB"},
-					RawDescription:  "",
-					Description:     "built grouped text",
-					DescriptionHTML: "<p>built grouped text</p>",
-				},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Groups) != 1 {
-		t.Fatalf("expected one description group, got %d", len(preview.Groups))
-	}
-	if preview.Groups[0].RawDescription != "built grouped text" {
-		t.Fatalf("expected raw description to fall back to built grouped text, got %q", preview.Groups[0].RawDescription)
-	}
-	if !strings.Contains(preview.Groups[0].RawDescriptionHTML, "built grouped text") {
-		t.Fatalf("expected rendered raw description to contain built grouped text, got %q", preview.Groups[0].RawDescriptionHTML)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewAppliesIgnoredDupesToCachedMeta(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "hdb", Trackers: []string{"HDB"}, Description: "hdb body"},
-				{GroupKey: "bhd", Trackers: []string{"BHD"}, Description: "bhd body"},
-			},
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeRefreshedDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-			"BHD": {api.TrackerBlockReasonDupe},
-		},
-	})
-
-	_, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:          []string{"/tmp/source"},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"HDB", "BHD"},
-		IgnoreDupesFor: []string{"HDB"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if _, ok := trackerSvc.prepareMeta.BlockedTrackers["HDB"]; ok {
-		t.Fatalf("expected ignored HDB dupe block to be cleared, got %#v", trackerSvc.prepareMeta.BlockedTrackers)
-	}
-	if got := trackerSvc.prepareMeta.BlockedTrackers["BHD"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected BHD dupe block to remain, got %#v", trackerSvc.prepareMeta.BlockedTrackers)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewUsesIgnoredMatchedTracker(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "aither", Trackers: []string{"AITHER"}, Description: "aither body"},
-			},
-		},
-	}
-	core := &Core{
-		cfg: config.Config{
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeRefreshedDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath:      "/tmp/source",
-		TrackersRemove:  []string{"AITHER", "BLU"},
-		MatchedTrackers: []string{"AITHER", "BLU"},
-	})
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:          []string{"/tmp/source"},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-		Options:        api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("fetch description builder preview: %v", err)
-	}
-	if len(preview.Groups) != 1 {
-		t.Fatalf("expected one description group, got %d", len(preview.Groups))
-	}
-	if !reflect.DeepEqual(trackerSvc.prepareTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected ignored matched tracker without default fallback, got %v", trackerSvc.prepareTrackers)
-	}
-	if containsTrackerName(trackerSvc.prepareMeta.TrackersRemove, "AITHER") || !containsTrackerName(trackerSvc.prepareMeta.TrackersRemove, "BLU") {
-		t.Fatalf("expected only unignored duplicate removal to remain, got %v", trackerSvc.prepareMeta.TrackersRemove)
-	}
-	if containsTrackerName(trackerSvc.prepareMeta.MatchedTrackers, "AITHER") || !containsTrackerName(trackerSvc.prepareMeta.MatchedTrackers, "BLU") {
-		t.Fatalf("expected only unignored matched tracker to remain, got %v", trackerSvc.prepareMeta.MatchedTrackers)
-	}
-}
-
-func TestFetchDescriptionBuilderGroupPreviewAppliesIgnoredFailuresToRefreshedCache(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{GroupKey: "hdb", Trackers: []string{"HDB"}, Description: "hdb body"},
-				{GroupKey: "bhd", Trackers: []string{"BHD"}, Description: "bhd body"},
-			},
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeRefreshedDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Mode:       api.ModeGUI,
-		Trackers:   []string{"HDB", "BHD"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-			"BHD": {api.TrackerBlockReasonDupe},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"HDB": {{Rule: "rule_hdb", Reason: "hdb"}},
-			"BHD": {{Rule: "rule_bhd", Reason: "bhd"}},
-		},
-	})
-
-	group, err := core.FetchDescriptionBuilderGroupPreview(context.Background(), api.Request{
-		Paths:                        []string{"/tmp/source"},
-		Mode:                         api.ModeGUI,
-		Trackers:                     []string{"HDB", "BHD"},
-		DescriptionOverrideGroup:     "HDB",
-		IgnoreDupesFor:               []string{"HDB"},
-		IgnoreTrackerRuleFailuresFor: []string{"HDB"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if group.GroupKey != "hdb" {
-		t.Fatalf("expected selected HDB group, got %q", group.GroupKey)
-	}
-	if _, ok := trackerSvc.prepareMeta.BlockedTrackers["HDB"]; ok {
-		t.Fatalf("expected ignored HDB dupe block to be cleared, got %#v", trackerSvc.prepareMeta.BlockedTrackers)
-	}
-	if got := trackerSvc.prepareMeta.BlockedTrackers["BHD"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected BHD dupe block to remain, got %#v", trackerSvc.prepareMeta.BlockedTrackers)
-	}
-	if _, ok := trackerSvc.prepareMeta.TrackerRuleFailures["HDB"]; ok {
-		t.Fatalf("expected ignored HDB rule failure to be cleared, got %#v", trackerSvc.prepareMeta.TrackerRuleFailures)
-	}
-	if _, ok := trackerSvc.prepareMeta.TrackerRuleFailures["BHD"]; !ok {
-		t.Fatalf("expected BHD rule failure to remain, got %#v", trackerSvc.prepareMeta.TrackerRuleFailures)
-	}
-}
-
-func TestFetchDescriptionBuilderPreviewPreservesFinalBuildWithOverrideCaseInsensitively(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{
-		override: db.DescriptionOverride{
-			SourcePath:  "/tmp/source",
-			GroupKey:    "HDB|HDB|TRACKER:HDB",
-			Description: "override body",
-		},
-	}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{
-					GroupKey:    "hdb|hdb|tracker:hdb",
-					Trackers:    []string{"HDB"},
-					Description: "built override body with rehosted images",
-					HasOverride: true,
-				},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchDescriptionBuilderPreview(context.Background(), api.Request{
-		Paths:   []string{"/tmp/source"},
-		Mode:    api.ModeGUI,
-		Options: api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Groups) != 1 {
-		t.Fatalf("expected one description group, got %d", len(preview.Groups))
-	}
-	if preview.Groups[0].GroupKey != "hdb|hdb|tracker:hdb" {
-		t.Fatalf("expected normalized group key, got %q", preview.Groups[0].GroupKey)
-	}
-	if preview.Groups[0].RawDescription != "built override body with rehosted images" {
-		t.Fatalf("expected final built override body, got %q", preview.Groups[0].RawDescription)
-	}
-	if !preview.Groups[0].HasOverride {
-		t.Fatalf("expected override flag to be true")
-	}
-}
-
-func TestFetchDescriptionBuilderGroupPreviewPreservesFinalBuildWithOverrideCaseInsensitively(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{
-		override: db.DescriptionOverride{
-			SourcePath:  "/tmp/source",
-			GroupKey:    "HDB|HDB|TRACKER:HDB",
-			Description: "override body",
-		},
-	}
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		preview: api.PreparationPreview{
-			SourcePath: "/tmp/source",
-			Descriptions: []api.PreparationDescription{
-				{
-					GroupKey:    "hdb|hdb|tracker:hdb",
-					Trackers:    []string{"HDB"},
-					Description: "built override body with rehosted images",
-					HasOverride: true,
-				},
-			},
-		},
-	}
-	metaSvc := &stubMeta{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Trackers:   trackerSvc,
-			Metadata:   metaSvc,
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.FetchDescriptionBuilderGroupPreview(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		Trackers:                 []string{"HDB"},
-		DescriptionOverrideGroup: "HDB|HDB|TRACKER:HDB",
-		Options:                  api.UploadOptions{Screens: 1},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if group.GroupKey != "hdb|hdb|tracker:hdb" {
-		t.Fatalf("expected normalized group key, got %q", group.GroupKey)
-	}
-	if group.RawDescription != "built override body with rehosted images" {
-		t.Fatalf("expected final built override body, got %q", group.RawDescription)
-	}
-	if !group.HasOverride {
-		t.Fatalf("expected override flag to be true")
-	}
-}
-
-func TestSaveDescriptionOverrideReturnsSavedGroup(t *testing.T) {
-	t.Parallel()
-
-	repo := &stubDescriptionRepo{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-		},
-		repo:      repo,
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group, err := core.SaveDescriptionOverride(context.Background(), api.Request{
-		Paths:                    []string{"/tmp/source"},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: "hdb",
-		Trackers:                 []string{"HDB"},
-	}, "custom body")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if group.GroupKey != "hdb" {
-		t.Fatalf("expected hdb group key, got %q", group.GroupKey)
-	}
-	if group.RawDescription != "custom body" {
-		t.Fatalf("expected saved raw description, got %q", group.RawDescription)
-	}
-	if !group.HasOverride {
-		t.Fatalf("expected override flag to be true")
-	}
-	if len(repo.saved) != 1 {
-		t.Fatalf("expected save to be called once, got %d", len(repo.saved))
-	}
-}
-
-func TestFetchTrackerDryRunPreviewUsesCanonicalDescriptionGroups(t *testing.T) {
-	t.Parallel()
-
-	trackerSvc := &stubDescriptionBuilderTrackers{
-		dryRunItems: []api.TrackerDryRunEntry{{Tracker: "HDB", Status: "ok"}},
-	}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Metadata:   &stubMeta{},
-			Torrents:   stubTorrent{},
-			Clients:    &stubClient{},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	signature := overrideSignature(
-		api.ExternalIDOverrides{},
-		api.ReleaseNameOverrides{},
-		api.MetadataOverrides{},
-		api.TrackerConfigOverrides{},
-		api.TrackerSiteOverrides{},
-		api.ClientOverrides{},
-		api.TorrentOverrides{},
-		api.ImageHostOverrides{},
-		api.ScreenshotOverrides{},
-	)
-	core.storeDupeCache("/tmp/source", signature, api.PreparedMetadata{SourcePath: "/tmp/source"})
-
-	group := api.DescriptionBuilderGroup{
-		GroupKey:       "hdb",
-		Trackers:       []string{"HDB"},
-		RawDescription: "saved canonical body",
-	}
-	preview, err := core.FetchTrackerDryRunPreview(context.Background(), api.Request{
-		Paths:             []string{"/tmp/source"},
-		Mode:              api.ModeGUI,
-		Trackers:          []string{"HDB"},
-		DescriptionGroups: []api.DescriptionBuilderGroup{group},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(preview.Trackers) != 1 {
-		t.Fatalf("expected one dry-run tracker entry, got %d", len(preview.Trackers))
-	}
-	if len(trackerSvc.dryRunMeta.DescriptionGroups) != 1 {
-		t.Fatalf("expected one canonical description group, got %d", len(trackerSvc.dryRunMeta.DescriptionGroups))
-	}
-	if trackerSvc.dryRunMeta.DescriptionGroups[0].RawDescription != "saved canonical body" {
-		t.Fatalf("expected dry-run to use canonical description group, got %q", trackerSvc.dryRunMeta.DescriptionGroups[0].RawDescription)
-	}
-}
-
-func TestResolveCanonicalDescriptionGroupsSkipsDefaultsWhenExplicitSelectionResolvesEmpty(t *testing.T) {
-	t.Parallel()
-
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	core := &Core{
-		cfg: config.Config{
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Trackers: trackerSvc,
-		},
-	}
-
-	groups, err := core.resolveCanonicalDescriptionGroups(context.Background(), api.PreparedMetadata{
-		SourcePath:     "/tmp/source",
-		TrackersRemove: []string{"AITHER"},
-	}, api.Request{
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if trackerSvc.called {
-		t.Fatal("expected tracker preparation to be skipped when selected trackers resolve empty")
-	}
-	if len(groups) != 0 {
-		t.Fatalf("expected no canonical groups, got %#v", groups)
-	}
-}
-
-func TestExecutePreparedUploadUsesCanonicalDescriptionGroups(t *testing.T) {
-	t.Parallel()
-
-	trackerSvc := &stubDescriptionBuilderTrackers{}
-	core := &Core{
-		cfg:    config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Torrents: stubTorrent{},
-			Trackers: trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	group := api.DescriptionBuilderGroup{
-		GroupKey:       "hdb",
-		Trackers:       []string{"HDB"},
-		RawDescription: "saved canonical upload body",
-	}
-	uploaded, err := core.executePreparedUpload(context.Background(), api.Request{
-		Paths:             []string{"/tmp/source"},
-		Mode:              api.ModeGUI,
-		Trackers:          []string{"HDB"},
-		DescriptionGroups: []api.DescriptionBuilderGroup{group},
-	}, api.PreparedMetadata{SourcePath: "/tmp/source"})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if uploaded != 1 {
-		t.Fatalf("expected one upload, got %d", uploaded)
-	}
-	if len(trackerSvc.uploadMeta.DescriptionGroups) != 1 {
-		t.Fatalf("expected one canonical upload description group, got %d", len(trackerSvc.uploadMeta.DescriptionGroups))
-	}
-	if trackerSvc.uploadMeta.DescriptionGroups[0].RawDescription != "saved canonical upload body" {
-		t.Fatalf("expected upload to use canonical description group, got %q", trackerSvc.uploadMeta.DescriptionGroups[0].RawDescription)
-	}
-}
diff --git a/internal/core/dupe.go b/internal/core/dupe.go
new file mode 100644
index 00000000..f0e5a929
--- /dev/null
+++ b/internal/core/dupe.go
@@ -0,0 +1,178 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// dupeModule owns duplicate-check policy over exact prepared generations.
+type dupeModule struct {
+	cfg           config.Config
+	logger        api.Logger
+	services      api.ServiceSet
+	registry      *trackers.Registry
+	preparedFacts duplicatePreparedFacts
+}
+
+// duplicatePreparedFacts exposes only preparation operations required by dupe checks.
+type duplicatePreparedFacts interface {
+	Prepare(context.Context, api.PrepareInput) (api.PrepareResult, error)
+	ResolveDuplicateSubject(context.Context, api.DuplicateCheckInput) (api.DuplicateSubject, error)
+}
+
+type duplicateAssessmentChecker interface {
+	CheckWithAssessment(context.Context, api.DuplicateSubject, []string, dupechecking.CheckOptions) (api.DupeCheckSummary, dupechecking.Assessment, error)
+}
+
+// newDupeModule composes duplicate policy with canonical prepared facts.
+func newDupeModule(
+	cfg config.Config,
+	logger api.Logger,
+	services api.ServiceSet,
+	registry *trackers.Registry,
+	preparedFacts duplicatePreparedFacts,
+) *dupeModule {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &dupeModule{
+		cfg:           cfg,
+		logger:        logger,
+		services:      services,
+		registry:      registry,
+		preparedFacts: preparedFacts,
+	}
+}
+
+func (m *dupeModule) check(ctx context.Context, req api.Request) (api.DupeCheckSummary, error) {
+	req = normalizeExecutionRequest(req)
+	if m.preparedFacts == nil {
+		return api.DupeCheckSummary{}, errors.New("core: canonical preparation is not configured")
+	}
+	prepareInput, err := api.MapPreparationRequest(req, api.PreparationIntentDuplicateCheck)
+	if err != nil {
+		return api.DupeCheckSummary{}, fmt.Errorf("core: map duplicate-check preparation request: %w", err)
+	}
+	prepared, err := m.preparedFacts.Prepare(ctx, prepareInput)
+	if err != nil {
+		return api.DupeCheckSummary{}, fmt.Errorf("core: prepare duplicate check: %w", err)
+	}
+	input := duplicateCheckInputFromRequest(req, api.ReleaseRef{
+		SourcePath: prepared.Release.Source.SourcePath,
+		Generation: prepared.Release.Generation,
+	})
+	input.Trackers = trackers.ResolveTrackersWithRegistry(m.cfg, req.Trackers, nil, m.logger, m.registry)
+	return m.checkAccepted(ctx, input)
+}
+
+// checkAccepted overlays explicit tracker IDs, performs auth preflight, and
+// assesses the exact prepared generation.
+func (m *dupeModule) checkAccepted(ctx context.Context, input api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	if m.preparedFacts == nil {
+		return api.DupeCheckSummary{}, errors.New("core: canonical preparation is not configured")
+	}
+	if m.services.Dupes == nil {
+		return api.DupeCheckSummary{}, errors.New("core: dupe service not configured")
+	}
+	subject, err := m.preparedFacts.ResolveDuplicateSubject(ctx, input)
+	if err != nil {
+		return api.DupeCheckSummary{}, fmt.Errorf("core: resolve duplicate-check subject: %w", err)
+	}
+	applyTrackerIDOverridesToDuplicateSubject(&subject, input.TrackerIDs)
+	resolvedTrackers := trackers.ResolveExplicitTrackersWithRegistry(input.Trackers, m.logger, m.registry)
+	if len(resolvedTrackers) == 0 {
+		return api.DupeCheckSummary{}, noEligibleTrackersError(api.OperationKindDuplicateCheck)
+	}
+	readyTrackers := resolvedTrackers
+	var authBlocked []api.DupeCheckResult
+	if input.Interaction == api.InteractionModeInteractive && m.services.TrackerAuth != nil {
+		readyTrackers, authBlocked, err = m.preflightGUITrackerAuth(ctx, subject, resolvedTrackers)
+		if err != nil {
+			return api.DupeCheckSummary{}, err
+		}
+	}
+	summary, _, err := checkDuplicateAssessment(ctx, m.services.Dupes, subject, readyTrackers, dupechecking.CheckOptions{SkipRemote: input.Skip})
+	if err != nil {
+		return summary, fmt.Errorf("core: %w", err)
+	}
+	summary.Results = append(summary.Results, authBlocked...)
+	sort.Slice(summary.Results, func(i, j int) bool {
+		return strings.ToUpper(summary.Results[i].Tracker) < strings.ToUpper(summary.Results[j].Tracker)
+	})
+	resultByTracker := mapDupeResults(summary.Results)
+	assessments := make([]api.TrackerEligibilityAssessment, 0, len(resolvedTrackers))
+	for _, tracker := range resolvedTrackers {
+		name := normalizeEligibilityTracker(tracker)
+		assessments = append(assessments, api.TrackerEligibilityAssessment{
+			Tracker:      name,
+			Duplicate:    resultByTracker[name],
+			RuleFailures: cloneRuleFailures(subject.TrackerRuleFailures[name]),
+			PolicyBlocks: append([]api.TrackerBlockReason(nil), subject.BlockedTrackers[name]...),
+			Choices: api.TrackerReviewChoices{
+				IgnoreDuplicate: containsNormalizedTracker(input.IgnoreFor, name),
+			},
+		})
+	}
+	summary.Eligibility, err = buildTrackerEligibility(api.TrackerEligibilityInput{
+		Release:          input.Release,
+		SelectedTrackers: resolvedTrackers,
+		Assessments:      assessments,
+	})
+	if err != nil {
+		return api.DupeCheckSummary{}, err
+	}
+	logTrackerEligibility(ctx, m.logger, "duplicate_check", summary.Eligibility)
+	return summary, nil
+}
+
+// applyTrackerIDOverridesToDuplicateSubject overlays explicit IDs after the
+// prepared generation's private client snapshot has been projected.
+func applyTrackerIDOverridesToDuplicateSubject(
+	subject *api.DuplicateSubject,
+	overrides map[string]string,
+) {
+	if subject == nil {
+		return
+	}
+	if subject.TrackerIDs == nil && len(overrides) > 0 {
+		subject.TrackerIDs = make(map[string]string, len(overrides))
+	}
+	for key, value := range overrides {
+		key = strings.ToLower(strings.TrimSpace(key))
+		value = strings.TrimSpace(value)
+		if key != "" && value != "" {
+			subject.TrackerIDs[key] = value
+		}
+	}
+}
+
+func containsNormalizedTracker(values []string, target string) bool {
+	for _, value := range values {
+		if normalizeEligibilityTracker(value) == target {
+			return true
+		}
+	}
+	return false
+}
+
+func cloneTrackerRuleFailures(input map[string][]api.RuleFailure) map[string][]api.RuleFailure {
+	if len(input) == 0 {
+		return nil
+	}
+	cloned := make(map[string][]api.RuleFailure, len(input))
+	for tracker, failures := range input {
+		cloned[tracker] = cloneRuleFailures(failures)
+	}
+	return cloned
+}
diff --git a/internal/core/dupe_assessment.go b/internal/core/dupe_assessment.go
new file mode 100644
index 00000000..9ed241fd
--- /dev/null
+++ b/internal/core/dupe_assessment.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func checkDuplicateAssessment(
+	ctx context.Context,
+	service api.DupeService,
+	meta api.DuplicateSubject,
+	trackers []string,
+	options dupechecking.CheckOptions,
+) (api.DupeCheckSummary, dupechecking.Assessment, error) {
+	checker, ok := service.(duplicateAssessmentChecker)
+	if !ok {
+		return api.DupeCheckSummary{}, dupechecking.EmptyAssessment(), errors.New("core: duplicate service does not provide structural assessment")
+	}
+	summary, assessment, err := checker.CheckWithAssessment(ctx, meta, trackers, options)
+	if err != nil {
+		return summary, assessment, fmt.Errorf("core: duplicate assessment: %w", err)
+	}
+	return summary, assessment, nil
+}
diff --git a/internal/core/dupe_client_discovery_test.go b/internal/core/dupe_client_discovery_test.go
new file mode 100644
index 00000000..20c2c1e1
--- /dev/null
+++ b/internal/core/dupe_client_discovery_test.go
@@ -0,0 +1,120 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type duplicateFactsStub struct {
+	subject api.DuplicateSubject
+}
+
+func duplicateTestRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
+func (*duplicateFactsStub) Prepare(context.Context, api.PrepareInput) (api.PrepareResult, error) {
+	return api.PrepareResult{}, nil
+}
+
+func (s *duplicateFactsStub) ResolveDuplicateSubject(context.Context, api.DuplicateCheckInput) (api.DuplicateSubject, error) {
+	return s.subject, nil
+}
+
+type duplicateAssessmentStub struct {
+	calls   int
+	subject api.DuplicateSubject
+	options dupechecking.CheckOptions
+}
+
+func (s *duplicateAssessmentStub) Check(context.Context, api.DuplicateSubject, []string) (api.DupeCheckSummary, error) {
+	return api.DupeCheckSummary{}, nil
+}
+
+func (s *duplicateAssessmentStub) CheckWithAssessment(
+	_ context.Context,
+	subject api.DuplicateSubject,
+	trackers []string,
+	options dupechecking.CheckOptions,
+) (api.DupeCheckSummary, dupechecking.Assessment, error) {
+	s.calls++
+	s.subject = subject
+	s.options = options
+	results := make([]api.DupeCheckResult, 0, len(trackers))
+	for _, tracker := range trackers {
+		results = append(results, api.DupeCheckResult{Tracker: tracker})
+	}
+	return api.DupeCheckSummary{Results: results}, dupechecking.EmptyAssessment(), nil
+}
+
+func TestAcceptedDuplicateCheckConsumesPreparedClientEvidenceAndOverlaysExplicitIDs(t *testing.T) {
+	t.Parallel()
+
+	checker := &duplicateAssessmentStub{}
+	module := newDupeModule(
+		config.Config{},
+		api.NopLogger{},
+		api.ServiceSet{Dupes: checker},
+		duplicateTestRegistry(t),
+		&duplicateFactsStub{subject: api.DuplicateSubject{
+			SourcePath:      "Example.Release.2026.mkv",
+			FileList:        []string{"Example.Release.2026.mkv"},
+			TrackerIDs:      map[string]string{"btn": "client-id", "aither": "aither-id"},
+			MatchedTrackers: []string{"AITHER", "BTN"},
+		}},
+	)
+	_, err := module.checkAccepted(context.Background(), api.DuplicateCheckInput{
+		Release:    api.ReleaseRef{SourcePath: "Example.Release.2026.mkv", Generation: 1},
+		Trackers:   []string{"AITHER"},
+		TrackerIDs: map[string]string{"btn": "explicit-id"},
+	})
+	if err != nil {
+		t.Fatalf("check accepted: %v", err)
+	}
+	if checker.calls != 1 {
+		t.Fatalf("checker calls = %d", checker.calls)
+	}
+	if checker.subject.TrackerIDs["btn"] != "explicit-id" || checker.subject.TrackerIDs["aither"] != "aither-id" {
+		t.Fatalf("tracker IDs = %#v", checker.subject.TrackerIDs)
+	}
+	if len(checker.subject.MatchedTrackers) != 2 || checker.subject.MatchedTrackers[0] != "AITHER" || checker.subject.MatchedTrackers[1] != "BTN" {
+		t.Fatalf("matched trackers = %#v", checker.subject.MatchedTrackers)
+	}
+}
+
+func TestAcceptedDuplicateCheckContinuesRemoteAssessmentWithoutPreparedLocalMatch(t *testing.T) {
+	t.Parallel()
+
+	checker := &duplicateAssessmentStub{}
+	module := newDupeModule(
+		config.Config{},
+		api.NopLogger{},
+		api.ServiceSet{Dupes: checker},
+		duplicateTestRegistry(t),
+		&duplicateFactsStub{subject: api.DuplicateSubject{SourcePath: "Example.Release.2026.mkv"}},
+	)
+	_, err := module.checkAccepted(context.Background(), api.DuplicateCheckInput{
+		Release:  api.ReleaseRef{SourcePath: "Example.Release.2026.mkv", Generation: 1},
+		Trackers: []string{"AITHER"},
+	})
+	if err != nil {
+		t.Fatalf("check accepted: %v", err)
+	}
+	if checker.calls != 1 || checker.options.SkipRemote {
+		t.Fatalf("checker/skip = %d/%t", checker.calls, checker.options.SkipRemote)
+	}
+}
diff --git a/internal/core/dvd_menus.go b/internal/core/dvd_menus.go
index 7ff1fed1..0d90440d 100644
--- a/internal/core/dvd_menus.go
+++ b/internal/core/dvd_menus.go
@@ -5,94 +5,59 @@ package core
 
 import (
 	"context"
-	"errors"
-	"fmt"
-	"strings"
 
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 // DVDMenuCapability reports the pure-Go engine version and the external
 // FFmpeg dvdvideo menu capability without returning executable paths.
 func (c *Core) DVDMenuCapability(ctx context.Context) (api.DVDMenuEngineInfo, error) {
-	if c == nil || c.services.DVDMenus == nil {
-		return api.DVDMenuEngineInfo{}, errors.New("core: DVD menu service not configured")
-	}
-	return wrapCoreResult(c.services.DVDMenus.Capability(ctx))
+	return c.media.dvdMenuCapability(ctx)
 }
 
-// CaptureDVDMenus captures and persists bounded menu screenshots for one DVD.
-// GUI requests require a prepared metadata cache; CLI requests prepare metadata
-// directly. Existing automatic captures are replaced only after rendering.
+// CaptureDVDMenus prepares one DVD source, then captures and persists bounded
+// menu screenshots. Existing automatic captures are replaced only after rendering.
 func (c *Core) CaptureDVDMenus(ctx context.Context, req api.Request) (api.DVDMenuCaptureResult, error) {
-	if c.services.DVDMenus == nil {
-		return api.DVDMenuCaptureResult{}, errors.New("core: DVD menu service not configured")
-	}
-	meta, err := c.resolveDVDMenuMetadata(ctx, req)
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
 		return api.DVDMenuCaptureResult{}, err
 	}
-	return wrapCoreResult(c.services.DVDMenus.Capture(ctx, meta, c.cfg.ScreenshotHandling.ResolvedMaxMenuItems()))
+	return c.CaptureAcceptedDVDMenus(ctx, api.MediaPlanInput{Release: ref})
+}
+
+// CaptureAcceptedDVDMenus captures from one exact prepared generation.
+func (c *Core) CaptureAcceptedDVDMenus(ctx context.Context, input api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	result, err := c.media.captureAcceptedDVDMenus(ctx, input)
+	return classifyOperationResult(api.OperationKindMedia, result, err)
 }
 
 // ListDVDMenuScreenshots lists persisted manual and generated menu screenshots
 // for one prepared release.
 func (c *Core) ListDVDMenuScreenshots(ctx context.Context, req api.Request) ([]api.ScreenshotImage, error) {
-	if c.services.DVDMenus == nil {
-		return nil, errors.New("core: DVD menu service not configured")
-	}
-	meta, err := c.resolveDVDMenuMetadata(ctx, req)
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
 		return nil, err
 	}
-	return wrapCoreResult(c.services.DVDMenus.List(ctx, meta))
+	return c.ListAcceptedDVDMenuScreenshots(ctx, api.MediaPlanInput{Release: ref})
+}
+
+// ListAcceptedDVDMenuScreenshots lists menu images for one exact generation.
+func (c *Core) ListAcceptedDVDMenuScreenshots(ctx context.Context, input api.MediaPlanInput) ([]api.ScreenshotImage, error) {
+	result, err := c.media.listAcceptedDVDMenuScreenshots(ctx, input)
+	return classifyOperationResult(api.OperationKindMedia, result, err)
 }
 
 // DeleteDVDMenuScreenshot removes one owned menu screenshot and its local
 // records for a prepared release. Remote-host assets are not deleted.
 func (c *Core) DeleteDVDMenuScreenshot(ctx context.Context, req api.Request, imagePath string) error {
-	if c.services.DVDMenus == nil {
-		return errors.New("core: DVD menu service not configured")
-	}
-	if strings.TrimSpace(imagePath) == "" {
-		return internalerrors.ErrInvalidInput
-	}
-	meta, err := c.resolveDVDMenuMetadata(ctx, req)
+	ref, err := c.prepareRequestRef(ctx, req, api.PreparationIntentMedia)
 	if err != nil {
 		return err
 	}
-	return wrapCoreError(c.services.DVDMenus.Delete(ctx, meta, imagePath))
+	return c.DeleteAcceptedDVDMenuScreenshot(ctx, api.MediaPlanInput{Release: ref}, imagePath)
 }
 
-// resolveDVDMenuMetadata requires exactly one prepared source. GUI requests use
-// the preview cache; non-GUI requests prepare metadata through the service.
-func (c *Core) resolveDVDMenuMetadata(ctx context.Context, req api.Request) (api.PreparedMetadata, error) {
-	path, err := c.resolveSinglePreparedMetaPath(ctx, req.Paths)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-	if req.Mode == api.ModeGUI {
-		if cached, ok, cacheErr := c.resolveGUICachedPreparedMeta(ctx, req, path); cacheErr != nil {
-			return api.PreparedMetadata{}, cacheErr
-		} else if ok {
-			return cached, nil
-		}
-		return api.PreparedMetadata{}, errors.New("core: DVD menu operation requires metadata preview")
-	}
-	if c.services.Metadata == nil {
-		return api.PreparedMetadata{}, errors.New("core: metadata service not configured")
-	}
-	options, err := c.applyDefaultOptions(req.Options)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-	singleReq := req
-	singleReq.Paths = []string{path}
-	singleReq.Options = options
-	meta, err := c.services.Metadata.Prepare(ctx, singleReq)
-	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("core: %w", err)
-	}
-	return meta, nil
+// DeleteAcceptedDVDMenuScreenshot deletes one menu image for an exact generation.
+func (c *Core) DeleteAcceptedDVDMenuScreenshot(ctx context.Context, input api.MediaPlanInput, imagePath string) error {
+	return classifyOperationError(api.OperationKindMedia, c.media.deleteAcceptedDVDMenuScreenshot(ctx, input, imagePath))
 }
diff --git a/internal/core/dvd_menus_test.go b/internal/core/dvd_menus_test.go
deleted file mode 100644
index 2df85dc0..00000000
--- a/internal/core/dvd_menus_test.go
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type recordingDVDMenuService struct {
-	meta       api.PreparedMetadata
-	maxItems   int
-	deleted    string
-	listed     bool
-	capability api.DVDMenuEngineInfo
-	probed     bool
-}
-
-func TestImportMenuImagesPersistsPurposeAndDeduplicatesManagedCopy(t *testing.T) {
-	t.Parallel()
-
-	repo, err := db.Open(":memory:")
-	if err != nil {
-		t.Fatalf("open repository: %v", err)
-	}
-	t.Cleanup(func() { _ = repo.Close() })
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repository: %v", err)
-	}
-
-	root := t.TempDir()
-	dbPath := filepath.Join(root, "db.sqlite")
-	sourcePath := filepath.Join(root, "Example.Release.2026.DVD-GRP")
-	originalPath := filepath.Join(t.TempDir(), "manual-menu.png")
-	if err := os.WriteFile(originalPath, []byte("synthetic menu image"), 0o600); err != nil {
-		t.Fatalf("write original menu: %v", err)
-	}
-	now := time.Now().UTC()
-	if err := repo.SaveFinalSelections(context.Background(), sourcePath, []api.ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: filepath.Join(root, "auto.png"), Order: 0, Source: api.ScreenshotSelectionSourceDVDMenu, SelectedAt: now},
-		{SourcePath: sourcePath, ImagePath: filepath.Join(root, "normal.png"), Order: 1, Source: "generated", SelectedAt: now},
-	}); err != nil {
-		t.Fatalf("seed selections: %v", err)
-	}
-	coreSvc := &Core{
-		cfg:      config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		services: api.ServiceSet{Filesystem: stubFS{}},
-		repo:     repo,
-	}
-	req := api.Request{Paths: []string{sourcePath}, Mode: api.ModeCLI}
-	for range 2 {
-		if err := coreSvc.ImportMenuImages(context.Background(), req, []string{originalPath}); err != nil {
-			t.Fatalf("import menu images: %v", err)
-		}
-	}
-
-	selections, err := repo.ListFinalSelections(context.Background(), sourcePath)
-	if err != nil {
-		t.Fatalf("list selections: %v", err)
-	}
-	if len(selections) != 3 {
-		t.Fatalf("selections = %#v, want auto/manual/normal", selections)
-	}
-	if selections[0].Source != api.ScreenshotSelectionSourceDVDMenu || selections[1].Source != api.ScreenshotSelectionSourceMenu || selections[2].Source != "generated" {
-		t.Fatalf("selection category order = %#v", selections)
-	}
-	if selections[1].ImagePath == originalPath {
-		t.Fatal("manual selection retained arbitrary original path")
-	}
-	if _, err := os.Stat(selections[1].ImagePath); err != nil {
-		t.Fatalf("managed menu copy missing: %v", err)
-	}
-	if _, err := os.Stat(originalPath); err != nil {
-		t.Fatalf("original menu changed: %v", err)
-	}
-	records, err := repo.ListScreenshotsByPath(context.Background(), sourcePath)
-	if err != nil {
-		t.Fatalf("list screenshots: %v", err)
-	}
-	if len(records) != 1 || records[0].ImagePath != selections[1].ImagePath || records[0].Purpose != api.ScreenshotPurposeMenu {
-		t.Fatalf("manual screenshot record = %#v", records)
-	}
-}
-
-func (s *recordingDVDMenuService) Capture(_ context.Context, meta api.PreparedMetadata, maxItems int) (api.DVDMenuCaptureResult, error) {
-	s.meta = meta
-	s.maxItems = maxItems
-	return api.DVDMenuCaptureResult{SourcePath: meta.SourcePath, MaxItems: maxItems}, nil
-}
-
-func (s *recordingDVDMenuService) List(_ context.Context, meta api.PreparedMetadata) ([]api.ScreenshotImage, error) {
-	s.meta = meta
-	s.listed = true
-	return []api.ScreenshotImage{{Path: "dvd-menu-01.png", Purpose: api.ScreenshotPurposeMenu}}, nil
-}
-
-func (s *recordingDVDMenuService) Delete(_ context.Context, meta api.PreparedMetadata, imagePath string) error {
-	s.meta = meta
-	s.deleted = imagePath
-	return nil
-}
-
-func (s *recordingDVDMenuService) Capability(context.Context) (api.DVDMenuEngineInfo, error) {
-	s.probed = true
-	return s.capability, nil
-}
-
-func TestDVDMenuCapabilityUsesConfiguredService(t *testing.T) {
-	t.Parallel()
-
-	menus := &recordingDVDMenuService{capability: api.DVDMenuEngineInfo{
-		EngineVersion:  "phase0a-1",
-		FFmpegDVDVideo: true,
-	}}
-	coreSvc := &Core{services: api.ServiceSet{DVDMenus: menus}}
-	info, err := coreSvc.DVDMenuCapability(context.Background())
-	if err != nil {
-		t.Fatalf("DVDMenuCapability: %v", err)
-	}
-	if !menus.probed || info.EngineVersion != "phase0a-1" || !info.FFmpegDVDVideo {
-		t.Fatalf("capability info = %#v probed=%t", info, menus.probed)
-	}
-}
-
-func TestDVDMenuCoreMethodsUsePreparedMetadataAndResolvedLimit(t *testing.T) {
-	t.Parallel()
-
-	menus := &recordingDVDMenuService{}
-	coreSvc := &Core{
-		cfg: config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		services: api.ServiceSet{
-			Filesystem: stubFS{},
-			Metadata:   &stubMeta{},
-			DVDMenus:   menus,
-		},
-	}
-	req := api.Request{Paths: []string{"Example.Release.2026.1080p-GRP"}, Mode: api.ModeCLI}
-
-	result, err := coreSvc.CaptureDVDMenus(context.Background(), req)
-	if err != nil {
-		t.Fatalf("CaptureDVDMenus: %v", err)
-	}
-	if result.SourcePath != req.Paths[0] || menus.meta.SourcePath != req.Paths[0] {
-		t.Fatalf("prepared source result=%q service=%q", result.SourcePath, menus.meta.SourcePath)
-	}
-	if result.MaxItems != config.DefaultDVDMenuItems || menus.maxItems != config.DefaultDVDMenuItems {
-		t.Fatalf("resolved max result=%d service=%d", result.MaxItems, menus.maxItems)
-	}
-
-	images, err := coreSvc.ListDVDMenuScreenshots(context.Background(), req)
-	if err != nil {
-		t.Fatalf("ListDVDMenuScreenshots: %v", err)
-	}
-	if !menus.listed || len(images) != 1 || images[0].Purpose != api.ScreenshotPurposeMenu {
-		t.Fatalf("list result = %+v", images)
-	}
-
-	if err := coreSvc.DeleteDVDMenuScreenshot(context.Background(), req, images[0].Path); err != nil {
-		t.Fatalf("DeleteDVDMenuScreenshot: %v", err)
-	}
-	if menus.deleted != images[0].Path {
-		t.Fatalf("deleted = %q, want %q", menus.deleted, images[0].Path)
-	}
-}
diff --git a/internal/core/e2e_disabled.go b/internal/core/e2e_disabled.go
index 77196870..10c2e731 100644
--- a/internal/core/e2e_disabled.go
+++ b/internal/core/e2e_disabled.go
@@ -9,10 +9,9 @@ import (
 	"context"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func maybeApplyE2EServices(context.Context, *api.ServiceSet, config.Config, db.MetadataRepository, api.Logger) error {
+func maybeApplyE2EServices(context.Context, *api.ServiceSet, config.Config, api.RepositoryCapabilities, api.Logger) error {
 	return nil
 }
diff --git a/internal/core/e2e_enabled.go b/internal/core/e2e_enabled.go
index ec4199ee..dbe10bc6 100644
--- a/internal/core/e2e_enabled.go
+++ b/internal/core/e2e_enabled.go
@@ -19,10 +19,14 @@ import (
 	"strings"
 	"time"
 
+	"github.com/autobrr/upbrr/internal/clientdiscovery"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -30,10 +34,15 @@ const (
 	e2eEnabledEnv    = "UPBRR_E2E_FAKE_SERVICES"
 	e2eTrackerURLEnv = "UPBRR_E2E_TRACKER_URL"
 	e2eImageURLEnv   = "UPBRR_E2E_IMAGE_URL"
+	e2eClientURLEnv  = "UPBRR_E2E_CLIENT_URL"
 	e2eShotPathEnv   = "UPBRR_E2E_SCREENSHOT_PATH"
+	e2eResolutionEnv = "UPBRR_E2E_RESOLUTION"
+	e2eDuplicateEnv  = "UPBRR_E2E_DUPLICATE_TRACKERS"
 )
 
-func maybeApplyE2EServices(_ context.Context, services *api.ServiceSet, cfg config.Config, repo db.MetadataRepository, logger api.Logger) error {
+// maybeApplyE2EServices replaces only missing runtime capabilities when both
+// the e2e build tag and fake-services environment gate are active.
+func maybeApplyE2EServices(_ context.Context, services *api.ServiceSet, cfg config.Config, repositories api.RepositoryCapabilities, logger api.Logger) error {
 	if !isE2EEnabled() {
 		return nil
 	}
@@ -45,26 +54,38 @@ func maybeApplyE2EServices(_ context.Context, services *api.ServiceSet, cfg conf
 		return fmt.Errorf("core: e2e tmp root: %w", err)
 	}
 	logger.Infof("core: using e2e fake services")
+	if services.Clients == nil {
+		services.Clients = e2eClientService{endpoint: os.Getenv(e2eClientURLEnv)}
+	}
 	if services.Metadata == nil {
-		services.Metadata = e2eMetadataService{repo: repo}
+		services.Metadata = e2eMetadataService{
+			repo:    repositories.ReleaseState(),
+			clients: clientdiscovery.New(services.Clients, logger),
+		}
 	}
 	if services.Torrents == nil {
 		services.Torrents = e2eTorrentService{dbPath: cfg.MainSettings.DBPath}
 	}
 	if services.Trackers == nil {
-		services.Trackers = e2eTrackerService{endpoint: os.Getenv(e2eTrackerURLEnv), repo: repo}
+		services.Trackers = e2eTrackerService{endpoint: os.Getenv(e2eTrackerURLEnv), repo: repositories.Uploads()}
 	}
 	if services.Images == nil {
-		services.Images = e2eImageService{endpoint: os.Getenv(e2eImageURLEnv), shotPath: os.Getenv(e2eShotPathEnv), tmpRoot: tmpRoot, repo: repo}
+		services.Images = e2eImageService{
+			endpoint: os.Getenv(e2eImageURLEnv),
+			shotPath: os.Getenv(e2eShotPathEnv),
+			tmpRoot:  tmpRoot,
+			repo:     repositories.Media(),
+		}
 	}
 	if services.Screenshots == nil {
-		services.Screenshots = e2eScreenshotService{shotPath: os.Getenv(e2eShotPathEnv), tmpRoot: tmpRoot, repo: repo}
-	}
-	if services.Clients == nil {
-		services.Clients = e2eClientService{}
+		services.Screenshots = e2eScreenshotService{
+			shotPath: os.Getenv(e2eShotPathEnv),
+			tmpRoot:  tmpRoot,
+			repo:     repositories.Media(),
+		}
 	}
 	if services.Dupes == nil {
-		services.Dupes = e2eDupeService{}
+		services.Dupes = e2eDupeService{cfg: cfg}
 	}
 	if services.TrackerAuth == nil {
 		services.TrackerAuth = e2eTrackerAuthService{}
@@ -77,25 +98,47 @@ func isE2EEnabled() bool {
 	return value == "1" || strings.EqualFold(value, "true")
 }
 
+// e2eMetadataService supplies deterministic preparation evidence under the
+// e2e-only fake-services gate.
 type e2eMetadataService struct {
-	repo db.MetadataRepository
-}
-
-func (s e2eMetadataService) Prepare(ctx context.Context, req api.Request) (api.PreparedMetadata, error) {
-	if len(req.Paths) == 0 || strings.TrimSpace(req.Paths[0]) == "" {
-		return api.PreparedMetadata{}, errors.New("e2e metadata: path is required")
-	}
-	sourcePath := strings.TrimSpace(req.Paths[0])
-	trackers := append([]string{}, req.Trackers...)
-	if len(trackers) == 0 {
-		trackers = []string{"BTN"}
-	}
-	meta := api.PreparedMetadata{
-		SourcePath:        sourcePath,
-		Paths:             []string{sourcePath},
-		Mode:              req.Mode,
-		Options:           req.Options,
-		Trackers:          trackers,
+	repo interface {
+		Save(context.Context, api.FileMetadata) error
+	}
+	clients *clientdiscovery.Module
+}
+
+// CollectPreparationEvidence emits deterministic progress and metadata while
+// exercising the same client-discovery boundary as production preparation.
+func (s e2eMetadataService) CollectPreparationEvidence(ctx context.Context, request preparationstate.Request) (preparationstate.State, error) {
+	input := request.Input
+	if strings.TrimSpace(input.SourcePath) == "" {
+		return preparationstate.State{}, errors.New("e2e metadata: path is required")
+	}
+	sourcePath := strings.TrimSpace(input.SourcePath)
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhaseSourceEvidence, api.PreparationProgressRunning, "Collecting synthetic source evidence."),
+	)
+	if request.Layout.DiscType == "BDMV" {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressRunning, "Scanning selected Blu-ray playlist."),
+		)
+	}
+	resolution := strings.TrimSpace(os.Getenv(e2eResolutionEnv))
+	if resolution == "" {
+		resolution = "1080p"
+	}
+	meta := preparationstate.State{
+		SourcePath: sourcePath,
+		Paths:      []string{sourcePath},
+		FileList:   []string{sourcePath},
+		Policy: preparationstate.CollectionPolicy{
+			OnlyID:          input.Policy.OnlyID,
+			KeepFolder:      input.Policy.KeepFolder,
+			KeepImages:      input.Policy.KeepImages,
+			InteractionMode: input.Controls.Interaction,
+		},
 		ReleaseName:       "E2E.Movie.2026.1080p.WEB-DL.DD5.1.H264-UPBRR",
 		ReleaseNameNoTag:  "E2E.Movie.2026.1080p.WEB-DL.DD5.1.H264",
 		ReleaseNameClean:  "E2E Movie 2026 1080p WEB-DL DD5.1 H264",
@@ -110,45 +153,67 @@ func (s e2eMetadataService) Prepare(ctx context.Context, req api.Request) (api.P
 		Channels:          "5.1",
 		AudioLanguages:    []string{"English"},
 		SubtitleLanguages: []string{"English"},
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: sourcePath,
-			TMDBID:     1001,
-			IMDBID:     1234567,
-			Category:   string(api.CategoryMovie),
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: sourcePath,
-			TMDB: &api.TMDBMetadata{
-				TMDBID:           1001,
-				IMDBID:           1234567,
-				Category:         string(api.CategoryMovie),
-				Title:            "E2E Movie",
-				OriginalTitle:    "E2E Movie",
-				Year:             2026,
-				ReleaseDate:      "2026-01-02",
-				OriginalLanguage: "en",
-				Overview:         "Deterministic E2E metadata fixture.",
-			},
-		},
 		Release: api.ReleaseInfo{
 			Category:   string(api.CategoryMovie),
 			Type:       "WEBDL",
 			Title:      "E2E Movie",
 			Year:       2026,
 			Source:     "WEB-DL",
-			Resolution: "1080p",
+			Resolution: resolution,
 			Ext:        ".mkv",
 			Group:      "UPBRR",
 		},
 		DescriptionTemplate: "E2E description fixture.",
-		DescriptionGroups: []api.DescriptionBuilderGroup{{
-			GroupKey:           "unit3d",
-			Trackers:           trackers,
-			RawDescription:     "E2E description fixture.",
-			RawDescriptionHTML: "<p>E2E description fixture.</p>",
-			Description:        "E2E description fixture.",
-			DescriptionHTML:    "<p>E2E description fixture.</p>",
-		}},
+	}
+	if s.clients != nil {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseClientDiscovery, api.PreparationProgressRunning, "Searching the synthetic torrent client."),
+		)
+		evidence, err := s.clients.Discover(ctx, clientdiscovery.SearchInput{
+			SourcePath:   sourcePath,
+			FileList:     meta.FileList,
+			DiscType:     request.Layout.DiscType,
+			Policy:       input.Search,
+			ForceRecheck: input.Controls.ForceRecheck,
+		})
+		if err != nil {
+			return preparationstate.State{}, fmt.Errorf("e2e metadata: discover client evidence: %w", err)
+		}
+		meta.InfoHash = evidence.InfoHash
+		meta.DiscoveredTorrentPath = evidence.TorrentPath
+		meta.TrackerIDs = evidence.TrackerIDs
+		meta.FoundTrackerMatch = evidence.FoundTrackerMatch
+		meta.EvidenceTrackers = append([]string(nil), evidence.MatchedTrackers...)
+		meta.MatchedEvidenceTrackers = append([]string(nil), evidence.MatchedTrackers...)
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(
+				api.PreparationPhaseClientDiscovery,
+				api.PreparationProgressCompleted,
+				"Synthetic torrent client search complete.",
+			),
+		)
+	}
+	meta.Identity = api.ExternalIdentity{
+		SourcePath: sourcePath,
+		TMDBID:     1001,
+		IMDBID:     1234567,
+		Category:   api.CanonicalCategoryMovie,
+	}
+	meta.ProviderMetadata = api.SourceScopedMetadata{
+		SourcePath: sourcePath,
+		TMDB: &api.TMDBMetadata{
+			TMDBID:           1001,
+			IMDBID:           1234567,
+			Category:         string(api.CategoryMovie),
+			Title:            "E2E Movie",
+			OriginalTitle:    "E2E Movie",
+			Year:             2026,
+			ReleaseDate:      "2026-01-02",
+			OriginalLanguage: "en",
+			Overview:         "Deterministic E2E metadata fixture.",
+		},
 	}
 	if s.repo != nil {
 		if info, err := os.Stat(sourcePath); err == nil {
@@ -167,44 +232,19 @@ func (s e2eMetadataService) Prepare(ctx context.Context, req api.Request) (api.P
 			Ext:        meta.Release.Ext,
 			Group:      meta.Release.Group,
 		}); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("e2e metadata: save: %w", err)
+			return preparationstate.State{}, fmt.Errorf("e2e metadata: save: %w", err)
 		}
 	}
-	return meta, nil
-}
-
-func (e e2eMetadataService) RefreshPreparedMetadata(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	if strings.TrimSpace(meta.ReleaseName) == "" {
-		prepared, err := e.Prepare(context.Background(), api.Request{Paths: []string{meta.SourcePath}, Mode: meta.Mode, Trackers: meta.Trackers, Options: meta.Options})
-		if err != nil {
-			return api.PreparedMetadata{}, err
-		}
-		return prepared, nil
+	if request.Layout.DiscType == "BDMV" {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressCompleted, "Blu-ray analysis complete."),
+		)
 	}
-	return meta, nil
-}
-
-func (e2eMetadataService) EnrichTrackerData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (e2eMetadataService) ApplyMediaInfoIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (e2eMetadataService) ApplyArrData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (e2eMetadataService) ResolveExternalIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (e2eMetadataService) ApplyMediaDetails(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (e2eMetadataService) ApplyTrackerClaims(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhaseSourceEvidence, api.PreparationProgressCompleted, "Synthetic source evidence complete."),
+	)
 	return meta, nil
 }
 
@@ -212,7 +252,7 @@ type e2eTorrentService struct {
 	dbPath string
 }
 
-func (s e2eTorrentService) Create(_ context.Context, meta api.PreparedMetadata) (api.TorrentResult, error) {
+func (s e2eTorrentService) Create(_ context.Context, meta api.TorrentSubject) (api.TorrentResult, error) {
 	root := filepath.Dir(strings.TrimSpace(s.dbPath))
 	if root == "." || root == "" {
 		root = os.TempDir()
@@ -229,26 +269,102 @@ func (s e2eTorrentService) Create(_ context.Context, meta api.PreparedMetadata)
 	return api.TorrentResult{Path: path, InfoHash: "0123456789abcdef0123456789abcdef01234567"}, nil
 }
 
-type e2eClientService struct{}
+// e2eClientService obtains deterministic pathed-torrent evidence from the fake E2E server.
+type e2eClientService struct {
+	endpoint string
+}
 
-func (e2eClientService) Inject(context.Context, api.PreparedMetadata, api.TorrentResult) error {
+func (s e2eClientService) Inject(ctx context.Context, _ api.ClientSubject, _ api.TorrentResult) error {
+	endpoint := strings.TrimRight(strings.TrimSpace(s.endpoint), "/")
+	if endpoint == "" {
+		return errors.New("e2e client: endpoint is required")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint+"/client-inject", http.NoBody)
+	if err != nil {
+		return fmt.Errorf("e2e client: injection request: %w", err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("e2e client: inject: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("e2e client: injection status %d", resp.StatusCode)
+	}
 	return nil
 }
 
-func (e2eClientService) SearchPathedTorrents(context.Context, api.PreparedMetadata) (api.ClientSearchResult, error) {
-	return api.ClientSearchResult{}, nil
+// SearchPathedTorrents verifies the fake client endpoint and returns stable evidence.
+func (s e2eClientService) SearchPathedTorrents(ctx context.Context, _ api.ClientSubject) (api.ClientSearchResult, error) {
+	endpoint := strings.TrimRight(strings.TrimSpace(s.endpoint), "/")
+	if endpoint == "" {
+		return api.ClientSearchResult{}, errors.New("e2e client: endpoint is required")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint+"/client-search", http.NoBody)
+	if err != nil {
+		return api.ClientSearchResult{}, fmt.Errorf("e2e client: request: %w", err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return api.ClientSearchResult{}, fmt.Errorf("e2e client: search: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return api.ClientSearchResult{}, fmt.Errorf("e2e client: status %d", resp.StatusCode)
+	}
+	return api.ClientSearchResult{
+		InfoHash:   "0123456789abcdef0123456789abcdef01234567",
+		TrackerIDs: map[string]string{"btn": "e2e-pathed-id"},
+	}, nil
 }
 
-type e2eDupeService struct{}
+type e2eDupeService struct {
+	cfg config.Config
+}
 
-func (e2eDupeService) Check(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.DupeCheckSummary, error) {
+func (e2eDupeService) Check(_ context.Context, meta api.DuplicateSubject, trackers []string) (api.DupeCheckSummary, error) {
+	duplicateTrackers := make(map[string]struct{})
+	for _, tracker := range strings.Split(os.Getenv(e2eDuplicateEnv), ",") {
+		if name := strings.ToUpper(strings.TrimSpace(tracker)); name != "" {
+			duplicateTrackers[name] = struct{}{}
+		}
+	}
 	results := make([]api.DupeCheckResult, 0, len(trackers))
 	for _, tracker := range trackers {
-		results = append(results, api.DupeCheckResult{Tracker: strings.ToUpper(strings.TrimSpace(tracker)), Status: "completed"})
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		result := api.DupeCheckResult{Tracker: name, Status: "completed"}
+		if _, ok := duplicateTrackers[name]; ok {
+			result.HasDupes = true
+			result.Filtered = []api.DupeEntry{{
+				ID:   "e2e-dupe-1",
+				Name: "Example.Release.2026.1080p-GRP",
+			}}
+		}
+		results = append(results, result)
 	}
 	return api.DupeCheckSummary{SourcePath: meta.SourcePath, Results: results}, nil
 }
 
+func (s e2eDupeService) CheckWithAssessment(
+	ctx context.Context,
+	meta api.DuplicateSubject,
+	trackers []string,
+	_ dupechecking.CheckOptions,
+) (api.DupeCheckSummary, dupechecking.Assessment, error) {
+	summary, err := s.Check(ctx, meta, trackers)
+	evidence := make([]dupechecking.AssessmentEvidence, 0, len(summary.Results))
+	for _, result := range summary.Results {
+		evidence = append(evidence, dupechecking.AssessmentEvidence{
+			Tracker:     result.Tracker,
+			Disposition: dupechecking.DispositionResolved,
+			HasDupes:    result.HasDupes,
+			Match:       result.Match,
+			Raw:         result.Raw,
+		})
+	}
+	return summary, dupechecking.NewAssessment(meta, s.cfg, evidence), err
+}
+
 // e2eTrackerAuthService keeps fake-services runs isolated from tracker auth IO.
 type e2eTrackerAuthService struct{}
 
@@ -268,10 +384,10 @@ func (e2eTrackerAuthService) ValidateMany(_ context.Context, trackerIDs []string
 
 type e2eTrackerService struct {
 	endpoint string
-	repo     db.MetadataRepository
+	repo     api.UploadLedgerRepository
 }
 
-func (s e2eTrackerService) Upload(ctx context.Context, meta api.PreparedMetadata) (api.UploadSummary, error) {
+func (s e2eTrackerService) Upload(ctx context.Context, meta api.UploadSubject) (api.UploadSummary, error) {
 	trackers := meta.Trackers
 	if len(trackers) == 0 {
 		trackers = []string{"BTN"}
@@ -283,7 +399,12 @@ func (s e2eTrackerService) Upload(ctx context.Context, meta api.PreparedMetadata
 			continue
 		}
 		if s.repo != nil {
-			if err := s.repo.CreateUploadRecord(ctx, db.UploadRecord{Tracker: name, Status: "pending", SourcePath: meta.SourcePath, CreatedAt: time.Now().UTC()}); err != nil {
+			if err := s.repo.CreateUploadRecord(ctx, db.UploadRecord{
+				Tracker:    name,
+				Status:     "pending",
+				SourcePath: meta.SourcePath,
+				CreatedAt:  time.Now().UTC(),
+			}); err != nil {
 				return api.UploadSummary{}, fmt.Errorf("e2e tracker: create record: %w", err)
 			}
 		}
@@ -311,7 +432,7 @@ func (s e2eTrackerService) Upload(ctx context.Context, meta api.PreparedMetadata
 	return summary, nil
 }
 
-func (s e2eTrackerService) BuildPreparation(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.PreparationPreview, error) {
+func (s e2eTrackerService) BuildPreparation(_ context.Context, meta api.DescriptionSubject, trackers []string) (api.PreparationPreview, error) {
 	if len(trackers) == 0 {
 		trackers = meta.Trackers
 	}
@@ -325,7 +446,7 @@ func (s e2eTrackerService) BuildPreparation(_ context.Context, meta api.Prepared
 	}}}, nil
 }
 
-func (s e2eTrackerService) BuildUploadDryRun(_ context.Context, meta api.PreparedMetadata, trackers []string) ([]api.TrackerDryRunEntry, error) {
+func (s e2eTrackerService) BuildUploadDryRun(_ context.Context, meta api.UploadSubject, trackers []string) ([]api.TrackerDryRunEntry, error) {
 	if len(trackers) == 0 {
 		trackers = meta.Trackers
 	}
@@ -348,7 +469,11 @@ func (s e2eTrackerService) BuildUploadDryRun(_ context.Context, meta api.Prepare
 				"name":     meta.ReleaseName,
 				"category": string(api.CategoryMovie),
 			},
-			Files: []api.TrackerDryRunFile{{Field: "torrent", Path: meta.TorrentPath, Present: strings.TrimSpace(meta.TorrentPath) != ""}},
+			Files: []api.TrackerDryRunFile{{
+				Field:   "torrent",
+				Path:    meta.TorrentPath,
+				Present: strings.TrimSpace(meta.TorrentPath) != "",
+			}},
 			ImageHost: api.ImageHostFeedback{
 				Status:       "ready",
 				SelectedHost: "imgbb",
@@ -359,7 +484,11 @@ func (s e2eTrackerService) BuildUploadDryRun(_ context.Context, meta api.Prepare
 	return entries, nil
 }
 
-func postE2ETrackerUpload(ctx context.Context, endpoint string, tracker string, meta api.PreparedMetadata) error {
+func (s e2eTrackerService) BuildUploadReview(ctx context.Context, meta api.UploadSubject, trackers []string) ([]api.TrackerDryRunEntry, error) {
+	return s.BuildUploadDryRun(ctx, meta, trackers)
+}
+
+func postE2ETrackerUpload(ctx context.Context, endpoint string, tracker string, meta api.UploadSubject) error {
 	if strings.TrimSpace(endpoint) == "" {
 		return errors.New("e2e tracker: endpoint is required")
 	}
@@ -409,18 +538,26 @@ type e2eImageService struct {
 	endpoint string
 	shotPath string
 	tmpRoot  string
-	repo     db.MetadataRepository
+	repo     interface {
+		SaveUploadedImages(context.Context, string, string, []api.UploadedImageLink) error
+	}
 }
 
-func (s e2eImageService) ListCandidates(_ context.Context, meta api.PreparedMetadata) ([]api.ScreenshotImage, error) {
-	shot, err := e2eManagedScreenshot(s.shotPath, s.tmpRoot, meta)
+func (s e2eImageService) ListCandidates(_ context.Context, meta api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
+	shot, err := e2eManagedScreenshot(s.shotPath, s.tmpRoot, filepath.Base(meta.SourcePath))
 	if err != nil {
 		return nil, err
 	}
 	return []api.ScreenshotImage{shot}, nil
 }
 
-func (s e2eImageService) Upload(ctx context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+func (s e2eImageService) Upload(
+	ctx context.Context,
+	meta api.ImageHostingSubject,
+	host string,
+	usageScope string,
+	images []api.ScreenshotImage,
+) ([]api.UploadedImageLink, error) {
 	if strings.TrimSpace(s.endpoint) == "" {
 		return nil, errors.New("e2e image: endpoint is required")
 	}
@@ -491,34 +628,41 @@ func postE2EImageUpload(ctx context.Context, endpoint string, host string, image
 type e2eScreenshotService struct {
 	shotPath string
 	tmpRoot  string
-	repo     db.MetadataRepository
+	repo     api.ScreenshotLifecycleRepository
 }
 
-func (s e2eScreenshotService) Plan(_ context.Context, meta api.PreparedMetadata, _ int) (api.ScreenshotPlan, error) {
-	shot, err := s.image(meta)
-	if err != nil {
-		return api.ScreenshotPlan{}, err
-	}
+func (s e2eScreenshotService) Plan(_ context.Context, meta api.ScreenshotSubject, _ int) (api.ScreenshotPlan, error) {
 	return api.ScreenshotPlan{
-		SourcePath:          meta.SourcePath,
-		DurationSeconds:     120,
-		FrameRate:           24,
-		SuggestedSelections: []api.ScreenshotSelection{{Index: 1, TimestampSeconds: shot.TimestampSeconds, Frame: 240}},
-		ExistingScreenshots: []api.ScreenshotImage{shot},
-		FinalSelections:     []api.ScreenshotImage{shot},
+		SourcePath:      meta.SourcePath,
+		DurationSeconds: 120,
+		FrameRate:       24,
+		SuggestedSelections: []api.ScreenshotSelection{{
+			Index:            1,
+			TimestampSeconds: 10,
+			Frame:            240,
+		}},
 	}, nil
 }
 
-func (s e2eScreenshotService) Capture(_ context.Context, meta api.PreparedMetadata, _ []api.ScreenshotSelection, purpose api.ScreenshotPurpose) (api.ScreenshotResult, error) {
+func (s e2eScreenshotService) Capture(
+	_ context.Context,
+	meta api.ScreenshotSubject,
+	_ []api.ScreenshotSelection,
+	purpose api.ScreenshotPurpose,
+) (api.ScreenshotResult, error) {
 	shot, err := s.image(meta)
 	if err != nil {
 		return api.ScreenshotResult{}, err
 	}
 	shot.Purpose = purpose
-	return api.ScreenshotResult{SourcePath: meta.SourcePath, Purpose: purpose, Images: []api.ScreenshotImage{shot}}, nil
+	return api.ScreenshotResult{
+		SourcePath: meta.SourcePath,
+		Purpose:    purpose,
+		Images:     []api.ScreenshotImage{shot},
+	}, nil
 }
 
-func (s e2eScreenshotService) PreviewFrame(_ context.Context, meta api.PreparedMetadata, timestampSeconds float64) (api.ScreenshotPreview, error) {
+func (s e2eScreenshotService) PreviewFrame(_ context.Context, meta api.ScreenshotSubject, timestampSeconds float64) (api.ScreenshotPreview, error) {
 	shot, err := s.image(meta)
 	if err != nil {
 		return api.ScreenshotPreview{}, err
@@ -527,14 +671,20 @@ func (s e2eScreenshotService) PreviewFrame(_ context.Context, meta api.PreparedM
 	if err != nil {
 		return api.ScreenshotPreview{}, fmt.Errorf("e2e screenshots: read preview: %w", err)
 	}
-	return api.ScreenshotPreview{TimestampSeconds: timestampSeconds, ImageBytes: payload, Width: shot.Width, Height: shot.Height, SizeBytes: shot.SizeBytes}, nil
+	return api.ScreenshotPreview{
+		TimestampSeconds: timestampSeconds,
+		ImageBytes:       payload,
+		Width:            shot.Width,
+		Height:           shot.Height,
+		SizeBytes:        shot.SizeBytes,
+	}, nil
 }
 
-func (s e2eScreenshotService) Delete(_ context.Context, _ api.PreparedMetadata, _ string) error {
+func (s e2eScreenshotService) Delete(_ context.Context, _ api.ScreenshotSubject, _ string) error {
 	return nil
 }
 
-func (s e2eScreenshotService) SaveFinalSelections(ctx context.Context, meta api.PreparedMetadata, images []api.ScreenshotImage) error {
+func (s e2eScreenshotService) SaveFinalSelections(ctx context.Context, meta api.ScreenshotSubject, images []api.ScreenshotImage) error {
 	if s.repo == nil {
 		return nil
 	}
@@ -548,17 +698,14 @@ func (s e2eScreenshotService) SaveFinalSelections(ctx context.Context, meta api.
 			SelectedAt: time.Now().UTC(),
 		})
 	}
-	if lifecycle, ok := s.repo.(api.ScreenshotLifecycleRepository); ok {
-		return lifecycle.ReplaceNormalFinalSelections(ctx, meta.SourcePath, selections)
-	}
-	return s.repo.SaveFinalSelections(ctx, meta.SourcePath, selections)
+	return s.repo.ReplaceNormalFinalSelections(ctx, meta.SourcePath, selections)
 }
 
-func (s e2eScreenshotService) image(meta api.PreparedMetadata) (api.ScreenshotImage, error) {
-	return e2eManagedScreenshot(s.shotPath, s.tmpRoot, meta)
+func (s e2eScreenshotService) image(meta api.ScreenshotSubject) (api.ScreenshotImage, error) {
+	return e2eManagedScreenshot(s.shotPath, s.tmpRoot, filepath.Base(meta.SourcePath))
 }
 
-func e2eManagedScreenshot(shotPath string, tmpRoot string, meta api.PreparedMetadata) (api.ScreenshotImage, error) {
+func e2eManagedScreenshot(shotPath string, tmpRoot string, releaseName string) (api.ScreenshotImage, error) {
 	path := strings.TrimSpace(shotPath)
 	if path == "" {
 		return api.ScreenshotImage{}, errors.New("e2e screenshots: screenshot path is required")
@@ -571,7 +718,7 @@ func e2eManagedScreenshot(shotPath string, tmpRoot string, meta api.PreparedMeta
 	if err != nil {
 		return api.ScreenshotImage{}, fmt.Errorf("e2e screenshots: read fixture: %w", err)
 	}
-	release := strings.TrimSpace(meta.ReleaseName)
+	release := strings.TrimSpace(releaseName)
 	if release == "" {
 		release = "e2e-release"
 	}
@@ -595,7 +742,15 @@ func e2eManagedScreenshot(shotPath string, tmpRoot string, meta api.PreparedMeta
 	if err != nil {
 		return api.ScreenshotImage{}, fmt.Errorf("e2e screenshots: stat managed screenshot: %w", err)
 	}
-	return api.ScreenshotImage{Index: 1, TimestampSeconds: 10, Path: managedPath, Purpose: api.ScreenshotPurposeFinal, Width: 320, Height: 180, SizeBytes: info.Size()}, nil
+	return api.ScreenshotImage{
+		Index:            1,
+		TimestampSeconds: 10,
+		Path:             managedPath,
+		Purpose:          api.ScreenshotPurposeFinal,
+		Width:            320,
+		Height:           180,
+		SizeBytes:        info.Size(),
+	}, nil
 }
 
 func writeJSONE2E(w io.Writer, value any) error {
diff --git a/internal/core/history.go b/internal/core/history.go
new file mode 100644
index 00000000..7ee1f0b1
--- /dev/null
+++ b/internal/core/history.go
@@ -0,0 +1,150 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"strings"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// historyModule owns history read shaping and deletion policy. Its repository
+// and logger are borrowed; Core remains responsible for repository lifetime.
+type historyModule struct {
+	repo          api.HistoryRepository
+	dbPath        string
+	fs            historyFilesystem
+	logger        api.Logger
+	preparedFacts *preparedrelease.Module
+}
+
+type historyFilesystem interface {
+	Stat(name string) (fs.FileInfo, error)
+	ReadDir(name string) ([]fs.DirEntry, error)
+	Remove(name string) error
+	RemoveAll(path string) error
+}
+
+type osHistoryFilesystem struct{}
+
+func (osHistoryFilesystem) Stat(name string) (fs.FileInfo, error) {
+	//nolint:wrapcheck // Adapter preserves OS error identity for existing cleanup policy.
+	return os.Stat(name)
+}
+
+func (osHistoryFilesystem) ReadDir(name string) ([]fs.DirEntry, error) {
+	//nolint:wrapcheck // Adapter preserves OS error identity for existing cleanup policy.
+	return os.ReadDir(name)
+}
+
+func (osHistoryFilesystem) Remove(name string) error {
+	//nolint:wrapcheck // Adapter preserves OS error identity for existing cleanup policy.
+	return os.Remove(name)
+}
+
+func (osHistoryFilesystem) RemoveAll(path string) error {
+	//nolint:wrapcheck // Adapter preserves OS error identity for existing cleanup policy.
+	return os.RemoveAll(path)
+}
+
+func newHistoryModule(repo api.HistoryRepository, dbPath string, logger api.Logger) *historyModule {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &historyModule{
+		repo:   repo,
+		dbPath: dbPath,
+		fs:     osHistoryFilesystem{},
+		logger: logger,
+	}
+}
+
+func (h *historyModule) List(ctx context.Context) ([]api.HistoryEntry, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("core: list history canceled: %w", err)
+	}
+	if h == nil || h.repo == nil {
+		return nil, errors.New("core: repository not initialized")
+	}
+
+	entries, err := h.repo.ListHistoryEntries(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("core: %w", err)
+	}
+
+	result := make([]api.HistoryEntry, 0, len(entries))
+	for _, entry := range entries {
+		entryCopy := entry
+		entryCopy.LatestUploadStatus = api.HistoryStatusLabel(entry.LatestUploadStatus, entry.RuleFailureCount)
+		result = append(result, entryCopy)
+	}
+	return result, nil
+}
+
+func (h *historyModule) Overview(ctx context.Context, sourcePath string) (api.HistoryOverview, error) {
+	if err := ctx.Err(); err != nil {
+		return api.HistoryOverview{}, fmt.Errorf("core: get history overview canceled: %w", err)
+	}
+	trimmed := strings.TrimSpace(sourcePath)
+	if trimmed == "" {
+		return api.HistoryOverview{}, internalerrors.ErrInvalidInput
+	}
+	if h == nil || h.repo == nil {
+		return api.HistoryOverview{}, errors.New("core: repository not initialized")
+	}
+
+	record, err := h.repo.LoadHistoryRecord(ctx, trimmed)
+	if err != nil {
+		return api.HistoryOverview{}, fmt.Errorf("core: %w", err)
+	}
+	overview := historyOverviewFromRecord(record)
+	if record.PreparedReleaseRef != nil {
+		if h.preparedFacts == nil {
+			return api.HistoryOverview{}, errors.New("core: canonical preparation is not configured")
+		}
+		prepared, resolveErr := h.preparedFacts.ResolveResult(ctx, *record.PreparedReleaseRef)
+		if resolveErr != nil {
+			return api.HistoryOverview{}, fmt.Errorf("core: resolve history prepared generation: %w", resolveErr)
+		}
+		display, displayErr := h.preparedFacts.ResolveDisplay(ctx, *record.PreparedReleaseRef)
+		if displayErr != nil {
+			return api.HistoryOverview{}, fmt.Errorf("core: project history prepared generation: %w", displayErr)
+		}
+		overview.Release = *record.PreparedReleaseRef
+		overview.Identity = prepared.Release.Identity
+		overview.Display = display
+	}
+	overview.StatusLabel = api.HistoryStatusLabel(overview.LatestUploadStatus, api.CountBlockingRuleFailures(overview.TrackerRuleFailures))
+	return overview, nil
+}
+
+func historyOverviewFromRecord(record api.HistoryRecord) api.HistoryOverview {
+	return api.HistoryOverview{
+		SourcePath:           record.SourcePath,
+		ReleaseTitle:         record.ReleaseTitle,
+		ReleaseSource:        record.ReleaseSource,
+		ReleaseResolution:    record.ReleaseResolution,
+		MetadataUpdatedAt:    record.MetadataUpdatedAt,
+		LatestUploadStatus:   record.LatestUploadStatus,
+		LatestUploadAt:       record.LatestUploadAt,
+		Metadata:             record.Metadata,
+		ReleaseNameOverrides: record.ReleaseNameOverrides,
+		DescriptionOverride:  record.DescriptionOverride,
+		DescriptionOverrides: append([]api.DescriptionOverride(nil), record.DescriptionOverrides...),
+		PlaylistSelection:    record.PlaylistSelection,
+		TrackerMetadata:      append([]api.TrackerMetadata(nil), record.TrackerMetadata...),
+		TrackerRuleFailures:  append([]api.TrackerRuleFailure(nil), record.TrackerRuleFailures...),
+		Screenshots:          append([]api.Screenshot(nil), record.Screenshots...),
+		FinalSelections:      append([]api.ScreenshotFinalSelection(nil), record.FinalSelections...),
+		UploadedImages:       append([]api.UploadedImageLink(nil), record.UploadedImages...),
+		UploadHistory:        append([]api.UploadRecord(nil), record.UploadHistory...),
+	}
+}
diff --git a/internal/core/history_cleanup.go b/internal/core/history_cleanup.go
index 3df22aa0..dda68360 100644
--- a/internal/core/history_cleanup.go
+++ b/internal/core/history_cleanup.go
@@ -12,28 +12,28 @@ import (
 	"strings"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func (c *Core) DeleteAllHistoryReleases(ctx context.Context) (int, error) {
+func (h *historyModule) DeleteAll(ctx context.Context) (int, error) {
 	if err := ctx.Err(); err != nil {
 		return 0, fmt.Errorf("core: delete all history releases canceled: %w", err)
 	}
-	if c.repo == nil {
+	if h == nil || h.repo == nil {
 		return 0, errors.New("core: repository not initialized")
 	}
 
-	storedPaths, err := c.repo.ListStoredReleasePaths(ctx)
+	storedPaths, err := h.repo.ListStoredReleasePaths(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("core: list stored release paths: %w", err)
 	}
 
 	deleted := 0
 	for _, sourcePath := range storedPaths {
-		if err := c.deleteStoredRelease(ctx, sourcePath); err != nil {
+		if err := h.deleteStoredRelease(ctx, sourcePath); err != nil {
 			return deleted, err
 		}
 		deleted++
@@ -42,7 +42,21 @@ func (c *Core) DeleteAllHistoryReleases(ctx context.Context) (int, error) {
 	return deleted, nil
 }
 
-func (c *Core) deleteStoredRelease(ctx context.Context, sourcePath string) error {
+func (h *historyModule) Delete(ctx context.Context, sourcePath string) error {
+	if err := ctx.Err(); err != nil {
+		return fmt.Errorf("core: delete history release canceled: %w", err)
+	}
+	trimmed := strings.TrimSpace(sourcePath)
+	if trimmed == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	if h == nil || h.repo == nil {
+		return errors.New("core: repository not initialized")
+	}
+	return h.deleteStoredRelease(ctx, trimmed)
+}
+
+func (h *historyModule) deleteStoredRelease(ctx context.Context, sourcePath string) error {
 	if err := ctx.Err(); err != nil {
 		return fmt.Errorf("core: delete stored release canceled: %w", err)
 	}
@@ -50,24 +64,24 @@ func (c *Core) deleteStoredRelease(ctx context.Context, sourcePath string) error
 	if trimmedPath == "" {
 		return internalerrors.ErrInvalidInput
 	}
-	if c.repo == nil {
+	if h == nil || h.repo == nil {
 		return errors.New("core: repository not initialized")
 	}
 
-	tmpRoot, err := db.Subdir(c.cfg.MainSettings.DBPath, "tmp")
+	tmpRoot, err := db.Subdir(h.dbPath, "tmp")
 	if err != nil {
 		return fmt.Errorf("core: delete history release: resolve tmp dir: %w", err)
 	}
-	cacheRoot, err := db.Subdir(c.cfg.MainSettings.DBPath, "cache")
+	cacheRoot, err := db.Subdir(h.dbPath, "cache")
 	if err != nil {
 		return fmt.Errorf("core: delete history release: resolve cache dir: %w", err)
 	}
-	nfoRoot, err := db.Subdir(c.cfg.MainSettings.DBPath, "nfo")
+	nfoRoot, err := db.Subdir(h.dbPath, "nfo")
 	if err != nil {
 		return fmt.Errorf("core: delete history release: resolve nfo dir: %w", err)
 	}
 
-	cleanupPaths, err := c.releaseCleanupPaths(ctx, trimmedPath)
+	cleanupPaths, err := h.releaseCleanupPaths(ctx, trimmedPath)
 	if err != nil {
 		return err
 	}
@@ -75,7 +89,7 @@ func (c *Core) deleteStoredRelease(ctx context.Context, sourcePath string) error
 	artifactPaths := make([]string, 0)
 	tmpDirs := make(map[string]struct{})
 	for _, cleanupPath := range cleanupPaths {
-		pathArtifacts, pathTmpDirs, err := c.collectReleaseCleanupTargets(ctx, cleanupPath, tmpRoot)
+		pathArtifacts, pathTmpDirs, err := h.collectReleaseCleanupTargets(ctx, cleanupPath, tmpRoot)
 		if err != nil {
 			return err
 		}
@@ -85,60 +99,70 @@ func (c *Core) deleteStoredRelease(ctx context.Context, sourcePath string) error
 		}
 	}
 
-	addDirectoryChildTempDirs(trimmedPath, tmpRoot, tmpDirs)
+	addDirectoryChildTempDirs(h.fs, trimmedPath, tmpRoot, tmpDirs)
 
 	fileRoots := []string{tmpRoot, cacheRoot, nfoRoot}
 	for _, filePath := range artifactPaths {
-		if _, err := ensureRemovableWithinRoots(fileRoots, filePath, false); err != nil {
+		if _, err := ensureRemovableWithinRootsFS(h.fs, fileRoots, filePath, false); err != nil {
 			return fmt.Errorf("core: delete history release validate file %q: %w", filePath, err)
 		}
 	}
 	for dir := range tmpDirs {
-		if _, err := ensureRemovableWithinRoot(tmpRoot, dir, true); err != nil {
+		if _, err := ensureRemovableWithinRootFS(h.fs, tmpRoot, dir, true); err != nil {
 			return fmt.Errorf("core: delete history release validate tmp dir %q: %w", dir, err)
 		}
 	}
-	for _, cleanupPath := range cleanupPaths {
-		if err := c.repo.PurgeContentData(ctx, cleanupPath); err != nil {
-			return fmt.Errorf("core: delete history release: %w", err)
-		}
-	}
-	for _, filePath := range artifactPaths {
-		removed, err := removeIfWithinRoots(fileRoots, filePath, false)
-		if err != nil {
-			return fmt.Errorf("core: delete history release remove file %q: %w", filePath, err)
+	deletePrepared := func(workCtx context.Context, invalidate func(string)) error {
+		for _, cleanupPath := range cleanupPaths {
+			if err := h.repo.PurgeContentData(workCtx, cleanupPath); err != nil {
+				return fmt.Errorf("core: delete history release: %w", err)
+			}
+			invalidate(cleanupPath)
 		}
-		if removed && c.logger != nil {
-			c.logger.Debugf("core: delete history release removed file %s", filePath)
+		for _, filePath := range artifactPaths {
+			removed, err := removeIfWithinRootsFS(h.fs, fileRoots, filePath, false)
+			if err != nil {
+				return fmt.Errorf("core: delete history release remove file %q: %w", filePath, err)
+			}
+			if removed && h.logger != nil {
+				h.logger.Debugf("core: delete history release removed file %s", filePath)
+			}
 		}
-	}
-	for dir := range tmpDirs {
-		removed, err := removeIfWithinRoot(tmpRoot, dir, true)
-		if err != nil {
-			return fmt.Errorf("core: delete history release remove tmp dir %q: %w", dir, err)
+		for dir := range tmpDirs {
+			removed, err := removeIfWithinRootFS(h.fs, tmpRoot, dir, true)
+			if err != nil {
+				return fmt.Errorf("core: delete history release remove tmp dir %q: %w", dir, err)
+			}
+			if removed && h.logger != nil {
+				h.logger.Debugf("core: delete history release removed tmp dir %s", dir)
+			}
 		}
-		if removed && c.logger != nil {
-			c.logger.Debugf("core: delete history release removed tmp dir %s", dir)
+		if h.logger != nil {
+			h.logger.Infof("core: delete history release completed path=%s", trimmedPath)
 		}
+		return nil
 	}
-	if c.logger != nil {
-		c.logger.Infof("core: delete history release completed path=%s", trimmedPath)
+	if h.preparedFacts != nil {
+		for _, cleanupPath := range cleanupPaths {
+			if err := h.preparedFacts.Purge(ctx, cleanupPath); err != nil {
+				return fmt.Errorf("core: purge prepared release %q: %w", cleanupPath, err)
+			}
+		}
 	}
-
-	return nil
+	return deletePrepared(ctx, func(string) {})
 }
 
-func (c *Core) releaseCleanupPaths(ctx context.Context, sourcePath string) ([]string, error) {
+func (h *historyModule) releaseCleanupPaths(ctx context.Context, sourcePath string) ([]string, error) {
 	cleanupPaths := []string{sourcePath}
-	if c.repo == nil {
+	if h.repo == nil {
 		return cleanupPaths, nil
 	}
-	storedPaths, err := c.repo.ListStoredReleasePaths(ctx)
+	storedPaths, err := h.repo.ListStoredReleasePaths(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("core: delete history release list stored paths: %w", err)
 	}
 	for _, storedPath := range storedPaths {
-		if !releasePathRelated(sourcePath, storedPath) {
+		if !releasePathRelated(h.fs, sourcePath, storedPath) {
 			continue
 		}
 		cleanupPaths = append(cleanupPaths, storedPath)
@@ -146,7 +170,7 @@ func (c *Core) releaseCleanupPaths(ctx context.Context, sourcePath string) ([]st
 	return compactStrings(cleanupPaths), nil
 }
 
-func releasePathRelated(sourcePath string, storedPath string) bool {
+func releasePathRelated(filesystem historyFilesystem, sourcePath string, storedPath string) bool {
 	sourcePath = strings.TrimSpace(sourcePath)
 	storedPath = strings.TrimSpace(storedPath)
 	if sourcePath == "" || storedPath == "" {
@@ -155,7 +179,7 @@ func releasePathRelated(sourcePath string, storedPath string) bool {
 	if pathutil.SamePath(sourcePath, storedPath) {
 		return true
 	}
-	info, err := os.Stat(sourcePath)
+	info, err := filesystem.Stat(sourcePath)
 	if err != nil || !info.IsDir() {
 		return false
 	}
@@ -170,62 +194,31 @@ func releasePathRelated(sourcePath string, storedPath string) bool {
 	return pathutil.IsWithinRoot(absSource, absStored)
 }
 
-func (c *Core) collectReleaseCleanupTargets(ctx context.Context, sourcePath string, tmpRoot string) ([]string, map[string]struct{}, error) {
+func (h *historyModule) collectReleaseCleanupTargets(ctx context.Context, sourcePath string, tmpRoot string) ([]string, map[string]struct{}, error) {
 	artifactPaths := make([]string, 0)
 
-	shots, err := c.repo.ListScreenshotsByPath(ctx, sourcePath)
-	if err != nil {
-		return nil, nil, fmt.Errorf("core: delete history release list screenshots: %w", err)
-	}
-	for _, shot := range shots {
-		artifactPaths = append(artifactPaths, shot.ImagePath)
-	}
-
-	uploaded, err := c.repo.ListUploadedImagesByPath(ctx, sourcePath)
-	if err != nil {
-		return nil, nil, fmt.Errorf("core: delete history release list uploaded images: %w", err)
-	}
-	for _, image := range uploaded {
-		artifactPaths = append(artifactPaths, image.ImagePath)
-	}
-
-	finals, err := c.repo.ListFinalSelections(ctx, sourcePath)
-	if err != nil {
-		return nil, nil, fmt.Errorf("core: delete history release list final selections: %w", err)
-	}
-	for _, image := range finals {
-		artifactPaths = append(artifactPaths, image.ImagePath)
-	}
-
-	slots, err := c.repo.ListScreenshotSlotsByPath(ctx, sourcePath)
+	snapshot, err := h.repo.LoadHistoryCleanupSnapshot(ctx, sourcePath)
 	if err != nil {
-		return nil, nil, fmt.Errorf("core: delete history release list screenshot slots: %w", err)
-	}
-	for _, slot := range slots {
-		artifactPaths = append(artifactPaths, slot.ImagePath)
-		for _, variant := range slot.Variants {
-			artifactPaths = append(artifactPaths, variant.ImagePath)
-		}
+		return nil, nil, fmt.Errorf("core: delete history release load cleanup snapshot: %w", err)
 	}
+	artifactPaths = append(artifactPaths, snapshot.ArtifactPaths...)
 
 	artifactPaths = compactStrings(artifactPaths)
 	tmpDirs := make(map[string]struct{})
-	fallbackBase := paths.ReleaseTempBase(api.PreparedMetadata{}, sourcePath)
+	fallbackBase := paths.ReleaseTempBaseFor(sourcePath, api.ReleaseInfo{})
 	tmpDirs[filepath.Join(tmpRoot, fallbackBase)] = struct{}{}
 
-	stored, err := c.repo.GetByPath(ctx, sourcePath)
-	if err == nil {
-		releaseBase := paths.ReleaseTempBase(api.PreparedMetadata{
-			Release: api.ReleaseInfo{
-				Title:    stored.Title,
-				Alt:      stored.Alt,
-				Year:     stored.Year,
-				Category: string(stored.Category),
-				Source:   stored.Source,
-				Type:     stored.Type,
-				Group:    stored.Group,
-			},
-		}, sourcePath)
+	if snapshot.Metadata != nil {
+		stored := *snapshot.Metadata
+		releaseBase := paths.ReleaseTempBaseFor(sourcePath, api.ReleaseInfo{
+			Title:    stored.Title,
+			Alt:      stored.Alt,
+			Year:     stored.Year,
+			Category: string(stored.Category),
+			Source:   stored.Source,
+			Type:     stored.Type,
+			Group:    stored.Group,
+		})
 		tmpDirs[filepath.Join(tmpRoot, releaseBase)] = struct{}{}
 	}
 	for _, filePath := range artifactPaths {
@@ -239,18 +232,18 @@ func (c *Core) collectReleaseCleanupTargets(ctx context.Context, sourcePath stri
 	return artifactPaths, tmpDirs, nil
 }
 
-func addDirectoryChildTempDirs(sourcePath string, tmpRoot string, tmpDirs map[string]struct{}) {
-	info, err := os.Stat(sourcePath)
+func addDirectoryChildTempDirs(filesystem historyFilesystem, sourcePath string, tmpRoot string, tmpDirs map[string]struct{}) {
+	info, err := filesystem.Stat(sourcePath)
 	if err != nil || !info.IsDir() {
 		return
 	}
-	entries, err := os.ReadDir(sourcePath)
+	entries, err := filesystem.ReadDir(sourcePath)
 	if err != nil {
 		return
 	}
 	for _, entry := range entries {
 		childPath := filepath.Join(sourcePath, entry.Name())
-		base := paths.ReleaseTempBase(api.PreparedMetadata{}, childPath)
+		base := paths.ReleaseTempBaseFor(childPath, api.ReleaseInfo{})
 		if strings.TrimSpace(base) == "" {
 			continue
 		}
@@ -305,8 +298,8 @@ func resolveContentTmpRoot(tmpRoot string, candidate string) (string, bool) {
 	return filepath.Join(absTmpRoot, parts[0]), true
 }
 
-func removeIfWithinRoot(root string, target string, recursive bool) (bool, error) {
-	absTarget, shouldRemove, err := inspectCleanupTarget(root, target, recursive)
+func removeIfWithinRootFS(filesystem historyFilesystem, root string, target string, recursive bool) (bool, error) {
+	absTarget, shouldRemove, err := inspectCleanupTargetFS(filesystem, root, target, recursive)
 	if err != nil {
 		return false, err
 	}
@@ -314,26 +307,26 @@ func removeIfWithinRoot(root string, target string, recursive bool) (bool, error
 		return false, nil
 	}
 	if recursive {
-		if err := os.RemoveAll(absTarget); err != nil {
+		if err := filesystem.RemoveAll(absTarget); err != nil {
 			return false, fmt.Errorf("cleanup history artifact: remove target tree: %w", err)
 		}
 		return true, nil
 	}
-	if err := os.Remove(absTarget); err != nil && !os.IsNotExist(err) {
+	if err := filesystem.Remove(absTarget); err != nil && !os.IsNotExist(err) {
 		return false, fmt.Errorf("cleanup history artifact: remove target: %w", err)
 	}
-	if _, err := os.Stat(absTarget); err == nil {
+	if _, err := filesystem.Stat(absTarget); err == nil {
 		return false, nil
 	}
 	return true, nil
 }
 
-func ensureRemovableWithinRoot(root string, target string, recursive bool) (bool, error) {
-	_, shouldRemove, err := inspectCleanupTarget(root, target, recursive)
+func ensureRemovableWithinRootFS(filesystem historyFilesystem, root string, target string, recursive bool) (bool, error) {
+	_, shouldRemove, err := inspectCleanupTargetFS(filesystem, root, target, recursive)
 	return shouldRemove, err
 }
 
-func inspectCleanupTarget(root string, target string, recursive bool) (string, bool, error) {
+func inspectCleanupTargetFS(filesystem historyFilesystem, root string, target string, recursive bool) (string, bool, error) {
 	trimmed := strings.TrimSpace(target)
 	if trimmed == "" {
 		return "", false, nil
@@ -352,7 +345,7 @@ func inspectCleanupTarget(root string, target string, recursive bool) (string, b
 	if !pathutil.IsWithinRoot(absRoot, absTarget) {
 		return "", false, nil
 	}
-	info, err := os.Stat(absTarget)
+	info, err := filesystem.Stat(absTarget)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return absTarget, false, nil
@@ -365,13 +358,13 @@ func inspectCleanupTarget(root string, target string, recursive bool) (string, b
 	return absTarget, true, nil
 }
 
-func removeIfWithinRoots(roots []string, target string, recursive bool) (bool, error) {
+func removeIfWithinRootsFS(filesystem historyFilesystem, roots []string, target string, recursive bool) (bool, error) {
 	for _, root := range roots {
 		trimmed := strings.TrimSpace(root)
 		if trimmed == "" {
 			continue
 		}
-		removed, err := removeIfWithinRoot(trimmed, target, recursive)
+		removed, err := removeIfWithinRootFS(filesystem, trimmed, target, recursive)
 		if err != nil {
 			return false, err
 		}
@@ -382,13 +375,13 @@ func removeIfWithinRoots(roots []string, target string, recursive bool) (bool, e
 	return false, nil
 }
 
-func ensureRemovableWithinRoots(roots []string, target string, recursive bool) (bool, error) {
+func ensureRemovableWithinRootsFS(filesystem historyFilesystem, roots []string, target string, recursive bool) (bool, error) {
 	for _, root := range roots {
 		trimmed := strings.TrimSpace(root)
 		if trimmed == "" {
 			continue
 		}
-		removable, err := ensureRemovableWithinRoot(trimmed, target, recursive)
+		removable, err := ensureRemovableWithinRootFS(filesystem, trimmed, target, recursive)
 		if err != nil {
 			return false, err
 		}
diff --git a/internal/core/history_cleanup_test.go b/internal/core/history_cleanup_test.go
index ad035172..63cc7f2e 100644
--- a/internal/core/history_cleanup_test.go
+++ b/internal/core/history_cleanup_test.go
@@ -10,7 +10,6 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
@@ -28,6 +27,8 @@ type cleanupRepo struct {
 	purgedPaths  []string
 	purgeCalls   int
 	purgeErr     error
+	purgeErrAt   int
+	cancel       context.CancelFunc
 }
 
 func (r *cleanupRepo) GetByPath(context.Context, string) (api.FileMetadata, error) {
@@ -63,10 +64,44 @@ func (r *cleanupRepo) ListStoredReleasePaths(context.Context) ([]string, error)
 func (r *cleanupRepo) PurgeContentData(_ context.Context, path string) error {
 	r.purgeCalls++
 	r.purgedPaths = append(r.purgedPaths, path)
+	if r.cancel != nil {
+		r.cancel()
+	}
+	if r.purgeErrAt > 0 && r.purgeCalls == r.purgeErrAt {
+		return r.purgeErr
+	}
+	if r.purgeErrAt > 0 {
+		return nil
+	}
 	return r.purgeErr
 }
 
-func TestCoreDeleteHistoryReleaseRemovesStoredArtifacts(t *testing.T) {
+func (r *cleanupRepo) LoadHistoryCleanupSnapshot(context.Context, string) (api.HistoryCleanupSnapshot, error) {
+	artifactPaths := make([]string, 0, len(r.screenshots)+len(r.uploaded)+len(r.finals)+len(r.slots))
+	for _, shot := range r.screenshots {
+		artifactPaths = append(artifactPaths, shot.ImagePath)
+	}
+	for _, image := range r.uploaded {
+		artifactPaths = append(artifactPaths, image.ImagePath)
+	}
+	for _, image := range r.finals {
+		artifactPaths = append(artifactPaths, image.ImagePath)
+	}
+	for _, slot := range r.slots {
+		artifactPaths = append(artifactPaths, slot.ImagePath)
+		for _, variant := range slot.Variants {
+			artifactPaths = append(artifactPaths, variant.ImagePath)
+		}
+	}
+	snapshot := api.HistoryCleanupSnapshot{ArtifactPaths: artifactPaths}
+	if r.getByPathErr == nil && r.stored.Path != "" {
+		stored := r.stored
+		snapshot.Metadata = &stored
+	}
+	return snapshot, nil
+}
+
+func TestHistoryDeleteRemovesStoredArtifacts(t *testing.T) {
 	t.Parallel()
 
 	baseDir := t.TempDir()
@@ -94,28 +129,28 @@ func TestCoreDeleteHistoryReleaseRemovesStoredArtifacts(t *testing.T) {
 		if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
 			t.Fatalf("mkdir %s: %v", target, err)
 		}
-		if err := os.WriteFile(target, []byte("test"), 0o644); err != nil {
+		if err := os.WriteFile(target, []byte("test"), 0o600); err != nil {
 			t.Fatalf("write %s: %v", target, err)
 		}
 	}
 
 	repo := &cleanupRepo{
 		screenshots: []api.Screenshot{{SourcePath: sourcePath, ImagePath: tmpFile}},
-		uploaded:    []api.UploadedImageLink{{SourcePath: sourcePath, ImagePath: cacheFile, Host: "imgbox"}},
-		finals:      []api.ScreenshotFinalSelection{{ImagePath: nfoFile}},
+		uploaded: []api.UploadedImageLink{{
+			SourcePath: sourcePath,
+			ImagePath:  cacheFile,
+			Host:       "imgbox",
+		}},
+		finals: []api.ScreenshotFinalSelection{{ImagePath: nfoFile}},
 		slots: []api.ScreenshotSlot{{
 			SourcePath: sourcePath,
 			ImagePath:  slotFile,
 			Variants:   []api.ScreenshotSlotVariant{{ImagePath: slotVariantFile}},
 		}},
 	}
-	coreSvc := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		logger: api.NopLogger{},
-		repo:   repo,
-	}
+	history := newHistoryModule(repo, dbPath, api.NopLogger{})
 
-	if err := coreSvc.DeleteHistoryRelease(context.Background(), sourcePath); err != nil {
+	if err := history.Delete(context.Background(), sourcePath); err != nil {
 		t.Fatalf("delete history release: %v", err)
 	}
 	if repo.purgeCalls != 1 || len(repo.purgedPaths) != 1 || repo.purgedPaths[0] != sourcePath {
@@ -131,7 +166,7 @@ func TestCoreDeleteHistoryReleaseRemovesStoredArtifacts(t *testing.T) {
 	}
 }
 
-func TestCoreDeleteHistoryReleaseRemovesDirectoryChildArtifacts(t *testing.T) {
+func TestHistoryDeleteRemovesDirectoryChildArtifacts(t *testing.T) {
 	t.Parallel()
 
 	baseDir := t.TempDir()
@@ -165,13 +200,9 @@ func TestCoreDeleteHistoryReleaseRemovesDirectoryChildArtifacts(t *testing.T) {
 		storedPaths:  []string{childPath},
 		getByPathErr: internalerrors.ErrNotFound,
 	}
-	coreSvc := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		logger: api.NopLogger{},
-		repo:   repo,
-	}
+	history := newHistoryModule(repo, dbPath, api.NopLogger{})
 
-	if err := coreSvc.DeleteHistoryRelease(context.Background(), sourceDir); err != nil {
+	if err := history.Delete(context.Background(), sourceDir); err != nil {
 		t.Fatalf("delete history release: %v", err)
 	}
 	if len(repo.purgedPaths) != 2 || repo.purgedPaths[0] != sourceDir || repo.purgedPaths[1] != childPath {
@@ -184,7 +215,7 @@ func TestCoreDeleteHistoryReleaseRemovesDirectoryChildArtifacts(t *testing.T) {
 	}
 }
 
-func TestCoreDeleteHistoryReleaseKeepsDBRowsWhenArtifactRemovalFails(t *testing.T) {
+func TestHistoryDeleteKeepsDBRowsWhenArtifactRemovalFails(t *testing.T) {
 	t.Parallel()
 
 	baseDir := t.TempDir()
@@ -206,13 +237,9 @@ func TestCoreDeleteHistoryReleaseKeepsDBRowsWhenArtifactRemovalFails(t *testing.
 	repo := &cleanupRepo{
 		screenshots: []api.Screenshot{{SourcePath: sourcePath, ImagePath: blockedPath}},
 	}
-	coreSvc := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		logger: api.NopLogger{},
-		repo:   repo,
-	}
+	history := newHistoryModule(repo, dbPath, api.NopLogger{})
 
-	if err := coreSvc.DeleteHistoryRelease(context.Background(), sourcePath); err == nil {
+	if err := history.Delete(context.Background(), sourcePath); err == nil {
 		t.Fatal("expected artifact removal failure")
 	}
 	if repo.purgeCalls != 0 {
@@ -223,7 +250,7 @@ func TestCoreDeleteHistoryReleaseKeepsDBRowsWhenArtifactRemovalFails(t *testing.
 	}
 }
 
-func TestCoreDeleteAllHistoryReleasesPurgesEveryStoredPath(t *testing.T) {
+func TestHistoryDeleteAllPurgesEveryStoredPath(t *testing.T) {
 	t.Parallel()
 
 	baseDir := t.TempDir()
@@ -234,13 +261,9 @@ func TestCoreDeleteAllHistoryReleasesPurgesEveryStoredPath(t *testing.T) {
 		},
 		getByPathErr: internalerrors.ErrNotFound,
 	}
-	coreSvc := &Core{
-		cfg:    config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(baseDir, "ua.db")}},
-		logger: api.NopLogger{},
-		repo:   repo,
-	}
+	history := newHistoryModule(repo, filepath.Join(baseDir, "ua.db"), api.NopLogger{})
 
-	deleted, err := coreSvc.DeleteAllHistoryReleases(context.Background())
+	deleted, err := history.DeleteAll(context.Background())
 	if err != nil {
 		t.Fatalf("delete all history releases: %v", err)
 	}
@@ -255,6 +278,79 @@ func TestCoreDeleteAllHistoryReleasesPurgesEveryStoredPath(t *testing.T) {
 	}
 }
 
+func TestHistoryDeleteDoesNotRemoveOutsideManagedRoots(t *testing.T) {
+	t.Parallel()
+
+	baseDir := t.TempDir()
+	dbPath := filepath.Join(baseDir, "ua.db")
+	sourcePath := filepath.Join(baseDir, "Example.Release.2026.mkv")
+	outsidePath := filepath.Join(t.TempDir(), "outside.png")
+	if err := os.WriteFile(outsidePath, []byte("keep"), 0o600); err != nil {
+		t.Fatalf("write outside artifact: %v", err)
+	}
+	repo := &cleanupRepo{screenshots: []api.Screenshot{{SourcePath: sourcePath, ImagePath: outsidePath}}}
+	history := newHistoryModule(repo, dbPath, api.NopLogger{})
+
+	if err := history.Delete(context.Background(), sourcePath); err != nil {
+		t.Fatalf("delete history release: %v", err)
+	}
+	if _, err := os.Stat(outsidePath); err != nil {
+		t.Fatalf("outside artifact changed: %v", err)
+	}
+	if repo.purgeCalls != 1 {
+		t.Fatalf("expected history row purge, got %d calls", repo.purgeCalls)
+	}
+}
+
+func TestHistoryDeleteAllReturnsPartialCountOnPurgeError(t *testing.T) {
+	t.Parallel()
+
+	baseDir := t.TempDir()
+	wantErr := errors.New("purge failed")
+	repo := &cleanupRepo{
+		storedPaths:  []string{filepath.Join(baseDir, "one.mkv"), filepath.Join(baseDir, "two.mkv")},
+		getByPathErr: internalerrors.ErrNotFound,
+		purgeErr:     wantErr,
+		purgeErrAt:   2,
+	}
+	history := newHistoryModule(repo, filepath.Join(baseDir, "ua.db"), api.NopLogger{})
+
+	deleted, err := history.DeleteAll(context.Background())
+	if deleted != 1 {
+		t.Fatalf("expected partial delete count 1, got %d", deleted)
+	}
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("expected purge error, got %v", err)
+	}
+	if repo.purgeCalls != 2 {
+		t.Fatalf("expected stop at second purge, got %d calls", repo.purgeCalls)
+	}
+}
+
+func TestHistoryDeleteAllHonorsCancellationBetweenReleases(t *testing.T) {
+	t.Parallel()
+
+	baseDir := t.TempDir()
+	ctx, cancel := context.WithCancel(context.Background())
+	repo := &cleanupRepo{
+		storedPaths:  []string{filepath.Join(baseDir, "one.mkv"), filepath.Join(baseDir, "two.mkv")},
+		getByPathErr: internalerrors.ErrNotFound,
+		cancel:       cancel,
+	}
+	history := newHistoryModule(repo, filepath.Join(baseDir, "ua.db"), api.NopLogger{})
+
+	deleted, err := history.DeleteAll(ctx)
+	if deleted != 1 {
+		t.Fatalf("expected one completed delete before cancellation, got %d", deleted)
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected cancellation, got %v", err)
+	}
+	if repo.purgeCalls != 1 {
+		t.Fatalf("expected no second purge after cancellation, got %d calls", repo.purgeCalls)
+	}
+}
+
 func TestRemoveIfWithinRootKeepsAliasedRoot(t *testing.T) {
 	t.Parallel()
 
@@ -268,7 +364,7 @@ func TestRemoveIfWithinRootKeepsAliasedRoot(t *testing.T) {
 		t.Skipf("symlink unavailable on this host: %v", err)
 	}
 
-	removed, err := removeIfWithinRoot(root, alias, true)
+	removed, err := removeIfWithinRootFS(osHistoryFilesystem{}, root, alias, true)
 	if err != nil {
 		t.Fatalf("remove aliased root: %v", err)
 	}
diff --git a/internal/core/history_test.go b/internal/core/history_test.go
new file mode 100644
index 00000000..33f22d94
--- /dev/null
+++ b/internal/core/history_test.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestHistoryOperationsHonorPreCanceledContext(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	history := newHistoryModule(&stubRepo{}, "", api.NopLogger{})
+
+	if _, err := history.List(ctx); !errors.Is(err, context.Canceled) {
+		t.Fatalf("list history: expected cancellation, got %v", err)
+	}
+	if _, err := history.Overview(ctx, "source"); !errors.Is(err, context.Canceled) {
+		t.Fatalf("history overview: expected cancellation, got %v", err)
+	}
+	if err := history.Delete(ctx, "source"); !errors.Is(err, context.Canceled) {
+		t.Fatalf("delete history: expected cancellation, got %v", err)
+	}
+	if _, err := history.DeleteAll(ctx); !errors.Is(err, context.Canceled) {
+		t.Fatalf("delete all history: expected cancellation, got %v", err)
+	}
+}
+
+func TestCoreHistoryOperationsWithoutRepositoryReturnInitializationError(t *testing.T) {
+	t.Parallel()
+
+	core := newTestCore(testCoreOptions{})
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "list",
+			call: func() error {
+				_, err := core.ListHistory(context.Background())
+				return err
+			},
+		},
+		{
+			name: "overview",
+			call: func() error {
+				_, err := core.GetHistoryOverview(context.Background(), "source")
+				return err
+			},
+		},
+		{
+			name: "delete",
+			call: func() error {
+				return core.DeleteHistoryRelease(context.Background(), "source")
+			},
+		},
+		{
+			name: "delete all",
+			call: func() error {
+				_, err := core.DeleteAllHistoryReleases(context.Background())
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.call()
+			if err == nil || err.Error() != "core: repository not initialized" {
+				t.Fatalf("expected repository initialization error, got %v", err)
+			}
+		})
+	}
+}
+
+func TestHistoryOverviewRejectsBlankPathBeforeRepositoryRead(t *testing.T) {
+	t.Parallel()
+
+	history := newHistoryModule(&stubRepo{}, "", api.NopLogger{})
+	if _, err := history.Overview(context.Background(), "  "); !errors.Is(err, internalerrors.ErrInvalidInput) {
+		t.Fatalf("expected invalid input, got %v", err)
+	}
+}
diff --git a/internal/core/media.go b/internal/core/media.go
new file mode 100644
index 00000000..af471551
--- /dev/null
+++ b/internal/core/media.go
@@ -0,0 +1,1198 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/logging"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type mediaRepository interface {
+	api.ScreenshotLifecycleRepository
+	ListTrackerMetadataByPath(ctx context.Context, path string) ([]api.TrackerMetadata, error)
+	SaveTrackerMetadata(ctx context.Context, metadata api.TrackerMetadata) error
+	ListUploadedImagesByPath(ctx context.Context, path string) ([]api.UploadedImageLink, error)
+	DeleteUploadedImage(ctx context.Context, path string, imagePath string, host string) error
+}
+
+type mediaFilesystemService interface {
+	ValidatePaths(ctx context.Context, paths []string) ([]string, error)
+}
+
+type mediaScreenshotService interface {
+	Plan(ctx context.Context, subject api.ScreenshotSubject, count int) (api.ScreenshotPlan, error)
+	Capture(
+		ctx context.Context,
+		subject api.ScreenshotSubject,
+		selections []api.ScreenshotSelection,
+		purpose api.ScreenshotPurpose,
+	) (api.ScreenshotResult, error)
+	PreviewFrame(ctx context.Context, subject api.ScreenshotSubject, timestampSeconds float64) (api.ScreenshotPreview, error)
+	Delete(ctx context.Context, subject api.ScreenshotSubject, imagePath string) error
+	SaveFinalSelections(ctx context.Context, subject api.ScreenshotSubject, images []api.ScreenshotImage) error
+}
+
+type mediaDVDMenuService interface {
+	Capture(ctx context.Context, subject api.DVDMenuSubject, maxItems int) (api.DVDMenuCaptureResult, error)
+	List(ctx context.Context, subject api.DVDMenuSubject) ([]api.ScreenshotImage, error)
+	Delete(ctx context.Context, subject api.DVDMenuSubject, imagePath string) error
+	Capability(ctx context.Context) (api.DVDMenuEngineInfo, error)
+}
+
+type mediaImageHostingService interface {
+	ListCandidates(ctx context.Context, subject api.ImageHostingSubject) ([]api.ScreenshotImage, error)
+	Upload(
+		ctx context.Context,
+		subject api.ImageHostingSubject,
+		host string,
+		usageScope string,
+		images []api.ScreenshotImage,
+	) ([]api.UploadedImageLink, error)
+}
+
+// mediaModule owns screenshot, disc-menu, and image-host workflow policy. It
+// borrows its services, repository, and prepared-release state from Core.
+type mediaModule struct {
+	cfg           config.Config
+	logger        api.Logger
+	filesystem    mediaFilesystemService
+	screenshots   mediaScreenshotService
+	dvdMenus      mediaDVDMenuService
+	images        mediaImageHostingService
+	repo          mediaRepository
+	registry      *trackers.Registry
+	preparedFacts *preparedrelease.Module
+}
+
+func newMediaModule(
+	cfg config.Config,
+	logger api.Logger,
+	services api.ServiceSet,
+	repo mediaRepository,
+	registry *trackers.Registry,
+	preparedFacts *preparedrelease.Module,
+) *mediaModule {
+	return &mediaModule{
+		cfg:           cfg,
+		logger:        logger,
+		filesystem:    services.Filesystem,
+		screenshots:   services.Screenshots,
+		dvdMenus:      services.DVDMenus,
+		images:        services.Images,
+		repo:          repo,
+		registry:      registry,
+		preparedFacts: preparedFacts,
+	}
+}
+
+func imageHostingSubject(meta api.UploadSubject) api.ImageHostingSubject {
+	galleryName := ""
+	for _, candidate := range []string{
+		meta.ReleaseName,
+		meta.ReleaseNameNoTag,
+		meta.Release.Title,
+		meta.Filename,
+		filepath.Base(meta.SourcePath),
+	} {
+		if trimmed := strings.TrimSpace(candidate); trimmed != "" {
+			galleryName = trimmed
+			break
+		}
+	}
+	return api.ImageHostingSubject{SourcePath: meta.SourcePath, GalleryName: galleryName}
+}
+
+func (m *mediaModule) dvdMenuCapability(ctx context.Context) (api.DVDMenuEngineInfo, error) {
+	if m == nil || m.dvdMenus == nil {
+		return api.DVDMenuEngineInfo{}, errors.New("core: DVD menu service not configured")
+	}
+	return wrapCoreResult(m.dvdMenus.Capability(ctx))
+}
+
+func (m *mediaModule) captureAcceptedDVDMenus(ctx context.Context, input api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	if m.dvdMenus == nil {
+		return api.DVDMenuCaptureResult{}, errors.New("core: DVD menu service not configured")
+	}
+	if m.preparedFacts == nil {
+		return api.DVDMenuCaptureResult{}, errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveDVDMenuSubject(ctx, input)
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("core: resolve DVD menu capture subject: %w", err)
+	}
+	return wrapCoreResult(m.dvdMenus.Capture(ctx, subject, m.cfg.ScreenshotHandling.ResolvedMaxMenuItems()))
+}
+
+func (m *mediaModule) listAcceptedDVDMenuScreenshots(ctx context.Context, input api.MediaPlanInput) ([]api.ScreenshotImage, error) {
+	if m.dvdMenus == nil {
+		return nil, errors.New("core: DVD menu service not configured")
+	}
+	if m.preparedFacts == nil {
+		return nil, errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveDVDMenuSubject(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("core: resolve DVD menu list subject: %w", err)
+	}
+	return wrapCoreResult(m.dvdMenus.List(ctx, subject))
+}
+
+func (m *mediaModule) deleteAcceptedDVDMenuScreenshot(ctx context.Context, input api.MediaPlanInput, imagePath string) error {
+	if m.dvdMenus == nil {
+		return errors.New("core: DVD menu service not configured")
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	if strings.TrimSpace(imagePath) == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveDVDMenuSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve DVD menu deletion subject: %w", err)
+	}
+	return wrapCoreError(m.dvdMenus.Delete(ctx, subject, imagePath))
+}
+
+func (m *mediaModule) fetchAcceptedScreenshotPlan(ctx context.Context, input api.MediaPlanInput) (api.ScreenshotPlan, error) {
+	if m.screenshots == nil {
+		return api.ScreenshotPlan{}, errors.New("core: screenshots service not configured")
+	}
+	if m.preparedFacts == nil {
+		return api.ScreenshotPlan{}, errors.New("core: canonical preparation is not configured")
+	}
+	if input.Count <= 0 {
+		input.Count = m.cfg.ScreenshotHandling.Screens
+	}
+	subject, err := m.preparedFacts.ResolveScreenshotSubject(ctx, input)
+	if err != nil {
+		return api.ScreenshotPlan{}, fmt.Errorf("core: resolve screenshot plan subject: %w", err)
+	}
+	return wrapCoreResult(m.screenshots.Plan(ctx, subject, input.Count))
+}
+
+func (m *mediaModule) generateAcceptedScreenshots(
+	ctx context.Context,
+	input api.MediaPlanInput,
+	selections []api.ScreenshotSelection,
+) (api.ScreenshotResult, error) {
+	if m.screenshots == nil {
+		return api.ScreenshotResult{}, errors.New("core: screenshots service not configured")
+	}
+	if m.preparedFacts == nil {
+		return api.ScreenshotResult{}, errors.New("core: canonical preparation is not configured")
+	}
+	if len(selections) == 0 {
+		return api.ScreenshotResult{}, internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveScreenshotSubject(ctx, input)
+	if err != nil {
+		return api.ScreenshotResult{}, fmt.Errorf("core: resolve screenshot capture subject: %w", err)
+	}
+	return wrapCoreResult(m.screenshots.Capture(ctx, subject, selections, input.Purpose))
+}
+
+func (m *mediaModule) previewAcceptedScreenshotFrame(
+	ctx context.Context,
+	input api.MediaPlanInput,
+	timestampSeconds float64,
+) (api.ScreenshotPreview, error) {
+	if m.screenshots == nil {
+		return api.ScreenshotPreview{}, errors.New("core: screenshots service not configured")
+	}
+	if m.preparedFacts == nil {
+		return api.ScreenshotPreview{}, errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveScreenshotSubject(ctx, input)
+	if err != nil {
+		return api.ScreenshotPreview{}, fmt.Errorf("core: resolve screenshot preview subject: %w", err)
+	}
+	return wrapCoreResult(m.screenshots.PreviewFrame(ctx, subject, timestampSeconds))
+}
+
+func (m *mediaModule) deleteAcceptedScreenshot(ctx context.Context, input api.MediaPlanInput, imagePath string) error {
+	if m.screenshots == nil {
+		return errors.New("core: screenshots service not configured")
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	if strings.TrimSpace(imagePath) == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveScreenshotSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve screenshot deletion subject: %w", err)
+	}
+	return wrapCoreError(m.screenshots.Delete(ctx, subject, imagePath))
+}
+
+func (m *mediaModule) deleteAcceptedTrackerImageURL(ctx context.Context, input api.ImageHostingInput, rawURL string) error {
+	if m.repo == nil {
+		return errors.New("core: repository not configured")
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	trimmedURL := strings.TrimSpace(rawURL)
+	if trimmedURL == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveImageHostingSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve tracker image deletion subject: %w", err)
+	}
+	return m.deleteTrackerImageURLForSource(ctx, subject.SourcePath, trimmedURL)
+}
+
+func (m *mediaModule) deleteTrackerImageURLForSource(ctx context.Context, sourcePath string, trimmedURL string) error {
+	records, err := m.repo.ListTrackerMetadataByPath(ctx, sourcePath)
+	if err != nil {
+		return fmt.Errorf("core: tracker metadata lookup: %w", err)
+	}
+
+	for _, record := range records {
+		if len(record.ImageURLs) == 0 {
+			continue
+		}
+		filtered := make([]string, 0, len(record.ImageURLs))
+		removed := false
+		for _, value := range record.ImageURLs {
+			if strings.TrimSpace(value) == trimmedURL {
+				removed = true
+				continue
+			}
+			filtered = append(filtered, value)
+		}
+		if !removed {
+			continue
+		}
+		record.ImageURLs = filtered
+		if strings.TrimSpace(record.SourcePath) == "" {
+			record.SourcePath = sourcePath
+		}
+		if err := m.repo.SaveTrackerMetadata(ctx, record); err != nil {
+			return fmt.Errorf("core: save tracker metadata: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (m *mediaModule) saveAcceptedFinalScreenshotSelections(ctx context.Context, input api.MediaPlanInput, images []api.ScreenshotImage) error {
+	if m.screenshots == nil {
+		return errors.New("core: screenshots service not configured")
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveScreenshotSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve final screenshot selection subject: %w", err)
+	}
+	return wrapCoreError(m.screenshots.SaveFinalSelections(ctx, subject, images))
+}
+
+// importAcceptedMenuImages copies supported host-filesystem images into one
+// exact prepared release's managed temp directory. Content-addressed names
+// deduplicate imports, and DB records/selections are appended atomically.
+func (m *mediaModule) importAcceptedMenuImages(ctx context.Context, input api.MediaPlanInput, importPaths []string) error {
+	if len(importPaths) == 0 {
+		return nil
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveDVDMenuSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve menu image import subject: %w", err)
+	}
+	return m.importMenuImagesForSource(ctx, subject.SourcePath, importPaths)
+}
+
+func (m *mediaModule) importMenuImagesForSource(ctx context.Context, sourcePath string, importPaths []string) error {
+	var expandedPaths []string
+	for _, p := range importPaths {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		info, err := os.Stat(p)
+		if err != nil {
+			return fmt.Errorf("stat menu path %s: %w", p, err)
+		}
+		if info.IsDir() {
+			entries, err := os.ReadDir(p)
+			if err != nil {
+				return fmt.Errorf("read menu dir %s: %w", p, err)
+			}
+			for _, entry := range entries {
+				if !entry.IsDir() {
+					ext := strings.ToLower(filepath.Ext(entry.Name()))
+					if isMenuImageExtension(ext) {
+						expandedPaths = append(expandedPaths, filepath.Join(p, entry.Name()))
+					}
+				}
+			}
+		} else {
+			ext := strings.ToLower(filepath.Ext(p))
+			if isMenuImageExtension(ext) {
+				expandedPaths = append(expandedPaths, p)
+			}
+		}
+	}
+
+	tmpRoot, err := db.Subdir(m.cfg.MainSettings.DBPath, "tmp")
+	if err != nil {
+		return fmt.Errorf("core: resolve tmp root: %w", err)
+	}
+
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, sourcePath, api.ReleaseInfo{})
+	if err != nil {
+		return fmt.Errorf("core: create release tmp dir: %w", err)
+	}
+
+	if len(expandedPaths) == 0 {
+		return nil
+	}
+
+	now := time.Now().UTC()
+	records := make([]api.Screenshot, 0, len(expandedPaths))
+	selections := make([]api.ScreenshotFinalSelection, 0, len(expandedPaths))
+	created := make([]string, 0, len(expandedPaths))
+	seen := make(map[string]struct{}, len(expandedPaths))
+	for _, sourceImage := range expandedPaths {
+		destPath, wasCreated, err := copyManagedMenuImage(tmpDir, sourceImage)
+		if err != nil {
+			removeMenuImportFiles(created)
+			return err
+		}
+		if _, exists := seen[destPath]; exists {
+			continue
+		}
+		seen[destPath] = struct{}{}
+		if wasCreated {
+			created = append(created, destPath)
+		}
+		records = append(records, api.Screenshot{
+			SourcePath: sourcePath,
+			ImagePath:  destPath,
+			Purpose:    api.ScreenshotPurposeMenu,
+			CapturedAt: now,
+		})
+		selections = append(selections, api.ScreenshotFinalSelection{
+			SourcePath: sourcePath,
+			ImagePath:  destPath,
+			Order:      len(selections),
+			Source:     api.ScreenshotSelectionSourceMenu,
+			SelectedAt: now,
+		})
+	}
+	if err := m.repo.AppendManualMenuScreenshots(ctx, sourcePath, records, selections); err != nil {
+		removeMenuImportFiles(created)
+		return fmt.Errorf("core: save menu selections: %w", err)
+	}
+	return nil
+}
+
+func isMenuImageExtension(extension string) bool {
+	switch strings.ToLower(strings.TrimSpace(extension)) {
+	case ".png", ".jpg", ".jpeg", ".webp":
+		return true
+	default:
+		return false
+	}
+}
+
+// copyManagedMenuImage stages one import and assigns a content-addressed managed
+// name. The boolean result reports whether this call created the destination.
+func copyManagedMenuImage(tmpDir string, sourcePath string) (string, bool, error) {
+	source, err := os.Open(sourcePath)
+	if err != nil {
+		return "", false, fmt.Errorf("core: open menu image: %w", err)
+	}
+	defer source.Close()
+
+	staged, err := os.CreateTemp(tmpDir, ".manual-dvd-menu-*.partial")
+	if err != nil {
+		return "", false, fmt.Errorf("core: stage menu image: %w", err)
+	}
+	stagedPath := staged.Name()
+	cleanupStaged := true
+	defer func() {
+		if cleanupStaged {
+			_ = os.Remove(stagedPath)
+		}
+	}()
+
+	hash := sha256.New()
+	if _, err := io.Copy(io.MultiWriter(staged, hash), source); err != nil {
+		_ = staged.Close()
+		return "", false, fmt.Errorf("core: copy menu image: %w", err)
+	}
+	if err := staged.Close(); err != nil {
+		return "", false, fmt.Errorf("core: close staged menu image: %w", err)
+	}
+	extension := strings.ToLower(filepath.Ext(sourcePath))
+	destPath := filepath.Join(tmpDir, fmt.Sprintf("manual-dvd-menu-%x%s", hash.Sum(nil)[:8], extension))
+	if info, err := os.Stat(destPath); err == nil {
+		if info.IsDir() {
+			return "", false, internalerrors.ErrInvalidInput
+		}
+		return destPath, false, nil
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return "", false, fmt.Errorf("core: inspect managed menu image: %w", err)
+	}
+	if err := os.Rename(stagedPath, destPath); err != nil {
+		if info, statErr := os.Stat(destPath); statErr == nil && !info.IsDir() {
+			return destPath, false, nil
+		}
+		return "", false, fmt.Errorf("core: finalize menu image: %w", err)
+	}
+	cleanupStaged = false
+	return destPath, true, nil
+}
+
+func removeMenuImportFiles(paths []string) {
+	for _, pathValue := range paths {
+		_ = os.Remove(pathValue)
+	}
+}
+
+// listAcceptedUploadCandidates returns persisted normal and disc-menu images
+// eligible for image-host upload for one exact prepared generation.
+func (m *mediaModule) listAcceptedUploadCandidates(ctx context.Context, input api.ImageHostingInput) ([]api.ScreenshotImage, error) {
+	if m.images == nil {
+		return nil, errors.New("core: image hosting service not configured")
+	}
+	if m.preparedFacts == nil {
+		return nil, errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveImageHostingSubject(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("core: resolve image upload candidate subject: %w", err)
+	}
+	return wrapCoreResult(m.images.ListCandidates(ctx, subject))
+}
+
+func (m *mediaModule) listAcceptedUploadedImages(ctx context.Context, input api.ImageHostingInput) ([]api.UploadedImageLink, error) {
+	if m.repo == nil {
+		return nil, errors.New("core: repository not configured")
+	}
+	if m.preparedFacts == nil {
+		return nil, errors.New("core: canonical preparation is not configured")
+	}
+	subject, err := m.preparedFacts.ResolveImageHostingSubject(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("core: resolve uploaded image list subject: %w", err)
+	}
+	return wrapCoreResult(m.repo.ListUploadedImagesByPath(ctx, subject.SourcePath))
+}
+
+// uploadAcceptedImages uploads selected images to the requested global host
+// and additional hosts required by eligible trackers. Host uploads run
+// concurrently, tracker-owned hosts use tracker-scoped records, and recoverable
+// host failures are returned in [api.UploadImagesResult].
+func (m *mediaModule) uploadAcceptedImages(
+	ctx context.Context,
+	input api.ImageHostingInput,
+	images []api.ScreenshotImage,
+) (api.UploadImagesResult, error) {
+	if m.images == nil {
+		return api.UploadImagesResult{}, errors.New("core: image hosting service not configured")
+	}
+	if m.preparedFacts == nil {
+		return api.UploadImagesResult{}, errors.New("core: canonical preparation is not configured")
+	}
+	if len(images) == 0 {
+		return api.UploadImagesResult{}, internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveUploadSubject(ctx, api.UploadReviewInput{
+		Release:  input.Release,
+		Trackers: append([]string(nil), input.Trackers...),
+	})
+	if err != nil {
+		return api.UploadImagesResult{}, fmt.Errorf("core: resolve image upload subject: %w", err)
+	}
+	targets, err := m.resolveImageUploadTargets(input.Trackers, subject, input.Host)
+	if err != nil {
+		return api.UploadImagesResult{}, err
+	}
+	return m.uploadImagesToTargetsWithFallback(ctx, subject, input.Host, targets, images)
+}
+
+func (m *mediaModule) resolveImageUploadTargets(trackerNames []string, subject api.UploadSubject, host string) ([]trackers.ImageUploadTarget, error) {
+	normalizedHost := strings.ToLower(strings.TrimSpace(host))
+	if normalizedHost == "" {
+		return nil, internalerrors.ErrInvalidInput
+	}
+
+	trackerCfg := m.cfg
+	trackerCfg.Trackers.DefaultTrackers = nil
+	resolvedTrackers := trackers.ResolveTrackersWithRegistry(trackerCfg, trackerNames, subject.TrackersRemove, m.logger, m.registry)
+	resolvedTrackers = m.filterImageUploadTrackers(resolvedTrackers, subject)
+	targets, err := trackers.NeededImageUploadTargetsForMetadataWithRegistry(m.registry, m.cfg, resolvedTrackers, normalizedHost, subject)
+	if err != nil {
+		return nil, fmt.Errorf("core: %w", err)
+	}
+	if len(targets) == 0 {
+		return nil, fmt.Errorf("core: image host %q is tracker-scoped but no active tracker can use it", normalizedHost)
+	}
+	normalized := make([]trackers.ImageUploadTarget, 0, len(targets))
+	for _, target := range targets {
+		target = normalizeImageUploadTarget(target)
+		if target.Host == "" {
+			continue
+		}
+		normalized = append(normalized, target)
+	}
+	if len(normalized) == 0 {
+		return nil, fmt.Errorf(
+			"core: image host %q resolved image upload targets were filtered out after tracker eligibility and normalization",
+			normalizedHost,
+		)
+	}
+	return normalized, nil
+}
+
+// filterImageUploadTrackers returns canonical tracker names that can receive
+// tracker-scoped image uploads, excluding unconditional policy blocks and existing matches.
+func (m *mediaModule) filterImageUploadTrackers(trackerNames []string, meta api.UploadSubject) []string {
+	filtered := make([]string, 0, len(trackerNames))
+	for _, tracker := range trackerNames {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if name == "" {
+			continue
+		}
+		blockedReasons := blockedReasonsForTracker(meta.BlockedTrackers, name)
+		existingMatch := matchedTrackerForUpload(meta.MatchedTrackers, name)
+		if len(blockedReasons) > 0 || existingMatch {
+			if m.logger != nil {
+				m.logger.Debugf(
+					"core: excluding blocked image upload tracker tracker=%s blocked_reasons=%v rule_failures=%d existing_match=%t",
+					name,
+					blockedReasons,
+					len(ruleFailuresForTracker(meta.TrackerRuleFailures, name)),
+					existingMatch,
+				)
+			}
+			continue
+		}
+		filtered = append(filtered, name)
+	}
+	return filtered
+}
+
+func matchedTrackerForUpload(matchedTrackers []string, tracker string) bool {
+	if len(matchedTrackers) == 0 {
+		return false
+	}
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	if name == "" {
+		return false
+	}
+	for _, matched := range matchedTrackers {
+		if strings.EqualFold(strings.TrimSpace(matched), name) {
+			return true
+		}
+	}
+	return false
+}
+
+func blockedReasonsForTracker(blocked map[string][]api.TrackerBlockReason, tracker string) []api.TrackerBlockReason {
+	if len(blocked) == 0 {
+		return nil
+	}
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	if reasons, ok := blocked[name]; ok {
+		return reasons
+	}
+	for key, reasons := range blocked {
+		if strings.EqualFold(strings.TrimSpace(key), name) {
+			return reasons
+		}
+	}
+	return nil
+}
+
+func ruleFailuresForTracker(failures map[string][]api.RuleFailure, tracker string) []api.RuleFailure {
+	if len(failures) == 0 {
+		return nil
+	}
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	if trackerFailures, ok := failures[name]; ok {
+		return trackerFailures
+	}
+	for key, trackerFailures := range failures {
+		if strings.EqualFold(strings.TrimSpace(key), name) {
+			return trackerFailures
+		}
+	}
+	return nil
+}
+
+func (m *mediaModule) resolveFallbackImageUploadTargets(
+	host string,
+	trackerNames []string,
+	excludedHosts []string,
+	meta api.UploadSubject,
+) ([]trackers.ImageUploadTarget, error) {
+	normalizedHost := strings.ToLower(strings.TrimSpace(host))
+	if normalizedHost == "" || len(trackerNames) == 0 {
+		return nil, nil
+	}
+	targets, err := trackers.NeededImageUploadTargetsForMetadataExcludingWithRegistry(m.registry, m.cfg, trackerNames, normalizedHost, excludedHosts, meta)
+	if err != nil {
+		return nil, fmt.Errorf("core: %w", err)
+	}
+	normalized := make([]trackers.ImageUploadTarget, 0, len(targets))
+	for _, target := range targets {
+		target = normalizeImageUploadTarget(target)
+		if target.Host == "" {
+			continue
+		}
+		normalized = append(normalized, target)
+	}
+	return normalized, nil
+}
+
+func (m *mediaModule) uploadImagesToTargetsWithFallback(
+	ctx context.Context,
+	meta api.UploadSubject,
+	host string,
+	targets []trackers.ImageUploadTarget,
+	images []api.ScreenshotImage,
+) (api.UploadImagesResult, error) {
+	allLinks := make([]api.UploadedImageLink, 0, len(images)*len(targets))
+	failedHosts := make(map[string]struct{}, len(targets))
+	currentTargets := targets
+	fallbackAttempt := false
+	var failures []api.UploadImageHostFailure
+
+	for len(currentTargets) > 0 {
+		result := m.uploadImagesToTargets(ctx, meta, currentTargets, images, fallbackAttempt)
+		allLinks = append(allLinks, result.Links...)
+		if len(result.Failures) == 0 {
+			return api.UploadImagesResult{Links: allLinks}, nil
+		}
+
+		failures = result.Failures
+		for _, failure := range result.Failures {
+			host := strings.ToLower(strings.TrimSpace(failure.Host))
+			if host != "" {
+				failedHosts[host] = struct{}{}
+			}
+		}
+
+		blockedTrackers := uploadFailureTrackers(failures)
+		fallbackTargets, err := m.resolveFallbackImageUploadTargets(host, blockedTrackers, sortedMapKeys(failedHosts), meta)
+		if err != nil {
+			return api.UploadImagesResult{}, err
+		}
+
+		var recoveredTrackers []string
+		nextTargets := make([]trackers.ImageUploadTarget, 0, len(fallbackTargets))
+		for _, target := range fallbackTargets {
+			if uploadedLinksCoverTarget(allLinks, target, len(images)) {
+				recoveredTrackers = append(recoveredTrackers, target.Trackers...)
+				continue
+			}
+			nextTargets = append(nextTargets, target)
+		}
+		failures = filterUploadFailuresForRecoveredTrackers(failures, recoveredTrackers)
+		if len(nextTargets) == 0 {
+			if len(failures) == 0 {
+				return api.UploadImagesResult{Links: allLinks}, nil
+			}
+			return api.UploadImagesResult{Links: allLinks, Failures: failures}, nil
+		}
+
+		m.logger.Warnf(
+			"core: retrying image uploads after host failures failed_hosts=%s fallback_hosts=%s trackers=%v",
+			strings.Join(sortedMapKeys(failedHosts), ","),
+			strings.Join(uploadTargetHosts(nextTargets), ","),
+			uploadTargetTrackers(nextTargets),
+		)
+		currentTargets = nextTargets
+		fallbackAttempt = true
+	}
+
+	return api.UploadImagesResult{Links: allLinks, Failures: failures}, nil
+}
+
+func uploadFailureTrackers(failures []api.UploadImageHostFailure) []string {
+	trackersList := make([]string, 0)
+	for _, failure := range failures {
+		for _, tracker := range failure.Trackers {
+			trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
+		}
+	}
+	return trackersList
+}
+
+func filterUploadFailuresForRecoveredTrackers(failures []api.UploadImageHostFailure, recoveredTrackers []string) []api.UploadImageHostFailure {
+	if len(failures) == 0 || len(recoveredTrackers) == 0 {
+		return failures
+	}
+	recovered := make(map[string]struct{}, len(recoveredTrackers))
+	for _, tracker := range recoveredTrackers {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if name != "" {
+			recovered[name] = struct{}{}
+		}
+	}
+
+	filtered := make([]api.UploadImageHostFailure, 0, len(failures))
+	for _, failure := range failures {
+		remainingTrackers := make([]string, 0, len(failure.Trackers))
+		for _, tracker := range failure.Trackers {
+			name := strings.ToUpper(strings.TrimSpace(tracker))
+			if name == "" {
+				continue
+			}
+			if _, ok := recovered[name]; ok {
+				continue
+			}
+			remainingTrackers = appendUniqueNormalizedTracker(remainingTrackers, name)
+		}
+		if len(failure.Trackers) > 0 && len(remainingTrackers) == 0 {
+			continue
+		}
+		failure.Trackers = remainingTrackers
+		filtered = append(filtered, failure)
+	}
+	return filtered
+}
+
+func uploadedLinksCoverTarget(links []api.UploadedImageLink, target trackers.ImageUploadTarget, expectedImages int) bool {
+	if expectedImages == 0 {
+		return false
+	}
+	host := strings.ToLower(strings.TrimSpace(target.Host))
+	scope := normalizeImageUploadUsageScope(target.UsageScope)
+	seenPaths := make(map[string]struct{}, expectedImages)
+	for _, link := range links {
+		if !strings.EqualFold(strings.TrimSpace(link.Host), host) {
+			continue
+		}
+		if normalizeImageUploadUsageScope(link.UsageScope) != scope {
+			continue
+		}
+		path := normalizedUploadImagePath(link.ImagePath)
+		if path == "" {
+			continue
+		}
+		seenPaths[path] = struct{}{}
+	}
+	return len(seenPaths) >= expectedImages
+}
+
+func uploadTargetHosts(targets []trackers.ImageUploadTarget) []string {
+	hosts := make([]string, 0, len(targets))
+	seen := make(map[string]struct{}, len(targets))
+	for _, target := range targets {
+		host := strings.ToLower(strings.TrimSpace(target.Host))
+		if host == "" {
+			continue
+		}
+		if _, ok := seen[host]; ok {
+			continue
+		}
+		seen[host] = struct{}{}
+		hosts = append(hosts, host)
+	}
+	slices.Sort(hosts)
+	return hosts
+}
+
+func uploadTargetTrackers(targets []trackers.ImageUploadTarget) []string {
+	trackersList := make([]string, 0)
+	for _, target := range targets {
+		for _, tracker := range target.Trackers {
+			trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
+		}
+	}
+	slices.Sort(trackersList)
+	return trackersList
+}
+
+func sortedMapKeys(values map[string]struct{}) []string {
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		if strings.TrimSpace(key) == "" {
+			continue
+		}
+		keys = append(keys, key)
+	}
+	slices.Sort(keys)
+	return keys
+}
+
+func (m *mediaModule) uploadImagesToTargets(
+	ctx context.Context,
+	meta api.UploadSubject,
+	targets []trackers.ImageUploadTarget,
+	images []api.ScreenshotImage,
+	fallback bool,
+) api.UploadImagesResult {
+	m.logger.Infof(
+		"core: image upload round started hosts=%d host_names=%s fallback=%t images=%d",
+		len(targets),
+		strings.Join(uploadTargetHosts(targets), ","),
+		fallback,
+		len(images),
+	)
+	type uploadResult struct {
+		index  int
+		target trackers.ImageUploadTarget
+		links  []api.UploadedImageLink
+		err    error
+	}
+
+	resultCh := make(chan uploadResult, len(targets))
+	var wg sync.WaitGroup
+	for idx, target := range targets {
+		wg.Add(1)
+		go func(idx int, target trackers.ImageUploadTarget) {
+			defer wg.Done()
+			uploaded, err := m.uploadImagesToTarget(ctx, meta, target, images, fallback)
+			resultCh <- uploadResult{
+				index:  idx,
+				target: normalizeImageUploadTarget(target),
+				links:  uploaded,
+				err:    err,
+			}
+		}(idx, target)
+	}
+	wg.Wait()
+	close(resultCh)
+
+	ordered := make([]uploadResult, len(targets))
+	for result := range resultCh {
+		ordered[result.index] = result
+	}
+
+	results := make([]api.UploadedImageLink, 0, len(images)*len(targets))
+	failures := make([]api.UploadImageHostFailure, 0)
+	failureMessages := make([]string, 0)
+	for _, result := range ordered {
+		results = append(results, result.links...)
+		if result.err != nil {
+			failure := api.UploadImageHostFailure{
+				Host:       result.target.Host,
+				UsageScope: result.target.UsageScope,
+				Trackers:   slices.Clone(result.target.Trackers),
+				Message:    logging.SanitizeMessage(uploadFailureMessage(result.err)),
+			}
+			failures = append(failures, failure)
+			failureMessages = append(failureMessages, fmt.Sprintf(
+				"host=%s trackers=%v err=%s",
+				result.target.Host,
+				result.target.Trackers,
+				redaction.RedactValue(failure.Message, nil),
+			))
+		}
+	}
+	if len(failures) == 0 {
+		return api.UploadImagesResult{Links: results}
+	}
+	result := api.UploadImagesResult{Links: results, Failures: failures}
+	if len(results) > 0 {
+		m.logger.Warnf(
+			"core: image uploads completed with %d host failures and %d successful links: %s",
+			len(failures),
+			len(results),
+			strings.Join(failureMessages, "; "),
+		)
+		return result
+	}
+	m.logger.Warnf("core: image uploads failed for all hosts: %s", strings.Join(failureMessages, "; "))
+	return result
+}
+
+func normalizeImageUploadTarget(target trackers.ImageUploadTarget) trackers.ImageUploadTarget {
+	target.Host = strings.ToLower(strings.TrimSpace(target.Host))
+	target.UsageScope = normalizeImageUploadUsageScope(target.UsageScope)
+	trackersList := make([]string, 0, len(target.Trackers))
+	for _, tracker := range target.Trackers {
+		trackersList = appendUniqueNormalizedTracker(trackersList, tracker)
+	}
+	target.Trackers = trackersList
+	return target
+}
+
+func appendUniqueNormalizedTracker(trackersList []string, tracker string) []string {
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	if name == "" {
+		return trackersList
+	}
+	if slices.Contains(trackersList, name) {
+		return trackersList
+	}
+	return append(trackersList, name)
+}
+
+func (m *mediaModule) uploadImagesToTarget(
+	ctx context.Context,
+	meta api.UploadSubject,
+	target trackers.ImageUploadTarget,
+	images []api.ScreenshotImage,
+	fallback bool,
+) ([]api.UploadedImageLink, error) {
+	target.Host = strings.ToLower(strings.TrimSpace(target.Host))
+	target.UsageScope = normalizeImageUploadUsageScope(target.UsageScope)
+	progressTarget := api.ImageUploadProgressTarget{
+		AttemptID:  target.Host + "|" + target.UsageScope,
+		Host:       target.Host,
+		UsageScope: target.UsageScope,
+		Trackers:   slices.Clone(target.Trackers),
+		Fallback:   fallback,
+		Total:      len(images),
+	}
+	progressCtx := api.WithImageUploadProgressTarget(ctx, progressTarget)
+	emitCoreImageUploadProgress(progressCtx, progressTarget, api.ImageUploadProgressRunning, 0, 0, 0, "Preparing host upload.")
+	if m.repo == nil {
+		m.logger.Tracef(
+			"core: uploading images host=%s tracker=%s scope=%s trackers=%v count=%d",
+			target.Host,
+			m.imageHostOwnerLogValue(target.Host),
+			target.UsageScope,
+			target.Trackers,
+			len(images),
+		)
+		uploaded, err := m.images.Upload(progressCtx, imageHostingSubject(meta), target.Host, target.UsageScope, images)
+		emitCoreImageUploadResult(progressCtx, progressTarget, len(uploaded), err)
+		return wrapCoreResult(uploaded, err)
+	}
+
+	existing, err := m.repo.ListUploadedImagesByPath(ctx, meta.SourcePath)
+	if err != nil {
+		emitCoreImageUploadProgress(progressCtx, progressTarget, api.ImageUploadProgressFailed, 0, 0, 0, "Existing uploads could not be checked.")
+		return nil, fmt.Errorf("core: %w", err)
+	}
+	existingByPath := uploadedImagesByPathForTarget(existing, target)
+	results := make([]api.UploadedImageLink, 0, len(images))
+	missing := make([]api.ScreenshotImage, 0, len(images))
+	for _, image := range images {
+		key := normalizedUploadImagePath(image.Path)
+		if key == "" {
+			missing = append(missing, image)
+			continue
+		}
+		if link, ok := existingByPath[key]; ok {
+			results = append(results, link)
+			continue
+		}
+		missing = append(missing, image)
+	}
+	progressTarget.Reused = len(results)
+	progressCtx = api.WithImageUploadProgressTarget(ctx, progressTarget)
+	if len(missing) == 0 {
+		m.logger.Tracef(
+			"core: reusing uploaded images host=%s tracker=%s scope=%s trackers=%v count=%d",
+			target.Host,
+			m.imageHostOwnerLogValue(target.Host),
+			target.UsageScope,
+			target.Trackers,
+			len(results),
+		)
+		emitCoreImageUploadProgress(
+			progressCtx,
+			progressTarget,
+			api.ImageUploadProgressCompleted,
+			len(results),
+			0,
+			0,
+			"Reused existing host uploads.",
+		)
+		return results, nil
+	}
+	emitCoreImageUploadProgress(
+		progressCtx,
+		progressTarget,
+		api.ImageUploadProgressRunning,
+		len(results),
+		0,
+		0,
+		fmt.Sprintf("Uploading %d images; %d already ready.", len(missing), len(results)),
+	)
+
+	m.logger.Debugf(
+		"core: uploading missing images host=%s tracker=%s scope=%s trackers=%v missing=%d reused=%d",
+		target.Host,
+		m.imageHostOwnerLogValue(target.Host),
+		target.UsageScope,
+		target.Trackers,
+		len(missing),
+		len(results),
+	)
+	uploaded, err := m.images.Upload(progressCtx, imageHostingSubject(meta), target.Host, target.UsageScope, missing)
+	results = append(results, uploaded...)
+	emitCoreImageUploadResult(progressCtx, progressTarget, len(uploaded), err)
+	if err != nil {
+		return results, fmt.Errorf("core: %w", err)
+	}
+	return results, nil
+}
+
+func emitCoreImageUploadResult(
+	ctx context.Context,
+	target api.ImageUploadProgressTarget,
+	uploaded int,
+	err error,
+) {
+	if err == nil {
+		emitCoreImageUploadProgress(
+			ctx,
+			target,
+			api.ImageUploadProgressCompleted,
+			target.Total,
+			uploaded,
+			0,
+			"Host upload complete.",
+		)
+		return
+	}
+	failed := max(0, target.Total-target.Reused-uploaded)
+	emitCoreImageUploadProgress(
+		ctx,
+		target,
+		api.ImageUploadProgressFailed,
+		target.Reused+uploaded+failed,
+		uploaded,
+		failed,
+		fmt.Sprintf("%d of %d host uploads failed.", failed, target.Total-target.Reused),
+	)
+}
+
+func emitCoreImageUploadProgress(
+	ctx context.Context,
+	target api.ImageUploadProgressTarget,
+	status api.ImageUploadProgressStatus,
+	completed int,
+	succeeded int,
+	failed int,
+	message string,
+) {
+	total := max(0, target.Total)
+	api.EmitImageUploadProgress(ctx, api.ImageUploadProgressUpdate{
+		AttemptID:  target.AttemptID,
+		Host:       target.Host,
+		UsageScope: target.UsageScope,
+		Trackers:   slices.Clone(target.Trackers),
+		Fallback:   target.Fallback,
+		Completed:  max(0, min(completed, total)),
+		Total:      total,
+		Succeeded:  max(0, succeeded),
+		Failed:     max(0, failed),
+		Reused:     max(0, min(target.Reused, total)),
+		Status:     status,
+		Message:    strings.TrimSpace(message),
+	})
+}
+
+func uploadFailureMessage(err error) string {
+	if err == nil {
+		return ""
+	}
+	if unwrapped := errors.Unwrap(err); unwrapped != nil {
+		return unwrapped.Error()
+	}
+	return err.Error()
+}
+
+func uploadedImagesByPathForTarget(images []api.UploadedImageLink, target trackers.ImageUploadTarget) map[string]api.UploadedImageLink {
+	matches := make(map[string]api.UploadedImageLink, len(images))
+	for _, image := range images {
+		if !strings.EqualFold(strings.TrimSpace(image.Host), target.Host) {
+			continue
+		}
+		if !strings.EqualFold(normalizeImageUploadUsageScope(image.UsageScope), normalizeImageUploadUsageScope(target.UsageScope)) {
+			continue
+		}
+		key := normalizedUploadImagePath(image.ImagePath)
+		if key == "" {
+			continue
+		}
+		matches[key] = image
+	}
+	return matches
+}
+
+func normalizedUploadImagePath(pathValue string) string {
+	trimmed := strings.TrimSpace(pathValue)
+	if trimmed == "" {
+		return ""
+	}
+	absPath, err := filepath.Abs(trimmed)
+	if err != nil {
+		return filepath.Clean(trimmed)
+	}
+	return filepath.Clean(absPath)
+}
+
+func normalizeImageUploadUsageScope(scope string) string {
+	trimmed := strings.TrimSpace(scope)
+	if trimmed == "" || strings.EqualFold(trimmed, "global") {
+		return "global"
+	}
+	if strings.HasPrefix(strings.ToLower(trimmed), "tracker:") {
+		tracker := strings.ToUpper(strings.TrimSpace(trimmed[len("tracker:"):]))
+		if tracker == "" {
+			return "global"
+		}
+		return "tracker:" + tracker
+	}
+	return trimmed
+}
+
+// imageHostOwnerLogValue identifies tracker-owned hosts in core upload logs.
+func (m *mediaModule) imageHostOwnerLogValue(host string) string {
+	if tracker := trackers.TrackerForOwnedImageHost(m.registry, host); tracker != "" {
+		return tracker
+	}
+	return "shared"
+}
+
+func (m *mediaModule) deleteAcceptedUploadedImage(
+	ctx context.Context,
+	input api.ImageHostingInput,
+	imagePath string,
+	host string,
+) error {
+	if m.repo == nil {
+		return errors.New("core: repository not configured")
+	}
+	if m.preparedFacts == nil {
+		return errors.New("core: canonical preparation is not configured")
+	}
+	if strings.TrimSpace(imagePath) == "" || strings.TrimSpace(host) == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	subject, err := m.preparedFacts.ResolveImageHostingSubject(ctx, input)
+	if err != nil {
+		return fmt.Errorf("core: resolve uploaded image deletion subject: %w", err)
+	}
+	m.logger.Debugf("core: deleting uploaded image path=%s host=%s tracker=%s", imagePath, host, m.imageHostOwnerLogValue(host))
+	return wrapCoreError(m.repo.DeleteUploadedImage(ctx, subject.SourcePath, imagePath, host))
+}
diff --git a/internal/core/media_test.go b/internal/core/media_test.go
new file mode 100644
index 00000000..9ca81f47
--- /dev/null
+++ b/internal/core/media_test.go
@@ -0,0 +1,318 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type imageHostCall struct {
+	host     string
+	fallback bool
+}
+
+type imageHostBehavior struct {
+	release <-chan struct{}
+	err     error
+}
+
+type imageUploadCallResult struct {
+	result api.UploadImagesResult
+	err    error
+}
+
+type barrierImageHostingService struct {
+	entered   chan imageHostCall
+	behaviors map[string]imageHostBehavior
+}
+
+func (*barrierImageHostingService) ListCandidates(context.Context, api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
+	return nil, nil
+}
+
+func (s *barrierImageHostingService) Upload(
+	ctx context.Context,
+	_ api.ImageHostingSubject,
+	host string,
+	usageScope string,
+	images []api.ScreenshotImage,
+) ([]api.UploadedImageLink, error) {
+	target, _ := api.ImageUploadProgressTargetFromContext(ctx)
+	s.entered <- imageHostCall{host: host, fallback: target.Fallback}
+	behavior := s.behaviors[host]
+	select {
+	case <-behavior.release:
+	case <-ctx.Done():
+		return nil, fmt.Errorf("context canceled: %w", ctx.Err())
+	}
+	links := make([]api.UploadedImageLink, 0, len(images))
+	for _, image := range images {
+		links = append(links, api.UploadedImageLink{
+			ImagePath:  image.Path,
+			Host:       host,
+			UsageScope: usageScope,
+			RawURL:     "https://images.example.invalid/" + host,
+		})
+	}
+	return links, behavior.err
+}
+
+func TestUploadImagesToTargetsOverlapsHostsAndPreservesTargetOrder(t *testing.T) {
+	t.Parallel()
+
+	alphaRelease := make(chan struct{})
+	betaRelease := make(chan struct{})
+	service := &barrierImageHostingService{
+		entered: make(chan imageHostCall, 2),
+		behaviors: map[string]imageHostBehavior{
+			"alpha": {release: alphaRelease, err: errors.New("alpha failed")},
+			"beta":  {release: betaRelease, err: errors.New("beta failed")},
+		},
+	}
+	logger := &eligibilityCaptureLogger{}
+	module := &mediaModule{images: service, logger: logger}
+	targets := []trackers.ImageUploadTarget{
+		{
+Host: "alpha",
+ UsageScope: "global",
+ Trackers: []string{"ONE"},
+},
+		{
+Host: "beta",
+ UsageScope: "global",
+ Trackers: []string{"TWO"},
+},
+	}
+	done := make(chan api.UploadImagesResult, 1)
+	go func() {
+		done <- module.uploadImagesToTargets(
+			context.Background(),
+			api.UploadSubject{SourcePath: "C:\\media\\Example.Release.2026.mkv"},
+			targets,
+			[]api.ScreenshotImage{{Path: "screen.png"}},
+			false,
+		)
+	}()
+
+	first := receiveImageHostCall(t, service.entered)
+	second := receiveImageHostCall(t, service.entered)
+	if first.host == second.host || first.fallback || second.fallback {
+		t.Fatalf("primary host entries = %#v, %#v", first, second)
+	}
+	close(betaRelease)
+	close(alphaRelease)
+	result := receiveImageUploadResult(t, done)
+	if got := uploadLinkHosts(result.Links); !slices.Equal(got, []string{"alpha", "beta"}) {
+		t.Fatalf("link order = %v", got)
+	}
+	if got := uploadFailureHosts(result.Failures); !slices.Equal(got, []string{"alpha", "beta"}) {
+		t.Fatalf("failure order = %v", got)
+	}
+	if info := strings.Join(logger.level("info"), "\n"); !strings.Contains(info, "hosts=2 host_names=alpha,beta fallback=false images=1") {
+		t.Fatalf("round-start log missing: %q", info)
+	}
+}
+
+func TestUploadImagesFallbackWaitsForPrimaryRoundAndOverlapsFallbackHosts(t *testing.T) {
+	t.Parallel()
+
+	registry := mediaImageHostRegistry(t)
+	releases := map[string]chan struct{}{
+		"pixhost":   make(chan struct{}),
+		"onlyimage": make(chan struct{}),
+		"imgbb":     make(chan struct{}),
+		"ptscreens": make(chan struct{}),
+	}
+	service := &barrierImageHostingService{
+		entered: make(chan imageHostCall, 4),
+		behaviors: map[string]imageHostBehavior{
+			"pixhost":   {release: releases["pixhost"], err: errors.New("pixhost failed")},
+			"onlyimage": {release: releases["onlyimage"], err: errors.New("onlyimage failed")},
+			"imgbb":     {release: releases["imgbb"]},
+			"ptscreens": {release: releases["ptscreens"]},
+		},
+	}
+	module := &mediaModule{
+		cfg: config.Config{ImageHosting: config.ImageHostingConfig{
+			Host1: "pixhost",
+			Host2: "onlyimage",
+			Host3: "imgbb",
+			Host4: "ptscreens",
+		}},
+		images:   service,
+		logger:   api.NopLogger{},
+		registry: registry,
+	}
+	resolvedFallbacks, err := module.resolveFallbackImageUploadTargets(
+		"pixhost",
+		[]string{"ONE", "TWO"},
+		[]string{"pixhost", "onlyimage"},
+		api.UploadSubject{},
+	)
+	if err != nil {
+		t.Fatalf("resolve fallback targets: %v", err)
+	}
+	if got := uploadTargetHosts(resolvedFallbacks); !slices.Equal(got, []string{"imgbb", "ptscreens"}) {
+		t.Fatalf("resolved fallback hosts = %v, targets=%#v", got, resolvedFallbacks)
+	}
+	done := make(chan imageUploadCallResult, 1)
+	go func() {
+		result, err := module.uploadImagesToTargetsWithFallback(
+			context.Background(),
+			api.UploadSubject{SourcePath: "C:\\media\\Example.Release.2026.mkv"},
+			"pixhost",
+			[]trackers.ImageUploadTarget{
+				{
+Host: "pixhost",
+ UsageScope: "global",
+ Trackers: []string{"ONE"},
+},
+				{
+Host: "onlyimage",
+ UsageScope: "global",
+ Trackers: []string{"TWO"},
+},
+			},
+			[]api.ScreenshotImage{{Path: "screen.png"}},
+		)
+		done <- imageUploadCallResult{result: result, err: err}
+	}()
+
+	primary := []imageHostCall{
+		receiveImageHostCall(t, service.entered),
+		receiveImageHostCall(t, service.entered),
+	}
+	if got := sortedCallHosts(primary); !slices.Equal(got, []string{"onlyimage", "pixhost"}) {
+		t.Fatalf("primary hosts = %v", got)
+	}
+	close(releases["pixhost"])
+	select {
+	case call := <-service.entered:
+		t.Fatalf("fallback started before primary round completed: %#v", call)
+	default:
+	}
+	close(releases["onlyimage"])
+
+	fallback := []imageHostCall{
+		receiveImageHostCall(t, service.entered),
+		receiveImageHostCall(t, service.entered),
+	}
+	if got := sortedCallHosts(fallback); !slices.Equal(got, []string{"imgbb", "ptscreens"}) {
+		t.Fatalf("fallback hosts = %v", got)
+	}
+	if !fallback[0].fallback || !fallback[1].fallback {
+		t.Fatalf("fallback flags = %#v", fallback)
+	}
+	close(releases["ptscreens"])
+	close(releases["imgbb"])
+	callResult := receiveImageUploadCallResult(t, done)
+	if callResult.err != nil {
+		t.Fatalf("upload images with fallback: %v", callResult.err)
+	}
+	result := callResult.result
+	if len(result.Failures) != 0 || len(result.Links) != 4 {
+		t.Fatalf("fallback result = %#v", result)
+	}
+}
+
+type mediaImageHostDefinition string
+
+func (d mediaImageHostDefinition) Name() string { return string(d) }
+
+func (mediaImageHostDefinition) Prepare(context.Context, trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.TrackerPlan{}, nil
+}
+
+func mediaImageHostRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry := trackers.NewRegistry()
+	for _, item := range []struct {
+		name  string
+		hosts []string
+	}{
+		{name: "ONE", hosts: []string{"pixhost", "imgbb"}},
+		{name: "TWO", hosts: []string{"onlyimage", "ptscreens"}},
+	} {
+		err := registry.RegisterDescriptor(trackers.Descriptor{
+			Name:              item.name,
+			Definition:        mediaImageHostDefinition(item.name),
+			Family:            trackers.FamilyStandalone,
+			BaseURL:           "https://" + strings.ToLower(item.name) + ".example.invalid",
+			UploadContentMode: trackers.UploadContentModeScreenshots,
+			ImageHost:         &trackers.ImageHostPolicy{AllowedHosts: item.hosts},
+		})
+		if err != nil {
+			t.Fatalf("register %s: %v", item.name, err)
+		}
+	}
+	return registry
+}
+
+func receiveImageHostCall(t *testing.T, calls <-chan imageHostCall) imageHostCall {
+	t.Helper()
+	select {
+	case call := <-calls:
+		return call
+	case <-time.After(5 * time.Second):
+		t.Fatal("timed out waiting for image-host call")
+		return imageHostCall{}
+	}
+}
+
+func receiveImageUploadResult(t *testing.T, results <-chan api.UploadImagesResult) api.UploadImagesResult {
+	t.Helper()
+	select {
+	case result := <-results:
+		return result
+	case <-time.After(5 * time.Second):
+		t.Fatal("timed out waiting for image upload result")
+		return api.UploadImagesResult{}
+	}
+}
+
+func receiveImageUploadCallResult(t *testing.T, results <-chan imageUploadCallResult) imageUploadCallResult {
+	t.Helper()
+	select {
+	case result := <-results:
+		return result
+	case <-time.After(5 * time.Second):
+		t.Fatal("timed out waiting for image upload result")
+		return imageUploadCallResult{}
+	}
+}
+
+func uploadLinkHosts(links []api.UploadedImageLink) []string {
+	hosts := make([]string, 0, len(links))
+	for _, link := range links {
+		hosts = append(hosts, link.Host)
+	}
+	return hosts
+}
+
+func uploadFailureHosts(failures []api.UploadImageHostFailure) []string {
+	hosts := make([]string, 0, len(failures))
+	for _, failure := range failures {
+		hosts = append(hosts, failure.Host)
+	}
+	return hosts
+}
+
+func sortedCallHosts(calls []imageHostCall) []string {
+	hosts := make([]string, 0, len(calls))
+	for _, call := range calls {
+		hosts = append(hosts, call.host)
+	}
+	slices.Sort(hosts)
+	return hosts
+}
diff --git a/internal/core/operation_failure.go b/internal/core/operation_failure.go
new file mode 100644
index 00000000..1cf2f4b4
--- /dev/null
+++ b/internal/core/operation_failure.go
@@ -0,0 +1,86 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"errors"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// classifyOperationError maps internal causes to stable frontend-safe recovery
+// contracts while retaining the original error as the wrapped cause.
+func classifyOperationError(operation api.OperationKind, err error) error {
+	if err == nil {
+		return nil
+	}
+	if _, ok := api.AsOperationFailure(err); ok {
+		return err
+	}
+	failure := api.OperationFailure{
+		Code:      api.OperationFailureInternal,
+		Operation: operation,
+		Message:   "The operation could not be completed.",
+		Recovery:  api.OperationRecoveryRetry,
+	}
+	var stale *preparedrelease.StalePreparationError
+	var incompatible *preparedrelease.IncompatiblePreparationError
+	var missing *api.MissingRequirementError
+	var rescan *api.BDMVRescanRequiredError
+	var playlistRequired *api.PlaylistSelectionRequiredError
+	var invalidPlaylist *api.InvalidPlaylistSelectionError
+	var authRequired *trackerauth.AuthRequiredError
+	var needs2FA *trackerauth.Needs2FAError
+	switch {
+	case errors.Is(err, api.ErrPreparationSourceRequired):
+		failure.Code = api.OperationFailureInvalidSource
+		failure.Message = "A source path is required."
+		failure.Recovery = api.OperationRecoveryEditInput
+	case errors.Is(err, sourcelayout.ErrSourceNotFound):
+		failure.Code = api.OperationFailureInvalidSource
+		failure.Message = "The source path is unavailable."
+		failure.Recovery = api.OperationRecoveryEditInput
+	case errors.As(err, &playlistRequired):
+		failure.Code = api.OperationFailureMissingPrerequisite
+		failure.Message = "Select at least one Blu-ray playlist before preparing the release."
+		failure.Recovery = api.OperationRecoveryCompletePrerequisite
+	case errors.As(err, &invalidPlaylist):
+		failure.Code = api.OperationFailureInvalidInput
+		failure.Message = "The Blu-ray playlist selection is invalid."
+		failure.Recovery = api.OperationRecoveryEditInput
+	case errors.As(err, &rescan):
+		failure.Code = api.OperationFailureConfirmationRequired
+		failure.Message = "Blu-ray playlist changes require confirmation before rescanning."
+		failure.Recovery = api.OperationRecoveryConfirm
+	case errors.As(err, &stale):
+		failure.Code = api.OperationFailureStaleGeneration
+		failure.Message = "The prepared release changed. Refresh it before continuing."
+		failure.Recovery = api.OperationRecoveryRefreshRelease
+	case errors.As(err, &incompatible):
+		failure.Code = api.OperationFailureIncompatibleGeneration
+		failure.Message = "The prepared release is incompatible. Prepare it again."
+		failure.Recovery = api.OperationRecoveryRefreshRelease
+	case errors.As(err, &missing):
+		failure.Code = api.OperationFailureMissingPrerequisite
+		failure.Message = missing.Error()
+		failure.Recovery = api.OperationRecoveryCompletePrerequisite
+	case errors.As(err, &authRequired), errors.As(err, &needs2FA):
+		failure.Code = api.OperationFailureTrackerAuthRequired
+		failure.Message = "Tracker authentication is required."
+		failure.Recovery = api.OperationRecoveryAuthenticateTrackers
+	case errors.Is(err, internalerrors.ErrInvalidInput):
+		failure.Code = api.OperationFailureInvalidInput
+		failure.Message = "The operation input is invalid."
+		failure.Recovery = api.OperationRecoveryEditInput
+	}
+	return api.NewOperationError(failure, err)
+}
+
+func classifyOperationResult[T any](operation api.OperationKind, value T, err error) (T, error) {
+	return value, classifyOperationError(operation, err)
+}
diff --git a/internal/core/operation_failure_mapping_test.go b/internal/core/operation_failure_mapping_test.go
new file mode 100644
index 00000000..96ceca95
--- /dev/null
+++ b/internal/core/operation_failure_mapping_test.go
@@ -0,0 +1,91 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestClassifyOperationErrorCanonicalMappings(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		operation api.OperationKind
+		cause     error
+		wantCode  api.OperationFailureCode
+		message   string
+		recovery  api.OperationRecovery
+	}{
+		{
+name: "missing source",
+ operation: api.OperationKindPreparation,
+ cause: api.ErrPreparationSourceRequired,
+ wantCode: api.OperationFailureInvalidSource,
+ message: "A source path is required.",
+ recovery: api.OperationRecoveryEditInput,
+},
+		{
+name: "unavailable source",
+ operation: api.OperationKindPreparation,
+ cause: sourcelayout.ErrSourceNotFound,
+ wantCode: api.OperationFailureInvalidSource,
+ message: "The source path is unavailable.",
+ recovery: api.OperationRecoveryEditInput,
+},
+		{
+name: "playlist required",
+ operation: api.OperationKindPreparation,
+ cause: &api.PlaylistSelectionRequiredError{SourcePath: `C:\private`},
+ wantCode: api.OperationFailureMissingPrerequisite,
+ message: "Select at least one Blu-ray playlist before preparing the release.",
+ recovery: api.OperationRecoveryCompletePrerequisite,
+},
+		{
+name: "playlist invalid",
+ operation: api.OperationKindPreparation,
+ cause: &api.InvalidPlaylistSelectionError{SourcePath: `C:\private`, Playlist: "../bad.mpls"},
+ wantCode: api.OperationFailureInvalidInput,
+ message: "The Blu-ray playlist selection is invalid.",
+ recovery: api.OperationRecoveryEditInput,
+},
+		{
+name: "rescan confirmation",
+ operation: api.OperationKindPreparation,
+ cause: &api.BDMVRescanRequiredError{SourcePath: `C:\private`},
+ wantCode: api.OperationFailureConfirmationRequired,
+ message: "Blu-ray playlist changes require confirmation before rescanning.",
+ recovery: api.OperationRecoveryConfirm,
+},
+		{
+name: "client failure",
+ operation: api.OperationKindDuplicateCheck,
+ cause: errors.New("client secret and private path"),
+ wantCode: api.OperationFailureInternal,
+ message: "The operation could not be completed.",
+ recovery: api.OperationRecoveryRetry,
+},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			failure, ok := api.AsOperationFailure(classifyOperationError(test.operation, test.cause))
+			if !ok {
+				t.Fatal("classified error has no operation failure")
+			}
+			want := api.OperationFailure{
+Code: test.wantCode,
+ Operation: test.operation,
+ Message: test.message,
+ Recovery: test.recovery,
+}
+			if failure != want {
+				t.Fatalf("failure = %#v, want %#v", failure, want)
+			}
+		})
+	}
+}
diff --git a/internal/core/preparation_test.go b/internal/core/preparation_test.go
deleted file mode 100644
index b486e931..00000000
--- a/internal/core/preparation_test.go
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"slices"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type stubFilesystem struct {
-	paths []string
-	err   error
-}
-
-func (s stubFilesystem) ValidatePaths(_ context.Context, paths []string) ([]string, error) {
-	if s.err != nil {
-		return nil, s.err
-	}
-	if s.paths != nil {
-		return append([]string{}, s.paths...), nil
-	}
-	return append([]string{}, paths...), nil
-}
-
-type stubPreparationTrackers struct {
-	called   bool
-	trackers []string
-	meta     api.PreparedMetadata
-}
-
-func (s *stubPreparationTrackers) Upload(context.Context, api.PreparedMetadata) (api.UploadSummary, error) {
-	return api.UploadSummary{Uploaded: 1}, nil
-}
-
-func (s *stubPreparationTrackers) BuildPreparation(_ context.Context, meta api.PreparedMetadata, trackers []string) (api.PreparationPreview, error) {
-	s.called = true
-	s.trackers = append([]string{}, trackers...)
-	s.meta = meta
-	return api.PreparationPreview{
-		SourcePath: meta.SourcePath,
-		Descriptions: []api.PreparationDescription{
-			{Trackers: trackers, RawDescription: meta.DescriptionTemplate, RawDescriptionHTML: "<p>ok</p>"},
-		},
-	}, nil
-}
-
-func (s *stubPreparationTrackers) BuildUploadDryRun(context.Context, api.PreparedMetadata, []string) ([]api.TrackerDryRunEntry, error) {
-	return []api.TrackerDryRunEntry{}, nil
-}
-
-func TestFetchPreparationPreviewFromCache(t *testing.T) {
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", DescriptionTemplate: "Example"}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	preview, err := core.FetchPreparationPreview(context.Background(), api.Request{Paths: []string{meta.SourcePath}, Mode: api.ModeGUI})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if !trackerSvc.called {
-		t.Fatalf("expected tracker preparation to be called")
-	}
-	if preview.SourcePath != meta.SourcePath {
-		t.Fatalf("expected source path %q, got %q", meta.SourcePath, preview.SourcePath)
-	}
-}
-
-func TestFetchPreparationPreviewReturnsEmptyWhenCachedSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		SourcePath:     "/tmp/source",
-		TrackersRemove: []string{"AITHER"},
-	}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	preview, err := core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths:    []string{meta.SourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if trackerSvc.called {
-		t.Fatal("expected tracker preparation to be skipped when selected trackers resolve empty")
-	}
-	if preview.SourcePath != meta.SourcePath {
-		t.Fatalf("expected source path %q, got %q", meta.SourcePath, preview.SourcePath)
-	}
-}
-
-func TestFetchPreparationPreviewUsesIgnoredMatchedTrackerFromCache(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		SourcePath:      "/tmp/source",
-		TrackersRemove:  []string{"AITHER", "BLU"},
-		MatchedTrackers: []string{"AITHER", "BLU"},
-	}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	preview, err := core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths:          []string{meta.SourcePath},
-		Mode:           api.ModeGUI,
-		Trackers:       []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if preview.SourcePath != meta.SourcePath {
-		t.Fatalf("expected source path %q, got %q", meta.SourcePath, preview.SourcePath)
-	}
-	if !slices.Equal(trackerSvc.trackers, []string{"AITHER"}) {
-		t.Fatalf("expected ignored matched tracker without default fallback, got %v", trackerSvc.trackers)
-	}
-	if slices.Contains(trackerSvc.meta.TrackersRemove, "AITHER") || !slices.Contains(trackerSvc.meta.TrackersRemove, "BLU") {
-		t.Fatalf("expected only unignored duplicate removal to remain, got %v", trackerSvc.meta.TrackersRemove)
-	}
-	if slices.Contains(trackerSvc.meta.MatchedTrackers, "AITHER") || !slices.Contains(trackerSvc.meta.MatchedTrackers, "BLU") {
-		t.Fatalf("expected only unignored matched tracker to remain, got %v", trackerSvc.meta.MatchedTrackers)
-	}
-}
-
-func TestFetchPreparationPreviewUsesOnlyExplicitTrackers(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	_, err := core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths:    []string{meta.SourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if !slices.Equal(trackerSvc.trackers, []string{"AITHER"}) {
-		t.Fatalf("expected explicit tracker only, got %v", trackerSvc.trackers)
-	}
-}
-
-func TestFetchPreparationPreviewDoesNotFallbackToUnsignedCacheWithExternalOverrides(t *testing.T) {
-	tmdbID := 321
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", DescriptionTemplate: "Example"}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	_, err := core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths: []string{meta.SourcePath},
-		Mode:  api.ModeGUI,
-		ExternalIDOverrides: api.ExternalIDOverrides{
-			TMDBID: &tmdbID,
-		},
-	})
-	if err == nil {
-		t.Fatalf("expected cache miss error when external overrides are present")
-	}
-	if trackerSvc.called {
-		t.Fatalf("expected tracker preparation not to run on unsigned cache fallback")
-	}
-}
-
-func TestFetchPreparationPreviewUsesBlockedTrackersFromCache(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-		},
-	}
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{meta.SourcePath}},
-			Trackers:   trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache(meta.SourcePath, "", meta)
-
-	_, err := core.FetchPreparationPreview(context.Background(), api.Request{Paths: []string{meta.SourcePath}, Mode: api.ModeGUI})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got := trackerSvc.meta.BlockedTrackers["HDB"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected blocked tracker metadata to be forwarded, got %#v", trackerSvc.meta.BlockedTrackers)
-	}
-}
-
-func TestFetchPreparationPreviewCachesMergedExternalIDSelections(t *testing.T) {
-	t.Parallel()
-
-	trackerSvc := &stubPreparationTrackers{}
-	core, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				SourcePath: "/tmp/source",
-				Release: api.ReleaseInfo{
-					Title: "Example",
-				},
-			}},
-			Trackers: trackerSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	tmdbID := 321
-	req := api.Request{
-		Paths: []string{"/tmp/source"},
-		Mode:  api.ModeGUI,
-		ExternalIDSelections: map[string]api.ExternalIDSelection{
-			"/tmp/source": {
-				TMDBID: &tmdbID,
-			},
-		},
-	}
-
-	if _, err := core.FetchPreparationPreview(context.Background(), req); err != nil {
-		t.Fatalf("fetch preparation preview: %v", err)
-	}
-
-	exported, ok, err := core.ExportGUICachedPreparedMeta(context.Background(), req)
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected preparation preview to cache merged external ID selection")
-	}
-	if exported.ExternalIDOverrides.TMDBID == nil || *exported.ExternalIDOverrides.TMDBID != tmdbID {
-		t.Fatalf("expected exported cached metadata to preserve merged TMDB selection, got %#v", exported.ExternalIDOverrides)
-	}
-}
-
-func TestFetchPreparationPreviewReturnsEmptyWhenPreparedSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	trackerSvc := &stubPreparationTrackers{}
-	core := &Core{
-		cfg: config.Config{
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		logger: api.NopLogger{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Metadata: &stubMeta{prepared: api.PreparedMetadata{
-				SourcePath:     "/tmp/source",
-				TrackersRemove: []string{"AITHER"},
-			}},
-			Trackers: trackerSvc,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	preview, err := core.FetchPreparationPreview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if trackerSvc.called {
-		t.Fatal("expected tracker preparation to be skipped when prepared selected trackers resolve empty")
-	}
-	if preview.SourcePath != "/tmp/source" {
-		t.Fatalf("expected source path to be preserved, got %q", preview.SourcePath)
-	}
-	if _, ok := core.getDupeCache("/tmp/source", ""); ok {
-		t.Fatal("expected explicit-empty preparation not to seed GUI cache")
-	}
-}
diff --git a/internal/core/preview_test.go b/internal/core/preview_test.go
deleted file mode 100644
index d246d395..00000000
--- a/internal/core/preview_test.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildMetadataPreviewMapsExternalData(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  "/media/example.mkv",
-		ReleaseName: "Example.Release.2026",
-		ExternalIDs: api.ExternalIDs{
-			TMDBID:     123,
-			SourceTMDB: "tracker",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				TMDBID:   123,
-				Title:    "Example",
-				Year:     2026,
-				Overview: "Overview text",
-				Poster:   "https://img.example/poster.jpg",
-				Backdrop: "https://img.example/backdrop.jpg",
-			},
-		},
-		TrackerData: []api.TrackerMetadata{
-			{Tracker: "AITHER", TMDBID: 123},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"NBL": {{Rule: "require_tv_only", Reason: "category movie is not tv"}},
-		},
-	}
-
-	preview := buildMetadataPreview(meta, config.Config{})
-
-	if preview.SourcePath != meta.SourcePath {
-		t.Fatalf("expected source path %q, got %q", meta.SourcePath, preview.SourcePath)
-	}
-	if preview.ReleaseName != meta.ReleaseName {
-		t.Fatalf("expected release name %q, got %q", meta.ReleaseName, preview.ReleaseName)
-	}
-	if preview.TrackerName != "AITHER" {
-		t.Fatalf("expected tracker name %q, got %q", "AITHER", preview.TrackerName)
-	}
-	if len(preview.ExternalPreview) != 1 {
-		t.Fatalf("expected 1 external preview, got %d", len(preview.ExternalPreview))
-	}
-
-	previewItem := preview.ExternalPreview[0]
-	if previewItem.Provider != "tmdb" {
-		t.Fatalf("expected provider tmdb, got %q", previewItem.Provider)
-	}
-	if previewItem.ID != 123 {
-		t.Fatalf("expected TMDB ID 123, got %d", previewItem.ID)
-	}
-	if previewItem.Title != "Example" {
-		t.Fatalf("expected title %q, got %q", "Example", previewItem.Title)
-	}
-	if previewItem.Year != 2026 {
-		t.Fatalf("expected year 2026, got %d", previewItem.Year)
-	}
-	if previewItem.PosterURL == "" || previewItem.BackdropURL == "" {
-		t.Fatalf("expected poster and backdrop URLs to be populated")
-	}
-	if got := preview.TrackerRuleFailures["NBL"]; len(got) != 1 || got[0].Rule != "require_tv_only" {
-		t.Fatalf("expected tracker rule failures in preview, got %#v", preview.TrackerRuleFailures)
-	}
-	preview.TrackerRuleFailures["NBL"][0].Rule = "mutated"
-	if meta.TrackerRuleFailures["NBL"][0].Rule != "require_tv_only" {
-		t.Fatalf("preview rule failures must not alias prepared metadata, got %#v", meta.TrackerRuleFailures)
-	}
-}
-
-func TestBuildMetadataPreviewOmitsResolvedIDsWithoutProviderData(t *testing.T) {
-	sourcePath := filepath.Join(t.TempDir(), "example.mkv")
-	meta := api.PreparedMetadata{
-		SourcePath: sourcePath,
-		ExternalIDs: api.ExternalIDs{
-			TMDBID:     123,
-			SourceTMDB: "tracker",
-		},
-	}
-
-	preview := buildMetadataPreview(meta, config.Config{})
-
-	if len(preview.ExternalIDInfo) != 1 {
-		t.Fatalf("expected resolved external ID to remain visible for editing, got %d", len(preview.ExternalIDInfo))
-	}
-	info := preview.ExternalIDInfo[0]
-	if info.Provider != "tmdb" || info.ID != 123 || info.Source != "tracker" {
-		t.Fatalf("expected preserved TMDB external ID info, got %#v", info)
-	}
-	if len(preview.ExternalPreview) != 0 {
-		t.Fatalf("expected no provider previews without fetched metadata, got %d", len(preview.ExternalPreview))
-	}
-}
-
-func TestBuildMetadataPreviewMapsTVmazeRichData(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  "/media/example-tv.mkv",
-		ReleaseName: "Example.Show.S01E01.2160p.WEB-DL",
-		ExternalIDs: api.ExternalIDs{
-			TVmazeID:     55,
-			SourceTVmaze: "tvmaze",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TVmaze: &api.TVmazeMetadata{
-				TVmazeID:  55,
-				Name:      "Example Show",
-				Premiered: "2021-04-03",
-				Summary:   "Series overview",
-				Poster:    "https://img.example/tvmaze-poster.jpg",
-				Backdrop:  "https://img.example/tvmaze-backdrop.jpg",
-				Type:      "Scripted",
-				Language:  "English",
-				Genres:    "Drama, Mystery",
-				Runtime:   52,
-				Rating:    8.6,
-				Weight:    88,
-				Country:   "United States",
-				IMDBID:    1234567,
-				TVDBID:    9988,
-			},
-		},
-	}
-
-	preview := buildMetadataPreview(meta, config.Config{})
-	if len(preview.ExternalPreview) != 1 {
-		t.Fatalf("expected 1 external preview, got %d", len(preview.ExternalPreview))
-	}
-	item := preview.ExternalPreview[0]
-	if item.Provider != "tvmaze" || item.ID != 55 {
-		t.Fatalf("unexpected tvmaze preview identity: %#v", item)
-	}
-	if item.Overview != "Series overview" || item.PosterURL == "" || item.BackdropURL == "" {
-		t.Fatalf("expected overview and image urls, got %#v", item)
-	}
-	if item.Rating != 8.6 || item.RatingCount != 88 || item.Country != "United States" {
-		t.Fatalf("expected rating/country populated, got %#v", item)
-	}
-}
-
-func TestBuildMetadataPreviewMapsAniListRichData(t *testing.T) {
-	updatedAt := time.Date(2026, 7, 8, 1, 2, 3, 0, time.UTC)
-	meta := api.PreparedMetadata{
-		SourcePath:  "/media/example-anime.mkv",
-		ReleaseName: "Example.Anime.S01.1080p.WEB-DL",
-		ExternalIDs: api.ExternalIDs{
-			MALID:     5114,
-			SourceMAL: "tmdb",
-			UpdatedAt: updatedAt,
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			AniList: &api.AniListMetadata{
-				AniListID:       1,
-				MALID:           5114,
-				SiteURL:         "https://anilist.co/anime/1",
-				TitleEnglish:    "Example Anime",
-				TitleRomaji:     "Example Anime Romaji",
-				Description:     "Anime overview",
-				Format:          "TV",
-				Status:          "FINISHED",
-				StartDate:       "2026-04-01",
-				SeasonYear:      2026,
-				Episodes:        12,
-				Duration:        24,
-				CoverLarge:      "https://img.example/anilist-cover.jpg",
-				BannerImage:     "https://img.example/anilist-banner.jpg",
-				Genres:          []string{"Action", "Drama"},
-				AverageScore:    82,
-				Popularity:      12345,
-				CountryOfOrigin: "JP",
-				ExternalLinks: []api.AniListExternalLink{
-					{Site: "Official", URL: "https://example.invalid/anime", Language: "ja"},
-				},
-			},
-			UpdatedAt: updatedAt,
-		},
-	}
-
-	preview := buildMetadataPreview(meta, config.Config{})
-	if len(preview.ExternalPreview) != 1 {
-		t.Fatalf("expected 1 external preview, got %d", len(preview.ExternalPreview))
-	}
-	item := preview.ExternalPreview[0]
-	if item.Provider != "mal" || item.ID != 5114 {
-		t.Fatalf("unexpected anilist preview identity: %#v", item)
-	}
-	if item.Source != "tmdb" {
-		t.Fatalf("expected MAL preview source provenance tmdb, got %q", item.Source)
-	}
-	if len(preview.ExternalIDInfo) != 1 || preview.ExternalIDInfo[0].Provider != "mal" || preview.ExternalIDInfo[0].Source != "tmdb" {
-		t.Fatalf("expected MAL external ID provenance in preview info, got %#v", preview.ExternalIDInfo)
-	}
-	if !preview.ExternalIDs.UpdatedAt.Equal(updatedAt) {
-		t.Fatalf("expected fresh external ID timestamp %s, got %s", updatedAt, preview.ExternalIDs.UpdatedAt)
-	}
-	if item.Title != "Example Anime" || item.Year != 2026 || item.Overview != "Anime overview" {
-		t.Fatalf("expected anilist title/year/overview, got %#v", item)
-	}
-	if item.PosterURL == "" || item.BackdropURL == "" || item.AniList == nil || item.AniList.AniListID != 1 {
-		t.Fatalf("expected anilist image urls and nested metadata, got %#v", item)
-	}
-	if item.AniList.Description != "Anime overview" || item.AniList.Status != "FINISHED" {
-		t.Fatalf("expected anilist message/status semantics, got description=%q status=%q", item.AniList.Description, item.AniList.Status)
-	}
-	if item.Genres != "Action, Drama" || item.Rating != 8.2 || item.RatingCount != 12345 {
-		t.Fatalf("expected anilist genres/rating, got %#v", item)
-	}
-	if item.OriginalLanguage != "ja" {
-		t.Fatalf("expected anilist preview original language from link language, got %q", item.OriginalLanguage)
-	}
-	if item.AniList.CountryOfOrigin != "JP" {
-		t.Fatalf("expected country of origin preserved only on nested anilist metadata, got %q", item.AniList.CountryOfOrigin)
-	}
-}
-
-func TestBuildMetadataPreviewWarnsForMixedSeasonPackGroupTags(t *testing.T) {
-	t.Parallel()
-
-	preview := buildMetadataPreview(api.PreparedMetadata{
-		SourcePath:     "Example.Show.S01.1080p.WEB-DL.x264-GRP",
-		ReleaseName:    "Example.Show.S01.1080p.WEB-DL.x264-GRP",
-		LookupWarnings: []string{"existing warning"},
-		TVPack:         true,
-		FileList: []string{
-			"Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv",
-			"Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv",
-		},
-	}, config.Config{})
-
-	if len(preview.Warnings) != 2 {
-		t.Fatalf("expected existing and mixed-group warnings, got %#v", preview.Warnings)
-	}
-	if preview.Warnings[0] != "existing warning" {
-		t.Fatalf("expected existing warning preserved first, got %#v", preview.Warnings)
-	}
-	if !strings.Contains(preview.Warnings[1], "mixed group tags (ALT, GRP)") {
-		t.Fatalf("expected mixed group warning, got %#v", preview.Warnings)
-	}
-}
diff --git a/internal/core/tracker_auth.go b/internal/core/tracker_auth.go
index 9c5e2227..bbbbc5ad 100644
--- a/internal/core/tracker_auth.go
+++ b/internal/core/tracker_auth.go
@@ -7,58 +7,26 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sort"
 	"strings"
 	"time"
 
 	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 // dupeSkipCodeTrackerAuthNotReady identifies auth-preflight skips for clients.
 const dupeSkipCodeTrackerAuthNotReady = "tracker_auth_not_ready"
 
-// checkGUIDupesWithAuth validates managed tracker auth before GUI and
-// embedded-web duplicate searches. Trackers needing user action are returned as
-// skipped results while ready and unmanaged trackers continue normally.
-func (c *Core) checkGUIDupesWithAuth(ctx context.Context, mode api.Mode, meta api.PreparedMetadata, trackerIDs []string) (api.DupeCheckSummary, error) {
-	if mode != api.ModeGUI {
-		summary, err := c.services.Dupes.Check(ctx, meta, trackerIDs)
-		if err != nil {
-			return api.DupeCheckSummary{}, fmt.Errorf("dupe service: %w", err)
-		}
-		return summary, nil
-	}
-
-	ready, blocked, err := c.preflightGUITrackerAuth(ctx, meta, trackerIDs)
-	if err != nil {
-		return api.DupeCheckSummary{}, err
-	}
-
-	summary := api.DupeCheckSummary{SourcePath: meta.SourcePath}
-	if len(ready) > 0 || len(blocked) == 0 {
-		summary, err = c.services.Dupes.Check(ctx, meta, ready)
-		if err != nil {
-			return api.DupeCheckSummary{}, fmt.Errorf("dupe service: %w", err)
-		}
-	}
-	summary.Results = append(summary.Results, blocked...)
-	sort.Slice(summary.Results, func(i, j int) bool {
-		return summary.Results[i].Tracker < summary.Results[j].Tracker
-	})
-	return summary, nil
-}
-
 // preflightGUITrackerAuth partitions trackers into auth-ready IDs and blocked
 // dupe results. Unmanaged trackers and trackers already destined for a rule
 // failure remain ready so the dupe service can produce their normal results.
-func (c *Core) preflightGUITrackerAuth(ctx context.Context, meta api.PreparedMetadata, trackerIDs []string) ([]string, []api.DupeCheckResult, error) {
-	if c.services.TrackerAuth == nil {
+func (m *dupeModule) preflightGUITrackerAuth(ctx context.Context, meta api.DuplicateSubject, trackerIDs []string) ([]string, []api.DupeCheckResult, error) {
+	if m.services.TrackerAuth == nil {
 		return nil, nil, errors.New("core: tracker auth service not configured")
 	}
 
-	capabilities, err := c.services.TrackerAuth.Capabilities(ctx)
+	capabilities, err := m.services.TrackerAuth.Capabilities(ctx)
 	if err != nil {
 		return nil, nil, fmt.Errorf("core: tracker auth capabilities: %w", err)
 	}
@@ -82,17 +50,13 @@ func (c *Core) preflightGUITrackerAuth(ctx context.Context, meta api.PreparedMet
 			readySet[name] = struct{}{}
 			continue
 		}
-		if !meta.IgnoreTrackerRuleFailures && len(ruleFailuresForTracker(meta.TrackerRuleFailures, name)) > 0 {
-			readySet[name] = struct{}{}
-			continue
-		}
 		managed = append(managed, name)
 	}
 	if len(managed) == 0 {
 		return orderedReadyTrackers(trackerIDs, readySet), nil, nil
 	}
 
-	c.logger.Infof("core: tracker auth preflight start trackers=%d", len(managed))
+	m.logger.Infof("core: tracker auth preflight start trackers=%d", len(managed))
 	for _, trackerID := range managed {
 		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
 			SourcePath: meta.SourcePath,
@@ -102,7 +66,7 @@ func (c *Core) preflightGUITrackerAuth(ctx context.Context, meta api.PreparedMet
 			Total:      len(trackerIDs),
 		})
 	}
-	statuses, err := c.services.TrackerAuth.ValidateMany(ctx, managed)
+	statuses, err := m.services.TrackerAuth.ValidateMany(ctx, managed)
 	if err != nil {
 		return nil, nil, fmt.Errorf("core: tracker auth validation: %w", err)
 	}
@@ -135,7 +99,7 @@ func (c *Core) preflightGUITrackerAuth(ctx context.Context, meta api.PreparedMet
 			CheckedAt:  time.Now().UTC(),
 		}
 		blocked = append(blocked, result)
-		c.logger.Warnf("core: tracker auth preflight blocked tracker=%s state=%s reason=%s", trackerID, redaction.RedactValue(status.State, nil), reason)
+		m.logger.Warnf("core: tracker auth preflight blocked tracker=%s state=%s reason=%s", trackerID, redaction.RedactValue(status.State, nil), reason)
 		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
 			SourcePath: meta.SourcePath,
 			Tracker:    trackerID,
@@ -146,7 +110,7 @@ func (c *Core) preflightGUITrackerAuth(ctx context.Context, meta api.PreparedMet
 		})
 	}
 	ready := orderedReadyTrackers(trackerIDs, readySet)
-	c.logger.Infof("core: tracker auth preflight complete ready=%d skipped=%d", len(ready), len(blocked))
+	m.logger.Infof("core: tracker auth preflight complete ready=%d skipped=%d", len(ready), len(blocked))
 	return ready, blocked, nil
 }
 
diff --git a/internal/core/tracker_auth_test.go b/internal/core/tracker_auth_test.go
index 0c8ded6b..189cab88 100644
--- a/internal/core/tracker_auth_test.go
+++ b/internal/core/tracker_auth_test.go
@@ -9,7 +9,8 @@ import (
 	"slices"
 	"testing"
 
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -32,7 +33,31 @@ type trackerAuthPreflightDupeService struct {
 	trackers []string
 }
 
-func (s *trackerAuthPreflightDupeService) Check(_ context.Context, meta api.PreparedMetadata, trackerIDs []string) (api.DupeCheckSummary, error) {
+func checkWithAuthForTest(
+	ctx context.Context,
+	module *dupeModule,
+	interaction api.InteractionMode,
+	subject api.DuplicateSubject,
+	trackerIDs []string,
+) (api.DupeCheckSummary, error) {
+	ready := trackerIDs
+	var blocked []api.DupeCheckResult
+	var err error
+	if interaction == api.InteractionModeInteractive {
+		ready, blocked, err = module.preflightGUITrackerAuth(ctx, subject, trackerIDs)
+		if err != nil {
+			return api.DupeCheckSummary{}, err
+		}
+	}
+	summary, _, err := checkDuplicateAssessment(ctx, module.services.Dupes, subject, ready, dupechecking.CheckOptions{})
+	if err != nil {
+		return summary, err
+	}
+	summary.Results = append(summary.Results, blocked...)
+	return summary, nil
+}
+
+func (s *trackerAuthPreflightDupeService) Check(_ context.Context, meta api.DuplicateSubject, trackerIDs []string) (api.DupeCheckSummary, error) {
 	s.trackers = append([]string(nil), trackerIDs...)
 	results := make([]api.DupeCheckResult, 0, len(trackerIDs))
 	for _, trackerID := range trackerIDs {
@@ -41,11 +66,25 @@ func (s *trackerAuthPreflightDupeService) Check(_ context.Context, meta api.Prep
 	return api.DupeCheckSummary{SourcePath: meta.SourcePath, Results: results}, nil
 }
 
+func (s *trackerAuthPreflightDupeService) CheckWithAssessment(
+	ctx context.Context,
+	meta api.DuplicateSubject,
+	trackerIDs []string,
+	_ dupechecking.CheckOptions,
+) (api.DupeCheckSummary, dupechecking.Assessment, error) {
+	summary, err := s.Check(ctx, meta, trackerIDs)
+	return summary, dupechecking.EmptyAssessment(), err
+}
+
 func TestCheckGUIDupesWithAuthSkipsBlockedTrackerAndContinuesReadyTrackers(t *testing.T) {
 	t.Parallel()
 
 	auth := &trackerAuthPreflightTestService{
-		capabilities: []api.TrackerAuthCapability{{TrackerID: "PTP", SupportsLogin: true, SupportsManual2FA: true}},
+		capabilities: []api.TrackerAuthCapability{{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		}},
 		statuses: []api.TrackerAuthStatus{{
 			TrackerID: "PTP",
 			State:     trackerauth.StateLoginRequired,
@@ -54,21 +93,21 @@ func TestCheckGUIDupesWithAuthSkipsBlockedTrackerAndContinuesReadyTrackers(t *te
 		}},
 	}
 	dupes := &trackerAuthPreflightDupeService{}
-	coreSvc := &Core{
+	coreSvc := newTestCore(testCoreOptions{
 		logger: api.NopLogger{},
 		services: api.ServiceSet{
 			Dupes:       dupes,
 			TrackerAuth: auth,
 		},
-	}
+	})
 	var progress []api.DupeProgressUpdate
 	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
 		progress = append(progress, update)
 	})
 
-	summary, err := coreSvc.checkGUIDupesWithAuth(ctx, api.ModeGUI, api.PreparedMetadata{SourcePath: "source.mkv"}, []string{"PTP", "AITHER"})
+	summary, err := checkWithAuthForTest(ctx, coreSvc.dupe, api.InteractionModeInteractive, api.DuplicateSubject{SourcePath: "source.mkv"}, []string{"PTP", "AITHER"})
 	if err != nil {
-		t.Fatalf("check GUI dupes with auth: %v", err)
+		t.Fatalf("check WebUI dupes with auth: %v", err)
 	}
 	if !slices.Equal(auth.validated, []string{"PTP"}) {
 		t.Fatalf("expected managed auth validation for PTP, got %v", auth.validated)
@@ -137,44 +176,81 @@ func TestCheckGUIDupesWithAuthPreservesReadyTrackerOrder(t *testing.T) {
 		statuses:     []api.TrackerAuthStatus{{TrackerID: "PTP", State: trackerauth.StateConfigured}},
 	}
 	dupes := &trackerAuthPreflightDupeService{}
-	coreSvc := &Core{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}}
+	coreSvc := newTestCore(testCoreOptions{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}})
 
-	_, err := coreSvc.checkGUIDupesWithAuth(context.Background(), api.ModeGUI, api.PreparedMetadata{SourcePath: "source.mkv"}, []string{"PTP", "AITHER"})
+	_, err := checkWithAuthForTest(context.Background(), coreSvc.dupe, api.InteractionModeInteractive, api.DuplicateSubject{SourcePath: "source.mkv"}, []string{"PTP", "AITHER"})
 	if err != nil {
-		t.Fatalf("check GUI dupes with auth: %v", err)
+		t.Fatalf("check WebUI dupes with auth: %v", err)
 	}
 	if !slices.Equal(dupes.trackers, []string{"PTP", "AITHER"}) {
 		t.Fatalf("expected input tracker order after auth preflight, got %v", dupes.trackers)
 	}
 }
 
-func TestCheckGUIDupesWithAuthAvoidsAuthForRuleFailedTracker(t *testing.T) {
+func TestCheckGUIDupesWithAuthStillValidatesRuleFailedTracker(t *testing.T) {
 	t.Parallel()
 
 	auth := &trackerAuthPreflightTestService{
 		capabilities: []api.TrackerAuthCapability{{TrackerID: "PTP", SupportsLogin: true}},
+		statuses:     []api.TrackerAuthStatus{{TrackerID: "PTP", State: trackerauth.StateConfigured}},
 	}
 	dupes := &trackerAuthPreflightDupeService{}
-	coreSvc := &Core{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}}
-	meta := api.PreparedMetadata{
+	coreSvc := newTestCore(testCoreOptions{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}})
+	meta := api.DuplicateSubject{
 		SourcePath: "source.mkv",
 		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"PTP": {{Rule: "example_rule", Reason: "example rule failed"}},
+			"PTP": {{
+				Rule:     "example_rule",
+				Reason:   "example rule failed",
+				Disposition: api.RuleDispositionWaivable,
+			}},
 		},
 	}
 
-	_, err := coreSvc.checkGUIDupesWithAuth(context.Background(), api.ModeGUI, meta, []string{"PTP"})
+	_, err := checkWithAuthForTest(context.Background(), coreSvc.dupe, api.InteractionModeInteractive, meta, []string{"PTP"})
 	if err != nil {
-		t.Fatalf("check GUI dupes with auth: %v", err)
+		t.Fatalf("check WebUI dupes with auth: %v", err)
 	}
-	if len(auth.validated) != 0 {
-		t.Fatalf("expected terminal rule failure to skip auth validation, got %v", auth.validated)
+	if !slices.Equal(auth.validated, []string{"PTP"}) {
+		t.Fatalf("expected rule diagnostics not to suppress auth validation, got %v", auth.validated)
 	}
 	if !slices.Equal(dupes.trackers, []string{"PTP"}) {
 		t.Fatalf("expected dupe service to retain rule-failed tracker for its skip result, got %v", dupes.trackers)
 	}
 }
 
+func TestCheckGUIDupesWithAuthStillValidatesWarningOnlyTracker(t *testing.T) {
+	t.Parallel()
+
+	auth := &trackerAuthPreflightTestService{
+		capabilities: []api.TrackerAuthCapability{{TrackerID: "PTP", SupportsLogin: true}},
+		statuses:     []api.TrackerAuthStatus{{TrackerID: "PTP", State: trackerauth.StateConfigured}},
+	}
+	dupes := &trackerAuthPreflightDupeService{}
+	coreSvc := newTestCore(testCoreOptions{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}})
+	meta := api.DuplicateSubject{
+		SourcePath: "Example.Release.2026.1080p-GRP.mkv",
+		TrackerRuleFailures: map[string][]api.RuleFailure{
+			"PTP": {{
+				Rule:     "example_advice",
+				Reason:   "example advisory",
+				Disposition: api.RuleDispositionAdvisory,
+			}},
+		},
+	}
+
+	_, err := checkWithAuthForTest(context.Background(), coreSvc.dupe, api.InteractionModeInteractive, meta, []string{"PTP"})
+	if err != nil {
+		t.Fatalf("check WebUI dupes with auth: %v", err)
+	}
+	if !slices.Equal(auth.validated, []string{"PTP"}) {
+		t.Fatalf("expected warning-only tracker to require managed auth validation, got %v", auth.validated)
+	}
+	if !slices.Equal(dupes.trackers, []string{"PTP"}) {
+		t.Fatalf("expected warning-only tracker to reach dupe search, got %v", dupes.trackers)
+	}
+}
+
 func TestCheckGUIDupesWithAuthLeavesCLIAuthOwnershipUnchanged(t *testing.T) {
 	t.Parallel()
 
@@ -182,9 +258,9 @@ func TestCheckGUIDupesWithAuthLeavesCLIAuthOwnershipUnchanged(t *testing.T) {
 		capabilities: []api.TrackerAuthCapability{{TrackerID: "PTP", SupportsLogin: true}},
 	}
 	dupes := &trackerAuthPreflightDupeService{}
-	coreSvc := &Core{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}}
+	coreSvc := newTestCore(testCoreOptions{logger: api.NopLogger{}, services: api.ServiceSet{Dupes: dupes, TrackerAuth: auth}})
 
-	_, err := coreSvc.checkGUIDupesWithAuth(context.Background(), api.ModeCLI, api.PreparedMetadata{SourcePath: "source.mkv"}, []string{"PTP"})
+	_, err := checkWithAuthForTest(context.Background(), coreSvc.dupe, api.InteractionModeUnattended, api.DuplicateSubject{SourcePath: "source.mkv"}, []string{"PTP"})
 	if err != nil {
 		t.Fatalf("check CLI dupes: %v", err)
 	}
diff --git a/internal/core/tracker_eligibility.go b/internal/core/tracker_eligibility.go
new file mode 100644
index 00000000..bca9a94c
--- /dev/null
+++ b/internal/core/tracker_eligibility.go
@@ -0,0 +1,143 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// buildTrackerEligibility is the only tracker eligibility decision mapper.
+// Callers provide current exact-generation assessments; presentation layers
+// consume the ordered projection without reconstructing policy.
+func buildTrackerEligibility(input api.TrackerEligibilityInput) (api.TrackerEligibility, error) {
+	selected := normalizeEligibilityTrackers(input.SelectedTrackers)
+	assessments := make(map[string]api.TrackerEligibilityAssessment, len(input.Assessments))
+	for _, assessment := range input.Assessments {
+		name := normalizeEligibilityTracker(assessment.Tracker)
+		if name != "" {
+			assessment.Tracker = name
+			assessments[name] = assessment
+		}
+	}
+	result := api.TrackerEligibility{
+		Release:  input.Release,
+		Trackers: make([]api.TrackerEligibilityState, 0, len(selected)),
+	}
+	for _, tracker := range selected {
+		assessment, found := assessments[tracker]
+		state := api.TrackerEligibilityState{Tracker: tracker}
+		if !found {
+			state.Reasons = append(state.Reasons, api.TrackerEligibilityReason{
+				Code:    api.TrackerEligibilityAssessmentFailed,
+				Message: "Tracker assessment is unavailable.",
+			})
+		} else {
+			var err error
+			state.Reasons, state.RuleDecisions, err = trackerEligibilityReasons(assessment)
+			if err != nil {
+				return api.TrackerEligibility{}, fmt.Errorf("core: tracker eligibility %s: %w", tracker, err)
+			}
+		}
+		state.Eligible = len(state.Reasons) == 0
+		result.Trackers = append(result.Trackers, state)
+		if state.Eligible {
+			result.EligibleTrackers = append(result.EligibleTrackers, tracker)
+		}
+	}
+	return result, nil
+}
+
+func trackerEligibilityReasons(assessment api.TrackerEligibilityAssessment) ([]api.TrackerEligibilityReason, []api.RuleDecision, error) {
+	reasons := make([]api.TrackerEligibilityReason, 0, 4)
+	appendReason := func(code api.TrackerEligibilityReasonCode, message string) {
+		for _, existing := range reasons {
+			if existing.Code == code {
+				return
+			}
+		}
+		reasons = append(reasons, api.TrackerEligibilityReason{Code: code, Message: message})
+	}
+	if assessment.AuthRequired || assessment.Duplicate.SkipCode == dupeSkipCodeTrackerAuthNotReady {
+		appendReason(api.TrackerEligibilityAuthRequired, "Tracker authentication is required.")
+	}
+	if assessment.Banned {
+		message := "Release group is banned by the tracker."
+		if value := strings.TrimSpace(assessment.BannedReason); value != "" {
+			message = value
+		}
+		appendReason(api.TrackerEligibilityBannedGroup, message)
+	}
+	if assessment.ContentFailure != nil {
+		failure := assessment.ContentFailure
+		if failure.Code == api.TrackerEligibilityScreenshotPreparationFailed ||
+			failure.Code == api.TrackerEligibilityDescriptionPreparationFailed {
+			message := strings.TrimSpace(failure.Message)
+			if message == "" {
+				message = "Required tracker upload content could not be prepared."
+			}
+			appendReason(failure.Code, message)
+		}
+	}
+	if len(assessment.PolicyBlocks) > 0 {
+		appendReason(api.TrackerEligibilityPolicy, "Tracker policy blocks this release.")
+	}
+	ruleAssessment, err := trackers.AssessRuleFailures(assessment.Tracker, assessment.RuleFailures, assessment.Choices.AuthorizedRuleFailures)
+	if err != nil {
+		return nil, nil, fmt.Errorf("assess %s tracker rules: %w", assessment.Tracker, err)
+	}
+	if !ruleAssessment.Eligible {
+		appendReason(api.TrackerEligibilityBlockingRule, "Blocking tracker rules must be resolved or explicitly authorized.")
+	}
+	duplicate := assessment.Duplicate
+	if duplicate.HasDupes && !assessment.Choices.IgnoreDuplicate {
+		appendReason(api.TrackerEligibilityDuplicate, "A blocking duplicate was found.")
+	}
+	status := strings.ToLower(strings.TrimSpace(duplicate.Status))
+	if status == "failed" || strings.TrimSpace(duplicate.Error) != "" {
+		appendReason(api.TrackerEligibilityAssessmentFailed, "Duplicate assessment failed.")
+	} else if duplicate.Skipped && duplicate.SkipCode != dupeSkipCodeTrackerAuthNotReady {
+		appendReason(api.TrackerEligibilityAssessmentSkipped, "Duplicate assessment was skipped.")
+	}
+	return reasons, ruleAssessment.Decisions, nil
+}
+
+func normalizeEligibilityTrackers(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		name := normalizeEligibilityTracker(value)
+		if name == "" {
+			continue
+		}
+		if _, ok := seen[name]; ok {
+			continue
+		}
+		seen[name] = struct{}{}
+		result = append(result, name)
+	}
+	return result
+}
+
+func normalizeEligibilityTracker(value string) string {
+	return strings.ToUpper(strings.TrimSpace(value))
+}
+
+func noEligibleTrackersError(operation api.OperationKind) error {
+	return api.NewOperationError(api.OperationFailure{
+		Code:      api.OperationFailureNoEligibleTrackers,
+		Operation: operation,
+		Message:   "No selected trackers are eligible.",
+		Recovery:  api.OperationRecoverySelectTrackers,
+	}, errNoEligibleTrackers)
+}
+
+var errNoEligibleTrackers = &trackerEligibilityError{}
+
+type trackerEligibilityError struct{}
+
+func (*trackerEligibilityError) Error() string { return "no eligible trackers" }
diff --git a/internal/core/tracker_eligibility_log.go b/internal/core/tracker_eligibility_log.go
new file mode 100644
index 00000000..3341b56e
--- /dev/null
+++ b/internal/core/tracker_eligibility_log.go
@@ -0,0 +1,101 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// logTrackerEligibility emits the canonical eligibility decision without
+// reconstructing reasons from tracker payload or presentation state.
+func logTrackerEligibility(
+	ctx context.Context,
+	fallback api.Logger,
+	operation string,
+	eligibility api.TrackerEligibility,
+) {
+	logger := logging.FromContext(ctx, fallback)
+	reasonCounts := make(map[api.TrackerEligibilityReasonCode]int)
+	blocked := 0
+	for _, tracker := range eligibility.Trackers {
+		if tracker.Eligible {
+			continue
+		}
+		blocked++
+		for _, reason := range tracker.Reasons {
+			reasonCounts[reason.Code]++
+		}
+	}
+	logger.Infof(
+		"core: tracker eligibility operation=%s selected=%d eligible=%d excluded=%d reasons=%s",
+		logging.SanitizeMessage(strings.TrimSpace(operation)),
+		len(eligibility.Trackers),
+		len(eligibility.EligibleTrackers),
+		blocked,
+		formatEligibilityReasonCounts(reasonCounts),
+	)
+	for _, tracker := range eligibility.Trackers {
+		if tracker.Eligible {
+			logger.Tracef(
+				"core: tracker eligibility operation=%s tracker=%s eligible=true",
+				logging.SanitizeMessage(strings.TrimSpace(operation)),
+				logging.SanitizeMessage(tracker.Tracker),
+			)
+			continue
+		}
+		codes := eligibilityReasonCodes(tracker.Reasons)
+		logger.Infof(
+			"core: tracker eligibility operation=%s tracker=%s included=false reasons=%s",
+			logging.SanitizeMessage(strings.TrimSpace(operation)),
+			logging.SanitizeMessage(tracker.Tracker),
+			strings.Join(codes, ","),
+		)
+		logger.Debugf(
+			"core: tracker eligibility operation=%s tracker=%s details=%s",
+			logging.SanitizeMessage(strings.TrimSpace(operation)),
+			logging.SanitizeMessage(tracker.Tracker),
+			eligibilityReasonDetails(tracker.Reasons),
+		)
+	}
+}
+
+func formatEligibilityReasonCounts(counts map[api.TrackerEligibilityReasonCode]int) string {
+	if len(counts) == 0 {
+		return "none"
+	}
+	codes := make([]string, 0, len(counts))
+	for code := range counts {
+		codes = append(codes, string(code))
+	}
+	slices.Sort(codes)
+	parts := make([]string, 0, len(codes))
+	for _, code := range codes {
+		parts = append(parts, fmt.Sprintf("%s:%d", code, counts[api.TrackerEligibilityReasonCode(code)]))
+	}
+	return strings.Join(parts, ",")
+}
+
+func eligibilityReasonCodes(reasons []api.TrackerEligibilityReason) []string {
+	codes := make([]string, 0, len(reasons))
+	for _, reason := range reasons {
+		codes = append(codes, string(reason.Code))
+	}
+	slices.Sort(codes)
+	return codes
+}
+
+func eligibilityReasonDetails(reasons []api.TrackerEligibilityReason) string {
+	details := make([]string, 0, len(reasons))
+	for _, reason := range reasons {
+		details = append(details, string(reason.Code)+":"+logging.SanitizeMessage(reason.Message))
+	}
+	slices.Sort(details)
+	return strings.Join(details, ",")
+}
diff --git a/internal/core/tracker_eligibility_test.go b/internal/core/tracker_eligibility_test.go
new file mode 100644
index 00000000..85de0171
--- /dev/null
+++ b/internal/core/tracker_eligibility_test.go
@@ -0,0 +1,382 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildTrackerEligibilityCanonicalOrderingAndReasons(t *testing.T) {
+	t.Parallel()
+
+	ref := api.ReleaseRef{SourcePath: "C:\\media\\Example.Release.2026.mkv", Generation: 7}
+	actual, err := buildTrackerEligibility(api.TrackerEligibilityInput{
+		Release:          ref,
+		SelectedTrackers: []string{" mtv ", "AITHER", "mtv", "BLU", "WARN", "AUTH"},
+		Assessments: []api.TrackerEligibilityAssessment{
+			{Tracker: "MTV", Duplicate: api.DupeCheckResult{Tracker: "MTV", HasDupes: true}},
+			{
+				Tracker:      "AITHER",
+				RuleFailures: []api.RuleFailure{{Rule: "source", Disposition: api.RuleDispositionWaivable}},
+			},
+			{Tracker: "BLU", Duplicate: api.DupeCheckResult{Tracker: "BLU", Status: "completed"}},
+			{
+				Tracker:      "WARN",
+				RuleFailures: []api.RuleFailure{{Rule: "advice", Disposition: api.RuleDispositionAdvisory}},
+			},
+			{Tracker: "AUTH", AuthRequired: true},
+		},
+	})
+	if err != nil {
+		t.Fatalf("build eligibility: %v", err)
+	}
+	if actual.Release != ref {
+		t.Fatalf("release = %#v", actual.Release)
+	}
+	if got, want := actual.EligibleTrackers, []string{"BLU", "WARN"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("eligible = %v, want %v", got, want)
+	}
+	wantCodes := []api.TrackerEligibilityReasonCode{
+		api.TrackerEligibilityDuplicate,
+		api.TrackerEligibilityBlockingRule,
+	}
+	for index, code := range wantCodes {
+		if got := actual.Trackers[index].Reasons[0].Code; got != code {
+			t.Fatalf("tracker[%d] reason = %q, want %q", index, got, code)
+		}
+	}
+	if got := actual.Trackers[4].Reasons[0].Code; got != api.TrackerEligibilityAuthRequired {
+		t.Fatalf("auth reason = %q", got)
+	}
+}
+
+func TestBuildTrackerEligibilityExplicitEmptyStaysEmpty(t *testing.T) {
+	t.Parallel()
+
+	actual, err := buildTrackerEligibility(api.TrackerEligibilityInput{
+		Release:          api.ReleaseRef{SourcePath: "C:\\media\\Example.mkv", Generation: 1},
+		SelectedTrackers: []string{},
+		Assessments: []api.TrackerEligibilityAssessment{
+			{Tracker: "MTV", Duplicate: api.DupeCheckResult{Status: "completed"}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("build eligibility: %v", err)
+	}
+	if len(actual.Trackers) != 0 || len(actual.EligibleTrackers) != 0 {
+		t.Fatalf("explicit empty eligibility = %#v", actual)
+	}
+}
+
+func TestBuildTrackerEligibilityUsesOnlyStructuredContentFailure(t *testing.T) {
+	t.Parallel()
+
+	actual, err := buildTrackerEligibility(api.TrackerEligibilityInput{
+		SelectedTrackers: []string{"ANT", "AITHER"},
+		Assessments: []api.TrackerEligibilityAssessment{
+			{Tracker: "ANT", Duplicate: api.DupeCheckResult{Status: "completed"}},
+			{
+				Tracker:   "AITHER",
+				Duplicate: api.DupeCheckResult{Status: "completed"},
+				ContentFailure: &api.TrackerContentFailure{
+					Tracker: "AITHER",
+					Code:    api.TrackerEligibilityDescriptionPreparationFailed,
+					Message: "description object failed",
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("build eligibility: %v", err)
+	}
+	if !actual.Trackers[0].Eligible {
+		t.Fatalf("ready-empty tracker should remain eligible: %#v", actual.Trackers[0])
+	}
+	if got := actual.Trackers[1].Reasons; len(got) != 1 || got[0].Code != api.TrackerEligibilityDescriptionPreparationFailed {
+		t.Fatalf("structured content failure reasons = %#v", got)
+	}
+}
+
+func TestBuildTrackerEligibilityAppliesExactRuleAuthorization(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name        string
+		failures    []api.RuleFailure
+		authorized  []string
+		duplicate   bool
+		ignoreDupe  bool
+		wantEligible bool
+		wantErr     bool
+	}{
+		{
+			name: "waivable requires exact authorization",
+			failures: []api.RuleFailure{{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+		},
+		{
+			name: "waivable exact authorization",
+			failures: []api.RuleFailure{{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+			authorized: []string{"container"},
+			wantEligible: true,
+		},
+		{
+			name: "strict remains blocked with waivable authorization",
+			failures: []api.RuleFailure{
+				{Rule: "container", Disposition: api.RuleDispositionWaivable},
+				{Rule: "resolution", Disposition: api.RuleDispositionStrict},
+			},
+			authorized: []string{"container"},
+		},
+		{
+			name: "new rule is not covered by prior authorization",
+			failures: []api.RuleFailure{
+				{Rule: "container", Disposition: api.RuleDispositionWaivable},
+				{Rule: "language", Disposition: api.RuleDispositionWaivable},
+			},
+			authorized: []string{"container"},
+		},
+		{
+			name: "unknown authorization rejected",
+			failures: []api.RuleFailure{{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+			authorized: []string{"language"},
+			wantErr: true,
+		},
+		{
+			name: "duplicate and rule authorization independent",
+			failures: []api.RuleFailure{{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+			authorized: []string{"container"},
+			duplicate: true,
+		},
+		{
+			name: "duplicate ignore plus rule authorization",
+			failures: []api.RuleFailure{{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+			authorized: []string{"container"},
+			duplicate: true,
+			ignoreDupe: true,
+			wantEligible: true,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			eligibility, err := buildTrackerEligibility(api.TrackerEligibilityInput{
+				SelectedTrackers: []string{"EXAMPLE"},
+				Assessments: []api.TrackerEligibilityAssessment{{
+					Tracker:      "EXAMPLE",
+					RuleFailures: test.failures,
+					Duplicate:    api.DupeCheckResult{
+Tracker: "EXAMPLE",
+ Status: "completed",
+ HasDupes: test.duplicate,
+},
+					Choices: api.TrackerReviewChoices{
+						IgnoreDuplicate:        test.ignoreDupe,
+						AuthorizedRuleFailures: test.authorized,
+					},
+				}},
+			})
+			if (err != nil) != test.wantErr {
+				t.Fatalf("error=%v, wantErr=%t", err, test.wantErr)
+			}
+			if test.wantErr {
+				return
+			}
+			if len(eligibility.Trackers) != 1 || eligibility.Trackers[0].Eligible != test.wantEligible {
+				t.Fatalf("eligibility = %#v", eligibility)
+			}
+			if len(test.failures) > 0 && len(eligibility.Trackers[0].RuleDecisions) != len(test.failures) {
+				t.Fatalf("rule evidence was dropped: %#v", eligibility.Trackers[0].RuleDecisions)
+			}
+		})
+	}
+}
+
+func TestLogTrackerEligibilityUsesCanonicalReasonsAndContextLogger(t *testing.T) {
+	t.Parallel()
+
+	fallback := &eligibilityCaptureLogger{}
+	scoped := &eligibilityCaptureLogger{}
+	ctx := logging.WithOperationLogger(context.Background(), scoped)
+	localPath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+	eligibility := api.TrackerEligibility{
+		Trackers: []api.TrackerEligibilityState{
+			{
+				Tracker: "ANT",
+				Reasons: []api.TrackerEligibilityReason{
+					{Code: api.TrackerEligibilityDuplicate, Message: "A blocking duplicate was found."},
+					{Code: api.TrackerEligibilityAuthRequired, Message: "Tracker authentication is required."},
+				},
+			},
+			{
+				Tracker: "AITHER",
+				Reasons: []api.TrackerEligibilityReason{{
+					Code:    api.TrackerEligibilityDescriptionPreparationFailed,
+					Message: "api_key=secret-value source=" + localPath,
+				}},
+			},
+			{Tracker: "BTN", Eligible: true},
+		},
+		EligibleTrackers: []string{"BTN"},
+	}
+
+	logTrackerEligibility(ctx, fallback, "dry_run", eligibility)
+	if fallback.count() != 0 {
+		t.Fatalf("fallback logger received operation lines: %#v", fallback.all())
+	}
+	info := scoped.level("info")
+	if len(info) != 3 {
+		t.Fatalf("info lines = %#v", info)
+	}
+	wantCounts := "reasons=auth_required:1,description_preparation_failed:1,duplicate:1"
+	if !strings.Contains(info[0], wantCounts) {
+		t.Fatalf("summary = %q, want %q", info[0], wantCounts)
+	}
+	if !strings.Contains(info[1], "tracker=ANT") || !strings.Contains(info[1], "reasons=auth_required,duplicate") {
+		t.Fatalf("ANT blocker line = %q", info[1])
+	}
+	debug := strings.Join(scoped.level("debug"), "\n")
+	if strings.Contains(debug, "secret-value") || strings.Contains(debug, localPath) {
+		t.Fatalf("debug details were not sanitized: %q", debug)
+	}
+	trace := scoped.level("trace")
+	if len(trace) != 1 || !strings.Contains(trace[0], "tracker=BTN eligible=true") {
+		t.Fatalf("eligible trace = %#v", trace)
+	}
+}
+
+func TestPersistTrackerRuleDecisionsStoresAuthorizationAndClearsResolvedTrackers(t *testing.T) {
+	t.Parallel()
+
+	repo := &recordingRuleDecisionRepo{}
+	err := persistTrackerRuleDecisions(context.Background(), repo, `C:\media\Example.Release.2026.mkv`, api.TrackerEligibility{
+		Trackers: []api.TrackerEligibilityState{
+			{
+				Tracker: "HDS",
+				RuleDecisions: []api.RuleDecision{
+					{
+Rule: "min_resolution",
+ Reason: "requires 720p",
+ Disposition: api.RuleDispositionStrict,
+},
+					{
+Rule: "imdb_required",
+ Reason: "requires IMDb",
+ Disposition: api.RuleDispositionWaivable,
+ Authorized: true,
+},
+				},
+			},
+			{Tracker: "BLU"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("persist rule decisions: %v", err)
+	}
+	if len(repo.calls) != 2 {
+		t.Fatalf("save calls = %#v", repo.calls)
+	}
+	if repo.calls[1].tracker != "BLU" || len(repo.calls[1].failures) != 0 {
+		t.Fatalf("resolved tracker was not cleared: %#v", repo.calls[1])
+	}
+	stored := repo.calls[0].failures
+	if len(stored) != 2 || stored[0].Disposition != api.RuleDispositionStrict || stored[0].Authorized {
+		t.Fatalf("strict decision = %#v", stored)
+	}
+	if stored[1].Disposition != api.RuleDispositionWaivable || !stored[1].Authorized {
+		t.Fatalf("authorized decision = %#v", stored[1])
+	}
+}
+
+type ruleDecisionSaveCall struct {
+	path     string
+	tracker  string
+	failures []api.TrackerRuleFailure
+}
+
+type recordingRuleDecisionRepo struct {
+	api.TrackerStateRepository
+	calls []ruleDecisionSaveCall
+}
+
+func (r *recordingRuleDecisionRepo) SaveTrackerRuleFailures(
+	_ context.Context,
+	path string,
+	tracker string,
+	failures []api.TrackerRuleFailure,
+) error {
+	r.calls = append(r.calls, ruleDecisionSaveCall{
+		path:     path,
+		tracker:  tracker,
+		failures: append([]api.TrackerRuleFailure(nil), failures...),
+	})
+	return nil
+}
+
+type eligibilityLogEntry struct {
+	level   string
+	message string
+}
+
+type eligibilityCaptureLogger struct {
+	mu      sync.Mutex
+	entries []eligibilityLogEntry
+}
+
+func (l *eligibilityCaptureLogger) record(level string, format string, args ...any) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.entries = append(l.entries, eligibilityLogEntry{level: level, message: fmt.Sprintf(format, args...)})
+}
+
+func (l *eligibilityCaptureLogger) Tracef(format string, args ...any) {
+	l.record("trace", format, args...)
+}
+
+func (l *eligibilityCaptureLogger) Debugf(format string, args ...any) {
+	l.record("debug", format, args...)
+}
+
+func (l *eligibilityCaptureLogger) Infof(format string, args ...any) {
+	l.record("info", format, args...)
+}
+
+func (l *eligibilityCaptureLogger) Warnf(format string, args ...any) {
+	l.record("warn", format, args...)
+}
+
+func (l *eligibilityCaptureLogger) Errorf(format string, args ...any) {
+	l.record("error", format, args...)
+}
+
+func (l *eligibilityCaptureLogger) count() int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return len(l.entries)
+}
+
+func (l *eligibilityCaptureLogger) all() []eligibilityLogEntry {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return append([]eligibilityLogEntry(nil), l.entries...)
+}
+
+func (l *eligibilityCaptureLogger) level(level string) []string {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	entries := make([]string, 0)
+	for _, entry := range l.entries {
+		if entry.level == level {
+			entries = append(entries, entry.message)
+		}
+	}
+	return entries
+}
diff --git a/internal/core/upload.go b/internal/core/upload.go
new file mode 100644
index 00000000..8bd63f29
--- /dev/null
+++ b/internal/core/upload.go
@@ -0,0 +1,681 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// uploadModule owns synchronous upload review and execution policy. It borrows
+// prepared-release state and runtime services; Core retains resource lifetime.
+type uploadModule struct {
+	cfg           config.Config
+	logger        api.Logger
+	policy        uploadPolicyEvaluator
+	trackers      api.TrackerService
+	torrents      api.TorrentService
+	clients       api.ClientService
+	filesystem    api.FilesystemService
+	dupes         api.DupeService
+	repo          api.ReleaseStateRepository
+	trackerRepo   api.TrackerStateRepository
+	registry      *trackers.Registry
+	preparedFacts *preparedrelease.Module
+
+	resolveDescriptionOverride func(context.Context, api.Request) (api.Request, error)
+	resolveSubjectGroups       func(context.Context, api.UploadSubject, api.UploadReviewInput) ([]api.DescriptionBuilderGroup, error)
+	importAcceptedMenuImages   func(context.Context, api.MediaPlanInput, []string) error
+}
+
+type uploadPolicyEvaluator interface {
+	EvaluateUploadPolicy(context.Context, api.UploadSubject, []string) (api.UploadReviewOutcome, error)
+}
+
+// newUploadModule composes upload review and execution around exact prepared
+// generations and borrowed runtime services.
+func newUploadModule(
+	cfg config.Config,
+	logger api.Logger,
+	services api.ServiceSet,
+	repo api.ReleaseStateRepository,
+	trackerRepo api.TrackerStateRepository,
+	registry *trackers.Registry,
+	preparedFacts *preparedrelease.Module,
+	resolveDescriptionOverride func(context.Context, api.Request) (api.Request, error),
+	resolveSubjectGroups func(context.Context, api.UploadSubject, api.UploadReviewInput) ([]api.DescriptionBuilderGroup, error),
+	importAcceptedMenuImages func(context.Context, api.MediaPlanInput, []string) error,
+) *uploadModule {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &uploadModule{
+		cfg:                        cfg,
+		logger:                     logger,
+		policy:                     uploadPolicyEvaluatorFrom(services.Metadata),
+		trackers:                   services.Trackers,
+		torrents:                   services.Torrents,
+		clients:                    services.Clients,
+		filesystem:                 services.Filesystem,
+		dupes:                      services.Dupes,
+		repo:                       repo,
+		trackerRepo:                trackerRepo,
+		registry:                   registry,
+		preparedFacts:              preparedFacts,
+		resolveDescriptionOverride: resolveDescriptionOverride,
+		resolveSubjectGroups:       resolveSubjectGroups,
+		importAcceptedMenuImages:   importAcceptedMenuImages,
+	}
+}
+
+func uploadPolicyEvaluatorFrom(value any) uploadPolicyEvaluator {
+	evaluator, _ := value.(uploadPolicyEvaluator)
+	return evaluator
+}
+
+func (m *uploadModule) runPrepared(ctx context.Context, req api.Request) (api.Result, error) {
+	req = normalizeExecutionRequest(req)
+	resolvedReq, err := m.resolveDescriptionOverride(ctx, req)
+	if err != nil {
+		return api.Result{}, err
+	}
+	return m.runCanonicalRequest(ctx, resolvedReq)
+}
+
+func (m *uploadModule) runCanonicalRequest(ctx context.Context, req api.Request) (api.Result, error) {
+	req = m.expandEntrypointTrackerDefaults(req)
+	if m.filesystem == nil {
+		return api.Result{}, errors.New("core: filesystem service not configured")
+	}
+	normalizedPaths, err := m.filesystem.ValidatePaths(ctx, []string{req.SourcePath})
+	if err != nil {
+		return api.Result{}, fmt.Errorf("core: %w", err)
+	}
+	if len(normalizedPaths) != 1 {
+		return api.Result{}, internalerrors.ErrInvalidInput
+	}
+	req.SourcePath = normalizedPaths[0]
+	prepareInput, err := api.MapPreparationRequest(req, api.PreparationIntentUpload)
+	if err != nil {
+		return api.Result{}, fmt.Errorf("core: map upload preparation request: %w", err)
+	}
+	prepared, err := m.preparedFacts.Prepare(ctx, prepareInput)
+	if err != nil {
+		return api.Result{}, fmt.Errorf("core: prepare upload release: %w", err)
+	}
+	reviewInput := uploadReviewInputFromRequest(req, api.ReleaseRef{
+		SourcePath: prepared.Release.Source.SourcePath,
+		Generation: prepared.Release.Generation,
+	})
+	reviewed, err := m.reviewAccepted(ctx, reviewInput)
+	if err != nil {
+		return api.Result{}, err
+	}
+	return m.runCanonicalAccepted(ctx, api.UploadExecutionPlan{Input: reviewInput, Outcome: reviewed.Outcome})
+}
+
+// expandEntrypointTrackerDefaults keeps default expansion at high-level
+// CLI/Core entrypoints. Exact accepted operations preserve explicit empty.
+func (m *uploadModule) expandEntrypointTrackerDefaults(req api.Request) api.Request {
+	if len(req.Trackers) != 0 {
+		return req
+	}
+	req.Trackers = trackers.ResolveTrackersWithRegistry(m.cfg, nil, req.TrackersRemove, m.logger, m.registry)
+	return req
+}
+
+func (m *uploadModule) runAccepted(ctx context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	result, err := m.runCanonicalAccepted(ctx, plan)
+	return result, classifyOperationError(api.OperationKindUploadExecute, err)
+}
+
+func cloneOperationQuestionnaireAnswers(input map[string]map[string]string) map[string]map[string]string {
+	if input == nil {
+		return nil
+	}
+	result := make(map[string]map[string]string, len(input))
+	for tracker, answers := range input {
+		cloned := make(map[string]string, len(answers))
+		maps.Copy(cloned, answers)
+		result[tracker] = cloned
+	}
+	return result
+}
+
+func (m *uploadModule) runCanonicalAccepted(ctx context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	subject, err := m.preparedFacts.ResolveUploadSubject(ctx, plan.Input)
+	if err != nil {
+		return api.Result{}, fmt.Errorf("core: resolve upload subject: %w", err)
+	}
+	resolvedTrackers := intersectReviewedTrackers(plan.Input.Trackers, plan.Outcome.Eligibility.EligibleTrackers)
+	if len(resolvedTrackers) == 0 {
+		m.logger.Debugf("core: reviewed upload resolved no trackers source=%s", subject.SourcePath)
+		return api.Result{}, noEligibleTrackersError(api.OperationKindUploadExecute)
+	}
+	subject.Trackers = resolvedTrackers
+	subject.MatchedTrackers = filterReviewedNames(plan.Outcome.MatchedTrackers, resolvedTrackers)
+	subject.TrackersRemove = append([]string(nil), subject.MatchedTrackers...)
+	subject.BlockedTrackers = filterReviewedBlocks(plan.Outcome.BlockedTrackers, resolvedTrackers)
+	subject.TrackerRuleFailures = filterReviewedRuleFailures(plan.Outcome.TrackerRuleFailures, resolvedTrackers)
+	subject.CrossSeedTorrents = filterReviewedTorrents(plan.Outcome.CrossSeedTorrents, resolvedTrackers)
+	if err := m.hydrateCanonicalTrackerState(ctx, &subject); err != nil {
+		return api.Result{}, err
+	}
+
+	req := uploadRequestFromPlan(plan, resolvedTrackers)
+	if len(req.ScreenshotOverrides.MenuPaths) > 0 {
+		if m.importAcceptedMenuImages == nil {
+			return api.Result{}, errors.New("core: accepted menu-image importer not configured")
+		}
+		if err := m.importAcceptedMenuImages(ctx, api.MediaPlanInput{Release: plan.Input.Release}, req.ScreenshotOverrides.MenuPaths); err != nil {
+			return api.Result{}, fmt.Errorf("core: import menu images failed: %w", err)
+		}
+	}
+	uploaded, err := m.executeAcceptedUpload(ctx, req, subject, plan.Input)
+	return api.Result{UploadedCount: uploaded}, err
+}
+
+// executeAcceptedUpload consumes only the exact reviewed subject and workflow
+// input. Mutable preparation state is neither reconstructed nor consulted.
+func (m *uploadModule) executeAcceptedUpload(
+	ctx context.Context,
+	req api.Request,
+	subject api.UploadSubject,
+	input api.UploadReviewInput,
+) (int, error) {
+	if m.resolveSubjectGroups == nil {
+		return 0, errors.New("core: subject description resolver not configured")
+	}
+	descriptionGroups, err := m.resolveSubjectGroups(ctx, subject, input)
+	if err != nil {
+		return 0, err
+	}
+	subject.DescriptionGroups = descriptionGroups
+
+	emitPreparedUploadProgress(ctx, req, subject.SourcePath, "", "torrent", "running", "Preparing torrent")
+	torrent, err := m.torrents.Create(ctx, torrentSubjectFromUpload(subject, input))
+	if err != nil {
+		return 0, fmt.Errorf("core: %w", err)
+	}
+	subject.TorrentPath = torrent.Path
+	if m.repo != nil && torrent.InfoHash != "" {
+		if err := ctx.Err(); err != nil {
+			return 0, fmt.Errorf("context canceled: %w", err)
+		}
+		if err := m.persistPreparedInfoHash(ctx, subject.SourcePath, torrent.InfoHash); err != nil {
+			return 0, fmt.Errorf("metadata: persist info hash: %w", err)
+		}
+	}
+
+	emitPreparedUploadProgress(ctx, req, subject.SourcePath, "", "tracker_upload", "running", "Uploading to tracker")
+	summary, uploadErr := m.trackers.Upload(ctx, subject)
+	if summary.Uploaded < 0 {
+		return 0, fmt.Errorf("upload summary invalid: %d", summary.Uploaded)
+	}
+	if uploadErr != nil && summary.Uploaded == 0 {
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, "", "tracker_upload", "failed", "Tracker upload failed")
+		return 0, fmt.Errorf("core: %w", uploadErr)
+	}
+
+	if !input.Options.NoSeed {
+		if err := m.injectReviewedCrossSeeds(ctx, req, subject, input); err != nil {
+			if uploadErr != nil {
+				return summary.Uploaded, fmt.Errorf("core: cross-seed injection failed after tracker-local upload failures: %w", err)
+			}
+			return summary.Uploaded, err
+		}
+	}
+	if uploadErr != nil {
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, "", "tracker_upload", "failed", "Tracker upload failed")
+		return summary.Uploaded, fmt.Errorf("core: %w", uploadErr)
+	}
+	emitPreparedUploadProgress(ctx, req, subject.SourcePath, "", "tracker_upload", "completed", "Tracker upload complete")
+
+	if !input.Options.NoSeed {
+		if len(summary.UploadedTorrents) == 0 {
+			m.logger.Warnf("core: no tracker torrent artifacts available for injection for %s", subject.SourcePath)
+		}
+		for _, uploaded := range summary.UploadedTorrents {
+			torrentPath := strings.TrimSpace(uploaded.TorrentPath)
+			torrentURL := strings.TrimSpace(uploaded.DownloadURL)
+			if torrentPath == "" && torrentURL == "" {
+				continue
+			}
+			emitPreparedUploadProgress(ctx, req, subject.SourcePath, uploaded.Tracker, "client_injection", "running", "Injecting torrent into client")
+			if err := m.clients.Inject(ctx, clientSubjectFromUpload(subject, input), api.TorrentResult{
+				Path:    torrentPath,
+				URL:     torrentURL,
+				Tracker: uploaded.Tracker,
+			}); err != nil {
+				emitPreparedUploadProgress(ctx, req, subject.SourcePath, uploaded.Tracker, "client_injection", "failed", "Client injection failed")
+				return summary.Uploaded, fmt.Errorf("core: %w", err)
+			}
+			emitPreparedUploadProgress(ctx, req, subject.SourcePath, uploaded.Tracker, "client_injection", "completed", "Client injection complete")
+		}
+	}
+	return summary.Uploaded, nil
+}
+
+func torrentSubjectFromUpload(subject api.UploadSubject, input api.UploadReviewInput) api.TorrentSubject {
+	return api.TorrentSubject{
+		SourcePath:        subject.SourcePath,
+		SourceSize:        subject.SourceSize,
+		FileList:          append([]string(nil), subject.FileList...),
+		DiscType:          subject.DiscType,
+		ClientTorrentPath: subject.ClientTorrentPath,
+		Trackers:          append([]string(nil), subject.Trackers...),
+		TorrentOverrides:  input.TorrentOverrides,
+	}
+}
+
+func clientSubjectFromUpload(subject api.UploadSubject, input api.UploadReviewInput) api.ClientSubject {
+	return api.ClientSubject{
+		SourcePath:      subject.SourcePath,
+		FileList:        append([]string(nil), subject.FileList...),
+		DiscType:        subject.DiscType,
+		ClientOverrides: input.ClientOverrides,
+	}
+}
+
+func (m *uploadModule) injectReviewedCrossSeeds(
+	ctx context.Context,
+	req api.Request,
+	subject api.UploadSubject,
+	input api.UploadReviewInput,
+) error {
+	if !m.cfg.PostUpload.CrossSeeding || len(subject.CrossSeedTorrents) == 0 {
+		return nil
+	}
+	if m.clients == nil {
+		return errors.New("core: client service not configured")
+	}
+	for _, crossSeed := range subject.CrossSeedTorrents {
+		torrentPath := strings.TrimSpace(crossSeed.TorrentPath)
+		torrentURL := strings.TrimSpace(crossSeed.DownloadURL)
+		if torrentPath == "" && torrentURL == "" {
+			continue
+		}
+		tracker := strings.ToUpper(strings.TrimSpace(crossSeed.Tracker))
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, tracker, "client_injection", "running", "Injecting cross-seed torrent into client")
+		if err := m.clients.Inject(ctx, clientSubjectFromUpload(subject, input), api.TorrentResult{
+			Path:      torrentPath,
+			URL:       torrentURL,
+			Tracker:   tracker,
+			CrossSeed: true,
+		}); err != nil {
+			emitPreparedUploadProgress(ctx, req, subject.SourcePath, tracker, "client_injection", "failed", "Cross-seed client injection failed")
+			return fmt.Errorf("core: %w", err)
+		}
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, tracker, "client_injection", "completed", "Cross-seed client injection complete")
+	}
+	return nil
+}
+
+func (m *uploadModule) injectTrackerDryRunSubjects(
+	ctx context.Context,
+	req api.Request,
+	subject api.UploadSubject,
+	input api.UploadReviewInput,
+	entries []api.TrackerDryRunEntry,
+	fallback api.TorrentResult,
+) (int, error) {
+	logger := logging.FromContext(ctx, m.logger)
+	ready := make([]api.TrackerDryRunEntry, 0, len(entries))
+	for _, entry := range entries {
+		trackerName := strings.ToUpper(strings.TrimSpace(entry.Tracker))
+		if strings.EqualFold(strings.TrimSpace(entry.Status), "ready") {
+			ready = append(ready, entry)
+		} else {
+			logger.Debugf("core: tracker dry-run injection skipped tracker=%s status=%s reason=payload_not_ready", trackerName, entry.Status)
+		}
+	}
+	if len(ready) > 0 && m.clients == nil {
+		return 0, errors.New("core: client service not configured")
+	}
+	injected := 0
+	for _, entry := range ready {
+		trackerName := strings.ToUpper(strings.TrimSpace(entry.Tracker))
+		injectSubject := subject
+		injectSubject.Trackers = []string{trackerName}
+		injectSubject.TorrentPath = trackerDryRunTorrentPath(entry)
+		trackerCfg := config.TrackerConfig{}
+		for name, cfg := range m.cfg.Trackers.Trackers {
+			if strings.EqualFold(strings.TrimSpace(name), trackerName) {
+				trackerCfg = cfg
+				break
+			}
+		}
+		prepared, err := trackers.PrepareDryRunInjectionTorrentWithRegistry(injectSubject, m.cfg.MainSettings.DBPath, trackerName, trackerCfg, m.registry)
+		if err != nil {
+			return 0, fmt.Errorf("core: tracker dry-run injection torrent artifact tracker=%s: %w", trackerName, err)
+		}
+		injectTorrent := api.TorrentResult{
+			Path:     strings.TrimSpace(prepared.TorrentPath),
+			InfoHash: fallback.InfoHash,
+			Tracker:  trackerName,
+		}
+		if injectTorrent.Path == "" {
+			injectTorrent.Path = strings.TrimSpace(fallback.Path)
+		}
+		if injectTorrent.Path == "" {
+			continue
+		}
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, trackerName, "client_injection", "running", "Injecting torrent into client")
+		if err := m.clients.Inject(ctx, clientSubjectFromUpload(injectSubject, input), injectTorrent); err != nil {
+			emitPreparedUploadProgress(ctx, req, subject.SourcePath, trackerName, "client_injection", "failed", "Client injection failed")
+			return 0, fmt.Errorf("core: %w", err)
+		}
+		injected++
+		emitPreparedUploadProgress(ctx, req, subject.SourcePath, trackerName, "client_injection", "completed", "Client injection complete")
+	}
+	return injected, nil
+}
+
+func (m *uploadModule) runAcceptedTrackerDryRun(ctx context.Context, plan api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	if m.preparedFacts == nil {
+		return api.TrackerDryRunPreview{}, errors.New("core: canonical preparation is not configured")
+	}
+	input := plan.Input
+	logger := logging.FromContext(ctx, m.logger)
+	reviewInput := trackerDryRunReviewInput(input)
+	req := uploadRequestFromPlan(api.UploadExecutionPlan{Input: reviewInput}, normalizeReviewedTrackers(input.Trackers))
+	sourcePath := strings.TrimSpace(input.Release.SourcePath)
+	logger.Infof("core: tracker dry-run started source=%s trackers=%d", sourcePath, len(req.Trackers))
+	emitPreparedUploadProgress(ctx, req, sourcePath, "", "dry_run", "running", "Building tracker dry run")
+	evidence, err := m.acceptedDryRunEvidence(ctx, plan)
+	if err != nil {
+		emitPreparedUploadProgress(ctx, req, sourcePath, "", "dry_run", "failed", "Tracker dry run failed")
+		return api.TrackerDryRunPreview{}, err
+	}
+	preview, err := m.buildTrackerPayloadPreview(ctx, reviewInput, trackers.PreparationIntentDryRun, evidence)
+	if err != nil {
+		emitPreparedUploadProgress(ctx, req, sourcePath, "", "dry_run", "failed", "Tracker dry run failed")
+		return api.TrackerDryRunPreview{}, err
+	}
+	entries := trackerDryRunEntriesFromAssessment(preview.review)
+	for _, entry := range entries {
+		logger.Tracef(
+			"core: operation=dry_run tracker=%s payload=%s live_eligible=%t rule_failures=%d dupes=%t",
+			strings.ToUpper(strings.TrimSpace(entry.Tracker)),
+			strings.TrimSpace(entry.Status),
+			len(entry.Diagnostics.LiveEligibilityReasons) == 0,
+			len(entry.Diagnostics.RuleDecisions),
+			entry.Diagnostics.Duplicate.HasDupes,
+		)
+	}
+	req = uploadRequestFromPlan(api.UploadExecutionPlan{Input: reviewInput}, preview.outcome.ResolvedTrackers)
+	injected := 0
+	if !preview.subject.Options.NoSeed {
+		injected, err = m.injectTrackerDryRunSubjects(
+			ctx,
+			req,
+			preview.subject,
+			reviewInput,
+			entries,
+			preview.torrent,
+		)
+		if err != nil {
+			emitPreparedUploadProgress(ctx, req, preview.subject.SourcePath, "", "dry_run", "failed", "Tracker dry run failed")
+			return api.TrackerDryRunPreview{}, err
+		}
+	} else {
+		logger.Infof("core: tracker dry-run injection skipped source=%s reason=no_seed", preview.subject.SourcePath)
+	}
+	emitPreparedUploadProgress(ctx, req, preview.subject.SourcePath, "", "dry_run", "completed", "Tracker dry run complete")
+	logger.Infof(
+		"core: tracker dry-run completed source=%s trackers=%d live_eligible=%d injected=%d",
+		preview.subject.SourcePath,
+		len(entries),
+		len(preview.outcome.Eligibility.EligibleTrackers),
+		injected,
+	)
+	return api.TrackerDryRunPreview{SourcePath: preview.subject.SourcePath, Trackers: sanitizeTrackerDryRunEntries(entries)}, nil
+}
+
+func trackerDryRunReviewInput(input api.TrackerDryRunInput) api.UploadReviewInput {
+	return api.UploadReviewInput{
+		Release:                input.Release,
+		Trackers:               append([]string(nil), input.Trackers...),
+		IgnoreDupesFor:         append([]string(nil), input.IgnoreDupesFor...),
+		QuestionnaireAnswers:   cloneOperationQuestionnaireAnswers(input.QuestionnaireAnswers),
+		TrackerIDOverrides:     cloneStringMap(input.TrackerIDOverrides),
+		DescriptionGroups:      api.CloneDescriptionBuilderGroups(input.DescriptionGroups),
+		TrackerConfigOverrides: input.TrackerConfigOverrides,
+		TrackerSiteOverrides:   input.TrackerSiteOverrides,
+		ClientOverrides:        input.ClientOverrides,
+		ImageHostOverrides:     input.ImageHostOverrides,
+		ScreenshotOverrides:    input.ScreenshotOverrides,
+		TorrentOverrides:       input.TorrentOverrides,
+		Options:                input.Options,
+	}
+}
+
+// trackerDryRunEntriesFromAssessment projects review payloads into explicit
+// dry-run entries while retaining every selected tracker's eligibility result.
+func trackerDryRunEntriesFromAssessment(review api.UploadReview) []api.TrackerDryRunEntry {
+	eligibility := make(map[string]api.TrackerEligibilityState, len(review.Eligibility.Trackers))
+	for _, state := range review.Eligibility.Trackers {
+		eligibility[strings.ToUpper(strings.TrimSpace(state.Tracker))] = state
+	}
+	entries := make([]api.TrackerDryRunEntry, 0, len(review.Trackers))
+	for _, tracker := range review.Trackers {
+		entry := tracker.DryRun
+		if strings.TrimSpace(entry.Tracker) == "" {
+			entry.Tracker = strings.ToUpper(strings.TrimSpace(tracker.Tracker))
+		}
+		state, ok := eligibility[strings.ToUpper(strings.TrimSpace(entry.Tracker))]
+		entry.Diagnostics.Duplicate = tracker.DupeCheck
+		if ok {
+			entry.Diagnostics.RuleDecisions = append([]api.RuleDecision(nil), state.RuleDecisions...)
+			entry.Diagnostics.LiveEligibilityReasons = append([]api.TrackerEligibilityReason(nil), state.Reasons...)
+		}
+		entries = append(entries, entry)
+	}
+	return entries
+}
+
+func normalizeReviewedTrackers(trackers []string) []string {
+	result := make([]string, 0, len(trackers))
+	seen := make(map[string]struct{}, len(trackers))
+	for _, tracker := range trackers {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if name == "" {
+			continue
+		}
+		if _, ok := seen[name]; ok {
+			continue
+		}
+		seen[name] = struct{}{}
+		result = append(result, name)
+	}
+	return result
+}
+
+func uploadRequestFromPlan(plan api.UploadExecutionPlan, trackers []string) api.Request {
+	input := plan.Input
+	return api.Request{
+		SourcePath:                  input.Release.SourcePath,
+		Options:                     input.Options,
+		DescriptionGroups:           api.CloneDescriptionBuilderGroups(input.DescriptionGroups),
+		Trackers:                    append([]string(nil), trackers...),
+		RuleAuthorizations:          cloneRuleAuthorizations(input.RuleAuthorizations),
+		IgnoreDupesFor:              append([]string(nil), input.IgnoreDupesFor...),
+		TrackerQuestionnaireAnswers: cloneOperationQuestionnaireAnswers(input.QuestionnaireAnswers),
+		TrackerConfigOverrides:      input.TrackerConfigOverrides,
+		TrackerSiteOverrides:        input.TrackerSiteOverrides,
+		ClientOverrides:             input.ClientOverrides,
+		ImageHostOverrides:          input.ImageHostOverrides,
+		ScreenshotOverrides:         input.ScreenshotOverrides,
+		TorrentOverrides:            input.TorrentOverrides,
+	}
+}
+
+func cloneRuleAuthorizations(values []api.RuleAuthorization) []api.RuleAuthorization {
+	if len(values) == 0 {
+		return nil
+	}
+	cloned := make([]api.RuleAuthorization, len(values))
+	for idx, value := range values {
+		cloned[idx] = api.RuleAuthorization{Tracker: value.Tracker, Rules: append([]string(nil), value.Rules...)}
+	}
+	return cloned
+}
+
+func intersectReviewedTrackers(selected []string, reviewed []string) []string {
+	allowed := make(map[string]struct{}, len(reviewed))
+	for _, tracker := range reviewed {
+		if name := strings.ToUpper(strings.TrimSpace(tracker)); name != "" {
+			allowed[name] = struct{}{}
+		}
+	}
+	result := make([]string, 0, len(selected))
+	seen := make(map[string]struct{}, len(selected))
+	for _, tracker := range selected {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if _, ok := allowed[name]; !ok || name == "" {
+			continue
+		}
+		if _, ok := seen[name]; ok {
+			continue
+		}
+		seen[name] = struct{}{}
+		result = append(result, name)
+	}
+	return result
+}
+
+func reviewedTrackerSet(trackers []string) map[string]struct{} {
+	result := make(map[string]struct{}, len(trackers))
+	for _, tracker := range trackers {
+		if name := strings.ToUpper(strings.TrimSpace(tracker)); name != "" {
+			result[name] = struct{}{}
+		}
+	}
+	return result
+}
+
+func filterReviewedNames(values []string, trackers []string) []string {
+	allowed := reviewedTrackerSet(trackers)
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		name := strings.ToUpper(strings.TrimSpace(value))
+		if _, ok := allowed[name]; ok {
+			result = append(result, name)
+		}
+	}
+	return result
+}
+
+func filterReviewedBlocks(values map[string][]api.TrackerBlockReason, trackers []string) map[string][]api.TrackerBlockReason {
+	allowed := reviewedTrackerSet(trackers)
+	result := make(map[string][]api.TrackerBlockReason)
+	for tracker, reasons := range values {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if _, ok := allowed[name]; ok {
+			result[name] = append([]api.TrackerBlockReason(nil), reasons...)
+		}
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+func filterReviewedRuleFailures(values map[string][]api.RuleFailure, trackers []string) map[string][]api.RuleFailure {
+	allowed := reviewedTrackerSet(trackers)
+	result := make(map[string][]api.RuleFailure)
+	for tracker, failures := range values {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if _, ok := allowed[name]; ok {
+			result[name] = append([]api.RuleFailure(nil), failures...)
+		}
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+func filterReviewedTorrents(values []api.UploadedTorrent, trackers []string) []api.UploadedTorrent {
+	allowed := reviewedTrackerSet(trackers)
+	result := make([]api.UploadedTorrent, 0, len(values))
+	for _, torrent := range values {
+		if _, ok := allowed[strings.ToUpper(strings.TrimSpace(torrent.Tracker))]; ok {
+			result = append(result, torrent)
+		}
+	}
+	return result
+}
+
+func (m *uploadModule) hydrateCanonicalTrackerState(ctx context.Context, subject *api.UploadSubject) error {
+	if m.trackerRepo == nil || subject == nil || subject.Options.SkipAutoTorrent {
+		return nil
+	}
+	records, err := m.trackerRepo.ListTrackerMetadataByPath(ctx, subject.SourcePath)
+	if err != nil {
+		return fmt.Errorf("core: tracker metadata lookup: %w", err)
+	}
+	allowed := reviewedTrackerSet(subject.Trackers)
+	for _, record := range records {
+		name := strings.ToUpper(strings.TrimSpace(record.Tracker))
+		if _, ok := allowed[name]; !ok {
+			continue
+		}
+		subject.TrackerData = append(subject.TrackerData, record)
+		if record.Matched {
+			subject.MatchedTrackers = appendUniqueNormalizedTracker(subject.MatchedTrackers, name)
+		}
+		if trackerID := strings.TrimSpace(record.TrackerID); trackerID != "" {
+			if subject.TrackerIDs == nil {
+				subject.TrackerIDs = make(map[string]string)
+			}
+			subject.TrackerIDs[strings.ToLower(name)] = trackerID
+		}
+		if subject.InfoHash == "" {
+			subject.InfoHash = strings.TrimSpace(record.InfoHash)
+		}
+	}
+	return nil
+}
+
+// persistPreparedInfoHash stores the prepared torrent hash without replacing
+// existing release metadata used by history views.
+func (m *uploadModule) persistPreparedInfoHash(ctx context.Context, sourcePath string, infoHash string) error {
+	if m == nil || m.repo == nil {
+		return nil
+	}
+	trimmedPath := strings.TrimSpace(sourcePath)
+	trimmedHash := strings.TrimSpace(infoHash)
+	if trimmedPath == "" || trimmedHash == "" {
+		return nil
+	}
+
+	metadata, err := m.repo.GetByPath(ctx, trimmedPath)
+	if err != nil {
+		if !errors.Is(err, internalerrors.ErrNotFound) {
+			return fmt.Errorf("lookup existing metadata: %w", err)
+		}
+		m.logger.Debugf("metadata: skip info hash persistence without stored metadata for %s", trimmedPath)
+		return nil
+	} else if strings.TrimSpace(metadata.Path) == "" {
+		metadata.Path = trimmedPath
+	}
+	metadata.InfoHash = trimmedHash
+	metadata.UpdatedAt = time.Now().UTC()
+	if err := m.repo.Save(ctx, metadata); err != nil {
+		return fmt.Errorf("save metadata: %w", err)
+	}
+	return nil
+}
diff --git a/internal/core/upload_dry_run_test.go b/internal/core/upload_dry_run_test.go
new file mode 100644
index 00000000..b5276a5e
--- /dev/null
+++ b/internal/core/upload_dry_run_test.go
@@ -0,0 +1,539 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package core
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/externalidentity"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dryRunPreparedStore struct {
+	release api.PreparedRelease
+}
+
+func (s *dryRunPreparedStore) LoadPreparedRelease(_ context.Context, sourcePath string) (api.PreparedRelease, error) {
+	if s.release.Generation == 0 || !strings.EqualFold(filepath.Clean(s.release.Source.SourcePath), filepath.Clean(sourcePath)) {
+		return api.PreparedRelease{}, internalerrors.ErrNotFound
+	}
+	cloned, err := s.release.Clone()
+	if err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("clone loaded release: %w", err)
+	}
+	return cloned, nil
+}
+
+func (s *dryRunPreparedStore) CommitPreparedRelease(_ context.Context, release api.PreparedRelease) error {
+	cloned, err := release.Clone()
+	if err != nil {
+		return fmt.Errorf("clone committed release: %w", err)
+	}
+	s.release = cloned
+	return nil
+}
+
+func (s *dryRunPreparedStore) PurgePreparedRelease(context.Context, string) error {
+	s.release = api.PreparedRelease{}
+	return nil
+}
+
+type dryRunIdentityResolver struct{}
+
+func (dryRunIdentityResolver) Resolve(_ context.Context, request externalidentity.Request) (externalidentity.Result, error) {
+	now := time.Now().UTC()
+	return externalidentity.Result{
+		Identity: api.ExternalIdentity{
+			SourcePath: request.SourcePath,
+			Generation: request.Generation,
+			TMDBID:     1234567,
+			Category:   api.CanonicalCategoryMovie,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB:     api.IdentityProvenanceProvider,
+				Category: api.IdentityProvenanceProvider,
+			},
+			Conflict: api.IdentityConflictNone,
+			Resolution: api.IdentityResolutionKey{
+				SourceFingerprint: request.SourceFingerprint,
+				IntentFingerprint: "dry-run-test",
+				ContractVersion:   externalidentity.ContractVersion,
+			},
+			ResolvedAt: now,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			SourcePath: request.SourcePath,
+			Generation: request.Generation,
+			UpdatedAt:  now,
+		},
+	}, nil
+}
+
+type dryRunFactCollector struct{}
+
+func (dryRunFactCollector) Collect(_ context.Context, request preparationstate.Request) (preparedrelease.CollectedFacts, error) {
+	return preparedrelease.CollectedFacts{
+		Naming: api.NamingFacts{
+			Filename:    filepath.Base(request.Manifest.SourcePath),
+			ReleaseName: "Example.Release.2026.1080p-GRP",
+		},
+		Assessments: api.ReleaseAssessments{
+			MediaInfoUniqueID:       api.UniqueIDStatusPresent,
+			MediaInfoEncodeSettings: api.EncodeSettingsStatusPresent,
+			Naming:                  api.NamingAssessment{Status: api.NamingStatusComplete},
+		},
+		Resources: preparedrelease.CollectedResources{
+			SourcePath: request.Manifest.SourcePath,
+			FileList:   []string{request.Manifest.SourcePath},
+		},
+	}, nil
+}
+
+type dryRunTrackerService struct {
+	uploadCalls int
+	buildCalls  int
+	reviewCalls int
+	status      string
+}
+
+func (s *dryRunTrackerService) Upload(context.Context, api.UploadSubject) (api.UploadSummary, error) {
+	s.uploadCalls++
+	return api.UploadSummary{Uploaded: 1}, nil
+}
+
+func (*dryRunTrackerService) BuildPreparation(context.Context, api.DescriptionSubject, []string) (api.PreparationPreview, error) {
+	return api.PreparationPreview{}, nil
+}
+
+func (s *dryRunTrackerService) BuildUploadReview(context.Context, api.UploadSubject, []string) ([]api.TrackerDryRunEntry, error) {
+	s.reviewCalls++
+	return nil, nil
+}
+
+func (s *dryRunTrackerService) BuildUploadDryRun(context.Context, api.UploadSubject, []string) ([]api.TrackerDryRunEntry, error) {
+	s.buildCalls++
+	status := s.status
+	if status == "" {
+		status = "ready"
+	}
+	return []api.TrackerDryRunEntry{{
+		Tracker:  "BLU",
+		Status:   status,
+		Endpoint: "https://user:super-secret@example.invalid/upload?api_key=super-secret",
+		Payload:  map[string]string{"api_key": "super-secret", "name": "Example.Release.2026.1080p-GRP"},
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    "prepared-blu.torrent",
+			Present: true,
+		}},
+	}}, nil
+}
+
+type dryRunTorrentService struct{}
+
+func (dryRunTorrentService) Create(context.Context, api.TorrentSubject) (api.TorrentResult, error) {
+	return api.TorrentResult{Path: "base.torrent", InfoHash: "0123456789abcdef"}, nil
+}
+
+type dryRunClientService struct {
+	injections []api.TorrentResult
+	searches   int
+}
+
+func (s *dryRunClientService) Inject(_ context.Context, _ api.ClientSubject, torrent api.TorrentResult) error {
+	s.injections = append(s.injections, torrent)
+	return nil
+}
+
+func (s *dryRunClientService) SearchPathedTorrents(context.Context, api.ClientSubject) (api.ClientSearchResult, error) {
+	s.searches++
+	return api.ClientSearchResult{}, nil
+}
+
+type dryRunDupeService struct {
+	hasDupes bool
+	calls    int
+}
+
+func (s *dryRunDupeService) Check(ctx context.Context, subject api.DuplicateSubject, trackerNames []string) (api.DupeCheckSummary, error) {
+	summary, _, err := s.CheckWithAssessment(ctx, subject, trackerNames, dupechecking.CheckOptions{})
+	return summary, err
+}
+
+func (s *dryRunDupeService) CheckWithAssessment(
+	_ context.Context,
+	subject api.DuplicateSubject,
+	trackerNames []string,
+	_ dupechecking.CheckOptions,
+) (api.DupeCheckSummary, dupechecking.Assessment, error) {
+	s.calls++
+	results := make([]api.DupeCheckResult, 0, len(trackerNames))
+	evidence := make([]dupechecking.AssessmentEvidence, 0, len(trackerNames))
+	for _, trackerName := range trackerNames {
+		results = append(results, api.DupeCheckResult{
+			Tracker:  trackerName,
+			Status:   "completed",
+			HasDupes: s.hasDupes,
+		})
+		evidence = append(evidence, dupechecking.AssessmentEvidence{
+			Tracker:     trackerName,
+			Disposition: dupechecking.DispositionResolved,
+			HasDupes:    s.hasDupes,
+			Match:       api.DupeMatch{MatchedReason: "name"},
+		})
+	}
+	return api.DupeCheckSummary{SourcePath: subject.SourcePath, Results: results}, dupechecking.NewAssessment(subject, config.Config{}, evidence), nil
+}
+
+type dryRunPolicy struct {
+	blocked     bool
+	ruleFailure bool
+}
+
+func (p dryRunPolicy) EvaluateUploadPolicy(context.Context, api.UploadSubject, []string) (api.UploadReviewOutcome, error) {
+	outcome := api.UploadReviewOutcome{}
+	if p.ruleFailure {
+		outcome.TrackerRuleFailures = map[string][]api.RuleFailure{
+			"BLU": {
+				{
+					Rule:     "source",
+					Reason:   "source is not permitted",
+					Disposition: api.RuleDispositionStrict,
+				},
+			},
+		}
+	}
+	if p.blocked {
+		outcome.BlockedTrackers = map[string][]api.TrackerBlockReason{
+			"BLU": {api.TrackerBlockReasonClaim},
+		}
+	}
+	return outcome, nil
+}
+
+func prepareDryRunCore(t *testing.T) (*Core, api.ReleaseRef, *dryRunTrackerService, *dryRunClientService, *uploadModule) {
+	t.Helper()
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+	if err := os.WriteFile(sourcePath, []byte("fixture"), 0o600); err != nil {
+		t.Fatalf("write source fixture: %v", err)
+	}
+	preparedFacts, err := preparedrelease.New(&dryRunPreparedStore{}, dryRunIdentityResolver{}, dryRunFactCollector{})
+	if err != nil {
+		t.Fatalf("create prepared-release module: %v", err)
+	}
+	prepared, err := preparedFacts.Prepare(context.Background(), api.PrepareInput{SourcePath: sourcePath, Intent: api.PreparationIntentDryRun})
+	if err != nil {
+		t.Fatalf("prepare release: %v", err)
+	}
+	trackerService := &dryRunTrackerService{}
+	clientService := &dryRunClientService{}
+	dupeService := &dryRunDupeService{}
+	module := &uploadModule{
+		cfg:           config.Config{MainSettings: config.MainSettingsConfig{DBPath: t.TempDir()}},
+		logger:        api.NopLogger{},
+		policy:        dryRunPolicy{},
+		trackers:      trackerService,
+		torrents:      dryRunTorrentService{},
+		clients:       clientService,
+		dupes:         dupeService,
+		registry:      trackerimpl.MustNewRegistry(),
+		preparedFacts: preparedFacts,
+		resolveSubjectGroups: func(context.Context, api.UploadSubject, api.UploadReviewInput) ([]api.DescriptionBuilderGroup, error) {
+			return nil, nil
+		},
+	}
+	return &Core{upload: module}, api.ReleaseRef{SourcePath: sourcePath, Generation: prepared.Release.Generation}, trackerService, clientService, module
+}
+
+func TestRunAcceptedTrackerDryRunOwnsSubmissionAndInjectionPolicy(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name        string
+		noSeed      bool
+		duplicate   bool
+		blocked     bool
+		ruleFailure bool
+		ignoreDupes bool
+		payloadStatus string
+		wantInject  int
+		wantStatus  string
+	}{
+		{
+			name:       "ready entry injects once",
+			wantInject: 1,
+			wantStatus: "ready",
+		},
+		{
+			name:       "no-seed suppresses injection",
+			noSeed:     true,
+			wantStatus: "ready",
+		},
+		{
+			name:       "duplicate remains visible and permits injection",
+			duplicate:  true,
+			wantInject: 1,
+			wantStatus: "ready",
+		},
+		{
+			name:        "explicit duplicate override permits injection",
+			duplicate:   true,
+			ignoreDupes: true,
+			wantInject:  1,
+			wantStatus:  "ready",
+		},
+		{
+			name:        "strict rule remains diagnostic and permits injection",
+			ruleFailure: true,
+			wantInject:  1,
+			wantStatus:  "ready",
+		},
+		{
+			name:       "policy block remains diagnostic and permits injection",
+			blocked:    true,
+			wantInject: 1,
+			wantStatus: "ready",
+		},
+		{
+			name:          "operationally failed payload does not inject",
+			payloadStatus: "error",
+			wantStatus:    "error",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			coreSvc, release, trackerService, clientService, module := prepareDryRunCore(t)
+			trackerService.status = test.payloadStatus
+			module.policy = dryRunPolicy{blocked: test.blocked, ruleFailure: test.ruleFailure}
+			var ignoreDupesFor []string
+			if test.ignoreDupes {
+				ignoreDupesFor = []string{"BLU"}
+			}
+			var progress []api.UploadProgressUpdate
+			ctx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) {
+				progress = append(progress, update)
+			})
+			preview, err := coreSvc.RunAcceptedTrackerDryRun(ctx, api.TrackerDryRunPlan{
+				Input: api.TrackerDryRunInput{
+					Release:               release,
+					Trackers:              []string{"blu", "BLU"},
+					IgnoreDupesFor: ignoreDupesFor,
+					Options:               api.UploadOptions{NoSeed: test.noSeed},
+				},
+				Duplicate: api.AcceptedDuplicateEvidence{
+					Release:  release,
+					Trackers: []string{"BLU"},
+					Results: []api.DupeCheckResult{{
+						Tracker:  "BLU",
+						Status:   "completed",
+						HasDupes: test.duplicate,
+					}},
+				},
+			})
+			if err != nil {
+				t.Fatalf("run accepted tracker dry run: %v", err)
+			}
+			if len(preview.Trackers) != 1 || preview.Trackers[0].Status != test.wantStatus {
+				t.Fatalf("preview = %#v", preview)
+			}
+			if trackerService.uploadCalls != 0 || trackerService.buildCalls != 1 || trackerService.reviewCalls != 0 {
+				t.Fatalf("tracker calls: upload=%d dry-run=%d review=%d", trackerService.uploadCalls, trackerService.buildCalls, trackerService.reviewCalls)
+			}
+			if len(clientService.injections) != test.wantInject {
+				t.Fatalf("client injections = %d, want %d", len(clientService.injections), test.wantInject)
+			}
+			if clientService.searches != 0 {
+				t.Fatalf("dry run client searches = %d, want 0", clientService.searches)
+			}
+			dupeService, ok := module.dupes.(*dryRunDupeService)
+			if !ok {
+				t.Fatalf("duplicate service type = %T", module.dupes)
+			}
+			if dupeService.calls != 0 {
+				t.Fatalf("dry run duplicate checks = %d, want 0", dupeService.calls)
+			}
+			if len(progress) < 2 || progress[0].Task != "dry_run" || progress[0].Status != "running" ||
+				progress[len(progress)-1].Task != "dry_run" || progress[len(progress)-1].Status != "completed" {
+				t.Fatalf("dry-run progress = %#v", progress)
+			}
+			serialized, marshalErr := json.Marshal(preview)
+			if marshalErr != nil {
+				t.Fatalf("marshal preview: %v", marshalErr)
+			}
+			if strings.Contains(string(serialized), "super-secret") {
+				t.Fatalf("preview leaked sensitive payload: %s", serialized)
+			}
+		})
+	}
+}
+
+func TestReviewAcceptedUploadRefreshesClientAndDuplicateAuthorityOnce(t *testing.T) {
+	t.Parallel()
+
+	coreSvc, release, trackerService, clientService, module := prepareDryRunCore(t)
+	reviewed, err := coreSvc.ReviewAcceptedUpload(context.Background(), api.UploadReviewInput{
+		Release:  release,
+		Trackers: []string{"BLU"},
+		Options:  api.UploadOptions{NoSeed: true},
+	})
+	if err != nil {
+		t.Fatalf("review accepted upload: %v", err)
+	}
+	if len(reviewed.Outcome.Eligibility.EligibleTrackers) != 1 || reviewed.Outcome.Eligibility.EligibleTrackers[0] != "BLU" {
+		t.Fatalf("review eligibility = %#v", reviewed.Outcome.Eligibility)
+	}
+	if clientService.searches != 0 {
+		t.Fatalf("review client searches = %d, want 0", clientService.searches)
+	}
+	dupeService, ok := module.dupes.(*dryRunDupeService)
+	if !ok {
+		t.Fatalf("duplicate service type = %T", module.dupes)
+	}
+	if dupeService.calls != 1 {
+		t.Fatalf("review duplicate checks = %d, want 1", dupeService.calls)
+	}
+	if trackerService.reviewCalls != 1 || trackerService.buildCalls != 0 || trackerService.uploadCalls != 0 {
+		t.Fatalf(
+			"tracker calls: review=%d dry-run=%d upload=%d",
+			trackerService.reviewCalls,
+			trackerService.buildCalls,
+			trackerService.uploadCalls,
+		)
+	}
+}
+
+func TestRunAcceptedTrackerDryRunRequiresExactGenerationAndTrackers(t *testing.T) {
+	t.Parallel()
+
+	coreSvc, release, _, _, _ := prepareDryRunCore(t)
+	_, err := coreSvc.RunAcceptedTrackerDryRun(context.Background(), api.TrackerDryRunPlan{Input: api.TrackerDryRunInput{Release: release}})
+	if err == nil {
+		t.Fatal("expected empty tracker selection to fail")
+	}
+	release.Generation++
+	_, err = coreSvc.RunAcceptedTrackerDryRun(context.Background(), api.TrackerDryRunPlan{
+		Input: api.TrackerDryRunInput{Release: release, Trackers: []string{"BLU"}},
+		Duplicate: api.AcceptedDuplicateEvidence{
+			Release:  api.ReleaseRef{SourcePath: release.SourcePath, Generation: release.Generation - 1},
+			Trackers: []string{"BLU"},
+			Results:  []api.DupeCheckResult{{Tracker: "BLU", Status: "completed"}},
+		},
+	})
+	failure, ok := api.AsOperationFailure(err)
+	if !ok || failure.Code != api.OperationFailureStaleGeneration {
+		t.Fatalf("stale generation error = %v", err)
+	}
+	release.Generation--
+
+	tests := []struct {
+		name     string
+		evidence api.AcceptedDuplicateEvidence
+	}{
+		{
+			name: "mismatched tracker selection",
+			evidence: api.AcceptedDuplicateEvidence{
+				Release:  release,
+				Trackers: []string{"AITHER"},
+				Results:  []api.DupeCheckResult{{Tracker: "AITHER", Status: "completed"}},
+			},
+		},
+		{
+			name: "missing tracker result",
+			evidence: api.AcceptedDuplicateEvidence{
+				Release:  release,
+				Trackers: []string{"BLU"},
+			},
+		},
+		{
+			name: "nonterminal tracker result",
+			evidence: api.AcceptedDuplicateEvidence{
+				Release:  release,
+				Trackers: []string{"BLU"},
+				Results:  []api.DupeCheckResult{{Tracker: "BLU", Status: "running"}},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, testErr := coreSvc.RunAcceptedTrackerDryRun(context.Background(), api.TrackerDryRunPlan{
+				Input:     api.TrackerDryRunInput{Release: release, Trackers: []string{"BLU"}},
+				Duplicate: test.evidence,
+			})
+			testFailure, testOK := api.AsOperationFailure(testErr)
+			if !testOK || testFailure.Code != api.OperationFailureMissingPrerequisite {
+				t.Fatalf("missing prerequisite error = %v", testErr)
+			}
+		})
+	}
+}
+
+func TestRunAcceptedTrackerDryRunHonorsPreCanceledContext(t *testing.T) {
+	t.Parallel()
+
+	coreSvc, release, trackerService, clientService, _ := prepareDryRunCore(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	_, err := coreSvc.RunAcceptedTrackerDryRun(ctx, api.TrackerDryRunPlan{
+		Input: api.TrackerDryRunInput{Release: release, Trackers: []string{"BLU"}},
+		Duplicate: api.AcceptedDuplicateEvidence{
+			Release:  release,
+			Trackers: []string{"BLU"},
+			Results:  []api.DupeCheckResult{{Tracker: "BLU", Status: "completed"}},
+		},
+	})
+	if err == nil {
+		t.Fatal("expected canceled dry run to fail")
+	}
+	if trackerService.uploadCalls != 0 || trackerService.buildCalls != 0 || len(clientService.injections) != 0 {
+		t.Fatalf("canceled dry run performed side effects: tracker=%#v clients=%#v", trackerService, clientService.injections)
+	}
+}
+
+func TestRunAcceptedUploadWithDebugLogLevelStillSubmits(t *testing.T) {
+	t.Parallel()
+
+	coreSvc, release, trackerService, clientService, _ := prepareDryRunCore(t)
+	result, err := coreSvc.RunAcceptedUpload(context.Background(), api.UploadExecutionPlan{
+		Input: api.UploadReviewInput{
+			Release:  release,
+			Trackers: []string{"BLU"},
+			Options:  api.UploadOptions{NoSeed: true, RunLogLevel: "debug"},
+		},
+		Outcome: api.UploadReviewOutcome{
+			ResolvedTrackers: []string{"BLU"},
+			Eligibility: api.TrackerEligibility{
+				Release:          release,
+				EligibleTrackers: []string{"BLU"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("run accepted upload: %v", err)
+	}
+	if result.UploadedCount != 1 || trackerService.uploadCalls != 1 || trackerService.buildCalls != 0 {
+		t.Fatalf("upload result=%#v calls: upload=%d dry-run=%d", result, trackerService.uploadCalls, trackerService.buildCalls)
+	}
+	if len(clientService.injections) != 0 {
+		t.Fatalf("no-seed upload injected clients: %#v", clientService.injections)
+	}
+}
+
+var _ api.TrackerService = (*dryRunTrackerService)(nil)
+var _ api.TorrentService = dryRunTorrentService{}
+var _ api.ClientService = (*dryRunClientService)(nil)
+var _ api.DupeService = (*dryRunDupeService)(nil)
+var _ uploadPolicyEvaluator = dryRunPolicy{}
+var _ preparedrelease.Store = (*dryRunPreparedStore)(nil)
diff --git a/internal/core/upload_images_test.go b/internal/core/upload_images_test.go
deleted file mode 100644
index 99ea6828..00000000
--- a/internal/core/upload_images_test.go
+++ /dev/null
@@ -1,718 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"slices"
-	"sort"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type stubImageHosting struct {
-	candidates []api.ScreenshotImage
-	uploaded   []api.UploadedImageLink
-	err        error
-	lastMeta   api.PreparedMetadata
-	mu         sync.Mutex
-	calls      []stubImageUploadCall
-	uploadFn   func(ctx context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error)
-}
-
-type stubImageUploadCall struct {
-	host       string
-	usageScope string
-	images     []api.ScreenshotImage
-}
-
-func (s *stubImageHosting) ListCandidates(_ context.Context, meta api.PreparedMetadata) ([]api.ScreenshotImage, error) {
-	if s.err != nil {
-		return nil, s.err
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.lastMeta = meta
-	return s.candidates, nil
-}
-
-func (s *stubImageHosting) Upload(ctx context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-	if s.err != nil {
-		return nil, s.err
-	}
-	s.mu.Lock()
-	s.lastMeta = meta
-	s.calls = append(s.calls, stubImageUploadCall{
-		host:       host,
-		usageScope: usageScope,
-		images:     append([]api.ScreenshotImage{}, images...),
-	})
-	s.mu.Unlock()
-	if s.uploadFn != nil {
-		return s.uploadFn(ctx, meta, host, usageScope, images)
-	}
-	return s.uploaded, nil
-}
-
-func TestUploadImagesWithoutCache(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	uploaded := []api.UploadedImageLink{{ImagePath: "/tmp/img1.png", Host: "imgbox"}}
-
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     &stubImageHosting{uploaded: uploaded},
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths: []string{"/tmp/source"},
-		Mode:  api.ModeGUI,
-	}, "imgbox", images)
-
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(result.Links) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(result.Links))
-	}
-	if result.Links[0].Host != "imgbox" {
-		t.Fatalf("expected host imgbox, got %s", result.Links[0].Host)
-	}
-}
-
-func TestListUploadCandidatesWithoutCache(t *testing.T) {
-	t.Parallel()
-
-	candidates := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg:    config.Config{},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     &stubImageHosting{candidates: candidates},
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.ListUploadCandidates(context.Background(), api.Request{
-		Paths: []string{"/tmp/source"},
-		Mode:  api.ModeGUI,
-	})
-
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(result) != 1 {
-		t.Fatalf("expected 1 candidate, got %d", len(result))
-	}
-	if result[0].Path != "/tmp/img1.png" {
-		t.Fatalf("expected path /tmp/img1.png, got %s", result[0].Path)
-	}
-}
-
-func TestUploadImagesGUIFallbackReappliesReleaseOverrides(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{uploaded: []api.UploadedImageLink{{ImagePath: "/tmp/img1.png", Host: "imgbox"}}}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Metadata:   &stubMeta{},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		Release: api.ReleaseInfo{
-			Title: "Example",
-		},
-	})
-
-	edition := "Director's Cut"
-	_, err := core.UploadImages(context.Background(), api.Request{
-		Paths: []string{"/tmp/source"},
-		Mode:  api.ModeGUI,
-		ReleaseNameOverrides: api.ReleaseNameOverrides{
-			Edition: &edition,
-		},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if imageService.lastMeta.ReleaseNameOverrides.Edition == nil || *imageService.lastMeta.ReleaseNameOverrides.Edition != edition {
-		t.Fatalf("expected upload images to receive edition override, got %#v", imageService.lastMeta.ReleaseNameOverrides)
-	}
-}
-
-func TestUploadImagesUploadsApplicableTrackerHosts(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"PTP": {ImageHost: "pixhost"},
-					"STC": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"PTP", "STC"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if len(imageService.calls) != 2 {
-		t.Fatalf("expected uploads to two hosts, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	calledHosts := map[string]string{}
-	for _, call := range imageService.calls {
-		calledHosts[call.host] = call.usageScope
-	}
-	if calledHosts["imgbox"] != "global" {
-		t.Fatalf("expected selected host imgbox, got %#v", imageService.calls)
-	}
-	if calledHosts["pixhost"] != "global" {
-		t.Fatalf("expected configured PTP host pixhost, got %#v", imageService.calls)
-	}
-	if len(result.Links) != 2 {
-		t.Fatalf("expected result from both hosts, got %d", len(result.Links))
-	}
-}
-
-func TestUploadImagesIncludesRequiredHDBRehost(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/menu.png", Purpose: api.ScreenshotPurposeMenu}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {ImgRehost: true},
-					"STC": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HDB", "STC"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if len(imageService.calls) != 2 {
-		t.Fatalf("expected global and HDB uploads, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	calledHosts := map[string]string{}
-	for _, call := range imageService.calls {
-		calledHosts[call.host] = call.usageScope
-	}
-	if calledHosts["imgbox"] != "global" {
-		t.Fatalf("expected selected global host, got %#v", imageService.calls)
-	}
-	if calledHosts["hdb"] != "tracker:HDB" {
-		t.Fatalf("expected tracker-scoped HDB rehost, got %#v", imageService.calls)
-	}
-	for _, call := range imageService.calls {
-		if call.host == "hdb" && (len(call.images) != 1 || call.images[0].Purpose != api.ScreenshotPurposeMenu) {
-			t.Fatalf("expected HDB upload to preserve menu purpose, got %#v", call.images)
-		}
-	}
-	if len(result.Links) != 2 {
-		t.Fatalf("expected results from both hosts, got %#v", result)
-	}
-}
-
-func TestUploadImagesUsesConfiguredHostPriorityWhenSelectedHostIsNotApproved(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{
-				Host1: "imgbb",
-				Host2: "pixhost",
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"PTP": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"PTP"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(imageService.calls) != 1 {
-		t.Fatalf("expected upload to required tracker host only, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	if imageService.calls[0].host != "pixhost" {
-		t.Fatalf("expected configured PTP-approved host pixhost, got %#v", imageService.calls[0])
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "pixhost" {
-		t.Fatalf("expected pixhost result only, got %#v", result)
-	}
-}
-
-func TestUploadImagesUsesSelectedHostWhenApprovedForTracker(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"MTV"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(imageService.calls) != 1 {
-		t.Fatalf("expected upload to selected approved host only, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	if imageService.calls[0].host != "imgbox" {
-		t.Fatalf("expected selected host imgbox, got %#v", imageService.calls[0])
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbox" {
-		t.Fatalf("expected imgbox result only, got %#v", result)
-	}
-}
-
-func TestUploadImagesFiltersCachedBlockedTrackers(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbb"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {ImageHost: "hdb"},
-					"NBL": {},
-					"OE":  {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath: "/tmp/source",
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"NBL": {{Rule: "require_tv_only", Reason: "category movie is not tv"}},
-		},
-	})
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HDB", "NBL", "OE"},
-	}, "imgbb", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(imageService.calls) != 1 {
-		t.Fatalf("expected upload only for unblocked tracker, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	if imageService.calls[0].host != "imgbb" {
-		t.Fatalf("expected only selected global host for OE, got %#v", imageService.calls[0])
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbb" {
-		t.Fatalf("expected imgbb result only, got %#v", result)
-	}
-}
-
-func TestUploadImagesFiltersCachedMatchedTrackers(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbb"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {ImageHost: "hdb"},
-					"OE":  {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-	core.storeDupeCache("/tmp/source", "", api.PreparedMetadata{
-		SourcePath:      "/tmp/source",
-		MatchedTrackers: []string{"hdb"},
-	})
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HDB", "OE"},
-	}, "imgbb", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(imageService.calls) != 1 {
-		t.Fatalf("expected upload only for unmatched tracker, got %d calls: %#v", len(imageService.calls), imageService.calls)
-	}
-	if imageService.calls[0].host != "imgbb" {
-		t.Fatalf("expected only selected global host for OE, got %#v", imageService.calls[0])
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbb" {
-		t.Fatalf("expected imgbb result only, got %#v", result)
-	}
-}
-
-func TestUploadImagesUploadsHostsConcurrently(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	bothStarted := make(chan struct{})
-	var startedMu sync.Mutex
-	started := 0
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			startedMu.Lock()
-			started++
-			if started == 2 {
-				close(bothStarted)
-			}
-			startedMu.Unlock()
-
-			select {
-			case <-bothStarted:
-			case <-time.After(500 * time.Millisecond):
-				return nil, errors.New("second host did not start")
-			}
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{Host1: "imgbox"},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"PTP": {ImageHost: "pixhost"},
-					"MTV": {ImageHost: "imgbox"},
-					"STC": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"PTP", "MTV", "STC"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(result.Links) != 2 {
-		t.Fatalf("expected both concurrent uploads to succeed, got %#v", result)
-	}
-}
-
-func TestUploadImagesReturnsHostFailuresWithSuccessfulLinks(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			if host == "pixhost" {
-				return nil, fmt.Errorf("%s unavailable", host)
-			}
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{
-				Host1: "imgbox",
-				Host2: "pixhost",
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"PTP": {ImageHost: "pixhost"},
-					"MTV": {ImageHost: "imgbox"},
-					"STC": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"PTP", "MTV", "STC"},
-	}, "imgbox", images)
-	if err != nil {
-		t.Fatalf("expected partial host failure to return successful links, got %v", err)
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbox" {
-		t.Fatalf("expected only successful imgbox upload, got %#v", result)
-	}
-	if len(result.Failures) != 1 {
-		t.Fatalf("expected one host failure, got %#v", result.Failures)
-	}
-	failure := result.Failures[0]
-	if failure.Host != "pixhost" || failure.Message != "pixhost unavailable" {
-		t.Fatalf("expected exhausted pixhost fallback failure, got %#v", failure)
-	}
-	expectedTrackers := []string{"PTP"}
-	sort.Strings(failure.Trackers)
-	sort.Strings(expectedTrackers)
-	if !slices.Equal(failure.Trackers, expectedTrackers) {
-		t.Fatalf("expected failure to block only linked trackers, got %#v", failure.Trackers)
-	}
-}
-
-func TestUploadImagesFallsBackWhenSelectedHostFails(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	var calls []string
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			calls = append(calls, host)
-			if host == "imgbb" {
-				return nil, errors.New("imgbb unavailable")
-			}
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{
-				Host1: "imgbb",
-				Host2: "imgbox",
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {},
-					"STC": {},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"MTV", "STC"},
-	}, "imgbb", images)
-	if err != nil {
-		t.Fatalf("expected fallback upload to succeed, got %v", err)
-	}
-	if len(result.Failures) != 0 {
-		t.Fatalf("expected selected host failure to be recovered by fallback, got %#v", result.Failures)
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbox" {
-		t.Fatalf("expected fallback imgbox link, got %#v", result)
-	}
-	if !slices.Equal(calls, []string{"imgbb", "imgbox"}) {
-		t.Fatalf("expected selected host then fallback host, got %v", calls)
-	}
-}
-
-func TestUploadImagesFallsBackFromTrackerConfiguredHostForUnrestrictedTracker(t *testing.T) {
-	t.Parallel()
-
-	images := []api.ScreenshotImage{{Path: "/tmp/img1.png"}}
-	var calls []string
-	imageService := &stubImageHosting{
-		uploadFn: func(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-			calls = append(calls, host)
-			if host == "pixhost" {
-				return nil, errors.New("pixhost unavailable")
-			}
-			return uploadedImageLinksForHost(meta, host, usageScope, images), nil
-		},
-	}
-	core := &Core{
-		logger: api.NopLogger{},
-		cfg: config.Config{
-			ImageHosting: config.ImageHostingConfig{
-				Host1: "pixhost",
-				Host2: "imgbb",
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HHD": {ImageHost: "pixhost"},
-				},
-			},
-		},
-		services: api.ServiceSet{
-			Filesystem: stubFilesystem{paths: []string{"/tmp/source"}},
-			Images:     imageService,
-		},
-		dupeCache: make(map[string]dupeCacheEntry),
-	}
-
-	result, err := core.UploadImages(context.Background(), api.Request{
-		Paths:    []string{"/tmp/source"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"HHD"},
-	}, "pixhost", images)
-	if err != nil {
-		t.Fatalf("expected fallback upload to succeed, got %v", err)
-	}
-	if len(result.Failures) != 0 {
-		t.Fatalf("expected configured host failure to be recovered by fallback, got %#v", result.Failures)
-	}
-	if len(result.Links) != 1 || result.Links[0].Host != "imgbb" {
-		t.Fatalf("expected fallback imgbb link, got %#v", result)
-	}
-	if !slices.Equal(calls, []string{"pixhost", "imgbb"}) {
-		t.Fatalf("expected configured host then fallback host, got %v", calls)
-	}
-}
-
-func uploadedImageLinksForHost(meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) []api.UploadedImageLink {
-	result := make([]api.UploadedImageLink, 0, len(images))
-	for _, image := range images {
-		result = append(result, api.UploadedImageLink{
-			SourcePath: meta.SourcePath,
-			ImagePath:  image.Path,
-			Host:       host,
-			UsageScope: usageScope,
-			RawURL:     "https://" + host + "/raw.png",
-			ImgURL:     "https://" + host + "/img.png",
-			WebURL:     "https://" + host + "/web.png",
-		})
-	}
-	return result
-}
diff --git a/internal/core/upload_review.go b/internal/core/upload_review.go
index 876a8897..3c2de0c2 100644
--- a/internal/core/upload_review.go
+++ b/internal/core/upload_review.go
@@ -11,572 +11,531 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/metadata"
+	"github.com/autobrr/upbrr/internal/logging"
 	trackerspkg "github.com/autobrr/upbrr/internal/trackers"
+	dupechecking "github.com/autobrr/upbrr/internal/trackers/dupe"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-// BuildUploadReview returns dupe, rule, dry-run, and banned-group review data
-// for one prepared source path, committing GUI cache updates only after review work succeeds.
-// Partial GUI reviews preserve unreviewed tracker cache state and can commit from
-// a request-refreshed cache entry only when that entry matches the current request.
+// BuildUploadReview prepares req.SourcePath, refreshes tracker policy and remote
+// duplicate evidence, builds non-submitting tracker payloads, and persists the
+// resulting rule decisions. It does not upload to trackers.
 func (c *Core) BuildUploadReview(ctx context.Context, req api.Request) (api.UploadReview, error) {
-	req = normalizeExecutionRequest(req)
-	resolvedReq, err := c.resolveDescriptionOverrideRequest(ctx, req)
-	if err != nil {
-		return api.UploadReview{}, err
-	}
-	req = resolvedReq
+	return c.upload.buildReview(ctx, req)
+}
 
-	if len(req.Paths) == 0 {
-		return api.UploadReview{}, internalerrors.ErrInvalidInput
-	}
-	if c.services.Filesystem == nil {
-		return api.UploadReview{}, errors.New("core: filesystem service not configured")
-	}
-	if c.services.Dupes == nil {
-		return api.UploadReview{}, errors.New("core: dupe service not configured")
-	}
-	if c.services.Torrents == nil {
-		return api.UploadReview{}, errors.New("core: torrent service not configured")
-	}
-	if c.services.Trackers == nil {
-		return api.UploadReview{}, errors.New("core: tracker service not configured")
-	}
+// ReviewAcceptedUpload reviews one exact canonical prepared generation and
+// returns the outcomes required for later execution.
+func (c *Core) ReviewAcceptedUpload(ctx context.Context, input api.UploadReviewInput) (api.ReviewedUpload, error) {
+	reviewed, err := c.upload.reviewAccepted(ctx, input)
+	return reviewed, classifyOperationError(api.OperationKindUploadReview, err)
+}
 
-	normalizedPaths, err := c.services.Filesystem.ValidatePaths(ctx, req.Paths)
+// reviewAccepted refreshes operation authority and produces the complete
+// outcome required to execute one accepted upload review.
+func (m *uploadModule) reviewAccepted(ctx context.Context, input api.UploadReviewInput) (api.ReviewedUpload, error) {
+	evidence, err := m.refreshUploadReviewAuthority(ctx, input)
 	if err != nil {
-		return api.UploadReview{}, fmt.Errorf("core: %w", err)
-	}
-	uniquePaths := make([]string, 0, len(normalizedPaths))
-	seenPaths := make(map[string]struct{}, len(normalizedPaths))
-	for _, path := range normalizedPaths {
-		if _, exists := seenPaths[path]; exists {
-			continue
-		}
-		seenPaths[path] = struct{}{}
-		uniquePaths = append(uniquePaths, path)
-	}
-	if len(uniquePaths) != 1 {
-		return api.UploadReview{}, internalerrors.ErrInvalidInput
+		return api.ReviewedUpload{}, err
 	}
-
-	options, err := c.applyDefaultOptions(req.Options)
+	preview, err := m.buildTrackerPayloadPreview(ctx, input, trackerspkg.PreparationIntentUploadReview, evidence)
 	if err != nil {
-		return api.UploadReview{}, err
+		return api.ReviewedUpload{}, err
+	}
+	if len(preview.outcome.Eligibility.EligibleTrackers) == 0 {
+		return api.ReviewedUpload{}, noEligibleTrackersError(api.OperationKindUploadReview)
 	}
+	return api.ReviewedUpload{Review: preview.review, Outcome: preview.outcome}, nil
+}
 
-	singleReq := req
-	singleReq.Paths = []string{uniquePaths[0]}
-	singleReq.Options = options
-	singleReq.ExternalIDOverrides = mergeExternalIDOverrides(req.ExternalIDOverrides, resolveExternalIDSelection(req.ExternalIDSelections, uniquePaths[0]))
+// trackerPayloadPreview contains the payload projection shared by upload review
+// and explicit dry-run execution. It retains the base torrent only long enough
+// for optional dry-run client injection.
+type trackerPayloadPreview struct {
+	subject api.UploadSubject
+	review  api.UploadReview
+	outcome api.UploadReviewOutcome
+	torrent api.TorrentResult
+}
 
-	signature := overrideSignature(singleReq.ExternalIDOverrides, singleReq.ReleaseNameOverrides, singleReq.MetadataOverrides, singleReq.TrackerConfigOverrides, singleReq.TrackerSiteOverrides, singleReq.ClientOverrides, singleReq.TorrentOverrides, singleReq.ImageHostOverrides, singleReq.ScreenshotOverrides)
-	var (
-		baseMeta                api.PreparedMetadata
-		baseMetaOK              bool
-		cachedDryRunDupeSummary api.DupeCheckSummary
-		meta                    api.PreparedMetadata
-		ok                      bool
-	)
-	if req.Mode == api.ModeGUI {
-		entry, _, found := c.lookupGUICachedMetaEntry(singleReq, uniquePaths[0])
-		if found {
-			ok = true
-			entryMatchesRequest := entry.requestRefreshed && cachedPreparedMetaMatchesRequest(entry.meta, singleReq, uniquePaths[0])
-			baseMetaOK = !entry.requestRefreshed || entryMatchesRequest
-			if baseMetaOK {
-				baseMeta = deepCopyPreparedMetadata(entry.meta)
-			}
-			if entryMatchesRequest {
-				meta = deepCopyPreparedMetadata(entry.meta)
-			} else {
-				meta, err = c.applyRequestToCachedPreparedMeta(ctx, entry.meta, singleReq)
-				if err != nil {
-					return api.UploadReview{}, err
-				}
-			}
-		}
-	} else {
-		entry, _, found := c.lookupGUICachedMetaEntry(singleReq, uniquePaths[0])
-		if found {
-			ok = true
-			if entry.requestRefreshed && cachedDupeSummaryMatchesRequest(entry.meta, singleReq, uniquePaths[0]) {
-				cachedDryRunDupeSummary = deepCopyDupeCheckSummary(entry.dupeSummary)
-			}
-			meta, err = c.applyRequestToCachedPreparedMeta(ctx, entry.meta, singleReq)
-			if err != nil {
-				return api.UploadReview{}, err
-			}
-		}
-	}
-	if !ok {
-		return api.UploadReview{}, fmt.Errorf("core: upload review requires prepared metadata for %s", uniquePaths[0])
-	}
+// trackerPayloadEvidence contains accepted authority results consumed by
+// payload construction. Building payloads never refreshes client or duplicate
+// evidence.
+type trackerPayloadEvidence struct {
+	subject          api.UploadSubject
+	resolvedTrackers []string
+	outcome          api.UploadReviewOutcome
+	duplicateResults []api.DupeCheckResult
+}
 
-	resolvedTrackers, explicitEmpty := c.resolveUploadReviewTrackers(singleReq, meta)
-	if explicitEmpty {
-		return api.UploadReview{
-			SourcePath: meta.SourcePath,
-			Trackers:   []api.TrackerReview{},
-		}, nil
+// refreshUploadReviewAuthority refreshes policy and remote duplicate state
+// immediately before final upload review. Client evidence is generation-owned.
+func (m *uploadModule) refreshUploadReviewAuthority(
+	ctx context.Context,
+	input api.UploadReviewInput,
+) (trackerPayloadEvidence, error) {
+	if m == nil || m.dupes == nil {
+		return trackerPayloadEvidence{}, errors.New("core: upload review duplicate service is not configured")
 	}
-	meta, err = c.resolveUploadReviewPTBRMetadata(ctx, meta, resolvedTrackers)
+	subject, resolvedTrackers, err := m.resolveTrackerPayloadSubject(ctx, input, api.OperationKindUploadReview)
 	if err != nil {
-		return api.UploadReview{}, err
-	}
-
-	dupeResults := make(map[string]api.DupeCheckResult)
-	if singleReq.SkipDupeCheck {
-		meta.BlockedTrackers = removeTrackerDupeBlockReason(cloneBlockedTrackers(meta.BlockedTrackers))
-		meta.CrossSeedTorrents = nil
-		for _, tracker := range resolvedTrackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name == "" {
-				continue
-			}
-			dupeResults[name] = api.DupeCheckResult{
-				Tracker:    name,
-				Status:     "skipped",
-				Skipped:    true,
-				SkipReason: "dupe check skipped",
-			}
-		}
-	} else {
-		var summary api.DupeCheckSummary
-		if dryRunDupeSummaryCoversTrackers(cachedDryRunDupeSummary, singleReq, resolvedTrackers) {
-			summary = cachedDryRunDupeSummary
-		} else {
-			summary, err = c.services.Dupes.Check(ctx, meta, resolvedTrackers)
-			if err != nil {
-				return api.UploadReview{}, fmt.Errorf("core: %w", err)
-			}
-			summary = appendPathedDupeResults(summary, meta.MatchedTrackers)
-		}
-		applyDupeSummaryToPreparedMeta(&meta, summary)
-		meta.BlockedTrackers = removeTrackerBlockReasonForTrackers(meta.BlockedTrackers, api.TrackerBlockReasonDupe, singleReq.IgnoreDupesFor)
-		meta.CrossSeedTorrents = removeCrossSeedTorrentsForTrackers(meta.CrossSeedTorrents, singleReq.IgnoreDupesFor)
-		dupeResults = mapDupeResults(summary.Results)
-	}
-	var cacheCommit func()
-	if req.Mode == api.ModeGUI && cacheableGUIPreparedMetaRequest(singleReq) {
-		if len(singleReq.Trackers) > 0 {
-			if baseMetaOK {
-				cacheMeta := mergeUploadReviewCacheMeta(baseMeta, meta, resolvedTrackers)
-				cacheCommit = func() {
-					c.storeDupeCache(uniquePaths[0], signature, cacheMeta)
-				}
-			}
-		} else {
-			cacheMeta := deepCopyPreparedMetadata(meta)
-			cacheCommit = func() {
-				c.storeRefreshedDupeCache(uniquePaths[0], signature, cacheMeta)
-			}
-		}
+		return trackerPayloadEvidence{}, err
 	}
+	applyTrackerIDOverrides(&subject, input.TrackerIDOverrides)
 
-	dryRunMeta := trackerDryRunProcessingMeta(meta, singleReq)
-	torrent, err := c.services.Torrents.Create(ctx, dryRunMeta)
+	policy, err := m.evaluateTrackerPayloadPolicy(ctx, subject, resolvedTrackers)
 	if err != nil {
-		return api.UploadReview{}, fmt.Errorf("core: %w", err)
+		return trackerPayloadEvidence{}, err
 	}
-	dryRunMeta.TorrentPath = torrent.Path
 
-	dryRunEntries, err := c.services.Trackers.BuildUploadDryRun(ctx, dryRunMeta, resolvedTrackers)
+	if err := trackerspkg.ValidateRuleAuthorizations(resolvedTrackers, policy.TrackerRuleFailures, input.RuleAuthorizations); err != nil {
+		return trackerPayloadEvidence{}, fmt.Errorf("core: rule authorization: %w", err)
+	}
+	duplicate := duplicateSubjectFromUpload(subject)
+	duplicate.MatchedTrackers = append([]string(nil), subject.MatchedTrackers...)
+	duplicate.BlockedTrackers = cloneBlockedTrackers(policy.BlockedTrackers)
+	summary, assessment, err := checkDuplicateAssessment(ctx, m.dupes, duplicate, resolvedTrackers, dupechecking.CheckOptions{
+		SkipRemote: input.SkipDuplicateCheck,
+	})
 	if err != nil {
-		return api.UploadReview{}, fmt.Errorf("core: %w", err)
+		return trackerPayloadEvidence{}, fmt.Errorf("core: %w", err)
 	}
-	annotateDryRunReleaseNames(dryRunMeta, dryRunEntries)
-	dryRunByTracker := make(map[string]api.TrackerDryRunEntry, len(dryRunEntries))
-	for _, entry := range dryRunEntries {
-		name := strings.ToUpper(strings.TrimSpace(entry.Tracker))
-		if name == "" {
-			continue
+	if len(input.IgnoreDupesFor) > 0 {
+		assessment, err = assessment.Authorize(duplicate, m.cfg, input.IgnoreDupesFor)
+		if err != nil {
+			return trackerPayloadEvidence{}, fmt.Errorf("core: duplicate authorization: %w", err)
 		}
-		dryRunByTracker[name] = entry
 	}
+	assessment.Apply(&duplicate)
 
-	reviews := make([]api.TrackerReview, 0, len(resolvedTrackers))
-	for _, tracker := range resolvedTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-
-		review := api.TrackerReview{
-			Tracker:      name,
-			RuleFailures: cloneRuleFailures(meta.TrackerRuleFailures[name]),
-			DupeCheck:    dupeResults[name],
-			DryRun:       dryRunByTracker[name],
-		}
-		if review.DryRun.Tracker == "" {
-			review.DryRun.Tracker = name
-		}
-		review.Banned = review.DryRun.Banned
-		review.BannedReason = review.DryRun.BannedReason
-		if reasons := meta.BlockedTrackers[name]; len(reasons) > 0 {
-			review.DryRun.Status = "blocked"
-			review.DryRun.Message = "tracker blocked: " + formatBlockedReasons(reasons)
-		} else if bannedCheckError := strings.TrimSpace(review.DryRun.BannedCheckError); bannedCheckError != "" {
-			review.DryRun.Status = "blocked"
-			review.DryRun.Message = bannedCheckError
-		}
-		review.Questionnaire = review.DryRun.Questionnaire
-
-		reviews = append(reviews, review)
+	outcome := api.UploadReviewOutcome{
+		ResolvedTrackers:    append([]string(nil), resolvedTrackers...),
+		MatchedTrackers:     append([]string(nil), subject.MatchedTrackers...),
+		BlockedTrackers:     cloneBlockedTrackers(duplicate.BlockedTrackers),
+		TrackerRuleFailures: cloneTrackerRuleFailures(policy.TrackerRuleFailures),
+		CrossSeedTorrents:   append([]api.UploadedTorrent(nil), duplicate.CrossSeedTorrents...),
 	}
-
-	if cacheCommit != nil {
-		cacheCommit()
-	}
-
-	return api.UploadReview{
-		SourcePath: meta.SourcePath,
-		Trackers:   reviews,
+	return trackerPayloadEvidence{
+		subject:          subject,
+		resolvedTrackers: append([]string(nil), resolvedTrackers...),
+		outcome:          outcome,
+		duplicateResults: api.CloneDupeCheckResults(summary.Results),
 	}, nil
 }
 
-// resolveUploadReviewTrackers applies GUI replacement semantics while allowing
-// non-debug, non-GUI review flows to include or fall back to configured defaults
-// unless site upload pins one tracker.
-func (c *Core) resolveUploadReviewTrackers(req api.Request, meta api.PreparedMetadata) ([]string, bool) {
-	includeDefaults := req.Mode != api.ModeGUI && strings.TrimSpace(req.Execution.SiteUploadTracker) == "" && !req.Options.Debug
-	remove := trackerResolutionRemoveForRequest(meta, req)
-	if req.Mode == api.ModeGUI && len(req.Trackers) > 0 && len(meta.MatchedTrackers) > 0 {
-		reviewedMatchedTrackers := make([]string, 0, len(req.Trackers))
-		for _, tracker := range req.Trackers {
-			if containsTrackerName(meta.MatchedTrackers, tracker) {
-				reviewedMatchedTrackers = append(reviewedMatchedTrackers, tracker)
-			}
-		}
-		remove = removeReviewedTrackerNames(remove, reviewedMatchedTrackers)
-		remove = mergeTrackerRemovals(remove, req.TrackersRemove)
-	}
-	return resolveTrackersPreservingExplicitEmpty(c.cfg, req.Trackers, remove, c.logger, includeDefaults, includeDefaults)
-}
-
-// resolveUploadReviewPTBRMetadata refreshes localized TMDB metadata after review
-// tracker resolution when selected or default tracker targets require pt-BR data.
-func (c *Core) resolveUploadReviewPTBRMetadata(ctx context.Context, meta api.PreparedMetadata, resolvedTrackers []string) (api.PreparedMetadata, error) {
-	if c.services.Metadata == nil || !uploadReviewNeedsPTBRMetadata(meta, resolvedTrackers) {
-		return meta, nil
-	}
-	refreshMeta := deepCopyPreparedMetadata(meta)
-	refreshMeta.Trackers = append([]string(nil), resolvedTrackers...)
-	refreshed, err := c.services.Metadata.ResolveExternalIDs(ctx, refreshMeta)
+// acceptedDryRunEvidence resolves exact prepared facts and combines them with
+// caller-accepted duplicate results without client discovery or another remote
+// duplicate check.
+func (m *uploadModule) acceptedDryRunEvidence(ctx context.Context, plan api.TrackerDryRunPlan) (trackerPayloadEvidence, error) {
+	input := trackerDryRunReviewInput(plan.Input)
+	subject, resolvedTrackers, err := m.resolveTrackerPayloadSubject(ctx, input, api.OperationKindDryRun)
 	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("core: %w", err)
-	}
-	return refreshed, nil
-}
-
-// uploadReviewNeedsPTBRMetadata reports whether a review dry-run needs a pt-BR refresh.
-func uploadReviewNeedsPTBRMetadata(meta api.PreparedMetadata, resolvedTrackers []string) bool {
-	if !hasPTBRTracker(resolvedTrackers) || hasLocalizedPTBR(meta) {
-		return false
+		return trackerPayloadEvidence{}, err
 	}
-	return hasKnownTMDBID(meta)
-}
-
-// hasPTBRTracker reports whether any tracker consumes localized pt-BR TMDB data.
-func hasPTBRTracker(trackers []string) bool {
-	return trackerspkg.AnyNeedsPTBRLocalizedMetadata(trackers)
-}
-
-// hasLocalizedPTBR reports whether TMDB metadata already contains complete pt-BR localized data.
-func hasLocalizedPTBR(meta api.PreparedMetadata) bool {
-	if meta.ExternalMetadata.TMDB == nil || meta.ExternalMetadata.TMDB.Localized == nil {
-		return false
-	}
-	localized, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]
-	return ok && localizedPTBRComplete(meta, localized)
-}
-
-// hasKnownTMDBID reports whether metadata has a source-current TMDB ID available for refresh.
-func hasKnownTMDBID(meta api.PreparedMetadata) bool {
-	if meta.StoredDataFresh && strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.SourcePath), strings.TrimSpace(meta.SourcePath)) && meta.ExternalIDs.TMDBID != 0 {
-		return true
-	}
-	if meta.StoredDataFresh &&
-		strings.EqualFold(strings.TrimSpace(meta.ExternalMetadata.SourcePath), strings.TrimSpace(meta.SourcePath)) &&
-		meta.ExternalMetadata.TMDB != nil &&
-		meta.ExternalMetadata.TMDB.TMDBID != 0 {
-		return true
+	results, err := validateAcceptedDuplicateEvidence(plan.Duplicate, plan.Input.Release, resolvedTrackers)
+	if err != nil {
+		return trackerPayloadEvidence{}, err
 	}
-	return meta.MediaInfoTMDBID != 0 || meta.SceneTMDBID != 0 || meta.ArrTMDBID != 0
+	applyTrackerIDOverrides(&subject, input.TrackerIDOverrides)
+	policy, err := m.evaluateTrackerPayloadPolicy(ctx, subject, resolvedTrackers)
+	if err != nil {
+		return trackerPayloadEvidence{}, err
+	}
+	outcome := api.UploadReviewOutcome{
+		ResolvedTrackers:    append([]string(nil), resolvedTrackers...),
+		MatchedTrackers:     append([]string(nil), subject.MatchedTrackers...),
+		BlockedTrackers:     cloneBlockedTrackers(policy.BlockedTrackers),
+		TrackerRuleFailures: cloneTrackerRuleFailures(policy.TrackerRuleFailures),
+	}
+	return trackerPayloadEvidence{
+		subject:          subject,
+		resolvedTrackers: append([]string(nil), resolvedTrackers...),
+		outcome:          outcome,
+		duplicateResults: results,
+	}, nil
 }
 
-// localizedPTBRComplete reports whether review metadata has the pt-BR title,
-// genre, and overview fields needed to avoid another localized refresh for
-// selected upload trackers.
-func localizedPTBRComplete(meta api.PreparedMetadata, localized api.TMDBLocalizedData) bool {
-	if strings.TrimSpace(localized.Title) == "" || strings.TrimSpace(localized.Genres) == "" {
-		return false
+func (m *uploadModule) resolveTrackerPayloadSubject(
+	ctx context.Context,
+	input api.UploadReviewInput,
+	operation api.OperationKind,
+) (api.UploadSubject, []string, error) {
+	if m == nil || m.preparedFacts == nil {
+		return api.UploadSubject{}, nil, errors.New("core: canonical preparation is not configured")
 	}
-	if localizedPTBRNeedsScopedOverview(meta) {
-		return strings.TrimSpace(localized.EpisodeOverview) != ""
+	if m.torrents == nil || m.trackers == nil {
+		return api.UploadSubject{}, nil, errors.New("core: tracker payload services are not configured")
 	}
-	return strings.TrimSpace(localized.Overview) != ""
-}
-
-func localizedPTBRNeedsScopedOverview(meta api.PreparedMetadata) bool {
-	if !localizedPTBRIsTV(meta) {
-		return false
-	}
-	if meta.SeasonInt > 0 || meta.EpisodeInt > 0 || meta.TVPack {
-		return true
+	subject, err := m.preparedFacts.ResolveUploadSubject(ctx, input)
+	if err != nil {
+		return api.UploadSubject{}, nil, fmt.Errorf("core: resolve tracker payload subject: %w", err)
 	}
-	return strings.TrimSpace(meta.SeasonStr) != "" ||
-		strings.TrimSpace(meta.EpisodeStr) != "" ||
-		strings.TrimSpace(meta.DailyEpisodeDate) != ""
-}
-
-func localizedPTBRIsTV(meta api.PreparedMetadata) bool {
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV") {
-		return true
+	logger := logging.FromContext(ctx, m.logger)
+	resolvedTrackers := trackerspkg.ResolveExplicitTrackersWithRegistry(input.Trackers, logger, m.registry)
+	if len(resolvedTrackers) == 0 {
+		return api.UploadSubject{}, nil, noEligibleTrackersError(operation)
 	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.EqualFold(strings.TrimSpace(meta.ExternalMetadata.TMDB.Category), "TV")
+	subject.Trackers = append([]string(nil), resolvedTrackers...)
+	if err := m.hydrateCanonicalTrackerState(ctx, &subject); err != nil {
+		return api.UploadSubject{}, nil, err
 	}
-	return false
+	return subject, resolvedTrackers, nil
 }
 
-func formatBlockedReasons(reasons []api.TrackerBlockReason) string {
-	if len(reasons) == 0 {
-		return "blocked"
-	}
-
-	labels := make([]string, 0, len(reasons))
-	seen := make(map[api.TrackerBlockReason]struct{}, len(reasons))
-	for _, reason := range reasons {
-		if _, ok := seen[reason]; ok {
-			continue
+func (m *uploadModule) evaluateTrackerPayloadPolicy(
+	ctx context.Context,
+	subject api.UploadSubject,
+	resolvedTrackers []string,
+) (api.UploadReviewOutcome, error) {
+	policy := api.UploadReviewOutcome{ResolvedTrackers: append([]string(nil), resolvedTrackers...)}
+	var err error
+	if m.policy != nil {
+		policy, err = m.policy.EvaluateUploadPolicy(ctx, subject, resolvedTrackers)
+		if err != nil {
+			return api.UploadReviewOutcome{}, fmt.Errorf("core: upload policy: %w", err)
 		}
-		seen[reason] = struct{}{}
-		label := strings.TrimSpace(string(reason))
-		if label != "" {
-			labels = append(labels, label)
+	} else {
+		policy.TrackerRuleFailures, err = evaluateSubjectRules(ctx, m.registry, subject, resolvedTrackers, logging.FromContext(ctx, m.logger))
+		if err != nil {
+			return api.UploadReviewOutcome{}, err
 		}
 	}
-	if len(labels) == 0 {
-		return "blocked"
-	}
-	return strings.Join(labels, ", ")
+	return policy, nil
 }
 
-func applyRequestToPreparedMeta(meta api.PreparedMetadata, req api.Request, cfg config.Config, logger api.Logger) api.PreparedMetadata {
-	return applyRequestToPreparedMetaWithDerivedFields(meta, req, cfg, logger, true)
-}
-
-func applyRequestToPreparedMetaBeforeRefresh(meta api.PreparedMetadata, req api.Request, cfg config.Config, logger api.Logger) api.PreparedMetadata {
-	return applyRequestToPreparedMetaWithDerivedFields(meta, req, cfg, logger, false)
-}
-
-func applyRequestToPreparedMetaWithDerivedFields(meta api.PreparedMetadata, req api.Request, cfg config.Config, logger api.Logger, rebuildDerivedFields bool) api.PreparedMetadata {
-	meta = deepCopyPreparedMetadata(meta)
-	existingTrackerIDs := cloneStringMap(meta.TrackerIDs)
-	existingTrackersRemove, existingMatchedTrackers := duplicateTrackerStateForRequest(meta, req)
-	meta.Mode = req.Mode
-	meta.Options = req.Options
-	meta.Paths = append([]string{}, req.Paths...)
-	if req.DescriptionGroups != nil {
-		meta.DescriptionGroups = api.CloneDescriptionBuilderGroups(req.DescriptionGroups)
+func applyTrackerIDOverrides(subject *api.UploadSubject, overrides map[string]string) {
+	if subject == nil || len(overrides) == 0 {
+		return
 	}
-	meta.Trackers = append([]string{}, req.Trackers...)
-	meta.MatchedTrackers = existingMatchedTrackers
-	meta.TrackersRemove = mergeTrackerRemovals(req.TrackersRemove, existingTrackersRemove)
-	meta.TrackersRemove = mergeTrackerRemovals(meta.TrackersRemove, existingMatchedTrackers)
-	meta.TrackerIDs = mergeTrackerIDOverrides(existingTrackerIDs, req.TrackerIDOverrides)
-	meta.DescriptionOverride = strings.TrimSpace(req.DescriptionOverrideRaw)
-	meta.MetadataOverrides = req.MetadataOverrides
-	meta.TrackerConfigOverrides = req.TrackerConfigOverrides
-	meta.TrackerSiteOverrides = req.TrackerSiteOverrides
-	meta.ClientOverrides = req.ClientOverrides
-	meta.ImageHostOverrides = req.ImageHostOverrides
-	meta.ScreenshotOverrides = req.ScreenshotOverrides
-	meta.TorrentOverrides = req.TorrentOverrides
-	meta.BlockedTrackers = cloneBlockedTrackers(meta.BlockedTrackers)
-	meta.IgnoreTrackerRuleFailures = req.IgnoreTrackerRuleFailures
-	meta.ExternalIDOverrides = req.ExternalIDOverrides
-	meta.ReleaseNameOverrides = req.ReleaseNameOverrides
-	meta.TrackerQuestionnaireAnswers = cloneTrackerQuestionnaireAnswers(req.TrackerQuestionnaireAnswers)
-	applyMetadataOverridesToPreparedMeta(&meta)
-	if rebuildDerivedFields {
-		metadata.ApplyRequestScopedAudioPolicy(&meta, cfg, logger)
-		metadata.RebuildReleaseName(&meta, logger)
+	if subject.TrackerIDs == nil {
+		subject.TrackerIDs = make(map[string]string)
 	}
-	applyTorrentOverridesToPreparedMeta(&meta)
-	meta.TrackerRuleFailures = filterTrackerRuleFailures(meta.TrackerRuleFailures, req.IgnoreTrackerRuleFailuresFor)
-	if req.SkipDupeCheck {
-		meta.BlockedTrackers = removeTrackerDupeBlockReason(meta.BlockedTrackers)
-		meta.CrossSeedTorrents = nil
-	} else if len(req.IgnoreDupesFor) > 0 {
-		meta.BlockedTrackers = removeTrackerBlockReasonForTrackers(meta.BlockedTrackers, api.TrackerBlockReasonDupe, req.IgnoreDupesFor)
-		meta.CrossSeedTorrents = removeCrossSeedTorrentsForTrackers(meta.CrossSeedTorrents, req.IgnoreDupesFor)
+	for key, value := range overrides {
+		key = strings.ToLower(strings.TrimSpace(key))
+		value = strings.TrimSpace(value)
+		if key != "" && value != "" {
+			subject.TrackerIDs[key] = value
+		}
+	}
+}
+
+func validateAcceptedDuplicateEvidence(
+	evidence api.AcceptedDuplicateEvidence,
+	release api.ReleaseRef,
+	resolvedTrackers []string,
+) ([]api.DupeCheckResult, error) {
+	if evidence.Release != release {
+		return nil, dryRunEvidenceError(
+			api.OperationFailureStaleGeneration,
+			"Duplicate-check results are stale. Run duplicate checking again.",
+			errors.New("duplicate evidence release does not match dry-run release"),
+		)
+	}
+	evidenceTrackers := normalizeReviewedTrackers(evidence.Trackers)
+	if !slices.Equal(evidenceTrackers, resolvedTrackers) {
+		return nil, dryRunEvidenceError(
+			api.OperationFailureMissingPrerequisite,
+			"Duplicate-check results do not match the selected trackers. Run duplicate checking again.",
+			errors.New("duplicate evidence tracker selection does not match dry-run selection"),
+		)
+	}
+	selected := reviewedTrackerSet(resolvedTrackers)
+	results := make(map[string]api.DupeCheckResult, len(evidence.Results))
+	for _, raw := range api.CloneDupeCheckResults(evidence.Results) {
+		name := normalizeEligibilityTracker(raw.Tracker)
+		if name == "" {
+			return nil, dryRunEvidenceError(
+				api.OperationFailureMissingPrerequisite,
+				"Duplicate-check results are incomplete. Run duplicate checking again.",
+				errors.New("duplicate evidence contains an unnamed tracker result"),
+			)
+		}
+		if _, ok := selected[name]; !ok {
+			return nil, dryRunEvidenceError(
+				api.OperationFailureMissingPrerequisite,
+				"Duplicate-check results do not match the selected trackers. Run duplicate checking again.",
+				fmt.Errorf("duplicate evidence contains unselected tracker %s", name),
+			)
+		}
+		if _, exists := results[name]; exists || !terminalDuplicateResult(raw) {
+			return nil, dryRunEvidenceError(
+				api.OperationFailureMissingPrerequisite,
+				"Duplicate-check results are incomplete. Run duplicate checking again.",
+				fmt.Errorf("duplicate evidence result is duplicate or incomplete for tracker %s", name),
+			)
+		}
+		raw.Tracker = name
+		results[name] = raw
+	}
+	ordered := make([]api.DupeCheckResult, 0, len(resolvedTrackers))
+	for _, tracker := range resolvedTrackers {
+		result, ok := results[tracker]
+		if !ok {
+			return nil, dryRunEvidenceError(
+				api.OperationFailureMissingPrerequisite,
+				"Duplicate-check results are incomplete. Run duplicate checking again.",
+				fmt.Errorf("duplicate evidence is missing tracker %s", tracker),
+			)
+		}
+		ordered = append(ordered, result)
 	}
-	return meta
+	return ordered, nil
 }
 
-// duplicateTrackerStateForRequest returns cached duplicate removal state after
-// applying the request's dupe bypass semantics. Ignored or skipped matched
-// trackers are removed from suppression state before later tracker resolution.
-func duplicateTrackerStateForRequest(meta api.PreparedMetadata, req api.Request) ([]string, []string) {
-	remove := append([]string(nil), meta.TrackersRemove...)
-	matched := append([]string(nil), meta.MatchedTrackers...)
-	if req.SkipDupeCheck {
-		return removeReviewedTrackerNames(remove, matched), nil
+func terminalDuplicateResult(result api.DupeCheckResult) bool {
+	if result.Skipped || strings.TrimSpace(result.Error) != "" {
+		return true
 	}
-	if len(req.IgnoreDupesFor) > 0 {
-		return removeReviewedTrackerNames(remove, req.IgnoreDupesFor), removeReviewedTrackerNames(matched, req.IgnoreDupesFor)
+	switch strings.ToLower(strings.TrimSpace(result.Status)) {
+	case "completed", "skipped", "failed":
+		return true
+	default:
+		return false
 	}
-	return remove, matched
 }
 
-func mergeTrackerIDOverrides(existing map[string]string, overrides map[string]string) map[string]string {
-	normalizedExisting := make(map[string]string, len(existing))
-	for key, value := range existing {
-		trimmedKey := strings.ToLower(strings.TrimSpace(key))
-		trimmedValue := strings.TrimSpace(value)
-		if trimmedKey == "" || trimmedValue == "" {
-			continue
-		}
-		normalizedExisting[trimmedKey] = trimmedValue
-	}
-
-	merged := cloneStringMap(normalizedExisting)
-	if merged == nil {
-		merged = make(map[string]string)
+func dryRunEvidenceError(code api.OperationFailureCode, message string, cause error) error {
+	return api.NewOperationError(api.OperationFailure{
+		Code:      code,
+		Operation: api.OperationKindDryRun,
+		Message:   message,
+		Recovery:  api.OperationRecoveryCompletePrerequisite,
+	}, cause)
+}
+
+// buildTrackerPayloadPreview constructs tracker payloads and eligibility from
+// accepted evidence. It never performs client discovery or remote duplicate
+// checking.
+func (m *uploadModule) buildTrackerPayloadPreview(
+	ctx context.Context,
+	input api.UploadReviewInput,
+	previewIntent trackerspkg.PreparationIntent,
+	evidence trackerPayloadEvidence,
+) (trackerPayloadPreview, error) {
+	subject := evidence.subject
+	resolvedTrackers := evidence.resolvedTrackers
+	outcome := evidence.outcome
+	var err error
+	subject.MatchedTrackers = append([]string(nil), outcome.MatchedTrackers...)
+	subject.BlockedTrackers = cloneBlockedTrackers(outcome.BlockedTrackers)
+	subject.TrackerRuleFailures = cloneTrackerRuleFailures(outcome.TrackerRuleFailures)
+	subject.CrossSeedTorrents = append([]api.UploadedTorrent(nil), outcome.CrossSeedTorrents...)
+	if m.resolveSubjectGroups == nil {
+		return trackerPayloadPreview{}, errors.New("core: subject description resolver not configured")
+	}
+	subject.DescriptionGroups, err = m.resolveSubjectGroups(ctx, subject, input)
+	if err != nil {
+		return trackerPayloadPreview{}, err
 	}
-	for key, value := range overrides {
-		trimmedKey := strings.ToLower(strings.TrimSpace(key))
-		trimmedValue := strings.TrimSpace(value)
-		if trimmedKey == "" || trimmedValue == "" {
-			continue
-		}
-		merged[trimmedKey] = trimmedValue
+	torrent, err := m.torrents.Create(ctx, torrentSubjectFromUpload(subject, input))
+	if err != nil {
+		return trackerPayloadPreview{}, fmt.Errorf("core: %w", err)
+	}
+	subject.TorrentPath = torrent.Path
+	var dryRuns []api.TrackerDryRunEntry
+	switch previewIntent {
+	case trackerspkg.PreparationIntentDryRun:
+		dryRuns, err = m.trackers.BuildUploadDryRun(ctx, subject, resolvedTrackers)
+	case trackerspkg.PreparationIntentUploadReview:
+		dryRuns, err = m.trackers.BuildUploadReview(ctx, subject, resolvedTrackers)
+	case trackerspkg.PreparationIntentDescriptionPreview, trackerspkg.PreparationIntentUpload:
+		return trackerPayloadPreview{}, fmt.Errorf("core: unsupported tracker payload intent %q", previewIntent)
 	}
-	if len(merged) == 0 {
-		return nil
+	if err != nil {
+		return trackerPayloadPreview{}, fmt.Errorf("core: %w", err)
 	}
-	return merged
-}
-
-func (c *Core) applyRequestToCachedPreparedMeta(ctx context.Context, meta api.PreparedMetadata, req api.Request) (api.PreparedMetadata, error) {
-	if c.services.Metadata == nil {
-		meta = applyRequestToPreparedMeta(meta, req, c.cfg, c.logger)
-		return meta, nil
+	annotateDryRunSubjectReleaseNames(subject, dryRuns)
+	dryRunByTracker := make(map[string]api.TrackerDryRunEntry, len(dryRuns))
+	for _, entry := range dryRuns {
+		if name := strings.ToUpper(strings.TrimSpace(entry.Tracker)); name != "" {
+			dryRunByTracker[name] = entry
+		}
 	}
-	meta = applyRequestToPreparedMetaBeforeRefresh(meta, req, c.cfg, c.logger)
-	refreshed, err := c.services.Metadata.RefreshPreparedMetadata(ctx, meta)
+	dupeResults := mapDupeResults(evidence.duplicateResults)
+	reviews := make([]api.TrackerReview, 0, len(resolvedTrackers))
+	eligibilityAssessments := make([]api.TrackerEligibilityAssessment, 0, len(resolvedTrackers))
+	for _, tracker := range resolvedTrackers {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		review := api.TrackerReview{
+			Tracker:      name,
+			RuleFailures: cloneRuleFailures(outcome.TrackerRuleFailures[name]),
+			DupeCheck:    dupeResults[name],
+			DryRun:       dryRunByTracker[name],
+		}
+		if review.DryRun.Tracker == "" {
+			review.DryRun.Tracker = name
+		}
+		review.Banned = review.DryRun.Banned
+		review.BannedReason = review.DryRun.BannedReason
+		review.Questionnaire = review.DryRun.Questionnaire
+		reviews = append(reviews, review)
+		authorizedRules, authorizationErr := trackerspkg.AuthorizedRulesForTracker(input.RuleAuthorizations, name)
+		if authorizationErr != nil {
+			return trackerPayloadPreview{}, fmt.Errorf("core: rule authorization: %w", authorizationErr)
+		}
+		eligibilityAssessments = append(eligibilityAssessments, api.TrackerEligibilityAssessment{
+			Tracker:        name,
+			Duplicate:      review.DupeCheck,
+			RuleFailures:   cloneRuleFailures(review.RuleFailures),
+			PolicyBlocks:   append([]api.TrackerBlockReason(nil), outcome.BlockedTrackers[name]...),
+			AuthRequired:   review.DupeCheck.SkipCode == dupeSkipCodeTrackerAuthNotReady,
+			Banned:         review.Banned,
+			BannedReason:   review.BannedReason,
+			ContentFailure: cloneTrackerContentFailure(review.DryRun.ContentFailure),
+			Choices: api.TrackerReviewChoices{
+				IgnoreDuplicate:        containsNormalizedTracker(input.IgnoreDupesFor, name),
+				AuthorizedRuleFailures: authorizedRules,
+			},
+		})
+	}
+	eligibility, err := buildTrackerEligibility(api.TrackerEligibilityInput{
+		Release:          input.Release,
+		SelectedTrackers: resolvedTrackers,
+		Assessments:      eligibilityAssessments,
+	})
 	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("core: %w", err)
-	}
-	refreshed.TrackerRuleFailures = filterTrackerRuleFailures(refreshed.TrackerRuleFailures, req.IgnoreTrackerRuleFailuresFor)
-	return refreshed, nil
+		return trackerPayloadPreview{}, err
+	}
+	if err := persistTrackerRuleDecisions(ctx, m.trackerRepo, subject.SourcePath, eligibility); err != nil {
+		return trackerPayloadPreview{}, err
+	}
+	logTrackerEligibility(ctx, m.logger, string(previewIntent), eligibility)
+	outcome.Eligibility = eligibility
+	return trackerPayloadPreview{
+		subject: subject,
+		review: api.UploadReview{
+			SourcePath:  subject.SourcePath,
+			Trackers:    reviews,
+			Eligibility: eligibility,
+		},
+		outcome: outcome,
+		torrent: torrent,
+	}, nil
 }
 
-func applyMetadataOverridesToPreparedMeta(meta *api.PreparedMetadata) {
-	if meta == nil {
-		return
-	}
-
-	overrides := meta.MetadataOverrides
-	if overrides.Distributor != nil {
-		meta.Distributor = strings.TrimSpace(*overrides.Distributor)
-	}
-	applyOriginalLanguageOverrideToPreparedMeta(meta, overrides.OriginalLanguage)
-	if overrides.PersonalRelease != nil {
-		meta.PersonalRelease = *overrides.PersonalRelease
-	}
-	if overrides.Commentary != nil {
-		meta.HasCommentary = *overrides.Commentary
-	}
-	if overrides.WebDV != nil {
-		meta.WebDV = *overrides.WebDV
+// persistTrackerRuleDecisions atomically replaces each selected tracker's
+// stored rule evidence with Core's canonical authorization decisions.
+func persistTrackerRuleDecisions(
+	ctx context.Context,
+	repo api.TrackerStateRepository,
+	sourcePath string,
+	eligibility api.TrackerEligibility,
+) error {
+	if repo == nil {
+		return nil
 	}
-	if overrides.StreamOptimized != nil {
-		if *overrides.StreamOptimized {
-			meta.StreamOptimized = 1
-		} else {
-			meta.StreamOptimized = 0
+	for _, state := range eligibility.Trackers {
+		failures := make([]api.TrackerRuleFailure, 0, len(state.RuleDecisions))
+		for _, decision := range state.RuleDecisions {
+			failures = append(failures, api.TrackerRuleFailure{
+				SourcePath:  sourcePath,
+				Tracker:     state.Tracker,
+				Rule:        decision.Rule,
+				Reason:      decision.Reason,
+				Disposition: decision.Disposition,
+				Authorized:  decision.Authorized,
+			})
+		}
+		if err := repo.SaveTrackerRuleFailures(ctx, sourcePath, state.Tracker, failures); err != nil {
+			return fmt.Errorf("core: persist tracker rule decisions tracker=%s: %w", state.Tracker, err)
 		}
 	}
-	if overrides.Anime != nil {
-		meta.Anime = *overrides.Anime
-	}
+	return nil
 }
 
-func applyOriginalLanguageOverrideToPreparedMeta(meta *api.PreparedMetadata, language *string) {
-	if meta == nil || language == nil {
-		return
-	}
-
-	trimmed := strings.TrimSpace(*language)
-	if trimmed == "" {
-		return
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		meta.ExternalMetadata.TMDB.OriginalLanguage = trimmed
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		meta.ExternalMetadata.IMDB.OriginalLanguage = trimmed
+func cloneTrackerContentFailure(value *api.TrackerContentFailure) *api.TrackerContentFailure {
+	if value == nil {
+		return nil
 	}
-	if meta.ExternalMetadata.TVDB != nil {
-		meta.ExternalMetadata.TVDB.OriginalLanguage = trimmed
+	cloned := *value
+	return &cloned
+}
+
+func duplicateSubjectFromUpload(subject api.UploadSubject) api.DuplicateSubject {
+	return api.DuplicateSubject{
+		SourcePath:           subject.SourcePath,
+		SourceSize:           subject.SourceSize,
+		VideoPath:            subject.VideoPath,
+		FileList:             append([]string(nil), subject.FileList...),
+		Filename:             subject.Filename,
+		SceneName:            subject.SceneName,
+		ReleaseName:          subject.ReleaseName,
+		Release:              subject.Release,
+		ReleaseNameOverrides: subject.ReleaseNameOverrides,
+		Identity:             subject.Identity,
+		ProviderMetadata:     subject.ProviderMetadata,
+		TrackerIDs:           cloneStringMap(subject.TrackerIDs),
+		DiscType:             subject.DiscType,
+		Type:                 subject.Type,
+		Source:               subject.Source,
+		Tag:                  subject.Tag,
+		HDR:                  subject.HDR,
+		UHD:                  subject.UHD,
+		VideoEncode:          subject.VideoEncode,
+		VideoCodec:           subject.VideoCodec,
+		HasEncodeSettings:    subject.HasEncodeSettings,
+		SeasonInt:            subject.SeasonInt,
+		EpisodeInt:           subject.EpisodeInt,
+		SeasonStr:            subject.SeasonStr,
+		EpisodeStr:           subject.EpisodeStr,
+		DailyEpisodeDate:     subject.DailyEpisodeDate,
+		TVPack:               subject.TVPack,
+		Anime:                subject.Anime,
+	}
+}
+
+func evaluateSubjectRules(
+	ctx context.Context,
+	registry *trackerspkg.Registry,
+	subject api.UploadSubject,
+	trackerNames []string,
+	logger api.Logger,
+) (map[string][]api.RuleFailure, error) {
+	result := make(map[string][]api.RuleFailure)
+	for _, tracker := range trackerNames {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		failures, err := trackerspkg.EvaluateRulesWithRegistry(ctx, registry, name, api.NewRuleSubject(subject), logger)
+		if err != nil {
+			return nil, fmt.Errorf("core: evaluate tracker rules: %w", err)
+		}
+		if len(failures) > 0 {
+			result[name] = append([]api.RuleFailure(nil), failures...)
+		}
 	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		meta.ExternalMetadata.TVmaze.Language = trimmed
+	if len(result) == 0 {
+		return nil, nil
 	}
+	return result, nil
 }
 
-func applyTorrentOverridesToPreparedMeta(meta *api.PreparedMetadata) {
-	if meta == nil {
-		return
-	}
-
-	if meta.TorrentOverrides.InfoHash != nil {
-		meta.InfoHash = strings.ToLower(strings.TrimSpace(*meta.TorrentOverrides.InfoHash))
-	}
+func (m *uploadModule) buildReview(ctx context.Context, req api.Request) (api.UploadReview, error) {
+	return m.buildCanonicalRequestReview(ctx, req)
 }
 
-func filterTrackerRuleFailures(failures map[string][]api.RuleFailure, allowTrackers []string) map[string][]api.RuleFailure {
-	if len(failures) == 0 {
-		return nil
-	}
-	if len(allowTrackers) == 0 {
-		cloned := make(map[string][]api.RuleFailure, len(failures))
-		for tracker, trackerFailures := range failures {
-			cloned[tracker] = cloneRuleFailures(trackerFailures)
-		}
-		return cloned
+func (m *uploadModule) buildCanonicalRequestReview(ctx context.Context, req api.Request) (api.UploadReview, error) {
+	req = normalizeExecutionRequest(req)
+	req = m.expandEntrypointTrackerDefaults(req)
+	resolved, err := m.resolveDescriptionOverride(ctx, req)
+	if err != nil {
+		return api.UploadReview{}, err
 	}
-
-	allowed := make(map[string]struct{}, len(allowTrackers))
-	for _, tracker := range allowTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name != "" {
-			allowed[name] = struct{}{}
-		}
+	prepareInput, err := api.MapPreparationRequest(resolved, api.PreparationIntentUpload)
+	if err != nil {
+		return api.UploadReview{}, fmt.Errorf("core: map upload-review preparation request: %w", err)
 	}
-
-	filtered := make(map[string][]api.RuleFailure, len(failures))
-	for tracker, trackerFailures := range failures {
-		if _, ok := allowed[strings.ToUpper(strings.TrimSpace(tracker))]; ok {
-			warnings := api.WarningRuleFailures(trackerFailures)
-			if len(warnings) > 0 {
-				filtered[tracker] = warnings
-			}
-			continue
-		}
-		filtered[tracker] = cloneRuleFailures(trackerFailures)
+	prepared, err := m.preparedFacts.Prepare(ctx, prepareInput)
+	if err != nil {
+		return api.UploadReview{}, fmt.Errorf("core: prepare upload review: %w", err)
 	}
-	if len(filtered) == 0 {
-		return nil
+	reviewInput := uploadReviewInputFromRequest(resolved, api.ReleaseRef{
+		SourcePath: prepared.Release.Source.SourcePath,
+		Generation: prepared.Release.Generation,
+	})
+	reviewed, err := m.reviewAccepted(ctx, reviewInput)
+	if err != nil {
+		return api.UploadReview{}, err
 	}
-	return filtered
+	return reviewed.Review, nil
 }
 
 func cloneRuleFailures(failures []api.RuleFailure) []api.RuleFailure {
@@ -600,197 +559,14 @@ func cloneStringMap(values map[string]string) map[string]string {
 func mapDupeResults(results []api.DupeCheckResult) map[string]api.DupeCheckResult {
 	mapped := make(map[string]api.DupeCheckResult, len(results))
 	for _, result := range results {
-		trackers := splitTrackerLabel(result.Tracker)
-		if len(trackers) == 0 {
-			name := strings.ToUpper(strings.TrimSpace(result.Tracker))
-			if name != "" {
-				mapped[name] = result
-			}
-			continue
-		}
-		for _, tracker := range trackers {
-			copyResult := result
-			copyResult.Tracker = tracker
-			mapped[tracker] = copyResult
+		name := strings.ToUpper(strings.TrimSpace(result.Tracker))
+		if name != "" {
+			mapped[name] = result
 		}
 	}
 	return mapped
 }
 
-// dryRunDupeSummaryCoversTrackers reports whether cached dupe-check results
-// already cover every tracker needed by a dry-run or debug review.
-func dryRunDupeSummaryCoversTrackers(summary api.DupeCheckSummary, req api.Request, trackers []string) bool {
-	if !dryRunOrDebug(req) || len(summary.Results) == 0 || len(trackers) == 0 {
-		return false
-	}
-
-	covered := make(map[string]struct{}, len(summary.Results))
-	for _, result := range summary.Results {
-		resultTrackers := splitTrackerLabel(result.Tracker)
-		if len(resultTrackers) == 0 {
-			name := strings.ToUpper(strings.TrimSpace(result.Tracker))
-			if name != "" {
-				covered[name] = struct{}{}
-			}
-			continue
-		}
-		for _, tracker := range resultTrackers {
-			covered[tracker] = struct{}{}
-		}
-	}
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		if _, ok := covered[name]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// cachedDupeSummaryMatchesRequest compares the cached dupe-check request to the
-// current review request. Dry-run/debug CLI flows add IgnoreDupesFor after the
-// initial dupe check so duplicate hits do not stop later processing; those
-// bypass fields are not part of dupe-search identity and must not force a second
-// dupe check.
-func cachedDupeSummaryMatchesRequest(meta api.PreparedMetadata, req api.Request, path string) bool {
-	if !dryRunOrDebug(req) {
-		return cachedPreparedMetaMatchesRequest(meta, req, path)
-	}
-	summaryReq := req
-	summaryReq.IgnoreDupesFor = nil
-	summaryReq.IgnoreTrackerRuleFailuresFor = nil
-	return cachedPreparedMetaMatchesRequest(meta, summaryReq, path)
-}
-
-func deepCopyDupeCheckSummary(summary api.DupeCheckSummary) api.DupeCheckSummary {
-	copied := summary
-	copied.Notes = append([]string(nil), summary.Notes...)
-	if len(summary.Results) == 0 {
-		copied.Results = nil
-		return copied
-	}
-	copied.Results = make([]api.DupeCheckResult, len(summary.Results))
-	for idx, result := range summary.Results {
-		copied.Results[idx] = deepCopyDupeCheckResult(result)
-	}
-	return copied
-}
-
-func deepCopyDupeCheckResult(result api.DupeCheckResult) api.DupeCheckResult {
-	copied := result
-	copied.Raw = deepCopyDupeEntries(result.Raw)
-	copied.Filtered = deepCopyDupeEntries(result.Filtered)
-	copied.Match = deepCopyDupeMatch(result.Match)
-	copied.Notes = append([]string(nil), result.Notes...)
-	copied.SkipRules = append([]string(nil), result.SkipRules...)
-	return copied
-}
-
-func deepCopyDupeEntries(entries []api.DupeEntry) []api.DupeEntry {
-	if len(entries) == 0 {
-		return nil
-	}
-	copied := make([]api.DupeEntry, len(entries))
-	for idx, entry := range entries {
-		copied[idx] = entry
-		copied[idx].Files = append([]string(nil), entry.Files...)
-		copied[idx].Flags = append([]string(nil), entry.Flags...)
-	}
-	return copied
-}
-
-func deepCopyDupeMatch(match api.DupeMatch) api.DupeMatch {
-	copied := match
-	copied.MatchedEpisodeIDs = append([]api.DupeEpisodeMatch(nil), match.MatchedEpisodeIDs...)
-	return copied
-}
-
-func cloneTrackerQuestionnaireAnswers(input map[string]map[string]string) map[string]map[string]string {
-	if len(input) == 0 {
-		return nil
-	}
-	cloned := make(map[string]map[string]string, len(input))
-	for tracker, values := range input {
-		if len(values) == 0 {
-			cloned[tracker] = map[string]string{}
-			continue
-		}
-		inner := make(map[string]string, len(values))
-		maps.Copy(inner, values)
-		cloned[tracker] = inner
-	}
-	return cloned
-}
-
-// applyDupeSummaryToPreparedMeta refreshes duplicate block and cross-seed
-// state from a dupe-check summary. Previous dupe block reasons are replaced,
-// while unrelated block reasons remain untouched.
-func applyDupeSummaryToPreparedMeta(meta *api.PreparedMetadata, summary api.DupeCheckSummary) {
-	if meta == nil {
-		return
-	}
-
-	blocked := removeTrackerDupeBlockReason(cloneBlockedTrackers(meta.BlockedTrackers))
-	crossSeeds := make([]api.UploadedTorrent, 0)
-	seenCrossSeeds := make(map[string]struct{})
-	for _, result := range summary.Results {
-		trackers := splitTrackerLabel(result.Tracker)
-		if len(trackers) == 0 {
-			trackers = []string{result.Tracker}
-		}
-		for _, tracker := range trackers {
-			if !dupeResultBlocksTracker(result, tracker) {
-				continue
-			}
-			blocked = addTrackerBlockReason(blocked, tracker, api.TrackerBlockReasonDupe)
-		}
-		for _, tracker := range trackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name == "" {
-				continue
-			}
-			if !result.HasDupes {
-				continue
-			}
-			downloadURL := strings.TrimSpace(result.Match.MatchedDownload)
-			if downloadURL == "" {
-				continue
-			}
-			key := name + "\x00" + downloadURL
-			if _, exists := seenCrossSeeds[key]; exists {
-				continue
-			}
-			seenCrossSeeds[key] = struct{}{}
-			crossSeeds = append(crossSeeds, api.UploadedTorrent{
-				Tracker:     name,
-				TorrentID:   strings.TrimSpace(result.Match.MatchedID),
-				DownloadURL: downloadURL,
-				TorrentURL:  strings.TrimSpace(result.Match.MatchedLink),
-			})
-		}
-	}
-	meta.BlockedTrackers = blocked
-	meta.CrossSeedTorrents = crossSeeds
-}
-
-// dupeResultBlocksTracker reports whether a duplicate-check result should
-// suppress upload for one tracker.
-func dupeResultBlocksTracker(result api.DupeCheckResult, _ string) bool {
-	if result.HasDupes {
-		return true
-	}
-	if result.Skipped {
-		return true
-	}
-	if strings.EqualFold(strings.TrimSpace(result.Status), "failed") {
-		return true
-	}
-	return strings.TrimSpace(result.Error) != ""
-}
-
 func cloneBlockedTrackers(input map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
 	if len(input) == 0 {
 		return nil
@@ -815,284 +591,3 @@ func cloneBlockedTrackers(input map[string][]api.TrackerBlockReason) map[string]
 	}
 	return cloned
 }
-
-func addTrackerBlockReason(blocked map[string][]api.TrackerBlockReason, tracker string, reason api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" || strings.TrimSpace(string(reason)) == "" {
-		return blocked
-	}
-	if blocked == nil {
-		blocked = make(map[string][]api.TrackerBlockReason)
-	}
-	if slices.Contains(blocked[name], reason) {
-		return blocked
-	}
-	blocked[name] = append(blocked[name], reason)
-	return blocked
-}
-
-func removeTrackerDupeBlockReason(blocked map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
-	if len(blocked) == 0 {
-		return nil
-	}
-
-	filtered := make(map[string][]api.TrackerBlockReason, len(blocked))
-	for tracker, reasons := range blocked {
-		if len(reasons) == 0 {
-			filtered[tracker] = nil
-			continue
-		}
-
-		kept := make([]api.TrackerBlockReason, 0, len(reasons))
-		for _, existing := range reasons {
-			if existing != api.TrackerBlockReasonDupe {
-				kept = append(kept, existing)
-			}
-		}
-		if len(kept) > 0 {
-			filtered[tracker] = kept
-		}
-	}
-	if len(filtered) == 0 {
-		return nil
-	}
-	return filtered
-}
-
-func removeTrackerBlockReasonForTrackers(blocked map[string][]api.TrackerBlockReason, reason api.TrackerBlockReason, trackers []string) map[string][]api.TrackerBlockReason {
-	if len(blocked) == 0 || len(trackers) == 0 {
-		return blocked
-	}
-
-	filtered := cloneBlockedTrackers(blocked)
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-
-		reasons := filtered[name]
-		if len(reasons) == 0 {
-			continue
-		}
-
-		kept := make([]api.TrackerBlockReason, 0, len(reasons))
-		for _, existing := range reasons {
-			if existing != reason {
-				kept = append(kept, existing)
-			}
-		}
-		if len(kept) == 0 {
-			delete(filtered, name)
-			continue
-		}
-		filtered[name] = kept
-	}
-	if len(filtered) == 0 {
-		return nil
-	}
-	return filtered
-}
-
-func removeCrossSeedTorrentsForTrackers(torrents []api.UploadedTorrent, trackers []string) []api.UploadedTorrent {
-	if len(torrents) == 0 || len(trackers) == 0 {
-		return torrents
-	}
-	ignored := make(map[string]struct{}, len(trackers))
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name != "" {
-			ignored[name] = struct{}{}
-		}
-	}
-	if len(ignored) == 0 {
-		return torrents
-	}
-	filtered := make([]api.UploadedTorrent, 0, len(torrents))
-	for _, torrent := range torrents {
-		name := strings.ToUpper(strings.TrimSpace(torrent.Tracker))
-		if _, skip := ignored[name]; skip {
-			continue
-		}
-		filtered = append(filtered, torrent)
-	}
-	return filtered
-}
-
-// mergeUploadReviewCacheMeta preserves unreviewed GUI cache state while
-// replacing refreshed tracker-scoped review state for the trackers reviewed by
-// this request, including matched-tracker and removal state.
-func mergeUploadReviewCacheMeta(base api.PreparedMetadata, updated api.PreparedMetadata, reviewedTrackers []string) api.PreparedMetadata {
-	merged := deepCopyPreparedMetadata(base)
-	merged.ExternalMetadata = deepCopyExternalMetadata(updated.ExternalMetadata)
-	merged.BlockedTrackers = mergeReviewedTrackerBlocks(base.BlockedTrackers, updated.BlockedTrackers, reviewedTrackers)
-	merged.CrossSeedTorrents = mergeReviewedTrackerCrossSeeds(base.CrossSeedTorrents, updated.CrossSeedTorrents, reviewedTrackers)
-	merged.TrackerRuleFailures = mergeReviewedTrackerRuleFailures(base.TrackerRuleFailures, updated.TrackerRuleFailures, reviewedTrackers)
-	merged.TrackersRemove = mergeReviewedTrackerNames(base.TrackersRemove, updated.TrackersRemove, reviewedTrackers)
-	merged.MatchedTrackers = mergeReviewedTrackerNames(base.MatchedTrackers, updated.MatchedTrackers, reviewedTrackers)
-	return merged
-}
-
-// mergeReviewedTrackerBlocks keeps base tracker blocks for unreviewed trackers
-// and replaces only reviewed trackers with refreshed block results.
-func mergeReviewedTrackerBlocks(
-	base map[string][]api.TrackerBlockReason,
-	updated map[string][]api.TrackerBlockReason,
-	reviewedTrackers []string,
-) map[string][]api.TrackerBlockReason {
-	merged := removeReviewedTrackerMapEntries(cloneBlockedTrackers(base), reviewedTrackers)
-	for _, tracker := range reviewedTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		reasons := append([]api.TrackerBlockReason(nil), lookupTrackerMapValue(updated, name)...)
-		if len(reasons) == 0 {
-			continue
-		}
-		if merged == nil {
-			merged = make(map[string][]api.TrackerBlockReason)
-		}
-		merged[name] = reasons
-	}
-	if len(merged) == 0 {
-		return nil
-	}
-	return merged
-}
-
-// mergeReviewedTrackerCrossSeeds keeps base cross-seed torrents for unreviewed
-// trackers and replaces only reviewed trackers with updated cross-seed results.
-func mergeReviewedTrackerCrossSeeds(
-	base []api.UploadedTorrent,
-	updated []api.UploadedTorrent,
-	reviewedTrackers []string,
-) []api.UploadedTorrent {
-	merged := removeCrossSeedTorrentsForTrackers(base, reviewedTrackers)
-	for _, torrent := range updated {
-		name := strings.ToUpper(strings.TrimSpace(torrent.Tracker))
-		if name == "" || !containsTrackerName(reviewedTrackers, name) {
-			continue
-		}
-		merged = append(merged, torrent)
-	}
-	if len(merged) == 0 {
-		return nil
-	}
-	return merged
-}
-
-// mergeReviewedTrackerRuleFailures keeps base rule failures for unreviewed
-// trackers and replaces only reviewed trackers with refreshed failures.
-func mergeReviewedTrackerRuleFailures(
-	base map[string][]api.RuleFailure,
-	updated map[string][]api.RuleFailure,
-	reviewedTrackers []string,
-) map[string][]api.RuleFailure {
-	merged := removeReviewedTrackerMapEntries(deepCopyTrackerRuleFailures(base), reviewedTrackers)
-	for _, tracker := range reviewedTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		failures := cloneRuleFailures(lookupTrackerMapValue(updated, name))
-		if len(failures) == 0 {
-			continue
-		}
-		if merged == nil {
-			merged = make(map[string][]api.RuleFailure)
-		}
-		merged[name] = failures
-	}
-	if len(merged) == 0 {
-		return nil
-	}
-	return merged
-}
-
-func mergeReviewedTrackerNames(base []string, updated []string, reviewedTrackers []string) []string {
-	merged := removeReviewedTrackerNames(base, reviewedTrackers)
-	for _, tracker := range updated {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" || !containsTrackerName(reviewedTrackers, name) || containsTrackerName(merged, name) {
-			continue
-		}
-		merged = append(merged, name)
-	}
-	if len(merged) == 0 {
-		return nil
-	}
-	return merged
-}
-
-func removeReviewedTrackerNames(trackers []string, reviewedTrackers []string) []string {
-	if len(trackers) == 0 {
-		return nil
-	}
-	if len(reviewedTrackers) == 0 {
-		return append([]string(nil), trackers...)
-	}
-	filtered := make([]string, 0, len(trackers))
-	for _, tracker := range trackers {
-		if strings.TrimSpace(tracker) == "" || containsTrackerName(reviewedTrackers, tracker) {
-			continue
-		}
-		filtered = append(filtered, tracker)
-	}
-	if len(filtered) == 0 {
-		return nil
-	}
-	return filtered
-}
-
-// removeReviewedTrackerMapEntries deletes reviewed tracker entries using
-// case-insensitive tracker names so stale mixed-case cache keys cannot survive.
-func removeReviewedTrackerMapEntries[T any](input map[string]T, reviewedTrackers []string) map[string]T {
-	if len(input) == 0 {
-		return nil
-	}
-	reviewed := make(map[string]struct{}, len(reviewedTrackers))
-	for _, tracker := range reviewedTrackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		reviewed[name] = struct{}{}
-	}
-	if len(reviewed) == 0 {
-		return input
-	}
-	for key := range input {
-		name := strings.ToUpper(strings.TrimSpace(key))
-		if _, ok := reviewed[name]; ok {
-			delete(input, key)
-		}
-	}
-	if len(input) == 0 {
-		return nil
-	}
-	return input
-}
-
-func containsTrackerName(trackers []string, target string) bool {
-	for _, tracker := range trackers {
-		if strings.EqualFold(strings.TrimSpace(tracker), strings.TrimSpace(target)) {
-			return true
-		}
-	}
-	return false
-}
-
-func lookupTrackerMapValue[T any](input map[string]T, tracker string) T {
-	var zero T
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" {
-		return zero
-	}
-	for key, value := range input {
-		if strings.EqualFold(strings.TrimSpace(key), name) {
-			return value
-		}
-	}
-	return zero
-}
diff --git a/internal/core/upload_review_test.go b/internal/core/upload_review_test.go
deleted file mode 100644
index 812fbedd..00000000
--- a/internal/core/upload_review_test.go
+++ /dev/null
@@ -1,2105 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package core
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"reflect"
-	"slices"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type reviewDupes struct {
-	calls        int
-	lastTrackers []string
-	summary      api.DupeCheckSummary
-}
-
-func (r *reviewDupes) Check(_ context.Context, _ api.PreparedMetadata, trackers []string) (api.DupeCheckSummary, error) {
-	r.calls++
-	r.lastTrackers = append([]string(nil), trackers...)
-	return r.summary, nil
-}
-
-type reviewTrackers struct{}
-
-func (reviewTrackers) Upload(context.Context, api.PreparedMetadata) (api.UploadSummary, error) {
-	return api.UploadSummary{}, nil
-}
-
-func (reviewTrackers) BuildPreparation(context.Context, api.PreparedMetadata, []string) (api.PreparationPreview, error) {
-	return api.PreparationPreview{}, nil
-}
-
-func (reviewTrackers) BuildUploadDryRun(context.Context, api.PreparedMetadata, []string) ([]api.TrackerDryRunEntry, error) {
-	return []api.TrackerDryRunEntry{
-		{Tracker: "AITHER", Status: "ready", ReleaseName: "AITHER.NAME"},
-		{Tracker: "BLU", Status: "ready", ReleaseName: "BLU.NAME"},
-	}, nil
-}
-
-type recordingReviewTrackers struct {
-	calls        int
-	lastMeta     api.PreparedMetadata
-	lastTrackers []string
-	entries      []api.TrackerDryRunEntry
-	err          error
-}
-
-func (*recordingReviewTrackers) Upload(context.Context, api.PreparedMetadata) (api.UploadSummary, error) {
-	return api.UploadSummary{}, nil
-}
-
-func (*recordingReviewTrackers) BuildPreparation(context.Context, api.PreparedMetadata, []string) (api.PreparationPreview, error) {
-	return api.PreparationPreview{}, nil
-}
-
-func (r *recordingReviewTrackers) BuildUploadDryRun(_ context.Context, meta api.PreparedMetadata, trackers []string) ([]api.TrackerDryRunEntry, error) {
-	r.calls++
-	r.lastMeta = deepCopyPreparedMetadata(meta)
-	r.lastTrackers = append([]string{}, trackers...)
-	if r.err != nil {
-		return nil, r.err
-	}
-	if len(r.entries) == 0 {
-		return []api.TrackerDryRunEntry{}, nil
-	}
-	return append([]api.TrackerDryRunEntry(nil), r.entries...), nil
-}
-
-type recordingReviewMetadata struct {
-	refreshCalls  int
-	resolveCalls  int
-	resolveInputs []api.PreparedMetadata
-	resolveFn     func(api.PreparedMetadata) api.PreparedMetadata
-}
-
-func (r *recordingReviewMetadata) Prepare(_ context.Context, req api.Request) (api.PreparedMetadata, error) {
-	return api.PreparedMetadata{SourcePath: req.Paths[0], Paths: req.Paths, Mode: req.Mode, Options: req.Options}, nil
-}
-
-func (r *recordingReviewMetadata) RefreshPreparedMetadata(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	r.refreshCalls++
-	return meta, nil
-}
-
-func (*recordingReviewMetadata) EnrichTrackerData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (*recordingReviewMetadata) ApplyMediaInfoIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (*recordingReviewMetadata) ApplyArrData(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (r *recordingReviewMetadata) ResolveExternalIDs(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	r.resolveCalls++
-	r.resolveInputs = append(r.resolveInputs, deepCopyPreparedMetadata(meta))
-	if r.resolveFn != nil {
-		return r.resolveFn(meta), nil
-	}
-	return meta, nil
-}
-
-func (*recordingReviewMetadata) ApplyMediaDetails(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-func (*recordingReviewMetadata) ApplyTrackerClaims(_ context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return meta, nil
-}
-
-type recordingReviewTorrent struct {
-	calls int
-	err   error
-}
-
-func (r *recordingReviewTorrent) Create(context.Context, api.PreparedMetadata) (api.TorrentResult, error) {
-	r.calls++
-	if r.err != nil {
-		return api.TorrentResult{}, r.err
-	}
-	return api.TorrentResult{Path: "/tmp/file.torrent"}, nil
-}
-
-func TestBuildUploadReviewIncludesRuleFailuresDupesAndDryRun(t *testing.T) {
-	t.Parallel()
-
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes: &reviewDupes{summary: api.DupeCheckSummary{
-				SourcePath: "/tmp/a",
-				Results:    []api.DupeCheckResult{{Tracker: "AITHER", HasDupes: true, Status: "completed", Notes: []string{"possible dupe"}}},
-			}},
-			Torrents: &stubTorrent{},
-			Trackers: reviewTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER", "BLU"},
-		Tag:        "-GROUP",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"BLU": {{Rule: "movie_only", Reason: "movie only"}},
-		},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BLU"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if len(review.Trackers) != 2 {
-		t.Fatalf("expected 2 tracker reviews, got %d", len(review.Trackers))
-	}
-	if !review.Trackers[0].DupeCheck.HasDupes {
-		t.Fatalf("expected AITHER dupe result")
-	}
-	if got := review.Trackers[1].RuleFailures; len(got) != 1 || got[0].Rule != "movie_only" {
-		t.Fatalf("expected BLU rule failure, got %#v", got)
-	}
-	if review.Trackers[0].DryRun.ReleaseName == "" || review.Trackers[1].DryRun.ReleaseName == "" {
-		t.Fatalf("expected dry-run release names in review")
-	}
-}
-
-func TestBuildUploadReviewSkipsDynamicBannedRefreshForEmptyEffectiveGroup(t *testing.T) {
-	t.Parallel()
-
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		_, _ = w.Write([]byte(`{"data":[],"meta":{"next_cursor":""}}`))
-	}))
-	defer server.Close()
-
-	sourcePath := "/tmp/a"
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db"), TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"AITHER": {APIKey: "aither-key", URL: server.URL},
-				},
-			},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	defer coreSvc.Close()
-	coreSvc.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath: sourcePath,
-		Tag:        "-",
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if got := requests.Load(); got != 0 {
-		t.Fatalf("expected no dynamic banned refresh for empty effective group, got %d request(s)", got)
-	}
-	if len(review.Trackers) != 1 || review.Trackers[0].Banned {
-		t.Fatalf("expected unbanned tracker review, got %#v", review.Trackers)
-	}
-}
-
-func TestBuildUploadReviewReusesDryRunBannedAnnotations(t *testing.T) {
-	t.Parallel()
-
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		_, _ = w.Write([]byte(`{"data":[],"meta":{"next_cursor":""}}`))
-	}))
-	defer server.Close()
-
-	sourcePath := filepath.Join(t.TempDir(), "a")
-	const bannedCheckError = "banned group check failed: cache unavailable"
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{
-			Tracker:          "AITHER",
-			Status:           "ready",
-			Banned:           true,
-			BannedReason:     "group examplegrp is banned on AITHER",
-			BannedCheckError: bannedCheckError,
-		}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db"), TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"AITHER": {APIKey: "aither-key", URL: server.URL},
-				},
-			},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	defer coreSvc.Close()
-	coreSvc.storeDupeCache(sourcePath, "", api.PreparedMetadata{
-		SourcePath: sourcePath,
-		Tag:        "-ExampleGRP",
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{sourcePath},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if got := requests.Load(); got != 0 {
-		t.Fatalf("expected review to reuse dry-run banned data without refresh, got %d request(s)", got)
-	}
-	if len(review.Trackers) != 1 {
-		t.Fatalf("expected one tracker review, got %#v", review.Trackers)
-	}
-	tracker := review.Trackers[0]
-	if !tracker.Banned || tracker.BannedReason != "group examplegrp is banned on AITHER" {
-		t.Fatalf("expected banned review annotation from dry-run data, got %#v", tracker)
-	}
-	if !tracker.DryRun.Banned || tracker.DryRun.BannedReason != tracker.BannedReason {
-		t.Fatalf("expected dry-run banned annotation to remain intact, got %#v", tracker.DryRun)
-	}
-	if tracker.DryRun.BannedCheckError != bannedCheckError {
-		t.Fatalf("expected dry-run banned check error %q, got %#v", bannedCheckError, tracker.DryRun)
-	}
-	if tracker.DryRun.Status != "blocked" {
-		t.Fatalf("expected dry-run banned check error to block upload review, got %#v", tracker.DryRun)
-	}
-	if tracker.DryRun.Message != bannedCheckError {
-		t.Fatalf("expected dry-run blocked message %q, got %#v", bannedCheckError, tracker.DryRun)
-	}
-}
-
-func TestApplyRequestToPreparedMetaClearsDupeBlocksWhenSkipped(t *testing.T) {
-	t.Parallel()
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-		},
-	}, api.Request{SkipDupeCheck: true}, config.Config{}, api.NopLogger{})
-
-	if len(meta.BlockedTrackers) != 0 {
-		t.Fatalf("expected dupe blocks to be cleared when dupe check is skipped, got %#v", meta.BlockedTrackers)
-	}
-}
-
-func TestApplyRequestToPreparedMetaClearsDupeBlocksForIgnoredTrackers(t *testing.T) {
-	t.Parallel()
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"HDB": {api.TrackerBlockReasonDupe},
-			"BHD": {api.TrackerBlockReasonDupe},
-		},
-	}, api.Request{IgnoreDupesFor: []string{"HDB"}}, config.Config{}, api.NopLogger{})
-
-	if _, ok := meta.BlockedTrackers["HDB"]; ok {
-		t.Fatalf("expected HDB dupe block to be cleared, got %#v", meta.BlockedTrackers)
-	}
-	if got := meta.BlockedTrackers["BHD"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected BHD dupe block to remain, got %#v", meta.BlockedTrackers)
-	}
-}
-
-func TestApplyRequestToPreparedMetaClearsIgnoredDupeRemovalState(t *testing.T) {
-	t.Parallel()
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		TrackersRemove:  []string{"AiThEr", "BLU"},
-		MatchedTrackers: []string{"aither", "BLU"},
-	}, api.Request{
-		IgnoreDupesFor: []string{"AITHER"},
-	}, config.Config{}, api.NopLogger{})
-
-	if !reflect.DeepEqual(meta.TrackersRemove, []string{"BLU"}) {
-		t.Fatalf("expected ignored duplicate removal cleared and unignored removal preserved, got %#v", meta.TrackersRemove)
-	}
-	if !reflect.DeepEqual(meta.MatchedTrackers, []string{"BLU"}) {
-		t.Fatalf("expected ignored duplicate match cleared and unignored match preserved, got %#v", meta.MatchedTrackers)
-	}
-}
-
-func TestApplyRequestToPreparedMetaPreservesRequestedRemovalForIgnoredDupe(t *testing.T) {
-	t.Parallel()
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		TrackersRemove:  []string{"AITHER"},
-		MatchedTrackers: []string{"AITHER"},
-	}, api.Request{
-		TrackersRemove: []string{"AITHER"},
-		IgnoreDupesFor: []string{"AITHER"},
-	}, config.Config{}, api.NopLogger{})
-
-	if !reflect.DeepEqual(meta.TrackersRemove, []string{"AITHER"}) {
-		t.Fatalf("expected requested removal to remain authoritative, got %#v", meta.TrackersRemove)
-	}
-	if len(meta.MatchedTrackers) != 0 {
-		t.Fatalf("expected ignored duplicate match cleared, got %#v", meta.MatchedTrackers)
-	}
-}
-
-func TestApplyDupeSummaryBlocksSkippedAndFailedTrackers(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{}
-	applyDupeSummaryToPreparedMeta(&meta, api.DupeCheckSummary{
-		Results: []api.DupeCheckResult{
-			{Tracker: "BTN", Skipped: true, SkipReason: "BTN only supports TV dupe search"},
-			{Tracker: "RTF", Status: "failed", Error: "dupe search failed"},
-			{Tracker: "OE", Status: "completed"},
-		},
-	})
-
-	if got := meta.BlockedTrackers["BTN"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected BTN skipped dupe block, got %#v", meta.BlockedTrackers)
-	}
-	if got := meta.BlockedTrackers["RTF"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected RTF failed dupe block, got %#v", meta.BlockedTrackers)
-	}
-	if _, ok := meta.BlockedTrackers["OE"]; ok {
-		t.Fatalf("expected completed OE dupe check not to block, got %#v", meta.BlockedTrackers)
-	}
-}
-
-func TestApplyDupeSummaryStoresMatchedDownloadsForCrossSeedInjection(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{}
-	applyDupeSummaryToPreparedMeta(&meta, api.DupeCheckSummary{
-		Results: []api.DupeCheckResult{
-			{
-				Tracker:  "HDB",
-				HasDupes: true,
-				Match: api.DupeMatch{
-					MatchedID:       "123",
-					MatchedLink:     "https://hdbits.org/details.php?id=123",
-					MatchedDownload: "https://hdbits.org/download.php/file?id=123&passkey=abc",
-				},
-			},
-			{Tracker: "BTN", Skipped: true},
-		},
-	})
-
-	if len(meta.CrossSeedTorrents) != 1 {
-		t.Fatalf("expected one cross-seed torrent, got %#v", meta.CrossSeedTorrents)
-	}
-	crossSeed := meta.CrossSeedTorrents[0]
-	if crossSeed.Tracker != "HDB" {
-		t.Fatalf("expected HDB cross-seed tracker, got %q", crossSeed.Tracker)
-	}
-	if crossSeed.DownloadURL != "https://hdbits.org/download.php/file?id=123&passkey=abc" {
-		t.Fatalf("expected matched download URL, got %q", crossSeed.DownloadURL)
-	}
-	if crossSeed.TorrentID != "123" || crossSeed.TorrentURL != "https://hdbits.org/details.php?id=123" {
-		t.Fatalf("expected matched metadata to be preserved, got %#v", crossSeed)
-	}
-}
-
-func TestApplyRequestToPreparedMetaPreservesCachedDescriptionGroupsWhenRequestOmitted(t *testing.T) {
-	t.Parallel()
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		DescriptionGroups: []api.DescriptionBuilderGroup{{
-			GroupKey:       "unit3d",
-			Trackers:       []string{"BLU"},
-			RawDescription: "cached body",
-			HasOverride:    true,
-		}},
-	}, api.Request{}, config.Config{}, api.NopLogger{})
-
-	if len(meta.DescriptionGroups) != 1 {
-		t.Fatalf("expected cached description groups to be preserved, got %d", len(meta.DescriptionGroups))
-	}
-	if meta.DescriptionGroups[0].GroupKey != "unit3d" {
-		t.Fatalf("expected cached group key to be preserved, got %q", meta.DescriptionGroups[0].GroupKey)
-	}
-	if meta.DescriptionGroups[0].RawDescription != "cached body" {
-		t.Fatalf("expected cached group body to be preserved, got %q", meta.DescriptionGroups[0].RawDescription)
-	}
-	if !meta.DescriptionGroups[0].HasOverride {
-		t.Fatalf("expected cached override flag to be preserved")
-	}
-}
-
-func TestApplyRequestToPreparedMetaAppliesMetadataOverrides(t *testing.T) {
-	t.Parallel()
-
-	distributor := "Criterion"
-	trueValue := true
-	falseValue := false
-
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{}, api.Request{
-		MetadataOverrides: api.MetadataOverrides{
-			Distributor:     &distributor,
-			PersonalRelease: &trueValue,
-			Commentary:      &trueValue,
-			WebDV:           &trueValue,
-			StreamOptimized: &trueValue,
-			Anime:           &falseValue,
-		},
-	}, config.Config{}, api.NopLogger{})
-
-	if meta.Distributor != "Criterion" {
-		t.Fatalf("expected distributor override, got %q", meta.Distributor)
-	}
-	if !meta.PersonalRelease {
-		t.Fatalf("expected personal release override")
-	}
-	if !meta.HasCommentary {
-		t.Fatalf("expected commentary override")
-	}
-	if !meta.WebDV {
-		t.Fatalf("expected webdv override")
-	}
-	if meta.StreamOptimized != 1 {
-		t.Fatalf("expected stream override to set 1, got %d", meta.StreamOptimized)
-	}
-	if meta.Anime {
-		t.Fatalf("expected anime override to set false")
-	}
-}
-
-func TestApplyRequestToPreparedMetaAppliesTorrentOverrides(t *testing.T) {
-	t.Parallel()
-
-	infoHash := "abcdef0123456789abcdef0123456789abcdef01"
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{}, api.Request{
-		TorrentOverrides: api.TorrentOverrides{
-			InfoHash: &infoHash,
-		},
-	}, config.Config{}, api.NopLogger{})
-
-	if meta.InfoHash != infoHash {
-		t.Fatalf("expected infohash override, got %q", meta.InfoHash)
-	}
-}
-
-func TestApplyRequestToPreparedMetaRecomputesAudioPolicyForOverridesAndTrackers(t *testing.T) {
-	t.Parallel()
-
-	originalLanguage := "ja"
-	meta := applyRequestToPreparedMeta(api.PreparedMetadata{
-		Audio:          "Dubbed DD 5.1",
-		AudioLanguages: []string{"English", "Japanese", "French"},
-		Trackers:       []string{"ANT"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"ANT": {api.TrackerBlockReasonAudio},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"ANT": {{Rule: "audio_bloat", Reason: "stale"}},
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginalLanguage: "en"},
-		},
-	}, api.Request{
-		Trackers: []string{"SPD"},
-		MetadataOverrides: api.MetadataOverrides{
-			OriginalLanguage: &originalLanguage,
-		},
-	}, config.Config{}, api.NopLogger{})
-
-	if meta.Audio != "Dual-Audio DD 5.1" {
-		t.Fatalf("expected audio label to be recomputed, got %q", meta.Audio)
-	}
-	if _, ok := meta.BlockedTrackers["ANT"]; ok {
-		t.Fatalf("expected stale ANT audio block to be cleared, got %#v", meta.BlockedTrackers)
-	}
-	if got := meta.TrackerRuleFailures["ANT"]; len(got) != 0 {
-		t.Fatalf("expected stale ANT audio rule failure to be cleared, got %#v", meta.TrackerRuleFailures)
-	}
-	if got := meta.TrackerRuleFailures["SPD"]; len(got) != 0 {
-		t.Fatalf("expected no SPD audio rule failure, got %#v", meta.TrackerRuleFailures)
-	}
-}
-
-func TestBuildUploadReviewMarksBlockedTrackersInDryRun(t *testing.T) {
-	t.Parallel()
-
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   reviewTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonClaim},
-		},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if len(review.Trackers) != 1 {
-		t.Fatalf("expected 1 tracker review, got %d", len(review.Trackers))
-	}
-	if review.Trackers[0].DryRun.Status != "blocked" {
-		t.Fatalf("expected blocked dry-run status, got %#v", review.Trackers[0].DryRun)
-	}
-	if !strings.Contains(review.Trackers[0].DryRun.Message, "claim") {
-		t.Fatalf("expected blocked dry-run message to mention claim, got %#v", review.Trackers[0].DryRun)
-	}
-}
-
-func TestBuildUploadReviewDebugBuildsPayloadsForBlockedTrackers(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{
-			{Tracker: "AITHER", Status: "ready", Payload: map[string]string{"name": "example"}},
-			{Tracker: "BLU", Status: "ready", Payload: map[string]string{"name": "example"}},
-		},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("source.mkv", "", api.PreparedMetadata{
-		SourcePath:     "source.mkv",
-		TrackersRemove: []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonClaim},
-		},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"source.mkv"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options:  api.UploadOptions{Debug: true},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"AITHER", "BLU"}) {
-		t.Fatalf("expected debug review dry-run for all trackers, got %#v", trackersSvc.lastTrackers)
-	}
-	if len(trackersSvc.lastMeta.BlockedTrackers) != 0 {
-		t.Fatalf("expected debug review dry-run metadata to ignore blocks, got %#v", trackersSvc.lastMeta.BlockedTrackers)
-	}
-	if len(review.Trackers) != 2 {
-		t.Fatalf("expected both tracker reviews, got %#v", review.Trackers)
-	}
-	if review.Trackers[0].Tracker != "AITHER" || review.Trackers[0].DryRun.Payload["name"] != "example" {
-		t.Fatalf("expected AITHER payload to be preserved, got %#v", review.Trackers[0])
-	}
-	if review.Trackers[0].DryRun.Status != "blocked" {
-		t.Fatalf("expected review to keep blocked status, got %#v", review.Trackers[0].DryRun)
-	}
-}
-
-func TestBuildUploadReviewDebugReusesCachedDupeSummary(t *testing.T) {
-	t.Parallel()
-
-	dupes := &reviewDupes{summary: api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", Status: "completed"},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	}}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-			Torrents:   &stubTorrent{},
-			Trackers:   reviewTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	cachedSummary := api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", HasDupes: true, Status: "completed", Notes: []string{"cached"}},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	}
-	coreSvc.storeRefreshedDupeCacheWithDupeSummary("source.mkv", "", api.PreparedMetadata{
-		SourcePath: "source.mkv",
-		Mode:       api.ModeCLI,
-		Trackers:   []string{"AITHER", "BLU"},
-		Options:    api.UploadOptions{Debug: true, Screens: 1, InteractionMode: api.InteractionModeInteractive},
-		Tag:        "-GROUP",
-	}, cachedSummary)
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"source.mkv"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options:  api.UploadOptions{Debug: true},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if dupes.calls != 0 {
-		t.Fatalf("expected debug review to reuse cached dupe summary, called dupe service %d time(s)", dupes.calls)
-	}
-	if len(review.Trackers) != 2 {
-		t.Fatalf("expected 2 tracker reviews, got %d", len(review.Trackers))
-	}
-	if !review.Trackers[0].DupeCheck.HasDupes {
-		t.Fatalf("expected cached AITHER dupe result")
-	}
-}
-
-func TestBuildUploadReviewDryRunReusesCachedDupeSummary(t *testing.T) {
-	t.Parallel()
-
-	dupes := &reviewDupes{summary: api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", Status: "completed"},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	}}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-			Torrents:   &stubTorrent{},
-			Trackers:   reviewTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	cachedSummary := api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", HasDupes: true, Status: "completed", Notes: []string{"cached"}},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	}
-	coreSvc.storeRefreshedDupeCacheWithDupeSummary("source.mkv", "", api.PreparedMetadata{
-		SourcePath: "source.mkv",
-		Mode:       api.ModeCLI,
-		Trackers:   []string{"AITHER", "BLU"},
-		Options:    api.UploadOptions{DryRun: true, Screens: 1, InteractionMode: api.InteractionModeInteractive},
-		Tag:        "-GROUP",
-	}, cachedSummary)
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:                        []string{"source.mkv"},
-		Mode:                         api.ModeCLI,
-		Trackers:                     []string{"AITHER", "BLU"},
-		IgnoreDupesFor:               []string{"AITHER", "BLU"},
-		IgnoreTrackerRuleFailuresFor: []string{"AITHER", "BLU"},
-		Options:                      api.UploadOptions{DryRun: true},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if dupes.calls != 0 {
-		t.Fatalf("expected dry-run review to reuse cached dupe summary, called dupe service %d time(s)", dupes.calls)
-	}
-	if len(review.Trackers) != 2 {
-		t.Fatalf("expected 2 tracker reviews, got %d", len(review.Trackers))
-	}
-	if !review.Trackers[0].DupeCheck.HasDupes {
-		t.Fatalf("expected cached AITHER dupe result")
-	}
-}
-
-func TestBuildUploadReviewDebugRefreshesDupeSummaryWhenCacheRequestDiffers(t *testing.T) {
-	t.Parallel()
-
-	dupes := &reviewDupes{summary: api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", Status: "completed", Notes: []string{"fresh"}},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	}}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-			Torrents:   &stubTorrent{},
-			Trackers:   reviewTrackers{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeRefreshedDupeCacheWithDupeSummary("source.mkv", "", api.PreparedMetadata{
-		SourcePath: "source.mkv",
-		Mode:       api.ModeGUI,
-		Trackers:   []string{"AITHER", "BLU"},
-		Options:    api.UploadOptions{Debug: true, Screens: 1, InteractionMode: api.InteractionModeInteractive},
-	}, api.DupeCheckSummary{
-		SourcePath: "source.mkv",
-		Results: []api.DupeCheckResult{
-			{Tracker: "AITHER", HasDupes: true, Status: "completed", Notes: []string{"stale"}},
-			{Tracker: "BLU", Status: "completed"},
-		},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"source.mkv"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER", "BLU"},
-		Options:  api.UploadOptions{Debug: true},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if dupes.calls != 1 {
-		t.Fatalf("expected stale debug dupe summary to be refreshed, called dupe service %d time(s)", dupes.calls)
-	}
-	if review.Trackers[0].DupeCheck.HasDupes {
-		t.Fatalf("expected fresh AITHER dupe result, got %#v", review.Trackers[0].DupeCheck)
-	}
-	if !slices.Contains(review.Trackers[0].DupeCheck.Notes, "fresh") {
-		t.Fatalf("expected fresh dupe result notes, got %#v", review.Trackers[0].DupeCheck)
-	}
-}
-
-func TestBuildUploadReviewReturnsEmptyWhenSelectedTrackersResolveEmpty(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "BLU", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:     "/tmp/a",
-		TrackersRemove: []string{"AITHER"},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if trackersSvc.calls != 0 {
-		t.Fatalf("expected dry-run to be skipped, got %d calls", trackersSvc.calls)
-	}
-	if len(review.Trackers) != 0 {
-		t.Fatalf("expected no tracker reviews, got %#v", review.Trackers)
-	}
-}
-
-func TestBuildUploadReviewAddsDefaultsForExplicitTrackersOutsideGUI(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{
-			{Tracker: "BLU", Status: "ready"},
-			{Tracker: "AITHER", Status: "ready"},
-		},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"BLU", "AITHER"}) {
-		t.Fatalf("expected default plus explicit trackers, got %v", trackersSvc.lastTrackers)
-	}
-	if got := []string{review.Trackers[0].Tracker, review.Trackers[1].Tracker}; !slices.Equal(got, []string{"BLU", "AITHER"}) {
-		t.Fatalf("expected review rows for default plus explicit trackers, got %v", got)
-	}
-}
-
-func TestBuildUploadReviewDebugDoesNotAddDefaultsForExplicitTrackersOutsideGUI(t *testing.T) {
-	t.Parallel()
-
-	dupes := &reviewDupes{}
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      dupes,
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeRefreshedDupeCacheWithDupeSummary("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Mode:       api.ModeCLI,
-		Trackers:   []string{"AITHER"},
-		Options:    api.UploadOptions{Debug: true, Screens: 1, InteractionMode: api.InteractionModeInteractive},
-	}, api.DupeCheckSummary{
-		SourcePath: "/tmp/a",
-		Results:    []api.DupeCheckResult{{Tracker: "AITHER", Status: "completed"}},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-		Options:  api.UploadOptions{Debug: true},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if dupes.calls != 0 {
-		t.Fatalf("expected cached debug dupe result to cover resolved trackers, called dupe service %d time(s)", dupes.calls)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected debug review to keep explicit trackers only, got %v", trackersSvc.lastTrackers)
-	}
-	if got := []string{review.Trackers[0].Tracker}; !slices.Equal(got, []string{"AITHER"}) {
-		t.Fatalf("expected review row for explicit tracker only, got %v", got)
-	}
-}
-
-func TestBuildUploadReviewFallsBackToDefaultsWhenExplicitTrackersRemovedOutsideGUI(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "BLU", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:     "/tmp/a",
-		TrackersRemove: []string{"AITHER"},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeCLI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"BLU"}) {
-		t.Fatalf("expected default tracker after explicit tracker removal, got %v", trackersSvc.lastTrackers)
-	}
-	if len(review.Trackers) != 1 || review.Trackers[0].Tracker != "BLU" {
-		t.Fatalf("expected one BLU review row, got %#v", review.Trackers)
-	}
-}
-
-func TestBuildUploadReviewRefreshesLocalizedMetadataForGUICachedPTBRSelection(t *testing.T) {
-	t.Parallel()
-
-	for _, tracker := range []string{"BJS", "BT", "ASC"} {
-		t.Run(tracker, func(t *testing.T) {
-			t.Parallel()
-
-			path := "/tmp/" + strings.ToLower(tracker)
-			metadataSvc := &recordingReviewMetadata{
-				resolveFn: func(meta api.PreparedMetadata) api.PreparedMetadata {
-					if meta.ExternalMetadata.TMDB == nil {
-						meta.ExternalMetadata.TMDB = &api.TMDBMetadata{TMDBID: meta.ExternalIDs.TMDBID}
-					}
-					if meta.ExternalMetadata.TMDB.Localized == nil {
-						meta.ExternalMetadata.TMDB.Localized = make(map[string]api.TMDBLocalizedData)
-					}
-					meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{Title: "Titulo " + tracker}
-					return meta
-				},
-			}
-			trackersSvc := &recordingReviewTrackers{
-				entries: []api.TrackerDryRunEntry{{Tracker: tracker, Status: "ready"}},
-			}
-			coreSvc, err := New(api.CoreDependencies{
-				Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-				Services: api.ServiceSet{
-					Filesystem: &stubFS{},
-					Metadata:   metadataSvc,
-					Dupes:      &reviewDupes{},
-					Torrents:   &stubTorrent{},
-					Trackers:   trackersSvc,
-				},
-				Repository: &stubRepo{},
-			})
-			if err != nil {
-				t.Fatalf("new core: %v", err)
-			}
-			coreSvc.storeDupeCache(path, "", api.PreparedMetadata{
-				SourcePath:      path,
-				StoredDataFresh: true,
-				Trackers:        []string{"AITHER"},
-				ExternalIDs: api.ExternalIDs{
-					SourcePath: path,
-					TMDBID:     42,
-					Category:   "MOVIE",
-				},
-				ExternalMetadata: api.ExternalMetadata{
-					SourcePath: path,
-					TMDB:       &api.TMDBMetadata{TMDBID: 42},
-				},
-			})
-
-			review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-				Paths:    []string{path},
-				Mode:     api.ModeGUI,
-				Trackers: []string{tracker},
-			})
-			if err != nil {
-				t.Fatalf("build upload review: %v", err)
-			}
-
-			if metadataSvc.resolveCalls != 1 {
-				t.Fatalf("expected one localized metadata refresh, got %d", metadataSvc.resolveCalls)
-			}
-			if got := metadataSvc.resolveInputs[0].Trackers; !slices.Equal(got, []string{tracker}) {
-				t.Fatalf("expected resolve to receive selected tracker, got %v", got)
-			}
-			if localized := api.ExtractLocalizedPTBR(trackersSvc.lastMeta); localized.Title != "Titulo "+tracker {
-				t.Fatalf("expected dry-run metadata to include pt-BR title, got %#v", localized)
-			}
-			if len(review.Trackers) != 1 || review.Trackers[0].Tracker != tracker {
-				t.Fatalf("expected one %s review row, got %#v", tracker, review.Trackers)
-			}
-		})
-	}
-}
-
-func TestBuildUploadReviewRefreshesPartialLocalizedPTBRBeforeDryRun(t *testing.T) {
-	t.Parallel()
-
-	path := "/tmp/partial-ptbr"
-	metadataSvc := &recordingReviewMetadata{
-		resolveFn: func(meta api.PreparedMetadata) api.PreparedMetadata {
-			meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-				Title:    "Titulo atualizado",
-				Overview: "Resumo atualizado",
-				Genres:   "Drama",
-			}
-			return meta
-		},
-	}
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "BJS", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metadataSvc,
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache(path, "", api.PreparedMetadata{
-		SourcePath:      path,
-		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: path,
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: path,
-			TMDB: &api.TMDBMetadata{
-				TMDBID: 42,
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {Title: "Titulo antigo"},
-				},
-			},
-		},
-	})
-
-	if _, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{path},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"BJS"},
-	}); err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-
-	if metadataSvc.resolveCalls != 1 {
-		t.Fatalf("expected partial pt-BR metadata to refresh once, got %d calls", metadataSvc.resolveCalls)
-	}
-	localized := api.ExtractLocalizedPTBR(trackersSvc.lastMeta)
-	if localized.Title != "Titulo atualizado" || localized.Overview != "Resumo atualizado" || localized.Genres != "Drama" {
-		t.Fatalf("expected dry-run metadata to use refreshed localized fields, got %#v", localized)
-	}
-}
-
-func TestPTBRTrackerPredicatesShareTrimCaseContract(t *testing.T) {
-	t.Parallel()
-
-	for _, name := range []string{"BJS", " bjs ", "BT", "bt", "ASC", "asc"} {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			if !hasPTBRTracker([]string{name}) {
-				t.Fatalf("expected upload review predicate to accept %q", name)
-			}
-			if !descriptionBuilderTrackersNeedPTBR([]string{name}) {
-				t.Fatalf("expected description builder predicate to accept %q", name)
-			}
-		})
-	}
-
-	for _, name := range []string{"", "BJSX", "XBT", "AITHER"} {
-		t.Run("reject_"+name, func(t *testing.T) {
-			t.Parallel()
-			if hasPTBRTracker([]string{name}) {
-				t.Fatalf("expected upload review predicate to reject %q", name)
-			}
-			if descriptionBuilderTrackersNeedPTBR([]string{name}) {
-				t.Fatalf("expected description builder predicate to reject %q", name)
-			}
-		})
-	}
-}
-
-func TestBuildUploadReviewRefreshesLocalizedMetadataForDefaultPTBRTracker(t *testing.T) {
-	t.Parallel()
-
-	for _, tracker := range []string{"BJS", "BT", "ASC"} {
-		t.Run(tracker, func(t *testing.T) {
-			t.Parallel()
-
-			path := "/tmp/default-" + strings.ToLower(tracker)
-			metadataSvc := &recordingReviewMetadata{
-				resolveFn: func(meta api.PreparedMetadata) api.PreparedMetadata {
-					if meta.ExternalMetadata.TMDB == nil {
-						meta.ExternalMetadata.TMDB = &api.TMDBMetadata{TMDBID: meta.ExternalIDs.TMDBID}
-					}
-					if meta.ExternalMetadata.TMDB.Localized == nil {
-						meta.ExternalMetadata.TMDB.Localized = make(map[string]api.TMDBLocalizedData)
-					}
-					meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{Title: "Default " + tracker}
-					return meta
-				},
-			}
-			trackersSvc := &recordingReviewTrackers{
-				entries: []api.TrackerDryRunEntry{{Tracker: tracker, Status: "ready"}},
-			}
-			coreSvc, err := New(api.CoreDependencies{
-				Config: config.Config{
-					MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-					ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-					Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{tracker}},
-				},
-				Services: api.ServiceSet{
-					Filesystem: &stubFS{},
-					Metadata:   metadataSvc,
-					Dupes:      &reviewDupes{},
-					Torrents:   &stubTorrent{},
-					Trackers:   trackersSvc,
-				},
-				Repository: &stubRepo{},
-			})
-			if err != nil {
-				t.Fatalf("new core: %v", err)
-			}
-			coreSvc.storeDupeCache(path, "", api.PreparedMetadata{
-				SourcePath:      path,
-				StoredDataFresh: true,
-				ExternalIDs: api.ExternalIDs{
-					SourcePath: path,
-					TMDBID:     42,
-					Category:   "MOVIE",
-				},
-				ExternalMetadata: api.ExternalMetadata{
-					SourcePath: path,
-					TMDB:       &api.TMDBMetadata{TMDBID: 42},
-				},
-			})
-
-			review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-				Paths: []string{path},
-				Mode:  api.ModeCLI,
-			})
-			if err != nil {
-				t.Fatalf("build upload review: %v", err)
-			}
-
-			if metadataSvc.resolveCalls != 1 {
-				t.Fatalf("expected one localized metadata refresh, got %d", metadataSvc.resolveCalls)
-			}
-			if got := metadataSvc.resolveInputs[0].Trackers; !slices.Equal(got, []string{tracker}) {
-				t.Fatalf("expected resolve to receive default tracker, got %v", got)
-			}
-			if localized := api.ExtractLocalizedPTBR(trackersSvc.lastMeta); localized.Title != "Default "+tracker {
-				t.Fatalf("expected dry-run metadata to include pt-BR title, got %#v", localized)
-			}
-			if len(review.Trackers) != 1 || review.Trackers[0].Tracker != tracker {
-				t.Fatalf("expected one %s review row, got %#v", tracker, review.Trackers)
-			}
-		})
-	}
-}
-
-func TestBuildUploadReviewDoesNotRefreshLocalizedMetadataForNonPTBRDefault(t *testing.T) {
-	t.Parallel()
-
-	metadataSvc := &recordingReviewMetadata{}
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metadataSvc,
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath:      "/tmp/a",
-		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: "/tmp/a",
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/a",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42},
-		},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-
-	if metadataSvc.resolveCalls != 0 {
-		t.Fatalf("expected no localized metadata refresh, got %d", metadataSvc.resolveCalls)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected AITHER dry-run only, got %v", trackersSvc.lastTrackers)
-	}
-	if len(review.Trackers) != 1 || review.Trackers[0].Tracker != "AITHER" {
-		t.Fatalf("expected one AITHER review row, got %#v", review.Trackers)
-	}
-}
-
-func TestUploadReviewNeedsPTBRMetadataRequiresCompleteLocalizedFields(t *testing.T) {
-	t.Parallel()
-
-	base := api.PreparedMetadata{
-		SourcePath:      "/tmp/a",
-		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: "/tmp/a",
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/a",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42},
-		},
-	}
-
-	tests := []struct {
-		name      string
-		localized api.TMDBLocalizedData
-		category  string
-		season    int
-		episode   int
-		tvPack    bool
-		trackers  []string
-		want      bool
-	}{
-		{
-			name:     "blank entry refreshes",
-			trackers: []string{"ASC"},
-			want:     true,
-		},
-		{
-			name:      "partial movie entry refreshes",
-			localized: api.TMDBLocalizedData{Title: "Titulo", Overview: "Resumo"},
-			trackers:  []string{"BT"},
-			want:      true,
-		},
-		{
-			name:      "complete movie entry skips",
-			localized: api.TMDBLocalizedData{Title: "Titulo", Overview: "Resumo", Genres: "Drama"},
-			trackers:  []string{"BJS"},
-			want:      false,
-		},
-		{
-			name:      "complete tv series entry uses series overview",
-			localized: api.TMDBLocalizedData{Title: "Titulo", Overview: "Resumo serie", Genres: "Drama"},
-			category:  "TV",
-			trackers:  []string{"ASC"},
-			want:      false,
-		},
-		{
-			name:      "complete tv episode entry can use episode overview without episode title",
-			localized: api.TMDBLocalizedData{Title: "Titulo", EpisodeOverview: "Resumo episodio", Genres: "Drama"},
-			category:  "TV",
-			season:    1,
-			episode:   2,
-			trackers:  []string{"ASC"},
-			want:      false,
-		},
-		{
-			name:      "tv episode entry with only series overview refreshes",
-			localized: api.TMDBLocalizedData{Title: "Titulo", Overview: "Resumo serie", Genres: "Drama"},
-			category:  "TV",
-			season:    1,
-			episode:   2,
-			trackers:  []string{"ASC"},
-			want:      true,
-		},
-		{
-			name:      "season pack entry with only series overview refreshes",
-			localized: api.TMDBLocalizedData{Title: "Titulo", Overview: "Resumo serie", Genres: "Drama"},
-			category:  "TV",
-			season:    1,
-			tvPack:    true,
-			trackers:  []string{"BT"},
-			want:      true,
-		},
-		{
-			name:      "tracker prefix does not refresh",
-			localized: api.TMDBLocalizedData{},
-			trackers:  []string{"ASCx"},
-			want:      false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			meta := deepCopyPreparedMetadata(base)
-			if tt.category != "" {
-				meta.ExternalIDs.Category = tt.category
-			}
-			meta.SeasonInt = tt.season
-			meta.EpisodeInt = tt.episode
-			meta.TVPack = tt.tvPack
-			meta.ExternalMetadata.TMDB.Localized = map[string]api.TMDBLocalizedData{"pt-BR": tt.localized}
-			if got := uploadReviewNeedsPTBRMetadata(meta, tt.trackers); got != tt.want {
-				t.Fatalf("uploadReviewNeedsPTBRMetadata() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestUploadReviewNeedsPTBRMetadataUsesFreshCachedTMDBMetadataID(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		SourcePath:      "/tmp/a",
-		StoredDataFresh: true,
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: "/tmp/a",
-			TMDB:       &api.TMDBMetadata{TMDBID: 42},
-		},
-	}
-	if !uploadReviewNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected source-current cached TMDB metadata ID to enable pt-BR refresh")
-	}
-
-	meta.ExternalMetadata.SourcePath = "/tmp/other"
-	if uploadReviewNeedsPTBRMetadata(meta, []string{"ASC"}) {
-		t.Fatal("expected stale cached TMDB metadata ID to skip pt-BR refresh")
-	}
-}
-
-func TestBuildUploadReviewPreservesSiteUploadSingleton(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-			Trackers:           config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}},
-		},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeCLI,
-		Execution: api.ExecutionOptions{
-			SiteUploadTracker: "AITHER",
-		},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if !slices.Equal(trackersSvc.lastTrackers, []string{"AITHER"}) {
-		t.Fatalf("expected singleton site-upload tracker, got %v", trackersSvc.lastTrackers)
-	}
-	if len(review.Trackers) != 1 || review.Trackers[0].Tracker != "AITHER" {
-		t.Fatalf("expected one AITHER review row, got %#v", review.Trackers)
-	}
-}
-
-func TestBuildUploadReviewPartialGUIReviewPreservesOmittedCacheState(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready", ReleaseName: "AITHER.NAME"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes: &reviewDupes{summary: api.DupeCheckSummary{
-				SourcePath: "/tmp/a",
-				Results: []api.DupeCheckResult{{
-					Tracker:  "AITHER",
-					HasDupes: true,
-					Status:   "completed",
-					Match: api.DupeMatch{
-						MatchedID:       "200",
-						MatchedLink:     "https://aither.cc/torrents/200",
-						MatchedDownload: "https://aither.cc/download/200.torrent",
-					},
-				}},
-			}},
-			Torrents: &stubTorrent{},
-			Trackers: trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Trackers:   []string{"AITHER", "BLU"},
-		TrackersRemove: []string{
-			"BLU",
-		},
-		MatchedTrackers: []string{
-			"BLU",
-		},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"BLU": {api.TrackerBlockReasonDupe},
-		},
-		CrossSeedTorrents: []api.UploadedTorrent{{
-			Tracker:     "BLU",
-			TorrentID:   "100",
-			DownloadURL: "https://blu/download/100.torrent",
-			TorrentURL:  "https://blu/torrents/100",
-		}},
-	})
-
-	review, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	if len(review.Trackers) != 1 || review.Trackers[0].Tracker != "AITHER" {
-		t.Fatalf("expected one AITHER review row, got %#v", review.Trackers)
-	}
-
-	exported, ok, err := coreSvc.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected exported cached metadata after partial review")
-	}
-	if got := exported.BlockedTrackers["BLU"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected BLU dupe block to survive, got %#v", exported.BlockedTrackers)
-	}
-	if got := exported.BlockedTrackers["AITHER"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected AITHER dupe block to update, got %#v", exported.BlockedTrackers)
-	}
-	if !reflect.DeepEqual(exported.TrackersRemove, []string{"BLU"}) {
-		t.Fatalf("expected reviewed tracker removals cleared and unreviewed removals preserved, got %#v", exported.TrackersRemove)
-	}
-	if !reflect.DeepEqual(exported.MatchedTrackers, []string{"BLU"}) {
-		t.Fatalf("expected reviewed tracker matches cleared and unreviewed matches preserved, got %#v", exported.MatchedTrackers)
-	}
-	if len(exported.CrossSeedTorrents) != 2 {
-		t.Fatalf("expected both cross-seed torrents to survive, got %#v", exported.CrossSeedTorrents)
-	}
-
-	runCore, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new run core: %v", err)
-	}
-	if err := runCore.ImportPreparedMetadataForGUI(context.Background(), api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, exported); err != nil {
-		t.Fatalf("import prepared metadata for gui: %v", err)
-	}
-	imported, ok := runCore.lookupGUICachedMeta(api.Request{
-		Paths: []string{"/tmp/a"},
-		Mode:  api.ModeGUI,
-	}, "/tmp/a")
-	if !ok {
-		t.Fatal("expected imported cached metadata")
-	}
-	if got := imported.BlockedTrackers["BLU"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected imported BLU dupe block to survive, got %#v", imported.BlockedTrackers)
-	}
-	if len(imported.CrossSeedTorrents) != 2 {
-		t.Fatalf("expected imported cross-seed torrents to survive, got %#v", imported.CrossSeedTorrents)
-	}
-}
-
-func TestBuildUploadReviewPartialGUIReviewRetainsRefreshedExternalMetadata(t *testing.T) {
-	t.Parallel()
-
-	path := "/tmp/selected-ptbr"
-	metadataSvc := &recordingReviewMetadata{
-		resolveFn: func(meta api.PreparedMetadata) api.PreparedMetadata {
-			meta.ExternalMetadata.TMDB.Localized["pt-BR"] = api.TMDBLocalizedData{
-				Title:    "Selecionado",
-				Overview: "Resumo selecionado",
-				Genres:   "Drama",
-			}
-			return meta
-		},
-	}
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "ASC", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   metadataSvc,
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	coreSvc.storeDupeCache(path, "", api.PreparedMetadata{
-		SourcePath:      path,
-		StoredDataFresh: true,
-		Trackers:        []string{"ASC", "BLU"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"BLU": {api.TrackerBlockReasonDupe},
-		},
-		ExternalIDs: api.ExternalIDs{
-			SourcePath: path,
-			TMDBID:     42,
-			Category:   "MOVIE",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			SourcePath: path,
-			TMDB: &api.TMDBMetadata{
-				TMDBID: 42,
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {Title: "Antigo"},
-				},
-			},
-		},
-	})
-
-	if _, err := coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{path},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"ASC"},
-	}); err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	exported, ok, err := coreSvc.ExportGUICachedPreparedMeta(context.Background(), api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeGUI,
-	})
-	if err != nil {
-		t.Fatalf("export gui cached prepared meta: %v", err)
-	}
-	if !ok {
-		t.Fatal("expected exported cached metadata")
-	}
-	localized := api.ExtractLocalizedPTBR(exported)
-	if localized.Title != "Selecionado" || localized.Overview != "Resumo selecionado" || localized.Genres != "Drama" {
-		t.Fatalf("expected selected review cache to retain refreshed external metadata, got %#v", localized)
-	}
-	if got := exported.BlockedTrackers["BLU"]; len(got) != 1 || got[0] != api.TrackerBlockReasonDupe {
-		t.Fatalf("expected unreviewed BLU state preserved, got %#v", exported.BlockedTrackers)
-	}
-}
-
-func TestMergeUploadReviewCacheMetaRefreshesReviewedTrackerStateWithMixedCaseBaseKeys(t *testing.T) {
-	t.Parallel()
-
-	base := api.PreparedMetadata{
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AiThEr": {api.TrackerBlockReasonDupe},
-			"BLU":    {api.TrackerBlockReasonClaim},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AiThEr": {{Rule: "old_aither", Reason: "stale"}},
-			"aither": {{Rule: "older_aither", Reason: "staler"}},
-			"BLU":    {{Rule: "old_blu", Reason: "keep"}},
-		},
-		TrackersRemove:  []string{"AiThEr", "BLU"},
-		MatchedTrackers: []string{"AiThEr", "BLU"},
-		CrossSeedTorrents: []api.UploadedTorrent{
-			{Tracker: "AiThEr", TorrentID: "1"},
-			{Tracker: "BLU", TorrentID: "2"},
-		},
-	}
-	updated := api.PreparedMetadata{
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"aItHeR": {api.TrackerBlockReasonAudio, api.TrackerBlockReasonDupe},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"aither": {{Rule: "new_aither", Reason: "fresh"}},
-		},
-		TrackersRemove: []string{"aither"},
-		CrossSeedTorrents: []api.UploadedTorrent{
-			{Tracker: "AITHER", TorrentID: "3"},
-		},
-	}
-
-	merged := mergeUploadReviewCacheMeta(base, updated, []string{"AITHER"})
-
-	if got := merged.BlockedTrackers["AITHER"]; !reflect.DeepEqual(got, []api.TrackerBlockReason{api.TrackerBlockReasonAudio, api.TrackerBlockReasonDupe}) {
-		t.Fatalf("expected reviewed tracker blocks to refresh, got %#v", got)
-	}
-	if _, ok := merged.BlockedTrackers["AiThEr"]; ok {
-		t.Fatalf("expected mixed-case reviewed tracker block key removed, got %#v", merged.BlockedTrackers)
-	}
-	if got := merged.BlockedTrackers["BLU"]; !reflect.DeepEqual(got, []api.TrackerBlockReason{api.TrackerBlockReasonClaim}) {
-		t.Fatalf("expected unreviewed tracker blocks to remain, got %#v", got)
-	}
-	if got := merged.TrackerRuleFailures["AITHER"]; !reflect.DeepEqual(got, []api.RuleFailure{{Rule: "new_aither", Reason: "fresh"}}) {
-		t.Fatalf("expected reviewed tracker rule failures to refresh, got %#v", got)
-	}
-	if _, ok := merged.TrackerRuleFailures["AiThEr"]; ok {
-		t.Fatalf("expected mixed-case reviewed tracker rule failure key removed, got %#v", merged.TrackerRuleFailures)
-	}
-	if _, ok := merged.TrackerRuleFailures["aither"]; ok {
-		t.Fatalf("expected duplicate reviewed tracker rule failure key removed, got %#v", merged.TrackerRuleFailures)
-	}
-	if got := merged.TrackerRuleFailures["BLU"]; !reflect.DeepEqual(got, []api.RuleFailure{{Rule: "old_blu", Reason: "keep"}}) {
-		t.Fatalf("expected unreviewed tracker rule failures to remain, got %#v", got)
-	}
-	if !reflect.DeepEqual(merged.TrackersRemove, []string{"BLU", "AITHER"}) {
-		t.Fatalf("expected reviewed tracker removals to refresh and unreviewed removals to remain, got %#v", merged.TrackersRemove)
-	}
-	if !reflect.DeepEqual(merged.MatchedTrackers, []string{"BLU"}) {
-		t.Fatalf("expected reviewed matched tracker cleared and unreviewed match preserved, got %#v", merged.MatchedTrackers)
-	}
-	if len(merged.CrossSeedTorrents) != 2 {
-		t.Fatalf("expected merged cross-seed torrents, got %#v", merged.CrossSeedTorrents)
-	}
-	if len(base.CrossSeedTorrents) != 2 || len(updated.CrossSeedTorrents) != 1 {
-		t.Fatalf("expected merge to avoid aliasing, base=%#v updated=%#v", base.CrossSeedTorrents, updated.CrossSeedTorrents)
-	}
-	coreSvc := &Core{logger: api.NopLogger{}}
-	eligible := mergeUploadReviewCacheMeta(base, api.PreparedMetadata{}, []string{"AITHER"})
-	if got := coreSvc.filterImageUploadTrackers([]string{"AITHER", "BLU"}, eligible); !reflect.DeepEqual(got, []string{"AITHER"}) {
-		t.Fatalf("expected reviewed tracker image upload eligibility restored after merge, got %#v", got)
-	}
-}
-
-func TestBuildUploadReviewCommitsReviewedTrackerUpdateFromMatchingRefreshedCache(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{
-			{Tracker: "AITHER", Status: "ready"},
-			{Tracker: "BLU", Status: "ready"},
-		},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	initial := api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Mode:       api.ModeGUI,
-		Options: api.UploadOptions{
-			InteractionMode: api.InteractionModeInteractive,
-			Screens:         1,
-		},
-		Trackers: []string{"BLU", "AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonDupe},
-			"BLU":    {api.TrackerBlockReasonDupe},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"BLU": {{Rule: "old_blu", Reason: "keep"}},
-		},
-		CrossSeedTorrents: []api.UploadedTorrent{
-			{Tracker: "AITHER", TorrentID: "1", DownloadURL: "https://dupes/aither"},
-			{Tracker: "BLU", TorrentID: "2", DownloadURL: "https://dupes/blu"},
-		},
-	}
-	coreSvc.storeRefreshedDupeCache("/tmp/a", "", initial)
-
-	_, err = coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"aither", "blu"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	entry, _, ok := coreSvc.lookupGUICachedMetaEntry(api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"aither", "blu"},
-	}, "/tmp/a")
-	if !ok {
-		t.Fatal("expected gui cache entry")
-	}
-	if entry.requestRefreshed {
-		t.Fatal("expected matching refreshed cache entry to commit as stable cache")
-	}
-	if got := entry.meta.BlockedTrackers["AITHER"]; len(got) != 0 {
-		t.Fatalf("expected reviewed tracker dupe block cleared, got %#v", entry.meta.BlockedTrackers)
-	}
-}
-
-func TestBuildUploadReviewSkipsCacheCommitWhenRefreshedBaseDoesNotMatchRequest(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "BLU", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	initial := api.PreparedMetadata{
-		SourcePath: "/tmp/a",
-		Mode:       api.ModeGUI,
-		Options: api.UploadOptions{
-			InteractionMode: api.InteractionModeInteractive,
-			Screens:         1,
-		},
-		Trackers: []string{"AITHER"},
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"BLU": {api.TrackerBlockReasonDupe},
-		},
-	}
-	coreSvc.storeRefreshedDupeCache("/tmp/a", "", initial)
-
-	_, err = coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"BLU"},
-	})
-	if err != nil {
-		t.Fatalf("build upload review: %v", err)
-	}
-	entry, _, ok := coreSvc.lookupGUICachedMetaEntry(api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"BLU"},
-	}, "/tmp/a")
-	if !ok {
-		t.Fatal("expected gui cache entry")
-	}
-	if !entry.requestRefreshed {
-		t.Fatal("expected mismatched refreshed cache entry to remain request-refreshed")
-	}
-	if !reflect.DeepEqual(entry.meta, initial) {
-		t.Fatalf("expected mismatched refreshed cache entry unchanged, got %#v", entry.meta)
-	}
-}
-
-func TestBuildUploadReviewDoesNotCorruptCacheWhenTorrentCreateFails(t *testing.T) {
-	t.Parallel()
-
-	torrentSvc := &recordingReviewTorrent{err: errors.New("torrent create failed")}
-	trackersSvc := &recordingReviewTrackers{
-		entries: []api.TrackerDryRunEntry{{Tracker: "AITHER", Status: "ready"}},
-	}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   torrentSvc,
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	initial := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER"}}
-	coreSvc.storeRefreshedDupeCache("/tmp/a", "", initial)
-
-	_, err = coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err == nil || !strings.Contains(err.Error(), "torrent create failed") {
-		t.Fatalf("expected torrent create failure, got %v", err)
-	}
-	entry, _, ok := coreSvc.lookupGUICachedMetaEntry(api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	}, "/tmp/a")
-	if !ok {
-		t.Fatal("expected gui cache entry")
-	}
-	if !reflect.DeepEqual(entry.meta, initial) {
-		t.Fatalf("expected cache entry unchanged after torrent failure, got %#v", entry.meta)
-	}
-}
-
-func TestBuildUploadReviewDoesNotCorruptCacheWhenDryRunFails(t *testing.T) {
-	t.Parallel()
-
-	trackersSvc := &recordingReviewTrackers{err: errors.New("dry-run failed")}
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-			Metadata:   &stubMeta{},
-			Dupes:      &reviewDupes{},
-			Torrents:   &stubTorrent{},
-			Trackers:   trackersSvc,
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	initial := api.PreparedMetadata{SourcePath: "/tmp/a", Trackers: []string{"AITHER"}}
-	coreSvc.storeRefreshedDupeCache("/tmp/a", "", initial)
-
-	_, err = coreSvc.BuildUploadReview(context.Background(), api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	})
-	if err == nil || !strings.Contains(err.Error(), "dry-run failed") {
-		t.Fatalf("expected dry-run failure, got %v", err)
-	}
-	entry, _, ok := coreSvc.lookupGUICachedMetaEntry(api.Request{
-		Paths:    []string{"/tmp/a"},
-		Mode:     api.ModeGUI,
-		Trackers: []string{"AITHER"},
-	}, "/tmp/a")
-	if !ok {
-		t.Fatal("expected gui cache entry")
-	}
-	if !reflect.DeepEqual(entry.meta, initial) {
-		t.Fatalf("expected cache entry unchanged after dry-run failure, got %#v", entry.meta)
-	}
-}
-
-func TestGetGUICachedMetaFallsBackWhenNonExternalSignatureMismatch(t *testing.T) {
-	t.Parallel()
-
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	coreSvc.storeDupeCache("/tmp/a", "", api.PreparedMetadata{SourcePath: "/tmp/a"})
-	if cached, ok := coreSvc.getGUICachedMeta("/tmp/a", "originalLanguage=ja", api.ExternalIDOverrides{}); !ok {
-		t.Fatalf("expected signed GUI cache lookup to reuse non-external cached metadata")
-	} else if cached.SourcePath != "/tmp/a" {
-		t.Fatalf("expected cached metadata source path, got %q", cached.SourcePath)
-	}
-}
-
-func TestGetGUICachedMetaReusesSignedEntryForEmptySignatureWhenNonExternal(t *testing.T) {
-	t.Parallel()
-
-	coreSvc, err := New(api.CoreDependencies{
-		Config: config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "x"}, ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-		Services: api.ServiceSet{
-			Filesystem: &stubFS{},
-		},
-		Repository: &stubRepo{},
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-
-	coreSvc.storeDupeCache("/tmp/a", "originalLanguage=ja", api.PreparedMetadata{SourcePath: "/tmp/a"})
-	if cached, ok := coreSvc.getGUICachedMeta("/tmp/a", "", api.ExternalIDOverrides{}); !ok {
-		t.Fatalf("expected unsigned GUI cache lookup to reuse signed non-external cached metadata")
-	} else if cached.SourcePath != "/tmp/a" {
-		t.Fatalf("expected cached metadata source path, got %q", cached.SourcePath)
-	}
-}
-
-func TestApplyRequestToPreparedMetaDoesNotMutateCachedExternalMetadata(t *testing.T) {
-	t.Parallel()
-
-	original := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				OriginalLanguage: "en",
-				LocalizedTitles:  map[string]string{"de": "Titel"},
-			},
-		},
-	}
-	updatedLanguage := "ja"
-	result := applyRequestToPreparedMeta(original, api.Request{
-		MetadataOverrides: api.MetadataOverrides{OriginalLanguage: &updatedLanguage},
-	}, config.Config{}, api.NopLogger{})
-
-	if original.ExternalMetadata.TMDB == nil || original.ExternalMetadata.TMDB.OriginalLanguage != "en" {
-		t.Fatalf("expected cached metadata to remain unchanged, got %#v", original.ExternalMetadata)
-	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.TMDB.OriginalLanguage != "ja" {
-		t.Fatalf("expected request-scoped metadata override to apply, got %#v", result.ExternalMetadata)
-	}
-	result.ExternalMetadata.TMDB.LocalizedTitles["de"] = "Changed"
-	result.ExternalMetadata.TMDB.LocalizedTitles["fr"] = "Titre"
-	if got := original.ExternalMetadata.TMDB.LocalizedTitles["de"]; got != "Titel" {
-		t.Fatalf("expected cached localized title unchanged, got %q", got)
-	}
-	if _, ok := original.ExternalMetadata.TMDB.LocalizedTitles["fr"]; ok {
-		t.Fatalf("expected cached localized titles to ignore request mutation, got %#v", original.ExternalMetadata.TMDB.LocalizedTitles)
-	}
-}
-
-func TestMergeTrackerIDOverridesNormalizesExistingKeys(t *testing.T) {
-	t.Parallel()
-
-	spacedExistingKey := " AITHER "
-	spacedOverrideKey := " RF "
-	existing := map[string]string{
-		spacedExistingKey: " 10001 ",
-		"RF":              " ",
-		"":                "10002",
-	}
-	overrides := map[string]string{
-		"aither":          "20001",
-		spacedOverrideKey: " 20002 ",
-	}
-
-	merged := mergeTrackerIDOverrides(existing, overrides)
-
-	if len(merged) != 2 {
-		t.Fatalf("expected two normalized tracker ids, got %#v", merged)
-	}
-	if got := merged["aither"]; got != "20001" {
-		t.Fatalf("expected override to replace normalized existing id, got %q", got)
-	}
-	if got := merged["rf"]; got != "20002" {
-		t.Fatalf("expected normalized override id, got %q", got)
-	}
-	if _, ok := merged[" AITHER "]; ok {
-		t.Fatalf("expected unnormalized existing key removed, got %#v", merged)
-	}
-}
diff --git a/internal/services/description/bbcode.go b/internal/description/bbcode.go
similarity index 100%
rename from internal/services/description/bbcode.go
rename to internal/description/bbcode.go
diff --git a/internal/services/description/description_test.go b/internal/description/description_test.go
similarity index 100%
rename from internal/services/description/description_test.go
rename to internal/description/description_test.go
diff --git a/internal/services/description/mediainfo.go b/internal/description/mediainfo.go
similarity index 100%
rename from internal/services/description/mediainfo.go
rename to internal/description/mediainfo.go
diff --git a/internal/services/description/render.go b/internal/description/render.go
similarity index 75%
rename from internal/services/description/render.go
rename to internal/description/render.go
index 90896409..f9495241 100644
--- a/internal/services/description/render.go
+++ b/internal/description/render.go
@@ -10,6 +10,9 @@ import (
 
 var htmlTagPattern = regexp.MustCompile(`(?i)<[a-z][^>]*>`)
 
+// Render converts BBCode, MediaInfo blocks, or existing HTML into HTML that has
+// passed the package's element, attribute, class, style, and URL allowlists.
+// Blank input returns an empty string.
 func Render(raw string) string {
 	trimmed := strings.TrimSpace(raw)
 	if trimmed == "" {
diff --git a/internal/services/description/sanitize.go b/internal/description/sanitize.go
similarity index 94%
rename from internal/services/description/sanitize.go
rename to internal/description/sanitize.go
index 3e5890ab..d9f4a832 100644
--- a/internal/services/description/sanitize.go
+++ b/internal/description/sanitize.go
@@ -63,16 +63,30 @@ var allowedAttrs = map[string]map[string]bool{
 	"a":          {"href": true, "title": true},
 	"blockquote": {"style": true, "align": true},
 	"details":    {"class": true},
-	"div":        {"style": true, "class": true, "align": true},
+	"div": {
+		"style": true,
+		"class": true,
+		"align": true,
+	},
 	"figcaption": {"class": true},
 	"figure":     {"class": true},
-	"img":        {"src": true, "alt": true, "title": true, "class": true, "width": true},
-	"p":          {"style": true, "align": true},
-	"section":    {"class": true},
-	"span":       {"style": true, "class": true, "align": true},
-	"summary":    {"class": true},
-	"ul":         {"class": true},
-	"li":         {"class": true},
+	"img": {
+		"src":   true,
+		"alt":   true,
+		"title": true,
+		"class": true,
+		"width": true,
+	},
+	"p":       {"style": true, "align": true},
+	"section": {"class": true},
+	"span": {
+		"style": true,
+		"class": true,
+		"align": true,
+	},
+	"summary": {"class": true},
+	"ul":      {"class": true},
+	"li":      {"class": true},
 }
 
 func sanitizeHTML(input string) string {
@@ -112,7 +126,11 @@ func tryParseUnescapedHTML(input string) ([]*xhtml.Node, bool) {
 }
 
 func fragmentContext() *xhtml.Node {
-	return &xhtml.Node{Type: xhtml.ElementNode, Data: "div", DataAtom: xatom.Div}
+	return &xhtml.Node{
+		Type:     xhtml.ElementNode,
+		Data:     "div",
+		DataAtom: xatom.Div,
+	}
 }
 
 func hasElementNodes(nodes []*xhtml.Node) bool {
diff --git a/internal/description/unit3d/builder.go b/internal/description/unit3d/builder.go
new file mode 100644
index 00000000..51258f89
--- /dev/null
+++ b/internal/description/unit3d/builder.go
@@ -0,0 +1,578 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const uaSignatureText = "Uploaded by upbrr"
+const uaSignatureLink = "https://github.com/autobrr/upbrr"
+const dvdVOBMediaInfoHeader = "[spoiler=VOB MediaInfo][code]"
+const dvdVOBMediaInfoFooter = "[/code][/spoiler]"
+
+var collapseNewlines = regexp.MustCompile(`\n{3,}`)
+var bbcodeImageTag = regexp.MustCompile(`(?is)\[img(?:=[^\]]*)?\](.*?)\[/img\]`)
+
+var unit3DBotSignatureTag = regexp.MustCompile(
+	`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`,
+)
+var unit3DEmptyCenterTag = regexp.MustCompile(`(?is)\[center\]\s*\[/center\]`)
+var unit3DAlignBlockTag = regexp.MustCompile(`(?is)\[align=(center|left|right)\](.*?)\[/align\]`)
+var unit3DWrapperBlockTag = regexp.MustCompile(`(?is)\[(center|align=(?:center|left|right))\](.*?)\[/(center|align)\]`)
+var unit3DWidthImageTag = regexp.MustCompile(`(?i)\[img\s+width=(\d+)\]`)
+
+var unit3DUASignatureTag = regexp.MustCompile(
+	`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`,
+)
+
+var unit3DNFOBlockTag = regexp.MustCompile(
+	`(?is)\[(?:center|align=center)\]\s*\[spoiler=(?:Scene|FraMeSToR) NFO:\]\[code\].*?\[/code\]\[/spoiler\]\s*\[/(?:center|align)\]`,
+)
+
+// BuildDescription composes the shared Unit3D upload description from prepared
+// metadata and selected images. Existing NFO and known uploader signature
+// blocks are removed; when screenshots are supplied, prior screenshot blocks
+// are replaced. Case-insensitive duplicate top-level parts are skipped. The
+// general MediaInfo payload intended for the upload API is not embedded, though
+// DVD VOB MediaInfo may be rendered as a dedicated block.
+func BuildDescription(
+	ctx context.Context,
+	meta api.DescriptionSubject,
+	appConfig config.Config,
+	_ config.TrackerConfig,
+	logger api.Logger,
+	keptDescription string,
+	menuImages []api.ScreenshotImage,
+	screenshots []api.ScreenshotImage,
+) (string, error) {
+	select {
+	case <-ctx.Done():
+		return "", fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+
+	if len(screenshots) > 0 {
+		meta.DescriptionTemplate = stripUnit3DScreenshotBlocks(meta.DescriptionTemplate)
+		keptDescription = stripUnit3DScreenshotBlocks(keptDescription)
+	}
+
+	meta.DescriptionTemplate = stripUnit3DNFOBlocks(meta.DescriptionTemplate)
+	keptDescription = stripUnit3DNFOBlocks(keptDescription)
+
+	parts := make([]string, 0, 10)
+	seenParts := make(map[string]struct{}, 4)
+	appendUniquePart := func(value string, logLabel string) {
+		normalized := strings.TrimSpace(value)
+		if normalized == "" {
+			return
+		}
+		key := strings.ToLower(normalized)
+		if _, ok := seenParts[key]; ok {
+			logger.Debugf("trackers: unit3d desc skipped duplicate part=%s", logLabel)
+			return
+		}
+		seenParts[key] = struct{}{}
+		parts = append(parts, normalized)
+	}
+	if template := stripUnit3DSignature(strings.TrimSpace(meta.DescriptionTemplate)); template != "" {
+		appendUniquePart(template, "template")
+		logger.Tracef("trackers: unit3d desc part=template len=%d", len(template))
+	}
+	if kept := stripUnit3DSignature(strings.TrimSpace(keptDescription)); kept != "" {
+		appendUniquePart(kept, "kept")
+		logger.Tracef("trackers: unit3d desc part=kept len=%d imgs=%d", len(kept), countBBCodeImages(kept))
+	}
+	if header := strings.TrimSpace(appConfig.Description.CustomDescriptionHeader); header != "" {
+		appendUniquePart(header, "custom_header")
+		logger.Tracef("trackers: unit3d desc part=custom_header len=%d", len(header))
+	}
+
+	logoURL, logoSize := ResolveLogo(meta, appConfig)
+	if logoURL != "" {
+		appendUniquePart(fmt.Sprintf("[center][img=%d]%s[/img][/center]", logoSize, logoURL), "logo")
+		logger.Tracef("trackers: unit3d desc part=logo size=%d", logoSize)
+	}
+
+	if episodeOverview := EpisodeOverviewBlock(meta, appConfig); episodeOverview != "" {
+		appendUniquePart(episodeOverview, "episode_overview")
+		logger.Tracef("trackers: unit3d desc part=episode_overview len=%d", len(episodeOverview))
+	}
+
+	if bluray := BlurayBlock(meta, appConfig); bluray != "" {
+		appendUniquePart(bluray, "bluray")
+		logger.Tracef("trackers: unit3d desc part=bluray")
+	}
+
+	if vobMediaInfo := DVDVOBMediaInfoBlock(meta); vobMediaInfo != "" {
+		appendUniquePart(vobMediaInfo, "dvd_vob_mediainfo")
+		logger.Tracef("trackers: unit3d desc part=dvd_vob_mediainfo")
+	}
+
+	if tonemapHeader := strings.TrimSpace(
+		appConfig.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		ShouldIncludeTonemappedHeader(meta, appConfig, screenshots) {
+		appendUniquePart(tonemapHeader, "tonemap_header")
+		logger.Tracef("trackers: unit3d desc part=tonemap_header len=%d", len(tonemapHeader))
+	}
+
+	if len(menuImages) > 0 {
+		menuHeader := strings.TrimSpace(appConfig.Description.DiscMenuHeader)
+		if menuHeader != "" {
+			appendUniquePart(menuHeader, "menu_header")
+		}
+		menuSection := buildScreenshotSection(menuImages, appConfig.Description.ThumbnailSize, parseScreensPerRow(appConfig.Description.ScreensPerRow))
+		if menuSection != "" {
+			appendUniquePart(menuSection, "menu_images")
+			logger.Tracef("trackers: unit3d desc part=menu_images count=%d", len(menuImages))
+		}
+	}
+
+	logger.Tracef("trackers: unit3d desc part=mediainfo skipped (sent via API)")
+
+	filteredScreenshots := filterScreenshotDuplicates(screenshots, keptDescription, menuImages)
+	logger.Tracef("trackers: unit3d desc screenshots total=%d filtered=%d", len(screenshots), len(filteredScreenshots))
+	screenshotHeader := strings.TrimSpace(appConfig.Description.ScreenshotHeader)
+	screenshotSection := buildScreenshotSection(
+		filteredScreenshots,
+		appConfig.Description.ThumbnailSize,
+		parseScreensPerRow(appConfig.Description.ScreensPerRow),
+	)
+	if screenshotSection != "" && screenshotHeader != "" {
+		appendUniquePart(screenshotHeader, "screenshot_header")
+		logger.Tracef("trackers: unit3d desc part=screenshot_header len=%d", len(screenshotHeader))
+	}
+	if screenshotSection != "" {
+		appendUniquePart(screenshotSection, "screenshots")
+		logger.Tracef("trackers: unit3d desc part=screenshots count=%d", countBBCodeImages(screenshotSection))
+	}
+	if customSignature := strings.TrimSpace(appConfig.Description.CustomSignature); customSignature != "" {
+		appendUniquePart(customSignature, "custom_signature")
+		logger.Tracef("trackers: unit3d desc part=custom_signature len=%d", len(customSignature))
+	} else {
+		link, text := UppbrrSignatureLink()
+		appendUniquePart(fmt.Sprintf("[right][url=%s][size=4]%s[/size][/url][/right]", link, text), "signature")
+		logger.Tracef("trackers: unit3d desc part=signature")
+	}
+
+	description := normalizeDescription(strings.Join(parts, "\n\n"))
+	description = finalizeUnit3DDescription(description)
+	if strings.TrimSpace(description) == "" {
+		return "", nil
+	}
+
+	return description, nil
+}
+
+func buildScreenshotSection(images []api.ScreenshotImage, thumbnailSize int, screensPerRow int) string {
+	if thumbnailSize <= 0 {
+		thumbnailSize = 350
+	}
+	if screensPerRow <= 0 {
+		screensPerRow = 2
+	}
+	rows := make([]string, 0)
+	rowParts := make([]string, 0, screensPerRow)
+	for _, image := range images {
+		imgTag := buildScreenshotTag(image, thumbnailSize)
+		if imgTag == "" {
+			continue
+		}
+		rowParts = append(rowParts, imgTag)
+		if len(rowParts) == screensPerRow {
+			rows = append(rows, strings.Join(rowParts, " "))
+			rowParts = rowParts[:0]
+		}
+	}
+	if len(rowParts) > 0 {
+		rows = append(rows, strings.Join(rowParts, " "))
+	}
+	if len(rows) == 0 {
+		return ""
+	}
+	return "[center]\n" + strings.Join(rows, "\n") + "\n[/center]"
+}
+
+func buildScreenshotTag(image api.ScreenshotImage, thumbnailSize int) string {
+	webURL := strings.TrimSpace(image.WebURL)
+	rawURL := strings.TrimSpace(image.RawURL)
+	if webURL != "" && rawURL != "" {
+		return fmt.Sprintf("[url=%s][img=%d]%s[/img][/url]", webURL, thumbnailSize, rawURL)
+	}
+	url := pickScreenshotURL(image)
+	if url == "" {
+		return ""
+	}
+	return fmt.Sprintf("[img=%d]%s[/img]", thumbnailSize, url)
+}
+
+func parseScreensPerRow(value string) int {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 2
+	}
+	parsed, err := strconv.Atoi(trimmed)
+	if err != nil || parsed <= 0 {
+		return 2
+	}
+	return parsed
+}
+
+func filterScreenshotDuplicates(images []api.ScreenshotImage, keptDescription string, menuImages []api.ScreenshotImage) []api.ScreenshotImage {
+	if len(images) == 0 {
+		return images
+	}
+	seen := extractBBCodeImageURLs(keptDescription)
+	if seen == nil {
+		seen = make(map[string]struct{})
+	}
+	for _, img := range menuImages {
+		u := pickScreenshotURL(img)
+		if u != "" {
+			seen[u] = struct{}{}
+		}
+	}
+	if len(seen) == 0 {
+		return images
+	}
+	filtered := make([]api.ScreenshotImage, 0, len(images))
+	for _, image := range images {
+		url := pickScreenshotURL(image)
+		if url == "" {
+			continue
+		}
+		if _, ok := seen[url]; ok {
+			continue
+		}
+		filtered = append(filtered, image)
+	}
+	return filtered
+}
+
+func extractBBCodeImageURLs(value string) map[string]struct{} {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return nil
+	}
+	matches := bbcodeImageTag.FindAllStringSubmatch(trimmed, -1)
+	if len(matches) == 0 {
+		return nil
+	}
+	results := make(map[string]struct{}, len(matches))
+	for _, match := range matches {
+		if len(match) < 2 {
+			continue
+		}
+		url := strings.TrimSpace(match[1])
+		if url == "" {
+			continue
+		}
+		results[url] = struct{}{}
+	}
+	return results
+}
+
+func countBBCodeImages(value string) int {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 0
+	}
+	return len(bbcodeImageTag.FindAllStringSubmatch(trimmed, -1))
+}
+
+func pickScreenshotURL(image api.ScreenshotImage) string {
+	url := strings.TrimSpace(image.ImgURL)
+	if url == "" {
+		url = strings.TrimSpace(image.RawURL)
+	}
+	if url == "" {
+		url = strings.TrimSpace(image.WebURL)
+	}
+	return url
+}
+
+func stripUnit3DSignature(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	trimmed = unit3DBotSignatureTag.ReplaceAllString(trimmed, "")
+	trimmed = unit3DEmptyCenterTag.ReplaceAllString(trimmed, "")
+	return strings.TrimSpace(unit3DUASignatureTag.ReplaceAllString(trimmed, ""))
+}
+
+func stripUnit3DScreenshotBlocks(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	cleaned := unit3DWrapperBlockTag.ReplaceAllStringFunc(trimmed, func(match string) string {
+		parts := unit3DWrapperBlockTag.FindStringSubmatch(match)
+		if len(parts) != 4 {
+			return match
+		}
+		if !isUnit3DScreenshotBlock(parts[2]) {
+			return match
+		}
+		return ""
+	})
+	return normalizeDescription(cleaned)
+}
+
+func stripUnit3DNFOBlocks(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	return normalizeDescription(unit3DNFOBlockTag.ReplaceAllString(trimmed, ""))
+}
+
+func isUnit3DScreenshotBlock(value string) bool {
+	images := extractUnit3DBlockImages(value)
+	if len(images) == 0 || isPosterLikeTopBlock(images) {
+		return false
+	}
+	withoutLinkedImages := unit3dURLImgPattern.ReplaceAllString(value, "")
+	withoutImages := unit3dImgPattern.ReplaceAllString(withoutLinkedImages, "")
+	return strings.TrimSpace(withoutImages) == ""
+}
+
+func extractUnit3DBlockImages(value string) []Image {
+	report := extractUnit3DImages(value)
+	images := make([]Image, 0, len(report))
+	for _, image := range report {
+		images = append(images, Image{
+			ImgURL: image.ImgURL,
+			RawURL: image.RawURL,
+			WebURL: image.WebURL,
+			Host:   image.Host,
+		})
+	}
+	return images
+}
+
+// ShouldIncludeTonemappedHeader reports whether the description should label tonemapped screenshots.
+func ShouldIncludeTonemappedHeader(meta api.DescriptionSubject, appConfig config.Config, screenshots []api.ScreenshotImage) bool {
+	if !appConfig.ScreenshotHandling.ToneMap {
+		return false
+	}
+	if len(screenshots) == 0 {
+		return false
+	}
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	return strings.Contains(hdr, "HDR") || strings.Contains(hdr, "DV")
+}
+
+// ResolveLogo returns the configured description logo URL and display width for meta.
+func ResolveLogo(meta api.DescriptionSubject, appConfig config.Config) (string, int) {
+	if !appConfig.Description.AddLogo {
+		return "", 0
+	}
+	logoURL := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		logoURL = strings.TrimSpace(meta.ProviderMetadata.TMDB.Logo)
+		if logoURL == "" {
+			logoURL = strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo)
+		}
+	}
+	if logoURL == "" {
+		return "", 0
+	}
+	size := appConfig.Description.LogoSize
+	if size <= 0 {
+		size = 300
+	}
+	return logoURL, size
+}
+
+// EpisodeOverviewBlock renders the episode overview section when applicable.
+func EpisodeOverviewBlock(meta api.DescriptionSubject, appConfig config.Config) string {
+	if !appConfig.Description.EpisodeOverview {
+		return ""
+	}
+	overview := strings.TrimSpace(meta.EpisodeOverview)
+	if overview == "" {
+		return ""
+	}
+	return "[center]" + escapeBBCode(overview) + "[/center]"
+}
+
+// BlurayBlock renders the Blu-ray metadata section when applicable.
+func BlurayBlock(meta api.DescriptionSubject, appConfig config.Config) string {
+	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") && !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return ""
+	}
+	if meta.ProviderMetadata.Bluray == nil {
+		return ""
+	}
+	candidate := meta.ProviderMetadata.Bluray.SelectedCandidate()
+	if candidate == nil {
+		return ""
+	}
+	parts := make([]string, 0, 2)
+	if appConfig.Description.AddBlurayLink {
+		if releaseURL := sanitizeBlurayReleaseURL(candidate.URL); releaseURL != "" {
+			parts = append(parts, "[center]"+releaseURL+"[/center]")
+		}
+	}
+	if appConfig.Description.UseBlurayImages && len(candidate.CoverImages) > 0 {
+		size := appConfig.Description.BlurayImageSize
+		if size <= 0 {
+			size = 250
+		}
+		imageTags := make([]string, 0, len(candidate.CoverImages))
+		for _, image := range candidate.CoverImages {
+			imageURL := sanitizeDescriptionURL(image.URL)
+			if imageURL == "" {
+				continue
+			}
+			imageTags = append(imageTags, fmt.Sprintf("[img=%d]%s[/img]", size, imageURL))
+		}
+		if len(imageTags) > 0 {
+			parts = append(parts, "[center]"+strings.Join(imageTags, " ")+"[/center]")
+		}
+	}
+	return strings.Join(parts, "\n")
+}
+
+func sanitizeBlurayReleaseURL(rawURL string) string {
+	return sanitizeDescriptionURL(rawURL)
+}
+
+func sanitizeDescriptionURL(rawURL string) string {
+	trimmed := strings.TrimSpace(rawURL)
+	if trimmed == "" {
+		return ""
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil || parsed.Host == "" {
+		return ""
+	}
+	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
+	if scheme != "http" && scheme != "https" {
+		return ""
+	}
+	return escapeBBCode(parsed.String())
+}
+
+func escapeBBCode(value string) string {
+	return strings.NewReplacer("[", "%5B", "]", "%5D").Replace(value)
+}
+
+// UppbrrSignatureLink returns the project URL followed by the signature label
+// used in descriptions.
+func UppbrrSignatureLink() (string, string) {
+	return uaSignatureLink, uaSignatureText
+}
+
+// DVDVOBMediaInfoBlock renders MediaInfo for DVD VOB content.
+func DVDVOBMediaInfoBlock(meta api.DescriptionSubject) string {
+	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return ""
+	}
+	vobText := strings.TrimSpace(meta.DVDVOBMediaInfoText)
+	if vobText == "" {
+		return ""
+	}
+	return dvdVOBMediaInfoHeader + vobText + dvdVOBMediaInfoFooter
+}
+
+// AppendDVDVOBMediaInfoBlock appends DVD VOB MediaInfo when meta contains it.
+func AppendDVDVOBMediaInfoBlock(description string, meta api.DescriptionSubject) string {
+	trimmedDescription := strings.TrimSpace(description)
+	block := DVDVOBMediaInfoBlock(meta)
+	if block == "" {
+		return trimmedDescription
+	}
+	if trimmedDescription == "" {
+		return block
+	}
+	if strings.Contains(trimmedDescription, block) {
+		return trimmedDescription
+	}
+	if strings.Contains(trimmedDescription, dvdVOBMediaInfoHeader) && strings.Contains(trimmedDescription, strings.TrimSpace(meta.DVDVOBMediaInfoText)) {
+		return trimmedDescription
+	}
+	return normalizeDescription(trimmedDescription + "\n\n" + block)
+}
+
+func normalizeDescription(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	cleaned := collapseNewlines.ReplaceAllString(trimmed, "\n\n")
+	return strings.TrimSpace(cleaned)
+}
+
+func finalizeUnit3DDescription(value string) string {
+	if strings.TrimSpace(value) == "" {
+		return ""
+	}
+	value = strings.ReplaceAll(value, "[hide", "[spoiler")
+	value = strings.ReplaceAll(value, "[/hide]", "[/spoiler]")
+	value = unit3DAlignBlockTag.ReplaceAllStringFunc(value, func(match string) string {
+		parts := unit3DAlignBlockTag.FindStringSubmatch(match)
+		if len(parts) != 3 {
+			return match
+		}
+		tag := strings.ToLower(strings.TrimSpace(parts[1]))
+		if tag == "left" {
+			tag = "center"
+		}
+		return "[" + tag + "]" + parts[2] + "[/" + tag + "]"
+	})
+	value = unit3DWidthImageTag.ReplaceAllString(value, "[img=$1]")
+	for _, tag := range []string{"[user]", "[/user]", "[hr]", "[/hr]", "[ul]", "[/ul]", "[ol]", "[/ol]"} {
+		value = strings.ReplaceAll(value, tag, "")
+	}
+	value = collapseNewlines.ReplaceAllString(value, "\n\n")
+	return normalizeDescription(value)
+}
+
+// SaveDescriptionDebug best-effort writes a tracker description diagnostic
+// beneath the database's managed temp directory; newly created files use mode
+// 0600. A blank dbPath is a no-op. Directory-resolution failures are silently
+// ignored; write failures are logged when logger is non-nil, and no error is
+// returned.
+func SaveDescriptionDebug(meta api.DescriptionSubject, tracker string, dbPath string, description string, logger api.Logger) {
+	if strings.TrimSpace(dbPath) == "" {
+		return
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return
+	}
+	name := "[" + tracker + "]DESCRIPTION.txt"
+	path := filepath.Join(tmpDir, name)
+	if err := os.WriteFile(path, []byte(description), 0o600); err != nil {
+		if logger != nil {
+			logger.Warnf("trackers: %s description debug save: %v", tracker, err)
+		}
+		return
+	}
+	if logger != nil {
+		logger.Debugf("trackers: %s description saved %s", tracker, path)
+	}
+}
diff --git a/internal/services/description/unit3d/clean.go b/internal/description/unit3d/clean.go
similarity index 90%
rename from internal/services/description/unit3d/clean.go
rename to internal/description/unit3d/clean.go
index 1cd2abd3..62f85772 100644
--- a/internal/services/description/unit3d/clean.go
+++ b/internal/description/unit3d/clean.go
@@ -10,7 +10,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/autobrr/upbrr/internal/services/imagehost"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
 )
 
 var (
@@ -19,14 +19,20 @@ var (
 	unit3dURLToken         = regexp.MustCompile(`(?i)https?://[^\s\[\]]+`)
 	unit3dWrapperTag       = regexp.MustCompile(`(?is)\[(?:center|align=[^\]]+)\][\s\S]*?\[/(?:center|align)\]`)
 	unit3dParagraphSplit   = regexp.MustCompile(`\n\s*\n+`)
-	unit3dTonemapOnlyBlock = regexp.MustCompile(`(?is)\[(?:center|align=[^\]]+)\]\s*\[code\]\s*Screenshots have been tonemapped for reference\s*\[/code\]\s*\[/(?:center|align)\]`)
-	unit3dEmptySpoilerTag  = regexp.MustCompile(`(?is)\[spoiler(?:=[^\]]*)?\]\s*\[/spoiler\]`)
-	unit3dWrapperOpenTag   = regexp.MustCompile(`(?is)\[(?:center|align=[^\]]+)\]`)
-	unit3dWrapperCloseTag  = regexp.MustCompile(`(?is)\[/(?:center|align)\]`)
-	unit3dHostAliasCache   sync.Map
-	unit3dSiteLinkCache    sync.Map
+	unit3dTonemapOnlyBlock = regexp.MustCompile(
+		`(?is)\[(?:center|align=[^\]]+)\]\s*\[code\]\s*Screenshots have been tonemapped for reference\s*\[/code\]\s*\[/(?:center|align)\]`,
+	)
+	unit3dEmptySpoilerTag = regexp.MustCompile(`(?is)\[spoiler(?:=[^\]]*)?\]\s*\[/spoiler\]`)
+	unit3dWrapperOpenTag  = regexp.MustCompile(`(?is)\[(?:center|align=[^\]]+)\]`)
+	unit3dWrapperCloseTag = regexp.MustCompile(`(?is)\[/(?:center|align)\]`)
+	unit3dHostAliasCache  sync.Map
+	unit3dSiteLinkCache   sync.Map
 )
 
+// CleanDescription normalizes entities and site-local references, removes all
+// image markup from the body, and returns the first non-poster image set. A
+// leading poster-only set does not prevent a later screenshot set from being
+// selected.
 func CleanDescription(description string, site string) Report {
 	desc, report, ok := normalizeUnit3DDescriptionInput(description, site)
 	if !ok {
@@ -38,6 +44,9 @@ func CleanDescription(description string, site string) Report {
 	return report
 }
 
+// CleanDescriptionBody applies the same entity and site-reference
+// normalization as [CleanDescription] and removes all image markup without
+// returning extracted images.
 func CleanDescriptionBody(description string, site string) Report {
 	desc, report, ok := normalizeUnit3DDescriptionInput(description, site)
 	if !ok {
@@ -48,6 +57,8 @@ func CleanDescriptionBody(description string, site string) Report {
 	return report
 }
 
+// CleanDescriptionImages returns the first non-poster image set after entity
+// and site-reference normalization without producing a cleaned body.
 func CleanDescriptionImages(description string, site string) Report {
 	desc, report, ok := normalizeUnit3DDescriptionInput(description, site)
 	if !ok {
@@ -164,7 +175,12 @@ func extractUnit3DImages(value string) []Image {
 			if host == "" {
 				host = imagehost.ExtractHost(imgURL)
 			}
-			images = append(images, Image{ImgURL: imgURL, RawURL: rawURL, WebURL: webURL, Host: host})
+			images = append(images, Image{
+				ImgURL: imgURL,
+				RawURL: rawURL,
+				WebURL: webURL,
+				Host:   host,
+			})
 		}
 		return ""
 	})
@@ -178,7 +194,12 @@ func extractUnit3DImages(value string) []Image {
 		if imgURL != "" && !containsImage(images, imgURL) {
 			host := imagehost.ExtractHost(imgURL)
 			rawURL := normalizeRawImageURL(imgURL)
-			images = append(images, Image{ImgURL: imgURL, RawURL: rawURL, WebURL: imgURL, Host: host})
+			images = append(images, Image{
+				ImgURL: imgURL,
+				RawURL: rawURL,
+				WebURL: imgURL,
+				Host:   host,
+			})
 		}
 		return ""
 	})
diff --git a/internal/services/description/unit3d/clean_test.go b/internal/description/unit3d/clean_test.go
similarity index 100%
rename from internal/services/description/unit3d/clean_test.go
rename to internal/description/unit3d/clean_test.go
diff --git a/internal/description/unit3d/types.go b/internal/description/unit3d/types.go
new file mode 100644
index 00000000..c131acf1
--- /dev/null
+++ b/internal/description/unit3d/types.go
@@ -0,0 +1,35 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package unit3d builds and cleans descriptions shared by Unit3D trackers.
+package unit3d
+
+// Image describes an image extracted from a Unit3D description.
+type Image struct {
+	// ImgURL is the BBCode-ready image URL, which may point at a thumbnail.
+	ImgURL string
+	// RawURL is the direct image URL.
+	RawURL string
+	// WebURL is the image host's browser-facing page URL when available.
+	WebURL string
+	// Host is the normalized image-host name.
+	Host string
+}
+
+// Note reports a non-fatal condition encountered while cleaning a Unit3D description.
+type Note struct {
+	// Kind categorizes the note for downstream handling.
+	Kind string
+	// Message contains caller-visible detail about the condition.
+	Message string
+}
+
+// Report contains a cleaned Unit3D description and extracted content.
+type Report struct {
+	// Description is the normalized BBCode that remains after cleanup.
+	Description string
+	// Images contains images removed or identified during cleanup.
+	Images []Image
+	// Notes contains non-fatal cleanup diagnostics.
+	Notes []Note
+}
diff --git a/internal/dupechecking/ant.go b/internal/dupechecking/ant.go
deleted file mode 100644
index 5db3cb03..00000000
--- a/internal/dupechecking/ant.go
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type antHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h antHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "ANT")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	params := url.Values{}
-	params.Set("t", "search")
-	params.Set("o", "json")
-	switch {
-	case meta.ExternalIDs.TMDBID != 0:
-		params.Set("tmdb", strconv.Itoa(meta.ExternalIDs.TMDBID))
-	case meta.ExternalIDs.IMDBID != 0:
-		params.Set("imdb", strconv.Itoa(meta.ExternalIDs.IMDBID))
-	default:
-		return nil, []string{noteSkip("missing tmdb/imdb id for ANT dupe search")}, nil
-	}
-	headers := map[string]string{
-		"User-Agent": "upbrr",
-		"X-API-Key":  apiKey,
-	}
-
-	status, payload, err := doJSONGet(ctx, h.http, "https://anthelion.me/api.php", params, headers)
-	if err != nil {
-		return nil, []string{noteSkip("ANT request failed")}, nil
-	}
-	if status < 200 || status >= 300 || len(payload) == 0 {
-		return nil, []string{noteSkip("ANT search failed")}, nil
-	}
-
-	items, _ := payload["item"].([]any)
-	entries := make([]api.DupeEntry, 0, len(items))
-	targetResolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
-	for _, raw := range items {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		if targetResolution != "" && strings.ToLower(stringFromAny(item["resolution"])) != targetResolution {
-			continue
-		}
-		files := make([]string, 0)
-		fileCount := int(intFromAny(item["fileCount"]))
-		if rawFiles, ok := item["files"].([]any); ok {
-			for _, rf := range rawFiles {
-				if fileMap, ok := rf.(map[string]any); ok {
-					name := stringFromAny(fileMap["name"])
-					if name != "" {
-						files = append(files, name)
-					}
-				}
-			}
-			if fileCount == 0 {
-				fileCount = len(files)
-			}
-		}
-		entry := api.DupeEntry{
-			Name:      stringFromAny(item["fileName"]),
-			Files:     files,
-			FileCount: fileCount,
-			Link:      stringFromAny(item["guid"]),
-			Download:  strings.ReplaceAll(stringFromAny(item["link"]), "&amp;", "&"),
-		}
-		if entry.Name == "" && len(files) > 0 {
-			entry.Name = files[0]
-		}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		if rawFlags, ok := item["flags"].([]any); ok {
-			for _, flag := range rawFlags {
-				f := stringFromAny(flag)
-				if f != "" {
-					entry.Flags = append(entry.Flags, f)
-				}
-			}
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/ant_test.go b/internal/dupechecking/ant_test.go
deleted file mode 100644
index 2d4318ee..00000000
--- a/internal/dupechecking/ant_test.go
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestANTHandlerSendsAPIKeyHeader(t *testing.T) {
-	t.Parallel()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			query := req.URL.Query()
-			if got := query.Get("apikey"); got != "" {
-				t.Fatal("apikey should not be sent as a query parameter")
-			}
-			assertQueryParam(t, query, "t", "search")
-			assertQueryParam(t, query, "o", "json")
-			assertQueryParam(t, query, "tmdb", "123")
-			if got := req.Header.Get("X-Api-Key"); got != "token" {
-				t.Fatal("unexpected X-API-Key header")
-			}
-			if got := req.Header.Get("User-Agent"); got == "" {
-				t.Fatal("expected User-Agent header")
-			}
-
-			body := `{"item":[{"fileName":"Example.1080p-GRP","resolution":"1080p","guid":"https://anthelion.me/torrents.php?id=1","link":"https://anthelion.me/download.php?id=1"}]}`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := antHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"ANT": {APIKey: "token"},
-				},
-			},
-		},
-		http: client,
-	}
-
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{TMDBID: 123},
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-	}, "ANT")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one entry, got %d", len(entries))
-	}
-}
diff --git a/internal/dupechecking/api_handlers_test.go b/internal/dupechecking/api_handlers_test.go
deleted file mode 100644
index ff337f2b..00000000
--- a/internal/dupechecking/api_handlers_test.go
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestAPIHandlersMissingCredentialsSkip(t *testing.T) {
-	t.Parallel()
-	meta := api.PreparedMetadata{SourcePath: "x", ExternalIDs: api.ExternalIDs{TMDBID: 1, IMDBID: 1}}
-	cases := []struct {
-		name    string
-		handler searchHandler
-	}{
-		{name: "ANT", handler: antHandler{cfg: config.Config{}}},
-		{name: "AR", handler: arHandler{cfg: config.Config{}}},
-		{name: "BHD", handler: bhdHandler{cfg: config.Config{}}},
-		{name: "HDB", handler: hdbHandler{cfg: config.Config{}}},
-		{name: "PTP", handler: ptpHandler{cfg: config.Config{}}},
-		{name: "DC", handler: dcHandler{cfg: config.Config{}}},
-		{name: "GPW", handler: gpwHandler{cfg: config.Config{}}},
-		{name: "NBL", handler: nblHandler{cfg: config.Config{}}},
-		{name: "MTV", handler: mtvHandler{cfg: config.Config{}}},
-		{name: "RTF", handler: rtfHandler{cfg: config.Config{}}},
-		{name: "SPD", handler: spdHandler{cfg: config.Config{}}},
-		{name: "TL", handler: tlHandler{cfg: config.Config{}}},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			_, notes, err := tc.handler.Search(context.Background(), meta, tc.name)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if _, ok := parseSkipReason(notes); !ok {
-				t.Fatalf("expected skip reason notes, got %#v", notes)
-			}
-		})
-	}
-}
-
-func TestBHDTVHandlerReturnsManualMessage(t *testing.T) {
-	t.Parallel()
-	entries, notes, err := (bhdtvHandler{}).Search(context.Background(), api.PreparedMetadata{}, "BHDTV")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one manual entry")
-	}
-	if len(notes) == 0 {
-		t.Fatalf("expected notes")
-	}
-}
-
-func TestTVCHandlerSkipsRestrictedContent(t *testing.T) {
-	t.Parallel()
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "2160p"}}
-	_, notes, err := (tvcHandler{}).Search(context.Background(), meta, "TVC")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if _, ok := parseSkipReason(notes); !ok {
-		t.Fatalf("expected skip reason")
-	}
-}
diff --git a/internal/dupechecking/ar.go b/internal/dupechecking/ar.go
deleted file mode 100644
index 79335b08..00000000
--- a/internal/dupechecking/ar.go
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	arBrowseEndpoint = "https://alpharatio.cc/ajax.php"
-)
-
-type arHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h arHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	if h.http == nil {
-		return nil, []string{noteSkip("AR handler misconfigured: no HTTP client")}, nil
-	}
-
-	query := arSearchQuery(meta)
-	if query == "" {
-		return nil, []string{noteSkip("missing title for AR dupe search")}, nil
-	}
-
-	cookies, cookiePath, err := h.resolveCookies(ctx)
-	if err != nil || len(cookies) == 0 {
-		if err != nil && h.logger != nil {
-			h.logger.Debugf("dupechecking: AR cookie resolution failed: %v", err)
-		}
-		return nil, []string{noteSkip("missing valid AR cookies")}, nil
-	}
-	if h.logger != nil && cookiePath != "" {
-		h.logger.Debugf("dupechecking: AR using stored cookies from %s", cookiePath)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, arBrowseEndpoint, nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("build AR request: %w", err)
-	}
-	params := req.URL.Query()
-	params.Set("action", "browse")
-	params.Set("searchstr", query)
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("User-Agent", "upbrr")
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-
-	resp, err := h.http.Do(req)
-	if err != nil {
-		if h.logger != nil {
-			h.logger.Debugf("dupechecking: AR request failed: %v", err)
-		}
-		return nil, []string{noteSkip("AR request failed")}, nil
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		if h.logger != nil {
-			h.logger.Debugf("dupechecking: AR returned status %d", resp.StatusCode)
-		}
-		return nil, []string{noteSkip("AR search returned non-success status")}, nil
-	}
-
-	var payload arResponse
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		if h.logger != nil {
-			h.logger.Debugf("dupechecking: AR response decode failed: %v", err)
-		}
-		return nil, []string{noteSkip("AR response decode failed")}, nil
-	}
-	if !strings.EqualFold(strings.TrimSpace(payload.Status), "success") {
-		return nil, []string{noteSkip("AR API returned non-success status")}, nil
-	}
-
-	entries := make([]api.DupeEntry, 0, len(payload.Response.Results))
-	for _, result := range payload.Response.Results {
-		name := strings.TrimSpace(result.GroupName)
-		if name == "" {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name:      name,
-			Files:     []string{name},
-			FileCount: result.FileCount,
-			ID:        strconv.FormatInt(result.TorrentID, 10),
-			Link:      "https://alpharatio.cc/torrents.php?id=" + strconv.FormatInt(result.GroupID, 10) + "&torrentid=" + strconv.FormatInt(result.TorrentID, 10),
-			Download:  "https://alpharatio.cc/torrents.php?action=download&id=" + strconv.FormatInt(result.TorrentID, 10),
-		}
-		if result.Size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = result.Size
-		}
-		entries = append(entries, entry)
-	}
-
-	return entries, nil, nil
-}
-
-func (h arHandler) resolveCookies(ctx context.Context) ([]*http.Cookie, string, error) {
-	arURL, _ := url.Parse("https://alpharatio.cc/")
-	merged := map[string]*http.Cookie{}
-
-	if h.http != nil && h.http.Jar != nil && arURL != nil {
-		for _, cookie := range h.http.Jar.Cookies(arURL) {
-			if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
-				continue
-			}
-			merged[cookie.Name] = cookie
-		}
-	}
-	if len(merged) > 0 {
-		if h.logger != nil {
-			h.logger.Debugf("dupechecking: AR using %d cookies from HTTP client jar", len(merged))
-		}
-		return mapCookiesToSlice(merged), "", nil
-	}
-
-	loaded, err := cookiepkg.LoadTrackerHTTPCookies(ctx, h.cfg.MainSettings.DBPath, "AR", "alpharatio.cc")
-	if err != nil {
-		return nil, "", fmt.Errorf("dupechecking: %w", err)
-	}
-	for _, cookie := range loaded {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
-			continue
-		}
-		merged[cookie.Name] = cookie
-	}
-	if len(merged) == 0 {
-		return nil, "", errors.New("no valid cookies found")
-	}
-	return mapCookiesToSlice(merged), "shared store", nil
-}
-
-func mapCookiesToSlice(values map[string]*http.Cookie) []*http.Cookie {
-	if len(values) == 0 {
-		return nil
-	}
-	out := make([]*http.Cookie, 0, len(values))
-	for _, cookie := range values {
-		out = append(out, cookie)
-	}
-	return out
-}
-
-func arSearchQuery(meta api.PreparedMetadata) string {
-	title := strings.TrimSpace(meta.Release.Title)
-	if title == "" && meta.ExternalMetadata.TMDB != nil {
-		title = strings.TrimSpace(meta.ExternalMetadata.TMDB.Title)
-	}
-	if title == "" && meta.ExternalMetadata.IMDB != nil {
-		title = strings.TrimSpace(meta.ExternalMetadata.IMDB.Title)
-	}
-	if title == "" {
-		title = strings.TrimSpace(meta.ReleaseName)
-	}
-	if title == "" {
-		return ""
-	}
-
-	year := meta.Release.Year
-	if year == 0 && meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		year = meta.ExternalMetadata.TMDB.Year
-	}
-	if year == 0 && meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		year = meta.ExternalMetadata.IMDB.Year
-	}
-	if year > 0 {
-		return strings.TrimSpace(title + " " + strconv.Itoa(year))
-	}
-	return title
-}
-
-type arResponse struct {
-	Status   string `json:"status"`
-	Response struct {
-		Results []struct {
-			GroupName string `json:"groupName"`
-			Size      int64  `json:"size"`
-			FileCount int    `json:"fileCount"`
-			GroupID   int64  `json:"groupId"`
-			TorrentID int64  `json:"torrentId"`
-		} `json:"results"`
-	} `json:"response"`
-}
diff --git a/internal/dupechecking/ar_test.go b/internal/dupechecking/ar_test.go
deleted file mode 100644
index fea6dc83..00000000
--- a/internal/dupechecking/ar_test.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestARHandlerSearchParsesResultsWithCookieFile(t *testing.T) {
-	t.Parallel()
-
-	tmpDir := t.TempDir()
-	cookieDir := filepath.Join(tmpDir, "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookies: %v", err)
-	}
-	cookiePath := filepath.Join(cookieDir, "AR.txt")
-	cookieText := `# Netscape HTTP Cookie File
-.alpharatio.cc	TRUE	/	TRUE	2147483647	session	abc123
-`
-	if err := os.WriteFile(cookiePath, []byte(cookieText), 0o644); err != nil {
-		t.Fatalf("write cookies: %v", err)
-	}
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			if req.Method != http.MethodGet {
-				t.Fatalf("expected GET request, got %s", req.Method)
-			}
-			if got := req.URL.String(); !strings.HasPrefix(got, arBrowseEndpoint+"?") {
-				t.Fatalf("unexpected request url %q", got)
-			}
-			query := req.URL.Query()
-			if got := query.Get("action"); got != "browse" {
-				t.Fatalf("expected action=browse, got %q", got)
-			}
-			if got := query.Get("searchstr"); got != "Movie Title 2023" {
-				t.Fatalf("expected searchstr to include title+year, got %q", got)
-			}
-			if got := req.Header.Get("User-Agent"); got == "" {
-				t.Fatalf("expected User-Agent header")
-			}
-			if raw := req.Header.Get("Cookie"); !strings.Contains(raw, "session=abc123") {
-				t.Fatal("expected cookie header to include session token")
-			}
-
-			body := `{"status":"success","response":{"results":[{"groupName":"Movie.Title.2023.1080p.BluRay-GRP","size":123456789,"fileCount":1,"groupId":44,"torrentId":55}]}}`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := arHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmpDir, "ua.db")},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Title: "Movie Title", Year: 2023}}
-	entries, notes, err := handler.Search(context.Background(), meta, "AR")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one entry, got %d", len(entries))
-	}
-	entry := entries[0]
-	if entry.Name != "Movie.Title.2023.1080p.BluRay-GRP" {
-		t.Fatalf("unexpected name %q", entry.Name)
-	}
-	if entry.FileCount != 1 {
-		t.Fatalf("expected file_count=1, got %d", entry.FileCount)
-	}
-	if !entry.SizeKnown || entry.SizeBytes != 123456789 {
-		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
-	}
-	if len(entry.Files) != 1 || entry.Files[0] != entry.Name {
-		t.Fatalf("expected files to contain group name, got %#v", entry.Files)
-	}
-	if entry.ID != "55" {
-		t.Fatalf("expected ID=55, got %q", entry.ID)
-	}
-	if entry.Link != "https://alpharatio.cc/torrents.php?id=44&torrentid=55" {
-		t.Fatalf("unexpected link %q", entry.Link)
-	}
-	if entry.Download != "https://alpharatio.cc/torrents.php?action=download&id=55" {
-		t.Fatalf("unexpected download %q", entry.Download)
-	}
-}
-
-func TestARHandlerMissingCookieFileReturnsSkipNote(t *testing.T) {
-	t.Parallel()
-
-	handler := arHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "ua.db")},
-		},
-		http:   &http.Client{},
-		logger: api.NopLogger{},
-	}
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Title: "Movie Title", Year: 2023}}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "AR")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	if _, ok := parseSkipReason(notes); !ok {
-		t.Fatalf("expected parseable skip reason, got %#v", notes)
-	}
-}
diff --git a/internal/dupechecking/asc.go b/internal/dupechecking/asc.go
deleted file mode 100644
index 93484caf..00000000
--- a/internal/dupechecking/asc.go
+++ /dev/null
@@ -1,418 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/url"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-
-	"golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	ascimpl "github.com/autobrr/upbrr/internal/trackers/impl/asc"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type ascHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h ascHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	if h.http == nil {
-		return nil, []string{noteSkip("ASC handler misconfigured: no HTTP client")}, nil
-	}
-	if !meta.Anime && resolveASCIMDb(meta) == "" {
-		return nil, []string{noteSkip("missing IMDb ID for ASC dupe search")}, nil
-	}
-
-	cookies, _, err := ascimpl.LoadCookies(ctx, h.cfg.MainSettings.DBPath)
-	if err != nil || len(cookies) == 0 {
-		return nil, []string{noteSkip("missing valid ASC cookies")}, nil
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, buildASCSearchURL(meta), nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("build ASC request: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-
-	resp, err := h.http.Do(req)
-	if err != nil {
-		return nil, []string{noteSkip("ASC request failed")}, nil
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, []string{noteSkip("ASC search returned non-success status")}, nil
-	}
-
-	doc, err := html.Parse(resp.Body)
-	if err != nil {
-		return nil, []string{noteSkip("ASC response parse failed")}, nil
-	}
-
-	var entries []api.DupeEntry
-	var tasks []ascDetailTask
-	seen := make(map[string]struct{})
-	walkASCNodes(doc, &entries, &tasks, seen, resolveASCTitle(meta))
-
-	if len(tasks) > 0 {
-		var mu sync.Mutex
-		var wg sync.WaitGroup
-		sem := make(chan struct{}, 5)
-	taskLoop:
-		for _, t := range tasks {
-			select {
-			case <-ctx.Done():
-				break taskLoop
-			case sem <- struct{}{}:
-			}
-
-			wg.Add(1)
-			go func(t ascDetailTask) {
-				defer wg.Done()
-				defer func() { <-sem }()
-
-				name := "N/A"
-				reqFile, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://cliente.amigos-share.club/torrents-arquivos.php?id="+t.ID, nil)
-				if err != nil {
-					h.logger.Debugf("ASC filename request creation failed for ID %s: %v", t.ID, err)
-				} else {
-					reqFile.Header.Set("User-Agent", "upbrr")
-					for _, cookie := range cookies {
-						reqFile.AddCookie(cookie)
-					}
-					fileResp, err := h.http.Do(reqFile)
-					if err != nil {
-						h.logger.Debugf("ASC filename request failed for ID %s: %v", t.ID, err)
-					} else {
-						defer fileResp.Body.Close()
-						if fileResp.StatusCode < 200 || fileResp.StatusCode >= 300 {
-							h.logger.Debugf("ASC filename request returned non-success status %d for ID %s", fileResp.StatusCode, t.ID)
-						} else {
-							fileDoc, err := html.Parse(fileResp.Body)
-							if err != nil {
-								h.logger.Debugf("ASC filename parse failed for ID %s: %v", t.ID, err)
-							} else {
-								if parsedName := getASCFilenameFromFiles(fileDoc); parsedName != "" {
-									name = parsedName
-								} else {
-									h.logger.Debugf("ASC filename not found in response for ID %s", t.ID)
-								}
-							}
-						}
-					}
-				}
-
-				mu.Lock()
-				entries = append(entries, api.DupeEntry{
-					Name:     name,
-					ID:       t.ID,
-					Link:     t.Link,
-					SizeText: t.Size,
-				})
-				mu.Unlock()
-			}(t)
-		}
-		wg.Wait()
-	}
-
-	return entries, nil, nil
-}
-
-func buildASCSearchURL(meta api.PreparedMetadata) string {
-	base := "https://cliente.amigos-share.club"
-	if meta.Anime {
-		return base + "/torrents-search.php?search=" + url.QueryEscape(resolveASCTitle(meta))
-	}
-	if strings.EqualFold(resolveASCCategory(meta), "TV") {
-		return base + "/busca-series.php?search=" + url.QueryEscape(resolveASCSeasonEpisode(meta)) + "&imdb=" + url.QueryEscape(resolveASCIMDb(meta))
-	}
-	return base + "/busca-filmes.php?search=&imdb=" + url.QueryEscape(resolveASCIMDb(meta))
-}
-
-type ascDetailTask struct {
-	ID   string
-	Link string
-	Size string
-}
-
-func walkASCNodes(n *html.Node, entries *[]api.DupeEntry, tasks *[]ascDetailTask, seen map[string]struct{}, baseTitle string) {
-	if n.Type == html.ElementNode && strings.EqualFold(n.Data, "li") {
-		if ascHasClass(n, "list-group-item") && ascHasClass(n, "dark-gray") {
-			processASCListItem(n, entries, tasks, seen, baseTitle)
-			return
-		}
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		walkASCNodes(c, entries, tasks, seen, baseTitle)
-	}
-}
-
-func processASCListItem(n *html.Node, entries *[]api.DupeEntry, tasks *[]ascDetailTask, seen map[string]struct{}, baseTitle string) {
-	var detailsHref string
-	var sizeText string
-	var badges []string
-
-	var walk func(*html.Node)
-	walk = func(child *html.Node) {
-		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "a") {
-			href := ascGetAttr(child, "href")
-			if strings.Contains(href, "torrents-details.php?id=") {
-				detailsHref = href
-			}
-		}
-		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "span") {
-			if ascHasClass(child, "badge-info") {
-				txt := strings.ToUpper(ascGetText(child))
-				if strings.Contains(txt, "GB") || strings.Contains(txt, "MB") {
-					sizeText = strings.TrimSpace(ascGetText(child))
-				}
-			} else if ascHasClass(child, "badge") {
-				badges = append(badges, strings.TrimSpace(ascGetText(child)))
-			}
-		}
-		for c := child.FirstChild; c != nil; c = c.NextSibling {
-			walk(c)
-		}
-	}
-	walk(n)
-
-	if detailsHref == "" {
-		return
-	}
-
-	id := parseASCTorrentID(detailsHref)
-	if id == "" {
-		return
-	}
-	if _, ok := seen[id]; ok {
-		return
-	}
-	seen[id] = struct{}{}
-
-	link := absolutizeASCLink(detailsHref)
-
-	discTypes := []string{"BD25", "BD50", "BD66", "BD100", "DVD5", "DVD9"}
-	isDisc := false
-	for _, b := range badges {
-		bUp := strings.ToUpper(b)
-		if ascContainsAny(bUp, discTypes) {
-			isDisc = true
-			break
-		}
-	}
-
-	if isDisc {
-		year := "N/A"
-		resolution := "N/A"
-		diskType := "N/A"
-		videoCodec := "N/A"
-		audioCodec := "N/A"
-
-		codecTerms := []string{"MPEG-4", "AV1", "AVC", "H264", "H265", "HEVC", "MPEG-1", "MPEG-2", "VC-1", "VP6", "VP9"}
-		audioTerms := []string{"DTS", "AC3", "DDP", "E-AC-3", "TRUEHD", "ATMOS", "LPCM", "AAC", "FLAC"}
-		resTypes := []string{"4K", "2160P", "1080P", "720P", "480P"}
-
-		for _, b := range badges {
-			bUp := strings.ToUpper(b)
-			switch {
-			case len(bUp) == 4 && ascIsDigit(bUp):
-				year = bUp
-			case ascContainsAnyStrict(bUp, resTypes):
-				if bUp == "4K" {
-					resolution = "2160p"
-				} else {
-					resolution = bUp
-				}
-			case ascContainsAny(bUp, codecTerms):
-				videoCodec = strings.TrimSpace(b)
-			case ascContainsAny(bUp, audioTerms):
-				audioCodec = strings.TrimSpace(b)
-			case ascContainsAny(bUp, discTypes):
-				diskType = strings.TrimSpace(b)
-			}
-		}
-
-		name := fmt.Sprintf("%s %s %s %s %s %s", baseTitle, year, resolution, diskType, strings.ToUpper(videoCodec), strings.ToUpper(audioCodec))
-		*entries = append(*entries, api.DupeEntry{
-			Name:     strings.TrimSpace(name),
-			ID:       id,
-			Link:     link,
-			SizeText: sizeText,
-		})
-	} else {
-		*tasks = append(*tasks, ascDetailTask{
-			ID:   id,
-			Link: link,
-			Size: sizeText,
-		})
-	}
-}
-
-func ascContainsAnyStrict(s string, terms []string) bool {
-	return slices.Contains(terms, s)
-}
-
-func ascContainsAny(s string, terms []string) bool {
-	for _, t := range terms {
-		if strings.Contains(s, t) {
-			return true
-		}
-	}
-	return false
-}
-
-func ascIsDigit(s string) bool {
-	for _, c := range s {
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-func ascHasClass(n *html.Node, class string) bool {
-	for _, attr := range n.Attr {
-		if strings.EqualFold(attr.Key, "class") {
-			for c := range strings.FieldsSeq(attr.Val) {
-				if strings.EqualFold(c, class) {
-					return true
-				}
-			}
-			return false
-		}
-	}
-	return false
-}
-
-func ascGetAttr(n *html.Node, key string) string {
-	for _, attr := range n.Attr {
-		if strings.EqualFold(attr.Key, key) {
-			return strings.TrimSpace(attr.Val)
-		}
-	}
-	return ""
-}
-
-func ascGetText(n *html.Node) string {
-	var b strings.Builder
-	var walk func(*html.Node)
-	walk = func(child *html.Node) {
-		if child.Type == html.TextNode {
-			b.WriteString(child.Data)
-		}
-		for c := child.FirstChild; c != nil; c = c.NextSibling {
-			walk(c)
-		}
-	}
-	walk(n)
-	return b.String()
-}
-
-func getASCFilenameFromFiles(n *html.Node) string {
-	var walk func(*html.Node) string
-	walk = func(child *html.Node) string {
-		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "li") && ascHasClass(child, "list-group-item") {
-			for c := child.FirstChild; c != nil; c = c.NextSibling {
-				switch c.Type {
-				case html.TextNode:
-					txt := strings.TrimSpace(c.Data)
-					if txt != "" {
-						return txt
-					}
-				case html.ElementNode:
-					txt := strings.TrimSpace(ascGetText(c))
-					if txt != "" {
-						return txt
-					}
-				case html.ErrorNode, html.DocumentNode, html.CommentNode, html.DoctypeNode, html.RawNode:
-					// ignore
-				}
-			}
-		}
-		for c := child.FirstChild; c != nil; c = c.NextSibling {
-			if txt := walk(c); txt != "" {
-				return txt
-			}
-		}
-		return ""
-	}
-	return walk(n)
-}
-
-func parseASCTorrentID(href string) string {
-	parsed, err := url.Parse(href)
-	if err == nil {
-		if id := strings.TrimSpace(parsed.Query().Get("id")); id != "" {
-			return id
-		}
-	}
-	parts := strings.Split(href, "id=")
-	if len(parts) < 2 {
-		return ""
-	}
-	return strings.TrimSpace(strings.Split(parts[len(parts)-1], "&")[0])
-}
-
-func absolutizeASCLink(href string) string {
-	if strings.HasPrefix(href, "http://") || strings.HasPrefix(href, "https://") {
-		return href
-	}
-	return "https://cliente.amigos-share.club/" + strings.TrimPrefix(href, "/")
-}
-
-func resolveASCIMDb(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveASCCategory(meta api.PreparedMetadata) string {
-	if strings.EqualFold(meta.ExternalIDs.Category, "TV") || meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 {
-		return "TV"
-	}
-	return "MOVIE"
-}
-
-func resolveASCTitle(meta api.PreparedMetadata) string {
-	if strings.TrimSpace(meta.Release.Title) != "" {
-		return strings.TrimSpace(meta.Release.Title)
-	}
-	if strings.TrimSpace(meta.ReleaseName) != "" {
-		return strings.TrimSpace(meta.ReleaseName)
-	}
-	return strings.TrimSpace(meta.SourcePath)
-}
-
-func resolveASCSeasonEpisode(meta api.PreparedMetadata) string {
-	if meta.EpisodeInt > 0 {
-		return "S" + padASC2(meta.SeasonInt) + "E" + padASC2(meta.EpisodeInt)
-	}
-	if meta.SeasonInt > 0 {
-		return "S" + padASC2(meta.SeasonInt)
-	}
-	return ""
-}
-
-func padASC2(value int) string {
-	if value < 10 {
-		return "0" + strconv.Itoa(value)
-	}
-	return strconv.Itoa(value)
-}
diff --git a/internal/dupechecking/az.go b/internal/dupechecking/az.go
deleted file mode 100644
index 9a0b2688..00000000
--- a/internal/dupechecking/az.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type azHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h azHandler) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	return azNetworkHandler(h).Search(ctx, meta, tracker)
-}
diff --git a/internal/dupechecking/azfamily.go b/internal/dupechecking/azfamily.go
deleted file mode 100644
index f161ead1..00000000
--- a/internal/dupechecking/azfamily.go
+++ /dev/null
@@ -1,378 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type azNetworkHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h azNetworkHandler) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	if h.http == nil {
-		return nil, []string{noteSkip("AZ-family handler misconfigured: no HTTP client")}, nil
-	}
-	site := azDupeSite(tracker)
-	if cfg, ok := trackerCfg(h.cfg, tracker); ok && strings.TrimSpace(cfg.URL) != "" {
-		site.baseURL = strings.TrimRight(strings.TrimSpace(cfg.URL), "/")
-	}
-	loadedCookies, err := loadAZFamilyCookies(ctx, h.cfg, tracker, site.baseURL)
-	if err != nil {
-		return nil, []string{noteSkip(fmt.Sprintf("missing valid %s cookies", strings.ToUpper(strings.TrimSpace(tracker))))}, nil
-	}
-	mediaCode, err := h.lookupMediaCode(ctx, site, loadedCookies, meta)
-	if err != nil {
-		return nil, []string{noteSkip(strings.ToUpper(strings.TrimSpace(tracker)) + " request failed")}, nil
-	}
-	if mediaCode == "" {
-		return nil, []string{noteSkip(strings.ToUpper(strings.TrimSpace(tracker)) + " media missing from tracker database")}, nil
-	}
-	pageURL := site.baseURL + "/movies/torrents/" + mediaCode + "?quality=" + url.QueryEscape(azDupeResolution(meta))
-	return h.fetchTorrentList(ctx, site, loadedCookies, pageURL, meta)
-}
-
-func (h azNetworkHandler) lookupMediaCode(ctx context.Context, site azDupeSiteDef, cookies []*http.Cookie, meta api.PreparedMetadata) (string, error) {
-	term := lookupAZDupeTitle(meta)
-	imdb := imdbForLookup(meta)
-	categoryID := "1"
-	if strings.EqualFold(meta.ExternalIDs.Category, "TV") || strings.EqualFold(meta.MediaInfoCategory, "TV") {
-		categoryID = "2"
-	}
-	search := func(term string) ([]map[string]any, error) {
-		if strings.TrimSpace(term) == "" {
-			return nil, nil
-		}
-		endpoint := fmt.Sprintf("%s/ajax/movies/%s?term=%s", site.baseURL, categoryID, url.QueryEscape(term))
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-		if err != nil {
-			return nil, fmt.Errorf("dupechecking: create %s media lookup request: %w", site.baseURL, err)
-		}
-		req.Header.Set("User-Agent", "upbrr")
-		req.Header.Set("X-Requested-With", "XMLHttpRequest")
-		for _, cookie := range cookies {
-			req.AddCookie(cookie)
-		}
-		resp, err := h.http.Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("dupechecking: fetch %s media lookup: %w", site.baseURL, err)
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-			return nil, fmt.Errorf("status %d", resp.StatusCode)
-		}
-		var payload struct {
-			Data []map[string]any `json:"data"`
-		}
-		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-			return nil, fmt.Errorf("dupechecking: decode %s media lookup: %w", site.baseURL, err)
-		}
-		return payload.Data, nil
-	}
-
-	items, err := search(imdb)
-	if err != nil {
-		return "", err
-	}
-	if len(items) == 0 {
-		items, err = search(term)
-		if err != nil {
-			return "", err
-		}
-	}
-	for _, item := range items {
-		if imdb != "" && strings.EqualFold(stringFromAny(item["imdb"]), imdb) {
-			return stringFromAny(item["id"]), nil
-		}
-	}
-	if len(items) > 0 {
-		return stringFromAny(items[0]["id"]), nil
-	}
-	return "", nil
-}
-
-func (h azNetworkHandler) fetchTorrentList(ctx context.Context, site azDupeSiteDef, cookies []*http.Cookie, pageURL string, meta api.PreparedMetadata) ([]api.DupeEntry, []string, error) {
-	results := make([]api.DupeEntry, 0)
-	visited := make(map[string]struct{})
-	ripType := azDupeRipType(meta)
-	for strings.TrimSpace(pageURL) != "" {
-		if _, ok := visited[pageURL]; ok {
-			break
-		}
-		visited[pageURL] = struct{}{}
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, pageURL, nil)
-		if err != nil {
-			return nil, nil, fmt.Errorf("dupechecking: create %s torrent list request: %w", site.baseURL, err)
-		}
-		req.Header.Set("User-Agent", "upbrr")
-		for _, cookie := range cookies {
-			req.AddCookie(cookie)
-		}
-		resp, err := h.http.Do(req)
-		if err != nil {
-			return nil, nil, fmt.Errorf("dupechecking: fetch %s torrent list: %w", site.baseURL, err)
-		}
-		root, err := xhtml.Parse(resp.Body)
-		_ = resp.Body.Close()
-		if err != nil {
-			return nil, nil, fmt.Errorf("dupechecking: parse %s search response: %w", site.baseURL, err)
-		}
-		rows := findTorrentRows(root)
-		for _, row := range rows {
-			entry := parseAZDupeRow(row, site)
-			if entry.Name == "" {
-				continue
-			}
-			if ripType != "" && !containsFlag(entry.Flags, ripType) {
-				continue
-			}
-			results = append(results, entry)
-		}
-		pageURL = nextAZPage(root, site.baseURL)
-	}
-	return results, nil, nil
-}
-
-type azDupeSiteDef struct {
-	baseURL string
-}
-
-func azDupeSite(tracker string) azDupeSiteDef {
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "CZ":
-		return azDupeSiteDef{baseURL: "https://cinemaz.to"}
-	case "PHD":
-		return azDupeSiteDef{baseURL: "https://privatehd.to"}
-	default:
-		return azDupeSiteDef{baseURL: "https://avistaz.to"}
-	}
-}
-
-func loadAZFamilyCookies(ctx context.Context, cfg config.Config, tracker string, baseURL string) ([]*http.Cookie, error) {
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return nil, fmt.Errorf("parse baseURL %q: %w", baseURL, err)
-	}
-	host := parsed.Hostname()
-	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, cfg.MainSettings.DBPath, strings.ToUpper(strings.TrimSpace(tracker)), host)
-	if err != nil {
-		return nil, fmt.Errorf("dupechecking: load AZ-family cookies: %w", err)
-	}
-	return loaded, nil
-}
-
-func lookupAZDupeTitle(meta api.PreparedMetadata) string {
-	if title := strings.TrimSpace(meta.Release.Title); title != "" {
-		return title
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		if title := strings.TrimSpace(meta.ExternalMetadata.TMDB.Title); title != "" {
-			return title
-		}
-	}
-	return strings.TrimSpace(meta.Filename)
-}
-
-func azDupeResolution(meta api.PreparedMetadata) string {
-	value := strings.TrimSpace(meta.Release.Resolution)
-	if value == "" {
-		value = detectResolution(meta.ReleaseName)
-	}
-	switch strings.ToLower(value) {
-	case "2160p":
-		return "UHD"
-	case "720p", "1080p":
-		return value
-	default:
-		return "all"
-	}
-}
-
-func azDupeRipType(meta api.PreparedMetadata) string {
-	switch strings.ToLower(strings.TrimSpace(meta.Type)) {
-	case "bdrip":
-		return "BDRip"
-	case "encode":
-		return "BluRay"
-	case "brrip":
-		return "BRRip"
-	case "dvdrip":
-		return "DVDRip"
-	case "hdrip":
-		return "HDRip"
-	case "hdtv":
-		return "HDTV"
-	case "sdtv":
-		return "SDTV"
-	case "webdl":
-		return "WEB-DL"
-	case "webrip":
-		return "WEBRip"
-	case "remux":
-		if strings.Contains(strings.ToLower(strings.TrimSpace(meta.Source)), "dvd") {
-			return "DVD Remux"
-		}
-		return "BluRay REMUX"
-	default:
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-			return "BluRay Raw"
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-			return "DVD"
-		}
-		return ""
-	}
-}
-
-func findTorrentRows(root *xhtml.Node) []*xhtml.Node {
-	rows := make([]*xhtml.Node, 0)
-	var walk func(*xhtml.Node)
-	walk = func(node *xhtml.Node) {
-		if node == nil {
-			return
-		}
-		if node.Type == xhtml.ElementNode && node.Data == "tr" {
-			rows = append(rows, node)
-		}
-		for child := node.FirstChild; child != nil; child = child.NextSibling {
-			walk(child)
-		}
-	}
-	walk(root)
-	return rows
-}
-
-func parseAZDupeRow(row *xhtml.Node, site azDupeSiteDef) api.DupeEntry {
-	entry := api.DupeEntry{}
-	var walk func(*xhtml.Node)
-	walk = func(node *xhtml.Node) {
-		if node == nil {
-			return
-		}
-		if node.Type == xhtml.ElementNode && node.Data == "span" && strings.Contains(attrValueHTML(node, "class"), "badge-extra") {
-			if value := strings.TrimSpace(nodeTextHTML(node)); value != "" {
-				entry.Flags = append(entry.Flags, value)
-			}
-		}
-		if node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "class"), "torrent-filename") {
-			entry.Name = strings.TrimSpace(nodeTextHTML(node))
-			href := strings.TrimSpace(attrValueHTML(node, "href"))
-			if href != "" {
-				entry.Link = absoluteAZURL(site.baseURL, href)
-				if id := extractAZTorrentID(entry.Link); id != "" {
-					entry.ID = id
-				}
-			}
-		}
-		for child := node.FirstChild; child != nil; child = child.NextSibling {
-			walk(child)
-		}
-	}
-	walk(row)
-	return entry
-}
-
-func nextAZPage(root *xhtml.Node, baseURL string) string {
-	var next string
-	var walk func(*xhtml.Node)
-	walk = func(node *xhtml.Node) {
-		if node == nil || next != "" {
-			return
-		}
-		if node.Type == xhtml.ElementNode && node.Data == "a" && strings.EqualFold(attrValueHTML(node, "rel"), "next") {
-			next = absoluteAZURL(baseURL, attrValueHTML(node, "href"))
-			return
-		}
-		for child := node.FirstChild; child != nil; child = child.NextSibling {
-			walk(child)
-		}
-	}
-	walk(root)
-	return next
-}
-
-func containsFlag(flags []string, want string) bool {
-	for _, flag := range flags {
-		if strings.EqualFold(strings.TrimSpace(flag), strings.TrimSpace(want)) {
-			return true
-		}
-	}
-	return false
-}
-
-func attrValueHTML(node *xhtml.Node, key string) string {
-	for _, attr := range node.Attr {
-		if strings.EqualFold(attr.Key, key) {
-			return strings.TrimSpace(attr.Val)
-		}
-	}
-	return ""
-}
-
-func nodeTextHTML(node *xhtml.Node) string {
-	if node == nil {
-		return ""
-	}
-	if node.Type == xhtml.TextNode {
-		return node.Data
-	}
-	var builder strings.Builder
-	for child := node.FirstChild; child != nil; child = child.NextSibling {
-		builder.WriteString(nodeTextHTML(child))
-	}
-	return builder.String()
-}
-
-func absoluteAZURL(baseURL, value string) string {
-	trimmed := strings.TrimSpace(value)
-	if strings.HasPrefix(trimmed, "http://") || strings.HasPrefix(trimmed, "https://") {
-		return trimmed
-	}
-	return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(trimmed, "/")
-}
-
-func extractAZTorrentID(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	parts := strings.Split(strings.Trim(trimmed, "/"), "/")
-	last := parts[len(parts)-1]
-	if _, err := strconv.Atoi(last); err == nil {
-		return last
-	}
-	return ""
-}
-
-func detectResolution(value string) string {
-	lower := strings.ToLower(strings.TrimSpace(value))
-	for _, candidate := range []string{"4320p", "2160p", "1080p", "1080i", "720p", "576p", "576i", "480p", "480i"} {
-		if strings.Contains(lower, candidate) {
-			return candidate
-		}
-	}
-	return ""
-}
-
-func imdbForLookup(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID != 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
diff --git a/internal/dupechecking/azfamily_test.go b/internal/dupechecking/azfamily_test.go
deleted file mode 100644
index cb1895c1..00000000
--- a/internal/dupechecking/azfamily_test.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestAZNetworkHandlerSearchParsesHTMLResults(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "ua.db")
-	cookieDir := filepath.Join(tmp, "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/ajax/movies/1":
-			_, _ = io.WriteString(w, `{"data":[{"id":"77","imdb":"tt0000123"}]}`)
-		case "/movies/torrents/77":
-			_, _ = io.WriteString(w, `<table class="table-bordered"><tbody><tr><td><a class="torrent-filename" href="/torrent/123">Movie.2024.1080p.WEB-DL.x265-GRP</a><span class="badge-extra">WEB-DL</span></td></tr></tbody></table>`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	parsed, _ := url.Parse(server.URL)
-	cookieText := "# Netscape HTTP Cookie File\n" + parsed.Hostname() + "\tTRUE\t/\tTRUE\t0\tsession\tcookievalue\n"
-	if err := os.WriteFile(filepath.Join(cookieDir, "AZ.txt"), []byte(cookieText), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-
-	handler := azNetworkHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-				"AZ": {URL: server.URL},
-			}},
-		},
-		http:   server.Client(),
-		logger: api.NopLogger{},
-	}
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 123},
-		Release:     api.ReleaseInfo{Title: "Movie", Resolution: "1080p"},
-		Type:        "WEBDL",
-	}, "AZ")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(entries))
-	}
-	if entries[0].ID != "123" {
-		t.Fatalf("expected torrent id 123, got %q", entries[0].ID)
-	}
-}
diff --git a/internal/dupechecking/bhd.go b/internal/dupechecking/bhd.go
deleted file mode 100644
index 8ddb7888..00000000
--- a/internal/dupechecking/bhd.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers/bhdmeta"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type bhdHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h bhdHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	cfg, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "BHD")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	tmdbID := meta.ExternalIDs.TMDBID
-	imdbID := imdbForLookup(meta)
-	if tmdbID == 0 && imdbID == "" {
-		return nil, []string{noteSkip("missing tmdb/imdb id for BHD dupe search")}, nil
-	}
-	category := "Movies"
-	tmdbPrefix := "movie"
-	if strings.EqualFold(meta.ExternalIDs.Category, "TV") {
-		category = "TV"
-		tmdbPrefix = "tv"
-	}
-	payload := map[string]any{
-		"action":     "search",
-		"categories": category,
-	}
-	if searchType, ok := bhdmeta.SearchType(meta); ok {
-		payload["types"] = searchType
-	} else {
-		payload["types"] = nil
-	}
-	if bhdmeta.IsSD(meta) {
-		payload["categories"] = nil
-		payload["types"] = nil
-	}
-	if tmdbID != 0 {
-		payload["tmdb_id"] = tmdbPrefix + "/" + strconv.Itoa(tmdbID)
-	} else {
-		payload["imdb_id"] = imdbID
-	}
-	if season := resolveSeasonValue(meta); season != "" && strings.EqualFold(category, "TV") {
-		payload["search"] = season
-	}
-	if rss := strings.TrimSpace(cfg.BhdRSSKey); rss != "" {
-		payload["rsskey"] = rss
-	}
-
-	endpoint := "https://beyond-hd.me/api/torrents/" + apiKey
-	status, body, err := doJSONPost(ctx, h.http, endpoint, payload, nil)
-	if err != nil {
-		return nil, []string{noteSkip("BHD request failed")}, nil
-	}
-	if status < 200 || status >= 300 || len(body) == 0 {
-		return nil, []string{noteSkip("BHD search failed")}, nil
-	}
-	if intFromAny(body["status_code"]) == 0 {
-		return nil, []string{noteSkip("BHD api rejected search")}, nil
-	}
-
-	results, _ := body["results"].([]any)
-	entries := make([]api.DupeEntry, 0, len(results))
-	for _, raw := range results {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: stringFromAny(item["name"]),
-			Link: stringFromAny(item["url"]),
-		}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		if intFromAny(item["dv"]) == 1 {
-			entry.Flags = append(entry.Flags, "DV")
-		}
-		if intFromAny(item["hdr10"]) == 1 || intFromAny(item["hdr10+"]) == 1 {
-			entry.Flags = append(entry.Flags, "HDR")
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/bhd_test.go b/internal/dupechecking/bhd_test.go
deleted file mode 100644
index 723c5c83..00000000
--- a/internal/dupechecking/bhd_test.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBHDSearchUsesExternalIDs(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name         string
-		meta         api.PreparedMetadata
-		wantTMDBID   string
-		wantIMDBID   string
-		wantCategory string
-		wantType     string
-		wantNilType  bool
-		wantNilCat   bool
-	}{
-		{
-			name: "tv tmdb id",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "TV"},
-				Release:     api.ReleaseInfo{Resolution: "1080p"},
-			},
-			wantTMDBID:   "tv/123",
-			wantCategory: "TV",
-			wantType:     "1080p",
-		},
-		{
-			name: "movie tmdb id",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				ExternalIDs: api.ExternalIDs{TMDBID: 234, Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Resolution: "1080p"},
-			},
-			wantTMDBID:   "movie/234",
-			wantCategory: "Movies",
-			wantType:     "1080p",
-		},
-		{
-			name: "tmdb takes precedence over imdb",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				ExternalIDs: api.ExternalIDs{TMDBID: 123, IMDBID: 7654321, Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Resolution: "2160p"},
-			},
-			wantTMDBID:   "movie/123",
-			wantCategory: "Movies",
-			wantType:     "2160p",
-		},
-		{
-			name: "imdb id",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				ExternalIDs: api.ExternalIDs{IMDBID: 1234567, Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Resolution: "1080p"},
-			},
-			wantIMDBID:   "tt1234567",
-			wantCategory: "Movies",
-			wantType:     "1080p",
-		},
-		{
-			name: "sd clears category and type filters",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Resolution: "576p"},
-			},
-			wantTMDBID:  "movie/123",
-			wantNilType: true,
-			wantNilCat:  true,
-		},
-		{
-			name: "dvd clears type filter",
-			meta: api.PreparedMetadata{
-				SourcePath:  "source",
-				DiscType:    "DVD",
-				ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Size: "DVD9"},
-			},
-			wantTMDBID:   "movie/123",
-			wantCategory: "Movies",
-			wantNilType:  true,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			var payload map[string]any
-			client := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				body, err := io.ReadAll(req.Body)
-				if err != nil {
-					t.Fatalf("read request body: %v", err)
-				}
-				if err := json.Unmarshal(body, &payload); err != nil {
-					t.Fatalf("decode request body: %v", err)
-				}
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body: io.NopCloser(bytes.NewBufferString(
-						`{"status_code":1,"results":[{"name":"Example.Release.2026.1080p-GRP"}]}`,
-					)),
-					Header: make(http.Header),
-				}, nil
-			})}
-			handler := bhdHandler{
-				cfg: config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-					"BHD": {APIKey: "placeholder"},
-				}}},
-				http: client,
-			}
-
-			entries, notes, err := handler.Search(context.Background(), tc.meta, "BHD")
-			if err != nil {
-				t.Fatalf("search failed: %v", err)
-			}
-			if reason, ok := parseSkipReason(notes); ok {
-				t.Fatalf("unexpected skip reason: %s", reason)
-			}
-			if len(entries) != 1 {
-				t.Fatalf("expected one result, got %#v", entries)
-			}
-			if got := stringFromAny(payload["tmdb_id"]); got != tc.wantTMDBID {
-				t.Fatalf("expected tmdb_id %q, got %q", tc.wantTMDBID, got)
-			}
-			if got := stringFromAny(payload["imdb_id"]); got != tc.wantIMDBID {
-				t.Fatalf("expected imdb_id %q, got %q", tc.wantIMDBID, got)
-			}
-			if tc.wantNilCat {
-				if value, ok := payload["categories"]; !ok || value != nil {
-					t.Fatalf("expected nil category filter, got %#v", value)
-				}
-			} else if got := stringFromAny(payload["categories"]); got != tc.wantCategory {
-				t.Fatalf("expected category %q, got %q", tc.wantCategory, got)
-			}
-			if tc.wantNilType {
-				if value, ok := payload["types"]; !ok || value != nil {
-					t.Fatalf("expected nil type filter, got %#v", value)
-				}
-			} else if got := stringFromAny(payload["types"]); got != tc.wantType {
-				t.Fatalf("expected type %q, got %q", tc.wantType, got)
-			}
-		})
-	}
-}
diff --git a/internal/dupechecking/bhdtv.go b/internal/dupechecking/bhdtv.go
deleted file mode 100644
index 2bb70bc4..00000000
--- a/internal/dupechecking/bhdtv.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type bhdtvHandler struct{}
-
-func (h bhdtvHandler) Search(_ context.Context, _ api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	return stringsToDupeEntries([]string{"Dupes must be checked Manually"}), []string{"BHDTV API dupe search is not available; manual check required"}, nil
-}
diff --git a/internal/dupechecking/bjs.go b/internal/dupechecking/bjs.go
deleted file mode 100644
index 1282b80a..00000000
--- a/internal/dupechecking/bjs.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type bjsHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h bjsHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	imdb := imdbForLookup(meta)
-	if imdb == "" {
-		return nil, []string{noteSkip("missing IMDb ID for BJS dupe search")}, nil
-	}
-	baseURL := trackerBaseURL(h.cfg, "BJS", "https://bj-share.info")
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "BJS", trackerHost(baseURL, "bj-share.info"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid BJS cookies")}, nil
-	}
-	resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/torrents.php", url.Values{"searchstr": {imdb}}, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("BJS search failed")}, nil
-	}
-	mainColumn := firstNode(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "div" && hasClass(node, "main_column")
-	})
-	if mainColumn == nil {
-		return nil, nil, nil
-	}
-	return extractBJSResults(baseURL, mainColumn, meta), nil, nil
-}
-
-func extractBJSResults(baseURL string, root *xhtml.Node, meta api.PreparedMetadata) []api.DupeEntry {
-	rows := findNodes(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "tr"
-	})
-	entries := make([]api.DupeEntry, 0)
-	currentSeason := ""
-	currentResolution := ""
-	currentEpisode := ""
-	currentPack := false
-	for _, row := range rows {
-		if updateBJSContext(row, &currentSeason, &currentResolution, &currentEpisode, &currentPack) {
-			continue
-		}
-
-		rowID := attrValueHTML(row, "id")
-		if !strings.HasPrefix(rowID, "torrent") || strings.HasPrefix(rowID, "torrent_") {
-			continue
-		}
-		if !shouldProcessBJSRow(currentSeason, currentResolution, currentEpisode, currentPack, meta) {
-			continue
-		}
-
-		entry := bjsEntryFromRow(baseURL, row)
-		if entry.ID != "" || entry.Name != "" {
-			entries = append(entries, entry)
-		}
-	}
-	return entries
-}
-
-func updateBJSContext(row *xhtml.Node, currentSeason *string, currentResolution *string, currentEpisode *string, currentPack *bool) bool {
-	for className := range strings.FieldsSeq(attrValueHTML(row, "class")) {
-		switch className {
-		case "resolution_header":
-			if match := regexp.MustCompile(`(?i)(\d{3,4}p|\d{3,4}i)`).FindStringSubmatch(nodeTextHTML(row)); len(match) == 2 {
-				*currentResolution = strings.ToLower(match[1])
-			}
-			return true
-		case "season_header":
-			if match := regexp.MustCompile(`(?i)temporada\s+(\d+)`).FindStringSubmatch(nodeTextHTML(row)); len(match) == 2 {
-				*currentSeason = match[1]
-			}
-			return true
-		}
-	}
-
-	rowspanCell := firstNode(row, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "td" && attrValueHTML(node, "rowspan") != ""
-	})
-	if rowspanCell == nil {
-		return false
-	}
-	link := firstNode(rowspanCell, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "href"), "torrents.php?id=")
-	})
-	if link == nil {
-		return false
-	}
-	text := strings.TrimSpace(nodeTextHTML(link))
-	if strings.Contains(strings.ToLower(text), "temporada") {
-		*currentPack = true
-		*currentEpisode = ""
-		return false
-	}
-	if match := regexp.MustCompile(`(?i)S(\d+)E(\d+)`).FindStringSubmatch(text); len(match) == 3 {
-		*currentPack = false
-		*currentEpisode = match[2]
-	}
-	return false
-}
-
-func shouldProcessBJSRow(currentSeason string, currentResolution string, currentEpisode string, currentPack bool, meta api.PreparedMetadata) bool {
-	category := strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.ExternalIDs.Category, meta.MediaInfoCategory, meta.Release.Category))
-	switch category {
-	case "TV":
-		if meta.SeasonInt <= 0 || strings.TrimSpace(currentSeason) == "" {
-			return false
-		}
-		season, err := strconv.Atoi(strings.TrimSpace(currentSeason))
-		if err != nil || season != meta.SeasonInt {
-			return false
-		}
-		if meta.TVPack {
-			return currentPack
-		}
-		if currentPack {
-			return true
-		}
-		episode, err := strconv.Atoi(strings.TrimSpace(currentEpisode))
-		return err == nil && episode == meta.EpisodeInt
-	case "MOVIE":
-		wantResolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
-		if wantResolution == "" || strings.TrimSpace(currentResolution) == "" {
-			return true
-		}
-		return strings.EqualFold(currentResolution, wantResolution)
-	default:
-		return true
-	}
-}
-
-func bjsEntryFromRow(baseURL string, row *xhtml.Node) api.DupeEntry {
-	link := firstNode(row, func(node *xhtml.Node) bool {
-		if node.Type != xhtml.ElementNode || node.Data != "a" {
-			return false
-		}
-		href := attrValueHTML(node, "href")
-		return strings.Contains(href, "torrentid=") || strings.Contains(attrValueHTML(node, "onclick"), "loadIfNeeded")
-	})
-	entry := api.DupeEntry{}
-	if link != nil {
-		entry.Name = strings.Join(strings.Fields(nodeTextHTML(link)), " ")
-		entry.ID = bjsTorrentIDFromLink(link)
-		if entry.ID != "" {
-			entry.Link = strings.TrimRight(baseURL, "/") + "/torrents.php?torrentid=" + entry.ID
-		}
-	}
-	if entry.ID == "" {
-		entry.ID = strings.TrimPrefix(attrValueHTML(row, "id"), "torrent")
-		if entry.ID != "" {
-			entry.Link = strings.TrimRight(baseURL, "/") + "/torrents.php?torrentid=" + entry.ID
-		}
-	}
-	sizeCell := firstNode(row, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "td" && hasClass(node, "number_column") && hasClass(node, "nobr")
-	})
-	if sizeCell != nil {
-		addSize(&entry, nodeTextHTML(sizeCell))
-	}
-	return entry
-}
-
-func bjsTorrentIDFromLink(link *xhtml.Node) string {
-	if link == nil {
-		return ""
-	}
-	href := attrValueHTML(link, "href")
-	if match := regexp.MustCompile(`(?i)torrentid=(\d+)`).FindStringSubmatch(href); len(match) == 2 {
-		return match[1]
-	}
-	if match := regexp.MustCompile(`loadIfNeeded\('(\d+)',\s*'(\d+)'`).FindStringSubmatch(attrValueHTML(link, "onclick")); len(match) >= 2 {
-		return match[1]
-	}
-	return ""
-}
diff --git a/internal/dupechecking/bjs_test.go b/internal/dupechecking/bjs_test.go
deleted file mode 100644
index 3683771b..00000000
--- a/internal/dupechecking/bjs_test.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"strings"
-	"testing"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestExtractBJSResultsNewTVLayout(t *testing.T) {
-	t.Parallel()
-
-	root := mustParseHTML(t, `
-<div class="main_column">
-  <table>
-    <tr class="resolution_header"><td>1080p</td></tr>
-    <tr class="season_header"><td>Temporada 1</td></tr>
-    <tr><td rowspan="2"><a href="torrents.php?id=77">Example S01E02</a></td></tr>
-    <tr id="torrent123"><td><a href="torrents.php?torrentid=123">Example.S01E02.1080p-GRP</a></td><td class="number_column nobr">1.5 GiB</td></tr>
-    <tr><td rowspan="2"><a href="torrents.php?id=78">Example S01E03</a></td></tr>
-    <tr id="torrent124"><td><a href="torrents.php?torrentid=124">Example.S01E03.1080p-GRP</a></td><td class="number_column nobr">1.7 GiB</td></tr>
-  </table>
-</div>`)
-
-	entries := extractBJSResults("https://bj-share.info", root, api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		SeasonInt:   1,
-		EpisodeInt:  2,
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-	})
-
-	if len(entries) != 1 {
-		t.Fatalf("expected one matching episode entry, got %#v", entries)
-	}
-	if entries[0].ID != "123" || entries[0].Name != "Example.S01E02.1080p-GRP" {
-		t.Fatalf("unexpected entry: %#v", entries[0])
-	}
-	if !entries[0].SizeKnown || entries[0].SizeBytes == 0 {
-		t.Fatalf("expected parsed size, got %#v", entries[0])
-	}
-}
-
-func TestExtractBJSResultsLegacyLoadIfNeededLayout(t *testing.T) {
-	t.Parallel()
-
-	root := mustParseHTML(t, `
-<div class="main_column">
-  <table>
-    <tr id="torrent555">
-      <td><a onclick="loadIfNeeded('555', '42')">Movie.2026.2160p-GRP</a></td>
-    </tr>
-  </table>
-</div>`)
-
-	entries := extractBJSResults("https://bj-share.info", root, api.PreparedMetadata{})
-	if len(entries) != 1 {
-		t.Fatalf("expected one legacy entry, got %#v", entries)
-	}
-	if entries[0].ID != "555" || entries[0].Link != "https://bj-share.info/torrents.php?torrentid=555" {
-		t.Fatalf("unexpected legacy entry: %#v", entries[0])
-	}
-}
-
-func mustParseHTML(t *testing.T, value string) *xhtml.Node {
-	t.Helper()
-
-	root, err := xhtml.Parse(strings.NewReader(value))
-	if err != nil {
-		t.Fatalf("parse html: %v", err)
-	}
-	return root
-}
diff --git a/internal/dupechecking/bt.go b/internal/dupechecking/bt.go
deleted file mode 100644
index d2de3a3f..00000000
--- a/internal/dupechecking/bt.go
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/url"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-
-	"golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type btHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h btHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "BT", trackerHost(trackerBaseURL(h.cfg, "BT", "https://brasiltracker.org"), "brasiltracker.org"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid BT cookies")}, nil
-	}
-
-	imdbID := resolveBTIMDbIDText(meta)
-
-	if imdbID == "" && !meta.Anime {
-		return nil, []string{noteSkip("missing IMDb ID for BT dupe search")}, nil
-	}
-
-	isTVPack := meta.TVPack
-
-	searchStr := imdbID
-	if meta.Anime {
-		tvdbNameEnglish := ""
-		tvdbName := ""
-		if meta.ExternalMetadata.TVDB != nil {
-			tvdbNameEnglish = strings.TrimSpace(meta.ExternalMetadata.TVDB.NameEnglish)
-			tvdbName = strings.TrimSpace(meta.ExternalMetadata.TVDB.Name)
-		}
-
-		tmdbTitle := ""
-		tmdbOriginalTitle := ""
-		if meta.ExternalMetadata.TMDB != nil {
-			tmdbTitle = strings.TrimSpace(meta.ExternalMetadata.TMDB.Title)
-			tmdbOriginalTitle = strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalTitle)
-		}
-
-		imdbTitle := ""
-		if meta.ExternalMetadata.IMDB != nil {
-			imdbTitle = strings.TrimSpace(meta.ExternalMetadata.IMDB.Title)
-		}
-
-		releaseName := strings.TrimSpace(meta.ReleaseName)
-
-		switch {
-		// English
-		case tvdbNameEnglish != "":
-			searchStr = tvdbNameEnglish
-		case tmdbTitle != "":
-			searchStr = tmdbTitle
-		case imdbTitle != "":
-			searchStr = imdbTitle
-
-		// Original
-		case tvdbName != "":
-			searchStr = tvdbName
-		case tmdbOriginalTitle != "":
-			searchStr = tmdbOriginalTitle
-
-		// Release Name
-		case releaseName != "":
-			searchStr = releaseName
-		}
-	}
-
-	if searchStr == "" {
-		return nil, []string{noteSkip("missing search term for BT dupe search")}, nil
-	}
-
-	baseURL := trackerBaseURL(h.cfg, "BT", "https://brasiltracker.org")
-
-	resp, stringBody, err := doTextGet(ctx, h.http, baseURL+"/torrents.php", url.Values{"searchstr": {searchStr}}, nil, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("BT search request failed")}, nil
-	}
-	if strings.Contains(strings.ToLower(resp.FinalURL), "login") {
-		return nil, []string{noteSkip("BT authentication required")}, nil
-	}
-
-	node, err := html.Parse(strings.NewReader(stringBody))
-	if err != nil {
-		return nil, []string{noteSkip("BT search html parse failed")}, nil
-	}
-
-	torrentTable := findBTNodeByID(node, "torrent_table")
-	if torrentTable == nil {
-		return nil, nil, nil
-	}
-
-	groupLinks := make(map[string]struct{})
-	findBTGroupLinks(torrentTable, groupLinks)
-
-	if len(groupLinks) == 0 {
-		return nil, nil, nil
-	}
-
-	var foundItems []string
-	if len(groupLinks) > 0 {
-		var mu sync.Mutex
-		var wg sync.WaitGroup
-		sem := make(chan struct{}, 5)
-	linkLoop:
-		for groupLink := range groupLinks {
-			select {
-			case <-ctx.Done():
-				break linkLoop
-			case sem <- struct{}{}:
-			}
-
-			wg.Add(1)
-			go func(link string) {
-				defer wg.Done()
-				defer func() { <-sem }()
-
-				groupResp, groupBody, groupErr := doTextGet(ctx, h.http, baseURL+"/"+link, nil, nil, cookies)
-				if groupErr != nil {
-					if h.logger != nil {
-						h.logger.Debugf("BT group link request failed for %s: %v", link, groupErr)
-					}
-					return
-				}
-				if !groupResp.ok() {
-					if h.logger != nil {
-						h.logger.Debugf("BT group link request returned non-success status %d for %s", groupResp.StatusCode, link)
-					}
-					return
-				}
-
-				groupNode, nodeErr := html.Parse(strings.NewReader(groupBody))
-				if nodeErr != nil {
-					if h.logger != nil {
-						h.logger.Debugf("BT group link html parse failed for %s: %v", link, nodeErr)
-					}
-					return
-				}
-
-				var localFound []string
-				processBTGroupPage(groupNode, isTVPack, &localFound)
-
-				if len(localFound) > 0 {
-					mu.Lock()
-					foundItems = append(foundItems, localFound...)
-					mu.Unlock()
-				}
-			}(groupLink)
-		}
-		wg.Wait()
-	}
-
-	var entries []api.DupeEntry
-	for _, item := range foundItems {
-		if trimmed := strings.TrimSpace(item); trimmed != "" {
-			entries = append(entries, api.DupeEntry{Name: trimmed})
-		}
-	}
-
-	return entries, nil, nil
-}
-
-func resolveBTIMDbIDText(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func findBTNodeByID(n *html.Node, id string) *html.Node {
-	if n.Type == html.ElementNode {
-		for _, a := range n.Attr {
-			if a.Key == "id" && a.Val == id {
-				return n
-			}
-		}
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		if res := findBTNodeByID(c, id); res != nil {
-			return res
-		}
-	}
-	return nil
-}
-
-func findBTGroupLinks(n *html.Node, links map[string]struct{}) {
-	if n.Type == html.ElementNode && n.Data == "a" {
-		href := ""
-		for _, a := range n.Attr {
-			if a.Key == "href" {
-				href = a.Val
-			}
-		}
-		if strings.Contains(href, "torrents.php?id=") && !strings.Contains(href, "torrentid") {
-			links[href] = struct{}{}
-		}
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		findBTGroupLinks(c, links)
-	}
-}
-
-func processBTGroupPage(n *html.Node, isTVPack bool, foundItems *[]string) {
-	trs := findBTAllNodes(n, func(node *html.Node) bool {
-		if node.Type == html.ElementNode && node.Data == "tr" {
-			for _, a := range node.Attr {
-				if a.Key == "id" && strings.HasPrefix(a.Val, "torrent") {
-					suffix := strings.TrimPrefix(a.Val, "torrent")
-					if _, err := strconv.Atoi(suffix); err == nil {
-						return true
-					}
-				}
-			}
-		}
-		return false
-	})
-
-	for _, tr := range trs {
-		descLink := findBTNode(tr, func(node *html.Node) bool {
-			if node.Type == html.ElementNode && node.Data == "a" {
-				for _, a := range node.Attr {
-					if a.Key == "onclick" && strings.Contains(a.Val, "gtoggle") {
-						return true
-					}
-				}
-			}
-			return false
-		})
-
-		if descLink == nil {
-			continue
-		}
-
-		descText := strings.ToLower(extractBTText(descLink))
-		isDisc := false
-		for _, kw := range []string{"bd25", "bd50", "bd66", "bd100", "dvd5", "dvd9", "m2ts"} {
-			if strings.Contains(descText, kw) {
-				isDisc = true
-				break
-			}
-		}
-
-		idVal := ""
-		for _, a := range tr.Attr {
-			if a.Key == "id" {
-				idVal = a.Val
-			}
-		}
-		torrentID := strings.TrimPrefix(idVal, "torrent")
-
-		fileDiv := findBTNodeByID(n, "files_"+torrentID)
-		if fileDiv == nil {
-			continue
-		}
-
-		if isDisc || isTVPack {
-			pathDiv := findBTNode(fileDiv, func(node *html.Node) bool {
-				return node.Type == html.ElementNode && node.Data == "div" && hasBTClass(node, "filelist_path")
-			})
-			if pathDiv != nil {
-				folderName := strings.Trim(strings.TrimSpace(extractBTText(pathDiv)), "/")
-				if folderName != "" {
-					*foundItems = append(*foundItems, folderName)
-				}
-			}
-		} else {
-			fileTable := findBTNode(fileDiv, func(node *html.Node) bool {
-				return node.Type == html.ElementNode && node.Data == "table" && hasBTClass(node, "filelist_table")
-			})
-			if fileTable != nil {
-				rows := findBTAllNodes(fileTable, func(node *html.Node) bool {
-					return node.Type == html.ElementNode && node.Data == "tr"
-				})
-				for _, row := range rows {
-					if hasBTClass(row, "colhead_dark") {
-						continue
-					}
-					cell := findBTNode(row, func(node *html.Node) bool {
-						return node.Type == html.ElementNode && node.Data == "td"
-					})
-					if cell != nil {
-						filename := strings.TrimSpace(extractBTText(cell))
-						if filename != "" {
-							*foundItems = append(*foundItems, filename)
-							break
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func findBTNode(n *html.Node, match func(*html.Node) bool) *html.Node {
-	if match(n) {
-		return n
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		if res := findBTNode(c, match); res != nil {
-			return res
-		}
-	}
-	return nil
-}
-
-func findBTAllNodes(n *html.Node, match func(*html.Node) bool) []*html.Node {
-	var nodes []*html.Node
-	if match(n) {
-		nodes = append(nodes, n)
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		nodes = append(nodes, findBTAllNodes(c, match)...)
-	}
-	return nodes
-}
-
-func hasBTClass(n *html.Node, class string) bool {
-	for _, a := range n.Attr {
-		if a.Key == "class" {
-			classes := strings.Fields(a.Val)
-			if slices.Contains(classes, class) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func extractBTText(n *html.Node) string {
-	if n.Type == html.TextNode {
-		return n.Data
-	}
-	var b strings.Builder
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		b.WriteString(extractBTText(c))
-	}
-	return b.String()
-}
diff --git a/internal/dupechecking/btn.go b/internal/dupechecking/btn.go
deleted file mode 100644
index af1853e0..00000000
--- a/internal/dupechecking/btn.go
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const btnRPCURL = "https://api.broadcasthe.net/"
-
-type btnHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h btnHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	apiToken := strings.TrimSpace(config.ResolveBTNAPIToken(h.cfg))
-	if apiToken == "" {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	if !isBTNTVMeta(meta) {
-		return nil, []string{noteSkip("BTN only supports TV dupe search")}, nil
-	}
-
-	filter := make(map[string]any)
-	switch {
-	case btnTrackerID(meta) != "":
-		filter["id"] = btnTrackerID(meta)
-	case meta.ExternalIDs.IMDBID != 0:
-		filter["imdb"] = formatBTNIMDbID(meta.ExternalIDs.IMDBID)
-	case meta.ExternalIDs.TVDBID != 0:
-		filter["tvdb"] = meta.ExternalIDs.TVDBID
-	case btnSearchTitle(meta) != "":
-		filter["searchstr"] = btnSearchTitle(meta)
-	default:
-		return nil, []string{noteSkip("missing btn/imdb/tvdb id and title for BTN dupe search")}, nil
-	}
-
-	payload := map[string]any{
-		"jsonrpc": "2.0",
-		"id":      "upbrr-btn-search",
-		"method":  "getTorrentsSearch",
-		"params":  []any{apiToken, filter, 50},
-	}
-	status, body, err := doJSONPostAny(ctx, h.http, btnRPCURL, payload, nil)
-	if err != nil {
-		return nil, []string{noteSkip("BTN request failed")}, nil
-	}
-	if status < 200 || status >= 300 || body == nil {
-		return nil, []string{noteSkip("BTN search failed")}, nil
-	}
-
-	response, ok := body.(map[string]any)
-	if !ok {
-		return nil, []string{noteSkip("BTN search failed")}, nil
-	}
-	if errPayload, ok := response["error"].(map[string]any); ok && len(errPayload) > 0 {
-		return nil, nil, nil
-	}
-
-	result, _ := response["result"].(map[string]any)
-	if len(result) == 0 {
-		return nil, nil, nil
-	}
-	torrents, _ := result["torrents"].(map[string]any)
-	entries := make([]api.DupeEntry, 0, len(torrents))
-	for torrentID, raw := range torrents {
-		torrentData, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: btnReleaseName(torrentID, torrentData),
-			ID:   strings.TrimSpace(torrentID),
-			Link: btnTorrentLink(torrentID, torrentData),
-			Res:  btnResolution(torrentData),
-			Type: btnType(torrentData),
-		}
-		size := intFromAny(firstValue(torrentData, "Size", "size"))
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entry.Flags = btnFlags(torrentData)
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
-
-func isBTNTVMeta(meta api.PreparedMetadata) bool {
-	category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	return category == "TV"
-}
-
-func btnTrackerID(meta api.PreparedMetadata) string {
-	if len(meta.TrackerIDs) == 0 {
-		return ""
-	}
-	for key, value := range meta.TrackerIDs {
-		if strings.EqualFold(strings.TrimSpace(key), "BTN") {
-			return strings.TrimSpace(value)
-		}
-	}
-	return ""
-}
-
-func formatBTNIMDbID(imdbID int) string {
-	if imdbID <= 0 {
-		return ""
-	}
-	return "tt" + leftPad(imdbID, 7)
-}
-
-func btnSearchTitle(meta api.PreparedMetadata) string {
-	candidates := []string{strings.TrimSpace(meta.Release.Title)}
-	if meta.ExternalMetadata.TVDB != nil {
-		candidates = append(candidates,
-			strings.TrimSpace(meta.ExternalMetadata.TVDB.Name),
-			strings.TrimSpace(meta.ExternalMetadata.TVDB.NameEnglish),
-		)
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		candidates = append(candidates, strings.TrimSpace(meta.ExternalMetadata.TVmaze.Name))
-	}
-	candidates = append(candidates,
-		strings.TrimSpace(meta.Filename),
-		strings.TrimSpace(meta.ReleaseName),
-	)
-	for _, candidate := range candidates {
-		if candidate != "" {
-			return candidate
-		}
-	}
-	return ""
-}
-
-func btnReleaseName(torrentID string, torrentData map[string]any) string {
-	candidates := []string{
-		stringFromAny(firstValue(torrentData, "ReleaseName", "releaseName")),
-		stringFromAny(firstValue(torrentData, "SceneName", "Name", "name")),
-		stringFromAny(firstValue(torrentData, "Series", "series")),
-		strings.TrimSpace(torrentID),
-	}
-	for _, candidate := range candidates {
-		if candidate != "" {
-			return candidate
-		}
-	}
-	return ""
-}
-
-func btnTorrentLink(torrentID string, torrentData map[string]any) string {
-	groupID := stringFromAny(firstValue(torrentData, "GroupID", "groupId"))
-	if groupID == "" || strings.TrimSpace(torrentID) == "" {
-		return ""
-	}
-	return "https://broadcasthe.net/torrents.php?id=" + groupID + "&torrentid=" + strings.TrimSpace(torrentID)
-}
-
-func btnResolution(torrentData map[string]any) string {
-	return stringFromAny(firstValue(torrentData, "Resolution", "resolution"))
-}
-
-func btnType(torrentData map[string]any) string {
-	return stringFromAny(firstValue(torrentData, "Source", "source", "Type", "type"))
-}
-
-func btnFlags(torrentData map[string]any) []string {
-	flags := make([]string, 0, 2)
-	for _, value := range []string{
-		stringFromAny(firstValue(torrentData, "HDR", "hdr")),
-		stringFromAny(firstValue(torrentData, "DolbyVision", "dolbyVision", "DV", "dv")),
-	} {
-		upper := strings.ToUpper(strings.TrimSpace(value))
-		switch upper {
-		case "", "0", "FALSE", "NO":
-			continue
-		case "1", "TRUE", "YES":
-			continue
-		}
-		flags = append(flags, upper)
-	}
-	return flags
-}
-
-func firstValue(values map[string]any, keys ...string) any {
-	for _, key := range keys {
-		if value, ok := values[key]; ok {
-			return value
-		}
-	}
-	return nil
-}
diff --git a/internal/dupechecking/btn_test.go b/internal/dupechecking/btn_test.go
deleted file mode 100644
index 59198c31..00000000
--- a/internal/dupechecking/btn_test.go
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"sync"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBTNHandlerSkipsWithoutAPIKey(t *testing.T) {
-	t.Parallel()
-
-	handler := btnHandler{cfg: config.Config{}}
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	reason, ok := parseSkipReason(notes)
-	if !ok || reason != "missing api_key for tracker" {
-		t.Fatalf("expected missing api_key skip note, got %v", notes)
-	}
-}
-
-func TestBTNHandlerSkipsNonTV(t *testing.T) {
-	t.Parallel()
-
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: http.DefaultClient}
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "MOVIE",
-		},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	reason, ok := parseSkipReason(notes)
-	if !ok || reason != "BTN only supports TV dupe search" {
-		t.Fatalf("expected non-tv skip note, got %v", notes)
-	}
-}
-
-func TestBTNHandlerUsesTrackerIDFirst(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	_, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		TrackerIDs: map[string]string{"btn": "1234"},
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-			IMDBID:   7654321,
-			TVDBID:   8899,
-		},
-		Release: api.ReleaseInfo{Title: "Ignored"},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %v", notes)
-	}
-	filter := payloads.lastFilter(t)
-	assertBTNFilterValue(t, filter, "id", "1234")
-	if _, ok := filter["imdb"]; ok {
-		t.Fatalf("did not expect imdb when btn id is present: %#v", filter)
-	}
-	if _, ok := filter["tvdb"]; ok {
-		t.Fatalf("did not expect tvdb when btn id is present: %#v", filter)
-	}
-	if _, ok := filter["searchstr"]; ok {
-		t.Fatalf("did not expect searchstr when btn id is present: %#v", filter)
-	}
-}
-
-func TestBTNHandlerFallsBackToIMDb(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	_, _, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-			IMDBID:   1234567,
-		},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	filter := payloads.lastFilter(t)
-	assertBTNFilterValue(t, filter, "imdb", "tt1234567")
-}
-
-func TestBTNHandlerFallsBackToTVDB(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	_, _, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-			TVDBID:   998877,
-		},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	filter := payloads.lastFilter(t)
-	if got := intFromAny(filter["tvdb"]); got != 998877 {
-		t.Fatalf("expected tvdb 998877, got %#v", filter["tvdb"])
-	}
-}
-
-func TestBTNHandlerFallsBackToTitleSearch(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	_, _, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		Release: api.ReleaseInfo{Title: "Example Show"},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	filter := payloads.lastFilter(t)
-	assertBTNFilterValue(t, filter, "searchstr", "Example Show")
-}
-
-func TestBTNHandlerNormalizesEntries(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"result":{"torrents":{"777":{"GroupID":"333","ReleaseName":"Example.Show.S01E01.1080p.WEB-DL.HDR.DV","Size":12345,"Resolution":"1080p","Source":"WEB-DL","HDR":"HDR10","DolbyVision":"DV"}}}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		Release: api.ReleaseInfo{Title: "Example Show"},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(entries))
-	}
-	entry := entries[0]
-	if entry.Name != "Example.Show.S01E01.1080p.WEB-DL.HDR.DV" {
-		t.Fatalf("unexpected name: %#v", entry)
-	}
-	if entry.ID != "777" {
-		t.Fatalf("unexpected id: %#v", entry)
-	}
-	if entry.Link != "https://broadcasthe.net/torrents.php?id=333&torrentid=777" {
-		t.Fatalf("unexpected link: %#v", entry)
-	}
-	if !entry.SizeKnown || entry.SizeBytes != 12345 {
-		t.Fatalf("unexpected size fields: %#v", entry)
-	}
-	if entry.Res != "1080p" {
-		t.Fatalf("unexpected resolution: %#v", entry)
-	}
-	if entry.Type != "WEB-DL" {
-		t.Fatalf("unexpected type: %#v", entry)
-	}
-	if len(entry.Flags) != 2 || entry.Flags[0] != "HDR10" || entry.Flags[1] != "DV" {
-		t.Fatalf("unexpected flags: %#v", entry.Flags)
-	}
-}
-
-func TestBTNHandlerAPIErrorReturnsNoDupes(t *testing.T) {
-	t.Parallel()
-
-	payloads := captureBTNPayloads(t, `{"error":{"message":"bad request"}}`)
-	handler := btnHandler{cfg: configWithBTNAPIKey(), http: payloads.client}
-
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		SourcePath: "x",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		Release: api.ReleaseInfo{Title: "Example Show"},
-	}, "BTN")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %v", notes)
-	}
-}
-
-type btnPayloadCapture struct {
-	client  *http.Client
-	payload map[string]any
-	mu      sync.Mutex
-}
-
-func captureBTNPayloads(t *testing.T, response string) *btnPayloadCapture {
-	t.Helper()
-
-	capture := &btnPayloadCapture{}
-	capture.client = &http.Client{
-		Transport: btnRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-			body, err := io.ReadAll(req.Body)
-			if err != nil {
-				return nil, fmt.Errorf("read BTN payload request body: %w", err)
-			}
-			_ = req.Body.Close()
-
-			capture.mu.Lock()
-			defer capture.mu.Unlock()
-			if err := json.Unmarshal(body, &capture.payload); err != nil {
-				return nil, fmt.Errorf("unmarshal BTN payload request body: %w", err)
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(response)),
-				Request:    req,
-			}, nil
-		}),
-	}
-	return capture
-}
-
-func (c *btnPayloadCapture) lastFilter(t *testing.T) map[string]any {
-	t.Helper()
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	params, ok := c.payload["params"].([]any)
-	if !ok || len(params) < 2 {
-		t.Fatalf("expected JSON-RPC params, got %#v", c.payload)
-	}
-	filter, ok := params[1].(map[string]any)
-	if !ok {
-		t.Fatalf("expected filter map, got %#v", params[1])
-	}
-	return filter
-}
-
-func configWithBTNAPIKey() config.Config {
-	return config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"BTN": {APIKey: strings.Repeat("x", 30)},
-			},
-		},
-	}
-}
-
-func assertBTNFilterValue(t *testing.T, filter map[string]any, key string, want string) {
-	t.Helper()
-	if got := stringFromAny(filter[key]); got != want {
-		t.Fatalf("expected %s=%q, got %#v", key, want, filter)
-	}
-}
-
-type btnRoundTripFunc func(*http.Request) (*http.Response, error)
-
-func (fn btnRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return fn(req)
-}
diff --git a/internal/dupechecking/common.go b/internal/dupechecking/common.go
deleted file mode 100644
index cd8e03be..00000000
--- a/internal/dupechecking/common.go
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"sort"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const skipNotePrefix = "skip: "
-
-func normalizeTracker(tracker string) string {
-	return strings.ToUpper(strings.TrimSpace(tracker))
-}
-
-func handlerNotImplementedReason(tracker string) string {
-	return "dupe search not implemented for tracker " + normalizeTracker(tracker)
-}
-
-func skipReason(meta api.PreparedMetadata, tracker string) (string, []string) {
-	if len(meta.TrackerRuleFailures) == 0 {
-		return "", nil
-	}
-	failures := meta.TrackerRuleFailures[tracker]
-	failures = api.BlockingRuleFailures(failures)
-	if len(failures) == 0 {
-		return "", nil
-	}
-
-	parts := make([]string, 0, len(failures))
-	ruleSet := make(map[string]struct{}, len(failures))
-	for _, failure := range failures {
-		rule := strings.TrimSpace(failure.Rule)
-		if rule != "" {
-			ruleSet[rule] = struct{}{}
-		}
-		reason := strings.TrimSpace(failure.Reason)
-		if reason == "" {
-			reason = rule
-		}
-		if reason != "" {
-			parts = append(parts, reason)
-		}
-	}
-
-	rules := make([]string, 0, len(ruleSet))
-	for rule := range ruleSet {
-		rules = append(rules, rule)
-	}
-	sort.Strings(rules)
-
-	if len(parts) == 0 {
-		return "rule check failed", rules
-	}
-	return "rule check failed: " + strings.Join(parts, "; "), rules
-}
-
-func trimEntries(entries []api.DupeEntry) []api.DupeEntry {
-	if len(entries) == 0 {
-		return nil
-	}
-	out := make([]api.DupeEntry, 0, len(entries))
-	for _, entry := range entries {
-		entry.Name = strings.TrimSpace(entry.Name)
-		entry.Link = strings.TrimSpace(entry.Link)
-		entry.Download = strings.TrimSpace(entry.Download)
-		entry.ID = strings.TrimSpace(entry.ID)
-		entry.Type = strings.TrimSpace(entry.Type)
-		entry.Res = strings.TrimSpace(entry.Res)
-		if entry.Name == "" {
-			continue
-		}
-		out = append(out, entry)
-	}
-	return out
-}
-
-func noteSkip(reason string) string {
-	return skipNotePrefix + strings.TrimSpace(reason)
-}
-
-func parseSkipReason(notes []string) (string, bool) {
-	for _, note := range notes {
-		trimmed := strings.TrimSpace(note)
-		if !strings.HasPrefix(strings.ToLower(trimmed), skipNotePrefix) {
-			continue
-		}
-		reason := strings.TrimSpace(trimmed[len(skipNotePrefix):])
-		if reason != "" {
-			return reason, true
-		}
-	}
-	return "", false
-}
-
-func stringsToDupeEntries(values []string) []api.DupeEntry {
-	if len(values) == 0 {
-		return nil
-	}
-	entries := make([]api.DupeEntry, 0, len(values))
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		entries = append(entries, api.DupeEntry{Name: trimmed})
-	}
-	return entries
-}
-
-func trackerCfg(cfg config.Config, name string) (config.TrackerConfig, bool) {
-	key := normalizeTracker(name)
-	if key == "" || len(cfg.Trackers.Trackers) == 0 {
-		return config.TrackerConfig{}, false
-	}
-	if entry, ok := cfg.Trackers.Trackers[key]; ok {
-		return entry, true
-	}
-	for candidate, entry := range cfg.Trackers.Trackers {
-		if strings.EqualFold(candidate, key) {
-			return entry, true
-		}
-	}
-	return config.TrackerConfig{}, false
-}
-
-func trackerCfgWithAPIKey(cfg config.Config, name string) (config.TrackerConfig, string, bool) {
-	tracker, ok := trackerCfg(cfg, name)
-	if !ok {
-		return config.TrackerConfig{}, "", false
-	}
-	apiKey := strings.TrimSpace(tracker.APIKey)
-	if apiKey == "" {
-		return config.TrackerConfig{}, "", false
-	}
-	return tracker, apiKey, true
-}
-
-func trackerCfgWithPasskey(cfg config.Config, name string) (config.TrackerConfig, string, bool) {
-	tracker, ok := trackerCfg(cfg, name)
-	if !ok {
-		return config.TrackerConfig{}, "", false
-	}
-	passkey := strings.TrimSpace(tracker.Passkey)
-	if passkey == "" {
-		return config.TrackerConfig{}, "", false
-	}
-	return tracker, passkey, true
-}
diff --git a/internal/dupechecking/common_test.go b/internal/dupechecking/common_test.go
deleted file mode 100644
index 2690240c..00000000
--- a/internal/dupechecking/common_test.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestSkipReasonIgnoresWarnings(t *testing.T) {
-	t.Parallel()
-	meta := api.PreparedMetadata{TrackerRuleFailures: map[string][]api.RuleFailure{
-		"PTP": {{Rule: "require_metadata_id", Reason: "IMDb recommended", Severity: api.RuleFailureSeverityWarning}},
-	}}
-	reason, rules := skipReason(meta, "PTP")
-	if reason != "" || len(rules) != 0 {
-		t.Fatalf("expected warning not to skip dupe checking, got reason=%q rules=%v", reason, rules)
-	}
-}
diff --git a/internal/dupechecking/cz.go b/internal/dupechecking/cz.go
deleted file mode 100644
index 5c0cfa3e..00000000
--- a/internal/dupechecking/cz.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type czHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h czHandler) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	return azNetworkHandler(h).Search(ctx, meta, tracker)
-}
diff --git a/internal/dupechecking/czt.go b/internal/dupechecking/czt.go
deleted file mode 100644
index 7e1a1e24..00000000
--- a/internal/dupechecking/czt.go
+++ /dev/null
@@ -1,187 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const cztDefaultBaseURL = "https://czteam.me"
-
-// cztHandler searches CZTeam for existing releases via its JSON search API:
-//
-//	GET {base}/api.php?action=search-torrents&type=name&query=...&passkey=<16-hex>
-//
-// The endpoint authenticates with the user's passkey (the same one used by
-// upload, announce, and download) and normally returns torrent objects either
-// as a bare array or under a small response wrapper.
-type cztHandler struct {
-	cfg     config.Config
-	http    *http.Client
-	logger  api.Logger
-	baseURL string
-}
-
-// Search queries CZTeam by the most specific prepared release name available.
-// Missing tracker config, passkey, or title returns skip notes; remote or
-// response-shape failures return errors so duplicate filtering fails closed.
-// Context cancellation is returned before transport errors are redacted or
-// wrapped as CZT failures so callers can preserve cancellation semantics.
-func (h cztHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	tracker, ok := trackerCfg(h.cfg, "CZT")
-	if !ok {
-		return nil, []string{noteSkip("missing passkey for tracker")}, nil
-	}
-	passkey := strings.TrimSpace(tracker.Passkey)
-	if passkey == "" {
-		return nil, []string{noteSkip("missing passkey for tracker")}, nil
-	}
-
-	query := cztSearchQuery(meta)
-	if query == "" {
-		return nil, []string{noteSkip("missing title for CZT dupe search")}, nil
-	}
-
-	base := strings.TrimRight(strings.TrimSpace(h.baseURL), "/")
-	if base == "" {
-		base = cztDefaultBaseURL
-	}
-
-	params := url.Values{}
-	params.Set("action", "search-torrents")
-	params.Set("type", "name")
-	params.Set("query", query)
-	params.Set("passkey", passkey)
-	params.Set("incldead", "1")
-
-	status, payload, err := doJSONGetAny(ctx, h.http, base+"/api.php", params, nil)
-	if err != nil {
-		if ctxErr := ctx.Err(); ctxErr != nil {
-			return nil, nil, fmt.Errorf("context canceled: %w", ctxErr)
-		}
-		return nil, nil, fmt.Errorf("CZT search failed: %w", redactedError(err))
-	}
-	if err := ctx.Err(); err != nil {
-		return nil, nil, fmt.Errorf("context canceled: %w", err)
-	}
-	if status < 200 || status >= 300 {
-		return nil, nil, fmt.Errorf("CZT search failed: HTTP status %d", status)
-	}
-	if payload == nil {
-		return nil, nil, errors.New("CZT search failed: empty response")
-	}
-
-	items, ok := cztResultItems(payload)
-	if !ok {
-		return nil, nil, errors.New("CZT search failed: unexpected response shape")
-	}
-
-	entries := make([]api.DupeEntry, 0, len(items))
-	for _, raw := range items {
-		if err := ctx.Err(); err != nil {
-			return nil, nil, fmt.Errorf("context canceled: %w", err)
-		}
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		name := strings.TrimSpace(stringFromAny(firstValue(item,
-			"name", "Name",
-			"torrent_name", "torrentName", "torrentname",
-			"release_name", "releaseName",
-			"title", "Title",
-			"filename", "fileName",
-		)))
-		if name == "" {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: name,
-			ID:   stringFromAny(firstValue(item, "id", "ID", "torrent_id", "torrentId", "torrentid")),
-			Link: stringFromAny(firstValue(item, "url", "URL", "details_url", "detailsUrl", "link")),
-		}
-		if size := intFromAny(firstValue(item, "size", "Size", "size_bytes", "sizeBytes")); size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
-
-// cztSearchQuery prefers exact upload/client names before media titles because
-// CZTeam's name search matches torrent release names.
-func cztSearchQuery(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(
-		meta.SceneName,
-		meta.ReleaseName,
-		meta.Release.Title,
-		meta.Filename,
-	)
-}
-
-// cztResultItems extracts torrent rows from the CZTeam search response. Auth or
-// validation objects without a recognizable result container return false so
-// callers fail the dupe check instead of treating the search as empty.
-func cztResultItems(payload any) ([]any, bool) {
-	if items, ok := payload.([]any); ok {
-		return items, true
-	}
-	obj, ok := payload.(map[string]any)
-	if !ok {
-		return nil, false
-	}
-	for _, key := range []string{"data", "results", "torrents", "response"} {
-		value, ok := obj[key]
-		if !ok {
-			continue
-		}
-		if items, ok := value.([]any); ok {
-			return items, true
-		}
-		if nested, ok := cztResultItems(value); ok {
-			return nested, true
-		}
-	}
-	if values, ok := cztObjectItems(obj); ok {
-		return values, true
-	}
-	return nil, false
-}
-
-// cztObjectItems accepts API shapes that key torrent rows by id. Mixed scalar
-// fields are rejected because those shapes are usually error/status payloads.
-func cztObjectItems(obj map[string]any) ([]any, bool) {
-	if len(obj) == 0 {
-		return nil, false
-	}
-	items := make([]any, 0, len(obj))
-	for _, value := range obj {
-		if _, ok := value.(map[string]any); !ok {
-			return nil, false
-		}
-		items = append(items, value)
-	}
-	return items, true
-}
-
-// redactedError returns an error whose text has passed through the repository
-// redactor, preventing passkeys embedded in transport errors from surfacing in
-// duplicate-check results or progress messages.
-func redactedError(err error) error {
-	if err == nil {
-		return nil
-	}
-	return errors.New(redaction.RedactValue(err.Error(), nil))
-}
diff --git a/internal/dupechecking/czt_test.go b/internal/dupechecking/czt_test.go
deleted file mode 100644
index 1a640fc6..00000000
--- a/internal/dupechecking/czt_test.go
+++ /dev/null
@@ -1,516 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestCZTHandlerSearchUsesPasskeyAndParsesArray(t *testing.T) {
-	t.Parallel()
-
-	const title = "Movie & Show/2024"
-
-	tests := []struct {
-		name string
-		cfg  config.TrackerConfig
-		meta api.PreparedMetadata
-	}{
-		{
-			name: "passkey only",
-			cfg:  config.TrackerConfig{Passkey: "passkey123"},
-			meta: api.PreparedMetadata{Release: api.ReleaseInfo{Title: title}},
-		},
-		{
-			name: "both credentials use passkey",
-			cfg:  config.TrackerConfig{APIKey: "bearer-token", Passkey: "passkey123"},
-			meta: api.PreparedMetadata{Release: api.ReleaseInfo{Title: title}},
-		},
-		{
-			name: "padded passkey and title fallback",
-			cfg:  config.TrackerConfig{Passkey: " passkey123 "},
-			meta: api.PreparedMetadata{ReleaseName: title},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			handlerErr := make(chan error, 1)
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if err := assertCZTSearchRequest(r, title); err != nil {
-					select {
-					case handlerErr <- err:
-					default:
-					}
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				}
-				_, _ = io.WriteString(w, `[{"id":"77","name":"Movie.2024.1080p.WEB-DL-GRP","url":"https://czteam.me/details.php?id=77","size":12345}]`)
-			}))
-			defer server.Close()
-
-			handler := cztHandler{
-				cfg:     cztTestConfig(tc.cfg),
-				http:    server.Client(),
-				logger:  api.NopLogger{},
-				baseURL: server.URL,
-			}
-			entries, notes, err := handler.Search(context.Background(), tc.meta, "CZT")
-			select {
-			case err := <-handlerErr:
-				t.Fatalf("handler: %v", err)
-			default:
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if len(notes) != 0 {
-				t.Fatalf("unexpected notes: %v", notes)
-			}
-			if len(entries) != 1 {
-				t.Fatalf("expected 1 entry, got %d", len(entries))
-			}
-			entry := entries[0]
-			if entry.ID != "77" || entry.Name != "Movie.2024.1080p.WEB-DL-GRP" || entry.Link == "" {
-				t.Fatalf("unexpected entry: %#v", entry)
-			}
-			if !entry.SizeKnown || entry.SizeBytes != 12345 {
-				t.Fatalf("unexpected size fields: %#v", entry)
-			}
-		})
-	}
-}
-
-func TestCZTHandlerSearchPrefersFullReleaseName(t *testing.T) {
-	t.Parallel()
-
-	const releaseName = "Movie.2024.1080p.WEB-DL-GRP"
-
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := assertCZTSearchRequest(r, releaseName); err != nil {
-			select {
-			case handlerErr <- err:
-			default:
-			}
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		_, _ = io.WriteString(w, `[{"id":"77","name":"Movie.2024.1080p.WEB-DL-GRP","url":"https://czteam.me/details.php?id=77"}]`)
-	}))
-	defer server.Close()
-
-	handler := cztHandler{
-		cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
-		http:    server.Client(),
-		logger:  api.NopLogger{},
-		baseURL: server.URL,
-	}
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		ReleaseName: releaseName,
-		Release:     api.ReleaseInfo{Title: "Movie"},
-	}, "CZT")
-	select {
-	case err := <-handlerErr:
-		t.Fatalf("handler: %v", err)
-	default:
-	}
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("unexpected notes: %v", notes)
-	}
-	if len(entries) != 1 || entries[0].Name != releaseName {
-		t.Fatalf("expected release-name result, got %#v", entries)
-	}
-}
-
-func TestCZTHandlerSearchParsesWrappedAndAliasedResults(t *testing.T) {
-	t.Parallel()
-
-	const title = "Movie.2024.1080p.WEB-DL-GRP"
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := assertCZTSearchRequest(r, title); err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		_, _ = io.WriteString(w, `{"data":{"results":[{"torrent_id":77,"torrent_name":"Movie.2024.1080p.WEB-DL-GRP","details_url":"https://czteam.me/details.php?id=77","size_bytes":12345}]}}`)
-	}))
-	defer server.Close()
-
-	handler := cztHandler{
-		cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
-		http:    server.Client(),
-		logger:  api.NopLogger{},
-		baseURL: server.URL,
-	}
-	entries, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-		ReleaseName: title,
-	}, "CZT")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("unexpected notes: %v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one entry, got %#v", entries)
-	}
-	entry := entries[0]
-	if entry.ID != "77" || entry.Name != title || entry.Link != "https://czteam.me/details.php?id=77" {
-		t.Fatalf("unexpected entry: %#v", entry)
-	}
-	if !entry.SizeKnown || entry.SizeBytes != 12345 {
-		t.Fatalf("unexpected size fields: %#v", entry)
-	}
-}
-
-func TestCZTHandlerSearchCancellationAfterResponseReturnsNoEntries(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	client := &http.Client{Transport: cztRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		cancel()
-		return &http.Response{
-			StatusCode: http.StatusOK,
-			Header:     make(http.Header),
-			Body:       io.NopCloser(strings.NewReader(`[{"id":"77","name":"Movie","url":"https://czteam.me/details.php?id=77"}]`)),
-			Request:    req,
-		}, nil
-	})}
-	handler := cztHandler{
-		cfg:    cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	entries, notes, err := handler.Search(ctx, api.PreparedMetadata{
-		Release: api.ReleaseInfo{Title: "Movie"},
-	}, "CZT")
-	if err == nil {
-		t.Fatal("expected context cancellation error")
-	}
-	if len(entries) != 0 || len(notes) != 0 {
-		t.Fatalf("expected no entries or notes after cancellation, got entries=%v notes=%v", entries, notes)
-	}
-}
-
-func TestCZTHandlerSearchCancellationDuringRequestPropagatesContext(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	client := &http.Client{Transport: cztRoundTripFunc(func(_ *http.Request) (*http.Response, error) {
-		cancel()
-		return nil, context.Canceled
-	})}
-	handler := cztHandler{
-		cfg:    cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	entries, notes, err := handler.Search(ctx, api.PreparedMetadata{
-		Release: api.ReleaseInfo{Title: "Movie"},
-	}, "CZT")
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected context cancellation error, got %v", err)
-	}
-	if err != nil && strings.Contains(err.Error(), "CZT search failed") {
-		t.Fatalf("expected cancellation before CZT search wrapping, got %v", err)
-	}
-	if len(entries) != 0 || len(notes) != 0 {
-		t.Fatalf("expected no entries or notes after cancellation, got entries=%v notes=%v", entries, notes)
-	}
-}
-
-type cztRoundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f cztRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
-func TestCZTHandlerSearchRequestAssertionReportsOnTestGoroutine(t *testing.T) {
-	t.Parallel()
-
-	const title = "Movie & Show/2024"
-
-	tests := []struct {
-		name        string
-		target      func(baseURL string) string
-		wantErrPart string
-	}{
-		{
-			name: "wrong path",
-			target: func(baseURL string) string {
-				return baseURL + "/wrong"
-			},
-			wantErrPart: "unexpected path",
-		},
-		{
-			name: "wrong query",
-			target: func(baseURL string) string {
-				return baseURL + "/api.php?action=search-torrents&type=name&passkey=passkey123&query=Wrong&incldead=1"
-			},
-			wantErrPart: "query",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			handlerErr := make(chan error, 1)
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if err := assertCZTSearchRequest(r, title); err != nil {
-					select {
-					case handlerErr <- err:
-					default:
-					}
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				}
-				w.WriteHeader(http.StatusOK)
-			}))
-			defer server.Close()
-
-			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, tc.target(server.URL), nil)
-			if err != nil {
-				t.Fatalf("new request: %v", err)
-			}
-			resp, err := server.Client().Do(req)
-			if err != nil {
-				t.Fatalf("do request: %v", err)
-			}
-			defer resp.Body.Close()
-			if resp.StatusCode != http.StatusInternalServerError {
-				t.Fatalf("expected status %d, got %d", http.StatusInternalServerError, resp.StatusCode)
-			}
-
-			select {
-			case err := <-handlerErr:
-				if !strings.Contains(err.Error(), tc.wantErrPart) {
-					t.Fatalf("expected handler assertion error containing %q, got %v", tc.wantErrPart, err)
-				}
-			default:
-				t.Fatalf("expected handler assertion error")
-			}
-		})
-	}
-}
-
-func TestCZTHandlerSearchCredentialMatrix(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name      string
-		cfg       config.TrackerConfig
-		wantSkip  string
-		wantError string
-	}{
-		{
-			name:     "missing all credentials skips",
-			cfg:      config.TrackerConfig{},
-			wantSkip: "missing passkey",
-		},
-		{
-			name:     "api key only is ignored",
-			cfg:      config.TrackerConfig{APIKey: "bearer-token"},
-			wantSkip: "missing passkey",
-		},
-		{
-			name:     "padded api key only is ignored",
-			cfg:      config.TrackerConfig{APIKey: " bearer-token "},
-			wantSkip: "missing passkey",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			handler := cztHandler{
-				cfg:    cztTestConfig(tc.cfg),
-				http:   http.DefaultClient,
-				logger: api.NopLogger{},
-			}
-			_, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-				Release: api.ReleaseInfo{Title: "Movie"},
-			}, "CZT")
-			if tc.wantError != "" {
-				if err == nil || !strings.Contains(err.Error(), tc.wantError) {
-					t.Fatalf("expected error containing %q, got %v", tc.wantError, err)
-				}
-				if len(notes) != 0 {
-					t.Fatalf("expected no skip notes on failure, got %v", notes)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			code, displayNotes := splitSkipCodeNotes(notes)
-			if code != "" {
-				t.Fatalf("expected no skip code, got %q from notes %v", code, notes)
-			}
-			if len(displayNotes) != 1 || !strings.Contains(displayNotes[0], tc.wantSkip) {
-				t.Fatalf("expected display skip note containing %q, got %v", tc.wantSkip, displayNotes)
-			}
-		})
-	}
-}
-
-func TestCZTHandlerSearchRemoteFailuresReturnErrors(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name       string
-		statusCode int
-		body       string
-		wantError  string
-	}{
-		{name: "non 2xx", statusCode: http.StatusUnauthorized, body: `{"error":"bad auth"}`, wantError: "HTTP status 401"},
-		{name: "auth object", statusCode: http.StatusOK, body: `{"error":"bad auth"}`, wantError: "unexpected response shape"},
-		{name: "null", statusCode: http.StatusOK, body: `null`, wantError: "empty response"},
-		{name: "scalar", statusCode: http.StatusOK, body: `"ok"`, wantError: "unexpected response shape"},
-		{name: "malformed", statusCode: http.StatusOK, body: `{`, wantError: "decode JSON GET response"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(tc.statusCode)
-				_, _ = io.WriteString(w, tc.body)
-			}))
-			defer server.Close()
-
-			handler := cztHandler{
-				cfg:     cztTestConfig(config.TrackerConfig{URL: "https://unused.example", Passkey: "passkey123"}),
-				http:    server.Client(),
-				logger:  api.NopLogger{},
-				baseURL: server.URL,
-			}
-			_, notes, err := handler.Search(context.Background(), api.PreparedMetadata{
-				Release: api.ReleaseInfo{Title: "Movie"},
-			}, "CZT")
-			if err == nil || !strings.Contains(err.Error(), tc.wantError) {
-				t.Fatalf("expected error containing %q, got %v", tc.wantError, err)
-			}
-			if len(notes) != 0 {
-				t.Fatalf("expected no skip notes on failure, got %v", notes)
-			}
-			if strings.Contains(err.Error(), "passkey123") {
-				t.Fatalf("error leaked passkey: %v", err)
-			}
-		})
-	}
-}
-
-func TestCZTHandlerSearchMissingTitleSkipsWithoutHTTP(t *testing.T) {
-	t.Parallel()
-
-	var called atomic.Bool
-	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
-		called.Store(true)
-	}))
-	defer server.Close()
-
-	handler := cztHandler{
-		cfg:     cztTestConfig(config.TrackerConfig{URL: "https://unused.example", Passkey: "passkey123"}),
-		http:    server.Client(),
-		logger:  api.NopLogger{},
-		baseURL: server.URL,
-	}
-	_, notes, err := handler.Search(context.Background(), api.PreparedMetadata{}, "CZT")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 1 || !strings.Contains(notes[0], "missing title") {
-		t.Fatalf("expected missing title skip, got %v", notes)
-	}
-	if called.Load() {
-		t.Fatalf("expected no HTTP call")
-	}
-}
-
-func TestCZTServiceIgnoresAPIKeyOnlyConfig(t *testing.T) {
-	t.Parallel()
-
-	svc := NewService(cztTestConfig(config.TrackerConfig{APIKey: "bearer-token"}), api.NopLogger{})
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{
-		SourcePath: "source.mkv",
-		Release:    api.ReleaseInfo{Title: "Movie"},
-	}, []string{"CZT"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if result.Status != "skipped" || !result.Skipped {
-		t.Fatalf("expected skipped result, got %#v", result)
-	}
-	if result.Error != "" {
-		t.Fatalf("expected no error, got %q", result.Error)
-	}
-	if result.SkipCode != "" {
-		t.Fatalf("expected no structured skip code, got %q", result.SkipCode)
-	}
-	if len(result.SkipRules) != 0 {
-		t.Fatalf("expected missing-passkey skip not to use rule grouping keys, got %#v", result.SkipRules)
-	}
-	if !strings.Contains(result.SkipReason, "missing passkey") {
-		t.Fatalf("expected passkey skip, got %q", result.SkipReason)
-	}
-	if strings.Contains(strings.Join(result.Notes, " "), "skip-code:") {
-		t.Fatalf("structured skip marker leaked into display notes: %#v", result.Notes)
-	}
-	if strings.Contains(result.SkipReason, "bearer-token") || strings.Contains(strings.Join(result.Notes, " "), "bearer-token") {
-		t.Fatalf("skip result leaked API key: %#v", result)
-	}
-}
-
-func cztTestConfig(tracker config.TrackerConfig) config.Config {
-	return config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-		"CZT": tracker,
-	}}}
-}
-
-func assertCZTSearchRequest(r *http.Request, title string) error {
-	if r.URL.Path != "/api.php" {
-		return fmt.Errorf("unexpected path: %s", r.URL.Path)
-	}
-	if got := r.URL.Query().Get("action"); got != "search-torrents" {
-		return fmt.Errorf("action query: got %q", got)
-	}
-	if got := r.URL.Query().Get("type"); got != "name" {
-		return fmt.Errorf("type query: got %q", got)
-	}
-	if got := r.URL.Query().Get("passkey"); got != "passkey123" {
-		return errors.New("passkey query mismatch")
-	}
-	if got := r.URL.Query().Get("query"); got != title {
-		return fmt.Errorf("query: got %q", got)
-	}
-	if got := r.URL.Query().Get("incldead"); got != "1" {
-		return fmt.Errorf("incldead query: got %q", got)
-	}
-	if got := r.Header.Get("Authorization"); got != "" {
-		return errors.New("unexpected authorization header")
-	}
-	return nil
-}
diff --git a/internal/dupechecking/dc.go b/internal/dupechecking/dc.go
deleted file mode 100644
index 938fa92f..00000000
--- a/internal/dupechecking/dc.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type dcHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h dcHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "DC")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	imdb := meta.ExternalIDs.IMDBID
-	if imdb == 0 {
-		return nil, []string{noteSkip("missing imdb id for DC dupe search")}, nil
-	}
-	params := url.Values{}
-	params.Set("searchText", "tt"+strconv.Itoa(imdb))
-	headers := map[string]string{"X-API-KEY": apiKey}
-	status, payload, err := doJSONGetAny(ctx, h.http, "https://digitalcore.club/api/v1/torrents", params, headers)
-	if err != nil || status < 200 || status >= 300 {
-		return nil, []string{noteSkip("DC search failed")}, nil
-	}
-	rawList, ok := anyToSlice(payload)
-	if !ok {
-		return nil, nil, nil
-	}
-	entries := make([]api.DupeEntry, 0, len(rawList))
-	for _, raw := range rawList {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		id := stringFromAny(item["id"])
-		entry := api.DupeEntry{Name: stringFromAny(item["name"]), ID: id, Link: "https://digitalcore.club/torrent/" + id + "/"}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/factory.go b/internal/dupechecking/factory.go
deleted file mode 100644
index f3da3f63..00000000
--- a/internal/dupechecking/factory.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/internal/trackers"
-)
-
-func buildHandlers(deps handlerDeps) map[string]searchHandler {
-	handlers := map[string]searchHandler{}
-
-	unit := unit3dHandler{cfg: deps.cfg, tracker: deps.tracker}
-	for _, tracker := range trackers.Unit3DTrackers() {
-		handlers[tracker] = unit
-	}
-
-	// Functional non-Unit3D handlers (first pass parity)
-	handlers["ANT"] = antHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["BHD"] = bhdHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["BTN"] = btnHandler{cfg: deps.cfg, http: deps.http}
-	handlers["HDB"] = hdbHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["PTP"] = ptpHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["BHDTV"] = bhdtvHandler{}
-	handlers["DC"] = dcHandler{cfg: deps.cfg, http: deps.http}
-	handlers["GPW"] = gpwHandler{cfg: deps.cfg, http: deps.http}
-	handlers["MTV"] = mtvHandler{cfg: deps.cfg, http: deps.http}
-	handlers["NBL"] = nblHandler{cfg: deps.cfg, http: deps.http}
-	handlers["AR"] = arHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["RTF"] = rtfHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["SPD"] = spdHandler{cfg: deps.cfg, http: deps.http}
-	handlers["TL"] = tlHandler{cfg: deps.cfg, http: deps.http}
-	handlers["TVC"] = tvcHandler{}
-
-	// Explicit per-tracker stubs
-	handlers["ASC"] = ascHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["AZ"] = azHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["BJS"] = bjsHandler{cfg: deps.cfg, http: deps.http}
-	handlers["BT"] = btHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["CZ"] = czHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["CZT"] = cztHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["FF"] = ffHandler{cfg: deps.cfg, http: deps.http}
-	handlers["FL"] = flHandler{cfg: deps.cfg, http: deps.http}
-	handlers["HDS"] = hdsHandler{cfg: deps.cfg, http: deps.http}
-	handlers["HDT"] = hdtHandler{cfg: deps.cfg, http: deps.http}
-	handlers["IS"] = isHandler{cfg: deps.cfg, http: deps.http}
-	handlers["PHD"] = phdHandler{cfg: deps.cfg, http: deps.http, logger: deps.logger}
-	handlers["PTS"] = ptsHandler{cfg: deps.cfg, http: deps.http}
-	handlers["THR"] = thrHandler{cfg: deps.cfg, http: deps.http}
-
-	// Config-aware Unit3D fallback for unknown/custom Unit3D trackers.
-	for name := range deps.cfg.Trackers.Trackers {
-		normalized := normalizeTracker(name)
-		if normalized == "" {
-			continue
-		}
-		if _, exists := handlers[normalized]; exists {
-			continue
-		}
-		if trackerdata.IsUnit3DTrackerWithConfig(deps.cfg, normalized) {
-			handlers[normalized] = unit
-		}
-	}
-
-	return handlers
-}
diff --git a/internal/dupechecking/factory_test.go b/internal/dupechecking/factory_test.go
deleted file mode 100644
index 6ddc58ce..00000000
--- a/internal/dupechecking/factory_test.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-)
-
-func TestBuildHandlersCoversKnownTrackers(t *testing.T) {
-	t.Parallel()
-	handlers := buildHandlers(handlerDeps{cfg: config.Config{}})
-
-	for _, tracker := range trackers.KnownTrackers() {
-		if tracker == "MANUAL" {
-			continue
-		}
-		if _, ok := handlers[tracker]; !ok {
-			t.Fatalf("expected handler for %s", tracker)
-		}
-	}
-}
diff --git a/internal/dupechecking/ff.go b/internal/dupechecking/ff.go
deleted file mode 100644
index 5c36bba7..00000000
--- a/internal/dupechecking/ff.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type ffHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h ffHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	if !meta.Anime && imdbForLookup(meta) == "" {
-		return nil, []string{noteSkip("missing IMDb ID for FF dupe search")}, nil
-	}
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "FF", trackerHost(trackerBaseURL(h.cfg, "FF", "https://www.funfile.org"), "funfile.org"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid FF cookies")}, nil
-	}
-	query := imdbForLookup(meta)
-	if meta.Anime {
-		query = metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)
-	}
-	resp, root, err := doHTMLGet(ctx, h.http, trackerBaseURL(h.cfg, "FF", "https://www.funfile.org")+"/torrents.php", url.Values{"searchstr": {query}}, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("FF search failed")}, nil
-	}
-	groupLinks := findNodes(root, func(node *xhtml.Node) bool {
-		href := attrValueHTML(node, "href")
-		return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(href, "torrents.php?id=") && !strings.Contains(href, "torrentid")
-	})
-	groupRe := regexp.MustCompile(`torrents\.php\?id=(\d+)`)
-	seen := map[string]struct{}{}
-	entries := make([]api.DupeEntry, 0)
-	baseURL := trackerBaseURL(h.cfg, "FF", "https://www.funfile.org")
-	for _, linkNode := range groupLinks {
-		groupLink := absoluteURL(baseURL, attrValueHTML(linkNode, "href"))
-		if groupLink == "" {
-			continue
-		}
-		if _, ok := seen[groupLink]; ok {
-			continue
-		}
-		seen[groupLink] = struct{}{}
-		groupResp, groupRoot, err := doHTMLGet(ctx, h.http, groupLink, nil, cookies)
-		if err != nil || !groupResp.ok() {
-			continue
-		}
-		torrents := findNodes(groupRoot, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "tr" && strings.HasPrefix(attrValueHTML(node, "id"), "torrent")
-		})
-		for _, row := range torrents {
-			link := firstNode(row, func(node *xhtml.Node) bool {
-				return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "onclick"), "gtoggle")
-			})
-			if link == nil {
-				continue
-			}
-			entry := api.DupeEntry{
-				Name: strings.TrimSpace(nodeTextHTML(link)),
-				Link: groupLink,
-			}
-			if match := groupRe.FindStringSubmatch(groupLink); len(match) == 2 {
-				entry.ID = match[1]
-			}
-			if entry.Name != "" {
-				entries = append(entries, entry)
-			}
-		}
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/fl.go b/internal/dupechecking/fl.go
deleted file mode 100644
index 57ac42b1..00000000
--- a/internal/dupechecking/fl.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type flHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h flHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "FL", ".filelist.io")
-	if err != nil {
-		return nil, []string{noteSkip("missing valid FL cookies")}, nil
-	}
-	params := url.Values{}
-	params.Set("cat", strconv.Itoa(resolveFLCategoryID(meta)))
-	if imdb := imdbForLookup(meta); imdb != "" {
-		params.Set("search", imdb)
-		params.Set("searchin", "3")
-	} else {
-		query := metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)
-		if query == "" {
-			return nil, []string{noteSkip("missing FL search query")}, nil
-		}
-		params.Set("search", query)
-		params.Set("searchin", "0")
-	}
-	resp, root, err := doHTMLGet(ctx, h.http, trackerBaseURL(h.cfg, "FL", "https://filelist.io")+"/browse.php", params, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("FL search failed")}, nil
-	}
-	links := findNodes(root, func(node *xhtml.Node) bool {
-		href := attrValueHTML(node, "href")
-		return node.Type == xhtml.ElementNode && node.Data == "a" && strings.HasPrefix(href, "details.php?id=") && !strings.Contains(href, "&")
-	})
-	entries := make([]api.DupeEntry, 0, len(links))
-	baseURL := trackerBaseURL(h.cfg, "FL", "https://filelist.io")
-	for _, link := range links {
-		entry := api.DupeEntry{
-			Name: strings.TrimSpace(metautil.FirstNonEmptyTrimmed(attrValueHTML(link, "title"), nodeTextHTML(link))),
-			Link: absoluteURL(baseURL, attrValueHTML(link, "href")),
-		}
-		if entry.Name == "" {
-			continue
-		}
-		if parsed, err := url.Parse(entry.Link); err == nil {
-			entry.ID = strings.TrimSpace(parsed.Query().Get("id"))
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/gpw.go b/internal/dupechecking/gpw.go
deleted file mode 100644
index aae14652..00000000
--- a/internal/dupechecking/gpw.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type gpwHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h gpwHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "GPW")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	if meta.ExternalIDs.IMDBID == 0 {
-		return nil, []string{noteSkip("missing imdb id for GPW dupe search")}, nil
-	}
-	endpoint := "https://greatposterwall.com/api.php"
-	params := url.Values{}
-	params.Set("api_key", apiKey)
-	params.Set("action", "torrent")
-	params.Set("imdbID", "tt"+strconv.Itoa(meta.ExternalIDs.IMDBID))
-	status, payload, err := doJSONGet(ctx, h.http, endpoint, params, nil)
-	if err != nil || status < 200 || status >= 300 {
-		return nil, []string{noteSkip("GPW search failed")}, nil
-	}
-	if intFromAny(payload["status"]) != 200 {
-		return nil, nil, nil
-	}
-	resp, _ := payload["response"].([]any)
-	entries := make([]api.DupeEntry, 0, len(resp))
-	for _, raw := range resp {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		name := strings.TrimSpace(strings.Join([]string{
-			stringFromAny(item["Name"]),
-			stringFromAny(item["Year"]),
-			stringFromAny(item["Resolution"]),
-			stringFromAny(item["Source"]),
-			stringFromAny(item["Processing"]),
-			stringFromAny(item["RemasterTitle"]),
-			stringFromAny(item["Codec"]),
-		}, " "))
-		entries = append(entries, api.DupeEntry{Name: strings.Join(strings.Fields(name), " ")})
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/hdb.go b/internal/dupechecking/hdb.go
deleted file mode 100644
index 40e01462..00000000
--- a/internal/dupechecking/hdb.go
+++ /dev/null
@@ -1,318 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type hdbHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h hdbHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	logger := h.logger
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	if h.http == nil {
-		return nil, []string{noteSkip("HDB handler misconfigured: no HTTP client")}, nil
-	}
-	cfg, ok := trackerCfg(h.cfg, "HDB")
-	if !ok || strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Passkey) == "" {
-		return nil, []string{noteSkip("missing username/passkey for tracker")}, nil
-	}
-	payload := map[string]any{"username": strings.TrimSpace(cfg.Username), "passkey": strings.TrimSpace(cfg.Passkey)}
-	categoryID := hdbCategoryID(meta)
-	codecID := hdbCodecID(meta)
-	mediumID := hdbMediumID(meta)
-	searchMethod := "id"
-	payload["category"] = categoryID
-	payload["codec"] = codecID
-	payload["medium"] = mediumID
-	if meta.ExternalIDs.IMDBID != 0 {
-		payload["imdb"] = map[string]any{"id": formatHDBIMDbID(meta.ExternalIDs.IMDBID)}
-	} else if isHDBTVCategory(meta) && meta.ExternalIDs.TVDBID != 0 {
-		payload["tvdb"] = map[string]any{"id": meta.ExternalIDs.TVDBID}
-	}
-	if _, hasIMDB := payload["imdb"]; !hasIMDB {
-		if _, hasTVDB := payload["tvdb"]; !hasTVDB {
-			query := strings.TrimSpace(meta.ReleaseName)
-			if query == "" {
-				query = strings.TrimSpace(meta.Filename)
-			}
-			if query == "" {
-				query = strings.TrimSpace(meta.Release.Title)
-			}
-			if query == "" {
-				logger.Warnf("dupechecking: HDB missing imdb/tvdb IDs and search text for %s", meta.SourcePath)
-				return nil, []string{noteSkip("missing imdb/tvdb id for HDB dupe search")}, nil
-			}
-			payload["search"] = query
-			searchMethod = "text_fallback"
-			logger.Debugf("dupechecking: HDB falling back to text search for %s", meta.SourcePath)
-		}
-	}
-	logPayload := redaction.RedactPrivateInfo(payload, nil)
-	logPayloadJSON, err := json.Marshal(logPayload)
-	if err != nil {
-		logger.Debugf("dupechecking: HDB search payload_marshal_failed=%v source=%s", err, meta.SourcePath)
-	} else {
-		logger.Debugf("dupechecking: HDB search payload=%s source=%s", string(logPayloadJSON), meta.SourcePath)
-	}
-	status, body, err := doJSONPost(ctx, h.http, "https://hdbits.org/api/torrents", payload, nil)
-	if err != nil {
-		logger.Warnf("dupechecking: HDB request failed for %s: %v", meta.SourcePath, err)
-		return nil, []string{noteSkip("HDB request failed")}, nil
-	}
-	if status < 200 || status >= 300 || len(body) == 0 {
-		logger.Warnf("dupechecking: HDB search failed for %s with status=%d body_len=%d", meta.SourcePath, status, len(body))
-		return nil, []string{noteSkip("HDB search failed")}, nil
-	}
-	if intFromAny(body["status"]) != 0 {
-		logger.Warnf("dupechecking: HDB API rejected search for %s with status=%v", meta.SourcePath, body["status"])
-		return nil, []string{noteSkip("HDB api rejected search")}, nil
-	}
-	items, _ := body["data"].([]any)
-	entries := make([]api.DupeEntry, 0, len(items))
-	for _, raw := range items {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		id := stringFromAny(item["id"])
-		name := stringFromAny(item["name"])
-		filename := stringFromAny(item["filename"])
-		entry := api.DupeEntry{
-			Name:      name,
-			ID:        id,
-			Link:      "https://hdbits.org/details.php?id=" + id,
-			Download:  "https://hdbits.org/download.php/" + url.QueryEscape(filename) + "?id=" + id + "&passkey=" + strings.TrimSpace(cfg.Passkey),
-			FileCount: int(intFromAny(item["numfiles"])),
-		}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entries = append(entries, entry)
-	}
-	logger.Debugf("dupechecking: HDB returned %d entries for %s method=%s", len(entries), meta.SourcePath, searchMethod)
-	return entries, nil, nil
-}
-
-// isHDBTVCategory reports whether HDB dupe searches may use TVDB-specific filters.
-// Explicit movie categories suppress TVDB even when MediaInfo or overrides classify the release as TV.
-func isHDBTVCategory(meta api.PreparedMetadata) bool {
-	if isHDBMovieCategory(meta) {
-		return false
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV") {
-		return true
-	}
-	if meta.ReleaseNameOverrides.Category != nil {
-		return strings.EqualFold(strings.TrimSpace(*meta.ReleaseNameOverrides.Category), "TV")
-	}
-	return false
-}
-
-func isHDBMovieCategory(meta api.PreparedMetadata) bool {
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "MOVIE") {
-		return true
-	}
-	if meta.ReleaseNameOverrides.Category != nil {
-		return strings.EqualFold(strings.TrimSpace(*meta.ReleaseNameOverrides.Category), "MOVIE")
-	}
-	return false
-}
-
-func formatHDBIMDbID(imdbID int) string {
-	return fmt.Sprintf("%07d", imdbID)
-}
-
-func hdbCategoryID(meta api.PreparedMetadata) int {
-	category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	if category == "" && meta.ReleaseNameOverrides.Category != nil {
-		category = strings.ToUpper(strings.TrimSpace(*meta.ReleaseNameOverrides.Category))
-	}
-
-	categoryID := 0
-	switch category {
-	case "MOVIE":
-		categoryID = 1
-	case "TV":
-		categoryID = 2
-	}
-
-	genres := ""
-	keywords := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		genres = strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres))
-		keywords = strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords))
-	}
-	if strings.Contains(genres, "documentary") || strings.Contains(keywords, "documentary") {
-		categoryID = 3
-	}
-
-	if meta.ExternalMetadata.IMDB != nil {
-		imdbType := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Type))
-		imdbGenres := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres))
-		if strings.Contains(imdbType, "concert") || (strings.Contains(imdbType, "video") && strings.Contains(imdbGenres, "music")) {
-			categoryID = 4
-		}
-	}
-	return categoryID
-}
-
-func hdbCodecID(meta api.PreparedMetadata) int {
-	codec := strings.ToUpper(strings.TrimSpace(meta.VideoCodec))
-	if codec == "" {
-		codec = strings.ToUpper(strings.TrimSpace(meta.VideoEncode))
-	}
-	switch codec {
-	case "AVC", "H.264":
-		return 1
-	case "MPEG-2":
-		return 2
-	case "VC-1":
-		return 3
-	case "XVID":
-		return 4
-	case "HEVC", "H.265":
-		return 5
-	case "VP9":
-		return 6
-	default:
-		return 0
-	}
-}
-
-func hdbMediumID(meta api.PreparedMetadata) int {
-	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
-	contentType := resolveHDBType(meta)
-	if discType == "BDMV" || discType == "HD DVD" {
-		return 1
-	}
-	if contentType == "HDTV" {
-		if meta.HasEncodeSettings {
-			return 3
-		}
-		return 4
-	}
-	switch contentType {
-	case "ENCODE", "WEBRIP":
-		return 3
-	case "REMUX":
-		return 5
-	case "WEBDL":
-		return 6
-	default:
-		return 0
-	}
-}
-
-func resolveHDBType(meta api.PreparedMetadata) string {
-	typeValue := normalizeHDBType(meta.Type)
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if meta.ReleaseNameOverrides.Type != nil {
-			typeValue = normalizeHDBType(*meta.ReleaseNameOverrides.Type)
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = normalizeHDBType(meta.Release.Type)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.DiscType) != "" {
-			typeValue = "DISC"
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = inferHDBTypeFromSource(meta.Source)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = inferHDBTypeFromPath(meta.SourcePath)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.VideoEncode) != "" {
-			typeValue = "ENCODE"
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.VideoCodec) != "" || strings.TrimSpace(meta.Release.Resolution) != "" || strings.TrimSpace(meta.Release.Ext) != "" {
-			typeValue = "ENCODE"
-		}
-	}
-	return typeValue
-}
-
-func normalizeHDBType(value string) string {
-	upper := strings.ToUpper(strings.TrimSpace(value))
-	if upper == "" {
-		return ""
-	}
-	upper = strings.ReplaceAll(upper, "-", "")
-	upper = strings.ReplaceAll(upper, " ", "")
-	upper = strings.ReplaceAll(upper, "_", "")
-	switch upper {
-	case "WEBDL":
-		return "WEBDL"
-	case "WEBRIP":
-		return "WEBRIP"
-	}
-	return upper
-}
-
-func isHDBCategoryType(value string) bool {
-	upper := strings.ToUpper(strings.TrimSpace(value))
-	return upper == "MOVIE" || upper == "TV"
-}
-
-func inferHDBTypeFromSource(source string) string {
-	upper := normalizeHDBType(source)
-	switch {
-	case strings.Contains(upper, "WEBDL"):
-		return "WEBDL"
-	case strings.Contains(upper, "WEBRIP"):
-		return "WEBRIP"
-	case strings.Contains(upper, "HDTV"):
-		return "HDTV"
-	}
-	return ""
-}
-
-func inferHDBTypeFromPath(path string) string {
-	base := strings.ToUpper(strings.TrimSpace(path))
-	compact := strings.NewReplacer(".", "", "-", "", "_", "", " ", "").Replace(base)
-	switch {
-	case strings.Contains(compact, "REMUX"):
-		return "REMUX"
-	case strings.Contains(compact, "WEBDL"):
-		return "WEBDL"
-	case strings.Contains(compact, "WEBRIP"):
-		return "WEBRIP"
-	case strings.Contains(compact, "HDTV"):
-		return "HDTV"
-	case strings.Contains(compact, "DVDRIP"):
-		return "DVDRIP"
-	}
-	return ""
-}
diff --git a/internal/dupechecking/hdb_test.go b/internal/dupechecking/hdb_test.go
deleted file mode 100644
index ecd5730a..00000000
--- a/internal/dupechecking/hdb_test.go
+++ /dev/null
@@ -1,508 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestHDBHandlerSearchBuildsPayloadAndParsesResults(t *testing.T) {
-	t.Parallel()
-	tmpDir := t.TempDir()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			if req.Method != http.MethodPost {
-				t.Fatalf("expected POST request, got %s", req.Method)
-			}
-			if req.URL.String() != "https://hdbits.org/api/torrents" {
-				t.Fatalf("unexpected endpoint %q", req.URL.String())
-			}
-
-			var payload map[string]any
-			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
-				t.Fatalf("decode request payload: %v", err)
-			}
-			if got := stringFromAny(payload["username"]); got != "user" {
-				t.Fatalf("unexpected username %q", got)
-			}
-			if got := stringFromAny(payload["passkey"]); got != "pk" {
-				t.Fatalf("unexpected passkey %q", got)
-			}
-			if got := intFromAny(payload["category"]); got != 1 {
-				t.Fatalf("unexpected category %d", got)
-			}
-			if got := intFromAny(payload["codec"]); got != 5 {
-				t.Fatalf("unexpected codec %d", got)
-			}
-			if got := intFromAny(payload["medium"]); got != 6 {
-				t.Fatalf("unexpected medium %d", got)
-			}
-			imdb, ok := payload["imdb"].(map[string]any)
-			if !ok || stringFromAny(imdb["id"]) != "1234567" {
-				t.Fatalf("unexpected imdb payload %#v", payload["imdb"])
-			}
-			if _, hasTVDB := payload["tvdb"]; hasTVDB {
-				t.Fatalf("did not expect tvdb payload when imdb is present")
-			}
-
-			body := `{"status":0,"data":[{"id":42,"name":"Movie.Title.2024.1080p.WEB-DL.DDP5.1.H.265-GRP","filename":"Movie Title (2024).torrent","size":1234567890,"numfiles":3}]}`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := hdbHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{
-				DBPath: filepath.Join(tmpDir, "ua.db"),
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {
-						Username: "user",
-						Passkey:  "pk",
-					},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath: "C:/media/movie",
-		ExternalIDs: api.ExternalIDs{
-			IMDBID:   1234567,
-			TVDBID:   765432,
-			Category: "MOVIE",
-		},
-		VideoCodec: "HEVC",
-		Type:       "WEBDL",
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "HDB")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one entry, got %d", len(entries))
-	}
-
-	entry := entries[0]
-	if entry.Name != "Movie.Title.2024.1080p.WEB-DL.DDP5.1.H.265-GRP" {
-		t.Fatalf("expected entry name from 'name', got %q", entry.Name)
-	}
-	if entry.ID != "42" {
-		t.Fatalf("unexpected id %q", entry.ID)
-	}
-	if entry.Link != "https://hdbits.org/details.php?id=42" {
-		t.Fatalf("unexpected link %q", entry.Link)
-	}
-	if entry.Download != "https://hdbits.org/download.php/Movie+Title+%282024%29.torrent?id=42&passkey=pk" {
-		t.Fatalf("unexpected download %q", entry.Download)
-	}
-	if !entry.SizeKnown || entry.SizeBytes != 1234567890 {
-		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
-	}
-	if entry.FileCount != 3 {
-		t.Fatalf("unexpected file count %d", entry.FileCount)
-	}
-}
-
-func TestHDBHandlerSearchFallsBackToTextSearchWhenIDsMissing(t *testing.T) {
-	t.Parallel()
-	tmpDir := t.TempDir()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			var payload map[string]any
-			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
-				t.Fatalf("decode request payload: %v", err)
-			}
-			if _, hasIMDB := payload["imdb"]; hasIMDB {
-				t.Fatalf("did not expect imdb in payload")
-			}
-			if _, hasTVDB := payload["tvdb"]; hasTVDB {
-				t.Fatalf("did not expect tvdb in payload")
-			}
-			if got := stringFromAny(payload["search"]); got != "Some.Release.Name.2024.1080p.WEB-DL" {
-				t.Fatalf("unexpected fallback search %q", got)
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := hdbHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{
-				DBPath: filepath.Join(tmpDir, "ua.db"),
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {
-						Username: "user",
-						Passkey:  "pk",
-					},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath:  "C:/media/no-ids",
-		ReleaseName: "Some.Release.Name.2024.1080p.WEB-DL",
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "HDB")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestHDBHandlerSearchUsesTVDBWhenIMDbMissing(t *testing.T) {
-	t.Parallel()
-	tmpDir := t.TempDir()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			var payload map[string]any
-			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
-				t.Fatalf("decode request payload: %v", err)
-			}
-
-			if _, hasIMDB := payload["imdb"]; hasIMDB {
-				t.Fatalf("did not expect imdb in payload")
-			}
-			tvdb, ok := payload["tvdb"].(map[string]any)
-			if !ok || intFromAny(tvdb["id"]) != 765432 {
-				t.Fatalf("unexpected tvdb payload %#v", payload["tvdb"])
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := hdbHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{
-				DBPath: filepath.Join(tmpDir, "ua.db"),
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {
-						Username: "user",
-						Passkey:  "pk",
-					},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath: "C:/media/show",
-		ExternalIDs: api.ExternalIDs{
-			TVDBID:   765432,
-			Category: "TV",
-		},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "HDB")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestHDBHandlerSearchSkipsTVDBForMovie(t *testing.T) {
-	t.Parallel()
-	tmpDir := t.TempDir()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			var payload map[string]any
-			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
-				t.Fatalf("decode request payload: %v", err)
-			}
-			if _, hasTVDB := payload["tvdb"]; hasTVDB {
-				t.Fatalf("did not expect tvdb in movie payload")
-			}
-			if got := stringFromAny(payload["search"]); got != "Movie.Release.2024.1080p.WEB-DL" {
-				t.Fatalf("unexpected fallback search %q", got)
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := hdbHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{
-				DBPath: filepath.Join(tmpDir, "ua.db"),
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {
-						Username: "user",
-						Passkey:  "pk",
-					},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath:        "C:/media/movie",
-		ReleaseName:       "Movie.Release.2024.1080p.WEB-DL",
-		MediaInfoCategory: "TV",
-		ExternalIDs: api.ExternalIDs{
-			TVDBID:   765432,
-			Category: "MOVIE",
-		},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "HDB")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestFormatHDBIMDbID(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		id   int
-		want string
-	}{
-		{id: 1, want: "0000001"},
-		{id: 1335975, want: "1335975"},
-		{id: 12345678, want: "12345678"},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.want, func(t *testing.T) {
-			t.Parallel()
-			if got := formatHDBIMDbID(tc.id); got != tc.want {
-				t.Fatalf("formatHDBIMDbID(%d) = %q, want %q", tc.id, got, tc.want)
-			}
-		})
-	}
-}
-
-func TestHDBHandlerSearchIncludesZeroValuedFilters(t *testing.T) {
-	t.Parallel()
-	tmpDir := t.TempDir()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			var payload map[string]any
-			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
-				t.Fatalf("decode request payload: %v", err)
-			}
-
-			category, hasCategory := payload["category"]
-			if !hasCategory {
-				t.Fatalf("expected category key to be present")
-			}
-			if got := intFromAny(category); got != 0 {
-				t.Fatalf("expected category 0, got %d", got)
-			}
-
-			codec, hasCodec := payload["codec"]
-			if !hasCodec {
-				t.Fatalf("expected codec key to be present")
-			}
-			if got := intFromAny(codec); got != 0 {
-				t.Fatalf("expected codec 0, got %d", got)
-			}
-
-			medium, hasMedium := payload["medium"]
-			if !hasMedium {
-				t.Fatalf("expected medium key to be present")
-			}
-			if got := intFromAny(medium); got != 0 {
-				t.Fatalf("expected medium 0, got %d", got)
-			}
-
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := hdbHandler{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{
-				DBPath: filepath.Join(tmpDir, "ua.db"),
-			},
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"HDB": {
-						Username: "user",
-						Passkey:  "pk",
-					},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath:  "C:/media/zero-filters",
-		ReleaseName: "Unknown.Release.2024",
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "HDB")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestHDBMediumIDTypePrecedence(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name string
-		meta api.PreparedMetadata
-		want int
-	}{
-		{
-			name: "metadata type takes precedence",
-			meta: api.PreparedMetadata{
-				Type: "WEBDL",
-				ReleaseNameOverrides: api.ReleaseNameOverrides{
-					Type: new("WEBRIP"),
-				},
-				Release: api.ReleaseInfo{Type: "REMUX"},
-			},
-			want: 6,
-		},
-		{
-			name: "falls back to override type",
-			meta: api.PreparedMetadata{
-				ReleaseNameOverrides: api.ReleaseNameOverrides{
-					Type: new("WEBRIP"),
-				},
-				Release: api.ReleaseInfo{Type: "REMUX"},
-			},
-			want: 3,
-		},
-		{
-			name: "falls back to release type",
-			meta: api.PreparedMetadata{
-				Release: api.ReleaseInfo{Type: "REMUX"},
-			},
-			want: 5,
-		},
-		{
-			name: "disc type takes precedence",
-			meta: api.PreparedMetadata{
-				DiscType: "BDMV",
-				Type:     "WEBDL",
-				ReleaseNameOverrides: api.ReleaseNameOverrides{
-					Type: new("WEBRIP"),
-				},
-				Release: api.ReleaseInfo{Type: "REMUX"},
-			},
-			want: 1,
-		},
-		{
-			name: "hdtv with encode settings maps to encode medium",
-			meta: api.PreparedMetadata{
-				Type:              "HDTV",
-				HasEncodeSettings: true,
-			},
-			want: 3,
-		},
-		{
-			name: "category type infers encode medium from metadata",
-			meta: api.PreparedMetadata{
-				Type:       "movie",
-				Source:     "BluRay",
-				VideoCodec: "AVC",
-				Release: api.ReleaseInfo{
-					Resolution: "1080p",
-				},
-			},
-			want: 3,
-		},
-		{
-			name: "category type uses source hint for webdl medium",
-			meta: api.PreparedMetadata{
-				Type:   "movie",
-				Source: "Web-DL",
-			},
-			want: 6,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			if got := hdbMediumID(tc.meta); got != tc.want {
-				t.Fatalf("hdbMediumID() = %d, want %d", got, tc.want)
-			}
-		})
-	}
-}
diff --git a/internal/dupechecking/hds.go b/internal/dupechecking/hds.go
deleted file mode 100644
index ef3b7163..00000000
--- a/internal/dupechecking/hds.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type hdsHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h hdsHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if resolution != "2160p" && resolution != "1080p" && resolution != "1080i" && resolution != "720p" {
-		return nil, []string{noteSkip("resolution below HDS dupe-check minimum")}, nil
-	}
-	imdb := imdbForLookup(meta)
-	if imdb == "" {
-		return nil, []string{noteSkip("missing IMDb ID for HDS dupe search")}, nil
-	}
-	baseURL := trackerBaseURL(h.cfg, "HDS", "https://hd-space.org")
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "HDS", trackerHost(baseURL, "hd-space.org"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid HDS cookies")}, nil
-	}
-	entries := make([]api.DupeEntry, 0)
-	pageRe := regexp.MustCompile(`pages=(\d+)`)
-	for page := 0; page <= 10; page++ {
-		params := url.Values{
-			"page":    {"torrents"},
-			"search":  {imdb},
-			"active":  {"0"},
-			"options": {"2"},
-			"pages":   {strconv.Itoa(page)},
-		}
-		resp, body, err := doTextGet(ctx, h.http, baseURL+"/index.php", params, nil, cookies)
-		if err != nil || !resp.ok() {
-			return nil, []string{noteSkip("HDS search failed")}, nil
-		}
-		parts := strings.SplitN(body, "Show/Hide Categories", 2)
-		if len(parts) < 2 {
-			break
-		}
-		root, err := xhtml.Parse(strings.NewReader(parts[1]))
-		if err != nil {
-			return nil, []string{noteSkip("HDS response parse failed")}, nil
-		}
-		rows := findNodes(root, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "tr"
-		})
-		beforeCount := len(entries)
-		for _, row := range rows {
-			nameNode := firstNode(row, func(node *xhtml.Node) bool {
-				return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "href"), "page=torrent-details")
-			})
-			if nameNode == nil {
-				continue
-			}
-			entry := api.DupeEntry{
-				Name: strings.TrimSpace(metautil.FirstNonEmptyTrimmed(nodeTextHTML(nameNode), attrValueHTML(nameNode, "title"))),
-				Link: absoluteURL(baseURL, attrValueHTML(nameNode, "href")),
-			}
-			cells := findNodes(row, func(node *xhtml.Node) bool {
-				return node.Type == xhtml.ElementNode && node.Data == "td" && hasClass(node, "lista")
-			})
-			for _, cell := range cells {
-				if sizeText := strings.TrimSpace(nodeTextHTML(cell)); sizePattern.MatchString(sizeText) {
-					addSize(&entry, sizeText)
-					break
-				}
-			}
-			if entry.Name != "" {
-				entries = append(entries, entry)
-			}
-		}
-		next := firstNode(root, func(node *xhtml.Node) bool {
-			if node.Type != xhtml.ElementNode || node.Data != "a" {
-				return false
-			}
-			href := attrValueHTML(node, "href")
-			text := strings.TrimSpace(nodeTextHTML(node))
-			return strings.Contains(href, "pages=") && (strings.EqualFold(text, "Next") || text == ">>" || pageRe.MatchString(href))
-		})
-		if next == nil || len(entries) == beforeCount {
-			break
-		}
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/hdt.go b/internal/dupechecking/hdt.go
deleted file mode 100644
index b606bfe0..00000000
--- a/internal/dupechecking/hdt.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type hdtHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h hdtHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if resolution != "2160p" && resolution != "1080p" && resolution != "1080i" && resolution != "720p" {
-		return nil, []string{noteSkip("resolution below HDT dupe-check minimum")}, nil
-	}
-	baseURL := trackerBaseURL(h.cfg, "HDT", "https://hd-torrents.me")
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "HDT", trackerHost(baseURL, "hd-torrents.me"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid HDT cookies")}, nil
-	}
-	query := imdbForLookup(meta)
-	params := url.Values{
-		"active":     {"0"},
-		"category[]": {strconv.Itoa(resolveHDTCategoryID(meta))},
-	}
-	if query != "" {
-		params.Set("search", query)
-		params.Set("options", "2")
-	} else {
-		params.Set("search", metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName))
-		params.Set("options", "3")
-	}
-	resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/torrents.php", params, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("HDT search failed")}, nil
-	}
-	rows := findNodes(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "tr"
-	})
-	entries := make([]api.DupeEntry, 0)
-	for _, row := range rows {
-		nameNode := firstNode(row, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "href"), "details.php?id=")
-		})
-		if nameNode == nil {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: strings.TrimSpace(nodeTextHTML(nameNode)),
-			Link: absoluteURL(baseURL, attrValueHTML(nameNode, "href")),
-		}
-		cells := findNodes(row, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "td" && hasClass(node, "mainblockcontent")
-		})
-		for _, cell := range cells {
-			if sizeText := strings.TrimSpace(nodeTextHTML(cell)); sizePattern.MatchString(sizeText) {
-				addSize(&entry, sizeText)
-				break
-			}
-		}
-		if entry.Name != "" {
-			entries = append(entries, entry)
-		}
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/http_helpers.go b/internal/dupechecking/http_helpers.go
deleted file mode 100644
index 1b4a7d15..00000000
--- a/internal/dupechecking/http_helpers.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-)
-
-func doJSONGet(ctx context.Context, client *http.Client, endpoint string, params url.Values, headers map[string]string) (int, map[string]any, error) {
-	status, payload, err := doJSONGetAny(ctx, client, endpoint, params, headers)
-	if err != nil {
-		return status, nil, err
-	}
-	if payload == nil {
-		return status, nil, nil
-	}
-	result, ok := payload.(map[string]any)
-	if !ok {
-		return status, nil, nil
-	}
-	return status, result, nil
-}
-
-func doJSONGetAny(ctx context.Context, client *http.Client, endpoint string, params url.Values, headers map[string]string) (int, any, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return 0, nil, fmt.Errorf("dupechecking: create JSON GET request: %w", err)
-	}
-	if len(params) > 0 {
-		req.URL.RawQuery = params.Encode()
-	}
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return 0, nil, fmt.Errorf("dupechecking: JSON GET request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return resp.StatusCode, nil, nil
-	}
-	var payload any
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return resp.StatusCode, nil, fmt.Errorf("dupechecking: decode JSON GET response: %w", err)
-	}
-	return resp.StatusCode, payload, nil
-}
-
-func doJSONPost(ctx context.Context, client *http.Client, endpoint string, body map[string]any, headers map[string]string) (int, map[string]any, error) {
-	status, payload, err := doJSONPostAny(ctx, client, endpoint, body, headers)
-	if err != nil {
-		return status, nil, err
-	}
-	if payload == nil {
-		return status, nil, nil
-	}
-	result, ok := payload.(map[string]any)
-	if !ok {
-		return status, nil, nil
-	}
-	return status, result, nil
-}
-
-func doJSONPostAny(ctx context.Context, client *http.Client, endpoint string, body map[string]any, headers map[string]string) (int, any, error) {
-	raw, err := json.Marshal(body)
-	if err != nil {
-		return 0, nil, fmt.Errorf("dupechecking: marshal JSON POST body: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(raw))
-	if err != nil {
-		return 0, nil, fmt.Errorf("dupechecking: create JSON POST request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return 0, nil, fmt.Errorf("dupechecking: JSON POST request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return resp.StatusCode, nil, nil
-	}
-	var payload any
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return resp.StatusCode, nil, fmt.Errorf("dupechecking: decode JSON POST response: %w", err)
-	}
-	return resp.StatusCode, payload, nil
-}
-
-func intFromAny(value any) int64 {
-	switch v := value.(type) {
-	case int:
-		return int64(v)
-	case int32:
-		return int64(v)
-	case int64:
-		return v
-	case float64:
-		return int64(v)
-	case json.Number:
-		i, _ := v.Int64()
-		return i
-	case string:
-		s := strings.TrimSpace(strings.TrimPrefix(v, "tt"))
-		if s == "" {
-			return 0
-		}
-		i, _ := strconv.ParseInt(s, 10, 64)
-		return i
-	default:
-		return 0
-	}
-}
-
-func stringFromAny(value any) string {
-	if value == nil {
-		return ""
-	}
-	switch v := value.(type) {
-	case string:
-		return strings.TrimSpace(v)
-	default:
-		return strings.TrimSpace(fmt.Sprint(v))
-	}
-}
-
-func anyToSlice(value any) ([]any, bool) {
-	list, ok := value.([]any)
-	return list, ok
-}
diff --git a/internal/dupechecking/is.go b/internal/dupechecking/is.go
deleted file mode 100644
index 753561e8..00000000
--- a/internal/dupechecking/is.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type isHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h isHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	baseURL := trackerBaseURL(h.cfg, "IS", "https://immortalseed.me")
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "IS", trackerHost(baseURL, "immortalseed.me"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid IS cookies")}, nil
-	}
-	params := url.Values{"do": {"search"}}
-	if strings.EqualFold(categoryOfSiteMeta(meta), "MOVIE") {
-		imdb := imdbForLookup(meta)
-		if imdb == "" {
-			return nil, []string{noteSkip("missing IMDb ID for IS movie dupe search")}, nil
-		}
-		params.Set("search_type", "t_genre")
-		params.Set("keywords", imdb)
-	} else {
-		params.Set("search_type", "t_name")
-		params.Set("keywords", strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)+" "+resolveSeasonEpisodeQuery(meta)))
-	}
-	resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/browse.php", params, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("IS search failed")}, nil
-	}
-	table := firstNode(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "table" && attrValueHTML(node, "id") == "sortabletable"
-	})
-	if table == nil {
-		return nil, nil, nil
-	}
-	rows := findNodes(table, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "tr"
-	})
-	entries := make([]api.DupeEntry, 0)
-	for _, row := range rows {
-		link := firstNode(row, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "href"), "details.php?id=")
-		})
-		if link == nil {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: strings.TrimSpace(nodeTextHTML(link)),
-			Link: absoluteURL(baseURL, attrValueHTML(link, "href")),
-		}
-		cells := findNodes(row, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "td"
-		})
-		if len(cells) >= 5 {
-			addSize(&entry, nodeTextHTML(cells[4]))
-		}
-		if entry.Name != "" {
-			entries = append(entries, entry)
-		}
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/mtv.go b/internal/dupechecking/mtv.go
deleted file mode 100644
index 1eb41b0b..00000000
--- a/internal/dupechecking/mtv.go
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"encoding/xml"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const mtvTorznabEndpoint = "https://www.morethantv.me/api/torznab"
-
-type mtvHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h mtvHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "MTV")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-
-	params := url.Values{}
-	params.Set("t", "search")
-	params.Set("apikey", apiKey)
-	params.Set("limit", "100")
-
-	switch {
-	case meta.ExternalIDs.IMDBID != 0:
-		params.Set("imdbid", "tt"+strconv.Itoa(meta.ExternalIDs.IMDBID))
-	case meta.ExternalIDs.TMDBID != 0:
-		params.Set("tmdbid", strconv.Itoa(meta.ExternalIDs.TMDBID))
-	case isMTVTVCategory(meta) && meta.ExternalIDs.TVDBID != 0:
-		params.Set("tvdbid", strconv.Itoa(meta.ExternalIDs.TVDBID))
-	default:
-		query := cleanMTVSearchTitle(meta)
-		if query == "" {
-			return nil, []string{noteSkip("missing imdb/tmdb/tvdb id or title for MTV dupe search")}, nil
-		}
-		params.Set("q", query)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, mtvTorznabEndpoint, nil)
-	if err != nil {
-		return nil, nil, fmt.Errorf("build MTV request: %w", err)
-	}
-	req.URL.RawQuery = params.Encode()
-
-	resp, err := h.http.Do(req)
-	if err != nil {
-		return nil, []string{noteSkip("MTV search failed")}, nil
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, []string{noteSkip("MTV search failed")}, nil
-	}
-
-	var payload mtvRSS
-	if err := xml.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return nil, []string{noteSkip("MTV response parse failed")}, nil
-	}
-
-	entries := make([]api.DupeEntry, 0, len(payload.Channel.Items))
-	for _, item := range payload.Channel.Items {
-		title := strings.TrimSpace(item.Title)
-		if title == "" {
-			continue
-		}
-
-		fileCount := parsePositiveInt(item.Files)
-		sizeBytes := parsePositiveInt64(item.Size)
-		for _, attr := range item.allAttrs() {
-			name := strings.ToLower(strings.TrimSpace(attr.Name))
-			value := strings.TrimSpace(attr.Value)
-			switch {
-			case fileCount == 0 && (name == "files" || name == "file_count" || name == "filecount"):
-				fileCount = parsePositiveInt(value)
-			case sizeBytes == 0 && name == "size":
-				sizeBytes = parsePositiveInt64(value)
-			}
-		}
-
-		guid := strings.TrimSpace(item.GUID)
-		download := strings.TrimSpace(item.Link)
-		if download == "" {
-			download = strings.TrimSpace(item.Enclosure.URL)
-		}
-
-		entry := api.DupeEntry{
-			Name:      title,
-			Files:     []string{title},
-			FileCount: fileCount,
-			ID:        guid,
-			Link:      guid,
-			Download:  strings.ReplaceAll(download, "&amp;", "&"),
-		}
-		if sizeBytes > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = sizeBytes
-		}
-		entries = append(entries, entry)
-	}
-
-	return entries, nil, nil
-}
-
-// isMTVTVCategory reports whether MTV torznab searches may use a TVDB ID query.
-// Explicit movie categories suppress TVDB even when MediaInfo classifies the release as TV.
-func isMTVTVCategory(meta api.PreparedMetadata) bool {
-	if isMTVMovieCategory(meta) {
-		return false
-	}
-	return strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV")
-}
-
-func isMTVMovieCategory(meta api.PreparedMetadata) bool {
-	return strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "MOVIE")
-}
-
-func cleanMTVSearchTitle(meta api.PreparedMetadata) string {
-	query := strings.TrimSpace(meta.Release.Title)
-	if query == "" {
-		query = strings.TrimSpace(meta.ReleaseName)
-	}
-	if query == "" {
-		return ""
-	}
-	query = strings.ReplaceAll(query, ": ", " ")
-	query = strings.ReplaceAll(query, "’", "")
-	query = strings.ReplaceAll(query, "'", "")
-	return strings.Join(strings.Fields(query), " ")
-}
-
-func parsePositiveInt(value string) int {
-	parsed, err := strconv.Atoi(strings.TrimSpace(value))
-	if err != nil || parsed <= 0 {
-		return 0
-	}
-	return parsed
-}
-
-func parsePositiveInt64(value string) int64 {
-	parsed, err := strconv.ParseInt(strings.TrimSpace(value), 10, 64)
-	if err != nil || parsed <= 0 {
-		return 0
-	}
-	return parsed
-}
-
-type mtvRSS struct {
-	Channel mtvChannel `xml:"channel"`
-}
-
-type mtvChannel struct {
-	Items []mtvItem `xml:"item"`
-}
-
-type mtvItem struct {
-	Title        string       `xml:"title"`
-	Files        string       `xml:"files"`
-	Size         string       `xml:"size"`
-	GUID         string       `xml:"guid"`
-	Link         string       `xml:"link"`
-	Enclosure    mtvEnclosure `xml:"enclosure"`
-	Attrs        []mtvAttr    `xml:"attr"`
-	TorznabAttrs []mtvAttr    `xml:"http://torznab.com/schemas/2015/feed attr"`
-}
-
-func (i mtvItem) allAttrs() []mtvAttr {
-	if len(i.Attrs) == 0 {
-		return i.TorznabAttrs
-	}
-	if len(i.TorznabAttrs) == 0 {
-		return i.Attrs
-	}
-	combined := make([]mtvAttr, 0, len(i.Attrs)+len(i.TorznabAttrs))
-	combined = append(combined, i.Attrs...)
-	combined = append(combined, i.TorznabAttrs...)
-	return combined
-}
-
-type mtvAttr struct {
-	Name  string `xml:"name,attr"`
-	Value string `xml:"value,attr"`
-}
-
-type mtvEnclosure struct {
-	URL string `xml:"url,attr"`
-}
diff --git a/internal/dupechecking/mtv_test.go b/internal/dupechecking/mtv_test.go
deleted file mode 100644
index 29fa14ea..00000000
--- a/internal/dupechecking/mtv_test.go
+++ /dev/null
@@ -1,286 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestMTVHandlerUsesIMDBPriorityAndParsesXML(t *testing.T) {
-	t.Parallel()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			if req.Method != http.MethodGet {
-				t.Fatalf("expected GET request, got %s", req.Method)
-			}
-			if got := req.URL.String(); !strings.HasPrefix(got, mtvTorznabEndpoint+"?") {
-				t.Fatalf("unexpected endpoint %q", got)
-			}
-
-			query := req.URL.Query()
-			assertQueryParam(t, query, "t", "search")
-			assertQueryParam(t, query, "apikey", "token")
-			assertQueryParam(t, query, "limit", "100")
-			assertQueryParam(t, query, "imdbid", "tt123456")
-			if got := query.Get("tmdbid"); got != "" {
-				t.Fatalf("tmdbid should be empty when imdbid is present, got %q", got)
-			}
-			if got := query.Get("tvdbid"); got != "" {
-				t.Fatalf("tvdbid should be empty when imdbid is present, got %q", got)
-			}
-			if got := query.Get("q"); got != "" {
-				t.Fatalf("q should be empty when imdbid is present, got %q", got)
-			}
-
-			body := `<?xml version="1.0" encoding="UTF-8"?>
-<rss xmlns:torznab="http://torznab.com/schemas/2015/feed">
-  <channel>
-    <item>
-      <title>Example.Release.1080p.WEB-DL.DDP5.1.H.264-GRP</title>
-      <files>3</files>
-      <size>123456789</size>
-      <guid>https://www.morethantv.me/torrents.php?id=100</guid>
-      <link>https://www.morethantv.me/download.php/100?torrent_pass=abc&amp;https=1</link>
-    </item>
-    <item>
-      <title>Example.Release.2160p.WEB-DL.DDP5.1.HEVC-GRP</title>
-      <guid>https://www.morethantv.me/torrents.php?id=101</guid>
-      <link>https://www.morethantv.me/download.php/101?torrent_pass=abc&amp;https=1</link>
-      <torznab:attr name="files" value="7" />
-      <torznab:attr name="size" value="222333444" />
-    </item>
-  </channel>
-</rss>`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := mtvHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {APIKey: "token"},
-				},
-			},
-		},
-		http: client,
-	}
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{
-			IMDBID: 123456,
-			TMDBID: 999,
-			TVDBID: 888,
-		},
-		Release: api.ReleaseInfo{Title: "Ignored Title"},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "MTV")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 2 {
-		t.Fatalf("expected 2 entries, got %d", len(entries))
-	}
-
-	first := entries[0]
-	if first.Name != "Example.Release.1080p.WEB-DL.DDP5.1.H.264-GRP" {
-		t.Fatalf("unexpected first entry name %q", first.Name)
-	}
-	if first.FileCount != 3 {
-		t.Fatalf("expected file_count=3, got %d", first.FileCount)
-	}
-	if !first.SizeKnown || first.SizeBytes != 123456789 {
-		t.Fatalf("expected parsed size for first entry, got known=%t size=%d", first.SizeKnown, first.SizeBytes)
-	}
-	if first.ID != "https://www.morethantv.me/torrents.php?id=100" {
-		t.Fatalf("unexpected first entry ID %q", first.ID)
-	}
-	if first.Link != "https://www.morethantv.me/torrents.php?id=100" {
-		t.Fatalf("unexpected first entry link %q", first.Link)
-	}
-	if first.Download != "https://www.morethantv.me/download.php/100?torrent_pass=abc&https=1" {
-		t.Fatalf("unexpected first entry download %q", first.Download)
-	}
-	if len(first.Files) != 1 || first.Files[0] != first.Name {
-		t.Fatalf("expected first entry files to contain release title, got %#v", first.Files)
-	}
-
-	second := entries[1]
-	if second.FileCount != 7 {
-		t.Fatalf("expected attr-derived file_count=7, got %d", second.FileCount)
-	}
-	if !second.SizeKnown || second.SizeBytes != 222333444 {
-		t.Fatalf("expected attr-derived size, got known=%t size=%d", second.SizeKnown, second.SizeBytes)
-	}
-}
-
-func TestMTVHandlerFallsBackToCleanedTitleQuery(t *testing.T) {
-	t.Parallel()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			query := req.URL.Query()
-			assertQueryParam(t, query, "t", "search")
-			assertQueryParam(t, query, "apikey", "token")
-			assertQueryParam(t, query, "limit", "100")
-			assertQueryParam(t, query, "q", "Johns Story The Return")
-			if got := query.Get("imdbid"); got != "" {
-				t.Fatalf("imdbid should be empty, got %q", got)
-			}
-			body := `<rss><channel></channel></rss>`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := mtvHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {APIKey: "token"},
-				},
-			},
-		},
-		http: client,
-	}
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Title: "John's Story: The Return"}}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "MTV")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestMTVHandlerSkipsTVDBForMovie(t *testing.T) {
-	t.Parallel()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			query := req.URL.Query()
-			assertQueryParam(t, query, "q", "Movie Title")
-			if got := query.Get("tvdbid"); got != "" {
-				t.Fatalf("tvdbid should be empty for movie category, got %q", got)
-			}
-			body := `<rss><channel></channel></rss>`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := mtvHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {APIKey: "token"},
-				},
-			},
-		},
-		http: client,
-	}
-	meta := api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE", TVDBID: 888},
-		Release:           api.ReleaseInfo{Title: "Movie Title"},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "MTV")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-func TestMTVHandlerUsesTVDBForTV(t *testing.T) {
-	t.Parallel()
-
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			query := req.URL.Query()
-			assertQueryParam(t, query, "tvdbid", "888")
-			if got := query.Get("q"); got != "" {
-				t.Fatalf("q should be empty when tvdbid is present, got %q", got)
-			}
-			body := `<rss><channel></channel></rss>`
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Body:       io.NopCloser(strings.NewReader(body)),
-				Header:     make(http.Header),
-			}, nil
-		}),
-	}
-
-	handler := mtvHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {APIKey: "token"},
-				},
-			},
-		},
-		http: client,
-	}
-	meta := api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{TVDBID: 888},
-		Release:           api.ReleaseInfo{Title: "Show Title"},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "MTV")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-}
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
-func assertQueryParam(t *testing.T, query url.Values, key string, expected string) {
-	t.Helper()
-	if got := query.Get(key); got != expected {
-		t.Fatalf("unexpected %s query value: got %q want %q", key, got, expected)
-	}
-}
diff --git a/internal/dupechecking/nbl.go b/internal/dupechecking/nbl.go
deleted file mode 100644
index ad45c34f..00000000
--- a/internal/dupechecking/nbl.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type nblHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h nblHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "NBL")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	searchTerm := map[string]any{}
-	switch {
-	case meta.ExternalIDs.TVmazeID != 0:
-		searchTerm["tvmaze"] = meta.ExternalIDs.TVmazeID
-	case meta.ExternalIDs.IMDBID != 0:
-		searchTerm["imdb"] = strconv.Itoa(meta.ExternalIDs.IMDBID)
-	default:
-		searchTerm["series"] = strings.TrimSpace(meta.Release.Title)
-	}
-	payload := map[string]any{
-		"jsonrpc": "2.0",
-		"id":      1,
-		"method":  "getTorrents",
-		"params":  []any{apiKey, searchTerm},
-	}
-	status, body, err := doJSONPost(ctx, h.http, "https://nebulance.io/api.php", payload, nil)
-	if err != nil || status < 200 || status >= 300 || len(body) == 0 {
-		return nil, []string{noteSkip("NBL search failed")}, nil
-	}
-	result, _ := body["result"].(map[string]any)
-	items, _ := result["items"].([]any)
-	entries := make([]api.DupeEntry, 0, len(items))
-	for _, raw := range items {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		entry := api.DupeEntry{
-			Name: stringFromAny(item["rls_name"]),
-			Link: "https://nebulance.io/torrents.php?id=" + stringFromAny(item["group_id"]),
-		}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		if fileList, ok := item["file_list"].([]any); ok {
-			entry.FileCount = len(fileList)
-			for _, file := range fileList {
-				f := stringFromAny(file)
-				if f != "" {
-					entry.Files = append(entry.Files, f)
-				}
-			}
-		}
-		entry.Download = stringFromAny(item["download"])
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/phd.go b/internal/dupechecking/phd.go
deleted file mode 100644
index ab5e8e7e..00000000
--- a/internal/dupechecking/phd.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type phdHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h phdHandler) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	return azNetworkHandler(h).Search(ctx, meta, tracker)
-}
diff --git a/internal/dupechecking/ptp.go b/internal/dupechecking/ptp.go
deleted file mode 100644
index 418cccb0..00000000
--- a/internal/dupechecking/ptp.go
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type ptpHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h ptpHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	cfg, ok := trackerCfg(h.cfg, "PTP")
-	apiUser := strings.TrimSpace(cfg.PTPAPIUser)
-	apiKey := strings.TrimSpace(cfg.PTPAPIKey)
-	if !ok || apiUser == "" || apiKey == "" {
-		return nil, []string{noteSkip("missing ApiUser/ApiKey for tracker")}, nil
-	}
-	if meta.ExternalIDs.IMDBID == 0 {
-		return nil, []string{noteSkip("missing imdb id for PTP dupe search")}, nil
-	}
-	headers := map[string]string{"ApiUser": apiUser, "ApiKey": apiKey}
-	groupParams := url.Values{}
-	groupParams.Set("imdb", "tt"+strconv.Itoa(meta.ExternalIDs.IMDBID))
-	_, groupPayload, err := doJSONGet(ctx, h.http, "https://passthepopcorn.me/torrents.php", groupParams, headers)
-	if err != nil || len(groupPayload) == 0 {
-		return nil, []string{noteSkip("PTP group search failed")}, nil
-	}
-	groupID := ""
-	if movies, ok := groupPayload["Movies"].([]any); ok && len(movies) > 0 {
-		if movie, ok := movies[0].(map[string]any); ok {
-			groupID = stringFromAny(movie["GroupId"])
-		}
-	}
-	if groupID == "" {
-		if id := stringFromAny(groupPayload["GroupId"]); id != "" {
-			groupID = id
-		}
-	}
-	if groupID == "" {
-		return nil, nil, nil
-	}
-
-	params := url.Values{}
-	params.Set("id", groupID)
-	_, payload, err := doJSONGet(ctx, h.http, "https://passthepopcorn.me/torrents.php", params, headers)
-	if err != nil || len(payload) == 0 {
-		return nil, []string{noteSkip("PTP torrent search failed")}, nil
-	}
-
-	quality := "High Definition"
-	res := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
-	if isSDResolution(res) {
-		quality = "Standard Definition"
-	}
-	if strings.Contains(res, "2160") || strings.Contains(res, "4320") || strings.Contains(res, "8640") {
-		quality = "Ultra High Definition"
-	}
-
-	torrents, _ := payload["Torrents"].([]any)
-	entries := make([]api.DupeEntry, 0, len(torrents))
-	for _, raw := range torrents {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		if q := stringFromAny(item["Quality"]); q != "" && !strings.EqualFold(q, quality) {
-			continue
-		}
-		id := stringFromAny(item["Id"])
-		name := "[" + stringFromAny(item["Resolution"]) + "] " + stringFromAny(item["ReleaseName"])
-		entries = append(entries, api.DupeEntry{
-			Name: strings.TrimSpace(name),
-			ID:   id,
-			Link: "https://passthepopcorn.me/torrents.php?torrentid=" + id,
-		})
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/pts.go b/internal/dupechecking/pts.go
deleted file mode 100644
index 95843d03..00000000
--- a/internal/dupechecking/pts.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type ptsHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h ptsHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	imdb := imdbForLookup(meta)
-	if imdb == "" {
-		return nil, []string{noteSkip("missing IMDb ID for PTS dupe search")}, nil
-	}
-	baseURL := trackerBaseURL(h.cfg, "PTS", "https://www.ptskit.org")
-	cookies, err := loadTrackerCookies(ctx, h.cfg, "PTS", trackerHost(baseURL, "ptskit.org"))
-	if err != nil {
-		return nil, []string{noteSkip("missing valid PTS cookies")}, nil
-	}
-	params := url.Values{"incldead": {"1"}, "search": {imdb}, "search_area": {"4"}}
-	resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/torrents.php", params, cookies)
-	if err != nil || !resp.ok() {
-		return nil, []string{noteSkip("PTS search failed")}, nil
-	}
-	names := findNodes(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "b"
-	})
-	entries := make([]api.DupeEntry, 0, len(names))
-	for _, node := range names {
-		name := strings.TrimSpace(nodeTextHTML(node))
-		if name == "" {
-			continue
-		}
-		entries = append(entries, api.DupeEntry{Name: name})
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/rtf.go b/internal/dupechecking/rtf.go
deleted file mode 100644
index f26d6c07..00000000
--- a/internal/dupechecking/rtf.go
+++ /dev/null
@@ -1,382 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	rtfTorrentEndpoint = "https://retroflix.club/api/torrent"
-	rtfLoginEndpoint   = "https://retroflix.club/api/login"
-	rtfBrowsePrefix    = "https://retroflix.club/browse/t/"
-	rtfAgeGraceDays    = 365*10 + 3
-)
-
-type rtfHandler struct {
-	cfg    config.Config
-	http   *http.Client
-	logger api.Logger
-}
-
-func (h rtfHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	cfg, ok := trackerCfg(h.cfg, "RTF")
-	if !ok || (rtfAPIKey(cfg) == "" && !rtfHasCredentials(cfg)) {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	if h.http == nil {
-		return nil, []string{noteSkip("RTF handler misconfigured: no HTTP client")}, nil
-	}
-	if !isRTFContentOldEnough(meta, time.Now().UTC()) {
-		return nil, []string{noteSkip("RTF requires content older than 10 years")}, nil
-	}
-
-	params, ok := buildRTFSearchParams(meta)
-	if !ok {
-		return nil, []string{noteSkip("missing imdb/title for RTF dupe search")}, nil
-	}
-
-	apiKey, err := h.ensureAPIKey(ctx, cfg)
-	if err != nil {
-		return nil, []string{noteSkip(err.Error())}, nil
-	}
-
-	status, payload, err := h.search(ctx, params, apiKey)
-	if err != nil {
-		return nil, []string{noteSkip("RTF request failed")}, nil
-	}
-	if status == http.StatusUnauthorized || status == http.StatusForbidden {
-		if !rtfHasCredentials(cfg) {
-			return nil, []string{noteSkip("RTF api key expired and username/password are missing")}, nil
-		}
-		refreshedKey, refreshErr := h.refreshToken(ctx, cfg)
-		if refreshErr != nil {
-			return nil, []string{noteSkip("RTF api key refresh failed")}, nil
-		}
-		h.cacheRTFAPIKey(cfg, refreshedKey)
-		status, payload, err = h.search(ctx, params, refreshedKey)
-		if err != nil {
-			return nil, []string{noteSkip("RTF request failed")}, nil
-		}
-	}
-	if status < 200 || status >= 300 {
-		return nil, []string{noteSkip("RTF search failed")}, nil
-	}
-	list, ok := anyToSlice(payload)
-	if !ok {
-		return nil, nil, nil
-	}
-	entries := make([]api.DupeEntry, 0, len(list))
-	for _, raw := range list {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		id := stringFromAny(item["id"])
-		entry := api.DupeEntry{
-			Name:     stringFromAny(item["name"]),
-			ID:       id,
-			Link:     buildRTFLink(item, id),
-			Download: buildRTFDownloadLink(id),
-		}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		if files, ok := item["files"].([]any); ok {
-			entry.FileCount = len(files)
-			for _, f := range files {
-				if fileMap, ok := f.(map[string]any); ok {
-					name := stringFromAny(fileMap["name"])
-					if name != "" {
-						entry.Files = append(entry.Files, name)
-					}
-				}
-			}
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
-
-func buildRTFSearchParams(meta api.PreparedMetadata) (url.Values, bool) {
-	params := url.Values{}
-	params.Set("includingDead", "1")
-	if meta.ExternalIDs.IMDBID != 0 {
-		params.Set("imdbId", fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID))
-		return params, true
-	}
-	query := cleanRTFSearchTitle(meta)
-	if query == "" {
-		return nil, false
-	}
-	params.Set("search", query)
-	return params, true
-}
-
-func cleanRTFSearchTitle(meta api.PreparedMetadata) string {
-	query := strings.TrimSpace(meta.Release.Title)
-	if query == "" {
-		query = strings.TrimSpace(meta.ReleaseName)
-	}
-	if query == "" {
-		return ""
-	}
-	replacer := strings.NewReplacer(
-		":", " ",
-		",", "",
-		"'", "",
-		"’", "",
-	)
-	query = replacer.Replace(query)
-	return strings.Join(strings.Fields(query), " ")
-}
-
-func (h rtfHandler) search(ctx context.Context, params url.Values, apiKey string) (int, any, error) {
-	headers := map[string]string{
-		"accept":        "application/json",
-		"Authorization": strings.TrimSpace(apiKey),
-	}
-	return doJSONGetAny(ctx, h.http, rtfTorrentEndpoint, params, headers)
-}
-
-func (h rtfHandler) ensureAPIKey(ctx context.Context, cfg config.TrackerConfig) (string, error) {
-	apiKey := rtfAPIKey(cfg)
-	if apiKey != "" {
-		return apiKey, nil
-	}
-	if !rtfHasCredentials(cfg) {
-		return "", errors.New("RTF api key unavailable: missing username/password for refresh")
-	}
-	token, err := h.refreshToken(ctx, cfg)
-	if err != nil {
-		return "", fmt.Errorf("RTF api key unavailable: %w", err)
-	}
-	h.cacheRTFAPIKey(cfg, token)
-	return token, nil
-}
-
-func (h rtfHandler) refreshToken(ctx context.Context, cfg config.TrackerConfig) (string, error) {
-	body := map[string]any{
-		"username": strings.TrimSpace(cfg.Username),
-		"password": strings.TrimSpace(cfg.Password),
-	}
-	status, payload, err := doJSONPostAny(ctx, h.http, rtfLoginEndpoint, body, map[string]string{"accept": "application/json"})
-	if err != nil {
-		return "", fmt.Errorf("RTF login request failed: %w", err)
-	}
-	if status < 200 || status >= 300 {
-		return "", fmt.Errorf("RTF login returned status %d", status)
-	}
-	obj, ok := payload.(map[string]any)
-	if !ok {
-		return "", errors.New("RTF login returned invalid payload")
-	}
-	token := strings.TrimSpace(stringFromAny(obj["token"]))
-	if token == "" {
-		return "", errors.New("RTF login response missing token")
-	}
-	return token, nil
-}
-
-// cacheRTFAPIKey updates the in-memory config map so later searches in this
-// process can reuse a refreshed token. Writing back to durable config storage
-// is handled elsewhere.
-func (h rtfHandler) cacheRTFAPIKey(cfg config.TrackerConfig, token string) {
-	if strings.TrimSpace(token) == "" || len(h.cfg.Trackers.Trackers) == 0 {
-		return
-	}
-	for key, current := range h.cfg.Trackers.Trackers {
-		if !strings.EqualFold(key, "RTF") {
-			continue
-		}
-		current.APIKey = token
-		current.PTPAPIKey = token
-		h.cfg.Trackers.Trackers[key] = current
-		return
-	}
-	cfg.APIKey = token
-	cfg.PTPAPIKey = token
-	h.cfg.Trackers.Trackers["RTF"] = cfg
-}
-
-func rtfAPIKey(cfg config.TrackerConfig) string {
-	if key := strings.TrimSpace(cfg.APIKey); key != "" {
-		return key
-	}
-	return strings.TrimSpace(cfg.PTPAPIKey)
-}
-
-func rtfHasCredentials(cfg config.TrackerConfig) bool {
-	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
-}
-
-func buildRTFLink(item map[string]any, id string) string {
-	if link := strings.TrimSpace(stringFromAny(item["url"])); link != "" {
-		return link
-	}
-	if id == "" {
-		return ""
-	}
-	return rtfBrowsePrefix + url.PathEscape(id)
-}
-
-func buildRTFDownloadLink(id string) string {
-	if strings.TrimSpace(id) == "" {
-		return ""
-	}
-	return rtfTorrentEndpoint + "/" + url.PathEscape(id) + "/download"
-}
-
-func isRTFContentOldEnough(meta api.PreparedMetadata, now time.Time) bool {
-	cutoff := now.UTC().AddDate(0, 0, -rtfAgeGraceDays)
-	if date, ok := rtfReferenceDate(meta); ok {
-		return !date.After(cutoff)
-	}
-	year := rtfReferenceYear(meta)
-	if year == 0 {
-		return true
-	}
-	// Year-based fallback is intentionally looser than the date-based check
-	// because month/day precision is unavailable when only year is known.
-	return now.UTC().Year()-year > 9
-}
-
-func rtfReferenceDate(meta api.PreparedMetadata) (time.Time, bool) {
-	category := rtfCategory(meta)
-	switch category {
-	case "MOVIE":
-		return rtfMovieReleaseDate(meta)
-	case "TV":
-		return rtfMostRecentTVDate(meta)
-	default:
-		if date, ok := rtfMovieReleaseDate(meta); ok {
-			return date, true
-		}
-		return rtfMostRecentTVDate(meta)
-	}
-}
-
-func rtfMovieReleaseDate(meta api.PreparedMetadata) (time.Time, bool) {
-	if meta.ExternalMetadata.TMDB == nil {
-		return time.Time{}, false
-	}
-	return parseRTFDate(meta.ExternalMetadata.TMDB.ReleaseDate)
-}
-
-func rtfMostRecentTVDate(meta api.PreparedMetadata) (time.Time, bool) {
-	candidates := make([]time.Time, 0, 8)
-	if meta.ExternalMetadata.TMDB != nil {
-		if date, ok := parseRTFDate(meta.ExternalMetadata.TMDB.LastAirDate); ok {
-			candidates = append(candidates, date)
-		}
-		if date, ok := parseRTFDate(meta.ExternalMetadata.TMDB.FirstAirDate); ok {
-			candidates = append(candidates, date)
-		}
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		if date, ok := parseRTFDate(meta.ExternalMetadata.TVmaze.Premiered); ok {
-			candidates = append(candidates, date)
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		for _, episode := range meta.ExternalMetadata.IMDB.Episodes {
-			if date, ok := rtfEpisodeDate(episode); ok {
-				candidates = append(candidates, date)
-			}
-		}
-	}
-	if len(candidates) == 0 {
-		return time.Time{}, false
-	}
-	latest := candidates[0]
-	for _, candidate := range candidates[1:] {
-		if candidate.After(latest) {
-			latest = candidate
-		}
-	}
-	return latest, true
-}
-
-func rtfEpisodeDate(episode api.IMDBEpisode) (time.Time, bool) {
-	if episode.ReleaseDate.Year > 0 {
-		month := episode.ReleaseDate.Month
-		if month <= 0 {
-			month = 1
-		}
-		day := episode.ReleaseDate.Day
-		if day <= 0 {
-			day = 1
-		}
-		return time.Date(episode.ReleaseDate.Year, time.Month(month), day, 0, 0, 0, 0, time.UTC), true
-	}
-	if episode.ReleaseYear > 0 {
-		return time.Date(episode.ReleaseYear, time.January, 1, 0, 0, 0, 0, time.UTC), true
-	}
-	return time.Time{}, false
-}
-
-func parseRTFDate(raw string) (time.Time, bool) {
-	value := strings.TrimSpace(raw)
-	if value == "" {
-		return time.Time{}, false
-	}
-	for _, layout := range []string{"2006-01-02", time.RFC3339} {
-		parsed, err := time.Parse(layout, value)
-		if err != nil {
-			continue
-		}
-		return time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, time.UTC), true
-	}
-	return time.Time{}, false
-}
-
-func rtfReferenceYear(meta api.PreparedMetadata) int {
-	if date, ok := rtfReferenceDate(meta); ok {
-		return date.Year()
-	}
-	if meta.Release.Year > 0 {
-		return meta.Release.Year
-	}
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		return meta.ExternalMetadata.TMDB.Year
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		return meta.ExternalMetadata.IMDB.Year
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		if date, ok := parseRTFDate(meta.ExternalMetadata.TVmaze.Premiered); ok {
-			return date.Year()
-		}
-	}
-	return 0
-}
-
-func rtfCategory(meta api.PreparedMetadata) string {
-	candidates := []string{
-		meta.ExternalIDs.Category,
-		meta.MediaInfoCategory,
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		candidates = append(candidates, meta.ExternalMetadata.TMDB.Category)
-	}
-	for _, candidate := range candidates {
-		trimmed := strings.ToUpper(strings.TrimSpace(candidate))
-		switch trimmed {
-		case "MOVIE", "TV":
-			return trimmed
-		}
-	}
-	return ""
-}
diff --git a/internal/dupechecking/rtf_test.go b/internal/dupechecking/rtf_test.go
deleted file mode 100644
index f918af65..00000000
--- a/internal/dupechecking/rtf_test.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestRTFHandlerUsesIMDBIDParamAndParsesResults(t *testing.T) {
-	t.Parallel()
-
-	sawSearch := false
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			switch req.URL.Path {
-			case "/api/torrent":
-				sawSearch = true
-				query := req.URL.Query()
-				if got := query.Get("includingDead"); got != "1" {
-					t.Fatalf("unexpected includingDead value %q", got)
-				}
-				if got := query.Get("imdbId"); got != "tt0123456" {
-					t.Fatalf("unexpected imdbId value %q", got)
-				}
-				if got := query.Get("imdb"); got != "" {
-					t.Fatalf("unexpected imdb query value %q", got)
-				}
-				body := `[{"id":"42","name":"Movie.1990.1080p.BluRay-GRP","size":123456789,"files":[{"name":"Movie.1990.1080p.BluRay-GRP.mkv"}]}]`
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(strings.NewReader(body)),
-					Header:     make(http.Header),
-				}, nil
-			default:
-				t.Fatalf("unexpected request path %q", req.URL.Path)
-				return nil, nil
-			}
-		}),
-	}
-
-	handler := rtfHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"RTF": {APIKey: "good-key"},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{IMDBID: 123456, Category: "MOVIE"},
-		Release:     api.ReleaseInfo{Year: 1990},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "RTF")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one entry, got %d", len(entries))
-	}
-	if !sawSearch {
-		t.Fatalf("expected /api/torrent call")
-	}
-
-	entry := entries[0]
-	if entry.ID != "42" {
-		t.Fatalf("unexpected ID %q", entry.ID)
-	}
-	if entry.Link != rtfBrowsePrefix+"42" {
-		t.Fatalf("unexpected link %q", entry.Link)
-	}
-	if entry.Download != rtfTorrentEndpoint+"/42/download" {
-		t.Fatalf("unexpected download %q", entry.Download)
-	}
-	if !entry.SizeKnown || entry.SizeBytes != 123456789 {
-		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
-	}
-	if entry.FileCount != 1 || len(entry.Files) != 1 {
-		t.Fatalf("unexpected files payload count=%d files=%#v", entry.FileCount, entry.Files)
-	}
-}
-
-func TestRTFHandlerRefreshesAndRetriesOn401(t *testing.T) {
-	t.Parallel()
-
-	searchCalls := 0
-	loginCalls := 0
-	client := &http.Client{
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			switch req.URL.Path {
-			case "/api/login":
-				loginCalls++
-				raw, err := io.ReadAll(req.Body)
-				if err != nil {
-					t.Fatalf("read login body: %v", err)
-				}
-				body := string(raw)
-				if !strings.Contains(body, `"username":"user"`) || !strings.Contains(body, `"password":"pass"`) {
-					t.Fatal("unexpected login body fields")
-				}
-				return &http.Response{
-					StatusCode: http.StatusCreated,
-					Body:       io.NopCloser(strings.NewReader(`{"token":"new-key"}`)),
-					Header:     make(http.Header),
-				}, nil
-			case "/api/torrent":
-				searchCalls++
-				auth := req.Header.Get("Authorization")
-				if searchCalls == 1 {
-					if auth != "old-key" {
-						t.Fatal("expected first search to use old key")
-					}
-					return &http.Response{
-						StatusCode: http.StatusUnauthorized,
-						Body:       io.NopCloser(strings.NewReader(``)),
-						Header:     make(http.Header),
-					}, nil
-				}
-				if auth != "new-key" {
-					t.Fatal("expected retry search to use new key")
-				}
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(strings.NewReader(`[]`)),
-					Header:     make(http.Header),
-				}, nil
-			default:
-				t.Fatalf("unexpected request path %q", req.URL.Path)
-				return nil, nil
-			}
-		}),
-	}
-
-	handler := rtfHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"RTF": {APIKey: "old-key", Username: "user", Password: "pass"},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{IMDBID: 123456, Category: "MOVIE"},
-		Release:     api.ReleaseInfo{Year: 1990},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "RTF")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 0 {
-		t.Fatalf("expected no notes, got %#v", notes)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	if searchCalls != 2 {
-		t.Fatalf("expected 2 search calls, got %d", searchCalls)
-	}
-	if loginCalls != 1 {
-		t.Fatalf("expected 1 login call, got %d", loginCalls)
-	}
-}
-
-func TestRTFHandlerSkipsTooRecentContent(t *testing.T) {
-	t.Parallel()
-
-	called := false
-	client := &http.Client{
-		Transport: roundTripFunc(func(_ *http.Request) (*http.Response, error) {
-			called = true
-			t.Fatalf("no request should be sent for too-recent content")
-			return nil, nil
-		}),
-	}
-
-	handler := rtfHandler{
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"RTF": {APIKey: "good-key"},
-				},
-			},
-		},
-		http:   client,
-		logger: api.NopLogger{},
-	}
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		Release:     api.ReleaseInfo{Title: "Recent Movie"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Category:    "MOVIE",
-				ReleaseDate: time.Now().UTC().AddDate(-1, 0, 0).Format("2006-01-02"),
-			},
-		},
-	}
-
-	entries, notes, err := handler.Search(context.Background(), meta, "RTF")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 0 {
-		t.Fatalf("expected no entries, got %d", len(entries))
-	}
-	reason, ok := parseSkipReason(notes)
-	if !ok {
-		t.Fatalf("expected skip reason, got %#v", notes)
-	}
-	if !strings.Contains(strings.ToLower(reason), "10 years") {
-		t.Fatalf("unexpected skip reason %q", reason)
-	}
-	if called {
-		t.Fatalf("request should not have been made")
-	}
-}
diff --git a/internal/dupechecking/service.go b/internal/dupechecking/service.go
deleted file mode 100644
index e401cbdb..00000000
--- a/internal/dupechecking/service.go
+++ /dev/null
@@ -1,563 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Package dupechecking runs tracker-specific duplicate searches and converts
-// the results into upload review state.
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	trackerspkg "github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const maxDupeWorkers = 4
-const defaultDupeCancelDrainTimeout = 5 * time.Second
-const (
-	skipCodeNotePrefix = "\x00upbrr-skip-code:"
-	skipCodeNoteSuffix = "\x00"
-)
-
-// Service coordinates duplicate checks across configured tracker handlers.
-type Service struct {
-	cfg      config.Config
-	logger   api.Logger
-	http     *http.Client
-	tracker  *trackerdata.Client
-	banned   *trackerspkg.BannedGroupChecker
-	handlers map[string]searchHandler
-	filter   func([]api.DupeEntry, api.PreparedMetadata, string, config.Config, api.Logger) ([]api.DupeEntry, api.DupeMatch)
-
-	cancelDrainTimeout time.Duration
-}
-
-// NewService builds a duplicate-checking service with shared HTTP and tracker
-// metadata clients.
-func NewService(cfg config.Config, logger api.Logger) *Service {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	httpClient := &http.Client{Timeout: 20 * time.Second}
-	trackerClient := trackerdata.NewClient(cfg, logger, httpClient)
-	deps := handlerDeps{cfg: cfg, logger: logger, http: httpClient, tracker: trackerClient}
-	return &Service{
-		cfg:      cfg,
-		logger:   logger,
-		http:     httpClient,
-		tracker:  trackerClient,
-		banned:   trackerspkg.NewBannedGroupChecker(cfg.MainSettings.DBPath),
-		handlers: buildHandlers(deps),
-		filter:   FilterDupes,
-
-		cancelDrainTimeout: defaultDupeCancelDrainTimeout,
-	}
-}
-
-// Check searches the requested trackers for duplicates of meta.SourcePath.
-// Missing source paths return an error, an empty tracker list returns a summary
-// note, and context cancellation stops queued work, waits briefly for active
-// workers, and returns a cancellation error instead of a partial summary.
-// Trackers blocked by rule failures or banned release groups are returned as
-// skipped results without running the tracker search handler. Per-tracker rule
-// skips remain terminal over banned-group skips in the returned result.
-// When meta has an effective release group, Check refreshes dynamic banned
-// group caches before per-tracker rule skips so the once-per-TTL cache
-// maintenance still runs for the requested tracker set.
-// Progress callback panics are logged and do not abort the duplicate check.
-func (s *Service) Check(ctx context.Context, meta api.PreparedMetadata, trackers []string) (api.DupeCheckSummary, error) {
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		return api.DupeCheckSummary{}, errors.New("dupechecking: missing source path")
-	}
-	summary := api.DupeCheckSummary{SourcePath: meta.SourcePath}
-	resolvedTrackers := dedupeTrackers(trackers)
-	if len(resolvedTrackers) == 0 {
-		summary.Notes = append(summary.Notes, "no trackers configured for dupe checking")
-		s.logger.Infof("dupechecking: no trackers configured for %s", meta.SourcePath)
-		return summary, nil
-	}
-	if trackerspkg.NormalizeBannedReleaseGroup(meta.Tag) != "" {
-		// RefreshDynamic is cache maintenance for the resolved tracker set, not
-		// per-tracker search work; keep it before terminal rule-skip handling.
-		if err := s.banned.RefreshDynamic(ctx, s.cfg, resolvedTrackers, s.logger); err != nil {
-			return api.DupeCheckSummary{}, fmt.Errorf("dupechecking: banned groups refresh: %w", err)
-		}
-	}
-
-	total := len(resolvedTrackers)
-	for _, tracker := range resolvedTrackers {
-		s.emitDupeProgress(ctx, api.DupeProgressUpdate{
-			SourcePath: meta.SourcePath,
-			Tracker:    tracker,
-			Status:     "queued",
-			Message:    "queued",
-			Completed:  0,
-			Total:      total,
-		})
-	}
-
-	jobs := make(chan string)
-	results := make(chan api.DupeCheckResult, total)
-	workerCount := min(total, maxDupeWorkers)
-
-	var workers sync.WaitGroup
-	for range workerCount {
-		workers.Go(func() {
-			for tracker := range jobs {
-				if ctx.Err() != nil {
-					return
-				}
-				s.emitDupeProgress(ctx, api.DupeProgressUpdate{
-					SourcePath: meta.SourcePath,
-					Tracker:    tracker,
-					Status:     "running",
-					Message:    "searching",
-					Total:      total,
-				})
-				results <- s.checkTracker(ctx, meta, tracker)
-			}
-		})
-	}
-	workersDone := make(chan struct{})
-	go func() {
-		workers.Wait()
-		close(workersDone)
-	}()
-
-	go func() {
-		defer close(jobs)
-		for _, tracker := range resolvedTrackers {
-			select {
-			case <-ctx.Done():
-				return
-			case jobs <- tracker:
-			}
-		}
-	}()
-
-	completed := 0
-	for completed < total {
-		select {
-		case <-ctx.Done():
-			s.waitForCanceledDupeWorkers(workersDone, meta.SourcePath)
-			return api.DupeCheckSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-		case result := <-results:
-			if ctx.Err() != nil {
-				s.waitForCanceledDupeWorkers(workersDone, meta.SourcePath)
-				return api.DupeCheckSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-			}
-			completed++
-			summary.Results = append(summary.Results, result)
-			s.emitDupeProgress(ctx, api.DupeProgressUpdate{
-				SourcePath: meta.SourcePath,
-				Tracker:    result.Tracker,
-				Status:     result.Status,
-				Message:    dupeProgressMessage(result),
-				Completed:  completed,
-				Total:      total,
-				Result:     result,
-			})
-		}
-	}
-
-	<-workersDone
-	summary.Results = groupRuleSkippedResults(summary.Results)
-	sort.Slice(summary.Results, func(i, j int) bool {
-		return summary.Results[i].Tracker < summary.Results[j].Tracker
-	})
-
-	return summary, nil
-}
-
-// waitForCanceledDupeWorkers joins canceled duplicate-check workers up to the
-// configured drain timeout so ctx-ignoring handlers cannot delay cancellation
-// indefinitely.
-func (s *Service) waitForCanceledDupeWorkers(workersDone <-chan struct{}, sourcePath string) {
-	timeout := s.cancelDrainTimeout
-	if timeout <= 0 {
-		timeout = defaultDupeCancelDrainTimeout
-	}
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-
-	select {
-	case <-workersDone:
-	case <-timer.C:
-		if s.logger != nil {
-			s.logger.Warnf("dupechecking: timed out waiting for canceled workers for %s", sourcePath)
-		}
-	}
-}
-
-func (s *Service) emitDupeProgress(ctx context.Context, update api.DupeProgressUpdate) {
-	defer func() {
-		if recovered := recover(); recovered != nil && s.logger != nil {
-			s.logger.Warnf("dupechecking: progress reporter panicked for %s %s: %s", update.Tracker, update.Status, panicProgressMessage(recovered))
-		}
-	}()
-	api.EmitDupeProgress(ctx, update)
-}
-
-func (s *Service) checkTracker(ctx context.Context, meta api.PreparedMetadata, tracker string) (result api.DupeCheckResult) {
-	result = api.DupeCheckResult{Tracker: tracker, CheckedAt: time.Now().UTC(), Status: "completed"}
-	defer func() {
-		if recovered := recover(); recovered != nil {
-			message := panicFailureMessage(recovered)
-			result = api.DupeCheckResult{
-				Tracker:   tracker,
-				CheckedAt: result.CheckedAt,
-				Status:    "failed",
-				Error:     message,
-				Notes:     []string{message},
-			}
-			s.logger.Warnf("dupechecking: %s search panicked for %s: %s", tracker, meta.SourcePath, message)
-		}
-	}()
-
-	if reason, rules := skipReason(meta, tracker); reason != "" {
-		result.Skipped = true
-		result.SkipReason = reason
-		result.SkipRules = rules
-		result.Status = "skipped"
-		result.Notes = append(result.Notes, reason)
-		s.logger.Debugf("dupechecking: skipped %s for %s due to rules: %s", tracker, meta.SourcePath, reason)
-		return result
-	}
-
-	if reason, err := s.bannedGroupSkipReason(tracker, meta.Tag); reason != "" || err != nil {
-		if err != nil {
-			message := bannedGroupCheckFailureMessage(err)
-			result.Status = "failed"
-			result.Error = message
-			result.Notes = append(result.Notes, message)
-			s.logger.Warnf("dupechecking: %s banned group check failed for %s: %s", tracker, meta.SourcePath, redaction.RedactValue(err.Error(), nil))
-			return result
-		}
-		result.Skipped = true
-		result.SkipReason = reason
-		result.SkipCode = "banned_group"
-		result.Status = "skipped"
-		result.Notes = append(result.Notes, reason)
-		s.logger.Debugf("dupechecking: skipped %s for %s due to banned group: %s", tracker, meta.SourcePath, reason)
-		return result
-	}
-
-	handler, ok := s.handlers[tracker]
-	if !ok {
-		reason := handlerNotImplementedReason(tracker)
-		result.Skipped = true
-		result.SkipReason = reason
-		result.Status = "skipped"
-		result.Notes = append(result.Notes, reason)
-		s.logger.Warnf("dupechecking: no handler for %s (%s)", tracker, meta.SourcePath)
-		return result
-	}
-
-	raw, notes, err := handler.Search(ctx, meta, tracker)
-	if err != nil {
-		message := strings.TrimSpace(logging.SanitizeMessage(err.Error()))
-		if message == "" {
-			message = "dupe search failed"
-		}
-		result.Status = "failed"
-		result.Error = message
-		result.Notes = append(result.Notes, "dupe search failed: "+message)
-		s.logger.Warnf("dupechecking: %s search failed for %s: %s", tracker, meta.SourcePath, message)
-		return result
-	}
-	skipCode, notes := splitSkipCodeNotes(notes)
-	if reason, ok := parseSkipReason(notes); ok {
-		result.Skipped = true
-		result.SkipReason = reason
-		result.SkipCode = skipCode
-		result.Status = "skipped"
-	}
-	result.Notes = append(result.Notes, notes...)
-	result.Raw = trimEntries(raw)
-	if result.Skipped {
-		s.logger.Debugf("dupechecking: handler marked skipped for %s (%s): %s", tracker, meta.SourcePath, result.SkipReason)
-		return result
-	}
-
-	filter := s.filter
-	if filter == nil {
-		filter = FilterDupes
-	}
-	filtered, match := filter(result.Raw, meta, tracker, s.cfg, s.logger)
-	result.Filtered = filtered
-	result.Match = match
-	result.HasDupes = len(filtered) > 0
-	s.logger.Debugf("dupechecking: %s checked for %s raw=%d filtered=%d dupes=%t", tracker, meta.SourcePath, len(result.Raw), len(filtered), result.HasDupes)
-	return result
-}
-
-// bannedGroupSkipReason reports the skip reason for tracker when the normalized
-// tag resolves to a banned release group. Cache read failures are returned for
-// the caller to expose as a failed tracker result.
-func (s *Service) bannedGroupSkipReason(tracker string, tag string) (string, error) {
-	group := trackerspkg.NormalizeBannedReleaseGroup(tag)
-	if group == "" {
-		return "", nil
-	}
-	banned, err := s.banned.IsBanned(tracker, group)
-	if err != nil {
-		return "", fmt.Errorf("dupechecking: %s banned group: %w", normalizeTracker(tracker), err)
-	}
-	if !banned {
-		return "", nil
-	}
-	return fmt.Sprintf("group %s is banned on %s", group, normalizeTracker(tracker)), nil
-}
-
-func panicFailureMessage(recovered any) string {
-	detail := strings.TrimSpace(redaction.RedactValue(fmt.Sprint(recovered), nil))
-	if detail == "" {
-		return "dupe search panicked"
-	}
-	return "dupe search panicked: " + detail
-}
-
-func bannedGroupCheckFailureMessage(err error) string {
-	detail := strings.TrimSpace(redaction.RedactValue(err.Error(), nil))
-	if detail == "" {
-		detail = "unknown error"
-	}
-	return "banned group check failed: " + detail + "; mode=non-interactive dupe check; action=fix banned-group cache or dynamic banned-group configuration, then retry"
-}
-
-func panicProgressMessage(recovered any) string {
-	detail := strings.TrimSpace(redaction.RedactValue(fmt.Sprint(recovered), nil))
-	if detail == "" {
-		return "dupe progress reporter panicked"
-	}
-	return "dupe progress reporter panicked: " + detail
-}
-
-func noteSkipCode(code string) string {
-	return skipCodeNotePrefix + strings.TrimSpace(code) + skipCodeNoteSuffix
-}
-
-// splitSkipCodeNotes extracts trusted internal skip-code metadata and leaves
-// handler display notes intact.
-func splitSkipCodeNotes(notes []string) (string, []string) {
-	if len(notes) == 0 {
-		return "", nil
-	}
-	out := make([]string, 0, len(notes))
-	var code string
-	for _, note := range notes {
-		skipCode, ok := parseSkipCodeNote(note)
-		if ok {
-			if code == "" {
-				code = skipCode
-			}
-			continue
-		}
-		out = append(out, note)
-	}
-	return code, out
-}
-
-// parseSkipCodeNote accepts only the NUL-wrapped internal marker so tracker
-// notes that merely begin with similar text stay user-visible.
-func parseSkipCodeNote(note string) (string, bool) {
-	if !strings.HasPrefix(note, skipCodeNotePrefix) || !strings.HasSuffix(note, skipCodeNoteSuffix) {
-		return "", false
-	}
-	code := strings.TrimSuffix(strings.TrimPrefix(note, skipCodeNotePrefix), skipCodeNoteSuffix)
-	return strings.TrimSpace(code), true
-}
-
-func dedupeTrackers(trackers []string) []string {
-	if len(trackers) == 0 {
-		return nil
-	}
-	resolved := make([]string, 0, len(trackers))
-	seen := make(map[string]struct{}, len(trackers))
-	for _, trackerName := range trackers {
-		tracker := normalizeTracker(trackerName)
-		if tracker == "" {
-			continue
-		}
-		if _, ok := seen[tracker]; ok {
-			continue
-		}
-		seen[tracker] = struct{}{}
-		resolved = append(resolved, tracker)
-	}
-	return resolved
-}
-
-func dupeProgressMessage(result api.DupeCheckResult) string {
-	switch result.Status {
-	case "failed":
-		if strings.TrimSpace(result.Error) != "" {
-			return result.Error
-		}
-		return "dupe search failed"
-	case "skipped":
-		if strings.TrimSpace(result.SkipReason) != "" {
-			return result.SkipReason
-		}
-		return "skipped"
-	default:
-		if result.HasDupes {
-			return fmt.Sprintf("%d dupes found", len(result.Filtered))
-		}
-		return "no dupes found"
-	}
-}
-
-type groupedResult struct {
-	result api.DupeCheckResult
-	used   map[int]struct{}
-}
-
-func groupRuleSkippedResults(results []api.DupeCheckResult) []api.DupeCheckResult {
-	if len(results) < 2 {
-		return results
-	}
-
-	groupedByRule, groupedByReason := collectRuleSkipGroups(results)
-	ruleCombined, indexesInCombinedRule := buildRuleGroupedResults(results, groupedByRule)
-	reasonCombined := buildReasonGroupedResults(results, groupedByReason)
-	combined := append(append([]groupedResult(nil), ruleCombined...), reasonCombined...)
-
-	out := make([]api.DupeCheckResult, 0, len(results))
-	consumedByReason := make(map[int]struct{}, len(results))
-	for _, entry := range combined {
-		out = append(out, entry.result)
-		for idx := range entry.used {
-			consumedByReason[idx] = struct{}{}
-		}
-	}
-
-	for idx, result := range results {
-		reason := strings.TrimSpace(result.SkipReason)
-		if !result.Skipped || !isRuleFailureReason(reason) {
-			out = append(out, result)
-			continue
-		}
-		if _, groupedByRule := indexesInCombinedRule[idx]; groupedByRule {
-			continue
-		}
-		if _, groupedByReason := consumedByReason[idx]; groupedByReason {
-			continue
-		}
-		out = append(out, result)
-	}
-
-	return out
-}
-
-func collectRuleSkipGroups(results []api.DupeCheckResult) (map[string][]int, map[string][]int) {
-	groupedByRule := make(map[string][]int)
-	groupedByReason := make(map[string][]int)
-	for idx, result := range results {
-		reason := strings.TrimSpace(result.SkipReason)
-		if !result.Skipped || !isRuleFailureReason(reason) {
-			continue
-		}
-		if len(result.SkipRules) > 0 {
-			for _, rule := range result.SkipRules {
-				key := strings.ToLower(strings.TrimSpace(rule))
-				if key == "" {
-					continue
-				}
-				groupedByRule[key] = append(groupedByRule[key], idx)
-			}
-			continue
-		}
-		key := strings.ToLower(reason)
-		groupedByReason[key] = append(groupedByReason[key], idx)
-	}
-	return groupedByRule, groupedByReason
-}
-
-func buildRuleGroupedResults(results []api.DupeCheckResult, groupedByRule map[string][]int) ([]groupedResult, map[int]struct{}) {
-	combined := make([]groupedResult, 0, len(groupedByRule))
-	indexesInCombinedRule := make(map[int]struct{}, len(results))
-	for _, rule := range sortedStringKeys(groupedByRule) {
-		group := uniqueSortedIndexes(groupedByRule[rule])
-		if len(group) < 2 {
-			continue
-		}
-		for _, idx := range group {
-			indexesInCombinedRule[idx] = struct{}{}
-		}
-		base := results[group[0]]
-		base.Tracker = strings.Join(trackersForIndexes(results, group), ", ")
-		base.SkipRules = []string{rule}
-		combined = append(combined, groupedResult{result: base, used: indexSliceToSet(group)})
-	}
-	return combined, indexesInCombinedRule
-}
-
-func buildReasonGroupedResults(results []api.DupeCheckResult, groupedByReason map[string][]int) []groupedResult {
-	combined := make([]groupedResult, 0, len(groupedByReason))
-	for _, reason := range sortedStringKeys(groupedByReason) {
-		group := uniqueSortedIndexes(groupedByReason[reason])
-		if len(group) < 2 {
-			continue
-		}
-		base := results[group[0]]
-		base.Tracker = strings.Join(trackersForIndexes(results, group), ", ")
-		combined = append(combined, groupedResult{result: base, used: indexSliceToSet(group)})
-	}
-	return combined
-}
-
-func uniqueSortedIndexes(indexes []int) []int {
-	out := make([]int, 0, len(indexes))
-	seen := make(map[int]struct{}, len(indexes))
-	for _, idx := range indexes {
-		if _, ok := seen[idx]; ok {
-			continue
-		}
-		seen[idx] = struct{}{}
-		out = append(out, idx)
-	}
-	sort.Ints(out)
-	return out
-}
-
-func trackersForIndexes(results []api.DupeCheckResult, indexes []int) []string {
-	trackers := make([]string, 0, len(indexes))
-	for _, idx := range indexes {
-		trackers = append(trackers, strings.TrimSpace(results[idx].Tracker))
-	}
-	sort.Strings(trackers)
-	return trackers
-}
-
-func sortedStringKeys(values map[string][]int) []string {
-	keys := make([]string, 0, len(values))
-	for key := range values {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-func indexSliceToSet(indexes []int) map[int]struct{} {
-	set := make(map[int]struct{}, len(indexes))
-	for _, idx := range indexes {
-		set[idx] = struct{}{}
-	}
-	return set
-}
-
-func isRuleFailureReason(reason string) bool {
-	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(reason)), "rule check failed")
-}
diff --git a/internal/dupechecking/service_test.go b/internal/dupechecking/service_test.go
deleted file mode 100644
index 8c19ec66..00000000
--- a/internal/dupechecking/service_test.go
+++ /dev/null
@@ -1,1105 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type testSearchHandler struct {
-	delay      time.Duration
-	entries    []api.DupeEntry
-	notes      []string
-	err        error
-	panicValue any
-}
-
-func (h testSearchHandler) Search(ctx context.Context, _ api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	if h.panicValue != nil {
-		panic(h.panicValue)
-	}
-	if h.delay > 0 {
-		select {
-		case <-ctx.Done():
-			return nil, nil, fmt.Errorf("context canceled: %w", ctx.Err())
-		case <-time.After(h.delay):
-		}
-	}
-	if h.err != nil {
-		return nil, nil, h.err
-	}
-	return h.entries, h.notes, nil
-}
-
-type searchHandlerFunc func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error)
-
-func (f searchHandlerFunc) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	return f(ctx, meta, tracker)
-}
-
-type recordingLogger struct {
-	api.NopLogger
-	mu    sync.Mutex
-	warns []string
-}
-
-func (l *recordingLogger) Warnf(format string, args ...any) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	l.warns = append(l.warns, fmt.Sprintf(format, args...))
-}
-
-func TestCheckMissingSourcePath(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	_, err := svc.Check(context.Background(), api.PreparedMetadata{}, []string{"AITHER"})
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-}
-
-func TestCheckNoTrackers(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x"}, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Notes) == 0 {
-		t.Fatalf("expected summary note")
-	}
-}
-
-func TestCheckRedactsSearchErrorsFromResultProgressAndLogs(t *testing.T) {
-	t.Parallel()
-
-	logger := &recordingLogger{}
-	svc := NewService(config.Config{}, logger)
-	svc.handlers = map[string]searchHandler{
-		"DP": testSearchHandler{err: errors.New(`unit3d: request: Get "https://tracker.example/api/torrents/filter?api_token=secret-api-token&name=Example.Release.2026.1080p-GRP": context deadline exceeded`)},
-	}
-
-	var updatesMu sync.Mutex
-	updates := make([]api.DupeProgressUpdate, 0, 3)
-	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		updatesMu.Lock()
-		updates = append(updates, update)
-		updatesMu.Unlock()
-	})
-
-	summary, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: `D:\media\Example's.Release.2026-GRP`}, []string{"DP"})
-	if err != nil {
-		t.Fatalf("check dupes: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected one result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if strings.Contains(result.Error, "secret-api-token") || strings.Contains(strings.Join(result.Notes, " "), "secret-api-token") {
-		t.Fatal("expected dupe result error details to redact request secret")
-	}
-	if !strings.Contains(result.Error, "api_token=[REDACTED]") {
-		t.Fatal("expected dupe result to preserve redacted request context")
-	}
-
-	updatesMu.Lock()
-	capturedUpdates := slices.Clone(updates)
-	updatesMu.Unlock()
-	foundFailed := false
-	for _, update := range capturedUpdates {
-		if strings.Contains(update.Message, "secret-api-token") || strings.Contains(update.Result.Error, "secret-api-token") {
-			t.Fatal("expected dupe progress to redact request secret")
-		}
-		if update.Status == "failed" {
-			foundFailed = true
-			if !strings.Contains(update.Message, "api_token=[REDACTED]") {
-				t.Fatal("expected failed progress to preserve redacted request context")
-			}
-		}
-	}
-	if !foundFailed {
-		t.Fatal("expected failed dupe progress update")
-	}
-
-	logger.mu.Lock()
-	warns := slices.Clone(logger.warns)
-	logger.mu.Unlock()
-	if strings.Contains(strings.Join(warns, " "), "secret-api-token") {
-		t.Fatal("expected dupe warning to redact request secret before logger boundary")
-	}
-}
-
-func TestCheckSkipsRuleFailures(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "require_unique_id", Reason: "missing MediaInfo Unique ID"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if !result.Skipped {
-		t.Fatalf("expected skipped result")
-	}
-	if result.SkipReason == "" {
-		t.Fatalf("expected skip reason")
-	}
-	if strings.Contains(strings.Join(result.Notes, " "), "api_key") {
-		t.Fatalf("expected skipped tracker to bypass API checks")
-	}
-}
-
-func TestCheckRuleSkipTakesPrecedenceOverBannedGroup(t *testing.T) {
-	t.Parallel()
-
-	svc := NewService(config.Config{}, api.NopLogger{})
-	called := false
-	svc.handlers = map[string]searchHandler{
-		"DP": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			called = true
-			return nil, nil, nil
-		}),
-	}
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		Tag:        "-FGT",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"DP": {{Rule: "example_rule", Reason: "example rule failure"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"DP"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if called {
-		t.Fatalf("expected terminal skip before tracker search")
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if !result.Skipped || result.Status != "skipped" {
-		t.Fatalf("expected skipped result, got %#v", result)
-	}
-	if result.SkipCode == "banned_group" {
-		t.Fatalf("expected rule skip to take precedence over banned group, got %#v", result)
-	}
-	if len(result.SkipRules) != 1 || result.SkipRules[0] != "example_rule" {
-		t.Fatalf("expected rule skip metadata, got %#v", result)
-	}
-	if !strings.Contains(result.SkipReason, "example rule failure") {
-		t.Fatalf("expected rule skip reason, got %q", result.SkipReason)
-	}
-}
-
-func TestCheckSkipsClaimRuleFailures(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"BTN": {{Rule: "claim_active", Reason: "BTN has an active claim for this release; approximately 11 hours remain in the 48-hour claim window"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"BTN"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if !result.Skipped {
-		t.Fatalf("expected skipped result")
-	}
-	if !strings.Contains(result.SkipReason, "active claim") {
-		t.Fatalf("expected claim skip reason, got %q", result.SkipReason)
-	}
-	if !strings.Contains(result.SkipReason, "11 hours remain") {
-		t.Fatalf("expected hours remaining in skip reason, got %q", result.SkipReason)
-	}
-	if len(result.SkipRules) != 1 || result.SkipRules[0] != "claim_active" {
-		t.Fatalf("expected claim_active skip rule, got %#v", result.SkipRules)
-	}
-}
-
-func TestCheckSkipsBannedGroupBeforeSearch(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")},
-	}
-	svc := NewService(cfg, api.NopLogger{})
-	called := false
-	svc.handlers = map[string]searchHandler{
-		"DP": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			called = true
-			return []api.DupeEntry{{Name: "Example.Release.2026.1080p-GRP"}}, nil, nil
-		}),
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x", Tag: "-FGT"}, []string{"DP"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if called {
-		t.Fatalf("expected banned group to skip before tracker search")
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if !result.Skipped || result.Status != "skipped" {
-		t.Fatalf("expected skipped banned-group result, got %#v", result)
-	}
-	if result.SkipCode != "banned_group" {
-		t.Fatalf("expected banned_group skip code, got %q", result.SkipCode)
-	}
-	if result.SkipReason != "group fgt is banned on DP" {
-		t.Fatalf("expected banned-group reason, got %q", result.SkipReason)
-	}
-}
-
-func TestCheckDoesNotCollapseUnrelatedTAoESubstringGroup(t *testing.T) {
-	t.Parallel()
-
-	svc := NewService(config.Config{}, api.NopLogger{})
-	called := false
-	svc.handlers = map[string]searchHandler{
-		"DP": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			called = true
-			return nil, nil, nil
-		}),
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x", Tag: "-NotTAoE"}, []string{"DP"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !called {
-		t.Fatalf("expected unrelated TAoE substring group to reach tracker search")
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if result.Skipped || result.SkipCode == "banned_group" {
-		t.Fatalf("expected unskipped result for unrelated TAoE substring, got %#v", result)
-	}
-}
-
-func TestCheckRefreshesDynamicBannedGroupsBeforeSearch(t *testing.T) {
-	var requests int
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requests++
-		if got := r.URL.Path; got != "/api/blacklists/releasegroups" {
-			t.Errorf("unexpected path %q", got)
-			return
-		}
-		if got := r.Header.Get("Authorization"); got != "Bearer aither-key" {
-			t.Error("unexpected auth header")
-			return
-		}
-		_, _ = w.Write([]byte(`{"data":[{"name":"GRP"}],"meta":{"next_cursor":""}}`))
-	}))
-	defer server.Close()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
-			},
-		},
-	}
-	svc := NewService(cfg, api.NopLogger{})
-	called := false
-	svc.handlers = map[string]searchHandler{
-		"AITHER": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			called = true
-			return []api.DupeEntry{{Name: "Example.Release.2026.1080p-GRP"}}, nil, nil
-		}),
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x", Tag: "-GRP"}, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if requests != 1 {
-		t.Fatalf("expected banned groups fetch, got %d requests", requests)
-	}
-	if called {
-		t.Fatalf("expected fetched banned group to skip before tracker search")
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if !result.Skipped || result.Status != "skipped" || result.SkipCode != "banned_group" {
-		t.Fatalf("expected banned group skip, got %#v", result)
-	}
-	if result.SkipReason != "group grp is banned on AITHER" {
-		t.Fatalf("expected dynamic banned-group reason, got %q", result.SkipReason)
-	}
-}
-
-func TestCheckSkipsDynamicBannedRefreshForEmptyEffectiveGroup(t *testing.T) {
-	t.Parallel()
-
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		_, _ = w.Write([]byte(`{"data":[],"meta":{"next_cursor":""}}`))
-	}))
-	defer server.Close()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
-			},
-		},
-	}
-	svc := NewService(cfg, api.NopLogger{})
-	called := false
-	svc.handlers = map[string]searchHandler{
-		"AITHER": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			called = true
-			return nil, nil, nil
-		}),
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x", Tag: "-"}, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got := requests.Load(); got != 0 {
-		t.Fatalf("expected no dynamic banned refresh for empty effective group, got %d request(s)", got)
-	}
-	if !called {
-		t.Fatalf("expected tracker search to proceed")
-	}
-	if len(summary.Results) != 1 || summary.Results[0].Skipped {
-		t.Fatalf("expected unskipped result, got %#v", summary.Results)
-	}
-}
-
-func TestCheckBannedGroupFailureIncludesModeAndAction(t *testing.T) {
-	t.Parallel()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
-	}
-	svc := NewService(cfg, api.NopLogger{})
-
-	cachePath := filepath.Join(tempDir, "cache", "banned", "RHD_banned_groups.json")
-	if err := os.MkdirAll(filepath.Dir(cachePath), 0o700); err != nil {
-		t.Fatalf("create banned cache dir: %v", err)
-	}
-	if err := os.Mkdir(cachePath, 0o700); err != nil {
-		t.Fatalf("create unreadable banned cache path: %v", err)
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x", Tag: "-CustomRHD"}, []string{"RHD"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if result.Status != "failed" {
-		t.Fatalf("expected failed status, got %#v", result)
-	}
-	assertBannedGroupFailureMessage(t, result.Error)
-	if len(result.Notes) != 1 {
-		t.Fatalf("expected one failure note, got %#v", result.Notes)
-	}
-	assertBannedGroupFailureMessage(t, result.Notes[0])
-}
-
-func assertBannedGroupFailureMessage(t *testing.T, message string) {
-	t.Helper()
-	for _, want := range []string{
-		"banned group check failed:",
-		"read banned groups",
-		"mode=non-interactive dupe check",
-		"action=fix banned-group cache or dynamic banned-group configuration, then retry",
-	} {
-		if !strings.Contains(message, want) {
-			t.Fatalf("expected failure message to contain %q, got %q", want, message)
-		}
-	}
-}
-
-func TestCheckUnsupportedTrackerMarkedSkipped(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x"}, []string{"UNKNOWN"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected one result")
-	}
-	result := summary.Results[0]
-	if !result.Skipped {
-		t.Fatalf("expected skipped")
-	}
-	if !strings.Contains(strings.ToLower(result.SkipReason), "not implemented") {
-		t.Fatalf("expected not implemented reason, got %q", result.SkipReason)
-	}
-}
-
-func TestCheckTrackerFailureDoesNotAbortWholeSummary(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{err: errors.New("boom")},
-		"BLU":    testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER", "BLU"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(summary.Results))
-	}
-
-	byTracker := make(map[string]api.DupeCheckResult, len(summary.Results))
-	for _, result := range summary.Results {
-		byTracker[result.Tracker] = result
-	}
-
-	failed, ok := byTracker["AITHER"]
-	if !ok {
-		t.Fatalf("missing AITHER result")
-	}
-	if failed.Status != "failed" {
-		t.Fatalf("expected failed status, got %q", failed.Status)
-	}
-	if failed.Error == "" {
-		t.Fatalf("expected tracker error")
-	}
-
-	success, ok := byTracker["BLU"]
-	if !ok {
-		t.Fatalf("missing BLU result")
-	}
-	if success.Status != "completed" {
-		t.Fatalf("expected completed status, got %q", success.Status)
-	}
-}
-
-func TestCheckCancelWaitsForInFlightWorkerBeforeReturning(t *testing.T) {
-	svc := NewService(config.Config{}, api.NopLogger{})
-	started := make(chan struct{})
-	release := make(chan struct{})
-	svc.handlers = map[string]searchHandler{
-		"AITHER": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			close(started)
-			<-release
-			return []api.DupeEntry{{Name: "release"}}, nil, nil
-		}),
-	}
-
-	var mu sync.Mutex
-	updates := make([]api.DupeProgressUpdate, 0)
-	progressCtx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		mu.Lock()
-		updates = append(updates, update)
-		mu.Unlock()
-	})
-	ctx, cancel := context.WithCancel(progressCtx)
-
-	returned := make(chan error, 1)
-	go func() {
-		_, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER"})
-		returned <- err
-	}()
-
-	<-started
-	cancel()
-
-	select {
-	case err := <-returned:
-		t.Fatalf("Check returned before active worker finished: %v", err)
-	case <-time.After(50 * time.Millisecond):
-	}
-
-	close(release)
-	select {
-	case err := <-returned:
-		if err == nil || !strings.Contains(err.Error(), "context canceled") {
-			t.Fatalf("expected cancellation error after worker finished, got %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatalf("Check did not return after active worker finished")
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	for _, update := range updates {
-		if update.Tracker == "AITHER" && update.Status == "completed" {
-			t.Fatalf("expected no terminal progress after cancellation, got %+v", updates)
-		}
-	}
-}
-
-func TestCheckCancelWorkerWaitIsBounded(t *testing.T) {
-	logger := &recordingLogger{}
-	svc := NewService(config.Config{}, logger)
-	svc.cancelDrainTimeout = 20 * time.Millisecond
-	started := make(chan struct{})
-	release := make(chan struct{})
-	svc.handlers = map[string]searchHandler{
-		"AITHER": searchHandlerFunc(func(context.Context, api.PreparedMetadata, string) ([]api.DupeEntry, []string, error) {
-			close(started)
-			<-release
-			return []api.DupeEntry{{Name: "release"}}, nil, nil
-		}),
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	returned := make(chan error, 1)
-	go func() {
-		_, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER"})
-		returned <- err
-	}()
-
-	<-started
-	cancel()
-
-	select {
-	case err := <-returned:
-		if err == nil || !strings.Contains(err.Error(), "context canceled") {
-			t.Fatalf("expected cancellation error, got %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatalf("Check did not return after cancel drain timeout")
-	}
-	close(release)
-
-	logger.mu.Lock()
-	warns := strings.Join(logger.warns, "\n")
-	logger.mu.Unlock()
-	if !strings.Contains(warns, "timed out waiting for canceled workers") {
-		t.Fatalf("expected bounded wait warning, got %q", warns)
-	}
-}
-
-func TestCheckContainsHandlerPanicAsFailedTrackerResult(t *testing.T) {
-	t.Parallel()
-	secret := "0123456789abcdef0123456789abcdef"
-	logger := &recordingLogger{}
-	svc := NewService(config.Config{}, logger)
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{panicValue: "handler token=" + secret},
-		"BLU":    testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-	}
-
-	var mu sync.Mutex
-	updates := make([]api.DupeProgressUpdate, 0)
-	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		mu.Lock()
-		updates = append(updates, update)
-		mu.Unlock()
-	})
-
-	summary, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER", "BLU"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(summary.Results))
-	}
-
-	failed, ok := findResultByTracker(summary.Results, "AITHER")
-	if !ok {
-		t.Fatalf("missing AITHER result")
-	}
-	assertPanicFailureResult(t, failed, secret)
-
-	success, ok := findResultByTracker(summary.Results, "BLU")
-	if !ok {
-		t.Fatalf("missing BLU result")
-	}
-	if success.Status != "completed" {
-		t.Fatalf("expected sibling completed status, got %q", success.Status)
-	}
-
-	mu.Lock()
-	terminalFailed := false
-	for _, update := range updates {
-		if update.Tracker == "AITHER" && update.Status == "failed" && update.Result.Status == "failed" {
-			terminalFailed = true
-			break
-		}
-	}
-	mu.Unlock()
-	if !terminalFailed {
-		t.Fatalf("expected terminal failed progress for panicking tracker, got %+v", updates)
-	}
-
-	logger.mu.Lock()
-	warns := strings.Join(logger.warns, "\n")
-	logger.mu.Unlock()
-	if strings.Contains(warns, secret) {
-		t.Fatalf("expected panic log to redact secret, got %q", warns)
-	}
-	if !strings.Contains(warns, "[REDACTED]") {
-		t.Fatalf("expected redacted panic log detail, got %q", warns)
-	}
-}
-
-func TestCheckContainsFilterPanicAsFailedTrackerResult(t *testing.T) {
-	t.Parallel()
-	secret := "abcdefabcdefabcdefabcdefabcdefab"
-	svc := NewService(config.Config{}, api.NopLogger{})
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-		"BLU":    testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-	}
-	svc.filter = func(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker string, cfg config.Config, logger api.Logger) ([]api.DupeEntry, api.DupeMatch) {
-		if tracker == "AITHER" {
-			panic("filter api_token=" + secret)
-		}
-		return FilterDupes(dupes, meta, tracker, cfg, logger)
-	}
-
-	summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER", "BLU"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 results, got %d", len(summary.Results))
-	}
-
-	failed, ok := findResultByTracker(summary.Results, "AITHER")
-	if !ok {
-		t.Fatalf("missing AITHER result")
-	}
-	assertPanicFailureResult(t, failed, secret)
-
-	success, ok := findResultByTracker(summary.Results, "BLU")
-	if !ok {
-		t.Fatalf("missing BLU result")
-	}
-	if success.Status != "completed" {
-		t.Fatalf("expected sibling completed status, got %q", success.Status)
-	}
-}
-
-func TestCheckContainsRunningProgressReporterPanic(t *testing.T) {
-	t.Parallel()
-	secret := "0123456789abcdef0123456789abcdef"
-	logger := &recordingLogger{}
-	svc := NewService(config.Config{}, logger)
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-	}
-
-	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		if update.Status == "running" {
-			panic("progress token=" + secret)
-		}
-	})
-
-	summary, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if result.Status != "completed" {
-		t.Fatalf("expected completed result after reporter panic, got %#v", result)
-	}
-
-	logger.mu.Lock()
-	warns := strings.Join(logger.warns, "\n")
-	logger.mu.Unlock()
-	if !strings.Contains(warns, "progress reporter panicked") {
-		t.Fatalf("expected progress reporter panic warning, got %q", warns)
-	}
-	if strings.Contains(warns, secret) {
-		t.Fatalf("expected progress reporter warning to redact secret, got %q", warns)
-	}
-	if !strings.Contains(warns, "[REDACTED]") {
-		t.Fatalf("expected redacted progress reporter detail, got %q", warns)
-	}
-}
-
-func TestCheckContainsTerminalProgressReporterPanic(t *testing.T) {
-	t.Parallel()
-	logger := &recordingLogger{}
-	svc := NewService(config.Config{}, logger)
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{entries: []api.DupeEntry{{Name: "release"}}},
-	}
-
-	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		if update.Status == "completed" {
-			panic("terminal progress failed")
-		}
-	})
-
-	summary, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(summary.Results))
-	}
-	result := summary.Results[0]
-	if result.Status != "completed" || result.Tracker != "AITHER" {
-		t.Fatalf("expected completed AITHER result after terminal reporter panic, got %#v", result)
-	}
-
-	logger.mu.Lock()
-	warns := strings.Join(logger.warns, "\n")
-	logger.mu.Unlock()
-	if !strings.Contains(warns, "progress reporter panicked") {
-		t.Fatalf("expected terminal progress reporter panic warning, got %q", warns)
-	}
-}
-
-func TestCheckGroupsSkippedTrackersWithSameRuleFailure(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "require_unique_id", Reason: "missing MediaInfo Unique ID"}},
-			"BLU":    {{Rule: "require_unique_id", Reason: "missing MediaInfo Unique ID"}},
-			"HDB":    {{Rule: "require_bdinfo", Reason: "missing BDInfo summary"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"AITHER", "BLU", "HDB"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 grouped results, got %d", len(summary.Results))
-	}
-
-	combined, foundCombined := findResultByTracker(summary.Results, "AITHER, BLU")
-	if !foundCombined {
-		t.Fatalf("expected combined AITHER, BLU result")
-	}
-	if !combined.Skipped {
-		t.Fatalf("expected combined result to be skipped")
-	}
-	if !strings.Contains(combined.SkipReason, "missing MediaInfo Unique ID") {
-		t.Fatalf("expected combined skip reason to contain original failure, got %q", combined.SkipReason)
-	}
-
-	separate, foundSeparate := findResultByTracker(summary.Results, "HDB")
-	if !foundSeparate {
-		t.Fatalf("expected separate HDB result")
-	}
-	if !separate.Skipped {
-		t.Fatalf("expected HDB result to stay skipped")
-	}
-	if !strings.Contains(separate.SkipReason, "missing BDInfo summary") {
-		t.Fatalf("expected HDB reason to be preserved, got %q", separate.SkipReason)
-	}
-}
-
-func TestCheckGroupsSkippedTrackersByRuleKeyWhenReasonsDiffer(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"PTP": {{Rule: "require_movie_only", Reason: "tv content requires movie category"}},
-			"RF":  {{Rule: "require_movie_only", Reason: "category tv is not movie"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"PTP", "RF"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 1 {
-		t.Fatalf("expected 1 grouped result, got %d", len(summary.Results))
-	}
-	combined := summary.Results[0]
-	if combined.Tracker != "PTP, RF" {
-		t.Fatalf("expected combined tracker list, got %q", combined.Tracker)
-	}
-	if len(combined.SkipRules) != 1 || combined.SkipRules[0] != "require_movie_only" {
-		t.Fatalf("expected grouped skip rule key, got %#v", combined.SkipRules)
-	}
-	if combined.SkipCode != "" {
-		t.Fatalf("expected rule grouped result not to carry structured skip code, got %q", combined.SkipCode)
-	}
-}
-
-func TestCheckGroupsMultiRuleFailuresPerRuleKey(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {
-				{Rule: "require_movie_only", Reason: "tv category blocked"},
-				{Rule: "min_resolution", Reason: "resolution 720p below 1080p"},
-			},
-			"BLU": {{Rule: "require_movie_only", Reason: "not a movie category"}},
-			"HDB": {{Rule: "min_resolution", Reason: "requires 1080p minimum"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"AITHER", "BLU", "HDB"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 grouped results, got %d", len(summary.Results))
-	}
-
-	movieGroup, ok := findResultByTracker(summary.Results, "AITHER, BLU")
-	if !ok {
-		t.Fatalf("expected movie rule group")
-	}
-	if len(movieGroup.SkipRules) != 1 || movieGroup.SkipRules[0] != "require_movie_only" {
-		t.Fatalf("expected movie rule group key, got %#v", movieGroup.SkipRules)
-	}
-
-	resolutionGroup, ok := findResultByTracker(summary.Results, "AITHER, HDB")
-	if !ok {
-		t.Fatalf("expected resolution rule group")
-	}
-	if len(resolutionGroup.SkipRules) != 1 || resolutionGroup.SkipRules[0] != "min_resolution" {
-		t.Fatalf("expected resolution rule group key, got %#v", resolutionGroup.SkipRules)
-	}
-}
-
-func TestCheckGroupsANTAndNBLWithMatchingRuleKeys(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	meta := api.PreparedMetadata{
-		SourcePath: "/tmp/example",
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"ANT": {{Rule: "require_movie_only", Reason: "category tv is not movie"}},
-			"RF":  {{Rule: "require_movie_only", Reason: "category tv is not movie"}},
-			"NBL": {{Rule: "require_tv_only", Reason: "category movie is not tv"}},
-			"STC": {{Rule: "require_tv_only", Reason: "category movie is not tv"}},
-		},
-	}
-
-	summary, err := svc.Check(context.Background(), meta, []string{"ANT", "RF", "NBL", "STC"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(summary.Results) != 2 {
-		t.Fatalf("expected 2 grouped results, got %d", len(summary.Results))
-	}
-
-	movieGroup, ok := findResultByTracker(summary.Results, "ANT, RF")
-	if !ok {
-		t.Fatalf("expected movie rule group")
-	}
-	if len(movieGroup.SkipRules) != 1 || movieGroup.SkipRules[0] != "require_movie_only" {
-		t.Fatalf("expected require_movie_only key, got %#v", movieGroup.SkipRules)
-	}
-
-	tvGroup, ok := findResultByTracker(summary.Results, "NBL, STC")
-	if !ok {
-		t.Fatalf("expected tv rule group")
-	}
-	if len(tvGroup.SkipRules) != 1 || tvGroup.SkipRules[0] != "require_tv_only" {
-		t.Fatalf("expected require_tv_only key, got %#v", tvGroup.SkipRules)
-	}
-}
-
-func TestCheckPreservesVisibleSkipCodeMarkerNotes(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		notes       []string
-		wantCode    string
-		wantSkipped bool
-	}{
-		{
-			name:        "visible marker without metadata",
-			notes:       []string{"skip-code: tracker-visible note"},
-			wantCode:    "",
-			wantSkipped: false,
-		},
-		{
-			name:        "metadata plus visible skip reason",
-			notes:       []string{noteSkipCode("test_skip_code"), noteSkip("tracker skipped"), "skip-code: tracker-visible note"},
-			wantCode:    "test_skip_code",
-			wantSkipped: true,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			svc := NewService(config.Config{}, api.NopLogger{})
-			svc.handlers = map[string]searchHandler{
-				"AITHER": testSearchHandler{notes: tc.notes},
-			}
-
-			summary, err := svc.Check(context.Background(), api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER"})
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if len(summary.Results) != 1 {
-				t.Fatalf("expected 1 result, got %d", len(summary.Results))
-			}
-			result := summary.Results[0]
-			if result.SkipCode != tc.wantCode {
-				t.Fatalf("expected skip code %q, got %q", tc.wantCode, result.SkipCode)
-			}
-			if result.Skipped != tc.wantSkipped {
-				t.Fatalf("expected skipped=%t, got %#v", tc.wantSkipped, result)
-			}
-			if !slices.Contains(result.Notes, "skip-code: tracker-visible note") {
-				t.Fatalf("expected visible skip-code note to remain, got %#v", result.Notes)
-			}
-			for _, note := range result.Notes {
-				if strings.Contains(note, skipCodeNotePrefix) {
-					t.Fatalf("internal skip-code metadata leaked into display notes: %#v", result.Notes)
-				}
-			}
-		})
-	}
-}
-
-func TestCheckEmitsPerTrackerProgressUpdates(t *testing.T) {
-	t.Parallel()
-	svc := NewService(config.Config{}, api.NopLogger{})
-	svc.handlers = map[string]searchHandler{
-		"AITHER": testSearchHandler{delay: 15 * time.Millisecond},
-		"BLU":    testSearchHandler{delay: 15 * time.Millisecond},
-	}
-
-	var mu sync.Mutex
-	updates := make([]api.DupeProgressUpdate, 0)
-	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
-		mu.Lock()
-		updates = append(updates, update)
-		mu.Unlock()
-	})
-
-	_, err := svc.Check(ctx, api.PreparedMetadata{SourcePath: "x"}, []string{"AITHER", "BLU"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if len(updates) == 0 {
-		t.Fatalf("expected progress updates")
-	}
-
-	completedByTracker := make(map[string]bool)
-	for _, update := range updates {
-		if strings.EqualFold(update.Status, "completed") || strings.EqualFold(update.Status, "failed") || strings.EqualFold(update.Status, "skipped") {
-			completedByTracker[strings.ToUpper(strings.TrimSpace(update.Tracker))] = true
-		}
-	}
-	if !completedByTracker["AITHER"] || !completedByTracker["BLU"] {
-		t.Fatalf("expected terminal progress events for both trackers, got %+v", completedByTracker)
-	}
-}
-
-func TestSplitSkipCodeNotesOnlyRemovesInternalMetadata(t *testing.T) {
-	t.Parallel()
-
-	notes := []string{
-		noteSkipCode("test_skip_code"),
-		"skip-code: tracker-visible note",
-		"  SKIP-CODE: tracker-visible mixed case  ",
-		noteSkipCode("secondary_code"),
-	}
-
-	code, displayNotes := splitSkipCodeNotes(notes)
-	if code != "test_skip_code" {
-		t.Fatalf("expected first skip code %q, got %q", "test_skip_code", code)
-	}
-	if len(displayNotes) != 2 {
-		t.Fatalf("expected 2 display notes, got %#v", displayNotes)
-	}
-	if displayNotes[0] != "skip-code: tracker-visible note" {
-		t.Fatalf("expected visible marker note to remain, got %#v", displayNotes)
-	}
-	if displayNotes[1] != "  SKIP-CODE: tracker-visible mixed case  " {
-		t.Fatalf("expected mixed-case visible marker note to remain, got %#v", displayNotes)
-	}
-	for _, note := range displayNotes {
-		if strings.Contains(note, skipCodeNotePrefix) {
-			t.Fatalf("internal skip-code metadata leaked into display notes: %#v", displayNotes)
-		}
-	}
-}
-
-func findResultByTracker(results []api.DupeCheckResult, tracker string) (api.DupeCheckResult, bool) {
-	for _, result := range results {
-		if result.Tracker == tracker {
-			return result, true
-		}
-	}
-	return api.DupeCheckResult{}, false
-}
-
-func assertPanicFailureResult(t *testing.T, result api.DupeCheckResult, secret string) {
-	t.Helper()
-	if result.Status != "failed" {
-		t.Fatalf("expected failed status, got %q", result.Status)
-	}
-	if result.Skipped {
-		t.Fatalf("expected panic failure not to be marked skipped")
-	}
-	if result.SkipReason != "" || len(result.SkipRules) != 0 {
-		t.Fatalf("expected panic failure not to carry skip fields, got reason=%q rules=%#v", result.SkipReason, result.SkipRules)
-	}
-	if !strings.Contains(result.Error, "dupe search panicked") {
-		t.Fatalf("expected panic failure error, got %q", result.Error)
-	}
-	if strings.Contains(result.Error, secret) || strings.Contains(strings.Join(result.Notes, "\n"), secret) {
-		t.Fatalf("expected panic failure text to redact secret, got error=%q notes=%#v", result.Error, result.Notes)
-	}
-	if !strings.Contains(result.Error, "[REDACTED]") {
-		t.Fatalf("expected redacted panic detail, got %q", result.Error)
-	}
-}
diff --git a/internal/dupechecking/site_handlers_test.go b/internal/dupechecking/site_handlers_test.go
deleted file mode 100644
index c6828e4d..00000000
--- a/internal/dupechecking/site_handlers_test.go
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestSiteHandlersSearch(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		tracker  string
-		meta     api.PreparedMetadata
-		setup    func(t *testing.T, baseURL string, dbPath string)
-		handler  func(cfg config.Config, client *http.Client) searchHandler
-		validate func(t *testing.T, entries []api.DupeEntry)
-	}{
-		{
-			name:    "BT",
-			tracker: "BT",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, Release: api.ReleaseInfo{Title: "Movie"}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "BT", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler {
-				return btHandler{cfg: cfg, http: client, logger: api.NopLogger{}}
-			},
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.WEB-DL-GRP" {
-					t.Fatalf("unexpected BT entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "FL",
-			tracker: "FL",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, Release: api.ReleaseInfo{Resolution: "1080p"}, SourcePath: "x"},
-			setup: func(t *testing.T, _ string, dbPath string) {
-				writeJSONCookie(t, dbPath, "FL", `{"sid":"cookie"}`)
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return flHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].ID != "1234" {
-					t.Fatalf("unexpected FL entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "FF",
-			tracker: "FF",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "FF", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return ffHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "Fun.Movie.2024.1080p.BluRay.x264-GRP" {
-					t.Fatalf("unexpected FF entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "BJS",
-			tracker: "BJS",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "BJS", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return bjsHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].ID != "44" {
-					t.Fatalf("unexpected BJS entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "HDS",
-			tracker: "HDS",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, Release: api.ReleaseInfo{Resolution: "1080p"}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "HDS", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return hdsHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || !entries[0].SizeKnown {
-					t.Fatalf("unexpected HDS entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "HDT",
-			tracker: "HDT",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, Release: api.ReleaseInfo{Resolution: "1080p"}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "HDT", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return hdtHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.REMUX-GRP" {
-					t.Fatalf("unexpected HDT entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "IS",
-			tracker: "IS",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 123}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "IS", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return isHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.WEB-DL-GRP" {
-					t.Fatalf("unexpected IS entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "PTS",
-			tracker: "PTS",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, SourcePath: "x"},
-			setup: func(t *testing.T, baseURL string, dbPath string) {
-				writeTextCookie(t, dbPath, "PTS", hostFromBaseURL(t, baseURL))
-			},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return ptsHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "PTS.Movie.2024.1080p.WEB-DL-GRP" {
-					t.Fatalf("unexpected PTS entries: %#v", entries)
-				}
-			},
-		},
-		{
-			name:    "THR",
-			tracker: "THR",
-			meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 123}, SourcePath: "x"},
-			setup:   func(_ *testing.T, _ string, _ string) {},
-			handler: func(cfg config.Config, client *http.Client) searchHandler { return thrHandler{cfg: cfg, http: client} },
-			validate: func(t *testing.T, entries []api.DupeEntry) {
-				if len(entries) != 1 || entries[0].Name != "THR.Movie.2024.1080p.BluRay-GRP" {
-					t.Fatalf("unexpected THR entries: %#v", entries)
-				}
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			tmp := t.TempDir()
-			dbPath := filepath.Join(tmp, "ua.db")
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				switch tc.tracker {
-				case "BT":
-					if r.URL.Path == "/torrents.php" {
-						if r.URL.RawQuery == "id=99" {
-							_, _ = w.Write([]byte(`<html><body><div id="files_99"><div class="filelist_path">Movie.2024.1080p.WEB-DL-GRP</div></div><table id="torrent_table"><tr id="torrent99"><td><a onclick="gtoggle()">m2ts</a></td></tr></table></body></html>`))
-							return
-						}
-						if strings.Contains(r.URL.RawQuery, "searchstr=") {
-							_, _ = w.Write([]byte(`<html><body><table id="torrent_table"><tr><td><a href="torrents.php?id=99">group</a></td></tr></table></body></html>`))
-							return
-						}
-					}
-				case "FL":
-					if r.URL.Path == "/browse.php" {
-						_, _ = w.Write([]byte(`<a href="details.php?id=1234" title="FileList.Movie.2024.1080p.BluRay-GRP">x</a>`))
-						return
-					}
-				case "FF":
-					if r.URL.Path == "/torrents.php" && r.URL.RawQuery == "id=55" {
-						_, _ = w.Write([]byte(`<html><body><table><tr id="torrent123"><td><a onclick="gtoggle()">Fun.Movie.2024.1080p.BluRay.x264-GRP</a></td></tr></table></body></html>`))
-						return
-					}
-					if r.URL.Path == "/torrents.php" {
-						_, _ = w.Write([]byte(`<html><body><table id="torrent_table"><tr><td><a href="torrents.php?id=55">group</a></td></tr></table></body></html>`))
-						return
-					}
-				case "BJS":
-					if r.URL.Path == "/torrents.php" {
-						_, _ = w.Write([]byte(`<html><body><div class="main_column"><table><tr id="torrent44"><td><a onclick="loadIfNeeded('44', '99')">BJS Movie 2024 1080p WEB-DL</a></td></tr></table></div></body></html>`))
-						return
-					}
-				case "HDS":
-					if r.URL.Path == "/index.php" {
-						_, _ = w.Write([]byte(`Show/Hide Categories<table><tr><td class="lista"><a href="index.php?page=torrent-details&id=7">HDS.Movie.2024.1080p.BluRay-GRP</a></td><td class="lista">10.5 GB</td></tr></table>`))
-						return
-					}
-				case "HDT":
-					if r.URL.Path == "/torrents.php" {
-						_, _ = w.Write([]byte(`<html><body><table><tr><td class="mainblockcontent"><a href="details.php?id=77">Movie.2024.1080p.REMUX-GRP</a></td><td class="mainblockcontent">15.2 GiB</td></tr></table></body></html>`))
-						return
-					}
-				case "IS":
-					if r.URL.Path == "/browse.php" {
-						_, _ = w.Write([]byte(`<table id="sortabletable"><tbody><tr><td></td><td><a href="details.php?id=12">Movie.2024.1080p.WEB-DL-GRP</a></td><td></td><td></td><td>8.2 GB</td></tr></tbody></table>`))
-						return
-					}
-				case "PTS":
-					if r.URL.Path == "/torrents.php" {
-						_, _ = w.Write([]byte(`<table class="torrents"><table class="torrentname"><b>PTS.Movie.2024.1080p.WEB-DL-GRP</b></table></table>`))
-						return
-					}
-				case "THR":
-					if r.URL.Path == "/login.php" {
-						_, _ = w.Write([]byte(`<form><input type="hidden" name="returnto" value="/browse.php"></form>`))
-						return
-					}
-					if r.URL.Path == "/takelogin.php" {
-						http.SetCookie(w, &http.Cookie{Name: "session", Value: "cookie", Path: "/"})
-						_, _ = w.Write([]byte("ok"))
-						return
-					}
-					if r.URL.Path == "/browse.php" {
-						_, _ = w.Write([]byte(`<a href="details.php?id=91" onmousemove="return overlibImage('THR.Movie.2024.1080p.BluRay-GRP','/images/test.png')">link</a>`))
-						return
-					}
-				}
-				http.NotFound(w, r)
-			}))
-			defer server.Close()
-
-			tc.setup(t, server.URL, dbPath)
-			cfg := config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-					tc.tracker: {URL: server.URL, Username: "user", Password: "pass"},
-				}},
-			}
-			entries, notes, err := tc.handler(cfg, server.Client()).Search(context.Background(), tc.meta, tc.tracker)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if len(notes) != 0 {
-				t.Fatalf("unexpected notes: %v", notes)
-			}
-			tc.validate(t, entries)
-		})
-	}
-}
-
-func writeTextCookie(t *testing.T, dbPath string, tracker string, domain string) {
-	t.Helper()
-	cookieDir := filepath.Join(filepath.Dir(dbPath), "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	line := domain + "\tTRUE\t/\tFALSE\t0\tsession\tcookie\n"
-	if err := os.WriteFile(filepath.Join(cookieDir, tracker+".txt"), []byte(line), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-}
-
-func writeJSONCookie(t *testing.T, dbPath string, tracker string, payload string) {
-	t.Helper()
-	cookieDir := filepath.Join(filepath.Dir(dbPath), "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(cookieDir, tracker+".json"), []byte(payload), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-}
-
-func hostFromBaseURL(t *testing.T, baseURL string) string {
-	t.Helper()
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		t.Fatalf("parse base URL: %v", err)
-	}
-	return parsed.Hostname()
-}
diff --git a/internal/dupechecking/site_helpers.go b/internal/dupechecking/site_helpers.go
deleted file mode 100644
index c4146b57..00000000
--- a/internal/dupechecking/site_helpers.go
+++ /dev/null
@@ -1,377 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var sizePattern = regexp.MustCompile(`(?i)(\d+(?:\.\d+)?)\s*([kmgt]?i?b)`)
-var thrNamePattern = regexp.MustCompile(`overlibImage\('(.+?)','/images`)
-
-type getResponseInfo struct {
-	StatusCode int
-	FinalURL   string
-}
-
-func newGetResponseInfo(resp *http.Response) getResponseInfo {
-	info := getResponseInfo{StatusCode: resp.StatusCode}
-	if resp.Request != nil && resp.Request.URL != nil {
-		info.FinalURL = resp.Request.URL.String()
-	}
-	return info
-}
-
-func (info getResponseInfo) ok() bool {
-	return info.StatusCode >= 200 && info.StatusCode < 300
-}
-
-func trackerBaseURL(cfg config.Config, tracker string, fallback string) string {
-	if trackerCfg, ok := trackerCfg(cfg, tracker); ok && strings.TrimSpace(trackerCfg.URL) != "" {
-		trimmed := strings.TrimSpace(trackerCfg.URL)
-		if parsed, err := url.Parse(trimmed); err == nil && parsed.Scheme != "" && parsed.Host != "" {
-			return strings.TrimRight(parsed.String(), "/")
-		}
-		return strings.TrimRight(trimmed, "/")
-	}
-	return strings.TrimRight(strings.TrimSpace(fallback), "/")
-}
-
-func trackerHost(baseURL string, fallback string) string {
-	if parsed, err := url.Parse(strings.TrimSpace(baseURL)); err == nil && parsed.Hostname() != "" {
-		return parsed.Hostname()
-	}
-	return strings.TrimSpace(fallback)
-}
-
-func loadTrackerCookies(ctx context.Context, cfg config.Config, tracker string, domain string) ([]*http.Cookie, error) {
-	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, cfg.MainSettings.DBPath, tracker, domain)
-	if err != nil {
-		return nil, fmt.Errorf("dupechecking: load tracker cookies: %w", err)
-	}
-	return loaded, nil
-}
-
-func doHTMLGet(ctx context.Context, client *http.Client, endpoint string, params url.Values, cookies []*http.Cookie) (getResponseInfo, *xhtml.Node, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return getResponseInfo{}, nil, fmt.Errorf("dupechecking: create HTML GET request: %w", err)
-	}
-	if len(params) > 0 {
-		req.URL.RawQuery = params.Encode()
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, cookies)
-	resp, err := client.Do(req)
-	if err != nil {
-		return getResponseInfo{}, nil, fmt.Errorf("dupechecking: HTML GET request: %w", err)
-	}
-	info := newGetResponseInfo(resp)
-	root, err := xhtml.Parse(resp.Body)
-	if closeErr := resp.Body.Close(); err == nil && closeErr != nil {
-		err = closeErr
-	}
-	if err != nil {
-		return info, nil, err
-	}
-	return info, root, nil
-}
-
-func doTextGet(ctx context.Context, client *http.Client, endpoint string, params url.Values, headers map[string]string, cookies []*http.Cookie) (getResponseInfo, string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return getResponseInfo{}, "", fmt.Errorf("dupechecking: create text GET request: %w", err)
-	}
-	if len(params) > 0 {
-		req.URL.RawQuery = params.Encode()
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	for key, value := range headers {
-		req.Header.Set(key, value)
-	}
-	commonhttp.ApplyCookies(req, cookies)
-	resp, err := client.Do(req)
-	if err != nil {
-		return getResponseInfo{}, "", fmt.Errorf("dupechecking: text GET request: %w", err)
-	}
-	info := newGetResponseInfo(resp)
-	body, err := io.ReadAll(resp.Body)
-	if closeErr := resp.Body.Close(); err == nil && closeErr != nil {
-		err = closeErr
-	}
-	if err != nil {
-		return info, "", err
-	}
-	return info, string(body), nil
-}
-
-func absoluteURL(baseURL string, value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	if strings.HasPrefix(trimmed, "http://") || strings.HasPrefix(trimmed, "https://") {
-		return trimmed
-	}
-	base, err := url.Parse(strings.TrimSpace(baseURL))
-	if err != nil {
-		return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(trimmed, "/")
-	}
-	ref, err := url.Parse(trimmed)
-	if err != nil {
-		return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(trimmed, "/")
-	}
-	return base.ResolveReference(ref).String()
-}
-
-func findNodes(root *xhtml.Node, match func(*xhtml.Node) bool) []*xhtml.Node {
-	nodes := make([]*xhtml.Node, 0)
-	var walk func(*xhtml.Node)
-	walk = func(node *xhtml.Node) {
-		if node == nil {
-			return
-		}
-		if match(node) {
-			nodes = append(nodes, node)
-		}
-		for child := node.FirstChild; child != nil; child = child.NextSibling {
-			walk(child)
-		}
-	}
-	walk(root)
-	return nodes
-}
-
-func firstNode(root *xhtml.Node, match func(*xhtml.Node) bool) *xhtml.Node {
-	var found *xhtml.Node
-	var walk func(*xhtml.Node)
-	walk = func(node *xhtml.Node) {
-		if node == nil || found != nil {
-			return
-		}
-		if match(node) {
-			found = node
-			return
-		}
-		for child := node.FirstChild; child != nil; child = child.NextSibling {
-			walk(child)
-		}
-	}
-	walk(root)
-	return found
-}
-
-func hasClass(node *xhtml.Node, want string) bool {
-	for className := range strings.FieldsSeq(attrValueHTML(node, "class")) {
-		if strings.EqualFold(strings.TrimSpace(className), strings.TrimSpace(want)) {
-			return true
-		}
-	}
-	return false
-}
-
-func parseSizeBytes(value string) (int64, bool) {
-	match := sizePattern.FindStringSubmatch(strings.TrimSpace(value))
-	if len(match) != 3 {
-		return 0, false
-	}
-	amount, err := strconv.ParseFloat(match[1], 64)
-	if err != nil {
-		return 0, false
-	}
-	multiplier := float64(1)
-	switch strings.ToLower(strings.TrimSpace(match[2])) {
-	case "kb":
-		multiplier = 1000
-	case "mb":
-		multiplier = 1000 * 1000
-	case "gb":
-		multiplier = 1000 * 1000 * 1000
-	case "tb":
-		multiplier = 1000 * 1000 * 1000 * 1000
-	case "kib":
-		multiplier = 1024
-	case "mib":
-		multiplier = 1024 * 1024
-	case "gib":
-		multiplier = 1024 * 1024 * 1024
-	case "tib":
-		multiplier = 1024 * 1024 * 1024 * 1024
-	case "b":
-		multiplier = 1
-	}
-	return int64(math.Round(amount * multiplier)), true
-}
-
-func addSize(entry *api.DupeEntry, value string) {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return
-	}
-	entry.SizeText = trimmed
-	if sizeBytes, ok := parseSizeBytes(trimmed); ok {
-		entry.SizeKnown = true
-		entry.SizeBytes = sizeBytes
-	}
-}
-
-func categoryOfSiteMeta(meta api.PreparedMetadata) string {
-	return strings.ToUpper(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.ExternalIDs.Category, meta.MediaInfoCategory)))
-}
-
-func resolveSeasonEpisodeQuery(meta api.PreparedMetadata) string {
-	if meta.SeasonInt > 0 && meta.EpisodeInt > 0 {
-		return fmt.Sprintf("S%02dE%02d", meta.SeasonInt, meta.EpisodeInt)
-	}
-	return strings.TrimSpace(meta.SeasonStr + meta.EpisodeStr)
-}
-
-func resolveFLCategoryID(meta api.PreparedMetadata) int {
-	if meta.Anime {
-		return 24
-	}
-	category := categoryOfSiteMeta(meta)
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	switch {
-	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
-		return 2
-	case category == "TV":
-		if resolution == "2160p" {
-			return 27
-		}
-		if resolution == "480p" || resolution == "576p" {
-			return 23
-		}
-		return 21
-	default:
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-			if resolution == "2160p" {
-				return 26
-			}
-			return 20
-		}
-		if resolution == "2160p" {
-			return 6
-		}
-		if resolution == "480p" || resolution == "576p" {
-			return 1
-		}
-		return 4
-	}
-}
-
-func resolveHDTCategoryID(meta api.PreparedMetadata) int {
-	category := categoryOfSiteMeta(meta)
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if category == "TV" {
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
-			if resolution == "2160p" {
-				return 72
-			}
-			return 59
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-			if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
-				return 73
-			}
-			return 60
-		}
-		switch resolution {
-		case "2160p":
-			return 65
-		case "1080p", "1080i":
-			return 30
-		default:
-			return 38
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
-		if resolution == "2160p" {
-			return 70
-		}
-		return 1
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
-			return 71
-		}
-		return 2
-	}
-	switch resolution {
-	case "2160p":
-		return 64
-	case "1080p", "1080i":
-		return 5
-	default:
-		return 3
-	}
-}
-
-func loginTHR(ctx context.Context, client *http.Client, baseURL string, username string, password string) ([]*http.Cookie, error) {
-	resp, root, err := doHTMLGet(ctx, client, baseURL+"/login.php", nil, nil)
-	if err != nil {
-		return nil, fmt.Errorf("fetch login page: %w", err)
-	}
-	if !resp.ok() {
-		return nil, fmt.Errorf("fetch login page: status=%d", resp.StatusCode)
-	}
-	form := url.Values{}
-	inputs := findNodes(root, func(node *xhtml.Node) bool {
-		return node.Type == xhtml.ElementNode && node.Data == "input"
-	})
-	for _, input := range inputs {
-		name := strings.TrimSpace(attrValueHTML(input, "name"))
-		if name == "" {
-			continue
-		}
-		form.Set(name, strings.TrimSpace(attrValueHTML(input, "value")))
-	}
-	form.Set("username", strings.TrimSpace(username))
-	form.Set("password", strings.TrimSpace(password))
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/takelogin.php", strings.NewReader(form.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("dupechecking: create THR login request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("Referer", baseURL+"/login.php")
-	req.Header.Set("User-Agent", "upbrr")
-	loginResp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("dupechecking: submit THR login: %w", err)
-	}
-	defer loginResp.Body.Close()
-	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 {
-		return nil, fmt.Errorf("status %d", loginResp.StatusCode)
-	}
-	cookies := loginResp.Cookies()
-	if len(cookies) == 0 {
-		return nil, errors.New("no cookies returned")
-	}
-	return cookies, nil
-}
-
-func parseTHRName(onMouseMove string) string {
-	match := thrNamePattern.FindStringSubmatch(strings.TrimSpace(onMouseMove))
-	if len(match) != 2 {
-		return ""
-	}
-	return strings.TrimSpace(match[1])
-}
diff --git a/internal/dupechecking/spd.go b/internal/dupechecking/spd.go
deleted file mode 100644
index e44f8edd..00000000
--- a/internal/dupechecking/spd.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type spdHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h spdHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, apiKey, ok := trackerCfgWithAPIKey(h.cfg, "SPD")
-	if !ok {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	params := url.Values{}
-	switch {
-	case meta.ExternalIDs.IMDBID != 0:
-		params.Set("imdbId", strconv.Itoa(meta.ExternalIDs.IMDBID))
-	case strings.TrimSpace(meta.Release.Title) != "":
-		params.Set("search", strings.TrimSpace(meta.Release.Title))
-	default:
-		return nil, []string{noteSkip("missing imdb/title for SPD dupe search")}, nil
-	}
-	headers := map[string]string{"Authorization": apiKey, "accept": "application/json"}
-	status, payload, err := doJSONGetAny(ctx, h.http, "https://speedapp.io/api/torrent", params, headers)
-	if err != nil || status < 200 || status >= 300 {
-		return nil, []string{noteSkip("SPD search failed")}, nil
-	}
-	list, ok := anyToSlice(payload)
-	if !ok {
-		return nil, nil, nil
-	}
-	entries := make([]api.DupeEntry, 0, len(list))
-	for _, raw := range list {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		id := stringFromAny(item["id"])
-		entry := api.DupeEntry{Name: stringFromAny(item["name"]), ID: id, Link: "https://speedapp.io/browse/" + id + "/"}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/stub.go b/internal/dupechecking/stub.go
deleted file mode 100644
index b6240ffb..00000000
--- a/internal/dupechecking/stub.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type stubHandler struct {
-	reason string
-}
-
-func (h stubHandler) Search(_ context.Context, _ api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	reason := h.reason
-	if reason == "" {
-		reason = handlerNotImplementedReason(tracker)
-	}
-	return nil, []string{noteSkip(reason)}, nil
-}
diff --git a/internal/dupechecking/stub_handlers_test.go b/internal/dupechecking/stub_handlers_test.go
deleted file mode 100644
index 4c77bd03..00000000
--- a/internal/dupechecking/stub_handlers_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestStubHandlerReturnsSkipNote(t *testing.T) {
-	t.Parallel()
-	h := stubHandler{}
-	_, notes, err := h.Search(context.Background(), api.PreparedMetadata{}, "AR")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(notes) != 1 {
-		t.Fatalf("expected a single note")
-	}
-	if reason, ok := parseSkipReason(notes); !ok || reason == "" {
-		t.Fatalf("expected parseable skip reason")
-	}
-}
diff --git a/internal/dupechecking/thr.go b/internal/dupechecking/thr.go
deleted file mode 100644
index cf5df3fa..00000000
--- a/internal/dupechecking/thr.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	xhtml "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type thrHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h thrHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	imdb := imdbForLookup(meta)
-	if imdb == "" {
-		return nil, []string{noteSkip("missing IMDb ID for THR dupe search")}, nil
-	}
-	cfg, ok := trackerCfg(h.cfg, "THR")
-	if !ok || strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, []string{noteSkip("missing THR username/password")}, nil
-	}
-	baseURL := trackerBaseURL(h.cfg, "THR", "https://www.torrenthr.org")
-	cookies, err := loginTHR(ctx, h.http, baseURL, cfg.Username, cfg.Password)
-	if err != nil {
-		return nil, []string{noteSkip("THR login failed")}, nil
-	}
-	entries := make([]api.DupeEntry, 0)
-	for page := 0; page <= 10; page++ {
-		params := url.Values{"search": {imdb}, "blah": {"2"}, "incldead": {"1"}}
-		if page > 0 {
-			params.Set("page", strconv.Itoa(page))
-		}
-		resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/browse.php", params, cookies)
-		if err != nil || !resp.ok() {
-			return nil, []string{noteSkip("THR search failed")}, nil
-		}
-		links := findNodes(root, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.HasPrefix(attrValueHTML(node, "href"), "details.php")
-		})
-		before := len(entries)
-		for _, link := range links {
-			name := parseTHRName(attrValueHTML(link, "onmousemove"))
-			if name == "" {
-				name = strings.TrimSpace(nodeTextHTML(link))
-			}
-			if name == "" {
-				continue
-			}
-			entries = append(entries, api.DupeEntry{Name: name, Link: absoluteURL(baseURL, attrValueHTML(link, "href"))})
-		}
-		next := firstNode(root, func(node *xhtml.Node) bool {
-			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(strings.ToLower(nodeTextHTML(node)), "next")
-		})
-		if next == nil || len(entries) == before {
-			break
-		}
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/tl.go b/internal/dupechecking/tl.go
deleted file mode 100644
index b0447e76..00000000
--- a/internal/dupechecking/tl.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type tlHandler struct {
-	cfg  config.Config
-	http *http.Client
-}
-
-func (h tlHandler) Search(ctx context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	_, _, ok := trackerCfgWithPasskey(h.cfg, "TL")
-	if !ok {
-		return nil, []string{noteSkip("missing passkey for tracker")}, nil
-	}
-	query := strings.TrimSpace(meta.Release.Title)
-	if query == "" {
-		query = strings.TrimSpace(meta.ReleaseName)
-	}
-	if query == "" {
-		return nil, []string{noteSkip("missing title for TL dupe search")}, nil
-	}
-	endpoint := "https://www.torrentleech.org/torrents/browse/list/query/" + url.PathEscape(query)
-	headers := map[string]string{"Accept": "application/json"}
-	status, payload, err := doJSONGet(ctx, h.http, endpoint, nil, headers)
-	if err != nil || status < 200 || status >= 300 || len(payload) == 0 {
-		return nil, []string{noteSkip("TL search failed")}, nil
-	}
-	torrents, _ := payload["torrentList"].([]any)
-	entries := make([]api.DupeEntry, 0, len(torrents))
-	for _, raw := range torrents {
-		item, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		fid := stringFromAny(item["fid"])
-		entry := api.DupeEntry{Name: stringFromAny(item["name"]), ID: fid, Link: "https://www.torrentleech.org/torrent/" + fid}
-		size := intFromAny(item["size"])
-		if size > 0 {
-			entry.SizeKnown = true
-			entry.SizeBytes = size
-		}
-		entries = append(entries, entry)
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/tvc.go b/internal/dupechecking/tvc.go
deleted file mode 100644
index 5f0815ea..00000000
--- a/internal/dupechecking/tvc.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type tvcHandler struct{}
-
-func (h tvcHandler) Search(_ context.Context, meta api.PreparedMetadata, _ string) ([]api.DupeEntry, []string, error) {
-	res := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
-	if strings.Contains(res, "2160") || strings.EqualFold(meta.Type, "REMUX") || strings.TrimSpace(meta.DiscType) != "" {
-		return nil, []string{noteSkip("TVC disallows UHD/disc/remux content")}, nil
-	}
-	return nil, []string{noteSkip("TVC dupe search currently unavailable; manual check required")}, nil
-}
diff --git a/internal/dupechecking/types.go b/internal/dupechecking/types.go
deleted file mode 100644
index 18805375..00000000
--- a/internal/dupechecking/types.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type searchHandler interface {
-	Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error)
-}
-
-type handlerDeps struct {
-	cfg     config.Config
-	logger  api.Logger
-	http    *http.Client
-	tracker *trackerdata.Client
-}
diff --git a/internal/dupechecking/unit3d.go b/internal/dupechecking/unit3d.go
deleted file mode 100644
index 9a7d81e6..00000000
--- a/internal/dupechecking/unit3d.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type unit3dHandler struct {
-	cfg     config.Config
-	tracker *trackerdata.Client
-}
-
-func (h unit3dHandler) Search(ctx context.Context, meta api.PreparedMetadata, tracker string) ([]api.DupeEntry, []string, error) {
-	if strings.TrimSpace(trackerdata.TrackerAPIKey(h.cfg, tracker)) == "" {
-		return nil, []string{noteSkip("missing api_key for tracker")}, nil
-	}
-	params := buildUnit3DSearchParams(meta, tracker)
-	if len(params) == 0 {
-		return nil, []string{"missing required metadata for dupe search"}, nil
-	}
-	entries, warning, err := h.tracker.SearchTorrents(ctx, tracker, params, strings.TrimSpace(meta.DiscType) != "")
-	if err != nil {
-		return nil, nil, fmt.Errorf("dupechecking: %w", err)
-	}
-	if warning != "" {
-		return entries, []string{warning}, nil
-	}
-	return entries, nil, nil
-}
diff --git a/internal/dupechecking/unit3d_params.go b/internal/dupechecking/unit3d_params.go
deleted file mode 100644
index b7352b50..00000000
--- a/internal/dupechecking/unit3d_params.go
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func buildUnit3DSearchParams(meta api.PreparedMetadata, tracker string) url.Values {
-	tmdbID := meta.ExternalIDs.TMDBID
-	if tmdbID == 0 {
-		return nil
-	}
-
-	category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	if category == "" && meta.ReleaseNameOverrides.Category != nil {
-		category = strings.ToUpper(strings.TrimSpace(*meta.ReleaseNameOverrides.Category))
-	}
-	categoryID := resolveUnit3DDupeCategoryID(tracker, category)
-	if categoryID == "" {
-		return nil
-	}
-
-	typeValue := strings.ToUpper(strings.TrimSpace(meta.Type))
-	if typeValue == "" {
-		typeValue = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
-	}
-	if typeValue == "" && strings.TrimSpace(meta.DiscType) != "" {
-		typeValue = "DISC"
-	}
-	if typeValue == "" {
-		if meta.ReleaseNameOverrides.Type != nil {
-			typeValue = strings.ToUpper(strings.TrimSpace(*meta.ReleaseNameOverrides.Type))
-		}
-	}
-	typeID := resolveUnit3DDupeTypeID(tracker, typeValue)
-
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if resolution == "" {
-		if meta.ReleaseNameOverrides.Resolution != nil {
-			resolution = strings.TrimSpace(*meta.ReleaseNameOverrides.Resolution)
-		}
-	}
-	resolutionID := resolveUnit3DDupeResolutionID(tracker, resolution)
-	if resolutionID == "" {
-		resolutionID = resolveUnit3DDupeResolutionID(tracker, "8640p")
-	}
-
-	params := url.Values{}
-	params.Set("tmdbId", strconv.Itoa(tmdbID))
-	params.Set("categories[]", categoryID)
-	params.Set("name", "")
-	params.Set("perPage", "100")
-
-	if !strings.EqualFold(tracker, "OTW") {
-		if resolutionID == "3" || resolutionID == "4" {
-			params.Add("resolutions[]", "3")
-			params.Add("resolutions[]", "4")
-		} else {
-			params.Set("resolutions[]", resolutionID)
-		}
-	}
-
-	if typeID != "" && !strings.EqualFold(tracker, "SP") && !strings.EqualFold(tracker, "STC") {
-		params.Set("types[]", typeID)
-	}
-
-	if strings.EqualFold(category, "TV") {
-		season := resolveSeasonValue(meta)
-		if season != "" {
-			params.Set("name", " "+season)
-		}
-	}
-
-	return params
-}
-
-func resolveUnit3DDupeCategoryID(tracker string, category string) string {
-	if strings.EqualFold(tracker, "EMUW") {
-		switch strings.ToUpper(strings.TrimSpace(category)) {
-		case "MOVIE", "FANRES":
-			return "1"
-		case "TV":
-			return "2"
-		default:
-			return ""
-		}
-	}
-	return trackerdata.CategoryID(category)
-}
-
-func resolveUnit3DDupeTypeID(tracker string, typeValue string) string {
-	if strings.EqualFold(tracker, "EMUW") {
-		mapping := map[string]string{
-			"DISC":   "1",
-			"REMUX":  "2",
-			"ENCODE": "3",
-			"WEBDL":  "4",
-			"WEBRIP": "5",
-			"HDTV":   "6",
-			"SD":     "7",
-		}
-		return mapping[strings.ToUpper(strings.TrimSpace(typeValue))]
-	}
-	return trackerdata.TypeID(typeValue)
-}
-
-func resolveUnit3DDupeResolutionID(tracker string, resolution string) string {
-	if strings.EqualFold(tracker, "EMUW") {
-		mapping := map[string]string{
-			"4320p": "1",
-			"2160p": "2",
-			"1080p": "3",
-			"1080i": "4",
-			"720p":  "5",
-			"576p":  "6",
-			"540p":  "7",
-			"480p":  "8",
-			"8640p": "10",
-		}
-		return mapping[strings.ToLower(strings.TrimSpace(resolution))]
-	}
-	return trackerdata.ResolutionID(resolution)
-}
-
-func resolveSeasonValue(meta api.PreparedMetadata) string {
-	if meta.ReleaseNameOverrides.Season != nil {
-		return normalizeSeasonEpisode(*meta.ReleaseNameOverrides.Season)
-	}
-	season, _ := parseSeasonEpisode(meta.ReleaseName)
-	return season
-}
-
-func normalizeSeasonEpisode(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	upper := strings.ToUpper(trimmed)
-	if strings.HasPrefix(upper, "S") {
-		return upper
-	}
-	if num, err := strconv.Atoi(trimmed); err == nil {
-		return "S" + strconv.Itoa(num)
-	}
-	return upper
-}
diff --git a/internal/dupechecking/unit3d_params_test.go b/internal/dupechecking/unit3d_params_test.go
deleted file mode 100644
index 78a9622b..00000000
--- a/internal/dupechecking/unit3d_params_test.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dupechecking
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildUnit3DSearchParamsSkipsResolutionForOTW(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "TV"},
-		Type:        "WEBDL",
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-		ReleaseName: "Show.S01E02.1080p.WEB-DL.H264-GRP",
-	}
-
-	params := buildUnit3DSearchParams(meta, "OTW")
-	if _, ok := params["resolutions[]"]; ok {
-		t.Fatalf("did not expect OTW resolution filter, got %#v", params["resolutions[]"])
-	}
-	if got := params.Get("name"); got != " S01" {
-		t.Fatalf("expected season search name, got %q", got)
-	}
-}
-
-func TestBuildUnit3DSearchParamsKeepsResolutionForOtherTrackers(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "TV"},
-		Type:        "WEBDL",
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-		ReleaseName: "Show.S01E02.1080p.WEB-DL.H264-GRP",
-	}
-
-	params := buildUnit3DSearchParams(meta, "AITHER")
-	if got := params["resolutions[]"]; len(got) != 2 || got[0] != "3" || got[1] != "4" {
-		t.Fatalf("expected 1080p/1080i search filters, got %#v", got)
-	}
-}
-
-func TestBuildUnit3DSearchParamsUsesEMUWTrackerMappings(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "MOVIE"},
-		Type:        "WEBDL",
-		Release:     api.ReleaseInfo{Resolution: "540p"},
-		ReleaseName: "Movie.2025.540p.WEB-DL.H264-GRP",
-	}
-
-	params := buildUnit3DSearchParams(meta, "EMUW")
-	if got := params.Get("name"); got != "" {
-		t.Fatalf("expected empty movie search name, got %q", got)
-	}
-	if got := params.Get("categories[]"); got != "1" {
-		t.Fatalf("expected EMUW movie category 1, got %q", got)
-	}
-	if got := params.Get("types[]"); got != "4" {
-		t.Fatalf("expected EMUW WEBDL type 4, got %q", got)
-	}
-	if got := params.Get("resolutions[]"); got != "7" {
-		t.Fatalf("expected EMUW 540p resolution 7, got %q", got)
-	}
-	if got := params.Get("perPage"); got != "100" {
-		t.Fatalf("expected perPage=100, got %q", got)
-	}
-}
-
-func TestBuildUnit3DSearchParamsUsesEMUWPaired1080Resolution(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{TMDBID: 123, Category: "TV"},
-		Type:        "SD",
-		Release:     api.ReleaseInfo{Resolution: "1080i"},
-		ReleaseName: "Show.S02E03.1080i.HDTV.H264-GRP",
-	}
-
-	params := buildUnit3DSearchParams(meta, "EMUW")
-	if got := params.Get("name"); got != " S02" {
-		t.Fatalf("expected season search name, got %q", got)
-	}
-	if got := params.Get("categories[]"); got != "2" {
-		t.Fatalf("expected EMUW TV category 2, got %q", got)
-	}
-	if got := params.Get("types[]"); got != "7" {
-		t.Fatalf("expected EMUW SD type 7, got %q", got)
-	}
-	if got := params["resolutions[]"]; len(got) != 2 || got[0] != "3" || got[1] != "4" {
-		t.Fatalf("expected EMUW 1080p/1080i filters, got %#v", got)
-	}
-}
diff --git a/internal/dvdvideo/engine/engine.go b/internal/dvdvideo/engine/engine.go
index aa289f42..2bca362a 100644
--- a/internal/dvdvideo/engine/engine.go
+++ b/internal/dvdvideo/engine/engine.go
@@ -128,7 +128,13 @@ func CaptureDirectory(ctx context.Context, root string, runner render.Runner, ex
 		return Result{}, fmt.Errorf("%w: menu item limit must be between 1 and %d", ErrCapture, graph.MaxMenuItems)
 	}
 	if opts.Logger != nil {
-		opts.Logger.Debugf("DVD menus: engine preflight started engine_version=%s max_items=%d process_timeout_ms=%d deinterlace=%t", Version, opts.Traversal.MaxItems, opts.ProcessTimeout.Milliseconds(), opts.Deinterlace)
+		opts.Logger.Debugf(
+			"DVD menus: engine preflight started engine_version=%s max_items=%d process_timeout_ms=%d deinterlace=%t",
+			Version,
+			opts.Traversal.MaxItems,
+			opts.ProcessTimeout.Milliseconds(),
+			opts.Deinterlace,
+		)
 	}
 
 	disc, err := ifo.InspectDirectory(root)
@@ -145,7 +151,12 @@ func CaptureDirectory(ctx context.Context, root string, runner render.Runner, ex
 				recovered++
 			}
 		}
-		opts.Logger.Debugf("DVD menus: inventory ready manager=%t title_sets=%d recovered_ifos=%d", disc.Manager.Kind == ifo.KindManager, len(disc.TitleSets), recovered)
+		opts.Logger.Debugf(
+			"DVD menus: inventory ready manager=%t title_sets=%d recovered_ifos=%d",
+			disc.Manager.Kind == ifo.KindManager,
+			len(disc.TitleSets),
+			recovered,
+		)
 	}
 	var capability render.Capability
 	if opts.Capability != nil {
@@ -176,7 +187,16 @@ func CaptureDirectory(ctx context.Context, root string, runner render.Runner, ex
 
 // captureDisc resolves selected graph screens again, decodes their exact
 // background frames, composites live SPU state, and retains non-black output.
-func captureDisc(ctx context.Context, root string, disc ifo.Disc, resolver *directoryResolver, runner render.Runner, executable string, capability render.Capability, opts Options) (Result, error) {
+func captureDisc(
+	ctx context.Context,
+	root string,
+	disc ifo.Disc,
+	resolver *directoryResolver,
+	runner render.Runner,
+	executable string,
+	capability render.Capability,
+	opts Options,
+) (Result, error) {
 	opts.Traversal.Logger = opts.Logger
 	opts.Traversal.Progress = func(update graph.Progress) {
 		reportProgress(opts.Progress, Progress{
@@ -203,7 +223,13 @@ func captureDisc(ctx context.Context, root string, disc ifo.Disc, resolver *dire
 		return result, fmt.Errorf("%w: menu discovery", ErrCapture)
 	}
 	if opts.Logger != nil {
-		opts.Logger.Debugf("DVD menus: rendering started selected=%d inventoried=%d states=%d buttons=%d", len(discovered.Screens), discovered.Inventoried, discovered.VisitedStates, discovered.VisitedButtons)
+		opts.Logger.Debugf(
+			"DVD menus: rendering started selected=%d inventoried=%d states=%d buttons=%d",
+			len(discovered.Screens),
+			discovered.Inventoried,
+			discovered.VisitedStates,
+			discovered.VisitedButtons,
+		)
 	}
 	reportEngineProgress(opts.Progress, result)
 
@@ -240,7 +266,15 @@ func captureDisc(ctx context.Context, root string, disc ifo.Disc, resolver *dire
 			}
 		}
 		if opts.Logger != nil {
-			opts.Logger.Tracef("DVD menus: render state index=%d target_ms=%d scan_truncated=%t overlay=%t highlight=%t buttons=%d", index+1, detail.target.Milliseconds(), detail.scanTruncated, detail.hasOverlay, detail.highlight != nil, len(detail.buttons))
+			opts.Logger.Tracef(
+				"DVD menus: render state index=%d target_ms=%d scan_truncated=%t overlay=%t highlight=%t buttons=%d",
+				index+1,
+				detail.target.Milliseconds(),
+				detail.scanTruncated,
+				detail.hasOverlay,
+				detail.highlight != nil,
+				len(detail.buttons),
+			)
 		}
 
 		frameCtx, cancelFrame := context.WithTimeout(ctx, opts.ProcessTimeout)
@@ -263,7 +297,13 @@ func captureDisc(ctx context.Context, root string, disc ifo.Disc, resolver *dire
 		}
 		if opts.Logger != nil {
 			bounds := background.Bounds()
-			opts.Logger.Debugf("DVD menus: frame decoded index=%d width=%d height=%d target_ms=%d", index+1, bounds.Dx(), bounds.Dy(), detail.target.Milliseconds())
+			opts.Logger.Debugf(
+				"DVD menus: frame decoded index=%d width=%d height=%d target_ms=%d",
+				index+1,
+				bounds.Dx(),
+				bounds.Dy(),
+				detail.target.Milliseconds(),
+			)
 		}
 
 		composed := copyImage(background)
@@ -292,14 +332,28 @@ func captureDisc(ctx context.Context, root string, disc ifo.Disc, resolver *dire
 			HasHighlight: detail.highlight != nil,
 		})
 		if opts.Logger != nil {
-			opts.Logger.Debugf("DVD menus: capture stored index=%d discovery=%s overlay=%t highlight=%t captured=%d", index+1, screen.Discovery, detail.hasOverlay, detail.highlight != nil, len(result.Captures))
+			opts.Logger.Debugf(
+				"DVD menus: capture stored index=%d discovery=%s overlay=%t highlight=%t captured=%d",
+				index+1,
+				screen.Discovery,
+				detail.hasOverlay,
+				detail.highlight != nil,
+				len(result.Captures),
+			)
 		}
 		reportEngineProgress(opts.Progress, result)
 	}
 
 	result.Complete = discovered.Complete && !result.Partial && !result.Truncated && len(result.Captures) == len(discovered.Screens)
 	if opts.Logger != nil {
-		opts.Logger.Debugf("DVD menus: rendering complete selected=%d captured=%d partial=%t truncated=%t warnings=%d", len(discovered.Screens), len(result.Captures), result.Partial, result.Truncated, len(result.Warnings))
+		opts.Logger.Debugf(
+			"DVD menus: rendering complete selected=%d captured=%d partial=%t truncated=%t warnings=%d",
+			len(discovered.Screens),
+			len(result.Captures),
+			result.Partial,
+			result.Truncated,
+			len(result.Warnings),
+		)
 	}
 	if len(result.Captures) == 0 {
 		return result, fmt.Errorf("%w: no menu frames captured", ErrCapture)
diff --git a/internal/dvdvideo/engine/engine_test.go b/internal/dvdvideo/engine/engine_test.go
index be5376a5..217bdf4b 100644
--- a/internal/dvdvideo/engine/engine_test.go
+++ b/internal/dvdvideo/engine/engine_test.go
@@ -112,7 +112,11 @@ func TestCaptureDirectoryRejectsItemLimitOverSafetyMaximum(t *testing.T) {
 func TestVisibleMenuStateRequiresAuthoredMenuEvidence(t *testing.T) {
 	t.Parallel()
 
-	base := ifo.ProgramChain{Programs: 2, Cells: 1, CellPlayback: []ifo.CellPlayback{{}}}
+	base := ifo.ProgramChain{
+		Programs:     2,
+		Cells:        1,
+		CellPlayback: []ifo.CellPlayback{{}},
+	}
 	withPGCStill := base
 	withPGCStill.StillTime = 0xff
 	withCellStill := base
@@ -128,14 +132,55 @@ func TestVisibleMenuStateRequiresAuthoredMenuEvidence(t *testing.T) {
 		highlight  bool
 		want       bool
 	}{
-		{name: "button", pgc: base, coordinate: graph.Coordinate{Program: 1, Cell: 1}, buttons: []nav.Button{{Number: 1}}, want: true},
-		{name: "overlay", pgc: base, coordinate: graph.Coordinate{Program: 1, Cell: 1}, overlay: true, want: true},
-		{name: "highlight", pgc: base, coordinate: graph.Coordinate{Program: 1, Cell: 1}, highlight: true, want: true},
-		{name: "pgc still", pgc: withPGCStill, coordinate: graph.Coordinate{Program: 1, Cell: 1}, want: true},
-		{name: "cell still", pgc: withCellStill, coordinate: graph.Coordinate{Program: 1, Cell: 1}, want: true},
-		{name: "entry program", pgc: entry, coordinate: graph.Coordinate{Program: 1, Cell: 1}, want: true},
-		{name: "entry transition program", pgc: entry, coordinate: graph.Coordinate{Program: 2, Cell: 1}},
-		{name: "plain transition", pgc: base, coordinate: graph.Coordinate{Program: 1, Cell: 1}},
+		{
+			name:       "button",
+			pgc:        base,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			buttons:    []nav.Button{{Number: 1}},
+			want:       true,
+		},
+		{
+			name:       "overlay",
+			pgc:        base,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			overlay:    true,
+			want:       true,
+		},
+		{
+			name:       "highlight",
+			pgc:        base,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			highlight:  true,
+			want:       true,
+		},
+		{
+			name:       "pgc still",
+			pgc:        withPGCStill,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			want:       true,
+		},
+		{
+			name:       "cell still",
+			pgc:        withCellStill,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			want:       true,
+		},
+		{
+			name:       "entry program",
+			pgc:        entry,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+			want:       true,
+		},
+		{
+			name:       "entry transition program",
+			pgc:        entry,
+			coordinate: graph.Coordinate{Program: 2, Cell: 1},
+		},
+		{
+			name:       "plain transition",
+			pgc:        base,
+			coordinate: graph.Coordinate{Program: 1, Cell: 1},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -439,7 +484,12 @@ func newFakeRunner(t *testing.T) *fakeRunner {
 	background := image.NewNRGBA(image.Rect(0, 0, 2, 2))
 	for y := range 2 {
 		for x := range 2 {
-			background.SetNRGBA(x, y, color.NRGBA{R: 16, G: 32, B: 48, A: 0xff})
+			background.SetNRGBA(x, y, color.NRGBA{
+				R: 16,
+				G: 32,
+				B: 48,
+				A: 0xff,
+			})
 		}
 	}
 	if err := png.Encode(&frame, background); err != nil {
@@ -454,7 +504,11 @@ func newFakeRunner(t *testing.T) *fakeRunner {
 
 func (r *fakeRunner) Run(_ context.Context, executable string, args []string, limit int) (render.Output, error) {
 	index := len(r.calls)
-	r.calls = append(r.calls, runnerCall{executable: executable, args: append([]string(nil), args...), limit: limit})
+	r.calls = append(r.calls, runnerCall{
+		executable: executable,
+		args:       append([]string(nil), args...),
+		limit:      limit,
+	})
 	var output render.Output
 	var err error
 	if index < len(r.outputs) {
diff --git a/internal/dvdvideo/engine/resolver.go b/internal/dvdvideo/engine/resolver.go
index 03d75a2c..3d02fa14 100644
--- a/internal/dvdvideo/engine/resolver.go
+++ b/internal/dvdvideo/engine/resolver.go
@@ -69,7 +69,8 @@ func newDirectoryResolver(root string, scan nav.CellScanOptions) (*directoryReso
 			continue
 		}
 		upper := strings.ToUpper(entry.Name())
-		if entry.Type()&os.ModeSymlink != 0 && (upper == "VIDEO_TS.VOB" || len(upper) == len("VTS_01_0.VOB") && strings.HasPrefix(upper, "VTS_") && strings.HasSuffix(upper, "_0.VOB")) {
+		if entry.Type()&os.ModeSymlink != 0 &&
+			(upper == "VIDEO_TS.VOB" || len(upper) == len("VTS_01_0.VOB") && strings.HasPrefix(upper, "VTS_") && strings.HasSuffix(upper, "_0.VOB")) {
 			return nil, fmt.Errorf("%w: menu VOB symlink", ErrLiveState)
 		}
 		switch {
@@ -112,7 +113,12 @@ func (r *directoryResolver) programChain(coordinate graph.Coordinate) ifo.Progra
 }
 
 func coordinateLookupKey(coordinate graph.Coordinate) coordinateKey {
-	return coordinateKey{kind: coordinate.Kind, vts: coordinate.VTS, language: coordinate.LanguageUnit, pgc: coordinate.PGC}
+	return coordinateKey{
+		kind:     coordinate.Kind,
+		vts:      coordinate.VTS,
+		language: coordinate.LanguageUnit,
+		pgc:      coordinate.PGC,
+	}
 }
 
 // resolve scans one authored cell, selects live NAV/SPU/highlight state, and
@@ -294,7 +300,11 @@ func selectOverlay(fragments []nav.SPUFragment, pgc ifo.ProgramChain, registers
 			continue
 		}
 		for _, packet := range complete {
-			packets = append(packets, timedSPUPacket{packet: packet, pts: streamPTS[index], hasPTS: streamHasPTS[index]})
+			packets = append(packets, timedSPUPacket{
+				packet: packet,
+				pts:    streamPTS[index],
+				hasPTS: streamHasPTS[index],
+			})
 			streamHasPTS[index] = false
 		}
 	}
diff --git a/internal/dvdvideo/graph/graph.go b/internal/dvdvideo/graph/graph.go
index c0a532ba..acdfbd1f 100644
--- a/internal/dvdvideo/graph/graph.go
+++ b/internal/dvdvideo/graph/graph.go
@@ -340,7 +340,14 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 				target, terminal, ok := resolveLink(current.node, preResult.Link, lookup)
 				if ok {
 					if opts.Logger != nil {
-						opts.Logger.Debugf("DVD menus: branch queued action=pre decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d", preResult.Link.Command, domainLabel(target.coordinate.Kind), target.coordinate.VTS, target.coordinate.PGC, target.coordinate.Program)
+						opts.Logger.Debugf(
+							"DVD menus: branch queued action=pre decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d",
+							preResult.Link.Command,
+							domainLabel(target.coordinate.Kind),
+							target.coordinate.VTS,
+							target.coordinate.PGC,
+							target.coordinate.Program,
+						)
 					}
 					queue = append(queue, transition(current, target, registers))
 					continue
@@ -392,11 +399,25 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 			switch {
 			case duplicateScreen:
 				if opts.Logger != nil {
-					opts.Logger.Debugf("DVD menus: screen skipped decision=dedupe reason=semantic_identity domain=%s vts=%d pgc=%d pg=%d screen=%x", domainLabel(current.node.coordinate.Kind), current.node.coordinate.VTS, current.node.coordinate.PGC, current.node.coordinate.Program, screenID[:6])
+					opts.Logger.Debugf(
+						"DVD menus: screen skipped decision=dedupe reason=semantic_identity domain=%s vts=%d pgc=%d pg=%d screen=%x",
+						domainLabel(current.node.coordinate.Kind),
+						current.node.coordinate.VTS,
+						current.node.coordinate.PGC,
+						current.node.coordinate.Program,
+						screenID[:6],
+					)
 				}
 			case hasControls && duplicateControls:
 				if opts.Logger != nil {
-					opts.Logger.Debugf("DVD menus: screen skipped decision=dedupe reason=control_identity domain=%s vts=%d pgc=%d pg=%d controls=%x", domainLabel(current.node.coordinate.Kind), current.node.coordinate.VTS, current.node.coordinate.PGC, current.node.coordinate.Program, controlID[:6])
+					opts.Logger.Debugf(
+						"DVD menus: screen skipped decision=dedupe reason=control_identity domain=%s vts=%d pgc=%d pg=%d controls=%x",
+						domainLabel(current.node.coordinate.Kind),
+						current.node.coordinate.VTS,
+						current.node.coordinate.PGC,
+						current.node.coordinate.Program,
+						controlID[:6],
+					)
 				}
 			default:
 				if opts.MaxItems > 0 && len(result.Screens) >= opts.MaxItems {
@@ -407,9 +428,27 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 					if hasControls {
 						rememberControlLayout(controlLayouts, controlID, live.Buttons)
 					}
-					result.Screens = append(result.Screens, Screen{Coordinate: current.node.coordinate, Discovery: DiscoveryReachable, Identity: screenID, Registers: registers.Clone(), Live: live})
+					result.Screens = append(result.Screens, Screen{
+						Coordinate: current.node.coordinate,
+						Discovery:  DiscoveryReachable,
+						Identity:   screenID,
+						Registers:  registers.Clone(),
+						Live:       live,
+					})
 					if opts.Logger != nil {
-						opts.Logger.Debugf("DVD menus: screen selected discovery=reachable domain=%s vts=%d language_unit=%d menu_id=%d pgc=%d pg=%d cell=%d buttons=%d screen=%x stored=%d", domainLabel(current.node.coordinate.Kind), current.node.coordinate.VTS, current.node.coordinate.LanguageUnit, current.node.coordinate.MenuID, current.node.coordinate.PGC, current.node.coordinate.Program, current.node.coordinate.Cell, len(live.Buttons), screenID[:6], len(result.Screens))
+						opts.Logger.Debugf(
+							"DVD menus: screen selected discovery=reachable domain=%s vts=%d language_unit=%d menu_id=%d pgc=%d pg=%d cell=%d buttons=%d screen=%x stored=%d",
+							domainLabel(current.node.coordinate.Kind),
+							current.node.coordinate.VTS,
+							current.node.coordinate.LanguageUnit,
+							current.node.coordinate.MenuID,
+							current.node.coordinate.PGC,
+							current.node.coordinate.Program,
+							current.node.coordinate.Cell,
+							len(live.Buttons),
+							screenID[:6],
+							len(result.Screens),
+						)
 					}
 				}
 			}
@@ -434,14 +473,29 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 				continue
 			}
 			if opts.Logger != nil {
-				opts.Logger.Tracef("DVD menus: action evaluated action=button button=%d executed=%d has_link=%t link=%d registers_changed=%t", button.Number, buttonResult.Executed, buttonResult.HasLink, buttonResult.Link.Command, branchRegisters != registers)
+				opts.Logger.Tracef(
+					"DVD menus: action evaluated action=button button=%d executed=%d has_link=%t link=%d registers_changed=%t",
+					button.Number,
+					buttonResult.Executed,
+					buttonResult.HasLink,
+					buttonResult.Link.Command,
+					branchRegisters != registers,
+				)
 			}
 			if buttonResult.HasLink {
 				target, terminal, ok := resolveLink(current.node, buttonResult.Link, lookup)
 				switch {
 				case ok:
 					if opts.Logger != nil {
-						opts.Logger.Debugf("DVD menus: branch queued action=button button=%d decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d", button.Number, buttonResult.Link.Command, domainLabel(target.coordinate.Kind), target.coordinate.VTS, target.coordinate.PGC, target.coordinate.Program)
+						opts.Logger.Debugf(
+							"DVD menus: branch queued action=button button=%d decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d",
+							button.Number,
+							buttonResult.Link.Command,
+							domainLabel(target.coordinate.Kind),
+							target.coordinate.VTS,
+							target.coordinate.PGC,
+							target.coordinate.Program,
+						)
 					}
 					queue = append(queue, transition(current, target, branchRegisters))
 				case !terminal:
@@ -454,7 +508,12 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 				continue
 			}
 			if branchRegisters != registers {
-				queue = append(queue, state{node: current.node, registers: branchRegisters, depth: current.depth + 1, utility: current.utility})
+				queue = append(queue, state{
+					node:      current.node,
+					registers: branchRegisters,
+					depth:     current.depth + 1,
+					utility:   current.utility,
+				})
 			}
 		}
 		reportProgress(opts.Progress, result)
@@ -462,7 +521,13 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 		postRegisters := registers.Clone()
 		postResult, postErr := vm.Execute(current.node.pgc.PostCommands, &postRegisters, opts.VM)
 		if postErr == nil && opts.Logger != nil {
-			opts.Logger.Tracef("DVD menus: action evaluated action=post commands=%d executed=%d has_link=%t link=%d", len(current.node.pgc.PostCommands), postResult.Executed, postResult.HasLink, postResult.Link.Command)
+			opts.Logger.Tracef(
+				"DVD menus: action evaluated action=post commands=%d executed=%d has_link=%t link=%d",
+				len(current.node.pgc.PostCommands),
+				postResult.Executed,
+				postResult.HasLink,
+				postResult.Link.Command,
+			)
 		}
 		switch {
 		case postErr != nil:
@@ -474,7 +539,14 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 			switch {
 			case ok:
 				if opts.Logger != nil {
-					opts.Logger.Debugf("DVD menus: branch queued action=post decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d", postResult.Link.Command, domainLabel(target.coordinate.Kind), target.coordinate.VTS, target.coordinate.PGC, target.coordinate.Program)
+					opts.Logger.Debugf(
+						"DVD menus: branch queued action=post decision=follow link=%d target_domain=%s target_vts=%d target_pgc=%d target_pg=%d",
+						postResult.Link.Command,
+						domainLabel(target.coordinate.Kind),
+						target.coordinate.VTS,
+						target.coordinate.PGC,
+						target.coordinate.Program,
+					)
 				}
 				queue = append(queue, transition(current, target, postRegisters))
 			case !terminal:
@@ -485,11 +557,26 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 				opts.Logger.Debugf("DVD menus: branch stopped action=post decision=terminal link=%d", postResult.Link.Command)
 			}
 		case current.node.pgc.Next != 0:
-			if target, ok := lookup[nodeKey{kind: current.node.coordinate.Kind, vts: current.node.coordinate.VTS, language: current.node.coordinate.LanguageUnit, pgc: int(current.node.pgc.Next)}]; ok {
+			if target, ok := lookup[nodeKey{
+				kind:     current.node.coordinate.Kind,
+				vts:      current.node.coordinate.VTS,
+				language: current.node.coordinate.LanguageUnit,
+				pgc:      int(current.node.pgc.Next),
+			}]; ok {
 				if opts.Logger != nil {
-					opts.Logger.Debugf("DVD menus: branch queued action=next_pgc decision=follow target_domain=%s target_vts=%d target_pgc=%d", domainLabel(target.coordinate.Kind), target.coordinate.VTS, target.coordinate.PGC)
+					opts.Logger.Debugf(
+						"DVD menus: branch queued action=next_pgc decision=follow target_domain=%s target_vts=%d target_pgc=%d",
+						domainLabel(target.coordinate.Kind),
+						target.coordinate.VTS,
+						target.coordinate.PGC,
+					)
 				}
-				queue = append(queue, state{node: target, registers: postRegisters, depth: current.depth + 1, runPre: true})
+				queue = append(queue, state{
+					node:      target,
+					registers: postRegisters,
+					depth:     current.depth + 1,
+					runPre:    true,
+				})
 			}
 		}
 	}
@@ -527,7 +614,14 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 		if hasControls && hasEquivalentControls(controlLayouts, controlID, live.Buttons) {
 			structuralDuplicates++
 			if opts.Logger != nil {
-				opts.Logger.Debugf("DVD menus: screen skipped decision=dedupe reason=control_identity domain=%s vts=%d pgc=%d pg=%d controls=%x", domainLabel(item.coordinate.Kind), item.coordinate.VTS, item.coordinate.PGC, item.coordinate.Program, controlID[:6])
+				opts.Logger.Debugf(
+					"DVD menus: screen skipped decision=dedupe reason=control_identity domain=%s vts=%d pgc=%d pg=%d controls=%x",
+					domainLabel(item.coordinate.Kind),
+					item.coordinate.VTS,
+					item.coordinate.PGC,
+					item.coordinate.Program,
+					controlID[:6],
+				)
 			}
 			continue
 		}
@@ -544,19 +638,57 @@ func Discover(ctx context.Context, disc ifo.Disc, resolver Resolver, opts Option
 		if hasControls {
 			rememberControlLayout(controlLayouts, controlID, live.Buttons)
 		}
-		result.Screens = append(result.Screens, Screen{Coordinate: item.coordinate, Discovery: DiscoveryStructural, Identity: screenID, Registers: opts.Registers.Clone(), Live: live})
+		result.Screens = append(result.Screens, Screen{
+			Coordinate: item.coordinate,
+			Discovery:  DiscoveryStructural,
+			Identity:   screenID,
+			Registers:  opts.Registers.Clone(),
+			Live:       live,
+		})
 		if opts.Logger != nil {
-			opts.Logger.Debugf("DVD menus: screen selected discovery=structural domain=%s vts=%d language_unit=%d menu_id=%d pgc=%d pg=%d cell=%d buttons=%d screen=%x stored=%d", domainLabel(item.coordinate.Kind), item.coordinate.VTS, item.coordinate.LanguageUnit, item.coordinate.MenuID, item.coordinate.PGC, item.coordinate.Program, item.coordinate.Cell, len(live.Buttons), screenID[:6], len(result.Screens))
+			opts.Logger.Debugf(
+				"DVD menus: screen selected discovery=structural domain=%s vts=%d language_unit=%d menu_id=%d pgc=%d pg=%d cell=%d buttons=%d screen=%x stored=%d",
+				domainLabel(item.coordinate.Kind),
+				item.coordinate.VTS,
+				item.coordinate.LanguageUnit,
+				item.coordinate.MenuID,
+				item.coordinate.PGC,
+				item.coordinate.Program,
+				item.coordinate.Cell,
+				len(live.Buttons),
+				screenID[:6],
+				len(result.Screens),
+			)
 		}
 		reportProgress(opts.Progress, result)
 	}
 	result.Complete = !result.Partial && !result.Truncated && len(classifiedCoordinates) == len(nodes)
 	if opts.Logger != nil {
-		opts.Logger.Debugf("DVD menus: structural reconciliation complete classified=%d transitions=%d noninteractive=%d utility=%d duplicates=%d visible_unreached=%d failures=%d", len(classifiedCoordinates), structuralTransitions, structuralNonInteractive, utilityScreens, structuralDuplicates, structuralVisible, structuralFailures)
+		opts.Logger.Debugf(
+			"DVD menus: structural reconciliation complete classified=%d transitions=%d noninteractive=%d utility=%d duplicates=%d visible_unreached=%d failures=%d",
+			len(classifiedCoordinates),
+			structuralTransitions,
+			structuralNonInteractive,
+			utilityScreens,
+			structuralDuplicates,
+			structuralVisible,
+			structuralFailures,
+		)
 		if limitSkipped > 0 {
 			opts.Logger.Debugf("DVD menus: storage limit applied max_items=%d additional_menu_candidates=%d", opts.MaxItems, limitSkipped)
 		}
-		opts.Logger.Debugf("DVD menus: discovery complete inventoried=%d classified=%d reached=%d states=%d buttons=%d screens=%d partial=%t truncated=%t warnings=%d", result.Inventoried, len(classifiedCoordinates), len(reachedCoordinates), result.VisitedStates, result.VisitedButtons, len(result.Screens), result.Partial, result.Truncated, len(result.Warnings))
+		opts.Logger.Debugf(
+			"DVD menus: discovery complete inventoried=%d classified=%d reached=%d states=%d buttons=%d screens=%d partial=%t truncated=%t warnings=%d",
+			result.Inventoried,
+			len(classifiedCoordinates),
+			len(reachedCoordinates),
+			result.VisitedStates,
+			result.VisitedButtons,
+			len(result.Screens),
+			result.Partial,
+			result.Truncated,
+			len(result.Warnings),
+		)
 	}
 	reportProgress(opts.Progress, result)
 	if len(result.Screens) == 0 {
@@ -607,7 +739,15 @@ func inventory(disc ifo.Disc, language string) ([]node, []node) {
 				continue
 			}
 			for program := 1; program <= int(pgc.Programs); program++ {
-				item := node{coordinate: Coordinate{Kind: file.Kind, VTS: file.VTS, LanguageUnit: languageIndex + 1, PGC: pgc.Number, Program: program, Cell: cellForProgram(pgc, program), MenuID: pgc.MenuID}, pgc: pgc}
+				item := node{coordinate: Coordinate{
+					Kind:         file.Kind,
+					VTS:          file.VTS,
+					LanguageUnit: languageIndex + 1,
+					PGC:          pgc.Number,
+					Program:      program,
+					Cell:         cellForProgram(pgc, program),
+					MenuID:       pgc.MenuID,
+				}, pgc: pgc}
 				nodes = append(nodes, item)
 				if program == 1 && pgc.EntryID&0x80 != 0 {
 					seeds = append(seeds, item)
@@ -675,7 +815,12 @@ type nodeKey struct {
 }
 
 func key(coordinate Coordinate) nodeKey {
-	return nodeKey{kind: coordinate.Kind, vts: coordinate.VTS, language: coordinate.LanguageUnit, pgc: coordinate.PGC}
+	return nodeKey{
+		kind:     coordinate.Kind,
+		vts:      coordinate.VTS,
+		language: coordinate.LanguageUnit,
+		pgc:      coordinate.PGC,
+	}
 }
 
 // resolveLink maps a VM transition to an inventoried node. The second result
diff --git a/internal/dvdvideo/graph/graph_test.go b/internal/dvdvideo/graph/graph_test.go
index ca529165..bf3b58d3 100644
--- a/internal/dvdvideo/graph/graph_test.go
+++ b/internal/dvdvideo/graph/graph_test.go
@@ -14,17 +14,43 @@ import (
 
 func TestDiscoverReachableAndStructuralMenus(t *testing.T) {
 	logger := &graphTestLogger{}
-	root := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1}
-	chapter := ifo.ProgramChain{Number: 2, EntryID: 0x07, MenuID: 7, Programs: 1, Cells: 1}
-	audio := ifo.ProgramChain{Number: 3, EntryID: 0x05, MenuID: 5, Programs: 1, Cells: 1}
+	root := ifo.ProgramChain{
+		Number:   1,
+		EntryID:  0x83,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
+	chapter := ifo.ProgramChain{
+		Number:   2,
+		EntryID:  0x07,
+		MenuID:   7,
+		Programs: 1,
+		Cells:    1,
+	}
+	audio := ifo.ProgramChain{
+		Number:   3,
+		EntryID:  0x05,
+		MenuID:   5,
+		Programs: 1,
+		Cells:    1,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{root, chapter, audio}}},
 	}}
 	resolver := fakeResolver{live: map[int]LiveState{
-		1: {Visible: true, Fingerprint: []byte("root"), Buttons: []nav.Button{{Command: linkPGCN(2)}}},
+		1: {
+			Visible:     true,
+			Fingerprint: []byte("root"),
+			Buttons:     []nav.Button{{Command: linkPGCN(2)}},
+		},
 		2: {Visible: true, Fingerprint: []byte("chapter")},
-		3: {Visible: true, Fingerprint: []byte("audio"), Buttons: []nav.Button{{Number: 1}}},
+		3: {
+			Visible:     true,
+			Fingerprint: []byte("audio"),
+			Buttons:     []nav.Button{{Number: 1}},
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 6, Logger: logger})
 	if err != nil {
@@ -99,13 +125,29 @@ func (l *graphTestLogger) Count(expected string) int {
 func TestDiscoverTruncatesStoredScreens(t *testing.T) {
 	logger := &graphTestLogger{}
 	chains := []ifo.ProgramChain{
-		{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1},
-		{Number: 2, EntryID: 0x85, MenuID: 5, Programs: 1, Cells: 1},
+		{
+			Number:   1,
+			EntryID:  0x83,
+			MenuID:   3,
+			Programs: 1,
+			Cells:    1,
+		},
+		{
+			Number:   2,
+			EntryID:  0x85,
+			MenuID:   5,
+			Programs: 1,
+			Cells:    1,
+		},
 	}
 	disc := ifo.Disc{Manager: ifo.File{Kind: ifo.KindManager, Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: chains}}}}
 	resolver := fakeResolver{live: map[int]LiveState{
 		1: {Visible: true, Fingerprint: []byte("one")},
-		2: {Visible: true, Fingerprint: []byte("two"), Buttons: []nav.Button{{Number: 1}}},
+		2: {
+			Visible:     true,
+			Fingerprint: []byte("two"),
+			Buttons:     []nav.Button{{Number: 1}},
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 1, Logger: logger})
 	if err != nil {
@@ -125,8 +167,18 @@ func TestDiscoverTruncatesStoredScreens(t *testing.T) {
 func TestDiscoverClassifiesInvisibleStructuralProgramsWithoutCapturingThem(t *testing.T) {
 	t.Parallel()
 
-	root := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1}
-	transition := ifo.ProgramChain{Number: 2, Programs: 1, Cells: 1}
+	root := ifo.ProgramChain{
+		Number:   1,
+		EntryID:  0x83,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
+	transition := ifo.ProgramChain{
+		Number:   2,
+		Programs: 1,
+		Cells:    1,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{root, transition}}},
@@ -150,15 +202,31 @@ func TestDiscoverClassifiesInvisibleStructuralProgramsWithoutCapturingThem(t *te
 func TestDiscoverDoesNotCaptureUnreachedZeroButtonScreens(t *testing.T) {
 	t.Parallel()
 
-	root := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1}
-	nonInteractive := ifo.ProgramChain{Number: 2, Programs: 1, Cells: 1, StillTime: 0xff}
+	root := ifo.ProgramChain{
+		Number:   1,
+		EntryID:  0x83,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
+	nonInteractive := ifo.ProgramChain{
+		Number:    2,
+		Programs:  1,
+		Cells:     1,
+		StillTime: 0xff,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{root, nonInteractive}}},
 	}}
 	resolver := fakeResolver{live: map[int]LiveState{
 		1: {Visible: true, Fingerprint: []byte("root")},
-		2: {Visible: true, Fingerprint: []byte("non-menu"), AuthoredStill: true, AuthoredEntry: true},
+		2: {
+			Visible:       true,
+			Fingerprint:   []byte("non-menu"),
+			AuthoredStill: true,
+			AuthoredEntry: true,
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 2})
 	if err != nil {
@@ -176,19 +244,46 @@ func TestDiscoverDeduplicatesEquivalentControlsAcrossBackgrounds(t *testing.T) {
 	t.Parallel()
 
 	logger := &graphTestLogger{}
-	root := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1}
-	alternate := ifo.ProgramChain{Number: 2, MenuID: 3, Programs: 1, Cells: 1}
+	root := ifo.ProgramChain{
+		Number:   1,
+		EntryID:  0x83,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
+	alternate := ifo.ProgramChain{
+		Number:   2,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{root, alternate}}},
 	}}
-	button := nav.Button{Number: 1, ColorGroup: 1, XStart: 10, YStart: 20, XEnd: 100, YEnd: 80}
+	button := nav.Button{
+		Number:     1,
+		ColorGroup: 1,
+		XStart:     10,
+		YStart:     20,
+		XEnd:       100,
+		YEnd:       80,
+	}
 	alternateButton := button
 	alternateButton.XStart += 7
 	alternateButton.YEnd += 8
 	resolver := fakeResolver{live: map[int]LiveState{
-		1: {Visible: true, Fingerprint: []byte("first-background"), Buttons: []nav.Button{button}, AuthoredEntry: true},
-		2: {Visible: true, Fingerprint: []byte("alternate-background"), Buttons: []nav.Button{alternateButton}},
+		1: {
+			Visible:       true,
+			Fingerprint:   []byte("first-background"),
+			Buttons:       []nav.Button{button},
+			AuthoredEntry: true,
+		},
+		2: {
+			Visible:     true,
+			Fingerprint: []byte("alternate-background"),
+			Buttons:     []nav.Button{alternateButton},
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 2, Logger: logger})
 	if err != nil {
@@ -208,18 +303,44 @@ func TestDiscoverDeduplicatesEquivalentControlsAcrossBackgrounds(t *testing.T) {
 func TestDiscoverPreservesSameLayoutWithDifferentCommands(t *testing.T) {
 	t.Parallel()
 
-	root := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 1, Cells: 1}
-	different := ifo.ProgramChain{Number: 2, MenuID: 3, Programs: 1, Cells: 1}
+	root := ifo.ProgramChain{
+		Number:   1,
+		EntryID:  0x83,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
+	different := ifo.ProgramChain{
+		Number:   2,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{root, different}}},
 	}}
-	baseButton := nav.Button{Number: 1, XStart: 10, YStart: 20, XEnd: 100, YEnd: 80}
+	baseButton := nav.Button{
+		Number: 1,
+		XStart: 10,
+		YStart: 20,
+		XEnd:   100,
+		YEnd:   80,
+	}
 	differentButton := baseButton
 	differentButton.Command = linkPGCN(1)
 	resolver := fakeResolver{live: map[int]LiveState{
-		1: {Visible: true, Fingerprint: []byte("first"), Buttons: []nav.Button{baseButton}, AuthoredEntry: true},
-		2: {Visible: true, Fingerprint: []byte("second"), Buttons: []nav.Button{differentButton}},
+		1: {
+			Visible:       true,
+			Fingerprint:   []byte("first"),
+			Buttons:       []nav.Button{baseButton},
+			AuthoredEntry: true,
+		},
+		2: {
+			Visible:     true,
+			Fingerprint: []byte("second"),
+			Buttons:     []nav.Button{differentButton},
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 2})
 	if err != nil {
@@ -234,15 +355,32 @@ func TestDiscoverTraversesButDoesNotCaptureManagerUtilityScreen(t *testing.T) {
 	t.Parallel()
 
 	logger := &graphTestLogger{}
-	utility := ifo.ProgramChain{Number: 1, Programs: 1, Cells: 1}
-	root := ifo.ProgramChain{Number: 2, MenuID: 3, Programs: 1, Cells: 1}
+	utility := ifo.ProgramChain{
+		Number:   1,
+		Programs: 1,
+		Cells:    1,
+	}
+	root := ifo.ProgramChain{
+		Number:   2,
+		MenuID:   3,
+		Programs: 1,
+		Cells:    1,
+	}
 	disc := ifo.Disc{Manager: ifo.File{
 		Kind:      ifo.KindManager,
 		Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{utility, root}}},
 	}}
 	resolver := fakeResolver{live: map[int]LiveState{
-		1: {Visible: true, Fingerprint: []byte("utility"), Buttons: []nav.Button{{Number: 1, Command: linkPGCN(2)}}},
-		2: {Visible: true, Fingerprint: []byte("root"), Buttons: []nav.Button{{Number: 1}}},
+		1: {
+			Visible:     true,
+			Fingerprint: []byte("utility"),
+			Buttons:     []nav.Button{{Number: 1, Command: linkPGCN(2)}},
+		},
+		2: {
+			Visible:     true,
+			Fingerprint: []byte("root"),
+			Buttons:     []nav.Button{{Number: 1}},
+		},
 	}}
 	result, err := Discover(context.Background(), disc, resolver, Options{MaxItems: 2, Logger: logger})
 	if err != nil {
@@ -269,7 +407,14 @@ func TestDiscoverRejectsItemLimitOverSafetyMaximum(t *testing.T) {
 }
 
 func TestDiscoverMapsProgramToAuthoredCell(t *testing.T) {
-	chain := ifo.ProgramChain{Number: 1, EntryID: 0x83, MenuID: 3, Programs: 2, Cells: 3, ProgramMap: []uint8{1, 3}}
+	chain := ifo.ProgramChain{
+		Number:     1,
+		EntryID:    0x83,
+		MenuID:     3,
+		Programs:   2,
+		Cells:      3,
+		ProgramMap: []uint8{1, 3},
+	}
 	chain.PreCommands = []vm.Command{linkPGN(2)}
 	disc := ifo.Disc{Manager: ifo.File{Kind: ifo.KindManager, Languages: []ifo.LanguageUnit{{Code: "en", ProgramChains: []ifo.ProgramChain{chain}}}}}
 	resolver := &coordinateResolver{}
diff --git a/internal/dvdvideo/ifo/ifo.go b/internal/dvdvideo/ifo/ifo.go
index 952636f3..ee4013f8 100644
--- a/internal/dvdvideo/ifo/ifo.go
+++ b/internal/dvdvideo/ifo/ifo.go
@@ -670,7 +670,12 @@ func (r boundedReader) cellPositions(base, count int) ([]CellPosition, error) {
 }
 
 func dvdTime(data []byte) DVDTime {
-	return DVDTime{Hour: data[0], Minute: data[1], Second: data[2], Frame: data[3]}
+	return DVDTime{
+		Hour:   data[0],
+		Minute: data[1],
+		Second: data[2],
+		Frame:  data[3],
+	}
 }
 
 func boundedUint32(value uint32, label string) (int, error) {
diff --git a/internal/dvdvideo/ifo/ifo_test.go b/internal/dvdvideo/ifo/ifo_test.go
index ee3aaca2..2b8d853d 100644
--- a/internal/dvdvideo/ifo/ifo_test.go
+++ b/internal/dvdvideo/ifo/ifo_test.go
@@ -44,7 +44,12 @@ func TestParseRejectsTruncatedLanguageTable(t *testing.T) {
 }
 
 func TestDVDTimeDuration(t *testing.T) {
-	duration, err := (DVDTime{Hour: 0x01, Minute: 0x02, Second: 0x03, Frame: 0x52}).Duration()
+	duration, err := (DVDTime{
+		Hour:   0x01,
+		Minute: 0x02,
+		Second: 0x03,
+		Frame:  0x52,
+	}).Duration()
 	if err != nil {
 		t.Fatalf("Duration: %v", err)
 	}
diff --git a/internal/dvdvideo/nav/nav_test.go b/internal/dvdvideo/nav/nav_test.go
index c54c64d0..f369a894 100644
--- a/internal/dvdvideo/nav/nav_test.go
+++ b/internal/dvdvideo/nav/nav_test.go
@@ -92,7 +92,11 @@ func TestRouteSPUFragmentsRejectsTruncatedPESHeader(t *testing.T) {
 func TestScanCellParsesNAVAndSPU(t *testing.T) {
 	sector := syntheticNAVSector()
 	reader := bytes.NewReader(sector)
-	result, err := ScanCell(reader, int64(len(sector)), 0, 0, CellScanOptions{MaxSectors: 1, MaxSPUPackets: 1, MaxSPUBytes: 3})
+	result, err := ScanCell(reader, int64(len(sector)), 0, 0, CellScanOptions{
+		MaxSectors:    1,
+		MaxSPUPackets: 1,
+		MaxSPUBytes:   3,
+	})
 	if err != nil {
 		t.Fatalf("ScanCell: %v", err)
 	}
diff --git a/internal/dvdvideo/render/render.go b/internal/dvdvideo/render/render.go
index cc144930..77cf0ac6 100644
--- a/internal/dvdvideo/render/render.go
+++ b/internal/dvdvideo/render/render.go
@@ -155,7 +155,11 @@ func Probe(ctx context.Context, runner Runner, executable string) (Capability, e
 	if version == "" {
 		version = firstLine(string(versionOutput.Stderr))
 	}
-	return Capability{Available: true, Version: version, Options: options}, nil
+	return Capability{
+		Available: true,
+		Version:   version,
+		Options:   options,
+	}, nil
 }
 
 func firstLine(value string) string {
@@ -191,7 +195,10 @@ func BuildArgs(request FrameRequest) ([]string, error) {
 	if strings.TrimSpace(request.SourcePath) == "" {
 		return nil, fmt.Errorf("%w: empty source", ErrFrame)
 	}
-	if request.VTS < 0 || request.VTS > 99 || request.LanguageUnit < 1 || request.LanguageUnit > 99 || request.PGC < 1 || request.PGC > 999 || request.Program < 1 || request.Program > 255 || request.Target < 0 {
+	if request.VTS < 0 || request.VTS > 99 || request.LanguageUnit < 1 || request.LanguageUnit > 99 || request.PGC < 1 || request.PGC > 999 ||
+		request.Program < 1 ||
+		request.Program > 255 ||
+		request.Target < 0 {
 		return nil, fmt.Errorf("%w: invalid menu coordinate", ErrFrame)
 	}
 	args := []string{
@@ -239,7 +246,8 @@ func DecodeFrame(ctx context.Context, runner Runner, executable string, request
 	if err != nil {
 		return nil, fmt.Errorf("%w: image header", ErrFrame)
 	}
-	if config.Width <= 0 || config.Height <= 0 || config.Width > MaxFrameWidth || config.Height > MaxFrameHeight || uint64(config.Width)*uint64(config.Height) > MaxFramePixels {
+	if config.Width <= 0 || config.Height <= 0 || config.Width > MaxFrameWidth || config.Height > MaxFrameHeight ||
+		uint64(config.Width)*uint64(config.Height) > MaxFramePixels {
 		return nil, fmt.Errorf("%w: image dimensions", ErrFrame)
 	}
 	frame, err := png.Decode(io.LimitReader(bytes.NewReader(output.Stdout), MaxFrameBytes))
diff --git a/internal/dvdvideo/render/render_test.go b/internal/dvdvideo/render/render_test.go
index 9616a91f..08f36611 100644
--- a/internal/dvdvideo/render/render_test.go
+++ b/internal/dvdvideo/render/render_test.go
@@ -43,7 +43,12 @@ func TestDecodeFrameRejectsOversizedDimensions(t *testing.T) {
 		t.Fatalf("encode PNG: %v", err)
 	}
 	runner := &fakeRunner{outputs: []Output{{Stdout: payload.Bytes()}}}
-	_, err := DecodeFrame(context.Background(), runner, "ffmpeg", FrameRequest{SourcePath: `C:\path\to\VIDEO_TS`, LanguageUnit: 1, PGC: 1, Program: 1})
+	_, err := DecodeFrame(context.Background(), runner, "ffmpeg", FrameRequest{
+		SourcePath:   `C:\path\to\VIDEO_TS`,
+		LanguageUnit: 1,
+		PGC:          1,
+		Program:      1,
+	})
 	if !errors.Is(err, ErrFrame) {
 		t.Fatalf("DecodeFrame error = %v, want ErrFrame", err)
 	}
diff --git a/internal/dvdvideo/spu/spu.go b/internal/dvdvideo/spu/spu.go
index 0cda70b1..29f18503 100644
--- a/internal/dvdvideo/spu/spu.go
+++ b/internal/dvdvideo/spu/spu.go
@@ -318,7 +318,12 @@ func clutColor(value uint32, alpha uint8) color.NRGBA {
 	cr := boundedByte((value >> 8) & 0xff)
 	cb := boundedByte(value & 0xff)
 	r, g, b := color.YCbCrToRGB(y, cb, cr)
-	return color.NRGBA{R: r, G: g, B: b, A: alpha}
+	return color.NRGBA{
+		R: r,
+		G: g,
+		B: b,
+		A: alpha,
+	}
 }
 
 // Composite overlays subpicture pixels and an optional selected-button
diff --git a/internal/dvdvideo/vm/vm.go b/internal/dvdvideo/vm/vm.go
index 4ae33bd3..e6f056be 100644
--- a/internal/dvdvideo/vm/vm.go
+++ b/internal/dvdvideo/vm/vm.go
@@ -155,7 +155,11 @@ func Execute(commands []Command, registers *Registers, opts Options) (Result, er
 		}
 	}
 
-	e := executor{registers: registers, now: now, random: random}
+	e := executor{
+		registers: registers,
+		now:       now,
+		random:    random,
+	}
 	executed := 0
 	for row := 0; row < len(commands); executed++ {
 		if executed >= budget {
@@ -166,7 +170,11 @@ func Execute(commands []Command, registers *Registers, opts Options) (Result, er
 			return Result{Executed: executed + 1}, fmt.Errorf("DVD VM row %d: %w", row+1, err)
 		}
 		if hasLink {
-			return Result{Link: link, HasLink: true, Executed: executed + 1}, nil
+			return Result{
+				Link:     link,
+				HasLink:  true,
+				Executed: executed + 1,
+			}, nil
 		}
 		if line > 0 {
 			if line == 256 {
@@ -463,11 +471,23 @@ func linkInstruction(instruction uint64) (Link, bool) {
 	case 4:
 		return Link{Command: LinkPGCN, Data1: bits16(instruction, 14, 15)}, true
 	case 5:
-		return Link{Command: LinkPTTN, Data1: bits16(instruction, 9, 10), Data2: bits16(instruction, 15, 6)}, true
+		return Link{
+			Command: LinkPTTN,
+			Data1:   bits16(instruction, 9, 10),
+			Data2:   bits16(instruction, 15, 6),
+		}, true
 	case 6:
-		return Link{Command: LinkPGN, Data1: bits16(instruction, 6, 7), Data2: bits16(instruction, 15, 6)}, true
+		return Link{
+			Command: LinkPGN,
+			Data1:   bits16(instruction, 6, 7),
+			Data2:   bits16(instruction, 15, 6),
+		}, true
 	case 7:
-		return Link{Command: LinkCN, Data1: bits16(instruction, 7, 8), Data2: bits16(instruction, 15, 6)}, true
+		return Link{
+			Command: LinkCN,
+			Data1:   bits16(instruction, 7, 8),
+			Data2:   bits16(instruction, 15, 6),
+		}, true
 	default:
 		return Link{}, false
 	}
@@ -482,7 +502,11 @@ func jumpInstruction(instruction uint64) (Link, bool) {
 	case 3:
 		return Link{Command: JumpVTSTT, Data1: bits16(instruction, 22, 7)}, true
 	case 5:
-		return Link{Command: JumpVTSPTT, Data1: bits16(instruction, 22, 7), Data2: bits16(instruction, 41, 10)}, true
+		return Link{
+			Command: JumpVTSPTT,
+			Data1:   bits16(instruction, 22, 7),
+			Data2:   bits16(instruction, 41, 10),
+		}, true
 	case 6:
 		switch bits(instruction, 23, 2) {
 		case 0:
@@ -490,7 +514,12 @@ func jumpInstruction(instruction uint64) (Link, bool) {
 		case 1:
 			return Link{Command: JumpVMGMMenu, Data1: bits16(instruction, 19, 4)}, true
 		case 2:
-			return Link{Command: JumpVTSM, Data1: bits16(instruction, 31, 8), Data2: bits16(instruction, 39, 8), Data3: bits16(instruction, 19, 4)}, true
+			return Link{
+				Command: JumpVTSM,
+				Data1:   bits16(instruction, 31, 8),
+				Data2:   bits16(instruction, 39, 8),
+				Data3:   bits16(instruction, 19, 4),
+			}, true
 		case 3:
 			return Link{Command: JumpVMGMPGC, Data1: bits16(instruction, 46, 15)}, true
 		}
@@ -500,11 +529,23 @@ func jumpInstruction(instruction uint64) (Link, bool) {
 		case 0:
 			return Link{Command: CallFirstPlay, Data1: resume}, true
 		case 1:
-			return Link{Command: CallVMGMMenu, Data1: bits16(instruction, 19, 4), Data2: resume}, true
+			return Link{
+				Command: CallVMGMMenu,
+				Data1:   bits16(instruction, 19, 4),
+				Data2:   resume,
+			}, true
 		case 2:
-			return Link{Command: CallVTSM, Data1: bits16(instruction, 19, 4), Data2: resume}, true
+			return Link{
+				Command: CallVTSM,
+				Data1:   bits16(instruction, 19, 4),
+				Data2:   resume,
+			}, true
 		case 3:
-			return Link{Command: CallVMGMPGC, Data1: bits16(instruction, 46, 15), Data2: resume}, true
+			return Link{
+				Command: CallVMGMPGC,
+				Data1:   bits16(instruction, 46, 15),
+				Data2:   resume,
+			}, true
 		}
 	}
 	return Link{}, false
diff --git a/internal/errors/errors.go b/internal/errors/errors.go
index c3ae4bce..5b0525bb 100644
--- a/internal/errors/errors.go
+++ b/internal/errors/errors.go
@@ -1,10 +1,12 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+// Package errors defines sentinel failure classes shared across internal package boundaries.
 package errors
 
 import "errors"
 
+// These sentinels may be wrapped; callers should classify them with [errors.Is].
 var (
 	ErrNotImplemented = errors.New("not implemented")
 	ErrInvalidInput   = errors.New("invalid input")
diff --git a/internal/externalidentity/resolver.go b/internal/externalidentity/resolver.go
new file mode 100644
index 00000000..86b02183
--- /dev/null
+++ b/internal/externalidentity/resolver.go
@@ -0,0 +1,655 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package externalidentity resolves one canonical, source-scoped external
+// identity without persisting it. Prepared-release publication owns the commit.
+package externalidentity
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ContractVersion changes whenever identity resolution semantics become
+// incompatible with a previously resolved identity.
+const ContractVersion = "external-identity-v1"
+
+// Request contains normalized source scope and identity-resolution intent. It
+// carries no gathered MediaInfo, scene, Arr, tracker, or provider evidence.
+type Request struct {
+	SourcePath        string
+	SourceFingerprint string
+	Generation        api.PreparedGeneration
+	Intent            ResolutionIntent
+}
+
+// ResolutionIntent contains caller instructions that affect canonical identity
+// resolution and its lineage fingerprint. Provider override pointers use nil
+// to preserve evidence, non-positive values to clear an ID, and positive values
+// to set one. CategoryOverride similarly preserves on nil, clears on empty or
+// unknown, and accepts movie or TV as explicit values.
+type ResolutionIntent struct {
+	Title                   string
+	Year                    int
+	Season                  int
+	Episode                 int
+	TrackerContext          []string
+	ProviderOverrides       api.ExternalIDOverrides
+	CategoryOverride        *api.CanonicalCategory
+	ReResolve               bool
+	RefreshProviderMetadata bool
+}
+
+// EvidenceFingerprint identifies one non-secret evidence snapshot considered
+// during resolution. Digest is a lowercase hexadecimal SHA-256 hash.
+type EvidenceFingerprint struct {
+	Kind   string
+	Digest string
+}
+
+// Result contains the canonical identity candidate, source-scoped provider
+// metadata, diagnostics, typed missing requirements, and evidence lineage.
+// The prepared-release module decides whether and how to commit it.
+type Result struct {
+	Identity             api.ExternalIdentity
+	ProviderMetadata     api.SourceScopedMetadata
+	Diagnostics          []api.PreparationDiagnostic
+	MissingRequirements  []api.MissingRequirementError
+	EvidenceFingerprints []EvidenceFingerprint
+}
+
+// CandidateEvidence is temporary provider-resolution evidence supplied by a
+// private adapter. Candidate lists remain diagnostics and never become
+// canonical identity facts by themselves.
+type CandidateEvidence struct {
+	Identity   api.ExternalIdentity
+	Metadata   api.SourceScopedMetadata
+	Candidates []api.ExternalIdentityCandidate
+}
+
+// CandidateSource supplies provider evidence without persistence. It exists
+// at the resolver boundary so provider clients remain private implementation
+// details rather than request fields.
+type CandidateSource interface {
+	ResolveIdentityCandidate(context.Context, Request) (CandidateEvidence, error)
+}
+
+// Clone returns a detached result projection.
+func (r Result) Clone() (Result, error) {
+	var cloned Result
+	payload, err := json.Marshal(r)
+	if err != nil {
+		return Result{}, fmt.Errorf("external identity: clone result: marshal: %w", err)
+	}
+	if err := json.Unmarshal(payload, &cloned); err != nil {
+		return Result{}, fmt.Errorf("external identity: clone result: unmarshal: %w", err)
+	}
+	return cloned, nil
+}
+
+type legacyEvidence struct {
+	identity api.ExternalIdentity
+	metadata api.SourceScopedMetadata
+	hasIDs   bool
+	hasMeta  bool
+}
+
+type evidenceLoader interface {
+	load(context.Context, string) (legacyEvidence, error)
+}
+
+type repositoryEvidenceLoader struct {
+	repo api.ReleaseStateRepository
+}
+
+func (l repositoryEvidenceLoader) load(ctx context.Context, sourcePath string) (legacyEvidence, error) {
+	var evidence legacyEvidence
+	ids, err := l.repo.GetExternalIdentity(ctx, sourcePath)
+	if err == nil {
+		evidence.identity = ids
+		evidence.hasIDs = true
+	} else if !errors.Is(err, internalerrors.ErrNotFound) {
+		return legacyEvidence{}, fmt.Errorf("load stored identity evidence: %w", err)
+	}
+	metadata, err := l.repo.GetExternalMetadata(ctx, sourcePath)
+	if err == nil {
+		evidence.metadata = metadata
+		evidence.hasMeta = true
+	} else if !errors.Is(err, internalerrors.ErrNotFound) {
+		return legacyEvidence{}, fmt.Errorf("load stored provider evidence: %w", err)
+	}
+	return evidence, nil
+}
+
+// Resolver owns identity evidence precedence, tri-state overrides, source
+// serialization, diagnostics, and immutable result projection.
+type Resolver struct {
+	evidence  evidenceLoader
+	candidate CandidateSource
+	gates     sourceGates
+	now       func() time.Time
+}
+
+// New constructs a resolver using the repository only as a private legacy
+// evidence adapter. Resolve never writes through it.
+func New(repo api.ReleaseStateRepository) (*Resolver, error) {
+	return NewWithCandidateSource(repo, nil)
+}
+
+// NewWithCandidateSource constructs a resolver with an optional, read-only
+// provider evidence source. Neither source can publish canonical state.
+func NewWithCandidateSource(repo api.ReleaseStateRepository, candidate CandidateSource) (*Resolver, error) {
+	if isNilRepository(repo) {
+		return nil, errors.New("external identity: repository is required")
+	}
+	return &Resolver{
+		evidence:  repositoryEvidenceLoader{repo: repo},
+		candidate: candidate,
+		now:       func() time.Time { return time.Now().UTC() },
+	}, nil
+}
+
+func isNilRepository(repo api.ReleaseStateRepository) bool {
+	if repo == nil {
+		return true
+	}
+	value := reflect.ValueOf(repo)
+	return value.Kind() == reflect.Pointer && value.IsNil()
+}
+
+// Resolve serializes work per normalized source, applies stored evidence then
+// provider candidates then explicit overrides, and returns a detached,
+// unpersisted result. Provider metadata whose ID no longer matches the final
+// identity is removed; absent IDs and category are reported through
+// Result.MissingRequirements rather than as an error.
+func (r *Resolver) Resolve(ctx context.Context, request Request) (Result, error) {
+	if r == nil || r.evidence == nil {
+		return Result{}, errors.New("external identity: resolver is not initialized")
+	}
+	if ctx == nil {
+		return Result{}, errors.New("external identity: context is required")
+	}
+	normalized, err := normalizeSourcePath(request.SourcePath)
+	if err != nil {
+		return Result{}, err
+	}
+	if strings.TrimSpace(request.SourceFingerprint) == "" || request.Generation == 0 {
+		return Result{}, internalerrors.ErrInvalidInput
+	}
+	request.SourcePath = normalized
+
+	release, err := r.gates.acquire(ctx, normalized)
+	if err != nil {
+		return Result{}, fmt.Errorf("external identity: wait for source: %w", err)
+	}
+	defer release()
+	if err := ctx.Err(); err != nil {
+		return Result{}, fmt.Errorf("external identity: resolve canceled: %w", err)
+	}
+
+	evidence, err := r.evidence.load(ctx, normalized)
+	if err != nil {
+		return Result{}, fmt.Errorf("external identity: %w", err)
+	}
+	intentFingerprint, err := fingerprintIntent(request.Intent)
+	if err != nil {
+		return Result{}, err
+	}
+	var candidate CandidateEvidence
+	if r.candidate != nil {
+		candidate, err = r.candidate.ResolveIdentityCandidate(ctx, request)
+		if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
+			return Result{}, fmt.Errorf("external identity: resolve provider evidence: %w", err)
+		}
+	}
+	result, err := r.resolveCandidate(request, intentFingerprint, evidence, candidate)
+	if err != nil {
+		return Result{}, err
+	}
+	return result.Clone()
+}
+
+func (r *Resolver) resolveCandidate(
+	request Request,
+	intentFingerprint string,
+	evidence legacyEvidence,
+	candidate CandidateEvidence,
+) (Result, error) {
+	resolvedAt := r.now().UTC()
+	identity := api.ExternalIdentity{
+		SourcePath: request.SourcePath,
+		Generation: request.Generation,
+		Category:   api.CanonicalCategoryUnknown,
+		Provenance: unknownProvenance(),
+		Overrides:  unsetOverrides(),
+		Conflict:   api.IdentityConflictNone,
+		Resolution: api.IdentityResolutionKey{
+			SourceFingerprint: request.SourceFingerprint,
+			IntentFingerprint: intentFingerprint,
+			ContractVersion:   ContractVersion,
+		},
+		ResolvedAt: resolvedAt,
+	}
+	metadata := api.SourceScopedMetadata{
+		SourcePath: request.SourcePath,
+		Generation: request.Generation,
+		UpdatedAt:  resolvedAt,
+	}
+	result := Result{Identity: identity, ProviderMetadata: metadata}
+
+	if evidence.hasIDs {
+		applyStoredIdentity(&result.Identity, evidence.identity)
+		if err := appendEvidenceFingerprint(&result, "stored_identity", evidence.identity); err != nil {
+			return Result{}, err
+		}
+		result.Diagnostics = append(result.Diagnostics, api.PreparationDiagnostic{
+			Code:     "legacy_identity_evidence",
+			Severity: api.DiagnosticSeverityInfo,
+			Message:  "stored external identity was considered as resolution evidence",
+		})
+	}
+	if evidence.hasMeta && sourceEvidenceMatches(evidence.metadata.SourcePath, request.SourcePath) {
+		result.ProviderMetadata = sourceScopedMetadata(evidence.metadata, request.SourcePath, request.Generation, resolvedAt)
+		if err := appendEvidenceFingerprint(&result, "stored_provider_metadata", evidence.metadata); err != nil {
+			return Result{}, err
+		}
+	}
+	if err := applyCandidateEvidence(&result, candidate, request.SourcePath, request.Generation, resolvedAt); err != nil {
+		return Result{}, err
+	}
+	if err := applyResolutionIntent(&result.Identity, request.Intent); err != nil {
+		return Result{}, err
+	}
+	invalidateMismatchedMetadata(&result.ProviderMetadata, result.Identity)
+	result.MissingRequirements = missingRequirements(result.Identity)
+	return result, nil
+}
+
+func applyCandidateEvidence(
+	result *Result,
+	candidate CandidateEvidence,
+	sourcePath string,
+	generation api.PreparedGeneration,
+	resolvedAt time.Time,
+) error {
+	if result == nil {
+		return nil
+	}
+	if hasCandidateIdentity(candidate.Identity) && sourceEvidenceMatches(candidate.Identity.SourcePath, sourcePath) {
+		applyCandidateIdentity(&result.Identity, candidate.Identity)
+		if err := appendEvidenceFingerprint(result, "provider_candidate", candidate.Identity); err != nil {
+			return err
+		}
+	}
+	if hasCandidateMetadata(candidate.Metadata) && sourceEvidenceMatches(candidate.Metadata.SourcePath, sourcePath) {
+		result.ProviderMetadata = sourceScopedMetadata(candidate.Metadata, sourcePath, generation, resolvedAt)
+		if err := appendEvidenceFingerprint(result, "provider_metadata_candidate", candidate.Metadata); err != nil {
+			return err
+		}
+	}
+	if diagnostics := candidateDiagnostics(candidate.Candidates); len(diagnostics) > 0 {
+		result.Diagnostics = append(result.Diagnostics, diagnostics...)
+	}
+	return nil
+}
+
+func hasCandidateIdentity(value api.ExternalIdentity) bool {
+	return value.TMDBID > 0 || value.IMDBID > 0 || value.TVDBID > 0 || value.TVmazeID > 0 || value.MALID > 0 || value.Category != ""
+}
+
+func hasCandidateMetadata(value api.SourceScopedMetadata) bool {
+	return value.TMDB != nil || value.IMDB != nil || value.TVDB != nil || value.TVmaze != nil || value.AniList != nil || value.Bluray != nil
+}
+
+func applyCandidateIdentity(identity *api.ExternalIdentity, candidate api.ExternalIdentity) {
+	if identity == nil {
+		return
+	}
+	applyCandidateProvider(&identity.TMDBID, &identity.Provenance.TMDB, candidate.TMDBID, candidate.Provenance.TMDB)
+	applyCandidateProvider(&identity.IMDBID, &identity.Provenance.IMDB, candidate.IMDBID, candidate.Provenance.IMDB)
+	applyCandidateProvider(&identity.TVDBID, &identity.Provenance.TVDB, candidate.TVDBID, candidate.Provenance.TVDB)
+	applyCandidateProvider(&identity.TVmazeID, &identity.Provenance.TVmaze, candidate.TVmazeID, candidate.Provenance.TVmaze)
+	applyCandidateProvider(&identity.MALID, &identity.Provenance.MAL, candidate.MALID, candidate.Provenance.MAL)
+	if category, err := api.NormalizeCanonicalCategory(string(candidate.Category)); err == nil && category != api.CanonicalCategoryUnknown {
+		identity.Category = category
+		identity.Provenance.Category = candidate.Provenance.Category
+		if identity.Provenance.Category == "" || identity.Provenance.Category == api.IdentityProvenanceUnknown {
+			identity.Provenance.Category = api.IdentityProvenanceProvider
+		}
+	}
+}
+
+func applyCandidateProvider(target *int, provenance *api.IdentityProvenance, value int, source api.IdentityProvenance) {
+	if value <= 0 {
+		return
+	}
+	*target = value
+	*provenance = source
+	if *provenance == "" || *provenance == api.IdentityProvenanceUnknown {
+		*provenance = api.IdentityProvenanceProvider
+	}
+}
+
+func candidateDiagnostics(value []api.ExternalIdentityCandidate) []api.PreparationDiagnostic {
+	candidates := make([]api.ExternalIdentityCandidate, 0, len(value))
+	for _, candidate := range value {
+		provider := api.IdentityProvider(strings.ToLower(strings.TrimSpace(string(candidate.Provider))))
+		if provider != api.IdentityProviderTMDB && provider != api.IdentityProviderIMDB {
+			continue
+		}
+		category, _ := api.NormalizeCanonicalCategory(string(candidate.Category))
+		candidates = append(candidates, api.ExternalIdentityCandidate{
+			Provider:      provider,
+			ID:            candidate.ID,
+			Title:         candidate.Title,
+			OriginalTitle: candidate.OriginalTitle,
+			Year:          candidate.Year,
+			Category:      category,
+			MediaType:     candidate.MediaType,
+			Overview:      candidate.Overview,
+			PosterURL:     candidate.PosterURL,
+			Similarity:    candidate.Similarity,
+		})
+	}
+	if len(candidates) == 0 {
+		return nil
+	}
+	return []api.PreparationDiagnostic{{
+		Code:       "external_identity_candidates",
+		Severity:   api.DiagnosticSeverityInfo,
+		Message:    "provider candidates were considered during identity resolution",
+		Candidates: candidates,
+	}}
+}
+
+func applyStoredIdentity(identity *api.ExternalIdentity, stored api.ExternalIdentity) {
+	if identity == nil || !sourceEvidenceMatches(stored.SourcePath, identity.SourcePath) {
+		return
+	}
+	identity.TMDBID = stored.TMDBID
+	identity.IMDBID = stored.IMDBID
+	identity.TVDBID = stored.TVDBID
+	identity.TVmazeID = stored.TVmazeID
+	identity.MALID = stored.MALID
+	if category, err := api.NormalizeCanonicalCategory(string(stored.Category)); err == nil {
+		identity.Category = category
+	}
+	identity.Provenance = stored.Provenance
+	ensureStoredProvenance(&identity.Provenance.TMDB, stored.TMDBID)
+	ensureStoredProvenance(&identity.Provenance.IMDB, stored.IMDBID)
+	ensureStoredProvenance(&identity.Provenance.TVDB, stored.TVDBID)
+	ensureStoredProvenance(&identity.Provenance.TVmaze, stored.TVmazeID)
+	ensureStoredProvenance(&identity.Provenance.MAL, stored.MALID)
+	ensureStoredProvenance(&identity.Provenance.Category, boolInt(identity.Category != api.CanonicalCategoryUnknown))
+}
+
+func ensureStoredProvenance(provenance *api.IdentityProvenance, value int) {
+	if value > 0 && (*provenance == "" || *provenance == api.IdentityProvenanceUnknown) {
+		*provenance = api.IdentityProvenanceLegacy
+	}
+}
+
+func applyResolutionIntent(identity *api.ExternalIdentity, intent ResolutionIntent) error {
+	if identity == nil {
+		return internalerrors.ErrInvalidInput
+	}
+	applyProviderOverride(&identity.TMDBID, &identity.Provenance.TMDB, &identity.Overrides.TMDB, intent.ProviderOverrides.TMDBID)
+	applyProviderOverride(&identity.IMDBID, &identity.Provenance.IMDB, &identity.Overrides.IMDB, intent.ProviderOverrides.IMDBID)
+	applyProviderOverride(&identity.TVDBID, &identity.Provenance.TVDB, &identity.Overrides.TVDB, intent.ProviderOverrides.TVDBID)
+	applyProviderOverride(&identity.TVmazeID, &identity.Provenance.TVmaze, &identity.Overrides.TVmaze, intent.ProviderOverrides.TVmazeID)
+	applyProviderOverride(&identity.MALID, &identity.Provenance.MAL, &identity.Overrides.MAL, intent.ProviderOverrides.MALID)
+	if intent.CategoryOverride != nil {
+		category := *intent.CategoryOverride
+		switch category {
+		case "", api.CanonicalCategoryUnknown:
+			identity.Category = api.CanonicalCategoryUnknown
+			identity.Overrides.Category = api.OverrideStateClear
+		case api.CanonicalCategoryMovie, api.CanonicalCategoryTV:
+			identity.Category = category
+			identity.Overrides.Category = api.OverrideStateValue
+		default:
+			return fmt.Errorf("external identity: invalid category override %q: %w", category, internalerrors.ErrInvalidInput)
+		}
+		identity.Provenance.Category = api.IdentityProvenanceExplicit
+	}
+	return nil
+}
+
+func applyProviderOverride(id *int, provenance *api.IdentityProvenance, state *api.OverrideState, override *int) {
+	if override == nil {
+		return
+	}
+	*provenance = api.IdentityProvenanceExplicit
+	if *override <= 0 {
+		*id = 0
+		*state = api.OverrideStateClear
+		return
+	}
+	*id = *override
+	*state = api.OverrideStateValue
+}
+
+func sourceScopedMetadata(
+	stored api.SourceScopedMetadata,
+	sourcePath string,
+	generation api.PreparedGeneration,
+	updatedAt time.Time,
+) api.SourceScopedMetadata {
+	return api.SourceScopedMetadata{
+		SourcePath: sourcePath,
+		Generation: generation,
+		TMDB:       stored.TMDB,
+		IMDB:       stored.IMDB,
+		TVDB:       stored.TVDB,
+		TVmaze:     stored.TVmaze,
+		AniList:    stored.AniList,
+		Bluray:     stored.Bluray,
+		UpdatedAt:  updatedAt,
+	}
+}
+
+func invalidateMismatchedMetadata(metadata *api.SourceScopedMetadata, identity api.ExternalIdentity) {
+	if metadata == nil {
+		return
+	}
+	if metadata.TMDB != nil && metadata.TMDB.TMDBID != identity.TMDBID {
+		metadata.TMDB = nil
+	}
+	if metadata.IMDB != nil && metadata.IMDB.IMDBID != identity.IMDBID {
+		metadata.IMDB = nil
+	}
+	if metadata.TVDB != nil && metadata.TVDB.TVDBID != identity.TVDBID {
+		metadata.TVDB = nil
+	}
+	if metadata.TVmaze != nil && metadata.TVmaze.TVmazeID != identity.TVmazeID {
+		metadata.TVmaze = nil
+	}
+	if metadata.AniList != nil && metadata.AniList.MALID != identity.MALID {
+		metadata.AniList = nil
+	}
+}
+
+func missingRequirements(identity api.ExternalIdentity) []api.MissingRequirementError {
+	requirements := make([]api.MissingRequirementError, 0, 6)
+	for _, provider := range []api.IdentityProvider{
+		api.IdentityProviderTMDB,
+		api.IdentityProviderIMDB,
+		api.IdentityProviderTVDB,
+		api.IdentityProviderTVmaze,
+		api.IdentityProviderMAL,
+	} {
+		if _, ok := identity.ProviderID(provider); !ok {
+			requirements = append(requirements, api.MissingRequirementError{
+				Requirement: api.RequirementKindProviderID,
+				Provider:    provider,
+			})
+		}
+	}
+	if _, err := identity.RequireCategory(); err != nil {
+		requirements = append(requirements, api.MissingRequirementError{Requirement: api.RequirementKindCategory})
+	}
+	return requirements
+}
+
+func unknownProvenance() api.IdentityProvenanceSet {
+	return api.IdentityProvenanceSet{
+		TMDB:     api.IdentityProvenanceUnknown,
+		IMDB:     api.IdentityProvenanceUnknown,
+		TVDB:     api.IdentityProvenanceUnknown,
+		TVmaze:   api.IdentityProvenanceUnknown,
+		MAL:      api.IdentityProvenanceUnknown,
+		Category: api.IdentityProvenanceUnknown,
+	}
+}
+
+func unsetOverrides() api.IdentityOverrideState {
+	return api.IdentityOverrideState{
+		TMDB:     api.OverrideStateUnset,
+		IMDB:     api.OverrideStateUnset,
+		TVDB:     api.OverrideStateUnset,
+		TVmaze:   api.OverrideStateUnset,
+		MAL:      api.OverrideStateUnset,
+		Category: api.OverrideStateUnset,
+	}
+}
+
+func boolInt(value bool) int {
+	if value {
+		return 1
+	}
+	return 0
+}
+
+func sourceEvidenceMatches(storedPath string, sourcePath string) bool {
+	storedPath = strings.TrimSpace(storedPath)
+	if storedPath == "" {
+		return true
+	}
+	return filepath.Clean(storedPath) == filepath.Clean(sourcePath)
+}
+
+func normalizeSourcePath(sourcePath string) (string, error) {
+	sourcePath = strings.TrimSpace(sourcePath)
+	if sourcePath == "" {
+		return "", internalerrors.ErrInvalidInput
+	}
+	normalized, err := filepath.Abs(sourcePath)
+	if err != nil {
+		return "", fmt.Errorf("external identity: normalize source path: %w", err)
+	}
+	return filepath.Clean(normalized), nil
+}
+
+func fingerprintIntent(intent ResolutionIntent) (string, error) {
+	normalized := intent
+	normalized.Title = strings.TrimSpace(normalized.Title)
+	normalized.TrackerContext = append([]string(nil), normalized.TrackerContext...)
+	for index := range normalized.TrackerContext {
+		normalized.TrackerContext[index] = strings.ToUpper(strings.TrimSpace(normalized.TrackerContext[index]))
+	}
+	payload, err := json.Marshal(normalized)
+	if err != nil {
+		return "", fmt.Errorf("external identity: fingerprint intent: %w", err)
+	}
+	digest := sha256.Sum256(payload)
+	return hex.EncodeToString(digest[:]), nil
+}
+
+func appendEvidenceFingerprint(result *Result, kind string, evidence any) error {
+	fingerprint, err := fingerprintEvidence(kind, evidence)
+	if err != nil {
+		return err
+	}
+	result.EvidenceFingerprints = append(result.EvidenceFingerprints, fingerprint)
+	return nil
+}
+
+func fingerprintEvidence(kind string, evidence any) (EvidenceFingerprint, error) {
+	payload, err := json.Marshal(evidence)
+	if err != nil {
+		return EvidenceFingerprint{}, fmt.Errorf("external identity: marshal %s evidence fingerprint: %w", kind, err)
+	}
+	digest := sha256.Sum256(payload)
+	return EvidenceFingerprint{Kind: kind, Digest: hex.EncodeToString(digest[:])}, nil
+}
+
+type sourceWaiter struct {
+	ready chan struct{}
+}
+
+type sourceGate struct {
+	held    bool
+	waiters []*sourceWaiter
+}
+
+type sourceGates struct {
+	mu    sync.Mutex
+	gates map[string]*sourceGate
+}
+
+func (g *sourceGates) acquire(ctx context.Context, sourcePath string) (func(), error) {
+	g.mu.Lock()
+	if g.gates == nil {
+		g.gates = make(map[string]*sourceGate)
+	}
+	gate := g.gates[sourcePath]
+	if gate == nil {
+		gate = &sourceGate{held: true}
+		g.gates[sourcePath] = gate
+		g.mu.Unlock()
+		return func() { g.release(sourcePath, gate) }, nil
+	}
+	waiter := &sourceWaiter{ready: make(chan struct{})}
+	gate.waiters = append(gate.waiters, waiter)
+	g.mu.Unlock()
+
+	select {
+	case <-waiter.ready:
+		if err := ctx.Err(); err != nil {
+			g.release(sourcePath, gate)
+			return nil, fmt.Errorf("external identity: acquire source gate: %w", err)
+		}
+		return func() { g.release(sourcePath, gate) }, nil
+	case <-ctx.Done():
+		g.mu.Lock()
+		removed := false
+		for index, candidate := range gate.waiters {
+			if candidate != waiter {
+				continue
+			}
+			gate.waiters = append(gate.waiters[:index], gate.waiters[index+1:]...)
+			removed = true
+			break
+		}
+		g.mu.Unlock()
+		if !removed {
+			g.release(sourcePath, gate)
+		}
+		return nil, fmt.Errorf("external identity: wait for source gate: %w", ctx.Err())
+	}
+}
+
+func (g *sourceGates) release(sourcePath string, gate *sourceGate) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if len(gate.waiters) > 0 {
+		next := gate.waiters[0]
+		gate.waiters = gate.waiters[1:]
+		close(next.ready)
+		return
+	}
+	gate.held = false
+	delete(g.gates, sourcePath)
+}
diff --git a/internal/externalidentity/resolver_test.go b/internal/externalidentity/resolver_test.go
new file mode 100644
index 00000000..158c849a
--- /dev/null
+++ b/internal/externalidentity/resolver_test.go
@@ -0,0 +1,326 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package externalidentity
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type evidenceLoaderFunc func(context.Context, string) (legacyEvidence, error)
+
+func (f evidenceLoaderFunc) load(ctx context.Context, sourcePath string) (legacyEvidence, error) {
+	return f(ctx, sourcePath)
+}
+
+type candidateSourceFunc func(context.Context, Request) (CandidateEvidence, error)
+
+func (f candidateSourceFunc) ResolveIdentityCandidate(ctx context.Context, request Request) (CandidateEvidence, error) {
+	return f(ctx, request)
+}
+
+func TestResolvePromotesProviderEvidenceAndKeepsCandidateListsDiagnostic(t *testing.T) {
+	t.Parallel()
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+	resolver := &Resolver{
+		evidence: evidenceLoaderFunc(func(context.Context, string) (legacyEvidence, error) {
+			return legacyEvidence{}, nil
+		}),
+		candidate: candidateSourceFunc(func(_ context.Context, request Request) (CandidateEvidence, error) {
+			return CandidateEvidence{
+				Identity: api.ExternalIdentity{
+					SourcePath: request.SourcePath,
+					TMDBID:     1234567,
+					Category:   api.CanonicalCategoryMovie,
+					Provenance: api.IdentityProvenanceSet{TMDB: api.IdentityProvenanceProvider, Category: api.IdentityProvenanceProvider},
+				},
+				Metadata: api.SourceScopedMetadata{
+					SourcePath: request.SourcePath,
+					TMDB:       &api.TMDBMetadata{TMDBID: 1234567, Title: "Example Release"},
+				},
+				Candidates: []api.ExternalIdentityCandidate{{
+					Provider: api.IdentityProviderTMDB,
+					ID:       7654321,
+					Title:    "Example Candidate",
+					Category: api.CanonicalCategoryMovie,
+				}},
+			}, nil
+		}),
+		now: time.Now,
+	}
+
+	result, err := resolver.Resolve(context.Background(), Request{
+		SourcePath:        sourcePath,
+		SourceFingerprint: "source-fingerprint",
+		Generation:        3,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Identity.TMDBID != 1234567 || result.Identity.Category != api.CanonicalCategoryMovie ||
+		result.Identity.Provenance.TMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("identity = %#v", result.Identity)
+	}
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.TMDB.TMDBID != 1234567 {
+		t.Fatalf("provider metadata = %#v", result.ProviderMetadata)
+	}
+	if len(result.Diagnostics) != 1 || len(result.Diagnostics[0].Candidates) != 1 || result.Diagnostics[0].Candidates[0].ID != 7654321 {
+		t.Fatalf("diagnostics = %#v", result.Diagnostics)
+	}
+	if result.Identity.TMDBID == result.Diagnostics[0].Candidates[0].ID {
+		t.Fatal("diagnostic candidate became canonical identity")
+	}
+}
+
+func TestResolveAppliesTriStateIntentWithoutPersisting(t *testing.T) {
+	repoPath := filepath.Join(t.TempDir(), "external-identity.db")
+	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("open repository: %v", err)
+	}
+	t.Cleanup(func() { _ = repo.Close() })
+	if err := repo.Migrate(); err != nil {
+		t.Fatalf("migrate repository: %v", err)
+	}
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+	stored := api.ExternalIdentity{
+		SourcePath: sourcePath,
+		TMDBID:     100,
+		IMDBID:     200,
+		Category:   api.CanonicalCategoryMovie,
+		Provenance: api.IdentityProvenanceSet{TMDB: api.IdentityProvenanceTracker, IMDB: api.IdentityProvenanceProvider},
+	}
+	if err := repo.SaveExternalIdentity(context.Background(), stored); err != nil {
+		t.Fatalf("save stored IDs: %v", err)
+	}
+	if err := repo.SaveExternalMetadata(context.Background(), api.SourceScopedMetadata{
+		SourcePath: sourcePath,
+		TMDB:       &api.TMDBMetadata{TMDBID: 100, Title: "Example Release 2026"},
+		IMDB:       &api.IMDBMetadata{IMDBID: 200, Title: "Example Release 2026"},
+	}); err != nil {
+		t.Fatalf("save stored metadata: %v", err)
+	}
+	resolver, err := New(repo)
+	if err != nil {
+		t.Fatalf("new resolver: %v", err)
+	}
+	fixedNow := time.Date(2026, time.July, 14, 2, 3, 4, 0, time.UTC)
+	resolver.now = func() time.Time { return fixedNow }
+	clearTMDB := 0
+	overrideIMDB := 300
+	category := api.CanonicalCategoryTV
+
+	result, err := resolver.Resolve(context.Background(), Request{
+		SourcePath:        sourcePath,
+		SourceFingerprint: "source-fingerprint",
+		Generation:        5,
+		Intent: ResolutionIntent{
+			ProviderOverrides: api.ExternalIDOverrides{TMDBID: &clearTMDB, IMDBID: &overrideIMDB},
+			CategoryOverride:  &category,
+		},
+	})
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	identity := result.Identity
+	if identity.TMDBID != 0 || identity.IMDBID != 300 || identity.Category != api.CanonicalCategoryTV {
+		t.Fatalf("identity = %#v", identity)
+	}
+	if identity.Overrides.TMDB != api.OverrideStateClear || identity.Overrides.IMDB != api.OverrideStateValue ||
+		identity.Overrides.Category != api.OverrideStateValue {
+		t.Fatalf("override state = %#v", identity.Overrides)
+	}
+	if identity.Provenance.TMDB != api.IdentityProvenanceExplicit || identity.Provenance.IMDB != api.IdentityProvenanceExplicit ||
+		identity.Provenance.Category != api.IdentityProvenanceExplicit {
+		t.Fatalf("provenance = %#v", identity.Provenance)
+	}
+	if result.ProviderMetadata.TMDB != nil || result.ProviderMetadata.IMDB != nil {
+		t.Fatalf("mismatched provider metadata was retained: %#v", result.ProviderMetadata)
+	}
+	if identity.Resolution.ContractVersion != ContractVersion || identity.Resolution.IntentFingerprint == "" || identity.ResolvedAt != fixedNow {
+		t.Fatalf("resolution lineage = %#v", identity.Resolution)
+	}
+	if len(result.EvidenceFingerprints) != 2 || len(result.Diagnostics) != 1 {
+		t.Fatalf("evidence result = %#v", result)
+	}
+
+	loaded, err := repo.GetExternalIdentity(context.Background(), sourcePath)
+	if err != nil {
+		t.Fatalf("reload stored IDs: %v", err)
+	}
+	if loaded.TMDBID != stored.TMDBID || loaded.IMDBID != stored.IMDBID || loaded.Category != stored.Category {
+		t.Fatalf("resolver persisted candidate identity: %#v", loaded)
+	}
+}
+
+func TestResolveReturnsPartialIdentityAndTypedMissingRequirements(t *testing.T) {
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.WEB-GRP.mkv")
+	resolver := &Resolver{
+		evidence: evidenceLoaderFunc(func(context.Context, string) (legacyEvidence, error) {
+			return legacyEvidence{}, nil
+		}),
+		now: func() time.Time { return time.Date(2026, time.July, 14, 0, 0, 0, 0, time.UTC) },
+	}
+
+	result, err := resolver.Resolve(context.Background(), Request{
+		SourcePath:        sourcePath,
+		SourceFingerprint: "source-fingerprint",
+		Generation:        1,
+	})
+	if err != nil {
+		t.Fatalf("resolve partial identity: %v", err)
+	}
+	if result.Identity.Category != api.CanonicalCategoryUnknown || result.Identity.Conflict != api.IdentityConflictNone {
+		t.Fatalf("partial identity = %#v", result.Identity)
+	}
+	if len(result.MissingRequirements) != 6 {
+		t.Fatalf("missing requirements = %#v", result.MissingRequirements)
+	}
+	if result.ProviderMetadata.SourcePath != sourcePath || result.ProviderMetadata.Generation != 1 {
+		t.Fatalf("source-scoped metadata = %#v", result.ProviderMetadata)
+	}
+}
+
+func TestResolveCancellationDoesNotReorderSourceWaiters(t *testing.T) {
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.BluRay-GRP")
+	normalized, err := normalizeSourcePath(sourcePath)
+	if err != nil {
+		t.Fatalf("normalize source: %v", err)
+	}
+	firstEntered := make(chan struct{})
+	releaseFirst := make(chan struct{})
+	var mu sync.Mutex
+	calls := make([]string, 0, 2)
+	resolver := &Resolver{
+		evidence: evidenceLoaderFunc(func(_ context.Context, path string) (legacyEvidence, error) {
+			mu.Lock()
+			calls = append(calls, path)
+			call := len(calls)
+			mu.Unlock()
+			if call == 1 {
+				close(firstEntered)
+				<-releaseFirst
+			}
+			return legacyEvidence{}, nil
+		}),
+		now: time.Now,
+	}
+	request := Request{
+SourcePath: sourcePath,
+ SourceFingerprint: "source-fingerprint",
+ Generation: 1,
+}
+	errs := make(chan error, 3)
+	go func() {
+		_, err := resolver.Resolve(context.Background(), request)
+		errs <- err
+	}()
+	<-firstEntered
+
+	canceledCtx, cancel := context.WithCancel(context.Background())
+	go func() {
+		_, err := resolver.Resolve(canceledCtx, request)
+		errs <- err
+	}()
+	waitForSourceWaiters(t, &resolver.gates, normalized, 1)
+	go func() {
+		_, err := resolver.Resolve(context.Background(), request)
+		errs <- err
+	}()
+	waitForSourceWaiters(t, &resolver.gates, normalized, 2)
+	cancel()
+	waitForSourceWaiters(t, &resolver.gates, normalized, 1)
+	close(releaseFirst)
+
+	var canceled bool
+	for range 3 {
+		err := <-errs
+		if errors.Is(err, context.Canceled) {
+			canceled = true
+			continue
+		}
+		if err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+	}
+	if !canceled {
+		t.Fatal("canceled waiter returned no cancellation error")
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(calls) != 2 || calls[0] != normalized || calls[1] != normalized {
+		t.Fatalf("evidence calls = %v", calls)
+	}
+}
+
+func TestResolveKeepsDifferentSourcesConcurrent(t *testing.T) {
+	entered := make(chan string, 2)
+	release := make(chan struct{})
+	resolver := &Resolver{
+		evidence: evidenceLoaderFunc(func(_ context.Context, path string) (legacyEvidence, error) {
+			entered <- path
+			<-release
+			return legacyEvidence{}, nil
+		}),
+		now: time.Now,
+	}
+	requests := []Request{
+		{
+			SourcePath:        filepath.Join(t.TempDir(), "Example.Release.2026.A-GRP.mkv"),
+			SourceFingerprint: "source-a",
+			Generation:        1,
+		},
+		{
+			SourcePath:        filepath.Join(t.TempDir(), "Example.Release.2026.B-GRP.mkv"),
+			SourceFingerprint: "source-b",
+			Generation:        1,
+		},
+	}
+	errs := make(chan error, len(requests))
+	for _, request := range requests {
+		go func() {
+			_, err := resolver.Resolve(context.Background(), request)
+			errs <- err
+		}()
+	}
+	for range requests {
+		select {
+		case <-entered:
+		case <-time.After(time.Second):
+			t.Fatal("different source did not enter resolution concurrently")
+		}
+	}
+	close(release)
+	for range requests {
+		if err := <-errs; err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+	}
+}
+
+func waitForSourceWaiters(t *testing.T, gates *sourceGates, sourcePath string, want int) {
+	t.Helper()
+	deadline := time.Now().Add(time.Second)
+	for time.Now().Before(deadline) {
+		gates.mu.Lock()
+		gate := gates.gates[sourcePath]
+		got := 0
+		if gate != nil {
+			got = len(gate.waiters)
+		}
+		gates.mu.Unlock()
+		if got == want {
+			return
+		}
+		time.Sleep(time.Millisecond)
+	}
+	t.Fatalf("source waiters did not reach %d", want)
+}
diff --git a/internal/filesystem/copy.go b/internal/filesystem/copy.go
index dc9c93ca..832c858d 100644
--- a/internal/filesystem/copy.go
+++ b/internal/filesystem/copy.go
@@ -9,8 +9,9 @@ import (
 	"os"
 )
 
-// CopyFile copies a file from src to dst. If dst does not exist, it will be created.
-// If dst exists, it will be overwritten.
+// CopyFile copies src to dst, creating or truncating dst without creating its
+// parent directory. It applies the source mode when available; copy failures
+// may leave a partial destination.
 func CopyFile(src, dst string) error {
 	sourceFile, err := os.Open(src)
 	if err != nil {
diff --git a/internal/filesystem/disc.go b/internal/filesystem/disc.go
index a401c08a..5d4ea738 100644
--- a/internal/filesystem/disc.go
+++ b/internal/filesystem/disc.go
@@ -17,8 +17,9 @@ import (
 
 var errDiscFound = errors.New("disc type found")
 
-// DetectDiscType scans the path for disc folder markers.
-// It returns "BDMV", "DVD", "HDDVD", or "" when no disc type is found.
+// DetectDiscType recursively scans root for disc folder markers and returns
+// "BDMV", "DVD", "HDDVD", or "" when none is found. BDMV matching is
+// case-insensitive; VIDEO_TS and HVDVD_TS matching is exact.
 func DetectDiscType(ctx context.Context, root string) (string, error) {
 	trimmed := strings.TrimSpace(root)
 	if trimmed == "" {
diff --git a/internal/filesystem/playlist.go b/internal/filesystem/playlist.go
index c21ecbde..88ccd36b 100644
--- a/internal/filesystem/playlist.go
+++ b/internal/filesystem/playlist.go
@@ -18,7 +18,9 @@ import (
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 )
 
-// PlaylistInfo represents a discovered playlist file with its metrics and scoring.
+// PlaylistInfo describes one MPLS candidate. File and item names are basenames,
+// Duration is seconds, item sizes are bytes, and Score ranks main-feature
+// likelihood. Edition is currently left empty by discovery.
 type PlaylistInfo struct {
 	File     string
 	Duration float64
@@ -27,14 +29,14 @@ type PlaylistInfo struct {
 	Edition  string
 }
 
-// PlaylistItem represents a single file reference within a playlist.
+// PlaylistItem identifies one referenced stream basename and its size in bytes.
 type PlaylistItem struct {
 	File string
 	Size int64
 }
 
-// DiscoverPlaylists discovers and scores all MPLS playlists in a BDMV folder.
-// Returns playlists sorted by score (highest first), or an error if the BDMV directory is invalid.
+// DiscoverPlaylists discovers and scores all MPLS files in a BDMV folder. It
+// returns candidates ordered by descending score.
 func DiscoverPlaylists(ctx context.Context, bdmvRoot string) ([]PlaylistInfo, error) {
 	if bdmvRoot == "" {
 		return nil, fmt.Errorf("playlist: empty path: %w", internalerrors.ErrInvalidInput)
@@ -147,8 +149,8 @@ func calculatePlaylistScore(duration float64, items []PlaylistItem) float64 {
 	return score
 }
 
-// ParseMPLS parses an MPLS file and extracts duration and file references.
-// Returns (duration in seconds, []PlaylistItem, error).
+// ParseMPLS returns an MPLS playlist's duration in seconds and referenced M2TS
+// basenames with stream sizes in bytes.
 func ParseMPLS(mpslPath string) (float64, []PlaylistItem, error) {
 	file, err := os.Open(mpslPath)
 	if err != nil {
@@ -458,7 +460,8 @@ func attachStreamSizes(playlistDir string, items []PlaylistItem) ([]PlaylistItem
 	return result, nil
 }
 
-// FormatDuration converts seconds to HH:MM:SS format for display.
+// FormatDuration truncates fractional seconds and formats the result as
+// HH:MM:SS; hours are not capped at 24.
 func FormatDuration(seconds float64) string {
 	d := time.Duration(seconds * float64(time.Second))
 	h := int(d.Hours())
diff --git a/internal/filesystem/queue.go b/internal/filesystem/queue.go
index 1d69cf09..c2f77093 100644
--- a/internal/filesystem/queue.go
+++ b/internal/filesystem/queue.go
@@ -20,9 +20,9 @@ var queueVideoExts = map[string]struct{}{
 	".ts":  {},
 }
 
-// GatherQueuePaths expands a queue root into first-level upload candidates.
-// Files are included directly; subdirectories are included as single units when
-// they contain video files or disc folder markers.
+// GatherQueuePaths returns sorted absolute host paths for first-level upload
+// candidates. A file root is returned directly; directory children are kept
+// only when they are video files or directories containing video or disc data.
 func GatherQueuePaths(ctx context.Context, root string) ([]string, error) {
 	trimmed := strings.TrimSpace(root)
 	if trimmed == "" {
@@ -80,6 +80,8 @@ func GatherQueuePaths(ctx context.Context, root string) ([]string, error) {
 	return paths, nil
 }
 
+// LimitQueuePaths returns a defensive copy capped at limit. A non-positive
+// limit returns all paths.
 func LimitQueuePaths(paths []string, limit int) []string {
 	if limit <= 0 || len(paths) <= limit {
 		return append([]string{}, paths...)
diff --git a/internal/filesystem/size.go b/internal/filesystem/size.go
index 0ad1bad9..650d7249 100644
--- a/internal/filesystem/size.go
+++ b/internal/filesystem/size.go
@@ -15,8 +15,10 @@ import (
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 )
 
-// SourceSize returns the total size of the content in bytes.
-// For disc sources, it walks the entire tree; otherwise it sums the file list or video path.
+// SourceSize returns content size in bytes. Disc sources walk the full tree and
+// report traversal errors. Other sources prefer nonblank fileList entries,
+// fall back to videoPath when none remain, and silently skip missing,
+// inaccessible, or non-regular files.
 func SourceSize(ctx context.Context, sourcePath, discType string, fileList []string, videoPath string) (int64, error) {
 	trimmed := strings.TrimSpace(sourcePath)
 	if trimmed == "" {
diff --git a/internal/filesystem/validator.go b/internal/filesystem/validator.go
index b086afd8..4237fce0 100644
--- a/internal/filesystem/validator.go
+++ b/internal/filesystem/validator.go
@@ -29,6 +29,8 @@ func NewValidatorWithLogger(logger api.Logger) *Validator {
 	return &Validator{logger: logger}
 }
 
+// ValidatePaths validates paths in input order and returns their absolute host
+// forms without deduplication. It stops at the first invalid path or cancellation.
 func (v *Validator) ValidatePaths(ctx context.Context, paths []string) ([]string, error) {
 	if len(paths) == 0 {
 		return nil, internalerrors.ErrInvalidInput
diff --git a/internal/filesystem/video.go b/internal/filesystem/video.go
index 97169306..fb2349e6 100644
--- a/internal/filesystem/video.go
+++ b/internal/filesystem/video.go
@@ -20,6 +20,7 @@ var videoExts = map[string]struct{}{
 	".ts":  {},
 }
 
+// SupportedVideoExtensions returns a sorted copy of recognized lowercase extensions.
 func SupportedVideoExtensions() []string {
 	exts := make([]string, 0, len(videoExts))
 	for ext := range videoExts {
@@ -29,14 +30,18 @@ func SupportedVideoExtensions() []string {
 	return exts
 }
 
+// IsVideoFile reports whether name has a recognized extension, ignoring case.
 func IsVideoFile(name string) bool {
 	ext := strings.ToLower(filepath.Ext(strings.ToLower(name)))
 	_, ok := videoExts[ext]
 	return ok
 }
 
-// CollectVideoFiles returns the selected video path and file list for a non-disc source.
-// When preferLargest is true, the selected video is the largest file by size.
+// CollectVideoFiles returns a selected video and candidate list for a non-disc
+// source. A file source is returned regardless of extension. A directory scan
+// is non-recursive, includes recognized video extensions, excludes sample-like
+// names except !sample, and sorts candidates by path. Selection uses the first
+// candidate unless preferLargest is set.
 func CollectVideoFiles(ctx context.Context, source string, preferLargest bool) (string, []string, error) {
 	trimmed := strings.TrimSpace(source)
 	if trimmed == "" {
diff --git a/internal/guiapp/app.go b/internal/guiapp/app.go
deleted file mode 100644
index 596c1e59..00000000
--- a/internal/guiapp/app.go
+++ /dev/null
@@ -1,1934 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/url"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/config/importer"
-	"github.com/autobrr/upbrr/internal/configstore"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/core"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/bdinfo"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/trackericon"
-	"github.com/autobrr/upbrr/internal/trackerauth"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var openTrackerAuthCookieDialog = runtime.OpenFileDialog
-
-const previewTimeout = 30 * time.Minute
-const bdinfoProgressEvent = "bdinfo:progress"
-const metadataProgressEvent = "metadata:progress"
-
-// App owns the Wails-bound backend state for the desktop GUI.
-type App struct {
-	runtimeCtx  *appRuntimeContext
-	runtimeMu   sync.RWMutex
-	cfg         config.Config
-	core        api.Core
-	coreInitErr error
-	logger      *logging.Logger
-	repo        *db.SQLiteRepository
-	streamMu    sync.Mutex
-	streams     map[string]*logStreamSession
-	dupeMu      sync.Mutex
-	dupes       map[string]*dupeCheckJob
-	dupeWG      sync.WaitGroup
-	uploadMu    sync.Mutex
-	uploads     map[string]*trackerUploadJob
-	uploadWG    sync.WaitGroup
-	dvdMenuMu   sync.Mutex
-	dvdMenus    map[string]*dvdMenuCaptureJob
-	dvdMenuWG   sync.WaitGroup
-
-	sharedCookieMigrator func(context.Context, string, api.Logger) error
-}
-
-type blurayCandidateSelector interface {
-	SelectBlurayCandidate(ctx context.Context, sourcePath string, releaseID string) (api.MetadataPreview, error)
-}
-
-// NewApp creates a Wails backend using the default background context.
-func NewApp(configPath string, configProvided bool) (*App, error) {
-	return NewAppWithContext(context.Background(), configPath, configProvided)
-}
-
-// NewAppWithContext bootstraps config, logging, repository access, and the core
-// service used by Wails calls. Invalid runtime config leaves upload features
-// disabled until settings are saved, while config/settings calls remain usable.
-func NewAppWithContext(ctx context.Context, configPath string, configProvided bool) (*App, error) {
-	if ctx == nil {
-		return nil, errors.New("guiapp: context is required")
-	}
-	cfg, dbPath, err := configstore.Bootstrap(ctx, configPath, configProvided, true)
-	if err != nil {
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-
-	logger, err := logging.New(cfg.Logging, cfg.MainSettings.DBPath)
-	if err != nil {
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-
-	repo, err := db.OpenWithLoggerContext(ctx, dbPath, logger)
-	if err != nil {
-		_ = logger.Close()
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		_ = logger.Close()
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-
-	var coreSvc api.Core
-	var coreInitErr error
-	if err := cfg.Validate(); err != nil {
-		coreInitErr = err
-		logger.Warnf("gui: config invalid, core disabled until settings are fixed: %v", err)
-	} else {
-		coreSvc, err = core.NewWithContext(ctx, api.CoreDependencies{
-			Config: cfg,
-			Logger: logger,
-			Services: api.ServiceSet{
-				Filesystem: filesystem.NewValidator(),
-			},
-			Repository: repo,
-		})
-		if err != nil {
-			_ = repo.Close()
-			_ = logger.Close()
-			return nil, fmt.Errorf("gui: %w", err)
-		}
-	}
-
-	return &App{
-		runtimeCtx:  newAppRuntimeContext(ctx),
-		cfg:         cfg,
-		core:        coreSvc,
-		coreInitErr: coreInitErr,
-		logger:      logger,
-		repo:        repo,
-		streams:     make(map[string]*logStreamSession),
-		dupes:       make(map[string]*dupeCheckJob),
-		uploads:     make(map[string]*trackerUploadJob),
-		dvdMenus:    make(map[string]*dvdMenuCaptureJob),
-	}, nil
-}
-
-func (a *App) startup(ctx context.Context) {
-	a.runtimeCtx.Store(ctx)
-}
-
-func (a *App) shutdown(_ context.Context) {
-	a.stopAllLogStreams()
-	a.stopAllDupeJobs()
-	a.stopAllUploadJobs()
-	a.stopAllDVDMenuJobs()
-	rt := a.runtimeSnapshot()
-	if rt.core != nil {
-		_ = rt.core.Close()
-	}
-	if a.repo != nil {
-		_ = a.repo.Close()
-	}
-	if rt.logger != nil {
-		_ = rt.logger.Close()
-	}
-}
-
-func (a *App) BrowseFile() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return "", err
-	}
-
-	selection, err := runtime.OpenFileDialog(ctx, runtime.OpenDialogOptions{
-		Title:   "Select a file",
-		Filters: []runtime.FileFilter{videoFileDialogFilter()},
-	})
-	if err != nil {
-		return "", fmt.Errorf("gui: open file dialog: %w", err)
-	}
-	return selection, nil
-}
-
-func videoFileDialogFilter() runtime.FileFilter {
-	extensions := filesystem.SupportedVideoExtensions()
-	patterns := make([]string, 0, len(extensions))
-	for _, ext := range extensions {
-		patterns = append(patterns, "*"+ext)
-	}
-	pattern := strings.Join(patterns, ";")
-	return runtime.FileFilter{
-		DisplayName: "Video files (" + pattern + ")",
-		Pattern:     pattern,
-	}
-}
-
-func (a *App) BrowseFiles() ([]string, error) {
-	return a.BrowseImageFiles()
-}
-
-func (a *App) BrowseImageFiles() ([]string, error) {
-	if a == nil {
-		return nil, errors.New("app not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return nil, err
-	}
-
-	selection, err := runtime.OpenMultipleFilesDialog(ctx, runtime.OpenDialogOptions{
-		Title: "Select images",
-		Filters: []runtime.FileFilter{
-			{DisplayName: "Image files", Pattern: "*.png;*.jpg;*.jpeg;*.webp"},
-			{DisplayName: "All files", Pattern: "*.*"},
-		},
-	})
-	if err != nil {
-		return nil, fmt.Errorf("gui: open files dialog: %w", err)
-	}
-	return selection, nil
-}
-
-func (a *App) BrowseFolder() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return "", err
-	}
-
-	selection, err := runtime.OpenDirectoryDialog(ctx, runtime.OpenDialogOptions{
-		Title: "Select a folder",
-	})
-	if err != nil {
-		return "", fmt.Errorf("gui: open directory dialog: %w", err)
-	}
-	return selection, nil
-}
-
-func (a *App) BrowsePath() (string, error) {
-	selection, err := a.BrowseFile()
-	if err != nil {
-		return "", err
-	}
-	if selection != "" {
-		return selection, nil
-	}
-
-	return a.BrowseFolder()
-}
-
-func (a *App) BrowseDirectory(path string, mode string) (api.BrowseDirectoryResponse, error) {
-	if a == nil {
-		return api.BrowseDirectoryResponse{}, errors.New("app not initialized")
-	}
-	fallback := guishared.BrowseDirectoryFallback(a.currentConfig().MainSettings.DBPath)
-	return wrapGUIResult(guishared.BrowseDirectory(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback))
-}
-
-func validateExternalURL(raw string) (string, error) {
-	trimmed := strings.TrimSpace(raw)
-	if trimmed == "" {
-		return "", errors.New("url is required")
-	}
-
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("parse url: %w", err)
-	}
-	if parsed == nil || !parsed.IsAbs() {
-		return "", errors.New("url must be absolute")
-	}
-
-	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
-	if scheme != "http" && scheme != "https" {
-		return "", errors.New("unsupported url scheme")
-	}
-
-	if strings.TrimSpace(parsed.Host) == "" {
-		return "", errors.New("url host is required")
-	}
-
-	return parsed.String(), nil
-}
-
-func (a *App) OpenExternalURL(rawURL string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return err
-	}
-
-	validatedURL, err := validateExternalURL(rawURL)
-	if err != nil {
-		return fmt.Errorf("open external url: %w", err)
-	}
-
-	runtime.BrowserOpenURL(ctx, validatedURL)
-	return nil
-}
-
-func (a *App) DetectDiscType(path string) (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return "", errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return wrapGUIResult(filesystem.DetectDiscType(ctx, path))
-}
-
-func (a *App) FetchMetadata(path string, sourceLookupURL string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string) (api.MetadataPreview, error) {
-	if err := a.requireCore(); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.MetadataPreview{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	trimmedPath := strings.TrimSpace(path)
-	progressCtx := api.WithMetadataProgressReporter(ctx, func(update api.MetadataProgressUpdate) {
-		if strings.TrimSpace(update.Path) == "" {
-			update.Path = trimmedPath
-		}
-		if strings.TrimSpace(update.Timestamp) == "" {
-			update.Timestamp = time.Now().UTC().Format(time.RFC3339)
-		}
-		runtime.EventsEmit(ctx, metadataProgressEvent, update)
-	})
-
-	req := api.Request{
-		Paths:           []string{trimmedPath},
-		Mode:            api.ModeGUI,
-		Trackers:        slices.Clone(trackers),
-		SourceLookupURL: strings.TrimSpace(sourceLookupURL),
-		Options:         a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(a.currentCore().FetchMetadataPreview(progressCtx, req))
-}
-
-func (a *App) SelectBlurayCandidate(path string, releaseID string) (api.MetadataPreview, error) {
-	if err := a.requireCore(); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.MetadataPreview{}, errors.New("path is required")
-	}
-	if strings.TrimSpace(releaseID) == "" {
-		return api.MetadataPreview{}, errors.New("release ID is required")
-	}
-	selector, ok := a.currentCore().(blurayCandidateSelector)
-	if !ok {
-		return api.MetadataPreview{}, errors.New("blu-ray candidate selection is unavailable in this build")
-	}
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	return wrapGUIResult(selector.SelectBlurayCandidate(ctx, path, releaseID))
-}
-
-func (a *App) ResetMetadata(path string, sourceLookupURL string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string) (api.MetadataPreview, error) {
-	if err := a.requireCore(); err != nil {
-		return api.MetadataPreview{}, err
-	}
-	if a.repo == nil {
-		return api.MetadataPreview{}, errors.New("config repository not initialized")
-	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return api.MetadataPreview{}, errors.New("path is required")
-	}
-	logger := a.currentLogger()
-	if logger != nil {
-		logger.Infof("gui: reset metadata started path=%s", trimmedPath)
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	progressCtx := api.WithMetadataProgressReporter(ctx, func(update api.MetadataProgressUpdate) {
-		if strings.TrimSpace(update.Path) == "" {
-			update.Path = trimmedPath
-		}
-		if strings.TrimSpace(update.Timestamp) == "" {
-			update.Timestamp = time.Now().UTC().Format(time.RFC3339)
-		}
-		runtime.EventsEmit(ctx, metadataProgressEvent, update)
-	})
-
-	tmpRoot, err := db.Subdir(a.currentConfig().MainSettings.DBPath, "tmp")
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("reset metadata: resolve tmp dir: %w", err)
-	}
-
-	artifactPaths := make([]string, 0)
-	shots, err := a.repo.ListScreenshotsByPath(ctx, trimmedPath)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list screenshots: %w", err)
-	}
-	for _, shot := range shots {
-		artifactPaths = append(artifactPaths, shot.ImagePath)
-	}
-
-	uploaded, err := a.repo.ListUploadedImagesByPath(ctx, trimmedPath)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list uploaded images: %w", err)
-	}
-	for _, image := range uploaded {
-		artifactPaths = append(artifactPaths, image.ImagePath)
-	}
-
-	finals, err := a.repo.ListFinalSelections(ctx, trimmedPath)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list final selections: %w", err)
-	}
-	for _, image := range finals {
-		artifactPaths = append(artifactPaths, image.ImagePath)
-	}
-	artifactPaths = slices.Compact(artifactPaths)
-	if logger != nil {
-		logger.Debugf("gui: reset metadata decision=collect_artifacts path=%s files=%d", trimmedPath, len(artifactPaths))
-	}
-
-	tmpDirs := make(map[string]struct{})
-	fallbackBase := paths.ReleaseTempBase(api.PreparedMetadata{}, trimmedPath)
-	tmpDirs[filepath.Join(tmpRoot, fallbackBase)] = struct{}{}
-
-	stored, err := a.repo.GetByPath(ctx, trimmedPath)
-	if err == nil {
-		releaseBase := paths.ReleaseTempBase(api.PreparedMetadata{
-			Release: api.ReleaseInfo{
-				Title:    stored.Title,
-				Alt:      stored.Alt,
-				Year:     stored.Year,
-				Category: string(stored.Category),
-				Source:   stored.Source,
-				Type:     stored.Type,
-				Group:    stored.Group,
-			},
-		}, trimmedPath)
-		tmpDirs[filepath.Join(tmpRoot, releaseBase)] = struct{}{}
-	}
-	for _, filePath := range artifactPaths {
-		contentRoot, ok := resolveContentTmpRoot(tmpRoot, filePath)
-		if !ok {
-			continue
-		}
-		tmpDirs[contentRoot] = struct{}{}
-	}
-
-	if err := a.repo.PurgeContentData(ctx, trimmedPath); err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("reset metadata: purge sqlite: %w", err)
-	}
-	if logger != nil {
-		logger.Infof("gui: reset metadata sqlite purge completed path=%s", trimmedPath)
-	}
-
-	removedFiles := 0
-	for _, filePath := range artifactPaths {
-		removed, err := removeIfWithinRoot(tmpRoot, filePath, false)
-		if err != nil {
-			if logger != nil {
-				logger.Warnf("gui: reset metadata remove file failed path=%q err=%s", filePath, redaction.RedactValue(err.Error(), nil))
-			}
-			continue
-		}
-		if removed {
-			removedFiles++
-		}
-	}
-	removedDirs := 0
-	for dir := range tmpDirs {
-		removed, err := removeIfWithinRoot(tmpRoot, dir, true)
-		if err != nil {
-			if logger != nil {
-				logger.Warnf("gui: reset metadata remove tmp dir failed path=%q err=%s", dir, redaction.RedactValue(err.Error(), nil))
-			}
-			continue
-		}
-		if removed {
-			removedDirs++
-		}
-	}
-	if logger != nil {
-		logger.Infof("gui: reset metadata artifacts cleaned path=%s files_removed=%d dirs_removed=%d", trimmedPath, removedFiles, removedDirs)
-	}
-
-	req := api.Request{
-		Paths:           []string{trimmedPath},
-		Mode:            api.ModeGUI,
-		Trackers:        slices.Clone(trackers),
-		SourceLookupURL: strings.TrimSpace(sourceLookupURL),
-		Options:         a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-	preview, err := a.currentCore().FetchMetadataPreview(progressCtx, req)
-	if err != nil {
-		return api.MetadataPreview{}, fmt.Errorf("gui: %w", err)
-	}
-	if logger != nil {
-		logger.Infof("gui: reset metadata completed path=%s release=%s", trimmedPath, strings.TrimSpace(preview.ReleaseName))
-	}
-	return preview, nil
-}
-
-func resolveContentTmpRoot(tmpRoot string, candidate string) (string, bool) {
-	trimmed := strings.TrimSpace(candidate)
-	if trimmed == "" {
-		return "", false
-	}
-	absCandidate, err := filepath.Abs(trimmed)
-	if err != nil {
-		return "", false
-	}
-	absTmpRoot, err := filepath.Abs(strings.TrimSpace(tmpRoot))
-	if err != nil {
-		return "", false
-	}
-	if !pathutil.IsWithinRoot(absTmpRoot, absCandidate) {
-		return "", false
-	}
-	rel, err := filepath.Rel(absTmpRoot, absCandidate)
-	if err != nil {
-		return "", false
-	}
-	parts := strings.Split(rel, string(filepath.Separator))
-	if len(parts) < 1 || strings.TrimSpace(parts[0]) == "" || parts[0] == "." {
-		return "", false
-	}
-	return filepath.Join(absTmpRoot, parts[0]), true
-}
-
-func removeIfWithinRoot(root string, target string, recursive bool) (bool, error) {
-	trimmed := strings.TrimSpace(target)
-	if trimmed == "" {
-		return false, nil
-	}
-	absRoot, err := filepath.Abs(strings.TrimSpace(root))
-	if err != nil {
-		return false, fmt.Errorf("cleanup path: resolve root path: %w", err)
-	}
-	absTarget, err := filepath.Abs(trimmed)
-	if err != nil {
-		return false, fmt.Errorf("cleanup path: resolve target path: %w", err)
-	}
-	if pathutil.SamePath(absRoot, absTarget) {
-		return false, nil
-	}
-	if !pathutil.IsWithinRoot(absRoot, absTarget) {
-		return false, nil
-	}
-	if recursive {
-		if _, err := os.Stat(absTarget); err != nil {
-			if os.IsNotExist(err) {
-				return false, nil
-			}
-			return false, fmt.Errorf("cleanup path: stat target: %w", err)
-		}
-		if err := os.RemoveAll(absTarget); err != nil {
-			return false, fmt.Errorf("cleanup path: remove target tree: %w", err)
-		}
-		return true, nil
-	}
-	if err := os.Remove(absTarget); err != nil && !os.IsNotExist(err) {
-		return false, fmt.Errorf("cleanup path: remove target: %w", err)
-	}
-	if _, err := os.Stat(absTarget); err == nil {
-		return false, nil
-	}
-	return true, nil
-}
-
-func (a *App) CheckDupes(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string) (api.DupeCheckSummary, error) {
-	if a == nil || a.currentCore() == nil {
-		return api.DupeCheckSummary{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.DupeCheckSummary{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	trimmedPath := strings.TrimSpace(path)
-
-	req := api.Request{
-		Paths:    []string{trimmedPath},
-		Mode:     api.ModeGUI,
-		Trackers: slices.Clone(trackers),
-		Options:  a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(a.currentCore().CheckDupes(ctx, req))
-}
-
-func (a *App) FetchPreparation(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string) (api.PreparationPreview, error) {
-	if a == nil || a.currentCore() == nil {
-		return api.PreparationPreview{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.PreparationPreview{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	trimmedPath := strings.TrimSpace(path)
-
-	req := api.Request{
-		Paths:          []string{trimmedPath},
-		Mode:           api.ModeGUI,
-		Trackers:       slices.Clone(trackers),
-		IgnoreDupesFor: normalizeTrackerList(ignoreDupesFor),
-		Options:        a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	progressCtx := bdinfo.WithProgressReporter(ctx, func(line string) {
-		if strings.TrimSpace(line) == "" {
-			return
-		}
-		runtime.EventsEmit(ctx, bdinfoProgressEvent, map[string]string{
-			"path": trimmedPath,
-			"line": line,
-		})
-	})
-
-	return wrapGUIResult(a.currentCore().FetchPreparationPreview(progressCtx, req))
-}
-
-// FetchTrackerDryRun builds tracker upload payload previews for a GUI-selected
-// path. It seeds a run-scoped core snapshot, emits upload/BDInfo progress
-// events, and rejects on missing paths, run-option errors, preparation errors,
-// or dry-run build failures.
-func (a *App) FetchTrackerDryRun(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string) (preview api.TrackerDryRunPreview, err error) {
-	defer func() {
-		if err != nil {
-			if logger := a.currentLogger(); logger != nil {
-				logger.Warnf("gui: tracker dry-run blocked err=%s", redaction.RedactValue(err.Error(), nil))
-			}
-		}
-	}()
-
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.TrackerDryRunPreview{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	if err := ctx.Err(); err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("gui: tracker dry-run preview canceled: %w", err)
-	}
-	trimmedPath := strings.TrimSpace(path)
-	runOpts, err := a.buildRunOptions(debug, noSeed, runLogLevel)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	if logger := a.currentLogger(); logger != nil {
-		logger.Debugf("gui: tracker dry-run request path=%s debug=%t no_seed=%t run_log_level=%s", trimmedPath, debug, noSeed, runOpts.RunLogLevel)
-	}
-	runCore, runLogger, err := a.buildRunCoreFromSnapshot(rt, runOpts)
-	if err != nil {
-		return api.TrackerDryRunPreview{}, err
-	}
-	defer func() {
-		_ = runCore.Close()
-		_ = runLogger.Close()
-	}()
-
-	req := api.Request{
-		Paths:                       []string{trimmedPath},
-		Mode:                        api.ModeGUI,
-		DescriptionGroups:           api.CloneDescriptionBuilderGroups(descriptionGroups),
-		Trackers:                    slices.Clone(trackers),
-		IgnoreDupesFor:              normalizeTrackerList(ignoreDupesFor),
-		IgnoreTrackerRuleFailures:   false,
-		Options:                     buildRunUploadOptions(rt.cfg, runOpts),
-		ExternalIDOverrides:         overrides,
-		ReleaseNameOverrides:        nameOverrides,
-		TrackerQuestionnaireAnswers: cloneQuestionnaireAnswers(questionnaireAnswers),
-	}
-	req.Options.DryRun = true
-	if err := guishared.SeedRunCorePreparedMeta(ctx, rt.core, runCore, req); err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	progressCtx := api.WithUploadProgressReporter(ctx, func(update api.UploadProgressUpdate) {
-		runtime.EventsEmit(ctx, trackerUploadProgressEvent, update)
-	})
-	progressCtx = bdinfo.WithProgressReporter(progressCtx, func(line string) {
-		if strings.TrimSpace(line) == "" {
-			return
-		}
-		runtime.EventsEmit(ctx, bdinfoProgressEvent, map[string]string{
-			"path": trimmedPath,
-			"line": line,
-		})
-	})
-
-	return wrapGUIResult(runCore.FetchTrackerDryRunPreview(progressCtx, req))
-}
-
-func (a *App) FetchDescriptionBuilder(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string) (api.DescriptionBuilderPreview, error) {
-	if a == nil || a.currentCore() == nil {
-		return api.DescriptionBuilderPreview{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.DescriptionBuilderPreview{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:          []string{path},
-		Mode:           api.ModeGUI,
-		Trackers:       slices.Clone(trackers),
-		IgnoreDupesFor: normalizeTrackerList(ignoreDupesFor),
-		Options:        a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(a.currentCore().FetchDescriptionBuilderPreview(ctx, req))
-}
-
-func (a *App) RenderDescription(raw string) (string, error) {
-	if a == nil || a.currentCore() == nil {
-		return "", errors.New("app not initialized")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return wrapGUIResult(a.currentCore().RenderDescription(ctx, raw))
-}
-
-func (a *App) SaveDescriptionOverride(path string, groupKey string, raw string, trackers []string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (api.DescriptionBuilderGroup, error) {
-	if a == nil || a.currentCore() == nil {
-		return api.DescriptionBuilderGroup{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.DescriptionBuilderGroup{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:                    []string{path},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: strings.TrimSpace(groupKey),
-	}
-
-	req.Trackers = slices.Clone(trackers)
-	req.ExternalIDOverrides = overrides
-	req.ReleaseNameOverrides = nameOverrides
-
-	return wrapGUIResult(a.currentCore().SaveDescriptionOverride(ctx, req, raw))
-}
-
-func (a *App) DiscoverPlaylists(path string) ([]api.PlaylistInfo, error) {
-	if a == nil || a.currentCore() == nil {
-		return nil, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return nil, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return wrapGUIResult(a.currentCore().DiscoverPlaylists(ctx, path))
-}
-
-func (a *App) SavePlaylistSelection(path string, playlists []string, useAll bool) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return wrapGUIError(a.currentCore().SavePlaylistSelection(ctx, path, playlists, useAll))
-}
-
-func (a *App) LoadPlaylistSelection(path string) (api.PlaylistSelection, error) {
-	if a == nil || a.currentCore() == nil {
-		return api.PlaylistSelection{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.PlaylistSelection{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return wrapGUIResult(a.currentCore().LoadPlaylistSelection(ctx, path))
-}
-
-func (a *App) ListHistory() ([]api.HistoryEntry, error) {
-	if err := a.requireHistoryRepo(); err != nil {
-		return nil, err
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return a.listHistoryFromRepo(ctx)
-}
-
-func (a *App) GetHistoryOverview(sourcePath string) (api.HistoryOverview, error) {
-	if err := a.requireHistoryRepo(); err != nil {
-		return api.HistoryOverview{}, err
-	}
-	if strings.TrimSpace(sourcePath) == "" {
-		return api.HistoryOverview{}, errors.New("source path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	return a.getHistoryOverviewFromRepo(ctx, sourcePath)
-}
-
-func (a *App) DeleteHistoryRelease(sourcePath string) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	trimmedPath := strings.TrimSpace(sourcePath)
-	if trimmedPath == "" {
-		return errors.New("source path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-	if err := a.currentCore().DeleteHistoryRelease(ctx, trimmedPath); err != nil {
-		return fmt.Errorf("delete history release: %w", err)
-	}
-	return nil
-}
-
-func (a *App) FetchScreenshotPlan(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (api.ScreenshotPlan, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return api.ScreenshotPlan{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.ScreenshotPlan{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(rt.core.FetchScreenshotPlan(ctx, req))
-}
-
-func (a *App) GenerateScreenshots(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, selections []api.ScreenshotSelection, purpose api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return api.ScreenshotResult{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.ScreenshotResult{}, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(rt.core.GenerateScreenshots(ctx, req, selections, purpose))
-}
-
-func (a *App) ListUploadCandidates(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.ScreenshotImage, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return nil, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(rt.core.ListUploadCandidates(ctx, req))
-}
-
-func (a *App) ListUploadedImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.UploadedImageLink, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return nil, errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIResult(rt.core.ListUploadedImages(ctx, req))
-}
-
-func (a *App) UploadImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, host string, images []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return api.UploadImagesResult{}, err
-	}
-	if strings.TrimSpace(path) == "" {
-		return api.UploadImagesResult{}, errors.New("path is required")
-	}
-	if strings.TrimSpace(host) == "" {
-		return api.UploadImagesResult{}, errors.New("host is required")
-	}
-	if len(images) == 0 {
-		return api.UploadImagesResult{}, errors.New("no images selected")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-		Trackers:             slices.Clone(trackers),
-	}
-
-	return wrapGUIResult(rt.core.UploadImages(ctx, req, host, images))
-}
-
-func (a *App) DeleteUploadedImage(path string, imagePath string, host string) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-	if strings.TrimSpace(imagePath) == "" {
-		return errors.New("image path is required")
-	}
-	if strings.TrimSpace(host) == "" {
-		return errors.New("host is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeGUI,
-	}
-
-	return wrapGUIError(a.currentCore().DeleteUploadedImage(ctx, req, imagePath, host))
-}
-
-func (a *App) PreviewScreenshotFrame(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, timestampSeconds float64) (string, error) {
-	if a == nil || a.currentCore() == nil {
-		return "", errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return "", errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	preview, err := a.currentCore().PreviewScreenshotFrame(ctx, req, timestampSeconds)
-	if err != nil {
-		return "", fmt.Errorf("gui: %w", err)
-	}
-	if len(preview.ImageBytes) == 0 {
-		return "", errors.New("preview image is empty")
-	}
-	encoded := base64.StdEncoding.EncodeToString(preview.ImageBytes)
-	return "data:image/png;base64," + encoded, nil
-}
-
-func (a *App) DeleteScreenshot(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, imagePath string) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-	if strings.TrimSpace(imagePath) == "" {
-		return errors.New("image path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIError(a.currentCore().DeleteScreenshot(ctx, req, imagePath))
-}
-
-func (a *App) DeleteTrackerImageURL(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, url string) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-	if strings.TrimSpace(url) == "" {
-		return errors.New("tracker image URL is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIError(a.currentCore().DeleteTrackerImageURL(ctx, req, url))
-}
-
-func (a *App) SaveFinalScreenshotSelections(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, images []api.ScreenshotImage) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIError(a.currentCore().SaveFinalScreenshotSelections(ctx, req, images))
-}
-
-func (a *App) ImportMenuImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, paths []string) error {
-	if a == nil || a.currentCore() == nil {
-		return errors.New("app not initialized")
-	}
-	if strings.TrimSpace(path) == "" {
-		return errors.New("path is required")
-	}
-
-	ctx := a.runtimeContext()
-	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
-	defer cancel()
-
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: a.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-
-	return wrapGUIError(a.currentCore().ImportMenuImages(ctx, req, paths))
-}
-
-func (a *App) ReadScreenshotImage(path string) (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	trimmed := strings.TrimSpace(path)
-	if trimmed == "" {
-		return "", errors.New("path is required")
-	}
-	payload, err := os.ReadFile(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("read preview image: %w", err)
-	}
-	encoded := base64.StdEncoding.EncodeToString(payload)
-	return "data:image/png;base64," + encoded, nil
-}
-
-// GetConfig returns the GUI settings payload as encrypted JSON. If no config
-// rows exist yet, it exports the current runtime config without persisting it.
-func (a *App) GetConfig() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return "", errors.New("config repository not initialized")
-	}
-
-	ctx := a.runtimeContext()
-	rt := a.runtimeSnapshot()
-
-	cfg, err := config.LoadFromDatabase(ctx, a.repo)
-	if err != nil {
-		if errors.Is(err, internalerrors.ErrNotFound) {
-			cfg = &rt.cfg
-		} else {
-			return "", fmt.Errorf("gui: %w", err)
-		}
-	}
-	normalized, err := normalizeGUIConfigForExport(cfg, rt.cfg.MainSettings.DBPath)
-	if err != nil {
-		return "", err
-	}
-
-	return wrapGUIResult(config.ExportToJSON(normalized))
-}
-
-// GetApplicationInfo returns build/runtime metadata plus a bounded, path-free
-// DVD menu capability probe for frontend diagnostics.
-func (a *App) GetApplicationInfo() (api.ApplicationInfo, error) {
-	if a == nil {
-		return api.ApplicationInfo{}, errors.New("app not initialized")
-	}
-	rt := a.runtimeSnapshot()
-	provider, _ := rt.core.(api.DVDMenuCapabilityProvider)
-	return guishared.CurrentApplicationInfo(a.runtimeContext(), provider), nil
-}
-
-func (a *App) GetDefaultConfig() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-
-	cfg, err := config.LoadEmbeddedDefaultConfig()
-	if err != nil {
-		return "", fmt.Errorf("gui: %w", err)
-	}
-
-	return wrapGUIResult(config.ExportToJSON(cfg))
-}
-
-func (a *App) ListKnownTrackers() ([]string, error) {
-	if a == nil {
-		return nil, errors.New("app not initialized")
-	}
-
-	return trackers.KnownTrackers(), nil
-}
-
-// ListTrackerAuthCapabilities returns tracker auth support metadata through the Wails bridge.
-func (a *App) ListTrackerAuthCapabilities() ([]api.TrackerAuthCapability, error) {
-	if a == nil {
-		return nil, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Capabilities(context.Background()))
-}
-
-// GetTrackerAuthStatus returns the current local auth status for one tracker.
-func (a *App) GetTrackerAuthStatus(tracker string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Status(context.Background(), tracker))
-}
-
-// ImportTrackerAuthCookies opens a native file picker, reads the selected file
-// with the shared bounded reader, and returns updated tracker auth status. A
-// cancelled picker or empty selection returns the current status without error.
-func (a *App) ImportTrackerAuthCookies(tracker string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	selection, err := openTrackerAuthCookieDialog(ctx, runtime.OpenDialogOptions{
-		Title: "Import tracker cookies",
-		Filters: []runtime.FileFilter{
-			{DisplayName: "Cookie files (*.txt;*.json)", Pattern: "*.txt;*.json"},
-			{DisplayName: "All files", Pattern: "*.*"},
-		},
-	})
-	if err != nil {
-		if isDialogCancelledErr(err) {
-			return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Status(context.Background(), tracker))
-		}
-		return api.TrackerAuthStatus{}, fmt.Errorf("gui: open tracker cookie dialog: %w", err)
-	}
-	if strings.TrimSpace(selection) == "" {
-		return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Status(context.Background(), tracker))
-	}
-	return importTrackerAuthCookieFile(ctx, trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()), tracker, selection)
-}
-
-// ImportTrackerAuthCookieContent imports caller-supplied cookie content for one
-// tracker using the current Wails runtime context and returns updated auth
-// status.
-func (a *App) ImportTrackerAuthCookieContent(tracker string, fileName string, content string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).ImportCookies(a.runtimeContext(), tracker, fileName, content))
-}
-
-// importTrackerAuthCookieFile imports one host cookie file without reading past
-// the shared raw content limit before rejection.
-func importTrackerAuthCookieFile(ctx context.Context, service *trackerauth.Service, tracker string, path string) (api.TrackerAuthStatus, error) {
-	file, err := os.Open(path)
-	if err != nil {
-		return api.TrackerAuthStatus{}, fmt.Errorf("gui: read tracker cookie file: %w", err)
-	}
-	defer func() {
-		_ = file.Close()
-	}()
-	content, err := trackerauth.ReadCookieImportContent(file)
-	if err != nil {
-		return api.TrackerAuthStatus{}, fmt.Errorf("gui: read tracker cookie file: %w", err)
-	}
-	return wrapGUIResult(service.ImportCookies(ctx, tracker, filepath.Base(path), content))
-}
-
-// TestTrackerAuth validates tracker auth remotely when supported, using the
-// current Wails runtime context so cancellation can stop remote validation.
-// Unsupported trackers return local status with an unsupported message.
-func (a *App) TestTrackerAuth(tracker string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Validate(a.runtimeContext(), tracker))
-}
-
-// LoginTrackerAuth attempts credential-based tracker auth with the current
-// Wails runtime context and returns status for missing credentials, unsupported
-// login, or 2FA.
-func (a *App) LoginTrackerAuth(tracker string, req api.TrackerAuthLoginRequest) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Login(a.runtimeContext(), tracker, req))
-}
-
-// SubmitTrackerAuth2FA submits a manual 2FA code for an active tracker auth
-// challenge using the current Wails runtime context.
-func (a *App) SubmitTrackerAuth2FA(challengeID string, code string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Submit2FA(a.runtimeContext(), challengeID, code))
-}
-
-// DeleteTrackerAuth removes stored auth material for one tracker and returns
-// refreshed local status using the current Wails runtime context.
-func (a *App) DeleteTrackerAuth(tracker string) (api.TrackerAuthStatus, error) {
-	if a == nil {
-		return api.TrackerAuthStatus{}, errors.New("app not initialized")
-	}
-	return wrapGUIResult(trackerauth.NewServiceWithLogger(a.currentConfig(), a.currentLogger()).Delete(a.runtimeContext(), tracker))
-}
-
-func (a *App) GetImageHostPolicyMetadata() (imagehostpolicy.Metadata, error) {
-	if a == nil {
-		return imagehostpolicy.Metadata{}, errors.New("app not initialized")
-	}
-
-	return imagehostpolicy.PolicyMetadata(), nil
-}
-
-// SaveConfig validates encrypted GUI settings, builds the replacement runtime,
-// migrates shared cookies, then saves the non-env config. Runtime build,
-// migration, or save failures leave the persisted config and active runtime
-// unchanged; env overrides apply only to the installed runtime config.
-func (a *App) SaveConfig(payload string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return errors.New("config repository not initialized")
-	}
-	if strings.TrimSpace(payload) == "" {
-		return errors.New("config payload is required")
-	}
-
-	cfg, err := config.ImportFromJSONEncrypted(payload)
-	if err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-	if _, err := config.MergeMissingTrackerDefaults(cfg); err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-	currentCfg := a.currentConfig()
-	if strings.TrimSpace(cfg.MainSettings.DBPath) == "" {
-		cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	}
-	if !pathutil.SamePath(cfg.MainSettings.DBPath, currentCfg.MainSettings.DBPath) {
-		return errors.New("changing main_settings.db_path requires restart and is not supported in the GUI")
-	}
-	cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := cfg.Validate(); err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-	runtimeCfg := *cfg
-	config.ApplyEnvOverrides(&runtimeCfg)
-	runtimeCfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := runtimeCfg.Validate(); err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-
-	ctx := a.runtimeContext()
-	return a.saveAndApplyConfig(ctx, cfg, runtimeCfg, cfg.MainSettings.DBPath)
-}
-
-// normalizeGUIConfigForExport clones cfg and fills tracker defaults, legacy
-// nils, and a missing DB path without mutating runtime or persisted config.
-func normalizeGUIConfigForExport(cfg *config.Config, dbPath string) (*config.Config, error) {
-	normalized, err := cloneGUIConfigForExport(cfg)
-	if err != nil {
-		return nil, err
-	}
-	if _, err := config.MergeMissingTrackerDefaults(normalized); err != nil {
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-	if strings.TrimSpace(normalized.MainSettings.DBPath) == "" {
-		normalized.MainSettings.DBPath = dbPath
-	}
-	if normalized.Trackers.Trackers == nil {
-		normalized.Trackers.Trackers = map[string]config.TrackerConfig{}
-	}
-	if normalized.Trackers.DefaultTrackers == nil {
-		normalized.Trackers.DefaultTrackers = config.CSVList{}
-	}
-	return normalized, nil
-}
-
-// cloneGUIConfigForExport deep-copies config through JSON so export
-// normalization cannot mutate the source snapshot.
-func cloneGUIConfigForExport(cfg *config.Config) (*config.Config, error) {
-	payload, err := json.Marshal(cfg)
-	if err != nil {
-		return nil, fmt.Errorf("gui: clone config for export: marshal: %w", err)
-	}
-	var cloned config.Config
-	if err := json.Unmarshal(payload, &cloned); err != nil {
-		return nil, fmt.Errorf("gui: clone config for export: unmarshal: %w", err)
-	}
-	return &cloned, nil
-}
-
-// isDialogCancelledErr reports whether err is the result of the user closing a
-// native Wails file dialog. On Windows, cancelling SaveFileDialog/OpenFileDialog
-// surfaces as a non-nil error containing "shellItem is nil" rather than an
-// empty path; treat that case the same as a normal cancel.
-func isDialogCancelledErr(err error) bool {
-	if err == nil {
-		return false
-	}
-	return strings.Contains(err.Error(), "shellItem is nil")
-}
-
-// ExportConfig opens a native save dialog and writes the GUI config as YAML.
-// It returns the written host path, or an empty string when the dialog is
-// canceled or yields a blank path.
-func (a *App) ExportConfig() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return "", errors.New("config repository not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return "", err
-	}
-
-	path, err := runtime.SaveFileDialog(ctx, runtime.SaveDialogOptions{
-		Title:           "Export configuration",
-		DefaultFilename: "config-export.yaml",
-		Filters: []runtime.FileFilter{
-			{DisplayName: "YAML files", Pattern: "*.yaml;*.yml"},
-		},
-	})
-	if isDialogCancelledErr(err) {
-		return "", nil
-	}
-	if err != nil {
-		return "", fmt.Errorf("gui: save config dialog: %w", err)
-	}
-
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", nil
-	}
-	if ext := strings.ToLower(filepath.Ext(trimmedPath)); ext == "" {
-		trimmedPath += ".yaml"
-	}
-
-	return a.exportConfigToPath(ctx, trimmedPath)
-}
-
-// exportConfigToPath writes the persisted config to trimmedPath, adding a YAML
-// extension when needed. Fresh installs with no config rows export the current
-// runtime config without persisting it.
-func (a *App) exportConfigToPath(ctx context.Context, trimmedPath string) (string, error) {
-	trimmedPath = strings.TrimSpace(trimmedPath)
-	if trimmedPath == "" {
-		return "", nil
-	}
-	if ext := strings.ToLower(filepath.Ext(trimmedPath)); ext == "" {
-		trimmedPath += ".yaml"
-	}
-
-	cfg, authDBPath, err := a.exportableConfig(ctx)
-	if err != nil {
-		return "", err
-	}
-	allowPlaintext, err := a.allowUnencryptedExport(authDBPath)
-	if err != nil {
-		return "", err
-	}
-
-	if allowPlaintext {
-		if err := config.ExportToPlaintextYAML(cfg, trimmedPath); err != nil {
-			return "", fmt.Errorf("gui: %w", err)
-		}
-		return trimmedPath, nil
-	}
-
-	if err := config.ExportToYAML(cfg, trimmedPath); err != nil {
-		return "", fmt.Errorf("gui: %w", err)
-	}
-
-	return trimmedPath, nil
-}
-
-// exportableConfig returns the normalized GUI export snapshot and the DB path
-// embedded in that snapshot. Plaintext export authorization must use that same
-// DB path so runtime config changes cannot authorize a different persisted
-// config boundary.
-func (a *App) exportableConfig(ctx context.Context) (*config.Config, string, error) {
-	rt := a.runtimeSnapshot()
-	cfg, err := config.LoadFromDatabase(ctx, a.repo)
-	if err != nil {
-		if errors.Is(err, internalerrors.ErrNotFound) {
-			cfg = &rt.cfg
-		} else {
-			return nil, "", fmt.Errorf("gui: %w", err)
-		}
-	}
-	normalized, err := normalizeGUIConfigForExport(cfg, rt.cfg.MainSettings.DBPath)
-	if err != nil {
-		return nil, "", err
-	}
-	return normalized, normalized.MainSettings.DBPath, nil
-}
-
-// allowUnencryptedExport reports whether the supplied DB auth material
-// permits plaintext config export. Missing auth material denies plaintext
-// export; malformed material is returned as an error.
-func (a *App) allowUnencryptedExport(dbPath string) (bool, error) {
-	if a == nil {
-		return false, errors.New("app not initialized")
-	}
-
-	dbPath = strings.TrimSpace(dbPath)
-	if dbPath == "" {
-		return false, nil
-	}
-
-	material, err := authmaterial.LoadFromDBPath(dbPath)
-	if err == nil {
-		return material.AllowUnencryptedExport, nil
-	}
-	if errors.Is(err, authmaterial.ErrUnavailable) {
-		return false, nil
-	}
-	return false, fmt.Errorf("gui: %w", err)
-}
-
-// ImportResult is returned to the GUI after an interactive config import.
-type ImportResult struct {
-	// Message is a user-displayable import summary.
-	Message string `json:"message"`
-	// Warnings contains non-fatal parser/import warnings.
-	Warnings []string `json:"warnings"`
-}
-
-// WebAuthStatus reports whether the current database has usable web auth
-// material for config secret encryption.
-type WebAuthStatus struct {
-	// Path is the host filesystem path to the web auth material file.
-	Path string `json:"path"`
-	// Exists reports whether web auth material was found on disk.
-	Exists bool `json:"exists"`
-	// Usable reports whether the auth material can decrypt/encrypt config secrets.
-	Usable bool `json:"usable"`
-	// CanCreate reports whether the GUI may create new auth material at Path.
-	CanCreate bool `json:"canCreate"`
-	// Username is populated only when usable auth material is loaded.
-	Username string `json:"username"`
-	// AllowUnencryptedExport mirrors the loaded auth policy.
-	AllowUnencryptedExport bool `json:"allowUnencryptedExport"`
-	// BrowseRoot is the host filesystem root enforced for browser file browsing.
-	BrowseRoot string `json:"browseRoot"`
-	// AllowUnrestrictedBrowse reports whether browser file browsing may ignore BrowseRoot.
-	AllowUnrestrictedBrowse bool `json:"allowUnrestrictedBrowse"`
-	// EncryptionEnabled reports whether config secret encryption is active.
-	EncryptionEnabled bool `json:"encryptionEnabled"`
-	// Message is a user-displayable status summary.
-	Message string `json:"message"`
-}
-
-func (a *App) GetWebAuthStatus() (WebAuthStatus, error) {
-	if a == nil {
-		return WebAuthStatus{}, errors.New("app not initialized")
-	}
-
-	dbPath := strings.TrimSpace(a.currentConfig().MainSettings.DBPath)
-	if dbPath == "" {
-		return WebAuthStatus{
-			CanCreate: false,
-			Message:   "Database path is not configured.",
-		}, nil
-	}
-
-	authPath := authmaterial.AuthFilePath(dbPath)
-	status := WebAuthStatus{
-		Path:      authPath,
-		CanCreate: true,
-		Message:   "No web auth file found. Secrets will continue to be stored in plaintext until one is created.",
-	}
-
-	if _, err := os.Stat(authPath); err == nil {
-		status.Exists = true
-		status.CanCreate = false
-	} else if err != nil && !os.IsNotExist(err) {
-		return WebAuthStatus{}, fmt.Errorf("web auth status: stat auth file: %w", err)
-	}
-
-	material, err := authmaterial.LoadFromDBPath(dbPath)
-	if err == nil {
-		status.Exists = true
-		status.Usable = true
-		status.CanCreate = false
-		status.Username = material.Username
-		status.AllowUnencryptedExport = material.AllowUnencryptedExport
-		if record, loadErr := authmaterial.LoadRecordFromDBPath(dbPath); loadErr == nil {
-			status.BrowseRoot = record.BrowseRoot
-			status.AllowUnrestrictedBrowse = record.AllowUnrestrictedBrowse
-		} else if logger := a.currentLogger(); logger != nil {
-			logger.Debugf(
-				"gui: web auth browse policy record unavailable db_path=%s error=%s",
-				redaction.RedactValue(dbPath, nil),
-				redaction.RedactValue(loadErr.Error(), nil),
-			)
-		}
-		status.EncryptionEnabled = true
-		status.Message = "Secret encryption is enabled for this installation."
-		return status, nil
-	}
-	if errors.Is(err, authmaterial.ErrUnavailable) {
-		if status.Exists {
-			status.Message = "web-auth.json exists but is not usable for secret encryption."
-		}
-		return status, nil
-	}
-
-	return WebAuthStatus{}, fmt.Errorf("web auth status: %w", err)
-}
-
-func (a *App) CreateWebAuth(username string, password string) (WebAuthStatus, error) {
-	if a == nil {
-		return WebAuthStatus{}, errors.New("app not initialized")
-	}
-
-	dbPath := strings.TrimSpace(a.currentConfig().MainSettings.DBPath)
-	if dbPath == "" {
-		return WebAuthStatus{}, errors.New("database path is not configured")
-	}
-
-	if err := authmaterial.BootstrapAuthFile(dbPath, username, password); err != nil {
-		return WebAuthStatus{}, fmt.Errorf("gui: %w", err)
-	}
-
-	return a.GetWebAuthStatus()
-}
-
-// ImportConfig opens a native file picker, imports the selected config, builds
-// the replacement runtime, migrates shared cookies, then saves the non-env
-// config. Runtime build, migration, or save failures leave the persisted config
-// and active runtime unchanged; env overrides apply only to the installed
-// runtime config.
-func (a *App) ImportConfig() (ImportResult, error) {
-	if a == nil {
-		return ImportResult{}, errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return ImportResult{}, errors.New("config repository not initialized")
-	}
-	ctx, err := a.readyRuntimeContext()
-	if err != nil {
-		return ImportResult{}, err
-	}
-
-	path, err := runtime.OpenFileDialog(ctx, runtime.OpenDialogOptions{
-		Title: "Import configuration",
-		Filters: []runtime.FileFilter{
-			{DisplayName: "Config files", Pattern: "*.py;*.yaml;*.yml;*.json"},
-			{DisplayName: "All files", Pattern: "*.*"},
-		},
-	})
-	if isDialogCancelledErr(err) {
-		return ImportResult{}, nil
-	}
-	if err != nil {
-		return ImportResult{}, fmt.Errorf("gui: import config dialog: %w", err)
-	}
-	if strings.TrimSpace(path) == "" {
-		return ImportResult{}, nil
-	}
-
-	return a.importConfigFromPath(ctx, path)
-}
-
-// importConfigFromPath imports one selected config file, validates both
-// persisted and env-applied runtime forms, then atomically saves and applies it.
-func (a *App) importConfigFromPath(ctx context.Context, path string) (ImportResult, error) {
-	cfg, warnings, err := importer.ImportFromFile(path)
-	if err != nil {
-		return ImportResult{}, fmt.Errorf("gui: %w", err)
-	}
-
-	currentCfg := a.currentConfig()
-	cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-
-	if err := cfg.Validate(); err != nil {
-		return ImportResult{}, fmt.Errorf("validate imported config: %w", err)
-	}
-	runtimeCfg := *cfg
-	config.ApplyEnvOverrides(&runtimeCfg)
-	runtimeCfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := runtimeCfg.Validate(); err != nil {
-		return ImportResult{}, fmt.Errorf("validate imported config: %w", err)
-	}
-
-	if err := a.saveAndApplyConfig(ctx, cfg, runtimeCfg, cfg.MainSettings.DBPath); err != nil {
-		return ImportResult{}, err
-	}
-
-	message := "imported config from " + filepath.Base(path)
-	if len(warnings) > 0 {
-		message += fmt.Sprintf(" (%d warnings)", len(warnings))
-	}
-	return ImportResult{Message: message, Warnings: warnings}, nil
-}
-
-// saveConfigToRepository persists GUI config changes through the already-open
-// repository.
-func (a *App) saveConfigToRepository(ctx context.Context, cfg *config.Config, dbPath string) error {
-	if err := configstore.SaveToRepository(ctx, cfg, a.repo, dbPath); err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-	return nil
-}
-
-// validateCookieAuthMaterial returns ErrAuthHelperUnavailable only when auth
-// material is absent; malformed material remains an error so callers can abort
-// before cookie encryption metadata is initialized.
-func validateCookieAuthMaterial(dbPath string) error {
-	material, err := authmaterial.LoadFromDBPath(dbPath)
-	if err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return cookies.ErrAuthHelperUnavailable
-		}
-		return fmt.Errorf("load auth helper: %w", err)
-	}
-	if _, _, err := material.PrimaryHelper(); err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return cookies.ErrAuthHelperUnavailable
-		}
-		return fmt.Errorf("derive auth helper: %w", err)
-	}
-	return nil
-}
-
-// saveAndApplyConfig builds the replacement runtime before any repository
-// writes, then migrates shared cookies, persists cfg, and installs the runtime
-// as one ordered transition. If migration or persistence fails, the built
-// runtime is closed and the active runtime is left untouched.
-func (a *App) saveAndApplyConfig(ctx context.Context, storedCfg *config.Config, runtimeCfg config.Config, dbPath string) error {
-	if err := validateCookieAuthMaterial(dbPath); err != nil {
-		if !errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			return fmt.Errorf("gui: validate cookie auth before config save: %w", err)
-		}
-	}
-
-	rt, err := guishared.BuildRuntime(ctx, runtimeCfg, a.repo)
-	if err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-
-	applied := false
-	defer func() {
-		if applied {
-			return
-		}
-		if rt.Core != nil {
-			_ = rt.Core.Close()
-		}
-		if rt.Logger != nil {
-			_ = rt.Logger.Close()
-		}
-	}()
-
-	if err := a.ensureSharedCookieMigrationForRuntime(ctx, dbPath, rt.Logger); err != nil {
-		return fmt.Errorf("gui: cookie migration failed: %w", err)
-	}
-
-	if err := a.saveConfigToRepository(ctx, storedCfg, dbPath); err != nil {
-		return err
-	}
-
-	oldCore, oldLogger := a.replaceRuntime(runtimeCfg, rt.Core, rt.Logger)
-	applied = true
-	a.rebindLogStreams(ctx, oldLogger, rt.Logger)
-
-	if oldCore != nil {
-		_ = oldCore.Close()
-	}
-	if oldLogger != nil {
-		_ = oldLogger.Close()
-	}
-
-	return nil
-}
-
-// ensureSharedCookieMigration syncs cookie encryption metadata and migrates
-// legacy cookie files against the shared repository before SkipCookieMigration
-// runtimes serve uploads. Missing auth material is retryable on a later save.
-func (a *App) ensureSharedCookieMigration(ctx context.Context, dbPath string, logger api.Logger) error {
-	if a.repo == nil {
-		return errors.New("repository not initialized")
-	}
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	if err := cookies.SyncCookieEncryptionWithAuth(ctx, a.repo.RawDB(), dbPath); err != nil {
-		if errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			logger.Debugf("gui: cookie encryption sync skipped: web auth helper unavailable")
-		} else {
-			return fmt.Errorf("cookies encryption sync: %w", err)
-		}
-	}
-
-	cookiesDir, err := db.CookiePath(dbPath, "")
-	if err != nil {
-		logger.Debugf("gui: failed to resolve cookies directory: %v", err)
-		return nil
-	}
-	if err := cookies.EnsureCookieMigration(ctx, a.repo.RawDB(), dbPath, cookiesDir, logger); err != nil {
-		if errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			logger.Debugf("gui: cookie migration skipped: web auth helper unavailable")
-			return nil
-		}
-		return fmt.Errorf("cookies migration: %w", err)
-	}
-	return nil
-}
-
-func (a *App) ensureSharedCookieMigrationForRuntime(ctx context.Context, dbPath string, logger api.Logger) error {
-	if a.sharedCookieMigrator != nil {
-		return a.sharedCookieMigrator(ctx, dbPath, logger)
-	}
-	return a.ensureSharedCookieMigration(ctx, dbPath, logger)
-}
-
-// applyConfig builds and installs a runtime from cfg without writing cfg to the
-// repository; it is used for startup and explicit runtime refresh paths.
-func (a *App) applyConfig(ctx context.Context, cfg config.Config) error {
-	rt, err := guishared.BuildRuntime(ctx, cfg, a.repo)
-	if err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-
-	oldCore, oldLogger := a.replaceRuntime(cfg, rt.Core, rt.Logger)
-	a.rebindLogStreams(ctx, oldLogger, rt.Logger)
-
-	if oldCore != nil {
-		_ = oldCore.Close()
-	}
-	if oldLogger != nil {
-		_ = oldLogger.Close()
-	}
-
-	return nil
-}
-
-func (a *App) requireCore() error {
-	_, err := a.requireRuntime()
-	return err
-}
-
-func (a *App) requireHistoryRepo() error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return errors.New("history repository not initialized")
-	}
-	return nil
-}
-
-func (a *App) GetTrackerIcon(trackerNameOrDomain string, customURL string) (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	ctx := a.runtimeContext()
-	cfg := a.currentConfig()
-
-	domain, resolvedURL := config.ResolveTrackerDomain(&cfg, trackerNameOrDomain)
-	urlToUse := customURL
-	if urlToUse == "" {
-		urlToUse = resolvedURL
-	}
-
-	res, err := trackericon.GetTrackerIcon(ctx, cfg.MainSettings.DBPath, domain, urlToUse)
-	if err != nil {
-		return "", fmt.Errorf("gui: %w", err)
-	}
-	return res, nil
-}
diff --git a/internal/guiapp/app_core_test.go b/internal/guiapp/app_core_test.go
deleted file mode 100644
index edbd4443..00000000
--- a/internal/guiapp/app_core_test.go
+++ /dev/null
@@ -1,1454 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestFetchMetadataReportsCoreValidationFailure(t *testing.T) {
-	t.Parallel()
-
-	app := &App{coreInitErr: errors.New("invalid config")}
-
-	_, err := app.FetchMetadata("/tmp/example.mkv", "", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "core unavailable") {
-		t.Fatalf("expected core unavailable error, got %v", err)
-	}
-	if !strings.Contains(err.Error(), "invalid config") {
-		t.Fatalf("expected wrapped validation error, got %v", err)
-	}
-}
-
-func TestFetchMetadataPropagatesSkipAutoTorrentSetting(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{}
-	app := &App{
-		cfg: config.Config{
-			Metadata:           config.MetadataConfig{SkipAutoTorrent: true},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 3},
-		},
-		core: coreSvc,
-	}
-
-	_, err := app.FetchMetadata("C:\\releases\\Example.mkv", "", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil)
-	if err != nil {
-		t.Fatalf("fetch metadata: %v", err)
-	}
-	if !coreSvc.fetchReq.Options.SkipAutoTorrent {
-		t.Fatalf("expected skip_auto_torrent request option, got %#v", coreSvc.fetchReq.Options)
-	}
-}
-
-type guiSnapshotGuardCore struct {
-	closeCounterCore
-	wantScreens int
-	errs        chan<- error
-}
-
-func (c *guiSnapshotGuardCore) check(req api.Request, method string) {
-	if req.Options.Screens != c.wantScreens {
-		select {
-		case c.errs <- errors.New(method + " used mismatched runtime options"):
-		default:
-		}
-	}
-}
-
-func (c *guiSnapshotGuardCore) FetchScreenshotPlan(_ context.Context, req api.Request) (api.ScreenshotPlan, error) {
-	c.check(req, "FetchScreenshotPlan")
-	return api.ScreenshotPlan{}, nil
-}
-
-func (c *guiSnapshotGuardCore) GenerateScreenshots(_ context.Context, req api.Request, _ []api.ScreenshotSelection, _ api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	c.check(req, "GenerateScreenshots")
-	return api.ScreenshotResult{}, nil
-}
-
-func (c *guiSnapshotGuardCore) ListUploadCandidates(_ context.Context, req api.Request) ([]api.ScreenshotImage, error) {
-	c.check(req, "ListUploadCandidates")
-	return nil, nil
-}
-
-func (c *guiSnapshotGuardCore) ListUploadedImages(_ context.Context, req api.Request) ([]api.UploadedImageLink, error) {
-	c.check(req, "ListUploadedImages")
-	return nil, nil
-}
-
-func (c *guiSnapshotGuardCore) UploadImages(_ context.Context, req api.Request, _ string, _ []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	c.check(req, "UploadImages")
-	return api.UploadImagesResult{}, nil
-}
-
-func (c *guiSnapshotGuardCore) RunUploadPrepared(_ context.Context, req api.Request) (api.Result, error) {
-	c.check(req, "RunUploadPrepared")
-	return api.Result{}, nil
-}
-
-func (c *guiSnapshotGuardCore) ExportGUICachedPreparedMeta(_ context.Context, req api.Request) (api.PreparedMetadata, bool, error) {
-	c.check(req, "ExportGUICachedPreparedMeta")
-	return api.PreparedMetadata{}, false, nil
-}
-
-func TestGUIRequestsUseSingleRuntimeSnapshot(t *testing.T) {
-	t.Parallel()
-
-	errs := make(chan error, 1)
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-runtime-snapshot.db")
-	cfgA := guiConfigTestConfig(repoPath)
-	cfgA.ScreenshotHandling.Screens = 1
-	cfgB := cfgA
-	cfgB.ScreenshotHandling.Screens = 2
-	app := &App{
-		cfg:  cfgA,
-		core: &guiSnapshotGuardCore{wantScreens: 1, errs: errs},
-		repo: repo,
-	}
-
-	stop := make(chan struct{})
-	var wg sync.WaitGroup
-	wg.Go(func() {
-		for i := 0; ; i++ {
-			select {
-			case <-stop:
-				return
-			default:
-			}
-			if i%2 == 0 {
-				app.replaceRuntime(cfgB, &guiSnapshotGuardCore{wantScreens: 2, errs: errs}, nil)
-			} else {
-				app.replaceRuntime(cfgA, &guiSnapshotGuardCore{wantScreens: 1, errs: errs}, nil)
-			}
-		}
-	})
-	t.Cleanup(func() {
-		close(stop)
-		wg.Wait()
-	})
-
-	for range 200 {
-		if _, err := app.FetchScreenshotPlan("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}); err != nil {
-			t.Fatalf("fetch screenshot plan: %v", err)
-		}
-		if _, err := app.GenerateScreenshots("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, api.ScreenshotPurposeFinal); err != nil {
-			t.Fatalf("generate screenshots: %v", err)
-		}
-		if _, err := app.ListUploadCandidates("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}); err != nil {
-			t.Fatalf("list upload candidates: %v", err)
-		}
-		if _, err := app.ListUploadedImages("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}); err != nil {
-			t.Fatalf("list uploaded images: %v", err)
-		}
-		if _, err := app.UploadImages("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, "host", []api.ScreenshotImage{{Path: "image.jpg"}}); err != nil {
-			t.Fatalf("upload images: %v", err)
-		}
-		_, _ = app.FetchTrackerDryRun("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, nil, nil, nil, false, false, "")
-		select {
-		case err := <-errs:
-			t.Fatal(err)
-		default:
-		}
-	}
-}
-
-func TestRunSingleTrackerUploadUsesJobUploadOptionsSnapshot(t *testing.T) {
-	t.Parallel()
-
-	errs := make(chan error, 1)
-	repoPath := filepath.Join(t.TempDir(), "gui-upload-job.db")
-	jobCfg := guiConfigTestConfig(repoPath)
-	jobCfg.ScreenshotHandling.Screens = 1
-	currentCfg := jobCfg
-	currentCfg.ScreenshotHandling.Screens = 2
-	app := &App{cfg: currentCfg}
-	job := &trackerUploadJob{
-		sourcePath:           "C:\\releases\\Example.mkv",
-		uploadOptions:        buildRunUploadOptions(jobCfg, runOptions{}),
-		runOptions:           runOptions{},
-		core:                 &guiSnapshotGuardCore{wantScreens: 1, errs: errs},
-		descriptionGroups:    nil,
-		trackers:             []string{"BTN"},
-		questionnaireAnswers: map[string]map[string]string{},
-	}
-
-	if _, err := app.runSingleTrackerUpload(context.Background(), job, "BTN"); err != nil {
-		t.Fatalf("run single tracker upload: %v", err)
-	}
-	select {
-	case err := <-errs:
-		t.Fatal(err)
-	default:
-	}
-}
-
-func TestSaveConfigAcceptsSameDatabasePathAlias(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-dbpath-alias.db")
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-	t.Cleanup(func() {
-		if coreSvc := app.currentCore(); coreSvc != nil {
-			_ = coreSvc.Close()
-		}
-		if logger := app.currentLogger(); logger != nil {
-			_ = logger.Close()
-		}
-	})
-
-	updated := initial
-	updated.MainSettings.DBPath = filepath.Dir(repoPath) + string(filepath.Separator) + "." + string(filepath.Separator) + filepath.Base(repoPath)
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	if err := app.SaveConfig(payload); err != nil {
-		t.Fatalf("save config with DBPath alias: %v", err)
-	}
-	if got := app.currentConfig().MainSettings.DBPath; got != repoPath {
-		t.Fatalf("runtime DBPath: got %q want %q", got, repoPath)
-	}
-}
-
-func TestSaveConfigRejectsDifferentDatabasePath(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-dbpath-change.db")
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.MainSettings.DBPath = filepath.Join(t.TempDir(), "different.db")
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected DBPath change rejection")
-	}
-	if !strings.Contains(err.Error(), "requires restart") {
-		t.Fatalf("expected restart error, got %v", err)
-	}
-}
-
-func TestSaveConfigAppliesRuntimeConfigImmediately(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "save-config.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-	initial := config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-	t.Cleanup(func() {
-		if coreSvc := app.currentCore(); coreSvc != nil {
-			_ = coreSvc.Close()
-		}
-		if logger := app.currentLogger(); logger != nil {
-			_ = logger.Close()
-		}
-	})
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	updated.Metadata.OnlyID = true
-	updated.ScreenshotHandling.Screens = 4
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	if err := app.SaveConfig(payload); err != nil {
-		t.Fatalf("save config: %v", err)
-	}
-
-	runtimeCfg := app.currentConfig()
-	if !runtimeCfg.Metadata.SkipAutoTorrent || !runtimeCfg.Metadata.OnlyID {
-		t.Fatalf("expected metadata settings applied, got %#v", runtimeCfg.Metadata)
-	}
-	if runtimeCfg.ScreenshotHandling.Screens != 4 {
-		t.Fatalf("expected screenshots=4, got %d", runtimeCfg.ScreenshotHandling.Screens)
-	}
-	if app.currentCore() == nil {
-		t.Fatal("expected runtime core to be rebuilt")
-	}
-	options := buildRunUploadOptions(runtimeCfg, runOptions{})
-	if !options.SkipAutoTorrent || !options.OnlyID || options.Screens != 4 {
-		t.Fatalf("expected upload options from saved config, got %#v", options)
-	}
-}
-
-func TestSaveConfigRejectsInvalidEnvRuntimeConfig(t *testing.T) {
-	t.Setenv("UA_DEFAULT_SCREENS", "0")
-
-	repoPath := filepath.Join(t.TempDir(), "save-config-env.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	initial := config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.ScreenshotHandling.Screens = 4
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected env-derived runtime validation error")
-	}
-	if !strings.Contains(err.Error(), "screenshot_handling.screens") {
-		t.Fatalf("expected screens validation error, got %v", err)
-	}
-	if got := app.currentConfig().ScreenshotHandling.Screens; got != 1 {
-		t.Fatalf("expected runtime config to remain unchanged, got screens=%d", got)
-	}
-	if app.currentCore() != nil {
-		t.Fatal("expected runtime core not to be rebuilt")
-	}
-	if _, loadErr := config.LoadFromDatabase(context.Background(), repo); loadErr == nil {
-		t.Fatal("expected invalid runtime config to be rejected before database save")
-	}
-}
-
-func TestSaveConfigBuildRuntimeFailureLeavesDatabaseAndRuntimeUnchanged(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-runtime-build-failure.db")
-	initial := guiConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	previousCore := &closeCounterCore{}
-	app := &App{
-		cfg:  initial,
-		core: previousCore,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	updated.Logging.Level = "invalid-level"
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected runtime build failure")
-	}
-
-	assertGUIStoredAndRuntimeConfigUnchanged(t, app, repo, initial, previousCore)
-}
-
-func TestGetConfigFallsBackToRuntimeConfigWhenDatabaseConfigMissing(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-get-missing-config.db")
-	cfg := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  cfg,
-		repo: repo,
-	}
-
-	payload, err := app.GetConfig()
-	if err != nil {
-		t.Fatalf("get config: %v", err)
-	}
-	exported, err := config.ImportFromJSONEncrypted(payload)
-	if err != nil {
-		t.Fatalf("parse exported config: %v", err)
-	}
-	if exported.MainSettings.DBPath != repoPath {
-		t.Fatalf("DBPath: got %q want %q", exported.MainSettings.DBPath, repoPath)
-	}
-	if _, loadErr := config.LoadFromDatabase(context.Background(), repo); !errors.Is(loadErr, internalerrors.ErrNotFound) {
-		t.Fatalf("fallback should not persist config rows, load err=%v", loadErr)
-	}
-}
-
-func TestGetConfigFallbackUsesSingleRuntimeSnapshot(t *testing.T) {
-	t.Parallel()
-
-	tempDir := t.TempDir()
-	repoPath := filepath.Join(tempDir, "gui-empty-snapshot.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	pathA := filepath.Join(tempDir, "runtime-a.db")
-	pathB := filepath.Join(tempDir, "runtime-b.db")
-	cfgA := config.Config{
-		MainSettings:       config.MainSettingsConfig{DBPath: pathA},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-	}
-	cfgB := config.Config{
-		MainSettings:       config.MainSettingsConfig{DBPath: pathB},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 2},
-	}
-	app := &App{
-		cfg:  cfgA,
-		repo: repo,
-	}
-
-	assertExport := func(want config.Config) {
-		t.Helper()
-
-		app.replaceRuntime(want, nil, nil)
-		payload, err := app.GetConfig()
-		if err != nil {
-			t.Fatalf("get config: %v", err)
-		}
-		exported, err := config.ImportFromJSONEncrypted(payload)
-		if err != nil {
-			t.Fatalf("parse exported config: %v", err)
-		}
-		switch exported.MainSettings.DBPath {
-		case pathA:
-			if exported.ScreenshotHandling.Screens != cfgA.ScreenshotHandling.Screens {
-				t.Fatalf("mixed fallback snapshot for %q: screens=%d", pathA, exported.ScreenshotHandling.Screens)
-			}
-		case pathB:
-			if exported.ScreenshotHandling.Screens != cfgB.ScreenshotHandling.Screens {
-				t.Fatalf("mixed fallback snapshot for %q: screens=%d", pathB, exported.ScreenshotHandling.Screens)
-			}
-		default:
-			t.Fatalf("unexpected fallback DBPath %q", exported.MainSettings.DBPath)
-		}
-	}
-	assertExport(cfgA)
-	assertExport(cfgB)
-
-	if _, loadErr := config.LoadFromDatabase(context.Background(), repo); !errors.Is(loadErr, internalerrors.ErrNotFound) {
-		t.Fatalf("fallback should not persist config rows, load err=%v", loadErr)
-	}
-}
-
-func TestExportConfigToPathFallsBackToRuntimeConfigWhenDatabaseConfigMissing(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-export-missing-config.db")
-	cfg := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  cfg,
-		repo: repo,
-	}
-
-	outputBase := filepath.Join(t.TempDir(), "config-export")
-	outputPath, err := app.exportConfigToPath(context.Background(), outputBase)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	wantPath := outputBase + ".yaml"
-	if outputPath != wantPath {
-		t.Fatalf("output path: got %q want %q", outputPath, wantPath)
-	}
-	exported, err := config.ImportFromYAML(outputPath)
-	if err != nil {
-		t.Fatalf("parse exported config: %v", err)
-	}
-	if exported.MainSettings.DBPath != repoPath {
-		t.Fatalf("DBPath: got %q want %q", exported.MainSettings.DBPath, repoPath)
-	}
-	if exported.Trackers.Trackers == nil {
-		t.Fatal("expected fallback export to include nonnil tracker map")
-	}
-	if _, loadErr := config.LoadFromDatabase(context.Background(), repo); !errors.Is(loadErr, internalerrors.ErrNotFound) {
-		t.Fatalf("fallback should not persist config rows, load err=%v", loadErr)
-	}
-}
-
-func TestExportConfigToPathUsesDatabaseConfigWhenPresent(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-export-stored-config.db")
-	runtimeCfg := guiConfigTestConfig(repoPath)
-	runtimeCfg.ScreenshotHandling.Screens = 1
-	storedCfg := guiConfigTestConfig(repoPath)
-	storedCfg.ScreenshotHandling.Screens = 7
-	if err := config.SaveToDatabase(context.Background(), &storedCfg, repo); err != nil {
-		t.Fatalf("save stored config: %v", err)
-	}
-	app := &App{
-		cfg:  runtimeCfg,
-		repo: repo,
-	}
-
-	outputPath, err := app.exportConfigToPath(context.Background(), filepath.Join(t.TempDir(), "stored.yaml"))
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	exported, err := config.ImportFromYAML(outputPath)
-	if err != nil {
-		t.Fatalf("parse exported config: %v", err)
-	}
-	if exported.ScreenshotHandling.Screens != storedCfg.ScreenshotHandling.Screens {
-		t.Fatalf("screens: got %d want %d", exported.ScreenshotHandling.Screens, storedCfg.ScreenshotHandling.Screens)
-	}
-}
-
-func TestExportConfigToPathAuthorizesAgainstExportSnapshotDBPath(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-export-snapshot-auth.db")
-	tempDir := filepath.Dir(repoPath)
-	runtimeDBPath := filepath.Join(tempDir, "runtime", "state.db")
-	storedDBPath := filepath.Join(tempDir, "stored", "state.db")
-	writeGUIAuthFile(t, runtimeDBPath, false)
-	writeGUIAuthFile(t, storedDBPath, true)
-
-	runtimeCfg := guiConfigTestConfig(runtimeDBPath)
-	runtimeCfg.MainSettings.TMDBAPI = "runtime-secret"
-	storedCfg := guiConfigTestConfig(storedDBPath)
-	storedCfg.MainSettings.TMDBAPI = "stored-secret"
-	if err := config.SaveToDatabase(context.Background(), &storedCfg, repo); err != nil {
-		t.Fatalf("save stored config: %v", err)
-	}
-	app := &App{
-		cfg:  runtimeCfg,
-		repo: repo,
-	}
-
-	outputPath, err := app.exportConfigToPath(context.Background(), filepath.Join(t.TempDir(), "stored.yaml"))
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	payload, err := os.ReadFile(outputPath)
-	if err != nil {
-		t.Fatalf("read exported config: %v", err)
-	}
-	exported := string(payload)
-	if !strings.Contains(exported, "stored-secret") {
-		t.Fatalf("expected plaintext stored secret authorized by stored DB path, payload=%s", exported)
-	}
-	if strings.Contains(exported, "runtime-secret") {
-		t.Fatalf("export used runtime secret, payload=%s", exported)
-	}
-}
-
-func TestExportConfigToPathFallbackRespectsUnencryptedExportAuth(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name                   string
-		allowUnencryptedExport bool
-		expectPlaintext        bool
-		expectEncryptedMarker  bool
-	}{
-		{
-			name:                   "allow unencrypted export",
-			allowUnencryptedExport: true,
-			expectPlaintext:        true,
-			expectEncryptedMarker:  false,
-		},
-		{
-			name:                   "deny unencrypted export",
-			allowUnencryptedExport: false,
-			expectPlaintext:        false,
-			expectEncryptedMarker:  true,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			repo, repoPath := openGUIConfigTestRepo(t, "gui-export-auth.db")
-			writeGUIAuthFile(t, repoPath, tc.allowUnencryptedExport)
-			cfg := guiConfigTestConfig(repoPath)
-			cfg.MainSettings.TMDBAPI = "plain-secret"
-			app := &App{
-				cfg:  cfg,
-				repo: repo,
-			}
-
-			outputPath, err := app.exportConfigToPath(context.Background(), filepath.Join(t.TempDir(), "auth.yaml"))
-			if err != nil {
-				t.Fatalf("export config: %v", err)
-			}
-			payload, err := os.ReadFile(outputPath)
-			if err != nil {
-				t.Fatalf("read exported config: %v", err)
-			}
-			exported := string(payload)
-			if got := strings.Contains(exported, "plain-secret"); got != tc.expectPlaintext {
-				t.Fatalf("plaintext presence = %t, want %t; payload=%s", got, tc.expectPlaintext, exported)
-			}
-			if got := strings.Contains(exported, "upbrr-enc:v1:"); got != tc.expectEncryptedMarker {
-				t.Fatalf("encrypted marker presence = %t, want %t; payload=%s", got, tc.expectEncryptedMarker, exported)
-			}
-		})
-	}
-}
-
-func TestExportConfigToPathBlankPathNoops(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-export-blank-path.db")
-	app := &App{
-		cfg:  guiConfigTestConfig(repoPath),
-		repo: repo,
-	}
-
-	outputPath, err := app.exportConfigToPath(context.Background(), "   ")
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	if outputPath != "" {
-		t.Fatalf("output path: got %q want empty", outputPath)
-	}
-}
-
-func TestSaveConfigMalformedWebAuthFailsBeforeConfigSave(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-malformed-auth.db")
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	if err := os.WriteFile(authmaterial.AuthFilePath(repoPath), []byte(`{`), 0o600); err != nil {
-		t.Fatalf("write malformed auth file: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected malformed web auth to fail before save")
-	}
-
-	assertGUIFailedConfigSaveRowsAbsent(t, repo)
-	if got := app.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after failed auth sync")
-	}
-}
-
-func TestImportConfigMalformedWebAuthFailsBeforeConfigSave(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-import-malformed-auth.db")
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	imported := initial
-	imported.Metadata.SkipAutoTorrent = true
-	path := exportGUIConfigYAML(t, &imported)
-	if err := os.WriteFile(authmaterial.AuthFilePath(repoPath), []byte(`{`), 0o600); err != nil {
-		t.Fatalf("write malformed auth file: %v", err)
-	}
-
-	_, err := app.importConfigFromPath(context.Background(), path)
-	if err == nil {
-		t.Fatal("expected malformed web auth to fail before imported config save")
-	}
-
-	assertGUIFailedConfigSaveRowsAbsent(t, repo)
-	if got := app.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after failed auth sync")
-	}
-}
-
-func TestSaveConfigHardCookieMigrationErrorDoesNotSaveOrInstallRuntime(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-cookie-migration-hard-error.db")
-	initial := guiConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-		sharedCookieMigrator: func(context.Context, string, api.Logger) error {
-			return errors.New("forced migration failure")
-		},
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected hard cookie migration error")
-	}
-	if !strings.Contains(err.Error(), "forced migration failure") {
-		t.Fatalf("expected forced migration failure, got %v", err)
-	}
-	assertGUIStoredAndRuntimeConfigUnchanged(t, app, repo, initial, nil)
-}
-
-func TestSaveConfigMigratesLegacyCookies(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-legacy-cookies.db")
-	if err := authmaterial.BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	legacyPath := writeGUILegacyCookieFile(t, repoPath, "BLU", `{"session":"from-legacy"}`)
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-	if err := app.SaveConfig(payload); err != nil {
-		t.Fatalf("save config: %v", err)
-	}
-	if _, err := os.Stat(legacyPath); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("expected legacy cookie file to be removed after migration, err=%v", err)
-	}
-	values, err := cookies.LoadTrackerCookieMap(context.Background(), repoPath, "BLU")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if got := values["session"]; got != "from-legacy" {
-		t.Fatal("migrated session cookie mismatch")
-	}
-}
-
-func TestImportConfigBuildRuntimeFailureLeavesDatabaseAndRuntimeUnchanged(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-import-runtime-build-failure.db")
-	initial := guiConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	previousCore := &closeCounterCore{}
-	app := &App{
-		cfg:  initial,
-		core: previousCore,
-		repo: repo,
-	}
-
-	imported := initial
-	imported.Metadata.SkipAutoTorrent = true
-	imported.Logging.Level = "invalid-level"
-	path := exportGUIConfigYAML(t, &imported)
-
-	result, err := app.importConfigFromPath(context.Background(), path)
-	if err == nil {
-		t.Fatal("expected runtime build failure")
-	}
-	if result.Message != "" || len(result.Warnings) != 0 {
-		t.Fatalf("expected empty import result on failed apply, got %#v", result)
-	}
-
-	assertGUIStoredAndRuntimeConfigUnchanged(t, app, repo, initial, previousCore)
-}
-
-func TestImportConfigHardCookieMigrationErrorDoesNotSaveOrInstallRuntime(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-import-cookie-migration-hard-error.db")
-	initial := guiConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	previousCore := &closeCounterCore{}
-	app := &App{
-		cfg:  initial,
-		core: previousCore,
-		repo: repo,
-		sharedCookieMigrator: func(context.Context, string, api.Logger) error {
-			return errors.New("forced migration failure")
-		},
-	}
-
-	imported := initial
-	imported.Metadata.SkipAutoTorrent = true
-	path := exportGUIConfigYAML(t, &imported)
-
-	result, err := app.importConfigFromPath(context.Background(), path)
-	if err == nil {
-		t.Fatal("expected hard cookie migration error")
-	}
-	if !strings.Contains(err.Error(), "forced migration failure") {
-		t.Fatalf("expected forced migration failure, got %v", err)
-	}
-	if result.Message != "" || len(result.Warnings) != 0 {
-		t.Fatalf("expected empty import result on failed apply, got %#v", result)
-	}
-	assertGUIStoredAndRuntimeConfigUnchanged(t, app, repo, initial, previousCore)
-}
-
-func TestSaveConfigSyncsUsableWebAuthBeforeSave(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-usable-auth.db")
-	if err := authmaterial.BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	if err := app.SaveConfig(payload); err != nil {
-		t.Fatalf("save config: %v", err)
-	}
-
-	assertGUICookieAuthStatePresent(t, repo)
-}
-
-func TestSaveConfigLeavesConfigUnchangedWhenRepositorySaveFailsAfterCookieSync(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-cookie-rollback.db")
-	if err := authmaterial.BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	installGUIFailMainSettingsTrigger(t, repo)
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	err = app.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected save config to fail")
-	}
-
-	assertGUIConfigRowsAbsent(t, repo)
-	assertGUICookieAuthStatePresent(t, repo)
-	if got := app.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after failed config save")
-	}
-}
-
-func TestSaveConfigRepositoryRejectsAuthChangeAfterValidation(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openGUIConfigTestRepo(t, "gui-save-auth-drift.db")
-	if err := authmaterial.BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := validateCookieAuthMaterial(repoPath); err != nil {
-		t.Fatalf("prevalidate auth material: %v", err)
-	}
-	if err := os.WriteFile(authmaterial.AuthFilePath(repoPath), []byte(`{`), 0o600); err != nil {
-		t.Fatalf("replace auth file: %v", err)
-	}
-	initial := guiConfigTestConfig(repoPath)
-	app := &App{
-		cfg:  initial,
-		repo: repo,
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	err := app.saveConfigToRepository(context.Background(), &updated, repoPath)
-	if err == nil {
-		t.Fatal("expected auth drift to malformed helper to fail")
-	}
-	assertGUIFailedConfigSaveRowsAbsent(t, repo)
-}
-
-func TestListHistoryUsesRepositoryWhenCoreDisabled(t *testing.T) {
-	t.Parallel()
-
-	repo := openGUIAppTestRepo(t)
-	ctx := context.Background()
-	sourcePath := filepath.Join(t.TempDir(), "Example.mkv")
-	updatedAt := time.Now().UTC().Add(-time.Hour)
-	createdAt := time.Now().UTC()
-
-	if err := repo.Save(ctx, db.FileMetadata{
-		Path:       sourcePath,
-		Title:      "Example",
-		Source:     "BluRay",
-		Resolution: "1080p",
-		UpdatedAt:  updatedAt,
-	}); err != nil {
-		t.Fatalf("save metadata: %v", err)
-	}
-	if err := repo.CreateUploadRecord(ctx, db.UploadRecord{
-		SourcePath: sourcePath,
-		Tracker:    "HDB",
-		Status:     "uploaded",
-		CreatedAt:  createdAt,
-	}); err != nil {
-		t.Fatalf("create upload record: %v", err)
-	}
-
-	app := &App{
-		repo:        repo,
-		coreInitErr: errors.New("invalid config"),
-	}
-
-	entries, err := app.ListHistory()
-	if err != nil {
-		t.Fatalf("list history: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 history entry, got %d", len(entries))
-	}
-	if entries[0].SourcePath != sourcePath {
-		t.Fatalf("unexpected source path: %q", entries[0].SourcePath)
-	}
-	if entries[0].LatestUploadStatus != "Uploaded" {
-		t.Fatalf("expected normalized status, got %q", entries[0].LatestUploadStatus)
-	}
-}
-
-func TestGetHistoryOverviewUsesRepositoryWhenCoreDisabled(t *testing.T) {
-	t.Parallel()
-
-	repo := openGUIAppTestRepo(t)
-	ctx := context.Background()
-	sourcePath := filepath.Join(t.TempDir(), "Example.mkv")
-	updatedAt := time.Now().UTC().Add(-time.Hour)
-	createdAt := time.Now().UTC()
-
-	if err := repo.Save(ctx, db.FileMetadata{
-		Path:       sourcePath,
-		Title:      "Example",
-		Source:     "WEB",
-		Resolution: "2160p",
-		UpdatedAt:  updatedAt,
-	}); err != nil {
-		t.Fatalf("save metadata: %v", err)
-	}
-	if err := repo.CreateUploadRecord(ctx, db.UploadRecord{
-		SourcePath: sourcePath,
-		Tracker:    "BHD",
-		Status:     "failed",
-		CreatedAt:  createdAt,
-	}); err != nil {
-		t.Fatalf("create upload record: %v", err)
-	}
-	if err := repo.SaveDescriptionOverride(ctx, db.DescriptionOverride{
-		SourcePath:  sourcePath,
-		GroupKey:    "unit3d",
-		Description: "grouped override",
-		UpdatedAt:   time.Now().UTC(),
-	}); err != nil {
-		t.Fatalf("save description override: %v", err)
-	}
-
-	app := &App{
-		repo:        repo,
-		coreInitErr: errors.New("invalid config"),
-	}
-
-	overview, err := app.GetHistoryOverview(sourcePath)
-	if err != nil {
-		t.Fatalf("get history overview: %v", err)
-	}
-	if overview.SourcePath != sourcePath {
-		t.Fatalf("unexpected source path: %q", overview.SourcePath)
-	}
-	if overview.ReleaseTitle != "Example" {
-		t.Fatalf("unexpected release title: %q", overview.ReleaseTitle)
-	}
-	if overview.StatusLabel != "Failed" {
-		t.Fatalf("expected failed status label, got %q", overview.StatusLabel)
-	}
-	if len(overview.DescriptionOverrides) != 1 {
-		t.Fatalf("expected 1 grouped description override, got %d", len(overview.DescriptionOverrides))
-	}
-	if overview.DescriptionOverrides[0].GroupKey != "unit3d" {
-		t.Fatalf("expected grouped override key to be preserved, got %q", overview.DescriptionOverrides[0].GroupKey)
-	}
-	if overview.DescriptionOverride.GroupKey != "unit3d" {
-		t.Fatalf("expected preferred description override key to be unit3d, got %q", overview.DescriptionOverride.GroupKey)
-	}
-}
-
-func TestGetLogExclusionsReturnsEmptySlice(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name  string
-		setup func(t *testing.T, app *App)
-	}{
-		{
-			name: "missing",
-		},
-		{
-			name: "stored empty",
-			setup: func(t *testing.T, app *App) {
-				t.Helper()
-
-				if err := app.UpdateLogExclusions(nil); err != nil {
-					t.Fatalf("update log exclusions: %v", err)
-				}
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			app := &App{repo: openGUIAppTestRepo(t)}
-			if tt.setup != nil {
-				tt.setup(t, app)
-			}
-
-			patterns, err := app.GetLogExclusions()
-			if err != nil {
-				t.Fatalf("get log exclusions: %v", err)
-			}
-			if patterns == nil {
-				t.Fatal("expected non-nil empty exclusions")
-			}
-			if len(patterns) != 0 {
-				t.Fatalf("expected no exclusions, got %#v", patterns)
-			}
-		})
-	}
-}
-
-func openGUIAppTestRepo(t *testing.T) *db.SQLiteRepository {
-	t.Helper()
-
-	repoPath := filepath.Join(t.TempDir(), "guiapp.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-	return repo
-}
-
-func openGUIConfigTestRepo(t *testing.T, name string) (*db.SQLiteRepository, string) {
-	t.Helper()
-
-	repoPath := filepath.Join(t.TempDir(), name)
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-	return repo, repoPath
-}
-
-func guiConfigTestConfig(repoPath string) config.Config {
-	return config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-}
-
-func exportGUIConfigYAML(t *testing.T, cfg *config.Config) string {
-	t.Helper()
-
-	path := filepath.Join(t.TempDir(), "config.yaml")
-	if err := config.ExportToYAML(cfg, path); err != nil {
-		t.Fatalf("export config yaml: %v", err)
-	}
-	return path
-}
-
-func writeGUILegacyCookieFile(t *testing.T, repoPath, trackerID, payload string) string {
-	t.Helper()
-
-	path, err := db.CookiePath(repoPath, trackerID+".json")
-	if err != nil {
-		t.Fatalf("resolve legacy cookie path: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		t.Fatalf("mkdir legacy cookie dir: %v", err)
-	}
-	if err := os.WriteFile(path, []byte(payload), 0o600); err != nil {
-		t.Fatalf("write legacy cookie file: %v", err)
-	}
-	return path
-}
-
-func writeGUIAuthFile(t *testing.T, dbPath string, allowUnencryptedExport bool) {
-	t.Helper()
-
-	if err := os.MkdirAll(filepath.Dir(dbPath), 0o755); err != nil {
-		t.Fatalf("create auth dir: %v", err)
-	}
-	authJSON := `{"username":"tester","password_hash":"hash","encryption_key_seed":"seed","allow_unencrypted_export":false}`
-	if allowUnencryptedExport {
-		authJSON = `{"username":"tester","password_hash":"hash","encryption_key_seed":"seed","allow_unencrypted_export":true}`
-	}
-	if err := os.WriteFile(authmaterial.AuthFilePath(dbPath), []byte(authJSON), 0o600); err != nil {
-		t.Fatalf("write auth file: %v", err)
-	}
-}
-
-func assertGUIFailedConfigSaveRowsAbsent(t *testing.T, repo *db.SQLiteRepository) {
-	t.Helper()
-
-	for _, section := range []string{
-		"MainSettings",
-		"cookies_encryption_salt",
-		"cookies_encryption_auth_state",
-	} {
-		var data string
-		err := repo.RawDB().QueryRowContext(context.Background(),
-			`SELECT data FROM config_settings WHERE section = ?`,
-			section,
-		).Scan(&data)
-		if !errors.Is(err, sql.ErrNoRows) {
-			t.Fatalf("expected %s to be absent after failed sync, got row=%q err=%v", section, data, err)
-		}
-	}
-}
-
-func assertGUIConfigRowsAbsent(t *testing.T, repo *db.SQLiteRepository) {
-	t.Helper()
-
-	var data string
-	err := repo.RawDB().QueryRowContext(context.Background(),
-		`SELECT data FROM config_settings WHERE section = ?`,
-		"MainSettings",
-	).Scan(&data)
-	if !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("expected MainSettings to be absent after failed save, got row=%q err=%v", data, err)
-	}
-}
-
-func assertGUICookieAuthStatePresent(t *testing.T, repo *db.SQLiteRepository) {
-	t.Helper()
-
-	var authState string
-	if err := repo.RawDB().QueryRowContext(context.Background(),
-		`SELECT data FROM config_settings WHERE section = ?`,
-		"cookies_encryption_auth_state",
-	).Scan(&authState); err != nil {
-		t.Fatalf("query cookie auth state: %v", err)
-	}
-	if !strings.Contains(authState, "fingerprint") {
-		t.Fatalf("expected synced cookie auth fingerprint, got %s", authState)
-	}
-}
-
-func installGUIFailMainSettingsTrigger(t *testing.T, repo *db.SQLiteRepository) {
-	t.Helper()
-
-	if _, err := repo.RawDB().ExecContext(context.Background(), `
-		CREATE TRIGGER fail_main_settings_save
-		BEFORE INSERT ON config_settings
-		WHEN NEW.section = 'MainSettings'
-		BEGIN
-			SELECT RAISE(FAIL, 'forced main settings failure');
-		END
-	`); err != nil {
-		t.Fatalf("create failure trigger: %v", err)
-	}
-}
-
-func assertGUIStoredAndRuntimeConfigUnchanged(t *testing.T, app *App, repo *db.SQLiteRepository, want config.Config, wantCore api.Core) {
-	t.Helper()
-
-	stored, err := config.LoadFromDatabase(context.Background(), repo)
-	if err != nil {
-		t.Fatalf("load stored config: %v", err)
-	}
-	if stored.Metadata.SkipAutoTorrent != want.Metadata.SkipAutoTorrent {
-		t.Fatalf("stored skip_auto_torrent: got %v want %v", stored.Metadata.SkipAutoTorrent, want.Metadata.SkipAutoTorrent)
-	}
-	if stored.Logging.Level != want.Logging.Level {
-		t.Fatalf("stored logging level: got %q want %q", stored.Logging.Level, want.Logging.Level)
-	}
-
-	runtimeCfg := app.currentConfig()
-	if runtimeCfg.Metadata.SkipAutoTorrent != want.Metadata.SkipAutoTorrent {
-		t.Fatalf("runtime skip_auto_torrent: got %v want %v", runtimeCfg.Metadata.SkipAutoTorrent, want.Metadata.SkipAutoTorrent)
-	}
-	if runtimeCfg.Logging.Level != want.Logging.Level {
-		t.Fatalf("runtime logging level: got %q want %q", runtimeCfg.Logging.Level, want.Logging.Level)
-	}
-	if gotCore := app.currentCore(); gotCore != wantCore {
-		t.Fatalf("runtime core changed: got %T want %T", gotCore, wantCore)
-	}
-}
-
-func TestApplyConfigKeepsSharedRepositoryUsable(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "apply.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-	cfg := config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-
-	app := &App{
-		cfg:  cfg,
-		repo: repo,
-	}
-	t.Cleanup(func() {
-		if app.core != nil {
-			_ = app.core.Close()
-		}
-		if app.logger != nil {
-			_ = app.logger.Close()
-		}
-	})
-
-	if err := app.applyConfig(context.Background(), cfg); err != nil {
-		t.Fatalf("apply config: %v", err)
-	}
-	if app.core == nil {
-		t.Fatal("expected core to be initialized")
-	}
-	if err := app.core.Close(); err != nil {
-		t.Fatalf("close core: %v", err)
-	}
-
-	if err := repo.Save(context.Background(), db.FileMetadata{
-		Path:      filepath.Join(t.TempDir(), "after-apply.mkv"),
-		Title:     "After Apply",
-		UpdatedAt: time.Now().UTC().Truncate(time.Second),
-	}); err != nil {
-		t.Fatalf("expected shared repo to remain usable after core close: %v", err)
-	}
-}
-
-func TestNewAppKeepsSharedRepositoryUsableAfterCoreClose(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "newapp.db")
-	cfg := &config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-
-	configPath := filepath.Join(t.TempDir(), "config.yaml")
-	authPath := filepath.Join(filepath.Dir(repoPath), authmaterial.WebAuthFileName)
-	if err := os.WriteFile(authPath, []byte(`{"username":"tester","password_hash":"very-secret-password-hash","encryption_key_seed":"stable-seed-for-tests"}`), 0o600); err != nil {
-		t.Fatalf("write web auth fixture: %v", err)
-	}
-	if err := config.ExportToYAML(cfg, configPath); err != nil {
-		t.Fatalf("export config: %v", err)
-	}
-
-	app, err := NewApp(configPath, true)
-	if err != nil {
-		t.Fatalf("new app: %v", err)
-	}
-	t.Cleanup(func() {
-		app.shutdown(context.Background())
-	})
-
-	if app.core == nil {
-		t.Fatal("expected startup core to be initialized")
-	}
-	if err := app.core.Close(); err != nil {
-		t.Fatalf("close core: %v", err)
-	}
-	if app.repo == nil {
-		t.Fatal("expected shared repo to be initialized")
-	}
-
-	if err := app.repo.Save(context.Background(), db.FileMetadata{
-		Path:      filepath.Join(t.TempDir(), "after-startup.mkv"),
-		Title:     "After Startup",
-		UpdatedAt: time.Now().UTC().Truncate(time.Second),
-	}); err != nil {
-		t.Fatalf("expected startup repo to remain usable after core close: %v", err)
-	}
-}
-
-func TestAppAllowUnencryptedExportFromWebAuth(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "gui.db")
-	authPath := filepath.Join(filepath.Dir(repoPath), authmaterial.WebAuthFileName)
-	if err := os.WriteFile(authPath, []byte(`{"username":"tester","password_hash":"hash","allow_unencrypted_export":true}`), 0o600); err != nil {
-		t.Fatalf("write web auth fixture: %v", err)
-	}
-
-	app := &App{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: repoPath},
-		},
-	}
-
-	allow, err := app.allowUnencryptedExport(repoPath)
-	if err != nil {
-		t.Fatalf("allowUnencryptedExport: %v", err)
-	}
-	if !allow {
-		t.Fatal("expected allowUnencryptedExport to be true")
-	}
-}
-
-func TestGetWebAuthStatusReportsMissingFile(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "gui.db")
-	app := &App{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: repoPath},
-		},
-	}
-
-	status, err := app.GetWebAuthStatus()
-	if err != nil {
-		t.Fatalf("GetWebAuthStatus: %v", err)
-	}
-	if status.Exists {
-		t.Fatal("expected missing web auth file")
-	}
-	if !status.CanCreate {
-		t.Fatal("expected status to allow creating web auth")
-	}
-	if status.Usable {
-		t.Fatal("expected missing web auth to be unusable")
-	}
-}
-
-func TestCreateWebAuthCreatesUsableAuthFile(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "gui.db")
-	app := &App{
-		cfg: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: repoPath},
-		},
-	}
-
-	status, err := app.CreateWebAuth("tester", "very-secure-password")
-	if err != nil {
-		t.Fatalf("CreateWebAuth: %v", err)
-	}
-	if !status.Exists || !status.Usable {
-		t.Fatalf("expected usable web auth after create, got %+v", status)
-	}
-	if status.Username != "tester" {
-		t.Fatalf("expected username tester, got %q", status.Username)
-	}
-	if status.CanCreate {
-		t.Fatal("expected create to be disabled after bootstrap")
-	}
-
-	authPath := authmaterial.AuthFilePath(repoPath)
-	if _, err := os.Stat(authPath); err != nil {
-		t.Fatalf("expected auth file to exist: %v", err)
-	}
-}
diff --git a/internal/guiapp/app_links_test.go b/internal/guiapp/app_links_test.go
deleted file mode 100644
index c736e333..00000000
--- a/internal/guiapp/app_links_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import "testing"
-
-func TestValidateExternalURL(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr bool
-	}{
-		{name: "http url", input: "http://example.com/test", wantErr: false},
-		{name: "https url", input: "https://example.com/test?q=1", wantErr: false},
-		{name: "trimmed url", input: "  https://example.com/path  ", wantErr: false},
-		{name: "empty", input: "", wantErr: true},
-		{name: "relative", input: "/path", wantErr: true},
-		{name: "mailto", input: "mailto:user@example.com", wantErr: true},
-		{name: "javascript", input: "javascript:alert(1)", wantErr: true},
-		{name: "no host", input: "https:///path", wantErr: true},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := validateExternalURL(tc.input)
-			if tc.wantErr && err == nil {
-				t.Fatalf("expected error for input %q", tc.input)
-			}
-			if !tc.wantErr && err != nil {
-				t.Fatalf("unexpected error for input %q: %v", tc.input, err)
-			}
-		})
-	}
-}
diff --git a/internal/guiapp/assets.go b/internal/guiapp/assets.go
deleted file mode 100644
index fe96d04f..00000000
--- a/internal/guiapp/assets.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"errors"
-	"io/fs"
-	"os"
-	"path/filepath"
-)
-
-func resolveAssets(override fs.FS) (fs.FS, error) {
-	return ResolveAssets(override)
-}
-
-func ResolveAssets(override fs.FS) (fs.FS, error) {
-	if override != nil {
-		return override, nil
-	}
-	if embeddedRoot, err := fs.Sub(embeddedAssets, "assets"); err == nil {
-		if hasIndex(embeddedRoot) {
-			return embeddedRoot, nil
-		}
-	}
-	if hasIndex(embeddedAssets) {
-		return embeddedAssets, nil
-	}
-	for _, path := range candidateAssetPaths() {
-		diskAssets := os.DirFS(path)
-		if hasIndex(diskAssets) {
-			return diskAssets, nil
-		}
-	}
-	return nil, errors.New("gui assets not found: build gui/frontend and retry")
-}
-
-func hasIndex(assets fs.FS) bool {
-	if assets == nil {
-		return false
-	}
-	_, err := fs.Stat(assets, "index.html")
-	return err == nil
-}
-
-func candidateAssetPaths() []string {
-	return []string{
-		filepath.Join("gui", "frontend", "dist"),
-		filepath.Join("frontend", "dist"),
-	}
-}
diff --git a/internal/guiapp/assets/.keep b/internal/guiapp/assets/.keep
deleted file mode 100644
index 5cc86853..00000000
--- a/internal/guiapp/assets/.keep
+++ /dev/null
@@ -1,2 +0,0 @@
-This placeholder is committed so go:embed all:assets always has at least one match in clean checkouts.
-Generated GUI build artifacts in this directory remain ignored.
diff --git a/internal/guiapp/assets_test.go b/internal/guiapp/assets_test.go
deleted file mode 100644
index a61c3f19..00000000
--- a/internal/guiapp/assets_test.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"path/filepath"
-	"slices"
-	"testing"
-)
-
-func TestCandidateAssetPaths(t *testing.T) {
-	t.Parallel()
-
-	paths := candidateAssetPaths()
-
-	if !slices.Contains(paths, filepath.Join("gui", "frontend", "dist")) {
-		t.Fatalf("missing repo-root asset path: %v", paths)
-	}
-	if !slices.Contains(paths, filepath.Join("frontend", "dist")) {
-		t.Fatalf("missing gui-working-directory asset path: %v", paths)
-	}
-}
diff --git a/internal/guiapp/dupe_jobs.go b/internal/guiapp/dupe_jobs.go
deleted file mode 100644
index 9971f383..00000000
--- a/internal/guiapp/dupe_jobs.go
+++ /dev/null
@@ -1,574 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"math/big"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const dupeCheckEventPrefix = "dupe:job:"
-const errDupeCheckRequiresMetadataPreview = "dupe check requires metadata preview"
-
-// DupeCheckTrackerState reports Wails-visible state for one tracker in a dupe
-// check job.
-type DupeCheckTrackerState struct {
-	Tracker    string              `json:"tracker"`
-	Status     string              `json:"status"`
-	Message    string              `json:"message"`
-	Result     api.DupeCheckResult `json:"result"`
-	StartedAt  string              `json:"startedAt"`
-	FinishedAt string              `json:"finishedAt"`
-}
-
-// DupeCheckSnapshot reports Wails-visible state for a dupe check job.
-type DupeCheckSnapshot struct {
-	JobID          string                  `json:"jobID"`
-	SourcePath     string                  `json:"sourcePath"`
-	Status         string                  `json:"status"`
-	Trackers       []DupeCheckTrackerState `json:"trackers"`
-	CompletedCount int                     `json:"completedCount"`
-	TotalCount     int                     `json:"totalCount"`
-	Summary        api.DupeCheckSummary    `json:"summary"`
-	Error          string                  `json:"error"`
-	StartedAt      string                  `json:"startedAt"`
-	FinishedAt     string                  `json:"finishedAt"`
-}
-
-type dupeCheckJob struct {
-	mu             sync.Mutex
-	cleanupOnce    sync.Once
-	id             string
-	sourcePath     string
-	uploadOptions  api.UploadOptions
-	core           api.Core
-	logger         interface{ Close() error }
-	overrides      api.ExternalIDOverrides
-	nameOverrides  api.ReleaseNameOverrides
-	trackers       []string
-	states         map[string]DupeCheckTrackerState
-	completedCount int
-	totalCount     int
-	summary        api.DupeCheckSummary
-	status         string
-	errorMessage   string
-	startedAt      time.Time
-	finishedAt     time.Time
-	cancel         context.CancelFunc
-}
-
-// StartDupeCheck starts a background dupe check for selected trackers and
-// returns the job ID. When the active core exposes the GUI prepared-metadata
-// cache, the matching metadata preview must already exist before a durable job
-// is created. The job captures a runtime snapshot so later config/core swaps do
-// not change the cache proof or execution core.
-func (a *App) StartDupeCheck(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string) (string, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return "", err
-	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
-	}
-	resolvedTrackers := normalizeTrackerList(trackers)
-	if len(resolvedTrackers) == 0 {
-		return "", errors.New("at least one tracker must be selected")
-	}
-
-	req := api.Request{
-		Paths:    []string{trimmedPath},
-		Mode:     api.ModeGUI,
-		Trackers: resolvedTrackers,
-		Options:  rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-	baseCtx := a.runtimeContext()
-	var preparedMeta api.PreparedMetadata
-	preparedMetaFound := false
-	if exporter, ok := rt.core.(guishared.PreparedMetaExporter); ok {
-		var found bool
-		preparedMeta, found, err = exporter.ExportGUICachedPreparedMeta(baseCtx, req)
-		if err != nil {
-			return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
-		}
-		if !found {
-			return "", errors.New(errDupeCheckRequiresMetadataPreview)
-		}
-		preparedMetaFound = true
-	}
-
-	runCore, runLogger, err := a.buildRunCoreFromSnapshot(rt, runOptions{})
-	if err != nil {
-		return "", err
-	}
-	if preparedMetaFound {
-		importer, ok := runCore.(guishared.PreparedMetaImporter)
-		if !ok {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", errors.New("dupe check metadata preview cache: run core cannot import prepared metadata")
-		}
-		if err := importer.ImportPreparedMetadataForGUI(baseCtx, req, preparedMeta); err != nil {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
-		}
-	}
-
-	jobID := randomJobID()
-	states := make(map[string]DupeCheckTrackerState, len(resolvedTrackers))
-	for _, tracker := range resolvedTrackers {
-		normalized := strings.ToUpper(strings.TrimSpace(tracker))
-		if normalized == "" {
-			continue
-		}
-		states[normalized] = DupeCheckTrackerState{Tracker: normalized, Status: "queued", Message: "queued"}
-	}
-
-	job := &dupeCheckJob{
-		id:            jobID,
-		sourcePath:    trimmedPath,
-		uploadOptions: req.Options,
-		core:          runCore,
-		logger:        runLogger,
-		overrides:     overrides,
-		nameOverrides: nameOverrides,
-		trackers:      resolvedTrackers,
-		states:        states,
-		totalCount:    len(states),
-		summary:       api.DupeCheckSummary{SourcePath: trimmedPath},
-		status:        "queued",
-		startedAt:     time.Now().UTC(),
-	}
-
-	jobCtx, cancel := context.WithCancel(baseCtx)
-	job.cancel = cancel
-
-	a.publishDupeCheckJob(job)
-	a.emitDupeCheckSnapshot(baseCtx, job)
-	go func() {
-		defer a.dupeWG.Done()
-		defer cancel()
-		a.runDupeCheckJob(jobCtx, baseCtx, job)
-	}()
-
-	return jobID, nil
-}
-
-// GetDupeCheckSnapshot returns the current state for an existing dupe check job.
-func (a *App) GetDupeCheckSnapshot(jobID string) (DupeCheckSnapshot, error) {
-	if a == nil {
-		return DupeCheckSnapshot{}, errors.New("app not initialized")
-	}
-	trimmedID := strings.TrimSpace(jobID)
-	if trimmedID == "" {
-		return DupeCheckSnapshot{}, errors.New("job id is required")
-	}
-
-	job := a.getDupeCheckJob(trimmedID)
-	if job == nil {
-		return DupeCheckSnapshot{}, errors.New("dupe job not found")
-	}
-
-	return buildDupeCheckSnapshot(job), nil
-}
-
-// CancelDupeCheck requests cancellation for an existing dupe check job.
-func (a *App) CancelDupeCheck(jobID string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	trimmedID := strings.TrimSpace(jobID)
-	if trimmedID == "" {
-		return errors.New("job id is required")
-	}
-
-	job := a.getDupeCheckJob(trimmedID)
-	if job == nil {
-		return errors.New("dupe job not found")
-	}
-
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
-	}
-	return nil
-}
-
-func (a *App) runDupeCheckJob(ctx context.Context, eventCtx context.Context, job *dupeCheckJob) {
-	if job != nil {
-		defer func() {
-			_ = job.closeResources()
-		}()
-	}
-	if a == nil || job == nil || job.core == nil {
-		return
-	}
-
-	job.mu.Lock()
-	job.status = "running"
-	job.mu.Unlock()
-	a.emitDupeCheckSnapshot(eventCtx, job)
-
-	progressCtx := api.WithDupeProgressReporter(ctx, func(update api.DupeProgressUpdate) {
-		a.applyDupeProgress(eventCtx, job, update)
-	})
-
-	req := api.Request{
-		Paths:    []string{job.sourcePath},
-		Mode:     api.ModeGUI,
-		Trackers: job.trackers,
-		Options:  job.uploadOptions,
-
-		ExternalIDOverrides:  job.overrides,
-		ReleaseNameOverrides: job.nameOverrides,
-	}
-
-	summary, err := job.core.CheckDupes(progressCtx, req)
-
-	job.mu.Lock()
-	job.finishedAt = time.Now().UTC()
-	job.cancel = nil
-	if err != nil {
-		if ctx.Err() != nil {
-			job.status = "canceled"
-			job.errorMessage = "dupe check canceled"
-			for tracker, state := range job.states {
-				if !isDupeTerminalStatus(state.Status) {
-					state.Status = "canceled"
-					state.Message = "canceled"
-					state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-					job.states[tracker] = state
-				}
-			}
-		} else {
-			job.status = "failed"
-			job.errorMessage = logging.SanitizeMessage(err.Error())
-		}
-		job.mu.Unlock()
-		a.emitDupeCheckSnapshot(eventCtx, job)
-		return
-	}
-
-	job.summary = summary
-	for _, result := range summary.Results {
-		for _, tracker := range dupeResultTrackerNames(result) {
-			state := job.states[tracker]
-			if state.Tracker == "" {
-				state.Tracker = tracker
-				job.trackers = append(job.trackers, tracker)
-				job.totalCount++
-			}
-			if !isDupeTerminalStatus(state.Status) {
-				job.completedCount++
-			}
-			state.Status = resultStatus(result)
-			state.Message = resultMessage(result)
-			state.Result = result
-			state.Result.Tracker = tracker
-			if state.StartedAt == "" {
-				state.StartedAt = job.startedAt.Format(time.RFC3339)
-			}
-			state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-			job.states[tracker] = state
-		}
-	}
-
-	if hasFailedDupeState(job.states) {
-		job.status = "completed_with_errors"
-		if strings.TrimSpace(job.errorMessage) == "" {
-			job.errorMessage = "one or more tracker dupe checks failed"
-		}
-	} else {
-		job.status = "completed"
-		job.errorMessage = ""
-	}
-	job.mu.Unlock()
-	a.emitDupeCheckSnapshot(eventCtx, job)
-}
-
-func randomJobID() string {
-	value, err := rand.Int(rand.Reader, new(big.Int).SetUint64(^uint64(0)))
-	if err != nil {
-		return strconv.FormatInt(time.Now().UnixNano(), 10)
-	}
-	return fmt.Sprintf("%d-%x", time.Now().UnixNano(), value.Uint64())
-}
-
-func (a *App) applyDupeProgress(ctx context.Context, job *dupeCheckJob, update api.DupeProgressUpdate) {
-	if a == nil || job == nil {
-		return
-	}
-	tracker := strings.ToUpper(strings.TrimSpace(update.Tracker))
-	if tracker == "" {
-		return
-	}
-
-	job.mu.Lock()
-	state := job.states[tracker]
-	if state.Tracker == "" {
-		state.Tracker = tracker
-		job.trackers = append(job.trackers, tracker)
-		if update.Total <= 0 {
-			job.totalCount++
-		}
-	}
-	previousStatus := state.Status
-	state.Status = strings.TrimSpace(update.Status)
-	if state.Status == "" {
-		state.Status = previousStatus
-	}
-	if strings.TrimSpace(update.Message) != "" {
-		state.Message = strings.TrimSpace(update.Message)
-	}
-	if state.Status == "running" && state.StartedAt == "" {
-		state.StartedAt = time.Now().UTC().Format(time.RFC3339)
-	}
-	if update.Result.Tracker != "" {
-		state.Result = update.Result
-		upsertDupeSummaryResult(&job.summary, update.Result)
-	}
-	if isDupeTerminalStatus(state.Status) {
-		if state.FinishedAt == "" {
-			state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
-		}
-		if !isDupeTerminalStatus(previousStatus) {
-			job.completedCount++
-		}
-	}
-	if update.Total > job.totalCount {
-		job.totalCount = update.Total
-	}
-	job.states[tracker] = state
-	job.mu.Unlock()
-
-	a.emitDupeCheckSnapshot(ctx, job)
-}
-
-func upsertDupeSummaryResult(summary *api.DupeCheckSummary, result api.DupeCheckResult) {
-	if summary == nil {
-		return
-	}
-	tracker := strings.ToUpper(strings.TrimSpace(result.Tracker))
-	if tracker == "" {
-		return
-	}
-	for idx := range summary.Results {
-		existing := strings.ToUpper(strings.TrimSpace(summary.Results[idx].Tracker))
-		if existing != tracker {
-			continue
-		}
-		summary.Results[idx] = result
-		return
-	}
-	summary.Results = append(summary.Results, result)
-}
-
-// dupeResultTrackerNames expands grouped dupe summary labels into the
-// per-tracker state keys used by frontend snapshots.
-func dupeResultTrackerNames(result api.DupeCheckResult) []string {
-	trackers := strings.Split(result.Tracker, ",")
-	names := make([]string, 0, len(trackers))
-	seen := make(map[string]struct{}, len(trackers))
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		if _, ok := seen[name]; ok {
-			continue
-		}
-		seen[name] = struct{}{}
-		names = append(names, name)
-	}
-	return names
-}
-
-func hasFailedDupeState(states map[string]DupeCheckTrackerState) bool {
-	for _, state := range states {
-		if strings.EqualFold(state.Status, "failed") {
-			return true
-		}
-	}
-	return false
-}
-
-func isDupeTerminalStatus(status string) bool {
-	switch strings.ToLower(strings.TrimSpace(status)) {
-	case "completed", "skipped", "failed", "canceled":
-		return true
-	default:
-		return false
-	}
-}
-
-func resultStatus(result api.DupeCheckResult) string {
-	if strings.TrimSpace(result.Status) != "" {
-		return result.Status
-	}
-	if result.Skipped {
-		return "skipped"
-	}
-	if strings.TrimSpace(result.Error) != "" {
-		return "failed"
-	}
-	return "completed"
-}
-
-func resultMessage(result api.DupeCheckResult) string {
-	if strings.TrimSpace(result.Error) != "" {
-		return strings.TrimSpace(result.Error)
-	}
-	if strings.TrimSpace(result.SkipReason) != "" {
-		return strings.TrimSpace(result.SkipReason)
-	}
-	if result.HasDupes {
-		return fmt.Sprintf("%d dupes found", len(result.Filtered))
-	}
-	return "no dupes found"
-}
-
-func (a *App) emitDupeCheckSnapshot(ctx context.Context, job *dupeCheckJob) {
-	if a == nil || ctx == nil || job == nil || ctx.Value("events") == nil {
-		return
-	}
-	defer func() {
-		_ = recover()
-	}()
-	snapshot := buildDupeCheckSnapshot(job)
-	runtime.EventsEmit(ctx, dupeCheckEventPrefix+job.id, snapshot)
-}
-
-func buildDupeCheckSnapshot(job *dupeCheckJob) DupeCheckSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-
-	trackers := make([]DupeCheckTrackerState, 0, len(job.trackers))
-	seen := make(map[string]struct{}, len(job.trackers))
-	for _, tracker := range job.trackers {
-		normalized := strings.ToUpper(strings.TrimSpace(tracker))
-		if normalized == "" {
-			continue
-		}
-		state, ok := job.states[normalized]
-		if !ok {
-			state = DupeCheckTrackerState{Tracker: normalized, Status: "queued", Message: "queued"}
-		}
-		trackers = append(trackers, state)
-		seen[normalized] = struct{}{}
-	}
-	for tracker, state := range job.states {
-		if _, ok := seen[tracker]; ok {
-			continue
-		}
-		trackers = append(trackers, state)
-	}
-
-	startedAt := ""
-	if !job.startedAt.IsZero() {
-		startedAt = job.startedAt.Format(time.RFC3339)
-	}
-	finishedAt := ""
-	if !job.finishedAt.IsZero() {
-		finishedAt = job.finishedAt.Format(time.RFC3339)
-	}
-
-	return DupeCheckSnapshot{
-		JobID:          job.id,
-		SourcePath:     job.sourcePath,
-		Status:         job.status,
-		Trackers:       trackers,
-		CompletedCount: job.completedCount,
-		TotalCount:     job.totalCount,
-		Summary:        job.summary,
-		Error:          job.errorMessage,
-		StartedAt:      startedAt,
-		FinishedAt:     finishedAt,
-	}
-}
-
-func (a *App) getDupeCheckJob(jobID string) *dupeCheckJob {
-	a.dupeMu.Lock()
-	defer a.dupeMu.Unlock()
-	return a.dupes[jobID]
-}
-
-func (a *App) publishDupeCheckJob(job *dupeCheckJob) {
-	a.dupeMu.Lock()
-	a.dupeWG.Add(1)
-	a.dupes[job.id] = job
-	a.dupeMu.Unlock()
-}
-
-func (j *dupeCheckJob) closeResources() error {
-	if j == nil {
-		return nil
-	}
-
-	var closeErr error
-	j.cleanupOnce.Do(func() {
-		j.mu.Lock()
-		coreSvc := j.core
-		logger := j.logger
-		j.core = nil
-		j.logger = nil
-		j.mu.Unlock()
-
-		if coreSvc != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("core", coreSvc))
-		}
-		if logger != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("logger", logger))
-		}
-	})
-	return closeErr
-}
-
-func (a *App) stopAllDupeJobs() {
-	if a == nil {
-		return
-	}
-	a.dupeMu.Lock()
-	jobs := make([]*dupeCheckJob, 0, len(a.dupes))
-	for _, job := range a.dupes {
-		jobs = append(jobs, job)
-	}
-	a.dupeMu.Unlock()
-
-	for _, job := range jobs {
-		if job == nil {
-			continue
-		}
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
-	}
-	a.dupeWG.Wait()
-	for _, job := range jobs {
-		if job != nil {
-			_ = job.closeResources()
-		}
-	}
-}
diff --git a/internal/guiapp/dvd_menu_jobs.go b/internal/guiapp/dvd_menu_jobs.go
deleted file mode 100644
index fefa3747..00000000
--- a/internal/guiapp/dvd_menu_jobs.go
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	dvdMenuCaptureEventPrefix              = "dvdmenu:job:"
-	errDVDMenuCaptureRequiresMetadataCache = "DVD menu capture requires metadata preview"
-	// dvdMenuCompletedJobRetention bounds how long terminal snapshots remain queryable.
-	dvdMenuCompletedJobRetention = 24 * time.Hour
-	// maxCompletedDVDMenuJobs bounds retained terminal snapshots across all GUI captures.
-	maxCompletedDVDMenuJobs = 200
-	dvdMenuSnapshotThrottle = 150 * time.Millisecond
-)
-
-// dvdMenuCaptureJob owns one isolated core/logger snapshot and its synchronized
-// frontend-visible progress state.
-type dvdMenuCaptureJob struct {
-	mu             sync.Mutex
-	cleanupOnce    sync.Once
-	id             string
-	sourcePath     string
-	uploadOptions  api.UploadOptions
-	core           api.Core
-	logger         interface{ Close() error }
-	overrides      api.ExternalIDOverrides
-	nameOverrides  api.ReleaseNameOverrides
-	status         string
-	phase          string
-	message        string
-	discovered     int
-	visitedStates  int
-	visitedButtons int
-	captured       int
-	warnings       int
-	result         api.DVDMenuCaptureResult
-	errorMessage   string
-	startedAt      time.Time
-	finishedAt     time.Time
-	lastEmit       time.Time
-	cancel         context.CancelFunc
-	retentionTimer *time.Timer
-}
-
-// StartDVDMenuCapture starts a background capture using the current prepared
-// GUI metadata and returns its job ID. Progress is emitted on
-// dvdmenu:job:<jobID>; setup errors reject the frontend call.
-func (a *App) StartDVDMenuCapture(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (string, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return "", err
-	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
-	}
-	req := newDVDMenuRequest(trimmedPath, overrides, nameOverrides, rt.baseUploadOptions())
-	baseCtx := a.runtimeContext()
-
-	var preparedMeta api.PreparedMetadata
-	preparedMetaFound := false
-	if exporter, ok := rt.core.(guishared.PreparedMetaExporter); ok {
-		preparedMeta, preparedMetaFound, err = exporter.ExportGUICachedPreparedMeta(baseCtx, req)
-		if err != nil {
-			return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
-		}
-		if !preparedMetaFound {
-			return "", errors.New(errDVDMenuCaptureRequiresMetadataCache)
-		}
-	}
-
-	runCore, runLogger, err := a.buildRunCoreFromSnapshot(rt, runOptions{})
-	if err != nil {
-		return "", err
-	}
-	if preparedMetaFound {
-		importer, ok := runCore.(guishared.PreparedMetaImporter)
-		if !ok {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", errors.New("DVD menu capture metadata preview cache: run core cannot import prepared metadata")
-		}
-		if err := importer.ImportPreparedMetadataForGUI(baseCtx, req, preparedMeta); err != nil {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
-		}
-	}
-
-	job := &dvdMenuCaptureJob{
-		id:            randomJobID(),
-		sourcePath:    trimmedPath,
-		uploadOptions: req.Options,
-		core:          runCore,
-		logger:        runLogger,
-		overrides:     overrides,
-		nameOverrides: nameOverrides,
-		status:        "queued",
-		phase:         "queued",
-		message:       "DVD menu capture queued.",
-		startedAt:     time.Now().UTC(),
-	}
-	jobCtx, cancel := context.WithCancel(baseCtx)
-	job.cancel = cancel
-
-	a.dvdMenuMu.Lock()
-	if a.dvdMenus == nil {
-		a.dvdMenus = make(map[string]*dvdMenuCaptureJob)
-	}
-	a.dvdMenus[job.id] = job
-	a.pruneCompletedDVDMenuJobsLocked(maxCompletedDVDMenuJobs)
-	a.dvdMenuWG.Add(1)
-	a.dvdMenuMu.Unlock()
-	a.emitDVDMenuCaptureSnapshot(baseCtx, job, true)
-	go func() {
-		defer a.dvdMenuWG.Done()
-		defer cancel()
-		a.runDVDMenuCaptureJob(jobCtx, baseCtx, job)
-	}()
-	return job.id, nil
-}
-
-// GetDVDMenuCaptureSnapshot returns the current capture job state. It rejects
-// unknown or expired job IDs. Terminal snapshots have bounded time and
-// capacity retention, so callers should consume their final state promptly.
-func (a *App) GetDVDMenuCaptureSnapshot(jobID string) (api.DVDMenuCaptureSnapshot, error) {
-	if a == nil {
-		return api.DVDMenuCaptureSnapshot{}, errors.New("app not initialized")
-	}
-	job := a.getDVDMenuCaptureJob(strings.TrimSpace(jobID))
-	if job == nil {
-		return api.DVDMenuCaptureSnapshot{}, errors.New("DVD menu capture job not found")
-	}
-	return buildDVDMenuCaptureSnapshot(job), nil
-}
-
-// CancelDVDMenuCapture requests cancellation for an existing capture job.
-// Completion is asynchronous and is reflected in later snapshots.
-func (a *App) CancelDVDMenuCapture(jobID string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	job := a.getDVDMenuCaptureJob(strings.TrimSpace(jobID))
-	if job == nil {
-		return errors.New("DVD menu capture job not found")
-	}
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
-	}
-	return nil
-}
-
-// ListDVDMenuScreenshots returns persisted manual and automatic menu images for
-// one host filesystem source path. The call requires prepared GUI metadata.
-func (a *App) ListDVDMenuScreenshots(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.ScreenshotImage, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return nil, err
-	}
-	ctx, cancel := context.WithTimeout(a.runtimeContext(), previewTimeout)
-	defer cancel()
-	req := newDVDMenuRequest(path, overrides, nameOverrides, rt.baseUploadOptions())
-	return wrapGUIResult(rt.core.ListDVDMenuScreenshots(ctx, req))
-}
-
-// DeleteDVDMenuScreenshot removes one persisted image from the prepared
-// release's managed directory and local records. Remote-host assets remain.
-func (a *App) DeleteDVDMenuScreenshot(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, imagePath string) error {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return err
-	}
-	ctx, cancel := context.WithTimeout(a.runtimeContext(), previewTimeout)
-	defer cancel()
-	req := newDVDMenuRequest(path, overrides, nameOverrides, rt.baseUploadOptions())
-	return wrapGUIError(rt.core.DeleteDVDMenuScreenshot(ctx, req, imagePath))
-}
-
-func newDVDMenuRequest(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, options api.UploadOptions) api.Request {
-	return api.Request{
-		Paths:                []string{strings.TrimSpace(path)},
-		Mode:                 api.ModeGUI,
-		Options:              options,
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-}
-
-// runDVDMenuCaptureJob owns the queued-to-terminal lifecycle, releases its
-// per-run core/logger resources exactly once, and schedules bounded retention.
-func (a *App) runDVDMenuCaptureJob(ctx context.Context, eventCtx context.Context, job *dvdMenuCaptureJob) {
-	if job != nil {
-		defer func() { _ = job.closeResources() }()
-	}
-	if a == nil || job == nil || job.core == nil {
-		return
-	}
-	job.mu.Lock()
-	job.status = "running"
-	job.phase = "preflight"
-	job.message = "Checking DVD menu capture support."
-	job.mu.Unlock()
-	a.emitDVDMenuCaptureSnapshot(eventCtx, job, true)
-
-	progressCtx := api.WithDVDMenuProgressReporter(ctx, func(update api.DVDMenuProgressUpdate) {
-		a.applyDVDMenuCaptureProgress(eventCtx, job, update)
-	})
-	req := newDVDMenuRequest(job.sourcePath, job.overrides, job.nameOverrides, job.uploadOptions)
-	result, err := job.core.CaptureDVDMenus(progressCtx, req)
-
-	job.mu.Lock()
-	job.result = result
-	job.finishedAt = time.Now().UTC()
-	job.cancel = nil
-	job.discovered = result.DiscoveredMenus
-	job.visitedStates = result.VisitedStates
-	job.visitedButtons = result.VisitedButtons
-	job.captured = len(result.Images)
-	job.warnings = len(result.Warnings)
-	if err != nil {
-		if ctx.Err() != nil {
-			job.status = "canceled"
-			job.phase = "canceled"
-			job.message = "DVD menu capture canceled."
-			job.errorMessage = "DVD menu capture canceled"
-		} else {
-			job.status = "failed"
-			job.phase = "failed"
-			job.message = "DVD menu capture failed."
-			job.errorMessage = redaction.RedactValue(err.Error(), nil)
-		}
-	} else {
-		job.status = "completed"
-		job.phase = "complete"
-		job.message = "DVD menu capture finished."
-		job.errorMessage = ""
-	}
-	job.mu.Unlock()
-	a.emitDVDMenuCaptureSnapshot(eventCtx, job, true)
-	a.scheduleDVDMenuJobCleanup(job)
-}
-
-func (a *App) applyDVDMenuCaptureProgress(ctx context.Context, job *dvdMenuCaptureJob, update api.DVDMenuProgressUpdate) {
-	job.mu.Lock()
-	if strings.TrimSpace(update.Phase) != "" {
-		job.phase = strings.TrimSpace(update.Phase)
-	}
-	if strings.TrimSpace(update.Message) != "" {
-		job.message = strings.TrimSpace(update.Message)
-	}
-	job.discovered = update.DiscoveredMenus
-	job.visitedStates = update.VisitedStates
-	job.visitedButtons = update.VisitedButtons
-	job.captured = update.CapturedCount
-	job.warnings = update.WarningCount
-	job.mu.Unlock()
-	a.emitDVDMenuCaptureSnapshot(ctx, job, false)
-}
-
-// emitDVDMenuCaptureSnapshot publishes a throttled Wails event; force bypasses
-// throttling for queued and terminal transitions.
-func (a *App) emitDVDMenuCaptureSnapshot(ctx context.Context, job *dvdMenuCaptureJob, force bool) {
-	if a == nil || ctx == nil || job == nil || ctx.Value("events") == nil {
-		return
-	}
-	job.mu.Lock()
-	if !force && time.Since(job.lastEmit) < dvdMenuSnapshotThrottle {
-		job.mu.Unlock()
-		return
-	}
-	job.lastEmit = time.Now()
-	job.mu.Unlock()
-	defer func() { _ = recover() }()
-	runtime.EventsEmit(ctx, dvdMenuCaptureEventPrefix+job.id, buildDVDMenuCaptureSnapshot(job))
-}
-
-func buildDVDMenuCaptureSnapshot(job *dvdMenuCaptureJob) api.DVDMenuCaptureSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	return api.DVDMenuCaptureSnapshot{
-		JobID:           job.id,
-		SourcePath:      job.sourcePath,
-		Status:          job.status,
-		Phase:           job.phase,
-		Message:         job.message,
-		DiscoveredMenus: job.discovered,
-		VisitedStates:   job.visitedStates,
-		VisitedButtons:  job.visitedButtons,
-		CapturedCount:   job.captured,
-		WarningCount:    job.warnings,
-		Result:          job.result,
-		Error:           job.errorMessage,
-		StartedAt:       formatDVDMenuTime(job.startedAt),
-		FinishedAt:      formatDVDMenuTime(job.finishedAt),
-	}
-}
-
-func formatDVDMenuTime(value time.Time) string {
-	if value.IsZero() {
-		return ""
-	}
-	return value.Format(time.RFC3339)
-}
-
-func (a *App) getDVDMenuCaptureJob(jobID string) *dvdMenuCaptureJob {
-	if strings.TrimSpace(jobID) == "" {
-		return nil
-	}
-	a.dvdMenuMu.Lock()
-	defer a.dvdMenuMu.Unlock()
-	return a.dvdMenus[jobID]
-}
-
-// closeResources closes the per-run core and logger at most once.
-func (job *dvdMenuCaptureJob) closeResources() error {
-	if job == nil {
-		return nil
-	}
-	var closeErr error
-	job.cleanupOnce.Do(func() {
-		job.mu.Lock()
-		coreSvc := job.core
-		logger := job.logger
-		job.core = nil
-		job.logger = nil
-		job.mu.Unlock()
-		if coreSvc != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("core", coreSvc))
-		}
-		if logger != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("logger", logger))
-		}
-	})
-	return closeErr
-}
-
-// scheduleDVDMenuJobCleanup retains a registered terminal job for the query
-// window and arranges its eventual removal. Capacity pruning may remove it
-// immediately when newer terminal jobs already fill the retained set.
-func (a *App) scheduleDVDMenuJobCleanup(job *dvdMenuCaptureJob) {
-	if a == nil || job == nil {
-		return
-	}
-	a.dvdMenuMu.Lock()
-	if a.dvdMenus[job.id] != job {
-		a.dvdMenuMu.Unlock()
-		return
-	}
-	a.pruneCompletedDVDMenuJobsLocked(maxCompletedDVDMenuJobs)
-	if a.dvdMenus[job.id] != job {
-		a.dvdMenuMu.Unlock()
-		return
-	}
-	timer := time.AfterFunc(dvdMenuCompletedJobRetention, func() {
-		a.dvdMenuMu.Lock()
-		defer a.dvdMenuMu.Unlock()
-		if current := a.dvdMenus[job.id]; current == job && isDVDMenuJobTerminal(job) {
-			a.deleteDVDMenuJobLocked(job)
-		}
-	})
-	job.mu.Lock()
-	job.retentionTimer = timer
-	job.mu.Unlock()
-	a.dvdMenuMu.Unlock()
-}
-
-// pruneCompletedDVDMenuJobsLocked evicts the oldest terminal jobs until at
-// most maxCompleted remain. The caller must hold a.dvdMenuMu.
-func (a *App) pruneCompletedDVDMenuJobsLocked(maxCompleted int) {
-	if maxCompleted <= 0 {
-		return
-	}
-	completed := make([]*dvdMenuCaptureJob, 0, len(a.dvdMenus))
-	for _, job := range a.dvdMenus {
-		if isDVDMenuJobTerminal(job) {
-			completed = append(completed, job)
-		}
-	}
-	if len(completed) <= maxCompleted {
-		return
-	}
-	sort.Slice(completed, func(i, j int) bool {
-		return completed[i].finishedAt.Before(completed[j].finishedAt)
-	})
-	for _, job := range completed[:len(completed)-maxCompleted] {
-		a.deleteDVDMenuJobLocked(job)
-	}
-}
-
-// deleteDVDMenuJobLocked removes job and stops its retention timer. The caller
-// must hold a.dvdMenuMu.
-func (a *App) deleteDVDMenuJobLocked(job *dvdMenuCaptureJob) {
-	delete(a.dvdMenus, job.id)
-	job.mu.Lock()
-	timer := job.retentionTimer
-	job.retentionTimer = nil
-	job.mu.Unlock()
-	if timer != nil {
-		timer.Stop()
-	}
-}
-
-// isDVDMenuJobTerminal reports whether job has reached a queryable final state.
-func isDVDMenuJobTerminal(job *dvdMenuCaptureJob) bool {
-	if job == nil {
-		return false
-	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	return job.status == "completed" || job.status == "failed" || job.status == "canceled"
-}
-
-// stopAllDVDMenuJobs cancels active captures, waits for workers, releases
-// per-job resources, and clears retained snapshots and cleanup timers.
-func (a *App) stopAllDVDMenuJobs() {
-	if a == nil {
-		return
-	}
-	a.dvdMenuMu.Lock()
-	jobs := make([]*dvdMenuCaptureJob, 0, len(a.dvdMenus))
-	for _, job := range a.dvdMenus {
-		jobs = append(jobs, job)
-	}
-	a.dvdMenuMu.Unlock()
-	for _, job := range jobs {
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
-	}
-	a.dvdMenuWG.Wait()
-	for _, job := range jobs {
-		_ = job.closeResources()
-	}
-	a.dvdMenuMu.Lock()
-	for _, job := range a.dvdMenus {
-		a.deleteDVDMenuJobLocked(job)
-	}
-	a.dvdMenuMu.Unlock()
-}
diff --git a/internal/guiapp/dvd_menu_jobs_test.go b/internal/guiapp/dvd_menu_jobs_test.go
deleted file mode 100644
index 698dd8a0..00000000
--- a/internal/guiapp/dvd_menu_jobs_test.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestRunDVDMenuCaptureJobPublishesProgressAndResult(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{
-		dvdMenuCapture: func(ctx context.Context, _ api.Request) (api.DVDMenuCaptureResult, error) {
-			api.ReportDVDMenuProgress(ctx, api.DVDMenuProgressUpdate{
-				Phase:           "capturing",
-				Message:         "Rendering distinct DVD menu screens.",
-				DiscoveredMenus: 3,
-				VisitedStates:   5,
-				VisitedButtons:  4,
-				CapturedCount:   1,
-				WarningCount:    1,
-			})
-			return api.DVDMenuCaptureResult{
-				SourcePath:      "Example.Release.2026.1080p-GRP",
-				DiscoveredMenus: 3,
-				VisitedStates:   5,
-				VisitedButtons:  4,
-				Partial:         true,
-				Images: []api.DVDMenuCaptureImage{{ScreenshotImage: api.ScreenshotImage{
-					Path:    "menu-1.png",
-					Purpose: api.ScreenshotPurposeMenu,
-				}}},
-				Warnings: []api.DVDMenuCaptureWarning{{Code: "frame_decode", Message: "One menu could not be rendered."}},
-			}, nil
-		},
-	}
-	job := &dvdMenuCaptureJob{
-		id:         "dvd-job-1",
-		sourcePath: "Example.Release.2026.1080p-GRP",
-		core:       coreSvc,
-		status:     "queued",
-		startedAt:  time.Now().UTC(),
-	}
-
-	(&App{}).runDVDMenuCaptureJob(context.Background(), nil, job)
-	snapshot := buildDVDMenuCaptureSnapshot(job)
-	if snapshot.Status != "completed" || snapshot.Phase != "complete" {
-		t.Fatalf("unexpected terminal snapshot: %#v", snapshot)
-	}
-	if snapshot.CapturedCount != 1 || snapshot.WarningCount != 1 || !snapshot.Result.Partial {
-		t.Fatalf("expected partial persisted result, got %#v", snapshot)
-	}
-	if got := coreSvc.dvdMenuCalls.Load(); got != 1 {
-		t.Fatalf("expected one capture call, got %d", got)
-	}
-	if got := coreSvc.count.Load(); got != 1 {
-		t.Fatalf("expected job core close, got %d", got)
-	}
-}
-
-func TestRunDVDMenuCaptureJobClassifiesCancellation(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{
-		dvdMenuCapture: func(ctx context.Context, _ api.Request) (api.DVDMenuCaptureResult, error) {
-			return api.DVDMenuCaptureResult{}, ctx.Err()
-		},
-	}
-	job := &dvdMenuCaptureJob{id: "dvd-job-1", core: coreSvc, status: "queued", startedAt: time.Now().UTC()}
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	(&App{}).runDVDMenuCaptureJob(ctx, nil, job)
-	snapshot := buildDVDMenuCaptureSnapshot(job)
-	if snapshot.Status != "canceled" || !errors.Is(ctx.Err(), context.Canceled) {
-		t.Fatalf("expected canceled snapshot, got %#v", snapshot)
-	}
-}
-
-func TestRunDVDMenuCaptureJobRedactsFailureMessage(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{
-		dvdMenuCapture: func(context.Context, api.Request) (api.DVDMenuCaptureResult, error) {
-			return api.DVDMenuCaptureResult{}, errors.New("provider rejected api_key=secret-value")
-		},
-	}
-	job := &dvdMenuCaptureJob{id: "dvd-job-1", core: coreSvc, status: "queued", startedAt: time.Now().UTC()}
-
-	(&App{}).runDVDMenuCaptureJob(context.Background(), nil, job)
-	snapshot := buildDVDMenuCaptureSnapshot(job)
-	if snapshot.Status != "failed" {
-		t.Fatal("expected failed snapshot")
-	}
-	if strings.Contains(snapshot.Error, "secret-value") || !strings.Contains(snapshot.Error, "[REDACTED]") {
-		t.Fatal("expected redacted DVD menu capture error")
-	}
-}
-
-func TestPruneCompletedDVDMenuJobsKeepsNewestBoundedSet(t *testing.T) {
-	t.Parallel()
-
-	now := time.Now().UTC()
-	oldest := &dvdMenuCaptureJob{
-		id:             "oldest",
-		status:         "completed",
-		finishedAt:     now.Add(-3 * time.Minute),
-		retentionTimer: time.NewTimer(time.Hour),
-	}
-	middle := &dvdMenuCaptureJob{id: "middle", status: "failed", finishedAt: now.Add(-2 * time.Minute)}
-	newest := &dvdMenuCaptureJob{id: "newest", status: "canceled", finishedAt: now.Add(-time.Minute)}
-	running := &dvdMenuCaptureJob{id: "running", status: "running", startedAt: now}
-	app := &App{dvdMenus: map[string]*dvdMenuCaptureJob{
-		oldest.id:  oldest,
-		middle.id:  middle,
-		newest.id:  newest,
-		running.id: running,
-	}}
-
-	app.dvdMenuMu.Lock()
-	app.pruneCompletedDVDMenuJobsLocked(2)
-	app.dvdMenuMu.Unlock()
-
-	if app.getDVDMenuCaptureJob(oldest.id) != nil {
-		t.Fatal("expected oldest terminal DVD menu job to be evicted")
-	}
-	oldest.mu.Lock()
-	oldestTimer := oldest.retentionTimer
-	oldest.mu.Unlock()
-	if oldestTimer != nil {
-		t.Fatal("expected evicted DVD menu job retention timer to be released")
-	}
-	for _, jobID := range []string{middle.id, newest.id, running.id} {
-		if app.getDVDMenuCaptureJob(jobID) == nil {
-			t.Fatal("expected retained DVD menu job")
-		}
-	}
-}
diff --git a/internal/guiapp/history.go b/internal/guiapp/history.go
deleted file mode 100644
index e1bd8c2b..00000000
--- a/internal/guiapp/history.go
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func (a *App) listHistoryFromRepo(ctx context.Context) ([]api.HistoryEntry, error) {
-	if err := a.requireHistoryRepo(); err != nil {
-		return nil, err
-	}
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("gui: list history canceled: %w", err)
-	}
-
-	entries, err := a.repo.ListHistoryEntries(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-
-	result := make([]api.HistoryEntry, 0, len(entries))
-	for _, entry := range entries {
-		entryCopy := entry
-		entryCopy.LatestUploadStatus = api.HistoryStatusLabel(entry.LatestUploadStatus, entry.RuleFailureCount)
-		result = append(result, entryCopy)
-	}
-
-	return result, nil
-}
-
-func (a *App) getHistoryOverviewFromRepo(ctx context.Context, sourcePath string) (api.HistoryOverview, error) {
-	if err := a.requireHistoryRepo(); err != nil {
-		return api.HistoryOverview{}, err
-	}
-	if err := ctx.Err(); err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: get history overview canceled: %w", err)
-	}
-
-	trimmed := strings.TrimSpace(sourcePath)
-	if trimmed == "" {
-		return api.HistoryOverview{}, internalerrors.ErrInvalidInput
-	}
-
-	metadata, err := a.repo.GetByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	overview := api.HistoryOverview{
-		SourcePath:        metadata.Path,
-		ReleaseTitle:      metadata.Title,
-		ReleaseSource:     metadata.Source,
-		ReleaseResolution: metadata.Resolution,
-		MetadataUpdatedAt: metadata.UpdatedAt,
-		Metadata:          metadata,
-	}
-
-	externalIDs, err := a.repo.GetExternalIDs(ctx, trimmed)
-	if err == nil {
-		overview.ExternalIDs = externalIDs
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	externalMetadata, err := a.repo.GetExternalMetadata(ctx, trimmed)
-	if err == nil {
-		overview.ExternalMetadata = externalMetadata
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	releaseOverrides, err := a.repo.GetReleaseNameOverrides(ctx, trimmed)
-	if err == nil {
-		overview.ReleaseNameOverrides = releaseOverrides
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	descriptionOverrides, err := a.repo.ListDescriptionOverridesByPath(ctx, trimmed)
-	if err == nil {
-		overview.DescriptionOverrides = append([]api.DescriptionOverride(nil), descriptionOverrides...)
-		overview.DescriptionOverride = preferredHistoryDescriptionOverride(descriptionOverrides)
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	playlistSelection, err := a.repo.GetPlaylistSelection(ctx, trimmed)
-	if err == nil {
-		overview.PlaylistSelection = playlistSelection
-	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-
-	trackerMetadata, err := a.repo.ListTrackerMetadataByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.TrackerMetadata = trackerMetadata
-
-	ruleFailures, err := a.repo.ListTrackerRuleFailuresByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.TrackerRuleFailures = ruleFailures
-
-	screenshots, err := a.repo.ListScreenshotsByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.Screenshots = screenshots
-
-	finalSelections, err := a.repo.ListFinalSelections(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.FinalSelections = finalSelections
-
-	uploadedImages, err := a.repo.ListUploadedImagesByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.UploadedImages = uploadedImages
-
-	uploadHistory, err := a.repo.ListUploadHistoryByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("gui: %w", err)
-	}
-	overview.UploadHistory = uploadHistory
-
-	if len(uploadHistory) > 0 {
-		overview.LatestUploadStatus = uploadHistory[0].Status
-		overview.LatestUploadAt = uploadHistory[0].CreatedAt
-	}
-	blockingRuleFailures := api.CountBlockingRuleFailures(ruleFailures)
-	overview.StatusLabel = api.HistoryStatusLabel(overview.LatestUploadStatus, blockingRuleFailures)
-
-	return overview, nil
-}
-
-func preferredHistoryDescriptionOverride(overrides []api.DescriptionOverride) api.DescriptionOverride {
-	if len(overrides) == 0 {
-		return api.DescriptionOverride{}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.GroupKey) == "" {
-			return override
-		}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.Description) != "" {
-			return override
-		}
-	}
-	return overrides[0]
-}
diff --git a/internal/guiapp/logging.go b/internal/guiapp/logging.go
deleted file mode 100644
index 272f9f2a..00000000
--- a/internal/guiapp/logging.go
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"math/big"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/logging"
-)
-
-const logStreamEventPrefix = "log:stream:"
-const logExclusionsSection = "log_exclusions"
-
-var emitLogStreamEvent = runtime.EventsEmit
-
-// LogExclusions stores muted log patterns for the UI.
-type LogExclusions struct {
-	Patterns []string `json:"patterns"`
-}
-
-type logStreamSession struct {
-	id        string
-	eventName string
-	logger    *logging.Logger
-	subID     int
-	stop      chan struct{}
-	done      chan struct{}
-}
-
-func (a *App) GetLogPath() (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	return wrapGUIResult(logging.LogPath(a.currentConfig().MainSettings.DBPath))
-}
-
-func (a *App) GetRecentLogs(limit int) ([]logging.Entry, error) {
-	logger := a.currentLogger()
-	if logger == nil {
-		return nil, errors.New("logger not initialized")
-	}
-	return logger.Recent(limit), nil
-}
-
-func (a *App) StartLogStream() (string, error) {
-	if a == nil || a.currentLogger() == nil {
-		return "", errors.New("logger not initialized")
-	}
-
-	a.streamMu.Lock()
-	defer a.streamMu.Unlock()
-
-	streamID := randomLogStreamID()
-	session := &logStreamSession{
-		id:        streamID,
-		eventName: logStreamEventPrefix + streamID,
-		stop:      make(chan struct{}),
-		done:      make(chan struct{}),
-	}
-	a.streams[streamID] = session
-	a.startStreamLocked(a.runtimeContext(), session)
-	return streamID, nil
-}
-
-func (a *App) StopLogStream(streamID string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-
-	a.streamMu.Lock()
-	session := a.streams[streamID]
-	if session != nil {
-		delete(a.streams, streamID)
-		a.stopStreamLocked(session)
-	}
-	a.streamMu.Unlock()
-
-	return nil
-}
-
-func (a *App) GetLogExclusions() ([]string, error) {
-	if a == nil {
-		return nil, errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return nil, errors.New("config repository not initialized")
-	}
-
-	ctx := a.runtimeContext()
-
-	var exclusions LogExclusions
-	if err := config.LoadSectionFromDatabase(ctx, logExclusionsSection, &exclusions, a.repo); err != nil {
-		if errors.Is(err, internalerrors.ErrNotFound) {
-			return []string{}, nil
-		}
-		return nil, fmt.Errorf("gui: %w", err)
-	}
-
-	return normalizePatterns(exclusions.Patterns), nil
-}
-
-func (a *App) UpdateLogExclusions(patterns []string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	if a.repo == nil {
-		return errors.New("config repository not initialized")
-	}
-
-	ctx := a.runtimeContext()
-
-	exclusions := LogExclusions{Patterns: normalizePatterns(patterns)}
-	if err := config.SaveSectionToDatabase(ctx, logExclusionsSection, exclusions, a.repo); err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-
-	return nil
-}
-
-// startStreamLocked subscribes session to the current logger while streamMu is
-// held; callers keep ownership of session registration and later shutdown.
-func (a *App) startStreamLocked(ctx context.Context, session *logStreamSession) {
-	if session == nil {
-		return
-	}
-	logger := a.currentLogger()
-	if logger == nil {
-		close(session.done)
-		return
-	}
-
-	subID, ch := logger.Subscribe(0)
-	session.logger = logger
-	session.subID = subID
-
-	stop := session.stop
-	done := session.done
-	eventName := session.eventName
-
-	go func() {
-		defer close(done)
-		for {
-			select {
-			case entry, ok := <-ch:
-				if !ok {
-					return
-				}
-				emitLogStreamEvent(ctx, eventName, entry)
-			case <-stop:
-				logger.Unsubscribe(subID)
-				return
-			}
-		}
-	}()
-}
-
-func (a *App) stopStreamLocked(session *logStreamSession) {
-	if session == nil || session.stop == nil {
-		return
-	}
-	select {
-	case <-session.stop:
-		return
-	default:
-		close(session.stop)
-	}
-}
-
-func (a *App) stopAllLogStreams() {
-	if a == nil {
-		return
-	}
-
-	a.streamMu.Lock()
-	for _, session := range a.streams {
-		a.stopStreamLocked(session)
-	}
-	a.streams = make(map[string]*logStreamSession)
-	a.streamMu.Unlock()
-}
-
-// rebindLogStreams moves active UI log streams from oldLogger to newLogger.
-// Existing stream goroutines are stopped and waited on before replacement
-// subscriptions start, so old subscriptions cannot emit after the rebind.
-func (a *App) rebindLogStreams(ctx context.Context, oldLogger *logging.Logger, newLogger *logging.Logger) {
-	if a == nil {
-		return
-	}
-	if oldLogger == newLogger {
-		return
-	}
-
-	type stoppedStream struct {
-		session *logStreamSession
-		done    <-chan struct{}
-	}
-
-	a.streamMu.Lock()
-	stopped := make([]stoppedStream, 0, len(a.streams))
-	for _, session := range a.streams {
-		if session == nil {
-			continue
-		}
-		stopped = append(stopped, stoppedStream{
-			session: session,
-			done:    session.done,
-		})
-		a.stopStreamLocked(session)
-	}
-	a.streamMu.Unlock()
-
-	for _, stream := range stopped {
-		if stream.done != nil {
-			<-stream.done
-		}
-	}
-
-	a.streamMu.Lock()
-	for _, stream := range stopped {
-		session := stream.session
-		if session == nil || a.streams[session.id] != session {
-			continue
-		}
-		session.stop = make(chan struct{})
-		session.done = make(chan struct{})
-		a.startStreamLocked(ctx, session)
-	}
-	a.streamMu.Unlock()
-}
-
-func normalizePatterns(patterns []string) []string {
-	seen := make(map[string]struct{})
-	normalized := make([]string, 0, len(patterns))
-	for _, pattern := range patterns {
-		trimmed := strings.TrimSpace(pattern)
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		normalized = append(normalized, trimmed)
-	}
-	return normalized
-}
-
-func randomLogStreamID() string {
-	value, err := rand.Int(rand.Reader, new(big.Int).SetUint64(^uint64(0)))
-	if err != nil {
-		return strconv.FormatInt(time.Now().UnixNano(), 10)
-	}
-	return fmt.Sprintf("%d-%x", time.Now().UnixNano(), value.Uint64())
-}
diff --git a/internal/guiapp/logging_test.go b/internal/guiapp/logging_test.go
deleted file mode 100644
index 1db8f2e0..00000000
--- a/internal/guiapp/logging_test.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"io"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/logging"
-)
-
-func TestRebindLogStreamsStopsOldSubscriptionWithoutStoppingNewStream(t *testing.T) {
-	oldLogger := newGUIAppLogStreamTestLogger(t)
-	newLogger := newGUIAppLogStreamTestLogger(t)
-	oldEmitStarted := make(chan struct{})
-	releaseOldEmit := make(chan struct{})
-	newEntryReceived := make(chan struct{}, 1)
-
-	previousEmitter := emitLogStreamEvent
-	t.Cleanup(func() {
-		emitLogStreamEvent = previousEmitter
-	})
-	emitLogStreamEvent = func(_ context.Context, _ string, data ...any) {
-		entry, ok := data[0].(logging.Entry)
-		if !ok {
-			return
-		}
-		switch entry.Message {
-		case "old":
-			close(oldEmitStarted)
-			<-releaseOldEmit
-		case "new":
-			newEntryReceived <- struct{}{}
-		}
-	}
-
-	app := &App{
-		logger:  oldLogger,
-		streams: make(map[string]*logStreamSession),
-	}
-	session := &logStreamSession{
-		id:        "stream",
-		eventName: logStreamEventPrefix + "stream",
-		stop:      make(chan struct{}),
-		done:      make(chan struct{}),
-	}
-	app.streams[session.id] = session
-	app.startStreamLocked(context.Background(), session)
-	oldStop := session.stop
-	oldDone := session.done
-
-	oldLogger.Errorf("old")
-	waitForLogStreamTestSignal(t, oldEmitStarted, "old stream emit")
-
-	rebindDone := make(chan struct{})
-	go func() {
-		app.replaceRuntime(config.Config{}, nil, newLogger)
-		app.rebindLogStreams(context.Background(), oldLogger, newLogger)
-		close(rebindDone)
-	}()
-
-	waitForLogStreamTestSignal(t, oldStop, "old stream stop signal")
-	assertLogStreamBlocked(t, rebindDone, "rebind before old stream stop")
-	if got := loggerSubscriberCount(newLogger); got != 0 {
-		t.Fatalf("new logger subscribers before old stop: got %d want 0", got)
-	}
-
-	close(releaseOldEmit)
-
-	waitForLogStreamTestSignal(t, oldDone, "old stream stop")
-	waitForLogStreamTestSignal(t, rebindDone, "rebind completion")
-	newDone := session.done
-	if got := loggerSubscriberCount(oldLogger); got != 0 {
-		t.Fatalf("old logger subscribers: got %d want 0", got)
-	}
-	if got := loggerSubscriberCount(newLogger); got != 1 {
-		t.Fatalf("new logger subscribers after old stop: got %d want 1", got)
-	}
-	assertLogStreamStillRunning(t, newDone, "new stream after old stop")
-
-	newLogger.Errorf("new")
-	waitForLogStreamTestSignal(t, newEntryReceived, "new stream entry")
-
-	if err := app.StopLogStream(session.id); err != nil {
-		t.Fatalf("stop log stream: %v", err)
-	}
-	waitForLogStreamTestSignal(t, newDone, "new stream stop")
-	if got := loggerSubscriberCount(newLogger); got != 0 {
-		t.Fatalf("new logger subscribers after explicit stop: got %d want 0", got)
-	}
-}
-
-func TestRebindLogStreamsSameLoggerDoesNotRestartStream(t *testing.T) {
-	logger := newGUIAppLogStreamTestLogger(t)
-	app := &App{
-		logger:  logger,
-		streams: make(map[string]*logStreamSession),
-	}
-	session := &logStreamSession{
-		id:        "stream",
-		eventName: logStreamEventPrefix + "stream",
-		stop:      make(chan struct{}),
-		done:      make(chan struct{}),
-	}
-	app.streams[session.id] = session
-	app.startStreamLocked(context.Background(), session)
-	stop := session.stop
-	done := session.done
-
-	app.rebindLogStreams(context.Background(), logger, logger)
-
-	if session.stop != stop {
-		t.Fatal("same-logger rebind replaced stop channel")
-	}
-	if session.done != done {
-		t.Fatal("same-logger rebind replaced done channel")
-	}
-	if got := loggerSubscriberCount(logger); got != 1 {
-		t.Fatalf("logger subscribers after same-logger rebind: got %d want 1", got)
-	}
-	assertLogStreamStillRunning(t, done, "same-logger stream")
-}
-
-func TestRebindLogStreamsNilLoggerDoesNotBlockNextRebind(t *testing.T) {
-	oldLogger := newGUIAppLogStreamTestLogger(t)
-	newLogger := newGUIAppLogStreamTestLogger(t)
-	app := &App{
-		logger:  oldLogger,
-		streams: make(map[string]*logStreamSession),
-	}
-	session := &logStreamSession{
-		id:        "stream",
-		eventName: logStreamEventPrefix + "stream",
-		stop:      make(chan struct{}),
-		done:      make(chan struct{}),
-	}
-	app.streams[session.id] = session
-	app.startStreamLocked(context.Background(), session)
-
-	app.replaceRuntime(config.Config{}, nil, nil)
-	app.rebindLogStreams(context.Background(), oldLogger, nil)
-	waitForLogStreamTestSignal(t, session.done, "nil logger rebind done")
-
-	rebindDone := make(chan struct{})
-	go func() {
-		app.replaceRuntime(config.Config{}, nil, newLogger)
-		app.rebindLogStreams(context.Background(), nil, newLogger)
-		close(rebindDone)
-	}()
-	waitForLogStreamTestSignal(t, rebindDone, "next logger rebind")
-	if got := loggerSubscriberCount(newLogger); got != 1 {
-		t.Fatalf("new logger subscribers after nil rebind recovery: got %d want 1", got)
-	}
-}
-
-func newGUIAppLogStreamTestLogger(t *testing.T) *logging.Logger {
-	t.Helper()
-
-	logger, err := logging.New(config.LoggingConfig{Level: "error"}, "")
-	if err != nil {
-		t.Fatalf("new logger: %v", err)
-	}
-	logger.SetConsoleOutput(io.Discard, io.Discard)
-	t.Cleanup(func() {
-		_ = logger.Close()
-	})
-	return logger
-}
-
-func loggerSubscriberCount(logger *logging.Logger) int {
-	return reflect.ValueOf(logger).Elem().FieldByName("subs").Len()
-}
-
-func waitForLogStreamTestSignal(t *testing.T, ch <-chan struct{}, name string) {
-	t.Helper()
-
-	select {
-	case <-ch:
-	case <-time.After(2 * time.Second):
-		t.Fatalf("timed out waiting for %s", name)
-	}
-}
-
-func assertLogStreamStillRunning(t *testing.T, done <-chan struct{}, name string) {
-	t.Helper()
-
-	select {
-	case <-done:
-		t.Fatalf("%s stopped unexpectedly", name)
-	default:
-	}
-}
-
-func assertLogStreamBlocked(t *testing.T, ch <-chan struct{}, name string) {
-	t.Helper()
-
-	select {
-	case <-ch:
-		t.Fatalf("%s completed unexpectedly", name)
-	case <-time.After(50 * time.Millisecond):
-	}
-}
diff --git a/internal/guiapp/run_options.go b/internal/guiapp/run_options.go
deleted file mode 100644
index beb0c31d..00000000
--- a/internal/guiapp/run_options.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/core"
-	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type runOptions struct {
-	Debug       bool
-	NoSeed      bool
-	RunLogLevel string
-}
-
-func (a *App) buildRunOptions(debug bool, noSeed bool, runLogLevel string) (runOptions, error) {
-	if a == nil {
-		return runOptions{}, errors.New("app not initialized")
-	}
-	if strings.TrimSpace(runLogLevel) == "" {
-		return runOptions{
-			Debug:       debug,
-			NoSeed:      noSeed,
-			RunLogLevel: "",
-		}, nil
-	}
-
-	normalized, err := api.ParseLogLevel(runLogLevel)
-	if err != nil {
-		return runOptions{}, fmt.Errorf("gui: %w", err)
-	}
-
-	return runOptions{
-		Debug:       debug,
-		NoSeed:      noSeed,
-		RunLogLevel: normalized,
-	}, nil
-}
-
-// buildRunCoreFromSnapshot creates a per-run core and logger from the same
-// runtime snapshot used to build upload options.
-func (a *App) buildRunCoreFromSnapshot(rt appRuntimeSnapshot, opts runOptions) (api.Core, *logging.Logger, error) {
-	if a.repo == nil {
-		return nil, nil, errors.New("config repository not initialized")
-	}
-
-	effectiveLogLevel := logging.ResolveEffectiveLevel(rt.cfg.Logging.Level, opts.RunLogLevel, opts.Debug)
-	logger, err := logging.NewWithLevel(rt.cfg.Logging, rt.cfg.MainSettings.DBPath, effectiveLogLevel)
-	if err != nil {
-		return nil, nil, fmt.Errorf("gui: %w", err)
-	}
-
-	coreSvc, err := core.New(api.CoreDependencies{
-		Config: rt.cfg,
-		Logger: logger,
-		Services: api.ServiceSet{
-			Filesystem: filesystem.NewValidator(),
-		},
-		Repository: a.repo,
-	})
-	if err != nil {
-		_ = logger.Close()
-		return nil, nil, fmt.Errorf("gui: %w", err)
-	}
-
-	return coreSvc, logger, nil
-}
-func buildRunUploadOptions(cfg config.Config, opts runOptions) api.UploadOptions {
-	options := buildBaseUploadOptions(cfg)
-	options.Debug = opts.Debug
-	// buildRunUploadOptions keeps runOptions legacy behavior: options.DryRun follows opts.Debug so debug runs stay non-uploading.
-	options.DryRun = opts.Debug
-	options.NoSeed = opts.NoSeed
-	options.RunLogLevel = opts.RunLogLevel
-	return options
-}
-
-func buildBaseUploadOptions(cfg config.Config) api.UploadOptions {
-	return api.UploadOptions{
-		Screens:         cfg.ScreenshotHandling.Screens,
-		SkipAutoTorrent: cfg.Metadata.SkipAutoTorrent,
-		OnlyID:          cfg.Metadata.OnlyID,
-		KeepImages:      cfg.Metadata.KeepImages,
-	}
-}
diff --git a/internal/guiapp/run_options_test.go b/internal/guiapp/run_options_test.go
deleted file mode 100644
index ae05ab7a..00000000
--- a/internal/guiapp/run_options_test.go
+++ /dev/null
@@ -1,1078 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/core"
-	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type closeCounter struct {
-	count      atomic.Int32
-	closeErr   error
-	panicValue any
-}
-
-func (c *closeCounter) Close() error {
-	c.count.Add(1)
-	if c.panicValue != nil {
-		panic(c.panicValue)
-	}
-	return c.closeErr
-}
-
-type closeCounterCore struct {
-	closeCounter
-	exportedMeta      api.PreparedMetadata
-	exportFound       bool
-	exportErr         error
-	expectedExportReq *api.Request
-	importedMeta      api.PreparedMetadata
-	importedReq       api.Request
-	fetchReq          api.Request
-	dupeSummary       api.DupeCheckSummary
-	dupeCalls         atomic.Int32
-	dvdMenuCapture    func(context.Context, api.Request) (api.DVDMenuCaptureResult, error)
-	dvdMenuCalls      atomic.Int32
-	uploads           []uploadPreparedResponse
-	uploadCalls       int
-}
-
-type uploadPreparedResponse struct {
-	result       api.Result
-	err          error
-	beforeReturn func()
-	panicValue   any
-}
-
-func (c *closeCounterCore) RunUpload(context.Context, api.Request) (api.Result, error) {
-	return api.Result{}, nil
-}
-
-func (c *closeCounterCore) RunUploadPrepared(context.Context, api.Request) (api.Result, error) {
-	if c.uploadCalls < len(c.uploads) {
-		response := c.uploads[c.uploadCalls]
-		c.uploadCalls++
-		if response.beforeReturn != nil {
-			response.beforeReturn()
-		}
-		if response.panicValue != nil {
-			panic(response.panicValue)
-		}
-		return response.result, response.err
-	}
-	return api.Result{}, nil
-}
-
-func (c *closeCounterCore) FetchMetadataPreview(_ context.Context, req api.Request) (api.MetadataPreview, error) {
-	c.fetchReq = req
-	return api.MetadataPreview{}, nil
-}
-
-func (c *closeCounterCore) FetchDescriptionBuilderPreview(context.Context, api.Request) (api.DescriptionBuilderPreview, error) {
-	return api.DescriptionBuilderPreview{}, nil
-}
-
-func (c *closeCounterCore) FetchPreparationPreview(context.Context, api.Request) (api.PreparationPreview, error) {
-	return api.PreparationPreview{}, nil
-}
-
-func (c *closeCounterCore) FetchTrackerDryRunPreview(context.Context, api.Request) (api.TrackerDryRunPreview, error) {
-	return api.TrackerDryRunPreview{}, nil
-}
-
-func (c *closeCounterCore) CheckDupes(context.Context, api.Request) (api.DupeCheckSummary, error) {
-	c.dupeCalls.Add(1)
-	return c.dupeSummary, nil
-}
-
-func (c *closeCounterCore) BuildUploadReview(context.Context, api.Request) (api.UploadReview, error) {
-	return api.UploadReview{}, nil
-}
-
-func (c *closeCounterCore) FetchScreenshotPlan(context.Context, api.Request) (api.ScreenshotPlan, error) {
-	return api.ScreenshotPlan{}, nil
-}
-
-func (c *closeCounterCore) GenerateScreenshots(context.Context, api.Request, []api.ScreenshotSelection, api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	return api.ScreenshotResult{}, nil
-}
-
-func (c *closeCounterCore) PreviewScreenshotFrame(context.Context, api.Request, float64) (api.ScreenshotPreview, error) {
-	return api.ScreenshotPreview{}, nil
-}
-
-func (c *closeCounterCore) DeleteScreenshot(context.Context, api.Request, string) error {
-	return nil
-}
-
-func (c *closeCounterCore) DeleteTrackerImageURL(context.Context, api.Request, string) error {
-	return nil
-}
-
-func (c *closeCounterCore) SaveFinalScreenshotSelections(context.Context, api.Request, []api.ScreenshotImage) error {
-	return nil
-}
-
-func (c *closeCounterCore) ImportMenuImages(context.Context, api.Request, []string) error {
-	return nil
-}
-
-func (c *closeCounterCore) CaptureDVDMenus(ctx context.Context, req api.Request) (api.DVDMenuCaptureResult, error) {
-	c.dvdMenuCalls.Add(1)
-	if c.dvdMenuCapture != nil {
-		return c.dvdMenuCapture(ctx, req)
-	}
-	return api.DVDMenuCaptureResult{}, nil
-}
-
-func (c *closeCounterCore) ListDVDMenuScreenshots(context.Context, api.Request) ([]api.ScreenshotImage, error) {
-	return nil, nil
-}
-
-func (c *closeCounterCore) DeleteDVDMenuScreenshot(context.Context, api.Request, string) error {
-	return nil
-}
-
-func (c *closeCounterCore) ListUploadCandidates(context.Context, api.Request) ([]api.ScreenshotImage, error) {
-	return nil, nil
-}
-
-func (c *closeCounterCore) ListUploadedImages(context.Context, api.Request) ([]api.UploadedImageLink, error) {
-	return nil, nil
-}
-
-func (c *closeCounterCore) UploadImages(_ context.Context, _ api.Request, _ string, _ []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	return api.UploadImagesResult{}, nil
-}
-
-func (c *closeCounterCore) DeleteUploadedImage(context.Context, api.Request, string, string) error {
-	return nil
-}
-
-func (c *closeCounterCore) DiscoverPlaylists(context.Context, string) ([]api.PlaylistInfo, error) {
-	return nil, nil
-}
-
-func (c *closeCounterCore) SavePlaylistSelection(context.Context, string, []string, bool) error {
-	return nil
-}
-
-func (c *closeCounterCore) LoadPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
-	return api.PlaylistSelection{}, nil
-}
-
-func (c *closeCounterCore) ListHistory(context.Context) ([]api.HistoryEntry, error) {
-	return nil, nil
-}
-
-func (c *closeCounterCore) GetHistoryOverview(context.Context, string) (api.HistoryOverview, error) {
-	return api.HistoryOverview{}, nil
-}
-
-func (c *closeCounterCore) DeleteHistoryRelease(context.Context, string) error {
-	return nil
-}
-
-func (c *closeCounterCore) DeleteAllHistoryReleases(context.Context) (int, error) {
-	return 0, nil
-}
-
-func (c *closeCounterCore) RenderDescription(context.Context, string) (string, error) {
-	return "", nil
-}
-
-func (c *closeCounterCore) FetchDescriptionBuilderGroupPreview(context.Context, api.Request) (api.DescriptionBuilderGroup, error) {
-	return api.DescriptionBuilderGroup{}, nil
-}
-
-func (c *closeCounterCore) SaveDescriptionOverride(context.Context, api.Request, string) (api.DescriptionBuilderGroup, error) {
-	return api.DescriptionBuilderGroup{}, nil
-}
-
-func (c *closeCounterCore) ExportGUICachedPreparedMeta(_ context.Context, req api.Request) (api.PreparedMetadata, bool, error) {
-	if err := assertPreparedMetaExportRequest(req, c.expectedExportReq); err != nil {
-		return api.PreparedMetadata{}, false, err
-	}
-	return c.exportedMeta, c.exportFound, c.exportErr
-}
-
-func (c *closeCounterCore) ImportPreparedMetadataForGUI(_ context.Context, req api.Request, meta api.PreparedMetadata) error {
-	c.importedReq = req
-	c.importedMeta = meta
-	return nil
-}
-
-func TestBuildRunOptionsDefaults(t *testing.T) {
-	t.Parallel()
-
-	app := &App{cfg: config.Config{Logging: config.LoggingConfig{Level: "info"}}}
-	opts, err := app.buildRunOptions(true, false, "")
-	if err != nil {
-		t.Fatalf("build run options: %v", err)
-	}
-	if !opts.Debug {
-		t.Fatalf("expected debug enabled, got %#v", opts)
-	}
-	if opts.RunLogLevel != "" {
-		t.Fatalf("expected empty explicit run log level, got %q", opts.RunLogLevel)
-	}
-}
-
-func TestBuildRunOptionsEmptyLogLevelSkipsNormalization(t *testing.T) {
-	t.Parallel()
-
-	app := &App{}
-	opts, err := app.buildRunOptions(false, false, "   ")
-	if err != nil {
-		t.Fatalf("build run options: %v", err)
-	}
-	if opts.RunLogLevel != "" {
-		t.Fatalf("expected empty run log level for blank input, got %q", opts.RunLogLevel)
-	}
-}
-
-func TestBuildRunOptionsRejectsInvalidLogLevel(t *testing.T) {
-	t.Parallel()
-
-	app := &App{}
-	if _, err := app.buildRunOptions(false, false, "verbose"); err == nil {
-		t.Fatal("expected invalid log level to fail")
-	}
-}
-
-func TestBuildRunOptionsPropagatesNoSeed(t *testing.T) {
-	t.Parallel()
-
-	app := &App{}
-	opts, err := app.buildRunOptions(false, true, "")
-	if err != nil {
-		t.Fatalf("build run options: %v", err)
-	}
-	if !opts.NoSeed {
-		t.Fatalf("expected no-seed enabled, got %#v", opts)
-	}
-}
-
-func TestBuildRunUploadOptionsPropagatesSkipAutoTorrent(t *testing.T) {
-	t.Parallel()
-
-	options := buildRunUploadOptions(config.Config{
-		Metadata: config.MetadataConfig{SkipAutoTorrent: true},
-	}, runOptions{})
-	if !options.SkipAutoTorrent {
-		t.Fatalf("expected skip_auto_torrent upload option, got %#v", options)
-	}
-}
-
-func TestCoreCloseDoesNotCloseInjectedRepository(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "guiapp.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	defer func() {
-		_ = repo.Close()
-	}()
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	coreSvc, err := core.New(api.CoreDependencies{
-		Config: config.Config{
-			MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		Logger: api.NopLogger{},
-		Services: api.ServiceSet{
-			Filesystem: filesystem.NewValidator(),
-		},
-		Repository: repo,
-	})
-	if err != nil {
-		t.Fatalf("new core: %v", err)
-	}
-	if err := coreSvc.Close(); err != nil {
-		t.Fatalf("close core: %v", err)
-	}
-
-	if err := repo.Save(context.Background(), db.FileMetadata{
-		Path: "C:\\test\\movie.mkv",
-	}); err != nil {
-		t.Fatalf("expected repo to remain usable after per-run core close: %v", err)
-	}
-}
-
-func TestTrackerUploadJobCloseResourcesIsIdempotent(t *testing.T) {
-	t.Parallel()
-
-	coreCloser := &closeCounterCore{}
-	loggerCloser := &closeCounter{}
-	job := &trackerUploadJob{
-		core:   coreCloser,
-		logger: loggerCloser,
-	}
-
-	_ = job.closeResources()
-	_ = job.closeResources()
-
-	if got := coreCloser.count.Load(); got != 1 {
-		t.Fatalf("expected core close once, got %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 1 {
-		t.Fatalf("expected logger close once, got %d", got)
-	}
-}
-
-func TestCloseTrackerUploadResourceReturnsCloseError(t *testing.T) {
-	t.Parallel()
-
-	wantErr := errors.New("close failed")
-
-	err := closeTrackerUploadResource("logger", &closeCounter{closeErr: wantErr})
-
-	if !errors.Is(err, wantErr) {
-		t.Fatalf("expected close error, got %v", err)
-	}
-}
-
-func TestCloseTrackerUploadResourceReturnsPanicError(t *testing.T) {
-	t.Parallel()
-
-	closeErr := errors.New("close failed")
-
-	err := closeTrackerUploadResource("logger", &closeCounter{closeErr: closeErr, panicValue: "close panic"})
-
-	if err == nil {
-		t.Fatal("expected panic error")
-	}
-	if !strings.Contains(err.Error(), "logger close panicked") {
-		t.Fatalf("expected panic context, got %v", err)
-	}
-	if errors.Is(err, closeErr) {
-		t.Fatalf("expected panic error to take precedence over close error, got %v", err)
-	}
-}
-
-func TestTrackerUploadRetryRequestUsesStoredUploadOptions(t *testing.T) {
-	t.Parallel()
-
-	job := &trackerUploadJob{
-		sourcePath:     `C:\Media\Movie.mkv`,
-		uploadOptions:  api.UploadOptions{Screens: 1, SkipAutoTorrent: true},
-		runOptions:     runOptions{Debug: true, NoSeed: true, RunLogLevel: "debug"},
-		failedTrackers: []string{"BLU"},
-		ignoreDupesFor: []string{"AITHER"},
-	}
-
-	retry, err := trackerUploadRetryRequestFromJob(job)
-	if err != nil {
-		t.Fatalf("retry request: %v", err)
-	}
-
-	job.uploadOptions.Screens = 9
-	job.failedTrackers[0] = "MUTATED"
-	job.ignoreDupesFor[0] = "MUTATED"
-
-	if retry.uploadOptions.Screens != 1 || !retry.uploadOptions.SkipAutoTorrent {
-		t.Fatalf("expected stored upload options snapshot, got %#v", retry.uploadOptions)
-	}
-	if len(retry.failedTrackers) != 1 || retry.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed trackers snapshot, got %#v", retry.failedTrackers)
-	}
-	if len(retry.ignoreDupesFor) != 1 || retry.ignoreDupesFor[0] != "AITHER" {
-		t.Fatalf("expected ignore dupes snapshot, got %#v", retry.ignoreDupesFor)
-	}
-	if !retry.runOptions.Debug || !retry.runOptions.NoSeed || retry.runOptions.RunLogLevel != "debug" {
-		t.Fatalf("expected run options snapshot, got %#v", retry.runOptions)
-	}
-}
-
-func TestCancelTrackerUploadDefersResourceCloseUntilWorkerExit(t *testing.T) {
-	coreCloser := &closeCounterCore{}
-	loggerCloser := &closeCounter{}
-	job := &trackerUploadJob{
-		id:     "job-1",
-		core:   coreCloser,
-		logger: loggerCloser,
-		cancel: func() {},
-	}
-	app := &App{
-		uploads: map[string]*trackerUploadJob{job.id: job},
-	}
-
-	if err := app.CancelTrackerUpload(job.id); err != nil {
-		t.Fatalf("cancel upload: %v", err)
-	}
-
-	if got := coreCloser.count.Load(); got != 0 {
-		t.Fatalf("expected cancel not to close core before worker exit, got %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 0 {
-		t.Fatalf("expected cancel not to close logger before worker exit, got %d", got)
-	}
-
-	_ = job.closeResources()
-}
-
-func TestStopAllUploadJobsWaitsForWorkersBeforeClosingResources(t *testing.T) {
-	coreCloser := &closeCounterCore{}
-	loggerCloser := &closeCounter{}
-	released := make(chan struct{})
-	cancelCalled := make(chan struct{})
-	workerFinished := make(chan struct{})
-	job := &trackerUploadJob{
-		id:     "job-1",
-		core:   coreCloser,
-		logger: loggerCloser,
-	}
-	app := &App{
-		uploads: map[string]*trackerUploadJob{job.id: job},
-	}
-	app.uploadWG.Add(1)
-	job.cancel = func() {
-		close(cancelCalled)
-		go func() {
-			<-released
-			app.uploadWG.Done()
-			close(workerFinished)
-		}()
-	}
-
-	done := make(chan struct{})
-	go func() {
-		app.stopAllUploadJobs()
-		close(done)
-	}()
-
-	select {
-	case <-cancelCalled:
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("expected stopAllUploadJobs to cancel active upload")
-	}
-
-	select {
-	case <-done:
-		t.Fatal("expected stopAllUploadJobs to wait for active worker")
-	case <-time.After(50 * time.Millisecond):
-	}
-	if got := coreCloser.count.Load(); got != 0 {
-		t.Fatalf("expected core to remain open while worker is active, got close count %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 0 {
-		t.Fatalf("expected logger to remain open while worker is active, got close count %d", got)
-	}
-
-	close(released)
-
-	select {
-	case <-done:
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("expected stopAllUploadJobs to return after worker finishes")
-	}
-	<-workerFinished
-	if got := coreCloser.count.Load(); got != 1 {
-		t.Fatalf("expected core close after worker exit, got %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 1 {
-		t.Fatalf("expected logger close after worker exit, got %d", got)
-	}
-}
-
-func TestStopAllUploadJobsWaitsForPublishedPreStartUpload(t *testing.T) {
-	coreCloser := &closeCounterCore{}
-	loggerCloser := &closeCounter{}
-	cancelCalled := make(chan struct{})
-	job := &trackerUploadJob{
-		id:     "job-1",
-		core:   coreCloser,
-		logger: loggerCloser,
-		cancel: func() {
-			close(cancelCalled)
-		},
-	}
-	app := &App{
-		uploads: map[string]*trackerUploadJob{},
-	}
-
-	app.publishTrackerUploadJob(job)
-	released := atomic.Bool{}
-	t.Cleanup(func() {
-		if released.CompareAndSwap(false, true) {
-			app.uploadWG.Done()
-		}
-	})
-
-	done := make(chan struct{})
-	go func() {
-		app.stopAllUploadJobs()
-		close(done)
-	}()
-
-	select {
-	case <-cancelCalled:
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("expected stopAllUploadJobs to cancel published upload")
-	}
-
-	select {
-	case <-done:
-		t.Fatal("expected stopAllUploadJobs to wait for pre-start upload enrollment")
-	case <-time.After(50 * time.Millisecond):
-	}
-	if got := coreCloser.count.Load(); got != 0 {
-		t.Fatalf("expected core to remain open before pre-start upload is released, got close count %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 0 {
-		t.Fatalf("expected logger to remain open before pre-start upload is released, got close count %d", got)
-	}
-
-	if released.CompareAndSwap(false, true) {
-		app.uploadWG.Done()
-	}
-
-	select {
-	case <-done:
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("expected stopAllUploadJobs to return after pre-start upload release")
-	}
-	if got := coreCloser.count.Load(); got != 1 {
-		t.Fatalf("expected core close after pre-start release, got %d", got)
-	}
-	if got := loggerCloser.count.Load(); got != 1 {
-		t.Fatalf("expected logger close after pre-start release, got %d", got)
-	}
-}
-
-func TestRunTrackerUploadJobCountsPartialErrorAndContinues(t *testing.T) {
-	app := &App{}
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: 1},
-			err:    errors.New("tracker failed after upload"),
-		},
-		{
-			result: api.Result{UploadedCount: 2},
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU", "AITHER"})
-
-	app.runTrackerUploadJob(context.Background(), nil, job)
-
-	if got := job.uploadedCount; got != 3 {
-		t.Fatalf("expected total uploaded count 3, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 1 {
-		t.Fatalf("expected failed tracker partial count 1, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "failed" {
-		t.Fatalf("expected partial error tracker to remain failed, got %q", got)
-	}
-	if got := job.states["AITHER"].UploadedCount; got != 2 {
-		t.Fatalf("expected success tracker count 2, got %d", got)
-	}
-	if got := job.status; got != "completed_with_errors" {
-		t.Fatalf("expected completed_with_errors status, got %q", got)
-	}
-	if len(job.failedTrackers) != 1 || job.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed tracker BLU, got %#v", job.failedTrackers)
-	}
-}
-
-func TestRunDupeCheckJobSplitsGroupedPathedResultsIntoTrackerStates(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Movie.mkv`,
-		Results: []api.DupeCheckResult{
-			{
-				Tracker:  "AITHER, BLU",
-				HasDupes: true,
-				Status:   "completed",
-				Notes:    []string{"pathed torrent match found; skipping dupe search"},
-			},
-			{Tracker: "RF", Status: "completed"},
-		},
-	}}
-	job := newDupeCheckJobTestJob(coreSvc.dupeSummary.SourcePath, []string{"AITHER", "BLU", "RF"})
-	job.core = coreSvc
-	app := &App{}
-
-	app.runDupeCheckJob(context.Background(), nil, job)
-
-	if got := job.completedCount; got != 3 {
-		t.Fatalf("expected all trackers completed, got %d", got)
-	}
-	if _, ok := job.states["AITHER, BLU"]; ok {
-		t.Fatal("did not expect grouped tracker state")
-	}
-	for _, tracker := range []string{"AITHER", "BLU"} {
-		state := job.states[tracker]
-		if got := state.Status; got != "completed" {
-			t.Fatalf("expected %s completed, got %q", tracker, got)
-		}
-		if got := state.Result.Tracker; got != tracker {
-			t.Fatalf("expected %s result tracker, got %q", tracker, got)
-		}
-	}
-}
-
-func TestApplyDupeProgressCountsNewTrackersWithoutInflatingExplicitTotal(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		startTotal  int
-		updateTotal int
-		wantTotal   int
-	}{
-		{name: "explicit total", startTotal: 2, updateTotal: 2, wantTotal: 2},
-		{name: "total omitted", startTotal: 1, wantTotal: 2},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			job := newDupeCheckJobTestJob(`C:\Media\Example.Release.2026.1080p-GRP.mkv`, []string{"AITHER"})
-			job.totalCount = tt.startTotal
-
-			(&App{}).applyDupeProgress(context.Background(), job, api.DupeProgressUpdate{
-				Tracker: "BLU",
-				Status:  "running",
-				Total:   tt.updateTotal,
-			})
-
-			if job.totalCount != tt.wantTotal {
-				t.Fatalf("expected total count %d, got %d", tt.wantTotal, job.totalCount)
-			}
-		})
-	}
-}
-
-func TestRunDupeCheckJobUsesJobCoreSnapshot(t *testing.T) {
-	t.Parallel()
-
-	jobCore := &closeCounterCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Movie.mkv`,
-		Results:    []api.DupeCheckResult{{Tracker: "AITHER", Status: "completed"}},
-	}}
-	currentCore := &closeCounterCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Other.mkv`,
-		Results:    []api.DupeCheckResult{{Tracker: "AITHER", Status: "failed"}},
-	}}
-	job := newDupeCheckJobTestJob(jobCore.dupeSummary.SourcePath, []string{"AITHER"})
-	job.core = jobCore
-	job.uploadOptions = api.UploadOptions{Screens: 1}
-	app := &App{core: currentCore}
-
-	app.runDupeCheckJob(context.Background(), nil, job)
-
-	if got := jobCore.dupeCalls.Load(); got != 1 {
-		t.Fatalf("expected job-owned core to run once, got %d", got)
-	}
-	if got := currentCore.dupeCalls.Load(); got != 0 {
-		t.Fatalf("expected current runtime core not to run, got %d", got)
-	}
-	if got := job.states["AITHER"].Status; got != "completed" {
-		t.Fatalf("expected result from job-owned core, got %q", got)
-	}
-}
-
-func TestStartDupeCheckRequiresMetadataPreviewCache(t *testing.T) {
-	t.Parallel()
-
-	coreSvc := &closeCounterCore{}
-	app := &App{
-		core: coreSvc,
-		cfg:  config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1}},
-	}
-
-	_, err := app.StartDupeCheck(`C:\Media\Example.mkv`, api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, []string{"AITHER"})
-	if err == nil {
-		t.Fatal("expected missing metadata preview cache to block dupe check start")
-	}
-	if !strings.Contains(err.Error(), "dupe check requires metadata preview") {
-		t.Fatalf("expected metadata preview error, got %v", err)
-	}
-	if len(app.dupes) != 0 {
-		t.Fatalf("expected no durable dupe job after cache miss, got %d", len(app.dupes))
-	}
-}
-
-func TestStartDupeCheckUsesMetadataPreviewCache(t *testing.T) {
-	t.Parallel()
-
-	app, sourcePath := newDupeCheckStartTestApp(t)
-	tmdbID := 1234567
-	releaseType := "movie"
-	overrides := api.ExternalIDOverrides{TMDBID: &tmdbID}
-	nameOverrides := api.ReleaseNameOverrides{Type: &releaseType}
-	coreSvc := &closeCounterCore{
-		exportFound:  true,
-		exportedMeta: api.PreparedMetadata{SourcePath: sourcePath},
-		expectedExportReq: &api.Request{
-			Paths:                []string{sourcePath},
-			Mode:                 api.ModeGUI,
-			Trackers:             []string{"AITHER"},
-			ExternalIDOverrides:  overrides,
-			ReleaseNameOverrides: nameOverrides,
-		},
-	}
-	app.core = coreSvc
-
-	jobID, err := app.StartDupeCheck(sourcePath, overrides, nameOverrides, []string{"AITHER"})
-	if err != nil {
-		t.Fatalf("start dupe check: %v", err)
-	}
-	if strings.TrimSpace(jobID) == "" {
-		t.Fatal("expected job id")
-	}
-	if len(app.dupes) != 1 {
-		t.Fatalf("expected durable dupe job, got %d", len(app.dupes))
-	}
-}
-
-func TestStartDupeCheckFailsOnMetadataPreviewCacheRequestMismatch(t *testing.T) {
-	t.Parallel()
-
-	for _, tt := range []struct {
-		name        string
-		expected    func(string) api.Request
-		overrides   api.ExternalIDOverrides
-		wantMessage string
-	}{
-		{
-			name: "path",
-			expected: func(sourcePath string) api.Request {
-				return api.Request{Paths: []string{sourcePath + ".other"}, Mode: api.ModeGUI, Trackers: []string{"AITHER"}}
-			},
-			wantMessage: "metadata preview cache request paths",
-		},
-		{
-			name: "tracker",
-			expected: func(sourcePath string) api.Request {
-				return api.Request{Paths: []string{sourcePath}, Mode: api.ModeGUI, Trackers: []string{"BLU"}}
-			},
-			wantMessage: "metadata preview cache request trackers",
-		},
-		{
-			name: "external id override",
-			expected: func(sourcePath string) api.Request {
-				tmdbID := 7654321
-				return api.Request{
-					Paths:               []string{sourcePath},
-					Mode:                api.ModeGUI,
-					Trackers:            []string{"AITHER"},
-					ExternalIDOverrides: api.ExternalIDOverrides{TMDBID: &tmdbID},
-				}
-			},
-			overrides: func() api.ExternalIDOverrides {
-				tmdbID := 1234567
-				return api.ExternalIDOverrides{TMDBID: &tmdbID}
-			}(),
-			wantMessage: "metadata preview cache request external overrides",
-		},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			app, sourcePath := newDupeCheckStartTestApp(t)
-			expected := tt.expected(sourcePath)
-			coreSvc := &closeCounterCore{
-				exportFound:       true,
-				exportedMeta:      api.PreparedMetadata{SourcePath: sourcePath},
-				expectedExportReq: &expected,
-			}
-			app.core = coreSvc
-
-			_, err := app.StartDupeCheck(sourcePath, tt.overrides, api.ReleaseNameOverrides{}, []string{"AITHER"})
-			if err == nil {
-				t.Fatal("expected metadata preview cache request mismatch to fail")
-			}
-			if !strings.Contains(err.Error(), tt.wantMessage) {
-				t.Fatalf("expected mismatch error %q, got %v", tt.wantMessage, err)
-			}
-			if len(app.dupes) != 0 {
-				t.Fatalf("expected no durable dupe job after cache request mismatch, got %d", len(app.dupes))
-			}
-		})
-	}
-}
-
-func TestRunTrackerUploadJobIgnoresNegativeUploadedCount(t *testing.T) {
-	app := &App{}
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: -1},
-			err:    errors.New("tracker failed after invalid count"),
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	app.runTrackerUploadJob(context.Background(), nil, job)
-
-	if got := job.uploadedCount; got != 0 {
-		t.Fatalf("expected negative count to leave total unchanged, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 0 {
-		t.Fatalf("expected negative count to leave tracker count unchanged, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "failed" {
-		t.Fatalf("expected tracker error handling to remain failed, got %q", got)
-	}
-	if len(job.failedTrackers) != 1 || job.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed tracker BLU, got %#v", job.failedTrackers)
-	}
-}
-
-func TestRunTrackerUploadJobCountsCanceledPartialWithoutFailedTracker(t *testing.T) {
-	app := &App{}
-	ctx, cancel := context.WithCancel(context.Background())
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			result:       api.Result{UploadedCount: 1},
-			err:          context.Canceled,
-			beforeReturn: cancel,
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	app.runTrackerUploadJob(ctx, nil, job)
-
-	if got := job.uploadedCount; got != 1 {
-		t.Fatalf("expected canceled partial count 1, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 1 {
-		t.Fatalf("expected tracker partial count 1, got %d", got)
-	}
-	if got := job.status; got != "canceled" {
-		t.Fatalf("expected canceled job status, got %q", got)
-	}
-	if len(job.failedTrackers) != 0 {
-		t.Fatalf("expected no failed trackers after cancellation, got %#v", job.failedTrackers)
-	}
-}
-
-func TestRunTrackerUploadJobRecoversRunUploadPreparedPanic(t *testing.T) {
-	app := &App{}
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			panicValue: "https://tracker.invalid/announce?api_token=secret-value",
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	app.runTrackerUploadJob(context.Background(), context.Background(), job)
-
-	if got := job.status; got != "failed" {
-		t.Fatalf("expected failed status after upload panic, got %q", got)
-	}
-	if !strings.Contains(job.errorMessage, "upload worker panicked") {
-		t.Fatalf("expected panic error message, got %q", job.errorMessage)
-	}
-	if strings.Contains(job.errorMessage, "secret-value") {
-		t.Fatalf("expected panic error message to redact secrets, got %q", job.errorMessage)
-	}
-	if got := coreSvc.count.Load(); got != 1 {
-		t.Fatalf("expected core close after upload panic, got %d", got)
-	}
-	if job.cancel != nil {
-		t.Fatal("expected upload panic to clear cancel func")
-	}
-}
-
-func TestRunTrackerUploadJobContainsCleanupPanic(t *testing.T) {
-	app := &App{}
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: 1},
-		},
-	}}
-	coreSvc.panicValue = "https://tracker.invalid/announce?api_token=secret-value"
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	app.runTrackerUploadJob(context.Background(), context.Background(), job)
-
-	if got := job.status; got != "failed" {
-		t.Fatalf("expected failed status after cleanup panic, got %q", got)
-	}
-	if !strings.Contains(job.errorMessage, "core close panicked") {
-		t.Fatalf("expected cleanup panic message, got %q", job.errorMessage)
-	}
-	if strings.Contains(job.errorMessage, "secret-value") {
-		t.Fatalf("expected cleanup panic message to redact secrets, got %q", job.errorMessage)
-	}
-	if got := coreSvc.count.Load(); got != 1 {
-		t.Fatalf("expected core close attempt once, got %d", got)
-	}
-}
-
-func TestRunTrackerUploadJobSanitizesCleanupError(t *testing.T) {
-	app := &App{}
-	coreSvc := &closeCounterCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: 1},
-		},
-	}}
-	coreSvc.closeErr = errors.New(`request failed for C:\path\to\Example.Release.2026.1080p-GRP: Get "https://tracker.invalid/api/torrents?api_token=secret-value"`)
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	app.runTrackerUploadJob(context.Background(), context.Background(), job)
-
-	snapshot := buildTrackerUploadSnapshot(job)
-	if snapshot.Status != "failed" {
-		t.Fatalf("expected failed status after cleanup error, got %q", snapshot.Status)
-	}
-	if strings.Contains(snapshot.Error, "secret-value") {
-		t.Fatal("expected cleanup error to redact secrets")
-	}
-	if strings.Contains(snapshot.Error, "Example.Release.2026.1080p-GRP") {
-		t.Fatal("expected cleanup error to redact local path details")
-	}
-}
-
-func newTrackerUploadJobTestJob(coreSvc api.Core, trackers []string) *trackerUploadJob {
-	job := &trackerUploadJob{
-		id:         "job",
-		sourcePath: `C:\Media\Movie.mkv`,
-		core:       coreSvc,
-		trackers:   trackers,
-		states:     make(map[string]TrackerUploadTrackerState, len(trackers)),
-		status:     "queued",
-		startedAt:  time.Now().UTC(),
-	}
-	for _, tracker := range trackers {
-		job.states[tracker] = TrackerUploadTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-	}
-	return job
-}
-
-func newDupeCheckJobTestJob(sourcePath string, trackers []string) *dupeCheckJob {
-	job := &dupeCheckJob{
-		id:         "dupe-job",
-		sourcePath: sourcePath,
-		trackers:   trackers,
-		states:     make(map[string]DupeCheckTrackerState, len(trackers)),
-		totalCount: len(trackers),
-		status:     "queued",
-		startedAt:  time.Now().UTC(),
-	}
-	for _, tracker := range trackers {
-		job.states[tracker] = DupeCheckTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-	}
-	return job
-}
-
-func newDupeCheckStartTestApp(t *testing.T) (*App, string) {
-	t.Helper()
-
-	tempDir := t.TempDir()
-	sourcePath := filepath.Join(tempDir, "Example.Release.2026.1080p-GRP.mkv")
-	if err := os.WriteFile(sourcePath, []byte("example"), 0o600); err != nil {
-		t.Fatalf("write source fixture: %v", err)
-	}
-	repoPath := filepath.Join(tempDir, "upbrr.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	if err := repo.Migrate(); err != nil {
-		_ = repo.Close()
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	app := &App{
-		cfg: config.Config{
-			MainSettings:       config.MainSettingsConfig{DBPath: repoPath, TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		repo:  repo,
-		dupes: make(map[string]*dupeCheckJob),
-	}
-	t.Cleanup(func() {
-		app.stopAllDupeJobs()
-		_ = repo.Close()
-	})
-	return app, sourcePath
-}
-
-func assertPreparedMetaExportRequest(req api.Request, expected *api.Request) error {
-	if expected == nil {
-		return nil
-	}
-	if !reflect.DeepEqual(req.Paths, expected.Paths) {
-		return fmt.Errorf("metadata preview cache request paths: got %#v want %#v", req.Paths, expected.Paths)
-	}
-	if req.Mode != expected.Mode {
-		return fmt.Errorf("metadata preview cache request mode: got %q want %q", req.Mode, expected.Mode)
-	}
-	if !reflect.DeepEqual(req.Trackers, expected.Trackers) {
-		return fmt.Errorf("metadata preview cache request trackers: got %#v want %#v", req.Trackers, expected.Trackers)
-	}
-	if !reflect.DeepEqual(req.ExternalIDOverrides, expected.ExternalIDOverrides) {
-		return fmt.Errorf("metadata preview cache request external overrides: got %#v want %#v", req.ExternalIDOverrides, expected.ExternalIDOverrides)
-	}
-	if !reflect.DeepEqual(req.ReleaseNameOverrides, expected.ReleaseNameOverrides) {
-		return fmt.Errorf("metadata preview cache request name overrides: got %#v want %#v", req.ReleaseNameOverrides, expected.ReleaseNameOverrides)
-	}
-	return nil
-}
-
-func TestSeedRunCorePreparedMetaCopiesPreparedMetadata(t *testing.T) {
-	t.Parallel()
-
-	source := &closeCounterCore{
-		exportFound:  true,
-		exportedMeta: api.PreparedMetadata{SourcePath: "C:\\releases\\movie.mkv"},
-	}
-	target := &closeCounterCore{}
-	req := api.Request{
-		Paths: []string{"C:\\releases\\movie.mkv"},
-		Mode:  api.ModeGUI,
-	}
-
-	if err := guishared.SeedRunCorePreparedMeta(context.Background(), source, target, req); err != nil {
-		t.Fatalf("seed run core prepared meta: %v", err)
-	}
-	if target.importedMeta.SourcePath != "C:\\releases\\movie.mkv" {
-		t.Fatalf("expected imported source path, got %q", target.importedMeta.SourcePath)
-	}
-	if len(target.importedReq.Paths) != 1 || target.importedReq.Paths[0] != "C:\\releases\\movie.mkv" {
-		t.Fatalf("expected import request paths to be preserved, got %#v", target.importedReq.Paths)
-	}
-}
-
-func TestSeedRunCorePreparedMetaSkipsWhenNoCacheFound(t *testing.T) {
-	t.Parallel()
-
-	source := &closeCounterCore{}
-	target := &closeCounterCore{}
-
-	if err := guishared.SeedRunCorePreparedMeta(context.Background(), source, target, api.Request{
-		Paths: []string{"C:\\releases\\movie.mkv"},
-		Mode:  api.ModeGUI,
-	}); err != nil {
-		t.Fatalf("seed run core prepared meta: %v", err)
-	}
-	if target.importedMeta.SourcePath != "" {
-		t.Fatalf("expected no metadata import when cache missing, got %#v", target.importedMeta)
-	}
-}
diff --git a/internal/guiapp/runner.go b/internal/guiapp/runner.go
deleted file mode 100644
index 840714c3..00000000
--- a/internal/guiapp/runner.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"fmt"
-	"io/fs"
-
-	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
-	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
-)
-
-// RunOptions configures Wails GUI startup.
-type RunOptions struct {
-	// Assets overrides the embedded or discovered frontend asset filesystem.
-	Assets fs.FS
-	// ConfigPath is passed to config bootstrap as the optional config file path.
-	ConfigPath string
-	// ConfigProvided reports whether ConfigPath came from an explicit user flag.
-	ConfigProvided bool
-}
-
-// Run starts the Wails GUI with a background context.
-func Run(opts RunOptions) error {
-	return RunWithContext(context.Background(), opts)
-}
-
-// RunWithContext starts the Wails GUI after resolving assets and creating the
-// bound app with ctx.
-func RunWithContext(ctx context.Context, opts RunOptions) error {
-	assets, err := resolveAssets(opts.Assets)
-	if err != nil {
-		return err
-	}
-
-	app, err := NewAppWithContext(ctx, opts.ConfigPath, opts.ConfigProvided)
-	if err != nil {
-		return err
-	}
-
-	if err := wails.Run(&options.App{
-		Title:     "upbrr",
-		Width:     1200,
-		Height:    820,
-		MinWidth:  900,
-		MinHeight: 700,
-		AssetServer: &assetserver.Options{
-			Assets: assets,
-		},
-		OnStartup:  app.startup,
-		OnShutdown: app.shutdown,
-		DragAndDrop: &options.DragAndDrop{
-			EnableFileDrop: true,
-		},
-		Bind: []any{
-			app,
-		},
-	}); err != nil {
-		return fmt.Errorf("gui: run: %w", err)
-	}
-
-	return nil
-}
diff --git a/internal/guiapp/runtime_context.go b/internal/guiapp/runtime_context.go
deleted file mode 100644
index ffc932df..00000000
--- a/internal/guiapp/runtime_context.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"sync/atomic"
-)
-
-type appRuntimeContext struct {
-	value atomic.Value
-}
-
-type runtimeContextValue struct {
-	ctx context.Context
-}
-
-func newAppRuntimeContext(ctx context.Context) *appRuntimeContext {
-	store := &appRuntimeContext{}
-	store.Store(ctx)
-	return store
-}
-
-func (s *appRuntimeContext) Store(ctx context.Context) {
-	if s == nil || ctx == nil {
-		return
-	}
-	s.value.Store(runtimeContextValue{ctx: ctx})
-}
-
-func (s *appRuntimeContext) Load() context.Context {
-	if s == nil {
-		return nil
-	}
-	value, _ := s.value.Load().(runtimeContextValue)
-	return value.ctx
-}
-
-func (a *App) runtimeContext() context.Context {
-	if a == nil {
-		return context.Background()
-	}
-	if ctx := a.runtimeCtx.Load(); ctx != nil {
-		return ctx
-	}
-	return context.Background()
-}
-
-func (a *App) readyRuntimeContext() (context.Context, error) {
-	if a == nil {
-		return nil, errors.New("app not initialized")
-	}
-	ctx := a.runtimeCtx.Load()
-	if ctx == nil {
-		return nil, errors.New("app context not ready")
-	}
-	return ctx, nil
-}
diff --git a/internal/guiapp/runtime_snapshot.go b/internal/guiapp/runtime_snapshot.go
deleted file mode 100644
index 75fcefa5..00000000
--- a/internal/guiapp/runtime_snapshot.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type appRuntimeSnapshot struct {
-	cfg         config.Config
-	core        api.Core
-	coreInitErr error
-	logger      *logging.Logger
-}
-
-func (a *App) runtimeSnapshot() appRuntimeSnapshot {
-	if a == nil {
-		return appRuntimeSnapshot{}
-	}
-	a.runtimeMu.RLock()
-	defer a.runtimeMu.RUnlock()
-	return appRuntimeSnapshot{
-		cfg:         a.cfg,
-		core:        a.core,
-		coreInitErr: a.coreInitErr,
-		logger:      a.logger,
-	}
-}
-
-func (a *App) requireRuntime() (appRuntimeSnapshot, error) {
-	if a == nil {
-		return appRuntimeSnapshot{}, errors.New("app not initialized")
-	}
-	rt := a.runtimeSnapshot()
-	if rt.core != nil {
-		return rt, nil
-	}
-	if rt.coreInitErr != nil {
-		return appRuntimeSnapshot{}, fmt.Errorf("core unavailable: %w", rt.coreInitErr)
-	}
-	return appRuntimeSnapshot{}, errors.New("core not initialized")
-}
-
-func (a *App) currentConfig() config.Config {
-	if a == nil {
-		return config.Config{}
-	}
-	a.runtimeMu.RLock()
-	defer a.runtimeMu.RUnlock()
-	return a.cfg
-}
-
-func (a *App) currentLogger() *logging.Logger {
-	if a == nil {
-		return nil
-	}
-	a.runtimeMu.RLock()
-	defer a.runtimeMu.RUnlock()
-	return a.logger
-}
-
-func (a *App) currentCore() api.Core {
-	if a == nil {
-		return nil
-	}
-	a.runtimeMu.RLock()
-	defer a.runtimeMu.RUnlock()
-	return a.core
-}
-
-// baseUploadOptions returns upload options from the current runtime config.
-func (a *App) baseUploadOptions() api.UploadOptions {
-	return buildBaseUploadOptions(a.currentConfig())
-}
-
-// baseUploadOptions returns upload options derived from the same runtime
-// snapshot as the core selected for a request.
-func (rt appRuntimeSnapshot) baseUploadOptions() api.UploadOptions {
-	return buildBaseUploadOptions(rt.cfg)
-}
-
-func (a *App) replaceRuntime(cfg config.Config, core api.Core, logger *logging.Logger) (api.Core, *logging.Logger) {
-	a.runtimeMu.Lock()
-	defer a.runtimeMu.Unlock()
-	oldCore := a.core
-	oldLogger := a.logger
-	a.core = core
-	a.coreInitErr = nil
-	a.logger = logger
-	a.cfg = cfg
-	return oldCore, oldLogger
-}
diff --git a/internal/guiapp/testmain_test.go b/internal/guiapp/testmain_test.go
deleted file mode 100644
index a553d2a3..00000000
--- a/internal/guiapp/testmain_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"io"
-	"os"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/logging"
-)
-
-func TestMain(m *testing.M) {
-	restore := logging.SetDefaultConsoleOutput(io.Discard, io.Discard)
-	code := m.Run()
-	restore()
-	os.Exit(code)
-}
diff --git a/internal/guiapp/tracker_auth_import_test.go b/internal/guiapp/tracker_auth_import_test.go
deleted file mode 100644
index f1ee36cd..00000000
--- a/internal/guiapp/tracker_auth_import_test.go
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerauth"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestAppImportTrackerAuthCookieContentRejectsOverCap(t *testing.T) {
-	t.Parallel()
-
-	_, err := (&App{}).ImportTrackerAuthCookieContent(
-		"AR",
-		"cookies.txt",
-		strings.Repeat("x", trackerauth.MaxCookieImportContentBytes+1),
-	)
-	if err == nil {
-		t.Fatal("expected over-cap import error")
-	}
-	if !strings.Contains(err.Error(), "cookie file content exceeds") {
-		t.Fatalf("expected shared content cap error, got %v", err)
-	}
-}
-
-func TestImportTrackerAuthCookieFileRejectsOverCap(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "cookies.txt")
-	if err := os.WriteFile(path, []byte(strings.Repeat("x", trackerauth.MaxCookieImportContentBytes+1)), 0o600); err != nil {
-		t.Fatalf("write oversized cookie file: %v", err)
-	}
-
-	_, err := importTrackerAuthCookieFile(context.Background(), trackerauth.NewService(config.Config{}), "AR", path)
-	if err == nil {
-		t.Fatal("expected over-cap import error")
-	}
-	if !strings.Contains(err.Error(), "cookie file content exceeds") {
-		t.Fatalf("expected shared content cap error, got %v", err)
-	}
-}
-
-func TestImportTrackerAuthCookieFileImportsValidFile(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newGUITrackerAuthTestDB(t)
-	path := filepath.Join(t.TempDir(), "cookies.txt")
-	if err := os.WriteFile(path, []byte(".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n"), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-	service := trackerauth.NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	status, err := importTrackerAuthCookieFile(context.Background(), service, "AR", path)
-	if err != nil {
-		t.Fatalf("importTrackerAuthCookieFile: %v", err)
-	}
-	if status.CookieCount != 1 {
-		t.Fatalf("expected imported cookie count, got %#v", status)
-	}
-}
-
-func TestAppImportTrackerAuthCookiesTreatsDialogCancelAsNoop(t *testing.T) {
-	oldOpen := openTrackerAuthCookieDialog
-	t.Cleanup(func() { openTrackerAuthCookieDialog = oldOpen })
-	openTrackerAuthCookieDialog = func(context.Context, runtime.OpenDialogOptions) (string, error) {
-		return "", errors.New("shellItem is nil")
-	}
-	app := &App{runtimeCtx: newAppRuntimeContext(context.Background())}
-
-	status, err := app.ImportTrackerAuthCookies("AR")
-	if err != nil {
-		t.Fatalf("ImportTrackerAuthCookies: %v", err)
-	}
-	if status.TrackerID != "AR" {
-		t.Fatalf("expected current AR status on cancel, got %#v", status)
-	}
-}
-
-func TestAppImportTrackerAuthCookiesPreservesRealDialogError(t *testing.T) {
-	oldOpen := openTrackerAuthCookieDialog
-	t.Cleanup(func() { openTrackerAuthCookieDialog = oldOpen })
-	openTrackerAuthCookieDialog = func(context.Context, runtime.OpenDialogOptions) (string, error) {
-		return "", errors.New("dialog failed")
-	}
-	app := &App{runtimeCtx: newAppRuntimeContext(context.Background())}
-
-	_, err := app.ImportTrackerAuthCookies("AR")
-	if err == nil {
-		t.Fatal("expected dialog error")
-	}
-	if !strings.Contains(err.Error(), "open tracker cookie dialog") {
-		t.Fatalf("expected wrapped dialog error, got %v", err)
-	}
-}
-
-func TestAppImportTrackerAuthCookieContentCanceledContextDoesNotPersistCookies(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newGUITrackerAuthTestDB(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	app := &App{
-		runtimeCtx: newAppRuntimeContext(ctx),
-		cfg:        config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-	}
-
-	_, err := app.ImportTrackerAuthCookieContent("AR", "cookies.txt", ".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n")
-	if err == nil {
-		t.Fatal("expected canceled import error")
-	}
-	if _, loadErr := cookies.LoadTrackerCookieMap(context.Background(), dbPath, "AR"); loadErr == nil {
-		t.Fatal("canceled import persisted cookies")
-	}
-}
-
-func TestAppTestTrackerAuthUsesRuntimeContext(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	app := &App{
-		runtimeCtx: newAppRuntimeContext(ctx),
-		cfg: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"MTV": {
-						URL:      "http://127.0.0.1:1",
-						Username: "user",
-						Password: "pass",
-					},
-				},
-			},
-		},
-	}
-
-	status, err := app.TestTrackerAuth("MTV")
-	if err != nil {
-		t.Fatalf("TestTrackerAuth: %v", err)
-	}
-	if !strings.Contains(status.LastError, "context canceled") {
-		t.Fatalf("expected context canceled status, got %#v", status)
-	}
-}
-
-func TestAppLoginTrackerAuthBTNCookiesWithoutAPIPreservesMissingAPIStatus(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newGUITrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	app := &App{
-		runtimeCtx: newAppRuntimeContext(ctx),
-		cfg:        config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-	}
-
-	status, err := app.LoginTrackerAuth("BTN", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("LoginTrackerAuth: %v", err)
-	}
-	if status.State != "login_required" || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected BTN cookie-only Wails login to preserve missing API status, got %#v", status)
-	}
-	if strings.Contains(status.Message, "username/password missing") {
-		t.Fatalf("missing credentials masked missing API status: %#v", status)
-	}
-}
-
-func newGUITrackerAuthTestDB(t *testing.T) string {
-	t.Helper()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	_ = repo.Close()
-	return dbPath
-}
diff --git a/internal/guiapp/upload_jobs.go b/internal/guiapp/upload_jobs.go
deleted file mode 100644
index cec1ddd2..00000000
--- a/internal/guiapp/upload_jobs.go
+++ /dev/null
@@ -1,704 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import (
-	"context"
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"maps"
-	"math/big"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/wailsapp/wails/v2/pkg/runtime"
-
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	trackerUploadEventPrefix   = "upload:job:"
-	trackerUploadProgressEvent = "upload:progress"
-)
-
-// TrackerUploadTrackerState reports frontend-visible state for one tracker in
-// an upload job. UploadedCount includes accepted uploads returned before a later
-// tracker error or cancellation.
-type TrackerUploadTrackerState struct {
-	Tracker         string  `json:"tracker"`
-	Status          string  `json:"status"`
-	Task            string  `json:"task"`
-	TaskStatus      string  `json:"taskStatus"`
-	Message         string  `json:"message"`
-	CompletedPieces int     `json:"completedPieces"`
-	TotalPieces     int     `json:"totalPieces"`
-	Percent         int     `json:"percent"`
-	HashRateMiB     float64 `json:"hashRateMiB"`
-	UploadedCount   int     `json:"uploadedCount"`
-	StartedAt       string  `json:"startedAt"`
-	FinishedAt      string  `json:"finishedAt"`
-}
-
-// TrackerUploadSnapshot reports frontend-visible state for a tracker upload
-// job. UploadedCount is the sum of per-tracker accepted uploads, including
-// partial counts returned with non-nil errors.
-type TrackerUploadSnapshot struct {
-	JobID                  string                      `json:"jobID"`
-	SourcePath             string                      `json:"sourcePath"`
-	Status                 string                      `json:"status"`
-	CurrentTask            string                      `json:"currentTask"`
-	CurrentTaskStatus      string                      `json:"currentTaskStatus"`
-	CurrentMessage         string                      `json:"currentMessage"`
-	CurrentCompletedPieces int                         `json:"currentCompletedPieces"`
-	CurrentTotalPieces     int                         `json:"currentTotalPieces"`
-	CurrentPercent         int                         `json:"currentPercent"`
-	CurrentHashRateMiB     float64                     `json:"currentHashRateMiB"`
-	Trackers               []TrackerUploadTrackerState `json:"trackers"`
-	FailedTrackers         []string                    `json:"failedTrackers"`
-	UploadedCount          int                         `json:"uploadedCount"`
-	Error                  string                      `json:"error"`
-	StartedAt              string                      `json:"startedAt"`
-	FinishedAt             string                      `json:"finishedAt"`
-}
-
-type trackerUploadJob struct {
-	mu          sync.Mutex
-	cleanupOnce sync.Once
-	id          string
-	sourcePath  string
-	// uploadOptions is the per-job runtime snapshot needed for upload requests;
-	// the full config may contain secrets and must not be retained in job state.
-	uploadOptions        api.UploadOptions
-	runOptions           runOptions
-	core                 api.Core
-	logger               interface{ Close() error }
-	overrides            api.ExternalIDOverrides
-	nameOverrides        api.ReleaseNameOverrides
-	questionnaireAnswers map[string]map[string]string
-	descriptionGroups    []api.DescriptionBuilderGroup
-	trackers             []string
-	ignoreDupesFor       []string
-	states               map[string]TrackerUploadTrackerState
-	failedTrackers       []string
-	uploadedCount        int
-	status               string
-	currentTask          string
-	currentTaskStatus    string
-	currentMessage       string
-	currentCompleted     int
-	currentTotal         int
-	currentPercent       int
-	currentHashRateMiB   float64
-	errorMessage         string
-	startedAt            time.Time
-	finishedAt           time.Time
-	cancel               context.CancelFunc
-}
-
-type trackerUploadRetryRequest struct {
-	sourcePath           string
-	overrides            api.ExternalIDOverrides
-	nameOverrides        api.ReleaseNameOverrides
-	questionnaireAnswers map[string]map[string]string
-	descriptionGroups    []api.DescriptionBuilderGroup
-	failedTrackers       []string
-	ignoreDupesFor       []string
-	runOptions           runOptions
-	uploadOptions        api.UploadOptions
-}
-
-func (j *trackerUploadJob) closeResources() error {
-	if j == nil {
-		return nil
-	}
-
-	var closeErr error
-	j.cleanupOnce.Do(func() {
-		j.mu.Lock()
-		coreSvc := j.core
-		logger := j.logger
-		j.core = nil
-		j.logger = nil
-		j.mu.Unlock()
-
-		if coreSvc != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("core", coreSvc))
-		}
-		if logger != nil {
-			closeErr = errors.Join(closeErr, closeTrackerUploadResource("logger", logger))
-		}
-	})
-	return closeErr
-}
-
-func trackerUploadRetryRequestFromJob(job *trackerUploadJob) (trackerUploadRetryRequest, error) {
-	if job == nil {
-		return trackerUploadRetryRequest{}, errors.New("upload job not found")
-	}
-
-	job.mu.Lock()
-	defer job.mu.Unlock()
-
-	if len(job.failedTrackers) == 0 {
-		return trackerUploadRetryRequest{}, errors.New("no failed trackers to retry")
-	}
-
-	return trackerUploadRetryRequest{
-		sourcePath:           job.sourcePath,
-		overrides:            job.overrides,
-		nameOverrides:        job.nameOverrides,
-		questionnaireAnswers: cloneQuestionnaireAnswers(job.questionnaireAnswers),
-		descriptionGroups:    api.CloneDescriptionBuilderGroups(job.descriptionGroups),
-		failedTrackers:       append([]string(nil), job.failedTrackers...),
-		ignoreDupesFor:       append([]string(nil), job.ignoreDupesFor...),
-		runOptions:           job.runOptions,
-		uploadOptions:        job.uploadOptions,
-	}, nil
-}
-
-// StartTrackerUpload starts a Wails upload job for selected trackers and
-// returns its job ID. Snapshots preserve partial upload counts returned with
-// later tracker errors or cancellation. The job captures upload options at
-// start time so failed-tracker retries reuse the original option set.
-func (a *App) StartTrackerUpload(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string) (string, error) {
-	return a.startTrackerUpload(path, overrides, nameOverrides, trackers, ignoreDupesFor, questionnaireAnswers, descriptionGroups, debug, noSeed, runLogLevel, nil)
-}
-
-func (a *App) startTrackerUpload(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string, uploadOptions *api.UploadOptions) (string, error) {
-	rt, err := a.requireRuntime()
-	if err != nil {
-		return "", err
-	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
-	}
-	resolvedTrackers := normalizeTrackerList(trackers)
-	if len(resolvedTrackers) == 0 {
-		return "", errors.New("at least one tracker must be selected")
-	}
-	runOpts, err := a.buildRunOptions(debug, noSeed, runLogLevel)
-	if err != nil {
-		return "", err
-	}
-	baseCtx := a.runtimeContext()
-
-	runCore, runLogger, err := a.buildRunCoreFromSnapshot(rt, runOpts)
-	if err != nil {
-		return "", err
-	}
-
-	seedReq := api.Request{
-		Paths:                []string{trimmedPath},
-		Mode:                 api.ModeGUI,
-		DescriptionGroups:    api.CloneDescriptionBuilderGroups(descriptionGroups),
-		Trackers:             resolvedTrackers,
-		IgnoreDupesFor:       normalizeTrackerList(ignoreDupesFor),
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-	if err := guishared.SeedRunCorePreparedMeta(baseCtx, rt.core, runCore, seedReq); err != nil {
-		_ = runCore.Close()
-		_ = runLogger.Close()
-		return "", fmt.Errorf("gui: %w", err)
-	}
-
-	jobID := randomUploadJobID()
-	jobUploadOptions := buildRunUploadOptions(rt.cfg, runOpts)
-	if uploadOptions != nil {
-		jobUploadOptions = *uploadOptions
-	}
-	job := &trackerUploadJob{
-		id:                   jobID,
-		sourcePath:           trimmedPath,
-		uploadOptions:        jobUploadOptions,
-		runOptions:           runOpts,
-		core:                 runCore,
-		logger:               runLogger,
-		overrides:            overrides,
-		nameOverrides:        nameOverrides,
-		questionnaireAnswers: cloneQuestionnaireAnswers(questionnaireAnswers),
-		descriptionGroups:    api.CloneDescriptionBuilderGroups(descriptionGroups),
-		trackers:             resolvedTrackers,
-		ignoreDupesFor:       normalizeTrackerList(ignoreDupesFor),
-		states:               make(map[string]TrackerUploadTrackerState, len(resolvedTrackers)),
-		status:               "queued",
-		startedAt:            time.Now().UTC(),
-	}
-	for _, tracker := range resolvedTrackers {
-		job.states[tracker] = TrackerUploadTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-	}
-
-	jobCtx, cancel := context.WithCancel(baseCtx)
-	job.cancel = cancel
-
-	a.startTrackerUploadWorker(jobCtx, baseCtx, job, cancel)
-	a.emitTrackerUploadSnapshot(baseCtx, job)
-
-	return jobID, nil
-}
-
-// CancelTrackerUpload requests cancellation for a Wails tracker upload job.
-func (a *App) CancelTrackerUpload(jobID string) error {
-	if a == nil {
-		return errors.New("app not initialized")
-	}
-	trimmedID := strings.TrimSpace(jobID)
-	if trimmedID == "" {
-		return errors.New("job id is required")
-	}
-
-	job := a.getTrackerUploadJob(trimmedID)
-	if job == nil {
-		return errors.New("upload job not found")
-	}
-
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
-	}
-	return nil
-}
-
-// RetryFailedTrackerUpload starts a new Wails upload job for trackers that
-// failed in the original job. The retry reuses the original job's run options,
-// upload options, questionnaire answers, description groups, and ignore-dupe
-// list instead of rebuilding them from current settings.
-func (a *App) RetryFailedTrackerUpload(jobID string) (string, error) {
-	if a == nil {
-		return "", errors.New("app not initialized")
-	}
-	trimmedID := strings.TrimSpace(jobID)
-	if trimmedID == "" {
-		return "", errors.New("job id is required")
-	}
-
-	job := a.getTrackerUploadJob(trimmedID)
-	if job == nil {
-		return "", errors.New("upload job not found")
-	}
-
-	retry, err := trackerUploadRetryRequestFromJob(job)
-	if err != nil {
-		return "", err
-	}
-
-	return a.startTrackerUpload(retry.sourcePath, retry.overrides, retry.nameOverrides, retry.failedTrackers, retry.ignoreDupesFor, retry.questionnaireAnswers, retry.descriptionGroups, retry.runOptions.Debug, retry.runOptions.NoSeed, retry.runOptions.RunLogLevel, &retry.uploadOptions)
-}
-
-// GetTrackerUploadSnapshot returns the current Wails tracker upload job state.
-func (a *App) GetTrackerUploadSnapshot(jobID string) (TrackerUploadSnapshot, error) {
-	if a == nil {
-		return TrackerUploadSnapshot{}, errors.New("app not initialized")
-	}
-	trimmedID := strings.TrimSpace(jobID)
-	if trimmedID == "" {
-		return TrackerUploadSnapshot{}, errors.New("job id is required")
-	}
-
-	job := a.getTrackerUploadJob(trimmedID)
-	if job == nil {
-		return TrackerUploadSnapshot{}, errors.New("upload job not found")
-	}
-
-	return buildTrackerUploadSnapshot(job), nil
-}
-
-// runTrackerUploadJob records UploadedCount before error handling so partial
-// successes returned with non-nil errors remain visible in snapshots.
-func (a *App) runTrackerUploadJob(ctx context.Context, eventCtx context.Context, job *trackerUploadJob) {
-	if a == nil || job == nil {
-		return
-	}
-	defer func() {
-		if recovered := recover(); recovered != nil {
-			a.failTrackerUploadJob(eventCtx, job, trackerUploadPanicMessage("upload worker panicked", recovered))
-		}
-	}()
-
-	job.mu.Lock()
-	job.status = "running"
-	job.mu.Unlock()
-	a.emitTrackerUploadSnapshot(eventCtx, job)
-
-	for _, tracker := range job.trackers {
-		if ctx.Err() != nil {
-			break
-		}
-
-		job.mu.Lock()
-		state := job.states[tracker]
-		state.Status = "running"
-		state.Message = "uploading"
-		state.StartedAt = time.Now().UTC().Format(time.RFC3339)
-		job.states[tracker] = state
-		job.mu.Unlock()
-		a.emitTrackerUploadSnapshot(eventCtx, job)
-
-		progressCtx := api.WithUploadProgressReporter(ctx, func(update api.UploadProgressUpdate) {
-			a.applyTrackerUploadProgress(eventCtx, job, update)
-		})
-		result, err := a.runSingleTrackerUpload(progressCtx, job, tracker)
-		if result.UploadedCount > 0 {
-			job.mu.Lock()
-			state = job.states[tracker]
-			state.UploadedCount += result.UploadedCount
-			job.states[tracker] = state
-			job.uploadedCount += result.UploadedCount
-			job.mu.Unlock()
-		}
-		if err != nil {
-			if ctx.Err() != nil {
-				break
-			}
-			job.mu.Lock()
-			message := logging.SanitizeMessage(err.Error())
-			state = job.states[tracker]
-			state.Status = "failed"
-			state.Message = message
-			state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
-			job.states[tracker] = state
-			job.failedTrackers = append(job.failedTrackers, tracker)
-			job.errorMessage = message
-			job.mu.Unlock()
-			a.emitTrackerUploadSnapshot(eventCtx, job)
-			continue
-		}
-
-		job.mu.Lock()
-		state = job.states[tracker]
-		state.Status = "success"
-		state.Message = "uploaded"
-		state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
-		job.states[tracker] = state
-		job.mu.Unlock()
-		a.emitTrackerUploadSnapshot(eventCtx, job)
-	}
-
-	job.mu.Lock()
-	job.finishedAt = time.Now().UTC()
-	switch {
-	case ctx.Err() != nil:
-		job.status = "canceled"
-		job.errorMessage = "upload canceled"
-		for _, tracker := range job.trackers {
-			state := job.states[tracker]
-			if state.Status == "queued" || state.Status == "running" {
-				state.Status = "canceled"
-				state.Message = "canceled"
-				state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-				job.states[tracker] = state
-			}
-		}
-	case len(job.failedTrackers) > 0:
-		job.status = "completed_with_errors"
-	default:
-		job.status = "completed"
-		job.errorMessage = ""
-	}
-	job.cancel = nil
-	job.mu.Unlock()
-	if err := job.closeResources(); err != nil {
-		a.failTrackerUploadJob(eventCtx, job, logging.SanitizeMessage(err.Error()))
-		return
-	}
-	a.emitTrackerUploadSnapshot(eventCtx, job)
-}
-
-func (a *App) applyTrackerUploadProgress(eventCtx context.Context, job *trackerUploadJob, update api.UploadProgressUpdate) {
-	if a == nil || job == nil {
-		return
-	}
-	tracker := strings.TrimSpace(update.Tracker)
-	if tracker == "" && len(job.trackers) == 1 {
-		tracker = job.trackers[0]
-	}
-
-	job.mu.Lock()
-	job.currentTask = strings.TrimSpace(update.Task)
-	job.currentTaskStatus = strings.TrimSpace(update.Status)
-	job.currentMessage = strings.TrimSpace(update.Message)
-	job.currentCompleted = update.CompletedPieces
-	job.currentTotal = update.TotalPieces
-	job.currentPercent = update.Percent
-	job.currentHashRateMiB = update.HashRateMiB
-	if tracker != "" {
-		state := job.states[tracker]
-		state.Tracker = tracker
-		state.Task = job.currentTask
-		state.TaskStatus = job.currentTaskStatus
-		state.CompletedPieces = update.CompletedPieces
-		state.TotalPieces = update.TotalPieces
-		state.Percent = update.Percent
-		state.HashRateMiB = update.HashRateMiB
-		if job.currentMessage != "" {
-			state.Message = job.currentMessage
-		}
-		if state.Status == "queued" && strings.EqualFold(job.currentTaskStatus, "running") {
-			state.Status = "running"
-		}
-		if state.StartedAt == "" && state.Status == "running" {
-			state.StartedAt = time.Now().UTC().Format(time.RFC3339)
-		}
-		job.states[tracker] = state
-	}
-	job.mu.Unlock()
-
-	a.emitTrackerUploadSnapshot(eventCtx, job)
-}
-
-func (a *App) runSingleTrackerUpload(ctx context.Context, job *trackerUploadJob, tracker string) (api.Result, error) {
-	if a == nil || job == nil || job.core == nil {
-		return api.Result{}, errors.New("app not initialized")
-	}
-
-	req := api.Request{
-		Paths:                       []string{job.sourcePath},
-		Mode:                        api.ModeGUI,
-		DescriptionGroups:           api.CloneDescriptionBuilderGroups(job.descriptionGroups),
-		Trackers:                    []string{tracker},
-		IgnoreDupesFor:              append([]string(nil), job.ignoreDupesFor...),
-		IgnoreTrackerRuleFailures:   false,
-		Options:                     job.uploadOptions,
-		ExternalIDOverrides:         job.overrides,
-		ReleaseNameOverrides:        job.nameOverrides,
-		TrackerQuestionnaireAnswers: cloneQuestionnaireAnswers(job.questionnaireAnswers),
-	}
-
-	return wrapGUIResult(job.core.RunUploadPrepared(ctx, req))
-}
-
-func (a *App) emitTrackerUploadSnapshot(ctx context.Context, job *trackerUploadJob) {
-	if a == nil || ctx == nil || job == nil || ctx.Value("events") == nil {
-		return
-	}
-	defer func() {
-		_ = recover()
-	}()
-	snapshot := buildTrackerUploadSnapshot(job)
-	runtime.EventsEmit(ctx, trackerUploadEventPrefix+job.id, snapshot)
-}
-
-// startTrackerUploadWorker publishes job only after WaitGroup enrollment so
-// shutdown waits for the worker before closing per-job resources.
-func (a *App) startTrackerUploadWorker(ctx context.Context, eventCtx context.Context, job *trackerUploadJob, cancel context.CancelFunc) {
-	a.publishTrackerUploadJob(job)
-
-	go func() {
-		defer a.uploadWG.Done()
-		defer cancel()
-		a.runTrackerUploadJob(ctx, eventCtx, job)
-	}()
-}
-
-// publishTrackerUploadJob enrolls job work and exposes the job under one lock
-// so stopAllUploadJobs observes both states together.
-func (a *App) publishTrackerUploadJob(job *trackerUploadJob) {
-	a.uploadMu.Lock()
-	a.uploadWG.Add(1)
-	a.uploads[job.id] = job
-	a.uploadMu.Unlock()
-}
-
-// failTrackerUploadJob marks unfinished tracker states failed, closes per-job
-// resources once, and emits the terminal snapshot.
-func (a *App) failTrackerUploadJob(eventCtx context.Context, job *trackerUploadJob, message string) {
-	if a == nil || job == nil {
-		return
-	}
-
-	job.mu.Lock()
-	now := time.Now().UTC()
-	if job.finishedAt.IsZero() {
-		job.finishedAt = now
-	}
-	job.status = "failed"
-	job.errorMessage = strings.TrimSpace(message)
-	if job.errorMessage == "" {
-		job.errorMessage = "upload failed"
-	}
-	for _, tracker := range job.trackers {
-		state := job.states[tracker]
-		if state.Status == "queued" || state.Status == "running" {
-			state.Status = "failed"
-			state.Message = job.errorMessage
-			state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-			job.states[tracker] = state
-		}
-	}
-	job.cancel = nil
-	job.mu.Unlock()
-
-	if err := job.closeResources(); err != nil {
-		job.mu.Lock()
-		message := logging.SanitizeMessage(err.Error())
-		if job.errorMessage == "" {
-			job.errorMessage = message
-		} else if !strings.Contains(job.errorMessage, message) {
-			job.errorMessage += "; " + message
-		}
-		for _, tracker := range job.trackers {
-			state := job.states[tracker]
-			if state.Status == "failed" && state.Message == message {
-				state.Message = job.errorMessage
-				job.states[tracker] = state
-			}
-		}
-		job.mu.Unlock()
-	}
-	a.emitTrackerUploadSnapshot(eventCtx, job)
-}
-
-// closeTrackerUploadResource converts Close panics into redacted errors for
-// upload worker terminal state handling.
-func closeTrackerUploadResource(name string, resource interface{ Close() error }) (err error) {
-	defer func() {
-		if recovered := recover(); recovered != nil {
-			err = errors.New(trackerUploadPanicMessage(name+" close panicked", recovered))
-		}
-	}()
-	if closeErr := resource.Close(); closeErr != nil {
-		return fmt.Errorf("%s close failed: %w", name, closeErr)
-	}
-	return nil
-}
-
-// trackerUploadPanicMessage redacts recovered panic text before it is stored in
-// upload job state or sent over the Wails event bridge.
-func trackerUploadPanicMessage(prefix string, recovered any) string {
-	detail := strings.TrimSpace(redaction.RedactValue(fmt.Sprint(recovered), nil))
-	if detail == "" {
-		return prefix
-	}
-	return prefix + ": " + detail
-}
-
-func buildTrackerUploadSnapshot(job *trackerUploadJob) TrackerUploadSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-
-	trackers := make([]TrackerUploadTrackerState, 0, len(job.trackers))
-	for _, tracker := range job.trackers {
-		state, ok := job.states[tracker]
-		if !ok {
-			state = TrackerUploadTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-		}
-		trackers = append(trackers, state)
-	}
-
-	startedAt := ""
-	if !job.startedAt.IsZero() {
-		startedAt = job.startedAt.Format(time.RFC3339)
-	}
-	finishedAt := ""
-	if !job.finishedAt.IsZero() {
-		finishedAt = job.finishedAt.Format(time.RFC3339)
-	}
-
-	return TrackerUploadSnapshot{
-		JobID:                  job.id,
-		SourcePath:             job.sourcePath,
-		Status:                 job.status,
-		CurrentTask:            job.currentTask,
-		CurrentTaskStatus:      job.currentTaskStatus,
-		CurrentMessage:         job.currentMessage,
-		CurrentCompletedPieces: job.currentCompleted,
-		CurrentTotalPieces:     job.currentTotal,
-		CurrentPercent:         job.currentPercent,
-		CurrentHashRateMiB:     job.currentHashRateMiB,
-		Trackers:               trackers,
-		FailedTrackers:         append([]string(nil), job.failedTrackers...),
-		UploadedCount:          job.uploadedCount,
-		Error:                  job.errorMessage,
-		StartedAt:              startedAt,
-		FinishedAt:             finishedAt,
-	}
-}
-
-func randomUploadJobID() string {
-	value, err := rand.Int(rand.Reader, new(big.Int).SetUint64(^uint64(0)))
-	if err != nil {
-		return strconv.FormatInt(time.Now().UnixNano(), 10)
-	}
-	return fmt.Sprintf("%d-%x", time.Now().UnixNano(), value.Uint64())
-}
-
-func (a *App) getTrackerUploadJob(jobID string) *trackerUploadJob {
-	a.uploadMu.Lock()
-	defer a.uploadMu.Unlock()
-	return a.uploads[jobID]
-}
-
-func (a *App) stopAllUploadJobs() {
-	if a == nil {
-		return
-	}
-	a.uploadMu.Lock()
-	jobs := make([]*trackerUploadJob, 0, len(a.uploads))
-	for _, job := range a.uploads {
-		jobs = append(jobs, job)
-	}
-	a.uploadMu.Unlock()
-
-	for _, job := range jobs {
-		if job == nil {
-			continue
-		}
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
-	}
-	a.uploadWG.Wait()
-	for _, job := range jobs {
-		if job != nil {
-			_ = job.closeResources()
-		}
-	}
-}
-
-func normalizeTrackerList(trackers []string) []string {
-	seen := make(map[string]struct{})
-	resolved := make([]string, 0, len(trackers))
-	for _, tracker := range trackers {
-		trimmed := strings.TrimSpace(tracker)
-		if trimmed == "" {
-			continue
-		}
-		normalized := strings.ToLower(trimmed)
-		if _, ok := seen[normalized]; ok {
-			continue
-		}
-		seen[normalized] = struct{}{}
-		resolved = append(resolved, trimmed)
-	}
-	return resolved
-}
-
-func cloneQuestionnaireAnswers(input map[string]map[string]string) map[string]map[string]string {
-	if len(input) == 0 {
-		return nil
-	}
-	cloned := make(map[string]map[string]string, len(input))
-	for tracker, values := range input {
-		if len(values) == 0 {
-			cloned[tracker] = map[string]string{}
-			continue
-		}
-		inner := make(map[string]string, len(values))
-		maps.Copy(inner, values)
-		cloned[tracker] = inner
-	}
-	return cloned
-}
diff --git a/internal/guiapp/wrap_errors.go b/internal/guiapp/wrap_errors.go
deleted file mode 100644
index 3fdcaf53..00000000
--- a/internal/guiapp/wrap_errors.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guiapp
-
-import "fmt"
-
-func wrapGUIError(err error) error {
-	if err != nil {
-		return fmt.Errorf("gui: %w", err)
-	}
-	return nil
-}
-
-func wrapGUIResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("gui: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/guishared/prepared_meta.go b/internal/guishared/prepared_meta.go
deleted file mode 100644
index 8ec6a3bd..00000000
--- a/internal/guishared/prepared_meta.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guishared
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type PreparedMetaExporter interface {
-	ExportGUICachedPreparedMeta(ctx context.Context, req api.Request) (api.PreparedMetadata, bool, error)
-}
-
-type PreparedMetaImporter interface {
-	ImportPreparedMetadataForGUI(ctx context.Context, req api.Request, meta api.PreparedMetadata) error
-}
-
-func SeedRunCorePreparedMeta(ctx context.Context, source api.Core, target api.Core, req api.Request) error {
-	exporter, ok := source.(PreparedMetaExporter)
-	if !ok {
-		return nil
-	}
-	importer, ok := target.(PreparedMetaImporter)
-	if !ok {
-		return nil
-	}
-
-	meta, found, err := exporter.ExportGUICachedPreparedMeta(ctx, req)
-	if err != nil {
-		return fmt.Errorf("gui shared: %w", err)
-	}
-	if !found {
-		return nil
-	}
-	if err := importer.ImportPreparedMetadataForGUI(ctx, req, meta); err != nil {
-		return fmt.Errorf("gui shared: import prepared metadata: %w", err)
-	}
-	return nil
-}
diff --git a/internal/guishared/runtime.go b/internal/guishared/runtime.go
deleted file mode 100644
index fc0eeb13..00000000
--- a/internal/guishared/runtime.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package guishared
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/core"
-	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-// Runtime bundles the logger and core service built from a config snapshot.
-// Both the GUI App and the web Backend reload their runtime when the user
-// edits settings; this helper keeps the build-and-swap pattern in one place.
-type Runtime struct {
-	Core   api.Core
-	Logger *logging.Logger
-}
-
-// BuildRuntime constructs a fresh logger and core service for cfg using the
-// existing app/backend context and shared repository. On failure any partially
-// initialized resources are cleaned up before returning.
-func BuildRuntime(ctx context.Context, cfg config.Config, repo *db.SQLiteRepository) (Runtime, error) {
-	if ctx == nil {
-		return Runtime{}, errors.New("guishared: context is required")
-	}
-
-	logger, err := logging.New(cfg.Logging, cfg.MainSettings.DBPath)
-	if err != nil {
-		return Runtime{}, fmt.Errorf("gui shared: %w", err)
-	}
-	svc, err := core.NewWithContext(ctx, api.CoreDependencies{
-		Config: cfg,
-		Logger: logger,
-		Services: api.ServiceSet{
-			Filesystem: filesystem.NewValidator(),
-		},
-		Repository:          repo,
-		SkipCookieMigration: true,
-	})
-	if err != nil {
-		_ = logger.Close()
-		return Runtime{}, fmt.Errorf("gui shared: %w", err)
-	}
-	return Runtime{Core: svc, Logger: logger}, nil
-}
diff --git a/internal/httpclient/httpclient.go b/internal/httpclient/httpclient.go
index 88d18615..db70cea2 100644
--- a/internal/httpclient/httpclient.go
+++ b/internal/httpclient/httpclient.go
@@ -9,10 +9,12 @@ import (
 )
 
 const (
+	// DefaultTimeout and UploadTimeout are whole-request deadlines assigned to [http.Client.Timeout].
 	DefaultTimeout = 45 * time.Second
 	UploadTimeout  = 60 * time.Second
 )
 
+// New returns a client whose timeout defaults to [DefaultTimeout] when timeout is non-positive.
 func New(timeout time.Duration) *http.Client {
 	if timeout <= 0 {
 		timeout = DefaultTimeout
@@ -20,6 +22,9 @@ func New(timeout time.Duration) *http.Client {
 	return &http.Client{Timeout: timeout}
 }
 
+// CloneWithTimeout shallow-copies base without mutating it and replaces its timeout.
+// It preserves all other fields; referenced transport and cookie-jar state remain shared.
+// A nil base creates a new client, and a non-positive timeout uses [DefaultTimeout].
 func CloneWithTimeout(base *http.Client, timeout time.Duration) *http.Client {
 	if base == nil {
 		return New(timeout)
diff --git a/internal/services/imagehost/imagehost.go b/internal/imagehosting/host/imagehost.go
similarity index 78%
rename from internal/services/imagehost/imagehost.go
rename to internal/imagehosting/host/imagehost.go
index 226c494a..9a7c8248 100644
--- a/internal/services/imagehost/imagehost.go
+++ b/internal/imagehosting/host/imagehost.go
@@ -1,14 +1,16 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package imagehost
+package host
 
 import (
 	"net/url"
 	"strings"
 )
 
-// HostMapping maps URL domain patterns to normalized host names
+// HostMapping is the process-wide URL-host normalization table used by
+// [ExtractHost]. Treat it as read-only after startup; ExtractHost reads it
+// without synchronization.
 var HostMapping = map[string]string{
 	"ibb.co":               "imgbb",
 	"pixhost.cc":           "pixhost",
@@ -33,8 +35,10 @@ var HostMapping = map[string]string{
 	"i.ibb.co": "imgbb",
 }
 
-// ExtractHost extracts the normalized host name from a URL.
-// Returns the mapped host name if found, otherwise returns the domain name.
+// ExtractHost returns the mapped image-host name for a URL, checking the exact
+// lowercased host, a removed "www." prefix, and the final two labels in that
+// order. Invalid or hostless URLs return empty; unmatched hosts are returned as
+// lowercased URL hosts.
 func ExtractHost(rawURL string) string {
 	if strings.TrimSpace(rawURL) == "" {
 		return ""
@@ -53,8 +57,7 @@ func ExtractHost(rawURL string) string {
 	}
 
 	// Try removing www. prefix
-	if strings.HasPrefix(hostname, "www.") {
-		withoutWWW := strings.TrimPrefix(hostname, "www.")
+	if withoutWWW, ok := strings.CutPrefix(hostname, "www."); ok {
 		if mapped, ok := HostMapping[withoutWWW]; ok {
 			return mapped
 		}
diff --git a/internal/services/imagehost/imagehost_test.go b/internal/imagehosting/host/imagehost_test.go
similarity index 99%
rename from internal/services/imagehost/imagehost_test.go
rename to internal/imagehosting/host/imagehost_test.go
index 49b6a0a2..e0ffe885 100644
--- a/internal/services/imagehost/imagehost_test.go
+++ b/internal/imagehosting/host/imagehost_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package imagehost
+package host
 
 import "testing"
 
diff --git a/internal/imagehosting/policy/policy.go b/internal/imagehosting/policy/policy.go
new file mode 100644
index 00000000..2bb3b6da
--- /dev/null
+++ b/internal/imagehosting/policy/policy.go
@@ -0,0 +1,67 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package policy describes generic image uploader capabilities. Tracker-owned
+// acceptance and ownership rules are exposed by the tracker registry.
+package policy
+
+import (
+	"slices"
+	"strings"
+)
+
+// Metadata is a defensive snapshot of uploader and composed tracker policy data.
+type Metadata struct {
+	// UploadHosts lists every configured uploader name.
+	UploadHosts []string
+	// TrackerUploadHosts maps tracker names to upload-capable accepted hosts.
+	TrackerUploadHosts map[string][]string
+	// OwnedHosts maps normalized host names to their owning tracker.
+	OwnedHosts map[string]string
+}
+
+var uploadHosts = map[string]struct{}{
+	"dalexni":      {},
+	"hdb":          {},
+	"imgbb":        {},
+	"imgbox":       {},
+	"lensdump":     {},
+	"lostimg":      {},
+	"onlyimage":    {},
+	"passtheimage": {},
+	"pixhost":      {},
+	"ptscreens":    {},
+	"reelflix":     {},
+	"seedpool_cdn": {},
+	"sharex":       {},
+	"thr":          {},
+	"utppm":        {},
+	"zipline":      {},
+}
+
+// KnownUploadHosts returns supported upload host names in deterministic order.
+func KnownUploadHosts() []string {
+	out := make([]string, 0, len(uploadHosts))
+	for host := range uploadHosts {
+		out = append(out, host)
+	}
+	slices.Sort(out)
+	return out
+}
+
+// IsUploadHost reports whether host has a configured uploader.
+func IsUploadHost(host string) bool {
+	_, ok := uploadHosts[strings.ToLower(strings.TrimSpace(host))]
+	return ok
+}
+
+// HostAllowed reports whether host is present in allowed; an empty allowlist permits every host.
+func HostAllowed(host string, allowed []string) bool {
+	if len(allowed) == 0 {
+		return true
+	}
+	needle := strings.ToLower(strings.TrimSpace(host))
+	return slices.ContainsFunc(allowed, func(item string) bool {
+		return strings.ToLower(strings.TrimSpace(item)) == needle
+	})
+}
diff --git a/internal/imagehosting/policy/policy_test.go b/internal/imagehosting/policy/policy_test.go
new file mode 100644
index 00000000..88aa2ec0
--- /dev/null
+++ b/internal/imagehosting/policy/policy_test.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package policy
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestKnownUploadHostsAreDeterministic(t *testing.T) {
+	t.Parallel()
+
+	hosts := KnownUploadHosts()
+	if !slices.IsSorted(hosts) {
+		t.Fatalf("upload hosts are not sorted: %v", hosts)
+	}
+	for _, host := range []string{"hdb", "lostimg", "pixhost", "reelflix", "thr"} {
+		if !IsUploadHost(host) {
+			t.Errorf("expected upload host %q", host)
+		}
+	}
+}
+
+func TestHostAllowedUsesGenericAllowlist(t *testing.T) {
+	t.Parallel()
+
+	if !HostAllowed("PIXHOST", []string{"pixhost"}) {
+		t.Fatal("expected case-insensitive allowlist match")
+	}
+	if HostAllowed("imgbox", []string{"pixhost"}) {
+		t.Fatal("unexpected allowlist match")
+	}
+	if !HostAllowed("imgbox", nil) {
+		t.Fatal("empty allowlist must permit every host")
+	}
+}
diff --git a/internal/imagehosting/service.go b/internal/imagehosting/service.go
new file mode 100644
index 00000000..ae31181a
--- /dev/null
+++ b/internal/imagehosting/service.go
@@ -0,0 +1,966 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package imagehosting selects, uploads, and persists release images.
+package imagehosting
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Service coordinates configured image-host uploaders and image persistence.
+type Service struct {
+	cfg       config.Config
+	logger    api.Logger
+	repo      repository
+	client    *http.Client
+	uploaders map[string]uploader
+	registry  *trackers.Registry
+}
+
+type repository interface {
+	ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error)
+	ListScreenshotsByPath(context.Context, string) ([]api.Screenshot, error)
+	ListUploadedImagesByPath(context.Context, string) ([]api.UploadedImageLink, error)
+	SaveUploadedImages(context.Context, string, string, []api.UploadedImageLink) error
+	ListScreenshotSlotsByPath(context.Context, string) ([]api.ScreenshotSlot, error)
+	ReplaceScreenshotSlots(context.Context, string, []api.ScreenshotSlot) error
+	UpsertScreenshotSlotVariants(context.Context, string, []api.ScreenshotSlotVariant) error
+}
+
+// NewServiceWithRegistry returns an image-hosting service with tracker-owned host scope metadata.
+func NewServiceWithRegistry(cfg config.Config, logger api.Logger, repo repository, registry *trackers.Registry) *Service {
+	if registry == nil {
+		panic("image hosting: tracker registry is nil")
+	}
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	client := httpclient.New(httpclient.UploadTimeout)
+	service := &Service{
+		cfg:      cfg,
+		logger:   logger,
+		repo:     repo,
+		client:   client,
+		registry: registry,
+	}
+	service.uploaders = newUploaderRegistry(cfg, client, registry)
+	return service
+}
+
+// ListCandidates returns existing local and uploaded screenshot selections for
+// image hosting, deduplicated by local image path. Disc-menu selections retain
+// [api.ScreenshotPurposeMenu]; all other candidates use final purpose.
+func (s *Service) ListCandidates(ctx context.Context, meta api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("image hosting: list candidates canceled: %w", err)
+	}
+	if s == nil || s.repo == nil {
+		return nil, errors.New("image hosting: repository not configured")
+	}
+	if strings.TrimSpace(meta.SourcePath) == "" {
+		return nil, internalerrors.ErrInvalidInput
+	}
+
+	// First, get all screenshots from the database
+	screens, err := s.repo.ListScreenshotsByPath(ctx, meta.SourcePath)
+	if err != nil {
+		return nil, fmt.Errorf("image hosting: %w", err)
+	}
+
+	// Then, get all previously uploaded images
+	uploaded, err := s.repo.ListUploadedImagesByPath(ctx, meta.SourcePath)
+	if err != nil {
+		return nil, fmt.Errorf("image hosting: %w", err)
+	}
+	selections, err := s.repo.ListFinalSelections(ctx, meta.SourcePath)
+	if err != nil {
+		s.logger.Debugf("image hosting: final selections unavailable: %v", err)
+		selections = nil
+	}
+	selectionSourceByPath := make(map[string]string, len(selections))
+	for _, selection := range selections {
+		selectionSourceByPath[strings.TrimSpace(selection.ImagePath)] = strings.TrimSpace(selection.Source)
+	}
+
+	// Build a map of uploaded images by path for quick lookup
+	uploadedByPath := make(map[string]api.UploadedImageLink, len(uploaded))
+	for _, upload := range uploaded {
+		uploadedByPath[upload.ImagePath] = upload
+	}
+
+	// Build result list, merging upload info where available
+	images := make([]api.ScreenshotImage, 0, len(screens))
+	for _, shot := range screens {
+		pathValue := strings.TrimSpace(shot.ImagePath)
+		if pathValue == "" || !isAllowedImageExt(pathValue) {
+			continue
+		}
+		info, statErr := os.Stat(pathValue)
+		if statErr != nil || info.IsDir() {
+			continue
+		}
+
+		img := api.ScreenshotImage{
+			Path:             pathValue,
+			TimestampSeconds: shot.Timestamp,
+			Purpose:          shot.Purpose,
+			Width:            shot.Width,
+			Height:           shot.Height,
+			SizeBytes:        info.Size(),
+		}
+		if api.IsDiscMenuSelectionSource(selectionSourceByPath[pathValue]) {
+			img.Purpose = api.ScreenshotPurposeMenu
+		} else if img.Purpose == "" {
+			img.Purpose = api.ScreenshotPurposeFinal
+		}
+
+		// If this image has been uploaded, include the upload info
+		if uploadInfo, exists := uploadedByPath[pathValue]; exists {
+			img.Host = uploadInfo.Host
+			img.ImgURL = uploadInfo.ImgURL
+			img.RawURL = uploadInfo.RawURL
+			img.WebURL = uploadInfo.WebURL
+			img.UploadedAt = uploadInfo.UploadedAt
+			s.logger.Tracef(
+				"image hosting: found uploaded image file=%s host=%s tracker=%s",
+				filepath.Base(pathValue),
+				uploadInfo.Host,
+				s.imageHostLogTracker(uploadInfo.Host),
+			)
+		}
+
+		images = append(images, img)
+	}
+
+	// Also include final selections (like menu images that didn't go through screenshot generation)
+	seenPaths := make(map[string]struct{}, len(images))
+	for _, img := range images {
+		seenPaths[img.Path] = struct{}{}
+	}
+	for _, sel := range selections {
+		pathValue := strings.TrimSpace(sel.ImagePath)
+		if pathValue == "" || !isAllowedImageExt(pathValue) {
+			continue
+		}
+		if _, exists := seenPaths[pathValue]; exists {
+			continue
+		}
+		info, statErr := os.Stat(pathValue)
+		if statErr != nil || info.IsDir() {
+			continue
+		}
+
+		img := api.ScreenshotImage{
+			Path:             pathValue,
+			TimestampSeconds: 0, // Fallback since it wasn't a generated frame
+			Purpose:          api.ScreenshotPurposeFinal,
+			Width:            0,
+			Height:           0,
+			SizeBytes:        info.Size(),
+		}
+		if api.IsDiscMenuSelectionSource(sel.Source) {
+			img.Purpose = api.ScreenshotPurposeMenu
+		}
+
+		if uploadInfo, exists := uploadedByPath[pathValue]; exists {
+			img.Host = uploadInfo.Host
+			img.ImgURL = uploadInfo.ImgURL
+			img.RawURL = uploadInfo.RawURL
+			img.WebURL = uploadInfo.WebURL
+			img.UploadedAt = uploadInfo.UploadedAt
+			s.logger.Tracef(
+				"image hosting: found uploaded final selection file=%s host=%s tracker=%s",
+				filepath.Base(pathValue),
+				uploadInfo.Host,
+				s.imageHostLogTracker(uploadInfo.Host),
+			)
+		}
+
+		images = append(images, img)
+		seenPaths[pathValue] = struct{}{}
+	}
+
+	for _, upload := range uploaded {
+		pathValue := strings.TrimSpace(upload.ImagePath)
+		if pathValue == "" || !isAllowedImageExt(pathValue) {
+			continue
+		}
+		if _, exists := seenPaths[pathValue]; exists {
+			continue
+		}
+		info, statErr := os.Stat(pathValue)
+		if statErr != nil || info.IsDir() {
+			continue
+		}
+		purpose := api.ScreenshotPurposeFinal
+		if api.IsDiscMenuSelectionSource(selectionSourceByPath[pathValue]) {
+			purpose = api.ScreenshotPurposeMenu
+		}
+		images = append(images, api.ScreenshotImage{
+			Path:       pathValue,
+			Purpose:    purpose,
+			SizeBytes:  info.Size(),
+			Host:       upload.Host,
+			ImgURL:     upload.ImgURL,
+			RawURL:     upload.RawURL,
+			WebURL:     upload.WebURL,
+			UploadedAt: upload.UploadedAt,
+		})
+		seenPaths[pathValue] = struct{}{}
+		s.logger.Tracef(
+			"image hosting: found uploaded-only image file=%s host=%s tracker=%s",
+			filepath.Base(pathValue),
+			upload.Host,
+			s.imageHostLogTracker(upload.Host),
+		)
+	}
+
+	sort.Slice(images, func(i, j int) bool {
+		return images[i].TimestampSeconds < images[j].TimestampSeconds
+	})
+
+	s.logger.Debugf("image hosting: returning candidate images count=%d uploaded=%d", len(images), len(uploadedByPath))
+	return images, nil
+}
+
+// Upload validates and deduplicates local image paths, uploads them to one host,
+// and persists successful links when a repository is configured. Tracker-owned
+// hosts require their matching usage scope; HDB batches keep normal and
+// disc-menu images in separate, non-overlapping galleries.
+func (s *Service) Upload(
+	ctx context.Context,
+	meta api.ImageHostingSubject,
+	host string,
+	usageScope string,
+	images []api.ScreenshotImage,
+) ([]api.UploadedImageLink, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
+	}
+	if s == nil {
+		return nil, errors.New("image hosting: service not configured")
+	}
+	normalizedHost := strings.ToLower(strings.TrimSpace(host))
+	if normalizedHost == "" {
+		return nil, internalerrors.ErrInvalidInput
+	}
+	normalizedScope := strings.TrimSpace(usageScope)
+	if normalizedScope == "" {
+		normalizedScope = "global"
+	}
+	if owner := trackers.TrackerForOwnedImageHost(s.registry, normalizedHost); owner != "" {
+		expectedScope := trackers.TrackerImageUsageScope(owner)
+		if !strings.EqualFold(normalizedScope, expectedScope) {
+			return nil, fmt.Errorf(
+				"image hosting: host %q is scoped to tracker %s: expected scope %q, got %q",
+				normalizedHost,
+				owner,
+				expectedScope,
+				normalizedScope,
+			)
+		}
+	}
+	if len(images) == 0 {
+		return nil, internalerrors.ErrInvalidInput
+	}
+	uploader := s.uploaders[normalizedHost]
+	if uploader == nil {
+		return nil, fmt.Errorf("image hosting: unsupported host %q", normalizedHost)
+	}
+	if strings.TrimSpace(meta.SourcePath) == "" {
+		return nil, internalerrors.ErrInvalidInput
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
+	}
+	logTracker := s.imageHostLogTracker(normalizedHost)
+
+	s.logger.Infof("image hosting: uploading images count=%d host=%s tracker=%s", len(images), normalizedHost, logTracker)
+	s.logger.Debugf("image hosting: upload source path=%s host=%s tracker=%s", meta.SourcePath, normalizedHost, logTracker)
+
+	unique := make([]imageCandidate, 0, len(images))
+	seen := make(map[string]struct{}, len(images))
+	for _, image := range images {
+		pathValue := strings.TrimSpace(image.Path)
+		if pathValue == "" {
+			return nil, internalerrors.ErrInvalidInput
+		}
+		absPath, err := filepath.Abs(pathValue)
+		if err != nil {
+			return nil, fmt.Errorf("image hosting: resolve image path: %w", err)
+		}
+		if !isAllowedImageExt(absPath) {
+			return nil, internalerrors.ErrInvalidInput
+		}
+		if _, exists := seen[absPath]; exists {
+			s.logger.Tracef("image hosting: skipping duplicate file=%s host=%s tracker=%s", filepath.Base(absPath), normalizedHost, logTracker)
+			continue
+		}
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return nil, fmt.Errorf("image hosting: stat image path: %w", err)
+		}
+		if info.IsDir() {
+			return nil, internalerrors.ErrInvalidInput
+		}
+		seen[absPath] = struct{}{}
+		unique = append(unique, imageCandidate{
+			Path:      absPath,
+			Purpose:   image.Purpose,
+			SizeBytes: info.Size(),
+		})
+		s.logger.Tracef(
+			"image hosting: queued file=%s host=%s tracker=%s size_kb=%.2f",
+			filepath.Base(absPath),
+			normalizedHost,
+			logTracker,
+			float64(info.Size())/1024.0,
+		)
+	}
+	if len(unique) == 0 {
+		return nil, internalerrors.ErrInvalidInput
+	}
+	progressTarget, ok := api.ImageUploadProgressTargetFromContext(ctx)
+	if !ok {
+		progressTarget = api.ImageUploadProgressTarget{
+			AttemptID:  normalizedHost + "|" + normalizedScope,
+			Host:       normalizedHost,
+			UsageScope: normalizedScope,
+			Total:      len(unique),
+		}
+	}
+	if progressTarget.Total <= 0 {
+		progressTarget.Total = progressTarget.Reused + len(unique)
+	}
+	emitUploadProgress(ctx, progressTarget, api.ImageUploadProgressRunning, progressTarget.Reused, 0, 0, "Uploading images.")
+
+	s.logger.Tracef("image hosting: prepared unique images count=%d host=%s tracker=%s", len(unique), normalizedHost, logTracker)
+
+	if batch, ok := uploader.(batchUploader); ok {
+		batchCount := 1
+		if normalizedHost == "hdb" {
+			normalCount, menuCount := imagePurposeCounts(unique)
+			batchCount = 0
+			if normalCount > 0 {
+				batchCount++
+			}
+			if menuCount > 0 {
+				batchCount++
+			}
+			s.logger.Infof("image hosting: HDB gallery upload plan host=%s tracker=%s normal=%d menu=%d", normalizedHost, logTracker, normalCount, menuCount)
+		}
+		s.logger.Debugf("image hosting: starting batch upload host=%s tracker=%s", normalizedHost, logTracker)
+		batchStart := time.Now()
+		uploadedResults, err := uploadBatch(ctx, batch, meta, normalizedHost, unique)
+		batchWallDuration := time.Since(batchStart)
+		if err != nil {
+			s.logger.Errorf(
+				"image hosting: batch upload failed host=%s tracker=%s batches=%d images=%d wall_duration=%v err=%s",
+				normalizedHost,
+				logTracker,
+				batchCount,
+				len(unique),
+				batchWallDuration,
+				redaction.RedactValue(err.Error(), nil),
+			)
+			emitUploadProgress(
+				ctx,
+				progressTarget,
+				api.ImageUploadProgressFailed,
+				progressTarget.Total,
+				0,
+				len(unique),
+				"Host batch upload failed.",
+			)
+			return nil, err
+		}
+		if len(uploadedResults) != len(unique) {
+			emitUploadProgress(
+				ctx,
+				progressTarget,
+				api.ImageUploadProgressFailed,
+				progressTarget.Total,
+				0,
+				len(unique),
+				"Host returned an incomplete batch.",
+			)
+			return nil, fmt.Errorf("image hosting: batch upload count mismatch for %s", normalizedHost)
+		}
+		results := make([]api.UploadedImageLink, len(unique))
+		for idx, candidate := range unique {
+			uploaded := uploadedResults[idx]
+			fileName := filepath.Base(candidate.Path)
+			if strings.TrimSpace(uploaded.RawURL) == "" {
+				emitUploadProgress(
+					ctx,
+					progressTarget,
+					api.ImageUploadProgressFailed,
+					progressTarget.Total,
+					idx,
+					len(unique)-idx,
+					"Host returned an invalid batch result.",
+				)
+				return nil, fmt.Errorf("image upload %s: missing raw url", fileName)
+			}
+			if strings.TrimSpace(uploaded.ImgURL) == "" {
+				uploaded.ImgURL = uploaded.RawURL
+			}
+			if strings.TrimSpace(uploaded.WebURL) == "" {
+				uploaded.WebURL = uploaded.RawURL
+			}
+			results[idx] = api.UploadedImageLink{
+				SourcePath: meta.SourcePath,
+				ImagePath:  candidate.Path,
+				Host:       normalizedHost,
+				UsageScope: normalizedScope,
+				ImgURL:     strings.TrimSpace(uploaded.ImgURL),
+				RawURL:     strings.TrimSpace(uploaded.RawURL),
+				WebURL:     strings.TrimSpace(uploaded.WebURL),
+				SizeBytes:  candidate.SizeBytes,
+				UploadedAt: time.Now().UTC(),
+			}
+		}
+		if s.repo != nil {
+			s.logger.Tracef("image hosting: persisting upload records count=%d host=%s tracker=%s", len(results), normalizedHost, logTracker)
+			if err := s.repo.SaveUploadedImages(ctx, meta.SourcePath, normalizedHost, results); err != nil {
+				s.logger.Errorf(
+					"image hosting: failed to save upload records host=%s tracker=%s err=%s",
+					normalizedHost,
+					logTracker,
+					redaction.RedactValue(err.Error(), nil),
+				)
+				emitUploadProgress(
+					ctx,
+					progressTarget,
+					api.ImageUploadProgressFailed,
+					progressTarget.Total,
+					0,
+					len(unique),
+					"Uploaded images could not be saved.",
+				)
+				return nil, fmt.Errorf("image hosting: %w", err)
+			}
+			summary, err := syncScreenshotSlotVariants(ctx, s.repo, meta.SourcePath, results)
+			if err != nil {
+				s.logger.Warnf(
+					"image hosting: failed to sync screenshot slot variants host=%s tracker=%s err=%s",
+					normalizedHost,
+					logTracker,
+					redaction.RedactValue(err.Error(), nil),
+				)
+			} else if summary.FallbackMatched > 0 {
+				s.logger.Debugf(
+					"image hosting: applied ordered screenshot slot fallback host=%s tracker=%s matched=%d",
+					normalizedHost,
+					logTracker,
+					summary.FallbackMatched,
+				)
+			}
+		}
+		s.logger.Infof(
+			"image hosting: completed batch upload host=%s tracker=%s batches=%d images=%d wall_duration=%v",
+			normalizedHost,
+			logTracker,
+			batchCount,
+			len(results),
+			batchWallDuration,
+		)
+		emitUploadProgress(
+			ctx,
+			progressTarget,
+			api.ImageUploadProgressCompleted,
+			progressTarget.Total,
+			len(results),
+			0,
+			"Host upload complete.",
+		)
+		return results, nil
+	}
+
+	limit := s.cfg.ScreenshotHandling.MaxConcurrentUploads
+	if limit <= 0 {
+		limit = 1
+	}
+
+	s.logger.Infof("image hosting: starting concurrent uploads limit=%d host=%s tracker=%s", limit, normalizedHost, logTracker)
+	uploadStart := time.Now()
+
+	var (
+		wg               sync.WaitGroup
+		mu               sync.Mutex
+		progressMu       sync.Mutex
+		results          = make([]indexedUploadResult, 0, len(unique))
+		failures         = make([]string, 0)
+		completed        = progressTarget.Reused
+		succeeded        int
+		failed           int
+		attemptDurations = make([]time.Duration, 0, len(unique))
+	)
+	sem := make(chan struct{}, limit)
+	recordProgress := func(success bool) {
+		progressMu.Lock()
+		defer progressMu.Unlock()
+		completed++
+		if success {
+			succeeded++
+		} else {
+			failed++
+		}
+		emitUploadProgress(
+			ctx,
+			progressTarget,
+			api.ImageUploadProgressRunning,
+			completed,
+			succeeded,
+			failed,
+			"Uploading images.",
+		)
+	}
+
+dispatchLoop:
+	for idx, candidate := range unique {
+		if err := ctx.Err(); err != nil {
+			break
+		}
+		select {
+		case <-ctx.Done():
+			break dispatchLoop
+		case sem <- struct{}{}:
+		}
+		if err := ctx.Err(); err != nil {
+			<-sem
+			break
+		}
+		wg.Go(func() {
+			defer func() { <-sem }()
+			if err := ctx.Err(); err != nil {
+				mu.Lock()
+				failures = append(failures, err.Error())
+				mu.Unlock()
+				recordProgress(false)
+				return
+			}
+			fileName := filepath.Base(candidate.Path)
+			s.logger.Debugf("image hosting: uploading image file=%s host=%s tracker=%s size_kb=%.2f", fileName, normalizedHost, logTracker, float64(candidate.SizeBytes)/1024.0)
+
+			// Add detailed debug logging for imgbox
+			if normalizedHost == "imgbox" {
+				s.logger.Debugf("imgbox: starting upload for %s", fileName)
+				s.logger.Tracef("imgbox: file path: %s", candidate.Path)
+				s.logger.Tracef("imgbox: file size: %d bytes", candidate.SizeBytes)
+			}
+
+			uploadStartTime := time.Now()
+			uploaded, err := uploader.Upload(ctx, candidate.Path)
+			uploadDuration := time.Since(uploadStartTime)
+			mu.Lock()
+			attemptDurations = append(attemptDurations, uploadDuration)
+			mu.Unlock()
+
+			if normalizedHost == "imgbox" {
+				if err != nil {
+					s.logger.Debugf("imgbox: upload failed file=%s duration=%v err=%s", fileName, uploadDuration, redaction.RedactValue(err.Error(), nil))
+				} else {
+					s.logger.Debugf("imgbox: upload succeeded file=%s duration=%v", fileName, uploadDuration)
+					s.logger.Tracef("imgbox: thumbnail URL: %s", uploaded.ImgURL)
+					s.logger.Tracef("imgbox: original URL: %s", uploaded.RawURL)
+					s.logger.Tracef("imgbox: image URL: %s", uploaded.WebURL)
+				}
+			}
+
+			if err != nil {
+				s.logger.Warnf("image hosting: upload failed file=%s host=%s tracker=%s err=%s", fileName, normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
+				mu.Lock()
+				failures = append(failures, fmt.Sprintf("image upload %s: %v", fileName, err))
+				mu.Unlock()
+				recordProgress(false)
+				return
+			}
+			if strings.TrimSpace(uploaded.RawURL) == "" {
+				s.logger.Warnf("image hosting: missing raw URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
+				mu.Lock()
+				failures = append(failures, fmt.Sprintf("image upload %s: missing raw url", fileName))
+				mu.Unlock()
+				recordProgress(false)
+				return
+			}
+			if strings.TrimSpace(uploaded.ImgURL) == "" {
+				s.logger.Tracef("image hosting: using raw URL as img URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
+				uploaded.ImgURL = uploaded.RawURL
+			}
+			if strings.TrimSpace(uploaded.WebURL) == "" {
+				s.logger.Tracef("image hosting: using raw URL as web URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
+				uploaded.WebURL = uploaded.RawURL
+			}
+			mu.Lock()
+			results = append(results, indexedUploadResult{
+				index: idx,
+				link: api.UploadedImageLink{
+					SourcePath: meta.SourcePath,
+					ImagePath:  candidate.Path,
+					Host:       normalizedHost,
+					UsageScope: normalizedScope,
+					ImgURL:     strings.TrimSpace(uploaded.ImgURL),
+					RawURL:     strings.TrimSpace(uploaded.RawURL),
+					WebURL:     strings.TrimSpace(uploaded.WebURL),
+					SizeBytes:  candidate.SizeBytes,
+					UploadedAt: time.Now().UTC(),
+				},
+			})
+			mu.Unlock()
+			recordProgress(true)
+			s.logger.Debugf("image hosting: successfully uploaded file=%s host=%s tracker=%s duration=%v", fileName, normalizedHost, logTracker, uploadDuration)
+		})
+	}
+
+	wg.Wait()
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
+	}
+
+	totalDuration := time.Since(uploadStart)
+	orderedResults := orderedUploadResults(results)
+	timing := summarizeUploadTiming(attemptDurations, len(orderedResults), len(failures))
+	s.logger.Infof(
+		"image hosting: completed uploads host=%s tracker=%s wall_duration=%v mean_attempt_duration=%v attempts=%d succeeded=%d unsuccessful=%d",
+		normalizedHost,
+		logTracker,
+		totalDuration,
+		timing.MeanAttemptDuration,
+		timing.Attempts,
+		timing.Succeeded,
+		timing.Failed,
+	)
+
+	if s.repo != nil && len(orderedResults) > 0 {
+		s.logger.Tracef("image hosting: persisting upload records count=%d host=%s tracker=%s", len(orderedResults), normalizedHost, logTracker)
+		if err := s.repo.SaveUploadedImages(ctx, meta.SourcePath, normalizedHost, orderedResults); err != nil {
+			s.logger.Errorf(
+				"image hosting: failed to save upload records host=%s tracker=%s err=%s",
+				normalizedHost,
+				logTracker,
+				redaction.RedactValue(err.Error(), nil),
+			)
+			emitUploadProgress(
+				ctx,
+				progressTarget,
+				api.ImageUploadProgressFailed,
+				completed,
+				succeeded,
+				failed,
+				"Uploaded images could not be saved.",
+			)
+			return nil, fmt.Errorf("image hosting: %w", err)
+		}
+		summary, err := syncScreenshotSlotVariants(ctx, s.repo, meta.SourcePath, orderedResults)
+		if err != nil {
+			s.logger.Warnf(
+				"image hosting: failed to sync screenshot slot variants host=%s tracker=%s err=%s",
+				normalizedHost,
+				logTracker,
+				redaction.RedactValue(err.Error(), nil),
+			)
+		} else if summary.FallbackMatched > 0 {
+			s.logger.Debugf(
+				"image hosting: applied ordered screenshot slot fallback host=%s tracker=%s matched=%d",
+				normalizedHost,
+				logTracker,
+				summary.FallbackMatched,
+			)
+		}
+		s.logger.Debugf("image hosting: upload records persisted successfully host=%s tracker=%s", normalizedHost, logTracker)
+	}
+
+	if len(failures) > 0 {
+		s.logger.Warnf(
+			"image hosting: upload batch completed host=%s tracker=%s failures=%d successes=%d",
+			normalizedHost,
+			logTracker,
+			len(failures),
+			len(orderedResults),
+		)
+		emitUploadProgress(
+			ctx,
+			progressTarget,
+			api.ImageUploadProgressFailed,
+			completed,
+			succeeded,
+			failed,
+			fmt.Sprintf("%d of %d host uploads failed.", failed, len(unique)),
+		)
+		return orderedResults, fmt.Errorf("image hosting: %d of %d uploads failed: %s", len(failures), len(unique), strings.Join(failures, "; "))
+	}
+
+	emitUploadProgress(
+		ctx,
+		progressTarget,
+		api.ImageUploadProgressCompleted,
+		completed,
+		succeeded,
+		0,
+		"Host upload complete.",
+	)
+	return orderedResults, nil
+}
+
+type uploadTimingSummary struct {
+	Attempts            int
+	Succeeded           int
+	Failed              int
+	MeanAttemptDuration time.Duration
+}
+
+// summarizeUploadTiming reports actual completed uploader-call timing rather
+// than deriving request latency from concurrent wall time.
+func summarizeUploadTiming(durations []time.Duration, succeeded int, failed int) uploadTimingSummary {
+	summary := uploadTimingSummary{
+		Attempts:  len(durations),
+		Succeeded: max(0, succeeded),
+		Failed:    max(0, failed),
+	}
+	if len(durations) == 0 {
+		return summary
+	}
+	var total time.Duration
+	for _, duration := range durations {
+		total += duration
+	}
+	summary.MeanAttemptDuration = total / time.Duration(len(durations))
+	return summary
+}
+
+func emitUploadProgress(
+	ctx context.Context,
+	target api.ImageUploadProgressTarget,
+	status api.ImageUploadProgressStatus,
+	completed int,
+	succeeded int,
+	failed int,
+	message string,
+) {
+	total := max(0, target.Total)
+	api.EmitImageUploadProgress(ctx, api.ImageUploadProgressUpdate{
+		AttemptID:  target.AttemptID,
+		Host:       target.Host,
+		UsageScope: target.UsageScope,
+		Trackers:   append([]string(nil), target.Trackers...),
+		Fallback:   target.Fallback,
+		Completed:  max(0, min(completed, total)),
+		Total:      total,
+		Succeeded:  max(0, succeeded),
+		Failed:     max(0, failed),
+		Reused:     max(0, min(target.Reused, total)),
+		Status:     status,
+		Message:    strings.TrimSpace(message),
+	})
+}
+
+// uploadBatch dispatches candidates through the uploader's supported batch
+// contract. Named HDB batches retain image purpose so gallery partitioning can
+// preserve input-to-result ordering.
+func uploadBatch(ctx context.Context, batch batchUploader, meta api.ImageHostingSubject, host string, images []imageCandidate) ([]uploadResult, error) {
+	imagePaths := make([]string, 0, len(images))
+	for _, image := range images {
+		imagePaths = append(imagePaths, image.Path)
+	}
+	if named, ok := batch.(namedBatchUploader); ok {
+		if strings.EqualFold(strings.TrimSpace(host), "hdb") {
+			return uploadHDBBatchByPurpose(ctx, named, meta, images)
+		}
+		results, err := named.UploadBatchWithName(ctx, imagePaths, resolveGalleryName(meta))
+		if err != nil {
+			return nil, fmt.Errorf("image hosting: upload named batch: %w", err)
+		}
+		return results, nil
+	}
+	results, err := batch.UploadBatch(ctx, imagePaths)
+	if err != nil {
+		return nil, fmt.Errorf("image hosting: upload batch: %w", err)
+	}
+	return results, nil
+}
+
+// uploadHDBBatchByPurpose uploads normal images to the release gallery and menu
+// images to a suffixed disc-menu gallery. Each candidate is uploaded once, and
+// results are restored to candidate order across both batches.
+func uploadHDBBatchByPurpose(ctx context.Context, batch namedBatchUploader, meta api.ImageHostingSubject, images []imageCandidate) ([]uploadResult, error) {
+	type indexedImage struct {
+		index int
+		path  string
+	}
+	normal := make([]indexedImage, 0, len(images))
+	menus := make([]indexedImage, 0, len(images))
+	for idx, image := range images {
+		item := indexedImage{index: idx, path: image.Path}
+		if image.Purpose == api.ScreenshotPurposeMenu {
+			menus = append(menus, item)
+			continue
+		}
+		normal = append(normal, item)
+	}
+
+	results := make([]uploadResult, len(images))
+	uploadGroup := func(group []indexedImage, galleryName string) error {
+		if len(group) == 0 {
+			return nil
+		}
+		paths := make([]string, 0, len(group))
+		for _, image := range group {
+			paths = append(paths, image.path)
+		}
+		uploaded, err := batch.UploadBatchWithName(ctx, paths, galleryName)
+		if err != nil {
+			return fmt.Errorf("image hosting: upload named batch: %w", err)
+		}
+		if len(uploaded) != len(group) {
+			return fmt.Errorf("image hosting: HDB batch returned %d images for %d uploads", len(uploaded), len(group))
+		}
+		for idx, image := range group {
+			results[image.index] = uploaded[idx]
+		}
+		return nil
+	}
+
+	galleryName := resolveGalleryName(meta)
+	if err := uploadGroup(normal, galleryName); err != nil {
+		return nil, err
+	}
+	if err := uploadGroup(menus, galleryName+" Disc Menus"); err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+
+func resolveGalleryName(meta api.ImageHostingSubject) string {
+	for _, candidate := range []string{strings.TrimSpace(meta.GalleryName), pathutil.Base(meta.SourcePath)} {
+		if candidate != "" {
+			return candidate
+		}
+	}
+	return "upbrr"
+}
+
+// imageHostLogTracker returns the tracker that owns a private image host, or
+// "shared" for hosts usable outside one tracker. Logging both host and tracker
+// keeps tracker-owned rehosting identifiable in operator output.
+func (s *Service) imageHostLogTracker(host string) string {
+	if tracker := trackers.TrackerForOwnedImageHost(s.registry, host); tracker != "" {
+		return tracker
+	}
+	return "shared"
+}
+
+// imagePurposeCounts summarizes the HDB gallery partition without exposing
+// local image paths in operator-visible progress logs.
+func imagePurposeCounts(images []imageCandidate) (normal int, menus int) {
+	for _, image := range images {
+		if image.Purpose == api.ScreenshotPurposeMenu {
+			menus++
+			continue
+		}
+		normal++
+	}
+	return normal, menus
+}
+
+type imageCandidate struct {
+	Path      string
+	Purpose   api.ScreenshotPurpose
+	SizeBytes int64
+}
+
+type indexedUploadResult struct {
+	index int
+	link  api.UploadedImageLink
+}
+
+func orderedUploadResults(results []indexedUploadResult) []api.UploadedImageLink {
+	if len(results) == 0 {
+		return nil
+	}
+	sort.Slice(results, func(i, j int) bool { return results[i].index < results[j].index })
+	ordered := make([]api.UploadedImageLink, 0, len(results))
+	for _, result := range results {
+		ordered = append(ordered, result.link)
+	}
+	return ordered
+}
+
+func isAllowedImageExt(path string) bool {
+	switch strings.ToLower(filepath.Ext(path)) {
+	case ".png", ".jpg", ".jpeg", ".webp":
+		return true
+	default:
+		return false
+	}
+}
+
+func syncScreenshotSlotVariants(
+	ctx context.Context,
+	repo repository,
+	sourcePath string,
+	uploaded []api.UploadedImageLink,
+) (trackers.SlotUploadAttachmentResult, error) {
+	if repo == nil || len(uploaded) == 0 || strings.TrimSpace(sourcePath) == "" {
+		return trackers.SlotUploadAttachmentResult{}, nil
+	}
+	slots, err := repo.ListScreenshotSlotsByPath(ctx, sourcePath)
+	if err != nil {
+		return trackers.SlotUploadAttachmentResult{}, fmt.Errorf("image hosting: %w", err)
+	}
+	if len(slots) == 0 {
+		return trackers.SlotUploadAttachmentResult{}, nil
+	}
+	summary := trackers.ApplyUploadedVariantsToSlots(slots, uploaded)
+	if summary.FallbackMatched > 0 {
+		if err := repo.ReplaceScreenshotSlots(ctx, sourcePath, slots); err != nil {
+			return summary, fmt.Errorf("image hosting: %w", err)
+		}
+	}
+	slotByPath := make(map[string]int, len(slots))
+	for _, slot := range slots {
+		if pathValue := strings.TrimSpace(slot.ImagePath); pathValue != "" {
+			slotByPath[pathValue] = slot.SlotOrder
+		}
+	}
+	variants := make([]api.ScreenshotSlotVariant, 0, len(uploaded))
+	for _, image := range uploaded {
+		slotOrder, ok := slotByPath[strings.TrimSpace(image.ImagePath)]
+		if !ok {
+			continue
+		}
+		variants = append(variants, api.ScreenshotSlotVariant{
+			SourcePath: sourcePath,
+			SlotOrder:  slotOrder,
+			Host:       strings.TrimSpace(image.Host),
+			UsageScope: strings.TrimSpace(image.UsageScope),
+			ImagePath:  strings.TrimSpace(image.ImagePath),
+			ImgURL:     strings.TrimSpace(image.ImgURL),
+			RawURL:     strings.TrimSpace(image.RawURL),
+			WebURL:     strings.TrimSpace(image.WebURL),
+			UploadedAt: image.UploadedAt,
+		})
+	}
+	if err := repo.UpsertScreenshotSlotVariants(ctx, sourcePath, variants); err != nil {
+		return summary, fmt.Errorf("image hosting: upsert screenshot slot variants: %w", err)
+	}
+	return summary, nil
+}
diff --git a/internal/imagehosting/service_test.go b/internal/imagehosting/service_test.go
new file mode 100644
index 00000000..440acc52
--- /dev/null
+++ b/internal/imagehosting/service_test.go
@@ -0,0 +1,799 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package imagehosting
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type recordingRepo struct {
+	savedHost   string
+	savedPath   string
+	savedImages []api.UploadedImageLink
+	screens     []api.Screenshot
+	selections  []api.ScreenshotFinalSelection
+	uploads     []api.UploadedImageLink
+}
+
+func imageHostingTestRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
+func (r *recordingRepo) SaveUploadedImages(_ context.Context, path string, host string, images []api.UploadedImageLink) error {
+	r.savedHost = host
+	r.savedPath = path
+	r.savedImages = images
+	return nil
+}
+
+func (r *recordingRepo) GetByPath(context.Context, string) (api.FileMetadata, error) {
+	return api.FileMetadata{}, nil
+}
+func (r *recordingRepo) Save(context.Context, api.FileMetadata) error { return nil }
+func (r *recordingRepo) GetExternalIdentity(context.Context, string) (api.ExternalIdentity, error) {
+	return api.ExternalIdentity{}, nil
+}
+func (r *recordingRepo) SaveExternalIdentity(context.Context, api.ExternalIdentity) error { return nil }
+func (r *recordingRepo) GetExternalMetadata(context.Context, string) (api.SourceScopedMetadata, error) {
+	return api.SourceScopedMetadata{}, nil
+}
+func (r *recordingRepo) SaveExternalMetadata(context.Context, api.SourceScopedMetadata) error {
+	return nil
+}
+func (r *recordingRepo) GetDVDMediaInfo(context.Context, string) (api.DVDMediaInfo, error) {
+	return api.DVDMediaInfo{}, nil
+}
+func (r *recordingRepo) SaveDVDMediaInfo(context.Context, api.DVDMediaInfo) error { return nil }
+func (r *recordingRepo) GetReleaseNameOverrides(context.Context, string) (api.ReleaseNameOverrides, error) {
+	return api.ReleaseNameOverrides{}, nil
+}
+func (r *recordingRepo) SaveReleaseNameOverrides(context.Context, string, api.ReleaseNameOverrides) error {
+	return nil
+}
+func (r *recordingRepo) DeleteReleaseNameOverrides(context.Context, string) error { return nil }
+func (r *recordingRepo) ListHistoryEntries(context.Context) ([]api.HistoryEntry, error) {
+	return nil, nil
+}
+func (r *recordingRepo) ListUploadHistoryByPath(context.Context, string) ([]api.UploadRecord, error) {
+	return nil, nil
+}
+func (r *recordingRepo) ListPendingUploads(context.Context) ([]api.UploadRecord, error) {
+	return nil, nil
+}
+func (r *recordingRepo) CreateUploadRecord(context.Context, api.UploadRecord) error { return nil }
+func (r *recordingRepo) UpdateLatestUploadRecordStatus(context.Context, string, string, string) error {
+	return nil
+}
+func (r *recordingRepo) SaveTrackerRuleFailures(context.Context, string, string, []api.TrackerRuleFailure) error {
+	return nil
+}
+func (r *recordingRepo) ListTrackerRuleFailuresByPath(context.Context, string) ([]api.TrackerRuleFailure, error) {
+	return nil, nil
+}
+func (r *recordingRepo) GetTrackerTimestamp(context.Context, string) (time.Time, error) {
+	return time.Time{}, nil
+}
+func (r *recordingRepo) SaveTrackerTimestamp(context.Context, api.TrackerTimestamp) error { return nil }
+func (r *recordingRepo) SaveTrackerMetadata(context.Context, api.TrackerMetadata) error   { return nil }
+func (r *recordingRepo) ListTrackerMetadataByPath(context.Context, string) ([]api.TrackerMetadata, error) {
+	return nil, nil
+}
+func (r *recordingRepo) SaveScreenshot(context.Context, api.Screenshot) error { return nil }
+func (r *recordingRepo) ListScreenshotsByPath(context.Context, string) ([]api.Screenshot, error) {
+	return append([]api.Screenshot(nil), r.screens...), nil
+}
+func (r *recordingRepo) DeleteScreenshot(context.Context, string) error { return nil }
+func (r *recordingRepo) SaveFinalSelections(context.Context, string, []api.ScreenshotFinalSelection) error {
+	return nil
+}
+func (r *recordingRepo) ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error) {
+	return append([]api.ScreenshotFinalSelection(nil), r.selections...), nil
+}
+func (r *recordingRepo) DeleteFinalSelection(context.Context, string) error { return nil }
+func (r *recordingRepo) ReplaceScreenshotSlots(context.Context, string, []api.ScreenshotSlot) error {
+	return nil
+}
+func (r *recordingRepo) ListScreenshotSlotsByPath(context.Context, string) ([]api.ScreenshotSlot, error) {
+	return nil, nil
+}
+func (r *recordingRepo) UpsertScreenshotSlotVariants(context.Context, string, []api.ScreenshotSlotVariant) error {
+	return nil
+}
+func (r *recordingRepo) ListUploadedImagesByPath(context.Context, string) ([]api.UploadedImageLink, error) {
+	return append([]api.UploadedImageLink(nil), r.uploads...), nil
+}
+func (r *recordingRepo) DeleteUploadedImage(context.Context, string, string, string) error {
+	return nil
+}
+func (r *recordingRepo) GetDescriptionOverride(context.Context, string, string) (api.DescriptionOverride, error) {
+	return api.DescriptionOverride{}, nil
+}
+func (r *recordingRepo) ListDescriptionOverridesByPath(context.Context, string) ([]api.DescriptionOverride, error) {
+	return nil, nil
+}
+func (r *recordingRepo) SaveDescriptionOverride(context.Context, api.DescriptionOverride) error {
+	return nil
+}
+func (r *recordingRepo) DeleteDescriptionOverride(context.Context, string, string) error { return nil }
+func (r *recordingRepo) GetPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
+	return api.PlaylistSelection{}, nil
+}
+func (r *recordingRepo) SavePlaylistSelection(context.Context, string, []string, bool) error {
+	return nil
+}
+func (r *recordingRepo) DeletePlaylistSelection(context.Context, string) error { return nil }
+func (r *recordingRepo) ListStoredReleasePaths(context.Context) ([]string, error) {
+	return nil, nil
+}
+func (r *recordingRepo) PurgeContentData(context.Context, string) error { return nil }
+
+type fakeUploader struct {
+	result uploadResult
+	err    error
+	mu     sync.Mutex
+	calls  []string
+}
+
+func (u *fakeUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
+	u.mu.Lock()
+	u.calls = append(u.calls, imagePath)
+	u.mu.Unlock()
+	return u.result, u.err
+}
+
+type selectiveUploader struct {
+	mu      sync.Mutex
+	results map[string]uploadResult
+	errs    map[string]error
+	calls   []string
+}
+
+func (u *selectiveUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
+	u.mu.Lock()
+	u.calls = append(u.calls, imagePath)
+	err := u.errs[imagePath]
+	result := u.results[imagePath]
+	u.mu.Unlock()
+	if err != nil {
+		return uploadResult{}, err
+	}
+	return result, nil
+}
+
+type blockingUploader struct {
+	mu          sync.Mutex
+	calls       []string
+	firstCallCh chan struct{}
+}
+
+func (u *blockingUploader) Upload(ctx context.Context, imagePath string) (uploadResult, error) {
+	u.mu.Lock()
+	u.calls = append(u.calls, imagePath)
+	if len(u.calls) == 1 && u.firstCallCh != nil {
+		close(u.firstCallCh)
+		u.firstCallCh = nil
+	}
+	u.mu.Unlock()
+
+	<-ctx.Done()
+	return uploadResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+}
+
+type fakeBatchUploader struct {
+	err          error
+	mu           sync.Mutex
+	calls        []string
+	batches      [][]string
+	galleryNames []string
+}
+
+type recordingImageHostLogger struct {
+	mu       sync.Mutex
+	messages []string
+}
+
+func (l *recordingImageHostLogger) record(format string, args ...any) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.messages = append(l.messages, fmt.Sprintf(format, args...))
+}
+
+func (l *recordingImageHostLogger) Tracef(format string, args ...any) {
+	l.record(format, args...)
+}
+
+func (l *recordingImageHostLogger) Debugf(format string, args ...any) {
+	l.record(format, args...)
+}
+
+func (l *recordingImageHostLogger) Infof(format string, args ...any) {
+	l.record(format, args...)
+}
+
+func (l *recordingImageHostLogger) Warnf(format string, args ...any) {
+	l.record(format, args...)
+}
+
+func (l *recordingImageHostLogger) Errorf(format string, args ...any) {
+	l.record(format, args...)
+}
+
+func (l *recordingImageHostLogger) contains(value string) bool {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	for _, message := range l.messages {
+		if strings.Contains(message, value) {
+			return true
+		}
+	}
+	return false
+}
+
+func (u *fakeBatchUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
+	u.mu.Lock()
+	u.calls = append(u.calls, imagePath)
+	u.mu.Unlock()
+	if u.err != nil {
+		return uploadResult{}, u.err
+	}
+	return uploadResult{}, nil
+}
+
+func (u *fakeBatchUploader) UploadBatch(_ context.Context, imagePaths []string) ([]uploadResult, error) {
+	u.mu.Lock()
+	u.batches = append(u.batches, append([]string{}, imagePaths...))
+	u.mu.Unlock()
+	return u.resultsFor(imagePaths)
+}
+
+func (u *fakeBatchUploader) UploadBatchWithName(_ context.Context, imagePaths []string, galleryName string) ([]uploadResult, error) {
+	u.mu.Lock()
+	u.batches = append(u.batches, append([]string{}, imagePaths...))
+	u.galleryNames = append(u.galleryNames, galleryName)
+	u.mu.Unlock()
+	return u.resultsFor(imagePaths)
+}
+
+func (u *fakeBatchUploader) resultsFor(imagePaths []string) ([]uploadResult, error) {
+	if u.err != nil {
+		return nil, u.err
+	}
+	results := make([]uploadResult, 0, len(imagePaths))
+	for idx := range imagePaths {
+		suffix := strconv.Itoa(idx)
+		results = append(results, uploadResult{
+			ImgURL: "https://thumb/" + suffix,
+			RawURL: "https://raw/" + suffix,
+			WebURL: "https://web/" + suffix,
+		})
+	}
+	return results, nil
+}
+
+func TestUploadImagesSuccess(t *testing.T) {
+	tmpDir := t.TempDir()
+	imagePath := filepath.Join(tmpDir, "shot-01.png")
+	if err := os.WriteFile(imagePath, []byte("testdata"), 0o644); err != nil {
+		t.Fatalf("write temp file: %v", err)
+	}
+	absPath, err := filepath.Abs(imagePath)
+	if err != nil {
+		t.Fatalf("abs path: %v", err)
+	}
+
+	uploaderStub := &fakeUploader{result: uploadResult{
+		ImgURL: "https://img",
+		RawURL: "https://raw",
+		WebURL: "https://web",
+	}}
+	repo := &recordingRepo{}
+	logger := &recordingImageHostLogger{}
+	service := &Service{
+		cfg:       config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 2}},
+		logger:    logger,
+		repo:      repo,
+		uploaders: map[string]uploader{"test": uploaderStub},
+	}
+
+	meta := api.ImageHostingSubject{SourcePath: "source"}
+	images := []api.ScreenshotImage{{Path: imagePath}}
+	result, err := service.Upload(context.Background(), meta, "test", "tracker:HDB", images)
+	if err != nil {
+		t.Fatalf("Upload returned error: %v", err)
+	}
+	if len(result) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(result))
+	}
+	if result[0].ImagePath != absPath {
+		t.Fatalf("expected image path %q, got %q", absPath, result[0].ImagePath)
+	}
+	if result[0].Host != "test" {
+		t.Fatalf("expected host test, got %q", result[0].Host)
+	}
+	if result[0].UsageScope != "tracker:HDB" {
+		t.Fatalf("expected usage scope tracker:HDB, got %q", result[0].UsageScope)
+	}
+	if repo.savedHost != "test" || repo.savedPath != "source" {
+		t.Fatalf("expected repo save for test/source, got %q/%q", repo.savedHost, repo.savedPath)
+	}
+	if len(repo.savedImages) != 1 {
+		t.Fatalf("expected repo to save 1 image, got %d", len(repo.savedImages))
+	}
+	if repo.savedImages[0].UsageScope != "tracker:HDB" {
+		t.Fatalf("expected repo usage scope tracker:HDB, got %q", repo.savedImages[0].UsageScope)
+	}
+	if !logger.contains("wall_duration=") || !logger.contains("mean_attempt_duration=") ||
+		!logger.contains("attempts=1 succeeded=1 unsuccessful=0") {
+		t.Fatalf("expected actual uploader-call timing fields, got %#v", logger.messages)
+	}
+	if logger.contains(" avg=") {
+		t.Fatalf("unexpected throughput-derived average field: %#v", logger.messages)
+	}
+}
+
+func TestSummarizeUploadTimingIncludesFailedUploaderCalls(t *testing.T) {
+	t.Parallel()
+
+	summary := summarizeUploadTiming([]time.Duration{time.Second, 3 * time.Second, 8 * time.Second}, 1, 2)
+	if summary.Attempts != 3 || summary.Succeeded != 1 || summary.Failed != 2 {
+		t.Fatalf("timing counts = %#v", summary)
+	}
+	if summary.MeanAttemptDuration != 4*time.Second {
+		t.Fatalf("mean attempt duration = %v", summary.MeanAttemptDuration)
+	}
+}
+
+func TestListCandidatesIncludesUploadedOnlyImages(t *testing.T) {
+	imagePath := filepath.Join(t.TempDir(), "tracker-artifact.png")
+	if err := os.WriteFile(imagePath, []byte("testdata"), 0o600); err != nil {
+		t.Fatalf("write image: %v", err)
+	}
+	uploadedAt := time.Now().UTC()
+	repo := &recordingRepo{
+		uploads: []api.UploadedImageLink{{
+			SourcePath: "/tmp/source",
+			ImagePath:  imagePath,
+			Host:       "pixhost",
+			UsageScope: "global",
+			ImgURL:     "https://pixhost/img.png",
+			RawURL:     "https://pixhost/raw.png",
+			WebURL:     "https://pixhost/view",
+			UploadedAt: uploadedAt,
+			SizeBytes:  8,
+		}},
+	}
+	service := &Service{logger: api.NopLogger{}, repo: repo}
+
+	images, err := service.ListCandidates(context.Background(), api.ImageHostingSubject{SourcePath: "/tmp/source"})
+	if err != nil {
+		t.Fatalf("ListCandidates returned error: %v", err)
+	}
+	if len(images) != 1 {
+		t.Fatalf("expected uploaded-only image candidate, got %d", len(images))
+	}
+	if images[0].Path != imagePath || images[0].Host != "pixhost" || images[0].RawURL != "https://pixhost/raw.png" {
+		t.Fatalf("expected uploaded-only candidate details, got %#v", images[0])
+	}
+	if !images[0].UploadedAt.Equal(uploadedAt) {
+		t.Fatalf("expected uploaded timestamp, got %v", images[0].UploadedAt)
+	}
+}
+
+func TestListCandidatesPopulatesGeneratedAndManualMenuPurpose(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	generatedPath := filepath.Join(root, "generated-menu.png")
+	manualPath := filepath.Join(root, "manual-menu.png")
+	for _, imagePath := range []string{generatedPath, manualPath} {
+		if err := os.WriteFile(imagePath, []byte("synthetic image"), 0o600); err != nil {
+			t.Fatalf("write image: %v", err)
+		}
+	}
+	repo := &recordingRepo{
+		screens: []api.Screenshot{{
+			SourcePath: "/tmp/source",
+			ImagePath:  generatedPath,
+			Purpose:    api.ScreenshotPurposeMenu,
+		}},
+		selections: []api.ScreenshotFinalSelection{
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  generatedPath,
+				Order:      0,
+				Source:     api.ScreenshotSelectionSourceDVDMenu,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  manualPath,
+				Order:      1,
+				Source:     api.ScreenshotSelectionSourceMenu,
+			},
+		},
+	}
+	service := &Service{logger: api.NopLogger{}, repo: repo}
+
+	images, err := service.ListCandidates(context.Background(), api.ImageHostingSubject{SourcePath: "/tmp/source"})
+	if err != nil {
+		t.Fatalf("list candidates: %v", err)
+	}
+	if len(images) != 2 {
+		t.Fatalf("candidate count = %d, want 2", len(images))
+	}
+	for _, imageValue := range images {
+		if imageValue.Purpose != api.ScreenshotPurposeMenu {
+			t.Fatalf("candidate purpose = %q for %q", imageValue.Purpose, filepath.Base(imageValue.Path))
+		}
+	}
+}
+
+func TestUploadImagesUnsupportedHost(t *testing.T) {
+	service := &Service{logger: api.NopLogger{}, uploaders: map[string]uploader{}}
+	meta := api.ImageHostingSubject{SourcePath: "source"}
+	_, err := service.Upload(context.Background(), meta, "missing", "global", []api.ScreenshotImage{{Path: "x.png"}})
+	if err == nil {
+		t.Fatal("expected error for unsupported host")
+	}
+}
+
+func TestUploadImagesRejectsTrackerOwnedHostOutsideOwnerScope(t *testing.T) {
+	service := &Service{
+		logger:    api.NopLogger{},
+		uploaders: map[string]uploader{"hdb": &fakeUploader{}},
+		registry:  imageHostingTestRegistry(t),
+	}
+	tmp, err := os.CreateTemp(t.TempDir(), "imagehosting-owned-host-*.png")
+	if err != nil {
+		t.Fatalf("create temp file: %v", err)
+	}
+	tmpPath := tmp.Name()
+	if err := tmp.Close(); err != nil {
+		t.Fatalf("close temp file: %v", err)
+	}
+	meta := api.ImageHostingSubject{SourcePath: "source"}
+	_, err = service.Upload(context.Background(), meta, "hdb", "global", []api.ScreenshotImage{{Path: tmpPath}})
+	if err == nil {
+		t.Fatal("expected tracker-owned host outside owner scope to fail")
+	}
+	if !strings.Contains(err.Error(), "scoped to tracker HDB") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestUploadImagesMissingFile(t *testing.T) {
+	uploaderStub := &fakeUploader{result: uploadResult{
+		ImgURL: "https://img",
+		RawURL: "https://raw",
+		WebURL: "https://web",
+	}}
+	service := &Service{logger: api.NopLogger{}, uploaders: map[string]uploader{"test": uploaderStub}}
+	meta := api.ImageHostingSubject{SourcePath: "source"}
+	_, err := service.Upload(context.Background(), meta, "test", "global", []api.ScreenshotImage{{Path: "missing.png"}})
+	if err == nil {
+		t.Fatal("expected error for missing file")
+	}
+	if len(uploaderStub.calls) != 0 {
+		t.Fatalf("expected uploader not called, got %d", len(uploaderStub.calls))
+	}
+}
+
+func TestImgboxUploaderInRegistry(t *testing.T) {
+	cfg := config.Config{}
+	registry := newUploaderRegistry(cfg, nil, trackers.NewRegistry())
+	if _, ok := registry["imgbox"]; !ok {
+		t.Fatal("imgbox not found in uploader registry")
+	}
+}
+
+func TestUploadImagesUsesBatchUploader(t *testing.T) {
+	tmpDir := t.TempDir()
+	firstPath := filepath.Join(tmpDir, "shot-01.png")
+	secondPath := filepath.Join(tmpDir, "shot-02.png")
+	for _, path := range []string{firstPath, secondPath} {
+		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
+			t.Fatalf("write temp file: %v", err)
+		}
+	}
+
+	uploaderStub := &fakeBatchUploader{}
+	service := &Service{
+		cfg:       config.Config{},
+		logger:    api.NopLogger{},
+		repo:      &recordingRepo{},
+		uploaders: map[string]uploader{"hdb": uploaderStub},
+		registry:  imageHostingTestRegistry(t),
+	}
+
+	_, err := service.Upload(context.Background(), api.ImageHostingSubject{
+		SourcePath:  "source",
+		GalleryName: "Movie.2026.2160p.WEB-DL",
+	}, "hdb", "tracker:HDB", []api.ScreenshotImage{
+		{Path: firstPath},
+		{Path: secondPath},
+	})
+	if err != nil {
+		t.Fatalf("Upload returned error: %v", err)
+	}
+	if len(uploaderStub.batches) != 1 {
+		t.Fatalf("expected 1 batch call, got %d", len(uploaderStub.batches))
+	}
+	if len(uploaderStub.batches[0]) != 2 {
+		t.Fatalf("expected 2 files in batch, got %d", len(uploaderStub.batches[0]))
+	}
+	if len(uploaderStub.calls) != 0 {
+		t.Fatalf("expected single-image Upload not to be used, got %d calls", len(uploaderStub.calls))
+	}
+	if len(uploaderStub.galleryNames) != 1 {
+		t.Fatalf("expected 1 gallery name call, got %d", len(uploaderStub.galleryNames))
+	}
+	if uploaderStub.galleryNames[0] != "Movie.2026.2160p.WEB-DL" {
+		t.Fatalf("expected content gallery name, got %q", uploaderStub.galleryNames[0])
+	}
+}
+
+func TestUploadImagesSeparatesHDBMenuGalleryWithoutDuplicates(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	firstPath := filepath.Join(tmpDir, "screen-01.png")
+	menuPath := filepath.Join(tmpDir, "menu-01.png")
+	secondPath := filepath.Join(tmpDir, "screen-02.png")
+	for _, imagePath := range []string{firstPath, menuPath, secondPath} {
+		if err := os.WriteFile(imagePath, []byte("testdata"), 0o600); err != nil {
+			t.Fatalf("write temp file: %v", err)
+		}
+	}
+
+	uploaderStub := &fakeBatchUploader{}
+	logger := &recordingImageHostLogger{}
+	service := &Service{
+		cfg:       config.Config{},
+		logger:    logger,
+		repo:      &recordingRepo{},
+		uploaders: map[string]uploader{"hdb": uploaderStub},
+		registry:  imageHostingTestRegistry(t),
+	}
+
+	result, err := service.Upload(context.Background(), api.ImageHostingSubject{
+		SourcePath:  filepath.Join(tmpDir, "Example.Release.2026.2160p.WEB-DL-GRP.mkv"),
+		GalleryName: "Example.Release.2026.2160p.WEB-DL-GRP",
+	}, "hdb", "tracker:HDB", []api.ScreenshotImage{
+		{Path: firstPath, Purpose: api.ScreenshotPurposeFinal},
+		{Path: menuPath, Purpose: api.ScreenshotPurposeMenu},
+		{Path: secondPath, Purpose: api.ScreenshotPurposeFinal},
+	})
+	if err != nil {
+		t.Fatalf("upload images: %v", err)
+	}
+	if len(uploaderStub.batches) != 2 {
+		t.Fatalf("expected normal and menu HDB batches, got %#v", uploaderStub.batches)
+	}
+	if !slices.Equal(uploaderStub.batches[0], []string{firstPath, secondPath}) {
+		t.Fatalf("expected normal gallery to exclude menu image, got %#v", uploaderStub.batches[0])
+	}
+	if !slices.Equal(uploaderStub.batches[1], []string{menuPath}) {
+		t.Fatalf("expected menu gallery to contain only menu image, got %#v", uploaderStub.batches[1])
+	}
+	if !slices.Equal(uploaderStub.galleryNames, []string{
+		"Example.Release.2026.2160p.WEB-DL-GRP",
+		"Example.Release.2026.2160p.WEB-DL-GRP Disc Menus",
+	}) {
+		t.Fatalf("unexpected HDB gallery names: %#v", uploaderStub.galleryNames)
+	}
+	if len(result) != 3 || result[0].ImagePath != firstPath || result[1].ImagePath != menuPath || result[2].ImagePath != secondPath {
+		t.Fatalf("expected upload results in input order, got %#v", result)
+	}
+	if !logger.contains("host=hdb tracker=HDB") {
+		t.Fatal("expected HDB tracker identity in image-host logs")
+	}
+	if !logger.contains("batches=2 images=3 wall_duration=") {
+		t.Fatalf("expected batch wall timing and counts, got %#v", logger.messages)
+	}
+	if logger.contains("mean_attempt_duration") {
+		t.Fatalf("batch logs must not claim per-image timing: %#v", logger.messages)
+	}
+}
+
+func TestImageHostLogTrackerNamesEveryOwnedHost(t *testing.T) {
+	t.Parallel()
+	service := &Service{registry: imageHostingTestRegistry(t)}
+
+	for host, expected := range map[string]string{
+		"hdb":      "HDB",
+		"lostimg":  "LST",
+		"reelflix": "RF",
+		"thr":      "THR",
+	} {
+		if got := service.imageHostLogTracker(host); got != expected {
+			t.Errorf("host %q tracker = %q, want %q", host, got, expected)
+		}
+	}
+	if got := service.imageHostLogTracker("imgbox"); got != "shared" {
+		t.Errorf("shared host tracker = %q, want shared", got)
+	}
+}
+
+func TestUploadImagesPersistsSuccessfulConcurrentUploadsOnPartialFailure(t *testing.T) {
+	tmpDir := t.TempDir()
+	firstPath := filepath.Join(tmpDir, "shot-01.png")
+	secondPath := filepath.Join(tmpDir, "shot-02.png")
+	for _, path := range []string{firstPath, secondPath} {
+		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
+			t.Fatalf("write temp file: %v", err)
+		}
+	}
+
+	uploaderStub := &selectiveUploader{
+		results: map[string]uploadResult{
+			firstPath: {
+				ImgURL: "https://img/1",
+				RawURL: "https://raw/1",
+				WebURL: "https://web/1",
+			},
+		},
+		errs: map[string]error{
+			secondPath: errors.New("temporary network failure"),
+		},
+	}
+	repo := &recordingRepo{}
+	service := &Service{
+		cfg: config.Config{
+			ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 2},
+		},
+		logger:    api.NopLogger{},
+		repo:      repo,
+		uploaders: map[string]uploader{"test": uploaderStub},
+	}
+
+	result, err := service.Upload(context.Background(), api.ImageHostingSubject{SourcePath: "source"}, "test", "global", []api.ScreenshotImage{
+		{Path: firstPath},
+		{Path: secondPath},
+	})
+	if err == nil {
+		t.Fatal("expected partial failure error")
+	}
+	if len(result) != 1 {
+		t.Fatalf("expected 1 successful upload result, got %d", len(result))
+	}
+	if len(repo.savedImages) != 1 {
+		t.Fatalf("expected repo to persist 1 successful upload, got %d", len(repo.savedImages))
+	}
+	if repo.savedImages[0].ImagePath == secondPath {
+		t.Fatalf("expected failed upload not to be persisted: %#v", repo.savedImages)
+	}
+}
+
+func TestUploadImagesReportsAbsoluteConcurrentProgress(t *testing.T) {
+	tmpDir := t.TempDir()
+	firstPath := filepath.Join(tmpDir, "shot-01.png")
+	secondPath := filepath.Join(tmpDir, "shot-02.png")
+	for _, imagePath := range []string{firstPath, secondPath} {
+		if err := os.WriteFile(imagePath, []byte("synthetic image"), 0o600); err != nil {
+			t.Fatalf("write temp file: %v", err)
+		}
+	}
+	uploaderStub := &selectiveUploader{
+		results: map[string]uploadResult{
+			firstPath: {RawURL: "https://example.invalid/raw/1"},
+		},
+		errs: map[string]error{secondPath: errors.New("synthetic host failure")},
+	}
+	service := &Service{
+		cfg:       config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 2}},
+		logger:    api.NopLogger{},
+		uploaders: map[string]uploader{"example": uploaderStub},
+	}
+	var (
+		mu      sync.Mutex
+		updates []api.ImageUploadProgressUpdate
+	)
+	ctx := api.WithImageUploadProgressReporter(context.Background(), func(update api.ImageUploadProgressUpdate) {
+		mu.Lock()
+		updates = append(updates, update)
+		mu.Unlock()
+	})
+	ctx = api.WithImageUploadProgressTarget(ctx, api.ImageUploadProgressTarget{
+		AttemptID:  "example|global",
+		Host:       "example",
+		UsageScope: "global",
+		Trackers:   []string{"AITHER"},
+		Total:      2,
+	})
+
+	_, err := service.Upload(ctx, api.ImageHostingSubject{SourcePath: "synthetic-source"}, "example", "global", []api.ScreenshotImage{
+		{Path: firstPath},
+		{Path: secondPath},
+	})
+	if err == nil {
+		t.Fatal("expected partial failure")
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(updates) < 4 {
+		t.Fatalf("progress update count=%d, want at least 4", len(updates))
+	}
+	final := updates[len(updates)-1]
+	if final.Status != api.ImageUploadProgressFailed || final.Completed != 2 || final.Succeeded != 1 || final.Failed != 1 {
+		t.Fatalf("unexpected final progress: %#v", final)
+	}
+	if final.AttemptID != "example|global" || len(final.Trackers) != 1 {
+		t.Fatalf("progress target metadata was not preserved: %#v", final)
+	}
+}
+
+func TestUploadImagesStopsDispatchingWhenContextCanceled(t *testing.T) {
+	tmpDir := t.TempDir()
+	firstPath := filepath.Join(tmpDir, "shot-01.png")
+	secondPath := filepath.Join(tmpDir, "shot-02.png")
+	for _, path := range []string{firstPath, secondPath} {
+		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
+			t.Fatalf("write temp file: %v", err)
+		}
+	}
+
+	uploaderStub := &blockingUploader{firstCallCh: make(chan struct{})}
+	service := &Service{
+		cfg: config.Config{
+			ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 1},
+		},
+		logger:    api.NopLogger{},
+		uploaders: map[string]uploader{"test": uploaderStub},
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	firstCallCh := uploaderStub.firstCallCh
+	done := make(chan error, 1)
+	go func() {
+		_, err := service.Upload(ctx, api.ImageHostingSubject{SourcePath: "source"}, "test", "global", []api.ScreenshotImage{
+			{Path: firstPath},
+			{Path: secondPath},
+		})
+		done <- err
+	}()
+
+	select {
+	case <-firstCallCh:
+	case <-time.After(2 * time.Second):
+		t.Fatal("timed out waiting for first upload to start")
+	}
+
+	cancel()
+
+	select {
+	case err := <-done:
+		if !errors.Is(err, context.Canceled) {
+			t.Fatalf("expected context cancellation, got %v", err)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("timed out waiting for upload to stop")
+	}
+
+	uploaderStub.mu.Lock()
+	defer uploaderStub.mu.Unlock()
+	if len(uploaderStub.calls) != 1 {
+		t.Fatalf("expected only first upload to start, got %d calls", len(uploaderStub.calls))
+	}
+}
diff --git a/internal/services/imagehosting/uploaders.go b/internal/imagehosting/uploaders.go
similarity index 92%
rename from internal/services/imagehosting/uploaders.go
rename to internal/imagehosting/uploaders.go
index 22222ef5..39a39eb6 100644
--- a/internal/services/imagehosting/uploaders.go
+++ b/internal/imagehosting/uploaders.go
@@ -25,6 +25,7 @@ import (
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/httpclient"
 	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers"
 )
 
 type uploadResult struct {
@@ -47,28 +48,56 @@ type namedBatchUploader interface {
 
 const maxResponseBodyPreviewBytes int64 = 64 * 1024
 
-func newUploaderRegistry(cfg config.Config, client *http.Client) map[string]uploader {
+func newUploaderRegistry(cfg config.Config, client *http.Client, registry *trackers.Registry) map[string]uploader {
 	client = httpclient.CloneWithTimeout(client, httpclient.UploadTimeout)
+	hdbConfig := ownedHostTrackerConfig(cfg, registry, "hdb")
 	return map[string]uploader{
-		"imgbb":        &imgbbUploader{apiKey: cfg.ImageHosting.ImgBBAPI, client: client},
-		"imgbox":       &imgboxUploader{client: client},
-		"hdb":          &hdbUploader{username: cfg.Trackers.Trackers["HDB"].Username, passkey: cfg.Trackers.Trackers["HDB"].Passkey, client: client},
-		"pixhost":      &pixhostUploader{client: client},
-		"lensdump":     &lensdumpUploader{apiKey: cfg.ImageHosting.LensdumpAPI, client: client},
-		"lostimg":      &lostimgUploader{apiKey: cfg.ImageHosting.LostimgAPI, client: client},
-		"ptscreens":    &ptScreensUploader{apiKey: cfg.ImageHosting.PTScreensAPI, client: client},
-		"onlyimage":    &onlyImageUploader{apiKey: cfg.ImageHosting.OnlyImageAPI, client: client},
-		"dalexni":      &dalexniUploader{apiKey: cfg.ImageHosting.DalexniAPI, client: client},
-		"zipline":      &ziplineUploader{apiKey: cfg.ImageHosting.ZiplineAPIKey, url: cfg.ImageHosting.ZiplineURL, client: client},
+		"imgbb":  &imgbbUploader{apiKey: cfg.ImageHosting.ImgBBAPI, client: client},
+		"imgbox": &imgboxUploader{client: client},
+		"hdb": &hdbUploader{
+			username: hdbConfig.Username,
+			passkey:  hdbConfig.Passkey,
+			client:   client,
+		},
+		"pixhost":   &pixhostUploader{client: client},
+		"lensdump":  &lensdumpUploader{apiKey: cfg.ImageHosting.LensdumpAPI, client: client},
+		"lostimg":   &lostimgUploader{apiKey: cfg.ImageHosting.LostimgAPI, client: client},
+		"ptscreens": &ptScreensUploader{apiKey: cfg.ImageHosting.PTScreensAPI, client: client},
+		"onlyimage": &onlyImageUploader{apiKey: cfg.ImageHosting.OnlyImageAPI, client: client},
+		"dalexni":   &dalexniUploader{apiKey: cfg.ImageHosting.DalexniAPI, client: client},
+		"zipline": &ziplineUploader{
+			apiKey: cfg.ImageHosting.ZiplineAPIKey,
+			url:    cfg.ImageHosting.ZiplineURL,
+			client: client,
+		},
 		"passtheimage": &passTheImageUploader{apiKey: cfg.ImageHosting.PassTheImageAPI, client: client},
-		"reelflix":     &reelflixUploader{apiKey: cfg.Trackers.Trackers["RF"].ImgAPI, client: client},
+		"reelflix":     &reelflixUploader{apiKey: ownedHostTrackerConfig(cfg, registry, "reelflix").ImgAPI, client: client},
 		"seedpool_cdn": &seedpoolUploader{apiKey: cfg.ImageHosting.SeedpoolCDNAPI, client: client},
-		"sharex":       &shareXUploader{apiKey: cfg.ImageHosting.ShareXAPIKey, url: cfg.ImageHosting.ShareXURL, client: client},
-		"thr":          &thrUploader{apiKey: cfg.Trackers.Trackers["THR"].ImgAPI, client: client},
-		"utppm":        &utppmUploader{apiKey: cfg.ImageHosting.UTPPMAPI, client: client},
+		"sharex": &shareXUploader{
+			apiKey: cfg.ImageHosting.ShareXAPIKey,
+			url:    cfg.ImageHosting.ShareXURL,
+			client: client,
+		},
+		"thr":   &thrUploader{apiKey: ownedHostTrackerConfig(cfg, registry, "thr").ImgAPI, client: client},
+		"utppm": &utppmUploader{apiKey: cfg.ImageHosting.UTPPMAPI, client: client},
 	}
 }
 
+// ownedHostTrackerConfig resolves private image-host credentials through the
+// tracker manifest instead of coupling uploaders to tracker identifiers.
+func ownedHostTrackerConfig(cfg config.Config, registry *trackers.Registry, host string) config.TrackerConfig {
+	if registry == nil {
+		return config.TrackerConfig{}
+	}
+	owner := registry.OwnerForImageHost(host)
+	for name, trackerConfig := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), owner) {
+			return trackerConfig
+		}
+	}
+	return config.TrackerConfig{}
+}
+
 type imgbbUploader struct {
 	apiKey string
 	client *http.Client
@@ -758,7 +787,11 @@ func (u *thrUploader) Upload(ctx context.Context, imagePath string) (uploadResul
 		}
 		return uploadResult{}, fmt.Errorf("thr upload failed: %s", message)
 	}
-	return uploadResult{ImgURL: imageURL, RawURL: imageURL, WebURL: imageURL}, nil
+	return uploadResult{
+		ImgURL: imageURL,
+		RawURL: imageURL,
+		WebURL: imageURL,
+	}, nil
 }
 
 type lostimgUploader struct {
@@ -830,7 +863,11 @@ func (u *lostimgUploader) uploadBatch(ctx context.Context, imagePaths []string)
 		if imageURL == "" {
 			return nil, errors.New("lostimg upload returned empty image URL")
 		}
-		results = append(results, uploadResult{ImgURL: imageURL, RawURL: imageURL, WebURL: imageURL})
+		results = append(results, uploadResult{
+			ImgURL: imageURL,
+			RawURL: imageURL,
+			WebURL: imageURL,
+		})
 	}
 	return results, nil
 }
@@ -867,7 +904,11 @@ func (u *pixhostUploader) Upload(ctx context.Context, imagePath string) (uploadR
 	rawURL := strings.ReplaceAll(response.ThumbnailURL, "https://t", "https://img")
 	rawURL = strings.ReplaceAll(rawURL, "/thumbs/", "/images/")
 
-	return uploadResult{ImgURL: response.ThumbnailURL, RawURL: rawURL, WebURL: response.ShowURL}, nil
+	return uploadResult{
+		ImgURL: response.ThumbnailURL,
+		RawURL: rawURL,
+		WebURL: response.ShowURL,
+	}, nil
 }
 
 type ziplineUploader struct {
@@ -911,7 +952,11 @@ func (u *ziplineUploader) Upload(ctx context.Context, imagePath string) (uploadR
 	}
 	rawURL := strings.Replace(urlValue, "/u/", "/r/", 1)
 
-	return uploadResult{ImgURL: urlValue, RawURL: rawURL, WebURL: rawURL}, nil
+	return uploadResult{
+		ImgURL: urlValue,
+		RawURL: rawURL,
+		WebURL: rawURL,
+	}, nil
 }
 
 type passTheImageUploader struct {
@@ -1067,7 +1112,11 @@ func (u *seedpoolUploader) Upload(ctx context.Context, imagePath string) (upload
 		imgURL = file.URL
 	}
 
-	return uploadResult{ImgURL: imgURL, RawURL: file.URL, WebURL: file.URL}, nil
+	return uploadResult{
+		ImgURL: imgURL,
+		RawURL: file.URL,
+		WebURL: file.URL,
+	}, nil
 }
 
 type shareXUploader struct {
@@ -1120,7 +1169,11 @@ func (u *shareXUploader) Upload(ctx context.Context, imagePath string) (uploadRe
 		return uploadResult{}, fmt.Errorf("sharex upload failed: %s", message)
 	}
 
-	return uploadResult{ImgURL: link, RawURL: link, WebURL: link}, nil
+	return uploadResult{
+		ImgURL: link,
+		RawURL: link,
+		WebURL: link,
+	}, nil
 }
 
 func postForm(ctx context.Context, client *http.Client, target string, data url.Values, headers map[string]string) ([]byte, int, error) {
@@ -1144,11 +1197,26 @@ func postForm(ctx context.Context, client *http.Client, target string, data url.
 	return body, resp.StatusCode, nil
 }
 
-func postMultipart(ctx context.Context, client *http.Client, target string, fields map[string]string, fileField string, filePath string, headers map[string]string) ([]byte, int, error) {
+func postMultipart(
+	ctx context.Context,
+	client *http.Client,
+	target string,
+	fields map[string]string,
+	fileField string,
+	filePath string,
+	headers map[string]string,
+) ([]byte, int, error) {
 	return postMultipartWithFields(ctx, client, target, fields, map[string]string{fileField: filePath}, headers)
 }
 
-func postMultipartWithFields(ctx context.Context, client *http.Client, target string, fields map[string]string, fileFields map[string]string, headers map[string]string) ([]byte, int, error) {
+func postMultipartWithFields(
+	ctx context.Context,
+	client *http.Client,
+	target string,
+	fields map[string]string,
+	fileFields map[string]string,
+	headers map[string]string,
+) ([]byte, int, error) {
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 	fieldKeys := make([]string, 0, len(fields))
@@ -1211,7 +1279,14 @@ func postMultipartWithFields(ctx context.Context, client *http.Client, target st
 	return bodyBytes, resp.StatusCode, nil
 }
 
-func postMultipartRepeatedFileField(ctx context.Context, client *http.Client, target string, fileField string, filePaths []string, headers map[string]string) ([]byte, int, error) {
+func postMultipartRepeatedFileField(
+	ctx context.Context,
+	client *http.Client,
+	target string,
+	fileField string,
+	filePaths []string,
+	headers map[string]string,
+) ([]byte, int, error) {
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 	for _, filePath := range filePaths {
diff --git a/internal/services/imagehosting/uploaders_test.go b/internal/imagehosting/uploaders_test.go
similarity index 99%
rename from internal/services/imagehosting/uploaders_test.go
rename to internal/imagehosting/uploaders_test.go
index 44447144..1693a323 100644
--- a/internal/services/imagehosting/uploaders_test.go
+++ b/internal/imagehosting/uploaders_test.go
@@ -186,7 +186,11 @@ func TestHDBUploadBatchChunksLargeUploads(t *testing.T) {
 		}),
 	}
 
-	uploader := &hdbUploader{username: "user", passkey: "pass", client: client}
+	uploader := &hdbUploader{
+		username: "user",
+		passkey:  "pass",
+		client:   client,
+	}
 	results, err := uploader.UploadBatchWithName(context.Background(), paths, "release")
 	if err != nil {
 		t.Fatalf("UploadBatchWithName returned error: %v", err)
diff --git a/internal/imagehostpolicy/policy.go b/internal/imagehostpolicy/policy.go
deleted file mode 100644
index 1c88c129..00000000
--- a/internal/imagehostpolicy/policy.go
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package imagehostpolicy
-
-import (
-	"maps"
-	"slices"
-	"strings"
-)
-
-type Policy struct {
-	AllowedHosts   []string
-	UploadHosts    []string
-	PreferredHosts []string
-	Required       bool
-}
-
-type Metadata struct {
-	UploadHosts        []string
-	TrackerUploadHosts map[string][]string
-	OwnedHosts         map[string]string
-}
-
-var trackerAllowedHosts = map[string][]string{
-	"A4K": {"onlyimage", "imgbox", "ptscreens", "imgbb", "imgur", "postimg"},
-	"BHD": {"imgbox", "imgbb", "pixhost", "bhd", "bam"},
-	"DC":  {"imgbox", "imgbb", "bhd", "imgur", "postimg", "sharex"},
-	"GPW": {"kshare", "pixhost", "pterclub", "ilikeshots", "imgbox"},
-	"HDB": {"hdb"},
-	"MTV": {"imgbox", "imgbb"},
-	"OE":  {"imgbox", "imgbb", "onlyimage", "ptscreens", "passtheimage"},
-	"PTP": {"pixhost", "imgbb", "onlyimage", "ptscreens", "passtheimage"},
-	"STC": {"imgbox", "imgbb"},
-	"THR": {"thr"},
-	"TVC": {"imgbb", "imgbox", "pixhost", "bam", "onlyimage"},
-}
-
-var uploadHosts = map[string]struct{}{
-	"dalexni":      {},
-	"hdb":          {},
-	"imgbb":        {},
-	"imgbox":       {},
-	"lensdump":     {},
-	"lostimg":      {},
-	"onlyimage":    {},
-	"passtheimage": {},
-	"pixhost":      {},
-	"ptscreens":    {},
-	"reelflix":     {},
-	"seedpool_cdn": {},
-	"sharex":       {},
-	"thr":          {},
-	"utppm":        {},
-	"zipline":      {},
-}
-
-var ownedHosts = map[string]string{
-	"hdb":      "HDB",
-	"lostimg":  "LST",
-	"reelflix": "RF",
-	"thr":      "THR",
-}
-
-var trackerOptionalUploadHosts = map[string][]string{
-	"LST": {"lostimg"},
-	"RF":  {"reelflix"},
-}
-
-func ForTracker(tracker string, imgRehost bool, imgAPI string) Policy {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "HDB" && !imgRehost {
-		return Policy{}
-	}
-	if name == "THR" && strings.TrimSpace(imgAPI) == "" {
-		return Policy{}
-	}
-	allowed, ok := trackerAllowedHosts[name]
-	if !ok {
-		return Policy{}
-	}
-	normalizedAllowed := normalizeUnique(allowed...)
-	return Policy{
-		AllowedHosts:   normalizedAllowed,
-		UploadHosts:    filterUploadHosts(normalizedAllowed),
-		PreferredHosts: filterUploadHosts(normalizedAllowed),
-		Required:       len(normalizedAllowed) > 0,
-	}
-}
-
-func KnownTrackerPolicies() map[string][]string {
-	out := make(map[string][]string, len(trackerAllowedHosts))
-	for tracker, hosts := range trackerAllowedHosts {
-		out[tracker] = append([]string(nil), hosts...)
-	}
-	return out
-}
-
-func PolicyMetadata() Metadata {
-	return Metadata{
-		UploadHosts:        KnownUploadHosts(),
-		TrackerUploadHosts: KnownTrackerUploadPolicies(),
-		OwnedHosts:         KnownOwnedHosts(),
-	}
-}
-
-func KnownUploadHosts() []string {
-	out := make([]string, 0, len(uploadHosts))
-	for host := range uploadHosts {
-		out = append(out, host)
-	}
-	slices.Sort(out)
-	return out
-}
-
-func KnownTrackerUploadPolicies() map[string][]string {
-	out := make(map[string][]string, len(trackerAllowedHosts))
-	for tracker, hosts := range trackerAllowedHosts {
-		out[tracker] = filterUploadHosts(normalizeUnique(hosts...))
-	}
-	for tracker, hosts := range trackerOptionalUploadHosts {
-		existing := out[tracker]
-		out[tracker] = filterUploadHosts(normalizeUnique(append(existing, hosts...)...))
-	}
-	return out
-}
-
-func KnownOwnedHosts() map[string]string {
-	out := make(map[string]string, len(ownedHosts))
-	maps.Copy(out, ownedHosts)
-	return out
-}
-
-func IsUploadHost(host string) bool {
-	_, ok := uploadHosts[strings.ToLower(strings.TrimSpace(host))]
-	return ok
-}
-
-func OwnerForHost(host string) string {
-	return ownedHosts[strings.ToLower(strings.TrimSpace(host))]
-}
-
-func HostAllowed(host string, allowed []string) bool {
-	if len(allowed) == 0 {
-		return true
-	}
-	needle := strings.ToLower(strings.TrimSpace(host))
-	for _, item := range allowed {
-		if strings.ToLower(strings.TrimSpace(item)) == needle {
-			return true
-		}
-	}
-	return false
-}
-
-func normalizeUnique(hosts ...string) []string {
-	out := make([]string, 0, len(hosts))
-	seen := make(map[string]struct{}, len(hosts))
-	for _, host := range hosts {
-		trimmed := strings.ToLower(strings.TrimSpace(host))
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		out = append(out, trimmed)
-	}
-	return out
-}
-
-func filterUploadHosts(hosts []string) []string {
-	out := make([]string, 0, len(hosts))
-	for _, host := range hosts {
-		if IsUploadHost(host) {
-			out = append(out, strings.ToLower(strings.TrimSpace(host)))
-		}
-	}
-	return out
-}
diff --git a/internal/imagehostpolicy/policy_test.go b/internal/imagehostpolicy/policy_test.go
deleted file mode 100644
index 440429e1..00000000
--- a/internal/imagehostpolicy/policy_test.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package imagehostpolicy
-
-import "testing"
-
-func TestPolicyMetadataExposesOnlySupportedTrackerUploadHosts(t *testing.T) {
-	t.Parallel()
-
-	metadata := PolicyMetadata()
-	ptpHosts := metadata.TrackerUploadHosts["PTP"]
-
-	if !HostAllowed("pixhost", ptpHosts) {
-		t.Fatalf("PTP upload hosts should include supported host pixhost: %v", ptpHosts)
-	}
-	for _, host := range []string{"imgbb", "onlyimage", "ptscreens", "passtheimage"} {
-		if !HostAllowed(host, ptpHosts) {
-			t.Fatalf("PTP upload hosts should include supported host %s: %v", host, ptpHosts)
-		}
-	}
-	if len(ptpHosts) != 5 {
-		t.Fatalf("PTP upload hosts should only allow supported PTP hosts: %v", ptpHosts)
-	}
-	if HostAllowed("imgur", ptpHosts) {
-		t.Fatalf("PTP upload hosts should exclude unsupported host: %v", ptpHosts)
-	}
-}
-
-func TestPolicyMetadataDefensivelyCopiesOwnedHosts(t *testing.T) {
-	t.Parallel()
-
-	metadata := PolicyMetadata()
-	metadata.OwnedHosts["hdb"] = "OTHER"
-
-	if got := OwnerForHost("hdb"); got != "HDB" {
-		t.Fatalf("OwnerForHost(hdb) = %q, want HDB", got)
-	}
-}
-
-func TestPolicyMetadataExposesLostimgAsLSTOwnedUploadHost(t *testing.T) {
-	t.Parallel()
-
-	metadata := PolicyMetadata()
-	lstHosts := metadata.TrackerUploadHosts["LST"]
-
-	if !HostAllowed("lostimg", lstHosts) {
-		t.Fatalf("LST upload hosts should include lostimg: %v", lstHosts)
-	}
-	if got := metadata.OwnedHosts["lostimg"]; got != "LST" {
-		t.Fatalf("lostimg owner = %q, want LST", got)
-	}
-}
-
-func TestPolicyMetadataExposesReelflixAsRFOwnedUploadHost(t *testing.T) {
-	t.Parallel()
-
-	metadata := PolicyMetadata()
-	rfHosts := metadata.TrackerUploadHosts["RF"]
-
-	if !HostAllowed("reelflix", rfHosts) {
-		t.Fatalf("RF upload hosts should include reelflix: %v", rfHosts)
-	}
-	if got := metadata.OwnedHosts["reelflix"]; got != "RF" {
-		t.Fatalf("reelflix owner = %q, want RF", got)
-	}
-}
diff --git a/internal/languageutil/normalize.go b/internal/languageutil/normalize.go
index dac92257..751c1e45 100644
--- a/internal/languageutil/normalize.go
+++ b/internal/languageutil/normalize.go
@@ -16,8 +16,9 @@ var (
 	languageNameMap     map[string]language.Tag
 )
 
-// NormalizeLanguageDisplay returns a title-cased display name for a language token.
-// The input can be a language code (en, eng, en-US) or a display name (English).
+// NormalizeLanguageDisplay returns the English base-language label resolved from
+// the first code or name token. Region and trailing tokens are discarded; blank
+// or unresolved input returns an empty string.
 func NormalizeLanguageDisplay(value string) string {
 	token := normalizeLanguageToken(value)
 	if token == "" {
diff --git a/internal/literalpolicy/checker.go b/internal/literalpolicy/checker.go
new file mode 100644
index 00000000..a1e001c5
--- /dev/null
+++ b/internal/literalpolicy/checker.go
@@ -0,0 +1,230 @@
+// Package literalpolicy enforces readable layout for substantial keyed composite literals.
+package literalpolicy
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+)
+
+const minimumKeyedElements = 3
+
+const allowDirective = "//literalpolicy:allow"
+
+var skippedDirectories = map[string]struct{}{
+	".git":              {},
+	"dist":              {},
+	"node_modules":      {},
+	"playwright-report": {},
+	"test-results":      {},
+	"tmp":               {},
+}
+
+// Violation describes a keyed composite literal that is not consistently multiline.
+type Violation struct {
+	Path   string
+	Line   int
+	Column int
+}
+
+// String returns the checker-compatible location and diagnostic.
+func (v Violation) String() string {
+	return fmt.Sprintf(
+		"%s:%d:%d: keyed composite literals with %d or more elements must use one element per line",
+		v.Path,
+		v.Line,
+		v.Column,
+		minimumKeyedElements,
+	)
+}
+
+// CheckRepository checks every non-generated Go source file below root.
+func CheckRepository(root string) ([]Violation, error) {
+	var violations []Violation
+	err := walkGoFiles(root, func(path string, source []byte) error {
+		found, _, err := inspectFile(root, path, source, false)
+		violations = append(violations, found...)
+		return err
+	})
+	return violations, err
+}
+
+// FixRepository makes substantial keyed composite literals consistently multiline
+// and returns the number of source files rewritten.
+func FixRepository(root string) (int, error) {
+	fixed := 0
+	err := walkGoFiles(root, func(path string, source []byte) error {
+		_, updated, err := inspectFile(root, path, source, true)
+		if err != nil || updated == nil {
+			return err
+		}
+		//nolint:gosec // The path comes from the repository walk and is not supplied independently.
+		if err := os.WriteFile(path, updated, 0o600); err != nil {
+			return fmt.Errorf("write %s: %w", path, err)
+		}
+		fixed++
+		return nil
+	})
+	return fixed, err
+}
+
+func walkGoFiles(root string, visit func(string, []byte) error) error {
+	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			if path != root {
+				if _, skip := skippedDirectories[entry.Name()]; skip {
+					return filepath.SkipDir
+				}
+			}
+			return nil
+		}
+		if filepath.Ext(path) != ".go" {
+			return nil
+		}
+		//nolint:gosec // The checker intentionally reads Go files discovered inside the trusted repository root.
+		source, err := os.ReadFile(path)
+		if err != nil {
+			return fmt.Errorf("read %s: %w", path, err)
+		}
+		if isGenerated(source) {
+			return nil
+		}
+		return visit(path, source)
+	})
+	if err != nil {
+		return fmt.Errorf("walk repository Go files: %w", err)
+	}
+	return nil
+}
+
+func isGenerated(source []byte) bool {
+	return bytes.Contains(source[:min(len(source), 2048)], []byte("Code generated")) &&
+		bytes.Contains(source[:min(len(source), 2048)], []byte("DO NOT EDIT."))
+}
+
+type insertion struct {
+	offset int
+	text   string
+}
+
+func inspectFile(root string, path string, source []byte, fix bool) ([]Violation, []byte, error) {
+	files := token.NewFileSet()
+	parsed, err := parser.ParseFile(files, path, source, parser.ParseComments)
+	if err != nil {
+		return nil, nil, fmt.Errorf("parse %s: %w", path, err)
+	}
+	var violations []Violation
+	var insertions []insertion
+	ast.Inspect(parsed, func(node ast.Node) bool {
+		literal, ok := node.(*ast.CompositeLit)
+		if !ok || !substantialKeyedLiteral(literal) || hasAllowDirective(files, literal, source) || consistentLayout(files, literal) {
+			return true
+		}
+		position := files.Position(literal.Lbrace)
+		relative, relErr := filepath.Rel(root, path)
+		if relErr != nil {
+			relative = path
+		}
+		violations = append(violations, Violation{
+			Path:   filepath.ToSlash(relative),
+			Line:   position.Line,
+			Column: position.Column,
+		})
+		if fix {
+			insertions = append(insertions, layoutInsertions(files, literal, source)...)
+		}
+		return true
+	})
+	if !fix || len(insertions) == 0 {
+		return violations, nil, nil
+	}
+	return violations, applyInsertions(source, insertions), nil
+}
+
+func hasAllowDirective(files *token.FileSet, literal *ast.CompositeLit, source []byte) bool {
+	lines := bytes.Split(source, []byte("\n"))
+	lineIndex := files.Position(literal.Lbrace).Line - 1
+	for _, index := range []int{lineIndex, lineIndex - 1} {
+		if index >= 0 && index < len(lines) && bytes.Contains(lines[index], []byte(allowDirective)) {
+			return true
+		}
+	}
+	return false
+}
+
+func substantialKeyedLiteral(literal *ast.CompositeLit) bool {
+	if len(literal.Elts) < minimumKeyedElements {
+		return false
+	}
+	for _, element := range literal.Elts {
+		if _, ok := element.(*ast.KeyValueExpr); !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func consistentLayout(files *token.FileSet, literal *ast.CompositeLit) bool {
+	if files.Position(literal.Lbrace).Line == files.Position(literal.Elts[0].Pos()).Line {
+		return false
+	}
+	for index := 1; index < len(literal.Elts); index++ {
+		if files.Position(literal.Elts[index-1].End()).Line == files.Position(literal.Elts[index].Pos()).Line {
+			return false
+		}
+	}
+	return files.Position(literal.Elts[len(literal.Elts)-1].End()).Line != files.Position(literal.Rbrace).Line
+}
+
+func layoutInsertions(files *token.FileSet, literal *ast.CompositeLit, source []byte) []insertion {
+	var result []insertion
+	if files.Position(literal.Lbrace).Line == files.Position(literal.Elts[0].Pos()).Line {
+		result = append(result, insertion{offset: files.Position(literal.Lbrace).Offset + 1, text: "\n"})
+	}
+	for index := 1; index < len(literal.Elts); index++ {
+		previous := literal.Elts[index-1]
+		current := literal.Elts[index]
+		if files.Position(previous.End()).Line != files.Position(current.Pos()).Line {
+			continue
+		}
+		start := files.Position(previous.End()).Offset
+		end := files.Position(current.Pos()).Offset
+		if comma := bytes.IndexByte(source[start:end], ','); comma >= 0 {
+			result = append(result, insertion{offset: start + comma + 1, text: "\n"})
+		}
+	}
+	last := literal.Elts[len(literal.Elts)-1]
+	if files.Position(last.End()).Line == files.Position(literal.Rbrace).Line {
+		start := files.Position(last.End()).Offset
+		end := files.Position(literal.Rbrace).Offset
+		separator := "\n"
+		if bytes.IndexByte(source[start:end], ',') < 0 {
+			separator = ",\n"
+		}
+		result = append(result, insertion{offset: end, text: separator})
+	}
+	return result
+}
+
+func applyInsertions(source []byte, insertions []insertion) []byte {
+	sort.Slice(insertions, func(i, j int) bool { return insertions[i].offset > insertions[j].offset })
+	seen := make(map[int]struct{}, len(insertions))
+	updated := append([]byte(nil), source...)
+	for _, edit := range insertions {
+		if _, duplicate := seen[edit.offset]; duplicate {
+			continue
+		}
+		seen[edit.offset] = struct{}{}
+		updated = append(updated[:edit.offset], append([]byte(edit.text), updated[edit.offset:]...)...)
+	}
+	return updated
+}
diff --git a/internal/literalpolicy/checker_test.go b/internal/literalpolicy/checker_test.go
new file mode 100644
index 00000000..d27d7662
--- /dev/null
+++ b/internal/literalpolicy/checker_test.go
@@ -0,0 +1,70 @@
+package literalpolicy
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCheckAndFixRepository(t *testing.T) {
+	t.Parallel()
+	root := t.TempDir()
+	path := filepath.Join(root, "sample.go")
+	source := `package sample
+
+var dense = Config{Name: "example", URL: "https://example.invalid", Enabled: true}
+var small = Point{X: 1, Y: 2}
+//literalpolicy:allow aliases are grouped by canonical value
+var grouped = Config{Name: "example", URL: "https://example.invalid", Enabled: true}
+var mixed = Config{
+	Name: "example", URL: "https://example.invalid",
+	Enabled: true}
+`
+	if err := os.WriteFile(path, []byte(source), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check fixture: %v", err)
+	}
+	if len(violations) != 2 {
+		t.Fatalf("violation count = %d, want 2", len(violations))
+	}
+	if fixed, err := FixRepository(root); err != nil || fixed != 1 {
+		t.Fatalf("FixRepository() = (%d, %v), want (1, nil)", fixed, err)
+	}
+	violations, err = CheckRepository(root)
+	if err != nil {
+		t.Fatalf("recheck fixture: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("remaining violations = %d, want 0", len(violations))
+	}
+	updated, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read fixture: %v", err)
+	}
+	if !strings.Contains(string(updated), `var small = Point{X: 1, Y: 2}`) {
+		t.Fatal("two-element literal was unexpectedly expanded")
+	}
+	if !strings.Contains(string(updated), `var grouped = Config{Name: "example", URL: "https://example.invalid", Enabled: true}`) {
+		t.Fatal("allowed literal was unexpectedly expanded")
+	}
+}
+
+func TestGeneratedFileIsIgnored(t *testing.T) {
+	t.Parallel()
+	root := t.TempDir()
+	source := "// Code generated by test. DO NOT EDIT.\npackage sample\nvar value = T{A: 1, B: 2, C: 3}\n"
+	if err := os.WriteFile(filepath.Join(root, "generated.go"), []byte(source), 0o600); err != nil {
+		t.Fatalf("write fixture: %v", err)
+	}
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("check fixture: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("generated violations = %d, want 0", len(violations))
+	}
+}
diff --git a/internal/logging/logger.go b/internal/logging/logger.go
index 8d8628e6..a7cfc920 100644
--- a/internal/logging/logger.go
+++ b/internal/logging/logger.go
@@ -21,6 +21,8 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Level is a maximum verbosity threshold: larger values admit progressively
+// more detailed entries, while [LevelError] admits errors only.
 type Level int
 
 const (
@@ -47,6 +49,8 @@ func (l Level) String() string {
 	}
 }
 
+// ParseLevel normalizes a configured level. Invalid input returns [LevelInfo]
+// together with an error.
 func ParseLevel(value string) (Level, error) {
 	normalized, err := api.ParseLogLevel(value)
 	if err != nil {
@@ -69,6 +73,9 @@ func ParseLevel(value string) (Level, error) {
 	}
 }
 
+// Logger writes sanitized, threshold-filtered entries to console and optional
+// file outputs while retaining the same entries for snapshots and subscribers.
+// Close releases the optional file output.
 type Logger struct {
 	level      Level
 	consoleOut *log.Logger
@@ -83,6 +90,8 @@ type Logger struct {
 	subID      int
 }
 
+// Entry is one sanitized retained log entry. IDs increase within a Logger, and
+// Level contains the lowercase level name.
 type Entry struct {
 	ID      int64     `json:"id"`
 	Time    time.Time `json:"time" ts_type:"string"`
@@ -99,10 +108,15 @@ var (
 const defaultBufferCap = 1000
 const defaultSubscriberBuffer = 200
 
+// New constructs a logger using cfg.Level. When file output is enabled, it
+// creates or opens the app log below the database directory; callers must close
+// the returned logger.
 func New(cfg config.LoggingConfig, dbPath string) (*Logger, error) {
 	return NewWithLevel(cfg, dbPath, "")
 }
 
+// NewWithLevel constructs a logger after replacing cfg.Level with a non-blank
+// override. It has the same file ownership and side effects as [New].
 func NewWithLevel(cfg config.LoggingConfig, dbPath string, override string) (*Logger, error) {
 	if trimmed := strings.TrimSpace(override); trimmed != "" {
 		cfg.Level = trimmed
@@ -145,6 +159,8 @@ func defaultConsoleWriters() (io.Writer, io.Writer) {
 	return defaultConsoleOut, defaultConsoleErr
 }
 
+// ResolveEffectiveLevel applies runOverride first, then the debug fallback,
+// then the configured level.
 func ResolveEffectiveLevel(configured string, runOverride string, debug bool) string {
 	if trimmed := strings.TrimSpace(runOverride); trimmed != "" {
 		return trimmed
@@ -155,6 +171,8 @@ func ResolveEffectiveLevel(configured string, runOverride string, debug bool) st
 	return strings.TrimSpace(configured)
 }
 
+// Close releases file logging resources. It is safe on a nil logger and is a
+// no-op when file logging is disabled.
 func (l *Logger) Close() error {
 	if l == nil || l.closer == nil {
 		return nil
@@ -226,8 +244,18 @@ func (l *Logger) logf(level Level, label string, format string, args ...any) {
 	if l == nil || level > l.level {
 		return
 	}
-
 	formatted := SanitizeMessage(fmt.Sprintf(format, args...))
+	l.writeSanitized(level, label, formatted)
+}
+
+func (l *Logger) writef(level Level, label string, format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.writeSanitized(level, label, SanitizeMessage(fmt.Sprintf(format, args...)))
+}
+
+func (l *Logger) writeSanitized(level Level, label string, formatted string) {
 	prefix := label + ": "
 	if level <= LevelWarn {
 		l.consoleErr.Print(prefix + formatted)
@@ -436,6 +464,8 @@ func (l *Logger) record(label string, message string) {
 	l.mu.Unlock()
 }
 
+// Recent returns a copied, oldest-to-newest snapshot of the most recent entries.
+// A non-positive or oversized limit returns the complete retained buffer.
 func (l *Logger) Recent(limit int) []Entry {
 	if l == nil {
 		return nil
@@ -453,6 +483,9 @@ func (l *Logger) Recent(limit int) []Entry {
 	return entries
 }
 
+// Subscribe registers a future-entry stream and returns its unsubscribe ID.
+// A non-positive buffer uses the package default. Delivery is non-blocking, so
+// entries are dropped for a subscriber whose channel is full.
 func (l *Logger) Subscribe(buffer int) (int, <-chan Entry) {
 	if l == nil {
 		return 0, nil
@@ -471,6 +504,8 @@ func (l *Logger) Subscribe(buffer int) (int, <-chan Entry) {
 	return id, ch
 }
 
+// Unsubscribe removes a subscription and closes its channel. Unknown IDs and a
+// nil logger are ignored.
 func (l *Logger) Unsubscribe(id int) {
 	if l == nil {
 		return
@@ -504,6 +539,8 @@ func resolveLogPath(dbPath string) (string, error) {
 	return filepath.Join(logDir, "upbrr.log"), nil
 }
 
+// LogPath returns the app log path, creating the database's logs subdirectory
+// when necessary.
 func LogPath(dbPath string) (string, error) {
 	return resolveLogPath(dbPath)
 }
@@ -524,7 +561,11 @@ func newRotatingWriter(path string, maxBytes int64, maxFiles int) (*rotatingWrit
 	if maxFiles <= 0 {
 		return nil, errors.New("logging: max files must be greater than zero")
 	}
-	writer := &rotatingWriter{path: path, maxBytes: maxBytes, maxFiles: maxFiles}
+	writer := &rotatingWriter{
+		path:     path,
+		maxBytes: maxBytes,
+		maxFiles: maxFiles,
+	}
 	if err := writer.open(); err != nil {
 		return nil, err
 	}
diff --git a/internal/logging/operation.go b/internal/logging/operation.go
new file mode 100644
index 00000000..f7d0bea3
--- /dev/null
+++ b/internal/logging/operation.go
@@ -0,0 +1,96 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package logging
+
+import (
+	"context"
+	"errors"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type operationLoggerKey struct{}
+
+// OperationLogger is an immutable non-owning verbosity view over one active
+// logger. Entries use the root logger's sanitized outputs, buffer, and
+// subscribers without changing its configured threshold.
+type OperationLogger struct {
+	root  *Logger
+	level Level
+}
+
+// NewOperationLogger creates a non-owning logger view. An empty override uses
+// the root logger's configured level. A nil root or invalid override returns an
+// error.
+func NewOperationLogger(root *Logger, override string) (*OperationLogger, error) {
+	if root == nil {
+		return nil, errors.New("logging: root logger is required")
+	}
+	level := root.level
+	if override != "" {
+		parsed, err := ParseLevel(override)
+		if err != nil {
+			return nil, err
+		}
+		level = parsed
+	}
+	return &OperationLogger{root: root, level: level}, nil
+}
+
+// WithOperationLogger attaches one operation-local logger view to ctx. It
+// returns ctx unchanged when ctx or logger is nil.
+func WithOperationLogger(ctx context.Context, logger api.Logger) context.Context {
+	if ctx == nil || logger == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, operationLoggerKey{}, logger)
+}
+
+// FromContext returns the operation logger attached to ctx or fallback. A nil
+// fallback becomes an [api.NopLogger].
+func FromContext(ctx context.Context, fallback api.Logger) api.Logger {
+	if ctx != nil {
+		if logger, ok := ctx.Value(operationLoggerKey{}).(api.Logger); ok && logger != nil {
+			return logger
+		}
+	}
+	if fallback == nil {
+		return api.NopLogger{}
+	}
+	return fallback
+}
+
+// Tracef logs a trace entry when enabled by this operation view.
+func (l *OperationLogger) Tracef(format string, args ...any) {
+	l.logf(LevelTrace, "TRACE", format, args...)
+}
+
+// Debugf logs a debug entry when enabled by this operation view.
+func (l *OperationLogger) Debugf(format string, args ...any) {
+	l.logf(LevelDebug, "DEBUG", format, args...)
+}
+
+// Infof logs an info entry when enabled by this operation view.
+func (l *OperationLogger) Infof(format string, args ...any) {
+	l.logf(LevelInfo, "INFO", format, args...)
+}
+
+// Warnf logs a warning entry when enabled by this operation view.
+func (l *OperationLogger) Warnf(format string, args ...any) {
+	l.logf(LevelWarn, "WARN", format, args...)
+}
+
+// Errorf logs an error entry when enabled by this operation view.
+func (l *OperationLogger) Errorf(format string, args ...any) {
+	l.logf(LevelError, "ERROR", format, args...)
+}
+
+func (l *OperationLogger) logf(level Level, label string, format string, args ...any) {
+	if l == nil || l.root == nil || level > l.level {
+		return
+	}
+	l.root.writef(level, label, format, args...)
+}
+
+var _ api.Logger = (*OperationLogger)(nil)
diff --git a/internal/logging/operation_test.go b/internal/logging/operation_test.go
new file mode 100644
index 00000000..cb490d44
--- /dev/null
+++ b/internal/logging/operation_test.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package logging
+
+import (
+	"context"
+	"io"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+)
+
+func TestOperationLoggerUsesRootSinkWithoutMutatingRootThreshold(t *testing.T) {
+	t.Parallel()
+
+	root, err := New(config.LoggingConfig{Level: "info"}, "")
+	if err != nil {
+		t.Fatalf("new root logger: %v", err)
+	}
+	root.SetConsoleOutput(io.Discard, io.Discard)
+	subscriptionID, entries := root.Subscribe(8)
+	defer root.Unsubscribe(subscriptionID)
+
+	scoped, err := NewOperationLogger(root, "trace")
+	if err != nil {
+		t.Fatalf("new operation logger: %v", err)
+	}
+	ctx := WithOperationLogger(context.Background(), scoped)
+	localPath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+
+	var workers sync.WaitGroup
+	workers.Add(2)
+	go func() {
+		defer workers.Done()
+		FromContext(ctx, root).Tracef("operation trace api_key=secret-value source=%s", localPath)
+	}()
+	go func() {
+		defer workers.Done()
+		root.Tracef("unscoped trace must remain filtered")
+	}()
+	workers.Wait()
+
+	recent := root.Recent(10)
+	if len(recent) != 1 || recent[0].Level != "trace" {
+		t.Fatalf("recent entries = %#v", recent)
+	}
+	if strings.Contains(recent[0].Message, "secret-value") || strings.Contains(recent[0].Message, localPath) {
+		t.Fatalf("scoped entry was not sanitized: %q", recent[0].Message)
+	}
+	select {
+	case entry := <-entries:
+		if entry.ID != recent[0].ID {
+			t.Fatalf("subscriber entry = %#v, recent = %#v", entry, recent[0])
+		}
+	default:
+		t.Fatal("scoped entry did not reach root subscriber")
+	}
+
+	root.Debugf("root remains info-filtered")
+	root.Infof("root remains usable")
+	if got := root.Recent(10); len(got) != 2 || got[1].Level != "info" {
+		t.Fatalf("root entries after scope = %#v", got)
+	}
+}
+
+func TestOperationLoggerEmptyOverrideUsesRootThreshold(t *testing.T) {
+	t.Parallel()
+
+	root, err := New(config.LoggingConfig{Level: "warn"}, "")
+	if err != nil {
+		t.Fatalf("new root logger: %v", err)
+	}
+	root.SetConsoleOutput(io.Discard, io.Discard)
+	scoped, err := NewOperationLogger(root, "")
+	if err != nil {
+		t.Fatalf("new operation logger: %v", err)
+	}
+	scoped.Infof("filtered")
+	scoped.Warnf("retained")
+	if entries := root.Recent(10); len(entries) != 1 || entries[0].Level != "warn" {
+		t.Fatalf("entries = %#v", entries)
+	}
+}
diff --git a/internal/logpolicy/checker.go b/internal/logpolicy/checker.go
index 5e069b92..6cb405c2 100644
--- a/internal/logpolicy/checker.go
+++ b/internal/logpolicy/checker.go
@@ -176,6 +176,7 @@ var infoVerboseSignals = []string{
 
 var rawErrorLogFieldRe = regexp.MustCompile(`(?:^|[\s,;])(?:err|error)=%`)
 
+// Violation identifies one source-positioned logging-policy diagnostic.
 type Violation struct {
 	File    string
 	Line    int
@@ -183,8 +184,9 @@ type Violation struct {
 	Message string
 }
 
-// CheckRepository scans repo-owned Go and frontend test sources for logging and
-// shareable-output patterns that can expose secrets or unsafe diagnostics.
+// CheckRepository scans internal Go, cmd/upbrr Go, and WebUI test sources for
+// logging and shareable-output patterns that can expose secrets or unsafe
+// diagnostics. It returns violations sorted by file, line, then column.
 func CheckRepository(root string) ([]Violation, error) {
 	internalRoot := filepath.Join(root, "internal")
 	if _, err := os.Stat(internalRoot); err != nil {
@@ -260,37 +262,6 @@ func CheckRepository(root string) ([]Violation, error) {
 		return nil, fmt.Errorf("logpolicy: stat cmd/upbrr root: %w", err)
 	}
 
-	guiRoot := filepath.Join(root, "gui")
-	if _, err := os.Stat(guiRoot); err == nil {
-		err = filepath.WalkDir(guiRoot, func(path string, entry os.DirEntry, walkErr error) error {
-			if walkErr != nil {
-				return walkErr
-			}
-			if entry.IsDir() {
-				switch entry.Name() {
-				case "frontend", "build":
-					return filepath.SkipDir
-				default:
-					return nil
-				}
-			}
-			if filepath.Ext(path) != ".go" || strings.HasSuffix(path, "_test.go") {
-				return nil
-			}
-			fileViolations, err := checkTerminalSensitiveOutputFile(fset, root, path)
-			if err != nil {
-				return err
-			}
-			violations = append(violations, fileViolations...)
-			return nil
-		})
-		if err != nil {
-			return nil, fmt.Errorf("logpolicy: walk gui: %w", err)
-		}
-	} else if !os.IsNotExist(err) {
-		return nil, fmt.Errorf("logpolicy: stat gui root: %w", err)
-	}
-
 	frontendViolations, err := checkFrontendTestSensitiveMatchers(root)
 	if err != nil {
 		return nil, err
@@ -364,11 +335,17 @@ func checkProjectLoggerPathSanitization(fset *token.FileSet, root string) ([]Vio
 		if logfFormatsThroughSanitizeMessage(fn.Body) {
 			return violations, nil
 		}
-		violations = append(violations, violationAt(fset, relPath, fn.Name.Pos(), "project logger logf must sanitize formatted messages with SanitizeMessage before output"))
+		violations = append(
+			violations,
+			violationAt(fset, relPath, fn.Name.Pos(), "project logger logf must sanitize formatted messages with SanitizeMessage before output"),
+		)
 		return violations, nil
 	}
 
-	violations = append(violations, violationAt(fset, relPath, file.Package, "project logger logf not found; logger output path sanitization cannot be verified"))
+	violations = append(
+		violations,
+		violationAt(fset, relPath, file.Package, "project logger logf not found; logger output path sanitization cannot be verified"),
+	)
 	return violations, nil
 }
 
@@ -393,7 +370,9 @@ func checkProjectLoggerURLPathPreservation(fset *token.FileSet, relPath string,
 // checkProjectLoggerSecretRedaction guards the logger boundary shared by
 // console, file, buffered, and frontend-streamed output.
 func checkProjectLoggerSecretRedaction(fset *token.FileSet, relPath string, pos token.Pos, sanitize func(string) string) []Violation {
-	sanitized := sanitize(`tracker: request: Get "https://tracker.example/api/torrents/filter?api_token=policy-secret&name=Example.Release.2026.1080p-GRP": timeout`)
+	sanitized := sanitize(
+		`tracker: request: Get "https://tracker.example/api/torrents/filter?api_token=policy-secret&name=Example.Release.2026.1080p-GRP": timeout`,
+	)
 	if strings.Contains(sanitized, "policy-secret") || !strings.Contains(sanitized, "api_token=[REDACTED]") {
 		return []Violation{violationAt(fset, relPath, pos, "project logger sanitizer must redact secret-bearing request URLs")}
 	}
@@ -518,14 +497,18 @@ var (
 	// Frontend secret-output patterns scan complete TS/TSX test files so
 	// typed declarations, multiline matchers, and JSX attributes are covered.
 	frontendEncryptedEnvelopeDeclRe = regexp.MustCompile("\\b(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*(?::[^=;]+)?=\\s*[\"'`]upbrr-enc:")
-	frontendDirectEnvelopeMatcherRe = regexp.MustCompile("\\.(?:toBe|toEqual|toStrictEqual|toContain|toMatch)\\s*\\(\\s*(?:[\"'`]upbrr-enc:|([A-Za-z_$][\\w$]*))")
-	frontendRawPayloadDOMRe         = regexp.MustCompile("(?s)(?:[\"']data-testid[\"']\\s*:\\s*[\"']payload[\"'][^;]*buildSavePayload\\s*\\(\\)|buildSavePayload\\s*\\(\\)[^;]*[\"']data-testid[\"']\\s*:\\s*[\"']payload[\"']|data-testid\\s*=\\s*(?:[\"']payload[\"']|\\{\\s*[\"']payload[\"']\\s*\\})[^;]*buildSavePayload\\s*\\(\\)|buildSavePayload\\s*\\(\\)[^;]*data-testid\\s*=\\s*(?:[\"']payload[\"']|\\{\\s*[\"']payload[\"']\\s*\\}))")
+	frontendDirectEnvelopeMatcherRe = regexp.MustCompile(
+		"\\.(?:toBe|toEqual|toStrictEqual|toContain|toMatch)\\s*\\(\\s*(?:[\"'`]upbrr-enc:|([A-Za-z_$][\\w$]*))",
+	)
+	frontendRawPayloadDOMRe = regexp.MustCompile(
+		"(?s)(?:[\"']data-testid[\"']\\s*:\\s*[\"']payload[\"'][^;]*buildSavePayload\\s*\\(\\)|buildSavePayload\\s*\\(\\)[^;]*[\"']data-testid[\"']\\s*:\\s*[\"']payload[\"']|data-testid\\s*=\\s*(?:[\"']payload[\"']|\\{\\s*[\"']payload[\"']\\s*\\})[^;]*buildSavePayload\\s*\\(\\)|buildSavePayload\\s*\\(\\)[^;]*data-testid\\s*=\\s*(?:[\"']payload[\"']|\\{\\s*[\"']payload[\"']\\s*\\}))",
+	)
 )
 
 // checkFrontendTestSensitiveMatchers scans frontend tests for assertions and DOM
 // fixtures that would print encrypted envelopes or save payloads in failure output.
 func checkFrontendTestSensitiveMatchers(root string) ([]Violation, error) {
-	frontendRoot := filepath.Join(root, "gui", "frontend", "src")
+	frontendRoot := filepath.Join(root, "webui", "src")
 	if _, err := os.Stat(frontendRoot); err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
@@ -668,10 +651,16 @@ func checkCLISensitiveOutputFile(fset *token.FileSet, root string, path string)
 				violations = append(violations, violationAt(fset, relPath, arg.Pos(), "dry-run payload output must be redacted before printing"))
 			}
 			if containsDryRunFilePathExpr(arg, dryRunFileVars) && !isSafeDryRunOutputExpr(arg) {
-				violations = append(violations, violationAt(fset, relPath, arg.Pos(), "dry-run file path output must be reduced to a DB-relative or basename label before printing"))
+				violations = append(
+					violations,
+					violationAt(fset, relPath, arg.Pos(), "dry-run file path output must be reduced to a DB-relative or basename label before printing"),
+				)
 			}
 			if containsLocalPathOutputExpr(arg, localPathVars, aliases) && !isSafeLocalPathOutputExpr(arg) {
-				violations = append(violations, violationAt(fset, relPath, arg.Pos(), "local filesystem path output must be reduced to a stable path label before printing"))
+				violations = append(
+					violations,
+					violationAt(fset, relPath, arg.Pos(), "local filesystem path output must be reduced to a stable path label before printing"),
+				)
 			}
 		}
 		if strings.Contains(strings.ToLower(format), "endpoint:") {
@@ -686,38 +675,6 @@ func checkCLISensitiveOutputFile(fset *token.FileSet, root string, path string)
 	return violations, nil
 }
 
-// checkTerminalSensitiveOutputFile scans command-style entrypoints for terminal
-// diagnostics that can expose raw errors, warnings, or unsafe path text.
-func checkTerminalSensitiveOutputFile(fset *token.FileSet, root string, path string) ([]Violation, error) {
-	file, err := parser.ParseFile(fset, path, nil, parser.SkipObjectResolution)
-	if err != nil {
-		return nil, fmt.Errorf("parse %s: %w", path, err)
-	}
-
-	aliases := importAliases(file)
-	relPath, err := filepath.Rel(root, path)
-	if err != nil {
-		relPath = path
-	}
-	relPath = filepath.ToSlash(relPath)
-
-	violations := make([]Violation, 0)
-	ast.Inspect(file, func(node ast.Node) bool {
-		call, ok := node.(*ast.CallExpr)
-		if !ok || !isTerminalStderrOutputCall(call, aliases) {
-			return true
-		}
-		format := cliOutputFormat(call)
-		for _, arg := range fmtOutputArgs(call) {
-			if isUnsafeTerminalDiagnosticArg(format, arg, aliases) {
-				violations = append(violations, violationAt(fset, relPath, arg.Pos(), "terminal error/warning output must be sanitized before printing"))
-			}
-		}
-		return true
-	})
-	return violations, nil
-}
-
 // collectDryRunFileVars tracks range variables bound to dry-run file entries so
 // file.Path output can be required to pass through a path label formatter.
 func collectDryRunFileVars(file *ast.File) map[string]struct{} {
@@ -821,14 +778,28 @@ func checkFile(fset *token.FileSet, root string, path string) ([]Violation, erro
 			importPath := aliases[packageName.Name]
 			if methods, found := disallowedStdlibCalls[importPath]; found {
 				if _, banned := methods[selector.Sel.Name]; banned {
-					appendLogpolicyViolation(fset, relPath, allows, &violations, selector.Sel.Pos(), fmt.Sprintf("use the project logger instead of %s.%s in internal packages", packageName.Name, selector.Sel.Name))
+					appendLogpolicyViolation(
+						fset,
+						relPath,
+						allows,
+						&violations,
+						selector.Sel.Pos(),
+						fmt.Sprintf("use the project logger instead of %s.%s in internal packages", packageName.Name, selector.Sel.Name),
+					)
 				}
 			}
 			if isTerminalStderrOutputCall(call, aliases) {
 				format := cliOutputFormat(call)
 				for _, arg := range fmtOutputArgs(call) {
 					if isUnsafeTerminalDiagnosticArg(format, arg, aliases) {
-						appendLogpolicyViolation(fset, relPath, allows, &violations, arg.Pos(), "terminal error/warning output must be sanitized before printing")
+						appendLogpolicyViolation(
+							fset,
+							relPath,
+							allows,
+							&violations,
+							arg.Pos(),
+							"terminal error/warning output must be sanitized before printing",
+						)
 					}
 				}
 			}
@@ -856,7 +827,14 @@ func checkFile(fset *token.FileSet, root string, path string) ([]Violation, erro
 		trimmed := strings.TrimSpace(format)
 		lowerFormat := strings.ToLower(trimmed)
 		if _, bare := bareFormats[trimmed]; bare {
-			appendLogpolicyViolation(fset, relPath, allows, &violations, firstArg.Pos(), selector.Sel.Name+" must include contextual text instead of logging a bare format string")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				firstArg.Pos(),
+				selector.Sel.Name+" must include contextual text instead of logging a bare format string",
+			)
 		}
 		if selector.Sel.Name == "Infof" {
 			for _, message := range infoLevelHygieneViolations(lowerFormat, trimmed) {
@@ -903,7 +881,14 @@ func checkFile(fset *token.FileSet, root string, path string) ([]Violation, erro
 		if isAuthSensitiveFormat(lowerFormat) {
 			for _, arg := range call.Args[1:] {
 				if isRawErrorLikeExpr(arg) {
-					appendLogpolicyViolation(fset, relPath, allows, &violations, arg.Pos(), "auth-sensitive log arguments must not include raw errors; log a stable incident code and operator-safe context instead")
+					appendLogpolicyViolation(
+						fset,
+						relPath,
+						allows,
+						&violations,
+						arg.Pos(),
+						"auth-sensitive log arguments must not include raw errors; log a stable incident code and operator-safe context instead",
+					)
 				}
 			}
 		}
@@ -1055,7 +1040,14 @@ func checkSensitiveOutputFile(fset *token.FileSet, root string, path string, tes
 
 // checkSensitiveOutputParsed runs the sensitive-value visitor after import
 // aliases and inline allow directives have been collected for the file.
-func checkSensitiveOutputParsed(fset *token.FileSet, relPath string, file *ast.File, aliases map[string]string, allows map[int]*logpolicyAllow, testFile bool) []Violation {
+func checkSensitiveOutputParsed(
+	fset *token.FileSet,
+	relPath string,
+	file *ast.File,
+	aliases map[string]string,
+	allows map[int]*logpolicyAllow,
+	testFile bool,
+) []Violation {
 	violations := make([]Violation, 0)
 	for _, decl := range file.Decls {
 		fn, ok := decl.(*ast.FuncDecl)
@@ -1103,7 +1095,14 @@ func checkDiagnosticArtifactWrites(fset *token.FileSet, relPath string, file *as
 			if isSafeSensitiveOutputExpr(call.Args[1]) || isSanitizedBindingBefore(fn.Body, call.Args[1], call.Pos()) {
 				return true
 			}
-			appendLogpolicyViolation(fset, relPath, allows, &violations, call.Args[1].Pos(), "diagnostic response artifacts must redact body/payload data before writing")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				call.Args[1].Pos(),
+				"diagnostic response artifacts must redact body/payload data before writing",
+			)
 			return true
 		})
 	}
@@ -1210,11 +1209,11 @@ func isSyntacticTypeExpr(expr ast.Expr) bool {
 	}
 }
 
-// checkFrontendVisibleRawErrors guards Wails/web job state and pkg/api result
-// objects, whose string fields are rendered or serialized for users.
+// checkFrontendVisibleRawErrors guards WebUI job state and pkg/api result
+// objects whose string fields are rendered or serialized for users.
 func checkFrontendVisibleRawErrors(fset *token.FileSet, relPath string, file *ast.File, aliases map[string]string, allows map[int]*logpolicyAllow) []Violation {
 	violations := make([]Violation, 0)
-	bridgeFile := strings.HasPrefix(relPath, "internal/guiapp/") || strings.HasPrefix(relPath, "internal/webserver/")
+	bridgeFile := strings.HasPrefix(relPath, "internal/webserver/")
 	ast.Inspect(file, func(node ast.Node) bool {
 		switch typed := node.(type) {
 		case *ast.AssignStmt:
@@ -1233,7 +1232,14 @@ func checkFrontendVisibleRawErrors(fset *token.FileSet, relPath string, file *as
 				if rhsIndex >= len(typed.Rhs) || isShareableMessageSanitizedExpr(typed.Rhs[rhsIndex]) || !isRawErrorLikeExpr(typed.Rhs[rhsIndex]) {
 					continue
 				}
-				appendLogpolicyViolation(fset, relPath, allows, &violations, typed.Rhs[rhsIndex].Pos(), "frontend-visible error/message fields must redact raw errors before assignment")
+				appendLogpolicyViolation(
+					fset,
+					relPath,
+					allows,
+					&violations,
+					typed.Rhs[rhsIndex].Pos(),
+					"frontend-visible error/message fields must redact raw errors before assignment",
+				)
 			}
 		case *ast.CompositeLit:
 			if !isAPICompositeType(typed.Type, aliases) {
@@ -1248,7 +1254,14 @@ func checkFrontendVisibleRawErrors(fset *token.FileSet, relPath string, file *as
 				if !ok || !isFrontendDiagnosticField(key.Name) || isShareableMessageSanitizedExpr(field.Value) || !isRawErrorLikeExpr(field.Value) {
 					continue
 				}
-				appendLogpolicyViolation(fset, relPath, allows, &violations, field.Value.Pos(), "frontend-visible API error/message fields must redact raw errors before serialization")
+				appendLogpolicyViolation(
+					fset,
+					relPath,
+					allows,
+					&violations,
+					field.Value.Pos(),
+					"frontend-visible API error/message fields must redact raw errors before serialization",
+				)
 			}
 		case *ast.CallExpr:
 			if !bridgeFile || callName(typed) != "failTrackerUploadJob" || len(typed.Args) < 3 {
@@ -1258,7 +1271,14 @@ func checkFrontendVisibleRawErrors(fset *token.FileSet, relPath string, file *as
 			if isShareableMessageSanitizedExpr(message) || !isRawErrorLikeExpr(message) {
 				return true
 			}
-			appendLogpolicyViolation(fset, relPath, allows, &violations, message.Pos(), "frontend-visible upload job failure messages must redact raw errors before state update and event emission")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				message.Pos(),
+				"frontend-visible upload job failure messages must redact raw errors before state update and event emission",
+			)
 		}
 		return true
 	})
@@ -1301,7 +1321,7 @@ func isAPICompositeType(expr ast.Expr, aliases map[string]string) bool {
 }
 
 // checkDryRunPreviewSerialization requires backend redaction before tracker
-// endpoint/payload data is placed in a bridge/API preview response.
+// endpoint/payload data is placed in a WebUI API preview response.
 func checkDryRunPreviewSerialization(fset *token.FileSet, relPath string, file *ast.File, allows map[int]*logpolicyAllow) []Violation {
 	violations := make([]Violation, 0)
 	ast.Inspect(file, func(node ast.Node) bool {
@@ -1318,7 +1338,14 @@ func checkDryRunPreviewSerialization(fset *token.FileSet, relPath string, file *
 			if !ok || key.Name != "Trackers" || isEmptyCompositeLiteral(field.Value) || isSanitizedDryRunEntriesExpr(field.Value) {
 				continue
 			}
-			appendLogpolicyViolation(fset, relPath, allows, &violations, field.Value.Pos(), "TrackerDryRunPreview entries must be sanitized before bridge/API serialization")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				field.Value.Pos(),
+				"TrackerDryRunPreview entries must be sanitized before WebUI API serialization",
+			)
 		}
 		return true
 	})
@@ -1353,7 +1380,14 @@ func isSanitizedDryRunEntriesExpr(expr ast.Expr) bool {
 // checkResponseJSONParseErrorOutput flags parse errors from raw JSON envelope
 // fields when they reach returned errors, logs, HTTP responses, or terminal
 // output without a recognized redaction wrapper.
-func checkResponseJSONParseErrorOutput(fset *token.FileSet, relPath string, aliases map[string]string, allows map[int]*logpolicyAllow, violations *[]Violation, body *ast.BlockStmt) {
+func checkResponseJSONParseErrorOutput(
+	fset *token.FileSet,
+	relPath string,
+	aliases map[string]string,
+	allows map[int]*logpolicyAllow,
+	violations *[]Violation,
+	body *ast.BlockStmt,
+) {
 	rawMessageMaps := responseJSONRawMessageMapVars(body, aliases)
 	ast.Inspect(body, func(node ast.Node) bool {
 		if node == nil {
@@ -1856,7 +1890,11 @@ func sinkArgs(exprs []ast.Expr, forceRawError bool) []sinkArg {
 func sinkArgsWithFormat(exprs []ast.Expr, forceRawError bool, format string) []sinkArg {
 	result := make([]sinkArg, 0, len(exprs))
 	for _, expr := range exprs {
-		result = append(result, sinkArg{expr: expr, forceRawError: forceRawError && isRawErrorLikeExpr(expr), format: format})
+		result = append(result, sinkArg{
+			expr:          expr,
+			forceRawError: forceRawError && isRawErrorLikeExpr(expr),
+			format:        format,
+		})
 	}
 	return result
 }
@@ -1941,7 +1979,15 @@ func checkTestHandlerFatalCalls(fset *token.FileSet, root string, path string) (
 				return true
 			}
 			if isTestingFatalCall(call) {
-				violations = append(violations, violationAt(fset, relPath, call.Pos(), "httptest handlers must not call t.Fatal/t.Fatalf from the request goroutine; record the error and assert from the test goroutine"))
+				violations = append(
+					violations,
+					violationAt(
+						fset,
+						relPath,
+						call.Pos(),
+						"httptest handlers must not call t.Fatal/t.Fatalf from the request goroutine; record the error and assert from the test goroutine",
+					),
+				)
 			}
 			return true
 		})
@@ -2037,7 +2083,10 @@ func checkUnboundedResponseBodyUses(fset *token.FileSet, relPath string, file *a
 				markUnboundedBodyAssignments(typed, aliases, unboundedBodyVars)
 			case *ast.CallExpr:
 				if isUnboundedResponseBodyUseCall(typed, unboundedBodyVars) {
-					violations = append(violations, violationAt(fset, relPath, typed.Pos(), "response body reads used for logs/errors/artifacts must be bounded before redaction"))
+					violations = append(
+						violations,
+						violationAt(fset, relPath, typed.Pos(), "response body reads used for logs/errors/artifacts must be bounded before redaction"),
+					)
 				}
 			}
 			return true
@@ -2597,7 +2646,21 @@ func isConfigOwnerTestPath(relPath string) bool {
 
 func isSensitiveConfigFieldName(name string) bool {
 	switch canonicalSensitiveKeyName(name) {
-	case "apikey", "apitoken", "password", "passkey", "token", "authkey", "anticsrftoken", "otpuri", "tmdbapi", "sonarrapikey", "radarrapikey", "qbitpass", "rsskey", "torrentpass", "secret":
+	case "apikey",
+		"apitoken",
+		"password",
+		"passkey",
+		"token",
+		"authkey",
+		"anticsrftoken",
+		"otpuri",
+		"tmdbapi",
+		"sonarrapikey",
+		"radarrapikey",
+		"qbitpass",
+		"rsskey",
+		"torrentpass",
+		"secret":
 		return true
 	default:
 		return false
@@ -3322,7 +3385,7 @@ func isSafeLocalPathOutputCall(call *ast.CallExpr, aliases map[string]string) bo
 			importPath = aliases[pkg.Name]
 		}
 		return (importPath == "path/filepath" || pkg.Name == "filepath") && fun.Sel.Name == "Base" ||
-			(importPath == "github.com/autobrr/upbrr/internal/pathutil" || pkg.Name == "pathutil") && fun.Sel.Name == "Base"
+			(importPath == "github.com/autobrr/upbrr/internal/pathing" || pkg.Name == "pathutil") && fun.Sel.Name == "Base"
 	default:
 		return false
 	}
@@ -3366,7 +3429,7 @@ func isLocalPathProducingCall(call *ast.CallExpr, aliases map[string]string) boo
 				}
 			case "github.com/autobrr/upbrr/internal/services/db":
 				return selector.Sel.Name == "Subdir"
-			case "github.com/autobrr/upbrr/internal/paths":
+			case "github.com/autobrr/upbrr/internal/pathing/layout":
 				return strings.Contains(strings.ToLower(selector.Sel.Name), "path") || selector.Sel.Name == "ReleaseTempDir"
 			}
 		}
@@ -3477,7 +3540,7 @@ func isSafeDryRunOutputExpr(expr ast.Expr) bool {
 // checkUnit3DQueryCredentialAuth prevents API credentials from returning to
 // request URLs after Unit3D authentication has moved to Bearer headers.
 func checkUnit3DQueryCredentialAuth(fset *token.FileSet, relPath string, file *ast.File, allows map[int]*logpolicyAllow) []Violation {
-	if relPath != "internal/trackerdata/unit3d.go" && !strings.HasPrefix(relPath, "internal/trackers/impl/unit3d/") {
+	if relPath != "internal/trackers/data/unit3d.go" && !strings.HasPrefix(relPath, "internal/trackers/impl/unit3d/") {
 		return nil
 	}
 	violations := make([]Violation, 0)
@@ -3496,7 +3559,14 @@ func checkUnit3DQueryCredentialAuth(fset *token.FileSet, relPath string, file *a
 		}
 		switch canonicalSensitiveKeyName(key) {
 		case "apikey", "apitoken", "authkey", "passkey", "token":
-			appendLogpolicyViolation(fset, relPath, allows, &violations, call.Args[0].Pos(), "Unit3D API credentials must use Authorization: Bearer instead of URL query parameters")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				call.Args[0].Pos(),
+				"Unit3D API credentials must use Authorization: Bearer instead of URL query parameters",
+			)
 		}
 		return true
 	})
@@ -3537,7 +3607,9 @@ func isRawBodyStringConversion(expr ast.Expr) bool {
 
 func isSuspiciousBodyName(name string) bool {
 	lower := strings.ToLower(strings.TrimSpace(name))
-	return lower == "body" || lower == "payload" || strings.HasSuffix(lower, "body") || strings.HasSuffix(lower, "payload") || strings.Contains(lower, "bodystr") || strings.Contains(lower, "bodypreview")
+	return lower == "body" || lower == "payload" || strings.HasSuffix(lower, "body") || strings.HasSuffix(lower, "payload") ||
+		strings.Contains(lower, "bodystr") ||
+		strings.Contains(lower, "bodypreview")
 }
 
 func isSensitiveUsernameName(name string) bool {
@@ -3754,13 +3826,39 @@ func checkWorkflowLoggingCoverage(fset *token.FileSet, relPath string, file *ast
 			continue
 		}
 		if summary.explicitLoggerParam && summary.totalLoggerCalls() == 0 {
-			appendLogpolicyViolation(fset, relPath, allows, &violations, fn.Name.Pos(), "workflow-like function has no logging; add Infof/Warnf/Debugf/Tracef progress or decision logs, or add logpolicy allow with reason")
-		}
-		if enableWorkflowBranchErrorCheck && summary.enforceWorkflowLogChecks() && summary.errorReturns > 0 && summary.contextualErrorReturns < summary.errorReturns && summary.totalLoggerCalls() > 0 && summary.loggerCalls["Warnf"] == 0 && summary.loggerCalls["Errorf"] == 0 {
-			appendLogpolicyViolation(fset, relPath, allows, &violations, fn.Name.Pos(), "workflow-like function has branch error returns without Warnf/Errorf blocked-outcome logging")
-		}
-		if enableWorkflowDecisionCheck && summary.enforceWorkflowLogChecks() && summary.decisionSignals > 0 && summary.totalLoggerCalls() > 0 && summary.decisionLoggerCalls == 0 {
-			appendLogpolicyViolation(fset, relPath, allows, &violations, fn.Name.Pos(), "workflow decision lacks logging; add stable decision/state context at Debugf, Infof, or Warnf")
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				fn.Name.Pos(),
+				"workflow-like function has no logging; add Infof/Warnf/Debugf/Tracef progress or decision logs, or add logpolicy allow with reason",
+			)
+		}
+		if enableWorkflowBranchErrorCheck && summary.enforceWorkflowLogChecks() && summary.errorReturns > 0 &&
+			summary.contextualErrorReturns < summary.errorReturns &&
+			summary.totalLoggerCalls() > 0 &&
+			summary.loggerCalls["Warnf"] == 0 &&
+			summary.loggerCalls["Errorf"] == 0 {
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				fn.Name.Pos(),
+				"workflow-like function has branch error returns without Warnf/Errorf blocked-outcome logging",
+			)
+		}
+		if enableWorkflowDecisionCheck && summary.enforceWorkflowLogChecks() && summary.decisionSignals > 0 && summary.totalLoggerCalls() > 0 &&
+			summary.decisionLoggerCalls == 0 {
+			appendLogpolicyViolation(
+				fset,
+				relPath,
+				allows,
+				&violations,
+				fn.Name.Pos(),
+				"workflow decision lacks logging; add stable decision/state context at Debugf, Infof, or Warnf",
+			)
 		}
 		for _, logViolation := range summary.logViolations {
 			appendLogpolicyViolation(fset, relPath, allows, &violations, logViolation.pos, logViolation.message)
@@ -4021,7 +4119,29 @@ func isWorkflowOperationCall(call *ast.CallExpr) bool {
 	if name == "" {
 		return false
 	}
-	signals := []string{"upload", "search", "check", "validate", "load", "save", "read", "write", "request", "post", "get", "create", "build", "resolve", "migrate", "discover", "generate", "submit", "start", "run", "decode"}
+	signals := []string{
+		"upload",
+		"search",
+		"check",
+		"validate",
+		"load",
+		"save",
+		"read",
+		"write",
+		"request",
+		"post",
+		"get",
+		"create",
+		"build",
+		"resolve",
+		"migrate",
+		"discover",
+		"generate",
+		"submit",
+		"start",
+		"run",
+		"decode",
+	}
 	for _, signal := range signals {
 		if strings.Contains(name, signal) {
 			return true
@@ -4052,7 +4172,22 @@ func containsDecisionSignal(node ast.Node) bool {
 
 func isDecisionSignal(value string) bool {
 	lower := strings.ToLower(value)
-	signals := []string{"skip", "selected", "ready", "blocked", "fallback", "retry", "prompt", "dryrun", "dry_run", "unattended", "auth", "dupe", "rule", "decision"}
+	signals := []string{
+		"skip",
+		"selected",
+		"ready",
+		"blocked",
+		"fallback",
+		"retry",
+		"prompt",
+		"dryrun",
+		"dry_run",
+		"unattended",
+		"auth",
+		"dupe",
+		"rule",
+		"decision",
+	}
 	for _, signal := range signals {
 		if strings.Contains(lower, signal) {
 			return true
@@ -4063,7 +4198,40 @@ func isDecisionSignal(value string) bool {
 
 func isWorkflowName(name string) bool {
 	lower := strings.ToLower(name)
-	signals := []string{"run", "upload", "prepare", "process", "execute", "build", "resolve", "search", "validate", "check", "import", "export", "save", "load", "migrate", "discover", "generate", "create", "submit", "start", "tracker", "torrent", "dupe", "auth", "metadata", "screenshot", "image", "client", "queue", "config", "database", "runtime"}
+	signals := []string{
+		"run",
+		"upload",
+		"prepare",
+		"process",
+		"execute",
+		"build",
+		"resolve",
+		"search",
+		"validate",
+		"check",
+		"import",
+		"export",
+		"save",
+		"load",
+		"migrate",
+		"discover",
+		"generate",
+		"create",
+		"submit",
+		"start",
+		"tracker",
+		"torrent",
+		"dupe",
+		"auth",
+		"metadata",
+		"screenshot",
+		"image",
+		"client",
+		"queue",
+		"config",
+		"database",
+		"runtime",
+	}
 	for _, signal := range signals {
 		if strings.Contains(lower, signal) {
 			return true
diff --git a/internal/logpolicy/checker_test.go b/internal/logpolicy/checker_test.go
index 01bb9a34..5098e3b3 100644
--- a/internal/logpolicy/checker_test.go
+++ b/internal/logpolicy/checker_test.go
@@ -634,7 +634,6 @@ type trackerConfig struct {
 	Secret string
 	TorrentPass string
 	AnnounceURL string
-	URL string
 }
 type metaInfo struct{ Announce string }
 
@@ -649,7 +648,6 @@ func check(t testingT, cfg config, meta metaInfo) {
 	t.Fatalf("tracker secret mismatch: got %q", cfg.Trackers.Trackers["BTN"].Secret)
 	t.Fatalf("tracker torrent pass mismatch: got %q", cfg.Trackers.Trackers["BTN"].TorrentPass)
 	t.Fatalf("tracker announce mismatch: got %q", cfg.Trackers.Trackers["CZT"].AnnounceURL)
-	t.Fatalf("tracker URL mismatch: got %q", cfg.Trackers.Trackers["BTN"].URL)
 	t.Fatalf("torrent announce mismatch: got %q", meta.Announce)
 }
 
@@ -663,8 +661,8 @@ type testingT interface {
 	if err != nil {
 		t.Fatalf("CheckRepository returned error: %v", err)
 	}
-	if len(violations) != 12 {
-		t.Fatalf("expected 12 violations, got %d: %#v", len(violations), violations)
+	if len(violations) != 11 {
+		t.Fatalf("expected 11 violations, got %d: %#v", len(violations), violations)
 	}
 }
 
@@ -848,7 +846,7 @@ func TestCheckRepositoryFlagsFrontendEncryptedEnvelopeMatcherOutput(t *testing.T
 	if err := os.MkdirAll(filepath.Join(root, "internal", "sample"), 0o755); err != nil {
 		t.Fatalf("mkdir internal sample: %v", err)
 	}
-	testDir := filepath.Join(root, "gui", "frontend", "src", "hooks")
+	testDir := filepath.Join(root, "webui", "src", "hooks")
 	if err := os.MkdirAll(testDir, 0o755); err != nil {
 		t.Fatalf("mkdir frontend test dir: %v", err)
 	}
@@ -1332,10 +1330,6 @@ func TestCheckRepositoryFlagsRawTerminalErrorOutput(t *testing.T) {
 	if err := os.MkdirAll(filepath.Join(root, "cmd", "upbrr"), 0o755); err != nil {
 		t.Fatalf("mkdir cmd upbrr: %v", err)
 	}
-	if err := os.MkdirAll(filepath.Join(root, "gui"), 0o755); err != nil {
-		t.Fatalf("mkdir gui: %v", err)
-	}
-
 	cliContent := `package main
 
 import (
@@ -1352,7 +1346,7 @@ func main() {
 
 func run() error { return nil }
 `
-	guiContent := `package main
+	internalContent := `package sample
 
 import (
 	"fmt"
@@ -1372,10 +1366,7 @@ func run() error { return nil }
 	if err := os.WriteFile(filepath.Join(root, "cmd", "upbrr", "main.go"), []byte(cliContent), 0o600); err != nil {
 		t.Fatalf("write CLI sample file: %v", err)
 	}
-	if err := os.WriteFile(filepath.Join(root, "gui", "main.go"), []byte(guiContent), 0o600); err != nil {
-		t.Fatalf("write GUI sample file: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "internal", "sample", "sample.go"), []byte(guiContent), 0o600); err != nil {
+	if err := os.WriteFile(filepath.Join(root, "internal", "sample", "sample.go"), []byte(internalContent), 0o600); err != nil {
 		t.Fatalf("write internal sample file: %v", err)
 	}
 
@@ -1383,8 +1374,8 @@ func run() error { return nil }
 	if err != nil {
 		t.Fatalf("CheckRepository returned error: %v", err)
 	}
-	if len(violations) != 6 {
-		t.Fatalf("expected 6 violations, got %d: %#v", len(violations), violations)
+	if len(violations) != 4 {
+		t.Fatalf("expected 4 violations, got %d: %#v", len(violations), violations)
 	}
 	for _, violation := range violations {
 		if !strings.Contains(violation.Message, "terminal error/warning output") {
@@ -1404,10 +1395,6 @@ func TestCheckRepositoryAllowsSanitizedTerminalOutput(t *testing.T) {
 	if err := os.MkdirAll(filepath.Join(root, "cmd", "upbrr"), 0o755); err != nil {
 		t.Fatalf("mkdir cmd upbrr: %v", err)
 	}
-	if err := os.MkdirAll(filepath.Join(root, "gui"), 0o755); err != nil {
-		t.Fatalf("mkdir gui: %v", err)
-	}
-
 	content := `package main
 
 import (
@@ -1434,9 +1421,6 @@ func warnings() []string { return nil }
 	if err := os.WriteFile(filepath.Join(root, "cmd", "upbrr", "main.go"), []byte(content), 0o600); err != nil {
 		t.Fatalf("write CLI sample file: %v", err)
 	}
-	if err := os.WriteFile(filepath.Join(root, "gui", "main.go"), []byte(content), 0o600); err != nil {
-		t.Fatalf("write GUI sample file: %v", err)
-	}
 	if err := os.WriteFile(filepath.Join(root, "internal", "sample", "sample.go"), []byte(content), 0o600); err != nil {
 		t.Fatalf("write internal sample file: %v", err)
 	}
@@ -3174,8 +3158,16 @@ func TestDiagnosticArtifactWritesRecognizeConvertedSanitizedBindings(t *testing.
 		writeExpr      string
 		wantViolations int
 	}{
-		{name: "slice conversion", writeExpr: "[]byte(payload)", wantViolations: 0},
-		{name: "ordinary call", writeExpr: "cloneBytes(payload)", wantViolations: 1},
+		{
+			name:           "slice conversion",
+			writeExpr:      "[]byte(payload)",
+			wantViolations: 0,
+		},
+		{
+			name:           "ordinary call",
+			writeExpr:      "cloneBytes(payload)",
+			wantViolations: 1,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -3206,7 +3198,7 @@ func writeFailureArtifact(path string, payload []byte) error {
 func TestFrontendVisibleRawErrorsRequireRedaction(t *testing.T) {
 	t.Parallel()
 
-	content := `package guiapp
+	content := `package webserver
 
 import (
 	"github.com/autobrr/upbrr/internal/logging"
@@ -3227,7 +3219,7 @@ func updateSafe(state *trackerState, err error) {
 }
 `
 	fset, file := parsePolicyFixture(t, content)
-	violations := checkFrontendVisibleRawErrors(fset, "internal/guiapp/sample.go", file, importAliases(file), nil)
+	violations := checkFrontendVisibleRawErrors(fset, "internal/webserver/sample.go", file, importAliases(file), nil)
 	if len(violations) != 3 {
 		t.Fatalf("expected 3 violations, got %d: %#v", len(violations), violations)
 	}
@@ -3241,7 +3233,7 @@ func updateSafe(state *trackerState, err error) {
 func TestFrontendVisibleUploadJobFailureMessagesRequireRedaction(t *testing.T) {
 	t.Parallel()
 
-	content := `package guiapp
+	content := `package webserver
 
 import "github.com/autobrr/upbrr/internal/logging"
 
@@ -3258,7 +3250,7 @@ func stable(app *App, eventCtx any, job *trackerUploadJob) {
 }
 `
 	fset, file := parsePolicyFixture(t, content)
-	violations := checkFrontendVisibleRawErrors(fset, "internal/guiapp/sample.go", file, importAliases(file), nil)
+	violations := checkFrontendVisibleRawErrors(fset, "internal/webserver/sample.go", file, importAliases(file), nil)
 	if len(violations) != 1 {
 		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
 	}
@@ -3321,7 +3313,7 @@ func safe(req *http.Request, apiKey string) {
 }
 `
 	fset, file := parsePolicyFixture(t, content)
-	violations := checkUnit3DQueryCredentialAuth(fset, "internal/trackerdata/unit3d.go", file, nil)
+	violations := checkUnit3DQueryCredentialAuth(fset, "internal/trackers/data/unit3d.go", file, nil)
 	if len(violations) != 1 {
 		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
 	}
diff --git a/internal/metadata/arr.go b/internal/metadata/arr.go
index bc78d793..90badf4e 100644
--- a/internal/metadata/arr.go
+++ b/internal/metadata/arr.go
@@ -14,12 +14,16 @@ import (
 	"strconv"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// ArrLookupResult carries non-authoritative identity, genre, and release-group
+// evidence from an Arr path match. Source identifies the provider family.
 type ArrLookupResult struct {
 	Source       string
 	TMDBID       int
@@ -44,10 +48,10 @@ type httpArrLookupClient struct {
 	logger    api.Logger
 }
 
-func (s *Service) ApplyArrData(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+func (s *Service) collectArrIdentityEvidence(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
@@ -92,7 +96,8 @@ func (s *Service) ApplyArrData(ctx context.Context, meta api.PreparedMetadata) (
 		}
 		return meta, nil
 	}
-	if result.TMDBID == 0 && result.IMDBID == 0 && result.TVDBID == 0 && result.TVmazeID == 0 && result.Year == 0 && len(result.Genres) == 0 && result.ReleaseGroup == "" {
+	if result.TMDBID == 0 && result.IMDBID == 0 && result.TVDBID == 0 && result.TVmazeID == 0 && result.Year == 0 && len(result.Genres) == 0 &&
+		result.ReleaseGroup == "" {
 		return meta, nil
 	}
 
@@ -157,7 +162,7 @@ func (s *Service) ensureRadarrClient() (ArrLookupClient, error) {
 	return s.radarr, nil
 }
 
-func (c *httpArrLookupClient) Lookup(ctx context.Context, meta api.PreparedMetadata) (ArrLookupResult, error) {
+func (c *httpArrLookupClient) Lookup(ctx context.Context, meta preparationstate.State) (ArrLookupResult, error) {
 	if c == nil {
 		return ArrLookupResult{}, errors.New("arr client not configured")
 	}
@@ -176,7 +181,8 @@ func (c *httpArrLookupClient) Lookup(ctx context.Context, meta api.PreparedMetad
 			}
 			continue
 		}
-		if result.TMDBID != 0 || result.IMDBID != 0 || result.TVDBID != 0 || result.TVmazeID != 0 || result.Year != 0 || len(result.Genres) != 0 || result.ReleaseGroup != "" {
+		if result.TMDBID != 0 || result.IMDBID != 0 || result.TVDBID != 0 || result.TVmazeID != 0 || result.Year != 0 || len(result.Genres) != 0 ||
+			result.ReleaseGroup != "" {
 			return result, nil
 		}
 	}
@@ -186,7 +192,12 @@ func (c *httpArrLookupClient) Lookup(ctx context.Context, meta api.PreparedMetad
 	return ArrLookupResult{}, nil
 }
 
-func (c *httpArrLookupClient) lookupInstance(ctx context.Context, httpClient *http.Client, instance arrInstance, meta api.PreparedMetadata) (ArrLookupResult, error) {
+func (c *httpArrLookupClient) lookupInstance(
+	ctx context.Context,
+	httpClient *http.Client,
+	instance arrInstance,
+	meta preparationstate.State,
+) (ArrLookupResult, error) {
 	switch c.service {
 	case "sonarr":
 		return lookupSonarr(ctx, httpClient, instance, meta)
@@ -197,7 +208,7 @@ func (c *httpArrLookupClient) lookupInstance(ctx context.Context, httpClient *ht
 	}
 }
 
-func lookupSonarr(ctx context.Context, httpClient *http.Client, instance arrInstance, meta api.PreparedMetadata) (ArrLookupResult, error) {
+func lookupSonarr(ctx context.Context, httpClient *http.Client, instance arrInstance, meta preparationstate.State) (ArrLookupResult, error) {
 	title, _ := resolveSearchTitles(meta)
 	if strings.TrimSpace(title) != "" {
 		parseURL, err := urlWithQuery(instance.baseURL, "/api/v3/parse", map[string]string{
@@ -217,7 +228,7 @@ func lookupSonarr(ctx context.Context, httpClient *http.Client, instance arrInst
 		}
 	}
 
-	tvdbID := firstNonZero(meta.ArrTVDBID, meta.MediaInfoTVDBID, meta.ExternalIDs.TVDBID)
+	tvdbID := firstNonZero(meta.ArrTVDBID, meta.MediaInfoTVDBID, meta.Identity.TVDBID)
 	if tvdbID == 0 {
 		return ArrLookupResult{}, nil
 	}
@@ -237,7 +248,7 @@ func lookupSonarr(ctx context.Context, httpClient *http.Client, instance arrInst
 	return result, nil
 }
 
-func lookupRadarr(ctx context.Context, httpClient *http.Client, instance arrInstance, meta api.PreparedMetadata) (ArrLookupResult, error) {
+func lookupRadarr(ctx context.Context, httpClient *http.Client, instance arrInstance, meta preparationstate.State) (ArrLookupResult, error) {
 	term := pathutil.Base(meta.SourcePath)
 	if term == "" {
 		term = strings.TrimSpace(meta.SourcePath)
@@ -259,7 +270,7 @@ func lookupRadarr(ctx context.Context, httpClient *http.Client, instance arrInst
 		}
 	}
 
-	tmdbID := firstNonZero(meta.ArrTMDBID, meta.MediaInfoTMDBID, meta.ExternalIDs.TMDBID)
+	tmdbID := firstNonZero(meta.ArrTMDBID, meta.MediaInfoTMDBID, meta.Identity.TMDBID)
 	if tmdbID == 0 {
 		return ArrLookupResult{}, nil
 	}
@@ -412,19 +423,51 @@ func (r ArrLookupResult) hasIDs() bool {
 
 func sonarrInstances(cfg config.ArrIntegrationConfig) []arrInstance {
 	return collectArrInstances("sonarr", []arrInstance{
-		{name: "default", baseURL: cfg.SonarrURL, apiKey: cfg.SonarrAPIKey},
-		{name: "1", baseURL: cfg.SonarrURL1, apiKey: cfg.SonarrAPIKey1},
-		{name: "2", baseURL: cfg.SonarrURL2, apiKey: cfg.SonarrAPIKey2},
-		{name: "3", baseURL: cfg.SonarrURL3, apiKey: cfg.SonarrAPIKey3},
+		{
+			name:    "default",
+			baseURL: cfg.SonarrURL,
+			apiKey:  cfg.SonarrAPIKey,
+		},
+		{
+			name:    "1",
+			baseURL: cfg.SonarrURL1,
+			apiKey:  cfg.SonarrAPIKey1,
+		},
+		{
+			name:    "2",
+			baseURL: cfg.SonarrURL2,
+			apiKey:  cfg.SonarrAPIKey2,
+		},
+		{
+			name:    "3",
+			baseURL: cfg.SonarrURL3,
+			apiKey:  cfg.SonarrAPIKey3,
+		},
 	})
 }
 
 func radarrInstances(cfg config.ArrIntegrationConfig) []arrInstance {
 	return collectArrInstances("radarr", []arrInstance{
-		{name: "default", baseURL: cfg.RadarrURL, apiKey: cfg.RadarrAPIKey},
-		{name: "1", baseURL: cfg.RadarrURL1, apiKey: cfg.RadarrAPIKey1},
-		{name: "2", baseURL: cfg.RadarrURL2, apiKey: cfg.RadarrAPIKey2},
-		{name: "3", baseURL: cfg.RadarrURL3, apiKey: cfg.RadarrAPIKey3},
+		{
+			name:    "default",
+			baseURL: cfg.RadarrURL,
+			apiKey:  cfg.RadarrAPIKey,
+		},
+		{
+			name:    "1",
+			baseURL: cfg.RadarrURL1,
+			apiKey:  cfg.RadarrAPIKey1,
+		},
+		{
+			name:    "2",
+			baseURL: cfg.RadarrURL2,
+			apiKey:  cfg.RadarrAPIKey2,
+		},
+		{
+			name:    "3",
+			baseURL: cfg.RadarrURL3,
+			apiKey:  cfg.RadarrAPIKey3,
+		},
 	})
 }
 
diff --git a/internal/metadata/arr_test.go b/internal/metadata/arr_test.go
index 8109d1db..0a87b27d 100644
--- a/internal/metadata/arr_test.go
+++ b/internal/metadata/arr_test.go
@@ -7,6 +7,8 @@ import (
 	"context"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/metadata/imdb"
 	"github.com/autobrr/upbrr/internal/metadata/tmdb"
@@ -17,10 +19,10 @@ type stubArrClient struct {
 	result ArrLookupResult
 	err    error
 	calls  int
-	last   api.PreparedMetadata
+	last   preparationstate.State
 }
 
-func (s *stubArrClient) Lookup(_ context.Context, meta api.PreparedMetadata) (ArrLookupResult, error) {
+func (s *stubArrClient) Lookup(_ context.Context, meta preparationstate.State) (ArrLookupResult, error) {
 	s.calls++
 	s.last = meta
 	if s.err != nil {
@@ -56,7 +58,7 @@ func TestApplyArrDataUsesSonarrForTV(t *testing.T) {
 		WithRadarrClient(radarr),
 	)
 
-	meta, err := svc.ApplyArrData(context.Background(), api.PreparedMetadata{
+	meta, err := svc.collectArrIdentityEvidence(context.Background(), preparationstate.State{
 		SourcePath: "/data/Show.S01E01.mkv",
 		SeasonInt:  1,
 		EpisodeInt: 1,
@@ -65,7 +67,7 @@ func TestApplyArrDataUsesSonarrForTV(t *testing.T) {
 		},
 	})
 	if err != nil {
-		t.Fatalf("ApplyArrData returned error: %v", err)
+		t.Fatalf("collectArrIdentityEvidence returned error: %v", err)
 	}
 	if sonarr.calls != 1 {
 		t.Fatalf("expected sonarr lookup, got %d calls", sonarr.calls)
@@ -95,7 +97,11 @@ func TestResolveExternalIDsPrefersArrBeforeSearch(t *testing.T) {
 	}
 	imdbClient := &stubIMDB{
 		searchResult: imdb.SearchResult{IMDbID: 888},
-		info:         imdb.Info{IMDbID: "tt0000123", Title: "Example", Year: 2021},
+		info: imdb.Info{
+			IMDbID: "tt0000123",
+			Title:  "Example",
+			Year:   2021,
+		},
 	}
 	svc := NewService(
 		repo,
@@ -106,20 +112,20 @@ func TestResolveExternalIDsPrefersArrBeforeSearch(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: "/data/Example.2021.mkv",
 		ArrSource:  "radarr",
 		ArrTMDBID:  123,
 		ArrIMDBID:  456,
 	})
 	if err != nil {
-		t.Fatalf("ResolveExternalIDs returned error: %v", err)
+		t.Fatalf("resolveExternalIdentity returned error: %v", err)
 	}
-	if result.ExternalIDs.TMDBID != 123 || result.ExternalIDs.SourceTMDB != "radarr" {
-		t.Fatalf("expected arr tmdb id preserved, got %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 123 || result.Identity.Provenance.TMDB != api.IdentityProvenanceArr {
+		t.Fatalf("expected arr tmdb id preserved, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.IMDBID != 456 || result.ExternalIDs.SourceIMDB != "radarr" {
-		t.Fatalf("expected arr imdb id preserved, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != 456 || result.Identity.Provenance.IMDB != api.IdentityProvenanceArr {
+		t.Fatalf("expected arr imdb id preserved, got %#v", result.Identity)
 	}
 	if tmdbClient.searchCalls != 0 {
 		t.Fatalf("expected tmdb search skipped, got %d calls", tmdbClient.searchCalls)
@@ -137,12 +143,16 @@ func TestResolveExternalIDsDoesNotOverwriteExplicitOverridesWithArr(t *testing.T
 		repo,
 		WithConfig(config.Config{MainSettings: config.MainSettingsConfig{TMDBAPI: "token"}}),
 		WithTMDBClient(&stubTMDB{metadata: tmdb.MetadataResult{Title: "Example", Year: 2022}}),
-		WithIMDBClient(&stubIMDB{info: imdb.Info{IMDbID: "tt0000777", Title: "Example", Year: 2022}}),
+		WithIMDBClient(&stubIMDB{info: imdb.Info{
+			IMDbID: "tt0000777",
+			Title:  "Example",
+			Year:   2022,
+		}}),
 		WithTVDBClient(&stubTVDB{}),
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: "/data/Example.2022.mkv",
 		ArrSource:  "radarr",
 		ArrTMDBID:  123,
@@ -153,18 +163,18 @@ func TestResolveExternalIDsDoesNotOverwriteExplicitOverridesWithArr(t *testing.T
 		},
 	})
 	if err != nil {
-		t.Fatalf("ResolveExternalIDs returned error: %v", err)
+		t.Fatalf("resolveExternalIdentity returned error: %v", err)
 	}
-	if result.ExternalIDs.TMDBID != overrideTMDB || result.ExternalIDs.SourceTMDB != "override" {
-		t.Fatalf("expected tmdb override retained, got %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != overrideTMDB || result.Identity.Provenance.TMDB != api.IdentityProvenanceExplicit || result.Identity.Overrides.TMDB != api.OverrideStateValue {
+		t.Fatalf("expected tmdb override retained, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.IMDBID != overrideIMDB || result.ExternalIDs.SourceIMDB != "override" {
-		t.Fatalf("expected imdb override retained, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != overrideIMDB || result.Identity.Provenance.IMDB != api.IdentityProvenanceExplicit || result.Identity.Overrides.IMDB != api.OverrideStateValue {
+		t.Fatalf("expected imdb override retained, got %#v", result.Identity)
 	}
 }
 
 func TestResolveSearchYearUsesArrYearBeforeReleaseYear(t *testing.T) {
-	year := resolveSearchYear(api.PreparedMetadata{
+	year := resolveSearchYear(preparationstate.State{
 		ArrYear: 2024,
 		Release: api.ReleaseInfo{
 			Year: 2020,
diff --git a/internal/metadata/bluray.go b/internal/metadata/bluray.go
index 27d30d1d..dd1f0abf 100644
--- a/internal/metadata/bluray.go
+++ b/internal/metadata/bluray.go
@@ -5,43 +5,44 @@ package metadata
 
 import (
 	"context"
-	"fmt"
 	"strings"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/metadata/bluraycom"
 	"github.com/autobrr/upbrr/internal/metadata/discparse"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func (s *Service) applyBlurayMetadata(ctx context.Context, meta api.PreparedMetadata, bdinfo *discparse.BDInfo) (api.PreparedMetadata, error) {
+func (s *Service) applyBlurayMetadata(ctx context.Context, meta preparationstate.State, bdinfo *discparse.BDInfo) preparationstate.State {
 	if reason := s.blurayLookupSkipReason(meta); reason != "" {
 		if s.logger != nil {
 			s.logger.Debugf("metadata: blu-ray.com lookup skipped: %s", reason)
 		}
 		meta = applySelectedBlurayCandidate(meta)
-		return meta, nil
+		return meta
 	}
 
-	imdbID := meta.ExternalIDs.IMDBID
-	if imdbID == 0 && meta.ExternalMetadata.IMDB != nil {
-		imdbID = meta.ExternalMetadata.IMDB.IMDBID
+	imdbID := meta.Identity.IMDBID
+	if imdbID == 0 && meta.ProviderMetadata.IMDB != nil {
+		imdbID = meta.ProviderMetadata.IMDB.IMDBID
 	}
 	if imdbID == 0 {
-		return meta, nil
+		return meta
 	}
 
 	selectedID := ""
-	if meta.ExternalMetadata.Bluray != nil {
-		selectedID = strings.TrimSpace(meta.ExternalMetadata.Bluray.SelectedReleaseID)
+	if meta.ProviderMetadata.Bluray != nil {
+		selectedID = strings.TrimSpace(meta.ProviderMetadata.Bluray.SelectedReleaseID)
 	}
 	if cached := s.reusableBlurayMetadata(meta, imdbID); cached != nil {
 		if selectedID != "" {
 			cached.SelectCandidate(selectedID, false, "manual")
 		}
-		meta.ExternalMetadata.Bluray = cached
+		meta.ProviderMetadata.Bluray = cached
 		meta = applySelectedBlurayCandidate(meta)
-		return meta, nil
+		return meta
 	}
 
 	lookup, err := s.bluray.Lookup(ctx, bluraycom.LookupInput{
@@ -59,10 +60,10 @@ func (s *Service) applyBlurayMetadata(ctx context.Context, meta api.PreparedMeta
 		if s.logger != nil {
 			s.logger.Warnf("metadata: blu-ray.com lookup failed: %v", err)
 		}
-		return meta, nil
+		return meta
 	}
 	if lookup == nil {
-		return meta, nil
+		return meta
 	}
 	if strings.TrimSpace(lookup.SourcePath) == "" {
 		lookup.SourcePath = meta.SourcePath
@@ -70,58 +71,34 @@ func (s *Service) applyBlurayMetadata(ctx context.Context, meta api.PreparedMeta
 	if lookup.UpdatedAt.IsZero() {
 		lookup.UpdatedAt = time.Now().UTC()
 	}
-	merged := meta.ExternalMetadata
-	if stored, err := s.repo.GetExternalMetadata(ctx, meta.SourcePath); err == nil {
-		if merged.TMDB != nil {
-			stored.TMDB = merged.TMDB
-		}
-		if merged.IMDB != nil {
-			stored.IMDB = merged.IMDB
-		}
-		if merged.TVDB != nil {
-			stored.TVDB = merged.TVDB
-		}
-		if merged.TVmaze != nil {
-			stored.TVmaze = merged.TVmaze
-		}
-		merged = stored
-	}
+	merged := meta.ProviderMetadata
 	merged.Bluray = lookup
 	merged.SourcePath = meta.SourcePath
 	merged.UpdatedAt = lookup.UpdatedAt
-	meta.ExternalMetadata = merged
-	if err := s.repo.SaveExternalMetadata(ctx, merged); err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: save blu-ray metadata: %w", err)
-	}
+	meta.ProviderMetadata = merged
 	meta = applySelectedBlurayCandidate(meta)
-	return meta, nil
+	return meta
 }
 
-func (s *Service) shouldLookupBluray(meta api.PreparedMetadata) bool {
+func (s *Service) shouldLookupBluray(meta preparationstate.State) bool {
 	return s.blurayLookupSkipReason(meta) == ""
 }
 
-func (s *Service) blurayLookupSkipReason(meta api.PreparedMetadata) string {
+func (s *Service) blurayLookupSkipReason(meta preparationstate.State) string {
 	if !s.blurayLookupEnabled() {
 		return "metadata.get_bluray_info and description blu-ray options disabled"
 	}
 	if s.bluray == nil {
 		return "blu-ray.com client unavailable"
 	}
-	if s.repo == nil {
-		return "metadata repository unavailable"
-	}
 	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
 	if discType != "BDMV" && discType != "DVD" {
 		return "source is not BDMV/DVD"
 	}
-	if meta.Options.DryRun {
-		return "dry-run enabled"
-	}
-	if meta.ExternalIDs.IMDBID == 0 && (meta.ExternalMetadata.IMDB == nil || meta.ExternalMetadata.IMDB.IMDBID == 0) {
+	if meta.Identity.IMDBID == 0 && (meta.ProviderMetadata.IMDB == nil || meta.ProviderMetadata.IMDB.IMDBID == 0) {
 		return "IMDb ID missing"
 	}
-	if meta.ExternalMetadata.Bluray != nil && len(meta.ExternalMetadata.Bluray.Candidates) > 0 {
+	if meta.ProviderMetadata.Bluray != nil && len(meta.ProviderMetadata.Bluray.Candidates) > 0 {
 		return ""
 	}
 	return ""
@@ -131,11 +108,11 @@ func (s *Service) blurayLookupEnabled() bool {
 	return s.cfg.Metadata.GetBlurayInfo || s.cfg.Description.AddBlurayLink || s.cfg.Description.UseBlurayImages
 }
 
-func (s *Service) reusableBlurayMetadata(meta api.PreparedMetadata, imdbID int) *api.BlurayMetadata {
-	if meta.ExternalMetadata.Bluray == nil {
+func (s *Service) reusableBlurayMetadata(meta preparationstate.State, imdbID int) *api.BlurayMetadata {
+	if meta.ProviderMetadata.Bluray == nil {
 		return nil
 	}
-	bluray := *meta.ExternalMetadata.Bluray
+	bluray := *meta.ProviderMetadata.Bluray
 	if bluray.IMDBID != imdbID || len(bluray.Candidates) == 0 {
 		return nil
 	}
@@ -143,11 +120,11 @@ func (s *Service) reusableBlurayMetadata(meta api.PreparedMetadata, imdbID int)
 	return &bluray
 }
 
-func applySelectedBlurayCandidate(meta api.PreparedMetadata) api.PreparedMetadata {
-	if meta.ExternalMetadata.Bluray == nil {
+func applySelectedBlurayCandidate(meta preparationstate.State) preparationstate.State {
+	if meta.ProviderMetadata.Bluray == nil {
 		return meta
 	}
-	candidate := meta.ExternalMetadata.Bluray.SelectedCandidate()
+	candidate := meta.ProviderMetadata.Bluray.SelectedCandidate()
 	if candidate == nil {
 		return meta
 	}
diff --git a/internal/metadata/bluray_test.go b/internal/metadata/bluray_test.go
index b43ab41a..c97fc70a 100644
--- a/internal/metadata/bluray_test.go
+++ b/internal/metadata/bluray_test.go
@@ -7,6 +7,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
@@ -67,9 +69,9 @@ func TestShouldLookupBlurayWhenDescriptionNeedsBlurayData(t *testing.T) {
 				t.Fatalf("blurayLookupEnabled() = %t, want %t", gotEnabled, tt.wantEnabled)
 			}
 
-			meta := api.PreparedMetadata{
-				DiscType:    "BDMV",
-				ExternalIDs: api.ExternalIDs{IMDBID: 75784},
+			meta := preparationstate.State{
+				DiscType: "BDMV",
+				Identity: api.ExternalIdentity{IMDBID: 75784},
 			}
 			if gotLookup := service.shouldLookupBluray(meta); gotLookup != tt.wantLookup {
 				t.Fatalf("shouldLookupBluray() = %t, want %t", gotLookup, tt.wantLookup)
diff --git a/internal/metadata/bluraycom/client.go b/internal/metadata/bluraycom/client.go
index 304a381f..e18c6f29 100644
--- a/internal/metadata/bluraycom/client.go
+++ b/internal/metadata/bluraycom/client.go
@@ -40,11 +40,15 @@ var (
 	appendImagePattern     = regexp.MustCompile(`(?is)append\(\s*['"](<img\b.*?>)['"]\s*\)`)
 )
 
+// Client queries and parses Blu-ray.com search, release, and product pages.
 type Client struct {
 	httpClient *http.Client
 	logger     api.Logger
 }
 
+// LookupInput supplies the local disc evidence used to filter and score release
+// candidates. Score thresholds use the candidate's 0-100 scale; non-positive
+// values default to 100.
 type LookupInput struct {
 	SourcePath        string
 	IMDBID            int
@@ -64,6 +68,8 @@ type movieLink struct {
 	ProductID   string
 }
 
+// NewClient uses a 30-second HTTP client when client is nil. Only the first
+// optional logger is used, and a nil logger becomes [api.NopLogger].
 func NewClient(client *http.Client, loggers ...api.Logger) *Client {
 	if client == nil {
 		client = &http.Client{Timeout: 30 * time.Second}
@@ -75,6 +81,11 @@ func NewClient(client *http.Client, loggers ...api.Logger) *Client {
 	return &Client{httpClient: client, logger: logger}
 }
 
+// Lookup returns score-sorted release candidates for input.IMDBID and selects an
+// explicit release before applying the score threshold. A non-positive IMDb ID
+// returns no result. Search-page failures abort the lookup; failures for an
+// individual release are skipped or retained as candidate warnings. A nil
+// receiver uses default client settings.
 func (c *Client) Lookup(ctx context.Context, input LookupInput) (*api.BlurayMetadata, error) {
 	if c == nil {
 		c = NewClient(nil)
@@ -303,7 +314,8 @@ func parseReleaseDetails(htmlText string, release api.BlurayReleaseCandidate) (a
 		return release, fmt.Errorf("bluray.com: parse release details html: %w", err)
 	}
 	specsNode := findFirst(root, func(n *html.Node) bool {
-		return n.Type == html.ElementNode && n.Data == "td" && attr(n, "width") == "228px" && strings.Contains(strings.ToLower(attr(n, "style")), "font-size: 12px")
+		return n.Type == html.ElementNode && n.Data == "td" && attr(n, "width") == "228px" &&
+			strings.Contains(strings.ToLower(attr(n, "style")), "font-size: 12px")
 	})
 	if specsNode == nil {
 		release.SpecsMissing = true
diff --git a/internal/metadata/bluraycom/client_test.go b/internal/metadata/bluraycom/client_test.go
index 5bc62f71..f74c74d9 100644
--- a/internal/metadata/bluraycom/client_test.go
+++ b/internal/metadata/bluraycom/client_test.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"net/http"
 	"net/http/httptest"
+	"slices"
 	"strings"
 	"testing"
 
@@ -262,7 +263,12 @@ func TestScoreCandidateHonorsThresholdShape(t *testing.T) {
 	scoreCandidate(&candidate, &discparse.BDInfo{
 		SizeGB: 70,
 		Video:  []discparse.BDVideo{{Codec: "HEVC", Resolution: "2160p"}},
-		Audio:  []discparse.BDAudio{{Language: "English", Codec: "Dolby TrueHD", Channels: "7.1", Atmos: "Atmos"}},
+		Audio: []discparse.BDAudio{{
+			Language: "English",
+			Codec:    "Dolby TrueHD",
+			Channels: "7.1",
+			Atmos:    "Atmos",
+		}},
 		Subtitles: []string{
 			"English",
 		},
@@ -336,9 +342,14 @@ func TestScoreCandidateEdgeCases(t *testing.T) {
 				candidate.Specs.Subtitles = []string{"SDH English"}
 			},
 			bdinfo: &discparse.BDInfo{
-				SizeGB:    70,
-				Video:     []discparse.BDVideo{{Codec: "HEVC", Resolution: "2160p"}},
-				Audio:     []discparse.BDAudio{{Language: "English", Codec: "Dolby TrueHD", Channels: "7.1", Atmos: "Atmos"}},
+				SizeGB: 70,
+				Video:  []discparse.BDVideo{{Codec: "HEVC", Resolution: "2160p"}},
+				Audio: []discparse.BDAudio{{
+					Language: "English",
+					Codec:    "Dolby TrueHD",
+					Channels: "7.1",
+					Atmos:    "Atmos",
+				}},
 				Subtitles: []string{"English SDH"},
 			},
 			wantScore: 100,
@@ -401,18 +412,18 @@ func matchingSpecs() api.BluraySpecs {
 
 func matchingBDInfo() *discparse.BDInfo {
 	return &discparse.BDInfo{
-		SizeGB:    70,
-		Video:     []discparse.BDVideo{{Codec: "HEVC", Resolution: "2160p"}},
-		Audio:     []discparse.BDAudio{{Language: "English", Codec: "Dolby TrueHD", Channels: "7.1", Atmos: "Atmos"}},
+		SizeGB: 70,
+		Video:  []discparse.BDVideo{{Codec: "HEVC", Resolution: "2160p"}},
+		Audio: []discparse.BDAudio{{
+			Language: "English",
+			Codec:    "Dolby TrueHD",
+			Channels: "7.1",
+			Atmos:    "Atmos",
+		}},
 		Subtitles: []string{"English"},
 	}
 }
 
 func hasNote(notes []string, want string) bool {
-	for _, note := range notes {
-		if note == want {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(notes, want)
 }
diff --git a/internal/metadata/bluraycom/parse_helpers.go b/internal/metadata/bluraycom/parse_helpers.go
index 6ef27665..302e5469 100644
--- a/internal/metadata/bluraycom/parse_helpers.go
+++ b/internal/metadata/bluraycom/parse_helpers.go
@@ -29,8 +29,8 @@ func attr(n *html.Node, key string) string {
 }
 
 func hasClass(n *html.Node, className string) bool {
-	classes := strings.Fields(attr(n, "class"))
-	for _, class := range classes {
+	classes := strings.FieldsSeq(attr(n, "class"))
+	for class := range classes {
 		if class == className {
 			return true
 		}
diff --git a/internal/metadata/client_evidence.go b/internal/metadata/client_evidence.go
new file mode 100644
index 00000000..faf3b03e
--- /dev/null
+++ b/internal/metadata/client_evidence.go
@@ -0,0 +1,167 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/clientdiscovery"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// collectClientEvidence performs the preparation-owned client search and
+// retains its explicit disposition with the detached result.
+func (s *Service) collectClientEvidence(
+	ctx context.Context,
+	input api.PrepareInput,
+	state preparationstate.State,
+) (preparationstate.State, error) {
+	evidence, err := s.discoverClientEvidence(ctx, input, state.SourcePath, state.FileList, state.DiscType)
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	applyClientEvidence(&state, input, evidence)
+	return state, nil
+}
+
+func (s *Service) discoverClientEvidence(
+	ctx context.Context,
+	input api.PrepareInput,
+	sourcePath string,
+	fileList []string,
+	discType string,
+) (clientdiscovery.Evidence, error) {
+	if s.clients == nil {
+		return clientdiscovery.Evidence{Disposition: clientdiscovery.DispositionUnavailable}, nil
+	}
+	evidence, err := s.clients.Discover(ctx, clientdiscovery.SearchInput{
+		SourcePath:   sourcePath,
+		FileList:     fileList,
+		DiscType:     discType,
+		Policy:       input.Search,
+		ForceRecheck: input.Controls.ForceRecheck,
+	})
+	if err != nil {
+		return clientdiscovery.Evidence{}, fmt.Errorf("metadata: discover client evidence: %w", err)
+	}
+	return evidence, nil
+}
+
+// applyClientEvidence merges a detached client snapshot into preparation state.
+// Explicit tracker IDs already present in state take precedence over discovered IDs.
+func applyClientEvidence(state *preparationstate.State, input api.PrepareInput, evidence clientdiscovery.Evidence) {
+	if state == nil {
+		return
+	}
+	state.ClientEvidence = clientEvidenceSnapshot(input, evidence)
+	if evidence.InfoHash != "" {
+		state.InfoHash = evidence.InfoHash
+	}
+	if evidence.TorrentPath != "" {
+		state.DiscoveredTorrentPath = evidence.TorrentPath
+	}
+	if state.TrackerIDs == nil && len(evidence.TrackerIDs) > 0 {
+		state.TrackerIDs = make(map[string]string, len(evidence.TrackerIDs))
+	}
+	for key, value := range evidence.TrackerIDs {
+		if _, exists := state.TrackerIDs[key]; !exists {
+			state.TrackerIDs[key] = value
+		}
+	}
+	state.FoundTrackerMatch = evidence.FoundTrackerMatch
+	state.TorrentComments = cloneTorrentMatches(evidence.TorrentComments)
+	state.PieceSizeConstraint = evidence.PieceSizeConstraint
+	state.FoundPreferredPiece = evidence.FoundPreferredPiece
+	state.MatchedEvidenceTrackers = mergeNormalizedTrackers(state.MatchedEvidenceTrackers, evidence.MatchedTrackers)
+	state.EvidenceTrackers = mergeNormalizedTrackers(state.EvidenceTrackers, evidence.MatchedTrackers)
+}
+
+func clientEvidenceSnapshot(input api.PrepareInput, evidence clientdiscovery.Evidence) preparationstate.ClientEvidenceSnapshot {
+	result := api.ClientSearchResult{
+		InfoHash:            evidence.InfoHash,
+		TorrentPath:         evidence.TorrentPath,
+		TrackerIDs:          cloneTrackerIDs(evidence.TrackerIDs),
+		FoundTrackerMatch:   evidence.FoundTrackerMatch,
+		TorrentComments:     cloneTorrentMatches(evidence.TorrentComments),
+		PieceSizeConstraint: evidence.PieceSizeConstraint,
+		FoundPreferredPiece: evidence.FoundPreferredPiece,
+		MatchedTrackers:     append([]string(nil), evidence.MatchedTrackers...),
+	}
+	disposition := preparationstate.ClientEvidenceDispositionUnknown
+	switch evidence.Disposition {
+	case clientdiscovery.DispositionSearched:
+		disposition = preparationstate.ClientEvidenceDispositionSearched
+	case clientdiscovery.DispositionSkipped:
+		disposition = preparationstate.ClientEvidenceDispositionSkipped
+	case clientdiscovery.DispositionUnavailable:
+		disposition = preparationstate.ClientEvidenceDispositionUnavailable
+	}
+	forced := input.Controls.ForceRecheck != nil && *input.Controls.ForceRecheck && disposition == preparationstate.ClientEvidenceDispositionSearched
+	return preparationstate.CloneClientEvidenceSnapshot(preparationstate.ClientEvidenceSnapshot{
+		Disposition:   disposition,
+		Policy:        input.Search,
+		ForcedRecheck: forced,
+		Result:        result,
+	})
+}
+
+// HydrateClientEvidence rebuilds only the private client snapshot needed when
+// a compatible persisted generation is first reused after process restart.
+func (s *Service) HydrateClientEvidence(
+	ctx context.Context,
+	request preparationstate.Request,
+) (preparationstate.ClientEvidenceSnapshot, error) {
+	files := make([]string, 0, len(request.Manifest.Entries))
+	for _, entry := range request.Manifest.Entries {
+		if entry.Type == api.SourceEntryTypeFile || entry.Type == api.SourceEntryTypePlaylist {
+			files = append(files, entry.Path)
+		}
+	}
+	discType := request.Layout.DiscType
+	if strings.TrimSpace(discType) == "" {
+		discType = request.Manifest.Classification.DiscType
+	}
+	evidence, err := s.discoverClientEvidence(ctx, request.Input, request.Manifest.SourcePath, files, discType)
+	if err != nil {
+		return preparationstate.ClientEvidenceSnapshot{}, fmt.Errorf("metadata: hydrate client evidence: %w", err)
+	}
+	return clientEvidenceSnapshot(request.Input, evidence), nil
+}
+
+// mergeNormalizedTrackers preserves first-seen order while deduplicating uppercase names.
+func mergeNormalizedTrackers(existing []string, additional []string) []string {
+	seen := make(map[string]struct{}, len(existing)+len(additional))
+	result := make([]string, 0, len(existing)+len(additional))
+	for _, values := range [][]string{existing, additional} {
+		for _, value := range values {
+			value = strings.ToUpper(strings.TrimSpace(value))
+			if value == "" {
+				continue
+			}
+			if _, ok := seen[value]; ok {
+				continue
+			}
+			seen[value] = struct{}{}
+			result = append(result, value)
+		}
+	}
+	return result
+}
+
+// cloneTorrentMatches detaches nested URL slices before evidence enters mutable state.
+func cloneTorrentMatches(values []api.TorrentMatch) []api.TorrentMatch {
+	if values == nil {
+		return nil
+	}
+	result := make([]api.TorrentMatch, len(values))
+	for index, value := range values {
+		result[index] = value
+		result[index].TrackerURLsRaw = append([]string(nil), value.TrackerURLsRaw...)
+		result[index].TrackerURLs = append([]api.TrackerMatch(nil), value.TrackerURLs...)
+	}
+	return result
+}
diff --git a/internal/metadata/client_evidence_test.go b/internal/metadata/client_evidence_test.go
new file mode 100644
index 00000000..0c1ae890
--- /dev/null
+++ b/internal/metadata/client_evidence_test.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/clientdiscovery"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/metadata/tmdb"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type metadataClientRecorder struct {
+	calls int
+	input api.ClientSubject
+}
+
+func (*metadataClientRecorder) Inject(context.Context, api.ClientSubject, api.TorrentResult) error {
+	return nil
+}
+
+func (c *metadataClientRecorder) SearchPathedTorrents(_ context.Context, input api.ClientSubject) (api.ClientSearchResult, error) {
+	c.calls++
+	c.input = input
+	return api.ClientSearchResult{
+		InfoHash:            "client-hash",
+		TorrentPath:         "Example.Release.2026.torrent",
+		TrackerIDs:          map[string]string{"btn": "client-id", "aither": "aither-id"},
+		FoundTrackerMatch:   true,
+		TorrentComments:     []api.TorrentMatch{{Name: "Example.Release.2026"}},
+		PieceSizeConstraint: "4194304",
+		FoundPreferredPiece: "4194304",
+		MatchedTrackers:     []string{"BTN", "AITHER"},
+	}, nil
+}
+
+func TestCollectClientEvidencePrecedesTrackerCandidatesAndPreservesExplicitIDs(t *testing.T) {
+	t.Parallel()
+
+	client := &metadataClientRecorder{}
+	service := &Service{clients: clientdiscovery.New(client, api.NopLogger{})}
+	state, err := service.collectClientEvidence(context.Background(), api.PrepareInput{
+		Instructions: api.ReleaseFactInstructions{TrackerIDs: map[string]string{"btn": "explicit-id"}},
+		Search:       api.ClientSearchPolicy{},
+	}, preparationstate.State{
+		SourcePath: "Example.Release.2026.mkv",
+		FileList:   []string{"Example.Release.2026.mkv"},
+		TrackerIDs: map[string]string{"btn": "explicit-id"},
+	})
+	if err != nil {
+		t.Fatalf("collect client evidence: %v", err)
+	}
+	if client.calls != 1 || client.input.SourcePath != "Example.Release.2026.mkv" {
+		t.Fatalf("client calls=%d input=%#v", client.calls, client.input)
+	}
+	if state.TrackerIDs["btn"] != "explicit-id" || state.TrackerIDs["aither"] != "aither-id" {
+		t.Fatalf("tracker IDs = %#v", state.TrackerIDs)
+	}
+	if state.InfoHash != "client-hash" || state.DiscoveredTorrentPath != "Example.Release.2026.torrent" || !state.FoundTrackerMatch {
+		t.Fatalf("client state = %#v", state)
+	}
+	if state.PieceSizeConstraint != "4194304" || state.FoundPreferredPiece != "4194304" || len(state.TorrentComments) != 1 {
+		t.Fatalf("retained evidence = %#v", state)
+	}
+	candidates := normalizeTrackers(resolveTrackerCandidates(state))
+	if !slices.Equal(candidates, []string{"AITHER", "BTN"}) {
+		t.Fatalf("tracker candidates = %#v", candidates)
+	}
+}
+
+func TestHydrateClientEvidenceSearchesManifestFilesOnce(t *testing.T) {
+	t.Parallel()
+
+	client := &metadataClientRecorder{}
+	service := &Service{clients: clientdiscovery.New(client, api.NopLogger{})}
+	force := true
+	snapshot, err := service.HydrateClientEvidence(context.Background(), preparationstate.Request{
+		Input: api.PrepareInput{
+			Search:   api.ClientSearchPolicy{},
+			Controls: api.PreparationControls{ForceRecheck: &force},
+		},
+		Manifest: api.SourceManifest{
+			SourcePath: "C:\\media\\Example.Release.2026",
+			Entries: []api.SourceManifestEntry{
+				{Path: "video.mkv", Type: api.SourceEntryTypeFile},
+				{Path: "playlist.mpls", Type: api.SourceEntryTypePlaylist},
+				{Path: "BDMV", Type: api.SourceEntryTypeDirectory},
+			},
+		},
+		Layout: sourcelayout.Layout{DiscType: "BDMV"},
+	})
+	if err != nil {
+		t.Fatalf("hydrate client evidence: %v", err)
+	}
+	if client.calls != 1 || !slices.Equal(client.input.FileList, []string{"video.mkv", "playlist.mpls"}) || client.input.DiscType != "BDMV" {
+		t.Fatalf("hydration search calls=%d input=%#v", client.calls, client.input)
+	}
+	if snapshot.Disposition != preparationstate.ClientEvidenceDispositionSearched || !snapshot.ForcedRecheck ||
+		snapshot.Result.InfoHash != "client-hash" {
+		t.Fatalf("hydrated snapshot = %#v", snapshot)
+	}
+}
+
+type pipelineClientRecorder struct {
+	calls int
+}
+
+func (*pipelineClientRecorder) Inject(context.Context, api.ClientSubject, api.TorrentResult) error {
+	return nil
+}
+
+func (c *pipelineClientRecorder) SearchPathedTorrents(context.Context, api.ClientSubject) (api.ClientSearchResult, error) {
+	c.calls++
+	return api.ClientSearchResult{TrackerIDs: map[string]string{"ant": "client-release-id"}}, nil
+}
+
+func TestCanonicalEvidencePipelineUsesClientTrackerIDBeforeProviderResolution(t *testing.T) {
+	t.Parallel()
+
+	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
+	if err := os.WriteFile(sourcePath, []byte("synthetic media"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	client := &pipelineClientRecorder{}
+	lookup := &stubTrackerLookup{results: map[string]trackerdata.Result{
+		"ANT": {TMDBID: 1234567, TrackerID: "client-release-id"},
+	}}
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"ANT": {APIKey: "synthetic-api-key"},
+	}}}
+	service := NewService(
+		&fakeRepo{},
+		WithConfig(cfg),
+		WithMediaInfoExporter(stubMediaInfo{}),
+		WithSceneDetector(stubSceneDetector{}),
+		WithClientDiscovery(clientdiscovery.New(client, api.NopLogger{})),
+		WithTrackerDataLookup(lookup),
+		WithTMDBClient(&stubTMDB{metadata: tmdb.MetadataResult{Title: "Example Release", Year: 2026}}),
+		WithIMDBClient(&stubIMDB{}),
+		WithTVDBClient(&stubTVDB{}),
+		WithTVmazeClient(&stubTVmaze{}),
+	)
+
+	var progress []api.PreparationProgressUpdate
+	ctx := api.WithPreparationProgressReporter(context.Background(), func(update api.PreparationProgressUpdate) {
+		progress = append(progress, update)
+	})
+	state, err := service.CollectPreparationEvidence(ctx, testCollectionRequest(t, api.Request{SourcePath: sourcePath}))
+	if err != nil {
+		t.Fatalf("collect canonical evidence: %v", err)
+	}
+	if client.calls != 1 || !slices.Equal(lookup.Calls(), []string{"ANT"}) {
+		t.Fatalf("client calls=%d tracker calls=%v", client.calls, lookup.Calls())
+	}
+	if state.Identity.TMDBID != 1234567 || state.ProviderMetadata.TMDB == nil || state.ProviderMetadata.TMDB.TMDBID != 1234567 {
+		t.Fatalf("identity/provider did not use client-derived tracker evidence: identity=%#v provider=%#v", state.Identity, state.ProviderMetadata.TMDB)
+	}
+	var completed []api.PreparationProgressPhase
+	for _, update := range progress {
+		if update.Status == api.PreparationProgressCompleted {
+			completed = append(completed, update.Phase)
+		}
+	}
+	wantCompleted := []api.PreparationProgressPhase{
+		api.PreparationPhaseSourceEvidence,
+		api.PreparationPhaseClientDiscovery,
+		api.PreparationPhaseTrackerEvidence,
+		api.PreparationPhaseMediaInfoIdentity,
+		api.PreparationPhaseArrIdentity,
+		api.PreparationPhaseExternalIdentity,
+		api.PreparationPhaseMediaFacts,
+	}
+	if !slices.Equal(completed, wantCompleted) {
+		t.Fatalf("completed progress phases=%v, want %v", completed, wantCompleted)
+	}
+}
diff --git a/internal/metadata/collection.go b/internal/metadata/collection.go
new file mode 100644
index 00000000..3d2716d5
--- /dev/null
+++ b/internal/metadata/collection.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// CollectPreparationEvidence owns the complete ordered metadata collection
+// sequence. Canonical preparation sees one deep collection port; intermediate
+// mutable evidence and step ordering do not escape this package.
+func (s *Service) CollectPreparationEvidence(ctx context.Context, request preparationstate.Request) (preparationstate.State, error) {
+	state, err := collectPreparationStage(ctx, api.PreparationPhaseSourceEvidence, func() (preparationstate.State, error) {
+		return s.collectSourceEvidence(ctx, request)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	state, err = collectPreparationStage(ctx, api.PreparationPhaseClientDiscovery, func() (preparationstate.State, error) {
+		return s.collectClientEvidence(ctx, request.Input, state)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	state, err = collectPreparationStage(ctx, api.PreparationPhaseTrackerEvidence, func() (preparationstate.State, error) {
+		return s.collectTrackerEvidence(ctx, state)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	state, err = collectPreparationStage(ctx, api.PreparationPhaseMediaInfoIdentity, func() (preparationstate.State, error) {
+		return s.collectMediaInfoIdentityEvidence(ctx, state)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	state, err = collectPreparationStage(ctx, api.PreparationPhaseArrIdentity, func() (preparationstate.State, error) {
+		return s.collectArrIdentityEvidence(ctx, state)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	state, err = collectPreparationStage(ctx, api.PreparationPhaseExternalIdentity, func() (preparationstate.State, error) {
+		return s.collectExternalIdentityEvidence(ctx, state)
+	})
+	if err != nil {
+		return preparationstate.State{}, err
+	}
+	return collectPreparationStage(ctx, api.PreparationPhaseMediaFacts, func() (preparationstate.State, error) {
+		return s.deriveMediaFacts(ctx, state)
+	})
+}
+
+// collectPreparationStage brackets one collection step with advisory progress
+// while preserving the collector's state and error result unchanged.
+func collectPreparationStage(
+	ctx context.Context,
+	phase api.PreparationProgressPhase,
+	collect func() (preparationstate.State, error),
+) (state preparationstate.State, err error) {
+	finish := api.BeginPreparationProgress(ctx, phase, "Stage started.")
+	defer func() { finish(err) }()
+	return collect()
+}
diff --git a/internal/metadata/discparse/bdinfo.go b/internal/metadata/discparse/bdinfo.go
index d7c9d0f9..e3950de0 100644
--- a/internal/metadata/discparse/bdinfo.go
+++ b/internal/metadata/discparse/bdinfo.go
@@ -14,6 +14,8 @@ import (
 
 var playlistReportHeaderPattern = regexp.MustCompile(`(?m)^\*{20}\r?\nPLAYLIST:\s+([^\r\n]+)\r?\n\*{20}`)
 
+// PlaylistReport preserves one raw BDInfo playlist block together with its
+// extracted quick-summary, files, and extended-summary sections.
 type PlaylistReport struct {
 	Playlist   string
 	Raw        string
@@ -22,6 +24,8 @@ type PlaylistReport struct {
 	ExtSummary string
 }
 
+// NormalizePlaylistName reduces slash- or backslash-delimited input to an
+// uppercase MPLS basename, adding the extension when absent.
 func NormalizePlaylistName(name string) string {
 	trimmed := strings.TrimSpace(name)
 	trimmed = strings.ReplaceAll(trimmed, "\\", "/")
@@ -87,7 +91,9 @@ func normalizeSummarySpaces(text string) string {
 	return strings.Join(lines, "\n")
 }
 
-// SplitBDInfoPlaylistReports extracts each playlist section from a full BDInfo report.
+// SplitBDInfoPlaylistReports extracts playlist blocks keyed by normalized MPLS
+// basename. Reports without playlist headers return nil; duplicate normalized
+// names fail the entire parse.
 func SplitBDInfoPlaylistReports(text string) (map[string]string, error) {
 	matches := playlistReportHeaderPattern.FindAllStringSubmatchIndex(text, -1)
 	if len(matches) == 0 {
@@ -118,6 +124,8 @@ func SplitBDInfoPlaylistReports(text string) (map[string]string, error) {
 }
 
 // ExtractPlaylistReports returns selected playlist reports in selection order.
+// Missing blocks or quick summaries fail the entire extraction without a
+// partial result.
 func ExtractPlaylistReports(text string, selected []string) ([]PlaylistReport, error) {
 	if len(selected) == 0 {
 		return nil, nil
diff --git a/internal/metadata/discparse/types.go b/internal/metadata/discparse/types.go
index 26ebce01..eff97117 100644
--- a/internal/metadata/discparse/types.go
+++ b/internal/metadata/discparse/types.go
@@ -34,6 +34,9 @@ type PlaylistItem struct {
 	Size int64
 }
 
+// BDInfo contains normalized fields parsed from a BDInfo quick summary. SizeGB
+// is measured in binary GiB despite its historical field name; Path remains a
+// host filesystem path supplied by the caller.
 type BDInfo struct {
 	Playlist  string
 	SizeGB    float64
diff --git a/internal/metadata/dvd_resolution_test.go b/internal/metadata/dvd_resolution_test.go
index e28e7fbf..a1d3fbac 100644
--- a/internal/metadata/dvd_resolution_test.go
+++ b/internal/metadata/dvd_resolution_test.go
@@ -6,11 +6,11 @@ package metadata
 import (
 	"testing"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
 )
 
 func TestExtractDVDMediaInfoFromVOBJSON(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType:            "DVD",
 		SourcePath:          `/releases/Movie.DVD`,
 		DVDVOBMediaInfoJSON: `{"media":{"track":[{"@type":"General"},{"@type":"Video","Width":"720","Height":"576","FrameRate":"25.000","ScanType":"Interlaced"}]}}`,
@@ -29,7 +29,7 @@ func TestExtractDVDMediaInfoFromVOBJSON(t *testing.T) {
 }
 
 func TestExtractDVDMediaInfoFallsBackToText(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType:            "DVD",
 		SourcePath:          `/releases/Movie.DVD`,
 		DVDVOBMediaInfoJSON: `{"media":{"track":[{"@type":"General"},{"@type":"Video"}]}}`,
@@ -52,7 +52,7 @@ func TestExtractDVDMediaInfoFallsBackToText(t *testing.T) {
 }
 
 func TestExtractDVDMediaInfoUsesInterlacedHintFromSourcePath(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType:            "DVD",
 		SourcePath:          `/releases/Movie.1080i.DVD`,
 		DVDVOBMediaInfoJSON: `{"media":{"track":[{"@type":"General"},{"@type":"Video","Width":"1920","Height":"1080","FrameRate":"25.000"}]}}`,
@@ -68,7 +68,7 @@ func TestExtractDVDMediaInfoUsesInterlacedHintFromSourcePath(t *testing.T) {
 }
 
 func TestExtractDVDMediaInfoDefaultsUnknownScanToProgressive(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType:            "DVD",
 		SourcePath:          `/releases/Movie.DVD`,
 		DVDVOBMediaInfoJSON: `{"media":{"track":[{"@type":"General"},{"@type":"Video","Width":"720","Height":"576","FrameRate":"25.000"}]}}`,
@@ -84,7 +84,7 @@ func TestExtractDVDMediaInfoDefaultsUnknownScanToProgressive(t *testing.T) {
 }
 
 func TestExtractDVDMediaInfoDoesNotOverrideJSONProgressiveScan(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType:            "DVD",
 		SourcePath:          `/releases/Movie.DVD`,
 		DVDVOBMediaInfoJSON: `{"media":{"track":[{"@type":"General"},{"@type":"Video","Width":"720","Height":"576","FrameRate":"25.000","ScanType":"Progressive"}]}}`,
diff --git a/internal/metadata/external_ids.go b/internal/metadata/external_ids.go
index 98ee4751..62988dd1 100644
--- a/internal/metadata/external_ids.go
+++ b/internal/metadata/external_ids.go
@@ -18,6 +18,8 @@ import (
 	"time"
 	"unicode"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"golang.org/x/sync/errgroup"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
@@ -28,24 +30,27 @@ import (
 	"github.com/autobrr/upbrr/internal/metadata/tmdb"
 	"github.com/autobrr/upbrr/internal/metadata/tvdb"
 	"github.com/autobrr/upbrr/internal/metadata/tvmaze"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 var (
-	searchYearPattern       = regexp.MustCompile(`\b(19\d{2}|20\d{2})\b`)
-	leadingSearchYearTitle  = regexp.MustCompile(`^\s*(19\d{2}|20\d{2})\s*[-:._]\s*(.+?)\s*$`)
-	searchBracketNoise      = regexp.MustCompile(`[\[\(\{][^\]\)\}]*[\]\)\}]`)
-	searchInnerWhitespace   = regexp.MustCompile(`\s+`)
-	tvdbAliasYearPattern    = regexp.MustCompile(`\b(19\d{2}|20\d{2})\b`)
-	tvdbAliasYearCleanup    = regexp.MustCompile(`\s*\(?\b(?:19\d{2}|20\d{2})\b\)?\s*`)
-	tvPathHintPattern       = regexp.MustCompile(`(?i)[\\/](tv|tvshows?|series)[\\/]`)
-	tvNameHintPattern       = regexp.MustCompile(`(?i)\bS\d{1,2}(?:E\d{1,3})?\b|\b\d{1,2}x\d{2,3}\b|\b(?:season|series)\s*\d+\b|\b(19\d{2}|20\d{2})[.-]\d{2}[.-]\d{2}\b`)
-	subsPleaseHintPattern   = regexp.MustCompile(`(?i)subsplease`)
-	animeEpisodeHint        = regexp.MustCompile(`(?i)-\s*\d{1,3}\s*\(1080p\)`)
-	genericEpisodePattern   = regexp.MustCompile(`(?i)^episode\s*#?\s*(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*$`)
+	searchYearPattern      = regexp.MustCompile(`\b(19\d{2}|20\d{2})\b`)
+	leadingSearchYearTitle = regexp.MustCompile(`^\s*(19\d{2}|20\d{2})\s*[-:._]\s*(.+?)\s*$`)
+	searchBracketNoise     = regexp.MustCompile(`[\[\(\{][^\]\)\}]*[\]\)\}]`)
+	searchInnerWhitespace  = regexp.MustCompile(`\s+`)
+	tvdbAliasYearPattern   = regexp.MustCompile(`\b(19\d{2}|20\d{2})\b`)
+	tvdbAliasYearCleanup   = regexp.MustCompile(`\s*\(?\b(?:19\d{2}|20\d{2})\b\)?\s*`)
+	tvPathHintPattern      = regexp.MustCompile(`(?i)[\\/](tv|tvshows?|series)[\\/]`)
+	tvNameHintPattern      = regexp.MustCompile(
+		`(?i)\bS\d{1,2}(?:E\d{1,3})?\b|\b\d{1,2}x\d{2,3}\b|\b(?:season|series)\s*\d+\b|\b(19\d{2}|20\d{2})[.-]\d{2}[.-]\d{2}\b`,
+	)
+	subsPleaseHintPattern = regexp.MustCompile(`(?i)subsplease`)
+	animeEpisodeHint      = regexp.MustCompile(`(?i)-\s*\d{1,3}\s*\(1080p\)`)
+	genericEpisodePattern = regexp.MustCompile(
+		`(?i)^episode\s*#?\s*(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*$`,
+	)
 	placeholderTitlePattern = regexp.MustCompile(`(?i)^(?:tba|tbd|tbc|tdc)$`)
 )
 
@@ -93,138 +98,137 @@ type TVmazeClient interface {
 	GetEpisodeByDate(ctx context.Context, tvmazeID int, airdate string) (*tvmaze.EpisodeData, error)
 }
 
-// ResolveExternalIDs resolves and persists cross-provider IDs and metadata for
-// a prepared item, honoring fresh stored data, overrides, scene IDs, and tracker
-// matches before falling back to provider searches. Without a configured or
-// injected TMDB client, it preserves independently resolved TMDB IDs while
-// skipping TMDB searches and enrichment; other providers continue normally.
-// Selected BJS, BT, and ASC targets trigger pt-BR TMDB localized metadata when
-// both a TMDB ID and client are available.
-func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+type externalIdentityCandidateEvidence struct {
+	TMDB []api.ExternalIdentityCandidate
+	IMDB []api.ExternalIdentityCandidate
+}
+
+// collectExternalIdentityEvidence resolves provider evidence without publishing
+// identity or provider metadata. The prepared-release owner commits the
+// candidate with the complete generation.
+func (s *Service) collectExternalIdentityEvidence(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
+	return s.collectProviderIdentityCandidate(ctx, meta)
+}
+
+func (s *Service) collectProviderIdentityCandidate(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
 	if s.repo == nil {
-		return api.PreparedMetadata{}, internalerrors.ErrInvalidInput
+		return preparationstate.State{}, internalerrors.ErrInvalidInput
 	}
 	if strings.TrimSpace(meta.SourcePath) == "" {
-		return api.PreparedMetadata{}, internalerrors.ErrInvalidInput
+		return preparationstate.State{}, internalerrors.ErrInvalidInput
 	}
 
-	ids := api.ExternalIDs{SourcePath: meta.SourcePath}
-	if meta.StoredDataFresh && sourceScopedMetadataMatches(meta.ExternalIDs.SourcePath, meta.SourcePath) {
-		ids = meta.ExternalIDs
+	ids := api.ExternalIdentity{SourcePath: meta.SourcePath}
+	if meta.StoredDataFresh && sourceScopedMetadataMatches(meta.Identity.SourcePath, meta.SourcePath) {
+		ids = meta.Identity
 		if strings.TrimSpace(ids.SourcePath) == "" {
 			ids.SourcePath = meta.SourcePath
 		}
 	}
-	if meta.Options.SkipAutoTorrent {
-		clearTrackerSourcedExternalIDs(&ids)
-	}
-	metadata := api.ExternalMetadata{SourcePath: meta.SourcePath}
-	if meta.StoredDataFresh && sourceScopedMetadataMatches(meta.ExternalMetadata.SourcePath, meta.SourcePath) {
-		metadata = meta.ExternalMetadata
+	metadata := api.SourceScopedMetadata{SourcePath: meta.SourcePath}
+	if meta.StoredDataFresh && sourceScopedMetadataMatches(meta.ProviderMetadata.SourcePath, meta.SourcePath) {
+		metadata = meta.ProviderMetadata
 		if strings.TrimSpace(metadata.SourcePath) == "" {
 			metadata.SourcePath = meta.SourcePath
 		}
 	} else {
 		storedMeta, err := s.repo.GetExternalMetadata(ctx, meta.SourcePath)
 		if err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: load stored external metadata: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: load stored external metadata: %w", err)
 		}
 		if err == nil {
 			metadata.Bluray = storedMeta.Bluray
 			metadata.AniList = storedMeta.AniList
 		}
 	}
-	candidates := api.ExternalIDCandidates{}
+	candidates := externalIdentityCandidateEvidence{}
 	categoryPref := resolveCategoryPreference(meta)
 	if categoryPref != "" {
-		ids.Category = categoryPref
+		ids.Category, _ = api.NormalizeCanonicalCategory(categoryPref)
 	}
-	tmdbCategoryPref := normalizeCategory(ids.Category)
+	tmdbCategoryPref := normalizeCategory(string(ids.Category))
 	if s.logger != nil {
 		s.logger.Debugf("metadata: external ids start path=%q category=%q", meta.SourcePath, ids.Category)
 	}
 
-	overrideTMDB, clearedTMDB := applyOverrideID(&ids.TMDBID, &ids.SourceTMDB, meta.ExternalIDOverrides.TMDBID)
-	overrideIMDB, clearedIMDB := applyOverrideID(&ids.IMDBID, &ids.SourceIMDB, meta.ExternalIDOverrides.IMDBID)
-	overrideTVDB, clearedTVDB := applyOverrideID(&ids.TVDBID, &ids.SourceTVDB, meta.ExternalIDOverrides.TVDBID)
-	overrideTVmaze, _ := applyOverrideID(&ids.TVmazeID, &ids.SourceTVmaze, meta.ExternalIDOverrides.TVmazeID)
-	overrideMAL, clearedMAL := applyOverrideID(&ids.MALID, &ids.SourceMAL, meta.ExternalIDOverrides.MALID)
+	overrideTMDB, clearedTMDB := applyOverrideID(&ids.TMDBID, &ids.Provenance.TMDB, &ids.Overrides.TMDB, meta.ExternalIDOverrides.TMDBID)
+	overrideIMDB, clearedIMDB := applyOverrideID(&ids.IMDBID, &ids.Provenance.IMDB, &ids.Overrides.IMDB, meta.ExternalIDOverrides.IMDBID)
+	overrideTVDB, clearedTVDB := applyOverrideID(&ids.TVDBID, &ids.Provenance.TVDB, &ids.Overrides.TVDB, meta.ExternalIDOverrides.TVDBID)
+	overrideTVmaze, _ := applyOverrideID(&ids.TVmazeID, &ids.Provenance.TVmaze, &ids.Overrides.TVmaze, meta.ExternalIDOverrides.TVmazeID)
+	overrideMAL, clearedMAL := applyOverrideID(&ids.MALID, &ids.Provenance.MAL, &ids.Overrides.MAL, meta.ExternalIDOverrides.MALID)
 
-	trackerTMDB, trackerIMDB, trackerTVDB, trackerMAL := 0, 0, 0, 0
-	if !meta.Options.SkipAutoTorrent || meta.SourceLookupActive {
-		trackerTMDB, trackerIMDB, trackerTVDB, trackerMAL = resolveTrackerIDs(meta.TrackerData)
-	}
+	trackerTMDB, trackerIMDB, trackerTVDB, trackerMAL := resolveTrackerIDs(meta.TrackerData)
 	if !overrideTMDB && !clearedTMDB {
-		applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, trackerTMDB, "tracker")
+		applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, trackerTMDB, "tracker")
 	}
 	if !overrideIMDB && !clearedIMDB {
-		applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, trackerIMDB, "tracker")
+		applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, trackerIMDB, "tracker")
 	}
 	if !overrideTVDB && !clearedTVDB {
-		applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, trackerTVDB, "tracker")
+		applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, trackerTVDB, "tracker")
 	}
 	if !overrideMAL && !clearedMAL {
-		applyResolvedID(&ids.MALID, &ids.SourceMAL, trackerMAL, "tracker")
+		applyResolvedID(&ids.MALID, &ids.Provenance.MAL, trackerMAL, "tracker")
 	}
 
 	if !overrideTMDB && !clearedTMDB {
-		applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, meta.MediaInfoTMDBID, "mediainfo")
+		applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, meta.MediaInfoTMDBID, "mediainfo")
 	}
 	if !overrideIMDB && !clearedIMDB {
-		applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, meta.MediaInfoIMDBID, "mediainfo")
+		applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, meta.MediaInfoIMDBID, "mediainfo")
 	}
 	if !overrideTVDB && !clearedTVDB {
-		applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, meta.MediaInfoTVDBID, "mediainfo")
+		applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, meta.MediaInfoTVDBID, "mediainfo")
 	}
 
 	if !overrideTMDB && !clearedTMDB {
-		applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, meta.SceneTMDBID, "scene")
+		applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, meta.SceneTMDBID, "scene")
 	}
 	if !overrideIMDB && !clearedIMDB {
-		applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, meta.SceneIMDB, "scene")
+		applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, meta.SceneIMDB, "scene")
 	}
 	if !overrideTVDB && !clearedTVDB {
-		applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, meta.SceneTVDBID, "scene")
+		applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, meta.SceneTVDBID, "scene")
 	}
 	if !overrideTVmaze {
-		applyResolvedID(&ids.TVmazeID, &ids.SourceTVmaze, meta.SceneTVmazeID, "scene")
+		applyResolvedID(&ids.TVmazeID, &ids.Provenance.TVmaze, meta.SceneTVmazeID, "scene")
 	}
 	if !overrideMAL && !clearedMAL {
-		applyResolvedID(&ids.MALID, &ids.SourceMAL, meta.SceneMALID, "scene")
+		applyResolvedID(&ids.MALID, &ids.Provenance.MAL, meta.SceneMALID, "scene")
 	}
 	if !overrideMAL && !clearedMAL {
-		applyResolvedID(&ids.MALID, &ids.SourceMAL, meta.MALID, "prepared")
+		applyResolvedID(&ids.MALID, &ids.Provenance.MAL, meta.MALID, "prepared")
 	}
 	if !overrideTMDB && !clearedTMDB {
-		applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, meta.ArrTMDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
+		applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, meta.ArrTMDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
 	}
 	if !overrideIMDB && !clearedIMDB {
-		applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, meta.ArrIMDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
+		applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, meta.ArrIMDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
 	}
 	if !overrideTVDB && !clearedTVDB {
-		applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, meta.ArrTVDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
+		applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, meta.ArrTVDBID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
 	}
 	if !overrideTVmaze {
-		applyResolvedID(&ids.TVmazeID, &ids.SourceTVmaze, meta.ArrTVmazeID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
+		applyResolvedID(&ids.TVmazeID, &ids.Provenance.TVmaze, meta.ArrTVmazeID, metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ArrSource), "arr"))
 	}
 	if s.logger != nil {
 		s.logger.Debugf(
 			"metadata: external ids initial tmdb=%d(%s) imdb=%d(%s) tvdb=%d(%s)",
 			ids.TMDBID,
-			ids.SourceTMDB,
+			ids.Provenance.TMDB,
 			ids.IMDBID,
-			ids.SourceIMDB,
+			ids.Provenance.IMDB,
 			ids.TVDBID,
-			ids.SourceTVDB,
+			ids.Provenance.TVDB,
 		)
 	}
-	metadataChanged := invalidateMismatchedProviderMetadata(&metadata, ids)
+	invalidateMismatchedProviderMetadata(&metadata, ids)
 
 	tmdbClient, anilistClient, imdbClient, tvdbClient, tvmazeClient := s.ensureExternalClients()
 
@@ -251,21 +255,20 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 				Year:          year,
 			},
 			Unattended: unattendedSearch,
-			Debug:      meta.Options.Debug,
+			Debug:      false,
 		})
 		if err != nil {
 			if s.logger != nil {
 				s.logger.Warnf("metadata: tmdb external lookup failed: %v", err)
 			}
 		} else if result.TMDBID != 0 {
-			applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, result.TMDBID, "tmdb_external")
+			applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, result.TMDBID, "tmdb_external")
 			if ids.Category == "" && result.Category != "" {
-				ids.Category = strings.ToUpper(strings.TrimSpace(result.Category))
+				ids.Category, _ = api.NormalizeCanonicalCategory(result.Category)
 			}
 		}
 		if len(result.Candidates) > 0 && len(candidates.TMDB) == 0 {
 			candidates.TMDB = mapTMDBCandidates(result.Candidates, result.Category)
-			candidates.TMDBAutoSelected = result.AutoSelected
 		}
 	}
 
@@ -323,7 +326,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 						Category:       tmdbCategoryPref,
 						Unattended:     unattendedSearch,
 						DontSwitch:     strings.EqualFold(tmdbCategoryPref, "TV"),
-						Debug:          meta.Options.Debug,
+						Debug:          false,
 					})
 					if err != nil {
 						mu.Lock()
@@ -344,9 +347,9 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 						SecondaryTitle:    secondary,
 						UntouchedFilename: pathutil.Base(meta.SourcePath),
 						SearchYear:        stageYear,
-						Category:          ids.Category,
+						Category:          string(ids.Category),
 						Unattended:        unattendedSearch,
-						Debug:             meta.Options.Debug,
+						Debug:             false,
 					})
 					if err != nil {
 						mu.Lock()
@@ -370,21 +373,19 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 			}
 
 			if stageNeedsTMDB && tmdbOutcome.TMDBID != 0 {
-				applyResolvedID(&ids.TMDBID, &ids.SourceTMDB, tmdbOutcome.TMDBID, "tmdb_search")
+				applyResolvedID(&ids.TMDBID, &ids.Provenance.TMDB, tmdbOutcome.TMDBID, "tmdb_search")
 				if ids.Category == "" && tmdbOutcome.Category != "" {
-					ids.Category = strings.ToUpper(strings.TrimSpace(tmdbOutcome.Category))
+					ids.Category, _ = api.NormalizeCanonicalCategory(tmdbOutcome.Category)
 				}
 			}
 			if stageNeedsTMDB && len(tmdbOutcome.Candidates) > 0 && len(candidates.TMDB) == 0 {
 				candidates.TMDB = mapTMDBCandidates(tmdbOutcome.Candidates, tmdbOutcome.Category)
-				candidates.TMDBAutoSelected = tmdbOutcome.AutoSelected
 			}
 			if stageNeedsIMDB && imdbResult.IMDbID != 0 {
-				applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, imdbResult.IMDbID, "imdb_search")
+				applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, imdbResult.IMDbID, "imdb_search")
 			}
 			if stageNeedsIMDB && len(imdbResult.Candidates) > 0 && len(candidates.IMDB) == 0 {
 				candidates.IMDB = mapIMDBCandidates(imdbResult.Candidates)
-				candidates.IMDBAutoSelected = imdbResult.AutoSelected
 			}
 			if s.logger != nil {
 				s.logger.Debugf(
@@ -486,7 +487,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 			group.Go(func() error {
 				result, err := tmdbClient.FetchMetadata(gctx, tmdb.MetadataInput{
 					TMDBID:         ids.TMDBID,
-					Category:       ids.Category,
+					Category:       string(ids.Category),
 					SearchYear:     year,
 					IMDbID:         ids.IMDBID,
 					TVDBID:         ids.TVDBID,
@@ -494,7 +495,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 					AddLogo:        s.cfg.Description.AddLogo,
 					LogoLanguages:  descriptionLogoLanguages(s.cfg.Description.LogoLanguage),
 					Filename:       filename,
-					Debug:          meta.Options.Debug,
+					Debug:          false,
 				})
 				if err != nil {
 					mu.Lock()
@@ -535,7 +536,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 
 		if fetchIMDB {
 			group.Go(func() error {
-				result, err := imdbClient.GetInfo(gctx, formatIMDbID(ids.IMDBID), manualLanguage, meta.Options.Debug)
+				result, err := imdbClient.GetInfo(gctx, formatIMDbID(ids.IMDBID), manualLanguage, false)
 				if err != nil {
 					mu.Lock()
 					if imdbErr == nil {
@@ -572,7 +573,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 				return nil
 			})
 		} else if s.logger != nil && ids.TVDBID != 0 {
-			s.logger.Debugf("metadata: external ids tvdb lookup skipped id=%d source=%s", ids.TVDBID, ids.SourceTVDB)
+			s.logger.Debugf("metadata: external ids tvdb lookup skipped id=%d source=%s", ids.TVDBID, ids.Provenance.TVDB)
 		}
 
 		if lookupTVmaze {
@@ -594,7 +595,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 					ManualDate:        manualDate,
 					StrictIDOnly:      !allowTVmazeNameFallback,
 					AllowNameFallback: allowTVmazeNameFallback,
-					Debug:             meta.Options.Debug,
+					Debug:             false,
 				})
 				if err != nil {
 					mu.Lock()
@@ -613,7 +614,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 				return nil
 			})
 		} else if s.logger != nil && ids.TVmazeID != 0 {
-			s.logger.Debugf("metadata: external ids tvmaze lookup skipped id=%d source=%s", ids.TVmazeID, ids.SourceTVmaze)
+			s.logger.Debugf("metadata: external ids tvmaze lookup skipped id=%d source=%s", ids.TVmazeID, ids.Provenance.TVmaze)
 		}
 
 		_ = group.Wait()
@@ -621,26 +622,24 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 		if tmdbResult != nil {
 			metadata.TMDB = mapTMDBMetadata(ids, *tmdbResult)
 			if !overrideIMDB && ids.IMDBID == 0 && tmdbResult.IMDbID != 0 {
-				applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, tmdbResult.IMDbID, "tmdb")
+				applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, tmdbResult.IMDbID, "tmdb")
 			}
 			if ids.Category == "" && tmdbResult.TMDBType != "" {
-				ids.Category = normalizeCategory(tmdbResult.TMDBType)
+				ids.Category, _ = api.NormalizeCanonicalCategory(tmdbResult.TMDBType)
 			}
 			if shouldUseTVDBForCategory(meta, ids) && !overrideTVDB && ids.TVDBID == 0 && tmdbResult.TVDBID != 0 {
-				applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, tmdbResult.TVDBID, "tmdb")
+				applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, tmdbResult.TVDBID, "tmdb")
 			}
 			if !overrideMAL && !clearedMAL && ids.MALID == 0 && tmdbResult.MALID != 0 {
-				applyResolvedID(&ids.MALID, &ids.SourceMAL, tmdbResult.MALID, "tmdb")
+				applyResolvedID(&ids.MALID, &ids.Provenance.MAL, tmdbResult.MALID, "tmdb")
 			}
 		}
 
 		if anilistResult != nil {
 			metadata.AniList = mapAniListMetadata(*anilistResult)
-			metadataChanged = true
 		} else if fetchAniList {
 			if metadata.AniList != nil {
 				metadata.AniList = nil
-				metadataChanged = true
 			}
 		}
 
@@ -650,7 +649,7 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 
 		if fetchedTVDBID != 0 {
 			if !overrideTVDB {
-				applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, fetchedTVDBID, "tvdb")
+				applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, fetchedTVDBID, "tvdb")
 			}
 			if metadata.TVDB == nil || metadata.TVDB.TVDBID == 0 {
 				metadata.TVDB = &api.TVDBMetadata{TVDBID: fetchedTVDBID, Name: fetchedTVDBName}
@@ -702,13 +701,13 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 
 		if tvmazeResult != nil {
 			if !overrideTVmaze {
-				applyResolvedID(&ids.TVmazeID, &ids.SourceTVmaze, tvmazeResult.SelectedID, "tvmaze")
+				applyResolvedID(&ids.TVmazeID, &ids.Provenance.TVmaze, tvmazeResult.SelectedID, "tvmaze")
 			}
 			if !overrideIMDB && ids.IMDBID == 0 && tvmazeResult.IMDBID != 0 {
-				applyResolvedID(&ids.IMDBID, &ids.SourceIMDB, tvmazeResult.IMDBID, "tvmaze")
+				applyResolvedID(&ids.IMDBID, &ids.Provenance.IMDB, tvmazeResult.IMDBID, "tvmaze")
 			}
 			if shouldUseTVDBForCategory(meta, ids) && !overrideTVDB && ids.TVDBID == 0 && tvmazeResult.TVDBID != 0 {
-				applyResolvedID(&ids.TVDBID, &ids.SourceTVDB, tvmazeResult.TVDBID, "tvmaze")
+				applyResolvedID(&ids.TVDBID, &ids.Provenance.TVDB, tvmazeResult.TVDBID, "tvmaze")
 			}
 			metadata.TVmaze = mapTVmazeMetadata(*tvmazeResult)
 		}
@@ -735,17 +734,17 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 	// Tracker and media metadata can supply an episode IMDb ID where downstream
 	// providers require the parent series ID. Clear the episode snapshot so the
 	// second fetch pass refreshes series metadata after a successful adjustment.
-	if episodeClient, ok := imdbClient.(imdbEpisodeClient); ok && shouldUseTVDBForCategory(meta, ids) && metadata.IMDB != nil && strings.EqualFold(strings.TrimSpace(metadata.IMDB.Type), "tvEpisode") {
-		lookup, err := episodeClient.GetEpisodeInfo(ctx, formatIMDbID(ids.IMDBID), meta.Options.Debug)
+	if episodeClient, ok := imdbClient.(imdbEpisodeClient); ok && shouldUseTVDBForCategory(meta, ids) && metadata.IMDB != nil &&
+		strings.EqualFold(strings.TrimSpace(metadata.IMDB.Type), "tvEpisode") {
+		lookup, err := episodeClient.GetEpisodeInfo(ctx, formatIMDbID(ids.IMDBID), false)
 		if err != nil {
 			if s.logger != nil {
 				s.logger.Debugf("metadata: imdb episode parent lookup failed")
 			}
 		} else if parentID := metautil.ParseIMDbNumeric(lookup.Series.SeriesID); parentID != 0 && parentID != ids.IMDBID {
 			ids.IMDBID = parentID
-			ids.SourceIMDB = "imdb_episode_parent"
+			ids.Provenance.IMDB = api.IdentityProvenanceProvider
 			metadata.IMDB = nil
-			metadataChanged = true
 			if s.logger != nil {
 				s.logger.Debugf("metadata: imdb episode id adjusted to parent series id=%d", parentID)
 			}
@@ -758,15 +757,15 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 	clearTVDBForNonTVCategory(meta, &ids, &metadata)
 	meta = s.applyTVEpisodeMetadata(ctx, meta, &ids, &metadata, tmdbClient, tvdbClient, tvmazeClient)
 
-	needsPTBR := trackers.AnyNeedsPTBRLocalizedMetadata(meta.Trackers) || trackers.AnyNeedsPTBRLocalizedMetadata(meta.MatchedTrackers)
+	needsPTBR := s.registry.NeedsLocalizedMetadata(meta.EvidenceTrackers, "pt-BR") || s.registry.NeedsLocalizedMetadata(meta.MatchedEvidenceTrackers, "pt-BR")
 
 	if tmdbClient != nil && needsPTBR && ids.TMDBID != 0 {
 		var mainData, seasonData, episodeData map[string]any
 		var localizedErr error
-		isTV := strings.EqualFold(ids.Category, "TV")
+		isTV := strings.EqualFold(string(ids.Category), "TV")
 		mainInput := tmdb.LocalizedDataInput{
 			TMDBID:           ids.TMDBID,
-			Category:         ids.Category,
+			Category:         string(ids.Category),
 			DataType:         "main",
 			Language:         "pt-BR",
 			AppendToResponse: localizedMainAppendToResponse(isTV),
@@ -843,15 +842,15 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 		s.logger.Debugf(
 			"metadata: external ids resolved tmdb=%d(%s) imdb=%d(%s) tvdb=%d(%s) tvmaze=%d(%s) mal=%d(%s)",
 			ids.TMDBID,
-			ids.SourceTMDB,
+			ids.Provenance.TMDB,
 			ids.IMDBID,
-			ids.SourceIMDB,
+			ids.Provenance.IMDB,
 			ids.TVDBID,
-			ids.SourceTVDB,
+			ids.Provenance.TVDB,
 			ids.TVmazeID,
-			ids.SourceTVmaze,
+			ids.Provenance.TVmaze,
 			ids.MALID,
-			ids.SourceMAL,
+			ids.Provenance.MAL,
 		)
 		s.logger.Debugf(
 			"metadata: external metadata fetched tmdb=%t imdb=%t tvdb=%t tvmaze=%t anilist=%t bluray=%t",
@@ -864,28 +863,13 @@ func (s *Service) ResolveExternalIDs(ctx context.Context, meta api.PreparedMetad
 		)
 	}
 
-	ids.UpdatedAt = time.Now().UTC()
-	metadata.UpdatedAt = ids.UpdatedAt
-	if ids.Category != "" {
-		meta.Release.Category = ids.Category
-		if err := s.persistResolvedReleaseCategory(ctx, meta.SourcePath, ids.Category, ids.UpdatedAt); err != nil {
-			return api.PreparedMetadata{}, err
-		}
-	}
+	ids.ResolvedAt = time.Now().UTC()
+	metadata.UpdatedAt = ids.ResolvedAt
 
-	if err := s.repo.SaveExternalIDs(ctx, ids); err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: save external ids: %w", err)
-	}
-	if metadataChanged || metadata.TMDB != nil || metadata.IMDB != nil || metadata.TVDB != nil || metadata.TVmaze != nil || metadata.AniList != nil || metadata.Bluray != nil {
-		if err := s.repo.SaveExternalMetadata(ctx, metadata); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: save external metadata: %w", err)
-		}
-	}
-
-	meta.ExternalIDs = ids
+	meta.Identity = ids
 	meta.MALID = ids.MALID
-	meta.ExternalIDCandidates = candidates
-	meta.ExternalMetadata = metadata
+	meta.ExternalIdentityCandidates = append(append([]api.ExternalIdentityCandidate(nil), candidates.TMDB...), candidates.IMDB...)
+	meta.ProviderMetadata = metadata
 	return meta, nil
 }
 
@@ -897,7 +881,7 @@ func sourceScopedMetadataMatches(storedSourcePath string, currentSourcePath stri
 	return strings.EqualFold(trimmedStored, strings.TrimSpace(currentSourcePath))
 }
 
-func invalidateMismatchedProviderMetadata(metadata *api.ExternalMetadata, ids api.ExternalIDs) bool {
+func invalidateMismatchedProviderMetadata(metadata *api.SourceScopedMetadata, ids api.ExternalIdentity) bool {
 	if metadata == nil {
 		return false
 	}
@@ -948,36 +932,10 @@ func shouldFetchAniListMetadata(malID int, metadata *api.AniListMetadata) bool {
 	return metadata == nil || metadata.MALID != malID
 }
 
-func clearTrackerSourcedExternalIDs(ids *api.ExternalIDs) {
-	if ids == nil {
-		return
-	}
-	if strings.EqualFold(strings.TrimSpace(ids.SourceTMDB), "tracker") {
-		ids.TMDBID = 0
-		ids.SourceTMDB = ""
-	}
-	if strings.EqualFold(strings.TrimSpace(ids.SourceIMDB), "tracker") {
-		ids.IMDBID = 0
-		ids.SourceIMDB = ""
-	}
-	if strings.EqualFold(strings.TrimSpace(ids.SourceTVDB), "tracker") {
-		ids.TVDBID = 0
-		ids.SourceTVDB = ""
-	}
-	if strings.EqualFold(strings.TrimSpace(ids.SourceTVmaze), "tracker") {
-		ids.TVmazeID = 0
-		ids.SourceTVmaze = ""
-	}
-	if strings.EqualFold(strings.TrimSpace(ids.SourceMAL), "tracker") {
-		ids.MALID = 0
-		ids.SourceMAL = ""
-	}
-}
-
 // shouldUseTVDBForCategory reports whether TVDB data may be used for the resolved media category.
 // Any explicit MOVIE category is authoritative over TV hints from MediaInfo, stored IDs, release data, or the filename.
-func shouldUseTVDBForCategory(meta api.PreparedMetadata, ids api.ExternalIDs) bool {
-	candidates := []string{ids.Category, meta.ExternalIDs.Category, meta.MediaInfoCategory, meta.Release.Category}
+func shouldUseTVDBForCategory(meta preparationstate.State, ids api.ExternalIdentity) bool {
+	candidates := []string{string(ids.Category), string(meta.Identity.Category), meta.MediaInfoCategory, meta.Release.Category}
 	if meta.ReleaseNameOverrides.Category != nil {
 		candidates = append(candidates, *meta.ReleaseNameOverrides.Category)
 	}
@@ -995,7 +953,7 @@ func shouldUseTVDBForCategory(meta api.PreparedMetadata, ids api.ExternalIDs) bo
 }
 
 // clearTVDBForNonTVCategory removes TVDB IDs and metadata when the resolved category no longer permits TVDB data.
-func clearTVDBForNonTVCategory(meta api.PreparedMetadata, ids *api.ExternalIDs, metadata *api.ExternalMetadata) {
+func clearTVDBForNonTVCategory(meta preparationstate.State, ids *api.ExternalIdentity, metadata *api.SourceScopedMetadata) {
 	if ids == nil {
 		return
 	}
@@ -1003,7 +961,7 @@ func clearTVDBForNonTVCategory(meta api.PreparedMetadata, ids *api.ExternalIDs,
 		return
 	}
 	ids.TVDBID = 0
-	ids.SourceTVDB = ""
+	ids.Provenance.TVDB = ""
 	if metadata != nil {
 		metadata.TVDB = nil
 	}
@@ -1112,12 +1070,12 @@ func localizedPTBRComplete(localized api.TMDBLocalizedData, episodeLike bool) bo
 	return strings.TrimSpace(localized.Overview) != ""
 }
 
-func mapTMDBCandidates(items []tmdb.Candidate, category string) []api.ExternalIDCandidate {
+func mapTMDBCandidates(items []tmdb.Candidate, category string) []api.ExternalIdentityCandidate {
 	if len(items) == 0 {
 		return nil
 	}
-	normalizedCategory := normalizeCategory(category)
-	mapped := make([]api.ExternalIDCandidate, 0, len(items))
+	normalizedCategory, _ := api.NormalizeCanonicalCategory(category)
+	mapped := make([]api.ExternalIdentityCandidate, 0, len(items))
 	for _, item := range items {
 		if item.TMDBID == 0 {
 			continue
@@ -1126,14 +1084,14 @@ func mapTMDBCandidates(items []tmdb.Candidate, category string) []api.ExternalID
 		if posterURL != "" && !strings.HasPrefix(strings.ToLower(posterURL), "http://") && !strings.HasPrefix(strings.ToLower(posterURL), "https://") {
 			posterURL = "https://image.tmdb.org/t/p/w342/" + strings.TrimPrefix(posterURL, "/")
 		}
-		mapped = append(mapped, api.ExternalIDCandidate{
-			Provider:      "tmdb",
+		mapped = append(mapped, api.ExternalIdentityCandidate{
+			Provider:      api.IdentityProviderTMDB,
 			ID:            item.TMDBID,
 			Title:         strings.TrimSpace(item.Title),
 			OriginalTitle: strings.TrimSpace(item.OriginalTitle),
 			Year:          item.Year,
 			Category:      normalizedCategory,
-			MediaType:     normalizedCategory,
+			MediaType:     string(normalizedCategory),
 			Overview:      strings.TrimSpace(item.Overview),
 			PosterURL:     posterURL,
 			Similarity:    item.Similarity,
@@ -1145,17 +1103,17 @@ func mapTMDBCandidates(items []tmdb.Candidate, category string) []api.ExternalID
 	return mapped
 }
 
-func mapIMDBCandidates(items []imdb.Candidate) []api.ExternalIDCandidate {
+func mapIMDBCandidates(items []imdb.Candidate) []api.ExternalIdentityCandidate {
 	if len(items) == 0 {
 		return nil
 	}
-	mapped := make([]api.ExternalIDCandidate, 0, len(items))
+	mapped := make([]api.ExternalIdentityCandidate, 0, len(items))
 	for _, item := range items {
 		if item.IMDbID == 0 {
 			continue
 		}
-		mapped = append(mapped, api.ExternalIDCandidate{
-			Provider:   "imdb",
+		mapped = append(mapped, api.ExternalIdentityCandidate{
+			Provider:   api.IdentityProviderIMDB,
 			ID:         item.IMDbID,
 			Title:      strings.TrimSpace(item.Title),
 			Year:       item.Year,
@@ -1208,7 +1166,7 @@ func (s *Service) ensureExternalClients() (TMDBClient, AniListClient, IMDBClient
 	return s.tmdb, s.anilist, s.imdb, s.tvdb, s.tvmaze
 }
 
-func isIMDbTVMovie(ids api.ExternalIDs, metadata api.ExternalMetadata) bool {
+func isIMDbTVMovie(ids api.ExternalIdentity, metadata api.SourceScopedMetadata) bool {
 	if ids.IMDBID == 0 || metadata.IMDB == nil {
 		return false
 	}
@@ -1243,7 +1201,7 @@ func resolveTVDBCacheDir(dbPath string) string {
 	return cacheDir
 }
 
-func resolveSearchTitles(meta api.PreparedMetadata) (string, string) {
+func resolveSearchTitles(meta preparationstate.State) (string, string) {
 	primary := normalizeSearchTitle(meta.Release.Title)
 	secondary := strings.TrimSpace(meta.Release.Alt)
 	if secondary == "" {
@@ -1264,7 +1222,7 @@ func resolveSearchTitles(meta api.PreparedMetadata) (string, string) {
 	return primary, secondary
 }
 
-func resolveSearchYear(meta api.PreparedMetadata) int {
+func resolveSearchYear(meta preparationstate.State) int {
 	if meta.ReleaseNameOverrides.ManualYear != nil {
 		if *meta.ReleaseNameOverrides.ManualYear > 0 {
 			return *meta.ReleaseNameOverrides.ManualYear
@@ -1359,9 +1317,9 @@ func uniqueSearchYears(values []int) []int {
 	return result
 }
 
-func isUnattendedMetadataSearch(meta api.PreparedMetadata) bool {
+func isUnattendedMetadataSearch(meta preparationstate.State) bool {
 	//nolint:exhaustive // Interactive modes are intentionally treated as attended.
-	switch meta.Options.InteractionMode {
+	switch meta.Policy.InteractionMode {
 	case api.InteractionModeUnattended, api.InteractionModeUnattendedConfirm:
 		return true
 	default:
@@ -1369,7 +1327,7 @@ func isUnattendedMetadataSearch(meta api.PreparedMetadata) bool {
 	}
 }
 
-func resolveCategoryPreference(meta api.PreparedMetadata) string {
+func resolveCategoryPreference(meta preparationstate.State) string {
 	if meta.ReleaseNameOverrides.Category != nil {
 		category := normalizeCategory(*meta.ReleaseNameOverrides.Category)
 		if category != "" {
@@ -1377,7 +1335,7 @@ func resolveCategoryPreference(meta api.PreparedMetadata) string {
 		}
 	}
 	// A known movie category wins before tracker or MediaInfo TV candidates can make the resolver keep TVDB state.
-	for _, candidate := range []string{meta.ExternalIDs.Category, meta.Release.Category, meta.MediaInfoCategory} {
+	for _, candidate := range []string{string(meta.Identity.Category), meta.Release.Category, meta.MediaInfoCategory} {
 		if normalizeCategory(candidate) == "MOVIE" {
 			return "MOVIE"
 		}
@@ -1387,7 +1345,7 @@ func resolveCategoryPreference(meta api.PreparedMetadata) string {
 			return normalized
 		}
 	}
-	if normalized := normalizeCategory(meta.ExternalIDs.Category); normalized != "" {
+	if normalized := normalizeCategory(string(meta.Identity.Category)); normalized != "" {
 		return normalized
 	}
 	category := normalizeCategory(meta.MediaInfoCategory)
@@ -1411,52 +1369,23 @@ func normalizeCategory(value string) string {
 	return ""
 }
 
-func (s *Service) persistResolvedReleaseCategory(ctx context.Context, sourcePath string, category string, updatedAt time.Time) error {
-	normalized := api.NormalizeCategory(category)
-	if s.repo == nil || strings.TrimSpace(sourcePath) == "" || !normalized.IsValid() {
-		return nil
-	}
-
-	stored, err := s.repo.GetByPath(ctx, sourcePath)
-	if err != nil {
-		if errors.Is(err, internalerrors.ErrNotFound) {
-			return nil
-		}
-		return fmt.Errorf("metadata: load stored metadata for resolved category: %w", err)
-	}
-	if stored.Category.Canonical() == normalized {
-		return nil
-	}
-
-	stored.Category = normalized
-	stored.UpdatedAt = updatedAt
-	if stored.UpdatedAt.IsZero() {
-		stored.UpdatedAt = time.Now().UTC()
-	}
-	if err := s.repo.Save(ctx, stored); err != nil {
-		return fmt.Errorf("metadata: persist resolved release category: %w", err)
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: persisted resolved release category path=%q category=%q", sourcePath, normalized)
-	}
-	return nil
-}
-
-func applyOverrideID(target *int, source *string, override *int) (bool, bool) {
-	if target == nil || source == nil || override == nil {
+func applyOverrideID(target *int, source *api.IdentityProvenance, state *api.OverrideState, override *int) (bool, bool) {
+	if target == nil || source == nil || state == nil || override == nil {
 		return false, false
 	}
 	if *override == 0 {
 		*target = 0
-		*source = "override_clear"
+		*source = api.IdentityProvenanceExplicit
+		*state = api.OverrideStateClear
 		return false, true
 	}
 	*target = *override
-	*source = "override"
+	*source = api.IdentityProvenanceExplicit
+	*state = api.OverrideStateValue
 	return true, false
 }
 
-func applyResolvedID(target *int, source *string, value int, origin string) {
+func applyResolvedID(target *int, source *api.IdentityProvenance, value int, origin string) {
 	if value == 0 || target == nil || source == nil {
 		return
 	}
@@ -1464,7 +1393,25 @@ func applyResolvedID(target *int, source *string, value int, origin string) {
 		return
 	}
 	*target = value
-	*source = origin
+	*source = identityProvenance(origin)
+}
+
+func identityProvenance(origin string) api.IdentityProvenance {
+	value := strings.ToLower(strings.TrimSpace(origin))
+	switch {
+	case strings.Contains(value, "mediainfo"):
+		return api.IdentityProvenanceMediaInfo
+	case strings.Contains(value, "scene") || strings.Contains(value, "nfo"):
+		return api.IdentityProvenanceScene
+	case strings.Contains(value, "arr") || strings.Contains(value, "sonarr") || strings.Contains(value, "radarr"):
+		return api.IdentityProvenanceArr
+	case strings.Contains(value, "tracker"):
+		return api.IdentityProvenanceTracker
+	case strings.Contains(value, "override"):
+		return api.IdentityProvenanceExplicit
+	default:
+		return api.IdentityProvenanceProvider
+	}
 }
 
 func formatIMDbID(value int) string {
@@ -1495,7 +1442,7 @@ func descriptionLogoLanguages(value string) []string {
 	return languages
 }
 
-func mapTMDBMetadata(ids api.ExternalIDs, result tmdb.MetadataResult) *api.TMDBMetadata {
+func mapTMDBMetadata(ids api.ExternalIdentity, result tmdb.MetadataResult) *api.TMDBMetadata {
 	if ids.TMDBID == 0 {
 		return nil
 	}
@@ -1503,7 +1450,7 @@ func mapTMDBMetadata(ids api.ExternalIDs, result tmdb.MetadataResult) *api.TMDBM
 		TMDBID:              ids.TMDBID,
 		IMDBID:              result.IMDbID,
 		TVDBID:              result.TVDBID,
-		Category:            ids.Category,
+		Category:            string(ids.Category),
 		Title:               result.Title,
 		OriginalTitle:       result.OriginalTitle,
 		Year:                result.Year,
@@ -1786,7 +1733,11 @@ func mapIMDBEpisodes(values []imdb.Episode) []api.IMDBEpisode {
 			ID:          value.ID,
 			Title:       value.Title,
 			ReleaseYear: value.ReleaseYear,
-			ReleaseDate: api.IMDBReleaseDate{Year: value.ReleaseDate.Year, Month: value.ReleaseDate.Month, Day: value.ReleaseDate.Day},
+			ReleaseDate: api.IMDBReleaseDate{
+				Year:  value.ReleaseDate.Year,
+				Month: value.ReleaseDate.Month,
+				Day:   value.ReleaseDate.Day,
+			},
 			Season:      value.Season,
 			EpisodeText: value.EpisodeText,
 		})
@@ -2051,13 +2002,12 @@ func mapTVmazeMetadata(result tvmaze.SearchResult) *api.TVmazeMetadata {
 // seasonless absolute episode before TVmaze and TMDB detail lookups run.
 func (s *Service) applyTVEpisodeMetadata(
 	ctx context.Context,
-	meta api.PreparedMetadata,
-	ids *api.ExternalIDs,
-	external *api.ExternalMetadata,
+	meta preparationstate.State,
+	ids *api.ExternalIdentity, external *api.SourceScopedMetadata,
 	tmdbClient TMDBClient,
 	tvdbClient TVDBClient,
 	tvmazeClient TVmazeClient,
-) api.PreparedMetadata {
+) preparationstate.State {
 	if ids == nil {
 		return meta
 	}
@@ -2070,11 +2020,11 @@ func (s *Service) applyTVEpisodeMetadata(
 		meta.MALID = metautil.FirstInt(ids.MALID, 0)
 	}
 
-	if !isLikelyTV(meta) && !strings.EqualFold(ids.Category, "TV") {
+	if !isLikelyTV(meta) && !strings.EqualFold(string(ids.Category), "TV") {
 		return meta
 	}
 	if ids.Category == "" {
-		ids.Category = "TV"
+		ids.Category = api.CanonicalCategoryTV
 	}
 
 	fallbackSeason, fallbackEpisode := meta.SeasonEpisodeWithParsedFallback()
@@ -2166,7 +2116,7 @@ func (s *Service) applyTVEpisodeMetadata(
 			Season:    querySeason,
 			Episode:   queryEpisode,
 			AiredDate: dailyDate,
-			Debug:     meta.Options.Debug,
+			Debug:     false,
 		}
 		if meta.Anime {
 			query.Absolute = seasonep.Extract(meta.SourcePath, meta).AbsoluteEpisode
@@ -2294,7 +2244,7 @@ func (s *Service) applyTVEpisodeMetadata(
 		} else if lookupSeason, lookupEpisode := metautil.FirstInt(season, fallbackSeason), metautil.FirstInt(episode, fallbackEpisode); lookupSeason > 0 && lookupEpisode > 0 {
 			epData, err = tvmazeClient.GetEpisodeByNumber(ctx, ids.TVmazeID, lookupSeason, lookupEpisode, tvmaze.EpisodeLookupContext{
 				ManualDate: dailyDate,
-				Debug:      meta.Options.Debug,
+				Debug:      false,
 			})
 		}
 		if err != nil && s.logger != nil {
@@ -2361,7 +2311,9 @@ func (s *Service) applyTVEpisodeMetadata(
 	meta.SeasonStr = seasonep.FormatSeason(season)
 	meta.EpisodeStr = seasonep.FormatEpisode(episode)
 	meta.EpisodeYear = metautil.FirstInt(episodeYear, meta.EpisodeYear)
-	meta.EpisodeTitle = sanitizeEpisodeTitle(metautil.FirstNonEmptyTrimmed(episodeTitle, tvdbEpisodeTitle, tvmazeEpisodeTitle, tmdbEpisodeTitle, imdbEpisodeTitle))
+	meta.EpisodeTitle = sanitizeEpisodeTitle(
+		metautil.FirstNonEmptyTrimmed(episodeTitle, tvdbEpisodeTitle, tvmazeEpisodeTitle, tmdbEpisodeTitle, imdbEpisodeTitle),
+	)
 	meta.EpisodeOverview = metautil.FirstNonEmptyTrimmed(episodeOverview, tvdbEpisodeOverview, tvmazeEpisodeOverview, tmdbEpisodeOverview)
 
 	if s.logger != nil && (initialSeason != season || initialEpisode != episode || initialSeasonStr != meta.SeasonStr || initialEpisodeStr != meta.EpisodeStr) {
@@ -2376,8 +2328,14 @@ func (s *Service) applyTVEpisodeMetadata(
 		)
 	}
 
-	if tmdbClient != nil && wantsSeasonEpisode && !hasManualSeasonEpisode && !tmdbDateMatch && strings.TrimSpace(meta.DailyEpisodeDate) != "" && ids.TMDBID != 0 && s.logger != nil {
-		s.logger.Warnf("metadata: season/episode naming requested but TMDB season/episode lookup failed for daily_date=%q tmdb_id=%d", strings.TrimSpace(meta.DailyEpisodeDate), ids.TMDBID)
+	if tmdbClient != nil && wantsSeasonEpisode && !hasManualSeasonEpisode && !tmdbDateMatch && strings.TrimSpace(meta.DailyEpisodeDate) != "" &&
+		ids.TMDBID != 0 &&
+		s.logger != nil {
+		s.logger.Warnf(
+			"metadata: season/episode naming requested but TMDB season/episode lookup failed for daily_date=%q tmdb_id=%d",
+			strings.TrimSpace(meta.DailyEpisodeDate),
+			ids.TMDBID,
+		)
 	}
 
 	return meta
@@ -2469,7 +2427,7 @@ func tvdbHasEnglishContent(metadata *api.TVDBMetadata) bool {
 		strings.TrimSpace(metadata.EpisodeOverviewEnglish) != ""
 }
 
-func resolveSeriesTitle(meta api.PreparedMetadata, external *api.ExternalMetadata) string {
+func resolveSeriesTitle(meta preparationstate.State, external *api.SourceScopedMetadata) string {
 	if external != nil {
 		if external.TMDB != nil && strings.TrimSpace(external.TMDB.Title) != "" {
 			return strings.TrimSpace(external.TMDB.Title)
@@ -2511,14 +2469,14 @@ func isGenericEpisodeTitle(value string) bool {
 
 // discardSeriesEpisodeTitle clears parsed episode titles that duplicate a known
 // series title so provider episode titles can still populate the release name.
-func discardSeriesEpisodeTitle(episodeTitle string, meta api.PreparedMetadata, external *api.ExternalMetadata) string {
+func discardSeriesEpisodeTitle(episodeTitle string, meta preparationstate.State, external *api.SourceScopedMetadata) string {
 	if episodeTitle == "" || !episodeTitleMatchesSeriesTitle(episodeTitle, meta, external) {
 		return episodeTitle
 	}
 	return ""
 }
 
-func episodeTitleMatchesSeriesTitle(episodeTitle string, meta api.PreparedMetadata, external *api.ExternalMetadata) bool {
+func episodeTitleMatchesSeriesTitle(episodeTitle string, meta preparationstate.State, external *api.SourceScopedMetadata) bool {
 	episodeKey := titleIdentityKey(episodeTitle)
 	if len(episodeKey) < 6 {
 		return false
@@ -2531,7 +2489,7 @@ func episodeTitleMatchesSeriesTitle(episodeTitle string, meta api.PreparedMetada
 	return false
 }
 
-func seriesTitleCandidates(meta api.PreparedMetadata, external *api.ExternalMetadata) []string {
+func seriesTitleCandidates(meta preparationstate.State, external *api.SourceScopedMetadata) []string {
 	candidates := []string{
 		meta.Release.Title,
 		meta.Release.Subtitle,
@@ -2611,8 +2569,8 @@ func parseTVDBAliasNameYear(alias string) (string, int, bool) {
 	return name, year, true
 }
 
-func isLikelyTV(meta api.PreparedMetadata) bool {
-	if strings.EqualFold(meta.MediaInfoCategory, "TV") || strings.EqualFold(meta.ExternalIDs.Category, "TV") {
+func isLikelyTV(meta preparationstate.State) bool {
+	if strings.EqualFold(meta.MediaInfoCategory, "TV") || strings.EqualFold(string(meta.Identity.Category), "TV") {
 		return true
 	}
 	if meta.HasTVSeasonEpisodeSignal() {
diff --git a/internal/metadata/external_ids_test.go b/internal/metadata/external_ids_test.go
index 9513b098..951ce12e 100644
--- a/internal/metadata/external_ids_test.go
+++ b/internal/metadata/external_ids_test.go
@@ -11,18 +11,48 @@ import (
 	"testing"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/metadata/imdb"
 	"github.com/autobrr/upbrr/internal/metadata/tmdb"
 	"github.com/autobrr/upbrr/internal/metadata/tvdb"
 	"github.com/autobrr/upbrr/internal/metadata/tvmaze"
+	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+type localizedMetadataTestDefinition struct{}
+
+func (localizedMetadataTestDefinition) Name() string { return "BJS" }
+
+func (localizedMetadataTestDefinition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+
+func (localizedMetadataTestDefinition) DefaultBaseURL() string {
+	return "https://tracker.example.invalid"
+}
+
+func (localizedMetadataTestDefinition) LocalizedMetadataLocale() string { return "pt-BR" }
+
+func (localizedMetadataTestDefinition) Prepare(context.Context, trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.TrackerPlan{}, nil
+}
+
+func localizedMetadataTestRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry := trackers.NewRegistry()
+	if err := registry.Register(localizedMetadataTestDefinition{}); err != nil {
+		t.Fatalf("register localized metadata test tracker: %v", err)
+	}
+	return registry
+}
+
 type fakeRepo struct {
-	ids                 api.ExternalIDs
-	meta                api.ExternalMetadata
+	ids                 api.ExternalIdentity
+	meta                api.SourceScopedMetadata
 	fileMetadata        api.FileMetadata
 	trackerMetadata     []api.TrackerMetadata
 	trackerTimestamps   []api.TrackerTimestamp
@@ -30,6 +60,12 @@ type fakeRepo struct {
 	externalMetaSaves   int
 }
 
+// resolveExternalIdentity keeps provider-adapter tests focused on the candidate
+// returned to canonical preparation; production collection never publishes it.
+func (s *Service) resolveExternalIdentity(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
+	return s.collectExternalIdentityEvidence(ctx, meta)
+}
+
 func (f *fakeRepo) GetByPath(_ context.Context, path string) (api.FileMetadata, error) {
 	if strings.EqualFold(strings.TrimSpace(f.fileMetadata.Path), strings.TrimSpace(path)) {
 		return f.fileMetadata, nil
@@ -42,23 +78,48 @@ func (f *fakeRepo) Save(_ context.Context, metadata api.FileMetadata) error {
 	return nil
 }
 
-func (f *fakeRepo) GetExternalIDs(_ context.Context, _ string) (api.ExternalIDs, error) {
-	return api.ExternalIDs{}, internalerrors.ErrNotFound
+func (f *fakeRepo) GetExternalIdentity(_ context.Context, _ string) (api.ExternalIdentity, error) {
+	return api.ExternalIdentity{}, internalerrors.ErrNotFound
 }
 
-func (f *fakeRepo) SaveExternalIDs(_ context.Context, ids api.ExternalIDs) error {
+func (f *fakeRepo) SaveExternalIdentity(_ context.Context, ids api.ExternalIdentity) error {
 	f.ids = ids
 	return nil
 }
 
-func (f *fakeRepo) GetExternalMetadata(_ context.Context, path string) (api.ExternalMetadata, error) {
+func TestResolveExternalIDsCandidateDoesNotPersist(t *testing.T) {
+	repo := &fakeRepo{}
+	svc := NewService(repo)
+	tmdbID := 1234567
+
+	result, err := svc.collectExternalIdentityEvidence(context.Background(), preparationstate.State{
+		SourcePath: "/media/Example.Release.2026.1080p-GRP.mkv",
+		Release: api.ReleaseInfo{
+			Category: "MOVIE",
+			Title:    "Example Release",
+			Year:     2026,
+		},
+		ExternalIDOverrides: api.ExternalIDOverrides{TMDBID: &tmdbID},
+	})
+	if err != nil {
+		t.Fatalf("collectExternalIdentityEvidence() error = %v", err)
+	}
+	if result.Identity.TMDBID != tmdbID {
+		t.Fatalf("candidate TMDB ID = %d, want %d", result.Identity.TMDBID, tmdbID)
+	}
+	if repo.ids.TMDBID != 0 || repo.externalMetaSaves != 0 || repo.fileMetadata.Category != "" {
+		t.Fatalf("candidate resolution persisted state ids=%#v metadata_saves=%d file=%#v", repo.ids, repo.externalMetaSaves, repo.fileMetadata)
+	}
+}
+
+func (f *fakeRepo) GetExternalMetadata(_ context.Context, path string) (api.SourceScopedMetadata, error) {
 	if strings.EqualFold(strings.TrimSpace(f.meta.SourcePath), strings.TrimSpace(path)) {
 		return f.meta, nil
 	}
-	return api.ExternalMetadata{}, internalerrors.ErrNotFound
+	return api.SourceScopedMetadata{}, internalerrors.ErrNotFound
 }
 
-func (f *fakeRepo) SaveExternalMetadata(_ context.Context, metadata api.ExternalMetadata) error {
+func (f *fakeRepo) SaveExternalMetadata(_ context.Context, metadata api.SourceScopedMetadata) error {
 	f.externalMetaSaves++
 	f.meta = metadata
 	return nil
@@ -424,7 +485,11 @@ func (s *stubTVmaze) GetEpisodeByDate(_ context.Context, _ int, _ string) (*tvma
 func TestResolveExternalIDsPrecedence(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{Title: "Example", Year: 2024}}
-	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt0000001", Title: "Example", Year: 2024}}
+	imdbClient := &stubIMDB{info: imdb.Info{
+		IMDbID: "tt0000001",
+		Title:  "Example",
+		Year:   2024,
+	}}
 	tvdbClient := &stubTVDB{}
 	tvmazeClient := &stubTVmaze{}
 
@@ -435,31 +500,35 @@ func TestResolveExternalIDsPrecedence(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
-		SourcePath:        "/media/file.mkv",
-		MediaInfoTMDBID:   999,
-		MediaInfoIMDBID:   888,
-		MediaInfoTVDBID:   777,
-		SceneIMDB:         666,
-		TrackerData:       []api.TrackerMetadata{{TMDBID: 1, IMDBID: 2, TVDBID: 3}},
+	meta := preparationstate.State{
+		SourcePath:      "/media/file.mkv",
+		MediaInfoTMDBID: 999,
+		MediaInfoIMDBID: 888,
+		MediaInfoTVDBID: 777,
+		SceneIMDB:       666,
+		TrackerData: []api.TrackerMetadata{{
+			TMDBID: 1,
+			IMDBID: 2,
+			TVDBID: 3,
+		}},
 		MediaInfoCategory: "TV",
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 1 || result.ExternalIDs.IMDBID != 2 || result.ExternalIDs.TVDBID != 3 {
-		t.Fatalf("unexpected resolved ids: %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 1 || result.Identity.IMDBID != 2 || result.Identity.TVDBID != 3 {
+		t.Fatalf("unexpected resolved ids: %#v", result.Identity)
 	}
-	if result.ExternalIDs.SourceTMDB != "tracker" || result.ExternalIDs.SourceIMDB != "tracker" || result.ExternalIDs.SourceTVDB != "tracker" {
-		t.Fatalf("unexpected sources: %#v", result.ExternalIDs)
+	if result.Identity.Provenance.TMDB != "tracker" || result.Identity.Provenance.IMDB != "tracker" || result.Identity.Provenance.TVDB != "tracker" {
+		t.Fatalf("unexpected sources: %#v", result.Identity)
 	}
-	if repo.ids.TMDBID != 1 || repo.ids.IMDBID != 2 || repo.ids.TVDBID != 3 {
-		t.Fatalf("unexpected persisted ids: %#v", repo.ids)
+	if repo.ids.SourcePath != "" || repo.externalMetaSaves != 0 {
+		t.Fatal("provider candidate must not publish identity or metadata")
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.IMDB == nil {
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.IMDB == nil {
 		t.Fatalf("expected metadata results")
 	}
 }
@@ -472,7 +541,7 @@ func TestResolveExternalIDsWithoutTMDBAPIKey(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "Example.Release.2026.1080p-GRP.mkv",
 		MediaInfoCategory: "MOVIE",
 		TrackerData:       []api.TrackerMetadata{{TMDBID: 123456}},
@@ -480,11 +549,11 @@ func TestResolveExternalIDsWithoutTMDBAPIKey(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolve without TMDB API key: %v", err)
 	}
-	if result.ExternalIDs.TMDBID != 123456 || result.ExternalIDs.SourceTMDB != "tracker" {
-		t.Fatalf("expected tracker TMDB ID without enrichment, got %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 123456 || result.Identity.Provenance.TMDB != "tracker" {
+		t.Fatalf("expected tracker TMDB ID without enrichment, got %#v", result.Identity)
 	}
-	if result.ExternalMetadata.TMDB != nil {
-		t.Fatalf("expected TMDB enrichment to remain unavailable, got %#v", result.ExternalMetadata.TMDB)
+	if result.ProviderMetadata.TMDB != nil {
+		t.Fatalf("expected TMDB enrichment to remain unavailable, got %#v", result.ProviderMetadata.TMDB)
 	}
 }
 
@@ -493,16 +562,28 @@ func TestResolveExternalIDsAdjustsEpisodeIMDbIDToParentSeries(t *testing.T) {
 	imdbClient := &stubIMDB{
 		infoFn: func(imdbID string) imdb.Info {
 			if imdbID == "tt7654321" {
-				return imdb.Info{IMDbID: imdbID, Title: "Example Episode", Type: "tvEpisode"}
+				return imdb.Info{
+					IMDbID: imdbID,
+					Title:  "Example Episode",
+					Type:   "tvEpisode",
+				}
+			}
+			return imdb.Info{
+				IMDbID: imdbID,
+				Title:  "Example Series",
+				Type:   "tvSeries",
 			}
-			return imdb.Info{IMDbID: imdbID, Title: "Example Series", Type: "tvSeries"}
 		},
 		episodeLookup: imdb.EpisodeLookup{Series: imdb.SeriesInfo{SeriesID: "tt1234567", SeriesTitle: "Example Series"}},
 	}
 	tvmazeClient := &stubTVmaze{result: tvmaze.SearchResult{
 		SelectedID: 55,
 		IMDBID:     1234567,
-		Candidates: []tvmaze.Candidate{{ID: 55, Name: "Example Series", Externals: tvmaze.Externals{IMDB: "tt1234567"}}},
+		Candidates: []tvmaze.Candidate{{
+			ID:        55,
+			Name:      "Example Series",
+			Externals: tvmaze.Externals{IMDB: "tt1234567"},
+		}},
 	}}
 	imdbOverride := 7654321
 	svc := NewService(repo,
@@ -511,7 +592,7 @@ func TestResolveExternalIDsAdjustsEpisodeIMDbIDToParentSeries(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "Example.Series.-.02.1080p-GRP.mkv",
 		MediaInfoCategory: "TV",
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -522,11 +603,11 @@ func TestResolveExternalIDsAdjustsEpisodeIMDbIDToParentSeries(t *testing.T) {
 		t.Fatalf("resolve episode IMDb ID: %v", err)
 	}
 
-	if result.ExternalIDs.IMDBID != 1234567 || result.ExternalIDs.SourceIMDB != "imdb_episode_parent" {
-		t.Fatalf("expected parent-series IMDb ID, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != 1234567 || result.Identity.Provenance.IMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("expected parent-series IMDb ID, got %#v", result.Identity)
 	}
-	if result.ExternalMetadata.IMDB == nil || result.ExternalMetadata.IMDB.Title != "Example Series" || result.ExternalMetadata.IMDB.Type != "tvSeries" {
-		t.Fatalf("expected parent-series IMDb metadata, got %#v", result.ExternalMetadata.IMDB)
+	if result.ProviderMetadata.IMDB == nil || result.ProviderMetadata.IMDB.Title != "Example Series" || result.ProviderMetadata.IMDB.Type != "tvSeries" {
+		t.Fatalf("expected parent-series IMDb metadata, got %#v", result.ProviderMetadata.IMDB)
 	}
 	if imdbClient.episodeLookupCalls != 1 || imdbClient.infoCalls != 2 {
 		t.Fatalf("expected one parent lookup and parent metadata refetch, got lookups=%d info=%d", imdbClient.episodeLookupCalls, imdbClient.infoCalls)
@@ -548,7 +629,7 @@ func TestEnsureExternalClientsInitializesKeylessAniListWithoutTMDBAPIKey(t *test
 func TestResolveExternalIDsRefreshesAniListWithoutTMDBAPIKey(t *testing.T) {
 	sourcePath := "Example.Anime.S01E01.2026.1080p-GRP.mkv"
 	repo := &fakeRepo{
-		meta: api.ExternalMetadata{
+		meta: api.SourceScopedMetadata{
 			SourcePath: sourcePath,
 			AniList: &api.AniListMetadata{
 				AniListID:   100,
@@ -571,7 +652,7 @@ func TestResolveExternalIDsRefreshesAniListWithoutTMDBAPIKey(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		MALID:      400,
 	})
@@ -584,14 +665,14 @@ func TestResolveExternalIDsRefreshesAniListWithoutTMDBAPIKey(t *testing.T) {
 	if anilistClient.anilistCalls != 1 || len(anilistClient.anilistInputs) != 1 || anilistClient.anilistInputs[0] != 400 {
 		t.Fatalf("expected one keyless AniList fetch for MAL 400, got calls=%d inputs=%v", anilistClient.anilistCalls, anilistClient.anilistInputs)
 	}
-	if result.ExternalMetadata.TMDB != nil {
-		t.Fatalf("expected TMDB enrichment to remain unavailable, got %#v", result.ExternalMetadata.TMDB)
+	if result.ProviderMetadata.TMDB != nil {
+		t.Fatalf("expected TMDB enrichment to remain unavailable, got %#v", result.ProviderMetadata.TMDB)
 	}
-	if result.ExternalMetadata.AniList == nil || result.ExternalMetadata.AniList.MALID != 400 || result.ExternalMetadata.AniList.TitleRomaji != "Current Anime" {
-		t.Fatalf("expected refreshed AniList metadata, got %#v", result.ExternalMetadata.AniList)
+	if result.ProviderMetadata.AniList == nil || result.ProviderMetadata.AniList.MALID != 400 || result.ProviderMetadata.AniList.TitleRomaji != "Current Anime" {
+		t.Fatalf("expected refreshed AniList metadata, got %#v", result.ProviderMetadata.AniList)
 	}
-	if repo.meta.AniList == nil || repo.meta.AniList.MALID != 400 {
-		t.Fatalf("expected refreshed AniList metadata persisted, got %#v", repo.meta.AniList)
+	if repo.externalMetaSaves != 0 {
+		t.Fatal("provider candidate must not publish refreshed AniList metadata")
 	}
 }
 
@@ -604,7 +685,7 @@ func TestResolveExternalIDsDoesNotCreateTVmazePlaceholder(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "Example.Release.2026.S01.1080p.WEB-DL-GRP",
 		MediaInfoCategory: "TV",
 		SceneTVmazeID:     55,
@@ -612,11 +693,11 @@ func TestResolveExternalIDsDoesNotCreateTVmazePlaceholder(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolve unresolved TVmaze ID: %v", err)
 	}
-	if result.ExternalIDs.TVmazeID != 55 {
-		t.Fatalf("expected canonical TVmaze ID to remain, got %#v", result.ExternalIDs)
+	if result.Identity.TVmazeID != 55 {
+		t.Fatalf("expected canonical TVmaze ID to remain, got %#v", result.Identity)
 	}
-	if result.ExternalMetadata.TVmaze != nil {
-		t.Fatalf("expected no placeholder TVmaze snapshot, got %#v", result.ExternalMetadata.TVmaze)
+	if result.ProviderMetadata.TVmaze != nil {
+		t.Fatalf("expected no placeholder TVmaze snapshot, got %#v", result.ProviderMetadata.TVmaze)
 	}
 	if tvmazeClient.calls == 0 {
 		t.Fatal("expected TVmaze fetch attempt")
@@ -651,7 +732,7 @@ func TestMapTMDBMetadataClonesLocalizedTitles(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			result := tmdb.MetadataResult{LocalizedTitles: tt.localizedTitles}
 
-			mapped := mapTMDBMetadata(api.ExternalIDs{TMDBID: 123}, result)
+			mapped := mapTMDBMetadata(api.ExternalIdentity{TMDBID: 123}, result)
 			if mapped == nil {
 				t.Fatal("expected mapped metadata")
 			}
@@ -694,10 +775,14 @@ func TestCloneStringMapReturnsDetachedEmptyMapForNil(t *testing.T) {
 	}
 }
 
-func TestResolveExternalIDsSkipAutoTorrentIgnoresTrackerSourcedIDs(t *testing.T) {
+func TestResolveExternalIDsPreservesCanonicalTrackerIdentity(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{Title: "Example", Year: 2024}}
-	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt0000888", Title: "Example", Year: 2024}}
+	imdbClient := &stubIMDB{info: imdb.Info{
+		IMDbID: "tt0000002",
+		Title:  "Example",
+		Year:   2024,
+	}}
 	tvdbClient := &stubTVDB{}
 	tvmazeClient := &stubTVmaze{}
 
@@ -708,19 +793,20 @@ func TestResolveExternalIDsSkipAutoTorrentIgnoresTrackerSourcedIDs(t *testing.T)
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:      "/media/file.mkv",
 		StoredDataFresh: true,
-		Options:         api.UploadOptions{SkipAutoTorrent: true},
-		ExternalIDs: api.ExternalIDs{
+		Identity: api.ExternalIdentity{
 			SourcePath: "/media/file.mkv",
 			TMDBID:     1,
-			SourceTMDB: "tracker",
 			IMDBID:     2,
-			SourceIMDB: "tracker",
 			TVDBID:     3,
-			SourceTVDB: "tracker",
-			Category:   "MOVIE",
+			Category:   api.CanonicalCategoryMovie,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB: api.IdentityProvenanceTracker,
+				IMDB: api.IdentityProvenanceTracker,
+				TVDB: api.IdentityProvenanceTracker,
+			},
 		},
 		MediaInfoTMDBID:   999,
 		MediaInfoIMDBID:   888,
@@ -736,14 +822,14 @@ func TestResolveExternalIDsSkipAutoTorrentIgnoresTrackerSourcedIDs(t *testing.T)
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 999 || result.ExternalIDs.SourceTMDB != "mediainfo" {
-		t.Fatalf("expected tmdb from mediainfo, got %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 1 || result.Identity.Provenance.TMDB != api.IdentityProvenanceTracker {
+		t.Fatalf("expected canonical tracker tmdb identity, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.IMDBID != 888 || result.ExternalIDs.SourceIMDB != "mediainfo" {
-		t.Fatalf("expected imdb from mediainfo, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != 2 || result.Identity.Provenance.IMDB != api.IdentityProvenanceTracker {
+		t.Fatalf("expected canonical tracker imdb identity, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.TVDBID != 0 || result.ExternalIDs.SourceTVDB != "" {
-		t.Fatalf("expected tvdb cleared for movie category, got %#v", result.ExternalIDs)
+	if result.Identity.TVDBID != 0 || result.Identity.Provenance.TVDB != "" {
+		t.Fatalf("expected tvdb cleared for movie category, got %#v", result.Identity)
 	}
 	if tmdbClient.findCalls != 0 || tmdbClient.searchCalls != 0 || tmdbClient.metaCalls != 1 {
 		t.Fatalf("expected one tmdb metadata fetch only, got find=%d search=%d metadata=%d", tmdbClient.findCalls, tmdbClient.searchCalls, tmdbClient.metaCalls)
@@ -772,25 +858,26 @@ func TestResolveExternalIDsSkipAutoTorrentIgnoresTrackerSourcedIDs(t *testing.T)
 		WithTVmazeClient(reuseTVmazeClient),
 	)
 
-	reused, err := reuseSvc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	reused, err := reuseSvc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:      "/media/file.mkv",
 		StoredDataFresh: true,
-		Options:         api.UploadOptions{SkipAutoTorrent: true},
-		ExternalIDs: api.ExternalIDs{
+		Identity: api.ExternalIdentity{
 			SourcePath: "/media/file.mkv",
 			TMDBID:     1,
-			SourceTMDB: "tracker",
 			IMDBID:     2,
-			SourceIMDB: "tracker",
 			TVDBID:     3,
-			SourceTVDB: "tracker",
-			Category:   "MOVIE",
+			Category:   api.CanonicalCategoryMovie,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB: api.IdentityProvenanceTracker,
+				IMDB: api.IdentityProvenanceTracker,
+				TVDB: api.IdentityProvenanceTracker,
+			},
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "/media/file.mkv",
-			TMDB:       &api.TMDBMetadata{TMDBID: 999, Title: "Stored TMDB"},
-			IMDB:       &api.IMDBMetadata{IMDBID: 888, Title: "Stored IMDb"},
-			TVDB:       &api.TVDBMetadata{TVDBID: 777, Name: "Stored TVDB"},
+			TMDB:       &api.TMDBMetadata{TMDBID: 1, Title: "Stored TMDB"},
+			IMDB:       &api.IMDBMetadata{IMDBID: 2, Title: "Stored IMDb"},
+			TVDB:       &api.TVDBMetadata{TVDBID: 3, Name: "Stored TVDB"},
 		},
 		MediaInfoTMDBID:   999,
 		MediaInfoIMDBID:   888,
@@ -805,14 +892,14 @@ func TestResolveExternalIDsSkipAutoTorrentIgnoresTrackerSourcedIDs(t *testing.T)
 	if err != nil {
 		t.Fatalf("resolve reused metadata: %v", err)
 	}
-	if reused.ExternalMetadata.TMDB == nil || reused.ExternalMetadata.TMDB.Title != "Stored TMDB" {
-		t.Fatalf("expected stored tmdb metadata reused, got %#v", reused.ExternalMetadata.TMDB)
+	if reused.ProviderMetadata.TMDB == nil || reused.ProviderMetadata.TMDB.Title != "Stored TMDB" {
+		t.Fatalf("expected stored tmdb metadata reused, got %#v", reused.ProviderMetadata.TMDB)
 	}
-	if reused.ExternalMetadata.IMDB == nil || reused.ExternalMetadata.IMDB.Title != "Stored IMDb" {
-		t.Fatalf("expected stored imdb metadata reused, got %#v", reused.ExternalMetadata.IMDB)
+	if reused.ProviderMetadata.IMDB == nil || reused.ProviderMetadata.IMDB.Title != "Stored IMDb" {
+		t.Fatalf("expected stored imdb metadata reused, got %#v", reused.ProviderMetadata.IMDB)
 	}
-	if reused.ExternalMetadata.TVDB != nil {
-		t.Fatalf("expected stored tvdb metadata cleared for movie category, got %#v", reused.ExternalMetadata.TVDB)
+	if reused.ProviderMetadata.TVDB != nil {
+		t.Fatalf("expected stored tvdb metadata cleared for movie category, got %#v", reused.ProviderMetadata.TVDB)
 	}
 	if reuseTMDBClient.findCalls != 0 || reuseTMDBClient.searchCalls != 0 || reuseTMDBClient.metaCalls != 0 {
 		t.Fatalf("expected tmdb calls skipped for stored metadata, got find=%d search=%d metadata=%d", reuseTMDBClient.findCalls, reuseTMDBClient.searchCalls, reuseTMDBClient.metaCalls)
@@ -849,29 +936,30 @@ func TestResolveExternalIDsMovieCategoryVetoesEarlierTVCandidate(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath:  "/media/file.mkv",
-		Release:     api.ReleaseInfo{Category: "MOVIE", Title: "Example", Year: 2024},
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath: "/media/file.mkv",
+		Release: api.ReleaseInfo{
+			Category: "MOVIE",
+			Title:    "Example",
+			Year:     2024,
+		},
 		TrackerData: []api.TrackerMetadata{{Category: "TV", TVDBID: 12345}},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.Category != "MOVIE" {
-		t.Fatalf("expected external IDs category MOVIE, got %q", result.ExternalIDs.Category)
+	if result.Identity.Category != api.CanonicalCategoryMovie {
+		t.Fatalf("expected external IDs category MOVIE, got %q", result.Identity.Category)
 	}
-	if result.ExternalIDs.TVDBID != 0 {
-		t.Fatalf("expected tvdb cleared for movie category, got %d", result.ExternalIDs.TVDBID)
+	if result.Identity.TVDBID != 0 {
+		t.Fatalf("expected tvdb cleared for movie category, got %d", result.Identity.TVDBID)
 	}
 	if result.Release.Category != "MOVIE" {
 		t.Fatalf("expected release category MOVIE, got %q", result.Release.Category)
 	}
-	if repo.fileMetadata.Category != "MOVIE" {
-		t.Fatalf("expected persisted release category MOVIE, got %q", repo.fileMetadata.Category)
-	}
-	if repo.ids.Category != "MOVIE" {
-		t.Fatalf("expected persisted external IDs category MOVIE, got %q", repo.ids.Category)
+	if repo.fileMetadata.Category != "MOVIE" || repo.ids.SourcePath != "" {
+		t.Fatal("provider candidate must not publish category state")
 	}
 	if len(tmdbClient.searchInputs) == 0 || tmdbClient.searchInputs[0].Category != "MOVIE" {
 		t.Fatalf("expected MOVIE to be passed as TMDB preference, got %#v", tmdbClient.searchInputs)
@@ -899,26 +987,27 @@ func TestResolveExternalIDsIgnoresUnsupportedTrackerCategory(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath:  "/media/file.mkv",
-		Release:     api.ReleaseInfo{Category: "MOVIE", Title: "Example", Year: 2024},
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath: "/media/file.mkv",
+		Release: api.ReleaseInfo{
+			Category: "MOVIE",
+			Title:    "Example",
+			Year:     2024,
+		},
 		TrackerData: []api.TrackerMetadata{{Category: "Music"}},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.Category != "MOVIE" {
-		t.Fatalf("expected external IDs category MOVIE, got %q", result.ExternalIDs.Category)
+	if result.Identity.Category != api.CanonicalCategoryMovie {
+		t.Fatalf("expected external IDs category MOVIE, got %q", result.Identity.Category)
 	}
 	if result.Release.Category != "MOVIE" {
 		t.Fatalf("expected release category MOVIE, got %q", result.Release.Category)
 	}
-	if repo.fileMetadata.Category != "MOVIE" {
-		t.Fatalf("expected persisted release category MOVIE, got %q", repo.fileMetadata.Category)
-	}
-	if repo.ids.Category != "MOVIE" {
-		t.Fatalf("expected persisted external IDs category MOVIE, got %q", repo.ids.Category)
+	if repo.fileMetadata.Category != "MOVIE" || repo.ids.SourcePath != "" {
+		t.Fatal("provider candidate must not publish category state")
 	}
 }
 
@@ -926,11 +1015,19 @@ func TestResolveExternalIDsSearchAndMetadata(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{
 		searchOutcome: tmdb.SearchOutcome{TMDBID: 42, Category: "MOVIE"},
-		metadata:      tmdb.MetadataResult{Title: "Example", Year: 2024, TMDBType: "Movie"},
+		metadata: tmdb.MetadataResult{
+			Title:    "Example",
+			Year:     2024,
+			TMDBType: "Movie",
+		},
 	}
 	imdbClient := &stubIMDB{searchResult: imdb.SearchResult{IMDbID: 24}, info: imdb.Info{IMDbID: "tt0000024", Title: "Example"}}
 	tvdbClient := &stubTVDB{id: 12, name: "Example"}
-	tvmazeClient := &stubTVmaze{result: tvmaze.SearchResult{SelectedID: 55, IMDBID: 24, TVDBID: 12}}
+	tvmazeClient := &stubTVmaze{result: tvmaze.SearchResult{
+		SelectedID: 55,
+		IMDBID:     24,
+		TVDBID:     12,
+	}}
 
 	svc := NewService(repo,
 		WithTMDBClient(tmdbClient),
@@ -939,20 +1036,20 @@ func TestResolveExternalIDsSearchAndMetadata(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/file.mkv",
 		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 42 || result.ExternalIDs.IMDBID != 24 {
-		t.Fatalf("unexpected resolved ids: %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 42 || result.Identity.IMDBID != 24 {
+		t.Fatalf("unexpected resolved ids: %#v", result.Identity)
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.IMDB == nil {
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.IMDB == nil {
 		t.Fatalf("expected metadata results")
 	}
 	if tmdbClient.searchCalls == 0 || imdbClient.searchCalls == 0 {
@@ -964,7 +1061,11 @@ func TestResolveExternalIDsPassesLogoSettingsToTMDB(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{
 		searchOutcome: tmdb.SearchOutcome{TMDBID: 42, Category: "MOVIE"},
-		metadata:      tmdb.MetadataResult{Title: "Example", Year: 2024, TMDBType: "Movie"},
+		metadata: tmdb.MetadataResult{
+			Title:    "Example",
+			Year:     2024,
+			TMDBType: "Movie",
+		},
 	}
 	svc := NewService(repo,
 		WithConfig(config.Config{Description: config.DescriptionSettingsConfig{AddLogo: true, LogoLanguage: "ja,en"}}),
@@ -974,7 +1075,7 @@ func TestResolveExternalIDsPassesLogoSettingsToTMDB(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	_, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	_, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: "/media/file.mkv",
 		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
 	})
@@ -1012,15 +1113,15 @@ func TestResolveExternalIDsRefetchesMissingTMDBLogo(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:      "/media/file.mkv",
 		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
+		Identity: api.ExternalIdentity{
 			SourcePath: "/media/file.mkv",
 			TMDBID:     42,
 			Category:   "MOVIE",
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "/media/file.mkv",
 			TMDB:       &api.TMDBMetadata{TMDBID: 42, Title: "Cached without logo"},
 		},
@@ -1031,17 +1132,25 @@ func TestResolveExternalIDsRefetchesMissingTMDBLogo(t *testing.T) {
 	if tmdbClient.metaCalls != 1 {
 		t.Fatalf("expected one metadata refetch for logo, got %d", tmdbClient.metaCalls)
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.TMDB.Logo == "" {
-		t.Fatalf("expected logo to be refreshed, got %#v", result.ExternalMetadata.TMDB)
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.TMDB.Logo == "" {
+		t.Fatalf("expected logo to be refreshed, got %#v", result.ProviderMetadata.TMDB)
 	}
 }
 
 func TestResolveExternalIDsUsesSceneTVmazeToResolveIMDb(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{Title: "Example Show", Year: 2026}}
-	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt1234567", Title: "Example Show", Year: 2026}}
+	imdbClient := &stubIMDB{info: imdb.Info{
+		IMDbID: "tt1234567",
+		Title:  "Example Show",
+		Year:   2026,
+	}}
 	tvdbClient := &stubTVDB{id: 456789, name: "Example Show"}
-	tvmazeClient := &stubTVmaze{result: tvmaze.SearchResult{SelectedID: 12345, IMDBID: 1234567, TVDBID: 456789}}
+	tvmazeClient := &stubTVmaze{result: tvmaze.SearchResult{
+		SelectedID: 12345,
+		IMDBID:     1234567,
+		TVDBID:     456789,
+	}}
 
 	svc := NewService(repo,
 		WithTMDBClient(tmdbClient),
@@ -1050,7 +1159,7 @@ func TestResolveExternalIDsUsesSceneTVmazeToResolveIMDb(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "/media/Example.Show.S04E01.2160p.WEB.h265-GRP.mkv",
 		SceneTVmazeID:     12345,
 		Release:           api.ReleaseInfo{Category: "TV", Title: "Example Show"},
@@ -1060,24 +1169,33 @@ func TestResolveExternalIDsUsesSceneTVmazeToResolveIMDb(t *testing.T) {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TVmazeID != 12345 || result.ExternalIDs.SourceTVmaze != "scene" {
-		t.Fatalf("expected scene tvmaze id, got %#v", result.ExternalIDs)
+	if result.Identity.TVmazeID != 12345 || result.Identity.Provenance.TVmaze != "scene" {
+		t.Fatalf("expected scene tvmaze id, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.IMDBID != 1234567 || result.ExternalIDs.SourceIMDB != "tvmaze" {
-		t.Fatalf("expected imdb from tvmaze, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != 1234567 || result.Identity.Provenance.IMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("expected imdb from tvmaze, got %#v", result.Identity)
 	}
 	if tvmazeClient.calls == 0 || len(tvmazeClient.inputs) == 0 || tvmazeClient.inputs[0].ManualID != 12345 {
 		t.Fatalf("expected tvmaze manual lookup, got calls=%d inputs=%#v", tvmazeClient.calls, tvmazeClient.inputs)
 	}
-	if repo.ids.IMDBID != 1234567 || repo.ids.TVmazeID != 12345 {
-		t.Fatalf("expected persisted ids from tvmaze, got %#v", repo.ids)
+	if repo.ids.SourcePath != "" {
+		t.Fatal("provider candidate must not publish TVmaze identity")
 	}
 }
 
 func TestResolveExternalIDsUsesSceneNFOIDs(t *testing.T) {
 	repo := &fakeRepo{}
-	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{Title: "Example", Year: 2024, TMDBType: "TV", MALID: 999}}
-	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt0123456", Title: "Example", Year: 2024}}
+	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{
+		Title:    "Example",
+		Year:     2024,
+		TMDBType: "TV",
+		MALID:    999,
+	}}
+	imdbClient := &stubIMDB{info: imdb.Info{
+		IMDbID: "tt0123456",
+		Title:  "Example",
+		Year:   2024,
+	}}
 	tvdbClient := &stubTVDB{}
 	tvmazeClient := &stubTVmaze{}
 
@@ -1088,7 +1206,7 @@ func TestResolveExternalIDsUsesSceneNFOIDs(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:    "/media/example.mkv",
 		SceneTMDBID:   42,
 		SceneIMDB:     123456,
@@ -1101,26 +1219,26 @@ func TestResolveExternalIDsUsesSceneNFOIDs(t *testing.T) {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 42 || result.ExternalIDs.SourceTMDB != "scene" {
-		t.Fatalf("expected scene tmdb id, got %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 42 || result.Identity.Provenance.TMDB != "scene" {
+		t.Fatalf("expected scene tmdb id, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.IMDBID != 123456 || result.ExternalIDs.SourceIMDB != "scene" {
-		t.Fatalf("expected scene imdb id, got %#v", result.ExternalIDs)
+	if result.Identity.IMDBID != 123456 || result.Identity.Provenance.IMDB != "scene" {
+		t.Fatalf("expected scene imdb id, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.TVDBID != 333 || result.ExternalIDs.SourceTVDB != "scene" {
-		t.Fatalf("expected scene tvdb id, got %#v", result.ExternalIDs)
+	if result.Identity.TVDBID != 333 || result.Identity.Provenance.TVDB != "scene" {
+		t.Fatalf("expected scene tvdb id, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.TVmazeID != 444 || result.ExternalIDs.SourceTVmaze != "scene" {
-		t.Fatalf("expected scene tvmaze id, got %#v", result.ExternalIDs)
+	if result.Identity.TVmazeID != 444 || result.Identity.Provenance.TVmaze != "scene" {
+		t.Fatalf("expected scene tvmaze id, got %#v", result.Identity)
 	}
-	if result.ExternalIDs.MALID != 555 || result.ExternalIDs.SourceMAL != "scene" {
-		t.Fatalf("expected scene mal id, got %#v", result.ExternalIDs)
+	if result.Identity.MALID != 555 || result.Identity.Provenance.MAL != "scene" {
+		t.Fatalf("expected scene mal id, got %#v", result.Identity)
 	}
 	if result.MALID != 555 {
 		t.Fatalf("expected canonical scene mal mirror, got %d", result.MALID)
 	}
-	if repo.ids.TMDBID != 42 || repo.ids.IMDBID != 123456 || repo.ids.TVDBID != 333 || repo.ids.TVmazeID != 444 || repo.ids.MALID != 555 {
-		t.Fatalf("expected persisted scene ids, got %#v", repo.ids)
+	if repo.ids.SourcePath != "" {
+		t.Fatal("provider candidate must not publish scene identity")
 	}
 }
 
@@ -1138,22 +1256,24 @@ func TestResolveExternalIDsUsesStoredFreshData(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:      "/media/file.mkv",
 		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
-			SourcePath:   "/media/file.mkv",
-			TMDBID:       42,
-			IMDBID:       24,
-			TVDBID:       12,
-			TVmazeID:     55,
-			Category:     "TV",
-			SourceTMDB:   "db",
-			SourceIMDB:   "db",
-			SourceTVDB:   "db",
-			SourceTVmaze: "db",
-		},
-		ExternalMetadata: api.ExternalMetadata{
+		Identity: api.ExternalIdentity{
+			SourcePath: "/media/file.mkv",
+			TMDBID:     42,
+			IMDBID:     24,
+			TVDBID:     12,
+			TVmazeID:   55,
+			Category:   api.CanonicalCategoryTV,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB:   api.IdentityProvenanceLegacy,
+				IMDB:   api.IdentityProvenanceLegacy,
+				TVDB:   api.IdentityProvenanceLegacy,
+				TVmaze: api.IdentityProvenanceLegacy,
+			},
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "/media/file.mkv",
 			TMDB:       &api.TMDBMetadata{TMDBID: 42, Title: "Example"},
 			IMDB:       &api.IMDBMetadata{IMDBID: 24, Title: "Example"},
@@ -1162,15 +1282,15 @@ func TestResolveExternalIDsUsesStoredFreshData(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 42 || result.ExternalIDs.IMDBID != 24 || result.ExternalIDs.TVDBID != 12 || result.ExternalIDs.TVmazeID != 55 {
-		t.Fatalf("unexpected resolved ids: %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 42 || result.Identity.IMDBID != 24 || result.Identity.TVDBID != 12 || result.Identity.TVmazeID != 55 {
+		t.Fatalf("unexpected resolved ids: %#v", result.Identity)
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.IMDB == nil || result.ExternalMetadata.TVDB == nil || result.ExternalMetadata.TVmaze == nil {
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.IMDB == nil || result.ProviderMetadata.TVDB == nil || result.ProviderMetadata.TVmaze == nil {
 		t.Fatalf("expected stored metadata to be reused")
 	}
 	if tmdbClient.findCalls != 0 || tmdbClient.searchCalls != 0 || tmdbClient.metaCalls != 0 {
@@ -1194,8 +1314,17 @@ func TestResolveExternalIDsPrefersTMDBFromIMDbBeforeSearch(t *testing.T) {
 		findResult:    tmdb.FindResult{TMDBID: 456789, Category: "TV"},
 		metadata:      tmdb.MetadataResult{Title: "Example Quiz", TMDBType: "Scripted"},
 	}
-	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt1234567", Title: "Example Quiz", Type: "tvSeries", Year: 2026}}
-	tvdbClient := &stubTVDB{seriesMetadata: tvdb.SeriesMetadata{TVDBID: 456789, Name: "Example Quiz", FirstAired: "2026-09-10"}}
+	imdbClient := &stubIMDB{info: imdb.Info{
+		IMDbID: "tt1234567",
+		Title:  "Example Quiz",
+		Type:   "tvSeries",
+		Year:   2026,
+	}}
+	tvdbClient := &stubTVDB{seriesMetadata: tvdb.SeriesMetadata{
+		TVDBID:     456789,
+		Name:       "Example Quiz",
+		FirstAired: "2026-09-10",
+	}}
 	tvmazeClient := &stubTVmaze{}
 
 	svc := NewService(repo,
@@ -1205,23 +1334,31 @@ func TestResolveExternalIDsPrefersTMDBFromIMDbBeforeSearch(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        `D:\temp\Example.Quiz.2026.11.10.1080p.WEB-DL.AAC2.0.H.264-GRP.mkv`,
 		MediaInfoCategory: "TV",
-		Release:           api.ReleaseInfo{Title: "Example Quiz", Year: 2026, Type: "episode"},
-		TrackerData:       []api.TrackerMetadata{{IMDBID: 1234567, TVDBID: 456789, Category: "TV"}},
+		Release: api.ReleaseInfo{
+			Title: "Example Quiz",
+			Year:  2026,
+			Type:  "episode",
+		},
+		TrackerData: []api.TrackerMetadata{{
+			IMDBID:   1234567,
+			TVDBID:   456789,
+			Category: "TV",
+		}},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 456789 {
-		t.Fatalf("expected tmdb id from imdb external lookup, got %d", result.ExternalIDs.TMDBID)
+	if result.Identity.TMDBID != 456789 {
+		t.Fatalf("expected tmdb id from imdb external lookup, got %d", result.Identity.TMDBID)
 	}
-	if result.ExternalIDs.SourceTMDB != "tmdb_external" {
-		t.Fatalf("expected tmdb source tmdb_external, got %q", result.ExternalIDs.SourceTMDB)
+	if result.Identity.Provenance.TMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("expected tmdb source tmdb_external, got %q", result.Identity.Provenance.TMDB)
 	}
 	if tmdbClient.findCalls != 1 {
 		t.Fatalf("expected one tmdb external lookup call, got %d", tmdbClient.findCalls)
@@ -1251,18 +1388,23 @@ func TestResolveExternalIDsEpisodeTypeForcesTVTMDBSearchCategory(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `/media/Example.Show.2025.11.10.1080p.WEB-DL.mkv`,
-		Release:    api.ReleaseInfo{Title: "Example Show", Year: 2025, Category: "TV", Type: "WEB-DL"},
+		Release: api.ReleaseInfo{
+			Title:    "Example Show",
+			Year:     2025,
+			Category: "TV",
+			Type:     "WEB-DL",
+		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.Category != "TV" {
-		t.Fatalf("expected category TV from release type episode, got %q", result.ExternalIDs.Category)
+	if result.Identity.Category != api.CanonicalCategoryTV {
+		t.Fatalf("expected category TV from release type episode, got %q", result.Identity.Category)
 	}
 	if tmdbClient.searchCalls != 1 {
 		t.Fatalf("expected one tmdb search call, got %d", tmdbClient.searchCalls)
@@ -1306,23 +1448,26 @@ func TestResolveExternalIDsSearchStagesAndUnattendedInteractionMode(t *testing.T
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Example.Series.2025.1080p.WEB-DL.mkv",
-		Mode:       api.ModeCLI,
-		Options:    api.UploadOptions{InteractionMode: api.InteractionModeUnattended},
-		Release:    api.ReleaseInfo{Title: "Example Series", Year: 2025, Type: "episode"},
+		Policy:     preparationstate.CollectionPolicy{InteractionMode: api.InteractionModeUnattended},
+		Release: api.ReleaseInfo{
+			Title: "Example Series",
+			Year:  2025,
+			Type:  "episode",
+		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 4242 {
-		t.Fatalf("expected staged tmdb id 4242, got %d", result.ExternalIDs.TMDBID)
+	if result.Identity.TMDBID != 4242 {
+		t.Fatalf("expected staged tmdb id 4242, got %d", result.Identity.TMDBID)
 	}
-	if result.ExternalIDs.IMDBID != 2424 {
-		t.Fatalf("expected staged imdb id 2424, got %d", result.ExternalIDs.IMDBID)
+	if result.Identity.IMDBID != 2424 {
+		t.Fatalf("expected staged imdb id 2424, got %d", result.Identity.IMDBID)
 	}
 
 	if len(tmdbClient.searchInputs) < 3 {
@@ -1360,11 +1505,14 @@ func TestResolveExternalIDsInteractiveCLIDoesNotForceUnattendedSearch(t *testing
 	}}
 	svc := NewService(repo, WithTMDBClient(tmdbClient), WithIMDBClient(imdbClient), WithTVDBClient(&stubTVDB{}), WithTVmazeClient(&stubTVmaze{}))
 
-	_, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	_, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: "/media/Example.Series.2025.1080p.WEB-DL.mkv",
-		Mode:       api.ModeCLI,
-		Options:    api.UploadOptions{InteractionMode: api.InteractionModeInteractive},
-		Release:    api.ReleaseInfo{Title: "Example Series", Year: 2025, Type: "episode"},
+		Policy:     preparationstate.CollectionPolicy{InteractionMode: api.InteractionModeInteractive},
+		Release: api.ReleaseInfo{
+			Title: "Example Series",
+			Year:  2025,
+			Type:  "episode",
+		},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
@@ -1406,7 +1554,7 @@ func TestResolveExternalIDsDailyDateSkipsParsedYearInSearch(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:       "/media/Example.Quiz.2026.01.12.720p.HDTV.x264.mkv",
 		DailyEpisodeDate: "2026-01-12",
 		Release: api.ReleaseInfo{
@@ -1416,13 +1564,13 @@ func TestResolveExternalIDsDailyDateSkipsParsedYearInSearch(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 4242 || result.ExternalIDs.IMDBID != 2424 {
-		t.Fatalf("unexpected resolved ids: %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 4242 || result.Identity.IMDBID != 2424 {
+		t.Fatalf("unexpected resolved ids: %#v", result.Identity)
 	}
 	if len(tmdbClient.searchInputs) != 1 {
 		t.Fatalf("expected single tmdb search stage with year 0, got %d", len(tmdbClient.searchInputs))
@@ -1436,7 +1584,11 @@ func TestResolveExternalIDsFetchesIMDBAfterTMDBResolvesIt(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{
 		searchOutcome: tmdb.SearchOutcome{TMDBID: 224372, Category: "TV"},
-		metadata:      tmdb.MetadataResult{Title: "Example Show", TMDBType: "Scripted", IMDbID: 1234567},
+		metadata: tmdb.MetadataResult{
+			Title:    "Example Show",
+			TMDBType: "Scripted",
+			IMDbID:   1234567,
+		},
 	}
 	imdbClient := &stubIMDB{info: imdb.Info{IMDbID: "tt1234567", Title: "Example Show"}}
 	tvdbClient := &stubTVDB{}
@@ -1449,24 +1601,24 @@ func TestResolveExternalIDsFetchesIMDBAfterTMDBResolvesIt(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.Show.S01E01.2160p.WEB-DL.mkv",
 		MediaInfoCategory: "TV",
 		Release:           api.ReleaseInfo{Title: "Example Show"},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.IMDBID != 1234567 {
-		t.Fatalf("expected imdb id resolved from tmdb metadata, got %d", result.ExternalIDs.IMDBID)
+	if result.Identity.IMDBID != 1234567 {
+		t.Fatalf("expected imdb id resolved from tmdb metadata, got %d", result.Identity.IMDBID)
 	}
 	if imdbClient.infoCalls == 0 {
 		t.Fatalf("expected imdb metadata fetch after tmdb-imdb enrichment")
 	}
-	if result.ExternalMetadata.IMDB == nil {
+	if result.ProviderMetadata.IMDB == nil {
 		t.Fatalf("expected imdb metadata after enrichment")
 	}
 }
@@ -1488,19 +1640,19 @@ func TestResolveExternalIDsDoesNotTreatTMDBMovieWithoutIMDbAsTVMovie(t *testing.
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.Movie.2024.2160p.WEB-DL.mkv",
 		MediaInfoCategory: "movie",
 		Release:           api.ReleaseInfo{Title: "Example Movie", Year: 2024},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TVDBID != 0 {
-		t.Fatalf("expected no tvdb id without imdb tv movie metadata, got %d", result.ExternalIDs.TVDBID)
+	if result.Identity.TVDBID != 0 {
+		t.Fatalf("expected no tvdb id without imdb tv movie metadata, got %d", result.Identity.TVDBID)
 	}
 	if len(tvdbClient.tvMovieCalls) != 0 {
 		t.Fatalf("expected no tvdb lookup for movie category, got calls %#v", tvdbClient.tvMovieCalls)
@@ -1511,11 +1663,19 @@ func TestResolveExternalIDsDoesNotApplyTVDBForMovieCategory(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{
 		searchOutcome: tmdb.SearchOutcome{TMDBID: 1234, Category: "Movie"},
-		metadata:      tmdb.MetadataResult{Title: "Example TV Movie", TMDBType: "Movie", TVDBID: 55},
+		metadata: tmdb.MetadataResult{
+			Title:    "Example TV Movie",
+			TMDBType: "Movie",
+			TVDBID:   55,
+		},
 	}
 	imdbClient := &stubIMDB{
 		searchResult: imdb.SearchResult{IMDbID: 9876},
-		info:         imdb.Info{IMDbID: "tt0009876", Title: "Example TV Movie", Type: "tvMovie"},
+		info: imdb.Info{
+			IMDbID: "tt0009876",
+			Title:  "Example TV Movie",
+			Type:   "tvMovie",
+		},
 	}
 	tvdbClient := &stubTVDB{idWhenTVMovie: 55, nameWhenTVMovie: "Example TV Movie"}
 	tvmazeClient := &stubTVmaze{}
@@ -1527,22 +1687,22 @@ func TestResolveExternalIDsDoesNotApplyTVDBForMovieCategory(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.TV.Movie.2024.1080p.WEB-DL.mkv",
 		MediaInfoCategory: "movie",
 		Release:           api.ReleaseInfo{Title: "Example TV Movie", Year: 2024},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TVDBID != 0 {
-		t.Fatalf("expected no tvdb id for movie category, got %d", result.ExternalIDs.TVDBID)
+	if result.Identity.TVDBID != 0 {
+		t.Fatalf("expected no tvdb id for movie category, got %d", result.Identity.TVDBID)
 	}
-	if result.ExternalMetadata.TVDB != nil {
-		t.Fatalf("expected no tvdb metadata for movie category, got %#v", result.ExternalMetadata.TVDB)
+	if result.ProviderMetadata.TVDB != nil {
+		t.Fatalf("expected no tvdb metadata for movie category, got %#v", result.ProviderMetadata.TVDB)
 	}
 	if len(tvdbClient.tvMovieCalls) != 0 {
 		t.Fatalf("expected no tvdb lookup for movie category, got %#v", tvdbClient.tvMovieCalls)
@@ -1553,7 +1713,11 @@ func TestResolveExternalIDsTVmazeWaitsForIDThenFallsBack(t *testing.T) {
 	repo := &fakeRepo{}
 	tmdbClient := &stubTMDB{
 		searchOutcome: tmdb.SearchOutcome{TMDBID: 224372, Category: "TV"},
-		metadata:      tmdb.MetadataResult{Title: "Example Show", TMDBType: "Scripted", TVDBID: 433631},
+		metadata: tmdb.MetadataResult{
+			Title:    "Example Show",
+			TMDBType: "Scripted",
+			TVDBID:   433631,
+		},
 	}
 	imdbClient := &stubIMDB{}
 	tvdbClient := &stubTVDB{}
@@ -1566,13 +1730,13 @@ func TestResolveExternalIDsTVmazeWaitsForIDThenFallsBack(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.Show.S01E01.2160p.WEB-DL.mkv",
 		MediaInfoCategory: "TV",
 		Release:           api.ReleaseInfo{Title: "Example Show"},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
@@ -1589,7 +1753,7 @@ func TestResolveExternalIDsTVmazeWaitsForIDThenFallsBack(t *testing.T) {
 	if tvmazeClient.inputs[0].StrictIDOnly {
 		t.Fatalf("expected second-pass tvmaze lookup to allow strict fallback")
 	}
-	if result.ExternalMetadata.TVmaze == nil || result.ExternalMetadata.TVmaze.TVmazeID != 55 {
+	if result.ProviderMetadata.TVmaze == nil || result.ProviderMetadata.TVmaze.TVmazeID != 55 {
 		t.Fatalf("expected tvmaze metadata result")
 	}
 }
@@ -1608,25 +1772,30 @@ func TestResolveExternalIDsOverride(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
-		SourcePath:  "/media/file.mkv",
-		TrackerData: []api.TrackerMetadata{{TMDBID: 1, IMDBID: 2, TVDBID: 3}},
+	meta := preparationstate.State{
+		SourcePath: "/media/file.mkv",
+		TrackerData: []api.TrackerMetadata{{
+			TMDBID: 1,
+			IMDBID: 2,
+			TVDBID: 3,
+		}},
 		ExternalIDOverrides: api.ExternalIDOverrides{
 			TMDBID: new(999),
 			IMDBID: new(111),
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 999 || result.ExternalIDs.IMDBID != 111 {
-		t.Fatalf("unexpected override ids: %#v", result.ExternalIDs)
+	if result.Identity.TMDBID != 999 || result.Identity.IMDBID != 111 {
+		t.Fatalf("unexpected override ids: %#v", result.Identity)
 	}
-	if result.ExternalIDs.SourceTMDB != "override" || result.ExternalIDs.SourceIMDB != "override" {
-		t.Fatalf("unexpected override sources: %#v", result.ExternalIDs)
+	if result.Identity.Provenance.TMDB != api.IdentityProvenanceExplicit || result.Identity.Provenance.IMDB != api.IdentityProvenanceExplicit ||
+		result.Identity.Overrides.TMDB != api.OverrideStateValue || result.Identity.Overrides.IMDB != api.OverrideStateValue {
+		t.Fatalf("unexpected override sources: %#v", result.Identity)
 	}
 }
 
@@ -1642,16 +1811,16 @@ func TestResolveExternalIDsRefetchesProviderSnapshotsAfterIDOverride(t *testing.
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:      "Example.Release.2026.1080p-GRP.mkv",
 		StoredDataFresh: true,
-		ExternalIDs: api.ExternalIDs{
+		Identity: api.ExternalIdentity{
 			SourcePath: "Example.Release.2026.1080p-GRP.mkv",
 			Category:   "movie",
 			TMDBID:     1,
 			IMDBID:     2,
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "Example.Release.2026.1080p-GRP.mkv",
 			TMDB:       &api.TMDBMetadata{TMDBID: 1, Title: "Stale TMDB"},
 			IMDB:       &api.IMDBMetadata{IMDBID: 2, Title: "Stale IMDb"},
@@ -1664,11 +1833,11 @@ func TestResolveExternalIDsRefetchesProviderSnapshotsAfterIDOverride(t *testing.
 	if err != nil {
 		t.Fatalf("resolve changed provider IDs: %v", err)
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.TMDB.TMDBID != 999 || result.ExternalMetadata.TMDB.Title != "Current TMDB" {
-		t.Fatalf("expected refetched TMDB snapshot, got %#v", result.ExternalMetadata.TMDB)
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.TMDB.TMDBID != 999 || result.ProviderMetadata.TMDB.Title != "Current TMDB" {
+		t.Fatalf("expected refetched TMDB snapshot, got %#v", result.ProviderMetadata.TMDB)
 	}
-	if result.ExternalMetadata.IMDB == nil || result.ExternalMetadata.IMDB.IMDBID != 111 || result.ExternalMetadata.IMDB.Title != "Current IMDb" {
-		t.Fatalf("expected refetched IMDb snapshot, got %#v", result.ExternalMetadata.IMDB)
+	if result.ProviderMetadata.IMDB == nil || result.ProviderMetadata.IMDB.IMDBID != 111 || result.ProviderMetadata.IMDB.Title != "Current IMDb" {
+		t.Fatalf("expected refetched IMDb snapshot, got %#v", result.ProviderMetadata.IMDB)
 	}
 	if tmdbClient.metaCalls != 1 || imdbClient.infoCalls != 1 {
 		t.Fatalf("expected one provider refetch each, got tmdb=%d imdb=%d", tmdbClient.metaCalls, imdbClient.infoCalls)
@@ -1677,7 +1846,11 @@ func TestResolveExternalIDsRefetchesProviderSnapshotsAfterIDOverride(t *testing.
 
 func TestResolveExternalIDsClearIMDBReresolvesFromOverriddenTMDB(t *testing.T) {
 	repo := &fakeRepo{}
-	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{IMDbID: 777, TMDBType: "Movie", Title: "Example"}}
+	tmdbClient := &stubTMDB{metadata: tmdb.MetadataResult{
+		IMDbID:   777,
+		TMDBType: "Movie",
+		Title:    "Example",
+	}}
 	imdbClient := &stubIMDB{}
 	tvdbClient := &stubTVDB{}
 	tvmazeClient := &stubTVmaze{}
@@ -1689,7 +1862,7 @@ func TestResolveExternalIDsClearIMDBReresolvesFromOverriddenTMDB(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  "/media/file.mkv",
 		TrackerData: []api.TrackerMetadata{{IMDBID: 2}},
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -1698,19 +1871,19 @@ func TestResolveExternalIDsClearIMDBReresolvesFromOverriddenTMDB(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalIDs.TMDBID != 999 {
-		t.Fatalf("expected tmdb override 999, got %d", result.ExternalIDs.TMDBID)
+	if result.Identity.TMDBID != 999 {
+		t.Fatalf("expected tmdb override 999, got %d", result.Identity.TMDBID)
 	}
-	if result.ExternalIDs.IMDBID != 777 {
-		t.Fatalf("expected imdb re-resolved from tmdb metadata, got %d", result.ExternalIDs.IMDBID)
+	if result.Identity.IMDBID != 777 {
+		t.Fatalf("expected imdb re-resolved from tmdb metadata, got %d", result.Identity.IMDBID)
 	}
-	if result.ExternalIDs.SourceIMDB != "tmdb" {
-		t.Fatalf("expected imdb source tmdb after clear, got %q", result.ExternalIDs.SourceIMDB)
+	if result.Identity.Provenance.IMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("expected imdb source tmdb after clear, got %q", result.Identity.Provenance.IMDB)
 	}
 }
 
@@ -1728,7 +1901,7 @@ func TestResolveExternalIDsClearTMDBReresolvesFromRetainedIMDB(t *testing.T) {
 		WithTVmazeClient(tvmazeClient),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  "/media/file.mkv",
 		TrackerData: []api.TrackerMetadata{{IMDBID: 159881, TMDBID: 1}},
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -1736,7 +1909,7 @@ func TestResolveExternalIDsClearTMDBReresolvesFromRetainedIMDB(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
@@ -1744,17 +1917,17 @@ func TestResolveExternalIDsClearTMDBReresolvesFromRetainedIMDB(t *testing.T) {
 	if tmdbClient.findCalls != 1 {
 		t.Fatalf("expected tmdb external lookup call, got %d", tmdbClient.findCalls)
 	}
-	if result.ExternalIDs.TMDBID != 77075 {
-		t.Fatalf("expected tmdb id re-resolved from imdb, got %d", result.ExternalIDs.TMDBID)
+	if result.Identity.TMDBID != 77075 {
+		t.Fatalf("expected tmdb id re-resolved from imdb, got %d", result.Identity.TMDBID)
 	}
-	if result.ExternalIDs.SourceTMDB != "tmdb_external" {
-		t.Fatalf("expected tmdb source tmdb_external after clear, got %q", result.ExternalIDs.SourceTMDB)
+	if result.Identity.Provenance.TMDB != api.IdentityProvenanceProvider {
+		t.Fatalf("expected tmdb source tmdb_external after clear, got %q", result.Identity.Provenance.TMDB)
 	}
 }
 
 func TestResolveExternalIDsMissingRepo(t *testing.T) {
 	svc := NewService(nil)
-	_, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{SourcePath: "/media/file.mkv"})
+	_, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{SourcePath: "/media/file.mkv"})
 	if err == nil {
 		t.Fatalf("expected error")
 	}
@@ -1764,7 +1937,7 @@ func TestResolveExternalIDsMissingRepo(t *testing.T) {
 }
 
 func TestResolveSearchTitleYearFromPathFallback(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\2026 - Example Movie [DVD9.PAL]`,
 	}
 
@@ -1786,11 +1959,11 @@ func TestApplyTVEpisodeMetadataDailyMappingMatch(t *testing.T) {
 	svc := NewService(&fakeRepo{})
 	tmdbClient := &stubTMDB{dailySeason: 2, dailyEpisode: 7}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:       "/media/Show.2024-01-15.mkv",
 		DailyEpisodeDate: "2024-01-15",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		Category: "TV",
 	}
@@ -1808,11 +1981,11 @@ func TestApplyTVEpisodeMetadataDailyMappingNoMatchDoesNotCoerceEpisode(t *testin
 	svc := NewService(&fakeRepo{})
 	tmdbClient := &stubTMDB{}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:       "/media/Show.2024-01-15.mkv",
 		DailyEpisodeDate: "2024-01-15",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		Category: "TV",
 	}
@@ -1830,7 +2003,7 @@ func TestApplyTVEpisodeMetadataDailyMappingNoMatchDoesNotPersistParsedFallback(t
 	svc := NewService(&fakeRepo{})
 	tmdbClient := &stubTMDB{}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:       "/media/Daily.Show.2024-01-15.mkv",
 		DailyEpisodeDate: "2024-01-15",
 		Release: api.ReleaseInfo{
@@ -1839,7 +2012,7 @@ func TestApplyTVEpisodeMetadataDailyMappingNoMatchDoesNotPersistParsedFallback(t
 			Episode:  115,
 		},
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		Category: "TV",
 	}
@@ -1862,7 +2035,7 @@ func TestApplyTVEpisodeMetadataUseSeasonEpisodePrefersTMDBDateMapping(t *testing
 	tmdbClient := &stubTMDB{dailySeason: 2, dailyEpisode: 7}
 	useSeasonEpisode := true
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:       "/media/Show.2024-01-15.mkv",
 		SeasonInt:        9,
 		EpisodeInt:       99,
@@ -1873,7 +2046,7 @@ func TestApplyTVEpisodeMetadataUseSeasonEpisodePrefersTMDBDateMapping(t *testing
 			UseSeasonEpisode: &useSeasonEpisode,
 		},
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		Category: "TV",
 	}
@@ -1952,15 +2125,15 @@ func TestApplyTVEpisodeMetadataTVDBAliasYearApplied(t *testing.T) {
 	tmdbClient := &stubTMDB{}
 	tvdbClient := &stubTVDB{specificAlias: "Le Bureau (2018)"}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Le.Bureau.S01E01.mkv",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TMDB: &api.TMDBMetadata{OriginalLanguage: "fr"},
 		TVDB: &api.TVDBMetadata{TVDBID: 200},
 	}
@@ -1980,15 +2153,15 @@ func TestApplyTVEpisodeMetadataTVDBAliasYearUsesLastYear(t *testing.T) {
 	tmdbClient := &stubTMDB{}
 	tvdbClient := &stubTVDB{specificAlias: "Hunter x Hunter (1999) (2011)"}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Hunter.x.Hunter.S01E01.mkv",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		TVDB: &api.TVDBMetadata{TVDBID: 200},
 	}
@@ -2012,10 +2185,26 @@ func TestApplyTVEpisodeMetadataTVDBAliasYearPreservesSource(t *testing.T) {
 		yearSource string
 		confidence string
 	}{
-		{name: "translation name", yearSource: "translation_name", confidence: "high"},
-		{name: "translation alias", yearSource: "translation_alias", confidence: "high"},
-		{name: "extended alias", yearSource: "extended_alias", confidence: "high"},
-		{name: "slug", yearSource: "slug", confidence: "low"},
+		{
+			name:       "translation name",
+			yearSource: "translation_name",
+			confidence: "high",
+		},
+		{
+			name:       "translation alias",
+			yearSource: "translation_alias",
+			confidence: "high",
+		},
+		{
+			name:       "extended alias",
+			yearSource: "extended_alias",
+			confidence: "high",
+		},
+		{
+			name:       "slug",
+			yearSource: "slug",
+			confidence: "low",
+		},
 	}
 
 	for _, tt := range tests {
@@ -2031,15 +2220,15 @@ func TestApplyTVEpisodeMetadataTVDBAliasYearPreservesSource(t *testing.T) {
 				specificAlias: "Hunter x Hunter (2011)",
 			}
 
-			meta := api.PreparedMetadata{
+			meta := preparationstate.State{
 				SourcePath: "/media/Hunter.x.Hunter.S01E01.mkv",
 			}
-			ids := &api.ExternalIDs{
+			ids := &api.ExternalIdentity{
 				TMDBID:   100,
 				TVDBID:   200,
 				Category: "TV",
 			}
-			external := &api.ExternalMetadata{
+			external := &api.SourceScopedMetadata{
 				TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 				TVDB: &api.TVDBMetadata{TVDBID: 200},
 			}
@@ -2064,15 +2253,15 @@ func TestApplyTVEpisodeMetadataTVDBTitleOnlyAliasAppliedWithoutYear(t *testing.T
 	tmdbClient := &stubTMDB{}
 	tvdbClient := &stubTVDB{specificAlias: "Cats Eye"}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Cats.Eye.S01E01.mkv",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		TVDB: &api.TVDBMetadata{TVDBID: 200},
 	}
@@ -2095,17 +2284,21 @@ func TestApplyTVEpisodeMetadataTVDBAliasAppliedForEnglish(t *testing.T) {
 	tmdbClient := &stubTMDB{}
 	tvdbClient := &stubTVDB{specificAlias: "English Show (2021)"}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/English.Show.S01E01.mkv",
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TMDBID:   100,
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TMDB: &api.TMDBMetadata{OriginalLanguage: "en"},
-		TVDB: &api.TVDBMetadata{TVDBID: 200, Name: "Native Name", Year: 2015},
+		TVDB: &api.TVDBMetadata{
+			TVDBID: 200,
+			Name:   "Native Name",
+			Year:   2015,
+		},
 	}
 
 	_ = svc.applyTVEpisodeMetadata(context.Background(), meta, ids, external, tmdbClient, tvdbClient, &stubTVmaze{})
@@ -2137,16 +2330,16 @@ func TestApplyTVEpisodeMetadataTVDBEpisodeTranslationApplied(t *testing.T) {
 		},
 	}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Example.Show.S01E02.mkv",
 		SeasonInt:  1,
 		EpisodeInt: 2,
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TVDB: &api.TVDBMetadata{TVDBID: 200, OriginalLanguage: "jpn"},
 	}
 
@@ -2194,12 +2387,12 @@ func TestApplyTVEpisodeMetadataTVDBMapsSeasonlessAbsoluteWithoutTMDB(t *testing.
 		}}},
 		episodeTranslate: tvdb.EpisodeTranslation{Name: "Take the Example Path"},
 	}
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "Example.Release.-.12.1080p-GRP.mkv",
 		EpisodeInt: 12,
 	}
-	ids := &api.ExternalIDs{TVDBID: 200, Category: "TV"}
-	external := &api.ExternalMetadata{
+	ids := &api.ExternalIdentity{TVDBID: 200, Category: "TV"}
+	external := &api.SourceScopedMetadata{
 		TVDB: &api.TVDBMetadata{TVDBID: 200, OriginalLanguage: "jpn"},
 	}
 
@@ -2225,19 +2418,39 @@ func TestApplyTVEpisodeMetadataIMDbMapsSeasonlessAbsoluteThenUsesTVmaze(t *testi
 		EpisodeNumber: 1,
 		AirDate:       "2026-04-24",
 	}}
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "Example.Series.-.03.1080p-GRP.mkv",
 		EpisodeInt: 3,
 	}
-	ids := &api.ExternalIDs{IMDBID: 1234567, TVmazeID: 55, Category: "TV"}
-	external := &api.ExternalMetadata{IMDB: &api.IMDBMetadata{
+	ids := &api.ExternalIdentity{
+		IMDBID:   1234567,
+		TVmazeID: 55,
+		Category: "TV",
+	}
+	external := &api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{
 		IMDBID: 1234567,
 		Title:  "Example Series",
 		Type:   "tvSeries",
 		Episodes: []api.IMDBEpisode{
-			{ID: "tt1000001", Title: "Episode One", Season: 1, EpisodeText: "1"},
-			{ID: "tt1000002", Title: "Episode Two", Season: 1, EpisodeText: "2"},
-			{ID: "tt1000003", Title: "IMDb Episode Three", Season: 2, EpisodeText: "1", ReleaseYear: 2026},
+			{
+				ID:          "tt1000001",
+				Title:       "Episode One",
+				Season:      1,
+				EpisodeText: "1",
+			},
+			{
+				ID:          "tt1000002",
+				Title:       "Episode Two",
+				Season:      1,
+				EpisodeText: "2",
+			},
+			{
+				ID:          "tt1000003",
+				Title:       "IMDb Episode Three",
+				Season:      2,
+				EpisodeText: "1",
+				ReleaseYear: 2026,
+			},
 		},
 	}}
 
@@ -2256,13 +2469,21 @@ func TestApplyTVEpisodeMetadataIMDbMapsSeasonlessAbsoluteThenUsesTVmaze(t *testi
 
 func TestApplyTVEpisodeMetadataIMDbTitleFallbackWithoutTVmaze(t *testing.T) {
 	svc := NewService(&fakeRepo{})
-	meta := api.PreparedMetadata{SourcePath: "Example.Series.S01E02.1080p-GRP.mkv", SeasonInt: 1, EpisodeInt: 2}
-	ids := &api.ExternalIDs{IMDBID: 1234567, Category: "TV"}
-	external := &api.ExternalMetadata{IMDB: &api.IMDBMetadata{
+	meta := preparationstate.State{
+		SourcePath: "Example.Series.S01E02.1080p-GRP.mkv",
+		SeasonInt:  1,
+		EpisodeInt: 2,
+	}
+	ids := &api.ExternalIdentity{IMDBID: 1234567, Category: "TV"}
+	external := &api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{
 		IMDBID: 1234567,
 		Title:  "Example Series",
 		Episodes: []api.IMDBEpisode{{
-			ID: "tt1000002", Title: "The Example Path", Season: 1, EpisodeText: "2", ReleaseYear: 2026,
+			ID:          "tt1000002",
+			Title:       "The Example Path",
+			Season:      1,
+			EpisodeText: "2",
+			ReleaseYear: 2026,
 		}},
 	}}
 
@@ -2299,16 +2520,16 @@ func TestApplyTVEpisodeMetadataStoresTVDBSeasonEpisodesForPack(t *testing.T) {
 		}},
 	}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Example.Show.S02.mkv",
 		SeasonInt:  2,
 		TVPack:     true,
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TVDB: &api.TVDBMetadata{TVDBID: 200, OriginalLanguage: "eng"},
 	}
 
@@ -2336,16 +2557,16 @@ func TestApplyTVEpisodeMetadataTVDBEpisodeTitleSkipsOriginalWhenEnglishMissing(t
 		episodeTransErr: errors.New("no english translation"),
 	}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Example.Show.S01E03.mkv",
 		SeasonInt:  1,
 		EpisodeInt: 3,
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TVDBID:   200,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TVDB: &api.TVDBMetadata{TVDBID: 200, OriginalLanguage: "jpn"},
 	}
 
@@ -2370,22 +2591,22 @@ func TestApplyTVEpisodeMetadataDiscardsSeriesTitleAsEpisodeTitle(t *testing.T) {
 		},
 	}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:   "/media/Re.ZERO.S04E11.mkv",
 		SeasonInt:    4,
 		EpisodeInt:   11,
 		EpisodeTitle: "Re:ZERO -Starting Life in Another World-",
-		ExternalIDs:  api.ExternalIDs{Category: "TV"},
-		ExternalMetadata: api.ExternalMetadata{
+		Identity:     api.ExternalIdentity{Category: "TV"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TVDB: &api.TVDBMetadata{NameEnglish: "Re: ZERO, Starting Life in Another World"},
 		},
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TVDBID:   200,
 		TVmazeID: 300,
 		Category: "TV",
 	}
-	external := &api.ExternalMetadata{
+	external := &api.SourceScopedMetadata{
 		TVDB: &api.TVDBMetadata{TVDBID: 200, NameEnglish: "Re: ZERO, Starting Life in Another World"},
 	}
 
@@ -2409,12 +2630,12 @@ func TestApplyTVEpisodeMetadataEpisodeTitleBlankedWhenTBA(t *testing.T) {
 		}}},
 	}
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/media/Example.Show.S01E04.mkv",
 		SeasonInt:  1,
 		EpisodeInt: 4,
 	}
-	ids := &api.ExternalIDs{
+	ids := &api.ExternalIdentity{
 		TVDBID:   200,
 		Category: "TV",
 	}
@@ -2432,14 +2653,46 @@ func TestSanitizeEpisodeTitleSkipsGenericAndPlaceholderTitles(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "numeric episode", input: "Episode 1", want: ""},
-		{name: "hash episode", input: "Episode #12", want: ""},
-		{name: "word episode", input: "Episode One", want: ""},
-		{name: "tba", input: "TBA", want: ""},
-		{name: "tbd", input: "TBD", want: ""},
-		{name: "tbc", input: "TBC", want: ""},
-		{name: "tdc", input: "TDC", want: ""},
-		{name: "real title containing episode", input: "The Episode Problem", want: "The Episode Problem"},
+		{
+			name:  "numeric episode",
+			input: "Episode 1",
+			want:  "",
+		},
+		{
+			name:  "hash episode",
+			input: "Episode #12",
+			want:  "",
+		},
+		{
+			name:  "word episode",
+			input: "Episode One",
+			want:  "",
+		},
+		{
+			name:  "tba",
+			input: "TBA",
+			want:  "",
+		},
+		{
+			name:  "tbd",
+			input: "TBD",
+			want:  "",
+		},
+		{
+			name:  "tbc",
+			input: "TBC",
+			want:  "",
+		},
+		{
+			name:  "tdc",
+			input: "TDC",
+			want:  "",
+		},
+		{
+			name:  "real title containing episode",
+			input: "The Episode Problem",
+			want:  "The Episode Problem",
+		},
 	}
 
 	for _, tt := range tests {
@@ -2481,7 +2734,7 @@ func TestResolveExternalIDsTVDBNoEnglishRefetch(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Arknights.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		SeasonInt:         1,
@@ -2491,7 +2744,7 @@ func TestResolveExternalIDsTVDBNoEnglishRefetch(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
@@ -2502,10 +2755,10 @@ func TestResolveExternalIDsTVDBNoEnglishRefetch(t *testing.T) {
 	if containsString(tvdbClient.episodeLangCalls, "eng") {
 		t.Fatalf("expected no eng episode refetch, calls=%v", tvdbClient.episodeLangCalls)
 	}
-	if result.ExternalMetadata.TVDB == nil {
+	if result.ProviderMetadata.TVDB == nil {
 		t.Fatalf("expected tvdb metadata")
 	}
-	if !result.ExternalMetadata.TVDB.HasEnglish {
+	if !result.ProviderMetadata.TVDB.HasEnglish {
 		t.Fatalf("expected HasEnglish true when english fields are populated")
 	}
 }
@@ -2533,7 +2786,7 @@ func TestResolveExternalIDsTVDBSlugYearNotUsedForNamingYear(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Cats.Eye.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -2541,18 +2794,18 @@ func TestResolveExternalIDsTVDBSlugYearNotUsedForNamingYear(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalMetadata.TVDB == nil {
+	if result.ProviderMetadata.TVDB == nil {
 		t.Fatalf("expected tvdb metadata")
 	}
-	if result.ExternalMetadata.TVDB.Year != 2010 {
-		t.Fatalf("expected first-aired tvdb year 2010, got %d", result.ExternalMetadata.TVDB.Year)
+	if result.ProviderMetadata.TVDB.Year != 2010 {
+		t.Fatalf("expected first-aired tvdb year 2010, got %d", result.ProviderMetadata.TVDB.Year)
 	}
-	if result.ExternalMetadata.TVDB.YearFromAlias {
+	if result.ProviderMetadata.TVDB.YearFromAlias {
 		t.Fatalf("expected slug-derived year not to mark YearFromAlias")
 	}
 }
@@ -2708,7 +2961,7 @@ func TestResolveExternalIDsTVDBExplicitSeriesYearUsedForNamingYear(t *testing.T)
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Cats.Eye.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -2716,22 +2969,22 @@ func TestResolveExternalIDsTVDBExplicitSeriesYearUsedForNamingYear(t *testing.T)
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalMetadata.TVDB == nil {
+	if result.ProviderMetadata.TVDB == nil {
 		t.Fatalf("expected tvdb metadata")
 	}
-	if result.ExternalMetadata.TVDB.Year != 2025 {
-		t.Fatalf("expected explicit tvdb series year 2025, got %d", result.ExternalMetadata.TVDB.Year)
+	if result.ProviderMetadata.TVDB.Year != 2025 {
+		t.Fatalf("expected explicit tvdb series year 2025, got %d", result.ProviderMetadata.TVDB.Year)
 	}
-	if !result.ExternalMetadata.TVDB.YearFromAlias {
+	if !result.ProviderMetadata.TVDB.YearFromAlias {
 		t.Fatalf("expected explicit series year to mark YearFromAlias")
 	}
-	if result.ExternalMetadata.TVDB.YearSource != "translation_alias" {
-		t.Fatalf("expected translation alias year source, got %q", result.ExternalMetadata.TVDB.YearSource)
+	if result.ProviderMetadata.TVDB.YearSource != "translation_alias" {
+		t.Fatalf("expected translation alias year source, got %q", result.ProviderMetadata.TVDB.YearSource)
 	}
 }
 
@@ -2754,7 +3007,7 @@ func TestResolveExternalIDsAppliesMALOverride(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.Anime.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		ExternalIDOverrides: api.ExternalIDOverrides{
@@ -2763,15 +3016,15 @@ func TestResolveExternalIDsAppliesMALOverride(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 	if result.MALID != 999 {
 		t.Fatalf("expected mal override 999, got %d", result.MALID)
 	}
-	if result.ExternalIDs.MALID != 999 || result.ExternalIDs.SourceMAL != "override" {
-		t.Fatalf("expected canonical mal override, got %#v", result.ExternalIDs)
+	if result.Identity.MALID != 999 || result.Identity.Provenance.MAL != api.IdentityProvenanceExplicit || result.Identity.Overrides.MAL != api.OverrideStateValue {
+		t.Fatalf("expected canonical mal override, got %#v", result.Identity)
 	}
 }
 
@@ -2791,7 +3044,7 @@ func TestResolveExternalIDsMALPrecedence(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "/media/Example.Anime.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		TrackerData:       []api.TrackerMetadata{{MALID: 111}},
@@ -2804,8 +3057,8 @@ func TestResolveExternalIDsMALPrecedence(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
-	if result.ExternalIDs.MALID != 111 || result.ExternalIDs.SourceMAL != "tracker" {
-		t.Fatalf("expected tracker mal precedence, got %#v", result.ExternalIDs)
+	if result.Identity.MALID != 111 || result.Identity.Provenance.MAL != "tracker" {
+		t.Fatalf("expected tracker mal precedence, got %#v", result.Identity)
 	}
 	if result.MALID != 111 {
 		t.Fatalf("expected prepared mal mirror 111, got %d", result.MALID)
@@ -2815,7 +3068,7 @@ func TestResolveExternalIDsMALPrecedence(t *testing.T) {
 func TestResolveExternalIDsPreservesStoredAniListForSameMALID(t *testing.T) {
 	sourcePath := "/media/Example.Anime.S01E01.mkv"
 	repo := &fakeRepo{
-		meta: api.ExternalMetadata{
+		meta: api.SourceScopedMetadata{
 			SourcePath: sourcePath,
 			AniList: &api.AniListMetadata{
 				AniListID:   100,
@@ -2832,7 +3085,7 @@ func TestResolveExternalIDsPreservesStoredAniListForSameMALID(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		MALID:      200,
 	})
@@ -2842,8 +3095,8 @@ func TestResolveExternalIDsPreservesStoredAniListForSameMALID(t *testing.T) {
 	if tmdbClient.anilistCalls != 0 {
 		t.Fatalf("expected stored anilist reuse without fetch, got %d calls", tmdbClient.anilistCalls)
 	}
-	if result.ExternalMetadata.AniList == nil || result.ExternalMetadata.AniList.TitleRomaji != "Stored Anime" {
-		t.Fatalf("expected stored anilist metadata preserved, got %#v", result.ExternalMetadata.AniList)
+	if result.ProviderMetadata.AniList == nil || result.ProviderMetadata.AniList.TitleRomaji != "Stored Anime" {
+		t.Fatalf("expected stored anilist metadata preserved, got %#v", result.ProviderMetadata.AniList)
 	}
 	if repo.meta.AniList == nil || repo.meta.AniList.MALID != 200 {
 		t.Fatalf("expected persisted anilist metadata preserved, got %#v", repo.meta.AniList)
@@ -2854,7 +3107,7 @@ func TestResolveExternalIDsRefetchesAniListWhenMALIDChanges(t *testing.T) {
 	sourcePath := "/media/Example.Anime.S01E02.mkv"
 	staleUpdatedAt := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
 	repo := &fakeRepo{
-		meta: api.ExternalMetadata{
+		meta: api.SourceScopedMetadata{
 			SourcePath: sourcePath,
 			AniList: &api.AniListMetadata{
 				AniListID:   100,
@@ -2878,7 +3131,7 @@ func TestResolveExternalIDsRefetchesAniListWhenMALIDChanges(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		MALID:      400,
 	})
@@ -2888,27 +3141,24 @@ func TestResolveExternalIDsRefetchesAniListWhenMALIDChanges(t *testing.T) {
 	if tmdbClient.anilistCalls != 1 || len(tmdbClient.anilistInputs) != 1 || tmdbClient.anilistInputs[0] != 400 {
 		t.Fatalf("expected one anilist refetch for MAL 400, got calls=%d inputs=%v", tmdbClient.anilistCalls, tmdbClient.anilistInputs)
 	}
-	if result.ExternalMetadata.AniList == nil || result.ExternalMetadata.AniList.MALID != 400 || result.ExternalMetadata.AniList.TitleRomaji != "Current Anime" {
-		t.Fatalf("expected current anilist metadata, got %#v", result.ExternalMetadata.AniList)
-	}
-	if repo.meta.AniList == nil || repo.meta.AniList.MALID != 400 {
-		t.Fatalf("expected persisted current anilist metadata, got %#v", repo.meta.AniList)
+	if result.ProviderMetadata.AniList == nil || result.ProviderMetadata.AniList.MALID != 400 || result.ProviderMetadata.AniList.TitleRomaji != "Current Anime" {
+		t.Fatalf("expected current anilist metadata, got %#v", result.ProviderMetadata.AniList)
 	}
-	if !result.ExternalMetadata.UpdatedAt.After(staleUpdatedAt) {
-		t.Fatalf("expected metadata timestamp refreshed after anilist side effect, got %s", result.ExternalMetadata.UpdatedAt)
+	if repo.externalMetaSaves != 0 {
+		t.Fatal("provider candidate must not publish current AniList metadata")
 	}
-	if !result.ExternalMetadata.UpdatedAt.Equal(result.ExternalIDs.UpdatedAt) {
-		t.Fatalf("expected metadata and id timestamps to match, got metadata=%s ids=%s", result.ExternalMetadata.UpdatedAt, result.ExternalIDs.UpdatedAt)
+	if !result.ProviderMetadata.UpdatedAt.After(staleUpdatedAt) {
+		t.Fatalf("expected metadata timestamp refreshed after anilist side effect, got %s", result.ProviderMetadata.UpdatedAt)
 	}
-	if !repo.meta.UpdatedAt.Equal(result.ExternalMetadata.UpdatedAt) {
-		t.Fatalf("expected persisted metadata timestamp to match result, got persisted=%s result=%s", repo.meta.UpdatedAt, result.ExternalMetadata.UpdatedAt)
+	if !result.ProviderMetadata.UpdatedAt.Equal(result.Identity.ResolvedAt) {
+		t.Fatalf("expected metadata and id timestamps to match, got metadata=%s ids=%s", result.ProviderMetadata.UpdatedAt, result.Identity.ResolvedAt)
 	}
 }
 
 func TestResolveExternalIDsClearsStaleAniListWhenChangedMALIDHasNoResult(t *testing.T) {
 	sourcePath := "/media/Example.Anime.S01E03.mkv"
 	repo := &fakeRepo{
-		meta: api.ExternalMetadata{
+		meta: api.SourceScopedMetadata{
 			SourcePath: sourcePath,
 			AniList: &api.AniListMetadata{
 				AniListID:   100,
@@ -2925,7 +3175,7 @@ func TestResolveExternalIDsClearsStaleAniListWhenChangedMALIDHasNoResult(t *test
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		MALID:      400,
 	})
@@ -2935,14 +3185,11 @@ func TestResolveExternalIDsClearsStaleAniListWhenChangedMALIDHasNoResult(t *test
 	if tmdbClient.anilistCalls != 1 || len(tmdbClient.anilistInputs) != 1 || tmdbClient.anilistInputs[0] != 400 {
 		t.Fatalf("expected one anilist refetch for MAL 400, got calls=%d inputs=%v", tmdbClient.anilistCalls, tmdbClient.anilistInputs)
 	}
-	if result.ExternalMetadata.AniList != nil {
-		t.Fatalf("expected stale anilist metadata cleared from result, got %#v", result.ExternalMetadata.AniList)
-	}
-	if repo.meta.SourcePath != sourcePath {
-		t.Fatalf("expected metadata row rewritten for source path, got %q", repo.meta.SourcePath)
+	if result.ProviderMetadata.AniList != nil {
+		t.Fatalf("expected stale anilist metadata cleared from result, got %#v", result.ProviderMetadata.AniList)
 	}
-	if repo.meta.AniList != nil {
-		t.Fatalf("expected stale anilist metadata cleared from persistence, got %#v", repo.meta.AniList)
+	if repo.meta.AniList == nil || repo.meta.AniList.MALID != 200 || repo.externalMetaSaves != 0 {
+		t.Fatal("provider candidate must leave stored AniList metadata unchanged")
 	}
 }
 
@@ -2957,7 +3204,7 @@ func TestResolveExternalIDsAniListFetchErrorDoesNotPersistEmptyMetadata(t *testi
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		MALID:      400,
 	})
@@ -2967,11 +3214,11 @@ func TestResolveExternalIDsAniListFetchErrorDoesNotPersistEmptyMetadata(t *testi
 	if tmdbClient.anilistCalls != 1 || len(tmdbClient.anilistInputs) != 1 || tmdbClient.anilistInputs[0] != 400 {
 		t.Fatalf("expected one anilist fetch for MAL 400, got calls=%d inputs=%v", tmdbClient.anilistCalls, tmdbClient.anilistInputs)
 	}
-	if result.ExternalIDs.MALID != 400 || result.ExternalIDs.SourceMAL != "prepared" {
-		t.Fatalf("expected MAL ID retained after anilist fetch error, got %#v", result.ExternalIDs)
+	if result.Identity.MALID != 400 || result.Identity.Provenance.MAL != api.IdentityProvenanceProvider {
+		t.Fatalf("expected MAL ID retained after anilist fetch error, got %#v", result.Identity)
 	}
-	if result.ExternalMetadata.AniList != nil {
-		t.Fatalf("expected no empty anilist metadata after fetch error, got %#v", result.ExternalMetadata.AniList)
+	if result.ProviderMetadata.AniList != nil {
+		t.Fatalf("expected no empty anilist metadata after fetch error, got %#v", result.ProviderMetadata.AniList)
 	}
 	if repo.externalMetaSaves != 0 {
 		t.Fatalf("expected no empty external metadata persistence after anilist fetch error, got %d saves", repo.externalMetaSaves)
@@ -2982,13 +3229,17 @@ func TestResolveExternalIDsMALFallbacksAndClear(t *testing.T) {
 	tmdbID := 101
 	clearMAL := 0
 	svc := NewService(&fakeRepo{},
-		WithTMDBClient(&stubTMDB{metadata: tmdb.MetadataResult{TMDBType: "tv", MALID: 444, Anime: true}}),
+		WithTMDBClient(&stubTMDB{metadata: tmdb.MetadataResult{
+			TMDBType: "tv",
+			MALID:    444,
+			Anime:    true,
+		}}),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "/media/Example.Anime.S01E02.mkv",
 		MediaInfoCategory: "TV",
 		SceneMALID:        222,
@@ -3000,11 +3251,11 @@ func TestResolveExternalIDsMALFallbacksAndClear(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolve scene: %v", err)
 	}
-	if result.ExternalIDs.MALID != 222 || result.ExternalIDs.SourceMAL != "scene" {
-		t.Fatalf("expected scene mal fallback, got %#v", result.ExternalIDs)
+	if result.Identity.MALID != 222 || result.Identity.Provenance.MAL != "scene" {
+		t.Fatalf("expected scene mal fallback, got %#v", result.Identity)
 	}
 
-	cleared, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
+	cleared, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
 		SourcePath:        "/media/Example.Anime.S01E03.mkv",
 		MediaInfoCategory: "TV",
 		TrackerData:       []api.TrackerMetadata{{MALID: 111}},
@@ -3018,8 +3269,8 @@ func TestResolveExternalIDsMALFallbacksAndClear(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolve clear: %v", err)
 	}
-	if cleared.ExternalIDs.MALID != 0 || cleared.ExternalIDs.SourceMAL != "override_clear" {
-		t.Fatalf("expected cleared mal lock, got %#v", cleared.ExternalIDs)
+	if cleared.Identity.MALID != 0 || cleared.Identity.Provenance.MAL != api.IdentityProvenanceExplicit || cleared.Identity.Overrides.MAL != api.OverrideStateClear {
+		t.Fatalf("expected cleared mal lock, got %#v", cleared.Identity)
 	}
 	if cleared.MALID != 0 {
 		t.Fatalf("expected prepared mal mirror cleared, got %d", cleared.MALID)
@@ -3046,7 +3297,7 @@ func TestResolveExternalIDsAppliesOriginalLanguageOverride(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:        "/media/Example.Show.S01E01.mkv",
 		MediaInfoCategory: "TV",
 		MetadataOverrides: api.MetadataOverrides{
@@ -3058,7 +3309,7 @@ func TestResolveExternalIDsAppliesOriginalLanguageOverride(t *testing.T) {
 		},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
@@ -3068,11 +3319,11 @@ func TestResolveExternalIDsAppliesOriginalLanguageOverride(t *testing.T) {
 	if imdbClient.lastManualLanguage != "ja" {
 		t.Fatalf("expected imdb manual language ja, got %q", imdbClient.lastManualLanguage)
 	}
-	if result.ExternalMetadata.TMDB == nil || result.ExternalMetadata.TMDB.OriginalLanguage != "ja" {
-		t.Fatalf("expected tmdb original language override, got %#v", result.ExternalMetadata.TMDB)
+	if result.ProviderMetadata.TMDB == nil || result.ProviderMetadata.TMDB.OriginalLanguage != "ja" {
+		t.Fatalf("expected tmdb original language override, got %#v", result.ProviderMetadata.TMDB)
 	}
-	if result.ExternalMetadata.IMDB == nil || result.ExternalMetadata.IMDB.OriginalLanguage != "ja" {
-		t.Fatalf("expected imdb original language override, got %#v", result.ExternalMetadata.IMDB)
+	if result.ProviderMetadata.IMDB == nil || result.ProviderMetadata.IMDB.OriginalLanguage != "ja" {
+		t.Fatalf("expected imdb original language override, got %#v", result.ProviderMetadata.IMDB)
 	}
 }
 
@@ -3096,6 +3347,7 @@ func TestResolveExternalIDsLocalizedFetchSucceedsWhenTMDBMetadataIsNil(t *testin
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
@@ -3103,24 +3355,24 @@ func TestResolveExternalIDsLocalizedFetchSucceedsWhenTMDBMetadataIsNil(t *testin
 	)
 
 	// Make sure BJS/BT/ASC is in Trackers list so needsPTBR is true
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/file.mkv",
-		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
-		Trackers:   []string{"BJS"},
+	meta := preparationstate.State{
+		SourcePath:       "/media/file.mkv",
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		EvidenceTrackers: []string{"BJS"},
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), meta)
+	result, err := svc.resolveExternalIdentity(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	if result.ExternalMetadata.TMDB == nil {
+	if result.ProviderMetadata.TMDB == nil {
 		t.Fatalf("expected TMDB metadata to be initialized with localized info")
 	}
-	if result.ExternalMetadata.TMDB.Localized == nil {
+	if result.ProviderMetadata.TMDB.Localized == nil {
 		t.Fatalf("expected Localized map to be populated")
 	}
-	ptBR, ok := result.ExternalMetadata.TMDB.Localized["pt-BR"]
+	ptBR, ok := result.ProviderMetadata.TMDB.Localized["pt-BR"]
 	if !ok || ptBR.Title != "Título Localizado" {
 		t.Fatalf("expected localized title, got %#v", ptBR)
 	}
@@ -3139,22 +3391,23 @@ func TestResolveExternalIDsSkipsIncompleteLocalizedPTBR(t *testing.T) {
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath: "/media/file.mkv",
-		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
-		Trackers:   []string{"BJS"},
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/file.mkv",
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		EvidenceTrackers: []string{"BJS"},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
-	if result.ExternalMetadata.TMDB != nil && result.ExternalMetadata.TMDB.Localized != nil {
-		if got, ok := result.ExternalMetadata.TMDB.Localized["pt-BR"]; ok {
+	if result.ProviderMetadata.TMDB != nil && result.ProviderMetadata.TMDB.Localized != nil {
+		if got, ok := result.ProviderMetadata.TMDB.Localized["pt-BR"]; ok {
 			t.Fatalf("expected incomplete localized data to stay unstored, got %#v", got)
 		}
 	}
@@ -3178,24 +3431,25 @@ func TestResolveExternalIDsStoresEpisodeOverviewWithoutEpisodeTitle(t *testing.T
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath: "/media/show.s01e02.mkv",
-		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
-		SeasonInt:  1,
-		EpisodeInt: 2,
-		Trackers:   []string{"BJS"},
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/show.s01e02.mkv",
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		SeasonInt:        1,
+		EpisodeInt:       2,
+		EvidenceTrackers: []string{"BJS"},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 
-	got := result.ExternalMetadata.TMDB.Localized["pt-BR"]
+	got := result.ProviderMetadata.TMDB.Localized["pt-BR"]
 	if got.Title != "Serie localizada" || got.EpisodeOverview != "Resumo do episodio" {
 		t.Fatalf("expected localized episode overview to be stored, got %#v", got)
 	}
@@ -3217,24 +3471,25 @@ func TestResolveExternalIDsSkipsEpisodeLocalizedPTBRWithoutScopedOverview(t *tes
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath: "/media/show.s01e02.mkv",
-		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
-		SeasonInt:  1,
-		EpisodeInt: 2,
-		Trackers:   []string{"BJS"},
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/show.s01e02.mkv",
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		SeasonInt:        1,
+		EpisodeInt:       2,
+		EvidenceTrackers: []string{"BJS"},
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
-	if result.ExternalMetadata.TMDB != nil && result.ExternalMetadata.TMDB.Localized != nil {
-		if got, ok := result.ExternalMetadata.TMDB.Localized["pt-BR"]; ok {
+	if result.ProviderMetadata.TMDB != nil && result.ProviderMetadata.TMDB.Localized != nil {
+		if got, ok := result.ProviderMetadata.TMDB.Localized["pt-BR"]; ok {
 			t.Fatalf("expected episode localized data without scoped overview to stay unstored, got %#v", got)
 		}
 	}
@@ -3250,6 +3505,7 @@ func TestResolveExternalIDsMergesLocalizedPTBRWithoutBlankOverwrite(t *testing.T
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
@@ -3261,17 +3517,17 @@ func TestResolveExternalIDsMergesLocalizedPTBRWithoutBlankOverwrite(t *testing.T
 		Genres:   "Drama",
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath:      "/media/file.mkv",
-		StoredDataFresh: true,
-		Release:         api.ReleaseInfo{Title: "Example", Year: 2024},
-		Trackers:        []string{"BJS"},
-		ExternalIDs: api.ExternalIDs{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/file.mkv",
+		StoredDataFresh:  true,
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		EvidenceTrackers: []string{"BJS"},
+		Identity: api.ExternalIdentity{
 			SourcePath: "/media/file.mkv",
 			TMDBID:     42,
 			Category:   "MOVIE",
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "/media/file.mkv",
 			TMDB: &api.TMDBMetadata{
 				TMDBID: 42,
@@ -3284,7 +3540,7 @@ func TestResolveExternalIDsMergesLocalizedPTBRWithoutBlankOverwrite(t *testing.T
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
-	got := result.ExternalMetadata.TMDB.Localized["pt-BR"]
+	got := result.ProviderMetadata.TMDB.Localized["pt-BR"]
 	if got.Title != "Titulo novo" {
 		t.Fatalf("expected new title merged, got %#v", got)
 	}
@@ -3309,6 +3565,7 @@ func TestResolveExternalIDsPreservesExistingLocalizedPTBRWhenEpisodeFetchFails(t
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
 		WithTVDBClient(&stubTVDB{}),
@@ -3321,19 +3578,19 @@ func TestResolveExternalIDsPreservesExistingLocalizedPTBRWhenEpisodeFetchFails(t
 		Genres:          "Acao",
 	}
 
-	result, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath:      "/media/show.s01e02.mkv",
-		StoredDataFresh: true,
-		Release:         api.ReleaseInfo{Title: "Example", Year: 2024},
-		SeasonInt:       1,
-		EpisodeInt:      2,
-		Trackers:        []string{"BJS"},
-		ExternalIDs: api.ExternalIDs{
+	result, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/show.s01e02.mkv",
+		StoredDataFresh:  true,
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		SeasonInt:        1,
+		EpisodeInt:       2,
+		EvidenceTrackers: []string{"BJS"},
+		Identity: api.ExternalIdentity{
 			SourcePath: "/media/show.s01e02.mkv",
 			TMDBID:     42,
 			Category:   "TV",
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "/media/show.s01e02.mkv",
 			TMDB: &api.TMDBMetadata{
 				TMDBID: 42,
@@ -3349,7 +3606,7 @@ func TestResolveExternalIDsPreservesExistingLocalizedPTBRWhenEpisodeFetchFails(t
 	if len(tmdbClient.localizedInputs) != 3 {
 		t.Fatalf("expected main, season, episode localized fetch attempts, got %#v", tmdbClient.localizedInputs)
 	}
-	got := result.ExternalMetadata.TMDB.Localized["pt-BR"]
+	got := result.ProviderMetadata.TMDB.Localized["pt-BR"]
 	if got.Title != "Serie nova" || got.Genres != "Drama" {
 		t.Fatalf("expected nonblank main localized fields to merge, got %#v", got)
 	}
@@ -3370,6 +3627,7 @@ func TestResolveExternalIDsLocalizedFetchUsesVariantCachePaths(t *testing.T) {
 		},
 	}
 	svc := NewService(repo,
+		WithTrackerRegistry(localizedMetadataTestRegistry(t)),
 		WithConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
 		WithTMDBClient(tmdbClient),
 		WithIMDBClient(&stubIMDB{}),
@@ -3377,12 +3635,12 @@ func TestResolveExternalIDsLocalizedFetchUsesVariantCachePaths(t *testing.T) {
 		WithTVmazeClient(&stubTVmaze{}),
 	)
 
-	_, err := svc.ResolveExternalIDs(context.Background(), api.PreparedMetadata{
-		SourcePath: "/media/show.mkv",
-		Release:    api.ReleaseInfo{Title: "Example", Year: 2024},
-		Trackers:   []string{"ASC"},
-		SeasonInt:  1,
-		EpisodeInt: 2,
+	_, err := svc.resolveExternalIdentity(context.Background(), preparationstate.State{
+		SourcePath:       "/media/show.mkv",
+		Release:          api.ReleaseInfo{Title: "Example", Year: 2024},
+		EvidenceTrackers: []string{"BJS"},
+		SeasonInt:        1,
+		EpisodeInt:       2,
 	})
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
diff --git a/internal/metadata/imdb/client.go b/internal/metadata/imdb/client.go
index 19fcd5d9..6edc316c 100644
--- a/internal/metadata/imdb/client.go
+++ b/internal/metadata/imdb/client.go
@@ -25,12 +25,16 @@ import (
 
 const defaultBaseURL = "https://api.graphql.imdb.com/"
 
+// Client queries IMDb's public GraphQL endpoint for title, search, and episode
+// metadata.
 type Client struct {
 	baseURL string
 	http    *http.Client
 	logger  api.Logger
 }
 
+// NewClient substitutes a 15-second HTTP client and no-op logger for nil
+// dependencies.
 func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	if httpClient == nil {
 		httpClient = &http.Client{Timeout: 15 * time.Second}
@@ -38,9 +42,17 @@ func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
-	return &Client{baseURL: defaultBaseURL, http: httpClient, logger: logger}
+	return &Client{
+		baseURL: defaultBaseURL,
+		http:    httpClient,
+		logger:  logger,
+	}
 }
 
+// GetInfo returns normalized title metadata for imdbID. Empty or zero IDs and
+// missing titles return an empty result without error; request or decode failures
+// return no partial result. Missing runtime and plot values default to 60 minutes
+// and "No plot available", and episode data is limited to the first 500 entries.
 func (c *Client) GetInfo(ctx context.Context, imdbID string, manualLanguage string, debug bool) (Info, error) {
 	info := Info{}
 	id := metautil.NormalizeIMDbID(imdbID)
@@ -48,7 +60,10 @@ func (c *Client) GetInfo(ctx context.Context, imdbID string, manualLanguage stri
 		return info, nil
 	}
 
-	query := fmt.Sprintf(`query GetTitleInfo { title(id: "%s") { id titleText { text isOriginalTitle country { text } } originalTitleText { text } releaseYear { year endYear } titleType { id } plot { plotText { plainText } } ratingsSummary { aggregateRating voteCount } primaryImage { url } runtime { displayableProperty { value { plainText } } seconds } titleGenres { genres { genre { text } } } principalCredits { category { text id } credits { name { id nameText { text } } } } episodes { episodes(first: 500) { edges { node { id series { displayableEpisodeNumber { displayableSeason { season } episodeNumber { text } } } titleText { text } releaseYear { year } releaseDate { year month day } } } pageInfo { hasNextPage hasPreviousPage } total } } runtimes(first: 10) { edges { node { id seconds displayableProperty { value { plainText } } attributes { text } } } } technicalSpecifications { soundMixes { items { text attributes { text } } } } akas(first: 100) { edges { node { text country { text } language { text } attributes { text } } } } countriesOfOrigin { countries { text } } } }`, escapeGraphQLString(id))
+	query := fmt.Sprintf(
+		`query GetTitleInfo { title(id: "%s") { id titleText { text isOriginalTitle country { text } } originalTitleText { text } releaseYear { year endYear } titleType { id } plot { plotText { plainText } } ratingsSummary { aggregateRating voteCount } primaryImage { url } runtime { displayableProperty { value { plainText } } seconds } titleGenres { genres { genre { text } } } principalCredits { category { text id } credits { name { id nameText { text } } } } episodes { episodes(first: 500) { edges { node { id series { displayableEpisodeNumber { displayableSeason { season } episodeNumber { text } } } titleText { text } releaseYear { year } releaseDate { year month day } } } pageInfo { hasNextPage hasPreviousPage } total } } runtimes(first: 10) { edges { node { id seconds displayableProperty { value { plainText } } attributes { text } } } } technicalSpecifications { soundMixes { items { text attributes { text } } } } akas(first: 100) { edges { node { text country { text } language { text } attributes { text } } } } countriesOfOrigin { countries { text } } } }`,
+		escapeGraphQLString(id),
+	)
 
 	var response map[string]any
 	if err := c.postGraphQL(ctx, query, &response); err != nil {
@@ -271,6 +286,11 @@ func (c *Client) GetInfo(ctx context.Context, imdbID string, manualLanguage stri
 	return info, nil
 }
 
+// Search tries increasingly broad title variants in order, pausing one second
+// between remote attempts. Individual request failures are treated as no results.
+// A single result or a sufficiently separated similarity winner is selected;
+// Unattended selects the top ambiguous candidate, while interactive mode returns
+// candidates with a zero IMDbID. Quickie validates only the first result.
 func (c *Client) Search(ctx context.Context, input SearchInput) (SearchResult, error) {
 	results := []map[string]any{}
 	imdbID := 0
@@ -381,14 +401,22 @@ func (c *Client) Search(ctx context.Context, input SearchInput) (SearchResult, e
 				if c.logger != nil {
 					c.logger.Infof("imdb: search auto-selected id=%d similarity=%.2f", best.IMDbID, best.Similarity)
 				}
-				return SearchResult{IMDbID: best.IMDbID, Candidates: candidates, AutoSelected: true}, nil
+				return SearchResult{
+					IMDbID:       best.IMDbID,
+					Candidates:   candidates,
+					AutoSelected: true,
+				}, nil
 			}
 		}
 		if input.Unattended {
 			if c.logger != nil {
 				c.logger.Infof("imdb: search unattended auto-selected id=%d similarity=%.2f", best.IMDbID, best.Similarity)
 			}
-			return SearchResult{IMDbID: best.IMDbID, Candidates: candidates, AutoSelected: true}, nil
+			return SearchResult{
+				IMDbID:       best.IMDbID,
+				Candidates:   candidates,
+				AutoSelected: true,
+			}, nil
 		}
 		return SearchResult{IMDbID: 0, Candidates: candidates}, nil
 	}
@@ -436,13 +464,19 @@ func applyReleaseHints(input SearchInput) SearchInput {
 	return input
 }
 
+// GetEpisodeInfo returns episode numbering, parent-series identity, and adjacent
+// episode references. Empty IDs and missing titles return an empty result without
+// error; request and decode failures return no partial result.
 func (c *Client) GetEpisodeInfo(ctx context.Context, imdbID string, debug bool) (EpisodeLookup, error) {
 	id := metautil.NormalizeIMDbID(imdbID)
 	if id == "" {
 		return EpisodeLookup{}, nil
 	}
 
-	query := fmt.Sprintf(`query { title(id: "%s") { id titleText { text } series { displayableEpisodeNumber { displayableSeason { id season text } episodeNumber { id text } } nextEpisode { id titleText { text } } previousEpisode { id titleText { text } } series { id titleText { text } } } } }`, escapeGraphQLString(id))
+	query := fmt.Sprintf(
+		`query { title(id: "%s") { id titleText { text } series { displayableEpisodeNumber { displayableSeason { id season text } episodeNumber { id text } } nextEpisode { id titleText { text } } previousEpisode { id titleText { text } } series { id titleText { text } } } } }`,
+		escapeGraphQLString(id),
+	)
 	var response map[string]any
 	if err := c.postGraphQL(ctx, query, &response); err != nil {
 		return EpisodeLookup{}, err
@@ -488,7 +522,13 @@ func (c *Client) GetEpisodeInfo(ctx context.Context, imdbID string, debug bool)
 		c.logger.Debugf("imdb: episode lookup loaded for %s", id)
 	}
 	if c.logger != nil {
-		c.logger.Tracef("imdb: episode lookup loaded id=%s series=%q season=%s episode=%s", id, lookup.Series.SeriesTitle, lookup.Series.SeasonText, lookup.Series.EpisodeText)
+		c.logger.Tracef(
+			"imdb: episode lookup loaded id=%s series=%q season=%s episode=%s",
+			id,
+			lookup.Series.SeriesTitle,
+			lookup.Series.SeasonText,
+			lookup.Series.EpisodeText,
+		)
 	}
 
 	return lookup, nil
@@ -515,7 +555,10 @@ func (c *Client) runSearch(ctx context.Context, filename string, searchYear int,
 	}
 	constraintsString := strings.Join(constraints, ", ")
 
-	query := fmt.Sprintf(`{ advancedTitleSearch(first: 10, constraints: {%s}) { total edges { node { title { id titleText { text } titleType { text } releaseYear { year } plot { plotText { plainText } } } } } } }`, constraintsString)
+	query := fmt.Sprintf(
+		`{ advancedTitleSearch(first: 10, constraints: {%s}) { total edges { node { title { id titleText { text } titleType { text } releaseYear { year } plot { plotText { plainText } } } } } } }`,
+		constraintsString,
+	)
 	var response map[string]any
 	if err := c.postGraphQL(ctx, query, &response); err != nil {
 		return nil
@@ -598,7 +641,15 @@ func rankCandidates(results []map[string]any, filename string, searchYear int) [
 				similarity += 0.05
 			}
 		}
-		candidates = append(candidates, Candidate{IMDbID: imdbID, Title: text, Year: year, Type: getStringFromMap(title, "titleType", "text"), Plot: plot, PosterURL: posterURL, Similarity: similarity})
+		candidates = append(candidates, Candidate{
+			IMDbID:     imdbID,
+			Title:      text,
+			Year:       year,
+			Type:       getStringFromMap(title, "titleType", "text"),
+			Plot:       plot,
+			PosterURL:  posterURL,
+			Similarity: similarity,
+		})
 	}
 
 	sort.SliceStable(candidates, func(i, j int) bool {
diff --git a/internal/metadata/imdb/types.go b/internal/metadata/imdb/types.go
index 125c03be..dcdfaa3a 100644
--- a/internal/metadata/imdb/types.go
+++ b/internal/metadata/imdb/types.go
@@ -3,6 +3,8 @@
 
 package imdb
 
+// Info contains normalized IMDb title metadata. RuntimeMinutes is minutes;
+// edition detail map keys are decimal runtime-minute strings.
 type Info struct {
 	IMDbID           string
 	IMDbURL          string
@@ -75,6 +77,9 @@ type SeasonSummary struct {
 	YearRange string
 }
 
+// SearchInput controls release-hint parsing and automatic candidate selection.
+// Quickie examines only the first result; Unattended permits selection of an
+// otherwise ambiguous top-ranked candidate.
 type SearchInput struct {
 	Filename          string
 	SearchYear        int
@@ -88,6 +93,8 @@ type SearchInput struct {
 	Debug             bool
 }
 
+// SearchResult retains ranked candidates even when interactive ambiguity leaves
+// IMDbID unset. AutoSelected reports that no manual choice remains.
 type SearchResult struct {
 	IMDbID       int
 	Candidates   []Candidate
diff --git a/internal/metadata/media_details.go b/internal/metadata/media_details.go
index 087c623f..e8b92653 100644
--- a/internal/metadata/media_details.go
+++ b/internal/metadata/media_details.go
@@ -15,12 +15,13 @@ import (
 	"time"
 	"unicode"
 
-	"github.com/autobrr/upbrr/internal/config"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/languageutil"
 	"github.com/autobrr/upbrr/internal/metadata/discparse"
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/internal/trackers"
@@ -35,22 +36,22 @@ var durationTokenPattern = regexp.MustCompile(`(?i)(\d+(?:\.\d+)?)\s*(millisecon
 var numericPattern = regexp.MustCompile(`\d+`)
 var releaseTokenSeparatorPattern = regexp.MustCompile(`[^A-Z0-9]+`)
 
-// ApplyMediaDetails enriches prepared metadata from MediaInfo, BDInfo, filename
+// deriveMediaFacts enriches prepared evidence from MediaInfo, BDInfo, and filename
 // tokens, overrides, and tracker rules, then rebuilds the release name.
-func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+func (s *Service) deriveMediaFacts(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
 	miDoc, err := loadMediaInfoDoc(meta.MediaInfoJSONPath)
 	if err != nil {
-		return api.PreparedMetadata{}, err
+		return preparationstate.State{}, err
 	}
 
-	meta.MediaInfoUniqueID, meta.ValidMediaInfo = validateMediaInfoUniqueID(meta, miDoc)
-	if !meta.ValidMediaInfo && s.logger != nil {
+	meta.MediaInfoUniqueID, meta.MediaInfoUniqueIDPresent = validateMediaInfoUniqueID(meta, miDoc)
+	if !meta.MediaInfoUniqueIDPresent && s.logger != nil {
 		s.logger.Warnf("metadata: mediainfo validation failed (missing unique id)")
 	}
 	meta.AudioLanguages, meta.SubtitleLanguages = extractMediaInfoLanguages(miDoc)
@@ -101,7 +102,7 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 		dvdDetails.VOBMediaInfoRaw = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), strings.TrimSpace(meta.DVDVOBMediaInfoJSON))
 		dvdDetails.UpdatedAt = time.Now().UTC()
 		if err := s.repo.SaveDVDMediaInfo(ctx, dvdDetails); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: persist dvd mediainfo details: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: persist dvd mediainfo details: %w", err)
 		}
 	}
 	// For non-DVD content, if rls did not parse a resolution from the filename,
@@ -125,12 +126,15 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 		s.logger.Debugf("metadata: media details uhd=%q hdr=%q", meta.UHD, meta.HDR)
 	}
 
-	meta, err = s.applyBlurayMetadata(ctx, meta, bdinfo)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-	if s.logger != nil && meta.ExternalMetadata.Bluray != nil {
-		s.logger.Debugf("metadata: blu-ray.com candidates=%d selected=%q score=%.1f threshold=%.1f", len(meta.ExternalMetadata.Bluray.Candidates), meta.ExternalMetadata.Bluray.SelectedReleaseID, meta.ExternalMetadata.Bluray.BestScore, meta.ExternalMetadata.Bluray.Threshold)
+	meta = s.applyBlurayMetadata(ctx, meta, bdinfo)
+	if s.logger != nil && meta.ProviderMetadata.Bluray != nil {
+		s.logger.Debugf(
+			"metadata: blu-ray.com candidates=%d selected=%q score=%.1f threshold=%.1f",
+			len(meta.ProviderMetadata.Bluray.Candidates),
+			meta.ProviderMetadata.Bluray.SelectedReleaseID,
+			meta.ProviderMetadata.Bluray.BestScore,
+			meta.ProviderMetadata.Bluray.Threshold,
+		)
 	}
 
 	meta.Distributor = normalizeDistributor(meta.Distributor)
@@ -145,7 +149,13 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 		meta.VideoEncode, meta.VideoCodec, meta.HasEncodeSettings, meta.BitDepth = videoEncodeFromMedia(miDoc, meta.Type)
 	}
 	if s.logger != nil {
-		s.logger.Debugf("metadata: media details region=%q video_encode=%q video_codec=%q bit_depth=%q", meta.Region, meta.VideoEncode, meta.VideoCodec, meta.BitDepth)
+		s.logger.Debugf(
+			"metadata: media details region=%q video_encode=%q video_codec=%q bit_depth=%q",
+			meta.Region,
+			meta.VideoEncode,
+			meta.VideoCodec,
+			meta.BitDepth,
+		)
 	}
 
 	meta.Edition, meta.Repack = editionFromMeta(meta, miDoc)
@@ -154,10 +164,10 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 		s.logger.Debugf("metadata: media details edition=%q repack=%q webdv=%t", meta.Edition, meta.Repack, meta.WebDV)
 	}
 
-	meta.ValidMediaInfoSettings = true
+	meta.MediaInfoEncodeSettingsPresent = true
 	if !strings.EqualFold(meta.DiscType, "BDMV") && strings.EqualFold(meta.Type, "ENCODE") && !strings.EqualFold(meta.VideoCodec, "AV1") {
-		meta.ValidMediaInfoSettings = validateMediaInfoSettings(miDoc)
-		if !meta.ValidMediaInfoSettings && s.logger != nil {
+		meta.MediaInfoEncodeSettingsPresent = validateMediaInfoSettings(miDoc)
+		if !meta.MediaInfoEncodeSettingsPresent && s.logger != nil {
 			s.logger.Warnf("metadata: mediainfo validation failed (missing encode settings)")
 		}
 	}
@@ -184,7 +194,7 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 	}
 
 	applyMetadataOverrides(&meta)
-	ApplyRequestScopedAudioPolicy(&meta, s.cfg, s.logger)
+	meta.Audio = applyAudioLanguagePrefix(meta.Audio, meta)
 	RebuildReleaseName(&meta, s.logger)
 
 	// Scene detection runs here — after external IDs are resolved and the release
@@ -193,17 +203,12 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 	// rules (which read meta.Scene / meta.SceneNFOPath / meta.SceneRenamed).
 	meta, err = s.applySceneDetection(ctx, meta)
 	if err != nil {
-		return api.PreparedMetadata{}, err
+		return preparationstate.State{}, err
 	}
 	// Scene detection can supply the service (from the NFO), which WEB release
 	// names embed, so rebuild once more to fold in scene-derived metadata.
 	RebuildReleaseName(&meta, s.logger)
 
-	meta, err = s.applyTrackerRules(ctx, meta)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-
 	return meta, nil
 }
 
@@ -212,7 +217,7 @@ func (s *Service) ApplyMediaDetails(ctx context.Context, meta api.PreparedMetada
 // never block the upload), but context cancellation/deadline is propagated so the
 // pipeline aborts rather than continuing into tracker rules. Detection is gated
 // by config (scene_detection) via a nil detector.
-func (s *Service) applySceneDetection(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+func (s *Service) applySceneDetection(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	if s.scene == nil {
 		return meta, nil
 	}
@@ -241,8 +246,8 @@ func (s *Service) applySceneDetection(ctx context.Context, meta api.PreparedMeta
 	applySceneResult(&meta, result)
 	// Detection now runs after ID resolution, so backfill a scene-discovered IMDb
 	// id only when resolution found none, so upload payloads still carry it.
-	if meta.ExternalIDs.IMDBID == 0 && result.IMDBID > 0 {
-		meta.ExternalIDs.IMDBID = result.IMDBID
+	if meta.Identity.IMDBID == 0 && result.IMDBID > 0 {
+		meta.Identity.IMDBID = result.IMDBID
 	}
 	if s.logger != nil {
 		if meta.Scene {
@@ -259,64 +264,7 @@ func (s *Service) applySceneDetection(ctx context.Context, meta api.PreparedMeta
 	return meta, nil
 }
 
-// ApplyTrackerClaims refreshes claim-based tracker blocks after media details
-// and tracker rules have populated the release attributes used for matching.
-func (s *Service) ApplyTrackerClaims(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	return s.applyTrackerClaims(ctx, meta)
-}
-
-// RefreshPreparedMetadata reapplies request-scoped audio, naming, rule, and
-// claim state without rereading media files. HDR may be refreshed from the
-// current source path only when it still matches the parsed release HDR.
-func (s *Service) RefreshPreparedMetadata(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	if s == nil {
-		return meta, nil
-	}
-	refreshService := *s
-
-	meta.BlockedTrackers = removeTrackerBlockReason(meta.BlockedTrackers, api.TrackerBlockReasonAudio)
-	meta.BlockedTrackers = removeTrackerBlockReason(meta.BlockedTrackers, api.TrackerBlockReasonClaim)
-	meta.TrackerRuleFailures = removeTrackerRule(meta.TrackerRuleFailures, trackerClaimRuleActive)
-
-	if filenameHDR := filenameHDRFromMeta(meta); filenameHDR != "" && meta.HDR == normalizeFilenameHDRTokens(meta.Release.HDR) {
-		meta.HDR = filenameHDR
-	}
-	normalizeMediaInfoSettings(&meta)
-	ApplyRequestScopedAudioPolicy(&meta, refreshService.cfg, refreshService.logger)
-	RebuildReleaseName(&meta, refreshService.logger)
-
-	var err error
-	meta, err = refreshService.applyTrackerRules(ctx, meta)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-	meta, err = refreshService.applyTrackerClaims(ctx, meta)
-	if err != nil {
-		return api.PreparedMetadata{}, err
-	}
-	return meta, nil
-}
-
-// normalizeMediaInfoSettings re-asserts the ValidMediaInfoSettings invariant on
-// refresh paths that reuse cached or imported metadata without re-reading media.
-// The full media pass (PrepareMetadata) only ever sets this false for a non-BDMV,
-// non-AV1 encode that is missing encoding settings; for every other release kind
-// it is unconditionally true. Cached or imported metadata can carry a stale or
-// zero-value false here, which would wrongly trip the UNIT3D MediaInfo-settings
-// rule (see internal/trackers/rules.go) and block valid remux/web/disc uploads,
-// so restore true whenever the release cannot be a validatable encode.
-func normalizeMediaInfoSettings(meta *api.PreparedMetadata) {
-	if meta == nil || meta.ValidMediaInfoSettings {
-		return
-	}
-	if strings.EqualFold(meta.DiscType, "BDMV") ||
-		!strings.EqualFold(meta.Type, "ENCODE") ||
-		strings.EqualFold(meta.VideoCodec, "AV1") {
-		meta.ValidMediaInfoSettings = true
-	}
-}
-
-func applyMetadataOverrides(meta *api.PreparedMetadata) {
+func applyMetadataOverrides(meta *preparationstate.State) {
 	if meta == nil {
 		return
 	}
@@ -347,7 +295,7 @@ func applyMetadataOverrides(meta *api.PreparedMetadata) {
 	}
 }
 
-func applyOriginalLanguageOverride(meta *api.PreparedMetadata, language *string) {
+func applyOriginalLanguageOverride(meta *preparationstate.State, language *string) {
 	if meta == nil || language == nil {
 		return
 	}
@@ -356,21 +304,21 @@ func applyOriginalLanguageOverride(meta *api.PreparedMetadata, language *string)
 	if trimmed == "" {
 		return
 	}
-	if meta.ExternalMetadata.TMDB != nil {
-		meta.ExternalMetadata.TMDB.OriginalLanguage = trimmed
+	if meta.ProviderMetadata.TMDB != nil {
+		meta.ProviderMetadata.TMDB.OriginalLanguage = trimmed
 	}
-	if meta.ExternalMetadata.IMDB != nil {
-		meta.ExternalMetadata.IMDB.OriginalLanguage = trimmed
+	if meta.ProviderMetadata.IMDB != nil {
+		meta.ProviderMetadata.IMDB.OriginalLanguage = trimmed
 	}
-	if meta.ExternalMetadata.TVDB != nil {
-		meta.ExternalMetadata.TVDB.OriginalLanguage = trimmed
+	if meta.ProviderMetadata.TVDB != nil {
+		meta.ProviderMetadata.TVDB.OriginalLanguage = trimmed
 	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		meta.ExternalMetadata.TVmaze.Language = trimmed
+	if meta.ProviderMetadata.TVmaze != nil {
+		meta.ProviderMetadata.TVmaze.Language = trimmed
 	}
 }
 
-func loadBDInfo(meta api.PreparedMetadata, dbPath string) *discparse.BDInfo {
+func loadBDInfo(meta preparationstate.State, dbPath string) *discparse.BDInfo {
 	if !strings.EqualFold(meta.DiscType, "BDMV") && !strings.EqualFold(meta.DiscType, "DVD") {
 		return nil
 	}
@@ -397,7 +345,7 @@ func loadBDInfo(meta api.PreparedMetadata, dbPath string) *discparse.BDInfo {
 	return discparse.ParseBDInfoSummary(summary, files, meta.SourcePath)
 }
 
-func containerFromMeta(meta api.PreparedMetadata) string {
+func containerFromMeta(meta preparationstate.State) string {
 	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
 	case "BDMV":
 		return "m2ts"
@@ -431,7 +379,7 @@ func containerFromMeta(meta api.PreparedMetadata) string {
 // Atmos are emitted after the channel count to match release-name ordering.
 // MediaInfo title-derived markers such as Auro3D come from the selected
 // primary audio track.
-func audioFromMedia(meta api.PreparedMetadata, doc mediaInfoDoc, bdinfo *discparse.BDInfo) (string, string, bool) {
+func audioFromMedia(meta preparationstate.State, doc mediaInfoDoc, bdinfo *discparse.BDInfo) (string, string, bool) {
 	if bdinfo != nil && len(bdinfo.Audio) > 0 {
 		track := bdinfo.Audio[0]
 		codec := normalizeAudioFormat(map[string]any{
@@ -523,7 +471,7 @@ func audioTrackTitle(track map[string]any) string {
 	return trackString(track, "Title", "title", "Title_String", "Title_String2", "Title_String3")
 }
 
-func audioLanguagePrefix(meta api.PreparedMetadata, tracks []map[string]any) string {
+func audioLanguagePrefix(meta preparationstate.State, tracks []map[string]any) string {
 	filtered := make([]map[string]any, 0, len(tracks))
 	for _, track := range tracks {
 		if isCommentaryOrCompatibilityAudioValue(audioTrackTitle(track)) {
@@ -542,7 +490,7 @@ func audioLanguagePrefix(meta api.PreparedMetadata, tracks []map[string]any) str
 	return audioLanguagePrefixFromLanguages(meta, languages)
 }
 
-func audioLanguagePrefixFromLanguages(meta api.PreparedMetadata, languages []string) string {
+func audioLanguagePrefixFromLanguages(meta preparationstate.State, languages []string) string {
 	if len(languages) == 0 {
 		return ""
 	}
@@ -580,16 +528,16 @@ func audioLanguagePrefixFromLanguages(meta api.PreparedMetadata, languages []str
 	return ""
 }
 
-func originalAudioLanguage(meta api.PreparedMetadata) string {
+func originalAudioLanguage(meta preparationstate.State) string {
 	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage) != "":
-		return meta.ExternalMetadata.TMDB.OriginalLanguage
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage) != "":
-		return meta.ExternalMetadata.IMDB.OriginalLanguage
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.OriginalLanguage) != "":
-		return meta.ExternalMetadata.TVDB.OriginalLanguage
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Language) != "":
-		return meta.ExternalMetadata.TVmaze.Language
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage) != "":
+		return meta.ProviderMetadata.TMDB.OriginalLanguage
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage) != "":
+		return meta.ProviderMetadata.IMDB.OriginalLanguage
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.OriginalLanguage) != "":
+		return meta.ProviderMetadata.TVDB.OriginalLanguage
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Language) != "":
+		return meta.ProviderMetadata.TVmaze.Language
 	default:
 		return ""
 	}
@@ -627,22 +575,10 @@ func isCommentaryOrCompatibilityAudioValue(value string) bool {
 	return strings.Contains(lower, "commentary") || strings.Contains(lower, "compatibility")
 }
 
-// ApplyRequestScopedAudioPolicy updates audio labels and tracker audio blocks
-// for the request's active tracker set.
-func ApplyRequestScopedAudioPolicy(meta *api.PreparedMetadata, cfg config.Config, logger api.Logger) {
-	if meta == nil {
-		return
-	}
-
-	meta.Audio = applyAudioLanguagePrefix(meta.Audio, *meta)
-	meta.BlockedTrackers = removeTrackerBlockReason(meta.BlockedTrackers, api.TrackerBlockReasonAudio)
-	meta.TrackerRuleFailures = removeTrackerRule(meta.TrackerRuleFailures, "audio_bloat")
-	applyAudioBloatPolicy(meta, trackers.ResolveTrackersWithDefaults(cfg, meta.Trackers, meta.TrackersRemove, logger), logger)
-}
-
 // RebuildReleaseName regenerates the prepared release-name fields from the
-// current metadata and release-name overrides.
-func RebuildReleaseName(meta *api.PreparedMetadata, logger api.Logger) {
+// current metadata and release-name overrides. It is a no-op for nil input and
+// replaces all name variants and missing-field hints in place.
+func RebuildReleaseName(meta *preparationstate.State, logger api.Logger) {
 	if meta == nil {
 		return
 	}
@@ -659,7 +595,7 @@ func RebuildReleaseName(meta *api.PreparedMetadata, logger api.Logger) {
 	}
 }
 
-func applyAudioLanguagePrefix(audio string, meta api.PreparedMetadata) string {
+func applyAudioLanguagePrefix(audio string, meta preparationstate.State) string {
 	base := strings.TrimSpace(audio)
 	for _, prefix := range []string{"Dual-Audio", "Dubbed"} {
 		if strings.EqualFold(base, prefix) {
@@ -691,34 +627,11 @@ func applyAudioLanguagePrefix(audio string, meta api.PreparedMetadata) string {
 	return strings.TrimSpace(prefix + " " + base)
 }
 
-func applyAudioBloatPolicy(meta *api.PreparedMetadata, candidateTrackers []string, logger api.Logger) {
-	if meta == nil || strings.TrimSpace(meta.DiscType) != "" {
-		return
-	}
-
-	blocked, warned := resolveAudioBloatPolicy(*meta, candidateTrackers)
-	if len(blocked) == 0 && len(warned) == 0 {
-		return
-	}
-
-	for tracker, languages := range blocked {
-		meta.BlockedTrackers = addMetadataTrackerBlockReason(meta.BlockedTrackers, tracker, api.TrackerBlockReasonAudio)
-		meta.TrackerRuleFailures = addMetadataTrackerRuleFailure(meta.TrackerRuleFailures, tracker, api.RuleFailure{
-			Rule:   "audio_bloat",
-			Reason: audioBloatReason(languages, true),
-		})
-		if logger != nil {
-			logger.Warnf("metadata: removed tracker %s due to audio bloat languages=%v", tracker, languages)
-		}
-	}
-	for tracker, languages := range warned {
-		if logger != nil {
-			logger.Warnf("metadata: audio may be considered bloated on %s languages=%v", tracker, languages)
-		}
-	}
-}
-
-func resolveAudioBloatPolicy(meta api.PreparedMetadata, candidateTrackers []string) (map[string][]string, map[string][]string) {
+func resolveAudioBloatPolicyWithRegistry(
+	meta preparationstate.State,
+	candidateTrackers []string,
+	registry *trackers.Registry,
+) (map[string][]string, map[string][]string) {
 	original := canonicalAudioLanguage(originalAudioLanguage(meta))
 	if original == "" || original == "unknown" {
 		return nil, nil
@@ -754,16 +667,11 @@ func resolveAudioBloatPolicy(meta api.PreparedMetadata, candidateTrackers []stri
 		return nil, nil
 	}
 
-	bloatAllowed := map[string]struct{}{
-		"ASC": {}, "BJS": {}, "BT": {}, "DC": {}, "FF": {}, "TL": {},
-	}
-	trackerAllowedLanguages := map[string][]string{
-		"AITHER": {"english"},
-		"ANT":    {"english"},
-		"SPD":    {"romanian"},
-	}
-	hardBlockedForEnglishOriginal := map[string]struct{}{
-		"ANT": {}, "BHD": {}, "MTV": {},
+	trackerPolicies := make(map[string]trackers.AudioPolicy, len(resolvedTrackers))
+	for _, tracker := range resolvedTrackers {
+		if policy, ok := registry.LookupAudioPolicy(tracker); ok {
+			trackerPolicies[tracker] = policy
+		}
 	}
 	isEnglishOriginalWithNonEnglish := original == "english" && hasEnglish && hasOther
 
@@ -774,17 +682,16 @@ func resolveAudioBloatPolicy(meta api.PreparedMetadata, candidateTrackers []stri
 			continue
 		}
 		for _, tracker := range resolvedTrackers {
-			if _, ok := bloatAllowed[tracker]; ok {
+			policy := trackerPolicies[tracker]
+			if policy.AllowBloat {
 				continue
 			}
-			if allowed, ok := trackerAllowedLanguages[tracker]; ok && containsCanonicalLanguage(allowed, language) {
+			if containsCanonicalLanguage(policy.AllowedLanguages, language) {
 				continue
 			}
-			if isEnglishOriginalWithNonEnglish {
-				if _, ok := hardBlockedForEnglishOriginal[tracker]; ok {
-					blocked[tracker] = appendUniqueString(blocked[tracker], languageutil.NormalizeLanguageDisplay(language))
-					continue
-				}
+			if isEnglishOriginalWithNonEnglish && policy.BlockEnglishOriginalWithForeign {
+				blocked[tracker] = appendUniqueString(blocked[tracker], languageutil.NormalizeLanguageDisplay(language))
+				continue
 			}
 			warned[tracker] = appendUniqueString(warned[tracker], languageutil.NormalizeLanguageDisplay(language))
 		}
@@ -811,56 +718,6 @@ func appendUniqueString(values []string, value string) []string {
 	return append(values, trimmed)
 }
 
-func removeTrackerBlockReason(blocked map[string][]api.TrackerBlockReason, reason api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
-	if len(blocked) == 0 {
-		return blocked
-	}
-
-	filtered := make(map[string][]api.TrackerBlockReason, len(blocked))
-	for tracker, reasons := range blocked {
-		kept := make([]api.TrackerBlockReason, 0, len(reasons))
-		for _, existing := range reasons {
-			if existing == reason {
-				continue
-			}
-			kept = append(kept, existing)
-		}
-		if len(kept) == 0 {
-			continue
-		}
-		filtered[tracker] = append([]api.TrackerBlockReason{}, kept...)
-	}
-	if len(filtered) == 0 {
-		return nil
-	}
-	return filtered
-}
-
-func removeTrackerRule(failures map[string][]api.RuleFailure, rule string) map[string][]api.RuleFailure {
-	if len(failures) == 0 {
-		return failures
-	}
-
-	filtered := make(map[string][]api.RuleFailure, len(failures))
-	for tracker, trackerFailures := range failures {
-		kept := make([]api.RuleFailure, 0, len(trackerFailures))
-		for _, failure := range trackerFailures {
-			if strings.EqualFold(strings.TrimSpace(failure.Rule), strings.TrimSpace(rule)) {
-				continue
-			}
-			kept = append(kept, failure)
-		}
-		if len(kept) == 0 {
-			continue
-		}
-		filtered[tracker] = kept
-	}
-	if len(filtered) == 0 {
-		return nil
-	}
-	return filtered
-}
-
 func containsCanonicalLanguage(values []string, target string) bool {
 	for _, value := range values {
 		if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
@@ -1263,7 +1120,7 @@ func threeDFromBDInfo(info *discparse.BDInfo) string {
 	return ""
 }
 
-func sourceAndType(meta api.PreparedMetadata, doc mediaInfoDoc) (string, string) {
+func sourceAndType(meta preparationstate.State, doc mediaInfoDoc) (string, string) {
 	source := strings.TrimSpace(meta.Release.Source)
 	typeValue := strings.TrimSpace(meta.Release.Type)
 	if typeValue == "" || isCategoryType(typeValue) {
@@ -1348,7 +1205,7 @@ func dvdSystemFromMedia(doc mediaInfoDoc) string {
 	return ""
 }
 
-func uhdFromMeta(meta api.PreparedMetadata) string {
+func uhdFromMeta(meta preparationstate.State) string {
 	upperPath := strings.ToUpper(meta.SourcePath)
 	if strings.Contains(upperPath, "UHD") {
 		return "UHD"
@@ -1374,7 +1231,7 @@ func uhdFromMeta(meta api.PreparedMetadata) string {
 // filename tokens from the current source path or parsed release. Bare PQ
 // transfer metadata is normalized to HDR only when BT.2020 primaries confirm
 // the HDR color space.
-func hdrFromMedia(doc mediaInfoDoc, bdinfo *discparse.BDInfo, meta api.PreparedMetadata) string {
+func hdrFromMedia(doc mediaInfoDoc, bdinfo *discparse.BDInfo, meta preparationstate.State) string {
 	if bdinfo != nil && len(bdinfo.Video) > 0 {
 		hdr := ""
 		dv := ""
@@ -1440,7 +1297,7 @@ func hdrFromMedia(doc mediaInfoDoc, bdinfo *discparse.BDInfo, meta api.PreparedM
 
 // filenameHDRFromMeta returns normalized HDR tokens from SourcePath before
 // falling back to previously parsed release tokens.
-func filenameHDRFromMeta(meta api.PreparedMetadata) string {
+func filenameHDRFromMeta(meta preparationstate.State) string {
 	if sourceHDR := normalizeFilenameHDRTokens(ParseReleaseInfo(meta.SourcePath).HDR); sourceHDR != "" {
 		return sourceHDR
 	}
@@ -1586,7 +1443,7 @@ func videoEncodeFromMedia(doc mediaInfoDoc, typeValue string) (string, string, b
 	return videoEncode, videoCodec, encodedSettings != "", bitDepth
 }
 
-func editionFromMeta(meta api.PreparedMetadata, doc mediaInfoDoc) (string, string) {
+func editionFromMeta(meta preparationstate.State, doc mediaInfoDoc) (string, string) {
 	edition := ""
 	isIMDbEdition := false
 	applyAnimeOverride(&meta)
@@ -1625,7 +1482,7 @@ func editionFromMeta(meta api.PreparedMetadata, doc mediaInfoDoc) (string, strin
 
 // repackFromMeta scans source basenames and parsed release tokens so repack
 // markers do not depend on guessit/rls placing them in the edition field.
-func repackFromMeta(meta api.PreparedMetadata, edition string) string {
+func repackFromMeta(meta preparationstate.State, edition string) string {
 	return repackFromText(
 		pathutil.Base(meta.SourcePath),
 		pathutil.Base(meta.VideoPath),
@@ -1685,11 +1542,11 @@ func hasReleaseToken(tokens map[string]struct{}, value string) bool {
 	return ok
 }
 
-func resolveMultiPlaylistEdition(meta api.PreparedMetadata) string {
+func resolveMultiPlaylistEdition(meta preparationstate.State) string {
 	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
 		return ""
 	}
-	if len(meta.SelectedBDMVPlaylists) < 2 || meta.ExternalMetadata.IMDB == nil || len(meta.ExternalMetadata.IMDB.EditionDetails) == 0 {
+	if len(meta.SelectedBDMVPlaylists) < 2 || meta.ProviderMetadata.IMDB == nil || len(meta.ProviderMetadata.IMDB.EditionDetails) == 0 {
 		return ""
 	}
 
@@ -1701,7 +1558,7 @@ func resolveMultiPlaylistEdition(meta api.PreparedMetadata) string {
 			continue
 		}
 
-		matches := imdbEditionMatches(playlist.Duration, meta.ExternalMetadata.IMDB.EditionDetails, true)
+		matches := imdbEditionMatches(playlist.Duration, meta.ProviderMetadata.IMDB.EditionDetails, true)
 		if len(matches) == 0 {
 			continue
 		}
@@ -1741,18 +1598,18 @@ type imdbEditionMatch struct {
 	minutes       int
 }
 
-func resolveIMDbEditionFromMediaDuration(meta api.PreparedMetadata, doc mediaInfoDoc) string {
+func resolveIMDbEditionFromMediaDuration(meta preparationstate.State, doc mediaInfoDoc) string {
 	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || !isMovieMetadata(meta) || meta.Anime {
 		return ""
 	}
-	if meta.ExternalMetadata.IMDB == nil || len(meta.ExternalMetadata.IMDB.EditionDetails) <= 1 {
+	if meta.ProviderMetadata.IMDB == nil || len(meta.ProviderMetadata.IMDB.EditionDetails) <= 1 {
 		return ""
 	}
 	duration := mediaDurationSeconds(doc)
 	if duration <= 0 {
 		return ""
 	}
-	matches := imdbEditionMatches(duration, meta.ExternalMetadata.IMDB.EditionDetails, true)
+	matches := imdbEditionMatches(duration, meta.ProviderMetadata.IMDB.EditionDetails, true)
 	if len(matches) == 0 || !matches[0].hasAttribute {
 		return ""
 	}
@@ -1988,7 +1845,7 @@ func cleanEditionResidue(edition string) string {
 	return strings.TrimSpace(edition)
 }
 
-func applyAnimeOverride(meta *api.PreparedMetadata) {
+func applyAnimeOverride(meta *preparationstate.State) {
 	if meta == nil || meta.MetadataOverrides.Anime == nil {
 		return
 	}
@@ -2003,8 +1860,8 @@ func hasNoEditionOverride(overrides api.ReleaseNameOverrides) bool {
 	return overrides.NoEdition != nil && *overrides.NoEdition
 }
 
-func isMovieMetadata(meta api.PreparedMetadata) bool {
-	category := normalizeNamingCategory(meta.ExternalIDs.Category)
+func isMovieMetadata(meta preparationstate.State) bool {
+	category := normalizeNamingCategory(string(meta.Identity.Category))
 	if category == "" {
 		category = normalizeNamingCategory(meta.MediaInfoCategory)
 	}
diff --git a/internal/metadata/media_details_test.go b/internal/metadata/media_details_test.go
index 2c010595..64af7b98 100644
--- a/internal/metadata/media_details_test.go
+++ b/internal/metadata/media_details_test.go
@@ -10,23 +10,75 @@ import (
 	"strings"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/metadata/discparse"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+type aitherRuleDefinition struct{}
+
+func (aitherRuleDefinition) Name() string           { return "AITHER" }
+func (aitherRuleDefinition) DefaultBaseURL() string { return "https://aither.cc" }
+func (aitherRuleDefinition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+func (aitherRuleDefinition) Prepare(ctx context.Context, input trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return preparePolicyDefinition(ctx, input)
+}
+func (aitherRuleDefinition) ClaimPolicy() *trackers.ClaimPolicy {
+	return &trackers.ClaimPolicy{APIBacked: true}
+}
+func preparePolicyDefinition(ctx context.Context, input trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.PrepareAdapter(
+		ctx,
+		input,
+		func(context.Context, trackers.PreparationInput) (trackers.DescriptionResult, error) {
+			return trackers.DescriptionResult{}, nil
+		},
+		func(context.Context, trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return trackers.NewPreparedOperation(
+				api.TrackerDryRunEntry{Tracker: input.Tracker, Status: "ready"},
+				func(context.Context) (api.UploadSummary, error) { return api.UploadSummary{}, nil },
+				nil,
+			), nil
+		},
+	)
+}
+
+func antRuleRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
 func TestEditionFromMetaMultiPlaylistAggregatesIMDbMatches(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType: "BDMV",
 		SelectedBDMVPlaylists: []api.PlaylistInfo{
 			{File: "00001.MPLS", Duration: 7200},
 			{File: "00002.MPLS", Duration: 7500},
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"120": {DisplayName: "2h", Seconds: 7200, Minutes: 120},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"Extended"}},
+					"120": {
+						DisplayName: "2h",
+						Seconds:     7200,
+						Minutes:     120,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"Extended"},
+					},
 				},
 			},
 		},
@@ -42,16 +94,21 @@ func TestEditionFromMetaMultiPlaylistAggregatesIMDbMatches(t *testing.T) {
 }
 
 func TestEditionFromMetaMultiPlaylistDeduplicatesMatches(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType: "BDMV",
 		SelectedBDMVPlaylists: []api.PlaylistInfo{
 			{File: "00001.MPLS", Duration: 7200},
 			{File: "00002.MPLS", Duration: 7205},
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"120": {DisplayName: "2h", Seconds: 7200, Minutes: 120, Attributes: []string{"Director's Cut"}},
+					"120": {
+						DisplayName: "2h",
+						Seconds:     7200,
+						Minutes:     120,
+						Attributes:  []string{"Director's Cut"},
+					},
 				},
 			},
 		},
@@ -64,17 +121,27 @@ func TestEditionFromMetaMultiPlaylistDeduplicatesMatches(t *testing.T) {
 }
 
 func TestEditionFromMetaMultiPlaylistTieBreaksEqualRuntimeMatches(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType: "BDMV",
 		SelectedBDMVPlaylists: []api.PlaylistInfo{
 			{File: "00001.MPLS", Duration: 7500},
 			{File: "00002.MPLS", Duration: 7500},
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"124": {DisplayName: "2h 4m 50s", Seconds: 7490, Minutes: 124, Attributes: []string{"extended cut"}},
-					"125": {DisplayName: "2h 5m 10s", Seconds: 7510, Minutes: 125, Attributes: []string{"director's cut"}},
+					"124": {
+						DisplayName: "2h 4m 50s",
+						Seconds:     7490,
+						Minutes:     124,
+						Attributes:  []string{"extended cut"},
+					},
+					"125": {
+						DisplayName: "2h 5m 10s",
+						Seconds:     7510,
+						Minutes:     125,
+						Attributes:  []string{"director's cut"},
+					},
 				},
 			},
 		},
@@ -87,7 +154,7 @@ func TestEditionFromMetaMultiPlaylistTieBreaksEqualRuntimeMatches(t *testing.T)
 }
 
 func TestEditionFromMetaMultiPlaylistFallsBackWhenNoIMDbMatch(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType: "BDMV",
 		SelectedBDMVPlaylists: []api.PlaylistInfo{
 			{File: "00001.MPLS", Duration: 7200},
@@ -96,10 +163,15 @@ func TestEditionFromMetaMultiPlaylistFallsBackWhenNoIMDbMatch(t *testing.T) {
 		Release: api.ReleaseInfo{
 			Edition: []string{"Collector's", "Edition"},
 		},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"90": {DisplayName: "1h 30m", Seconds: 5400, Minutes: 90, Attributes: []string{"Extended"}},
+					"90": {
+						DisplayName: "1h 30m",
+						Seconds:     5400,
+						Minutes:     90,
+						Attributes:  []string{"Extended"},
+					},
 				},
 			},
 		},
@@ -112,13 +184,22 @@ func TestEditionFromMetaMultiPlaylistFallsBackWhenNoIMDbMatch(t *testing.T) {
 }
 
 func TestEditionFromMetaMatchesIMDbRuntimeForSingleFile(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended edition"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended edition"},
+					},
 				},
 			},
 		},
@@ -135,13 +216,21 @@ func TestEditionFromMetaMatchesIMDbRuntimeForSingleFile(t *testing.T) {
 }
 
 func TestEditionFromMetaIgnoresIMDbRuntimeTheatricalOnlyForSingleFile(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+					},
 				},
 			},
 		},
@@ -155,13 +244,23 @@ func TestEditionFromMetaIgnoresIMDbRuntimeTheatricalOnlyForSingleFile(t *testing
 }
 
 func TestEditionFromMetaChoosesClosestIMDbRuntimeForSingleFile(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"124": {DisplayName: "2h 4m", Seconds: 7440, Minutes: 124, Attributes: []string{"director's cut"}},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended cut"}},
+					"124": {
+						DisplayName: "2h 4m",
+						Seconds:     7440,
+						Minutes:     124,
+						Attributes:  []string{"director's cut"},
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended cut"},
+					},
 				},
 			},
 		},
@@ -175,13 +274,22 @@ func TestEditionFromMetaChoosesClosestIMDbRuntimeForSingleFile(t *testing.T) {
 }
 
 func TestEditionFromMetaSuppressesEditionWhenCloserIMDbRuntimeIsTheatrical(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"124": {DisplayName: "2h 4m", Seconds: 7440, Minutes: 124, Attributes: []string{"director's cut"}},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125},
+					"124": {
+						DisplayName: "2h 4m",
+						Seconds:     7440,
+						Minutes:     124,
+						Attributes:  []string{"director's cut"},
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+					},
 				},
 			},
 		},
@@ -196,15 +304,24 @@ func TestEditionFromMetaSuppressesEditionWhenCloserIMDbRuntimeIsTheatrical(t *te
 
 func TestEditionFromMetaSkipsIMDbRuntimeWhenManualEditionOverridePresent(t *testing.T) {
 	manual := "Hybrid"
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		ReleaseNameOverrides: api.ReleaseNameOverrides{Edition: &manual},
 		Release:              api.ReleaseInfo{Edition: []string{"Collector's", "Edition"}},
-		ExternalIDs:          api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+		Identity:             api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended"},
+					},
 				},
 			},
 		},
@@ -219,16 +336,25 @@ func TestEditionFromMetaSkipsIMDbRuntimeWhenManualEditionOverridePresent(t *test
 
 func TestEditionFromMetaSkipsIMDbRuntimeWhenNoEditionOverridePresent(t *testing.T) {
 	noEdition := true
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		ReleaseNameOverrides: api.ReleaseNameOverrides{NoEdition: &noEdition},
 		Edition:              "IMAX",
 		Release:              api.ReleaseInfo{Edition: []string{"Collector's", "Edition"}},
-		ExternalIDs:          api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+		Identity:             api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended"},
+					},
 				},
 			},
 		},
@@ -243,14 +369,23 @@ func TestEditionFromMetaSkipsIMDbRuntimeWhenNoEditionOverridePresent(t *testing.
 
 func TestEditionFromMetaSkipsIMDbRuntimeWhenAnimeOverridePresent(t *testing.T) {
 	anime := true
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		MetadataOverrides: api.MetadataOverrides{Anime: &anime},
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+		Identity:          api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended"},
+					},
 				},
 			},
 		},
@@ -264,7 +399,7 @@ func TestEditionFromMetaSkipsIMDbRuntimeWhenAnimeOverridePresent(t *testing.T) {
 }
 
 func TestEditionFromMetaExtractsRepackAndCleansEdition(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Release: api.ReleaseInfo{Edition: []string{"Limited", "Extended", "Edition", "REPACK2"}},
 	}
 
@@ -278,7 +413,7 @@ func TestEditionFromMetaExtractsRepackAndCleansEdition(t *testing.T) {
 }
 
 func TestEditionFromMetaDropsPunctuationOnlyEditionResidue(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Release: api.ReleaseInfo{Edition: []string{"Limited.Edition", "Limited.Edition"}},
 	}
 
@@ -292,7 +427,7 @@ func TestEditionFromMetaDropsPunctuationOnlyEditionResidue(t *testing.T) {
 }
 
 func TestEditionFromMetaTrimsPunctuationAroundKeptEdition(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Release: api.ReleaseInfo{Edition: []string{"Limited.Edition", "Extended.Edition"}},
 	}
 
@@ -303,7 +438,7 @@ func TestEditionFromMetaTrimsPunctuationAroundKeptEdition(t *testing.T) {
 }
 
 func TestEditionFromMetaStripsRepackAliasesFromEdition(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Release: api.ReleaseInfo{Edition: []string{"Director's", "Cut", "V3"}},
 	}
 
@@ -351,7 +486,7 @@ func TestEditionFromMetaExtractsRepackFromSourcePath(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			edition, repack := editionFromMeta(api.PreparedMetadata{SourcePath: tc.path}, mediaInfoDoc{})
+			edition, repack := editionFromMeta(preparationstate.State{SourcePath: tc.path}, mediaInfoDoc{})
 			if edition != "" {
 				t.Fatalf("expected empty edition, got %q", edition)
 			}
@@ -400,13 +535,22 @@ func TestMediaDurationSecondsParsesMediaInfoDurationFormats(t *testing.T) {
 }
 
 func TestEditionFromMetaMatchesIMDbRuntimeFromDurationString(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"extended"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"extended"},
+					},
 				},
 			},
 		},
@@ -420,13 +564,22 @@ func TestEditionFromMetaMatchesIMDbRuntimeFromDurationString(t *testing.T) {
 }
 
 func TestEditionFromMetaPreservesIMDbEditionAttributeText(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB: &api.IMDBMetadata{
 				EditionDetails: map[string]api.IMDBEditionDetail{
-					"100": {DisplayName: "1h 40m", Seconds: 6000, Minutes: 100},
-					"125": {DisplayName: "2h 5m", Seconds: 7500, Minutes: 125, Attributes: []string{"IMAX", "remastered version"}},
+					"100": {
+						DisplayName: "1h 40m",
+						Seconds:     6000,
+						Minutes:     100,
+					},
+					"125": {
+						DisplayName: "2h 5m",
+						Seconds:     7500,
+						Minutes:     125,
+						Attributes:  []string{"IMAX", "remastered version"},
+					},
 				},
 			},
 		},
@@ -446,7 +599,7 @@ func TestSmartEditionWordHandlesUnicodeFirstRune(t *testing.T) {
 }
 
 func TestSourceAndTypeInfersWebDLFromParsedRelease(t *testing.T) {
-	source, typeValue := sourceAndType(api.PreparedMetadata{
+	source, typeValue := sourceAndType(preparationstate.State{
 		SourcePath: "Movie.2026.1080p.WEB-DL.DDP5.1.H.264-GRP.mkv",
 		Release: api.ReleaseInfo{
 			Source: "Web",
@@ -463,7 +616,7 @@ func TestSourceAndTypeInfersWebDLFromParsedRelease(t *testing.T) {
 }
 
 func TestSourceAndTypeBareWebEncodeDefaultsToWebDL(t *testing.T) {
-	source, typeValue := sourceAndType(api.PreparedMetadata{
+	source, typeValue := sourceAndType(preparationstate.State{
 		SourcePath: "Movie.2026.HDR.2160p.WEB.h265-GRP.mkv",
 		Release: api.ReleaseInfo{
 			Source: "WEB",
@@ -480,7 +633,7 @@ func TestSourceAndTypeBareWebEncodeDefaultsToWebDL(t *testing.T) {
 }
 
 func TestSourceAndTypeBareWebMissingTypeDefaultsToWebDL(t *testing.T) {
-	source, typeValue := sourceAndType(api.PreparedMetadata{
+	source, typeValue := sourceAndType(preparationstate.State{
 		SourcePath: "Movie.2026.HDR.2160p.WEB.h265-GRP.mkv",
 		Release: api.ReleaseInfo{
 			Source: "WEB",
@@ -502,7 +655,7 @@ func TestApplyMediaDetailsFallsBackToFilenameHDRWhenMediaInfoHasNoHDR(t *testing
 	}
 
 	svc := NewService(&fakeRepo{}, WithConfig(config.Config{}))
-	meta, err := svc.ApplyMediaDetails(context.Background(), api.PreparedMetadata{
+	meta, err := svc.deriveMediaFacts(context.Background(), preparationstate.State{
 		SourcePath:        "Movie.2026.[DV].HDR10+.HLG.2160p.WEB-DL.H.265-GRP.mkv",
 		MediaInfoJSONPath: miPath,
 		Release:           api.ReleaseInfo{HDR: []string{"HDR"}, Resolution: "2160p"},
@@ -524,7 +677,7 @@ func TestHDRFromMediaPrefersMediaInfoOverFilenameHDR(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{
+	got := hdrFromMedia(doc, nil, preparationstate.State{
 		SourcePath: "Movie.2026.DV.HDR.2160p.WEB-DL.H.265-GRP.mkv",
 	})
 	if got != "HDR10+" {
@@ -538,7 +691,7 @@ func TestHDRFromMediaNormalizesPQTransferToHDR(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "HDR" {
 		t.Fatalf("expected PQ transfer to normalize to HDR, got %q", got)
 	}
@@ -550,7 +703,7 @@ func TestHDRFromMediaDetectsDolbyVisionHDR10Compatibility(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "DV HDR" {
 		t.Fatalf("expected Dolby Vision HDR10 compatibility to normalize to DV HDR, got %q", got)
 	}
@@ -562,7 +715,7 @@ func TestHDRFromMediaDetectsDolbyVisionHDR10PlusCompatibility(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "DV HDR10+" {
 		t.Fatalf("expected Dolby Vision HDR10+ compatibility to normalize to DV HDR10+, got %q", got)
 	}
@@ -574,7 +727,7 @@ func TestHDRFromMediaDetectsDolbyVisionOnly(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "DV" {
 		t.Fatalf("expected Dolby Vision metadata to normalize to DV, got %q", got)
 	}
@@ -586,7 +739,7 @@ func TestHDRFromMediaDetectsSMPTE2094AsHDR(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "HDR" {
 		t.Fatalf("expected SMPTE ST 2094 metadata to normalize to HDR, got %q", got)
 	}
@@ -598,7 +751,7 @@ func TestHDRFromMediaDetectsHLGFormat(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "HLG" {
 		t.Fatalf("expected HLG format metadata to normalize to HLG, got %q", got)
 	}
@@ -610,7 +763,7 @@ func TestHDRFromMediaDetectsHLGTransfer(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "HLG" {
 		t.Fatalf("expected HLG transfer metadata to normalize to HLG, got %q", got)
 	}
@@ -622,7 +775,7 @@ func TestHDRFromMediaDetectsBT2020TransferAsWCG(t *testing.T) {
 		t.Fatalf("parse mediainfo: %v", err)
 	}
 
-	got := hdrFromMedia(doc, nil, api.PreparedMetadata{})
+	got := hdrFromMedia(doc, nil, preparationstate.State{})
 	if got != "WCG" {
 		t.Fatalf("expected BT.2020 transfer metadata to normalize to WCG, got %q", got)
 	}
@@ -634,7 +787,7 @@ func TestHDRFromMediaPrefersBDInfoOverFilenameHDR(t *testing.T) {
 			{HDRDV: "HDR10+"},
 			{HDRDV: "Dolby Vision"},
 		},
-	}, api.PreparedMetadata{
+	}, preparationstate.State{
 		SourcePath: "Movie.2026.HDR.2160p.BluRay-GRP",
 	})
 	if got != "DV HDR10+" {
@@ -645,27 +798,27 @@ func TestHDRFromMediaPrefersBDInfoOverFilenameHDR(t *testing.T) {
 func TestFilenameHDRFromMetaNormalizesSafeTokens(t *testing.T) {
 	tests := []struct {
 		name string
-		meta api.PreparedMetadata
+		meta preparationstate.State
 		want string
 	}{
 		{
 			name: "dot bracket space tokens",
-			meta: api.PreparedMetadata{SourcePath: "Movie.2026.[DV].HDR10+.HLG.2160p.WEB-DL.H.265-GRP.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie.2026.[DV].HDR10+.HLG.2160p.WEB-DL.H.265-GRP.mkv"},
 			want: "DV HDR10+ HLG",
 		},
 		{
 			name: "underscore separator",
-			meta: api.PreparedMetadata{SourcePath: "Movie_2026_HDR_2160p_WEB-DL_H265-GRP.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie_2026_HDR_2160p_WEB-DL_H265-GRP.mkv"},
 			want: "HDR",
 		},
 		{
 			name: "hyphen separator",
-			meta: api.PreparedMetadata{SourcePath: "Movie-2026-HDR10-2160p-WEB-DL-H265-GRP.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie-2026-HDR10-2160p-WEB-DL-H265-GRP.mkv"},
 			want: "HDR",
 		},
 		{
 			name: "source path tokens win over stale parsed release tokens",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				SourcePath: "Movie.2026.DV.HDR10+.2160p.WEB-DL.H265-GRP.mkv",
 				Release:    api.ReleaseInfo{HDR: []string{"HDR"}},
 			},
@@ -673,22 +826,22 @@ func TestFilenameHDRFromMetaNormalizesSafeTokens(t *testing.T) {
 		},
 		{
 			name: "parsed release tokens fallback when source path has no hdr",
-			meta: api.PreparedMetadata{Release: api.ReleaseInfo{HDR: []string{"DV", "HDR10+", "SDR"}}},
+			meta: preparationstate.State{Release: api.ReleaseInfo{HDR: []string{"DV", "HDR10+", "SDR"}}},
 			want: "DV HDR10+",
 		},
 		{
 			name: "sdr token ignored",
-			meta: api.PreparedMetadata{SourcePath: "Movie.2026.SDR.2160p.WEB-DL.H.265-GRP.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie.2026.SDR.2160p.WEB-DL.H.265-GRP.mkv"},
 			want: "",
 		},
 		{
 			name: "hdrip source ignored",
-			meta: api.PreparedMetadata{SourcePath: "Movie.2026.1080p.HDRip.H.264-GRP.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie.2026.1080p.HDRip.H.264-GRP.mkv"},
 			want: "",
 		},
 		{
 			name: "group suffix ignored",
-			meta: api.PreparedMetadata{SourcePath: "Movie.2026.2160p.WEB-DL.H.265-GRP-HDR.mkv"},
+			meta: preparationstate.State{SourcePath: "Movie.2026.2160p.WEB-DL.H.265-GRP-HDR.mkv"},
 			want: "",
 		},
 	}
@@ -703,7 +856,7 @@ func TestFilenameHDRFromMetaNormalizesSafeTokens(t *testing.T) {
 }
 
 func TestSourceAndTypeInfersRemuxWhenReleaseTypeMissing(t *testing.T) {
-	source, typeValue := sourceAndType(api.PreparedMetadata{
+	source, typeValue := sourceAndType(preparationstate.State{
 		SourcePath: "Movie.2026.1080p.BluRay.REMUX.AVC.DTS-HD.MA.5.1-GRP.mkv",
 		Release: api.ReleaseInfo{
 			Source: "BluRay",
@@ -721,7 +874,7 @@ func TestSourceAndTypeInfersRemuxWhenReleaseTypeMissing(t *testing.T) {
 // Python get_type() falls back to "ENCODE" for any release that is not a disc
 // and does not match a known keyword. Verify Go does the same.
 func TestSourceAndTypeDefaultsToEncodeForUnknownRelease(t *testing.T) {
-	_, typeValue := sourceAndType(api.PreparedMetadata{
+	_, typeValue := sourceAndType(preparationstate.State{
 		SourcePath: "Some.Unknown.Movie.2026-GRP.mkv",
 		Release:    api.ReleaseInfo{},
 	}, mediaInfoDoc{})
@@ -735,7 +888,7 @@ func TestSourceAndTypeEncodeDefaultNotAppliedForDiscs(t *testing.T) {
 	for _, discType := range []string{"BDMV", "DVD", "HDDVD"} {
 		t.Run(discType, func(t *testing.T) {
 			t.Parallel()
-			_, typeValue := sourceAndType(api.PreparedMetadata{
+			_, typeValue := sourceAndType(preparationstate.State{
 				DiscType:   discType,
 				SourcePath: "/media/disc",
 				Release:    api.ReleaseInfo{},
@@ -748,7 +901,7 @@ func TestSourceAndTypeEncodeDefaultNotAppliedForDiscs(t *testing.T) {
 }
 
 func TestSourceAndTypeDefaultsDiscSourceForBDMV(t *testing.T) {
-	source, typeValue := sourceAndType(api.PreparedMetadata{
+	source, typeValue := sourceAndType(preparationstate.State{
 		DiscType:   "BDMV",
 		SourcePath: "/media/disc",
 		Release:    api.ReleaseInfo{},
@@ -765,7 +918,7 @@ func TestSourceAndTypeDefaultsDiscSourceForBDMV(t *testing.T) {
 // Python get_uhd() does NOT include WEBRIP in the 2160p→UHD check.
 // Verify that a 2160p WEBRIP does not produce a UHD flag.
 func TestUHDFromMetaWEBRIP2160pNotUHD(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Type: "WEBRIP",
 		Release: api.ReleaseInfo{
 			Resolution: "2160p",
@@ -777,7 +930,7 @@ func TestUHDFromMetaWEBRIP2160pNotUHD(t *testing.T) {
 }
 
 func TestUHDFromMetaWEBDL2160pNotUHD(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Type: "WEBDL",
 		Release: api.ReleaseInfo{
 			Resolution: "2160p",
@@ -789,7 +942,7 @@ func TestUHDFromMetaWEBDL2160pNotUHD(t *testing.T) {
 }
 
 func TestUHDFromMetaBareWebEncode2160pNotUHD(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Type:   "ENCODE",
 		Source: "WEB",
 		Release: api.ReleaseInfo{
@@ -803,7 +956,7 @@ func TestUHDFromMetaBareWebEncode2160pNotUHD(t *testing.T) {
 }
 
 func TestUHDFromMetaENCODE2160pIsUHD(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Type: "ENCODE",
 		Release: api.ReleaseInfo{
 			Resolution: "2160p",
@@ -815,7 +968,7 @@ func TestUHDFromMetaENCODE2160pIsUHD(t *testing.T) {
 }
 
 func TestUHDFromMetaUHDInPath(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Type:       "WEBRIP",
 		SourcePath: "/media/Movie.2160p.UHD.WEBRip-GRP.mkv",
 		Release: api.ReleaseInfo{
@@ -828,7 +981,7 @@ func TestUHDFromMetaUHDInPath(t *testing.T) {
 }
 
 func TestUHDFromMetaUltraHDReleaseOther(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		Release: api.ReleaseInfo{
 			Other: []string{"Ultra HD"},
 		},
@@ -840,8 +993,8 @@ func TestUHDFromMetaUltraHDReleaseOther(t *testing.T) {
 
 func TestAudioFromMediaAddsDualAudioForEnglishAndOriginalLanguage(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","Language":"en","StreamOrder":"1"},{"@type":"Audio","Format":"AC-3","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","Language":"ja","StreamOrder":"2"}]}}`)
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -856,8 +1009,8 @@ func TestAudioFromMediaAddsDualAudioForEnglishAndOriginalLanguage(t *testing.T)
 
 func TestAudioFromMediaSkipsCommentaryTitleVariantsForDualAudio(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"MLP FBA","Format_AdditionalFeatures":"16-ch","Channels":"8","ChannelLayout":"L R C LFE Ls Rs Lb Rb","Language":"en","StreamOrder":"1"},{"@type":"Audio","Format":"AC-3","Channels":"2","ChannelLayout":"L R","Language":"ja","StreamOrder":"2","Title_String":"Director Commentary"}]}}`)
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -874,7 +1027,7 @@ func TestAudioFromMediaSkipsCommentaryTitleVariantsForDualAudio(t *testing.T) {
 func TestAudioFromMediaSkipsCompatibilityTitleStringForPrimaryAudio(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"2","ChannelLayout":"L R","StreamOrder":"0","Title_String":"Compatibility Track"},{"@type":"Audio","Format":"MLP FBA","Format_AdditionalFeatures":"16-ch","Channels":"8","ChannelLayout":"L R C LFE Ls Rs Lb Rb","StreamOrder":"1"}]}}`)
 
-	audio, channels, commentary := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, commentary := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "TrueHD 7.1 Atmos" {
 		t.Fatalf("expected compatibility Title_String track to be ignored for primary audio, got %q", audio)
 	}
@@ -886,7 +1039,7 @@ func TestAudioFromMediaSkipsCompatibilityTitleStringForPrimaryAudio(t *testing.T
 func TestAudioFromMediaSkipsCommentaryTitleStringForPrimaryAudio(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"2","ChannelLayout":"L R","StreamOrder":"0","Title_String":"Director Commentary"},{"@type":"Audio","Format":"MLP FBA","Format_AdditionalFeatures":"16-ch","Channels":"8","ChannelLayout":"L R C LFE Ls Rs Lb Rb","StreamOrder":"1"}]}}`)
 
-	audio, channels, commentary := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, commentary := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "TrueHD 7.1 Atmos" {
 		t.Fatalf("expected commentary Title_String track to be ignored for primary audio, got %q", audio)
 	}
@@ -898,7 +1051,7 @@ func TestAudioFromMediaSkipsCommentaryTitleStringForPrimaryAudio(t *testing.T) {
 func TestAudioFromMediaDetectsAuro3DFromPrimaryAudioTitle(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"2","ChannelLayout":"L R","StreamOrder":"0","Title_String":"Compatibility Track"},{"@type":"Audio","Format":"DTS","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","StreamOrder":"1","Title_String":"Auro3D"}]}}`)
 
-	audio, channels, commentary := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, commentary := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "DTS 5.1 Auro3D" {
 		t.Fatalf("expected selected primary audio title to drive Auro3D marker, got %q", audio)
 	}
@@ -909,8 +1062,8 @@ func TestAudioFromMediaDetectsAuro3DFromPrimaryAudioTitle(t *testing.T) {
 
 func TestAudioFromMediaAddsDubbedWhenOnlyEnglishTrackPresent(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","Language":"en","StreamOrder":"1"}]}}`)
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -922,9 +1075,9 @@ func TestAudioFromMediaAddsDubbedWhenOnlyEnglishTrackPresent(t *testing.T) {
 
 func TestAudioFromMediaSkipsLanguagePrefixForDiscs(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","Language":"en","StreamOrder":"1"},{"@type":"Audio","Format":"AC-3","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","Language":"ja","StreamOrder":"2"}]}}`)
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		DiscType: "BDMV",
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -935,9 +1088,9 @@ func TestAudioFromMediaSkipsLanguagePrefixForDiscs(t *testing.T) {
 }
 
 func TestApplyAudioLanguagePrefixFiltersCommentaryAndCompatibilityEntries(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		AudioLanguages: []string{"English Commentary", "Compatibility Track", "Japanese"},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -950,7 +1103,7 @@ func TestApplyAudioLanguagePrefixFiltersCommentaryAndCompatibilityEntries(t *tes
 
 func TestAudioFromMediaAddsEXFormatSetting(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Format_Settings":"Dolby Surround EX","Channels":"6","ChannelLayout":"L R C LFE Ls Rs","StreamOrder":"1"}]}}`)
-	audio, _, _ := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, _, _ := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "DD EX 5.1" {
 		t.Fatalf("expected DD EX 5.1, got %q", audio)
 	}
@@ -958,7 +1111,7 @@ func TestAudioFromMediaAddsEXFormatSetting(t *testing.T) {
 
 func TestAudioFromMediaUsesCodecIDWhenFormatIsGenericAudio(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"Audio","CodecID":"A_VORBIS","Channels":"2","StreamOrder":"1"}]}}`)
-	audio, channels, _ := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, _ := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "VORBIS 2.0" {
 		t.Fatalf("expected VORBIS 2.0, got %q", audio)
 	}
@@ -969,7 +1122,7 @@ func TestAudioFromMediaUsesCodecIDWhenFormatIsGenericAudio(t *testing.T) {
 
 func TestAudioFromMediaKeepsGenericFormatWhenCodecIDUnknown(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"Audio","CodecID":"A_UNKNOWN","Channels":"2","StreamOrder":"1"}]}}`)
-	audio, channels, _ := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, _ := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "Audio 2.0" {
 		t.Fatalf("expected Audio 2.0, got %q", audio)
 	}
@@ -978,253 +1131,9 @@ func TestAudioFromMediaKeepsGenericFormatWhenCodecIDUnknown(t *testing.T) {
 	}
 }
 
-func TestRemoveTrackerBlockReasonDoesNotMutateInput(t *testing.T) {
-	original := []api.TrackerBlockReason{api.TrackerBlockReasonAudio, api.TrackerBlockReasonClaim}
-	blocked := map[string][]api.TrackerBlockReason{
-		"AITHER": append([]api.TrackerBlockReason{}, original...),
-	}
-
-	filtered := removeTrackerBlockReason(blocked, api.TrackerBlockReasonAudio)
-
-	if got := blocked["AITHER"]; len(got) != len(original) || got[0] != original[0] || got[1] != original[1] {
-		t.Fatalf("expected input blocked map to remain unchanged, got %#v", blocked)
-	}
-	if got := filtered["AITHER"]; len(got) != 1 || got[0] != api.TrackerBlockReasonClaim {
-		t.Fatalf("expected filtered map to keep only claim block, got %#v", filtered)
-	}
-}
-
-func TestRefreshPreparedMetadataPreservesNonRequestScopedFailures(t *testing.T) {
-	svc := NewService(&fakeRepo{}, WithConfig(config.Config{}))
-	meta := api.PreparedMetadata{
-		BlockedTrackers: map[string][]api.TrackerBlockReason{
-			"AITHER": {api.TrackerBlockReasonAudio, api.TrackerBlockReasonClaim},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {
-				{Rule: "audio_bloat", Reason: "audio languages French may be considered bloated"},
-				{Rule: trackerClaimRuleActive, Reason: "AITHER has an active claim for this release"},
-				{Rule: "language_rule", Reason: "missing original language coverage"},
-			},
-			"ANT": {
-				{Rule: "require_movie_only", Reason: "category tv is not movie"},
-			},
-		},
-	}
-
-	refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("refresh prepared metadata: %v", err)
-	}
-	if refreshed.BlockedTrackers != nil {
-		t.Fatalf("expected request-scoped tracker blocks cleared, got %#v", refreshed.BlockedTrackers)
-	}
-	if failures := refreshed.TrackerRuleFailures["AITHER"]; len(failures) != 1 || failures[0].Rule != "language_rule" {
-		t.Fatalf("expected only non-request-scoped AITHER failure preserved, got %#v", refreshed.TrackerRuleFailures)
-	}
-	if failures := refreshed.TrackerRuleFailures["ANT"]; len(failures) != 1 || failures[0].Rule != "require_movie_only" {
-		t.Fatalf("expected unrelated ANT failure preserved, got %#v", refreshed.TrackerRuleFailures)
-	}
-	for tracker, failures := range refreshed.TrackerRuleFailures {
-		for _, failure := range failures {
-			if failure.Rule == "audio_bloat" || failure.Rule == trackerClaimRuleActive {
-				t.Fatalf("did not expect request-scoped failure %q for %s after refresh: %#v", failure.Rule, tracker, refreshed.TrackerRuleFailures)
-			}
-		}
-	}
-}
-
-func TestRefreshPreparedMetadataRefreshesFilenameHDRFromCurrentSourcePath(t *testing.T) {
-	svc := NewService(&fakeRepo{}, WithConfig(config.Config{}))
-	meta := api.PreparedMetadata{
-		SourcePath: "Movie.2026.DV.HDR10+.2160p.WEB-DL.H.265-GRP.mkv",
-		Source:     "Web",
-		Type:       "WEBDL",
-		VideoCodec: "H.265",
-		HDR:        "HDR",
-		Release: api.ReleaseInfo{
-			Title:      "Movie",
-			Year:       2026,
-			Resolution: "2160p",
-			HDR:        []string{"HDR"},
-		},
-	}
-
-	refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("refresh prepared metadata: %v", err)
-	}
-	if refreshed.HDR != "DV HDR10+" {
-		t.Fatalf("expected current source path HDR, got %q", refreshed.HDR)
-	}
-	if !strings.Contains(refreshed.ReleaseName, "DV HDR10+") {
-		t.Fatalf("expected refreshed release name to include current source path HDR, got %q", refreshed.ReleaseName)
-	}
-}
-
-func TestRefreshPreparedMetadataKeepsDistinctMediaHDR(t *testing.T) {
-	svc := NewService(&fakeRepo{}, WithConfig(config.Config{}))
-	meta := api.PreparedMetadata{
-		SourcePath: "Movie.2026.DV.2160p.WEB-DL.H.265-GRP.mkv",
-		Source:     "Web",
-		Type:       "WEBDL",
-		VideoCodec: "H.265",
-		HDR:        "HDR10+",
-		Release: api.ReleaseInfo{
-			Title:      "Movie",
-			Year:       2026,
-			Resolution: "2160p",
-			HDR:        []string{"HDR"},
-		},
-	}
-
-	refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("refresh prepared metadata: %v", err)
-	}
-	if refreshed.HDR != "HDR10+" {
-		t.Fatalf("expected distinct media HDR to remain, got %q", refreshed.HDR)
-	}
-}
-
-func TestRefreshPreparedMetadataClearsResolvedRuleFailures(t *testing.T) {
-	repo := &fakeRepo{}
-	svc := NewService(repo, WithConfig(config.Config{}))
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/example.mkv",
-		Trackers:   []string{"ANT"},
-		ExternalIDs: api.ExternalIDs{
-			Category: "MOVIE",
-			TMDBID:   1,
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"},
-		},
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"ANT": {
-				{Rule: "require_movie_only", Reason: "category tv is not movie"},
-			},
-			"BTN": {
-				{Rule: "language_rule", Reason: "missing original language coverage"},
-			},
-		},
-	}
-
-	refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("refresh prepared metadata: %v", err)
-	}
-	if failures := refreshed.TrackerRuleFailures["ANT"]; len(failures) != 0 {
-		t.Fatalf("expected resolved ANT rule failure to be cleared, got %#v", failures)
-	}
-	if failures := refreshed.TrackerRuleFailures["BTN"]; len(failures) != 1 || failures[0].Rule != "language_rule" {
-		t.Fatalf("expected unevaluated BTN rule failure to remain, got %#v", refreshed.TrackerRuleFailures)
-	}
-	if len(repo.trackerRuleFailures) != 0 {
-		t.Fatalf("expected cleared ANT rule failures to be persisted, got %#v", repo.trackerRuleFailures)
-	}
-}
-
-func TestRefreshPreparedMetadataKeepsRepoForRulePersistence(t *testing.T) {
-	repo := &fakeRepo{}
-	svc := NewService(repo, WithConfig(config.Config{}))
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/example.mkv",
-		Trackers:   []string{"ANT"},
-		ExternalIDs: api.ExternalIDs{
-			Category: "tv",
-		},
-	}
-
-	refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("refresh prepared metadata: %v", err)
-	}
-	failures := refreshed.TrackerRuleFailures["ANT"]
-	if len(failures) == 0 {
-		t.Fatalf("expected refreshed metadata to retain ANT rule failure, got %#v", refreshed.TrackerRuleFailures)
-	}
-	if len(repo.trackerRuleFailures) == 0 {
-		t.Fatalf("expected tracker rule failures to be persisted during refresh")
-	}
-	if repo.trackerRuleFailures[0].Tracker != "ANT" || repo.trackerRuleFailures[0].Rule != "require_movie_only" {
-		t.Fatalf("unexpected persisted tracker rule failures: %#v", repo.trackerRuleFailures)
-	}
-}
-
-func TestRefreshPreparedMetadataNormalizesStaleMISettingsForNonEncodes(t *testing.T) {
-	svc := NewService(&fakeRepo{}, WithConfig(config.Config{}))
-	cases := []struct {
-		name       string
-		meta       api.PreparedMetadata
-		wantBlock  bool
-		wantNormal bool
-	}{
-		{
-			name: "remux not blocked",
-			meta: api.PreparedMetadata{
-				Type:                   "REMUX",
-				ValidMediaInfoSettings: false,
-			},
-			wantNormal: true,
-		},
-		{
-			name: "bdmv not blocked",
-			meta: api.PreparedMetadata{
-				Type:                   "ENCODE",
-				DiscType:               "BDMV",
-				ValidMediaInfoSettings: false,
-			},
-			wantNormal: true,
-		},
-		{
-			name: "av1 encode not blocked",
-			meta: api.PreparedMetadata{
-				Type:                   "ENCODE",
-				VideoCodec:             "AV1",
-				ValidMediaInfoSettings: false,
-			},
-			wantNormal: true,
-		},
-		{
-			name: "genuine encode stays blocked",
-			meta: api.PreparedMetadata{
-				Type:                   "ENCODE",
-				VideoCodec:             "H.265",
-				ValidMediaInfoSettings: false,
-			},
-			wantBlock: true,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			meta := tc.meta
-			meta.SourcePath = "/media/example.mkv"
-			meta.Trackers = []string{"AITHER"}
-			refreshed, err := svc.RefreshPreparedMetadata(context.Background(), meta)
-			if err != nil {
-				t.Fatalf("refresh prepared metadata: %v", err)
-			}
-			if tc.wantNormal && !refreshed.ValidMediaInfoSettings {
-				t.Fatalf("expected ValidMediaInfoSettings normalized to true")
-			}
-			blocked := false
-			for _, failure := range refreshed.TrackerRuleFailures["AITHER"] {
-				if failure.Rule == "require_valid_mi_setting" {
-					blocked = true
-				}
-			}
-			if blocked != tc.wantBlock {
-				t.Fatalf("require_valid_mi_setting blocked=%t, want %t (failures=%#v)", blocked, tc.wantBlock, refreshed.TrackerRuleFailures["AITHER"])
-			}
-		})
-	}
-}
-
 func TestAudioFromMediaUsesChannelsOriginalWhenPresent(t *testing.T) {
 	doc := mustParseMediaInfoDoc(`{"media":{"track":[{"@type":"General"},{"@type":"Audio","Format":"AC-3","Channels":"8 / 6","Channels_Original":"6","ChannelLayout":"L R C LFE Ls Rs","StreamOrder":"1"}]}}`)
-	audio, channels, _ := audioFromMedia(api.PreparedMetadata{}, doc, nil)
+	audio, channels, _ := audioFromMedia(preparationstate.State{}, doc, nil)
 	if audio != "DD 5.1" {
 		t.Fatalf("expected DD 5.1, got %q", audio)
 	}
@@ -1234,7 +1143,7 @@ func TestAudioFromMediaUsesChannelsOriginalWhenPresent(t *testing.T) {
 }
 
 func TestAudioFromMediaNormalizesBDInfoCodec(t *testing.T) {
-	audio, channels, commentary := audioFromMedia(api.PreparedMetadata{}, mediaInfoDoc{}, &discparse.BDInfo{
+	audio, channels, commentary := audioFromMedia(preparationstate.State{}, mediaInfoDoc{}, &discparse.BDInfo{
 		Audio: []discparse.BDAudio{{
 			Codec:    "Dolby TrueHD Audio",
 			Channels: "5.1",
@@ -1250,7 +1159,7 @@ func TestAudioFromMediaNormalizesBDInfoCodec(t *testing.T) {
 }
 
 func TestAudioFromMediaNormalizesBDInfoCodecWithAtmos(t *testing.T) {
-	audio, channels, commentary := audioFromMedia(api.PreparedMetadata{}, mediaInfoDoc{}, &discparse.BDInfo{
+	audio, channels, commentary := audioFromMedia(preparationstate.State{}, mediaInfoDoc{}, &discparse.BDInfo{
 		Audio: []discparse.BDAudio{{
 			Codec:    "Dolby TrueHD Audio",
 			Channels: "7.1",
@@ -1267,12 +1176,12 @@ func TestAudioFromMediaNormalizesBDInfoCodecWithAtmos(t *testing.T) {
 }
 
 func TestResolveAudioBloatPolicyBlocksStrictTrackersForEnglishOriginal(t *testing.T) {
-	blocked, warned := resolveAudioBloatPolicy(api.PreparedMetadata{
+	blocked, warned := resolveAudioBloatPolicyWithRegistry(preparationstate.State{
 		AudioLanguages: []string{"English", "French"},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "en"},
 		},
-	}, []string{"ANT", "BHD", "MTV", "AITHER", "ASC"})
+	}, []string{"ANT", "BHD", "MTV", "AITHER", "ASC"}, antRuleRegistry(t))
 
 	if got := blocked["ANT"]; len(got) != 1 || got[0] != "French" {
 		t.Fatalf("expected ANT blocked for French bloat, got %#v", blocked)
@@ -1292,12 +1201,12 @@ func TestResolveAudioBloatPolicyBlocksStrictTrackersForEnglishOriginal(t *testin
 }
 
 func TestResolveAudioBloatPolicyWarnsButDoesNotBlockNonEnglishOriginal(t *testing.T) {
-	blocked, warned := resolveAudioBloatPolicy(api.PreparedMetadata{
+	blocked, warned := resolveAudioBloatPolicyWithRegistry(preparationstate.State{
 		AudioLanguages: []string{"English", "Japanese", "French"},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
-	}, []string{"ANT", "BHD", "SPD"})
+	}, []string{"ANT", "BHD", "SPD"}, antRuleRegistry(t))
 
 	if blocked != nil {
 		t.Fatalf("expected no blocked trackers, got %#v", blocked)
diff --git a/internal/metadata/mediainfo/service.go b/internal/metadata/mediainfo/service.go
index 5461c79f..b7addfeb 100644
--- a/internal/metadata/mediainfo/service.go
+++ b/internal/metadata/mediainfo/service.go
@@ -11,17 +11,22 @@ import (
 	"path/filepath"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	gomediainfo "github.com/autobrr/go-mediainfo"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Exporter materializes or reuses source-scoped MediaInfo artifacts.
 type Exporter interface {
 	Export(ctx context.Context, req Request) (Result, error)
 }
 
+// Request names host filesystem paths for one source and its release-scoped
+// temporary root. VideoPath overrides SourcePath for non-DVD analysis.
 type Request struct {
 	SourcePath string
 	DiscType   string
@@ -30,6 +35,9 @@ type Request struct {
 	Release    api.ReleaseInfo
 }
 
+// Result identifies persisted MediaInfo artifacts and optional DVD evidence.
+// Path fields are host filesystem paths; VOBText and VOBJSON are in-memory
+// reports for the selected DVD title set.
 type Result struct {
 	JSONPath string
 	TextPath string
@@ -47,15 +55,21 @@ type targetSelection struct {
 	VOBSet      string
 }
 
+// Analyzer renders text and JSON MediaInfo reports for one host filesystem
+// target. Service owns artifact persistence.
 type Analyzer interface {
 	Analyze(ctx context.Context, target string) (text string, json []byte, err error)
 }
 
+// Service selects the analysis target and owns release-scoped artifact reuse and
+// persistence.
 type Service struct {
 	logger   api.Logger
 	analyzer Analyzer
 }
 
+// NewService substitutes a no-op logger and the module-backed analyzer for nil
+// dependencies.
 func NewService(logger api.Logger, analyzer Analyzer) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
@@ -66,6 +80,10 @@ func NewService(logger api.Logger, analyzer Analyzer) *Service {
 	return &Service{logger: logger, analyzer: analyzer}
 }
 
+// Export writes mode-0600 text and JSON reports beneath the release temporary
+// directory. Existing artifacts are reused only when both files exist and the
+// JSON has no conformance error; DVD VOB evidence is analyzed on every call.
+// Errors return no Result, although a failed JSON write may leave the text file.
 func (s *Service) Export(ctx context.Context, req Request) (Result, error) {
 	select {
 	case <-ctx.Done():
@@ -81,7 +99,7 @@ func (s *Service) Export(ctx context.Context, req Request) (Result, error) {
 		return Result{}, errors.New("mediainfo: empty target")
 	}
 
-	tmpDir, _, err := paths.ReleaseTempDir(req.TempRoot, api.PreparedMetadata{Release: req.Release}, req.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDir(req.TempRoot, preparationstate.State{Release: req.Release}, req.SourcePath)
 	if err != nil {
 		return Result{}, fmt.Errorf("metadata: %w", err)
 	}
@@ -100,7 +118,15 @@ func (s *Service) Export(ctx context.Context, req Request) (Result, error) {
 			if s.logger != nil {
 				s.logger.Debugf("mediainfo: reusing existing artifacts from %s", tmpDir)
 			}
-			return Result{JSONPath: jsonPath, TextPath: textPath, IFOPath: target.IFOPath, VOBPath: target.VOBPath, VOBSet: target.VOBSet, VOBText: vobText, VOBJSON: vobJSON}, nil
+			return Result{
+				JSONPath: jsonPath,
+				TextPath: textPath,
+				IFOPath:  target.IFOPath,
+				VOBPath:  target.VOBPath,
+				VOBSet:   target.VOBSet,
+				VOBText:  vobText,
+				VOBJSON:  vobJSON,
+			}, nil
 		}
 		if s.logger != nil {
 			if err != nil {
@@ -138,7 +164,15 @@ func (s *Service) Export(ctx context.Context, req Request) (Result, error) {
 		return Result{}, err
 	}
 
-	return Result{JSONPath: jsonPath, TextPath: textPath, IFOPath: target.IFOPath, VOBPath: target.VOBPath, VOBSet: target.VOBSet, VOBText: vobText, VOBJSON: vobJSON}, nil
+	return Result{
+		JSONPath: jsonPath,
+		TextPath: textPath,
+		IFOPath:  target.IFOPath,
+		VOBPath:  target.VOBPath,
+		VOBSet:   target.VOBSet,
+		VOBText:  vobText,
+		VOBJSON:  vobJSON,
+	}, nil
 }
 
 func analyzeVOB(ctx context.Context, analyzer Analyzer, vobPath string) (string, string, error) {
diff --git a/internal/metadata/mediainfo/service_test.go b/internal/metadata/mediainfo/service_test.go
index ee1d1e26..3c5c070c 100644
--- a/internal/metadata/mediainfo/service_test.go
+++ b/internal/metadata/mediainfo/service_test.go
@@ -11,7 +11,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/autobrr/upbrr/internal/paths"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -80,7 +82,7 @@ func TestExportReusesExistingArtifactsWhenConformanceOK(t *testing.T) {
 	}
 
 	release := api.ReleaseInfo{Title: "Movie.Title", Year: 2024}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{Release: release}, targetPath)
+	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{Release: release}, targetPath)
 	if err != nil {
 		t.Fatalf("temp dir: %v", err)
 	}
diff --git a/internal/metadata/mediainfo_ids.go b/internal/metadata/mediainfo_ids.go
index d3f8054a..20696698 100644
--- a/internal/metadata/mediainfo_ids.go
+++ b/internal/metadata/mediainfo_ids.go
@@ -11,6 +11,8 @@ import (
 	"strconv"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -22,10 +24,10 @@ type mediaInfoIDs struct {
 	TVDBID   int
 }
 
-func (s *Service) ApplyMediaInfoIDs(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+func (s *Service) collectMediaInfoIdentityEvidence(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
diff --git a/internal/metadata/mediainfo_ids_test.go b/internal/metadata/mediainfo_ids_test.go
index 3dc8cb06..eff2c800 100644
--- a/internal/metadata/mediainfo_ids_test.go
+++ b/internal/metadata/mediainfo_ids_test.go
@@ -9,6 +9,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -21,7 +23,7 @@ func TestApplyMediaInfoIDsFromJSON(t *testing.T) {
 	}
 
 	svc := &Service{}
-	meta, err := svc.ApplyMediaInfoIDs(context.Background(), api.PreparedMetadata{MediaInfoJSONPath: jsonPath})
+	meta, err := svc.collectMediaInfoIdentityEvidence(context.Background(), preparationstate.State{MediaInfoJSONPath: jsonPath})
 	if err != nil {
 		t.Fatalf("apply mediainfo ids: %v", err)
 	}
@@ -48,7 +50,7 @@ func TestApplyMediaInfoIDsTextTVDBPriority(t *testing.T) {
 	}
 
 	svc := &Service{}
-	meta, err := svc.ApplyMediaInfoIDs(context.Background(), api.PreparedMetadata{MediaInfoTextPath: textPath})
+	meta, err := svc.collectMediaInfoIdentityEvidence(context.Background(), preparationstate.State{MediaInfoTextPath: textPath})
 	if err != nil {
 		t.Fatalf("apply mediainfo ids: %v", err)
 	}
@@ -66,7 +68,7 @@ func TestApplyMediaInfoIDsMismatch(t *testing.T) {
 	}
 
 	svc := &Service{}
-	meta, err := svc.ApplyMediaInfoIDs(context.Background(), api.PreparedMetadata{
+	meta, err := svc.collectMediaInfoIdentityEvidence(context.Background(), preparationstate.State{
 		MediaInfoJSONPath: jsonPath,
 		TrackerData:       []api.TrackerMetadata{{TMDBID: 999}},
 	})
diff --git a/internal/metadata/mediainfo_languages.go b/internal/metadata/mediainfo_languages.go
index e3ee52ab..01582b87 100644
--- a/internal/metadata/mediainfo_languages.go
+++ b/internal/metadata/mediainfo_languages.go
@@ -7,11 +7,12 @@ import (
 	"path/filepath"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/languageutil"
-	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func validateMediaInfoUniqueID(meta api.PreparedMetadata, doc mediaInfoDoc) (string, bool) {
+func validateMediaInfoUniqueID(meta preparationstate.State, doc mediaInfoDoc) (string, bool) {
 	if !requiresUniqueID(meta) {
 		return "", true
 	}
@@ -27,7 +28,7 @@ func validateMediaInfoUniqueID(meta api.PreparedMetadata, doc mediaInfoDoc) (str
 	return "", false
 }
 
-func requiresUniqueID(meta api.PreparedMetadata) bool {
+func requiresUniqueID(meta preparationstate.State) bool {
 	if strings.TrimSpace(meta.DiscType) != "" {
 		return false
 	}
diff --git a/internal/metadata/mediainfo_languages_test.go b/internal/metadata/mediainfo_languages_test.go
index 630aee62..9112e44c 100644
--- a/internal/metadata/mediainfo_languages_test.go
+++ b/internal/metadata/mediainfo_languages_test.go
@@ -8,7 +8,11 @@ import "testing"
 func TestExtractMediaInfoLanguagesSkipsCommentary(t *testing.T) {
 	doc := mediaInfoDoc{}
 	doc.Media.Track = []map[string]any{
-		{"@type": "Audio", "Language": "en", "Title": "Director Commentary"},
+		{
+			"@type":    "Audio",
+			"Language": "en",
+			"Title":    "Director Commentary",
+		},
 		{"@type": "Audio", "Language": "fr"},
 		{"@type": "Text", "Language": "en"},
 	}
@@ -24,7 +28,11 @@ func TestExtractMediaInfoLanguagesSkipsCommentary(t *testing.T) {
 func TestExtractMediaInfoLanguagesSkipsCompatibility(t *testing.T) {
 	doc := mediaInfoDoc{}
 	doc.Media.Track = []map[string]any{
-		{"@type": "Audio", "Language": "en", "Title": "Compatibility Track"},
+		{
+			"@type":    "Audio",
+			"Language": "en",
+			"Title":    "Compatibility Track",
+		},
 		{"@type": "Audio", "Language": "ja"},
 	}
 	audio, _ := extractMediaInfoLanguages(doc)
diff --git a/internal/metadata/mediainfo_parse.go b/internal/metadata/mediainfo_parse.go
index cfd03d24..9ca6760e 100644
--- a/internal/metadata/mediainfo_parse.go
+++ b/internal/metadata/mediainfo_parse.go
@@ -11,6 +11,8 @@ import (
 	"strconv"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -84,7 +86,7 @@ var scanTypeRegex = regexp.MustCompile(`(?i)Scan\s*type\s*:\s*([^\r\n]+)`)
 var interlacedResolutionHintRegex = regexp.MustCompile(`(?i)\b(1080i|576i|480i)\b`)
 var numericRegex = regexp.MustCompile(`\d+(?:\.\d+)?`)
 
-func extractDVDMediaInfo(meta api.PreparedMetadata) api.DVDMediaInfo {
+func extractDVDMediaInfo(meta preparationstate.State) api.DVDMediaInfo {
 	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
 		return api.DVDMediaInfo{}
 	}
diff --git a/internal/metadata/metautil/episode_title.go b/internal/metadata/metautil/episode_title.go
index 64002a73..dfc79ab7 100644
--- a/internal/metadata/metautil/episode_title.go
+++ b/internal/metadata/metautil/episode_title.go
@@ -86,13 +86,21 @@ func releaseNameTokens(value string) []releaseNameToken {
 			continue
 		}
 		if tokenStart != -1 {
-			tokens = append(tokens, releaseNameToken{value: builder.String(), start: tokenStart, end: idx})
+			tokens = append(tokens, releaseNameToken{
+				value: builder.String(),
+				start: tokenStart,
+				end:   idx,
+			})
 			builder.Reset()
 			tokenStart = -1
 		}
 	}
 	if tokenStart != -1 {
-		tokens = append(tokens, releaseNameToken{value: builder.String(), start: tokenStart, end: len(value)})
+		tokens = append(tokens, releaseNameToken{
+			value: builder.String(),
+			start: tokenStart,
+			end:   len(value),
+		})
 	}
 	return tokens
 }
diff --git a/internal/metadata/metautil/helpers.go b/internal/metadata/metautil/helpers.go
index 124d51f9..5446ead9 100644
--- a/internal/metadata/metautil/helpers.go
+++ b/internal/metadata/metautil/helpers.go
@@ -10,9 +10,11 @@ import (
 
 	"github.com/moistari/rls"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 )
 
+// ParsedRelease is the subset of basename parser output used by metadata
+// provider searches.
 type ParsedRelease struct {
 	Title    string
 	Alt      string
@@ -21,6 +23,8 @@ type ParsedRelease struct {
 	Year     int
 }
 
+// ParseRelease parses the host-path basename and normalizes its category to
+// MOVIE, TV, or empty.
 func ParseRelease(filename string) ParsedRelease {
 	base := strings.TrimSpace(filename)
 	if base == "" {
@@ -37,6 +41,9 @@ func ParseRelease(filename string) ParsedRelease {
 	}
 }
 
+// NormalizeIMDbID adds the tt prefix and seven-digit padding to numeric IDs.
+// Empty and zero values become empty; non-numeric input is preserved verbatim
+// after trimming.
 func NormalizeIMDbID(value string) string {
 	trimmed := strings.TrimSpace(value)
 	if trimmed == "" || trimmed == "0" {
@@ -52,6 +59,8 @@ func NormalizeIMDbID(value string) string {
 	return fmt.Sprintf("tt%07d", id)
 }
 
+// ParseIMDbNumeric accepts a trimmed numeric or tt-prefixed ID and returns zero
+// for malformed input.
 func ParseIMDbNumeric(value string) int {
 	value = strings.TrimSpace(value)
 	value = strings.TrimPrefix(value, "tt")
@@ -75,6 +84,8 @@ func FirstInt(values ...int) int {
 	return 0
 }
 
+// FirstNonEmpty returns the first value containing non-whitespace text without
+// trimming the returned value.
 func FirstNonEmpty(values ...string) string {
 	for _, value := range values {
 		if strings.TrimSpace(value) != "" {
@@ -84,6 +95,7 @@ func FirstNonEmpty(values ...string) string {
 	return ""
 }
 
+// FirstNonEmptyTrimmed returns the first non-empty value after trimming it.
 func FirstNonEmptyTrimmed(values ...string) string {
 	for _, value := range values {
 		trimmed := strings.TrimSpace(value)
@@ -94,12 +106,22 @@ func FirstNonEmptyTrimmed(values ...string) string {
 	return ""
 }
 
+// ReduceTitle splits on whitespace, removes standalone common video-extension
+// tokens, and drops the requested number of trailing tokens. It returns empty
+// when too few tokens remain.
 func ReduceTitle(filename string, drop int) string {
 	words := strings.Fields(filename)
 	if len(words) <= drop {
 		return ""
 	}
-	extensions := map[string]struct{}{"mp4": {}, "mkv": {}, "avi": {}, "webm": {}, "mov": {}, "wmv": {}}
+	extensions := map[string]struct{}{
+		"mp4":  {},
+		"mkv":  {},
+		"avi":  {},
+		"webm": {},
+		"mov":  {},
+		"wmv":  {},
+	}
 	filtered := make([]string, 0, len(words))
 	for _, word := range words {
 		if _, ok := extensions[strings.ToLower(word)]; ok {
@@ -113,6 +135,8 @@ func ReduceTitle(filename string, drop int) string {
 	return strings.Join(filtered[:len(filtered)-drop], " ")
 }
 
+// SimilarityRatio returns a case-sensitive, rune-aware recursive
+// longest-common-substring score in the range 0 to 1.
 func SimilarityRatio(a, b string) float64 {
 	if a == "" || b == "" {
 		return 0
@@ -132,6 +156,8 @@ func AbsInt(value int) int {
 	return value
 }
 
+// ReleaseCategoryFromRLS collapses supported parser categories to MOVIE or TV
+// and returns empty for unknown categories.
 func ReleaseCategoryFromRLS(value string) string {
 	upper := strings.ToUpper(strings.TrimSpace(value))
 	switch upper {
diff --git a/internal/metadata/metautil/helpers_test.go b/internal/metadata/metautil/helpers_test.go
index 9eef0af4..775389f3 100644
--- a/internal/metadata/metautil/helpers_test.go
+++ b/internal/metadata/metautil/helpers_test.go
@@ -11,23 +11,91 @@ func TestReleaseCategoryFromRLS(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "empty", input: "", want: ""},
-		{name: "movie", input: "movie", want: "MOVIE"},
-		{name: "movie uppercase", input: "MOVIE", want: "MOVIE"},
-		{name: "movie title case", input: "Movie", want: "MOVIE"},
-		{name: "movie surrounding spaces", input: " movie ", want: "MOVIE"},
-		{name: "movie surrounding whitespace", input: "\tmovie\n", want: "MOVIE"},
-		{name: "episode", input: "episode", want: "TV"},
-		{name: "episode uppercase", input: "EPISODE", want: "TV"},
-		{name: "episode title case", input: "Episode", want: "TV"},
-		{name: "episode surrounding spaces", input: " episode ", want: "TV"},
-		{name: "season pack", input: "SEASONPACK", want: "TV"},
-		{name: "season pack lowercase", input: "seasonpack", want: "TV"},
-		{name: "season pack surrounding whitespace", input: "\tSEASONPACK\n", want: "TV"},
-		{name: "tv show hyphen", input: "tv-show", want: "TV"},
-		{name: "tv show hyphen uppercase", input: "TV-SHOW", want: "TV"},
-		{name: "tv show hyphen surrounding whitespace", input: " tv-show ", want: "TV"},
-		{name: "unknown", input: "documentary", want: ""},
+		{
+			name:  "empty",
+			input: "",
+			want:  "",
+		},
+		{
+			name:  "movie",
+			input: "movie",
+			want:  "MOVIE",
+		},
+		{
+			name:  "movie uppercase",
+			input: "MOVIE",
+			want:  "MOVIE",
+		},
+		{
+			name:  "movie title case",
+			input: "Movie",
+			want:  "MOVIE",
+		},
+		{
+			name:  "movie surrounding spaces",
+			input: " movie ",
+			want:  "MOVIE",
+		},
+		{
+			name:  "movie surrounding whitespace",
+			input: "\tmovie\n",
+			want:  "MOVIE",
+		},
+		{
+			name:  "episode",
+			input: "episode",
+			want:  "TV",
+		},
+		{
+			name:  "episode uppercase",
+			input: "EPISODE",
+			want:  "TV",
+		},
+		{
+			name:  "episode title case",
+			input: "Episode",
+			want:  "TV",
+		},
+		{
+			name:  "episode surrounding spaces",
+			input: " episode ",
+			want:  "TV",
+		},
+		{
+			name:  "season pack",
+			input: "SEASONPACK",
+			want:  "TV",
+		},
+		{
+			name:  "season pack lowercase",
+			input: "seasonpack",
+			want:  "TV",
+		},
+		{
+			name:  "season pack surrounding whitespace",
+			input: "\tSEASONPACK\n",
+			want:  "TV",
+		},
+		{
+			name:  "tv show hyphen",
+			input: "tv-show",
+			want:  "TV",
+		},
+		{
+			name:  "tv show hyphen uppercase",
+			input: "TV-SHOW",
+			want:  "TV",
+		},
+		{
+			name:  "tv show hyphen surrounding whitespace",
+			input: " tv-show ",
+			want:  "TV",
+		},
+		{
+			name:  "unknown",
+			input: "documentary",
+			want:  "",
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/internal/metadata/metautil/localized_test.go b/internal/metadata/metautil/localized_test.go
index 174128dc..48f22144 100644
--- a/internal/metadata/metautil/localized_test.go
+++ b/internal/metadata/metautil/localized_test.go
@@ -11,13 +11,41 @@ func TestTranslateGenreToPortuguese(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "empty", input: "", want: ""},
-		{name: "action", input: "action", want: "ação"},
-		{name: "action & adventure upper", input: "ACTION & ADVENTURE", want: "ação e aventura"},
-		{name: "drama unchanged", input: "drama", want: "drama"},
-		{name: "unknown unchanged", input: "some-unknown-genre", want: "some-unknown-genre"},
-		{name: "comedy with space", input: "  Comedy  ", want: "comédia"},
-		{name: "sci-fi", input: "sci-fi", want: "ficção científica"},
+		{
+			name:  "empty",
+			input: "",
+			want:  "",
+		},
+		{
+			name:  "action",
+			input: "action",
+			want:  "ação",
+		},
+		{
+			name:  "action & adventure upper",
+			input: "ACTION & ADVENTURE",
+			want:  "ação e aventura",
+		},
+		{
+			name:  "drama unchanged",
+			input: "drama",
+			want:  "drama",
+		},
+		{
+			name:  "unknown unchanged",
+			input: "some-unknown-genre",
+			want:  "some-unknown-genre",
+		},
+		{
+			name:  "comedy with space",
+			input: "  Comedy  ",
+			want:  "comédia",
+		},
+		{
+			name:  "sci-fi",
+			input: "sci-fi",
+			want:  "ficção científica",
+		},
 	}
 
 	for _, tt := range tests {
@@ -35,11 +63,31 @@ func TestCapitalizeGenre(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "empty", input: "", want: ""},
-		{name: "acao", input: "ação", want: "Ação"},
-		{name: "action & adventure", input: "ação e aventura", want: "Ação e aventura"},
-		{name: "comedy", input: "comedy", want: "Comedy"},
-		{name: "with spaces", input: "  drama  ", want: "Drama"},
+		{
+			name:  "empty",
+			input: "",
+			want:  "",
+		},
+		{
+			name:  "acao",
+			input: "ação",
+			want:  "Ação",
+		},
+		{
+			name:  "action & adventure",
+			input: "ação e aventura",
+			want:  "Ação e aventura",
+		},
+		{
+			name:  "comedy",
+			input: "comedy",
+			want:  "Comedy",
+		},
+		{
+			name:  "with spaces",
+			input: "  drama  ",
+			want:  "Drama",
+		},
 	}
 
 	for _, tt := range tests {
@@ -57,17 +105,61 @@ func TestTranslateGenreToPortugueseStrict(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "empty", input: "", want: ""},
-		{name: "action", input: "action", want: "ação"},
-		{name: "action & adventure upper", input: "ACTION & ADVENTURE", want: "ação e aventura"},
-		{name: "drama", input: "drama", want: "drama"},
-		{name: "unknown returns empty", input: "some-unknown-genre", want: ""},
-		{name: "comedy with space", input: "  Comedy  ", want: "comédia"},
-		{name: "sci-fi", input: "sci-fi", want: "ficção científica"},
-		{name: "adult", input: "adult", want: "adulto"},
-		{name: "film-noir", input: "Film Noir", want: "filme noir"},
-		{name: "musical", input: "musical", want: "musical"},
-		{name: "talk-show", input: "talk-show", want: "talk show"},
+		{
+			name:  "empty",
+			input: "",
+			want:  "",
+		},
+		{
+			name:  "action",
+			input: "action",
+			want:  "ação",
+		},
+		{
+			name:  "action & adventure upper",
+			input: "ACTION & ADVENTURE",
+			want:  "ação e aventura",
+		},
+		{
+			name:  "drama",
+			input: "drama",
+			want:  "drama",
+		},
+		{
+			name:  "unknown returns empty",
+			input: "some-unknown-genre",
+			want:  "",
+		},
+		{
+			name:  "comedy with space",
+			input: "  Comedy  ",
+			want:  "comédia",
+		},
+		{
+			name:  "sci-fi",
+			input: "sci-fi",
+			want:  "ficção científica",
+		},
+		{
+			name:  "adult",
+			input: "adult",
+			want:  "adulto",
+		},
+		{
+			name:  "film-noir",
+			input: "Film Noir",
+			want:  "filme noir",
+		},
+		{
+			name:  "musical",
+			input: "musical",
+			want:  "musical",
+		},
+		{
+			name:  "talk-show",
+			input: "talk-show",
+			want:  "talk show",
+		},
 	}
 
 	for _, tt := range tests {
@@ -86,11 +178,36 @@ func TestISO3166PortugueseName(t *testing.T) {
 		fallback string
 		want     string
 	}{
-		{name: "empty", code: "", fallback: "Unknown", want: "Unknown"},
-		{name: "US to PT", code: "US", fallback: "US", want: "Estados Unidos da América"},
-		{name: "US lowercase", code: "us", fallback: "US", want: "Estados Unidos da América"},
-		{name: "BR to PT", code: "BR", fallback: "BR", want: "Brasil"},
-		{name: "unknown fallback", code: "XYZ", fallback: "XYZ", want: "XYZ"},
+		{
+			name:     "empty",
+			code:     "",
+			fallback: "Unknown",
+			want:     "Unknown",
+		},
+		{
+			name:     "US to PT",
+			code:     "US",
+			fallback: "US",
+			want:     "Estados Unidos da América",
+		},
+		{
+			name:     "US lowercase",
+			code:     "us",
+			fallback: "US",
+			want:     "Estados Unidos da América",
+		},
+		{
+			name:     "BR to PT",
+			code:     "BR",
+			fallback: "BR",
+			want:     "Brasil",
+		},
+		{
+			name:     "unknown fallback",
+			code:     "XYZ",
+			fallback: "XYZ",
+			want:     "XYZ",
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/internal/metadata/naming.go b/internal/metadata/naming.go
index d2a75720..46076189 100644
--- a/internal/metadata/naming.go
+++ b/internal/metadata/naming.go
@@ -9,18 +9,26 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 var (
-	namingTVPathHintPattern     = regexp.MustCompile(`(?i)[\\/](tv|tvshows?|series)[\\/]`)
-	namingTVNameHintPattern     = regexp.MustCompile(`(?i)\bS\d{1,2}(?:E\d{1,3})?\b|\b\d{1,2}x\d{2,3}\b|\b(?:season|series)\s*\d+\b|\b(19\d{2}|20\d{2})[.-]\d{2}[.-]\d{2}\b`)
+	namingTVPathHintPattern = regexp.MustCompile(`(?i)[\\/](tv|tvshows?|series)[\\/]`)
+	namingTVNameHintPattern = regexp.MustCompile(
+		`(?i)\bS\d{1,2}(?:E\d{1,3})?\b|\b\d{1,2}x\d{2,3}\b|\b(?:season|series)\s*\d+\b|\b(19\d{2}|20\d{2})[.-]\d{2}[.-]\d{2}\b`,
+	)
 	namingSubsPleaseHintPattern = regexp.MustCompile(`(?i)subsplease`)
 	namingAnimeEpisodeHint      = regexp.MustCompile(`(?i)-\s*\d{1,3}\s*\(1080p\)`)
 	namingWebDLFilenamePattern  = regexp.MustCompile(`(?i)(^|[ ._-])web([ ._-]|$)|web-?dl`)
 )
 
+// BuildReleaseName normalizes category and format signals, applies the request's
+// manual omission controls, and builds tracker-style name variants. Unsupported
+// category/format combinations return an empty name while preserving the
+// applicable missing-field hints; a nil logger is accepted.
 func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.ReleaseNameResult {
 	if logger == nil {
 		logger = api.NopLogger{}
@@ -30,7 +38,17 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 	typeValue := strings.ToUpper(strings.TrimSpace(req.Type))
 	typeValue = normalizeReleaseTypeForCategory(category, typeValue, strings.TrimSpace(req.Source), "")
 	matchType := normalizeReleaseType(typeValue)
-	logger.Tracef("metadata: release name input category=%q type=%q normalized_type=%q source=%q season=%q episode=%q date=%q manual_date=%t", category, typeValue, matchType, strings.TrimSpace(req.Source), strings.TrimSpace(req.Season), strings.TrimSpace(req.Episode), strings.TrimSpace(req.DailyDate), req.ManualDate)
+	logger.Tracef(
+		"metadata: release name input category=%q type=%q normalized_type=%q source=%q season=%q episode=%q date=%q manual_date=%t",
+		category,
+		typeValue,
+		matchType,
+		strings.TrimSpace(req.Source),
+		strings.TrimSpace(req.Season),
+		strings.TrimSpace(req.Episode),
+		strings.TrimSpace(req.DailyDate),
+		req.ManualDate,
+	)
 	title := strings.TrimSpace(req.Title)
 	altTitle := strings.TrimSpace(req.AltTitle)
 	year := req.Year
@@ -100,7 +118,16 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 		}
 	}
 
-	logger.Tracef("metadata: release name build category=%q type=%q source=%q disc=%q title=%q season=%q episode=%q", category, matchType, source, req.DiscType, title, season, episode)
+	logger.Tracef(
+		"metadata: release name build category=%q type=%q source=%q disc=%q title=%q season=%q episode=%q",
+		category,
+		matchType,
+		source,
+		req.DiscType,
+		title,
+		season,
+		episode,
+	)
 
 	name := ""
 	missing := make([]string, 0)
@@ -150,7 +177,23 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 		case matchType == "DISC":
 			switch strings.ToUpper(strings.TrimSpace(req.DiscType)) {
 			case "BDMV":
-				name = joinParts(title, yearValue, altTitle, seasonEpisode, threeD, edition, hybrid, repack, resolution, region, uhd, source, hdr, videoCodec, audio)
+				name = joinParts(
+					title,
+					yearValue,
+					altTitle,
+					seasonEpisode,
+					threeD,
+					edition,
+					hybrid,
+					repack,
+					resolution,
+					region,
+					uhd,
+					source,
+					hdr,
+					videoCodec,
+					audio,
+				)
 				missing = []string{"edition", "region", "distributor"}
 			case "DVD":
 				name = joinParts(title, yearValue, altTitle, seasonEpisode+threeD, repack, edition, region, source, dvdSize, audio)
@@ -160,19 +203,87 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 				missing = []string{"edition", "region", "distributor"}
 			}
 		case matchType == "REMUX" && sourceIn(source, "BluRay", "HDDVD"):
-			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, threeD, edition, hybrid, repack, resolution, uhd, source, "REMUX", hdr, videoCodec, audio)
+			name = joinParts(
+				title,
+				yearValue,
+				altTitle,
+				seasonEpisode,
+				episodeTitle,
+				part,
+				threeD,
+				edition,
+				hybrid,
+				repack,
+				resolution,
+				uhd,
+				source,
+				"REMUX",
+				hdr,
+				videoCodec,
+				audio,
+			)
 			missing = []string{"edition", "description"}
 		case matchType == "REMUX" && sourceIn(source, "PAL DVD", "NTSC DVD", "DVD"):
 			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, edition, repack, source, "REMUX", audio)
 			missing = []string{"edition", "description"}
 		case matchType == "ENCODE":
-			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, edition, hybrid, repack, resolution, uhd, source, audio, hdr, videoName)
+			name = joinParts(
+				title,
+				yearValue,
+				altTitle,
+				seasonEpisode,
+				episodeTitle,
+				part,
+				edition,
+				hybrid,
+				repack,
+				resolution,
+				uhd,
+				source,
+				audio,
+				hdr,
+				videoName,
+			)
 			missing = []string{"edition", "description"}
 		case matchType == "WEBDL":
-			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, edition, hybrid, repack, resolution, uhd, service, "WEB-DL", audio, hdr, videoName)
+			name = joinParts(
+				title,
+				yearValue,
+				altTitle,
+				seasonEpisode,
+				episodeTitle,
+				part,
+				edition,
+				hybrid,
+				repack,
+				resolution,
+				uhd,
+				service,
+				"WEB-DL",
+				audio,
+				hdr,
+				videoName,
+			)
 			missing = []string{"edition", "service"}
 		case matchType == "WEBRIP":
-			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, edition, hybrid, repack, resolution, uhd, service, "WEBRip", audio, hdr, videoName)
+			name = joinParts(
+				title,
+				yearValue,
+				altTitle,
+				seasonEpisode,
+				episodeTitle,
+				part,
+				edition,
+				hybrid,
+				repack,
+				resolution,
+				uhd,
+				service,
+				"WEBRip",
+				audio,
+				hdr,
+				videoName,
+			)
 			missing = []string{"edition", "service"}
 		case matchType == "HDTV":
 			name = joinParts(title, yearValue, altTitle, seasonEpisode, episodeTitle, part, edition, repack, resolution, source, audio, videoName)
@@ -183,7 +294,14 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 
 	nameNoTag := strings.TrimSpace(name)
 	if nameNoTag == "" {
-		logger.Tracef("metadata: release name build skipped (empty base) category=%q type=%q source=%q season=%q episode=%q", category, matchType, source, season, episode)
+		logger.Tracef(
+			"metadata: release name build skipped (empty base) category=%q type=%q source=%q season=%q episode=%q",
+			category,
+			matchType,
+			source,
+			season,
+			episode,
+		)
 		return api.ReleaseNameResult{MissingFields: missing}
 	}
 	nameWithTag := strings.TrimSpace(nameNoTag + tag)
@@ -201,12 +319,12 @@ func BuildReleaseName(req api.ReleaseNameRequest, logger api.Logger) api.Release
 // releaseNameRequestFromMeta converts prepared metadata into the naming input,
 // omitting TV-pack season titles that are stored in EpisodeTitle only as scoped
 // metadata fallback text.
-func releaseNameRequestFromMeta(meta api.PreparedMetadata, logger api.Logger) api.ReleaseNameRequest {
+func releaseNameRequestFromMeta(meta preparationstate.State, logger api.Logger) api.ReleaseNameRequest {
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
 
-	category := normalizeNamingCategory(meta.ExternalIDs.Category)
+	category := normalizeNamingCategory(string(meta.Identity.Category))
 	if category == "" {
 		category = normalizeNamingCategory(meta.MediaInfoCategory)
 	}
@@ -269,14 +387,28 @@ func releaseNameRequestFromMeta(meta api.PreparedMetadata, logger api.Logger) ap
 	}
 	tvdbYearSource := ""
 	tvdbYearFromAlias := false
-	if strings.EqualFold(category, "TV") && meta.ExternalMetadata.TVDB != nil {
-		tvdbYearSource = strings.TrimSpace(meta.ExternalMetadata.TVDB.YearSource)
-		tvdbYearFromAlias = meta.ExternalMetadata.TVDB.YearFromAlias
+	if strings.EqualFold(category, "TV") && meta.ProviderMetadata.TVDB != nil {
+		tvdbYearSource = strings.TrimSpace(meta.ProviderMetadata.TVDB.YearSource)
+		tvdbYearFromAlias = meta.ProviderMetadata.TVDB.YearFromAlias
 	}
 
 	typeValue = normalizeReleaseTypeForCategory(category, typeValue, source, meta.SourcePath)
 
-	logger.Tracef("metadata: release name request resolved category=%q type=%q base_type=%q source=%q season=%q episode=%q date=%q tv_pack=%t year=%d search_year=%q year_source=%q tvdb_year_from_alias=%t", category, typeValue, baseType, source, strings.TrimSpace(meta.SeasonStr), strings.TrimSpace(meta.EpisodeStr), strings.TrimSpace(meta.DailyEpisodeDate), meta.TVPack, year, searchYear, tvdbYearSource, tvdbYearFromAlias)
+	logger.Tracef(
+		"metadata: release name request resolved category=%q type=%q base_type=%q source=%q season=%q episode=%q date=%q tv_pack=%t year=%d search_year=%q year_source=%q tvdb_year_from_alias=%t",
+		category,
+		typeValue,
+		baseType,
+		source,
+		strings.TrimSpace(meta.SeasonStr),
+		strings.TrimSpace(meta.EpisodeStr),
+		strings.TrimSpace(meta.DailyEpisodeDate),
+		meta.TVPack,
+		year,
+		searchYear,
+		tvdbYearSource,
+		tvdbYearFromAlias,
+	)
 
 	dailyDate := strings.TrimSpace(meta.DailyEpisodeDate)
 	manualDate := strings.EqualFold(category, "TV") && dailyDate != "" && !meta.TVPack
@@ -325,14 +457,14 @@ func releaseNameRequestFromMeta(meta api.PreparedMetadata, logger api.Logger) ap
 
 // resolveReleaseNameTitle selects naming fields from current matching provider
 // metadata while preserving parsed values when no eligible snapshot exists.
-func resolveReleaseNameTitle(category string, meta api.PreparedMetadata) (string, string, int) {
+func resolveReleaseNameTitle(category string, meta preparationstate.State) (string, string, int) {
 	title := strings.TrimSpace(meta.Release.Title)
 	altTitle := strings.TrimSpace(meta.Release.Alt)
 	year := meta.Release.Year
 	isTV := strings.EqualFold(strings.TrimSpace(category), "TV")
 
 	if isTV && matchingTVDBMetadataForNaming(meta) {
-		tvdb := meta.ExternalMetadata.TVDB
+		tvdb := meta.ProviderMetadata.TVDB
 		englishTitle := strings.TrimSpace(tvdb.NameEnglish)
 		nativeTitle := strings.TrimSpace(tvdb.Name)
 		if englishTitle != "" {
@@ -351,14 +483,14 @@ func resolveReleaseNameTitle(category string, meta api.PreparedMetadata) (string
 
 	switch {
 	case matchingTMDBMetadataForNaming(meta):
-		tmdb := meta.ExternalMetadata.TMDB
+		tmdb := meta.ProviderMetadata.TMDB
 		title = strings.TrimSpace(tmdb.Title)
 		altTitle = fillProviderAlternateTitle(altTitle, title, tmdb.OriginalTitle)
 		if year == 0 && tmdb.Year > 0 {
 			year = tmdb.Year
 		}
 	case matchingIMDBMetadataForNaming(meta):
-		imdb := meta.ExternalMetadata.IMDB
+		imdb := meta.ProviderMetadata.IMDB
 		title = strings.TrimSpace(imdb.Title)
 		altTitle = fillProviderAlternateTitle(altTitle, title, imdb.AKA)
 		if year == 0 && imdb.Year > 0 {
@@ -369,32 +501,32 @@ func resolveReleaseNameTitle(category string, meta api.PreparedMetadata) (string
 }
 
 // matchingTMDBMetadataForNaming reports whether TMDB can supply the naming title.
-func matchingTMDBMetadataForNaming(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.TMDB
-	return namingProviderMetadataCurrent(meta) && value != nil && meta.ExternalIDs.TMDBID > 0 &&
-		value.TMDBID == meta.ExternalIDs.TMDBID && strings.TrimSpace(value.Title) != ""
+func matchingTMDBMetadataForNaming(meta preparationstate.State) bool {
+	value := meta.ProviderMetadata.TMDB
+	return namingProviderMetadataCurrent(meta) && value != nil && meta.Identity.TMDBID > 0 &&
+		value.TMDBID == meta.Identity.TMDBID && strings.TrimSpace(value.Title) != ""
 }
 
 // matchingIMDBMetadataForNaming reports whether IMDb can supply the naming title.
-func matchingIMDBMetadataForNaming(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.IMDB
-	return namingProviderMetadataCurrent(meta) && value != nil && meta.ExternalIDs.IMDBID > 0 &&
-		value.IMDBID == meta.ExternalIDs.IMDBID && strings.TrimSpace(value.Title) != ""
+func matchingIMDBMetadataForNaming(meta preparationstate.State) bool {
+	value := meta.ProviderMetadata.IMDB
+	return namingProviderMetadataCurrent(meta) && value != nil && meta.Identity.IMDBID > 0 &&
+		value.IMDBID == meta.Identity.IMDBID && strings.TrimSpace(value.Title) != ""
 }
 
 // matchingTVDBMetadataForNaming reports whether TVDB can supply the TV naming title.
-func matchingTVDBMetadataForNaming(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.TVDB
-	return namingProviderMetadataCurrent(meta) && value != nil && meta.ExternalIDs.TVDBID > 0 &&
-		value.TVDBID == meta.ExternalIDs.TVDBID &&
+func matchingTVDBMetadataForNaming(meta preparationstate.State) bool {
+	value := meta.ProviderMetadata.TVDB
+	return namingProviderMetadataCurrent(meta) && value != nil && meta.Identity.TVDBID > 0 &&
+		value.TVDBID == meta.Identity.TVDBID &&
 		(strings.TrimSpace(value.NameEnglish) != "" || strings.TrimSpace(value.Name) != "")
 }
 
 // namingProviderMetadataCurrent reports whether both provider IDs and snapshots
 // are unscoped or belong to the prepared source.
-func namingProviderMetadataCurrent(meta api.PreparedMetadata) bool {
-	return namingSourceMatches(meta.ExternalIDs.SourcePath, meta.SourcePath) &&
-		namingSourceMatches(meta.ExternalMetadata.SourcePath, meta.SourcePath)
+func namingProviderMetadataCurrent(meta preparationstate.State) bool {
+	return namingSourceMatches(meta.Identity.SourcePath, meta.SourcePath) &&
+		namingSourceMatches(meta.ProviderMetadata.SourcePath, meta.SourcePath)
 }
 
 // namingSourceMatches accepts legacy unscoped data and case-insensitive source matches.
@@ -578,8 +710,8 @@ func normalizeCategoryFromType(value string) string {
 	return normalizeNamingCategory(value)
 }
 
-func inferCategoryFromMetadata(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TVDB != nil || meta.ExternalMetadata.TVmaze != nil {
+func inferCategoryFromMetadata(meta preparationstate.State) string {
+	if meta.ProviderMetadata.TVDB != nil || meta.ProviderMetadata.TVmaze != nil {
 		return "TV"
 	}
 	if meta.HasTVSeasonEpisodeSignal() {
diff --git a/internal/metadata/naming_test.go b/internal/metadata/naming_test.go
index 8ce2ce42..361aa763 100644
--- a/internal/metadata/naming_test.go
+++ b/internal/metadata/naming_test.go
@@ -8,6 +8,8 @@ import (
 	"strings"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -149,8 +151,8 @@ func TestApplyReleaseNameOverrides(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaDefaultsToDailyForTVEpisode(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:      api.ExternalIDs{Category: "TV"},
+	meta := preparationstate.State{
+		Identity:         api.ExternalIdentity{Category: "TV"},
 		Release:          api.ReleaseInfo{Title: "Example Show", Resolution: "1080p"},
 		Type:             "WEBDL",
 		Source:           "Web",
@@ -174,9 +176,9 @@ func TestReleaseNameRequestFromMetaDefaultsToDailyForTVEpisode(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaOmitsSeriesTitleEpisodeTitle(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 2},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 2},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TVDB: &api.TVDBMetadata{TVDBID: 2, NameEnglish: "Re: ZERO, Starting Life in Another World"},
 		},
 		Type:         "ENCODE",
@@ -197,8 +199,12 @@ func TestReleaseNameRequestFromMetaOmitsSeriesTitleEpisodeTitle(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaTVPackOmitsSeasonTitle(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TMDBID: 1, TVDBID: 2},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			TMDBID:   1,
+			TVDBID:   2,
+		},
 		Release: api.ReleaseInfo{
 			Title:      "Example Spy Show",
 			Resolution: "2160p",
@@ -232,7 +238,7 @@ func TestReleaseNameRequestFromMetaTVPackOmitsSeasonTitle(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaFallsBackMovieCategory(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\2026 - Example Movie [DVD9.PAL]`,
 		DiscType:   "DVD",
 		Type:       "DISC",
@@ -266,7 +272,7 @@ func TestReleaseNameRequestFromMetaIgnoresUnsupportedReleaseCategory(t *testing.
 
 	for _, tc := range testCases {
 		t.Run(tc.category, func(t *testing.T) {
-			meta := api.PreparedMetadata{
+			meta := preparationstate.State{
 				SourcePath: `D:\Movies\2026 - Example Movie [DVD9.PAL]`,
 				DiscType:   "DVD",
 				Type:       "DISC",
@@ -293,7 +299,7 @@ func TestReleaseNameRequestFromMetaIgnoresUnsupportedReleaseCategory(t *testing.
 }
 
 func TestReleaseNameRequestFromMetaInfersTVFromPath(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Shows\Example.Show.S01E01.1080p.WEB-DL`,
 		Type:       "ENCODE",
 	}
@@ -349,12 +355,27 @@ func TestBuildReleaseNameTVSeriesAliasFallsBackEncode(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitleTVDBEnglishWinsForTV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TMDBID: 1, TVDBID: 2},
-		Release:     api.ReleaseInfo{Title: "Release Name", Year: 2001},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "TMDB Name", OriginalTitle: "TMDB Original", Year: 2010},
-			TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "TVDB Native", NameEnglish: "TVDB English", Year: 2012, YearFromAlias: true},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			TMDBID:   1,
+			TVDBID:   2,
+		},
+		Release: api.ReleaseInfo{Title: "Release Name", Year: 2001},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID:        1,
+				Title:         "TMDB Name",
+				OriginalTitle: "TMDB Original",
+				Year:          2010,
+			},
+			TVDB: &api.TVDBMetadata{
+				TVDBID:        2,
+				Name:          "TVDB Native",
+				NameEnglish:   "TVDB English",
+				Year:          2012,
+				YearFromAlias: true,
+			},
 		},
 	}
 
@@ -371,12 +392,25 @@ func TestResolveReleaseNameTitleTVDBEnglishWinsForTV(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitleTVDBFallsBackToOriginalWhenEnglishMissing(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TMDBID: 1, TVDBID: 2},
-		Release:     api.ReleaseInfo{Title: "Release Name", Year: 2001},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "TMDB Name", OriginalTitle: "TMDB Original", Year: 2010},
-			TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "TVDB Native", Year: 2012},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			TMDBID:   1,
+			TVDBID:   2,
+		},
+		Release: api.ReleaseInfo{Title: "Release Name", Year: 2001},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID:        1,
+				Title:         "TMDB Name",
+				OriginalTitle: "TMDB Original",
+				Year:          2010,
+			},
+			TVDB: &api.TVDBMetadata{
+				TVDBID: 2,
+				Name:   "TVDB Native",
+				Year:   2012,
+			},
 		},
 	}
 
@@ -393,17 +427,22 @@ func TestResolveReleaseNameTitleTVDBFallsBackToOriginalWhenEnglishMissing(t *tes
 }
 
 func TestReleaseNameRequestFromMetaMovieUsesIMDbWithoutTMDB(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  `D:\Movies\Parsed.Title.2026.1080p.BluRay.x264-GRP.mkv`,
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
+		Identity:    api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
 		Type:        "ENCODE",
 		Source:      "BluRay",
 		Audio:       "AAC 2.0",
 		VideoEncode: "x264",
 		Tag:         "-GRP",
 		Release:     api.ReleaseInfo{Title: "Parsed Title", Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "IMDb Title", AKA: "Original Title", Year: 2026},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "IMDb Title",
+				AKA:    "Original Title",
+				Year:   2026,
+			},
 		},
 	}
 
@@ -425,17 +464,30 @@ func TestResolveReleaseNameTitleProviderAlternateRules(t *testing.T) {
 		wantAlt    string
 	}{
 		{name: "same as title", imdbAKA: "IMDb Title"},
-		{name: "normalizes prefix", imdbAKA: "AKA Original Title", wantAlt: "AKA Original Title"},
-		{name: "preserves parsed alternate", releaseAlt: "AKA Parsed Alternate", imdbAKA: "Original Title", wantAlt: "AKA Parsed Alternate"},
+		{
+			name:    "normalizes prefix",
+			imdbAKA: "AKA Original Title",
+			wantAlt: "AKA Original Title",
+		},
+		{
+			name:       "preserves parsed alternate",
+			releaseAlt: "AKA Parsed Alternate",
+			imdbAKA:    "Original Title",
+			wantAlt:    "AKA Parsed Alternate",
+		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			meta := api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
-				Release:     api.ReleaseInfo{Title: "Parsed Title", Alt: tc.releaseAlt},
-				ExternalMetadata: api.ExternalMetadata{
-					IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "IMDb Title", AKA: tc.imdbAKA},
+			meta := preparationstate.State{
+				Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
+				Release:  api.ReleaseInfo{Title: "Parsed Title", Alt: tc.releaseAlt},
+				ProviderMetadata: api.SourceScopedMetadata{
+					IMDB: &api.IMDBMetadata{
+						IMDBID: 1234567,
+						Title:  "IMDb Title",
+						AKA:    tc.imdbAKA,
+					},
 				},
 			}
 			_, got, _ := resolveReleaseNameTitle("MOVIE", meta)
@@ -447,12 +499,26 @@ func TestResolveReleaseNameTitleProviderAlternateRules(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitlePrefersTMDBForMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE", TMDBID: 1, IMDBID: 1234567},
-		Release:     api.ReleaseInfo{Title: "Parsed Title"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "TMDB Title", OriginalTitle: "TMDB Original", Year: 2025},
-			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "IMDb Title", AKA: "IMDb Original", Year: 2026},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{
+			Category: "MOVIE",
+			TMDBID:   1,
+			IMDBID:   1234567,
+		},
+		Release: api.ReleaseInfo{Title: "Parsed Title"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID:        1,
+				Title:         "TMDB Title",
+				OriginalTitle: "TMDB Original",
+				Year:          2025,
+			},
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "IMDb Title",
+				AKA:    "IMDb Original",
+				Year:   2026,
+			},
 		},
 	}
 	title, alt, year := resolveReleaseNameTitle("MOVIE", meta)
@@ -462,11 +528,20 @@ func TestResolveReleaseNameTitlePrefersTMDBForMovie(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitleTVFallsBackFromUnusableTVDBToIMDb(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", IMDBID: 1234567, TVDBID: 2},
-		Release:     api.ReleaseInfo{Title: "Parsed Series"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "IMDb Series", AKA: "Original Series", Year: 2026},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			IMDBID:   1234567,
+			TVDBID:   2,
+		},
+		Release: api.ReleaseInfo{Title: "Parsed Series"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "IMDb Series",
+				AKA:    "Original Series",
+				Year:   2026,
+			},
 			TVDB: &api.TVDBMetadata{TVDBID: 3, NameEnglish: "Wrong Series"},
 		},
 	}
@@ -477,9 +552,9 @@ func TestResolveReleaseNameTitleTVFallsBackFromUnusableTVDBToIMDb(t *testing.T)
 }
 
 func TestReleaseNameRequestFromMetaTVUsesIMDbWithoutTVDBOrTMDB(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  `D:\Shows\Parsed.Series.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
-		ExternalIDs: api.ExternalIDs{Category: "TV", IMDBID: 1234567},
+		Identity:    api.ExternalIdentity{Category: "TV", IMDBID: 1234567},
 		Type:        "WEBDL",
 		Source:      "Web",
 		Audio:       "AAC 2.0",
@@ -488,8 +563,13 @@ func TestReleaseNameRequestFromMetaTVUsesIMDbWithoutTVDBOrTMDB(t *testing.T) {
 		EpisodeStr:  "E01",
 		Tag:         "-GRP",
 		Release:     api.ReleaseInfo{Title: "Parsed Series", Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "IMDb Series", AKA: "Original Series", Year: 2026},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "IMDb Series",
+				AKA:    "Original Series",
+				Year:   2026,
+			},
 		},
 	}
 	req := releaseNameRequestFromMeta(meta, api.NopLogger{})
@@ -503,11 +583,15 @@ func TestReleaseNameRequestFromMetaTVUsesIMDbWithoutTVDBOrTMDB(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitleIgnoresTVmazeOnlyMetadata(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVmazeID: 3},
-		Release:     api.ReleaseInfo{Title: "Parsed Series", Year: 2025},
-		ExternalMetadata: api.ExternalMetadata{
-			TVmaze: &api.TVmazeMetadata{TVmazeID: 3, Name: "TVmaze Series", Premiered: "2026-01-01"},
+	meta := preparationstate.State{
+		Identity: api.ExternalIdentity{Category: "TV", TVmazeID: 3},
+		Release:  api.ReleaseInfo{Title: "Parsed Series", Year: 2025},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVmaze: &api.TVmazeMetadata{
+				TVmazeID:  3,
+				Name:      "TVmaze Series",
+				Premiered: "2026-01-01",
+			},
 		},
 	}
 	title, alt, year := resolveReleaseNameTitle("TV", meta)
@@ -517,13 +601,22 @@ func TestResolveReleaseNameTitleIgnoresTVmazeOnlyMetadata(t *testing.T) {
 }
 
 func TestResolveReleaseNameTitleIgnoresStaleProviderMetadata(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  "current-source",
-		ExternalIDs: api.ExternalIDs{SourcePath: "current-source", Category: "MOVIE", IMDBID: 1234567},
-		Release:     api.ReleaseInfo{Title: "Parsed Title", Year: 2025},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := preparationstate.State{
+		SourcePath: "current-source",
+		Identity: api.ExternalIdentity{
+			SourcePath: "current-source",
+			Category:   "MOVIE",
+			IMDBID:     1234567,
+		},
+		Release: api.ReleaseInfo{Title: "Parsed Title", Year: 2025},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "stale-source",
-			IMDB:       &api.IMDBMetadata{IMDBID: 1234567, Title: "Stale IMDb Title", AKA: "Stale Original", Year: 2026},
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "Stale IMDb Title",
+				AKA:    "Stale Original",
+				Year:   2026,
+			},
 		},
 	}
 	title, alt, year := resolveReleaseNameTitle("MOVIE", meta)
@@ -533,17 +626,30 @@ func TestResolveReleaseNameTitleIgnoresStaleProviderMetadata(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaTVSearchYearComesFromTVDB(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  `D:\Shows\Example.Show.S01E01.1080p.BluRay.x264`,
-		ExternalIDs: api.ExternalIDs{Category: "TV", TMDBID: 1, TVDBID: 2},
+	meta := preparationstate.State{
+		SourcePath: `D:\Shows\Example.Show.S01E01.1080p.BluRay.x264`,
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			TMDBID:   1,
+			TVDBID:   2,
+		},
 		Type:        "ENCODE",
 		Source:      "BluRay",
 		Audio:       "AAC 2.0",
 		VideoEncode: "x264",
 		Release:     api.ReleaseInfo{Title: "Example Show", Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "TMDB Name", Year: 2010},
-			TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "TVDB Name", Year: 2024, YearFromAlias: true},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID: 1,
+				Title:  "TMDB Name",
+				Year:   2010,
+			},
+			TVDB: &api.TVDBMetadata{
+				TVDBID:        2,
+				Name:          "TVDB Name",
+				Year:          2024,
+				YearFromAlias: true,
+			},
 		},
 	}
 
@@ -559,9 +665,9 @@ func TestReleaseNameRequestFromMetaTVSearchYearComesFromTVDB(t *testing.T) {
 
 func TestReleaseNameRequestFromMetaTVStripsBracketedTVDBYear(t *testing.T) {
 	sourceName := "Example.Show.2024.S01.720p.NF.WEB-DL.DDP5.1.x264-GRP"
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  sourceName,
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 2},
+		Identity:    api.ExternalIdentity{Category: "TV", TVDBID: 2},
 		Type:        "WEBDL",
 		Source:      "Web",
 		Audio:       "DD+ 5.1 Atmos",
@@ -574,8 +680,13 @@ func TestReleaseNameRequestFromMetaTVStripsBracketedTVDBYear(t *testing.T) {
 			Year:       2024,
 			Resolution: "720p",
 		},
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{TVDBID: 2, NameEnglish: "Example Show (2024)", Year: 2024, YearFromAlias: true},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{
+				TVDBID:        2,
+				NameEnglish:   "Example Show (2024)",
+				Year:          2024,
+				YearFromAlias: true,
+			},
 		},
 		Tag: "-GRP",
 	}
@@ -595,16 +706,20 @@ func TestReleaseNameRequestFromMetaTVStripsBracketedTVDBYear(t *testing.T) {
 }
 
 func TestReleaseNameRequestFromMetaTVOmitsSearchYearWhenTVDBYearNotAliasDerived(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath:  `D:\Shows\Example.Show.S01E01.1080p.BluRay.x264`,
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 2},
+		Identity:    api.ExternalIdentity{Category: "TV", TVDBID: 2},
 		Type:        "ENCODE",
 		Source:      "BluRay",
 		Audio:       "AAC 2.0",
 		VideoEncode: "x264",
 		Release:     api.ReleaseInfo{Title: "Example Show", Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "TVDB Name", Year: 2024},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{
+				TVDBID: 2,
+				Name:   "TVDB Name",
+				Year:   2024,
+			},
 		},
 	}
 
@@ -615,14 +730,19 @@ func TestReleaseNameRequestFromMetaTVOmitsSearchYearWhenTVDBYearNotAliasDerived(
 }
 
 func TestReleaseNameRequestFromMetaLogsTVDBYearSource(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  `D:\Shows\Example.Show.S01E01.1080p.BluRay.x264`,
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 2},
-		Type:        "ENCODE",
-		Source:      "BluRay",
-		Release:     api.ReleaseInfo{Title: "Example Show", Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "TVDB Name", Year: 2024, YearSource: "first_aired"},
+	meta := preparationstate.State{
+		SourcePath: `D:\Shows\Example.Show.S01E01.1080p.BluRay.x264`,
+		Identity:   api.ExternalIdentity{Category: "TV", TVDBID: 2},
+		Type:       "ENCODE",
+		Source:     "BluRay",
+		Release:    api.ReleaseInfo{Title: "Example Show", Resolution: "1080p"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{
+				TVDBID:     2,
+				Name:       "TVDB Name",
+				Year:       2024,
+				YearSource: "first_aired",
+			},
 		},
 	}
 	logger := &captureLogger{}
@@ -683,20 +803,24 @@ func TestBuildReleaseNameTVStripsDuplicateParentheticalSearchYear(t *testing.T)
 }
 
 func TestReleaseNameRequestFromMetaMovieKeepsParsedYearWhenTVDBMetadataPresent(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourcePath:  `D:\Movies\Example.Movie.2026.720p.BluRay.x264-GRP.mkv`,
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE", TMDBID: 1},
-		Type:        "ENCODE",
-		Source:      "BluRay",
-		Audio:       "DD 5.1",
-		VideoCodec:  "AVC",
+	meta := preparationstate.State{
+		SourcePath: `D:\Movies\Example.Movie.2026.720p.BluRay.x264-GRP.mkv`,
+		Identity:   api.ExternalIdentity{Category: "MOVIE", TMDBID: 1},
+		Type:       "ENCODE",
+		Source:     "BluRay",
+		Audio:      "DD 5.1",
+		VideoCodec: "AVC",
 		Release: api.ReleaseInfo{
 			Title:      "Example Movie",
 			Year:       2026,
 			Resolution: "720p",
 		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Movie", Year: 2026},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID: 1,
+				Title:  "Example Movie",
+				Year:   2026,
+			},
 			TVDB: &api.TVDBMetadata{},
 		},
 	}
diff --git a/internal/metadata/overrides.go b/internal/metadata/overrides.go
index ef4016c4..854f2529 100644
--- a/internal/metadata/overrides.go
+++ b/internal/metadata/overrides.go
@@ -49,6 +49,9 @@ func (b *boolString) UnmarshalJSON(data []byte) error {
 	return errors.New("personalrelease: invalid value")
 }
 
+// ApplyTagOverrides resolves a release tag and its optional naming overrides
+// from tagsPath. An empty path or missing file is a no-op; read and JSON errors
+// preserve currentTag. In-name and explicit-tag matches are case-sensitive.
 func ApplyTagOverrides(path, currentTag, tagsPath string) (string, *api.TagOverride, error) {
 	if strings.TrimSpace(tagsPath) == "" {
 		return currentTag, nil, nil
diff --git a/internal/metadata/playlist_selection.go b/internal/metadata/playlist_selection.go
new file mode 100644
index 00000000..91cf67f0
--- /dev/null
+++ b/internal/metadata/playlist_selection.go
@@ -0,0 +1,134 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/filesystem"
+	"github.com/autobrr/upbrr/internal/metadata/discparse"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// resolveBDMVPlaylistSelection resolves a direct or remembered selection only
+// against playlists discovered from the current BDMV resource root.
+func (s *Service) resolveBDMVPlaylistSelection(ctx context.Context, request preparationstate.Request) ([]api.PlaylistInfo, error) {
+	bdmvRoot := strings.TrimSpace(request.Layout.BDMVRoot)
+	if bdmvRoot == "" {
+		return nil, fmt.Errorf("metadata: BDMV resource root is unavailable: %w", internalerrors.ErrInvalidInput)
+	}
+	discovered, err := discoverBDMVPlaylists(ctx, bdmvRoot)
+	if err != nil {
+		return nil, fmt.Errorf("metadata: discover BDMV playlists: %w", err)
+	}
+
+	instruction := request.Input.Instructions.Playlist
+	selected := append([]string(nil), instruction.Selected...)
+	useAll := instruction.UseAll
+	if !instruction.Set {
+		stored, lookupErr := s.repo.GetPlaylistSelection(ctx, playlistSelectionKey(request.Layout.SourcePath))
+		if lookupErr != nil {
+			if errors.Is(lookupErr, internalerrors.ErrNotFound) {
+				return nil, &api.PlaylistSelectionRequiredError{SourcePath: request.Layout.SourcePath}
+			}
+			return nil, fmt.Errorf("metadata: load remembered playlist selection: %w", lookupErr)
+		}
+		selected = append([]string(nil), stored.SelectedPlaylists...)
+		useAll = stored.UseAll
+	}
+
+	if useAll {
+		return apiPlaylists(discovered), nil
+	}
+	if len(selected) == 0 {
+		return nil, &api.PlaylistSelectionRequiredError{SourcePath: request.Layout.SourcePath}
+	}
+
+	byName := make(map[string]filesystem.PlaylistInfo, len(discovered))
+	for _, playlist := range discovered {
+		byName[discparse.NormalizePlaylistName(playlist.File)] = playlist
+	}
+	seen := make(map[string]struct{}, len(selected))
+	result := make([]api.PlaylistInfo, 0, len(selected))
+	for _, raw := range selected {
+		normalized, validationErr := validatePlaylistName(raw)
+		if validationErr != nil {
+			return nil, &api.InvalidPlaylistSelectionError{
+				SourcePath: request.Layout.SourcePath,
+				Playlist:   strings.TrimSpace(raw),
+				Reason:     validationErr.Error(),
+			}
+		}
+		if _, exists := seen[normalized]; exists {
+			return nil, &api.InvalidPlaylistSelectionError{
+				SourcePath: request.Layout.SourcePath,
+				Playlist:   normalized,
+				Reason:     "duplicate playlist",
+			}
+		}
+		playlist, exists := byName[normalized]
+		if !exists {
+			return nil, &api.InvalidPlaylistSelectionError{
+				SourcePath: request.Layout.SourcePath,
+				Playlist:   normalized,
+				Reason:     "playlist was not found in the current source",
+			}
+		}
+		seen[normalized] = struct{}{}
+		result = append(result, apiPlaylist(playlist))
+	}
+	return result, nil
+}
+
+// validatePlaylistName accepts one local MPLS filename and rejects paths or traversal.
+func validatePlaylistName(value string) (string, error) {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return "", errors.New("playlist name is empty")
+	}
+	if filepath.IsAbs(trimmed) || filepath.VolumeName(trimmed) != "" || strings.ContainsAny(trimmed, `/\\`) || trimmed == "." || trimmed == ".." {
+		return "", errors.New("playlist name must be a local filename")
+	}
+	normalized := discparse.NormalizePlaylistName(trimmed)
+	if normalized == "" || !strings.EqualFold(filepath.Ext(normalized), ".MPLS") {
+		return "", errors.New("playlist name is invalid")
+	}
+	return normalized, nil
+}
+
+// playlistSelectionKey preserves the repository's slash-normalized source key.
+func playlistSelectionKey(sourcePath string) string {
+	return filepath.ToSlash(filepath.Clean(sourcePath))
+}
+
+// apiPlaylists projects discovered filesystem playlists into detached API values.
+func apiPlaylists(values []filesystem.PlaylistInfo) []api.PlaylistInfo {
+	result := make([]api.PlaylistInfo, 0, len(values))
+	for _, value := range values {
+		result = append(result, apiPlaylist(value))
+	}
+	return result
+}
+
+// apiPlaylist projects one filesystem playlist and detaches its item list.
+func apiPlaylist(value filesystem.PlaylistInfo) api.PlaylistInfo {
+	items := make([]api.PlaylistItem, 0, len(value.Items))
+	for _, item := range value.Items {
+		items = append(items, api.PlaylistItem{File: item.File, Size: item.Size})
+	}
+	return api.PlaylistInfo{
+		File:     value.File,
+		Duration: value.Duration,
+		Items:    items,
+		Score:    value.Score,
+		Edition:  value.Edition,
+	}
+}
diff --git a/internal/metadata/release.go b/internal/metadata/release.go
index 43650aef..0df8280d 100644
--- a/internal/metadata/release.go
+++ b/internal/metadata/release.go
@@ -6,14 +6,19 @@ package metadata
 import (
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/moistari/rls"
 
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
 	"github.com/autobrr/upbrr/internal/metadata/seasonep"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// ParseReleaseInfo parses the host-path basename into detached release fields.
+// It derives the release format separately from the movie/TV category and fills
+// missing season or episode values from the basename fallback parser.
 func ParseReleaseInfo(path string) api.ReleaseInfo {
 	trimmed := strings.TrimSpace(path)
 	if trimmed == "" {
@@ -32,7 +37,7 @@ func ParseReleaseInfo(path string) api.ReleaseInfo {
 	season := release.Series
 	episode := release.Episode
 	if season == 0 || episode == 0 {
-		extracted := seasonep.Extract(base, api.PreparedMetadata{})
+		extracted := seasonep.Extract(base, preparationstate.State{})
 		if season == 0 {
 			season = extracted.Season
 		}
diff --git a/internal/metadata/scene.go b/internal/metadata/scene.go
index 7377823d..8e5cf06f 100644
--- a/internal/metadata/scene.go
+++ b/internal/metadata/scene.go
@@ -18,7 +18,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -27,7 +29,7 @@ const srrdbBaseURL = "https://api.srrdb.com"
 // SceneDetector resolves scene metadata from a prepared item. Implementations
 // may return a populated result with an error when an optional side effect fails.
 type SceneDetector interface {
-	Detect(ctx context.Context, meta api.PreparedMetadata) (SceneResult, error)
+	Detect(ctx context.Context, meta preparationstate.State) (SceneResult, error)
 }
 
 // SceneResult captures scene metadata from external sources. NFO fields are
@@ -166,7 +168,7 @@ func (c sceneCandidates) primaryLocalBase() string {
 // paths. VideoPath is the primary media file; SourcePath is the release root — a
 // folder for folder releases (its basename is the canonical dotted name) or the
 // media file itself for single-file releases.
-func sceneLocalCandidates(meta api.PreparedMetadata) sceneCandidates {
+func sceneLocalCandidates(meta preparationstate.State) sceneCandidates {
 	video := strings.TrimSpace(meta.VideoPath)
 	source := strings.TrimSpace(meta.SourcePath)
 	var c sceneCandidates
@@ -199,14 +201,20 @@ func sceneLocalCandidates(meta api.PreparedMetadata) sceneCandidates {
 	return c
 }
 
-func (d *srrdbDetector) Detect(ctx context.Context, meta api.PreparedMetadata) (SceneResult, error) {
+func (d *srrdbDetector) Detect(ctx context.Context, meta preparationstate.State) (SceneResult, error) {
 	cands := sceneLocalCandidates(meta)
 	if cands.empty() {
 		d.log().Tracef("metadata: scene detection skipped: no local candidates")
 		return SceneResult{}, nil
 	}
 	imdbID := sceneIMDbID(meta)
-	d.log().Debugf("metadata: scene detection start imdb=%d folders=%d files=%d media_present=%t", imdbID, len(cands.folders), len(cands.files), strings.TrimSpace(cands.mediaFilename) != "")
+	d.log().Debugf(
+		"metadata: scene detection start imdb=%d folders=%d files=%d media_present=%t",
+		imdbID,
+		len(cands.folders),
+		len(cands.files),
+		strings.TrimSpace(cands.mediaFilename) != "",
+	)
 
 	// For TV releases, a word:<title SxxEyy|Sxx> search is the cheapest
 	// high-signal path and avoids broad IMDb fan-out on long-running shows. TV
@@ -235,7 +243,7 @@ func (d *srrdbDetector) Detect(ctx context.Context, meta api.PreparedMetadata) (
 // detectViaTVWord runs the low-fan-out SRRDB word search for parsed TV releases.
 // It returns no match when the metadata cannot form a title/season query. Network
 // and decode failures are soft unless they are context cancellation.
-func (d *srrdbDetector) detectViaTVWord(ctx context.Context, meta api.PreparedMetadata, cands sceneCandidates) (SceneResult, error) {
+func (d *srrdbDetector) detectViaTVWord(ctx context.Context, meta preparationstate.State, cands sceneCandidates) (SceneResult, error) {
 	query := srrdbTVWordQuery(meta)
 	if query == "" {
 		return SceneResult{}, nil
@@ -257,7 +265,13 @@ func (d *srrdbDetector) detectViaTVWord(ctx context.Context, meta api.PreparedMe
 
 	best, source := selectSceneRelease(meta, cands, releases)
 	if best == nil {
-		d.log().Debugf("metadata: scene word no confident candidate query=%q candidates=%d folders=%d files=%d", query, len(releases), len(cands.folders), len(cands.files))
+		d.log().Debugf(
+			"metadata: scene word no confident candidate query=%q candidates=%d folders=%d files=%d",
+			query,
+			len(releases),
+			len(cands.folders),
+			len(cands.files),
+		)
 		return SceneResult{}, nil
 	}
 	return d.finishSceneMatch(ctx, cands, *best, source, "word")
@@ -266,7 +280,7 @@ func (d *srrdbDetector) detectViaTVWord(ctx context.Context, meta api.PreparedMe
 // detectViaIMDB lists every scene release for the title, selects the one matching
 // the local folder/filename, then verifies the media filename. Strictly
 // best-effort: every failure returns a no-match (except context cancellation).
-func (d *srrdbDetector) detectViaIMDB(ctx context.Context, meta api.PreparedMetadata, cands sceneCandidates, imdbID int) (SceneResult, error) {
+func (d *srrdbDetector) detectViaIMDB(ctx context.Context, meta preparationstate.State, cands sceneCandidates, imdbID int) (SceneResult, error) {
 	d.log().Tracef("metadata: scene imdb search start imdb=%d", imdbID)
 	releases, err := d.fetchIMDBReleases(ctx, meta, imdbID)
 	if err != nil {
@@ -284,7 +298,13 @@ func (d *srrdbDetector) detectViaIMDB(ctx context.Context, meta api.PreparedMeta
 
 	best, source := selectSceneRelease(meta, cands, releases)
 	if best == nil {
-		d.log().Debugf("metadata: scene imdb no confident candidate imdb=%d candidates=%d folders=%d files=%d", imdbID, len(releases), len(cands.folders), len(cands.files))
+		d.log().Debugf(
+			"metadata: scene imdb no confident candidate imdb=%d candidates=%d folders=%d files=%d",
+			imdbID,
+			len(releases),
+			len(cands.folders),
+			len(cands.files),
+		)
 		return SceneResult{}, nil
 	}
 	return d.finishSceneMatch(ctx, cands, *best, source, "imdb")
@@ -383,7 +403,7 @@ func (d *srrdbDetector) searchWord(ctx context.Context, query string) ([]srrdbSe
 // case-insensitive equality (only for selecting the right release when local
 // casing differs): exact folder match, then exact filename/release-name match,
 // then metadata scoring to break ties / reject weak candidates.
-func selectSceneRelease(meta api.PreparedMetadata, cands sceneCandidates, releases []srrdbSearchResult) (*srrdbSearchResult, string) {
+func selectSceneRelease(meta preparationstate.State, cands sceneCandidates, releases []srrdbSearchResult) (*srrdbSearchResult, string) {
 	for _, folder := range cands.folders {
 		for i := range releases {
 			if strings.EqualFold(strings.TrimSpace(releases[i].Release), folder) {
@@ -413,7 +433,16 @@ func (d *srrdbDetector) finishSceneMatch(ctx context.Context, cands sceneCandida
 		reason = sceneRenamedReason
 		d.log().Infof("metadata: scene release renamed or modified via=%s", matchSource)
 	}
-	d.log().Debugf("metadata: scene matched mode=%s via=%s release=%q folders=%v media=%q has_nfo=%t renamed=%t", mode, matchSource, release.Release, cands.folders, cands.mediaFilename, strings.EqualFold(release.HasNFO, "yes"), renamed)
+	d.log().Debugf(
+		"metadata: scene matched mode=%s via=%s release=%q folders=%v media=%q has_nfo=%t renamed=%t",
+		mode,
+		matchSource,
+		release.Release,
+		cands.folders,
+		cands.mediaFilename,
+		strings.EqualFold(release.HasNFO, "yes"),
+		renamed,
+	)
 	return d.buildSceneResult(ctx, release, renamed, reason)
 }
 
@@ -455,7 +484,15 @@ func (d *srrdbDetector) buildSceneResult(ctx context.Context, result srrdbSearch
 				scene.MALID = nfoIDs.MALID
 				scene.Service = nfoIDs.Service
 				scene.ServiceLongName = nfoIDs.ServiceLongName
-				d.log().Tracef("metadata: scene nfo ids tmdb=%d imdb=%d tvdb=%d tvmaze=%d mal=%d service_present=%t", scene.TMDBID, scene.IMDBID, scene.TVDBID, scene.TVmazeID, scene.MALID, scene.Service != "")
+				d.log().Tracef(
+					"metadata: scene nfo ids tmdb=%d imdb=%d tvdb=%d tvmaze=%d mal=%d service_present=%t",
+					scene.TMDBID,
+					scene.IMDBID,
+					scene.TVDBID,
+					scene.TVmazeID,
+					scene.MALID,
+					scene.Service != "",
+				)
 			} else {
 				d.log().Debugf("metadata: scene nfo id parse failed: %v", readErr)
 			}
@@ -774,7 +811,13 @@ func (d *srrdbDetector) fetchNFO(ctx context.Context, release string) (string, b
 		return path, false, detailsErr
 	}
 
-	d.log().Tracef("metadata: scene nfo downloading release=%q file=%q details_nfo=%t details_error=%t", trimmed, fileBase+".nfo", detailsNFO, detailsErr != nil)
+	d.log().Tracef(
+		"metadata: scene nfo downloading release=%q file=%q details_nfo=%t details_error=%t",
+		trimmed,
+		fileBase+".nfo",
+		detailsNFO,
+		detailsErr != nil,
+	)
 	nfoURL := fmt.Sprintf("https://www.srrdb.com/download/file/%s/%s.nfo", url.PathEscape(trimmed), url.PathEscape(fileBase))
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, nfoURL, nil)
 	if err != nil {
@@ -888,15 +931,15 @@ const (
 )
 
 // sceneIMDbID returns the resolved IMDb id on meta in precedence order. Detection
-// runs in ApplyMediaDetails, after ResolveExternalIDs, so meta.ExternalIDs.IMDBID
+// runs during media-detail enrichment after identity resolution, so the canonical IMDB ID
 // is normally populated; 0 means "no id known" and the imdb: search is skipped in
 // favor of the r: fallback.
-func sceneIMDbID(meta api.PreparedMetadata) int {
+func sceneIMDbID(meta preparationstate.State) int {
 	if id := meta.ExternalIDOverrides.IMDBID; id != nil && *id > 0 {
 		return *id
 	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return meta.ExternalIDs.IMDBID
+	if meta.Identity.IMDBID > 0 {
+		return meta.Identity.IMDBID
 	}
 	if meta.ArrIMDBID > 0 {
 		return meta.ArrIMDBID
@@ -908,7 +951,7 @@ func sceneIMDbID(meta api.PreparedMetadata) int {
 // It returns "<title> SxxEyy" when an episode is known and "<title> Sxx" when
 // only the season is known. A normalized TV category, title, and season are
 // required so movie-like releases do not take the TV-only path.
-func srrdbTVWordQuery(meta api.PreparedMetadata) string {
+func srrdbTVWordQuery(meta preparationstate.State) string {
 	if !isSRRDBTVCategory(meta) {
 		return ""
 	}
@@ -928,14 +971,14 @@ func srrdbTVWordQuery(meta api.PreparedMetadata) string {
 
 // isSRRDBTVCategory reports whether scene detection should use TV-specific SRRDB
 // search behavior for the parsed release category.
-func isSRRDBTVCategory(meta api.PreparedMetadata) bool {
+func isSRRDBTVCategory(meta preparationstate.State) bool {
 	return api.NormalizeCategory(meta.Release.Category) == api.CategoryTV
 }
 
 // fetchIMDBReleases lists every scene release for an IMDb id via the imdb:
 // search, paginating up to srrdbIMDBMaxPages. The id is a validated integer, so
 // the URL cannot be influenced by parsed metadata (no SSRF surface).
-func (d *srrdbDetector) fetchIMDBReleases(ctx context.Context, meta api.PreparedMetadata, imdbID int) ([]srrdbSearchResult, error) {
+func (d *srrdbDetector) fetchIMDBReleases(ctx context.Context, meta preparationstate.State, imdbID int) ([]srrdbSearchResult, error) {
 	if imdbID <= 0 {
 		return nil, nil
 	}
@@ -962,7 +1005,7 @@ func (d *srrdbDetector) fetchIMDBReleases(ctx context.Context, meta api.Prepared
 	return all, nil
 }
 
-func (d *srrdbDetector) fetchIMDBReleasePage(ctx context.Context, meta api.PreparedMetadata, imdbID, page int) (srrdbIMDBSearchResponse, error) {
+func (d *srrdbDetector) fetchIMDBReleasePage(ctx context.Context, meta preparationstate.State, imdbID, page int) (srrdbIMDBSearchResponse, error) {
 	imdb := formatSRRDBIMDbID(imdbID)
 	if imdb == "" {
 		return srrdbIMDBSearchResponse{}, nil
@@ -992,7 +1035,7 @@ func (d *srrdbDetector) fetchIMDBReleasePage(ctx context.Context, meta api.Prepa
 // srrdbIMDBForeignFilterPath narrows the broad imdb: release listing by the
 // parsed release language. Empty or English-only release names search
 // non-foreign entries; any explicit non-English marker searches foreign entries.
-func srrdbIMDBForeignFilterPath(meta api.PreparedMetadata) string {
+func srrdbIMDBForeignFilterPath(meta preparationstate.State) string {
 	for _, language := range meta.Release.Language {
 		switch strings.ToLower(strings.TrimSpace(language)) {
 		case "":
@@ -1009,6 +1052,14 @@ func srrdbIMDBForeignFilterPath(meta api.PreparedMetadata) string {
 // sceneMediaExtensions are the archive members treated as the primary media file
 // for rename detection.
 var sceneMediaExtensions = map[string]struct{}{
-	".mkv": {}, ".mp4": {}, ".avi": {}, ".ts": {}, ".m2ts": {},
-	".vob": {}, ".iso": {}, ".wmv": {}, ".mov": {}, ".m4v": {},
+	".mkv":  {},
+	".mp4":  {},
+	".avi":  {},
+	".ts":   {},
+	".m2ts": {},
+	".vob":  {},
+	".iso":  {},
+	".wmv":  {},
+	".mov":  {},
+	".m4v":  {},
 }
diff --git a/internal/metadata/scene_scoring.go b/internal/metadata/scene_scoring.go
index 2dfd7e71..78a8f200 100644
--- a/internal/metadata/scene_scoring.go
+++ b/internal/metadata/scene_scoring.go
@@ -8,7 +8,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
 )
 
 // sceneTokenSplit breaks a release name into its dotted/spaced/underscored
@@ -39,7 +39,7 @@ var sceneForeignKeywords = []string{
 // metadata, or (nil, 0) when no candidate clears the structural eligibility bar.
 // Eligibility, not just the highest score, is what guards against
 // false-flagging a non-scene release.
-func bestSceneCandidate(meta api.PreparedMetadata, localBase string, candidates []srrdbSearchResult) (*srrdbSearchResult, int) {
+func bestSceneCandidate(meta preparationstate.State, localBase string, candidates []srrdbSearchResult) (*srrdbSearchResult, int) {
 	wantRes := sceneResolution(meta, localBase)
 	localForeign := releaseLooksForeign(meta, localBase)
 
@@ -64,7 +64,7 @@ func bestSceneCandidate(meta api.PreparedMetadata, localBase string, candidates
 // scoreSceneCandidate scores one candidate against the effective release tokens.
 // Eligibility is false for structural conflicts such as resolution mismatch,
 // known-group mismatch, foreign-language mismatch, or edition mismatch.
-func scoreSceneCandidate(meta api.PreparedMetadata, wantRes string, localForeign bool, cand srrdbSearchResult) (int, bool) {
+func scoreSceneCandidate(meta preparationstate.State, wantRes string, localForeign bool, cand srrdbSearchResult) (int, bool) {
 	tokens := sceneTokens(cand.Release)
 	score := 0
 
@@ -143,7 +143,7 @@ func scoreSceneCandidate(meta api.PreparedMetadata, wantRes string, localForeign
 
 // sceneResolution returns the normalized resolution available after media
 // details and release-name overrides, falling back to the local name when needed.
-func sceneResolution(meta api.PreparedMetadata, localBase string) string {
+func sceneResolution(meta preparationstate.State, localBase string) string {
 	if meta.ReleaseNameOverrides.Resolution != nil {
 		if resolution := strings.ToLower(strings.TrimSpace(*meta.ReleaseNameOverrides.Resolution)); resolution != "" {
 			return resolution
@@ -165,7 +165,7 @@ func sceneResolution(meta api.PreparedMetadata, localBase string) string {
 
 // sceneYear returns the best title year known after tracker, Arr, and external
 // metadata enrichment. Parsed filename year is only one possible source.
-func sceneYear(meta api.PreparedMetadata) int {
+func sceneYear(meta preparationstate.State) int {
 	if meta.ReleaseNameOverrides.ManualYear != nil && *meta.ReleaseNameOverrides.ManualYear > 0 {
 		return *meta.ReleaseNameOverrides.ManualYear
 	}
@@ -175,17 +175,17 @@ func sceneYear(meta api.PreparedMetadata) int {
 	if meta.ArrYear > 0 {
 		return meta.ArrYear
 	}
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		return meta.ExternalMetadata.TMDB.Year
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		return meta.ProviderMetadata.TMDB.Year
 	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		return meta.ExternalMetadata.IMDB.Year
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		return meta.ProviderMetadata.IMDB.Year
 	}
-	if meta.ExternalMetadata.TVDB != nil && meta.ExternalMetadata.TVDB.Year > 0 {
-		return meta.ExternalMetadata.TVDB.Year
+	if meta.ProviderMetadata.TVDB != nil && meta.ProviderMetadata.TVDB.Year > 0 {
+		return meta.ProviderMetadata.TVDB.Year
 	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		return parseSceneYearPrefix(meta.ExternalMetadata.TVmaze.Premiered)
+	if meta.ProviderMetadata.TVmaze != nil {
+		return parseSceneYearPrefix(meta.ProviderMetadata.TVmaze.Premiered)
 	}
 	return 0
 }
@@ -206,7 +206,7 @@ func parseSceneYearPrefix(value string) int {
 
 // sceneSource returns the source label used for scoring, preferring manual
 // release-name overrides before the normalized media source and parsed source.
-func sceneSource(meta api.PreparedMetadata) string {
+func sceneSource(meta preparationstate.State) string {
 	if meta.ReleaseNameOverrides.Source != nil {
 		if source := strings.TrimSpace(*meta.ReleaseNameOverrides.Source); source != "" {
 			return source
@@ -220,7 +220,7 @@ func sceneSource(meta api.PreparedMetadata) string {
 
 // sceneCodecs returns every codec-like token known after media analysis so
 // parsed filename codecs and MediaInfo-derived codecs can both influence ties.
-func sceneCodecs(meta api.PreparedMetadata) []string {
+func sceneCodecs(meta preparationstate.State) []string {
 	values := make([]string, 0, len(meta.Release.Codec)+2)
 	values = append(values, meta.Release.Codec...)
 	values = append(values, meta.VideoEncode, meta.VideoCodec)
@@ -229,7 +229,7 @@ func sceneCodecs(meta api.PreparedMetadata) []string {
 
 // sceneEditions returns the effective edition markers for mismatch checks,
 // preferring manual naming overrides before normalized and parsed editions.
-func sceneEditions(meta api.PreparedMetadata) []string {
+func sceneEditions(meta preparationstate.State) []string {
 	if meta.ReleaseNameOverrides.Edition != nil {
 		if edition := strings.TrimSpace(*meta.ReleaseNameOverrides.Edition); edition != "" {
 			return []string{edition}
@@ -288,7 +288,7 @@ func scoreEditions(localEditions []string, tokens map[string]struct{}) (score in
 // releaseLooksForeign reports whether the local release is itself a
 // foreign-language/dub variant, so that foreign candidates are preferred rather
 // than penalised for it.
-func releaseLooksForeign(meta api.PreparedMetadata, localBase string) bool {
+func releaseLooksForeign(meta preparationstate.State, localBase string) bool {
 	// Parsed language metadata is authoritative when present: a non-English entry
 	// means foreign, and an English-only set means not foreign — the name-token
 	// heuristic below must not override it (e.g. a "dual"/"multi" token on an
@@ -321,7 +321,7 @@ func releaseLooksForeign(meta api.PreparedMetadata, localBase string) bool {
 // sceneGroup resolves the effective release group used for scene matching.
 // Manual release-name tag overrides win over parsed groups, because they also
 // drive the rebuilt upload name.
-func sceneGroup(meta api.PreparedMetadata) string {
+func sceneGroup(meta preparationstate.State) string {
 	if meta.ReleaseNameOverrides.Tag != nil {
 		return strings.TrimPrefix(strings.TrimSpace(*meta.ReleaseNameOverrides.Tag), "-")
 	}
diff --git a/internal/metadata/scene_scoring_test.go b/internal/metadata/scene_scoring_test.go
index 3b69df44..f59b91a8 100644
--- a/internal/metadata/scene_scoring_test.go
+++ b/internal/metadata/scene_scoring_test.go
@@ -7,6 +7,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -16,7 +18,7 @@ func TestBestSceneCandidate(t *testing.T) {
 	manualTag := "-GRP"
 	cases := []struct {
 		name      string
-		meta      api.PreparedMetadata
+		meta      preparationstate.State
 		release   api.ReleaseInfo
 		tag       string
 		overrides api.ReleaseNameOverrides
@@ -25,8 +27,14 @@ func TestBestSceneCandidate(t *testing.T) {
 		wantPick  string // "" means expect no confident match
 	}{
 		{
-			name:      "exact tokens (renamed dots to spaces) match",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "GRP", Source: "BluRay", Codec: []string{"x264"}},
+			name: "exact tokens (renamed dots to spaces) match",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "GRP",
+				Source:     "BluRay",
+				Codec:      []string{"x264"},
+			},
 			localBase: "Example Movie 2026 1080p BluRay x264 GRP",
 			cands: []srrdbSearchResult{
 				// Same title at a different resolution must not be matched.
@@ -36,8 +44,13 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Example.Movie.2026.1080p.BluRay.x264-GRP",
 		},
 		{
-			name:      "foreign dub is not chosen for an english release",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "GRP", Language: []string{"English"}},
+			name: "foreign dub is not chosen for an english release",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "GRP",
+				Language:   []string{"English"},
+			},
 			localBase: "Example Drama 2026 1080p BluRay x264 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Example.Drama.2026.German.DL.1080p.BluRay.x264-GRP", IsForeign: "yes"},
@@ -46,8 +59,12 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Example.Drama.2026.1080p.BluRay.x264-GRP",
 		},
 		{
-			name:      "multi-edition prefers the matching theatrical cut",
-			release:   api.ReleaseInfo{Resolution: "2160p", Year: 2014, Group: "GRP"},
+			name: "multi-edition prefers the matching theatrical cut",
+			release: api.ReleaseInfo{
+				Resolution: "2160p",
+				Year:       2014,
+				Group:      "GRP",
+			},
 			localBase: "Movie 2014 2160p BluRay x265 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Movie.2014.Extended.2160p.BluRay.x265-GRP"},
@@ -56,8 +73,13 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Movie.2014.2160p.BluRay.x265-GRP",
 		},
 		{
-			name:      "multi-edition prefers the matching extended cut",
-			release:   api.ReleaseInfo{Resolution: "2160p", Year: 2014, Group: "GRP", Edition: []string{"Extended"}},
+			name: "multi-edition prefers the matching extended cut",
+			release: api.ReleaseInfo{
+				Resolution: "2160p",
+				Year:       2014,
+				Group:      "GRP",
+				Edition:    []string{"Extended"},
+			},
 			localBase: "Movie 2014 Extended 2160p BluRay x265 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Movie.2014.2160p.BluRay.x265-GRP"},
@@ -66,8 +88,12 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Movie.2014.Extended.2160p.BluRay.x265-GRP",
 		},
 		{
-			name:      "season pack matches on resolution and group without a year",
-			release:   api.ReleaseInfo{Resolution: "1080p", Group: "GRP", Source: "WEB-DL"},
+			name: "season pack matches on resolution and group without a year",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Group:      "GRP",
+				Source:     "WEB-DL",
+			},
 			localBase: "Show S01 1080p WEB-DL GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Show.S01.1080p.WEB-DL.DDP5.1.H.264-GRP"},
@@ -76,8 +102,14 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Show.S01.1080p.WEB-DL.DDP5.1.H.264-GRP",
 		},
 		{
-			name:      "english web-dl is not misclassified as a foreign dub",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "GRP", Source: "WEB-DL", Language: []string{"English"}},
+			name: "english web-dl is not misclassified as a foreign dub",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "GRP",
+				Source:     "WEB-DL",
+				Language:   []string{"English"},
+			},
 			localBase: "Movie 2026 1080p WEB-DL DDP5 1 H 264 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Movie.2026.German.DL.1080p.BluRay.x264-GRP", IsForeign: "yes"},
@@ -95,8 +127,14 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "",
 		},
 		{
-			name:      "known local group must match candidate group",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "EXAMPLE", Source: "WEB-DL", Codec: []string{"H.264"}},
+			name: "known local group must match candidate group",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "EXAMPLE",
+				Source:     "WEB-DL",
+				Codec:      []string{"H.264"},
+			},
 			localBase: "Example Sports Movie 2026 1080p AMZN WEB-DL DD+ 5.1 H.264-EXAMPLE",
 			cands: []srrdbSearchResult{
 				{Release: "Example.Sports.Movie.2026.1080p.WEB.H264-OTHER", IsForeign: "no"},
@@ -104,8 +142,14 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "",
 		},
 		{
-			name:      "known local group match is case-insensitive",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "example", Source: "WEB-DL", Codec: []string{"H.264"}},
+			name: "known local group match is case-insensitive",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "example",
+				Source:     "WEB-DL",
+				Codec:      []string{"H.264"},
+			},
 			localBase: "Movie 2026 1080p WEB-DL H.264-example",
 			cands: []srrdbSearchResult{
 				{Release: "Movie.2026.1080p.WEB-DL.H.264-EXAMPLE", IsForeign: "no"},
@@ -113,8 +157,14 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Movie.2026.1080p.WEB-DL.H.264-EXAMPLE",
 		},
 		{
-			name:      "manual tag override wins over parsed filename group",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "example", Source: "BluRay", Codec: []string{"x264"}},
+			name: "manual tag override wins over parsed filename group",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2026,
+				Group:      "example",
+				Source:     "BluRay",
+				Codec:      []string{"x264"},
+			},
 			tag:       "-example",
 			overrides: api.ReleaseNameOverrides{Tag: &manualTag},
 			localBase: "renamed-example",
@@ -125,9 +175,9 @@ func TestBestSceneCandidate(t *testing.T) {
 		},
 		{
 			name: "external metadata year participates when parser year is missing",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				Release:          api.ReleaseInfo{Resolution: "1080p"},
-				ExternalMetadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{Year: 2026}},
+				ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Year: 2026}},
 			},
 			localBase: "renamed-example",
 			cands: []srrdbSearchResult{
@@ -137,9 +187,9 @@ func TestBestSceneCandidate(t *testing.T) {
 		},
 		{
 			name: "media-derived codec participates when parser codec is missing",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				Release:          api.ReleaseInfo{Resolution: "1080p"},
-				ExternalMetadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{Year: 2026}},
+				ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Year: 2026}},
 				VideoEncode:      "x264",
 			},
 			localBase: "Example Driver 2026 1080p",
@@ -150,8 +200,12 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "Example.Driver.2026.1080p.BluRay.x264-GRP",
 		},
 		{
-			name:      "no candidate at the right resolution is not matched",
-			release:   api.ReleaseInfo{Resolution: "2160p", Year: 2014, Group: "GRP"},
+			name: "no candidate at the right resolution is not matched",
+			release: api.ReleaseInfo{
+				Resolution: "2160p",
+				Year:       2014,
+				Group:      "GRP",
+			},
 			localBase: "Movie 2014 2160p BluRay x265 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Movie.2014.1080p.BluRay.x264-GRP"},
@@ -160,8 +214,12 @@ func TestBestSceneCandidate(t *testing.T) {
 			wantPick: "",
 		},
 		{
-			name:      "wrong year and group is not matched",
-			release:   api.ReleaseInfo{Resolution: "1080p", Year: 2014, Group: "GRP"},
+			name: "wrong year and group is not matched",
+			release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Year:       2014,
+				Group:      "GRP",
+			},
 			localBase: "Movie 2014 1080p BluRay x264 GRP",
 			cands: []srrdbSearchResult{
 				{Release: "Different.Movie.1999.1080p.BluRay.x264-OTHER"},
@@ -173,14 +231,18 @@ func TestBestSceneCandidate(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			meta := api.PreparedMetadata{Release: tc.release, Tag: tc.tag, ReleaseNameOverrides: tc.overrides}
+			meta := preparationstate.State{
+				Release:              tc.release,
+				Tag:                  tc.tag,
+				ReleaseNameOverrides: tc.overrides,
+			}
 			if tc.meta.SourcePath != "" ||
 				tc.meta.VideoPath != "" ||
 				tc.meta.Release.Resolution != "" ||
-				tc.meta.ExternalMetadata.TMDB != nil ||
-				tc.meta.ExternalMetadata.IMDB != nil ||
-				tc.meta.ExternalMetadata.TVDB != nil ||
-				tc.meta.ExternalMetadata.TVmaze != nil ||
+				tc.meta.ProviderMetadata.TMDB != nil ||
+				tc.meta.ProviderMetadata.IMDB != nil ||
+				tc.meta.ProviderMetadata.TVDB != nil ||
+				tc.meta.ProviderMetadata.TVmaze != nil ||
 				tc.meta.VideoEncode != "" ||
 				tc.meta.VideoCodec != "" {
 				meta = tc.meta
@@ -296,7 +358,7 @@ func TestSceneLocalCandidates(t *testing.T) {
 
 	// Folder release: SourcePath is the release folder, VideoPath the media file.
 	const folder = "Example.Driver.2026.1080p.BluRay.x264-GRP"
-	c := sceneLocalCandidates(api.PreparedMetadata{
+	c := sceneLocalCandidates(preparationstate.State{
 		SourcePath: filepath.Join(base, folder),
 		VideoPath:  filepath.Join(base, folder, "renamed-example.mkv"),
 	})
@@ -312,7 +374,7 @@ func TestSceneLocalCandidates(t *testing.T) {
 
 	// Single-file release: SourcePath == VideoPath, no folder candidate.
 	singlePath := filepath.Join(base, "movie.2020.1080p.bluray.x264-grp.mkv")
-	single := sceneLocalCandidates(api.PreparedMetadata{SourcePath: singlePath, VideoPath: singlePath})
+	single := sceneLocalCandidates(preparationstate.State{SourcePath: singlePath, VideoPath: singlePath})
 	if len(single.folders) != 0 {
 		t.Fatalf("single-file folder candidates = %v, want none", single.folders)
 	}
diff --git a/internal/metadata/scene_test.go b/internal/metadata/scene_test.go
index a97cc714..3c58aef6 100644
--- a/internal/metadata/scene_test.go
+++ b/internal/metadata/scene_test.go
@@ -17,6 +17,8 @@ import (
 	"sync/atomic"
 	"testing"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -57,7 +59,7 @@ func TestSceneDetectorSRRDB(t *testing.T) {
 	nfoDir := t.TempDir()
 	detector := newSRRDBDetector(server.Client(), server.URL, cacheDir, nfoDir)
 
-	meta := api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"}
+	meta := preparationstate.State{VideoPath: "/data/Example.Release.mkv"}
 	result, err := detector.Detect(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("Detect error: %v", err)
@@ -91,7 +93,7 @@ func TestSceneDetectorSRRDBFetchesIMDbWhenSearchOmitsIt(t *testing.T) {
 	nfoDir := t.TempDir()
 	detector := newSRRDBDetector(server.Client(), server.URL, cacheDir, nfoDir)
 
-	meta := api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"}
+	meta := preparationstate.State{VideoPath: "/data/Example.Release.mkv"}
 	result, err := detector.Detect(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("Detect error: %v", err)
@@ -139,7 +141,7 @@ func TestSceneDetectorSRRDBLogsNFODownloadLifecycle(t *testing.T) {
 	detector := newSRRDBDetector(client, server.URL, t.TempDir(), t.TempDir())
 	detector.logger = logger
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err != nil {
 		t.Fatalf("Detect error: %v", err)
 	}
@@ -180,7 +182,7 @@ func TestSceneDetectorSRRDBNFOFetchFailurePreservesMatch(t *testing.T) {
 
 	detector := newSRRDBDetector(client, server.URL, t.TempDir(), t.TempDir())
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err == nil {
 		t.Fatalf("expected NFO fetch failure to be returned")
 	}
@@ -229,7 +231,7 @@ func TestSceneDetectorSRRDBDetailsFailureDirectNFOSuccessPreservesWarning(t *tes
 	nfoDir := t.TempDir()
 	detector := newSRRDBDetector(client, server.URL, t.TempDir(), nfoDir)
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err == nil {
 		t.Fatalf("expected details failure to remain visible")
 	}
@@ -273,7 +275,7 @@ func TestSceneDetectorSRRDBDetailsAndNFOFailuresPreserveBothCauses(t *testing.T)
 
 	detector := newSRRDBDetector(client, server.URL, t.TempDir(), t.TempDir())
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err == nil {
 		t.Fatalf("expected details and NFO failures to be returned")
 	}
@@ -308,7 +310,7 @@ func TestSceneDetectorSRRDBNFOFailurePreservesMatch(t *testing.T) {
 	}
 	detector := newSRRDBDetector(server.Client(), server.URL, cacheDir, nfoDir)
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err == nil {
 		t.Fatalf("expected NFO save failure to be returned")
 	} else if !strings.Contains(err.Error(), "scene: nfo dir") {
@@ -344,7 +346,7 @@ func TestSceneDetectorSRRDBDetailsFailureCachedNFOPreservesWarning(t *testing.T)
 	}
 	detector := newSRRDBDetector(server.Client(), server.URL, cacheDir, nfoDir)
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err == nil {
 		t.Fatalf("expected details failure to remain visible")
 	}
@@ -377,7 +379,7 @@ func TestSceneDetectorSRRDBCachedNFOPreservesAttachment(t *testing.T) {
 	}
 	detector := newSRRDBDetector(server.Client(), server.URL, cacheDir, nfoDir)
 
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err != nil {
 		t.Fatalf("Detect error: %v", err)
 	}
@@ -414,7 +416,7 @@ func TestSceneDetectorSRRDBNFOContextCancellationIsFatal(t *testing.T) {
 
 	detector := newSRRDBDetector(client, server.URL, t.TempDir(), t.TempDir())
 
-	result, err := detector.Detect(ctx, api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(ctx, preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation, got result=%#v err=%v", result, err)
 	}
@@ -495,10 +497,10 @@ func (h srrdbFallbackHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
 	}
 }
 
-func renamedSceneMeta(videoPath string) api.PreparedMetadata {
-	return api.PreparedMetadata{
-		VideoPath:   videoPath,
-		ExternalIDs: api.ExternalIDs{IMDBID: 1234567},
+func renamedSceneMeta(videoPath string) preparationstate.State {
+	return preparationstate.State{
+		VideoPath: videoPath,
+		Identity:  api.ExternalIdentity{IMDBID: 1234567},
 		Release: api.ReleaseInfo{
 			Resolution: "1080p",
 			Year:       2026,
@@ -614,11 +616,18 @@ func TestSceneDetectorFolderMatchDetectsRenamedFile(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
-		SourcePath:  "/data/Example.Driver.2026.1080p.BluRay.x264-GRP",
-		VideoPath:   "/data/Example.Driver.2026.1080p.BluRay.x264-GRP/example-driver-renamed.mkv",
-		ExternalIDs: api.ExternalIDs{IMDBID: 12345},
-		Release:     api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "GRP", Source: "BluRay", Codec: []string{"x264"}, Language: []string{"English"}},
+	meta := preparationstate.State{
+		SourcePath: "/data/Example.Driver.2026.1080p.BluRay.x264-GRP",
+		VideoPath:  "/data/Example.Driver.2026.1080p.BluRay.x264-GRP/example-driver-renamed.mkv",
+		Identity:   api.ExternalIdentity{IMDBID: 12345},
+		Release: api.ReleaseInfo{
+			Resolution: "1080p",
+			Year:       2026,
+			Group:      "GRP",
+			Source:     "BluRay",
+			Codec:      []string{"x264"},
+			Language:   []string{"English"},
+		},
 	}
 	detector := newSRRDBDetector(server.Client(), server.URL, t.TempDir(), t.TempDir())
 	result, err := detector.Detect(context.Background(), meta)
@@ -695,9 +704,9 @@ func TestSceneDetectorTVWordSearchRunsBeforeIMDBFallback(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
-		VideoPath:   "/data/" + release + ".mkv",
-		ExternalIDs: api.ExternalIDs{IMDBID: 1234567},
+	meta := preparationstate.State{
+		VideoPath: "/data/" + release + ".mkv",
+		Identity:  api.ExternalIdentity{IMDBID: 1234567},
 		Release: api.ReleaseInfo{
 			Category:   "TV",
 			Title:      "Example Show",
@@ -747,9 +756,9 @@ func TestSceneDetectorTVWordSearchAllowsSeasonOnly(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
-		VideoPath:   "/data/" + release + ".mkv",
-		ExternalIDs: api.ExternalIDs{IMDBID: 1234567},
+	meta := preparationstate.State{
+		VideoPath: "/data/" + release + ".mkv",
+		Identity:  api.ExternalIdentity{IMDBID: 1234567},
 		Release: api.ReleaseInfo{
 			Category:   "TV",
 			Title:      "Example Show",
@@ -799,9 +808,9 @@ func TestSceneDetectorTVWordMissSkipsIMDBFallback(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
-		VideoPath:   "/data/" + release + ".mkv",
-		ExternalIDs: api.ExternalIDs{IMDBID: 1234567},
+	meta := preparationstate.State{
+		VideoPath: "/data/" + release + ".mkv",
+		Identity:  api.ExternalIdentity{IMDBID: 1234567},
 		Release: api.ReleaseInfo{
 			Category:   "TV",
 			Title:      "Example Show",
@@ -946,7 +955,7 @@ func TestSceneDetectorRSearchSoftFailsOnNetworkError(t *testing.T) {
 	detector := newSRRDBDetector(client, "https://api.srrdb.com", t.TempDir(), t.TempDir())
 
 	meta := renamedSceneMeta("/data/Example Movie 2026 1080p BluRay x264 GRP.mkv")
-	meta.ExternalIDs = api.ExternalIDs{} // force the r: fallback path
+	meta.Identity = api.ExternalIdentity{} // force the r: fallback path
 	result, err := detector.Detect(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("expected soft-fail (nil error) on r: network error, got %v", err)
@@ -971,7 +980,7 @@ func TestSceneDetectorRFallbackFolderFirstWhenNoIMDb(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: "/data/" + release,
 		VideoPath:  "/data/" + release + "/example.driver.2026.1080p.bluray.x264-grp.mkv",
 	}
@@ -998,7 +1007,7 @@ func TestSceneDetectorRSearchSoftFailsOnMalformedBody(t *testing.T) {
 	t.Cleanup(server.Close)
 
 	detector := newSRRDBDetector(server.Client(), server.URL, t.TempDir(), t.TempDir())
-	result, err := detector.Detect(context.Background(), api.PreparedMetadata{VideoPath: "/data/Example.Release.mkv"})
+	result, err := detector.Detect(context.Background(), preparationstate.State{VideoPath: "/data/Example.Release.mkv"})
 	if err != nil {
 		t.Fatalf("expected soft-fail (nil error) on malformed r: body, got %v", err)
 	}
@@ -1015,7 +1024,7 @@ func TestSceneDetectorIMDBFallbackSkippedWithoutIMDbID(t *testing.T) {
 
 	detector := newSRRDBDetector(server.Client(), server.URL, t.TempDir(), t.TempDir())
 	meta := renamedSceneMeta("/data/Example Movie 2026 1080p BluRay x264 GRP.mkv")
-	meta.ExternalIDs = api.ExternalIDs{} // no known id at detect time
+	meta.Identity = api.ExternalIdentity{} // no known id at detect time
 	result, err := detector.Detect(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("Detect error: %v", err)
@@ -1046,11 +1055,15 @@ func TestSceneDetectorFallsBackToRWhenIMDbFindsNoMatch(t *testing.T) {
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	meta := api.PreparedMetadata{
-		SourcePath:  "/data/" + release,
-		VideoPath:   "/data/" + release + "/example.driver.2026.1080p.bluray.x264-grp.mkv",
-		ExternalIDs: api.ExternalIDs{IMDBID: 12345},
-		Release:     api.ReleaseInfo{Resolution: "1080p", Year: 2026, Group: "GRP"},
+	meta := preparationstate.State{
+		SourcePath: "/data/" + release,
+		VideoPath:  "/data/" + release + "/example.driver.2026.1080p.bluray.x264-grp.mkv",
+		Identity:   api.ExternalIdentity{IMDBID: 12345},
+		Release: api.ReleaseInfo{
+			Resolution: "1080p",
+			Year:       2026,
+			Group:      "GRP",
+		},
 	}
 	detector := newSRRDBDetector(server.Client(), server.URL, t.TempDir(), t.TempDir())
 	result, err := detector.Detect(context.Background(), meta)
diff --git a/internal/metadata/seasonep/seasonep.go b/internal/metadata/seasonep/seasonep.go
index 1fc0b02e..e7d8ea32 100644
--- a/internal/metadata/seasonep/seasonep.go
+++ b/internal/metadata/seasonep/seasonep.go
@@ -12,8 +12,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 )
 
 var (
@@ -31,9 +32,22 @@ var (
 )
 
 var videoExtensions = map[string]struct{}{
-	".mkv": {}, ".mp4": {}, ".avi": {}, ".mov": {}, ".wmv": {}, ".webm": {}, ".ts": {}, ".m2ts": {}, ".m2v": {}, ".mpg": {}, ".mpeg": {},
+	".mkv":  {},
+	".mp4":  {},
+	".avi":  {},
+	".mov":  {},
+	".wmv":  {},
+	".webm": {},
+	".ts":   {},
+	".m2ts": {},
+	".m2v":  {},
+	".mpg":  {},
+	".mpeg": {},
 }
 
+// Result contains normalized episodic signals. DailyDate uses YYYY-MM-DD;
+// MultiEpisode includes the first episode; AbsoluteEpisode is retained even
+// when it also supplies Episode.
 type Result struct {
 	Season          int
 	Episode         int
@@ -43,7 +57,12 @@ type Result struct {
 	MultiEpisode    []int
 }
 
-func Extract(path string, meta api.PreparedMetadata) Result {
+// Extract parses the source basename before the selected video basename, then
+// fills missing values from parsed release metadata. Season-only or multi-video
+// sources become TV packs unless the primary basename names one explicit
+// episode. Directory inspection is best-effort and filesystem errors are
+// treated as no multi-video evidence.
+func Extract(path string, meta preparationstate.State) Result {
 	candidates := buildCandidates(path, meta)
 	primaryCandidate := ""
 	if len(candidates) > 0 {
@@ -129,7 +148,7 @@ func FormatEpisode(value int) string {
 	return fmt.Sprintf("E%02d", value)
 }
 
-func buildCandidates(path string, meta api.PreparedMetadata) []string {
+func buildCandidates(path string, meta preparationstate.State) []string {
 	seen := map[string]struct{}{}
 	out := make([]string, 0, 2)
 	add := func(value string) {
diff --git a/internal/metadata/seasonep/seasonep_test.go b/internal/metadata/seasonep/seasonep_test.go
index b3a3cbf9..5bcb85db 100644
--- a/internal/metadata/seasonep/seasonep_test.go
+++ b/internal/metadata/seasonep/seasonep_test.go
@@ -9,7 +9,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
 )
 
 func TestExtract(t *testing.T) {
@@ -46,7 +46,7 @@ func TestExtract(t *testing.T) {
 	tests := []struct {
 		name    string
 		path    string
-		meta    api.PreparedMetadata
+		meta    preparationstate.State
 		want    Result
 		wantMul []int
 	}{
@@ -66,7 +66,7 @@ func TestExtract(t *testing.T) {
 		{
 			name: "season pack",
 			path: tvPackDir,
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				VideoPath: first,
 				FileList:  []string{first, second},
 			},
@@ -75,7 +75,7 @@ func TestExtract(t *testing.T) {
 		{
 			name: "season pack keeps pack semantics with multi-token video path",
 			path: multiTokenDir,
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				VideoPath: multiFirst,
 				FileList:  []string{multiFirst, multiSecond},
 			},
diff --git a/internal/metadata/service.go b/internal/metadata/service.go
index 45677838..5483bc05 100644
--- a/internal/metadata/service.go
+++ b/internal/metadata/service.go
@@ -15,6 +15,9 @@ import (
 	"strings"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/clientdiscovery"
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/filesystem"
@@ -23,16 +26,19 @@ import (
 	"github.com/autobrr/upbrr/internal/metadata/mediainfo"
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
 	"github.com/autobrr/upbrr/internal/metadata/seasonep"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/bdinfo"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerdata"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Service collects source-scoped metadata evidence for canonical preparation.
+// Optional providers and client discovery are installed through [Option] values.
 type Service struct {
-	repo     db.MetadataRepository
+	repo     repository
 	tagsPath string
 	scene    SceneDetector
 	mi       mediainfo.Exporter
@@ -50,6 +56,23 @@ type Service struct {
 	radarr   ArrLookupClient
 	tracker  TrackerDataLookup
 	bluray   *bluraycom.Client
+	registry *trackers.Registry
+	clients  *clientdiscovery.Module
+}
+
+type repository interface {
+	GetByPath(context.Context, string) (api.FileMetadata, error)
+	Save(context.Context, api.FileMetadata) error
+	GetExternalIdentity(context.Context, string) (api.ExternalIdentity, error)
+	GetExternalMetadata(context.Context, string) (api.SourceScopedMetadata, error)
+	SaveDVDMediaInfo(context.Context, api.DVDMediaInfo) error
+	GetReleaseNameOverrides(context.Context, string) (api.ReleaseNameOverrides, error)
+	SaveReleaseNameOverrides(context.Context, string, api.ReleaseNameOverrides) error
+	GetPlaylistSelection(context.Context, string) (api.PlaylistSelection, error)
+	GetTrackerTimestamp(context.Context, string) (time.Time, error)
+	SaveTrackerTimestamp(context.Context, api.TrackerTimestamp) error
+	SaveTrackerMetadata(context.Context, api.TrackerMetadata) error
+	SaveTrackerRuleFailures(context.Context, string, string, []api.TrackerRuleFailure) error
 }
 
 type cachedBDMVSummary struct {
@@ -82,54 +105,82 @@ var (
 	}
 )
 
+// TrackerDataLookup provides optional remote enrichment for one tracker
+// candidate. Implementations receive the operation's ID-only and image-retention
+// policy; persistence and cross-tracker selection remain owned by [Service].
 type TrackerDataLookup interface {
 	Lookup(
 		ctx context.Context,
 		tracker string,
 		trackerID string,
-		meta api.PreparedMetadata,
+		subject api.UploadSubject,
 		searchFileName string,
 		onlyID bool,
 		keepImages bool,
 	) (trackerdata.Result, error)
 }
 
+// ArrLookupClient returns non-authoritative source-path evidence from an Arr
+// service. An empty result means the source was not matched.
 type ArrLookupClient interface {
-	Lookup(ctx context.Context, meta api.PreparedMetadata) (ArrLookupResult, error)
+	Lookup(ctx context.Context, meta preparationstate.State) (ArrLookupResult, error)
 }
 
+// Option configures a Service during construction. Options run in caller order;
+// later options may replace earlier dependencies.
 type Option func(*Service)
 
+// WithTagsPathFromDB derives the optional tag-override file from dbPath.
 func WithTagsPathFromDB(dbPath string) Option {
 	return func(s *Service) {
 		s.tagsPath = resolveTagsPath(dbPath)
 	}
 }
 
+// WithSceneDetector installs an explicit detector. A non-nil detector is used
+// even when configured scene detection is disabled; nil permits the
+// config-gated default.
 func WithSceneDetector(detector SceneDetector) Option {
 	return func(s *Service) {
 		s.scene = detector
 	}
 }
 
+// WithLogger installs the service logger; nil is normalized to [api.NopLogger].
 func WithLogger(logger api.Logger) Option {
 	return func(s *Service) {
 		s.logger = logger
 	}
 }
 
+// WithMediaInfoExporter installs the MediaInfo exporter; nil permits the
+// construction-time default.
 func WithMediaInfoExporter(exporter mediainfo.Exporter) Option {
 	return func(s *Service) {
 		s.mi = exporter
 	}
 }
 
+// WithConfig copies cfg for provider, path, and policy decisions.
 func WithConfig(cfg config.Config) Option {
 	return func(s *Service) {
 		s.cfg = cfg
 	}
 }
 
+// WithTrackerRegistry supplies tracker policies and factories and enables the
+// default tracker-data client when no explicit lookup is installed.
+func WithTrackerRegistry(registry *trackers.Registry) Option {
+	return func(s *Service) { s.registry = registry }
+}
+
+// WithClientDiscovery installs canonical preparation-time client discovery.
+func WithClientDiscovery(discovery *clientdiscovery.Module) Option {
+	return func(s *Service) { s.clients = discovery }
+}
+
+// WithTMDBClient also installs client as the AniList provider when it implements
+// [AniListClient] and no earlier option supplied one.
 func WithTMDBClient(client TMDBClient) Option {
 	return func(s *Service) {
 		s.tmdb = client
@@ -139,6 +190,8 @@ func WithTMDBClient(client TMDBClient) Option {
 	}
 }
 
+// WithAniListClient explicitly replaces the current AniList provider, including
+// one inferred by an earlier [WithTMDBClient] option.
 func WithAniListClient(client AniListClient) Option {
 	return func(s *Service) {
 		s.anilist = client
@@ -193,6 +246,8 @@ func WithBlurayClient(client *bluraycom.Client) Option {
 	}
 }
 
+// WithSRRDBPaths derives the scene cache and NFO directories from dbPath and may
+// create the private cache directory during construction.
 func WithSRRDBPaths(dbPath string) Option {
 	return func(s *Service) {
 		cacheDir, nfoDir := resolveSRRDBPaths(dbPath)
@@ -201,7 +256,10 @@ func WithSRRDBPaths(dbPath string) Option {
 	}
 }
 
-func NewService(repo db.MetadataRepository, opts ...Option) *Service {
+// NewService applies non-nil options in order, then installs default logging,
+// MediaInfo, configured scene detection, tracker lookup, and Blu-ray providers.
+// Resolving default scene paths may create private cache directories.
+func NewService(repo repository, opts ...Option) *Service {
 	service := &Service{repo: repo, logger: api.NopLogger{}}
 	for _, opt := range opts {
 		if opt != nil {
@@ -230,8 +288,8 @@ func NewService(repo db.MetadataRepository, opts ...Option) *Service {
 		detector.logger = service.logger
 		service.scene = detector
 	}
-	if service.tracker == nil {
-		service.tracker = trackerdata.NewClient(service.cfg, service.logger, nil)
+	if service.tracker == nil && service.registry != nil {
+		service.tracker = trackerdata.NewClientWithRegistry(service.cfg, service.logger, nil, service.registry)
 	}
 	if service.bluray == nil {
 		service.bluray = bluraycom.NewClient(nil, service.logger)
@@ -280,177 +338,144 @@ func cloneTrackerIDs(values map[string]string) map[string]string {
 	return cloned
 }
 
-func applyTorrentOverridesToPreparedMeta(meta *api.PreparedMetadata) {
-	if meta == nil {
-		return
-	}
-
-	if meta.TorrentOverrides.InfoHash != nil {
-		meta.InfoHash = strings.ToLower(strings.TrimSpace(*meta.TorrentOverrides.InfoHash))
-	}
-}
-
-func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.PreparedMetadata, err error) {
+// collectSourceEvidence validates source resources, resolves Blu-ray selection,
+// and gathers filesystem evidence before provider and client enrichment.
+func (s *Service) collectSourceEvidence(ctx context.Context, request preparationstate.Request) (meta preparationstate.State, err error) {
+	bdinfoActive := false
+	bdinfoTerminal := false
 	defer func() {
 		if err != nil {
+			if bdinfoActive && !bdinfoTerminal {
+				api.EmitPreparationProgress(
+					ctx,
+					api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressFailed, "Blu-ray analysis failed."),
+				)
+			}
 			s.logger.Warnf("metadata: preparation blocked err=%s", redaction.RedactValue(err.Error(), nil))
 		}
 	}()
 
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
-	s.logger.Debugf("metadata: preparing metadata for %d paths", len(req.Paths))
-
-	if len(req.Paths) == 0 {
-		return api.PreparedMetadata{}, internalerrors.ErrInvalidInput
-	}
+	s.logger.Debugf("metadata: preparing source")
 	if s.repo == nil {
-		return api.PreparedMetadata{}, errors.New("metadata: repository not configured")
+		return preparationstate.State{}, errors.New("metadata: repository not configured")
 	}
 
-	primary := strings.TrimSpace(req.Paths[0])
+	input := request.Input
+	primary := strings.TrimSpace(request.Layout.SourcePath)
 	if primary == "" {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: empty primary path: %w", internalerrors.ErrInvalidInput)
+		return preparationstate.State{}, fmt.Errorf("metadata: empty primary path: %w", internalerrors.ErrInvalidInput)
 	}
 
 	absPath, err := filepath.Abs(primary)
 	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: resolve path: %w", err)
+		return preparationstate.State{}, fmt.Errorf("metadata: resolve path: %w", err)
 	}
 	primary = absPath
 	s.logger.Debugf("metadata: primary path resolved to %s", primary)
 
-	normalizedPaths := make([]string, 0, len(req.Paths))
-	seenPaths := make(map[string]struct{}, len(req.Paths))
-	for _, value := range req.Paths {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: empty path: %w", internalerrors.ErrInvalidInput)
-		}
-		abs, err := filepath.Abs(trimmed)
-		if err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: resolve path: %w", err)
-		}
-		if _, exists := seenPaths[abs]; exists {
-			continue
-		}
-		seenPaths[abs] = struct{}{}
-		normalizedPaths = append(normalizedPaths, abs)
-		s.logger.Tracef("metadata: normalized path %s", abs)
-	}
-
-	meta = api.PreparedMetadata{
-		SourcePath:             primary,
-		SourceLookupURL:        strings.TrimSpace(req.SourceLookupURL),
-		Paths:                  normalizedPaths,
-		Mode:                   req.Mode,
-		Trackers:               append([]string{}, req.Trackers...),
-		Options:                req.Options,
-		TrackersRemove:         append([]string{}, req.TrackersRemove...),
-		TrackerIDs:             cloneTrackerIDs(req.TrackerIDOverrides),
-		DescriptionOverride:    strings.TrimSpace(req.DescriptionOverrideRaw),
-		MetadataOverrides:      req.MetadataOverrides,
-		TrackerConfigOverrides: req.TrackerConfigOverrides,
-		TrackerSiteOverrides:   req.TrackerSiteOverrides,
-		ClientOverrides:        req.ClientOverrides,
-		ImageHostOverrides:     req.ImageHostOverrides,
-		ScreenshotOverrides:    normalizeScreenshotOverrides(req.ScreenshotOverrides),
-		TorrentOverrides:       req.TorrentOverrides,
-		ExternalIDOverrides:    req.ExternalIDOverrides,
-		ReleaseNameOverrides:   req.ReleaseNameOverrides,
-	}
-	applyTorrentOverridesToPreparedMeta(&meta)
-	applySourceLookupOverride(&meta)
+	normalizedPaths := []string{primary}
+	s.logger.Tracef("metadata: normalized path %s", primary)
+
+	meta = preparationstate.State{
+		SourcePath:      primary,
+		SourceLookupURL: strings.TrimSpace(input.Instructions.SourceLookup),
+		Paths:           normalizedPaths,
+		Policy: preparationstate.CollectionPolicy{
+			OnlyID:          input.Policy.OnlyID,
+			KeepFolder:      input.Policy.KeepFolder,
+			KeepImages:      input.Policy.KeepImages,
+			InteractionMode: input.Controls.Interaction,
+		},
+		TrackerIDs:           cloneTrackerIDs(input.Instructions.TrackerIDs),
+		MetadataOverrides:    input.Instructions.Metadata,
+		ExternalIDOverrides:  input.Instructions.Identity,
+		ReleaseNameOverrides: input.Instructions.ReleaseName,
+	}
+	applySourceLookupOverrideWithRegistry(&meta, s.registry)
 	meta.Release = ParseReleaseInfo(primary)
 
-	discType, err := filesystem.DetectDiscType(ctx, primary)
-	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: detect disc: %w", err)
-	}
+	discType := request.Layout.DiscType
 	meta.DiscType = discType
 	if discType != "" {
 		s.logger.Debugf("metadata: detected disc type %s", discType)
 	}
 
 	// For BDMV discs, check if a playlist was selected
-	if discType == "BDMV" && s.repo != nil {
-		var sel db.PlaylistSelection
-		var playlistPath string
-		var found bool
-
+	if discType == "BDMV" {
 		s.logger.Debugf("metadata: checking playlist selection, bdinfo=%v", s.bdinfo != nil)
-
-		// Normalize primary path for DB lookup (must match normalized save path)
-		primaryNorm := filepath.ToSlash(filepath.Clean(primary))
-		bdmvNorm := filepath.ToSlash(filepath.Clean(filepath.Join(primary, "BDMV")))
-
-		s.logger.Debugf("metadata: querying playlist selection for normalized path: %s", primaryNorm)
-
-		// Try normalized primary path first
-		if result, err := s.repo.GetPlaylistSelection(ctx, primaryNorm); err == nil && len(result.SelectedPlaylists) > 0 {
-			sel = result
-			playlistPath = primary // Use original path for file operations
-			found = true
-			s.logger.Debugf("metadata: found playlist selection at normalized primary path: %s", primaryNorm)
-		} else {
-			// Try normalized BDMV path
-			s.logger.Debugf("metadata: querying playlist selection for normalized BDMV path: %s", bdmvNorm)
-			if result, err := s.repo.GetPlaylistSelection(ctx, bdmvNorm); err == nil && len(result.SelectedPlaylists) > 0 {
-				sel = result
-				playlistPath = filepath.Join(primary, "BDMV")
-				found = true
-				s.logger.Debugf("metadata: found playlist selection at normalized BDMV path: %s", bdmvNorm)
-			} else {
-				s.logger.Debugf("metadata: no playlist selection found, err=%s", redaction.RedactValue(fmt.Sprint(err), nil))
-			}
+		selectedPlaylists, derr := s.resolveBDMVPlaylistSelection(ctx, request)
+		if derr != nil {
+			return preparationstate.State{}, derr
 		}
-
-		if found && len(sel.SelectedPlaylists) > 0 {
-			s.logger.Debugf("metadata: found playlist selection playlists=%d path=%s", len(sel.SelectedPlaylists), playlistPath)
-			selectedPlaylists, derr := loadSelectedBDMVPlaylists(ctx, playlistPath, sel.SelectedPlaylists)
-			if derr != nil {
-				return api.PreparedMetadata{}, fmt.Errorf("metadata: discover selected playlists: %w", derr)
-			}
-			meta.SelectedBDMVPlaylists = selectedPlaylists
+		meta.SelectedBDMVPlaylists = selectedPlaylists
+		if len(selectedPlaylists) > 0 {
+			playlistPath := request.Layout.BDMVRoot
+			s.logger.Debugf("metadata: resolved playlist selection playlists=%d", len(selectedPlaylists))
 			selectedPlaylistNames := playlistNames(meta.SelectedBDMVPlaylists)
 
 			// Execute BDInfo on selected playlists
 			if s.bdinfo != nil {
+				bdinfoActive = true
+				api.EmitPreparationProgress(
+					ctx,
+					api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressRunning, "Preparing Blu-ray analysis."),
+				)
 				tmpRoot, rerr := db.Subdir(s.cfg.MainSettings.DBPath, "tmp")
 				if rerr != nil {
-					return api.PreparedMetadata{}, fmt.Errorf("metadata: resolve tmp root: %w", rerr)
+					bdinfoTerminal = true
+					api.EmitPreparationProgress(
+						ctx,
+						api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressFailed, "Blu-ray analysis failed."),
+					)
+					return preparationstate.State{}, fmt.Errorf("metadata: resolve tmp root: %w", rerr)
 				}
 				tmpDir, _, rerr := paths.ReleaseTempDir(tmpRoot, meta, primary)
 				if rerr != nil {
-					return api.PreparedMetadata{}, fmt.Errorf("metadata: resolve bdinfo temp dir: %w", rerr)
+					return preparationstate.State{}, fmt.Errorf("metadata: resolve bdinfo temp dir: %w", rerr)
 				}
 				s.logger.Debugf("metadata: bdinfo temp dir: %s", tmpDir)
 				if err := os.MkdirAll(tmpDir, 0755); err != nil {
-					return api.PreparedMetadata{}, fmt.Errorf("metadata: create bdinfo temp dir: %w", err)
+					return preparationstate.State{}, fmt.Errorf("metadata: create bdinfo temp dir: %w", err)
 				}
 
-				outputPath, needScan, berr := s.resolveOrCreateBDMVSummaries(ctx, req, tmpDir, playlistPath, selectedPlaylistNames)
+				outputPath, needScan, berr := s.resolveOrCreateBDMVSummaries(ctx, input, tmpDir, playlistPath, selectedPlaylistNames)
 				if berr != nil {
-					return api.PreparedMetadata{}, berr
+					bdinfoTerminal = true
+					api.EmitPreparationProgress(
+						ctx,
+						api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressFailed, "Blu-ray analysis failed."),
+					)
+					return preparationstate.State{}, berr
 				}
 				if strings.TrimSpace(outputPath) != "" {
 					s.logger.Debugf("metadata: parsing canonical bdinfo output from %s", outputPath)
 					bdinfoParsed, perr := parseBDInfoOutput(s.bdinfo, outputPath)
 					if perr != nil {
-						return api.PreparedMetadata{}, fmt.Errorf("metadata: bdinfo parse failed: %w", perr)
+						return preparationstate.State{}, fmt.Errorf("metadata: bdinfo parse failed: %w", perr)
 					}
 					meta.BDInfo = bdinfoParsed
 					s.logger.Debugf("metadata: bdinfo data collected with %d fields", len(bdinfoParsed))
 				}
 				if needScan {
 					s.logger.Debugf("metadata: bdinfo scan completed for %d selected playlists", len(selectedPlaylistNames))
+					api.EmitPreparationProgress(
+						ctx,
+						api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressCompleted, "Blu-ray analysis complete."),
+					)
+					bdinfoTerminal = true
+				} else {
+					api.SkipPreparationProgress(ctx, api.PreparationPhaseBDInfo, "Reused cached Blu-ray analysis.")
+					bdinfoTerminal = true
 				}
 			} else {
 				s.logger.Debugf("metadata: bdinfo service is nil, skipping disc analysis")
+				api.SkipPreparationProgress(ctx, api.PreparationPhaseBDInfo, "Blu-ray analysis is unavailable.")
 			}
 
 			// Extract m2ts files from selected playlist(s)
@@ -469,7 +494,7 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 	if discType == "" {
 		video, filelist, err := filesystem.CollectVideoFiles(ctx, primary, false)
 		if err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: collect video files: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: collect video files: %w", err)
 		}
 		meta.VideoPath = video
 		meta.FileList = filelist
@@ -477,16 +502,6 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 	}
 
 	applySeasonEpisodeMetadata(&meta, seasonep.Extract(primary, meta), s.logger)
-	if shouldCollapseCLIFolderToVideo(meta, primary) {
-		meta.VideoPath = preferredCLIFolderVideo(meta, primary)
-		primary = strings.TrimSpace(meta.VideoPath)
-		meta.SourcePath = primary
-		meta.Paths = []string{primary}
-		meta.FileList = []string{primary}
-		clearSeasonEpisodeMetadata(&meta)
-		applySeasonEpisodeMetadata(&meta, seasonep.Extract(primary, meta), s.logger)
-		s.logger.Debugf("metadata: collapsed CLI folder input to video file %s", primary)
-	}
 	release := ParseReleaseInfo(primary)
 	meta.Release = release
 
@@ -494,19 +509,19 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 	if stored, err := s.repo.GetReleaseNameOverrides(ctx, primary); err == nil {
 		storedOverrides = stored
 	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: release overrides lookup: %w", err)
+		return preparationstate.State{}, fmt.Errorf("metadata: release overrides lookup: %w", err)
 	}
-	mergedOverrides := mergeReleaseNameOverrides(storedOverrides, req.ReleaseNameOverrides)
+	mergedOverrides := mergeReleaseNameOverrides(storedOverrides, input.Instructions.ReleaseName)
 	meta.ReleaseNameOverrides = mergedOverrides
-	if hasReleaseNameOverrides(req.ReleaseNameOverrides) {
+	if hasReleaseNameOverrides(input.Instructions.ReleaseName) {
 		if err := s.repo.SaveReleaseNameOverrides(ctx, primary, mergedOverrides); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: release overrides persist: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: release overrides persist: %w", err)
 		}
 	}
 
 	size, err := filesystem.SourceSize(ctx, primary, meta.DiscType, meta.FileList, meta.VideoPath)
 	if err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: source size: %w", err)
+		return preparationstate.State{}, fmt.Errorf("metadata: source size: %w", err)
 	}
 	meta.SourceSize = size
 	s.logger.Debugf("metadata: source size %d bytes", size)
@@ -525,27 +540,43 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 			s.logger.Debugf("metadata: stored metadata stale for %s; recomputing", primary)
 		}
 	} else if !errors.Is(err, internalerrors.ErrNotFound) {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: lookup: %w", err)
+		return preparationstate.State{}, fmt.Errorf("metadata: lookup: %w", err)
 	}
 
 	if meta.StoredDataFresh {
-		if storedIDs, err := s.repo.GetExternalIDs(ctx, primary); err == nil {
-			meta.ExternalIDs = storedIDs
+		if storedIDs, err := s.repo.GetExternalIdentity(ctx, primary); err == nil {
+			meta.Identity = storedIDs
 		} else if !errors.Is(err, internalerrors.ErrNotFound) {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: external ids lookup: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: external ids lookup: %w", err)
 		}
 		if storedMeta, err := s.repo.GetExternalMetadata(ctx, primary); err == nil {
-			meta.ExternalMetadata = storedMeta
+			meta.ProviderMetadata = storedMeta
 		} else if !errors.Is(err, internalerrors.ErrNotFound) {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: external metadata lookup: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: external metadata lookup: %w", err)
 		}
 	}
 
-	// Scene detection was moved out of Prepare into ApplyMediaDetails: it needs a
-	// resolved IMDb id and the rebuilt release name (both produced after
-	// ResolveExternalIDs), so running it here — before tracker/external-ID
-	// resolution — missed renamed releases entirely.
-	if release.Title != "" || release.Alt != "" || release.Subtitle != "" || release.Artist != "" || release.Year != 0 || release.Month != 0 || release.Day != 0 || release.Source != "" || release.Resolution != "" || release.Ext != "" || release.Site != "" || release.Genre != "" || release.Channels != "" || release.Collection != "" || release.Region != "" || release.Size != "" || release.Group != "" || release.Disc != "" || release.Type != "" || release.Category != "" || len(release.Codec) > 0 || len(release.Audio) > 0 || len(release.HDR) > 0 || len(release.Language) > 0 {
+	// Scene detection runs during fact derivation after provider evidence and
+	// rebuilt naming are available. Running it here would miss renamed releases.
+	if release.Title != "" || release.Alt != "" || release.Subtitle != "" || release.Artist != "" || release.Year != 0 || release.Month != 0 ||
+		release.Day != 0 ||
+		release.Source != "" ||
+		release.Resolution != "" ||
+		release.Ext != "" ||
+		release.Site != "" ||
+		release.Genre != "" ||
+		release.Channels != "" ||
+		release.Collection != "" ||
+		release.Region != "" ||
+		release.Size != "" ||
+		release.Group != "" ||
+		release.Disc != "" ||
+		release.Type != "" ||
+		release.Category != "" ||
+		len(release.Codec) > 0 ||
+		len(release.Audio) > 0 ||
+		len(release.HDR) > 0 ||
+		len(release.Language) > 0 {
 		s.logger.Debugf(
 			"metadata: release parsed category=%q type=%q artist=%q title=%q subtitle=%q alt=%q year=%d month=%d day=%d source=%q resolution=%q codec=%v audio=%v hdr=%v ext=%q language=%v site=%q genre=%q channels=%q collection=%q region=%q size=%q group=%q disc=%q",
 			release.Category,
@@ -583,14 +614,14 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
 	if s.mi != nil {
 		tmpRoot, err := db.Subdir(s.cfg.MainSettings.DBPath, "tmp")
 		if err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: tmp dir: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: tmp dir: %w", err)
 		}
 		miResult, err := s.mi.Export(ctx, mediainfo.Request{
 			SourcePath: meta.SourcePath,
@@ -600,7 +631,7 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 			Release:    meta.Release,
 		})
 		if err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: mediainfo: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: mediainfo: %w", err)
 		}
 		meta.MediaInfoJSONPath = miResult.JSONPath
 		meta.MediaInfoTextPath = miResult.TextPath
@@ -620,7 +651,7 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 			dvdDetails.VOBMediaInfoRaw = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(miResult.VOBText), strings.TrimSpace(miResult.VOBJSON))
 			dvdDetails.UpdatedAt = time.Now().UTC()
 			if err := s.repo.SaveDVDMediaInfo(ctx, dvdDetails); err != nil {
-				return api.PreparedMetadata{}, fmt.Errorf("metadata: persist dvd mediainfo: %w", err)
+				return preparationstate.State{}, fmt.Errorf("metadata: persist dvd mediainfo: %w", err)
 			}
 		}
 	}
@@ -648,13 +679,13 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 	if err := s.repo.Save(ctx, db.FileMetadata{
@@ -692,7 +723,7 @@ func (s *Service) Prepare(ctx context.Context, req api.Request) (meta api.Prepar
 		Edition:    meta.Release.Edition,
 		Other:      meta.Release.Other,
 	}); err != nil {
-		return api.PreparedMetadata{}, fmt.Errorf("metadata: persist: %w", err)
+		return preparationstate.State{}, fmt.Errorf("metadata: persist: %w", err)
 	}
 	s.logger.Debugf("metadata: persisted metadata for %s", primary)
 
@@ -716,7 +747,7 @@ func sceneResultHasData(result SceneResult) bool {
 
 // applySceneResult copies detector scene metadata into prepared metadata,
 // preserving existing service labels unless the detector supplied them first.
-func applySceneResult(meta *api.PreparedMetadata, result SceneResult) {
+func applySceneResult(meta *preparationstate.State, result SceneResult) {
 	meta.Scene = result.IsScene
 	meta.SceneName = result.SceneName
 	meta.SceneTMDBID = result.TMDBID
@@ -792,43 +823,6 @@ func (s *Service) extractM2TSFromPlaylist(bdmvPath string, playlistFiles []strin
 	return m2tsFiles, largestFile, nil
 }
 
-func loadSelectedBDMVPlaylists(ctx context.Context, bdmvPath string, selected []string) ([]api.PlaylistInfo, error) {
-	discovered, err := discoverBDMVPlaylists(ctx, bdmvPath)
-	if err != nil {
-		return nil, err
-	}
-
-	byName := make(map[string]filesystem.PlaylistInfo, len(discovered))
-	for _, playlist := range discovered {
-		byName[discparse.NormalizePlaylistName(playlist.File)] = playlist
-	}
-
-	result := make([]api.PlaylistInfo, 0, len(selected))
-	for _, name := range selected {
-		normalized := discparse.NormalizePlaylistName(name)
-		playlist, ok := byName[normalized]
-		if !ok {
-			return nil, fmt.Errorf("selected playlist %s was not found during discovery", normalized)
-		}
-		items := make([]api.PlaylistItem, 0, len(playlist.Items))
-		for _, item := range playlist.Items {
-			items = append(items, api.PlaylistItem{
-				File: item.File,
-				Size: item.Size,
-			})
-		}
-		result = append(result, api.PlaylistInfo{
-			File:     playlist.File,
-			Duration: playlist.Duration,
-			Items:    items,
-			Score:    playlist.Score,
-			Edition:  playlist.Edition,
-		})
-	}
-
-	return result, nil
-}
-
 func playlistNames(playlists []api.PlaylistInfo) []string {
 	names := make([]string, 0, len(playlists))
 	for _, playlist := range playlists {
@@ -930,7 +924,8 @@ func discoverBDMVSummaryCache(tmpDir string) (bdmvSummaryCache, error) {
 			continue
 		}
 		name := entry.Name()
-		if !strings.HasPrefix(name, "BD_SUMMARY_") || strings.HasPrefix(name, "BD_SUMMARY_EXT_") || strings.HasPrefix(name, "BD_SUMMARY_FULL_") || !strings.HasSuffix(name, ".txt") {
+		if !strings.HasPrefix(name, "BD_SUMMARY_") || strings.HasPrefix(name, "BD_SUMMARY_EXT_") || strings.HasPrefix(name, "BD_SUMMARY_FULL_") ||
+			!strings.HasSuffix(name, ".txt") {
 			continue
 		}
 		playlistFromName := paths.BDMVPlaylistKey(strings.TrimSuffix(strings.TrimPrefix(name, "BD_SUMMARY_"), ".txt"))
@@ -957,7 +952,11 @@ func discoverBDMVSummaryCache(tmpDir string) (bdmvSummaryCache, error) {
 		if extPath != "" {
 			cleanTmpDir := filepath.Clean(tmpDir)
 			cleanExtPath := filepath.Clean(extPath)
-			if relPath, err := filepath.Rel(cleanTmpDir, cleanExtPath); err == nil && relPath != ".." && !strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
+			if relPath, err := filepath.Rel(
+				cleanTmpDir,
+				cleanExtPath,
+			); err == nil && relPath != ".." &&
+				!strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
 				if rawExt, err := os.ReadFile(cleanExtPath); err == nil {
 					extPayload = string(rawExt)
 				}
@@ -968,7 +967,11 @@ func discoverBDMVSummaryCache(tmpDir string) (bdmvSummaryCache, error) {
 		if fullPath != "" {
 			cleanTmpDir := filepath.Clean(tmpDir)
 			cleanFullPath := filepath.Clean(fullPath)
-			if relPath, err := filepath.Rel(cleanTmpDir, cleanFullPath); err == nil && relPath != ".." && !strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
+			if relPath, err := filepath.Rel(
+				cleanTmpDir,
+				cleanFullPath,
+			); err == nil && relPath != ".." &&
+				!strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
 				if rawFull, err := os.ReadFile(cleanFullPath); err == nil {
 					fullPayload = string(rawFull)
 				}
@@ -1019,7 +1022,15 @@ func cachedPlaylistNames(cache bdmvSummaryCache) []string {
 	return names
 }
 
-func (s *Service) resolveOrCreateBDMVSummaries(ctx context.Context, req api.Request, tmpDir string, playlistPath string, selected []string) (string, bool, error) {
+// resolveOrCreateBDMVSummaries reuses complete cached playlist reports or runs
+// the minimum permitted BDInfo scan, requiring confirmation for partial caches.
+func (s *Service) resolveOrCreateBDMVSummaries(
+	ctx context.Context,
+	input api.PrepareInput,
+	tmpDir string,
+	playlistPath string,
+	selected []string,
+) (string, bool, error) {
 	cache, err := discoverBDMVSummaryCache(tmpDir)
 	if err != nil {
 		return "", false, fmt.Errorf("metadata: discover bdmv tmp cache: %w", err)
@@ -1034,9 +1045,9 @@ func (s *Service) resolveOrCreateBDMVSummaries(ctx context.Context, req api.Requ
 		}
 		return outputPath, false, nil
 	case len(missing) > 0 && len(missing) < len(selected):
-		if req.Options.InteractionMode != api.InteractionModeUnattended && !req.ConfirmBDMVRescan {
+		if input.Controls.Interaction != api.InteractionModeUnattended && !input.Controls.ConfirmBDMVRescan {
 			return "", false, &api.BDMVRescanRequiredError{
-				SourcePath:        req.Paths[0],
+				SourcePath:        input.SourcePath,
 				SelectedPlaylists: append([]string(nil), selected...),
 				CachedPlaylists:   cachedPlaylistNames(cache),
 				MissingPlaylists:  missing,
@@ -1077,7 +1088,7 @@ func (s *Service) resolveOrCreateBDMVSummaries(ctx context.Context, req api.Requ
 	return outputPath, true, nil
 }
 
-func metadataFingerprintMatches(primary string, current api.PreparedMetadata, stored db.FileMetadata) bool {
+func metadataFingerprintMatches(primary string, current preparationstate.State, stored db.FileMetadata) bool {
 	if !pathEqualForFingerprint(primary, stored.Path) {
 		return false
 	}
@@ -1087,7 +1098,8 @@ func metadataFingerprintMatches(primary string, current api.PreparedMetadata, st
 	if current.SourceSize != 0 && stored.SourceSize != 0 && current.SourceSize != stored.SourceSize {
 		return false
 	}
-	if strings.TrimSpace(current.VideoPath) != "" && strings.TrimSpace(stored.VideoPath) != "" && !pathEqualForFingerprint(current.VideoPath, stored.VideoPath) {
+	if strings.TrimSpace(current.VideoPath) != "" && strings.TrimSpace(stored.VideoPath) != "" &&
+		!pathEqualForFingerprint(current.VideoPath, stored.VideoPath) {
 		return false
 	}
 	if len(current.FileList) > 0 && len(stored.FileList) > 0 {
@@ -1130,45 +1142,7 @@ func normalizePathForFingerprint(path string) string {
 	return normalized
 }
 
-func normalizeScreenshotOverrides(overrides api.ScreenshotOverrides) api.ScreenshotOverrides {
-	if len(overrides.ManualFrames) > 0 {
-		frames := make([]int, 0, len(overrides.ManualFrames))
-		for _, frame := range overrides.ManualFrames {
-			if frame <= 0 {
-				continue
-			}
-			frames = append(frames, frame)
-		}
-		overrides.ManualFrames = frames
-	}
-	if len(overrides.ComparisonPaths) > 0 {
-		paths := make([]string, 0, len(overrides.ComparisonPaths))
-		seen := make(map[string]struct{}, len(overrides.ComparisonPaths))
-		for _, value := range overrides.ComparisonPaths {
-			trimmed := strings.TrimSpace(value)
-			if trimmed == "" {
-				continue
-			}
-			absPath, err := filepath.Abs(trimmed)
-			if err != nil {
-				continue
-			}
-			normalized := normalizePathForFingerprint(absPath)
-			if _, ok := seen[normalized]; ok {
-				continue
-			}
-			seen[normalized] = struct{}{}
-			paths = append(paths, absPath)
-		}
-		overrides.ComparisonPaths = paths
-	}
-	if overrides.ComparisonPrimaryIndex != nil && *overrides.ComparisonPrimaryIndex <= 0 {
-		overrides.ComparisonPrimaryIndex = nil
-	}
-	return overrides
-}
-
-func applySeasonEpisodeMetadata(meta *api.PreparedMetadata, result seasonep.Result, logger api.Logger) {
+func applySeasonEpisodeMetadata(meta *preparationstate.State, result seasonep.Result, logger api.Logger) {
 	if meta == nil {
 		return
 	}
@@ -1193,147 +1167,14 @@ func applySeasonEpisodeMetadata(meta *api.PreparedMetadata, result seasonep.Resu
 	meta.TVPack = result.TVPack
 
 	if logger != nil && (meta.SeasonStr != "" || meta.EpisodeStr != "" || meta.DailyEpisodeDate != "" || meta.TVPack) {
-		logger.Debugf("metadata: parsed season/episode season=%q episode=%q daily_date=%q tv_pack=%t", meta.SeasonStr, meta.EpisodeStr, meta.DailyEpisodeDate, meta.TVPack)
-	}
-}
-
-func clearSeasonEpisodeMetadata(meta *api.PreparedMetadata) {
-	if meta == nil {
-		return
-	}
-	meta.SeasonInt = 0
-	meta.EpisodeInt = 0
-	meta.SeasonStr = ""
-	meta.EpisodeStr = ""
-	meta.DailyEpisodeDate = ""
-	meta.TVPack = false
-	meta.Release.Season = 0
-	meta.Release.Episode = 0
-}
-
-func shouldCollapseCLIFolderToVideo(meta api.PreparedMetadata, sourcePath string) bool {
-	if meta.Mode != api.ModeCLI || meta.Options.KeepFolder || meta.TVPack || strings.TrimSpace(meta.DiscType) != "" {
-		return false
-	}
-	videoPath := strings.TrimSpace(meta.VideoPath)
-	if videoPath == "" || strings.EqualFold(videoPath, strings.TrimSpace(sourcePath)) {
-		return false
-	}
-	info, err := os.Stat(strings.TrimSpace(sourcePath))
-	if err != nil || !info.IsDir() {
-		return false
-	}
-	return true
-}
-
-func largestVideoFile(fileList []string, fallback string) string {
-	largest := strings.TrimSpace(fallback)
-	largestSize := int64(-1)
-	for _, candidate := range fileList {
-		trimmed := strings.TrimSpace(candidate)
-		if trimmed == "" {
-			continue
-		}
-		info, err := os.Stat(trimmed)
-		if err != nil || !info.Mode().IsRegular() {
-			continue
-		}
-		if info.Size() > largestSize {
-			largest = trimmed
-			largestSize = info.Size()
-		}
-	}
-	return largest
-}
-
-func preferredCLIFolderVideo(meta api.PreparedMetadata, sourcePath string) string {
-	if matched := exactFolderNamedVideoFile(meta.FileList, sourcePath); matched != "" {
-		return matched
-	}
-	if matched := seasonEpisodeMatchedVideoFile(meta.FileList, meta); matched != "" {
-		return matched
-	}
-	fallback := strings.TrimSpace(meta.VideoPath)
-	if isRegularPathInList(meta.FileList, fallback) {
-		return fallback
-	}
-	return largestVideoFile(meta.FileList, fallback)
-}
-
-func exactFolderNamedVideoFile(fileList []string, sourcePath string) string {
-	folderBase := strings.TrimSpace(filepath.Base(filepath.Clean(sourcePath)))
-	if folderBase == "" {
-		return ""
-	}
-	normalizedFolder := normalizeVideoStem(folderBase)
-	for _, candidate := range fileList {
-		trimmed := strings.TrimSpace(candidate)
-		if trimmed == "" {
-			continue
-		}
-		if normalizeVideoStem(filepath.Base(trimmed)) == normalizedFolder && isRegularPathInList([]string{trimmed}, trimmed) {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func seasonEpisodeMatchedVideoFile(fileList []string, meta api.PreparedMetadata) string {
-	if meta.SeasonInt <= 0 && meta.EpisodeInt <= 0 && strings.TrimSpace(meta.DailyEpisodeDate) == "" {
-		return ""
-	}
-	matches := make([]string, 0, len(fileList))
-	for _, candidate := range fileList {
-		trimmed := strings.TrimSpace(candidate)
-		if trimmed == "" || !isRegularPathInList([]string{trimmed}, trimmed) {
-			continue
-		}
-		if releaseMatchesPreparedEpisode(ParseReleaseInfo(trimmed), meta) {
-			matches = append(matches, trimmed)
-		}
-	}
-	if len(matches) == 0 {
-		return ""
-	}
-	fallback := strings.TrimSpace(meta.VideoPath)
-	if isRegularPathInList(matches, fallback) {
-		return fallback
-	}
-	return largestVideoFile(matches, matches[0])
-}
-
-func releaseMatchesPreparedEpisode(release api.ReleaseInfo, meta api.PreparedMetadata) bool {
-	if strings.TrimSpace(meta.DailyEpisodeDate) != "" && release.Year > 0 && release.Month > 0 && release.Day > 0 {
-		expected := fmt.Sprintf("%04d-%02d-%02d", release.Year, release.Month, release.Day)
-		if expected == strings.TrimSpace(meta.DailyEpisodeDate) {
-			return true
-		}
-	}
-	return meta.SeasonInt > 0 && meta.EpisodeInt > 0 && release.Season == meta.SeasonInt && release.Episode == meta.EpisodeInt
-}
-
-func normalizeVideoStem(value string) string {
-	base := strings.TrimSuffix(strings.TrimSpace(value), filepath.Ext(value))
-	return strings.ToLower(base)
-}
-
-func isRegularPathInList(fileList []string, candidate string) bool {
-	trimmedCandidate := strings.TrimSpace(candidate)
-	if trimmedCandidate == "" {
-		return false
-	}
-	found := false
-	for _, value := range fileList {
-		if pathEqualForFingerprint(value, trimmedCandidate) {
-			found = true
-			break
-		}
-	}
-	if !found {
-		return false
+		logger.Debugf(
+			"metadata: parsed season/episode season=%q episode=%q daily_date=%q tv_pack=%t",
+			meta.SeasonStr,
+			meta.EpisodeStr,
+			meta.DailyEpisodeDate,
+			meta.TVPack,
+		)
 	}
-	info, err := os.Stat(trimmedCandidate)
-	return err == nil && info.Mode().IsRegular()
 }
 
 func safeWriteFile(dir string, path string, data []byte) error {
diff --git a/internal/metadata/service_resolve.go b/internal/metadata/service_resolve.go
index 8cd7cf7e..671924fb 100644
--- a/internal/metadata/service_resolve.go
+++ b/internal/metadata/service_resolve.go
@@ -8,8 +8,9 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 )
 
 // serviceAlias carries a configured service alias and its normalized token span
@@ -23,7 +24,7 @@ type serviceAlias struct {
 // resolveService returns the normalized service token, display name, and source
 // filename for metadata naming. Existing metadata service values win over
 // filename-derived matches.
-func resolveService(meta api.PreparedMetadata) (string, string, string) {
+func resolveService(meta preparationstate.State) (string, string, string) {
 	services := serviceCodeMap()
 	filename := strings.TrimSpace(meta.Filename)
 	if filename == "" {
@@ -118,7 +119,11 @@ func orderedServiceAliases(services map[string]string) []serviceAlias {
 		if len(tokens) == 0 {
 			continue
 		}
-		aliases = append(aliases, serviceAlias{name: name, service: service, tokens: tokens})
+		aliases = append(aliases, serviceAlias{
+			name:    name,
+			service: service,
+			tokens:  tokens,
+		})
 	}
 	sort.Slice(aliases, func(i, j int) bool {
 		iWeight := serviceAliasTokenWeight(aliases[i])
diff --git a/internal/metadata/service_test.go b/internal/metadata/service_test.go
index af1b9688..2d928d5e 100644
--- a/internal/metadata/service_test.go
+++ b/internal/metadata/service_test.go
@@ -15,17 +15,27 @@ import (
 	"testing"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/filesystem"
 	"github.com/autobrr/upbrr/internal/metadata/mediainfo"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/bdinfo"
 	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func TestPrepare(t *testing.T) {
+func testCollectionRequest(t *testing.T, request api.Request) preparationstate.Request {
+	t.Helper()
+	input, _ := api.MapPreparationRequest(request, api.PreparationIntentPreview)
+	layout, _ := sourcelayout.Resolve(context.Background(), request.SourcePath)
+	return preparationstate.Request{Input: input, Layout: layout}
+}
+
+func TestCollectSourceEvidenceKeepsCanonicalSource(t *testing.T) {
 	t.Parallel()
 
 	base := t.TempDir()
@@ -42,51 +52,39 @@ func TestPrepare(t *testing.T) {
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg))
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths:          []string{path},
-		Mode:           api.ModeCLI,
+	meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath:     path,
 		Trackers:       []string{"blu", "bhd"},
-		Options:        api.UploadOptions{Debug: true, Screens: 3},
+		Options:        api.UploadOptions{
+OnlyID: true,
+ KeepImages: true,
+ InteractionMode: api.InteractionModeUnattended,
+},
 		TrackersRemove: []string{"bhd"},
-	})
+	}))
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
-	if meta.SourcePath != videoPath {
+	if meta.SourcePath != path {
 		t.Fatalf("unexpected source path: %s", meta.SourcePath)
 	}
 	if len(meta.Paths) != 1 {
 		t.Fatalf("unexpected paths length: %d", len(meta.Paths))
 	}
-	if meta.Mode != api.ModeCLI {
-		t.Fatalf("unexpected mode: %s", meta.Mode)
-	}
-	if len(meta.Trackers) != 2 {
-		t.Fatalf("unexpected trackers length: %d", len(meta.Trackers))
+	if len(meta.EvidenceTrackers) != 0 {
+		t.Fatalf("workflow trackers leaked into preparation evidence: %v", meta.EvidenceTrackers)
 	}
-	if !meta.Options.Debug || meta.Options.Screens != 3 {
-		t.Fatalf("unexpected options: %+v", meta.Options)
+	if !meta.Policy.OnlyID || !meta.Policy.KeepImages || meta.Policy.InteractionMode != api.InteractionModeUnattended {
+		t.Fatalf("unexpected collection policy: %+v", meta.Policy)
 	}
-	if len(meta.TrackersRemove) != 1 {
-		t.Fatalf("unexpected trackers-remove length: %d", len(meta.TrackersRemove))
-	}
-	if len(meta.Paths) != 1 || meta.Paths[0] != videoPath {
+	if len(meta.Paths) != 1 || meta.Paths[0] != path {
 		t.Fatalf("unexpected paths: %v", meta.Paths)
 	}
-	if meta.StoredInfoHash != "hash" {
-		t.Fatalf("unexpected stored info hash: %s", meta.StoredInfoHash)
-	}
-	if !meta.StoredDataFresh {
-		t.Fatalf("expected stored metadata marked fresh")
-	}
-	if repo.saved.InfoHash != "hash" {
-		t.Fatalf("expected persisted info hash, got %s", repo.saved.InfoHash)
-	}
-	if repo.saved.Path != videoPath {
+	if repo.saved.Path != path {
 		t.Fatalf("expected repo save path, got %q", repo.saved.Path)
 	}
 
-	_, err = service.Prepare(context.Background(), api.Request{})
+	_, err = service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{}))
 	if !errors.Is(err, internalerrors.ErrInvalidInput) {
 		t.Fatalf("expected invalid input error, got: %v", err)
 	}
@@ -95,7 +93,7 @@ func TestPrepare(t *testing.T) {
 func TestApplySceneDetectionCopiesResultAfterRecoverableNFOFailure(t *testing.T) {
 	t.Parallel()
 
-	// Scene detection runs in ApplyMediaDetails now; applySceneDetection is the
+	// Scene detection runs during fact derivation; applySceneDetection is the
 	// plumbing that copies the result and surfaces a recoverable NFO side effect.
 	logger := &recordingLogger{}
 	service := NewService(&stubRepo{},
@@ -112,7 +110,7 @@ func TestApplySceneDetectionCopiesResultAfterRecoverableNFOFailure(t *testing.T)
 		WithLogger(logger),
 	)
 
-	meta, err := service.applySceneDetection(context.Background(), api.PreparedMetadata{})
+	meta, err := service.applySceneDetection(context.Background(), preparationstate.State{})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -133,21 +131,21 @@ func TestApplySceneDetectionBackfillsIMDbID(t *testing.T) {
 	service := NewService(&stubRepo{},
 		WithSceneDetector(staticSceneDetector{result: SceneResult{IsScene: true, IMDBID: 132245}}),
 	)
-	// No externally-resolved id: the scene-discovered id backfills ExternalIDs.
-	meta, err := service.applySceneDetection(context.Background(), api.PreparedMetadata{})
+	// No externally resolved ID: scene evidence backfills canonical identity.
+	meta, err := service.applySceneDetection(context.Background(), preparationstate.State{})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if meta.ExternalIDs.IMDBID != 132245 {
-		t.Fatalf("expected scene imdb backfilled, got %d", meta.ExternalIDs.IMDBID)
+	if meta.Identity.IMDBID != 132245 {
+		t.Fatalf("expected scene imdb backfilled, got %d", meta.Identity.IMDBID)
 	}
 	// An already-resolved id is not overwritten.
-	meta, err = service.applySceneDetection(context.Background(), api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 999}})
+	meta, err = service.applySceneDetection(context.Background(), preparationstate.State{Identity: api.ExternalIdentity{IMDBID: 999}})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if meta.ExternalIDs.IMDBID != 999 {
-		t.Fatalf("expected resolved imdb preserved, got %d", meta.ExternalIDs.IMDBID)
+	if meta.Identity.IMDBID != 999 {
+		t.Fatalf("expected resolved imdb preserved, got %d", meta.Identity.IMDBID)
 	}
 }
 
@@ -159,7 +157,7 @@ func TestApplySceneDetectionPropagatesCancellation(t *testing.T) {
 	service := NewService(&stubRepo{},
 		WithSceneDetector(staticSceneDetector{err: context.Canceled}),
 	)
-	if _, err := service.applySceneDetection(context.Background(), api.PreparedMetadata{}); !errors.Is(err, context.Canceled) {
+	if _, err := service.applySceneDetection(context.Background(), preparationstate.State{}); !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected cancellation propagated, got %v", err)
 	}
 }
@@ -181,11 +179,10 @@ func TestPrepareCLIKeepFolderPreservesSingleFileDirectory(t *testing.T) {
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg))
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeCLI,
+	meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath: path,
 		Options: api.UploadOptions{KeepFolder: true},
-	})
+	}))
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -221,10 +218,9 @@ func TestPrepareCLITVPackPreservesDirectory(t *testing.T) {
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg))
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeCLI,
-	})
+	meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath: path,
+	}))
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -242,85 +238,10 @@ func TestPrepareCLITVPackPreservesDirectory(t *testing.T) {
 	}
 }
 
-func TestPrepareCLISingleEpisodeFolderPrefersEpisodeVideoOverLargerExtra(t *testing.T) {
-	t.Parallel()
-
-	base := t.TempDir()
-	path := filepath.Join(base, "Example.Show.S01E01.1080p.WEB-DL-GRP")
-	if err := os.MkdirAll(path, 0o755); err != nil {
-		t.Fatalf("mkdir failed: %v", err)
-	}
-	small := filepath.Join(path, "Example.Show.S01E01.1080p.WEB-DL-GRP.mkv")
-	large := filepath.Join(path, "Featurette.mp4")
-	if err := os.WriteFile(small, []byte("video"), 0o600); err != nil {
-		t.Fatalf("write small video failed: %v", err)
-	}
-	if err := os.WriteFile(large, []byte("larger video"), 0o600); err != nil {
-		t.Fatalf("write large video failed: %v", err)
-	}
-
-	repo := &stubRepo{}
-	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
-	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg))
-
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if meta.SourcePath != small {
-		t.Fatalf("expected episode video source path %q, got %q", small, meta.SourcePath)
-	}
-	if meta.TVPack {
-		t.Fatalf("did not expect TV pack metadata")
-	}
-	if len(meta.FileList) != 1 || meta.FileList[0] != small {
-		t.Fatalf("expected only selected episode video in file list, got %#v", meta.FileList)
-	}
-	if repo.saved.Path != small {
-		t.Fatalf("expected repo save path to be episode video, got %q", repo.saved.Path)
-	}
-}
-
-func TestPrepareAppliesTorrentOverrides(t *testing.T) {
-	t.Parallel()
-
-	base := t.TempDir()
-	path := filepath.Join(base, "example")
-	if err := os.MkdirAll(path, 0o755); err != nil {
-		t.Fatalf("mkdir failed: %v", err)
-	}
-	videoPath := filepath.Join(path, "example.mkv")
-	if err := os.WriteFile(videoPath, []byte("video"), 0o644); err != nil {
-		t.Fatalf("write video failed: %v", err)
-	}
-
-	repo := &stubRepo{}
-	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
-	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg))
-	infoHash := "abcdef0123456789abcdef0123456789abcdef01"
-
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeCLI,
-		TorrentOverrides: api.TorrentOverrides{
-			InfoHash: &infoHash,
-		},
-	})
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if meta.InfoHash != infoHash {
-		t.Fatalf("expected infohash override, got %q", meta.InfoHash)
-	}
-}
-
 func TestResolveServiceDarkroom(t *testing.T) {
 	t.Parallel()
 
-	service, longName, filename := resolveService(api.PreparedMetadata{
+	service, longName, filename := resolveService(preparationstate.State{
 		SourcePath: `/releases/Example.Movie.2025.DARKROOM.WEB-DL.mkv`,
 	})
 	if service != "DARKROOM" {
@@ -337,7 +258,7 @@ func TestResolveServiceDarkroom(t *testing.T) {
 func TestResolveServiceMGMPlus(t *testing.T) {
 	t.Parallel()
 
-	service, longName, filename := resolveService(api.PreparedMetadata{
+	service, longName, filename := resolveService(preparationstate.State{
 		SourcePath: `D:\TV\Example.Spy.Show.S01.2160p.MGMP.WEB-DL.DDP5.1.H.265-GRP`,
 	})
 	if service != "MGMP" {
@@ -354,7 +275,7 @@ func TestResolveServiceMGMPlus(t *testing.T) {
 func TestResolveServiceIgnoresTitleServiceTokens(t *testing.T) {
 	t.Parallel()
 
-	service, longName, filename := resolveService(api.PreparedMetadata{
+	service, longName, filename := resolveService(preparationstate.State{
 		SourcePath: `/releases/Example.Show.S01E01.Netflix.and.Chill.1080p.WEB-DL.DDP5.1.H.264-GRP.mkv`,
 	})
 	if service != "" {
@@ -409,7 +330,7 @@ func TestResolveServicePrefersLongestAdjacentAlias(t *testing.T) {
 func assertResolvedService(t *testing.T, sourcePath, wantService, wantLongName string) {
 	t.Helper()
 
-	service, longName, filename := resolveService(api.PreparedMetadata{
+	service, longName, filename := resolveService(preparationstate.State{
 		SourcePath: sourcePath,
 	})
 	if service != wantService {
@@ -449,10 +370,14 @@ func TestApplySceneDetectionAppliesServiceFromNFO(t *testing.T) {
 	t.Parallel()
 
 	service := NewService(&stubRepo{},
-		WithSceneDetector(staticSceneDetector{result: SceneResult{IsScene: true, Service: "iT", ServiceLongName: "iTunes"}}),
+		WithSceneDetector(staticSceneDetector{result: SceneResult{
+			IsScene:         true,
+			Service:         "iT",
+			ServiceLongName: "iTunes",
+		}}),
 	)
 
-	meta, err := service.applySceneDetection(context.Background(), api.PreparedMetadata{})
+	meta, err := service.applySceneDetection(context.Background(), preparationstate.State{})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -479,7 +404,7 @@ func TestPrepareBDMVMultiPlaylistUsesFullScanAndDerivesSummaries(t *testing.T) {
 		playlistSelection: db.PlaylistSelection{
 			SelectedPlaylists: []string{"00002.MPLS", "00001.MPLS"},
 		},
-		playlistSelectionPath: filepath.ToSlash(filepath.Clean(filepath.Join(sourcePath, "BDMV"))),
+		playlistSelectionPath: filepath.ToSlash(filepath.Clean(sourcePath)),
 	}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	mediaInfo := &recordingMediaInfo{}
@@ -586,10 +511,9 @@ func TestPrepareBDMVMultiPlaylistUsesFullScanAndDerivesSummaries(t *testing.T) {
 		return map[string]any{"summary": string(payload)}, nil
 	}
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{sourcePath},
-		Mode:  api.ModeCLI,
-	})
+	meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath: sourcePath,
+	}))
 	if err != nil {
 		t.Fatalf("prepare failed: %v", err)
 	}
@@ -635,7 +559,7 @@ func TestPrepareBDMVMultiPlaylistUsesFullScanAndDerivesSummaries(t *testing.T) {
 	assertFileContains(t, filepath.Join(tmpDir, "BD_FULL.txt"), "PLAYLIST: 00002.MPLS")
 }
 
-func TestLoadSelectedBDMVPlaylistsErrorsWhenRequestedPlaylistMissing(t *testing.T) {
+func TestResolveBDMVPlaylistSelectionRejectsUnknownDirectPlaylist(t *testing.T) {
 	originalDiscover := discoverBDMVPlaylists
 	t.Cleanup(func() {
 		discoverBDMVPlaylists = originalDiscover
@@ -647,9 +571,16 @@ func TestLoadSelectedBDMVPlaylistsErrorsWhenRequestedPlaylistMissing(t *testing.
 		}, nil
 	}
 
-	_, err := loadSelectedBDMVPlaylists(context.Background(), `D:\Disc\BDMV`, []string{"00001.MPLS", "00002.MPLS"})
-	if err == nil || !strings.Contains(err.Error(), "00002.MPLS") {
-		t.Fatalf("expected missing playlist error for 00002.MPLS, got %v", err)
+	_, err := (&Service{}).resolveBDMVPlaylistSelection(context.Background(), preparationstate.Request{
+		Input: api.PrepareInput{Instructions: api.ReleaseFactInstructions{Playlist: api.PlaylistInstruction{
+			Set:      true,
+			Selected: []string{"00001.MPLS", "00002.MPLS"},
+		}}},
+		Layout: sourcelayout.Layout{SourcePath: `D:\Disc`, BDMVRoot: `D:\Disc\BDMV`},
+	})
+	var invalid *api.InvalidPlaylistSelectionError
+	if !errors.As(err, &invalid) || invalid.Playlist != "00002.MPLS" {
+		t.Fatalf("expected typed missing playlist error for 00002.MPLS, got %v", err)
 	}
 }
 
@@ -721,7 +652,7 @@ func TestPrepareBDMVUsesCachedSummariesWithoutRescan(t *testing.T) {
 		playlistSelection: db.PlaylistSelection{
 			SelectedPlaylists: []string{"00002.MPLS", "00001.MPLS"},
 		},
-		playlistSelectionPath: filepath.ToSlash(filepath.Clean(filepath.Join(sourcePath, "BDMV"))),
+		playlistSelectionPath: filepath.ToSlash(filepath.Clean(sourcePath)),
 	}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg), WithBDInfoService(bdinfo.New(api.NopLogger{})))
@@ -783,7 +714,7 @@ func TestPrepareBDMVUsesCachedSummariesWithoutRescan(t *testing.T) {
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, sourcePath)
+	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{}, sourcePath)
 	if err != nil {
 		t.Fatalf("tmp dir: %v", err)
 	}
@@ -793,10 +724,9 @@ func TestPrepareBDMVUsesCachedSummariesWithoutRescan(t *testing.T) {
 	writeBDMVSummaryFixture(t, tmpDir, "00001.MPLS", "extended summary one")
 	writeBDMVSummaryFixture(t, tmpDir, "00002.MPLS", "extended summary two")
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{sourcePath},
-		Mode:  api.ModeCLI,
-	})
+	meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath: sourcePath,
+	}))
 	if err != nil {
 		t.Fatalf("prepare failed: %v", err)
 	}
@@ -819,7 +749,7 @@ func TestPrepareBDMVUsesCachedSummariesWithoutRescan(t *testing.T) {
 	}
 }
 
-func TestPrepareBDMVSinglePlaylistFullScan(t *testing.T) {
+func TestPrepareBDMVDirectPlaylistInvokesBDInfoForParentAndRoot(t *testing.T) {
 	base := t.TempDir()
 	sourcePath := filepath.Join(base, "disc")
 	bdmvPath := filepath.Join(sourcePath, "BDMV")
@@ -830,12 +760,7 @@ func TestPrepareBDMVSinglePlaylistFullScan(t *testing.T) {
 		t.Fatalf("mkdir stream failed: %v", err)
 	}
 
-	repo := &stubRepo{
-		playlistSelection: db.PlaylistSelection{
-			SelectedPlaylists: []string{"00001.MPLS"},
-		},
-		playlistSelectionPath: filepath.ToSlash(filepath.Clean(filepath.Join(sourcePath, "BDMV"))),
-	}
+	repo := &stubRepo{}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg), WithBDInfoService(bdinfo.New(api.NopLogger{})))
 
@@ -865,6 +790,8 @@ func TestPrepareBDMVSinglePlaylistFullScan(t *testing.T) {
 
 	fullScans := 0
 	playlistScans := 0
+	var scannedRoots []string
+	var scannedPlaylists []string
 	dummyFullReport := strings.Join([]string{
 		"DISC INFO:",
 		"DISC LABEL: DISC-ONE",
@@ -888,8 +815,10 @@ func TestPrepareBDMVSinglePlaylistFullScan(t *testing.T) {
 		fullScans++
 		return bdinfo.ScanResult{}, errors.New("unexpected full scan")
 	}
-	executePlaylistBDInfo = func(_ *bdinfo.Service, _ context.Context, _ string, _ string, outputPath string, summaryOnly bool) (string, error) {
+	executePlaylistBDInfo = func(_ *bdinfo.Service, _ context.Context, root string, playlist string, outputPath string, summaryOnly bool) (string, error) {
 		playlistScans++
+		scannedRoots = append(scannedRoots, root)
+		scannedPlaylists = append(scannedPlaylists, playlist)
 		if summaryOnly {
 			return "", errors.New("expected full scan, got summaryOnly = true")
 		}
@@ -907,41 +836,51 @@ func TestPrepareBDMVSinglePlaylistFullScan(t *testing.T) {
 		return map[string]any{"summary": string(payload)}, nil
 	}
 
-	tmpRoot, err := db.Subdir(cfg.MainSettings.DBPath, "tmp")
-	if err != nil {
-		t.Fatalf("tmp root: %v", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, sourcePath)
-	if err != nil {
-		t.Fatalf("tmp dir: %v", err)
-	}
+	for _, requestedSource := range []string{sourcePath, bdmvPath} {
+		meta, err := service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+			SourcePath: requestedSource,
+			PlaylistInstruction: api.PlaylistInstruction{
+				Set:      true,
+				Selected: []string{"00001.MPLS"},
+			},
+		}))
+		if err != nil {
+			t.Fatalf("prepare %q: %v", requestedSource, err)
+		}
+		if !sameFilesystemPath(meta.SourcePath, requestedSource) {
+			t.Fatalf("prepared source = %q, want %q", meta.SourcePath, requestedSource)
+		}
+		tmpRoot, err := db.Subdir(cfg.MainSettings.DBPath, "tmp")
+		if err != nil {
+			t.Fatalf("tmp root: %v", err)
+		}
+		tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, requestedSource)
+		if err != nil {
+			t.Fatalf("tmp dir: %v", err)
+		}
+		assertFileContains(t, paths.BDMVSummaryPath(tmpDir, "00001.MPLS"), "Playlist: 00001.MPLS")
+		assertFileContains(t, paths.BDMVExtSummaryPath(tmpDir, "00001.MPLS"), "extended summary one")
+		assertFileContains(t, paths.BDMVFullSummaryPath(tmpDir, "00001.MPLS"), "QUICK SUMMARY:")
 
-	meta, err := service.Prepare(context.Background(), api.Request{
-		Paths: []string{sourcePath},
-		Mode:  api.ModeCLI,
-	})
-	if err != nil {
-		t.Fatalf("prepare failed: %v", err)
+		got, ok := meta.BDInfo["summary"].(string)
+		if !ok {
+			t.Fatalf("expected BDInfo summary string, got %T", meta.BDInfo["summary"])
+		}
+		if !strings.Contains(got, "Playlist: 00001.MPLS") {
+			t.Fatalf("unexpected summary in BDInfo: %v", got)
+		}
 	}
 
 	if fullScans != 0 {
 		t.Fatalf("expected no full scan, got %d", fullScans)
 	}
-	if playlistScans != 1 {
-		t.Fatalf("expected exactly 1 playlist scan, got %d", playlistScans)
-	}
-
-	// Verify all three versions of the report are saved in tmpDir
-	assertFileContains(t, paths.BDMVSummaryPath(tmpDir, "00001.MPLS"), "Playlist: 00001.MPLS")
-	assertFileContains(t, paths.BDMVExtSummaryPath(tmpDir, "00001.MPLS"), "extended summary one")
-	assertFileContains(t, paths.BDMVFullSummaryPath(tmpDir, "00001.MPLS"), "QUICK SUMMARY:")
-
-	got, ok := meta.BDInfo["summary"].(string)
-	if !ok {
-		t.Fatalf("expected BDInfo summary string, got %T", meta.BDInfo["summary"])
+	if playlistScans != 2 {
+		t.Fatalf("expected exactly 2 playlist scans, got %d", playlistScans)
 	}
-	if !strings.Contains(got, "Playlist: 00001.MPLS") {
-		t.Fatalf("unexpected summary in BDInfo: %v", got)
+	for index := range scannedRoots {
+		if !sameFilesystemPath(scannedRoots[index], bdmvPath) || scannedPlaylists[index] != "00001.MPLS" {
+			t.Fatalf("BDInfo call %d root=%q playlist=%q", index, scannedRoots[index], scannedPlaylists[index])
+		}
 	}
 }
 
@@ -960,7 +899,7 @@ func TestPrepareBDMVPartialCacheRequiresConfirmation(t *testing.T) {
 		playlistSelection: db.PlaylistSelection{
 			SelectedPlaylists: []string{"00002.MPLS", "00001.MPLS"},
 		},
-		playlistSelectionPath: filepath.ToSlash(filepath.Clean(filepath.Join(sourcePath, "BDMV"))),
+		playlistSelectionPath: filepath.ToSlash(filepath.Clean(sourcePath)),
 	}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg), WithBDInfoService(bdinfo.New(api.NopLogger{})))
@@ -980,7 +919,7 @@ func TestPrepareBDMVPartialCacheRequiresConfirmation(t *testing.T) {
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, sourcePath)
+	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{}, sourcePath)
 	if err != nil {
 		t.Fatalf("tmp dir: %v", err)
 	}
@@ -989,11 +928,10 @@ func TestPrepareBDMVPartialCacheRequiresConfirmation(t *testing.T) {
 	}
 	writeBDMVSummaryFixture(t, tmpDir, "00001.MPLS", "extended summary one")
 
-	_, err = service.Prepare(context.Background(), api.Request{
-		Paths:   []string{sourcePath},
-		Mode:    api.ModeCLI,
+	_, err = service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath: sourcePath,
 		Options: api.UploadOptions{InteractionMode: api.InteractionModeInteractive},
-	})
+	}))
 	var rescanErr *api.BDMVRescanRequiredError
 	if !errors.As(err, &rescanErr) {
 		t.Fatalf("expected rescan confirmation error, got %v", err)
@@ -1018,7 +956,7 @@ func TestPrepareBDMVPartialCacheRescansWhenConfirmed(t *testing.T) {
 		playlistSelection: db.PlaylistSelection{
 			SelectedPlaylists: []string{"00002.MPLS", "00001.MPLS"},
 		},
-		playlistSelectionPath: filepath.ToSlash(filepath.Clean(filepath.Join(sourcePath, "BDMV"))),
+		playlistSelectionPath: filepath.ToSlash(filepath.Clean(sourcePath)),
 	}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(base, "db.sqlite")}}
 	service := NewService(repo, WithMediaInfoExporter(&stubMediaInfo{}), WithSceneDetector(stubSceneDetector{}), WithConfig(cfg), WithBDInfoService(bdinfo.New(api.NopLogger{})))
@@ -1102,7 +1040,7 @@ func TestPrepareBDMVPartialCacheRescansWhenConfirmed(t *testing.T) {
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, sourcePath)
+	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{}, sourcePath)
 	if err != nil {
 		t.Fatalf("tmp dir: %v", err)
 	}
@@ -1111,12 +1049,11 @@ func TestPrepareBDMVPartialCacheRescansWhenConfirmed(t *testing.T) {
 	}
 	writeBDMVSummaryFixture(t, tmpDir, "00001.MPLS", "extended summary one")
 
-	_, err = service.Prepare(context.Background(), api.Request{
-		Paths:             []string{sourcePath},
-		Mode:              api.ModeCLI,
+	_, err = service.collectSourceEvidence(context.Background(), testCollectionRequest(t, api.Request{
+		SourcePath:        sourcePath,
 		ConfirmBDMVRescan: true,
 		Options:           api.UploadOptions{InteractionMode: api.InteractionModeInteractive},
-	})
+	}))
 	if err != nil {
 		t.Fatalf("prepare failed: %v", err)
 	}
@@ -1159,7 +1096,7 @@ func (r *recordingLogger) Warnf(format string, args ...any) {
 
 type stubSceneDetector struct{}
 
-func (stubSceneDetector) Detect(context.Context, api.PreparedMetadata) (SceneResult, error) {
+func (stubSceneDetector) Detect(context.Context, preparationstate.State) (SceneResult, error) {
 	return SceneResult{}, nil
 }
 
@@ -1168,7 +1105,7 @@ type staticSceneDetector struct {
 	err    error
 }
 
-func (s staticSceneDetector) Detect(context.Context, api.PreparedMetadata) (SceneResult, error) {
+func (s staticSceneDetector) Detect(context.Context, preparationstate.State) (SceneResult, error) {
 	return s.result, s.err
 }
 
@@ -1185,19 +1122,19 @@ func (s *stubRepo) Save(_ context.Context, metadata db.FileMetadata) error {
 	return nil
 }
 
-func (s *stubRepo) GetExternalIDs(context.Context, string) (db.ExternalIDs, error) {
-	return db.ExternalIDs{}, internalerrors.ErrNotFound
+func (s *stubRepo) GetExternalIdentity(context.Context, string) (db.Identity, error) {
+	return db.Identity{}, internalerrors.ErrNotFound
 }
 
-func (s *stubRepo) SaveExternalIDs(context.Context, db.ExternalIDs) error {
+func (s *stubRepo) SaveExternalIdentity(context.Context, db.Identity) error {
 	return internalerrors.ErrNotImplemented
 }
 
-func (s *stubRepo) GetExternalMetadata(context.Context, string) (db.ExternalMetadata, error) {
-	return db.ExternalMetadata{}, internalerrors.ErrNotFound
+func (s *stubRepo) GetExternalMetadata(context.Context, string) (db.ProviderMetadata, error) {
+	return db.ProviderMetadata{}, internalerrors.ErrNotFound
 }
 
-func (s *stubRepo) SaveExternalMetadata(context.Context, db.ExternalMetadata) error {
+func (s *stubRepo) SaveExternalMetadata(context.Context, db.ProviderMetadata) error {
 	return internalerrors.ErrNotImplemented
 }
 
@@ -1354,6 +1291,10 @@ func sortedStrings(values []string) []string {
 	return cloned
 }
 
+func sameFilesystemPath(left string, right string) bool {
+	return strings.EqualFold(filepath.Clean(left), filepath.Clean(right))
+}
+
 func assertFileContains(t *testing.T, path string, want string) {
 	t.Helper()
 	payload, err := os.ReadFile(path)
diff --git a/internal/metadata/source_lookup.go b/internal/metadata/source_lookup.go
index b6459678..90cea93c 100644
--- a/internal/metadata/source_lookup.go
+++ b/internal/metadata/source_lookup.go
@@ -10,9 +10,9 @@ import (
 	"strconv"
 	"strings"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
-	"github.com/autobrr/upbrr/pkg/api"
 )
 
 var (
@@ -35,7 +35,13 @@ type sourceLookupResolution struct {
 	Mode      string
 }
 
-func applySourceLookupOverride(meta *api.PreparedMetadata) {
+func applySourceLookupOverride(meta *preparationstate.State) {
+	applySourceLookupOverrideWithRegistry(meta, nil)
+}
+
+// applySourceLookupOverrideWithRegistry converts a source URL into tracker or
+// provider evidence without replacing explicit IDs already present in meta.
+func applySourceLookupOverrideWithRegistry(meta *preparationstate.State, registry *trackers.Registry) {
 	if meta == nil {
 		return
 	}
@@ -45,7 +51,7 @@ func applySourceLookupOverride(meta *api.PreparedMetadata) {
 		return
 	}
 
-	resolution, err := resolveSourceLookupURL(raw)
+	resolution, err := resolveSourceLookupURLWithRegistry(raw, registry)
 	if err != nil {
 		meta.LookupWarnings = append(meta.LookupWarnings, "Source URL lookup failed; using default metadata lookup flow.")
 		return
@@ -60,9 +66,11 @@ func applySourceLookupOverride(meta *api.PreparedMetadata) {
 		if meta.TrackerIDs == nil {
 			meta.TrackerIDs = make(map[string]string)
 		}
-		meta.TrackerIDs[trackerKey] = strings.TrimSpace(resolution.TrackerID)
-		meta.Trackers = []string{strings.ToUpper(trackerKey)}
-		meta.MatchedTrackers = []string{strings.ToUpper(trackerKey)}
+		if _, explicitlySet := meta.TrackerIDs[trackerKey]; !explicitlySet {
+			meta.TrackerIDs[trackerKey] = strings.TrimSpace(resolution.TrackerID)
+		}
+		meta.EvidenceTrackers = []string{strings.ToUpper(trackerKey)}
+		meta.MatchedEvidenceTrackers = []string{strings.ToUpper(trackerKey)}
 		meta.SourceLookupActive = true
 		meta.SourceLookupMode = "tracker"
 		meta.SourceLookupTracker = strings.ToUpper(trackerKey)
@@ -93,9 +101,8 @@ func applySourceLookupOverride(meta *api.PreparedMetadata) {
 		}
 		meta.SourceLookupActive = true
 		meta.SourceLookupMode = "media"
-		meta.Trackers = nil
-		meta.MatchedTrackers = nil
-		meta.TrackerIDs = nil
+		meta.EvidenceTrackers = nil
+		meta.MatchedEvidenceTrackers = nil
 		return
 	}
 
@@ -103,6 +110,10 @@ func applySourceLookupOverride(meta *api.PreparedMetadata) {
 }
 
 func resolveSourceLookupURL(raw string) (sourceLookupResolution, error) {
+	return resolveSourceLookupURLWithRegistry(raw, nil)
+}
+
+func resolveSourceLookupURLWithRegistry(raw string, registry *trackers.Registry) (sourceLookupResolution, error) {
 	parsed, err := url.Parse(strings.TrimSpace(raw))
 	if err != nil {
 		return sourceLookupResolution{}, fmt.Errorf("metadata: parse source lookup URL: %w", err)
@@ -117,8 +128,12 @@ func resolveSourceLookupURL(raw string) (sourceLookupResolution, error) {
 		return sourceLookupResolution{}, url.InvalidHostError("missing host")
 	}
 
-	if tracker, trackerID, ok := extractUnit3DTrackerID(host, parsed.Path); ok {
-		return sourceLookupResolution{Tracker: tracker, TrackerID: trackerID, Mode: "tracker"}, nil
+	if tracker, trackerID, ok := extractUnit3DTrackerID(host, parsed.Path, registry); ok {
+		return sourceLookupResolution{
+			Tracker:   tracker,
+			TrackerID: trackerID,
+			Mode:      "tracker",
+		}, nil
 	}
 
 	path := parsed.EscapedPath()
@@ -178,9 +193,10 @@ func extractTVDBIDFromQuery(host string, query url.Values) (int, bool) {
 	return id, true
 }
 
-func extractUnit3DTrackerID(host string, path string) (string, string, bool) {
-	for _, tracker := range trackers.Unit3DTrackers() {
-		baseURL, ok := unit3dmeta.BaseURL(tracker)
+func extractUnit3DTrackerID(host string, path string, registry *trackers.Registry) (string, string, bool) {
+	trackerNames := registry.NamesByFamily(trackers.FamilyUnit3D)
+	for _, tracker := range trackerNames {
+		baseURL, ok := registry.LookupBaseURL(tracker)
 		if !ok {
 			continue
 		}
diff --git a/internal/metadata/source_lookup_test.go b/internal/metadata/source_lookup_test.go
index 8aeffc4d..b01e67f4 100644
--- a/internal/metadata/source_lookup_test.go
+++ b/internal/metadata/source_lookup_test.go
@@ -6,11 +6,27 @@ package metadata
 import (
 	"testing"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/trackers"
 )
 
+func sourceLookupRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry := trackers.NewRegistry()
+	if err := registry.RegisterDescriptor(trackers.Descriptor{
+		Name:       "AITHER",
+		Family:     trackers.FamilyUnit3D,
+		BaseURL:    "https://aither.cc",
+		Definition: aitherRuleDefinition{},
+	}); err != nil {
+		t.Fatalf("register source tracker: %v", err)
+	}
+	return registry
+}
+
 func TestResolveSourceLookupURLTracker(t *testing.T) {
-	result, err := resolveSourceLookupURL("https://aither.cc/torrents/12345")
+	result, err := resolveSourceLookupURLWithRegistry("https://aither.cc/torrents/12345", sourceLookupRegistry(t))
 	if err != nil {
 		t.Fatalf("resolve tracker url: %v", err)
 	}
@@ -32,12 +48,42 @@ func TestResolveSourceLookupURLMedia(t *testing.T) {
 		provider string
 		id       int
 	}{
-		{name: "imdb", url: "https://www.imdb.com/title/tt1234567/", provider: "imdb", id: 1234567},
-		{name: "tmdb", url: "https://www.themoviedb.org/movie/765432-example-movie", provider: "tmdb", id: 765432},
-		{name: "tvmaze", url: "https://www.tvmaze.com/shows/12345/example-show", provider: "tvmaze", id: 12345},
-		{name: "tvdb", url: "https://thetvdb.com/series/456789", provider: "tvdb", id: 456789},
-		{name: "tvdb query", url: "https://www.thetvdb.com/?tab=series&id=456790", provider: "tvdb", id: 456790},
-		{name: "mal anime", url: "https://myanimelist.net/anime/54321/example-anime", provider: "mal", id: 54321},
+		{
+			name:     "imdb",
+			url:      "https://www.imdb.com/title/tt1234567/",
+			provider: "imdb",
+			id:       1234567,
+		},
+		{
+			name:     "tmdb",
+			url:      "https://www.themoviedb.org/movie/765432-example-movie",
+			provider: "tmdb",
+			id:       765432,
+		},
+		{
+			name:     "tvmaze",
+			url:      "https://www.tvmaze.com/shows/12345/example-show",
+			provider: "tvmaze",
+			id:       12345,
+		},
+		{
+			name:     "tvdb",
+			url:      "https://thetvdb.com/series/456789",
+			provider: "tvdb",
+			id:       456789,
+		},
+		{
+			name:     "tvdb query",
+			url:      "https://www.thetvdb.com/?tab=series&id=456790",
+			provider: "tvdb",
+			id:       456790,
+		},
+		{
+			name:     "mal anime",
+			url:      "https://myanimelist.net/anime/54321/example-anime",
+			provider: "mal",
+			id:       54321,
+		},
 	}
 
 	for _, tc := range cases {
@@ -74,12 +120,12 @@ func TestResolveSourceLookupURLMedia(t *testing.T) {
 }
 
 func TestApplySourceLookupOverrideTracker(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourceLookupURL: "https://aither.cc/torrents/778899",
-		Trackers:        []string{"ANT", "AITHER"},
+	meta := preparationstate.State{
+		SourceLookupURL:  "https://aither.cc/torrents/778899",
+		EvidenceTrackers: []string{"ANT", "AITHER"},
 	}
 
-	applySourceLookupOverride(&meta)
+	applySourceLookupOverrideWithRegistry(&meta, sourceLookupRegistry(t))
 
 	if !meta.SourceLookupActive {
 		t.Fatalf("expected source lookup to be active")
@@ -90,16 +136,16 @@ func TestApplySourceLookupOverrideTracker(t *testing.T) {
 	if got := meta.TrackerIDs["aither"]; got != "778899" {
 		t.Fatalf("expected aither tracker id 778899, got %q", got)
 	}
-	if len(meta.Trackers) != 1 || meta.Trackers[0] != "AITHER" {
-		t.Fatalf("expected tracker list to be narrowed to AITHER, got %v", meta.Trackers)
+	if len(meta.EvidenceTrackers) != 1 || meta.EvidenceTrackers[0] != "AITHER" {
+		t.Fatalf("expected tracker list to be narrowed to AITHER, got %v", meta.EvidenceTrackers)
 	}
 }
 
 func TestApplySourceLookupOverrideMedia(t *testing.T) {
-	meta := api.PreparedMetadata{
-		SourceLookupURL: "https://www.imdb.com/title/tt7654321/",
-		Trackers:        []string{"AITHER"},
-		TrackerIDs:      map[string]string{"aither": "101"},
+	meta := preparationstate.State{
+		SourceLookupURL:  "https://www.imdb.com/title/tt7654321/",
+		EvidenceTrackers: []string{"AITHER"},
+		TrackerIDs:       map[string]string{"aither": "101"},
 	}
 
 	applySourceLookupOverride(&meta)
@@ -113,16 +159,16 @@ func TestApplySourceLookupOverrideMedia(t *testing.T) {
 	if meta.ExternalIDOverrides.IMDBID == nil || *meta.ExternalIDOverrides.IMDBID != 7654321 {
 		t.Fatalf("expected imdb override 7654321, got %#v", meta.ExternalIDOverrides.IMDBID)
 	}
-	if len(meta.Trackers) != 0 {
-		t.Fatalf("expected trackers cleared for media url, got %v", meta.Trackers)
+	if len(meta.EvidenceTrackers) != 0 {
+		t.Fatalf("expected trackers cleared for media url, got %v", meta.EvidenceTrackers)
 	}
-	if len(meta.TrackerIDs) != 0 {
-		t.Fatalf("expected tracker ids cleared for media url, got %v", meta.TrackerIDs)
+	if got := meta.TrackerIDs["aither"]; got != "101" {
+		t.Fatalf("explicit tracker id was not preserved, got %q", got)
 	}
 }
 
 func TestApplySourceLookupOverrideFallbackWarning(t *testing.T) {
-	meta := api.PreparedMetadata{SourceLookupURL: "notaurl"}
+	meta := preparationstate.State{SourceLookupURL: "notaurl"}
 	applySourceLookupOverride(&meta)
 
 	if meta.SourceLookupActive {
diff --git a/internal/metadata/tags.go b/internal/metadata/tags.go
index 27fea930..11b14714 100644
--- a/internal/metadata/tags.go
+++ b/internal/metadata/tags.go
@@ -8,7 +8,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
 )
 
 // DetectTag returns the parsed release group as a hyphen-prefixed tag.
@@ -39,7 +39,7 @@ type SeasonPackGroupTagInfo struct {
 
 // DetectSeasonPackGroupTags parses file-list release groups and reports when a
 // season pack contains more than one group tag.
-func DetectSeasonPackGroupTags(meta api.PreparedMetadata) SeasonPackGroupTagInfo {
+func DetectSeasonPackGroupTags(meta preparationstate.State) SeasonPackGroupTagInfo {
 	if !meta.TVPack || len(meta.FileList) < 2 {
 		return SeasonPackGroupTagInfo{}
 	}
@@ -82,7 +82,7 @@ func DetectSeasonPackGroupTags(meta api.PreparedMetadata) SeasonPackGroupTagInfo
 
 // SeasonPackMixedGroupTagNotice returns the user-facing notice for season packs
 // with mismatched file-level group tags.
-func SeasonPackMixedGroupTagNotice(meta api.PreparedMetadata) (string, bool) {
+func SeasonPackMixedGroupTagNotice(meta preparationstate.State) (string, bool) {
 	info := DetectSeasonPackGroupTags(meta)
 	if !info.Mixed || strings.TrimSpace(info.Notice) == "" {
 		return "", false
diff --git a/internal/metadata/tags_test.go b/internal/metadata/tags_test.go
index 23137bdf..3178d360 100644
--- a/internal/metadata/tags_test.go
+++ b/internal/metadata/tags_test.go
@@ -8,7 +8,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/autobrr/upbrr/pkg/api"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
 )
 
 func TestDetectSeasonPackGroupTags(t *testing.T) {
@@ -16,13 +16,13 @@ func TestDetectSeasonPackGroupTags(t *testing.T) {
 
 	tests := []struct {
 		name       string
-		meta       api.PreparedMetadata
+		meta       preparationstate.State
 		wantMixed  bool
 		wantGroups []string
 	}{
 		{
 			name: "mixed season pack groups",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				TVPack: true,
 				FileList: []string{
 					"Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv",
@@ -34,7 +34,7 @@ func TestDetectSeasonPackGroupTags(t *testing.T) {
 		},
 		{
 			name: "same season pack groups",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				TVPack: true,
 				FileList: []string{
 					"Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv",
@@ -45,7 +45,7 @@ func TestDetectSeasonPackGroupTags(t *testing.T) {
 		},
 		{
 			name: "mixed groups ignored outside season packs",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				FileList: []string{
 					"Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv",
 					"Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv",
@@ -55,7 +55,7 @@ func TestDetectSeasonPackGroupTags(t *testing.T) {
 		},
 		{
 			name: "unknown groups ignored",
-			meta: api.PreparedMetadata{
+			meta: preparationstate.State{
 				TVPack: true,
 				FileList: []string{
 					"Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv",
diff --git a/internal/metadata/thexem/client.go b/internal/metadata/thexem/client.go
index 679bd0c0..e8f3fe31 100644
--- a/internal/metadata/thexem/client.go
+++ b/internal/metadata/thexem/client.go
@@ -38,12 +38,15 @@ var (
 	ipv6Pattern            = regexp.MustCompile(`(?i)\b(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}(?:%\w+)?\b`)
 )
 
+// Client maps TVDB episode numbering and season names through XEM's public API.
 type Client struct {
 	baseURL    string
 	httpClient *http.Client
 	logger     api.Logger
 }
 
+// NewClient substitutes a 12-second HTTP client and no-op logger for nil
+// dependencies.
 func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	if httpClient == nil {
 		httpClient = &http.Client{Timeout: 12 * time.Second}
@@ -58,6 +61,9 @@ func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	}
 }
 
+// MapAbsoluteEpisode maps positive TVDB and absolute episode IDs to scene season
+// and episode numbers. Missing mappings return an error; Cloudflare refusal
+// wraps [ErrUnavailable].
 func (c *Client) MapAbsoluteEpisode(ctx context.Context, tvdbID, absoluteEp int) (int, int, error) {
 	if tvdbID <= 0 || absoluteEp <= 0 {
 		return 0, 0, errors.New("thexem: invalid ids")
@@ -105,6 +111,8 @@ func (c *Client) MapAbsoluteEpisode(ctx context.Context, tvdbID, absoluteEp int)
 	return season, episode, nil
 }
 
+// GetSeasonNames returns trimmed, case-insensitively deduplicated names keyed by
+// positive season number. Cloudflare refusal wraps [ErrUnavailable].
 func (c *Client) GetSeasonNames(ctx context.Context, tvdbID int) (map[int][]string, error) {
 	if tvdbID <= 0 {
 		return nil, errors.New("thexem: invalid tvdb id")
@@ -139,6 +147,8 @@ func (c *Client) GetSeasonNames(ctx context.Context, tvdbID int) (map[int][]stri
 	return parseSeasonNames(payload), nil
 }
 
+// MatchSeasonByName normalizes separators and selects the highest season-name
+// similarity at or above 0.45, breaking ties by lower season number.
 func (c *Client) MatchSeasonByName(ctx context.Context, tvdbID int, title string) (int, error) {
 	namesBySeason, err := c.GetSeasonNames(ctx, tvdbID)
 	if err != nil {
diff --git a/internal/metadata/tmdb/anilist.go b/internal/metadata/tmdb/anilist.go
index 0e6b3578..d058bb90 100644
--- a/internal/metadata/tmdb/anilist.go
+++ b/internal/metadata/tmdb/anilist.go
@@ -29,8 +29,9 @@ const maxAniListMetadataResponseBytes int64 = 1024 * 1024
 
 var seasonPattern = regexp.MustCompile(`(?i)(?:season\s*(\d+)|\bS(\d{1,2})\b)`)
 
-// ResolveAnime enriches anime metadata from AniList, preferring an explicit MAL
-// ID and falling back to TMDB title or filename searches.
+// ResolveAnime best-effort selects AniList metadata by explicit MAL ID or title
+// and season similarity. Lookup failures are treated as no match; an explicit
+// MAL ID is retained even when no candidate resolves.
 func (c *Client) ResolveAnime(ctx context.Context, tmdbName string, input MetadataInput) (AnimeResult, error) {
 	result := AnimeResult{Demographic: "Mina"}
 	if input.MALManual != 0 {
diff --git a/internal/metadata/tmdb/client.go b/internal/metadata/tmdb/client.go
index 498d2196..073dafed 100644
--- a/internal/metadata/tmdb/client.go
+++ b/internal/metadata/tmdb/client.go
@@ -26,6 +26,7 @@ const defaultBaseURL = "https://api.themoviedb.org/3"
 
 var errNotFound = errors.New("tmdb: not found")
 
+// Client queries TMDB and shares its HTTP transport with AniList enrichment.
 type Client struct {
 	apiKey  string
 	baseURL string
@@ -33,6 +34,8 @@ type Client struct {
 	logger  api.Logger
 }
 
+// NewClient trims apiKey and substitutes a 15-second HTTP client and no-op
+// logger for nil dependencies.
 func NewClient(httpClient *http.Client, logger api.Logger, apiKey string) *Client {
 	if httpClient == nil {
 		httpClient = &http.Client{Timeout: 15 * time.Second}
@@ -48,6 +51,8 @@ func NewClient(httpClient *http.Client, logger api.Logger, apiKey string) *Clien
 	}
 }
 
+// NormalizeTitle lowercases and trims a title and normalizes ampersands to
+// "and" for provider similarity comparisons.
 func NormalizeTitle(title string) string {
 	value := strings.ToLower(title)
 	value = strings.ReplaceAll(value, "&", "and")
@@ -55,6 +60,10 @@ func NormalizeTitle(title string) string {
 	return strings.TrimSpace(value)
 }
 
+// FindByExternalID tries IMDb, then TVDB, then filename search. External-ID
+// lookup errors are treated as misses. When an IMDb ID maps to movie and TV,
+// CategoryPreference chooses; otherwise movie wins. FilenameSearch reports that
+// identifier lookup did not resolve the result.
 func (c *Client) FindByExternalID(ctx context.Context, input FindInput) (FindResult, error) {
 	imdbID := metautil.NormalizeIMDbID(input.IMDbID)
 	filenameSearch := false
@@ -182,6 +191,11 @@ func (c *Client) FindByExternalID(ctx context.Context, input FindInput) (FindRes
 	}, nil
 }
 
+// SearchID tries the parsed title, Roman-numeral and alternate titles, next year,
+// optional opposite category, and progressively reduced titles in order.
+// Provider failures are treated as misses. One candidate or a winner scoring at
+// least 0.75 with a 0.10 lead is auto-selected; Unattended selects the top
+// ambiguous candidate.
 func (c *Client) SearchID(ctx context.Context, input SearchInput) (SearchOutcome, error) {
 	input = applySearchHints(input)
 	category := strings.ToUpper(strings.TrimSpace(input.Category))
@@ -280,7 +294,11 @@ func applyReleaseHints(input FindInput) FindInput {
 		input.SearchYear = release.Year
 	}
 	if input.IMDbInfo == nil {
-		input.IMDbInfo = &IMDbInfo{Title: mainTitle, OriginalTitle: secondaryTitle, Year: release.Year}
+		input.IMDbInfo = &IMDbInfo{
+			Title:         mainTitle,
+			OriginalTitle: secondaryTitle,
+			Year:          release.Year,
+		}
 	}
 	return input
 }
@@ -341,20 +359,39 @@ func (c *Client) searchTMDb(ctx context.Context, input SearchInput, category str
 	}
 
 	if len(candidates) == 1 {
-		return SearchOutcome{TMDBID: candidates[0].TMDBID, Category: category, Candidates: candidates, AutoSelected: true}
+		return SearchOutcome{
+			TMDBID:       candidates[0].TMDBID,
+			Category:     category,
+			Candidates:   candidates,
+			AutoSelected: true,
+		}
 	}
 
 	best := candidates[0]
 	second := candidates[1]
 	if best.Similarity >= 0.75 && best.Similarity-second.Similarity >= 0.10 {
-		return SearchOutcome{TMDBID: best.TMDBID, Category: category, Candidates: candidates, AutoSelected: true}
+		return SearchOutcome{
+			TMDBID:       best.TMDBID,
+			Category:     category,
+			Candidates:   candidates,
+			AutoSelected: true,
+		}
 	}
 
 	if input.Unattended {
-		return SearchOutcome{TMDBID: best.TMDBID, Category: category, Candidates: candidates, AutoSelected: true}
+		return SearchOutcome{
+			TMDBID:       best.TMDBID,
+			Category:     category,
+			Candidates:   candidates,
+			AutoSelected: true,
+		}
 	}
 
-	return SearchOutcome{TMDBID: 0, Category: category, Candidates: candidates}
+	return SearchOutcome{
+		TMDBID:     0,
+		Category:   category,
+		Candidates: candidates,
+	}
 }
 
 func selectCandidates(ctx context.Context, c *Client, items []SearchItem, input SearchInput) []Candidate {
@@ -503,6 +540,8 @@ func (c *Client) searchTitle(ctx context.Context, filename string, year int, cat
 	return resp.Results, nil
 }
 
+// GetTranslations returns the title or name from the first exact TMDB language
+// match, or empty when no translation exists.
 func (c *Client) GetTranslations(ctx context.Context, tmdbID int, category, targetLanguage string) (string, error) {
 	endpoint := "movie"
 	if strings.EqualFold(category, "TV") {
@@ -609,7 +648,15 @@ func resultYear(item SearchItem) int {
 
 func convertRomanNumerals(title string) string {
 	roman := map[string]string{
-		"II": "2", "III": "3", "IV": "4", "V": "5", "VI": "6", "VII": "7", "VIII": "8", "IX": "9", "X": "10",
+		"II":   "2",
+		"III":  "3",
+		"IV":   "4",
+		"V":    "5",
+		"VI":   "6",
+		"VII":  "7",
+		"VIII": "8",
+		"IX":   "9",
+		"X":    "10",
 	}
 	words := strings.Fields(title)
 	converted := false
diff --git a/internal/metadata/tmdb/metadata.go b/internal/metadata/tmdb/metadata.go
index fea88457..0a9cb581 100644
--- a/internal/metadata/tmdb/metadata.go
+++ b/internal/metadata/tmdb/metadata.go
@@ -24,8 +24,9 @@ const imageBaseURL = "https://image.tmdb.org/t/p/original"
 
 var yearPattern = regexp.MustCompile(`(18|19|20)\d{2}`)
 
-// FetchMetadata loads the primary TMDB record plus optional external IDs,
-// translations, media assets, credits, keywords, and anime enrichment.
+// FetchMetadata loads the primary TMDB record plus best-effort external IDs,
+// translations, media assets, credits, and keywords. A primary-record failure
+// returns no result; optional TMDB lookup failures are logged and omitted.
 func (c *Client) FetchMetadata(ctx context.Context, input MetadataInput) (MetadataResult, error) {
 	if input.TMDBID == 0 {
 		return MetadataResult{}, errNotFound
@@ -325,7 +326,11 @@ func addRegionalGenericCandidate(candidates map[string]localizedTitleCandidate,
 	if currentOK && current.priority < priority {
 		return
 	}
-	candidates[language] = localizedTitleCandidate{title: title, regionalKey: regionalKey, priority: priority}
+	candidates[language] = localizedTitleCandidate{
+		title:       title,
+		regionalKey: regionalKey,
+		priority:    priority,
+	}
 }
 
 // defaultRegionalTitleKey returns the language's conventional same-region tag
@@ -409,7 +414,7 @@ func (c *Client) GetEpisodeDetails(ctx context.Context, tmdbID, season, episode
 		EpisodeNumber: resp.EpisodeNumber,
 		SeasonNumber:  resp.SeasonNumber,
 		Runtime:       resp.Runtime,
-		IMDbID:        resp.ExternalIDs.IMDbID,
+		IMDbID:        resp.Identity.IMDbID,
 	}
 	if resp.StillPath != "" {
 		details.StillURL = imageBaseURL + resp.StillPath
@@ -462,6 +467,9 @@ func (c *Client) GetSeasonDetails(ctx context.Context, tmdbID, season int) (Seas
 	return result, nil
 }
 
+// DailyToSeasonEpisode selects the highest numbered season whose air date is not
+// after date, then returns the episode with the same YYYY-MM-DD air date. Missing
+// IDs, seasons, or exact episode dates return the package not-found error.
 func (c *Client) DailyToSeasonEpisode(ctx context.Context, tmdbID int, date time.Time) (int, int, error) {
 	if tmdbID == 0 {
 		return 0, 0, errNotFound
@@ -500,6 +508,10 @@ func (c *Client) DailyToSeasonEpisode(ctx context.Context, tmdbID int, date time
 	return 0, 0, errNotFound
 }
 
+// GetLocalizedData fetches one main, season, or episode response in the requested
+// language. With CachePath, entries are serialized per process and keyed by
+// language and DataType; malformed cache contents and cache-write failures are
+// treated as misses while provider failures are returned.
 func (c *Client) GetLocalizedData(ctx context.Context, input LocalizedDataInput) (map[string]any, error) {
 	endpoint, err := localizedEndpoint(input)
 	if err != nil {
@@ -760,6 +772,8 @@ func findTrailer(items []videoItem) string {
 	return ""
 }
 
+// ExtractIMDbID accepts a numeric ID, tt-prefixed ID, or an IMDb /title/<id>/
+// URL without a trailing subpath. Malformed input returns zero.
 func ExtractIMDbID(value string) int {
 	value = strings.TrimSpace(value)
 	if value == "" {
@@ -985,7 +999,7 @@ type episodeDetailsResponse struct {
 	EpisodeNumber int     `json:"episode_number"`
 	SeasonNumber  int     `json:"season_number"`
 	Runtime       int     `json:"runtime"`
-	ExternalIDs   struct {
+	Identity      struct {
 		IMDbID string `json:"imdb_id"`
 	} `json:"external_ids"`
 	Crew       []creditMember `json:"crew"`
diff --git a/internal/metadata/tmdb/metadata_test.go b/internal/metadata/tmdb/metadata_test.go
index 3d8b7245..35efe72e 100644
--- a/internal/metadata/tmdb/metadata_test.go
+++ b/internal/metadata/tmdb/metadata_test.go
@@ -261,8 +261,16 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 				"pt-PT": "Titulo Portugal",
 			},
 			translations: []Translation{
-				{ISO6391: "pt", ISO31661: "PT", Data: TranslationData{Title: "Titulo Portugal"}},
-				{ISO6391: " pt ", ISO31661: " br ", Data: TranslationData{Title: "Titulo Brasil"}},
+				{
+					ISO6391:  "pt",
+					ISO31661: "PT",
+					Data:     TranslationData{Title: "Titulo Portugal"},
+				},
+				{
+					ISO6391:  " pt ",
+					ISO31661: " br ",
+					Data:     TranslationData{Title: "Titulo Brasil"},
+				},
 			},
 		},
 		{
@@ -274,8 +282,16 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 				"pt-PT": "Titulo Portugal",
 			},
 			translations: []Translation{
-				{ISO6391: " pt ", ISO31661: " br ", Data: TranslationData{Title: "Titulo Brasil"}},
-				{ISO6391: "pt", ISO31661: "PT", Data: TranslationData{Title: "Titulo Portugal"}},
+				{
+					ISO6391:  " pt ",
+					ISO31661: " br ",
+					Data:     TranslationData{Title: "Titulo Brasil"},
+				},
+				{
+					ISO6391:  "pt",
+					ISO31661: "PT",
+					Data:     TranslationData{Title: "Titulo Portugal"},
+				},
 			},
 		},
 		{
@@ -284,7 +300,11 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 			wantGeneric:     "American Title",
 			wantRegional:    map[string]string{"en-US": "American Title"},
 			translations: []Translation{
-				{ISO6391: "en", ISO31661: "US", Data: TranslationData{Title: "American Title"}},
+				{
+					ISO6391:  "en",
+					ISO31661: "US",
+					Data:     TranslationData{Title: "American Title"},
+				},
 			},
 		},
 		{
@@ -293,7 +313,11 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 			wantGeneric:     "Titre Canadien",
 			wantRegional:    map[string]string{"fr-CA": "Titre Canadien"},
 			translations: []Translation{
-				{ISO6391: " fr ", ISO31661: " ca ", Data: TranslationData{Title: "Titre Canadien"}},
+				{
+					ISO6391:  " fr ",
+					ISO31661: " ca ",
+					Data:     TranslationData{Title: "Titre Canadien"},
+				},
 			},
 		},
 		{
@@ -302,7 +326,11 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 			wantGeneric:     "Serie Mexicana",
 			wantRegional:    map[string]string{"es-MX": "Serie Mexicana"},
 			translations: []Translation{
-				{ISO6391: "es", ISO31661: "MX", Data: TranslationData{Name: "Serie Mexicana"}},
+				{
+					ISO6391:  "es",
+					ISO31661: "MX",
+					Data:     TranslationData{Name: "Serie Mexicana"},
+				},
 			},
 		},
 	}
@@ -325,10 +353,22 @@ func TestBuildLocalizedTitlesUsesDeterministicGenericRegionalCandidate(t *testin
 
 func TestBuildLocalizedTitlesKeepsNeutralGenericOverRegionalCandidate(t *testing.T) {
 	titles := buildLocalizedTitles([]Translation{
-		{ISO6391: "pt", ISO31661: "PT", Data: TranslationData{Title: "Titulo Portugal"}},
+		{
+			ISO6391:  "pt",
+			ISO31661: "PT",
+			Data:     TranslationData{Title: "Titulo Portugal"},
+		},
 		{ISO6391: "pt", Data: TranslationData{Title: "Titulo Neutro"}},
-		{ISO6391: "de", ISO31661: "DE", Data: TranslationData{Title: "Deutscher Titel"}},
-		{ISO6391: "en", ISO31661: "US", Data: TranslationData{Title: "American English"}},
+		{
+			ISO6391:  "de",
+			ISO31661: "DE",
+			Data:     TranslationData{Title: "Deutscher Titel"},
+		},
+		{
+			ISO6391:  "en",
+			ISO31661: "US",
+			Data:     TranslationData{Title: "American English"},
+		},
 		{ISO6391: "en", Data: TranslationData{Title: "Neutral English"}},
 	})
 
@@ -351,7 +391,11 @@ func TestBuildLocalizedTitlesKeepsNeutralGenericOverRegionalCandidate(t *testing
 
 func TestBuildLocalizedTitlesUsesTVTranslationName(t *testing.T) {
 	titles := buildLocalizedTitles([]Translation{
-		{ISO6391: "es", ISO31661: "ES", Data: TranslationData{Name: "Serie Espanola"}},
+		{
+			ISO6391:  "es",
+			ISO31661: "ES",
+			Data:     TranslationData{Name: "Serie Espanola"},
+		},
 	})
 
 	if got := titles["es"]; got != "Serie Espanola" {
diff --git a/internal/metadata/tmdb/types.go b/internal/metadata/tmdb/types.go
index f0e22731..9b3c25db 100644
--- a/internal/metadata/tmdb/types.go
+++ b/internal/metadata/tmdb/types.go
@@ -11,6 +11,8 @@ type IMDbInfo struct {
 	Year             int
 }
 
+// FindInput supplies external-ID and filename evidence for TMDB identity
+// resolution. CategoryPreference disambiguates IDs that map to movie and TV.
 type FindInput struct {
 	IMDbID             string
 	TVDBID             int
@@ -22,6 +24,9 @@ type FindInput struct {
 	Debug              bool
 }
 
+// FindResult retains filename-search candidates when identity cannot be selected
+// automatically. FilenameSearch distinguishes fallback results from external-ID
+// matches.
 type FindResult struct {
 	Category         string
 	TMDBID           int
@@ -31,6 +36,9 @@ type FindResult struct {
 	AutoSelected     bool
 }
 
+// SearchInput controls candidate fallback and selection. DontSwitch prevents
+// trying the opposite movie/TV category; Unattended resolves ambiguity to the
+// top-ranked candidate.
 type SearchInput struct {
 	Filename       string
 	SearchYear     int
@@ -41,6 +49,8 @@ type SearchInput struct {
 	Debug          bool
 }
 
+// SearchOutcome retains ranked candidates when interactive ambiguity leaves
+// TMDBID unset.
 type SearchOutcome struct {
 	TMDBID       int
 	Category     string
@@ -100,6 +110,8 @@ type TranslationData struct {
 	Name  string `json:"name"`
 }
 
+// MetadataInput controls primary TMDB enrichment and optional logo, anime,
+// language, identity, and season evidence.
 type MetadataInput struct {
 	TMDBID           int
 	Category         string
@@ -121,6 +133,9 @@ type MetadataInput struct {
 	Season           string
 }
 
+// MetadataResult contains normalized primary fields and any optional enrichment
+// that completed successfully. Runtime is minutes; LocalizedTitles keys are
+// generic language codes or regional language tags.
 type MetadataResult struct {
 	Title            string
 	Year             int
@@ -252,6 +267,8 @@ type LogoOptions struct {
 	Languages []string
 }
 
+// LocalizedDataInput identifies a main, season, or episode request. CachePath is
+// a host filesystem JSON cache shared by language and DataType.
 type LocalizedDataInput struct {
 	DataType         string
 	Category         string
diff --git a/internal/metadata/tmdb_localized_test.go b/internal/metadata/tmdb_localized_test.go
index a5e50468..89c2d71c 100644
--- a/internal/metadata/tmdb_localized_test.go
+++ b/internal/metadata/tmdb_localized_test.go
@@ -25,8 +25,16 @@ func TestParseTMDBLocalizedData(t *testing.T) {
 			},
 			"videos": map[string]any{
 				"results": []any{
-					map[string]any{"site": "YouTube", "type": "Teaser", "key": "teaser"},
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": "trailer"},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Teaser",
+						"key":  "teaser",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "trailer",
+					},
 				},
 			},
 			"content_ratings": map[string]any{
@@ -161,45 +169,89 @@ func TestParseTMDBLocalizedData(t *testing.T) {
 			{
 				name: "trailer type wins over adjacent teaser",
 				data: []any{
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": "official"},
-					map[string]any{"site": "YouTube", "type": "Teaser", "key": "teaser"},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "official",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Teaser",
+						"key":  "teaser",
+					},
 				},
 				want: "https://www.youtube.com/watch?v=official",
 			},
 			{
 				name: "teaser only ignored",
 				data: []any{
-					map[string]any{"site": "YouTube", "type": "Teaser", "key": "teaser"},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Teaser",
+						"key":  "teaser",
+					},
 				},
 			},
 			{
 				name: "non trailer video types ignored",
 				data: []any{
-					map[string]any{"site": "YouTube", "type": "Featurette", "key": "featurette"},
-					map[string]any{"site": "YouTube", "type": "Recap", "key": "recap"},
-					map[string]any{"site": "YouTube", "type": "Opening Credits", "key": "credits"},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Featurette",
+						"key":  "featurette",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Recap",
+						"key":  "recap",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Opening Credits",
+						"key":  "credits",
+					},
 				},
 			},
 			{
 				name: "non youtube trailer ignored and youtube trailer accepted",
 				data: []any{
-					map[string]any{"site": "Vimeo", "type": "Trailer", "key": "vimeo"},
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": "youtube"},
+					map[string]any{
+						"site": "Vimeo",
+						"type": "Trailer",
+						"key":  "vimeo",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "youtube",
+					},
 				},
 				want: "https://www.youtube.com/watch?v=youtube",
 			},
 			{
 				name: "first youtube trailer wins",
 				data: []any{
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": "first"},
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": "second"},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "first",
+					},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "second",
+					},
 				},
 				want: "https://www.youtube.com/watch?v=first",
 			},
 			{
 				name: "empty video key ignored",
 				data: []any{
-					map[string]any{"site": "YouTube", "type": "Trailer", "key": ""},
+					map[string]any{
+						"site": "YouTube",
+						"type": "Trailer",
+						"key":  "",
+					},
 				},
 			},
 		}
@@ -228,11 +280,31 @@ func TestParseTMDBLocalizedData(t *testing.T) {
 		}{
 			{name: "empty", path: ""},
 			{name: "whitespace", path: " \t\n "},
-			{name: "relative with slash", path: "/poster.jpg", want: "https://image.tmdb.org/t/p/original/poster.jpg"},
-			{name: "relative without slash", path: "poster.jpg", want: "https://image.tmdb.org/t/p/original/poster.jpg"},
-			{name: "trim relative path", path: " /poster.jpg ", want: "https://image.tmdb.org/t/p/original/poster.jpg"},
-			{name: "absolute https", path: "https://cdn.example/poster.jpg", want: "https://cdn.example/poster.jpg"},
-			{name: "absolute http", path: "http://cdn.example/poster.jpg", want: "http://cdn.example/poster.jpg"},
+			{
+				name: "relative with slash",
+				path: "/poster.jpg",
+				want: "https://image.tmdb.org/t/p/original/poster.jpg",
+			},
+			{
+				name: "relative without slash",
+				path: "poster.jpg",
+				want: "https://image.tmdb.org/t/p/original/poster.jpg",
+			},
+			{
+				name: "trim relative path",
+				path: " /poster.jpg ",
+				want: "https://image.tmdb.org/t/p/original/poster.jpg",
+			},
+			{
+				name: "absolute https",
+				path: "https://cdn.example/poster.jpg",
+				want: "https://cdn.example/poster.jpg",
+			},
+			{
+				name: "absolute http",
+				path: "http://cdn.example/poster.jpg",
+				want: "http://cdn.example/poster.jpg",
+			},
 			{name: "malformed absolute", path: "https://"},
 			{name: "unsupported scheme", path: "ftp://cdn.example/poster.jpg"},
 			{name: "scheme relative", path: "//cdn.example/poster.jpg"},
diff --git a/internal/metadata/tracker_artifacts.go b/internal/metadata/tracker_artifacts.go
index 81c9c778..2ad2fdd2 100644
--- a/internal/metadata/tracker_artifacts.go
+++ b/internal/metadata/tracker_artifacts.go
@@ -20,10 +20,11 @@ import (
 	"sync"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/paths"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/pkg/api"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 )
 
 const (
@@ -36,7 +37,18 @@ var newUnit3DArtifactImageHTTPClient = func() *http.Client {
 	return trackerdata.Unit3DImageHTTPClient(&http.Client{Timeout: unit3dImageTimeout})
 }
 
-func (s *Service) persistUnit3DArtifacts(ctx context.Context, meta api.PreparedMetadata, tracker string, result trackerdata.Result, keepImages bool) []string {
+// persistUnit3DArtifacts best-effort persists a tracker description and bounded,
+// validated images beneath the release's private temporary directory. Existing
+// non-empty files are reused, image downloads run concurrently, and the returned
+// URL slice preserves input indexes with empty entries for failed downloads.
+// Cancellation returns URLs completed before workers stop.
+func (s *Service) persistUnit3DArtifacts(
+	ctx context.Context,
+	meta preparationstate.State,
+	tracker string,
+	result trackerdata.Result,
+	keepImages bool,
+) []string {
 	if strings.TrimSpace(result.Description) == "" && (len(result.Validated) == 0 || !keepImages) {
 		if s.logger != nil {
 			s.logger.Debugf("metadata: unit3d artifacts skipped (no description/images)")
@@ -71,7 +83,13 @@ func (s *Service) persistUnit3DArtifacts(ctx context.Context, meta api.PreparedM
 		return nil
 	}
 	if s.logger != nil {
-		s.logger.Debugf("metadata: unit3d artifacts dir=%s desc=%t images=%d keepImages=%t", artifactDir, strings.TrimSpace(result.Description) != "", len(result.Validated), keepImages)
+		s.logger.Debugf(
+			"metadata: unit3d artifacts dir=%s desc=%t images=%d keepImages=%t",
+			artifactDir,
+			strings.TrimSpace(result.Description) != "",
+			len(result.Validated),
+			keepImages,
+		)
 	}
 
 	if strings.TrimSpace(result.Description) != "" {
diff --git a/internal/metadata/tracker_artifacts_test.go b/internal/metadata/tracker_artifacts_test.go
index e86708f4..0c914aeb 100644
--- a/internal/metadata/tracker_artifacts_test.go
+++ b/internal/metadata/tracker_artifacts_test.go
@@ -13,9 +13,11 @@ import (
 	"testing"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackerdata"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -93,7 +95,7 @@ func TestPersistUnit3DArtifactsMaxConcurrentImageDownloads(t *testing.T) {
 		logger: api.NopLogger{},
 	}
 
-	meta := api.PreparedMetadata{SourcePath: filepath.Join(tempDir, "source")}
+	meta := preparationstate.State{SourcePath: filepath.Join(tempDir, "source")}
 	result := trackerdata.Result{Validated: validated}
 
 	successful := svc.persistUnit3DArtifacts(context.Background(), meta, "BHD", result, true)
@@ -133,7 +135,7 @@ func TestPersistUnit3DArtifactsRejectsPrivateImageURLBeforeDownload(t *testing.T
 		logger: api.NopLogger{},
 	}
 
-	meta := api.PreparedMetadata{SourcePath: filepath.Join(tempDir, "source")}
+	meta := preparationstate.State{SourcePath: filepath.Join(tempDir, "source")}
 	result := trackerdata.Result{Validated: []bbcode.Image{{RawURL: "http://127.0.0.1/private.png"}}}
 
 	successful := svc.persistUnit3DArtifacts(context.Background(), meta, "BHD", result, true)
diff --git a/internal/metadata/tracker_claims.go b/internal/metadata/tracker_claims.go
index f8c0b69a..3cee404b 100644
--- a/internal/metadata/tracker_claims.go
+++ b/internal/metadata/tracker_claims.go
@@ -12,15 +12,15 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/logging"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerdata"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -28,13 +28,14 @@ const trackerClaimsCacheTTL = 24 * time.Hour
 const trackerClaimRuleActive = "claim_active"
 
 type trackerClaimProvider interface {
-	cachePath(dbPath string, tracker string) (string, error)
-	cacheTTL() time.Duration
-	hasClaim(ctx context.Context, s *Service, tracker string, meta api.PreparedMetadata) (bool, error)
+	hasClaim(ctx context.Context, s *Service, tracker string, meta api.UploadSubject) (bool, error)
+	failureReason(meta api.UploadSubject) string
 }
 
 type apiTrackerClaimProvider struct{}
 
+type registryTrackerClaimProvider struct{ checker trackers.ClaimChecker }
+
 type trackerClaimsCache struct {
 	LastUpdated string              `json:"last_updated"`
 	Claims      []trackerClaimEntry `json:"extracted_data"`
@@ -71,67 +72,91 @@ type trackerClaimsAttributes struct {
 	Types       trackerClaimTypes       `json:"types"`
 }
 
-func (s *Service) applyTrackerClaims(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	resolved := uniqueUpperTrackers(trackersWithClaimChecks(meta))
+func (s *Service) evaluateTrackerClaims(ctx context.Context, meta api.UploadSubject) (api.UploadSubject, error) {
+	logger := logging.FromContext(ctx, s.logger)
+	resolved := uniqueUpperTrackers(s.trackersWithClaimChecks(meta))
 	if len(resolved) == 0 {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: tracker claims skipped (no eligible trackers)")
-		}
+		logger.Debugf("metadata: tracker claims skipped (no eligible trackers)")
 		return meta, nil
 	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: tracker claims evaluating trackers=%v", resolved)
-	}
+	logger.Debugf("metadata: tracker claims evaluating trackers=%v", resolved)
 
 	for _, tracker := range resolved {
 		select {
 		case <-ctx.Done():
-			return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+			return api.UploadSubject{}, fmt.Errorf("context canceled: %w", ctx.Err())
 		default:
 		}
 
-		match, err := s.hasTrackerClaim(ctx, tracker, meta)
+		match, err := s.hasTrackerClaim(ctx, tracker, meta, logger)
 		if err != nil {
-			return api.PreparedMetadata{}, err
+			return api.UploadSubject{}, err
 		}
 		if !match {
 			continue
 		}
 
-		meta.BlockedTrackers = addMetadataTrackerBlockReason(meta.BlockedTrackers, tracker, api.TrackerBlockReasonClaim)
-		meta.TrackerRuleFailures = addMetadataTrackerRuleFailure(meta.TrackerRuleFailures, tracker, api.RuleFailure{
-			Rule:   trackerClaimRuleActive,
-			Reason: trackerClaimFailureReason(tracker, meta, s),
-		})
-		if s.logger != nil {
-			if strings.EqualFold(tracker, "BTN") {
-				s.logger.Debugf("metadata: tracker claim match found tracker=%s", tracker)
-			} else {
-				s.logger.Warnf("metadata: tracker claim match found tracker=%s decision=blocked reason=%s", tracker, trackerClaimRuleActive)
-			}
+		meta.TrackerRuleFailures = addMetadataTrackerRuleFailure(
+			meta.TrackerRuleFailures,
+			tracker,
+			trackerClaimRuleFailure(trackerClaimFailureReason(tracker, meta, s, logger)),
+		)
+		if _, ok := s.registry.LookupClaimCheckerFactory(tracker); ok {
+			logger.Debugf("metadata: tracker claim match found tracker=%s", tracker)
+		} else {
+			logger.Warnf("metadata: tracker claim match found tracker=%s decision=blocked reason=%s", tracker, trackerClaimRuleActive)
 		}
 	}
 
 	return meta, nil
 }
 
-func (s *Service) hasTrackerClaim(ctx context.Context, tracker string, meta api.PreparedMetadata) (bool, error) {
-	provider, ok := resolveTrackerClaimProvider(tracker)
+func trackerClaimRuleFailure(reason string) api.RuleFailure {
+	return api.RuleFailure{
+		Rule:        trackerClaimRuleActive,
+		Reason:      reason,
+		Disposition: api.RuleDispositionStrict,
+	}
+}
+
+// EvaluateTrackerClaims evaluates every eligible tracker from the subject and
+// appends strict claim_active failures for matches. Registry claim checkers run
+// directly; API-backed policies may refresh a private 24-hour filesystem cache.
+// The subject and its maps must be operation-owned because failures are appended
+// in place. Any cancellation, checker, fetch, or cache error discards the partial
+// result. Prepared-release state is neither read nor published.
+func (s *Service) EvaluateTrackerClaims(ctx context.Context, subject api.UploadSubject) (api.UploadSubject, error) {
+	return s.evaluateTrackerClaims(ctx, subject)
+}
+
+func (s *Service) hasTrackerClaim(ctx context.Context, tracker string, meta api.UploadSubject, logger api.Logger) (bool, error) {
+	provider, ok := s.resolveTrackerClaimProvider(tracker, logger)
 	if !ok {
 		return false, nil
 	}
 	return provider.hasClaim(ctx, s, tracker, meta)
 }
 
-func resolveTrackerClaimProvider(tracker string) (trackerClaimProvider, bool) {
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "BTN":
-		return btnTrackerClaimProvider{}, true
-	case "AITHER":
+func (s *Service) resolveTrackerClaimProvider(tracker string, logger api.Logger) (trackerClaimProvider, bool) {
+	if factory, ok := s.registry.LookupClaimCheckerFactory(tracker); ok {
+		return registryTrackerClaimProvider{checker: factory.NewClaimChecker(s.cfg, logger)}, true
+	}
+	if policy, ok := s.registry.LookupClaimPolicy(tracker); ok && policy.APIBacked {
 		return apiTrackerClaimProvider{}, true
-	default:
-		return nil, false
 	}
+	return nil, false
+}
+
+func (p registryTrackerClaimProvider) hasClaim(ctx context.Context, _ *Service, _ string, meta api.UploadSubject) (bool, error) {
+	match, err := p.checker.HasClaim(ctx, meta)
+	if err != nil {
+		return false, fmt.Errorf("metadata: evaluate tracker claim: %w", err)
+	}
+	return match, nil
+}
+
+func (p registryTrackerClaimProvider) failureReason(meta api.UploadSubject) string {
+	return p.checker.FailureReason(meta)
 }
 
 func (apiTrackerClaimProvider) cachePath(dbPath string, tracker string) (string, error) {
@@ -142,7 +167,7 @@ func (apiTrackerClaimProvider) cacheTTL() time.Duration {
 	return trackerClaimsCacheTTL
 }
 
-func (p apiTrackerClaimProvider) hasClaim(ctx context.Context, s *Service, tracker string, meta api.PreparedMetadata) (bool, error) {
+func (p apiTrackerClaimProvider) hasClaim(ctx context.Context, s *Service, tracker string, meta api.UploadSubject) (bool, error) {
 	cachePath, err := p.cachePath(s.cfg.MainSettings.DBPath, tracker)
 	if err != nil {
 		return false, fmt.Errorf("metadata: tracker claims path %s: %w", tracker, err)
@@ -180,6 +205,8 @@ func (p apiTrackerClaimProvider) hasClaim(ctx context.Context, s *Service, track
 	return false, nil
 }
 
+func (apiTrackerClaimProvider) failureReason(api.UploadSubject) string { return "" }
+
 func (s *Service) loadTrackerClaims(ctx context.Context, tracker string, cachePath string, cacheTTL time.Duration) ([]trackerClaimEntry, error) {
 	if payload, ok := loadFreshTrackerClaimsCache(cachePath, cacheTTL); ok {
 		return payload.Claims, nil
@@ -233,7 +260,7 @@ func writeTrackerClaimsCache(path string, claims []trackerClaimEntry) error {
 }
 
 func (s *Service) fetchTrackerClaims(ctx context.Context, tracker string) ([]trackerClaimEntry, error) {
-	baseURL, ok := trackerClaimsBaseURL(s.cfg, tracker)
+	baseURL, ok := trackerClaimsBaseURL(s.cfg, s.registry, tracker)
 	if !ok {
 		return nil, nil
 	}
@@ -345,10 +372,10 @@ type trackerClaimMatchTarget struct {
 // trackerClaimTarget builds the canonical upload identity used to compare
 // tracker-side claim records. TV claim matching requires provider-resolved
 // season metadata and intentionally ignores parsed release fallbacks.
-func trackerClaimTarget(meta api.PreparedMetadata) (trackerClaimMatchTarget, bool) {
+func trackerClaimTarget(meta api.UploadSubject) (trackerClaimMatchTarget, bool) {
 	season, _ := meta.CanonicalSeasonEpisode()
 	target := trackerClaimMatchTarget{
-		tmdbID:     meta.ExternalIDs.TMDBID,
+		tmdbID:     meta.Identity.TMDBID,
 		season:     season,
 		category:   trackerdata.CanonicalUnit3DCategory(resolveTrackerClaimCategory(meta)),
 		typeName:   trackerdata.CanonicalUnit3DType(resolveTrackerClaimType(meta)),
@@ -364,19 +391,11 @@ func trackerClaimTarget(meta api.PreparedMetadata) (trackerClaimMatchTarget, boo
 	return target, true
 }
 
-func resolveTrackerClaimCategory(meta api.PreparedMetadata) string {
-	for _, candidate := range []string{meta.ExternalIDs.Category, meta.MediaInfoCategory, meta.Release.Category} {
-		if canonical := trackerdata.CanonicalUnit3DCategory(candidate); canonical != "" {
-			return canonical
-		}
-	}
-	if isTVCategory(meta) {
-		return "TV"
-	}
-	return "MOVIE"
+func resolveTrackerClaimCategory(meta api.UploadSubject) string {
+	return trackerdata.CanonicalUnit3DCategory(string(meta.Identity.Category))
 }
 
-func resolveTrackerClaimType(meta api.PreparedMetadata) string {
+func resolveTrackerClaimType(meta api.UploadSubject) string {
 	for _, candidate := range []string{meta.Type, meta.Release.Type, meta.Source, meta.Release.Source} {
 		if canonical := trackerdata.CanonicalUnit3DType(candidate); canonical != "" {
 			return canonical
@@ -385,7 +404,7 @@ func resolveTrackerClaimType(meta api.PreparedMetadata) string {
 	return ""
 }
 
-func resolveTrackerClaimResolution(meta api.PreparedMetadata) string {
+func resolveTrackerClaimResolution(meta api.UploadSubject) string {
 	for _, candidate := range []string{meta.Release.Resolution} {
 		if canonical := trackerdata.CanonicalUnit3DResolution(candidate); canonical != "" {
 			return canonical
@@ -402,13 +421,13 @@ func trackerClaimsPath(dbPath string, tracker string) (string, error) {
 	return path, nil
 }
 
-func trackerClaimsBaseURL(cfg config.Config, tracker string) (string, bool) {
+func trackerClaimsBaseURL(cfg config.Config, registry *trackers.Registry, tracker string) (string, bool) {
 	if entry, ok := trackerConfigFor(cfg, tracker); ok {
 		if announceBase := announceBaseURL(entry.AnnounceURL); announceBase != "" {
 			return announceBase, true
 		}
 	}
-	return unit3dmeta.BaseURL(tracker)
+	return registry.LookupBaseURL(tracker)
 }
 
 func announceBaseURL(value string) string {
@@ -426,7 +445,7 @@ func announceBaseURL(value string) string {
 	return strings.TrimRight(parsed.String(), "/")
 }
 
-func trackersWithClaimChecks(meta api.PreparedMetadata) []string {
+func (s *Service) trackersWithClaimChecks(meta api.UploadSubject) []string {
 	resolved := resolveClaimTrackerCandidates(meta)
 	if len(resolved) == 0 {
 		return nil
@@ -435,15 +454,16 @@ func trackersWithClaimChecks(meta api.PreparedMetadata) []string {
 	selected := make([]string, 0, len(resolved))
 	for _, tracker := range resolved {
 		normalized := strings.ToUpper(strings.TrimSpace(tracker))
-		switch normalized {
-		case "AITHER", "BTN":
+		_, hasFactory := s.registry.LookupClaimCheckerFactory(normalized)
+		policy, hasPolicy := s.registry.LookupClaimPolicy(normalized)
+		if hasFactory || hasPolicy && policy.APIBacked {
 			selected = append(selected, normalized)
 		}
 	}
 	return selected
 }
 
-func resolveClaimTrackerCandidates(meta api.PreparedMetadata) []string {
+func resolveClaimTrackerCandidates(meta api.UploadSubject) []string {
 	values := make([]string, 0, len(meta.Trackers)+len(meta.MatchedTrackers)+len(meta.TrackerIDs))
 	values = append(values, meta.Trackers...)
 	values = append(values, meta.MatchedTrackers...)
@@ -473,21 +493,6 @@ func uniqueUpperTrackers(values []string) []string {
 	return out
 }
 
-func addMetadataTrackerBlockReason(blocked map[string][]api.TrackerBlockReason, tracker string, reason api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	if name == "" || strings.TrimSpace(string(reason)) == "" {
-		return blocked
-	}
-	if blocked == nil {
-		blocked = make(map[string][]api.TrackerBlockReason)
-	}
-	if slices.Contains(blocked[name], reason) {
-		return blocked
-	}
-	blocked[name] = append(blocked[name], reason)
-	return blocked
-}
-
 func addMetadataTrackerRuleFailure(failures map[string][]api.RuleFailure, tracker string, failure api.RuleFailure) map[string][]api.RuleFailure {
 	name := strings.ToUpper(strings.TrimSpace(tracker))
 	rule := strings.TrimSpace(failure.Rule)
@@ -503,18 +508,22 @@ func addMetadataTrackerRuleFailure(failures map[string][]api.RuleFailure, tracke
 			return failures
 		}
 	}
-	failures[name] = append(failures[name], api.RuleFailure{Rule: rule, Reason: reason})
+	failures[name] = append(failures[name], api.RuleFailure{
+		Rule:        rule,
+		Reason:      reason,
+		Disposition: api.NormalizeRuleDisposition(failure.Disposition),
+	})
 	return failures
 }
 
-func trackerClaimFailureReason(tracker string, meta api.PreparedMetadata, s *Service) string {
+func trackerClaimFailureReason(tracker string, meta api.UploadSubject, s *Service, logger api.Logger) string {
 	name := strings.ToUpper(strings.TrimSpace(tracker))
-	switch name {
-	case "BTN":
-		return btnClaimFailureReason(meta, s.btnClaimWindowGraceHours())
-	default:
-		return name + " has an active claim for this release"
+	if provider, ok := s.resolveTrackerClaimProvider(name, logger); ok {
+		if reason := strings.TrimSpace(provider.failureReason(meta)); reason != "" {
+			return reason
+		}
 	}
+	return name + " has an active claim for this release"
 }
 
 func containsTrackerClaimValue(values []string, target string) bool {
@@ -616,8 +625,8 @@ func decodeTrackerClaimValue(raw json.RawMessage, namesByID func(string) []strin
 	return nil, fmt.Errorf("metadata: invalid tracker claim value %s", string(raw))
 }
 
-func isTVCategory(meta api.PreparedMetadata) bool {
-	return meta.HasTVSeasonEpisodeSignal() ||
+func isTVCategory(meta api.UploadSubject) bool {
+	return meta.SeasonInt > 0 || meta.EpisodeInt > 0 || meta.Release.Season > 0 || meta.Release.Episode > 0 ||
 		meta.TVPack ||
 		strings.TrimSpace(meta.DailyEpisodeDate) != ""
 }
diff --git a/internal/metadata/tracker_claims_btn.go b/internal/metadata/tracker_claims_btn.go
deleted file mode 100644
index e719c295..00000000
--- a/internal/metadata/tracker_claims_btn.go
+++ /dev/null
@@ -1,973 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package metadata
-
-import (
-	"bytes"
-	"context"
-	"crypto/hmac"
-	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
-	"encoding/base32"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"html"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	htmlnode "golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	btnSiteBaseURL             = "https://broadcasthe.net"
-	btnBackupBaseURL           = "https://backup.landof.tv"
-	btnUserPath                = "/user.php"
-	btnLoginPath               = "/login.php"
-	btnClaimedShowsURL         = "https://broadcasthe.net/forums.php?action=viewthread&threadid=30793"
-	btnClaimedShowsPostID      = "post1405482"
-	btnClaimedShowsCacheTTL    = 48 * time.Hour
-	btnClaimWindowBaseHours    = 48
-	btnClaimWindowDefaultGrace = 24
-)
-
-var (
-	btnLineBreakPattern  = regexp.MustCompile(`(?i)<br\s*/?>`)
-	btnTagPattern        = regexp.MustCompile(`(?s)<[^>]*>`)
-	btnAKAExtractPattern = regexp.MustCompile(`(?i)\(\s*aka\s*:\s*([^\)]*?)\)`)
-	btnSxxExxCutPattern  = regexp.MustCompile(`(?i)\bS\d{1,2}E\d{1,3}\b`)
-	btnSeasonCutPattern  = regexp.MustCompile(`(?i)\bS\d{1,2}\b`)
-	btnDateCutPattern    = regexp.MustCompile(`\b\d{4}[\-\.]\d{2}[\-\.]\d{2}\b`)
-	btnNonAlnumPattern   = regexp.MustCompile(`[^a-z0-9]+`)
-	btnSpacePattern      = regexp.MustCompile(`\s+`)
-	btnTime24Pattern     = regexp.MustCompile(`^(\d{1,2}):(\d{2})(?::(\d{2}))?$`)
-	btnTime12Pattern     = regexp.MustCompile(`^(\d{1,2}):(\d{2})\s*([AaPp][Mm])$`)
-)
-
-type btnClaimedShowsCache struct {
-	FetchedAt int64    `json:"fetched_at"`
-	SourceURL string   `json:"source_url"`
-	PostID    string   `json:"post_id"`
-	Titles    []string `json:"titles"`
-}
-
-type btnTrackerClaimProvider struct{}
-
-func (btnTrackerClaimProvider) cachePath(dbPath string, tracker string) (string, error) {
-	return trackerClaimsPath(dbPath, tracker)
-}
-
-func (btnTrackerClaimProvider) cacheTTL() time.Duration {
-	return btnClaimedShowsCacheTTL
-}
-
-func (p btnTrackerClaimProvider) hasClaim(ctx context.Context, s *Service, tracker string, meta api.PreparedMetadata) (bool, error) {
-	if !isTVCategory(meta) {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims skipped for non-TV content")
-		}
-		return false, nil
-	}
-
-	cachePath, err := p.cachePath(s.cfg.MainSettings.DBPath, tracker)
-	if err != nil {
-		return false, fmt.Errorf("metadata: BTN claims cache path: %w", err)
-	}
-
-	claimedTitles, err := s.loadBTNClaimedTitles(ctx, cachePath, p.cacheTTL())
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claim list unavailable: %v", err)
-		}
-		return false, nil
-	}
-	if len(claimedTitles) == 0 {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims loaded 0 titles")
-		}
-		return false, nil
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims loaded %d titles", len(claimedTitles))
-	}
-
-	matched, matchedTitle := matchBTNClaimedTitle(meta, claimedTitles)
-	if !matched {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims found no title match for release=%q", meta.ReleaseName)
-		}
-		return false, nil
-	}
-
-	graceHours := s.btnClaimWindowGraceHours()
-	expired, thresholdHours, hoursSinceAir := btnClaimWindowExpired(meta, graceHours)
-	if expired {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claim window expired for %q (hours_since_air=%.2f threshold=%d)", matchedTitle, hoursSinceAir, thresholdHours)
-		}
-		return false, nil
-	}
-
-	if s.logger != nil {
-		s.logger.Warnf("metadata: BTN claim match found title=%q threshold_hours=%d cache_ttl=%s", matchedTitle, thresholdHours, p.cacheTTL())
-	}
-	return true, nil
-}
-
-func (s *Service) btnClaimWindowGraceHours() int {
-	grace := btnClaimWindowDefaultGrace
-	entry, ok := trackerConfigFor(s.cfg, "BTN")
-	if !ok || entry.Unknown == nil {
-		return grace
-	}
-	value, ok := entry.Unknown["claim_window_grace_hours"]
-	if !ok {
-		return grace
-	}
-	parsed := parseOptionalInt(value)
-	if parsed < 0 {
-		return 0
-	}
-	if parsed == 0 {
-		return grace
-	}
-	return parsed
-}
-
-func (s *Service) loadBTNClaimedTitles(ctx context.Context, cachePath string, cacheTTL time.Duration) (map[string]struct{}, error) {
-	cached, fetchedAt, cacheErr := readBTNClaimedCache(cachePath)
-	if cacheErr != nil {
-		if s.logger != nil && !errors.Is(cacheErr, os.ErrNotExist) {
-			s.logger.Warnf("metadata: BTN claims cache read failed path=%s err=%s", cachePath, redaction.RedactValue(cacheErr.Error(), nil))
-		}
-	} else if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims cache loaded path=%s titles=%d fetched_at=%d", cachePath, len(cached), fetchedAt)
-	}
-	if len(cached) > 0 && time.Since(time.Unix(fetchedAt, 0)) < cacheTTL {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims cache hit path=%s age=%s ttl=%s", cachePath, time.Since(time.Unix(fetchedAt, 0)).Round(time.Second), cacheTTL)
-		}
-		return cached, nil
-	}
-	if s.logger != nil {
-		if len(cached) == 0 {
-			s.logger.Debugf("metadata: BTN claims cache miss path=%s", cachePath)
-		} else {
-			s.logger.Debugf("metadata: BTN claims cache stale path=%s age=%s ttl=%s", cachePath, time.Since(time.Unix(fetchedAt, 0)).Round(time.Second), cacheTTL)
-		}
-	}
-
-	fresh, fetchErr := s.fetchBTNClaimedTitles(ctx)
-	if fetchErr == nil && len(fresh) > 0 {
-		if err := writeBTNClaimedCache(cachePath, fresh); err != nil && s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims cache write failed: %v", err)
-		} else if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims cache saved path=%s titles=%d", cachePath, len(fresh))
-		}
-		return fresh, nil
-	}
-	if fetchErr == nil && len(fresh) == 0 && s.logger != nil {
-		s.logger.Warnf("metadata: BTN claims fetch succeeded but returned no titles")
-	}
-	if fetchErr != nil && s.logger != nil {
-		s.logger.Warnf("metadata: BTN claims fetch failed; falling back to cache: %v", fetchErr)
-	}
-	if len(cached) > 0 {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims using cached titles after fetch failure path=%s titles=%d", cachePath, len(cached))
-		}
-		return cached, nil
-	}
-	return nil, fetchErr
-}
-
-func (s *Service) fetchBTNClaimedTitles(ctx context.Context) (map[string]struct{}, error) {
-	jar, _ := cookiejar.New(nil)
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims fetch starting url=%s", btnClaimedShowsURL)
-	}
-	if err := s.loadBTNCookiesForClaims(ctx, client); err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims cookie load failed: %v", err)
-		}
-	} else if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims cookie load completed")
-	}
-	isLoggedIn, err := s.btnClaimsSessionValid(ctx, client)
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims session validation failed: %v", err)
-		}
-	} else if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims session valid=%t", isLoggedIn)
-	}
-	if !isLoggedIn {
-		if err := s.loginBTNForClaims(ctx, client); err != nil {
-			if s.logger != nil {
-				s.logger.Warnf("metadata: BTN claims login failed: %v", err)
-			}
-			return nil, err
-		} else if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims login completed")
-		}
-	} else if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims login skipped; existing session is valid")
-	}
-	if !isLoggedIn && s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims continuing after login attempt")
-	}
-	mirrorBTNCookiesForClaimedThread(client)
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims mirrored cookies for broadcasthe thread")
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, btnClaimedShowsURL, nil)
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims request build failed: %v", err)
-		}
-		return nil, fmt.Errorf("metadata: build BTN claims request: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims fetch request failed: %v", err)
-		}
-		return nil, fmt.Errorf("metadata: execute BTN claims request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims fetch returned status=%d", resp.StatusCode)
-		}
-		return nil, fmt.Errorf("status %d", resp.StatusCode)
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims fetch returned status=%d", resp.StatusCode)
-	}
-
-	payload, err := ioReadAllLimit(resp, 1<<20)
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims response read failed: %v", err)
-		}
-		return nil, err
-	}
-	titles := extractBTNClaimedShows(string(payload))
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims parsed %d titles from claimed thread", len(titles))
-	}
-	return titles, nil
-}
-
-func (s *Service) loginBTNForClaims(ctx context.Context, client *http.Client) error {
-	entry, ok := trackerConfigFor(s.cfg, "BTN")
-	if !ok {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims login skipped; tracker not configured")
-		}
-		return nil
-	}
-	baseURL := resolveBTNLoginBaseURL(entry)
-	username := strings.TrimSpace(entry.Username)
-	password := strings.TrimSpace(entry.Password)
-	if username == "" || password == "" {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims login skipped; missing username or password")
-		}
-		return nil
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims login attempting with configured credentials")
-	}
-
-	values := map[string]string{
-		"username":   username,
-		"password":   password,
-		"keeplogged": "1",
-		"login":      "Log In!",
-	}
-	if code, err := resolveBTNClaims2FACode(strings.TrimSpace(entry.OTPURI)); err == nil && code != "" {
-		values["code"] = code
-	} else if err != nil && s.logger != nil {
-		s.logger.Warnf("metadata: BTN claims TOTP generation failed: %v", err)
-	}
-	encoded := encodeForm(values)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, "/")+btnLoginPath, strings.NewReader(encoded))
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims login request build failed: %v", err)
-		}
-		return fmt.Errorf("metadata: build BTN claims login request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", "upbrr")
-	resp, err := client.Do(req)
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims login request failed: %v", err)
-		}
-		return fmt.Errorf("metadata: execute BTN claims login request: %w", err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 400 {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims login returned status=%d", resp.StatusCode)
-		}
-		return fmt.Errorf("login status %d", resp.StatusCode)
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims login returned status=%d", resp.StatusCode)
-	}
-	if valid, err := s.btnClaimsSessionValid(ctx, client); err != nil {
-		if s.logger != nil {
-			s.logger.Warnf("metadata: BTN claims post-login validation failed: %v", err)
-		}
-		return err
-	} else if !valid {
-		return errors.New("BTN login failed to establish a valid session")
-	}
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims login established a valid session; leaving cookie file unchanged")
-	}
-	return nil
-}
-
-func resolveBTNLoginBaseURL(entry config.TrackerConfig) string {
-	if baseURL := sanitizeBTNWebBaseURL(entry.URL); baseURL != "" {
-		return baseURL
-	}
-	if baseURL := sanitizeBTNWebBaseURL(entry.AnnounceURL); baseURL != "" {
-		return baseURL
-	}
-	if baseURL := sanitizeBTNWebBaseURL(entry.MyAnnounceURL); baseURL != "" {
-		return baseURL
-	}
-
-	return btnSiteBaseURL
-}
-
-func (s *Service) loadBTNCookiesForClaims(ctx context.Context, client *http.Client) error {
-	if client == nil || client.Jar == nil {
-		return nil
-	}
-
-	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "BTN", "")
-	if err != nil {
-		if s.logger != nil {
-			s.logger.Debugf("metadata: BTN claims cookie load skipped: %v", err)
-		}
-		return nil
-	}
-
-	if err := setBTNJarCookiesFromNetscape(client, btnSiteBaseURL, trackerCookies); err != nil {
-		return err
-	}
-	if err := setBTNJarCookiesFromNetscape(client, btnBackupBaseURL, trackerCookies); err != nil {
-		return err
-	}
-
-	if s.logger != nil {
-		s.logger.Debugf("metadata: BTN claims loaded %d cookies from shared store", len(trackerCookies))
-	}
-	return nil
-}
-
-func setBTNJarCookiesFromNetscape(client *http.Client, rawURL string, values []*http.Cookie) error {
-	if client == nil || client.Jar == nil || len(values) == 0 {
-		return nil
-	}
-
-	parsed, err := url.Parse(rawURL)
-	if err != nil {
-		return fmt.Errorf("metadata: parse BTN cookie URL: %w", err)
-	}
-
-	jarCookies := make([]*http.Cookie, 0, len(values))
-	for _, cookie := range values {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		copied := *cookie // #nosec G124 -- Outbound tracker jar cookie mirrors imported BTN cookie attributes.
-		copied.Domain = parsed.Hostname()
-		if strings.TrimSpace(copied.Path) == "" {
-			copied.Path = "/"
-		}
-		// #nosec G124 -- Outbound tracker jar cookie mirrors imported BTN cookie attributes.
-		jarCookies = append(jarCookies, &copied)
-	}
-	if len(jarCookies) == 0 {
-		return nil
-	}
-
-	client.Jar.SetCookies(parsed, jarCookies)
-	return nil
-}
-
-func (s *Service) btnClaimsSessionValid(ctx context.Context, client *http.Client) (bool, error) {
-	if client == nil {
-		return false, nil
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, btnSiteBaseURL+btnUserPath, nil)
-	if err != nil {
-		return false, fmt.Errorf("metadata: build BTN claims session validation request: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return false, fmt.Errorf("metadata: execute BTN claims session validation request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	if strings.Contains(strings.ToLower(finalURL), strings.ToLower(btnLoginPath)) {
-		return false, nil
-	}
-	return resp.StatusCode >= 200 && resp.StatusCode < 400, nil
-}
-
-func resolveBTNClaims2FACode(otpURI string) (string, error) {
-	trimmed := strings.TrimSpace(otpURI)
-	if trimmed == "" {
-		return "", errors.New("otp_uri not configured")
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("metadata: parse BTN claims otp_uri: %w", err)
-	}
-	secret := strings.TrimSpace(parsed.Query().Get("secret"))
-	if secret == "" {
-		return "", errors.New("otp_uri missing secret")
-	}
-	period := 30
-	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
-		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
-			period = parsedValue
-		}
-	}
-	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
-	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
-	if err != nil {
-		return "", fmt.Errorf("metadata: decode BTN otp secret: %w", err)
-	}
-	counterTime := time.Now().Unix() / int64(period)
-	if counterTime < 0 {
-		return "", errors.New("totp counter before unix epoch")
-	}
-	counter := uint64(counterTime)
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint64(buf, counter)
-	mac := hmac.New(sha1.New, secretBytes)
-	_, _ = mac.Write(buf)
-	hash := mac.Sum(nil)
-	offset := hash[len(hash)-1] & 0x0f
-	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
-	return fmt.Sprintf("%06d", code%1000000), nil
-}
-
-func sanitizeBTNWebBaseURL(raw string) string {
-	trimmed := strings.TrimSpace(raw)
-	if trimmed == "" {
-		return ""
-	}
-
-	parsed, err := url.Parse(trimmed)
-	if err != nil || parsed.Host == "" {
-		return ""
-	}
-	if parsed.Scheme == "" {
-		parsed.Scheme = "https"
-	}
-
-	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
-	switch host {
-	case "", "landof.tv":
-		return ""
-	case "broadcasthe.net", "www.broadcasthe.net":
-		host = "broadcasthe.net"
-	default:
-		return ""
-	}
-
-	lowerPath := strings.ToLower(strings.TrimSpace(parsed.Path))
-	if lowerPath != "" && lowerPath != "/" {
-		return ""
-	}
-
-	parsed.Host = host
-	parsed.Path = ""
-	parsed.RawPath = ""
-	parsed.RawQuery = ""
-	parsed.Fragment = ""
-	return strings.TrimRight(parsed.String(), "/")
-}
-
-func extractBTNClaimedShows(rawHTML string) map[string]struct{} {
-	scopedHTML := extractBTNClaimedPostHTML(rawHTML)
-	normalized := btnLineBreakPattern.ReplaceAllString(scopedHTML, "\n")
-	normalized = btnTagPattern.ReplaceAllString(normalized, "")
-	normalized = html.UnescapeString(normalized)
-
-	lines := strings.Split(normalized, "\n")
-	inCurrentShows := false
-	out := make(map[string]struct{})
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" {
-			continue
-		}
-		lower := strings.ToLower(trimmed)
-		if strings.Contains(lower, "current shows:") {
-			inCurrentShows = true
-			continue
-		}
-		if !inCurrentShows {
-			continue
-		}
-		if strings.Contains(lower, "upcoming shows:") || strings.Contains(lower, "available shows:") {
-			break
-		}
-		if !strings.Contains(trimmed, "--") || !strings.Contains(strings.ToUpper(trimmed), "BTN") {
-			continue
-		}
-		title := strings.TrimSpace(strings.SplitN(trimmed, "--", 2)[0])
-		if strings.EqualFold(title, "show") || title == "" {
-			continue
-		}
-		for variant := range btnTitleVariants(title) {
-			out[variant] = struct{}{}
-		}
-	}
-	return out
-}
-
-func extractBTNClaimedPostHTML(rawHTML string) string {
-	if strings.TrimSpace(rawHTML) == "" {
-		return rawHTML
-	}
-
-	doc, err := htmlnode.Parse(strings.NewReader(rawHTML))
-	if err != nil {
-		return rawHTML
-	}
-
-	scope := findBTNHTMLNode(doc, func(node *htmlnode.Node) bool {
-		return node.Type == htmlnode.ElementNode && node.Data == "table" && btnHTMLNodeID(node) == btnClaimedShowsPostID
-	})
-	if scope == nil {
-		return rawHTML
-	}
-
-	content := findBTNHTMLNode(scope, func(node *htmlnode.Node) bool {
-		if node.Type != htmlnode.ElementNode || node.Data != "div" {
-			return false
-		}
-		if btnHTMLNodeID(node) == "content1405482" {
-			return true
-		}
-		return btnHTMLNodeHasClass(node, "postcontent")
-	})
-	if content != nil {
-		if rendered := renderBTNHTMLChildren(content); rendered != "" {
-			return rendered
-		}
-	}
-
-	if rendered := renderBTNHTMLChildren(scope); rendered != "" {
-		return rendered
-	}
-
-	return rawHTML
-}
-
-func findBTNHTMLNode(root *htmlnode.Node, match func(*htmlnode.Node) bool) *htmlnode.Node {
-	if root == nil {
-		return nil
-	}
-	if match(root) {
-		return root
-	}
-	for child := root.FirstChild; child != nil; child = child.NextSibling {
-		if found := findBTNHTMLNode(child, match); found != nil {
-			return found
-		}
-	}
-	return nil
-}
-
-func btnHTMLNodeID(node *htmlnode.Node) string {
-	return strings.TrimSpace(btnHTMLAttr(node, "id"))
-}
-
-func btnHTMLNodeHasClass(node *htmlnode.Node, className string) bool {
-	classes := strings.FieldsSeq(strings.TrimSpace(btnHTMLAttr(node, "class")))
-	for candidate := range classes {
-		if strings.EqualFold(candidate, className) {
-			return true
-		}
-	}
-	return false
-}
-
-func btnHTMLAttr(node *htmlnode.Node, key string) string {
-	if node == nil {
-		return ""
-	}
-	for _, attr := range node.Attr {
-		if strings.EqualFold(attr.Key, key) {
-			return attr.Val
-		}
-	}
-	return ""
-}
-
-func renderBTNHTMLChildren(node *htmlnode.Node) string {
-	if node == nil {
-		return ""
-	}
-	var buf bytes.Buffer
-	for child := node.FirstChild; child != nil; child = child.NextSibling {
-		if err := htmlnode.Render(&buf, child); err != nil {
-			return ""
-		}
-	}
-	return buf.String()
-}
-
-func matchBTNClaimedTitle(meta api.PreparedMetadata, claimed map[string]struct{}) (bool, string) {
-	for candidate := range btnCandidateTitles(meta) {
-		if _, ok := claimed[candidate]; ok {
-			return true, candidate
-		}
-	}
-	return false, ""
-}
-
-func btnCandidateTitles(meta api.PreparedMetadata) map[string]struct{} {
-	candidates := []string{
-		meta.ReleaseName,
-		meta.ReleaseNameNoTag,
-		meta.Filename,
-		pathutil.Base(meta.SourcePath),
-	}
-	if meta.ExternalMetadata.TVDB != nil {
-		candidates = append(candidates, meta.ExternalMetadata.TVDB.Name, meta.ExternalMetadata.TVDB.NameEnglish)
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		candidates = append(candidates, meta.ExternalMetadata.TMDB.Title, meta.ExternalMetadata.TMDB.OriginalTitle)
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		candidates = append(candidates, meta.ExternalMetadata.TVmaze.Name)
-	}
-
-	out := make(map[string]struct{})
-	for _, title := range candidates {
-		trimmed := strings.TrimSpace(title)
-		if trimmed == "" {
-			continue
-		}
-		for variant := range btnTitleVariants(trimmed) {
-			out[variant] = struct{}{}
-		}
-		derived := btnDeriveShowTitleFromRelease(trimmed)
-		for variant := range btnTitleVariants(derived) {
-			out[variant] = struct{}{}
-		}
-	}
-	return out
-}
-
-func btnDeriveShowTitleFromRelease(value string) string {
-	candidate := strings.ReplaceAll(value, ".", " ")
-	candidate = strings.ReplaceAll(candidate, "_", " ")
-	candidate = strings.TrimSpace(candidate)
-	if candidate == "" {
-		return ""
-	}
-	cutAt := len(candidate)
-	for _, pattern := range []*regexp.Regexp{btnSxxExxCutPattern, btnSeasonCutPattern, btnDateCutPattern} {
-		if match := pattern.FindStringIndex(candidate); match != nil && match[0] < cutAt {
-			cutAt = match[0]
-		}
-	}
-	return strings.TrimSpace(candidate[:cutAt])
-}
-
-func btnTitleVariants(value string) map[string]struct{} {
-	canonical, aliases := extractAKAAliases(value)
-	out := make(map[string]struct{})
-	for _, candidate := range append([]string{canonical}, aliases...) {
-		if normalized := normalizeBTNTitle(candidate); normalized != "" {
-			out[normalized] = struct{}{}
-		}
-	}
-	return out
-}
-
-func extractAKAAliases(value string) (string, []string) {
-	cleaned := strings.TrimSpace(value)
-	if cleaned == "" {
-		return "", nil
-	}
-	match := btnAKAExtractPattern.FindStringSubmatch(cleaned)
-	if len(match) < 2 {
-		return cleaned, nil
-	}
-	aliases := make([]string, 0)
-	for _, part := range strings.FieldsFunc(match[1], func(r rune) bool {
-		switch r {
-		case ',', '/', ';':
-			return true
-		default:
-			return false
-		}
-	}) {
-		if alias := strings.TrimSpace(part); alias != "" {
-			aliases = append(aliases, alias)
-		}
-	}
-	cleaned = strings.TrimSpace(btnAKAExtractPattern.ReplaceAllString(cleaned, ""))
-	return cleaned, aliases
-}
-
-func normalizeBTNTitle(value string) string {
-	cleaned := strings.TrimSpace(value)
-	if cleaned == "" {
-		return ""
-	}
-	cleaned = html.UnescapeString(cleaned)
-	cleaned = strings.ReplaceAll(cleaned, "\u2018", "'")
-	cleaned = strings.ReplaceAll(cleaned, "\u2019", "'")
-	cleaned = strings.ReplaceAll(cleaned, "\u0060", "'")
-	cleaned = strings.ReplaceAll(cleaned, "&", " and ")
-	cleaned = strings.ToLower(cleaned)
-	cleaned = btnNonAlnumPattern.ReplaceAllString(cleaned, " ")
-	cleaned = btnSpacePattern.ReplaceAllString(cleaned, " ")
-	return strings.TrimSpace(cleaned)
-}
-
-func btnClaimWindowExpired(meta api.PreparedMetadata, graceHours int) (bool, int, float64) {
-	airedDate := strings.TrimSpace(meta.TVDBAiredDate)
-	thresholdHours := btnClaimWindowBaseHours + graceHours
-	if airedDate == "" {
-		return false, thresholdHours, 0
-	}
-	airedDateValue, err := time.Parse("2006-01-02", airedDate)
-	if err != nil {
-		return false, thresholdHours, 0
-	}
-
-	airsTime, hasTime := parseBTNTime(strings.TrimSpace(meta.TVDBAirsTime))
-	graceHoursUsed := graceHours
-	location := time.UTC
-	if hasTime {
-		graceHoursUsed = 0
-		if tz := strings.TrimSpace(meta.TVDBAirsTimezone); tz != "" {
-			if loaded, err := time.LoadLocation(tz); err == nil {
-				location = loaded
-			} else {
-				location = time.Now().Location()
-			}
-		} else {
-			location = time.Now().Location()
-		}
-	}
-	thresholdHours = btnClaimWindowBaseHours + graceHoursUsed
-
-	var airedAt time.Time
-	if hasTime {
-		airedAt = time.Date(airedDateValue.Year(), airedDateValue.Month(), airedDateValue.Day(), airsTime.Hour(), airsTime.Minute(), airsTime.Second(), 0, location)
-	} else {
-		airedAt = time.Date(airedDateValue.Year(), airedDateValue.Month(), airedDateValue.Day(), 0, 0, 0, 0, time.UTC)
-	}
-
-	hoursSinceAir := time.Since(airedAt.UTC()).Hours()
-	return hoursSinceAir > float64(thresholdHours), thresholdHours, hoursSinceAir
-}
-
-func btnClaimFailureReason(meta api.PreparedMetadata, graceHours int) string {
-	expired, thresholdHours, hoursSinceAir := btnClaimWindowExpired(meta, graceHours)
-	if expired {
-		return "BTN claim window has expired"
-	}
-	if thresholdHours <= 0 {
-		return "BTN has an active claim for this release"
-	}
-	if hoursSinceAir <= 0 {
-		return fmt.Sprintf("BTN has an active claim for this release; up to %d hours remain in the claim window", thresholdHours)
-	}
-	hoursRemaining := max(int(float64(thresholdHours)-hoursSinceAir+0.999999999), 1)
-	return fmt.Sprintf("BTN has an active claim for this release; approximately %d hours remain in the %d-hour claim window", hoursRemaining, thresholdHours)
-}
-
-func parseBTNTime(value string) (time.Time, bool) {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return time.Time{}, false
-	}
-	if match := btnTime24Pattern.FindStringSubmatch(trimmed); len(match) == 4 {
-		hour, _ := strconv.Atoi(match[1])
-		minute, _ := strconv.Atoi(match[2])
-		second := 0
-		if match[3] != "" {
-			second, _ = strconv.Atoi(match[3])
-		}
-		if hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59 {
-			return time.Date(2000, 1, 1, hour, minute, second, 0, time.UTC), true
-		}
-	}
-	if match := btnTime12Pattern.FindStringSubmatch(trimmed); len(match) == 4 {
-		hour, _ := strconv.Atoi(match[1])
-		minute, _ := strconv.Atoi(match[2])
-		if hour >= 1 && hour <= 12 && minute >= 0 && minute <= 59 {
-			hour %= 12
-			if strings.EqualFold(match[3], "pm") {
-				hour += 12
-			}
-			return time.Date(2000, 1, 1, hour, minute, 0, 0, time.UTC), true
-		}
-	}
-	return time.Time{}, false
-}
-
-func readBTNClaimedCache(path string) (map[string]struct{}, int64, error) {
-	payload, err := os.ReadFile(path)
-	if err != nil {
-		return nil, 0, fmt.Errorf("metadata: read BTN claimed cache: %w", err)
-	}
-	var cache btnClaimedShowsCache
-	if err := json.Unmarshal(payload, &cache); err != nil {
-		return nil, 0, fmt.Errorf("metadata: unmarshal BTN claimed cache: %w", err)
-	}
-	titles := make(map[string]struct{}, len(cache.Titles))
-	for _, title := range cache.Titles {
-		if normalized := normalizeBTNTitle(title); normalized != "" {
-			titles[normalized] = struct{}{}
-		}
-	}
-	return titles, cache.FetchedAt, nil
-}
-
-func writeBTNClaimedCache(path string, titles map[string]struct{}) error {
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		return fmt.Errorf("metadata: create BTN claimed cache dir: %w", err)
-	}
-	serializedTitles := make([]string, 0, len(titles))
-	for title := range titles {
-		serializedTitles = append(serializedTitles, title)
-	}
-	sort.Strings(serializedTitles)
-	cache := btnClaimedShowsCache{
-		FetchedAt: time.Now().Unix(),
-		SourceURL: btnClaimedShowsURL,
-		PostID:    btnClaimedShowsPostID,
-		Titles:    serializedTitles,
-	}
-	encoded, err := json.MarshalIndent(cache, "", "  ")
-	if err != nil {
-		return fmt.Errorf("metadata: marshal BTN claimed cache: %w", err)
-	}
-	if err := os.WriteFile(path, encoded, 0o600); err != nil {
-		return fmt.Errorf("metadata: write BTN claimed cache: %w", err)
-	}
-	return nil
-}
-
-func parseOptionalInt(value any) int {
-	switch typed := value.(type) {
-	case int:
-		return typed
-	case int64:
-		return int(typed)
-	case float64:
-		return int(typed)
-	case string:
-		parsed, err := strconv.Atoi(strings.TrimSpace(typed))
-		if err == nil {
-			return parsed
-		}
-	}
-	return 0
-}
-
-func mirrorBTNCookiesForClaimedThread(client *http.Client) {
-	if client == nil || client.Jar == nil {
-		return
-	}
-
-	backupURL, backupErr := url.Parse("https://backup.landof.tv/")
-	broadcastURL, broadcastErr := url.Parse("https://broadcasthe.net/")
-	if backupErr != nil || broadcastErr != nil {
-		return
-	}
-
-	backupCookies := client.Jar.Cookies(backupURL)
-	if len(backupCookies) == 0 {
-		return
-	}
-
-	mirrored := make([]*http.Cookie, 0, len(backupCookies)*2)
-	for _, cookie := range backupCookies {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
-			continue
-		}
-		copied := *cookie // #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
-		copied.Domain = "broadcasthe.net"
-		if copied.Path == "" {
-			copied.Path = "/"
-		}
-		// #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
-		mirrored = append(mirrored, &copied)
-
-		dotted := copied // #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
-		dotted.Domain = ".broadcasthe.net"
-		// #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
-		mirrored = append(mirrored, &dotted)
-	}
-	if len(mirrored) == 0 {
-		return
-	}
-	client.Jar.SetCookies(broadcastURL, mirrored)
-}
-
-func encodeForm(values map[string]string) string {
-	encoded := url.Values{}
-	for key, value := range values {
-		encoded.Set(key, value)
-	}
-	return encoded.Encode()
-}
-
-func ioReadAllLimit(resp *http.Response, maxBytes int64) ([]byte, error) {
-	if resp == nil || resp.Body == nil {
-		return nil, errors.New("nil response body")
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBytes))
-	if err != nil {
-		return nil, fmt.Errorf("read limited response body: %w", err)
-	}
-	return body, nil
-}
diff --git a/internal/metadata/tracker_claims_btn_compat_test.go b/internal/metadata/tracker_claims_btn_compat_test.go
new file mode 100644
index 00000000..b6f6e363
--- /dev/null
+++ b/internal/metadata/tracker_claims_btn_compat_test.go
@@ -0,0 +1,71 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"time"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/services/db"
+	btnimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/btn"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	btnClaimedShowsURL    = "https://broadcasthe.net/forums.php?action=viewthread&threadid=30793"
+	btnClaimedShowsPostID = "post1405482"
+)
+
+type btnClaimedShowsCache struct {
+	FetchedAt int64    `json:"fetched_at"`
+	SourceURL string   `json:"source_url"`
+	PostID    string   `json:"post_id"`
+	Titles    []string `json:"titles"`
+}
+
+type btnTrackerClaimProvider struct{}
+
+func (btnTrackerClaimProvider) cachePath(dbPath string, _ string) (string, error) {
+	path, err := db.FileInSubdir(dbPath, "cache", filepath.Join("banned", "BTN_claimed_releases.json"))
+	if err != nil {
+		return "", fmt.Errorf("resolve BTN claim cache path: %w", err)
+	}
+	return path, nil
+}
+func (btnTrackerClaimProvider) cacheTTL() time.Duration { return 48 * time.Hour }
+
+func normalizeBTNTitle(value string) string { return btnimpl.NormalizeClaimTitle(value) }
+func extractBTNClaimedShows(value string) map[string]struct{} {
+	return btnimpl.ExtractClaimedShows(value)
+}
+func mirrorBTNCookiesForClaimedThread(client *http.Client) {
+	btnimpl.MirrorCookiesForClaimedThread(client)
+}
+func btnClaimWindowExpired(meta preparationstate.State, graceHours int) (bool, int, float64) {
+	return btnimpl.ClaimWindowExpired(api.UploadSubject{
+		TVDBAiredDate:    meta.TVDBAiredDate,
+		TVDBAirsTime:     meta.TVDBAirsTime,
+		TVDBAirsTimezone: meta.TVDBAirsTimezone,
+	}, graceHours)
+}
+
+func (s *Service) loadBTNClaimedTitles(ctx context.Context, cachePath string, ttl time.Duration) (map[string]struct{}, error) {
+	titles, err := btnimpl.LoadClaimedTitles(ctx, s.cfg, s.logger, cachePath, ttl)
+	if err != nil {
+		return nil, fmt.Errorf("load BTN claimed titles: %w", err)
+	}
+	return titles, nil
+}
+func (s *Service) fetchBTNClaimedTitles(ctx context.Context) (map[string]struct{}, error) {
+	titles, err := btnimpl.FetchClaimedTitles(ctx, s.cfg, s.logger)
+	if err != nil {
+		return nil, fmt.Errorf("fetch BTN claimed titles: %w", err)
+	}
+	return titles, nil
+}
diff --git a/internal/metadata/tracker_claims_rule_test.go b/internal/metadata/tracker_claims_rule_test.go
new file mode 100644
index 00000000..aa20f61d
--- /dev/null
+++ b/internal/metadata/tracker_claims_rule_test.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestTrackerClaimRuleFailureIsStrict(t *testing.T) {
+	t.Parallel()
+
+	failure := trackerClaimRuleFailure("active claim")
+	if failure.Rule != trackerClaimRuleActive || failure.Disposition != api.RuleDispositionStrict {
+		t.Fatalf("claim failure = %#v", failure)
+	}
+}
diff --git a/internal/metadata/tracker_data.go b/internal/metadata/tracker_data.go
index 51126e5b..ad3fbb0a 100644
--- a/internal/metadata/tracker_data.go
+++ b/internal/metadata/tracker_data.go
@@ -12,35 +12,41 @@ import (
 	"sync"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerdata"
 	trackerscatalog "github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 const (
 	defaultTrackerCooldown = 15 * time.Second
-	ptpTrackerCooldown     = 60 * time.Second
 	trackerLookupWorkers   = 4
 )
 
-func (s *Service) EnrichTrackerData(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
+// collectTrackerEvidence skips fresh stored snapshots and cooling-down trackers,
+// then persists accepted lookup records and timestamps. Explicit IDs or a
+// preferred tracker force configured priority order; otherwise at most four
+// lookups race and the first result with IDs wins. Lookup failures are soft,
+// while cancellation and persistence failures discard the result.
+func (s *Service) collectTrackerEvidence(ctx context.Context, meta preparationstate.State) (preparationstate.State, error) {
 	select {
 	case <-ctx.Done():
-		return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
 	if s.repo == nil {
-		return api.PreparedMetadata{}, internalerrors.ErrInvalidInput
+		return preparationstate.State{}, internalerrors.ErrInvalidInput
 	}
 	if strings.TrimSpace(meta.SourcePath) == "" {
-		return api.PreparedMetadata{}, internalerrors.ErrInvalidInput
+		return preparationstate.State{}, internalerrors.ErrInvalidInput
 	}
 	if meta.StoredDataFresh {
 		if s.logger != nil {
@@ -56,7 +62,7 @@ func (s *Service) EnrichTrackerData(ctx context.Context, meta api.PreparedMetada
 
 	trackers := normalizeTrackers(candidates)
 	if s.logger != nil {
-		configured, missing := configuredTrackers(s.cfg)
+		configured, missing := configuredTrackers(s.cfg, s.registry)
 		s.logger.Debugf("metadata: tracker candidates %v", trackers)
 		if len(configured) > 0 {
 			s.logger.Debugf("metadata: trackers configured %v", configured)
@@ -69,9 +75,9 @@ func (s *Service) EnrichTrackerData(ctx context.Context, meta api.PreparedMetada
 		logPathedTrackerDetails(meta, s.logger)
 		logClientSearchIDs(meta, s.logger)
 	}
-	trackers = filterConfiguredTrackers(s.cfg, trackers, s.logger)
-	trackers = orderTrackersByPriority(trackers)
-	trackers = reorderTrackersForMetadataNeeds(trackers, meta.Options)
+	trackers = filterConfiguredTrackers(s.cfg, trackers, s.logger, s.registry)
+	trackers = orderTrackersByPriority(trackers, s.registry)
+	trackers = reorderTrackersForMetadataNeeds(trackers, api.UploadOptions{OnlyID: meta.Policy.OnlyID, KeepImages: meta.Policy.KeepImages}, s.registry)
 	trackers = applyPreferredTracker(trackers, s.cfg.Trackers.PreferredTracker)
 	if len(trackers) == 0 {
 		if s.logger != nil {
@@ -85,12 +91,11 @@ func (s *Service) EnrichTrackerData(ctx context.Context, meta api.PreparedMetada
 
 	now := time.Now().UTC()
 	meta.TrackerData = append([]api.TrackerMetadata{}, meta.TrackerData...)
-	unit3dClient := trackerdata.NewClient(s.cfg, s.logger, nil)
 	eligible := make([]string, 0, len(trackers))
 	for _, tracker := range trackers {
 		select {
 		case <-ctx.Done():
-			return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+			return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 		default:
 		}
 		if s.isTrackerCoolingDown(ctx, tracker, now) {
@@ -103,13 +108,13 @@ func (s *Service) EnrichTrackerData(ctx context.Context, meta api.PreparedMetada
 	}
 
 	if !shouldUseStrictPriorityLookup(meta, eligible, s.cfg.Trackers.PreferredTracker) {
-		return s.enrichTrackerDataConcurrent(ctx, meta, eligible, now, unit3dClient)
+		return s.enrichTrackerDataConcurrent(ctx, meta, eligible, now)
 	}
 
-	return s.enrichTrackerDataPriority(ctx, meta, eligible, now, unit3dClient)
+	return s.enrichTrackerDataPriority(ctx, meta, eligible, now)
 }
 
-func shouldUseStrictPriorityLookup(meta api.PreparedMetadata, eligible []string, preferred string) bool {
+func shouldUseStrictPriorityLookup(meta preparationstate.State, eligible []string, preferred string) bool {
 	if len(meta.TrackerIDs) > 0 {
 		return true
 	}
@@ -127,20 +132,19 @@ func shouldUseStrictPriorityLookup(meta api.PreparedMetadata, eligible []string,
 
 func (s *Service) enrichTrackerDataPriority(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta preparationstate.State,
 	eligible []string,
 	now time.Time,
-	unit3dClient *trackerdata.Client,
-) (api.PreparedMetadata, error) {
+) (preparationstate.State, error) {
 	assetSourceTracker := ""
 	for _, tracker := range eligible {
 		select {
 		case <-ctx.Done():
-			return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
+			return preparationstate.State{}, fmt.Errorf("context canceled: %w", ctx.Err())
 		default:
 		}
 
-		record, persistable, hasIDs, err := s.lookupTrackerData(ctx, meta, tracker, now, unit3dClient)
+		record, persistable, hasIDs, err := s.lookupTrackerData(ctx, meta, tracker, now)
 		if err != nil {
 			if s.logger != nil {
 				s.logger.Warnf("metadata: tracker lookup failed tracker=%s: %s", tracker, redaction.RedactValue(err.Error(), nil))
@@ -159,7 +163,11 @@ func (s *Service) enrichTrackerDataPriority(
 				}
 			} else if !strings.EqualFold(assetSourceTracker, tracker) {
 				if s.logger != nil {
-					s.logger.Debugf("metadata: ignoring description/images from %s (source=%s)", strings.ToUpper(strings.TrimSpace(tracker)), assetSourceTracker)
+					s.logger.Debugf(
+						"metadata: ignoring description/images from %s (source=%s)",
+						strings.ToUpper(strings.TrimSpace(tracker)),
+						assetSourceTracker,
+					)
 				}
 				record.Description = ""
 				record.ImageURLs = nil
@@ -167,10 +175,10 @@ func (s *Service) enrichTrackerDataPriority(
 		}
 
 		if err := s.repo.SaveTrackerMetadata(ctx, record); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: save tracker metadata: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: save tracker metadata: %w", err)
 		}
 		if err := s.repo.SaveTrackerTimestamp(ctx, db.TrackerTimestamp{Tracker: tracker, UpdatedAt: now}); err != nil {
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: save tracker timestamp: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: save tracker timestamp: %w", err)
 		}
 		meta.TrackerData = append(meta.TrackerData, record)
 		if hasIDs {
@@ -186,11 +194,10 @@ func (s *Service) enrichTrackerDataPriority(
 
 func (s *Service) enrichTrackerDataConcurrent(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta preparationstate.State,
 	eligible []string,
 	now time.Time,
-	unit3dClient *trackerdata.Client,
-) (api.PreparedMetadata, error) {
+) (preparationstate.State, error) {
 	lookupCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
@@ -207,7 +214,7 @@ func (s *Service) enrichTrackerDataConcurrent(
 	for idx := 0; idx < workerCount; idx++ {
 		workers.Go(func() {
 			for tracker := range jobs {
-				record, persistable, hasIDs, err := s.lookupTrackerData(lookupCtx, lookupMeta, tracker, now, unit3dClient)
+				record, persistable, hasIDs, err := s.lookupTrackerData(lookupCtx, lookupMeta, tracker, now)
 				results <- trackerLookupOutcome{
 					tracker:     tracker,
 					record:      record,
@@ -249,7 +256,11 @@ func (s *Service) enrichTrackerDataConcurrent(
 				}
 			} else if !strings.EqualFold(assetSourceTracker, outcome.tracker) {
 				if s.logger != nil {
-					s.logger.Debugf("metadata: ignoring description/images from %s (source=%s)", strings.ToUpper(strings.TrimSpace(outcome.tracker)), assetSourceTracker)
+					s.logger.Debugf(
+						"metadata: ignoring description/images from %s (source=%s)",
+						strings.ToUpper(strings.TrimSpace(outcome.tracker)),
+						assetSourceTracker,
+					)
 				}
 				outcome.record.Description = ""
 				outcome.record.ImageURLs = nil
@@ -258,11 +269,11 @@ func (s *Service) enrichTrackerDataConcurrent(
 
 		if err := s.repo.SaveTrackerMetadata(ctx, outcome.record); err != nil {
 			workers.Wait()
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: save tracker metadata: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: save tracker metadata: %w", err)
 		}
 		if err := s.repo.SaveTrackerTimestamp(ctx, db.TrackerTimestamp{Tracker: outcome.tracker, UpdatedAt: now}); err != nil {
 			workers.Wait()
-			return api.PreparedMetadata{}, fmt.Errorf("metadata: save tracker timestamp: %w", err)
+			return preparationstate.State{}, fmt.Errorf("metadata: save tracker timestamp: %w", err)
 		}
 		meta.TrackerData = append(meta.TrackerData, outcome.record)
 		if outcome.hasIDs {
@@ -289,10 +300,9 @@ type trackerLookupOutcome struct {
 
 func (s *Service) lookupTrackerData(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta preparationstate.State,
 	tracker string,
 	now time.Time,
-	unit3dClient *trackerdata.Client,
 ) (api.TrackerMetadata, bool, bool, error) {
 	select {
 	case <-ctx.Done():
@@ -309,73 +319,6 @@ func (s *Service) lookupTrackerData(
 		UpdatedAt:  now,
 	}
 
-	if trackerdata.IsUnit3DTracker(tracker) {
-		fileName := trackerLookupFileName(meta, record.TrackerID, s.cfg.Metadata.SkipTrackerFilenameLookup)
-		if s.logger != nil {
-			s.logger.Tracef("metadata: unit3d lookup start tracker=%s id=%q file=%q", tracker, record.TrackerID, fileName)
-		}
-		result, err := unit3dClient.TorrentInfo(
-			ctx,
-			tracker,
-			record.TrackerID,
-			fileName,
-			meta.Options.OnlyID,
-			meta.Options.KeepImages,
-		)
-		if err != nil {
-			return api.TrackerMetadata{}, false, false, fmt.Errorf("metadata: %w", err)
-		}
-		if !hasUnit3DData(result) {
-			if s.logger != nil {
-				s.logger.Debugf("metadata: unit3d lookup empty tracker=%s id=%q", tracker, record.TrackerID)
-			}
-			if !trackerRecordHasPathedData(record) {
-				if s.logger != nil {
-					s.logger.Debugf("metadata: tracker %s has no pathed data, skipping", tracker)
-				}
-				return api.TrackerMetadata{}, false, false, nil
-			}
-			return record, true, false, nil
-		}
-
-		downloadedImages := s.persistUnit3DArtifacts(ctx, meta, tracker, result, meta.Options.KeepImages)
-		if s.logger != nil {
-			s.logger.Debugf("metadata: unit3d downloaded %d of %d images", len(downloadedImages), len(result.Validated))
-		}
-		record.TMDBID = result.TMDBID
-		record.IMDBID = result.IMDBID
-		record.TVDBID = result.TVDBID
-		record.MALID = result.MALID
-		record.Category = normalizeUnit3DCategory(result.Category)
-		record.InfoHash = metautil.FirstNonEmptyTrimmed(record.InfoHash, result.InfoHash)
-		record.Description = result.Description
-		record.ImageURLs = trackerImageURLsFromResult(result, downloadedImages, meta.Options.KeepImages)
-		record.Filename = result.FileName
-		record.Matched = true
-		if s.logger != nil {
-			s.logger.Debugf(
-				"metadata: unit3d lookup applied tracker=%s tmdb=%d imdb=%d tvdb=%d mal=%d desc=%t images=%d infohash=%t file=%t",
-				tracker,
-				record.TMDBID,
-				record.IMDBID,
-				record.TVDBID,
-				record.MALID,
-				record.Description != "",
-				len(record.ImageURLs),
-				record.InfoHash != "",
-				record.Filename != "",
-			)
-		}
-
-		if !trackerRecordHasPathedData(record) {
-			if s.logger != nil {
-				s.logger.Debugf("metadata: tracker %s has no pathed data, skipping", tracker)
-			}
-			return api.TrackerMetadata{}, false, false, nil
-		}
-		return record, true, hasTrackerMetadataIDs(record), nil
-	}
-
 	if s.tracker == nil {
 		if !trackerRecordHasPathedData(record) {
 			if s.logger != nil {
@@ -390,10 +333,10 @@ func (s *Service) lookupTrackerData(
 		ctx,
 		tracker,
 		record.TrackerID,
-		meta,
+		trackerLookupSubject(meta),
 		trackerLookupFileName(meta, record.TrackerID, s.cfg.Metadata.SkipTrackerFilenameLookup),
-		meta.Options.OnlyID,
-		meta.Options.KeepImages,
+		meta.Policy.OnlyID,
+		meta.Policy.KeepImages,
 	)
 	if err != nil {
 		return api.TrackerMetadata{}, false, false, fmt.Errorf("metadata: %w", err)
@@ -418,9 +361,9 @@ func (s *Service) lookupTrackerData(
 			meta,
 			tracker,
 			trackerdata.Result{Description: result.Description, Validated: result.Images},
-			meta.Options.KeepImages,
+			meta.Policy.KeepImages,
 		)
-		record.ImageURLs = trackerImageURLsFromResult(result, downloadedImages, meta.Options.KeepImages)
+		record.ImageURLs = trackerImageURLsFromResult(result, downloadedImages, meta.Policy.KeepImages)
 	}
 	if s.logger != nil {
 		s.logger.Debugf(
@@ -445,6 +388,83 @@ func (s *Service) lookupTrackerData(
 	return record, true, hasTrackerMetadataIDs(record), nil
 }
 
+func trackerLookupSubject(meta preparationstate.State) api.UploadSubject {
+	identity := meta.Identity
+	if identity.Category == "" || identity.Category == api.CanonicalCategoryUnknown {
+		identity.Category, _ = api.NormalizeCanonicalCategory(meta.MediaInfoCategory)
+	}
+	return api.UploadSubject{
+		SourcePath:            meta.SourcePath,
+		Paths:                 append([]string(nil), meta.Paths...),
+		DiscType:              meta.DiscType,
+		VideoPath:             meta.VideoPath,
+		FileList:              append([]string(nil), meta.FileList...),
+		SourceSize:            meta.SourceSize,
+		MediaInfoJSONPath:     meta.MediaInfoJSONPath,
+		MediaInfoTextPath:     meta.MediaInfoTextPath,
+		DVDVOBMediaInfoText:   meta.DVDVOBMediaInfoText,
+		Scene:                 meta.Scene,
+		SceneName:             meta.SceneName,
+		SceneNFOPath:          meta.SceneNFOPath,
+		SceneRenamed:          meta.SceneRenamed,
+		SceneRenamedReason:    meta.SceneRenamedReason,
+		Trackers:              append([]string(nil), meta.EvidenceTrackers...),
+		MatchedTrackers:       append([]string(nil), meta.MatchedEvidenceTrackers...),
+		Tag:                   meta.Tag,
+		Release:               meta.Release,
+		DescriptionTemplate:   meta.DescriptionTemplate,
+		PersonalRelease:       meta.PersonalRelease,
+		InfoHash:              meta.InfoHash,
+		TrackerIDs:            cloneTrackerIDs(meta.TrackerIDs),
+		TrackerData:           append([]api.TrackerMetadata(nil), meta.TrackerData...),
+		ArrReleaseGroup:       meta.ArrReleaseGroup,
+		ReleaseNameOverrides:  meta.ReleaseNameOverrides,
+		SeasonInt:             meta.SeasonInt,
+		EpisodeInt:            meta.EpisodeInt,
+		SeasonStr:             meta.SeasonStr,
+		EpisodeStr:            meta.EpisodeStr,
+		TVDBAiredDate:         meta.TVDBAiredDate,
+		TVDBAirsTime:          meta.TVDBAirsTime,
+		TVDBAirsTimezone:      meta.TVDBAirsTimezone,
+		TVPack:                meta.TVPack,
+		DailyEpisodeDate:      meta.DailyEpisodeDate,
+		Anime:                 meta.Anime,
+		EpisodeTitle:          meta.EpisodeTitle,
+		EpisodeOverview:       meta.EpisodeOverview,
+		SelectedBDMVPlaylists: append([]api.PlaylistInfo(nil), meta.SelectedBDMVPlaylists...),
+		Identity:              identity,
+		ProviderMetadata:      meta.ProviderMetadata,
+		AudioLanguages:        append([]string(nil), meta.AudioLanguages...),
+		SubtitleLanguages:     append([]string(nil), meta.SubtitleLanguages...),
+		Container:             meta.Container,
+		Audio:                 meta.Audio,
+		Channels:              meta.Channels,
+		HasCommentary:         meta.HasCommentary,
+		Is3D:                  meta.Is3D,
+		Source:                meta.Source,
+		Type:                  meta.Type,
+		UHD:                   meta.UHD,
+		HDR:                   meta.HDR,
+		Distributor:           meta.Distributor,
+		Region:                meta.Region,
+		VideoCodec:            meta.VideoCodec,
+		VideoEncode:           meta.VideoEncode,
+		HasEncodeSettings:     meta.HasEncodeSettings,
+		BitDepth:              meta.BitDepth,
+		Edition:               meta.Edition,
+		Repack:                meta.Repack,
+		WebDV:                 meta.WebDV,
+		Assessments:           meta.ReleaseAssessments(),
+		StreamOptimized:       meta.StreamOptimized,
+		Service:               meta.Service,
+		ServiceLongName:       meta.ServiceLongName,
+		Filename:              meta.Filename,
+		ReleaseName:           meta.ReleaseName,
+		ReleaseNameNoTag:      meta.ReleaseNameNoTag,
+		ReleaseNameClean:      meta.ReleaseNameClean,
+	}
+}
+
 func trackerImageURLsFromResult(_ trackerdata.Result, downloadedImages []string, keepImages bool) []string {
 	if !keepImages || len(downloadedImages) == 0 {
 		return nil
@@ -484,7 +504,7 @@ func (s *Service) isTrackerCoolingDown(ctx context.Context, tracker string, now
 		}
 		return false
 	}
-	cooldown := trackerCooldown(tracker)
+	cooldown := trackerCooldown(s.registry, tracker)
 	if cooldown <= 0 {
 		return false
 	}
@@ -497,26 +517,49 @@ func (s *Service) isTrackerCoolingDown(ctx context.Context, tracker string, now
 	return false
 }
 
-func trackerCooldown(tracker string) time.Duration {
-	if strings.EqualFold(tracker, "PTP") {
-		return ptpTrackerCooldown
+func trackerCooldown(registry *trackerscatalog.Registry, tracker string) time.Duration {
+	if policy, ok := registry.LookupDataPolicy(tracker); ok {
+		return policy.Cooldown
 	}
 	return defaultTrackerCooldown
 }
 
-func resolveTrackerCandidates(meta api.PreparedMetadata) []string {
+// resolveTrackerCandidates orders trackers with current matched evidence first,
+// then appends remaining tracker-ID keys deterministically.
+func resolveTrackerCandidates(meta preparationstate.State) []string {
 	if len(meta.TrackerIDs) > 0 {
 		result := make([]string, 0, len(meta.TrackerIDs))
+		seen := make(map[string]struct{}, len(meta.TrackerIDs))
+		appendKnown := func(values []string) {
+			for _, value := range values {
+				key := strings.ToLower(strings.TrimSpace(value))
+				if _, exists := meta.TrackerIDs[key]; !exists {
+					continue
+				}
+				if _, exists := seen[key]; exists {
+					continue
+				}
+				seen[key] = struct{}{}
+				result = append(result, value)
+			}
+		}
+		appendKnown(meta.MatchedEvidenceTrackers)
+		appendKnown(meta.EvidenceTrackers)
+		remaining := make([]string, 0, len(meta.TrackerIDs)-len(result))
 		for key := range meta.TrackerIDs {
-			result = append(result, key)
+			if _, exists := seen[key]; !exists {
+				remaining = append(remaining, key)
+			}
 		}
+		sort.Strings(remaining)
+		result = append(result, remaining...)
 		return result
 	}
-	if len(meta.MatchedTrackers) > 0 {
-		return meta.MatchedTrackers
+	if len(meta.MatchedEvidenceTrackers) > 0 {
+		return meta.MatchedEvidenceTrackers
 	}
-	if len(meta.Trackers) > 0 {
-		return meta.Trackers
+	if len(meta.EvidenceTrackers) > 0 {
+		return meta.EvidenceTrackers
 	}
 	return nil
 }
@@ -539,11 +582,11 @@ func normalizeTrackers(values []string) []string {
 	return out
 }
 
-func orderTrackersByPriority(trackers []string) []string {
+func orderTrackersByPriority(trackers []string, registry *trackerscatalog.Registry) []string {
 	if len(trackers) == 0 {
 		return trackers
 	}
-	trackerPriority := trackerscatalog.TrackerPriority()
+	trackerPriority := registry.Priority()
 	priority := make(map[string]int, len(trackerPriority))
 	for idx, value := range trackerPriority {
 		priority[strings.ToUpper(value)] = idx
@@ -569,30 +612,28 @@ func orderTrackersByPriority(trackers []string) []string {
 	return trackers
 }
 
-func reorderTrackersForMetadataNeeds(trackers []string, opts api.UploadOptions) []string {
-	if len(trackers) == 0 {
-		return trackers
+func reorderTrackersForMetadataNeeds(trackerNames []string, opts api.UploadOptions, registry *trackerscatalog.Registry) []string {
+	if len(trackerNames) == 0 {
+		return trackerNames
 	}
 	if opts.OnlyID || !opts.KeepImages {
-		return trackers
+		return trackerNames
 	}
 
-	nonBTN := make([]string, 0, len(trackers))
-	btnCount := 0
-	for _, tracker := range trackers {
-		if strings.EqualFold(strings.TrimSpace(tracker), "BTN") {
-			btnCount++
+	preferred := make([]string, 0, len(trackerNames))
+	deferred := make([]string, 0, len(trackerNames))
+	for _, tracker := range trackerNames {
+		policy, ok := registry.LookupDataPolicy(tracker)
+		if ok && policy.DeferWhenCollectingImages {
+			deferred = append(deferred, tracker)
 			continue
 		}
-		nonBTN = append(nonBTN, tracker)
-	}
-	if btnCount == 0 {
-		return trackers
+		preferred = append(preferred, tracker)
 	}
-	for idx := 0; idx < btnCount; idx++ {
-		nonBTN = append(nonBTN, "BTN")
+	if len(deferred) == 0 {
+		return trackerNames
 	}
-	return nonBTN
+	return append(preferred, deferred...)
 }
 
 func applyPreferredTracker(trackers []string, preferred string) []string {
@@ -621,7 +662,7 @@ func applyPreferredTracker(trackers []string, preferred string) []string {
 	return trackers
 }
 
-func configuredTrackers(cfg config.Config) ([]string, []string) {
+func configuredTrackers(cfg config.Config, registry *trackerscatalog.Registry) ([]string, []string) {
 	configured := make([]string, 0)
 	missing := make([]string, 0)
 	for name, entry := range cfg.Trackers.Trackers {
@@ -630,32 +671,39 @@ func configuredTrackers(cfg config.Config) ([]string, []string) {
 			continue
 		}
 		upper := strings.ToUpper(trimmed)
-		if !trackerLookupConfigured(upper, entry) {
+		ready, owned := registry.DataLookupConfigured(upper, cfg)
+		if !owned {
+			ready = customTrackerLookupConfigured(entry)
+		}
+		if !ready {
 			missing = append(missing, upper)
 			continue
 		}
 		configured = append(configured, upper)
 	}
-	if len(config.ResolveBTNAPIToken(cfg)) >= minTrackerTokenLen {
-		configured = append(configured, "BTN")
+	for _, name := range registry.Names() {
+		if ready, owned := registry.DataLookupConfigured(name, cfg); owned && ready {
+			configured = append(configured, name)
+		}
 	}
 	configured = uniqueSorted(configured)
 	missing = uniqueSorted(missing)
 	return configured, missing
 }
 
-func filterConfiguredTrackers(cfg config.Config, trackers []string, logger api.Logger) []string {
+func filterConfiguredTrackers(cfg config.Config, trackers []string, logger api.Logger, registry *trackerscatalog.Registry) []string {
 	if len(trackers) == 0 {
 		return trackers
 	}
 
 	filtered := make([]string, 0, len(trackers))
 	for _, tracker := range trackers {
-		if strings.EqualFold(strings.TrimSpace(tracker), "BTN") {
-			if len(config.ResolveBTNAPIToken(cfg)) >= minTrackerTokenLen {
+		configured, owned := registry.DataLookupConfigured(tracker, cfg)
+		if owned {
+			if configured {
 				filtered = append(filtered, tracker)
 			} else if logger != nil {
-				logger.Debugf("metadata: tracker %s missing BTN api token", tracker)
+				logger.Debugf("metadata: tracker %s missing lookup credentials", tracker)
 			}
 			continue
 		}
@@ -666,39 +714,23 @@ func filterConfiguredTrackers(cfg config.Config, trackers []string, logger api.L
 			}
 			continue
 		}
-		if !trackerLookupConfigured(tracker, entry) {
+		configured = customTrackerLookupConfigured(entry)
+		if !configured {
 			if logger != nil {
 				logger.Debugf("metadata: tracker %s missing lookup credentials", tracker)
 			}
 			continue
 		}
-		if strings.EqualFold(strings.TrimSpace(tracker), "ANT") && strings.TrimSpace(entry.APIKey) == "" {
-			if logger != nil {
-				logger.Debugf("metadata: tracker %s missing api_key", tracker)
-			}
-			continue
-		}
 		filtered = append(filtered, tracker)
 	}
 	return filtered
 }
 
-const minTrackerTokenLen = 25
-
-func trackerLookupConfigured(tracker string, entry config.TrackerConfig) bool {
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "BHD":
-		return len(strings.TrimSpace(entry.APIKey)) >= minTrackerTokenLen &&
-			len(strings.TrimSpace(entry.BhdRSSKey)) >= minTrackerTokenLen
-	case "PTP":
-		return strings.TrimSpace(entry.PTPAPIUser) != "" && strings.TrimSpace(entry.PTPAPIKey) != ""
-	case "HDB":
-		return strings.TrimSpace(entry.Username) != "" && strings.TrimSpace(entry.Passkey) != ""
-	case "ANT":
-		return strings.TrimSpace(entry.APIKey) != ""
-	default:
-		return strings.TrimSpace(entry.APIKey) != "" || strings.TrimSpace(entry.AnnounceURL) != ""
-	}
+func customTrackerLookupConfigured(entry config.TrackerConfig) bool {
+	return strings.TrimSpace(entry.APIKey) != "" ||
+		strings.TrimSpace(entry.AnnounceURL) != "" ||
+		(strings.TrimSpace(entry.Username) != "" && strings.TrimSpace(entry.Passkey) != "") ||
+		(strings.TrimSpace(entry.PTPAPIUser) != "" && strings.TrimSpace(entry.PTPAPIKey) != "")
 }
 
 func applyTrackerDataResult(record *api.TrackerMetadata, result trackerdata.Result) {
@@ -744,7 +776,7 @@ func trackerConfigFor(cfg config.Config, tracker string) (config.TrackerConfig,
 	return config.TrackerConfig{}, false
 }
 
-func trackerIDFor(meta api.PreparedMetadata, tracker string) string {
+func trackerIDFor(meta preparationstate.State, tracker string) string {
 	if len(meta.TrackerIDs) == 0 {
 		return ""
 	}
@@ -755,15 +787,15 @@ func trackerIDFor(meta api.PreparedMetadata, tracker string) string {
 	return strings.TrimSpace(meta.TrackerIDs[key])
 }
 
-func trackerMatched(meta api.PreparedMetadata, tracker string) bool {
-	if !meta.FoundTrackerMatch || len(meta.MatchedTrackers) == 0 {
+func trackerMatched(meta preparationstate.State, tracker string) bool {
+	if !meta.FoundTrackerMatch || len(meta.MatchedEvidenceTrackers) == 0 {
 		return false
 	}
 	target := strings.ToUpper(strings.TrimSpace(tracker))
 	if target == "" {
 		return false
 	}
-	for _, value := range meta.MatchedTrackers {
+	for _, value := range meta.MatchedEvidenceTrackers {
 		if strings.EqualFold(strings.TrimSpace(value), target) {
 			return true
 		}
@@ -792,7 +824,7 @@ func uniqueSorted(values []string) []string {
 	return result
 }
 
-func logPathedTrackerDetails(meta api.PreparedMetadata, logger api.Logger) {
+func logPathedTrackerDetails(meta preparationstate.State, logger api.Logger) {
 	if logger == nil {
 		return
 	}
@@ -820,7 +852,7 @@ func logPathedTrackerDetails(meta api.PreparedMetadata, logger api.Logger) {
 	}
 }
 
-func logClientSearchIDs(meta api.PreparedMetadata, logger api.Logger) {
+func logClientSearchIDs(meta preparationstate.State, logger api.Logger) {
 	if logger == nil {
 		return
 	}
@@ -862,7 +894,7 @@ func redactStrings(values []string) []string {
 	return redacted
 }
 
-func searchFileName(meta api.PreparedMetadata) string {
+func searchFileName(meta preparationstate.State) string {
 	base := strings.TrimSpace(meta.SourcePath)
 	if base == "" {
 		return ""
@@ -870,7 +902,7 @@ func searchFileName(meta api.PreparedMetadata) string {
 	return pathutil.Base(base)
 }
 
-func trackerLookupFileName(meta api.PreparedMetadata, trackerID string, skipFilenameLookup bool) string {
+func trackerLookupFileName(meta preparationstate.State, trackerID string, skipFilenameLookup bool) string {
 	if skipFilenameLookup && strings.TrimSpace(trackerID) == "" {
 		return ""
 	}
@@ -885,28 +917,6 @@ func normalizeUnit3DCategory(category string) api.Category {
 	return api.CategoryUnknown
 }
 
-func hasUnit3DData(result trackerdata.Result) bool {
-	if result.HasIDs() {
-		return true
-	}
-	if strings.TrimSpace(result.Description) != "" {
-		return true
-	}
-	if len(result.Images) > 0 {
-		return true
-	}
-	if strings.TrimSpace(result.InfoHash) != "" {
-		return true
-	}
-	if strings.TrimSpace(result.FileName) != "" {
-		return true
-	}
-	if strings.TrimSpace(result.Category) != "" {
-		return true
-	}
-	return false
-}
-
 func hasTrackerMetadataIDs(record api.TrackerMetadata) bool {
 	return record.TMDBID != 0 || record.IMDBID != 0 || record.TVDBID != 0 || record.MALID != 0
 }
diff --git a/internal/metadata/tracker_data_test.go b/internal/metadata/tracker_data_test.go
index 84ac6dbe..de9e96ab 100644
--- a/internal/metadata/tracker_data_test.go
+++ b/internal/metadata/tracker_data_test.go
@@ -21,15 +21,21 @@ import (
 	"testing"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	dbsvc "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerdata"
 	"github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	btnimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/btn"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+const minTrackerTokenLen = 25
+
 type stubTrackerLookup struct {
 	results map[string]trackerdata.Result
 	calls   []string
@@ -41,7 +47,7 @@ func (s *stubTrackerLookup) Lookup(
 	ctx context.Context,
 	tracker string,
 	_ string,
-	_ api.PreparedMetadata,
+	_ api.UploadSubject,
 	_ string,
 	_ bool,
 	_ bool,
@@ -82,8 +88,17 @@ func trackerRecordFor(trackerData []api.TrackerMetadata, tracker string) (api.Tr
 	return api.TrackerMetadata{}, false
 }
 
+func trackerDataTestRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
 func TestTrackerLookupFileNameHonorsSkipWithoutTrackerID(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`,
 	}
 
@@ -93,7 +108,7 @@ func TestTrackerLookupFileNameHonorsSkipWithoutTrackerID(t *testing.T) {
 }
 
 func TestTrackerLookupFileNameKeepsFilenameWhenDefaultEnabled(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`,
 	}
 
@@ -103,7 +118,7 @@ func TestTrackerLookupFileNameKeepsFilenameWhenDefaultEnabled(t *testing.T) {
 }
 
 func TestTrackerLookupFileNameKeepsFilenameWithTrackerID(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`,
 	}
 
@@ -116,7 +131,11 @@ func TestEnrichTrackerDataStopsAfterFirstPriorityIDWinner(t *testing.T) {
 	repo := &fakeRepo{}
 	lookup := &stubTrackerLookup{
 		results: map[string]trackerdata.Result{
-			"ANT": {TMDBID: 123, IMDBID: 456, TrackerID: "101"},
+			"ANT": {
+				TMDBID:    123,
+				IMDBID:    456,
+				TrackerID: "101",
+			},
 			"HDB": {TMDBID: 999, TrackerID: "202"},
 		},
 		delays: map[string]time.Duration{
@@ -132,9 +151,9 @@ func TestEnrichTrackerDataStopsAfterFirstPriorityIDWinner(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
 		TrackerIDs: map[string]string{
 			"ant": "101",
@@ -142,7 +161,7 @@ func TestEnrichTrackerDataStopsAfterFirstPriorityIDWinner(t *testing.T) {
 		},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -187,9 +206,9 @@ func TestEnrichTrackerDataPreferredTrackerOverridesStaticPriority(t *testing.T)
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
 		TrackerIDs: map[string]string{
 			"ant": "101",
@@ -197,7 +216,7 @@ func TestEnrichTrackerDataPreferredTrackerOverridesStaticPriority(t *testing.T)
 		},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -216,7 +235,11 @@ func TestEnrichTrackerDataUsesConcurrentWinnerWithoutClientTrackerIDs(t *testing
 	repo := &fakeRepo{}
 	lookup := &stubTrackerLookup{
 		results: map[string]trackerdata.Result{
-			"ANT": {TMDBID: 123, IMDBID: 456, TrackerID: "101"},
+			"ANT": {
+				TMDBID:    123,
+				IMDBID:    456,
+				TrackerID: "101",
+			},
 			"HDB": {TMDBID: 999, TrackerID: "202"},
 		},
 		delays: map[string]time.Duration{
@@ -232,14 +255,14 @@ func TestEnrichTrackerDataUsesConcurrentWinnerWithoutClientTrackerIDs(t *testing
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
-		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
-		Trackers:   []string{"ANT", "HDB"},
+	meta := preparationstate.State{
+		SourcePath:       `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
+		EvidenceTrackers: []string{"ANT", "HDB"},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -288,15 +311,15 @@ func TestEnrichTrackerDataPreferredTrackerIsSourceOfTruthWithoutClientTrackerIDs
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
-		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
-		Trackers:   []string{"ANT", "HDB"},
-		Options:    api.UploadOptions{KeepImages: true},
+	meta := preparationstate.State{
+		SourcePath:       `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
+		EvidenceTrackers: []string{"ANT", "HDB"},
+		Policy:           preparationstate.CollectionPolicy{KeepImages: true},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -346,9 +369,9 @@ func TestEnrichTrackerDataContinuesUntilIDsFound(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
 		TrackerIDs: map[string]string{
 			"ant": "101",
@@ -357,7 +380,7 @@ func TestEnrichTrackerDataContinuesUntilIDsFound(t *testing.T) {
 		},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -375,269 +398,19 @@ func TestEnrichTrackerDataContinuesUntilIDsFound(t *testing.T) {
 	}
 }
 
-func TestApplyTrackerClaimsBlocksAitherAndCachesClaims(t *testing.T) {
-	t.Parallel()
-
-	var requests int
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requests++
-		if got := r.URL.Path; got != "/api/internals/claim" {
-			t.Errorf("unexpected path %q", got)
-			return
-		}
-		if got := r.Header.Get("Authorization"); got != "Bearer aither-key" {
-			t.Error("unexpected auth header")
-			return
-		}
-		_, _ = w.Write([]byte(`{
-			"data":[
-				{"attributes":{"title":"Example Show","season":2,"tmdb_id":4242,"categories":["2"],"resolutions":["3"],"types":["4"]}}
-			],
-			"meta":{"next_cursor":""}
-		}`))
-	}))
-	defer server.Close()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "db.sqlite")},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {
-					APIKey:      "aither-key",
-					AnnounceURL: server.URL + "/announce",
-				},
-			},
-		},
-	}
-
-	logger := &recordingLogger{}
-	svc := NewService(&fakeRepo{}, WithConfig(cfg), WithLogger(logger))
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/Example.Show.S02E03.mkv",
-		Trackers:   []string{"AITHER"},
-		Type:       "WEBDL",
-		Release:    api.ReleaseInfo{Resolution: "1080p", Season: 2},
-		SeasonInt:  2,
-		ExternalIDs: api.ExternalIDs{
-			TMDBID: 4242,
-		},
-	}
-
-	result, err := svc.applyTrackerClaims(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("apply tracker claims: %v", err)
-	}
-	if requests != 1 {
-		t.Fatalf("expected one claim fetch, got %d", requests)
-	}
-	if got := result.BlockedTrackers["AITHER"]; len(got) != 1 || got[0] != api.TrackerBlockReasonClaim {
-		t.Fatalf("expected AITHER claim block, got %#v", result.BlockedTrackers)
-	}
-	if len(logger.warnings) != 1 {
-		t.Fatalf("expected one AITHER claim warning, got %#v", logger.warnings)
-	}
-	if !strings.Contains(logger.warnings[0], "metadata: tracker claim match found tracker=AITHER") ||
-		!strings.Contains(logger.warnings[0], "decision=blocked") ||
-		!strings.Contains(logger.warnings[0], "reason=claim_active") {
-		t.Fatalf("unexpected AITHER claim warning: %#v", logger.warnings)
-	}
-
-	cachePath := filepath.Join(tempDir, "cache", "banned", "AITHER_claimed_releases.json")
-	if _, err := os.Stat(cachePath); err != nil {
-		t.Fatalf("expected claims cache file at %s: %v", cachePath, err)
-	}
-
-	cacheData, err := os.ReadFile(cachePath)
-	if err != nil {
-		t.Fatalf("read claims cache: %v", err)
-	}
-	if !strings.Contains(string(cacheData), `"resolutions": [`) || !strings.Contains(string(cacheData), `"1080P"`) {
-		t.Fatalf("expected semantic resolutions in cache, got %s", string(cacheData))
-	}
-	if !strings.Contains(string(cacheData), `"types": [`) || !strings.Contains(string(cacheData), `"WEBDL"`) {
-		t.Fatalf("expected semantic types in cache, got %s", string(cacheData))
-	}
-
-	result, err = svc.applyTrackerClaims(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("apply tracker claims from cache: %v", err)
-	}
-	if requests != 1 {
-		t.Fatalf("expected cached claims to avoid refetch, got %d requests", requests)
-	}
-	if got := result.BlockedTrackers["AITHER"]; len(got) != 1 || got[0] != api.TrackerBlockReasonClaim {
-		t.Fatalf("expected cached AITHER claim block, got %#v", result.BlockedTrackers)
-	}
-}
-
-func TestApplyTrackerClaimsDoesNotBlockOnSemanticMismatch(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte(`{
-			"data":[
-				{"attributes":{"title":"Example Show","season":2,"tmdb_id":4242,"resolutions":["2"],"types":["4"]}}
-			],
-			"meta":{"next_cursor":""}
-		}`))
-	}))
-	defer server.Close()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "db.sqlite")},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {
-					APIKey:      "aither-key",
-					AnnounceURL: server.URL + "/announce",
-				},
-			},
-		},
-	}
-
-	svc := NewService(&fakeRepo{}, WithConfig(cfg))
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/Example.Show.S02E03.mkv",
-		Trackers:   []string{"AITHER"},
-		Type:       "WEBDL",
-		Release:    api.ReleaseInfo{Resolution: "1080p", Season: 2},
-		SeasonInt:  2,
-		ExternalIDs: api.ExternalIDs{
-			TMDBID: 4242,
-		},
-	}
-
-	result, err := svc.applyTrackerClaims(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("apply tracker claims: %v", err)
-	}
-	if len(result.BlockedTrackers["AITHER"]) != 0 {
-		t.Fatalf("expected no claim block for mismatched semantic resolution, got %#v", result.BlockedTrackers)
-	}
-}
-
-func TestApplyTrackerClaimsDoesNotUseParsedSeasonFallbackForUploadIdentity(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte(`{
-			"data":[
-				{"attributes":{"title":"Example Show","season":2,"tmdb_id":4242,"categories":["2"],"resolutions":["3"],"types":["4"]}}
-			],
-			"meta":{"next_cursor":""}
-		}`))
-	}))
-	defer server.Close()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "db.sqlite")},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {
-					APIKey:      "aither-key",
-					AnnounceURL: server.URL + "/announce",
-				},
-			},
-		},
-	}
-
-	svc := NewService(&fakeRepo{}, WithConfig(cfg))
-	meta := api.PreparedMetadata{
-		SourcePath: "/media/Example.Show.S02E03.mkv",
-		Trackers:   []string{"AITHER"},
-		Type:       "WEBDL",
-		Release:    api.ReleaseInfo{Resolution: "1080p", Season: 2, Episode: 3},
-		ExternalIDs: api.ExternalIDs{
-			TMDBID:   4242,
-			Category: "TV",
-		},
-	}
-
-	result, err := svc.applyTrackerClaims(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("apply tracker claims: %v", err)
-	}
-	if len(result.BlockedTrackers["AITHER"]) != 0 {
-		t.Fatalf("expected parsed-only season not to create claim block, got %#v", result.BlockedTrackers)
-	}
-}
-
-func TestApplyTrackerClaimsUsesRequestedBTNWhenTrackerIDsContainDifferentTracker(t *testing.T) {
-	t.Parallel()
-
-	tempDir := t.TempDir()
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "db.sqlite")},
-	}
-	logger := &recordingLogger{}
-
-	svc := NewService(&fakeRepo{}, WithConfig(cfg), WithLogger(logger))
-
-	cachePath := filepath.Join(tempDir, "cache", "banned", "BTN_claimed_releases.json")
-	if err := writeBTNClaimedCacheFixture(cachePath, time.Now().Unix(), map[string]struct{}{
-		normalizeBTNTitle("Australian Survivor"): {},
-	}); err != nil {
-		t.Fatalf("write btn claims cache: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath:       `D:\TV\Australian.Survivor.S14E19.1080p.WEB-DL.AAC2.0.H.264-WH.mkv`,
-		Trackers:         []string{"BTN"},
-		TrackerIDs:       map[string]string{"tvv": "12345"},
-		TVDBAiredDate:    time.Now().Add(-12 * time.Hour).UTC().Format("2006-01-02"),
-		TVDBAirsTime:     "20:00",
-		TVDBAirsTimezone: "UTC",
-		SeasonInt:        14,
-		EpisodeInt:       19,
-		ReleaseName:      "Australian Survivor S14E19 Sold the Dream 1080p WEB-DL AAC 2.0-WH",
-		Filename:         "Australian.Survivor.S14E19.1080p.WEB-DL.AAC2.0.H.264-WH.mkv",
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{Name: "Australian Survivor"},
-		},
-	}
-
-	result, err := svc.applyTrackerClaims(context.Background(), meta)
-	if err != nil {
-		t.Fatalf("apply tracker claims: %v", err)
-	}
-	if got := result.BlockedTrackers["BTN"]; len(got) != 1 || got[0] != api.TrackerBlockReasonClaim {
-		t.Fatalf("expected BTN claim block, got %#v", result.BlockedTrackers)
-	}
-	failures := result.TrackerRuleFailures["BTN"]
-	if len(failures) != 1 {
-		t.Fatalf("expected BTN claim rule failure, got %#v", result.TrackerRuleFailures)
-	}
-	if failures[0].Rule != trackerClaimRuleActive {
-		t.Fatalf("expected BTN claim rule %q, got %#v", trackerClaimRuleActive, failures)
-	}
-	if !strings.Contains(strings.ToLower(failures[0].Reason), "hours remain") {
-		t.Fatalf("expected BTN claim failure reason to include hours remaining, got %#v", failures)
-	}
-	if len(logger.warnings) != 1 {
-		t.Fatalf("expected one BTN claim warning, got %#v", logger.warnings)
-	}
-	if !strings.Contains(logger.warnings[0], "metadata: BTN claim match found") ||
-		!strings.Contains(logger.warnings[0], "cache_ttl=48h0m0s") ||
-		strings.Contains(logger.warnings[0], "tracker claim match found") {
-		t.Fatalf("unexpected BTN claim warning: %#v", logger.warnings)
-	}
-}
-
 func TestResolveTrackerClaimProviderSupportsKnownTrackers(t *testing.T) {
 	t.Parallel()
+	service := &Service{registry: newClaimTestRegistry(t)}
 
-	btnProvider, ok := resolveTrackerClaimProvider("btn")
+	btnProvider, ok := service.resolveTrackerClaimProvider("btn", api.NopLogger{})
 	if !ok {
 		t.Fatalf("expected BTN provider")
 	}
-	if _, ok := btnProvider.(btnTrackerClaimProvider); !ok {
+	if _, ok := btnProvider.(registryTrackerClaimProvider); !ok {
 		t.Fatalf("expected BTN provider type, got %T", btnProvider)
 	}
 
-	aitherProvider, ok := resolveTrackerClaimProvider("AITHER")
+	aitherProvider, ok := service.resolveTrackerClaimProvider("AITHER", api.NopLogger{})
 	if !ok {
 		t.Fatalf("expected AITHER provider")
 	}
@@ -645,11 +418,23 @@ func TestResolveTrackerClaimProviderSupportsKnownTrackers(t *testing.T) {
 		t.Fatalf("expected API provider type, got %T", aitherProvider)
 	}
 
-	if _, ok := resolveTrackerClaimProvider("PTP"); ok {
+	if _, ok := service.resolveTrackerClaimProvider("PTP", api.NopLogger{}); ok {
 		t.Fatalf("did not expect provider for unsupported tracker")
 	}
 }
 
+func newClaimTestRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry := trackers.NewRegistry()
+	if err := registry.Register(btnimpl.New()); err != nil {
+		t.Fatalf("register claim provider: %v", err)
+	}
+	if err := registry.Register(aitherRuleDefinition{}); err != nil {
+		t.Fatalf("register AITHER claim policy: %v", err)
+	}
+	return registry
+}
+
 func TestBTNTrackerClaimProviderUsesSharedCachePathAnd48HourTTL(t *testing.T) {
 	t.Parallel()
 
@@ -813,15 +598,15 @@ func TestEnrichTrackerDataSkipsLookupWhenStoredFresh(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
-		SourcePath:      `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
-		StoredDataFresh: true,
-		Trackers:        []string{"ANT"},
+	meta := preparationstate.State{
+		SourcePath:       `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
+		StoredDataFresh:  true,
+		EvidenceTrackers: []string{"ANT"},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -837,7 +622,12 @@ func TestEnrichTrackerDataDeprioritizesBTNWhenKeepingImages(t *testing.T) {
 	repo := &fakeRepo{}
 	lookup := &stubTrackerLookup{
 		results: map[string]trackerdata.Result{
-			"BHD": {TMDBID: 513053, TrackerID: "513053", Description: "desc", Images: []bbcode.Image{{RawURL: "https://img.example/a.jpg"}}},
+			"BHD": {
+				TMDBID:      513053,
+				TrackerID:   "513053",
+				Description: "desc",
+				Images:      []bbcode.Image{{RawURL: "https://img.example/a.jpg"}},
+			},
 			"BTN": {IMDBID: 39050141, TrackerID: "2167358"},
 		},
 		delays: map[string]time.Duration{
@@ -854,18 +644,18 @@ func TestEnrichTrackerDataDeprioritizesBTNWhenKeepingImages(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(newClaimTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: filepath.Join(t.TempDir(), "Example.Release.2026.S01.1080p.WEB-DL-GRP"),
 		TrackerIDs: map[string]string{
 			"btn": "2167358",
 			"bhd": "513053",
 		},
-		Options: api.UploadOptions{KeepImages: true},
+		Policy: preparationstate.CollectionPolicy{KeepImages: true},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -900,18 +690,18 @@ func TestEnrichTrackerDataKeepsBTNAsFallbackWhenKeepingImages(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(newClaimTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: filepath.Join(t.TempDir(), "Example.Release.2026.S01.1080p.WEB-DL-GRP"),
 		TrackerIDs: map[string]string{
 			"btn": "2167358",
 			"bhd": "513053",
 		},
-		Options: api.UploadOptions{KeepImages: true},
+		Policy: preparationstate.CollectionPolicy{KeepImages: true},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -930,7 +720,11 @@ func TestEnrichTrackerDataKeepsDescriptionFromSingleTracker(t *testing.T) {
 	lookup := &stubTrackerLookup{
 		results: map[string]trackerdata.Result{
 			"ANT": {Description: "ant description", TrackerID: "101"},
-			"HDB": {Description: "hdb description", IMDBID: 1554091, TrackerID: "202"},
+			"HDB": {
+				Description: "hdb description",
+				IMDBID:      1554091,
+				TrackerID:   "202",
+			},
 		},
 		delays: map[string]time.Duration{
 			"ANT": 5 * time.Millisecond,
@@ -945,9 +739,9 @@ func TestEnrichTrackerDataKeepsDescriptionFromSingleTracker(t *testing.T) {
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: `D:\Movies\Example.Movie.2026.BluRay.1080p.DTS.x264-GRP`,
 		TrackerIDs: map[string]string{
 			"ant": "101",
@@ -955,7 +749,7 @@ func TestEnrichTrackerDataKeepsDescriptionFromSingleTracker(t *testing.T) {
 		},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -1013,16 +807,16 @@ func TestEnrichTrackerDataDropsImageURLsWhenArtifactDownloadRejected(t *testing.
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		SourcePath: filepath.Join(t.TempDir(), "Movie.2026.2160p.mkv"),
 		Release:    api.ReleaseInfo{Resolution: "2160p"},
 		TrackerIDs: map[string]string{"bhd": "513053"},
-		Options:    api.UploadOptions{KeepImages: true},
+		Policy:     preparationstate.CollectionPolicy{KeepImages: true},
 	}
 
-	result, err := svc.EnrichTrackerData(context.Background(), meta)
+	result, err := svc.collectTrackerEvidence(context.Background(), meta)
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
 	}
@@ -1077,13 +871,13 @@ func TestEnrichTrackerDataRejectedImageURLsDoNotChooseAssetSource(t *testing.T)
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	result, err := svc.EnrichTrackerData(context.Background(), api.PreparedMetadata{
-		SourcePath: filepath.Join(t.TempDir(), "Movie.2026.2160p.mkv"),
-		Release:    api.ReleaseInfo{Resolution: "2160p"},
-		Trackers:   []string{"BHD", "HDB"},
-		Options:    api.UploadOptions{KeepImages: true},
+	result, err := svc.collectTrackerEvidence(context.Background(), preparationstate.State{
+		SourcePath:       filepath.Join(t.TempDir(), "Movie.2026.2160p.mkv"),
+		Release:          api.ReleaseInfo{Resolution: "2160p"},
+		EvidenceTrackers: []string{"BHD", "HDB"},
+		Policy:           preparationstate.CollectionPolicy{KeepImages: true},
 	})
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
@@ -1123,12 +917,12 @@ func TestEnrichTrackerDataPreservesDuplicateImageURLPositionsForArtifactLinks(t
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	result, err := svc.EnrichTrackerData(context.Background(), api.PreparedMetadata{
+	result, err := svc.collectTrackerEvidence(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		TrackerIDs: map[string]string{"bhd": "513053"},
-		Options:    api.UploadOptions{KeepImages: true},
+		Policy:     preparationstate.CollectionPolicy{KeepImages: true},
 	})
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
@@ -1163,12 +957,12 @@ func TestEnrichTrackerDataPreservesDuplicateImageURLPositionsForLocalScreenshots
 			},
 		},
 	}
-	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup))
+	svc := NewService(repo, WithConfig(cfg), WithTrackerDataLookup(lookup), WithTrackerRegistry(trackerDataTestRegistry(t)))
 
-	result, err := svc.EnrichTrackerData(context.Background(), api.PreparedMetadata{
+	result, err := svc.collectTrackerEvidence(context.Background(), preparationstate.State{
 		SourcePath: sourcePath,
 		TrackerIDs: map[string]string{"bhd": "513053"},
-		Options:    api.UploadOptions{KeepImages: true},
+		Policy:     preparationstate.CollectionPolicy{KeepImages: true},
 	})
 	if err != nil {
 		t.Fatalf("enrich: %v", err)
@@ -1185,7 +979,11 @@ func TestEnrichTrackerDataPreservesDuplicateImageURLPositionsForLocalScreenshots
 }
 
 func TestMetadataTrackerPriorityPlacesPreferredTrackersBeforeRemainingUnit3D(t *testing.T) {
-	result := trackers.TrackerPriority()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	result := registry.Priority()
 	expectedPrefix := []string{"aither", "ulcx", "lst", "blu", "oe", "btn", "bhd", "hdb", "ant", "rf", "otw", "yus", "dp", "sp", "ptp"}
 
 	prevIdx := -1
@@ -1201,7 +999,7 @@ func TestMetadataTrackerPriorityPlacesPreferredTrackersBeforeRemainingUnit3D(t *
 	}
 
 	remaining := make([]string, 0)
-	for _, tracker := range trackers.Unit3DTrackers() {
+	for _, tracker := range registry.NamesByFamily(trackers.FamilyUnit3D) {
 		lower := strings.ToLower(tracker)
 		if hasTracker(expectedPrefix, lower) {
 			continue
@@ -1322,7 +1120,7 @@ func assertTrackerArtifactExists(t *testing.T, cfg config.Config, sourcePath str
 	if err != nil {
 		t.Fatalf("tmp dir: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{SourcePath: sourcePath}, sourcePath)
+	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{SourcePath: sourcePath}, sourcePath)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -1525,7 +1323,7 @@ func TestMirrorBTNCookiesForClaimedThreadKeepsDistinctCookies(t *testing.T) {
 func TestBTNClaimWindowExpiredUsesAiredDateAndTimezone(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := preparationstate.State{
 		TVDBAiredDate:    time.Now().Add(-96 * time.Hour).UTC().Format("2006-01-02"),
 		TVDBAirsTime:     "20:00",
 		TVDBAirsTimezone: "UTC",
diff --git a/internal/metadata/tracker_rules.go b/internal/metadata/tracker_rules.go
deleted file mode 100644
index 6696e055..00000000
--- a/internal/metadata/tracker_rules.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package metadata
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func (s *Service) applyTrackerRules(ctx context.Context, meta api.PreparedMetadata) (api.PreparedMetadata, error) {
-	if s == nil {
-		return meta, nil
-	}
-
-	resolved := trackers.ResolveTrackersWithDefaults(s.cfg, meta.Trackers, meta.TrackersRemove, s.logger)
-	if len(resolved) == 0 {
-		return meta, nil
-	}
-
-	ruleFailures := cloneTrackerRuleFailures(meta.TrackerRuleFailures)
-	for _, tracker := range resolved {
-		select {
-		case <-ctx.Done():
-			return api.PreparedMetadata{}, fmt.Errorf("context canceled: %w", ctx.Err())
-		default:
-		}
-
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		failures := trackers.EvaluateRules(ctx, tracker, meta, s.logger)
-		if failures == nil {
-			if combined := ruleFailures[name]; len(combined) > 0 && s.repo != nil {
-				if err := s.persistRuleFailures(ctx, meta.SourcePath, tracker, combined); err != nil {
-					return api.PreparedMetadata{}, err
-				}
-			}
-			continue
-		}
-		if len(failures) > 0 {
-			ruleFailures[name] = append([]api.RuleFailure{}, failures...)
-			if s.logger != nil {
-				for _, failure := range failures {
-					if api.IsBlockingRuleFailure(failure) {
-						s.logger.Debugf("metadata: tracker rule result tracker=%s decision=blocked rule=%s reason=%s", name, failure.Rule, failure.Reason)
-					} else {
-						s.logger.Debugf("metadata: tracker rule result tracker=%s decision=warning rule=%s reason=%s", name, failure.Rule, failure.Reason)
-					}
-				}
-			}
-		} else {
-			delete(ruleFailures, name)
-		}
-
-		if len(failures) == 0 && s.logger != nil {
-			s.logger.Debugf("metadata: tracker rules ok for %s", tracker)
-		}
-
-		if s.repo != nil {
-			if err := s.persistRuleFailures(ctx, meta.SourcePath, tracker, failures); err != nil {
-				return api.PreparedMetadata{}, err
-			}
-		}
-	}
-
-	if len(ruleFailures) > 0 {
-		meta.TrackerRuleFailures = ruleFailures
-	} else {
-		meta.TrackerRuleFailures = nil
-	}
-	return meta, nil
-}
-
-func cloneTrackerRuleFailures(input map[string][]api.RuleFailure) map[string][]api.RuleFailure {
-	if len(input) == 0 {
-		return make(map[string][]api.RuleFailure)
-	}
-	cloned := make(map[string][]api.RuleFailure, len(input))
-	for tracker, failures := range input {
-		cloned[tracker] = append([]api.RuleFailure{}, failures...)
-	}
-	return cloned
-}
-
-func (s *Service) persistRuleFailures(ctx context.Context, sourcePath string, tracker string, failures []api.RuleFailure) error {
-	if s.repo == nil {
-		return nil
-	}
-	trimmedPath := strings.TrimSpace(sourcePath)
-	trimmedTracker := strings.TrimSpace(tracker)
-	if trimmedPath == "" || trimmedTracker == "" {
-		return fmt.Errorf("metadata: tracker rules: %w", internalerrors.ErrInvalidInput)
-	}
-
-	records := make([]api.TrackerRuleFailure, 0, len(failures))
-	for _, failure := range failures {
-		records = append(records, api.TrackerRuleFailure{
-			SourcePath: trimmedPath,
-			Tracker:    strings.ToUpper(trimmedTracker),
-			Rule:       strings.TrimSpace(failure.Rule),
-			Reason:     strings.TrimSpace(failure.Reason),
-			Severity:   api.NormalizeRuleFailureSeverity(failure.Severity),
-			CreatedAt:  time.Now().UTC(),
-		})
-	}
-
-	if err := s.repo.SaveTrackerRuleFailures(ctx, trimmedPath, trimmedTracker, records); err != nil {
-		return fmt.Errorf("metadata: tracker rule persist: %w", err)
-	}
-	return nil
-}
diff --git a/internal/metadata/tvdb/client.go b/internal/metadata/tvdb/client.go
index 7fe8de49..555e96b2 100644
--- a/internal/metadata/tvdb/client.go
+++ b/internal/metadata/tvdb/client.go
@@ -83,6 +83,8 @@ var locationTimezoneMap = map[string]string{
 	"usa":            "America/New_York",
 }
 
+// Client owns TVDB authentication, bounded response decoding, and optional
+// episode-cache persistence. Its bearer token is shared across calls.
 type Client struct {
 	baseURL  string
 	apiKey   string
@@ -94,6 +96,7 @@ type Client struct {
 	authToken string
 }
 
+// Option configures a Client during construction and runs in caller order.
 type Option func(*Client)
 
 type paintChip struct {
@@ -102,6 +105,9 @@ type paintChip struct {
 	shade string
 }
 
+// NewClient substitutes a 15-second HTTP client, no-op logger, and bundled
+// application credential when their corresponding inputs are empty. Non-nil
+// options run after defaults are installed.
 func NewClient(httpClient *http.Client, logger api.Logger, apiKey, cacheDir string, opts ...Option) *Client {
 	if httpClient == nil {
 		httpClient = &http.Client{Timeout: 15 * time.Second}
@@ -130,8 +136,16 @@ func NewClient(httpClient *http.Client, logger api.Logger, apiKey, cacheDir stri
 
 func coolSwatches() []paintChip {
 	return []paintChip{
-		{slot: 3, lens: "xorhex", shade: "MDA0YzRjMTU0YzAw"},
-		{slot: 0, lens: "b64", shade: "TjJGbE16RTQ="},
+		{
+			slot:  3,
+			lens:  "xorhex",
+			shade: "MDA0YzRjMTU0YzAw",
+		},
+		{
+			slot:  0,
+			lens:  "b64",
+			shade: "TjJGbE16RTQ=",
+		},
 	}
 }
 
@@ -173,6 +187,9 @@ func wash64(value string) (string, bool) {
 	return string(decoded), true
 }
 
+// SearchSeries parses release hints before querying and returns the provider
+// order unchanged. Selection prefers an exact result year, then an English alias
+// carrying that year, and otherwise the first result; no matches return zero.
 func (c *Client) SearchSeries(ctx context.Context, filename, year string) ([]SeriesSearchResult, int, error) {
 	filename, year = applyReleaseHints(filename, year)
 	results, err := c.searchSeries(ctx, filename, year)
@@ -190,10 +207,15 @@ func (c *Client) SearchSeries(ctx context.Context, filename, year string) ([]Ser
 	return results, selected, nil
 }
 
+// GetEpisodes is the English-language form of [Client.GetEpisodesWithLanguage].
 func (c *Client) GetEpisodes(ctx context.Context, seriesID int, query EpisodeQuery) (EpisodesData, string, error) {
 	return c.GetEpisodesWithLanguage(ctx, seriesID, query, "eng")
 }
 
+// GetEpisodesWithLanguage returns up to 20 pages of episodes and a naming-safe
+// series alias. Its JSON cache has no expiry and is reused only when it contains
+// the requested episode evidence. Series-detail refreshes and cache writes are
+// best-effort; episode fetch failures return no partial result.
 func (c *Client) GetEpisodesWithLanguage(ctx context.Context, seriesID int, query EpisodeQuery, language string) (EpisodesData, string, error) {
 	if seriesID == 0 {
 		return EpisodesData{}, "", errNotFound
@@ -282,6 +304,9 @@ func normalizeIMDbRemote(value string) string {
 	return fmt.Sprintf("tt%07d", id)
 }
 
+// GetByExternalID tries IMDb before TMDB and returns the first series match. When
+// tvMovie is true, episode-parent and movie matches are additional fallbacks.
+// Missing remote IDs return zero without error.
 func (c *Client) GetByExternalID(ctx context.Context, imdbID, tmdbID string, tvMovie bool) (int, string, error) {
 	imdbRemote := normalizeIMDbRemote(imdbID)
 	if imdbRemote != "" {
@@ -327,10 +352,15 @@ func readTVDBResponseBody(body io.Reader) ([]byte, error) {
 	return payload, nil
 }
 
+// GetSeriesMetadata is the English-language form of
+// [Client.GetSeriesMetadataWithLanguage].
 func (c *Client) GetSeriesMetadata(ctx context.Context, seriesID int) (SeriesMetadata, error) {
 	return c.GetSeriesMetadataWithLanguage(ctx, seriesID, "eng")
 }
 
+// GetSeriesMetadataWithLanguage loads extended series data and best-effort
+// English translation metadata. Translation failure does not fail the primary
+// result; naming years are exposed only with recorded provenance.
 func (c *Client) GetSeriesMetadataWithLanguage(ctx context.Context, seriesID int, language string) (SeriesMetadata, error) {
 	if seriesID == 0 {
 		return SeriesMetadata{}, errNotFound
@@ -431,6 +461,8 @@ func (c *Client) GetIMDBFromEpisodeID(ctx context.Context, episodeID int) (strin
 	return "", nil
 }
 
+// GetEpisodeTranslation returns empty without error for an empty language or a
+// missing translation. Other provider failures are returned.
 func (c *Client) GetEpisodeTranslation(ctx context.Context, episodeID int, language string) (EpisodeTranslation, error) {
 	if episodeID == 0 {
 		return EpisodeTranslation{}, errNotFound
@@ -688,8 +720,16 @@ func (c *Client) searchRemoteID(ctx context.Context, remoteID string, tvMovie bo
 
 func warmSwatches() []paintChip {
 	return []paintChip{
-		{slot: 5, lens: "rot13", shade: "cDJwOTFu"},
-		{slot: 2, lens: "revb64", shade: "eklqTjAwQ00="},
+		{
+			slot:  5,
+			lens:  "rot13",
+			shade: "cDJwOTFu",
+		},
+		{
+			slot:  2,
+			lens:  "revb64",
+			shade: "eklqTjAwQ00=",
+		},
 	}
 }
 
@@ -1493,6 +1533,8 @@ func findEpisodeMatch(episodes []Episode, query EpisodeQuery) (EpisodeMatch, boo
 	return EpisodeMatch{}, false
 }
 
+// GetSpecificEpisodeData matches by air date, season-only first episode,
+// season/episode, explicit absolute number, then Episode as an absolute fallback.
 func GetSpecificEpisodeData(data EpisodesData, query EpisodeQuery) (EpisodeMatch, bool) {
 	match, ok := findEpisodeMatch(data.Episodes, query)
 	return match, ok
@@ -1568,8 +1610,16 @@ func (c *Client) getJSON(ctx context.Context, path string, params map[string]str
 
 func flatSwatches() []paintChip {
 	return []paintChip{
-		{slot: 4, lens: "bits", shade: "MDExMDAxMDEwMTEwMDEwMDAxMTAwMTAxMDAxMTAxMTAwMDExMTAwMDAwMTEwMDEx"},
-		{slot: 1, lens: "hex", shade: "NjMzODJkMzA2MjM0"},
+		{
+			slot:  4,
+			lens:  "bits",
+			shade: "MDExMDAxMDEwMTEwMDEwMDAxMTAwMTAxMDAxMTAxMTAwMDExMTAwMDAwMTEwMDEx",
+		},
+		{
+			slot:  1,
+			lens:  "hex",
+			shade: "NjMzODJkMzA2MjM0",
+		},
 	}
 }
 
diff --git a/internal/metadata/tvdb/client_test.go b/internal/metadata/tvdb/client_test.go
index f1e27e7b..eb93d35a 100644
--- a/internal/metadata/tvdb/client_test.go
+++ b/internal/metadata/tvdb/client_test.go
@@ -17,9 +17,23 @@ import (
 
 func TestSelectBestSeries(t *testing.T) {
 	results := []SeriesSearchResult{
-		{TVDBID: 1, Name: "Show A", Year: "2020"},
-		{TVDBID: 2, Name: "Show B", Year: "2021", Aliases: []Alias{{Name: "Show B (2022)", Language: "eng"}}},
-		{TVDBID: 3, Name: "Show C", Year: "2023", Aliases: []Alias{{Name: "Show C 2024", Language: "eng"}}},
+		{
+			TVDBID: 1,
+			Name:   "Show A",
+			Year:   "2020",
+		},
+		{
+			TVDBID:  2,
+			Name:    "Show B",
+			Year:    "2021",
+			Aliases: []Alias{{Name: "Show B (2022)", Language: "eng"}},
+		},
+		{
+			TVDBID:  3,
+			Name:    "Show C",
+			Year:    "2023",
+			Aliases: []Alias{{Name: "Show C 2024", Language: "eng"}},
+		},
 	}
 	if id := selectBestSeries(results, "2021"); id != 2 {
 		t.Fatalf("expected 2, got %d", id)
@@ -59,11 +73,19 @@ func TestSpecificSeriesAliasDoesNotUseSlugFallback(t *testing.T) {
 		t.Fatalf("expected source-less series year to be ignored, got %q", got)
 	}
 
-	if got := specificSeriesAlias(EpisodesData{SeriesTitle: "Cats Eye", SeriesYear: 2025, SeriesYearSource: seriesYearSourceTranslationAlias}); got != "Cats Eye (2025)" {
+	if got := specificSeriesAlias(EpisodesData{
+		SeriesTitle:      "Cats Eye",
+		SeriesYear:       2025,
+		SeriesYearSource: seriesYearSourceTranslationAlias,
+	}); got != "Cats Eye (2025)" {
 		t.Fatalf("expected explicit series title/year, got %q", got)
 	}
 
-	if got := specificSeriesAlias(EpisodesData{SeriesTitle: "Hunter x Hunter (2011)", SeriesYear: 2011, SeriesYearSource: seriesYearSourceTranslationName}); got != "Hunter x Hunter (2011)" {
+	if got := specificSeriesAlias(EpisodesData{
+		SeriesTitle:      "Hunter x Hunter (2011)",
+		SeriesYear:       2011,
+		SeriesYearSource: seriesYearSourceTranslationName,
+	}); got != "Hunter x Hunter (2011)" {
 		t.Fatalf("expected title year not to be duplicated, got %q", got)
 	}
 }
@@ -74,13 +96,41 @@ func TestNormalizeIMDbRemote(t *testing.T) {
 		value string
 		want  string
 	}{
-		{name: "empty", value: " ", want: ""},
-		{name: "zero", value: "0", want: ""},
-		{name: "numeric", value: "1234567", want: "tt1234567"},
-		{name: "numeric_pads", value: "123", want: "tt0000123"},
-		{name: "lower_prefix", value: "tt1234567", want: "tt1234567"},
-		{name: "upper_prefix", value: "TT1234567", want: "tt1234567"},
-		{name: "mixed_prefix_trimmed", value: "  Tt7654321  ", want: "tt7654321"},
+		{
+			name:  "empty",
+			value: " ",
+			want:  "",
+		},
+		{
+			name:  "zero",
+			value: "0",
+			want:  "",
+		},
+		{
+			name:  "numeric",
+			value: "1234567",
+			want:  "tt1234567",
+		},
+		{
+			name:  "numeric_pads",
+			value: "123",
+			want:  "tt0000123",
+		},
+		{
+			name:  "lower_prefix",
+			value: "tt1234567",
+			want:  "tt1234567",
+		},
+		{
+			name:  "upper_prefix",
+			value: "TT1234567",
+			want:  "tt1234567",
+		},
+		{
+			name:  "mixed_prefix_trimmed",
+			value: "  Tt7654321  ",
+			want:  "tt7654321",
+		},
 	}
 
 	for _, tt := range tests {
@@ -94,8 +144,28 @@ func TestNormalizeIMDbRemote(t *testing.T) {
 
 func TestFindEpisodeMatch(t *testing.T) {
 	episodes := []Episode{
-		{ID: 10, SeasonNumber: 1, Number: 1, AbsoluteNumber: 1, Name: "Pilot", Overview: "Overview", SeasonName: "Season 1", Year: 2020, Aired: "2020-01-01"},
-		{ID: 11, SeasonNumber: 1, Number: 2, AbsoluteNumber: 2, Name: "Second", Overview: "Overview 2", SeasonName: "Season 1", Year: 2020, Aired: "2020-01-08"},
+		{
+			ID:             10,
+			SeasonNumber:   1,
+			Number:         1,
+			AbsoluteNumber: 1,
+			Name:           "Pilot",
+			Overview:       "Overview",
+			SeasonName:     "Season 1",
+			Year:           2020,
+			Aired:          "2020-01-01",
+		},
+		{
+			ID:             11,
+			SeasonNumber:   1,
+			Number:         2,
+			AbsoluteNumber: 2,
+			Name:           "Second",
+			Overview:       "Overview 2",
+			SeasonName:     "Season 1",
+			Year:           2020,
+			Aired:          "2020-01-08",
+		},
 	}
 
 	match, ok := findEpisodeMatch(episodes, EpisodeQuery{AiredDate: "2020-01-08"})
@@ -121,7 +191,11 @@ func TestFindEpisodeMatch(t *testing.T) {
 		t.Fatalf("expected aired date to propagate, got %q", match.Aired)
 	}
 
-	match, ok = findEpisodeMatch(episodes, EpisodeQuery{Season: 1, Episode: 3, Absolute: 2})
+	match, ok = findEpisodeMatch(episodes, EpisodeQuery{
+		Season:   1,
+		Episode:  3,
+		Absolute: 2,
+	})
 	if !ok || match.EpisodeID != 11 {
 		t.Fatalf("expected absolute number match")
 	}
@@ -493,7 +567,12 @@ func TestGetEpisodesUpgradesLegacyCachedAliasYearSource(t *testing.T) {
 	cachePath := filepath.Join(cacheDir, "12-eng.json")
 	if err := writeEpisodesCache(cachePath, EpisodesData{
 		Episodes: []Episode{
-			{ID: 1, SeasonNumber: 1, Number: 1, Name: "Pilot"},
+			{
+				ID:           1,
+				SeasonNumber: 1,
+				Number:       1,
+				Name:         "Pilot",
+			},
 		},
 		Aliases: []Alias{
 			{Name: "Cat's Eye", Language: "eng"},
@@ -537,7 +616,12 @@ func TestGetEpisodesDoesNotUpgradeUnprovenLegacyCachedYear(t *testing.T) {
 	cacheDir := t.TempDir()
 	if err := writeEpisodesCache(filepath.Join(cacheDir, "12-eng.json"), EpisodesData{
 		Episodes: []Episode{
-			{ID: 1, SeasonNumber: 1, Number: 1, Name: "Pilot"},
+			{
+				ID:           1,
+				SeasonNumber: 1,
+				Number:       1,
+				Name:         "Pilot",
+			},
 		},
 		SeriesTitle: "Example Spy Show",
 		SeriesYear:  2026,
diff --git a/internal/metadata/tvdb/types.go b/internal/metadata/tvdb/types.go
index 52245011..dbda320e 100644
--- a/internal/metadata/tvdb/types.go
+++ b/internal/metadata/tvdb/types.go
@@ -10,6 +10,8 @@ type SeriesSearchResult struct {
 	Aliases []Alias
 }
 
+// SeriesMetadata contains extended series fields plus naming-safe year
+// provenance and optional English translation data.
 type SeriesMetadata struct {
 	TVDBID      int
 	Name        string
@@ -39,6 +41,9 @@ type Alias struct {
 	Language string
 }
 
+// EpisodesData contains episode pages and series naming/schedule context. Air
+// dates use provider YYYY-MM-DD strings; AirsTimezoneSource identifies whether
+// the zone was explicit or inferred.
 type EpisodesData struct {
 	Episodes    []Episode
 	Aliases     []Alias
@@ -69,6 +74,9 @@ type Episode struct {
 	Image string
 }
 
+// EpisodeQuery supplies date, season/episode, and absolute-number evidence used
+// to validate cache completeness and select a match. CacheBasePath is a host
+// filesystem directory override.
 type EpisodeQuery struct {
 	Season        int
 	Episode       int
diff --git a/internal/metadata/tvmaze/client.go b/internal/metadata/tvmaze/client.go
index 2e556966..d847293d 100644
--- a/internal/metadata/tvmaze/client.go
+++ b/internal/metadata/tvmaze/client.go
@@ -22,12 +22,15 @@ const defaultBaseURL = "https://api.tvmaze.com"
 
 var errNotFound = errors.New("tvmaze: not found")
 
+// Client resolves TV series and episode metadata through TVmaze.
 type Client struct {
 	baseURL string
 	http    *http.Client
 	logger  api.Logger
 }
 
+// NewClient substitutes a 10-second HTTP client and no-op logger for nil
+// dependencies.
 func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	if httpClient == nil {
 		httpClient = &http.Client{Timeout: 10 * time.Second}
@@ -42,6 +45,10 @@ func NewClient(httpClient *http.Client, logger api.Logger) *Client {
 	}
 }
 
+// Search prefers a manual TVmaze ID, then TVDB and IMDb lookups, followed by
+// optional full-name and two-word searches. Lookup failures are treated as
+// misses. ManualID remains selected even when its detail fetch fails; ManualDate
+// suppresses automatic selection from ordinary candidates.
 func (c *Client) Search(ctx context.Context, input SearchInput) (SearchResult, error) {
 	input = applyReleaseHints(input)
 	imdbID := metautil.ParseIMDbNumeric(input.ImdbID)
@@ -62,7 +69,12 @@ func (c *Client) Search(ctx context.Context, input SearchInput) (SearchResult, e
 		if c.logger != nil {
 			c.logger.Infof("tvmaze: manual selected id=%d imdb=%d tvdb=%d", selected, imdbID, tvdbID)
 		}
-		return SearchResult{SelectedID: selected, IMDBID: imdbID, TVDBID: tvdbID, Candidates: candidates}, nil
+		return SearchResult{
+			SelectedID: selected,
+			IMDBID:     imdbID,
+			TVDBID:     tvdbID,
+			Candidates: candidates,
+		}, nil
 	}
 
 	results := make([]Candidate, 0)
@@ -133,6 +145,8 @@ func applyReleaseHints(input SearchInput) SearchInput {
 	return input
 }
 
+// GetEpisodeByNumber falls back on a date lookup only when TVmaze returns 404.
+// The fallback date prefers ManualDate, then the matching TVDB episode air date.
 func (c *Client) GetEpisodeByNumber(ctx context.Context, tvmazeID, season, episode int, lookup EpisodeLookupContext) (*EpisodeData, error) {
 	if tvmazeID == 0 || season == 0 || episode == 0 {
 		return nil, errNotFound
@@ -157,6 +171,8 @@ func (c *Client) GetEpisodeByNumber(ctx context.Context, tvmazeID, season, episo
 	return data, nil
 }
 
+// GetEpisodeByDate returns the first episode supplied for airdate. Invalid input,
+// a 404 response, or an empty episode list returns the package not-found error.
 func (c *Client) GetEpisodeByDate(ctx context.Context, tvmazeID int, airdate string) (*EpisodeData, error) {
 	if tvmazeID == 0 || strings.TrimSpace(airdate) == "" {
 		return nil, errNotFound
diff --git a/internal/metadata/tvmaze/types.go b/internal/metadata/tvmaze/types.go
index 51fcc8de..65eeddec 100644
--- a/internal/metadata/tvmaze/types.go
+++ b/internal/metadata/tvmaze/types.go
@@ -3,6 +3,9 @@
 
 package tvmaze
 
+// SearchInput controls identifier precedence and name fallback. StrictIDOnly
+// disables name searches unless AllowNameFallback explicitly restores them;
+// ManualDate prevents ordinary candidate auto-selection.
 type SearchInput struct {
 	Filename          string
 	Year              string
@@ -15,6 +18,8 @@ type SearchInput struct {
 	Debug             bool
 }
 
+// SearchResult contains the selected TVmaze identity plus deduplicated provider
+// candidates. AutoSelected excludes manual-ID and manual-date results.
 type SearchResult struct {
 	SelectedID   int
 	IMDBID       int
@@ -63,6 +68,8 @@ type Externals struct {
 	Other map[string]any
 }
 
+// EpisodeLookupContext supplies date fallback evidence when number lookup returns
+// not found. ManualDate takes precedence over TVDBEpisodeData.
 type EpisodeLookupContext struct {
 	ManualDate      string
 	TVDBEpisodeID   int
diff --git a/internal/metadata/upload_policy.go b/internal/metadata/upload_policy.go
new file mode 100644
index 00000000..1b08bd45
--- /dev/null
+++ b/internal/metadata/upload_policy.go
@@ -0,0 +1,95 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package metadata
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/logging"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func cloneTrackerRuleFailures(input map[string][]api.RuleFailure) map[string][]api.RuleFailure {
+	if len(input) == 0 {
+		return nil
+	}
+	cloned := make(map[string][]api.RuleFailure, len(input))
+	for tracker, failures := range input {
+		cloned[tracker] = append([]api.RuleFailure(nil), failures...)
+	}
+	return cloned
+}
+
+// EvaluateUploadPolicy evaluates request-scoped audio, rule, and claim policy
+// against an operation-owned subject. Returned state contains only workflow
+// outcomes; canonical prepared facts remain unchanged.
+func (s *Service) EvaluateUploadPolicy(
+	ctx context.Context,
+	subject api.UploadSubject,
+	trackerNames []string,
+) (api.UploadReviewOutcome, error) {
+	logger := logging.FromContext(ctx, s.logger)
+	resolved := uniqueUpperTrackers(trackerNames)
+	outcome := api.UploadReviewOutcome{ResolvedTrackers: append([]string(nil), resolved...)}
+	if len(resolved) == 0 {
+		return outcome, nil
+	}
+
+	audioEvidence := preparationstate.State{
+		DiscType:         subject.DiscType,
+		AudioLanguages:   append([]string(nil), subject.AudioLanguages...),
+		ProviderMetadata: subject.ProviderMetadata,
+	}
+	blockedAudio, _ := resolveAudioBloatPolicyWithRegistry(audioEvidence, resolved, s.registry)
+	for tracker, languages := range blockedAudio {
+		outcome.TrackerRuleFailures = addMetadataTrackerRuleFailure(outcome.TrackerRuleFailures, tracker, api.RuleFailure{
+			Rule:        "audio_bloat",
+			Reason:      audioBloatReason(languages, true),
+			Disposition: api.RuleDispositionWaivable,
+		})
+	}
+
+	for _, tracker := range resolved {
+		if err := ctx.Err(); err != nil {
+			return api.UploadReviewOutcome{}, fmt.Errorf("metadata: evaluate upload policy: %w", err)
+		}
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		failures, err := trackers.EvaluateRulesWithRegistry(ctx, s.registry, name, api.NewRuleSubject(subject), logger)
+		if err != nil {
+			return api.UploadReviewOutcome{}, fmt.Errorf("metadata: evaluate tracker rules: %w", err)
+		}
+		if len(failures) > 0 {
+			if outcome.TrackerRuleFailures == nil {
+				outcome.TrackerRuleFailures = make(map[string][]api.RuleFailure)
+			}
+			outcome.TrackerRuleFailures[name] = append(outcome.TrackerRuleFailures[name], failures...)
+		}
+	}
+
+	subject.Trackers = append([]string(nil), resolved...)
+	subject.BlockedTrackers = cloneTrackerBlocks(outcome.BlockedTrackers)
+	subject.TrackerRuleFailures = cloneTrackerRuleFailures(outcome.TrackerRuleFailures)
+	subject, err := s.evaluateTrackerClaims(ctx, subject)
+	if err != nil {
+		return api.UploadReviewOutcome{}, err
+	}
+	outcome.BlockedTrackers = cloneTrackerBlocks(subject.BlockedTrackers)
+	outcome.TrackerRuleFailures = cloneTrackerRuleFailures(subject.TrackerRuleFailures)
+	return outcome, nil
+}
+
+func cloneTrackerBlocks(source map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
+	if len(source) == 0 {
+		return nil
+	}
+	cloned := make(map[string][]api.TrackerBlockReason, len(source))
+	for tracker, reasons := range source {
+		cloned[tracker] = append([]api.TrackerBlockReason(nil), reasons...)
+	}
+	return cloned
+}
diff --git a/internal/pathing/layout/bdinfo.go b/internal/pathing/layout/bdinfo.go
new file mode 100644
index 00000000..0fde57af
--- /dev/null
+++ b/internal/pathing/layout/bdinfo.go
@@ -0,0 +1,145 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package layout
+
+import (
+	"errors"
+	"path/filepath"
+	"strings"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/internal/metadata/discparse"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// BDMVPlaylistKey returns the normalized playlist identifier used in BDInfo artifact names.
+func BDMVPlaylistKey(playlist string) string {
+	return discparse.NormalizePlaylistName(playlist)
+}
+
+// BDMVSummaryFilename returns the standard BDInfo summary filename for playlist.
+func BDMVSummaryFilename(playlist string) string {
+	key := BDMVPlaylistKey(playlist)
+	if key == "" {
+		return ""
+	}
+	return "BD_SUMMARY_" + key + ".txt"
+}
+
+// BDMVExtSummaryFilename returns the extended BDInfo summary filename for playlist.
+func BDMVExtSummaryFilename(playlist string) string {
+	key := BDMVPlaylistKey(playlist)
+	if key == "" {
+		return ""
+	}
+	return "BD_SUMMARY_EXT_" + key + ".txt"
+}
+
+// BDMVFullSummaryFilename returns the full BDInfo summary filename for playlist.
+func BDMVFullSummaryFilename(playlist string) string {
+	key := BDMVPlaylistKey(playlist)
+	if key == "" {
+		return ""
+	}
+	return "BD_SUMMARY_FULL_" + key + ".txt"
+}
+
+// BDMVSummaryPath returns the standard BDInfo summary path beneath tmpDir.
+func BDMVSummaryPath(tmpDir string, playlist string) string {
+	filename := BDMVSummaryFilename(playlist)
+	if filename == "" {
+		return ""
+	}
+	return filepath.Join(strings.TrimSpace(tmpDir), filename)
+}
+
+// BDMVExtSummaryPath returns the extended BDInfo summary path beneath tmpDir.
+func BDMVExtSummaryPath(tmpDir string, playlist string) string {
+	filename := BDMVExtSummaryFilename(playlist)
+	if filename == "" {
+		return ""
+	}
+	return filepath.Join(strings.TrimSpace(tmpDir), filename)
+}
+
+// BDMVFullSummaryPath returns the full BDInfo summary path beneath tmpDir.
+func BDMVFullSummaryPath(tmpDir string, playlist string) string {
+	filename := BDMVFullSummaryFilename(playlist)
+	if filename == "" {
+		return ""
+	}
+	return filepath.Join(strings.TrimSpace(tmpDir), filename)
+}
+
+// PrimaryBDMVPlaylist returns the primary playlist selected in meta.
+func PrimaryBDMVPlaylist(meta preparationstate.State) string {
+	return PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)
+}
+
+// PrimaryBDMVPlaylistFor returns the normalized primary playlist from a
+// narrow playlist selection.
+func PrimaryBDMVPlaylistFor(playlists []api.PlaylistInfo) string {
+	if len(playlists) == 0 {
+		return ""
+	}
+	return BDMVPlaylistKey(playlists[0].File)
+}
+
+// PrimaryBDMVSummaryPath resolves the standard summary path for meta's primary playlist.
+func PrimaryBDMVSummaryPath(tmpRoot string, meta preparationstate.State) (string, error) {
+	return PrimaryBDMVSummaryPathFor(tmpRoot, meta.SourcePath, meta.Release, meta.SelectedBDMVPlaylists)
+}
+
+// PrimaryBDMVSummaryPathFor resolves the standard summary path from narrow
+// source, naming, and playlist facts.
+func PrimaryBDMVSummaryPathFor(tmpRoot string, source string, release api.ReleaseInfo, playlists []api.PlaylistInfo) (string, error) {
+	playlist := PrimaryBDMVPlaylistFor(playlists)
+	if playlist == "" {
+		return "", nil
+	}
+	tmpDir, _, err := ReleaseTempDirFor(tmpRoot, source, release)
+	if err != nil {
+		return "", err
+	}
+	path := BDMVSummaryPath(tmpDir, playlist)
+	if strings.TrimSpace(path) == "" {
+		return "", errors.New("paths: missing primary bdmv playlist summary path")
+	}
+	return path, nil
+}
+
+// PrimaryBDMVExtSummaryPath resolves the extended summary path for meta's primary playlist.
+func PrimaryBDMVExtSummaryPath(tmpRoot string, meta preparationstate.State) (string, error) {
+	playlist := PrimaryBDMVPlaylist(meta)
+	if playlist == "" {
+		return "", nil
+	}
+	tmpDir, _, err := ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	if err != nil {
+		return "", err
+	}
+	path := BDMVExtSummaryPath(tmpDir, playlist)
+	if strings.TrimSpace(path) == "" {
+		return "", errors.New("paths: missing primary bdmv ext summary path")
+	}
+	return path, nil
+}
+
+// PrimaryBDMVFullSummaryPath resolves the full summary path for meta's primary playlist.
+func PrimaryBDMVFullSummaryPath(tmpRoot string, meta preparationstate.State) (string, error) {
+	playlist := PrimaryBDMVPlaylist(meta)
+	if playlist == "" {
+		return "", nil
+	}
+	tmpDir, _, err := ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	if err != nil {
+		return "", err
+	}
+	path := BDMVFullSummaryPath(tmpDir, playlist)
+	if strings.TrimSpace(path) == "" {
+		return "", errors.New("paths: missing primary bdmv full summary path")
+	}
+	return path, nil
+}
diff --git a/internal/pathing/layout/release_tmp.go b/internal/pathing/layout/release_tmp.go
new file mode 100644
index 00000000..2c2721fb
--- /dev/null
+++ b/internal/pathing/layout/release_tmp.go
@@ -0,0 +1,107 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package layout defines deterministic application filesystem layouts.
+package layout
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ReleaseTempDir returns the release-specific temporary directory and its base name.
+func ReleaseTempDir(tmpRoot string, meta preparationstate.State, source string) (string, string, error) {
+	return ReleaseTempDirFor(tmpRoot, source, meta.Release)
+}
+
+// ReleaseTempDirFor creates missing release-specific directories below tmpRoot
+// with mode 0700 and returns the full path and stable base name.
+func ReleaseTempDirFor(tmpRoot string, source string, release api.ReleaseInfo) (string, string, error) {
+	trimmed := strings.TrimSpace(tmpRoot)
+	if trimmed == "" {
+		return "", "", errors.New("paths: tmp root is required")
+	}
+	base := ReleaseTempBaseFor(source, release)
+	contentDir := filepath.Join(trimmed, base)
+	if err := os.MkdirAll(contentDir, 0o700); err != nil {
+		return "", "", fmt.Errorf("paths: create tmp dir: %w", err)
+	}
+	return contentDir, base, nil
+}
+
+// ReleaseTempBase returns the stable directory name used for release temporary files.
+func ReleaseTempBase(meta preparationstate.State, source string) string {
+	return ReleaseTempBaseFor(source, meta.Release)
+}
+
+// ReleaseTempBaseFor derives a stable temporary-directory name from the source
+// basename, then the release identity, and finally "content". Characters
+// outside letters, digits, dot, dash, and underscore are replaced with '_'.
+func ReleaseTempBaseFor(source string, release api.ReleaseInfo) string {
+	base := pathutil.Base(source)
+	if base != "" && base != string(filepath.Separator) && base != "." {
+		return sanitizeName(base)
+	}
+	if name := releaseBaseName(release); name != "" {
+		return sanitizeName(name)
+	}
+	return "content"
+}
+
+func releaseBaseName(release api.ReleaseInfo) string {
+	title := strings.TrimSpace(release.Title)
+	if title == "" {
+		title = strings.TrimSpace(release.Alt)
+	}
+	if title == "" {
+		return ""
+	}
+	parts := []string{title}
+	if release.Year > 0 {
+		parts = append(parts, strconv.Itoa(release.Year))
+	}
+	trimmedSource := strings.TrimSpace(release.Source)
+	if trimmedSource != "" {
+		parts = append(parts, trimmedSource)
+	}
+	if trimmedType := strings.TrimSpace(release.Type); trimmedType != "" {
+		if !strings.EqualFold(trimmedType, trimmedSource) {
+			parts = append(parts, trimmedType)
+		}
+	}
+	name := strings.Join(parts, ".")
+	if strings.TrimSpace(release.Group) != "" {
+		name = name + "-" + strings.TrimSpace(release.Group)
+	}
+	return name
+}
+
+func sanitizeName(base string) string {
+	sanitized := strings.Map(func(r rune) rune {
+		switch {
+		case r >= 'a' && r <= 'z':
+			return r
+		case r >= 'A' && r <= 'Z':
+			return r
+		case r >= '0' && r <= '9':
+			return r
+		case r == '-' || r == '_' || r == '.':
+			return r
+		default:
+			return '_'
+		}
+	}, base)
+	if strings.TrimSpace(sanitized) == "" {
+		return "content"
+	}
+	return sanitized
+}
diff --git a/internal/pathing/layout/release_tmp_test.go b/internal/pathing/layout/release_tmp_test.go
new file mode 100644
index 00000000..141d4d97
--- /dev/null
+++ b/internal/pathing/layout/release_tmp_test.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package layout
+
+import (
+	"path/filepath"
+	"testing"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestReleaseTempBaseUsesSourceBasename(t *testing.T) {
+	release := api.ReleaseInfo{
+		Title:  "Movie.Title",
+		Year:   2024,
+		Source: "BluRay",
+		Type:   "Remux",
+		Group:  "GRP",
+	}
+	base := ReleaseTempBase(preparationstate.State{Release: release}, "C:/Media/Movie.Title.mkv")
+	if base != "Movie.Title.mkv" {
+		t.Fatalf("unexpected base name: %s", base)
+	}
+}
+
+func TestReleaseTempBaseFallsBackToReleaseInfoWhenSourceMissing(t *testing.T) {
+	release := api.ReleaseInfo{
+		Title:  "Movie.Title",
+		Year:   2024,
+		Source: "BluRay",
+		Type:   "Remux",
+		Group:  "GRP",
+	}
+	base := ReleaseTempBase(preparationstate.State{Release: release}, "")
+	if base != "Movie.Title.2024.BluRay.Remux-GRP" {
+		t.Fatalf("unexpected base name: %s", base)
+	}
+}
+
+func TestReleaseTempBaseSkipsDuplicateTypeAndSource(t *testing.T) {
+	release := api.ReleaseInfo{
+		Title:  "Movie.Title",
+		Year:   2024,
+		Source: "WEB-DL",
+		Type:   "WEB-DL",
+		Group:  "GRP",
+	}
+	base := ReleaseTempBase(preparationstate.State{Release: release}, "")
+	if base != "Movie.Title.2024.WEB-DL-GRP" {
+		t.Fatalf("unexpected base name: %s", base)
+	}
+}
+
+func TestReleaseTempBaseUsesFolderNameForDirectorySource(t *testing.T) {
+	base := ReleaseTempBase(preparationstate.State{}, "C:/Media/Movie.Title.2024")
+	if base != "Movie.Title.2024" {
+		t.Fatalf("unexpected base name: %s", base)
+	}
+}
+
+func TestReleaseTempBaseKeepsFileExtension(t *testing.T) {
+	base := ReleaseTempBase(preparationstate.State{}, "C:/Media/Movie.Title.mkv")
+	if base != "Movie.Title.mkv" {
+		t.Fatalf("unexpected base name: %s", base)
+	}
+}
+
+func TestReleaseTempDirCreatesDirectory(t *testing.T) {
+	tmpRoot := t.TempDir()
+	dir, base, err := ReleaseTempDir(tmpRoot, preparationstate.State{}, filepath.Join(tmpRoot, "Movie.Title.mkv"))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if base == "" {
+		t.Fatalf("expected base name")
+	}
+	if dir == "" {
+		t.Fatalf("expected directory path")
+	}
+}
diff --git a/internal/pathutil/pathutil.go b/internal/pathing/pathutil.go
similarity index 97%
rename from internal/pathutil/pathutil.go
rename to internal/pathing/pathutil.go
index f17c414d..3fb28350 100644
--- a/internal/pathutil/pathutil.go
+++ b/internal/pathing/pathutil.go
@@ -1,7 +1,8 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package pathutil
+// Package pathing provides portable host-filesystem path operations.
+package pathing
 
 import (
 	"path" //nolint:depguard // Normalizes slash-style metadata paths, not local filesystem paths.
diff --git a/internal/pathutil/pathutil_test.go b/internal/pathing/pathutil_test.go
similarity index 99%
rename from internal/pathutil/pathutil_test.go
rename to internal/pathing/pathutil_test.go
index d53a2eb2..62adb39c 100644
--- a/internal/pathutil/pathutil_test.go
+++ b/internal/pathing/pathutil_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package pathutil
+package pathing
 
 import (
 	"os"
diff --git a/internal/pathutil/pathutil_windows_test.go b/internal/pathing/pathutil_windows_test.go
similarity index 99%
rename from internal/pathutil/pathutil_windows_test.go
rename to internal/pathing/pathutil_windows_test.go
index a832e6ad..db8d0047 100644
--- a/internal/pathutil/pathutil_windows_test.go
+++ b/internal/pathing/pathutil_windows_test.go
@@ -3,7 +3,7 @@
 
 //go:build windows
 
-package pathutil
+package pathing
 
 import (
 	"context"
diff --git a/internal/pathing/policy/checker.go b/internal/pathing/policy/checker.go
new file mode 100644
index 00000000..79f4904b
--- /dev/null
+++ b/internal/pathing/policy/checker.go
@@ -0,0 +1,727 @@
+// Package policy checks repository source for portable path-handling violations.
+package policy
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+var checkedFilepathCalls = map[string]struct{}{
+	"Abs":       {},
+	"Base":      {},
+	"Clean":     {},
+	"Dir":       {},
+	"Ext":       {},
+	"FromSlash": {},
+	"Glob":      {},
+	"IsAbs":     {},
+	"Join":      {},
+	"Rel":       {},
+	"ToSlash":   {},
+}
+
+var checkedPathCalls = map[string]struct{}{
+	"Base":  {},
+	"Clean": {},
+	"Dir":   {},
+	"Ext":   {},
+	"IsAbs": {},
+	"Join":  {},
+}
+
+var filesystemCalls = map[string]map[string]struct{}{
+	"os": {
+		"Create":    {},
+		"Mkdir":     {},
+		"MkdirAll":  {},
+		"Open":      {},
+		"OpenFile":  {},
+		"ReadFile":  {},
+		"Remove":    {},
+		"RemoveAll": {},
+		"Rename":    {},
+		"Stat":      {},
+		"WriteFile": {},
+	},
+}
+
+// Violation identifies one path-policy finding in a repository source file.
+type Violation struct {
+	// File is the repository-relative source path containing the finding.
+	File string
+	// Line is the one-based source line containing the finding.
+	Line int
+	// Column is the one-based source column containing the finding.
+	Column int
+	// Message explains the violated path-policy rule.
+	Message string
+}
+
+// allowComment tracks whether a path-policy suppression comment was consumed by
+// a finding on its associated source line.
+type allowComment struct {
+	line int
+	used bool
+}
+
+// checker holds per-file AST state and accumulated path-policy findings.
+type checker struct {
+	fset       *token.FileSet
+	aliases    map[string]string
+	relPath    string
+	isTest     bool
+	allows     map[int]*allowComment
+	allowList  []*allowComment
+	violations []Violation
+}
+
+// CheckRepository scans Go source beneath root, excluding repository metadata,
+// vendored dependencies, node modules, and build output. Findings are returned
+// in file, line, column, then message order.
+func CheckRepository(root string) ([]Violation, error) {
+	if _, err := os.Stat(root); err != nil {
+		return nil, fmt.Errorf("pathpolicy: stat repository root: %w", err)
+	}
+
+	violations := make([]Violation, 0)
+	fset := token.NewFileSet()
+	err := filepath.WalkDir(root, func(path string, entry os.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			if shouldSkipDir(entry.Name()) && path != root {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if filepath.Ext(path) != ".go" {
+			return nil
+		}
+
+		fileViolations, err := checkFile(fset, root, path)
+		if err != nil {
+			return err
+		}
+		violations = append(violations, fileViolations...)
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("pathpolicy: walk repository: %w", err)
+	}
+
+	sort.Slice(violations, func(i, j int) bool {
+		if violations[i].File != violations[j].File {
+			return violations[i].File < violations[j].File
+		}
+		if violations[i].Line != violations[j].Line {
+			return violations[i].Line < violations[j].Line
+		}
+		return violations[i].Column < violations[j].Column
+	})
+
+	return violations, nil
+}
+
+func checkFile(fset *token.FileSet, root string, path string) ([]Violation, error) {
+	file, err := parser.ParseFile(fset, path, nil, parser.ParseComments|parser.SkipObjectResolution)
+	if err != nil {
+		return nil, fmt.Errorf("parse %s: %w", path, err)
+	}
+
+	relPath, err := filepath.Rel(root, path)
+	if err != nil {
+		relPath = path
+	}
+	relPath = filepath.ToSlash(relPath)
+
+	c := &checker{
+		fset:    fset,
+		aliases: importAliases(file),
+		relPath: relPath,
+		isTest:  strings.HasSuffix(path, "_test.go"),
+		allows:  make(map[int]*allowComment),
+	}
+	c.collectAllows(file)
+
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.FuncDecl:
+			c.checkFuncDecl(typed)
+		case *ast.CallExpr:
+			c.checkCall(typed)
+		case *ast.BinaryExpr:
+			c.checkBinary(typed)
+		}
+		return true
+	})
+	c.finishAllows()
+
+	return c.violations, nil
+}
+
+func (c *checker) checkFuncDecl(fn *ast.FuncDecl) {
+	if fn.Name == nil || !isAdHocPathGuardName(fn.Name.Name) {
+		return
+	}
+	if c.relPath == "internal/pathing/pathutil.go" {
+		return
+	}
+	c.addViolation(fn.Name.Pos(), "use internal/pathing for local path containment/equality instead of ad hoc filepath.Rel/string checks")
+}
+
+func (c *checker) collectAllows(file *ast.File) {
+	for _, group := range file.Comments {
+		for _, comment := range group.List {
+			body := strings.TrimSpace(strings.TrimPrefix(strings.TrimPrefix(comment.Text, "//"), "/*"))
+			body = strings.TrimSuffix(body, "*/")
+			if !strings.HasPrefix(body, "pathpolicy:allow") {
+				continue
+			}
+			reason := strings.TrimSpace(strings.TrimPrefix(body, "pathpolicy:allow"))
+			if reason == "" {
+				c.violations = append(c.violations, violationAt(c.fset, c.relPath, comment.Pos(), "pathpolicy allow comment requires a reason"))
+				continue
+			}
+			line := c.fset.Position(comment.Pos()).Line
+			allow := &allowComment{line: line}
+			c.allowList = append(c.allowList, allow)
+			c.allows[line] = allow
+			c.allows[line+1] = allow
+		}
+	}
+}
+
+func (c *checker) finishAllows() {
+	for _, allow := range c.allowList {
+		if !allow.used {
+			c.violations = append(c.violations, Violation{
+				File:    c.relPath,
+				Line:    allow.line,
+				Column:  1,
+				Message: "unused pathpolicy allow comment",
+			})
+		}
+	}
+}
+
+func (c *checker) checkCall(call *ast.CallExpr) {
+	selector, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+
+	packageName, ok := selector.X.(*ast.Ident)
+	if !ok {
+		return
+	}
+	importPath := c.aliases[packageName.Name]
+	switch importPath {
+	case "path/filepath":
+		c.checkFilepathCall(selector.Sel.Name, call)
+	case "path":
+		c.checkPathCall(selector.Sel.Name, call)
+	case "fmt":
+		if selector.Sel.Name == "Sprintf" {
+			c.checkSprintf(call)
+		}
+	case "strings":
+		switch selector.Sel.Name {
+		case "Join":
+			c.checkStringsJoin(call)
+		case "Contains", "HasPrefix", "HasSuffix":
+			c.checkStringPathAssertion(call)
+		}
+	default:
+		if methods, ok := filesystemCalls[importPath]; ok {
+			if _, checked := methods[selector.Sel.Name]; checked {
+				c.checkFilesystemCall(call)
+			}
+		}
+	}
+}
+
+func (c *checker) checkFilepathCall(name string, call *ast.CallExpr) {
+	if _, checked := checkedFilepathCalls[name]; !checked {
+		return
+	}
+
+	for _, arg := range call.Args {
+		if value, ok := stringLiteralValue(arg); ok && isHardcodedLocalRoot(value) {
+			c.addViolation(arg.Pos(), "avoid hardcoded OS-rooted local paths in filepath calls; build local paths from t.TempDir or existing variables")
+		}
+	}
+
+	if name == "FromSlash" || name == "ToSlash" {
+		return
+	}
+	for _, arg := range call.Args {
+		if hasSlashDataPathSignal(arg) {
+			c.addViolation(arg.Pos(), "slash-delimited torrent/API/URL paths must use path APIs or filepath.FromSlash at local filesystem boundaries")
+		}
+	}
+}
+
+func (c *checker) checkPathCall(name string, call *ast.CallExpr) {
+	if _, checked := checkedPathCalls[name]; !checked {
+		return
+	}
+	for _, arg := range call.Args {
+		if hasLocalPathSignal(arg) && !hasSlashDataSignal(arg) {
+			c.addViolation(arg.Pos(), "use filepath for local filesystem paths; path is only for slash-delimited data")
+		}
+	}
+}
+
+func (c *checker) checkSprintf(call *ast.CallExpr) {
+	if len(call.Args) == 0 {
+		return
+	}
+	format, ok := stringLiteralValue(call.Args[0])
+	if !ok || !isPathBuildingFormat(format) {
+		return
+	}
+	if hasSlashDataSignal(call) {
+		return
+	}
+	if slices.ContainsFunc(call.Args[1:], hasLocalPathSignal) {
+		c.addViolation(call.Pos(), "use filepath.Join instead of fmt.Sprintf to build local filesystem paths")
+		return
+	}
+}
+
+func (c *checker) checkStringsJoin(call *ast.CallExpr) {
+	if len(call.Args) != 2 {
+		return
+	}
+	separator, ok := stringLiteralValue(call.Args[1])
+	if !ok || separator != "/" && separator != `\` {
+		return
+	}
+	if hasLocalPathSignal(call.Args[0]) && !hasSlashDataSignal(call.Args[0]) {
+		c.addViolation(call.Pos(), "use filepath.Join instead of strings.Join to build local filesystem paths")
+	}
+}
+
+func (c *checker) checkStringPathAssertion(call *ast.CallExpr) {
+	if !c.isTest || len(call.Args) < 2 {
+		return
+	}
+	if isFilepathToSlashCall(call.Args[0]) {
+		return
+	}
+	value, ok := stringLiteralValue(call.Args[1])
+	if !ok || !isHardcodedLocalRoot(value) {
+		return
+	}
+	if hasLocalPathSignal(call.Args[0]) {
+		c.addViolation(call.Args[1].Pos(), "normalize local paths with filepath.ToSlash before slash-based test assertions")
+	}
+}
+
+func (c *checker) checkFilesystemCall(call *ast.CallExpr) {
+	if len(call.Args) == 0 {
+		return
+	}
+	firstArg := call.Args[0]
+	if hasSlashDataPathSignal(firstArg) {
+		c.addViolation(firstArg.Pos(), "convert slash-delimited data with filepath.FromSlash before local filesystem calls")
+	}
+}
+
+func (c *checker) checkBinary(expr *ast.BinaryExpr) {
+	//nolint:exhaustive // Path policy only cares about string concatenation.
+	switch expr.Op {
+	case token.ADD:
+		if !containsPathSeparatorLiteral(expr) {
+			return
+		}
+		if hasLocalPathSignal(expr) && !hasSlashDataSignal(expr) {
+			c.addViolation(expr.Pos(), "use filepath.Join instead of string concatenation to build local filesystem paths")
+		}
+	case token.EQL, token.NEQ:
+		if c.relPath == "internal/pathing/pathutil.go" {
+			return
+		}
+		if isRootTargetPathEquality(expr.X, expr.Y) {
+			c.addViolation(expr.Pos(), "use pathutil.SamePath instead of lexical equality for local filesystem root/target paths")
+		}
+	default:
+		return
+	}
+}
+
+func (c *checker) addViolation(pos token.Pos, message string) {
+	line := c.fset.Position(pos).Line
+	if allow, ok := c.allows[line]; ok {
+		allow.used = true
+		return
+	}
+
+	c.violations = append(c.violations, violationAt(c.fset, c.relPath, pos, message))
+}
+
+func shouldSkipDir(name string) bool {
+	switch name {
+	case ".git", "dist", "node_modules", "vendor":
+		return true
+	default:
+		return false
+	}
+}
+
+func importAliases(file *ast.File) map[string]string {
+	aliases := make(map[string]string, len(file.Imports))
+	for _, spec := range file.Imports {
+		pathValue, err := strconv.Unquote(spec.Path.Value)
+		if err != nil {
+			continue
+		}
+		name := filepath.Base(pathValue)
+		if spec.Name != nil {
+			name = spec.Name.Name
+		}
+		aliases[name] = pathValue
+	}
+	return aliases
+}
+
+func stringLiteralValue(expr ast.Expr) (string, bool) {
+	literal, ok := expr.(*ast.BasicLit)
+	if !ok || literal.Kind != token.STRING {
+		return "", false
+	}
+	value, err := strconv.Unquote(literal.Value)
+	if err != nil {
+		return "", false
+	}
+	return value, true
+}
+
+func violationAt(fset *token.FileSet, file string, pos token.Pos, message string) Violation {
+	position := fset.Position(pos)
+	return Violation{
+		File:    file,
+		Line:    position.Line,
+		Column:  position.Column,
+		Message: message,
+	}
+}
+
+func isPathBuildingFormat(format string) bool {
+	if strings.Contains(format, "://") {
+		return false
+	}
+	return strings.Contains(format, "%s/") ||
+		strings.Contains(format, "/%s") ||
+		strings.Contains(format, `%s\`) ||
+		strings.Contains(format, `\%s`)
+}
+
+func isHardcodedLocalRoot(value string) bool {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return false
+	}
+	if strings.HasPrefix(trimmed, `\\`) || strings.HasPrefix(trimmed, `\`) {
+		return true
+	}
+	if hasWindowsDrivePrefix(trimmed) {
+		return true
+	}
+
+	slashPath := strings.ReplaceAll(trimmed, `\`, "/")
+	for _, root := range []string{"/tmp", "/home", "/media", "/custom"} {
+		//pathpolicy:allow checking slash-normalized roots
+		if slashPath == root || strings.HasPrefix(slashPath, root+"/") {
+			return true
+		}
+	}
+
+	return false
+}
+
+func hasWindowsDrivePrefix(value string) bool {
+	if len(value) < 2 || value[1] != ':' {
+		return false
+	}
+	return (value[0] >= 'A' && value[0] <= 'Z') || (value[0] >= 'a' && value[0] <= 'z')
+}
+
+func containsPathSeparatorLiteral(expr ast.Expr) bool {
+	found := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if found {
+			return false
+		}
+		value, ok := stringLiteralValueFromNode(node)
+		if ok && (strings.Contains(value, "/") || strings.Contains(value, `\`)) {
+			found = true
+			return false
+		}
+		return true
+	})
+	return found
+}
+
+func isFilepathToSlashCall(expr ast.Expr) bool {
+	call, ok := expr.(*ast.CallExpr)
+	if !ok {
+		return false
+	}
+	selector, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "ToSlash" {
+		return false
+	}
+	pkg, ok := selector.X.(*ast.Ident)
+	return ok && pkg.Name == "filepath"
+}
+
+func hasLocalPathSignal(expr ast.Expr) bool {
+	found := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if found {
+			return false
+		}
+		switch typed := node.(type) {
+		case *ast.Ident:
+			if isLocalPathName(typed.Name) {
+				found = true
+				return false
+			}
+		case *ast.SelectorExpr:
+			if isLocalPathName(typed.Sel.Name) {
+				found = true
+				return false
+			}
+		case *ast.CallExpr:
+			if isLocalPathCall(typed) {
+				found = true
+				return false
+			}
+		}
+		return true
+	})
+	return found
+}
+
+func hasSlashDataPathSignal(expr ast.Expr) bool {
+	found := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if found {
+			return false
+		}
+		switch typed := node.(type) {
+		case *ast.Ident:
+			if isSlashDataPathName(typed.Name) {
+				found = true
+				return false
+			}
+		case *ast.SelectorExpr:
+			if isSlashDataSelector(typed) {
+				found = true
+				return false
+			}
+			if isSlashDataPathName(typed.Sel.Name) {
+				found = true
+				return false
+			}
+		}
+		return true
+	})
+	return found
+}
+
+func hasSlashDataSignal(expr ast.Expr) bool {
+	found := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if found {
+			return false
+		}
+		if value, ok := stringLiteralValueFromNode(node); ok {
+			if strings.Contains(value, "://") {
+				found = true
+				return false
+			}
+			return true
+		}
+		switch typed := node.(type) {
+		case *ast.Ident:
+			if isSlashDataName(typed.Name) {
+				found = true
+				return false
+			}
+		case *ast.SelectorExpr:
+			if isSlashDataSelector(typed) {
+				found = true
+				return false
+			}
+			if isSlashDataName(typed.Sel.Name) {
+				found = true
+				return false
+			}
+		}
+		return true
+	})
+	return found
+}
+
+func stringLiteralValueFromNode(node ast.Node) (string, bool) {
+	expr, ok := node.(ast.Expr)
+	if !ok {
+		return "", false
+	}
+	return stringLiteralValue(expr)
+}
+
+func isLocalPathCall(call *ast.CallExpr) bool {
+	selector, ok := call.Fun.(*ast.SelectorExpr)
+	if ok {
+		if selector.Sel.Name == "TempDir" {
+			return true
+		}
+		if pkg, ok := selector.X.(*ast.Ident); ok {
+			switch pkg.Name + "." + selector.Sel.Name {
+			case "os.TempDir", "os.UserHomeDir", "os.Getwd":
+				return true
+			}
+			if pkg.Name == "filepath" {
+				return true
+			}
+		}
+		return isLocalPathName(selector.Sel.Name)
+	}
+	if ident, ok := call.Fun.(*ast.Ident); ok {
+		return isLocalPathName(ident.Name)
+	}
+	return false
+}
+
+func isLocalPathName(name string) bool {
+	lower := strings.ToLower(strings.TrimSpace(name))
+	if lower == "" || isSlashDataName(lower) {
+		return false
+	}
+	if strings.Contains(lower, "filepath") || strings.Contains(lower, "dbpath") || strings.Contains(lower, "sourcepath") ||
+		strings.Contains(lower, "targetpath") ||
+		strings.Contains(lower, "outputpath") ||
+		strings.Contains(lower, "artifactpath") ||
+		strings.Contains(lower, "configpath") ||
+		strings.Contains(lower, "mediainfopath") {
+		return true
+	}
+	if strings.Contains(lower, "pathparts") || strings.Contains(lower, "fileparts") || strings.Contains(lower, "dirparts") {
+		return true
+	}
+	for _, signal := range []string{"dir", "root", "folder", "file", "tmp", "temp", "watch", "browse", "destination"} {
+		if strings.Contains(lower, signal) {
+			return true
+		}
+	}
+	return false
+}
+
+func isSlashDataPathName(name string) bool {
+	lower := strings.ToLower(strings.TrimSpace(name))
+	return strings.Contains(lower, "slashpath") ||
+		strings.Contains(lower, "torrentcontentpath") ||
+		strings.Contains(lower, "apipath") ||
+		strings.Contains(lower, "urlpath") ||
+		strings.Contains(lower, "remotepath") ||
+		strings.Contains(lower, "payloadpath") ||
+		strings.Contains(lower, "requestpath") ||
+		strings.Contains(lower, "responsepath")
+}
+
+func isSlashDataName(name string) bool {
+	lower := strings.ToLower(strings.TrimSpace(name))
+	if isSlashDataPathName(lower) {
+		return true
+	}
+	for _, signal := range []string{"url", "uri", "endpoint", "route", "href", "html", "bbcode", "desc", "description", "announce", "domain", "host", "link", "web", "raw", "img", "image", "api", "query", "request", "response", "cookie", "form"} {
+		if strings.Contains(lower, signal) {
+			return true
+		}
+	}
+	return false
+}
+
+func isSlashDataSelector(selector *ast.SelectorExpr) bool {
+	if selector.Sel.Name != "Path" && selector.Sel.Name != "RawPath" && selector.Sel.Name != "EscapedPath" {
+		return false
+	}
+	return selectorChainHasName(selector.X, "url") ||
+		selectorChainHasName(selector.X, "uri") ||
+		selectorChainHasName(selector.X, "parsed") ||
+		selectorChainHasName(selector.X, "request") ||
+		selectorChainHasName(selector.X, "response") ||
+		selectorChainHasName(selector.X, "req") ||
+		selectorChainHasName(selector.X, "resp")
+}
+
+func selectorChainHasName(expr ast.Expr, needle string) bool {
+	switch typed := expr.(type) {
+	case *ast.Ident:
+		return strings.Contains(strings.ToLower(typed.Name), needle)
+	case *ast.SelectorExpr:
+		return strings.Contains(strings.ToLower(typed.Sel.Name), needle) || selectorChainHasName(typed.X, needle)
+	default:
+		return false
+	}
+}
+
+func isAdHocPathGuardName(name string) bool {
+	switch strings.ToLower(strings.TrimSpace(name)) {
+	case "iswithinroot", "ispathwithinroot", "pathwithinroot", "pathwithin", "samepath":
+		return true
+	default:
+		return false
+	}
+}
+
+func isRootTargetPathEquality(left ast.Expr, right ast.Expr) bool {
+	leftName, leftOK := rootTargetPathName(left)
+	rightName, rightOK := rootTargetPathName(right)
+	if !leftOK || !rightOK {
+		return false
+	}
+	return isRootPathName(leftName) && isTargetPathName(rightName) ||
+		isTargetPathName(leftName) && isRootPathName(rightName)
+}
+
+func rootTargetPathName(expr ast.Expr) (string, bool) {
+	switch typed := expr.(type) {
+	case *ast.Ident:
+		return pathGuardEqualityName(typed.Name)
+	case *ast.SelectorExpr:
+		return pathGuardEqualityName(typed.Sel.Name)
+	}
+	return "", false
+}
+
+func pathGuardEqualityName(name string) (string, bool) {
+	lower := strings.ToLower(strings.TrimSpace(name))
+	if lower == "" || isSlashDataName(lower) {
+		return "", false
+	}
+	if isRootPathName(lower) || isTargetPathName(lower) || isLocalPathName(lower) {
+		return lower, true
+	}
+	return "", false
+}
+
+func isRootPathName(name string) bool {
+	return strings.Contains(name, "root")
+}
+
+func isTargetPathName(name string) bool {
+	return strings.Contains(name, "target") || strings.Contains(name, "candidate")
+}
diff --git a/internal/pathing/policy/checker_test.go b/internal/pathing/policy/checker_test.go
new file mode 100644
index 00000000..6b51d909
--- /dev/null
+++ b/internal/pathing/policy/checker_test.go
@@ -0,0 +1,339 @@
+package policy
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCheckRepositoryFlagsHardcodedRootsInFilepathCalls(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import "path/filepath"
+
+func check() {
+	_ = filepath.Join("C:\\shared", "file.mkv")
+	_ = filepath.Join("\\\\server\\share", "file.mkv")
+	_ = filepath.Clean("/tmp/file.mkv")
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 3 {
+		t.Fatalf("expected 3 violations, got %d: %#v", len(violations), violations)
+	}
+	for _, violation := range violations {
+		if !strings.Contains(violation.Message, "hardcoded OS-rooted local paths") {
+			t.Fatalf("unexpected violation message: %q", violation.Message)
+		}
+	}
+}
+
+func TestCheckRepositoryAllowsSlashFixturesOutsideFilepathCalls(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import "path/filepath"
+
+func check(base string) {
+	_ = filepath.Join(base, "file.mkv")
+	_ = "/media/file.mkv"
+	_ = "https://example.invalid/path/file.mkv"
+	_ = "C:\\fixture\\file.mkv"
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("expected no violations, got %#v", violations)
+	}
+}
+
+func TestCheckRepositoryAllowsURLPathsInFilepathCalls(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import "path/filepath"
+
+func check() {
+	_ = filepath.Join("/api", "v1")
+	_ = filepath.Join("/upload", "file")
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("expected no violations, got %#v", violations)
+	}
+}
+
+func TestCheckRepositoryFlagsLocalPathStringBuilders(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func check(t *testing.T, dbPath string, fileParts []string) {
+	_ = t.TempDir() + "/upbrr.db"
+	_ = dbPath + "\\state.db"
+	_ = fmt.Sprintf("%s/%s", dbPath, "state.db")
+	_ = strings.Join(fileParts, "/")
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 4 {
+		t.Fatalf("expected 4 violations, got %d: %#v", len(violations), violations)
+	}
+	messages := strings.Join(violationMessages(violations), "\n")
+	for _, want := range []string{"string concatenation", "fmt.Sprintf", "strings.Join"} {
+		if !strings.Contains(messages, want) {
+			t.Fatalf("expected %q violation, got %q", want, messages)
+		}
+	}
+}
+
+func TestPathSignalClassifiesTorrentPaths(t *testing.T) {
+	if isLocalPathName("torrentPath") {
+		t.Fatalf("torrentPath should not be classified as a local path signal")
+	}
+	if isLocalPathName("torrentContentPath") {
+		t.Fatalf("torrentContentPath should not be classified as a local path signal")
+	}
+	if !isSlashDataPathName("torrentContentPath") {
+		t.Fatalf("torrentContentPath should be classified as slash-delimited data")
+	}
+	if !isLocalPathName("torrentFilePath") {
+		t.Fatalf("torrentFilePath should remain classified as a local path signal")
+	}
+}
+
+func TestCheckRepositoryFlagsWrongPathPackageForPathKind(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample.go", `package sample
+
+import (
+	"net/url"
+	"path"
+	"path/filepath"
+)
+
+func check(state struct{ torrentPath string }, torrentContentPath string, torrentFilePath string, raw string) {
+	_ = path.Base(state.torrentPath)
+	_ = path.Base(torrentContentPath)
+	_ = path.Base(torrentFilePath)
+	parsed, _ := url.Parse(raw)
+	_ = filepath.Base(parsed.Path)
+	_ = filepath.Base(torrentContentPath)
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 3 {
+		t.Fatalf("expected 3 violations, got %d: %#v", len(violations), violations)
+	}
+	messages := strings.Join(violationMessages(violations), "\n")
+	if !strings.Contains(messages, "use filepath for local filesystem paths") {
+		t.Fatalf("expected path package violation, got %q", messages)
+	}
+	if !strings.Contains(messages, "slash-delimited torrent/API/URL paths") {
+		t.Fatalf("expected filepath slash-data violation, got %q", messages)
+	}
+}
+
+func TestCheckRepositoryFlagsFilesystemCallsWithSlashData(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample.go", `package sample
+
+import "os"
+
+func check(apiPath string) {
+	_, _ = os.ReadFile(apiPath)
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 1 {
+		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
+	}
+	if !strings.Contains(violations[0].Message, "filepath.FromSlash") {
+		t.Fatalf("expected FromSlash violation, got %q", violations[0].Message)
+	}
+}
+
+func TestCheckRepositoryFlagsSlashAssertionsAgainstLocalPaths(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import "strings"
+
+func check(dbPath string) bool {
+	return strings.Contains(dbPath, "/tmp/upbrr.db")
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 1 {
+		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
+	}
+	if !strings.Contains(violations[0].Message, "filepath.ToSlash") {
+		t.Fatalf("expected ToSlash violation, got %q", violations[0].Message)
+	}
+}
+
+func TestCheckRepositoryFlagsAdHocPathGuards(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample.go", `package sample
+
+func pathWithinRoot(root string, target string) bool {
+	return len(root) <= len(target)
+}
+
+func samePath(left string, right string) bool {
+	return left == right
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 2 {
+		t.Fatalf("expected 2 violations, got %d: %#v", len(violations), violations)
+	}
+	messages := strings.Join(violationMessages(violations), "\n")
+	if !strings.Contains(messages, "internal/pathing") {
+		t.Fatalf("expected pathutil violation, got %q", messages)
+	}
+}
+
+func TestCheckRepositoryFlagsLexicalRootTargetPathEquality(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample.go", `package sample
+
+func check(absRoot string, absTarget string) bool {
+	return absTarget == absRoot
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 1 {
+		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
+	}
+	if !strings.Contains(violations[0].Message, "pathutil.SamePath") {
+		t.Fatalf("expected SamePath violation, got %q", violations[0].Message)
+	}
+}
+
+func TestCheckRepositoryAllowsPathutilPathGuards(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/pathing/pathutil.go", `package pathing
+
+func IsWithinRoot(root string, target string) bool {
+	return root == target
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("expected no violations, got %#v", violations)
+	}
+}
+
+func TestCheckRepositoryAllowsIntentionalPathPolicyComments(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample_test.go", `package sample
+
+import "testing"
+
+func check(t *testing.T) string {
+	//pathpolicy:allow exercising checker fixture
+	return t.TempDir() + "/upbrr.db"
+}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 0 {
+		t.Fatalf("expected no violations, got %#v", violations)
+	}
+}
+
+func TestCheckRepositoryFlagsInvalidPathPolicyAllows(t *testing.T) {
+	root := t.TempDir()
+	writeSample(t, root, "internal/sample/sample.go", `package sample
+
+//pathpolicy:allow
+func blankReason() {}
+
+//pathpolicy:allow no longer needed
+func stale() {}
+`)
+
+	violations, err := CheckRepository(root)
+	if err != nil {
+		t.Fatalf("CheckRepository returned error: %v", err)
+	}
+	if len(violations) != 2 {
+		t.Fatalf("expected 2 violations, got %d: %#v", len(violations), violations)
+	}
+	messages := strings.Join(violationMessages(violations), "\n")
+	if !strings.Contains(messages, "requires a reason") || !strings.Contains(messages, "unused") {
+		t.Fatalf("expected invalid allow violations, got %q", messages)
+	}
+}
+
+func violationMessages(violations []Violation) []string {
+	messages := make([]string, 0, len(violations))
+	for _, violation := range violations {
+		messages = append(messages, violation.Message)
+	}
+	return messages
+}
+
+func writeSample(t *testing.T, root string, path string, content string) {
+	t.Helper()
+
+	fullPath := filepath.Join(root, filepath.FromSlash(path))
+	if err := os.MkdirAll(filepath.Dir(fullPath), 0o755); err != nil {
+		t.Fatalf("mkdir sample dir: %v", err)
+	}
+	if err := os.WriteFile(fullPath, []byte(content), 0o600); err != nil {
+		t.Fatalf("write sample file: %v", err)
+	}
+}
diff --git a/internal/pathutil/realpath.go b/internal/pathing/realpath.go
similarity index 95%
rename from internal/pathutil/realpath.go
rename to internal/pathing/realpath.go
index 4b24350d..13c3f9a4 100644
--- a/internal/pathutil/realpath.go
+++ b/internal/pathing/realpath.go
@@ -3,7 +3,7 @@
 
 //go:build !windows
 
-package pathutil
+package pathing
 
 import "path/filepath"
 
diff --git a/internal/pathutil/realpath_windows.go b/internal/pathing/realpath_windows.go
similarity index 91%
rename from internal/pathutil/realpath_windows.go
rename to internal/pathing/realpath_windows.go
index 2e79fb32..0db8ddbd 100644
--- a/internal/pathutil/realpath_windows.go
+++ b/internal/pathing/realpath_windows.go
@@ -3,7 +3,7 @@
 
 //go:build windows
 
-package pathutil
+package pathing
 
 import (
 	"path/filepath"
@@ -50,8 +50,8 @@ func resolveExistingPath(value string) (string, bool) {
 
 func trimWindowsFinalPathPrefix(value string) string {
 	trimmed := strings.TrimPrefix(value, `\\?\`)
-	if strings.HasPrefix(trimmed, `UNC\`) {
-		return `\\` + strings.TrimPrefix(trimmed, `UNC\`)
+	if after, ok := strings.CutPrefix(trimmed, `UNC\`); ok {
+		return `\\` + after
 	}
 	return trimmed
 }
diff --git a/internal/pathpolicy/checker.go b/internal/pathpolicy/checker.go
deleted file mode 100644
index b2e18d46..00000000
--- a/internal/pathpolicy/checker.go
+++ /dev/null
@@ -1,711 +0,0 @@
-package pathpolicy
-
-import (
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-var checkedFilepathCalls = map[string]struct{}{
-	"Abs":       {},
-	"Base":      {},
-	"Clean":     {},
-	"Dir":       {},
-	"Ext":       {},
-	"FromSlash": {},
-	"Glob":      {},
-	"IsAbs":     {},
-	"Join":      {},
-	"Rel":       {},
-	"ToSlash":   {},
-}
-
-var checkedPathCalls = map[string]struct{}{
-	"Base":  {},
-	"Clean": {},
-	"Dir":   {},
-	"Ext":   {},
-	"IsAbs": {},
-	"Join":  {},
-}
-
-var filesystemCalls = map[string]map[string]struct{}{
-	"os": {
-		"Create":    {},
-		"Mkdir":     {},
-		"MkdirAll":  {},
-		"Open":      {},
-		"OpenFile":  {},
-		"ReadFile":  {},
-		"Remove":    {},
-		"RemoveAll": {},
-		"Rename":    {},
-		"Stat":      {},
-		"WriteFile": {},
-	},
-}
-
-type Violation struct {
-	File    string
-	Line    int
-	Column  int
-	Message string
-}
-
-type allowComment struct {
-	line int
-	used bool
-}
-
-type checker struct {
-	fset       *token.FileSet
-	aliases    map[string]string
-	relPath    string
-	isTest     bool
-	allows     map[int]*allowComment
-	allowList  []*allowComment
-	violations []Violation
-}
-
-func CheckRepository(root string) ([]Violation, error) {
-	if _, err := os.Stat(root); err != nil {
-		return nil, fmt.Errorf("pathpolicy: stat repository root: %w", err)
-	}
-
-	violations := make([]Violation, 0)
-	fset := token.NewFileSet()
-	err := filepath.WalkDir(root, func(path string, entry os.DirEntry, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if entry.IsDir() {
-			if shouldSkipDir(entry.Name()) && path != root {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if filepath.Ext(path) != ".go" {
-			return nil
-		}
-
-		fileViolations, err := checkFile(fset, root, path)
-		if err != nil {
-			return err
-		}
-		violations = append(violations, fileViolations...)
-		return nil
-	})
-	if err != nil {
-		return nil, fmt.Errorf("pathpolicy: walk repository: %w", err)
-	}
-
-	sort.Slice(violations, func(i, j int) bool {
-		if violations[i].File != violations[j].File {
-			return violations[i].File < violations[j].File
-		}
-		if violations[i].Line != violations[j].Line {
-			return violations[i].Line < violations[j].Line
-		}
-		return violations[i].Column < violations[j].Column
-	})
-
-	return violations, nil
-}
-
-func checkFile(fset *token.FileSet, root string, path string) ([]Violation, error) {
-	file, err := parser.ParseFile(fset, path, nil, parser.ParseComments|parser.SkipObjectResolution)
-	if err != nil {
-		return nil, fmt.Errorf("parse %s: %w", path, err)
-	}
-
-	relPath, err := filepath.Rel(root, path)
-	if err != nil {
-		relPath = path
-	}
-	relPath = filepath.ToSlash(relPath)
-
-	c := &checker{
-		fset:    fset,
-		aliases: importAliases(file),
-		relPath: relPath,
-		isTest:  strings.HasSuffix(path, "_test.go"),
-		allows:  make(map[int]*allowComment),
-	}
-	c.collectAllows(file)
-
-	ast.Inspect(file, func(node ast.Node) bool {
-		switch typed := node.(type) {
-		case *ast.FuncDecl:
-			c.checkFuncDecl(typed)
-		case *ast.CallExpr:
-			c.checkCall(typed)
-		case *ast.BinaryExpr:
-			c.checkBinary(typed)
-		}
-		return true
-	})
-	c.finishAllows()
-
-	return c.violations, nil
-}
-
-func (c *checker) checkFuncDecl(fn *ast.FuncDecl) {
-	if fn.Name == nil || !isAdHocPathGuardName(fn.Name.Name) {
-		return
-	}
-	if c.relPath == "internal/pathutil/pathutil.go" {
-		return
-	}
-	c.addViolation(fn.Name.Pos(), "use internal/pathutil for local path containment/equality instead of ad hoc filepath.Rel/string checks")
-}
-
-func (c *checker) collectAllows(file *ast.File) {
-	for _, group := range file.Comments {
-		for _, comment := range group.List {
-			body := strings.TrimSpace(strings.TrimPrefix(strings.TrimPrefix(comment.Text, "//"), "/*"))
-			body = strings.TrimSuffix(body, "*/")
-			if !strings.HasPrefix(body, "pathpolicy:allow") {
-				continue
-			}
-			reason := strings.TrimSpace(strings.TrimPrefix(body, "pathpolicy:allow"))
-			if reason == "" {
-				c.violations = append(c.violations, violationAt(c.fset, c.relPath, comment.Pos(), "pathpolicy allow comment requires a reason"))
-				continue
-			}
-			line := c.fset.Position(comment.Pos()).Line
-			allow := &allowComment{line: line}
-			c.allowList = append(c.allowList, allow)
-			c.allows[line] = allow
-			c.allows[line+1] = allow
-		}
-	}
-}
-
-func (c *checker) finishAllows() {
-	for _, allow := range c.allowList {
-		if !allow.used {
-			c.violations = append(c.violations, Violation{
-				File:    c.relPath,
-				Line:    allow.line,
-				Column:  1,
-				Message: "unused pathpolicy allow comment",
-			})
-		}
-	}
-}
-
-func (c *checker) checkCall(call *ast.CallExpr) {
-	selector, ok := call.Fun.(*ast.SelectorExpr)
-	if !ok {
-		return
-	}
-
-	packageName, ok := selector.X.(*ast.Ident)
-	if !ok {
-		return
-	}
-	importPath := c.aliases[packageName.Name]
-	switch importPath {
-	case "path/filepath":
-		c.checkFilepathCall(selector.Sel.Name, call)
-	case "path":
-		c.checkPathCall(selector.Sel.Name, call)
-	case "fmt":
-		if selector.Sel.Name == "Sprintf" {
-			c.checkSprintf(call)
-		}
-	case "strings":
-		switch selector.Sel.Name {
-		case "Join":
-			c.checkStringsJoin(call)
-		case "Contains", "HasPrefix", "HasSuffix":
-			c.checkStringPathAssertion(call)
-		}
-	default:
-		if methods, ok := filesystemCalls[importPath]; ok {
-			if _, checked := methods[selector.Sel.Name]; checked {
-				c.checkFilesystemCall(call)
-			}
-		}
-	}
-}
-
-func (c *checker) checkFilepathCall(name string, call *ast.CallExpr) {
-	if _, checked := checkedFilepathCalls[name]; !checked {
-		return
-	}
-
-	for _, arg := range call.Args {
-		if value, ok := stringLiteralValue(arg); ok && isHardcodedLocalRoot(value) {
-			c.addViolation(arg.Pos(), "avoid hardcoded OS-rooted local paths in filepath calls; build local paths from t.TempDir or existing variables")
-		}
-	}
-
-	if name == "FromSlash" || name == "ToSlash" {
-		return
-	}
-	for _, arg := range call.Args {
-		if hasSlashDataPathSignal(arg) {
-			c.addViolation(arg.Pos(), "slash-delimited torrent/API/URL paths must use path APIs or filepath.FromSlash at local filesystem boundaries")
-		}
-	}
-}
-
-func (c *checker) checkPathCall(name string, call *ast.CallExpr) {
-	if _, checked := checkedPathCalls[name]; !checked {
-		return
-	}
-	for _, arg := range call.Args {
-		if hasLocalPathSignal(arg) && !hasSlashDataSignal(arg) {
-			c.addViolation(arg.Pos(), "use filepath for local filesystem paths; path is only for slash-delimited data")
-		}
-	}
-}
-
-func (c *checker) checkSprintf(call *ast.CallExpr) {
-	if len(call.Args) == 0 {
-		return
-	}
-	format, ok := stringLiteralValue(call.Args[0])
-	if !ok || !isPathBuildingFormat(format) {
-		return
-	}
-	if hasSlashDataSignal(call) {
-		return
-	}
-	for _, arg := range call.Args[1:] {
-		if hasLocalPathSignal(arg) {
-			c.addViolation(call.Pos(), "use filepath.Join instead of fmt.Sprintf to build local filesystem paths")
-			return
-		}
-	}
-}
-
-func (c *checker) checkStringsJoin(call *ast.CallExpr) {
-	if len(call.Args) != 2 {
-		return
-	}
-	separator, ok := stringLiteralValue(call.Args[1])
-	if !ok || separator != "/" && separator != `\` {
-		return
-	}
-	if hasLocalPathSignal(call.Args[0]) && !hasSlashDataSignal(call.Args[0]) {
-		c.addViolation(call.Pos(), "use filepath.Join instead of strings.Join to build local filesystem paths")
-	}
-}
-
-func (c *checker) checkStringPathAssertion(call *ast.CallExpr) {
-	if !c.isTest || len(call.Args) < 2 {
-		return
-	}
-	if isFilepathToSlashCall(call.Args[0]) {
-		return
-	}
-	value, ok := stringLiteralValue(call.Args[1])
-	if !ok || !isHardcodedLocalRoot(value) {
-		return
-	}
-	if hasLocalPathSignal(call.Args[0]) {
-		c.addViolation(call.Args[1].Pos(), "normalize local paths with filepath.ToSlash before slash-based test assertions")
-	}
-}
-
-func (c *checker) checkFilesystemCall(call *ast.CallExpr) {
-	if len(call.Args) == 0 {
-		return
-	}
-	firstArg := call.Args[0]
-	if hasSlashDataPathSignal(firstArg) {
-		c.addViolation(firstArg.Pos(), "convert slash-delimited data with filepath.FromSlash before local filesystem calls")
-	}
-}
-
-func (c *checker) checkBinary(expr *ast.BinaryExpr) {
-	//nolint:exhaustive // Path policy only cares about string concatenation.
-	switch expr.Op {
-	case token.ADD:
-		if !containsPathSeparatorLiteral(expr) {
-			return
-		}
-		if hasLocalPathSignal(expr) && !hasSlashDataSignal(expr) {
-			c.addViolation(expr.Pos(), "use filepath.Join instead of string concatenation to build local filesystem paths")
-		}
-	case token.EQL, token.NEQ:
-		if c.relPath == "internal/pathutil/pathutil.go" {
-			return
-		}
-		if isRootTargetPathEquality(expr.X, expr.Y) {
-			c.addViolation(expr.Pos(), "use pathutil.SamePath instead of lexical equality for local filesystem root/target paths")
-		}
-	default:
-		return
-	}
-}
-
-func (c *checker) addViolation(pos token.Pos, message string) {
-	line := c.fset.Position(pos).Line
-	if allow, ok := c.allows[line]; ok {
-		allow.used = true
-		return
-	}
-
-	c.violations = append(c.violations, violationAt(c.fset, c.relPath, pos, message))
-}
-
-func shouldSkipDir(name string) bool {
-	switch name {
-	case ".git", "dist", "node_modules", "vendor":
-		return true
-	default:
-		return false
-	}
-}
-
-func importAliases(file *ast.File) map[string]string {
-	aliases := make(map[string]string, len(file.Imports))
-	for _, spec := range file.Imports {
-		pathValue, err := strconv.Unquote(spec.Path.Value)
-		if err != nil {
-			continue
-		}
-		name := filepath.Base(pathValue)
-		if spec.Name != nil {
-			name = spec.Name.Name
-		}
-		aliases[name] = pathValue
-	}
-	return aliases
-}
-
-func stringLiteralValue(expr ast.Expr) (string, bool) {
-	literal, ok := expr.(*ast.BasicLit)
-	if !ok || literal.Kind != token.STRING {
-		return "", false
-	}
-	value, err := strconv.Unquote(literal.Value)
-	if err != nil {
-		return "", false
-	}
-	return value, true
-}
-
-func violationAt(fset *token.FileSet, file string, pos token.Pos, message string) Violation {
-	position := fset.Position(pos)
-	return Violation{
-		File:    file,
-		Line:    position.Line,
-		Column:  position.Column,
-		Message: message,
-	}
-}
-
-func isPathBuildingFormat(format string) bool {
-	if strings.Contains(format, "://") {
-		return false
-	}
-	return strings.Contains(format, "%s/") ||
-		strings.Contains(format, "/%s") ||
-		strings.Contains(format, `%s\`) ||
-		strings.Contains(format, `\%s`)
-}
-
-func isHardcodedLocalRoot(value string) bool {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return false
-	}
-	if strings.HasPrefix(trimmed, `\\`) || strings.HasPrefix(trimmed, `\`) {
-		return true
-	}
-	if hasWindowsDrivePrefix(trimmed) {
-		return true
-	}
-
-	slashPath := strings.ReplaceAll(trimmed, `\`, "/")
-	for _, root := range []string{"/tmp", "/home", "/media", "/custom"} {
-		//pathpolicy:allow checking slash-normalized roots
-		if slashPath == root || strings.HasPrefix(slashPath, root+"/") {
-			return true
-		}
-	}
-
-	return false
-}
-
-func hasWindowsDrivePrefix(value string) bool {
-	if len(value) < 2 || value[1] != ':' {
-		return false
-	}
-	return (value[0] >= 'A' && value[0] <= 'Z') || (value[0] >= 'a' && value[0] <= 'z')
-}
-
-func containsPathSeparatorLiteral(expr ast.Expr) bool {
-	found := false
-	ast.Inspect(expr, func(node ast.Node) bool {
-		if found {
-			return false
-		}
-		value, ok := stringLiteralValueFromNode(node)
-		if ok && (strings.Contains(value, "/") || strings.Contains(value, `\`)) {
-			found = true
-			return false
-		}
-		return true
-	})
-	return found
-}
-
-func isFilepathToSlashCall(expr ast.Expr) bool {
-	call, ok := expr.(*ast.CallExpr)
-	if !ok {
-		return false
-	}
-	selector, ok := call.Fun.(*ast.SelectorExpr)
-	if !ok || selector.Sel.Name != "ToSlash" {
-		return false
-	}
-	pkg, ok := selector.X.(*ast.Ident)
-	return ok && pkg.Name == "filepath"
-}
-
-func hasLocalPathSignal(expr ast.Expr) bool {
-	found := false
-	ast.Inspect(expr, func(node ast.Node) bool {
-		if found {
-			return false
-		}
-		switch typed := node.(type) {
-		case *ast.Ident:
-			if isLocalPathName(typed.Name) {
-				found = true
-				return false
-			}
-		case *ast.SelectorExpr:
-			if isLocalPathName(typed.Sel.Name) {
-				found = true
-				return false
-			}
-		case *ast.CallExpr:
-			if isLocalPathCall(typed) {
-				found = true
-				return false
-			}
-		}
-		return true
-	})
-	return found
-}
-
-func hasSlashDataPathSignal(expr ast.Expr) bool {
-	found := false
-	ast.Inspect(expr, func(node ast.Node) bool {
-		if found {
-			return false
-		}
-		switch typed := node.(type) {
-		case *ast.Ident:
-			if isSlashDataPathName(typed.Name) {
-				found = true
-				return false
-			}
-		case *ast.SelectorExpr:
-			if isSlashDataSelector(typed) {
-				found = true
-				return false
-			}
-			if isSlashDataPathName(typed.Sel.Name) {
-				found = true
-				return false
-			}
-		}
-		return true
-	})
-	return found
-}
-
-func hasSlashDataSignal(expr ast.Expr) bool {
-	found := false
-	ast.Inspect(expr, func(node ast.Node) bool {
-		if found {
-			return false
-		}
-		if value, ok := stringLiteralValueFromNode(node); ok {
-			if strings.Contains(value, "://") {
-				found = true
-				return false
-			}
-			return true
-		}
-		switch typed := node.(type) {
-		case *ast.Ident:
-			if isSlashDataName(typed.Name) {
-				found = true
-				return false
-			}
-		case *ast.SelectorExpr:
-			if isSlashDataSelector(typed) {
-				found = true
-				return false
-			}
-			if isSlashDataName(typed.Sel.Name) {
-				found = true
-				return false
-			}
-		}
-		return true
-	})
-	return found
-}
-
-func stringLiteralValueFromNode(node ast.Node) (string, bool) {
-	expr, ok := node.(ast.Expr)
-	if !ok {
-		return "", false
-	}
-	return stringLiteralValue(expr)
-}
-
-func isLocalPathCall(call *ast.CallExpr) bool {
-	selector, ok := call.Fun.(*ast.SelectorExpr)
-	if ok {
-		if selector.Sel.Name == "TempDir" {
-			return true
-		}
-		if pkg, ok := selector.X.(*ast.Ident); ok {
-			switch pkg.Name + "." + selector.Sel.Name {
-			case "os.TempDir", "os.UserHomeDir", "os.Getwd":
-				return true
-			}
-			if pkg.Name == "filepath" {
-				return true
-			}
-		}
-		return isLocalPathName(selector.Sel.Name)
-	}
-	if ident, ok := call.Fun.(*ast.Ident); ok {
-		return isLocalPathName(ident.Name)
-	}
-	return false
-}
-
-func isLocalPathName(name string) bool {
-	lower := strings.ToLower(strings.TrimSpace(name))
-	if lower == "" || isSlashDataName(lower) {
-		return false
-	}
-	if strings.Contains(lower, "filepath") || strings.Contains(lower, "dbpath") || strings.Contains(lower, "sourcepath") || strings.Contains(lower, "targetpath") || strings.Contains(lower, "outputpath") || strings.Contains(lower, "artifactpath") || strings.Contains(lower, "configpath") || strings.Contains(lower, "mediainfopath") {
-		return true
-	}
-	if strings.Contains(lower, "pathparts") || strings.Contains(lower, "fileparts") || strings.Contains(lower, "dirparts") {
-		return true
-	}
-	for _, signal := range []string{"dir", "root", "folder", "file", "tmp", "temp", "watch", "browse", "destination"} {
-		if strings.Contains(lower, signal) {
-			return true
-		}
-	}
-	return false
-}
-
-func isSlashDataPathName(name string) bool {
-	lower := strings.ToLower(strings.TrimSpace(name))
-	return strings.Contains(lower, "slashpath") ||
-		strings.Contains(lower, "torrentcontentpath") ||
-		strings.Contains(lower, "apipath") ||
-		strings.Contains(lower, "urlpath") ||
-		strings.Contains(lower, "remotepath") ||
-		strings.Contains(lower, "payloadpath") ||
-		strings.Contains(lower, "requestpath") ||
-		strings.Contains(lower, "responsepath")
-}
-
-func isSlashDataName(name string) bool {
-	lower := strings.ToLower(strings.TrimSpace(name))
-	if isSlashDataPathName(lower) {
-		return true
-	}
-	for _, signal := range []string{"url", "uri", "endpoint", "route", "href", "html", "bbcode", "desc", "description", "announce", "domain", "host", "link", "web", "raw", "img", "image", "api", "query", "request", "response", "cookie", "form"} {
-		if strings.Contains(lower, signal) {
-			return true
-		}
-	}
-	return false
-}
-
-func isSlashDataSelector(selector *ast.SelectorExpr) bool {
-	if selector.Sel.Name != "Path" && selector.Sel.Name != "RawPath" && selector.Sel.Name != "EscapedPath" {
-		return false
-	}
-	return selectorChainHasName(selector.X, "url") ||
-		selectorChainHasName(selector.X, "uri") ||
-		selectorChainHasName(selector.X, "parsed") ||
-		selectorChainHasName(selector.X, "request") ||
-		selectorChainHasName(selector.X, "response") ||
-		selectorChainHasName(selector.X, "req") ||
-		selectorChainHasName(selector.X, "resp")
-}
-
-func selectorChainHasName(expr ast.Expr, needle string) bool {
-	switch typed := expr.(type) {
-	case *ast.Ident:
-		return strings.Contains(strings.ToLower(typed.Name), needle)
-	case *ast.SelectorExpr:
-		return strings.Contains(strings.ToLower(typed.Sel.Name), needle) || selectorChainHasName(typed.X, needle)
-	default:
-		return false
-	}
-}
-
-func isAdHocPathGuardName(name string) bool {
-	switch strings.ToLower(strings.TrimSpace(name)) {
-	case "iswithinroot", "ispathwithinroot", "pathwithinroot", "pathwithin", "samepath":
-		return true
-	default:
-		return false
-	}
-}
-
-func isRootTargetPathEquality(left ast.Expr, right ast.Expr) bool {
-	leftName, leftOK := rootTargetPathName(left)
-	rightName, rightOK := rootTargetPathName(right)
-	if !leftOK || !rightOK {
-		return false
-	}
-	return isRootPathName(leftName) && isTargetPathName(rightName) ||
-		isTargetPathName(leftName) && isRootPathName(rightName)
-}
-
-func rootTargetPathName(expr ast.Expr) (string, bool) {
-	switch typed := expr.(type) {
-	case *ast.Ident:
-		return pathGuardEqualityName(typed.Name)
-	case *ast.SelectorExpr:
-		return pathGuardEqualityName(typed.Sel.Name)
-	}
-	return "", false
-}
-
-func pathGuardEqualityName(name string) (string, bool) {
-	lower := strings.ToLower(strings.TrimSpace(name))
-	if lower == "" || isSlashDataName(lower) {
-		return "", false
-	}
-	if isRootPathName(lower) || isTargetPathName(lower) || isLocalPathName(lower) {
-		return lower, true
-	}
-	return "", false
-}
-
-func isRootPathName(name string) bool {
-	return strings.Contains(name, "root")
-}
-
-func isTargetPathName(name string) bool {
-	return strings.Contains(name, "target") || strings.Contains(name, "candidate")
-}
diff --git a/internal/pathpolicy/checker_test.go b/internal/pathpolicy/checker_test.go
deleted file mode 100644
index 59326882..00000000
--- a/internal/pathpolicy/checker_test.go
+++ /dev/null
@@ -1,339 +0,0 @@
-package pathpolicy
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestCheckRepositoryFlagsHardcodedRootsInFilepathCalls(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import "path/filepath"
-
-func check() {
-	_ = filepath.Join("C:\\shared", "file.mkv")
-	_ = filepath.Join("\\\\server\\share", "file.mkv")
-	_ = filepath.Clean("/tmp/file.mkv")
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 3 {
-		t.Fatalf("expected 3 violations, got %d: %#v", len(violations), violations)
-	}
-	for _, violation := range violations {
-		if !strings.Contains(violation.Message, "hardcoded OS-rooted local paths") {
-			t.Fatalf("unexpected violation message: %q", violation.Message)
-		}
-	}
-}
-
-func TestCheckRepositoryAllowsSlashFixturesOutsideFilepathCalls(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import "path/filepath"
-
-func check(base string) {
-	_ = filepath.Join(base, "file.mkv")
-	_ = "/media/file.mkv"
-	_ = "https://example.invalid/path/file.mkv"
-	_ = "C:\\fixture\\file.mkv"
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 0 {
-		t.Fatalf("expected no violations, got %#v", violations)
-	}
-}
-
-func TestCheckRepositoryAllowsURLPathsInFilepathCalls(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import "path/filepath"
-
-func check() {
-	_ = filepath.Join("/api", "v1")
-	_ = filepath.Join("/upload", "file")
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 0 {
-		t.Fatalf("expected no violations, got %#v", violations)
-	}
-}
-
-func TestCheckRepositoryFlagsLocalPathStringBuilders(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func check(t *testing.T, dbPath string, fileParts []string) {
-	_ = t.TempDir() + "/upbrr.db"
-	_ = dbPath + "\\state.db"
-	_ = fmt.Sprintf("%s/%s", dbPath, "state.db")
-	_ = strings.Join(fileParts, "/")
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 4 {
-		t.Fatalf("expected 4 violations, got %d: %#v", len(violations), violations)
-	}
-	messages := strings.Join(violationMessages(violations), "\n")
-	for _, want := range []string{"string concatenation", "fmt.Sprintf", "strings.Join"} {
-		if !strings.Contains(messages, want) {
-			t.Fatalf("expected %q violation, got %q", want, messages)
-		}
-	}
-}
-
-func TestPathSignalClassifiesTorrentPaths(t *testing.T) {
-	if isLocalPathName("torrentPath") {
-		t.Fatalf("torrentPath should not be classified as a local path signal")
-	}
-	if isLocalPathName("torrentContentPath") {
-		t.Fatalf("torrentContentPath should not be classified as a local path signal")
-	}
-	if !isSlashDataPathName("torrentContentPath") {
-		t.Fatalf("torrentContentPath should be classified as slash-delimited data")
-	}
-	if !isLocalPathName("torrentFilePath") {
-		t.Fatalf("torrentFilePath should remain classified as a local path signal")
-	}
-}
-
-func TestCheckRepositoryFlagsWrongPathPackageForPathKind(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample.go", `package sample
-
-import (
-	"net/url"
-	"path"
-	"path/filepath"
-)
-
-func check(state struct{ torrentPath string }, torrentContentPath string, torrentFilePath string, raw string) {
-	_ = path.Base(state.torrentPath)
-	_ = path.Base(torrentContentPath)
-	_ = path.Base(torrentFilePath)
-	parsed, _ := url.Parse(raw)
-	_ = filepath.Base(parsed.Path)
-	_ = filepath.Base(torrentContentPath)
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 3 {
-		t.Fatalf("expected 3 violations, got %d: %#v", len(violations), violations)
-	}
-	messages := strings.Join(violationMessages(violations), "\n")
-	if !strings.Contains(messages, "use filepath for local filesystem paths") {
-		t.Fatalf("expected path package violation, got %q", messages)
-	}
-	if !strings.Contains(messages, "slash-delimited torrent/API/URL paths") {
-		t.Fatalf("expected filepath slash-data violation, got %q", messages)
-	}
-}
-
-func TestCheckRepositoryFlagsFilesystemCallsWithSlashData(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample.go", `package sample
-
-import "os"
-
-func check(apiPath string) {
-	_, _ = os.ReadFile(apiPath)
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 1 {
-		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
-	}
-	if !strings.Contains(violations[0].Message, "filepath.FromSlash") {
-		t.Fatalf("expected FromSlash violation, got %q", violations[0].Message)
-	}
-}
-
-func TestCheckRepositoryFlagsSlashAssertionsAgainstLocalPaths(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import "strings"
-
-func check(dbPath string) bool {
-	return strings.Contains(dbPath, "/tmp/upbrr.db")
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 1 {
-		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
-	}
-	if !strings.Contains(violations[0].Message, "filepath.ToSlash") {
-		t.Fatalf("expected ToSlash violation, got %q", violations[0].Message)
-	}
-}
-
-func TestCheckRepositoryFlagsAdHocPathGuards(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample.go", `package sample
-
-func pathWithinRoot(root string, target string) bool {
-	return len(root) <= len(target)
-}
-
-func samePath(left string, right string) bool {
-	return left == right
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 2 {
-		t.Fatalf("expected 2 violations, got %d: %#v", len(violations), violations)
-	}
-	messages := strings.Join(violationMessages(violations), "\n")
-	if !strings.Contains(messages, "internal/pathutil") {
-		t.Fatalf("expected pathutil violation, got %q", messages)
-	}
-}
-
-func TestCheckRepositoryFlagsLexicalRootTargetPathEquality(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample.go", `package sample
-
-func check(absRoot string, absTarget string) bool {
-	return absTarget == absRoot
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 1 {
-		t.Fatalf("expected 1 violation, got %d: %#v", len(violations), violations)
-	}
-	if !strings.Contains(violations[0].Message, "pathutil.SamePath") {
-		t.Fatalf("expected SamePath violation, got %q", violations[0].Message)
-	}
-}
-
-func TestCheckRepositoryAllowsPathutilPathGuards(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/pathutil/pathutil.go", `package pathutil
-
-func IsWithinRoot(root string, target string) bool {
-	return root == target
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 0 {
-		t.Fatalf("expected no violations, got %#v", violations)
-	}
-}
-
-func TestCheckRepositoryAllowsIntentionalPathPolicyComments(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample_test.go", `package sample
-
-import "testing"
-
-func check(t *testing.T) string {
-	//pathpolicy:allow exercising checker fixture
-	return t.TempDir() + "/upbrr.db"
-}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 0 {
-		t.Fatalf("expected no violations, got %#v", violations)
-	}
-}
-
-func TestCheckRepositoryFlagsInvalidPathPolicyAllows(t *testing.T) {
-	root := t.TempDir()
-	writeSample(t, root, "internal/sample/sample.go", `package sample
-
-//pathpolicy:allow
-func blankReason() {}
-
-//pathpolicy:allow no longer needed
-func stale() {}
-`)
-
-	violations, err := CheckRepository(root)
-	if err != nil {
-		t.Fatalf("CheckRepository returned error: %v", err)
-	}
-	if len(violations) != 2 {
-		t.Fatalf("expected 2 violations, got %d: %#v", len(violations), violations)
-	}
-	messages := strings.Join(violationMessages(violations), "\n")
-	if !strings.Contains(messages, "requires a reason") || !strings.Contains(messages, "unused") {
-		t.Fatalf("expected invalid allow violations, got %q", messages)
-	}
-}
-
-func violationMessages(violations []Violation) []string {
-	messages := make([]string, 0, len(violations))
-	for _, violation := range violations {
-		messages = append(messages, violation.Message)
-	}
-	return messages
-}
-
-func writeSample(t *testing.T, root string, path string, content string) {
-	t.Helper()
-
-	fullPath := filepath.Join(root, filepath.FromSlash(path))
-	if err := os.MkdirAll(filepath.Dir(fullPath), 0o755); err != nil {
-		t.Fatalf("mkdir sample dir: %v", err)
-	}
-	if err := os.WriteFile(fullPath, []byte(content), 0o600); err != nil {
-		t.Fatalf("write sample file: %v", err)
-	}
-}
diff --git a/internal/paths/bdinfo.go b/internal/paths/bdinfo.go
deleted file mode 100644
index 3b9c9b22..00000000
--- a/internal/paths/bdinfo.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package paths
-
-import (
-	"errors"
-	"path/filepath"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/metadata/discparse"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func BDMVPlaylistKey(playlist string) string {
-	return discparse.NormalizePlaylistName(playlist)
-}
-
-func BDMVSummaryFilename(playlist string) string {
-	key := BDMVPlaylistKey(playlist)
-	if key == "" {
-		return ""
-	}
-	return "BD_SUMMARY_" + key + ".txt"
-}
-
-func BDMVExtSummaryFilename(playlist string) string {
-	key := BDMVPlaylistKey(playlist)
-	if key == "" {
-		return ""
-	}
-	return "BD_SUMMARY_EXT_" + key + ".txt"
-}
-
-func BDMVFullSummaryFilename(playlist string) string {
-	key := BDMVPlaylistKey(playlist)
-	if key == "" {
-		return ""
-	}
-	return "BD_SUMMARY_FULL_" + key + ".txt"
-}
-
-func BDMVSummaryPath(tmpDir string, playlist string) string {
-	filename := BDMVSummaryFilename(playlist)
-	if filename == "" {
-		return ""
-	}
-	return filepath.Join(strings.TrimSpace(tmpDir), filename)
-}
-
-func BDMVExtSummaryPath(tmpDir string, playlist string) string {
-	filename := BDMVExtSummaryFilename(playlist)
-	if filename == "" {
-		return ""
-	}
-	return filepath.Join(strings.TrimSpace(tmpDir), filename)
-}
-
-func BDMVFullSummaryPath(tmpDir string, playlist string) string {
-	filename := BDMVFullSummaryFilename(playlist)
-	if filename == "" {
-		return ""
-	}
-	return filepath.Join(strings.TrimSpace(tmpDir), filename)
-}
-
-func PrimaryBDMVPlaylist(meta api.PreparedMetadata) string {
-	if len(meta.SelectedBDMVPlaylists) == 0 {
-		return ""
-	}
-	return BDMVPlaylistKey(meta.SelectedBDMVPlaylists[0].File)
-}
-
-func PrimaryBDMVSummaryPath(tmpRoot string, meta api.PreparedMetadata) (string, error) {
-	playlist := PrimaryBDMVPlaylist(meta)
-	if playlist == "" {
-		return "", nil
-	}
-	tmpDir, _, err := ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", err
-	}
-	path := BDMVSummaryPath(tmpDir, playlist)
-	if strings.TrimSpace(path) == "" {
-		return "", errors.New("paths: missing primary bdmv playlist summary path")
-	}
-	return path, nil
-}
-
-func PrimaryBDMVExtSummaryPath(tmpRoot string, meta api.PreparedMetadata) (string, error) {
-	playlist := PrimaryBDMVPlaylist(meta)
-	if playlist == "" {
-		return "", nil
-	}
-	tmpDir, _, err := ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", err
-	}
-	path := BDMVExtSummaryPath(tmpDir, playlist)
-	if strings.TrimSpace(path) == "" {
-		return "", errors.New("paths: missing primary bdmv ext summary path")
-	}
-	return path, nil
-}
-
-func PrimaryBDMVFullSummaryPath(tmpRoot string, meta api.PreparedMetadata) (string, error) {
-	playlist := PrimaryBDMVPlaylist(meta)
-	if playlist == "" {
-		return "", nil
-	}
-	tmpDir, _, err := ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", err
-	}
-	path := BDMVFullSummaryPath(tmpDir, playlist)
-	if strings.TrimSpace(path) == "" {
-		return "", errors.New("paths: missing primary bdmv full summary path")
-	}
-	return path, nil
-}
diff --git a/internal/paths/release_tmp.go b/internal/paths/release_tmp.go
deleted file mode 100644
index 0f3cdac2..00000000
--- a/internal/paths/release_tmp.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package paths
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func ReleaseTempDir(tmpRoot string, meta api.PreparedMetadata, source string) (string, string, error) {
-	trimmed := strings.TrimSpace(tmpRoot)
-	if trimmed == "" {
-		return "", "", errors.New("paths: tmp root is required")
-	}
-	base := ReleaseTempBase(meta, source)
-	contentDir := filepath.Join(trimmed, base)
-	if err := os.MkdirAll(contentDir, 0o700); err != nil {
-		return "", "", fmt.Errorf("paths: create tmp dir: %w", err)
-	}
-	return contentDir, base, nil
-}
-
-func ReleaseTempBase(meta api.PreparedMetadata, source string) string {
-	base := pathutil.Base(source)
-	if base != "" && base != string(filepath.Separator) && base != "." {
-		return sanitizeName(base)
-	}
-	if name := releaseBaseName(meta.Release); name != "" {
-		return sanitizeName(name)
-	}
-	return "content"
-}
-
-func releaseBaseName(release api.ReleaseInfo) string {
-	title := strings.TrimSpace(release.Title)
-	if title == "" {
-		title = strings.TrimSpace(release.Alt)
-	}
-	if title == "" {
-		return ""
-	}
-	parts := []string{title}
-	if release.Year > 0 {
-		parts = append(parts, strconv.Itoa(release.Year))
-	}
-	trimmedSource := strings.TrimSpace(release.Source)
-	if trimmedSource != "" {
-		parts = append(parts, trimmedSource)
-	}
-	if trimmedType := strings.TrimSpace(release.Type); trimmedType != "" {
-		if !strings.EqualFold(trimmedType, trimmedSource) {
-			parts = append(parts, trimmedType)
-		}
-	}
-	name := strings.Join(parts, ".")
-	if strings.TrimSpace(release.Group) != "" {
-		name = name + "-" + strings.TrimSpace(release.Group)
-	}
-	return name
-}
-
-func sanitizeName(base string) string {
-	sanitized := strings.Map(func(r rune) rune {
-		switch {
-		case r >= 'a' && r <= 'z':
-			return r
-		case r >= 'A' && r <= 'Z':
-			return r
-		case r >= '0' && r <= '9':
-			return r
-		case r == '-' || r == '_' || r == '.':
-			return r
-		default:
-			return '_'
-		}
-	}, base)
-	if strings.TrimSpace(sanitized) == "" {
-		return "content"
-	}
-	return sanitized
-}
diff --git a/internal/paths/release_tmp_test.go b/internal/paths/release_tmp_test.go
deleted file mode 100644
index e44b2cec..00000000
--- a/internal/paths/release_tmp_test.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package paths
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestReleaseTempBaseUsesSourceBasename(t *testing.T) {
-	release := api.ReleaseInfo{
-		Title:  "Movie.Title",
-		Year:   2024,
-		Source: "BluRay",
-		Type:   "Remux",
-		Group:  "GRP",
-	}
-	base := ReleaseTempBase(api.PreparedMetadata{Release: release}, "C:/Media/Movie.Title.mkv")
-	if base != "Movie.Title.mkv" {
-		t.Fatalf("unexpected base name: %s", base)
-	}
-}
-
-func TestReleaseTempBaseFallsBackToReleaseInfoWhenSourceMissing(t *testing.T) {
-	release := api.ReleaseInfo{
-		Title:  "Movie.Title",
-		Year:   2024,
-		Source: "BluRay",
-		Type:   "Remux",
-		Group:  "GRP",
-	}
-	base := ReleaseTempBase(api.PreparedMetadata{Release: release}, "")
-	if base != "Movie.Title.2024.BluRay.Remux-GRP" {
-		t.Fatalf("unexpected base name: %s", base)
-	}
-}
-
-func TestReleaseTempBaseSkipsDuplicateTypeAndSource(t *testing.T) {
-	release := api.ReleaseInfo{
-		Title:  "Movie.Title",
-		Year:   2024,
-		Source: "WEB-DL",
-		Type:   "WEB-DL",
-		Group:  "GRP",
-	}
-	base := ReleaseTempBase(api.PreparedMetadata{Release: release}, "")
-	if base != "Movie.Title.2024.WEB-DL-GRP" {
-		t.Fatalf("unexpected base name: %s", base)
-	}
-}
-
-func TestReleaseTempBaseUsesFolderNameForDirectorySource(t *testing.T) {
-	base := ReleaseTempBase(api.PreparedMetadata{}, "C:/Media/Movie.Title.2024")
-	if base != "Movie.Title.2024" {
-		t.Fatalf("unexpected base name: %s", base)
-	}
-}
-
-func TestReleaseTempBaseKeepsFileExtension(t *testing.T) {
-	base := ReleaseTempBase(api.PreparedMetadata{}, "C:/Media/Movie.Title.mkv")
-	if base != "Movie.Title.mkv" {
-		t.Fatalf("unexpected base name: %s", base)
-	}
-}
-
-func TestReleaseTempDirCreatesDirectory(t *testing.T) {
-	tmpRoot := t.TempDir()
-	dir, base, err := ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, filepath.Join(tmpRoot, "Movie.Title.mkv"))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if base == "" {
-		t.Fatalf("expected base name")
-	}
-	if dir == "" {
-		t.Fatalf("expected directory path")
-	}
-}
diff --git a/internal/preparedrelease/display.go b/internal/preparedrelease/display.go
new file mode 100644
index 00000000..ee825174
--- /dev/null
+++ b/internal/preparedrelease/display.go
@@ -0,0 +1,229 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ResolveDisplay validates and projects one exact prepared generation into its
+// canonical provider presentation.
+func (m *Module) ResolveDisplay(ctx context.Context, ref api.ReleaseRef) (api.PreparedReleaseDisplay, error) {
+	owned, err := m.resolveEnvelope(ctx, ref)
+	if err != nil {
+		return api.PreparedReleaseDisplay{}, err
+	}
+	return projectPreparedReleaseDisplay(owned.result.Release)
+}
+
+func projectPreparedReleaseDisplay(release api.PreparedRelease) (api.PreparedReleaseDisplay, error) {
+	if reason := providerIdentityMismatch(release); reason != "" {
+		return api.PreparedReleaseDisplay{}, &IncompatiblePreparationError{SourcePath: release.Source.SourcePath, Reason: reason}
+	}
+	detached, err := release.Clone()
+	if err != nil {
+		return api.PreparedReleaseDisplay{}, fmt.Errorf("prepared release: clone display source: %w", err)
+	}
+	release = detached
+	display := api.PreparedReleaseDisplay{ReleaseName: release.Naming.ReleaseName}
+	identity := release.Identity
+	metadata := release.ProviderMetadata
+	if value := metadata.TMDB; value != nil {
+		summary := api.ProviderDisplaySummary{
+			Title:            firstNonEmpty(value.Title, release.Naming.ReleaseName),
+			OriginalTitle:    value.OriginalTitle,
+			Year:             value.Year,
+			Overview:         value.Overview,
+			PosterURL:        value.Poster,
+			BackdropURL:      value.Backdrop,
+			Category:         firstNonEmpty(value.Category, displayIdentityCategory(identity), value.TMDBType),
+			Date:             firstNonEmpty(value.ReleaseDate, value.FirstAirDate),
+			EndDate:          value.LastAirDate,
+			OriginalLanguage: value.OriginalLanguage,
+			MediaType:        value.TMDBType,
+			RuntimeMinutes:   value.Runtime,
+			Genres:           value.Genres,
+			Keywords:         value.Keywords,
+			TrailerURL:       value.YouTube,
+			Country:          strings.Join(value.OriginCountry, ", "),
+		}
+		display.Providers = append(display.Providers, providerDisplay(
+			api.IdentityProviderTMDB,
+			identity.TMDBID,
+			identity.Provenance.TMDB,
+			tmdbDisplayURL(identity.TMDBID, summary.Category),
+			summary,
+			api.ProviderDisplayDetails{TMDB: value},
+		))
+	}
+	if value := metadata.IMDB; value != nil {
+		summary := api.ProviderDisplaySummary{
+			Title:            firstNonEmpty(value.Title, release.Naming.ReleaseName),
+			Year:             value.Year,
+			Overview:         value.Plot,
+			PosterURL:        value.Cover,
+			Category:         firstNonEmpty(displayIdentityCategory(identity), value.Type),
+			OriginalLanguage: value.OriginalLanguage,
+			MediaType:        value.Type,
+			RuntimeMinutes:   value.RuntimeMinutes,
+			Genres:           value.Genres,
+			Rating:           value.Rating,
+			RatingCount:      value.RatingCount,
+			Country:          value.Country,
+		}
+		display.Providers = append(display.Providers, providerDisplay(
+			api.IdentityProviderIMDB,
+			identity.IMDBID,
+			identity.Provenance.IMDB,
+			fmt.Sprintf("https://www.imdb.com/title/tt%07d", identity.IMDBID),
+			summary,
+			api.ProviderDisplayDetails{IMDB: value},
+		))
+	}
+	if value := metadata.TVDB; value != nil {
+		summary := api.ProviderDisplaySummary{
+			Title:            firstNonEmpty(value.Name, release.Naming.ReleaseName),
+			Year:             value.Year,
+			Overview:         value.Overview,
+			PosterURL:        value.Poster,
+			Category:         firstNonEmpty(displayIdentityCategory(identity), value.Type),
+			Date:             value.FirstAired,
+			OriginalLanguage: value.OriginalLanguage,
+			MediaType:        value.Type,
+			Genres:           value.Genres,
+			Country:          value.OriginalCountry,
+		}
+		display.Providers = append(display.Providers, providerDisplay(
+			api.IdentityProviderTVDB,
+			identity.TVDBID,
+			identity.Provenance.TVDB,
+			fmt.Sprintf("https://www.thetvdb.com/?id=%d&tab=series", identity.TVDBID),
+			summary,
+			api.ProviderDisplayDetails{TVDB: value},
+		))
+	}
+	if value := metadata.TVmaze; value != nil {
+		runtimeMinutes := value.Runtime
+		if runtimeMinutes == 0 {
+			runtimeMinutes = value.AverageRuntime
+		}
+		summary := api.ProviderDisplaySummary{
+			Title:            firstNonEmpty(value.Name, release.Naming.ReleaseName),
+			Overview:         value.Summary,
+			PosterURL:        value.Poster,
+			BackdropURL:      value.Backdrop,
+			Category:         firstNonEmpty(displayIdentityCategory(identity), value.Type),
+			Date:             value.Premiered,
+			EndDate:          value.Ended,
+			OriginalLanguage: value.Language,
+			MediaType:        value.Type,
+			RuntimeMinutes:   runtimeMinutes,
+			Genres:           value.Genres,
+			Rating:           value.Rating,
+			RatingCount:      value.Weight,
+			Country:          value.Country,
+		}
+		display.Providers = append(display.Providers, providerDisplay(
+			api.IdentityProviderTVmaze,
+			identity.TVmazeID,
+			identity.Provenance.TVmaze,
+			fmt.Sprintf("https://www.tvmaze.com/shows/%d", identity.TVmazeID),
+			summary,
+			api.ProviderDisplayDetails{TVmaze: value},
+		))
+	}
+	if value := metadata.AniList; value != nil {
+		summary := api.ProviderDisplaySummary{
+			Title:            firstNonEmpty(value.TitleEnglish, value.TitleRomaji, release.Naming.ReleaseName),
+			OriginalTitle:    value.TitleRomaji,
+			Year:             value.SeasonYear,
+			Overview:         value.Description,
+			PosterURL:        firstNonEmpty(value.CoverExtraLarge, value.CoverLarge, value.CoverMedium),
+			BackdropURL:      value.BannerImage,
+			Category:         firstNonEmpty(value.Format, displayIdentityCategory(identity)),
+			Date:             value.StartDate,
+			EndDate:          value.EndDate,
+			OriginalLanguage: strings.ToLower(value.CountryOfOrigin),
+			MediaType:        value.Format,
+			RuntimeMinutes:   value.Duration,
+			Genres:           strings.Join(value.Genres, ", "),
+			Rating:           float64(value.AverageScore) / 10,
+			RatingCount:      value.Popularity,
+		}
+		display.Providers = append(display.Providers, providerDisplay(
+			api.IdentityProviderMAL,
+			identity.MALID,
+			identity.Provenance.MAL,
+			fmt.Sprintf("https://myanimelist.net/anime/%d", identity.MALID),
+			summary,
+			api.ProviderDisplayDetails{AniList: value},
+		))
+	}
+	return display, nil
+}
+
+func providerDisplay(
+	provider api.IdentityProvider,
+	id int,
+	provenance api.IdentityProvenance,
+	url string,
+	summary api.ProviderDisplaySummary,
+	details api.ProviderDisplayDetails,
+) api.ProviderDisplay {
+	displayID := strconv.Itoa(id)
+	if provider == api.IdentityProviderIMDB {
+		displayID = fmt.Sprintf("tt%07d", id)
+	}
+	return api.ProviderDisplay{
+		Provider:         provider,
+		ID:               id,
+		DisplayID:        displayID,
+		URL:              url,
+		Provenance:       provenance,
+		SummaryAvailable: providerSummaryAvailable(summary),
+		Summary:          summary,
+		Details:          details,
+	}
+}
+
+func providerSummaryAvailable(summary api.ProviderDisplaySummary) bool {
+	return strings.TrimSpace(summary.Title) != "" ||
+		strings.TrimSpace(summary.OriginalTitle) != "" ||
+		summary.Year != 0 ||
+		strings.TrimSpace(summary.Overview) != "" ||
+		strings.TrimSpace(summary.PosterURL) != "" ||
+		strings.TrimSpace(summary.BackdropURL) != "" ||
+		strings.TrimSpace(summary.Category) != "" ||
+		strings.TrimSpace(summary.Date) != "" ||
+		strings.TrimSpace(summary.EndDate) != "" ||
+		strings.TrimSpace(summary.OriginalLanguage) != "" ||
+		strings.TrimSpace(summary.MediaType) != "" ||
+		summary.RuntimeMinutes != 0 ||
+		strings.TrimSpace(summary.Genres) != "" ||
+		strings.TrimSpace(summary.Keywords) != "" ||
+		strings.TrimSpace(summary.TrailerURL) != "" ||
+		summary.Rating != 0 ||
+		summary.RatingCount != 0 ||
+		strings.TrimSpace(summary.Country) != ""
+}
+
+func displayIdentityCategory(identity api.ExternalIdentity) string {
+	if identity.Category == api.CanonicalCategoryUnknown {
+		return ""
+	}
+	return string(identity.Category)
+}
+
+func tmdbDisplayURL(id int, category string) string {
+	kind := "movie"
+	if strings.EqualFold(strings.TrimSpace(category), "tv") {
+		kind = "tv"
+	}
+	return fmt.Sprintf("https://www.themoviedb.org/%s/%d", kind, id)
+}
diff --git a/internal/preparedrelease/display_test.go b/internal/preparedrelease/display_test.go
new file mode 100644
index 00000000..d11a21db
--- /dev/null
+++ b/internal/preparedrelease/display_test.go
@@ -0,0 +1,249 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestProjectPreparedReleaseDisplayCanonicalFixture(t *testing.T) {
+	t.Parallel()
+
+	data, err := os.ReadFile(filepath.Join("..", "..", "pkg", "api", "testdata", "prepared_release_display.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var expected api.PreparedReleaseDisplay
+	if err := json.Unmarshal(data, &expected); err != nil {
+		t.Fatal(err)
+	}
+
+	release := canonicalDisplayFixtureRelease()
+	actual, err := projectPreparedReleaseDisplay(release)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		expectedJSON, err := json.MarshalIndent(expected, "", "  ")
+		if err != nil {
+			t.Fatalf("marshal expected display: %v", err)
+		}
+		actualJSON, err := json.MarshalIndent(actual, "", "  ")
+		if err != nil {
+			t.Fatalf("marshal actual display: %v", err)
+		}
+		t.Fatalf("display mismatch\nexpected: %s\nactual: %s", expectedJSON, actualJSON)
+	}
+
+	if actual.Providers[0].Details.TMDB == release.ProviderMetadata.TMDB {
+		t.Fatal("display details alias prepared release metadata")
+	}
+	actual.Providers[0].Details.TMDB.OriginCountry[0] = "changed"
+	if release.ProviderMetadata.TMDB.OriginCountry[0] != "AU" {
+		t.Fatal("display mutation changed prepared release")
+	}
+	repeated, err := projectPreparedReleaseDisplay(release)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(repeated, expected) {
+		t.Fatal("repeated projection was not deterministic and detached")
+	}
+}
+
+func TestProjectPreparedReleaseDisplaySparseAndLocalFallbacks(t *testing.T) {
+	t.Parallel()
+
+	identityOnly := api.PreparedRelease{
+		Naming:   api.NamingFacts{ReleaseName: "Example.Release.2026-GRP"},
+		Identity: api.ExternalIdentity{TMDBID: 101, Category: api.CanonicalCategoryMovie},
+	}
+	display, err := projectPreparedReleaseDisplay(identityOnly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(display.Providers) != 0 {
+		t.Fatalf("identity-only display providers = %d, want 0", len(display.Providers))
+	}
+
+	noSummary := api.PreparedRelease{
+		Identity: api.ExternalIdentity{IMDBID: 123456},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{IMDBID: 123456},
+		},
+	}
+	display, err = projectPreparedReleaseDisplay(noSummary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(display.Providers) != 1 || display.Providers[0].SummaryAvailable {
+		t.Fatalf("no-summary display = %#v", display.Providers)
+	}
+
+	fallback := api.PreparedRelease{
+		Naming: api.NamingFacts{ReleaseName: "Example.Release.2026-GRP"},
+		Identity: api.ExternalIdentity{
+			TVmazeID: 404,
+			Category: api.CanonicalCategoryTV,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVmaze: &api.TVmazeMetadata{
+				TVmazeID:       404,
+				Premiered:      "2026-01-02",
+				AverageRuntime: 51,
+				Type:           "Scripted",
+			},
+		},
+	}
+	display, err = projectPreparedReleaseDisplay(fallback)
+	if err != nil {
+		t.Fatal(err)
+	}
+	summary := display.Providers[0].Summary
+	if summary.Title != fallback.Naming.ReleaseName || summary.Category != "tv" || summary.Date != "2026-01-02" || summary.RuntimeMinutes != 51 {
+		t.Fatalf("fallback summary = %#v", summary)
+	}
+	if summary.Overview != "" || summary.PosterURL != "" {
+		t.Fatalf("fallback crossed provider-local boundary: %#v", summary)
+	}
+}
+
+func TestProjectPreparedReleaseDisplayRejectsProviderIdentityMismatch(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		mutate func(*api.PreparedRelease)
+	}{
+		{name: "tmdb", mutate: func(value *api.PreparedRelease) { value.ProviderMetadata.TMDB.TMDBID++ }},
+		{name: "imdb", mutate: func(value *api.PreparedRelease) { value.ProviderMetadata.IMDB.IMDBID = 0 }},
+		{name: "tvdb", mutate: func(value *api.PreparedRelease) { value.ProviderMetadata.TVDB.TVDBID++ }},
+		{name: "tvmaze", mutate: func(value *api.PreparedRelease) { value.ProviderMetadata.TVmaze.TVmazeID++ }},
+		{name: "mal", mutate: func(value *api.PreparedRelease) { value.ProviderMetadata.AniList.MALID++ }},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			release := canonicalDisplayFixtureRelease()
+			test.mutate(&release)
+			if _, err := projectPreparedReleaseDisplay(release); err == nil {
+				t.Fatal("expected provider identity mismatch")
+			}
+		})
+	}
+
+	linkedOnly := canonicalDisplayFixtureRelease()
+	linkedOnly.ProviderMetadata.TMDB.TMDBID = 0
+	linkedOnly.ProviderMetadata.TMDB.IMDBID = linkedOnly.Identity.TMDBID
+	if _, err := projectPreparedReleaseDisplay(linkedOnly); err == nil {
+		t.Fatal("linked provider ID satisfied missing TMDB own ID")
+	}
+}
+
+func canonicalDisplayFixtureRelease() api.PreparedRelease {
+	return api.PreparedRelease{
+		Naming: api.NamingFacts{ReleaseName: "Example.Release.2026.1080p-GRP"},
+		Identity: api.ExternalIdentity{
+			TMDBID:   101,
+			IMDBID:   123456,
+			TVDBID:   303,
+			TVmazeID: 404,
+			MALID:    505,
+			Category: api.CanonicalCategoryMovie,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB:    api.IdentityProvenanceExplicit,
+				IMDB:    api.IdentityProvenanceTracker,
+				TVDB:    api.IdentityProvenanceScene,
+				TVmaze:  api.IdentityProvenanceArr,
+				MAL:     api.IdentityProvenanceProvider,
+			},
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				TMDBID:           101,
+				Category:         "movie",
+				Title:            "Example TMDB",
+				OriginalTitle:    "Example Original",
+				Year:             2026,
+				ReleaseDate:      "2026-01-02",
+				LastAirDate:      "2026-02-03",
+				OriginCountry:    []string{"AU", "NZ"},
+				OriginalLanguage: "en",
+				Overview:         "TMDB overview",
+				Poster:           "https://img.example/tmdb-poster.jpg",
+				Backdrop:         "https://img.example/tmdb-backdrop.jpg",
+				TMDBType:         "movie",
+				Runtime:          123,
+				Genres:           "Drama",
+				Keywords:         "example, release",
+				YouTube:          "https://video.example/tmdb",
+			},
+			IMDB: &api.IMDBMetadata{
+				IMDBID:           123456,
+				Title:            "Example IMDb",
+				Year:             2025,
+				Type:             "movie",
+				Plot:             "IMDb overview",
+				Rating:           7.4,
+				RatingCount:      4567,
+				RuntimeMinutes:   119,
+				Genres:           "Mystery",
+				Country:          "Australia",
+				Cover:            "https://img.example/imdb-cover.jpg",
+				OriginalLanguage: "en",
+			},
+			TVDB: &api.TVDBMetadata{
+				TVDBID:            303,
+				Name:              "Example TVDB",
+				Overview:          "TVDB overview",
+				FirstAired:        "2024-03-04",
+				Year:              2024,
+				Type:              "series",
+				OriginalCountry:   "FR",
+				OriginalLanguage:  "fr",
+				Genres:            "Comedy",
+				Poster:            "https://img.example/tvdb-poster.jpg",
+			},
+			TVmaze: &api.TVmazeMetadata{
+				TVmazeID:       404,
+				Name:           "Example TVmaze",
+				Premiered:      "2023-05-06",
+				Ended:          "2023-07-08",
+				Summary:        "TVmaze overview",
+				Type:           "Scripted",
+				Language:       "es",
+				Genres:         "Thriller",
+				AverageRuntime: 47,
+				Rating:         8.1,
+				Weight:         99,
+				Country:        "ES",
+				Poster:         "https://img.example/tvmaze-poster.jpg",
+				Backdrop:       "https://img.example/tvmaze-backdrop.jpg",
+			},
+			AniList: &api.AniListMetadata{
+				AniListID:       606,
+				MALID:           505,
+				TitleRomaji:     "Example Anime Romaji",
+				TitleEnglish:    "Example Anime",
+				Description:     "AniList overview",
+				Format:          "TV",
+				StartDate:       "2022-09-10",
+				EndDate:         "2022-12-11",
+				SeasonYear:      2022,
+				Duration:        24,
+				CountryOfOrigin: "JP",
+				CoverExtraLarge: "https://img.example/anilist-cover.jpg",
+				BannerImage:     "https://img.example/anilist-banner.jpg",
+				Genres:          []string{"Action", "Drama"},
+				AverageScore:    82,
+				Popularity:      6789,
+			},
+		},
+	}
+}
diff --git a/internal/preparedrelease/evidence_collector.go b/internal/preparedrelease/evidence_collector.go
new file mode 100644
index 00000000..ce311bd1
--- /dev/null
+++ b/internal/preparedrelease/evidence_collector.go
@@ -0,0 +1,345 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/externalidentity"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// EvidencePipeline is the single private collection port owned by canonical
+// preparation. Ordering and intermediate mutable evidence stay behind it.
+type EvidencePipeline interface {
+	CollectPreparationEvidence(context.Context, preparationstate.Request) (preparationstate.State, error)
+}
+
+type clientEvidencePipeline interface {
+	HydrateClientEvidence(context.Context, preparationstate.Request) (preparationstate.ClientEvidenceSnapshot, error)
+}
+
+// EvidenceCollector adapts the existing evidence pipeline to canonical grouped
+// facts while canonical identity/persistence ownership moves out of metadata.
+// It also supplies the resulting provider candidate to externalidentity.
+type EvidenceCollector struct {
+	pipeline EvidencePipeline
+	mu       sync.Mutex
+	pending  map[string]externalidentity.CandidateEvidence
+}
+
+// NewEvidenceCollector requires a collection pipeline and owns the one-use,
+// per-source candidate handoff consumed during canonical identity resolution.
+func NewEvidenceCollector(pipeline EvidencePipeline) (*EvidenceCollector, error) {
+	if pipeline == nil {
+		return nil, errors.New("prepared release: metadata evidence pipeline is required")
+	}
+	return &EvidenceCollector{
+		pipeline: pipeline,
+		pending:  make(map[string]externalidentity.CandidateEvidence),
+	}, nil
+}
+
+// Collect runs the canonical evidence sequence without identity persistence and
+// maps its result into non-aliased fact groups.
+func (c *EvidenceCollector) Collect(
+	ctx context.Context,
+	request preparationstate.Request,
+) (CollectedFacts, error) {
+	if c == nil || c.pipeline == nil {
+		return CollectedFacts{}, errors.New("prepared release: evidence collector is not initialized")
+	}
+	meta, err := c.pipeline.CollectPreparationEvidence(ctx, request)
+	if err != nil {
+		return CollectedFacts{}, fmt.Errorf("prepared release: collect preparation evidence: %w", err)
+	}
+	if canonicalSourceKey(meta.SourcePath) != canonicalSourceKey(request.Manifest.SourcePath) {
+		return CollectedFacts{}, fmt.Errorf("prepared release: collected source differs from manifest: %w", internalerrors.ErrInvalidInput)
+	}
+	meta.ProviderMetadata = cloneCollectedProviderMetadata(meta.ProviderMetadata)
+	if err := applyBlurayFactInstruction(&meta, request.Input.Instructions.BlurayReleaseID); err != nil {
+		return CollectedFacts{}, err
+	}
+
+	candidate := externalidentity.CandidateEvidence{
+		Identity:   cloneCollectedIdentity(meta.Identity),
+		Metadata:   cloneCollectedProviderMetadata(meta.ProviderMetadata),
+		Candidates: cloneCollectedCandidates(meta.ExternalIdentityCandidates),
+	}
+	candidate.Identity.SourcePath = request.Manifest.SourcePath
+	candidate.Metadata.SourcePath = request.Manifest.SourcePath
+	c.mu.Lock()
+	c.pending[canonicalSourceKey(request.Manifest.SourcePath)] = candidate
+	c.mu.Unlock()
+
+	return mapCollectedFacts(meta), nil
+}
+
+// HydrateClientEvidence delegates the restart-only private evidence operation
+// without running the full metadata or canonical-identity pipeline.
+func (c *EvidenceCollector) HydrateClientEvidence(
+	ctx context.Context,
+	request preparationstate.Request,
+) (preparationstate.ClientEvidenceSnapshot, error) {
+	if c == nil || c.pipeline == nil {
+		return preparationstate.ClientEvidenceSnapshot{}, errors.New("prepared release: evidence collector is not initialized")
+	}
+	pipeline, ok := c.pipeline.(clientEvidencePipeline)
+	if !ok {
+		return preparationstate.ClientEvidenceSnapshot{}, errors.New("prepared release: metadata pipeline cannot hydrate client evidence")
+	}
+	snapshot, err := pipeline.HydrateClientEvidence(ctx, request)
+	if err != nil {
+		return preparationstate.ClientEvidenceSnapshot{}, fmt.Errorf("prepared release: hydrate client evidence: %w", err)
+	}
+	return preparationstate.CloneClientEvidenceSnapshot(snapshot), nil
+}
+
+func applyBlurayFactInstruction(meta *preparationstate.State, releaseID string) error {
+	releaseID = strings.TrimSpace(releaseID)
+	if releaseID == "" {
+		return nil
+	}
+	if meta == nil || meta.ProviderMetadata.Bluray == nil || !meta.ProviderMetadata.Bluray.SelectCandidate(releaseID, false, "manual") {
+		return fmt.Errorf("prepared release: Blu-ray candidate %q: %w", releaseID, internalerrors.ErrNotFound)
+	}
+	candidate := meta.ProviderMetadata.Bluray.SelectedCandidate()
+	if candidate == nil {
+		return fmt.Errorf("prepared release: Blu-ray candidate %q: %w", releaseID, internalerrors.ErrNotFound)
+	}
+	if region := strings.TrimSpace(candidate.Region); region != "" {
+		meta.Region = region
+		meta.Release.Region = region
+	}
+	if publisher := strings.TrimSpace(candidate.Publisher); publisher != "" {
+		meta.Distributor = strings.ToUpper(publisher)
+	}
+	return nil
+}
+
+// ResolveIdentityCandidate supplies and consumes the provider candidate built
+// by the immediately preceding source-scoped collection.
+func (c *EvidenceCollector) ResolveIdentityCandidate(
+	_ context.Context,
+	request externalidentity.Request,
+) (externalidentity.CandidateEvidence, error) {
+	if c == nil {
+		return externalidentity.CandidateEvidence{}, internalerrors.ErrNotFound
+	}
+	key := canonicalSourceKey(request.SourcePath)
+	c.mu.Lock()
+	candidate, ok := c.pending[key]
+	if ok {
+		delete(c.pending, key)
+	}
+	c.mu.Unlock()
+	if !ok {
+		return externalidentity.CandidateEvidence{}, internalerrors.ErrNotFound
+	}
+	return candidate, nil
+}
+
+func mapCollectedFacts(meta preparationstate.State) CollectedFacts {
+	namingStatus := api.NamingStatusComplete
+	if len(meta.ReleaseNameMissing) > 0 {
+		namingStatus = api.NamingStatusIncomplete
+	}
+	missing := make([]api.NamingRequirement, 0, len(meta.ReleaseNameMissing))
+	for _, value := range meta.ReleaseNameMissing {
+		if value = strings.TrimSpace(value); value != "" {
+			missing = append(missing, api.NamingRequirement(value))
+		}
+	}
+	assessments := meta.ReleaseAssessments()
+	assessments.Naming = api.NamingAssessment{Status: namingStatus, Missing: missing}
+	diagnostics := make([]api.PreparationDiagnostic, 0, len(meta.LookupWarnings))
+	for _, warning := range meta.LookupWarnings {
+		if warning = strings.TrimSpace(warning); warning != "" {
+			diagnostics = append(diagnostics, api.PreparationDiagnostic{
+				Code:     "source_lookup_warning",
+				Severity: api.DiagnosticSeverityWarning,
+				Message:  warning,
+			})
+		}
+	}
+	return CollectedFacts{
+		Naming: api.NamingFacts{
+			Filename:       meta.Filename,
+			ReleaseName:    meta.ReleaseName,
+			NameWithoutTag: meta.ReleaseNameNoTag,
+			CleanName:      meta.ReleaseNameClean,
+			Tag:            meta.Tag,
+			Type:           meta.Release.Type,
+			Artist:         meta.Release.Artist,
+			Title:          meta.Release.Title,
+			Subtitle:       meta.Release.Subtitle,
+			AlternateTitle: meta.Release.Alt,
+			Year:           meta.Release.Year,
+			Month:          meta.Release.Month,
+			Day:            meta.Release.Day,
+			Source:         meta.Release.Source,
+			Resolution:     meta.Release.Resolution,
+			Codecs:         append([]string(nil), meta.Release.Codec...),
+			Audio:          append([]string(nil), meta.Release.Audio...),
+			HDR:            append([]string(nil), meta.Release.HDR...),
+			Extension:      meta.Release.Ext,
+			Languages:      append([]string(nil), meta.Release.Language...),
+			Site:           meta.Release.Site,
+			Genre:          meta.Release.Genre,
+			Channels:       meta.Release.Channels,
+			Collection:     meta.Release.Collection,
+			Region:         meta.Release.Region,
+			Size:           meta.Release.Size,
+			Group:          meta.Release.Group,
+			Disc:           meta.Release.Disc,
+			Editions:       append([]string(nil), meta.Release.Edition...),
+			Other:          append([]string(nil), meta.Release.Other...),
+			Scene:          meta.Scene,
+			SceneName:      meta.SceneName,
+			Personal:       meta.PersonalRelease,
+		},
+		Episode: api.EpisodeFacts{
+			Season:            meta.SeasonInt,
+			Episode:           meta.EpisodeInt,
+			SeasonLabel:       meta.SeasonStr,
+			EpisodeLabel:      meta.EpisodeStr,
+			DailyDate:         meta.DailyEpisodeDate,
+			Pack:              meta.TVPack,
+			Title:             meta.EpisodeTitle,
+			Overview:          meta.EpisodeOverview,
+			Year:              meta.EpisodeYear,
+			AiredDate:         meta.TVDBAiredDate,
+			AirDays:           append([]string(nil), meta.TVDBAirsDays...),
+			AirTime:           meta.TVDBAirsTime,
+			AirTimezone:       meta.TVDBAirsTimezone,
+			AirTimezoneSource: meta.TVDBAirsTimezoneSource,
+			DateMatched:       meta.TMDBDateMatch,
+		},
+		Media: api.MediaFacts{
+			AudioLanguages:    append([]string(nil), meta.AudioLanguages...),
+			SubtitleLanguages: append([]string(nil), meta.SubtitleLanguages...),
+			Container:         meta.Container,
+			Audio:             meta.Audio,
+			Channels:          meta.Channels,
+			Commentary:        meta.HasCommentary,
+			ThreeD:            meta.Is3D,
+			Source:            meta.Source,
+			Type:              meta.Type,
+			UHD:               meta.UHD,
+			HDR:               meta.HDR,
+			Distributor:       meta.Distributor,
+			Region:            meta.Region,
+			VideoCodec:        meta.VideoCodec,
+			VideoEncode:       meta.VideoEncode,
+			HasEncodeSettings: meta.HasEncodeSettings,
+			BitDepth:          meta.BitDepth,
+			Edition:           meta.Edition,
+			Repack:            meta.Repack,
+			WebDV:             meta.WebDV,
+			StreamOptimized:   meta.StreamOptimized,
+			Service:           meta.Service,
+			ServiceLongName:   meta.ServiceLongName,
+			MediaInfoUniqueID: meta.MediaInfoUniqueID,
+			Anime:             meta.Anime,
+		},
+		Disc: api.DiscFacts{
+			Type:            meta.DiscType,
+			Summary:         collectedBDInfoSummary(meta.BDInfo),
+			DurationSeconds: collectedBDInfoDurationSeconds(meta.BDInfo),
+			PlaylistCount:   len(meta.SelectedBDMVPlaylists),
+			DVDVOBSet:       meta.DVDVOBSet,
+		},
+		Assessments: assessments,
+		Identity: externalidentity.ResolutionIntent{
+			Title:   meta.Release.Title,
+			Year:    meta.Release.Year,
+			Season:  meta.SeasonInt,
+			Episode: meta.EpisodeInt,
+		},
+		Diagnostics: diagnostics,
+		Resources: CollectedResources{
+			SourcePath:            firstCollectedSourcePath(meta.Paths),
+			VideoPath:             meta.VideoPath,
+			FileList:              append([]string(nil), meta.FileList...),
+			MediaInfoJSONPath:     meta.MediaInfoJSONPath,
+			MediaInfoTextPath:     meta.MediaInfoTextPath,
+			DVDIFOPath:            meta.DVDIFOPath,
+			DVDVOBPath:            meta.DVDVOBPath,
+			DVDVOBMediaInfoJSON:   meta.DVDVOBMediaInfoJSON,
+			DVDVOBMediaInfoText:   meta.DVDVOBMediaInfoText,
+			SceneNFOPath:          meta.SceneNFOPath,
+			DescriptionTemplate:   meta.DescriptionTemplate,
+			SelectedBDMVPlaylists: clonePlaylists(meta.SelectedBDMVPlaylists),
+			ClientEvidence:        preparationstate.CloneClientEvidenceSnapshot(meta.ClientEvidence),
+		},
+	}
+}
+
+func firstCollectedSourcePath(paths []string) string {
+	for _, sourcePath := range paths {
+		if sourcePath = strings.TrimSpace(sourcePath); sourcePath != "" {
+			return sourcePath
+		}
+	}
+	return ""
+}
+
+func collectedBDInfoSummary(value map[string]any) string {
+	summary, _ := value["summary"].(string)
+	return strings.TrimSpace(summary)
+}
+
+func collectedBDInfoDurationSeconds(value map[string]any) float64 {
+	text := strings.TrimSpace(fmt.Sprint(value["length"]))
+	if text == "" || text == "<nil>" {
+		return 0
+	}
+	parts := strings.Split(text, ":")
+	if len(parts) != 3 {
+		return 0
+	}
+	hours, hoursErr := strconv.ParseFloat(strings.TrimSpace(parts[0]), 64)
+	minutes, minutesErr := strconv.ParseFloat(strings.TrimSpace(parts[1]), 64)
+	seconds, secondsErr := strconv.ParseFloat(strings.TrimSpace(parts[2]), 64)
+	if hoursErr != nil || minutesErr != nil || secondsErr != nil || hours < 0 || minutes < 0 || seconds < 0 {
+		return 0
+	}
+	return hours*3600 + minutes*60 + seconds
+}
+
+func cloneCollectedIdentity(value api.ExternalIdentity) api.ExternalIdentity {
+	return value
+}
+
+func cloneCollectedProviderMetadata(value api.SourceScopedMetadata) api.SourceScopedMetadata {
+	cloned, err := cloneWithJSON(value)
+	if err != nil {
+		panic(err)
+	}
+	return cloned
+}
+
+func cloneCollectedCandidates(value []api.ExternalIdentityCandidate) []api.ExternalIdentityCandidate {
+	cloned, err := cloneWithJSON(value)
+	if err != nil {
+		panic(err)
+	}
+	return cloned
+}
+
+func clonePlaylists(value []api.PlaylistInfo) []api.PlaylistInfo {
+	cloned, err := cloneWithJSON(value)
+	if err != nil {
+		panic(err)
+	}
+	return cloned
+}
diff --git a/internal/preparedrelease/evidence_collector_test.go b/internal/preparedrelease/evidence_collector_test.go
new file mode 100644
index 00000000..eb78b966
--- /dev/null
+++ b/internal/preparedrelease/evidence_collector_test.go
@@ -0,0 +1,110 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"errors"
+	"testing"
+
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestMapLegacyFactsUsesTypedConcreteAssessments(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name       string
+		meta       preparationstate.State
+		uniqueID   api.UniqueIDStatus
+		settings   api.EncodeSettingsStatus
+		naming     api.NamingStatus
+		missingLen int
+	}{
+		{
+			name: "non-applicable remux",
+			meta: preparationstate.State{
+				SourcePath:                     "Example.Release.2026.1080p-GRP.mp4",
+				Type:                           "REMUX",
+				MediaInfoUniqueIDPresent:       false,
+				MediaInfoEncodeSettingsPresent: false,
+			},
+			uniqueID: api.UniqueIDStatusNotApplicable,
+			settings: api.EncodeSettingsStatusNotApplicable,
+			naming:   api.NamingStatusComplete,
+		},
+		{
+			name: "missing mkv encode facts",
+			meta: preparationstate.State{
+				SourcePath:                     "Example.Release.2026.1080p-GRP.mkv",
+				FileList:                       []string{"Example.Release.2026.1080p-GRP.mkv"},
+				Type:                           "ENCODE",
+				VideoCodec:                     "H.264",
+				MediaInfoUniqueIDPresent:       false,
+				MediaInfoEncodeSettingsPresent: false,
+				ReleaseNameMissing:             []string{"resolution"},
+			},
+			uniqueID:   api.UniqueIDStatusMissing,
+			settings:   api.EncodeSettingsStatusMissing,
+			naming:     api.NamingStatusIncomplete,
+			missingLen: 1,
+		},
+		{
+			name: "present mkv encode facts",
+			meta: preparationstate.State{
+				SourcePath:                     "Example.Release.2026.1080p-GRP.mkv",
+				Type:                           "ENCODE",
+				VideoCodec:                     "HEVC",
+				MediaInfoUniqueIDPresent:       true,
+				MediaInfoEncodeSettingsPresent: true,
+			},
+			uniqueID: api.UniqueIDStatusPresent,
+			settings: api.EncodeSettingsStatusPresent,
+			naming:   api.NamingStatusComplete,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			facts := mapCollectedFacts(tt.meta)
+			if facts.Assessments.MediaInfoUniqueID != tt.uniqueID ||
+				facts.Assessments.MediaInfoEncodeSettings != tt.settings ||
+				facts.Assessments.Naming.Status != tt.naming ||
+				len(facts.Assessments.Naming.Missing) != tt.missingLen {
+				t.Fatalf("assessments = %#v", facts.Assessments)
+			}
+		})
+	}
+}
+
+func TestApplyBlurayFactInstructionSelectsCandidateBeforePublication(t *testing.T) {
+	t.Parallel()
+	meta := preparationstate.State{
+		ProviderMetadata: api.SourceScopedMetadata{
+			Bluray: &api.BlurayMetadata{
+				Candidates: []api.BlurayReleaseCandidate{{
+					ReleaseID: "candidate-2",
+					Region:    "B",
+					Publisher: "Example Publisher",
+				}},
+			},
+		},
+	}
+	if err := applyBlurayFactInstruction(&meta, "candidate-2"); err != nil {
+		t.Fatalf("apply Blu-ray instruction: %v", err)
+	}
+	if meta.ProviderMetadata.Bluray.SelectedReleaseID != "candidate-2" || meta.Release.Region != "B" || meta.Distributor != "EXAMPLE PUBLISHER" {
+		t.Fatalf("selected facts = %#v", meta)
+	}
+}
+
+func TestApplyBlurayFactInstructionRejectsUnknownCandidate(t *testing.T) {
+	t.Parallel()
+	meta := preparationstate.State{ProviderMetadata: api.SourceScopedMetadata{Bluray: &api.BlurayMetadata{}}}
+	if err := applyBlurayFactInstruction(&meta, "missing"); !errors.Is(err, internalerrors.ErrNotFound) {
+		t.Fatalf("error = %v, want not found", err)
+	}
+}
diff --git a/internal/preparedrelease/fingerprint.go b/internal/preparedrelease/fingerprint.go
new file mode 100644
index 00000000..3010dc63
--- /dev/null
+++ b/internal/preparedrelease/fingerprint.go
@@ -0,0 +1,301 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type normalizedPrepareInput struct {
+	input     api.PrepareInput
+	sourceKey string
+}
+
+// normalizePrepareInput canonicalizes fact-producing values before inspection
+// and compatibility hashing while preserving one-shot controls unchanged.
+func normalizePrepareInput(input api.PrepareInput) (normalizedPrepareInput, error) {
+	primary, err := normalizeSourcePath(input.SourcePath)
+	if err != nil {
+		return normalizedPrepareInput{}, err
+	}
+	input.SourcePath = primary
+	input.Instructions.SourceLookup = strings.TrimSpace(input.Instructions.SourceLookup)
+	input.Instructions.Playlist.Selected = normalizePlaylistSelection(input.Instructions.Playlist.Selected)
+	input.Instructions.TrackerIDs = normalizeTrackerIDs(input.Instructions.TrackerIDs)
+	input.Search.Client = normalizeOptionalString(input.Search.Client)
+	return normalizedPrepareInput{input: input, sourceKey: canonicalSourceKey(primary)}, nil
+}
+
+// normalizeTrackerIDs lowercases tracker keys and drops blank keys and values.
+func normalizeTrackerIDs(values map[string]string) map[string]string {
+	if values == nil {
+		return nil
+	}
+	result := make(map[string]string, len(values))
+	for key, value := range values {
+		key = strings.ToLower(strings.TrimSpace(key))
+		value = strings.TrimSpace(value)
+		if key != "" && value != "" {
+			result[key] = value
+		}
+	}
+	return result
+}
+
+// normalizeOptionalString trims a present value without collapsing it to nil.
+func normalizeOptionalString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	normalized := strings.TrimSpace(*value)
+	return &normalized
+}
+
+func normalizeSourcePath(value string) (string, error) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "", internalerrors.ErrInvalidInput
+	}
+	abs, err := filepath.Abs(value)
+	if err != nil {
+		return "", fmt.Errorf("prepared release: normalize source path: %w", err)
+	}
+	return filepath.Clean(abs), nil
+}
+
+func canonicalSourceKey(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	value = filepath.Clean(value)
+	if runtime.GOOS == "windows" {
+		value = strings.ToLower(value)
+	}
+	return value
+}
+
+func normalizePlaylistSelection(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		value = filepath.ToSlash(filepath.Clean(strings.TrimSpace(value)))
+		if value == "." || value == "" {
+			continue
+		}
+		key := value
+		if runtime.GOOS == "windows" {
+			key = strings.ToLower(key)
+		}
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		result = append(result, value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+// inspectSource inventories the validated layout and returns its canonical
+// manifest plus a deterministic source fingerprint.
+func inspectSource(ctx context.Context, input api.PrepareInput, layout sourcelayout.Layout) (api.SourceManifest, string, error) {
+	normalized, err := normalizePrepareInput(input)
+	if err != nil {
+		return api.SourceManifest{}, "", err
+	}
+	input = normalized.input
+	if canonicalSourceKey(layout.SourcePath) != canonicalSourceKey(input.SourcePath) {
+		return api.SourceManifest{}, "", fmt.Errorf("prepared release: source layout differs from input: %w", internalerrors.ErrInvalidInput)
+	}
+	entries := make([]api.SourceManifestEntry, 0, 1)
+	var total int64
+	for _, root := range []string{input.SourcePath} {
+		if err := ctx.Err(); err != nil {
+			return api.SourceManifest{}, "", fmt.Errorf("prepared release: inventory canceled: %w", err)
+		}
+		info, err := os.Stat(root)
+		if err != nil {
+			return api.SourceManifest{}, "", fmt.Errorf("prepared release: inspect source %s: %w", root, err)
+		}
+		if !info.IsDir() {
+			entry := manifestEntry(root, info)
+			entries = append(entries, entry)
+			total += entry.Size
+			continue
+		}
+		err = filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			if err := ctx.Err(); err != nil {
+				return fmt.Errorf("prepared release: inventory walk canceled: %w", err)
+			}
+			info, infoErr := entry.Info()
+			if infoErr != nil {
+				return fmt.Errorf("prepared release: inspect inventory entry %q: %w", path, infoErr)
+			}
+			item := manifestEntry(path, info)
+			entries = append(entries, item)
+			if item.Type == api.SourceEntryTypeFile || item.Type == api.SourceEntryTypePlaylist {
+				total += item.Size
+			}
+			return nil
+		})
+		if err != nil {
+			return api.SourceManifest{}, "", fmt.Errorf("prepared release: inventory source %s: %w", root, err)
+		}
+	}
+	sort.Slice(entries, func(i, j int) bool {
+		left := canonicalSourceKey(entries[i].Path)
+		right := canonicalSourceKey(entries[j].Path)
+		return left < right
+	})
+
+	selected := make([]api.PlaylistInfo, 0, len(input.Instructions.Playlist.Selected))
+	for _, value := range input.Instructions.Playlist.Selected {
+		selected = append(selected, api.PlaylistInfo{File: value})
+	}
+	manifest := api.SourceManifest{
+		SourcePath:        input.SourcePath,
+		Size:              total,
+		Entries:           entries,
+		SelectedPlaylists: selected,
+		Classification:    classifyManifest(entries),
+	}
+	if manifest.Classification.DiscType == "" {
+		manifest.Classification.DiscType = layout.DiscType
+	}
+	fingerprint, err := fingerprintJSON(sourceFingerprintPayload{
+		SourcePath: canonicalSourceKey(input.SourcePath),
+		Entries:    canonicalFingerprintEntries(entries),
+		Playlists:  input.Instructions.Playlist,
+	})
+	if err != nil {
+		return api.SourceManifest{}, "", fmt.Errorf("prepared release: fingerprint source: %w", err)
+	}
+	return manifest, fingerprint, nil
+}
+
+func manifestEntry(path string, info fs.FileInfo) api.SourceManifestEntry {
+	entryType := api.SourceEntryTypeUnknown
+	switch {
+	case info.IsDir():
+		entryType = api.SourceEntryTypeDirectory
+	case info.Mode().IsRegular():
+		entryType = api.SourceEntryTypeFile
+	}
+	ext := strings.ToLower(filepath.Ext(path))
+	if ext == ".mpls" || ext == ".ifo" {
+		entryType = api.SourceEntryTypePlaylist
+	}
+	disc := ""
+	upper := strings.ToUpper(filepath.ToSlash(path))
+	switch {
+	case strings.Contains(upper, "/BDMV/") || strings.HasSuffix(upper, "/BDMV"):
+		disc = "BDMV"
+	case strings.Contains(upper, "/VIDEO_TS/") || strings.HasSuffix(upper, "/VIDEO_TS"):
+		disc = "DVD"
+	}
+	playlist := ""
+	if entryType == api.SourceEntryTypePlaylist {
+		playlist = filepath.Base(path)
+	}
+	return api.SourceManifestEntry{
+		Path:       filepath.Clean(path),
+		Type:       entryType,
+		Size:       info.Size(),
+		ModifiedAt: info.ModTime().UTC(),
+		Disc:       disc,
+		Playlist:   playlist,
+	}
+}
+
+func classifyManifest(entries []api.SourceManifestEntry) api.SourceClassification {
+	classification := api.SourceClassification{}
+	for _, entry := range entries {
+		if classification.DiscType == "" && entry.Disc != "" {
+			classification.DiscType = entry.Disc
+		}
+		if classification.Container == "" && entry.Type == api.SourceEntryTypeFile {
+			classification.Container = strings.TrimPrefix(strings.ToLower(filepath.Ext(entry.Path)), ".")
+		}
+	}
+	return classification
+}
+
+type sourceFingerprintPayload struct {
+	SourcePath string
+	Entries    []sourceFingerprintEntry
+	Playlists  api.PlaylistInstruction
+}
+
+type sourceFingerprintEntry struct {
+	Path         string
+	Type         api.SourceEntryType
+	Size         int64
+	ModifiedNano int64
+	Disc         string
+	Playlist     string
+}
+
+func canonicalFingerprintEntries(entries []api.SourceManifestEntry) []sourceFingerprintEntry {
+	result := make([]sourceFingerprintEntry, 0, len(entries))
+	for _, entry := range entries {
+		result = append(result, sourceFingerprintEntry{
+			Path:         canonicalSourceKey(entry.Path),
+			Type:         entry.Type,
+			Size:         entry.Size,
+			ModifiedNano: entry.ModifiedAt.UTC().UnixNano(),
+			Disc:         entry.Disc,
+			Playlist:     filepath.ToSlash(entry.Playlist),
+		})
+	}
+	return result
+}
+
+// preparationCompatibility fingerprints fact instructions and reusable policy;
+// intent and one-shot controls are deliberately excluded.
+func preparationCompatibility(input api.PrepareInput, sourceFingerprint string) (api.PreparationCompatibility, error) {
+	factInstructions, err := fingerprintJSON(input.Instructions)
+	if err != nil {
+		return api.PreparationCompatibility{}, fmt.Errorf("prepared release: fingerprint fact instructions: %w", err)
+	}
+	policy, err := fingerprintJSON(struct {
+		Policy api.PreparationPolicy
+		Search api.ClientSearchPolicy
+	}{Policy: input.Policy, Search: input.Search})
+	if err != nil {
+		return api.PreparationCompatibility{}, fmt.Errorf("prepared release: fingerprint policy: %w", err)
+	}
+	return api.PreparationCompatibility{
+		SourceFingerprint:          sourceFingerprint,
+		FactInstructionFingerprint: factInstructions,
+		PolicyFingerprint:          policy,
+		ContractVersion:            ContractVersion,
+	}, nil
+}
+
+func fingerprintJSON(value any) (string, error) {
+	payload, err := json.Marshal(value)
+	if err != nil {
+		return "", fmt.Errorf("prepared release: marshal fingerprint input: %w", err)
+	}
+	digest := sha256.Sum256(payload)
+	return hex.EncodeToString(digest[:]), nil
+}
diff --git a/internal/preparedrelease/gates.go b/internal/preparedrelease/gates.go
new file mode 100644
index 00000000..4314aa72
--- /dev/null
+++ b/internal/preparedrelease/gates.go
@@ -0,0 +1,77 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+type sourceGates struct {
+	mu      sync.Mutex
+	sources map[string]*sourceGate
+}
+
+type sourceGate struct {
+	waiters []*sourceWaiter
+}
+
+type sourceWaiter struct {
+	ready chan struct{}
+}
+
+func (g *sourceGates) acquire(ctx context.Context, source string) (func(), error) {
+	waiter := &sourceWaiter{ready: make(chan struct{})}
+	g.mu.Lock()
+	if g.sources == nil {
+		g.sources = make(map[string]*sourceGate)
+	}
+	gate := g.sources[source]
+	if gate == nil {
+		gate = &sourceGate{}
+		g.sources[source] = gate
+	}
+	gate.waiters = append(gate.waiters, waiter)
+	if len(gate.waiters) == 1 {
+		close(waiter.ready)
+	}
+	g.mu.Unlock()
+
+	select {
+	case <-waiter.ready:
+		if err := ctx.Err(); err != nil {
+			g.remove(source, waiter)
+			return nil, fmt.Errorf("prepared release: acquire source gate: %w", err)
+		}
+	case <-ctx.Done():
+		g.remove(source, waiter)
+		return nil, fmt.Errorf("prepared release: wait for source gate: %w", ctx.Err())
+	}
+	var once sync.Once
+	return func() { once.Do(func() { g.remove(source, waiter) }) }, nil
+}
+
+func (g *sourceGates) remove(source string, waiter *sourceWaiter) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	gate := g.sources[source]
+	if gate == nil {
+		return
+	}
+	for idx, queued := range gate.waiters {
+		if queued != waiter {
+			continue
+		}
+		wasHead := idx == 0
+		gate.waiters = append(gate.waiters[:idx], gate.waiters[idx+1:]...)
+		if wasHead && len(gate.waiters) > 0 {
+			close(gate.waiters[0].ready)
+		}
+		break
+	}
+	if len(gate.waiters) == 0 {
+		delete(g.sources, source)
+	}
+}
diff --git a/internal/preparedrelease/module.go b/internal/preparedrelease/module.go
new file mode 100644
index 00000000..abae8746
--- /dev/null
+++ b/internal/preparedrelease/module.go
@@ -0,0 +1,833 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package preparedrelease owns immutable, source-scoped prepared-release
+// generations and their private preparation resources.
+package preparedrelease
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/externalidentity"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ContractVersion changes whenever prepared fact semantics or the private seed
+// contract become incompatible with an earlier generation.
+const ContractVersion = "prepared-release-v2"
+
+// Store is the prepared-release persistence port. Implementations must commit
+// facts, identity, and provider metadata as one generation transaction.
+type Store interface {
+	LoadPreparedRelease(context.Context, string) (api.PreparedRelease, error)
+	CommitPreparedRelease(context.Context, api.PreparedRelease) error
+	PurgePreparedRelease(context.Context, string) error
+}
+
+// IdentityResolver builds an unpersisted canonical identity candidate. The
+// module commits it with the rest of the prepared generation.
+type IdentityResolver interface {
+	Resolve(context.Context, externalidentity.Request) (externalidentity.Result, error)
+}
+
+// Collector finalizes reusable source-derived facts. It does not persist,
+// publish, or attach workflow choices/outcomes.
+type Collector interface {
+	Collect(context.Context, preparationstate.Request) (CollectedFacts, error)
+}
+
+// CollectedFacts is the collector-to-owner handoff. Identity and provider
+// metadata are supplied only by IdentityResolver.
+type CollectedFacts struct {
+	Naming      api.NamingFacts
+	Episode     api.EpisodeFacts
+	Media       api.MediaFacts
+	Disc        api.DiscFacts
+	Assessments api.ReleaseAssessments
+	Identity    externalidentity.ResolutionIntent
+	Diagnostics []api.PreparationDiagnostic
+	Resources   CollectedResources
+}
+
+// CollectedResources is the collector-to-owner handoff for local artifacts
+// required by later operations. Resources remain inside the prepared-release
+// module and are never included in PreparedRelease. Path fields are host
+// filesystem paths.
+type CollectedResources struct {
+	SourcePath            string
+	VideoPath             string
+	FileList              []string
+	MediaInfoJSONPath     string
+	MediaInfoTextPath     string
+	DVDIFOPath            string
+	DVDVOBPath            string
+	DVDVOBMediaInfoJSON   string
+	DVDVOBMediaInfoText   string
+	SceneNFOPath          string
+	DescriptionTemplate   string
+	SelectedBDMVPlaylists []api.PlaylistInfo
+	ClientEvidence        preparationstate.ClientEvidenceSnapshot
+}
+
+type clientEvidenceHydrator interface {
+	HydrateClientEvidence(context.Context, preparationstate.Request) (preparationstate.ClientEvidenceSnapshot, error)
+}
+
+// Module owns one current immutable generation and private envelope per
+// normalized source. It serializes mutation for the same source while allowing
+// different sources to prepare concurrently.
+type Module struct {
+	store     Store
+	identity  IdentityResolver
+	collector Collector
+	now       func() time.Time
+
+	mu        sync.RWMutex
+	envelopes map[string]envelope
+	gates     sourceGates
+}
+
+// New requires and borrows all persistence, identity, and collection ports.
+func New(store Store, identity IdentityResolver, collector Collector) (*Module, error) {
+	if store == nil {
+		return nil, errors.New("prepared release: store is required")
+	}
+	if identity == nil {
+		return nil, errors.New("prepared release: identity resolver is required")
+	}
+	if collector == nil {
+		return nil, errors.New("prepared release: fact collector is required")
+	}
+	return &Module{
+		store:     store,
+		identity:  identity,
+		collector: collector,
+		now:       func() time.Time { return time.Now().UTC() },
+		envelopes: make(map[string]envelope),
+	}, nil
+}
+
+// Prepare serializes same-source work and returns a detached copy of the exact
+// compatible generation when reuse is allowed. Otherwise it commits a new
+// generation before publishing it; failed collection or commit leaves the
+// prior published generation intact.
+func (m *Module) Prepare(ctx context.Context, input api.PrepareInput) (api.PrepareResult, error) {
+	if m == nil || m.store == nil || m.identity == nil || m.collector == nil {
+		return api.PrepareResult{}, errors.New("prepared release: module is not initialized")
+	}
+	if ctx == nil {
+		return api.PrepareResult{}, errors.New("prepared release: context is required")
+	}
+	normalized, err := normalizePrepareInput(input)
+	if err != nil {
+		return api.PrepareResult{}, err
+	}
+	input = normalized.input
+
+	releaseGate, err := m.gates.acquire(ctx, normalized.sourceKey)
+	if err != nil {
+		return api.PrepareResult{}, fmt.Errorf("prepared release: wait for source: %w", err)
+	}
+	defer releaseGate()
+	if err := ctx.Err(); err != nil {
+		return api.PrepareResult{}, fmt.Errorf("prepared release: prepare canceled: %w", err)
+	}
+
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhaseSourceInspection, api.PreparationProgressRunning, "Inspecting source layout."),
+	)
+	layout, err := sourcelayout.Resolve(ctx, input.SourcePath)
+	if err != nil {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseSourceInspection, api.PreparationProgressFailed, "Source inspection failed."),
+		)
+		return api.PrepareResult{}, fmt.Errorf("prepared release: resolve source layout: %w", err)
+	}
+	manifest, sourceFingerprint, err := inspectSource(ctx, input, layout)
+	if err != nil {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseSourceInspection, api.PreparationProgressFailed, "Source inspection failed."),
+		)
+		return api.PrepareResult{}, err
+	}
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhaseSourceInspection, api.PreparationProgressCompleted, "Source inspection complete."),
+	)
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhasePreparedCache, api.PreparationProgressRunning, "Checking prepared generation compatibility."),
+	)
+	compatibility, err := preparationCompatibility(input, sourceFingerprint)
+	if err != nil {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhasePreparedCache, api.PreparationProgressFailed, "Prepared cache check failed."),
+		)
+		return api.PrepareResult{}, err
+	}
+
+	current, hasCurrent, err := m.loadCurrent(ctx, input.SourcePath)
+	if err != nil {
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhasePreparedCache, api.PreparationProgressFailed, "Prepared cache check failed."),
+		)
+		return api.PrepareResult{}, err
+	}
+	// A remembered BDMV selection is repository state, not part of the input
+	// fingerprint. Keep that compatibility fallback non-cacheable so a changed
+	// remembered selection cannot silently reuse an older generation. Normal CLI
+	// and WebUI calls carry their resolved selection directly and remain reusable.
+	reuseAllowed := layout.DiscType != "BDMV" || input.Instructions.Playlist.Set
+	forceClientRefresh := input.Controls.ForceRecheck != nil && *input.Controls.ForceRecheck
+	if hasCurrent && reuseAllowed && !input.Force && !forceClientRefresh && current.Compatibility == compatibility {
+		if !m.hasPublishedGeneration(current.Source.SourcePath, current.Generation) {
+			hydrator, ok := m.collector.(clientEvidenceHydrator)
+			if !ok {
+				return api.PrepareResult{}, errors.New("prepared release: collector cannot hydrate private client evidence")
+			}
+			finish := api.BeginPreparationProgress(ctx, api.PreparationPhaseClientDiscovery, "Hydrating private client evidence.")
+			snapshot, hydrateErr := hydrator.HydrateClientEvidence(ctx, preparationstate.Request{
+				Input:    input,
+				Manifest: current.Source,
+				Layout:   layout,
+			})
+			finish(hydrateErr)
+			if hydrateErr != nil {
+				return api.PrepareResult{}, fmt.Errorf("prepared release: hydrate persisted client evidence: %w", hydrateErr)
+			}
+			owned := envelopeFromPersisted(current, input)
+			owned.resources.clientEvidence = preparationstate.CloneClientEvidenceSnapshot(snapshot)
+			m.publish(owned)
+		}
+		api.EmitPreparationProgress(
+			ctx,
+			api.NewPreparationProgressUpdate(api.PreparationPhasePreparedCache, api.PreparationProgressCompleted, "Reused the compatible prepared generation."),
+		)
+		skipReusedPreparationStages(ctx)
+		return cloneResult(api.PrepareResult{Release: current})
+	}
+	api.EmitPreparationProgress(
+		ctx,
+		api.NewPreparationProgressUpdate(api.PreparationPhasePreparedCache, api.PreparationProgressCompleted, "A new prepared generation is required."),
+	)
+
+	generation := api.PreparedGeneration(1)
+	if hasCurrent {
+		generation = current.Generation + 1
+		if generation == 0 {
+			return api.PrepareResult{}, errors.New("prepared release: generation overflow")
+		}
+	}
+	collected, err := m.collector.Collect(ctx, preparationstate.Request{
+		Input:    input,
+		Manifest: manifest,
+		Layout:   layout,
+	})
+	if err != nil {
+		return api.PrepareResult{}, fmt.Errorf("prepared release: collect facts: %w", err)
+	}
+	manifest.SelectedPlaylists = clonePreparedPlaylists(collected.Resources.SelectedBDMVPlaylists)
+	identityIntent := collected.Identity
+	mergeFactInstructions(&identityIntent, input.Instructions)
+	identityFinish := api.BeginPreparationProgress(ctx, api.PreparationPhaseCanonicalIdentity, "Resolving canonical identity.")
+	identityResult, err := m.identity.Resolve(ctx, externalidentity.Request{
+		SourcePath:        manifest.SourcePath,
+		SourceFingerprint: sourceFingerprint,
+		Generation:        generation,
+		Intent:            identityIntent,
+	})
+	if err != nil {
+		identityFinish(err)
+		return api.PrepareResult{}, fmt.Errorf("prepared release: resolve identity: %w", err)
+	}
+	identityFinish(nil)
+
+	preparedAt := m.now().UTC()
+	release := api.PreparedRelease{
+		Generation:       generation,
+		Compatibility:    compatibility,
+		Source:           manifest,
+		Naming:           collected.Naming,
+		Episode:          collected.Episode,
+		Media:            collected.Media,
+		Disc:             collected.Disc,
+		Identity:         identityResult.Identity,
+		ProviderMetadata: identityResult.ProviderMetadata,
+		Assessments:      normalizeAssessments(collected.Assessments),
+		PreparedAt:       preparedAt,
+	}
+	commitFinish := api.BeginPreparationProgress(ctx, api.PreparationPhaseGenerationCommit, "Committing prepared generation.")
+	if err := validateGeneration(release); err != nil {
+		commitFinish(err)
+		return api.PrepareResult{}, err
+	}
+	if err := m.store.CommitPreparedRelease(ctx, release); err != nil {
+		commitFinish(err)
+		return api.PrepareResult{}, fmt.Errorf("prepared release: commit generation: %w", err)
+	}
+
+	diagnostics := append([]api.PreparationDiagnostic(nil), collected.Diagnostics...)
+	diagnostics = append(diagnostics, identityResult.Diagnostics...)
+	owned := envelope{
+		result: api.PrepareResult{
+			Release:     release,
+			Diagnostics: diagnostics,
+		},
+		resources: mergePreparationResources(resourcesFromManifest(manifest, input), resourcesFromCollected(collected.Resources)),
+	}
+	m.publish(owned)
+	commitFinish(nil)
+	return cloneResult(owned.result)
+}
+
+// skipReusedPreparationStages emits terminal skipped updates for work supplied
+// by a compatible prepared generation.
+func skipReusedPreparationStages(ctx context.Context) {
+	for _, phase := range []api.PreparationProgressPhase{
+		api.PreparationPhaseSourceEvidence,
+		api.PreparationPhaseBDInfo,
+		api.PreparationPhaseClientDiscovery,
+		api.PreparationPhaseTrackerEvidence,
+		api.PreparationPhaseMediaInfoIdentity,
+		api.PreparationPhaseArrIdentity,
+		api.PreparationPhaseExternalIdentity,
+		api.PreparationPhaseMediaFacts,
+		api.PreparationPhaseCanonicalIdentity,
+		api.PreparationPhaseGenerationCommit,
+	} {
+		api.SkipPreparationProgress(ctx, phase, "Reused from the compatible prepared generation.")
+	}
+}
+
+// Export returns an opaque immutable seed for one exact published generation.
+func (m *Module) Export(ctx context.Context, ref api.ReleaseRef) (Seed, error) {
+	if m == nil {
+		return Seed{}, errors.New("prepared release: module is not initialized")
+	}
+	if ctx == nil {
+		return Seed{}, errors.New("prepared release: context is required")
+	}
+	normalized, err := normalizeSourcePath(ref.SourcePath)
+	if err != nil || ref.Generation == 0 {
+		return Seed{}, internalerrors.ErrInvalidInput
+	}
+	key := canonicalSourceKey(normalized)
+	if err := ctx.Err(); err != nil {
+		return Seed{}, fmt.Errorf("prepared release: export canceled: %w", err)
+	}
+	m.mu.RLock()
+	owned, ok := m.envelopes[key]
+	m.mu.RUnlock()
+	if !ok || owned.result.Release.Generation != ref.Generation {
+		return Seed{}, &StalePreparationError{
+			SourcePath: key,
+			Generation: ref.Generation,
+			Reason:     StaleReasonGeneration,
+		}
+	}
+	cloned, err := cloneEnvelope(owned)
+	if err != nil {
+		return Seed{}, err
+	}
+	return Seed{payload: cloned}, nil
+}
+
+// ResolveResult validates one exact published generation and returns a cloned
+// public projection without exposing preparation resources.
+func (m *Module) ResolveResult(ctx context.Context, ref api.ReleaseRef) (api.PrepareResult, error) {
+	owned, err := m.resolveEnvelope(ctx, ref)
+	if err != nil {
+		return api.PrepareResult{}, err
+	}
+	return cloneResult(owned.result)
+}
+
+// Import validates and publishes an opaque seed. Persistence completes before
+// the in-memory generation becomes visible.
+func (m *Module) Import(ctx context.Context, seed Seed) (api.ReleaseRef, error) {
+	if m == nil || m.store == nil {
+		return api.ReleaseRef{}, errors.New("prepared release: module is not initialized")
+	}
+	if ctx == nil {
+		return api.ReleaseRef{}, errors.New("prepared release: context is required")
+	}
+	owned, err := seed.clonePayload()
+	if err != nil {
+		return api.ReleaseRef{}, err
+	}
+	release := owned.result.Release
+	normalized, err := normalizeSourcePath(release.Source.SourcePath)
+	if err != nil || release.Generation == 0 {
+		return api.ReleaseRef{}, internalerrors.ErrInvalidInput
+	}
+	key := canonicalSourceKey(normalized)
+	if err := validateGeneration(release); err != nil {
+		return api.ReleaseRef{}, err
+	}
+
+	releaseGate, err := m.gates.acquire(ctx, key)
+	if err != nil {
+		return api.ReleaseRef{}, fmt.Errorf("prepared release: wait to import source: %w", err)
+	}
+	defer releaseGate()
+	current, found, err := m.loadCurrent(ctx, release.Source.SourcePath)
+	if err != nil {
+		return api.ReleaseRef{}, err
+	}
+	if err := validateSeedSource(ctx, owned); err != nil {
+		return api.ReleaseRef{}, err
+	}
+	if found && current.Generation > release.Generation {
+		return api.ReleaseRef{}, &StalePreparationError{
+			SourcePath: key,
+			Generation: release.Generation,
+			Reason:     StaleReasonGeneration,
+		}
+	}
+	if found && current.Generation == release.Generation && current.Compatibility != release.Compatibility {
+		return api.ReleaseRef{}, &IncompatiblePreparationError{SourcePath: key, Reason: "generation compatibility differs"}
+	}
+	if !found || current.Generation != release.Generation {
+		if err := m.store.CommitPreparedRelease(ctx, release); err != nil {
+			return api.ReleaseRef{}, fmt.Errorf("prepared release: import generation: %w", err)
+		}
+	}
+	m.publish(owned)
+	return api.ReleaseRef{SourcePath: release.Source.SourcePath, Generation: release.Generation}, nil
+}
+
+// Purge removes persisted and published prepared state for sourcePath.
+func (m *Module) Purge(ctx context.Context, sourcePath string) error {
+	if m == nil || m.store == nil {
+		return errors.New("prepared release: module is not initialized")
+	}
+	normalized, err := normalizeSourcePath(sourcePath)
+	if err != nil {
+		return err
+	}
+	key := canonicalSourceKey(normalized)
+	releaseGate, err := m.gates.acquire(ctx, key)
+	if err != nil {
+		return fmt.Errorf("prepared release: wait to purge source: %w", err)
+	}
+	defer releaseGate()
+	if err := m.store.PurgePreparedRelease(ctx, normalized); err != nil {
+		return fmt.Errorf("prepared release: purge: %w", err)
+	}
+	m.mu.Lock()
+	delete(m.envelopes, key)
+	m.mu.Unlock()
+	return nil
+}
+
+func (m *Module) loadCurrent(ctx context.Context, sourcePath string) (api.PreparedRelease, bool, error) {
+	release, err := m.store.LoadPreparedRelease(ctx, sourcePath)
+	if err == nil {
+		cloned, cloneErr := release.Clone()
+		if cloneErr != nil {
+			return api.PreparedRelease{}, false, fmt.Errorf("prepared release: clone current release: %w", cloneErr)
+		}
+		return cloned, true, nil
+	}
+	if errors.Is(err, internalerrors.ErrNotFound) {
+		return api.PreparedRelease{}, false, nil
+	}
+	return api.PreparedRelease{}, false, fmt.Errorf("prepared release: load current: %w", err)
+}
+
+func (m *Module) publish(owned envelope) {
+	key := canonicalSourceKey(owned.result.Release.Source.SourcePath)
+	cloned, err := cloneEnvelope(owned)
+	if err != nil {
+		panic(fmt.Sprintf("prepared release: clone validated generation for publication: %v", err))
+	}
+	m.mu.Lock()
+	m.envelopes[key] = cloned
+	m.mu.Unlock()
+}
+
+func (m *Module) hasPublishedGeneration(sourcePath string, generation api.PreparedGeneration) bool {
+	key := canonicalSourceKey(sourcePath)
+	m.mu.RLock()
+	current, ok := m.envelopes[key]
+	m.mu.RUnlock()
+	return ok && current.result.Release.Generation == generation
+}
+
+func mergeFactInstructions(intent *externalidentity.ResolutionIntent, instructions api.ReleaseFactInstructions) {
+	intent.ProviderOverrides = cloneExternalIDOverrides(instructions.Identity)
+	if instructions.Category != nil {
+		value := *instructions.Category
+		intent.CategoryOverride = &value
+	}
+}
+
+func normalizeAssessments(value api.ReleaseAssessments) api.ReleaseAssessments {
+	if value.MediaInfoUniqueID == "" {
+		value.MediaInfoUniqueID = api.UniqueIDStatusUnknown
+	}
+	if value.MediaInfoEncodeSettings == "" {
+		value.MediaInfoEncodeSettings = api.EncodeSettingsStatusUnknown
+	}
+	if value.Naming.Status == "" {
+		value.Naming.Status = api.NamingStatusUnknown
+	}
+	value.Naming.Missing = append([]api.NamingRequirement(nil), value.Naming.Missing...)
+	return value
+}
+
+func validateGeneration(release api.PreparedRelease) error {
+	if release.Generation == 0 || canonicalSourceKey(release.Source.SourcePath) == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	if release.Compatibility.ContractVersion != ContractVersion {
+		return &IncompatiblePreparationError{SourcePath: release.Source.SourcePath, Reason: "unsupported prepared-release contract"}
+	}
+	if strings.TrimSpace(release.Compatibility.SourceFingerprint) == "" ||
+		strings.TrimSpace(release.Compatibility.FactInstructionFingerprint) == "" ||
+		strings.TrimSpace(release.Compatibility.PolicyFingerprint) == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	if release.Identity.Generation != release.Generation || release.ProviderMetadata.Generation != release.Generation ||
+		canonicalSourceKey(release.Identity.SourcePath) != canonicalSourceKey(release.Source.SourcePath) ||
+		canonicalSourceKey(release.ProviderMetadata.SourcePath) != canonicalSourceKey(release.Source.SourcePath) {
+		return &IncompatiblePreparationError{SourcePath: release.Source.SourcePath, Reason: "generation components differ"}
+	}
+	if reason := providerIdentityMismatch(release); reason != "" {
+		return &IncompatiblePreparationError{SourcePath: release.Source.SourcePath, Reason: reason}
+	}
+	return nil
+}
+
+func providerIdentityMismatch(release api.PreparedRelease) string {
+	metadata := release.ProviderMetadata
+	identity := release.Identity
+	checks := []struct {
+		provider api.IdentityProvider
+		present  bool
+		ownID    int
+		identity int
+	}{
+		{
+			provider: api.IdentityProviderTMDB,
+			present:  metadata.TMDB != nil,
+			ownID:    metadataIDTMDB(metadata.TMDB),
+			identity: identity.TMDBID,
+		},
+		{
+			provider: api.IdentityProviderIMDB,
+			present:  metadata.IMDB != nil,
+			ownID:    metadataIDIMDB(metadata.IMDB),
+			identity: identity.IMDBID,
+		},
+		{
+			provider: api.IdentityProviderTVDB,
+			present:  metadata.TVDB != nil,
+			ownID:    metadataIDTVDB(metadata.TVDB),
+			identity: identity.TVDBID,
+		},
+		{
+			provider: api.IdentityProviderTVmaze,
+			present:  metadata.TVmaze != nil,
+			ownID:    metadataIDTVmaze(metadata.TVmaze),
+			identity: identity.TVmazeID,
+		},
+		{
+			provider: api.IdentityProviderMAL,
+			present:  metadata.AniList != nil,
+			ownID:    metadataIDMAL(metadata.AniList),
+			identity: identity.MALID,
+		},
+	}
+	for _, check := range checks {
+		if check.present && (check.ownID <= 0 || check.identity <= 0 || check.ownID != check.identity) {
+			return fmt.Sprintf("%s provider metadata does not match canonical identity", check.provider)
+		}
+	}
+	return ""
+}
+
+func metadataIDTMDB(value *api.TMDBMetadata) int {
+	if value == nil {
+		return 0
+	}
+	return value.TMDBID
+}
+
+func metadataIDIMDB(value *api.IMDBMetadata) int {
+	if value == nil {
+		return 0
+	}
+	return value.IMDBID
+}
+
+func metadataIDTVDB(value *api.TVDBMetadata) int {
+	if value == nil {
+		return 0
+	}
+	return value.TVDBID
+}
+
+func metadataIDTVmaze(value *api.TVmazeMetadata) int {
+	if value == nil {
+		return 0
+	}
+	return value.TVmazeID
+}
+
+func metadataIDMAL(value *api.AniListMetadata) int {
+	if value == nil {
+		return 0
+	}
+	return value.MALID
+}
+
+func cloneResult(result api.PrepareResult) (api.PrepareResult, error) {
+	cloned, err := result.Clone()
+	if err != nil {
+		return api.PrepareResult{}, fmt.Errorf("prepared release: clone result: %w", err)
+	}
+	return cloned, nil
+}
+
+func cloneExternalIDOverrides(value api.ExternalIDOverrides) api.ExternalIDOverrides {
+	return api.ExternalIDOverrides{
+		TMDBID:   cloneInt(value.TMDBID),
+		IMDBID:   cloneInt(value.IMDBID),
+		TVDBID:   cloneInt(value.TVDBID),
+		TVmazeID: cloneInt(value.TVmazeID),
+		MALID:    cloneInt(value.MALID),
+	}
+}
+
+func cloneInt(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+type envelope struct {
+	result    api.PrepareResult
+	resources preparationResources
+}
+
+type preparationResources struct {
+	sourcePath            string
+	playlist              api.PlaylistInstruction
+	videoPath             string
+	fileList              []string
+	mediaInfoJSONPath     string
+	mediaInfoTextPath     string
+	dvdIFOPath            string
+	dvdVOBPath            string
+	dvdVOBMediaInfoJSON   string
+	dvdVOBMediaInfoText   string
+	sceneNFOPath          string
+	descriptionTemplate   string
+	selectedBDMVPlaylists []api.PlaylistInfo
+	clientEvidence        preparationstate.ClientEvidenceSnapshot
+}
+
+func resourcesFromManifest(manifest api.SourceManifest, input api.PrepareInput) preparationResources {
+	playlist := api.PlaylistInstruction{
+		Set:      input.Instructions.Playlist.Set,
+		Selected: append([]string(nil), input.Instructions.Playlist.Selected...),
+		UseAll:   input.Instructions.Playlist.UseAll,
+	}
+	return preparationResources{sourcePath: manifest.SourcePath, playlist: playlist}
+}
+
+func envelopeFromPersisted(release api.PreparedRelease, input api.PrepareInput) envelope {
+	return envelope{
+		result:    api.PrepareResult{Release: release},
+		resources: resourcesFromManifest(release.Source, input),
+	}
+}
+
+func mergePreparationResources(base preparationResources, collected preparationResources) preparationResources {
+	if strings.TrimSpace(collected.sourcePath) != "" {
+		base.sourcePath = collected.sourcePath
+	}
+	base.videoPath = collected.videoPath
+	base.fileList = append([]string(nil), collected.fileList...)
+	base.mediaInfoJSONPath = collected.mediaInfoJSONPath
+	base.mediaInfoTextPath = collected.mediaInfoTextPath
+	base.dvdIFOPath = collected.dvdIFOPath
+	base.dvdVOBPath = collected.dvdVOBPath
+	base.dvdVOBMediaInfoJSON = collected.dvdVOBMediaInfoJSON
+	base.dvdVOBMediaInfoText = collected.dvdVOBMediaInfoText
+	base.sceneNFOPath = collected.sceneNFOPath
+	base.descriptionTemplate = collected.descriptionTemplate
+	base.selectedBDMVPlaylists = collected.selectedBDMVPlaylists
+	base.clientEvidence = preparationstate.CloneClientEvidenceSnapshot(collected.clientEvidence)
+	return base
+}
+
+func resourcesFromCollected(collected CollectedResources) preparationResources {
+	return preparationResources{
+		sourcePath:            collected.SourcePath,
+		videoPath:             collected.VideoPath,
+		fileList:              append([]string(nil), collected.FileList...),
+		mediaInfoJSONPath:     collected.MediaInfoJSONPath,
+		mediaInfoTextPath:     collected.MediaInfoTextPath,
+		dvdIFOPath:            collected.DVDIFOPath,
+		dvdVOBPath:            collected.DVDVOBPath,
+		dvdVOBMediaInfoJSON:   collected.DVDVOBMediaInfoJSON,
+		dvdVOBMediaInfoText:   collected.DVDVOBMediaInfoText,
+		sceneNFOPath:          collected.SceneNFOPath,
+		descriptionTemplate:   collected.DescriptionTemplate,
+		selectedBDMVPlaylists: clonePreparedPlaylists(collected.SelectedBDMVPlaylists),
+		clientEvidence:        preparationstate.CloneClientEvidenceSnapshot(collected.ClientEvidence),
+	}
+}
+
+func cloneEnvelope(value envelope) (envelope, error) {
+	clonedResult, err := value.result.Clone()
+	if err != nil {
+		return envelope{}, fmt.Errorf("prepared release: clone envelope: %w", err)
+	}
+	cloned := envelope{
+		result: clonedResult,
+		resources: preparationResources{
+			sourcePath:          value.resources.sourcePath,
+			videoPath:           value.resources.videoPath,
+			fileList:            append([]string(nil), value.resources.fileList...),
+			mediaInfoJSONPath:   value.resources.mediaInfoJSONPath,
+			mediaInfoTextPath:   value.resources.mediaInfoTextPath,
+			dvdIFOPath:          value.resources.dvdIFOPath,
+			dvdVOBPath:          value.resources.dvdVOBPath,
+			dvdVOBMediaInfoJSON: value.resources.dvdVOBMediaInfoJSON,
+			dvdVOBMediaInfoText: value.resources.dvdVOBMediaInfoText,
+			sceneNFOPath:        value.resources.sceneNFOPath,
+			descriptionTemplate: value.resources.descriptionTemplate,
+			playlist: api.PlaylistInstruction{
+				Set:      value.resources.playlist.Set,
+				Selected: append([]string(nil), value.resources.playlist.Selected...),
+				UseAll:   value.resources.playlist.UseAll,
+			},
+			selectedBDMVPlaylists: clonePreparedPlaylists(value.resources.selectedBDMVPlaylists),
+			clientEvidence:        preparationstate.CloneClientEvidenceSnapshot(value.resources.clientEvidence),
+		},
+	}
+	return cloned, nil
+}
+
+func clonePreparedPlaylists(value []api.PlaylistInfo) []api.PlaylistInfo {
+	cloned, err := cloneWithJSON(value)
+	if err != nil {
+		panic(fmt.Sprintf("prepared release: clone playlists: %v", err))
+	}
+	return cloned
+}
+
+func cloneWithJSON[T any](value T) (T, error) {
+	var cloned T
+	payload, err := json.Marshal(value)
+	if err != nil {
+		return cloned, fmt.Errorf("prepared release: clone value: marshal: %w", err)
+	}
+	if err := json.Unmarshal(payload, &cloned); err != nil {
+		return cloned, fmt.Errorf("prepared release: clone value: unmarshal: %w", err)
+	}
+	return cloned, nil
+}
+
+// Seed is an opaque prepared-generation transfer value. Its payload contains
+// preparation resources but no workflow choices or outcomes.
+type Seed struct {
+	payload envelope
+}
+
+func (s Seed) clonePayload() (envelope, error) {
+	if s.payload.result.Release.Generation == 0 {
+		return envelope{}, internalerrors.ErrInvalidInput
+	}
+	return cloneEnvelope(s.payload)
+}
+
+// validateSeedSource rejects transferred generations whose current source
+// fingerprint no longer matches the committed preparation resources.
+func validateSeedSource(ctx context.Context, owned envelope) error {
+	sourcePath := strings.TrimSpace(owned.resources.sourcePath)
+	if sourcePath == "" {
+		return &IncompatiblePreparationError{
+			SourcePath: owned.result.Release.Source.SourcePath,
+			Reason:     "seed has no source resources",
+		}
+	}
+	input := api.PrepareInput{
+		SourcePath: sourcePath,
+		Instructions: api.ReleaseFactInstructions{
+			Playlist: owned.resources.playlist,
+		},
+	}
+	layout, err := sourcelayout.Resolve(ctx, sourcePath)
+	if err != nil {
+		return fmt.Errorf("prepared release: validate source layout: %w", err)
+	}
+	_, fingerprint, err := inspectSource(ctx, input, layout)
+	if err != nil {
+		return err
+	}
+	if fingerprint != owned.result.Release.Compatibility.SourceFingerprint {
+		return &StalePreparationError{
+			SourcePath: owned.result.Release.Source.SourcePath,
+			Generation: owned.result.Release.Generation,
+			Reason:     StaleReasonFingerprint,
+		}
+	}
+	return nil
+}
+
+// StaleReason classifies why an exact prepared generation cannot be used.
+type StaleReason string
+
+const (
+	// StaleReasonGeneration means the requested generation is not current/published.
+	StaleReasonGeneration StaleReason = "generation"
+	// StaleReasonFingerprint means source inventory no longer matches.
+	StaleReasonFingerprint StaleReason = "fingerprint"
+)
+
+// StalePreparationError reports an exact-generation compatibility failure.
+type StalePreparationError struct {
+	SourcePath string
+	Generation api.PreparedGeneration
+	Reason     StaleReason
+}
+
+func (e *StalePreparationError) Error() string {
+	if e == nil {
+		return "stale prepared release"
+	}
+	return fmt.Sprintf("prepared release is stale: source=%s generation=%d reason=%s", e.SourcePath, e.Generation, e.Reason)
+}
+
+// IncompatiblePreparationError reports a prepared contract/lineage mismatch.
+type IncompatiblePreparationError struct {
+	SourcePath string
+	Reason     string
+}
+
+func (e *IncompatiblePreparationError) Error() string {
+	if e == nil {
+		return "incompatible prepared release"
+	}
+	return fmt.Sprintf("prepared release is incompatible: source=%s reason=%s", e.SourcePath, e.Reason)
+}
diff --git a/internal/preparedrelease/module_test.go b/internal/preparedrelease/module_test.go
new file mode 100644
index 00000000..cd6b9c10
--- /dev/null
+++ b/internal/preparedrelease/module_test.go
@@ -0,0 +1,772 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/externalidentity"
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestPrepareUsesExactCompatibilityAndPublishesConcreteAssessments(t *testing.T) {
+	t.Parallel()
+	path := writePreparedTestFile(t, "source.mkv", "first")
+	store := newMemoryStore()
+	collector := &recordingCollector{}
+	module := newTestModule(t, store, collector)
+	input := api.PrepareInput{
+		SourcePath: path,
+		Intent:     api.PreparationIntentPreview,
+		Instructions: api.ReleaseFactInstructions{
+			ReleaseName: api.ReleaseNameOverrides{},
+		},
+		Policy: api.PreparationPolicy{KeepFolder: true},
+	}
+
+	first, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() first error = %v", err)
+	}
+	if first.Release.Generation != 1 {
+		t.Fatalf("generation = %d, want 1", first.Release.Generation)
+	}
+	if first.Release.Assessments.MediaInfoUniqueID != api.UniqueIDStatusPresent ||
+		first.Release.Assessments.MediaInfoEncodeSettings != api.EncodeSettingsStatusMissing {
+		t.Fatalf("assessments = %#v", first.Release.Assessments)
+	}
+
+	input.Intent = api.PreparationIntentUpload
+	reused, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() reuse error = %v", err)
+	}
+	if reused.Release.Generation != first.Release.Generation {
+		t.Fatalf("intent-specific generation = %d, want %d", reused.Release.Generation, first.Release.Generation)
+	}
+	if collector.callCount() != 1 || store.commitCount() != 1 {
+		t.Fatalf("reuse calls collector=%d commits=%d, want 1/1", collector.callCount(), store.commitCount())
+	}
+
+	name := "Example.Release.2026.1080p-GRP"
+	input.Instructions.ReleaseName.Type = &name
+	second, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() instruction change error = %v", err)
+	}
+	if second.Release.Generation != 2 {
+		t.Fatalf("instruction generation = %d, want 2", second.Release.Generation)
+	}
+
+	input.Policy.OnlyID = true
+	third, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() policy change error = %v", err)
+	}
+	if third.Release.Generation != 3 {
+		t.Fatalf("policy generation = %d, want 3", third.Release.Generation)
+	}
+
+	if err := os.WriteFile(path, []byte("changed source"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	fourth, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() source change error = %v", err)
+	}
+	if fourth.Release.Generation != 4 {
+		t.Fatalf("source generation = %d, want 4", fourth.Release.Generation)
+	}
+}
+
+func TestPrepareReportsCanonicalOwnerStagesAndReuse(t *testing.T) {
+	t.Parallel()
+	path := writePreparedTestFile(t, "source.mkv", "synthetic media")
+	module := newTestModule(t, newMemoryStore(), &recordingCollector{})
+	var progress []api.PreparationProgressUpdate
+	ctx := api.WithPreparationProgressReporter(context.Background(), func(update api.PreparationProgressUpdate) {
+		progress = append(progress, update)
+	})
+
+	if _, err := module.Prepare(ctx, api.PrepareInput{SourcePath: path}); err != nil {
+		t.Fatalf("prepare generation: %v", err)
+	}
+	for _, phase := range []api.PreparationProgressPhase{
+		api.PreparationPhaseSourceInspection,
+		api.PreparationPhasePreparedCache,
+		api.PreparationPhaseCanonicalIdentity,
+		api.PreparationPhaseGenerationCommit,
+	} {
+		if !hasPreparationProgress(progress, phase, api.PreparationProgressCompleted) {
+			t.Fatalf("canonical owner phase %q did not complete", phase)
+		}
+	}
+
+	progress = nil
+	if _, err := module.Prepare(ctx, api.PrepareInput{SourcePath: path}); err != nil {
+		t.Fatalf("reuse generation: %v", err)
+	}
+	if !hasPreparationProgress(progress, api.PreparationPhasePreparedCache, api.PreparationProgressCompleted) ||
+		!hasPreparationProgress(progress, api.PreparationPhaseSourceEvidence, api.PreparationProgressSkipped) {
+		t.Fatal("compatible generation reuse did not report cache and skipped collection stages")
+	}
+}
+
+func TestPrepareHydratesPersistedClientEvidenceOnceAfterRestart(t *testing.T) {
+	t.Parallel()
+
+	path := writePreparedTestFile(t, "source.mkv", "synthetic media")
+	store := newMemoryStore()
+	initialCollector := newClientEvidenceTestCollector(clientEvidenceTestSnapshot("initial-hash"))
+	initial := newTestModule(t, store, initialCollector)
+	prepared, err := initial.Prepare(context.Background(), api.PrepareInput{SourcePath: path})
+	if err != nil {
+		t.Fatalf("initial prepare: %v", err)
+	}
+
+	restartedCollector := newClientEvidenceTestCollector(clientEvidenceTestSnapshot("hydrated-hash"))
+	restarted := newTestModule(t, store, restartedCollector)
+	reused, err := restarted.Prepare(context.Background(), api.PrepareInput{SourcePath: path})
+	if err != nil {
+		t.Fatalf("restart reuse: %v", err)
+	}
+	if reused.Release.Generation != prepared.Release.Generation {
+		t.Fatalf("restart generation = %d, want %d", reused.Release.Generation, prepared.Release.Generation)
+	}
+	if restartedCollector.collectCount() != 0 || restartedCollector.hydrateCount() != 1 {
+		t.Fatalf(
+			"restart collector calls collect=%d hydrate=%d, want 0/1",
+			restartedCollector.collectCount(),
+			restartedCollector.hydrateCount(),
+		)
+	}
+	if _, err := restarted.Prepare(context.Background(), api.PrepareInput{SourcePath: path}); err != nil {
+		t.Fatalf("second restart reuse: %v", err)
+	}
+	if restartedCollector.hydrateCount() != 1 {
+		t.Fatalf("private evidence hydrated %d times, want 1", restartedCollector.hydrateCount())
+	}
+
+	ref := api.ReleaseRef{SourcePath: path, Generation: reused.Release.Generation}
+	upload, err := restarted.ResolveUploadSubject(context.Background(), api.UploadReviewInput{Release: ref})
+	if err != nil {
+		t.Fatalf("resolve hydrated upload subject: %v", err)
+	}
+	if upload.InfoHash != "hydrated-hash" || upload.TrackerIDs["ant"] != "hydrated-id" ||
+		len(upload.MatchedTrackers) != 1 || upload.MatchedTrackers[0] != "ANT" {
+		t.Fatalf("hydrated upload evidence = %#v", upload)
+	}
+	upload.TrackerIDs["ant"] = "mutated"
+	upload.MatchedTrackers[0] = "MUTATED"
+	duplicate, err := restarted.ResolveDuplicateSubject(context.Background(), api.DuplicateCheckInput{Release: ref})
+	if err != nil {
+		t.Fatalf("resolve detached duplicate subject: %v", err)
+	}
+	if duplicate.TrackerIDs["ant"] != "hydrated-id" || duplicate.MatchedTrackers[0] != "ANT" {
+		t.Fatalf("private snapshot was aliased: %#v", duplicate)
+	}
+}
+
+func TestPrepareForceRecheckBuildsOneFreshGeneration(t *testing.T) {
+	t.Parallel()
+
+	path := writePreparedTestFile(t, "source.mkv", "synthetic media")
+	collector := newClientEvidenceTestCollector(clientEvidenceTestSnapshot("client-hash"))
+	module := newTestModule(t, newMemoryStore(), collector)
+	first, err := module.Prepare(context.Background(), api.PrepareInput{SourcePath: path})
+	if err != nil {
+		t.Fatalf("initial prepare: %v", err)
+	}
+	force := true
+	second, err := module.Prepare(context.Background(), api.PrepareInput{
+		SourcePath: path,
+		Controls:   api.PreparationControls{ForceRecheck: &force},
+	})
+	if err != nil {
+		t.Fatalf("forced prepare: %v", err)
+	}
+	if second.Release.Generation != first.Release.Generation+1 {
+		t.Fatalf("forced generation = %d, want %d", second.Release.Generation, first.Release.Generation+1)
+	}
+	if collector.collectCount() != 2 || collector.hydrateCount() != 0 {
+		t.Fatalf("forced preparation calls collect=%d hydrate=%d, want 2/0", collector.collectCount(), collector.hydrateCount())
+	}
+	ref := api.ReleaseRef{SourcePath: path, Generation: second.Release.Generation}
+	upload, err := module.ResolveUploadSubject(context.Background(), api.UploadReviewInput{Release: ref})
+	if err != nil {
+		t.Fatalf("resolve forced upload subject: %v", err)
+	}
+	if upload.InfoHash != "client-hash" {
+		t.Fatalf("forced client evidence = %#v", upload)
+	}
+}
+
+func hasPreparationProgress(
+	updates []api.PreparationProgressUpdate,
+	phase api.PreparationProgressPhase,
+	status api.PreparationProgressStatus,
+) bool {
+	for _, update := range updates {
+		if update.Phase == phase && update.Status == status {
+			return true
+		}
+	}
+	return false
+}
+
+func TestPrepareDoesNotCacheImplicitBDMVPlaylistSelection(t *testing.T) {
+	t.Parallel()
+	sourcePath := filepath.Join(t.TempDir(), "disc")
+	if err := os.MkdirAll(filepath.Join(sourcePath, "BDMV", "PLAYLIST"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Join(sourcePath, "BDMV", "STREAM"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	collector := &recordingCollector{}
+	module := newTestModule(t, newMemoryStore(), collector)
+	input := api.PrepareInput{SourcePath: sourcePath}
+
+	first, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() first error = %v", err)
+	}
+	second, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() second error = %v", err)
+	}
+	if second.Release.Generation != first.Release.Generation+1 || collector.callCount() != 2 {
+		t.Fatalf("implicit BDMV reuse generation=%d calls=%d, want generation=%d calls=2", second.Release.Generation, collector.callCount(), first.Release.Generation+1)
+	}
+
+	input.Instructions.Playlist = api.PlaylistInstruction{Set: true, Selected: []string{"00001.MPLS"}}
+	third, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() direct instruction error = %v", err)
+	}
+	fourth, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatalf("Prepare() direct instruction reuse error = %v", err)
+	}
+	if fourth.Release.Generation != third.Release.Generation || collector.callCount() != 3 {
+		t.Fatalf("direct BDMV reuse generation=%d calls=%d, want generation=%d calls=3", fourth.Release.Generation, collector.callCount(), third.Release.Generation)
+	}
+}
+
+func TestPreparationCompatibilityIncludesEvidencePolicyAndExcludesOneShotControls(t *testing.T) {
+	t.Parallel()
+
+	stringPtr := func(value string) *string { return &value }
+	boolPtr := func(value bool) *bool { return &value }
+	baseline := api.PrepareInput{SourcePath: "Example.Release.2026.mkv"}
+	want, err := preparationCompatibility(baseline, "source")
+	if err != nil {
+		t.Fatalf("baseline compatibility: %v", err)
+	}
+	included := []struct {
+		name   string
+		mutate func(*api.PrepareInput)
+	}{
+		{name: "fact instructions", mutate: func(input *api.PrepareInput) { input.Instructions.TrackerIDs = map[string]string{"btn": "123"} }},
+		{name: "keep folder", mutate: func(input *api.PrepareInput) { input.Policy.KeepFolder = true }},
+		{name: "keep images", mutate: func(input *api.PrepareInput) { input.Policy.KeepImages = true }},
+		{name: "only id", mutate: func(input *api.PrepareInput) { input.Policy.OnlyID = true }},
+		{name: "skip client", mutate: func(input *api.PrepareInput) { input.Search.Skip = true }},
+		{name: "client selector", mutate: func(input *api.PrepareInput) { input.Search.Client = stringPtr("qbit") }},
+	}
+	for _, test := range included {
+		t.Run(test.name, func(t *testing.T) {
+			input := baseline
+			test.mutate(&input)
+			got, compatibilityErr := preparationCompatibility(input, "source")
+			if compatibilityErr != nil {
+				t.Fatalf("compatibility: %v", compatibilityErr)
+			}
+			if got == want {
+				t.Fatalf("included change did not affect compatibility: %#v", got)
+			}
+		})
+	}
+	excluded := []struct {
+		name   string
+		mutate func(*api.PrepareInput)
+	}{
+		{name: "intent", mutate: func(input *api.PrepareInput) { input.Intent = api.PreparationIntentUpload }},
+		{name: "interaction", mutate: func(input *api.PrepareInput) { input.Controls.Interaction = api.InteractionModeInteractive }},
+		{name: "rescan permission", mutate: func(input *api.PrepareInput) { input.Controls.ConfirmBDMVRescan = true }},
+		{name: "force recheck", mutate: func(input *api.PrepareInput) { input.Controls.ForceRecheck = boolPtr(true) }},
+		{name: "force preparation", mutate: func(input *api.PrepareInput) { input.Force = true }},
+	}
+	for _, test := range excluded {
+		t.Run(test.name, func(t *testing.T) {
+			input := baseline
+			test.mutate(&input)
+			got, compatibilityErr := preparationCompatibility(input, "source")
+			if compatibilityErr != nil {
+				t.Fatalf("compatibility: %v", compatibilityErr)
+			}
+			if got != want {
+				t.Fatalf("one-shot change affected compatibility: got %#v want %#v", got, want)
+			}
+		})
+	}
+}
+
+func TestOperationSubjectsUseExactGenerationAndDetachedFacts(t *testing.T) {
+	t.Parallel()
+
+	path := writePreparedTestFile(t, "source.mkv", "source")
+	module := newTestModule(t, newMemoryStore(), &recordingCollector{})
+	prepared, err := module.Prepare(context.Background(), api.PrepareInput{SourcePath: path})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ref := api.ReleaseRef{SourcePath: path, Generation: prepared.Release.Generation}
+	upload, err := module.ResolveUploadSubject(context.Background(), api.UploadReviewInput{
+		Release:  ref,
+		Trackers: []string{"AITHER"},
+		Options:  api.UploadOptions{KeepImages: true},
+	})
+	if err != nil {
+		t.Fatalf("ResolveUploadSubject() error = %v", err)
+	}
+	if upload.SourcePath != path || upload.ReleaseName != "Example.Release.2026.1080p-GRP" || len(upload.Trackers) != 1 {
+		t.Fatalf("upload subject = %#v", upload)
+	}
+	if upload.Assessments.MediaInfoUniqueID != api.UniqueIDStatusPresent ||
+		upload.Assessments.MediaInfoEncodeSettings != api.EncodeSettingsStatusMissing {
+		t.Fatalf("upload assessments = %#v", upload.Assessments)
+	}
+	upload.Trackers[0] = "changed"
+
+	duplicate, err := module.ResolveDuplicateSubject(context.Background(), api.DuplicateCheckInput{Release: ref})
+	if err != nil {
+		t.Fatalf("ResolveDuplicateSubject() error = %v", err)
+	}
+	if duplicate.SourcePath != path || duplicate.ReleaseName != "Example.Release.2026.1080p-GRP" {
+		t.Fatalf("duplicate subject = %#v", duplicate)
+	}
+
+	_, err = module.ResolveDuplicateSubject(context.Background(), api.DuplicateCheckInput{
+		Release: api.ReleaseRef{SourcePath: path, Generation: prepared.Release.Generation + 1},
+	})
+	var stale *StalePreparationError
+	if !errors.As(err, &stale) || stale.Reason != StaleReasonGeneration {
+		t.Fatalf("wrong generation error = %v", err)
+	}
+}
+
+func TestPrepareCommitFailureLeavesPriorGenerationPublished(t *testing.T) {
+	t.Parallel()
+	path := writePreparedTestFile(t, "source.mkv", "source")
+	store := newMemoryStore()
+	module := newTestModule(t, store, &recordingCollector{})
+	input := api.PrepareInput{SourcePath: path}
+	first, err := module.Prepare(context.Background(), input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store.setCommitError(errors.New("forced commit failure"))
+	input.Policy.OnlyID = true
+	if _, err := module.Prepare(context.Background(), input); err == nil {
+		t.Fatal("Prepare() error = nil, want commit failure")
+	}
+
+	seed, err := module.Export(context.Background(), api.ReleaseRef{
+		SourcePath: path,
+		Generation: first.Release.Generation,
+	})
+	if err != nil {
+		t.Fatalf("Export() prior generation error = %v", err)
+	}
+	if seed.payload.result.Release.Generation != 1 {
+		t.Fatalf("published generation = %d, want 1", seed.payload.result.Release.Generation)
+	}
+	current, err := store.LoadPreparedRelease(context.Background(), first.Release.Source.SourcePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if current.Generation != 1 {
+		t.Fatalf("persisted generation = %d, want 1", current.Generation)
+	}
+}
+
+func TestSeedImportRechecksSourceFingerprint(t *testing.T) {
+	t.Parallel()
+	path := writePreparedTestFile(t, "source.mkv", "source")
+	sourceStore := newMemoryStore()
+	source := newTestModule(t, sourceStore, &recordingCollector{})
+	prepared, err := source.Prepare(context.Background(), api.PrepareInput{SourcePath: path})
+	if err != nil {
+		t.Fatal(err)
+	}
+	seed, err := source.Export(context.Background(), api.ReleaseRef{
+		SourcePath: path,
+		Generation: prepared.Release.Generation,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	target := newTestModule(t, newMemoryStore(), &recordingCollector{})
+	layout, layoutErr := sourcelayout.Resolve(context.Background(), path)
+	if layoutErr != nil {
+		t.Fatal(layoutErr)
+	}
+	_, actualFingerprint, inspectErr := inspectSource(context.Background(), api.PrepareInput{SourcePath: path}, layout)
+	if inspectErr != nil {
+		t.Fatal(inspectErr)
+	}
+	if actualFingerprint != prepared.Release.Compatibility.SourceFingerprint {
+		t.Fatalf("unchanged fingerprint = %s, want %s", actualFingerprint, prepared.Release.Compatibility.SourceFingerprint)
+	}
+	ref, err := target.Import(context.Background(), seed)
+	if err != nil {
+		t.Fatalf("Import() error = %v", err)
+	}
+	if ref.Generation != prepared.Release.Generation {
+		t.Fatalf("imported generation = %d, want %d", ref.Generation, prepared.Release.Generation)
+	}
+
+	if err := os.WriteFile(path, []byte("changed after acceptance"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	staleTarget := newTestModule(t, newMemoryStore(), &recordingCollector{})
+	_, err = staleTarget.Import(context.Background(), seed)
+	var stale *StalePreparationError
+	if !errors.As(err, &stale) || stale.Reason != StaleReasonFingerprint {
+		t.Fatalf("Import() error = %v, want fingerprint StalePreparationError", err)
+	}
+}
+
+func TestPrepareCancellationDoesNotReorderSourceFIFO(t *testing.T) {
+	t.Parallel()
+	path := writePreparedTestFile(t, "source.mkv", "source")
+	collector := newBlockingCollector()
+	module := newTestModule(t, newMemoryStore(), collector)
+
+	firstDone := make(chan error, 1)
+	go func() {
+		_, err := module.Prepare(context.Background(), prepareInputWithLookup(path, "first"))
+		firstDone <- err
+	}()
+	waitForString(t, collector.started, "first")
+
+	canceledCtx, cancel := context.WithCancel(context.Background())
+	canceledDone := make(chan error, 1)
+	go func() {
+		_, err := module.Prepare(canceledCtx, prepareInputWithLookup(path, "canceled"))
+		canceledDone <- err
+	}()
+	thirdDone := make(chan error, 1)
+	go func() {
+		_, err := module.Prepare(context.Background(), prepareInputWithLookup(path, "third"))
+		thirdDone <- err
+	}()
+	time.Sleep(20 * time.Millisecond)
+	cancel()
+	if err := <-canceledDone; !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled Prepare() error = %v", err)
+	}
+
+	collector.release <- struct{}{}
+	if err := <-firstDone; err != nil {
+		t.Fatal(err)
+	}
+	waitForString(t, collector.started, "third")
+	collector.release <- struct{}{}
+	if err := <-thirdDone; err != nil {
+		t.Fatal(err)
+	}
+	if got := collector.order(); len(got) != 2 || got[0] != "first" || got[1] != "third" {
+		t.Fatalf("collector order = %v, want [first third]", got)
+	}
+}
+
+func TestPrepareDifferentSourcesRunConcurrently(t *testing.T) {
+	t.Parallel()
+	firstPath := writePreparedTestFile(t, "first.mkv", "first")
+	secondPath := writePreparedTestFile(t, "second.mkv", "second")
+	collector := newBlockingCollector()
+	module := newTestModule(t, newMemoryStore(), collector)
+	done := make(chan error, 2)
+	for path, lookup := range map[string]string{firstPath: "first", secondPath: "second"} {
+		go func() {
+			_, err := module.Prepare(context.Background(), prepareInputWithLookup(path, lookup))
+			done <- err
+		}()
+	}
+	seen := map[string]bool{}
+	seen[<-collector.started] = true
+	seen[<-collector.started] = true
+	if !seen["first"] || !seen["second"] {
+		t.Fatalf("concurrent starts = %v", seen)
+	}
+	collector.release <- struct{}{}
+	collector.release <- struct{}{}
+	for range 2 {
+		if err := <-done; err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func prepareInputWithLookup(path string, lookup string) api.PrepareInput {
+	return api.PrepareInput{
+		SourcePath: path,
+		Instructions: api.ReleaseFactInstructions{
+			SourceLookup: lookup,
+		},
+	}
+}
+
+func writePreparedTestFile(t *testing.T, name string, body string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), name)
+	if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func newTestModule(t *testing.T, store Store, collector Collector) *Module {
+	t.Helper()
+	module, err := New(store, staticIdentityResolver{}, collector)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return module
+}
+
+type staticIdentityResolver struct{}
+
+func (staticIdentityResolver) Resolve(_ context.Context, request externalidentity.Request) (externalidentity.Result, error) {
+	now := time.Now().UTC()
+	identity := api.ExternalIdentity{
+		SourcePath: request.SourcePath,
+		Generation: request.Generation,
+		TMDBID:     1234567,
+		Category:   api.CanonicalCategoryMovie,
+		Provenance: api.IdentityProvenanceSet{
+			TMDB:     api.IdentityProvenanceProvider,
+			Category: api.IdentityProvenanceProvider,
+		},
+		Conflict: api.IdentityConflictNone,
+		Resolution: api.IdentityResolutionKey{
+			SourceFingerprint: request.SourceFingerprint,
+			IntentFingerprint: "intent",
+			ContractVersion:   externalidentity.ContractVersion,
+		},
+		ResolvedAt: now,
+	}
+	return externalidentity.Result{
+		Identity: identity,
+		ProviderMetadata: api.SourceScopedMetadata{
+			SourcePath: request.SourcePath,
+			Generation: request.Generation,
+			UpdatedAt:  now,
+		},
+	}, nil
+}
+
+type recordingCollector struct {
+	mu    sync.Mutex
+	calls []string
+}
+
+func (c *recordingCollector) Collect(_ context.Context, request preparationstate.Request) (CollectedFacts, error) {
+	c.mu.Lock()
+	c.calls = append(c.calls, request.Input.Instructions.SourceLookup)
+	c.mu.Unlock()
+	return CollectedFacts{
+		Naming: api.NamingFacts{
+			Filename:    filepath.Base(request.Manifest.SourcePath),
+			ReleaseName: "Example.Release.2026.1080p-GRP",
+		},
+		Assessments: api.ReleaseAssessments{
+			MediaInfoUniqueID:       api.UniqueIDStatusPresent,
+			MediaInfoEncodeSettings: api.EncodeSettingsStatusMissing,
+			Naming: api.NamingAssessment{
+				Status: api.NamingStatusComplete,
+			},
+		},
+	}, nil
+}
+
+func (c *recordingCollector) callCount() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return len(c.calls)
+}
+
+type clientEvidenceTestCollector struct {
+	base     recordingCollector
+	mu       sync.Mutex
+	hydrates int
+	snapshot preparationstate.ClientEvidenceSnapshot
+}
+
+func newClientEvidenceTestCollector(snapshot preparationstate.ClientEvidenceSnapshot) *clientEvidenceTestCollector {
+	return &clientEvidenceTestCollector{snapshot: snapshot}
+}
+
+func (c *clientEvidenceTestCollector) Collect(ctx context.Context, request preparationstate.Request) (CollectedFacts, error) {
+	facts, err := c.base.Collect(ctx, request)
+	if err != nil {
+		return CollectedFacts{}, err
+	}
+	facts.Resources.ClientEvidence = preparationstate.CloneClientEvidenceSnapshot(c.snapshot)
+	return facts, nil
+}
+
+func (c *clientEvidenceTestCollector) HydrateClientEvidence(
+	context.Context,
+	preparationstate.Request,
+) (preparationstate.ClientEvidenceSnapshot, error) {
+	c.mu.Lock()
+	c.hydrates++
+	c.mu.Unlock()
+	return preparationstate.CloneClientEvidenceSnapshot(c.snapshot), nil
+}
+
+func (c *clientEvidenceTestCollector) collectCount() int { return c.base.callCount() }
+
+func (c *clientEvidenceTestCollector) hydrateCount() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.hydrates
+}
+
+func clientEvidenceTestSnapshot(infoHash string) preparationstate.ClientEvidenceSnapshot {
+	return preparationstate.ClientEvidenceSnapshot{
+		Disposition: preparationstate.ClientEvidenceDispositionSearched,
+		Result: api.ClientSearchResult{
+			InfoHash:        infoHash,
+			TorrentPath:     "Example.Release.2026.torrent",
+			TrackerIDs:      map[string]string{"ant": "hydrated-id"},
+			MatchedTrackers: []string{"ANT"},
+		},
+	}
+}
+
+type blockingCollector struct {
+	*recordingCollector
+	started chan string
+	release chan struct{}
+}
+
+func newBlockingCollector() *blockingCollector {
+	return &blockingCollector{
+		recordingCollector: &recordingCollector{},
+		started:            make(chan string, 4),
+		release:            make(chan struct{}, 4),
+	}
+}
+
+func (c *blockingCollector) Collect(ctx context.Context, request preparationstate.Request) (CollectedFacts, error) {
+	c.mu.Lock()
+	c.calls = append(c.calls, request.Input.Instructions.SourceLookup)
+	c.mu.Unlock()
+	c.started <- request.Input.Instructions.SourceLookup
+	select {
+	case <-c.release:
+		request.Input = api.PrepareInput{}
+		return c.recordingCollector.Collect(ctx, request)
+	case <-ctx.Done():
+		return CollectedFacts{}, fmt.Errorf("blocking collector canceled: %w", ctx.Err())
+	}
+}
+
+func (c *blockingCollector) order() []string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	result := make([]string, 0, len(c.calls))
+	for _, call := range c.calls {
+		if call != "" {
+			result = append(result, call)
+		}
+	}
+	return result
+}
+
+func waitForString(t *testing.T, values <-chan string, want string) {
+	t.Helper()
+	select {
+	case got := <-values:
+		if got != want {
+			t.Fatalf("started = %q, want %q", got, want)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatalf("timed out waiting for %q", want)
+	}
+}
+
+type memoryStore struct {
+	mu        sync.Mutex
+	current   map[string]api.PreparedRelease
+	commits   int
+	commitErr error
+}
+
+func newMemoryStore() *memoryStore {
+	return &memoryStore{current: make(map[string]api.PreparedRelease)}
+}
+
+func (s *memoryStore) LoadPreparedRelease(_ context.Context, sourcePath string) (api.PreparedRelease, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	release, ok := s.current[canonicalSourceKey(sourcePath)]
+	if !ok {
+		return api.PreparedRelease{}, internalerrors.ErrNotFound
+	}
+	cloned, err := release.Clone()
+	if err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("memory store: clone loaded release: %w", err)
+	}
+	return cloned, nil
+}
+
+func (s *memoryStore) CommitPreparedRelease(_ context.Context, release api.PreparedRelease) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.commitErr != nil {
+		return s.commitErr
+	}
+	cloned, err := release.Clone()
+	if err != nil {
+		return fmt.Errorf("memory store: clone committed release: %w", err)
+	}
+	s.current[canonicalSourceKey(release.Source.SourcePath)] = cloned
+	s.commits++
+	return nil
+}
+
+func (s *memoryStore) PurgePreparedRelease(_ context.Context, sourcePath string) error {
+	s.mu.Lock()
+	delete(s.current, canonicalSourceKey(sourcePath))
+	s.mu.Unlock()
+	return nil
+}
+
+func (s *memoryStore) setCommitError(err error) {
+	s.mu.Lock()
+	s.commitErr = err
+	s.mu.Unlock()
+}
+
+func (s *memoryStore) commitCount() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.commits
+}
diff --git a/internal/preparedrelease/state/client_evidence.go b/internal/preparedrelease/state/client_evidence.go
new file mode 100644
index 00000000..1975f3ef
--- /dev/null
+++ b/internal/preparedrelease/state/client_evidence.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparationstate
+
+import (
+	"maps"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ClientEvidenceDisposition identifies how preparation obtained its private
+// torrent-client evidence.
+type ClientEvidenceDisposition string
+
+const (
+	// ClientEvidenceDispositionUnknown is valid only before collection or while
+	// an older persisted generation is awaiting private-evidence hydration.
+	ClientEvidenceDispositionUnknown ClientEvidenceDisposition = ""
+	// ClientEvidenceDispositionSearched reports that the client adapter ran,
+	// including searches that found no matching torrent.
+	ClientEvidenceDispositionSearched ClientEvidenceDisposition = "searched"
+	// ClientEvidenceDispositionSkipped reports an explicit preparation policy skip.
+	ClientEvidenceDispositionSkipped ClientEvidenceDisposition = "skipped"
+	// ClientEvidenceDispositionUnavailable reports that no client adapter exists.
+	ClientEvidenceDispositionUnavailable ClientEvidenceDisposition = "unavailable"
+)
+
+// ClientEvidenceSnapshot is detached private evidence owned by one prepared
+// generation. It is never persisted in public prepared-release storage or
+// exposed through transport DTOs.
+type ClientEvidenceSnapshot struct {
+	Disposition   ClientEvidenceDisposition
+	Policy        api.ClientSearchPolicy
+	ForcedRecheck bool
+	Result        api.ClientSearchResult
+}
+
+// CloneClientEvidenceSnapshot returns a fully detached private snapshot.
+func CloneClientEvidenceSnapshot(value ClientEvidenceSnapshot) ClientEvidenceSnapshot {
+	value.Policy.Client = cloneClientEvidenceString(value.Policy.Client)
+	value.Result.TrackerIDs = cloneClientEvidenceStringMap(value.Result.TrackerIDs)
+	value.Result.MatchedTrackers = append([]string(nil), value.Result.MatchedTrackers...)
+	value.Result.TorrentComments = cloneClientEvidenceTorrentMatches(value.Result.TorrentComments)
+	return value
+}
+
+func cloneClientEvidenceString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+func cloneClientEvidenceStringMap(value map[string]string) map[string]string {
+	if value == nil {
+		return nil
+	}
+	cloned := make(map[string]string, len(value))
+	maps.Copy(cloned, value)
+	return cloned
+}
+
+func cloneClientEvidenceTorrentMatches(value []api.TorrentMatch) []api.TorrentMatch {
+	if value == nil {
+		return nil
+	}
+	cloned := make([]api.TorrentMatch, len(value))
+	for index, match := range value {
+		cloned[index] = match
+		cloned[index].TrackerURLsRaw = append([]string(nil), match.TrackerURLsRaw...)
+		cloned[index].TrackerURLs = append([]api.TrackerMatch(nil), match.TrackerURLs...)
+	}
+	return cloned
+}
diff --git a/internal/preparedrelease/state/state.go b/internal/preparedrelease/state/state.go
new file mode 100644
index 00000000..227812b3
--- /dev/null
+++ b/internal/preparedrelease/state/state.go
@@ -0,0 +1,239 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package preparationstate contains mutable evidence while a prepared release
+// is being collected. State is private to preparation and must never cross a
+// transport, operation-module, or persistence boundary.
+package preparationstate
+
+import (
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Request is the complete preparation-only handoff to the evidence pipeline.
+// It contains no workflow request or tracker selection.
+type Request struct {
+	// Input contains normalized preparation choices for this evidence pass.
+	Input api.PrepareInput
+	// Manifest is the validated source snapshot bound to the request.
+	Manifest api.SourceManifest
+	// Layout exposes preparation-only derived resource roots for the same source.
+	Layout sourcelayout.Layout
+}
+
+// ReleaseAssessments projects concrete source-derived validation facts from
+// private collection state into their canonical typed form.
+func (s State) ReleaseAssessments() api.ReleaseAssessments {
+	uniqueID := api.UniqueIDStatusMissing
+	if !s.requiresMediaInfoUniqueID() {
+		uniqueID = api.UniqueIDStatusNotApplicable
+	} else if s.MediaInfoUniqueIDPresent {
+		uniqueID = api.UniqueIDStatusPresent
+	}
+
+	encodeSettings := api.EncodeSettingsStatusMissing
+	if strings.EqualFold(s.DiscType, "BDMV") || !strings.EqualFold(s.Type, "ENCODE") || strings.EqualFold(s.VideoCodec, "AV1") {
+		encodeSettings = api.EncodeSettingsStatusNotApplicable
+	} else if s.MediaInfoEncodeSettingsPresent {
+		encodeSettings = api.EncodeSettingsStatusPresent
+	}
+
+	return api.ReleaseAssessments{
+		MediaInfoUniqueID:       uniqueID,
+		MediaInfoEncodeSettings: encodeSettings,
+	}
+}
+
+func (s State) requiresMediaInfoUniqueID() bool {
+	if strings.TrimSpace(s.DiscType) != "" {
+		return false
+	}
+	if len(s.FileList) == 0 {
+		return strings.EqualFold(filepath.Ext(s.SourcePath), ".mkv")
+	}
+	for _, path := range s.FileList {
+		if strings.EqualFold(filepath.Ext(path), ".mkv") {
+			return true
+		}
+	}
+	return false
+}
+
+// State is mutable, source-scoped collection evidence used only during
+// preparation. It contains no upload outcome, tracker-selection result, client
+// instruction, or transport state. Callers must project it into canonical fact
+// groups or operation-owned subjects before it leaves this boundary.
+type State struct {
+	SourcePath              string
+	SourceLookupURL         string
+	SourceLookupActive      bool
+	SourceLookupMode        string
+	SourceLookupTracker     string
+	SourceLookupTrackerID   string
+	LookupWarnings          []string
+	Paths                   []string
+	DiscType                string
+	VideoPath               string
+	FileList                []string
+	SourceSize              int64
+	MediaInfoJSONPath       string
+	MediaInfoTextPath       string
+	DVDIFOPath              string
+	DVDVOBPath              string
+	DVDVOBSet               string
+	DVDVOBMediaInfoJSON     string
+	DVDVOBMediaInfoText     string
+	MediaInfoUniqueID       string
+	Scene                   bool
+	SceneName               string
+	SceneTMDBID             int
+	SceneIMDB               int
+	SceneTVDBID             int
+	SceneTVmazeID           int
+	SceneMALID              int
+	SceneNFOPath            string
+	SceneNFONew             bool
+	SceneRenamed            bool
+	SceneRenamedReason      string
+	EvidenceTrackers        []string
+	Policy                  CollectionPolicy
+	MatchedEvidenceTrackers []string
+	Tag                     string
+	Release                 api.ReleaseInfo
+	TagOverride             *api.TagOverride
+	MetadataOverrides       api.MetadataOverrides
+	PersonalRelease         bool
+	InfoHash                string
+	// ClientEvidence retains the complete detached preparation-owned client snapshot.
+	ClientEvidence ClientEvidenceSnapshot
+	// DiscoveredTorrentPath is a reusable local metainfo path found during client discovery.
+	DiscoveredTorrentPath          string
+	TrackerIDs                     map[string]string
+	FoundTrackerMatch              bool
+	TorrentComments                []api.TorrentMatch
+	DescriptionTemplate            string
+	PieceSizeConstraint            string
+	FoundPreferredPiece            string
+	StoredInfoHash                 string
+	StoredUpdatedAt                time.Time
+	StoredDataFresh                bool
+	TrackerData                    []api.TrackerMetadata
+	MediaInfoCategory              string
+	MediaInfoTMDBID                int
+	MediaInfoIMDBID                int
+	MediaInfoTVDBID                int
+	ArrSource                      string
+	ArrTMDBID                      int
+	ArrIMDBID                      int
+	ArrTVDBID                      int
+	ArrTVmazeID                    int
+	ArrYear                        int
+	ArrGenres                      []string
+	ArrReleaseGroup                string
+	MismatchedMediaInfoTMDBID      int
+	MismatchedMediaInfoIMDBID      int
+	MismatchedMediaInfoTVDBID      int
+	ExternalIDOverrides            api.ExternalIDOverrides
+	ReleaseNameOverrides           api.ReleaseNameOverrides
+	SeasonInt                      int
+	EpisodeInt                     int
+	SeasonStr                      string
+	EpisodeStr                     string
+	TVDBAiredDate                  string
+	TVDBAirsDays                   []string
+	TVDBAirsTime                   string
+	TVDBAirsTimezone               string
+	TVDBAirsTimezoneSource         string
+	TVPack                         bool
+	DailyEpisodeDate               string
+	TMDBDateMatch                  bool
+	Anime                          bool
+	MALID                          int
+	EpisodeTitle                   string
+	EpisodeOverview                string
+	EpisodeYear                    int
+	SelectedBDMVPlaylists          []api.PlaylistInfo
+	Identity                       api.ExternalIdentity
+	ExternalIdentityCandidates     []api.ExternalIdentityCandidate
+	ProviderMetadata               api.SourceScopedMetadata
+	AudioLanguages                 []string
+	SubtitleLanguages              []string
+	Container                      string
+	Audio                          string
+	Channels                       string
+	HasCommentary                  bool
+	Is3D                           string
+	Source                         string
+	Type                           string
+	UHD                            string
+	HDR                            string
+	Distributor                    string
+	Region                         string
+	VideoCodec                     string
+	VideoEncode                    string
+	HasEncodeSettings              bool
+	BitDepth                       string
+	Edition                        string
+	Repack                         string
+	WebDV                          bool
+	MediaInfoUniqueIDPresent       bool
+	MediaInfoEncodeSettingsPresent bool
+	StreamOptimized                int
+	Service                        string
+	ServiceLongName                string
+	Filename                       string
+	ReleaseName                    string
+	ReleaseNameNoTag               string
+	ReleaseNameClean               string
+	ReleaseNameMissing             []string
+	BDInfo                         map[string]any
+}
+
+// CollectionPolicy contains preparation-only controls used while gathering
+// evidence. It excludes upload, tracker-selection, and client instructions.
+type CollectionPolicy struct {
+	OnlyID          bool
+	KeepFolder      bool
+	KeepImages      bool
+	InteractionMode api.InteractionMode
+}
+
+// CanonicalSeasonEpisode returns the provider-resolved TV season/episode.
+func (s State) CanonicalSeasonEpisode() (int, int) {
+	return s.SeasonInt, s.EpisodeInt
+}
+
+// SeasonEpisodeWithParsedFallback returns canonical values with independent
+// parsed-name fallback for classification and evidence lookup only.
+func (s State) SeasonEpisodeWithParsedFallback() (int, int) {
+	season, episode := s.CanonicalSeasonEpisode()
+	if season <= 0 {
+		season = s.Release.Season
+	}
+	if episode <= 0 {
+		episode = s.Release.Episode
+	}
+	return season, episode
+}
+
+// HasTVSeasonEpisodeSignal reports whether canonical or parsed naming evidence
+// carries a season or episode hint.
+func (s State) HasTVSeasonEpisodeSignal() bool {
+	season, episode := s.SeasonEpisodeWithParsedFallback()
+	return season > 0 || episode > 0
+}
+
+// LocalizedPTBR returns source-scoped Brazilian Portuguese TMDB data.
+func (s State) LocalizedPTBR() api.TMDBLocalizedData {
+	if s.ProviderMetadata.TMDB != nil && s.ProviderMetadata.TMDB.Localized != nil {
+		if value, ok := s.ProviderMetadata.TMDB.Localized["pt-BR"]; ok {
+			return value
+		}
+	}
+	return api.TMDBLocalizedData{}
+}
diff --git a/internal/preparedrelease/state/state_test.go b/internal/preparedrelease/state/state_test.go
new file mode 100644
index 00000000..0ac08968
--- /dev/null
+++ b/internal/preparedrelease/state/state_test.go
@@ -0,0 +1,66 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparationstate
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestSeasonEpisodeHelpers(t *testing.T) {
+	t.Parallel()
+
+	state := State{
+		SeasonInt: 9,
+		Release: api.ReleaseInfo{
+			Season:  1,
+			Episode: 2,
+		},
+	}
+
+	canonicalSeason, canonicalEpisode := state.CanonicalSeasonEpisode()
+	if canonicalSeason != 9 || canonicalEpisode != 0 {
+		t.Fatalf("canonical season/episode = %d/%d, want 9/0", canonicalSeason, canonicalEpisode)
+	}
+
+	fallbackSeason, fallbackEpisode := state.SeasonEpisodeWithParsedFallback()
+	if fallbackSeason != 9 || fallbackEpisode != 2 {
+		t.Fatalf("fallback season/episode = %d/%d, want 9/2", fallbackSeason, fallbackEpisode)
+	}
+	if !state.HasTVSeasonEpisodeSignal() {
+		t.Fatal("expected parsed release episode to provide TV signal")
+	}
+}
+
+func TestCloneClientEvidenceSnapshotDetachesNestedValues(t *testing.T) {
+	t.Parallel()
+
+	client := "qbit"
+	original := ClientEvidenceSnapshot{
+		Disposition: ClientEvidenceDispositionSearched,
+		Policy:      api.ClientSearchPolicy{Client: &client},
+		Result: api.ClientSearchResult{
+			TrackerIDs:      map[string]string{"ant": "release-id"},
+			MatchedTrackers: []string{"ANT"},
+			TorrentComments: []api.TorrentMatch{{
+				TrackerURLsRaw: []string{"https://tracker.example.invalid/announce"},
+				TrackerURLs:    []api.TrackerMatch{{ID: "ANT"}},
+			}},
+		},
+	}
+	cloned := CloneClientEvidenceSnapshot(original)
+	*cloned.Policy.Client = "other"
+	cloned.Result.TrackerIDs["ant"] = "changed"
+	cloned.Result.MatchedTrackers[0] = "CHANGED"
+	cloned.Result.TorrentComments[0].TrackerURLsRaw[0] = "changed"
+	cloned.Result.TorrentComments[0].TrackerURLs[0].ID = "CHANGED"
+
+	if *original.Policy.Client != "qbit" || original.Result.TrackerIDs["ant"] != "release-id" ||
+		original.Result.MatchedTrackers[0] != "ANT" ||
+		original.Result.TorrentComments[0].TrackerURLsRaw[0] != "https://tracker.example.invalid/announce" ||
+		original.Result.TorrentComments[0].TrackerURLs[0].ID != "ANT" {
+		t.Fatalf("original snapshot was aliased: %#v", original)
+	}
+}
diff --git a/internal/preparedrelease/subjects.go b/internal/preparedrelease/subjects.go
new file mode 100644
index 00000000..f30d98ef
--- /dev/null
+++ b/internal/preparedrelease/subjects.go
@@ -0,0 +1,360 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package preparedrelease
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"path/filepath"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ResolveUploadSubject validates and projects one exact prepared generation
+// into the upload module's operation-owned read model.
+func (m *Module) ResolveUploadSubject(ctx context.Context, input api.UploadReviewInput) (api.UploadSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.UploadSubject{}, err
+	}
+	release := owned.result.Release
+	resources := owned.resources
+	discType := firstNonEmpty(release.Disc.Type, release.Source.Classification.DiscType)
+	fileList := append([]string(nil), resources.fileList...)
+	if len(fileList) == 0 {
+		fileList = manifestFiles(release.Source)
+	}
+	selectedPlaylists := clonePreparedPlaylists(resources.selectedBDMVPlaylists)
+	if len(selectedPlaylists) == 0 {
+		selectedPlaylists = clonePreparedPlaylists(release.Source.SelectedPlaylists)
+	}
+	subject := api.UploadSubject{
+		SourcePath:                  release.Source.SourcePath,
+		Paths:                       []string{resources.sourcePath},
+		DiscType:                    discType,
+		VideoPath:                   resources.videoPath,
+		FileList:                    fileList,
+		SourceSize:                  release.Source.Size,
+		MediaInfoJSONPath:           resources.mediaInfoJSONPath,
+		MediaInfoTextPath:           resources.mediaInfoTextPath,
+		DVDVOBMediaInfoText:         resources.dvdVOBMediaInfoText,
+		Scene:                       release.Naming.Scene,
+		SceneName:                   release.Naming.SceneName,
+		SceneNFOPath:                resources.sceneNFOPath,
+		DescriptionGroups:           api.CloneDescriptionBuilderGroups(input.DescriptionGroups),
+		DescriptionTemplate:         resources.descriptionTemplate,
+		Trackers:                    append([]string(nil), input.Trackers...),
+		Options:                     input.Options,
+		Tag:                         release.Naming.Tag,
+		Release:                     releaseInfo(release),
+		TrackerConfigOverrides:      input.TrackerConfigOverrides,
+		TrackerSiteOverrides:        input.TrackerSiteOverrides,
+		ImageHostOverrides:          input.ImageHostOverrides,
+		PersonalRelease:             release.Naming.Personal,
+		TrackerQuestionnaireAnswers: cloneAnswers(input.QuestionnaireAnswers),
+		SeasonInt:                   release.Episode.Season,
+		EpisodeInt:                  release.Episode.Episode,
+		SeasonStr:                   release.Episode.SeasonLabel,
+		EpisodeStr:                  release.Episode.EpisodeLabel,
+		TVDBAiredDate:               release.Episode.AiredDate,
+		TVDBAirsTime:                release.Episode.AirTime,
+		TVDBAirsTimezone:            release.Episode.AirTimezone,
+		TVPack:                      release.Episode.Pack,
+		DailyEpisodeDate:            release.Episode.DailyDate,
+		Anime:                       release.Media.Anime,
+		EpisodeTitle:                release.Episode.Title,
+		EpisodeOverview:             release.Episode.Overview,
+		SelectedBDMVPlaylists:       selectedPlaylists,
+		Identity:                    release.Identity,
+		ProviderMetadata:            release.ProviderMetadata,
+		Disc:                        release.Disc,
+		AudioLanguages:              append([]string(nil), release.Media.AudioLanguages...),
+		SubtitleLanguages:           append([]string(nil), release.Media.SubtitleLanguages...),
+		Container:                   release.Media.Container,
+		Audio:                       release.Media.Audio,
+		Channels:                    release.Media.Channels,
+		HasCommentary:               release.Media.Commentary,
+		Is3D:                        release.Media.ThreeD,
+		Source:                      release.Media.Source,
+		Type:                        release.Media.Type,
+		UHD:                         release.Media.UHD,
+		HDR:                         release.Media.HDR,
+		Distributor:                 release.Media.Distributor,
+		Region:                      release.Media.Region,
+		VideoCodec:                  release.Media.VideoCodec,
+		VideoEncode:                 release.Media.VideoEncode,
+		HasEncodeSettings:           release.Media.HasEncodeSettings,
+		BitDepth:                    release.Media.BitDepth,
+		Edition:                     release.Media.Edition,
+		Repack:                      release.Media.Repack,
+		WebDV:                       release.Media.WebDV,
+		Assessments:                 release.Assessments,
+		StreamOptimized:             release.Media.StreamOptimized,
+		Service:                     release.Media.Service,
+		ServiceLongName:             release.Media.ServiceLongName,
+		Filename:                    release.Naming.Filename,
+		ReleaseName:                 release.Naming.ReleaseName,
+		ReleaseNameNoTag:            release.Naming.NameWithoutTag,
+		ReleaseNameClean:            release.Naming.CleanName,
+		ArrReleaseGroup:             release.Naming.Group,
+		InfoHash:                    resources.clientEvidence.Result.InfoHash,
+		ClientTorrentPath:           resources.clientEvidence.Result.TorrentPath,
+		TrackerIDs:                  maps.Clone(resources.clientEvidence.Result.TrackerIDs),
+		MatchedTrackers:             append([]string(nil), resources.clientEvidence.Result.MatchedTrackers...),
+	}
+	cloned, err := cloneWithJSON(subject)
+	if err != nil {
+		return api.UploadSubject{}, fmt.Errorf("prepared release: clone upload subject: %w", err)
+	}
+	return cloned, nil
+}
+
+// ResolveDuplicateSubject validates and projects one exact prepared generation
+// into the duplicate module's operation-owned read model.
+func (m *Module) ResolveDuplicateSubject(ctx context.Context, input api.DuplicateCheckInput) (api.DuplicateSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.DuplicateSubject{}, err
+	}
+	release := owned.result.Release
+	resources := owned.resources
+	fileList := append([]string(nil), resources.fileList...)
+	if len(fileList) == 0 {
+		fileList = manifestFiles(release.Source)
+	}
+	subject := api.DuplicateSubject{
+		SourcePath:        release.Source.SourcePath,
+		SourceSize:        release.Source.Size,
+		VideoPath:         resources.videoPath,
+		FileList:          fileList,
+		Filename:          release.Naming.Filename,
+		SceneName:         release.Naming.SceneName,
+		ReleaseName:       release.Naming.ReleaseName,
+		Release:           releaseInfo(release),
+		Identity:          release.Identity,
+		ProviderMetadata:  release.ProviderMetadata,
+		DiscType:          firstNonEmpty(release.Disc.Type, release.Source.Classification.DiscType),
+		Type:              release.Media.Type,
+		Source:            release.Media.Source,
+		Tag:               release.Naming.Tag,
+		HDR:               release.Media.HDR,
+		UHD:               release.Media.UHD,
+		VideoEncode:       release.Media.VideoEncode,
+		VideoCodec:        release.Media.VideoCodec,
+		HasEncodeSettings: release.Media.HasEncodeSettings,
+		SeasonInt:         release.Episode.Season,
+		EpisodeInt:        release.Episode.Episode,
+		SeasonStr:         release.Episode.SeasonLabel,
+		EpisodeStr:        release.Episode.EpisodeLabel,
+		DailyEpisodeDate:  release.Episode.DailyDate,
+		TVPack:            release.Episode.Pack,
+		Anime:             release.Media.Anime,
+		TrackerIDs:        maps.Clone(resources.clientEvidence.Result.TrackerIDs),
+		MatchedTrackers:   append([]string(nil), resources.clientEvidence.Result.MatchedTrackers...),
+	}
+	cloned, err := cloneWithJSON(subject)
+	if err != nil {
+		return api.DuplicateSubject{}, fmt.Errorf("prepared release: clone duplicate subject: %w", err)
+	}
+	return cloned, nil
+}
+
+// ResolveDVDMenuSubject validates and projects one exact prepared generation
+// into the DVD-menu module's operation-owned read model.
+func (m *Module) ResolveDVDMenuSubject(ctx context.Context, input api.MediaPlanInput) (api.DVDMenuSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.DVDMenuSubject{}, err
+	}
+	release := owned.result.Release
+	return api.DVDMenuSubject{
+		SourcePath: release.Source.SourcePath,
+		DiscType:   firstNonEmpty(release.Disc.Type, release.Source.Classification.DiscType),
+	}, nil
+}
+
+// ResolveScreenshotSubject validates and projects one exact prepared
+// generation into the screenshot module's operation-owned read model.
+func (m *Module) ResolveScreenshotSubject(ctx context.Context, input api.MediaPlanInput) (api.ScreenshotSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.ScreenshotSubject{}, err
+	}
+	release := owned.result.Release
+	resources := owned.resources
+	selectedPlaylists := clonePreparedPlaylists(resources.selectedBDMVPlaylists)
+	if len(selectedPlaylists) == 0 {
+		selectedPlaylists = clonePreparedPlaylists(release.Source.SelectedPlaylists)
+	}
+	return api.ScreenshotSubject{
+		SourcePath:            release.Source.SourcePath,
+		DiscType:              firstNonEmpty(release.Disc.Type, release.Source.Classification.DiscType),
+		VideoPath:             resources.videoPath,
+		MediaInfoJSONPath:     resources.mediaInfoJSONPath,
+		MediaCategory:         string(release.Identity.Category),
+		HDR:                   release.Media.HDR,
+		TVPack:                release.Episode.Pack,
+		Episode:               release.Episode.Episode,
+		Release:               releaseInfo(release),
+		SelectedBDMVPlaylists: selectedPlaylists,
+		DefaultCount:          input.Count,
+		ManualFrames:          append([]int(nil), input.Options.ManualFrames...),
+	}, nil
+}
+
+// ResolveImageHostingSubject validates and projects one exact prepared
+// generation into the image-hosting module's operation-owned read model.
+func (m *Module) ResolveImageHostingSubject(ctx context.Context, input api.ImageHostingInput) (api.ImageHostingSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.ImageHostingSubject{}, err
+	}
+	release := owned.result.Release
+	galleryName := firstNonEmpty(
+		release.Naming.ReleaseName,
+		release.Naming.NameWithoutTag,
+		release.Naming.Title,
+		release.Naming.Filename,
+		filepath.Base(release.Source.SourcePath),
+	)
+	return api.ImageHostingSubject{SourcePath: release.Source.SourcePath, GalleryName: galleryName}, nil
+}
+
+// ResolveDescriptionSubject validates and projects one exact prepared
+// generation into the description module's operation-owned read model.
+func (m *Module) ResolveDescriptionSubject(ctx context.Context, input api.DescriptionInput) (api.DescriptionSubject, error) {
+	owned, err := m.resolveEnvelope(ctx, input.Release)
+	if err != nil {
+		return api.DescriptionSubject{}, err
+	}
+	release := owned.result.Release
+	resources := owned.resources
+	selectedPlaylists := clonePreparedPlaylists(resources.selectedBDMVPlaylists)
+	if len(selectedPlaylists) == 0 {
+		selectedPlaylists = clonePreparedPlaylists(release.Source.SelectedPlaylists)
+	}
+	return api.DescriptionSubject{
+		SourcePath:            release.Source.SourcePath,
+		DiscType:              firstNonEmpty(release.Disc.Type, release.Source.Classification.DiscType),
+		MediaInfoTextPath:     resources.mediaInfoTextPath,
+		DVDVOBMediaInfoText:   resources.dvdVOBMediaInfoText,
+		EpisodeOverview:       release.Episode.Overview,
+		DescriptionTemplate:   resources.descriptionTemplate,
+		Options:               input.Options,
+		Release:               releaseInfo(release),
+		SelectedBDMVPlaylists: selectedPlaylists,
+		Tag:                   release.Naming.Tag,
+		Identity:              release.Identity,
+		ProviderMetadata:      release.ProviderMetadata,
+		SeasonInt:             release.Episode.Season,
+		EpisodeInt:            release.Episode.Episode,
+		Filename:              release.Naming.Filename,
+		ReleaseName:           release.Naming.ReleaseName,
+		ReleaseNameNoTag:      release.Naming.NameWithoutTag,
+		ServiceLongName:       release.Media.ServiceLongName,
+		Type:                  release.Media.Type,
+		HDR:                   release.Media.HDR,
+		ArrReleaseGroup:       release.Naming.Group,
+	}, nil
+}
+
+func (m *Module) resolveEnvelope(ctx context.Context, ref api.ReleaseRef) (envelope, error) {
+	if m == nil {
+		return envelope{}, errors.New("prepared release: module is not initialized")
+	}
+	if ctx == nil {
+		return envelope{}, errors.New("prepared release: context is required")
+	}
+	normalized, err := normalizeSourcePath(ref.SourcePath)
+	if err != nil || ref.Generation == 0 {
+		return envelope{}, &IncompatiblePreparationError{SourcePath: ref.SourcePath, Reason: "invalid release reference"}
+	}
+	key := canonicalSourceKey(normalized)
+	m.mu.RLock()
+	owned, ok := m.envelopes[key]
+	m.mu.RUnlock()
+	if !ok || owned.result.Release.Generation != ref.Generation {
+		return envelope{}, &StalePreparationError{
+			SourcePath: key,
+			Generation: ref.Generation,
+			Reason:     StaleReasonGeneration,
+		}
+	}
+	cloned, err := cloneEnvelope(owned)
+	if err != nil {
+		return envelope{}, err
+	}
+	if err := validateSeedSource(ctx, cloned); err != nil {
+		return envelope{}, err
+	}
+	return cloned, nil
+}
+
+func releaseInfo(release api.PreparedRelease) api.ReleaseInfo {
+	naming := release.Naming
+	return api.ReleaseInfo{
+		Type:       naming.Type,
+		Artist:     naming.Artist,
+		Title:      naming.Title,
+		Subtitle:   naming.Subtitle,
+		Alt:        naming.AlternateTitle,
+		Year:       naming.Year,
+		Month:      naming.Month,
+		Day:        naming.Day,
+		Source:     naming.Source,
+		Resolution: naming.Resolution,
+		Codec:      append([]string(nil), naming.Codecs...),
+		Audio:      append([]string(nil), naming.Audio...),
+		HDR:        append([]string(nil), naming.HDR...),
+		Ext:        naming.Extension,
+		Language:   append([]string(nil), naming.Languages...),
+		Site:       naming.Site,
+		Genre:      naming.Genre,
+		Channels:   naming.Channels,
+		Collection: naming.Collection,
+		Region:     naming.Region,
+		Size:       naming.Size,
+		Group:      naming.Group,
+		Disc:       naming.Disc,
+		Season:     release.Episode.Season,
+		Episode:    release.Episode.Episode,
+		Edition:    append([]string(nil), naming.Editions...),
+		Other:      append([]string(nil), naming.Other...),
+	}
+}
+
+func manifestFiles(manifest api.SourceManifest) []string {
+	files := make([]string, 0, len(manifest.Entries))
+	for _, entry := range manifest.Entries {
+		if entry.Type == api.SourceEntryTypeFile || entry.Type == api.SourceEntryTypePlaylist {
+			files = append(files, entry.Path)
+		}
+	}
+	return files
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value = strings.TrimSpace(value); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func cloneAnswers(source map[string]map[string]string) map[string]map[string]string {
+	if source == nil {
+		return nil
+	}
+	cloned := make(map[string]map[string]string, len(source))
+	for tracker, answers := range source {
+		inner := make(map[string]string, len(answers))
+		maps.Copy(inner, answers)
+		cloned[tracker] = inner
+	}
+	return cloned
+}
diff --git a/internal/redaction/redaction.go b/internal/redaction/redaction.go
index 28e6ce54..060978cf 100644
--- a/internal/redaction/redaction.go
+++ b/internal/redaction/redaction.go
@@ -9,11 +9,16 @@ import (
 	"strings"
 )
 
+// Block identifies a candidate JSON object's or array's half-open byte range
+// within the source string.
 type Block struct {
 	Start int
 	End   int
 }
 
+// DefaultSensitiveKeys is the JSON-key set used when a redaction call receives
+// nil keys. Key matching ignores case and common separators and treats a key as
+// sensitive when its normalized form contains a normalized entry.
 var DefaultSensitiveKeys = map[string]struct{}{
 	"token":         {},
 	"passkey":       {},
@@ -37,15 +42,23 @@ var (
 	apiPathTokenRe      = regexp.MustCompile(`(?i)(/api/torrents/)([A-Za-z0-9]{10,})($|[/?#"])`)
 	proxyPathRe         = regexp.MustCompile(`(?i)(/proxy/)([^/\s?#"]+)`) // /proxy/<secret>
 	urlUserinfoRe       = regexp.MustCompile(`(?i)(\b[a-z][a-z0-9+.-]*://|//)([^/@\s]+)@`)
-	queryParamRe        = regexp.MustCompile(`(?i)([?&](anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|auth|auth[_-]?key|csrf|info[_-]?hash|key|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass|uid|user|user[_-]?id|userid)=)[^&]+`)
-	keyValueQuotedRe    = regexp.MustCompile(`(?i)\b(anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|authorization|auth|auth[_-]?key|cookie|csrf|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass)\b(\s*[:=]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')`)
-	keyValuePlainRe     = regexp.MustCompile(`(?i)\b(anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|authorization|auth|auth[_-]?key|cookie|csrf|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass)\b(\s*[:=]\s*)(bearer\s+)?([^"'\s,;)\]}]+)`)
-	cookieTailRe        = regexp.MustCompile(`(?i)(\bcookie\b\s*[:=]\s*\[REDACTED\])(?:[;]\s*[^,\r\n]+)+`)
-	authTailRe          = regexp.MustCompile(`(?i)(\bauthorization\b\s*[:=]\s*bearer\s+\[REDACTED\])(?:,\s*[^,\s]+)+`)
-	longHexTokenRe      = regexp.MustCompile(`\b[a-fA-F0-9]{32,}\b`)
+	queryParamRe        = regexp.MustCompile(
+		`(?i)([?&](anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|auth|auth[_-]?key|csrf|info[_-]?hash|key|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass|uid|user|user[_-]?id|userid)=)[^&]+`,
+	)
+	keyValueQuotedRe = regexp.MustCompile(
+		`(?i)\b(anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|authorization|auth|auth[_-]?key|cookie|csrf|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass)\b(\s*[:=]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')`,
+	)
+	keyValuePlainRe = regexp.MustCompile(
+		`(?i)\b(anti[_-]?csrf[_-]?token|api[_-]?key|api[_-]?token|authorization|auth|auth[_-]?key|cookie|csrf|passkey|password|rss[_-]?key|secret|token|torrent[_-]?pass)\b(\s*[:=]\s*)(bearer\s+)?([^"'\s,;)\]}]+)`,
+	)
+	cookieTailRe   = regexp.MustCompile(`(?i)(\bcookie\b\s*[:=]\s*\[REDACTED\])(?:[;]\s*[^,\r\n]+)+`)
+	authTailRe     = regexp.MustCompile(`(?i)(\bauthorization\b\s*[:=]\s*bearer\s+\[REDACTED\])(?:,\s*[^,\s]+)+`)
+	longHexTokenRe = regexp.MustCompile(`\b[a-fA-F0-9]{32,}\b`)
 )
 
-// ExtractJSONBlocks returns candidate JSON substrings based on bracket counting.
+// ExtractJSONBlocks returns balanced top-level object and array candidates in
+// source order. Brackets inside quoted strings are ignored, and unterminated
+// candidates are omitted.
 func ExtractJSONBlocks(text string) []Block {
 	blocks := make([]Block, 0)
 	stack := make([]rune, 0)
@@ -100,7 +113,10 @@ func ExtractJSONBlocks(text string) []Block {
 	return blocks
 }
 
-// RedactValue redacts sensitive content in a string.
+// RedactValue redacts valid embedded JSON plus known secret-bearing URL, path,
+// query, key/value, cookie, authorization, and long-hex patterns. Nil keys use
+// [DefaultSensitiveKeys] for embedded JSON; textual patterns use the package's
+// fixed secret vocabulary.
 func RedactValue(value string, sensitiveKeys map[string]struct{}) string {
 	keys := sensitiveKeys
 	if keys == nil {
@@ -171,7 +187,8 @@ func redactPlainKeyValue(value string) string {
 	return matches[1] + matches[2] + matches[3] + "[REDACTED]"
 }
 
-// RedactPrivateInfo recursively redacts sensitive values in JSON-like data.
+// RedactPrivateInfo recursively redacts JSON-like maps, slices, and strings
+// without mutating input maps or slices. Nil keys use [DefaultSensitiveKeys].
 func RedactPrivateInfo(data any, sensitiveKeys map[string]struct{}) any {
 	keys := sensitiveKeys
 	if keys == nil {
diff --git a/internal/releasepolicy/modified.go b/internal/releasepolicy/modified.go
new file mode 100644
index 00000000..7e1708cc
--- /dev/null
+++ b/internal/releasepolicy/modified.go
@@ -0,0 +1,205 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package releasepolicy applies release-wide upload eligibility rules.
+package releasepolicy
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ModifiedReleaseSubject contains only source and naming facts needed by the
+// modified-release policy.
+type ModifiedReleaseSubject struct {
+	SourcePath         string
+	VideoPath          string
+	DiscType           string
+	PersonalRelease    bool
+	SceneRenamed       bool
+	SceneRenamedReason string
+	Release            api.ReleaseInfo
+}
+
+// DetectModifiedRelease reports whether source media was renamed away from its
+// original scene/P2P release name. Trackers reject such modified releases
+// ([Modified Release] Renamed), so detecting it lets us skip the upload before it
+// is rejected. Two independent, deliberately high-signal cases are checked:
+//
+//   - *arr id tokens: Radarr/Sonarr inject "{tmdb-…}", "{imdb-…}", "{tvdb-…}",
+//     jellyfin "[tmdb" style, or bracket/paren variants into renamed names
+//     (e.g. "Example Release (2026) {imdb-tt1234567}"). These never occur in an
+//     original scene/P2P name, so their presence alone marks a rename. This is
+//     independent of the release group, which an *arr rename often strips.
+//
+//   - whitespace renames: a grouped release (a trailing "-GROUP" tag, which
+//     scene/P2P releases always dot-delimit) whose on-disk name has had its dots
+//     replaced with spaces — e.g. a library manager rewriting
+//     "Example.Release.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP" to spaces.
+//     This path is deliberately conservative: it only fires on whitespace
+//     (underscore/other separator renames are out of scope), requires the parsed
+//     group to be the actual trailing "-GROUP" suffix so a mis-parsed token (e.g.
+//     an id) cannot trigger it, and skips names with parentheses/brackets/braces
+//     (human/library naming markers) that lack an *arr id token.
+//
+// Personal releases and disc-based sources are excluded from all rename checks.
+// Groups in standardRenameCheckSkippedGroups skip only the heuristic checks;
+// SceneRenamed remains authoritative for those groups.
+//
+// Both the source path (folder) and the primary video file are checked, since the
+// tracker inspects the file (MediaInfo "Complete name") and the in-torrent names.
+func DetectModifiedRelease(meta ModifiedReleaseSubject) (bool, string) {
+	if meta.PersonalRelease {
+		return false, ""
+	}
+	if strings.TrimSpace(meta.DiscType) != "" {
+		return false, ""
+	}
+
+	// srrdb scene detection (the imdb: fallback) authoritatively compares the
+	// on-disk basename to the canonical scene media filename and sets this when
+	// they differ. It is the strongest signal (a database match, not a heuristic),
+	// so it is checked first and independent of the release group an *arr rename
+	// may strip.
+	if meta.SceneRenamed {
+		reason := strings.TrimSpace(meta.SceneRenamedReason)
+		if reason == "" {
+			reason = modifiedReleaseReason
+		}
+		return true, reason
+	}
+
+	group := strings.TrimSpace(meta.Release.Group)
+	if skipsStandardRenameCheck(group) {
+		return false, ""
+	}
+
+	names := candidateReleaseNames(meta)
+
+	// *arr id tokens mark a rename on their own, independent of the release group
+	// (which an *arr rename often strips), so check them before the group gate.
+	for _, name := range names {
+		if arrRenameToken(name) != "" {
+			return true, modifiedReleaseReason
+		}
+	}
+
+	if group == "" {
+		return false, ""
+	}
+	for _, name := range names {
+		if isRenamedReleaseName(name, group) {
+			return true, modifiedReleaseReason
+		}
+	}
+	return false, ""
+}
+
+// modifiedReleaseReason is deliberately generic: it discloses neither the
+// on-disk name nor which signal fired, so a modified release cannot be trivially
+// resolved by renaming the file back. The source should be investigated (file
+// hash, provenance) rather than papered over with a rename.
+const modifiedReleaseReason = "source appears renamed or modified from its original release name; verify the file hash and source provenance"
+
+// standardRenameCheckSkippedGroups contains release groups that bypass only the
+// standard heuristic rename checks. SRRDB scene rename matches still apply.
+var standardRenameCheckSkippedGroups = map[string]struct{}{
+	"HIDT": {},
+	"SPHD": {},
+}
+
+// skipsStandardRenameCheck reports whether group is configured to bypass the
+// standard non-scene rename heuristics.
+func skipsStandardRenameCheck(group string) bool {
+	_, ok := standardRenameCheckSkippedGroups[strings.ToUpper(strings.TrimSpace(group))]
+	return ok
+}
+
+// arrReleaseIDTokens are the Radarr/Sonarr id-injection tokens that appear in
+// renamed filenames (e.g. "Example Release (2026) {imdb-tt1234567}") and never
+// in an original scene/P2P release name.
+var arrReleaseIDTokens = []string{
+	"{tmdb-", "{imdb-", "{tvdb-",
+	"[tmdb", "(tmdb",
+	"[imdb", "(imdb",
+	"[tvdb", "(tvdb",
+}
+
+// arrRenameToken returns the first *arr id-injection token present in name
+// (case-insensitive), or "" when none is found.
+func arrRenameToken(name string) string {
+	lower := strings.ToLower(name)
+	for _, token := range arrReleaseIDTokens {
+		if strings.Contains(lower, token) {
+			return token
+		}
+	}
+	return ""
+}
+
+// mediaFileExtensions are the on-disk media file extensions whose suffix is
+// stripped from a candidate release name. A source path is frequently a
+// directory whose dotted name legitimately ends in a token like "H.265-GROUP",
+// so the extension must only be removed for actual media files — otherwise
+// filepath.Ext would strip that trailing token and hide the "-GROUP" tag.
+var mediaFileExtensions = map[string]struct{}{
+	".mkv":  {},
+	".mp4":  {},
+	".avi":  {},
+	".ts":   {},
+	".m2ts": {},
+	".m4v":  {},
+	".mov":  {},
+	".wmv":  {},
+	".mpg":  {},
+	".mpeg": {},
+	".vob":  {},
+	".iso":  {},
+}
+
+// candidateReleaseNames returns the on-disk base names that should carry the
+// release name (the source path and the primary video file). A recognized media
+// file extension is stripped; a directory basename is kept whole so dotted
+// tokens in a renamed folder name are preserved.
+func candidateReleaseNames(meta ModifiedReleaseSubject) []string {
+	names := make([]string, 0, 2)
+	seen := make(map[string]struct{}, 2)
+	for _, candidate := range []string{meta.SourcePath, meta.VideoPath} {
+		base := strings.TrimSpace(filepath.Base(strings.TrimSpace(candidate)))
+		if base == "" || base == "." || base == string(filepath.Separator) {
+			continue
+		}
+		if ext := filepath.Ext(base); ext != "" {
+			if _, ok := mediaFileExtensions[strings.ToLower(ext)]; ok {
+				base = strings.TrimSuffix(base, ext)
+			}
+		}
+		if _, ok := seen[base]; ok {
+			continue
+		}
+		seen[base] = struct{}{}
+		names = append(names, base)
+	}
+	return names
+}
+
+// isRenamedReleaseName reports whether a single base name looks like a
+// space-renamed copy of a "-group" scene/P2P release.
+func isRenamedReleaseName(name, group string) bool {
+	if name == "" {
+		return false
+	}
+	if !strings.ContainsAny(name, " \t") {
+		return false
+	}
+	// Parentheses/brackets/braces indicate human/library naming (Plex/Radarr/
+	// Jellyfin), never a scene/P2P release name, so do not treat them as renames.
+	if strings.ContainsAny(name, "()[]{}") {
+		return false
+	}
+	// Require the parsed group to be the actual trailing "-GROUP" tag so a token
+	// the parser mistook for a group (e.g. an id) cannot trigger a false positive.
+	return strings.HasSuffix(strings.ToUpper(name), "-"+strings.ToUpper(group))
+}
diff --git a/internal/releasepolicy/modified_test.go b/internal/releasepolicy/modified_test.go
new file mode 100644
index 00000000..0bcdb0e2
--- /dev/null
+++ b/internal/releasepolicy/modified_test.go
@@ -0,0 +1,280 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package releasepolicy
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestIsRenamedRelease(t *testing.T) {
+	t.Parallel()
+
+	grouped := func(sourcePath string) ModifiedReleaseSubject {
+		return ModifiedReleaseSubject{
+			SourcePath: sourcePath,
+			Release:    api.ReleaseInfo{Group: "GRP"},
+		}
+	}
+
+	cases := []struct {
+		name string
+		meta ModifiedReleaseSubject
+		want bool
+	}{
+		{
+			name: "clean dotted folder with group",
+			meta: grouped("/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP"),
+			want: false,
+		},
+		{
+			name: "renamed spaced folder with group",
+			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP"),
+			want: true,
+		},
+		{
+			name: "renamed spaced single file with group",
+			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv"),
+			want: true,
+		},
+		{
+			name: "spaced name without group tag is not flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Some Home Video 2024"},
+			want: false,
+		},
+		{
+			name: "spaced name whose group is not the trailing tag is not flagged",
+			// Guards against a parser mis-extracting a token as the group.
+			meta: grouped("/data/movies/Some Renamed Movie 2024 1080p WEB-DL"),
+			want: false,
+		},
+		{
+			name: "radarr-renamed folder with imdb token is flagged",
+			// *arr injects {imdb-…} when it renames; this is a modified release the
+			// tracker rejects, regardless of how rls parses the group.
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Movie (2026) {imdb-tt1234567}",
+				Release:    api.ReleaseInfo{Group: "tt1234567"},
+			},
+			want: true,
+		},
+		{
+			name: "sonarr-renamed file with tmdb token is flagged",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/tv/Example Show (2026) {tmdb-12345}/Example Show S01E01 {tmdb-12345}.mkv",
+				VideoPath:  "/data/tv/Example Show (2026) {tmdb-12345}/Example Show S01E01 {tmdb-12345}.mkv",
+			},
+			want: true,
+		},
+		{
+			name: "tvdb token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/tv/Show (2020) {tvdb-360893}"},
+			want: true,
+		},
+		{
+			name: "arr token match is case-insensitive",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) {IMDb-tt1234567}"},
+			want: true,
+		},
+		{
+			name: "arr token is flagged even when the group tag was stripped",
+			// *arr renames frequently drop the trailing -GROUP, so the token check
+			// must fire without a parsed group.
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) {tmdb-12345}"},
+			want: true,
+		},
+		{
+			name: "tmdb bracket token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) [tmdb-12345]"},
+			want: true,
+		},
+		{
+			name: "tmdb paren token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) (tmdb-12345)"},
+			want: true,
+		},
+		{
+			name: "imdb bracket token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) [imdb-tt1234567]"},
+			want: true,
+		},
+		{
+			name: "imdb paren token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/movies/Example Movie (2026) (imdb-tt1234567)"},
+			want: true,
+		},
+		{
+			name: "tvdb bracket token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/tv/Example Show (2026) [tvdb-12345]"},
+			want: true,
+		},
+		{
+			name: "tvdb paren token is flagged",
+			meta: ModifiedReleaseSubject{SourcePath: "/data/tv/Example Show (2026) (tvdb-12345)"},
+			want: true,
+		},
+		{
+			name: "standard rename check skipped for configured group",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Release 2026 2160p MA WEB-DL DDP5 1 HDR H 265-HiDt",
+				Release:    api.ReleaseInfo{Group: "HiDt"},
+			},
+			want: false,
+		},
+		{
+			name: "standard rename check skipped for SPHD",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Release 2026 2160p MA WEB-DL DDP5 1 HDR H 265-SPHD",
+				Release:    api.ReleaseInfo{Group: "SPHD"},
+			},
+			want: false,
+		},
+		{
+			name: "standard arr-token rename check skipped for configured group",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Release (2026) {imdb-tt1234567}-HiDt",
+				Release:    api.ReleaseInfo{Group: "HiDt"},
+			},
+			want: false,
+		},
+		{
+			name: "standard arr-token rename check skipped for SPHD",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Release (2026) {imdb-tt1234567}-SPHD",
+				Release:    api.ReleaseInfo{Group: "SPHD"},
+			},
+			want: false,
+		},
+		{
+			name: "arr-renamed personal release is exempt",
+			meta: ModifiedReleaseSubject{
+				SourcePath:      "/data/movies/Example Movie (2026) {imdb-tt1234567}",
+				PersonalRelease: true,
+			},
+			want: false,
+		},
+		{
+			name: "arr-renamed disc source is exempt",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example Movie (2026) {imdb-tt1234567}",
+				DiscType:   "BDMV",
+			},
+			want: false,
+		},
+		{
+			name: "edition-only brace token without an id token is not an arr rename",
+			// Only the {tmdb-/imdb-/tvdb-} id tokens mark an *arr rename; other
+			// braces (e.g. {edition-…}) must not trigger the token signal, and the
+			// spaces heuristic still skips bracketed names.
+			meta: grouped("/data/movies/Example Movie 2026 2160p WEB-DL {edition-Directors Cut}-GRP"),
+			want: false,
+		},
+		{
+			name: "parenthesized spaced library name without an id token is not flagged",
+			// Guards that the bracket marker still suppresses the whitespace
+			// heuristic when no *arr id token is present.
+			meta: grouped("/data/movies/Example Movie (2026) 2160p WEB-DL-GRP"),
+			want: false,
+		},
+		{
+			name: "personal release is exempt",
+			meta: func() ModifiedReleaseSubject {
+				m := grouped("/data/movies/Example Movie 2026 2160p WEB-DL-GRP")
+				m.PersonalRelease = true
+				return m
+			}(),
+			want: false,
+		},
+		{
+			name: "disc source is exempt",
+			meta: func() ModifiedReleaseSubject {
+				m := grouped("/data/movies/Example Movie 2026 2160p BluRay-GRP")
+				m.DiscType = "BDMV"
+				return m
+			}(),
+			want: false,
+		},
+		{
+			name: "clean folder containing a spaced video file is flagged",
+			// Finding: the tracker inspects the file, so a spaced file inside a clean
+			// dotted folder must still be detected.
+			meta: ModifiedReleaseSubject{
+				SourcePath: "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP",
+				VideoPath:  "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv",
+				Release:    api.ReleaseInfo{Group: "GRP"},
+			},
+			want: true,
+		},
+		{
+			name: "falls back to video path when source path is empty",
+			meta: ModifiedReleaseSubject{
+				SourcePath: "",
+				VideoPath:  "/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv",
+				Release:    api.ReleaseInfo{Group: "GRP"},
+			},
+			want: true,
+		},
+		{
+			name: "spaced folder retaining dotted tokens is still flagged",
+			// A library rename that converts most separators to spaces but leaves
+			// dotted tokens (DDP5.1, H.265) must not have its trailing "-GROUP" tag
+			// stripped by extension handling on the directory basename (filepath.Ext
+			// would otherwise treat ".265-GRP" as an extension).
+			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5.1 HDR H.265-GRP"),
+			want: true,
+		},
+		{
+			name: "srrdb rename signal flags a clean-looking name with no group",
+			// The imdb: fallback authoritatively confirmed a rename that the
+			// heuristics above cannot see (no group tag, no *arr token, no spaces).
+			meta: ModifiedReleaseSubject{
+				SourcePath:         "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
+				SceneRenamed:       true,
+				SceneRenamedReason: "source appears renamed or modified from its original release name; verify the file hash and source provenance",
+			},
+			want: true,
+		},
+		{
+			name: "srrdb rename signal still flags configured standard-skip group",
+			meta: ModifiedReleaseSubject{
+				SourcePath:   "/data/movies/Example.Release.2026.1080p.BluRay.x264-HiDt",
+				Release:      api.ReleaseInfo{Group: "HiDt"},
+				SceneRenamed: true,
+			},
+			want: true,
+		},
+		{
+			name: "srrdb rename signal is exempt for personal release",
+			meta: ModifiedReleaseSubject{
+				SourcePath:      "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
+				PersonalRelease: true,
+				SceneRenamed:    true,
+			},
+			want: false,
+		},
+		{
+			name: "srrdb rename signal is exempt for disc source",
+			meta: ModifiedReleaseSubject{
+				SourcePath:   "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
+				DiscType:     "BDMV",
+				SceneRenamed: true,
+			},
+			want: false,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got, reason := DetectModifiedRelease(tc.meta)
+			if got != tc.want {
+				t.Fatalf("isRenamedRelease = %v (%q), want %v", got, reason, tc.want)
+			}
+			if got && reason == "" {
+				t.Fatal("expected a non-empty reason when renamed")
+			}
+		})
+	}
+}
diff --git a/internal/services/bbcode/bbcode_test.go b/internal/services/bbcode/bbcode_test.go
deleted file mode 100644
index 5f43b3c6..00000000
--- a/internal/services/bbcode/bbcode_test.go
+++ /dev/null
@@ -1,320 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCleanUnit3DDescription(t *testing.T) {
-	desc := "[url=https://blutopia.xyz/torrents/123]Title[/url]\n[img]https://example.com/a.jpg[/img]\n[img]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img]"
-	report := CleanUnit3DDescription(desc, "https://blutopia.xyz")
-
-	if report.Description != "Title" {
-		t.Fatalf("expected description text to be preserved, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://example.com/a.jpg" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanUnit3DDescriptionPreservesFetchedTextWithoutScreenshotBlocks(t *testing.T) {
-	desc := "[center]Existing tracker description[/center]\n\n" +
-		"[center][url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url][/center]\n\n" +
-		"[right][url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url][/right]"
-	report := CleanUnit3DDescription(desc, "https://example.org")
-
-	if report.Description != "[center]Existing tracker description[/center]\n\n[right][url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url][/right]" {
-		t.Fatalf("expected text body without screenshot block, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-}
-
-func TestCleanUnit3DDescriptionConvertsPixhostThumbRawURL(t *testing.T) {
-	desc := "[url=https://pixhost.to/show/11645/685417513_file-upload-0.png][img]https://t1.pixhost.to/thumbs/11645/685417513_file-upload-0.png[/img][/url]"
-	report := CleanUnit3DDescription(desc, "https://example.org")
-
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].RawURL != "https://img1.pixhost.to/images/11645/685417513_file-upload-0.png" {
-		t.Fatalf("unexpected converted raw url %q", report.Images[0].RawURL)
-	}
-}
-
-func TestCleanUnit3DDescriptionRemovesOrphanedTonemapAndEmptyAlign(t *testing.T) {
-	desc := "[center][code] Screenshots have been tonemapped for reference [/code][/center]\n\n[align=center]\n[url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url]\n[/align]"
-	report := CleanUnit3DDescription(desc, "https://example.org")
-
-	if report.Description != "" {
-		t.Fatalf("expected orphaned tonemap note to be discarded, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://img.example/a.jpg" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanUnit3DDescriptionKeepsFirstScreenshotSetAfterTMDBPoster(t *testing.T) {
-	desc := "[center][img=300]https://image.tmdb.org/t/p/original/poster.png[/img][/center]\n\n" +
-		"[center]Stranger.Things.S05E01[/center]\n\n" +
-		"[center]" +
-		"[url=https://imgbox.com/A][img=300]https://images2.imgbox.com/aa/aa/A_o.png[/img][/url] " +
-		"[url=https://imgbox.com/B][img=300]https://images2.imgbox.com/bb/bb/B_o.png[/img][/url] " +
-		"[url=https://imgbox.com/C][img=300]https://images2.imgbox.com/cc/cc/C_o.png[/img][/url]" +
-		"[/center]\n\n" +
-		"[center][spoiler=Other files]" +
-		"[url=https://imgbox.com/D][img=300]https://images2.imgbox.com/dd/dd/D_o.png[/img][/url]" +
-		"[/spoiler][/center]"
-
-	report := CleanUnit3DDescription(desc, "https://example.org")
-
-	if report.Description != "[center]Stranger.Things.S05E01[/center]" {
-		t.Fatalf("expected non-screenshot text to be preserved, got %q", report.Description)
-	}
-	if len(report.Images) != 3 {
-		t.Fatalf("expected first screenshot set only (3 images), got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://images2.imgbox.com/aa/aa/A_o.png" {
-		t.Fatalf("unexpected first image %q", report.Images[0].ImgURL)
-	}
-	if report.Images[1].ImgURL != "https://images2.imgbox.com/bb/bb/B_o.png" {
-		t.Fatalf("unexpected second image %q", report.Images[1].ImgURL)
-	}
-	if report.Images[2].ImgURL != "https://images2.imgbox.com/cc/cc/C_o.png" {
-		t.Fatalf("unexpected third image %q", report.Images[2].ImgURL)
-	}
-}
-
-func TestCleanHDBDescription(t *testing.T) {
-	desc := "Text\n[url=https://imgbox.com/abc][img]https://thumbs2.imgbox.com/abc_t.png[/img][/url]\nhttps://hdbits.org/x"
-	report := CleanHDBDescription(desc)
-
-	if report.Description != "Text" {
-		t.Fatalf("expected description to be cleaned, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].RawURL != "https://images2.imgbox.com/abc_o.png" {
-		t.Fatalf("expected raw url conversion, got %q", report.Images[0].RawURL)
-	}
-}
-
-func TestCleanHDBDescriptionRemovesEmptyURLTags(t *testing.T) {
-	desc := "Text\n[url=][/url] [url=][/url] [url=][/url] [url=][/url]"
-	report := CleanHDBDescription(desc)
-	if report.Description != "Text" {
-		t.Fatalf("expected empty url tags removed, got %q", report.Description)
-	}
-}
-
-func TestCleanBHDDescription(t *testing.T) {
-	desc := "hello\n[url=https://example.com/full/a][img]https://example.com/a.png[/img][/url]\n[img]https://example.com/b.webp[/img]"
-	report := CleanBHDDescription(desc, BHDOptions{Framestor: true, Flux: true})
-
-	if report.Description != "[code]hello[/code]" {
-		t.Fatalf("expected code block description, got %q", report.Description)
-	}
-	if len(report.Images) != 2 {
-		t.Fatalf("expected 2 images, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://example.com/a.png" || report.Images[0].WebURL != "https://example.com/full/a" {
-		t.Fatalf("unexpected first image %+v", report.Images[0])
-	}
-	if report.Images[1].ImgURL != "https://example.com/b.webp" {
-		t.Fatalf("unexpected second image %+v", report.Images[1])
-	}
-	if len(report.Artifacts) != 1 {
-		t.Fatalf("expected 1 artifact, got %d", len(report.Artifacts))
-	}
-	if report.Artifacts[0].Name != "bhd.nfo" {
-		t.Fatalf("unexpected artifact name %q", report.Artifacts[0].Name)
-	}
-}
-
-func TestCleanBHDDescriptionRemovesOrphanedEmptyAlign(t *testing.T) {
-	desc := "[center][code] Screenshots have been tonemapped for reference [/code][/center]\n\n[align=center]\n[url=https://img.example/a.jpg][img]https://img.example/a.jpg[/img][/url]\n[/align]"
-	report := CleanBHDDescription(desc, BHDOptions{})
-
-	if report.Description != "" {
-		t.Fatalf("expected empty wrapper bbcode removed, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://img.example/a.jpg" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanBHDDescriptionRemovesKnownBotSignatures(t *testing.T) {
-	desc := strings.Join([]string{
-		"Body",
-		"[center][b]Uploaded Using [url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url] Auto Uploader[/b][/center]",
-		"[center][url=https://github.com/z-ink/uploadrr][img=300]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img][/url][/center]",
-		"[center][url=https://github.com/edge20200/Only-Uploader]Powered by Only-Uploader[/url][/center]",
-		"[center][url=/torrents?perPage=50&name=Example][/url][/center]",
-		"[right]Created by Upload Assistant[/right]",
-	}, "\n")
-	report := CleanBHDDescription(desc, BHDOptions{})
-
-	if report.Description != "Body" {
-		t.Fatalf("expected bot signatures removed, got %q", report.Description)
-	}
-	if len(report.Images) != 0 {
-		t.Fatalf("expected bot images removed with signatures, got %d", len(report.Images))
-	}
-}
-
-func TestCleanBHDDescriptionKeepsCenteredScreenshotBeforeAitherFooter(t *testing.T) {
-	desc := strings.Join([]string{
-		"Body",
-		"[center][url=https://web.example/1][img=350]https://raw.example/1.png[/img][/url][/center]",
-		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
-	}, "\n\n")
-	report := CleanBHDDescription(desc, BHDOptions{})
-
-	if report.Description != "Body" {
-		t.Fatalf("expected body preserved and footer stripped, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image retained, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://raw.example/1.png" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanPTPDescriptionRemovesKnownBotSignatures(t *testing.T) {
-	desc := strings.Join([]string{
-		"Body",
-		"[center][b]Uploaded Using [url=https://github.com/HDInnovations/UNIT3D]UNIT3D[/url] Auto Uploader[/b][/center]",
-		"[center][url=https://github.com/z-ink/uploadrr][img=300]https://i.ibb.co/2NVWb0c/uploadrr.webp[/img][/url][/center]",
-		"[center][url=https://github.com/edge20200/Only-Uploader]Powered by Only-Uploader[/url][/center]",
-		"[center][url=/torrents?perPage=50&name=Example][/url][/center]",
-		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
-		"[right]Created by Upload Assistant[/right]",
-	}, "\n")
-	report := CleanPTPDescription(desc, "")
-
-	if report.Description != "Body" {
-		t.Fatalf("expected bot signatures removed, got %q", report.Description)
-	}
-	if len(report.Images) != 0 {
-		t.Fatalf("expected bot images removed with signatures, got %d", len(report.Images))
-	}
-}
-
-func TestCleanPTPDescriptionKeepsCenteredScreenshotBeforeAitherFooter(t *testing.T) {
-	desc := strings.Join([]string{
-		"Body",
-		"[center][img]https://raw.example/1.png[/img][/center]",
-		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
-	}, "\n\n")
-	report := CleanPTPDescription(desc, "")
-
-	if report.Description != "Body" {
-		t.Fatalf("expected body preserved and footer stripped, got %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image retained, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://raw.example/1.png" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanPTPDescription(t *testing.T) {
-	desc := "&bull; item\n[quote]x[/quote]\nhttps://example.com/test.jpg"
-	report := CleanPTPDescription(desc, "")
-
-	if report.Description != "- item\n[code]x[/code]" {
-		t.Fatalf("unexpected description %q", report.Description)
-	}
-	if len(report.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(report.Images))
-	}
-	if report.Images[0].ImgURL != "https://example.com/test.jpg" {
-		t.Fatalf("unexpected image url %q", report.Images[0].ImgURL)
-	}
-}
-
-func TestCleanPTPDescriptionRemovesWidthStyledImageBlocks(t *testing.T) {
-	desc := `[align=center]
-[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
-[/align]`
-	report := CleanPTPDescription(desc, "")
-
-	if strings.Contains(report.Description, "[url=][img][/img][/url]") {
-		t.Fatalf("expected no orphaned empty image tags, got %q", report.Description)
-	}
-	if strings.TrimSpace(report.Description) != "" {
-		t.Fatalf("expected screenshot-only description to be removed, got %q", report.Description)
-	}
-}
-
-func TestNormalizeImageRawURLConvertsPixhostThumbURL(t *testing.T) {
-	tests := []struct {
-		name string
-		in   string
-		want string
-	}{
-		{
-			name: "current domain",
-			in:   "https://t1.pixhost.cc/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://img1.pixhost.cc/images/11645/685417513_file-upload-0.png",
-		},
-		{
-			name: "mixed case current domain",
-			in:   "https://T1.PixHost.Cc/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://img1.pixhost.cc/images/11645/685417513_file-upload-0.png",
-		},
-		{
-			name: "legacy domain",
-			in:   "https://t1.pixhost.to/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://img1.pixhost.to/images/11645/685417513_file-upload-0.png",
-		},
-		{
-			name: "exact current host",
-			in:   "https://pixhost.cc/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://pixhost.cc/images/11645/685417513_file-upload-0.png",
-		},
-		{
-			name: "foreign suffix current domain",
-			in:   "https://t1.evilpixhost.cc/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://t1.evilpixhost.cc/thumbs/11645/685417513_file-upload-0.png",
-		},
-		{
-			name: "foreign suffix legacy domain",
-			in:   "https://t1.evilpixhost.to/thumbs/11645/685417513_file-upload-0.png",
-			want: "https://t1.evilpixhost.to/thumbs/11645/685417513_file-upload-0.png",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			value := normalizeImageRawURL(tt.in)
-			if value != tt.want {
-				t.Fatalf("unexpected normalized value %q", value)
-			}
-		})
-	}
-}
-
-func TestIsOnlyBBCode(t *testing.T) {
-	if !isOnlyBBCode("[b][/b]") {
-		t.Fatal("expected only bbcode to be true")
-	}
-	if isOnlyBBCode("text [b][/b]") {
-		t.Fatal("expected text to be false")
-	}
-}
diff --git a/internal/services/bbcode/bhd.go b/internal/services/bbcode/bhd.go
deleted file mode 100644
index b957ac80..00000000
--- a/internal/services/bbcode/bhd.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/services/imagehost"
-)
-
-type BHDOptions struct {
-	Framestor bool
-	Flux      bool
-	BaseDir   string
-	UUID      string
-	OnNFO     func(text string) error
-}
-
-var (
-	bhdSizePattern   = regexp.MustCompile(`(?i)\[size=.*?\]`)
-	bhdURLImgPattern = regexp.MustCompile(`(?is)\[url=(https?://[^\]]+)\]\s*\[img(?:=[^\]]*)?\](https?://[^\[]+?)\[/img\]\s*\[/url\]`)
-	bhdImgTagPattern = regexp.MustCompile(`(?is)\[img(?:=[^\]]*)?\](https?://[^\[]+?)\[/img\]`)
-	bhdLooseImg      = regexp.MustCompile(`(?i)(https?://[^\s\[\]]+\.(?:png|jpe?g|webp|gif)(?:\?[^\s\[\]]*)?)`)
-	bhdEmptyCenter   = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
-	bhdEmptyAlign    = regexp.MustCompile(`(?i)\[align=[^\]]+\]\s*\[/align\]`)
-	bhdTonemapNotice = regexp.MustCompile(`(?is)\[(?:center|align=center)\]\s*\[code\]\s*Screenshots\s+have\s+been\s+tonemapped\s+for\s+reference\s*\[/code\]\s*\[/(?:center|align)\]`)
-	bhdBotSignature  = regexp.MustCompile(`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`)
-)
-
-func CleanBHDDescription(description string, options BHDOptions) Report {
-	desc := normalizeNewlines(description)
-	report := Report{}
-	imagelist := make([]Image, 0)
-
-	if options.Framestor {
-		if options.OnNFO != nil {
-			if err := options.OnNFO(desc); err != nil {
-				report.Notes = append(report.Notes, Note{Kind: "nfo", Message: err.Error()})
-			}
-		}
-		report.Artifacts = append(report.Artifacts, Artifact{Name: "bhd.nfo", Kind: "nfo", Content: desc})
-	}
-
-	desc = bhdSizePattern.ReplaceAllString(desc, "")
-	desc = strings.ReplaceAll(desc, "[/size]", "")
-	desc = bhdBotSignature.ReplaceAllString(desc, "")
-	desc = strings.ReplaceAll(desc, "<", "/")
-	desc = strings.ReplaceAll(desc, "<", "\\")
-
-	seen := make(map[string]struct{})
-	appendImage := func(imgURL, webURL string) {
-		imgURL = strings.TrimSpace(imgURL)
-		if imgURL == "" {
-			return
-		}
-		key := strings.ToLower(imgURL)
-		if _, ok := seen[key]; ok {
-			return
-		}
-		seen[key] = struct{}{}
-		host := imagehost.ExtractHost(imgURL)
-		web := strings.TrimSpace(webURL)
-		if web == "" {
-			web = imgURL
-		}
-		rawURL := normalizeImageRawURL(imgURL)
-		imagelist = append(imagelist, Image{ImgURL: imgURL, RawURL: rawURL, WebURL: web, Host: host})
-	}
-
-	urlImgMatches := bhdURLImgPattern.FindAllStringSubmatch(desc, -1)
-	for _, match := range urlImgMatches {
-		if len(match) < 3 {
-			continue
-		}
-		appendImage(match[2], match[1])
-	}
-	desc = bhdURLImgPattern.ReplaceAllString(desc, "")
-
-	imgTagMatches := bhdImgTagPattern.FindAllStringSubmatch(desc, -1)
-	for _, match := range imgTagMatches {
-		if len(match) < 2 {
-			continue
-		}
-		appendImage(match[1], "")
-	}
-	desc = bhdImgTagPattern.ReplaceAllString(desc, "")
-
-	looseImages := bhdLooseImg.FindAllString(desc, -1)
-	for _, imgURL := range looseImages {
-		appendImage(imgURL, "")
-		desc = strings.ReplaceAll(desc, imgURL, "")
-	}
-
-	for _, image := range imagelist {
-		imgURL := regexp.QuoteMeta(image.ImgURL)
-		urlTag := regexp.MustCompile(`(?i)\[URL=` + imgURL + `\]\[/URL\]`)
-		desc = urlTag.ReplaceAllString(desc, "")
-		urlImg := regexp.MustCompile(`(?i)\[URL=` + imgURL + `\]\[img[^\]]*\]` + imgURL + `\[/img\]\[/URL\]`)
-		desc = urlImg.ReplaceAllString(desc, "")
-	}
-
-	desc = regexp.MustCompile(`(?i)\[URL=[\s\S]*?\]\[/URL\]`).ReplaceAllString(desc, "")
-	desc = bhdTonemapNotice.ReplaceAllString(desc, "")
-	desc = bhdEmptyCenter.ReplaceAllString(desc, "")
-	desc = bhdEmptyAlign.ReplaceAllString(desc, "")
-	desc = removeExtraLines(desc)
-	desc = strings.TrimSpace(desc)
-
-	if options.Flux {
-		desc = strings.TrimRight(desc, " \t\n")
-		desc = strings.Trim(desc, "\n")
-		desc = regexp.MustCompile(`\n\n+`).ReplaceAllString(desc, "\n\n")
-		for strings.HasPrefix(desc, "\n") {
-			desc = strings.TrimPrefix(desc, "\n")
-		}
-		desc = strings.Trim(desc, "\n")
-		if strings.TrimSpace(strings.ReplaceAll(desc, "\n", "")) == "" {
-			return Report{Images: imagelist}
-		}
-		report.Description = "[code]" + desc + "[/code]"
-	} else {
-		report.Description = desc
-	}
-
-	if report.Description == "" {
-		report.Description = ""
-	}
-	if isOnlyBBCode(report.Description) {
-		return Report{Images: imagelist, Notes: report.Notes, Artifacts: report.Artifacts}
-	}
-	return Report{Description: report.Description, Images: imagelist, Notes: report.Notes, Artifacts: report.Artifacts}
-}
diff --git a/internal/services/bbcode/common.go b/internal/services/bbcode/common.go
deleted file mode 100644
index 7edd6772..00000000
--- a/internal/services/bbcode/common.go
+++ /dev/null
@@ -1,320 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"html"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var onlyBBCodePattern = regexp.MustCompile(`\[/?[a-zA-Z0-9]+(?:=[^\]]*)?\]`)
-
-func normalizeNewlines(value string) string {
-	value = html.UnescapeString(value)
-	return strings.ReplaceAll(value, "\r\n", "\n")
-}
-
-func isOnlyBBCode(value string) bool {
-	text := onlyBBCodePattern.ReplaceAllString(value, "")
-	return strings.TrimSpace(text) == ""
-}
-
-func removeExtraLines(value string) string {
-	re := regexp.MustCompile(`\n{3,}`)
-	return re.ReplaceAllString(value, "\n\n")
-}
-
-func convertPreToCode(value string) string {
-	value = strings.ReplaceAll(value, "[pre]", "[code]")
-	value = strings.ReplaceAll(value, "[/pre]", "[/code]")
-	return value
-}
-
-func convertCodeToPre(value string) string {
-	value = strings.ReplaceAll(value, "[code]", "[pre]")
-	value = strings.ReplaceAll(value, "[/code]", "[/pre]")
-	return value
-}
-
-func convertHideToSpoiler(value string) string {
-	value = strings.ReplaceAll(value, "[hide", "[spoiler")
-	value = strings.ReplaceAll(value, "[/hide]", "[/spoiler]")
-	return value
-}
-
-func convertSpoilerToHide(value string) string {
-	value = strings.ReplaceAll(value, "[spoiler", "[hide")
-	value = strings.ReplaceAll(value, "[/spoiler]", "[/hide]")
-	return value
-}
-
-func removeHide(value string) string {
-	value = strings.ReplaceAll(value, "[hide]", "")
-	value = strings.ReplaceAll(value, "[/hide]", "")
-	return value
-}
-
-func convertNamedSpoilerToNamedHide(value string) string {
-	re := regexp.MustCompile(`(?i)\[spoiler=([^]]+)]`)
-	value = re.ReplaceAllString(value, "[hide=$1]")
-	value = strings.ReplaceAll(value, "[/spoiler]", "[/hide]")
-	return value
-}
-
-func removeSpoiler(value string) string {
-	re := regexp.MustCompile(`(?i)\[/?spoiler[\s\S]*?\]`)
-	return re.ReplaceAllString(value, "")
-}
-
-func removeColor(value string) string {
-	re := regexp.MustCompile(`(?i)\[/?color(?:=[^\]]*)?\]`)
-	return re.ReplaceAllString(value, "")
-}
-
-func convertNamedSpoilerToNormalSpoiler(value string) string {
-	re := regexp.MustCompile(`(?i)(\[spoiler=[^]]+])`)
-	return re.ReplaceAllString(value, "[spoiler]")
-}
-
-func convertCodeToQuote(value string) string {
-	value = strings.ReplaceAll(value, "[code", "[quote")
-	value = strings.ReplaceAll(value, "[/code]", "[/quote]")
-	return value
-}
-
-func removeImgResize(value string) string {
-	re := regexp.MustCompile(`(?i)\[img(?:[^\]]*)\]`)
-	return re.ReplaceAllString(value, "[img]")
-}
-
-func convertToAlign(value string) string {
-	reStart := regexp.MustCompile(`\[(right|center|left)\]`)
-	reEnd := regexp.MustCompile(`\[/(right|center|left)\]`)
-	value = reStart.ReplaceAllString(value, "[align=$1]")
-	value = reEnd.ReplaceAllString(value, "[/align]")
-	return value
-}
-
-func removeSup(value string) string {
-	value = strings.ReplaceAll(value, "[sup]", "")
-	value = strings.ReplaceAll(value, "[/sup]", "")
-	return value
-}
-
-func removeSub(value string) string {
-	value = strings.ReplaceAll(value, "[sub]", "")
-	value = strings.ReplaceAll(value, "[/sub]", "")
-	return value
-}
-
-func removeList(value string) string {
-	value = strings.ReplaceAll(value, "[list]", "")
-	value = strings.ReplaceAll(value, "[/list]", "")
-	return value
-}
-
-func convertComparisonToCollapse(value string, maxWidth int) string {
-	re := regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
-	comparisons := re.FindAllString(value, -1)
-	for _, comp := range comparisons {
-		parts := strings.SplitN(comp, "]", 2)
-		if len(parts) < 2 {
-			continue
-		}
-		compSources := strings.ReplaceAll(parts[0], "[comparison=", "")
-		compSources = strings.ReplaceAll(compSources, " ", "")
-		sources := strings.Split(compSources, ",")
-		images := strings.ReplaceAll(parts[1], "[/comparison]", "")
-		images = strings.ReplaceAll(images, ",", "\n")
-		images = strings.ReplaceAll(images, " ", "\n")
-		imgRe := regexp.MustCompile(`(?i)(https?://.*\.(?:png|jpg))`)
-		compImages := imgRe.FindAllString(images, -1)
-		screensPerLine := len(sources)
-		if screensPerLine == 0 {
-			continue
-		}
-		imgSize := min(maxWidth/screensPerLine, 350)
-		line := make([]string, 0, screensPerLine)
-		output := make([]string, 0)
-		for _, img := range compImages {
-			img = strings.TrimSpace(img)
-			if img == "" {
-				continue
-			}
-			bb := "[url=" + img + "][img=" + itoa(imgSize) + "]" + img + "[/img][/url]"
-			line = append(line, bb)
-			if len(line) == screensPerLine {
-				output = append(output, strings.Join(line, ""))
-				line = line[:0]
-			}
-		}
-		outputStr := strings.Join(output, "\n")
-		newBB := "[spoiler=" + strings.Join(sources, " vs ") + "][center]" + strings.Join(sources, " | ") + "[/center]\n" + outputStr + "[/spoiler]"
-		value = strings.ReplaceAll(value, comp, newBB)
-	}
-	return value
-}
-
-func convertComparisonToCentered(value string, maxWidth int) string {
-	re := regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
-	comparisons := re.FindAllString(value, -1)
-	for _, comp := range comparisons {
-		parts := strings.SplitN(comp, "]", 2)
-		if len(parts) < 2 {
-			continue
-		}
-		compSources := strings.TrimSpace(strings.ReplaceAll(parts[0], "[comparison=", ""))
-		sources := regexp.MustCompile(`\s*,\s*`).Split(compSources, -1)
-		images := strings.ReplaceAll(parts[1], "[/comparison]", "")
-		images = strings.ReplaceAll(images, ",", "\n")
-		images = strings.ReplaceAll(images, " ", "\n")
-		imgRe := regexp.MustCompile(`(?i)(https?://.*\.(?:png|jpg))`)
-		compImages := imgRe.FindAllString(images, -1)
-		screensPerLine := len(sources)
-		if screensPerLine == 0 {
-			continue
-		}
-		imgSize := min(maxWidth/screensPerLine, 350)
-		line := make([]string, 0, screensPerLine)
-		output := make([]string, 0)
-		for _, img := range compImages {
-			img = strings.TrimSpace(img)
-			if img == "" {
-				continue
-			}
-			bb := "[url=" + img + "][img=" + itoa(imgSize) + "]" + img + "[/img][/url]"
-			line = append(line, bb)
-			if len(line) == screensPerLine {
-				output = append(output, strings.Join(line, ""))
-				line = line[:0]
-			}
-		}
-		outputStr := strings.Join(output, "\n")
-		newBB := "[center]" + strings.Join(sources, " | ") + "\n" + outputStr + "[/center]"
-		value = strings.ReplaceAll(value, comp, newBB)
-	}
-	return value
-}
-
-func convertCollapseToComparison(value string, spoilerHide string, collapses []string) string {
-	if len(collapses) == 0 {
-		return value
-	}
-	imgTagRe := regexp.MustCompile(`(?i)\[img[\s\S]*?\[/img\]`)
-	imgURLRe := regexp.MustCompile(`(?i)\[img[\s\S]*\]`)
-	for _, tag := range collapses {
-		images := imgTagRe.FindAllString(tag, -1)
-		if len(images) < 6 {
-			continue
-		}
-		compImages := make([]string, 0, len(images))
-		for _, image := range images {
-			imageURL := imgURLRe.ReplaceAllString(strings.ReplaceAll(image, "[/img]", ""), "")
-			compImages = append(compImages, imageURL)
-		}
-		sources := ""
-		if spoilerHide == "spoiler" {
-			match := regexp.MustCompile(`(?i)\[spoiler[\s\S]*?\]`).FindString(tag)
-			if match == "" {
-				continue
-			}
-			sources = strings.TrimSuffix(strings.TrimPrefix(match, "[spoiler="), "]")
-		} else if spoilerHide == "hide" {
-			match := regexp.MustCompile(`(?i)\[hide[\s\S]*?\]`).FindString(tag)
-			if match == "" {
-				continue
-			}
-			sources = strings.TrimSuffix(strings.TrimPrefix(match, "[hide="), "]")
-		}
-		if sources == "" {
-			continue
-		}
-		sources = regexp.MustCompile(`(?i)comparison`).ReplaceAllString(sources, "")
-		for _, sep := range []string{"vs", ",", "|"} {
-			parts := strings.Split(sources, sep)
-			sources = strings.Join(parts, "$")
-		}
-		finalSources := strings.Split(sources, "$")
-		for i, source := range finalSources {
-			finalSources[i] = strings.TrimSpace(source)
-		}
-		compImagesStr := strings.Join(compImages, "\n")
-		finalSourcesStr := strings.Join(finalSources, ", ")
-		spoilToComp := "[comparison=" + finalSourcesStr + "]" + compImagesStr + "[/comparison]"
-		value = strings.ReplaceAll(value, tag, spoilToComp)
-	}
-	return value
-}
-
-func itoa(value int) string {
-	return strconv.Itoa(value)
-}
-
-func normalizeImageRawURL(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	converted := convertImgboxThumbURL(trimmed)
-	converted = convertPixhostThumbURL(converted)
-	return converted
-}
-
-func convertImgboxThumbURL(value string) string {
-	parsed, err := url.Parse(value)
-	if err != nil {
-		return value
-	}
-	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
-	if !strings.Contains(host, "imgbox.com") || !strings.Contains(host, "thumbs") {
-		return value
-	}
-	parsed.Host = strings.ReplaceAll(parsed.Host, "thumbs2.imgbox.com", "images2.imgbox.com")
-	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.png", "_o.png")
-	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.jpg", "_o.jpg")
-	parsed.Path = strings.ReplaceAll(parsed.Path, "_t.jpeg", "_o.jpeg")
-	return parsed.String()
-}
-
-func convertPixhostThumbURL(value string) string {
-	parsed, err := url.Parse(value)
-	if err != nil {
-		return value
-	}
-	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
-	pathValue := strings.TrimSpace(parsed.Path)
-	if !isPixhostHost(host) || !strings.HasPrefix(pathValue, "/thumbs/") {
-		return value
-	}
-	replacePixhostThumbHost(parsed, host)
-	parsed.Path = strings.Replace(pathValue, "/thumbs/", "/images/", 1)
-	return parsed.String()
-}
-
-func replacePixhostThumbHost(parsed *url.URL, host string) {
-	hostParts := strings.SplitN(host, ".", 2)
-	if len(hostParts) != 2 {
-		return
-	}
-	first := hostParts[0]
-	if !strings.HasPrefix(first, "t") || len(first) == 1 {
-		return
-	}
-
-	port := parsed.Port()
-	parsed.Host = "img" + strings.TrimPrefix(first, "t") + "." + hostParts[1]
-	if port != "" {
-		parsed.Host += ":" + port
-	}
-}
-
-func isPixhostHost(host string) bool {
-	return host == "pixhost.cc" ||
-		host == "pixhost.to" ||
-		strings.HasSuffix(host, ".pixhost.cc") ||
-		strings.HasSuffix(host, ".pixhost.to")
-}
diff --git a/internal/services/bbcode/hdb.go b/internal/services/bbcode/hdb.go
deleted file mode 100644
index 738dd127..00000000
--- a/internal/services/bbcode/hdb.go
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/services/imagehost"
-)
-
-var (
-	hdbComparisonSectionPattern = regexp.MustCompile(`(?i)\[center\]\s*\[b\].*?(Comparison|vs).*?\[/b\][\s\S]*?\[/center\]`)
-	hdbComparisonLinePattern    = regexp.MustCompile(`(?i)(.*comparison.*)\n`)
-	hdbEmptyURLPattern          = regexp.MustCompile(`(?i)\[url=https?://(img\.|t\.)?hdbits\.org[^\]]*\]\[/url\]`)
-	hdbEmptyAnyURLPattern       = regexp.MustCompile(`(?is)\[url\s*=\s*]\s*\[/url\]`)
-	hdbURLTagPattern            = regexp.MustCompile(`(?i)(\[url[=]]https?://(img\.|t\.)?hdbits\.org[^\]]+\])(.*?)(\[/url\])?`)
-	hdbImgPattern               = regexp.MustCompile(`(?i)\[img\][\s\S]*?(img\.|t\.)?hdbits\.org[\s\S]*?\[/img\]`)
-	hdbStandalonePattern        = regexp.MustCompile(`(?i)https?://(img\.|t\.)?hdbits\.org/[^\s\[\]]+`)
-	hdbURLTagAnyPattern         = regexp.MustCompile(`(?i)\[url[^\]]*hdbits\.org[^\]]*\](.*?)\[/url\]`)
-	hdbSelfClosingPattern       = regexp.MustCompile(`(?i)\[url=https?://[^\]]*hdbits\.org[^\]]*\]\[/url\]`)
-	hdbCenterEmptyPattern       = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
-	hdbURLImgPattern            = regexp.MustCompile(`(?i)\[url=(https?://[^\]]+)\]\[img\](https?://[^\]]+)\[/img\]\[/url\]`)
-)
-
-func CleanHDBDescription(description string) Report {
-	desc := normalizeNewlines(description)
-	imagelist := make([]Image, 0)
-
-	sections := hdbComparisonSectionPattern.FindAllString(desc, -1)
-	for _, section := range sections {
-		if strings.Contains(strings.ToLower(section), "hdbits.org") {
-			desc = strings.ReplaceAll(desc, section, "")
-		}
-	}
-
-	lines := hdbComparisonLinePattern.FindAllStringIndex(desc, -1)
-	for _, match := range lines {
-		start := match[0]
-		end := min(start+500, len(desc))
-		segment := desc[start:end]
-		parts := strings.SplitN(segment, "\n", 4)
-		if len(parts) > 3 {
-			parts = parts[:3]
-		}
-		nextLines := strings.Join(parts, "\n")
-		if strings.Contains(strings.ToLower(nextLines), "hdbits.org") {
-			desc = strings.ReplaceAll(desc, nextLines, "")
-		}
-	}
-
-	desc = hdbEmptyURLPattern.ReplaceAllString(desc, "")
-	urlTags := hdbURLTagPattern.FindAllString(desc, -1)
-	for _, urlTag := range urlTags {
-		desc = strings.ReplaceAll(desc, urlTag, "")
-	}
-
-	imgTags := hdbImgPattern.FindAllString(desc, -1)
-	for _, imgTag := range imgTags {
-		desc = strings.ReplaceAll(desc, imgTag, "")
-	}
-
-	standalone := hdbStandalonePattern.FindAllString(desc, -1)
-	for _, url := range standalone {
-		desc = strings.ReplaceAll(desc, url, "")
-	}
-
-	desc = hdbURLTagAnyPattern.ReplaceAllString(desc, "")
-	desc = hdbSelfClosingPattern.ReplaceAllString(desc, "")
-	desc = hdbEmptyAnyURLPattern.ReplaceAllString(desc, "")
-	desc = hdbComparisonSectionPattern.ReplaceAllString(desc, "")
-	desc = hdbCenterEmptyPattern.ReplaceAllString(desc, "")
-	desc = removeExtraLines(desc)
-
-	desc = hdbURLImgPattern.ReplaceAllStringFunc(desc, func(value string) string {
-		parts := hdbURLImgPattern.FindStringSubmatch(value)
-		if len(parts) < 3 {
-			return value
-		}
-		webURL := parts[1]
-		imgURL := parts[2]
-		lower := strings.ToLower(webURL + imgURL)
-		if strings.Contains(lower, "hdbits.org") {
-			return ""
-		}
-		rawURL := imgURL
-		rawURL = normalizeImageRawURL(rawURL)
-		host := imagehost.ExtractHost(imgURL)
-		imagelist = append(imagelist, Image{ImgURL: imgURL, RawURL: rawURL, WebURL: webURL, Host: host})
-		return ""
-	})
-
-	desc = strings.TrimSpace(desc)
-	if desc == "" || isOnlyBBCode(desc) {
-		return Report{Images: imagelist}
-	}
-	return Report{Description: desc, Images: imagelist}
-}
diff --git a/internal/services/bbcode/ptp.go b/internal/services/bbcode/ptp.go
deleted file mode 100644
index c77f1780..00000000
--- a/internal/services/bbcode/ptp.go
+++ /dev/null
@@ -1,214 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/services/imagehost"
-)
-
-var (
-	ptpPTPURLPattern               = regexp.MustCompile(`(?i)(?:\[url(?:=|\])[^\]]*https?://passthepopcorn\.m[^\]]*\]|\bhttps?://passthepopcorn\.m[^\s]+)`)
-	ptpHDBURLPattern               = regexp.MustCompile(`(?i)(\[url[=]]https?://hdbits\.o[^\]]+)([^\[]+)(\[/url\])?`)
-	ptpComparePattern              = regexp.MustCompile(`(?i)\[comparison=[\s\S]*?\[/comparison\]`)
-	ptpHidePattern                 = regexp.MustCompile(`(?i)\[hide[\s\S]*?\[/hide\]`)
-	ptpImgPattern                  = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\][\s\S]*?\[/img\]`)
-	ptpLooseImg                    = regexp.MustCompile(`(?i)(https?://[^\s\[\]]+\.(?:png|jpg))`)
-	ptpQuotePattern                = regexp.MustCompile(`(?i)\[quote.*?\]`)
-	ptpAlignPattern                = regexp.MustCompile(`(?i)\[align=.*?\]`)
-	ptpURLTagPattern               = regexp.MustCompile(`(?i)(\[url[=]]https?://passthepopcorn\.m[^\]]+])`)
-	ptpHDBTagPattern               = regexp.MustCompile(`(?i)(\[url[=]]https?://hdbits\.o[^\]]+])`)
-	ptpMediaInfoPattern            = regexp.MustCompile(`(?i)\[mediainfo\][\s\S]*?\[/mediainfo\]`)
-	ptpGeneralUniquePattern        = regexp.MustCompile(`(?im)(^general\nunique)(.*?)^$`)
-	ptpGeneralCompletePattern      = regexp.MustCompile(`(?im)(^general\ncomplete)(.*?)^$`)
-	ptpFormatPattern               = regexp.MustCompile(`(?im)(^(Format[\s]{2,}:))(.*?)^$`)
-	ptpTrackIDPattern              = regexp.MustCompile(`(?im)(^(video|audio|text)( #\d+)?\nid)(.*?)^$`)
-	ptpMenuPattern                 = regexp.MustCompile(`(?im)(^(menu)( #\d+)?\n)(.*?)^$`)
-	ptpBoldMediaPattern            = regexp.MustCompile(`(?is)\[b\](.*?)(Matroska|DTS|AVC|x264|Progressive|23\.976 fps|16:9|[0-9]+x[0-9]+|[0-9]+ MiB|[0-9]+ Kbps|[0-9]+ bits|cabac=.*?/ aq=.*?|\d+\.\d+ Mbps)\[/b\]`)
-	ptpMediaTokenPattern           = regexp.MustCompile(`(?is)(Matroska|DTS|AVC|x264|Progressive|23\.976 fps|16:9|[0-9]+x[0-9]+|[0-9]+ MiB|[0-9]+ Kbps|[0-9]+ bits|cabac=.*?/ aq=.*?|\d+\.\d+ Mbps|[0-9]+\s+channels|[0-9]+\.[0-9]+\s+KHz|[0-9]+ KHz|[0-9]+\s+bits)`)
-	ptpUnderlinedFieldPattern      = regexp.MustCompile(`(?i)\[u\](Format|Bitrate|Channels|Sampling Rate|Resolution):\[/u\]\s*\d*.*?`)
-	ptpNumericMediaLinePattern     = regexp.MustCompile(`(?im)^\s*\d+\s*(channels|KHz|bits)\s*$`)
-	ptpWhitespaceLinePattern       = regexp.MustCompile(`(?m)^\s+$`)
-	ptpMultiNewlinePattern         = regexp.MustCompile(`\n{2,}`)
-	ptpEmptyCenterPattern          = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
-	ptpSizePattern                 = regexp.MustCompile(`(?i)\[size=.*?\]`)
-	ptpVideoPattern                = regexp.MustCompile(`(?i)\[video\][\s\S]*?\[/video\]`)
-	ptpStaffPattern                = regexp.MustCompile(`(?i)\[staff[\s\S]*?\[/staff\]`)
-	ptpDiscInfoPattern             = regexp.MustCompile(`(?i)DISC INFO:[\s\S]*?(\n\n|$)`)
-	ptpDiscTitlePattern            = regexp.MustCompile(`(?i)Disc Title:[\s\S]*?(\n\n|$)`)
-	ptpDiscSizePattern             = regexp.MustCompile(`(?i)Disc Size:[\s\S]*?(\n\n|$)`)
-	ptpProtectionPattern           = regexp.MustCompile(`(?i)Protection:[\s\S]*?(\n\n|$)`)
-	ptpBDJavaPattern               = regexp.MustCompile(`(?i)BD-Java:[\s\S]*?(\n\n|$)`)
-	ptpBDInfoPattern               = regexp.MustCompile(`(?i)BDInfo:[\s\S]*?(\n\n|$)`)
-	ptpPlaylistReportPattern       = regexp.MustCompile(`(?i)PLAYLIST REPORT:[\s\S]*?(\n\n|$)`)
-	ptpNamePattern                 = regexp.MustCompile(`(?i)Name:[\s\S]*?(\n\n|$)`)
-	ptpLengthPattern               = regexp.MustCompile(`(?i)Length:[\s\S]*?(\n\n|$)`)
-	ptpSizeLinePattern             = regexp.MustCompile(`(?i)Size:[\s\S]*?(\n\n|$)`)
-	ptpTotalBitratePattern         = regexp.MustCompile(`(?i)Total Bitrate:[\s\S]*?(\n\n|$)`)
-	ptpVideoSectionPattern         = regexp.MustCompile(`(?i)VIDEO:[\s\S]*?(\n\n|$)`)
-	ptpAudioSectionPattern         = regexp.MustCompile(`(?i)AUDIO:[\s\S]*?(\n\n|$)`)
-	ptpSubtitlesSectionPattern     = regexp.MustCompile(`(?i)SUBTITLES:[\s\S]*?(\n\n|$)`)
-	ptpCodecBitratePattern         = regexp.MustCompile(`(?i)Codec\s+Bitrate\s+Description[\s\S]*?(\n\n|$)`)
-	ptpCodecLanguageBitratePattern = regexp.MustCompile(`(?i)Codec\s+Language\s+Bitrate\s+Description[\s\S]*?(\n\n|$)`)
-	ptpBotSignature                = regexp.MustCompile(`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`)
-)
-
-func CleanPTPDescription(description string, discType string) Report {
-	desc := strings.ReplaceAll(description, "&bull;", "-")
-	desc = normalizeNewlines(desc)
-	desc = ptpBotSignature.ReplaceAllString(desc, "")
-
-	urlTags := ptpPTPURLPattern.FindAllString(desc, -1)
-	hdbTags := ptpHDBURLPattern.FindAllString(desc, -1)
-	urlTags = append(urlTags, hdbTags...)
-	for _, urlTag := range urlTags {
-		cleaned := ptpURLTagPattern.ReplaceAllString(urlTag, "")
-		cleaned = ptpHDBTagPattern.ReplaceAllString(cleaned, "")
-		cleaned = strings.ReplaceAll(cleaned, "[/url]", "")
-		desc = strings.ReplaceAll(desc, urlTag, cleaned)
-	}
-
-	desc = strings.ReplaceAll(desc, "http://passthepopcorn.me", "PTP")
-	desc = strings.ReplaceAll(desc, "https://passthepopcorn.me", "PTP")
-	desc = strings.ReplaceAll(desc, "http://hdbits.org", "HDB")
-	desc = strings.ReplaceAll(desc, "https://hdbits.org", "HDB")
-
-	imagelist := make([]Image, 0)
-	excluded := make(map[string]struct{})
-
-	sourceEncode := regexp.MustCompile(`(?i)\[comparison=Source, Encode\][\s\S]*`).FindAllString(desc, -1)
-	sourceVs := regexp.MustCompile(`(?i)Source Vs Encode:[\s\S]*`).FindAllString(desc, -1)
-	for _, block := range append(sourceEncode, sourceVs...) {
-		urls := ptpLooseImg.FindAllString(block, -1)
-		for _, url := range urls {
-			excluded[url] = struct{}{}
-		}
-		desc = strings.ReplaceAll(desc, block, "")
-	}
-
-	comps := ptpComparePattern.FindAllString(desc, -1)
-	hides := ptpHidePattern.FindAllString(desc, -1)
-	comps = append(comps, hides...)
-	nocomp := desc
-	for url := range excluded {
-		nocomp = strings.ReplaceAll(nocomp, url, "")
-	}
-
-	compPlaceholders := make([]string, 0, len(comps))
-	for i, comp := range comps {
-		nocomp = strings.ReplaceAll(nocomp, comp, "")
-		placeholder := "COMPARISON_PLACEHOLDER-" + itoa(i) + " "
-		desc = strings.ReplaceAll(desc, comp, placeholder)
-		compPlaceholders = append(compPlaceholders, comp)
-	}
-
-	var links []string
-
-	switch strings.ToUpper(strings.TrimSpace(discType)) {
-	case "DVD":
-		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
-	case "BDMV":
-		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
-		desc = ptpDiscInfoPattern.ReplaceAllString(desc, "")
-		desc = ptpDiscTitlePattern.ReplaceAllString(desc, "")
-		desc = ptpDiscSizePattern.ReplaceAllString(desc, "")
-		desc = ptpProtectionPattern.ReplaceAllString(desc, "")
-		desc = ptpBDJavaPattern.ReplaceAllString(desc, "")
-		desc = ptpBDInfoPattern.ReplaceAllString(desc, "")
-		desc = ptpPlaylistReportPattern.ReplaceAllString(desc, "")
-		desc = ptpNamePattern.ReplaceAllString(desc, "")
-		desc = ptpLengthPattern.ReplaceAllString(desc, "")
-		desc = ptpSizeLinePattern.ReplaceAllString(desc, "")
-		desc = ptpTotalBitratePattern.ReplaceAllString(desc, "")
-		desc = ptpVideoSectionPattern.ReplaceAllString(desc, "")
-		desc = ptpAudioSectionPattern.ReplaceAllString(desc, "")
-		desc = ptpSubtitlesSectionPattern.ReplaceAllString(desc, "")
-		desc = ptpCodecBitratePattern.ReplaceAllString(desc, "")
-		desc = ptpCodecLanguageBitratePattern.ReplaceAllString(desc, "")
-	default:
-		desc = ptpMediaInfoPattern.ReplaceAllString(desc, "")
-		desc = ptpGeneralUniquePattern.ReplaceAllString(desc, "")
-		desc = ptpGeneralCompletePattern.ReplaceAllString(desc, "")
-		desc = ptpFormatPattern.ReplaceAllString(desc, "")
-		desc = ptpTrackIDPattern.ReplaceAllString(desc, "")
-		desc = ptpMenuPattern.ReplaceAllString(desc+"\n\n", "")
-
-		desc, links = protectLinks(desc)
-		desc = ptpBoldMediaPattern.ReplaceAllString(desc, "")
-		desc = ptpMediaTokenPattern.ReplaceAllString(desc, "")
-		desc = ptpUnderlinedFieldPattern.ReplaceAllString(desc, "")
-		desc = ptpNumericMediaLinePattern.ReplaceAllString(desc, "")
-		desc = ptpWhitespaceLinePattern.ReplaceAllString(desc, "")
-		desc = ptpMultiNewlinePattern.ReplaceAllString(desc, "\n")
-	}
-
-	desc = restoreLinks(desc, links)
-
-	desc = ptpQuotePattern.ReplaceAllString(desc, "[code]")
-	desc = strings.ReplaceAll(desc, "[/quote]", "[/code]")
-	desc = ptpAlignPattern.ReplaceAllString(desc, "")
-	desc = strings.ReplaceAll(desc, "[/align]", "")
-
-	desc = ptpSizePattern.ReplaceAllString(desc, "")
-	desc = strings.ReplaceAll(desc, "[/size]", "")
-	desc = ptpVideoPattern.ReplaceAllString(desc, "")
-	desc = ptpStaffPattern.ReplaceAllString(desc, "")
-
-	for _, tag := range []string{"[movie]", "[/movie]", "[artist]", "[/artist]", "[user]", "[/user]", "[indent]", "[/indent]", "[size]", "[/size]", "[hr]"} {
-		desc = strings.ReplaceAll(desc, tag, "")
-	}
-
-	desc = ptpImgPattern.ReplaceAllString(desc, "")
-
-	looseImages := ptpLooseImg.FindAllString(nocomp, -1)
-	for _, imgURL := range looseImages {
-		if _, ok := excluded[imgURL]; ok {
-			continue
-		}
-		host := imagehost.ExtractHost(imgURL)
-		rawURL := normalizeImageRawURL(imgURL)
-		imagelist = append(imagelist, Image{ImgURL: imgURL, RawURL: rawURL, WebURL: imgURL, Host: host})
-		desc = strings.ReplaceAll(desc, imgURL, "")
-	}
-
-	for i, comp := range compPlaceholders {
-		cleanComp := regexp.MustCompile(`(?i)\[/?img[\s\S]*?\]`).ReplaceAllString(comp, "")
-		desc = strings.ReplaceAll(desc, "COMPARISON_PLACEHOLDER-"+itoa(i)+" ", cleanComp)
-	}
-
-	desc = convertCollapseToComparison(desc, "hide", hides)
-	desc = ptpEmptyCenterPattern.ReplaceAllString(desc, "")
-
-	desc = strings.Trim(desc, "\n")
-	desc = regexp.MustCompile(`\n\n+`).ReplaceAllString(desc, "\n\n")
-	for strings.HasPrefix(desc, "\n") {
-		desc = strings.TrimPrefix(desc, "\n")
-	}
-	desc = strings.Trim(desc, "\n")
-
-	if strings.TrimSpace(strings.ReplaceAll(desc, "\n", "")) == "" {
-		return Report{Images: imagelist}
-	}
-	if isOnlyBBCode(desc) {
-		return Report{Images: imagelist}
-	}
-	return Report{Description: desc, Images: imagelist}
-}
-
-func protectLinks(value string) (string, []string) {
-	links := regexp.MustCompile(`https?://\S+`).FindAllString(value, -1)
-	for i, link := range links {
-		value = strings.ReplaceAll(value, link, "__LINK_PLACEHOLDER_"+itoa(i)+"__")
-	}
-	return value, links
-}
-
-func restoreLinks(value string, links []string) string {
-	for i, link := range links {
-		value = strings.ReplaceAll(value, "__LINK_PLACEHOLDER_"+itoa(i)+"__", link)
-	}
-	return value
-}
diff --git a/internal/services/bbcode/tracker_profiles.go b/internal/services/bbcode/tracker_profiles.go
deleted file mode 100644
index eb172f7e..00000000
--- a/internal/services/bbcode/tracker_profiles.go
+++ /dev/null
@@ -1,257 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"regexp"
-	"strings"
-)
-
-var (
-	ffURLSizedImagePattern = regexp.MustCompile(`(?i)\[url=(?P<href>[^\]]+)\]\[img=(?P<width>\d+)\](?P<src>[^\[]+)\[/img\]\[/url\]`)
-	ffURLImagePattern      = regexp.MustCompile(`(?i)\[url=(?P<href>[^\]]+)\]\[img\](?P<src>[^\[]+)\[/img\]\[/url\]`)
-	ffSizedImagePattern    = regexp.MustCompile(`(?i)\[img=(?P<width>\d+)\](?P<src>[^\[]+)\[/img\]`)
-	tlCodeTagPattern       = regexp.MustCompile(`(?is)\[c\](.*?)\[/c\]`)
-	tlImageTagPattern      = regexp.MustCompile(`(?i)\[img=[\d"x]+\]`)
-	ptsSceneNFOPattern     = regexp.MustCompile(`(?is)\[center\]\[spoiler=.*? nfo:\]\[code\].*?\[/code\]\[/spoiler\]\[/center\]`)
-	thrSceneNFOPattern     = regexp.MustCompile(`(?is)(\[hide=(?:Scene|FraMeSToR) NFO:\]\[pre\])(.*?)(\[/pre\]\[/hide\])`)
-)
-
-func FinalizeTrackerDescription(tracker string, desc string) string {
-	trimmed := strings.TrimSpace(normalizeNewlines(desc))
-	if trimmed == "" {
-		return ""
-	}
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "ANT":
-		return finalizeANTDescription(trimmed)
-	case "BJS":
-		return finalizeBJSDescription(trimmed)
-	case "BT":
-		return finalizeBTDescription(trimmed)
-	case "DC":
-		return finalizeDCDescription(trimmed)
-	case "FF":
-		return finalizeFFDescription(trimmed)
-	case "FL":
-		return finalizeFLDescription(trimmed)
-	case "GPW":
-		return finalizeGPWDescription(trimmed)
-	case "HDS":
-		return finalizeHDSDescription(trimmed)
-	case "HDT":
-		return finalizeHDTDescription(trimmed)
-	case "IS":
-		return finalizeISDescription(trimmed)
-	case "PTS":
-		return finalizePTSDescription(trimmed)
-	case "SPD":
-		return finalizeSPDDescription(trimmed)
-	case "THR":
-		return finalizeTHRDescription(trimmed)
-	case "TL":
-		return finalizeTLDescription(trimmed)
-	case "TVC":
-		return finalizeTVCDescription(trimmed)
-	default:
-		return trimmed
-	}
-}
-
-func finalizeANTDescription(value string) string {
-	value = convertToAlign(value)
-	value = removeImgResize(value)
-	value = removeSup(value)
-	value = removeSub(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeBJSDescription(value string) string {
-	value = convertNamedSpoilerToNamedHide(value)
-	value = convertSpoilerToHide(value)
-	value = removeImgResize(value)
-	value = convertToAlign(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeBTDescription(value string) string {
-	value = removeImgResize(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeDCDescription(value string) string {
-	value = removeSup(value)
-	value = removeSub(value)
-	value = convertNamedSpoilerToNormalSpoiler(value)
-	value = convertComparisonToCentered(value, 1000)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeFFDescription(value string) string {
-	replacer := strings.NewReplacer(
-		"[user]", "", "[/user]", "",
-		"[align=left]", "", "[/align]", "",
-		"[right]", "", "[/right]", "",
-		"[align=right]", "", "[/align]", "",
-		"[alert]", "", "[/alert]", "",
-		"[note]", "", "[/note]", "",
-		"[hr]", "", "[/hr]", "",
-		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
-		"[ul]", "", "[/ul]", "",
-		"[ol]", "", "[/ol]", "",
-		"[hide]", "", "[/hide]", "",
-		"•", "-", "“", `"`, "”", `"`,
-	)
-	value = replacer.Replace(value)
-	value = removeSub(value)
-	value = removeSup(value)
-	value = convertComparisonToCentered(value, 1000)
-	value = removeSpoiler(value)
-	value = ffURLSizedImagePattern.ReplaceAllString(value, `<a href="$href" target="_blank"><img src="$src" width="$width"></a>`)
-	value = ffURLImagePattern.ReplaceAllString(value, `<a href="$href" target="_blank"><img src="$src" width="220"></a>`)
-	value = ffSizedImagePattern.ReplaceAllString(value, `<img src="$src" width="$width">`)
-	return removeExtraLines(value)
-}
-
-func finalizeFLDescription(value string) string {
-	value = removeSpoiler(value)
-	value = convertCodeToQuote(value)
-	value = convertComparisonToCentered(value, 900)
-	value = removeImgResize(value)
-	return removeExtraLines(value)
-}
-
-func finalizeGPWDescription(value string) string {
-	value = removeSup(value)
-	value = removeSub(value)
-	value = convertToAlign(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeHDSDescription(value string) string {
-	replacer := strings.NewReplacer(
-		"[user]", "", "[/user]", "",
-		"[align=left]", "", "[/align]", "",
-		"[right]", "", "[/right]", "",
-		"[align=right]", "", "[/align]", "",
-		"[alert]", "", "[/alert]", "",
-		"[note]", "", "[/note]", "",
-		"[hr]", "", "[/hr]", "",
-		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
-		"[ul]", "", "[/ul]", "",
-		"[ol]", "", "[/ol]", "",
-	)
-	value = replacer.Replace(value)
-	value = removeSub(value)
-	value = removeSup(value)
-	value = removeHide(value)
-	value = removeImgResize(value)
-	value = convertComparisonToCentered(value, 1000)
-	value = removeSpoiler(value)
-	value = removeColor(value)
-	return removeExtraLines(value)
-}
-
-func finalizeHDTDescription(value string) string {
-	replacer := strings.NewReplacer(
-		"[user]", "", "[/user]", "",
-		"[align=left]", "", "[/align]", "",
-		"[align=right]", "", "[/align]", "",
-		"[alert]", "", "[/alert]", "",
-		"[note]", "", "[/note]", "",
-		"[hr]", "", "[/hr]", "",
-		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
-		"[ul]", "", "[/ul]", "",
-		"[ol]", "", "[/ol]", "",
-	)
-	value = replacer.Replace(value)
-	value = removeSub(value)
-	value = removeSup(value)
-	value = convertSpoilerToHide(value)
-	value = removeImgResize(value)
-	value = convertComparisonToCentered(value, 1000)
-	value = removeSpoiler(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeISDescription(value string) string {
-	return removeExtraLines(value)
-}
-
-func finalizePTSDescription(value string) string {
-	replacer := strings.NewReplacer(
-		"[user]", "", "[/user]", "",
-		"[align=left]", "", "[/align]", "",
-		"[right]", "", "[/right]", "",
-		"[align=right]", "", "[/align=right]", "",
-		"[sup]", "", "[/sup]", "",
-		"[sub]", "", "[/sub]", "",
-		"[alert]", "", "[/alert]", "",
-		"[note]", "", "[/note]", "",
-		"[hr]", "", "[/hr]", "",
-		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
-		"[ul]", "", "[/ul]", "",
-		"[ol]", "", "[/ol]", "",
-		"[hide]", "", "[/hide]", "",
-	)
-	value = replacer.Replace(value)
-	value = ptsSceneNFOPattern.ReplaceAllString(value, "")
-	value = convertComparisonToCentered(value, 1000)
-	value = removeSpoiler(value)
-	return removeExtraLines(value)
-}
-
-func finalizeSPDDescription(value string) string {
-	value = removeImgResize(value)
-	value = convertNamedSpoilerToNormalSpoiler(value)
-	replacer := strings.NewReplacer("[note]", "Note: ", "[/note]", "", "[code]", "", "[/code]", "", "[*]", "• ")
-	value = replacer.Replace(value)
-	value = removeSpoiler(value)
-	value = removeList(value)
-	return removeExtraLines(value)
-}
-
-func finalizeTHRDescription(value string) string {
-	value = convertNamedSpoilerToNamedHide(value)
-	value = convertSpoilerToHide(value)
-	value = convertCodeToPre(value)
-	value = thrSceneNFOPattern.ReplaceAllString(value, `$1[align=left]$2[/align]$3`)
-	return removeExtraLines(value)
-}
-
-func finalizeTLDescription(value string) string {
-	value = strings.ReplaceAll(value, "[center]", "<center>")
-	value = strings.ReplaceAll(value, "[/center]", "</center>")
-	value = regexp.MustCompile(`(?i)\[\*\]`).ReplaceAllString(value, "\n[*]")
-	value = tlCodeTagPattern.ReplaceAllString(value, "[code]$1[/code]")
-	value = regexp.MustCompile(`(?i)\[hr\]`).ReplaceAllString(value, "---")
-	value = tlImageTagPattern.ReplaceAllString(value, "[img]")
-	replacer := strings.NewReplacer("[*] ", "• ", "[*]", "• ", "[note]", "Note: ", "[/note]", "", "[code]", "", "[/code]", "")
-	value = replacer.Replace(value)
-	value = removeList(value)
-	value = convertComparisonToCentered(value, 1000)
-	value = removeSpoiler(value)
-	return removeExtraLines(value)
-}
-
-func finalizeTVCDescription(value string) string {
-	value = convertPreToCode(value)
-	value = convertHideToSpoiler(value)
-	value = convertComparisonToCollapse(value, 1000)
-	return removeExtraLines(value)
-}
diff --git a/internal/services/bbcode/tracker_profiles_test.go b/internal/services/bbcode/tracker_profiles_test.go
deleted file mode 100644
index 2406d862..00000000
--- a/internal/services/bbcode/tracker_profiles_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestFinalizeTrackerDescriptionANT(t *testing.T) {
-	input := "[center][img=350]https://img.example/a.png[/img][/center]\n[sup]x[/sup]\n[sub]y[/sub]\n[list]z[/list]"
-	got := FinalizeTrackerDescription("ANT", input)
-	if !strings.Contains(got, "[align=center][img]https://img.example/a.png[/img][/align]") {
-		t.Fatalf("expected center/img tags normalized for ANT, got %q", got)
-	}
-	if strings.Contains(got, "[sup]") || strings.Contains(got, "[sub]") || strings.Contains(got, "[list]") {
-		t.Fatalf("expected ANT cleanup to strip unsupported tags, got %q", got)
-	}
-}
-
-func TestFinalizeTrackerDescriptionPTS(t *testing.T) {
-	input := "[hide]x[/hide]\n[comparison=A, B]https://img.example/a.png https://img.example/b.png[/comparison]"
-	got := FinalizeTrackerDescription("PTS", input)
-	if strings.Contains(got, "[hide]") {
-		t.Fatalf("expected hide tags removed for PTS, got %q", got)
-	}
-	if !strings.Contains(got, "[center]A | B") {
-		t.Fatalf("expected comparison centered for PTS, got %q", got)
-	}
-}
-
-func TestFinalizeTrackerDescriptionTL(t *testing.T) {
-	input := "[center]x[/center]\n[comparison=A, B]https://img.example/a.png https://img.example/b.png[/comparison]\n[note]n[/note]"
-	got := FinalizeTrackerDescription("TL", input)
-	if !strings.Contains(got, "<center>x</center>") {
-		t.Fatalf("expected center tags converted for TL, got %q", got)
-	}
-	if !strings.Contains(got, "Note: n") {
-		t.Fatalf("expected note tag rewritten for TL, got %q", got)
-	}
-	if strings.Contains(got, "[comparison=") {
-		t.Fatalf("expected comparison converted for TL, got %q", got)
-	}
-}
diff --git a/internal/services/bbcode/types.go b/internal/services/bbcode/types.go
deleted file mode 100644
index 65f3e074..00000000
--- a/internal/services/bbcode/types.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-type Image struct {
-	ImgURL string
-	RawURL string
-	WebURL string
-	Host   string // Normalized host name (e.g., "imgbb", "pixhost")
-}
-
-type Note struct {
-	Kind    string
-	Message string
-}
-
-type Artifact struct {
-	Name    string
-	Kind    string
-	Content string
-}
-
-type Report struct {
-	Description string
-	Images      []Image
-	Notes       []Note
-	Artifacts   []Artifact
-}
diff --git a/internal/services/bbcode/unit3d.go b/internal/services/bbcode/unit3d.go
deleted file mode 100644
index 37d23980..00000000
--- a/internal/services/bbcode/unit3d.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bbcode
-
-import descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-
-func CleanUnit3DDescription(description string, site string) Report {
-	report := descriptionunit3d.CleanDescription(description, site)
-	return Report{
-		Description: report.Description,
-		Images:      convertUnit3DImages(report.Images),
-		Notes:       convertUnit3DNotes(report.Notes),
-	}
-}
-
-func convertUnit3DImages(images []descriptionunit3d.Image) []Image {
-	if len(images) == 0 {
-		return nil
-	}
-	converted := make([]Image, 0, len(images))
-	for _, image := range images {
-		converted = append(converted, Image{
-			ImgURL: image.ImgURL,
-			RawURL: image.RawURL,
-			WebURL: image.WebURL,
-			Host:   image.Host,
-		})
-	}
-	return converted
-}
-
-func convertUnit3DNotes(notes []descriptionunit3d.Note) []Note {
-	if len(notes) == 0 {
-		return nil
-	}
-	converted := make([]Note, 0, len(notes))
-	for _, note := range notes {
-		converted = append(converted, Note{
-			Kind:    note.Kind,
-			Message: note.Message,
-		})
-	}
-	return converted
-}
diff --git a/internal/services/bdinfo/service.go b/internal/services/bdinfo/service.go
index 9becc111..42080086 100644
--- a/internal/services/bdinfo/service.go
+++ b/internal/services/bdinfo/service.go
@@ -94,7 +94,8 @@ func emitDetailedProgressEvent(reporter ProgressReporter, event bdrunner.Progres
 	reporter(stage)
 }
 
-// Service handles BDInfo execution and parsing for BDMV discs
+// Service runs the in-process BDInfo scanner and parses its persisted text
+// reports.
 type Service struct {
 	logger api.Logger
 }
@@ -107,10 +108,12 @@ type ScanResult struct {
 
 type progressReporterKey struct{}
 
-// ProgressReporter receives raw BDInfo progress lines.
+// ProgressReporter receives user-facing progress messages derived from BDInfo
+// scanner stages.
 type ProgressReporter func(line string)
 
-// WithProgressReporter attaches a progress reporter to context.
+// WithProgressReporter attaches a progress reporter to ctx. A nil reporter
+// leaves ctx unchanged.
 func WithProgressReporter(ctx context.Context, reporter ProgressReporter) context.Context {
 	if reporter == nil {
 		return ctx
@@ -139,7 +142,7 @@ func normalizePlaylistSelector(playlistFile string) string {
 	return strings.ToUpper(playlistName)
 }
 
-// New creates a new BDInfo service
+// New returns a BDInfo service, replacing a nil logger with [api.NopLogger].
 func New(logger api.Logger) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
@@ -147,7 +150,10 @@ func New(logger api.Logger) *Service {
 	return &Service{logger: logger}
 }
 
-// ExecuteForPlaylist runs the embedded Go BDInfo scanner for a specific playlist and writes to the caller-provided path.
+// ExecuteForPlaylist scans one playlist and writes its report to outputPath;
+// newly created report files use mode 0600. playlistFile is reduced to an
+// uppercased basename and gains an .MPLS suffix when absent; the returned path
+// may be replaced by the scanner's reported output path.
 func (s *Service) ExecuteForPlaylist(ctx context.Context, bdmvPath string, playlistFile string, outputPath string, summaryOnly bool) (string, error) {
 	result, err := s.execute(ctx, bdmvPath, normalizePlaylistSelector(playlistFile), outputPath, summaryOnly)
 	if err != nil {
@@ -156,7 +162,9 @@ func (s *Service) ExecuteForPlaylist(ctx context.Context, bdmvPath string, playl
 	return result.ReportPath, nil
 }
 
-// ExecuteFullScan runs the embedded Go BDInfo scanner for the full disc and returns the raw report.
+// ExecuteFullScan scans the full disc, writes BD_FULL.txt beneath outputDir,
+// and returns both the persisted path and report text. A newly created report
+// file uses mode 0600.
 func (s *Service) ExecuteFullScan(ctx context.Context, bdmvPath string, outputDir string) (ScanResult, error) {
 	return s.execute(ctx, bdmvPath, "", filepath.Join(outputDir, "BD_FULL.txt"), false)
 }
@@ -220,15 +228,17 @@ func (s *Service) execute(ctx context.Context, bdmvPath string, playlistName str
 	}, nil
 }
 
-// ParseOutput parses BDInfo output and returns structured data
-func (s *Service) ParseOutput(filePath string) (map[string]interface{}, error) {
+// ParseOutput extracts the title, label, size, length, and quick-summary fields
+// present in a persisted BDInfo report. Missing fields are omitted without an
+// error.
+func (s *Service) ParseOutput(filePath string) (map[string]any, error) {
 	content, err := os.ReadFile(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("bdinfo: read output: %w", err)
 	}
 
 	text := string(content)
-	result := make(map[string]interface{})
+	result := make(map[string]any)
 
 	// Extract basic info
 	if idx := strings.Index(text, "Disc Title:"); idx >= 0 {
diff --git a/internal/services/bdinfo/service_test.go b/internal/services/bdinfo/service_test.go
index e73cf60d..6f8476ad 100644
--- a/internal/services/bdinfo/service_test.go
+++ b/internal/services/bdinfo/service_test.go
@@ -199,9 +199,21 @@ func TestExecuteForPlaylistNormalizesLowercaseAndPathPlaylist(t *testing.T) {
 		playlistFile string
 		want         string
 	}{
-		{name: "lowercase extension", playlistFile: "00001.mpls", want: "00001.MPLS"},
-		{name: "full windows path", playlistFile: `D:\Disc\BDMV\PLAYLIST\00002.mpls`, want: "00002.MPLS"},
-		{name: "full slash path no ext", playlistFile: "BDMV/PLAYLIST/00003", want: "00003.MPLS"},
+		{
+			name:         "lowercase extension",
+			playlistFile: "00001.mpls",
+			want:         "00001.MPLS",
+		},
+		{
+			name:         "full windows path",
+			playlistFile: `D:\Disc\BDMV\PLAYLIST\00002.mpls`,
+			want:         "00002.MPLS",
+		},
+		{
+			name:         "full slash path no ext",
+			playlistFile: "BDMV/PLAYLIST/00003",
+			want:         "00003.MPLS",
+		},
 	}
 
 	for _, tc := range tests {
@@ -238,11 +250,31 @@ func TestNormalizePlaylistSelector(t *testing.T) {
 		input string
 		want  string
 	}{
-		{name: "trim and add extension", input: " 00001 ", want: "00001.MPLS"},
-		{name: "preserve extension uppercase", input: "00001.MPLS", want: "00001.MPLS"},
-		{name: "normalize lowercase extension", input: "00001.mpls", want: "00001.MPLS"},
-		{name: "strip windows path", input: `D:\Movie\BDMV\PLAYLIST\00004.mpls`, want: "00004.MPLS"},
-		{name: "strip slash path", input: "BDMV/PLAYLIST/00005", want: "00005.MPLS"},
+		{
+			name:  "trim and add extension",
+			input: " 00001 ",
+			want:  "00001.MPLS",
+		},
+		{
+			name:  "preserve extension uppercase",
+			input: "00001.MPLS",
+			want:  "00001.MPLS",
+		},
+		{
+			name:  "normalize lowercase extension",
+			input: "00001.mpls",
+			want:  "00001.MPLS",
+		},
+		{
+			name:  "strip windows path",
+			input: `D:\Movie\BDMV\PLAYLIST\00004.mpls`,
+			want:  "00004.MPLS",
+		},
+		{
+			name:  "strip slash path",
+			input: "BDMV/PLAYLIST/00005",
+			want:  "00005.MPLS",
+		},
 	}
 
 	for _, tc := range tests {
diff --git a/internal/services/db/capabilities.go b/internal/services/db/capabilities.go
new file mode 100644
index 00000000..fa2aac52
--- /dev/null
+++ b/internal/services/db/capabilities.go
@@ -0,0 +1,13 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import "github.com/autobrr/upbrr/pkg/api"
+
+// RepositoryCapabilities returns immutable borrowed capability views over this
+// SQLite owner. Every view shares its connection, transaction runner, retry
+// policy, migration state, and lifecycle.
+func (r *SQLiteRepository) RepositoryCapabilities() api.RepositoryCapabilities {
+	return api.RepositoryCapabilitiesFrom(r)
+}
diff --git a/internal/services/db/history_capability.go b/internal/services/db/history_capability.go
new file mode 100644
index 00000000..c27cd62d
--- /dev/null
+++ b/internal/services/db/history_capability.go
@@ -0,0 +1,144 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// LoadHistoryRecord assembles one complete persisted history record.
+// Optional release records remain zero-valued when absent; collection ordering
+// is inherited from the canonical SQLite queries.
+func (r *SQLiteRepository) LoadHistoryRecord(ctx context.Context, sourcePath string) (api.HistoryRecord, error) {
+	metadata, err := r.GetByPath(ctx, sourcePath)
+	if err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record metadata: %w", err)
+	}
+	record := api.HistoryRecord{
+		SourcePath:        metadata.Path,
+		ReleaseTitle:      metadata.Title,
+		ReleaseSource:     metadata.Source,
+		ReleaseResolution: metadata.Resolution,
+		MetadataUpdatedAt: metadata.UpdatedAt,
+		Metadata:          metadata,
+	}
+
+	prepared, preparedErr := r.LoadPreparedRelease(ctx, sourcePath)
+	if preparedErr == nil {
+		record.PreparedReleaseRef = &api.ReleaseRef{SourcePath: prepared.Source.SourcePath, Generation: prepared.Generation}
+	} else if !errors.Is(preparedErr, internalerrors.ErrNotFound) {
+		return api.HistoryRecord{}, fmt.Errorf("db history record prepared release: %w", preparedErr)
+	}
+	if record.ReleaseNameOverrides, err = r.GetReleaseNameOverrides(ctx, sourcePath); err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
+		return api.HistoryRecord{}, fmt.Errorf("db history record release overrides: %w", err)
+	}
+	descriptionOverrides, err := r.ListDescriptionOverridesByPath(ctx, sourcePath)
+	if err == nil {
+		record.DescriptionOverrides = append([]api.DescriptionOverride(nil), descriptionOverrides...)
+		record.DescriptionOverride = preferredHistoryDescriptionOverride(descriptionOverrides)
+	} else if !errors.Is(err, internalerrors.ErrNotFound) {
+		return api.HistoryRecord{}, fmt.Errorf("db history record description overrides: %w", err)
+	}
+	if record.PlaylistSelection, err = r.GetPlaylistSelection(ctx, sourcePath); err != nil && !errors.Is(err, internalerrors.ErrNotFound) {
+		return api.HistoryRecord{}, fmt.Errorf("db history record playlist selection: %w", err)
+	}
+	if record.TrackerMetadata, err = r.ListTrackerMetadataByPath(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record tracker metadata: %w", err)
+	}
+	if record.TrackerRuleFailures, err = r.ListTrackerRuleFailuresByPath(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record tracker failures: %w", err)
+	}
+	if record.Screenshots, err = r.ListScreenshotsByPath(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record screenshots: %w", err)
+	}
+	if record.FinalSelections, err = r.ListFinalSelections(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record final selections: %w", err)
+	}
+	if record.UploadedImages, err = r.ListUploadedImagesByPath(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record uploaded images: %w", err)
+	}
+	if record.UploadHistory, err = r.ListUploadHistoryByPath(ctx, sourcePath); err != nil {
+		return api.HistoryRecord{}, fmt.Errorf("db history record upload history: %w", err)
+	}
+	if len(record.UploadHistory) > 0 {
+		record.LatestUploadStatus = record.UploadHistory[0].Status
+		record.LatestUploadAt = record.UploadHistory[0].CreatedAt
+	}
+	return record, nil
+}
+
+// LoadHistoryCleanupSnapshot returns caller-owned local artifact paths and the
+// optional metadata needed to derive the managed release directory.
+func (r *SQLiteRepository) LoadHistoryCleanupSnapshot(ctx context.Context, sourcePath string) (api.HistoryCleanupSnapshot, error) {
+	snapshot := api.HistoryCleanupSnapshot{}
+	shots, err := r.ListScreenshotsByPath(ctx, sourcePath)
+	if err != nil {
+		return api.HistoryCleanupSnapshot{}, fmt.Errorf("db history cleanup screenshots: %w", err)
+	}
+	for _, shot := range shots {
+		snapshot.ArtifactPaths = append(snapshot.ArtifactPaths, shot.ImagePath)
+	}
+	uploaded, err := r.ListUploadedImagesByPath(ctx, sourcePath)
+	if err != nil {
+		return api.HistoryCleanupSnapshot{}, fmt.Errorf("db history cleanup uploaded images: %w", err)
+	}
+	for _, image := range uploaded {
+		snapshot.ArtifactPaths = append(snapshot.ArtifactPaths, image.ImagePath)
+	}
+	finals, err := r.ListFinalSelections(ctx, sourcePath)
+	if err != nil {
+		return api.HistoryCleanupSnapshot{}, fmt.Errorf("db history cleanup final selections: %w", err)
+	}
+	for _, image := range finals {
+		snapshot.ArtifactPaths = append(snapshot.ArtifactPaths, image.ImagePath)
+	}
+	slots, err := r.ListScreenshotSlotsByPath(ctx, sourcePath)
+	if err != nil {
+		return api.HistoryCleanupSnapshot{}, fmt.Errorf("db history cleanup screenshot slots: %w", err)
+	}
+	for _, slot := range slots {
+		snapshot.ArtifactPaths = append(snapshot.ArtifactPaths, slot.ImagePath)
+		for _, variant := range slot.Variants {
+			snapshot.ArtifactPaths = append(snapshot.ArtifactPaths, variant.ImagePath)
+		}
+	}
+	// Metadata only refines the derived temp directory. Preserve cleanup of
+	// known artifact paths when the optional release row cannot be read.
+	if metadata, metadataErr := r.GetByPath(ctx, sourcePath); metadataErr == nil {
+		snapshot.Metadata = &metadata
+	}
+	return snapshot, nil
+}
+
+func preferredHistoryDescriptionOverride(overrides []api.DescriptionOverride) api.DescriptionOverride {
+	if len(overrides) == 0 {
+		return api.DescriptionOverride{}
+	}
+	for _, override := range overrides {
+		if strings.TrimSpace(override.GroupKey) == "" {
+			return override
+		}
+	}
+	for _, override := range overrides {
+		if strings.TrimSpace(override.Description) != "" {
+			return override
+		}
+	}
+	return overrides[0]
+}
+
+var (
+	_ api.ReleaseStateRepository     = (*SQLiteRepository)(nil)
+	_ api.ReleaseSelectionRepository = (*SQLiteRepository)(nil)
+	_ api.HistoryRepository          = (*SQLiteRepository)(nil)
+	_ api.UploadLedgerRepository     = (*SQLiteRepository)(nil)
+	_ api.TrackerStateRepository     = (*SQLiteRepository)(nil)
+	_ api.MediaAssetRepository       = (*SQLiteRepository)(nil)
+)
diff --git a/internal/services/db/logger.go b/internal/services/db/logger.go
index 28d473d0..050ee301 100644
--- a/internal/services/db/logger.go
+++ b/internal/services/db/logger.go
@@ -3,6 +3,9 @@
 
 package db
 
+// Logger receives repository lifecycle, retry, and maintenance diagnostics.
+// Repository operations do not require an error-level method because returned
+// errors remain caller-owned.
 type Logger interface {
 	Debugf(format string, args ...any)
 	Infof(format string, args ...any)
diff --git a/internal/services/db/media_capability.go b/internal/services/db/media_capability.go
new file mode 100644
index 00000000..4a1fb3a9
--- /dev/null
+++ b/internal/services/db/media_capability.go
@@ -0,0 +1,35 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// LoadMediaAssetSnapshot assembles the ordered media records for one release.
+// Each query already returns caller-owned values; nested slot variants are
+// cloned so callers cannot share mutable slice backing storage.
+func (r *SQLiteRepository) LoadMediaAssetSnapshot(ctx context.Context, path string) (api.MediaAssetSnapshot, error) {
+	snapshot := api.MediaAssetSnapshot{}
+	var err error
+	if snapshot.Screenshots, err = r.ListScreenshotsByPath(ctx, path); err != nil {
+		return api.MediaAssetSnapshot{}, fmt.Errorf("db media snapshot screenshots: %w", err)
+	}
+	if snapshot.FinalSelections, err = r.ListFinalSelections(ctx, path); err != nil {
+		return api.MediaAssetSnapshot{}, fmt.Errorf("db media snapshot final selections: %w", err)
+	}
+	if snapshot.ScreenshotSlots, err = r.ListScreenshotSlotsByPath(ctx, path); err != nil {
+		return api.MediaAssetSnapshot{}, fmt.Errorf("db media snapshot screenshot slots: %w", err)
+	}
+	for index := range snapshot.ScreenshotSlots {
+		snapshot.ScreenshotSlots[index].Variants = append([]api.ScreenshotSlotVariant(nil), snapshot.ScreenshotSlots[index].Variants...)
+	}
+	if snapshot.UploadedImages, err = r.ListUploadedImagesByPath(ctx, path); err != nil {
+		return api.MediaAssetSnapshot{}, fmt.Errorf("db media snapshot uploaded images: %w", err)
+	}
+	return snapshot, nil
+}
diff --git a/internal/services/db/migrations.go b/internal/services/db/migrations.go
index b38f40cb..73f2d4bc 100644
--- a/internal/services/db/migrations.go
+++ b/internal/services/db/migrations.go
@@ -59,19 +59,274 @@ type migrationExecutor interface {
 //     bridge mapping also changed historically.
 var migrationRegistry = []migrationStep{
 	{id: baselineMigrationID, apply: createBaselineSchema},
-	{id: "2026_04_add_dvd_mediainfo", dependsOn: []string{baselineMigrationID}, apply: migrateAddDVDMediaInfo},
-	{id: "2026_04_add_release_override_use_season_episode", dependsOn: []string{baselineMigrationID}, apply: migrateAddReleaseOverrideUseSeasonEpisode},
-	{id: "2026_04_add_history_indexes", dependsOn: []string{baselineMigrationID}, apply: migrateAddHistoryIndexes},
-	{id: "2026_04_backfill_uploaded_image_usage_scope", dependsOn: []string{"2026_04_add_history_indexes"}, apply: migrateBackfillUploadedImageUsageScope},
-	{id: "2026_04_add_screenshot_slot_tables", dependsOn: []string{"2026_04_backfill_uploaded_image_usage_scope"}, apply: migrateAddScreenshotSlotTables},
-	{id: "2026_04_normalize_description_overrides", dependsOn: []string{"2026_04_add_screenshot_slot_tables"}, apply: migrateNormalizeDescriptionOverrides},
-	{id: "2026_04_add_tracker_cookies", dependsOn: []string{"2026_04_normalize_description_overrides"}, apply: migrateAddTrackerCookies},
-	{id: "2026_04_add_release_category", dependsOn: []string{"2026_04_add_tracker_cookies"}, apply: migrateAddReleaseCategory},
-	{id: "2026_05_add_bluray_external_metadata", dependsOn: []string{"2026_04_add_release_category"}, apply: migrateAddBlurayExternalMetadata},
-	{id: "2026_06_add_tracker_auth_state", dependsOn: []string{"2026_05_add_bluray_external_metadata"}, apply: migrateAddTrackerAuthState},
-	{id: "2026_07_add_external_ids_mal", dependsOn: []string{"2026_06_add_tracker_auth_state"}, apply: migrateAddExternalIDsMAL},
-	{id: "2026_07_add_anilist_external_metadata", dependsOn: []string{"2026_07_add_external_ids_mal"}, apply: migrateAddAniListExternalMetadata},
-	{id: "2026_07_add_tracker_rule_failure_severity", dependsOn: []string{"2026_07_add_anilist_external_metadata"}, apply: migrateAddTrackerRuleFailureSeverity},
+	{
+		id:        "2026_04_add_dvd_mediainfo",
+		dependsOn: []string{baselineMigrationID},
+		apply:     migrateAddDVDMediaInfo,
+	},
+	{
+		id:        "2026_04_add_release_override_use_season_episode",
+		dependsOn: []string{baselineMigrationID},
+		apply:     migrateAddReleaseOverrideUseSeasonEpisode,
+	},
+	{
+		id:        "2026_04_add_history_indexes",
+		dependsOn: []string{baselineMigrationID},
+		apply:     migrateAddHistoryIndexes,
+	},
+	{
+		id:        "2026_04_backfill_uploaded_image_usage_scope",
+		dependsOn: []string{"2026_04_add_history_indexes"},
+		apply:     migrateBackfillUploadedImageUsageScope,
+	},
+	{
+		id:        "2026_04_add_screenshot_slot_tables",
+		dependsOn: []string{"2026_04_backfill_uploaded_image_usage_scope"},
+		apply:     migrateAddScreenshotSlotTables,
+	},
+	{
+		id:        "2026_04_normalize_description_overrides",
+		dependsOn: []string{"2026_04_add_screenshot_slot_tables"},
+		apply:     migrateNormalizeDescriptionOverrides,
+	},
+	{
+		id:        "2026_04_add_tracker_cookies",
+		dependsOn: []string{"2026_04_normalize_description_overrides"},
+		apply:     migrateAddTrackerCookies,
+	},
+	{
+		id:        "2026_04_add_release_category",
+		dependsOn: []string{"2026_04_add_tracker_cookies"},
+		apply:     migrateAddReleaseCategory,
+	},
+	{
+		id:        "2026_05_add_bluray_external_metadata",
+		dependsOn: []string{"2026_04_add_release_category"},
+		apply:     migrateAddBlurayExternalMetadata,
+	},
+	{
+		id:        "2026_06_add_tracker_auth_state",
+		dependsOn: []string{"2026_05_add_bluray_external_metadata"},
+		apply:     migrateAddTrackerAuthState,
+	},
+	{
+		id:        "2026_07_add_external_ids_mal",
+		dependsOn: []string{"2026_06_add_tracker_auth_state"},
+		apply:     migrateAddExternalIDsMAL,
+	},
+	{
+		id:        "2026_07_add_anilist_external_metadata",
+		dependsOn: []string{"2026_07_add_external_ids_mal"},
+		apply:     migrateAddAniListExternalMetadata,
+	},
+	{
+		id:        "2026_07_add_tracker_rule_failure_severity",
+		dependsOn: []string{"2026_07_add_anilist_external_metadata"},
+		apply:     migrateAddTrackerRuleFailureSeverity,
+	},
+	{
+		id:        "2026_07_add_canonical_release_generations",
+		dependsOn: []string{"2026_07_add_tracker_rule_failure_severity"},
+		apply:     migrateAddCanonicalReleaseGenerations,
+	},
+	{
+		id:        "2026_07_add_tracker_rule_disposition",
+		dependsOn: []string{"2026_07_add_canonical_release_generations"},
+		apply:     migrateAddTrackerRuleDisposition,
+	},
+}
+
+// migrateAddTrackerRuleDisposition adds exact enforcement and authorization
+// state while preserving readable legacy severity rows.
+func migrateAddTrackerRuleDisposition(ctx context.Context, exec migrationExecutor) error {
+	exists, err := tableExists(ctx, exec, "tracker_rule_failures")
+	if err != nil {
+		return err
+	}
+	if !exists {
+		statements := []string{`CREATE TABLE tracker_rule_failures (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			source_path TEXT NOT NULL,
+			tracker TEXT NOT NULL,
+			rule TEXT NOT NULL,
+			reason TEXT NOT NULL DEFAULT "",
+			severity TEXT NOT NULL DEFAULT "blocking",
+			disposition TEXT NOT NULL DEFAULT "waivable",
+			authorized INTEGER NOT NULL DEFAULT 0,
+			created_at TEXT NOT NULL
+		)`,
+			`CREATE INDEX IF NOT EXISTS idx_tracker_rule_failures_source_path ON tracker_rule_failures (source_path)`,
+			`CREATE INDEX IF NOT EXISTS idx_tracker_rule_failures_tracker ON tracker_rule_failures (tracker)`,
+		}
+		for _, statement := range statements {
+			if _, err := exec.ExecContext(ctx, statement); err != nil {
+				return fmt.Errorf("db: add tracker rule disposition table: %w", err)
+			}
+		}
+		return nil
+	}
+	hasDisposition, err := tableColumnExists(ctx, exec, "tracker_rule_failures", "disposition")
+	if err != nil {
+		return err
+	}
+	if !hasDisposition {
+		if _, err := exec.ExecContext(ctx, `ALTER TABLE tracker_rule_failures ADD COLUMN disposition TEXT NOT NULL DEFAULT "waivable"`); err != nil {
+			return fmt.Errorf("db: add tracker rule disposition: %w", err)
+		}
+	}
+	hasAuthorized, err := tableColumnExists(ctx, exec, "tracker_rule_failures", "authorized")
+	if err != nil {
+		return err
+	}
+	if !hasAuthorized {
+		if _, err := exec.ExecContext(ctx, `ALTER TABLE tracker_rule_failures ADD COLUMN authorized INTEGER NOT NULL DEFAULT 0`); err != nil {
+			return fmt.Errorf("db: add tracker rule authorization: %w", err)
+		}
+	}
+	if _, err := exec.ExecContext(ctx, `UPDATE tracker_rule_failures SET disposition = CASE
+		WHEN severity = "warning" THEN "advisory"
+		WHEN severity = "blocking" OR severity = "" THEN "waivable"
+		ELSE "strict"
+	END`); err != nil {
+		return fmt.Errorf("db: backfill tracker rule disposition: %w", err)
+	}
+	return nil
+}
+
+// migrateAddCanonicalReleaseGenerations is the branch's single first-time
+// migration from the last public schema to canonical prepared generations.
+func migrateAddCanonicalReleaseGenerations(ctx context.Context, exec migrationExecutor) error {
+	if _, err := exec.ExecContext(ctx, `
+		CREATE TABLE IF NOT EXISTS prepared_release_current (
+			source_path TEXT PRIMARY KEY,
+			generation INTEGER NOT NULL,
+			source_fingerprint TEXT NOT NULL,
+			fact_instruction_fingerprint TEXT NOT NULL,
+			policy_fingerprint TEXT NOT NULL,
+			contract_version TEXT NOT NULL,
+			source_json TEXT NOT NULL,
+			naming_json TEXT NOT NULL,
+			episode_json TEXT NOT NULL,
+			media_json TEXT NOT NULL,
+			disc_json TEXT NOT NULL,
+			assessments_json TEXT NOT NULL,
+			prepared_at TEXT NOT NULL
+		)
+	`); err != nil {
+		return fmt.Errorf("db: create prepared release current: %w", err)
+	}
+	if _, err := exec.ExecContext(ctx, `
+		CREATE INDEX IF NOT EXISTS idx_prepared_release_current_generation
+		ON prepared_release_current (source_path, generation)
+	`); err != nil {
+		return fmt.Errorf("db: index prepared release current: %w", err)
+	}
+
+	if err := ensurePreparedExternalIDsSchema(ctx, exec); err != nil {
+		return err
+	}
+	if err := ensurePreparedExternalMetadataSchema(ctx, exec); err != nil {
+		return err
+	}
+	if _, err := exec.ExecContext(ctx, `
+		UPDATE external_ids SET
+			source_tmdb = CASE WHEN tmdb_id > 0 AND source_tmdb = "" THEN "legacy" ELSE source_tmdb END,
+			source_imdb = CASE WHEN imdb_id > 0 AND source_imdb = "" THEN "legacy" ELSE source_imdb END,
+			source_tvdb = CASE WHEN tvdb_id > 0 AND source_tvdb = "" THEN "legacy" ELSE source_tvdb END,
+			source_tvmaze = CASE WHEN tvmaze_id > 0 AND source_tvmaze = "" THEN "legacy" ELSE source_tvmaze END,
+			source_mal = CASE WHEN mal_id > 0 AND source_mal = "" THEN "legacy" ELSE source_mal END,
+			category_provenance = CASE WHEN category != "" AND category_provenance = "" THEN "legacy" ELSE category_provenance END,
+			contract_version = CASE WHEN contract_version = "" THEN "legacy" ELSE contract_version END
+	`); err != nil {
+		return fmt.Errorf("db: seed legacy external identity lineage: %w", err)
+	}
+	return nil
+}
+
+func ensurePreparedExternalIDsSchema(ctx context.Context, exec migrationExecutor) error {
+	exists, err := tableExists(ctx, exec, "external_ids")
+	if err != nil {
+		return fmt.Errorf("db: inspect external_ids for prepared release: %w", err)
+	}
+	if !exists {
+		if _, err := exec.ExecContext(ctx, `
+			CREATE TABLE external_ids (
+				source_path TEXT PRIMARY KEY,
+				generation INTEGER NOT NULL DEFAULT 0,
+				tmdb_id INTEGER NOT NULL DEFAULT 0,
+				imdb_id INTEGER NOT NULL DEFAULT 0,
+				tvdb_id INTEGER NOT NULL DEFAULT 0,
+				tvmaze_id INTEGER NOT NULL DEFAULT 0,
+				mal_id INTEGER NOT NULL DEFAULT 0,
+				category TEXT NOT NULL DEFAULT "",
+				source_tmdb TEXT NOT NULL DEFAULT "",
+				source_imdb TEXT NOT NULL DEFAULT "",
+				source_tvdb TEXT NOT NULL DEFAULT "",
+				source_tvmaze TEXT NOT NULL DEFAULT "",
+				source_mal TEXT NOT NULL DEFAULT "",
+				category_provenance TEXT NOT NULL DEFAULT "",
+				override_json TEXT NOT NULL DEFAULT "{}",
+				conflict_status TEXT NOT NULL DEFAULT "none",
+				source_fingerprint TEXT NOT NULL DEFAULT "",
+				intent_fingerprint TEXT NOT NULL DEFAULT "",
+				contract_version TEXT NOT NULL DEFAULT "legacy",
+				resolved_at TEXT NOT NULL DEFAULT "",
+				updated_at TEXT NOT NULL
+			)
+		`); err != nil {
+			return fmt.Errorf("db: create external_ids for prepared release: %w", err)
+		}
+		return nil
+	}
+
+	columns := []struct {
+		name string
+		ddl  string
+	}{
+		{name: "generation", ddl: `ALTER TABLE external_ids ADD COLUMN generation INTEGER NOT NULL DEFAULT 0`},
+		{name: "category_provenance", ddl: `ALTER TABLE external_ids ADD COLUMN category_provenance TEXT NOT NULL DEFAULT ""`},
+		{name: "override_json", ddl: `ALTER TABLE external_ids ADD COLUMN override_json TEXT NOT NULL DEFAULT "{}"`},
+		{name: "conflict_status", ddl: `ALTER TABLE external_ids ADD COLUMN conflict_status TEXT NOT NULL DEFAULT "none"`},
+		{name: "source_fingerprint", ddl: `ALTER TABLE external_ids ADD COLUMN source_fingerprint TEXT NOT NULL DEFAULT ""`},
+		{name: "intent_fingerprint", ddl: `ALTER TABLE external_ids ADD COLUMN intent_fingerprint TEXT NOT NULL DEFAULT ""`},
+		{name: "contract_version", ddl: `ALTER TABLE external_ids ADD COLUMN contract_version TEXT NOT NULL DEFAULT "legacy"`},
+		{name: "resolved_at", ddl: `ALTER TABLE external_ids ADD COLUMN resolved_at TEXT NOT NULL DEFAULT ""`},
+	}
+	for _, column := range columns {
+		columnExists, err := tableColumnExists(ctx, exec, "external_ids", column.name)
+		if err != nil {
+			return fmt.Errorf("db: inspect external_ids.%s: %w", column.name, err)
+		}
+		if columnExists {
+			continue
+		}
+		if _, err := exec.ExecContext(ctx, column.ddl); err != nil {
+			return fmt.Errorf("db: add external_ids.%s: %w", column.name, err)
+		}
+	}
+	return nil
+}
+
+func ensurePreparedExternalMetadataSchema(ctx context.Context, exec migrationExecutor) error {
+	exists, err := tableExists(ctx, exec, "external_metadata")
+	if err != nil {
+		return fmt.Errorf("db: inspect external_metadata for prepared release: %w", err)
+	}
+	if !exists {
+		if err := createExternalMetadataSchema(ctx, exec); err != nil {
+			return err
+		}
+	}
+	columnExists, err := tableColumnExists(ctx, exec, "external_metadata", "generation")
+	if err != nil {
+		return fmt.Errorf("db: inspect external_metadata.generation: %w", err)
+	}
+	if !columnExists {
+		if _, err := exec.ExecContext(ctx, `ALTER TABLE external_metadata ADD COLUMN generation INTEGER NOT NULL DEFAULT 0`); err != nil {
+			return fmt.Errorf("db: add external_metadata.generation: %w", err)
+		}
+	}
+	return nil
 }
 
 // migrateAddTrackerRuleFailureSeverity creates the rule-results table when
@@ -120,10 +375,40 @@ var legacyVersionToMigrationIDs = map[int][]string{
 	2: {baselineMigrationID, "2026_04_add_dvd_mediainfo"},
 	3: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode"},
 	4: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode", "2026_04_add_history_indexes"},
-	5: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode", "2026_04_add_history_indexes", "2026_04_backfill_uploaded_image_usage_scope"},
-	6: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode", "2026_04_add_history_indexes", "2026_04_backfill_uploaded_image_usage_scope", "2026_04_add_screenshot_slot_tables"},
-	7: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode", "2026_04_add_history_indexes", "2026_04_backfill_uploaded_image_usage_scope", "2026_04_add_screenshot_slot_tables", "2026_04_normalize_description_overrides"},
-	8: {baselineMigrationID, "2026_04_add_dvd_mediainfo", "2026_04_add_release_override_use_season_episode", "2026_04_add_history_indexes", "2026_04_backfill_uploaded_image_usage_scope", "2026_04_add_screenshot_slot_tables", "2026_04_normalize_description_overrides", "2026_04_add_tracker_cookies"},
+	5: {
+		baselineMigrationID,
+		"2026_04_add_dvd_mediainfo",
+		"2026_04_add_release_override_use_season_episode",
+		"2026_04_add_history_indexes",
+		"2026_04_backfill_uploaded_image_usage_scope",
+	},
+	6: {
+		baselineMigrationID,
+		"2026_04_add_dvd_mediainfo",
+		"2026_04_add_release_override_use_season_episode",
+		"2026_04_add_history_indexes",
+		"2026_04_backfill_uploaded_image_usage_scope",
+		"2026_04_add_screenshot_slot_tables",
+	},
+	7: {
+		baselineMigrationID,
+		"2026_04_add_dvd_mediainfo",
+		"2026_04_add_release_override_use_season_episode",
+		"2026_04_add_history_indexes",
+		"2026_04_backfill_uploaded_image_usage_scope",
+		"2026_04_add_screenshot_slot_tables",
+		"2026_04_normalize_description_overrides",
+	},
+	8: {
+		baselineMigrationID,
+		"2026_04_add_dvd_mediainfo",
+		"2026_04_add_release_override_use_season_episode",
+		"2026_04_add_history_indexes",
+		"2026_04_backfill_uploaded_image_usage_scope",
+		"2026_04_add_screenshot_slot_tables",
+		"2026_04_normalize_description_overrides",
+		"2026_04_add_tracker_cookies",
+	},
 }
 
 func migrateAddDVDMediaInfo(ctx context.Context, exec migrationExecutor) error {
@@ -276,7 +561,10 @@ func migrateNormalizeDescriptionOverrides(ctx context.Context, exec migrationExe
 		`); err != nil {
 			return fmt.Errorf("db: %w", err)
 		}
-		if _, err := exec.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_description_overrides_source_path ON description_overrides (source_path)`); err != nil {
+		if _, err := exec.ExecContext(
+			ctx,
+			`CREATE INDEX IF NOT EXISTS idx_description_overrides_source_path ON description_overrides (source_path)`,
+		); err != nil {
 			return fmt.Errorf("db: %w", err)
 		}
 		return nil
@@ -585,10 +873,15 @@ func tableExists(ctx context.Context, exec migrationExecutor, tableName string)
 	return count > 0, nil
 }
 
+// Migrate applies the registered migration graph using a background context.
 func Migrate(db *sql.DB) error {
 	return MigrateContext(context.Background(), db)
 }
 
+// MigrateContext validates and applies the registered forward-only migration
+// graph in one BEGIN IMMEDIATE transaction. It bridges a recognized legacy
+// user_version only when no migration IDs are recorded, then leaves the legacy
+// compatibility version at 8 after all pending steps succeed.
 func MigrateContext(ctx context.Context, db *sql.DB) error {
 	return migrateContextWithRegistry(ctx, db, migrationRegistry)
 }
@@ -1072,6 +1365,8 @@ func createBaselineSchema(ctx context.Context, exec migrationExecutor) error {
 			rule TEXT NOT NULL,
 			reason TEXT NOT NULL DEFAULT "",
 			severity TEXT NOT NULL DEFAULT "blocking",
+			disposition TEXT NOT NULL DEFAULT "waivable",
+			authorized INTEGER NOT NULL DEFAULT 0,
 			created_at TEXT NOT NULL
 		)
 		`,
diff --git a/internal/services/db/migrations_test.go b/internal/services/db/migrations_test.go
index 46520cd5..10e78004 100644
--- a/internal/services/db/migrations_test.go
+++ b/internal/services/db/migrations_test.go
@@ -62,7 +62,7 @@ func TestMigrateAddTrackerRuleFailureSeverityHandlesAbsentAndLegacyTables(t *tes
 				if err := db.QueryRowContext(context.Background(), `SELECT severity FROM tracker_rule_failures WHERE rule = "legacy"`).Scan(&severity); err != nil {
 					t.Fatalf("read legacy severity: %v", err)
 				}
-				if severity != string(api.RuleFailureSeverityBlocking) {
+				if severity != "blocking" {
 					t.Fatalf("legacy severity=%q", severity)
 				}
 			}
@@ -70,6 +70,45 @@ func TestMigrateAddTrackerRuleFailureSeverityHandlesAbsentAndLegacyTables(t *tes
 	}
 }
 
+func TestMigrateAddTrackerRuleDispositionNormalizesLegacyRows(t *testing.T) {
+	t.Parallel()
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+	if err := migrateAddTrackerRuleFailureSeverity(context.Background(), db); err != nil {
+		t.Fatalf("create legacy rule table: %v", err)
+	}
+	for _, row := range []struct{ rule, severity string }{{"legacy", "blocking"}, {"advice", "warning"}, {"unknown", "other"}} {
+		if _, err := db.ExecContext(context.Background(), `INSERT INTO tracker_rule_failures (source_path, tracker, rule, severity, created_at) VALUES ("source", "PTP", ?, ?, "now")`, row.rule, row.severity); err != nil {
+			t.Fatalf("seed %s: %v", row.rule, err)
+		}
+	}
+	if err := migrateAddTrackerRuleDisposition(context.Background(), db); err != nil {
+		t.Fatalf("migrate disposition: %v", err)
+	}
+	rows, err := db.QueryContext(context.Background(), `SELECT rule, disposition, authorized FROM tracker_rule_failures ORDER BY id`)
+	if err != nil {
+		t.Fatalf("query: %v", err)
+	}
+	defer rows.Close()
+	want := []api.RuleDisposition{api.RuleDispositionWaivable, api.RuleDispositionAdvisory, api.RuleDispositionStrict}
+	for idx := 0; rows.Next(); idx++ {
+		var rule, disposition string
+		var authorized int
+		if err := rows.Scan(&rule, &disposition, &authorized); err != nil {
+			t.Fatalf("scan: %v", err)
+		}
+		if idx >= len(want) || disposition != string(want[idx]) || authorized != 0 {
+			t.Fatalf("row %s disposition=%q authorized=%d", rule, disposition, authorized)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatalf("iterate rows: %v", err)
+	}
+}
+
 func TestMigrateCreatesTrackerCookiesSchema(t *testing.T) {
 	t.Parallel()
 
@@ -312,6 +351,31 @@ func TestMigrateAddAniListExternalMetadataCreatesMissingTable(t *testing.T) {
 	}
 }
 
+func TestCanonicalReleaseGenerationMigrationIsOnlyBranchMigration(t *testing.T) {
+	const (
+		publicBoundary = "2026_07_add_tracker_rule_failure_severity"
+		finalID        = "2026_07_add_canonical_release_generations"
+		removedID      = "2026_07_add_prepared_release_generations"
+	)
+
+	var final *migrationStep
+	for i := range migrationRegistry {
+		step := &migrationRegistry[i]
+		if step.id == removedID {
+			t.Fatalf("removed branch-only migration %q remains registered", removedID)
+		}
+		if step.id == finalID {
+			final = step
+		}
+	}
+	if final == nil {
+		t.Fatalf("final migration %q is not registered", finalID)
+	}
+	if !slices.Equal(final.dependsOn, []string{publicBoundary}) {
+		t.Fatalf("final migration dependencies = %v, want [%s]", final.dependsOn, publicBoundary)
+	}
+}
+
 func assertSQLiteObjectExists(t *testing.T, db *sql.DB, objectType, name string) {
 	t.Helper()
 
diff --git a/internal/services/db/paths.go b/internal/services/db/paths.go
index 2b24a0ad..ba1d842e 100644
--- a/internal/services/db/paths.go
+++ b/internal/services/db/paths.go
@@ -14,6 +14,11 @@ import (
 const defaultDirName = ".upbrr"
 const defaultDBName = "db.sqlite"
 
+// DefaultPath returns the preferred database path without creating it. When
+// XDG_CONFIG_HOME is set, an existing canonical database wins, followed by an
+// existing legacy .upbrr database under that same config root; otherwise a new
+// canonical XDG path is returned. Without XDG_CONFIG_HOME, the user-home
+// .upbrr path is returned.
 func DefaultPath() (string, error) {
 	if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" {
 		preferred := filepath.Join(xdg, "upbrr", defaultDBName)
@@ -57,6 +62,10 @@ func sameConfigRoot(a, b string) bool {
 	return cleanA == cleanB
 }
 
+// RootDir returns and creates the parent directory used for database-adjacent
+// files. Empty, in-memory, and SQLite URI inputs deliberately resolve to the
+// default on-disk database directory instead of deriving a directory from the
+// connection string.
 func RootDir(dbPath string) (string, error) {
 	trimmed := strings.TrimSpace(dbPath)
 	if trimmed == "" || trimmed == ":memory:" || strings.HasPrefix(trimmed, "file:") {
@@ -73,6 +82,8 @@ func RootDir(dbPath string) (string, error) {
 	return filepath.Dir(cleaned), nil
 }
 
+// Subdir creates name beneath [RootDir] and returns its path. Newly created
+// directories use mode 0700.
 func Subdir(dbPath, name string) (string, error) {
 	root, err := RootDir(dbPath)
 	if err != nil {
@@ -85,6 +96,8 @@ func Subdir(dbPath, name string) (string, error) {
 	return path, nil
 }
 
+// FileInSubdir creates dirName beneath [RootDir] and returns fileName joined
+// within it; it does not create the file.
 func FileInSubdir(dbPath, dirName, fileName string) (string, error) {
 	dir, err := Subdir(dbPath, dirName)
 	if err != nil {
@@ -93,6 +106,8 @@ func FileInSubdir(dbPath, dirName, fileName string) (string, error) {
 	return filepath.Join(dir, fileName), nil
 }
 
+// CookiePath returns a path beneath the managed cookies subdirectory, creating
+// that directory when needed.
 func CookiePath(dbPath, fileName string) (string, error) {
 	return FileInSubdir(dbPath, "cookies", fileName)
 }
diff --git a/internal/services/db/prepared_release.go b/internal/services/db/prepared_release.go
new file mode 100644
index 00000000..b9b0e4e1
--- /dev/null
+++ b/internal/services/db/prepared_release.go
@@ -0,0 +1,524 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// CommitPreparedRelease atomically replaces the current grouped release facts,
+// canonical identity, and source-scoped provider metadata for one source.
+func (r *SQLiteRepository) CommitPreparedRelease(ctx context.Context, release api.PreparedRelease) error {
+	if r == nil || r.db == nil {
+		return errors.New("db: repository not initialized")
+	}
+	generation, err := validatePreparedReleaseForCommit(release)
+	if err != nil {
+		return err
+	}
+
+	preparedAt := release.PreparedAt.UTC()
+	if preparedAt.IsZero() {
+		preparedAt = time.Now().UTC()
+		release.PreparedAt = preparedAt
+	}
+	if release.Identity.ResolvedAt.IsZero() {
+		release.Identity.ResolvedAt = preparedAt
+	}
+	if release.ProviderMetadata.UpdatedAt.IsZero() {
+		release.ProviderMetadata.UpdatedAt = preparedAt
+	}
+
+	sourceJSON, err := encodePreparedJSON(release.Source)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode source: %w", err)
+	}
+	namingJSON, err := encodePreparedJSON(release.Naming)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode naming: %w", err)
+	}
+	episodeJSON, err := encodePreparedJSON(release.Episode)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode episode: %w", err)
+	}
+	mediaJSON, err := encodePreparedJSON(release.Media)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode media: %w", err)
+	}
+	discJSON, err := encodePreparedJSON(release.Disc)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode disc: %w", err)
+	}
+	assessmentsJSON, err := encodePreparedJSON(release.Assessments)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode assessments: %w", err)
+	}
+
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: begin: %w", err)
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	compatibility := release.Compatibility
+	if _, err := tx.ExecContext(ctx, `
+		INSERT INTO prepared_release_current (
+			source_path, generation, source_fingerprint, fact_instruction_fingerprint,
+			policy_fingerprint, contract_version, source_json, naming_json,
+			episode_json, media_json, disc_json, assessments_json, prepared_at
+		)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(source_path) DO UPDATE SET
+			generation = excluded.generation,
+			source_fingerprint = excluded.source_fingerprint,
+			fact_instruction_fingerprint = excluded.fact_instruction_fingerprint,
+			policy_fingerprint = excluded.policy_fingerprint,
+			contract_version = excluded.contract_version,
+			source_json = excluded.source_json,
+			naming_json = excluded.naming_json,
+			episode_json = excluded.episode_json,
+			media_json = excluded.media_json,
+			disc_json = excluded.disc_json,
+			assessments_json = excluded.assessments_json,
+			prepared_at = excluded.prepared_at
+	`,
+		release.Source.SourcePath,
+		generation,
+		compatibility.SourceFingerprint,
+		compatibility.FactInstructionFingerprint,
+		compatibility.PolicyFingerprint,
+		compatibility.ContractVersion,
+		sourceJSON,
+		namingJSON,
+		episodeJSON,
+		mediaJSON,
+		discJSON,
+		assessmentsJSON,
+		preparedAt.Format(time.RFC3339Nano),
+	); err != nil {
+		return fmt.Errorf("db commit prepared release: facts: %w", err)
+	}
+	if err := commitPreparedIdentityTx(ctx, tx, release.Identity, generation); err != nil {
+		return err
+	}
+	if err := commitSourceScopedMetadataTx(ctx, tx, release.ProviderMetadata, generation); err != nil {
+		return err
+	}
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("db commit prepared release: commit: %w", err)
+	}
+	return nil
+}
+
+// LoadPreparedRelease returns the current complete generation for sourcePath.
+// Missing or generation-mismatched identity/metadata is treated as corrupt
+// prepared state rather than silently falling back to legacy rows.
+func (r *SQLiteRepository) LoadPreparedRelease(ctx context.Context, sourcePath string) (api.PreparedRelease, error) {
+	if r == nil || r.db == nil {
+		return api.PreparedRelease{}, errors.New("db: repository not initialized")
+	}
+	sourcePath = strings.TrimSpace(sourcePath)
+	if sourcePath == "" {
+		return api.PreparedRelease{}, internalerrors.ErrInvalidInput
+	}
+
+	tx, err := r.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	if err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: begin: %w", err)
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	row := tx.QueryRowContext(ctx, `
+		SELECT generation, source_fingerprint, fact_instruction_fingerprint,
+			policy_fingerprint, contract_version, source_json, naming_json,
+			episode_json, media_json, disc_json, assessments_json, prepared_at
+		FROM prepared_release_current
+		WHERE source_path = ?
+	`, sourcePath)
+	var release api.PreparedRelease
+	var generation int64
+	var sourceJSON string
+	var namingJSON string
+	var episodeJSON string
+	var mediaJSON string
+	var discJSON string
+	var assessmentsJSON string
+	var preparedAt string
+	if err := row.Scan(
+		&generation,
+		&release.Compatibility.SourceFingerprint,
+		&release.Compatibility.FactInstructionFingerprint,
+		&release.Compatibility.PolicyFingerprint,
+		&release.Compatibility.ContractVersion,
+		&sourceJSON,
+		&namingJSON,
+		&episodeJSON,
+		&mediaJSON,
+		&discJSON,
+		&assessmentsJSON,
+		&preparedAt,
+	); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return api.PreparedRelease{}, internalerrors.ErrNotFound
+		}
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: facts: %w", err)
+	}
+	if generation <= 0 {
+		return api.PreparedRelease{}, errors.New("db load prepared release: invalid generation")
+	}
+	release.Generation = api.PreparedGeneration(generation)
+	if err := decodePreparedJSON(sourceJSON, &release.Source); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode source: %w", err)
+	}
+	if err := decodePreparedJSON(namingJSON, &release.Naming); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode naming: %w", err)
+	}
+	if err := decodePreparedJSON(episodeJSON, &release.Episode); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode episode: %w", err)
+	}
+	if err := decodePreparedJSON(mediaJSON, &release.Media); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode media: %w", err)
+	}
+	if err := decodePreparedJSON(discJSON, &release.Disc); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode disc: %w", err)
+	}
+	if err := decodePreparedJSON(assessmentsJSON, &release.Assessments); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: decode assessments: %w", err)
+	}
+	parsedPreparedAt, err := time.Parse(time.RFC3339Nano, preparedAt)
+	if err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: parse prepared time: %w", err)
+	}
+	release.PreparedAt = parsedPreparedAt
+
+	release.Identity, err = loadPreparedIdentityTx(ctx, tx, sourcePath, release.Generation)
+	if err != nil {
+		return api.PreparedRelease{}, err
+	}
+	release.ProviderMetadata, err = loadSourceScopedMetadataTx(ctx, tx, sourcePath, release.Generation)
+	if err != nil {
+		return api.PreparedRelease{}, err
+	}
+	if err := tx.Commit(); err != nil {
+		return api.PreparedRelease{}, fmt.Errorf("db load prepared release: commit read: %w", err)
+	}
+	return release, nil
+}
+
+// PurgePreparedRelease deletes current prepared facts, canonical identity, and
+// source-scoped provider metadata for one source in one transaction.
+func (r *SQLiteRepository) PurgePreparedRelease(ctx context.Context, sourcePath string) error {
+	if r == nil || r.db == nil {
+		return errors.New("db: repository not initialized")
+	}
+	sourcePath = strings.TrimSpace(sourcePath)
+	if sourcePath == "" {
+		return internalerrors.ErrInvalidInput
+	}
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("db purge prepared release: begin: %w", err)
+	}
+	defer func() { _ = tx.Rollback() }()
+	for _, table := range []string{"prepared_release_current", "external_ids", "external_metadata"} {
+		query := `DELETE FROM ` + table + ` WHERE source_path = ?` //nolint:gosec // Fixed internal table allowlist, no caller SQL.
+		if _, err := tx.ExecContext(ctx, query, sourcePath); err != nil {
+			return fmt.Errorf("db purge prepared release: %s: %w", table, err)
+		}
+	}
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("db purge prepared release: commit: %w", err)
+	}
+	return nil
+}
+
+func validatePreparedReleaseForCommit(release api.PreparedRelease) (int64, error) {
+	sourcePath := strings.TrimSpace(release.Source.SourcePath)
+	if sourcePath == "" || release.Generation == 0 || uint64(release.Generation) > math.MaxInt64 {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	generation := int64(release.Generation) //nolint:gosec // Bounds checked immediately above.
+	compatibility := release.Compatibility
+	if strings.TrimSpace(compatibility.SourceFingerprint) == "" ||
+		strings.TrimSpace(compatibility.FactInstructionFingerprint) == "" ||
+		strings.TrimSpace(compatibility.PolicyFingerprint) == "" ||
+		strings.TrimSpace(compatibility.ContractVersion) == "" {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	if release.Identity.SourcePath != sourcePath || release.Identity.Generation != release.Generation {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	if release.ProviderMetadata.SourcePath != sourcePath || release.ProviderMetadata.Generation != release.Generation {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	if release.Identity.Category == "" || release.Identity.Conflict == "" {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	if release.Assessments.MediaInfoUniqueID == "" || release.Assessments.MediaInfoEncodeSettings == "" ||
+		release.Assessments.Naming.Status == "" {
+		return 0, internalerrors.ErrInvalidInput
+	}
+	return generation, nil
+}
+
+func commitPreparedIdentityTx(ctx context.Context, tx *sql.Tx, identity api.ExternalIdentity, generation int64) error {
+	overrideJSON, err := encodePreparedJSON(identity.Overrides)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: encode identity overrides: %w", err)
+	}
+	resolvedAt := identity.ResolvedAt.UTC().Format(time.RFC3339Nano)
+	_, err = tx.ExecContext(ctx, `
+		INSERT INTO external_ids (
+			source_path, generation, tmdb_id, imdb_id, tvdb_id, tvmaze_id, mal_id,
+			category, source_tmdb, source_imdb, source_tvdb, source_tvmaze,
+			source_mal, category_provenance, override_json, conflict_status,
+			source_fingerprint, intent_fingerprint, contract_version, resolved_at, updated_at
+		)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(source_path) DO UPDATE SET
+			generation = excluded.generation,
+			tmdb_id = excluded.tmdb_id,
+			imdb_id = excluded.imdb_id,
+			tvdb_id = excluded.tvdb_id,
+			tvmaze_id = excluded.tvmaze_id,
+			mal_id = excluded.mal_id,
+			category = excluded.category,
+			source_tmdb = excluded.source_tmdb,
+			source_imdb = excluded.source_imdb,
+			source_tvdb = excluded.source_tvdb,
+			source_tvmaze = excluded.source_tvmaze,
+			source_mal = excluded.source_mal,
+			category_provenance = excluded.category_provenance,
+			override_json = excluded.override_json,
+			conflict_status = excluded.conflict_status,
+			source_fingerprint = excluded.source_fingerprint,
+			intent_fingerprint = excluded.intent_fingerprint,
+			contract_version = excluded.contract_version,
+			resolved_at = excluded.resolved_at,
+			updated_at = excluded.updated_at
+	`,
+		identity.SourcePath,
+		generation,
+		identity.TMDBID,
+		identity.IMDBID,
+		identity.TVDBID,
+		identity.TVmazeID,
+		identity.MALID,
+		string(identity.Category),
+		string(identity.Provenance.TMDB),
+		string(identity.Provenance.IMDB),
+		string(identity.Provenance.TVDB),
+		string(identity.Provenance.TVmaze),
+		string(identity.Provenance.MAL),
+		string(identity.Provenance.Category),
+		overrideJSON,
+		string(identity.Conflict),
+		identity.Resolution.SourceFingerprint,
+		identity.Resolution.IntentFingerprint,
+		identity.Resolution.ContractVersion,
+		resolvedAt,
+		resolvedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: identity: %w", err)
+	}
+	return nil
+}
+
+func commitSourceScopedMetadataTx(ctx context.Context, tx *sql.Tx, metadata api.SourceScopedMetadata, generation int64) error {
+	updatedAt := metadata.UpdatedAt.UTC().Format(time.RFC3339Nano)
+	_, err := tx.ExecContext(ctx, `
+		INSERT INTO external_metadata (
+			source_path, generation, tmdb_json, imdb_json, tvdb_json,
+			tvmaze_json, anilist_json, bluray_json, updated_at
+		)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(source_path) DO UPDATE SET
+			generation = excluded.generation,
+			tmdb_json = excluded.tmdb_json,
+			imdb_json = excluded.imdb_json,
+			tvdb_json = excluded.tvdb_json,
+			tvmaze_json = excluded.tvmaze_json,
+			anilist_json = excluded.anilist_json,
+			bluray_json = excluded.bluray_json,
+			updated_at = excluded.updated_at
+	`,
+		metadata.SourcePath,
+		generation,
+		encodeOptionalJSON(metadata.TMDB),
+		encodeOptionalJSON(metadata.IMDB),
+		encodeOptionalJSON(metadata.TVDB),
+		encodeOptionalJSON(metadata.TVmaze),
+		encodeOptionalJSON(metadata.AniList),
+		encodeOptionalJSON(metadata.Bluray),
+		updatedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("db commit prepared release: provider metadata: %w", err)
+	}
+	return nil
+}
+
+func loadPreparedIdentityTx(
+	ctx context.Context,
+	tx *sql.Tx,
+	sourcePath string,
+	wantGeneration api.PreparedGeneration,
+) (api.ExternalIdentity, error) {
+	row := tx.QueryRowContext(ctx, `
+		SELECT generation, tmdb_id, imdb_id, tvdb_id, tvmaze_id, mal_id, category,
+			source_tmdb, source_imdb, source_tvdb, source_tvmaze, source_mal,
+			category_provenance, override_json, conflict_status, source_fingerprint,
+			intent_fingerprint, contract_version, resolved_at
+		FROM external_ids
+		WHERE source_path = ?
+	`, sourcePath)
+	identity := api.ExternalIdentity{SourcePath: sourcePath}
+	var generation int64
+	var category string
+	var sourceTMDB string
+	var sourceIMDB string
+	var sourceTVDB string
+	var sourceTVmaze string
+	var sourceMAL string
+	var categoryProvenance string
+	var overrideJSON string
+	var conflictStatus string
+	var resolvedAt string
+	if err := row.Scan(
+		&generation,
+		&identity.TMDBID,
+		&identity.IMDBID,
+		&identity.TVDBID,
+		&identity.TVmazeID,
+		&identity.MALID,
+		&category,
+		&sourceTMDB,
+		&sourceIMDB,
+		&sourceTVDB,
+		&sourceTVmaze,
+		&sourceMAL,
+		&categoryProvenance,
+		&overrideJSON,
+		&conflictStatus,
+		&identity.Resolution.SourceFingerprint,
+		&identity.Resolution.IntentFingerprint,
+		&identity.Resolution.ContractVersion,
+		&resolvedAt,
+	); err != nil {
+		return api.ExternalIdentity{}, fmt.Errorf("db load prepared release: identity: %w", err)
+	}
+	if generation <= 0 || api.PreparedGeneration(generation) != wantGeneration {
+		return api.ExternalIdentity{}, errors.New("db load prepared release: identity generation mismatch")
+	}
+	identity.Generation = api.PreparedGeneration(generation)
+	identity.Category = api.CanonicalCategory(category)
+	identity.Provenance = api.IdentityProvenanceSet{
+		TMDB:     api.IdentityProvenance(sourceTMDB),
+		IMDB:     api.IdentityProvenance(sourceIMDB),
+		TVDB:     api.IdentityProvenance(sourceTVDB),
+		TVmaze:   api.IdentityProvenance(sourceTVmaze),
+		MAL:      api.IdentityProvenance(sourceMAL),
+		Category: api.IdentityProvenance(categoryProvenance),
+	}
+	identity.Conflict = api.IdentityConflictStatus(conflictStatus)
+	if err := decodePreparedJSON(overrideJSON, &identity.Overrides); err != nil {
+		return api.ExternalIdentity{}, fmt.Errorf("db load prepared release: decode identity overrides: %w", err)
+	}
+	parsedResolvedAt, err := time.Parse(time.RFC3339Nano, resolvedAt)
+	if err != nil {
+		return api.ExternalIdentity{}, fmt.Errorf("db load prepared release: parse identity time: %w", err)
+	}
+	identity.ResolvedAt = parsedResolvedAt
+	return identity, nil
+}
+
+func loadSourceScopedMetadataTx(
+	ctx context.Context,
+	tx *sql.Tx,
+	sourcePath string,
+	wantGeneration api.PreparedGeneration,
+) (api.SourceScopedMetadata, error) {
+	row := tx.QueryRowContext(ctx, `
+		SELECT generation, tmdb_json, imdb_json, tvdb_json, tvmaze_json,
+			anilist_json, bluray_json, updated_at
+		FROM external_metadata
+		WHERE source_path = ?
+	`, sourcePath)
+	metadata := api.SourceScopedMetadata{SourcePath: sourcePath}
+	var generation int64
+	var tmdbJSON string
+	var imdbJSON string
+	var tvdbJSON string
+	var tvmazeJSON string
+	var anilistJSON string
+	var blurayJSON string
+	var updatedAt string
+	if err := row.Scan(
+		&generation,
+		&tmdbJSON,
+		&imdbJSON,
+		&tvdbJSON,
+		&tvmazeJSON,
+		&anilistJSON,
+		&blurayJSON,
+		&updatedAt,
+	); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: provider metadata: %w", err)
+	}
+	if generation <= 0 || api.PreparedGeneration(generation) != wantGeneration {
+		return api.SourceScopedMetadata{}, errors.New("db load prepared release: provider metadata generation mismatch")
+	}
+	metadata.Generation = api.PreparedGeneration(generation)
+	var err error
+	if metadata.TMDB, err = decodeOptionalJSON[api.TMDBMetadata](tmdbJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode TMDB metadata: %w", err)
+	}
+	if metadata.IMDB, err = decodeOptionalJSON[api.IMDBMetadata](imdbJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode IMDb metadata: %w", err)
+	}
+	if metadata.TVDB, err = decodeOptionalJSON[api.TVDBMetadata](tvdbJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode TVDB metadata: %w", err)
+	}
+	if metadata.TVmaze, err = decodeOptionalJSON[api.TVmazeMetadata](tvmazeJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode TVmaze metadata: %w", err)
+	}
+	if metadata.AniList, err = decodeOptionalJSON[api.AniListMetadata](anilistJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode AniList metadata: %w", err)
+	}
+	if metadata.Bluray, err = decodeOptionalJSON[api.BlurayMetadata](blurayJSON); err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: decode Blu-ray metadata: %w", err)
+	}
+	parsedUpdatedAt, err := time.Parse(time.RFC3339Nano, updatedAt)
+	if err != nil {
+		return api.SourceScopedMetadata{}, fmt.Errorf("db load prepared release: parse provider metadata time: %w", err)
+	}
+	metadata.UpdatedAt = parsedUpdatedAt
+	return metadata, nil
+}
+
+func encodePreparedJSON(value any) (string, error) {
+	payload, err := json.Marshal(value)
+	if err != nil {
+		return "", fmt.Errorf("marshal JSON: %w", err)
+	}
+	return string(payload), nil
+}
+
+func decodePreparedJSON(payload string, target any) error {
+	if err := json.Unmarshal([]byte(payload), target); err != nil {
+		return fmt.Errorf("unmarshal JSON: %w", err)
+	}
+	return nil
+}
diff --git a/internal/services/db/prepared_release_test.go b/internal/services/db/prepared_release_test.go
new file mode 100644
index 00000000..841b47b3
--- /dev/null
+++ b/internal/services/db/prepared_release_test.go
@@ -0,0 +1,274 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestPreparedReleaseCommitExactReadback(t *testing.T) {
+	repo := openPreparedReleaseTestRepo(t)
+	release := preparedReleaseDBFixture(filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv"), 7)
+
+	if err := repo.CommitPreparedRelease(context.Background(), release); err != nil {
+		t.Fatalf("commit prepared release: %v", err)
+	}
+	loaded, err := repo.LoadPreparedRelease(context.Background(), release.Source.SourcePath)
+	if err != nil {
+		t.Fatalf("load prepared release: %v", err)
+	}
+	if !reflect.DeepEqual(loaded, release) {
+		t.Fatalf("loaded prepared release differs\ngot:  %#v\nwant: %#v", loaded, release)
+	}
+}
+
+func TestPreparedReleaseCommitFailureRollsBackWholeGeneration(t *testing.T) {
+	repo := openPreparedReleaseTestRepo(t)
+	release := preparedReleaseDBFixture(filepath.Join(t.TempDir(), "Example.Release.2026.2160p-GRP.mkv"), 9)
+	ctx := context.Background()
+	if _, err := repo.RawDB().ExecContext(ctx, `
+		CREATE TRIGGER fail_prepared_metadata
+		BEFORE INSERT ON external_metadata
+		BEGIN
+			SELECT RAISE(ABORT, 'forced provider metadata failure');
+		END
+	`); err != nil {
+		t.Fatalf("create failure trigger: %v", err)
+	}
+
+	err := repo.CommitPreparedRelease(ctx, release)
+	if err == nil || !strings.Contains(err.Error(), "forced provider metadata failure") {
+		t.Fatalf("commit error = %v", err)
+	}
+	if _, err := repo.LoadPreparedRelease(ctx, release.Source.SourcePath); !errors.Is(err, internalerrors.ErrNotFound) {
+		t.Fatalf("load after rollback error = %v, want not found", err)
+	}
+	var identityCount int
+	if err := repo.RawDB().QueryRowContext(ctx, `SELECT COUNT(*) FROM external_ids WHERE source_path = ?`, release.Source.SourcePath).Scan(&identityCount); err != nil {
+		t.Fatalf("count identities: %v", err)
+	}
+	if identityCount != 0 {
+		t.Fatalf("identity rows after rollback = %d", identityCount)
+	}
+}
+
+func TestPreparedReleaseLoadRejectsMixedGeneration(t *testing.T) {
+	repo := openPreparedReleaseTestRepo(t)
+	release := preparedReleaseDBFixture(filepath.Join(t.TempDir(), "Example.Release.2026.720p-GRP.mkv"), 4)
+	ctx := context.Background()
+	if err := repo.CommitPreparedRelease(ctx, release); err != nil {
+		t.Fatalf("commit prepared release: %v", err)
+	}
+	if _, err := repo.RawDB().ExecContext(
+		ctx,
+		`UPDATE external_metadata SET generation = ? WHERE source_path = ?`,
+		int64(release.Generation+1),
+		release.Source.SourcePath,
+	); err != nil {
+		t.Fatalf("corrupt provider generation: %v", err)
+	}
+
+	_, err := repo.LoadPreparedRelease(ctx, release.Source.SourcePath)
+	if err == nil || !strings.Contains(err.Error(), "generation mismatch") {
+		t.Fatalf("load error = %v, want generation mismatch", err)
+	}
+}
+
+func TestPreparedReleasePurgeDeletesGenerationState(t *testing.T) {
+	repo := openPreparedReleaseTestRepo(t)
+	release := preparedReleaseDBFixture(filepath.Join(t.TempDir(), "Example.Release.2026.WEB-GRP.mkv"), 3)
+	ctx := context.Background()
+	if err := repo.CommitPreparedRelease(ctx, release); err != nil {
+		t.Fatalf("commit prepared release: %v", err)
+	}
+	if err := repo.PurgePreparedRelease(ctx, release.Source.SourcePath); err != nil {
+		t.Fatalf("purge prepared release: %v", err)
+	}
+	if _, err := repo.LoadPreparedRelease(ctx, release.Source.SourcePath); !errors.Is(err, internalerrors.ErrNotFound) {
+		t.Fatalf("load after purge error = %v, want not found", err)
+	}
+	for _, table := range []string{"external_ids", "external_metadata"} {
+		var count int
+		query := `SELECT COUNT(*) FROM ` + table + ` WHERE source_path = ?`
+		if err := repo.RawDB().QueryRowContext(ctx, query, release.Source.SourcePath).Scan(&count); err != nil {
+			t.Fatalf("count %s: %v", table, err)
+		}
+		if count != 0 {
+			t.Fatalf("%s rows after purge = %d", table, count)
+		}
+	}
+}
+
+func TestCanonicalReleaseGenerationMigrationSeedsLegacyIdentityLineage(t *testing.T) {
+	repoPath := filepath.Join(t.TempDir(), "legacy-prepared-release.db")
+	repo, err := OpenWithLogger(repoPath, nopLogger{})
+	if err != nil {
+		t.Fatalf("open repository: %v", err)
+	}
+	t.Cleanup(func() { _ = repo.Close() })
+	ctx := context.Background()
+	statements := []string{
+		`CREATE TABLE external_ids (
+			source_path TEXT PRIMARY KEY, tmdb_id INTEGER NOT NULL DEFAULT 0,
+			imdb_id INTEGER NOT NULL DEFAULT 0, tvdb_id INTEGER NOT NULL DEFAULT 0,
+			tvmaze_id INTEGER NOT NULL DEFAULT 0, mal_id INTEGER NOT NULL DEFAULT 0,
+			category TEXT NOT NULL DEFAULT "", source_tmdb TEXT NOT NULL DEFAULT "",
+			source_imdb TEXT NOT NULL DEFAULT "", source_tvdb TEXT NOT NULL DEFAULT "",
+			source_tvmaze TEXT NOT NULL DEFAULT "", source_mal TEXT NOT NULL DEFAULT "",
+			updated_at TEXT NOT NULL
+		)`,
+		externalMetadataTableDDL,
+		`INSERT INTO external_ids (source_path, tmdb_id, category, updated_at)
+			VALUES ("", 123456, "MOVIE", "2026-07-14T00:00:00Z")`,
+	}
+	for _, statement := range statements {
+		if _, err := repo.RawDB().ExecContext(ctx, statement); err != nil {
+			t.Fatalf("seed legacy schema: %v", err)
+		}
+	}
+	if err := migrateAddCanonicalReleaseGenerations(ctx, repo.RawDB()); err != nil {
+		t.Fatalf("migrate prepared release generations: %v", err)
+	}
+	if err := migrateAddCanonicalReleaseGenerations(ctx, repo.RawDB()); err != nil {
+		t.Fatalf("repeat prepared release migration: %v", err)
+	}
+
+	var generation int64
+	var sourceTMDB string
+	var categoryProvenance string
+	var contractVersion string
+	if err := repo.RawDB().QueryRowContext(ctx, `
+		SELECT generation, source_tmdb, category_provenance, contract_version
+		FROM external_ids WHERE source_path = ""
+	`).Scan(&generation, &sourceTMDB, &categoryProvenance, &contractVersion); err != nil {
+		t.Fatalf("read migrated identity: %v", err)
+	}
+	if generation != 0 || sourceTMDB != "legacy" || categoryProvenance != "legacy" || contractVersion != "legacy" {
+		t.Fatalf(
+			"migrated identity lineage = generation=%d tmdb=%q category=%q contract=%q",
+			generation,
+			sourceTMDB,
+			categoryProvenance,
+			contractVersion,
+		)
+	}
+}
+
+func openPreparedReleaseTestRepo(t *testing.T) *SQLiteRepository {
+	t.Helper()
+	repo, err := OpenWithLogger(filepath.Join(t.TempDir(), "prepared-release.db"), nopLogger{})
+	if err != nil {
+		t.Fatalf("open repository: %v", err)
+	}
+	t.Cleanup(func() { _ = repo.Close() })
+	if err := repo.Migrate(); err != nil {
+		t.Fatalf("migrate repository: %v", err)
+	}
+	return repo
+}
+
+func preparedReleaseDBFixture(sourcePath string, generation api.PreparedGeneration) api.PreparedRelease {
+	preparedAt := time.Date(2026, time.July, 14, 1, 2, 3, 4, time.UTC)
+	return api.PreparedRelease{
+		Generation: generation,
+		Compatibility: api.PreparationCompatibility{
+			SourceFingerprint:          "source-fingerprint",
+			FactInstructionFingerprint: "instruction-fingerprint",
+			PolicyFingerprint:          "policy-fingerprint",
+			ContractVersion:            "prepared-v1",
+		},
+		Source: api.SourceManifest{
+			SourcePath: sourcePath,
+			Size:       42,
+			Entries: []api.SourceManifestEntry{
+				{
+					Path:       sourcePath,
+					Type:       api.SourceEntryTypeFile,
+					Size:       42,
+					ModifiedAt: preparedAt.Add(-time.Hour),
+				},
+			},
+			Classification: api.SourceClassification{Container: "Matroska", MediaType: "encode"},
+		},
+		Naming: api.NamingFacts{
+			Filename:    filepath.Base(sourcePath),
+			ReleaseName: "Example.Release.2026.1080p-GRP",
+			Title:       "Example Release 2026",
+			Year:        2026,
+			Codecs:      []string{"H.264"},
+			Languages:   []string{"English"},
+		},
+		Episode: api.EpisodeFacts{
+Season: 1,
+ Episode: 2,
+ SeasonLabel: "S01",
+ EpisodeLabel: "E02",
+},
+		Media: api.MediaFacts{
+			AudioLanguages:    []string{"English"},
+			SubtitleLanguages: []string{"English"},
+			Container:         "Matroska",
+			VideoCodec:        "H.264",
+			MediaInfoUniqueID: "example-unique-id",
+		},
+		Disc: api.DiscFacts{Type: "", Summary: "not applicable"},
+		Identity: api.ExternalIdentity{
+			SourcePath: sourcePath,
+			Generation: generation,
+			TMDBID:     123456,
+			IMDBID:     7654321,
+			Category:   api.CanonicalCategoryMovie,
+			Provenance: api.IdentityProvenanceSet{
+				TMDB:     api.IdentityProvenanceExplicit,
+				IMDB:     api.IdentityProvenanceProvider,
+				TVDB:     api.IdentityProvenanceUnknown,
+				TVmaze:   api.IdentityProvenanceUnknown,
+				MAL:      api.IdentityProvenanceUnknown,
+				Category: api.IdentityProvenanceExplicit,
+			},
+			Overrides: api.IdentityOverrideState{
+				TMDB:     api.OverrideStateValue,
+				IMDB:     api.OverrideStateUnset,
+				TVDB:     api.OverrideStateClear,
+				TVmaze:   api.OverrideStateUnset,
+				MAL:      api.OverrideStateUnset,
+				Category: api.OverrideStateValue,
+			},
+			Conflict: api.IdentityConflictNone,
+			Resolution: api.IdentityResolutionKey{
+				SourceFingerprint: "source-fingerprint",
+				IntentFingerprint: "identity-intent-fingerprint",
+				ContractVersion:   "identity-v1",
+			},
+			ResolvedAt: preparedAt.Add(-time.Minute),
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			SourcePath: sourcePath,
+			Generation: generation,
+			TMDB: &api.TMDBMetadata{
+				TMDBID:          123456,
+				Title:           "Example Release 2026",
+				LocalizedTitles: map[string]string{"en": "Example Release 2026"},
+			},
+			UpdatedAt: preparedAt,
+		},
+		Assessments: api.ReleaseAssessments{
+			MediaInfoUniqueID:       api.UniqueIDStatusPresent,
+			MediaInfoEncodeSettings: api.EncodeSettingsStatusPresent,
+			Naming: api.NamingAssessment{
+				Status: api.NamingStatusComplete,
+			},
+		},
+		PreparedAt: preparedAt,
+	}
+}
diff --git a/internal/services/db/repository.go b/internal/services/db/repository.go
index 8a3f01d6..9ce1654b 100644
--- a/internal/services/db/repository.go
+++ b/internal/services/db/repository.go
@@ -7,14 +7,14 @@ import "github.com/autobrr/upbrr/pkg/api"
 
 type FileMetadata = api.FileMetadata
 type HistoryEntry = api.HistoryEntry
-type HistoryOverview = api.HistoryOverview
+type HistoryRecord = api.HistoryRecord
 type UploadRecord = api.UploadRecord
 type TrackerRuleFailure = api.TrackerRuleFailure
 type DescriptionOverride = api.DescriptionOverride
 type TrackerMetadata = api.TrackerMetadata
 type TrackerTimestamp = api.TrackerTimestamp
-type ExternalIDs = api.ExternalIDs
-type ExternalMetadata = api.ExternalMetadata
+type Identity = api.ExternalIdentity
+type ProviderMetadata = api.SourceScopedMetadata
 type DVDMediaInfo = api.DVDMediaInfo
 type TMDBMetadata = api.TMDBMetadata
 type IMDBMetadata = api.IMDBMetadata
@@ -30,4 +30,3 @@ type UploadedImageLink = api.UploadedImageLink
 type PlaylistSelection = api.PlaylistSelection
 type PlaylistInfo = api.PlaylistInfo
 type PlaylistItem = api.PlaylistItem
-type MetadataRepository = api.MetadataRepository
diff --git a/internal/services/db/repository_capabilities_test.go b/internal/services/db/repository_capabilities_test.go
new file mode 100644
index 00000000..9f2d96e4
--- /dev/null
+++ b/internal/services/db/repository_capabilities_test.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package db
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestRepositoryCapabilitiesShareSQLiteOwner(t *testing.T) {
+	t.Parallel()
+
+	repo, err := Open(filepath.Join(t.TempDir(), "capabilities.sqlite"))
+	if err != nil {
+		t.Fatalf("open repository: %v", err)
+	}
+	t.Cleanup(func() { _ = repo.Close() })
+
+	capabilities, err := api.NewRepositoryCapabilities(repo)
+	if err != nil {
+		t.Fatalf("new repository capabilities: %v", err)
+	}
+	if capabilities.ReleaseState() != repo || capabilities.Selections() != repo || capabilities.History() != repo ||
+		capabilities.Uploads() != repo || capabilities.Trackers() != repo || capabilities.Media() != repo {
+		t.Fatal("repository capabilities do not share one SQLite owner")
+	}
+}
diff --git a/internal/services/db/screenshot_final_selections_test.go b/internal/services/db/screenshot_final_selections_test.go
index 4a83e21e..c0ca7280 100644
--- a/internal/services/db/screenshot_final_selections_test.go
+++ b/internal/services/db/screenshot_final_selections_test.go
@@ -32,8 +32,20 @@ func TestScreenshotFinalSelectionsCRUD(t *testing.T) {
 	now := time.Now().UTC().Truncate(time.Second)
 
 	selections := []ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: "/tmp/final-01.png", Order: 0, Source: "existing", SelectedAt: now},
-		{SourcePath: sourcePath, ImagePath: "/tmp/final-02.png", Order: 1, Source: "generated", SelectedAt: now},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  "/tmp/final-01.png",
+			Order:      0,
+			Source:     "existing",
+			SelectedAt: now,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  "/tmp/final-02.png",
+			Order:      1,
+			Source:     "generated",
+			SelectedAt: now,
+		},
 	}
 
 	if err := repo.SaveFinalSelections(ctx, sourcePath, selections); err != nil {
diff --git a/internal/services/db/screenshot_lifecycle_test.go b/internal/services/db/screenshot_lifecycle_test.go
index 1f7466d1..2683fd09 100644
--- a/internal/services/db/screenshot_lifecycle_test.go
+++ b/internal/services/db/screenshot_lifecycle_test.go
@@ -35,22 +35,56 @@ func TestScreenshotLifecyclePreservesCategoriesAndCleansReferences(t *testing.T)
 	normalNew := filepath.Join(root, "normal-new.png")
 	now := time.Now().UTC()
 
-	if err := repo.SaveScreenshot(ctx, api.Screenshot{SourcePath: sourcePath, ImagePath: autoOld, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}); err != nil {
+	if err := repo.SaveScreenshot(ctx, api.Screenshot{
+		SourcePath: sourcePath,
+		ImagePath:  autoOld,
+		Purpose:    api.ScreenshotPurposeMenu,
+		CapturedAt: now,
+	}); err != nil {
 		t.Fatalf("save old auto screenshot: %v", err)
 	}
-	if err := repo.SaveScreenshot(ctx, api.Screenshot{SourcePath: sourcePath, ImagePath: manualOld, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}); err != nil {
+	if err := repo.SaveScreenshot(ctx, api.Screenshot{
+		SourcePath: sourcePath,
+		ImagePath:  manualOld,
+		Purpose:    api.ScreenshotPurposeMenu,
+		CapturedAt: now,
+	}); err != nil {
 		t.Fatalf("save old manual screenshot: %v", err)
 	}
 	if err := repo.SaveFinalSelections(ctx, sourcePath, []api.ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: normalOld, Order: 0, Source: "generated", SelectedAt: now},
-		{SourcePath: sourcePath, ImagePath: manualOld, Order: 1, Source: api.ScreenshotSelectionSourceMenu, SelectedAt: now},
-		{SourcePath: sourcePath, ImagePath: autoOld, Order: 2, Source: api.ScreenshotSelectionSourceDVDMenu, SelectedAt: now},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  normalOld,
+			Order:      0,
+			Source:     "generated",
+			SelectedAt: now,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  manualOld,
+			Order:      1,
+			Source:     api.ScreenshotSelectionSourceMenu,
+			SelectedAt: now,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  autoOld,
+			Order:      2,
+			Source:     api.ScreenshotSelectionSourceDVDMenu,
+			SelectedAt: now,
+		},
 	}); err != nil {
 		t.Fatalf("seed final selections: %v", err)
 	}
 
 	if err := repo.ReplaceNormalFinalSelections(ctx, sourcePath, []api.ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: normalNew, Order: 0, Source: "generated", SelectedAt: now},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  normalNew,
+			Order:      0,
+			Source:     "generated",
+			SelectedAt: now,
+		},
 	}); err != nil {
 		t.Fatalf("replace normal selections: %v", err)
 	}
@@ -58,8 +92,18 @@ func TestScreenshotLifecyclePreservesCategoriesAndCleansReferences(t *testing.T)
 
 	manualNew := filepath.Join(root, "manual-new.png")
 	if err := repo.AppendManualMenuScreenshots(ctx, sourcePath,
-		[]api.Screenshot{{SourcePath: sourcePath, ImagePath: manualNew, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}},
-		[]api.ScreenshotFinalSelection{{SourcePath: sourcePath, ImagePath: manualNew, Source: api.ScreenshotSelectionSourceMenu, SelectedAt: now}},
+		[]api.Screenshot{{
+			SourcePath: sourcePath,
+			ImagePath:  manualNew,
+			Purpose:    api.ScreenshotPurposeMenu,
+			CapturedAt: now,
+		}},
+		[]api.ScreenshotFinalSelection{{
+			SourcePath: sourcePath,
+			ImagePath:  manualNew,
+			Source:     api.ScreenshotSelectionSourceMenu,
+			SelectedAt: now,
+		}},
 	); err != nil {
 		t.Fatalf("append manual screenshot: %v", err)
 	}
@@ -92,8 +136,18 @@ func TestScreenshotLifecyclePreservesCategoriesAndCleansReferences(t *testing.T)
 
 	autoNew := filepath.Join(root, "auto-new.png")
 	replaced, err := repo.ReplaceDVDMenuScreenshots(ctx, sourcePath,
-		[]api.Screenshot{{SourcePath: sourcePath, ImagePath: autoNew, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}},
-		[]api.ScreenshotFinalSelection{{SourcePath: sourcePath, ImagePath: autoNew, Source: api.ScreenshotSelectionSourceDVDMenu, SelectedAt: now}},
+		[]api.Screenshot{{
+			SourcePath: sourcePath,
+			ImagePath:  autoNew,
+			Purpose:    api.ScreenshotPurposeMenu,
+			CapturedAt: now,
+		}},
+		[]api.ScreenshotFinalSelection{{
+			SourcePath: sourcePath,
+			ImagePath:  autoNew,
+			Source:     api.ScreenshotSelectionSourceDVDMenu,
+			SelectedAt: now,
+		}},
 	)
 	if err != nil {
 		t.Fatalf("replace auto screenshots: %v", err)
@@ -208,8 +262,16 @@ func TestAppendManualMenuScreenshotsRollsBackCrossSourceImageConflict(t *testing
 	}
 
 	err = repo.AppendManualMenuScreenshots(ctx, secondSource,
-		[]api.Screenshot{{SourcePath: secondSource, ImagePath: imagePath, Purpose: api.ScreenshotPurposeMenu}},
-		[]api.ScreenshotFinalSelection{{SourcePath: secondSource, ImagePath: imagePath, Source: api.ScreenshotSelectionSourceMenu}},
+		[]api.Screenshot{{
+			SourcePath: secondSource,
+			ImagePath:  imagePath,
+			Purpose:    api.ScreenshotPurposeMenu,
+		}},
+		[]api.ScreenshotFinalSelection{{
+			SourcePath: secondSource,
+			ImagePath:  imagePath,
+			Source:     api.ScreenshotSelectionSourceMenu,
+		}},
 	)
 	if !errors.Is(err, internalerrors.ErrInvalidInput) {
 		t.Fatalf("append error = %v, want invalid input", err)
diff --git a/internal/services/db/sqlite.go b/internal/services/db/sqlite.go
index 114a88d4..d18ed9f0 100644
--- a/internal/services/db/sqlite.go
+++ b/internal/services/db/sqlite.go
@@ -22,10 +22,13 @@ import (
 	sqlite3 "modernc.org/sqlite/lib"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// SQLiteRepository owns one SQLite handle constrained to a single connection
+// so connection-local PRAGMAs remain consistent. Callers must close the
+// repository when finished; opening does not run schema migrations.
 type SQLiteRepository struct {
 	db     *sql.DB
 	logger Logger
@@ -44,18 +47,25 @@ const (
 	pragmaBusyTimeoutPrefix = "PRAGMA busy_timeout = "
 )
 
+// Open opens path with a background context and no-op logger.
 func Open(path string) (*SQLiteRepository, error) {
 	return OpenWithLogger(path, nopLogger{})
 }
 
+// OpenContext opens path with ctx and a no-op logger.
 func OpenContext(ctx context.Context, path string) (*SQLiteRepository, error) {
 	return OpenWithLoggerContext(ctx, path, nopLogger{})
 }
 
+// OpenWithLogger opens path with a background context and logger.
 func OpenWithLogger(path string, logger Logger) (*SQLiteRepository, error) {
 	return OpenWithLoggerContext(context.Background(), path, logger)
 }
 
+// OpenWithLoggerContext resolves and opens path, enables foreign keys and a
+// five-second busy timeout, and requires WAL mode for on-disk databases.
+// In-memory databases retain their supported journal mode. A nil context is
+// rejected and a nil logger is replaced with a no-op logger.
 func OpenWithLoggerContext(ctx context.Context, path string, logger Logger) (*SQLiteRepository, error) {
 	if ctx == nil {
 		return nil, errors.New("db: context is required")
@@ -113,7 +123,11 @@ func OpenWithLoggerContext(ctx context.Context, path string, logger Logger) (*SQ
 		}
 	}
 
-	return &SQLiteRepository{db: db, logger: logger, path: repositoryDBPath(path, resolved)}, nil
+	return &SQLiteRepository{
+		db:     db,
+		logger: logger,
+		path:   repositoryDBPath(path, resolved),
+	}, nil
 }
 
 // DBPath returns the resolved on-disk database path when the repository was
@@ -127,6 +141,8 @@ func (r *SQLiteRepository) DBPath() string {
 	return r.path
 }
 
+// Close releases the owned SQLite handle. A nil or uninitialized repository is
+// a no-op.
 func (r *SQLiteRepository) Close() error {
 	if r == nil || r.db == nil {
 		return nil
@@ -154,10 +170,14 @@ func (r *SQLiteRepository) RawDB() *sql.DB {
 	return r.db
 }
 
+// Migrate applies pending repository migrations using a background context and
+// the busy-lock retry policy.
 func (r *SQLiteRepository) Migrate() error {
 	return r.MigrateContext(context.Background())
 }
 
+// MigrateContext applies pending repository migrations under ctx and retries
+// the complete migration operation for transient SQLite busy or locked errors.
 func (r *SQLiteRepository) MigrateContext(ctx context.Context) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -170,6 +190,7 @@ func (r *SQLiteRepository) MigrateContext(ctx context.Context) error {
 	})
 }
 
+// IsBusyError reports whether err wraps a modernc SQLite BUSY or LOCKED result.
 func IsBusyError(err error) bool {
 	if err == nil {
 		return false
@@ -295,6 +316,9 @@ func isMemorySQLitePath(path string) bool {
 	return strings.HasPrefix(normalized, "file:") && strings.Contains(normalized, "mode=memory")
 }
 
+// GetByPath loads release metadata for path. Malformed legacy list or timestamp
+// fields are left at their zero values; a missing row returns
+// [internalerrors.ErrNotFound].
 func (r *SQLiteRepository) GetByPath(ctx context.Context, path string) (FileMetadata, error) {
 	if r == nil || r.db == nil {
 		return FileMetadata{}, errors.New("db: repository not initialized")
@@ -414,6 +438,8 @@ func (r *SQLiteRepository) GetByPath(ctx context.Context, path string) (FileMeta
 	return metadata, nil
 }
 
+// Save upserts release metadata by path, canonicalizing invalid categories to
+// unknown and assigning the current UTC time when UpdatedAt is zero.
 func (r *SQLiteRepository) Save(ctx context.Context, metadata FileMetadata) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -534,12 +560,12 @@ func (r *SQLiteRepository) Save(ctx context.Context, metadata FileMetadata) erro
 	return nil
 }
 
-func (r *SQLiteRepository) GetExternalIDs(ctx context.Context, path string) (ExternalIDs, error) {
+func (r *SQLiteRepository) GetExternalIdentity(ctx context.Context, path string) (Identity, error) {
 	if r == nil || r.db == nil {
-		return ExternalIDs{}, errors.New("db: repository not initialized")
+		return Identity{}, errors.New("db: repository not initialized")
 	}
 	if strings.TrimSpace(path) == "" {
-		return ExternalIDs{}, internalerrors.ErrInvalidInput
+		return Identity{}, internalerrors.ErrInvalidInput
 	}
 
 	row := r.db.QueryRowContext(ctx, `
@@ -549,8 +575,14 @@ func (r *SQLiteRepository) GetExternalIDs(ctx context.Context, path string) (Ext
 		WHERE source_path = ?
 	`, path)
 
-	var ids ExternalIDs
+	var ids Identity
 	var updatedAt string
+	var category string
+	var sourceTMDB string
+	var sourceIMDB string
+	var sourceTVDB string
+	var sourceTVmaze string
+	var sourceMAL string
 	if err := row.Scan(
 		&ids.SourcePath,
 		&ids.TMDBID,
@@ -558,29 +590,37 @@ func (r *SQLiteRepository) GetExternalIDs(ctx context.Context, path string) (Ext
 		&ids.TVDBID,
 		&ids.TVmazeID,
 		&ids.MALID,
-		&ids.Category,
-		&ids.SourceTMDB,
-		&ids.SourceIMDB,
-		&ids.SourceTVDB,
-		&ids.SourceTVmaze,
-		&ids.SourceMAL,
+		&category,
+		&sourceTMDB,
+		&sourceIMDB,
+		&sourceTVDB,
+		&sourceTVmaze,
+		&sourceMAL,
 		&updatedAt,
 	); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
-			return ExternalIDs{}, internalerrors.ErrNotFound
+			return Identity{}, internalerrors.ErrNotFound
 		}
-		return ExternalIDs{}, fmt.Errorf("db get external ids: %w", err)
+		return Identity{}, fmt.Errorf("db get external ids: %w", err)
 	}
 	if updatedAt != "" {
 		if parsed, err := time.Parse(time.RFC3339Nano, updatedAt); err == nil {
-			ids.UpdatedAt = parsed
+			ids.ResolvedAt = parsed
 		}
 	}
+	ids.Category, _ = api.NormalizeCanonicalCategory(category)
+	ids.Provenance = api.IdentityProvenanceSet{
+		TMDB:   api.IdentityProvenance(sourceTMDB),
+		IMDB:   api.IdentityProvenance(sourceIMDB),
+		TVDB:   api.IdentityProvenance(sourceTVDB),
+		TVmaze: api.IdentityProvenance(sourceTVmaze),
+		MAL:    api.IdentityProvenance(sourceMAL),
+	}
 
 	return ids, nil
 }
 
-func (r *SQLiteRepository) SaveExternalIDs(ctx context.Context, ids ExternalIDs) error {
+func (r *SQLiteRepository) SaveExternalIdentity(ctx context.Context, ids Identity) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
 	}
@@ -588,7 +628,7 @@ func (r *SQLiteRepository) SaveExternalIDs(ctx context.Context, ids ExternalIDs)
 		return internalerrors.ErrInvalidInput
 	}
 
-	timestamp := ids.UpdatedAt
+	timestamp := ids.ResolvedAt
 	if timestamp.IsZero() {
 		timestamp = time.Now().UTC()
 	}
@@ -620,11 +660,11 @@ func (r *SQLiteRepository) SaveExternalIDs(ctx context.Context, ids ExternalIDs)
 		ids.TVmazeID,
 		ids.MALID,
 		ids.Category,
-		ids.SourceTMDB,
-		ids.SourceIMDB,
-		ids.SourceTVDB,
-		ids.SourceTVmaze,
-		ids.SourceMAL,
+		ids.Provenance.TMDB,
+		ids.Provenance.IMDB,
+		ids.Provenance.TVDB,
+		ids.Provenance.TVmaze,
+		ids.Provenance.MAL,
 		timestamp.Format(time.RFC3339Nano),
 	)
 	if err != nil {
@@ -633,6 +673,8 @@ func (r *SQLiteRepository) SaveExternalIDs(ctx context.Context, ids ExternalIDs)
 	return nil
 }
 
+// GetDVDMediaInfo reads the SQLite-only DVD diagnostic record. It is not part
+// of the release-state capability because no production workflow reads it.
 func (r *SQLiteRepository) GetDVDMediaInfo(ctx context.Context, path string) (DVDMediaInfo, error) {
 	if r == nil || r.db == nil {
 		return DVDMediaInfo{}, errors.New("db: repository not initialized")
@@ -742,12 +784,12 @@ func (r *SQLiteRepository) SaveDVDMediaInfo(ctx context.Context, info DVDMediaIn
 	return nil
 }
 
-func (r *SQLiteRepository) GetExternalMetadata(ctx context.Context, path string) (ExternalMetadata, error) {
+func (r *SQLiteRepository) GetExternalMetadata(ctx context.Context, path string) (ProviderMetadata, error) {
 	if r == nil || r.db == nil {
-		return ExternalMetadata{}, errors.New("db: repository not initialized")
+		return ProviderMetadata{}, errors.New("db: repository not initialized")
 	}
 	if strings.TrimSpace(path) == "" {
-		return ExternalMetadata{}, internalerrors.ErrInvalidInput
+		return ProviderMetadata{}, internalerrors.ErrInvalidInput
 	}
 
 	row := r.db.QueryRowContext(ctx, `
@@ -756,7 +798,7 @@ func (r *SQLiteRepository) GetExternalMetadata(ctx context.Context, path string)
 		WHERE source_path = ?
 	`, path)
 
-	var metadata ExternalMetadata
+	var metadata ProviderMetadata
 	var tmdbJSON string
 	var imdbJSON string
 	var tvdbJSON string
@@ -775,29 +817,29 @@ func (r *SQLiteRepository) GetExternalMetadata(ctx context.Context, path string)
 		&updatedAt,
 	); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
-			return ExternalMetadata{}, internalerrors.ErrNotFound
+			return ProviderMetadata{}, internalerrors.ErrNotFound
 		}
-		return ExternalMetadata{}, fmt.Errorf("db get external metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db get external metadata: %w", err)
 	}
 
 	var err error
 	if metadata.TMDB, err = decodeOptionalJSON[TMDBMetadata](tmdbJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode tmdb metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode tmdb metadata: %w", err)
 	}
 	if metadata.IMDB, err = decodeOptionalJSON[IMDBMetadata](imdbJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode imdb metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode imdb metadata: %w", err)
 	}
 	if metadata.TVDB, err = decodeOptionalJSON[TVDBMetadata](tvdbJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode tvdb metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode tvdb metadata: %w", err)
 	}
 	if metadata.TVmaze, err = decodeOptionalJSON[TVmazeMetadata](tvmazeJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode tvmaze metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode tvmaze metadata: %w", err)
 	}
 	if metadata.AniList, err = decodeOptionalJSON[api.AniListMetadata](anilistJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode anilist metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode anilist metadata: %w", err)
 	}
 	if metadata.Bluray, err = decodeOptionalJSON[api.BlurayMetadata](blurayJSON); err != nil {
-		return ExternalMetadata{}, fmt.Errorf("db decode bluray metadata: %w", err)
+		return ProviderMetadata{}, fmt.Errorf("db decode bluray metadata: %w", err)
 	}
 	if updatedAt != "" {
 		if parsed, err := time.Parse(time.RFC3339Nano, updatedAt); err == nil {
@@ -808,7 +850,7 @@ func (r *SQLiteRepository) GetExternalMetadata(ctx context.Context, path string)
 	return metadata, nil
 }
 
-func (r *SQLiteRepository) SaveExternalMetadata(ctx context.Context, metadata ExternalMetadata) error {
+func (r *SQLiteRepository) SaveExternalMetadata(ctx context.Context, metadata ProviderMetadata) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
 	}
@@ -1048,6 +1090,8 @@ func (r *SQLiteRepository) SaveReleaseNameOverrides(ctx context.Context, path st
 	return nil
 }
 
+// DeleteReleaseNameOverrides is retained for SQLite maintenance and migration
+// tests; current workflows replace overrides instead of deleting them.
 func (r *SQLiteRepository) DeleteReleaseNameOverrides(ctx context.Context, path string) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -1134,6 +1178,8 @@ func (r *SQLiteRepository) SavePlaylistSelection(ctx context.Context, sourcePath
 	return nil
 }
 
+// DeletePlaylistSelection is retained for SQLite maintenance and migration
+// tests; current workflows persist explicit empty selections.
 func (r *SQLiteRepository) DeletePlaylistSelection(ctx context.Context, sourcePath string) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -1174,7 +1220,11 @@ func (r *SQLiteRepository) GetDescriptionOverride(ctx context.Context, path stri
 		return DescriptionOverride{}, fmt.Errorf("db get description override: %w", err)
 	}
 
-	override := DescriptionOverride{SourcePath: trimmed, GroupKey: normalizeDescriptionOverrideGroupKey(storedGroupKey), Description: description}
+	override := DescriptionOverride{
+		SourcePath:  trimmed,
+		GroupKey:    normalizeDescriptionOverrideGroupKey(storedGroupKey),
+		Description: description,
+	}
 	if updatedAt != "" {
 		if parsed, err := time.Parse(time.RFC3339Nano, updatedAt); err == nil {
 			override.UpdatedAt = parsed
@@ -1267,7 +1317,13 @@ func (r *SQLiteRepository) DeleteDescriptionOverride(ctx context.Context, path s
 		return internalerrors.ErrInvalidInput
 	}
 	trimmedGroup := normalizeDescriptionOverrideGroupKey(groupKey)
-	if _, err := r.execWrite(ctx, "delete description override", `DELETE FROM description_overrides WHERE source_path = ? AND group_key = ?`, trimmed, trimmedGroup); err != nil {
+	if _, err := r.execWrite(
+		ctx,
+		"delete description override",
+		`DELETE FROM description_overrides WHERE source_path = ? AND group_key = ?`,
+		trimmed,
+		trimmedGroup,
+	); err != nil {
 		return fmt.Errorf("db delete description override: %w", err)
 	}
 	return nil
@@ -1404,6 +1460,9 @@ func decodeOptionalJSON[T any](value string) (*T, error) {
 	return &result, nil
 }
 
+// ListHistoryEntries returns non-placeholder release rows in descending
+// metadata-update order, with each row's latest upload and separate advisory
+// versus non-advisory rule counts.
 func (r *SQLiteRepository) ListHistoryEntries(ctx context.Context) ([]HistoryEntry, error) {
 	if r == nil || r.db == nil {
 		return nil, errors.New("db: repository not initialized")
@@ -1421,12 +1480,12 @@ func (r *SQLiteRepository) ListHistoryEntries(ctx context.Context) ([]HistoryEnt
 			(
 				SELECT COUNT(1)
 				FROM tracker_rule_failures trf
-				WHERE trf.source_path = fm.path AND trf.severity <> "warning"
+				WHERE trf.source_path = fm.path AND trf.disposition <> "advisory"
 			),
 			(
 				SELECT COUNT(1)
 				FROM tracker_rule_failures trf
-				WHERE trf.source_path = fm.path AND trf.severity = "warning"
+				WHERE trf.source_path = fm.path AND trf.disposition = "advisory"
 			)
 		FROM file_metadata fm
 		LEFT JOIN upload_records ur ON ur.id = (
@@ -1482,7 +1541,7 @@ func (r *SQLiteRepository) ListHistoryEntries(ctx context.Context) ([]HistoryEnt
 			&entry.LatestUploadStatus,
 			&uploadCreatedAt,
 			&entry.RuleFailureCount,
-			&entry.RuleWarningCount,
+			&entry.RuleAdvisoryCount,
 		); err != nil {
 			return nil, fmt.Errorf("db list history entries: %w", err)
 		}
@@ -1546,6 +1605,8 @@ func (r *SQLiteRepository) ListUploadHistoryByPath(ctx context.Context, sourcePa
 	return records, nil
 }
 
+// ListPendingUploads is retained as a SQLite diagnostic query and intentionally
+// excluded from the upload-ledger capability until a production caller exists.
 func (r *SQLiteRepository) ListPendingUploads(ctx context.Context) ([]UploadRecord, error) {
 	if r == nil || r.db == nil {
 		return nil, errors.New("db: repository not initialized")
@@ -1649,6 +1710,9 @@ func (r *SQLiteRepository) UpdateLatestUploadRecordStatus(ctx context.Context, s
 	return nil
 }
 
+// SaveTrackerRuleFailures atomically replaces one source/tracker result set.
+// Tracker names are stored uppercase, blank rule names are skipped, missing
+// timestamps default to now, and dispositions are normalized before storage.
 func (r *SQLiteRepository) SaveTrackerRuleFailures(ctx context.Context, sourcePath string, tracker string, failures []TrackerRuleFailure) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -1669,8 +1733,8 @@ func (r *SQLiteRepository) SaveTrackerRuleFailures(ctx context.Context, sourcePa
 
 		if len(failures) > 0 {
 			stmt, err := tx.PrepareContext(ctx, `
-				INSERT INTO tracker_rule_failures (source_path, tracker, rule, reason, severity, created_at)
-				VALUES (?, ?, ?, ?, ?, ?)
+				INSERT INTO tracker_rule_failures (source_path, tracker, rule, reason, disposition, authorized, created_at)
+				VALUES (?, ?, ?, ?, ?, ?, ?)
 			`)
 			if err != nil {
 				return fmt.Errorf("db save tracker rule failures: prepare: %w", err)
@@ -1691,7 +1755,8 @@ func (r *SQLiteRepository) SaveTrackerRuleFailures(ctx context.Context, sourcePa
 					strings.ToUpper(trimmedTracker),
 					rule,
 					strings.TrimSpace(failure.Reason),
-					api.NormalizeRuleFailureSeverity(failure.Severity),
+					api.NormalizeRuleDisposition(failure.Disposition),
+					failure.Authorized,
 					createdAt.Format(time.RFC3339Nano),
 				); err != nil {
 					return fmt.Errorf("db save tracker rule failures: insert: %w", err)
@@ -1715,7 +1780,7 @@ func (r *SQLiteRepository) ListTrackerRuleFailuresByPath(ctx context.Context, pa
 	}
 
 	rows, err := r.db.QueryContext(ctx, `
-		SELECT source_path, tracker, rule, reason, severity, created_at
+		SELECT source_path, tracker, rule, reason, disposition, authorized, created_at
 		FROM tracker_rule_failures
 		WHERE source_path = ?
 		ORDER BY id ASC
@@ -1729,7 +1794,15 @@ func (r *SQLiteRepository) ListTrackerRuleFailuresByPath(ctx context.Context, pa
 	for rows.Next() {
 		var record TrackerRuleFailure
 		var createdAt string
-		if err := rows.Scan(&record.SourcePath, &record.Tracker, &record.Rule, &record.Reason, &record.Severity, &createdAt); err != nil {
+		if err := rows.Scan(
+			&record.SourcePath,
+			&record.Tracker,
+			&record.Rule,
+			&record.Reason,
+			&record.Disposition,
+			&record.Authorized,
+			&createdAt,
+		); err != nil {
 			return nil, fmt.Errorf("db list tracker rule failures: %w", err)
 		}
 		if createdAt != "" {
@@ -1995,6 +2068,8 @@ func (r *SQLiteRepository) ListScreenshotsByPath(ctx context.Context, path strin
 	return screenshots, nil
 }
 
+// DeleteScreenshot atomically removes the screenshot record and every local
+// uploaded-image record keyed by imagePath. Final selections are not removed.
 func (r *SQLiteRepository) DeleteScreenshot(ctx context.Context, imagePath string) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -2016,6 +2091,9 @@ func (r *SQLiteRepository) DeleteScreenshot(ctx context.Context, imagePath strin
 	return nil
 }
 
+// SaveFinalSelections atomically replaces every final selection for path.
+// Callers that must preserve menu selections should use
+// [SQLiteRepository.ReplaceNormalFinalSelections].
 func (r *SQLiteRepository) SaveFinalSelections(ctx context.Context, path string, selections []ScreenshotFinalSelection) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -2138,7 +2216,8 @@ func (r *SQLiteRepository) ReplaceNormalFinalSelections(ctx context.Context, pat
 		return internalerrors.ErrInvalidInput
 	}
 	for _, selection := range selections {
-		if strings.TrimSpace(selection.SourcePath) != trimmed || strings.TrimSpace(selection.ImagePath) == "" || api.IsDiscMenuSelectionSource(strings.TrimSpace(selection.Source)) {
+		if strings.TrimSpace(selection.SourcePath) != trimmed || strings.TrimSpace(selection.ImagePath) == "" ||
+			api.IsDiscMenuSelectionSource(strings.TrimSpace(selection.Source)) {
 			return internalerrors.ErrInvalidInput
 		}
 	}
@@ -2161,7 +2240,12 @@ func (r *SQLiteRepository) ReplaceNormalFinalSelections(ctx context.Context, pat
 
 // AppendManualMenuScreenshots atomically upserts manual menu screenshot records
 // and appends their selections after existing manual-menu order values.
-func (r *SQLiteRepository) AppendManualMenuScreenshots(ctx context.Context, path string, screenshots []Screenshot, selections []ScreenshotFinalSelection) error {
+func (r *SQLiteRepository) AppendManualMenuScreenshots(
+	ctx context.Context,
+	path string,
+	screenshots []Screenshot,
+	selections []ScreenshotFinalSelection,
+) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
 	}
@@ -2194,7 +2278,12 @@ func (r *SQLiteRepository) AppendManualMenuScreenshots(ctx context.Context, path
 // ReplaceDVDMenuScreenshots atomically replaces automatic DVD-menu records and
 // selections while preserving manual menus and normal screenshots. It returns
 // replaced local image paths for caller-owned filesystem cleanup.
-func (r *SQLiteRepository) ReplaceDVDMenuScreenshots(ctx context.Context, path string, screenshots []Screenshot, selections []ScreenshotFinalSelection) ([]string, error) {
+func (r *SQLiteRepository) ReplaceDVDMenuScreenshots(
+	ctx context.Context,
+	path string,
+	screenshots []Screenshot,
+	selections []ScreenshotFinalSelection,
+) ([]string, error) {
 	if r == nil || r.db == nil {
 		return nil, errors.New("db: repository not initialized")
 	}
@@ -2341,16 +2430,19 @@ func (r *SQLiteRepository) RestoreDiscMenuScreenshot(ctx context.Context, path s
 	selection := deleted.Selection
 	selection.SourcePath = strings.TrimSpace(selection.SourcePath)
 	selection.ImagePath = strings.TrimSpace(selection.ImagePath)
-	if trimmedPath == "" || selection.SourcePath != trimmedPath || selection.ImagePath == "" || !api.IsDiscMenuSelectionSource(strings.TrimSpace(selection.Source)) {
+	if trimmedPath == "" || selection.SourcePath != trimmedPath || selection.ImagePath == "" ||
+		!api.IsDiscMenuSelectionSource(strings.TrimSpace(selection.Source)) {
 		return internalerrors.ErrInvalidInput
 	}
 	if deleted.Screenshot != nil {
-		if strings.TrimSpace(deleted.Screenshot.SourcePath) != trimmedPath || strings.TrimSpace(deleted.Screenshot.ImagePath) != selection.ImagePath || deleted.Screenshot.Purpose != api.ScreenshotPurposeMenu {
+		if strings.TrimSpace(deleted.Screenshot.SourcePath) != trimmedPath || strings.TrimSpace(deleted.Screenshot.ImagePath) != selection.ImagePath ||
+			deleted.Screenshot.Purpose != api.ScreenshotPurposeMenu {
 			return internalerrors.ErrInvalidInput
 		}
 	}
 	for _, uploaded := range deleted.UploadedImages {
-		if strings.TrimSpace(uploaded.SourcePath) != trimmedPath || strings.TrimSpace(uploaded.ImagePath) != selection.ImagePath || strings.TrimSpace(uploaded.Host) == "" {
+		if strings.TrimSpace(uploaded.SourcePath) != trimmedPath || strings.TrimSpace(uploaded.ImagePath) != selection.ImagePath ||
+			strings.TrimSpace(uploaded.Host) == "" {
 			return internalerrors.ErrInvalidInput
 		}
 	}
@@ -2606,7 +2698,8 @@ func validMenuScreenshotBatch(path string, screenshots []Screenshot, selections
 	}
 	paths := make(map[string]struct{}, len(screenshots))
 	for _, screenshot := range screenshots {
-		if strings.TrimSpace(screenshot.SourcePath) != path || strings.TrimSpace(screenshot.ImagePath) == "" || screenshot.Purpose != api.ScreenshotPurposeMenu {
+		if strings.TrimSpace(screenshot.SourcePath) != path || strings.TrimSpace(screenshot.ImagePath) == "" ||
+			screenshot.Purpose != api.ScreenshotPurposeMenu {
 			return false
 		}
 		imagePath := strings.TrimSpace(screenshot.ImagePath)
@@ -2813,6 +2906,8 @@ func deleteScreenshotReferencesTx(ctx context.Context, tx *sql.Tx, path string,
 	return nil
 }
 
+// ReplaceScreenshotSlots atomically replaces all slots and variants for path;
+// variants absent from slots are deleted.
 func (r *SQLiteRepository) ReplaceScreenshotSlots(ctx context.Context, path string, slots []ScreenshotSlot) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -3053,6 +3148,9 @@ func (r *SQLiteRepository) UpsertScreenshotSlotVariants(ctx context.Context, pat
 	return nil
 }
 
+// SaveUploadedImages upserts upload records without deleting omitted images.
+// path and host override their per-image fields; empty usage scopes default to
+// "global" and zero upload times default to the current UTC time.
 func (r *SQLiteRepository) SaveUploadedImages(ctx context.Context, path string, host string, images []UploadedImageLink) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -3189,6 +3287,8 @@ func (r *SQLiteRepository) ListUploadedImagesByPath(ctx context.Context, path st
 	return images, nil
 }
 
+// DeleteUploadedImage deletes every usage-scope record matching path,
+// imagePath, and host. It returns an error when no record matched.
 func (r *SQLiteRepository) DeleteUploadedImage(ctx context.Context, path string, imagePath string, host string) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -3280,6 +3380,9 @@ func (r *SQLiteRepository) ListStoredReleasePaths(ctx context.Context) ([]string
 	return paths, nil
 }
 
+// PurgeContentData atomically deletes persisted release, metadata, upload, and
+// media rows for path, including matching retired UI-state rows. It does not
+// remove local files or remote uploads.
 func (r *SQLiteRepository) PurgeContentData(ctx context.Context, path string) error {
 	if r == nil || r.db == nil {
 		return errors.New("db: repository not initialized")
@@ -3300,6 +3403,7 @@ func (r *SQLiteRepository) PurgeContentData(ctx context.Context, path string) er
 		args []any
 	}{
 		{sql: `DELETE FROM dvd_mediainfo WHERE source_path = ?`, args: []any{trimmedPath}},
+		{sql: `DELETE FROM prepared_release_current WHERE source_path = ?`, args: []any{trimmedPath}},
 		{sql: `DELETE FROM external_metadata WHERE source_path = ?`, args: []any{trimmedPath}},
 		{sql: `DELETE FROM external_ids WHERE source_path = ?`, args: []any{trimmedPath}},
 		{sql: `DELETE FROM release_overrides WHERE source_path = ?`, args: []any{trimmedPath}},
diff --git a/internal/services/db/sqlite_test.go b/internal/services/db/sqlite_test.go
index df58a4c6..fdf008fb 100644
--- a/internal/services/db/sqlite_test.go
+++ b/internal/services/db/sqlite_test.go
@@ -146,7 +146,11 @@ func TestSQLiteRepositoryCRUD(t *testing.T) {
 		t.Fatalf("expected no pending uploads, got %d", len(pending))
 	}
 
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: "/tmp/file"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: "/tmp/file",
+	}); err != nil {
 		t.Fatalf("create upload record: %v", err)
 	}
 
@@ -207,48 +211,50 @@ func TestSQLiteRepositoryCRUD(t *testing.T) {
 	}
 
 	idsStamp := time.Now().UTC().Truncate(time.Second)
-	if err := repo.SaveExternalIDs(ctx, ExternalIDs{
-		SourcePath:   "/media/file.mkv",
-		TMDBID:       100,
-		IMDBID:       200,
-		TVDBID:       300,
-		TVmazeID:     400,
-		MALID:        500,
-		Category:     "MOVIE",
-		SourceTMDB:   "tracker",
-		SourceIMDB:   "mediainfo",
-		SourceTVDB:   "tmdb",
-		SourceTVmaze: "tvmaze",
-		SourceMAL:    "scene",
-		UpdatedAt:    idsStamp,
+	if err := repo.SaveExternalIdentity(ctx, Identity{
+		SourcePath: "/media/file.mkv",
+		TMDBID:     100,
+		IMDBID:     200,
+		TVDBID:     300,
+		TVmazeID:   400,
+		MALID:      500,
+		Category:   api.CanonicalCategoryMovie,
+		Provenance: api.IdentityProvenanceSet{
+			TMDB:   api.IdentityProvenanceTracker,
+			IMDB:   api.IdentityProvenanceMediaInfo,
+			TVDB:   api.IdentityProvenanceProvider,
+			TVmaze: api.IdentityProvenanceProvider,
+			MAL:    api.IdentityProvenanceScene,
+		},
+		ResolvedAt: idsStamp,
 	}); err != nil {
 		t.Fatalf("save external ids: %v", err)
 	}
 
-	ids, err := repo.GetExternalIDs(ctx, "/media/file.mkv")
+	ids, err := repo.GetExternalIdentity(ctx, "/media/file.mkv")
 	if err != nil {
 		t.Fatalf("get external ids: %v", err)
 	}
 	if ids.TMDBID != 100 || ids.IMDBID != 200 || ids.TVDBID != 300 || ids.TVmazeID != 400 || ids.MALID != 500 {
 		t.Fatalf("unexpected external ids: %#v", ids)
 	}
-	if ids.SourcePath != "/media/file.mkv" || ids.Category != "MOVIE" ||
-		ids.SourceTMDB != "tracker" || ids.SourceIMDB != "mediainfo" ||
-		ids.SourceTVDB != "tmdb" || ids.SourceTVmaze != "tvmaze" ||
-		ids.SourceMAL != "scene" {
+	if ids.SourcePath != "/media/file.mkv" || ids.Category != api.CanonicalCategoryMovie ||
+		ids.Provenance.TMDB != api.IdentityProvenanceTracker || ids.Provenance.IMDB != api.IdentityProvenanceMediaInfo ||
+		ids.Provenance.TVDB != api.IdentityProvenanceProvider || ids.Provenance.TVmaze != api.IdentityProvenanceProvider ||
+		ids.Provenance.MAL != api.IdentityProvenanceScene {
 		t.Fatalf(
 			"unexpected external id source fields: path=%q category=%q tmdb=%q imdb=%q tvdb=%q tvmaze=%q mal=%q",
 			ids.SourcePath,
 			ids.Category,
-			ids.SourceTMDB,
-			ids.SourceIMDB,
-			ids.SourceTVDB,
-			ids.SourceTVmaze,
-			ids.SourceMAL,
+			ids.Provenance.TMDB,
+			ids.Provenance.IMDB,
+			ids.Provenance.TVDB,
+			ids.Provenance.TVmaze,
+			ids.Provenance.MAL,
 		)
 	}
-	if !ids.UpdatedAt.Equal(idsStamp) {
-		t.Fatalf("unexpected external id timestamp: got %s want %s", ids.UpdatedAt, idsStamp)
+	if !ids.ResolvedAt.Equal(idsStamp) {
+		t.Fatalf("unexpected external id timestamp: got %s want %s", ids.ResolvedAt, idsStamp)
 	}
 
 	if err := repo.SaveDVDMediaInfo(ctx, DVDMediaInfo{
@@ -278,7 +284,7 @@ func TestSQLiteRepositoryCRUD(t *testing.T) {
 		t.Fatalf("unexpected dvd mediainfo: %#v", dvdInfo)
 	}
 
-	if err := repo.SaveExternalMetadata(ctx, ExternalMetadata{
+	if err := repo.SaveExternalMetadata(ctx, ProviderMetadata{
 		SourcePath: "/media/file.mkv",
 		TMDB: &TMDBMetadata{
 			TMDBID:           100,
@@ -308,7 +314,11 @@ func TestSQLiteRepositoryCRUD(t *testing.T) {
 			IMDBID:            200,
 			SelectedReleaseID: "123",
 			Candidates: []api.BlurayReleaseCandidate{
-				{ReleaseID: "123", Title: "Example 4K", Score: 99.5},
+				{
+					ReleaseID: "123",
+					Title:     "Example 4K",
+					Score:     99.5,
+				},
 			},
 		},
 		UpdatedAt: idsStamp,
@@ -538,7 +548,7 @@ func TestSQLiteRepositoryListHistoryEntriesSkipsInfoHashOnlyPlaceholders(t *test
 	}
 }
 
-func TestSQLiteRepositoryHistoryCountsRuleSeverities(t *testing.T) {
+func TestSQLiteRepositoryHistoryCountsRuleDispositions(t *testing.T) {
 	t.Parallel()
 	repo, err := Open(":memory:")
 	if err != nil {
@@ -550,12 +560,17 @@ func TestSQLiteRepositoryHistoryCountsRuleSeverities(t *testing.T) {
 	}
 	ctx := context.Background()
 	sourcePath := filepath.Join(t.TempDir(), "example-release.mkv")
-	if err := repo.Save(ctx, FileMetadata{Path: sourcePath, Title: "Example Release", SourceSize: 1, UpdatedAt: time.Now().UTC()}); err != nil {
+	if err := repo.Save(ctx, FileMetadata{
+		Path:       sourcePath,
+		Title:      "Example Release",
+		SourceSize: 1,
+		UpdatedAt:  time.Now().UTC(),
+	}); err != nil {
 		t.Fatalf("save metadata: %v", err)
 	}
 	if err := repo.SaveTrackerRuleFailures(ctx, sourcePath, "PTP", []TrackerRuleFailure{
 		{Rule: "blocking"},
-		{Rule: "warning", Severity: api.RuleFailureSeverityWarning},
+		{Rule: "advisory", Disposition: api.RuleDispositionAdvisory},
 	}); err != nil {
 		t.Fatalf("save rule results: %v", err)
 	}
@@ -563,7 +578,7 @@ func TestSQLiteRepositoryHistoryCountsRuleSeverities(t *testing.T) {
 	if err != nil {
 		t.Fatalf("list history: %v", err)
 	}
-	if len(entries) != 1 || entries[0].RuleFailureCount != 1 || entries[0].RuleWarningCount != 1 {
+	if len(entries) != 1 || entries[0].RuleFailureCount != 1 || entries[0].RuleAdvisoryCount != 1 {
 		t.Fatalf("unexpected history counts: %#v", entries)
 	}
 }
@@ -620,11 +635,11 @@ func TestSQLiteRepositoryConcurrentDistinctPathWritesOnDisk(t *testing.T) {
 					errCh <- fmt.Errorf("repo %d save metadata %d: %w", repoIdx, item, err)
 					return
 				}
-				if err := repo.SaveExternalIDs(ctx, ExternalIDs{
+				if err := repo.SaveExternalIdentity(ctx, Identity{
 					SourcePath: sourcePath,
 					TMDBID:     repoIdx*1000 + item,
-					Category:   string(api.CategoryMovie),
-					UpdatedAt:  now,
+					Category:   api.CanonicalCategoryMovie,
+					ResolvedAt: now,
 				}); err != nil {
 					errCh <- fmt.Errorf("repo %d save external ids %d: %w", repoIdx, item, err)
 					return
@@ -687,7 +702,7 @@ func TestSQLiteRepositoryConcurrentDistinctPathWritesOnDisk(t *testing.T) {
 			if _, ok := stored[sourcePath]; !ok {
 				t.Fatalf("missing stored path %s", sourcePath)
 			}
-			ids, err := migratorRepo.GetExternalIDs(ctx, sourcePath)
+			ids, err := migratorRepo.GetExternalIdentity(ctx, sourcePath)
 			if err != nil {
 				t.Fatalf("get external ids %s: %v", sourcePath, err)
 			}
@@ -999,7 +1014,8 @@ func TestTrackerRuleFailuresCRUD(t *testing.T) {
 			Tracker:    tracker,
 			Rule:       "recommended_id",
 			Reason:     "missing recommended ID",
-			Severity:   api.RuleFailureSeverityWarning,
+			Disposition: api.RuleDispositionAdvisory,
+			Authorized:  true,
 		},
 	}
 	if err := repo.SaveTrackerRuleFailures(ctx, path, tracker, failures); err != nil {
@@ -1013,11 +1029,11 @@ func TestTrackerRuleFailuresCRUD(t *testing.T) {
 	if len(stored) != 2 {
 		t.Fatalf("expected 2 tracker rule results, got %d", len(stored))
 	}
-	if stored[0].Rule != "require_unique_id" || stored[0].Tracker != tracker || stored[0].Severity != api.RuleFailureSeverityBlocking {
+	if stored[0].Rule != "require_unique_id" || stored[0].Tracker != tracker || stored[0].Disposition != api.RuleDispositionWaivable || stored[0].Authorized {
 		t.Fatalf("unexpected rule failure: %#v", stored[0])
 	}
-	if stored[1].Severity != api.RuleFailureSeverityWarning {
-		t.Fatalf("unexpected rule warning: %#v", stored[1])
+	if stored[1].Disposition != api.RuleDispositionAdvisory || !stored[1].Authorized {
+		t.Fatalf("unexpected rule advisory: %#v", stored[1])
 	}
 
 	if err := repo.SaveTrackerRuleFailures(ctx, path, tracker, nil); err != nil {
@@ -1378,11 +1394,19 @@ func TestSQLiteMigrationBranchesCanApplyDisjointLedgerMigrations(t *testing.T) {
 
 	registryA := []migrationStep{
 		{id: baselineMigrationID, apply: createBaselineSchema},
-		{id: "branch_a_feature", dependsOn: []string{baselineMigrationID}, apply: func(context.Context, migrationExecutor) error { return nil }},
+		{
+			id:        "branch_a_feature",
+			dependsOn: []string{baselineMigrationID},
+			apply:     func(context.Context, migrationExecutor) error { return nil },
+		},
 	}
 	registryB := []migrationStep{
 		{id: baselineMigrationID, apply: createBaselineSchema},
-		{id: "branch_b_feature", dependsOn: []string{baselineMigrationID}, apply: func(context.Context, migrationExecutor) error { return nil }},
+		{
+			id:        "branch_b_feature",
+			dependsOn: []string{baselineMigrationID},
+			apply:     func(context.Context, migrationExecutor) error { return nil },
+		},
 	}
 
 	if err := migrateContextWithRegistry(context.Background(), rawDB, registryA); err != nil {
@@ -1428,7 +1452,11 @@ func TestSQLiteMigrationFailsWhenAppliedMigrationIsMissingDependency(t *testing.
 
 	registry := []migrationStep{
 		{id: baselineMigrationID, apply: createBaselineSchema},
-		{id: "child", dependsOn: []string{baselineMigrationID}, apply: func(context.Context, migrationExecutor) error { return nil }},
+		{
+			id:        "child",
+			dependsOn: []string{baselineMigrationID},
+			apply:     func(context.Context, migrationExecutor) error { return nil },
+		},
 	}
 
 	err = migrateContextWithRegistry(context.Background(), rawDB, registry)
@@ -1450,15 +1478,27 @@ func TestValidatedMigrationRegistryRejectsInvalidDefinitions(t *testing.T) {
 
 	missingDependency := []migrationStep{
 		{id: baselineMigrationID, apply: createBaselineSchema},
-		{id: "child", dependsOn: []string{"missing"}, apply: func(context.Context, migrationExecutor) error { return nil }},
+		{
+			id:        "child",
+			dependsOn: []string{"missing"},
+			apply:     func(context.Context, migrationExecutor) error { return nil },
+		},
 	}
 	if _, err := validatedMigrationRegistry(missingDependency); err == nil || !strings.Contains(err.Error(), "depends on unknown migration") {
 		t.Fatalf("expected missing dependency definition error, got %v", err)
 	}
 
 	cycle := []migrationStep{
-		{id: baselineMigrationID, dependsOn: []string{"child"}, apply: createBaselineSchema},
-		{id: "child", dependsOn: []string{baselineMigrationID}, apply: func(context.Context, migrationExecutor) error { return nil }},
+		{
+			id:        baselineMigrationID,
+			dependsOn: []string{"child"},
+			apply:     createBaselineSchema,
+		},
+		{
+			id:        "child",
+			dependsOn: []string{baselineMigrationID},
+			apply:     func(context.Context, migrationExecutor) error { return nil },
+		},
 	}
 	if _, err := validatedMigrationRegistry(cycle); err == nil || !strings.Contains(err.Error(), "dependency cycle") {
 		t.Fatalf("expected dependency cycle error, got %v", err)
@@ -1554,16 +1594,28 @@ func TestSQLitePurgeContentData(t *testing.T) {
 		t.Fatalf("insert legacy ui_states: %v", err)
 	}
 
-	if err := repo.Save(ctx, FileMetadata{Path: targetPath, InfoHash: "hash-a", UpdatedAt: now}); err != nil {
+	if err := repo.Save(ctx, FileMetadata{
+		Path:      targetPath,
+		InfoHash:  "hash-a",
+		UpdatedAt: now,
+	}); err != nil {
 		t.Fatalf("save target metadata: %v", err)
 	}
-	if err := repo.Save(ctx, FileMetadata{Path: otherPath, InfoHash: "hash-b", UpdatedAt: now}); err != nil {
+	if err := repo.Save(ctx, FileMetadata{
+		Path:      otherPath,
+		InfoHash:  "hash-b",
+		UpdatedAt: now,
+	}); err != nil {
 		t.Fatalf("save other metadata: %v", err)
 	}
-	if err := repo.SaveExternalIDs(ctx, ExternalIDs{SourcePath: targetPath, TMDBID: 100, UpdatedAt: now}); err != nil {
+	if err := repo.SaveExternalIdentity(ctx, Identity{
+		SourcePath: targetPath,
+		TMDBID:     100,
+		ResolvedAt: now,
+	}); err != nil {
 		t.Fatalf("save external ids: %v", err)
 	}
-	if err := repo.SaveExternalMetadata(ctx, ExternalMetadata{
+	if err := repo.SaveExternalMetadata(ctx, ProviderMetadata{
 		SourcePath: targetPath,
 		TMDB:       &TMDBMetadata{TMDBID: 100, Title: "Example"},
 		UpdatedAt:  now,
@@ -1649,10 +1701,18 @@ func TestSQLitePurgeContentData(t *testing.T) {
 	}}); err != nil {
 		t.Fatalf("save screenshot slots other: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: targetPath}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: targetPath,
+	}); err != nil {
 		t.Fatalf("save upload record target: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: otherPath}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: otherPath,
+	}); err != nil {
 		t.Fatalf("save upload record other: %v", err)
 	}
 	if err := repo.PurgeContentData(ctx, targetPath); err != nil {
@@ -1662,7 +1722,7 @@ func TestSQLitePurgeContentData(t *testing.T) {
 	if _, err := repo.GetByPath(ctx, targetPath); !errors.Is(err, internalerrors.ErrNotFound) {
 		t.Fatalf("expected target metadata removed, got %v", err)
 	}
-	if _, err := repo.GetExternalIDs(ctx, targetPath); !errors.Is(err, internalerrors.ErrNotFound) {
+	if _, err := repo.GetExternalIdentity(ctx, targetPath); !errors.Is(err, internalerrors.ErrNotFound) {
 		t.Fatalf("expected external ids removed, got %v", err)
 	}
 	if _, err := repo.GetExternalMetadata(ctx, targetPath); !errors.Is(err, internalerrors.ErrNotFound) {
@@ -1812,7 +1872,11 @@ func TestSQLiteRepositoryListStoredReleasePathsIncludesOrphans(t *testing.T) {
 	if err := repo.Save(ctx, FileMetadata{Path: "/media/a.mkv", UpdatedAt: now}); err != nil {
 		t.Fatalf("save metadata: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: "/media/orphan-upload.mkv"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: "/media/orphan-upload.mkv",
+	}); err != nil {
 		t.Fatalf("create upload record: %v", err)
 	}
 	if err := repo.SaveScreenshot(ctx, Screenshot{
@@ -1874,13 +1938,25 @@ func TestSQLiteRepositoryListPendingUploadsIncludesInternal(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: "/tmp/a"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: "/tmp/a",
+	}); err != nil {
 		t.Fatalf("create pending record: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "AITHER", Status: "pending-internal", SourcePath: "/tmp/b"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "AITHER",
+		Status:     "pending-internal",
+		SourcePath: "/tmp/b",
+	}); err != nil {
 		t.Fatalf("create pending-internal record: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "HDB", Status: "uploaded", SourcePath: "/tmp/c"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "HDB",
+		Status:     "uploaded",
+		SourcePath: "/tmp/c",
+	}); err != nil {
 		t.Fatalf("create uploaded record: %v", err)
 	}
 
@@ -2002,10 +2078,18 @@ func TestSQLiteRepositoryUpdateLatestUploadRecordStatus(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: "/tmp/file"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: "/tmp/file",
+	}); err != nil {
 		t.Fatalf("create first upload record: %v", err)
 	}
-	if err := repo.CreateUploadRecord(ctx, UploadRecord{Tracker: "BLU", Status: "pending", SourcePath: "/tmp/file"}); err != nil {
+	if err := repo.CreateUploadRecord(ctx, UploadRecord{
+		Tracker:    "BLU",
+		Status:     "pending",
+		SourcePath: "/tmp/file",
+	}); err != nil {
 		t.Fatalf("create second upload record: %v", err)
 	}
 
diff --git a/internal/services/description/hdb/builder.go b/internal/services/description/hdb/builder.go
deleted file mode 100644
index 101034b6..00000000
--- a/internal/services/description/hdb/builder.go
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	hdbImgSizedPattern = regexp.MustCompile(`(?i)\[img=\d+\]`)
-	hdbSizePattern     = regexp.MustCompile(`(?i)\[/size\]|\[size=\d+\]`)
-	hdbSpoilerPattern  = regexp.MustCompile(`(?i)\[spoiler([^\]]*)\]`)
-	hdbCompPattern     = regexp.MustCompile(`(?i)\[comparison=([^\]]+)\]([\s\S]*?)\[/comparison\]`)
-	hdbImgURLPattern   = regexp.MustCompile(`(?i)(https?://[^\s\]]+\.(?:png|jpg|jpeg|webp))`)
-	hdbURLImgPattern   = regexp.MustCompile(`(?is)\[url=(https?://[^\]]+)\]\s*\[img(?:[^\]]*)?\](https?://[^\[]+?)\[/img\]\s*\[/url\]`)
-	hdbImgBlockPattern = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\](https?://[^\[]+?)\[/img\]`)
-	hdbUARegex         = regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`)
-	hdbEmptyWrapperTag = regexp.MustCompile(`(?is)\[(?:center|align=center)\]\s*\[/(?:center|align)\]`)
-)
-
-// BuildDescription builds HDB-compatible BBCode from retained description
-// text and resolved image assets. Disc-menu images render in their own section
-// before normal screenshots; cancellation and disc-metadata read failures are
-// returned to the caller.
-func BuildDescription(ctx context.Context, meta api.PreparedMetadata, appConfig config.Config, keptDescription string, menuImages []api.ScreenshotImage, screenshots []api.ScreenshotImage) (string, error) {
-	select {
-	case <-ctx.Done():
-		return "", fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	parts := make([]string, 0, 8)
-
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" && strings.TrimSpace(keptDescription) == "" {
-		parts = append(parts, fmt.Sprintf("[center][quote]This release is sourced from %s[/quote][/center]", strings.TrimSpace(meta.ServiceLongName)))
-	}
-
-	discSection, err := buildDiscSection(meta, appConfig.MainSettings.DBPath)
-	if err != nil {
-		return "", err
-	}
-	if strings.TrimSpace(discSection) != "" {
-		parts = append(parts, discSection)
-	}
-
-	if transformed := transformBaseDescription(keptDescription, len(menuImages) > 0 || len(screenshots) > 0); strings.TrimSpace(transformed) != "" {
-		parts = append(parts, transformed)
-	}
-
-	if len(menuImages) > 0 {
-		if header := strings.TrimSpace(appConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		if section := buildScreenshotSection(menuImages, 0); section != "" {
-			parts = append(parts, section)
-		}
-	}
-
-	if section := buildScreenshotSection(screenshots, meta.Options.Screens); section != "" {
-		parts = append(parts, section)
-	}
-
-	if signature := strings.TrimSpace(appConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	return normalize(strings.Join(parts, "\n\n")), nil
-}
-
-func buildDiscSection(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if strings.TrimSpace(meta.DVDVOBMediaInfoText) != "" {
-		return "[quote=VOB MediaInfo]" + strings.TrimSpace(meta.DVDVOBMediaInfoText) + "[/quote]", nil
-	}
-
-	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return "", nil
-	}
-
-	if strings.TrimSpace(dbPath) == "" {
-		return "", nil
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("description: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("description: %w", err)
-	}
-	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta))
-	if strings.TrimSpace(path) == "" {
-		return "", nil
-	}
-	content, err := os.ReadFile(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return "", nil
-		}
-		return "", fmt.Errorf("description: HDB read MediaInfo file: %w", err)
-	}
-	trimmed := strings.TrimSpace(string(content))
-	if trimmed == "" {
-		return "", nil
-	}
-	return "[quote]" + trimmed + "[/quote]", nil
-}
-
-func transformBaseDescription(value string, stripScreens bool) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	transformed := trimmed
-	transformed = hdbUARegex.ReplaceAllString(transformed, "")
-	if stripScreens {
-		transformed = hdbURLImgPattern.ReplaceAllString(transformed, "")
-		transformed = hdbImgBlockPattern.ReplaceAllString(transformed, "")
-		transformed = hdbEmptyWrapperTag.ReplaceAllString(transformed, "")
-	}
-	transformed = strings.ReplaceAll(transformed, "[code]", "[font=monospace]")
-	transformed = strings.ReplaceAll(transformed, "[/code]", "[/font]")
-	for _, tag := range []string{"user", "left", "right", "sup", "sub", "alert", "note", "hr", "ul", "ol"} {
-		transformed = strings.ReplaceAll(transformed, "["+tag+"]", "")
-		transformed = strings.ReplaceAll(transformed, "[/"+tag+"]", "")
-	}
-	transformed = strings.ReplaceAll(transformed, "[align=left]", "")
-	transformed = strings.ReplaceAll(transformed, "[align=right]", "")
-	transformed = strings.ReplaceAll(transformed, "[/align]", "")
-	transformed = strings.ReplaceAll(transformed, "[h1]", "[u][b]")
-	transformed = strings.ReplaceAll(transformed, "[/h1]", "[/b][/u]")
-	transformed = strings.ReplaceAll(transformed, "[h2]", "[u][b]")
-	transformed = strings.ReplaceAll(transformed, "[/h2]", "[/b][/u]")
-	transformed = strings.ReplaceAll(transformed, "[h3]", "[u][b]")
-	transformed = strings.ReplaceAll(transformed, "[/h3]", "[/b][/u]")
-	transformed = strings.ReplaceAll(transformed, "[*]", "* ")
-	transformed = hdbSpoilerPattern.ReplaceAllString(transformed, "[hide$1]")
-	transformed = strings.ReplaceAll(transformed, "[/spoiler]", "[/hide]")
-	transformed = convertComparisonToCentered(transformed, 1000)
-	transformed = hdbImgSizedPattern.ReplaceAllString(transformed, "[img]")
-	transformed = hdbSizePattern.ReplaceAllString(transformed, "")
-	return normalize(transformed)
-}
-
-func convertComparisonToCentered(value string, maxWidth int) string {
-	return hdbCompPattern.ReplaceAllStringFunc(value, func(match string) string {
-		parts := hdbCompPattern.FindStringSubmatch(match)
-		if len(parts) < 3 {
-			return match
-		}
-		sourcePart := strings.TrimSpace(parts[1])
-		imagePart := strings.TrimSpace(parts[2])
-		sources := splitCSV(sourcePart)
-		if len(sources) == 0 {
-			return match
-		}
-		images := hdbImgURLPattern.FindAllString(imagePart, -1)
-		if len(images) == 0 {
-			return match
-		}
-		screensPerLine := len(sources)
-		if screensPerLine <= 0 {
-			return match
-		}
-		imgSize := min(maxWidth/screensPerLine, 350)
-		rows := make([]string, 0)
-		line := make([]string, 0, screensPerLine)
-		for _, img := range images {
-			u := strings.TrimSpace(img)
-			if u == "" {
-				continue
-			}
-			line = append(line, "[url="+u+"][img="+strconv.Itoa(imgSize)+"]"+u+"[/img][/url]")
-			if len(line) == screensPerLine {
-				rows = append(rows, strings.Join(line, ""))
-				line = line[:0]
-			}
-		}
-		return "[center]" + strings.Join(sources, " | ") + "\n" + strings.Join(rows, "\n") + "[/center]"
-	})
-}
-
-func splitCSV(value string) []string {
-	parts := strings.Split(value, ",")
-	out := make([]string, 0, len(parts))
-	for _, part := range parts {
-		trimmed := strings.TrimSpace(part)
-		if trimmed != "" {
-			out = append(out, trimmed)
-		}
-	}
-	return out
-}
-
-func buildScreenshotSection(images []api.ScreenshotImage, maxCount int) string {
-	if len(images) == 0 {
-		return ""
-	}
-	limit := len(images)
-	if maxCount > 0 && maxCount < limit {
-		limit = maxCount
-	}
-	parts := make([]string, 0, limit+2)
-	parts = append(parts, "[center]")
-	for _, image := range images[:limit] {
-		imgURL := strings.TrimSpace(image.ImgURL)
-		if imgURL == "" {
-			imgURL = strings.TrimSpace(image.RawURL)
-		}
-		webURL := strings.TrimSpace(image.WebURL)
-		if imgURL == "" {
-			continue
-		}
-		if webURL != "" {
-			parts = append(parts, "[url="+webURL+"][img]"+imgURL+"[/img][/url]")
-			continue
-		}
-		parts = append(parts, "[img]"+imgURL+"[/img]")
-	}
-	parts = append(parts, "[/center]")
-	return strings.Join(parts, "")
-}
-
-func normalize(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	re := regexp.MustCompile(`\n{3,}`)
-	return strings.TrimSpace(re.ReplaceAllString(trimmed, "\n\n"))
-}
diff --git a/internal/services/description/hdb/builder_test.go b/internal/services/description/hdb/builder_test.go
deleted file mode 100644
index 03246cd5..00000000
--- a/internal/services/description/hdb/builder_test.go
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionAddsWebDLSource(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Type:            "WEBDL",
-		ServiceLongName: "Netflix",
-	}
-	description, err := BuildDescription(context.Background(), meta, config.Config{}, "", nil, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(description, "This release is sourced from Netflix") {
-		t.Fatalf("expected web source quote, got %q", description)
-	}
-}
-
-func TestBuildDescriptionTransformsBaseAndAddsScreens(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Options: api.UploadOptions{Screens: 1},
-	}
-	base := "[code]x[/code]\n[spoiler=Comp][comparison=A, B]https://img/a.jpg https://img/b.jpg[/comparison][/spoiler]\n[size=3][img=300]https://img/x.jpg[/img][/size]"
-	screens := []api.ScreenshotImage{{ImgURL: "https://img/s1.jpg", WebURL: "https://web/s1"}, {ImgURL: "https://img/s2.jpg"}}
-
-	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(description, "[font=monospace]x[/font]") {
-		t.Fatalf("expected code tag conversion, got %q", description)
-	}
-	if !strings.Contains(description, "[hide=Comp]") {
-		t.Fatalf("expected spoiler-to-hide conversion, got %q", description)
-	}
-	if !strings.Contains(description, "[center][url=https://web/s1][img]https://img/s1.jpg[/img][/url][/center]") {
-		t.Fatalf("expected screenshot section with one image due to limit, got %q", description)
-	}
-	if strings.Contains(description, "https://img/s2.jpg") {
-		t.Fatalf("expected second screenshot omitted by limit, got %q", description)
-	}
-}
-
-func TestBuildDescriptionAddsRehostedMenuImagesSeparately(t *testing.T) {
-	menuImages := []api.ScreenshotImage{{
-		Purpose: api.ScreenshotPurposeMenu,
-		ImgURL:  "https://t.hdbits.org/menu.jpg",
-		WebURL:  "https://img.hdbits.org/menu",
-	}}
-	screens := []api.ScreenshotImage{{
-		Purpose: api.ScreenshotPurposeFinal,
-		ImgURL:  "https://t.hdbits.org/screen.jpg",
-		WebURL:  "https://img.hdbits.org/screen",
-	}}
-	appConfig := config.Config{Description: config.DescriptionSettingsConfig{DiscMenuHeader: "[b]Disc menu[/b]"}}
-
-	description, err := BuildDescription(context.Background(), api.PreparedMetadata{}, appConfig, "", menuImages, screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	menuPos := strings.Index(description, "https://t.hdbits.org/menu.jpg")
-	screenPos := strings.Index(description, "https://t.hdbits.org/screen.jpg")
-	if menuPos < 0 || screenPos < 0 {
-		t.Fatalf("expected menu and screenshot sections, got %q", description)
-	}
-	if !strings.Contains(description, "[b]Disc menu[/b]") {
-		t.Fatalf("expected disc menu header, got %q", description)
-	}
-	if menuPos >= screenPos {
-		t.Fatalf("expected menu before screenshots, got %q", description)
-	}
-}
-
-func TestBuildDescriptionReplacesExistingScreenshotBlock(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Options: api.UploadOptions{Screens: 4},
-	}
-	base := `[align=center]
-[url=https://pixhost.to/8ca234.png][img width=350]https://pixhost.to/8ca234.png[/img][/url]
-[url=https://pixhost.to/4oh0bz.png][img width=350]https://pixhost.to/4oh0bz.png[/img][/url]
-[/align]
-
-[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
-	screens := []api.ScreenshotImage{
-		{ImgURL: "https://t.hdbits.org/51q8jo2.jpg", RawURL: "https://img.hdbits.org/51q8jo2.jpg", WebURL: "https://img.hdbits.org/51q8jo2"},
-		{ImgURL: "https://t.hdbits.org/w0S7ltI.jpg", RawURL: "https://img.hdbits.org/w0S7ltI.jpg", WebURL: "https://img.hdbits.org/w0S7ltI"},
-	}
-
-	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(description, "pixhost.to/8ca234.png") || strings.Contains(description, "pixhost.to/4oh0bz.png") {
-		t.Fatalf("expected old screenshot block to be removed, got %q", description)
-	}
-	if count := strings.Count(description, "[center][url=https://img.hdbits.org/"); count != 1 {
-		t.Fatalf("expected one rebuilt screenshot section, got %d in %q", count, description)
-	}
-	if !strings.Contains(description, "img.hdbits.org/51q8jo2") || !strings.Contains(description, "img.hdbits.org/w0S7ltI") {
-		t.Fatalf("expected new HDB screenshots, got %q", description)
-	}
-}
-
-func TestBuildDescriptionPreservesExistingScreensWhenNoNewScreensProvided(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Options: api.UploadOptions{Screens: 4},
-	}
-	base := `[align=center]
-[url=https://pixhost.to/8ca234.png][img width=350]https://pixhost.to/8ca234.png[/img][/url]
-[url=https://pixhost.to/4oh0bz.png][img width=350]https://pixhost.to/4oh0bz.png[/img][/url]
-[/align]
-
-[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
-
-	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(description, "pixhost.to/8ca234.png") || !strings.Contains(description, "pixhost.to/4oh0bz.png") {
-		t.Fatalf("expected existing screenshot block preserved, got %q", description)
-	}
-	if strings.Contains(description, "upbrr") {
-		t.Fatalf("expected default signature removed, got %q", description)
-	}
-}
diff --git a/internal/services/description/mtv/builder.go b/internal/services/description/mtv/builder.go
deleted file mode 100644
index efaea003..00000000
--- a/internal/services/description/mtv/builder.go
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var mtvQuoteTagPattern = regexp.MustCompile(`(?i)\[/?quote\]`)
-var mtvCollapseLinesPattern = regexp.MustCompile(`\n{3,}`)
-var mtvNFOBlockPattern = regexp.MustCompile(`(?is)(?:\[(?:center|align=center)\]\s*)?\[(?:spoiler|hide)=(?:Scene|FraMeSToR) NFO:\](?:\[(?:code|pre)\])?.*?(?:\[/(?:code|pre)\])?\[/(?:spoiler|hide)\](?:\s*\[/(?:center|align)\])?`)
-var mtvURLImagePattern = regexp.MustCompile(`(?is)\[url=[^\]]+\]\s*\[img(?:[^\]]*)?\][^\[]+\[/img\]\s*\[/url\]`)
-var mtvImagePattern = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\][^\[]+\[/img\]`)
-var mtvSignaturePattern = regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`)
-var mtvEmptyAlignPattern = regexp.MustCompile(`(?is)\[(?:center|right|left|align=(?:center|right|left))\]\s*\[/(?:center|right|left|align)\]`)
-
-func BuildDescription(ctx context.Context, meta api.PreparedMetadata, appConfig config.Config, keptDescription string, screenshots []api.ScreenshotImage) (string, error) {
-	select {
-	case <-ctx.Done():
-		return "", fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	parts := make([]string, 0, 8)
-
-	mediaBlock, err := buildMediaInfoBlock(meta, appConfig.MainSettings.DBPath)
-	if err != nil {
-		return "", err
-	}
-	if mediaBlock != "" {
-		parts = append(parts, mediaBlock)
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") && strings.TrimSpace(meta.DVDVOBMediaInfoText) != "" {
-		parts = append(parts, "[mediainfo]"+strings.TrimSpace(meta.DVDVOBMediaInfoText)+"[/mediainfo]")
-	}
-
-	if shouldIncludeTonemappedHeader(meta, appConfig, screenshots) {
-		header := strings.TrimSpace(appConfig.Description.TonemappedHeader)
-		if header != "" {
-			parts = append(parts, header)
-		}
-	}
-
-	if section := buildScreenshotSection(screenshots); section != "" {
-		parts = append(parts, section)
-	}
-
-	base := sanitizeNotes(keptDescription)
-	if base != "" {
-		parts = append(parts, "[spoiler=Notes]"+base+"[/spoiler]")
-	}
-
-	return normalize(strings.Join(parts, "\n\n")), nil
-}
-
-func buildMediaInfoBlock(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		bdInfoPath, err := resolveBDInfoPath(meta, dbPath)
-		if err != nil {
-			return "", err
-		}
-		if strings.TrimSpace(bdInfoPath) != "" {
-			text, err := os.ReadFile(bdInfoPath)
-			if err != nil {
-				if !os.IsNotExist(err) {
-					return "", fmt.Errorf("description: MTV read BDInfo file: %w", err)
-				}
-			} else {
-				trimmed := strings.TrimSpace(string(text))
-				if trimmed != "" {
-					return "[mediainfo]" + trimmed + "[/mediainfo]", nil
-				}
-			}
-		}
-	}
-
-	if strings.TrimSpace(meta.MediaInfoTextPath) != "" {
-		text, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-		if err != nil {
-			if !os.IsNotExist(err) {
-				return "", fmt.Errorf("description: MTV read MediaInfo file: %w", err)
-			}
-		} else {
-			trimmed := strings.TrimSpace(string(text))
-			if trimmed != "" {
-				return "[mediainfo]" + trimmed + "[/mediainfo]", nil
-			}
-		}
-	}
-
-	return "", nil
-}
-
-func resolveBDInfoPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" {
-		return "", nil
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("description: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("description: %w", err)
-	}
-	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta))
-	if strings.TrimSpace(path) == "" {
-		return "", nil
-	}
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			return "", nil
-		}
-		return "", fmt.Errorf("description: MTV stat BDInfo summary: %w", err)
-	}
-	return path, nil
-}
-
-func buildScreenshotSection(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(images))
-	for _, image := range images {
-		imgURL := strings.TrimSpace(image.ImgURL)
-		if imgURL == "" {
-			imgURL = strings.TrimSpace(image.RawURL)
-		}
-		rawURL := strings.TrimSpace(image.RawURL)
-		if rawURL == "" {
-			rawURL = imgURL
-		}
-		if imgURL == "" {
-			continue
-		}
-		if rawURL != "" {
-			parts = append(parts, "[url="+rawURL+"][img=250]"+imgURL+"[/img][/url]")
-			continue
-		}
-		parts = append(parts, "[img=250]"+imgURL+"[/img]")
-	}
-	return strings.Join(parts, "")
-}
-
-func normalize(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	return strings.TrimSpace(mtvCollapseLinesPattern.ReplaceAllString(trimmed, "\n\n"))
-}
-
-func sanitizeNotes(value string) string {
-	cleaned := mtvQuoteTagPattern.ReplaceAllString(value, "")
-	cleaned = mtvNFOBlockPattern.ReplaceAllString(cleaned, "")
-	cleaned = mtvURLImagePattern.ReplaceAllString(cleaned, "")
-	cleaned = mtvImagePattern.ReplaceAllString(cleaned, "")
-	cleaned = mtvSignaturePattern.ReplaceAllString(cleaned, "")
-	cleaned = mtvEmptyAlignPattern.ReplaceAllString(cleaned, "")
-	return normalize(cleaned)
-}
-
-func shouldIncludeTonemappedHeader(meta api.PreparedMetadata, appConfig config.Config, screenshots []api.ScreenshotImage) bool {
-	if !appConfig.ScreenshotHandling.ToneMap {
-		return false
-	}
-	if len(screenshots) == 0 {
-		return false
-	}
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	return strings.Contains(hdr, "HDR") || strings.Contains(hdr, "DV")
-}
diff --git a/internal/services/description/mtv/builder_test.go b/internal/services/description/mtv/builder_test.go
deleted file mode 100644
index 422a08a4..00000000
--- a/internal/services/description/mtv/builder_test.go
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesMediaInfoAndNotes(t *testing.T) {
-	dir := t.TempDir()
-	miPath := filepath.Join(dir, "MEDIAINFO.txt")
-	if err := os.WriteFile(miPath, []byte("MI_CONTENT"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		MediaInfoTextPath: miPath,
-	}
-
-	desc, err := BuildDescription(context.Background(), meta, config.Config{}, "[quote]note[/quote]", nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(desc, "[mediainfo]MI_CONTENT[/mediainfo]") {
-		t.Fatalf("expected mediainfo block, got %q", desc)
-	}
-	if !strings.Contains(desc, "[spoiler=Notes]note[/spoiler]") {
-		t.Fatalf("expected notes spoiler, got %q", desc)
-	}
-}
-
-func TestBuildDescriptionIncludesTonemapAndScreenshots(t *testing.T) {
-	meta := api.PreparedMetadata{HDR: "HDR10"}
-	cfg := config.Config{
-		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
-		Description:        config.DescriptionSettingsConfig{TonemappedHeader: "[center]tone[/center]"},
-	}
-	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
-
-	desc, err := BuildDescription(context.Background(), meta, cfg, "", screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(desc, "[center]tone[/center]") {
-		t.Fatalf("expected tonemap header, got %q", desc)
-	}
-	if !strings.Contains(desc, "[url=https://raw/1][img=250]https://img/1.jpg[/img][/url]") {
-		t.Fatalf("expected mtv screenshot bbcode, got %q", desc)
-	}
-}
-
-func TestBuildDescriptionSkipsTonemapHeaderForNonHDR(t *testing.T) {
-	meta := api.PreparedMetadata{}
-	cfg := config.Config{
-		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
-		Description:        config.DescriptionSettingsConfig{TonemappedHeader: "[center]tone[/center]"},
-	}
-	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
-
-	desc, err := BuildDescription(context.Background(), meta, cfg, "", screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(desc, "[center]tone[/center]") {
-		t.Fatalf("did not expect tonemap header for non-HDR content, got %q", desc)
-	}
-}
-
-func TestBuildDescriptionStripsNFOFromNotes(t *testing.T) {
-	meta := api.PreparedMetadata{}
-	kept := "[center][spoiler=Scene NFO:][code]scene nfo[/code][/spoiler][/center]\n\nActual note"
-
-	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(desc, "scene nfo") {
-		t.Fatalf("expected nfo removed from notes, got %q", desc)
-	}
-	if !strings.Contains(desc, "[spoiler=Notes]Actual note[/spoiler]") {
-		t.Fatalf("expected cleaned notes spoiler, got %q", desc)
-	}
-}
-
-func TestBuildDescriptionStripsImagesFromNotesWhenScreenshotsProvided(t *testing.T) {
-	meta := api.PreparedMetadata{}
-	kept := "[url=https://raw/1][img=250]https://img/1.jpg[/img][/url]\n\nSome note"
-	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
-
-	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Count(desc, "https://img/1.jpg") != 1 {
-		t.Fatalf("expected screenshot included once, got %q", desc)
-	}
-	if !strings.Contains(desc, "[spoiler=Notes]Some note[/spoiler]") {
-		t.Fatalf("expected notes without duplicated screenshot tags, got %q", desc)
-	}
-}
-
-func TestBuildDescriptionStripsWidthImagesAndSignatureFromNotes(t *testing.T) {
-	meta := api.PreparedMetadata{}
-	kept := `[align=center]
-[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
-[/align]
-
-[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
-	screens := []api.ScreenshotImage{{RawURL: "https://pixhost.to/fv71hr.png", ImgURL: "https://pixhost.to/fv71hr.png"}}
-
-	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, screens)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(desc, "[spoiler=Notes]") {
-		t.Fatalf("expected notes section omitted when only screenshots/signature remain, got %q", desc)
-	}
-	if strings.Count(desc, "https://pixhost.to/fv71hr.png") != 2 {
-		t.Fatalf("expected one screenshot block only, got %q", desc)
-	}
-	if strings.Contains(desc, "upbrr") {
-		t.Fatalf("expected default signature removed from notes, got %q", desc)
-	}
-}
diff --git a/internal/services/description/unit3d/builder.go b/internal/services/description/unit3d/builder.go
deleted file mode 100644
index f1be72f3..00000000
--- a/internal/services/description/unit3d/builder.go
+++ /dev/null
@@ -1,538 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"context"
-	"fmt"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const uaSignatureText = "Uploaded by upbrr"
-const uaSignatureLink = "https://github.com/autobrr/upbrr"
-const dvdVOBMediaInfoHeader = "[spoiler=VOB MediaInfo][code]"
-const dvdVOBMediaInfoFooter = "[/code][/spoiler]"
-
-var collapseNewlines = regexp.MustCompile(`\n{3,}`)
-var bbcodeImageTag = regexp.MustCompile(`(?is)\[img(?:=[^\]]*)?\](.*?)\[/img\]`)
-var unit3DBotSignatureTag = regexp.MustCompile(`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`)
-var unit3DEmptyCenterTag = regexp.MustCompile(`(?is)\[center\]\s*\[/center\]`)
-var unit3DAlignBlockTag = regexp.MustCompile(`(?is)\[align=(center|left|right)\](.*?)\[/align\]`)
-var unit3DWrapperBlockTag = regexp.MustCompile(`(?is)\[(center|align=(?:center|left|right))\](.*?)\[/(center|align)\]`)
-var unit3DWidthImageTag = regexp.MustCompile(`(?i)\[img\s+width=(\d+)\]`)
-var unit3DUASignatureTag = regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`)
-var unit3DNFOBlockTag = regexp.MustCompile(`(?is)\[(?:center|align=center)\]\s*\[spoiler=(?:Scene|FraMeSToR) NFO:\]\[code\].*?\[/code\]\[/spoiler\]\s*\[/(?:center|align)\]`)
-
-func BuildDescription(ctx context.Context, meta api.PreparedMetadata, appConfig config.Config, _ config.TrackerConfig, logger api.Logger, keptDescription string, menuImages []api.ScreenshotImage, screenshots []api.ScreenshotImage) (string, error) {
-	select {
-	case <-ctx.Done():
-		return "", fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-
-	if len(screenshots) > 0 {
-		meta.DescriptionTemplate = stripUnit3DScreenshotBlocks(meta.DescriptionTemplate)
-		keptDescription = stripUnit3DScreenshotBlocks(keptDescription)
-	}
-
-	meta.DescriptionTemplate = stripUnit3DNFOBlocks(meta.DescriptionTemplate)
-	keptDescription = stripUnit3DNFOBlocks(keptDescription)
-
-	parts := make([]string, 0, 10)
-	seenParts := make(map[string]struct{}, 4)
-	appendUniquePart := func(value string, logLabel string) {
-		normalized := strings.TrimSpace(value)
-		if normalized == "" {
-			return
-		}
-		key := strings.ToLower(normalized)
-		if _, ok := seenParts[key]; ok {
-			logger.Debugf("trackers: unit3d desc skipped duplicate part=%s", logLabel)
-			return
-		}
-		seenParts[key] = struct{}{}
-		parts = append(parts, normalized)
-	}
-	if template := stripUnit3DSignature(strings.TrimSpace(meta.DescriptionTemplate)); template != "" {
-		appendUniquePart(template, "template")
-		logger.Tracef("trackers: unit3d desc part=template len=%d", len(template))
-	}
-	if kept := stripUnit3DSignature(strings.TrimSpace(keptDescription)); kept != "" {
-		appendUniquePart(kept, "kept")
-		logger.Tracef("trackers: unit3d desc part=kept len=%d imgs=%d", len(kept), countBBCodeImages(kept))
-	}
-	if header := strings.TrimSpace(appConfig.Description.CustomDescriptionHeader); header != "" {
-		appendUniquePart(header, "custom_header")
-		logger.Tracef("trackers: unit3d desc part=custom_header len=%d", len(header))
-	}
-
-	logoURL, logoSize := ResolveLogo(meta, appConfig)
-	if logoURL != "" {
-		appendUniquePart(fmt.Sprintf("[center][img=%d]%s[/img][/center]", logoSize, logoURL), "logo")
-		logger.Tracef("trackers: unit3d desc part=logo size=%d", logoSize)
-	}
-
-	if episodeOverview := EpisodeOverviewBlock(meta, appConfig); episodeOverview != "" {
-		appendUniquePart(episodeOverview, "episode_overview")
-		logger.Tracef("trackers: unit3d desc part=episode_overview len=%d", len(episodeOverview))
-	}
-
-	if bluray := BlurayBlock(meta, appConfig); bluray != "" {
-		appendUniquePart(bluray, "bluray")
-		logger.Tracef("trackers: unit3d desc part=bluray")
-	}
-
-	if vobMediaInfo := DVDVOBMediaInfoBlock(meta); vobMediaInfo != "" {
-		appendUniquePart(vobMediaInfo, "dvd_vob_mediainfo")
-		logger.Tracef("trackers: unit3d desc part=dvd_vob_mediainfo")
-	}
-
-	if tonemapHeader := strings.TrimSpace(appConfig.Description.TonemappedHeader); tonemapHeader != "" && ShouldIncludeTonemappedHeader(meta, appConfig, screenshots) {
-		appendUniquePart(tonemapHeader, "tonemap_header")
-		logger.Tracef("trackers: unit3d desc part=tonemap_header len=%d", len(tonemapHeader))
-	}
-
-	if len(menuImages) > 0 {
-		menuHeader := strings.TrimSpace(appConfig.Description.DiscMenuHeader)
-		if menuHeader != "" {
-			appendUniquePart(menuHeader, "menu_header")
-		}
-		menuSection := buildScreenshotSection(menuImages, appConfig.Description.ThumbnailSize, parseScreensPerRow(appConfig.Description.ScreensPerRow))
-		if menuSection != "" {
-			appendUniquePart(menuSection, "menu_images")
-			logger.Tracef("trackers: unit3d desc part=menu_images count=%d", len(menuImages))
-		}
-	}
-
-	logger.Tracef("trackers: unit3d desc part=mediainfo skipped (sent via API)")
-
-	filteredScreenshots := filterScreenshotDuplicates(screenshots, keptDescription, menuImages)
-	logger.Tracef("trackers: unit3d desc screenshots total=%d filtered=%d", len(screenshots), len(filteredScreenshots))
-	screenshotHeader := strings.TrimSpace(appConfig.Description.ScreenshotHeader)
-	screenshotSection := buildScreenshotSection(filteredScreenshots, appConfig.Description.ThumbnailSize, parseScreensPerRow(appConfig.Description.ScreensPerRow))
-	if screenshotSection != "" && screenshotHeader != "" {
-		appendUniquePart(screenshotHeader, "screenshot_header")
-		logger.Tracef("trackers: unit3d desc part=screenshot_header len=%d", len(screenshotHeader))
-	}
-	if screenshotSection != "" {
-		appendUniquePart(screenshotSection, "screenshots")
-		logger.Tracef("trackers: unit3d desc part=screenshots count=%d", countBBCodeImages(screenshotSection))
-	}
-	if customSignature := strings.TrimSpace(appConfig.Description.CustomSignature); customSignature != "" {
-		appendUniquePart(customSignature, "custom_signature")
-		logger.Tracef("trackers: unit3d desc part=custom_signature len=%d", len(customSignature))
-	} else {
-		link, text := UppbrrSignatureLink()
-		appendUniquePart(fmt.Sprintf("[right][url=%s][size=4]%s[/size][/url][/right]", link, text), "signature")
-		logger.Tracef("trackers: unit3d desc part=signature")
-	}
-
-	description := normalizeDescription(strings.Join(parts, "\n\n"))
-	description = finalizeUnit3DDescription(description)
-	if strings.TrimSpace(description) == "" {
-		return "", nil
-	}
-
-	if meta.Options.Debug {
-		SaveDescriptionDebug(meta, "unit3d", appConfig.MainSettings.DBPath, description, logger)
-	}
-
-	return description, nil
-}
-
-func buildScreenshotSection(images []api.ScreenshotImage, thumbnailSize int, screensPerRow int) string {
-	if thumbnailSize <= 0 {
-		thumbnailSize = 350
-	}
-	if screensPerRow <= 0 {
-		screensPerRow = 2
-	}
-	rows := make([]string, 0)
-	rowParts := make([]string, 0, screensPerRow)
-	for _, image := range images {
-		imgTag := buildScreenshotTag(image, thumbnailSize)
-		if imgTag == "" {
-			continue
-		}
-		rowParts = append(rowParts, imgTag)
-		if len(rowParts) == screensPerRow {
-			rows = append(rows, strings.Join(rowParts, " "))
-			rowParts = rowParts[:0]
-		}
-	}
-	if len(rowParts) > 0 {
-		rows = append(rows, strings.Join(rowParts, " "))
-	}
-	if len(rows) == 0 {
-		return ""
-	}
-	return "[center]\n" + strings.Join(rows, "\n") + "\n[/center]"
-}
-
-func buildScreenshotTag(image api.ScreenshotImage, thumbnailSize int) string {
-	webURL := strings.TrimSpace(image.WebURL)
-	rawURL := strings.TrimSpace(image.RawURL)
-	if webURL != "" && rawURL != "" {
-		return fmt.Sprintf("[url=%s][img=%d]%s[/img][/url]", webURL, thumbnailSize, rawURL)
-	}
-	url := pickScreenshotURL(image)
-	if url == "" {
-		return ""
-	}
-	return fmt.Sprintf("[img=%d]%s[/img]", thumbnailSize, url)
-}
-
-func parseScreensPerRow(value string) int {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 2
-	}
-	parsed, err := strconv.Atoi(trimmed)
-	if err != nil || parsed <= 0 {
-		return 2
-	}
-	return parsed
-}
-
-func filterScreenshotDuplicates(images []api.ScreenshotImage, keptDescription string, menuImages []api.ScreenshotImage) []api.ScreenshotImage {
-	if len(images) == 0 {
-		return images
-	}
-	seen := extractBBCodeImageURLs(keptDescription)
-	if seen == nil {
-		seen = make(map[string]struct{})
-	}
-	for _, img := range menuImages {
-		u := pickScreenshotURL(img)
-		if u != "" {
-			seen[u] = struct{}{}
-		}
-	}
-	if len(seen) == 0 {
-		return images
-	}
-	filtered := make([]api.ScreenshotImage, 0, len(images))
-	for _, image := range images {
-		url := pickScreenshotURL(image)
-		if url == "" {
-			continue
-		}
-		if _, ok := seen[url]; ok {
-			continue
-		}
-		filtered = append(filtered, image)
-	}
-	return filtered
-}
-
-func extractBBCodeImageURLs(value string) map[string]struct{} {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return nil
-	}
-	matches := bbcodeImageTag.FindAllStringSubmatch(trimmed, -1)
-	if len(matches) == 0 {
-		return nil
-	}
-	results := make(map[string]struct{}, len(matches))
-	for _, match := range matches {
-		if len(match) < 2 {
-			continue
-		}
-		url := strings.TrimSpace(match[1])
-		if url == "" {
-			continue
-		}
-		results[url] = struct{}{}
-	}
-	return results
-}
-
-func countBBCodeImages(value string) int {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 0
-	}
-	return len(bbcodeImageTag.FindAllStringSubmatch(trimmed, -1))
-}
-
-func pickScreenshotURL(image api.ScreenshotImage) string {
-	url := strings.TrimSpace(image.ImgURL)
-	if url == "" {
-		url = strings.TrimSpace(image.RawURL)
-	}
-	if url == "" {
-		url = strings.TrimSpace(image.WebURL)
-	}
-	return url
-}
-
-func stripUnit3DSignature(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	trimmed = unit3DBotSignatureTag.ReplaceAllString(trimmed, "")
-	trimmed = unit3DEmptyCenterTag.ReplaceAllString(trimmed, "")
-	return strings.TrimSpace(unit3DUASignatureTag.ReplaceAllString(trimmed, ""))
-}
-
-func stripUnit3DScreenshotBlocks(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	cleaned := unit3DWrapperBlockTag.ReplaceAllStringFunc(trimmed, func(match string) string {
-		parts := unit3DWrapperBlockTag.FindStringSubmatch(match)
-		if len(parts) != 4 {
-			return match
-		}
-		if !isUnit3DScreenshotBlock(parts[2]) {
-			return match
-		}
-		return ""
-	})
-	return normalizeDescription(cleaned)
-}
-
-func stripUnit3DNFOBlocks(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	return normalizeDescription(unit3DNFOBlockTag.ReplaceAllString(trimmed, ""))
-}
-
-func isUnit3DScreenshotBlock(value string) bool {
-	images := extractUnit3DBlockImages(value)
-	if len(images) == 0 || isPosterLikeTopBlock(images) {
-		return false
-	}
-	withoutLinkedImages := unit3dURLImgPattern.ReplaceAllString(value, "")
-	withoutImages := unit3dImgPattern.ReplaceAllString(withoutLinkedImages, "")
-	return strings.TrimSpace(withoutImages) == ""
-}
-
-func extractUnit3DBlockImages(value string) []Image {
-	report := extractUnit3DImages(value)
-	images := make([]Image, 0, len(report))
-	for _, image := range report {
-		images = append(images, Image{
-			ImgURL: image.ImgURL,
-			RawURL: image.RawURL,
-			WebURL: image.WebURL,
-			Host:   image.Host,
-		})
-	}
-	return images
-}
-
-func ShouldIncludeTonemappedHeader(meta api.PreparedMetadata, appConfig config.Config, screenshots []api.ScreenshotImage) bool {
-	if !appConfig.ScreenshotHandling.ToneMap {
-		return false
-	}
-	if len(screenshots) == 0 {
-		return false
-	}
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	return strings.Contains(hdr, "HDR") || strings.Contains(hdr, "DV")
-}
-
-func ResolveLogo(meta api.PreparedMetadata, appConfig config.Config) (string, int) {
-	if !appConfig.Description.AddLogo {
-		return "", 0
-	}
-	logoURL := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		logoURL = strings.TrimSpace(meta.ExternalMetadata.TMDB.Logo)
-		if logoURL == "" {
-			logoURL = strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo)
-		}
-	}
-	if logoURL == "" {
-		return "", 0
-	}
-	size := appConfig.Description.LogoSize
-	if size <= 0 {
-		size = 300
-	}
-	return logoURL, size
-}
-
-func EpisodeOverviewBlock(meta api.PreparedMetadata, appConfig config.Config) string {
-	if !appConfig.Description.EpisodeOverview {
-		return ""
-	}
-	overview := strings.TrimSpace(meta.EpisodeOverview)
-	if overview == "" {
-		return ""
-	}
-	return "[center]" + escapeBBCode(overview) + "[/center]"
-}
-
-func BlurayBlock(meta api.PreparedMetadata, appConfig config.Config) string {
-	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") && !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return ""
-	}
-	if meta.ExternalMetadata.Bluray == nil {
-		return ""
-	}
-	candidate := meta.ExternalMetadata.Bluray.SelectedCandidate()
-	if candidate == nil {
-		return ""
-	}
-	parts := make([]string, 0, 2)
-	if appConfig.Description.AddBlurayLink {
-		if releaseURL := sanitizeBlurayReleaseURL(candidate.URL); releaseURL != "" {
-			parts = append(parts, "[center]"+releaseURL+"[/center]")
-		}
-	}
-	if appConfig.Description.UseBlurayImages && len(candidate.CoverImages) > 0 {
-		size := appConfig.Description.BlurayImageSize
-		if size <= 0 {
-			size = 250
-		}
-		imageTags := make([]string, 0, len(candidate.CoverImages))
-		for _, image := range candidate.CoverImages {
-			imageURL := sanitizeDescriptionURL(image.URL)
-			if imageURL == "" {
-				continue
-			}
-			imageTags = append(imageTags, fmt.Sprintf("[img=%d]%s[/img]", size, imageURL))
-		}
-		if len(imageTags) > 0 {
-			parts = append(parts, "[center]"+strings.Join(imageTags, " ")+"[/center]")
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-func sanitizeBlurayReleaseURL(rawURL string) string {
-	return sanitizeDescriptionURL(rawURL)
-}
-
-func sanitizeDescriptionURL(rawURL string) string {
-	trimmed := strings.TrimSpace(rawURL)
-	if trimmed == "" {
-		return ""
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil || parsed.Host == "" {
-		return ""
-	}
-	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
-	if scheme != "http" && scheme != "https" {
-		return ""
-	}
-	return escapeBBCode(parsed.String())
-}
-
-func escapeBBCode(value string) string {
-	return strings.NewReplacer("[", "%5B", "]", "%5D").Replace(value)
-}
-
-func UppbrrSignatureLink() (string, string) {
-	return uaSignatureLink, uaSignatureText
-}
-
-func DVDVOBMediaInfoBlock(meta api.PreparedMetadata) string {
-	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return ""
-	}
-	vobText := strings.TrimSpace(meta.DVDVOBMediaInfoText)
-	if vobText == "" {
-		return ""
-	}
-	return dvdVOBMediaInfoHeader + vobText + dvdVOBMediaInfoFooter
-}
-
-func AppendDVDVOBMediaInfoBlock(description string, meta api.PreparedMetadata) string {
-	trimmedDescription := strings.TrimSpace(description)
-	block := DVDVOBMediaInfoBlock(meta)
-	if block == "" {
-		return trimmedDescription
-	}
-	if trimmedDescription == "" {
-		return block
-	}
-	if strings.Contains(trimmedDescription, block) {
-		return trimmedDescription
-	}
-	if strings.Contains(trimmedDescription, dvdVOBMediaInfoHeader) && strings.Contains(trimmedDescription, strings.TrimSpace(meta.DVDVOBMediaInfoText)) {
-		return trimmedDescription
-	}
-	return normalizeDescription(trimmedDescription + "\n\n" + block)
-}
-
-func normalizeDescription(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	cleaned := collapseNewlines.ReplaceAllString(trimmed, "\n\n")
-	return strings.TrimSpace(cleaned)
-}
-
-func finalizeUnit3DDescription(value string) string {
-	if strings.TrimSpace(value) == "" {
-		return ""
-	}
-	value = strings.ReplaceAll(value, "[hide", "[spoiler")
-	value = strings.ReplaceAll(value, "[/hide]", "[/spoiler]")
-	value = unit3DAlignBlockTag.ReplaceAllStringFunc(value, func(match string) string {
-		parts := unit3DAlignBlockTag.FindStringSubmatch(match)
-		if len(parts) != 3 {
-			return match
-		}
-		tag := strings.ToLower(strings.TrimSpace(parts[1]))
-		if tag == "left" {
-			tag = "center"
-		}
-		return "[" + tag + "]" + parts[2] + "[/" + tag + "]"
-	})
-	value = unit3DWidthImageTag.ReplaceAllString(value, "[img=$1]")
-	for _, tag := range []string{"[user]", "[/user]", "[hr]", "[/hr]", "[ul]", "[/ul]", "[ol]", "[/ol]"} {
-		value = strings.ReplaceAll(value, tag, "")
-	}
-	value = collapseNewlines.ReplaceAllString(value, "\n\n")
-	return normalizeDescription(value)
-}
-
-func SaveDescriptionDebug(meta api.PreparedMetadata, tracker string, dbPath string, description string, logger api.Logger) {
-	if strings.TrimSpace(dbPath) == "" {
-		return
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return
-	}
-	name := "[" + tracker + "]DESCRIPTION.txt"
-	path := filepath.Join(tmpDir, name)
-	if err := os.WriteFile(path, []byte(description), 0o600); err != nil {
-		if logger != nil {
-			logger.Warnf("trackers: %s description debug save: %v", tracker, err)
-		}
-		return
-	}
-	if logger != nil {
-		logger.Debugf("trackers: %s description saved %s", tracker, path)
-	}
-}
diff --git a/internal/services/description/unit3d/types.go b/internal/services/description/unit3d/types.go
deleted file mode 100644
index 4c726c69..00000000
--- a/internal/services/description/unit3d/types.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-type Image struct {
-	ImgURL string
-	RawURL string
-	WebURL string
-	Host   string
-}
-
-type Note struct {
-	Kind    string
-	Message string
-}
-
-type Report struct {
-	Description string
-	Images      []Image
-	Notes       []Note
-}
diff --git a/internal/services/dvdmenus/service.go b/internal/services/dvdmenus/service.go
index 12b3b7d6..98a773e2 100644
--- a/internal/services/dvdmenus/service.go
+++ b/internal/services/dvdmenus/service.go
@@ -22,8 +22,8 @@ import (
 	"github.com/autobrr/upbrr/internal/dvdvideo/graph"
 	"github.com/autobrr/upbrr/internal/dvdvideo/render"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/screenshots"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -61,8 +61,7 @@ type capabilityCache struct {
 type Service struct {
 	logger            api.Logger
 	tmpRoot           string
-	repo              api.MetadataRepository
-	lifecycle         api.ScreenshotLifecycleRepository
+	repo              repository
 	runner            render.Runner
 	resolveExecutable executableResolverFunc
 	captureDirectory  captureDirectoryFunc
@@ -71,17 +70,22 @@ type Service struct {
 	capabilityCache   capabilityCache
 }
 
+type repository interface {
+	api.ScreenshotLifecycleRepository
+	LoadMediaAssetSnapshot(context.Context, string) (api.MediaAssetSnapshot, error)
+}
+
 // NewService returns a DVD menu service that shares the screenshot FFmpeg
 // resolver and stores managed images beneath tmpRoot. A nil logger is replaced
 // with [api.NopLogger].
-func NewService(logger api.Logger, tmpRoot string, repo api.MetadataRepository) *Service {
+func NewService(logger api.Logger, tmpRoot string, repo repository) *Service {
 	return newService(logger, tmpRoot, repo, render.ExecRunner{}, screenshots.ResolveFFmpegExecutable, engine.CaptureDirectory)
 }
 
 func newService(
 	logger api.Logger,
 	tmpRoot string,
-	repo api.MetadataRepository,
+	repo repository,
 	runner render.Runner,
 	resolveExecutable executableResolverFunc,
 	captureDirectory captureDirectoryFunc,
@@ -98,12 +102,10 @@ func newService(
 	if captureDirectory == nil {
 		captureDirectory = engine.CaptureDirectory
 	}
-	lifecycle, _ := repo.(api.ScreenshotLifecycleRepository)
 	return &Service{
 		logger:            logger,
 		tmpRoot:           tmpRoot,
 		repo:              repo,
-		lifecycle:         lifecycle,
 		runner:            runner,
 		resolveExecutable: resolveExecutable,
 		captureDirectory:  captureDirectory,
@@ -114,7 +116,7 @@ func newService(
 // Capture renders and persists up to maxItems automatic menu images for one
 // prepared DVD. It atomically replaces earlier automatic captures, preserves
 // manual menus and normal screenshots, and reports partial coverage in result.
-func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxItems int) (api.DVDMenuCaptureResult, error) {
+func (s *Service) Capture(ctx context.Context, meta api.DVDMenuSubject, maxItems int) (api.DVDMenuCaptureResult, error) {
 	result := api.DVDMenuCaptureResult{SourcePath: meta.SourcePath, MaxItems: maxItems}
 	if s != nil && s.logger != nil {
 		s.logger.Debugf("DVD menus: capture requested disc_type=%s max_items=%d", strings.ToUpper(strings.TrimSpace(meta.DiscType)), maxItems)
@@ -123,7 +125,7 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 	if err := ctx.Err(); err != nil {
 		return result, fmt.Errorf("DVD menus: capture canceled: %w", err)
 	}
-	if s == nil || s.repo == nil || s.lifecycle == nil {
+	if s == nil || s.repo == nil {
 		return result, errors.New("DVD menus: screenshot lifecycle repository not configured")
 	}
 	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
@@ -145,7 +147,14 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 		return result, err
 	}
 
-	s.logger.Infof("DVD menus: capture started language=%s region=%d max_items=%d engine_version=%s ffmpeg_dvdvideo=%t", defaultLanguage, 0, maxItems, info.EngineVersion, info.FFmpegDVDVideo)
+	s.logger.Infof(
+		"DVD menus: capture started language=%s region=%d max_items=%d engine_version=%s ffmpeg_dvdvideo=%t",
+		defaultLanguage,
+		0,
+		maxItems,
+		info.EngineVersion,
+		info.FFmpegDVDVideo,
+	)
 	lastProgress := engine.Progress{}
 	hasProgress := false
 	engineResult, err := s.captureDirectory(ctx, videoTS, s.runner, executable, engine.Options{
@@ -156,7 +165,15 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 		Logger:         s.logger,
 		Progress: func(update engine.Progress) {
 			if !hasProgress || update != lastProgress {
-				s.logger.Debugf("DVD menus: progress phase=%s inventoried=%d states=%d buttons=%d captured=%d warnings=%d", update.Phase, update.Inventoried, update.VisitedStates, update.VisitedButtons, update.Captured, update.Warnings)
+				s.logger.Debugf(
+					"DVD menus: progress phase=%s inventoried=%d states=%d buttons=%d captured=%d warnings=%d",
+					update.Phase,
+					update.Inventoried,
+					update.VisitedStates,
+					update.VisitedButtons,
+					update.Captured,
+					update.Warnings,
+				)
 				lastProgress = update
 				hasProgress = true
 			}
@@ -173,14 +190,29 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 	})
 	result = mapEngineResult(meta.SourcePath, maxItems, engineResult, info)
 	if err != nil {
-		s.logger.Warnf("DVD menus: capture failed stage=engine captured=%d discovered=%d warnings=%d", len(engineResult.Captures), engineResult.Inventoried, len(engineResult.Warnings))
+		s.logger.Warnf(
+			"DVD menus: capture failed stage=engine captured=%d discovered=%d warnings=%d",
+			len(engineResult.Captures),
+			engineResult.Inventoried,
+			len(engineResult.Warnings),
+		)
 		return result, fmt.Errorf("DVD menus: %w", err)
 	}
 	if len(engineResult.Captures) == 0 {
 		s.logger.Warnf("DVD menus: capture failed stage=render reason=no_frames")
 		return result, errors.New("DVD menus: no menu images captured")
 	}
-	s.logger.Debugf("DVD menus: engine complete discovered=%d states=%d buttons=%d selected=%d captured=%d partial=%t truncated=%t warnings=%d", result.DiscoveredMenus, result.VisitedStates, result.VisitedButtons, engineResult.Selected, len(engineResult.Captures), result.Partial, result.Truncated, len(result.Warnings))
+	s.logger.Debugf(
+		"DVD menus: engine complete discovered=%d states=%d buttons=%d selected=%d captured=%d partial=%t truncated=%t warnings=%d",
+		result.DiscoveredMenus,
+		result.VisitedStates,
+		result.VisitedButtons,
+		engineResult.Selected,
+		len(engineResult.Captures),
+		result.Partial,
+		result.Truncated,
+		len(result.Warnings),
+	)
 	for _, warning := range result.Warnings {
 		s.logger.Debugf("DVD menus: warning recorded code=%s detail=%q", warning.Code, dvdMenuWarningDetail(warning.Code))
 	}
@@ -195,7 +227,7 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 		WarningCount:    len(result.Warnings),
 	})
 
-	tmpDir, base, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, base, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, api.ReleaseInfo{})
 	if err != nil {
 		return result, fmt.Errorf("DVD menus: %w", err)
 	}
@@ -206,7 +238,7 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 		return result, err
 	}
 	s.logger.Debugf("DVD menus: persistence files ready created=%d", len(created))
-	replaced, err := s.lifecycle.ReplaceDVDMenuScreenshots(ctx, meta.SourcePath, records, selections)
+	replaced, err := s.repo.ReplaceDVDMenuScreenshots(ctx, meta.SourcePath, records, selections)
 	if err != nil {
 		removeCreatedFiles(created)
 		s.logger.Warnf("DVD menus: persistence failed stage=database created=%d", len(created))
@@ -235,7 +267,16 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, maxIte
 		s.logger.Warnf("DVD menus: replaced file cleanup incomplete count=%d", cleanupFailed)
 	}
 	if result.Partial || result.Truncated {
-		s.logger.Warnf("DVD menus: capture incomplete captured=%d discovered=%d states=%d buttons=%d partial=%t truncated=%t warnings=%d", len(result.Images), result.DiscoveredMenus, result.VisitedStates, result.VisitedButtons, result.Partial, result.Truncated, len(result.Warnings))
+		s.logger.Warnf(
+			"DVD menus: capture incomplete captured=%d discovered=%d states=%d buttons=%d partial=%t truncated=%t warnings=%d",
+			len(result.Images),
+			result.DiscoveredMenus,
+			result.VisitedStates,
+			result.VisitedButtons,
+			result.Partial,
+			result.Truncated,
+			len(result.Warnings),
+		)
 	}
 	s.logger.Infof(
 		"DVD menus: capture complete captured=%d discovered=%d states=%d buttons=%d complete=%t partial=%t truncated=%t warnings=%d",
@@ -275,7 +316,7 @@ func dvdMenuProgressMessage(phase string) string {
 
 // List returns persisted manual and automatic menu images in final-selection
 // order. Missing or directory-valued local image paths are omitted.
-func (s *Service) List(ctx context.Context, meta api.PreparedMetadata) ([]api.ScreenshotImage, error) {
+func (s *Service) List(ctx context.Context, meta api.DVDMenuSubject) ([]api.ScreenshotImage, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("DVD menus: list canceled: %w", err)
 	}
@@ -286,32 +327,24 @@ func (s *Service) List(ctx context.Context, meta api.PreparedMetadata) ([]api.Sc
 		return nil, internalerrors.ErrInvalidInput
 	}
 
-	selections, err := s.repo.ListFinalSelections(ctx, meta.SourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("DVD menus: list selections: %w", err)
-	}
-	records, err := s.repo.ListScreenshotsByPath(ctx, meta.SourcePath)
+	snapshot, err := s.repo.LoadMediaAssetSnapshot(ctx, meta.SourcePath)
 	if err != nil {
-		return nil, fmt.Errorf("DVD menus: list screenshots: %w", err)
-	}
-	uploaded, err := s.repo.ListUploadedImagesByPath(ctx, meta.SourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("DVD menus: list uploaded images: %w", err)
+		return nil, fmt.Errorf("DVD menus: load media assets: %w", err)
 	}
 
-	recordByPath := make(map[string]api.Screenshot, len(records))
-	for _, record := range records {
+	recordByPath := make(map[string]api.Screenshot, len(snapshot.Screenshots))
+	for _, record := range snapshot.Screenshots {
 		if record.Purpose == api.ScreenshotPurposeMenu {
 			recordByPath[strings.TrimSpace(record.ImagePath)] = record
 		}
 	}
-	uploadByPath := make(map[string]api.UploadedImageLink, len(uploaded))
-	for _, link := range uploaded {
+	uploadByPath := make(map[string]api.UploadedImageLink, len(snapshot.UploadedImages))
+	for _, link := range snapshot.UploadedImages {
 		uploadByPath[strings.TrimSpace(link.ImagePath)] = link
 	}
 
 	images := make([]api.ScreenshotImage, 0)
-	for _, selection := range selections {
+	for _, selection := range snapshot.FinalSelections {
 		if !api.IsDiscMenuSelectionSource(selection.Source) {
 			continue
 		}
@@ -332,18 +365,18 @@ func (s *Service) List(ctx context.Context, meta api.PreparedMetadata) ([]api.Sc
 // assets are not deleted. If final removal of the staged file fails, Delete
 // attempts to restore the original file and its local records before returning;
 // compensation failures are joined with the removal error.
-func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePath string) error {
+func (s *Service) Delete(ctx context.Context, meta api.DVDMenuSubject, imagePath string) error {
 	if err := ctx.Err(); err != nil {
 		return fmt.Errorf("DVD menus: delete canceled: %w", err)
 	}
-	if s == nil || s.lifecycle == nil {
+	if s == nil || s.repo == nil {
 		return errors.New("DVD menus: screenshot lifecycle repository not configured")
 	}
 	trimmedPath := strings.TrimSpace(imagePath)
 	if strings.TrimSpace(meta.SourcePath) == "" || trimmedPath == "" {
 		return internalerrors.ErrInvalidInput
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, api.ReleaseInfo{})
 	if err != nil {
 		return fmt.Errorf("DVD menus: %w", err)
 	}
@@ -366,7 +399,7 @@ func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePa
 		return fmt.Errorf("DVD menus: inspect local image: %w", statErr)
 	}
 
-	deleted, err := s.lifecycle.DeleteDiscMenuScreenshot(ctx, meta.SourcePath, trimmedPath)
+	deleted, err := s.repo.DeleteDiscMenuScreenshot(ctx, meta.SourcePath, trimmedPath)
 	if err != nil {
 		if renamed {
 			if restoreErr := os.Rename(pendingPath, trimmedPath); restoreErr != nil {
@@ -384,7 +417,7 @@ func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePa
 			if restoreErr := os.Rename(pendingPath, trimmedPath); restoreErr != nil {
 				return fmt.Errorf("DVD menus: remove staged local image and restore file: %w", errors.Join(removeErr, restoreErr))
 			}
-			if restoreErr := s.lifecycle.RestoreDiscMenuScreenshot(context.WithoutCancel(ctx), meta.SourcePath, deleted); restoreErr != nil {
+			if restoreErr := s.repo.RestoreDiscMenuScreenshot(context.WithoutCancel(ctx), meta.SourcePath, deleted); restoreErr != nil {
 				return fmt.Errorf("DVD menus: remove staged local image and restore records: %w", errors.Join(removeErr, restoreErr))
 			}
 			return fmt.Errorf("DVD menus: remove staged local image; deletion rolled back: %w", removeErr)
@@ -445,7 +478,11 @@ func (s *Service) resolveCapability(ctx context.Context) (string, render.Capabil
 		return "", render.Capability{}, info, fmt.Errorf("DVD menus: FFmpeg capability: %w", err)
 	}
 	s.capabilityMu.Lock()
-	s.capabilityCache = capabilityCache{identity: identity, capability: capability, valid: true}
+	s.capabilityCache = capabilityCache{
+		identity:   identity,
+		capability: capability,
+		valid:      true,
+	}
 	s.capabilityMu.Unlock()
 	s.logger.Debugf("DVD menus: FFmpeg capability probe complete dvdvideo=%t options=%d", capability.Available, len(capability.Options))
 	return executable, capability, engineInfo(capability), nil
@@ -507,7 +544,11 @@ func inspectExecutable(executable string) (executableIdentity, error) {
 	if info.IsDir() {
 		return executableIdentity{}, errors.New("DVD menus: FFmpeg executable is a directory")
 	}
-	return executableIdentity{path: absPath, size: info.Size(), modTime: info.ModTime().UnixNano()}, nil
+	return executableIdentity{
+		path:    absPath,
+		size:    info.Size(),
+		modTime: info.ModTime().UnixNano(),
+	}, nil
 }
 
 func baseEngineInfo() api.DVDMenuEngineInfo {
diff --git a/internal/services/dvdmenus/service_test.go b/internal/services/dvdmenus/service_test.go
index 17b0c6d3..0b6dfd1b 100644
--- a/internal/services/dvdmenus/service_test.go
+++ b/internal/services/dvdmenus/service_test.go
@@ -16,10 +16,12 @@ import (
 	"testing"
 	"time"
 
+	preparationstate "github.com/autobrr/upbrr/internal/preparedrelease/state"
+
 	"github.com/autobrr/upbrr/internal/dvdvideo/engine"
 	"github.com/autobrr/upbrr/internal/dvdvideo/graph"
 	"github.com/autobrr/upbrr/internal/dvdvideo/render"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -102,24 +104,51 @@ func TestCaptureRerunListAndDeletePreserveManualMenus(t *testing.T) {
 		t.Fatalf("write FFmpeg identity: %v", err)
 	}
 
-	meta := api.PreparedMetadata{SourcePath: discRoot, DiscType: "DVD"}
-	managedDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	meta := api.DVDMenuSubject{SourcePath: discRoot, DiscType: "DVD"}
+	managedDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, api.ReleaseInfo{})
 	if err != nil {
 		t.Fatalf("managed dir: %v", err)
 	}
 	manualPath := filepath.Join(managedDir, "manual-dvd-menu-example.png")
-	writePNG(t, manualPath, color.NRGBA{R: 20, G: 40, B: 60, A: 255})
+	writePNG(t, manualPath, color.NRGBA{
+		R: 20,
+		G: 40,
+		B: 60,
+		A: 255,
+	})
 	now := time.Now().UTC()
 	if err := repo.AppendManualMenuScreenshots(context.Background(), meta.SourcePath,
-		[]api.Screenshot{{SourcePath: meta.SourcePath, ImagePath: manualPath, Width: 2, Height: 2, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}},
-		[]api.ScreenshotFinalSelection{{SourcePath: meta.SourcePath, ImagePath: manualPath, Source: api.ScreenshotSelectionSourceMenu, SelectedAt: now}},
+		[]api.Screenshot{{
+			SourcePath: meta.SourcePath,
+			ImagePath:  manualPath,
+			Width:      2,
+			Height:     2,
+			Purpose:    api.ScreenshotPurposeMenu,
+			CapturedAt: now,
+		}},
+		[]api.ScreenshotFinalSelection{{
+			SourcePath: meta.SourcePath,
+			ImagePath:  manualPath,
+			Source:     api.ScreenshotSelectionSourceMenu,
+			SelectedAt: now,
+		}},
 	); err != nil {
 		t.Fatalf("seed manual menu: %v", err)
 	}
 
 	captures := []engine.Capture{
-		{Image: solidImage(color.NRGBA{R: 200, G: 10, B: 10, A: 255}), Discovery: graph.DiscoveryReachable},
-		{Image: solidImage(color.NRGBA{R: 10, G: 200, B: 10, A: 255}), Discovery: graph.DiscoveryStructural},
+		{Image: solidImage(color.NRGBA{
+			R: 200,
+			G: 10,
+			B: 10,
+			A: 255,
+		}), Discovery: graph.DiscoveryReachable},
+		{Image: solidImage(color.NRGBA{
+			R: 10,
+			G: 200,
+			B: 10,
+			A: 255,
+		}), Discovery: graph.DiscoveryStructural},
 	}
 	progressUpdates := make([]api.DVDMenuProgressUpdate, 0)
 	progressCtx := api.WithDVDMenuProgressReporter(context.Background(), func(update api.DVDMenuProgressUpdate) {
@@ -288,11 +317,11 @@ func TestCaptureRollsBackCreatedFilesWhenPersistenceFails(t *testing.T) {
 			return engine.Result{Captures: []engine.Capture{{Image: solidImage(color.NRGBA{R: 50, A: 255}), Discovery: graph.DiscoveryReachable}}}, nil
 		})
 
-	_, err := service.Capture(context.Background(), api.PreparedMetadata{SourcePath: discRoot, DiscType: "DVD"}, 1)
+	_, err := service.Capture(context.Background(), api.DVDMenuSubject{SourcePath: discRoot, DiscType: "DVD"}, 1)
 	if err == nil || !strings.Contains(err.Error(), "persist capture") {
 		t.Fatalf("capture error = %v", err)
 	}
-	managedDir, _, err := paths.ReleaseTempDir(tmpRoot, api.PreparedMetadata{}, discRoot)
+	managedDir, _, err := paths.ReleaseTempDir(tmpRoot, preparationstate.State{}, discRoot)
 	if err != nil {
 		t.Fatalf("managed dir: %v", err)
 	}
@@ -322,7 +351,7 @@ func TestDeleteRejectsOriginalOutsideManagedDirectory(t *testing.T) {
 		t.Fatalf("save original selection: %v", err)
 	}
 	service := NewService(api.NopLogger{}, tmpRoot, repo)
-	err := service.Delete(context.Background(), api.PreparedMetadata{SourcePath: discRoot, DiscType: "DVD"}, original)
+	err := service.Delete(context.Background(), api.DVDMenuSubject{SourcePath: discRoot, DiscType: "DVD"}, original)
 	if err == nil || !strings.Contains(err.Error(), "outside the managed release directory") {
 		t.Fatalf("delete error = %v", err)
 	}
@@ -337,17 +366,34 @@ func TestDeleteRestoresFileAndRecordsWhenFinalRemoveFails(t *testing.T) {
 	repo := openTestRepository(t)
 	tmpRoot := t.TempDir()
 	discRoot := t.TempDir()
-	meta := api.PreparedMetadata{SourcePath: discRoot, DiscType: "DVD"}
-	managedDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	meta := api.DVDMenuSubject{SourcePath: discRoot, DiscType: "DVD"}
+	managedDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, api.ReleaseInfo{})
 	if err != nil {
 		t.Fatal("create managed directory failed")
 	}
 	imagePath := filepath.Join(managedDir, "Example.Release.2026-dvd-menu-01.png")
-	writePNG(t, imagePath, color.NRGBA{R: 20, G: 40, B: 60, A: 255})
+	writePNG(t, imagePath, color.NRGBA{
+		R: 20,
+		G: 40,
+		B: 60,
+		A: 255,
+	})
 	now := time.Now().UTC()
 	if err := repo.AppendManualMenuScreenshots(context.Background(), meta.SourcePath,
-		[]api.Screenshot{{SourcePath: meta.SourcePath, ImagePath: imagePath, Width: 2, Height: 2, Purpose: api.ScreenshotPurposeMenu, CapturedAt: now}},
-		[]api.ScreenshotFinalSelection{{SourcePath: meta.SourcePath, ImagePath: imagePath, Source: api.ScreenshotSelectionSourceMenu, SelectedAt: now}},
+		[]api.Screenshot{{
+			SourcePath: meta.SourcePath,
+			ImagePath:  imagePath,
+			Width:      2,
+			Height:     2,
+			Purpose:    api.ScreenshotPurposeMenu,
+			CapturedAt: now,
+		}},
+		[]api.ScreenshotFinalSelection{{
+			SourcePath: meta.SourcePath,
+			ImagePath:  imagePath,
+			Source:     api.ScreenshotSelectionSourceMenu,
+			SelectedAt: now,
+		}},
 	); err != nil {
 		t.Fatal("seed menu screenshot failed")
 	}
diff --git a/internal/services/imagehosting/service.go b/internal/services/imagehosting/service.go
deleted file mode 100644
index 2de36058..00000000
--- a/internal/services/imagehosting/service.go
+++ /dev/null
@@ -1,670 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package imagehosting
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Service struct {
-	cfg       config.Config
-	logger    api.Logger
-	repo      api.MetadataRepository
-	client    *http.Client
-	uploaders map[string]uploader
-}
-
-func NewService(cfg config.Config, logger api.Logger, repo api.MetadataRepository) *Service {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	client := httpclient.New(httpclient.UploadTimeout)
-	service := &Service{cfg: cfg, logger: logger, repo: repo, client: client}
-	service.uploaders = newUploaderRegistry(cfg, client)
-	return service
-}
-
-// ListCandidates returns existing local and uploaded screenshot selections for
-// image hosting, deduplicated by local image path. Disc-menu selections retain
-// [api.ScreenshotPurposeMenu]; all other candidates use final purpose.
-func (s *Service) ListCandidates(ctx context.Context, meta api.PreparedMetadata) ([]api.ScreenshotImage, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("image hosting: list candidates canceled: %w", err)
-	}
-	if s == nil || s.repo == nil {
-		return nil, errors.New("image hosting: repository not configured")
-	}
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		return nil, internalerrors.ErrInvalidInput
-	}
-
-	// First, get all screenshots from the database
-	screens, err := s.repo.ListScreenshotsByPath(ctx, meta.SourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("image hosting: %w", err)
-	}
-
-	// Then, get all previously uploaded images
-	uploaded, err := s.repo.ListUploadedImagesByPath(ctx, meta.SourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("image hosting: %w", err)
-	}
-	selections, err := s.repo.ListFinalSelections(ctx, meta.SourcePath)
-	if err != nil {
-		s.logger.Debugf("image hosting: final selections unavailable: %v", err)
-		selections = nil
-	}
-	selectionSourceByPath := make(map[string]string, len(selections))
-	for _, selection := range selections {
-		selectionSourceByPath[strings.TrimSpace(selection.ImagePath)] = strings.TrimSpace(selection.Source)
-	}
-
-	// Build a map of uploaded images by path for quick lookup
-	uploadedByPath := make(map[string]api.UploadedImageLink, len(uploaded))
-	for _, upload := range uploaded {
-		uploadedByPath[upload.ImagePath] = upload
-	}
-
-	// Build result list, merging upload info where available
-	images := make([]api.ScreenshotImage, 0, len(screens))
-	for _, shot := range screens {
-		pathValue := strings.TrimSpace(shot.ImagePath)
-		if pathValue == "" || !isAllowedImageExt(pathValue) {
-			continue
-		}
-		info, statErr := os.Stat(pathValue)
-		if statErr != nil || info.IsDir() {
-			continue
-		}
-
-		img := api.ScreenshotImage{
-			Path:             pathValue,
-			TimestampSeconds: shot.Timestamp,
-			Purpose:          shot.Purpose,
-			Width:            shot.Width,
-			Height:           shot.Height,
-			SizeBytes:        info.Size(),
-		}
-		if api.IsDiscMenuSelectionSource(selectionSourceByPath[pathValue]) {
-			img.Purpose = api.ScreenshotPurposeMenu
-		} else if img.Purpose == "" {
-			img.Purpose = api.ScreenshotPurposeFinal
-		}
-
-		// If this image has been uploaded, include the upload info
-		if uploadInfo, exists := uploadedByPath[pathValue]; exists {
-			img.Host = uploadInfo.Host
-			img.ImgURL = uploadInfo.ImgURL
-			img.RawURL = uploadInfo.RawURL
-			img.WebURL = uploadInfo.WebURL
-			img.UploadedAt = uploadInfo.UploadedAt
-			s.logger.Tracef("image hosting: found uploaded image file=%s host=%s tracker=%s", filepath.Base(pathValue), uploadInfo.Host, imageHostLogTracker(uploadInfo.Host))
-		}
-
-		images = append(images, img)
-	}
-
-	// Also include final selections (like menu images that didn't go through screenshot generation)
-	seenPaths := make(map[string]struct{}, len(images))
-	for _, img := range images {
-		seenPaths[img.Path] = struct{}{}
-	}
-	for _, sel := range selections {
-		pathValue := strings.TrimSpace(sel.ImagePath)
-		if pathValue == "" || !isAllowedImageExt(pathValue) {
-			continue
-		}
-		if _, exists := seenPaths[pathValue]; exists {
-			continue
-		}
-		info, statErr := os.Stat(pathValue)
-		if statErr != nil || info.IsDir() {
-			continue
-		}
-
-		img := api.ScreenshotImage{
-			Path:             pathValue,
-			TimestampSeconds: 0, // Fallback since it wasn't a generated frame
-			Purpose:          api.ScreenshotPurposeFinal,
-			Width:            0,
-			Height:           0,
-			SizeBytes:        info.Size(),
-		}
-		if api.IsDiscMenuSelectionSource(sel.Source) {
-			img.Purpose = api.ScreenshotPurposeMenu
-		}
-
-		if uploadInfo, exists := uploadedByPath[pathValue]; exists {
-			img.Host = uploadInfo.Host
-			img.ImgURL = uploadInfo.ImgURL
-			img.RawURL = uploadInfo.RawURL
-			img.WebURL = uploadInfo.WebURL
-			img.UploadedAt = uploadInfo.UploadedAt
-			s.logger.Tracef("image hosting: found uploaded final selection file=%s host=%s tracker=%s", filepath.Base(pathValue), uploadInfo.Host, imageHostLogTracker(uploadInfo.Host))
-		}
-
-		images = append(images, img)
-		seenPaths[pathValue] = struct{}{}
-	}
-
-	for _, upload := range uploaded {
-		pathValue := strings.TrimSpace(upload.ImagePath)
-		if pathValue == "" || !isAllowedImageExt(pathValue) {
-			continue
-		}
-		if _, exists := seenPaths[pathValue]; exists {
-			continue
-		}
-		info, statErr := os.Stat(pathValue)
-		if statErr != nil || info.IsDir() {
-			continue
-		}
-		purpose := api.ScreenshotPurposeFinal
-		if api.IsDiscMenuSelectionSource(selectionSourceByPath[pathValue]) {
-			purpose = api.ScreenshotPurposeMenu
-		}
-		images = append(images, api.ScreenshotImage{
-			Path:       pathValue,
-			Purpose:    purpose,
-			SizeBytes:  info.Size(),
-			Host:       upload.Host,
-			ImgURL:     upload.ImgURL,
-			RawURL:     upload.RawURL,
-			WebURL:     upload.WebURL,
-			UploadedAt: upload.UploadedAt,
-		})
-		seenPaths[pathValue] = struct{}{}
-		s.logger.Tracef("image hosting: found uploaded-only image file=%s host=%s tracker=%s", filepath.Base(pathValue), upload.Host, imageHostLogTracker(upload.Host))
-	}
-
-	sort.Slice(images, func(i, j int) bool {
-		return images[i].TimestampSeconds < images[j].TimestampSeconds
-	})
-
-	s.logger.Debugf("image hosting: returning candidate images count=%d uploaded=%d", len(images), len(uploadedByPath))
-	return images, nil
-}
-
-// Upload validates and deduplicates local image paths, uploads them to one host,
-// and persists successful links when a repository is configured. Tracker-owned
-// hosts require their matching usage scope; HDB batches keep normal and
-// disc-menu images in separate, non-overlapping galleries.
-func (s *Service) Upload(ctx context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
-	}
-	if s == nil {
-		return nil, errors.New("image hosting: service not configured")
-	}
-	normalizedHost := strings.ToLower(strings.TrimSpace(host))
-	if normalizedHost == "" {
-		return nil, internalerrors.ErrInvalidInput
-	}
-	normalizedScope := strings.TrimSpace(usageScope)
-	if normalizedScope == "" {
-		normalizedScope = "global"
-	}
-	if owner := trackers.TrackerForOwnedImageHost(normalizedHost); owner != "" {
-		expectedScope := trackers.TrackerImageUsageScope(owner)
-		if !strings.EqualFold(normalizedScope, expectedScope) {
-			return nil, fmt.Errorf("image hosting: host %q is scoped to tracker %s: expected scope %q, got %q", normalizedHost, owner, expectedScope, normalizedScope)
-		}
-	}
-	if len(images) == 0 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-	uploader := s.uploaders[normalizedHost]
-	if uploader == nil {
-		return nil, fmt.Errorf("image hosting: unsupported host %q", normalizedHost)
-	}
-	if strings.TrimSpace(meta.SourcePath) == "" {
-		return nil, internalerrors.ErrInvalidInput
-	}
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
-	}
-	logTracker := imageHostLogTracker(normalizedHost)
-
-	s.logger.Infof("image hosting: uploading images count=%d host=%s tracker=%s", len(images), normalizedHost, logTracker)
-	s.logger.Debugf("image hosting: upload source path=%s host=%s tracker=%s", meta.SourcePath, normalizedHost, logTracker)
-
-	unique := make([]imageCandidate, 0, len(images))
-	seen := make(map[string]struct{}, len(images))
-	for _, image := range images {
-		pathValue := strings.TrimSpace(image.Path)
-		if pathValue == "" {
-			return nil, internalerrors.ErrInvalidInput
-		}
-		absPath, err := filepath.Abs(pathValue)
-		if err != nil {
-			return nil, fmt.Errorf("image hosting: resolve image path: %w", err)
-		}
-		if !isAllowedImageExt(absPath) {
-			return nil, internalerrors.ErrInvalidInput
-		}
-		if _, exists := seen[absPath]; exists {
-			s.logger.Tracef("image hosting: skipping duplicate file=%s host=%s tracker=%s", filepath.Base(absPath), normalizedHost, logTracker)
-			continue
-		}
-		info, err := os.Stat(absPath)
-		if err != nil {
-			return nil, fmt.Errorf("image hosting: stat image path: %w", err)
-		}
-		if info.IsDir() {
-			return nil, internalerrors.ErrInvalidInput
-		}
-		seen[absPath] = struct{}{}
-		unique = append(unique, imageCandidate{Path: absPath, Purpose: image.Purpose, SizeBytes: info.Size()})
-		s.logger.Tracef("image hosting: queued file=%s host=%s tracker=%s size_kb=%.2f", filepath.Base(absPath), normalizedHost, logTracker, float64(info.Size())/1024.0)
-	}
-	if len(unique) == 0 {
-		return nil, internalerrors.ErrInvalidInput
-	}
-
-	s.logger.Tracef("image hosting: prepared unique images count=%d host=%s tracker=%s", len(unique), normalizedHost, logTracker)
-
-	if batch, ok := uploader.(batchUploader); ok {
-		if normalizedHost == "hdb" {
-			normalCount, menuCount := imagePurposeCounts(unique)
-			s.logger.Infof("image hosting: HDB gallery upload plan host=%s tracker=%s normal=%d menu=%d", normalizedHost, logTracker, normalCount, menuCount)
-		}
-		s.logger.Debugf("image hosting: starting batch upload host=%s tracker=%s", normalizedHost, logTracker)
-		uploadedResults, err := uploadBatch(ctx, batch, meta, normalizedHost, unique)
-		if err != nil {
-			s.logger.Errorf("image hosting: batch upload failed host=%s tracker=%s err=%s", normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-			return nil, err
-		}
-		if len(uploadedResults) != len(unique) {
-			return nil, fmt.Errorf("image hosting: batch upload count mismatch for %s", normalizedHost)
-		}
-		results := make([]api.UploadedImageLink, len(unique))
-		for idx, candidate := range unique {
-			uploaded := uploadedResults[idx]
-			fileName := filepath.Base(candidate.Path)
-			if strings.TrimSpace(uploaded.RawURL) == "" {
-				return nil, fmt.Errorf("image upload %s: missing raw url", fileName)
-			}
-			if strings.TrimSpace(uploaded.ImgURL) == "" {
-				uploaded.ImgURL = uploaded.RawURL
-			}
-			if strings.TrimSpace(uploaded.WebURL) == "" {
-				uploaded.WebURL = uploaded.RawURL
-			}
-			results[idx] = api.UploadedImageLink{
-				SourcePath: meta.SourcePath,
-				ImagePath:  candidate.Path,
-				Host:       normalizedHost,
-				UsageScope: normalizedScope,
-				ImgURL:     strings.TrimSpace(uploaded.ImgURL),
-				RawURL:     strings.TrimSpace(uploaded.RawURL),
-				WebURL:     strings.TrimSpace(uploaded.WebURL),
-				SizeBytes:  candidate.SizeBytes,
-				UploadedAt: time.Now().UTC(),
-			}
-		}
-		if s.repo != nil {
-			s.logger.Tracef("image hosting: persisting upload records count=%d host=%s tracker=%s", len(results), normalizedHost, logTracker)
-			if err := s.repo.SaveUploadedImages(ctx, meta.SourcePath, normalizedHost, results); err != nil {
-				s.logger.Errorf("image hosting: failed to save upload records host=%s tracker=%s err=%s", normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-				return nil, fmt.Errorf("image hosting: %w", err)
-			}
-			summary, err := syncScreenshotSlotVariants(ctx, s.repo, meta.SourcePath, results)
-			if err != nil {
-				s.logger.Warnf("image hosting: failed to sync screenshot slot variants host=%s tracker=%s err=%s", normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-			} else if summary.FallbackMatched > 0 {
-				s.logger.Debugf("image hosting: applied ordered screenshot slot fallback host=%s tracker=%s matched=%d", normalizedHost, logTracker, summary.FallbackMatched)
-			}
-		}
-		s.logger.Infof("image hosting: completed batch upload count=%d host=%s tracker=%s", len(results), normalizedHost, logTracker)
-		return results, nil
-	}
-
-	limit := s.cfg.ScreenshotHandling.MaxConcurrentUploads
-	if limit <= 0 {
-		limit = 1
-	}
-
-	s.logger.Infof("image hosting: starting concurrent uploads limit=%d host=%s tracker=%s", limit, normalizedHost, logTracker)
-	uploadStart := time.Now()
-
-	var (
-		wg       sync.WaitGroup
-		mu       sync.Mutex
-		results  = make([]indexedUploadResult, 0, len(unique))
-		failures = make([]string, 0)
-	)
-	sem := make(chan struct{}, limit)
-
-dispatchLoop:
-	for idx, candidate := range unique {
-		if err := ctx.Err(); err != nil {
-			break
-		}
-		select {
-		case <-ctx.Done():
-			break dispatchLoop
-		case sem <- struct{}{}:
-		}
-		if err := ctx.Err(); err != nil {
-			<-sem
-			break
-		}
-		wg.Go(func() {
-			defer func() { <-sem }()
-			if err := ctx.Err(); err != nil {
-				mu.Lock()
-				failures = append(failures, err.Error())
-				mu.Unlock()
-				return
-			}
-			fileName := filepath.Base(candidate.Path)
-			s.logger.Debugf("image hosting: uploading image file=%s host=%s tracker=%s size_kb=%.2f", fileName, normalizedHost, logTracker, float64(candidate.SizeBytes)/1024.0)
-
-			// Add detailed debug logging for imgbox
-			if normalizedHost == "imgbox" {
-				s.logger.Debugf("imgbox: starting upload for %s", fileName)
-				s.logger.Tracef("imgbox: file path: %s", candidate.Path)
-				s.logger.Tracef("imgbox: file size: %d bytes", candidate.SizeBytes)
-			}
-
-			uploadStartTime := time.Now()
-			uploaded, err := uploader.Upload(ctx, candidate.Path)
-			uploadDuration := time.Since(uploadStartTime)
-
-			if normalizedHost == "imgbox" {
-				if err != nil {
-					s.logger.Debugf("imgbox: upload failed file=%s duration=%v err=%s", fileName, uploadDuration, redaction.RedactValue(err.Error(), nil))
-				} else {
-					s.logger.Debugf("imgbox: upload succeeded file=%s duration=%v", fileName, uploadDuration)
-					s.logger.Tracef("imgbox: thumbnail URL: %s", uploaded.ImgURL)
-					s.logger.Tracef("imgbox: original URL: %s", uploaded.RawURL)
-					s.logger.Tracef("imgbox: image URL: %s", uploaded.WebURL)
-				}
-			}
-
-			if err != nil {
-				s.logger.Warnf("image hosting: upload failed file=%s host=%s tracker=%s err=%s", fileName, normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-				mu.Lock()
-				failures = append(failures, fmt.Sprintf("image upload %s: %v", fileName, err))
-				mu.Unlock()
-				return
-			}
-			if strings.TrimSpace(uploaded.RawURL) == "" {
-				s.logger.Warnf("image hosting: missing raw URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
-				mu.Lock()
-				failures = append(failures, fmt.Sprintf("image upload %s: missing raw url", fileName))
-				mu.Unlock()
-				return
-			}
-			if strings.TrimSpace(uploaded.ImgURL) == "" {
-				s.logger.Tracef("image hosting: using raw URL as img URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
-				uploaded.ImgURL = uploaded.RawURL
-			}
-			if strings.TrimSpace(uploaded.WebURL) == "" {
-				s.logger.Tracef("image hosting: using raw URL as web URL file=%s host=%s tracker=%s", fileName, normalizedHost, logTracker)
-				uploaded.WebURL = uploaded.RawURL
-			}
-			mu.Lock()
-			results = append(results, indexedUploadResult{
-				index: idx,
-				link: api.UploadedImageLink{
-					SourcePath: meta.SourcePath,
-					ImagePath:  candidate.Path,
-					Host:       normalizedHost,
-					UsageScope: normalizedScope,
-					ImgURL:     strings.TrimSpace(uploaded.ImgURL),
-					RawURL:     strings.TrimSpace(uploaded.RawURL),
-					WebURL:     strings.TrimSpace(uploaded.WebURL),
-					SizeBytes:  candidate.SizeBytes,
-					UploadedAt: time.Now().UTC(),
-				},
-			})
-			mu.Unlock()
-			s.logger.Debugf("image hosting: successfully uploaded file=%s host=%s tracker=%s duration=%v", fileName, normalizedHost, logTracker, uploadDuration)
-		})
-	}
-
-	wg.Wait()
-	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("image hosting: upload canceled: %w", err)
-	}
-
-	totalDuration := time.Since(uploadStart)
-	orderedResults := orderedUploadResults(results)
-	if len(orderedResults) > 0 {
-		s.logger.Infof("image hosting: completed uploads count=%d host=%s tracker=%s duration=%v avg=%v", len(orderedResults), normalizedHost, logTracker, totalDuration, totalDuration/time.Duration(len(orderedResults)))
-	}
-
-	if s.repo != nil && len(orderedResults) > 0 {
-		s.logger.Tracef("image hosting: persisting upload records count=%d host=%s tracker=%s", len(orderedResults), normalizedHost, logTracker)
-		if err := s.repo.SaveUploadedImages(ctx, meta.SourcePath, normalizedHost, orderedResults); err != nil {
-			s.logger.Errorf("image hosting: failed to save upload records host=%s tracker=%s err=%s", normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-			return nil, fmt.Errorf("image hosting: %w", err)
-		}
-		summary, err := syncScreenshotSlotVariants(ctx, s.repo, meta.SourcePath, orderedResults)
-		if err != nil {
-			s.logger.Warnf("image hosting: failed to sync screenshot slot variants host=%s tracker=%s err=%s", normalizedHost, logTracker, redaction.RedactValue(err.Error(), nil))
-		} else if summary.FallbackMatched > 0 {
-			s.logger.Debugf("image hosting: applied ordered screenshot slot fallback host=%s tracker=%s matched=%d", normalizedHost, logTracker, summary.FallbackMatched)
-		}
-		s.logger.Debugf("image hosting: upload records persisted successfully host=%s tracker=%s", normalizedHost, logTracker)
-	}
-
-	if len(failures) > 0 {
-		s.logger.Warnf("image hosting: upload batch completed host=%s tracker=%s failures=%d successes=%d", normalizedHost, logTracker, len(failures), len(orderedResults))
-		return orderedResults, fmt.Errorf("image hosting: %d of %d uploads failed: %s", len(failures), len(unique), strings.Join(failures, "; "))
-	}
-
-	return orderedResults, nil
-}
-
-// uploadBatch dispatches candidates through the uploader's supported batch
-// contract. Named HDB batches retain image purpose so gallery partitioning can
-// preserve input-to-result ordering.
-func uploadBatch(ctx context.Context, batch batchUploader, meta api.PreparedMetadata, host string, images []imageCandidate) ([]uploadResult, error) {
-	imagePaths := make([]string, 0, len(images))
-	for _, image := range images {
-		imagePaths = append(imagePaths, image.Path)
-	}
-	if named, ok := batch.(namedBatchUploader); ok {
-		if strings.EqualFold(strings.TrimSpace(host), "hdb") {
-			return uploadHDBBatchByPurpose(ctx, named, meta, images)
-		}
-		results, err := named.UploadBatchWithName(ctx, imagePaths, resolveGalleryName(meta))
-		if err != nil {
-			return nil, fmt.Errorf("image hosting: upload named batch: %w", err)
-		}
-		return results, nil
-	}
-	results, err := batch.UploadBatch(ctx, imagePaths)
-	if err != nil {
-		return nil, fmt.Errorf("image hosting: upload batch: %w", err)
-	}
-	return results, nil
-}
-
-// uploadHDBBatchByPurpose uploads normal images to the release gallery and menu
-// images to a suffixed disc-menu gallery. Each candidate is uploaded once, and
-// results are restored to candidate order across both batches.
-func uploadHDBBatchByPurpose(ctx context.Context, batch namedBatchUploader, meta api.PreparedMetadata, images []imageCandidate) ([]uploadResult, error) {
-	type indexedImage struct {
-		index int
-		path  string
-	}
-	normal := make([]indexedImage, 0, len(images))
-	menus := make([]indexedImage, 0, len(images))
-	for idx, image := range images {
-		item := indexedImage{index: idx, path: image.Path}
-		if image.Purpose == api.ScreenshotPurposeMenu {
-			menus = append(menus, item)
-			continue
-		}
-		normal = append(normal, item)
-	}
-
-	results := make([]uploadResult, len(images))
-	uploadGroup := func(group []indexedImage, galleryName string) error {
-		if len(group) == 0 {
-			return nil
-		}
-		paths := make([]string, 0, len(group))
-		for _, image := range group {
-			paths = append(paths, image.path)
-		}
-		uploaded, err := batch.UploadBatchWithName(ctx, paths, galleryName)
-		if err != nil {
-			return fmt.Errorf("image hosting: upload named batch: %w", err)
-		}
-		if len(uploaded) != len(group) {
-			return fmt.Errorf("image hosting: HDB batch returned %d images for %d uploads", len(uploaded), len(group))
-		}
-		for idx, image := range group {
-			results[image.index] = uploaded[idx]
-		}
-		return nil
-	}
-
-	galleryName := resolveGalleryName(meta)
-	if err := uploadGroup(normal, galleryName); err != nil {
-		return nil, err
-	}
-	if err := uploadGroup(menus, galleryName+" Disc Menus"); err != nil {
-		return nil, err
-	}
-	return results, nil
-}
-
-func resolveGalleryName(meta api.PreparedMetadata) string {
-	for _, candidate := range []string{
-		strings.TrimSpace(meta.ReleaseName),
-		strings.TrimSpace(meta.ReleaseNameNoTag),
-		strings.TrimSpace(meta.Release.Title),
-		strings.TrimSpace(meta.Filename),
-		pathutil.Base(meta.SourcePath),
-	} {
-		if candidate != "" {
-			return candidate
-		}
-	}
-	return "upbrr"
-}
-
-// imageHostLogTracker returns the tracker that owns a private image host, or
-// "shared" for hosts usable outside one tracker. Logging both host and tracker
-// keeps tracker-owned rehosting identifiable in operator output.
-func imageHostLogTracker(host string) string {
-	if tracker := trackers.TrackerForOwnedImageHost(host); tracker != "" {
-		return tracker
-	}
-	return "shared"
-}
-
-// imagePurposeCounts summarizes the HDB gallery partition without exposing
-// local image paths in operator-visible progress logs.
-func imagePurposeCounts(images []imageCandidate) (normal int, menus int) {
-	for _, image := range images {
-		if image.Purpose == api.ScreenshotPurposeMenu {
-			menus++
-			continue
-		}
-		normal++
-	}
-	return normal, menus
-}
-
-type imageCandidate struct {
-	Path      string
-	Purpose   api.ScreenshotPurpose
-	SizeBytes int64
-}
-
-type indexedUploadResult struct {
-	index int
-	link  api.UploadedImageLink
-}
-
-func orderedUploadResults(results []indexedUploadResult) []api.UploadedImageLink {
-	if len(results) == 0 {
-		return nil
-	}
-	sort.Slice(results, func(i, j int) bool { return results[i].index < results[j].index })
-	ordered := make([]api.UploadedImageLink, 0, len(results))
-	for _, result := range results {
-		ordered = append(ordered, result.link)
-	}
-	return ordered
-}
-
-func isAllowedImageExt(path string) bool {
-	switch strings.ToLower(filepath.Ext(path)) {
-	case ".png", ".jpg", ".jpeg", ".webp":
-		return true
-	default:
-		return false
-	}
-}
-
-func syncScreenshotSlotVariants(ctx context.Context, repo api.MetadataRepository, sourcePath string, uploaded []api.UploadedImageLink) (trackers.SlotUploadAttachmentResult, error) {
-	if repo == nil || len(uploaded) == 0 || strings.TrimSpace(sourcePath) == "" {
-		return trackers.SlotUploadAttachmentResult{}, nil
-	}
-	slots, err := repo.ListScreenshotSlotsByPath(ctx, sourcePath)
-	if err != nil {
-		return trackers.SlotUploadAttachmentResult{}, fmt.Errorf("image hosting: %w", err)
-	}
-	if len(slots) == 0 {
-		return trackers.SlotUploadAttachmentResult{}, nil
-	}
-	summary := trackers.ApplyUploadedVariantsToSlots(slots, uploaded)
-	if summary.FallbackMatched > 0 {
-		if err := repo.ReplaceScreenshotSlots(ctx, sourcePath, slots); err != nil {
-			return summary, fmt.Errorf("image hosting: %w", err)
-		}
-	}
-	slotByPath := make(map[string]int, len(slots))
-	for _, slot := range slots {
-		if pathValue := strings.TrimSpace(slot.ImagePath); pathValue != "" {
-			slotByPath[pathValue] = slot.SlotOrder
-		}
-	}
-	variants := make([]api.ScreenshotSlotVariant, 0, len(uploaded))
-	for _, image := range uploaded {
-		slotOrder, ok := slotByPath[strings.TrimSpace(image.ImagePath)]
-		if !ok {
-			continue
-		}
-		variants = append(variants, api.ScreenshotSlotVariant{
-			SourcePath: sourcePath,
-			SlotOrder:  slotOrder,
-			Host:       strings.TrimSpace(image.Host),
-			UsageScope: strings.TrimSpace(image.UsageScope),
-			ImagePath:  strings.TrimSpace(image.ImagePath),
-			ImgURL:     strings.TrimSpace(image.ImgURL),
-			RawURL:     strings.TrimSpace(image.RawURL),
-			WebURL:     strings.TrimSpace(image.WebURL),
-			UploadedAt: image.UploadedAt,
-		})
-	}
-	if err := repo.UpsertScreenshotSlotVariants(ctx, sourcePath, variants); err != nil {
-		return summary, fmt.Errorf("image hosting: upsert screenshot slot variants: %w", err)
-	}
-	return summary, nil
-}
diff --git a/internal/services/imagehosting/service_test.go b/internal/services/imagehosting/service_test.go
deleted file mode 100644
index 5cf1a003..00000000
--- a/internal/services/imagehosting/service_test.go
+++ /dev/null
@@ -1,676 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package imagehosting
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type recordingRepo struct {
-	savedHost   string
-	savedPath   string
-	savedImages []api.UploadedImageLink
-	screens     []api.Screenshot
-	selections  []api.ScreenshotFinalSelection
-	uploads     []api.UploadedImageLink
-}
-
-func (r *recordingRepo) SaveUploadedImages(_ context.Context, path string, host string, images []api.UploadedImageLink) error {
-	r.savedHost = host
-	r.savedPath = path
-	r.savedImages = images
-	return nil
-}
-
-func (r *recordingRepo) GetByPath(context.Context, string) (api.FileMetadata, error) {
-	return api.FileMetadata{}, nil
-}
-func (r *recordingRepo) Save(context.Context, api.FileMetadata) error { return nil }
-func (r *recordingRepo) GetExternalIDs(context.Context, string) (api.ExternalIDs, error) {
-	return api.ExternalIDs{}, nil
-}
-func (r *recordingRepo) SaveExternalIDs(context.Context, api.ExternalIDs) error { return nil }
-func (r *recordingRepo) GetExternalMetadata(context.Context, string) (api.ExternalMetadata, error) {
-	return api.ExternalMetadata{}, nil
-}
-func (r *recordingRepo) SaveExternalMetadata(context.Context, api.ExternalMetadata) error { return nil }
-func (r *recordingRepo) GetDVDMediaInfo(context.Context, string) (api.DVDMediaInfo, error) {
-	return api.DVDMediaInfo{}, nil
-}
-func (r *recordingRepo) SaveDVDMediaInfo(context.Context, api.DVDMediaInfo) error { return nil }
-func (r *recordingRepo) GetReleaseNameOverrides(context.Context, string) (api.ReleaseNameOverrides, error) {
-	return api.ReleaseNameOverrides{}, nil
-}
-func (r *recordingRepo) SaveReleaseNameOverrides(context.Context, string, api.ReleaseNameOverrides) error {
-	return nil
-}
-func (r *recordingRepo) DeleteReleaseNameOverrides(context.Context, string) error { return nil }
-func (r *recordingRepo) ListHistoryEntries(context.Context) ([]api.HistoryEntry, error) {
-	return nil, nil
-}
-func (r *recordingRepo) ListUploadHistoryByPath(context.Context, string) ([]api.UploadRecord, error) {
-	return nil, nil
-}
-func (r *recordingRepo) ListPendingUploads(context.Context) ([]api.UploadRecord, error) {
-	return nil, nil
-}
-func (r *recordingRepo) CreateUploadRecord(context.Context, api.UploadRecord) error { return nil }
-func (r *recordingRepo) UpdateLatestUploadRecordStatus(context.Context, string, string, string) error {
-	return nil
-}
-func (r *recordingRepo) SaveTrackerRuleFailures(context.Context, string, string, []api.TrackerRuleFailure) error {
-	return nil
-}
-func (r *recordingRepo) ListTrackerRuleFailuresByPath(context.Context, string) ([]api.TrackerRuleFailure, error) {
-	return nil, nil
-}
-func (r *recordingRepo) GetTrackerTimestamp(context.Context, string) (time.Time, error) {
-	return time.Time{}, nil
-}
-func (r *recordingRepo) SaveTrackerTimestamp(context.Context, api.TrackerTimestamp) error { return nil }
-func (r *recordingRepo) SaveTrackerMetadata(context.Context, api.TrackerMetadata) error   { return nil }
-func (r *recordingRepo) ListTrackerMetadataByPath(context.Context, string) ([]api.TrackerMetadata, error) {
-	return nil, nil
-}
-func (r *recordingRepo) SaveScreenshot(context.Context, api.Screenshot) error { return nil }
-func (r *recordingRepo) ListScreenshotsByPath(context.Context, string) ([]api.Screenshot, error) {
-	return append([]api.Screenshot(nil), r.screens...), nil
-}
-func (r *recordingRepo) DeleteScreenshot(context.Context, string) error { return nil }
-func (r *recordingRepo) SaveFinalSelections(context.Context, string, []api.ScreenshotFinalSelection) error {
-	return nil
-}
-func (r *recordingRepo) ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error) {
-	return append([]api.ScreenshotFinalSelection(nil), r.selections...), nil
-}
-func (r *recordingRepo) DeleteFinalSelection(context.Context, string) error { return nil }
-func (r *recordingRepo) ReplaceScreenshotSlots(context.Context, string, []api.ScreenshotSlot) error {
-	return nil
-}
-func (r *recordingRepo) ListScreenshotSlotsByPath(context.Context, string) ([]api.ScreenshotSlot, error) {
-	return nil, nil
-}
-func (r *recordingRepo) UpsertScreenshotSlotVariants(context.Context, string, []api.ScreenshotSlotVariant) error {
-	return nil
-}
-func (r *recordingRepo) ListUploadedImagesByPath(context.Context, string) ([]api.UploadedImageLink, error) {
-	return append([]api.UploadedImageLink(nil), r.uploads...), nil
-}
-func (r *recordingRepo) DeleteUploadedImage(context.Context, string, string, string) error {
-	return nil
-}
-func (r *recordingRepo) GetDescriptionOverride(context.Context, string, string) (api.DescriptionOverride, error) {
-	return api.DescriptionOverride{}, nil
-}
-func (r *recordingRepo) ListDescriptionOverridesByPath(context.Context, string) ([]api.DescriptionOverride, error) {
-	return nil, nil
-}
-func (r *recordingRepo) SaveDescriptionOverride(context.Context, api.DescriptionOverride) error {
-	return nil
-}
-func (r *recordingRepo) DeleteDescriptionOverride(context.Context, string, string) error { return nil }
-func (r *recordingRepo) GetPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
-	return api.PlaylistSelection{}, nil
-}
-func (r *recordingRepo) SavePlaylistSelection(context.Context, string, []string, bool) error {
-	return nil
-}
-func (r *recordingRepo) DeletePlaylistSelection(context.Context, string) error { return nil }
-func (r *recordingRepo) ListStoredReleasePaths(context.Context) ([]string, error) {
-	return nil, nil
-}
-func (r *recordingRepo) PurgeContentData(context.Context, string) error { return nil }
-
-type fakeUploader struct {
-	result uploadResult
-	err    error
-	mu     sync.Mutex
-	calls  []string
-}
-
-func (u *fakeUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
-	u.mu.Lock()
-	u.calls = append(u.calls, imagePath)
-	u.mu.Unlock()
-	return u.result, u.err
-}
-
-type selectiveUploader struct {
-	mu      sync.Mutex
-	results map[string]uploadResult
-	errs    map[string]error
-	calls   []string
-}
-
-func (u *selectiveUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
-	u.mu.Lock()
-	u.calls = append(u.calls, imagePath)
-	err := u.errs[imagePath]
-	result := u.results[imagePath]
-	u.mu.Unlock()
-	if err != nil {
-		return uploadResult{}, err
-	}
-	return result, nil
-}
-
-type blockingUploader struct {
-	mu          sync.Mutex
-	calls       []string
-	firstCallCh chan struct{}
-}
-
-func (u *blockingUploader) Upload(ctx context.Context, imagePath string) (uploadResult, error) {
-	u.mu.Lock()
-	u.calls = append(u.calls, imagePath)
-	if len(u.calls) == 1 && u.firstCallCh != nil {
-		close(u.firstCallCh)
-		u.firstCallCh = nil
-	}
-	u.mu.Unlock()
-
-	<-ctx.Done()
-	return uploadResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-}
-
-type fakeBatchUploader struct {
-	err          error
-	mu           sync.Mutex
-	calls        []string
-	batches      [][]string
-	galleryNames []string
-}
-
-type recordingImageHostLogger struct {
-	mu       sync.Mutex
-	messages []string
-}
-
-func (l *recordingImageHostLogger) record(format string, args ...any) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	l.messages = append(l.messages, fmt.Sprintf(format, args...))
-}
-
-func (l *recordingImageHostLogger) Tracef(format string, args ...any) {
-	l.record(format, args...)
-}
-
-func (l *recordingImageHostLogger) Debugf(format string, args ...any) {
-	l.record(format, args...)
-}
-
-func (l *recordingImageHostLogger) Infof(format string, args ...any) {
-	l.record(format, args...)
-}
-
-func (l *recordingImageHostLogger) Warnf(format string, args ...any) {
-	l.record(format, args...)
-}
-
-func (l *recordingImageHostLogger) Errorf(format string, args ...any) {
-	l.record(format, args...)
-}
-
-func (l *recordingImageHostLogger) contains(value string) bool {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	for _, message := range l.messages {
-		if strings.Contains(message, value) {
-			return true
-		}
-	}
-	return false
-}
-
-func (u *fakeBatchUploader) Upload(_ context.Context, imagePath string) (uploadResult, error) {
-	u.mu.Lock()
-	u.calls = append(u.calls, imagePath)
-	u.mu.Unlock()
-	if u.err != nil {
-		return uploadResult{}, u.err
-	}
-	return uploadResult{}, nil
-}
-
-func (u *fakeBatchUploader) UploadBatch(_ context.Context, imagePaths []string) ([]uploadResult, error) {
-	u.mu.Lock()
-	u.batches = append(u.batches, append([]string{}, imagePaths...))
-	u.mu.Unlock()
-	return u.resultsFor(imagePaths)
-}
-
-func (u *fakeBatchUploader) UploadBatchWithName(_ context.Context, imagePaths []string, galleryName string) ([]uploadResult, error) {
-	u.mu.Lock()
-	u.batches = append(u.batches, append([]string{}, imagePaths...))
-	u.galleryNames = append(u.galleryNames, galleryName)
-	u.mu.Unlock()
-	return u.resultsFor(imagePaths)
-}
-
-func (u *fakeBatchUploader) resultsFor(imagePaths []string) ([]uploadResult, error) {
-	if u.err != nil {
-		return nil, u.err
-	}
-	results := make([]uploadResult, 0, len(imagePaths))
-	for idx := range imagePaths {
-		suffix := strconv.Itoa(idx)
-		results = append(results, uploadResult{
-			ImgURL: "https://thumb/" + suffix,
-			RawURL: "https://raw/" + suffix,
-			WebURL: "https://web/" + suffix,
-		})
-	}
-	return results, nil
-}
-
-func TestUploadImagesSuccess(t *testing.T) {
-	tmpDir := t.TempDir()
-	imagePath := filepath.Join(tmpDir, "shot-01.png")
-	if err := os.WriteFile(imagePath, []byte("testdata"), 0o644); err != nil {
-		t.Fatalf("write temp file: %v", err)
-	}
-	absPath, err := filepath.Abs(imagePath)
-	if err != nil {
-		t.Fatalf("abs path: %v", err)
-	}
-
-	uploaderStub := &fakeUploader{result: uploadResult{ImgURL: "https://img", RawURL: "https://raw", WebURL: "https://web"}}
-	repo := &recordingRepo{}
-	service := &Service{
-		cfg:       config.Config{ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 2}},
-		logger:    api.NopLogger{},
-		repo:      repo,
-		uploaders: map[string]uploader{"test": uploaderStub},
-	}
-
-	meta := api.PreparedMetadata{SourcePath: "source"}
-	images := []api.ScreenshotImage{{Path: imagePath}}
-	result, err := service.Upload(context.Background(), meta, "test", "tracker:HDB", images)
-	if err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	if len(result) != 1 {
-		t.Fatalf("expected 1 result, got %d", len(result))
-	}
-	if result[0].ImagePath != absPath {
-		t.Fatalf("expected image path %q, got %q", absPath, result[0].ImagePath)
-	}
-	if result[0].Host != "test" {
-		t.Fatalf("expected host test, got %q", result[0].Host)
-	}
-	if result[0].UsageScope != "tracker:HDB" {
-		t.Fatalf("expected usage scope tracker:HDB, got %q", result[0].UsageScope)
-	}
-	if repo.savedHost != "test" || repo.savedPath != "source" {
-		t.Fatalf("expected repo save for test/source, got %q/%q", repo.savedHost, repo.savedPath)
-	}
-	if len(repo.savedImages) != 1 {
-		t.Fatalf("expected repo to save 1 image, got %d", len(repo.savedImages))
-	}
-	if repo.savedImages[0].UsageScope != "tracker:HDB" {
-		t.Fatalf("expected repo usage scope tracker:HDB, got %q", repo.savedImages[0].UsageScope)
-	}
-}
-
-func TestListCandidatesIncludesUploadedOnlyImages(t *testing.T) {
-	imagePath := filepath.Join(t.TempDir(), "tracker-artifact.png")
-	if err := os.WriteFile(imagePath, []byte("testdata"), 0o600); err != nil {
-		t.Fatalf("write image: %v", err)
-	}
-	uploadedAt := time.Now().UTC()
-	repo := &recordingRepo{
-		uploads: []api.UploadedImageLink{{
-			SourcePath: "/tmp/source",
-			ImagePath:  imagePath,
-			Host:       "pixhost",
-			UsageScope: "global",
-			ImgURL:     "https://pixhost/img.png",
-			RawURL:     "https://pixhost/raw.png",
-			WebURL:     "https://pixhost/view",
-			UploadedAt: uploadedAt,
-			SizeBytes:  8,
-		}},
-	}
-	service := &Service{logger: api.NopLogger{}, repo: repo}
-
-	images, err := service.ListCandidates(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"})
-	if err != nil {
-		t.Fatalf("ListCandidates returned error: %v", err)
-	}
-	if len(images) != 1 {
-		t.Fatalf("expected uploaded-only image candidate, got %d", len(images))
-	}
-	if images[0].Path != imagePath || images[0].Host != "pixhost" || images[0].RawURL != "https://pixhost/raw.png" {
-		t.Fatalf("expected uploaded-only candidate details, got %#v", images[0])
-	}
-	if !images[0].UploadedAt.Equal(uploadedAt) {
-		t.Fatalf("expected uploaded timestamp, got %v", images[0].UploadedAt)
-	}
-}
-
-func TestListCandidatesPopulatesGeneratedAndManualMenuPurpose(t *testing.T) {
-	t.Parallel()
-
-	root := t.TempDir()
-	generatedPath := filepath.Join(root, "generated-menu.png")
-	manualPath := filepath.Join(root, "manual-menu.png")
-	for _, imagePath := range []string{generatedPath, manualPath} {
-		if err := os.WriteFile(imagePath, []byte("synthetic image"), 0o600); err != nil {
-			t.Fatalf("write image: %v", err)
-		}
-	}
-	repo := &recordingRepo{
-		screens: []api.Screenshot{{
-			SourcePath: "/tmp/source",
-			ImagePath:  generatedPath,
-			Purpose:    api.ScreenshotPurposeMenu,
-		}},
-		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: generatedPath, Order: 0, Source: api.ScreenshotSelectionSourceDVDMenu},
-			{SourcePath: "/tmp/source", ImagePath: manualPath, Order: 1, Source: api.ScreenshotSelectionSourceMenu},
-		},
-	}
-	service := &Service{logger: api.NopLogger{}, repo: repo}
-
-	images, err := service.ListCandidates(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"})
-	if err != nil {
-		t.Fatalf("list candidates: %v", err)
-	}
-	if len(images) != 2 {
-		t.Fatalf("candidate count = %d, want 2", len(images))
-	}
-	for _, imageValue := range images {
-		if imageValue.Purpose != api.ScreenshotPurposeMenu {
-			t.Fatalf("candidate purpose = %q for %q", imageValue.Purpose, filepath.Base(imageValue.Path))
-		}
-	}
-}
-
-func TestUploadImagesUnsupportedHost(t *testing.T) {
-	service := &Service{logger: api.NopLogger{}, uploaders: map[string]uploader{}}
-	meta := api.PreparedMetadata{SourcePath: "source"}
-	_, err := service.Upload(context.Background(), meta, "missing", "global", []api.ScreenshotImage{{Path: "x.png"}})
-	if err == nil {
-		t.Fatal("expected error for unsupported host")
-	}
-}
-
-func TestUploadImagesRejectsTrackerOwnedHostOutsideOwnerScope(t *testing.T) {
-	service := &Service{
-		logger:    api.NopLogger{},
-		uploaders: map[string]uploader{"hdb": &fakeUploader{}},
-	}
-	tmp, err := os.CreateTemp(t.TempDir(), "imagehosting-owned-host-*.png")
-	if err != nil {
-		t.Fatalf("create temp file: %v", err)
-	}
-	tmpPath := tmp.Name()
-	if err := tmp.Close(); err != nil {
-		t.Fatalf("close temp file: %v", err)
-	}
-	meta := api.PreparedMetadata{SourcePath: "source"}
-	_, err = service.Upload(context.Background(), meta, "hdb", "global", []api.ScreenshotImage{{Path: tmpPath}})
-	if err == nil {
-		t.Fatal("expected tracker-owned host outside owner scope to fail")
-	}
-	if !strings.Contains(err.Error(), "scoped to tracker HDB") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestUploadImagesMissingFile(t *testing.T) {
-	uploaderStub := &fakeUploader{result: uploadResult{ImgURL: "https://img", RawURL: "https://raw", WebURL: "https://web"}}
-	service := &Service{logger: api.NopLogger{}, uploaders: map[string]uploader{"test": uploaderStub}}
-	meta := api.PreparedMetadata{SourcePath: "source"}
-	_, err := service.Upload(context.Background(), meta, "test", "global", []api.ScreenshotImage{{Path: "missing.png"}})
-	if err == nil {
-		t.Fatal("expected error for missing file")
-	}
-	if len(uploaderStub.calls) != 0 {
-		t.Fatalf("expected uploader not called, got %d", len(uploaderStub.calls))
-	}
-}
-
-func TestImgboxUploaderInRegistry(t *testing.T) {
-	cfg := config.Config{}
-	registry := newUploaderRegistry(cfg, nil)
-	if _, ok := registry["imgbox"]; !ok {
-		t.Fatal("imgbox not found in uploader registry")
-	}
-}
-
-func TestUploadImagesUsesBatchUploader(t *testing.T) {
-	tmpDir := t.TempDir()
-	firstPath := filepath.Join(tmpDir, "shot-01.png")
-	secondPath := filepath.Join(tmpDir, "shot-02.png")
-	for _, path := range []string{firstPath, secondPath} {
-		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
-			t.Fatalf("write temp file: %v", err)
-		}
-	}
-
-	uploaderStub := &fakeBatchUploader{}
-	service := &Service{
-		cfg:       config.Config{},
-		logger:    api.NopLogger{},
-		repo:      &recordingRepo{},
-		uploaders: map[string]uploader{"hdb": uploaderStub},
-	}
-
-	_, err := service.Upload(context.Background(), api.PreparedMetadata{
-		SourcePath:  "source",
-		ReleaseName: "Movie.2026.2160p.WEB-DL",
-	}, "hdb", "tracker:HDB", []api.ScreenshotImage{
-		{Path: firstPath},
-		{Path: secondPath},
-	})
-	if err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	if len(uploaderStub.batches) != 1 {
-		t.Fatalf("expected 1 batch call, got %d", len(uploaderStub.batches))
-	}
-	if len(uploaderStub.batches[0]) != 2 {
-		t.Fatalf("expected 2 files in batch, got %d", len(uploaderStub.batches[0]))
-	}
-	if len(uploaderStub.calls) != 0 {
-		t.Fatalf("expected single-image Upload not to be used, got %d calls", len(uploaderStub.calls))
-	}
-	if len(uploaderStub.galleryNames) != 1 {
-		t.Fatalf("expected 1 gallery name call, got %d", len(uploaderStub.galleryNames))
-	}
-	if uploaderStub.galleryNames[0] != "Movie.2026.2160p.WEB-DL" {
-		t.Fatalf("expected content gallery name, got %q", uploaderStub.galleryNames[0])
-	}
-}
-
-func TestUploadImagesSeparatesHDBMenuGalleryWithoutDuplicates(t *testing.T) {
-	t.Parallel()
-
-	tmpDir := t.TempDir()
-	firstPath := filepath.Join(tmpDir, "screen-01.png")
-	menuPath := filepath.Join(tmpDir, "menu-01.png")
-	secondPath := filepath.Join(tmpDir, "screen-02.png")
-	for _, imagePath := range []string{firstPath, menuPath, secondPath} {
-		if err := os.WriteFile(imagePath, []byte("testdata"), 0o600); err != nil {
-			t.Fatalf("write temp file: %v", err)
-		}
-	}
-
-	uploaderStub := &fakeBatchUploader{}
-	logger := &recordingImageHostLogger{}
-	service := &Service{
-		cfg:       config.Config{},
-		logger:    logger,
-		repo:      &recordingRepo{},
-		uploaders: map[string]uploader{"hdb": uploaderStub},
-	}
-
-	result, err := service.Upload(context.Background(), api.PreparedMetadata{
-		SourcePath:  filepath.Join(tmpDir, "Example.Release.2026.2160p.WEB-DL-GRP.mkv"),
-		ReleaseName: "Example.Release.2026.2160p.WEB-DL-GRP",
-	}, "hdb", "tracker:HDB", []api.ScreenshotImage{
-		{Path: firstPath, Purpose: api.ScreenshotPurposeFinal},
-		{Path: menuPath, Purpose: api.ScreenshotPurposeMenu},
-		{Path: secondPath, Purpose: api.ScreenshotPurposeFinal},
-	})
-	if err != nil {
-		t.Fatalf("upload images: %v", err)
-	}
-	if len(uploaderStub.batches) != 2 {
-		t.Fatalf("expected normal and menu HDB batches, got %#v", uploaderStub.batches)
-	}
-	if !slices.Equal(uploaderStub.batches[0], []string{firstPath, secondPath}) {
-		t.Fatalf("expected normal gallery to exclude menu image, got %#v", uploaderStub.batches[0])
-	}
-	if !slices.Equal(uploaderStub.batches[1], []string{menuPath}) {
-		t.Fatalf("expected menu gallery to contain only menu image, got %#v", uploaderStub.batches[1])
-	}
-	if !slices.Equal(uploaderStub.galleryNames, []string{
-		"Example.Release.2026.2160p.WEB-DL-GRP",
-		"Example.Release.2026.2160p.WEB-DL-GRP Disc Menus",
-	}) {
-		t.Fatalf("unexpected HDB gallery names: %#v", uploaderStub.galleryNames)
-	}
-	if len(result) != 3 || result[0].ImagePath != firstPath || result[1].ImagePath != menuPath || result[2].ImagePath != secondPath {
-		t.Fatalf("expected upload results in input order, got %#v", result)
-	}
-	if !logger.contains("host=hdb tracker=HDB") {
-		t.Fatal("expected HDB tracker identity in image-host logs")
-	}
-}
-
-func TestImageHostLogTrackerNamesEveryOwnedHost(t *testing.T) {
-	t.Parallel()
-
-	for host, expected := range map[string]string{
-		"hdb":      "HDB",
-		"lostimg":  "LST",
-		"reelflix": "RF",
-		"thr":      "THR",
-	} {
-		if got := imageHostLogTracker(host); got != expected {
-			t.Errorf("host %q tracker = %q, want %q", host, got, expected)
-		}
-	}
-	if got := imageHostLogTracker("imgbox"); got != "shared" {
-		t.Errorf("shared host tracker = %q, want shared", got)
-	}
-}
-
-func TestUploadImagesPersistsSuccessfulConcurrentUploadsOnPartialFailure(t *testing.T) {
-	tmpDir := t.TempDir()
-	firstPath := filepath.Join(tmpDir, "shot-01.png")
-	secondPath := filepath.Join(tmpDir, "shot-02.png")
-	for _, path := range []string{firstPath, secondPath} {
-		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
-			t.Fatalf("write temp file: %v", err)
-		}
-	}
-
-	uploaderStub := &selectiveUploader{
-		results: map[string]uploadResult{
-			firstPath: {ImgURL: "https://img/1", RawURL: "https://raw/1", WebURL: "https://web/1"},
-		},
-		errs: map[string]error{
-			secondPath: errors.New("temporary network failure"),
-		},
-	}
-	repo := &recordingRepo{}
-	service := &Service{
-		cfg: config.Config{
-			ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 2},
-		},
-		logger:    api.NopLogger{},
-		repo:      repo,
-		uploaders: map[string]uploader{"test": uploaderStub},
-	}
-
-	result, err := service.Upload(context.Background(), api.PreparedMetadata{SourcePath: "source"}, "test", "global", []api.ScreenshotImage{
-		{Path: firstPath},
-		{Path: secondPath},
-	})
-	if err == nil {
-		t.Fatal("expected partial failure error")
-	}
-	if len(result) != 1 {
-		t.Fatalf("expected 1 successful upload result, got %d", len(result))
-	}
-	if len(repo.savedImages) != 1 {
-		t.Fatalf("expected repo to persist 1 successful upload, got %d", len(repo.savedImages))
-	}
-	if repo.savedImages[0].ImagePath == secondPath {
-		t.Fatalf("expected failed upload not to be persisted: %#v", repo.savedImages)
-	}
-}
-
-func TestUploadImagesStopsDispatchingWhenContextCanceled(t *testing.T) {
-	tmpDir := t.TempDir()
-	firstPath := filepath.Join(tmpDir, "shot-01.png")
-	secondPath := filepath.Join(tmpDir, "shot-02.png")
-	for _, path := range []string{firstPath, secondPath} {
-		if err := os.WriteFile(path, []byte("testdata"), 0o644); err != nil {
-			t.Fatalf("write temp file: %v", err)
-		}
-	}
-
-	uploaderStub := &blockingUploader{firstCallCh: make(chan struct{})}
-	service := &Service{
-		cfg: config.Config{
-			ScreenshotHandling: config.ScreenshotHandlingConfig{MaxConcurrentUploads: 1},
-		},
-		logger:    api.NopLogger{},
-		uploaders: map[string]uploader{"test": uploaderStub},
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	firstCallCh := uploaderStub.firstCallCh
-	done := make(chan error, 1)
-	go func() {
-		_, err := service.Upload(ctx, api.PreparedMetadata{SourcePath: "source"}, "test", "global", []api.ScreenshotImage{
-			{Path: firstPath},
-			{Path: secondPath},
-		})
-		done <- err
-	}()
-
-	select {
-	case <-firstCallCh:
-	case <-time.After(2 * time.Second):
-		t.Fatal("timed out waiting for first upload to start")
-	}
-
-	cancel()
-
-	select {
-	case err := <-done:
-		if !errors.Is(err, context.Canceled) {
-			t.Fatalf("expected context cancellation, got %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("timed out waiting for upload to stop")
-	}
-
-	uploaderStub.mu.Lock()
-	defer uploaderStub.mu.Unlock()
-	if len(uploaderStub.calls) != 1 {
-		t.Fatalf("expected only first upload to start, got %d calls", len(uploaderStub.calls))
-	}
-}
diff --git a/internal/services/screenshots/ffmpeg.go b/internal/services/screenshots/ffmpeg.go
index f1aba1c7..24646d74 100644
--- a/internal/services/screenshots/ffmpeg.go
+++ b/internal/services/screenshots/ffmpeg.go
@@ -22,10 +22,14 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Runner executes FFmpeg-compatible commands for capture services. Run must
+// honor ctx and use dir as the working directory when it is non-empty.
 type Runner interface {
 	Run(ctx context.Context, name string, args []string, dir string) (CommandResult, error)
 }
 
+// CommandResult preserves command output and the observed process exit code
+// for fallback decisions and bounded diagnostics.
 type CommandResult struct {
 	Stdout   []byte
 	Stderr   []byte
@@ -44,7 +48,11 @@ func (commandRunner) Run(ctx context.Context, name string, args []string, dir st
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	err := cmd.Run()
-	result := CommandResult{Stdout: stdout.Bytes(), Stderr: stderr.Bytes(), ExitCode: 0}
+	result := CommandResult{
+		Stdout:   stdout.Bytes(),
+		Stderr:   stderr.Bytes(),
+		ExitCode: 0,
+	}
 	if err != nil {
 		exitCode := 1
 		var exitErr *exec.ExitError
@@ -178,7 +186,14 @@ func captureFrame(ctx context.Context, runner Runner, cmdPath string, req captur
 
 	useLibplacebo := req.UseLibplacebo && req.ToneMap && !req.FrameOverlay
 	args := buildFFmpegArgs(req, useLibplacebo)
-	logger.Tracef("screenshots: ffmpeg capture attempt mode=%s timestamp_seconds=%.3f input=%s output=%s filters=%s", ffmpegModeLabel(useLibplacebo), req.Timestamp, req.InputPath, req.OutputPath, ffmpegFilterFromArgs(args))
+	logger.Tracef(
+		"screenshots: ffmpeg capture attempt mode=%s timestamp_seconds=%.3f input=%s output=%s filters=%s",
+		ffmpegModeLabel(useLibplacebo),
+		req.Timestamp,
+		req.InputPath,
+		req.OutputPath,
+		ffmpegFilterFromArgs(args),
+	)
 	result, err := runner.Run(ctx, cmdPath, args, "")
 	if err == nil && result.ExitCode == 0 {
 		if err = validateCaptureOutput(req.OutputPath); err == nil {
@@ -190,7 +205,15 @@ func captureFrame(ctx context.Context, runner Runner, cmdPath string, req captur
 	if useLibplacebo {
 		logger.Debugf("screenshots: ffmpeg capture retry mode=%s reason=%s", ffmpegModeLabel(true), ffmpegResultPreview(result, err))
 		args = buildFFmpegArgs(req, true)
-		logger.Tracef("screenshots: ffmpeg capture attempt mode=%s retry=%t timestamp_seconds=%.3f input=%s output=%s filters=%s", ffmpegModeLabel(true), true, req.Timestamp, req.InputPath, req.OutputPath, ffmpegFilterFromArgs(args))
+		logger.Tracef(
+			"screenshots: ffmpeg capture attempt mode=%s retry=%t timestamp_seconds=%.3f input=%s output=%s filters=%s",
+			ffmpegModeLabel(true),
+			true,
+			req.Timestamp,
+			req.InputPath,
+			req.OutputPath,
+			ffmpegFilterFromArgs(args),
+		)
 		result, err = runner.Run(ctx, cmdPath, args, "")
 		if err == nil && result.ExitCode == 0 {
 			if err = validateCaptureOutput(req.OutputPath); err == nil {
@@ -199,9 +222,21 @@ func captureFrame(ctx context.Context, runner Runner, cmdPath string, req captur
 			}
 		}
 
-		logger.Debugf("screenshots: ffmpeg capture fallback from_mode=%s to_mode=%s reason=%s", ffmpegModeLabel(true), ffmpegModeLabel(false), ffmpegResultPreview(result, err))
+		logger.Debugf(
+			"screenshots: ffmpeg capture fallback from_mode=%s to_mode=%s reason=%s",
+			ffmpegModeLabel(true),
+			ffmpegModeLabel(false),
+			ffmpegResultPreview(result, err),
+		)
 		args = buildFFmpegArgs(req, false)
-		logger.Tracef("screenshots: ffmpeg capture attempt mode=%s timestamp_seconds=%.3f input=%s output=%s filters=%s", ffmpegModeLabel(false), req.Timestamp, req.InputPath, req.OutputPath, ffmpegFilterFromArgs(args))
+		logger.Tracef(
+			"screenshots: ffmpeg capture attempt mode=%s timestamp_seconds=%.3f input=%s output=%s filters=%s",
+			ffmpegModeLabel(false),
+			req.Timestamp,
+			req.InputPath,
+			req.OutputPath,
+			ffmpegFilterFromArgs(args),
+		)
 		result, err = runner.Run(ctx, cmdPath, args, "")
 		if err == nil && result.ExitCode == 0 {
 			if err = validateCaptureOutput(req.OutputPath); err == nil {
@@ -508,7 +543,10 @@ func overlayFilters(req captureRequest) []string {
 		fmt.Sprintf("drawtext=text='Frame Type\\: %s':fontcolor=white:fontsize=%d:x=%d:y=%d:box=1:boxcolor=black@0.5", frameType, fontSize, xAll, yType),
 	}
 	if req.ToneMap {
-		filters = append(filters, fmt.Sprintf("drawtext=text='Tonemapped HDR':fontcolor=white:fontsize=%d:x=%d:y=%d:box=1:boxcolor=black@0.5", fontSize, xAll, yHDR))
+		filters = append(
+			filters,
+			fmt.Sprintf("drawtext=text='Tonemapped HDR':fontcolor=white:fontsize=%d:x=%d:y=%d:box=1:boxcolor=black@0.5", fontSize, xAll, yHDR),
+		)
 	}
 	return filters
 }
diff --git a/internal/services/screenshots/helpers.go b/internal/services/screenshots/helpers.go
index c46729e2..060398da 100644
--- a/internal/services/screenshots/helpers.go
+++ b/internal/services/screenshots/helpers.go
@@ -17,8 +17,8 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/metadata/discparse"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -63,7 +63,7 @@ var durationTokenPattern = regexp.MustCompile(`(?i)(\d+(?:\.\d+)?)\s*(millisecon
 // resolveVideoInfo selects timing metadata and the ffmpeg inputs used for
 // screenshot planning/capture. DVD releases keep ordered title-set segments so
 // global screenshot times can be captured from the matching VOB part.
-func resolveVideoInfo(ctx context.Context, meta api.PreparedMetadata, tmpRoot string, logger api.Logger) (videoInfo, error) {
+func resolveVideoInfo(ctx context.Context, meta api.ScreenshotSubject, tmpRoot string, logger api.Logger) (videoInfo, error) {
 	logger = screenshotLogger(logger)
 	info := videoInfo{}
 
@@ -113,7 +113,11 @@ func resolveVideoInfo(ctx context.Context, meta api.PreparedMetadata, tmpRoot st
 			logger.Tracef("screenshots: BDMV source selected method=metadata path=%s", filePath)
 		}
 
-		logger.Tracef("screenshots: BDMV summary lookup tmp_root_present=%t playlist=%s", strings.TrimSpace(tmpRoot) != "", paths.PrimaryBDMVPlaylist(meta))
+		logger.Tracef(
+			"screenshots: BDMV summary lookup tmp_root_present=%t playlist=%s",
+			strings.TrimSpace(tmpRoot) != "",
+			paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists),
+		)
 		bdinfo, err := loadBDInfo(tmpRoot, meta)
 		if err != nil {
 			return info, err
@@ -134,7 +138,12 @@ func resolveVideoInfo(ctx context.Context, meta api.PreparedMetadata, tmpRoot st
 					logger.Debugf("screenshots: BDMV source selection unavailable err=%s", redaction.RedactValue(err.Error(), nil))
 				}
 			}
-			logger.Tracef("screenshots: BDMV summary applied duration_seconds=%.3f frame_rate=%.3f files=%d", info.DurationSeconds, info.FrameRate, len(bdinfo.Files))
+			logger.Tracef(
+				"screenshots: BDMV summary applied duration_seconds=%.3f frame_rate=%.3f files=%d",
+				info.DurationSeconds,
+				info.FrameRate,
+				len(bdinfo.Files),
+			)
 		} else {
 			logger.Tracef("screenshots: BDMV summary not available")
 		}
@@ -182,7 +191,11 @@ func resolveSegmentTimestamp(info videoInfo, timestamp float64) (string, float64
 // frame from the primary segment.
 func resolveSegmentCandidates(info videoInfo, timestamp float64) []segmentCandidate {
 	if len(info.Segments) == 0 {
-		return []segmentCandidate{{SourcePath: info.SourcePath, Timestamp: timestamp, SegmentIndex: -1}}
+		return []segmentCandidate{{
+			SourcePath:   info.SourcePath,
+			Timestamp:    timestamp,
+			SegmentIndex: -1,
+		}}
 	}
 
 	primaryIndex := 0
@@ -236,7 +249,11 @@ func resolveSegmentCandidates(info videoInfo, timestamp float64) []segmentCandid
 		})
 	}
 	if len(candidates) == 0 {
-		return []segmentCandidate{{SourcePath: info.SourcePath, Timestamp: timestamp, SegmentIndex: -1}}
+		return []segmentCandidate{{
+			SourcePath:   info.SourcePath,
+			Timestamp:    timestamp,
+			SegmentIndex: -1,
+		}}
 	}
 	return candidates
 }
@@ -254,7 +271,7 @@ func segmentFallbackTimestamp(segment videoSegment) float64 {
 
 // resolveVideoSource applies the same input-file preference as resolveVideoInfo
 // when callers only need the ffmpeg source path, such as preview generation.
-func resolveVideoSource(ctx context.Context, meta api.PreparedMetadata, tmpRoot string, logger api.Logger) (string, error) {
+func resolveVideoSource(ctx context.Context, meta api.ScreenshotSubject, tmpRoot string, logger api.Logger) (string, error) {
 	logger = screenshotLogger(logger)
 	basePath := strings.TrimSpace(meta.VideoPath)
 	if basePath == "" {
@@ -280,7 +297,11 @@ func resolveVideoSource(ctx context.Context, meta api.PreparedMetadata, tmpRoot
 			return filePath, nil
 		}
 
-		logger.Tracef("screenshots: video source BDMV summary lookup tmp_root_present=%t playlist=%s", strings.TrimSpace(tmpRoot) != "", paths.PrimaryBDMVPlaylist(meta))
+		logger.Tracef(
+			"screenshots: video source BDMV summary lookup tmp_root_present=%t playlist=%s",
+			strings.TrimSpace(tmpRoot) != "",
+			paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists),
+		)
 		bdinfo, err := loadBDInfo(tmpRoot, meta)
 		if err != nil {
 			return "", err
@@ -311,7 +332,7 @@ func resolveVideoSource(ctx context.Context, meta api.PreparedMetadata, tmpRoot
 
 // selectBDMVFileFromMetadata returns a concrete stream path when the prepared
 // metadata already identifies the selected BDMV item or resolved video file.
-func selectBDMVFileFromMetadata(ctx context.Context, meta api.PreparedMetadata) (string, bool, error) {
+func selectBDMVFileFromMetadata(ctx context.Context, meta api.ScreenshotSubject) (string, bool, error) {
 	if fileName := largestSelectedBDMVPlaylistItem(meta.SelectedBDMVPlaylists); fileName != "" {
 		if videoPath := strings.TrimSpace(meta.VideoPath); videoPath != "" && strings.EqualFold(filepath.Base(videoPath), fileName) {
 			return videoPath, true, nil
@@ -611,18 +632,18 @@ func trackString(track map[string]any, keys ...string) string {
 	return ""
 }
 
-func loadBDInfo(tmpRoot string, meta api.PreparedMetadata) (*discparse.BDInfo, error) {
+func loadBDInfo(tmpRoot string, meta api.ScreenshotSubject) (*discparse.BDInfo, error) {
 	if !strings.EqualFold(meta.DiscType, "BDMV") && !strings.EqualFold(meta.DiscType, "DVD") {
 		return nil, nil
 	}
 	if strings.TrimSpace(tmpRoot) == "" {
 		return nil, nil
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return nil, fmt.Errorf("screenshots: %w", err)
 	}
-	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta))
+	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists))
 	if strings.TrimSpace(path) == "" {
 		return nil, nil
 	}
@@ -862,13 +883,13 @@ func findVideoTS(ctx context.Context, root string) (string, error) {
 
 var errFound = errors.New("found")
 
-func buildScreenshotSelections(count int, durationSeconds float64, frameRate float64, meta api.PreparedMetadata) []api.ScreenshotSelection {
+func buildScreenshotSelections(count int, durationSeconds float64, frameRate float64, meta api.ScreenshotSubject) []api.ScreenshotSelection {
 	if count <= 0 || durationSeconds <= 0 || frameRate <= 0 {
 		return nil
 	}
 	totalFrames := int(durationSeconds * frameRate)
 	startFrame := int(float64(totalFrames) * 0.05)
-	if strings.EqualFold(meta.MediaInfoCategory, "TV") {
+	if strings.EqualFold(meta.MediaCategory, "TV") {
 		startFrame = int(float64(totalFrames) * 0.10)
 	}
 	endFrame := int(float64(totalFrames) * 0.90)
@@ -936,14 +957,14 @@ func sanitizeFilename(value string) string {
 	}, trimmed)
 }
 
-func shouldTonemap(meta api.PreparedMetadata, cfg config.Config) bool {
+func shouldTonemap(meta api.ScreenshotSubject, cfg config.Config) bool {
 	if !cfg.ScreenshotHandling.ToneMap {
 		return false
 	}
 	return strings.Contains(strings.ToUpper(meta.HDR), "HDR") || strings.Contains(strings.ToUpper(meta.HDR), "DV")
 }
 
-func shouldUseLibplacebo(meta api.PreparedMetadata, cfg config.Config) bool {
+func shouldUseLibplacebo(meta api.ScreenshotSubject, cfg config.Config) bool {
 	if !cfg.ScreenshotHandling.UseLibplacebo {
 		return false
 	}
@@ -962,7 +983,7 @@ func screenshotLogger(logger api.Logger) api.Logger {
 
 // screenshotSourceKind classifies the prepared metadata for diagnostic logs
 // without changing screenshot selection behavior.
-func screenshotSourceKind(meta api.PreparedMetadata) string {
+func screenshotSourceKind(meta api.ScreenshotSubject) string {
 	discType := strings.TrimSpace(meta.DiscType)
 	if discType != "" {
 		return "disc_" + strings.ToLower(sanitizeFilename(discType))
@@ -970,8 +991,8 @@ func screenshotSourceKind(meta api.PreparedMetadata) string {
 	if meta.TVPack {
 		return "season_pack"
 	}
-	if strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") {
-		if meta.EpisodeInt <= 0 && meta.Release.Episode <= 0 {
+	if strings.EqualFold(strings.TrimSpace(meta.MediaCategory), "TV") {
+		if meta.Episode <= 0 && meta.Release.Episode <= 0 {
 			return "season_pack"
 		}
 		return "episode"
diff --git a/internal/services/screenshots/helpers_test.go b/internal/services/screenshots/helpers_test.go
index fcd1ced8..7a996292 100644
--- a/internal/services/screenshots/helpers_test.go
+++ b/internal/services/screenshots/helpers_test.go
@@ -16,7 +16,7 @@ import (
 )
 
 func TestBuildScreenshotSelections(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.ScreenshotSubject{}
 	selections := buildScreenshotSelections(4, 600, 24, meta)
 	if len(selections) != 4 {
 		t.Fatalf("expected 4 selections, got %d", len(selections))
@@ -78,7 +78,7 @@ func TestParseDurationValueParsesMediaInfoText(t *testing.T) {
 
 func TestBuildScreenshotSelectionsUsesLongMediaInfoDuration(t *testing.T) {
 	duration := parseDurationValue("10571.090286852")
-	selections := buildScreenshotSelections(5, duration, 23.976, api.PreparedMetadata{})
+	selections := buildScreenshotSelections(5, duration, 23.976, api.ScreenshotSubject{})
 	if len(selections) != 5 {
 		t.Fatalf("expected 5 selections, got %d", len(selections))
 	}
@@ -89,12 +89,28 @@ func TestBuildScreenshotSelectionsUsesLongMediaInfoDuration(t *testing.T) {
 
 func TestFilterScreenshotsMatchingSelectionsRejectsStaleTimestamps(t *testing.T) {
 	selections := []api.ScreenshotSelection{
-		{Index: 0, TimestampSeconds: 528.5, Frame: 12671},
-		{Index: 1, TimestampSeconds: 2322.0, Frame: 55671},
+		{
+			Index:            0,
+			TimestampSeconds: 528.5,
+			Frame:            12671,
+		},
+		{
+			Index:            1,
+			TimestampSeconds: 2322.0,
+			Frame:            55671,
+		},
 	}
 	images := []api.ScreenshotImage{
-		{Index: 0, TimestampSeconds: 0.5, Path: "stale.png"},
-		{Index: 1, TimestampSeconds: 2322.1, Path: "current.png"},
+		{
+			Index:            0,
+			TimestampSeconds: 0.5,
+			Path:             "stale.png",
+		},
+		{
+			Index:            1,
+			TimestampSeconds: 2322.1,
+			Path:             "current.png",
+		},
 	}
 
 	filtered := filterScreenshotsMatchingSelections(images, selections, 23.976)
@@ -120,7 +136,7 @@ func TestResolveVideoInfoPrefersLargestSelectedBDMVPlaylistFile(t *testing.T) {
 		}
 	}
 
-	meta := api.PreparedMetadata{
+	meta := api.ScreenshotSubject{
 		SourcePath: root,
 		DiscType:   "BDMV",
 		VideoPath:  small,
@@ -162,7 +178,7 @@ func TestResolveVideoSourcePrefersLargestSelectedBDMVPlaylistFile(t *testing.T)
 		}
 	}
 
-	meta := api.PreparedMetadata{
+	meta := api.ScreenshotSubject{
 		SourcePath: root,
 		DiscType:   "BDMV",
 		VideoPath:  small,
@@ -199,10 +215,10 @@ func TestResolveVideoInfoLogsSeasonPackSourceKind(t *testing.T) {
 	}
 
 	logger := &screenshotRecordingLogger{}
-	meta := api.PreparedMetadata{
+	meta := api.ScreenshotSubject{
 		SourcePath:        filepath.Join(tmpDir, "Example.Release.2026.S01"),
 		MediaInfoJSONPath: mediaInfoPath,
-		MediaInfoCategory: "TV",
+		MediaCategory:     "TV",
 		TVPack:            true,
 	}
 
@@ -269,7 +285,7 @@ func TestResolveVideoInfoBuildsOrderedDVDSegments(t *testing.T) {
 		t.Fatalf("write mediainfo: %v", err)
 	}
 
-	info, err := resolveVideoInfo(context.Background(), api.PreparedMetadata{
+	info, err := resolveVideoInfo(context.Background(), api.ScreenshotSubject{
 		SourcePath:        root,
 		DiscType:          "DVD",
 		MediaInfoJSONPath: mediaInfoPath,
@@ -335,8 +351,16 @@ func TestResolveSegmentCandidatesFallsForwardFromPrimarySegment(t *testing.T) {
 	info := videoInfo{
 		SourcePath: "VTS_01_1.VOB",
 		Segments: []videoSegment{
-			{SourcePath: "VTS_01_1.VOB", StartSeconds: 0, DurationSeconds: 2},
-			{SourcePath: "VTS_01_2.VOB", StartSeconds: 2, DurationSeconds: 98},
+			{
+				SourcePath:      "VTS_01_1.VOB",
+				StartSeconds:    0,
+				DurationSeconds: 2,
+			},
+			{
+				SourcePath:      "VTS_01_2.VOB",
+				StartSeconds:    2,
+				DurationSeconds: 98,
+			},
 		},
 	}
 
diff --git a/internal/services/screenshots/service.go b/internal/services/screenshots/service.go
index 244cac04..2aafaed5 100644
--- a/internal/services/screenshots/service.go
+++ b/internal/services/screenshots/service.go
@@ -24,23 +24,38 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
 	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Service plans, captures, previews, persists, and removes release screenshots
+// beneath a managed temporary root.
 type Service struct {
 	cfg     config.Config
 	logger  api.Logger
 	tmpRoot string
 	runner  Runner
-	repo    api.MetadataRepository
+	repo    repository
 }
 
+type repository interface {
+	api.ScreenshotLifecycleRepository
+	SaveScreenshot(context.Context, api.Screenshot) error
+	ListScreenshotsByPath(context.Context, string) ([]api.Screenshot, error)
+	DeleteScreenshot(context.Context, string) error
+	ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error)
+	DeleteFinalSelection(context.Context, string) error
+	ListTrackerMetadataByPath(context.Context, string) ([]api.TrackerMetadata, error)
+	SaveTrackerMetadata(context.Context, api.TrackerMetadata) error
+}
+
+// NewService returns a screenshot service without persistence. Nil logger and
+// runner values select [api.NopLogger] and the process-backed FFmpeg runner.
 func NewService(cfg config.Config, logger api.Logger, tmpRoot string, runner Runner) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
@@ -48,20 +63,38 @@ func NewService(cfg config.Config, logger api.Logger, tmpRoot string, runner Run
 	if runner == nil {
 		runner = commandRunner{}
 	}
-	return &Service{cfg: cfg, logger: logger, tmpRoot: tmpRoot, runner: runner}
+	return &Service{
+		cfg:     cfg,
+		logger:  logger,
+		tmpRoot: tmpRoot,
+		runner:  runner,
+	}
 }
 
-func NewServiceWithRepo(cfg config.Config, logger api.Logger, tmpRoot string, runner Runner, repo api.MetadataRepository) *Service {
+// NewServiceWithRepo returns a screenshot service that can reuse and persist
+// screenshot, final-selection, and tracker-image records through repo.
+func NewServiceWithRepo(cfg config.Config, logger api.Logger, tmpRoot string, runner Runner, repo repository) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
 	if runner == nil {
 		runner = commandRunner{}
 	}
-	return &Service{cfg: cfg, logger: logger, tmpRoot: tmpRoot, runner: runner, repo: repo}
+	return &Service{
+		cfg:     cfg,
+		logger:  logger,
+		tmpRoot: tmpRoot,
+		runner:  runner,
+		repo:    repo,
+	}
 }
 
-func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int) (plan api.ScreenshotPlan, err error) {
+// Plan derives frame suggestions from prepared timing data and excludes
+// matching managed screenshots already present on disk and in the repository.
+// A non-positive count falls back to the subject default and then config. When
+// timing is unavailable, the returned plan requests manual frames instead of
+// failing; stored tracker images are merged into final selections.
+func (s *Service) Plan(ctx context.Context, meta api.ScreenshotSubject, count int) (plan api.ScreenshotPlan, err error) {
 	defer func() {
 		if err != nil {
 			s.logger.Warnf("screenshots: planning blocked err=%s", redaction.RedactValue(err.Error(), nil))
@@ -80,7 +113,7 @@ func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int
 	}
 
 	if count <= 0 {
-		count = meta.Options.Screens
+		count = meta.DefaultCount
 	}
 	if count <= 0 {
 		count = s.cfg.ScreenshotHandling.Screens
@@ -101,13 +134,13 @@ func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int
 		screenshotSourceKind(meta),
 		screenshotLogField(meta.DiscType),
 		count,
-		len(meta.ScreenshotOverrides.ManualFrames),
+		len(meta.ManualFrames),
 		plan.DurationSeconds,
 		plan.FrameRate,
 		info.SourcePath,
 	)
 
-	manualSelections := buildManualFrameSelections(meta.ScreenshotOverrides.ManualFrames, plan.FrameRate)
+	manualSelections := buildManualFrameSelections(meta.ManualFrames, plan.FrameRate)
 	if len(manualSelections) == 0 && (plan.DurationSeconds <= 0 || plan.FrameRate <= 0) {
 		plan.RequiresManualFrames = true
 		s.logger.Debugf("screenshots: manual frames required reason=missing_timing duration_seconds=%.3f frame_rate=%.3f", plan.DurationSeconds, plan.FrameRate)
@@ -119,7 +152,7 @@ func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int
 		total = count + 1
 	}
 
-	tmpDir, _, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return api.ScreenshotPlan{}, fmt.Errorf("screenshots: %w", err)
 	}
@@ -206,7 +239,7 @@ func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int
 	plan.SuggestedSelections = suggestions
 
 	plan.ExistingScreenshots = filterScreenshotsMatchingSelections(listExistingScreens(tmpDir, base), baselineSelections, plan.FrameRate)
-	plan.TrackerImageLinks = buildTrackerImageLinks(meta, tmpDir)
+	plan.TrackerImageLinks = buildTrackerImageLinks(s.loadTrackerMetadata(ctx, meta.SourcePath), tmpDir)
 	plan.ExistingTrackerScreenshots = filterUnlinkedTrackerScreens(
 		listTrackerScreens(tmpDir, base),
 		plan.TrackerImageLinks,
@@ -231,7 +264,12 @@ func (s *Service) Plan(ctx context.Context, meta api.PreparedMetadata, count int
 // Capture renders the requested frames into the prepared release's managed temp
 // directory and records each image with purpose. It returns successful images
 // plus per-selection failures and honors context cancellation.
-func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, selections []api.ScreenshotSelection, purpose api.ScreenshotPurpose) (result api.ScreenshotResult, err error) {
+func (s *Service) Capture(
+	ctx context.Context,
+	meta api.ScreenshotSubject,
+	selections []api.ScreenshotSelection,
+	purpose api.ScreenshotPurpose,
+) (result api.ScreenshotResult, err error) {
 	defer func() {
 		if err != nil {
 			s.logger.Warnf("screenshots: capture blocked err=%s", redaction.RedactValue(err.Error(), nil))
@@ -261,7 +299,7 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, select
 		return api.ScreenshotResult{}, err
 	}
 
-	tmpDir, _, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return api.ScreenshotResult{}, fmt.Errorf("screenshots: %w", err)
 	}
@@ -365,7 +403,16 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, select
 			var usedLib bool
 			var captureErr error
 			for _, candidate := range resolveSegmentCandidates(info, ts) {
-				s.logger.Tracef("screenshots: capture queued index=%d timestamp_seconds=%.3f input_timestamp_seconds=%.3f segment=%d fallback=%d input=%s output=%s", selection.Index, ts, candidate.Timestamp, candidate.SegmentIndex, candidate.FallbackIndex, candidate.SourcePath, output)
+				s.logger.Tracef(
+					"screenshots: capture queued index=%d timestamp_seconds=%.3f input_timestamp_seconds=%.3f segment=%d fallback=%d input=%s output=%s",
+					selection.Index,
+					ts,
+					candidate.Timestamp,
+					candidate.SegmentIndex,
+					candidate.FallbackIndex,
+					candidate.SourcePath,
+					output,
+				)
 				capture := captureRequest{
 					InputPath:     candidate.SourcePath,
 					OutputPath:    output,
@@ -390,7 +437,13 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, select
 				if captureErr == nil {
 					break
 				}
-				s.logger.Debugf("screenshots: capture segment failed index=%d segment=%d fallback=%d err=%s", selection.Index, candidate.SegmentIndex, candidate.FallbackIndex, redaction.RedactValue(captureErr.Error(), nil))
+				s.logger.Debugf(
+					"screenshots: capture segment failed index=%d segment=%d fallback=%d err=%s",
+					selection.Index,
+					candidate.SegmentIndex,
+					candidate.FallbackIndex,
+					redaction.RedactValue(captureErr.Error(), nil),
+				)
 			}
 			if captureErr != nil {
 				s.logger.Warnf("screenshots: capture frame failed index=%d err=%s", selection.Index, redaction.RedactValue(captureErr.Error(), nil))
@@ -404,7 +457,12 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, select
 				usedLibplacebo.Store(true)
 			}
 
-			img := api.ScreenshotImage{Index: selection.Index, TimestampSeconds: ts, Path: output, Purpose: purpose}
+			img := api.ScreenshotImage{
+				Index:            selection.Index,
+				TimestampSeconds: ts,
+				Path:             output,
+				Purpose:          purpose,
+			}
 			if stat, err := os.Stat(output); err == nil {
 				img.SizeBytes = stat.Size()
 			}
@@ -481,7 +539,10 @@ func (s *Service) Capture(ctx context.Context, meta api.PreparedMetadata, select
 	return result, nil
 }
 
-func (s *Service) PreviewFrame(ctx context.Context, meta api.PreparedMetadata, timestampSeconds float64) (preview api.ScreenshotPreview, err error) {
+// PreviewFrame captures one decodable, non-black PNG into memory without
+// persisting it. DVD inputs try the selected VOB segment followed by later
+// segments when a candidate yields no usable frame.
+func (s *Service) PreviewFrame(ctx context.Context, meta api.ScreenshotSubject, timestampSeconds float64) (preview api.ScreenshotPreview, err error) {
 	defer func() {
 		if err != nil {
 			s.logger.Warnf("screenshots: preview blocked err=%s", redaction.RedactValue(err.Error(), nil))
@@ -512,10 +573,25 @@ func (s *Service) PreviewFrame(ctx context.Context, meta api.PreparedMetadata, t
 	}
 	candidates := resolveSegmentCandidates(info, timestampSeconds)
 
-	s.logger.Debugf("screenshots: preview setup kind=%s disc=%s timestamp_seconds=%.3f candidates=%d selected_path=%s ffmpeg=%s", screenshotSourceKind(meta), screenshotLogField(meta.DiscType), timestampSeconds, len(candidates), candidates[0].SourcePath, cmd)
+	s.logger.Debugf(
+		"screenshots: preview setup kind=%s disc=%s timestamp_seconds=%.3f candidates=%d selected_path=%s ffmpeg=%s",
+		screenshotSourceKind(meta),
+		screenshotLogField(meta.DiscType),
+		timestampSeconds,
+		len(candidates),
+		candidates[0].SourcePath,
+		cmd,
+	)
 	var payload []byte
 	for _, candidate := range candidates {
-		s.logger.Tracef("screenshots: preview queued timestamp_seconds=%.3f input_timestamp_seconds=%.3f segment=%d fallback=%d input=%s", timestampSeconds, candidate.Timestamp, candidate.SegmentIndex, candidate.FallbackIndex, candidate.SourcePath)
+		s.logger.Tracef(
+			"screenshots: preview queued timestamp_seconds=%.3f input_timestamp_seconds=%.3f segment=%d fallback=%d input=%s",
+			timestampSeconds,
+			candidate.Timestamp,
+			candidate.SegmentIndex,
+			candidate.FallbackIndex,
+			candidate.SourcePath,
+		)
 		payload, err = captureFrameBytes(ctx, s.runner, cmd, previewRequest{
 			InputPath: candidate.SourcePath,
 			Timestamp: candidate.Timestamp,
@@ -523,7 +599,12 @@ func (s *Service) PreviewFrame(ctx context.Context, meta api.PreparedMetadata, t
 		if err == nil {
 			break
 		}
-		s.logger.Debugf("screenshots: preview segment failed segment=%d fallback=%d err=%s", candidate.SegmentIndex, candidate.FallbackIndex, redaction.RedactValue(err.Error(), nil))
+		s.logger.Debugf(
+			"screenshots: preview segment failed segment=%d fallback=%d err=%s",
+			candidate.SegmentIndex,
+			candidate.FallbackIndex,
+			redaction.RedactValue(err.Error(), nil),
+		)
 	}
 	if err != nil {
 		return api.ScreenshotPreview{}, err
@@ -542,7 +623,11 @@ func (s *Service) PreviewFrame(ctx context.Context, meta api.PreparedMetadata, t
 	return preview, nil
 }
 
-func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePath string) error {
+// Delete removes an allowed image beneath the release's managed temp directory.
+// Repository screenshot, upload, final-selection, and tracker-image references
+// are then cleaned up best-effort; those cleanup failures are logged and do not
+// restore the local file or fail the call.
+func (s *Service) Delete(ctx context.Context, meta api.ScreenshotSubject, imagePath string) error {
 	select {
 	case <-ctx.Done():
 		return fmt.Errorf("context canceled: %w", ctx.Err())
@@ -557,7 +642,7 @@ func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePa
 		s.logger.Tracef("screenshots: delete requested path=%s", trimmed)
 	}
 
-	tmpDir, _, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return fmt.Errorf("screenshots: %w", err)
 	}
@@ -616,7 +701,7 @@ func (s *Service) Delete(ctx context.Context, meta api.PreparedMetadata, imagePa
 	return nil
 }
 
-func (s *Service) removeTrackerImageReference(ctx context.Context, meta api.PreparedMetadata, tmpDir string, absTarget string) {
+func (s *Service) removeTrackerImageReference(ctx context.Context, meta api.ScreenshotSubject, tmpDir string, absTarget string) {
 	if s.repo == nil {
 		return
 	}
@@ -624,7 +709,7 @@ func (s *Service) removeTrackerImageReference(ctx context.Context, meta api.Prep
 		return
 	}
 	fileStem := strings.ToLower(strings.TrimSuffix(filepath.Base(absTarget), filepath.Ext(absTarget)))
-	records := meta.TrackerData
+	var records []api.TrackerMetadata
 	if strings.TrimSpace(meta.SourcePath) != "" {
 		stored, err := s.repo.ListTrackerMetadataByPath(ctx, meta.SourcePath)
 		if err != nil {
@@ -670,7 +755,11 @@ func (s *Service) removeTrackerImageReference(ctx context.Context, meta api.Prep
 				if baseStem != "" && (fileStem == baseStem || strings.HasPrefix(fileStem, baseStem+"_")) {
 					removed = true
 					if s.logger != nil {
-						s.logger.Tracef("screenshots: tracker image stem match tracker=%s url=%s", strings.TrimSpace(record.Tracker), strings.TrimSpace(urlValue))
+						s.logger.Tracef(
+							"screenshots: tracker image stem match tracker=%s url=%s",
+							strings.TrimSpace(record.Tracker),
+							strings.TrimSpace(urlValue),
+						)
 					}
 					continue
 				}
@@ -694,6 +783,20 @@ func (s *Service) removeTrackerImageReference(ctx context.Context, meta api.Prep
 	}
 }
 
+func (s *Service) loadTrackerMetadata(ctx context.Context, sourcePath string) []api.TrackerMetadata {
+	if s.repo == nil || strings.TrimSpace(sourcePath) == "" {
+		return nil
+	}
+	records, err := s.repo.ListTrackerMetadataByPath(ctx, sourcePath)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Debugf("screenshots: failed to load tracker metadata: %v", err)
+		}
+		return nil
+	}
+	return records
+}
+
 func retrySQLiteBusy(ctx context.Context, attempts int, fn func() error) error {
 	if attempts < 1 {
 		attempts = 1
@@ -726,7 +829,7 @@ func isSQLiteBusyError(err error) bool {
 // SaveFinalSelections replaces normal final selections from images while
 // preserving manual and automatic disc-menu selections. Menu-purpose images in
 // the input are ignored rather than reclassified as normal screenshots.
-func (s *Service) SaveFinalSelections(ctx context.Context, meta api.PreparedMetadata, images []api.ScreenshotImage) error {
+func (s *Service) SaveFinalSelections(ctx context.Context, meta api.ScreenshotSubject, images []api.ScreenshotImage) error {
 	if s.repo == nil {
 		return nil
 	}
@@ -736,7 +839,7 @@ func (s *Service) SaveFinalSelections(ctx context.Context, meta api.PreparedMeta
 	default:
 	}
 
-	tmpDir, _, err := paths.ReleaseTempDir(s.tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(s.tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return fmt.Errorf("screenshots: %w", err)
 	}
@@ -765,20 +868,14 @@ func (s *Service) SaveFinalSelections(ctx context.Context, meta api.PreparedMeta
 		})
 	}
 
-	if lifecycle, ok := s.repo.(api.ScreenshotLifecycleRepository); ok {
-		if err := lifecycle.ReplaceNormalFinalSelections(ctx, meta.SourcePath, selections); err != nil {
-			return fmt.Errorf("screenshots: replace normal final selections: %w", err)
-		}
-		return nil
-	}
-	if err := s.repo.SaveFinalSelections(ctx, meta.SourcePath, selections); err != nil {
-		return fmt.Errorf("screenshots: save final selections: %w", err)
+	if err := s.repo.ReplaceNormalFinalSelections(ctx, meta.SourcePath, selections); err != nil {
+		return fmt.Errorf("screenshots: replace normal final selections: %w", err)
 	}
 	return nil
 }
 
-func screenshotBaseName(meta api.PreparedMetadata) string {
-	base := paths.ReleaseTempBase(meta, meta.SourcePath)
+func screenshotBaseName(meta api.ScreenshotSubject) string {
+	base := paths.ReleaseTempBaseFor(meta.SourcePath, meta.Release)
 	return sanitizeFilename(base)
 }
 
@@ -897,7 +994,11 @@ func listTrackerScreens(tmpDir, base string) []api.ScreenshotImage {
 		if infoErr != nil {
 			return nil
 		}
-		results = append(results, api.ScreenshotImage{Path: path, Purpose: api.ScreenshotPurposeFinal, SizeBytes: info.Size()})
+		results = append(results, api.ScreenshotImage{
+			Path:      path,
+			Purpose:   api.ScreenshotPurposeFinal,
+			SizeBytes: info.Size(),
+		})
 		return nil
 	})
 
@@ -905,7 +1006,7 @@ func listTrackerScreens(tmpDir, base string) []api.ScreenshotImage {
 	return results
 }
 
-func (s *Service) loadFinalSelections(ctx context.Context, meta api.PreparedMetadata, tmpDir string) []api.ScreenshotImage {
+func (s *Service) loadFinalSelections(ctx context.Context, meta api.ScreenshotSubject, tmpDir string) []api.ScreenshotImage {
 	if s.repo == nil {
 		return nil
 	}
@@ -1051,15 +1152,15 @@ func reindexScreenshotImages(images []api.ScreenshotImage) []api.ScreenshotImage
 	return images
 }
 
-func buildTrackerImageLinks(meta api.PreparedMetadata, tmpDir string) []api.ScreenshotLinkedImage {
+func buildTrackerImageLinks(records []api.TrackerMetadata, tmpDir string) []api.ScreenshotLinkedImage {
 	if strings.TrimSpace(tmpDir) == "" {
 		return nil
 	}
-	if len(meta.TrackerData) == 0 {
+	if len(records) == 0 {
 		return nil
 	}
 	results := make([]api.ScreenshotLinkedImage, 0)
-	for _, record := range meta.TrackerData {
+	for _, record := range records {
 		tracker := strings.TrimSpace(record.Tracker)
 		if tracker == "" {
 			continue
diff --git a/internal/services/screenshots/service_test.go b/internal/services/screenshots/service_test.go
index 4a4f9640..87036b64 100644
--- a/internal/services/screenshots/service_test.go
+++ b/internal/services/screenshots/service_test.go
@@ -94,12 +94,10 @@ func TestPlanUsesManualFrameOverridesWithoutDuration(t *testing.T) {
 	}
 
 	service := NewService(config.Config{}, api.NopLogger{}, tmpDir, nil)
-	meta := api.PreparedMetadata{
+	meta := api.ScreenshotSubject{
 		SourcePath:        filepath.Join(tmpDir, "movie.mkv"),
 		MediaInfoJSONPath: mediaInfoPath,
-		ScreenshotOverrides: api.ScreenshotOverrides{
-			ManualFrames: []int{120, 360, 600},
-		},
+		ManualFrames:      []int{120, 360, 600},
 	}
 
 	plan, err := service.Plan(context.Background(), meta, 4)
@@ -142,11 +140,16 @@ func TestPreviewFrameExcludesDVDMenuVOB(t *testing.T) {
 	t.Chdir(ffmpegRoot)
 
 	runner := &scriptedRunner{results: []CommandResult{{
-		Stdout:   testPNGBytes(t, color.RGBA{R: 16, G: 16, B: 16, A: 255}),
+		Stdout: testPNGBytes(t, color.RGBA{
+			R: 16,
+			G: 16,
+			B: 16,
+			A: 255,
+		}),
 		ExitCode: 0,
 	}}}
 	service := NewService(config.Config{}, api.NopLogger{}, root, runner)
-	preview, err := service.PreviewFrame(context.Background(), api.PreparedMetadata{
+	preview, err := service.PreviewFrame(context.Background(), api.ScreenshotSubject{
 		SourcePath:        root,
 		DiscType:          "DVD",
 		MediaInfoJSONPath: mediaInfoPath,
diff --git a/internal/services/trackericon/service.go b/internal/services/trackericon/service.go
index 7cc8bb74..e9f20f9d 100644
--- a/internal/services/trackericon/service.go
+++ b/internal/services/trackericon/service.go
@@ -38,7 +38,13 @@ var (
 	}
 )
 
-// GetTrackerIcon resolves the domain icon, caches it under the dbPath directory, and returns its Base64 Data URL.
+// GetTrackerIcon returns a validated image as a Base64 data URL and caches it
+// relative to the database directory. Callers must supply a valid tracker
+// hostname because the cache-name filter does not validate path-component
+// structure. Lookup tries the custom URL and its root favicon before domain
+// favicon candidates, limits responses to 1 MiB, rejects unsupported image
+// types and validation-time private addresses, and negative-caches complete
+// failures for 24 hours. Custom URLs are part of the cache key.
 func GetTrackerIcon(ctx context.Context, dbPath string, domain string, customURL string) (string, error) {
 	sanitized := SafeDomainFilename(domain)
 	if sanitized == "" {
@@ -306,7 +312,9 @@ func isAllowedIconContentType(mime string) bool {
 	}
 }
 
-// SafeDomainFilename purges disallowed characters from domain strings for file system safety.
+// SafeDomainFilename lowercases domain and removes every character except
+// ASCII letters, digits, dots, and hyphens. It does not validate DNS name
+// structure or guarantee that the result is a single path component.
 func SafeDomainFilename(domain string) string {
 	var sb strings.Builder
 	for _, r := range strings.ToLower(domain) {
@@ -317,7 +325,8 @@ func SafeDomainFilename(domain string) string {
 	return sb.String()
 }
 
-// DetectIconContentType detects the image format MIME type.
+// DetectIconContentType uses HTTP content sniffing and relabels otherwise
+// generic octet-stream data only when it has a structurally valid ICO header.
 func DetectIconContentType(data []byte) string {
 	ct := http.DetectContentType(data)
 	if ct == "application/octet-stream" && isICOFile(data) {
diff --git a/internal/sourcelayout/layout.go b/internal/sourcelayout/layout.go
new file mode 100644
index 00000000..46b6aec7
--- /dev/null
+++ b/internal/sourcelayout/layout.go
@@ -0,0 +1,160 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package sourcelayout resolves one requested preparation source into the
+// local resource roots used while collecting release facts.
+package sourcelayout
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+)
+
+// Kind identifies how the requested source relates to its content root.
+type Kind string
+
+const (
+	// KindFile identifies a source that is one regular file.
+	KindFile Kind = "file"
+	// KindDirectory identifies a non-disc directory source.
+	KindDirectory Kind = "directory"
+	// KindDiscParent identifies a directory containing a recognized disc root.
+	KindDiscParent Kind = "disc_parent"
+	// KindDiscRoot identifies a recognized disc root selected directly.
+	KindDiscRoot Kind = "disc_root"
+)
+
+// Layout preserves requested-source identity while exposing derived local
+// resource roots only to preparation internals.
+type Layout struct {
+	// SourcePath is the absolute, cleaned path originally selected by the caller.
+	SourcePath string
+	// Kind describes how SourcePath relates to ContentRoot.
+	Kind Kind
+	// DiscType is BDMV, DVD, or HDDVD for recognized disc layouts; otherwise empty.
+	DiscType string
+	// ContentRoot is the local file or directory used to collect source facts.
+	ContentRoot string
+	// BDMVRoot is the selected or discovered BDMV directory; otherwise empty.
+	BDMVRoot string
+	// DVDRoot is the selected or discovered VIDEO_TS or HVDVD_TS directory; otherwise empty.
+	DVDRoot string
+}
+
+// ErrSourceNotFound identifies a requested preparation source that does not
+// exist without exposing its local path through public failures. Test it with
+// [errors.Is].
+var ErrSourceNotFound = errors.New("source layout: source not found")
+
+// Resolve normalizes and validates sourcePath and derives any disc resource
+// root without changing the source's canonical identity. Disc markers are
+// matched case-insensitively at the source root or among its immediate children;
+// deeper descendants are not scanned.
+func Resolve(ctx context.Context, sourcePath string) (Layout, error) {
+	if ctx == nil {
+		return Layout{}, errors.New("source layout: context is required")
+	}
+	trimmed := strings.TrimSpace(sourcePath)
+	if trimmed == "" {
+		return Layout{}, fmt.Errorf("source layout: source path is required: %w", internalerrors.ErrInvalidInput)
+	}
+	abs, err := filepath.Abs(trimmed)
+	if err != nil {
+		return Layout{}, fmt.Errorf("source layout: normalize source: %w", err)
+	}
+	abs = filepath.Clean(abs)
+	if err := ctx.Err(); err != nil {
+		return Layout{}, fmt.Errorf("source layout: resolve canceled: %w", err)
+	}
+	info, err := os.Stat(abs)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return Layout{}, ErrSourceNotFound
+		}
+		return Layout{}, fmt.Errorf("source layout: inspect source: %w", err)
+	}
+	if !info.IsDir() {
+		return Layout{
+			SourcePath:  abs,
+			Kind:        KindFile,
+			ContentRoot: abs,
+		}, nil
+	}
+
+	markerPath, discType, err := findDiscMarker(ctx, abs)
+	if err != nil {
+		return Layout{}, err
+	}
+	if markerPath == "" {
+		return Layout{
+			SourcePath:  abs,
+			Kind:        KindDirectory,
+			ContentRoot: abs,
+		}, nil
+	}
+
+	kind := KindDiscParent
+	if pathutil.SamePath(abs, markerPath) {
+		kind = KindDiscRoot
+	}
+	layout := Layout{
+		SourcePath:  abs,
+		Kind:        kind,
+		DiscType:    discType,
+		ContentRoot: markerPath,
+	}
+	switch discType {
+	case "BDMV":
+		layout.BDMVRoot = markerPath
+	case "DVD", "HDDVD":
+		layout.DVDRoot = markerPath
+	}
+	return layout, nil
+}
+
+// findDiscMarker checks root and its immediate children for a recognized disc directory.
+func findDiscMarker(ctx context.Context, root string) (string, string, error) {
+	if err := ctx.Err(); err != nil {
+		return "", "", fmt.Errorf("source layout: scan canceled: %w", err)
+	}
+	if discType := markerDiscType(filepath.Base(root)); discType != "" {
+		return filepath.Clean(root), discType, nil
+	}
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return "", "", fmt.Errorf("source layout: read source: %w", err)
+	}
+	for _, entry := range entries {
+		if err := ctx.Err(); err != nil {
+			return "", "", fmt.Errorf("source layout: scan canceled: %w", err)
+		}
+		if !entry.IsDir() {
+			continue
+		}
+		if discType := markerDiscType(entry.Name()); discType != "" {
+			return filepath.Join(root, entry.Name()), discType, nil
+		}
+	}
+	return "", "", nil
+}
+
+// markerDiscType maps a case-insensitive disc directory name to its canonical type.
+func markerDiscType(name string) string {
+	switch {
+	case strings.EqualFold(name, "BDMV"):
+		return "BDMV"
+	case strings.EqualFold(name, "VIDEO_TS"):
+		return "DVD"
+	case strings.EqualFold(name, "HVDVD_TS"):
+		return "HDDVD"
+	default:
+		return ""
+	}
+}
diff --git a/internal/sourcelayout/layout_test.go b/internal/sourcelayout/layout_test.go
new file mode 100644
index 00000000..146c7fbe
--- /dev/null
+++ b/internal/sourcelayout/layout_test.go
@@ -0,0 +1,155 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package sourcelayout
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+)
+
+func TestResolveSourceKinds(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	filePath := filepath.Join(root, "Example.Release.2026.mkv")
+	if err := os.WriteFile(filePath, []byte("example"), 0o600); err != nil {
+		t.Fatalf("write source file: %v", err)
+	}
+	ordinary := filepath.Join(root, "ordinary")
+	nestedBDMV := filepath.Join(ordinary, "nested", "BDMV")
+	if err := os.MkdirAll(nestedBDMV, 0o700); err != nil {
+		t.Fatalf("create ordinary source: %v", err)
+	}
+	discParent := filepath.Join(root, "disc-parent")
+	bdmvRoot := filepath.Join(discParent, "BDMV")
+	if err := os.MkdirAll(bdmvRoot, 0o700); err != nil {
+		t.Fatalf("create BDMV source: %v", err)
+	}
+	dvdParent := filepath.Join(root, "dvd-parent")
+	dvdRoot := filepath.Join(dvdParent, "VIDEO_TS")
+	if err := os.MkdirAll(dvdRoot, 0o700); err != nil {
+		t.Fatalf("create DVD source: %v", err)
+	}
+
+	tests := []struct {
+		name        string
+		path        string
+		kind        Kind
+		discType    string
+		contentRoot string
+		bdmvRoot    string
+		dvdRoot     string
+	}{
+		{
+name: "file",
+ path: filePath,
+ kind: KindFile,
+ contentRoot: filePath,
+},
+		{
+name: "ordinary directory",
+ path: ordinary,
+ kind: KindDirectory,
+ contentRoot: ordinary,
+},
+		{
+name: "disc parent",
+ path: discParent + string(filepath.Separator),
+ kind: KindDiscParent,
+ discType: "BDMV",
+ contentRoot: bdmvRoot,
+ bdmvRoot: bdmvRoot,
+},
+		{
+name: "direct BDMV root",
+ path: bdmvRoot,
+ kind: KindDiscRoot,
+ discType: "BDMV",
+ contentRoot: bdmvRoot,
+ bdmvRoot: bdmvRoot,
+},
+		{
+name: "DVD parent",
+ path: dvdParent,
+ kind: KindDiscParent,
+ discType: "DVD",
+ contentRoot: dvdRoot,
+ dvdRoot: dvdRoot,
+},
+		{
+name: "direct DVD root",
+ path: dvdRoot,
+ kind: KindDiscRoot,
+ discType: "DVD",
+ contentRoot: dvdRoot,
+ dvdRoot: dvdRoot,
+},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			layout, err := Resolve(context.Background(), test.path)
+			if err != nil {
+				t.Fatalf("resolve source: %v", err)
+			}
+			if layout.Kind != test.kind || layout.DiscType != test.discType {
+				t.Fatalf("layout kind/disc = %s/%s, want %s/%s", layout.Kind, layout.DiscType, test.kind, test.discType)
+			}
+			assertSamePath(t, layout.ContentRoot, test.contentRoot)
+			assertSamePath(t, layout.BDMVRoot, test.bdmvRoot)
+			assertSamePath(t, layout.DVDRoot, test.dvdRoot)
+			assertSamePath(t, layout.SourcePath, filepath.Clean(test.path))
+		})
+	}
+}
+
+func TestResolveWindowsPathCasing(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("host filesystem is case-sensitive")
+	}
+	root := t.TempDir()
+	bdmvRoot := filepath.Join(root, "BDMV")
+	if err := os.MkdirAll(bdmvRoot, 0o700); err != nil {
+		t.Fatalf("create BDMV source: %v", err)
+	}
+	layout, err := Resolve(context.Background(), filepath.Join(root, "bdmv"))
+	if err != nil {
+		t.Fatalf("resolve differently cased source: %v", err)
+	}
+	if layout.Kind != KindDiscRoot || layout.DiscType != "BDMV" {
+		t.Fatalf("layout = %#v", layout)
+	}
+}
+
+func TestResolveRejectsMissingAndCanceledSources(t *testing.T) {
+	t.Parallel()
+
+	if _, err := Resolve(context.Background(), filepath.Join(t.TempDir(), "missing")); !errors.Is(err, ErrSourceNotFound) {
+		t.Fatalf("missing source error = %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := Resolve(ctx, t.TempDir()); !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled source error = %v", err)
+	}
+}
+
+func assertSamePath(t *testing.T, got string, want string) {
+	t.Helper()
+	if got == "" || want == "" {
+		if got != want {
+			t.Fatalf("path = %q, want %q", got, want)
+		}
+		return
+	}
+	if !pathutil.SamePath(got, want) {
+		t.Fatalf("path = %q, want %q", got, want)
+	}
+}
diff --git a/internal/torrent/metainfo/comment.go b/internal/torrent/metainfo/comment.go
new file mode 100644
index 00000000..00fd2fd1
--- /dev/null
+++ b/internal/torrent/metainfo/comment.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package metainfo defines application-owned torrent metainfo values.
+package metainfo
+
+const (
+	// UploadCreatedBy identifies torrents uploaded directly by upbrr.
+	UploadCreatedBy = "uploaded with upbrr"
+	// MkbrrUploadCreatedBy identifies upbrr uploads whose torrent was created by mkbrr.
+	MkbrrUploadCreatedBy = UploadCreatedBy + " using mkbrr"
+	// UploadCommentFallback is used when no tracker-specific torrent comment is available.
+	UploadCommentFallback = "upbrr"
+)
diff --git a/internal/torrent/policy.go b/internal/torrent/policy.go
index 7f0d2faa..17a589cb 100644
--- a/internal/torrent/policy.go
+++ b/internal/torrent/policy.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/anacrolix/torrent/metainfo"
 
+	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -17,6 +18,8 @@ type pieceSizeRange struct {
 	pieceExp uint
 }
 
+// trackerTorrentPolicy contains the metainfo limits enforced during both
+// candidate reuse and torrent creation for one tracker.
 type trackerTorrentPolicy struct {
 	name            string
 	maxPieceExp     uint
@@ -24,9 +27,21 @@ type trackerTorrentPolicy struct {
 	maxTorrentBytes int64
 }
 
-func resolveTrackerPolicy(meta api.PreparedMetadata) *trackerTorrentPolicy {
-	if hasTracker(meta.Trackers, []string{"ANT"}) {
-		return antTorrentPolicy()
+// resolveTrackerPolicy uses the first registered artifact policy in subject
+// tracker order. When none match, the legacy PTP size chart applies if PTP is
+// present anywhere in the subject tracker list.
+func resolveTrackerPolicy(meta api.TorrentSubject, registry *trackers.Registry) *trackerTorrentPolicy {
+	for _, name := range meta.Trackers {
+		artifact, ok := registry.LookupArtifactPolicy(name)
+		if !ok {
+			continue
+		}
+		maxPieceExp, _ := pieceExpForMiB(artifact.MaxPieceSizeMiB)
+		return &trackerTorrentPolicy{
+			name:            strings.ToUpper(strings.TrimSpace(name)),
+			maxPieceExp:     maxPieceExp,
+			maxTorrentBytes: artifact.MaxTorrentBytes,
+		}
 	}
 	if hasTracker(meta.Trackers, []string{"PTP"}) {
 		return &trackerTorrentPolicy{
@@ -45,16 +60,10 @@ func resolveTrackerPolicy(meta api.PreparedMetadata) *trackerTorrentPolicy {
 			},
 		}
 	}
-	if hasTracker(meta.Trackers, []string{"HDB"}) {
-		return &trackerTorrentPolicy{
-			name:        "HDB",
-			maxPieceExp: 24,
-		}
-	}
 	return nil
 }
 
-func (p *trackerTorrentPolicy) createOptions(meta api.PreparedMetadata) mkbrrPieceOptions {
+func (p *trackerTorrentPolicy) createOptions(meta api.TorrentSubject) mkbrrPieceOptions {
 	if p == nil {
 		return applyTorrentOverridePieceOptions(meta, mkbrrPieceOptions{maxPieceExp: 27})
 	}
@@ -68,7 +77,7 @@ func (p *trackerTorrentPolicy) createOptions(meta api.PreparedMetadata) mkbrrPie
 	return applyTorrentOverridePieceOptions(meta, options)
 }
 
-func (p *trackerTorrentPolicy) requiredPieceExp(meta api.PreparedMetadata) (uint, bool) {
+func (p *trackerTorrentPolicy) requiredPieceExp(meta api.TorrentSubject) (uint, bool) {
 	if p == nil || len(p.pieceSizeChart) == 0 {
 		return 0, false
 	}
@@ -84,7 +93,7 @@ func (p *trackerTorrentPolicy) requiredPieceExp(meta api.PreparedMetadata) (uint
 	return 0, false
 }
 
-func (p *trackerTorrentPolicy) validateTorrent(path string, meta api.PreparedMetadata) error {
+func (p *trackerTorrentPolicy) validateTorrent(path string, meta api.TorrentSubject) error {
 	if p == nil || strings.TrimSpace(path) == "" {
 		return nil
 	}
@@ -121,7 +130,7 @@ type mkbrrPieceOptions struct {
 	pieceExp    *uint
 }
 
-func applyTorrentOverridePieceOptions(meta api.PreparedMetadata, options mkbrrPieceOptions) mkbrrPieceOptions {
+func applyTorrentOverridePieceOptions(meta api.TorrentSubject, options mkbrrPieceOptions) mkbrrPieceOptions {
 	if meta.TorrentOverrides.MaxPieceSizeMiB == nil {
 		return options
 	}
diff --git a/internal/torrent/policy_ant.go b/internal/torrent/policy_ant.go
deleted file mode 100644
index 1101f870..00000000
--- a/internal/torrent/policy_ant.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package torrent
-
-import (
-	"fmt"
-	"os"
-)
-
-const antMaxTorrentBytes int64 = 250 << 10
-
-func antTorrentPolicy() *trackerTorrentPolicy {
-	return &trackerTorrentPolicy{
-		name:            "ANT",
-		maxPieceExp:     27,
-		maxTorrentBytes: antMaxTorrentBytes,
-	}
-}
-
-func validateTorrentFileSize(path string, policy *trackerTorrentPolicy) error {
-	if policy == nil || policy.maxTorrentBytes <= 0 {
-		return nil
-	}
-	info, err := os.Stat(path)
-	if err != nil {
-		return fmt.Errorf("stat torrent %q: %w", path, err)
-	}
-	if info.Size() > policy.maxTorrentBytes {
-		return fmt.Errorf("%s torrent file size %d exceeds max %d", policy.name, info.Size(), policy.maxTorrentBytes)
-	}
-	return nil
-}
diff --git a/internal/torrent/policy_file.go b/internal/torrent/policy_file.go
new file mode 100644
index 00000000..6260ea7d
--- /dev/null
+++ b/internal/torrent/policy_file.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package torrent
+
+import (
+	"fmt"
+	"os"
+)
+
+func validateTorrentFileSize(path string, policy *trackerTorrentPolicy) error {
+	if policy == nil || policy.maxTorrentBytes <= 0 {
+		return nil
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		return fmt.Errorf("stat torrent %q: %w", path, err)
+	}
+	if info.Size() > policy.maxTorrentBytes {
+		return fmt.Errorf("%s torrent file size %d exceeds max %d", policy.name, info.Size(), policy.maxTorrentBytes)
+	}
+	return nil
+}
diff --git a/internal/torrent/service.go b/internal/torrent/service.go
index ee7ac801..ee556347 100644
--- a/internal/torrent/service.go
+++ b/internal/torrent/service.go
@@ -1,6 +1,8 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+// Package torrent validates reusable torrent metadata or creates private
+// torrent artifacts for prepared source layouts.
 package torrent
 
 import (
@@ -20,26 +22,54 @@ import (
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/torrentmeta"
+	torrentmeta "github.com/autobrr/upbrr/internal/torrent/metainfo"
+	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Service selects or creates torrent artifacts under a configured temporary
+// root. Callers must not mutate its registry concurrently with use.
 type Service struct {
-	logger  api.Logger
-	tmpRoot string
+	logger   api.Logger
+	tmpRoot  string
+	registry *trackers.Registry
 }
 
+// NewService returns a service with legacy built-in PTP policy fallback.
+// A nil logger is replaced with [api.NopLogger].
 func NewService(logger api.Logger, tmpRoot string) *Service {
+	return NewServiceWithRegistry(logger, tmpRoot, nil)
+}
+
+// NewServiceWithRegistry returns a service that prefers the first registered
+// tracker artifact policy in request order. A nil registry leaves only legacy
+// policy fallback available; tmpRoot is trimmed and may be empty until an
+// operation needs a release-specific temporary path.
+func NewServiceWithRegistry(logger api.Logger, tmpRoot string, registry *trackers.Registry) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
-	return &Service{logger: logger, tmpRoot: strings.TrimSpace(tmpRoot)}
+	return &Service{
+		logger:   logger,
+		tmpRoot:  strings.TrimSpace(tmpRoot),
+		registry: registry,
+	}
 }
 
-func (s *Service) Create(ctx context.Context, meta api.PreparedMetadata) (api.TorrentResult, error) {
+// Create returns the first reusable torrent in client, source, temporary, then
+// adjacent-path order, unless Rehash requests a new artifact. Reused candidates
+// are checked against tracker policy and source names, paths, and lengths; their
+// pieces are not rehashed against source bytes. NoHash fails when none qualify,
+// while Rehash takes precedence when both overrides are enabled.
+//
+// New artifacts are private, written below the configured temporary root, and
+// may use a temporary hardlink-or-copy staging tree for selected files. Staging
+// cleanup is attempted before return. Cancellation is checked before selection
+// and creation but does not interrupt mkbrr after hashing starts.
+func (s *Service) Create(ctx context.Context, meta api.TorrentSubject) (api.TorrentResult, error) {
 	select {
 	case <-ctx.Done():
 		return api.TorrentResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
@@ -53,7 +83,7 @@ func (s *Service) Create(ctx context.Context, meta api.PreparedMetadata) (api.To
 	meta.SourcePath = source
 
 	s.logger.Debugf("torrent: preparing for %s", source)
-	policy := resolveTrackerPolicy(meta)
+	policy := resolveTrackerPolicy(meta, s.registry)
 	forceRehash := torrentOverrideEnabled(meta.TorrentOverrides.Rehash)
 	reuseOnly := torrentOverrideEnabled(meta.TorrentOverrides.NoHash)
 	if forceRehash && reuseOnly {
@@ -92,7 +122,7 @@ func (s *Service) Create(ctx context.Context, meta api.PreparedMetadata) (api.To
 	}
 
 	if !forceRehash && s.tmpRoot != "" {
-		tmpTorrentPath, err := TempTorrentPath(s.tmpRoot, meta, source)
+		tmpTorrentPath, err := TempTorrentPath(s.tmpRoot, source)
 		if err != nil {
 			return api.TorrentResult{}, err
 		}
@@ -145,7 +175,13 @@ func (s *Service) Create(ctx context.Context, meta api.PreparedMetadata) (api.To
 	if err != nil {
 		return api.TorrentResult{}, err
 	}
-	s.logger.Debugf("torrent: create spec path=%s name=%q include_patterns=%d staged=%t", createSpec.path, createSpec.name, len(createSpec.includePatterns), createSpec.cleanupPath != "")
+	s.logger.Debugf(
+		"torrent: create spec path=%s name=%q include_patterns=%d staged=%t",
+		createSpec.path,
+		createSpec.name,
+		len(createSpec.includePatterns),
+		createSpec.cleanupPath != "",
+	)
 	if createSpec.cleanupPath != "" {
 		defer func() {
 			if err := os.RemoveAll(createSpec.cleanupPath); err != nil {
@@ -169,7 +205,7 @@ func (s *Service) Create(ctx context.Context, meta api.PreparedMetadata) (api.To
 	if s.tmpRoot == "" {
 		return api.TorrentResult{}, errors.New("torrent: tmp root is required")
 	}
-	outputPath, err := TempTorrentPath(s.tmpRoot, meta, source)
+	outputPath, err := TempTorrentPath(s.tmpRoot, source)
 	if err != nil {
 		return api.TorrentResult{}, err
 	}
@@ -228,7 +264,7 @@ func setCreatedBy(path string, createdBy string) error {
 	return nil
 }
 
-func resultFromExistingTorrent(ctx context.Context, meta api.PreparedMetadata, path string, message string) (api.TorrentResult, error) {
+func resultFromExistingTorrent(ctx context.Context, meta api.TorrentSubject, path string, message string) (api.TorrentResult, error) {
 	result, err := resultFromPath(path)
 	if err != nil {
 		return api.TorrentResult{}, err
@@ -237,11 +273,11 @@ func resultFromExistingTorrent(ctx context.Context, meta api.PreparedMetadata, p
 	return result, nil
 }
 
-func emitTorrentProgress(ctx context.Context, meta api.PreparedMetadata, status string, message string) {
+func emitTorrentProgress(ctx context.Context, meta api.TorrentSubject, status string, message string) {
 	emitTorrentHashProgress(ctx, meta, status, message, 0, 0, 0)
 }
 
-func torrentProgressCallback(ctx context.Context, meta api.PreparedMetadata) mkbrr.ProgressCallback {
+func torrentProgressCallback(ctx context.Context, meta api.TorrentSubject) mkbrr.ProgressCallback {
 	return func(completed, total int, hashRate float64) {
 		if total <= 0 {
 			emitTorrentHashProgress(ctx, meta, "running", "Preparing torrent pieces", completed, total, hashRate)
@@ -260,7 +296,7 @@ func torrentProgressCallback(ctx context.Context, meta api.PreparedMetadata) mkb
 	}
 }
 
-func emitTorrentHashProgress(ctx context.Context, meta api.PreparedMetadata, status string, message string, completed int, total int, hashRate float64) {
+func emitTorrentHashProgress(ctx context.Context, meta api.TorrentSubject, status string, message string, completed int, total int, hashRate float64) {
 	tracker := ""
 	if len(meta.Trackers) == 1 {
 		tracker = meta.Trackers[0]
@@ -300,7 +336,7 @@ func torrentOverrideEnabled(value *bool) bool {
 // validateCandidateTorrent checks an existing torrent against the active
 // tracker policy and prepared source layout. Expected candidate rejection is
 // logged at debug level so discovery can continue without operator warnings.
-func validateCandidateTorrent(path string, policy *trackerTorrentPolicy, meta api.PreparedMetadata, logger api.Logger) error {
+func validateCandidateTorrent(path string, policy *trackerTorrentPolicy, meta api.TorrentSubject, logger api.Logger) error {
 	if policy != nil {
 		if err := policy.validateTorrent(path, meta); err != nil {
 			if logger != nil {
@@ -337,7 +373,7 @@ type sourceContentFile struct {
 	contentFile
 }
 
-func resolveCreateSpec(meta api.PreparedMetadata, source string, tmpRoot string) (createSpec, error) {
+func resolveCreateSpec(meta api.TorrentSubject, source string, tmpRoot string) (createSpec, error) {
 	source = strings.TrimSpace(source)
 	if source == "" {
 		return createSpec{}, internalerrors.ErrInvalidInput
@@ -577,7 +613,7 @@ func globLiteral(value string) string {
 	return "{" + builder.String() + "}"
 }
 
-func validateTorrentContent(path string, meta api.PreparedMetadata) error {
+func validateTorrentContent(path string, meta api.TorrentSubject) error {
 	expectedFiles, ok, err := expectedTorrentFiles(meta)
 	if err != nil {
 		return err
@@ -611,7 +647,7 @@ func validateTorrentContent(path string, meta api.PreparedMetadata) error {
 	return nil
 }
 
-func expectedTorrentFiles(meta api.PreparedMetadata) ([]sourceContentFile, bool, error) {
+func expectedTorrentFiles(meta api.TorrentSubject) ([]sourceContentFile, bool, error) {
 	source := strings.TrimSpace(meta.SourcePath)
 	if source == "" || strings.EqualFold(filepath.Ext(source), ".torrent") {
 		return nil, false, nil
@@ -671,7 +707,7 @@ func expectedTorrentFiles(meta api.PreparedMetadata) ([]sourceContentFile, bool,
 	return expected, true, nil
 }
 
-func expectedTorrentName(meta api.PreparedMetadata) (string, bool, error) {
+func expectedTorrentName(meta api.TorrentSubject) (string, bool, error) {
 	source := strings.TrimSpace(meta.SourcePath)
 	if source == "" || strings.EqualFold(filepath.Ext(source), ".torrent") {
 		return "", false, nil
@@ -823,8 +859,10 @@ func sortContentFiles(files []contentFile) {
 	})
 }
 
-func TempTorrentPath(tmpRoot string, meta api.PreparedMetadata, source string) (string, error) {
-	contentDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, source)
+// TempTorrentPath creates the release-specific directory below tmpRoot with
+// mode 0700 when missing and returns its deterministic .torrent path.
+func TempTorrentPath(tmpRoot string, source string) (string, error) {
+	contentDir, base, err := paths.ReleaseTempDirFor(tmpRoot, source, api.ReleaseInfo{})
 	if err != nil {
 		return "", fmt.Errorf("torrent: tmp dir: %w", err)
 	}
diff --git a/internal/torrent/service_test.go b/internal/torrent/service_test.go
index a09e2be3..9580d182 100644
--- a/internal/torrent/service_test.go
+++ b/internal/torrent/service_test.go
@@ -20,9 +20,13 @@ import (
 	mkbrr "github.com/autobrr/mkbrr/torrent"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ant"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+const antMaxTorrentBytesForTest int64 = 250 << 10
+
 func TestCreateReusesTorrent(t *testing.T) {
 	t.Parallel()
 
@@ -32,7 +36,7 @@ func TestCreateReusesTorrent(t *testing.T) {
 	createTestTorrent(t, contentPath, torrentPath)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{SourcePath: torrentPath})
+	result, err := service.Create(context.Background(), api.TorrentSubject{SourcePath: torrentPath})
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -53,7 +57,7 @@ func TestCreateFallbacksToSibling(t *testing.T) {
 	createTestTorrent(t, source, sibling)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{SourcePath: source})
+	result, err := service.Create(context.Background(), api.TorrentSubject{SourcePath: source})
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -69,7 +73,7 @@ func TestCreateMissingTorrent(t *testing.T) {
 	t.Parallel()
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	_, err := service.Create(context.Background(), api.PreparedMetadata{SourcePath: "/missing/file.mkv"})
+	_, err := service.Create(context.Background(), api.TorrentSubject{SourcePath: "/missing/file.mkv"})
 	if !errors.Is(err, internalerrors.ErrNotFound) {
 		t.Fatalf("expected not found error, got %v", err)
 	}
@@ -84,7 +88,7 @@ func TestCreateEmptySourceDoesNotEmitProgress(t *testing.T) {
 	})
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	_, err := service.Create(ctx, api.PreparedMetadata{SourcePath: " \t "})
+	_, err := service.Create(ctx, api.TorrentSubject{SourcePath: " \t "})
 	if !errors.Is(err, internalerrors.ErrInvalidInput) {
 		t.Fatalf("expected invalid input, got %v", err)
 	}
@@ -104,7 +108,7 @@ func TestCreateNewTorrent(t *testing.T) {
 
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
-	result, err := service.Create(context.Background(), api.PreparedMetadata{SourcePath: source})
+	result, err := service.Create(context.Background(), api.TorrentSubject{SourcePath: source})
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -146,7 +150,7 @@ func TestCreateHonorsMaxPieceSizeOverride(t *testing.T) {
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
 	maxPiece := 1
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: source,
 		TorrentOverrides: api.TorrentOverrides{
 			MaxPieceSizeMiB: &maxPiece,
@@ -179,9 +183,8 @@ func TestCreateFolderWithSingleWantedVideoHashesFile(t *testing.T) {
 	writeTestFile(t, filepath.Join(sourceDir, "proof.jpg"), "proof")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  video,
 		FileList:   []string{video},
 	})
 	if err != nil {
@@ -209,9 +212,8 @@ func TestCreateFolderPackUsesWantedFileList(t *testing.T) {
 	writeTestFile(t, filepath.Join(sourceDir, "proof.jpg"), "proof")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  episode1,
 		FileList:   []string{episode1, episode2},
 	})
 	if err != nil {
@@ -234,9 +236,8 @@ func TestCreateFolderPackRejectsMissingWantedFile(t *testing.T) {
 	writeTestFile(t, episode1, "episode 1")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  episode1,
 		FileList:   []string{missing},
 	})
 	if !errors.Is(err, internalerrors.ErrNotFound) {
@@ -253,9 +254,8 @@ func TestCreateFolderPackRejectsPartialMissingWantedFile(t *testing.T) {
 	writeTestFile(t, episode1, "episode 1")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  episode1,
 		FileList:   []string{episode1, missing},
 	})
 	if !errors.Is(err, internalerrors.ErrNotFound) {
@@ -275,9 +275,8 @@ func TestCreateFolderPackEscapesWantedFilePatterns(t *testing.T) {
 	writeTestFile(t, filepath.Join(sourceDir, "Show.S01E03.mkv"), "extra")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  episode1,
 		FileList:   []string{episode1, episode2},
 	})
 	if err != nil {
@@ -298,10 +297,9 @@ func TestCreateDiscFolderIgnoresWantedFileList(t *testing.T) {
 	writeTestFile(t, filepath.Join(sourceDir, "CERTIFICATE", "id.bdmv"), "certificate")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
 		DiscType:   "BDMV",
-		VideoPath:  stream,
 		FileList:   []string{stream},
 	})
 	if err != nil {
@@ -366,10 +364,9 @@ func TestCreateDiscMarkerFolderUsesSelectedRoot(t *testing.T) {
 			writeTestFile(t, filepath.Join(parent, "outside.txt"), "outside")
 
 			service := NewService(api.NopLogger{}, t.TempDir())
-			result, err := service.Create(context.Background(), api.PreparedMetadata{
+			result, err := service.Create(context.Background(), api.TorrentSubject{
 				SourcePath: sourceDir,
 				DiscType:   tt.discType,
-				VideoPath:  filepath.Join(sourceDir, tt.files[0]),
 				FileList:   []string{filepath.Join(sourceDir, tt.files[0])},
 			})
 			if err != nil {
@@ -402,7 +399,7 @@ func TestCreateFolderSkipsMkbrrIgnoredFilesInValidation(t *testing.T) {
 	writeTestFile(t, filepath.Join(sourceDir, "@eaDir", "metadata.bin"), "ignored")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
 	})
 	if err != nil {
@@ -437,7 +434,7 @@ func TestCreateNoHashRequiresReusableTorrent(t *testing.T) {
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: source,
 		TorrentOverrides: api.TorrentOverrides{
 			NoHash: &reuseOnly,
@@ -460,7 +457,7 @@ func TestCreateNoHashReusesExactCaseClientTorrent(t *testing.T) {
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -493,7 +490,7 @@ func TestCreateNoHashRejectsCaseOnlySingleFileClientTorrent(t *testing.T) {
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -527,9 +524,8 @@ func TestCreateNoHashRejectsCaseOnlyMultiFileClientTorrent(t *testing.T) {
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        sourceDir,
-		VideoPath:         episode1,
 		FileList:          []string{episode1, episode2},
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -552,13 +548,13 @@ func TestCreateNoHashReusesPureV2ClientTorrent(t *testing.T) {
 	}
 	clientTorrentPath := filepath.Join(dir, "client.torrent")
 	createPureV2TestTorrent(t, source, content, clientTorrentPath)
-	if err := validateTorrentContent(clientTorrentPath, api.PreparedMetadata{SourcePath: source}); err != nil {
+	if err := validateTorrentContent(clientTorrentPath, api.TorrentSubject{SourcePath: source}); err != nil {
 		t.Fatalf("expected pure v2 torrent to validate, got %v", err)
 	}
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -586,7 +582,7 @@ func TestCreateNoHashReusesPureV2ZeroLengthClientTorrent(t *testing.T) {
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -615,7 +611,7 @@ func TestCreateNoHashReusesPureV2SameNameSameSizeDifferentContent(t *testing.T)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -642,7 +638,7 @@ func TestValidateTorrentContentAllowsPureV2NonEmptyFileWithoutPiecesRoot(t *test
 	clientTorrentPath := filepath.Join(dir, "client.torrent")
 	createPureV2TestTorrentWithPiecesRoot(t, source, content, clientTorrentPath, false)
 
-	err := validateTorrentContent(clientTorrentPath, api.PreparedMetadata{SourcePath: source})
+	err := validateTorrentContent(clientTorrentPath, api.TorrentSubject{SourcePath: source})
 	if err != nil {
 		t.Fatalf("expected metadata-only validation to pass, got %v", err)
 	}
@@ -663,7 +659,7 @@ func TestCreateNoHashReusesSameNameSameSizeDifferentContentTorrent(t *testing.T)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
 	reuseOnly := true
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 		TorrentOverrides: api.TorrentOverrides{
@@ -689,9 +685,9 @@ func TestCreateRehashBypassesReusableTempTorrent(t *testing.T) {
 
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
-	meta := api.PreparedMetadata{SourcePath: source}
+	meta := api.TorrentSubject{SourcePath: source}
 
-	tmpTorrentPath, err := TempTorrentPath(tmpRoot, meta, source)
+	tmpTorrentPath, err := TempTorrentPath(tmpRoot, source)
 	if err != nil {
 		t.Fatalf("temp torrent path: %v", err)
 	}
@@ -723,22 +719,22 @@ func TestCreateRehashBypassesReusableTempTorrent(t *testing.T) {
 func TestCreateRehashOverridesNoHashReusableTorrents(t *testing.T) {
 	t.Parallel()
 
-	cases := map[string]func(t *testing.T, source string, tmpTorrentPath string) (api.PreparedMetadata, string){
-		"client": func(t *testing.T, source string, _ string) (api.PreparedMetadata, string) {
+	cases := map[string]func(t *testing.T, source string, tmpTorrentPath string) (api.TorrentSubject, string){
+		"client": func(t *testing.T, source string, _ string) (api.TorrentSubject, string) {
 			t.Helper()
 
 			clientTorrentPath := filepath.Join(filepath.Dir(source), "client.torrent")
 			createTestTorrentFromExisting(t, source, clientTorrentPath)
-			return api.PreparedMetadata{SourcePath: source, ClientTorrentPath: clientTorrentPath}, clientTorrentPath
+			return api.TorrentSubject{SourcePath: source, ClientTorrentPath: clientTorrentPath}, clientTorrentPath
 		},
-		"adjacent": func(t *testing.T, source string, _ string) (api.PreparedMetadata, string) {
+		"adjacent": func(t *testing.T, source string, _ string) (api.TorrentSubject, string) {
 			t.Helper()
 
 			adjacentTorrentPath := source + ".torrent"
 			createTestTorrentFromExisting(t, source, adjacentTorrentPath)
-			return api.PreparedMetadata{SourcePath: source}, adjacentTorrentPath
+			return api.TorrentSubject{SourcePath: source}, adjacentTorrentPath
 		},
-		"temp": func(t *testing.T, source string, tmpTorrentPath string) (api.PreparedMetadata, string) {
+		"temp": func(t *testing.T, source string, tmpTorrentPath string) (api.TorrentSubject, string) {
 			t.Helper()
 
 			createTestTorrentFromExisting(t, source, tmpTorrentPath)
@@ -746,7 +742,7 @@ func TestCreateRehashOverridesNoHashReusableTorrents(t *testing.T) {
 			if err := os.Chtimes(tmpTorrentPath, past, past); err != nil {
 				t.Fatalf("chtimes: %v", err)
 			}
-			return api.PreparedMetadata{SourcePath: source}, tmpTorrentPath
+			return api.TorrentSubject{SourcePath: source}, tmpTorrentPath
 		},
 	}
 
@@ -762,7 +758,7 @@ func TestCreateRehashOverridesNoHashReusableTorrents(t *testing.T) {
 
 			tmpRoot := t.TempDir()
 			service := NewService(api.NopLogger{}, tmpRoot)
-			tmpTorrentPath, err := TempTorrentPath(tmpRoot, api.PreparedMetadata{SourcePath: source}, source)
+			tmpTorrentPath, err := TempTorrentPath(tmpRoot, source)
 			if err != nil {
 				t.Fatalf("temp torrent path: %v", err)
 			}
@@ -832,7 +828,7 @@ func TestApplyTorrentOverridePieceOptionsKeepsUserMax(t *testing.T) {
 	maxPiece := 16
 	requiredExp := uint(26)
 
-	options := applyTorrentOverridePieceOptions(api.PreparedMetadata{
+	options := applyTorrentOverridePieceOptions(api.TorrentSubject{
 		TorrentOverrides: api.TorrentOverrides{
 			MaxPieceSizeMiB: &maxPiece,
 		},
@@ -854,7 +850,7 @@ func TestApplyTorrentOverridePieceOptionsCapsToTrackerMax(t *testing.T) {
 
 	maxPiece := 128
 
-	options := applyTorrentOverridePieceOptions(api.PreparedMetadata{
+	options := applyTorrentOverridePieceOptions(api.TorrentSubject{
 		TorrentOverrides: api.TorrentOverrides{
 			MaxPieceSizeMiB: &maxPiece,
 		},
@@ -879,8 +875,8 @@ func TestCreateReusesAssociatedTempTorrent(t *testing.T) {
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
 
-	meta := api.PreparedMetadata{SourcePath: source}
-	tmpTorrentPath, err := TempTorrentPath(tmpRoot, meta, source)
+	meta := api.TorrentSubject{SourcePath: source}
+	tmpTorrentPath, err := TempTorrentPath(tmpRoot, source)
 	if err != nil {
 		t.Fatalf("temp torrent path: %v", err)
 	}
@@ -909,9 +905,9 @@ func TestCreatePrefersClientTorrentOverAssociatedTempTorrent(t *testing.T) {
 
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
-	meta := api.PreparedMetadata{SourcePath: source}
+	meta := api.TorrentSubject{SourcePath: source}
 
-	tmpTorrentPath, err := TempTorrentPath(tmpRoot, meta, source)
+	tmpTorrentPath, err := TempTorrentPath(tmpRoot, source)
 	if err != nil {
 		t.Fatalf("temp torrent path: %v", err)
 	}
@@ -942,9 +938,9 @@ func TestCreateRejectsMismatchedClientTorrent(t *testing.T) {
 
 	tmpRoot := t.TempDir()
 	service := NewService(api.NopLogger{}, tmpRoot)
-	meta := api.PreparedMetadata{SourcePath: source}
+	meta := api.TorrentSubject{SourcePath: source}
 
-	tmpTorrentPath, err := TempTorrentPath(tmpRoot, meta, source)
+	tmpTorrentPath, err := TempTorrentPath(tmpRoot, source)
 	if err != nil {
 		t.Fatalf("temp torrent path: %v", err)
 	}
@@ -978,7 +974,7 @@ func TestCreateRejectsSameNameDifferentSizeClientTorrent(t *testing.T) {
 	createTestTorrentFromExisting(t, clientSource, clientTorrentPath)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 	})
@@ -1004,7 +1000,7 @@ func TestCreateReusesSameNameSameSizeDifferentContentClientTorrent(t *testing.T)
 	createTestTorrentFromExisting(t, clientSource, clientTorrentPath)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		ClientTorrentPath: clientTorrentPath,
 	})
@@ -1033,9 +1029,8 @@ func TestCreateRejectsDifferentRootClientTorrent(t *testing.T) {
 	createTestTorrentFromExisting(t, clientDir, clientTorrentPath)
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        sourceDir,
-		VideoPath:         episode1,
 		FileList:          []string{episode1, episode2},
 		ClientTorrentPath: clientTorrentPath,
 	})
@@ -1057,9 +1052,8 @@ func TestCreateRejectsWantedFileOutsideRoot(t *testing.T) {
 	writeTestFile(t, outside, "outside")
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	_, err := service.Create(context.Background(), api.PreparedMetadata{
+	_, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath: sourceDir,
-		VideoPath:  video,
 		FileList:   []string{outside},
 	})
 	if err == nil {
@@ -1090,7 +1084,7 @@ func TestCreateRegeneratesNonCompliantPTPTorrent(t *testing.T) {
 	}
 
 	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		SourceSize:        int64(len(content)),
 		Trackers:          []string{"PTP"},
@@ -1142,8 +1136,8 @@ func TestPTPPiecePolicyBoundaries(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		meta := api.PreparedMetadata{Trackers: []string{"PTP"}, SourceSize: int64(tc.size)}
-		policy := resolveTrackerPolicy(meta)
+		meta := api.TorrentSubject{Trackers: []string{"PTP"}, SourceSize: int64(tc.size)}
+		policy := resolveTrackerPolicy(meta, nil)
 		got, ok := policy.requiredPieceExp(meta)
 		if !ok {
 			t.Fatalf("expected piece exponent for size %d", tc.size)
@@ -1188,12 +1182,16 @@ func TestCreateRegeneratesOversizedANTTorrent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("stat client torrent: %v", err)
 	}
-	if info.Size() <= antMaxTorrentBytes {
+	if info.Size() <= antMaxTorrentBytesForTest {
 		t.Fatalf("expected oversized ANT torrent fixture, got %d bytes", info.Size())
 	}
 
-	service := NewService(api.NopLogger{}, t.TempDir())
-	result, err := service.Create(context.Background(), api.PreparedMetadata{
+	registry := trackers.NewRegistry()
+	if err := registry.Register(ant.New()); err != nil {
+		t.Fatalf("register ANT: %v", err)
+	}
+	service := NewServiceWithRegistry(api.NopLogger{}, t.TempDir(), registry)
+	result, err := service.Create(context.Background(), api.TorrentSubject{
 		SourcePath:        source,
 		SourceSize:        sourceSize,
 		Trackers:          []string{"ANT"},
@@ -1209,8 +1207,8 @@ func TestCreateRegeneratesOversizedANTTorrent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("stat regenerated torrent: %v", err)
 	}
-	if regenerated.Size() > antMaxTorrentBytes {
-		t.Fatalf("expected regenerated torrent <= %d bytes, got %d", antMaxTorrentBytes, regenerated.Size())
+	if regenerated.Size() > antMaxTorrentBytesForTest {
+		t.Fatalf("expected regenerated torrent <= %d bytes, got %d", antMaxTorrentBytesForTest, regenerated.Size())
 	}
 }
 
diff --git a/internal/clients/linking.go b/internal/torrentclient/linking.go
similarity index 86%
rename from internal/clients/linking.go
rename to internal/torrentclient/linking.go
index 7d1d425b..9a8f5051 100644
--- a/internal/clients/linking.go
+++ b/internal/torrentclient/linking.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package clients
+package torrentclient
 
 import (
 	"bytes"
@@ -17,7 +17,8 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	"github.com/autobrr/upbrr/internal/logging"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -33,12 +34,16 @@ type linkStagingResult struct {
 	Cleanup         *linkStagingCleanup
 }
 
+// linkStagingCleanup records the staged destination to remove when client
+// injection fails and whether its now-empty tracker directory may also be removed.
 type linkStagingCleanup struct {
 	TrackerDir       string
 	Dest             string
 	RemoveTrackerDir bool
 }
 
+// Run removes the staged destination after proving it is a child of TrackerDir.
+// It removes TrackerDir only when requested and the directory is empty.
 func (c *linkStagingCleanup) Run() error {
 	if c == nil {
 		return nil
@@ -85,14 +90,20 @@ var createReflink = reflinkFile
 // prepareLinkStaging creates a client-visible staging tree for the final local
 // torrent artifact. It uses the torrent's metainfo layout, validates staged
 // files before returning, and maps the containing directory to the qBittorrent
-// host path. URL-only or invalid layouts fall back only when the client permits
-// it; every original-path fallback requires qBittorrent to verify content.
-// Cancellation during metainfo planning returns a wrapped context error instead
-// of falling back.
-func (s *Service) prepareLinkStaging(ctx context.Context, clientName string, client config.TorrentClientConfig, meta api.PreparedMetadata, torrent api.TorrentResult) (linkStagingResult, error) {
+// host path. URL-only or invalid layouts return an unlinked original-path
+// fallback only when the client permits it. Cancellation during metainfo
+// planning returns a wrapped context error instead of falling back.
+func (s *Service) prepareLinkStaging(
+	ctx context.Context,
+	clientName string,
+	client config.TorrentClientConfig,
+	meta api.ClientSubject,
+	torrent api.TorrentResult,
+) (linkStagingResult, error) {
+	logger := logging.FromContext(ctx, s.logger)
 	mode := client.LinkingMode()
 	if mode == "" {
-		s.logger.Tracef("clients: %s link staging disabled", clientName)
+		logger.Tracef("clients: %s link staging disabled", clientName)
 		return linkStagingResult{}, nil
 	}
 	if mode != "symlink" && mode != "hardlink" && mode != "reflink" {
@@ -116,28 +127,58 @@ func (s *Service) prepareLinkStaging(ctx context.Context, clientName string, cli
 
 	var torrentPlan torrentLinkPlan
 	if torrentPath := strings.TrimSpace(torrent.Path); torrentPath != "" {
-		s.logger.Debugf("clients: inspecting injected torrent layout client=%s tracker=%s mode=%s", clientName, tracker, mode)
+		logger.Debugf("clients: inspecting injected torrent layout client=%s tracker=%s mode=%s", clientName, tracker, mode)
 		plan, err := buildTorrentLinkPlan(ctx, torrentPath, meta)
 		if err != nil {
 			if ctx.Err() != nil {
 				return linkStagingResult{}, fmt.Errorf("clients: %s plan %s staging from injected torrent: %w", clientName, mode, err)
 			}
 			if client.FallbackAllowed() {
-				s.logger.Warnf("clients: injected torrent layout validation failed client=%s tracker=%s mode=%s decision=original-path-fallback reason=%s", clientName, tracker, mode, redaction.RedactValue(err.Error(), nil))
+				logger.Warnf(
+					"clients: injected torrent layout validation failed client=%s tracker=%s mode=%s decision=original-path-fallback reason=%s",
+					clientName,
+					tracker,
+					mode,
+					redaction.RedactValue(err.Error(), nil),
+				)
 				return linkStagingResult{}, nil
 			}
 			return linkStagingResult{}, fmt.Errorf("clients: %s plan %s staging from injected torrent: %w", clientName, mode, err)
 		}
 		torrentPlan = plan
-		s.logger.Debugf("clients: injected torrent layout ready client=%s tracker=%s root=%q files=%d padding_files=%d multi_file=%t", clientName, tracker, plan.root, len(plan.files), plan.paddingFiles, plan.torrentIsMulti)
+		logger.Debugf(
+			"clients: injected torrent layout ready client=%s tracker=%s root=%q files=%d padding_files=%d multi_file=%t",
+			clientName,
+			tracker,
+			plan.root,
+			len(plan.files),
+			plan.paddingFiles,
+			plan.torrentIsMulti,
+		)
 		for _, file := range plan.files {
-			s.logger.Tracef("clients: injected torrent file mapped client=%s tracker=%s match=%s source=%s destination=%s", clientName, tracker, file.match, file.sourcePath, file.destRel)
+			logger.Tracef(
+				"clients: injected torrent file mapped client=%s tracker=%s match=%s source=%s destination=%s",
+				clientName,
+				tracker,
+				file.match,
+				file.sourcePath,
+				file.destRel,
+			)
 		}
 	} else {
 		if !client.FallbackAllowed() {
-			return linkStagingResult{}, fmt.Errorf("clients: %s cannot validate %s staging for URL-only torrent; provide a torrent file or enable allow_fallback for this client", clientName, mode)
-		}
-		s.logger.Warnf("clients: URL-only linked injection cannot inspect torrent layout client=%s tracker=%s mode=%s decision=original-path-fallback", clientName, tracker, mode)
+			return linkStagingResult{}, fmt.Errorf(
+				"clients: %s cannot validate %s staging for URL-only torrent; provide a torrent file or enable allow_fallback for this client",
+				clientName,
+				mode,
+			)
+		}
+		logger.Warnf(
+			"clients: URL-only linked injection cannot inspect torrent layout client=%s tracker=%s mode=%s decision=original-path-fallback",
+			clientName,
+			tracker,
+			mode,
+		)
 		return linkStagingResult{}, nil
 	}
 
@@ -158,13 +199,27 @@ func (s *Service) prepareLinkStaging(ctx context.Context, clientName string, cli
 			mappedPath, mapped := mappedRemotePath(trackerDir, client.LocalPath, client.RemotePath)
 			if !mapped {
 				lastErr = fmt.Errorf("clients: %s linked staging path is outside configured local_path roots: %w", clientName, internalerrors.ErrInvalidInput)
-				s.logger.Debugf("clients: linked torrent path mapping skipped client=%s tracker=%s mode=%s state=no-local-root-match tracker_dir=%s", clientName, tracker, mode, trackerDir)
+				logger.Debugf(
+					"clients: linked torrent path mapping skipped client=%s tracker=%s mode=%s state=no-local-root-match tracker_dir=%s",
+					clientName,
+					tracker,
+					mode,
+					trackerDir,
+				)
 				continue
 			}
 			mappingCandidateFound = true
 			mappingState = "matched"
 			savePath = mappedPath
-			s.logger.Debugf("clients: linked torrent path mapping ready client=%s tracker=%s mode=%s state=%s local=%s remote=%s", clientName, tracker, mode, mappingState, trackerDir, savePath)
+			logger.Debugf(
+				"clients: linked torrent path mapping ready client=%s tracker=%s mode=%s state=%s local=%s remote=%s",
+				clientName,
+				tracker,
+				mode,
+				mappingState,
+				trackerDir,
+				savePath,
+			)
 		}
 
 		trackerDirExisted, err := pathExists(trackerDir)
@@ -195,7 +250,7 @@ func (s *Service) prepareLinkStaging(ctx context.Context, clientName string, cli
 					Dest:             dest,
 					RemoveTrackerDir: !trackerDirExisted,
 				}).Run(); cleanupErr != nil {
-					s.logger.Warnf("clients: %s cleanup failed after staged link error target=%s: %v", clientName, linkTarget, cleanupErr)
+					logger.Warnf("clients: %s cleanup failed after staged link error target=%s: %v", clientName, linkTarget, cleanupErr)
 				}
 			}
 			lastErr = fmt.Errorf("clients: %s %s target %s: %w", clientName, mode, linkTarget, linkErr)
@@ -217,16 +272,30 @@ func (s *Service) prepareLinkStaging(ctx context.Context, clientName string, cli
 			FileCount:       len(torrentPlan.files),
 			Cleanup:         cleanup,
 		}
-		s.logger.Infof("clients: linked torrent staging ready client=%s tracker=%s mode=%s files=%d layout_validated=%t path_mapping=%s save_path=%s", clientName, tracker, mode, result.FileCount, result.LayoutValidated, mappingState, result.SavePath)
+		logger.Infof(
+			"clients: linked torrent staging ready client=%s tracker=%s mode=%s files=%d layout_validated=%t path_mapping=%s save_path=%s",
+			clientName,
+			tracker,
+			mode,
+			result.FileCount,
+			result.LayoutValidated,
+			mappingState,
+			result.SavePath,
+		)
 		return result, nil
 	}
 
 	if mappingRequired && !mappingCandidateFound {
-		s.logger.Warnf("clients: linked torrent path mapping blocked client=%s tracker=%s mode=%s decision=abort reason=no-local-root-match", clientName, tracker, mode)
+		logger.Warnf(
+			"clients: linked torrent path mapping blocked client=%s tracker=%s mode=%s decision=abort reason=no-local-root-match",
+			clientName,
+			tracker,
+			mode,
+		)
 		return linkStagingResult{}, lastErr
 	}
 	if client.FallbackAllowed() {
-		s.logger.Warnf("clients: %s %s failed for %s, falling back to original qbit path: %v", clientName, mode, source, lastErr)
+		logger.Warnf("clients: %s %s failed for %s, falling back to original qbit path: %v", clientName, mode, source, lastErr)
 		return linkStagingResult{}, nil
 	}
 	return linkStagingResult{}, lastErr
@@ -252,7 +321,7 @@ func (s *Service) trackerLinkDirName(tracker string) string {
 // sourcePathForLinking returns an existing local source path suitable for link
 // creation. It stats candidate paths because link staging must copy or link real
 // filesystem content.
-func sourcePathForLinking(meta api.PreparedMetadata) (string, error) {
+func sourcePathForLinking(meta api.ClientSubject) (string, error) {
 	if len(meta.FileList) == 1 {
 		if candidate := strings.TrimSpace(meta.FileList[0]); candidate != "" {
 			info, err := os.Stat(candidate)
@@ -281,7 +350,7 @@ func sourcePathForLinking(meta api.PreparedMetadata) (string, error) {
 // sourcePathForQbitSavePath returns the prepared source path used for qbit
 // savepath mapping. It is intentionally lexical and does not stat the source,
 // because qbit injection can still be valid when source metadata is unavailable.
-func sourcePathForQbitSavePath(meta api.PreparedMetadata) (string, error) {
+func sourcePathForQbitSavePath(meta api.ClientSubject) (string, error) {
 	if len(meta.FileList) == 1 {
 		if candidate := strings.TrimSpace(meta.FileList[0]); candidate != "" {
 			return absLocalPath("qbit mapping source", candidate)
@@ -662,7 +731,8 @@ func hardlinkDirectory(ctx context.Context, source string, dest string) error {
 		} else if !os.IsNotExist(err) {
 			return fmt.Errorf("stat hardlink target: %w", err)
 		}
-		if err := os.Link(path, target); err != nil { //nolint:gosec // Hardlink staging intentionally links files from a user-selected source tree into a guarded destination.
+		//nolint:gosec // Hardlink staging intentionally links files from a user-selected source tree into a guarded destination.
+		if err := os.Link(path, target); err != nil {
 			return fmt.Errorf("create hardlink for directory entry: %w", err)
 		}
 		return nil
@@ -712,7 +782,7 @@ func mappedRemotePath[S ~[]string](value string, localPaths S, remotePaths S) (s
 // save path parent that can contain the torrent's top-level content. It returns
 // mapped=false without touching source metadata when no usable path pairs exist
 // or no configured pair matches the lexical source path.
-func mappedQbitSavePathForSource[S ~[]string](meta api.PreparedMetadata, localPaths S, remotePaths S) (string, bool, error) {
+func mappedQbitSavePathForSource[S ~[]string](meta api.ClientSubject, localPaths S, remotePaths S) (string, bool, error) {
 	if len(pathMappingPairs(localPaths, remotePaths)) == 0 {
 		return "", false, nil
 	}
diff --git a/internal/clients/linking_torrent.go b/internal/torrentclient/linking_torrent.go
similarity index 95%
rename from internal/clients/linking_torrent.go
rename to internal/torrentclient/linking_torrent.go
index d39a10f0..d012e3ca 100644
--- a/internal/clients/linking_torrent.go
+++ b/internal/torrentclient/linking_torrent.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package clients
+package torrentclient
 
 import (
 	"context"
@@ -15,7 +15,7 @@ import (
 
 	"github.com/anacrolix/torrent/metainfo"
 
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -52,7 +52,7 @@ type sourceLinkCandidate struct {
 // paths preserve the torrent root and internal file layout. It checks ctx
 // around metainfo processing and during source discovery and matching, returning
 // an error that wraps the context error when canceled.
-func buildTorrentLinkPlan(ctx context.Context, torrentPath string, meta api.PreparedMetadata) (torrentLinkPlan, error) {
+func buildTorrentLinkPlan(ctx context.Context, torrentPath string, meta api.ClientSubject) (torrentLinkPlan, error) {
 	if err := torrentLinkPlanContextError(ctx); err != nil {
 		return torrentLinkPlan{}, err
 	}
@@ -125,7 +125,7 @@ func buildTorrentLinkPlan(ctx context.Context, torrentPath string, meta api.Prep
 // Single-file sources produce one candidate; directory sources are walked
 // recursively. It checks ctx around filesystem operations and on every walk
 // callback, returning a wrapped context error when canceled.
-func sourceLinkCandidates(ctx context.Context, meta api.PreparedMetadata) ([]sourceLinkCandidate, error) {
+func sourceLinkCandidates(ctx context.Context, meta api.ClientSubject) ([]sourceLinkCandidate, error) {
 	if err := torrentLinkPlanContextError(ctx); err != nil {
 		return nil, err
 	}
@@ -227,7 +227,13 @@ func matchSourceLinkCandidate(ctx context.Context, candidates []sourceLinkCandid
 
 // matchSourceLinkCandidateWithCaseFold applies the matcher with explicit case
 // semantics so host-independent tests can prove Windows and non-Windows rules.
-func matchSourceLinkCandidateWithCaseFold(ctx context.Context, candidates []sourceLinkCandidate, torrentRel string, length int64, foldCase bool) (*sourceLinkCandidate, string, error) {
+func matchSourceLinkCandidateWithCaseFold(
+	ctx context.Context,
+	candidates []sourceLinkCandidate,
+	torrentRel string,
+	length int64,
+	foldCase bool,
+) (*sourceLinkCandidate, string, error) {
 	torrentRel = filepath.Clean(torrentRel)
 	torrentName := filepath.Base(torrentRel)
 	checks := []struct {
@@ -365,7 +371,11 @@ func createTorrentLinkPlan(ctx context.Context, trackerDir string, plan torrentL
 			return rollbackTorrentLinkPlan(trackerDir, created, fmt.Errorf("validate staged torrent file: %w", err))
 		}
 		if !info.Mode().IsRegular() || info.Size() != file.length {
-			return rollbackTorrentLinkPlan(trackerDir, created, fmt.Errorf("staged torrent file size mismatch: expected=%d actual=%d", file.length, info.Size()))
+			return rollbackTorrentLinkPlan(
+				trackerDir,
+				created,
+				fmt.Errorf("staged torrent file size mismatch: expected=%d actual=%d", file.length, info.Size()),
+			)
 		}
 	}
 	return nil
diff --git a/internal/clients/linking_torrent_test.go b/internal/torrentclient/linking_torrent_test.go
similarity index 94%
rename from internal/clients/linking_torrent_test.go
rename to internal/torrentclient/linking_torrent_test.go
index fe9ebabb..e74d2117 100644
--- a/internal/clients/linking_torrent_test.go
+++ b/internal/torrentclient/linking_torrent_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package clients
+package torrentclient
 
 import (
 	"context"
@@ -53,7 +53,11 @@ func writeQbitTestTorrentForSource(t *testing.T, torrentPath string, sourcePath
 
 func writeQbitTestTorrent(t *testing.T, torrentPath string, rootName string, files map[string]string, multi bool) {
 	t.Helper()
-	info := metainfo.Info{Name: rootName, PieceLength: 16 * 1024, Private: new(true)}
+	info := metainfo.Info{
+		Name:        rootName,
+		PieceLength: 16 * 1024,
+		Private:     new(true),
+	}
 	if multi {
 		for rel, source := range files {
 			fileInfo, err := os.Stat(source)
@@ -102,7 +106,7 @@ func TestBuildTorrentLinkPlanUsesInjectedSingleFileName(t *testing.T) {
 	torrentPath := filepath.Join(root, "renamed.torrent")
 	writeQbitTestTorrent(t, torrentPath, "Tracker.Name.2026.mkv", map[string]string{"source": source}, false)
 
-	plan, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.PreparedMetadata{SourcePath: source, FileList: []string{source}})
+	plan, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.ClientSubject{SourcePath: source, FileList: []string{source}})
 	if err != nil {
 		t.Fatalf("build plan: %v", err)
 	}
@@ -127,7 +131,7 @@ func TestBuildTorrentLinkPlanUsesInjectedMultiFileLayout(t *testing.T) {
 		filepath.Join("Feature", "Tracker.Name.2026.mkv"): source,
 	}, true)
 
-	plan, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.PreparedMetadata{SourcePath: sourceRoot, FileList: []string{source}})
+	plan, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.ClientSubject{SourcePath: sourceRoot, FileList: []string{source}})
 	if err != nil {
 		t.Fatalf("build plan: %v", err)
 	}
@@ -179,8 +183,16 @@ func TestCreateTorrentLinkPlanRollsBackCreatedLinksUnderExistingRoot(t *testing.
 	plan := torrentLinkPlan{
 		root: "Example.Release.2026",
 		files: []torrentLinkFile{
-			{sourcePath: firstSource, destRel: filepath.Join("Example.Release.2026", "first.mkv"), length: 5},
-			{sourcePath: secondSource, destRel: filepath.Join("Example.Release.2026", "second.mkv"), length: 5},
+			{
+				sourcePath: firstSource,
+				destRel:    filepath.Join("Example.Release.2026", "first.mkv"),
+				length:     5,
+			},
+			{
+				sourcePath: secondSource,
+				destRel:    filepath.Join("Example.Release.2026", "second.mkv"),
+				length:     5,
+			},
 		},
 		torrentIsMulti: true,
 	}
@@ -216,7 +228,7 @@ func TestBuildTorrentLinkPlanRejectsAmbiguousSizeOnlyMatch(t *testing.T) {
 	torrentPath := filepath.Join(root, "ambiguous.torrent")
 	writeQbitTestTorrent(t, torrentPath, "Renamed.mkv", map[string]string{"source": first}, false)
 
-	_, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.PreparedMetadata{SourcePath: sourceRoot})
+	_, err := buildTorrentLinkPlan(context.Background(), torrentPath, api.ClientSubject{SourcePath: sourceRoot})
 	if err == nil || !strings.Contains(err.Error(), "no unique source match") {
 		t.Fatalf("expected ambiguous source mapping error")
 	}
@@ -323,7 +335,7 @@ func TestPrepareLinkStagingReturnsPlannerCancellation(t *testing.T) {
 	_, err := service.prepareLinkStaging(ctx, "qbit", config.TorrentClientConfig{
 		Linking:      "hardlink",
 		LinkedFolder: config.StringList{filepath.Join(root, "links")},
-	}, api.PreparedMetadata{
+	}, api.ClientSubject{
 		SourcePath: source,
 		FileList:   []string{source},
 	}, api.TorrentResult{Path: filepath.Join(root, "injected.torrent"), Tracker: "EXAMPLE"})
@@ -347,7 +359,7 @@ func TestPrepareLinkStagingRejectsURLOnlyWhenFallbackDisabled(t *testing.T) {
 	}
 	service := NewService(config.Config{}, nil)
 
-	_, err := service.prepareLinkStaging(context.Background(), "qbit", client, api.PreparedMetadata{
+	_, err := service.prepareLinkStaging(context.Background(), "qbit", client, api.ClientSubject{
 		SourcePath: source,
 		FileList:   []string{source},
 	}, api.TorrentResult{URL: "https://tracker.example/torrent/1", Tracker: "EXAMPLE"})
diff --git a/internal/clients/reflink_linux.go b/internal/torrentclient/reflink_linux.go
similarity index 98%
rename from internal/clients/reflink_linux.go
rename to internal/torrentclient/reflink_linux.go
index 9a77f07f..ed9a617b 100644
--- a/internal/clients/reflink_linux.go
+++ b/internal/torrentclient/reflink_linux.go
@@ -3,7 +3,7 @@
 
 //go:build linux
 
-package clients
+package torrentclient
 
 import (
 	"errors"
diff --git a/internal/clients/reflink_unsupported.go b/internal/torrentclient/reflink_unsupported.go
similarity index 92%
rename from internal/clients/reflink_unsupported.go
rename to internal/torrentclient/reflink_unsupported.go
index 4e433ff2..9cad4cad 100644
--- a/internal/clients/reflink_unsupported.go
+++ b/internal/torrentclient/reflink_unsupported.go
@@ -3,7 +3,7 @@
 
 //go:build !linux && !windows
 
-package clients
+package torrentclient
 
 import "errors"
 
diff --git a/internal/clients/reflink_windows.go b/internal/torrentclient/reflink_windows.go
similarity index 98%
rename from internal/clients/reflink_windows.go
rename to internal/torrentclient/reflink_windows.go
index b71667fc..ca82b26d 100644
--- a/internal/clients/reflink_windows.go
+++ b/internal/torrentclient/reflink_windows.go
@@ -3,7 +3,7 @@
 
 //go:build windows
 
-package clients
+package torrentclient
 
 import (
 	"errors"
@@ -30,6 +30,8 @@ const (
 	fileBegin                   = 0
 )
 
+// duplicateExtentsData matches the Windows DUPLICATE_EXTENTS_DATA control
+// structure used to clone a byte range between files.
 type duplicateExtentsData struct {
 	FileHandle       windows.Handle
 	SourceFileOffset int64
diff --git a/internal/clients/search.go b/internal/torrentclient/search.go
similarity index 83%
rename from internal/clients/search.go
rename to internal/torrentclient/search.go
index 91326507..1d308821 100644
--- a/internal/clients/search.go
+++ b/internal/torrentclient/search.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package clients
+package torrentclient
 
 import (
 	"bytes"
@@ -22,12 +22,11 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/internal/torrent"
 	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
 	"github.com/autobrr/upbrr/pkg/api"
 
 	"github.com/anacrolix/torrent/metainfo"
@@ -41,134 +40,56 @@ const (
 	proxySearchTimeout = 15 * time.Second
 )
 
+// trackerPattern associates a tracker endpoint with the expression used to
+// extract its torrent identifier.
 type trackerPattern struct {
-	url     string
-	pattern *regexp.Regexp
+	trackerURLs      []string
+	commentURLs      []string
+	pattern          *regexp.Regexp
+	workingTrackerID string
+	inferMatchFromID bool
 }
 
-var (
-	unit3dTrackerIDPattern = regexp.MustCompile(`/(\d+)`)
-	trackerIDPatterns      = buildTrackerIDPatterns()
-)
-
-var trackerIDCommentAliases = map[string][]string{
-	"rf": {"https://reelflix.xyz"},
-}
-
-var trackerURLPatterns = map[string][]string{
-	"acm":    {"https://eiga.moi"},
-	"aither": {"https://aither.cc"},
-	"ant":    {"tracker.anthelion.me"},
-	"ar":     {"tracker.alpharatio"},
-	"asc":    {"amigos-share.club"},
-	"az":     {"tracker.avistaz.to"},
-	"bhd":    {"https://beyond-hd.me", "tracker.beyond-hd.me"},
-	"bjs":    {"tracker.bj-share.info"},
-	"blu":    {"https://blutopia.cc"},
-	"bt":     {"t.brasiltracker.org"},
-	"btn":    {"https://broadcasthe.net", "https://backup.landof.tv", "https://landof.tv", "landof.tv/"},
-	"cbr":    {"capybarabr.com"},
-	"cz":     {"tracker.cinemaz.to"},
-	// CZTeam exposes tracker provenance through announce URLs; it has no
-	// separate client-visible torrent id pattern.
-	"czt":  {"czteam.me"},
-	"dc":   {"tracker.digitalcore.club", "trackerprxy.digitalcore.club"},
-	"dp":   {"https://darkpeers.org"},
-	"ff":   {"tracker.funfile.org"},
-	"fl":   {"reactor.filelist", "reactor.thefl.org"},
-	"gpw":  {"https://tracker.greatposterwall.com"},
-	"hdb":  {"https://tracker.hdbits.org"},
-	"hds":  {"hd-space.pw"},
-	"hdt":  {"https://hdts-announce.ru"},
-	"hhd":  {"https://homiehelpdesk.net"},
-	"ihd":  {"https://infinityhd.net"},
-	"is":   {"https://immortalseed.me"},
-	"itt":  {"https://itatorrents.xyz"},
-	"lcd":  {"locadora.cc"},
-	"ldu":  {"theldu.to"},
-	"lst":  {"https://lst.gg"},
-	"lt":   {"https://lat-team.com"},
-	"lume": {"https://luminarr.me"},
-	"mns":  {"https://midnightscene.cc"},
-	"mtv":  {"tracker.morethantv"},
-	"nbl":  {"tracker.nebulance"},
-	"oe":   {"https://onlyencodes.cc"},
-	"otw":  {"https://oldtoons.world"},
-	"phd":  {"tracker.privatehd"},
-	"pt":   {"https://portugas.org"},
-	"ptp":  {"passthepopcorn.me"},
-	"pts":  {"https://tracker.ptskit.com"},
-	"ras":  {"https://rastastugan.org"},
-	"rf":   {"https://reelflix.xyz", "https://reelflix.cc"},
-	"rtf":  {"peer.retroflix"},
-	"sam":  {"https://samaritano.cc"},
-	"sp":   {"https://seedpool.org"},
-	"spd":  {"ramjet.speedapp.io", "ramjet.speedapp.to", "ramjet.speedappio.org"},
-	"stc":  {"https://skipthecommercials.xyz"},
-	"thr":  {"torrenthr"},
-	"tl":   {"tracker.tleechreload", "tracker.torrentleech"},
-	"tlz":  {"https://tlzdigital.com/"},
-	"tos":  {"https://theoldschool.cc"},
-	"ttr":  {"https://torrenteros.org"},
-	"tvc":  {"https://tvchaosuk.com"},
-	"ulcx": {"https://upload.cx"},
-	"yus":  {"https://yu-scene.net"},
-	"znth": {"https://znth.cx"},
-}
-
-var lowerTrackerURLPatterns = buildLowerTrackerURLPatterns(trackerURLPatterns)
-
-func buildLowerTrackerURLPatterns(source map[string][]string) map[string][]string {
-	if len(source) == 0 {
-		return nil
-	}
-	lowered := make(map[string][]string, len(source))
-	for id, patterns := range source {
-		normalized := make([]string, 0, len(patterns))
-		for _, pattern := range patterns {
-			trimmed := strings.ToLower(strings.TrimSpace(pattern))
-			if trimmed == "" {
-				continue
-			}
-			normalized = append(normalized, trimmed)
+func buildTrackerIDPatterns(registry *trackers.Registry) map[string]trackerPattern {
+	patterns := make(map[string]trackerPattern)
+	for _, tracker := range registry.Names() {
+		policy, ok := registry.LookupTorrentIdentityPolicy(tracker)
+		if !ok {
+			continue
+		}
+		var pattern *regexp.Regexp
+		if policy.DetailIDPattern != "" {
+			pattern = regexp.MustCompile(policy.DetailIDPattern)
+		}
+		patterns[strings.ToLower(tracker)] = trackerPattern{
+			trackerURLs:      append([]string(nil), policy.TrackerURLPatterns...),
+			commentURLs:      append([]string(nil), policy.CommentURLPatterns...),
+			pattern:          pattern,
+			workingTrackerID: policy.WorkingTrackerID,
+			inferMatchFromID: policy.InferMatchFromResolvedID,
 		}
-		lowered[id] = normalized
 	}
-	return lowered
+	return patterns
 }
 
-func buildTrackerIDPatterns() map[string]trackerPattern {
-	patterns := map[string]trackerPattern{
-		"hdb": {url: "https://hdbits.org", pattern: regexp.MustCompile(`id=(\d+)`)},
-		"btn": {url: "https://broadcasthe.net", pattern: regexp.MustCompile(`id=(\d+)`)},
-		"bhd": {url: "https://beyond-hd.me", pattern: regexp.MustCompile(`details/(\d+)`)},
-		"ptp": {url: "passthepopcorn.me", pattern: regexp.MustCompile(`torrentid=(\d+)`)},
-		"rtf": {url: "https://retroflix.club", pattern: regexp.MustCompile(`(?i)retroflix\.club/browse/t/(\d+)`)},
-	}
-
-	for _, tracker := range trackers.Unit3DTrackers() {
-		baseURL, ok := unit3dmeta.BaseURL(tracker)
-		if !ok || strings.TrimSpace(baseURL) == "" {
-			continue
-		}
-		key := strings.ToLower(strings.TrimSpace(tracker))
-		if key == "" {
-			continue
+func trackerSearchPreferenceNames(registry *trackers.Registry, preference trackers.TorrentSearchPreference) []string {
+	names := make([]string, 0)
+	for _, tracker := range registry.Names() {
+		policy, ok := registry.LookupTorrentIdentityPolicy(tracker)
+		if ok && policy.SearchPreference == preference {
+			names = append(names, tracker)
 		}
-		patterns[key] = trackerPattern{url: strings.ToLower(baseURL), pattern: unit3dTrackerIDPattern}
 	}
-	if pattern, ok := patterns["rf"]; ok {
-		pattern.pattern = regexp.MustCompile(`(?i)reelflix\.(?:cc|xyz)/torrents/(\d+)`)
-		patterns["rf"] = pattern
-	}
-
-	return patterns
+	return names
 }
 
+// proxySearchResponse models the torrent list returned by the Qui search proxy.
 type proxySearchResponse struct {
 	Torrents []qbittorrent.Torrent `json:"torrents"`
 }
 
+// pieceConstraints describes tracker-specific preferences used when selecting
+// a reusable torrent from validated client matches.
 type pieceConstraints struct {
 	label       string
 	preferSmall bool
@@ -197,7 +118,19 @@ type torrentDataValidation struct {
 	reason      string
 }
 
-func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.PreparedMetadata) (result api.ClientSearchResult, err error) {
+// SearchPathedTorrents searches selected qBittorrent or Qui clients in
+// configured order, validates exported metainfo against meta, and stops once
+// the active piece-size preference is satisfied. Match lists are deduplicated
+// across clients; per-client scalar results are replaced as later matching
+// clients are evaluated.
+//
+// A reusable export is stripped of announce, comment, and web-seed metadata and
+// written with mode 0600 below the configured DB temporary directory. A requested
+// force recheck also mutates direct qBittorrent state and waits for checking to
+// finish. Client-level failures abort the search; individual property or tracker
+// lookup failures degrade that candidate, while export failures reject only the
+// affected candidate.
+func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.ClientSubject) (result api.ClientSearchResult, err error) {
 	defer func() {
 		if err != nil {
 			s.logger.Warnf("clients: pathed search blocked err=%s", redaction.RedactValue(err.Error(), nil))
@@ -208,7 +141,7 @@ func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.PreparedMet
 		return api.ClientSearchResult{}, internalerrors.ErrInvalidInput
 	}
 
-	constraints := resolvePieceConstraints(s.cfg)
+	constraints := resolvePieceConstraints(s.cfg, s.smallPieceTrackers)
 	result = api.ClientSearchResult{PieceSizeConstraint: constraints.label}
 	s.logger.Tracef("clients: pathed search start source=%s constraints=%q", meta.SourcePath, constraints.label)
 
@@ -221,9 +154,7 @@ func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.PreparedMet
 		s.logger.Debugf("clients: no default search client set; searching all qBittorrent clients (%d)", len(clients))
 	}
 	s.logger.Tracef("clients: pathed search clients=%s", strings.Join(clients, ","))
-	if meta.Options.Debug {
-		s.logger.Debugf("clients: pathed search for %s (clients=%d constraints=%q)", meta.SourcePath, len(clients), constraints.label)
-	}
+	s.logger.Debugf("clients: pathed search for %s (clients=%d constraints=%q)", meta.SourcePath, len(clients), constraints.label)
 
 	allMatches := make([]api.TorrentMatch, 0)
 	seenHashes := make(map[string]struct{})
@@ -253,11 +184,15 @@ func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.PreparedMet
 		if err != nil {
 			return api.ClientSearchResult{}, err
 		}
-		s.logger.Tracef("clients: pathed search client %s results matches=%d trackerMatch=%t preferred=%q", name, len(matches), clientResult.FoundTrackerMatch, clientResult.FoundPreferredPiece)
+		s.logger.Tracef(
+			"clients: pathed search client %s results matches=%d trackerMatch=%t preferred=%q",
+			name,
+			len(matches),
+			clientResult.FoundTrackerMatch,
+			clientResult.FoundPreferredPiece,
+		)
 		if len(matches) == 0 {
-			if meta.Options.Debug {
-				s.logger.Debugf("clients: no torrent matches found in %s", name)
-			}
+			s.logger.Debugf("clients: no torrent matches found in %s", name)
 			continue
 		}
 
@@ -288,18 +223,14 @@ func (s *Service) SearchPathedTorrents(ctx context.Context, meta api.PreparedMet
 	}
 
 	if len(allMatches) == 0 {
-		if meta.Options.Debug {
-			s.logger.Debugf("clients: pathed search yielded no matches")
-		}
+		s.logger.Debugf("clients: pathed search yielded no matches")
 		return result, nil
 	}
 
 	result.TorrentComments = allMatches
 	result.MatchedTrackers = dedupeStrings(result.MatchedTrackers)
-	if meta.Options.Debug {
-		s.logger.Debugf("clients: pathed search found %d matches", len(allMatches))
-		logPathedSearchMatches(s.logger, allMatches)
-	}
+	s.logger.Debugf("clients: pathed search found %d matches", len(allMatches))
+	logPathedSearchMatches(s.logger, allMatches)
 
 	return result, nil
 }
@@ -346,13 +277,20 @@ func formatTrackerMatches(matches []api.TrackerMatch) string {
 	return strings.Join(formatted, ",")
 }
 
-func resolvePieceConstraints(cfg config.Config) pieceConstraints {
-	mtv := false
-	if trackerCfg, ok := cfg.Trackers.Trackers["MTV"]; ok {
-		mtv = trackerCfg.PreferMTV
-	}
-	if mtv {
-		return pieceConstraints{label: "MTV", preferSmall: true}
+func resolvePieceConstraints(cfg config.Config, smallPieceTrackers []string) pieceConstraints {
+	for _, tracker := range smallPieceTrackers {
+		trackerCfg, ok := cfg.Trackers.Trackers[tracker]
+		if !ok {
+			for name, candidate := range cfg.Trackers.Trackers {
+				if strings.EqualFold(strings.TrimSpace(name), tracker) {
+					trackerCfg, ok = candidate, true
+					break
+				}
+			}
+		}
+		if ok && trackerCfg.PreferMTV {
+			return pieceConstraints{label: strings.ToUpper(tracker), preferSmall: true}
+		}
 	}
 	if cfg.TorrentCreation.PreferMax16 {
 		return pieceConstraints{label: "16MiB", preferMax16: true}
@@ -468,7 +406,13 @@ func selectSearchClientNames(clients map[string]config.TorrentClientConfig, sele
 	return result
 }
 
-func (s *Service) searchQbitClient(ctx context.Context, name string, clientCfg config.TorrentClientConfig, meta api.PreparedMetadata, constraints pieceConstraints) (api.ClientSearchResult, []api.TorrentMatch, error) {
+func (s *Service) searchQbitClient(
+	ctx context.Context,
+	name string,
+	clientCfg config.TorrentClientConfig,
+	meta api.ClientSubject,
+	constraints pieceConstraints,
+) (api.ClientSearchResult, []api.TorrentMatch, error) {
 	searchTerms := buildSearchTerms(meta)
 	if len(searchTerms) == 0 {
 		s.logger.Debugf("clients: %s search term empty for source=%s", name, meta.SourcePath)
@@ -536,7 +480,7 @@ func (s *Service) searchQbitClient(ctx context.Context, name string, clientCfg c
 		return api.ClientSearchResult{}, nil, nil
 	}
 
-	priorityOrder := effectiveTrackerPriority(s.cfg)
+	priorityOrder := effectiveTrackerPriority(s.cfg, s.trackerPriority)
 	matches := make([]api.TorrentMatch, 0)
 	nameMatched := 0
 
@@ -577,7 +521,7 @@ func (s *Service) searchQbitClient(ctx context.Context, name string, clientCfg c
 			}
 		}
 
-		trackerMatches, trackerFound := extractTrackerMatches(comment, trackerURLs, hasWorkingTracker, priorityOrder)
+		trackerMatches, trackerFound := extractTrackerMatchesWithPatterns(comment, trackerURLs, hasWorkingTracker, priorityOrder, s.trackerPatterns)
 
 		match := api.TorrentMatch{
 			Hash:              torrent.Hash,
@@ -614,8 +558,8 @@ func (s *Service) searchQbitClient(ctx context.Context, name string, clientCfg c
 	s.logger.Tracef("clients: %s validated %d of %d matched torrents", name, len(selection.matches), len(matches))
 
 	trackerIDs := collectTrackerIDs(selection.matches, priorityOrder)
-	matchedTrackers := collectMatchedTrackers(selection.matches)
-	matchedTrackers = ensureMatchedTrackersForKnownIDs(matchedTrackers, trackerIDs)
+	matchedTrackers := collectMatchedTrackers(selection.matches, s.trackerPatterns)
+	matchedTrackers = ensureMatchedTrackersForKnownIDs(matchedTrackers, trackerIDs, s.trackerPatterns)
 
 	result := api.ClientSearchResult{
 		InfoHash:            selection.infoHash,
@@ -633,7 +577,7 @@ func (s *Service) searchQbitClient(ctx context.Context, name string, clientCfg c
 
 // buildSearchTerms returns distinct sanitized qBittorrent search terms for the
 // source path, including extensionless single-file variants when safe.
-func buildSearchTerms(meta api.PreparedMetadata) []string {
+func buildSearchTerms(meta api.ClientSubject) []string {
 	terms := make([]string, 0, 4)
 	seen := make(map[string]struct{}, 4)
 	add := func(base string, allowExtensionless bool) {
@@ -730,7 +674,7 @@ func sanitizeSearchTerm(value string) string {
 	return strings.TrimSpace(builder.String())
 }
 
-func torrentMatchesMeta(torrent qbittorrent.Torrent, meta api.PreparedMetadata) bool {
+func torrentMatchesMeta(torrent qbittorrent.Torrent, meta api.ClientSubject) bool {
 	if torrentNameMatches(torrent.Name, meta) {
 		return true
 	}
@@ -738,7 +682,7 @@ func torrentMatchesMeta(torrent qbittorrent.Torrent, meta api.PreparedMetadata)
 	return contentBase != "" && torrentNameMatches(contentBase, meta)
 }
 
-func torrentNameMatches(name string, meta api.PreparedMetadata) bool {
+func torrentNameMatches(name string, meta api.ClientSubject) bool {
 	if strings.TrimSpace(name) == "" {
 		return false
 	}
@@ -862,7 +806,13 @@ func buildProxySearchURL(proxyBase, searchTerm string) (string, error) {
 	return parsed.String(), nil
 }
 
-func fetchTorrentProperties(ctx context.Context, client *qbittorrent.Client, httpClient *http.Client, proxyBase, hash string, useProxy bool) (qbittorrent.TorrentProperties, error) {
+func fetchTorrentProperties(
+	ctx context.Context,
+	client *qbittorrent.Client,
+	httpClient *http.Client,
+	proxyBase, hash string,
+	useProxy bool,
+) (qbittorrent.TorrentProperties, error) {
 	if !useProxy {
 		props, err := client.GetTorrentPropertiesCtx(ctx, hash)
 		if err != nil {
@@ -900,7 +850,14 @@ func fetchTorrentProperties(ctx context.Context, client *qbittorrent.Client, htt
 	return props, nil
 }
 
-func fetchTorrentTrackers(ctx context.Context, client *qbittorrent.Client, httpClient *http.Client, proxyBase, hash string, useProxy bool, fallback []qbittorrent.TorrentTracker) ([]qbittorrent.TorrentTracker, error) {
+func fetchTorrentTrackers(
+	ctx context.Context,
+	client *qbittorrent.Client,
+	httpClient *http.Client,
+	proxyBase, hash string,
+	useProxy bool,
+	fallback []qbittorrent.TorrentTracker,
+) ([]qbittorrent.TorrentTracker, error) {
 	if useProxy {
 		if len(fallback) > 0 {
 			return fallback, nil
@@ -956,17 +913,23 @@ func collectTrackerURLs(primary string, trackers []qbittorrent.TorrentTracker) [
 	return urls
 }
 
-func extractTrackerMatches(comment string, trackerURLs []string, hasWorkingTracker bool, priority []string) ([]api.TrackerMatch, bool) {
+func extractTrackerMatchesWithPatterns(
+	comment string,
+	trackerURLs []string,
+	hasWorkingTracker bool,
+	priority []string,
+	patterns map[string]trackerPattern,
+) ([]api.TrackerMatch, bool) {
 	matches := make([]api.TrackerMatch, 0)
 	trackerFound := false
 	lowerComment := strings.ToLower(comment)
 
-	for _, trackerID := range trackerIDExtractionOrder(priority) {
-		pattern, ok := trackerIDPatterns[trackerID]
+	for _, trackerID := range trackerIDExtractionOrder(priority, patterns) {
+		pattern, ok := patterns[trackerID]
 		if !ok {
 			continue
 		}
-		if !hasWorkingTracker || !trackerPatternMatchesComment(trackerID, lowerComment, pattern) {
+		if !hasWorkingTracker || pattern.pattern == nil || !trackerPatternMatchesComment(lowerComment, pattern) {
 			continue
 		}
 		match := pattern.pattern.FindStringSubmatch(comment)
@@ -977,22 +940,23 @@ func extractTrackerMatches(comment string, trackerURLs []string, hasWorkingTrack
 		trackerFound = true
 	}
 
-	for _, url := range trackerURLs {
-		lowerURL := strings.ToLower(url)
-		if strings.Contains(lowerURL, "tracker.anthelion.me") {
-			if hasWorkingTracker {
-				matches = append(matches, api.TrackerMatch{ID: "ant", TrackerID: "1"})
-				trackerFound = true
+	if hasWorkingTracker {
+		for _, trackerID := range trackerIDExtractionOrder(priority, patterns) {
+			pattern := patterns[trackerID]
+			if pattern.workingTrackerID == "" || !trackerURLsMatch(trackerURLs, pattern.trackerURLs) {
+				continue
 			}
+			matches = append(matches, api.TrackerMatch{ID: trackerID, TrackerID: pattern.workingTrackerID})
+			trackerFound = true
 		}
 	}
 
 	return matches, trackerFound
 }
 
-func trackerIDExtractionOrder(priority []string) []string {
-	seen := make(map[string]struct{}, len(priority)+len(trackerIDPatterns))
-	ordered := make([]string, 0, len(priority)+len(trackerIDPatterns))
+func trackerIDExtractionOrder(priority []string, patterns map[string]trackerPattern) []string {
+	seen := make(map[string]struct{}, len(priority)+len(patterns))
+	ordered := make([]string, 0, len(priority)+len(patterns))
 	for _, trackerID := range priority {
 		key := strings.ToLower(strings.TrimSpace(trackerID))
 		if key == "" {
@@ -1005,8 +969,8 @@ func trackerIDExtractionOrder(priority []string) []string {
 		ordered = append(ordered, key)
 	}
 
-	keys := make([]string, 0, len(trackerIDPatterns))
-	for key := range trackerIDPatterns {
+	keys := make([]string, 0, len(patterns))
+	for key := range patterns {
 		keys = append(keys, key)
 	}
 	sort.Strings(keys)
@@ -1020,27 +984,24 @@ func trackerIDExtractionOrder(priority []string) []string {
 	return ordered
 }
 
-func trackerPatternMatchesComment(trackerID string, lowerComment string, pattern trackerPattern) bool {
-	if strings.Contains(lowerComment, strings.ToLower(pattern.url)) {
-		return true
-	}
-	for _, alias := range trackerIDCommentAliases[strings.ToLower(strings.TrimSpace(trackerID))] {
-		if strings.Contains(lowerComment, strings.ToLower(strings.TrimSpace(alias))) {
+func trackerPatternMatchesComment(lowerComment string, pattern trackerPattern) bool {
+	for _, commentURL := range pattern.commentURLs {
+		if strings.Contains(lowerComment, strings.ToLower(strings.TrimSpace(commentURL))) {
 			return true
 		}
 	}
 	return false
 }
 
-func matchTrackerURLs(trackerURLs []string) []string {
+func matchTrackerURLs(trackerURLs []string, patterns map[string]trackerPattern) []string {
 	found := make(map[string]struct{})
 	for _, trackerURL := range trackerURLs {
 		lowerURL := strings.ToLower(strings.TrimSpace(trackerURL))
 		if lowerURL == "" {
 			continue
 		}
-		for id, patterns := range lowerTrackerURLPatterns {
-			for _, pattern := range patterns {
+		for id, identity := range patterns {
+			for _, pattern := range identity.trackerURLs {
 				if strings.Contains(lowerURL, pattern) {
 					found[strings.ToUpper(id)] = struct{}{}
 				}
@@ -1050,6 +1011,18 @@ func matchTrackerURLs(trackerURLs []string) []string {
 	return mapKeys(found)
 }
 
+func trackerURLsMatch(trackerURLs []string, patterns []string) bool {
+	for _, trackerURL := range trackerURLs {
+		lowerURL := strings.ToLower(strings.TrimSpace(trackerURL))
+		for _, pattern := range patterns {
+			if strings.Contains(lowerURL, strings.ToLower(strings.TrimSpace(pattern))) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func sortMatchingTorrents(matches []api.TorrentMatch, priority []string) {
 	priorityIndex := make(map[string]int, len(priority))
 	for idx, id := range priority {
@@ -1133,10 +1106,10 @@ func collectTrackerIDs(matches []api.TorrentMatch, priority []string) map[string
 
 // collectMatchedTrackers derives matched tracker names from validated torrent
 // announce URLs only.
-func collectMatchedTrackers(matches []api.TorrentMatch) []string {
+func collectMatchedTrackers(matches []api.TorrentMatch, patterns map[string]trackerPattern) []string {
 	matched := make([]string, 0, len(matches))
 	for _, match := range matches {
-		matched = append(matched, matchTrackerURLs(match.TrackerURLsRaw)...)
+		matched = append(matched, matchTrackerURLs(match.TrackerURLsRaw, patterns)...)
 	}
 	return dedupeStrings(matched)
 }
@@ -1151,7 +1124,11 @@ func hasTrackerIDMatch(matches []api.TorrentMatch) bool {
 	return false
 }
 
-func ensureMatchedTrackersForKnownIDs(matchedTrackers []string, trackerIDs map[string]string) []string {
+func ensureMatchedTrackersForKnownIDs(
+	matchedTrackers []string,
+	trackerIDs map[string]string,
+	patterns map[string]trackerPattern,
+) []string {
 	if len(trackerIDs) == 0 {
 		return matchedTrackers
 	}
@@ -1160,8 +1137,10 @@ func ensureMatchedTrackersForKnownIDs(matchedTrackers []string, trackerIDs map[s
 		if strings.TrimSpace(id) == "" {
 			continue
 		}
-		if strings.EqualFold(strings.TrimSpace(tracker), "btn") && !hasMatchedTracker(resolved, "BTN") {
-			resolved = append(resolved, "BTN")
+		normalized := strings.ToLower(strings.TrimSpace(tracker))
+		pattern, ok := patterns[normalized]
+		if ok && pattern.inferMatchFromID && !hasMatchedTracker(resolved, tracker) {
+			resolved = append(resolved, strings.ToUpper(normalized))
 		}
 	}
 	return resolved
@@ -1176,8 +1155,8 @@ func hasMatchedTracker(trackers []string, target string) bool {
 	return false
 }
 
-func effectiveTrackerPriority(cfg config.Config) []string {
-	return applyPreferredTrackerPriority(trackers.TrackerPriority(), cfg.Trackers.PreferredTracker)
+func effectiveTrackerPriority(cfg config.Config, priority []string) []string {
+	return applyPreferredTrackerPriority(priority, cfg.Trackers.PreferredTracker)
 }
 
 func applyPreferredTrackerPriority(priority []string, preferred string) []string {
@@ -1217,7 +1196,7 @@ func shouldStopSearch(constraints string, foundPreferred string) bool {
 	if foundPreferred == "no_constraints" {
 		return true
 	}
-	if foundPreferred == "MTV" {
+	if constraints != "" && foundPreferred == constraints {
 		return true
 	}
 	if foundPreferred == "16MiB" && constraints == "16MiB" {
@@ -1248,7 +1227,7 @@ func dedupeStrings(values []string) []string {
 // choosing one reusable torrent file when strict path and piece checks pass.
 func (s *Service) selectValidTorrent(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta api.ClientSubject,
 	matches []api.TorrentMatch,
 	constraints pieceConstraints,
 	qbitClient *qbittorrent.Client,
@@ -1323,7 +1302,7 @@ func (s *Service) selectValidTorrent(
 			continue
 		}
 
-		outputPath, err := torrent.TempTorrentPath(tmpRoot, meta, meta.SourcePath)
+		outputPath, err := torrent.TempTorrentPath(tmpRoot, meta.SourcePath)
 		if err != nil {
 			return validatedTorrentSelection{}, fmt.Errorf("clients: %w", err)
 		}
@@ -1526,7 +1505,7 @@ func sanitizeTorrentData(data []byte) ([]byte, error) {
 
 // validateTorrentData parses torrent data and reports whether its hash, paths,
 // and piece metadata are usable as a client match and/or a reusable torrent file.
-func validateTorrentData(meta api.PreparedMetadata, hash string, data []byte, constraints pieceConstraints) torrentDataValidation {
+func validateTorrentData(meta api.ClientSubject, hash string, data []byte, constraints pieceConstraints) torrentDataValidation {
 	metaInfo, err := metainfo.Load(bytes.NewReader(data))
 	if err != nil {
 		return torrentDataValidation{reason: "load_failed"}
@@ -1548,7 +1527,11 @@ func validateTorrentData(meta api.PreparedMetadata, hash string, data []byte, co
 	pieceSize := info.PieceLength
 	pieces := info.NumPieces()
 	if pieceSize <= 0 || pieces <= 0 {
-		return torrentDataValidation{pieceSize: pieceSize, infoHash: infoHash, reason: "piece_metadata_invalid"}
+		return torrentDataValidation{
+			pieceSize: pieceSize,
+			infoHash:  infoHash,
+			reason:    "piece_metadata_invalid",
+		}
 	}
 
 	if wrongFile {
@@ -1581,7 +1564,7 @@ func validateTorrentData(meta api.PreparedMetadata, hash string, data []byte, co
 
 // validateTorrentPaths returns whether torrent paths strictly match the source
 // and whether a same-basename layout mismatch can still identify provenance.
-func validateTorrentPaths(meta api.PreparedMetadata, info metainfo.Info) (bool, bool) {
+func validateTorrentPaths(meta api.ClientSubject, info metainfo.Info) (bool, bool) {
 	fileList := meta.FileList
 	metaPath := strings.TrimSpace(meta.SourcePath)
 	wrongFile := false
@@ -1721,7 +1704,7 @@ func preferredPieceLabel(pieceSize int64, constraints pieceConstraints) string {
 		return "no_constraints"
 	}
 	if constraints.preferSmall && pieceSize <= mtvPieceSizeLimit {
-		return "MTV"
+		return constraints.label
 	}
 	if constraints.preferMax16 && pieceSize <= max16PieceSize {
 		return "16MiB"
diff --git a/internal/clients/search_test.go b/internal/torrentclient/search_test.go
similarity index 93%
rename from internal/clients/search_test.go
rename to internal/torrentclient/search_test.go
index 61c232c8..ef2299e5 100644
--- a/internal/clients/search_test.go
+++ b/internal/torrentclient/search_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package clients
+package torrentclient
 
 import (
 	"bytes"
@@ -18,7 +18,7 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 
 	"github.com/anacrolix/torrent/metainfo"
@@ -30,6 +30,15 @@ type captureLogger struct {
 	debug []string
 }
 
+func trackerPatternRegistry(t *testing.T) *trackers.Registry {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return registry
+}
+
 func (l *captureLogger) Tracef(string, ...any) {}
 
 func (l *captureLogger) Debugf(format string, args ...any) {
@@ -129,8 +138,8 @@ func TestSearchPathedTorrentsProxyPrefersPieceSize(t *testing.T) {
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	meta := api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	meta := api.ClientSubject{
 		SourcePath: "/tmp/Movie.Title.2024",
 		FileList:   []string{"/tmp/Movie.Title.2024.mkv"},
 	}
@@ -217,8 +226,8 @@ func TestSearchPathedTorrentsProxyStripsSymbolsFromSearch(t *testing.T) {
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: `D:\Movies\Fixture Title 2024 2160p AUS UHD Blu-ray DV HDR HEVC DTS-HD MA 5.1-FixtureGroup` + "\u2122",
 		DiscType:   "BDMV",
 	})
@@ -298,8 +307,8 @@ func TestSearchPathedTorrentsProxySearchesExtensionlessFileName(t *testing.T) {
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: filepath.Join(dir, "Movie.Title.2024.mkv"),
 		FileList:   []string{filepath.Join(dir, "Movie.Title.2024.mkv")},
 	})
@@ -396,8 +405,8 @@ func TestSearchPathedTorrentsProxyRejectsIDsFromInvalidExtensionlessMatch(t *tes
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: filepath.Join(dir, "Movie.Title.2024.mkv"),
 		FileList:   []string{filepath.Join(dir, "Movie.Title.2024.mkv")},
 	})
@@ -494,8 +503,8 @@ func TestSearchPathedTorrentsProxyUsesFolderWrappedSingleFileAsTrackerSource(t *
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: filepath.Join(dir, "Movie.Title.2024.mkv"),
 		FileList:   []string{filepath.Join(dir, "Movie.Title.2024.mkv")},
 	})
@@ -583,8 +592,8 @@ func TestSearchPathedTorrentsProxyKeepsPieceConstrainedTrackerData(t *testing.T)
 		},
 	}
 
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: filepath.Join(dir, "Movie.Title.2024.mkv"),
 		FileList:   []string{filepath.Join(dir, "Movie.Title.2024.mkv")},
 	})
@@ -717,8 +726,8 @@ func TestSearchPathedTorrentsQbitForceRecheckAfterMetadataValidation(t *testing.
 	}
 
 	forceRecheck := true
-	svc := NewService(cfg, api.NopLogger{})
-	result, err := svc.SearchPathedTorrents(context.Background(), api.PreparedMetadata{
+	svc := NewServiceWithRegistry(cfg, api.NopLogger{}, trackerPatternRegistry(t))
+	result, err := svc.SearchPathedTorrents(context.Background(), api.ClientSubject{
 		SourcePath: filepath.Join(dir, "Movie.Title.2024.mkv"),
 		FileList:   []string{filepath.Join(dir, "Movie.Title.2024.mkv")},
 		ClientOverrides: api.ClientOverrides{
@@ -791,7 +800,10 @@ func TestCommonPathDoesNotFoldCaseDistinctSegments(t *testing.T) {
 func TestMatchTrackerURLsMatchesBTNLandOfTVAnnounce(t *testing.T) {
 	t.Parallel()
 
-	matched := matchTrackerURLs([]string{"https://landof.tv/redacted/announce"})
+	matched := matchTrackerURLs(
+		[]string{"https://landof.tv/redacted/announce"},
+		buildTrackerIDPatterns(trackerPatternRegistry(t)),
+	)
 	if !containsString(matched, "BTN") {
 		t.Fatalf("expected BTN in matched trackers, got %v", matched)
 	}
@@ -800,7 +812,10 @@ func TestMatchTrackerURLsMatchesBTNLandOfTVAnnounce(t *testing.T) {
 func TestMatchTrackerURLsMatchesCZTAnnounce(t *testing.T) {
 	t.Parallel()
 
-	matched := matchTrackerURLs([]string{"https://czteam.me/announce.php?passkey=redacted"})
+	matched := matchTrackerURLs(
+		[]string{"https://czteam.me/announce.php?passkey=redacted"},
+		buildTrackerIDPatterns(trackerPatternRegistry(t)),
+	)
 	if !containsString(matched, "CZT") {
 		t.Fatalf("expected CZT in matched trackers, got %v", matched)
 	}
@@ -809,7 +824,9 @@ func TestMatchTrackerURLsMatchesCZTAnnounce(t *testing.T) {
 func TestEnsureMatchedTrackersForKnownIDsAddsBTN(t *testing.T) {
 	t.Parallel()
 
-	matched := ensureMatchedTrackersForKnownIDs(nil, map[string]string{"btn": "2202392"})
+	matched := ensureMatchedTrackersForKnownIDs(nil, map[string]string{"btn": "2202392"}, map[string]trackerPattern{
+		"btn": {inferMatchFromID: true},
+	})
 	if !containsString(matched, "BTN") {
 		t.Fatalf("expected BTN in matched trackers, got %v", matched)
 	}
@@ -818,11 +835,12 @@ func TestEnsureMatchedTrackersForKnownIDsAddsBTN(t *testing.T) {
 func TestExtractTrackerMatchesHandlesReelFlixAliasComment(t *testing.T) {
 	t.Parallel()
 
-	matches, found := extractTrackerMatches(
+	matches, found := extractTrackerMatchesWithPatterns(
 		"https://reelflix.xyz/torrents/10003",
 		[]string{"https://reelflix.cc/announce/redacted"},
 		true,
 		[]string{"rf"},
+		buildTrackerIDPatterns(trackerPatternRegistry(t)),
 	)
 
 	if !found {
@@ -836,11 +854,13 @@ func TestExtractTrackerMatchesHandlesReelFlixAliasComment(t *testing.T) {
 func TestExtractTrackerMatchesHandlesRetroFlixBrowseComment(t *testing.T) {
 	t.Parallel()
 
-	matches, found := extractTrackerMatches(
+	registry := trackerPatternRegistry(t)
+	matches, found := extractTrackerMatchesWithPatterns(
 		"https://retroflix.club/browse/t/10004",
 		[]string{"http://peer.retroflix.club/announce.php?passkey=redacted"},
 		true,
 		[]string{"rtf"},
+		buildTrackerIDPatterns(registry),
 	)
 
 	if !found {
@@ -854,11 +874,13 @@ func TestExtractTrackerMatchesHandlesRetroFlixBrowseComment(t *testing.T) {
 func TestExtractTrackerMatchesIncludesPatternsOutsidePriority(t *testing.T) {
 	t.Parallel()
 
-	matches, found := extractTrackerMatches(
+	registry := trackerPatternRegistry(t)
+	matches, found := extractTrackerMatchesWithPatterns(
 		"https://retroflix.club/browse/t/10004",
 		[]string{"http://peer.retroflix.club/announce.php?passkey=redacted"},
 		true,
-		trackers.TrackerPriority(),
+		registry.Priority(),
+		buildTrackerIDPatterns(registry),
 	)
 
 	if !found {
@@ -872,7 +894,7 @@ func TestExtractTrackerMatchesIncludesPatternsOutsidePriority(t *testing.T) {
 func TestTorrentMatchesMetaAllowsSymbolDrift(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.ClientSubject{
 		SourcePath: `D:\Movies\Fixture Title 2024 2160p AUS UHD Blu-ray DV HDR HEVC DTS-HD MA 5.1-FixtureGroup` + "\u2122",
 		DiscType:   "BDMV",
 	}
@@ -888,7 +910,7 @@ func TestTorrentMatchesMetaAllowsSymbolDrift(t *testing.T) {
 func TestTorrentMatchesMetaAllowsSeparatorDrift(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.ClientSubject{
 		SourcePath: `/tmp/Movie.Title.2024`,
 		FileList:   []string{`/tmp/Movie.Title.2024.mkv`},
 	}
@@ -902,7 +924,7 @@ func TestTorrentMatchesMetaAllowsSeparatorDrift(t *testing.T) {
 func TestTorrentMatchesMetaRejectsExtraTokens(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{SourcePath: `/tmp/Movie.Title.2024`}
+	meta := api.ClientSubject{SourcePath: `/tmp/Movie.Title.2024`}
 	torrent := qbittorrent.Torrent{Name: "Movie Title 2024 Remux"}
 
 	if torrentMatchesMeta(torrent, meta) {
@@ -913,7 +935,7 @@ func TestTorrentMatchesMetaRejectsExtraTokens(t *testing.T) {
 func TestTorrentMatchesMetaUsesContentPathBasename(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{SourcePath: `/tmp/Movie.Title.2024`}
+	meta := api.ClientSubject{SourcePath: `/tmp/Movie.Title.2024`}
 	torrent := qbittorrent.Torrent{
 		Name:        "Tracker renamed folder",
 		ContentPath: `/downloads/Movie Title 2024`,
@@ -1080,18 +1102,27 @@ func TestResolveSearchClientsNormalizesSelectorCase(t *testing.T) {
 }
 
 func TestBuildTrackerIDPatternsIncludesUnit3DBaseURLs(t *testing.T) {
-	for _, tracker := range trackers.Unit3DTrackers() {
-		baseURL, ok := unit3dmeta.BaseURL(tracker)
+	registry := trackerPatternRegistry(t)
+	patterns := buildTrackerIDPatterns(registry)
+	for _, tracker := range registry.NamesByFamily(trackers.FamilyUnit3D) {
+		baseURL, ok := registry.LookupBaseURL(tracker)
 		if !ok {
 			t.Fatalf("expected base URL for %s", tracker)
 		}
 		key := strings.ToLower(tracker)
-		pattern, found := trackerIDPatterns[key]
+		pattern, found := patterns[key]
 		if !found {
 			t.Fatalf("expected unit3d tracker pattern for %s", key)
 		}
-		if pattern.url != strings.ToLower(baseURL) {
-			t.Fatalf("expected %s URL %q, got %q", key, strings.ToLower(baseURL), pattern.url)
+		foundBaseURL := false
+		for _, trackerURL := range pattern.trackerURLs {
+			if strings.EqualFold(trackerURL, baseURL) {
+				foundBaseURL = true
+				break
+			}
+		}
+		if !foundBaseURL {
+			t.Fatalf("expected %s URL %q, got %q", key, baseURL, pattern.trackerURLs)
 		}
 		match := pattern.pattern.FindStringSubmatch(strings.ToLower(baseURL) + "/torrents/12345")
 		if len(match) != 2 || match[1] != "12345" {
@@ -1101,7 +1132,8 @@ func TestBuildTrackerIDPatternsIncludesUnit3DBaseURLs(t *testing.T) {
 }
 
 func TestTrackerPriorityPlacesPreferredTrackersBeforeRemainingUnit3D(t *testing.T) {
-	result := trackers.TrackerPriority()
+	registry := trackerPatternRegistry(t)
+	result := registry.Priority()
 	expectedPrefix := []string{"aither", "ulcx", "lst", "blu", "oe", "btn", "bhd", "hdb", "ant", "rf", "otw", "yus", "dp", "sp", "ptp"}
 
 	prevIdx := -1
@@ -1117,7 +1149,7 @@ func TestTrackerPriorityPlacesPreferredTrackersBeforeRemainingUnit3D(t *testing.
 	}
 
 	remaining := make([]string, 0)
-	for _, tracker := range trackers.Unit3DTrackers() {
+	for _, tracker := range registry.NamesByFamily(trackers.FamilyUnit3D) {
 		lower := strings.ToLower(tracker)
 		if hasValue(expectedPrefix, lower) {
 			continue
@@ -1138,7 +1170,7 @@ func TestTrackerPriorityPlacesPreferredTrackersBeforeRemainingUnit3D(t *testing.
 }
 
 func TestApplyPreferredTrackerPriorityMovesToFront(t *testing.T) {
-	result := applyPreferredTrackerPriority(trackers.TrackerPriority(), "PTP")
+	result := applyPreferredTrackerPriority(trackerPatternRegistry(t).Priority(), "PTP")
 	if len(result) == 0 {
 		t.Fatalf("expected non-empty priority list")
 	}
@@ -1148,7 +1180,7 @@ func TestApplyPreferredTrackerPriorityMovesToFront(t *testing.T) {
 }
 
 func TestApplyPreferredTrackerPriorityNoopForUnknown(t *testing.T) {
-	priority := trackers.TrackerPriority()
+	priority := trackerPatternRegistry(t).Priority()
 	result := applyPreferredTrackerPriority(priority, "UNKNOWN")
 	if len(result) != len(priority) {
 		t.Fatalf("expected unchanged list length")
diff --git a/internal/torrentclient/service.go b/internal/torrentclient/service.go
new file mode 100644
index 00000000..e5287b70
--- /dev/null
+++ b/internal/torrentclient/service.go
@@ -0,0 +1,779 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package torrentclient injects uploads into configured torrent clients and
+// searches those clients for already-pathed torrents.
+package torrentclient
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/logging"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+
+	qbittorrent "github.com/autobrr/go-qbittorrent"
+)
+
+// Service coordinates torrent-client injection and search operations.
+type Service struct {
+	cfg                config.Config
+	logger             api.Logger
+	trackerPatterns    map[string]trackerPattern
+	trackerPriority    []string
+	smallPieceTrackers []string
+}
+
+// qbit injection HTTP uses a short, single-attempt client so a dead WebUI or
+// Qui proxy fails quickly without timing out local link staging first.
+const (
+	qbitInjectHTTPTimeout       = 30 * time.Second
+	qbitInjectHTTPRetryAttempts = 1
+	qbitLoginResponseMaxBytes   = 4 << 10
+)
+
+// qbitLoginValidatingTransport verifies direct qBittorrent login responses
+// before net/http can persist response cookies in the client's jar.
+type qbitLoginValidatingTransport struct {
+	base http.RoundTripper
+}
+
+// RoundTrip requires the exact qBittorrent success body for HTTP 200 login
+// responses. It bounds the body read and restores valid bodies for LoginCtx.
+func (t qbitLoginValidatingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	resp, err := t.base.RoundTrip(req)
+	if err != nil {
+		return nil, fmt.Errorf("qbit HTTP request: %w", err)
+	}
+	if !strings.HasSuffix(req.URL.Path, "/api/v2/auth/login") || resp.StatusCode != http.StatusOK {
+		return resp, nil
+	}
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, qbitLoginResponseMaxBytes+1))
+	if err != nil {
+		_ = resp.Body.Close()
+		return nil, fmt.Errorf("read qbit login response: %w", err)
+	}
+	if err := resp.Body.Close(); err != nil {
+		return nil, fmt.Errorf("close qbit login response: %w", err)
+	}
+	if len(body) > qbitLoginResponseMaxBytes {
+		return nil, errors.New("qbit login response exceeds limit")
+	}
+	if string(body) != "Ok." {
+		return nil, errors.New("qbit login response was not successful")
+	}
+	resp.Body = io.NopCloser(bytes.NewReader(body))
+	return resp, nil
+}
+
+// NewService returns a torrent-client service without tracker-specific search policies.
+func NewService(cfg config.Config, logger api.Logger) *Service {
+	return NewServiceWithRegistry(cfg, logger, nil)
+}
+
+// NewServiceWithRegistry returns a torrent-client service backed by registry.
+// A nil registry selects an empty registry, and a nil logger selects
+// [api.NopLogger]. Registry-derived policy is copied during construction.
+func NewServiceWithRegistry(cfg config.Config, logger api.Logger, registry *trackers.Registry) *Service {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	if registry == nil {
+		registry = trackers.NewRegistry()
+	}
+	return &Service{
+		cfg:                cfg,
+		logger:             logger,
+		trackerPatterns:    buildTrackerIDPatterns(registry),
+		trackerPriority:    registry.Priority(),
+		smallPieceTrackers: trackerSearchPreferenceNames(registry, trackers.TorrentSearchPreferenceSmallPieces),
+	}
+}
+
+// Inject dispatches a prepared torrent to selected clients in sorted name order
+// and applies per-client delay, path mapping, link staging, category, and tag
+// policy. URL-only torrents require a URL-capable client unless global/default
+// fallback can select one; explicit tracker or caller selections that resolve
+// only to watch-folder clients return [internalerrors.ErrInvalidInput].
+//
+// qBittorrent adds set skip_checking=true for both linked and original-path
+// injection. The first client error stops dispatch; prior watch-folder copies or
+// client adds are not rolled back, while staging created for the failed
+// qBittorrent add is removed when owned by that attempt.
+func (s *Service) Inject(ctx context.Context, meta api.ClientSubject, torrent api.TorrentResult) (err error) {
+	logger := logging.FromContext(ctx, s.logger)
+	defer func() {
+		if err != nil {
+			logger.Warnf("clients: injection blocked err=%s", redaction.RedactValue(err.Error(), nil))
+		}
+	}()
+
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	logger.Debugf("clients: injecting torrent for %s", meta.SourcePath)
+
+	torrentPath := strings.TrimSpace(torrent.Path)
+	torrentURL := strings.TrimSpace(torrent.URL)
+	if torrentPath == "" && torrentURL == "" {
+		logger.Debugf("clients: skipping injection for %s: no torrent file or URL", meta.SourcePath)
+		return internalerrors.ErrInvalidInput
+	}
+	logger.Tracef(
+		"clients: injection input source=%s tracker=%s has_file=%t has_url=%t configured_clients=%d",
+		meta.SourcePath,
+		strings.TrimSpace(torrent.Tracker),
+		torrentPath != "",
+		torrentURL != "",
+		len(s.cfg.TorrentClients),
+	)
+
+	if len(s.cfg.TorrentClients) == 0 {
+		logger.Debugf("clients: no torrent clients configured, skipping injection")
+		return nil
+	}
+
+	clientOverrides := s.resolveInjectClientOverrides(meta.ClientOverrides, torrent.Tracker)
+	clients := resolveInjectClients(s.cfg, clientOverrides)
+	// Tracker-scoped torrent_client is an effective client override; URL
+	// fallback is only for global/default selections that cannot consume URLs.
+	effectiveClientOverride := clientOverrides.Client != nil && strings.TrimSpace(*clientOverrides.Client) != ""
+	if torrentPath == "" && torrentURL != "" && !effectiveClientOverride {
+		clients = withURLCapableInjectFallback(clients, s.cfg.TorrentClients)
+	}
+	if len(clients) == 0 {
+		logger.Debugf("clients: no matching torrent clients selected, skipping injection")
+		return nil
+	}
+	logger.Debugf("clients: selected %d torrent client(s) for injection", len(clients))
+
+	clientNames := make([]string, 0, len(clients))
+	for name := range clients {
+		clientNames = append(clientNames, name)
+	}
+	sort.Strings(clientNames)
+
+	injected := false
+	skippedURLOnlyClients := 0
+	for _, name := range clientNames {
+		client := applyClientOverrides(clients[name], clientOverrides)
+		clientType := strings.ToLower(strings.TrimSpace(client.ClientType()))
+		logger.Debugf("clients: processing client name=%s type=%s", name, clientType)
+		// Watch folders can still consume a local torrent file when URL metadata
+		// is also present. Skip only URL-only input before any injection delay so
+		// a skipped client cannot fail a successful URL add.
+		if clientType == "watch" && torrentPath == "" && torrentURL != "" {
+			logger.Debugf("clients: skipping watch folder client %s for URL injection", name)
+			skippedURLOnlyClients++
+			continue
+		}
+		if err := s.waitInjectDelay(ctx, torrent.Tracker); err != nil {
+			return err
+		}
+		switch clientType {
+		case "none", "disabled":
+			logger.Debugf("clients: skipping disabled client %s", name)
+			continue
+		case "watch":
+			if err := s.injectWatchFolder(ctx, name, client.WatchFolder, torrent.Path); err != nil {
+				return err
+			}
+			injected = true
+		case "qbit", "qbittorrent", "qui":
+			if err := s.injectQbit(ctx, name, client, meta, torrent); err != nil {
+				return err
+			}
+			injected = true
+		case "":
+			return fmt.Errorf("clients: %s type is required", name)
+		default:
+			return fmt.Errorf("clients: type %q not yet supported: %w", client.ClientType(), internalerrors.ErrNotImplemented)
+		}
+	}
+
+	if effectiveClientOverride && torrentPath == "" && torrentURL != "" && skippedURLOnlyClients > 0 && !injected {
+		return fmt.Errorf("clients: no selected torrent client supports URL injection: %w", internalerrors.ErrInvalidInput)
+	}
+
+	logger.Debugf("clients: injection dispatch complete for %s", meta.SourcePath)
+	return nil
+}
+
+func (s *Service) resolveInjectClientOverrides(overrides api.ClientOverrides, tracker string) api.ClientOverrides {
+	if overrides.Client != nil && strings.TrimSpace(*overrides.Client) != "" {
+		return overrides
+	}
+	trackerClient := s.trackerTorrentClient(tracker)
+	if trackerClient == "" {
+		return overrides
+	}
+	overrides.Client = &trackerClient
+	return overrides
+}
+
+func (s *Service) trackerTorrentClient(tracker string) string {
+	trackerCfg, ok := s.trackerConfig(tracker)
+	if !ok {
+		return ""
+	}
+	return strings.TrimSpace(trackerCfg.TorrentClient)
+}
+
+func (s *Service) trackerConfig(tracker string) (config.TrackerConfig, bool) {
+	trackerName := strings.TrimSpace(tracker)
+	if trackerName == "" {
+		return config.TrackerConfig{}, false
+	}
+	for name, trackerCfg := range s.cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), trackerName) {
+			return trackerCfg, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+
+func (s *Service) waitInjectDelay(ctx context.Context, tracker string) error {
+	logger := logging.FromContext(ctx, s.logger)
+	delay := s.cfg.PostUpload.InjectDelay
+	if trackerCfg, ok := s.trackerConfig(tracker); ok && trackerCfg.InjectDelay != nil {
+		delay = *trackerCfg.InjectDelay
+	}
+	if delay <= 0 {
+		return nil
+	}
+
+	logger.Debugf("clients: waiting %ds before injection for tracker %s", delay, strings.TrimSpace(tracker))
+	timer := time.NewTimer(time.Duration(delay) * time.Second)
+	defer timer.Stop()
+
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled: %w", ctx.Err())
+	case <-timer.C:
+		return nil
+	}
+}
+
+func (s *Service) injectWatchFolder(ctx context.Context, name, folder, torrentPath string) error {
+	logger := logging.FromContext(ctx, s.logger)
+	if strings.TrimSpace(folder) == "" {
+		return fmt.Errorf("clients: %s watch_folder is required", name)
+	}
+	logger.Debugf("clients: writing torrent to watch folder for %s", name)
+
+	absTorrent, err := filepath.Abs(torrentPath)
+	if err != nil {
+		return fmt.Errorf("clients: %s torrent: %w", name, err)
+	}
+
+	info, err := os.Stat(folder)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("clients: %s watch_folder: %w", name, internalerrors.ErrNotFound)
+		}
+		return fmt.Errorf("clients: %s watch_folder: %w", name, err)
+	}
+	if !info.IsDir() {
+		return fmt.Errorf("clients: %s watch_folder is not a directory", name)
+	}
+
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	source, err := os.Open(absTorrent)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("clients: %s torrent: %w", name, internalerrors.ErrNotFound)
+		}
+		return fmt.Errorf("clients: %s torrent: %w", name, err)
+	}
+	defer source.Close()
+
+	destPath := filepath.Join(folder, filepath.Base(absTorrent))
+	dest, err := os.Create(destPath)
+	if err != nil {
+		return fmt.Errorf("clients: %s write torrent: %w", name, err)
+	}
+	defer func() {
+		_ = dest.Close()
+	}()
+
+	if _, err := io.Copy(dest, source); err != nil {
+		return fmt.Errorf("clients: %s write torrent: %w", name, err)
+	}
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	logger.Infof("clients: copied torrent to watch folder path=%s", destPath)
+	return nil
+}
+
+func (s *Service) injectQbit(ctx context.Context, name string, client config.TorrentClientConfig, meta api.ClientSubject, torrent api.TorrentResult) error {
+	logger := logging.FromContext(ctx, s.logger)
+	host := strings.TrimSpace(client.QbitHost())
+	if host == "" {
+		return fmt.Errorf("clients: %s qbit host is required", name)
+	}
+	username := strings.TrimSpace(client.QbitUsername())
+	if username == "" && !client.UsesQuiProxy() {
+		return fmt.Errorf("clients: %s qbit username is required", name)
+	}
+	password := strings.TrimSpace(client.QbitPassword())
+	if password == "" && !client.UsesQuiProxy() {
+		return fmt.Errorf("clients: %s qbit password is required", name)
+	}
+
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	qbit := qbittorrent.NewClient(qbitInjectClientConfig(host, username, password, client))
+	qbitHTTP := qbit.GetHTTPClient()
+	baseTransport := qbitHTTP.Transport
+	if baseTransport == nil {
+		baseTransport = http.DefaultTransport
+	}
+	// The transport sees the response before http.Client stores Set-Cookie
+	// values, so a transient body cannot create an authenticated session.
+	qbitHTTP.Transport = qbitLoginValidatingTransport{base: baseTransport}
+
+	options := qbittorrent.TorrentAddOptions{}
+	logger.Debugf("clients: preparing qbit add options client=%s tracker=%s cross_seed=%t", name, strings.TrimSpace(torrent.Tracker), torrent.CrossSeed)
+	optionsStart := time.Now()
+	staging, err := s.prepareLinkStaging(ctx, name, client, meta, torrent)
+	if err != nil {
+		return err
+	}
+	options.SkipHashCheck = true
+	if staging.Linked {
+		options.SavePath = staging.SavePath
+		logger.Debugf(
+			"clients: qbit link staging selected client=%s tracker=%s files=%d layout_validated=%t save_path=%s",
+			name,
+			strings.TrimSpace(torrent.Tracker),
+			staging.FileCount,
+			staging.LayoutValidated,
+			staging.SavePath,
+		)
+	} else {
+		// Without link staging, local_path/remote_path still controls where
+		// qBittorrent should save the injected torrent on the client host.
+		savePath, mapped, err := mappedQbitSavePathForSource(meta, client.LocalPath, client.RemotePath)
+		if err != nil {
+			return fmt.Errorf("clients: %s qbit path mapping: %w", name, err)
+		}
+		if mapped {
+			options.SavePath = savePath
+			logger.Debugf("clients: qbit path mapping ready client=%s save_path=%s", name, savePath)
+		}
+	}
+	if category := strings.TrimSpace(client.QbitCrossCategory); torrent.CrossSeed && category != "" {
+		options.Category = category
+	} else if category := strings.TrimSpace(client.QbitCategory()); category != "" {
+		options.Category = category
+	}
+	if tags := strings.TrimSpace(client.QbitCrossTag); torrent.CrossSeed && tags != "" {
+		options.Tags = tags
+	} else if tags := strings.TrimSpace(client.QbitTags()); tags != "" {
+		options.Tags = tags
+	} else if client.UseTrackerAsTag {
+		options.Tags = strings.TrimSpace(torrent.Tracker)
+	}
+	autoManagement := !staging.Linked && qbitAutomaticManagementEnabled(meta, client.AutomaticManagementPaths)
+	addOptions := options.Prepare()
+	addOptions["autoTMM"] = strconv.FormatBool(autoManagement)
+	logger.Debugf(
+		"clients: qbit add options ready client=%s auto_tmm=%t skip_hash_check=%t elapsed=%s",
+		name,
+		autoManagement,
+		options.SkipHashCheck,
+		time.Since(optionsStart).Round(time.Millisecond),
+	)
+
+	qbitCtx, cancel := context.WithTimeout(ctx, qbitInjectHTTPTimeout)
+	defer cancel()
+
+	logger.Debugf(
+		"clients: connecting to qbit %s timeout=%s retries=%d",
+		redaction.RedactValue(host, nil),
+		qbitInjectHTTPTimeout,
+		qbitInjectHTTPRetryAttempts,
+	)
+	if !client.UsesQuiProxy() {
+		if err := qbit.LoginCtx(qbitCtx); err != nil {
+			s.cleanupFailedLinkStaging(ctx, name, torrent.Tracker, staging)
+			return fmt.Errorf("clients: %s qbit login: %w", name, err)
+		}
+		logger.Debugf("clients: connected to qbit client %s", name)
+	} else {
+		logger.Debugf("clients: using qbit proxy for client %s", name)
+	}
+
+	if torrentPath := strings.TrimSpace(torrent.Path); torrentPath != "" {
+		logger.Debugf("clients: adding torrent file to qbit client %s for %s", name, meta.SourcePath)
+		if _, err := qbit.AddTorrentFromFileCtx(qbitCtx, torrentPath, addOptions); err != nil {
+			s.cleanupFailedLinkStaging(ctx, name, torrent.Tracker, staging)
+			return fmt.Errorf("clients: %s qbit add torrent file: %w", name, err)
+		}
+
+		logger.Infof(
+			"clients: added torrent file to qbit client=%s tracker=%s linked=%t qbit_hash_check=%t source=%s",
+			name,
+			logTracker(torrent.Tracker),
+			staging.Linked,
+			!options.SkipHashCheck,
+			meta.SourcePath,
+		)
+		return nil
+	}
+
+	if torrentURL := strings.TrimSpace(torrent.URL); torrentURL != "" {
+		logger.Debugf("clients: adding tracker torrent URL to qbit client %s for %s", name, meta.SourcePath)
+		if _, err := qbit.AddTorrentFromUrlCtx(qbitCtx, torrentURL, addOptions); err != nil {
+			s.cleanupFailedLinkStaging(ctx, name, torrent.Tracker, staging)
+			return fmt.Errorf("clients: %s qbit add torrent URL: %w", name, err)
+		}
+		logger.Infof(
+			"clients: added tracker torrent URL to qbit client=%s tracker=%s linked=%t qbit_hash_check=%t source=%s",
+			name,
+			logTracker(torrent.Tracker),
+			staging.Linked,
+			!options.SkipHashCheck,
+			meta.SourcePath,
+		)
+		return nil
+	}
+
+	return internalerrors.ErrInvalidInput
+}
+
+// qbitAutomaticManagementEnabled reports whether the original local save path
+// is a configured automatic-management root or one of its descendants after
+// trimming and filepath cleaning. Containment uses host semantics: Windows
+// comparisons ignore case, while case-sensitive systems preserve it. Linked
+// staging is excluded by the caller.
+func qbitAutomaticManagementEnabled(meta api.ClientSubject, configuredPaths config.StringList) bool {
+	if len(configuredPaths) == 0 {
+		return false
+	}
+
+	source, err := sourcePathForQbitSavePath(meta)
+	if err != nil {
+		return false
+	}
+	localSavePath := filepath.Clean(filepath.Dir(source))
+	for _, configuredPath := range configuredPaths {
+		configuredPath = strings.TrimSpace(configuredPath)
+		if configuredPath == "" {
+			continue
+		}
+		configuredPath = filepath.Clean(configuredPath)
+		if pathutil.IsWithinRoot(configuredPath, localSavePath) {
+			return true
+		}
+	}
+	return false
+}
+
+func logTracker(tracker string) string {
+	tracker = strings.TrimSpace(tracker)
+	if tracker == "" {
+		return "none"
+	}
+	return tracker
+}
+
+// qbitInjectClientConfig preserves configured auth and TLS behavior while
+// applying the bounded HTTP policy used only for torrent injection requests.
+func qbitInjectClientConfig(host, username, password string, client config.TorrentClientConfig) qbittorrent.Config {
+	return qbittorrent.Config{
+		Host:          host,
+		Username:      username,
+		Password:      password,
+		TLSSkipVerify: client.QbitTLSSkipVerify(),
+		Timeout:       int(qbitInjectHTTPTimeout / time.Second),
+		RetryAttempts: qbitInjectHTTPRetryAttempts,
+	}
+}
+
+func (s *Service) cleanupFailedLinkStaging(ctx context.Context, clientName string, tracker string, staging linkStagingResult) {
+	logger := logging.FromContext(ctx, s.logger)
+	if staging.Cleanup == nil {
+		return
+	}
+	if err := staging.Cleanup.Run(); err != nil {
+		logger.Warnf("clients: %s cleanup failed after qbit injection error tracker=%s: %v", clientName, strings.TrimSpace(tracker), err)
+		return
+	}
+	logger.Debugf("clients: %s cleaned staged links after qbit injection error tracker=%s", clientName, strings.TrimSpace(tracker))
+}
+
+// resolveInjectClients selects the configured torrent clients that should receive
+// an injected torrent. Explicit client overrides take precedence, then a
+// non-empty injecting_client_list, then default_torrent_client. Configured
+// selectors are authoritative: if a non-empty selector set resolves to no
+// clients, lower-priority fallbacks are skipped.
+func resolveInjectClients(cfg config.Config, overrides api.ClientOverrides) map[string]config.TorrentClientConfig {
+	clients := cfg.TorrentClients
+	if len(clients) == 0 {
+		return nil
+	}
+
+	if overrides.Client != nil && strings.TrimSpace(*overrides.Client) != "" {
+		if isDisableSelector(*overrides.Client) {
+			if selected := selectTorrentClients(clients, []string{*overrides.Client}); len(selected) > 0 {
+				return selected
+			}
+			return disabledTorrentClientSelection()
+		}
+		return selectTorrentClients(clients, []string{*overrides.Client})
+	}
+
+	if hasDisableOnlySelector(cfg.ClientSetup.InjectClients) {
+		return disabledTorrentClientSelection()
+	}
+	if hasNonBlankSelector(cfg.ClientSetup.InjectClients) {
+		return selectTorrentClients(clients, cfg.ClientSetup.InjectClients)
+	}
+
+	if strings.TrimSpace(cfg.ClientSetup.DefaultClient) != "" {
+		if isDisableSelector(cfg.ClientSetup.DefaultClient) {
+			return disabledTorrentClientSelection()
+		}
+		return selectTorrentClients(clients, []string{cfg.ClientSetup.DefaultClient})
+	}
+
+	if len(clients) == 1 {
+		for name, client := range clients {
+			return map[string]config.TorrentClientConfig{name: client}
+		}
+	}
+
+	return nil
+}
+
+// hasNonBlankSelector reports whether a selector list contains at least one
+// real client name. A lone "none" selector is handled separately as an
+// explicit disable sentinel.
+func hasNonBlankSelector(selected []string) bool {
+	for _, value := range selected {
+		if strings.TrimSpace(value) != "" && !isDisableSelector(value) {
+			return true
+		}
+	}
+	return false
+}
+
+// hasDisableOnlySelector reports whether the selector list contains only blank
+// values and "none", with at least one "none" entry.
+func hasDisableOnlySelector(selected []string) bool {
+	hasDisable := false
+	for _, value := range selected {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if !isDisableSelector(trimmed) {
+			return false
+		}
+		hasDisable = true
+	}
+	return hasDisable
+}
+
+// isDisableSelector recognizes the literal selector used in config to disable
+// torrent injection or search fallback. Client configs with Type "disabled" are
+// detected later after a real client has been selected.
+func isDisableSelector(selected string) bool {
+	return strings.EqualFold(strings.TrimSpace(selected), "none")
+}
+
+// disabledTorrentClientSelection returns a synthetic selected client set that
+// carries the same no-op behavior as a configured client with Type "none".
+func disabledTorrentClientSelection() map[string]config.TorrentClientConfig {
+	return map[string]config.TorrentClientConfig{
+		"none": {Type: "none"},
+	}
+}
+
+// selectTorrentClients returns configured clients selected by name. Blank and
+// unknown selectors are ignored; ambiguous case-insensitive selectors are
+// ignored rather than letting map iteration order choose a target. Duplicate
+// selectors are collapsed only after they resolve to the same configured client,
+// so exact case-variant client names can both be selected.
+func selectTorrentClients(clients map[string]config.TorrentClientConfig, selected []string) map[string]config.TorrentClientConfig {
+	if len(clients) == 0 || len(selected) == 0 {
+		return nil
+	}
+
+	matches := make(map[string]config.TorrentClientConfig)
+	seenClients := make(map[string]struct{}, len(selected))
+	for _, value := range selected {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		name, client, ok := lookupTorrentClientConfig(clients, trimmed)
+		if !ok {
+			continue
+		}
+		if _, ok := seenClients[name]; ok {
+			continue
+		}
+		seenClients[name] = struct{}{}
+		matches[name] = client
+	}
+	if len(matches) == 0 {
+		return nil
+	}
+	return matches
+}
+
+// lookupTorrentClientConfig returns the configured client using the original map
+// key casing when selected matches exactly or has exactly one case-insensitive
+// match. Ambiguous exact or folded matches are rejected.
+func lookupTorrentClientConfig(clients map[string]config.TorrentClientConfig, selected string) (string, config.TorrentClientConfig, bool) {
+	trimmed := strings.TrimSpace(selected)
+	if trimmed == "" {
+		return "", config.TorrentClientConfig{}, false
+	}
+
+	exactMatches := make([]string, 0, 1)
+	foldMatches := make([]string, 0, 1)
+	for name := range clients {
+		nameTrimmed := strings.TrimSpace(name)
+		if nameTrimmed == trimmed {
+			exactMatches = append(exactMatches, name)
+			continue
+		}
+		if strings.EqualFold(nameTrimmed, trimmed) {
+			foldMatches = append(foldMatches, name)
+		}
+	}
+
+	switch len(exactMatches) {
+	case 1:
+		name := exactMatches[0]
+		return name, clients[name], true
+	case 0:
+	default:
+		return "", config.TorrentClientConfig{}, false
+	}
+
+	if len(foldMatches) == 1 {
+		name := foldMatches[0]
+		return name, clients[name], true
+	}
+	return "", config.TorrentClientConfig{}, false
+}
+
+// withURLCapableInjectFallback replaces empty or URL-incompatible global/default
+// selections with configured qbit/qui clients for URL-only injection. The
+// original selection is not merged into the fallback set, so unsupported client
+// types cannot fail an otherwise valid URL fallback. Selected none/disabled
+// clients are authoritative and suppress fallback fanout.
+func withURLCapableInjectFallback(selected, configured map[string]config.TorrentClientConfig) map[string]config.TorrentClientConfig {
+	if hasDisabledTorrentClient(selected) {
+		return selected
+	}
+	if hasURLCapableTorrentClient(selected) {
+		return selected
+	}
+
+	fallback := urlCapableTorrentClients(configured)
+	if len(fallback) == 0 {
+		return selected
+	}
+
+	return maps.Clone(fallback)
+}
+
+// hasDisabledTorrentClient reports whether the selected set explicitly disables
+// injection, which must not fan out into fallback clients.
+func hasDisabledTorrentClient(clients map[string]config.TorrentClientConfig) bool {
+	for _, client := range clients {
+		switch strings.ToLower(strings.TrimSpace(client.ClientType())) {
+		case "none", "disabled":
+			return true
+		}
+	}
+	return false
+}
+
+// hasURLCapableTorrentClient reports whether any selected client type can add a
+// torrent by URL.
+func hasURLCapableTorrentClient(clients map[string]config.TorrentClientConfig) bool {
+	for _, client := range clients {
+		if isURLCapableTorrentClient(client) {
+			return true
+		}
+	}
+	return false
+}
+
+// urlCapableTorrentClients returns every configured client that can add a
+// torrent by URL and permits fallback fanout.
+func urlCapableTorrentClients(clients map[string]config.TorrentClientConfig) map[string]config.TorrentClientConfig {
+	matches := make(map[string]config.TorrentClientConfig)
+	for name, client := range clients {
+		if client.FallbackAllowed() && isURLCapableTorrentClient(client) {
+			matches[name] = client
+		}
+	}
+	if len(matches) == 0 {
+		return nil
+	}
+	return matches
+}
+
+// isURLCapableTorrentClient reports whether a client type supports URL adds.
+func isURLCapableTorrentClient(client config.TorrentClientConfig) bool {
+	switch strings.ToLower(strings.TrimSpace(client.ClientType())) {
+	case "qbit", "qbittorrent", "qui":
+		return true
+	default:
+		return false
+	}
+}
+
+func applyClientOverrides(client config.TorrentClientConfig, overrides api.ClientOverrides) config.TorrentClientConfig {
+	if overrides.QbitCategory != nil {
+		client.Category = strings.TrimSpace(*overrides.QbitCategory)
+		client.QbitCategoryValue = strings.TrimSpace(*overrides.QbitCategory)
+	}
+	if overrides.QbitTag != nil {
+		trimmed := strings.TrimSpace(*overrides.QbitTag)
+		client.Tags = nil
+		client.QbitTagsValue = nil
+		client.QbitTag = trimmed
+	}
+	return client
+}
diff --git a/internal/torrentclient/service_test.go b/internal/torrentclient/service_test.go
new file mode 100644
index 00000000..44ffb096
--- /dev/null
+++ b/internal/torrentclient/service_test.go
@@ -0,0 +1,3118 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package torrentclient
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type qbitAddCapture struct {
+	errCh        chan error
+	mu           sync.Mutex
+	addCalls     int
+	category     string
+	savePath     string
+	tags         string
+	autoTMM      string
+	skipChecking string
+}
+
+func newQbitAddCaptureServer(t *testing.T) (*httptest.Server, *qbitAddCapture) {
+	t.Helper()
+
+	capture := &qbitAddCapture{errCh: make(chan error, 1)}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
+				if err := r.ParseMultipartForm(10 << 20); err != nil {
+					capture.errCh <- err
+					w.WriteHeader(http.StatusBadRequest)
+					return
+				}
+			} else if err := r.ParseForm(); err != nil {
+				capture.errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			capture.mu.Lock()
+			capture.addCalls++
+			capture.category = r.FormValue("category")
+			capture.savePath = r.FormValue("savepath")
+			capture.tags = r.FormValue("tags")
+			capture.autoTMM = r.FormValue("autoTMM")
+			capture.skipChecking = r.FormValue("skip_checking")
+			capture.mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	t.Cleanup(server.Close)
+	return server, capture
+}
+
+func TestInjectWatchFolder(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	watch := filepath.Join(dir, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	torrentPath := filepath.Join(dir, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	copied := filepath.Join(watch, filepath.Base(torrentPath))
+	if _, err := os.Stat(copied); err != nil {
+		t.Fatalf("expected copied torrent: %v", err)
+	}
+}
+
+func TestInjectUnsupportedType(t *testing.T) {
+	t.Parallel()
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"rtorrent": {Type: "rtorrent", URL: "http://localhost"},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: "/tmp/file.torrent"})
+	if !errors.Is(err, internalerrors.ErrNotImplemented) {
+		t.Fatalf("expected not implemented error, got %v", err)
+	}
+}
+
+func TestInjectQbitClient(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	loginCalled := false
+	addCalled := false
+	var addCategory string
+	var addTags string
+	var addSkipChecking string
+	var addAutoTMM string
+	var fileCount int
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			mu.Lock()
+			loginCalled = true
+			mu.Unlock()
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCalled = true
+			addCategory = r.FormValue("category")
+			addTags = r.FormValue("tags")
+			addSkipChecking = r.FormValue("skip_checking")
+			addAutoTMM = r.FormValue("autoTMM")
+			if files, ok := r.MultipartForm.File["torrents"]; ok {
+				fileCount = len(files)
+			}
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+				Category: "ua",
+				Tags:     []string{"tag1", "tag2"},
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !loginCalled {
+		t.Fatalf("expected qbit login call")
+	}
+	if !addCalled {
+		t.Fatalf("expected qbit add call")
+	}
+	if addCategory != "ua" {
+		t.Fatalf("expected category ua, got %q", addCategory)
+	}
+	if addTags != "tag1,tag2" {
+		t.Fatalf("expected tags tag1,tag2, got %q", addTags)
+	}
+	if addSkipChecking != "true" {
+		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
+	}
+	if addAutoTMM != "false" {
+		t.Fatalf("expected autoTMM false, got %q", addAutoTMM)
+	}
+	if fileCount != 1 {
+		t.Fatalf("expected 1 torrent file, got %d", fileCount)
+	}
+}
+
+func TestInjectQbitClientRejectsCookieBearingNonOKLogin(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalls := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			http.SetCookie(w, &http.Cookie{Name: "SID", Value: "transient-session"})
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Try again."))
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalls++
+			mu.Unlock()
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	torrentPath := filepath.Join(t.TempDir(), "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "Example.Release.2026.mkv"}, api.TorrentResult{Path: torrentPath})
+	if err == nil {
+		t.Fatal("expected cookie-bearing non-Ok login rejection")
+	}
+	if !strings.Contains(err.Error(), "qbit login") {
+		t.Fatal("expected qbit login error")
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if addCalls != 0 {
+		t.Fatalf("expected no qbit add attempt, got %d", addCalls)
+	}
+}
+
+func TestQbitInjectClientConfigCapsTimeoutAndRetries(t *testing.T) {
+	t.Parallel()
+
+	cfg := qbitInjectClientConfig("http://localhost:8080", "user", "pass", config.TorrentClientConfig{})
+	if cfg.Timeout != int(qbitInjectHTTPTimeout/time.Second) {
+		t.Fatalf("expected timeout %d, got %d", int(qbitInjectHTTPTimeout/time.Second), cfg.Timeout)
+	}
+	if cfg.RetryAttempts != qbitInjectHTTPRetryAttempts {
+		t.Fatalf("expected retry attempts %d, got %d", qbitInjectHTTPRetryAttempts, cfg.RetryAttempts)
+	}
+}
+
+func TestQbitAutomaticManagementEnabledUsesPathBoundaries(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	tests := []struct {
+		name       string
+		sourcePath string
+		configured string
+		want       bool
+	}{
+		{
+			name:       "configured root",
+			sourcePath: filepath.Join(root, "video.mkv"),
+			configured: root,
+			want:       true,
+		},
+		{
+			name:       "configured root child",
+			sourcePath: filepath.Join(root, "child", "video.mkv"),
+			configured: root,
+			want:       true,
+		},
+		{
+			name:       "sibling prefix",
+			sourcePath: filepath.Join(root+"-old", "video.mkv"),
+			configured: root,
+			want:       false,
+		},
+		{
+			name:       "case variant directory",
+			sourcePath: filepath.Join(root, "media", "video.mkv"),
+			configured: filepath.Join(root, "Media"),
+			want:       runtime.GOOS == "windows",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			meta := api.ClientSubject{SourcePath: tt.sourcePath}
+			if got := qbitAutomaticManagementEnabled(meta, config.StringList{tt.configured}); got != tt.want {
+				t.Fatalf("qbitAutomaticManagementEnabled() = %t, want %t", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestInjectQbitClientUsesPathMappingSavePath(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+
+	root := t.TempDir()
+	localRoot := filepath.Join(root, "local")
+	releaseDir := filepath.Join(localRoot, "Movies", "Fixture.Title.2024")
+	if err := os.MkdirAll(releaseDir, 0o700); err != nil {
+		t.Fatalf("mkdir release: %v", err)
+	}
+	source := filepath.Join(releaseDir, "video.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	remoteRoot := "/remote/media"
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:                     "qbit",
+				URL:                      server.URL,
+				Username:                 "user",
+				Password:                 "pass",
+				LocalPath:                config.StringList{"", localRoot},
+				RemotePath:               config.StringList{"/wrong/root", remoteRoot},
+				AutomaticManagementPaths: config.StringList{localRoot},
+			},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: source, FileList: []string{source}}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	wantSavePath := "/remote/media/Movies/Fixture.Title.2024/"
+	if capture.savePath != wantSavePath {
+		t.Fatalf("expected mapped savepath %q, got %q", wantSavePath, capture.savePath)
+	}
+	if capture.autoTMM != "true" {
+		t.Fatalf("expected autoTMM true, got %q", capture.autoTMM)
+	}
+}
+
+func TestInjectQbitClientUsesPathMappingSavePathWithoutSourceStat(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+
+	root := t.TempDir()
+	localRoot := filepath.Join(root, "local")
+	source := filepath.Join(localRoot, "Movies", "Fixture.Title.2024", "video.mkv")
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	remoteRoot := "/remote/media"
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:       "qbit",
+				URL:        server.URL,
+				Username:   "user",
+				Password:   "pass",
+				LocalPath:  config.StringList{localRoot},
+				RemotePath: config.StringList{remoteRoot},
+			},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: source, FileList: []string{source}}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	wantSavePath := "/remote/media/Movies/Fixture.Title.2024/"
+	if capture.savePath != wantSavePath {
+		t.Fatalf("expected mapped savepath %q, got %q", wantSavePath, capture.savePath)
+	}
+}
+
+func TestMappedRemotePathPreservesBlankPathPairAlignment(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	localRoot := filepath.Join(root, "local")
+	otherRoot := filepath.Join(root, "other")
+	source := filepath.Join(localRoot, "Movies", "Fixture.Title.2024", "video.mkv")
+
+	tests := []struct {
+		name    string
+		locals  config.StringList
+		remotes config.StringList
+	}{
+		{
+			name:    "blank local path",
+			locals:  config.StringList{"", localRoot},
+			remotes: config.StringList{"/wrong/root", "/remote/media"},
+		},
+		{
+			name:    "blank remote path",
+			locals:  config.StringList{otherRoot, localRoot},
+			remotes: config.StringList{"", "/remote/media"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := mappedRemotePath(source, tt.locals, tt.remotes)
+			if !ok {
+				t.Fatal("expected mapped path")
+			}
+			want := filepath.Join("/remote/media", "Movies", "Fixture.Title.2024", "video.mkv")
+			if got != want {
+				t.Fatalf("expected mapped path %q, got %q", want, got)
+			}
+		})
+	}
+}
+
+func TestMappedRemotePathUsesMostSpecificRoot(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	linkedRoot := filepath.Join(root, "cross-seed")
+	source := filepath.Join(linkedRoot, "EXAMPLE", "Example.Release.2026.mkv")
+
+	got, ok := mappedRemotePath(
+		source,
+		config.StringList{root, linkedRoot},
+		config.StringList{"/remote/general", "/remote/cross-seed"},
+	)
+	if !ok {
+		t.Fatal("expected mapped path")
+	}
+	want := filepath.Join("/remote/cross-seed", "EXAMPLE", "Example.Release.2026.mkv")
+	if got != want {
+		t.Fatalf("expected most-specific mapped path %q, got %q", want, got)
+	}
+}
+
+func TestMappedRemotePathIsCaseInsensitiveOnWindows(t *testing.T) {
+	t.Parallel()
+
+	if runtime.GOOS != "windows" {
+		t.Skip("Windows path semantics")
+	}
+	root := t.TempDir()
+	source := filepath.Join(root, "CrossSeed", "EXAMPLE", "Example.Release.2026.mkv")
+	localRoot := strings.ToUpper(filepath.Join(root, "crossseed"))
+
+	got, ok := mappedRemotePath(source, config.StringList{localRoot}, config.StringList{"/remote/cross-seed"})
+	if !ok {
+		t.Fatal("expected case-insensitive mapped path")
+	}
+	want := filepath.Join("/remote/cross-seed", "EXAMPLE", "Example.Release.2026.mkv")
+	if got != want {
+		t.Fatalf("expected mapped path %q, got %q", want, got)
+	}
+}
+
+func TestInjectQbitClientUsesRequestOverrides(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	var addCategory string
+	var addTags string
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCategory = r.FormValue("category")
+			addTags = r.FormValue("tags")
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+				Category: "config-cat",
+				Tags:     []string{"config1", "config2"},
+			},
+		},
+	}, nil)
+
+	overrideCategory := "override-cat"
+	overrideTag := "override-tag"
+	meta := api.ClientSubject{
+		SourcePath: "video.mkv",
+		ClientOverrides: api.ClientOverrides{
+			QbitCategory: &overrideCategory,
+			QbitTag:      &overrideTag,
+		},
+	}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if addCategory != "override-cat" {
+		t.Fatalf("expected override category, got %q", addCategory)
+	}
+	if addTags != "override-tag" {
+		t.Fatalf("expected override tag, got %q", addTags)
+	}
+}
+
+func TestInjectQbitClientIgnoresCrossFieldsForNormalTorrent(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:              "qbit",
+				URL:               server.URL,
+				Username:          "user",
+				Password:          "pass",
+				Category:          "config-cat",
+				Tags:              []string{"config1", "config2"},
+				QbitCrossCategory: "cross-cat",
+				QbitCrossTag:      "cross-tag",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.category != "config-cat" {
+		t.Fatalf("expected config category, got %q", capture.category)
+	}
+	if capture.tags != "config1,config2" {
+		t.Fatalf("expected config tags, got %q", capture.tags)
+	}
+}
+
+func TestInjectQbitClientUsesCrossFieldsForCrossSeedTorrent(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:              "qbit",
+				URL:               server.URL,
+				Username:          "user",
+				Password:          "pass",
+				Category:          "config-cat",
+				Tags:              []string{"config1", "config2"},
+				QbitCrossCategory: "cross-cat",
+				QbitCrossTag:      "cross-tag",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{
+		Path:      torrentPath,
+		Tracker:   "AITHER",
+		CrossSeed: true,
+	}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.category != "cross-cat" {
+		t.Fatalf("expected cross category, got %q", capture.category)
+	}
+	if capture.tags != "cross-tag" {
+		t.Fatalf("expected cross tag, got %q", capture.tags)
+	}
+}
+
+func newQbitAddFailureServer(t *testing.T) (*httptest.Server, *qbitAddCapture) {
+	t.Helper()
+
+	capture := &qbitAddCapture{}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
+				if err := r.ParseMultipartForm(10 << 20); err != nil {
+					w.WriteHeader(http.StatusBadRequest)
+					return
+				}
+			} else {
+				if err := r.ParseForm(); err != nil {
+					w.WriteHeader(http.StatusBadRequest)
+					return
+				}
+			}
+			capture.mu.Lock()
+			capture.addCalls++
+			capture.mu.Unlock()
+			w.WriteHeader(http.StatusInternalServerError)
+			_, _ = w.Write([]byte("Fails."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	t.Cleanup(server.Close)
+	return server, capture
+}
+
+func TestInjectQbitClientCleansStagingAfterLoginFailure(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/v2/auth/login" {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		w.WriteHeader(http.StatusUnauthorized)
+		_, _ = w.Write([]byte("Fails."))
+	}))
+	t.Cleanup(server.Close)
+
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"EXAMPLE": {LinkDirName: "example-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
+	if err == nil {
+		t.Fatal("expected qbit login failure")
+	}
+
+	stagingDir := filepath.Join(linkRoot, "example-links")
+	if _, statErr := os.Stat(stagingDir); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected login failure to remove staging, stat err=%v", statErr)
+	}
+}
+
+func TestInjectQbitClientCleansStagingAfterFileAddFailure(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddFailureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"EXAMPLE": {LinkDirName: "example-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
+	if err == nil {
+		t.Fatal("expected qbit add failure")
+	}
+	capture.mu.Lock()
+	addCalls := capture.addCalls
+	capture.mu.Unlock()
+	if addCalls != 1 {
+		t.Fatalf("expected one qbit add attempt, got %d", addCalls)
+	}
+
+	stagedPath := filepath.Join(linkRoot, "example-links", filepath.Base(source))
+	if _, statErr := os.Stat(stagedPath); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected staged file cleanup, stat err=%v", statErr)
+	}
+	if _, statErr := os.Stat(filepath.Join(linkRoot, "example-links")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected tracker staging dir cleanup, stat err=%v", statErr)
+	}
+}
+
+func TestInjectQbitClientURLLinkingFallsBackWithoutStaging(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{URL: "https://tracker.example/torrent/1", Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject URL fallback: %v", err)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	stagedPath := filepath.Join(linkRoot, "aither-links", filepath.Base(source))
+	if _, statErr := os.Stat(stagedPath); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected URL-only injection not to stage files, stat err=%v", statErr)
+	}
+	if _, statErr := os.Stat(filepath.Join(linkRoot, "aither-links")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected URL-only injection not to create tracker staging, stat err=%v", statErr)
+	}
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.addCalls != 1 {
+		t.Fatalf("expected one qbit add attempt, got %d", capture.addCalls)
+	}
+	if capture.skipChecking != "true" {
+		t.Fatalf("expected URL fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
+	}
+}
+
+func TestInjectQbitClientInvalidLinkPlanFallbackSkipsHashCheck(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "Example.Release.2026.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "invalid.torrent")
+	if err := os.WriteFile(torrentPath, []byte("invalid metainfo"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{
+		SourcePath: source,
+		FileList:   []string{source},
+	}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
+	if err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.savePath != "" {
+		t.Fatalf("expected original-path fallback, got savepath %q", capture.savePath)
+	}
+	if capture.skipChecking != "true" {
+		t.Fatalf("expected fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
+	}
+}
+
+func TestInjectQbitClientHardlinksSourceAndUsesLinkedSavePath(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	var addSavePath string
+	var addTags string
+	var addAutoTMM string
+	var addSkipChecking string
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addSavePath = r.FormValue("savepath")
+			addTags = r.FormValue("tags")
+			addAutoTMM = r.FormValue("autoTMM")
+			addSkipChecking = r.FormValue("skip_checking")
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	torrentRoot := "Tracker.Name.2026.mkv"
+	writeQbitTestTorrent(t, torrentPath, torrentRoot, map[string]string{"source": source}, false)
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:                     "qbit",
+				URL:                      server.URL,
+				Username:                 "user",
+				Password:                 "pass",
+				Linking:                  "hardlink",
+				LinkedFolder:             config.StringList{linkRoot},
+				LocalPath:                config.StringList{root},
+				RemotePath:               config.StringList{"/remote/root"},
+				AutomaticManagementPaths: config.StringList{root},
+				UseTrackerAsTag:          true,
+			},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: source, FileList: []string{source}}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	linkedSource := filepath.Join(linkRoot, "aither-links", torrentRoot)
+	sourceInfo, err := os.Stat(source)
+	if err != nil {
+		t.Fatalf("stat source: %v", err)
+	}
+	linkedInfo, err := os.Stat(linkedSource)
+	if err != nil {
+		t.Fatalf("stat linked source: %v", err)
+	}
+	if !os.SameFile(sourceInfo, linkedInfo) {
+		t.Fatalf("expected linked file to share source file identity")
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	wantSavePath := "/remote/root/links/aither-links/"
+	if addSavePath != wantSavePath {
+		t.Fatalf("expected savepath %q, got %q", wantSavePath, addSavePath)
+	}
+	if addTags != "AITHER" {
+		t.Fatalf("expected tracker tag, got %q", addTags)
+	}
+	if addAutoTMM != "false" {
+		t.Fatalf("expected linked injection autoTMM false, got %q", addAutoTMM)
+	}
+	if addSkipChecking != "true" {
+		t.Fatalf("expected linked injection to skip hash checking, got skip_checking=%q", addSkipChecking)
+	}
+}
+
+func TestInjectQbitClientRejectsUnmappedLinkedSavePath(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	mediaRoot := filepath.Join(root, "media")
+	if err := os.MkdirAll(mediaRoot, 0o700); err != nil {
+		t.Fatalf("mkdir media: %v", err)
+	}
+	source := filepath.Join(mediaRoot, "Example.Release.2026.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "cross-seed")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"EXAMPLE": {LinkDirName: "example-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+				LocalPath:    config.StringList{mediaRoot},
+				RemotePath:   config.StringList{"/remote/media"},
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"})
+	if err == nil || !strings.Contains(err.Error(), "outside configured local_path roots") {
+		t.Fatal("expected linked staging path mapping error")
+	}
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.addCalls != 0 {
+		t.Fatal("expected mapping failure to prevent qBittorrent add")
+	}
+	if _, statErr := os.Stat(filepath.Join(linkRoot, "example-links")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatal("expected mapping failure not to create tracker staging")
+	}
+}
+
+func TestInjectQbitClientRejectsUnsafeTrackerLinkDirName(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: filepath.Join("..", "escape")},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"})
+	if !errors.Is(err, internalerrors.ErrInvalidInput) {
+		t.Fatalf("expected invalid input for unsafe link dir name, got %v", err)
+	}
+	if _, statErr := os.Stat(filepath.Join(root, "escape")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("expected no escaped tracker directory, stat err=%v", statErr)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+}
+
+func TestInjectQbitClientRejectsStaleExistingHardlinkDest(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("fresh"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	trackerDir := filepath.Join(linkRoot, "aither-links")
+	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	dest := filepath.Join(trackerDir, filepath.Base(source))
+	if err := os.WriteFile(dest, []byte("stale"), 0o600); err != nil {
+		t.Fatalf("write stale dest: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+	allowFallback := false
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:          "qbit",
+				URL:           server.URL,
+				Username:      "user",
+				Password:      "pass",
+				Linking:       "hardlink",
+				LinkedFolder:  config.StringList{linkRoot},
+				AllowFallback: &allowFallback,
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"})
+	if !errors.Is(err, internalerrors.ErrInvalidInput) {
+		t.Fatalf("expected stale link dest to fail with invalid input, got %v", err)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+}
+
+func TestInjectQbitClientFailedLinkPlanFallbackSkipsHashCheck(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("fresh"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	trackerDir := filepath.Join(linkRoot, "example-links")
+	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	dest := filepath.Join(trackerDir, filepath.Base(source))
+	if err := os.WriteFile(dest, []byte("stale"), 0o600); err != nil {
+		t.Fatalf("write stale dest: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"EXAMPLE": {LinkDirName: "example-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "EXAMPLE"}); err != nil {
+		t.Fatalf("inject failed-link fallback: %v", err)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	if capture.addCalls != 1 {
+		t.Fatalf("expected one qbit add attempt, got %d", capture.addCalls)
+	}
+	if capture.savePath != "" {
+		t.Fatalf("expected original-path fallback, got savepath %q", capture.savePath)
+	}
+	if capture.skipChecking != "true" {
+		t.Fatalf("expected failed-link fallback to skip hash checking, got skip_checking=%q", capture.skipChecking)
+	}
+}
+
+func TestInjectQbitClientAllowsMatchingExistingHardlinkDest(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "links")
+	trackerDir := filepath.Join(linkRoot, "aither-links")
+	if err := os.MkdirAll(trackerDir, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	dest := filepath.Join(trackerDir, filepath.Base(source))
+	if err := os.Link(source, dest); err != nil {
+		t.Fatalf("precreate hardlink dest: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "hardlink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	wantSavePath := filepath.ToSlash(filepath.Join(linkRoot, "aither-links")) + "/"
+	if capture.savePath != wantSavePath {
+		t.Fatalf("expected savepath %q, got %q", wantSavePath, capture.savePath)
+	}
+}
+
+func TestInjectQbitClientTriesLaterLinkedFolderAfterFirstFails(t *testing.T) {
+	t.Parallel()
+
+	server, capture := newQbitAddCaptureServer(t)
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	firstLinkRoot := filepath.Join(root, "links-first")
+	secondLinkRoot := filepath.Join(root, "links-second")
+	firstTrackerDir := filepath.Join(firstLinkRoot, "aither-links")
+	if err := os.MkdirAll(firstTrackerDir, 0o700); err != nil {
+		t.Fatalf("mkdir first links: %v", err)
+	}
+	if err := os.MkdirAll(secondLinkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir second links: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(firstTrackerDir, filepath.Base(source)), []byte("stale"), 0o600); err != nil {
+		t.Fatalf("write stale first dest: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+	allowFallback := false
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-links"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:          "qbit",
+				URL:           server.URL,
+				Username:      "user",
+				Password:      "pass",
+				Linking:       "hardlink",
+				LinkedFolder:  config.StringList{firstLinkRoot, secondLinkRoot},
+				AllowFallback: &allowFallback,
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: source, FileList: []string{source}}, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+	select {
+	case err := <-capture.errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+	capture.mu.Lock()
+	defer capture.mu.Unlock()
+	wantSavePath := filepath.ToSlash(filepath.Join(secondLinkRoot, "aither-links")) + "/"
+	if capture.savePath != wantSavePath {
+		t.Fatalf("expected second linked folder savepath %q, got %q", wantSavePath, capture.savePath)
+	}
+}
+
+func TestLinkedFolderCandidatesWindowsSymlinkDoesNotRepeatSameVolumeFolders(t *testing.T) {
+	t.Parallel()
+
+	if runtime.GOOS != "windows" {
+		t.Skip("windows-specific symlink ordering")
+	}
+
+	root := t.TempDir()
+	source := filepath.Join(root, "source.mkv")
+	if err := os.WriteFile(source, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	firstLinkRoot := filepath.Join(root, "links-first")
+	secondLinkRoot := filepath.Join(root, "links-second")
+	if err := os.MkdirAll(firstLinkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir first links: %v", err)
+	}
+	if err := os.MkdirAll(secondLinkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir second links: %v", err)
+	}
+
+	got, err := linkedFolderCandidates(source, []string{firstLinkRoot, secondLinkRoot}, "symlink")
+	if err != nil {
+		t.Fatalf("linked folder candidates: %v", err)
+	}
+
+	wantFirst, err := absLocalPath("first linked folder", firstLinkRoot)
+	if err != nil {
+		t.Fatalf("first linked folder abs path: %v", err)
+	}
+	wantSecond, err := absLocalPath("second linked folder", secondLinkRoot)
+	if err != nil {
+		t.Fatalf("second linked folder abs path: %v", err)
+	}
+
+	if len(got) != 2 {
+		t.Fatalf("expected 2 unique candidates, got %d (%v)", len(got), got)
+	}
+	if got[0] != wantFirst || got[1] != wantSecond {
+		t.Fatalf("expected ordered unique candidates [%q %q], got %v", wantFirst, wantSecond, got)
+	}
+}
+
+func TestInjectQbitClientReflinksSourceAndUsesLinkedSavePath(t *testing.T) {
+	var mu sync.Mutex
+	var addSavePath string
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addSavePath = r.FormValue("savepath")
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	source := filepath.Join(root, "release")
+	nested := filepath.Join(source, "disc")
+	if err := os.MkdirAll(nested, 0o700); err != nil {
+		t.Fatalf("mkdir source: %v", err)
+	}
+	sourceFile := filepath.Join(nested, "movie.mkv")
+	if err := os.WriteFile(sourceFile, []byte("media"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	linkRoot := filepath.Join(root, "reflinks")
+	if err := os.MkdirAll(linkRoot, 0o700); err != nil {
+		t.Fatalf("mkdir links: %v", err)
+	}
+	torrentPath := filepath.Join(root, "sample.torrent")
+	writeQbitTestTorrentForSource(t, torrentPath, source)
+
+	originalCreateReflink := createReflink
+	var cloneCalls []string
+	createReflink = func(src, dst string) error {
+		cloneCalls = append(cloneCalls, src+"->"+dst)
+		data, err := os.ReadFile(src)
+		if err != nil {
+			return fmt.Errorf("read reflink source: %w", err)
+		}
+		return os.WriteFile(dst, data, 0o600)
+	}
+	t.Cleanup(func() { createReflink = originalCreateReflink })
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"AITHER": {LinkDirName: "aither-reflinks"},
+		}},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:         "qbit",
+				URL:          server.URL,
+				Username:     "user",
+				Password:     "pass",
+				Linking:      "reflink",
+				LinkedFolder: config.StringList{linkRoot},
+			},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: source}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	linkedFile := filepath.Join(linkRoot, "aither-reflinks", filepath.Base(source), "disc", filepath.Base(sourceFile))
+	if _, err := os.Stat(linkedFile); err != nil {
+		t.Fatalf("expected reflinked source file: %v", err)
+	}
+	if len(cloneCalls) != 1 {
+		t.Fatalf("expected 1 reflink call, got %d (%v)", len(cloneCalls), cloneCalls)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	wantSavePath := filepath.ToSlash(filepath.Join(linkRoot, "aither-reflinks")) + "/"
+	if addSavePath != wantSavePath {
+		t.Fatalf("expected savepath %q, got %q", wantSavePath, addSavePath)
+	}
+}
+
+func TestInjectUsesSelectedClientOverride(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	firstWatch := filepath.Join(watchRoot, "first")
+	secondWatch := filepath.Join(watchRoot, "second")
+	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
+		t.Fatalf("mkdir first: %v", err)
+	}
+	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
+		t.Fatalf("mkdir second: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"first":  {Type: "watch", WatchFolder: firstWatch},
+			"second": {Type: "watch", WatchFolder: secondWatch},
+		},
+	}, nil)
+
+	selectedClient := "second"
+	meta := api.ClientSubject{
+		SourcePath: "video.mkv",
+		ClientOverrides: api.ClientOverrides{
+			Client: &selectedClient,
+		},
+	}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected first client untouched, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected second client copy, got %v", err)
+	}
+}
+
+func TestInjectUsesDefaultClientWhenNoInjectionListOrTrackerClient(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	defaultWatch := filepath.Join(watchRoot, "default")
+	otherWatch := filepath.Join(watchRoot, "other")
+	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
+		t.Fatalf("mkdir default: %v", err)
+	}
+	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
+		t.Fatalf("mkdir other: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "default",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"default": {Type: "watch", WatchFolder: defaultWatch},
+			"other":   {Type: "watch", WatchFolder: otherWatch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected default client copy, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected other client untouched, got %v", err)
+	}
+}
+
+func TestInjectUsesMultipleInjectionClients(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	firstWatch := filepath.Join(watchRoot, "first")
+	secondWatch := filepath.Join(watchRoot, "second")
+	thirdWatch := filepath.Join(watchRoot, "third")
+	for _, dir := range []string{firstWatch, secondWatch, thirdWatch} {
+		if err := os.MkdirAll(dir, 0o700); err != nil {
+			t.Fatalf("mkdir %s: %v", dir, err)
+		}
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "first",
+			InjectClients: config.CSVList{"second", "third"},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"first":  {Type: "watch", WatchFolder: firstWatch},
+			"second": {Type: "watch", WatchFolder: secondWatch},
+			"third":  {Type: "watch", WatchFolder: thirdWatch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected default client untouched, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected second client copy, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(thirdWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected third client copy, got %v", err)
+	}
+}
+
+func TestInjectUsesSingleInjectionClientBeforeDefaultClient(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	defaultWatch := filepath.Join(watchRoot, "default")
+	otherWatch := filepath.Join(watchRoot, "other")
+	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
+		t.Fatalf("mkdir default: %v", err)
+	}
+	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
+		t.Fatalf("mkdir other: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "default",
+			InjectClients: config.CSVList{"other"},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"default": {Type: "watch", WatchFolder: defaultWatch},
+			"other":   {Type: "watch", WatchFolder: otherWatch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected default client untouched, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected single injection client copy, got %v", err)
+	}
+}
+
+func TestInjectSkipsDefaultClientWhenInjectionClientUnknown(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	defaultWatch := filepath.Join(watchRoot, "default")
+	if err := os.MkdirAll(defaultWatch, 0o700); err != nil {
+		t.Fatalf("mkdir default: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "default",
+			InjectClients: config.CSVList{"missing"},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"default": {Type: "watch", WatchFolder: defaultWatch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(defaultWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected unknown injection selector to skip default fallback, got %v", err)
+	}
+}
+
+func TestInjectSkipsImplicitSingleClientWhenDefaultClientUnknown(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir watch: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "missing",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected unknown default selector to skip implicit fallback, got %v", err)
+	}
+}
+
+func TestInjectUnknownExplicitClientOverrideSkipsImplicitFallback(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir watch: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	missing := "missing"
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{
+		SourcePath: "video.mkv",
+		ClientOverrides: api.ClientOverrides{
+			Client: &missing,
+		},
+	}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected explicit unknown override to skip fallback, got %v", err)
+	}
+}
+
+func TestInjectUsesTrackerTorrentClient(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	firstWatch := filepath.Join(watchRoot, "first")
+	secondWatch := filepath.Join(watchRoot, "second")
+	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
+		t.Fatalf("mkdir first: %v", err)
+	}
+	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
+		t.Fatalf("mkdir second: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AITHER": {TorrentClient: "second"},
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"first":  {Type: "watch", WatchFolder: firstWatch},
+			"second": {Type: "watch", WatchFolder: secondWatch},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: "video.mkv"}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "aither"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected first client untouched, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected second client copy, got %v", err)
+	}
+}
+
+func TestInjectClientOverrideWinsOverTrackerTorrentClient(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	firstWatch := filepath.Join(watchRoot, "first")
+	secondWatch := filepath.Join(watchRoot, "second")
+	if err := os.MkdirAll(firstWatch, 0o700); err != nil {
+		t.Fatalf("mkdir first: %v", err)
+	}
+	if err := os.MkdirAll(secondWatch, 0o700); err != nil {
+		t.Fatalf("mkdir second: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AITHER": {TorrentClient: "second"},
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"first":  {Type: "watch", WatchFolder: firstWatch},
+			"second": {Type: "watch", WatchFolder: secondWatch},
+		},
+	}, nil)
+
+	selectedClient := "first"
+	meta := api.ClientSubject{
+		SourcePath: "video.mkv",
+		ClientOverrides: api.ClientOverrides{
+			Client: &selectedClient,
+		},
+	}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(firstWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected first client copy, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(secondWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected second client untouched, got %v", err)
+	}
+}
+
+func TestInjectTrackerTorrentClientURLOnlyWatchReturnsErrorWithoutFallback(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AITHER": {TorrentClient: "watch"},
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{
+		URL:     "https://aither.cc/torrent/download/374352.382",
+		Tracker: "aither",
+	})
+	if !errors.Is(err, internalerrors.ErrInvalidInput) {
+		t.Fatalf("expected invalid input error, got %v", err)
+	}
+
+	entries, err := os.ReadDir(watch)
+	if err != nil {
+		t.Fatalf("read watch folder: %v", err)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if addCalled {
+		t.Fatalf("did not expect tracker-selected watch client to fall back to qbit")
+	}
+}
+
+func TestInjectTrackerTorrentClientCanSelectClientNamedNone(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	noneWatch := filepath.Join(watchRoot, "none")
+	otherWatch := filepath.Join(watchRoot, "other")
+	if err := os.MkdirAll(noneWatch, 0o700); err != nil {
+		t.Fatalf("mkdir none: %v", err)
+	}
+	if err := os.MkdirAll(otherWatch, 0o700); err != nil {
+		t.Fatalf("mkdir other: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AITHER": {TorrentClient: "none"},
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"none":  {Type: "watch", WatchFolder: noneWatch},
+			"other": {Type: "watch", WatchFolder: otherWatch},
+		},
+	}, nil)
+
+	meta := api.ClientSubject{SourcePath: "video.mkv"}
+	if err := svc.Inject(context.Background(), meta, api.TorrentResult{Path: torrentPath, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(noneWatch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected none client copy, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(otherWatch, filepath.Base(torrentPath))); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("expected other client untouched, got %v", err)
+	}
+}
+
+func TestSelectTorrentClientsRejectsAmbiguousCaseInsensitiveNames(t *testing.T) {
+	t.Parallel()
+
+	clients := map[string]config.TorrentClientConfig{
+		"Qbit": {Type: "watch"},
+		"qbit": {Type: "qbit"},
+	}
+
+	matches := selectTorrentClients(clients, []string{"QBIT"})
+	if len(matches) != 0 {
+		t.Fatalf("expected ambiguous case-insensitive selector to be ignored, got %v", matches)
+	}
+
+	matches = selectTorrentClients(clients, []string{"qbit"})
+	if len(matches) != 1 {
+		t.Fatalf("expected exact selector match, got %v", matches)
+	}
+	if _, ok := matches["qbit"]; !ok {
+		t.Fatalf("expected exact lower-case client match, got %v", matches)
+	}
+
+	matches = selectTorrentClients(clients, []string{"QBIT", "qbit"})
+	if len(matches) != 1 {
+		t.Fatalf("expected later exact selector after ambiguous selector, got %v", matches)
+	}
+	if _, ok := matches["qbit"]; !ok {
+		t.Fatalf("expected exact lower-case client match after ambiguous selector, got %v", matches)
+	}
+}
+
+func TestSelectTorrentClientsDeduplicatesNormalizedSelectors(t *testing.T) {
+	t.Parallel()
+
+	clients := map[string]config.TorrentClientConfig{
+		"qbit": {Type: "qbit"},
+	}
+
+	matches := selectTorrentClients(clients, []string{"qbit", " QBIT ", "qbit"})
+	if len(matches) != 1 {
+		t.Fatalf("expected duplicate selector variants to select one client, got %v", matches)
+	}
+	if _, ok := matches["qbit"]; !ok {
+		t.Fatalf("expected qbit match, got %v", matches)
+	}
+}
+
+func TestSelectTorrentClientsKeepsExactCaseVariantClients(t *testing.T) {
+	t.Parallel()
+
+	clients := map[string]config.TorrentClientConfig{
+		"Qbit": {Type: "watch"},
+		"qbit": {Type: "qbit"},
+	}
+
+	matches := selectTorrentClients(clients, []string{"Qbit", "qbit"})
+	if len(matches) != 2 {
+		t.Fatalf("expected both exact case-variant clients, got %v", matches)
+	}
+	if _, ok := matches["Qbit"]; !ok {
+		t.Fatalf("expected exact upper-case client match, got %v", matches)
+	}
+	if _, ok := matches["qbit"]; !ok {
+		t.Fatalf("expected exact lower-case client match, got %v", matches)
+	}
+}
+
+func TestInjectDisabledClient(t *testing.T) {
+	t.Parallel()
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"disabled": {Type: "none"},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: "/tmp/file.torrent"}); err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+}
+
+func TestInjectQuiProxyClient(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	loginCalled := false
+	addCalled := false
+	var fileCount int
+	var addSkipChecking string
+	proxyPrefix := "/proxy/abc123"
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case proxyPrefix + "/api/v2/auth/login":
+			mu.Lock()
+			loginCalled = true
+			mu.Unlock()
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case proxyPrefix + "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCalled = true
+			addSkipChecking = r.FormValue("skip_checking")
+			if files, ok := r.MultipartForm.File["torrents"]; ok {
+				fileCount = len(files)
+			}
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:        "qbit",
+				QuiProxyURL: server.URL + proxyPrefix,
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if loginCalled {
+		t.Fatalf("did not expect qbit login call")
+	}
+	if !addCalled {
+		t.Fatalf("expected qbit add call")
+	}
+	if addSkipChecking != "true" {
+		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
+	}
+	if fileCount != 1 {
+		t.Fatalf("expected 1 torrent file, got %d", fileCount)
+	}
+}
+
+func TestInjectWatchFolderTempTorrent(t *testing.T) {
+	t.Parallel()
+
+	patterns := []string{
+		filepath.Join(os.TempDir(), "*.torrent"),
+		filepath.Join(os.TempDir(), "**", "*.torrent"),
+	}
+	var torrentPath string
+	for _, pattern := range patterns {
+		matches, err := filepath.Glob(pattern)
+		if err != nil {
+			continue
+		}
+		if len(matches) > 0 {
+			torrentPath = matches[0]
+			break
+		}
+	}
+	if torrentPath == "" {
+		t.Skip("no .torrent files found in temp directory")
+	}
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{Path: torrentPath}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	copied := filepath.Join(watch, filepath.Base(torrentPath))
+	if _, err := os.Stat(copied); err != nil {
+		t.Fatalf("expected copied torrent: %v", err)
+	}
+}
+
+func TestInjectQbitClientFromURL(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	loginCalled := false
+	addCalled := false
+	var addedURLs string
+	var addSkipChecking string
+	var fileCount int
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			mu.Lock()
+			loginCalled = true
+			mu.Unlock()
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseForm(); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCalled = true
+			addedURLs = r.FormValue("urls")
+			addSkipChecking = r.FormValue("skip_checking")
+			fileCount = 0
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	injectURL := "https://aither.cc/torrent/download/374352.382"
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: injectURL, Tracker: "AITHER"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !loginCalled {
+		t.Fatalf("expected qbit login call")
+	}
+	if !addCalled {
+		t.Fatalf("expected qbit add call")
+	}
+	if addedURLs != injectURL {
+		t.Fatalf("expected injected URL %q, got %q", injectURL, addedURLs)
+	}
+	if addSkipChecking != "true" {
+		t.Fatalf("expected skip_checking true, got %q", addSkipChecking)
+	}
+	if fileCount != 0 {
+		t.Fatalf("expected 0 torrent files for URL add, got %d", fileCount)
+	}
+}
+
+func TestInjectQbitClientPrefersTorrentFileOverURL(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	var addedURLs string
+	var fileCount int
+	errCh := make(chan error, 1)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseMultipartForm(10 << 20); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCalled = true
+			addedURLs = r.FormValue("urls")
+			if r.MultipartForm != nil {
+				if files, ok := r.MultipartForm.File["torrents"]; ok {
+					fileCount = len(files)
+				}
+			}
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{
+		Path:    torrentPath,
+		URL:     "https://aither.cc/torrent/download/374352.382",
+		Tracker: "AITHER",
+	}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit add call")
+	}
+	if fileCount != 1 {
+		t.Fatalf("expected 1 torrent file, got %d", fileCount)
+	}
+	if addedURLs != "" {
+		t.Fatalf("expected empty URL payload when path is provided, got %q", addedURLs)
+	}
+}
+
+func TestInjectURLSkipsWatchFolderClient(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "qbit",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	entries, err := os.ReadDir(watch)
+	if err != nil {
+		t.Fatalf("read watch folder: %v", err)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectURLFallsBackToQbitWhenDefaultWatchCannotHandleURL(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "watch",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	entries, err := os.ReadDir(watch)
+	if err != nil {
+		t.Fatalf("read watch folder: %v", err)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected watch folder untouched for URL injection, got %d entries", len(entries))
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectURLFallbackIgnoresUnsupportedSelectedClient(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "rtorrent",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"rtorrent": {Type: "rtorrent"},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectURLDefaultDisabledDoesNotFallbackToQbit(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "disabled",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"disabled": {Type: "disabled"},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if addCalled {
+		t.Fatalf("did not expect disabled default client to fall back to qbit")
+	}
+}
+
+func TestInjectURLUnknownDefaultFallsBackToQbit(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "missing",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectURLUnknownInjectionListFallsBackToQbit(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "missing-default",
+			InjectClients: config.CSVList{
+				"missing-inject",
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectURLInjectionListDisabledDoesNotFallbackToQbit(t *testing.T) {
+	t.Parallel()
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "qbit",
+			InjectClients: config.CSVList{
+				"disabled",
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"disabled": {Type: "none"},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if addCalled {
+		t.Fatalf("did not expect disabled injection client to fall back to qbit")
+	}
+}
+
+func TestInjectURLFallbackSkipsQbitWhenFallbackDisallowed(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	allowFallback := false
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "watch",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:          "qbit",
+				URL:           server.URL,
+				Username:      "user",
+				Password:      "pass",
+				AllowFallback: &allowFallback,
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if addCalled {
+		t.Fatalf("did not expect qbit client with fallback disabled to receive URL fallback")
+	}
+}
+
+func TestInjectWatchFolderCopiesFileWhenURLAlsoPresent(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	torrentPath := filepath.Join(watchRoot, "sample.torrent")
+	if err := os.WriteFile(torrentPath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "watch",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{
+		Path: torrentPath,
+		URL:  "https://aither.cc/torrent/download/374352.382",
+	}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(watch, filepath.Base(torrentPath))); err != nil {
+		t.Fatalf("expected watch client copy with file and URL, got %v", err)
+	}
+}
+
+func TestInjectURLFallbackSkipsWatchBeforeDelay(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCalled := false
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			mu.Lock()
+			addCalled = true
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			if flusher, ok := w.(http.Flusher); ok {
+				flusher.Flush()
+			}
+			go func() {
+				time.Sleep(100 * time.Millisecond)
+				cancel()
+			}()
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		PostUpload: config.PostUploadConfig{InjectDelay: 1},
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "watch",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	err := svc.Inject(ctx, api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://aither.cc/torrent/download/374352.382"})
+	if err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !addCalled {
+		t.Fatalf("expected qbit URL add call")
+	}
+}
+
+func TestInjectCrossSeedURLFallbackPreservesQbitMetadata(t *testing.T) {
+	t.Parallel()
+
+	watchRoot := t.TempDir()
+	watch := filepath.Join(watchRoot, "watch")
+	if err := os.MkdirAll(watch, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+
+	var mu sync.Mutex
+	addCategory := ""
+	addTags := ""
+	errCh := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			if err := r.ParseForm(); err != nil {
+				errCh <- err
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			mu.Lock()
+			addCategory = r.FormValue("category")
+			addTags = r.FormValue("tags")
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		ClientSetup: config.ClientSetupConfig{
+			DefaultClient: "watch",
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"watch": {Type: "watch", WatchFolder: watch},
+			"qbit": {
+				Type:              "qbit",
+				URL:               server.URL,
+				Username:          "user",
+				Password:          "pass",
+				QbitCrossCategory: "cross-cat",
+				QbitCrossTag:      "cross-tag",
+			},
+		},
+	}, nil)
+
+	if err := svc.Inject(context.Background(), api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{
+		URL:       "https://aither.cc/torrent/download/374352.382",
+		Tracker:   "AITHER",
+		CrossSeed: true,
+	}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+
+	select {
+	case err := <-errCh:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if addCategory != "cross-cat" {
+		t.Fatalf("expected cross category, got %q", addCategory)
+	}
+	if addTags != "cross-tag" {
+		t.Fatalf("expected cross tag, got %q", addTags)
+	}
+}
+
+func TestInjectHonorsGlobalDelayCancellation(t *testing.T) {
+	t.Parallel()
+
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			addCalled = true
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	svc := NewService(config.Config{
+		PostUpload: config.PostUploadConfig{InjectDelay: 1},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	err := svc.Inject(ctx, api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://tracker.example/download/1", Tracker: "AITHER"})
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("expected deadline exceeded, got %v", err)
+	}
+	if addCalled {
+		t.Fatalf("did not expect qbit add call before delay elapsed")
+	}
+}
+
+func TestInjectTrackerDelayOverrideBeatsGlobalDelay(t *testing.T) {
+	t.Parallel()
+
+	addCalled := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v2/auth/login":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		case "/api/v2/torrents/add":
+			addCalled = true
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("Ok."))
+			return
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+	}))
+	defer server.Close()
+
+	overrideDelay := 0
+	svc := NewService(config.Config{
+		PostUpload: config.PostUploadConfig{InjectDelay: 1},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AITHER": {InjectDelay: &overrideDelay},
+			},
+		},
+		TorrentClients: map[string]config.TorrentClientConfig{
+			"qbit": {
+				Type:     "qbit",
+				URL:      server.URL,
+				Username: "user",
+				Password: "pass",
+			},
+		},
+	}, nil)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	if err := svc.Inject(ctx, api.ClientSubject{SourcePath: "video.mkv"}, api.TorrentResult{URL: "https://tracker.example/download/1", Tracker: "aither"}); err != nil {
+		t.Fatalf("inject: %v", err)
+	}
+	if !addCalled {
+		t.Fatalf("expected qbit add call without global delay because tracker override is zero")
+	}
+}
diff --git a/internal/torrentmeta/comment.go b/internal/torrentmeta/comment.go
deleted file mode 100644
index 19c0faeb..00000000
--- a/internal/torrentmeta/comment.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package torrentmeta
-
-const (
-	UploadCreatedBy       = "uploaded with upbrr"
-	MkbrrUploadCreatedBy  = UploadCreatedBy + " using mkbrr"
-	UploadCommentFallback = "upbrr"
-)
diff --git a/internal/trackerauth/adapters.go b/internal/trackerauth/adapters.go
deleted file mode 100644
index 4f37dac7..00000000
--- a/internal/trackerauth/adapters.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerauth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/trackers/impl/btn"
-	"github.com/autobrr/upbrr/internal/trackers/impl/mtv"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ptp"
-	"github.com/autobrr/upbrr/internal/trackers/impl/rtf"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type sessionResolver func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) error
-
-type trackerAdapter struct {
-	capability api.TrackerAuthCapability
-	resolve    sessionResolver
-}
-
-func defaultAdapters() map[string]Adapter {
-	adapters := map[string]Adapter{}
-	for _, spec := range builtInSpecs() {
-		switch spec.id {
-		case "AR":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: resolveARSessionForTrackerAuth}
-		case "BTN":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: btn.ResolveSessionForTrackerAuthLogin}
-		case "FF":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: resolveFFSessionForTrackerAuth}
-		case "FL":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: resolveFLSessionForTrackerAuth}
-		case "HDB":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: resolveHDBStoredSessionForTrackerAuth}
-		case "MTV":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: mtv.ResolveSessionForTrackerAuthLogin}
-		case "PTP":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: ptp.ResolveSessionForTrackerAuthLogin}
-		case "RTF":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: rtf.ResolveSessionForTrackerAuthLogin}
-		case "THR":
-			adapters[spec.id] = trackerAdapter{capability: capabilityFromSpec(spec), resolve: resolveTHRSessionForTrackerAuth}
-		}
-	}
-	return adapters
-}
-
-func (s *Service) adapterFor(trackerID string) (Adapter, bool) {
-	if s.adapters == nil {
-		s.adapters = defaultAdapters()
-	}
-	adapter, ok := s.adapters[normalizeTrackerID(trackerID)]
-	return adapter, ok
-}
-
-func (a trackerAdapter) Capability() api.TrackerAuthCapability {
-	return a.capability
-}
-
-func (a trackerAdapter) Status(ctx context.Context, cfg config.TrackerConfig, dbPath string) (api.TrackerAuthStatus, error) {
-	_ = cfg
-	trackerID := normalizeTrackerID(a.capability.TrackerID)
-	status := api.TrackerAuthStatus{
-		TrackerID:        trackerID,
-		DisplayName:      trackerID,
-		State:            StateNotConfigured,
-		LastCheckedAt:    time.Now().UTC().Format(time.RFC3339),
-		EncryptedStorage: strings.TrimSpace(dbPath) != "",
-	}
-	if a.capability.SupportsCookieFile {
-		values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, trackerID)
-		if err == nil && len(values) > 0 {
-			status.CookieCount = len(values)
-			status.State = StateHasCookies
-		}
-	}
-	return status, nil
-}
-
-func (a trackerAdapter) Validate(ctx context.Context, cfg config.TrackerConfig, dbPath string) (Session, error) {
-	if a.resolve == nil {
-		return Session{}, &UnsupportedAuthError{TrackerID: a.capability.TrackerID, Reason: "remote validation unavailable"}
-	}
-	if err := a.resolve(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{}); err != nil {
-		return Session{}, classifyAdapterError(a.capability.TrackerID, err)
-	}
-	return Session{TrackerID: normalizeTrackerID(a.capability.TrackerID), State: SessionStateReady, Message: "session ready"}, nil
-}
-
-func (a trackerAdapter) Login(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
-	if a.resolve == nil {
-		return Session{}, &UnsupportedAuthError{TrackerID: a.capability.TrackerID, Reason: "remote login unavailable"}
-	}
-	if err := a.resolve(ctx, cfg, dbPath, req); err != nil {
-		return Session{}, classifyAdapterError(a.capability.TrackerID, err)
-	}
-	return Session{TrackerID: normalizeTrackerID(a.capability.TrackerID), State: SessionStateReady, Message: "session ready"}, nil
-}
-
-func (a trackerAdapter) Submit2FA(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
-	return a.Login(ctx, cfg, dbPath, req)
-}
-
-func (a trackerAdapter) Delete(ctx context.Context, dbPath string) error {
-	if err := cookies.DeleteTrackerCookies(ctx, dbPath, normalizeTrackerID(a.capability.TrackerID)); err != nil {
-		return fmt.Errorf("tracker auth: delete %s cookies: %w", normalizeTrackerID(a.capability.TrackerID), err)
-	}
-	return nil
-}
-
-// classifyAdapterError maps tracker adapter failures to typed auth errors used
-// by EnsureSession. Only explicit 2FA-required failures become manual
-// challenges; parser/layout failures and other remote failures remain transient.
-func classifyAdapterError(trackerID string, err error) error {
-	if err == nil {
-		return nil
-	}
-	var authRequired *AuthRequiredError
-	if errors.As(err, &authRequired) {
-		return authRequired
-	}
-	var needs2FA *Needs2FAError
-	if errors.As(err, &needs2FA) {
-		return needs2FA
-	}
-	var unsupported *UnsupportedAuthError
-	if errors.As(err, &unsupported) {
-		return unsupported
-	}
-	if validation, ok := asValidationError(err); ok {
-		return validation
-	}
-	if strings.EqualFold(trackerID, "BTN") && strings.Contains(strings.ToLower(err.Error()), "stored session confirmed invalid") {
-		return &ValidationError{TrackerID: trackerID, ConfirmedInvalid: true, Reason: "stored session expired", Err: err}
-	}
-	if isSubmitted2FARejected(err) {
-		return &ValidationError{TrackerID: trackerID, Transient: true, Submitted2FARejected: true, Reason: "submitted 2FA rejected", Err: err}
-	}
-	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
-		return &ValidationError{TrackerID: trackerID, Transient: true, Reason: "remote validation unavailable", Err: err}
-	}
-	lower := strings.ToLower(err.Error())
-	switch {
-	case contains2FARequiredText(lower):
-		return &Needs2FAError{TrackerID: trackerID, Reason: "2FA required", Err: err}
-	case strings.Contains(lower, "username") || strings.Contains(lower, "password") || strings.Contains(lower, "announce_url") || strings.Contains(lower, "not configured"):
-		return &AuthRequiredError{TrackerID: trackerID, Reason: "credentials missing", Err: err}
-	default:
-		return &ValidationError{TrackerID: trackerID, Transient: true, Reason: "remote validation failed", Err: err}
-	}
-}
-
-func isSubmitted2FARejected(err error) bool {
-	return errors.Is(err, ptp.ErrSubmitted2FARejected) || errors.Is(err, mtv.ErrSubmitted2FARejected) || errors.Is(err, btn.ErrSubmitted2FARejected)
-}
-
-// contains2FARequiredText matches only the standalone "2FA required" phrase so
-// parser details such as token names or setup URLs do not create manual 2FA
-// challenges.
-func contains2FARequiredText(lower string) bool {
-	const phrase = "2fa required"
-	for offset := 0; offset < len(lower); {
-		idx := strings.Index(lower[offset:], phrase)
-		if idx < 0 {
-			return false
-		}
-		start := offset + idx
-		end := start + len(phrase)
-		if isClassifierBoundary(lower, start-1) && isClassifierBoundary(lower, end) {
-			return true
-		}
-		offset = start + 1
-	}
-	return false
-}
-
-func isClassifierBoundary(s string, idx int) bool {
-	if idx < 0 || idx >= len(s) {
-		return true
-	}
-	c := s[idx]
-	return (c < 'a' || c > 'z') && (c < '0' || c > '9')
-}
diff --git a/internal/trackerauth/service.go b/internal/trackerauth/service.go
deleted file mode 100644
index c4093851..00000000
--- a/internal/trackerauth/service.go
+++ /dev/null
@@ -1,1416 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerauth
-
-import (
-	"bytes"
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-
-	"golang.org/x/sync/errgroup"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/redaction"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-// Tracker auth status values returned in api.TrackerAuthStatus.State.
-const (
-	// MaxCookieImportContentBytes is the shared decoded cookie text byte limit for web, Wails, and service imports.
-	MaxCookieImportContentBytes = 1024 * 1024
-
-	// StateConfigured means required non-cookie config auth material is present.
-	StateConfigured = "configured"
-	// StateHasCookies means encrypted cookie storage contains at least one cookie for the tracker.
-	StateHasCookies = "has_cookies"
-	// StateNotConfigured means no supported auth material is currently configured.
-	StateNotConfigured = "not_configured"
-	// StateLoginRequired means credentials or imported cookies are required before tracker auth can proceed.
-	StateLoginRequired = "login_required"
-	// StateEncryptedStorageUnavailable means cookie import cannot be used until web auth material exists.
-	StateEncryptedStorageUnavailable = "encrypted_storage_unavailable"
-
-	// maxConcurrentValidations bounds simultaneous tracker and auth DB work.
-	maxConcurrentValidations = 4
-
-	expiredSessionActionMessage = "stored session expired or invalid; log in again or import fresh cookies"
-)
-
-// Service reports and manages persisted tracker auth material for configured trackers.
-type Service struct {
-	cfg                config.Config
-	adapters           map[string]Adapter
-	challenges         *ChallengeManager
-	logger             api.Logger
-	now                func() time.Time
-	afterDeleteCleanup func()
-}
-
-type trackerSpec struct {
-	id        string
-	authKind  string
-	cookies   bool
-	login     bool
-	autoLogin bool
-	totp      bool
-	// manual2FA permits adapter Needs2FA errors to become reusable Submit2FA challenges.
-	manual2FA        bool
-	apiKey           bool
-	passkey          bool
-	needsCredentials bool
-	notes            []string
-}
-
-// NewService builds a tracker auth service with default remote adapters and the shared manual 2FA challenge manager.
-func NewService(cfg config.Config) *Service {
-	return NewServiceWithLogger(cfg, api.NopLogger{})
-}
-
-// NewServiceWithLogger builds a tracker auth service that writes auth operation
-// outcomes to logger without logging cookie values, credentials, 2FA codes, or
-// challenge identifiers. Nil logger uses [api.NopLogger].
-func NewServiceWithLogger(cfg config.Config, logger api.Logger) *Service {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	return &Service{
-		cfg:        cfg,
-		adapters:   defaultAdapters(),
-		challenges: sharedChallengeManager,
-		logger:     logger,
-		now:        time.Now,
-	}
-}
-
-func (s *Service) logInfof(format string, args ...any) {
-	if s == nil || s.logger == nil {
-		return
-	}
-	s.logger.Infof(format, args...)
-}
-
-func (s *Service) logTracef(format string, args ...any) {
-	if s == nil || s.logger == nil {
-		return
-	}
-	s.logger.Tracef(format, args...)
-}
-
-func (s *Service) logWarnf(format string, args ...any) {
-	if s == nil || s.logger == nil {
-		return
-	}
-	s.logger.Warnf(format, args...)
-}
-
-// logStatus records the user-visible auth state returned to callers, keeping
-// the log payload to tracker ID, state, cookie count, encrypted-storage state,
-// 2FA requirement, and already-redacted status errors.
-func (s *Service) logStatus(operation string, status api.TrackerAuthStatus) {
-	if strings.TrimSpace(status.LastError) != "" {
-		s.logWarnf(
-			"tracker auth: %s warning tracker=%s state=%s error=%s",
-			operation,
-			trackerLogID(status.TrackerID),
-			status.State,
-			status.LastError,
-		)
-		return
-	}
-	logf := s.logTracef
-	if operation == "login completed" && status.State == StateConfigured {
-		logf = s.logInfof
-	}
-	logf(
-		"tracker auth: %s tracker=%s state=%s cookies=%d encrypted_storage=%t needs_2fa=%t",
-		operation,
-		trackerLogID(status.TrackerID),
-		status.State,
-		status.CookieCount,
-		status.EncryptedStorage,
-		status.Needs2FA,
-	)
-}
-
-// trackerLogID normalizes tracker IDs for log messages and avoids empty tracker
-// fields when validation fails before a concrete tracker is resolved.
-func trackerLogID(trackerID string) string {
-	trackerID = normalizeTrackerID(trackerID)
-	if trackerID == "" {
-		return "unknown"
-	}
-	return trackerID
-}
-
-// Capabilities returns tracker auth support metadata for built-in trackers and configured custom trackers.
-func (s *Service) Capabilities(_ context.Context) (caps []api.TrackerAuthCapability, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: capabilities failed: %v", err)
-			return
-		}
-		s.logTracef("tracker auth: capabilities loaded count=%d", len(caps))
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return nil, err
-	}
-	specs := s.specs()
-	out := make([]api.TrackerAuthCapability, 0, len(specs))
-	for _, spec := range specs {
-		out = append(out, s.capabilityForSpec(spec))
-	}
-	return out, nil
-}
-
-// Status returns local tracker auth state derived from config, encrypted cookie storage, and stored cookies.
-func (s *Service) Status(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: status failed tracker=%s: %v", trackerLogID(trackerID), err)
-			return
-		}
-		s.logStatus("status checked", status)
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	spec, err := s.specFor(trackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	return s.statusForSpec(ctx, spec), nil
-}
-
-// ImportCookies parses supplied cookie content, saves it for trackerID, and
-// returns refreshed auth status from persisted cookie/auth state. Parser errors
-// leave existing stored cookies unchanged. BTN imports still report a missing
-// API-key prerequisite when cookies alone do not make the tracker upload-ready.
-func (s *Service) ImportCookies(ctx context.Context, trackerID string, fileName string, content string) (status api.TrackerAuthStatus, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: cookie import failed tracker=%s bytes=%d: %v", trackerLogID(trackerID), len(content), err)
-			return
-		}
-		s.logStatus("cookies imported", status)
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	spec, err := s.specFor(trackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	if !spec.cookies {
-		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: %s does not support cookie import", spec.id)
-	}
-	values, err := ParseCookieContent(fileName, content)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	if err := cookies.SaveTrackerCookieMap(ctx, s.cfg.MainSettings.DBPath, spec.id, values); err != nil {
-		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: import %s cookies: %w", spec.id, err)
-	}
-	status = s.statusForSpec(ctx, spec)
-	if status.State != StateLoginRequired || !isBTNSpec(spec) || !strings.Contains(status.Message, "API key is required") {
-		status.State = StateHasCookies
-		status.Message = "cookies imported"
-	}
-	return status, nil
-}
-
-// Validate returns tracker auth status after a remote validation check when the
-// tracker has an adapter. Confirmed-invalid stored sessions are deleted and
-// reported as login-required status without returning an error. BTN session
-// success remains login-required until the API token needed for torrent
-// resolution is configured. Returned cookie counts and RFC3339 timestamps are
-// rebuilt after login or deletion side effects complete.
-func (s *Service) Validate(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: validation failed tracker=%s: %v", trackerLogID(trackerID), err)
-			return
-		}
-		s.logStatus("validation completed", status)
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	spec, err := s.specFor(trackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	status = s.statusForSpec(ctx, spec)
-
-	if _, ok := s.adapterFor(spec.id); ok {
-		session, ensureErr := s.EnsureSession(ctx, EnsureRequest{
-			TrackerID: spec.id,
-			Config:    mustTrackerConfig(s.cfg, spec.id),
-			DBPath:    s.cfg.MainSettings.DBPath,
-			AutoLogin: true,
-		})
-		if ensureErr != nil {
-			status = s.statusForSpec(ctx, spec)
-			applyEnsureErrorToStatus(&status, ensureErr)
-			if session.ChallengeID != "" {
-				status.ChallengeID = session.ChallengeID
-			}
-			return status, nil
-		}
-		status = s.statusForSpec(ctx, spec)
-		if isBTNSpec(spec) && !s.btnAPIKeyConfigured() {
-			status.State = StateLoginRequired
-			status.Message = btnMissingAPIKeyMessage()
-			return status, nil
-		}
-		status.State = StateConfigured
-		status.Message = "remote auth check succeeded"
-		return status, nil
-	}
-	status.Message = "remote auth validation is not supported for this tracker"
-	return status, nil
-}
-
-// ValidateMany validates every tracker concurrently and returns statuses in
-// input order. It waits for the full batch with bounded concurrency; if any
-// validation fails, it returns the first input-ordered error and no statuses.
-func (s *Service) ValidateMany(ctx context.Context, trackerIDs []string) ([]api.TrackerAuthStatus, error) {
-	statuses := make([]api.TrackerAuthStatus, len(trackerIDs))
-	errs := make([]error, len(trackerIDs))
-
-	var group errgroup.Group
-	group.SetLimit(maxConcurrentValidations)
-	for i, trackerID := range trackerIDs {
-		group.Go(func() error {
-			statuses[i], errs[i] = s.Validate(ctx, trackerID)
-			return nil
-		})
-	}
-	_ = group.Wait()
-
-	for i, err := range errs {
-		if err != nil {
-			return nil, fmt.Errorf("tracker auth: validate %s: %w", trackerLogID(trackerIDs[i]), err)
-		}
-	}
-	return statuses, nil
-}
-
-// IsManagedCapability reports whether a capability requires session, login,
-// refresh, or 2FA handling rather than only static API-key/passkey config.
-func IsManagedCapability(capability api.TrackerAuthCapability) bool {
-	authKind := strings.ToLower(strings.TrimSpace(capability.AuthKind))
-	return capability.SupportsCookieFile ||
-		capability.SupportsLogin ||
-		capability.SupportsAutoLogin ||
-		capability.SupportsTOTP ||
-		capability.SupportsManual2FA ||
-		strings.Contains(authKind, "refresh") ||
-		strings.Contains(authKind, "2fa")
-}
-
-// IsReadyStatus reports whether a status represents usable auth without further
-// user input. A pending 2FA challenge is never ready, regardless of state.
-func IsReadyStatus(status api.TrackerAuthStatus) bool {
-	if status.Needs2FA {
-		return false
-	}
-	switch strings.TrimSpace(status.State) {
-	case StateConfigured, StateHasCookies:
-		return true
-	default:
-		return false
-	}
-}
-
-// Login runs credential-based tracker auth when supported and returns status for
-// missing credentials, unsupported remote login, or 2FA. Trackers with separate
-// API prerequisites, such as BTN, keep the narrower prerequisite status when
-// credential login cannot proceed or completes without making the tracker ready.
-func (s *Service) Login(ctx context.Context, trackerID string, req api.TrackerAuthLoginRequest) (status api.TrackerAuthStatus, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: login failed tracker=%s: %v", trackerLogID(trackerID), err)
-			return
-		}
-		s.logStatus("login completed", status)
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	spec, err := s.specFor(trackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	if !spec.login {
-		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: %s does not support credential login", spec.id)
-	}
-	trackerCfg := mustTrackerConfig(s.cfg, spec.id)
-	status = s.statusForSpec(ctx, spec)
-	if status.State == StateLoginRequired && !hasUsableLoginConfig(spec, trackerCfg) {
-		if !hasSpecificLoginBlocker(status) {
-			status.Message = "username/password missing"
-		}
-		return status, nil
-	}
-
-	if _, ok := s.adapterFor(spec.id); ok {
-		session, ensureErr := s.EnsureSession(ctx, EnsureRequest{
-			TrackerID: spec.id,
-			Config:    trackerCfg,
-			DBPath:    s.cfg.MainSettings.DBPath,
-			AutoLogin: true,
-			Login:     req,
-		})
-		if ensureErr != nil {
-			applyEnsureErrorToStatus(&status, ensureErr)
-			if session.ChallengeID != "" {
-				status.ChallengeID = session.ChallengeID
-			}
-			return status, nil
-		}
-		if isBTNSpec(spec) && !s.btnAPIKeyConfigured() {
-			return s.statusForSpec(ctx, spec), nil
-		}
-		status.State = StateConfigured
-		status.Message = "remote login/auth check succeeded"
-		return status, nil
-	}
-	status.Message = "remote credential login is not supported for this tracker"
-	return status, nil
-}
-
-// Submit2FA completes an active manual 2FA challenge. Adapter failures return
-// refreshed status without consuming the challenge; only failures classified
-// with [ValidationError.Submitted2FARejected] keep the challenge visible for
-// another try. Successful challenge completion clears the challenge fields but
-// does not override separate tracker prerequisites such as BTN's API key.
-func (s *Service) Submit2FA(ctx context.Context, challengeID string, code string) (status api.TrackerAuthStatus, err error) {
-	logTrackerID := ""
-	defer func() {
-		if logTrackerID == "" {
-			logTrackerID = status.TrackerID
-		}
-		if err != nil {
-			s.logWarnf("tracker auth: 2FA submit failed tracker=%s: %v", trackerLogID(logTrackerID), err)
-			return
-		}
-		s.logStatus("2FA completed", status)
-	}()
-	if strings.TrimSpace(challengeID) == "" {
-		return api.TrackerAuthStatus{}, errors.New("tracker auth: challenge id is required")
-	}
-	if strings.TrimSpace(code) == "" {
-		return api.TrackerAuthStatus{}, errors.New("tracker auth: 2FA code is required")
-	}
-	challenges := s.challengeManager()
-	challenge, ok := challenges.Get(challengeID)
-	if !ok {
-		return api.TrackerAuthStatus{}, errors.New("tracker auth: no active manual 2FA challenge")
-	}
-	logTrackerID = challenge.TrackerID
-	ownerKey, err := s.challengeOwnerKey(challenge.TrackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	if !challengeOwnerMatches(challenge, ownerKey) {
-		return api.TrackerAuthStatus{}, errors.New("tracker auth: stale manual 2FA challenge")
-	}
-	adapter, ok := s.adapterFor(challenge.TrackerID)
-	if !ok {
-		return api.TrackerAuthStatus{}, newUnknownTrackerError(challenge.TrackerID)
-	}
-	session, err := adapter.Submit2FA(ctx, mustTrackerConfig(s.cfg, challenge.TrackerID), s.cfg.MainSettings.DBPath, api.TrackerAuthLoginRequest{Code: code})
-	if err != nil {
-		status, statusErr := s.Status(ctx, challenge.TrackerID)
-		if statusErr != nil {
-			return api.TrackerAuthStatus{}, statusErr
-		}
-		applyEnsureErrorToStatus(&status, err)
-		if !shouldKeepSubmitted2FARetryVisible(challenge.TrackerID, err) {
-			return status, nil
-		}
-		status.Needs2FA = true
-		status.ChallengeID = challengeID
-		status.State = StateLoginRequired
-		status.Message = "2FA code rejected; enter a new 2FA code"
-		return status, nil
-	}
-	if _, err := challenges.Consume(challengeID, challenge.TrackerID, ownerKey); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	status, err = s.Status(ctx, challenge.TrackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	missingBTNAPIKey := isBTNSpec(trackerSpec{id: challenge.TrackerID}) && !s.btnAPIKeyConfigured()
-	if (strings.TrimSpace(session.State) == "" || session.State == SessionStateReady) && !missingBTNAPIKey {
-		status.State = StateConfigured
-	}
-	status.Needs2FA = false
-	status.ChallengeID = ""
-	if !missingBTNAPIKey {
-		status.Message = "2FA auth completed"
-	}
-	return status, nil
-}
-
-// shouldKeepSubmitted2FARetryVisible reports whether an adapter proved the
-// submitted manual code reached the tracker and was rejected, so the UI can
-// retry the same active challenge.
-func shouldKeepSubmitted2FARetryVisible(_ string, err error) bool {
-	validation, ok := asValidationError(err)
-	return ok && validation.Transient && !validation.ConfirmedInvalid && validation.Submitted2FARejected
-}
-
-func (s *Service) challengeManager() *ChallengeManager {
-	if s.challenges == nil {
-		s.challenges = sharedChallengeManager
-	}
-	return s.challenges
-}
-
-// Delete removes tracker-specific auth state and generic cookies, then returns
-// the refreshed local auth status. AR auth-state and cookie cleanup failures
-// restore the previous AR auth state before returning the error even when the
-// caller's context has been canceled.
-func (s *Service) Delete(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
-	defer func() {
-		if err != nil {
-			s.logWarnf("tracker auth: delete failed tracker=%s: %v", trackerLogID(trackerID), err)
-			return
-		}
-		s.logStatus("auth deleted", status)
-	}()
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	spec, err := s.specFor(trackerID)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	authSnapshot, err := snapshotTrackerAuthState(ctx, s.cfg.MainSettings.DBPath, spec.id)
-	if err != nil {
-		return api.TrackerAuthStatus{}, err
-	}
-	if err := deleteTrackerAuthState(ctx, s.cfg.MainSettings.DBPath, spec.id); err != nil {
-		restoreErr := authSnapshot.restore(ctx)
-		deleteErr := fmt.Errorf("tracker auth: delete %s auth state: %w", spec.id, err)
-		if restoreErr != nil {
-			return api.TrackerAuthStatus{}, errors.Join(deleteErr, restoreErr)
-		}
-		return api.TrackerAuthStatus{}, deleteErr
-	}
-	if err := cookies.DeleteTrackerCookies(ctx, s.cfg.MainSettings.DBPath, spec.id); err != nil {
-		restoreErr := authSnapshot.restore(ctx)
-		deleteErr := fmt.Errorf("tracker auth: delete %s cookies: %w", spec.id, err)
-		if restoreErr != nil {
-			return api.TrackerAuthStatus{}, errors.Join(deleteErr, restoreErr)
-		}
-		return api.TrackerAuthStatus{}, deleteErr
-	}
-	if s.afterDeleteCleanup != nil {
-		s.afterDeleteCleanup()
-	}
-	status = s.statusForSpec(contextWithoutCancel(ctx), spec)
-	status.CookieCount = 0
-	status.Message = "stored auth deleted"
-	return status, nil
-}
-
-// statusForSpec reports configured auth material without hiding encrypted
-// storage availability. It does not create manual 2FA status; Login, Validate,
-// and Submit2FA attach active challenges only when a challenge ID exists.
-func (s *Service) statusForSpec(ctx context.Context, spec trackerSpec) api.TrackerAuthStatus {
-	encryptedStorage := s.encryptedStorageAvailable()
-	status := api.TrackerAuthStatus{
-		TrackerID:        spec.id,
-		DisplayName:      spec.id,
-		State:            StateNotConfigured,
-		LastCheckedAt:    s.currentTime().UTC().Format(time.RFC3339),
-		EncryptedStorage: encryptedStorage,
-	}
-
-	cfg, hasCfg := trackerConfig(s.cfg, spec.id)
-	hasAPIKey := spec.apiKey && configAPIKey(cfg) != ""
-	if isBTNSpec(spec) {
-		hasAPIKey = s.btnAPIKeyConfigured()
-	}
-	hasPasskey := strings.TrimSpace(cfg.Passkey) != ""
-	hasCredentials := spec.login && hasCfg && hasUsableLoginConfig(spec, cfg)
-	if spec.cookies {
-		values, err := cookies.LoadTrackerCookieMap(ctx, s.cfg.MainSettings.DBPath, spec.id)
-		if err == nil && len(values) > 0 {
-			status.CookieCount = len(values)
-			status.State = StateHasCookies
-		} else if err != nil && !strings.Contains(strings.ToLower(err.Error()), "no cookies found") {
-			status.LastError = redact(err.Error())
-		}
-	}
-
-	if hasAPIKey && (!uploadAuthNeedsCookiesOrLogin(spec) || hasCredentials || (isMTVSpec(spec) && status.CookieCount > 0)) {
-		status.State = StateConfigured
-	}
-	missingBTNAPIKey := isBTNSpec(spec) && !hasAPIKey && (status.CookieCount > 0 || hasCredentials)
-	if missingBTNAPIKey {
-		status.State = StateLoginRequired
-	}
-	if passkeyCoversAuth(spec) && hasPasskey {
-		status.State = StateConfigured
-	}
-	if isHDBSpec(spec) && hasPasskey && strings.TrimSpace(cfg.Username) != "" && status.CookieCount > 0 {
-		status.State = StateConfigured
-	}
-	if isHDBSpec(spec) && hasPasskey && strings.TrimSpace(cfg.Username) != "" && status.CookieCount == 0 {
-		status.State = StateLoginRequired
-	}
-	if spec.login {
-		if hasCredentials {
-			if status.State == StateNotConfigured {
-				status.State = StateConfigured
-			}
-		} else if status.CookieCount == 0 && spec.needsCredentials {
-			status.State = StateLoginRequired
-		}
-	}
-	if !missingBTNAPIKey && spec.cookies && status.CookieCount == 0 && !encryptedStorage && authStatusRequiresEncryptedStorage(spec, hasCredentials, hasAPIKey, hasPasskey) {
-		status.State = StateEncryptedStorageUnavailable
-	}
-	status.Message = validationMessage(spec, status)
-	if status.State != StateEncryptedStorageUnavailable && uploadAuthNeedsCookiesOrLogin(spec) && hasAPIKey && status.CookieCount == 0 && !hasCredentials {
-		status.Message = uploadAuthRequiredMessage(spec)
-	}
-	if missingBTNAPIKey {
-		status.Message = btnMissingAPIKeyMessage()
-	}
-	return status
-}
-
-// currentTime returns the service clock, falling back to the wall clock for
-// zero-value or test-constructed services without an injected clock.
-func (s *Service) currentTime() time.Time {
-	if s != nil && s.now != nil {
-		return s.now()
-	}
-	return time.Now()
-}
-
-// btnAPIKeyConfigured reports whether BTN has an API token in tracker config or
-// legacy metadata; a valid browser session is not upload-ready without it.
-func (s *Service) btnAPIKeyConfigured() bool {
-	return strings.TrimSpace(config.ResolveBTNAPIToken(s.cfg)) != ""
-}
-
-// btnMissingAPIKeyMessage is the shared user-visible status for BTN when
-// cookies or credentials can cover upload auth but torrent resolution cannot run.
-func btnMissingAPIKeyMessage() string {
-	return "API key is required for torrent resolution; imported cookies or login credentials cover upload auth"
-}
-
-func isMTVSpec(spec trackerSpec) bool {
-	return strings.EqualFold(spec.id, "MTV")
-}
-
-func isBTNSpec(spec trackerSpec) bool {
-	return strings.EqualFold(spec.id, "BTN")
-}
-
-func isHDBSpec(spec trackerSpec) bool {
-	return strings.EqualFold(spec.id, "HDB")
-}
-
-// uploadAuthNeedsCookiesOrLogin reports trackers where an API key is necessary
-// but does not prove upload-session readiness.
-func uploadAuthNeedsCookiesOrLogin(spec trackerSpec) bool {
-	return isMTVSpec(spec) || isBTNSpec(spec)
-}
-
-// uploadAuthRequiredMessage explains the split between API/search auth and
-// browser-session upload auth for trackers that need both.
-func uploadAuthRequiredMessage(spec trackerSpec) string {
-	if isBTNSpec(spec) {
-		return "API key covers torrent resolution; imported cookies or login credentials required for upload auth"
-	}
-	return "API key covers Torznab/search; imported cookies or login credentials required for upload auth"
-}
-
-func passkeyCoversAuth(spec trackerSpec) bool {
-	return spec.passkey && !isHDBSpec(spec)
-}
-
-// hasUsableLoginConfig reports whether credential login has every config value
-// required by the tracker implementation. PTP also needs announce_url because
-// login derives the passkey from it.
-func hasUsableLoginConfig(spec trackerSpec, cfg config.TrackerConfig) bool {
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return false
-	}
-	if strings.EqualFold(spec.id, "PTP") && strings.TrimSpace(cfg.AnnounceURL) == "" {
-		return false
-	}
-	return true
-}
-
-// hasSpecificLoginBlocker reports whether status already explains a prerequisite
-// more specific than the generic login-required message.
-func hasSpecificLoginBlocker(status api.TrackerAuthStatus) bool {
-	message := strings.TrimSpace(status.Message)
-	return message != "" && message != validationMessage(trackerSpec{}, status)
-}
-
-func (s *Service) encryptedStorageAvailable() bool {
-	if strings.TrimSpace(s.cfg.MainSettings.DBPath) == "" {
-		return false
-	}
-	_, err := authmaterial.LoadFromDBPath(s.cfg.MainSettings.DBPath)
-	return err == nil
-}
-
-func authStatusRequiresEncryptedStorage(spec trackerSpec, hasCredentials bool, hasAPIKey bool, hasPasskey bool) bool {
-	if passkeyCoversAuth(spec) && hasPasskey {
-		return false
-	}
-	if spec.apiKey && hasAPIKey && !uploadAuthNeedsCookiesOrLogin(spec) {
-		return false
-	}
-	return !hasAPIKey || uploadAuthNeedsCookiesOrLogin(spec) || hasCredentials
-}
-
-// specFor resolves built-in and configured tracker IDs through normalizeTrackerID
-// so ASCII case differences match while non-ASCII runes keep their original case.
-func (s *Service) specFor(trackerID string) (trackerSpec, error) {
-	needle := normalizeTrackerID(trackerID)
-	if needle == "" {
-		return trackerSpec{}, errors.New("tracker auth: tracker id is required")
-	}
-	for _, spec := range s.specs() {
-		if spec.id == needle {
-			return spec, nil
-		}
-	}
-	return trackerSpec{}, fmt.Errorf("tracker auth: unknown tracker %s", needle)
-}
-
-func (s *Service) validateTrackerConfigIDs() error {
-	seen := map[string]string{}
-	for id := range s.cfg.Trackers.Trackers {
-		trimmedID := strings.TrimSpace(id)
-		if trimmedID == "" {
-			continue
-		}
-		normalizedID := normalizeTrackerID(trimmedID)
-		if previous, ok := seen[normalizedID]; ok && previous != trimmedID {
-			return fmt.Errorf("tracker auth: duplicate tracker config id %q conflicts with %q", trimmedID, previous)
-		}
-		seen[normalizedID] = trimmedID
-	}
-	return nil
-}
-
-// specs returns built-ins plus configured trackers indexed by the same
-// canonical ID used by lookup and duplicate-config validation.
-func (s *Service) specs() []trackerSpec {
-	index := map[string]trackerSpec{}
-	for _, spec := range builtInSpecs() {
-		index[spec.id] = spec
-	}
-	for id, cfg := range s.cfg.Trackers.Trackers {
-		trimmedID := strings.TrimSpace(id)
-		if trimmedID == "" {
-			continue
-		}
-		normalizedID := normalizeTrackerID(trimmedID)
-		spec, ok := index[normalizedID]
-		if !ok {
-			spec = trackerSpec{id: normalizedID, authKind: "config"}
-		}
-		if configAPIKey(cfg) != "" {
-			spec.apiKey = true
-			if spec.authKind == "config" {
-				spec.authKind = "api_key"
-			}
-		}
-		if strings.TrimSpace(cfg.Passkey) != "" {
-			spec.passkey = true
-			if spec.authKind == "config" {
-				spec.authKind = "passkey"
-			}
-		}
-		if strings.TrimSpace(cfg.Username) != "" || strings.TrimSpace(cfg.Password) != "" {
-			if !ok || spec.login {
-				spec.login = true
-				spec.autoLogin = spec.autoLogin || spec.id == "AR" || spec.id == "BTN" || spec.id == "FF" || spec.id == "FL" || spec.id == "MTV" || spec.id == "PTP" || spec.id == "RTF" || spec.id == "THR"
-				if spec.authKind == "config" {
-					spec.authKind = "credential_login"
-				}
-			}
-		}
-		index[normalizedID] = spec
-	}
-
-	out := make([]trackerSpec, 0, len(index))
-	for _, spec := range index {
-		out = append(out, spec)
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].id < out[j].id })
-	return out
-}
-
-// builtInSpecs defines static tracker auth capabilities before adapter support
-// is applied. Manual 2FA is enabled only where login can retry with a submitted
-// api.TrackerAuthLoginRequest.Code.
-func builtInSpecs() []trackerSpec {
-	return []trackerSpec{
-		{id: "AR", authKind: "cookies_login", cookies: true, login: true, autoLogin: true, needsCredentials: true},
-		{id: "BTN", authKind: "api_key_cookies_login_manual_2fa", cookies: true, login: true, autoLogin: true, totp: true, manual2FA: true, apiKey: true, needsCredentials: true, notes: []string{"API key is required for torrent resolution; cookies/login cover upload auth."}},
-		{id: "FF", authKind: "cookies_login", cookies: true, login: true, autoLogin: true, needsCredentials: true},
-		{id: "FL", authKind: "cookies_login", cookies: true, login: true, autoLogin: true, needsCredentials: true},
-		{id: "MTV", authKind: "api_key_cookies_login_manual_2fa", cookies: true, login: true, autoLogin: true, totp: true, manual2FA: true, apiKey: true, needsCredentials: true, notes: []string{"API key covers Torznab/search; cookies/login cover upload authkey."}},
-		{id: "PTP", authKind: "cookies_login_manual_2fa", cookies: true, login: true, autoLogin: true, totp: true, manual2FA: true, needsCredentials: true},
-		{id: "THR", authKind: "credential_login", login: true, autoLogin: true, needsCredentials: true},
-		{id: "RTF", authKind: "api_key_credential_refresh", login: true, autoLogin: true, apiKey: true, needsCredentials: false},
-		{id: "ASC", authKind: "cookies", cookies: true},
-		{id: "AZ", authKind: "cookies", cookies: true},
-		{id: "BJS", authKind: "cookies", cookies: true},
-		{id: "BT", authKind: "cookies", cookies: true},
-		{id: "CZ", authKind: "cookies", cookies: true},
-		{id: "HDB", authKind: "passkey_cookies", cookies: true, passkey: true},
-		{id: "HDS", authKind: "cookies", cookies: true},
-		{id: "HDT", authKind: "cookies", cookies: true},
-		{id: "IS", authKind: "cookies", cookies: true},
-		{id: "PHD", authKind: "cookies", cookies: true},
-		{id: "PTS", authKind: "cookies", cookies: true},
-		{id: "TL", authKind: "cookies", cookies: true},
-	}
-}
-
-func capabilityFromSpec(spec trackerSpec) api.TrackerAuthCapability {
-	return api.TrackerAuthCapability{
-		TrackerID:          spec.id,
-		DisplayName:        spec.id,
-		AuthKind:           spec.authKind,
-		SupportsCookieFile: spec.cookies,
-		SupportsLogin:      spec.login,
-		SupportsAutoLogin:  spec.autoLogin,
-		SupportsTOTP:       spec.totp,
-		SupportsManual2FA:  spec.manual2FA,
-		RequiresAPIKey:     spec.apiKey,
-		RequiresPasskey:    spec.passkey,
-		Notes:              append([]string{}, spec.notes...),
-	}
-}
-
-// capabilityForSpec exposes remote login, auto-login, and 2FA actions only
-// when this service has an adapter that can execute them.
-func (s *Service) capabilityForSpec(spec trackerSpec) api.TrackerAuthCapability {
-	if adapter, ok := s.adapterFor(spec.id); ok {
-		return adapter.Capability()
-	}
-	capability := capabilityFromSpec(spec)
-	capability.SupportsLogin = false
-	capability.SupportsAutoLogin = false
-	capability.SupportsTOTP = false
-	capability.SupportsManual2FA = false
-	return capability
-}
-
-func (s *Service) challengeOwnerKey(trackerID string) (string, error) {
-	if err := s.validateTrackerConfigIDs(); err != nil {
-		return "", err
-	}
-	cfg, ok := trackerConfig(s.cfg, trackerID)
-	if !ok {
-		cfg = config.TrackerConfig{}
-	}
-	// #nosec G117 -- payload is only hashed for a local challenge owner key.
-	payload, err := json.Marshal(cfg)
-	if err != nil {
-		return "", fmt.Errorf("tracker auth: encode challenge owner: %w", err)
-	}
-	sum := sha256.Sum256(payload)
-	return normalizeTrackerID(trackerID) + ":" + hex.EncodeToString(sum[:]), nil
-}
-
-func trackerConfig(cfg config.Config, trackerID string) (config.TrackerConfig, bool) {
-	normalizedTrackerID := normalizeTrackerID(trackerID)
-	for key, value := range cfg.Trackers.Trackers {
-		if normalizeTrackerID(key) == normalizedTrackerID {
-			return value, true
-		}
-	}
-	return config.TrackerConfig{}, false
-}
-
-func configAPIKey(cfg config.TrackerConfig) string {
-	if key := strings.TrimSpace(cfg.APIKey); key != "" {
-		return key
-	}
-	return strings.TrimSpace(cfg.PTPAPIKey)
-}
-
-func validationMessage(spec trackerSpec, status api.TrackerAuthStatus) string {
-	switch status.State {
-	case StateHasCookies:
-		return fmt.Sprintf("%d stored cookie(s); tracker upload/search will validate remotely when used", status.CookieCount)
-	case StateConfigured:
-		if status.CookieCount > 0 {
-			return fmt.Sprintf("required config auth material is present; %d stored cookie(s)", status.CookieCount)
-		}
-		return "required config auth material is present"
-	case StateLoginRequired:
-		return "login credentials or imported cookies required"
-	case StateEncryptedStorageUnavailable:
-		return "encrypted cookie storage unavailable; create web-auth.json before importing cookies"
-	default:
-		if spec.cookies || spec.login || spec.apiKey || spec.passkey {
-			return "auth material not configured"
-		}
-		return "no tracker-specific auth handling"
-	}
-}
-
-// ParseCookieContent parses JSON cookie exports or Netscape cookie files into
-// a non-empty name/value map. Raw content above [MaxCookieImportContentBytes],
-// malformed JSON-looking payloads, JSON array entries without name and value,
-// and duplicate trimmed cookie names are rejected; cookie values are preserved
-// byte-for-byte after decoding.
-func ParseCookieContent(fileName string, content string) (map[string]string, error) {
-	if len(content) > MaxCookieImportContentBytes {
-		return nil, fmt.Errorf("tracker auth: cookie file content exceeds %d byte limit", MaxCookieImportContentBytes)
-	}
-	trimmed := strings.TrimSpace(content)
-	if trimmed == "" {
-		return nil, errors.New("tracker auth: cookie file content is required")
-	}
-	if shouldParseJSONCookies(fileName, trimmed) {
-		return parseJSONCookieContent([]byte(trimmed))
-	}
-	return parseNetscapeCookieContent(content)
-}
-
-// shouldParseJSONCookies accepts JSON by extension, leading object, or a valid
-// leading array so exported array payloads are not filename-dependent.
-func shouldParseJSONCookies(fileName string, trimmed string) bool {
-	return strings.EqualFold(filepath.Ext(strings.TrimSpace(fileName)), ".json") ||
-		strings.HasPrefix(trimmed, "{") ||
-		strings.HasPrefix(trimmed, "[")
-}
-
-func parseJSONCookieContent(payload []byte) (map[string]string, error) {
-	if err := rejectDuplicateJSONCookieNames(payload); err != nil {
-		return nil, err
-	}
-	var decoded any
-	if err := json.Unmarshal(payload, &decoded); err != nil {
-		return nil, fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	out := make(map[string]string)
-	switch typed := decoded.(type) {
-	case map[string]any:
-		if err := addJSONCookieObject(out, typed); err != nil {
-			return nil, err
-		}
-	case []any:
-		for _, item := range typed {
-			entry, ok := item.(map[string]any)
-			if !ok {
-				return nil, errors.New("tracker auth: JSON cookie array entries must be objects")
-			}
-			if err := addJSONCookieArrayEntry(out, entry); err != nil {
-				return nil, err
-			}
-		}
-	default:
-		return nil, errors.New("tracker auth: JSON cookie content must be an object or array")
-	}
-	if len(out) == 0 {
-		return nil, errors.New("tracker auth: cookie content has no entries")
-	}
-	return out, nil
-}
-
-// rejectDuplicateJSONCookieNames rejects duplicates only where JSON fields
-// become effective cookie names or values before json.Unmarshal can collapse
-// them into a map.
-func rejectDuplicateJSONCookieNames(payload []byte) error {
-	decoder := json.NewDecoder(bytes.NewReader(payload))
-	token, err := decoder.Token()
-	if err != nil {
-		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	delim, ok := token.(json.Delim)
-	if !ok {
-		return nil
-	}
-	switch delim {
-	case '{':
-		return rejectDuplicateJSONRootCookieNames(decoder)
-	case '[':
-		return rejectDuplicateJSONArrayCookieFields(decoder)
-	default:
-		return nil
-	}
-}
-
-func rejectDuplicateJSONRootCookieNames(decoder *json.Decoder) error {
-	seen := map[string]struct{}{}
-	for decoder.More() {
-		token, err := decoder.Token()
-		if err != nil {
-			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-		}
-		key, ok := token.(string)
-		if !ok {
-			return errors.New("tracker auth: JSON cookie object has non-string key")
-		}
-		name := strings.TrimSpace(key)
-		if name != "" {
-			if _, ok := seen[name]; ok {
-				return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
-			}
-			seen[name] = struct{}{}
-		}
-		valueToken, err := decoder.Token()
-		if err != nil {
-			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-		}
-		if err := rejectDuplicateJSONObjectCookieFields(decoder, valueToken, map[string]struct{}{"value": {}}); err != nil {
-			return err
-		}
-	}
-	if _, err := decoder.Token(); err != nil {
-		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	return nil
-}
-
-func rejectDuplicateJSONArrayCookieFields(decoder *json.Decoder) error {
-	for decoder.More() {
-		token, err := decoder.Token()
-		if err != nil {
-			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-		}
-		if err := rejectDuplicateJSONObjectCookieFields(decoder, token, map[string]struct{}{"name": {}, "value": {}}); err != nil {
-			return err
-		}
-	}
-	if _, err := decoder.Token(); err != nil {
-		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	return nil
-}
-
-func rejectDuplicateJSONObjectCookieFields(decoder *json.Decoder, token json.Token, fields map[string]struct{}) error {
-	delim, ok := token.(json.Delim)
-	if !ok {
-		return nil
-	}
-	if delim != '{' {
-		return discardJSONValue(decoder, token)
-	}
-	seen := map[string]struct{}{}
-	for decoder.More() {
-		keyToken, err := decoder.Token()
-		if err != nil {
-			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-		}
-		key, ok := keyToken.(string)
-		if !ok {
-			return errors.New("tracker auth: JSON cookie object has non-string key")
-		}
-		name := strings.TrimSpace(key)
-		if _, relevant := fields[name]; relevant {
-			if _, ok := seen[name]; ok {
-				return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
-			}
-			seen[name] = struct{}{}
-		}
-		valueToken, err := decoder.Token()
-		if err != nil {
-			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-		}
-		if err := discardJSONValue(decoder, valueToken); err != nil {
-			return err
-		}
-	}
-	if _, err := decoder.Token(); err != nil {
-		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	return nil
-}
-
-func discardJSONValue(decoder *json.Decoder, token json.Token) error {
-	delim, ok := token.(json.Delim)
-	if !ok {
-		return nil
-	}
-	switch delim {
-	case '{':
-		for decoder.More() {
-			if _, err := decoder.Token(); err != nil {
-				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-			}
-			valueToken, err := decoder.Token()
-			if err != nil {
-				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-			}
-			if err := discardJSONValue(decoder, valueToken); err != nil {
-				return err
-			}
-		}
-	case '[':
-		for decoder.More() {
-			valueToken, err := decoder.Token()
-			if err != nil {
-				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-			}
-			if err := discardJSONValue(decoder, valueToken); err != nil {
-				return err
-			}
-		}
-	default:
-		return nil
-	}
-	if _, err := decoder.Token(); err != nil {
-		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
-	}
-	return nil
-}
-
-func addJSONCookieObject(out map[string]string, decoded map[string]any) error {
-	for key, value := range decoded {
-		name := strings.TrimSpace(key)
-		if name == "" {
-			continue
-		}
-		switch typed := value.(type) {
-		case string:
-			if err := addCookieValue(out, name, typed); err != nil {
-				return err
-			}
-		case map[string]any:
-			if raw, ok := typed["value"]; ok && raw != nil {
-				if err := addCookieValue(out, name, fmt.Sprint(raw)); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func addJSONCookieArrayEntry(out map[string]string, entry map[string]any) error {
-	name, hasName := jsonCookieNameField(entry, "name")
-	value, hasValue := jsonCookieValueField(entry, "value")
-	if !hasName || !hasValue {
-		return errors.New("tracker auth: JSON cookie array entries require name and value")
-	}
-	return addCookieValue(out, name, value)
-}
-
-func jsonCookieNameField(entry map[string]any, key string) (string, bool) {
-	raw, ok := entry[key]
-	if !ok || raw == nil {
-		return "", false
-	}
-	return strings.TrimSpace(fmt.Sprint(raw)), true
-}
-
-func jsonCookieValueField(entry map[string]any, key string) (string, bool) {
-	raw, ok := entry[key]
-	if !ok || raw == nil {
-		return "", false
-	}
-	return fmt.Sprint(raw), true
-}
-
-func addCookieValue(out map[string]string, name string, value string) error {
-	name = strings.TrimSpace(name)
-	if name != "" && value != "" {
-		if _, ok := out[name]; ok {
-			return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
-		}
-		out[name] = value
-	}
-	return nil
-}
-
-// parseNetscapeCookieContent extracts cookie name/value pairs from Netscape
-// cookie lines without scanner token-size limits. Names are trimmed; values are
-// preserved after the value column, including surrounding spaces and tabs.
-func parseNetscapeCookieContent(content string) (map[string]string, error) {
-	out := make(map[string]string)
-	for rawLine := range strings.SplitSeq(content, "\n") {
-		line := strings.TrimSuffix(rawLine, "\r")
-		trimmedLine := strings.TrimSpace(line)
-		if trimmedLine == "" {
-			continue
-		}
-		if strings.HasPrefix(trimmedLine, "#HttpOnly_") {
-			line = line[strings.Index(line, "#HttpOnly_")+len("#HttpOnly_"):]
-		} else if strings.HasPrefix(trimmedLine, "#") {
-			continue
-		}
-		fields := strings.Split(line, "\t")
-		if len(fields) < 7 {
-			continue
-		}
-		name := strings.TrimSpace(fields[5])
-		value := strings.Join(fields[6:], "\t")
-		if name != "" && value != "" {
-			if _, ok := out[name]; ok {
-				return nil, fmt.Errorf("tracker auth: duplicate cookie name %q", name)
-			}
-			out[name] = value
-		}
-	}
-	if len(out) == 0 {
-		return nil, errors.New("tracker auth: cookie content has no entries")
-	}
-	return out, nil
-}
-
-var statusURLRe = regexp.MustCompile(`https?://[^\s"'>)]+`)
-
-func redact(value string) string {
-	redacted := redaction.RedactValue(value, nil)
-	redacted = statusURLRe.ReplaceAllStringFunc(redacted, func(raw string) string {
-		trimmed := strings.TrimRight(raw, ".,;:")
-		suffix := strings.TrimPrefix(raw, trimmed)
-		parsed, err := url.Parse(trimmed)
-		if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-			return raw
-		}
-		if parsed.EscapedPath() == "" && parsed.RawQuery == "" {
-			return raw
-		}
-		return parsed.Scheme + "://" + parsed.Host + "/[REDACTED]" + suffix
-	})
-	return strings.TrimSpace(redacted)
-}
-
-func mustTrackerConfig(cfg config.Config, trackerID string) config.TrackerConfig {
-	trackerCfg, _ := trackerConfig(cfg, trackerID)
-	return trackerCfg
-}
-
-// applyEnsureErrorToStatus maps typed ensure errors onto API status. Confirmed
-// invalid sessions clear the reported cookie count and include recovery action;
-// 2FA is actionable only when a reusable challenge id exists.
-func applyEnsureErrorToStatus(status *api.TrackerAuthStatus, err error) {
-	status.LastError = redact(err.Error())
-	status.Message = "remote auth test failed"
-
-	if isCookieStorageFailure(err) {
-		status.State = StateEncryptedStorageUnavailable
-		status.Message = "cookie storage unavailable; see error details"
-		return
-	}
-
-	var authRequired *AuthRequiredError
-	if errors.As(err, &authRequired) {
-		status.State = StateLoginRequired
-		if validation, ok := asValidationError(err); ok && validation.ConfirmedInvalid {
-			status.CookieCount = 0
-			status.Message = expiredSessionActionMessage
-		} else {
-			status.Message = "login credentials or imported cookies required"
-		}
-		return
-	}
-
-	var needs2FA *Needs2FAError
-	if errors.As(err, &needs2FA) {
-		challengeID := strings.TrimSpace(needs2FA.ChallengeID)
-		if challengeID == "" {
-			status.State = StateLoginRequired
-			status.Needs2FA = false
-			status.ChallengeID = ""
-			status.Message = "2FA required but no manual challenge is available"
-			return
-		}
-		status.Needs2FA = true
-		status.ChallengeID = challengeID
-		status.State = StateLoginRequired
-		status.Message = "2FA required"
-		return
-	}
-
-	var unsupported *UnsupportedAuthError
-	if errors.As(err, &unsupported) {
-		status.Message = "remote auth validation is not supported"
-		return
-	}
-
-	var validation *ValidationError
-	if errors.As(err, &validation) && validation.ConfirmedInvalid {
-		status.State = StateLoginRequired
-		status.CookieCount = 0
-		status.Message = expiredSessionActionMessage
-	}
-}
-
-// isCookieStorageFailure recognizes cookie persistence/load failures that should
-// be exposed as storage-unavailable rather than login-required auth states.
-func isCookieStorageFailure(err error) bool {
-	if err == nil || errors.Is(err, cookies.ErrTrackerCookiesNotFound) {
-		return false
-	}
-	lower := strings.ToLower(err.Error())
-	return strings.Contains(lower, "cookies:") ||
-		strings.Contains(lower, "cookie store") ||
-		strings.Contains(lower, "legacy cookie file")
-}
-
-// CookiesToMap converts HTTP cookies to a name/value map, ignoring nil cookies
-// and blank names or values while preserving cookie value bytes.
-func CookiesToMap(values []*http.Cookie) map[string]string {
-	out := make(map[string]string)
-	for _, cookie := range values {
-		if cookie == nil {
-			continue
-		}
-		name := strings.TrimSpace(cookie.Name)
-		value := cookie.Value
-		if name != "" && value != "" {
-			out[name] = value
-		}
-	}
-	return out
-}
-
-// ReadCookieImportContent reads at most [MaxCookieImportContentBytes] from r and
-// returns the shared parser cap error before allocating a larger payload.
-func ReadCookieImportContent(r io.Reader) (string, error) {
-	if r == nil {
-		return "", errors.New("tracker auth: cookie file content is required")
-	}
-	limited := io.LimitReader(r, MaxCookieImportContentBytes+1)
-	payload, err := io.ReadAll(limited)
-	if err != nil {
-		return "", fmt.Errorf("tracker auth: read cookie file content: %w", err)
-	}
-	if len(payload) > MaxCookieImportContentBytes {
-		return "", fmt.Errorf("tracker auth: cookie file content exceeds %d byte limit", MaxCookieImportContentBytes)
-	}
-	return string(payload), nil
-}
-
-// trackerAuthStateSnapshot keeps the AR auth material needed to roll back a
-// partial delete after tracker cookie cleanup reports failure.
-type trackerAuthStateSnapshot struct {
-	dbPath          string
-	trackerID       string
-	authKeyValue    string
-	hadAuthKey      bool
-	legacyAuthPath  string
-	legacyAuthValue []byte
-	hadLegacyAuth   bool
-}
-
-// snapshotTrackerAuthState captures AR encrypted and legacy auth keys before a
-// destructive delete; non-AR trackers have no tracker-specific auth state here.
-func snapshotTrackerAuthState(ctx context.Context, dbPath string, trackerID string) (trackerAuthStateSnapshot, error) {
-	snapshot := trackerAuthStateSnapshot{dbPath: dbPath, trackerID: trackerID}
-	if !strings.EqualFold(strings.TrimSpace(trackerID), "AR") {
-		return snapshot, nil
-	}
-	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
-	if err == nil {
-		snapshot.authKeyValue = authKey
-		snapshot.hadAuthKey = true
-	} else if !errors.Is(err, ErrAuthStateNotFound) && encryptedAuthStateMayExist(dbPath) {
-		return snapshot, fmt.Errorf("tracker auth: snapshot AR auth state: %w", err)
-	}
-	if legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt"); err == nil {
-		snapshot.legacyAuthPath = legacyPath
-		legacyValue, readErr := os.ReadFile(legacyPath)
-		if readErr == nil {
-			snapshot.legacyAuthValue = legacyValue
-			snapshot.hadLegacyAuth = true
-		} else if !os.IsNotExist(readErr) {
-			return snapshot, fmt.Errorf("tracker auth: snapshot AR legacy auth key: %w", readErr)
-		}
-	}
-	return snapshot, nil
-}
-
-// restore writes captured AR auth material back using a rollback context so a
-// canceled request cannot prevent best-effort restoration.
-func (s trackerAuthStateSnapshot) restore(ctx context.Context) error {
-	if !strings.EqualFold(strings.TrimSpace(s.trackerID), "AR") {
-		return nil
-	}
-	rollbackCtx := contextWithoutCancel(ctx)
-	var errs []error
-	if s.hadAuthKey {
-		if err := SaveAuthState(rollbackCtx, s.dbPath, "AR", "auth_key", s.authKeyValue); err != nil {
-			errs = append(errs, fmt.Errorf("tracker auth: restore AR auth state: %w", err))
-		}
-	}
-	if s.hadLegacyAuth && s.legacyAuthPath != "" {
-		if err := os.MkdirAll(filepath.Dir(s.legacyAuthPath), 0o700); err != nil {
-			errs = append(errs, fmt.Errorf("tracker auth: restore AR legacy auth key dir: %w", err))
-		} else if err := os.WriteFile(s.legacyAuthPath, s.legacyAuthValue, 0o600); err != nil {
-			errs = append(errs, fmt.Errorf("tracker auth: restore AR legacy auth key: %w", err))
-		}
-	}
-	return errors.Join(errs...)
-}
-
-// contextWithoutCancel preserves context values for rollback work while
-// detaching cancellation and deadline state.
-func contextWithoutCancel(ctx context.Context) context.Context {
-	if ctx == nil {
-		return context.Background()
-	}
-	return context.WithoutCancel(ctx)
-}
-
-// deleteTrackerAuthState removes tracker-specific encrypted state in addition
-// to generic cookie storage. AR also has a legacy plaintext auth key path, so
-// deletion reports uncertain encrypted cleanup instead of silently leaving stale
-// auth material when helper state cannot prove absence.
-func deleteTrackerAuthState(ctx context.Context, dbPath string, trackerID string) error {
-	if !strings.EqualFold(strings.TrimSpace(trackerID), "AR") {
-		return nil
-	}
-	var errs []error
-	if err := DeleteAuthState(ctx, dbPath, "AR", "auth_key"); err != nil && encryptedAuthStateMayExist(dbPath) {
-		errs = append(errs, fmt.Errorf("tracker auth: delete AR auth state: %w", err))
-	} else if err != nil && !errors.Is(err, ErrAuthStateNotFound) {
-		errs = append(errs, fmt.Errorf("tracker auth: delete AR auth state uncertain: %w", err))
-	}
-	if legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt"); err == nil {
-		if err := os.Remove(legacyPath); err != nil && !os.IsNotExist(err) {
-			errs = append(errs, fmt.Errorf("tracker auth: delete AR legacy auth key: %w", err))
-		}
-	} else {
-		errs = append(errs, fmt.Errorf("tracker auth: resolve AR legacy auth key path: %w", err))
-	}
-	return errors.Join(errs...)
-}
-
-func encryptedAuthStateMayExist(dbPath string) bool {
-	if strings.TrimSpace(dbPath) == "" {
-		return false
-	}
-	_, err := authmaterial.LoadFromDBPath(dbPath)
-	return err == nil
-}
diff --git a/internal/trackerauth/service_test.go b/internal/trackerauth/service_test.go
deleted file mode 100644
index 41d5c4ee..00000000
--- a/internal/trackerauth/service_test.go
+++ /dev/null
@@ -1,3361 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerauth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/btn"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/internal/trackers/impl/mtv"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ptp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type trackerAuthRecordingLogger struct {
-	api.NopLogger
-	info  []string
-	trace []string
-	warn  []string
-}
-
-func (l *trackerAuthRecordingLogger) Infof(format string, args ...any) {
-	l.info = append(l.info, fmt.Sprintf(format, args...))
-}
-
-func (l *trackerAuthRecordingLogger) Tracef(format string, args ...any) {
-	l.trace = append(l.trace, fmt.Sprintf(format, args...))
-}
-
-func (l *trackerAuthRecordingLogger) Warnf(format string, args ...any) {
-	l.warn = append(l.warn, fmt.Sprintf(format, args...))
-}
-
-func TestLoginCreatesManual2FAChallengeBeforeReturning(t *testing.T) {
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "PTP",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "PTP"}
-		},
-	}
-	loginService := NewService(cfg)
-	loginService.adapters = map[string]Adapter{"PTP": adapter}
-
-	status, err := loginService.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if !status.Needs2FA || strings.TrimSpace(status.ChallengeID) == "" {
-		t.Fatalf("expected active 2FA challenge, got %#v", status)
-	}
-
-	submitService := NewService(cfg)
-	submitService.adapters = map[string]Adapter{"PTP": adapter}
-	status, err = submitService.Submit2FA(context.Background(), status.ChallengeID, "123456")
-	if err != nil {
-		t.Fatalf("Submit2FA with challenge from separate service: %v", err)
-	}
-	if status.Needs2FA || status.ChallengeID != "" || status.Message != "2FA auth completed" {
-		t.Fatalf("unexpected submit status: %#v", status)
-	}
-}
-
-func TestDefaultAdaptersExposeMTVPTPManual2FAChallenge(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		cfg    func(string) config.TrackerConfig
-		server func(*testing.T) *httptest.Server
-	}{
-		"MTV": {
-			cfg: func(serverURL string) config.TrackerConfig {
-				return config.TrackerConfig{URL: serverURL, Username: "user", Password: "pass"}
-			},
-			server: newMTVManual2FAServer,
-		},
-		"BTN": {
-			cfg: func(serverURL string) config.TrackerConfig {
-				return config.TrackerConfig{URL: serverURL, APIKey: "api-token", Username: "user", Password: "pass"}
-			},
-			server: newBTNManual2FAServer,
-		},
-		"PTP": {
-			cfg: func(serverURL string) config.TrackerConfig {
-				return config.TrackerConfig{
-					URL:         serverURL,
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				}
-			},
-			server: newPTPManual2FAServer,
-		},
-	}
-	for trackerID, tt := range tests {
-		t.Run(trackerID, func(t *testing.T) {
-			t.Parallel()
-
-			server := tt.server(t)
-			dbPath := newTrackerAuthTestDB(t)
-			cfg := config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-				Trackers: config.TrackersConfig{
-					Trackers: map[string]config.TrackerConfig{
-						trackerID: tt.cfg(server.URL),
-					},
-				},
-			}
-
-			for name, action := range map[string]func(*Service) (api.TrackerAuthStatus, error){
-				"Login": func(service *Service) (api.TrackerAuthStatus, error) {
-					return service.Login(context.Background(), trackerID, api.TrackerAuthLoginRequest{})
-				},
-				"Validate": func(service *Service) (api.TrackerAuthStatus, error) {
-					return service.Validate(context.Background(), trackerID)
-				},
-			} {
-				t.Run(name, func(t *testing.T) {
-					service := NewService(cfg)
-					service.challenges = NewChallengeManager(defaultChallengeTTL)
-
-					status, err := action(service)
-					if err != nil {
-						t.Fatalf("%s: %v", name, err)
-					}
-					if !status.Needs2FA || strings.TrimSpace(status.ChallengeID) == "" {
-						t.Fatalf("%s should expose an active manual 2FA challenge, got %#v", name, status)
-					}
-					if status.State != StateLoginRequired || status.Message != "2FA required" {
-						t.Fatalf("%s returned unexpected status: %#v", name, status)
-					}
-				})
-			}
-		})
-	}
-}
-
-func TestBTNCapabilityAndLocalStatusSemantics(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Metadata:     config.MetadataConfig{BTNAPI: "legacy-token"},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {},
-		}},
-	}
-	service := NewService(cfg)
-	caps, err := service.Capabilities(ctx)
-	if err != nil {
-		t.Fatalf("Capabilities: %v", err)
-	}
-	var btnCap api.TrackerAuthCapability
-	for _, cap := range caps {
-		if cap.TrackerID == "BTN" {
-			btnCap = cap
-			break
-		}
-	}
-	if btnCap.TrackerID == "" {
-		t.Fatal("expected BTN capability")
-	}
-	if !btnCap.RequiresAPIKey || !btnCap.SupportsCookieFile || !btnCap.SupportsLogin || !btnCap.SupportsAutoLogin || !btnCap.SupportsTOTP || !btnCap.SupportsManual2FA {
-		t.Fatalf("unexpected BTN capability: %#v", btnCap)
-	}
-
-	status, err := service.Status(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Status api-key only: %v", err)
-	}
-	if status.State != StateLoginRequired && status.State != StateNotConfigured {
-		t.Fatalf("BTN API-key-only must not be upload-ready, got %#v", status)
-	}
-	if !strings.Contains(status.Message, "imported cookies or login credentials required") {
-		t.Fatalf("expected upload-auth message, got %#v", status)
-	}
-
-	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{Username: "user", Password: "pass"}
-	service = NewService(cfg)
-	status, err = service.Status(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Status credentials: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected BTN API key plus credentials configured, got %#v", status)
-	}
-
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{}
-	service = NewService(cfg)
-	status, err = service.Status(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Status cookies: %v", err)
-	}
-	if status.State != StateHasCookies || status.CookieCount != 1 {
-		t.Fatalf("expected BTN stored cookies to remain local has_cookies, got %#v", status)
-	}
-
-	cfg.Metadata.BTNAPI = ""
-	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{Username: "user", Password: "pass"}
-	service = NewService(cfg)
-	status, err = service.Status(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Status missing API key: %v", err)
-	}
-	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected missing API key to block BTN upload readiness, got %#v", status)
-	}
-
-	cfg.MainSettings.DBPath = filepath.Join(t.TempDir(), "missing-auth", "upbrr.db")
-	service = NewService(cfg)
-	status, err = service.Status(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Status missing API key without encrypted storage: %v", err)
-	}
-	if status.State != StateLoginRequired || status.EncryptedStorage || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected missing API key to take precedence over encrypted storage, got %#v", status)
-	}
-}
-
-func TestValidateBTNStoredCookiesPromotesRemoteSuccess(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/upload.php" {
-			http.NotFound(w, r)
-			return
-		}
-		if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=abc") {
-			select {
-			case handlerErr <- errors.New("expected BTN session cookie"):
-			default:
-			}
-			http.Error(w, "unexpected cookie", http.StatusInternalServerError)
-			return
-		}
-		_, _ = w.Write([]byte(`<form action="/upload.php"><input name="file_input" /></form>`))
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Metadata:     config.MetadataConfig{BTNAPI: "legacy-token"},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {URL: server.URL},
-		}},
-	}).Validate(ctx, "BTN")
-	select {
-	case err := <-handlerErr:
-		t.Fatal(err)
-	default:
-	}
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured || status.Message != "remote auth check succeeded" {
-		t.Fatalf("expected successful BTN auth validation, got %#v", status)
-	}
-}
-
-func TestValidateBTNRemoteSuccessRequiresAPIKey(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/upload.php" {
-			http.NotFound(w, r)
-			return
-		}
-		if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=abc") {
-			select {
-			case handlerErr <- errors.New("expected BTN session cookie"):
-			default:
-			}
-			http.Error(w, "unexpected cookie", http.StatusInternalServerError)
-			return
-		}
-		_, _ = w.Write([]byte(`<form action="/upload.php"><input name="file_input" /></form>`))
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {URL: server.URL},
-		}},
-	}).Validate(ctx, "BTN")
-	select {
-	case err := <-handlerErr:
-		t.Fatal(err)
-	default:
-	}
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected validated BTN session to remain blocked by missing API key, got %#v", status)
-	}
-}
-
-func TestValidateBTNMissingAPIAfterCookieRefreshUpdatesCookieCount(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login.php":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-			_, _ = w.Write([]byte("ok"))
-		case "/upload.php":
-			if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=new") {
-				select {
-				case handlerErr <- errors.New("expected refreshed BTN session cookie"):
-				default:
-				}
-				http.Error(w, "unexpected cookie", http.StatusInternalServerError)
-				return
-			}
-			_, _ = w.Write([]byte(`<form action="/upload.php"><input name="file_input" /></form>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {URL: server.URL, Username: "user", Password: "pass"},
-		}},
-	}).Validate(ctx, "BTN")
-	select {
-	case err := <-handlerErr:
-		t.Fatal(err)
-	default:
-	}
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected missing API status to include refreshed cookie count, got %#v", status)
-	}
-}
-
-func TestValidateBTNInvalidCookiesDeletesOnlyConfirmedInvalid(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "expired"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/upload.php" {
-			http.NotFound(w, r)
-			return
-		}
-		http.Redirect(w, r, "/login.php", http.StatusFound)
-	}))
-	t.Cleanup(server.Close)
-
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Metadata:     config.MetadataConfig{BTNAPI: "legacy-token"},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {URL: server.URL},
-		}},
-	})
-	preEffectTime := time.Date(2026, time.July, 11, 1, 2, 3, 0, time.UTC)
-	postEffectTime := preEffectTime.Add(time.Minute)
-	nowCalls := 0
-	service.now = func() time.Time {
-		nowCalls++
-		if nowCalls == 1 {
-			return preEffectTime
-		}
-		return postEffectTime
-	}
-
-	status, err := service.Validate(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 0 {
-		t.Fatalf("expected confirmed-invalid BTN cookies to be deleted, got %#v", status)
-	}
-	if status.LastCheckedAt != postEffectTime.Format(time.RFC3339) {
-		t.Fatalf("expected post-deletion LastCheckedAt %q, got %q", postEffectTime.Format(time.RFC3339), status.LastCheckedAt)
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "BTN"); err == nil {
-		t.Fatal("expected BTN cookies to be deleted")
-	}
-}
-
-func TestValidateBTNCookieStorageFailureReportsStorageStatus(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	jsonPath := trackerAuthLegacyCookiePathByExt(t, dbPath, "BTN", ".json")
-	if err := os.MkdirAll(filepath.Dir(jsonPath), 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	if err := os.WriteFile(jsonPath, []byte(`{"session":`), 0o600); err != nil {
-		t.Fatalf("write malformed cookie file: %v", err)
-	}
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Metadata:     config.MetadataConfig{BTNAPI: "legacy-token"},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {Username: "user", Password: "pass"},
-		}},
-	}).Validate(ctx, "BTN")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateEncryptedStorageUnavailable {
-		t.Fatalf("expected storage-unavailable state, got %#v", status)
-	}
-	if !strings.Contains(status.Message, "cookie storage unavailable") {
-		t.Fatalf("expected storage failure message, got %#v", status)
-	}
-	if !strings.Contains(status.LastError, "unmarshal") {
-		t.Fatalf("expected parse error detail for CLI/frontend consumers, got %#v", status)
-	}
-}
-
-func TestClassifyAdapterErrorRecognizesBTNSubmitted2FARejected(t *testing.T) {
-	t.Parallel()
-
-	err := classifyAdapterError("BTN", fmt.Errorf("login failed: %w", btn.ErrSubmitted2FARejected))
-	var validationErr *ValidationError
-	if !errors.As(err, &validationErr) || !validationErr.Transient || !validationErr.Submitted2FARejected || validationErr.ConfirmedInvalid {
-		t.Fatalf("expected retry-visible BTN submitted 2FA rejection, got %v", err)
-	}
-}
-
-func TestValidateRTFRefreshesExpiredAPIKey(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"RTF": {APIKey: "old-token", Username: "user", Password: "pass"},
-			},
-		},
-	}
-	saveTrackerAuthTestConfig(t, dbPath, cfg)
-
-	var testedToken string
-	var loginCalled bool
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/test":
-			testedToken = r.Header.Get("Authorization")
-			w.WriteHeader(http.StatusUnauthorized)
-		case "/api/login":
-			loginCalled = true
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"token":"new-token"}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-	cfg.Trackers.Trackers["RTF"] = config.TrackerConfig{
-		URL:      server.URL,
-		APIKey:   "old-token",
-		Username: "user",
-		Password: "pass",
-	}
-
-	status, err := NewService(cfg).Validate(context.Background(), "RTF")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured || status.Message != "remote auth check succeeded" {
-		t.Fatalf("expected successful RTF auth validation, got %#v", status)
-	}
-	if testedToken != "old-token" {
-		t.Fatal("expected old token validation")
-	}
-	if !loginCalled {
-		t.Fatal("expected expired API key to trigger RTF login")
-	}
-	if got := loadStoredTrackerConfig(t, dbPath).Trackers.Trackers["RTF"].APIKey; got != "new-token" {
-		t.Fatal("expected refreshed token persisted")
-	}
-}
-
-func TestValidateARStoredCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != arIndexPath {
-			http.NotFound(w, r)
-			return
-		}
-		if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=abc") {
-			t.Error("expected AR session cookie")
-			return
-		}
-		_, _ = w.Write([]byte(`<a href="https://alpharatio.cc/logout.php?auth=session-key">Logout</a>`))
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AR": {URL: server.URL},
-		}},
-	}).Validate(ctx, "AR")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured || status.Message != "remote auth check succeeded" {
-		t.Fatalf("expected successful AR auth validation, got %#v", status)
-	}
-}
-
-func TestValidateARAutoLoginReplacesMissingOrExpiredCookies(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		seedExpired bool
-	}{
-		{name: "missing cookies"},
-		{name: "expired cookies", seedExpired: true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ctx := context.Background()
-			dbPath := newTrackerAuthTestDB(t)
-			if tt.seedExpired {
-				if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "expired"}); err != nil {
-					t.Fatalf("SaveTrackerCookieMap: %v", err)
-				}
-			}
-
-			var loginCalls atomic.Int32
-			var indexCalls atomic.Int32
-			var invalidLoginForm atomic.Bool
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				switch r.URL.Path {
-				case arLoginPath:
-					loginCalls.Add(1)
-					if r.FormValue("username") != "user" || r.FormValue("password") != "password" || r.FormValue("keeplogged") != "1" {
-						invalidLoginForm.Store(true)
-					}
-					http.SetCookie(w, &http.Cookie{Name: "session", Value: "refreshed", Path: "/"})
-					http.Redirect(w, r, arIndexPath, http.StatusFound)
-				case arIndexPath:
-					indexCalls.Add(1)
-					cookie, cookieErr := r.Cookie("session")
-					if cookieErr != nil || cookie.Value != "refreshed" {
-						_, _ = w.Write([]byte(`login.php?act=recover`))
-						return
-					}
-					_, _ = w.Write([]byte(`<a href="https://alpharatio.cc/logout.php?auth=session-key">Logout</a>`))
-				default:
-					http.NotFound(w, r)
-				}
-			}))
-			t.Cleanup(server.Close)
-
-			status, err := NewService(config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-					"AR": {URL: server.URL, Username: "user", Password: "password"},
-				}},
-			}).Validate(ctx, "AR")
-			if err != nil {
-				t.Fatalf("Validate: %v", err)
-			}
-			if status.State != StateConfigured || status.Message != "remote auth check succeeded" {
-				t.Fatalf("expected successful AR auto-login, got %#v", status)
-			}
-			if loginCalls.Load() != 1 || invalidLoginForm.Load() {
-				t.Fatal("expected one AR login with configured credentials")
-			}
-			wantIndexCalls := int32(2)
-			if tt.seedExpired {
-				wantIndexCalls++
-			}
-			if indexCalls.Load() != wantIndexCalls {
-				t.Fatalf("expected AR login redirect plus session validation, got %d index requests", indexCalls.Load())
-			}
-			values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
-			if err != nil {
-				t.Fatalf("LoadTrackerCookieMap: %v", err)
-			}
-			if values["session"] != "refreshed" {
-				t.Fatal("expected refreshed AR session cookie")
-			}
-		})
-	}
-}
-
-func TestValidateARTransientFailurePreservesCookiesWithoutLogin(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	var loginCalls atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == arLoginPath {
-			loginCalls.Add(1)
-		}
-		w.WriteHeader(http.StatusServiceUnavailable)
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AR": {URL: server.URL, Username: "user", Password: "password"},
-		}},
-	}).Validate(ctx, "AR")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.Message != "remote auth test failed" {
-		t.Fatalf("expected transient AR validation status, got %#v", status)
-	}
-	if loginCalls.Load() != 0 {
-		t.Fatal("transient AR failure must not trigger credential login")
-	}
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("transient AR failure must preserve stored cookies")
-	}
-}
-
-func TestValidateHDBInvalidCookiesDeletesSession(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "HDB", map[string]string{"session": "expired"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/upload/upload" {
-			http.NotFound(w, r)
-			return
-		}
-		http.Redirect(w, r, "/login.php", http.StatusFound)
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"HDB": {URL: server.URL, Username: "user", Passkey: "passkey"},
-		}},
-	}).Validate(ctx, "HDB")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 0 || status.Message != "stored session expired or invalid; log in again or import fresh cookies" {
-		t.Fatalf("expected HDB login-required expired-session status, got %#v", status)
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "HDB"); err == nil {
-		t.Fatal("expected invalid HDB cookies to be deleted")
-	}
-}
-
-func TestValidateFFLoginPersistsCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "FF", map[string]string{"session": "expired"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/upload.php":
-			if cookie, err := r.Cookie("session"); err == nil && cookie.Value == "valid" {
-				_, _ = w.Write([]byte(`<a href="friends.php">Friends</a>`))
-				return
-			}
-			_, _ = w.Write([]byte(`<input name="username">`))
-		case "/takelogin.php":
-			if err := r.ParseForm(); err != nil {
-				t.Errorf("ParseForm: %v", err)
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
-				t.Error("unexpected FF login form")
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "valid", Path: "/"})
-			w.Header().Set("Location", "/index.php")
-			w.WriteHeader(http.StatusFound)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"FF": {URL: server.URL, Username: "user", Password: "pass"},
-			},
-		},
-	}).Validate(ctx, "FF")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected FF configured after login, got %#v", status)
-	}
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "FF")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "valid" {
-		t.Fatal("expected saved FF login cookies")
-	}
-}
-
-func TestValidateFFLoginDoesNotPersistUnverifiedCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "FF", map[string]string{"session": "expired"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-
-	var uploadValidationRequests atomic.Int32
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/upload.php":
-			if cookie, err := r.Cookie("session"); err == nil && cookie.Value == "invalid" {
-				uploadValidationRequests.Add(1)
-			}
-			_, _ = w.Write([]byte(`<input name="username">`))
-		case "/takelogin.php":
-			if err := r.ParseForm(); err != nil {
-				select {
-				case handlerErr <- fmt.Errorf("parse login form: %w", err):
-				default:
-				}
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
-				select {
-				case handlerErr <- errors.New("unexpected FF login form"):
-				default:
-				}
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "invalid", Path: "/"})
-			w.Header().Set("Location", "/index.php")
-			w.WriteHeader(http.StatusFound)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"FF": {URL: server.URL, Username: "user", Password: "pass"},
-			},
-		},
-	}).Validate(ctx, "FF")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	select {
-	case err := <-handlerErr:
-		t.Fatal(err)
-	default:
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 0 {
-		t.Fatalf("expected rejected FF login cookies to leave login required with no cookies, got %#v", status)
-	}
-	if uploadValidationRequests.Load() == 0 {
-		t.Fatalf("expected returned FF login cookies to be validated before persistence, got %d request(s)", uploadValidationRequests.Load())
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "FF"); err == nil {
-		t.Fatal("invalid FF login cookies were persisted")
-	}
-}
-
-func TestValidateFLLoginPersistsCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "FL", map[string]string{"session": "expired"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login.php":
-			_, _ = w.Write([]byte(`<input name="validator" value="token">`))
-		case "/takelogin.php":
-			if err := r.ParseForm(); err != nil {
-				t.Errorf("ParseForm: %v", err)
-				return
-			}
-			if r.FormValue("validator") != "token" || r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
-				t.Error("unexpected FL login form")
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "valid", Path: "/"})
-			_, _ = w.Write([]byte("Logout"))
-		case "/index.php":
-			if cookie, err := r.Cookie("session"); err == nil && cookie.Value == "valid" {
-				_, _ = w.Write([]byte("Logout"))
-				return
-			}
-			_, _ = w.Write([]byte(`<input name="username">`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"FL": {URL: server.URL, Username: "user", Password: "pass"},
-			},
-		},
-	}).Validate(ctx, "FL")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected FL configured after login, got %#v", status)
-	}
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "FL")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "valid" {
-		t.Fatal("expected saved FL login cookies")
-	}
-}
-
-func TestValidateFLLoginDoesNotPersistUnverifiedCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case flLoginPagePath:
-			_, _ = w.Write([]byte(`<input name="validator" value="token">`))
-		case flLoginPath:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "unverified", Path: "/"})
-			http.Redirect(w, r, flIndexPath, http.StatusFound)
-		case flIndexPath:
-			_, _ = w.Write([]byte(`<input name="username">`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"FL": {URL: server.URL, Username: "user", Password: "pass"},
-		}},
-	}).Validate(ctx, "FL")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 0 {
-		t.Fatalf("expected unverified FL login to remain login required, got %#v", status)
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "FL"); err == nil {
-		t.Fatal("unverified FL login cookies were persisted")
-	}
-}
-
-func TestValidateTHRChecksCredentialLogin(t *testing.T) {
-	t.Parallel()
-
-	handlerErr := make(chan error, 4)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login.php":
-			http.SetCookie(w, &http.Cookie{Name: "bootstrap", Value: "ready", Path: "/"})
-			_, _ = w.Write([]byte(`<input type="hidden" name="token" value="login-token">`))
-		case "/takelogin.php":
-			if err := r.ParseForm(); err != nil {
-				handlerErr <- fmt.Errorf("parse THR login form: %w", err)
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" || r.FormValue("ssl") != "yes" || r.FormValue("token") != "login-token" {
-				handlerErr <- errors.New("unexpected THR login form")
-			}
-			if cookie, err := r.Cookie("bootstrap"); err != nil || cookie.Value != "ready" {
-				handlerErr <- errors.New("THR login bootstrap cookie missing")
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "authenticated", Path: "/"})
-			http.Redirect(w, r, "/index.php", http.StatusFound)
-		case "/index.php":
-			if cookie, err := r.Cookie("session"); err != nil || cookie.Value != "authenticated" {
-				handlerErr <- errors.New("THR redirect session cookie missing")
-				return
-			}
-			_, _ = w.Write([]byte(`<a href="logout.php">Logout</a>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	status, err := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"THR": {URL: server.URL, Username: "user", Password: "pass"},
-			},
-		},
-	}).Validate(context.Background(), "THR")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected THR configured after login check, got %#v", status)
-	}
-	close(handlerErr)
-	for err := range handlerErr {
-		t.Error(err)
-	}
-}
-
-func TestSubmit2FARetriesAdapterLoginWithCurrentConfigAndCode(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				},
-			},
-		},
-	}
-	var gotCode, gotDBPath, gotUsername string
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "PTP",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "PTP"}
-		},
-		submit: func(_ context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
-			gotCode = req.Code
-			gotDBPath = dbPath
-			gotUsername = cfg.Username
-			return Session{TrackerID: "PTP", State: SessionStateReady}, nil
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"PTP": adapter}
-
-	status, err := service.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if strings.TrimSpace(status.ChallengeID) == "" {
-		t.Fatalf("expected challenge: %#v", status)
-	}
-	if _, err := service.Submit2FA(context.Background(), status.ChallengeID, "654321"); err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if gotCode != "654321" || gotDBPath != dbPath || gotUsername != "user" {
-		t.Fatalf("unexpected adapter retry args code=%q db=%q username=%q", gotCode, gotDBPath, gotUsername)
-	}
-}
-
-func TestSubmit2FABTNSuccessPreservesMissingAPIStatus(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"BTN": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	var gotCode string
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "BTN",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "BTN"}
-		},
-		submit: func(_ context.Context, _ config.TrackerConfig, _ string, req api.TrackerAuthLoginRequest) (Session, error) {
-			gotCode = req.Code
-			return Session{TrackerID: "BTN", State: SessionStateReady}, nil
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"BTN": adapter}
-
-	status, err := service.Login(context.Background(), "BTN", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if strings.TrimSpace(status.ChallengeID) == "" {
-		t.Fatalf("expected challenge: %#v", status)
-	}
-	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "654321")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if gotCode != "654321" {
-		t.Fatalf("unexpected submitted code %q", gotCode)
-	}
-	if status.Needs2FA || status.ChallengeID != "" {
-		t.Fatalf("expected challenge cleared after successful submit, got %#v", status)
-	}
-	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected successful BTN 2FA to preserve missing API status, got %#v", status)
-	}
-}
-
-func TestSubmit2FAFailureKeepsChallengeRetryVisible(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				},
-			},
-		},
-	}
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "PTP",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "PTP"}
-		},
-		submit: func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) (Session, error) {
-			return Session{}, &ValidationError{TrackerID: "PTP", Transient: true, Submitted2FARejected: true, Err: errors.New("login failed")}
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"PTP": adapter}
-
-	status, err := service.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if !status.Needs2FA || strings.TrimSpace(status.ChallengeID) == "" {
-		t.Fatalf("expected retry-visible challenge after failed code, got %#v", status)
-	}
-	if status.State != StateLoginRequired || !strings.Contains(status.Message, "enter a new 2FA code") {
-		t.Fatalf("expected failed 2FA status to include mode and required action, got %#v", status)
-	}
-}
-
-func TestSubmit2FATransientSubmittedCodeFailureKeepsChallengeRetryVisible(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				},
-			},
-		},
-	}
-	service := NewService(cfg)
-	service.challenges = NewChallengeManager(defaultChallengeTTL)
-	service.adapters = map[string]Adapter{
-		"PTP": trackerAdapter{
-			capability: api.TrackerAuthCapability{
-				TrackerID:         "PTP",
-				SupportsLogin:     true,
-				SupportsManual2FA: true,
-			},
-			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
-				if login.Code != "000000" {
-					t.Fatalf("expected submitted code, got %q", login.Code)
-				}
-				return fmt.Errorf("trackers: PTP login failed: %w", ptp.ErrSubmitted2FARejected)
-			},
-		},
-	}
-	ownerKey, err := service.challengeOwnerKey("PTP")
-	if err != nil {
-		t.Fatalf("challengeOwnerKey: %v", err)
-	}
-	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
-
-	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if !status.Needs2FA || status.ChallengeID != challengeID {
-		t.Fatalf("expected retry-visible challenge after classified failed code, got %#v", status)
-	}
-	if status.State != StateLoginRequired || !strings.Contains(status.Message, "enter a new 2FA code") {
-		t.Fatalf("expected failed 2FA status to include mode and required action, got %#v", status)
-	}
-	if _, ok := service.challenges.Get(challengeID); !ok {
-		t.Fatal("failed submitted code consumed challenge")
-	}
-}
-
-func TestSubmit2FAPreCodeLoginFailureDoesNotExposeRetryChallenge(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				},
-			},
-		},
-	}
-	service := NewService(cfg)
-	service.challenges = NewChallengeManager(defaultChallengeTTL)
-	service.adapters = map[string]Adapter{
-		"PTP": trackerAdapter{
-			capability: api.TrackerAuthCapability{
-				TrackerID:         "PTP",
-				SupportsLogin:     true,
-				SupportsManual2FA: true,
-			},
-			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
-				if login.Code != "000000" {
-					t.Fatalf("expected submitted code, got %q", login.Code)
-				}
-				return errors.New("trackers: PTP login failed")
-			},
-		},
-	}
-	ownerKey, err := service.challengeOwnerKey("PTP")
-	if err != nil {
-		t.Fatalf("challengeOwnerKey: %v", err)
-	}
-	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
-
-	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
-		t.Fatalf("pre-code login failure must not expose retry challenge: %#v", status)
-	}
-	if !strings.Contains(status.LastError, "login failed") {
-		t.Fatalf("expected login failure in status, got %#v", status)
-	}
-}
-
-func TestSubmit2FAConfirmedInvalidFailureDoesNotExposeRetryChallenge(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {
-					Username:    "user",
-					Password:    "pass",
-					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-				},
-			},
-		},
-	}
-	service := NewService(cfg)
-	service.challenges = NewChallengeManager(defaultChallengeTTL)
-	service.adapters = map[string]Adapter{
-		"PTP": trackerAdapter{
-			capability: api.TrackerAuthCapability{
-				TrackerID:         "PTP",
-				SupportsLogin:     true,
-				SupportsManual2FA: true,
-			},
-			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
-				if login.Code != "000000" {
-					t.Fatalf("expected submitted code, got %q", login.Code)
-				}
-				return &ValidationError{TrackerID: "PTP", ConfirmedInvalid: true, Submitted2FARejected: true, Err: errors.New("login failed")}
-			},
-		},
-	}
-	ownerKey, err := service.challengeOwnerKey("PTP")
-	if err != nil {
-		t.Fatalf("challengeOwnerKey: %v", err)
-	}
-	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
-
-	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
-		t.Fatalf("confirmed-invalid failure must not expose retry challenge: %#v", status)
-	}
-}
-
-func TestSubmit2FAMTVSubmittedCodeAuthKeyFailureKeepsChallengeRetryVisible(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"MTV": {
-					Username: "user",
-					Password: "pass",
-				},
-			},
-		},
-	}
-	service := NewService(cfg)
-	service.challenges = NewChallengeManager(defaultChallengeTTL)
-	service.adapters = map[string]Adapter{
-		"MTV": trackerAdapter{
-			capability: api.TrackerAuthCapability{
-				TrackerID:         "MTV",
-				SupportsLogin:     true,
-				SupportsManual2FA: true,
-			},
-			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
-				if login.Code != "000000" {
-					t.Fatalf("expected submitted code, got %q", login.Code)
-				}
-				return fmt.Errorf("trackers: MTV auth key not found: %w", mtv.ErrSubmitted2FARejected)
-			},
-		},
-	}
-	ownerKey, err := service.challengeOwnerKey("MTV")
-	if err != nil {
-		t.Fatalf("challengeOwnerKey: %v", err)
-	}
-	challengeID := service.challenges.Create(context.Background(), "MTV", ownerKey)
-
-	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if !status.Needs2FA || status.ChallengeID != challengeID {
-		t.Fatalf("expected retry-visible MTV challenge after auth-key miss, got %#v", status)
-	}
-	if _, ok := service.challenges.Get(challengeID); !ok {
-		t.Fatal("failed MTV submitted code consumed challenge")
-	}
-}
-
-func TestSubmit2FATransientParserFailureDoesNotExposeRetryChallenge(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"MTV": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "MTV",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "MTV"}
-		},
-		submit: func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) (Session, error) {
-			return Session{}, classifyAdapterError("MTV", errors.New("trackers: MTV 2FA token not found"))
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"MTV": adapter}
-
-	status, err := service.Login(context.Background(), "MTV", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "000000")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
-		t.Fatalf("transient parser failure must not expose retry challenge: %#v", status)
-	}
-	if !strings.Contains(status.LastError, "2FA token not found") {
-		t.Fatalf("expected parser failure in status, got %#v", status)
-	}
-}
-
-func TestSubmit2FARejectsChallengeAfterTrackerConfigReplacement(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "PTP",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		validate: func() (Session, error) {
-			return Session{}, &Needs2FAError{TrackerID: "PTP"}
-		},
-	}
-	loginService := NewService(cfg)
-	loginService.adapters = map[string]Adapter{"PTP": adapter}
-
-	status, err := loginService.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-
-	replacedCfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {Username: "other", Password: "pass"},
-			},
-		},
-	}
-	submitService := NewService(replacedCfg)
-	submitService.adapters = map[string]Adapter{"PTP": adapter}
-	_, err = submitService.Submit2FA(context.Background(), status.ChallengeID, "123456")
-	if err == nil {
-		t.Fatal("expected stale challenge error")
-	}
-	if !strings.Contains(err.Error(), "stale manual 2FA challenge") {
-		t.Fatalf("expected stale challenge error, got %v", err)
-	}
-}
-
-func TestSubmit2FAUsesCanceledContextWithoutConsumingChallenge(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"PTP": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	challenges := NewChallengeManager(defaultChallengeTTL)
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{
-			TrackerID:         "PTP",
-			SupportsLogin:     true,
-			SupportsManual2FA: true,
-		},
-		submit: func(ctx context.Context, _ config.TrackerConfig, _ string, _ api.TrackerAuthLoginRequest) (Session, error) {
-			return Session{}, ctx.Err()
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"PTP": adapter}
-	service.challenges = challenges
-	ownerKey, err := service.challengeOwnerKey("PTP")
-	if err != nil {
-		t.Fatalf("challengeOwnerKey: %v", err)
-	}
-	challengeID := challenges.Create(context.Background(), "PTP", ownerKey)
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	status, err := service.Submit2FA(ctx, challengeID, "123456")
-	if err != nil {
-		t.Fatalf("Submit2FA: %v", err)
-	}
-	if !strings.Contains(status.LastError, "context canceled") {
-		t.Fatalf("expected context canceled status, got %#v", status)
-	}
-	if _, ok := challenges.Get(challengeID); !ok {
-		t.Fatal("canceled 2FA submit consumed the challenge")
-	}
-}
-
-func TestLoginMissingCredentialsReturnsLoginRequiredWithoutChallenge(t *testing.T) {
-	t.Parallel()
-
-	status, err := NewService(config.Config{}).Login(
-		context.Background(),
-		"PTP",
-		api.TrackerAuthLoginRequest{},
-	)
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if status.State != StateLoginRequired {
-		t.Fatalf("expected login required status, got %#v", status)
-	}
-	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
-		t.Fatalf("missing credentials must not create manual 2FA challenge: %#v", status)
-	}
-}
-
-func TestLoginBTNCredentialsWithoutAPIAttemptsSessionValidation(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"BTN": {Username: "user", Password: "pass"},
-			},
-		},
-	}
-	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{TrackerID: "BTN", SupportsLogin: true},
-		validate: func() (Session, error) {
-			return Session{}, &AuthRequiredError{TrackerID: "BTN", Reason: "login required"}
-		},
-		login: func() (Session, error) {
-			return Session{TrackerID: "BTN", State: SessionStateReady}, nil
-		},
-	}
-	service := NewService(cfg)
-	service.adapters = map[string]Adapter{"BTN": adapter}
-
-	status, err := service.Login(context.Background(), "BTN", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if adapter.validateCalls != 1 || adapter.loginCalls != 1 {
-		t.Fatalf("expected BTN session validation and login, got validate=%d login=%d", adapter.validateCalls, adapter.loginCalls)
-	}
-	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected successful BTN login to preserve missing API status, got %#v", status)
-	}
-}
-
-func TestLoginBTNCookiesWithoutAPIPreservesMissingAPIStatus(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-	}).Login(ctx, "BTN", api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("Login: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected BTN cookie-only login to preserve missing API status, got %#v", status)
-	}
-	if strings.Contains(status.Message, "username/password missing") {
-		t.Fatalf("missing credentials masked missing API status: %#v", status)
-	}
-}
-
-func TestStatusConfiguredOTPURIAvoidsManualChallenge(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]config.TrackerConfig{
-		"configured otp uri": {
-			Username:    "user",
-			Password:    "pass",
-			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-			OTPURI:      "otpauth://totp/PTP:user?secret=ABC",
-		},
-		"missing otp uri": {
-			Username:    "user",
-			Password:    "pass",
-			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-		},
-	}
-	for name, trackerCfg := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			service := NewService(config.Config{
-				Trackers: config.TrackersConfig{
-					Trackers: map[string]config.TrackerConfig{
-						"PTP": trackerCfg,
-					},
-				},
-			})
-			status := service.statusForSpec(context.Background(), trackerSpec{
-				id:               "PTP",
-				login:            true,
-				totp:             true,
-				manual2FA:        true,
-				needsCredentials: true,
-			})
-			if status.State != StateConfigured {
-				t.Fatalf("expected configured status, got %#v", status)
-			}
-			if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
-				t.Fatalf("status-only config must not expose manual challenge path: %#v", status)
-			}
-		})
-	}
-}
-
-func TestStatusPTPRequiresAnnounceURLForConfiguredLogin(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		cfg       config.TrackerConfig
-		wantState string
-	}{
-		"missing announce": {
-			cfg:       config.TrackerConfig{Username: "user", Password: "pass"},
-			wantState: StateLoginRequired,
-		},
-		"blank announce": {
-			cfg:       config.TrackerConfig{Username: "user", Password: "pass", AnnounceURL: " \t\n "},
-			wantState: StateLoginRequired,
-		},
-		"complete login config": {
-			cfg:       config.TrackerConfig{Username: "user", Password: "pass", AnnounceURL: "https://please.passthepopcorn.me/passkey/announce"},
-			wantState: StateConfigured,
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			service := NewService(config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
-				Trackers: config.TrackersConfig{
-					Trackers: map[string]config.TrackerConfig{"PTP": tt.cfg},
-				},
-			})
-			status, err := service.Status(context.Background(), "PTP")
-			if err != nil {
-				t.Fatalf("Status: %v", err)
-			}
-			if status.State != tt.wantState {
-				t.Fatalf("expected %s state, got %#v", tt.wantState, status)
-			}
-		})
-	}
-}
-
-func TestStatusPTPCookiesRemainConfiguredWithoutAnnounceURL(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{"PTP": {Username: "user", Password: "pass"}},
-		},
-	})
-
-	status, err := service.Status(ctx, "PTP")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateHasCookies || status.CookieCount != 1 {
-		t.Fatalf("expected stored PTP cookies to remain usable without announce URL, got %#v", status)
-	}
-}
-
-func TestStatusConfiguredAuthReportsEncryptedStorageUnavailableWhenPersistenceRequired(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		cfg       config.TrackerConfig
-		spec      trackerSpec
-		wantState string
-	}{
-		"MTV api key only": {
-			cfg:       config.TrackerConfig{APIKey: "api-key"},
-			wantState: StateEncryptedStorageUnavailable,
-			spec: trackerSpec{
-				id:               "MTV",
-				cookies:          true,
-				apiKey:           true,
-				needsCredentials: true,
-			},
-		},
-		"credentials": {
-			cfg:       config.TrackerConfig{Username: "user", Password: "pass"},
-			wantState: StateEncryptedStorageUnavailable,
-			spec: trackerSpec{
-				id:               "AR",
-				cookies:          true,
-				login:            true,
-				needsCredentials: true,
-			},
-		},
-		"passkey": {
-			cfg:       config.TrackerConfig{Passkey: "passkey"},
-			wantState: StateEncryptedStorageUnavailable,
-			spec: trackerSpec{
-				id:      "HDB",
-				cookies: true,
-				passkey: true,
-			},
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			service := NewService(config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")},
-				Trackers: config.TrackersConfig{
-					Trackers: map[string]config.TrackerConfig{tt.spec.id: tt.cfg},
-				},
-			})
-			status := service.statusForSpec(context.Background(), tt.spec)
-			if status.State != tt.wantState {
-				t.Fatalf("expected %s state, got %#v", tt.wantState, status)
-			}
-			if status.EncryptedStorage {
-				t.Fatalf("expected storage availability to remain visible as false: %#v", status)
-			}
-			if !strings.Contains(status.Message, "encrypted cookie storage unavailable") {
-				t.Fatalf("expected storage-specific message, got %#v", status)
-			}
-		})
-	}
-}
-
-func TestStatusStateMessageParityForAuthBlockers(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		dbPath      string
-		cfg         config.Config
-		spec        trackerSpec
-		wantState   string
-		wantMessage string
-	}{
-		"not configured": {
-			dbPath:      newTrackerAuthTestDB(t),
-			spec:        trackerSpec{id: "ASC", cookies: true},
-			wantState:   StateNotConfigured,
-			wantMessage: "auth material not configured",
-		},
-		"login required": {
-			dbPath:      newTrackerAuthTestDB(t),
-			spec:        trackerSpec{id: "PTP", cookies: true, login: true, needsCredentials: true},
-			wantState:   StateLoginRequired,
-			wantMessage: "login credentials or imported cookies required",
-		},
-		"encrypted storage unavailable": {
-			dbPath:      filepath.Join(t.TempDir(), "missing-auth", "upbrr.db"),
-			spec:        trackerSpec{id: "ASC", cookies: true},
-			wantState:   StateEncryptedStorageUnavailable,
-			wantMessage: "encrypted cookie storage unavailable; create web-auth.json before importing cookies",
-		},
-		"api key still needs upload auth": {
-			dbPath: newTrackerAuthTestDB(t),
-			cfg: config.Config{
-				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"MTV": {APIKey: "api-key"}}},
-			},
-			spec:        trackerSpec{id: "MTV", cookies: true, login: true, apiKey: true, needsCredentials: true},
-			wantState:   StateLoginRequired,
-			wantMessage: "API key covers Torznab/search; imported cookies or login credentials required for upload auth",
-		},
-		"btn missing api key": {
-			dbPath: newTrackerAuthTestDB(t),
-			cfg: config.Config{
-				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BTN": {Username: "user", Password: "pass"}}},
-			},
-			spec:        trackerSpec{id: "BTN", cookies: true, login: true, apiKey: true, needsCredentials: true},
-			wantState:   StateLoginRequired,
-			wantMessage: btnMissingAPIKeyMessage(),
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			cfg := tt.cfg
-			cfg.MainSettings.DBPath = tt.dbPath
-			service := NewService(cfg)
-			status := service.statusForSpec(context.Background(), tt.spec)
-			if status.State != tt.wantState {
-				t.Fatalf("expected state %q, got %#v", tt.wantState, status)
-			}
-			if status.Message != tt.wantMessage {
-				t.Fatalf("expected message %q for state %q, got %#v", tt.wantMessage, tt.wantState, status)
-			}
-		})
-	}
-}
-
-func TestStatusCookieReadErrorStaysDistinctFromMissingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	defer repo.Close()
-	if _, err := repo.RawDB().ExecContext(ctx, `UPDATE tracker_cookies SET encrypted_value = ? WHERE tracker_id = ?`, "not-base64", "PTP"); err != nil {
-		t.Fatalf("corrupt cookie row: %v", err)
-	}
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-	}).Status(ctx, "PTP")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.LastError == "" {
-		t.Fatalf("expected cookie read error detail, got %#v", status)
-	}
-	if strings.Contains(status.LastError, "no cookies found") {
-		t.Fatalf("cookie read error was reported as missing cookies: %#v", status)
-	}
-
-	missingStatus, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
-	}).Status(ctx, "PTP")
-	if err != nil {
-		t.Fatalf("Status missing cookies: %v", err)
-	}
-	if missingStatus.LastError != "" {
-		t.Fatalf("missing cookies must not populate LastError, got %#v", missingStatus)
-	}
-}
-
-func TestStatusCookieParseErrorStaysDistinctFromMissingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	jsonPath := trackerAuthLegacyCookiePathByExt(t, dbPath, "PTP", ".json")
-	if err := os.MkdirAll(filepath.Dir(jsonPath), 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	if err := os.WriteFile(jsonPath, []byte(`{"session":`), 0o600); err != nil {
-		t.Fatalf("write malformed cookie file: %v", err)
-	}
-
-	status, err := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-	}).Status(ctx, "PTP")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.LastError == "" {
-		t.Fatalf("expected cookie parse error detail, got %#v", status)
-	}
-	if strings.Contains(status.LastError, "no cookies found") {
-		t.Fatalf("cookie parse error was reported as missing cookies: %#v", status)
-	}
-	if !strings.Contains(status.LastError, "parse") && !strings.Contains(status.LastError, "unmarshal") {
-		t.Fatalf("expected parse detail, got %#v", status)
-	}
-}
-
-func TestStatusConfiguredAuthReportsCoexistingCookies(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		trackerID string
-		cfg       config.TrackerConfig
-	}{
-		"api key": {trackerID: "MTV", cfg: config.TrackerConfig{APIKey: "api-key"}},
-		"passkey": {trackerID: "HDB", cfg: config.TrackerConfig{Username: "user", Passkey: "passkey"}},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			ctx := context.Background()
-			dbPath := newTrackerAuthTestDB(t)
-			if err := cookies.SaveTrackerCookieMap(ctx, dbPath, tt.trackerID, map[string]string{"session": "abc"}); err != nil {
-				t.Fatalf("SaveTrackerCookieMap: %v", err)
-			}
-			service := NewService(config.Config{
-				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-				Trackers: config.TrackersConfig{
-					Trackers: map[string]config.TrackerConfig{tt.trackerID: tt.cfg},
-				},
-			})
-
-			status, err := service.Status(ctx, tt.trackerID)
-			if err != nil {
-				t.Fatalf("Status: %v", err)
-			}
-			if status.State != StateConfigured || status.CookieCount != 1 {
-				t.Fatalf("expected configured state with cookie count, got %#v", status)
-			}
-			if !strings.Contains(status.Message, "stored cookie") {
-				t.Fatalf("expected message to preserve cookie presence, got %#v", status)
-			}
-		})
-	}
-}
-
-func TestStatusHDBPasskeyWithoutCookiesIsNotUploadReady(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{"HDB": {Username: "user", Passkey: "passkey"}},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "HDB")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateLoginRequired {
-		t.Fatalf("expected HDB cookie import requirement, got %#v", status)
-	}
-}
-
-func TestStatusMTVAPIKeyOnlyReportsUploadNotReady(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{"MTV": {APIKey: "api-key"}},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "MTV")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateLoginRequired {
-		t.Fatalf("expected upload auth to be login-required, got %#v", status)
-	}
-	if !strings.Contains(status.Message, "API key covers Torznab/search") || !strings.Contains(status.Message, "required for upload auth") {
-		t.Fatalf("expected split search/upload message, got %#v", status)
-	}
-}
-
-func TestStatusMTVCredentialsWithoutAPIKeyRemainUploadReady(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{"MTV": {Username: "user", Password: "pass"}},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "MTV")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected MTV credentials to remain upload-ready, got %#v", status)
-	}
-}
-
-func TestStatusCookiesOnlyReportsEncryptedStorageUnavailable(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")},
-	})
-	status := service.statusForSpec(context.Background(), trackerSpec{
-		id:      "ASC",
-		cookies: true,
-	})
-	if status.State != StateEncryptedStorageUnavailable {
-		t.Fatalf("expected encrypted storage unavailable, got %#v", status)
-	}
-	if status.EncryptedStorage {
-		t.Fatalf("expected storage availability to remain visible as false: %#v", status)
-	}
-}
-
-func TestRTFStatusTreatsCredentialsAsRefreshAuth(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"RTF": {Username: "user", Password: "pass"},
-			},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "RTF")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("RTF credentials should report refresh auth configured without api_key: %#v", status)
-	}
-}
-
-func TestTHRDoesNotAdvertiseCookieImport(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{})
-	caps, err := service.Capabilities(context.Background())
-	if err != nil {
-		t.Fatalf("Capabilities: %v", err)
-	}
-	for _, cap := range caps {
-		if cap.TrackerID != "THR" {
-			continue
-		}
-		if cap.SupportsCookieFile {
-			t.Fatalf("THR upload logs in per request and must not advertise DB cookie import: %#v", cap)
-		}
-		return
-	}
-	t.Fatal("THR capability not found")
-}
-
-func TestFFAdvertisesCookieImportWithRemoteLoginAction(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{})
-	caps, err := service.Capabilities(context.Background())
-	if err != nil {
-		t.Fatalf("Capabilities: %v", err)
-	}
-	for _, cap := range caps {
-		if cap.TrackerID != "FF" {
-			continue
-		}
-		if !cap.SupportsCookieFile {
-			t.Fatalf("FF upload can use DB cookies and must advertise cookie import: %#v", cap)
-		}
-		if !cap.SupportsLogin || !cap.SupportsAutoLogin {
-			t.Fatalf("FF tracker-auth adapter must advertise login actions: %#v", cap)
-		}
-		return
-	}
-	t.Fatal("FF capability not found")
-}
-
-func TestValidateWithoutAdapterReportsUnsupportedRemoteValidation(t *testing.T) {
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"ASC": {},
-			},
-		},
-	}
-	status, err := NewService(cfg).Validate(context.Background(), "ASC")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if strings.Contains(status.Message, "succeeded") {
-		t.Fatalf("unexpected remote success message: %#v", status)
-	}
-	if !strings.Contains(status.Message, "not supported") {
-		t.Fatalf("expected unsupported remote validation message, got %#v", status)
-	}
-}
-
-func TestParseCookieContentJSONMap(t *testing.T) {
-	got, err := ParseCookieContent("MTV.json", `{"session":"abc","nested":{"value":"def"}}`)
-	if err != nil {
-		t.Fatalf("ParseCookieContent: %v", err)
-	}
-	if got["session"] != "abc" || got["nested"] != "def" {
-		t.Fatalf("unexpected cookies: %#v", got)
-	}
-}
-
-func TestParseCookieContentJSONArray(t *testing.T) {
-	got, err := ParseCookieContent("PTP.json", `[
-		{"domain":".example.test","name":"session","value":"abc"},
-		{"name":"token","value":"latest"},
-		{"name":"empty","value":""},
-		{"name":"","value":"ignored"}
-	]`)
-	if err != nil {
-		t.Fatalf("ParseCookieContent: %v", err)
-	}
-	if got["session"] != "abc" || got["token"] != "latest" {
-		t.Fatalf("unexpected cookies: %#v", got)
-	}
-	if _, ok := got["empty"]; ok {
-		t.Fatalf("empty cookie value should be ignored: %#v", got)
-	}
-}
-
-func TestParseCookieContentJSONArrayWithoutJSONExtension(t *testing.T) {
-	got, err := ParseCookieContent("PTP.txt", `[
-		{"domain":".example.test","name":"session","value":"abc"}
-	]`)
-	if err != nil {
-		t.Fatalf("ParseCookieContent: %v", err)
-	}
-	if got["session"] != "abc" {
-		t.Fatalf("unexpected cookies: %#v", got)
-	}
-}
-
-func TestParseCookieContentNetscape(t *testing.T) {
-	got, err := ParseCookieContent("PTP.txt", ".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n")
-	if err != nil {
-		t.Fatalf("ParseCookieContent: %v", err)
-	}
-	if got["session"] != "abc" {
-		t.Fatalf("unexpected cookies: %#v", got)
-	}
-}
-
-func TestParseCookieContentRejectsTrimmedObjectKeyCollision(t *testing.T) {
-	t.Parallel()
-
-	_, err := ParseCookieContent("cookies.json", `{"session":"abc"," session ":"def"}`)
-	if err == nil {
-		t.Fatal("expected trimmed key collision error")
-	}
-	if !strings.Contains(err.Error(), "duplicate cookie name") {
-		t.Fatalf("expected duplicate cookie name error, got %v", err)
-	}
-}
-
-func TestParseCookieContentRejectsDuplicateJSONObjectNamesBeforeMapCollapse(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]string{
-		"root exact":           `{"session":"abc","session":"def"}`,
-		"root escaped":         `{"session":"abc","\u0073ession":"def"}`,
-		"nested value exact":   `{"session":{"value":"abc","value":"def"}}`,
-		"nested value escaped": `{"session":{"value":"abc","\u0076alue":"def"}}`,
-		"array name exact":     `[{"name":"session","name":"token","value":"abc"}]`,
-		"array value escaped":  `[{"name":"session","value":"abc","\u0076alue":"def"}]`,
-	}
-	for name, content := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := ParseCookieContent("cookies.json", content)
-			if err == nil {
-				t.Fatal("expected duplicate error")
-			}
-			if !strings.Contains(err.Error(), "duplicate cookie name") {
-				t.Fatalf("expected duplicate cookie name error, got %v", err)
-			}
-		})
-	}
-}
-
-func TestParseCookieContentAllowsNestedNonCookieDuplicateJSONKeys(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]string{
-		"object metadata": `{"session":{"value":"abc","metadata":{"same":"first","same":"second"}}}`,
-		"array metadata":  `[{"name":"session","value":"abc","metadata":{"same":"first","same":"second"}}]`,
-	}
-	for name, content := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := ParseCookieContent("cookies.json", content)
-			if err != nil {
-				t.Fatalf("ParseCookieContent: %v", err)
-			}
-			if got["session"] != "abc" {
-				t.Fatalf("unexpected cookies: %#v", got)
-			}
-		})
-	}
-}
-
-func TestParseCookieContentValidJSONModesUnchanged(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		fileName string
-		content  string
-		want     map[string]string
-	}{
-		"root map": {
-			fileName: "cookies.json",
-			content:  `{"session":"abc","nested":{"value":"def"}}`,
-			want:     map[string]string{"session": "abc", "nested": "def"},
-		},
-		"array": {
-			fileName: "cookies.json",
-			content:  `[{"name":"session","value":"abc"},{"name":"token","value":"def"}]`,
-			want:     map[string]string{"session": "abc", "token": "def"},
-		},
-		"txt array": {
-			fileName: "cookies.txt",
-			content:  `[{"name":"session","value":"abc"}]`,
-			want:     map[string]string{"session": "abc"},
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := ParseCookieContent(tt.fileName, tt.content)
-			if err != nil {
-				t.Fatalf("ParseCookieContent: %v", err)
-			}
-			for key, want := range tt.want {
-				if got[key] != want {
-					t.Fatalf("unexpected cookie %s: got %#v want %q", key, got, want)
-				}
-			}
-		})
-	}
-}
-
-func TestParseCookieContentPreservesCookieValueWhitespace(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		fileName string
-		content  string
-	}{
-		"JSON object": {
-			fileName: "cookies.json",
-			content:  `{"session":" abc "}`,
-		},
-		"JSON array": {
-			fileName: "cookies.json",
-			content:  `[{"name":"session","value":" abc "}]`,
-		},
-		"Netscape": {
-			fileName: "cookies.txt",
-			content:  ".example.test\tTRUE\t/\tTRUE\t0\tsession\t abc ",
-		},
-		"Netscape HttpOnly": {
-			fileName: "cookies.txt",
-			content:  "#HttpOnly_.example.test\tTRUE\t/\tTRUE\t0\tsession\t abc ",
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := ParseCookieContent(tt.fileName, tt.content)
-			if err != nil {
-				t.Fatalf("ParseCookieContent: %v", err)
-			}
-			if got["session"] != " abc " {
-				t.Fatalf("cookie value was normalized: %#v", got)
-			}
-		})
-	}
-}
-
-func TestApplyEnsureErrorToStatusDoesNotExposeEmpty2FAChallenge(t *testing.T) {
-	t.Parallel()
-
-	status := api.TrackerAuthStatus{TrackerID: "PTP", State: StateConfigured}
-	applyEnsureErrorToStatus(&status, &Needs2FAError{TrackerID: "PTP", Reason: "2FA required"})
-
-	if status.Needs2FA {
-		t.Fatalf("empty challenge must not enable 2FA submission: %#v", status)
-	}
-	if status.ChallengeID != "" {
-		t.Fatalf("empty challenge must not set challenge id: %#v", status)
-	}
-	if status.State != StateLoginRequired {
-		t.Fatalf("expected login required state, got %#v", status)
-	}
-}
-
-func TestApplyEnsureErrorToStatusKeepsStateMessageParity(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		err         error
-		wantState   string
-		wantMessage string
-	}{
-		"cookie storage": {
-			err:         errors.New("cookies: load tracker PTP from db: failed to decode stored cookie"),
-			wantState:   StateEncryptedStorageUnavailable,
-			wantMessage: "cookie storage unavailable; see error details",
-		},
-		"auth required": {
-			err:         &AuthRequiredError{TrackerID: "PTP", Reason: "missing cookies"},
-			wantState:   StateLoginRequired,
-			wantMessage: "login credentials or imported cookies required",
-		},
-		"confirmed invalid": {
-			err:         &ValidationError{TrackerID: "PTP", ConfirmedInvalid: true, Err: errors.New("expired")},
-			wantState:   StateLoginRequired,
-			wantMessage: "stored session expired or invalid; log in again or import fresh cookies",
-		},
-		"2FA with challenge": {
-			err:         &Needs2FAError{TrackerID: "PTP", ChallengeID: "challenge-1"},
-			wantState:   StateLoginRequired,
-			wantMessage: "2FA required",
-		},
-		"2FA without challenge": {
-			err:         &Needs2FAError{TrackerID: "PTP"},
-			wantState:   StateLoginRequired,
-			wantMessage: "2FA required but no manual challenge is available",
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			status := api.TrackerAuthStatus{TrackerID: "PTP", State: StateConfigured}
-			applyEnsureErrorToStatus(&status, tt.err)
-			if status.State != tt.wantState {
-				t.Fatalf("expected state %q, got %#v", tt.wantState, status)
-			}
-			if status.Message != tt.wantMessage {
-				t.Fatalf("expected message %q, got %#v", tt.wantMessage, status)
-			}
-			if status.LastError == "" {
-				t.Fatalf("expected LastError for blocker, got %#v", status)
-			}
-		})
-	}
-}
-
-func TestApplyEnsureErrorToStatusRedactsURLPath(t *testing.T) {
-	t.Parallel()
-
-	status := api.TrackerAuthStatus{TrackerID: "MTV", State: StateConfigured}
-	applyEnsureErrorToStatus(&status, errors.New(`Get "https://www.morethantv.me/secret-login-token?passkey=abc": auth key not found`))
-
-	if strings.Contains(status.LastError, "secret-login-token") || strings.Contains(status.LastError, "abc") {
-		t.Fatalf("LastError leaked URL secret: %#v", status)
-	}
-	if !strings.Contains(status.LastError, "https://www.morethantv.me/[REDACTED]") {
-		t.Fatalf("LastError lost useful URL host context: %#v", status)
-	}
-}
-
-func TestCookiesToMapPreservesCookieValueWhitespace(t *testing.T) {
-	t.Parallel()
-
-	got := CookiesToMap([]*http.Cookie{{Name: " session ", Value: " abc "}})
-	if got["session"] != " abc " {
-		t.Fatal("cookie value was normalized")
-	}
-}
-
-func TestParseCookieContentInvalidLeadingArrayReportsJSONError(t *testing.T) {
-	t.Parallel()
-
-	_, err := ParseCookieContent("PTP.txt", `[{"name":"session","value":"abc"}`)
-	if err == nil {
-		t.Fatal("expected invalid JSON error")
-	}
-	if !strings.Contains(err.Error(), "parse JSON cookies") {
-		t.Fatalf("expected JSON parse error, got %v", err)
-	}
-}
-
-func TestParseCookieContentRejectsDuplicateNames(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]struct {
-		fileName string
-		content  string
-	}{
-		"JSON array": {
-			fileName: "cookies.json",
-			content:  `[{"name":"session","value":"abc"},{"name":"session","value":"def"}]`,
-		},
-		"Netscape": {
-			fileName: "cookies.txt",
-			content:  ".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n.example.test\tTRUE\t/\tTRUE\t0\tsession\tdef\n",
-		},
-	}
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := ParseCookieContent(tt.fileName, tt.content)
-			if err == nil {
-				t.Fatal("expected duplicate error")
-			}
-			if !strings.Contains(err.Error(), "duplicate cookie name") {
-				t.Fatalf("expected duplicate error, got %v", err)
-			}
-		})
-	}
-}
-
-func TestParseCookieContentNetscapeOversizedValidLine(t *testing.T) {
-	value := strings.Repeat("a", 70*1024)
-	got, err := ParseCookieContent("PTP.txt", ".example.test\tTRUE\t/\tTRUE\t0\tsession\t"+value)
-	if err != nil {
-		t.Fatalf("ParseCookieContent: %v", err)
-	}
-	if got["session"] != value {
-		t.Fatalf("unexpected oversized cookie value length: got %d want %d", len(got["session"]), len(value))
-	}
-}
-
-func TestParseCookieContentNetscapeOversizedMalformedLineHasNoEntries(t *testing.T) {
-	_, err := ParseCookieContent("PTP.txt", strings.Repeat("x", 70*1024))
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "no entries") {
-		t.Fatalf("expected no entries error, got %v", err)
-	}
-}
-
-func TestParseCookieContentJSONRejectsInvalidShapes(t *testing.T) {
-	tests := map[string]string{
-		"empty":         "",
-		"invalid json":  "{",
-		"non-object":    `[{"name":"session","value":"abc"},"bad"]`,
-		"missing name":  `[{"value":"abc"}]`,
-		"missing value": `[{"name":"session"}]`,
-	}
-	for name, payload := range tests {
-		t.Run(name, func(t *testing.T) {
-			if _, err := ParseCookieContent("cookies.json", payload); err == nil {
-				t.Fatal("expected error")
-			}
-		})
-	}
-}
-
-func TestImportCookiesRejectsMalformedArrayEntryWithoutReplacingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	_, err := service.ImportCookies(ctx, "AR", "cookies.json", `[
-		{"name":"session","value":"replacement"},
-		{"name":"token"}
-	]`)
-	if err == nil {
-		t.Fatal("expected malformed array entry error")
-	}
-	if !strings.Contains(err.Error(), "require name and value") {
-		t.Fatalf("expected missing value error, got %v", err)
-	}
-
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("existing cookies changed after failed import")
-	}
-}
-
-func TestImportCookiesRejectsOverCapWithoutReplacingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	_, err := service.ImportCookies(ctx, "AR", "cookies.txt", strings.Repeat("x", MaxCookieImportContentBytes+1))
-	if err == nil {
-		t.Fatal("expected over-cap import error")
-	}
-	if !strings.Contains(err.Error(), "exceeds") {
-		t.Fatalf("expected size error, got %v", err)
-	}
-
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("existing cookies changed after failed import")
-	}
-}
-
-func TestImportCookiesReportsMergedCookieCount(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	legacyPath, err := servicedb.CookiePath(dbPath, "AR.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
-		t.Fatalf("mkdir legacy dir: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, []byte(".example.test\tTRUE\t/\tTRUE\t0\tlegacy\tfrom-file\n"), 0o600); err != nil {
-		t.Fatalf("write legacy cookies: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	status, err := service.ImportCookies(ctx, "AR", "cookies.json", `{"session":"from-db"}`)
-	if err != nil {
-		t.Fatalf("ImportCookies: %v", err)
-	}
-	if status.CookieCount != 2 {
-		t.Fatalf("expected merged cookie count, got %#v", status)
-	}
-}
-
-func TestImportCookiesPreservesBTNMissingAPIStatus(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {},
-		}},
-	})
-
-	status, err := service.ImportCookies(ctx, "BTN", "cookies.json", `{"session":"abc"}`)
-	if err != nil {
-		t.Fatalf("ImportCookies: %v", err)
-	}
-	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
-		t.Fatalf("expected missing BTN API to survive cookie import, got %#v", status)
-	}
-}
-
-func TestCapabilitiesAdvertiseOnlySupportedManual2FA(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{})
-	caps, err := service.Capabilities(context.Background())
-	if err != nil {
-		t.Fatalf("Capabilities: %v", err)
-	}
-	for _, cap := range caps {
-		switch cap.TrackerID {
-		case "MTV", "PTP":
-			if !cap.SupportsManual2FA {
-				t.Fatalf("%s must advertise supported manual 2FA", cap.TrackerID)
-			}
-			if !cap.SupportsTOTP {
-				t.Fatalf("%s TOTP auto-login capability must be preserved", cap.TrackerID)
-			}
-			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
-				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
-			}
-		case "RTF":
-			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
-				t.Fatalf("%s API refresh capability must be preserved: %#v", cap.TrackerID, cap)
-			}
-			if cap.SupportsManual2FA || cap.SupportsTOTP {
-				t.Fatalf("%s must not advertise 2FA actions: %#v", cap.TrackerID, cap)
-			}
-		case "AR":
-			if !cap.SupportsLogin || !cap.SupportsAutoLogin || cap.SupportsManual2FA {
-				t.Fatalf("%s must advertise credential auto-login without manual 2FA: %#v", cap.TrackerID, cap)
-			}
-			if !cap.SupportsCookieFile {
-				t.Fatalf("%s must keep cookie import capability: %#v", cap.TrackerID, cap)
-			}
-		case "HDB":
-			if cap.SupportsLogin || cap.SupportsAutoLogin || cap.SupportsManual2FA {
-				t.Fatalf("%s auth check is validation-only in tracker-auth UI: %#v", cap.TrackerID, cap)
-			}
-			if !cap.SupportsCookieFile || !cap.RequiresPasskey {
-				t.Fatalf("%s must keep cookie/passkey capability: %#v", cap.TrackerID, cap)
-			}
-		case "FF", "FL":
-			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
-				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
-			}
-			if !cap.SupportsCookieFile || cap.SupportsManual2FA {
-				t.Fatalf("%s must advertise cookie import without manual 2FA: %#v", cap.TrackerID, cap)
-			}
-		case "THR":
-			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
-				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
-			}
-			if cap.SupportsCookieFile || cap.SupportsManual2FA {
-				t.Fatalf("%s must advertise stateless login without cookie import or 2FA: %#v", cap.TrackerID, cap)
-			}
-		case "ASC":
-			if cap.SupportsLogin || cap.SupportsAutoLogin || cap.SupportsManual2FA {
-				t.Fatalf("%s must not advertise unsupported login actions: %#v", cap.TrackerID, cap)
-			}
-		}
-	}
-}
-
-func TestBuiltInSpecsOnlyReferenceKnownTrackers(t *testing.T) {
-	t.Parallel()
-
-	for _, spec := range builtInSpecs() {
-		if !trackers.IsKnownTracker(spec.id) {
-			t.Fatalf("built-in tracker auth spec references unknown tracker %s", spec.id)
-		}
-	}
-}
-
-func TestTrackerAuthLogsOperationResultsWithoutSecrets(t *testing.T) {
-	t.Parallel()
-
-	logger := &trackerAuthRecordingLogger{}
-	service := NewServiceWithLogger(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"MTV": {APIKey: "secret-api-key", Username: "secret-user", Password: "secret-password"},
-			},
-		},
-	}, logger)
-
-	status, err := service.Status(context.Background(), "MTV")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.TrackerID != "MTV" {
-		t.Fatalf("expected MTV status, got %#v", status)
-	}
-	if _, err := service.Capabilities(context.Background()); err != nil {
-		t.Fatalf("Capabilities: %v", err)
-	}
-	if _, err := service.ImportCookies(context.Background(), "AR", "cookies.json", "{bad"); err == nil {
-		t.Fatal("expected invalid cookie import to fail")
-	}
-
-	infoLog := strings.Join(logger.info, "\n")
-	traceLog := strings.Join(logger.trace, "\n")
-	warnLog := strings.Join(logger.warn, "\n")
-	allLogs := infoLog + "\n" + traceLog + "\n" + warnLog
-	if !strings.Contains(traceLog, "tracker auth: status checked tracker=MTV") {
-		t.Fatal("expected status trace log")
-	}
-	if !strings.Contains(traceLog, "tracker auth: capabilities loaded count=") {
-		t.Fatal("expected capabilities trace log")
-	}
-	for _, routine := range []string{"tracker auth: status checked tracker=MTV", "tracker auth: capabilities loaded count="} {
-		if strings.Contains(infoLog, routine) {
-			t.Fatal("routine tracker auth log used info level")
-		}
-	}
-	if !strings.Contains(warnLog, "tracker auth: cookie import failed tracker=AR bytes=4") {
-		t.Fatal("expected import warning log")
-	}
-	for _, secret := range []string{"secret-api-key", "secret-user", "secret-password", "{bad"} {
-		if strings.Contains(allLogs, secret) {
-			t.Fatal("tracker auth log leaked secret")
-		}
-	}
-}
-
-func TestTrackerAuthWarningStatusDoesNotLogSuccess(t *testing.T) {
-	t.Parallel()
-
-	logger := &trackerAuthRecordingLogger{}
-	service := NewServiceWithLogger(config.Config{}, logger)
-	service.logStatus("login completed", api.TrackerAuthStatus{
-		TrackerID: "MTV",
-		State:     StateConfigured,
-		LastError: "tracker auth: MTV: validation failed",
-	})
-
-	infoLog := strings.Join(logger.info, "\n")
-	warnLog := strings.Join(logger.warn, "\n")
-	if strings.Contains(infoLog, "tracker auth: login completed") {
-		t.Fatalf("warning status logged success info: info=%q warn=%q", infoLog, warnLog)
-	}
-	if !strings.Contains(warnLog, "tracker auth: login completed warning tracker=MTV") {
-		t.Fatalf("expected warning log, got info=%q warn=%q", infoLog, warnLog)
-	}
-}
-
-func TestTrackerAuthConfiguredLoginStatusUsesInfo(t *testing.T) {
-	t.Parallel()
-
-	logger := &trackerAuthRecordingLogger{}
-	service := NewServiceWithLogger(config.Config{}, logger)
-	service.logStatus("login completed", api.TrackerAuthStatus{
-		TrackerID: "MTV",
-		State:     StateConfigured,
-	})
-
-	infoLog := strings.Join(logger.info, "\n")
-	traceLog := strings.Join(logger.trace, "\n")
-	if !strings.Contains(infoLog, "tracker auth: login completed tracker=MTV") {
-		t.Fatalf("expected successful login info log, got info=%q trace=%q", infoLog, traceLog)
-	}
-	if strings.Contains(traceLog, "tracker auth: login completed tracker=MTV") {
-		t.Fatalf("successful login logged at trace: info=%q trace=%q", infoLog, traceLog)
-	}
-}
-
-func TestTrackerAuthRejectsCaseCollidingConfigIDs(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"ar": {Username: "user", Password: "pass"},
-				"AR": {APIKey: "api-key"},
-			},
-		},
-	})
-
-	if _, err := service.Capabilities(context.Background()); err == nil {
-		t.Fatal("expected capabilities to reject duplicate tracker ids")
-	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
-		t.Fatalf("expected duplicate tracker id error, got %v", err)
-	}
-	if _, err := service.Status(context.Background(), "AR"); err == nil {
-		t.Fatal("expected status to reject duplicate tracker ids")
-	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
-		t.Fatalf("expected duplicate tracker id error, got %v", err)
-	}
-	if _, err := service.Delete(context.Background(), "AR"); err == nil {
-		t.Fatal("expected delete to reject duplicate tracker ids")
-	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
-		t.Fatalf("expected duplicate tracker id error, got %v", err)
-	}
-}
-
-func TestTrackerAuthKeepsCaseInsensitiveSingleConfigLookup(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"ar": {Username: "user", Password: "pass"},
-			},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "AR")
-	if err != nil {
-		t.Fatalf("Status: %v", err)
-	}
-	if status.State != StateEncryptedStorageUnavailable {
-		t.Fatalf("expected single case variant to preserve storage readiness, got %#v", status)
-	}
-}
-
-func TestTrackerAuthKeepsCustomUnicodeConfigLookupCanonical(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"åar": {Username: "user", Password: "pass"},
-			},
-		},
-	})
-
-	status, err := service.Status(context.Background(), "åar")
-	if err != nil {
-		t.Fatalf("Status lowercase Unicode tracker: %v", err)
-	}
-	if status.State != StateConfigured {
-		t.Fatalf("expected custom Unicode tracker to remain configured, got %#v", status)
-	}
-	if _, err := service.Status(context.Background(), "Åar"); err == nil {
-		t.Fatal("expected Unicode-folded tracker id to remain unknown")
-	}
-}
-
-func TestTrackerAuthRejectsASCIICollidingUnicodeConfigIDs(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"åar": {Username: "user", Password: "pass"},
-				"åAR": {APIKey: "api-key"},
-			},
-		},
-	})
-
-	if _, err := service.Capabilities(context.Background()); err == nil {
-		t.Fatal("expected capabilities to reject duplicate custom Unicode tracker ids")
-	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
-		t.Fatalf("expected duplicate tracker id error, got %v", err)
-	}
-}
-
-func TestTrackerAuthDoesNotFoldUnicodeLookalikeTrackerIDs(t *testing.T) {
-	t.Parallel()
-
-	service := NewService(config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"K": {Username: "user", Password: "pass"},
-			},
-		},
-	})
-
-	if _, err := service.Status(context.Background(), "K"); err != nil {
-		t.Fatalf("Status ASCII tracker: %v", err)
-	}
-	if _, err := service.Status(context.Background(), "\u212a"); err == nil {
-		t.Fatal("expected Unicode lookalike tracker id to be unknown")
-	}
-}
-
-func TestDeleteARAuthClearsCookiesAuthStateAndLegacyAuth(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
-		t.Fatalf("SaveAuthState: %v", err)
-	}
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
-		t.Fatalf("mkdir legacy dir: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, []byte("legacy-auth-key"), 0o600); err != nil {
-		t.Fatalf("write legacy auth: %v", err)
-	}
-
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-	status, err := service.Delete(ctx, "AR")
-	if err != nil {
-		t.Fatalf("Delete: %v", err)
-	}
-	if status.CookieCount != 0 {
-		t.Fatalf("expected zero cookies after delete, got %#v", status)
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
-		t.Fatal("expected AR cookies to be deleted")
-	}
-	if _, err := LoadAuthState(ctx, dbPath, "AR", "auth_key"); !errors.Is(err, ErrAuthStateNotFound) {
-		t.Fatalf("expected AR auth state to be deleted, got %v", err)
-	}
-	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
-		t.Fatalf("expected legacy AR auth to be deleted, got %v", err)
-	}
-}
-
-func TestDeleteARAuthStatusRefreshIgnoresCancellationAfterMutation(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	deleteCtx, cancel := context.WithCancel(context.Background())
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-	service.afterDeleteCleanup = cancel
-
-	status, err := service.Delete(deleteCtx, "AR")
-	if err != nil {
-		t.Fatalf("Delete: %v", err)
-	}
-	if deleteCtx.Err() == nil {
-		t.Fatal("expected delete context to be canceled before status refresh")
-	}
-	if status.CookieCount != 0 || status.Message != "stored auth deleted" {
-		t.Fatalf("expected truthful delete status after cancellation, got %#v", status)
-	}
-	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
-		t.Fatal("expected AR cookies to be deleted")
-	}
-}
-
-func TestDeleteARAuthLegacyPathFailureReturnsError(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
-		t.Fatalf("SaveAuthState: %v", err)
-	}
-	cookiesDir := filepath.Join(filepath.Dir(dbPath), "cookies")
-	if err := os.WriteFile(cookiesDir, []byte("blocks cookie path"), 0o600); err != nil {
-		t.Fatalf("write cookie path blocker: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	_, err := service.Delete(ctx, "AR")
-	if err == nil {
-		t.Fatal("expected legacy auth path resolution error")
-	}
-	if !strings.Contains(err.Error(), "resolve AR legacy auth key path") {
-		t.Fatalf("expected legacy path resolution error, got %v", err)
-	}
-	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
-	if err != nil {
-		t.Fatalf("expected AR auth state to be restored: %v", err)
-	}
-	if authKey != "secret-auth-key" {
-		t.Fatalf("unexpected restored auth state")
-	}
-}
-
-func TestDeleteARAuthWithoutWebAuthMaterialDeletesStaleAuth(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	_ = repo.Close()
-	legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
-		t.Fatalf("mkdir legacy dir: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, []byte("legacy-auth-key"), 0o600); err != nil {
-		t.Fatalf("write legacy auth: %v", err)
-	}
-	cookiePath, err := servicedb.CookiePath(dbPath, "AR.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.WriteFile(cookiePath, []byte(".alpharatio.cc\tTRUE\t/\tTRUE\t0\tsession\tabc\n"), 0o600); err != nil {
-		t.Fatalf("write legacy cookies: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	_, err = service.Delete(ctx, "AR")
-	if err != nil {
-		t.Fatalf("Delete: %v", err)
-	}
-	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
-		t.Fatalf("expected legacy AR auth deleted, got %v", err)
-	}
-	if _, err := os.Stat(cookiePath); !os.IsNotExist(err) {
-		t.Fatalf("expected cookies deleted, got %v", err)
-	}
-}
-
-func TestDeleteARCookieFailureRestoresAuthState(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
-		t.Fatalf("SaveAuthState: %v", err)
-	}
-	legacyAuthPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(legacyAuthPath), 0o700); err != nil {
-		t.Fatalf("mkdir legacy auth dir: %v", err)
-	}
-	if err := os.WriteFile(legacyAuthPath, []byte("legacy-auth-key"), 0o600); err != nil {
-		t.Fatalf("write legacy auth: %v", err)
-	}
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	legacyCookiePath, err := servicedb.CookiePath(dbPath, "AR.txt")
-	if err != nil {
-		t.Fatalf("CookiePath: %v", err)
-	}
-	if err := os.MkdirAll(legacyCookiePath, 0o700); err != nil {
-		t.Fatalf("mkdir legacy cookie path: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(legacyCookiePath, "child"), []byte("blocks remove"), 0o600); err != nil {
-		t.Fatalf("write legacy cookie child: %v", err)
-	}
-	service := NewService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
-
-	_, err = service.Delete(ctx, "AR")
-	if err == nil {
-		t.Fatal("expected cookie delete error")
-	}
-	if !strings.Contains(err.Error(), "delete AR cookies") {
-		t.Fatalf("expected cookie delete error, got %v", err)
-	}
-	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
-	if err != nil {
-		t.Fatalf("expected AR auth state to be restored: %v", err)
-	}
-	if authKey != "secret-auth-key" {
-		t.Fatalf("unexpected restored auth state")
-	}
-	legacyAuth, err := os.ReadFile(legacyAuthPath)
-	if err != nil {
-		t.Fatalf("expected legacy AR auth to be restored: %v", err)
-	}
-	if string(legacyAuth) != "legacy-auth-key" {
-		t.Fatalf("unexpected restored legacy AR auth")
-	}
-	cookieValues, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("expected AR cookies to be restored: %v", err)
-	}
-	if cookieValues["session"] != "abc" {
-		t.Fatal("unexpected restored AR cookies")
-	}
-}
-
-func TestTrackerAuthSnapshotRestoreIgnoresCanceledContext(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
-		t.Fatalf("SaveAuthState: %v", err)
-	}
-	snapshot, err := snapshotTrackerAuthState(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("snapshotTrackerAuthState: %v", err)
-	}
-	if err := deleteTrackerAuthState(ctx, dbPath, "AR"); err != nil {
-		t.Fatalf("deleteTrackerAuthState: %v", err)
-	}
-
-	cancelledCtx, cancel := context.WithCancel(context.Background())
-	cancel()
-	if err := snapshot.restore(cancelledCtx); err != nil {
-		t.Fatalf("restore with canceled context: %v", err)
-	}
-	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
-	if err != nil {
-		t.Fatalf("expected AR auth state to be restored: %v", err)
-	}
-	if authKey != "secret-auth-key" {
-		t.Fatalf("unexpected restored auth state")
-	}
-}
-
-func TestEnsureSessionPreservesMTVCookiesOnInvalidLookingAdapterText(t *testing.T) {
-	t.Parallel()
-
-	tests := map[string]string{
-		"MTV": "session",
-	}
-	for trackerID, cookieName := range tests {
-		t.Run(trackerID, func(t *testing.T) {
-			t.Parallel()
-
-			ctx := context.Background()
-			dbPath := newTrackerAuthTestDB(t)
-			if err := cookies.SaveTrackerCookieMap(ctx, dbPath, trackerID, map[string]string{cookieName: "abc"}); err != nil {
-				t.Fatalf("SaveTrackerCookieMap: %v", err)
-			}
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte("<html>logged out</html>"))
-			}))
-			t.Cleanup(server.Close)
-
-			service := NewService(config.Config{})
-			_, err := service.EnsureSession(ctx, EnsureRequest{
-				TrackerID: trackerID,
-				Config:    config.TrackerConfig{URL: server.URL},
-				DBPath:    dbPath,
-				AutoLogin: true,
-			})
-			if err == nil {
-				t.Fatal("expected validation error")
-			}
-			values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, trackerID)
-			if err != nil {
-				t.Fatalf("LoadTrackerCookieMap: %v", err)
-			}
-			if values[cookieName] != "abc" {
-				t.Fatal("expected invalid-looking adapter text to preserve cookies")
-			}
-		})
-	}
-}
-
-func TestValidateTransientAdapterFailurePreservesCookieCount(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "MTV", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("<html>logged out</html>"))
-	}))
-	t.Cleanup(server.Close)
-
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"MTV": {URL: server.URL},
-			},
-		},
-	})
-	status, err := service.Validate(ctx, "MTV")
-	if err != nil {
-		t.Fatalf("Validate: %v", err)
-	}
-	if status.State != StateHasCookies {
-		t.Fatalf("expected cookies to remain configured after transient adapter failure, got %#v", status)
-	}
-	if status.CookieCount != 1 {
-		t.Fatalf("expected existing cookies to be preserved, got %#v", status)
-	}
-	if !strings.Contains(status.LastError, "auth key not found") {
-		t.Fatalf("expected adapter failure in status, got %#v", status)
-	}
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "MTV")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "abc" {
-		t.Fatal("expected transient adapter failure to preserve cookies")
-	}
-}
-
-func TestValidateManyRunsTrackerChecksConcurrentlyAndPreservesOrder(t *testing.T) {
-	t.Parallel()
-
-	dbPath := newTrackerAuthTestDB(t)
-	trackerIDs := [maxConcurrentValidations + 1]string{"PTP", "MTV", "RTF", "AR", "HDB"}
-	entered := make(chan string, len(trackerIDs))
-	releases := make(map[string]chan struct{}, len(trackerIDs))
-	released := make(map[string]bool, len(trackerIDs))
-	releaseValidation := func(trackerID string) {
-		if !released[trackerID] {
-			close(releases[trackerID])
-			released[trackerID] = true
-		}
-	}
-	defer func() {
-		for _, trackerID := range trackerIDs {
-			releaseValidation(trackerID)
-		}
-	}()
-	newBlockingAdapter := func(trackerID string) *fakeAdapter {
-		release := make(chan struct{})
-		releases[trackerID] = release
-		return &fakeAdapter{
-			capability: api.TrackerAuthCapability{TrackerID: trackerID, SupportsLogin: true},
-			validate: func() (Session, error) {
-				entered <- trackerID
-				<-release
-				return Session{TrackerID: trackerID, State: SessionStateReady}, nil
-			},
-		}
-	}
-	trackerConfigs := make(map[string]config.TrackerConfig, len(trackerIDs))
-	for _, trackerID := range trackerIDs {
-		trackerConfigs[trackerID] = config.TrackerConfig{}
-	}
-	service := NewService(config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers:     config.TrackersConfig{Trackers: trackerConfigs},
-	})
-	for _, trackerID := range trackerIDs {
-		service.adapters[trackerID] = newBlockingAdapter(trackerID)
-	}
-
-	type result struct {
-		statuses []api.TrackerAuthStatus
-		err      error
-	}
-	resultCh := make(chan result, 1)
-	go func() {
-		statuses, err := service.ValidateMany(context.Background(), trackerIDs[:])
-		resultCh <- result{statuses: statuses, err: err}
-	}()
-
-	seen := make(map[string]bool, len(trackerIDs))
-	firstEntered := ""
-	for range maxConcurrentValidations {
-		select {
-		case trackerID := <-entered:
-			seen[trackerID] = true
-			if firstEntered == "" {
-				firstEntered = trackerID
-			}
-		case <-time.After(2 * time.Second):
-			t.Fatal("concurrent tracker validations did not reach the limit")
-		}
-	}
-	select {
-	case trackerID := <-entered:
-		t.Fatalf("expected only %d concurrent validations, but %s also entered", maxConcurrentValidations, trackerID)
-	case <-time.After(100 * time.Millisecond):
-	}
-
-	releaseValidation(firstEntered)
-	select {
-	case trackerID := <-entered:
-		seen[trackerID] = true
-	case <-time.After(2 * time.Second):
-		t.Fatal("queued tracker validation did not enter after a slot was released")
-	}
-	for _, trackerID := range trackerIDs {
-		releaseValidation(trackerID)
-	}
-
-	var got result
-	select {
-	case got = <-resultCh:
-	case <-time.After(10 * time.Second):
-		t.Fatal("ValidateMany did not return after all validations were released")
-	}
-	if got.err != nil {
-		t.Fatalf("ValidateMany: %v", got.err)
-	}
-	if len(seen) != len(trackerIDs) {
-		t.Fatalf("expected all tracker validations to start, got %#v", seen)
-	}
-	if len(got.statuses) != len(trackerIDs) {
-		t.Fatalf("expected input-ordered statuses, got %#v", got.statuses)
-	}
-	for i, trackerID := range trackerIDs {
-		if got.statuses[i].TrackerID != trackerID || got.statuses[i].State != StateConfigured {
-			t.Fatalf("expected successful input-ordered status for %s, got %#v", trackerID, got.statuses[i])
-		}
-	}
-}
-
-func newTrackerAuthTestDB(t *testing.T) string {
-	t.Helper()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	_ = repo.Close()
-	return dbPath
-}
-
-// trackerAuthLegacyCookiePathByExt selects the concrete legacy candidate path
-// for auth-status tests that seed malformed cookie files by format.
-func trackerAuthLegacyCookiePathByExt(t *testing.T, dbPath string, trackerID string, ext string) string {
-	t.Helper()
-
-	for _, candidate := range commonhttp.CookiePathCandidates(dbPath, trackerID, ".txt", ".json") {
-		if filepath.Ext(candidate) == ext {
-			return candidate
-		}
-	}
-	t.Fatalf("expected %s legacy cookie path", ext)
-	return ""
-}
-
-func saveTrackerAuthTestConfig(t *testing.T, dbPath string, cfg config.Config) {
-	t.Helper()
-
-	repo, err := servicedb.OpenWithLoggerContext(context.Background(), dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	defer repo.Close()
-	if err := config.SaveToDatabase(context.Background(), &cfg, repo); err != nil {
-		t.Fatalf("SaveToDatabase: %v", err)
-	}
-}
-
-func loadStoredTrackerConfig(t *testing.T, dbPath string) config.Config {
-	t.Helper()
-
-	repo, err := servicedb.OpenWithLoggerContext(context.Background(), dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	defer repo.Close()
-	cfg, err := config.LoadFromDatabase(context.Background(), repo)
-	if err != nil {
-		t.Fatalf("LoadFromDatabase: %v", err)
-	}
-	return *cfg
-}
-
-func newMTVManual2FAServer(t *testing.T) *httptest.Server {
-	t.Helper()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			_, _ = w.Write([]byte("<html>logged out</html>"))
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
-		case "/twofactor/login":
-			_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-	return server
-}
-
-func newBTNManual2FAServer(t *testing.T) *httptest.Server {
-	t.Helper()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/upload.php":
-			_, _ = w.Write([]byte(`<form action="/login.php"><input type="password" name="password"></form>`))
-		case "/login.php":
-			_, _ = w.Write([]byte(`<form><input name="codenumber" value=""></form><p>2FA required</p>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-	return server
-}
-
-func newPTPManual2FAServer(t *testing.T) *httptest.Server {
-	t.Helper()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
-	}))
-	t.Cleanup(server.Close)
-	return server
-}
diff --git a/internal/trackerauth/site_validators.go b/internal/trackerauth/site_validators.go
deleted file mode 100644
index 6cf0c4df..00000000
--- a/internal/trackerauth/site_validators.go
+++ /dev/null
@@ -1,594 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerauth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"regexp"
-	"strings"
-	"time"
-
-	"golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/internal/trackers/impl/thr"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	arDefaultBaseURL  = "https://alpharatio.cc"
-	authPreviewBytes  = 64 * 1024
-	authResponseBytes = 1 * 1024 * 1024
-	arIndexPath       = "/index.php"
-	arLoginPath       = "/login.php"
-	ffDefaultBaseURL  = "https://www.funfile.org"
-	ffLoginPath       = "/takelogin.php"
-	ffUploadPath      = "/upload.php"
-	flDefaultBaseURL  = "https://filelist.io"
-	flIndexPath       = "/index.php"
-	flLoginPagePath   = "/login.php"
-	flLoginPath       = "/takelogin.php"
-	hdbDefaultBaseURL = "https://hdbits.org"
-	hdbUploadPath     = "/upload/upload"
-)
-
-// flValidatorPattern extracts the anti-CSRF validator required by FL login.
-var flValidatorPattern = regexp.MustCompile(`name="validator"\s+value="([^"]+)"`)
-
-// resolveARSessionForTrackerAuth verifies imported AR cookies against the
-// post-login index page and refreshes missing or confirmed-invalid sessions with
-// configured credentials. Transport and unexpected HTTP failures preserve
-// stored cookies and do not trigger credential login.
-func resolveARSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
-	baseURL := resolveAuthBaseURL(cfg, arDefaultBaseURL)
-	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "AR", "alpharatio.cc")
-	switch {
-	case err == nil && len(values) > 0:
-		validationErr := validateARStoredCookies(ctx, baseURL, values)
-		if validationErr == nil {
-			return nil
-		}
-		if !shouldRefreshStoredCookiesWithCredentials(validationErr) {
-			return validationErr
-		}
-		if !hasLoginCredentials(cfg) {
-			return validationErr
-		}
-	case err != nil && !errors.Is(err, cookies.ErrTrackerCookiesNotFound):
-		return &AuthRequiredError{TrackerID: "AR", Reason: "cookies unavailable", Err: cookieLoadError("AR", err)}
-	case !hasLoginCredentials(cfg):
-		return &AuthRequiredError{TrackerID: "AR", Reason: "cookies missing", Err: cookieLoadError("AR", err)}
-	}
-
-	return loginARForTrackerAuth(ctx, cfg, dbPath, baseURL)
-}
-
-func validateARStoredCookies(ctx context.Context, baseURL string, values []*http.Cookie) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, joinAuthURL(baseURL, arIndexPath), nil)
-	if err != nil {
-		return fmt.Errorf("trackers: AR session validation request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, values)
-
-	resp, err := noRedirectHTTPClient().Do(req)
-	if err != nil {
-		return &ValidationError{TrackerID: "AR", Transient: true, Reason: "remote validation unavailable", Err: fmt.Errorf("trackers: AR session validation request: %w", err)}
-	}
-	defer resp.Body.Close()
-	body, readErr := readTrackerAuthResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300)
-	if readErr != nil {
-		return &ValidationError{TrackerID: "AR", Transient: true, Reason: "remote validation unavailable", Err: readErr}
-	}
-	if isLoginRedirect(resp) || resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || arLooksLoggedOut(string(body)) {
-		return &ValidationError{TrackerID: "AR", ConfirmedInvalid: true, Reason: "stored session expired", Err: fmt.Errorf("trackers: AR session validation failed status=%d", resp.StatusCode)}
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return &ValidationError{TrackerID: "AR", Transient: true, Reason: "remote validation failed", Err: fmt.Errorf("trackers: AR session validation failed status=%d", resp.StatusCode)}
-	}
-	if !arLooksLoggedIn(string(body)) {
-		return &ValidationError{TrackerID: "AR", ConfirmedInvalid: true, Reason: "stored session expired", Err: errors.New("trackers: AR logout marker not found")}
-	}
-	return nil
-}
-
-// loginARForTrackerAuth creates a clean AR session, proves it against the
-// post-login index page, and persists only the validated replacement cookies.
-func loginARForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return fmt.Errorf("trackers: AR create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	data := url.Values{}
-	data.Set("username", strings.TrimSpace(cfg.Username))
-	data.Set("password", strings.TrimSpace(cfg.Password))
-	data.Set("keeplogged", "1")
-	data.Set("login", "Login")
-	loginReq, err := http.NewRequestWithContext(ctx, http.MethodPost, joinAuthURL(baseURL, arLoginPath), strings.NewReader(data.Encode()))
-	if err != nil {
-		return fmt.Errorf("trackers: AR login request build: %w", err)
-	}
-	loginReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	loginReq.Header.Set("User-Agent", "upbrr")
-	loginResp, err := client.Do(loginReq)
-	if err != nil {
-		return &ValidationError{TrackerID: "AR", Transient: true, Reason: "remote login unavailable", Err: fmt.Errorf("trackers: AR login request: %w", err)}
-	}
-	defer loginResp.Body.Close()
-	body, readErr := readTrackerAuthResponseBody(loginResp, loginResp.StatusCode >= 200 && loginResp.StatusCode < 400)
-	if readErr != nil {
-		return &ValidationError{TrackerID: "AR", Transient: true, Reason: "remote login unavailable", Err: readErr}
-	}
-	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 || arLooksLoggedOut(string(body)) {
-		return &ValidationError{TrackerID: "AR", ConfirmedInvalid: true, Reason: "login failed", Err: fmt.Errorf("trackers: AR login failed status=%d", loginResp.StatusCode)}
-	}
-
-	base, err := url.Parse(strings.TrimRight(baseURL, "/") + "/")
-	if err != nil {
-		return fmt.Errorf("trackers: AR parse base URL: %w", err)
-	}
-	loginCookies := jar.Cookies(base)
-	if len(usableHTTPCookies(loginCookies)) == 0 {
-		return &ValidationError{TrackerID: "AR", ConfirmedInvalid: true, Reason: "login failed", Err: errors.New("trackers: AR login returned no usable cookies")}
-	}
-	if validationErr := validateARStoredCookies(ctx, baseURL, loginCookies); validationErr != nil {
-		return validationErr
-	}
-	if err := persistHTTPCookies(ctx, dbPath, "AR", loginCookies); err != nil {
-		return err
-	}
-	return nil
-}
-
-// resolveFFSessionForTrackerAuth verifies stored FF cookies against the upload
-// page, or logs in with configured credentials and persists returned cookies.
-func resolveFFSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
-	baseURL := resolveAuthBaseURL(cfg, ffDefaultBaseURL)
-	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FF", "www.funfile.org")
-	if err == nil && len(values) > 0 {
-		validationErr := validateFFStoredCookies(ctx, baseURL, values)
-		if validationErr == nil {
-			return nil
-		}
-		if !shouldRefreshStoredCookiesWithCredentials(validationErr) || !hasLoginCredentials(cfg) {
-			return validationErr
-		}
-	}
-	if !hasLoginCredentials(cfg) {
-		return &AuthRequiredError{TrackerID: "FF", Reason: "cookies or username/password missing", Err: cookieLoadError("FF", err)}
-	}
-	return loginFFForTrackerAuth(ctx, cfg, dbPath, baseURL)
-}
-
-// validateFFStoredCookies checks imported FF cookies without mutating storage.
-// Login pages and missing logged-in markers are confirmed invalid; transport
-// and unexpected HTTP failures are transient.
-func validateFFStoredCookies(ctx context.Context, baseURL string, values []*http.Cookie) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, joinAuthURL(baseURL, ffUploadPath), nil)
-	if err != nil {
-		return fmt.Errorf("trackers: FF session validation request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, values)
-
-	resp, err := noRedirectHTTPClient().Do(req)
-	if err != nil {
-		return &ValidationError{TrackerID: "FF", Transient: true, Reason: "remote validation unavailable", Err: fmt.Errorf("trackers: FF session validation request: %w", err)}
-	}
-	defer resp.Body.Close()
-	body, readErr := readTrackerAuthResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300)
-	if readErr != nil {
-		return &ValidationError{TrackerID: "FF", Transient: true, Reason: "remote validation unavailable", Err: readErr}
-	}
-	if isLoginRedirect(resp) || resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || ffLooksLoggedOut(string(body)) {
-		return &ValidationError{TrackerID: "FF", ConfirmedInvalid: true, Reason: "stored session expired", Err: fmt.Errorf("trackers: FF session validation failed status=%d", resp.StatusCode)}
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return &ValidationError{TrackerID: "FF", Transient: true, Reason: "remote validation failed", Err: fmt.Errorf("trackers: FF session validation failed status=%d", resp.StatusCode)}
-	}
-	if !ffLooksLoggedIn(string(body)) {
-		return &ValidationError{TrackerID: "FF", ConfirmedInvalid: true, Reason: "stored session expired", Err: errors.New("trackers: FF login marker not found")}
-	}
-	return nil
-}
-
-// loginFFForTrackerAuth performs the FF credential login flow, verifies the
-// returned cookies against the upload page, then persists them.
-func loginFFForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
-	data := url.Values{}
-	data.Set("returnto", "/index.php")
-	data.Set("username", strings.TrimSpace(cfg.Username))
-	data.Set("password", strings.TrimSpace(cfg.Password))
-	data.Set("login", "Login")
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, joinAuthURL(baseURL, ffLoginPath), strings.NewReader(data.Encode()))
-	if err != nil {
-		return fmt.Errorf("trackers: FF login request build: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", "upbrr")
-	resp, err := noRedirectHTTPClient().Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: FF login request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusFound {
-		return &ValidationError{TrackerID: "FF", ConfirmedInvalid: true, Reason: "login failed", Err: fmt.Errorf("trackers: FF login failed status=%d", resp.StatusCode)}
-	}
-	loginCookies := usableHTTPCookies(resp.Cookies())
-	if len(loginCookies) == 0 {
-		return errors.New("trackers: FF login returned no usable cookies")
-	}
-	if err := validateFFStoredCookies(ctx, baseURL, loginCookies); err != nil {
-		return fmt.Errorf("trackers: FF validate login cookies: %w", err)
-	}
-	if err := persistHTTPCookies(ctx, dbPath, "FF", loginCookies); err != nil {
-		return fmt.Errorf("trackers: FF persist login cookies: %w", err)
-	}
-	return nil
-}
-
-// resolveFLSessionForTrackerAuth verifies stored FL cookies against the index
-// page, or logs in with configured credentials and persists returned cookies.
-func resolveFLSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
-	baseURL := resolveAuthBaseURL(cfg, flDefaultBaseURL)
-	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FL", ".filelist.io")
-	if err == nil && len(values) > 0 {
-		validationErr := validateFLStoredCookies(ctx, baseURL, values)
-		if validationErr == nil {
-			return nil
-		}
-		if !shouldRefreshStoredCookiesWithCredentials(validationErr) || !hasLoginCredentials(cfg) {
-			return validationErr
-		}
-	}
-	if !hasLoginCredentials(cfg) {
-		return &AuthRequiredError{TrackerID: "FL", Reason: "cookies or username/password missing", Err: cookieLoadError("FL", err)}
-	}
-	return loginFLForTrackerAuth(ctx, cfg, dbPath, baseURL)
-}
-
-// validateFLStoredCookies checks imported FL cookies against the index page
-// without mutating storage. Logout text is treated as the logged-in marker.
-func validateFLStoredCookies(ctx context.Context, baseURL string, values []*http.Cookie) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, joinAuthURL(baseURL, flIndexPath), nil)
-	if err != nil {
-		return fmt.Errorf("trackers: FL session validation request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, values)
-
-	resp, err := noRedirectHTTPClient().Do(req)
-	if err != nil {
-		return &ValidationError{TrackerID: "FL", Transient: true, Reason: "remote validation unavailable", Err: fmt.Errorf("trackers: FL session validation request: %w", err)}
-	}
-	defer resp.Body.Close()
-	body, readErr := readTrackerAuthResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300)
-	if readErr != nil {
-		return &ValidationError{TrackerID: "FL", Transient: true, Reason: "remote validation unavailable", Err: readErr}
-	}
-	if isLoginRedirect(resp) || resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || flLooksLoggedOut(string(body)) {
-		return &ValidationError{TrackerID: "FL", ConfirmedInvalid: true, Reason: "stored session expired", Err: fmt.Errorf("trackers: FL session validation failed status=%d", resp.StatusCode)}
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return &ValidationError{TrackerID: "FL", Transient: true, Reason: "remote validation failed", Err: fmt.Errorf("trackers: FL session validation failed status=%d", resp.StatusCode)}
-	}
-	if !flLooksLoggedIn(string(body)) {
-		return &ValidationError{TrackerID: "FL", ConfirmedInvalid: true, Reason: "stored session expired", Err: errors.New("trackers: FL logout marker not found")}
-	}
-	return nil
-}
-
-// loginFLForTrackerAuth fetches FL's login validator, submits credentials, and
-// persists the resulting cookie jar when login succeeds.
-func loginFLForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return fmt.Errorf("trackers: FL create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, joinAuthURL(baseURL, flLoginPagePath), nil)
-	if err != nil {
-		return fmt.Errorf("trackers: FL login page request build: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: FL login page request: %w", err)
-	}
-	body, readErr := readTrackerAuthResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300)
-	resp.Body.Close()
-	if readErr != nil {
-		return fmt.Errorf("trackers: FL read login page response: %w", readErr)
-	}
-	match := flValidatorPattern.FindStringSubmatch(string(body))
-	if len(match) < 2 {
-		return errors.New("trackers: FL validator token not found")
-	}
-	data := url.Values{}
-	data.Set("validator", match[1])
-	data.Set("username", strings.TrimSpace(cfg.Username))
-	data.Set("password", strings.TrimSpace(cfg.Password))
-	data.Set("unlock", "1")
-	loginReq, err := http.NewRequestWithContext(ctx, http.MethodPost, joinAuthURL(baseURL, flLoginPath), strings.NewReader(data.Encode()))
-	if err != nil {
-		return fmt.Errorf("trackers: FL login request build: %w", err)
-	}
-	loginReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	loginResp, err := client.Do(loginReq)
-	if err != nil {
-		return fmt.Errorf("trackers: FL login request: %w", err)
-	}
-	defer loginResp.Body.Close()
-	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 {
-		return &ValidationError{TrackerID: "FL", ConfirmedInvalid: true, Reason: "login failed", Err: fmt.Errorf("trackers: FL login failed status=%d", loginResp.StatusCode)}
-	}
-	base, err := url.Parse(strings.TrimRight(baseURL, "/") + "/")
-	if err != nil {
-		return fmt.Errorf("trackers: FL parse base URL: %w", err)
-	}
-	loginCookies := jar.Cookies(base)
-	if err := validateFLStoredCookies(ctx, baseURL, loginCookies); err != nil {
-		return fmt.Errorf("trackers: FL validate login cookies: %w", err)
-	}
-	if err := persistHTTPCookies(ctx, dbPath, "FL", loginCookies); err != nil {
-		return fmt.Errorf("trackers: FL persist login cookies: %w", err)
-	}
-	return nil
-}
-
-// resolveHDBStoredSessionForTrackerAuth verifies the HDB upload prerequisites:
-// username/passkey config plus imported cookies that can reach the upload page.
-// Confirmed login responses invalidate stored cookies; remote failures remain
-// transient so a temporary tracker outage does not discard auth material.
-func resolveHDBStoredSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Passkey) == "" {
-		return &AuthRequiredError{TrackerID: "HDB", Reason: "username/passkey missing", Err: errors.New("trackers: HDB missing username/passkey")}
-	}
-	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDB", "hdbits.org")
-	if err != nil || len(values) == 0 {
-		return &AuthRequiredError{TrackerID: "HDB", Reason: "cookies missing", Err: cookieLoadError("HDB", err)}
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, joinAuthURL(resolveAuthBaseURL(cfg, hdbDefaultBaseURL), hdbUploadPath), nil)
-	if err != nil {
-		return fmt.Errorf("trackers: HDB session validation request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, values)
-
-	resp, err := noRedirectHTTPClient().Do(req)
-	if err != nil {
-		return &ValidationError{TrackerID: "HDB", Transient: true, Reason: "remote validation unavailable", Err: fmt.Errorf("trackers: HDB session validation request: %w", err)}
-	}
-	defer resp.Body.Close()
-	body, readErr := readTrackerAuthResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300)
-	if readErr != nil {
-		return &ValidationError{TrackerID: "HDB", Transient: true, Reason: "remote validation unavailable", Err: readErr}
-	}
-	if isLoginRedirect(resp) || resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || hdbLooksLoggedOut(string(body)) {
-		return &ValidationError{TrackerID: "HDB", ConfirmedInvalid: true, Reason: "stored session expired", Err: fmt.Errorf("trackers: HDB session validation failed status=%d", resp.StatusCode)}
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return &ValidationError{TrackerID: "HDB", Transient: true, Reason: "remote validation failed", Err: fmt.Errorf("trackers: HDB session validation failed status=%d", resp.StatusCode)}
-	}
-	if !hdbLooksLikeUploadPage(string(body)) {
-		return &ValidationError{TrackerID: "HDB", ConfirmedInvalid: true, Reason: "stored session expired", Err: errors.New("trackers: HDB upload marker not found")}
-	}
-	return nil
-}
-
-// resolveTHRSessionForTrackerAuth validates THR credentials using the same
-// browser-style session bootstrap as uploads. THR logs in per request and does
-// not persist cookies in tracker-auth storage.
-func resolveTHRSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, _ string, _ api.TrackerAuthLoginRequest) error {
-	if !hasLoginCredentials(cfg) {
-		return &AuthRequiredError{TrackerID: "THR", Reason: "username/password missing", Err: errors.New("trackers: THR missing username/password")}
-	}
-	if _, err := thr.LoginSession(ctx, cfg); err != nil {
-		if errors.Is(err, thr.ErrLoginFailed) {
-			return &ValidationError{TrackerID: "THR", ConfirmedInvalid: true, Reason: "login failed", Err: err}
-		}
-		return fmt.Errorf("trackers: THR login session: %w", err)
-	}
-	return nil
-}
-
-// readTrackerAuthResponseBody reads success-candidate auth pages through a
-// 1 MiB plus sentinel and rejects oversized bodies before marker parsing.
-// Failed-status diagnostics are capped at 64 KiB.
-func readTrackerAuthResponseBody(resp *http.Response, successCandidate bool) ([]byte, error) {
-	if successCandidate {
-		body, err := io.ReadAll(io.LimitReader(resp.Body, authResponseBytes+1))
-		if err != nil {
-			return nil, fmt.Errorf("trackers: read auth response body: %w", err)
-		}
-		if len(body) > authResponseBytes {
-			return nil, fmt.Errorf("trackers: auth response body exceeds %d bytes", authResponseBytes)
-		}
-		return body, nil
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, authPreviewBytes))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: read auth response preview: %w", err)
-	}
-	return body, nil
-}
-
-// shouldRefreshStoredCookiesWithCredentials reports whether stored cookies were
-// proven expired, allowing credential login to refresh them.
-func shouldRefreshStoredCookiesWithCredentials(err error) bool {
-	validation, ok := asValidationError(err)
-	return ok && validation.ConfirmedInvalid && !validation.Transient
-}
-
-// persistHTTPCookies saves non-empty login cookies and rejects empty login
-// responses so tracker auth never reports success without durable auth material.
-func persistHTTPCookies(ctx context.Context, dbPath string, trackerID string, values []*http.Cookie) error {
-	valid := usableHTTPCookies(values)
-	if len(valid) == 0 {
-		return fmt.Errorf("trackers: %s login returned no usable cookies", trackerID)
-	}
-	if err := cookies.SaveTrackerHTTPCookies(ctx, dbPath, trackerID, valid); err != nil {
-		return fmt.Errorf("trackers: %s save cookies: %w", trackerID, err)
-	}
-	return nil
-}
-
-// usableHTTPCookies keeps only cookies with non-empty names and values so login
-// flows never persist placeholders as usable auth material.
-func usableHTTPCookies(values []*http.Cookie) []*http.Cookie {
-	valid := make([]*http.Cookie, 0, len(values))
-	for _, cookie := range values {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		valid = append(valid, cookie)
-	}
-	return valid
-}
-
-// cookieLoadError preserves the underlying cookie load failure when available
-// while providing a stable tracker-specific error for empty cookie storage.
-func cookieLoadError(trackerID string, err error) error {
-	if err != nil {
-		return fmt.Errorf("trackers: %s load cookies: %w", trackerID, err)
-	}
-	return fmt.Errorf("trackers: %s cookies not found", trackerID)
-}
-
-// noRedirectHTTPClient exposes login redirects as validation evidence instead
-// of following them and classifying the login page as a successful response.
-func noRedirectHTTPClient() *http.Client {
-	return &http.Client{
-		Timeout: 30 * time.Second,
-		CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
-			return http.ErrUseLastResponse
-		},
-	}
-}
-
-// resolveAuthBaseURL applies a tracker override when configured and otherwise
-// falls back to the site's production base URL.
-func resolveAuthBaseURL(cfg config.TrackerConfig, fallback string) string {
-	if value := strings.TrimRight(strings.TrimSpace(cfg.URL), "/"); value != "" {
-		return value
-	}
-	return fallback
-}
-
-// joinAuthURL resolves site-relative validation paths against tracker base URLs
-// without using path joins that would corrupt URL semantics.
-func joinAuthURL(baseURL string, urlPath string) string {
-	parsed, err := url.Parse(strings.TrimRight(baseURL, "/") + "/")
-	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-		return strings.TrimRight(baseURL, "/") + urlPath
-	}
-	ref, err := url.Parse(strings.TrimLeft(urlPath, "/"))
-	if err != nil {
-		return strings.TrimRight(baseURL, "/") + urlPath
-	}
-	return parsed.ResolveReference(ref).String()
-}
-
-// isLoginRedirect reports redirects whose target path indicates an unauthenticated session.
-func isLoginRedirect(resp *http.Response) bool {
-	if resp == nil || resp.StatusCode < 300 || resp.StatusCode >= 400 {
-		return false
-	}
-	location := strings.ToLower(strings.TrimSpace(resp.Header.Get("Location")))
-	return strings.Contains(location, "login")
-}
-
-// arLooksLoggedOut recognizes AR login/recovery page markers in validation responses.
-func arLooksLoggedOut(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "forgot your password") || strings.Contains(lower, "login.php?act=recover")
-}
-
-// arLooksLoggedIn requires a logout.php anchor with a non-empty auth query.
-// Relative links are accepted; absolute links must use HTTPS on alpharatio.cc.
-func arLooksLoggedIn(body string) bool {
-	tokenizer := html.NewTokenizer(strings.NewReader(body))
-	for {
-		switch tokenizer.Next() {
-		case html.ErrorToken:
-			return false
-		case html.StartTagToken, html.SelfClosingTagToken:
-			token := tokenizer.Token()
-			if !strings.EqualFold(token.Data, "a") {
-				continue
-			}
-			for _, attr := range token.Attr {
-				if !strings.EqualFold(attr.Key, "href") {
-					continue
-				}
-				candidate, err := url.Parse(attr.Val)
-				if err != nil || !strings.EqualFold(strings.TrimPrefix(candidate.Path, "/"), "logout.php") {
-					continue
-				}
-				if candidate.Scheme != "" && !strings.EqualFold(candidate.Scheme, "https") {
-					continue
-				}
-				if candidate.Host != "" && !strings.EqualFold(candidate.Hostname(), "alpharatio.cc") {
-					continue
-				}
-				if strings.TrimSpace(candidate.Query().Get("auth")) == "" {
-					continue
-				}
-				return true
-			}
-		case html.TextToken, html.EndTagToken, html.CommentToken, html.DoctypeToken:
-			continue
-		}
-	}
-}
-
-// hdbLooksLoggedOut recognizes HDB login form markers in validation responses.
-func hdbLooksLoggedOut(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "login.php") || strings.Contains(lower, "name=\"username\"") || strings.Contains(lower, "name=\"password\"")
-}
-
-// hdbLooksLikeUploadPage recognizes concrete HDB upload form structure.
-func hdbLooksLikeUploadPage(body string) bool {
-	lower := strings.ToLower(body)
-	hasUploadAction := strings.Contains(lower, "action=\"/upload/upload") ||
-		strings.Contains(lower, "action='/upload/upload") ||
-		strings.Contains(lower, "action=\"upload/upload") ||
-		strings.Contains(lower, "action='upload/upload")
-	hasUploadField := strings.Contains(lower, "name=\"file\"") ||
-		strings.Contains(lower, "name='file'") ||
-		strings.Contains(lower, "name=\"category\"") ||
-		strings.Contains(lower, "name='category'")
-	return hasUploadAction && hasUploadField
-}
-
-// ffLooksLoggedIn recognizes the FF upload-page marker used by Upload Assistant.
-func ffLooksLoggedIn(body string) bool {
-	return strings.Contains(strings.ToLower(body), "friends.php")
-}
-
-// ffLooksLoggedOut recognizes FF login form markers in validation responses.
-func ffLooksLoggedOut(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "takelogin.php") || strings.Contains(lower, "name=\"username\"") || strings.Contains(lower, "name=\"password\"")
-}
-
-// flLooksLoggedIn recognizes FL's logout marker on authenticated pages.
-func flLooksLoggedIn(body string) bool {
-	return strings.Contains(strings.ToLower(body), "logout")
-}
-
-// flLooksLoggedOut recognizes FL login form markers in validation responses.
-func flLooksLoggedOut(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "login.php") || strings.Contains(lower, "name=\"username\"") || strings.Contains(lower, "name=\"password\"")
-}
diff --git a/internal/trackerauth/site_validators_test.go b/internal/trackerauth/site_validators_test.go
deleted file mode 100644
index ac649344..00000000
--- a/internal/trackerauth/site_validators_test.go
+++ /dev/null
@@ -1,276 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerauth
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestValidateFFStoredCookiesReadsFullSuccessBody(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(strings.Repeat("a", authPreviewBytes+32) + "friends.php"))
-	}))
-	defer server.Close()
-
-	err := validateFFStoredCookies(context.Background(), server.URL, []*http.Cookie{{Name: "session", Value: "ok"}})
-	if err != nil {
-		t.Fatalf("expected marker beyond preview cap to validate session: %v", err)
-	}
-}
-
-func TestResolveARStoredSessionRequiresAuthenticatedLogoutMarker(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		body        string
-		wantInvalid bool
-	}{
-		{
-			name: "authenticated logout link",
-			body: `<a href="https://alpharatio.cc/logout.php?auth=session-key">Logout</a>`,
-		},
-		{
-			name: "relative logout link",
-			body: `<a href="/logout.php?auth=session-key">Logout</a>`,
-		},
-		{
-			name:        "logout link without auth key",
-			body:        `<a href="https://alpharatio.cc/logout.php?auth=">Logout</a>`,
-			wantInvalid: true,
-		},
-		{
-			name:        "logout link without query",
-			body:        `<a href="https://alpharatio.cc/logout.php">Logout</a>`,
-			wantInvalid: true,
-		},
-		{
-			name:        "foreign logout link",
-			body:        `<a href="https://example.invalid/logout.php?auth=session-key">Logout</a>`,
-			wantInvalid: true,
-		},
-		{
-			name:        "protocol-relative foreign logout link",
-			body:        `<a href="//example.invalid/logout.php?auth=session-key">Logout</a>`,
-			wantInvalid: true,
-		},
-		{
-			name:        "arbitrary help page",
-			body:        `<html><h1>Browse help</h1></html>`,
-			wantInvalid: true,
-		},
-		{
-			name:        "unrecognized login page",
-			body:        `<form action="/login.php"><input name="username"><input name="password"></form>`,
-			wantInvalid: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ctx := context.Background()
-			dbPath := newTrackerAuthTestDB(t)
-			if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
-				t.Fatalf("SaveTrackerCookieMap: %v", err)
-			}
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if r.URL.Path != arIndexPath {
-					http.NotFound(w, r)
-					return
-				}
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte(tt.body))
-			}))
-			t.Cleanup(server.Close)
-
-			err := resolveARSessionForTrackerAuth(ctx, config.TrackerConfig{URL: server.URL}, dbPath, api.TrackerAuthLoginRequest{})
-			if !tt.wantInvalid {
-				if err != nil {
-					t.Fatalf("expected authenticated AR index page to validate: %v", err)
-				}
-				return
-			}
-			validationErr, ok := asValidationError(err)
-			if !ok {
-				t.Fatalf("expected validation error, got %v", err)
-			}
-			if !validationErr.ConfirmedInvalid || validationErr.Transient {
-				t.Fatalf("expected missing AR logout marker to invalidate session, got %+v", validationErr)
-			}
-		})
-	}
-}
-
-func TestValidateARStoredCookiesBoundsSuccessfulResponseBody(t *testing.T) {
-	t.Parallel()
-
-	const marker = `<a href="/logout.php?auth=session-key">Logout</a>`
-	tests := []struct {
-		name          string
-		bodySize      int
-		wantTransient bool
-	}{
-		{name: "at limit", bodySize: authResponseBytes},
-		{name: "over limit", bodySize: authResponseBytes + 1, wantTransient: true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			body := marker + strings.Repeat("a", tt.bodySize-len(marker))
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte(body))
-			}))
-			t.Cleanup(server.Close)
-
-			err := validateARStoredCookies(context.Background(), server.URL, []*http.Cookie{{Name: "session", Value: "ok"}})
-			if !tt.wantTransient {
-				if err != nil {
-					t.Fatalf("expected response at size limit to validate: %v", err)
-				}
-				return
-			}
-			validationErr, ok := asValidationError(err)
-			if !ok {
-				t.Fatalf("expected oversized response validation error, got %v", err)
-			}
-			if !validationErr.Transient || validationErr.ConfirmedInvalid {
-				t.Fatalf("expected oversized response to fail transiently, got %+v", validationErr)
-			}
-			if !strings.Contains(validationErr.Error(), "exceeds") {
-				t.Fatalf("expected oversized response error, got %v", validationErr)
-			}
-		})
-	}
-}
-
-func TestValidateFFStoredCookiesTreatsBodyReadErrorAsTransient(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Length", "64")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("friends.php"))
-	}))
-	defer server.Close()
-
-	err := validateFFStoredCookies(context.Background(), server.URL, []*http.Cookie{{Name: "session", Value: "ok"}})
-	validationErr, ok := asValidationError(err)
-	if !ok {
-		t.Fatalf("expected validation error, got %v", err)
-	}
-	if !validationErr.Transient || validationErr.ConfirmedInvalid {
-		t.Fatalf("expected transient read failure, got %+v", validationErr)
-	}
-}
-
-func TestValidateFFStoredCookiesRejectsSuccessStatusWithoutUploadMarker(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("<html>temporarily unavailable</html>"))
-	}))
-	defer server.Close()
-
-	err := validateFFStoredCookies(context.Background(), server.URL, []*http.Cookie{{Name: "session", Value: "ok"}})
-	validationErr, ok := asValidationError(err)
-	if !ok {
-		t.Fatalf("expected validation error, got %v", err)
-	}
-	if !validationErr.ConfirmedInvalid || validationErr.Transient {
-		t.Fatalf("expected missing FF upload marker to invalidate session, got %+v", validationErr)
-	}
-}
-
-func TestValidateFLStoredCookiesRejectsSuccessStatusWithoutLoggedInMarker(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("<html>maintenance page</html>"))
-	}))
-	defer server.Close()
-
-	err := validateFLStoredCookies(context.Background(), server.URL, []*http.Cookie{{Name: "session", Value: "ok"}})
-	validationErr, ok := asValidationError(err)
-	if !ok {
-		t.Fatalf("expected validation error, got %v", err)
-	}
-	if !validationErr.ConfirmedInvalid || validationErr.Transient {
-		t.Fatalf("expected missing FL logged-in marker to invalidate session, got %+v", validationErr)
-	}
-}
-
-func TestValidateHDBStoredCookiesRejectsSuccessStatusWithoutUploadMarker(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "HDB", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != hdbUploadPath {
-			http.NotFound(w, r)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("<html>upload help</html>"))
-	}))
-	defer server.Close()
-
-	err := resolveHDBStoredSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Passkey:  "passkey",
-	}, dbPath, api.TrackerAuthLoginRequest{})
-	validationErr, ok := asValidationError(err)
-	if !ok {
-		t.Fatalf("expected validation error, got %v", err)
-	}
-	if !validationErr.ConfirmedInvalid || validationErr.Transient {
-		t.Fatalf("expected missing HDB upload marker to invalidate session, got %+v", validationErr)
-	}
-}
-
-func TestValidateHDBStoredCookiesAcceptsConcreteUploadMarker(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newTrackerAuthTestDB(t)
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "HDB", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != hdbUploadPath {
-			http.NotFound(w, r)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`<form action="/upload/upload" method="post"><input name="file"><select name="category"></select></form>`))
-	}))
-	defer server.Close()
-
-	err := resolveHDBStoredSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Passkey:  "passkey",
-	}, dbPath, api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("expected HDB upload marker to validate session: %v", err)
-	}
-}
diff --git a/internal/trackerauth/types.go b/internal/trackerauth/types.go
deleted file mode 100644
index 0f676c34..00000000
--- a/internal/trackerauth/types.go
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Package trackerauth manages tracker login, cookie import, session validation,
-// and encrypted auxiliary auth state for tracker implementations.
-package trackerauth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	// SessionStateReady means an adapter returned auth material ready for tracker requests.
-	SessionStateReady = "ready"
-	// SessionStateAuthRequired means no usable session is available without user auth material.
-	SessionStateAuthRequired = "auth_required"
-	// SessionStateNeeds2FA means the auth flow is paused until a manual 2FA code is submitted.
-	SessionStateNeeds2FA = "needs_2fa"
-	// SessionStateUnsupported means the tracker has no supported auth operation for the requested flow.
-	SessionStateUnsupported = "unsupported"
-)
-
-// EnsureRequest describes one tracker auth validation or login attempt.
-type EnsureRequest struct {
-	// TrackerID is the tracker code to validate; comparisons are case-insensitive.
-	TrackerID string
-	// Config supplies credentials, URLs, passkeys, and OTP settings for the tracker.
-	Config config.TrackerConfig
-	// DBPath points at the application database used for encrypted cookie and state storage.
-	DBPath string
-	// AutoLogin allows EnsureSession to attempt credential login after a confirmed invalid stored session.
-	AutoLogin bool
-	// Login carries optional adapter-specific login input, such as a one-time 2FA code.
-	Login api.TrackerAuthLoginRequest
-}
-
-// Session is the normalized result returned by a tracker auth adapter.
-type Session struct {
-	// TrackerID is the normalized tracker code that produced the session.
-	TrackerID string
-	// State reports whether the session is ready, blocked by auth, paused for 2FA, or unsupported.
-	State string
-	// Cookies contains session cookies returned by adapters that expose cookie maps.
-	Cookies map[string]string
-	// Token contains tracker-specific CSRF/auth tokens when an adapter exposes one.
-	Token string
-	// ChallengeID identifies a pending manual 2FA continuation.
-	ChallengeID string
-	// Message contains caller-visible detail about the current auth state.
-	Message string
-}
-
-// Adapter validates and mutates tracker-specific auth material.
-type Adapter interface {
-	// Capability returns static auth support metadata for the tracker.
-	Capability() api.TrackerAuthCapability
-	// Status returns local auth state without forcing a remote login.
-	Status(ctx context.Context, cfg config.TrackerConfig, dbPath string) (api.TrackerAuthStatus, error)
-	// Validate checks whether stored auth material can be used for tracker requests.
-	Validate(ctx context.Context, cfg config.TrackerConfig, dbPath string) (Session, error)
-	// Login attempts credential-based auth and may persist refreshed auth material.
-	Login(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error)
-	// Submit2FA retries auth with manual 2FA input for a service-verified challenge.
-	Submit2FA(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error)
-	// Delete removes persisted auth material owned by the adapter.
-	Delete(ctx context.Context, dbPath string) error
-}
-
-// AuthRequiredError reports that no usable session is available and caller-supplied auth material is required.
-type AuthRequiredError struct {
-	TrackerID string
-	Reason    string
-	Err       error
-}
-
-func (e *AuthRequiredError) Error() string {
-	return trackerAuthError("auth required", e.TrackerID, e.Reason, e.Err)
-}
-
-func (e *AuthRequiredError) Unwrap() error {
-	return e.Err
-}
-
-// Needs2FAError reports that a manual 2FA code is required before auth can continue.
-type Needs2FAError struct {
-	TrackerID string
-	// ChallengeID is set when the caller can continue the flow with Submit2FA.
-	ChallengeID string
-	Reason      string
-	Err         error
-}
-
-func (e *Needs2FAError) Error() string {
-	return trackerAuthError("2FA required", e.TrackerID, e.Reason, e.Err)
-}
-
-func (e *Needs2FAError) Unwrap() error {
-	return e.Err
-}
-
-// UnsupportedAuthError reports that the requested auth operation is not implemented for the tracker.
-type UnsupportedAuthError struct {
-	TrackerID string
-	Reason    string
-	Err       error
-}
-
-func (e *UnsupportedAuthError) Error() string {
-	return trackerAuthError("unsupported auth", e.TrackerID, e.Reason, e.Err)
-}
-
-func (e *UnsupportedAuthError) Unwrap() error {
-	return e.Err
-}
-
-// ValidationError reports a failed remote or local validation check.
-type ValidationError struct {
-	TrackerID string
-	// ConfirmedInvalid means stored auth material is known bad and may be deleted.
-	ConfirmedInvalid bool
-	// Transient means stored auth material should be preserved because the failure may be temporary.
-	Transient bool
-	// Submitted2FARejected means an adapter proved a submitted manual 2FA code reached the tracker and was rejected.
-	Submitted2FARejected bool
-	Reason               string
-	Err                  error
-}
-
-func (e *ValidationError) Error() string {
-	return trackerAuthError("validation failed", e.TrackerID, e.Reason, e.Err)
-}
-
-func (e *ValidationError) Unwrap() error {
-	return e.Err
-}
-
-func trackerAuthError(kind string, trackerID string, reason string, err error) string {
-	parts := []string{"tracker auth"}
-	if trimmed := strings.TrimSpace(trackerID); trimmed != "" {
-		parts = append(parts, strings.ToUpper(trimmed))
-	}
-	parts = append(parts, kind)
-	if trimmed := strings.TrimSpace(reason); trimmed != "" {
-		parts = append(parts, trimmed)
-	}
-	msg := strings.Join(parts, ": ")
-	if err != nil {
-		msg += ": " + err.Error()
-	}
-	return msg
-}
-
-func asValidationError(err error) (*ValidationError, bool) {
-	var validationErr *ValidationError
-	if errors.As(err, &validationErr) {
-		return validationErr, true
-	}
-	return nil, false
-}
-
-func hasLoginCredentials(cfg config.TrackerConfig) bool {
-	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
-}
-
-func normalizeTrackerID(trackerID string) string {
-	trimmed := strings.TrimSpace(trackerID)
-	var builder strings.Builder
-	builder.Grow(len(trimmed))
-	for _, r := range trimmed {
-		if r >= 'a' && r <= 'z' {
-			r -= 'a' - 'A'
-		}
-		builder.WriteRune(r)
-	}
-	return builder.String()
-}
-
-func newUnknownTrackerError(trackerID string) error {
-	return fmt.Errorf("tracker auth: unknown tracker %s", strings.TrimSpace(trackerID))
-}
diff --git a/internal/trackerdata/ant.go b/internal/trackerdata/ant.go
deleted file mode 100644
index 26fab1af..00000000
--- a/internal/trackerdata/ant.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func (c *Client) lookupANT(ctx context.Context, meta api.PreparedMetadata, searchFileName string) (Result, error) {
-	if strings.TrimSpace(meta.DiscType) != "" {
-		return Result{}, nil
-	}
-	cfg, ok := c.trackerCfg("ANT")
-	if !ok || strings.TrimSpace(cfg.APIKey) == "" {
-		return Result{}, nil
-	}
-	fileName := strings.TrimSpace(searchFileName)
-	if fileName == "" {
-		return Result{}, nil
-	}
-
-	params := url.Values{}
-	params.Set("t", "search")
-	params.Set("filename", fileName)
-	params.Set("o", "json")
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.antURL, nil)
-	if err != nil {
-		return Result{}, fmt.Errorf("trackerdata: ant request: %w", err)
-	}
-	req.URL.RawQuery = params.Encode()
-	req.Header.Set("User-Agent", "upbrr")
-	req.Header.Set("X-Api-Key", strings.TrimSpace(cfg.APIKey))
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return Result{}, fmt.Errorf("trackerdata: ant request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return Result{}, nil
-	}
-
-	var decoded struct {
-		Items []map[string]any `json:"item"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
-		return Result{}, fmt.Errorf("trackerdata: ant decode: %w", err)
-	}
-	item := matchANTItem(decoded.Items, fileName)
-	if len(item) == 0 {
-		return Result{}, nil
-	}
-	return Result{TrackerID: "1", IMDBID: imdbFromAny(item["imdb"]), TMDBID: intValue(item["tmdb"])}, nil
-}
-
-func matchANTItem(items []map[string]any, fileName string) map[string]any {
-	if len(items) == 1 {
-		return items[0]
-	}
-	baseName := strings.ToLower(strings.TrimSpace(trimExt(fileName)))
-	for _, item := range items {
-		files, _ := item["files"].([]any)
-		for _, raw := range files {
-			entry := mapValue(raw)
-			name := strings.ToLower(strings.TrimSpace(stringValue(entry["name"])))
-			if name == "" {
-				continue
-			}
-			if strings.EqualFold(name, fileName) {
-				return item
-			}
-			if trimExt(name) == baseName {
-				return item
-			}
-		}
-	}
-	return nil
-}
diff --git a/internal/trackerdata/bhd.go b/internal/trackerdata/bhd.go
deleted file mode 100644
index a99d078c..00000000
--- a/internal/trackerdata/bhd.go
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func (c *Client) lookupBHD(
-	ctx context.Context,
-	trackerID string,
-	meta api.PreparedMetadata,
-	searchFileName string,
-	onlyID bool,
-	keepImages bool,
-) (Result, error) {
-	cfg, ok := c.trackerCfg("BHD")
-	if !ok {
-		return Result{}, nil
-	}
-	apiKey := strings.TrimSpace(cfg.APIKey)
-	rssKey := strings.TrimSpace(cfg.BhdRSSKey)
-	if len(apiKey) < minTokenLength || len(rssKey) < minTokenLength {
-		return Result{}, nil
-	}
-
-	endpoint := strings.TrimRight(c.bhdBaseURL, "/") + "/" + apiKey
-	payload := map[string]any{}
-	if id := strings.TrimSpace(trackerID); id != "" {
-		payload["action"] = "details"
-		payload["torrent_id"] = id
-	} else {
-		payload["action"] = "search"
-		payload["rsskey"] = rssKey
-		hasSearchFilter := false
-		if shouldUseFolderSearch(meta) {
-			payload["folder_name"] = pathutil.Base(meta.SourcePath)
-			hasSearchFilter = true
-		} else if trimmed := strings.TrimSpace(searchFileName); trimmed != "" {
-			payload["file_name"] = trimmed
-			hasSearchFilter = true
-		}
-		if !hasSearchFilter {
-			return Result{}, nil
-		}
-	}
-
-	first, err := c.bhdRequestFirst(ctx, endpoint, payload)
-	if err != nil || len(first) == 0 {
-		return Result{}, err
-	}
-
-	result := Result{
-		TrackerID: trackerID,
-		IMDBID:    imdbFromAny(first["imdb_id"]),
-	}
-	result.Category, result.TMDBID = parseBHDTMDB(first["tmdb_id"])
-	descriptionValue := first["description"]
-	description := ""
-	if stringValue(descriptionValue) == "1" {
-		torrentID := stringValue(first["id"])
-		if torrentID == "" {
-			torrentID = strings.TrimSpace(trackerID)
-		}
-		if torrentID != "" {
-			descMap, derr := c.bhdRequest(ctx, endpoint, map[string]any{
-				"action":     "description",
-				"torrent_id": torrentID,
-			})
-			if derr == nil {
-				description = stringValue(descMap["result"])
-			}
-		}
-	} else {
-		description = stringValue(descriptionValue)
-	}
-
-	if onlyID && !keepImages {
-		return result, nil
-	}
-	report := bbcode.CleanBHDDescription(description, bbcode.BHDOptions{})
-	if !onlyID {
-		result.Description = strings.TrimSpace(report.Description)
-	}
-	if keepImages {
-		result.Images = report.Images
-	}
-	if strings.TrimSpace(result.TrackerID) == "" {
-		result.TrackerID = stringValue(first["id"])
-	}
-	return result, nil
-}
-
-func (c *Client) bhdRequestFirst(ctx context.Context, endpoint string, payload map[string]any) (map[string]any, error) {
-	body, err := c.bhdRequest(ctx, endpoint, payload)
-	if err != nil || len(body) == 0 {
-		return nil, err
-	}
-	if items, ok := body["results"].([]any); ok && len(items) > 0 {
-		return mapValue(items[0]), nil
-	}
-	if item, ok := body["result"].(map[string]any); ok {
-		return item, nil
-	}
-	return nil, nil
-}
-
-func (c *Client) bhdRequest(ctx context.Context, endpoint string, payload map[string]any) (map[string]any, error) {
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: bhd encode request: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(raw))
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: bhd request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: bhd request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, nil
-	}
-	result := map[string]any{}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return nil, fmt.Errorf("trackerdata: bhd decode: %w", err)
-	}
-	if intValue(result["status_code"]) == 0 {
-		return nil, nil
-	}
-	if success, ok := result["success"].(bool); ok && !success {
-		return nil, nil
-	}
-	return result, nil
-}
-
-func parseBHDTMDB(value any) (string, int) {
-	raw := strings.ToLower(strings.TrimSpace(stringValue(value)))
-	if raw == "" || raw == "0" {
-		return "", 0
-	}
-	if after, ok := strings.CutPrefix(raw, "tv/"); ok {
-		return "TV", intValue(after)
-	}
-	if after, ok := strings.CutPrefix(raw, "movie/"); ok {
-		return "MOVIE", intValue(after)
-	}
-	return "", intValue(raw)
-}
diff --git a/internal/trackerdata/btn.go b/internal/trackerdata/btn.go
deleted file mode 100644
index f915526e..00000000
--- a/internal/trackerdata/btn.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"github.com/autobrr/upbrr/internal/config"
-)
-
-func (c *Client) lookupBTN(ctx context.Context, trackerID string) (Result, error) {
-	apiToken := config.ResolveBTNAPIToken(c.cfg)
-	if len(apiToken) < minTokenLength || trackerID == "" {
-		return Result{}, nil
-	}
-
-	payload := map[string]any{
-		"jsonrpc": "2.0",
-		"id":      "ua-go",
-		"method":  "getTorrentsSearch",
-		"params":  []any{apiToken, map[string]any{"id": trackerID}, 50},
-	}
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return Result{}, fmt.Errorf("trackerdata: btn encode request: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.btnURL, bytes.NewReader(body))
-	if err != nil {
-		return Result{}, fmt.Errorf("trackerdata: btn request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return Result{}, fmt.Errorf("trackerdata: btn request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return Result{}, nil
-	}
-
-	var decoded struct {
-		Error  map[string]any `json:"error"`
-		Result struct {
-			Torrents map[string]map[string]any `json:"torrents"`
-		} `json:"result"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
-		return Result{}, fmt.Errorf("trackerdata: btn decode: %w", err)
-	}
-	if len(decoded.Error) > 0 {
-		return Result{}, nil
-	}
-	for _, value := range decoded.Result.Torrents {
-		return Result{
-			TrackerID: trackerID,
-			IMDBID:    intValue(value["ImdbID"]),
-			TVDBID:    intValue(value["TvdbID"]),
-		}, nil
-	}
-	return Result{}, nil
-}
diff --git a/internal/trackerdata/client.go b/internal/trackerdata/client.go
deleted file mode 100644
index b9734146..00000000
--- a/internal/trackerdata/client.go
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const minTokenLength = 25
-
-type Result struct {
-	TrackerID   string
-	InfoHash    string
-	TMDBID      int
-	IMDBID      int
-	TVDBID      int
-	MALID       int
-	Category    string
-	Description string
-	Images      []bbcode.Image
-	Validated   []bbcode.Image
-	FileName    string
-}
-
-func (r Result) HasIDs() bool {
-	return r.TMDBID != 0 || r.IMDBID != 0 || r.TVDBID != 0 || r.MALID != 0
-}
-
-func (r Result) HasData() bool {
-	if r.HasIDs() {
-		return true
-	}
-	if strings.TrimSpace(r.Description) != "" {
-		return true
-	}
-	if len(r.Images) > 0 || len(r.Validated) > 0 {
-		return true
-	}
-	if strings.TrimSpace(r.InfoHash) != "" {
-		return true
-	}
-	if strings.TrimSpace(r.FileName) != "" {
-		return true
-	}
-	if strings.TrimSpace(r.Category) != "" {
-		return true
-	}
-	return false
-}
-
-type Client struct {
-	cfg    config.Config
-	logger api.Logger
-	http   *http.Client
-
-	btnURL     string
-	bhdBaseURL string
-	ptpURL     string
-	hdbURL     string
-	antURL     string
-}
-
-func NewClient(cfg config.Config, logger api.Logger, httpClient *http.Client) *Client {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-	if httpClient == nil {
-		httpClient = &http.Client{Timeout: 30 * time.Second}
-	}
-	return &Client{
-		cfg:        cfg,
-		logger:     logger,
-		http:       httpClient,
-		btnURL:     "https://api.broadcasthe.net/",
-		bhdBaseURL: "https://beyond-hd.me/api/torrents/",
-		ptpURL:     "https://passthepopcorn.me/torrents.php",
-		hdbURL:     "https://hdbits.org/api/torrents",
-		antURL:     "https://anthelion.me/api.php",
-	}
-}
-
-func (c *Client) Lookup(
-	ctx context.Context,
-	tracker string,
-	trackerID string,
-	meta api.PreparedMetadata,
-	searchFileName string,
-	onlyID bool,
-	keepImages bool,
-) (Result, error) {
-	normalized := strings.ToUpper(strings.TrimSpace(tracker))
-	if IsUnit3DTracker(normalized) {
-		return c.lookupUnit3D(ctx, normalized, trackerID, searchFileName, onlyID, keepImages)
-	}
-
-	switch normalized {
-	case "BTN":
-		return c.lookupBTN(ctx, strings.TrimSpace(trackerID))
-	case "BHD":
-		return c.lookupBHD(ctx, trackerID, meta, searchFileName, onlyID, keepImages)
-	case "PTP":
-		return c.lookupPTP(ctx, trackerID, meta, searchFileName, onlyID, keepImages)
-	case "ANT":
-		return c.lookupANT(ctx, meta, searchFileName)
-	case "HDB":
-		return c.lookupHDB(ctx, trackerID, meta, searchFileName, onlyID, keepImages)
-	default:
-		return Result{}, nil
-	}
-}
-
-func (c *Client) trackerCfg(name string) (config.TrackerConfig, bool) {
-	if c.cfg.Trackers.Trackers == nil {
-		return config.TrackerConfig{}, false
-	}
-	if cfg, ok := c.cfg.Trackers.Trackers[name]; ok {
-		return cfg, true
-	}
-	for key, cfg := range c.cfg.Trackers.Trackers {
-		if strings.EqualFold(key, name) {
-			return cfg, true
-		}
-	}
-	return config.TrackerConfig{}, false
-}
-
-func shouldUseFolderSearch(meta api.PreparedMetadata) bool {
-	if strings.TrimSpace(meta.DiscType) != "" {
-		return true
-	}
-	return len(meta.FileList) != 1
-}
-
-func (c *Client) getJSON(ctx context.Context, endpoint string, params url.Values, headers map[string]string) (map[string]any, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: request: %w", err)
-	}
-	req.URL.RawQuery = params.Encode()
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, nil
-	}
-	result := map[string]any{}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return nil, fmt.Errorf("trackerdata: decode: %w", err)
-	}
-	return result, nil
-}
-
-func mapValue(value any) map[string]any {
-	if m, ok := value.(map[string]any); ok {
-		return m
-	}
-	return nil
-}
-
-func intValue(value any) int {
-	switch v := value.(type) {
-	case int:
-		return v
-	case int64:
-		return int(v)
-	case float64:
-		return int(v)
-	case json.Number:
-		i, _ := v.Int64()
-		return int(i)
-	case string:
-		trimmed := strings.TrimSpace(strings.TrimPrefix(v, "tt"))
-		if trimmed == "" {
-			return 0
-		}
-		i, _ := strconv.Atoi(trimmed)
-		return i
-	default:
-		return 0
-	}
-}
-
-func stringValue(value any) string {
-	if value == nil {
-		return ""
-	}
-	switch v := value.(type) {
-	case string:
-		return strings.TrimSpace(v)
-	default:
-		return strings.TrimSpace(fmt.Sprint(v))
-	}
-}
-
-func trimExt(value string) string {
-	trimmed := strings.TrimSpace(value)
-	ext := filepath.Ext(trimmed)
-	return strings.TrimSuffix(strings.ToLower(trimmed), strings.ToLower(ext))
-}
-
-func imdbFromAny(value any) int {
-	raw := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(stringValue(value))), "tt")
-	return intValue(raw)
-}
diff --git a/internal/trackerdata/client_test.go b/internal/trackerdata/client_test.go
deleted file mode 100644
index a43477bb..00000000
--- a/internal/trackerdata/client_test.go
+++ /dev/null
@@ -1,586 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type rewriteHostTransport struct {
-	base *url.URL
-	rt   http.RoundTripper
-}
-
-func (t rewriteHostTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	clone := req.Clone(req.Context())
-	clone.URL.Scheme = t.base.Scheme
-	clone.URL.Host = t.base.Host
-	clone.Host = t.base.Host
-	resp, err := t.rt.RoundTrip(clone)
-	if err != nil {
-		return resp, fmt.Errorf("rewrite host round trip: %w", err)
-	}
-	return resp, nil
-}
-
-func TestLookupBTN(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/btn" {
-			http.NotFound(w, r)
-			return
-		}
-		_ = json.NewEncoder(w).Encode(map[string]any{
-			"result": map[string]any{
-				"torrents": map[string]any{
-					"1": map[string]any{"ImdbID": 1234567, "TvdbID": 76543},
-				},
-			},
-		})
-	}))
-	defer server.Close()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BTN": {APIKey: strings.Repeat("a", 30)},
-		}},
-	}
-	client := NewClient(cfg, api.NopLogger{}, server.Client())
-	client.btnURL = server.URL + "/btn"
-
-	result, err := client.Lookup(context.Background(), "BTN", "42", api.PreparedMetadata{}, "", true, false)
-	if err != nil {
-		t.Fatalf("lookup failed: %v", err)
-	}
-	if result.IMDBID != 1234567 || result.TVDBID != 76543 {
-		t.Fatalf("unexpected result: %+v", result)
-	}
-}
-
-func TestLookupBHD(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if !strings.HasPrefix(r.URL.Path, "/bhd/") {
-			http.NotFound(w, r)
-			return
-		}
-		_ = json.NewEncoder(w).Encode(map[string]any{
-			"status_code": 1,
-			"success":     true,
-			"results": []any{
-				map[string]any{
-					"id":          "99",
-					"name":        "Example.Release",
-					"imdb_id":     "tt1234567",
-					"tmdb_id":     "movie/765",
-					"description": "hello\n[url=https://pixhost.to/full/example][img]https://pixhost.to/example.png[/img][/url]",
-				},
-			},
-		})
-	}))
-	defer server.Close()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BHD": {APIKey: strings.Repeat("a", 30), BhdRSSKey: strings.Repeat("b", 30)},
-		}},
-	}
-	client := NewClient(cfg, api.NopLogger{}, server.Client())
-	client.bhdBaseURL = server.URL + "/bhd"
-
-	result, err := client.Lookup(context.Background(), "BHD", "", api.PreparedMetadata{SourcePath: "/tmp/release"}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("lookup failed: %v", err)
-	}
-	if result.TrackerID != "99" || result.IMDBID != 1234567 || result.TMDBID != 765 || result.Category != "MOVIE" {
-		t.Fatalf("unexpected ids: %+v", result)
-	}
-	if result.Description != "hello" {
-		t.Fatalf("unexpected description: %q", result.Description)
-	}
-	if len(result.Images) != 1 {
-		t.Fatalf("expected image extraction, got %d", len(result.Images))
-	}
-	if result.Images[0].ImgURL != "https://pixhost.to/example.png" {
-		t.Fatalf("unexpected image data: %+v", result.Images[0])
-	}
-}
-
-func TestLookupPTPAndHDB(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/ptp":
-			switch {
-			case r.URL.Query().Get("torrentid") != "":
-				_ = json.NewEncoder(w).Encode(map[string]any{
-					"ImdbId": "1122334",
-					"Torrents": []any{
-						map[string]any{"Id": "777", "InfoHash": "abc123"},
-					},
-				})
-			case r.URL.Query().Get("action") == "get_description":
-				_, _ = w.Write([]byte("Desc\nhttps://pixhost.to/abc.png"))
-			default:
-				http.NotFound(w, r)
-			}
-		case "/hdb":
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"status": 0,
-				"data": []any{
-					map[string]any{
-						"id":    "321",
-						"hash":  "deadbeef",
-						"imdb":  map[string]any{"id": "998877"},
-						"tvdb":  map[string]any{"id": "5544"},
-						"descr": "Text\n[url=https://imgbox.com/abc][img]https://thumbs2.imgbox.com/abc_t.png[/img][/url]",
-					},
-				},
-			})
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"PTP": {PTPAPIUser: "user", PTPAPIKey: "key"},
-			"HDB": {Username: "user", Passkey: "pass"},
-		}},
-	}
-	client := NewClient(cfg, api.NopLogger{}, server.Client())
-	client.ptpURL = server.URL + "/ptp"
-	client.hdbURL = server.URL + "/hdb"
-
-	ptpResult, err := client.Lookup(context.Background(), "PTP", "777", api.PreparedMetadata{}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("ptp lookup failed: %v", err)
-	}
-	if ptpResult.IMDBID != 1122334 || ptpResult.TrackerID != "777" || ptpResult.InfoHash != "abc123" {
-		t.Fatalf("unexpected ptp result: %+v", ptpResult)
-	}
-	if ptpResult.Description != "Desc" || len(ptpResult.Images) != 1 {
-		t.Fatalf("unexpected ptp description/images: %+v", ptpResult)
-	}
-
-	hdbResult, err := client.Lookup(context.Background(), "HDB", "321", api.PreparedMetadata{}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("hdb lookup failed: %v", err)
-	}
-	if hdbResult.IMDBID != 998877 || hdbResult.TVDBID != 5544 || hdbResult.InfoHash != "deadbeef" {
-		t.Fatalf("unexpected hdb ids: %+v", hdbResult)
-	}
-	if hdbResult.Description != "Text" || len(hdbResult.Images) != 1 {
-		t.Fatalf("unexpected hdb description/images: %+v", hdbResult)
-	}
-}
-
-func TestLookupANTSendsAPIKeyHeader(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		query := r.URL.Query()
-		if got := query.Get("apikey"); got != "" {
-			t.Error("apikey should not be sent as a query parameter")
-			return
-		}
-		if got := query.Get("t"); got != "search" {
-			t.Errorf("unexpected t query value: got %q want %q", got, "search")
-			return
-		}
-		if got := query.Get("filename"); got != "Example.Release.mkv" {
-			t.Errorf("unexpected filename query value: got %q", got)
-			return
-		}
-		if got := r.Header.Get("X-Api-Key"); got != "token" {
-			t.Error("unexpected X-API-Key header")
-			return
-		}
-		if got := r.Header.Get("User-Agent"); got == "" {
-			t.Error("expected User-Agent header")
-			return
-		}
-		_ = json.NewEncoder(w).Encode(map[string]any{
-			"item": []map[string]any{
-				{"imdb": "tt1234567", "tmdb": 765},
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := NewClient(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"ANT": {APIKey: "token"},
-		}},
-	}, api.NopLogger{}, server.Client())
-	client.antURL = server.URL
-
-	result, err := client.Lookup(context.Background(), "ANT", "", api.PreparedMetadata{}, "Example.Release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("ant lookup failed: %v", err)
-	}
-	if result.IMDBID != 1234567 || result.TMDBID != 765 {
-		t.Fatalf("unexpected ant result: %+v", result)
-	}
-}
-
-func TestLookupUnit3DOnlyIDKeepsImages(t *testing.T) {
-	t.Parallel()
-
-	pngBytes := []byte{
-		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
-		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
-		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
-		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
-		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
-		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
-		0x44, 0xae, 0x42, 0x60, 0x82,
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
-			imageURL := "http://93.184.216.34/images/shot.png"
-			description := "[url=https://example.com/view][img]" + imageURL + "[/img][/url]"
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"attributes": map[string]any{
-					"tmdb_id":     100,
-					"description": description,
-				},
-			})
-		case r.URL.Path == "/images/shot.png":
-			w.Header().Set("Content-Type", "image/png")
-			_, _ = w.Write(pngBytes)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	baseURL, err := url.Parse(server.URL)
-	if err != nil {
-		t.Fatalf("parse server url: %v", err)
-	}
-
-	httpClient := server.Client()
-	transport := httpClient.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
-
-	client := NewClient(config.Config{}, api.NopLogger{}, httpClient)
-
-	result, err := client.Lookup(context.Background(), "BLU", "777", api.PreparedMetadata{}, "release.mkv", true, true)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if result.TMDBID != 100 {
-		t.Fatalf("expected tmdb id, got %+v", result)
-	}
-	if result.Description != "" {
-		t.Fatalf("expected onlyID to clear description, got %q", result.Description)
-	}
-	if len(result.Images) != 1 {
-		t.Fatalf("expected keepImages to retain images with onlyID=true, got %d", len(result.Images))
-	}
-}
-
-func TestLookupUnit3DRejectsLinkedPrivateRawURLBeforeFetch(t *testing.T) {
-	t.Parallel()
-
-	var privateRequests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
-			description := "[url=http://127.0.0.1/private.png][img]http://93.184.216.34/thumb.png[/img][/url]"
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"attributes": map[string]any{
-					"tmdb_id":     100,
-					"description": description,
-				},
-			})
-		case r.URL.Path == "/private.png":
-			privateRequests.Add(1)
-			http.Error(w, "private image should not be fetched", http.StatusInternalServerError)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	baseURL, err := url.Parse(server.URL)
-	if err != nil {
-		t.Fatalf("parse server url: %v", err)
-	}
-
-	httpClient := server.Client()
-	transport := httpClient.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
-
-	client := NewClient(config.Config{}, api.NopLogger{}, httpClient)
-	result, err := client.Lookup(context.Background(), "BLU", "777", api.PreparedMetadata{}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if len(result.Images) != 0 || len(result.Validated) != 0 {
-		t.Fatalf("expected private linked image to be rejected, got images=%+v validated=%+v", result.Images, result.Validated)
-	}
-	if got := privateRequests.Load(); got != 0 {
-		t.Fatalf("expected private raw URL not to be fetched, got %d request(s)", got)
-	}
-}
-
-func TestLookupUnit3DAllowsPublicLinkedRawURL(t *testing.T) {
-	t.Parallel()
-
-	pngBytes := []byte{
-		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
-		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
-		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
-		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
-		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
-		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
-		0x44, 0xae, 0x42, 0x60, 0x82,
-	}
-
-	var fullRequests atomic.Int32
-	var thumbRequests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
-			description := "[url=http://93.184.216.34/images/full.png][img]http://93.184.216.34/images/thumb.png[/img][/url]"
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"attributes": map[string]any{
-					"tmdb_id":     100,
-					"description": description,
-				},
-			})
-		case r.URL.Path == "/images/full.png":
-			fullRequests.Add(1)
-			w.Header().Set("Content-Type", "image/png")
-			_, _ = w.Write(pngBytes)
-		case r.URL.Path == "/images/thumb.png":
-			thumbRequests.Add(1)
-			http.Error(w, "thumbnail should not be validated when linked full-size URL is public", http.StatusInternalServerError)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	baseURL, err := url.Parse(server.URL)
-	if err != nil {
-		t.Fatalf("parse server url: %v", err)
-	}
-
-	httpClient := server.Client()
-	transport := httpClient.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
-
-	client := NewClient(config.Config{}, api.NopLogger{}, httpClient)
-	result, err := client.Lookup(context.Background(), "BLU", "777", api.PreparedMetadata{}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if len(result.Images) != 1 || len(result.Validated) != 1 {
-		t.Fatalf("expected public linked image to validate, got images=%+v validated=%+v", result.Images, result.Validated)
-	}
-	if got := result.Images[0].RawURL; got != "http://93.184.216.34/images/full.png" {
-		t.Fatalf("expected linked full-size raw URL, got %q", got)
-	}
-	if got := result.Images[0].ImgURL; got != "http://93.184.216.34/images/thumb.png" {
-		t.Fatalf("expected thumbnail image URL preserved, got %q", got)
-	}
-	if got := fullRequests.Load(); got != 1 {
-		t.Fatalf("expected one public full-size fetch, got %d", got)
-	}
-	if got := thumbRequests.Load(); got != 0 {
-		t.Fatalf("expected thumbnail not to be fetched, got %d request(s)", got)
-	}
-}
-
-func TestLookupUnit3DDescriptionFlagsGateDescriptionAndImages(t *testing.T) {
-	t.Parallel()
-
-	pngBytes := []byte{
-		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
-		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
-		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
-		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
-		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
-		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
-		0x44, 0xae, 0x42, 0x60, 0x82,
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
-			imageURL := "http://93.184.216.34/images/shot.png"
-			description := "[center]Fetched tracker body[/center]\n\n[center][url=https://example.com/view][img]" + imageURL + "[/img][/url][/center]"
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"attributes": map[string]any{
-					"tmdb_id":     100,
-					"description": description,
-				},
-			})
-		case r.URL.Path == "/images/shot.png":
-			w.Header().Set("Content-Type", "image/png")
-			_, _ = w.Write(pngBytes)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	baseURL, err := url.Parse(server.URL)
-	if err != nil {
-		t.Fatalf("parse server url: %v", err)
-	}
-
-	httpClient := server.Client()
-	transport := httpClient.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
-
-	client := NewClient(config.Config{}, api.NopLogger{}, httpClient)
-	ctx := context.Background()
-
-	result, err := client.Lookup(ctx, "BLU", "777", api.PreparedMetadata{}, "release.mkv", false, false)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if result.Description != "[center]Fetched tracker body[/center]" {
-		t.Fatalf("expected cleaned description when onlyID=false, got %q", result.Description)
-	}
-	if len(result.Images) != 0 {
-		t.Fatalf("expected keepImages=false to skip images, got %d", len(result.Images))
-	}
-
-	result, err = client.Lookup(ctx, "BLU", "777", api.PreparedMetadata{}, "release.mkv", true, false)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if result.Description != "" {
-		t.Fatalf("expected onlyID=true to clear description, got %q", result.Description)
-	}
-	if len(result.Images) != 0 {
-		t.Fatalf("expected keepImages=false to skip images with onlyID=true, got %d", len(result.Images))
-	}
-
-	result, err = client.Lookup(ctx, "BLU", "777", api.PreparedMetadata{}, "release.mkv", false, true)
-	if err != nil {
-		t.Fatalf("unit3d lookup failed: %v", err)
-	}
-	if result.Description != "[center]Fetched tracker body[/center]" {
-		t.Fatalf("expected cleaned description with keepImages=true, got %q", result.Description)
-	}
-	if len(result.Images) != 1 {
-		t.Fatalf("expected keepImages=true to retain images, got %d", len(result.Images))
-	}
-}
-
-func TestLookupHDBSkipsUnfilteredSearch(t *testing.T) {
-	t.Parallel()
-
-	requested := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requested = true
-		http.Error(w, "unexpected request", http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	client := NewClient(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"HDB": {Username: "user", Passkey: "pass"},
-		}},
-	}, api.NopLogger{}, server.Client())
-	client.hdbURL = server.URL + "/hdb"
-
-	result, err := client.Lookup(
-		context.Background(),
-		"HDB",
-		"",
-		api.PreparedMetadata{SourcePath: `D:\TV\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`, FileList: []string{"Example.Show.S04E01.2160p.WEB.h265-GRP.mkv"}},
-		"",
-		false,
-		true,
-	)
-	if err != nil {
-		t.Fatalf("hdb lookup failed: %v", err)
-	}
-	if result.HasData() {
-		t.Fatalf("expected empty result for unfiltered HDB lookup, got %+v", result)
-	}
-	if requested {
-		t.Fatalf("expected HDB lookup to skip request without id or filename")
-	}
-}
-
-func TestLookupBHDSkipsUnfilteredSearch(t *testing.T) {
-	t.Parallel()
-
-	requested := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requested = true
-		http.Error(w, "unexpected request", http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	token := strings.Repeat("a", minTokenLength)
-	client := NewClient(config.Config{
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"BHD": {APIKey: token, BhdRSSKey: token},
-		}},
-	}, api.NopLogger{}, server.Client())
-	client.bhdBaseURL = server.URL + "/api/torrents"
-
-	result, err := client.Lookup(
-		context.Background(),
-		"BHD",
-		"",
-		api.PreparedMetadata{SourcePath: `D:\TV\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`, FileList: []string{"Example.Show.S04E01.2160p.WEB.h265-GRP.mkv"}},
-		"",
-		false,
-		true,
-	)
-	if err != nil {
-		t.Fatalf("bhd lookup failed: %v", err)
-	}
-	if result.HasData() {
-		t.Fatalf("expected empty result for unfiltered BHD lookup, got %+v", result)
-	}
-	if requested {
-		t.Fatalf("expected BHD lookup to skip request without id or filename")
-	}
-}
diff --git a/internal/trackerdata/hdb.go b/internal/trackerdata/hdb.go
deleted file mode 100644
index 52d68fd0..00000000
--- a/internal/trackerdata/hdb.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func (c *Client) lookupHDB(
-	ctx context.Context,
-	trackerID string,
-	meta api.PreparedMetadata,
-	searchFileName string,
-	onlyID bool,
-	keepImages bool,
-) (Result, error) {
-	cfg, ok := c.trackerCfg("HDB")
-	if !ok {
-		return Result{}, nil
-	}
-	username := strings.TrimSpace(cfg.Username)
-	passkey := strings.TrimSpace(cfg.Passkey)
-	if username == "" || passkey == "" {
-		return Result{}, nil
-	}
-
-	payload := map[string]any{"username": username, "passkey": passkey}
-	if id := strings.TrimSpace(trackerID); id != "" {
-		payload["id"] = id
-	} else {
-		payload["limit"] = 100
-		hasSearchFilter := false
-		if shouldUseFolderSearch(meta) {
-			payload["search"] = pathutil.Base(meta.SourcePath)
-			hasSearchFilter = true
-		} else if strings.TrimSpace(searchFileName) != "" {
-			payload["file_in_torrent"] = searchFileName
-			hasSearchFilter = true
-		}
-		if !hasSearchFilter {
-			return Result{}, nil
-		}
-	}
-
-	first, err := c.hdbRequestFirst(ctx, payload)
-	if err != nil || len(first) == 0 {
-		return Result{}, err
-	}
-
-	result := Result{
-		TrackerID: stringValue(first["id"]),
-		IMDBID:    nestedInt(first, "imdb", "id"),
-		TVDBID:    nestedInt(first, "tvdb", "id"),
-		InfoHash:  stringValue(first["hash"]),
-	}
-	if result.TrackerID == "" {
-		result.TrackerID = strings.TrimSpace(trackerID)
-	}
-	if onlyID && !keepImages {
-		return result, nil
-	}
-
-	report := bbcode.CleanHDBDescription(stringValue(first["descr"]))
-	if !onlyID {
-		result.Description = strings.TrimSpace(report.Description)
-	}
-	if keepImages {
-		result.Images = report.Images
-	}
-	return result, nil
-}
-
-func (c *Client) hdbRequestFirst(ctx context.Context, payload map[string]any) (map[string]any, error) {
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: hdb encode request: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.hdbURL, bytes.NewReader(raw))
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: hdb request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackerdata: hdb request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, nil
-	}
-
-	result := map[string]any{}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return nil, fmt.Errorf("trackerdata: hdb decode: %w", err)
-	}
-	if intValue(result["status"]) != 0 {
-		return nil, nil
-	}
-	items, ok := result["data"].([]any)
-	if !ok || len(items) == 0 {
-		return nil, nil
-	}
-	return mapValue(items[0]), nil
-}
-
-func nestedInt(value map[string]any, root string, key string) int {
-	node := mapValue(value[root])
-	return intValue(node[key])
-}
diff --git a/internal/trackerdata/ptp.go b/internal/trackerdata/ptp.go
deleted file mode 100644
index a8b2fb82..00000000
--- a/internal/trackerdata/ptp.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type ptpLookup struct {
-	trackerID string
-	imdbID    int
-	infoHash  string
-}
-
-func (c *Client) lookupPTP(
-	ctx context.Context,
-	trackerID string,
-	meta api.PreparedMetadata,
-	searchFileName string,
-	onlyID bool,
-	keepImages bool,
-) (Result, error) {
-	cfg, ok := c.trackerCfg("PTP")
-	if !ok {
-		return Result{}, nil
-	}
-	apiUser := strings.TrimSpace(cfg.PTPAPIUser)
-	apiKey := strings.TrimSpace(cfg.PTPAPIKey)
-	if apiUser == "" || apiKey == "" {
-		return Result{}, nil
-	}
-	headers := map[string]string{"ApiUser": apiUser, "ApiKey": apiKey}
-
-	foundID := strings.TrimSpace(trackerID)
-	var lookup ptpLookup
-
-	if foundID != "" {
-		var err error
-		lookup, err = c.ptpFetchByID(ctx, headers, foundID)
-		if err != nil {
-			return Result{}, err
-		}
-	} else {
-		var err error
-		lookup, err = c.ptpSearch(ctx, headers, searchFileName)
-		if err != nil {
-			return Result{}, err
-		}
-		foundID = lookup.trackerID
-	}
-	imdbID := lookup.imdbID
-	infoHash := lookup.infoHash
-	if imdbID == 0 && strings.TrimSpace(foundID) == "" {
-		return Result{}, nil
-	}
-
-	result := Result{TrackerID: foundID, IMDBID: imdbID, InfoHash: infoHash}
-	if strings.TrimSpace(foundID) == "" || (onlyID && !keepImages) {
-		return result, nil
-	}
-
-	description, err := c.ptpDescription(ctx, headers, foundID)
-	if err != nil {
-		return result, err
-	}
-	report := bbcode.CleanPTPDescription(description, meta.DiscType)
-	if !onlyID {
-		result.Description = strings.TrimSpace(report.Description)
-	}
-	if keepImages {
-		result.Images = report.Images
-	}
-	return result, nil
-}
-
-func (c *Client) ptpFetchByID(ctx context.Context, headers map[string]string, trackerID string) (ptpLookup, error) {
-	params := url.Values{}
-	params.Set("torrentid", trackerID)
-	body, err := c.getJSON(ctx, c.ptpURL, params, headers)
-	if err != nil || len(body) == 0 {
-		return ptpLookup{}, err
-	}
-	return parsePTPResponse(body, trackerID, "")
-}
-
-func (c *Client) ptpSearch(ctx context.Context, headers map[string]string, search string) (ptpLookup, error) {
-	if strings.TrimSpace(search) == "" {
-		return ptpLookup{}, nil
-	}
-	params := url.Values{}
-	params.Set("searchstr", search)
-	body, err := c.getJSON(ctx, c.ptpURL, params, headers)
-	if err != nil || len(body) == 0 {
-		return ptpLookup{}, err
-	}
-	return parsePTPSearchResponse(body, search)
-}
-
-func (c *Client) ptpDescription(ctx context.Context, headers map[string]string, trackerID string) (string, error) {
-	params := url.Values{}
-	params.Set("id", trackerID)
-	params.Set("action", "get_description")
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.ptpURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("trackerdata: ptp description request: %w", err)
-	}
-	req.URL.RawQuery = params.Encode()
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("trackerdata: ptp description request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return "", nil
-	}
-	payload, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("trackerdata: ptp description read: %w", err)
-	}
-	return string(payload), nil
-}
-
-func parsePTPResponse(body map[string]any, trackerID string, searchTerm string) (ptpLookup, error) {
-	imdbID := intValue(body["ImdbId"])
-	torrents, _ := body["Torrents"].([]any)
-	selectedID := strings.TrimSpace(trackerID)
-	infoHash := ""
-	needle := strings.ToLower(strings.TrimSpace(searchTerm))
-	for _, torrent := range torrents {
-		item := mapValue(torrent)
-		id := stringValue(item["Id"])
-		releaseName := strings.ToLower(stringValue(item["ReleaseName"]))
-		if selectedID == "" && needle != "" && strings.Contains(releaseName, needle) {
-			selectedID = id
-			infoHash = stringValue(item["InfoHash"])
-			break
-		}
-		if selectedID != "" && selectedID == id {
-			infoHash = stringValue(item["InfoHash"])
-			break
-		}
-		if selectedID == "" {
-			selectedID = id
-			infoHash = stringValue(item["InfoHash"])
-		}
-	}
-	return ptpLookup{trackerID: selectedID, imdbID: imdbID, infoHash: infoHash}, nil
-}
-
-func parsePTPSearchResponse(body map[string]any, searchTerm string) (ptpLookup, error) {
-	movies, _ := body["Movies"].([]any)
-	for _, movie := range movies {
-		item := mapValue(movie)
-		imdbID := intValue(item["ImdbId"])
-		lookup, err := parsePTPResponse(item, "", searchTerm)
-		if err != nil {
-			return ptpLookup{}, err
-		}
-		if imdbID != 0 {
-			lookup.imdbID = imdbID
-		}
-		if lookup.imdbID != 0 || lookup.trackerID != "" {
-			return lookup, nil
-		}
-	}
-	return ptpLookup{}, nil
-}
diff --git a/internal/trackerdata/unit3d.go b/internal/trackerdata/unit3d.go
deleted file mode 100644
index fdb0dffa..00000000
--- a/internal/trackerdata/unit3d.go
+++ /dev/null
@@ -1,998 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackerdata
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"image"
-	_ "image/gif"  // register GIF decoder for tracker images
-	_ "image/jpeg" // register JPEG decoder for tracker images
-	_ "image/png"  // register PNG decoder for tracker images
-	"io"
-	"net"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"path" //nolint:depguard // Builds Unit3D API URL paths, not local filesystem paths.
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	imageTimeout     = 15 * time.Second
-	maxImageBytes    = 20 * 1024 * 1024
-	imageConcurrency = 5
-)
-
-var unit3DImageBlockedIPRanges = []netip.Prefix{
-	netip.MustParsePrefix("0.0.0.0/8"),
-	netip.MustParsePrefix("100.64.0.0/10"),
-	netip.MustParsePrefix("192.0.0.0/24"),
-	netip.MustParsePrefix("192.0.2.0/24"),
-	netip.MustParsePrefix("198.18.0.0/15"),
-	netip.MustParsePrefix("198.51.100.0/24"),
-	netip.MustParsePrefix("203.0.113.0/24"),
-	netip.MustParsePrefix("240.0.0.0/4"),
-	netip.MustParsePrefix("2001:db8::/32"),
-	netip.MustParsePrefix("fc00::/7"),
-	netip.MustParsePrefix("fe80::/10"),
-}
-
-var unit3DCategoryNamesByID = map[string][]string{
-	"1": {"MOVIE"},
-	"2": {"TV"},
-}
-
-var unit3DTypeNamesByID = map[string][]string{
-	"1": {"DISC"},
-	"2": {"REMUX"},
-	"3": {"ENCODE", "DVDRIP"},
-	"4": {"WEBDL"},
-	"5": {"WEBRIP"},
-	"6": {"HDTV"},
-}
-
-var unit3DResolutionNamesByID = map[string][]string{
-	"10": {"8640P"},
-	"1":  {"4320P"},
-	"2":  {"2160P"},
-	"3":  {"1080P", "1440P"},
-	"4":  {"1080I"},
-	"5":  {"720P"},
-	"6":  {"576P"},
-	"7":  {"576I"},
-	"8":  {"480P"},
-	"9":  {"480I"},
-}
-
-func IsUnit3DTracker(tracker string) bool {
-	return trackers.IsUnit3DTracker(tracker)
-}
-
-func IsUnit3DTrackerWithConfig(cfg config.Config, tracker string) bool {
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	if key == "" {
-		return false
-	}
-	if IsUnit3DTracker(key) {
-		return true
-	}
-	if trackers.IsKnownTracker(key) {
-		return false
-	}
-	entry, ok := cfg.Trackers.Trackers[key]
-	if !ok {
-		for name, candidate := range cfg.Trackers.Trackers {
-			if strings.EqualFold(name, key) {
-				entry = candidate
-				ok = true
-				break
-			}
-		}
-	}
-	if !ok {
-		return false
-	}
-	if strings.TrimSpace(entry.APIKey) == "" {
-		return false
-	}
-	if strings.TrimSpace(entry.AnnounceURL) == "" {
-		return false
-	}
-	if strings.TrimSpace(entry.Username) != "" || strings.TrimSpace(entry.Password) != "" || strings.TrimSpace(entry.Passkey) != "" {
-		return false
-	}
-	if strings.TrimSpace(entry.PTPAPIUser) != "" || strings.TrimSpace(entry.PTPAPIKey) != "" {
-		return false
-	}
-	return true
-}
-
-func CategoryID(category string) string {
-	return reverseLookupCanonicalID(CanonicalUnit3DCategory(category), unit3DCategoryNamesByID)
-}
-
-func TypeID(typeValue string) string {
-	return reverseLookupCanonicalID(CanonicalUnit3DType(typeValue), unit3DTypeNamesByID)
-}
-
-func ResolutionID(value string) string {
-	return reverseLookupCanonicalID(CanonicalUnit3DResolution(value), unit3DResolutionNamesByID)
-}
-
-func CategoryName(id string) string {
-	return firstCanonicalValue(CategoryNames(id))
-}
-
-func CategoryNames(id string) []string {
-	return copyCanonicalValues(unit3DCategoryNamesByID[strings.TrimSpace(id)])
-}
-
-func TypeName(id string) string {
-	return firstCanonicalValue(TypeNames(id))
-}
-
-func TypeNames(id string) []string {
-	return copyCanonicalValues(unit3DTypeNamesByID[strings.TrimSpace(id)])
-}
-
-func ResolutionName(id string) string {
-	return firstCanonicalValue(ResolutionNames(id))
-}
-
-func ResolutionNames(id string) []string {
-	return copyCanonicalValues(unit3DResolutionNamesByID[strings.TrimSpace(id)])
-}
-
-func CanonicalUnit3DCategory(value string) string {
-	switch normalizeUnit3DLookupKey(value) {
-	case "MOVIE", "FILM":
-		return "MOVIE"
-	case "TV", "TELEVISION", "SHOW", "SERIES", "TVSHOW", "EPISODE":
-		return "TV"
-	default:
-		return ""
-	}
-}
-
-func CanonicalUnit3DType(value string) string {
-	switch normalizeUnit3DLookupKey(value) {
-	case "DISC":
-		return "DISC"
-	case "REMUX":
-		return "REMUX"
-	case "ENCODE":
-		return "ENCODE"
-	case "DVDRIP":
-		return "DVDRIP"
-	case "WEBDL":
-		return "WEBDL"
-	case "WEBRIP":
-		return "WEBRIP"
-	case "HDTV", "UHDTV":
-		return "HDTV"
-	default:
-		return ""
-	}
-}
-
-func CanonicalUnit3DResolution(value string) string {
-	switch normalizeUnit3DLookupKey(value) {
-	case "8640P":
-		return "8640P"
-	case "4320P":
-		return "4320P"
-	case "2160P":
-		return "2160P"
-	case "1440P":
-		return "1440P"
-	case "1080P":
-		return "1080P"
-	case "1080I":
-		return "1080I"
-	case "720P":
-		return "720P"
-	case "576P":
-		return "576P"
-	case "576I":
-		return "576I"
-	case "480P":
-		return "480P"
-	case "480I":
-		return "480I"
-	default:
-		return ""
-	}
-}
-
-func normalizeUnit3DLookupKey(value string) string {
-	return strings.NewReplacer("-", "", "_", "", " ", "").Replace(strings.ToUpper(strings.TrimSpace(value)))
-}
-
-func reverseLookupCanonicalID(canonical string, namesByID map[string][]string) string {
-	if canonical == "" {
-		return ""
-	}
-	for id, names := range namesByID {
-		if slices.Contains(names, canonical) {
-			return id
-		}
-	}
-	return ""
-}
-
-func firstCanonicalValue(values []string) string {
-	if len(values) == 0 {
-		return ""
-	}
-	return values[0]
-}
-
-func copyCanonicalValues(values []string) []string {
-	if len(values) == 0 {
-		return nil
-	}
-	return append([]string{}, values...)
-}
-
-func TrackerAPIKey(cfg config.Config, tracker string) string {
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	if key == "" {
-		return ""
-	}
-	if entry, ok := cfg.Trackers.Trackers[key]; ok {
-		return strings.TrimSpace(entry.APIKey)
-	}
-	if entry, ok := cfg.Trackers.Trackers[strings.ToLower(key)]; ok {
-		return strings.TrimSpace(entry.APIKey)
-	}
-	for name, entry := range cfg.Trackers.Trackers {
-		if strings.EqualFold(name, key) {
-			return strings.TrimSpace(entry.APIKey)
-		}
-	}
-	return ""
-}
-
-func (c *Client) TorrentInfo(ctx context.Context, tracker string, id string, fileName string, onlyID bool, keepImages bool) (Result, error) {
-	return c.lookupUnit3D(ctx, tracker, id, fileName, onlyID, keepImages)
-}
-
-func (c *Client) lookupUnit3D(ctx context.Context, tracker string, id string, fileName string, onlyID bool, keepImages bool) (Result, error) {
-	baseURL, ok := baseURLForTracker(tracker)
-	if !ok {
-		return Result{}, fmt.Errorf("unit3d: unknown tracker %q", tracker)
-	}
-
-	apiKey := strings.TrimSpace(TrackerAPIKey(c.cfg, tracker))
-	params := url.Values{}
-	if apiKey == "" {
-		c.logger.Debugf("unit3d: %s missing API key; request will be unauthenticated", tracker)
-	}
-
-	var endpoint string
-	switch {
-	case strings.TrimSpace(id) != "":
-		endpoint = baseURL + "/api/torrents/" + strings.TrimSpace(id)
-	case strings.TrimSpace(fileName) != "":
-		endpoint = baseURL + "/api/torrents/filter"
-		params.Set("file_name", fileName)
-	default:
-		return Result{}, nil
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return Result{}, fmt.Errorf("unit3d: request: %w", err)
-	}
-	if len(params) > 0 {
-		req.URL.RawQuery = params.Encode()
-	}
-	SetUnit3DAPIHeaders(req, apiKey)
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return Result{}, fmt.Errorf("unit3d: request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		c.logger.Debugf("unit3d: %s request failed (status=%d id=%q file=%q)", tracker, resp.StatusCode, strings.TrimSpace(id), strings.TrimSpace(fileName))
-		return Result{}, nil
-	}
-
-	var payload unit3dResponse
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return Result{}, fmt.Errorf("unit3d: decode: %w", err)
-	}
-	attrs := payload.extractAttributes(strings.TrimSpace(id) != "")
-	if attrs == nil {
-		c.logger.Debugf("unit3d: %s response contained no attributes (id=%q file=%q)", tracker, strings.TrimSpace(id), strings.TrimSpace(fileName))
-		return Result{}, nil
-	}
-
-	result := Result{
-		TrackerID: strings.TrimSpace(id),
-		TMDBID:    attrs.tmdbID,
-		IMDBID:    attrs.imdbID,
-		TVDBID:    attrs.tvdbID,
-		MALID:     attrs.malID,
-		Category:  strings.TrimSpace(attrs.category),
-		InfoHash:  strings.TrimSpace(attrs.infoHash),
-		FileName:  attrs.fileName,
-	}
-
-	description := strings.TrimSpace(attrs.description)
-	if description == "" {
-		return result, nil
-	}
-	reports := make([]descriptionunit3d.Report, 0, 2)
-	cleaned := ""
-	if !onlyID {
-		report := descriptionunit3d.CleanDescriptionBody(description, baseURL)
-		reports = append(reports, report)
-		cleaned = report.Description
-	}
-	images := []bbcode.Image(nil)
-	if keepImages {
-		report := descriptionunit3d.CleanDescriptionImages(description, baseURL)
-		reports = append(reports, report)
-		images = convertCleanedUnit3DImages(report.Images)
-	}
-	cleanedLen := len(cleaned)
-	imageCount := len(images)
-	validated := []bbcode.Image(nil)
-	if keepImages {
-		validated = validateImages(ctx, c.http, images)
-		images = validated
-	} else {
-		images = nil
-	}
-	result.Description = cleaned
-	result.Images = images
-	result.Validated = validated
-	c.logger.Debugf("unit3d: %s description raw=%d cleaned=%d images=%d validated=%d onlyID=%t keepImages=%t", tracker, len(description), cleanedLen, imageCount, len(validated), onlyID, keepImages)
-	for _, report := range reports {
-		for _, note := range report.Notes {
-			c.logger.Debugf("unit3d: %s description note kind=%s msg=%s", tracker, note.Kind, note.Message)
-		}
-	}
-
-	return result, nil
-}
-
-func convertCleanedUnit3DImages(images []descriptionunit3d.Image) []bbcode.Image {
-	if len(images) == 0 {
-		return nil
-	}
-	converted := make([]bbcode.Image, 0, len(images))
-	for _, image := range images {
-		converted = append(converted, bbcode.Image{
-			ImgURL: image.ImgURL,
-			RawURL: image.RawURL,
-			WebURL: image.WebURL,
-			Host:   image.Host,
-		})
-	}
-	return converted
-}
-
-func (c *Client) SearchTorrents(ctx context.Context, tracker string, params url.Values, isDisc bool) ([]api.DupeEntry, string, error) {
-	baseURL, ok := baseURLForTrackerWithConfig(c.cfg, tracker)
-	if !ok {
-		return nil, "", fmt.Errorf("unit3d: unknown tracker %q", tracker)
-	}
-
-	apiKey := strings.TrimSpace(TrackerAPIKey(c.cfg, tracker))
-	if apiKey == "" && c.logger != nil {
-		c.logger.Debugf("unit3d: %s missing API key; request will be unauthenticated", tracker)
-	}
-
-	endpoints := []unit3dSearchEndpoint{{
-		url: strings.TrimRight(baseURL, "/") + path.Join("/", "api", "torrents", "filter"),
-	}}
-	if usesUnit3DPendingSearch(tracker) {
-		tmdbID, _ := strconv.Atoi(strings.TrimSpace(params.Get("tmdbId")))
-		endpoints = append(endpoints, unit3dSearchEndpoint{
-			url:           strings.TrimRight(baseURL, "/") + path.Join("/", "api", "torrents", "pending"),
-			pending:       true,
-			filterTMDBID:  tmdbID,
-			pendingWebURL: strings.TrimRight(baseURL, "/") + "/torrents/pending",
-		})
-	}
-
-	var entries []api.DupeEntry
-	for _, endpoint := range endpoints {
-		endpointEntries, warning, err := c.searchUnit3DEndpoint(ctx, tracker, endpoint, params, apiKey, isDisc)
-		if err != nil {
-			return nil, "", err
-		}
-		if warning != "" {
-			return entries, warning, nil
-		}
-		entries = append(entries, endpointEntries...)
-	}
-
-	return entries, "", nil
-}
-
-func (c *Client) searchUnit3DEndpoint(ctx context.Context, tracker string, endpoint unit3dSearchEndpoint, params url.Values, apiKey string, isDisc bool) ([]api.DupeEntry, string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint.url, nil)
-	if err != nil {
-		return nil, "", fmt.Errorf("unit3d: request: %w", err)
-	}
-	if len(params) > 0 {
-		req.URL.RawQuery = params.Encode()
-	}
-	SetUnit3DAPIHeaders(req, apiKey)
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, "", fmt.Errorf("unit3d: request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		if c.logger != nil {
-			c.logger.Warnf("unit3d: %s search failed (status=%d)", tracker, resp.StatusCode)
-		}
-		return nil, fmt.Sprintf("%s search failed (status=%d)", strings.ToUpper(strings.TrimSpace(tracker)), resp.StatusCode), nil
-	}
-
-	if endpoint.pending {
-		var payload unit3dPendingSearchResponse
-		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-			return nil, "", fmt.Errorf("unit3d: decode: %w", err)
-		}
-		return buildUnit3DPendingEntries(payload.Data, endpoint, isDisc), "", nil
-	}
-
-	var payload unit3dSearchResponse
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return nil, "", fmt.Errorf("unit3d: decode: %w", err)
-	}
-	return buildUnit3DSearchEntries(payload.Data, isDisc), "", nil
-}
-
-// SetUnit3DAPIHeaders applies the authentication and response format expected
-// by every Unit3D API request.
-func SetUnit3DAPIHeaders(req *http.Request, apiKey string) {
-	if req == nil {
-		return
-	}
-	req.Header.Set("Accept", "application/json")
-	if apiKey = strings.TrimSpace(apiKey); apiKey != "" {
-		req.Header.Set("Authorization", "Bearer "+apiKey)
-	}
-}
-
-func buildUnit3DSearchEntries(items []unit3dSearchItem, isDisc bool) []api.DupeEntry {
-	entries := make([]api.DupeEntry, 0, len(items))
-	for _, item := range items {
-		entry := api.DupeEntry{
-			Name:        strings.TrimSpace(item.Attributes.Name),
-			Trumpable:   item.Attributes.Trumpable,
-			Link:        strings.TrimSpace(item.Attributes.DetailsLink),
-			Download:    strings.TrimSpace(item.Attributes.DownloadLink),
-			ID:          strings.TrimSpace(item.ID.String()),
-			Type:        strings.TrimSpace(item.Attributes.Type),
-			Res:         strings.TrimSpace(item.Attributes.Resolution),
-			Internal:    item.Attributes.Internal,
-			BDInfo:      strings.TrimSpace(item.Attributes.BDInfo),
-			Description: strings.TrimSpace(item.Attributes.Description),
-			Flags:       append([]string{}, item.Attributes.Flags...),
-		}
-
-		if sizeValue, err := parseNumberToInt64(item.Attributes.Size); err == nil {
-			entry.SizeBytes = sizeValue
-			entry.SizeKnown = sizeValue > 0
-		} else if raw := strings.TrimSpace(item.Attributes.Size.String()); raw != "" {
-			entry.SizeText = raw
-		}
-
-		if len(item.Attributes.Files) > 0 {
-			entry.FileCount = len(item.Attributes.Files)
-			if !isDisc {
-				entry.Files = make([]string, 0, len(item.Attributes.Files))
-				for _, file := range item.Attributes.Files {
-					trimmed := strings.TrimSpace(file.Name)
-					if trimmed != "" {
-						entry.Files = append(entry.Files, trimmed)
-					}
-				}
-			}
-		}
-
-		entries = append(entries, entry)
-	}
-
-	return entries
-}
-
-func buildUnit3DPendingEntries(items []unit3dPendingSearchItem, endpoint unit3dSearchEndpoint, isDisc bool) []api.DupeEntry {
-	entries := make([]api.DupeEntry, 0, len(items))
-	for _, item := range items {
-		if endpoint.filterTMDBID > 0 && item.TMDBID != endpoint.filterTMDBID {
-			continue
-		}
-
-		entry := api.DupeEntry{
-			Name:        strings.TrimSpace(item.Name),
-			Trumpable:   item.Trumpable,
-			Link:        endpoint.pendingWebURL,
-			Download:    strings.TrimSpace(item.DownloadLink),
-			ID:          strings.TrimSpace(item.ID.String()),
-			Type:        strings.TrimSpace(item.Type),
-			Res:         strings.TrimSpace(item.Resolution),
-			Internal:    item.Internal,
-			BDInfo:      strings.TrimSpace(item.BDInfo),
-			Description: strings.TrimSpace(item.Description),
-			Flags:       append([]string{}, item.Flags...),
-		}
-
-		if sizeValue, err := parseNumberToInt64(item.Size); err == nil {
-			entry.SizeBytes = sizeValue
-			entry.SizeKnown = sizeValue > 0
-		} else if raw := strings.TrimSpace(item.Size.String()); raw != "" {
-			entry.SizeText = raw
-		}
-
-		if len(item.Files) > 0 {
-			entry.FileCount = len(item.Files)
-			if !isDisc {
-				entry.Files = make([]string, 0, len(item.Files))
-				for _, file := range item.Files {
-					trimmed := strings.TrimSpace(file.Name)
-					if trimmed != "" {
-						entry.Files = append(entry.Files, trimmed)
-					}
-				}
-			}
-		}
-
-		entries = append(entries, entry)
-	}
-
-	return entries
-}
-
-func usesUnit3DPendingSearch(tracker string) bool {
-	return strings.EqualFold(tracker, "CBR")
-}
-
-func validateImages(ctx context.Context, client *http.Client, images []bbcode.Image) []bbcode.Image {
-	if len(images) == 0 {
-		return nil
-	}
-	client = Unit3DImageHTTPClient(client)
-
-	results := make([]bbcode.Image, len(images))
-	valid := make([]bool, len(images))
-	sem := make(chan struct{}, imageConcurrency)
-	var wg sync.WaitGroup
-
-	for idx, img := range images {
-		wg.Go(func() {
-			sem <- struct{}{}
-			defer func() { <-sem }()
-			if checkImage(ctx, client, img.RawURL) {
-				results[idx] = img
-				valid[idx] = true
-			}
-		})
-	}
-	wg.Wait()
-
-	filtered := make([]bbcode.Image, 0, len(images))
-	for idx, ok := range valid {
-		if ok {
-			filtered = append(filtered, results[idx])
-		}
-	}
-	return filtered
-}
-
-func checkImage(ctx context.Context, client *http.Client, rawURL string) bool {
-	trimmed := strings.TrimSpace(rawURL)
-	if trimmed == "" {
-		return false
-	}
-	if err := ValidateUnit3DImageURL(ctx, trimmed); err != nil {
-		return false
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, trimmed, nil)
-	if err != nil {
-		return false
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return false
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return false
-	}
-	if resp.ContentLength > 0 && resp.ContentLength > maxImageBytes {
-		return false
-	}
-	contentType := strings.ToLower(resp.Header.Get("Content-Type"))
-	if contentType != "" && !strings.Contains(contentType, "image") {
-		return false
-	}
-	limited := io.LimitReader(resp.Body, maxImageBytes)
-	if _, _, err := image.DecodeConfig(limited); err != nil {
-		return false
-	}
-	return true
-}
-
-// Unit3DImageHTTPClient returns a clone that rejects non-public image redirects and,
-// for standard transports, dials only public target IPs.
-func Unit3DImageHTTPClient(client *http.Client) *http.Client {
-	if client == nil {
-		client = &http.Client{Timeout: imageTimeout}
-	}
-	cloned := *client
-	if cloned.Timeout == 0 {
-		cloned.Timeout = imageTimeout
-	}
-	if transport, ok := unit3DImagePublicTransport(cloned.Transport); ok {
-		cloned.Transport = transport
-	}
-	checkRedirect := cloned.CheckRedirect
-	cloned.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-		if err := ValidateUnit3DImageURL(req.Context(), req.URL.String()); err != nil {
-			return err
-		}
-		if checkRedirect != nil {
-			return checkRedirect(req, via)
-		}
-		if len(via) >= 10 {
-			return errors.New("stopped after 10 redirects")
-		}
-		return nil
-	}
-	return &cloned
-}
-
-func unit3DImagePublicTransport(rt http.RoundTripper) (http.RoundTripper, bool) {
-	var transport *http.Transport
-	switch typed := rt.(type) {
-	case nil:
-		defaultTransport, ok := http.DefaultTransport.(*http.Transport)
-		if !ok {
-			return rt, false
-		}
-		transport = defaultTransport.Clone()
-	case *http.Transport:
-		transport = typed.Clone()
-	default:
-		return rt, false
-	}
-
-	originalDial := transport.DialContext
-	dialer := &net.Dialer{Timeout: imageTimeout}
-	transport.DialContext = func(ctx context.Context, network string, address string) (net.Conn, error) {
-		host, port, err := net.SplitHostPort(address)
-		if err != nil {
-			return nil, fmt.Errorf("parse address: %w", err)
-		}
-		addrs, err := resolveUnit3DImagePublicAddrs(ctx, host)
-		if err != nil {
-			return nil, err
-		}
-		var lastErr error
-		for _, addr := range addrs {
-			target := net.JoinHostPort(addr.String(), port)
-			var conn net.Conn
-			if originalDial != nil {
-				conn, err = originalDial(ctx, network, target)
-			} else {
-				conn, err = dialer.DialContext(ctx, network, target)
-			}
-			if err == nil {
-				return conn, nil
-			}
-			lastErr = err
-		}
-		return nil, lastErr
-	}
-	return transport, true
-}
-
-// ValidateUnit3DImageURL rejects non-HTTP(S) or non-public Unit3D image targets.
-func ValidateUnit3DImageURL(ctx context.Context, rawURL string) error {
-	parsed, err := url.Parse(strings.TrimSpace(rawURL))
-	if err != nil {
-		return fmt.Errorf("parse url: %w", err)
-	}
-	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
-	if scheme != "http" && scheme != "https" {
-		return fmt.Errorf("unsupported scheme %q", parsed.Scheme)
-	}
-	host := strings.TrimSpace(parsed.Hostname())
-	if host == "" {
-		return errors.New("missing host")
-	}
-	_, err = resolveUnit3DImagePublicAddrs(ctx, host)
-	return err
-}
-
-func resolveUnit3DImagePublicAddrs(ctx context.Context, host string) ([]netip.Addr, error) {
-	host = strings.Trim(strings.TrimSpace(host), "[]")
-	if host == "" {
-		return nil, errors.New("missing host")
-	}
-	lowerHost := strings.ToLower(host)
-	if lowerHost == "localhost" || strings.HasSuffix(lowerHost, ".localhost") || strings.Contains(lowerHost, "%") {
-		return nil, fmt.Errorf("blocked private image host %q", host)
-	}
-	if addr, err := netip.ParseAddr(host); err == nil {
-		addr = addr.Unmap()
-		if !isUnit3DImagePublicIP(addr) {
-			return nil, fmt.Errorf("blocked private image address %q", addr)
-		}
-		return []netip.Addr{addr}, nil
-	}
-
-	resolved, err := net.DefaultResolver.LookupIPAddr(ctx, host)
-	if err != nil {
-		return nil, fmt.Errorf("resolve host %q: %w", host, err)
-	}
-	addrs := make([]netip.Addr, 0, len(resolved))
-	for _, item := range resolved {
-		addr, ok := netip.AddrFromSlice(item.IP)
-		if !ok {
-			continue
-		}
-		addr = addr.Unmap()
-		if !isUnit3DImagePublicIP(addr) {
-			return nil, fmt.Errorf("blocked private image address %q", addr)
-		}
-		addrs = append(addrs, addr)
-	}
-	if len(addrs) == 0 {
-		return nil, fmt.Errorf("host %q resolved no public addresses", host)
-	}
-	return addrs, nil
-}
-
-func isUnit3DImagePublicIP(addr netip.Addr) bool {
-	addr = addr.Unmap()
-	if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() || addr.IsUnspecified() {
-		return false
-	}
-	for _, blocked := range unit3DImageBlockedIPRanges {
-		if blocked.Contains(addr) {
-			return false
-		}
-	}
-	return true
-}
-
-func baseURLForTracker(tracker string) (string, bool) {
-	return unit3dmeta.BaseURL(tracker)
-}
-
-func baseURLForTrackerWithConfig(cfg config.Config, tracker string) (string, bool) {
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	if key != "" {
-		if entry, ok := cfg.Trackers.Trackers[key]; ok {
-			if base := baseFromAnnounce(entry.AnnounceURL); base != "" {
-				return base, true
-			}
-		}
-		if entry, ok := cfg.Trackers.Trackers[strings.ToLower(key)]; ok {
-			if base := baseFromAnnounce(entry.AnnounceURL); base != "" {
-				return base, true
-			}
-		}
-		for name, entry := range cfg.Trackers.Trackers {
-			if strings.EqualFold(name, key) {
-				if base := baseFromAnnounce(entry.AnnounceURL); base != "" {
-					return base, true
-				}
-			}
-		}
-	}
-	return baseURLForTracker(tracker)
-}
-
-func baseFromAnnounce(announce string) string {
-	trimmed := strings.TrimSpace(announce)
-	if trimmed == "" {
-		return ""
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return ""
-	}
-	parsed.Path = "/"
-	parsed.RawQuery = ""
-	parsed.Fragment = ""
-	return parsed.String()
-}
-
-func parseNumberToInt64(value json.Number) (int64, error) {
-	text := strings.TrimSpace(value.String())
-	if text == "" {
-		return 0, errors.New("empty number")
-	}
-	if parsed, err := strconv.ParseInt(text, 10, 64); err == nil {
-		return parsed, nil
-	}
-	parsed, err := strconv.ParseFloat(text, 64)
-	if err != nil {
-		return 0, fmt.Errorf("parse numeric JSON value %q: %w", text, err)
-	}
-	return int64(parsed), nil
-}
-
-type unit3dResponse struct {
-	Data       json.RawMessage `json:"data"`
-	Attributes json.RawMessage `json:"attributes"`
-}
-
-type unit3dDataItem struct {
-	Attributes unit3dAttributes `json:"attributes"`
-}
-
-type unit3dAttributes struct {
-	Category      string         `json:"category"`
-	Description   string         `json:"description"`
-	TMDBID        int            `json:"tmdb_id"`
-	IMDBID        int            `json:"imdb_id"`
-	TVDBID        int            `json:"tvdb_id"`
-	MALID         int            `json:"mal_id"`
-	InfoHash      string         `json:"info_hash"`
-	Files         []unit3dFile   `json:"files"`
-	RegionID      int            `json:"region_id"`
-	DistributorID int            `json:"distributor_id"`
-	RawFileName   string         `json:"file_name"`
-	ExtraFiles    []unit3dFile   `json:"file"`
-	Other         map[string]any `json:"-"`
-}
-
-type unit3dFile struct {
-	Name string `json:"name"`
-}
-
-type parsedAttributes struct {
-	category    string
-	description string
-	tmdbID      int
-	imdbID      int
-	tvdbID      int
-	malID       int
-	infoHash    string
-	fileName    string
-}
-
-func (r unit3dResponse) extractAttributes(preferTopLevel bool) *parsedAttributes {
-	if len(r.Data) > 0 {
-		var dataString string
-		if err := json.Unmarshal(r.Data, &dataString); err == nil {
-			if strings.TrimSpace(dataString) == "404" {
-				return nil
-			}
-		}
-		var dataItems []unit3dDataItem
-		if err := json.Unmarshal(r.Data, &dataItems); err == nil {
-			if len(dataItems) > 0 {
-				return parseAttributes(dataItems[0].Attributes)
-			}
-		}
-	}
-
-	if !preferTopLevel || len(r.Attributes) == 0 {
-		return nil
-	}
-	var attrs unit3dAttributes
-	if err := json.Unmarshal(r.Attributes, &attrs); err != nil {
-		return nil
-	}
-	return parseAttributes(attrs)
-}
-
-func parseAttributes(attrs unit3dAttributes) *parsedAttributes {
-	info := &parsedAttributes{
-		category:    attrs.Category,
-		description: attrs.Description,
-		infoHash:    attrs.InfoHash,
-	}
-	info.tmdbID = normalizeID(attrs.TMDBID)
-	info.imdbID = normalizeID(attrs.IMDBID)
-	info.tvdbID = normalizeID(attrs.TVDBID)
-	info.malID = normalizeID(attrs.MALID)
-
-	fileNames := make([]string, 0, len(attrs.Files))
-	for _, file := range attrs.Files {
-		trimmed := strings.TrimSpace(file.Name)
-		if trimmed == "" {
-			continue
-		}
-		fileNames = append(fileNames, trimmed)
-		if len(fileNames) >= 5 {
-			break
-		}
-	}
-	if len(fileNames) == 1 {
-		info.fileName = fileNames[0]
-	} else if len(fileNames) > 1 {
-		info.fileName = strings.Join(fileNames, ", ")
-	}
-	if info.fileName == "" {
-		info.fileName = strings.TrimSpace(attrs.RawFileName)
-	}
-	return info
-}
-
-func normalizeID(value int) int {
-	if value <= 0 {
-		return 0
-	}
-	return value
-}
-
-type unit3dSearchResponse struct {
-	Data []unit3dSearchItem `json:"data"`
-}
-
-type unit3dSearchEndpoint struct {
-	url           string
-	pending       bool
-	filterTMDBID  int
-	pendingWebURL string
-}
-
-type unit3dSearchItem struct {
-	ID         json.Number       `json:"id"`
-	Attributes unit3dSearchAttrs `json:"attributes"`
-}
-
-type unit3dSearchAttrs struct {
-	Name         string       `json:"name"`
-	Size         json.Number  `json:"size"`
-	Files        []unit3dFile `json:"files"`
-	Trumpable    bool         `json:"trumpable"`
-	DetailsLink  string       `json:"details_link"`
-	DownloadLink string       `json:"download_link"`
-	Type         string       `json:"type"`
-	Resolution   string       `json:"resolution"`
-	Internal     bool         `json:"internal"`
-	BDInfo       string       `json:"bd_info"`
-	Description  string       `json:"description"`
-	Flags        []string     `json:"flags"`
-}
-
-type unit3dPendingSearchResponse struct {
-	Data []unit3dPendingSearchItem `json:"data"`
-}
-
-type unit3dPendingSearchItem struct {
-	ID           json.Number  `json:"id"`
-	TMDBID       int          `json:"tmdb_id"`
-	Name         string       `json:"name"`
-	Size         json.Number  `json:"size"`
-	Files        []unit3dFile `json:"files"`
-	Trumpable    bool         `json:"trumpable"`
-	DownloadLink string       `json:"download_link"`
-	Type         string       `json:"type"`
-	Resolution   string       `json:"resolution"`
-	Internal     bool         `json:"internal"`
-	BDInfo       string       `json:"bd_info"`
-	Description  string       `json:"description"`
-	Flags        []string     `json:"flags"`
-}
diff --git a/internal/trackers/architecture_test.go b/internal/trackers/architecture_test.go
new file mode 100644
index 00000000..ba596b73
--- /dev/null
+++ b/internal/trackers/architecture_test.go
@@ -0,0 +1,106 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers_test
+
+import (
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const trackerImplImportPrefix = "github.com/autobrr/upbrr/internal/trackers/impl/"
+
+func TestTrackerImplementationImportBoundaries(t *testing.T) {
+	t.Parallel()
+	_, currentFile, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatal("resolve architecture test path")
+	}
+	repoRoot := filepath.Clean(filepath.Join(filepath.Dir(currentFile), "..", ".."))
+	allowedDebt := map[string]map[string]bool{}
+
+	roots := []string{
+		filepath.Join(repoRoot, "internal", "trackers"),
+		filepath.Join(repoRoot, "internal", "metadata"),
+		filepath.Join(repoRoot, "internal", "bbcode"),
+		filepath.Join(repoRoot, "internal", "imagehosting"),
+	}
+	for _, root := range roots {
+		err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".go") || strings.HasSuffix(entry.Name(), "_test.go") {
+				return nil
+			}
+			checkImplementationImports(t, repoRoot, path, allowedDebt)
+			return nil
+		})
+		if err != nil {
+			t.Fatalf("scan architecture root: %v", err)
+		}
+	}
+	for file, imports := range allowedDebt {
+		for importPath, seen := range imports {
+			if !seen {
+				t.Errorf("stale architecture debt allowlist: file=%s import=%s", file, importPath)
+			}
+		}
+	}
+}
+
+func checkImplementationImports(t *testing.T, repoRoot string, filePath string, allowedDebt map[string]map[string]bool) {
+	t.Helper()
+	parsed, err := parser.ParseFile(token.NewFileSet(), filePath, nil, parser.ImportsOnly)
+	if err != nil {
+		t.Errorf("parse imports: %v", err)
+		return
+	}
+	relative, err := filepath.Rel(repoRoot, filePath)
+	if err != nil {
+		t.Errorf("resolve relative source path: %v", err)
+		return
+	}
+	for _, spec := range parsed.Imports {
+		importPath, err := strconv.Unquote(spec.Path.Value)
+		if err != nil || !strings.HasPrefix(importPath, trackerImplImportPrefix) {
+			continue
+		}
+		if implementationImportAllowed(relative, importPath) {
+			continue
+		}
+		if imports := allowedDebt[relative]; imports != nil {
+			if _, ok := imports[importPath]; ok {
+				imports[importPath] = true
+				continue
+			}
+		}
+		t.Errorf("generic or sibling package imports tracker implementation: file=%s import=%s", relative, importPath)
+	}
+}
+
+func implementationImportAllowed(relative string, importPath string) bool {
+	compositionRoot := filepath.Join("internal", "trackers", "impl", "registry.go")
+	if relative == compositionRoot {
+		return true
+	}
+	implRoot := filepath.Join("internal", "trackers", "impl") + string(filepath.Separator)
+	if strings.HasPrefix(relative, implRoot) && importPath == trackerImplImportPrefix+"commonhttp" {
+		return true
+	}
+	standaloneRoot := filepath.Join("internal", "trackers", "impl", "standalone") + string(filepath.Separator)
+	if strings.HasPrefix(relative, standaloneRoot) && importPath == trackerImplImportPrefix+"standalone" {
+		return true
+	}
+	if strings.HasPrefix(relative, standaloneRoot) && strings.HasPrefix(importPath, trackerImplImportPrefix+"standalone/internal/") {
+		return true
+	}
+	unit3DSitesRoot := filepath.Join("internal", "trackers", "impl", "unit3d", "sites") + string(filepath.Separator)
+	return strings.HasPrefix(relative, unit3DSitesRoot) && strings.HasPrefix(importPath, trackerImplImportPrefix+"unit3d")
+}
diff --git a/internal/trackers/auth/adapters.go b/internal/trackers/auth/adapters.go
new file mode 100644
index 00000000..0b6fb6e0
--- /dev/null
+++ b/internal/trackers/auth/adapters.go
@@ -0,0 +1,229 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	trackerscatalog "github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type sessionResolver func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) error
+
+type trackerAdapter struct {
+	capability api.TrackerAuthCapability
+	resolve    sessionResolver
+}
+
+// registryAdapters builds adapters exclusively from tracker-owned capabilities.
+func registryAdapters(registry *trackerscatalog.Registry) map[string]Adapter {
+	adapters := map[string]Adapter{}
+	for _, trackerID := range registry.Names() {
+		capability, hasCapability := registry.LookupAuthCapability(trackerID)
+		if !hasCapability {
+			continue
+		}
+		resolver, _ := registry.LookupAuthSessionResolver(trackerID)
+		adapters[normalizeTrackerID(trackerID)] = trackerAdapter{
+			capability: capability,
+			resolve:    sessionResolver(resolver),
+		}
+	}
+	return adapters
+}
+
+func (s *Service) adapterFor(trackerID string) (Adapter, bool) {
+	adapter, ok := s.adapters[normalizeTrackerID(trackerID)]
+	return adapter, ok
+}
+
+func (a trackerAdapter) Capability() api.TrackerAuthCapability {
+	return a.capability
+}
+
+func (a trackerAdapter) Status(ctx context.Context, cfg config.TrackerConfig, dbPath string) (api.TrackerAuthStatus, error) {
+	_ = cfg
+	trackerID := normalizeTrackerID(a.capability.TrackerID)
+	status := api.TrackerAuthStatus{
+		TrackerID:        trackerID,
+		DisplayName:      trackerID,
+		State:            StateNotConfigured,
+		LastCheckedAt:    time.Now().UTC().Format(time.RFC3339),
+		EncryptedStorage: strings.TrimSpace(dbPath) != "",
+	}
+	if a.capability.SupportsCookieFile {
+		values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, trackerID)
+		if err == nil && len(values) > 0 {
+			status.CookieCount = len(values)
+			status.State = StateHasCookies
+		}
+	}
+	return status, nil
+}
+
+func (a trackerAdapter) Validate(ctx context.Context, cfg config.TrackerConfig, dbPath string) (Session, error) {
+	if a.resolve == nil {
+		return Session{}, &UnsupportedAuthError{TrackerID: a.capability.TrackerID, Reason: "remote validation unavailable"}
+	}
+	if err := a.resolve(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{}); err != nil {
+		return Session{}, classifyAdapterError(a.capability.TrackerID, err)
+	}
+	return Session{
+		TrackerID: normalizeTrackerID(a.capability.TrackerID),
+		State:     SessionStateReady,
+		Message:   "session ready",
+	}, nil
+}
+
+func (a trackerAdapter) Login(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
+	if a.resolve == nil {
+		return Session{}, &UnsupportedAuthError{TrackerID: a.capability.TrackerID, Reason: "remote login unavailable"}
+	}
+	if err := a.resolve(ctx, cfg, dbPath, req); err != nil {
+		return Session{}, classifyAdapterError(a.capability.TrackerID, err)
+	}
+	return Session{
+		TrackerID: normalizeTrackerID(a.capability.TrackerID),
+		State:     SessionStateReady,
+		Message:   "session ready",
+	}, nil
+}
+
+func (a trackerAdapter) Submit2FA(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
+	return a.Login(ctx, cfg, dbPath, req)
+}
+
+func (a trackerAdapter) Delete(ctx context.Context, dbPath string) error {
+	if err := cookies.DeleteTrackerCookies(ctx, dbPath, normalizeTrackerID(a.capability.TrackerID)); err != nil {
+		return fmt.Errorf("tracker auth: delete %s cookies: %w", normalizeTrackerID(a.capability.TrackerID), err)
+	}
+	return nil
+}
+
+// classifyAdapterError maps tracker adapter failures to typed auth errors used
+// by EnsureSession. Only explicit 2FA-required failures become manual
+// challenges; parser/layout failures and other remote failures remain transient.
+func classifyAdapterError(trackerID string, err error) error {
+	if err == nil {
+		return nil
+	}
+	var authRequired *AuthRequiredError
+	if errors.As(err, &authRequired) {
+		return authRequired
+	}
+	var needs2FA *Needs2FAError
+	if errors.As(err, &needs2FA) {
+		return needs2FA
+	}
+	var unsupported *UnsupportedAuthError
+	if errors.As(err, &unsupported) {
+		return unsupported
+	}
+	if validation, ok := asValidationError(err); ok {
+		return validation
+	}
+	var resolution *trackerscatalog.AuthResolutionError
+	if errors.As(err, &resolution) {
+		if resolution.AuthRequired {
+			return &AuthRequiredError{
+				TrackerID: trackerID,
+				Reason:    resolution.Reason,
+				Err:       err,
+			}
+		}
+		return &ValidationError{
+			TrackerID:        trackerID,
+			ConfirmedInvalid: resolution.ConfirmedInvalid,
+			Transient:        resolution.Transient,
+			Reason:           resolution.Reason,
+			Err:              err,
+		}
+	}
+	if strings.Contains(strings.ToLower(err.Error()), "stored session confirmed invalid") {
+		return &ValidationError{
+			TrackerID:        trackerID,
+			ConfirmedInvalid: true,
+			Reason:           "stored session expired",
+			Err:              err,
+		}
+	}
+	if isSubmitted2FARejected(err) {
+		return &ValidationError{
+			TrackerID:            trackerID,
+			Transient:            true,
+			Submitted2FARejected: true,
+			Reason:               "submitted 2FA rejected",
+			Err:                  err,
+		}
+	}
+	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+		return &ValidationError{
+			TrackerID: trackerID,
+			Transient: true,
+			Reason:    "remote validation unavailable",
+			Err:       err,
+		}
+	}
+	lower := strings.ToLower(err.Error())
+	switch {
+	case contains2FARequiredText(lower):
+		return &Needs2FAError{
+			TrackerID: trackerID,
+			Reason:    "2FA required",
+			Err:       err,
+		}
+	case strings.Contains(lower, "username") || strings.Contains(lower, "password") || strings.Contains(lower, "announce_url") || strings.Contains(lower, "not configured"):
+		return &AuthRequiredError{
+			TrackerID: trackerID,
+			Reason:    "credentials missing",
+			Err:       err,
+		}
+	default:
+		return &ValidationError{
+			TrackerID: trackerID,
+			Transient: true,
+			Reason:    "remote validation failed",
+			Err:       err,
+		}
+	}
+}
+
+func isSubmitted2FARejected(err error) bool {
+	return errors.Is(err, trackerscatalog.ErrSubmitted2FARejected)
+}
+
+// contains2FARequiredText matches only the standalone "2FA required" phrase so
+// parser details such as token names or setup URLs do not create manual 2FA
+// challenges.
+func contains2FARequiredText(lower string) bool {
+	const phrase = "2fa required"
+	for offset := 0; offset < len(lower); {
+		idx := strings.Index(lower[offset:], phrase)
+		if idx < 0 {
+			return false
+		}
+		start := offset + idx
+		end := start + len(phrase)
+		if isClassifierBoundary(lower, start-1) && isClassifierBoundary(lower, end) {
+			return true
+		}
+		offset = start + 1
+	}
+	return false
+}
+
+func isClassifierBoundary(s string, idx int) bool {
+	if idx < 0 || idx >= len(s) {
+		return true
+	}
+	c := s[idx]
+	return (c < 'a' || c > 'z') && (c < '0' || c > '9')
+}
diff --git a/internal/trackerauth/challenge.go b/internal/trackers/auth/challenge.go
similarity index 99%
rename from internal/trackerauth/challenge.go
rename to internal/trackers/auth/challenge.go
index ea17cc77..b544eac9 100644
--- a/internal/trackerauth/challenge.go
+++ b/internal/trackers/auth/challenge.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
diff --git a/internal/trackerauth/challenge_test.go b/internal/trackers/auth/challenge_test.go
similarity index 99%
rename from internal/trackerauth/challenge_test.go
rename to internal/trackers/auth/challenge_test.go
index b441445e..a35f936e 100644
--- a/internal/trackerauth/challenge_test.go
+++ b/internal/trackers/auth/challenge_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
diff --git a/internal/trackerauth/ensure.go b/internal/trackers/auth/ensure.go
similarity index 89%
rename from internal/trackerauth/ensure.go
rename to internal/trackers/auth/ensure.go
index d56014dc..3bc9fe33 100644
--- a/internal/trackerauth/ensure.go
+++ b/internal/trackers/auth/ensure.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
@@ -64,12 +64,24 @@ func (s *Service) EnsureSession(ctx context.Context, req EnsureRequest) (Session
 	capability := adapter.Capability()
 	if !capability.SupportsLogin {
 		if confirmedInvalid {
-			return Session{}, &AuthRequiredError{TrackerID: trackerID, Reason: "stored session expired", Err: err}
+			return Session{}, &AuthRequiredError{
+				TrackerID: trackerID,
+				Reason:    "stored session expired",
+				Err:       err,
+			}
+		}
+		return Session{}, &UnsupportedAuthError{
+			TrackerID: trackerID,
+			Reason:    "credential login unsupported",
+			Err:       err,
 		}
-		return Session{}, &UnsupportedAuthError{TrackerID: trackerID, Reason: "credential login unsupported", Err: err}
 	}
 	if !hasLoginCredentials(req.Config) {
-		return Session{}, &AuthRequiredError{TrackerID: trackerID, Reason: "username/password missing", Err: err}
+		return Session{}, &AuthRequiredError{
+			TrackerID: trackerID,
+			Reason:    "username/password missing",
+			Err:       err,
+		}
 	}
 
 	session, loginErr := adapter.Login(ctx, req.Config, req.DBPath, req.Login)
diff --git a/internal/trackerauth/ensure_test.go b/internal/trackers/auth/ensure_test.go
similarity index 96%
rename from internal/trackerauth/ensure_test.go
rename to internal/trackers/auth/ensure_test.go
index 5bed7035..a5ab8f15 100644
--- a/internal/trackerauth/ensure_test.go
+++ b/internal/trackers/auth/ensure_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
@@ -115,7 +115,11 @@ func TestEnsureSessionDeletesConfirmedInvalidAndLogsIn(t *testing.T) {
 	adapter := &fakeAdapter{
 		capability: api.TrackerAuthCapability{TrackerID: "FAKE", SupportsLogin: true},
 		validate: func() (Session, error) {
-			return Session{}, &ValidationError{TrackerID: "FAKE", ConfirmedInvalid: true, Err: errors.New("expired")}
+			return Session{}, &ValidationError{
+				TrackerID:        "FAKE",
+				ConfirmedInvalid: true,
+				Err:              errors.New("expired"),
+			}
 		},
 		login: func() (Session, error) {
 			return Session{TrackerID: "FAKE", State: SessionStateReady}, nil
@@ -142,7 +146,11 @@ func TestEnsureSessionKeepsCookiesOnTransientValidationFailure(t *testing.T) {
 	adapter := &fakeAdapter{
 		capability: api.TrackerAuthCapability{TrackerID: "FAKE", SupportsLogin: true},
 		validate: func() (Session, error) {
-			return Session{}, &ValidationError{TrackerID: "FAKE", Transient: true, Err: errors.New("timeout")}
+			return Session{}, &ValidationError{
+				TrackerID: "FAKE",
+				Transient: true,
+				Err:       errors.New("timeout"),
+			}
 		},
 	}
 	service := &Service{adapters: map[string]Adapter{"FAKE": adapter}, challenges: NewChallengeManager(defaultChallengeTTL)}
@@ -323,7 +331,11 @@ func TestEnsureSessionCreatesManual2FAChallenge(t *testing.T) {
 	t.Parallel()
 
 	adapter := &fakeAdapter{
-		capability: api.TrackerAuthCapability{TrackerID: "FAKE", SupportsLogin: true, SupportsManual2FA: true},
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "FAKE",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
 		validate: func() (Session, error) {
 			return Session{}, &Needs2FAError{TrackerID: "FAKE"}
 		},
diff --git a/internal/trackers/auth/service.go b/internal/trackers/auth/service.go
new file mode 100644
index 00000000..c6825673
--- /dev/null
+++ b/internal/trackers/auth/service.go
@@ -0,0 +1,1274 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package auth
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/redaction"
+	trackerscatalog "github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Tracker auth status values returned in api.TrackerAuthStatus.State.
+const (
+	// MaxCookieImportContentBytes is the shared decoded cookie text byte limit for WebUI and service imports.
+	MaxCookieImportContentBytes = 1024 * 1024
+
+	// StateConfigured means required non-cookie config auth material is present.
+	StateConfigured = "configured"
+	// StateHasCookies means encrypted cookie storage contains at least one cookie for the tracker.
+	StateHasCookies = "has_cookies"
+	// StateNotConfigured means no supported auth material is currently configured.
+	StateNotConfigured = "not_configured"
+	// StateLoginRequired means credentials or imported cookies are required before tracker auth can proceed.
+	StateLoginRequired = "login_required"
+	// StateEncryptedStorageUnavailable means cookie import cannot be used until web auth material exists.
+	StateEncryptedStorageUnavailable = "encrypted_storage_unavailable"
+
+	// maxConcurrentValidations bounds simultaneous tracker and auth DB work.
+	maxConcurrentValidations = 4
+
+	expiredSessionActionMessage = "stored session expired or invalid; log in again or import fresh cookies"
+)
+
+// Service reports and manages persisted tracker auth material for configured trackers.
+type Service struct {
+	cfg                config.Config
+	adapters           map[string]Adapter
+	challenges         *ChallengeManager
+	logger             api.Logger
+	now                func() time.Time
+	afterDeleteCleanup func()
+	registry           *trackerscatalog.Registry
+}
+
+type trackerSpec struct {
+	id        string
+	authKind  string
+	cookies   bool
+	login     bool
+	autoLogin bool
+	totp      bool
+	// manual2FA permits adapter Needs2FA errors to become reusable Submit2FA challenges.
+	manual2FA        bool
+	apiKey           bool
+	passkey          bool
+	needsCredentials bool
+	notes            []string
+	policy           trackerscatalog.AuthPolicy
+}
+
+// NewServiceWithRegistryAndLogger snapshots tracker-owned auth capabilities at
+// construction, substitutes a no-op logger, and uses the process-wide manual
+// challenge manager. It panics when registry is nil.
+func NewServiceWithRegistryAndLogger(cfg config.Config, registry *trackerscatalog.Registry, logger api.Logger) *Service {
+	if registry == nil {
+		panic("tracker auth: registry is required")
+	}
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &Service{
+		cfg:        cfg,
+		adapters:   registryAdapters(registry),
+		challenges: sharedChallengeManager,
+		logger:     logger,
+		now:        time.Now,
+		registry:   registry,
+	}
+}
+
+func (s *Service) logInfof(format string, args ...any) {
+	if s == nil || s.logger == nil {
+		return
+	}
+	s.logger.Infof(format, args...)
+}
+
+func (s *Service) logTracef(format string, args ...any) {
+	if s == nil || s.logger == nil {
+		return
+	}
+	s.logger.Tracef(format, args...)
+}
+
+func (s *Service) logWarnf(format string, args ...any) {
+	if s == nil || s.logger == nil {
+		return
+	}
+	s.logger.Warnf(format, args...)
+}
+
+// logStatus records the user-visible auth state returned to callers, keeping
+// the log payload to tracker ID, state, cookie count, encrypted-storage state,
+// 2FA requirement, and already-redacted status errors.
+func (s *Service) logStatus(operation string, status api.TrackerAuthStatus) {
+	if strings.TrimSpace(status.LastError) != "" {
+		s.logWarnf(
+			"tracker auth: %s warning tracker=%s state=%s error=%s",
+			operation,
+			trackerLogID(status.TrackerID),
+			status.State,
+			status.LastError,
+		)
+		return
+	}
+	logf := s.logTracef
+	if operation == "login completed" && status.State == StateConfigured {
+		logf = s.logInfof
+	}
+	logf(
+		"tracker auth: %s tracker=%s state=%s cookies=%d encrypted_storage=%t needs_2fa=%t",
+		operation,
+		trackerLogID(status.TrackerID),
+		status.State,
+		status.CookieCount,
+		status.EncryptedStorage,
+		status.Needs2FA,
+	)
+}
+
+// trackerLogID normalizes tracker IDs for log messages and avoids empty tracker
+// fields when validation fails before a concrete tracker is resolved.
+func trackerLogID(trackerID string) string {
+	trackerID = normalizeTrackerID(trackerID)
+	if trackerID == "" {
+		return "unknown"
+	}
+	return trackerID
+}
+
+// Capabilities returns tracker-owned authentication metadata from the registry.
+func (s *Service) Capabilities(_ context.Context) (caps []api.TrackerAuthCapability, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: capabilities failed: %v", err)
+			return
+		}
+		s.logTracef("tracker auth: capabilities loaded count=%d", len(caps))
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return nil, err
+	}
+	specs := s.specs()
+	out := make([]api.TrackerAuthCapability, 0, len(specs))
+	for _, spec := range specs {
+		out = append(out, s.capabilityForSpec(spec))
+	}
+	return out, nil
+}
+
+// Status returns local tracker auth state derived from config, encrypted cookie storage, and stored cookies.
+func (s *Service) Status(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: status failed tracker=%s: %v", trackerLogID(trackerID), err)
+			return
+		}
+		s.logStatus("status checked", status)
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, err := s.specFor(trackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	return s.statusForSpec(ctx, spec), nil
+}
+
+// ImportCookies parses supplied cookie content, saves it for trackerID, and
+// returns refreshed auth status from persisted cookie/auth state. Parser errors
+// leave existing stored cookies unchanged. BTN imports still report a missing
+// API-key prerequisite when cookies alone do not make the tracker upload-ready.
+func (s *Service) ImportCookies(ctx context.Context, trackerID string, fileName string, content string) (status api.TrackerAuthStatus, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: cookie import failed tracker=%s bytes=%d: %v", trackerLogID(trackerID), len(content), err)
+			return
+		}
+		s.logStatus("cookies imported", status)
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, err := s.specFor(trackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	if !spec.cookies {
+		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: %s does not support cookie import", spec.id)
+	}
+	values, err := ParseCookieContent(fileName, content)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	if err := cookies.SaveTrackerCookieMap(ctx, s.cfg.MainSettings.DBPath, spec.id, values); err != nil {
+		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: import %s cookies: %w", spec.id, err)
+	}
+	status = s.statusForSpec(ctx, spec)
+	if status.State != StateLoginRequired || spec.policy.MissingAPIKeyMessage == "" || status.Message != spec.policy.MissingAPIKeyMessage {
+		status.State = StateHasCookies
+		status.Message = "cookies imported"
+	}
+	return status, nil
+}
+
+// Validate returns tracker auth status after a remote validation check when the
+// tracker has an adapter. Confirmed-invalid stored sessions are deleted and
+// reported as login-required status without returning an error. BTN session
+// success remains login-required until the API token needed for torrent
+// resolution is configured. Returned cookie counts and RFC3339 timestamps are
+// rebuilt after login or deletion side effects complete.
+func (s *Service) Validate(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: validation failed tracker=%s: %v", trackerLogID(trackerID), err)
+			return
+		}
+		s.logStatus("validation completed", status)
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, err := s.specFor(trackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	status = s.statusForSpec(ctx, spec)
+
+	if _, ok := s.adapterFor(spec.id); ok {
+		session, ensureErr := s.EnsureSession(ctx, EnsureRequest{
+			TrackerID: spec.id,
+			Config:    mustTrackerConfig(s.cfg, spec.id),
+			DBPath:    s.cfg.MainSettings.DBPath,
+			AutoLogin: true,
+		})
+		if ensureErr != nil {
+			status = s.statusForSpec(ctx, spec)
+			applyEnsureErrorToStatus(&status, ensureErr)
+			if session.ChallengeID != "" {
+				status.ChallengeID = session.ChallengeID
+			}
+			return status, nil
+		}
+		status = s.statusForSpec(ctx, spec)
+		if spec.policy.MissingAPIKeyMessage != "" && s.effectiveAPIKey(spec, mustTrackerConfig(s.cfg, spec.id)) == "" {
+			status.State = StateLoginRequired
+			status.Message = spec.policy.MissingAPIKeyMessage
+			return status, nil
+		}
+		status.State = StateConfigured
+		status.Message = "remote auth check succeeded"
+		return status, nil
+	}
+	status.Message = "remote auth validation is not supported for this tracker"
+	return status, nil
+}
+
+// ValidateMany validates every tracker concurrently and returns statuses in
+// input order. It waits for the full batch with bounded concurrency; if any
+// validation fails, it returns the first input-ordered error and no statuses.
+func (s *Service) ValidateMany(ctx context.Context, trackerIDs []string) ([]api.TrackerAuthStatus, error) {
+	statuses := make([]api.TrackerAuthStatus, len(trackerIDs))
+	errs := make([]error, len(trackerIDs))
+
+	var group errgroup.Group
+	group.SetLimit(maxConcurrentValidations)
+	for i, trackerID := range trackerIDs {
+		group.Go(func() error {
+			statuses[i], errs[i] = s.Validate(ctx, trackerID)
+			return nil
+		})
+	}
+	_ = group.Wait()
+
+	for i, err := range errs {
+		if err != nil {
+			return nil, fmt.Errorf("tracker auth: validate %s: %w", trackerLogID(trackerIDs[i]), err)
+		}
+	}
+	return statuses, nil
+}
+
+// IsManagedCapability reports whether a capability requires session, login,
+// refresh, or 2FA handling rather than only static API-key/passkey config.
+func IsManagedCapability(capability api.TrackerAuthCapability) bool {
+	authKind := strings.ToLower(strings.TrimSpace(capability.AuthKind))
+	return capability.SupportsCookieFile ||
+		capability.SupportsLogin ||
+		capability.SupportsAutoLogin ||
+		capability.SupportsTOTP ||
+		capability.SupportsManual2FA ||
+		strings.Contains(authKind, "refresh") ||
+		strings.Contains(authKind, "2fa")
+}
+
+// IsReadyStatus reports whether a status represents usable auth without further
+// user input. A pending 2FA challenge is never ready, regardless of state.
+func IsReadyStatus(status api.TrackerAuthStatus) bool {
+	if status.Needs2FA {
+		return false
+	}
+	switch strings.TrimSpace(status.State) {
+	case StateConfigured, StateHasCookies:
+		return true
+	default:
+		return false
+	}
+}
+
+// Login runs credential-based tracker auth when supported and returns status for
+// missing credentials, unsupported remote login, or 2FA. Trackers with separate
+// API prerequisites, such as BTN, keep the narrower prerequisite status when
+// credential login cannot proceed or completes without making the tracker ready.
+func (s *Service) Login(ctx context.Context, trackerID string, req api.TrackerAuthLoginRequest) (status api.TrackerAuthStatus, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: login failed tracker=%s: %v", trackerLogID(trackerID), err)
+			return
+		}
+		s.logStatus("login completed", status)
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, err := s.specFor(trackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	if !spec.login {
+		return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: %s does not support credential login", spec.id)
+	}
+	trackerCfg := mustTrackerConfig(s.cfg, spec.id)
+	status = s.statusForSpec(ctx, spec)
+	if status.State == StateLoginRequired && !hasUsableLoginConfig(spec, trackerCfg) {
+		if !hasSpecificLoginBlocker(status) {
+			status.Message = "username/password missing"
+		}
+		return status, nil
+	}
+
+	if _, ok := s.adapterFor(spec.id); ok {
+		session, ensureErr := s.EnsureSession(ctx, EnsureRequest{
+			TrackerID: spec.id,
+			Config:    trackerCfg,
+			DBPath:    s.cfg.MainSettings.DBPath,
+			AutoLogin: true,
+			Login:     req,
+		})
+		if ensureErr != nil {
+			applyEnsureErrorToStatus(&status, ensureErr)
+			if session.ChallengeID != "" {
+				status.ChallengeID = session.ChallengeID
+			}
+			return status, nil
+		}
+		if spec.policy.MissingAPIKeyMessage != "" && s.effectiveAPIKey(spec, trackerCfg) == "" {
+			return s.statusForSpec(ctx, spec), nil
+		}
+		status.State = StateConfigured
+		status.Message = "remote login/auth check succeeded"
+		return status, nil
+	}
+	status.Message = "remote credential login is not supported for this tracker"
+	return status, nil
+}
+
+// Submit2FA completes an active manual 2FA challenge. Adapter failures return
+// refreshed status without consuming the challenge; only failures classified
+// with [ValidationError.Submitted2FARejected] keep the challenge visible for
+// another try. Successful challenge completion clears the challenge fields but
+// does not override separate tracker prerequisites such as BTN's API key.
+func (s *Service) Submit2FA(ctx context.Context, challengeID string, code string) (status api.TrackerAuthStatus, err error) {
+	logTrackerID := ""
+	defer func() {
+		if logTrackerID == "" {
+			logTrackerID = status.TrackerID
+		}
+		if err != nil {
+			s.logWarnf("tracker auth: 2FA submit failed tracker=%s: %v", trackerLogID(logTrackerID), err)
+			return
+		}
+		s.logStatus("2FA completed", status)
+	}()
+	if strings.TrimSpace(challengeID) == "" {
+		return api.TrackerAuthStatus{}, errors.New("tracker auth: challenge id is required")
+	}
+	if strings.TrimSpace(code) == "" {
+		return api.TrackerAuthStatus{}, errors.New("tracker auth: 2FA code is required")
+	}
+	challenges := s.challengeManager()
+	challenge, ok := challenges.Get(challengeID)
+	if !ok {
+		return api.TrackerAuthStatus{}, errors.New("tracker auth: no active manual 2FA challenge")
+	}
+	logTrackerID = challenge.TrackerID
+	ownerKey, err := s.challengeOwnerKey(challenge.TrackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	if !challengeOwnerMatches(challenge, ownerKey) {
+		return api.TrackerAuthStatus{}, errors.New("tracker auth: stale manual 2FA challenge")
+	}
+	adapter, ok := s.adapterFor(challenge.TrackerID)
+	if !ok {
+		return api.TrackerAuthStatus{}, newUnknownTrackerError(challenge.TrackerID)
+	}
+	session, err := adapter.Submit2FA(ctx, mustTrackerConfig(s.cfg, challenge.TrackerID), s.cfg.MainSettings.DBPath, api.TrackerAuthLoginRequest{Code: code})
+	if err != nil {
+		status, statusErr := s.Status(ctx, challenge.TrackerID)
+		if statusErr != nil {
+			return api.TrackerAuthStatus{}, statusErr
+		}
+		applyEnsureErrorToStatus(&status, err)
+		if !shouldKeepSubmitted2FARetryVisible(challenge.TrackerID, err) {
+			return status, nil
+		}
+		status.Needs2FA = true
+		status.ChallengeID = challengeID
+		status.State = StateLoginRequired
+		status.Message = "2FA code rejected; enter a new 2FA code"
+		return status, nil
+	}
+	if _, err := challenges.Consume(challengeID, challenge.TrackerID, ownerKey); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	status, err = s.Status(ctx, challenge.TrackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, specErr := s.specFor(challenge.TrackerID)
+	if specErr != nil {
+		return api.TrackerAuthStatus{}, specErr
+	}
+	missingAPIKey := spec.policy.MissingAPIKeyMessage != "" && s.effectiveAPIKey(spec, mustTrackerConfig(s.cfg, spec.id)) == ""
+	if (strings.TrimSpace(session.State) == "" || session.State == SessionStateReady) && !missingAPIKey {
+		status.State = StateConfigured
+	}
+	status.Needs2FA = false
+	status.ChallengeID = ""
+	if !missingAPIKey {
+		status.Message = "2FA auth completed"
+	}
+	return status, nil
+}
+
+// shouldKeepSubmitted2FARetryVisible reports whether an adapter proved the
+// submitted manual code reached the tracker and was rejected, so the UI can
+// retry the same active challenge.
+func shouldKeepSubmitted2FARetryVisible(_ string, err error) bool {
+	validation, ok := asValidationError(err)
+	return ok && validation.Transient && !validation.ConfirmedInvalid && validation.Submitted2FARejected
+}
+
+func (s *Service) challengeManager() *ChallengeManager {
+	if s.challenges == nil {
+		s.challenges = sharedChallengeManager
+	}
+	return s.challenges
+}
+
+// Delete removes tracker-specific auth state and generic cookies, then returns
+// the refreshed local auth status. AR auth-state and cookie cleanup failures
+// restore the previous AR auth state before returning the error even when the
+// caller's context has been canceled.
+func (s *Service) Delete(ctx context.Context, trackerID string) (status api.TrackerAuthStatus, err error) {
+	defer func() {
+		if err != nil {
+			s.logWarnf("tracker auth: delete failed tracker=%s: %v", trackerLogID(trackerID), err)
+			return
+		}
+		s.logStatus("auth deleted", status)
+	}()
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	spec, err := s.specFor(trackerID)
+	if err != nil {
+		return api.TrackerAuthStatus{}, err
+	}
+	stateManager, hasStateManager := s.registry.LookupAuthStateManager(spec.id)
+	var authSnapshot trackerscatalog.AuthStateSnapshot
+	if hasStateManager {
+		authSnapshot, err = stateManager.Snapshot(ctx, s.cfg.MainSettings.DBPath)
+		if err != nil {
+			return api.TrackerAuthStatus{}, fmt.Errorf("tracker auth: snapshot %s auth state: %w", spec.id, err)
+		}
+	}
+	if hasStateManager {
+		err = stateManager.Delete(ctx, s.cfg.MainSettings.DBPath)
+	}
+	if err != nil {
+		restoreErr := restoreAuthStateSnapshot(ctx, authSnapshot)
+		deleteErr := fmt.Errorf("tracker auth: delete %s auth state: %w", spec.id, err)
+		if restoreErr != nil {
+			return api.TrackerAuthStatus{}, errors.Join(deleteErr, restoreErr)
+		}
+		return api.TrackerAuthStatus{}, deleteErr
+	}
+	if err := cookies.DeleteTrackerCookies(ctx, s.cfg.MainSettings.DBPath, spec.id); err != nil {
+		restoreErr := restoreAuthStateSnapshot(ctx, authSnapshot)
+		deleteErr := fmt.Errorf("tracker auth: delete %s cookies: %w", spec.id, err)
+		if restoreErr != nil {
+			return api.TrackerAuthStatus{}, errors.Join(deleteErr, restoreErr)
+		}
+		return api.TrackerAuthStatus{}, deleteErr
+	}
+	if s.afterDeleteCleanup != nil {
+		s.afterDeleteCleanup()
+	}
+	status = s.statusForSpec(contextWithoutCancel(ctx), spec)
+	status.CookieCount = 0
+	status.Message = "stored auth deleted"
+	return status, nil
+}
+
+func restoreAuthStateSnapshot(ctx context.Context, snapshot trackerscatalog.AuthStateSnapshot) error {
+	if snapshot == nil {
+		return nil
+	}
+	if err := snapshot.Restore(ctx); err != nil {
+		return fmt.Errorf("tracker auth: restore auth state: %w", err)
+	}
+	return nil
+}
+
+// statusForSpec reports configured auth material without hiding encrypted
+// storage availability. It does not create manual 2FA status; Login, Validate,
+// and Submit2FA attach active challenges only when a challenge ID exists.
+func (s *Service) statusForSpec(ctx context.Context, spec trackerSpec) api.TrackerAuthStatus {
+	encryptedStorage := s.encryptedStorageAvailable()
+	status := api.TrackerAuthStatus{
+		TrackerID:        spec.id,
+		DisplayName:      spec.id,
+		State:            StateNotConfigured,
+		LastCheckedAt:    s.currentTime().UTC().Format(time.RFC3339),
+		EncryptedStorage: encryptedStorage,
+	}
+
+	cfg, hasCfg := trackerConfig(s.cfg, spec.id)
+	hasAPIKey := spec.apiKey && s.effectiveAPIKey(spec, cfg) != ""
+	hasPasskey := strings.TrimSpace(cfg.Passkey) != ""
+	hasCredentials := spec.login && hasCfg && hasUsableLoginConfig(spec, cfg)
+	if spec.cookies {
+		values, err := cookies.LoadTrackerCookieMap(ctx, s.cfg.MainSettings.DBPath, spec.id)
+		if err == nil && len(values) > 0 {
+			status.CookieCount = len(values)
+			status.State = StateHasCookies
+		} else if err != nil && !strings.Contains(strings.ToLower(err.Error()), "no cookies found") {
+			status.LastError = redact(err.Error())
+		}
+	}
+
+	if hasAPIKey && (!spec.policy.APIKeyRequiresUploadSession || hasCredentials || (spec.policy.CookieCompletesAPIKeyAuth && status.CookieCount > 0)) {
+		status.State = StateConfigured
+	}
+	missingAPIKey := spec.policy.MissingAPIKeyMessage != "" && !hasAPIKey && (status.CookieCount > 0 || hasCredentials)
+	if missingAPIKey {
+		status.State = StateLoginRequired
+	}
+	if passkeyCoversAuth(spec) && hasPasskey {
+		status.State = StateConfigured
+	}
+	if spec.policy.PasskeyRequiresUsername && hasPasskey && strings.TrimSpace(cfg.Username) != "" &&
+		(!spec.policy.PasskeyRequiresCookie || status.CookieCount > 0) {
+		status.State = StateConfigured
+	}
+	if spec.policy.PasskeyRequiresUsername && spec.policy.PasskeyRequiresCookie && hasPasskey && strings.TrimSpace(cfg.Username) != "" &&
+		status.CookieCount == 0 {
+		status.State = StateLoginRequired
+	}
+	if spec.login {
+		if hasCredentials {
+			if status.State == StateNotConfigured {
+				status.State = StateConfigured
+			}
+		} else if status.CookieCount == 0 && spec.needsCredentials {
+			status.State = StateLoginRequired
+		}
+	}
+	if !missingAPIKey && spec.cookies && status.CookieCount == 0 && !encryptedStorage &&
+		authStatusRequiresEncryptedStorage(spec, hasCredentials, hasAPIKey, hasPasskey) {
+		status.State = StateEncryptedStorageUnavailable
+	}
+	status.Message = validationMessage(spec, status)
+	if status.State != StateEncryptedStorageUnavailable && spec.policy.APIKeyRequiresUploadSession && hasAPIKey && status.CookieCount == 0 && !hasCredentials {
+		status.Message = spec.policy.UploadSessionMissingMessage
+	}
+	if missingAPIKey {
+		status.Message = spec.policy.MissingAPIKeyMessage
+	}
+	return status
+}
+
+// currentTime returns the service clock, falling back to the wall clock for
+// zero-value or test-constructed services without an injected clock.
+func (s *Service) currentTime() time.Time {
+	if s != nil && s.now != nil {
+		return s.now()
+	}
+	return time.Now()
+}
+
+// effectiveAPIKey resolves a tracker-owned compatibility credential when one
+// exists, otherwise using the tracker entry's standard API-key fields.
+func (s *Service) effectiveAPIKey(spec trackerSpec, cfg config.TrackerConfig) string {
+	if spec.policy.ResolveAPIKey != nil {
+		return strings.TrimSpace(spec.policy.ResolveAPIKey(s.cfg, cfg))
+	}
+	return configAPIKey(cfg)
+}
+
+func passkeyCoversAuth(spec trackerSpec) bool {
+	return spec.passkey && spec.policy.PasskeyCoversAuth
+}
+
+// hasUsableLoginConfig reports whether credential login has every config value
+// required by the tracker implementation. PTP also needs announce_url because
+// login derives the passkey from it.
+func hasUsableLoginConfig(spec trackerSpec, cfg config.TrackerConfig) bool {
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return false
+	}
+	if spec.policy.LoginRequiresAnnounceURL && strings.TrimSpace(cfg.AnnounceURL) == "" {
+		return false
+	}
+	return true
+}
+
+// hasSpecificLoginBlocker reports whether status already explains a prerequisite
+// more specific than the generic login-required message.
+func hasSpecificLoginBlocker(status api.TrackerAuthStatus) bool {
+	message := strings.TrimSpace(status.Message)
+	return message != "" && message != validationMessage(trackerSpec{}, status)
+}
+
+func (s *Service) encryptedStorageAvailable() bool {
+	if strings.TrimSpace(s.cfg.MainSettings.DBPath) == "" {
+		return false
+	}
+	_, err := authmaterial.LoadFromDBPath(s.cfg.MainSettings.DBPath)
+	return err == nil
+}
+
+func authStatusRequiresEncryptedStorage(spec trackerSpec, hasCredentials bool, hasAPIKey bool, hasPasskey bool) bool {
+	if passkeyCoversAuth(spec) && hasPasskey {
+		return false
+	}
+	if spec.apiKey && hasAPIKey && !spec.policy.APIKeyRequiresUploadSession {
+		return false
+	}
+	return !hasAPIKey || spec.policy.APIKeyRequiresUploadSession || hasCredentials
+}
+
+// specFor resolves built-in and configured tracker IDs through normalizeTrackerID
+// so ASCII case differences match while non-ASCII runes keep their original case.
+func (s *Service) specFor(trackerID string) (trackerSpec, error) {
+	needle := normalizeTrackerID(trackerID)
+	if needle == "" {
+		return trackerSpec{}, errors.New("tracker auth: tracker id is required")
+	}
+	for _, spec := range s.specs() {
+		if spec.id == needle {
+			return spec, nil
+		}
+	}
+	return trackerSpec{}, fmt.Errorf("tracker auth: unknown tracker %s", needle)
+}
+
+func (s *Service) validateTrackerConfigIDs() error {
+	seen := map[string]string{}
+	for id := range s.cfg.Trackers.Trackers {
+		trimmedID := strings.TrimSpace(id)
+		if trimmedID == "" {
+			continue
+		}
+		normalizedID := normalizeTrackerID(trimmedID)
+		if previous, ok := seen[normalizedID]; ok && previous != trimmedID {
+			return fmt.Errorf("tracker auth: duplicate tracker config id %q conflicts with %q", trimmedID, previous)
+		}
+		seen[normalizedID] = trimmedID
+	}
+	return nil
+}
+
+// specs projects tracker-owned registry capabilities into coordinator state.
+func (s *Service) specs() []trackerSpec {
+	out := make([]trackerSpec, 0)
+	for _, id := range s.registry.Names() {
+		capability, ok := s.registry.LookupAuthCapability(id)
+		if !ok {
+			continue
+		}
+		policy, _ := s.registry.LookupAuthPolicy(id)
+		out = append(out, trackerSpec{
+			id:               normalizeTrackerID(capability.TrackerID),
+			authKind:         capability.AuthKind,
+			cookies:          capability.SupportsCookieFile,
+			login:            capability.SupportsLogin,
+			autoLogin:        capability.SupportsAutoLogin,
+			totp:             capability.SupportsTOTP,
+			manual2FA:        capability.SupportsManual2FA,
+			apiKey:           capability.RequiresAPIKey,
+			passkey:          capability.RequiresPasskey,
+			needsCredentials: capability.SupportsLogin && capability.AuthKind != "api_key_credential_refresh",
+			notes:            append([]string(nil), capability.Notes...),
+			policy:           policy,
+		})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].id < out[j].id })
+	return out
+}
+
+func capabilityFromSpec(spec trackerSpec) api.TrackerAuthCapability {
+	return api.TrackerAuthCapability{
+		TrackerID:          spec.id,
+		DisplayName:        spec.id,
+		AuthKind:           spec.authKind,
+		SupportsCookieFile: spec.cookies,
+		SupportsLogin:      spec.login,
+		SupportsAutoLogin:  spec.autoLogin,
+		SupportsTOTP:       spec.totp,
+		SupportsManual2FA:  spec.manual2FA,
+		RequiresAPIKey:     spec.apiKey,
+		RequiresPasskey:    spec.passkey,
+		Notes:              append([]string{}, spec.notes...),
+	}
+}
+
+// capabilityForSpec exposes remote login, auto-login, and 2FA actions only
+// when this service has an adapter that can execute them.
+func (s *Service) capabilityForSpec(spec trackerSpec) api.TrackerAuthCapability {
+	if capability, ok := s.registry.LookupAuthCapability(spec.id); ok {
+		_, capability.SupportsRemoteValidation = s.registry.LookupAuthSessionResolver(spec.id)
+		if _, hasAdapter := s.adapterFor(spec.id); !hasAdapter {
+			capability.SupportsLogin = false
+			capability.SupportsAutoLogin = false
+			capability.SupportsTOTP = false
+			capability.SupportsManual2FA = false
+		}
+		return capability
+	}
+	if adapter, ok := s.adapterFor(spec.id); ok {
+		return adapter.Capability()
+	}
+	capability := capabilityFromSpec(spec)
+	capability.SupportsLogin = false
+	capability.SupportsAutoLogin = false
+	capability.SupportsTOTP = false
+	capability.SupportsManual2FA = false
+	return capability
+}
+
+func (s *Service) challengeOwnerKey(trackerID string) (string, error) {
+	if err := s.validateTrackerConfigIDs(); err != nil {
+		return "", err
+	}
+	cfg, ok := trackerConfig(s.cfg, trackerID)
+	if !ok {
+		cfg = config.TrackerConfig{}
+	}
+	// #nosec G117 -- payload is only hashed for a local challenge owner key.
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return "", fmt.Errorf("tracker auth: encode challenge owner: %w", err)
+	}
+	sum := sha256.Sum256(payload)
+	return normalizeTrackerID(trackerID) + ":" + hex.EncodeToString(sum[:]), nil
+}
+
+func trackerConfig(cfg config.Config, trackerID string) (config.TrackerConfig, bool) {
+	normalizedTrackerID := normalizeTrackerID(trackerID)
+	for key, value := range cfg.Trackers.Trackers {
+		if normalizeTrackerID(key) == normalizedTrackerID {
+			return value, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+
+func configAPIKey(cfg config.TrackerConfig) string {
+	if key := strings.TrimSpace(cfg.APIKey); key != "" {
+		return key
+	}
+	return strings.TrimSpace(cfg.PTPAPIKey)
+}
+
+func validationMessage(spec trackerSpec, status api.TrackerAuthStatus) string {
+	switch status.State {
+	case StateHasCookies:
+		return fmt.Sprintf("%d stored cookie(s); tracker upload/search will validate remotely when used", status.CookieCount)
+	case StateConfigured:
+		if status.CookieCount > 0 {
+			return fmt.Sprintf("required config auth material is present; %d stored cookie(s)", status.CookieCount)
+		}
+		return "required config auth material is present"
+	case StateLoginRequired:
+		return "login credentials or imported cookies required"
+	case StateEncryptedStorageUnavailable:
+		return "encrypted cookie storage unavailable; create web-auth.json before importing cookies"
+	default:
+		if spec.cookies || spec.login || spec.apiKey || spec.passkey {
+			return "auth material not configured"
+		}
+		return "no tracker-specific auth handling"
+	}
+}
+
+// ParseCookieContent parses JSON cookie exports or Netscape cookie files into
+// a non-empty name/value map. Raw content above [MaxCookieImportContentBytes],
+// malformed JSON-looking payloads, JSON array entries without name and value,
+// and duplicate trimmed cookie names are rejected; cookie values are preserved
+// byte-for-byte after decoding.
+func ParseCookieContent(fileName string, content string) (map[string]string, error) {
+	if len(content) > MaxCookieImportContentBytes {
+		return nil, fmt.Errorf("tracker auth: cookie file content exceeds %d byte limit", MaxCookieImportContentBytes)
+	}
+	trimmed := strings.TrimSpace(content)
+	if trimmed == "" {
+		return nil, errors.New("tracker auth: cookie file content is required")
+	}
+	if shouldParseJSONCookies(fileName, trimmed) {
+		return parseJSONCookieContent([]byte(trimmed))
+	}
+	return parseNetscapeCookieContent(content)
+}
+
+// shouldParseJSONCookies accepts JSON by extension, leading object, or a valid
+// leading array so exported array payloads are not filename-dependent.
+func shouldParseJSONCookies(fileName string, trimmed string) bool {
+	return strings.EqualFold(filepath.Ext(strings.TrimSpace(fileName)), ".json") ||
+		strings.HasPrefix(trimmed, "{") ||
+		strings.HasPrefix(trimmed, "[")
+}
+
+func parseJSONCookieContent(payload []byte) (map[string]string, error) {
+	if err := rejectDuplicateJSONCookieNames(payload); err != nil {
+		return nil, err
+	}
+	var decoded any
+	if err := json.Unmarshal(payload, &decoded); err != nil {
+		return nil, fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	out := make(map[string]string)
+	switch typed := decoded.(type) {
+	case map[string]any:
+		if err := addJSONCookieObject(out, typed); err != nil {
+			return nil, err
+		}
+	case []any:
+		for _, item := range typed {
+			entry, ok := item.(map[string]any)
+			if !ok {
+				return nil, errors.New("tracker auth: JSON cookie array entries must be objects")
+			}
+			if err := addJSONCookieArrayEntry(out, entry); err != nil {
+				return nil, err
+			}
+		}
+	default:
+		return nil, errors.New("tracker auth: JSON cookie content must be an object or array")
+	}
+	if len(out) == 0 {
+		return nil, errors.New("tracker auth: cookie content has no entries")
+	}
+	return out, nil
+}
+
+// rejectDuplicateJSONCookieNames rejects duplicates only where JSON fields
+// become effective cookie names or values before json.Unmarshal can collapse
+// them into a map.
+func rejectDuplicateJSONCookieNames(payload []byte) error {
+	decoder := json.NewDecoder(bytes.NewReader(payload))
+	token, err := decoder.Token()
+	if err != nil {
+		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	delim, ok := token.(json.Delim)
+	if !ok {
+		return nil
+	}
+	switch delim {
+	case '{':
+		return rejectDuplicateJSONRootCookieNames(decoder)
+	case '[':
+		return rejectDuplicateJSONArrayCookieFields(decoder)
+	default:
+		return nil
+	}
+}
+
+func rejectDuplicateJSONRootCookieNames(decoder *json.Decoder) error {
+	seen := map[string]struct{}{}
+	for decoder.More() {
+		token, err := decoder.Token()
+		if err != nil {
+			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+		}
+		key, ok := token.(string)
+		if !ok {
+			return errors.New("tracker auth: JSON cookie object has non-string key")
+		}
+		name := strings.TrimSpace(key)
+		if name != "" {
+			if _, ok := seen[name]; ok {
+				return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
+			}
+			seen[name] = struct{}{}
+		}
+		valueToken, err := decoder.Token()
+		if err != nil {
+			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+		}
+		if err := rejectDuplicateJSONObjectCookieFields(decoder, valueToken, map[string]struct{}{"value": {}}); err != nil {
+			return err
+		}
+	}
+	if _, err := decoder.Token(); err != nil {
+		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	return nil
+}
+
+func rejectDuplicateJSONArrayCookieFields(decoder *json.Decoder) error {
+	for decoder.More() {
+		token, err := decoder.Token()
+		if err != nil {
+			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+		}
+		if err := rejectDuplicateJSONObjectCookieFields(decoder, token, map[string]struct{}{"name": {}, "value": {}}); err != nil {
+			return err
+		}
+	}
+	if _, err := decoder.Token(); err != nil {
+		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	return nil
+}
+
+func rejectDuplicateJSONObjectCookieFields(decoder *json.Decoder, token json.Token, fields map[string]struct{}) error {
+	delim, ok := token.(json.Delim)
+	if !ok {
+		return nil
+	}
+	if delim != '{' {
+		return discardJSONValue(decoder, token)
+	}
+	seen := map[string]struct{}{}
+	for decoder.More() {
+		keyToken, err := decoder.Token()
+		if err != nil {
+			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+		}
+		key, ok := keyToken.(string)
+		if !ok {
+			return errors.New("tracker auth: JSON cookie object has non-string key")
+		}
+		name := strings.TrimSpace(key)
+		if _, relevant := fields[name]; relevant {
+			if _, ok := seen[name]; ok {
+				return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
+			}
+			seen[name] = struct{}{}
+		}
+		valueToken, err := decoder.Token()
+		if err != nil {
+			return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+		}
+		if err := discardJSONValue(decoder, valueToken); err != nil {
+			return err
+		}
+	}
+	if _, err := decoder.Token(); err != nil {
+		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	return nil
+}
+
+func discardJSONValue(decoder *json.Decoder, token json.Token) error {
+	delim, ok := token.(json.Delim)
+	if !ok {
+		return nil
+	}
+	switch delim {
+	case '{':
+		for decoder.More() {
+			if _, err := decoder.Token(); err != nil {
+				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+			}
+			valueToken, err := decoder.Token()
+			if err != nil {
+				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+			}
+			if err := discardJSONValue(decoder, valueToken); err != nil {
+				return err
+			}
+		}
+	case '[':
+		for decoder.More() {
+			valueToken, err := decoder.Token()
+			if err != nil {
+				return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+			}
+			if err := discardJSONValue(decoder, valueToken); err != nil {
+				return err
+			}
+		}
+	default:
+		return nil
+	}
+	if _, err := decoder.Token(); err != nil {
+		return fmt.Errorf("tracker auth: parse JSON cookies: %w", err)
+	}
+	return nil
+}
+
+func addJSONCookieObject(out map[string]string, decoded map[string]any) error {
+	for key, value := range decoded {
+		name := strings.TrimSpace(key)
+		if name == "" {
+			continue
+		}
+		switch typed := value.(type) {
+		case string:
+			if err := addCookieValue(out, name, typed); err != nil {
+				return err
+			}
+		case map[string]any:
+			if raw, ok := typed["value"]; ok && raw != nil {
+				if err := addCookieValue(out, name, fmt.Sprint(raw)); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func addJSONCookieArrayEntry(out map[string]string, entry map[string]any) error {
+	name, hasName := jsonCookieNameField(entry, "name")
+	value, hasValue := jsonCookieValueField(entry, "value")
+	if !hasName || !hasValue {
+		return errors.New("tracker auth: JSON cookie array entries require name and value")
+	}
+	return addCookieValue(out, name, value)
+}
+
+func jsonCookieNameField(entry map[string]any, key string) (string, bool) {
+	raw, ok := entry[key]
+	if !ok || raw == nil {
+		return "", false
+	}
+	return strings.TrimSpace(fmt.Sprint(raw)), true
+}
+
+func jsonCookieValueField(entry map[string]any, key string) (string, bool) {
+	raw, ok := entry[key]
+	if !ok || raw == nil {
+		return "", false
+	}
+	return fmt.Sprint(raw), true
+}
+
+func addCookieValue(out map[string]string, name string, value string) error {
+	name = strings.TrimSpace(name)
+	if name != "" && value != "" {
+		if _, ok := out[name]; ok {
+			return fmt.Errorf("tracker auth: duplicate cookie name %q", name)
+		}
+		out[name] = value
+	}
+	return nil
+}
+
+// parseNetscapeCookieContent extracts cookie name/value pairs from Netscape
+// cookie lines without scanner token-size limits. Names are trimmed; values are
+// preserved after the value column, including surrounding spaces and tabs.
+func parseNetscapeCookieContent(content string) (map[string]string, error) {
+	out := make(map[string]string)
+	for rawLine := range strings.SplitSeq(content, "\n") {
+		line := strings.TrimSuffix(rawLine, "\r")
+		trimmedLine := strings.TrimSpace(line)
+		if trimmedLine == "" {
+			continue
+		}
+		if strings.HasPrefix(trimmedLine, "#HttpOnly_") {
+			line = line[strings.Index(line, "#HttpOnly_")+len("#HttpOnly_"):]
+		} else if strings.HasPrefix(trimmedLine, "#") {
+			continue
+		}
+		fields := strings.Split(line, "\t")
+		if len(fields) < 7 {
+			continue
+		}
+		name := strings.TrimSpace(fields[5])
+		value := strings.Join(fields[6:], "\t")
+		if name != "" && value != "" {
+			if _, ok := out[name]; ok {
+				return nil, fmt.Errorf("tracker auth: duplicate cookie name %q", name)
+			}
+			out[name] = value
+		}
+	}
+	if len(out) == 0 {
+		return nil, errors.New("tracker auth: cookie content has no entries")
+	}
+	return out, nil
+}
+
+var statusURLRe = regexp.MustCompile(`https?://[^\s"'>)]+`)
+
+func redact(value string) string {
+	redacted := redaction.RedactValue(value, nil)
+	redacted = statusURLRe.ReplaceAllStringFunc(redacted, func(raw string) string {
+		trimmed := strings.TrimRight(raw, ".,;:")
+		suffix := strings.TrimPrefix(raw, trimmed)
+		parsed, err := url.Parse(trimmed)
+		if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+			return raw
+		}
+		if parsed.EscapedPath() == "" && parsed.RawQuery == "" {
+			return raw
+		}
+		return parsed.Scheme + "://" + parsed.Host + "/[REDACTED]" + suffix
+	})
+	return strings.TrimSpace(redacted)
+}
+
+func mustTrackerConfig(cfg config.Config, trackerID string) config.TrackerConfig {
+	trackerCfg, _ := trackerConfig(cfg, trackerID)
+	return trackerCfg
+}
+
+// applyEnsureErrorToStatus maps typed ensure errors onto API status. Confirmed
+// invalid sessions clear the reported cookie count and include recovery action;
+// 2FA is actionable only when a reusable challenge id exists.
+func applyEnsureErrorToStatus(status *api.TrackerAuthStatus, err error) {
+	status.LastError = redact(err.Error())
+	status.Message = "remote auth test failed"
+
+	if isCookieStorageFailure(err) {
+		status.State = StateEncryptedStorageUnavailable
+		status.Message = "cookie storage unavailable; see error details"
+		return
+	}
+
+	var authRequired *AuthRequiredError
+	if errors.As(err, &authRequired) {
+		status.State = StateLoginRequired
+		if validation, ok := asValidationError(err); ok && validation.ConfirmedInvalid {
+			status.CookieCount = 0
+			status.Message = expiredSessionActionMessage
+		} else {
+			status.Message = "login credentials or imported cookies required"
+		}
+		return
+	}
+
+	var needs2FA *Needs2FAError
+	if errors.As(err, &needs2FA) {
+		challengeID := strings.TrimSpace(needs2FA.ChallengeID)
+		if challengeID == "" {
+			status.State = StateLoginRequired
+			status.Needs2FA = false
+			status.ChallengeID = ""
+			status.Message = "2FA required but no manual challenge is available"
+			return
+		}
+		status.Needs2FA = true
+		status.ChallengeID = challengeID
+		status.State = StateLoginRequired
+		status.Message = "2FA required"
+		return
+	}
+
+	var unsupported *UnsupportedAuthError
+	if errors.As(err, &unsupported) {
+		status.Message = "remote auth validation is not supported"
+		return
+	}
+
+	var validation *ValidationError
+	if errors.As(err, &validation) && validation.ConfirmedInvalid {
+		status.State = StateLoginRequired
+		status.CookieCount = 0
+		status.Message = expiredSessionActionMessage
+	}
+}
+
+// isCookieStorageFailure recognizes cookie persistence/load failures that should
+// be exposed as storage-unavailable rather than login-required auth states.
+func isCookieStorageFailure(err error) bool {
+	if err == nil || errors.Is(err, cookies.ErrTrackerCookiesNotFound) {
+		return false
+	}
+	lower := strings.ToLower(err.Error())
+	return strings.Contains(lower, "cookies:") ||
+		strings.Contains(lower, "cookie store") ||
+		strings.Contains(lower, "legacy cookie file")
+}
+
+// CookiesToMap converts HTTP cookies to a name/value map, ignoring nil cookies
+// and blank names or values while preserving cookie value bytes.
+func CookiesToMap(values []*http.Cookie) map[string]string {
+	out := make(map[string]string)
+	for _, cookie := range values {
+		if cookie == nil {
+			continue
+		}
+		name := strings.TrimSpace(cookie.Name)
+		value := cookie.Value
+		if name != "" && value != "" {
+			out[name] = value
+		}
+	}
+	return out
+}
+
+// ReadCookieImportContent reads at most [MaxCookieImportContentBytes] from r and
+// returns the shared parser cap error before allocating a larger payload.
+func ReadCookieImportContent(r io.Reader) (string, error) {
+	if r == nil {
+		return "", errors.New("tracker auth: cookie file content is required")
+	}
+	limited := io.LimitReader(r, MaxCookieImportContentBytes+1)
+	payload, err := io.ReadAll(limited)
+	if err != nil {
+		return "", fmt.Errorf("tracker auth: read cookie file content: %w", err)
+	}
+	if len(payload) > MaxCookieImportContentBytes {
+		return "", fmt.Errorf("tracker auth: cookie file content exceeds %d byte limit", MaxCookieImportContentBytes)
+	}
+	return string(payload), nil
+}
+
+// contextWithoutCancel preserves context values for rollback work while
+// detaching cancellation and deadline state.
+func contextWithoutCancel(ctx context.Context) context.Context {
+	if ctx == nil {
+		return context.Background()
+	}
+	return context.WithoutCancel(ctx)
+}
diff --git a/internal/trackers/auth/service_test.go b/internal/trackers/auth/service_test.go
new file mode 100644
index 00000000..7287a65f
--- /dev/null
+++ b/internal/trackers/auth/service_test.go
@@ -0,0 +1,2465 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/btn"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/mtv"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ptp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/rtf"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/thr"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func newTestService(cfg config.Config) *Service {
+	return newTestServiceWithLogger(cfg, api.NopLogger{})
+}
+
+func newTestServiceWithLogger(cfg config.Config, logger api.Logger) *Service {
+	registry := trackers.NewRegistry()
+	for _, definition := range []trackers.Definition{btn.New(), mtv.New(), ptp.New(), rtf.New(), thr.New()} {
+		if err := registry.Register(definition); err != nil {
+			panic(err)
+		}
+	}
+	for _, capability := range []api.TrackerAuthCapability{
+		{
+			TrackerID:          "AR",
+			DisplayName:        "AR",
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		{
+			TrackerID:          "ASC",
+			DisplayName:        "ASC",
+			AuthKind:           "cookies",
+			SupportsCookieFile: true,
+		},
+		{
+			TrackerID:          "FF",
+			DisplayName:        "FF",
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		{
+			TrackerID:          "FL",
+			DisplayName:        "FL",
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		{
+			TrackerID:          "HDB",
+			DisplayName:        "HDB",
+			AuthKind:           "passkey_cookies",
+			SupportsCookieFile: true,
+			RequiresPasskey:    true,
+		},
+	} {
+		definition := authRegistryDefinition{capability: capability}
+		switch capability.TrackerID {
+		case "AR":
+			definition.stateManager = NewKeyedFileStateManager("AR", "auth_key", "AR_auth.txt")
+		case "HDB":
+			definition.policy = &trackers.AuthPolicy{PasskeyRequiresUsername: true, PasskeyRequiresCookie: true}
+		}
+		if err := registry.Register(definition); err != nil {
+			panic(err)
+		}
+	}
+	return NewServiceWithRegistryAndLogger(cfg, registry, logger)
+}
+
+type authRegistryDefinition struct {
+	capability   api.TrackerAuthCapability
+	policy       *trackers.AuthPolicy
+	stateManager trackers.AuthStateManager
+}
+
+func (d authRegistryDefinition) Name() string { return d.capability.TrackerID }
+
+func (authRegistryDefinition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+
+func (authRegistryDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+
+func (authRegistryDefinition) Prepare(context.Context, trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.TrackerPlan{}, nil
+}
+
+func (d authRegistryDefinition) AuthCapability() api.TrackerAuthCapability { return d.capability }
+
+func (d authRegistryDefinition) AuthPolicy() *trackers.AuthPolicy { return d.policy }
+
+func (d authRegistryDefinition) AuthStateManager() trackers.AuthStateManager { return d.stateManager }
+
+type trackerAuthRecordingLogger struct {
+	api.NopLogger
+	info  []string
+	trace []string
+	warn  []string
+}
+
+func (l *trackerAuthRecordingLogger) Infof(format string, args ...any) {
+	l.info = append(l.info, fmt.Sprintf(format, args...))
+}
+
+func (l *trackerAuthRecordingLogger) Tracef(format string, args ...any) {
+	l.trace = append(l.trace, fmt.Sprintf(format, args...))
+}
+
+func (l *trackerAuthRecordingLogger) Warnf(format string, args ...any) {
+	l.warn = append(l.warn, fmt.Sprintf(format, args...))
+}
+
+func TestLoginCreatesManual2FAChallengeBeforeReturning(t *testing.T) {
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "PTP"}
+		},
+	}
+	loginService := newTestService(cfg)
+	loginService.adapters = map[string]Adapter{"PTP": adapter}
+
+	status, err := loginService.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if !status.Needs2FA || strings.TrimSpace(status.ChallengeID) == "" {
+		t.Fatalf("expected active 2FA challenge, got %#v", status)
+	}
+
+	submitService := newTestService(cfg)
+	submitService.adapters = map[string]Adapter{"PTP": adapter}
+	status, err = submitService.Submit2FA(context.Background(), status.ChallengeID, "123456")
+	if err != nil {
+		t.Fatalf("Submit2FA with challenge from separate service: %v", err)
+	}
+	if status.Needs2FA || status.ChallengeID != "" || status.Message != "2FA auth completed" {
+		t.Fatalf("unexpected submit status: %#v", status)
+	}
+}
+
+func TestBTNCapabilityAndLocalStatusSemantics(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	cfg := config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Metadata:     config.MetadataConfig{BTNAPI: "legacy-token"},
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"BTN": {},
+		}},
+	}
+	service := newTestService(cfg)
+	caps, err := service.Capabilities(ctx)
+	if err != nil {
+		t.Fatalf("Capabilities: %v", err)
+	}
+	var btnCap api.TrackerAuthCapability
+	for _, cap := range caps {
+		if cap.TrackerID == "BTN" {
+			btnCap = cap
+			break
+		}
+	}
+	if btnCap.TrackerID == "" {
+		t.Fatal("expected BTN capability")
+	}
+	if !btnCap.RequiresAPIKey || !btnCap.SupportsCookieFile || !btnCap.SupportsLogin || !btnCap.SupportsAutoLogin || !btnCap.SupportsTOTP || !btnCap.SupportsManual2FA ||
+		!btnCap.SupportsRemoteValidation {
+		t.Fatalf("unexpected BTN capability: %#v", btnCap)
+	}
+
+	status, err := service.Status(ctx, "BTN")
+	if err != nil {
+		t.Fatalf("Status api-key only: %v", err)
+	}
+	if status.State != StateLoginRequired && status.State != StateNotConfigured {
+		t.Fatalf("BTN API-key-only must not be upload-ready, got %#v", status)
+	}
+	if !strings.Contains(status.Message, "imported cookies or login credentials required") {
+		t.Fatalf("expected upload-auth message, got %#v", status)
+	}
+
+	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{Username: "user", Password: "pass"}
+	service = newTestService(cfg)
+	status, err = service.Status(ctx, "BTN")
+	if err != nil {
+		t.Fatalf("Status credentials: %v", err)
+	}
+	if status.State != StateConfigured {
+		t.Fatalf("expected BTN API key plus credentials configured, got %#v", status)
+	}
+
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{}
+	service = newTestService(cfg)
+	status, err = service.Status(ctx, "BTN")
+	if err != nil {
+		t.Fatalf("Status cookies: %v", err)
+	}
+	if status.State != StateHasCookies || status.CookieCount != 1 {
+		t.Fatalf("expected BTN stored cookies to remain local has_cookies, got %#v", status)
+	}
+
+	cfg.Metadata.BTNAPI = ""
+	cfg.Trackers.Trackers["BTN"] = config.TrackerConfig{Username: "user", Password: "pass"}
+	service = newTestService(cfg)
+	status, err = service.Status(ctx, "BTN")
+	if err != nil {
+		t.Fatalf("Status missing API key: %v", err)
+	}
+	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected missing API key to block BTN upload readiness, got %#v", status)
+	}
+
+	cfg.MainSettings.DBPath = filepath.Join(t.TempDir(), "missing-auth", "upbrr.db")
+	service = newTestService(cfg)
+	status, err = service.Status(ctx, "BTN")
+	if err != nil {
+		t.Fatalf("Status missing API key without encrypted storage: %v", err)
+	}
+	if status.State != StateLoginRequired || status.EncryptedStorage || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected missing API key to take precedence over encrypted storage, got %#v", status)
+	}
+}
+
+func TestSubmit2FARetriesAdapterLoginWithCurrentConfigAndCode(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	cfg := config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {
+					Username:    "user",
+					Password:    "pass",
+					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+				},
+			},
+		},
+	}
+	var gotCode, gotDBPath, gotUsername string
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "PTP"}
+		},
+		submit: func(_ context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error) {
+			gotCode = req.Code
+			gotDBPath = dbPath
+			gotUsername = cfg.Username
+			return Session{TrackerID: "PTP", State: SessionStateReady}, nil
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"PTP": adapter}
+
+	status, err := service.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if strings.TrimSpace(status.ChallengeID) == "" {
+		t.Fatalf("expected challenge: %#v", status)
+	}
+	if _, err := service.Submit2FA(context.Background(), status.ChallengeID, "654321"); err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if gotCode != "654321" || gotDBPath != dbPath || gotUsername != "user" {
+		t.Fatalf("unexpected adapter retry args code=%q db=%q username=%q", gotCode, gotDBPath, gotUsername)
+	}
+}
+
+func TestSubmit2FABTNSuccessPreservesMissingAPIStatus(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	cfg := config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"BTN": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	var gotCode string
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "BTN",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "BTN"}
+		},
+		submit: func(_ context.Context, _ config.TrackerConfig, _ string, req api.TrackerAuthLoginRequest) (Session, error) {
+			gotCode = req.Code
+			return Session{TrackerID: "BTN", State: SessionStateReady}, nil
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"BTN": adapter}
+
+	status, err := service.Login(context.Background(), "BTN", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if strings.TrimSpace(status.ChallengeID) == "" {
+		t.Fatalf("expected challenge: %#v", status)
+	}
+	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "654321")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if gotCode != "654321" {
+		t.Fatalf("unexpected submitted code %q", gotCode)
+	}
+	if status.Needs2FA || status.ChallengeID != "" {
+		t.Fatalf("expected challenge cleared after successful submit, got %#v", status)
+	}
+	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected successful BTN 2FA to preserve missing API status, got %#v", status)
+	}
+}
+
+func TestSubmit2FAFailureKeepsChallengeRetryVisible(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {
+					Username:    "user",
+					Password:    "pass",
+					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+				},
+			},
+		},
+	}
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "PTP"}
+		},
+		submit: func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) (Session, error) {
+			return Session{}, &ValidationError{
+				TrackerID:            "PTP",
+				Transient:            true,
+				Submitted2FARejected: true,
+				Err:                  errors.New("login failed"),
+			}
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"PTP": adapter}
+
+	status, err := service.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if !status.Needs2FA || strings.TrimSpace(status.ChallengeID) == "" {
+		t.Fatalf("expected retry-visible challenge after failed code, got %#v", status)
+	}
+	if status.State != StateLoginRequired || !strings.Contains(status.Message, "enter a new 2FA code") {
+		t.Fatalf("expected failed 2FA status to include mode and required action, got %#v", status)
+	}
+}
+
+func TestSubmit2FATransientSubmittedCodeFailureKeepsChallengeRetryVisible(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {
+					Username:    "user",
+					Password:    "pass",
+					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+				},
+			},
+		},
+	}
+	service := newTestService(cfg)
+	service.challenges = NewChallengeManager(defaultChallengeTTL)
+	service.adapters = map[string]Adapter{
+		"PTP": trackerAdapter{
+			capability: api.TrackerAuthCapability{
+				TrackerID:         "PTP",
+				SupportsLogin:     true,
+				SupportsManual2FA: true,
+			},
+			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
+				if login.Code != "000000" {
+					t.Fatalf("expected submitted code, got %q", login.Code)
+				}
+				return fmt.Errorf("trackers: PTP login failed: %w", ptp.ErrSubmitted2FARejected)
+			},
+		},
+	}
+	ownerKey, err := service.challengeOwnerKey("PTP")
+	if err != nil {
+		t.Fatalf("challengeOwnerKey: %v", err)
+	}
+	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
+
+	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if !status.Needs2FA || status.ChallengeID != challengeID {
+		t.Fatalf("expected retry-visible challenge after classified failed code, got %#v", status)
+	}
+	if status.State != StateLoginRequired || !strings.Contains(status.Message, "enter a new 2FA code") {
+		t.Fatalf("expected failed 2FA status to include mode and required action, got %#v", status)
+	}
+	if _, ok := service.challenges.Get(challengeID); !ok {
+		t.Fatal("failed submitted code consumed challenge")
+	}
+}
+
+func TestSubmit2FAPreCodeLoginFailureDoesNotExposeRetryChallenge(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {
+					Username:    "user",
+					Password:    "pass",
+					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+				},
+			},
+		},
+	}
+	service := newTestService(cfg)
+	service.challenges = NewChallengeManager(defaultChallengeTTL)
+	service.adapters = map[string]Adapter{
+		"PTP": trackerAdapter{
+			capability: api.TrackerAuthCapability{
+				TrackerID:         "PTP",
+				SupportsLogin:     true,
+				SupportsManual2FA: true,
+			},
+			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
+				if login.Code != "000000" {
+					t.Fatalf("expected submitted code, got %q", login.Code)
+				}
+				return errors.New("trackers: PTP login failed")
+			},
+		},
+	}
+	ownerKey, err := service.challengeOwnerKey("PTP")
+	if err != nil {
+		t.Fatalf("challengeOwnerKey: %v", err)
+	}
+	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
+
+	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
+		t.Fatalf("pre-code login failure must not expose retry challenge: %#v", status)
+	}
+	if !strings.Contains(status.LastError, "login failed") {
+		t.Fatalf("expected login failure in status, got %#v", status)
+	}
+}
+
+func TestSubmit2FAConfirmedInvalidFailureDoesNotExposeRetryChallenge(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {
+					Username:    "user",
+					Password:    "pass",
+					AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+				},
+			},
+		},
+	}
+	service := newTestService(cfg)
+	service.challenges = NewChallengeManager(defaultChallengeTTL)
+	service.adapters = map[string]Adapter{
+		"PTP": trackerAdapter{
+			capability: api.TrackerAuthCapability{
+				TrackerID:         "PTP",
+				SupportsLogin:     true,
+				SupportsManual2FA: true,
+			},
+			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
+				if login.Code != "000000" {
+					t.Fatalf("expected submitted code, got %q", login.Code)
+				}
+				return &ValidationError{
+					TrackerID:            "PTP",
+					ConfirmedInvalid:     true,
+					Submitted2FARejected: true,
+					Err:                  errors.New("login failed"),
+				}
+			},
+		},
+	}
+	ownerKey, err := service.challengeOwnerKey("PTP")
+	if err != nil {
+		t.Fatalf("challengeOwnerKey: %v", err)
+	}
+	challengeID := service.challenges.Create(context.Background(), "PTP", ownerKey)
+
+	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
+		t.Fatalf("confirmed-invalid failure must not expose retry challenge: %#v", status)
+	}
+}
+
+func TestSubmit2FAMTVSubmittedCodeAuthKeyFailureKeepsChallengeRetryVisible(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"MTV": {
+					Username: "user",
+					Password: "pass",
+				},
+			},
+		},
+	}
+	service := newTestService(cfg)
+	service.challenges = NewChallengeManager(defaultChallengeTTL)
+	service.adapters = map[string]Adapter{
+		"MTV": trackerAdapter{
+			capability: api.TrackerAuthCapability{
+				TrackerID:         "MTV",
+				SupportsLogin:     true,
+				SupportsManual2FA: true,
+			},
+			resolve: func(_ context.Context, _ config.TrackerConfig, _ string, login api.TrackerAuthLoginRequest) error {
+				if login.Code != "000000" {
+					t.Fatalf("expected submitted code, got %q", login.Code)
+				}
+				return fmt.Errorf("trackers: MTV auth key not found: %w", mtv.ErrSubmitted2FARejected)
+			},
+		},
+	}
+	ownerKey, err := service.challengeOwnerKey("MTV")
+	if err != nil {
+		t.Fatalf("challengeOwnerKey: %v", err)
+	}
+	challengeID := service.challenges.Create(context.Background(), "MTV", ownerKey)
+
+	status, err := service.Submit2FA(context.Background(), challengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if !status.Needs2FA || status.ChallengeID != challengeID {
+		t.Fatalf("expected retry-visible MTV challenge after auth-key miss, got %#v", status)
+	}
+	if _, ok := service.challenges.Get(challengeID); !ok {
+		t.Fatal("failed MTV submitted code consumed challenge")
+	}
+}
+
+func TestSubmit2FATransientParserFailureDoesNotExposeRetryChallenge(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"MTV": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "MTV",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "MTV"}
+		},
+		submit: func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) (Session, error) {
+			return Session{}, classifyAdapterError("MTV", errors.New("trackers: MTV 2FA token not found"))
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"MTV": adapter}
+
+	status, err := service.Login(context.Background(), "MTV", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	status, err = service.Submit2FA(context.Background(), status.ChallengeID, "000000")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
+		t.Fatalf("transient parser failure must not expose retry challenge: %#v", status)
+	}
+	if !strings.Contains(status.LastError, "2FA token not found") {
+		t.Fatalf("expected parser failure in status, got %#v", status)
+	}
+}
+
+func TestSubmit2FARejectsChallengeAfterTrackerConfigReplacement(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		validate: func() (Session, error) {
+			return Session{}, &Needs2FAError{TrackerID: "PTP"}
+		},
+	}
+	loginService := newTestService(cfg)
+	loginService.adapters = map[string]Adapter{"PTP": adapter}
+
+	status, err := loginService.Login(context.Background(), "PTP", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+
+	replacedCfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {Username: "other", Password: "pass"},
+			},
+		},
+	}
+	submitService := newTestService(replacedCfg)
+	submitService.adapters = map[string]Adapter{"PTP": adapter}
+	_, err = submitService.Submit2FA(context.Background(), status.ChallengeID, "123456")
+	if err == nil {
+		t.Fatal("expected stale challenge error")
+	}
+	if !strings.Contains(err.Error(), "stale manual 2FA challenge") {
+		t.Fatalf("expected stale challenge error, got %v", err)
+	}
+}
+
+func TestSubmit2FAUsesCanceledContextWithoutConsumingChallenge(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"PTP": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	challenges := NewChallengeManager(defaultChallengeTTL)
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{
+			TrackerID:         "PTP",
+			SupportsLogin:     true,
+			SupportsManual2FA: true,
+		},
+		submit: func(ctx context.Context, _ config.TrackerConfig, _ string, _ api.TrackerAuthLoginRequest) (Session, error) {
+			return Session{}, ctx.Err()
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"PTP": adapter}
+	service.challenges = challenges
+	ownerKey, err := service.challengeOwnerKey("PTP")
+	if err != nil {
+		t.Fatalf("challengeOwnerKey: %v", err)
+	}
+	challengeID := challenges.Create(context.Background(), "PTP", ownerKey)
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	status, err := service.Submit2FA(ctx, challengeID, "123456")
+	if err != nil {
+		t.Fatalf("Submit2FA: %v", err)
+	}
+	if !strings.Contains(status.LastError, "context canceled") {
+		t.Fatalf("expected context canceled status, got %#v", status)
+	}
+	if _, ok := challenges.Get(challengeID); !ok {
+		t.Fatal("canceled 2FA submit consumed the challenge")
+	}
+}
+
+func TestLoginMissingCredentialsReturnsLoginRequiredWithoutChallenge(t *testing.T) {
+	t.Parallel()
+
+	status, err := newTestService(config.Config{}).Login(
+		context.Background(),
+		"PTP",
+		api.TrackerAuthLoginRequest{},
+	)
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if status.State != StateLoginRequired {
+		t.Fatalf("expected login required status, got %#v", status)
+	}
+	if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
+		t.Fatalf("missing credentials must not create manual 2FA challenge: %#v", status)
+	}
+}
+
+func TestLoginBTNCredentialsWithoutAPIAttemptsSessionValidation(t *testing.T) {
+	t.Parallel()
+
+	cfg := config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"BTN": {Username: "user", Password: "pass"},
+			},
+		},
+	}
+	adapter := &fakeAdapter{
+		capability: api.TrackerAuthCapability{TrackerID: "BTN", SupportsLogin: true},
+		validate: func() (Session, error) {
+			return Session{}, &AuthRequiredError{TrackerID: "BTN", Reason: "login required"}
+		},
+		login: func() (Session, error) {
+			return Session{TrackerID: "BTN", State: SessionStateReady}, nil
+		},
+	}
+	service := newTestService(cfg)
+	service.adapters = map[string]Adapter{"BTN": adapter}
+
+	status, err := service.Login(context.Background(), "BTN", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if adapter.validateCalls != 1 || adapter.loginCalls != 1 {
+		t.Fatalf("expected BTN session validation and login, got validate=%d login=%d", adapter.validateCalls, adapter.loginCalls)
+	}
+	if status.State != StateLoginRequired || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected successful BTN login to preserve missing API status, got %#v", status)
+	}
+}
+
+func TestLoginBTNCookiesWithoutAPIPreservesMissingAPIStatus(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+
+	status, err := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+	}).Login(ctx, "BTN", api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("Login: %v", err)
+	}
+	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected BTN cookie-only login to preserve missing API status, got %#v", status)
+	}
+	if strings.Contains(status.Message, "username/password missing") {
+		t.Fatalf("missing credentials masked missing API status: %#v", status)
+	}
+}
+
+func TestStatusConfiguredOTPURIAvoidsManualChallenge(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]config.TrackerConfig{
+		"configured otp uri": {
+			Username:    "user",
+			Password:    "pass",
+			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+			OTPURI:      "otpauth://totp/PTP:user?secret=ABC",
+		},
+		"missing otp uri": {
+			Username:    "user",
+			Password:    "pass",
+			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+		},
+	}
+	for name, trackerCfg := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			service := newTestService(config.Config{
+				Trackers: config.TrackersConfig{
+					Trackers: map[string]config.TrackerConfig{
+						"PTP": trackerCfg,
+					},
+				},
+			})
+			status := service.statusForSpec(context.Background(), trackerSpec{
+				id:               "PTP",
+				login:            true,
+				totp:             true,
+				manual2FA:        true,
+				needsCredentials: true,
+			})
+			if status.State != StateConfigured {
+				t.Fatalf("expected configured status, got %#v", status)
+			}
+			if status.Needs2FA || strings.TrimSpace(status.ChallengeID) != "" {
+				t.Fatalf("status-only config must not expose manual challenge path: %#v", status)
+			}
+		})
+	}
+}
+
+func TestStatusPTPRequiresAnnounceURLForConfiguredLogin(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		cfg       config.TrackerConfig
+		wantState string
+	}{
+		"missing announce": {
+			cfg:       config.TrackerConfig{Username: "user", Password: "pass"},
+			wantState: StateLoginRequired,
+		},
+		"blank announce": {
+			cfg: config.TrackerConfig{
+				Username:    "user",
+				Password:    "pass",
+				AnnounceURL: " \t\n ",
+			},
+			wantState: StateLoginRequired,
+		},
+		"complete login config": {
+			cfg: config.TrackerConfig{
+				Username:    "user",
+				Password:    "pass",
+				AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+			},
+			wantState: StateConfigured,
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			service := newTestService(config.Config{
+				MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
+				Trackers: config.TrackersConfig{
+					Trackers: map[string]config.TrackerConfig{"PTP": tt.cfg},
+				},
+			})
+			status, err := service.Status(context.Background(), "PTP")
+			if err != nil {
+				t.Fatalf("Status: %v", err)
+			}
+			if status.State != tt.wantState {
+				t.Fatalf("expected %s state, got %#v", tt.wantState, status)
+			}
+		})
+	}
+}
+
+func TestStatusPTPCookiesRemainConfiguredWithoutAnnounceURL(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{"PTP": {Username: "user", Password: "pass"}},
+		},
+	})
+
+	status, err := service.Status(ctx, "PTP")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateHasCookies || status.CookieCount != 1 {
+		t.Fatalf("expected stored PTP cookies to remain usable without announce URL, got %#v", status)
+	}
+}
+
+func TestStatusConfiguredAuthReportsEncryptedStorageUnavailableWhenPersistenceRequired(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		cfg       config.TrackerConfig
+		spec      trackerSpec
+		wantState string
+	}{
+		"MTV api key only": {
+			cfg:       config.TrackerConfig{APIKey: "api-key"},
+			wantState: StateEncryptedStorageUnavailable,
+			spec: trackerSpec{
+				id:               "MTV",
+				cookies:          true,
+				apiKey:           true,
+				needsCredentials: true,
+				policy: trackers.AuthPolicy{
+					APIKeyRequiresUploadSession: true,
+					CookieCompletesAPIKeyAuth:   true,
+					UploadSessionMissingMessage: "API key covers Torznab/search; imported cookies or login credentials required for upload auth",
+				},
+			},
+		},
+		"credentials": {
+			cfg:       config.TrackerConfig{Username: "user", Password: "pass"},
+			wantState: StateEncryptedStorageUnavailable,
+			spec: trackerSpec{
+				id:               "AR",
+				cookies:          true,
+				login:            true,
+				needsCredentials: true,
+			},
+		},
+		"passkey": {
+			cfg:       config.TrackerConfig{Passkey: "passkey"},
+			wantState: StateEncryptedStorageUnavailable,
+			spec: trackerSpec{
+				id:      "HDB",
+				cookies: true,
+				passkey: true,
+			},
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			service := newTestService(config.Config{
+				MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")},
+				Trackers: config.TrackersConfig{
+					Trackers: map[string]config.TrackerConfig{tt.spec.id: tt.cfg},
+				},
+			})
+			status := service.statusForSpec(context.Background(), tt.spec)
+			if status.State != tt.wantState {
+				t.Fatalf("expected %s state, got %#v", tt.wantState, status)
+			}
+			if status.EncryptedStorage {
+				t.Fatalf("expected storage availability to remain visible as false: %#v", status)
+			}
+			if !strings.Contains(status.Message, "encrypted cookie storage unavailable") {
+				t.Fatalf("expected storage-specific message, got %#v", status)
+			}
+		})
+	}
+}
+
+func TestStatusStateMessageParityForAuthBlockers(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		dbPath      string
+		cfg         config.Config
+		spec        trackerSpec
+		wantState   string
+		wantMessage string
+	}{
+		"not configured": {
+			dbPath:      newTrackerAuthTestDB(t),
+			spec:        trackerSpec{id: "ASC", cookies: true},
+			wantState:   StateNotConfigured,
+			wantMessage: "auth material not configured",
+		},
+		"login required": {
+			dbPath: newTrackerAuthTestDB(t),
+			spec: trackerSpec{
+				id:               "PTP",
+				cookies:          true,
+				login:            true,
+				needsCredentials: true,
+			},
+			wantState:   StateLoginRequired,
+			wantMessage: "login credentials or imported cookies required",
+		},
+		"encrypted storage unavailable": {
+			dbPath:      filepath.Join(t.TempDir(), "missing-auth", "upbrr.db"),
+			spec:        trackerSpec{id: "ASC", cookies: true},
+			wantState:   StateEncryptedStorageUnavailable,
+			wantMessage: "encrypted cookie storage unavailable; create web-auth.json before importing cookies",
+		},
+		"api key still needs upload auth": {
+			dbPath: newTrackerAuthTestDB(t),
+			cfg: config.Config{
+				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"MTV": {APIKey: "api-key"}}},
+			},
+			spec: trackerSpec{
+				id:               "MTV",
+				cookies:          true,
+				login:            true,
+				apiKey:           true,
+				needsCredentials: true,
+				policy: trackers.AuthPolicy{
+					APIKeyRequiresUploadSession: true,
+					CookieCompletesAPIKeyAuth:   true,
+					UploadSessionMissingMessage: "API key covers Torznab/search; imported cookies or login credentials required for upload auth",
+				},
+			},
+			wantState:   StateLoginRequired,
+			wantMessage: "API key covers Torznab/search; imported cookies or login credentials required for upload auth",
+		},
+		"btn missing api key": {
+			dbPath: newTrackerAuthTestDB(t),
+			cfg: config.Config{
+				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BTN": {Username: "user", Password: "pass"}}},
+			},
+			spec: trackerSpec{
+				id:               "BTN",
+				cookies:          true,
+				login:            true,
+				apiKey:           true,
+				needsCredentials: true,
+				policy: trackers.AuthPolicy{
+					APIKeyRequiresUploadSession: true,
+					MissingAPIKeyMessage:        "API key is required for torrent resolution; imported cookies or login credentials cover upload auth",
+				},
+			},
+			wantState:   StateLoginRequired,
+			wantMessage: "API key is required for torrent resolution; imported cookies or login credentials cover upload auth",
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			cfg := tt.cfg
+			cfg.MainSettings.DBPath = tt.dbPath
+			service := newTestService(cfg)
+			status := service.statusForSpec(context.Background(), tt.spec)
+			if status.State != tt.wantState {
+				t.Fatalf("expected state %q, got %#v", tt.wantState, status)
+			}
+			if status.Message != tt.wantMessage {
+				t.Fatalf("expected message %q for state %q, got %#v", tt.wantMessage, tt.wantState, status)
+			}
+		})
+	}
+}
+
+func TestStatusCookieReadErrorStaysDistinctFromMissingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("OpenWithLoggerContext: %v", err)
+	}
+	defer repo.Close()
+	if _, err := repo.RawDB().ExecContext(ctx, `UPDATE tracker_cookies SET encrypted_value = ? WHERE tracker_id = ?`, "not-base64", "PTP"); err != nil {
+		t.Fatalf("corrupt cookie row: %v", err)
+	}
+
+	status, err := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+	}).Status(ctx, "PTP")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.LastError == "" {
+		t.Fatalf("expected cookie read error detail, got %#v", status)
+	}
+	if strings.Contains(status.LastError, "no cookies found") {
+		t.Fatalf("cookie read error was reported as missing cookies: %#v", status)
+	}
+
+	missingStatus, err := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
+	}).Status(ctx, "PTP")
+	if err != nil {
+		t.Fatalf("Status missing cookies: %v", err)
+	}
+	if missingStatus.LastError != "" {
+		t.Fatalf("missing cookies must not populate LastError, got %#v", missingStatus)
+	}
+}
+
+func TestStatusCookieParseErrorStaysDistinctFromMissingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	jsonPath := trackerAuthLegacyCookiePathByExt(t, dbPath, "PTP", ".json")
+	if err := os.MkdirAll(filepath.Dir(jsonPath), 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+	if err := os.WriteFile(jsonPath, []byte(`{"session":`), 0o600); err != nil {
+		t.Fatalf("write malformed cookie file: %v", err)
+	}
+
+	status, err := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+	}).Status(ctx, "PTP")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.LastError == "" {
+		t.Fatalf("expected cookie parse error detail, got %#v", status)
+	}
+	if strings.Contains(status.LastError, "no cookies found") {
+		t.Fatalf("cookie parse error was reported as missing cookies: %#v", status)
+	}
+	if !strings.Contains(status.LastError, "parse") && !strings.Contains(status.LastError, "unmarshal") {
+		t.Fatalf("expected parse detail, got %#v", status)
+	}
+}
+
+func TestStatusConfiguredAuthReportsCoexistingCookies(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		trackerID string
+		cfg       config.TrackerConfig
+	}{
+		"api key": {trackerID: "MTV", cfg: config.TrackerConfig{APIKey: "api-key"}},
+		"passkey": {trackerID: "HDB", cfg: config.TrackerConfig{Username: "user", Passkey: "passkey"}},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := context.Background()
+			dbPath := newTrackerAuthTestDB(t)
+			if err := cookies.SaveTrackerCookieMap(ctx, dbPath, tt.trackerID, map[string]string{"session": "abc"}); err != nil {
+				t.Fatalf("SaveTrackerCookieMap: %v", err)
+			}
+			service := newTestService(config.Config{
+				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+				Trackers: config.TrackersConfig{
+					Trackers: map[string]config.TrackerConfig{tt.trackerID: tt.cfg},
+				},
+			})
+
+			status, err := service.Status(ctx, tt.trackerID)
+			if err != nil {
+				t.Fatalf("Status: %v", err)
+			}
+			if status.State != StateConfigured || status.CookieCount != 1 {
+				t.Fatalf("expected configured state with cookie count, got %#v", status)
+			}
+			if !strings.Contains(status.Message, "stored cookie") {
+				t.Fatalf("expected message to preserve cookie presence, got %#v", status)
+			}
+		})
+	}
+}
+
+func TestStatusHDBPasskeyWithoutCookiesIsNotUploadReady(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{"HDB": {Username: "user", Passkey: "passkey"}},
+		},
+	})
+
+	status, err := service.Status(context.Background(), "HDB")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateLoginRequired {
+		t.Fatalf("expected HDB cookie import requirement, got %#v", status)
+	}
+}
+
+func TestStatusMTVAPIKeyOnlyReportsUploadNotReady(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{"MTV": {APIKey: "api-key"}},
+		},
+	})
+
+	status, err := service.Status(context.Background(), "MTV")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateLoginRequired {
+		t.Fatalf("expected upload auth to be login-required, got %#v", status)
+	}
+	if !strings.Contains(status.Message, "API key covers Torznab/search") || !strings.Contains(status.Message, "required for upload auth") {
+		t.Fatalf("expected split search/upload message, got %#v", status)
+	}
+}
+
+func TestStatusMTVCredentialsWithoutAPIKeyRemainUploadReady(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{"MTV": {Username: "user", Password: "pass"}},
+		},
+	})
+
+	status, err := service.Status(context.Background(), "MTV")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateConfigured {
+		t.Fatalf("expected MTV credentials to remain upload-ready, got %#v", status)
+	}
+}
+
+func TestStatusCookiesOnlyReportsEncryptedStorageUnavailable(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")},
+	})
+	status := service.statusForSpec(context.Background(), trackerSpec{
+		id:      "ASC",
+		cookies: true,
+	})
+	if status.State != StateEncryptedStorageUnavailable {
+		t.Fatalf("expected encrypted storage unavailable, got %#v", status)
+	}
+	if status.EncryptedStorage {
+		t.Fatalf("expected storage availability to remain visible as false: %#v", status)
+	}
+}
+
+func TestRTFStatusTreatsCredentialsAsRefreshAuth(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"RTF": {Username: "user", Password: "pass"},
+			},
+		},
+	})
+
+	status, err := service.Status(context.Background(), "RTF")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateConfigured {
+		t.Fatalf("RTF credentials should report refresh auth configured without api_key: %#v", status)
+	}
+}
+
+func TestTHRDoesNotAdvertiseCookieImport(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{})
+	caps, err := service.Capabilities(context.Background())
+	if err != nil {
+		t.Fatalf("Capabilities: %v", err)
+	}
+	for _, cap := range caps {
+		if cap.TrackerID != "THR" {
+			continue
+		}
+		if cap.SupportsCookieFile {
+			t.Fatalf("THR upload logs in per request and must not advertise DB cookie import: %#v", cap)
+		}
+		return
+	}
+	t.Fatal("THR capability not found")
+}
+
+func TestFFAdvertisesCookieImportWithRemoteLoginAction(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{})
+	caps, err := service.Capabilities(context.Background())
+	if err != nil {
+		t.Fatalf("Capabilities: %v", err)
+	}
+	for _, cap := range caps {
+		if cap.TrackerID != "FF" {
+			continue
+		}
+		if !cap.SupportsCookieFile {
+			t.Fatalf("FF upload can use DB cookies and must advertise cookie import: %#v", cap)
+		}
+		if !cap.SupportsLogin || !cap.SupportsAutoLogin {
+			t.Fatalf("FF tracker-auth adapter must advertise login actions: %#v", cap)
+		}
+		return
+	}
+	t.Fatal("FF capability not found")
+}
+
+func TestValidateWithoutAdapterReportsUnsupportedRemoteValidation(t *testing.T) {
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"ASC": {},
+			},
+		},
+	}
+	status, err := newTestService(cfg).Validate(context.Background(), "ASC")
+	if err != nil {
+		t.Fatalf("Validate: %v", err)
+	}
+	if strings.Contains(status.Message, "succeeded") {
+		t.Fatalf("unexpected remote success message: %#v", status)
+	}
+	if !strings.Contains(status.Message, "not supported") {
+		t.Fatalf("expected unsupported remote validation message, got %#v", status)
+	}
+}
+
+func TestParseCookieContentJSONMap(t *testing.T) {
+	got, err := ParseCookieContent("MTV.json", `{"session":"abc","nested":{"value":"def"}}`)
+	if err != nil {
+		t.Fatalf("ParseCookieContent: %v", err)
+	}
+	if got["session"] != "abc" || got["nested"] != "def" {
+		t.Fatalf("unexpected cookies: %#v", got)
+	}
+}
+
+func TestParseCookieContentJSONArray(t *testing.T) {
+	got, err := ParseCookieContent("PTP.json", `[
+		{"domain":".example.test","name":"session","value":"abc"},
+		{"name":"token","value":"latest"},
+		{"name":"empty","value":""},
+		{"name":"","value":"ignored"}
+	]`)
+	if err != nil {
+		t.Fatalf("ParseCookieContent: %v", err)
+	}
+	if got["session"] != "abc" || got["token"] != "latest" {
+		t.Fatalf("unexpected cookies: %#v", got)
+	}
+	if _, ok := got["empty"]; ok {
+		t.Fatalf("empty cookie value should be ignored: %#v", got)
+	}
+}
+
+func TestParseCookieContentJSONArrayWithoutJSONExtension(t *testing.T) {
+	got, err := ParseCookieContent("PTP.txt", `[
+		{"domain":".example.test","name":"session","value":"abc"}
+	]`)
+	if err != nil {
+		t.Fatalf("ParseCookieContent: %v", err)
+	}
+	if got["session"] != "abc" {
+		t.Fatalf("unexpected cookies: %#v", got)
+	}
+}
+
+func TestParseCookieContentNetscape(t *testing.T) {
+	got, err := ParseCookieContent("PTP.txt", ".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n")
+	if err != nil {
+		t.Fatalf("ParseCookieContent: %v", err)
+	}
+	if got["session"] != "abc" {
+		t.Fatalf("unexpected cookies: %#v", got)
+	}
+}
+
+func TestParseCookieContentRejectsTrimmedObjectKeyCollision(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseCookieContent("cookies.json", `{"session":"abc"," session ":"def"}`)
+	if err == nil {
+		t.Fatal("expected trimmed key collision error")
+	}
+	if !strings.Contains(err.Error(), "duplicate cookie name") {
+		t.Fatalf("expected duplicate cookie name error, got %v", err)
+	}
+}
+
+func TestParseCookieContentRejectsDuplicateJSONObjectNamesBeforeMapCollapse(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]string{
+		"root exact":           `{"session":"abc","session":"def"}`,
+		"root escaped":         `{"session":"abc","\u0073ession":"def"}`,
+		"nested value exact":   `{"session":{"value":"abc","value":"def"}}`,
+		"nested value escaped": `{"session":{"value":"abc","\u0076alue":"def"}}`,
+		"array name exact":     `[{"name":"session","name":"token","value":"abc"}]`,
+		"array value escaped":  `[{"name":"session","value":"abc","\u0076alue":"def"}]`,
+	}
+	for name, content := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			_, err := ParseCookieContent("cookies.json", content)
+			if err == nil {
+				t.Fatal("expected duplicate error")
+			}
+			if !strings.Contains(err.Error(), "duplicate cookie name") {
+				t.Fatalf("expected duplicate cookie name error, got %v", err)
+			}
+		})
+	}
+}
+
+func TestParseCookieContentAllowsNestedNonCookieDuplicateJSONKeys(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]string{
+		"object metadata": `{"session":{"value":"abc","metadata":{"same":"first","same":"second"}}}`,
+		"array metadata":  `[{"name":"session","value":"abc","metadata":{"same":"first","same":"second"}}]`,
+	}
+	for name, content := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := ParseCookieContent("cookies.json", content)
+			if err != nil {
+				t.Fatalf("ParseCookieContent: %v", err)
+			}
+			if got["session"] != "abc" {
+				t.Fatalf("unexpected cookies: %#v", got)
+			}
+		})
+	}
+}
+
+func TestParseCookieContentValidJSONModesUnchanged(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		fileName string
+		content  string
+		want     map[string]string
+	}{
+		"root map": {
+			fileName: "cookies.json",
+			content:  `{"session":"abc","nested":{"value":"def"}}`,
+			want:     map[string]string{"session": "abc", "nested": "def"},
+		},
+		"array": {
+			fileName: "cookies.json",
+			content:  `[{"name":"session","value":"abc"},{"name":"token","value":"def"}]`,
+			want:     map[string]string{"session": "abc", "token": "def"},
+		},
+		"txt array": {
+			fileName: "cookies.txt",
+			content:  `[{"name":"session","value":"abc"}]`,
+			want:     map[string]string{"session": "abc"},
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := ParseCookieContent(tt.fileName, tt.content)
+			if err != nil {
+				t.Fatalf("ParseCookieContent: %v", err)
+			}
+			for key, want := range tt.want {
+				if got[key] != want {
+					t.Fatalf("unexpected cookie %s: got %#v want %q", key, got, want)
+				}
+			}
+		})
+	}
+}
+
+func TestParseCookieContentPreservesCookieValueWhitespace(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		fileName string
+		content  string
+	}{
+		"JSON object": {
+			fileName: "cookies.json",
+			content:  `{"session":" abc "}`,
+		},
+		"JSON array": {
+			fileName: "cookies.json",
+			content:  `[{"name":"session","value":" abc "}]`,
+		},
+		"Netscape": {
+			fileName: "cookies.txt",
+			content:  ".example.test\tTRUE\t/\tTRUE\t0\tsession\t abc ",
+		},
+		"Netscape HttpOnly": {
+			fileName: "cookies.txt",
+			content:  "#HttpOnly_.example.test\tTRUE\t/\tTRUE\t0\tsession\t abc ",
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := ParseCookieContent(tt.fileName, tt.content)
+			if err != nil {
+				t.Fatalf("ParseCookieContent: %v", err)
+			}
+			if got["session"] != " abc " {
+				t.Fatalf("cookie value was normalized: %#v", got)
+			}
+		})
+	}
+}
+
+func TestApplyEnsureErrorToStatusDoesNotExposeEmpty2FAChallenge(t *testing.T) {
+	t.Parallel()
+
+	status := api.TrackerAuthStatus{TrackerID: "PTP", State: StateConfigured}
+	applyEnsureErrorToStatus(&status, &Needs2FAError{TrackerID: "PTP", Reason: "2FA required"})
+
+	if status.Needs2FA {
+		t.Fatalf("empty challenge must not enable 2FA submission: %#v", status)
+	}
+	if status.ChallengeID != "" {
+		t.Fatalf("empty challenge must not set challenge id: %#v", status)
+	}
+	if status.State != StateLoginRequired {
+		t.Fatalf("expected login required state, got %#v", status)
+	}
+}
+
+func TestApplyEnsureErrorToStatusKeepsStateMessageParity(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		err         error
+		wantState   string
+		wantMessage string
+	}{
+		"cookie storage": {
+			err:         errors.New("cookies: load tracker PTP from db: failed to decode stored cookie"),
+			wantState:   StateEncryptedStorageUnavailable,
+			wantMessage: "cookie storage unavailable; see error details",
+		},
+		"auth required": {
+			err:         &AuthRequiredError{TrackerID: "PTP", Reason: "missing cookies"},
+			wantState:   StateLoginRequired,
+			wantMessage: "login credentials or imported cookies required",
+		},
+		"confirmed invalid": {
+			err: &ValidationError{
+				TrackerID:        "PTP",
+				ConfirmedInvalid: true,
+				Err:              errors.New("expired"),
+			},
+			wantState:   StateLoginRequired,
+			wantMessage: "stored session expired or invalid; log in again or import fresh cookies",
+		},
+		"2FA with challenge": {
+			err:         &Needs2FAError{TrackerID: "PTP", ChallengeID: "challenge-1"},
+			wantState:   StateLoginRequired,
+			wantMessage: "2FA required",
+		},
+		"2FA without challenge": {
+			err:         &Needs2FAError{TrackerID: "PTP"},
+			wantState:   StateLoginRequired,
+			wantMessage: "2FA required but no manual challenge is available",
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			status := api.TrackerAuthStatus{TrackerID: "PTP", State: StateConfigured}
+			applyEnsureErrorToStatus(&status, tt.err)
+			if status.State != tt.wantState {
+				t.Fatalf("expected state %q, got %#v", tt.wantState, status)
+			}
+			if status.Message != tt.wantMessage {
+				t.Fatalf("expected message %q, got %#v", tt.wantMessage, status)
+			}
+			if status.LastError == "" {
+				t.Fatalf("expected LastError for blocker, got %#v", status)
+			}
+		})
+	}
+}
+
+func TestApplyEnsureErrorToStatusRedactsURLPath(t *testing.T) {
+	t.Parallel()
+
+	status := api.TrackerAuthStatus{TrackerID: "MTV", State: StateConfigured}
+	applyEnsureErrorToStatus(&status, errors.New(`Get "https://www.morethantv.me/secret-login-token?passkey=abc": auth key not found`))
+
+	if strings.Contains(status.LastError, "secret-login-token") || strings.Contains(status.LastError, "abc") {
+		t.Fatalf("LastError leaked URL secret: %#v", status)
+	}
+	if !strings.Contains(status.LastError, "https://www.morethantv.me/[REDACTED]") {
+		t.Fatalf("LastError lost useful URL host context: %#v", status)
+	}
+}
+
+func TestCookiesToMapPreservesCookieValueWhitespace(t *testing.T) {
+	t.Parallel()
+
+	got := CookiesToMap([]*http.Cookie{{Name: " session ", Value: " abc "}})
+	if got["session"] != " abc " {
+		t.Fatal("cookie value was normalized")
+	}
+}
+
+func TestParseCookieContentInvalidLeadingArrayReportsJSONError(t *testing.T) {
+	t.Parallel()
+
+	_, err := ParseCookieContent("PTP.txt", `[{"name":"session","value":"abc"}`)
+	if err == nil {
+		t.Fatal("expected invalid JSON error")
+	}
+	if !strings.Contains(err.Error(), "parse JSON cookies") {
+		t.Fatalf("expected JSON parse error, got %v", err)
+	}
+}
+
+func TestParseCookieContentRejectsDuplicateNames(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		fileName string
+		content  string
+	}{
+		"JSON array": {
+			fileName: "cookies.json",
+			content:  `[{"name":"session","value":"abc"},{"name":"session","value":"def"}]`,
+		},
+		"Netscape": {
+			fileName: "cookies.txt",
+			content:  ".example.test\tTRUE\t/\tTRUE\t0\tsession\tabc\n.example.test\tTRUE\t/\tTRUE\t0\tsession\tdef\n",
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			_, err := ParseCookieContent(tt.fileName, tt.content)
+			if err == nil {
+				t.Fatal("expected duplicate error")
+			}
+			if !strings.Contains(err.Error(), "duplicate cookie name") {
+				t.Fatalf("expected duplicate error, got %v", err)
+			}
+		})
+	}
+}
+
+func TestParseCookieContentNetscapeOversizedValidLine(t *testing.T) {
+	value := strings.Repeat("a", 70*1024)
+	got, err := ParseCookieContent("PTP.txt", ".example.test\tTRUE\t/\tTRUE\t0\tsession\t"+value)
+	if err != nil {
+		t.Fatalf("ParseCookieContent: %v", err)
+	}
+	if got["session"] != value {
+		t.Fatalf("unexpected oversized cookie value length: got %d want %d", len(got["session"]), len(value))
+	}
+}
+
+func TestParseCookieContentNetscapeOversizedMalformedLineHasNoEntries(t *testing.T) {
+	_, err := ParseCookieContent("PTP.txt", strings.Repeat("x", 70*1024))
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if !strings.Contains(err.Error(), "no entries") {
+		t.Fatalf("expected no entries error, got %v", err)
+	}
+}
+
+func TestParseCookieContentJSONRejectsInvalidShapes(t *testing.T) {
+	tests := map[string]string{
+		"empty":         "",
+		"invalid json":  "{",
+		"non-object":    `[{"name":"session","value":"abc"},"bad"]`,
+		"missing name":  `[{"value":"abc"}]`,
+		"missing value": `[{"name":"session"}]`,
+	}
+	for name, payload := range tests {
+		t.Run(name, func(t *testing.T) {
+			if _, err := ParseCookieContent("cookies.json", payload); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestImportCookiesRejectsMalformedArrayEntryWithoutReplacingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	_, err := service.ImportCookies(ctx, "AR", "cookies.json", `[
+		{"name":"session","value":"replacement"},
+		{"name":"token"}
+	]`)
+	if err == nil {
+		t.Fatal("expected malformed array entry error")
+	}
+	if !strings.Contains(err.Error(), "require name and value") {
+		t.Fatalf("expected missing value error, got %v", err)
+	}
+
+	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
+	if err != nil {
+		t.Fatalf("LoadTrackerCookieMap: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatal("existing cookies changed after failed import")
+	}
+}
+
+func TestImportCookiesRejectsOverCapWithoutReplacingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	_, err := service.ImportCookies(ctx, "AR", "cookies.txt", strings.Repeat("x", MaxCookieImportContentBytes+1))
+	if err == nil {
+		t.Fatal("expected over-cap import error")
+	}
+	if !strings.Contains(err.Error(), "exceeds") {
+		t.Fatalf("expected size error, got %v", err)
+	}
+
+	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
+	if err != nil {
+		t.Fatalf("LoadTrackerCookieMap: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatal("existing cookies changed after failed import")
+	}
+}
+
+func TestImportCookiesReportsMergedCookieCount(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	legacyPath, err := servicedb.CookiePath(dbPath, "AR.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
+		t.Fatalf("mkdir legacy dir: %v", err)
+	}
+	if err := os.WriteFile(legacyPath, []byte(".example.test\tTRUE\t/\tTRUE\t0\tlegacy\tfrom-file\n"), 0o600); err != nil {
+		t.Fatalf("write legacy cookies: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	status, err := service.ImportCookies(ctx, "AR", "cookies.json", `{"session":"from-db"}`)
+	if err != nil {
+		t.Fatalf("ImportCookies: %v", err)
+	}
+	if status.CookieCount != 2 {
+		t.Fatalf("expected merged cookie count, got %#v", status)
+	}
+}
+
+func TestImportCookiesPreservesBTNMissingAPIStatus(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"BTN": {},
+		}},
+	})
+
+	status, err := service.ImportCookies(ctx, "BTN", "cookies.json", `{"session":"abc"}`)
+	if err != nil {
+		t.Fatalf("ImportCookies: %v", err)
+	}
+	if status.State != StateLoginRequired || status.CookieCount != 1 || !strings.Contains(status.Message, "API key is required") {
+		t.Fatalf("expected missing BTN API to survive cookie import, got %#v", status)
+	}
+}
+
+func TestCapabilitiesAdvertiseOnlySupportedManual2FA(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{})
+	caps, err := service.Capabilities(context.Background())
+	if err != nil {
+		t.Fatalf("Capabilities: %v", err)
+	}
+	for _, cap := range caps {
+		switch cap.TrackerID {
+		case "MTV", "PTP":
+			if !cap.SupportsManual2FA {
+				t.Fatalf("%s must advertise supported manual 2FA", cap.TrackerID)
+			}
+			if !cap.SupportsTOTP {
+				t.Fatalf("%s TOTP auto-login capability must be preserved", cap.TrackerID)
+			}
+			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
+				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
+			}
+		case "RTF":
+			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
+				t.Fatalf("%s API refresh capability must be preserved: %#v", cap.TrackerID, cap)
+			}
+			if cap.SupportsManual2FA || cap.SupportsTOTP {
+				t.Fatalf("%s must not advertise 2FA actions: %#v", cap.TrackerID, cap)
+			}
+		case "AR":
+			if !cap.SupportsLogin || !cap.SupportsAutoLogin || cap.SupportsManual2FA {
+				t.Fatalf("%s must advertise credential auto-login without manual 2FA: %#v", cap.TrackerID, cap)
+			}
+			if !cap.SupportsCookieFile {
+				t.Fatalf("%s must keep cookie import capability: %#v", cap.TrackerID, cap)
+			}
+		case "HDB":
+			if cap.SupportsLogin || cap.SupportsAutoLogin || cap.SupportsManual2FA {
+				t.Fatalf("%s auth check is validation-only in tracker-auth UI: %#v", cap.TrackerID, cap)
+			}
+			if !cap.SupportsCookieFile || !cap.RequiresPasskey {
+				t.Fatalf("%s must keep cookie/passkey capability: %#v", cap.TrackerID, cap)
+			}
+		case "FF", "FL":
+			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
+				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
+			}
+			if !cap.SupportsCookieFile || cap.SupportsManual2FA {
+				t.Fatalf("%s must advertise cookie import without manual 2FA: %#v", cap.TrackerID, cap)
+			}
+		case "THR":
+			if !cap.SupportsLogin || !cap.SupportsAutoLogin {
+				t.Fatalf("%s adapter-backed login capability must be preserved: %#v", cap.TrackerID, cap)
+			}
+			if cap.SupportsCookieFile || cap.SupportsManual2FA {
+				t.Fatalf("%s must advertise stateless login without cookie import or 2FA: %#v", cap.TrackerID, cap)
+			}
+		case "ASC":
+			if cap.SupportsLogin || cap.SupportsAutoLogin || cap.SupportsManual2FA {
+				t.Fatalf("%s must not advertise unsupported login actions: %#v", cap.TrackerID, cap)
+			}
+		}
+	}
+}
+
+func TestTrackerAuthLogsOperationResultsWithoutSecrets(t *testing.T) {
+	t.Parallel()
+
+	logger := &trackerAuthRecordingLogger{}
+	service := newTestServiceWithLogger(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: newTrackerAuthTestDB(t)},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"MTV": {
+					APIKey:   "secret-api-key",
+					Username: "secret-user",
+					Password: "secret-password",
+				},
+			},
+		},
+	}, logger)
+
+	status, err := service.Status(context.Background(), "MTV")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.TrackerID != "MTV" {
+		t.Fatalf("expected MTV status, got %#v", status)
+	}
+	if _, err := service.Capabilities(context.Background()); err != nil {
+		t.Fatalf("Capabilities: %v", err)
+	}
+	if _, err := service.ImportCookies(context.Background(), "AR", "cookies.json", "{bad"); err == nil {
+		t.Fatal("expected invalid cookie import to fail")
+	}
+
+	infoLog := strings.Join(logger.info, "\n")
+	traceLog := strings.Join(logger.trace, "\n")
+	warnLog := strings.Join(logger.warn, "\n")
+	allLogs := infoLog + "\n" + traceLog + "\n" + warnLog
+	if !strings.Contains(traceLog, "tracker auth: status checked tracker=MTV") {
+		t.Fatal("expected status trace log")
+	}
+	if !strings.Contains(traceLog, "tracker auth: capabilities loaded count=") {
+		t.Fatal("expected capabilities trace log")
+	}
+	for _, routine := range []string{"tracker auth: status checked tracker=MTV", "tracker auth: capabilities loaded count="} {
+		if strings.Contains(infoLog, routine) {
+			t.Fatal("routine tracker auth log used info level")
+		}
+	}
+	if !strings.Contains(warnLog, "tracker auth: cookie import failed tracker=AR bytes=4") {
+		t.Fatal("expected import warning log")
+	}
+	for _, secret := range []string{"secret-api-key", "secret-user", "secret-password", "{bad"} {
+		if strings.Contains(allLogs, secret) {
+			t.Fatal("tracker auth log leaked secret")
+		}
+	}
+}
+
+func TestTrackerAuthWarningStatusDoesNotLogSuccess(t *testing.T) {
+	t.Parallel()
+
+	logger := &trackerAuthRecordingLogger{}
+	service := newTestServiceWithLogger(config.Config{}, logger)
+	service.logStatus("login completed", api.TrackerAuthStatus{
+		TrackerID: "MTV",
+		State:     StateConfigured,
+		LastError: "tracker auth: MTV: validation failed",
+	})
+
+	infoLog := strings.Join(logger.info, "\n")
+	warnLog := strings.Join(logger.warn, "\n")
+	if strings.Contains(infoLog, "tracker auth: login completed") {
+		t.Fatalf("warning status logged success info: info=%q warn=%q", infoLog, warnLog)
+	}
+	if !strings.Contains(warnLog, "tracker auth: login completed warning tracker=MTV") {
+		t.Fatalf("expected warning log, got info=%q warn=%q", infoLog, warnLog)
+	}
+}
+
+func TestTrackerAuthConfiguredLoginStatusUsesInfo(t *testing.T) {
+	t.Parallel()
+
+	logger := &trackerAuthRecordingLogger{}
+	service := newTestServiceWithLogger(config.Config{}, logger)
+	service.logStatus("login completed", api.TrackerAuthStatus{
+		TrackerID: "MTV",
+		State:     StateConfigured,
+	})
+
+	infoLog := strings.Join(logger.info, "\n")
+	traceLog := strings.Join(logger.trace, "\n")
+	if !strings.Contains(infoLog, "tracker auth: login completed tracker=MTV") {
+		t.Fatalf("expected successful login info log, got info=%q trace=%q", infoLog, traceLog)
+	}
+	if strings.Contains(traceLog, "tracker auth: login completed tracker=MTV") {
+		t.Fatalf("successful login logged at trace: info=%q trace=%q", infoLog, traceLog)
+	}
+}
+
+func TestTrackerAuthRejectsCaseCollidingConfigIDs(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"ar": {Username: "user", Password: "pass"},
+				"AR": {APIKey: "api-key"},
+			},
+		},
+	})
+
+	if _, err := service.Capabilities(context.Background()); err == nil {
+		t.Fatal("expected capabilities to reject duplicate tracker ids")
+	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
+		t.Fatalf("expected duplicate tracker id error, got %v", err)
+	}
+	if _, err := service.Status(context.Background(), "AR"); err == nil {
+		t.Fatal("expected status to reject duplicate tracker ids")
+	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
+		t.Fatalf("expected duplicate tracker id error, got %v", err)
+	}
+	if _, err := service.Delete(context.Background(), "AR"); err == nil {
+		t.Fatal("expected delete to reject duplicate tracker ids")
+	} else if !strings.Contains(err.Error(), "duplicate tracker config id") {
+		t.Fatalf("expected duplicate tracker id error, got %v", err)
+	}
+}
+
+func TestTrackerAuthKeepsCaseInsensitiveSingleConfigLookup(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"ar": {Username: "user", Password: "pass"},
+			},
+		},
+	})
+
+	status, err := service.Status(context.Background(), "AR")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status.State != StateEncryptedStorageUnavailable {
+		t.Fatalf("expected single case variant to preserve storage readiness, got %#v", status)
+	}
+}
+
+func TestTrackerAuthDoesNotFoldUnicodeLookalikeTrackerIDs(t *testing.T) {
+	t.Parallel()
+
+	service := newTestService(config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"AR": {Username: "user", Password: "pass"},
+			},
+		},
+	})
+
+	if _, err := service.Status(context.Background(), "AR"); err != nil {
+		t.Fatalf("Status ASCII tracker: %v", err)
+	}
+	if _, err := service.Status(context.Background(), "A\u211d"); err == nil {
+		t.Fatal("expected Unicode lookalike tracker id to be unknown")
+	}
+}
+
+func TestDeleteARAuthClearsCookiesAuthStateAndLegacyAuth(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
+		t.Fatalf("SaveAuthState: %v", err)
+	}
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
+		t.Fatalf("mkdir legacy dir: %v", err)
+	}
+	if err := os.WriteFile(legacyPath, []byte("legacy-auth-key"), 0o600); err != nil {
+		t.Fatalf("write legacy auth: %v", err)
+	}
+
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+	status, err := service.Delete(ctx, "AR")
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	if status.CookieCount != 0 {
+		t.Fatalf("expected zero cookies after delete, got %#v", status)
+	}
+	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
+		t.Fatal("expected AR cookies to be deleted")
+	}
+	if _, err := LoadAuthState(ctx, dbPath, "AR", "auth_key"); !errors.Is(err, ErrAuthStateNotFound) {
+		t.Fatalf("expected AR auth state to be deleted, got %v", err)
+	}
+	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
+		t.Fatalf("expected legacy AR auth to be deleted, got %v", err)
+	}
+}
+
+func TestDeleteARAuthStatusRefreshIgnoresCancellationAfterMutation(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newTrackerAuthTestDB(t)
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	deleteCtx, cancel := context.WithCancel(context.Background())
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+	service.afterDeleteCleanup = cancel
+
+	status, err := service.Delete(deleteCtx, "AR")
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	if deleteCtx.Err() == nil {
+		t.Fatal("expected delete context to be canceled before status refresh")
+	}
+	if status.CookieCount != 0 || status.Message != "stored auth deleted" {
+		t.Fatalf("expected truthful delete status after cancellation, got %#v", status)
+	}
+	if _, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
+		t.Fatal("expected AR cookies to be deleted")
+	}
+}
+
+func TestDeleteARAuthLegacyPathFailureReturnsError(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
+		t.Fatalf("SaveAuthState: %v", err)
+	}
+	cookiesDir := filepath.Join(filepath.Dir(dbPath), "cookies")
+	if err := os.WriteFile(cookiesDir, []byte("blocks cookie path"), 0o600); err != nil {
+		t.Fatalf("write cookie path blocker: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	_, err := service.Delete(ctx, "AR")
+	if err == nil {
+		t.Fatal("expected legacy auth path resolution error")
+	}
+	if !strings.Contains(err.Error(), "resolve AR legacy auth key path") {
+		t.Fatalf("expected legacy path resolution error, got %v", err)
+	}
+	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
+	if err != nil {
+		t.Fatalf("expected AR auth state to be restored: %v", err)
+	}
+	if authKey != "secret-auth-key" {
+		t.Fatalf("unexpected restored auth state")
+	}
+}
+
+func TestDeleteARAuthWithoutWebAuthMaterialDeletesStaleAuth(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("OpenWithLoggerContext: %v", err)
+	}
+	if err := repo.MigrateContext(ctx); err != nil {
+		_ = repo.Close()
+		t.Fatalf("MigrateContext: %v", err)
+	}
+	_ = repo.Close()
+	legacyPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o700); err != nil {
+		t.Fatalf("mkdir legacy dir: %v", err)
+	}
+	if err := os.WriteFile(legacyPath, []byte("legacy-auth-key"), 0o600); err != nil {
+		t.Fatalf("write legacy auth: %v", err)
+	}
+	cookiePath, err := servicedb.CookiePath(dbPath, "AR.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.WriteFile(cookiePath, []byte(".alpharatio.cc\tTRUE\t/\tTRUE\t0\tsession\tabc\n"), 0o600); err != nil {
+		t.Fatalf("write legacy cookies: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	_, err = service.Delete(ctx, "AR")
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
+		t.Fatalf("expected legacy AR auth deleted, got %v", err)
+	}
+	if _, err := os.Stat(cookiePath); !os.IsNotExist(err) {
+		t.Fatalf("expected cookies deleted, got %v", err)
+	}
+}
+
+func TestDeleteARCookieFailureRestoresAuthState(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
+		t.Fatalf("SaveAuthState: %v", err)
+	}
+	legacyAuthPath, err := servicedb.CookiePath(dbPath, "AR_auth.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(legacyAuthPath), 0o700); err != nil {
+		t.Fatalf("mkdir legacy auth dir: %v", err)
+	}
+	if err := os.WriteFile(legacyAuthPath, []byte("legacy-auth-key"), 0o600); err != nil {
+		t.Fatalf("write legacy auth: %v", err)
+	}
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	legacyCookiePath, err := servicedb.CookiePath(dbPath, "AR.txt")
+	if err != nil {
+		t.Fatalf("CookiePath: %v", err)
+	}
+	if err := os.MkdirAll(legacyCookiePath, 0o700); err != nil {
+		t.Fatalf("mkdir legacy cookie path: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(legacyCookiePath, "child"), []byte("blocks remove"), 0o600); err != nil {
+		t.Fatalf("write legacy cookie child: %v", err)
+	}
+	service := newTestService(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+
+	_, err = service.Delete(ctx, "AR")
+	if err == nil {
+		t.Fatal("expected cookie delete error")
+	}
+	if !strings.Contains(err.Error(), "delete AR cookies") {
+		t.Fatalf("expected cookie delete error, got %v", err)
+	}
+	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
+	if err != nil {
+		t.Fatalf("expected AR auth state to be restored: %v", err)
+	}
+	if authKey != "secret-auth-key" {
+		t.Fatalf("unexpected restored auth state")
+	}
+	legacyAuth, err := os.ReadFile(legacyAuthPath)
+	if err != nil {
+		t.Fatalf("expected legacy AR auth to be restored: %v", err)
+	}
+	if string(legacyAuth) != "legacy-auth-key" {
+		t.Fatalf("unexpected restored legacy AR auth")
+	}
+	cookieValues, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "AR")
+	if err != nil {
+		t.Fatalf("expected AR cookies to be restored: %v", err)
+	}
+	if cookieValues["session"] != "abc" {
+		t.Fatal("unexpected restored AR cookies")
+	}
+}
+
+func TestTrackerAuthSnapshotRestoreIgnoresCanceledContext(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := SaveAuthState(ctx, dbPath, "AR", "auth_key", "secret-auth-key"); err != nil {
+		t.Fatalf("SaveAuthState: %v", err)
+	}
+	manager := NewKeyedFileStateManager("AR", "auth_key", "AR_auth.txt")
+	snapshot, err := manager.Snapshot(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("snapshot auth state: %v", err)
+	}
+	if err := manager.Delete(ctx, dbPath); err != nil {
+		t.Fatalf("delete auth state: %v", err)
+	}
+
+	cancelledCtx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if err := snapshot.Restore(cancelledCtx); err != nil {
+		t.Fatalf("restore with canceled context: %v", err)
+	}
+	authKey, err := LoadAuthState(ctx, dbPath, "AR", "auth_key")
+	if err != nil {
+		t.Fatalf("expected AR auth state to be restored: %v", err)
+	}
+	if authKey != "secret-auth-key" {
+		t.Fatalf("unexpected restored auth state")
+	}
+}
+
+func TestValidateManyRunsTrackerChecksConcurrentlyAndPreservesOrder(t *testing.T) {
+	t.Parallel()
+
+	dbPath := newTrackerAuthTestDB(t)
+	trackerIDs := [maxConcurrentValidations + 1]string{"PTP", "MTV", "RTF", "AR", "HDB"}
+	entered := make(chan string, len(trackerIDs))
+	releases := make(map[string]chan struct{}, len(trackerIDs))
+	released := make(map[string]bool, len(trackerIDs))
+	releaseValidation := func(trackerID string) {
+		if !released[trackerID] {
+			close(releases[trackerID])
+			released[trackerID] = true
+		}
+	}
+	defer func() {
+		for _, trackerID := range trackerIDs {
+			releaseValidation(trackerID)
+		}
+	}()
+	newBlockingAdapter := func(trackerID string) *fakeAdapter {
+		release := make(chan struct{})
+		releases[trackerID] = release
+		return &fakeAdapter{
+			capability: api.TrackerAuthCapability{TrackerID: trackerID, SupportsLogin: true},
+			validate: func() (Session, error) {
+				entered <- trackerID
+				<-release
+				return Session{TrackerID: trackerID, State: SessionStateReady}, nil
+			},
+		}
+	}
+	trackerConfigs := make(map[string]config.TrackerConfig, len(trackerIDs))
+	for _, trackerID := range trackerIDs {
+		trackerConfigs[trackerID] = config.TrackerConfig{}
+	}
+	service := newTestService(config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers:     config.TrackersConfig{Trackers: trackerConfigs},
+	})
+	for _, trackerID := range trackerIDs {
+		service.adapters[trackerID] = newBlockingAdapter(trackerID)
+	}
+
+	type result struct {
+		statuses []api.TrackerAuthStatus
+		err      error
+	}
+	resultCh := make(chan result, 1)
+	go func() {
+		statuses, err := service.ValidateMany(context.Background(), trackerIDs[:])
+		resultCh <- result{statuses: statuses, err: err}
+	}()
+
+	seen := make(map[string]bool, len(trackerIDs))
+	firstEntered := ""
+	for range maxConcurrentValidations {
+		select {
+		case trackerID := <-entered:
+			seen[trackerID] = true
+			if firstEntered == "" {
+				firstEntered = trackerID
+			}
+		case <-time.After(2 * time.Second):
+			t.Fatal("concurrent tracker validations did not reach the limit")
+		}
+	}
+	select {
+	case trackerID := <-entered:
+		t.Fatalf("expected only %d concurrent validations, but %s also entered", maxConcurrentValidations, trackerID)
+	case <-time.After(100 * time.Millisecond):
+	}
+
+	releaseValidation(firstEntered)
+	select {
+	case trackerID := <-entered:
+		seen[trackerID] = true
+	case <-time.After(2 * time.Second):
+		t.Fatal("queued tracker validation did not enter after a slot was released")
+	}
+	for _, trackerID := range trackerIDs {
+		releaseValidation(trackerID)
+	}
+
+	var got result
+	select {
+	case got = <-resultCh:
+	case <-time.After(10 * time.Second):
+		t.Fatal("ValidateMany did not return after all validations were released")
+	}
+	if got.err != nil {
+		t.Fatalf("ValidateMany: %v", got.err)
+	}
+	if len(seen) != len(trackerIDs) {
+		t.Fatalf("expected all tracker validations to start, got %#v", seen)
+	}
+	if len(got.statuses) != len(trackerIDs) {
+		t.Fatalf("expected input-ordered statuses, got %#v", got.statuses)
+	}
+	for i, trackerID := range trackerIDs {
+		if got.statuses[i].TrackerID != trackerID || got.statuses[i].State != StateConfigured {
+			t.Fatalf("expected successful input-ordered status for %s, got %#v", trackerID, got.statuses[i])
+		}
+	}
+}
+
+func newTrackerAuthTestDB(t *testing.T) string {
+	t.Helper()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("OpenWithLoggerContext: %v", err)
+	}
+	if err := repo.MigrateContext(ctx); err != nil {
+		_ = repo.Close()
+		t.Fatalf("MigrateContext: %v", err)
+	}
+	_ = repo.Close()
+	return dbPath
+}
+
+// trackerAuthLegacyCookiePathByExt selects the concrete legacy candidate path
+// for auth-status tests that seed malformed cookie files by format.
+func trackerAuthLegacyCookiePathByExt(t *testing.T, dbPath string, trackerID string, ext string) string {
+	t.Helper()
+
+	for _, candidate := range commonhttp.CookiePathCandidates(dbPath, trackerID, ".txt", ".json") {
+		if filepath.Ext(candidate) == ext {
+			return candidate
+		}
+	}
+	t.Fatalf("expected %s legacy cookie path", ext)
+	return ""
+}
diff --git a/internal/trackers/auth/state_manager.go b/internal/trackers/auth/state_manager.go
new file mode 100644
index 00000000..c92d45ae
--- /dev/null
+++ b/internal/trackers/auth/state_manager.go
@@ -0,0 +1,118 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+type keyedFileStateManager struct {
+	trackerID      string
+	stateKey       string
+	legacyFileName string
+}
+
+type keyedFileStateSnapshot struct {
+	manager        keyedFileStateManager
+	dbPath         string
+	stateValue     string
+	hadState       bool
+	legacyPath     string
+	legacyValue    []byte
+	hadLegacyValue bool
+}
+
+// NewKeyedFileStateManager returns a reusable manager for a tracker-owned
+// encrypted auth value and optional legacy plaintext file.
+func NewKeyedFileStateManager(trackerID string, stateKey string, legacyFileName string) trackers.AuthStateManager {
+	return keyedFileStateManager{
+		trackerID:      strings.ToUpper(strings.TrimSpace(trackerID)),
+		stateKey:       strings.TrimSpace(stateKey),
+		legacyFileName: strings.TrimSpace(legacyFileName),
+	}
+}
+
+func (m keyedFileStateManager) Snapshot(ctx context.Context, dbPath string) (trackers.AuthStateSnapshot, error) {
+	snapshot := &keyedFileStateSnapshot{manager: m, dbPath: dbPath}
+	stateValue, err := LoadAuthState(ctx, dbPath, m.trackerID, m.stateKey)
+	if err == nil {
+		snapshot.stateValue = stateValue
+		snapshot.hadState = true
+	} else if !errors.Is(err, ErrAuthStateNotFound) && encryptedAuthStateMayExist(dbPath) {
+		return nil, fmt.Errorf("tracker auth: snapshot %s auth state: %w", m.trackerID, err)
+	}
+	if m.legacyFileName == "" {
+		return snapshot, nil
+	}
+	legacyPath, err := servicedb.CookiePath(dbPath, m.legacyFileName)
+	if err != nil {
+		return snapshot, nil
+	}
+	snapshot.legacyPath = legacyPath
+	legacyValue, readErr := os.ReadFile(legacyPath)
+	if readErr == nil {
+		snapshot.legacyValue = legacyValue
+		snapshot.hadLegacyValue = true
+	} else if !os.IsNotExist(readErr) {
+		return nil, fmt.Errorf("tracker auth: snapshot %s legacy auth key: %w", m.trackerID, readErr)
+	}
+	return snapshot, nil
+}
+
+func (m keyedFileStateManager) Delete(ctx context.Context, dbPath string) error {
+	var errs []error
+	if err := DeleteAuthState(ctx, dbPath, m.trackerID, m.stateKey); err != nil && encryptedAuthStateMayExist(dbPath) {
+		errs = append(errs, fmt.Errorf("tracker auth: delete %s auth state: %w", m.trackerID, err))
+	} else if err != nil && !errors.Is(err, ErrAuthStateNotFound) {
+		errs = append(errs, fmt.Errorf("tracker auth: delete %s auth state uncertain: %w", m.trackerID, err))
+	}
+	if m.legacyFileName == "" {
+		return errors.Join(errs...)
+	}
+	legacyPath, err := servicedb.CookiePath(dbPath, m.legacyFileName)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("tracker auth: resolve %s legacy auth key path: %w", m.trackerID, err))
+	} else if err := os.Remove(legacyPath); err != nil && !os.IsNotExist(err) {
+		errs = append(errs, fmt.Errorf("tracker auth: delete %s legacy auth key: %w", m.trackerID, err))
+	}
+	return errors.Join(errs...)
+}
+
+func (s *keyedFileStateSnapshot) Restore(ctx context.Context) error {
+	if s == nil {
+		return nil
+	}
+	rollbackCtx := contextWithoutCancel(ctx)
+	var errs []error
+	if s.hadState {
+		if err := SaveAuthState(rollbackCtx, s.dbPath, s.manager.trackerID, s.manager.stateKey, s.stateValue); err != nil {
+			errs = append(errs, fmt.Errorf("tracker auth: restore %s auth state: %w", s.manager.trackerID, err))
+		}
+	}
+	if s.hadLegacyValue && s.legacyPath != "" {
+		if err := os.MkdirAll(filepath.Dir(s.legacyPath), 0o700); err != nil {
+			errs = append(errs, fmt.Errorf("tracker auth: restore %s legacy auth key dir: %w", s.manager.trackerID, err))
+		} else if err := os.WriteFile(s.legacyPath, s.legacyValue, 0o600); err != nil {
+			errs = append(errs, fmt.Errorf("tracker auth: restore %s legacy auth key: %w", s.manager.trackerID, err))
+		}
+	}
+	return errors.Join(errs...)
+}
+
+func encryptedAuthStateMayExist(dbPath string) bool {
+	if strings.TrimSpace(dbPath) == "" {
+		return false
+	}
+	_, err := authmaterial.LoadFromDBPath(dbPath)
+	return err == nil
+}
diff --git a/internal/trackerauth/state_store.go b/internal/trackers/auth/state_store.go
similarity index 96%
rename from internal/trackerauth/state_store.go
rename to internal/trackers/auth/state_store.go
index 6ef9f9d7..cc298733 100644
--- a/internal/trackerauth/state_store.go
+++ b/internal/trackers/auth/state_store.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
@@ -20,7 +20,7 @@ import (
 var ErrAuthStateNotFound = errors.New("tracker auth state not found")
 
 // AuthStateStore persists encrypted tracker auth state in the shared SQLite database.
-type AuthStateStore struct {
+type AuthStateStore struct { //nolint:revive // Preserve the established cross-package API during package relocation.
 	db *sql.DB
 }
 
@@ -155,7 +155,12 @@ func (s *AuthStateStore) Delete(ctx context.Context, trackerID string, stateKey
 	if err := validateStateInputs("Delete", trackerID, stateKey); err != nil {
 		return err
 	}
-	_, err := s.db.ExecContext(ctx, `DELETE FROM tracker_auth_state WHERE tracker_id = ? AND state_key = ?`, normalizeTrackerID(trackerID), strings.TrimSpace(stateKey))
+	_, err := s.db.ExecContext(
+		ctx,
+		`DELETE FROM tracker_auth_state WHERE tracker_id = ? AND state_key = ?`,
+		normalizeTrackerID(trackerID),
+		strings.TrimSpace(stateKey),
+	)
 	if err != nil {
 		return fmt.Errorf("tracker auth state: delete: %w", err)
 	}
diff --git a/internal/trackerauth/state_store_test.go b/internal/trackers/auth/state_store_test.go
similarity index 99%
rename from internal/trackerauth/state_store_test.go
rename to internal/trackers/auth/state_store_test.go
index e6b15c7a..deda02bb 100644
--- a/internal/trackerauth/state_store_test.go
+++ b/internal/trackers/auth/state_store_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerauth
+package auth
 
 import (
 	"context"
diff --git a/internal/trackers/auth/types.go b/internal/trackers/auth/types.go
new file mode 100644
index 00000000..1945abbe
--- /dev/null
+++ b/internal/trackers/auth/types.go
@@ -0,0 +1,186 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package auth manages tracker login, cookie import, session validation,
+// and encrypted auxiliary auth state for tracker implementations.
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	// SessionStateReady means an adapter returned auth material ready for tracker requests.
+	SessionStateReady = "ready"
+	// SessionStateAuthRequired means no usable session is available without user auth material.
+	SessionStateAuthRequired = "auth_required"
+	// SessionStateNeeds2FA means the auth flow is paused until a manual 2FA code is submitted.
+	SessionStateNeeds2FA = "needs_2fa"
+	// SessionStateUnsupported means the tracker has no supported auth operation for the requested flow.
+	SessionStateUnsupported = "unsupported"
+)
+
+// EnsureRequest describes one tracker auth validation or login attempt.
+type EnsureRequest struct {
+	// TrackerID is the tracker code to validate; comparisons are case-insensitive.
+	TrackerID string
+	// Config supplies credentials, URLs, passkeys, and OTP settings for the tracker.
+	Config config.TrackerConfig
+	// DBPath points at the application database used for encrypted cookie and state storage.
+	DBPath string
+	// AutoLogin allows EnsureSession to attempt credential login after a confirmed invalid stored session.
+	AutoLogin bool
+	// Login carries optional adapter-specific login input, such as a one-time 2FA code.
+	Login api.TrackerAuthLoginRequest
+}
+
+// Session is the normalized result returned by a tracker auth adapter.
+type Session struct {
+	// TrackerID is the normalized tracker code that produced the session.
+	TrackerID string
+	// State reports whether the session is ready, blocked by auth, paused for 2FA, or unsupported.
+	State string
+	// Cookies contains session cookies returned by adapters that expose cookie maps.
+	Cookies map[string]string
+	// Token contains tracker-specific CSRF/auth tokens when an adapter exposes one.
+	Token string
+	// ChallengeID identifies a pending manual 2FA continuation.
+	ChallengeID string
+	// Message contains caller-visible detail about the current auth state.
+	Message string
+}
+
+// Adapter validates and mutates tracker-specific auth material.
+type Adapter interface {
+	// Capability returns static auth support metadata for the tracker.
+	Capability() api.TrackerAuthCapability
+	// Status returns local auth state without forcing a remote login.
+	Status(ctx context.Context, cfg config.TrackerConfig, dbPath string) (api.TrackerAuthStatus, error)
+	// Validate checks whether stored auth material can be used for tracker requests.
+	Validate(ctx context.Context, cfg config.TrackerConfig, dbPath string) (Session, error)
+	// Login attempts credential-based auth and may persist refreshed auth material.
+	Login(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error)
+	// Submit2FA retries auth with manual 2FA input for a service-verified challenge.
+	Submit2FA(ctx context.Context, cfg config.TrackerConfig, dbPath string, req api.TrackerAuthLoginRequest) (Session, error)
+	// Delete removes persisted auth material owned by the adapter.
+	Delete(ctx context.Context, dbPath string) error
+}
+
+// AuthRequiredError reports that no usable session is available and caller-supplied auth material is required.
+type AuthRequiredError struct { //nolint:revive // Preserve the established cross-package API during package relocation.
+	TrackerID string
+	Reason    string
+	Err       error
+}
+
+func (e *AuthRequiredError) Error() string {
+	return trackerAuthError("auth required", e.TrackerID, e.Reason, e.Err)
+}
+
+func (e *AuthRequiredError) Unwrap() error {
+	return e.Err
+}
+
+// Needs2FAError reports that a manual 2FA code is required before auth can continue.
+type Needs2FAError struct {
+	TrackerID string
+	// ChallengeID is set when the caller can continue the flow with Submit2FA.
+	ChallengeID string
+	Reason      string
+	Err         error
+}
+
+func (e *Needs2FAError) Error() string {
+	return trackerAuthError("2FA required", e.TrackerID, e.Reason, e.Err)
+}
+
+func (e *Needs2FAError) Unwrap() error {
+	return e.Err
+}
+
+// UnsupportedAuthError reports that the requested auth operation is not implemented for the tracker.
+type UnsupportedAuthError struct {
+	TrackerID string
+	Reason    string
+	Err       error
+}
+
+func (e *UnsupportedAuthError) Error() string {
+	return trackerAuthError("unsupported auth", e.TrackerID, e.Reason, e.Err)
+}
+
+func (e *UnsupportedAuthError) Unwrap() error {
+	return e.Err
+}
+
+// ValidationError reports a failed remote or local validation check.
+type ValidationError struct {
+	TrackerID string
+	// ConfirmedInvalid means stored auth material is known bad and may be deleted.
+	ConfirmedInvalid bool
+	// Transient means stored auth material should be preserved because the failure may be temporary.
+	Transient bool
+	// Submitted2FARejected means an adapter proved a submitted manual 2FA code reached the tracker and was rejected.
+	Submitted2FARejected bool
+	Reason               string
+	Err                  error
+}
+
+func (e *ValidationError) Error() string {
+	return trackerAuthError("validation failed", e.TrackerID, e.Reason, e.Err)
+}
+
+func (e *ValidationError) Unwrap() error {
+	return e.Err
+}
+
+func trackerAuthError(kind string, trackerID string, reason string, err error) string {
+	parts := []string{"tracker auth"}
+	if trimmed := strings.TrimSpace(trackerID); trimmed != "" {
+		parts = append(parts, strings.ToUpper(trimmed))
+	}
+	parts = append(parts, kind)
+	if trimmed := strings.TrimSpace(reason); trimmed != "" {
+		parts = append(parts, trimmed)
+	}
+	msg := strings.Join(parts, ": ")
+	if err != nil {
+		msg += ": " + err.Error()
+	}
+	return msg
+}
+
+func asValidationError(err error) (*ValidationError, bool) {
+	var validationErr *ValidationError
+	if errors.As(err, &validationErr) {
+		return validationErr, true
+	}
+	return nil, false
+}
+
+func hasLoginCredentials(cfg config.TrackerConfig) bool {
+	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
+}
+
+func normalizeTrackerID(trackerID string) string {
+	trimmed := strings.TrimSpace(trackerID)
+	var builder strings.Builder
+	builder.Grow(len(trimmed))
+	for _, r := range trimmed {
+		if r >= 'a' && r <= 'z' {
+			r -= 'a' - 'A'
+		}
+		builder.WriteRune(r)
+	}
+	return builder.String()
+}
+
+func newUnknownTrackerError(trackerID string) error {
+	return fmt.Errorf("tracker auth: unknown tracker %s", strings.TrimSpace(trackerID))
+}
diff --git a/internal/trackers/az_rules_test.go b/internal/trackers/az_rules_test.go
deleted file mode 100644
index dcc66420..00000000
--- a/internal/trackers/az_rules_test.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackers
-
-import (
-	"context"
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestEvaluateRulesAZRedirectsEnglishTerritories(t *testing.T) {
-	t.Parallel()
-
-	failures := EvaluateRules(context.Background(), "AZ", api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginCountry: []string{"US"}},
-		},
-	}, api.NopLogger{})
-	if len(failures) == 0 {
-		t.Fatal("expected AZ rule failure")
-	}
-}
-
-func TestEvaluateRulesCZRejectsAsianContent(t *testing.T) {
-	t.Parallel()
-
-	failures := EvaluateRules(context.Background(), "CZ", api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginCountry: []string{"JP"}},
-		},
-	}, api.NopLogger{})
-	if len(failures) == 0 {
-		t.Fatal("expected CZ rule failure")
-	}
-}
-
-func TestEvaluateRulesPHDRejectsSDAndBlockedGroup(t *testing.T) {
-	t.Parallel()
-
-	failures := EvaluateRules(context.Background(), "PHD", api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		Release:     api.ReleaseInfo{Resolution: "480p"},
-		Container:   "avi",
-		Tag:         "-RARBG",
-	}, api.NopLogger{})
-	if len(failures) < 2 {
-		t.Fatalf("expected multiple PHD failures, got %v", failures)
-	}
-}
diff --git a/internal/trackers/banned.go b/internal/trackers/banned.go
index b86d4a05..e4567439 100644
--- a/internal/trackers/banned.go
+++ b/internal/trackers/banned.go
@@ -23,7 +23,6 @@ import (
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -42,6 +41,8 @@ var trashGuideBannedGroupsURL = "https://raw.githubusercontent.com/TRaSH-Guides/
 // banned-group lists.
 type BannedGroupChecker struct {
 	basePath string
+	registry *Registry
+	client   *http.Client
 	mu       sync.Mutex
 	cache    map[string]map[string]struct{}
 }
@@ -79,12 +80,24 @@ type trashGuideSpecification struct {
 // NewBannedGroupChecker creates a checker rooted at the banned-group cache
 // directory derived from dbPath.
 func NewBannedGroupChecker(dbPath string) *BannedGroupChecker {
+	return NewBannedGroupCheckerWithRegistry(dbPath, nil)
+}
+
+// NewBannedGroupCheckerWithRegistry resolves the banned-group cache path,
+// creating its mode-0700 cache parent, and uses registry-owned static and
+// dynamic policies. It returns nil when the cache path cannot be resolved.
+func NewBannedGroupCheckerWithRegistry(dbPath string, registry *Registry) *BannedGroupChecker {
 	basePath, err := db.Subdir(dbPath, "cache")
 	if err != nil {
 		return nil
 	}
 	basePath = filepath.Join(basePath, "banned")
-	return &BannedGroupChecker{basePath: basePath, cache: make(map[string]map[string]struct{})}
+	return &BannedGroupChecker{
+		basePath: basePath,
+		registry: registry,
+		client:   &http.Client{Timeout: 20 * time.Second},
+		cache:    make(map[string]map[string]struct{}),
+	}
 }
 
 // IsBanned reports whether group is banned for tracker after normalizing both
@@ -117,7 +130,10 @@ func (c *BannedGroupChecker) IsBanned(tracker, group string) (bool, error) {
 // refreshed list from applying. Cancellation is checked before fetches and again
 // before durable writes so canceled refreshes do not replace cache files.
 func (c *BannedGroupChecker) RefreshDynamic(ctx context.Context, cfg config.Config, trackerNames []string, logger api.Logger) error {
-	return c.refreshDynamic(ctx, cfg, trackerNames, logger, fetchDynamicBannedGroups)
+	fetch := func(ctx context.Context, cfg config.Config, tracker string) ([]string, []json.RawMessage, error) {
+		return fetchDynamicBannedGroupsWithClient(ctx, cfg, tracker, c.registry, c.client)
+	}
+	return c.refreshDynamic(ctx, cfg, trackerNames, logger, fetch)
 }
 
 // dynamicBannedGroupsFetcher lets tests place cancellation exactly between a
@@ -135,7 +151,7 @@ func (c *BannedGroupChecker) refreshDynamic(
 		return nil
 	}
 	for _, tracker := range uniqueBannedGroupTrackers(trackerNames) {
-		if !usesDynamicBannedGroups(tracker) {
+		if !usesDynamicBannedGroups(c.registry, tracker) {
 			continue
 		}
 		if ctx.Err() != nil {
@@ -159,7 +175,11 @@ func (c *BannedGroupChecker) refreshDynamic(
 		}
 		if err != nil {
 			if logger != nil {
-				logger.Warnf("trackers: banned groups refresh failed tracker=%s decision=cache_fallback err=%s", tracker, redaction.RedactValue(err.Error(), nil))
+				logger.Warnf(
+					"trackers: banned groups refresh failed tracker=%s decision=cache_fallback err=%s",
+					tracker,
+					redaction.RedactValue(err.Error(), nil),
+				)
 			}
 			continue
 		}
@@ -186,8 +206,8 @@ func (c *BannedGroupChecker) load(tracker string) (map[string]struct{}, error) {
 	}
 
 	groups := map[string]struct{}{}
-	if builtin := builtinBannedGroups[tracker]; len(builtin) > 0 {
-		for _, value := range builtin {
+	if owned, ok := c.registry.LookupBannedGroups(tracker); ok {
+		for _, value := range owned {
 			cleaned := strings.ToLower(strings.TrimSpace(value))
 			if cleaned != "" {
 				groups[cleaned] = struct{}{}
@@ -255,13 +275,9 @@ func uniqueBannedGroupTrackers(values []string) []string {
 
 // usesDynamicBannedGroups reports whether upbrr knows how to fetch a tracker
 // banned-group API instead of relying only on built-ins or a manual cache file.
-func usesDynamicBannedGroups(tracker string) bool {
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "AITHER", "LST", "LUME", "SPD":
-		return true
-	default:
-		return false
-	}
+func usesDynamicBannedGroups(registry *Registry, tracker string) bool {
+	_, ok := registry.LookupBannedGroupPolicy(tracker)
+	return ok
 }
 
 // bannedGroupsCacheFresh reports whether a cache file can satisfy a refresh
@@ -411,33 +427,40 @@ func normalizedBannedGroupList(groups []string) []string {
 	return out
 }
 
-// fetchDynamicBannedGroups downloads every page for API-backed trackers, or the
-// TRaSH guide source for LUME. Missing endpoint config or API key returns
-// errBannedGroupsRefreshSkipped so callers do not overwrite an existing cache
-// with an empty file. Pagination is bounded and repeated cursors fail instead
-// of looping indefinitely.
-func fetchDynamicBannedGroups(ctx context.Context, cfg config.Config, tracker string) ([]string, []json.RawMessage, error) {
-	if strings.EqualFold(strings.TrimSpace(tracker), "LUME") {
-		return fetchTRaSHGuideBannedGroups(ctx, trashGuideBannedGroupsURL)
+func fetchDynamicBannedGroupsWithClient(
+	ctx context.Context,
+	cfg config.Config,
+	tracker string,
+	registry *Registry,
+	client *http.Client,
+) ([]string, []json.RawMessage, error) {
+	policy, ok := registry.LookupBannedGroupPolicy(tracker)
+	if !ok {
+		return nil, nil, errBannedGroupsRefreshSkipped
+	}
+	if endpoint := strings.TrimSpace(policy.TRaSHGuideURL); endpoint != "" {
+		return fetchTRaSHGuideBannedGroupsWithClient(ctx, endpoint, client)
 	}
 
-	endpoint, ok := bannedGroupsEndpoint(cfg, tracker)
+	endpoint, ok := bannedGroupsEndpoint(cfg, tracker, registry, policy)
 	if !ok {
 		return nil, nil, errBannedGroupsRefreshSkipped
 	}
 	apiKey := strings.TrimSpace(bannedGroupAPIKey(cfg, tracker))
-	if apiKey == "" {
+	if policy.RequireAPIKey && apiKey == "" {
 		return nil, nil, errBannedGroupsRefreshSkipped
 	}
 
-	client := &http.Client{Timeout: 20 * time.Second}
+	if client == nil {
+		client = &http.Client{Timeout: 20 * time.Second}
+	}
 	cursor := ""
 	groups := make([]string, 0)
 	rawItems := make([]json.RawMessage, 0)
 	seenCursors := make(map[string]struct{})
 
 	for page := 1; ; page++ {
-		pageGroups, pageRaw, nextCursor, err := fetchDynamicBannedGroupsPage(ctx, client, endpoint, tracker, apiKey, cursor)
+		pageGroups, pageRaw, nextCursor, err := fetchDynamicBannedGroupsPage(ctx, client, endpoint, tracker, apiKey, cursor, policy.RawAPIKeyFallback)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -462,7 +485,17 @@ func fetchDynamicBannedGroups(ctx context.Context, cfg config.Config, tracker st
 // extracts release-group specifications into the same cache shape as tracker
 // API-backed banned groups.
 func fetchTRaSHGuideBannedGroups(ctx context.Context, endpoint string) ([]string, []json.RawMessage, error) {
-	client := &http.Client{Timeout: 20 * time.Second}
+	return fetchTRaSHGuideBannedGroupsWithClient(ctx, endpoint, &http.Client{Timeout: 20 * time.Second})
+}
+
+func fetchTRaSHGuideBannedGroupsWithClient(
+	ctx context.Context,
+	endpoint string,
+	client *http.Client,
+) ([]string, []json.RawMessage, error) {
+	if client == nil {
+		client = &http.Client{Timeout: 20 * time.Second}
+	}
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return nil, nil, fmt.Errorf("build TRaSH banned groups request: %w", err)
@@ -668,11 +701,19 @@ func stripTRaSHReleaseGroupPattern(value string) string {
 
 // fetchDynamicBannedGroupsPage fetches and parses one blacklist page, including
 // SPD's alternate Authorization header form when bearer auth is rejected.
-func fetchDynamicBannedGroupsPage(ctx context.Context, client *http.Client, endpoint string, tracker string, apiKey string, cursor string) ([]string, []json.RawMessage, string, error) {
+func fetchDynamicBannedGroupsPage(
+	ctx context.Context,
+	client *http.Client,
+	endpoint string,
+	tracker string,
+	apiKey string,
+	cursor string,
+	rawAPIKeyFallback bool,
+) ([]string, []json.RawMessage, string, error) {
 	var raw json.RawMessage
 	var statusCode int
 	var err error
-	authValues := bannedGroupsAuthValues(tracker, apiKey)
+	authValues := bannedGroupsAuthValues(apiKey, rawAPIKeyFallback)
 	for idx, authValue := range authValues {
 		raw, statusCode, err = doBannedGroupsRequest(ctx, client, endpoint, tracker, authValue, cursor)
 		if err != nil {
@@ -702,7 +743,14 @@ func fetchDynamicBannedGroupsPage(ctx context.Context, client *http.Client, endp
 
 // doBannedGroupsRequest performs one HTTP request and returns only decoded JSON
 // for successful responses so error paths never include remote response bodies.
-func doBannedGroupsRequest(ctx context.Context, client *http.Client, endpoint string, tracker string, authValue string, cursor string) (json.RawMessage, int, error) {
+func doBannedGroupsRequest(
+	ctx context.Context,
+	client *http.Client,
+	endpoint string,
+	tracker string,
+	authValue string,
+	cursor string,
+) (json.RawMessage, int, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return nil, 0, fmt.Errorf("build banned groups request %s: %w", tracker, err)
@@ -759,9 +807,9 @@ func decodeBannedGroupsJSON(body io.Reader, dest any) error {
 
 // bannedGroupsAuthValues returns the Authorization header values to try for a
 // tracker; SPD's API uses raw API-key auth in existing upbrr code paths.
-func bannedGroupsAuthValues(tracker string, apiKey string) []string {
+func bannedGroupsAuthValues(apiKey string, rawAPIKeyFallback bool) []string {
 	values := []string{"Bearer " + apiKey}
-	if strings.EqualFold(strings.TrimSpace(tracker), "SPD") {
+	if rawAPIKeyFallback {
 		values = append(values, apiKey)
 	}
 	return values
@@ -827,46 +875,13 @@ func bannedGroupName(raw json.RawMessage) string {
 
 // bannedGroupsEndpoint resolves the tracker-specific blacklist URL. AITHER and
 // LST use Unit3D-style base URLs; SPD uses its SpeedApp API endpoint.
-func bannedGroupsEndpoint(cfg config.Config, tracker string) (string, bool) {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	switch name {
-	case "AITHER":
-		return bannedGroupsBaseEndpoint(cfg, name, "/api/blacklists/releasegroups")
-	case "LST":
-		return bannedGroupsBaseEndpoint(cfg, name, "/api/bannedReleaseGroups")
-	case "SPD":
-		if base, ok := configuredTrackerBaseURL(cfg, name); ok {
-			return strings.TrimRight(base, "/") + "/api/torrent/release-group/blacklist", true
-		}
-		return "https://speedapp.io/api/torrent/release-group/blacklist", true
-	default:
-		return "", false
-	}
-}
-
-// bannedGroupsBaseEndpoint resolves a Unit3D tracker base URL from config first
-// and embedded defaults second, then appends the tracker-specific API path.
-func bannedGroupsBaseEndpoint(cfg config.Config, tracker string, endpointPath string) (string, bool) {
-	baseURL, ok := configuredTrackerBaseURL(cfg, tracker)
-	if !ok {
-		baseURL, ok = unit3dmeta.BaseURL(tracker)
+func bannedGroupsEndpoint(cfg config.Config, tracker string, registry *Registry, policy BannedGroupPolicy) (string, bool) {
+	_ = cfg
+	if base, ok := registry.LookupBaseURL(tracker); ok && strings.TrimSpace(policy.EndpointPath) != "" {
+		return strings.TrimRight(base, "/") + policy.EndpointPath, true
 	}
-	if !ok {
-		return "", false
-	}
-	return strings.TrimRight(baseURL, "/") + endpointPath, true
-}
-
-// configuredTrackerBaseURL derives a web base URL from configured tracker URL
-// fields without retaining announce paths or query strings.
-func configuredTrackerBaseURL(cfg config.Config, tracker string) (string, bool) {
-	entry := trackerConfigFor(cfg, tracker)
-	for _, value := range []string{entry.URL, entry.AnnounceURL, entry.MyAnnounceURL} {
-		if base := webBaseURL(value); base != "" {
-			return base, true
-		}
-	}
-	return "", false
+	endpoint := strings.TrimSpace(policy.DefaultEndpoint)
+	return endpoint, endpoint != ""
 }
 
 // bannedGroupAPIKey returns the configured tracker API key used for dynamic
@@ -874,1067 +889,3 @@ func configuredTrackerBaseURL(cfg config.Config, tracker string) (string, bool)
 func bannedGroupAPIKey(cfg config.Config, tracker string) string {
 	return strings.TrimSpace(trackerConfigFor(cfg, tracker).APIKey)
 }
-
-// webBaseURL strips a configured URL to scheme and host for API endpoint
-// construction.
-func webBaseURL(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-		return ""
-	}
-	parsed.Path = ""
-	parsed.RawQuery = ""
-	parsed.Fragment = ""
-	return strings.TrimRight(parsed.String(), "/")
-}
-
-var builtinBannedGroups = map[string][]string{
-	"A4K": {
-		"BiTOR",
-		"DepraveD",
-		"Flights",
-		"SasukeducK",
-		"SPDVD",
-		"TEKNO3D",
-	},
-	"ANT": {
-		"3LTON",
-		"4yEo",
-		"ADE",
-		"AFG",
-		"AniHLS",
-		"AnimeRG",
-		"AniURL",
-		"AROMA",
-		"aXXo",
-		"Brrip",
-		"CHD",
-		"CM8",
-		"CrEwSaDe",
-		"d3g",
-		"DDR",
-		"DNL",
-		"DeadFish",
-		"ELiTE",
-		"eSc",
-		"EVO",
-		"FaNGDiNG0",
-		"FGT",
-		"FRDS",
-		"FUM",
-		"HAiKU",
-		"HD2DVD",
-		"HDS",
-		"HDTime",
-		"Hi10",
-		"ION10",
-		"iPlanet",
-		"JIVE",
-		"KiNGDOM",
-		"Leffe",
-		"LiGaS",
-		"LOAD",
-		"MeGusta",
-		"MkvCage",
-		"mHD",
-		"mSD",
-		"NhaNc3",
-		"nHD",
-		"NOIVTC",
-		"nSD",
-		"Oj",
-		"Ozlem",
-		"PiRaTeS",
-		"PRoDJi",
-		"RAPiDCOWS",
-		"RARBG",
-		"RetroPeeps",
-		"RDN",
-		"REsuRRecTioN",
-		"RMTeam",
-		"SANTi",
-		"SicFoI",
-		"SPASM",
-		"SM737",
-		"SPDVD",
-		"STUTTERSHIT",
-		"TBS",
-		"Telly",
-		"TM",
-		"UPiNSMOKE",
-		"URANiME",
-		"WAF",
-		"xRed",
-		"XS",
-		"YIFY",
-		"YTS",
-		"Zeus",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-	},
-	"BHD": {
-		"Sicario",
-		"TOMMY",
-		"x0r",
-		"nikt0",
-		"FGT",
-		"d3g",
-		"MeGusta",
-		"YIFY",
-		"tigole",
-		"TEKNO3D",
-		"C4K",
-		"RARBG",
-		"4K4U",
-		"EASports",
-		"ReaLHD",
-		"Telly",
-		"AOC",
-		"WKS",
-		"SasukeducK",
-		"CRUCiBLE",
-		"iFT",
-		"ProRes",
-		"MezRips",
-		"Flights",
-		"BiTOR",
-		"iVy",
-		"QxR",
-		"SyncUP",
-		"OFT",
-		"TGS",
-	},
-	"BLU": {
-		"[Oj]",
-		"3LTON",
-		"4yEo",
-		"ADE",
-		"AFG",
-		"AniHLS",
-		"AnimeRG",
-		"AniURL",
-		"AROMA",
-		"aXXo",
-		"B3LLUM",
-		"BHDStudio",
-		"Brrip",
-		"CHD",
-		"CM8",
-		"CrEwSaDe",
-		"d3g",
-		"DeadFish",
-		"DNL",
-		"DTLegacy",
-		"ELiTE",
-		"eSc",
-		"EZTV",
-		"EZTV.RE",
-		"F13",
-		"FaNGDiNG0",
-		"FGT",
-		"Flights",
-		"flower",
-		"FRDS",
-		"FUM",
-		"HAiKU",
-		"hallowed",
-		"HD2DVD",
-		"HDS",
-		"HDTime",
-		"Hi10",
-		"ION10",
-		"iPlanet",
-		"JIVE",
-		"KiNGDOM",
-		"LAMA",
-		"Leffe",
-		"LEGi0N",
-		"LOAD",
-		"MeGusta",
-		"mHD",
-		"mSD",
-		"NhaNc3",
-		"nHD",
-		"nikt0",
-		"NOIVTC",
-		"nSD",
-		"OFT",
-		"PiRaTeS",
-		"playBD",
-		"PlaySD",
-		"playXD",
-		"PRODJi",
-		"RAPiDCOWS",
-		"RARBG",
-		"RetroPeeps",
-		"RDN",
-		"REsuRRecTioN",
-		"RMTeam",
-		"SANTi",
-		"SasukeducK",
-		"SicFoI",
-		"SPASM",
-		"SPDVD",
-		"STUTTERSHIT",
-		"Telly",
-		"TheFarm",
-		"TM",
-		"TRiToN",
-		"UPiNSMOKE",
-		"URANiME",
-		"VN_Foxcore",
-		"WAF",
-		"WKS",
-		"x0r",
-		"xRed",
-		"XS",
-		"YIFY",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-	},
-	"CBR": {
-		"4K4U",
-		"afm72",
-		"Alcaide_Kira",
-		"AROMA",
-		"ASM",
-		"Bandi",
-		"BiTOR",
-		"BLUDV",
-		"Bluespots",
-		"BOLS",
-		"CaNNIBal",
-		"Comando", //nolint:misspell // Specific group spelling.
-		"d3g",
-		"DepraveD",
-		"EMBER",
-		"FGT",
-		"FreetheFish",
-		"Garshasp",
-		"Ghost",
-		"Grym",
-		"HDS",
-		"Hi10",
-		"HiQVE",
-		"Hiro360",
-		"ImE",
-		"ION10",
-		"iVy",
-		"Judas",
-		"LAMA",
-		"Langbard",
-		"Lapumia",
-		"LION",
-		"MeGusta",
-		"MONOLITH",
-		"MRCS",
-		"NaNi",
-		"Natty",
-		"nikt0",
-		"OEPlus",
-		"OFT",
-		"OsC",
-		"Panda",
-		"PANDEMONiUM",
-		"PHOCiS",
-		"PiRaTeS",
-		"PYC",
-		"QxR",
-		"r00t",
-		"Ralphy",
-		"RARBG",
-		"RetroPeeps",
-		"RZeroX",
-		"S74Ll10n",
-		"SAMPA",
-		"Sicario",
-		"SiCFoI",
-		"Silence",
-		"SkipTT",
-		"SM737",
-		"SPDVD",
-		"STUTTERSHIT",
-		"SWTYBLZ",
-		"t3nzin",
-		"TAoE",
-		"TEKNO3D",
-		"Telly",
-		"TGx",
-		"Tigole",
-		"TSP",
-		"TSPxL",
-		"TWA",
-		"UnKn0wn",
-		"VXT",
-		"Vyndros",
-		"W32",
-		"Will1869",
-		"x0r",
-		"YIFY",
-		"YTS.MX",
-		"YTS",
-	},
-	"DP": {
-		"ARCADE",
-		"aXXo",
-		"BANDOLEROS",
-		"BONE",
-		"BRrip",
-		"CM8",
-		"CrEwSaDe",
-		"CTFOH",
-		"dAV1nci",
-		"DNL",
-		"eranger2",
-		"FaNGDiNG0",
-		"FGT",
-		"FiSTER",
-		"flower",
-		"GalaxyTV",
-		"HD2DVD",
-		"HDTime",
-		"HorribleSubs",
-		"iHYTECH",
-		"ION10",
-		"iPlanet",
-		"KiNGDOM",
-		"LAMA",
-		"MeGusta",
-		"mHD",
-		"mSD",
-		"NaNi",
-		"NhaNc3",
-		"nHD",
-		"nikt0",
-		"nSD",
-		"OFT",
-		"PiTBULL",
-		"PRODJi",
-		"PSA",
-		"RARBG",
-		"Rifftrax",
-		"ROCKETRACCOON",
-		"SANTi",
-		"SasukeducK",
-		"SEEDSTER",
-		"ShAaNiG",
-		"Sicario",
-		"STUTTERSHIT",
-		"Subsplease",
-		"SyncUp",
-		"TAoE",
-		"TGALAXY",
-		"TGx",
-		"TORRENTGALAXY",
-		"ToVaR",
-		"Trix",
-		"TSP",
-		"TSPxL",
-		"ViSION",
-		"VXT",
-		"WAF",
-		"WKS",
-		"X0r",
-		"YIFY",
-		"YTS",
-	},
-	"GPW": {
-		"ALT",
-		"aXXo",
-		"BATWEB",
-		"BlackTV",
-		"BitsTV",
-		"BMDRu",
-		"BRrip",
-		"CM8",
-		"CrEwSaDe",
-		"CTFOH",
-		"CTRLHD",
-		"DDHDTV",
-		"DNL",
-		"DreamHD",
-		"ENTHD",
-		"FaNGDiNG0",
-		"FGT",
-		"HD2DVD",
-		"HDTime",
-		"HDT",
-		"Huawei",
-		"GPTHD",
-		"ION10",
-		"iPlanet",
-		"KiNGDOM",
-		"Leffe",
-		"Mp4Ba",
-		"mHD",
-		"MiniHD",
-		"mSD",
-		"MOMOWEB",
-		"nHD",
-		"nikt0",
-		"NSBC",
-		"nSD",
-		"NhaNc3",
-		"NukeHD",
-		"OFT",
-		"PRODJi",
-		"RARBG",
-		"RDN",
-		"SANTi",
-		"SeeHD",
-		"SeeWEB",
-		"SM737",
-		"SonyHD",
-		"STUTTERSHIT",
-		"TAGWEB",
-		"ViSION",
-		"VXT",
-		"WAF",
-		"x0r",
-		"Xiaomi",
-		"YIFY",
-	},
-	"HHD": {
-		"aXXo",
-		"BONE",
-		"BRrip",
-		"CM8",
-		"CrEwSaDe",
-		"CTFOH",
-		"dAV1nci",
-		"d3g",
-		"DNL",
-		"FaNGDiNG0",
-		"GalaxyTV",
-		"HD2DVD",
-		"HDTime",
-		"iHYTECH",
-		"ION10",
-		"iPlanet",
-		"KiNGDOM",
-		"LAMA",
-		"MeGusta",
-		"mHD",
-		"mSD",
-		"NaNi",
-		"NhaNc3",
-		"nHD",
-		"nikt0",
-		"nSD",
-		"OFT",
-		"PRODJi",
-		"RARBG",
-		"Rifftrax",
-		"SANTi",
-		"SasukeducK",
-		"ShAaNiG",
-		"Sicario",
-		"STUTTERSHIT",
-		"TGALAXY",
-		"TORRENTGALAXY",
-		"TSP",
-		"TSPxL",
-		"ViSION",
-		"VXT",
-		"WAF",
-		"WKS",
-		"x0r",
-		"YAWNiX",
-		"YIFY",
-		"YTS",
-		"PSA",
-		"EVO",
-	},
-	"LT": {
-		"EVO",
-	},
-	"MTV": {
-		"3LTON",
-		"[Oj]",
-		"aXXo",
-		"BDP",
-		"BRrip",
-		"CM8",
-		"CrEwSaDe",
-		"CMCT",
-		"DeadFish",
-		"DNL",
-		"ELiTE",
-		"AFG",
-		"ZMNT",
-		"FaNGDiNG0",
-		"FRDS",
-		"FUM",
-		"h65",
-		"HD2DVD",
-		"HDTime",
-		"ION10",
-		"iPlanet",
-		"JIVE",
-		"KiNGDOM",
-		"LAMA",
-		"Leffe",
-		"LOAD",
-		"mHD",
-		"mRS",
-		"mSD",
-		"NhaNc3",
-		"nHD",
-		"nikt0",
-		"nSD",
-		"PandaRG",
-		"PRODJi",
-		"QxR",
-		"RARBG",
-		"RDN",
-		"SANTi",
-		"STUTTERSHIT",
-		"TERMiNAL",
-		"TM",
-		"ViSiON",
-		"WAF",
-		"x0r",
-		"XS",
-		"YIFY",
-		"ZKBL",
-		"ZmN",
-	},
-	"NBL": {
-		"0neshot",
-		"3LTON",
-		"4yEo",
-		"[Oj]",
-		"AFG",
-		"AkihitoSubs",
-		"AniHLS",
-		"Anime Time",
-		"AnimeRG",
-		"AniURL",
-		"ASW",
-		"BakedFish",
-		"bonkai77",
-		"Cleo",
-		"DeadFish",
-		"DeeJayAhmed",
-		"ELiTE",
-		"EMBER",
-		"eSc",
-		"EVO",
-		"FGT",
-		"FUM",
-		"GERMini",
-		"HAiKU",
-		"Hi10",
-		"ION10",
-		"JacobSwaggedUp",
-		"JIVE",
-		"Judas",
-		"LOAD",
-		"MeGusta",
-		"Mr.Deadpool",
-		"mSD",
-		"NemDiggers",
-		"neoHEVC",
-		"NhaNc3",
-		"NOIVTC",
-		"PlaySD",
-		"playXD",
-		"project-gxs",
-		"PSA",
-		"QaS",
-		"Ranger",
-		"RAPiDCOWS",
-		"Raze",
-		"Reaktor",
-		"REsuRRecTioN",
-		"RMTeam",
-		"ROBOTS",
-		"SpaceFish",
-		"SPASM",
-		"SSA",
-		"Telly",
-		"Tenrai-Sensei",
-		"TM",
-		"Trix",
-		"URANiME",
-		"VipapkStudios",
-		"ViSiON",
-		"Wardevil",
-		"xRed",
-		"XS",
-		"YakuboEncodes",
-		"YuiSubs",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-	},
-	"OE": {
-		"0neshot",
-		"3LT0N",
-		"4K4U",
-		"4yEo",
-		"$andra",
-		"[Oj]",
-		"AFG",
-		"AkihitoSubs",
-		"Alcaide_Kira",
-		"AniHLS",
-		"Anime Time",
-		"AnimeRG",
-		"AniURL",
-		"AOC",
-		"AR",
-		"AROMA",
-		"ASW",
-		"aXXo",
-		"BakedFish",
-		"BiTOR",
-		"BRrip",
-		"bonkai",
-		"Cleo",
-		"CM8",
-		"C4K",
-		"CrEwSaDe",
-		"core",
-		"d3g",
-		"DDR",
-		"DE3PM",
-		"DeadFish",
-		"DeeJayAhmed",
-		"DNL",
-		"ELiTE",
-		"EMBER",
-		"eSc",
-		"EVO",
-		"EZTV",
-		"FaNGDiNG0",
-		"FGT",
-		"fenix",
-		"FUM",
-		"FRDS",
-		"FROZEN",
-		"GalaxyTV",
-		"GalaxyRG",
-		"GalaxyRG265",
-		"GERMini",
-		"Grym",
-		"GrymLegacy",
-		"HAiKU",
-		"HD2DVD",
-		"HDTime",
-		"Hi10",
-		"HiQVE",
-		"ION10",
-		"iPlanet",
-		"iVy",
-		"JacobSwaggedUp",
-		"JIVE",
-		"Judas",
-		"KiNGDOM",
-		"LAMA",
-		"Leffe",
-		"LiGaS",
-		"LOAD",
-		"LycanHD",
-		"MeGusta",
-		"MezRips",
-		"mHD",
-		"Mr.Deadpool",
-		"mSD",
-		"NemDiggers",
-		"neoHEVC",
-		"NeXus",
-		"nHD",
-		"nikt0",
-		"nSD",
-		"NhaNc3",
-		"NOIVTC",
-		"pahe.in",
-		"PlaySD",
-		"playXD",
-		"PRODJi",
-		"ProRes",
-		"project-gxs",
-		"PSA",
-		"QaS",
-		"Ranger",
-		"RAPiDCOWS",
-		"RARBG",
-		"Raze",
-		"RCDiVX",
-		"RDN",
-		"Reaktor",
-		"REsuRRecTioN",
-		"RMTeam",
-		"ROBOTS",
-		"rubix",
-		"SANTi",
-		"SHUTTERSHIT",
-		"SM737",
-		"SpaceFish",
-		"SPASM",
-		"SSA",
-		"TBS",
-		"Telly",
-		"Tenrai-Sensei",
-		"TERMiNAL",
-		"TGx",
-		"TM",
-		"topaz",
-		"ToVaR",
-		"TSP",
-		"TSPxL",
-		"UnKn0wn",
-		"URANiME",
-		"UTR",
-		"VipapkSudios",
-		"ViSION",
-		"WAF",
-		"Wardevil",
-		"x0r",
-		"xRed",
-		"XS",
-		"YakuboEncodes",
-		"YAWNTiC",
-		"YAWNiX",
-		"YIFY",
-		"YTS",
-		"YuiSubs",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-	},
-	"OTW": {
-		"[Oj]",
-		"3LTON",
-		"4yEo",
-		"ADE",
-		"AFG",
-		"AniHLS",
-		"AnimeRG",
-		"AniURL",
-		"AROMA",
-		"aXXo",
-		"CM8",
-		"CrEwSaDe",
-		"DeadFish",
-		"DNL",
-		"ELiTE",
-		"eSc",
-		"FaNGDiNG0",
-		"FGT",
-		"Flights",
-		"FRDS",
-		"FUM",
-		"GalaxyRG",
-		"HAiKU",
-		"HD2DVD",
-		"HDS",
-		"HDTime",
-		"Hi10",
-		"INFINITY",
-		"ION10",
-		"iPlanet",
-		"JIVE",
-		"KiNGDOM",
-		"LAMA",
-		"Leffe",
-		"LOAD",
-		"mHD",
-		"NhaNc3",
-		"nHD",
-		"NOIVTC",
-		"nSD",
-		"PiRaTeS",
-		"PRODJi",
-		"RAPiDCOWS",
-		"RARBG",
-		"RDN",
-		"REsuRRecTioN",
-		"RMTeam",
-		"SANTi",
-		"SicFoI",
-		"SPASM",
-		"STUTTERSHIT",
-		"Telly",
-		"TM",
-		"UPiNSMOKE",
-		"WAF",
-		"xRed",
-		"XS",
-		"YELLO",
-		"YIFY",
-		"YTS",
-		"ZKBL",
-		"ZmN",
-		"4f8c4100292",
-		"Azkars",
-		"Sync0rdi",
-	},
-	"PHD": {
-		"RARBG",
-		"STUTTERSHIT",
-		"LiGaS",
-		"DDR",
-		"Zeus",
-		"TBS",
-		"SWTYBLZ",
-		"EASports",
-		"C4K",
-		"d3g",
-		"MeGusta",
-		"YTS",
-		"YIFY",
-		"Tigole",
-		"x0r",
-		"nikt0",
-		"NhaNc3",
-		"PRoDJi",
-		"RDN",
-		"SANTi",
-		"FaNGDiNG0",
-		"FRDS",
-		"HD2DVD",
-		"HDTime",
-		"iPlanet",
-		"KiNGDOM",
-		"Leffe",
-		"4K4U",
-		"Xiaomi",
-		"VisionXpert",
-		"WKS",
-	},
-	"PTP": {
-		"aXXo",
-		"BMDru",
-		"BRrip",
-		"CM8",
-		"CrEwSaDe",
-		"CTFOH",
-		"d3g",
-		"DNL",
-		"FaNGDiNG0",
-		"HD2DVD",
-		"HDT",
-		"HDTime",
-		"ION10",
-		"iPlanet",
-		"KiNGDOM",
-		"mHD",
-		"mSD",
-		"nHD",
-		"nikt0",
-		"nSD",
-		"NhaNc3",
-		"OFT",
-		"PRODJi",
-		"SANTi",
-		"SPiRiT",
-		"STUTTERSHIT",
-		"ViSION",
-		"VXT",
-		"WAF",
-		"x0r",
-		"YIFY",
-		"LAMA",
-		"WORLD",
-	},
-	"PTT": {
-		"ViP",
-		"BiRD",
-		"M@RTiNU$",
-		"inTGrity",
-		"CiNEMAET",
-		"MusicET",
-		"TeamET",
-		"R2D2",
-	},
-	"RAS": {
-		"YTS",
-		"YiFY",
-		"LAMA",
-		"MeGUSTA",
-		"NAHOM",
-		"GalaxyRG",
-		"RARBG",
-		"INFINITY",
-	},
-	"RHD": {
-		"1XBET",
-		"MEGA",
-		"MTZ",
-		"Whistler",
-		"WOTT",
-		"Taylor.D",
-		"HELD",
-		"FSX",
-		"FuN",
-		"MagicX",
-		"w00t",
-		"PaTroL",
-		"BB",
-		"266ers",
-		"GTF",
-		"JellyfinPlex",
-		"2BA",
-		"FritzBox",
-		"FUNXDTV",
-	},
-	"TOS": {
-		"FL3ER",
-		"SUNS3T",
-		"WoLFHD",
-		"EXTREME",
-		"Slay3R",
-		"3T3AM",
-		"BARBiE",
-	},
-	"BTN": {
-		"3LTON",
-		"4yEo",
-		"7VFr33104D",
-		"AFG",
-		"AniHLS",
-		"AnimeRG",
-		"AniURL",
-		"DeadFish",
-		"ELiTE",
-		"eSc",
-		"EVO",
-		"FGT",
-		"FUM",
-		"GalaxyTV",
-		"GRANiTEN",
-		"HAiKU",
-		"Hi10",
-		"ION10",
-		"JFF",
-		"JIVE",
-		"LOAD",
-		"MeGusta",
-		"mSD",
-		"NhaNc3",
-		"NOIVTC",
-		"PHOENiX",
-		"PlaySD",
-		"playXD",
-		"Pr1M371M3",
-		"RAPiDCOWS",
-		"REsuRRecTioN",
-		"RMTeam",
-		"ROBOTS",
-		"RUBiK",
-		"SPASM",
-		"Telly",
-		"TM",
-		"URANiME",
-		"ViSiON",
-		"W45Ps",
-		"xRed",
-		"XS",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-		"[Oj]",
-	},
-	"ULCX": {
-		"4K4U",
-		"AROMA",
-		"d3g",
-		"EDGE2020",
-		"EMBER",
-		"FGT",
-		"FnP",
-		"FRDS",
-		"Grym",
-		"Hi10",
-		"iAHD",
-		"INFINITY",
-		"ION10",
-		"iVy",
-		"Judas",
-		"LAMA",
-		"MeGusta",
-		"NAHOM",
-		"Niblets",
-		"nikt0",
-		"NuBz",
-		"OFT",
-		"QxR",
-		"Ralphy",
-		"RARBG",
-		"Sicario",
-		"SM737",
-		"SPDVD",
-		"SWTYBLZ",
-		"TAoE",
-		"TGx",
-		"Tigole",
-		"TSP",
-		"TSPxL",
-		"VXT",
-		"Vyndros",
-		"Will1869",
-		"x0r",
-		"YIFY",
-		"Alcaide_Kira",
-		"PHOCiS",
-		"HDT",
-		"SPx",
-		"seedpool",
-	},
-	"YUS": {
-		"ADDICTION",
-		"B3LLUM",
-		"BANDOLEROS",
-		"BigEasy",
-		"CINEMAXIS",
-		"D3US",
-		"d3g",
-		"DUMMESCHWEDEN",
-		"FGT",
-		"GRANiTEN",
-		"KiNGDOM",
-		"Lama",
-		"MeGusta",
-		"MezRips",
-		"mHD",
-		"mRS",
-		"msd",
-		"NeXus",
-		"NhaNc3",
-		"nHD",
-		"NorTekst",
-		"NORViNE",
-		"PANDEMONiUM",
-		"PiTBULL",
-		"RAPiDCOWS",
-		"RARBG",
-		"Radarr",
-		"RCDiVX",
-		"RDN",
-		"ROCKETRACCOON",
-		"SANTi",
-		"SHOWTiME",
-		"SOOSi",
-		"SUXWIC",
-		"TOXVIO",
-		"TWA",
-		"VXT",
-		"Will1869",
-		"x0r",
-		"XS",
-		"YIFY",
-		"YOLAND",
-		"YTS",
-		"ZKBL",
-		"ZmN",
-		"ZMNT",
-	},
-}
diff --git a/internal/trackers/banned_test.go b/internal/trackers/banned_test.go
index 8f64b005..3bf222f7 100644
--- a/internal/trackers/banned_test.go
+++ b/internal/trackers/banned_test.go
@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"os"
 	"path/filepath"
 	"slices"
@@ -23,6 +24,99 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+type bannedRewriteTransport struct {
+	base *url.URL
+	rt   http.RoundTripper
+}
+
+func (t bannedRewriteTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	clone := req.Clone(req.Context())
+	clone.URL.Scheme = t.base.Scheme
+	clone.URL.Host = t.base.Host
+	clone.Host = t.base.Host
+	resp, err := t.rt.RoundTrip(clone)
+	if err != nil {
+		return nil, fmt.Errorf("round trip rewritten banned-group request: %w", err)
+	}
+	return resp, nil
+}
+
+func bannedRewriteClient(t *testing.T, server *httptest.Server) *http.Client {
+	t.Helper()
+	base, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse banned-group test server URL: %v", err)
+	}
+	client := server.Client()
+	client.Transport = bannedRewriteTransport{base: base, rt: client.Transport}
+	return client
+}
+
+func newTestBannedGroupChecker(t *testing.T, dbPath string) *BannedGroupChecker {
+	t.Helper()
+	return NewBannedGroupCheckerWithRegistry(dbPath, newTestBannedPolicyRegistry(t))
+}
+
+func newTestBannedPolicyRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	policies := map[string]struct {
+		baseURL string
+		policy  BannedGroupPolicy
+	}{
+		"AITHER": {baseURL: "https://aither.cc", policy: BannedGroupPolicy{EndpointPath: "/api/blacklists/releasegroups", RequireAPIKey: true}},
+		"LST":    {baseURL: "https://lst.gg", policy: BannedGroupPolicy{EndpointPath: "/api/bannedReleaseGroups", RequireAPIKey: true}},
+		"LUME":   {baseURL: "https://luminarr.me", policy: BannedGroupPolicy{TRaSHGuideURL: trashGuideBannedGroupsURL}},
+		"SPD": {baseURL: "https://speedapp.io", policy: BannedGroupPolicy{
+			DefaultEndpoint: "https://speedapp.io/api/torrent/release-group/blacklist",
+			EndpointPath:    "/api/torrent/release-group/blacklist",
+			RequireAPIKey:   true,
+		}},
+	}
+	for name, item := range policies {
+		policy := item.policy
+		if err := registry.RegisterDescriptor(Descriptor{
+			Name:         name,
+			BaseURL:      item.baseURL,
+			Definition:   stubDefinition{name: name},
+			BannedPolicy: &policy,
+		}); err != nil {
+			t.Fatalf("register %s banned policy: %v", name, err)
+		}
+	}
+	static := map[string][]string{
+		"A4K":  {"TEKNO3D"},
+		"BLU":  {"TheFarm"},
+		"CBR":  {"YTS.MX"},
+		"DP":   {"FGT", "PSA", "HorribleSubs", "Subsplease", "SyncUp", "Trix"},
+		"GPW":  {"MOMOWEB"},
+		"HHD":  {"EVO"},
+		"LT":   {"EVO"},
+		"MTV":  {"PandaRG"},
+		"NBL":  {"YakuboEncodes"},
+		"OE":   {"VipapkSudios"},
+		"OTW":  {"Sync0rdi"},
+		"PHD":  {"VisionXpert"},
+		"PTP":  {"WORLD"},
+		"PTT":  {"M@RTiNU$"},
+		"RAS":  {"INFINITY"},
+		"RHD":  {"MagicX"},
+		"TOS":  {"FL3ER"},
+		"ULCX": {"EDGE2020", "NuBz", "Ralphy"},
+		"YUS":  {"YOLAND"},
+	}
+	for name, groups := range static {
+		if err := registry.RegisterDescriptor(Descriptor{
+			Name:         name,
+			Definition:   stubDefinition{name: name},
+			BannedGroups: groups,
+		}); err != nil {
+			t.Fatalf("register %s static banned groups: %v", name, err)
+		}
+	}
+	return registry
+}
+
 type bannedRefreshTestLogger struct {
 	debugMessages []string
 }
@@ -43,7 +137,7 @@ func TestNewBannedGroupCheckerFromDBPath(t *testing.T) {
 	t.Parallel()
 
 	tempDir := t.TempDir()
-	checker := NewBannedGroupChecker(filepath.Join(tempDir, "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(tempDir, "db.sqlite"))
 	if checker == nil {
 		t.Fatalf("expected checker, got nil")
 	}
@@ -58,7 +152,7 @@ func TestNewBannedGroupCheckerNoPathUsesDefaultRoot(t *testing.T) {
 	t.Setenv("USERPROFILE", home)
 	t.Setenv("XDG_CONFIG_HOME", "")
 
-	checker := NewBannedGroupChecker(" ")
+	checker := newTestBannedGroupChecker(t, " ")
 	if checker == nil {
 		t.Fatalf("expected checker")
 	}
@@ -71,11 +165,9 @@ func TestNewBannedGroupCheckerNoPathUsesDefaultRoot(t *testing.T) {
 func TestBannedGroupCheckerStaticBuiltins(t *testing.T) {
 	t.Parallel()
 
-	checker := NewBannedGroupChecker(filepath.Join(t.TempDir(), "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(t.TempDir(), "db.sqlite"))
 	cases := map[string][]string{
 		"A4K":  {"TEKNO3D"},
-		"ANT":  {"ZMNT"},
-		"BHD":  {"ProRes", "MezRips", "Flights", "BiTOR", "iVy", "QxR", "SyncUP", "OFT", "TGS"},
 		"BLU":  {"TheFarm"},
 		"CBR":  {"YTS.MX"},
 		"DP":   {"FGT", "PSA", "HorribleSubs", "Subsplease", "SyncUp", "Trix"},
@@ -109,7 +201,7 @@ func TestBannedGroupCheckerStaticBuiltins(t *testing.T) {
 func TestBannedGroupCheckerMergesBuiltinsWithCacheFile(t *testing.T) {
 	t.Parallel()
 
-	checker := NewBannedGroupChecker(filepath.Join(t.TempDir(), "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(t.TempDir(), "db.sqlite"))
 	if checker == nil {
 		t.Fatalf("expected checker")
 	}
@@ -135,7 +227,7 @@ func TestBannedGroupCheckerMergesBuiltinsWithCacheFile(t *testing.T) {
 func TestBannedGroupCheckerUnreadableCacheFallsBackToRhdBuiltins(t *testing.T) {
 	t.Parallel()
 
-	checker := NewBannedGroupChecker(filepath.Join(t.TempDir(), "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(t.TempDir(), "db.sqlite"))
 	if checker == nil {
 		t.Fatalf("expected checker")
 	}
@@ -184,7 +276,7 @@ func TestBannedGroupCheckerUnreadableCacheFallsBackToRhdBuiltins(t *testing.T) {
 func TestBannedGroupCheckerDPDoesNotIncludeRemovedHDT(t *testing.T) {
 	t.Parallel()
 
-	checker := NewBannedGroupChecker(filepath.Join(t.TempDir(), "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(t.TempDir(), "db.sqlite"))
 	banned, err := checker.IsBanned("DP", "HDT")
 	if err != nil {
 		t.Fatalf("check HDT: %v", err)
@@ -232,11 +324,12 @@ func TestRefreshDynamicBannedGroupsCachesAither(t *testing.T) {
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
+				"AITHER": {APIKey: "aither-key"},
 			},
 		},
 	}
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
+	checker.client = bannedRewriteClient(t, server)
 
 	if err := checker.RefreshDynamic(context.Background(), cfg, []string{"AITHER"}, api.NopLogger{}); err != nil {
 		t.Fatalf("refresh banned groups: %v", err)
@@ -290,12 +383,14 @@ func TestRefreshDynamicBannedGroupsRejectsTrailingJSON(t *testing.T) {
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
+				"AITHER": {APIKey: "aither-key"},
 			},
 		},
 	}
 
-	_, _, err := fetchDynamicBannedGroups(context.Background(), cfg, "AITHER")
+	_, _, err := fetchDynamicBannedGroupsWithClient(
+		context.Background(), cfg, "AITHER", newTestBannedPolicyRegistry(t), bannedRewriteClient(t, server),
+	)
 	if err == nil {
 		t.Fatalf("expected trailing JSON error")
 	}
@@ -303,7 +398,8 @@ func TestRefreshDynamicBannedGroupsRejectsTrailingJSON(t *testing.T) {
 		t.Fatalf("expected trailing JSON error, got %v", err)
 	}
 
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
+	checker.client = bannedRewriteClient(t, server)
 	if err := checker.RefreshDynamic(context.Background(), cfg, []string{"AITHER"}, api.NopLogger{}); err != nil {
 		t.Fatalf("refresh banned groups with malformed response: %v", err)
 	}
@@ -316,7 +412,7 @@ func TestRefreshDynamicBannedGroupsRejectsTrailingJSON(t *testing.T) {
 func TestRefreshDynamicDoesNotLogUnsupportedTrackers(t *testing.T) {
 	t.Parallel()
 
-	checker := NewBannedGroupChecker(filepath.Join(t.TempDir(), "db.sqlite"))
+	checker := newTestBannedGroupChecker(t, filepath.Join(t.TempDir(), "db.sqlite"))
 	logger := &bannedRefreshTestLogger{}
 
 	if err := checker.RefreshDynamic(context.Background(), config.Config{}, []string{"DP", "BHD", "MTV"}, logger); err != nil {
@@ -351,11 +447,13 @@ func TestFetchDynamicBannedGroupsRejectsRepeatedCursor(t *testing.T) {
 	cfg := config.Config{
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
+				"AITHER": {APIKey: "aither-key"},
 			},
 		},
 	}
-	_, _, err := fetchDynamicBannedGroups(context.Background(), cfg, "AITHER")
+	_, _, err := fetchDynamicBannedGroupsWithClient(
+		context.Background(), cfg, "AITHER", newTestBannedPolicyRegistry(t), bannedRewriteClient(t, server),
+	)
 	if err == nil {
 		t.Fatalf("expected repeated cursor error")
 	}
@@ -383,7 +481,7 @@ func TestFetchDynamicBannedGroupsPageRetriesSPDRawKeyOnBearerAuthFailure(t *test
 			}))
 			defer server.Close()
 
-			groups, _, nextCursor, err := fetchDynamicBannedGroupsPage(context.Background(), server.Client(), server.URL, "SPD", "spd-key", "")
+			groups, _, nextCursor, err := fetchDynamicBannedGroupsPage(context.Background(), server.Client(), server.URL, "SPD", "spd-key", "", true)
 			if err != nil {
 				t.Fatalf("fetch SPD banned groups: %v", err)
 			}
@@ -416,7 +514,7 @@ func TestFetchDynamicBannedGroupsPageDoesNotRetrySPDRawKeyOnNonAuthFailure(t *te
 	}))
 	defer server.Close()
 
-	_, _, _, err := fetchDynamicBannedGroupsPage(context.Background(), server.Client(), server.URL, "SPD", "spd-key", "")
+	_, _, _, err := fetchDynamicBannedGroupsPage(context.Background(), server.Client(), server.URL, "SPD", "spd-key", "", true)
 	if err == nil {
 		t.Fatalf("expected non-auth status error")
 	}
@@ -437,11 +535,13 @@ func TestFetchDynamicBannedGroupsRejectsOversizedSuccessBody(t *testing.T) {
 	cfg := config.Config{
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
+				"AITHER": {APIKey: "aither-key"},
 			},
 		},
 	}
-	_, _, err := fetchDynamicBannedGroups(context.Background(), cfg, "AITHER")
+	_, _, err := fetchDynamicBannedGroupsWithClient(
+		context.Background(), cfg, "AITHER", newTestBannedPolicyRegistry(t), bannedRewriteClient(t, server),
+	)
 	if err == nil {
 		t.Fatalf("expected oversized response error")
 	}
@@ -497,7 +597,7 @@ func TestRefreshDynamicFreshCacheInvalidatesLoadedGroups(t *testing.T) {
 	cfg := config.Config{
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 	}
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
 	cachePath := filepath.Join(tempDir, "cache", "banned", "AITHER_banned_groups.json")
 	if err := writeBannedGroupsCache(cachePath, []string{"OldGRP"}, nil); err != nil {
 		t.Fatalf("write old banned groups cache: %v", err)
@@ -539,7 +639,7 @@ func TestRefreshDynamicCanceledAfterFetchDoesNotWriteOrInvalidate(t *testing.T)
 	cfg := config.Config{
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 	}
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
 	cachePath := filepath.Join(tempDir, "cache", "banned", "AITHER_banned_groups.json")
 	if err := writeBannedGroupsCache(cachePath, []string{"OldGRP"}, nil); err != nil {
 		t.Fatalf("write old banned groups cache: %v", err)
@@ -710,7 +810,7 @@ func TestRefreshDynamicBannedGroupsCachesLUMEFromTRaSHGuide(t *testing.T) {
 	cfg := config.Config{
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 	}
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
 
 	if err := checker.RefreshDynamic(context.Background(), cfg, []string{"LUME"}, api.NopLogger{}); err != nil {
 		t.Fatalf("refresh banned groups: %v", err)
@@ -759,11 +859,11 @@ func TestRefreshDynamicBannedGroupsMissingAPIKeyDoesNotWriteEmptyCache(t *testin
 		MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "upbrr.db")},
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {URL: "https://aither.example.invalid"},
+				"AITHER": {},
 			},
 		},
 	}
-	checker := NewBannedGroupChecker(cfg.MainSettings.DBPath)
+	checker := newTestBannedGroupChecker(t, cfg.MainSettings.DBPath)
 
 	if err := checker.RefreshDynamic(context.Background(), cfg, []string{"AITHER"}, api.NopLogger{}); err != nil {
 		t.Fatalf("refresh banned groups: %v", err)
diff --git a/internal/trackers/bhdmeta/bhdmeta.go b/internal/trackers/bhdmeta/bhdmeta.go
deleted file mode 100644
index 19704b0e..00000000
--- a/internal/trackers/bhdmeta/bhdmeta.go
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Package bhdmeta maps prepared metadata to BHD upload and dupe-search enums.
-package bhdmeta
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-// Source maps local source labels to BHD's upload source enum.
-// The boolean is false when BHD has no supported source value for the input.
-func Source(source string) (string, bool) {
-	switch strings.ToUpper(strings.TrimSpace(source)) {
-	case "BLURAY", "BLU-RAY":
-		return "Blu-ray", true
-	case "HDDVD", "HD DVD", "HD-DVD":
-		return "HD-DVD", true
-	case "WEB", "WEB-DL", "WEBDL", "WEBRIP":
-		return "WEB", true
-	case "HDTV", "UHDTV":
-		return "HDTV", true
-	case "NTSC", "PAL", "NTSC DVD", "PAL DVD", "DVD":
-		return "DVD", true
-	default:
-		return "", false
-	}
-}
-
-// SourceForMetadata maps the canonical prepared source.
-func SourceForMetadata(meta api.PreparedMetadata) (string, bool) {
-	return Source(meta.Source)
-}
-
-// Type maps prepared metadata to BHD's upload/search type enum. Unknown or
-// unsupported combinations return Other, including direct 576i releases and
-// HD-DVD remuxes.
-func Type(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		size := 100
-		for _, candidate := range []int{25, 50, 66, 100} {
-			if meta.SourceSize > 0 && meta.SourceSize < int64(candidate)<<30 {
-				size = candidate
-				break
-			}
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && size != 25 {
-			if size == 50 || size == 66 || size == 100 {
-				return fmt.Sprintf("UHD %d", size)
-			}
-			return "Other"
-		}
-		if size == 25 || size == 50 {
-			return fmt.Sprintf("BD %d", size)
-		}
-		return "Other"
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		upper := strings.ToUpper(strings.TrimSpace(meta.Release.Size))
-		switch {
-		case strings.Contains(upper, "DVD5"):
-			return "DVD 5"
-		case strings.Contains(upper, "DVD9"):
-			return "DVD 9"
-		default:
-			return "Other"
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(firstNonEmpty(meta.Type, meta.Release.Type)), "REMUX") {
-		source := firstNonEmpty(meta.Source, meta.Release.Source)
-		switch {
-		case isHDDVDSource(source):
-			return "Other"
-		case strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD"):
-			return "UHD Remux"
-		case isDVDSource(source):
-			return "DVD Remux"
-		case strings.EqualFold(strings.TrimSpace(source), "BluRay"), strings.EqualFold(strings.TrimSpace(source), "Blu-ray"):
-			return "BD Remux"
-		default:
-			return "Other"
-		}
-	}
-	resolution := normalizeResolution(meta.Release.Resolution)
-	switch resolution {
-	case "2160p", "1080p", "1080i", "720p", "576p", "540p", "480p":
-		return resolution
-	default:
-		return "Other"
-	}
-}
-
-// SearchType returns the BHD search type filter. The boolean is false for DVD
-// searches because BHD matching is broader when the type filter is omitted.
-func SearchType(meta api.PreparedMetadata) (string, bool) {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return "", false
-	}
-	return Type(meta), true
-}
-
-// IsSD reports whether BHD should mark the release as SD or omit HD-only dupe
-// filters.
-func IsSD(meta api.PreparedMetadata) bool {
-	resolution := normalizeResolution(meta.Release.Resolution)
-	return strings.Contains(resolution, "480") || strings.Contains(resolution, "540") || strings.Contains(resolution, "576")
-}
-
-// IsDVDSource reports whether a source label maps to BHD's DVD source.
-func IsDVDSource(source string) bool {
-	return isDVDSource(source)
-}
-
-func normalizeResolution(value string) string {
-	return strings.ToLower(strings.TrimSpace(value))
-}
-
-func isDVDSource(source string) bool {
-	upper := strings.ToUpper(strings.TrimSpace(source))
-	return upper == "PAL DVD" || upper == "NTSC DVD" || upper == "DVD" || upper == "PAL" || upper == "NTSC"
-}
-
-func isHDDVDSource(source string) bool {
-	upper := strings.ToUpper(strings.TrimSpace(source))
-	return upper == "HDDVD" || upper == "HD DVD" || upper == "HD-DVD"
-}
-
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
diff --git a/internal/trackers/bhdmeta/bhdmeta_test.go b/internal/trackers/bhdmeta/bhdmeta_test.go
deleted file mode 100644
index 8abd28a7..00000000
--- a/internal/trackers/bhdmeta/bhdmeta_test.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhdmeta
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestSourceForMetadataDoesNotFallbackToParsedSource(t *testing.T) {
-	t.Parallel()
-
-	got, ok := SourceForMetadata(api.PreparedMetadata{
-		Release: api.ReleaseInfo{Source: "WEB"},
-	})
-	if ok || got != "" {
-		t.Fatalf("expected missing canonical source to remain unsupported, got source=%q ok=%t", got, ok)
-	}
-}
diff --git a/internal/trackers/catalog.go b/internal/trackers/catalog.go
deleted file mode 100644
index da92f8a3..00000000
--- a/internal/trackers/catalog.go
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackers
-
-import (
-	"slices"
-	"sort"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
-)
-
-type Kind string
-
-const (
-	KindUnknown   Kind = ""
-	KindUnit3D    Kind = "unit3d"
-	KindNonUnit3D Kind = "non-unit3d"
-)
-
-var knownNonUnit3DTrackers = map[string]struct{}{
-	"ACM":    {},
-	"ANT":    {},
-	"AR":     {},
-	"ASC":    {},
-	"AZ":     {},
-	"BHD":    {},
-	"BHDTV":  {},
-	"BJS":    {},
-	"BT":     {},
-	"BTN":    {},
-	"CZ":     {},
-	"CZT":    {},
-	"DC":     {},
-	"FF":     {},
-	"FL":     {},
-	"GPW":    {},
-	"HDB":    {},
-	"HDS":    {},
-	"HDT":    {},
-	"IS":     {},
-	"MTV":    {},
-	"NBL":    {},
-	"PHD":    {},
-	"PTP":    {},
-	"PTS":    {},
-	"RTF":    {},
-	"SPD":    {},
-	"THR":    {},
-	"TL":     {},
-	"TVC":    {},
-	"MANUAL": {},
-}
-
-var (
-	trackerKinds    = buildTrackerKinds()
-	trackerPriority = buildTrackerPriority()
-)
-
-// KnownTrackers returns the sorted list of tracker names in the registry.
-func KnownTrackers() []string {
-	trackers := make([]string, 0, len(trackerKinds))
-	for name := range trackerKinds {
-		trackers = append(trackers, name)
-	}
-	sort.Strings(trackers)
-	return trackers
-}
-
-// Unit3DTrackers returns the sorted list of Unit3D tracker names in the registry.
-func Unit3DTrackers() []string {
-	return trackersByKind(KindUnit3D)
-}
-
-// NonUnit3DTrackers returns the sorted list of non-Unit3D tracker names in the registry.
-func NonUnit3DTrackers() []string {
-	return trackersByKind(KindNonUnit3D)
-}
-
-// TrackerPriority returns the shared lowercase tracker ordering used when
-// ranking tracker IDs and metadata lookups. It prefers the curated list first,
-// then appends any remaining Unit3D trackers in sorted order.
-func TrackerPriority() []string {
-	return append([]string(nil), trackerPriority...)
-}
-
-func buildTrackerPriority() []string {
-	preferred := []string{
-		"aither", "ulcx", "lst", "blu", "oe", "btn", "bhd",
-		"hdb", "ant", "rf", "otw", "yus", "dp", "sp", "ptp",
-	}
-
-	seen := make(map[string]struct{}, len(preferred))
-	unit3dTrackers := Unit3DTrackers()
-	ordered := make([]string, 0, len(preferred)+len(unit3dTrackers))
-	for _, name := range preferred {
-		trimmed := strings.ToLower(strings.TrimSpace(name))
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		ordered = append(ordered, trimmed)
-	}
-
-	for _, tracker := range unit3dTrackers {
-		lower := strings.ToLower(strings.TrimSpace(tracker))
-		if _, ok := seen[lower]; ok {
-			continue
-		}
-		seen[lower] = struct{}{}
-		ordered = append(ordered, lower)
-	}
-
-	return ordered
-}
-
-func IsKnownTracker(name string) bool {
-	return TrackerKind(name) != KindUnknown
-}
-
-func IsUnit3DTracker(name string) bool {
-	return TrackerKind(name) == KindUnit3D
-}
-
-func IsNonUnit3DTracker(name string) bool {
-	return TrackerKind(name) == KindNonUnit3D
-}
-
-// skipsModifiedReleaseCheck reports whether a tracker is exempt from the
-// modified/renamed-release rule (see isRenamedRelease). The rule is on for all
-// trackers by default; this is the single place to exempt special pseudo-trackers
-// or any tracker known to accept modified releases.
-func skipsModifiedReleaseCheck(name string) bool {
-	switch strings.ToUpper(strings.TrimSpace(name)) {
-	case "MANUAL":
-		return true
-	default:
-		return false
-	}
-}
-
-// NeedsPTBRLocalizedMetadata reports whether a trimmed tracker name is one of
-// the exact trackers that consumes pt-BR TMDB data.
-func NeedsPTBRLocalizedMetadata(name string) bool {
-	switch strings.ToLower(strings.TrimSpace(name)) {
-	case "bjs", "bt", "asc":
-		return true
-	default:
-		return false
-	}
-}
-
-// AnyNeedsPTBRLocalizedMetadata reports whether any tracker name resolves to an
-// exact pt-BR localized metadata consumer.
-func AnyNeedsPTBRLocalizedMetadata(names []string) bool {
-	return slices.ContainsFunc(names, NeedsPTBRLocalizedMetadata)
-}
-
-func TrackerKind(name string) Kind {
-	return trackerKinds[strings.ToUpper(strings.TrimSpace(name))]
-}
-
-func trackersByKind(kind Kind) []string {
-	trackers := make([]string, 0, len(trackerKinds))
-	for name, trackerKind := range trackerKinds {
-		if trackerKind != kind {
-			continue
-		}
-		trackers = append(trackers, name)
-	}
-	sort.Strings(trackers)
-	return trackers
-}
-
-func buildTrackerKinds() map[string]Kind {
-	trackers := make(map[string]Kind, len(knownNonUnit3DTrackers)+len(unit3dmeta.Trackers()))
-	for name := range knownNonUnit3DTrackers {
-		trackers[name] = KindNonUnit3D
-	}
-	for _, tracker := range unit3dmeta.Trackers() {
-		trackers[tracker] = KindUnit3D
-	}
-	return trackers
-}
diff --git a/internal/trackers/data/client.go b/internal/trackers/data/client.go
new file mode 100644
index 00000000..62c6a1ad
--- /dev/null
+++ b/internal/trackers/data/client.go
@@ -0,0 +1,93 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package data coordinates metadata lookups owned by tracker implementations.
+package data
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Result is the normalized metadata returned by a tracker lookup.
+type Result = trackers.DataLookupResult
+
+// Client dispatches metadata lookups through tracker registry capabilities.
+type Client struct {
+	cfg    config.Config
+	logger api.Logger
+	http   *http.Client
+
+	lookups  map[string]trackers.DataLookup
+	registry *trackers.Registry
+}
+
+// NewClientWithRegistry snapshots registry data-lookup factories at construction.
+// It substitutes a 30-second HTTP client and no-op logger and panics when
+// registry is nil.
+func NewClientWithRegistry(cfg config.Config, logger api.Logger, httpClient *http.Client, registry *trackers.Registry) *Client {
+	if registry == nil {
+		panic("tracker data: registry is required")
+	}
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	if httpClient == nil {
+		httpClient = &http.Client{Timeout: 30 * time.Second}
+	}
+	client := &Client{
+		cfg:      cfg,
+		logger:   logger,
+		http:     httpClient,
+		lookups:  make(map[string]trackers.DataLookup),
+		registry: registry,
+	}
+	for _, name := range registry.Names() {
+		if factory, ok := registry.LookupDataFactory(name); ok {
+			client.lookups[name] = factory.NewDataLookup(cfg, httpClient, logger)
+		}
+	}
+	return client
+}
+
+// Lookup dispatches to a registered tracker lookup, then falls back to generic
+// Unit3D lookup for Unit3D-family trackers. Unknown or unsupported trackers
+// return an empty result without error; tracker lookup errors are wrapped with
+// the normalized tracker name.
+func (c *Client) Lookup(
+	ctx context.Context,
+	tracker string,
+	trackerID string,
+	meta api.UploadSubject,
+	searchFileName string,
+	onlyID bool,
+	keepImages bool,
+) (Result, error) {
+	normalized := strings.ToUpper(strings.TrimSpace(tracker))
+	if lookup, ok := c.lookups[normalized]; ok {
+		result, err := lookup.Lookup(ctx, trackers.DataLookupRequest{
+			TrackerID:  trackerID,
+			Meta:       meta,
+			SearchName: searchFileName,
+			OnlyID:     onlyID,
+			KeepImages: keepImages,
+		})
+		if err != nil {
+			return Result{}, fmt.Errorf("trackerdata: %s lookup: %w", normalized, err)
+		}
+		return result, nil
+	}
+	family, registered := c.registry.LookupFamily(normalized)
+	if registered && family == trackers.FamilyUnit3D {
+		return c.lookupUnit3D(ctx, normalized, trackerID, searchFileName, onlyID, keepImages)
+	}
+
+	return Result{}, nil
+}
diff --git a/internal/trackers/data/unit3d.go b/internal/trackers/data/unit3d.go
new file mode 100644
index 00000000..225fd0c8
--- /dev/null
+++ b/internal/trackers/data/unit3d.go
@@ -0,0 +1,952 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package data
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"image"
+	_ "image/gif"  // register GIF decoder for tracker images
+	_ "image/jpeg" // register JPEG decoder for tracker images
+	_ "image/png"  // register PNG decoder for tracker images
+	"io"
+	"net"
+	"net/http"
+	"net/netip"
+	"net/url"
+	"path" //nolint:depguard // Builds Unit3D API URL paths, not local filesystem paths.
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	"github.com/autobrr/upbrr/internal/config"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	imageTimeout     = 15 * time.Second
+	maxImageBytes    = 20 * 1024 * 1024
+	imageConcurrency = 5
+)
+
+var unit3DImageBlockedIPRanges = []netip.Prefix{
+	netip.MustParsePrefix("0.0.0.0/8"),
+	netip.MustParsePrefix("100.64.0.0/10"),
+	netip.MustParsePrefix("192.0.0.0/24"),
+	netip.MustParsePrefix("192.0.2.0/24"),
+	netip.MustParsePrefix("198.18.0.0/15"),
+	netip.MustParsePrefix("198.51.100.0/24"),
+	netip.MustParsePrefix("203.0.113.0/24"),
+	netip.MustParsePrefix("240.0.0.0/4"),
+	netip.MustParsePrefix("2001:db8::/32"),
+	netip.MustParsePrefix("fc00::/7"),
+	netip.MustParsePrefix("fe80::/10"),
+}
+
+var unit3DCategoryNamesByID = map[string][]string{
+	"1": {"MOVIE"},
+	"2": {"TV"},
+}
+
+var unit3DTypeNamesByID = map[string][]string{
+	"1": {"DISC"},
+	"2": {"REMUX"},
+	"3": {"ENCODE", "DVDRIP"},
+	"4": {"WEBDL"},
+	"5": {"WEBRIP"},
+	"6": {"HDTV"},
+}
+
+var unit3DResolutionNamesByID = map[string][]string{
+	"10": {"8640P"},
+	"1":  {"4320P"},
+	"2":  {"2160P"},
+	"3":  {"1080P", "1440P"},
+	"4":  {"1080I"},
+	"5":  {"720P"},
+	"6":  {"576P"},
+	"7":  {"576I"},
+	"8":  {"480P"},
+	"9":  {"480I"},
+}
+
+// CategoryID returns the Unit3D category ID for a canonical category name.
+func CategoryID(category string) string {
+	return reverseLookupCanonicalID(CanonicalUnit3DCategory(category), unit3DCategoryNamesByID)
+}
+
+// TypeID returns the Unit3D type ID for a canonical type name.
+func TypeID(typeValue string) string {
+	return reverseLookupCanonicalID(CanonicalUnit3DType(typeValue), unit3DTypeNamesByID)
+}
+
+// ResolutionID returns the Unit3D resolution ID for a canonical resolution name.
+func ResolutionID(value string) string {
+	return reverseLookupCanonicalID(CanonicalUnit3DResolution(value), unit3DResolutionNamesByID)
+}
+
+// CategoryName returns the preferred category name for a Unit3D ID.
+func CategoryName(id string) string {
+	return firstCanonicalValue(CategoryNames(id))
+}
+
+// CategoryNames returns all known category names for a Unit3D ID.
+func CategoryNames(id string) []string {
+	return copyCanonicalValues(unit3DCategoryNamesByID[strings.TrimSpace(id)])
+}
+
+// TypeName returns the preferred type name for a Unit3D ID.
+func TypeName(id string) string {
+	return firstCanonicalValue(TypeNames(id))
+}
+
+// TypeNames returns all known type names for a Unit3D ID.
+func TypeNames(id string) []string {
+	return copyCanonicalValues(unit3DTypeNamesByID[strings.TrimSpace(id)])
+}
+
+// ResolutionName returns the preferred resolution name for a Unit3D ID.
+func ResolutionName(id string) string {
+	return firstCanonicalValue(ResolutionNames(id))
+}
+
+// ResolutionNames returns all known resolution names for a Unit3D ID.
+func ResolutionNames(id string) []string {
+	return copyCanonicalValues(unit3DResolutionNamesByID[strings.TrimSpace(id)])
+}
+
+// CanonicalUnit3DCategory normalizes a Unit3D category name or ID.
+func CanonicalUnit3DCategory(value string) string {
+	switch normalizeUnit3DLookupKey(value) {
+	case "MOVIE", "FILM":
+		return "MOVIE"
+	case "TV", "TELEVISION", "SHOW", "SERIES", "TVSHOW", "EPISODE":
+		return "TV"
+	default:
+		return ""
+	}
+}
+
+// CanonicalUnit3DType normalizes a Unit3D type name or ID.
+func CanonicalUnit3DType(value string) string {
+	switch normalizeUnit3DLookupKey(value) {
+	case "DISC":
+		return "DISC"
+	case "REMUX":
+		return "REMUX"
+	case "ENCODE":
+		return "ENCODE"
+	case "DVDRIP":
+		return "DVDRIP"
+	case "WEBDL":
+		return "WEBDL"
+	case "WEBRIP":
+		return "WEBRIP"
+	case "HDTV", "UHDTV":
+		return "HDTV"
+	default:
+		return ""
+	}
+}
+
+// CanonicalUnit3DResolution normalizes a Unit3D resolution name or ID.
+func CanonicalUnit3DResolution(value string) string {
+	switch normalizeUnit3DLookupKey(value) {
+	case "8640P":
+		return "8640P"
+	case "4320P":
+		return "4320P"
+	case "2160P":
+		return "2160P"
+	case "1440P":
+		return "1440P"
+	case "1080P":
+		return "1080P"
+	case "1080I":
+		return "1080I"
+	case "720P":
+		return "720P"
+	case "576P":
+		return "576P"
+	case "576I":
+		return "576I"
+	case "480P":
+		return "480P"
+	case "480I":
+		return "480I"
+	default:
+		return ""
+	}
+}
+
+func normalizeUnit3DLookupKey(value string) string {
+	return strings.NewReplacer("-", "", "_", "", " ", "").Replace(strings.ToUpper(strings.TrimSpace(value)))
+}
+
+func reverseLookupCanonicalID(canonical string, namesByID map[string][]string) string {
+	if canonical == "" {
+		return ""
+	}
+	for id, names := range namesByID {
+		if slices.Contains(names, canonical) {
+			return id
+		}
+	}
+	return ""
+}
+
+func firstCanonicalValue(values []string) string {
+	if len(values) == 0 {
+		return ""
+	}
+	return values[0]
+}
+
+func copyCanonicalValues(values []string) []string {
+	if len(values) == 0 {
+		return nil
+	}
+	return append([]string{}, values...)
+}
+
+// TrackerAPIKey returns the configured API key for a Unit3D tracker.
+func TrackerAPIKey(cfg config.Config, tracker string) string {
+	key := strings.ToUpper(strings.TrimSpace(tracker))
+	if key == "" {
+		return ""
+	}
+	if entry, ok := cfg.Trackers.Trackers[key]; ok {
+		return strings.TrimSpace(entry.APIKey)
+	}
+	if entry, ok := cfg.Trackers.Trackers[strings.ToLower(key)]; ok {
+		return strings.TrimSpace(entry.APIKey)
+	}
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(name, key) {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
+
+// TorrentInfo fetches by tracker ID or, when absent, filename. Non-success and
+// no-match responses return an empty result without error. onlyID skips cleaned
+// description text; keepImages enables bounded public-image validation.
+func (c *Client) TorrentInfo(ctx context.Context, tracker string, id string, fileName string, onlyID bool, keepImages bool) (Result, error) {
+	return c.lookupUnit3D(ctx, tracker, id, fileName, onlyID, keepImages)
+}
+
+func (c *Client) lookupUnit3D(ctx context.Context, tracker string, id string, fileName string, onlyID bool, keepImages bool) (Result, error) {
+	baseURL, ok := baseURLForTrackerWithConfig(c.cfg, c.registry, tracker)
+	if !ok {
+		return Result{}, fmt.Errorf("unit3d: unknown tracker %q", tracker)
+	}
+
+	apiKey := strings.TrimSpace(TrackerAPIKey(c.cfg, tracker))
+	params := url.Values{}
+	if apiKey == "" {
+		c.logger.Debugf("unit3d: %s missing API key; request will be unauthenticated", tracker)
+	}
+
+	var endpoint string
+	switch {
+	case strings.TrimSpace(id) != "":
+		endpoint = baseURL + "/api/torrents/" + strings.TrimSpace(id)
+	case strings.TrimSpace(fileName) != "":
+		endpoint = baseURL + "/api/torrents/filter"
+		params.Set("file_name", fileName)
+	default:
+		return Result{}, nil
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return Result{}, fmt.Errorf("unit3d: request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	SetUnit3DAPIHeaders(req, apiKey)
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return Result{}, fmt.Errorf("unit3d: request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		c.logger.Debugf("unit3d: %s request failed (status=%d id=%q file=%q)", tracker, resp.StatusCode, strings.TrimSpace(id), strings.TrimSpace(fileName))
+		return Result{}, nil
+	}
+
+	var payload unit3dResponse
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return Result{}, fmt.Errorf("unit3d: decode: %w", err)
+	}
+	attrs := payload.extractAttributes(strings.TrimSpace(id) != "")
+	if attrs == nil {
+		c.logger.Debugf("unit3d: %s response contained no attributes (id=%q file=%q)", tracker, strings.TrimSpace(id), strings.TrimSpace(fileName))
+		return Result{}, nil
+	}
+
+	result := Result{
+		TrackerID: strings.TrimSpace(id),
+		TMDBID:    attrs.tmdbID,
+		IMDBID:    attrs.imdbID,
+		TVDBID:    attrs.tvdbID,
+		MALID:     attrs.malID,
+		Category:  strings.TrimSpace(attrs.category),
+		InfoHash:  strings.TrimSpace(attrs.infoHash),
+		FileName:  attrs.fileName,
+	}
+
+	description := strings.TrimSpace(attrs.description)
+	if description == "" {
+		return result, nil
+	}
+	reports := make([]descriptionunit3d.Report, 0, 2)
+	cleaned := ""
+	if !onlyID {
+		report := descriptionunit3d.CleanDescriptionBody(description, baseURL)
+		reports = append(reports, report)
+		cleaned = report.Description
+	}
+	images := []bbcode.Image(nil)
+	if keepImages {
+		report := descriptionunit3d.CleanDescriptionImages(description, baseURL)
+		reports = append(reports, report)
+		images = convertCleanedUnit3DImages(report.Images)
+	}
+	cleanedLen := len(cleaned)
+	imageCount := len(images)
+	validated := []bbcode.Image(nil)
+	if keepImages {
+		validated = validateImages(ctx, c.http, images)
+		images = validated
+	} else {
+		images = nil
+	}
+	result.Description = cleaned
+	result.Images = images
+	result.Validated = validated
+	c.logger.Debugf(
+		"unit3d: %s description raw=%d cleaned=%d images=%d validated=%d onlyID=%t keepImages=%t",
+		tracker,
+		len(description),
+		cleanedLen,
+		imageCount,
+		len(validated),
+		onlyID,
+		keepImages,
+	)
+	for _, report := range reports {
+		for _, note := range report.Notes {
+			c.logger.Debugf("unit3d: %s description note kind=%s msg=%s", tracker, note.Kind, note.Message)
+		}
+	}
+
+	return result, nil
+}
+
+func convertCleanedUnit3DImages(images []descriptionunit3d.Image) []bbcode.Image {
+	if len(images) == 0 {
+		return nil
+	}
+	converted := make([]bbcode.Image, 0, len(images))
+	for _, image := range images {
+		converted = append(converted, bbcode.Image{
+			ImgURL: image.ImgURL,
+			RawURL: image.RawURL,
+			WebURL: image.WebURL,
+			Host:   image.Host,
+		})
+	}
+	return converted
+}
+
+// SearchTorrents returns normalized duplicate candidates in provider order.
+// Non-success responses become a caller-visible warning rather than an error;
+// CBR also appends matching pending uploads.
+func (c *Client) SearchTorrents(ctx context.Context, tracker string, params url.Values, isDisc bool) ([]api.DupeEntry, string, error) {
+	baseURL, ok := baseURLForTrackerWithConfig(c.cfg, c.registry, tracker)
+	if !ok {
+		return nil, "", fmt.Errorf("unit3d: unknown tracker %q", tracker)
+	}
+
+	apiKey := strings.TrimSpace(TrackerAPIKey(c.cfg, tracker))
+	if apiKey == "" && c.logger != nil {
+		c.logger.Debugf("unit3d: %s missing API key; request will be unauthenticated", tracker)
+	}
+
+	endpoints := []unit3dSearchEndpoint{{
+		url: strings.TrimRight(baseURL, "/") + path.Join("/", "api", "torrents", "filter"),
+	}}
+	if usesUnit3DPendingSearch(tracker) {
+		tmdbID, _ := strconv.Atoi(strings.TrimSpace(params.Get("tmdbId")))
+		endpoints = append(endpoints, unit3dSearchEndpoint{
+			url:           strings.TrimRight(baseURL, "/") + path.Join("/", "api", "torrents", "pending"),
+			pending:       true,
+			filterTMDBID:  tmdbID,
+			pendingWebURL: strings.TrimRight(baseURL, "/") + "/torrents/pending",
+		})
+	}
+
+	var entries []api.DupeEntry
+	for _, endpoint := range endpoints {
+		endpointEntries, warning, err := c.searchUnit3DEndpoint(ctx, tracker, endpoint, params, apiKey, isDisc)
+		if err != nil {
+			return nil, "", err
+		}
+		if warning != "" {
+			return entries, warning, nil
+		}
+		entries = append(entries, endpointEntries...)
+	}
+
+	return entries, "", nil
+}
+
+func (c *Client) searchUnit3DEndpoint(
+	ctx context.Context,
+	tracker string,
+	endpoint unit3dSearchEndpoint,
+	params url.Values,
+	apiKey string,
+	isDisc bool,
+) ([]api.DupeEntry, string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint.url, nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("unit3d: request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	SetUnit3DAPIHeaders(req, apiKey)
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("unit3d: request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		if c.logger != nil {
+			c.logger.Warnf("unit3d: %s search failed (status=%d)", tracker, resp.StatusCode)
+		}
+		return nil, fmt.Sprintf("%s search failed (status=%d)", strings.ToUpper(strings.TrimSpace(tracker)), resp.StatusCode), nil
+	}
+
+	if endpoint.pending {
+		var payload unit3dPendingSearchResponse
+		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+			return nil, "", fmt.Errorf("unit3d: decode: %w", err)
+		}
+		return buildUnit3DPendingEntries(payload.Data, endpoint, isDisc), "", nil
+	}
+
+	var payload unit3dSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return nil, "", fmt.Errorf("unit3d: decode: %w", err)
+	}
+	return buildUnit3DSearchEntries(payload.Data, isDisc), "", nil
+}
+
+// SetUnit3DAPIHeaders applies the authentication and response format expected
+// by every Unit3D API request.
+func SetUnit3DAPIHeaders(req *http.Request, apiKey string) {
+	if req == nil {
+		return
+	}
+	req.Header.Set("Accept", "application/json")
+	if apiKey = strings.TrimSpace(apiKey); apiKey != "" {
+		req.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+}
+
+func buildUnit3DSearchEntries(items []unit3dSearchItem, isDisc bool) []api.DupeEntry {
+	entries := make([]api.DupeEntry, 0, len(items))
+	for _, item := range items {
+		entry := api.DupeEntry{
+			Name:        strings.TrimSpace(item.Attributes.Name),
+			Trumpable:   item.Attributes.Trumpable,
+			Link:        strings.TrimSpace(item.Attributes.DetailsLink),
+			Download:    strings.TrimSpace(item.Attributes.DownloadLink),
+			ID:          strings.TrimSpace(item.ID.String()),
+			Type:        strings.TrimSpace(item.Attributes.Type),
+			Res:         strings.TrimSpace(item.Attributes.Resolution),
+			Internal:    item.Attributes.Internal,
+			BDInfo:      strings.TrimSpace(item.Attributes.BDInfo),
+			Description: strings.TrimSpace(item.Attributes.Description),
+			Flags:       append([]string{}, item.Attributes.Flags...),
+		}
+
+		if sizeValue, err := parseNumberToInt64(item.Attributes.Size); err == nil {
+			entry.SizeBytes = sizeValue
+			entry.SizeKnown = sizeValue > 0
+		} else if raw := strings.TrimSpace(item.Attributes.Size.String()); raw != "" {
+			entry.SizeText = raw
+		}
+
+		if len(item.Attributes.Files) > 0 {
+			entry.FileCount = len(item.Attributes.Files)
+			if !isDisc {
+				entry.Files = make([]string, 0, len(item.Attributes.Files))
+				for _, file := range item.Attributes.Files {
+					trimmed := strings.TrimSpace(file.Name)
+					if trimmed != "" {
+						entry.Files = append(entry.Files, trimmed)
+					}
+				}
+			}
+		}
+
+		entries = append(entries, entry)
+	}
+
+	return entries
+}
+
+func buildUnit3DPendingEntries(items []unit3dPendingSearchItem, endpoint unit3dSearchEndpoint, isDisc bool) []api.DupeEntry {
+	entries := make([]api.DupeEntry, 0, len(items))
+	for _, item := range items {
+		if endpoint.filterTMDBID > 0 && item.TMDBID != endpoint.filterTMDBID {
+			continue
+		}
+
+		entry := api.DupeEntry{
+			Name:        strings.TrimSpace(item.Name),
+			Trumpable:   item.Trumpable,
+			Link:        endpoint.pendingWebURL,
+			Download:    strings.TrimSpace(item.DownloadLink),
+			ID:          strings.TrimSpace(item.ID.String()),
+			Type:        strings.TrimSpace(item.Type),
+			Res:         strings.TrimSpace(item.Resolution),
+			Internal:    item.Internal,
+			BDInfo:      strings.TrimSpace(item.BDInfo),
+			Description: strings.TrimSpace(item.Description),
+			Flags:       append([]string{}, item.Flags...),
+		}
+
+		if sizeValue, err := parseNumberToInt64(item.Size); err == nil {
+			entry.SizeBytes = sizeValue
+			entry.SizeKnown = sizeValue > 0
+		} else if raw := strings.TrimSpace(item.Size.String()); raw != "" {
+			entry.SizeText = raw
+		}
+
+		if len(item.Files) > 0 {
+			entry.FileCount = len(item.Files)
+			if !isDisc {
+				entry.Files = make([]string, 0, len(item.Files))
+				for _, file := range item.Files {
+					trimmed := strings.TrimSpace(file.Name)
+					if trimmed != "" {
+						entry.Files = append(entry.Files, trimmed)
+					}
+				}
+			}
+		}
+
+		entries = append(entries, entry)
+	}
+
+	return entries
+}
+
+func usesUnit3DPendingSearch(tracker string) bool {
+	return strings.EqualFold(tracker, "CBR")
+}
+
+func validateImages(ctx context.Context, client *http.Client, images []bbcode.Image) []bbcode.Image {
+	if len(images) == 0 {
+		return nil
+	}
+	client = Unit3DImageHTTPClient(client)
+
+	results := make([]bbcode.Image, len(images))
+	valid := make([]bool, len(images))
+	sem := make(chan struct{}, imageConcurrency)
+	var wg sync.WaitGroup
+
+	for idx, img := range images {
+		wg.Go(func() {
+			sem <- struct{}{}
+			defer func() { <-sem }()
+			if checkImage(ctx, client, img.RawURL) {
+				results[idx] = img
+				valid[idx] = true
+			}
+		})
+	}
+	wg.Wait()
+
+	filtered := make([]bbcode.Image, 0, len(images))
+	for idx, ok := range valid {
+		if ok {
+			filtered = append(filtered, results[idx])
+		}
+	}
+	return filtered
+}
+
+func checkImage(ctx context.Context, client *http.Client, rawURL string) bool {
+	trimmed := strings.TrimSpace(rawURL)
+	if trimmed == "" {
+		return false
+	}
+	if err := ValidateUnit3DImageURL(ctx, trimmed); err != nil {
+		return false
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, trimmed, nil)
+	if err != nil {
+		return false
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return false
+	}
+	if resp.ContentLength > 0 && resp.ContentLength > maxImageBytes {
+		return false
+	}
+	contentType := strings.ToLower(resp.Header.Get("Content-Type"))
+	if contentType != "" && !strings.Contains(contentType, "image") {
+		return false
+	}
+	limited := io.LimitReader(resp.Body, maxImageBytes)
+	if _, _, err := image.DecodeConfig(limited); err != nil {
+		return false
+	}
+	return true
+}
+
+// Unit3DImageHTTPClient returns a clone that rejects non-public image redirects and,
+// for standard transports, dials only public target IPs.
+func Unit3DImageHTTPClient(client *http.Client) *http.Client {
+	if client == nil {
+		client = &http.Client{Timeout: imageTimeout}
+	}
+	cloned := *client
+	if cloned.Timeout == 0 {
+		cloned.Timeout = imageTimeout
+	}
+	if transport, ok := unit3DImagePublicTransport(cloned.Transport); ok {
+		cloned.Transport = transport
+	}
+	checkRedirect := cloned.CheckRedirect
+	cloned.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		if err := ValidateUnit3DImageURL(req.Context(), req.URL.String()); err != nil {
+			return err
+		}
+		if checkRedirect != nil {
+			return checkRedirect(req, via)
+		}
+		if len(via) >= 10 {
+			return errors.New("stopped after 10 redirects")
+		}
+		return nil
+	}
+	return &cloned
+}
+
+func unit3DImagePublicTransport(rt http.RoundTripper) (http.RoundTripper, bool) {
+	var transport *http.Transport
+	switch typed := rt.(type) {
+	case nil:
+		defaultTransport, ok := http.DefaultTransport.(*http.Transport)
+		if !ok {
+			return rt, false
+		}
+		transport = defaultTransport.Clone()
+	case *http.Transport:
+		transport = typed.Clone()
+	default:
+		return rt, false
+	}
+
+	originalDial := transport.DialContext
+	dialer := &net.Dialer{Timeout: imageTimeout}
+	transport.DialContext = func(ctx context.Context, network string, address string) (net.Conn, error) {
+		host, port, err := net.SplitHostPort(address)
+		if err != nil {
+			return nil, fmt.Errorf("parse address: %w", err)
+		}
+		addrs, err := resolveUnit3DImagePublicAddrs(ctx, host)
+		if err != nil {
+			return nil, err
+		}
+		var lastErr error
+		for _, addr := range addrs {
+			target := net.JoinHostPort(addr.String(), port)
+			var conn net.Conn
+			if originalDial != nil {
+				conn, err = originalDial(ctx, network, target)
+			} else {
+				conn, err = dialer.DialContext(ctx, network, target)
+			}
+			if err == nil {
+				return conn, nil
+			}
+			lastErr = err
+		}
+		return nil, lastErr
+	}
+	return transport, true
+}
+
+// ValidateUnit3DImageURL rejects non-HTTP(S) or non-public Unit3D image targets.
+func ValidateUnit3DImageURL(ctx context.Context, rawURL string) error {
+	parsed, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil {
+		return fmt.Errorf("parse url: %w", err)
+	}
+	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
+	if scheme != "http" && scheme != "https" {
+		return fmt.Errorf("unsupported scheme %q", parsed.Scheme)
+	}
+	host := strings.TrimSpace(parsed.Hostname())
+	if host == "" {
+		return errors.New("missing host")
+	}
+	_, err = resolveUnit3DImagePublicAddrs(ctx, host)
+	return err
+}
+
+func resolveUnit3DImagePublicAddrs(ctx context.Context, host string) ([]netip.Addr, error) {
+	host = strings.Trim(strings.TrimSpace(host), "[]")
+	if host == "" {
+		return nil, errors.New("missing host")
+	}
+	lowerHost := strings.ToLower(host)
+	if lowerHost == "localhost" || strings.HasSuffix(lowerHost, ".localhost") || strings.Contains(lowerHost, "%") {
+		return nil, fmt.Errorf("blocked private image host %q", host)
+	}
+	if addr, err := netip.ParseAddr(host); err == nil {
+		addr = addr.Unmap()
+		if !isUnit3DImagePublicIP(addr) {
+			return nil, fmt.Errorf("blocked private image address %q", addr)
+		}
+		return []netip.Addr{addr}, nil
+	}
+
+	resolved, err := net.DefaultResolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return nil, fmt.Errorf("resolve host %q: %w", host, err)
+	}
+	addrs := make([]netip.Addr, 0, len(resolved))
+	for _, item := range resolved {
+		addr, ok := netip.AddrFromSlice(item.IP)
+		if !ok {
+			continue
+		}
+		addr = addr.Unmap()
+		if !isUnit3DImagePublicIP(addr) {
+			return nil, fmt.Errorf("blocked private image address %q", addr)
+		}
+		addrs = append(addrs, addr)
+	}
+	if len(addrs) == 0 {
+		return nil, fmt.Errorf("host %q resolved no public addresses", host)
+	}
+	return addrs, nil
+}
+
+func isUnit3DImagePublicIP(addr netip.Addr) bool {
+	addr = addr.Unmap()
+	if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() ||
+		addr.IsUnspecified() {
+		return false
+	}
+	for _, blocked := range unit3DImageBlockedIPRanges {
+		if blocked.Contains(addr) {
+			return false
+		}
+	}
+	return true
+}
+
+// baseURLForTrackerWithConfig returns the profile-owned endpoint.
+func baseURLForTrackerWithConfig(_ config.Config, registry *trackers.Registry, tracker string) (string, bool) {
+	return registry.LookupBaseURL(tracker)
+}
+
+func parseNumberToInt64(value json.Number) (int64, error) {
+	text := strings.TrimSpace(value.String())
+	if text == "" {
+		return 0, errors.New("empty number")
+	}
+	if parsed, err := strconv.ParseInt(text, 10, 64); err == nil {
+		return parsed, nil
+	}
+	parsed, err := strconv.ParseFloat(text, 64)
+	if err != nil {
+		return 0, fmt.Errorf("parse numeric JSON value %q: %w", text, err)
+	}
+	return int64(parsed), nil
+}
+
+type unit3dResponse struct {
+	Data       json.RawMessage `json:"data"`
+	Attributes json.RawMessage `json:"attributes"`
+}
+
+type unit3dDataItem struct {
+	Attributes unit3dAttributes `json:"attributes"`
+}
+
+type unit3dAttributes struct {
+	Category      string         `json:"category"`
+	Description   string         `json:"description"`
+	TMDBID        int            `json:"tmdb_id"`
+	IMDBID        int            `json:"imdb_id"`
+	TVDBID        int            `json:"tvdb_id"`
+	MALID         int            `json:"mal_id"`
+	InfoHash      string         `json:"info_hash"`
+	Files         []unit3dFile   `json:"files"`
+	RegionID      int            `json:"region_id"`
+	DistributorID int            `json:"distributor_id"`
+	RawFileName   string         `json:"file_name"`
+	ExtraFiles    []unit3dFile   `json:"file"`
+	Other         map[string]any `json:"-"`
+}
+
+type unit3dFile struct {
+	Name string `json:"name"`
+}
+
+type parsedAttributes struct {
+	category    string
+	description string
+	tmdbID      int
+	imdbID      int
+	tvdbID      int
+	malID       int
+	infoHash    string
+	fileName    string
+}
+
+func (r unit3dResponse) extractAttributes(preferTopLevel bool) *parsedAttributes {
+	if len(r.Data) > 0 {
+		var dataString string
+		if err := json.Unmarshal(r.Data, &dataString); err == nil {
+			if strings.TrimSpace(dataString) == "404" {
+				return nil
+			}
+		}
+		var dataItems []unit3dDataItem
+		if err := json.Unmarshal(r.Data, &dataItems); err == nil {
+			if len(dataItems) > 0 {
+				return parseAttributes(dataItems[0].Attributes)
+			}
+		}
+	}
+
+	if !preferTopLevel || len(r.Attributes) == 0 {
+		return nil
+	}
+	var attrs unit3dAttributes
+	if err := json.Unmarshal(r.Attributes, &attrs); err != nil {
+		return nil
+	}
+	return parseAttributes(attrs)
+}
+
+func parseAttributes(attrs unit3dAttributes) *parsedAttributes {
+	info := &parsedAttributes{
+		category:    attrs.Category,
+		description: attrs.Description,
+		infoHash:    attrs.InfoHash,
+	}
+	info.tmdbID = normalizeID(attrs.TMDBID)
+	info.imdbID = normalizeID(attrs.IMDBID)
+	info.tvdbID = normalizeID(attrs.TVDBID)
+	info.malID = normalizeID(attrs.MALID)
+
+	fileNames := make([]string, 0, len(attrs.Files))
+	for _, file := range attrs.Files {
+		trimmed := strings.TrimSpace(file.Name)
+		if trimmed == "" {
+			continue
+		}
+		fileNames = append(fileNames, trimmed)
+		if len(fileNames) >= 5 {
+			break
+		}
+	}
+	if len(fileNames) == 1 {
+		info.fileName = fileNames[0]
+	} else if len(fileNames) > 1 {
+		info.fileName = strings.Join(fileNames, ", ")
+	}
+	if info.fileName == "" {
+		info.fileName = strings.TrimSpace(attrs.RawFileName)
+	}
+	return info
+}
+
+func normalizeID(value int) int {
+	if value <= 0 {
+		return 0
+	}
+	return value
+}
+
+type unit3dSearchResponse struct {
+	Data []unit3dSearchItem `json:"data"`
+}
+
+type unit3dSearchEndpoint struct {
+	url           string
+	pending       bool
+	filterTMDBID  int
+	pendingWebURL string
+}
+
+type unit3dSearchItem struct {
+	ID         json.Number       `json:"id"`
+	Attributes unit3dSearchAttrs `json:"attributes"`
+}
+
+type unit3dSearchAttrs struct {
+	Name         string       `json:"name"`
+	Size         json.Number  `json:"size"`
+	Files        []unit3dFile `json:"files"`
+	Trumpable    bool         `json:"trumpable"`
+	DetailsLink  string       `json:"details_link"`
+	DownloadLink string       `json:"download_link"`
+	Type         string       `json:"type"`
+	Resolution   string       `json:"resolution"`
+	Internal     bool         `json:"internal"`
+	BDInfo       string       `json:"bd_info"`
+	Description  string       `json:"description"`
+	Flags        []string     `json:"flags"`
+}
+
+type unit3dPendingSearchResponse struct {
+	Data []unit3dPendingSearchItem `json:"data"`
+}
+
+type unit3dPendingSearchItem struct {
+	ID           json.Number  `json:"id"`
+	TMDBID       int          `json:"tmdb_id"`
+	Name         string       `json:"name"`
+	Size         json.Number  `json:"size"`
+	Files        []unit3dFile `json:"files"`
+	Trumpable    bool         `json:"trumpable"`
+	DownloadLink string       `json:"download_link"`
+	Type         string       `json:"type"`
+	Resolution   string       `json:"resolution"`
+	Internal     bool         `json:"internal"`
+	BDInfo       string       `json:"bd_info"`
+	Description  string       `json:"description"`
+	Flags        []string     `json:"flags"`
+}
diff --git a/internal/trackerdata/unit3d_test.go b/internal/trackers/data/unit3d_test.go
similarity index 78%
rename from internal/trackerdata/unit3d_test.go
rename to internal/trackers/data/unit3d_test.go
index 80e7dca3..28187373 100644
--- a/internal/trackerdata/unit3d_test.go
+++ b/internal/trackers/data/unit3d_test.go
@@ -1,32 +1,63 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackerdata
+package data
 
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"testing"
 
 	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func TestIsUnit3DTracker(t *testing.T) {
-	t.Parallel()
+type rewriteHostTransport struct {
+	base *url.URL
+	rt   http.RoundTripper
+}
 
-	if !IsUnit3DTracker("BLU") {
-		t.Fatalf("expected BLU to be a Unit3D tracker")
-	}
-	if !IsUnit3DTracker("ACM") {
-		t.Fatalf("expected ACM to be a Unit3D tracker")
-	}
-	if IsUnit3DTracker("PTP") {
-		t.Fatalf("did not expect PTP to be a Unit3D tracker")
+func (t rewriteHostTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	clone := req.Clone(req.Context())
+	clone.URL.Scheme = t.base.Scheme
+	clone.URL.Host = t.base.Host
+	clone.Host = t.base.Host
+	resp, err := t.rt.RoundTrip(clone)
+	if err != nil {
+		return resp, fmt.Errorf("rewrite host round trip: %w", err)
 	}
+	return resp, nil
+}
+
+type testDefinition struct{ name string }
+
+func (d testDefinition) Name() string { return d.name }
+
+func (testDefinition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+
+func (testDefinition) Prepare(context.Context, trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.TrackerPlan{}, nil
+}
+
+func testUnit3DRegistry(t *testing.T, name string, baseURL string) *trackers.Registry {
+	t.Helper()
+	registry := trackers.NewRegistry()
+	if err := registry.RegisterDescriptor(trackers.Descriptor{
+		Name:       name,
+		Family:     trackers.FamilyUnit3D,
+		BaseURL:    baseURL,
+		Definition: testDefinition{name: name},
+	}); err != nil {
+		t.Fatalf("register test tracker: %v", err)
+	}
+	return registry
 }
 
 func TestSetUnit3DAPIHeadersUsesBearerAuthorization(t *testing.T) {
@@ -175,16 +206,20 @@ func TestSearchTorrentsCBRIncludesPendingAndFiltersTMDB(t *testing.T) {
 	}))
 	defer server.Close()
 
-	client := NewClient(config.Config{
+	baseURL := "https://cbr.example"
+	base, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse test server URL: %v", err)
+	}
+	client := NewClientWithRegistry(config.Config{
 		Trackers: config.TrackersConfig{
 			Trackers: map[string]config.TrackerConfig{
 				"CBR": {
-					APIKey:      "secret",
-					AnnounceURL: server.URL + "/announce",
+					APIKey: "secret",
 				},
 			},
 		},
-	}, api.NopLogger{}, server.Client())
+	}, api.NopLogger{}, &http.Client{Transport: rewriteHostTransport{base: base, rt: server.Client().Transport}}, testUnit3DRegistry(t, "CBR", baseURL))
 
 	params := url.Values{}
 	params.Set("tmdbId", "42")
@@ -207,7 +242,7 @@ func TestSearchTorrentsCBRIncludesPendingAndFiltersTMDB(t *testing.T) {
 	if entries[0].Name != "Existing.Release" || entries[0].Link != "https://example.test/torrents/101" {
 		t.Fatalf("unexpected filter entry: %#v", entries[0])
 	}
-	if entries[1].Name != "Pending.Release" || entries[1].Link != server.URL+"/torrents/pending" {
+	if entries[1].Name != "Pending.Release" || entries[1].Link != baseURL+"/torrents/pending" {
 		t.Fatalf("unexpected pending entry: %#v", entries[1])
 	}
 	if entries[1].ID != "202" || entries[1].SizeBytes != 456 || entries[1].Files[0] != "pending.mkv" {
@@ -236,11 +271,11 @@ func TestTorrentInfoUsesBearerAuthorization(t *testing.T) {
 	if err != nil {
 		t.Fatal("parse test server URL")
 	}
-	client := NewClient(config.Config{
+	client := NewClientWithRegistry(config.Config{
 		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"AITHER": {APIKey: "secret"},
+			"AITHER": {APIKey: "secret", AnnounceURL: "https://aither.cc/announce"},
 		}},
-	}, api.NopLogger{}, &http.Client{Transport: rewriteHostTransport{base: base, rt: server.Client().Transport}})
+	}, api.NopLogger{}, &http.Client{Transport: rewriteHostTransport{base: base, rt: server.Client().Transport}}, testUnit3DRegistry(t, "AITHER", "https://aither.cc"))
 
 	result, err := client.TorrentInfo(context.Background(), "AITHER", "123", "", true, false)
 	if err != nil {
@@ -250,29 +285,3 @@ func TestTorrentInfoUsesBearerAuthorization(t *testing.T) {
 		t.Fatalf("unexpected Unit3D lookup result: %#v", result)
 	}
 }
-
-func TestIsUnit3DTrackerWithConfig(t *testing.T) {
-	t.Parallel()
-
-	cfg := config.Config{
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{
-				"CUSTOM": {
-					APIKey:      "token",
-					AnnounceURL: "https://custom.unit3d.example/announce",
-				},
-				"BHD": {
-					APIKey:      "token",
-					AnnounceURL: "https://beyond-hd.me/announce",
-				},
-			},
-		},
-	}
-
-	if !IsUnit3DTrackerWithConfig(cfg, "CUSTOM") {
-		t.Fatalf("expected CUSTOM to be detected as Unit3D by config")
-	}
-	if IsUnit3DTrackerWithConfig(cfg, "BHD") {
-		t.Fatalf("did not expect BHD to be detected as Unit3D")
-	}
-}
diff --git a/internal/trackers/data_contract.go b/internal/trackers/data_contract.go
new file mode 100644
index 00000000..568c639b
--- /dev/null
+++ b/internal/trackers/data_contract.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+// DataLookupResult contains tracker-derived metadata for one release.
+type DataLookupResult struct {
+	// TrackerID is the tracker-side torrent or release identifier.
+	TrackerID string
+	// InfoHash is the normalized BitTorrent info hash when supplied by the tracker.
+	InfoHash string
+	// TMDBID is the resolved TMDB identifier.
+	TMDBID int
+	// IMDBID is the numeric portion of the resolved IMDb identifier.
+	IMDBID int
+	// TVDBID is the resolved TVDB identifier.
+	TVDBID int
+	// MALID is the resolved MyAnimeList identifier.
+	MALID int
+	// Category is the normalized tracker category.
+	Category string
+	// Description is tracker-provided BBCode after applicable cleanup.
+	Description string
+	// Images contains images extracted from Description.
+	Images []bbcode.Image
+	// Validated contains extracted images that passed remote URL validation.
+	Validated []bbcode.Image
+	// FileName is the tracker-provided torrent or release filename.
+	FileName string
+}
+
+// HasIDs reports whether the result contains any supported external metadata ID.
+func (r DataLookupResult) HasIDs() bool {
+	return r.TMDBID != 0 || r.IMDBID != 0 || r.TVDBID != 0 || r.MALID != 0
+}
+
+// HasData reports whether the result contains any usable metadata or release identity.
+func (r DataLookupResult) HasData() bool {
+	return r.HasIDs() || strings.TrimSpace(r.Description) != "" || len(r.Images) > 0 || len(r.Validated) > 0 || strings.TrimSpace(r.InfoHash) != "" ||
+		strings.TrimSpace(r.FileName) != "" ||
+		strings.TrimSpace(r.Category) != ""
+}
diff --git a/internal/trackers/definition.go b/internal/trackers/definition.go
index 5227a4aa..7a84fb3a 100644
--- a/internal/trackers/definition.go
+++ b/internal/trackers/definition.go
@@ -5,24 +5,503 @@ package trackers
 
 import (
 	"context"
+	"errors"
+	"net/http"
+	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-type UploadRequest struct {
-	Tracker       string
-	Meta          api.PreparedMetadata
+// ErrSubmitted2FARejected marks tracker auth failure after a supplied manual 2FA code was rejected.
+var ErrSubmitted2FARejected = errors.New("trackers: submitted 2FA rejected")
+
+// AuthResolutionError reports tracker-owned remote auth classification to the generic coordinator.
+type AuthResolutionError struct {
+	// Reason is sanitized operator-facing failure detail.
+	Reason string
+	// AuthRequired reports that configured or interactive authentication is needed.
+	AuthRequired bool
+	// ConfirmedInvalid reports that existing authentication was rejected remotely.
+	ConfirmedInvalid bool
+	// Transient reports that retrying may succeed without changing credentials.
+	Transient bool
+	// Err retains the underlying diagnostic cause for errors.Is and errors.As.
+	Err error
+}
+
+// Error returns the underlying cause text when available, otherwise the public reason.
+func (e *AuthResolutionError) Error() string {
+	if e == nil {
+		return "tracker auth resolution failed"
+	}
+	if e.Err != nil {
+		return e.Err.Error()
+	}
+	return e.Reason
+}
+
+// Unwrap exposes the diagnostic cause.
+func (e *AuthResolutionError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.Err
+}
+
+// PreparationInput supplies one immutable, operation-scoped tracker preparation snapshot.
+// The tracker module resolves this input before invoking an adapter.
+type PreparationInput struct {
+	// Intent selects the maximum preparation depth for this invocation.
+	Intent PreparationIntent
+	// Tracker is the normalized tracker name receiving the upload.
+	Tracker string
+	// Meta is the prepared release snapshot used throughout this upload attempt.
+	Meta api.UploadSubject
+	// TrackerConfig is the effective configuration for Tracker.
 	TrackerConfig config.TrackerConfig
-	AppConfig     config.Config
-	Logger        api.Logger
-	Repo          db.MetadataRepository
-	Images        api.ImageHostingService
-	Assets        *DescriptionAssets
+	// Runtime contains the deliberately projected non-tracker configuration needed by adapters.
+	Runtime PreparationRuntime
+	// Logger receives tracker workflow progress and diagnostics.
+	Logger api.Logger
+	// Assets contains pre-resolved description text and selected images, when available.
+	Assets *DescriptionAssets
+	// SelectedImageHost is the module-resolved image target for adapter-specific assets.
+	SelectedImageHost string
+	// UploadImages uploads to SelectedImageHost without exposing the generic image service.
+	UploadImages func(context.Context, []api.ScreenshotImage) ([]api.UploadedImageLink, error)
+}
+
+// PreparationRuntime is a narrow immutable projection of application settings used during preparation.
+type PreparationRuntime struct {
+	// DBPath is the host filesystem database path used to resolve managed artifacts and sessions.
+	DBPath string
+	// Description contains projected description-layout settings only.
+	Description config.DescriptionSettingsConfig
+	// Internal reports whether the release group is internal for the target tracker.
+	Internal bool
+	// BTNAPIToken is the resolved BTN API credential used only by the BTN adapter.
+	BTNAPIToken string
+}
+
+// PreparationRuntimeFromConfig projects protocol-test configuration into the narrow runtime value.
+func PreparationRuntimeFromConfig(cfg config.Config) PreparationRuntime {
+	return PreparationRuntime{
+		DBPath:      cfg.MainSettings.DBPath,
+		Description: cfg.Description,
+		BTNAPIToken: config.ResolveBTNAPIToken(cfg),
+	}
+}
+
+// DescriptionConfig returns a configuration containing only projected description layout settings.
+func (r PreparationRuntime) DescriptionConfig() config.Config {
+	return config.Config{Description: r.Description}
 }
 
+// Definition is the required preparation contract for a registered tracker.
 type Definition interface {
+	// Name returns the stable normalized tracker identifier.
 	Name() string
-	Upload(ctx context.Context, req UploadRequest) (api.UploadSummary, error)
+	// Prepare creates a fresh operation-scoped plan for the requested intent.
+	Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure)
+}
+
+// FamilyProvider declares a tracker's protocol family.
+type FamilyProvider interface {
+	// TrackerFamily returns the tracker's protocol family.
+	TrackerFamily() Family
+}
+
+// BaseURLProvider declares a tracker's default endpoint.
+type BaseURLProvider interface {
+	// DefaultBaseURL returns the tracker endpoint used when configuration supplies none.
+	DefaultBaseURL() string
+}
+
+// LocalizedMetadataProvider declares a locale consumed by tracker-owned naming or description behavior.
+type LocalizedMetadataProvider interface {
+	// LocalizedMetadataLocale returns the locale used for tracker-owned metadata rendering.
+	LocalizedMetadataLocale() string
+}
+
+// DescriptionGroupProvider declares a tracker-specific description override group.
+type DescriptionGroupProvider interface {
+	// DescriptionGroup returns the tracker-specific description override group.
+	DescriptionGroup() string
+}
+
+// AuthSessionResolver validates or refreshes tracker-owned auth material.
+type AuthSessionResolver func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) error
+
+// AuthSessionProvider declares tracker-owned remote auth behavior.
+type AuthSessionProvider interface {
+	// AuthSessionResolver returns the tracker-owned session validation and refresh operation.
+	AuthSessionResolver() AuthSessionResolver
+}
+
+// AuthCapabilityProvider declares tracker-owned auth support metadata.
+type AuthCapabilityProvider interface {
+	// AuthCapability describes supported tracker authentication interactions.
+	AuthCapability() api.TrackerAuthCapability
+}
+
+// AuthCapabilityDescriptorProvider declares optional tracker auth metadata
+// without using a zero-valued capability as an absence sentinel.
+type AuthCapabilityDescriptorProvider interface {
+	// AuthCapabilityDescriptor returns nil when the tracker has no configurable auth capability.
+	AuthCapabilityDescriptor() *api.TrackerAuthCapability
+}
+
+// AuthPolicy declares coordinator behavior that cannot be inferred from the
+// user-facing auth capability alone.
+type AuthPolicy struct {
+	// ResolveAPIKey returns the effective API credential, including any legacy
+	// config source still supported by the owning tracker.
+	ResolveAPIKey func(config.Config, config.TrackerConfig) string
+	// APIKeyRequiresUploadSession keeps API-only search auth separate from
+	// cookie/login-based upload readiness.
+	APIKeyRequiresUploadSession bool
+	// CookieCompletesAPIKeyAuth promotes API-key plus stored-cookie auth to configured state.
+	CookieCompletesAPIKeyAuth bool
+	// MissingAPIKeyMessage explains a separate API prerequisite after session auth succeeds.
+	MissingAPIKeyMessage string
+	// UploadSessionMissingMessage explains why an API key alone is not upload-ready.
+	UploadSessionMissingMessage string
+	// LoginRequiresAnnounceURL requires a personal announce URL in addition to credentials.
+	LoginRequiresAnnounceURL bool
+	// PasskeyCoversAuth allows a passkey alone to satisfy auth readiness.
+	PasskeyCoversAuth bool
+	// PasskeyRequiresUsername requires username alongside the passkey.
+	PasskeyRequiresUsername bool
+	// PasskeyRequiresCookie requires a validated stored cookie alongside passkey credentials.
+	PasskeyRequiresCookie bool
+}
+
+// AuthPolicyProvider declares tracker-owned auth coordinator policy.
+type AuthPolicyProvider interface {
+	// AuthPolicy returns tracker-specific auth readiness semantics.
+	AuthPolicy() *AuthPolicy
+}
+
+// AuthStateSnapshot restores tracker-owned auth state after a later deletion step fails.
+type AuthStateSnapshot interface {
+	// Restore performs best-effort rollback independent of caller cancellation.
+	Restore(context.Context) error
+}
+
+// AuthStateManager owns tracker-specific persisted auth material outside generic cookies.
+type AuthStateManager interface {
+	// Snapshot captures state needed to roll back a multi-step delete.
+	Snapshot(context.Context, string) (AuthStateSnapshot, error)
+	// Delete removes tracker-owned persisted auth state.
+	Delete(context.Context, string) error
+}
+
+// AuthStateManagerProvider declares tracker-owned persisted auth cleanup.
+type AuthStateManagerProvider interface {
+	// AuthStateManager returns the tracker-specific auth state manager.
+	AuthStateManager() AuthStateManager
+}
+
+// RuleProvider declares tracker-owned validation rules.
+type RuleProvider interface {
+	// Rules returns tracker-owned release validation rules.
+	Rules() *RuleSet
+}
+
+// ArtifactPolicy declares tracker-owned torrent artifact constraints.
+type ArtifactPolicy struct {
+	// MaxPieceSizeMiB is the largest permitted torrent piece size; zero imposes no limit.
+	MaxPieceSizeMiB int
+	// MaxTorrentBytes is the largest permitted encoded torrent size; zero imposes no limit.
+	MaxTorrentBytes int64
+}
+
+// ArtifactPolicyProvider declares tracker-owned torrent artifact policy.
+type ArtifactPolicyProvider interface {
+	// ArtifactPolicy returns tracker-owned torrent artifact limits.
+	ArtifactPolicy() *ArtifactPolicy
+}
+
+// DataLookupRequest contains tracker metadata lookup inputs.
+type DataLookupRequest struct {
+	// TrackerID is the tracker-side torrent or release identifier when already known.
+	TrackerID string
+	// Meta is the prepared release whose tracker metadata is requested.
+	Meta api.UploadSubject
+	// SearchName overrides the release name used for tracker search when non-empty.
+	SearchName string
+	// OnlyID limits lookup work to resolving tracker identity where supported.
+	OnlyID bool
+	// KeepImages requests preservation of images found in tracker descriptions.
+	KeepImages bool
+}
+
+// DataLookup resolves tracker-owned metadata for a release.
+type DataLookup interface {
+	// Lookup resolves tracker-owned metadata for one prepared release.
+	Lookup(ctx context.Context, req DataLookupRequest) (DataLookupResult, error)
+}
+
+// DataLookupFactory constructs a tracker-owned lookup from runtime deps.
+type DataLookupFactory interface {
+	// NewDataLookup constructs a lookup bound to runtime configuration and diagnostics.
+	NewDataLookup(cfg config.Config, httpClient *http.Client, logger api.Logger) DataLookup
+}
+
+// DataLookupConfigProvider validates tracker-data lookup credentials.
+type DataLookupConfigProvider interface {
+	// DataLookupConfigured reports whether required lookup credentials are present.
+	DataLookupConfigured(cfg config.Config) bool
+}
+
+// DataLookupPolicy declares tracker-specific lookup orchestration behavior.
+type DataLookupPolicy struct {
+	// Cooldown is the minimum delay applied around tracker lookup operations.
+	Cooldown time.Duration
+	// DeferWhenCollectingImages postpones lookup while the caller is still collecting images.
+	DeferWhenCollectingImages bool
+}
+
+// DataLookupPolicyProvider declares tracker-owned lookup orchestration policy.
+type DataLookupPolicyProvider interface {
+	// DataLookupPolicy returns tracker-specific lookup orchestration settings.
+	DataLookupPolicy() *DataLookupPolicy
+}
+
+// BannedGroupsProvider declares tracker-owned static banned release groups.
+type BannedGroupsProvider interface {
+	// BannedGroups returns the tracker's static banned release-group list.
+	BannedGroups() []string
+}
+
+// BannedGroupPolicy declares a tracker-owned dynamic blacklist source.
+type BannedGroupPolicy struct {
+	// EndpointPath is appended to the configured tracker base URL.
+	EndpointPath string
+	// DefaultEndpoint is used when tracker configuration supplies no base URL.
+	DefaultEndpoint string
+	// TRaSHGuideURL supplies an optional external banned-group source.
+	TRaSHGuideURL string
+	// RequireAPIKey disables remote refresh when no API key is configured.
+	RequireAPIKey bool
+	// RawAPIKeyFallback allows the configured APIKey field when no specialized key exists.
+	RawAPIKeyFallback bool
+}
+
+// BannedGroupPolicyProvider declares dynamic banned-group retrieval behavior.
+type BannedGroupPolicyProvider interface {
+	// BannedGroupPolicy returns dynamic banned-group retrieval settings.
+	BannedGroupPolicy() *BannedGroupPolicy
+}
+
+// MetadataPolicyProvider declares tracker-owned metadata requirements.
+type MetadataPolicyProvider interface {
+	// MetadataPolicy returns tracker-owned metadata requirements.
+	MetadataPolicy() *TrackerMetadataPolicy
+}
+
+// UploadArtifactPolicy declares tracker torrent personalization fields.
+type UploadArtifactPolicy struct {
+	// Source replaces the torrent info dictionary's private-tracker source field.
+	Source string
+	// DefaultAnnounce is used when tracker configuration has no announce URL.
+	DefaultAnnounce string
+	// UseMyAnnounce selects the tracker configuration's personal announce URL.
+	UseMyAnnounce bool
+	// RequireAnnounce prevents artifact preparation without an announce URL.
+	RequireAnnounce bool
+}
+
+// UploadArtifactPolicyProvider declares tracker-owned personalization policy.
+type UploadArtifactPolicyProvider interface {
+	// UploadArtifactPolicy returns tracker torrent personalization settings.
+	UploadArtifactPolicy() *UploadArtifactPolicy
+}
+
+// DupePolicy declares tracker-specific duplicate comparison semantics.
+type DupePolicy struct {
+	// DolbyVisionImpliesHDR treats Dolby Vision candidates as HDR during matching.
+	DolbyVisionImpliesHDR bool
+	// MatchAggregateSize compares aggregate file size rather than a single-file size.
+	MatchAggregateSize bool
+	// ContainsFilenameMatch permits containment-based filename comparison.
+	ContainsFilenameMatch bool
+	// NormalizeMTVName applies MTV-specific release-name normalization.
+	NormalizeMTVName bool
+	// TrackTrumpableID preserves a matched tracker ID for trumpability checks.
+	TrackTrumpableID bool
+	// MatchDVDReleaseGroup includes DVD release-group identity in matching.
+	MatchDVDReleaseGroup bool
+	// RequireReleaseGroup rejects candidates without a comparable release group.
+	RequireReleaseGroup bool
+	// RejectEpisodeResolutionMismatch blocks episode candidates at a different resolution.
+	RejectEpisodeResolutionMismatch bool
+	// NormalizeDDPlusName normalizes Dolby Digital Plus naming variants.
+	NormalizeDDPlusName bool
+	// SDMatchesHD permits standard-definition metadata to match high-definition candidates.
+	SDMatchesHD bool
+	// CompareDVDResolution includes DVD resolution in candidate comparison.
+	CompareDVDResolution bool
+	// AllowSizeVariance1080 enables the tracker-specific 1080p size tolerance.
+	AllowSizeVariance1080 bool
+}
+
+// DupePolicyProvider declares tracker-owned duplicate comparison policy.
+type DupePolicyProvider interface {
+	// DupePolicy returns tracker-specific duplicate comparison settings.
+	DupePolicy() *DupePolicy
+}
+
+// AudioPolicy declares tracker-specific multi-language upload constraints.
+type AudioPolicy struct {
+	// AllowBloat accepts additional non-original audio languages without warning.
+	AllowBloat bool
+	// AllowedLanguages contains normalized languages accepted for foreign audio.
+	AllowedLanguages []string
+	// BlockEnglishOriginalWithForeign rejects foreign tracks when English is original audio.
+	BlockEnglishOriginalWithForeign bool
+}
+
+// AudioPolicyProvider declares tracker-owned audio constraints.
+type AudioPolicyProvider interface {
+	// AudioPolicy returns tracker-specific audio-language restrictions.
+	AudioPolicy() *AudioPolicy
+}
+
+// ImageHostPolicy declares tracker-owned accepted image hosts and activation gates.
+type ImageHostPolicy struct {
+	// AllowedHosts lists normalized image hosts accepted in descriptions.
+	AllowedHosts []string
+	// OwnedHosts lists private upload hosts scoped to this tracker.
+	OwnedHosts []string
+	// DisableWithoutRehost disables the policy unless image rehosting is enabled.
+	DisableWithoutRehost bool
+	// DisableWithoutAPI disables the policy unless tracker image API credentials exist.
+	DisableWithoutAPI bool
+	// ConditionalHost is enabled only when its associated runtime condition is met.
+	ConditionalHost string
+	// EnableWithLostimg enables ConditionalHost when LostImg is configured.
+	EnableWithLostimg bool
+	// EnableWhenConfigured enables ConditionalHost when that uploader is configured.
+	EnableWhenConfigured bool
+}
+
+// ImageHostPolicyProvider declares tracker-owned image-host restrictions.
+type ImageHostPolicyProvider interface {
+	// ImageHostPolicy returns accepted host and activation settings.
+	ImageHostPolicy() *ImageHostPolicy
+}
+
+// TorrentSearchPreference identifies tracker-owned torrent reuse selection behavior.
+type TorrentSearchPreference string
+
+const (
+	// TorrentSearchPreferenceNone applies the global torrent reuse preference.
+	TorrentSearchPreferenceNone TorrentSearchPreference = ""
+	// TorrentSearchPreferenceSmallPieces prefers the smallest reusable torrent pieces.
+	TorrentSearchPreferenceSmallPieces TorrentSearchPreference = "small_pieces"
+)
+
+// TorrentIdentityPolicy declares how torrent-client metadata identifies a tracker.
+type TorrentIdentityPolicy struct {
+	// TrackerURLPatterns match announce URLs reported by torrent clients.
+	TrackerURLPatterns []string
+	// CommentURLPatterns match tracker detail URLs in torrent comments.
+	CommentURLPatterns []string
+	// DetailIDPattern extracts a tracker torrent ID from a matching comment.
+	DetailIDPattern string
+	// WorkingTrackerID supplies a stable synthetic ID when a working announce URL is sufficient.
+	WorkingTrackerID string
+	// SearchPreference selects optional tracker-owned torrent reuse behavior.
+	SearchPreference TorrentSearchPreference
+	// InferMatchFromResolvedID treats a resolved tracker ID as provenance even
+	// when no announce URL was available in the matched torrent response.
+	InferMatchFromResolvedID bool
+}
+
+// TorrentIdentityPolicyProvider declares torrent-client identity and search behavior.
+type TorrentIdentityPolicyProvider interface {
+	// TorrentIdentityPolicy returns tracker-owned torrent identity patterns and search behavior.
+	TorrentIdentityPolicy() *TorrentIdentityPolicy
+}
+
+// ClaimChecker evaluates tracker-owned active-claim rules.
+type ClaimChecker interface {
+	// HasClaim reports whether an active tracker claim blocks this release.
+	HasClaim(ctx context.Context, meta api.UploadSubject) (bool, error)
+	// FailureReason returns sanitized operator-facing text for a positive claim.
+	FailureReason(meta api.UploadSubject) string
+}
+
+// ClaimCheckerFactory constructs a tracker-owned claim checker.
+type ClaimCheckerFactory interface {
+	// NewClaimChecker constructs a tracker-owned claim checker.
+	NewClaimChecker(cfg config.Config, logger api.Logger) ClaimChecker
+}
+
+// ClaimPolicy declares generic claim orchestration required by a tracker.
+type ClaimPolicy struct {
+	// APIBacked reports that claim evaluation requires a remote tracker lookup.
+	APIBacked bool
+}
+
+// ClaimPolicyProvider declares tracker-owned claim orchestration policy.
+type ClaimPolicyProvider interface {
+	// ClaimPolicy returns generic claim-orchestration requirements.
+	ClaimPolicy() *ClaimPolicy
+}
+
+// Descriptor binds a tracker definition to its optional capabilities.
+type Descriptor struct {
+	// Name is the stable normalized tracker identifier.
+	Name string
+	// Family identifies the tracker protocol family.
+	Family Family
+	// BaseURL is the tracker's default endpoint.
+	BaseURL string
+	// Definition is the required preparation adapter.
+	Definition Definition
+	// UploadContentMode identifies the shared content object consumed before preparation.
+	UploadContentMode UploadContentMode
+	// Rules contains optional tracker-owned validation rules.
+	Rules *RuleSet
+	// Artifact contains optional generic torrent limits.
+	Artifact *ArtifactPolicy
+	// DataFactory constructs optional tracker metadata lookup support.
+	DataFactory DataLookupFactory
+	// DataPolicy contains optional lookup orchestration settings.
+	DataPolicy *DataLookupPolicy
+	// BannedGroups is the static banned release-group list.
+	BannedGroups []string
+	// BannedPolicy contains optional dynamic banned-group retrieval settings.
+	BannedPolicy *BannedGroupPolicy
+	// Metadata contains optional metadata requirements.
+	Metadata *TrackerMetadataPolicy
+	// UploadArtifact contains optional torrent personalization settings.
+	UploadArtifact *UploadArtifactPolicy
+	// DupePolicy contains optional duplicate comparison settings.
+	DupePolicy *DupePolicy
+	// AudioPolicy contains optional audio-language restrictions.
+	AudioPolicy *AudioPolicy
+	// ImageHost contains optional accepted-host restrictions.
+	ImageHost *ImageHostPolicy
+	// TorrentIdentity contains optional torrent-client identity and search behavior.
+	TorrentIdentity *TorrentIdentityPolicy
+	// ClaimFactory constructs optional claim checking support.
+	ClaimFactory ClaimCheckerFactory
+	// ClaimPolicy contains optional generic claim orchestration settings.
+	ClaimPolicy *ClaimPolicy
+	// AuthResolver performs optional tracker-owned auth resolution.
+	AuthResolver AuthSessionResolver
+	// AuthCapability describes optional interactive auth support.
+	AuthCapability *api.TrackerAuthCapability
+	// AuthPolicy contains optional tracker-owned auth readiness semantics.
+	AuthPolicy *AuthPolicy
+	// AuthStateManager owns optional tracker-specific persisted auth cleanup.
+	AuthStateManager AuthStateManager
+	// MetadataLocale is the optional locale for tracker-owned rendering.
+	MetadataLocale string
+	// DescriptionGroup is the optional tracker-specific description override group.
+	DescriptionGroup string
 }
diff --git a/internal/trackers/description.go b/internal/trackers/description.go
index 45f214c1..b62e7d76 100644
--- a/internal/trackers/description.go
+++ b/internal/trackers/description.go
@@ -3,29 +3,10 @@
 
 package trackers
 
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type DescriptionRequest struct {
-	Tracker       string
-	Meta          api.PreparedMetadata
-	TrackerConfig config.TrackerConfig
-	AppConfig     config.Config
-	Logger        api.Logger
-	Repo          db.MetadataRepository
-	Assets        *DescriptionAssets
-}
-
+// DescriptionResult contains rendered description text and optional diagnostics.
 type DescriptionResult struct {
-	Group       string
+	// Group identifies the tracker-specific description override group.
+	Group string
+	// Description is rendered tracker markup ready for preview or payload preparation.
 	Description string
 }
-
-type DescriptionBuilder interface {
-	BuildDescription(ctx context.Context, req DescriptionRequest) (DescriptionResult, error)
-}
diff --git a/internal/trackers/description_assets.go b/internal/trackers/description_assets.go
index 9871faf9..1ac19dff 100644
--- a/internal/trackers/description_assets.go
+++ b/internal/trackers/description_assets.go
@@ -13,17 +13,37 @@ import (
 	"strings"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// DescriptionAssets contains persisted description text and images selected for one tracker.
 type DescriptionAssets struct {
+	// Description is the persisted or generated BBCode selected for the tracker.
 	Description string
+	// Screenshots contains non-menu images selected for the final description.
 	Screenshots []api.ScreenshotImage
-	MenuImages  []api.ScreenshotImage
-	Slots       []api.ScreenshotSlot
-	Override    bool
-	Final       bool
+	// MenuImages contains selected disc-menu images.
+	MenuImages []api.ScreenshotImage
+	// Slots preserves screenshot ordering and uploaded variants.
+	Slots []api.ScreenshotSlot
+	// Override reports that Description came from a saved user override.
+	Override bool
+	// Final reports that screenshot selection has been finalized.
+	Final bool
+}
+
+// PreparedDescriptionAssets returns a defensive copy of module-resolved image
+// and slot slices. Nil input returns zero assets; it currently returns no error.
+func PreparedDescriptionAssets(prepared *DescriptionAssets) (DescriptionAssets, error) {
+	if prepared == nil {
+		return DescriptionAssets{}, nil
+	}
+	assets := *prepared
+	assets.Screenshots = append([]api.ScreenshotImage(nil), prepared.Screenshots...)
+	assets.MenuImages = append([]api.ScreenshotImage(nil), prepared.MenuImages...)
+	assets.Slots = cloneScreenshotSlots(prepared.Slots)
+	return assets, nil
 }
 
 var embeddedNFOBlockPatterns = []*regexp.Regexp{
@@ -32,13 +52,23 @@ var embeddedNFOBlockPatterns = []*regexp.Regexp{
 }
 
 var descriptionSpacingPattern = regexp.MustCompile(`\n{3,}`)
-var defaultSignaturePattern = regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`)
-var unit3DBotSignaturePattern = regexp.MustCompile(`(?is)\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?(?:\[b\]\s*Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\s*\[/b\]|Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader)(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\]`)
-var knownBotSignaturePattern = regexp.MustCompile(`(?is)(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*Find\s+our\s+uploads\s+\[url=https?://[^\]]*/torrents\?name=[^\]]+\].*?here.*?\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s+v?\d+(?:\.\d+)*)?(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])|(?:\[(?:center|right|align=right)\]\s*Uploaded\s+with\s+(?:\[color=[^\]]+\]\s*)?\x{2764}(?:\s*\[/color\])?\s+using\s+GG-BOT\s+Upload\s+Assistant\s*\[/(?:center|right|align)\])`)
+
+var defaultSignaturePattern = regexp.MustCompile(
+	`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`,
+)
+
+var unit3DBotSignaturePattern = regexp.MustCompile(
+	`(?is)\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?(?:\[b\]\s*Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\s*\[/b\]|Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader)(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\]`,
+)
+
+var knownBotSignaturePattern = regexp.MustCompile(
+	`(?is)(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*Find\s+our\s+uploads\s+\[url=https?://[^\]]*/torrents\?name=[^\]]+\].*?here.*?\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s+v?\d+(?:\.\d+)*)?(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])|(?:\[(?:center|right|align=right)\]\s*Uploaded\s+with\s+(?:\[color=[^\]]+\]\s*)?\x{2764}(?:\s*\[/color\])?\s+using\s+GG-BOT\s+Upload\s+Assistant\s*\[/(?:center|right|align)\])`,
+)
 var knownBotImagePattern = regexp.MustCompile(`(?is)\[img(?:=[^\]]*)?\]\s*https://files\.catbox\.moe/5izwmx\.svg\s*\[/img\]`)
 var emptyCenterPattern = regexp.MustCompile(`(?is)\[center\]\s*\[/center\]`)
 
 type preloadedDescriptionAssetData struct {
+	registry              *Registry
 	descriptionOverrides  map[string]api.DescriptionOverride
 	groupDescriptions     map[string]string
 	trackerDescriptions   map[string]string
@@ -50,11 +80,26 @@ type preloadedDescriptionAssetData struct {
 	screenshotSlotsLoaded bool
 }
 
+func preloadedRegistry(preloaded *preloadedDescriptionAssetData) *Registry {
+	if preloaded == nil {
+		return nil
+	}
+	return preloaded.registry
+}
+
+func firstRegistry(registries []*Registry) *Registry {
+	if len(registries) == 0 {
+		return nil
+	}
+	return registries[0]
+}
+
 func clonePreloadedDescriptionAssetData(preloaded *preloadedDescriptionAssetData) *preloadedDescriptionAssetData {
 	if preloaded == nil {
 		return nil
 	}
 	return &preloadedDescriptionAssetData{
+		registry:              preloaded.registry,
 		descriptionOverrides:  cloneDescriptionOverrides(preloaded.descriptionOverrides),
 		groupDescriptions:     cloneStringMap(preloaded.groupDescriptions),
 		trackerDescriptions:   cloneStringMap(preloaded.trackerDescriptions),
@@ -106,38 +151,43 @@ func cloneTrackerMetadata(records []api.TrackerMetadata) []api.TrackerMetadata {
 	return cloned
 }
 
-func DescriptionOverrideGroupForTracker(tracker string) string {
+// DescriptionOverrideGroupForTrackerWithRegistry returns the registered group,
+// falls back to "unit3d" for Unit3D definitions, and otherwise uses the
+// lower-case tracker name. Unregistered trackers return empty.
+func DescriptionOverrideGroupForTrackerWithRegistry(tracker string, registry *Registry) string {
 	normalized := strings.ToUpper(strings.TrimSpace(tracker))
-	switch {
-	case normalized == "":
-		return ""
-	case IsUnit3DTracker(normalized):
-		if normalized == "ACM" {
-			return "acm"
+	if descriptor, ok := registry.LookupDescriptor(normalized); ok {
+		if group := strings.ToLower(strings.TrimSpace(descriptor.DescriptionGroup)); group != "" {
+			return group
+		}
+		if descriptor.Family == FamilyUnit3D {
+			return "unit3d"
 		}
-		return "unit3d"
-	default:
 		return strings.ToLower(normalized)
 	}
+	return ""
 }
 
 func normalizeDescriptionOverrideGroupKey(groupKey string) string {
 	return strings.ToLower(strings.TrimSpace(groupKey))
 }
 
-func ResolveDescriptionAssets(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger) (DescriptionAssets, error) {
-	return resolveDescriptionAssets(ctx, tracker, meta, repo, logger, nil)
-}
-
-// ResolveDescriptionAssetsWithPrepared returns caller-prepared assets when
-// available, preserving image-host resolution performed by the orchestrator.
-func ResolveDescriptionAssetsWithPrepared(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger, prepared *DescriptionAssets) (DescriptionAssets, error) {
-	if prepared != nil {
-		return *prepared, nil
-	}
-	return ResolveDescriptionAssets(ctx, tracker, meta, repo, logger)
+// ResolveDescriptionAssets returns sanitized tracker description text and
+// ordered persisted screenshot assets. With no repository or source path it
+// resolves prepared/request description text only; required screenshot-slot
+// failures abort the result while optional description lookups fall back.
+func ResolveDescriptionAssets(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	registries ...*Registry,
+) (DescriptionAssets, error) {
+	return resolveDescriptionAssets(ctx, tracker, meta, repo, logger, nil, registries...)
 }
 
+// LogDescriptionAssetResolutionFailure records a redacted tracker asset-resolution failure.
 func LogDescriptionAssetResolutionFailure(logger api.Logger, tracker string, err error) {
 	if err == nil || logger == nil {
 		return
@@ -149,33 +199,45 @@ func LogDescriptionAssetResolutionFailure(logger api.Logger, tracker string, err
 	)
 }
 
-func resolveDescriptionAssets(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger, preloaded *preloadedDescriptionAssetData) (DescriptionAssets, error) {
+func resolveDescriptionAssets(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	preloaded *preloadedDescriptionAssetData,
+	registries ...*Registry,
+) (DescriptionAssets, error) {
+	registry := firstRegistry(registries)
+	if registry == nil {
+		registry = preloadedRegistry(preloaded)
+	}
 	if err := ctx.Err(); err != nil {
 		return DescriptionAssets{}, fmt.Errorf("trackers: resolve description assets canceled: %w", err)
 	}
 	if repo == nil || strings.TrimSpace(meta.SourcePath) == "" {
 		description := meta.DescriptionOverride
 		final := false
-		if canonical := descriptionGroupFromPreparedMeta(meta, tracker, preloaded); strings.TrimSpace(canonical) != "" {
+		if canonical := descriptionGroupFromPreparedMeta(meta, tracker, preloaded, registry); strings.TrimSpace(canonical) != "" {
 			description = canonical
 			final = true
 		}
 		description = sanitizeTrackerDescription(tracker, description)
 		hasDescription := strings.TrimSpace(description) != ""
-		return DescriptionAssets{Description: description, Override: hasDescription, Final: final && hasDescription}, nil
+		return DescriptionAssets{
+			Description: description,
+			Override:    hasDescription,
+			Final:       final && hasDescription,
+		}, nil
 	}
 	if logger != nil {
 		logger.Tracef("trackers: description assets start tracker=%s source=%s", strings.TrimSpace(tracker), meta.SourcePath)
 	}
 
-	description, overridden, final := resolveTrackerDescription(ctx, tracker, meta, repo, logger, preloaded)
-	slots, screenshots, err := resolveDescriptionScreenshots(ctx, tracker, meta, repo, logger, preloaded)
+	description, overridden, final := resolveTrackerDescription(ctx, tracker, meta, repo, logger, preloaded, registry)
+	slots, screenshots, err := resolveDescriptionScreenshots(ctx, tracker, meta, repo, logger, preloaded, registry)
 	if err != nil {
-		if logger != nil {
-			logger.Warnf("trackers: description assets screenshots degraded for %s: %v", strings.TrimSpace(tracker), err)
-		}
-		slots = nil
-		screenshots = nil
+		return DescriptionAssets{}, fmt.Errorf("trackers: resolve required description screenshots: %w", err)
 	}
 	if logger != nil {
 		logger.Tracef("trackers: description assets resolved desc_len=%d screenshots=%d", len(strings.TrimSpace(description)), len(screenshots))
@@ -195,7 +257,14 @@ func resolveDescriptionAssets(ctx context.Context, tracker string, meta api.Prep
 	}, nil
 }
 
-func applyResolvedDescriptionScreenshots(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData, assets *DescriptionAssets, screenshots []api.ScreenshotImage) {
+func applyResolvedDescriptionScreenshots(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+	assets *DescriptionAssets,
+	screenshots []api.ScreenshotImage,
+) {
 	if assets == nil {
 		return
 	}
@@ -208,7 +277,14 @@ func applyResolvedDescriptionScreenshots(ctx context.Context, meta api.PreparedM
 	assets.MenuImages, assets.Screenshots = splitResolvedDescriptionScreenshots(ctx, meta, repo, preloaded, assets.Slots, screenshots)
 }
 
-func splitResolvedDescriptionScreenshots(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData, slots []api.ScreenshotSlot, screenshots []api.ScreenshotImage) ([]api.ScreenshotImage, []api.ScreenshotImage) {
+func splitResolvedDescriptionScreenshots(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+	slots []api.ScreenshotSlot,
+	screenshots []api.ScreenshotImage,
+) ([]api.ScreenshotImage, []api.ScreenshotImage) {
 	if len(screenshots) == 0 {
 		return nil, nil
 	}
@@ -226,7 +302,13 @@ func splitResolvedDescriptionScreenshots(ctx context.Context, meta api.PreparedM
 	return splitDescriptionScreenshots(ctx, meta, repo, preloaded, filtered)
 }
 
-func splitDescriptionScreenshots(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData, screenshots []api.ScreenshotImage) ([]api.ScreenshotImage, []api.ScreenshotImage) {
+func splitDescriptionScreenshots(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+	screenshots []api.ScreenshotImage,
+) ([]api.ScreenshotImage, []api.ScreenshotImage) {
 	if len(screenshots) == 0 {
 		return nil, nil
 	}
@@ -325,13 +407,26 @@ func rewriteDescriptionSlotURLs(description string, slots []api.ScreenshotSlot,
 	return strings.TrimSpace(descriptionSpacingPattern.ReplaceAllString(result, "\n\n"))
 }
 
-func resolveTrackerDescription(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger, preloaded *preloadedDescriptionAssetData) (string, bool, bool) {
+func resolveTrackerDescription(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
+) (string, bool, bool) {
 	if err := ctx.Err(); err != nil {
 		return "", false, false
 	}
-	if canonical := descriptionGroupFromPreparedMeta(meta, tracker, preloaded); strings.TrimSpace(canonical) != "" {
+	if canonical := descriptionGroupFromPreparedMeta(meta, tracker, preloaded, registry); strings.TrimSpace(canonical) != "" {
 		if logger != nil {
-			logger.Tracef("trackers: canonical group description applied source=%s tracker=%s len=%d", meta.SourcePath, strings.TrimSpace(tracker), len(strings.TrimSpace(canonical)))
+			logger.Tracef(
+				"trackers: canonical group description applied source=%s tracker=%s len=%d",
+				meta.SourcePath,
+				strings.TrimSpace(tracker),
+				len(strings.TrimSpace(canonical)),
+			)
 		}
 		return canonical, true, true
 	}
@@ -342,13 +437,18 @@ func resolveTrackerDescription(ctx context.Context, tracker string, meta api.Pre
 		return meta.DescriptionOverride, true, false
 	}
 	if repo != nil && strings.TrimSpace(meta.SourcePath) != "" {
-		for _, groupKey := range descriptionOverrideLookupKeys(meta.DescriptionGroups, tracker) {
+		for _, groupKey := range descriptionOverrideLookupKeys(meta.DescriptionGroups, tracker, registry) {
 			override, err := descriptionOverrideFromSource(ctx, meta, repo, groupKey, preloaded)
 			if err == nil {
 				trimmed := strings.TrimSpace(override.Description)
 				if trimmed != "" {
 					if logger != nil {
-						logger.Tracef("trackers: description override applied source=%s group=%s len=%d", meta.SourcePath, strings.TrimSpace(groupKey), len(trimmed))
+						logger.Tracef(
+							"trackers: description override applied source=%s group=%s len=%d",
+							meta.SourcePath,
+							strings.TrimSpace(groupKey),
+							len(trimmed),
+						)
 					}
 					return override.Description, true, false
 				}
@@ -375,12 +475,18 @@ func resolveTrackerDescription(ctx context.Context, tracker string, meta api.Pre
 	}
 	result := combineDescriptions(tracker, combined)
 	if logger != nil {
-		logger.Tracef("trackers: description assets description sources db=%d meta=%d combined=%d desc_len=%d", len(records), len(meta.TrackerData), len(combined), len(strings.TrimSpace(result)))
+		logger.Tracef(
+			"trackers: description assets description sources db=%d meta=%d combined=%d desc_len=%d",
+			len(records),
+			len(meta.TrackerData),
+			len(combined),
+			len(strings.TrimSpace(result)),
+		)
 	}
 	return result, false, false
 }
 
-func descriptionGroupFromPreparedMeta(meta api.PreparedMetadata, tracker string, preloaded *preloadedDescriptionAssetData) string {
+func descriptionGroupFromPreparedMeta(meta api.UploadSubject, tracker string, preloaded *preloadedDescriptionAssetData, registry *Registry) string {
 	if len(meta.DescriptionGroups) == 0 {
 		return ""
 	}
@@ -390,7 +496,7 @@ func descriptionGroupFromPreparedMeta(meta api.PreparedMetadata, tracker string,
 		return ""
 	}
 
-	for _, groupKey := range descriptionOverrideLookupKeys(meta.DescriptionGroups, tracker) {
+	for _, groupKey := range descriptionOverrideLookupKeys(meta.DescriptionGroups, tracker, registry) {
 		if description, ok := groupDescriptions[strings.ToUpper(strings.TrimSpace(groupKey))]; ok {
 			return description
 		}
@@ -409,16 +515,16 @@ func descriptionGroupFromPreparedMeta(meta api.PreparedMetadata, tracker string,
 	return ""
 }
 
-func descriptionOverrideLookupKeys(groups []api.DescriptionBuilderGroup, tracker string) []string {
-	keys := matchingPreparationDescriptionGroupKeys(groups, tracker)
-	canonical := strings.TrimSpace(DescriptionOverrideGroupForTracker(tracker))
+func descriptionOverrideLookupKeys(groups []api.DescriptionBuilderGroup, tracker string, registries ...*Registry) []string {
+	keys := matchingPreparationDescriptionGroupKeys(groups, tracker, registries...)
+	canonical := strings.TrimSpace(DescriptionOverrideGroupForTrackerWithRegistry(tracker, firstRegistry(registries)))
 	if canonical == "" {
 		return keys
 	}
 	return appendUniqueDescriptionGroupKey(keys, canonical)
 }
 
-func matchingPreparationDescriptionGroupKeys(groups []api.DescriptionBuilderGroup, tracker string) []string {
+func matchingPreparationDescriptionGroupKeys(groups []api.DescriptionBuilderGroup, tracker string, registries ...*Registry) []string {
 	if len(groups) == 0 {
 		return nil
 	}
@@ -428,7 +534,7 @@ func matchingPreparationDescriptionGroupKeys(groups []api.DescriptionBuilderGrou
 		return nil
 	}
 
-	canonicalGroup := strings.ToLower(strings.TrimSpace(DescriptionOverrideGroupForTracker(tracker)))
+	canonicalGroup := strings.ToLower(strings.TrimSpace(DescriptionOverrideGroupForTrackerWithRegistry(tracker, firstRegistry(registries))))
 	if canonicalGroup == "" {
 		return nil
 	}
@@ -458,7 +564,11 @@ func matchingPreparationDescriptionGroupKeys(groups []api.DescriptionBuilderGrou
 		if host == strings.ToLower(normalizedTracker) {
 			score++
 		}
-		candidates = append(candidates, candidate{key: key, score: score, order: idx})
+		candidates = append(candidates, candidate{
+			key:   key,
+			score: score,
+			order: idx,
+		})
 	}
 
 	sort.SliceStable(candidates, func(i, j int) bool {
@@ -523,7 +633,10 @@ func appendUniqueDescriptionGroupKey(keys []string, groupKey string) []string {
 	return append(keys, trimmed)
 }
 
-func preparedDescriptionGroupLookups(groups []api.DescriptionBuilderGroup, preloaded *preloadedDescriptionAssetData) (map[string]string, map[string]string, map[string]struct{}) {
+func preparedDescriptionGroupLookups(
+	groups []api.DescriptionBuilderGroup,
+	preloaded *preloadedDescriptionAssetData,
+) (map[string]string, map[string]string, map[string]struct{}) {
 	if preloaded != nil && (preloaded.groupDescriptions != nil || preloaded.trackerDescriptions != nil || preloaded.ambiguousTrackers != nil) {
 		return preloaded.groupDescriptions, preloaded.trackerDescriptions, preloaded.ambiguousTrackers
 	}
@@ -544,7 +657,8 @@ func preparedDescriptionGroupLookups(groups []api.DescriptionBuilderGroup, prelo
 			if _, ambiguous := ambiguousTrackers[normalizedTracker]; ambiguous {
 				continue
 			}
-			if existing, ok := trackerDescriptions[normalizedTracker]; ok && !strings.EqualFold(strings.TrimSpace(existing), strings.TrimSpace(group.RawDescription)) {
+			if existing, ok := trackerDescriptions[normalizedTracker]; ok &&
+				!strings.EqualFold(strings.TrimSpace(existing), strings.TrimSpace(group.RawDescription)) {
 				delete(trackerDescriptions, normalizedTracker)
 				ambiguousTrackers[normalizedTracker] = struct{}{}
 				continue
@@ -572,23 +686,25 @@ func mergeTrackerMetadata(primary []api.TrackerMetadata, fallback []api.TrackerM
 	return combined
 }
 
-func resolveDescriptionScreenshots(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger, preloaded *preloadedDescriptionAssetData) ([]api.ScreenshotSlot, []api.ScreenshotImage, error) {
+func resolveDescriptionScreenshots(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
+) ([]api.ScreenshotSlot, []api.ScreenshotImage, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, nil, fmt.Errorf("trackers: resolve description screenshots canceled: %w", err)
 	}
-	slots, err := screenshotSlotsFromSource(ctx, tracker, meta, repo, logger, preloaded)
+	slots, err := screenshotSlotsFromSource(ctx, tracker, meta, repo, logger, preloaded, registry)
 	if err != nil {
-		if logger != nil {
-			logger.Debugf("trackers: description assets failed to load screenshot slots: %v", err)
-		}
-		slots = nil
+		return nil, nil, fmt.Errorf("trackers: load screenshot slots: %w", err)
 	}
 	images, _, _, err := selectScreenshotsFromSlots(tracker, slots, imageHostPolicy{})
 	if err != nil {
-		if logger != nil {
-			logger.Warnf("trackers: description assets slot screenshot resolution failed tracker=%s: %v", strings.TrimSpace(tracker), err)
-		}
-		images = nil
+		return nil, nil, fmt.Errorf("trackers: resolve screenshot slots for %s: %w", strings.TrimSpace(tracker), err)
 	}
 	if len(images) > 0 {
 		if logger != nil {
@@ -604,33 +720,45 @@ func resolveDescriptionScreenshots(ctx context.Context, tracker string, meta api
 	return nil, resolveTrackerScreenshots(urls), nil
 }
 
-func preloadDescriptionAssetData(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository) (*preloadedDescriptionAssetData, error) {
+func preloadDescriptionAssetData(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	registry *Registry,
+) (*preloadedDescriptionAssetData, error) {
+	preloaded, err := preloadUploadAssetData(ctx, meta, repo, registry)
+	if err != nil {
+		return nil, err
+	}
+	if err := preloadDescriptionFields(ctx, meta, repo, preloaded); err != nil {
+		return nil, err
+	}
+	return preloaded, nil
+}
+
+func preloadScreenshotAssetData(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	registry *Registry,
+) (*preloadedDescriptionAssetData, error) {
+	return preloadUploadAssetData(ctx, meta, repo, registry)
+}
+
+func preloadUploadAssetData(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	registry *Registry,
+) (*preloadedDescriptionAssetData, error) {
 	if err := ctx.Err(); err != nil {
-		return nil, fmt.Errorf("trackers: preload description assets canceled: %w", err)
+		return nil, fmt.Errorf("trackers: preload upload assets canceled: %w", err)
 	}
 	if repo == nil || strings.TrimSpace(meta.SourcePath) == "" {
 		return nil, nil
 	}
 
-	preloaded := &preloadedDescriptionAssetData{
-		descriptionOverrides: make(map[string]api.DescriptionOverride),
-	}
-	preloaded.groupDescriptions, preloaded.trackerDescriptions, preloaded.ambiguousTrackers = preparedDescriptionGroupLookups(meta.DescriptionGroups, nil)
-
-	overrides, err := repo.ListDescriptionOverridesByPath(ctx, meta.SourcePath)
-	switch {
-	case err == nil:
-		for _, override := range overrides {
-			normalizedGroupKey := normalizeDescriptionOverrideGroupKey(override.GroupKey)
-			if normalizedGroupKey == "" {
-				continue
-			}
-			preloaded.descriptionOverrides[normalizedGroupKey] = override
-		}
-	case errors.Is(err, internalerrors.ErrNotFound):
-	default:
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
+	preloaded := &preloadedDescriptionAssetData{registry: registry}
 
 	trackerRecords, err := repo.ListTrackerMetadataByPath(ctx, meta.SourcePath)
 	if err != nil {
@@ -650,7 +778,7 @@ func preloadDescriptionAssetData(ctx context.Context, meta api.PreparedMetadata,
 	}
 	preloaded.uploads = uploads
 
-	slots, err := screenshotSlotsFromSource(ctx, "", meta, repo, nil, preloaded)
+	slots, err := screenshotSlotsFromSource(ctx, "", meta, repo, nil, preloaded, registry)
 	if err != nil {
 		return nil, err
 	}
@@ -660,7 +788,45 @@ func preloadDescriptionAssetData(ctx context.Context, meta api.PreparedMetadata,
 	return preloaded, nil
 }
 
-func descriptionOverrideFromSource(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, groupKey string, preloaded *preloadedDescriptionAssetData) (api.DescriptionOverride, error) {
+func preloadDescriptionFields(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+) error {
+	if err := ctx.Err(); err != nil {
+		return fmt.Errorf("trackers: preload description fields canceled: %w", err)
+	}
+	if preloaded == nil || repo == nil || strings.TrimSpace(meta.SourcePath) == "" {
+		return nil
+	}
+
+	preloaded.descriptionOverrides = make(map[string]api.DescriptionOverride)
+	preloaded.groupDescriptions, preloaded.trackerDescriptions, preloaded.ambiguousTrackers = preparedDescriptionGroupLookups(meta.DescriptionGroups, nil)
+	overrides, err := repo.ListDescriptionOverridesByPath(ctx, meta.SourcePath)
+	switch {
+	case err == nil:
+		for _, override := range overrides {
+			normalizedGroupKey := normalizeDescriptionOverrideGroupKey(override.GroupKey)
+			if normalizedGroupKey == "" {
+				continue
+			}
+			preloaded.descriptionOverrides[normalizedGroupKey] = override
+		}
+	case errors.Is(err, internalerrors.ErrNotFound):
+	default:
+		return fmt.Errorf("trackers: list description overrides: %w", err)
+	}
+	return nil
+}
+
+func descriptionOverrideFromSource(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	groupKey string,
+	preloaded *preloadedDescriptionAssetData,
+) (api.DescriptionOverride, error) {
 	if err := ctx.Err(); err != nil {
 		return api.DescriptionOverride{}, fmt.Errorf("trackers: load description override canceled: %w", err)
 	}
@@ -678,7 +844,12 @@ func descriptionOverrideFromSource(ctx context.Context, meta api.PreparedMetadat
 	return api.DescriptionOverride{}, fmt.Errorf("trackers: %w", err)
 }
 
-func trackerMetadataFromSource(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData) ([]api.TrackerMetadata, error) {
+func trackerMetadataFromSource(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+) ([]api.TrackerMetadata, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("trackers: load tracker metadata canceled: %w", err)
 	}
@@ -688,7 +859,12 @@ func trackerMetadataFromSource(ctx context.Context, meta api.PreparedMetadata, r
 	return wrapTrackerResult(repo.ListTrackerMetadataByPath(ctx, meta.SourcePath))
 }
 
-func finalSelectionsFromSource(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData) ([]api.ScreenshotFinalSelection, error) {
+func finalSelectionsFromSource(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+) ([]api.ScreenshotFinalSelection, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("trackers: load final selections canceled: %w", err)
 	}
@@ -698,7 +874,12 @@ func finalSelectionsFromSource(ctx context.Context, meta api.PreparedMetadata, r
 	return wrapTrackerResult(repo.ListFinalSelections(ctx, meta.SourcePath))
 }
 
-func uploadedImagesFromSource(ctx context.Context, meta api.PreparedMetadata, repo api.MetadataRepository, preloaded *preloadedDescriptionAssetData) ([]api.UploadedImageLink, error) {
+func uploadedImagesFromSource(
+	ctx context.Context,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	preloaded *preloadedDescriptionAssetData,
+) ([]api.UploadedImageLink, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("trackers: load uploaded images canceled: %w", err)
 	}
@@ -708,7 +889,14 @@ func uploadedImagesFromSource(ctx context.Context, meta api.PreparedMetadata, re
 	return wrapTrackerResult(repo.ListUploadedImagesByPath(ctx, meta.SourcePath))
 }
 
-func resolveTrackerImageURLs(ctx context.Context, tracker string, meta api.PreparedMetadata, repo api.MetadataRepository, logger api.Logger, preloaded *preloadedDescriptionAssetData) []string {
+func resolveTrackerImageURLs(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	preloaded *preloadedDescriptionAssetData,
+) []string {
 	if err := ctx.Err(); err != nil {
 		return nil
 	}
@@ -726,7 +914,12 @@ func resolveTrackerImageURLs(ctx context.Context, tracker string, meta api.Prepa
 				filtered := filterTrackerMetadataByName(records, trackerKey)
 				if len(filtered) > 0 {
 					if logger != nil {
-						logger.Tracef("trackers: description assets tracker urls source=db tracker=%s records=%d filtered=%d", trackerKey, len(records), len(filtered))
+						logger.Tracef(
+							"trackers: description assets tracker urls source=db tracker=%s records=%d filtered=%d",
+							trackerKey,
+							len(records),
+							len(filtered),
+						)
 					}
 					return collectImageURLs(filtered)
 				}
@@ -743,7 +936,12 @@ func resolveTrackerImageURLs(ctx context.Context, tracker string, meta api.Prepa
 		filtered := filterTrackerMetadataByName(meta.TrackerData, trackerKey)
 		if len(filtered) > 0 {
 			if logger != nil {
-				logger.Tracef("trackers: description assets tracker urls source=meta tracker=%s records=%d filtered=%d", trackerKey, len(meta.TrackerData), len(filtered))
+				logger.Tracef(
+					"trackers: description assets tracker urls source=meta tracker=%s records=%d filtered=%d",
+					trackerKey,
+					len(meta.TrackerData),
+					len(filtered),
+				)
 			}
 			return collectImageURLs(filtered)
 		}
@@ -928,19 +1126,20 @@ func stripEmbeddedNFOBlocks(value string) string {
 	return strings.TrimSpace(cleaned)
 }
 
-func sanitizeTrackerDescription(tracker string, value string) string {
+func sanitizeTrackerDescription(_ string, value string) string {
 	cleaned := stripEmbeddedNFOBlocks(value)
 	cleaned = unit3DBotSignaturePattern.ReplaceAllString(cleaned, "")
 	cleaned = knownBotSignaturePattern.ReplaceAllString(cleaned, "")
 	cleaned = knownBotImagePattern.ReplaceAllString(cleaned, "")
+	cleaned = defaultSignaturePattern.ReplaceAllString(cleaned, "")
 	cleaned = emptyCenterPattern.ReplaceAllString(cleaned, "")
 	cleaned = descriptionSpacingPattern.ReplaceAllString(cleaned, "\n\n")
-	switch strings.ToUpper(strings.TrimSpace(tracker)) {
-	case "ANT", "NBL":
-		cleaned = defaultSignaturePattern.ReplaceAllString(cleaned, "")
-		cleaned = descriptionSpacingPattern.ReplaceAllString(cleaned, "\n\n")
-		return strings.TrimSpace(cleaned)
-	default:
-		return strings.TrimSpace(cleaned)
-	}
+	return strings.TrimSpace(cleaned)
+}
+
+// StripDefaultDescriptionSignature removes the generic uploader signature.
+func StripDefaultDescriptionSignature(value string) string {
+	cleaned := defaultSignaturePattern.ReplaceAllString(value, "")
+	cleaned = descriptionSpacingPattern.ReplaceAllString(cleaned, "\n\n")
+	return strings.TrimSpace(cleaned)
 }
diff --git a/internal/trackers/description_assets_test.go b/internal/trackers/description_assets_test.go
index f6ee0ec5..0f8aeb5b 100644
--- a/internal/trackers/description_assets_test.go
+++ b/internal/trackers/description_assets_test.go
@@ -15,33 +15,34 @@ import (
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	dbsvc "github.com/autobrr/upbrr/internal/services/db"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 type stubRepo struct {
-	mu                  sync.Mutex
-	trackerRecords      []api.TrackerMetadata
-	trackerRecordsErr   error
-	trackerRecordsCalls int
-	selections          []api.ScreenshotFinalSelection
-	selectionsErr       error
-	selectionsCalls     int
-	screenshotSlots     []api.ScreenshotSlot
-	screenshotSlotsErr  error
-	screenshotSlotCalls int
-	uploads             []api.UploadedImageLink
-	uploadsErr          error
-	uploadsCalls        int
-	deletedUploads      []string
-	createdUploads      []api.UploadRecord
-	statusUpdates       []uploadStatusUpdate
-	descriptionOverride string
-	overrideGroupKey    string
-	overrideCalls       int
+	mu                     sync.Mutex
+	trackerRecords         []api.TrackerMetadata
+	trackerRecordsErr      error
+	trackerRecordsCalls    int
+	selections             []api.ScreenshotFinalSelection
+	selectionsErr          error
+	selectionsCalls        int
+	screenshotSlots        []api.ScreenshotSlot
+	screenshotSlotsErr     error
+	screenshotSlotCalls    int
+	uploads                []api.UploadedImageLink
+	uploadsErr             error
+	uploadsCalls           int
+	deletedUploads         []string
+	createdUploads         []api.UploadRecord
+	statusUpdates          []uploadStatusUpdate
+	descriptionOverride    string
+	descriptionOverrideErr error
+	overrideGroupKey       string
+	overrideCalls          int
 }
 
 type uploadStatusUpdate struct {
@@ -49,18 +50,76 @@ type uploadStatusUpdate struct {
 	status  string
 }
 
+type descriptionAssetsTestDefinition struct {
+	name   string
+	family Family
+}
+
+func (d descriptionAssetsTestDefinition) Name() string { return d.name }
+
+func (descriptionAssetsTestDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (descriptionAssetsTestDefinition) DefaultBaseURL() string {
+	return "https://tracker.example.invalid"
+}
+
+func (d descriptionAssetsTestDefinition) TrackerFamily() Family { return d.family }
+
+func (descriptionAssetsTestDefinition) Prepare(context.Context, PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return TrackerPlan{}, nil
+}
+
+func descriptionAssetsTestRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	policies := map[string]*ImageHostPolicy{
+		"HDB": {
+			AllowedHosts:         []string{"hdb"},
+			OwnedHosts:           []string{"hdb"},
+			DisableWithoutRehost: true,
+		},
+		"MTV": {AllowedHosts: []string{"imgbox", "imgbb"}},
+		"OE":  {AllowedHosts: []string{"imgbox", "imgbb", "onlyimage", "ptscreens", "passtheimage"}},
+		"PTP": {AllowedHosts: []string{"pixhost", "imgbb", "onlyimage", "ptscreens", "passtheimage"}},
+	}
+	for _, item := range []descriptionAssetsTestDefinition{
+		{name: "AITHER", family: FamilyUnit3D},
+		{name: "HHD", family: FamilyUnit3D},
+		{name: "ANT", family: FamilyStandalone},
+		{name: "HDB", family: FamilyStandalone},
+		{name: "MTV", family: FamilyStandalone},
+		{name: "NBL", family: FamilyStandalone},
+		{name: "OE", family: FamilyUnit3D},
+		{name: "PTP", family: FamilyStandalone},
+		{name: "RHD", family: FamilyUnit3D},
+	} {
+		policy := policies[item.name]
+		if err := registry.RegisterDescriptor(Descriptor{
+			Name:       item.name,
+			Definition: item,
+			Family:     item.family,
+			ImageHost:  policy,
+		}); err != nil {
+			t.Fatalf("register %s description asset policy: %v", item.name, err)
+		}
+	}
+	return registry
+}
+
 func (s *stubRepo) GetByPath(context.Context, string) (api.FileMetadata, error) {
 	return api.FileMetadata{}, nil
 }
 func (s *stubRepo) Save(context.Context, api.FileMetadata) error { return nil }
-func (s *stubRepo) GetExternalIDs(context.Context, string) (api.ExternalIDs, error) {
-	return api.ExternalIDs{}, nil
+func (s *stubRepo) GetExternalIdentity(context.Context, string) (api.ExternalIdentity, error) {
+	return api.ExternalIdentity{}, nil
 }
-func (s *stubRepo) SaveExternalIDs(context.Context, api.ExternalIDs) error { return nil }
-func (s *stubRepo) GetExternalMetadata(context.Context, string) (api.ExternalMetadata, error) {
-	return api.ExternalMetadata{}, nil
+func (s *stubRepo) SaveExternalIdentity(context.Context, api.ExternalIdentity) error { return nil }
+func (s *stubRepo) GetExternalMetadata(context.Context, string) (api.SourceScopedMetadata, error) {
+	return api.SourceScopedMetadata{}, nil
 }
-func (s *stubRepo) SaveExternalMetadata(context.Context, api.ExternalMetadata) error { return nil }
+func (s *stubRepo) SaveExternalMetadata(context.Context, api.SourceScopedMetadata) error { return nil }
 func (s *stubRepo) GetDVDMediaInfo(context.Context, string) (api.DVDMediaInfo, error) {
 	return api.DVDMediaInfo{}, internalerrors.ErrNotFound
 }
@@ -86,16 +145,27 @@ func (s *stubRepo) GetDescriptionOverride(_ context.Context, _ string, groupKey
 	if expectedGroupKey == "" && strings.TrimSpace(groupKey) != "" {
 		return api.DescriptionOverride{}, internalerrors.ErrNotFound
 	}
-	return api.DescriptionOverride{SourcePath: "/tmp/source", GroupKey: s.overrideGroupKey, Description: s.descriptionOverride}, nil
+	return api.DescriptionOverride{
+		SourcePath:  "/tmp/source",
+		GroupKey:    s.overrideGroupKey,
+		Description: s.descriptionOverride,
+	}, nil
 }
 func (s *stubRepo) ListDescriptionOverridesByPath(context.Context, string) ([]api.DescriptionOverride, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.overrideCalls++
+	if s.descriptionOverrideErr != nil {
+		return nil, s.descriptionOverrideErr
+	}
 	if s.descriptionOverride == "" {
 		return nil, internalerrors.ErrNotFound
 	}
-	return []api.DescriptionOverride{{SourcePath: "/tmp/source", GroupKey: s.overrideGroupKey, Description: s.descriptionOverride}}, nil
+	return []api.DescriptionOverride{{
+		SourcePath:  "/tmp/source",
+		GroupKey:    s.overrideGroupKey,
+		Description: s.descriptionOverride,
+	}}, nil
 }
 func (s *stubRepo) SaveDescriptionOverride(context.Context, api.DescriptionOverride) error {
 	return nil
@@ -225,11 +295,11 @@ type stubImageService struct {
 	repo    *stubRepo
 }
 
-func (s *stubImageService) ListCandidates(context.Context, api.PreparedMetadata) ([]api.ScreenshotImage, error) {
+func (s *stubImageService) ListCandidates(context.Context, api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
 	return nil, nil
 }
 
-func (s *stubImageService) Upload(_ context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+func (s *stubImageService) Upload(_ context.Context, meta api.ImageHostingSubject, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
 	s.mu.Lock()
 	s.calls = append(s.calls, host)
 	err := s.errs[host]
@@ -276,9 +346,9 @@ func TestResolveDescriptionAssetsPrefersDBDescription(t *testing.T) {
 	repo := &stubRepo{
 		trackerRecords: []api.TrackerMetadata{{Tracker: "AITHER", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", TrackerData: []api.TrackerMetadata{{Tracker: "AITHER", Description: "meta desc"}}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", TrackerData: []api.TrackerMetadata{{Tracker: "AITHER", Description: "meta desc"}}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -287,27 +357,24 @@ func TestResolveDescriptionAssetsPrefersDBDescription(t *testing.T) {
 	}
 }
 
-func TestResolveDescriptionAssetsWithPreparedPreservesCallerAssets(t *testing.T) {
+func TestPreparedDescriptionAssetsReturnsDefensiveCopy(t *testing.T) {
 	t.Parallel()
 
 	prepared := DescriptionAssets{
 		Description: "prepared description",
 		MenuImages:  []api.ScreenshotImage{{Path: filepath.Join(t.TempDir(), "prepared-menu.png")}},
 	}
-	resolved, err := ResolveDescriptionAssetsWithPrepared(
-		context.Background(),
-		"AITHER",
-		api.PreparedMetadata{},
-		&stubRepo{trackerRecordsErr: errors.New("must not query repository")},
-		api.NopLogger{},
-		&prepared,
-	)
+	resolved, err := PreparedDescriptionAssets(&prepared)
 	if err != nil {
 		t.Fatalf("resolve prepared assets: %v", err)
 	}
 	if resolved.Description != prepared.Description || len(resolved.MenuImages) != 1 || resolved.MenuImages[0].Path != prepared.MenuImages[0].Path {
 		t.Fatalf("resolved assets = %#v, want %#v", resolved, prepared)
 	}
+	resolved.MenuImages[0].Path = "mutated"
+	if resolved.MenuImages[0].Path == prepared.MenuImages[0].Path {
+		t.Fatal("prepared assets share mutable menu image storage")
+	}
 }
 
 func TestResolveDescriptionAssetsDedupesAfterSanitizingBotSignatures(t *testing.T) {
@@ -317,9 +384,9 @@ func TestResolveDescriptionAssetsDedupesAfterSanitizingBotSignatures(t *testing.
 			{Tracker: "AITHER", Description: "Body"},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -331,12 +398,27 @@ func TestResolveDescriptionAssetsDedupesAfterSanitizingBotSignatures(t *testing.
 func TestApplyResolvedDescriptionScreenshotsKeepsMenuImagesSeparate(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/screen1.png", Order: 0, Source: string(api.ScreenshotPurposeFinal)},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/menu1.png", Order: 1, Source: api.ScreenshotSelectionSourceDVDMenu},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/screen2.png", Order: 2, Source: string(api.ScreenshotPurposeFinal)},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/screen1.png",
+				Order:      0,
+				Source:     string(api.ScreenshotPurposeFinal),
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/menu1.png",
+				Order:      1,
+				Source:     api.ScreenshotSelectionSourceDVDMenu,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/screen2.png",
+				Order:      2,
+				Source:     string(api.ScreenshotPurposeFinal),
+			},
 		},
 	}
 	assets := DescriptionAssets{}
@@ -372,14 +454,29 @@ func TestDescriptionAssetsPreserveMenuClassificationAcrossRehost(t *testing.T) {
 		filepath.Join(root, "normal-screen.png"),
 	}
 	repo := &stubRepo{selections: []api.ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: paths[0], Order: 0, Source: api.ScreenshotSelectionSourceDVDMenu},
-		{SourcePath: sourcePath, ImagePath: paths[1], Order: 1, Source: api.ScreenshotSelectionSourceMenu},
-		{SourcePath: sourcePath, ImagePath: paths[2], Order: 2, Source: string(api.ScreenshotPurposeFinal)},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  paths[0],
+			Order:      0,
+			Source:     api.ScreenshotSelectionSourceDVDMenu,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  paths[1],
+			Order:      1,
+			Source:     api.ScreenshotSelectionSourceMenu,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  paths[2],
+			Order:      2,
+			Source:     string(api.ScreenshotPurposeFinal),
+		},
 	}}
 	images := &stubImageService{repo: repo}
-	meta := api.PreparedMetadata{SourcePath: sourcePath}
+	meta := api.UploadSubject{SourcePath: sourcePath}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"PTP",
 		meta,
@@ -387,7 +484,7 @@ func TestDescriptionAssetsPreserveMenuClassificationAcrossRehost(t *testing.T) {
 		config.TrackerConfig{},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("rehost description assets: %v", err)
@@ -396,7 +493,7 @@ func TestDescriptionAssetsPreserveMenuClassificationAcrossRehost(t *testing.T) {
 		t.Fatalf("rehost feedback = %#v", resolution.feedback)
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "PTP", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "PTP", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("resolve rehosted assets: %v", err)
 	}
@@ -428,9 +525,24 @@ func TestPartialMenuRemovalUpdatesResolvedAndRenderedDescription(t *testing.T) {
 	autoSecond := filepath.Join(root, "auto-menu-02.png")
 	normal := filepath.Join(root, "normal-screen-01.png")
 	selections := []api.ScreenshotFinalSelection{
-		{SourcePath: sourcePath, ImagePath: autoFirst, Order: 0, Source: api.ScreenshotSelectionSourceDVDMenu},
-		{SourcePath: sourcePath, ImagePath: autoSecond, Order: 1, Source: api.ScreenshotSelectionSourceDVDMenu},
-		{SourcePath: sourcePath, ImagePath: normal, Order: 2, Source: string(api.ScreenshotPurposeFinal)},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  autoFirst,
+			Order:      0,
+			Source:     api.ScreenshotSelectionSourceDVDMenu,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  autoSecond,
+			Order:      1,
+			Source:     api.ScreenshotSelectionSourceDVDMenu,
+		},
+		{
+			SourcePath: sourcePath,
+			ImagePath:  normal,
+			Order:      2,
+			Source:     string(api.ScreenshotPurposeFinal),
+		},
 	}
 	if err := repo.SaveFinalSelections(context.Background(), sourcePath, selections); err != nil {
 		t.Fatalf("save selections: %v", err)
@@ -475,7 +587,7 @@ func TestPartialMenuRemovalUpdatesResolvedAndRenderedDescription(t *testing.T) {
 		t.Fatalf("save slots: %v", err)
 	}
 
-	meta := api.PreparedMetadata{SourcePath: sourcePath}
+	meta := api.UploadSubject{SourcePath: sourcePath}
 	before := resolveAssetsForTest(t, meta, repo)
 	if len(before.MenuImages) != 2 || len(before.Screenshots) != 1 {
 		t.Fatalf("assets before removal = %#v", before)
@@ -490,7 +602,7 @@ func TestPartialMenuRemovalUpdatesResolvedAndRenderedDescription(t *testing.T) {
 
 	description, err := descriptionunit3d.BuildDescription(
 		context.Background(),
-		meta,
+		api.NewDescriptionSubject(meta),
 		config.Config{Description: config.DescriptionSettingsConfig{
 			DiscMenuHeader:   "Disc menu token",
 			ScreenshotHeader: "Screenshots token",
@@ -511,9 +623,9 @@ func TestPartialMenuRemovalUpdatesResolvedAndRenderedDescription(t *testing.T) {
 	}
 }
 
-func resolveAssetsForTest(t *testing.T, meta api.PreparedMetadata, repo api.MetadataRepository) DescriptionAssets {
+func resolveAssetsForTest(t *testing.T, meta api.UploadSubject, repo UploadPersistence) DescriptionAssets {
 	t.Helper()
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("resolve description assets: %v", err)
 	}
@@ -547,11 +659,21 @@ func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...
 func TestResolveDescriptionAssetsAppendsMenuSelectionToStoredSlots(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/screen1.png", Order: 0, Source: string(api.ScreenshotPurposeFinal)},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/menu1.png", Order: 1, Source: screenshotPurposeMenu},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/screen1.png",
+				Order:      0,
+				Source:     string(api.ScreenshotPurposeFinal),
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/menu1.png",
+				Order:      1,
+				Source:     screenshotPurposeMenu,
+			},
 		},
 		screenshotSlots: []api.ScreenshotSlot{
 			{
@@ -564,12 +686,24 @@ func TestResolveDescriptionAssetsAppendsMenuSelectionToStoredSlots(t *testing.T)
 			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/screen1.png", Host: "imgbb", UsageScope: globalImageUsageScope, ImgURL: "https://img.example/screen1.png"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/menu1.png", Host: "imgbb", UsageScope: globalImageUsageScope, ImgURL: "https://img.example/menu1.png"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/screen1.png",
+				Host:       "imgbb",
+				UsageScope: globalImageUsageScope,
+				ImgURL:     "https://img.example/screen1.png",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/menu1.png",
+				Host:       "imgbb",
+				UsageScope: globalImageUsageScope,
+				ImgURL:     "https://img.example/menu1.png",
+			},
 		},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("resolve description assets: %v", err)
 	}
@@ -587,9 +721,9 @@ func TestResolveDescriptionAssetsUsesOverride(t *testing.T) {
 		overrideGroupKey:    "unit3d",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "AITHER", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -607,9 +741,9 @@ func TestResolveDescriptionAssetsClearsOverrideWhenSanitizedDescriptionIsEmpty(t
 		overrideGroupKey:    "unit3d",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "AITHER", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -627,7 +761,7 @@ func TestResolveDescriptionAssetsUsesCompositeGroupOverride(t *testing.T) {
 		overrideGroupKey:    "unit3d|pixhost|global",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "AITHER", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey:       "unit3d|pixhost|global",
@@ -636,7 +770,7 @@ func TestResolveDescriptionAssetsUsesCompositeGroupOverride(t *testing.T) {
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -653,7 +787,7 @@ func TestResolveDescriptionAssetsUsesCompositeGroupOverride(t *testing.T) {
 
 func TestResolveDescriptionAssetsClearsFinalWhenSanitizedDescriptionIsEmpty(t *testing.T) {
 	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: sourcePath,
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey:       "unit3d",
@@ -662,7 +796,7 @@ func TestResolveDescriptionAssetsClearsFinalWhenSanitizedDescriptionIsEmpty(t *t
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, nil, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, nil, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -701,7 +835,7 @@ func TestApplyResolvedDescriptionScreenshotsDoesNotAppendFinalBuilderScreenshots
 		}},
 	}
 
-	applyResolvedDescriptionScreenshots(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, nil, nil, &assets, []api.ScreenshotImage{{
+	applyResolvedDescriptionScreenshots(context.Background(), api.UploadSubject{SourcePath: sourcePath}, nil, nil, &assets, []api.ScreenshotImage{{
 		ImgURL: "https://pixhost.example/1.png",
 		RawURL: "https://pixhost.example/raw-1.png",
 		Host:   "pixhost",
@@ -744,7 +878,7 @@ func TestApplyResolvedDescriptionScreenshotsPreservesFinalNonRenderableImages(t
 		},
 	}
 
-	applyResolvedDescriptionScreenshots(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, nil, nil, &assets, []api.ScreenshotImage{{
+	applyResolvedDescriptionScreenshots(context.Background(), api.UploadSubject{SourcePath: sourcePath}, nil, nil, &assets, []api.ScreenshotImage{{
 		ImgURL: "https://pixhost.example/1.png",
 		RawURL: "https://pixhost.example/raw-1.png",
 		Host:   "pixhost",
@@ -767,7 +901,7 @@ func TestResolveDescriptionAssetsLoadsStoredCompositeGroupOverride(t *testing.T)
 		overrideGroupKey:    "unit3d|pixhost|global",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "AITHER", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey:       "unit3d|pixhost|global",
@@ -776,7 +910,7 @@ func TestResolveDescriptionAssetsLoadsStoredCompositeGroupOverride(t *testing.T)
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -789,7 +923,7 @@ func TestResolveDescriptionAssetsLoadsStoredCompositeGroupOverride(t *testing.T)
 }
 
 func TestResolveDescriptionAssetsUsesTrackerMatchedVariantGroup(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DescriptionGroups: []api.DescriptionBuilderGroup{
 			{
 				GroupKey:       "unit3d",
@@ -804,7 +938,7 @@ func TestResolveDescriptionAssetsUsesTrackerMatchedVariantGroup(t *testing.T) {
 		},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HHD", meta, nil, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HHD", meta, nil, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -821,9 +955,9 @@ func TestResolveDescriptionAssetsDoesNotFallbackToLegacyDefaultGroupOverride(t *
 		descriptionOverride: "legacy default desc",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "HDB", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -841,7 +975,7 @@ func TestResolveDescriptionAssetsPrefersCanonicalGroupDescription(t *testing.T)
 		overrideGroupKey:    "hdb",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "HDB", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey:       "hdb",
@@ -850,7 +984,7 @@ func TestResolveDescriptionAssetsPrefersCanonicalGroupDescription(t *testing.T)
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -868,7 +1002,7 @@ func TestResolveDescriptionAssetsPrefersTrackerScopedCompositeGroupDescription(t
 		overrideGroupKey:    "hdb|hdb|tracker:HDB",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "HDB", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		DescriptionGroups: []api.DescriptionBuilderGroup{
 			{
@@ -884,7 +1018,7 @@ func TestResolveDescriptionAssetsPrefersTrackerScopedCompositeGroupDescription(t
 		},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -897,7 +1031,7 @@ func TestResolveDescriptionAssetsPrefersTrackerScopedCompositeGroupDescription(t
 }
 
 func TestResolveDescriptionAssetsUsesCanonicalGroupDescriptionWithoutRepo(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DescriptionOverride: "legacy override desc",
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey:       "hdb",
@@ -906,7 +1040,7 @@ func TestResolveDescriptionAssetsUsesCanonicalGroupDescriptionWithoutRepo(t *tes
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, nil, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, nil, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -920,7 +1054,7 @@ func TestResolveDescriptionAssetsUsesCanonicalGroupDescriptionWithoutRepo(t *tes
 
 func TestResolveDescriptionAssetsUsesCanonicalGroupDescriptionWithoutSourcePath(t *testing.T) {
 	repo := &stubRepo{descriptionOverride: "stored override desc", overrideGroupKey: "hdb"}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath:          "",
 		DescriptionOverride: "legacy override desc",
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
@@ -930,7 +1064,7 @@ func TestResolveDescriptionAssetsUsesCanonicalGroupDescriptionWithoutSourcePath(
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -951,7 +1085,7 @@ func TestResolveDescriptionAssetsIgnoresAmbiguousTrackerGroupFallback(t *testing
 		overrideGroupKey:    "hdb",
 		trackerRecords:      []api.TrackerMetadata{{Tracker: "HDB", Description: "db desc"}},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		DescriptionGroups: []api.DescriptionBuilderGroup{
 			{
@@ -967,7 +1101,7 @@ func TestResolveDescriptionAssetsIgnoresAmbiguousTrackerGroupFallback(t *testing
 		},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -984,9 +1118,9 @@ func TestResolveDescriptionAssetsStripsEmbeddedNFOBlocksFromOverride(t *testing.
 		descriptionOverride: "[center][spoiler=Scene NFO:][code]scene nfo[/code][/spoiler][/center]\n\nCustom body",
 		overrideGroupKey:    "ant",
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "ANT", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "ANT", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1001,18 +1135,41 @@ func TestResolveDescriptionAssetsStripsEmbeddedNFOBlocksFromOverride(t *testing.
 func TestResolveDescriptionAssetsSelectsMostCommonHost(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb.com/a.png"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", ImgURL: "https://imgbb.com/b.png"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost.to/a.png"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb.com/a.png",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb.com/b.png",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost.to/a.png",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1034,9 +1191,9 @@ func TestResolveDescriptionAssetsFallbackTrackerImages(t *testing.T) {
 			ImageURLs: []string{"https://imgbb.com/a.png", "https://imgbb.com/b.png", "https://pixhost.to/c.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1055,9 +1212,9 @@ func TestResolveDescriptionAssetsSkipsTrackerImagesWhenNotKeepingImages(t *testi
 			ImageURLs: []string{"https://imgbb.com/a.png", "https://imgbb.com/b.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1081,9 +1238,9 @@ func TestResolveDescriptionAssetsSkipsStoredTrackerSlotsWhenNotKeepingImages(t *
 			RenderInScreenshots: true,
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1099,9 +1256,9 @@ func TestResolveDescriptionAssetsSkipsTMDBTrackerImages(t *testing.T) {
 			ImageURLs: []string{"https://image.tmdb.org/t/p/original/poster.jpg", "https://imgbb.com/a.png", "https://imgbb.com/b.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1119,9 +1276,9 @@ func TestResolveDescriptionAssetsFallbackOtherTrackerDescription(t *testing.T) {
 	repo := &stubRepo{
 		trackerRecords: []api.TrackerMetadata{{Tracker: "ULCX", Description: "ulcx desc"}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1136,9 +1293,9 @@ func TestResolveDescriptionAssetsFallbackSanitizesByRecordTracker(t *testing.T)
 			{Tracker: "ANT", Description: "[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]\n\nBody"},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1154,9 +1311,9 @@ func TestResolveDescriptionAssetsPrefersMatchingTrackerDescription(t *testing.T)
 			{Tracker: "AITHER", Description: "[center]unit3d[/center]"},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1171,9 +1328,9 @@ func TestResolveDescriptionAssetsStripsEmbeddedNFOBlocksFromTrackerDescriptions(
 			{Tracker: "ANT", Description: "[hide=FraMeSToR NFO:][pre]frame nfo[/pre][/hide]\n\nTracker body"},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "ANT", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "ANT", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1185,23 +1342,10 @@ func TestResolveDescriptionAssetsStripsEmbeddedNFOBlocksFromTrackerDescriptions(
 	}
 }
 
-func TestResolveDescriptionAssetsStripsDefaultSignatureForANT(t *testing.T) {
-	repo := &stubRepo{
-		trackerRecords: []api.TrackerMetadata{
-			{Tracker: "ANT", Description: "[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]\n\nBody"},
-		},
-	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
-
-	assets, err := ResolveDescriptionAssets(context.Background(), "ANT", meta, repo, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(assets.Description, "upbrr") {
-		t.Fatalf("expected default signature removed for ANT, got %q", assets.Description)
-	}
-	if assets.Description != "Body" {
-		t.Fatalf("expected cleaned ANT description, got %q", assets.Description)
+func TestStripDefaultDescriptionSignature(t *testing.T) {
+	value := "[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]\n\nBody"
+	if got := StripDefaultDescriptionSignature(value); got != "Body" {
+		t.Fatalf("cleaned description = %q", got)
 	}
 }
 
@@ -1211,9 +1355,9 @@ func TestResolveDescriptionAssetsStripsDefaultSignatureForNBL(t *testing.T) {
 			{Tracker: "NBL", Description: "[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]\n\nBody"},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "NBL", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "NBL", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1247,9 +1391,9 @@ func TestResolveDescriptionAssetsStripsKnownBotSignaturesFromTrackerDescriptions
 			}, "\n")},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1276,7 +1420,7 @@ func TestSanitizeTrackerDescriptionKeepsMalformedUNIT3DBoldTags(t *testing.T) {
 }
 
 func TestResolveDescriptionAssetsStripsKnownBotSignaturesFromDescriptionGroups(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DescriptionGroups: []api.DescriptionBuilderGroup{{
 			GroupKey: "unit3d",
 			Trackers: []string{"AITHER"},
@@ -1288,7 +1432,7 @@ func TestResolveDescriptionAssetsStripsKnownBotSignaturesFromDescriptionGroups(t
 		}},
 	}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, nil, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, nil, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1304,9 +1448,9 @@ func TestResolveDescriptionAssetsFallbackOtherTrackerImages(t *testing.T) {
 			ImageURLs: []string{"https://imgbb.com/a.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1321,19 +1465,59 @@ func TestResolveDescriptionAssetsFallbackOtherTrackerImages(t *testing.T) {
 func TestResolveDescriptionAssetsIgnoresTrackerScopedUploadsForOtherTrackers(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/a.png", RawURL: "https://hdb/a.png", WebURL: "https://hdb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/b.png", RawURL: "https://hdb/b.png", WebURL: "https://hdb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/a.png",
+				RawURL:     "https://hdb/a.png",
+				WebURL:     "https://hdb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/b.png",
+				RawURL:     "https://hdb/b.png",
+				WebURL:     "https://hdb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1350,19 +1534,59 @@ func TestResolveDescriptionAssetsIgnoresTrackerScopedUploadsForOtherTrackers(t *
 func TestResolveDescriptionAssetsPrefersTrackerScopedUploadsForMatchingTracker(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/a.png", RawURL: "https://hdb/a.png", WebURL: "https://hdb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/b.png", RawURL: "https://hdb/b.png", WebURL: "https://hdb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/a.png",
+				RawURL:     "https://hdb/a.png",
+				WebURL:     "https://hdb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/b.png",
+				RawURL:     "https://hdb/b.png",
+				WebURL:     "https://hdb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "HDB", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1376,7 +1600,7 @@ func TestResolveDescriptionAssetsPrefersTrackerScopedUploadsForMatchingTracker(t
 	}
 }
 
-func TestResolveDescriptionAssetsDegradesGracefullyOnScreenshotReadFailure(t *testing.T) {
+func TestResolveDescriptionAssetsFailsOnScreenshotReadFailure(t *testing.T) {
 	repo := &stubRepo{
 		selectionsErr: errors.New("database is locked"),
 		trackerRecords: []api.TrackerMetadata{{
@@ -1384,42 +1608,48 @@ func TestResolveDescriptionAssetsDegradesGracefullyOnScreenshotReadFailure(t *te
 			ImageURLs: []string{"https://imgbb.com/a.png", "https://imgbb.com/b.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("expected graceful degradation, got %v", err)
-	}
-	if len(assets.Screenshots) != 2 {
-		t.Fatalf("expected tracker url fallback screenshots, got %d", len(assets.Screenshots))
+	_, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
+	if err == nil || !strings.Contains(err.Error(), "database is locked") {
+		t.Fatalf("expected screenshot read failure, got %v", err)
 	}
 }
 
-func TestResolveDescriptionAssetsDegradesGracefullyOnSelectedUploadMismatch(t *testing.T) {
+func TestResolveDescriptionAssetsFailsOnSelectedUploadMismatch(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb.com/a.png", RawURL: "https://imgbb.com/a.png", WebURL: "https://imgbb.com/a"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb.com/a.png",
+				RawURL:     "https://imgbb.com/a.png",
+				WebURL:     "https://imgbb.com/a",
+			},
 		},
 		trackerRecords: []api.TrackerMetadata{{
 			Tracker:   "AITHER",
 			ImageURLs: []string{"https://pixhost.to/fallback-a.png", "https://pixhost.to/fallback-b.png"},
 		}},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
+	meta := api.UploadSubject{SourcePath: "/tmp/source", Options: api.UploadOptions{KeepImages: true}}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("expected graceful degradation, got %v", err)
-	}
-	if len(assets.Screenshots) != 2 {
-		t.Fatalf("expected tracker url fallback screenshots, got %d", len(assets.Screenshots))
-	}
-	if assets.Screenshots[0].ImgURL != "https://pixhost.to/fallback-a.png" {
-		t.Fatalf("expected fallback screenshot urls, got %#v", assets.Screenshots)
+	_, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
+	if err == nil || !strings.Contains(err.Error(), "missing screenshot variant for slot 1") {
+		t.Fatalf("expected selected upload mismatch, got %v", err)
 	}
 }
 
@@ -1432,9 +1662,9 @@ Some text
 `),
 		overrideGroupKey: "unit3d",
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1461,13 +1691,21 @@ func TestResolveDescriptionAssetsLimitsDescriptionSlotsToSelectedImages(t *testi
 `),
 		overrideGroupKey: "unit3d",
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/first-local.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/second-local.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/first-local.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/second-local.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "AITHER", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1503,9 +1741,21 @@ https://lostimg.cc/extra.png
 		slots[idx].ImagePath = fmt.Sprintf("/tmp/comparison-%d.png", idx)
 	}
 	rewritten := rewriteDescriptionSlotURLs(description, slots, []api.ScreenshotImage{
-		{Path: "/tmp/comparison-0.png", Host: "pixhost", RawURL: "https://pixhost.to/show/source.png"},
-		{Path: "/tmp/comparison-1.png", Host: "pixhost", RawURL: "https://pixhost.to/show/encode.png"},
-		{Path: "/tmp/comparison-2.png", Host: "pixhost", RawURL: "https://pixhost.to/show/extra.png"},
+		{
+			Path:   "/tmp/comparison-0.png",
+			Host:   "pixhost",
+			RawURL: "https://pixhost.to/show/source.png",
+		},
+		{
+			Path:   "/tmp/comparison-1.png",
+			Host:   "pixhost",
+			RawURL: "https://pixhost.to/show/encode.png",
+		},
+		{
+			Path:   "/tmp/comparison-2.png",
+			Host:   "pixhost",
+			RawURL: "https://pixhost.to/show/extra.png",
+		},
 	}, false)
 
 	if strings.Contains(rewritten, "lostimg.cc") {
@@ -1536,7 +1786,7 @@ https://lostimg.cc/encode.png
 	slots := parseDescriptionImageSlots("/tmp/source", description)
 	appendSourceImageSlots(&slots, "/tmp/source", []api.ScreenshotImage{{Path: "/tmp/encode_01.png"}})
 	assets := DescriptionAssets{Description: description, Slots: slots}
-	applyResolvedDescriptionScreenshots(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, nil, nil, &assets, []api.ScreenshotImage{
+	applyResolvedDescriptionScreenshots(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"}, nil, nil, &assets, []api.ScreenshotImage{
 		{Path: "/tmp/source-copy.png", RawURL: "https://pixhost/source.png"},
 		{Path: "/tmp/encode_01.png", RawURL: "https://pixhost/encode-comparison.png"},
 		{Path: "/tmp/encode_01.png", RawURL: "https://pixhost/encode-normal.png"},
@@ -1621,8 +1871,24 @@ func TestApplyUploadedVariantsToSlotsUsesOrderedFallbackForURLOnlySlots(t *testi
 		},
 	}
 	uploads := []api.UploadedImageLink{
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/first-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/first.jpg", RawURL: "https://img.hdbits.org/first.jpg", WebURL: "https://img.hdbits.org/first"},
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/second-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/second.jpg", RawURL: "https://img.hdbits.org/second.jpg", WebURL: "https://img.hdbits.org/second"},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/first-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/first.jpg",
+			RawURL:     "https://img.hdbits.org/first.jpg",
+			WebURL:     "https://img.hdbits.org/first",
+		},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/second-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/second.jpg",
+			RawURL:     "https://img.hdbits.org/second.jpg",
+			WebURL:     "https://img.hdbits.org/second",
+		},
 	}
 
 	summary := ApplyUploadedVariantsToSlots(slots, uploads)
@@ -1661,8 +1927,24 @@ func TestApplyUploadedVariantsToSlotsPrefersDirectPathMatches(t *testing.T) {
 		},
 	}
 	uploads := []api.UploadedImageLink{
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/first-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/first.jpg", RawURL: "https://img.hdbits.org/first.jpg", WebURL: "https://img.hdbits.org/first"},
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/second-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/second.jpg", RawURL: "https://img.hdbits.org/second.jpg", WebURL: "https://img.hdbits.org/second"},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/first-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/first.jpg",
+			RawURL:     "https://img.hdbits.org/first.jpg",
+			WebURL:     "https://img.hdbits.org/first",
+		},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/second-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/second.jpg",
+			RawURL:     "https://img.hdbits.org/second.jpg",
+			WebURL:     "https://img.hdbits.org/second",
+		},
 	}
 
 	summary := ApplyUploadedVariantsToSlots(slots, uploads)
@@ -1695,7 +1977,15 @@ func TestApplyUploadedVariantsToSlotsAppliesDuplicatePathToAllSlots(t *testing.T
 		},
 	}
 	uploads := []api.UploadedImageLink{
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/encode.png", Host: "pixhost", UsageScope: "global", RawURL: "https://pixhost/encode.png", ImgURL: "https://pixhost/encode.png", WebURL: "https://pixhost/view"},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/encode.png",
+			Host:       "pixhost",
+			UsageScope: "global",
+			RawURL:     "https://pixhost/encode.png",
+			ImgURL:     "https://pixhost/encode.png",
+			WebURL:     "https://pixhost/view",
+		},
 	}
 
 	summary := ApplyUploadedVariantsToSlots(slots, uploads)
@@ -1738,8 +2028,24 @@ func TestApplyUploadedVariantsToSlotsSkipsNonRenderableSlotsDuringFallback(t *te
 		},
 	}
 	uploads := []api.UploadedImageLink{
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/first-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/first.jpg", RawURL: "https://img.hdbits.org/first.jpg", WebURL: "https://img.hdbits.org/first"},
-		{SourcePath: "/tmp/source", ImagePath: "/tmp/second-local.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/second.jpg", RawURL: "https://img.hdbits.org/second.jpg", WebURL: "https://img.hdbits.org/second"},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/first-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/first.jpg",
+			RawURL:     "https://img.hdbits.org/first.jpg",
+			WebURL:     "https://img.hdbits.org/first",
+		},
+		{
+			SourcePath: "/tmp/source",
+			ImagePath:  "/tmp/second-local.png",
+			Host:       "hdb",
+			UsageScope: "tracker:HDB",
+			ImgURL:     "https://t.hdbits.org/second.jpg",
+			RawURL:     "https://img.hdbits.org/second.jpg",
+			WebURL:     "https://img.hdbits.org/second",
+		},
 	}
 
 	summary := ApplyUploadedVariantsToSlots(slots, uploads)
@@ -1769,19 +2075,55 @@ func TestResolveTrackerScreenshotsReturnsNilWhenHostsAreInvalid(t *testing.T) {
 func TestEnsureDescriptionImageHostReusesAllowedHost(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost/a.png", RawURL: "https://pixhost/a.png", WebURL: "https://pixhost/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "pixhost", ImgURL: "https://pixhost/b.png", RawURL: "https://pixhost/b.png", WebURL: "https://pixhost/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/a.png",
+				RawURL:     "https://pixhost/a.png",
+				WebURL:     "https://pixhost/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/b.png",
+				RawURL:     "https://pixhost/b.png",
+				WebURL:     "https://pixhost/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, nil, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, nil, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1796,7 +2138,7 @@ func TestEnsureDescriptionImageHostReusesAllowedHost(t *testing.T) {
 func TestEnsureDescriptionImageHostReusesUploadedRecordsBeforeUploading(t *testing.T) {
 	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
 	dbPath := filepath.Join(t.TempDir(), "db.sqlite")
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: sourcePath,
 		TrackerData: []api.TrackerMetadata{{
 			Tracker:   "HHD",
@@ -1807,7 +2149,7 @@ func TestEnsureDescriptionImageHostReusesUploadedRecordsBeforeUploading(t *testi
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	releaseDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, sourcePath)
+	releaseDir, _, err := paths.ReleaseTempDirFor(tmpRoot, sourcePath, meta.Release)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -1823,13 +2165,29 @@ func TestEnsureDescriptionImageHostReusesUploadedRecordsBeforeUploading(t *testi
 	}
 	repo := &stubRepo{
 		uploads: []api.UploadedImageLink{
-			{SourcePath: sourcePath, ImagePath: firstPath, Host: "pixhost", UsageScope: "global", ImgURL: "https://pixhost/1.png", RawURL: "https://pixhost/raw1.png", WebURL: "https://pixhost/view1"},
-			{SourcePath: sourcePath, ImagePath: secondPath, Host: "pixhost", UsageScope: "global", ImgURL: "https://pixhost/2.png", RawURL: "https://pixhost/raw2.png", WebURL: "https://pixhost/view2"},
+			{
+				SourcePath: sourcePath,
+				ImagePath:  firstPath,
+				Host:       "pixhost",
+				UsageScope: "global",
+				ImgURL:     "https://pixhost/1.png",
+				RawURL:     "https://pixhost/raw1.png",
+				WebURL:     "https://pixhost/view1",
+			},
+			{
+				SourcePath: sourcePath,
+				ImagePath:  secondPath,
+				Host:       "pixhost",
+				UsageScope: "global",
+				ImgURL:     "https://pixhost/2.png",
+				RawURL:     "https://pixhost/raw2.png",
+				WebURL:     "https://pixhost/view2",
+			},
 		},
 	}
 	images := &stubImageService{}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"HHD",
 		meta,
@@ -1837,7 +2195,7 @@ func TestEnsureDescriptionImageHostReusesUploadedRecordsBeforeUploading(t *testi
 		config.TrackerConfig{ImageHost: "pixhost"},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -1856,17 +2214,39 @@ func TestEnsureDescriptionImageHostReusesUploadedRecordsBeforeUploading(t *testi
 func TestEnsureDescriptionImageHostReuploadsForRequiredTracker(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, &stubImageService{}, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, &stubImageService{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1889,17 +2269,32 @@ func TestEnsureDescriptionImageHostReuploadsForRequiredTracker(t *testing.T) {
 func TestEnsureDescriptionImageHostReuploadsWhenAllowedHostCoverageIsPartial(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost/a.png", RawURL: "https://pixhost/a.png", WebURL: "https://pixhost/a"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/a.png",
+				RawURL:     "https://pixhost/a.png",
+				WebURL:     "https://pixhost/a",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, images, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, images, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1920,7 +2315,7 @@ func TestEnsureDescriptionImageHostReuploadsWhenAllowedHostCoverageIsPartial(t *
 func TestEnsureDescriptionImageHostAlignsDescriptionSlotsToLocalTrackerImages(t *testing.T) {
 	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
 	dbPath := filepath.Join(t.TempDir(), "db.sqlite")
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: sourcePath,
 		TrackerData: []api.TrackerMetadata{{
 			Tracker: "AITHER",
@@ -1937,7 +2332,7 @@ func TestEnsureDescriptionImageHostAlignsDescriptionSlotsToLocalTrackerImages(t
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	releaseDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, sourcePath)
+	releaseDir, _, err := paths.ReleaseTempDirFor(tmpRoot, sourcePath, meta.Release)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -1953,7 +2348,7 @@ func TestEnsureDescriptionImageHostAlignsDescriptionSlotsToLocalTrackerImages(t
 	repo := &stubRepo{}
 	images := &stubImageService{}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"PTP",
 		meta,
@@ -1961,7 +2356,7 @@ func TestEnsureDescriptionImageHostAlignsDescriptionSlotsToLocalTrackerImages(t
 		config.TrackerConfig{},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -1989,7 +2384,7 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 		imageBaseURL + "/encode.png",
 		imageBaseURL + "/other.png",
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: sourcePath,
 		TrackerData: []api.TrackerMetadata{{
 			Tracker: "AITHER",
@@ -2008,7 +2403,7 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	releaseDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, sourcePath)
+	releaseDir, _, err := paths.ReleaseTempDirFor(tmpRoot, sourcePath, meta.Release)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -2032,7 +2427,7 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 
 	repo := &stubRepo{}
 	images := &stubImageService{}
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"PTP",
 		meta,
@@ -2040,7 +2435,7 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 		config.TrackerConfig{},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -2056,7 +2451,7 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 	if !strings.Contains(resolution.screenshots[3].Path, "aither") {
 		t.Fatalf("expected normal screenshot to use extracted tracker image, got %#v", resolution.screenshots[3])
 	}
-	assets, err := ResolveDescriptionAssets(context.Background(), "PTP", meta, repo, api.NopLogger{})
+	assets, err := ResolveDescriptionAssets(context.Background(), "PTP", meta, repo, api.NopLogger{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("resolve assets: %v", err)
 	}
@@ -2084,16 +2479,24 @@ func TestEnsureDescriptionImageHostRehostsComparisonAndKeepsMatchedDescriptionIm
 func TestEnsureDescriptionImageHostFallsBackAfterConfiguredHostFailure(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{
 		errs: map[string]error{"onlyimage": errors.New("onlyimage unavailable")},
 	}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"OE",
 		meta,
@@ -2101,7 +2504,7 @@ func TestEnsureDescriptionImageHostFallsBackAfterConfiguredHostFailure(t *testin
 		config.TrackerConfig{ImageHost: "onlyimage"},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -2123,16 +2526,24 @@ func TestEnsureDescriptionImageHostFallsBackAfterConfiguredHostFailure(t *testin
 func TestEnsureDescriptionImageHostFallsBackFromConfiguredHostForUnrestrictedTracker(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{
 		errs: map[string]error{"pixhost": errors.New("pixhost unavailable")},
 	}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"HHD",
 		meta,
@@ -2140,7 +2551,7 @@ func TestEnsureDescriptionImageHostFallsBackFromConfiguredHostForUnrestrictedTra
 		config.TrackerConfig{ImageHost: "pixhost"},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -2165,14 +2576,22 @@ func TestEnsureDescriptionImageHostFallsBackFromConfiguredHostForUnrestrictedTra
 func TestEnsureDescriptionImageHostUploadsPreferredHostForUnrestrictedTracker(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{}
 
-	resolution, err := ensureDescriptionImageHostWithData(
+	resolution, err := ensureDescriptionImageHostWithDataAndRegistry(
 		context.Background(),
 		"RHD",
 		meta,
@@ -2181,6 +2600,7 @@ func TestEnsureDescriptionImageHostUploadsPreferredHostForUnrestrictedTracker(t
 		repo,
 		images,
 		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 		nil,
 		"imgbb",
 	)
@@ -2209,18 +2629,26 @@ func TestEnsureDescriptionImageHostUploadsPreferredHostForUnrestrictedTracker(t
 func TestEnsureDescriptionImageHostBlocksWhenAllUploadHostsFail(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{
 		errs: map[string]error{
 			"pixhost": errors.New("pixhost unavailable"),
 		},
 	}
 
-	resolution, err := ensureDescriptionImageHost(
+	resolution, err := ensureDescriptionImageHostWithRegistry(
 		context.Background(),
 		"PTP",
 		meta,
@@ -2228,7 +2656,7 @@ func TestEnsureDescriptionImageHostBlocksWhenAllUploadHostsFail(t *testing.T) {
 		config.TrackerConfig{},
 		repo,
 		images,
-		api.NopLogger{},
+		descriptionAssetsTestRegistry(t),
 	)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -2251,24 +2679,60 @@ func TestEnsureDescriptionImageHostUsesPreferredOverrideWhenAllowed(t *testing.T
 	preferredHost := "imgbb"
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost/a.png", RawURL: "https://pixhost/a.png", WebURL: "https://pixhost/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "pixhost", ImgURL: "https://pixhost/b.png", RawURL: "https://pixhost/b.png", WebURL: "https://pixhost/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/a.png",
+				RawURL:     "https://pixhost/a.png",
+				WebURL:     "https://pixhost/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/b.png",
+				RawURL:     "https://pixhost/b.png",
+				WebURL:     "https://pixhost/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		ImageHostOverrides: api.ImageHostOverrides{
 			PreferredHost: &preferredHost,
 		},
 	}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "OE", meta, config.Config{}, config.TrackerConfig{}, repo, nil, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "OE", meta, config.Config{}, config.TrackerConfig{}, repo, nil, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2280,19 +2744,59 @@ func TestEnsureDescriptionImageHostUsesPreferredOverrideWhenAllowed(t *testing.T
 func TestEnsureDescriptionImageHostReusesGlobalUploadsInsteadOfOtherTrackerScope(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/a.png", RawURL: "https://hdb/a.png", WebURL: "https://hdb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/b.png", RawURL: "https://hdb/b.png", WebURL: "https://hdb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/a.png",
+				RawURL:     "https://hdb/a.png",
+				WebURL:     "https://hdb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/b.png",
+				RawURL:     "https://hdb/b.png",
+				WebURL:     "https://hdb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "OE", meta, config.Config{}, config.TrackerConfig{}, repo, nil, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "OE", meta, config.Config{}, config.TrackerConfig{}, repo, nil, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2310,22 +2814,44 @@ func TestEnsureDescriptionImageHostSkipsAutomaticUploadWhenDisabled(t *testing.T
 	skipUpload := true
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: "/tmp/source",
 		ImageHostOverrides: api.ImageHostOverrides{
 			SkipUpload: &skipUpload,
 		},
 	}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, &stubImageService{}, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, &stubImageService{}, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2346,16 +2872,31 @@ func TestEnsureDescriptionImageHostSkipsAutomaticUploadWhenDisabled(t *testing.T
 func TestEnsureDescriptionImageHostWarnsOnPartialAllowedHostCoverageWithoutUploader(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost/a.png", RawURL: "https://pixhost/a.png", WebURL: "https://pixhost/a"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "pixhost",
+				ImgURL:     "https://pixhost/a.png",
+				RawURL:     "https://pixhost/a.png",
+				WebURL:     "https://pixhost/a",
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, nil, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, nil, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2370,20 +2911,35 @@ func TestEnsureDescriptionImageHostWarnsOnPartialAllowedHostCoverageWithoutUploa
 func TestEnsureDescriptionImageHostRollsBackUploadedImagesOnSelectionError(t *testing.T) {
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	meta := api.PreparedMetadata{SourcePath: "/tmp/source"}
+	meta := api.UploadSubject{SourcePath: "/tmp/source"}
 	images := &stubImageService{
 		uploads: map[string][]api.UploadedImageLink{
 			"pixhost": {
-				{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "pixhost", ImgURL: "https://pixhost/a.png", RawURL: "https://pixhost/a.png", WebURL: "https://pixhost/a"},
+				{
+					SourcePath: "/tmp/source",
+					ImagePath:  "/tmp/a.png",
+					Host:       "pixhost",
+					ImgURL:     "https://pixhost/a.png",
+					RawURL:     "https://pixhost/a.png",
+					WebURL:     "https://pixhost/a",
+				},
 			},
 		},
 	}
 
-	resolution, err := ensureDescriptionImageHost(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, images, api.NopLogger{})
+	resolution, err := ensureDescriptionImageHostWithRegistry(context.Background(), "PTP", meta, config.Config{}, config.TrackerConfig{}, repo, images, descriptionAssetsTestRegistry(t))
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
diff --git a/internal/trackers/dryrun.go b/internal/trackers/dryrun.go
deleted file mode 100644
index c740533a..00000000
--- a/internal/trackers/dryrun.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackers
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type UploadDryRunBuilder interface {
-	BuildUploadDryRun(ctx context.Context, req UploadRequest) (api.TrackerDryRunEntry, error)
-}
diff --git a/internal/trackers/dupe/assessment.go b/internal/trackers/dupe/assessment.go
new file mode 100644
index 00000000..9cc73c00
--- /dev/null
+++ b/internal/trackers/dupe/assessment.go
@@ -0,0 +1,429 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dupe
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"maps"
+	"slices"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Verdict is the upload decision derived from duplicate evidence and explicit authorization.
+type Verdict string
+
+const (
+	// VerdictClear permits upload because the resolved outcome contains no duplicate.
+	VerdictClear Verdict = "clear"
+	// VerdictBlocked prevents upload until an overrideable outcome is explicitly authorized.
+	VerdictBlocked Verdict = "blocked"
+	// VerdictOverridden permits upload after explicit authorization of a remote candidate.
+	VerdictOverridden Verdict = "overridden"
+	// VerdictWaived permits upload after explicit authorization of unresolved remote work.
+	VerdictWaived Verdict = "waived"
+)
+
+// AuthorizationKind identifies an explicit operator decision.
+type AuthorizationKind string
+
+const (
+	// AuthorizationNone indicates that no operator authorization is attached.
+	AuthorizationNone AuthorizationKind = ""
+	// AuthorizationOverride authorizes a resolved remote duplicate candidate.
+	AuthorizationOverride AuthorizationKind = "override"
+	// AuthorizationWaiver authorizes a not-run or failed remote duplicate check.
+	AuthorizationWaiver AuthorizationKind = "waiver"
+)
+
+type assessmentEntry struct {
+	tracker       string
+	binding       string
+	outcomeID     string
+	disposition   Disposition
+	code          string
+	hasDupes      bool
+	verdict       Verdict
+	authorization AuthorizationKind
+	match         api.DupeMatch
+	privateRaw    []api.DupeEntry
+}
+
+// Assessment is immutable reusable duplicate decision state. Full public outcomes are not retained.
+// assessed distinguishes an explicit empty check result from the zero value, which means no
+// assessment was supplied and therefore must not alter an existing metadata projection.
+type Assessment struct {
+	entries  map[string]assessmentEntry
+	assessed bool
+}
+
+// Decision is a defensive assessment projection for Core tracker planning.
+type Decision struct {
+	// Tracker is the normalized tracker identifier.
+	Tracker string
+	// Disposition records whether search resolved, did not run, or failed.
+	Disposition Disposition
+	// Code is the stable disposition reason code.
+	Code string
+	// Verdict is the current upload eligibility decision.
+	Verdict Verdict
+	// Authorization records the explicit operator decision, when present.
+	Authorization AuthorizationKind
+	// Match contains a defensive public projection of matched evidence.
+	Match api.DupeMatch
+}
+
+// AssessmentEvidence is one structural adapter outcome used to construct reusable decision state.
+type AssessmentEvidence struct {
+	// Tracker is the normalized tracker identifier.
+	Tracker string
+	// Disposition records whether the adapter resolved, did not run, or failed.
+	Disposition Disposition
+	// Code is the stable structural reason code.
+	Code string
+	// HasDupes reports whether filtering found a blocking candidate.
+	HasDupes bool
+	// Match contains the selected candidate evidence.
+	Match api.DupeMatch
+	// Raw contains private adapter evidence defensively copied into the assessment.
+	Raw []api.DupeEntry
+}
+
+// EmptyAssessment returns an assessment with no bound entries.
+func EmptyAssessment() Assessment { return Assessment{} }
+
+// NewAssessment binds structural adapter evidence to the current release and tracker configuration.
+func NewAssessment(meta api.DuplicateSubject, cfg config.Config, evidence []AssessmentEvidence) Assessment {
+	assessment := Assessment{entries: make(map[string]assessmentEntry, len(evidence)), assessed: true}
+	for _, item := range evidence {
+		tracker := normalizeTracker(item.Tracker)
+		if tracker == "" {
+			continue
+		}
+		disposition := item.Disposition
+		if disposition != DispositionResolved && disposition != DispositionNotRun && disposition != DispositionFailed {
+			disposition = DispositionFailed
+		}
+		assessment.entries[tracker] = newAssessmentEntry(meta, cfg, tracker, disposition, item.Code, item.HasDupes, item.Match, item.Raw)
+	}
+	return assessment
+}
+
+// IsEmpty reports whether no tracker decisions are bound.
+func (a Assessment) IsEmpty() bool { return len(a.entries) == 0 }
+
+// Clone returns an independent immutable assessment value.
+func (a Assessment) Clone() Assessment {
+	if len(a.entries) == 0 && !a.assessed {
+		return Assessment{}
+	}
+	out := Assessment{entries: make(map[string]assessmentEntry, len(a.entries)), assessed: a.assessed}
+	for tracker, entry := range a.entries {
+		out.entries[tracker] = cloneAssessmentEntry(entry)
+	}
+	return out
+}
+
+// Merge replaces selected tracker entries represented by delta, clearing prior authorization for rechecked trackers.
+// Missing delta entries preserve prior state; a completed structural check represents a clear result with an entry.
+func (a Assessment) Merge(delta Assessment, selected []string) Assessment {
+	out := a.Clone()
+	out.assessed = out.assessed || delta.assessed || len(selected) > 0
+	if out.entries == nil {
+		out.entries = make(map[string]assessmentEntry)
+	}
+	for _, tracker := range dedupeTrackers(selected) {
+		entry, ok := delta.entries[tracker]
+		if !ok {
+			continue
+		}
+		entry.authorization = AuthorizationNone
+		entry.verdict = defaultVerdict(entry)
+		out.entries[tracker] = cloneAssessmentEntry(entry)
+	}
+	return out
+}
+
+// RetainValid drops entries whose Prepared release or effective tracker config binding changed.
+func (a Assessment) RetainValid(meta api.DuplicateSubject, cfg config.Config) Assessment {
+	out := Assessment{entries: make(map[string]assessmentEntry), assessed: a.assessed}
+	for tracker, entry := range a.entries {
+		if entry.binding != assessmentBinding(meta, tracker, effectiveTrackerConfig(cfg, tracker)) {
+			continue
+		}
+		out.entries[tracker] = cloneAssessmentEntry(entry)
+	}
+	if len(out.entries) == 0 && !out.assessed {
+		return Assessment{}
+	}
+	return out
+}
+
+// Authorize validates and binds explicit overrides/waivers to current outcomes.
+func (a Assessment) Authorize(meta api.DuplicateSubject, cfg config.Config, trackerNames []string) (Assessment, error) {
+	out := a.Clone()
+	for _, tracker := range dedupeTrackers(trackerNames) {
+		entry, ok := out.entries[tracker]
+		if !ok {
+			return Assessment{}, fmt.Errorf("duplicate authorization rejected: tracker %s has no current assessment", tracker)
+		}
+		if entry.binding != assessmentBinding(meta, tracker, effectiveTrackerConfig(cfg, tracker)) {
+			return Assessment{}, fmt.Errorf("duplicate authorization rejected: tracker %s assessment is stale", tracker)
+		}
+		switch {
+		case entry.disposition == DispositionResolved && entry.match.MatchedReason == "in_client":
+			return Assessment{}, fmt.Errorf("duplicate authorization rejected: tracker %s is already in client", tracker)
+		case entry.disposition == DispositionResolved && entry.verdict == VerdictBlocked:
+			entry.authorization = AuthorizationOverride
+			entry.verdict = VerdictOverridden
+		case entry.disposition == DispositionNotRun || entry.disposition == DispositionFailed:
+			entry.authorization = AuthorizationWaiver
+			entry.verdict = VerdictWaived
+		default:
+			return Assessment{}, fmt.Errorf("duplicate authorization rejected: tracker %s outcome is not overrideable", tracker)
+		}
+		out.entries[tracker] = entry
+	}
+	return out, nil
+}
+
+// Decision returns one defensive tracker decision.
+func (a Assessment) Decision(tracker string) (Decision, bool) {
+	entry, ok := a.entries[normalizeTracker(tracker)]
+	if !ok {
+		return Decision{}, false
+	}
+	return Decision{
+		Tracker:       entry.tracker,
+		Disposition:   entry.disposition,
+		Code:          entry.code,
+		Verdict:       entry.verdict,
+		Authorization: entry.authorization,
+		Match:         clonePrivateMatch(entry.match),
+	}, true
+}
+
+// Apply projects current decisions into the duplicate subject's block/cross-seed fields.
+func (a Assessment) Apply(meta *api.DuplicateSubject) {
+	if meta == nil || !a.assessed || len(a.entries) == 0 {
+		return
+	}
+	blocked := removeDupeBlocks(meta.BlockedTrackers)
+	crossSeeds := make([]api.UploadedTorrent, 0)
+	for _, tracker := range sortedAssessmentTrackers(a.entries) {
+		entry := a.entries[tracker]
+		if entry.verdict == VerdictBlocked {
+			blocked = addDupeBlock(blocked, tracker)
+		}
+		if entry.disposition != DispositionResolved || entry.match.MatchedReason == "in_client" || entry.authorization == AuthorizationOverride {
+			continue
+		}
+		download := strings.TrimSpace(entry.match.MatchedDownload)
+		if download == "" {
+			continue
+		}
+		crossSeeds = append(crossSeeds, api.UploadedTorrent{
+			Tracker:     tracker,
+			TorrentID:   strings.TrimSpace(entry.match.MatchedID),
+			DownloadURL: download,
+			TorrentURL:  strings.TrimSpace(entry.match.MatchedLink),
+		})
+	}
+	meta.BlockedTrackers = blocked
+	meta.CrossSeedTorrents = crossSeeds
+}
+
+func newAssessmentEntry(
+	meta api.DuplicateSubject,
+	cfg config.Config,
+	tracker string,
+	disposition Disposition,
+	code string,
+	hasDupes bool,
+	match api.DupeMatch,
+	raw []api.DupeEntry,
+) assessmentEntry {
+	entry := assessmentEntry{
+		tracker:     normalizeTracker(tracker),
+		disposition: disposition,
+		code:        strings.TrimSpace(code),
+		hasDupes:    hasDupes,
+		match:       clonePrivateMatch(match),
+		privateRaw:  cloneEntries(raw),
+	}
+	entry.binding = assessmentBinding(meta, entry.tracker, effectiveTrackerConfig(cfg, entry.tracker))
+	entry.outcomeID = outcomeIdentity(entry)
+	entry.verdict = defaultVerdict(entry)
+	return entry
+}
+
+func defaultVerdict(entry assessmentEntry) Verdict {
+	if entry.disposition == DispositionResolved && !entry.hasDupes && entry.match.MatchedReason != "in_client" {
+		return VerdictClear
+	}
+	return VerdictBlocked
+}
+
+func assessmentBinding(meta api.DuplicateSubject, tracker string, trackerConfig config.TrackerConfig) string {
+	bound := struct {
+		SourcePath           string
+		SourceSize           int64
+		VideoPath            string
+		FileList             []string
+		Filename             string
+		SceneName            string
+		ReleaseName          string
+		Release              api.ReleaseInfo
+		ReleaseNameOverrides api.ReleaseNameOverrides
+		Identity             api.ExternalIdentity
+		ProviderMetadata     api.SourceScopedMetadata
+		TrackerIDs           map[string]string
+		DiscType             string
+		Type                 string
+		Source               string
+		Tag                  string
+		HDR                  string
+		UHD                  string
+		VideoEncode          string
+		SeasonInt            int
+		EpisodeInt           int
+		SeasonStr            string
+		EpisodeStr           string
+		TVPack               bool
+		Anime                bool
+		InClient             bool
+		RuleFailures         []api.RuleFailure
+		Tracker              string
+		Config               config.TrackerConfig
+	}{
+		SourcePath:           strings.TrimSpace(meta.SourcePath),
+		SourceSize:           meta.SourceSize,
+		VideoPath:            strings.TrimSpace(meta.VideoPath),
+		FileList:             append([]string(nil), meta.FileList...),
+		Filename:             strings.TrimSpace(meta.Filename),
+		SceneName:            strings.TrimSpace(meta.SceneName),
+		ReleaseName:          strings.TrimSpace(meta.ReleaseName),
+		Release:              meta.Release,
+		ReleaseNameOverrides: meta.ReleaseNameOverrides,
+		Identity:             meta.Identity,
+		ProviderMetadata:     meta.ProviderMetadata,
+		TrackerIDs:           cloneStringMap(meta.TrackerIDs),
+		DiscType:             strings.TrimSpace(meta.DiscType),
+		Type:                 strings.TrimSpace(meta.Type),
+		Source:               strings.TrimSpace(meta.Source),
+		Tag:                  strings.TrimSpace(meta.Tag),
+		HDR:                  strings.TrimSpace(meta.HDR),
+		UHD:                  strings.TrimSpace(meta.UHD),
+		VideoEncode:          strings.TrimSpace(meta.VideoEncode),
+		SeasonInt:            meta.SeasonInt,
+		EpisodeInt:           meta.EpisodeInt,
+		SeasonStr:            strings.TrimSpace(meta.SeasonStr),
+		EpisodeStr:           strings.TrimSpace(meta.EpisodeStr),
+		TVPack:               meta.TVPack,
+		Anime:                meta.Anime,
+		InClient:             containsTracker(meta.MatchedTrackers, tracker),
+		RuleFailures:         append([]api.RuleFailure(nil), trackerRuleFailures(meta, tracker)...),
+		Tracker:              normalizeTracker(tracker),
+		Config:               trackerConfig,
+	}
+	encoded, err := json.Marshal(bound)
+	if err != nil {
+		return ""
+	}
+	sum := sha256.Sum256(encoded)
+	return hex.EncodeToString(sum[:])
+}
+
+func cloneStringMap(input map[string]string) map[string]string {
+	if len(input) == 0 {
+		return nil
+	}
+	out := make(map[string]string, len(input))
+	maps.Copy(out, input)
+	return out
+}
+
+func trackerRuleFailures(meta api.DuplicateSubject, tracker string) []api.RuleFailure {
+	for name, failures := range meta.TrackerRuleFailures {
+		if strings.EqualFold(strings.TrimSpace(name), strings.TrimSpace(tracker)) {
+			return failures
+		}
+	}
+	return nil
+}
+
+func outcomeIdentity(entry assessmentEntry) string {
+	bound := struct {
+		Disposition Disposition
+		Code        string
+		HasDupes    bool
+		Match       api.DupeMatch
+		Raw         []api.DupeEntry
+	}{entry.disposition, entry.code, entry.hasDupes, entry.match, entry.privateRaw}
+	encoded, err := json.Marshal(bound)
+	if err != nil {
+		return ""
+	}
+	sum := sha256.Sum256(encoded)
+	return hex.EncodeToString(sum[:])
+}
+
+func cloneAssessmentEntry(entry assessmentEntry) assessmentEntry {
+	entry.match = clonePrivateMatch(entry.match)
+	entry.privateRaw = cloneEntries(entry.privateRaw)
+	return entry
+}
+
+func clonePrivateMatch(match api.DupeMatch) api.DupeMatch {
+	match.MatchedEpisodeIDs = append([]api.DupeEpisodeMatch(nil), match.MatchedEpisodeIDs...)
+	return match
+}
+
+func removeDupeBlocks(input map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
+	out := make(map[string][]api.TrackerBlockReason, len(input))
+	for tracker, reasons := range input {
+		for _, reason := range reasons {
+			if reason != api.TrackerBlockReasonDupe {
+				out[normalizeTracker(tracker)] = append(out[normalizeTracker(tracker)], reason)
+			}
+		}
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func addDupeBlock(blocked map[string][]api.TrackerBlockReason, tracker string) map[string][]api.TrackerBlockReason {
+	if blocked == nil {
+		blocked = make(map[string][]api.TrackerBlockReason)
+	}
+	if slices.Contains(blocked[tracker], api.TrackerBlockReasonDupe) {
+		return blocked
+	}
+	blocked[tracker] = append(blocked[tracker], api.TrackerBlockReasonDupe)
+	return blocked
+}
+
+func sortedAssessmentTrackers(entries map[string]assessmentEntry) []string {
+	trackers := make([]string, 0, len(entries))
+	for tracker := range entries {
+		trackers = append(trackers, tracker)
+	}
+	sortStrings(trackers)
+	return trackers
+}
+
+func sortStrings(values []string) {
+	for index := 1; index < len(values); index++ {
+		for current := index; current > 0 && values[current] < values[current-1]; current-- {
+			values[current], values[current-1] = values[current-1], values[current]
+		}
+	}
+}
diff --git a/internal/trackers/dupe/assessment_test.go b/internal/trackers/dupe/assessment_test.go
new file mode 100644
index 00000000..89f5b126
--- /dev/null
+++ b/internal/trackers/dupe/assessment_test.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dupe
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestAssessmentSeparatesDispositionFromUploadVerdict(t *testing.T) {
+	t.Parallel()
+	meta := api.DuplicateSubject{SourcePath: "Example.Release.2026", ReleaseName: "Example.Release.2026.1080p-GRP"}
+	assessment := NewAssessment(meta, config.Config{}, []AssessmentEvidence{
+		{Tracker: "CLEAR", Disposition: DispositionResolved},
+		{
+			Tracker:     "CANDIDATE",
+			Disposition: DispositionResolved,
+			HasDupes:    true,
+			Match:       api.DupeMatch{MatchedReason: "remote_candidate"},
+		},
+		{
+			Tracker:     "CLIENT",
+			Disposition: DispositionResolved,
+			HasDupes:    true,
+			Match:       api.DupeMatch{MatchedReason: "in_client"},
+		},
+		{
+			Tracker:     "CLIENT_STRUCTURAL",
+			Disposition: DispositionResolved,
+			Match:       api.DupeMatch{MatchedReason: "in_client"},
+		},
+		{
+			Tracker:     "NOTRUN",
+			Disposition: DispositionNotRun,
+			Code:        NotRunMissingCredentials,
+		},
+		{
+			Tracker:     "FAILED",
+			Disposition: DispositionFailed,
+			Code:        FailureInternal,
+		},
+	})
+	want := map[string]Verdict{
+		"CLEAR":             VerdictClear,
+		"CANDIDATE":         VerdictBlocked,
+		"CLIENT":            VerdictBlocked,
+		"CLIENT_STRUCTURAL": VerdictBlocked,
+		"NOTRUN":            VerdictBlocked,
+		"FAILED":            VerdictBlocked,
+	}
+	for tracker, verdict := range want {
+		decision, ok := assessment.Decision(tracker)
+		if !ok || decision.Verdict != verdict {
+			t.Errorf("%s decision = %#v, %t; want %s", tracker, decision, ok, verdict)
+		}
+	}
+}
+
+func TestAssessmentAuthorizationIsOutcomeBoundAndInClientCannotBeOverridden(t *testing.T) {
+	t.Parallel()
+	meta := api.DuplicateSubject{SourcePath: "Example.Release.2026", ReleaseName: "Example.Release.2026.1080p-GRP"}
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"CANDIDATE": {APIKey: "candidate-key"},
+	}}}
+	assessment := NewAssessment(meta, cfg, []AssessmentEvidence{
+		{
+			Tracker:     "CANDIDATE",
+			Disposition: DispositionResolved,
+			HasDupes:    true,
+			Match:       api.DupeMatch{MatchedReason: "remote_candidate"},
+		},
+		{
+			Tracker:     "NOTRUN",
+			Disposition: DispositionNotRun,
+			Code:        NotRunMissingCredentials,
+		},
+		{
+			Tracker:     "CLIENT",
+			Disposition: DispositionResolved,
+			HasDupes:    true,
+			Match:       api.DupeMatch{MatchedReason: "in_client"},
+		},
+		{Tracker: "CLEAR", Disposition: DispositionResolved},
+	})
+	authorized, err := assessment.Authorize(meta, cfg, []string{"CANDIDATE", "NOTRUN"})
+	if err != nil {
+		t.Fatalf("authorize: %v", err)
+	}
+	for tracker, want := range map[string]Verdict{"CANDIDATE": VerdictOverridden, "NOTRUN": VerdictWaived} {
+		decision, _ := authorized.Decision(tracker)
+		if decision.Verdict != want {
+			t.Errorf("%s verdict = %s, want %s", tracker, decision.Verdict, want)
+		}
+	}
+	if _, err := assessment.Authorize(meta, cfg, []string{"CLIENT"}); err == nil {
+		t.Fatal("in-client authorization succeeded")
+	}
+	if _, err := assessment.Authorize(meta, cfg, []string{"CLEAR"}); err == nil {
+		t.Fatal("clear authorization succeeded")
+	}
+	changed := cfg
+	changed.Trackers.Trackers = map[string]config.TrackerConfig{"CANDIDATE": {APIKey: "changed-key"}}
+	if _, err := assessment.Authorize(meta, changed, []string{"CANDIDATE"}); err == nil {
+		t.Fatal("stale authorization succeeded")
+	}
+	inClientNow := meta
+	inClientNow.MatchedTrackers = []string{"CANDIDATE"}
+	if _, err := assessment.Authorize(inClientNow, cfg, []string{"CANDIDATE"}); err == nil {
+		t.Fatal("authorization survived a new in-client association")
+	}
+	presentationOnly := meta
+	presentationOnly.BlockedTrackers = map[string][]api.TrackerBlockReason{"OTHER": {api.TrackerBlockReasonClaim}}
+	if _, err := assessment.Authorize(presentationOnly, cfg, []string{"CANDIDATE"}); err != nil {
+		t.Fatalf("presentation-only change invalidated assessment: %v", err)
+	}
+}
+
+func TestClearAssessmentEntriesClearOwnedProjection(t *testing.T) {
+	t.Parallel()
+	meta := api.DuplicateSubject{
+		BlockedTrackers: map[string][]api.TrackerBlockReason{
+			"AITHER": {api.TrackerBlockReasonDupe, api.TrackerBlockReasonClaim},
+		},
+		CrossSeedTorrents: []api.UploadedTorrent{{Tracker: "AITHER", DownloadURL: "https://tracker.example/download?token=private"}},
+	}
+	NewAssessment(meta, config.Config{}, []AssessmentEvidence{{
+		Tracker:     "AITHER",
+		Disposition: DispositionResolved,
+	}}).Apply(&meta)
+	if !slices.Equal(meta.BlockedTrackers["AITHER"], []api.TrackerBlockReason{api.TrackerBlockReasonClaim}) {
+		t.Fatalf("owned dupe projection not cleared: %#v", meta.BlockedTrackers)
+	}
+	if len(meta.CrossSeedTorrents) != 0 {
+		t.Fatalf("owned cross-seed projection not cleared: %#v", meta.CrossSeedTorrents)
+	}
+}
+
+func TestAssessmentRetainValidAndApplyUseOnlyBoundPrivateState(t *testing.T) {
+	t.Parallel()
+	meta := api.DuplicateSubject{SourcePath: "Example.Release.2026", ReleaseName: "Example.Release.2026.1080p-GRP"}
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"AITHER": {APIKey: "aither-key"},
+		"BLU":    {APIKey: "blu-key"},
+	}}}
+	assessment := NewAssessment(meta, cfg, []AssessmentEvidence{
+		{
+			Tracker:     "AITHER",
+			Disposition: DispositionResolved,
+			HasDupes:    true,
+			Match: api.DupeMatch{
+				MatchedID:       "123",
+				MatchedLink:     "https://aither.example/torrents/123",
+				MatchedDownload: "https://aither.example/download/123?token=private",
+			},
+		},
+		{Tracker: "BLU", Disposition: DispositionResolved},
+	})
+	changed := cfg
+	changed.Trackers.Trackers = map[string]config.TrackerConfig{
+		"AITHER": {APIKey: "changed-key"},
+		"BLU":    {APIKey: "blu-key"},
+	}
+	retained := assessment.RetainValid(meta, changed)
+	if _, ok := retained.Decision("AITHER"); ok {
+		t.Fatal("changed tracker assessment retained")
+	}
+	if _, ok := retained.Decision("BLU"); !ok {
+		t.Fatal("unrelated tracker assessment dropped")
+	}
+
+	projected := meta
+	assessment.Apply(&projected)
+	if !slices.Contains(projected.BlockedTrackers["AITHER"], api.TrackerBlockReasonDupe) {
+		t.Fatalf("dupe block missing: %#v", projected.BlockedTrackers)
+	}
+	if len(projected.CrossSeedTorrents) != 1 || projected.CrossSeedTorrents[0].DownloadURL != "https://aither.example/download/123?token=private" {
+		t.Fatalf("private cross-seed evidence lost: %#v", projected.CrossSeedTorrents)
+	}
+}
diff --git a/internal/trackers/dupe/common.go b/internal/trackers/dupe/common.go
new file mode 100644
index 00000000..7fcae8a7
--- /dev/null
+++ b/internal/trackers/dupe/common.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dupe
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func normalizeTracker(tracker string) string {
+	return strings.ToUpper(strings.TrimSpace(tracker))
+}
+
+func trimEntries(entries []api.DupeEntry) []api.DupeEntry {
+	if len(entries) == 0 {
+		return nil
+	}
+	out := make([]api.DupeEntry, 0, len(entries))
+	for _, entry := range entries {
+		entry.Name = strings.TrimSpace(entry.Name)
+		entry.Link = strings.TrimSpace(entry.Link)
+		entry.Download = strings.TrimSpace(entry.Download)
+		entry.ID = strings.TrimSpace(entry.ID)
+		entry.Type = strings.TrimSpace(entry.Type)
+		entry.Res = strings.TrimSpace(entry.Res)
+		if entry.Name == "" {
+			continue
+		}
+		out = append(out, entry)
+	}
+	return out
+}
diff --git a/internal/dupechecking/filter.go b/internal/trackers/dupe/filter.go
similarity index 86%
rename from internal/dupechecking/filter.go
rename to internal/trackers/dupe/filter.go
index 9c40cc60..cd920c78 100644
--- a/internal/dupechecking/filter.go
+++ b/internal/trackers/dupe/filter.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package dupechecking
+package dupe
 
 import (
 	"os"
@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -19,8 +20,15 @@ var episodePattern = regexp.MustCompile(`(?i)[e](\d{1,3})`)
 var dailyEpisodePattern = regexp.MustCompile(`(?i)\b((?:19|20)\d{2})[.\-_/\s](\d{1,2})[.\-_/\s](\d{1,2})\b`)
 var otwEpisodePattern = regexp.MustCompile(`(?i)e\d{2}`)
 
-func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker string, _ config.Config, _ api.Logger) ([]api.DupeEntry, api.DupeMatch) {
+// FilterDupes applies tracker matching policy and returns candidates that remain
+// blocking plus accumulated first-match evidence.
+func FilterDupes(dupes []api.DupeEntry, meta api.DuplicateSubject, tracker string, _ config.Config, _ api.Logger) ([]api.DupeEntry, api.DupeMatch) {
+	return filterDupes(dupes, meta, tracker, nil)
+}
+
+func filterDupes(dupes []api.DupeEntry, meta api.DuplicateSubject, tracker string, registry *trackers.Registry) ([]api.DupeEntry, api.DupeMatch) {
 	match := api.DupeMatch{}
+	policy, _ := registry.LookupDupePolicy(tracker)
 	if len(dupes) == 0 {
 		return nil, match
 	}
@@ -85,14 +93,14 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			}
 		}
 
-		if (tracker == "AITHER" || tracker == "LST") && entry.Trumpable && entry.Res != "" && targetResolution == entry.Res {
+		if policy.TrackTrumpableID && entry.Trumpable && entry.Res != "" && targetResolution == entry.Res {
 			match.TrumpableID = entry.ID
 			rememberMatch("trumpable_id")
 		}
 
 		if !hasDisc {
 			for _, file := range filenames {
-				if tracker == "MTV" || tracker == "AR" || tracker == "RTF" {
+				if policy.ContainsFilenameMatch {
 					for _, dupeFile := range entry.Files {
 						if strings.Contains(strings.ToLower(file), strings.ToLower(dupeFile)) {
 							match.FilenameMatch = entry.Name
@@ -124,7 +132,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 					}
 				}
 			}
-			if tracker == "BHD" {
+			if policy.MatchAggregateSize {
 				if entry.SizeKnown && meta.SourceSize > 0 && entry.SizeBytes == meta.SourceSize {
 					match.SizeMatch = entry.Name
 					rememberMatch("size")
@@ -144,7 +152,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			return true
 		}
 
-		if tracker == "MTV" {
+		if policy.NormalizeMTVName {
 			targetName := strings.ReplaceAll(meta.ReleaseName, " ", ".")
 			targetName = strings.ReplaceAll(targetName, "DD+", "DDP")
 			dupeName := entry.Name
@@ -155,7 +163,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			}
 		}
 
-		if tracker == "BHD" {
+		if policy.NormalizeDDPlusName {
 			targetName := strings.ReplaceAll(meta.ReleaseName, "DD+", "DDP")
 			if entry.Name == targetName {
 				match.FilenameMatch = entry.Name
@@ -170,7 +178,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			return true
 		}
 
-		if isSD && (tracker == "BHD" || tracker == "AITHER") && containsResolution(each, []int{1080, 720, 2160}) {
+		if isSD && policy.SDMatchesHD && containsResolution(each, []int{1080, 720, 2160}) {
 			return false
 		}
 
@@ -178,7 +186,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			return false
 		}
 
-		if (tracker == "AITHER" || tracker == "LST") && isDVD {
+		if policy.MatchDVDReleaseGroup && isDVD {
 			if tag == "" {
 				return false
 			}
@@ -189,7 +197,8 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			if strings.Contains(normalized, "hdtv") && !containsAny(normalized, []string{"web-dl", "web -dl", "webdl", "web dl"}) {
 				return true
 			}
-			if containsAny(normalized, []string{"blu-ray", "blu ray", "bluray", "blu -ray"}) && !containsAny(normalized, []string{"web-dl", "web -dl", "webdl", "web dl"}) {
+			if containsAny(normalized, []string{"blu-ray", "blu ray", "bluray", "blu -ray"}) &&
+				!containsAny(normalized, []string{"web-dl", "web -dl", "webdl", "web dl"}) {
 				return true
 			}
 		}
@@ -198,19 +207,19 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 		}
 
 		skipResolutionCheck := isDVD || strings.Contains(strings.ToUpper(targetSource), "DVD") || isDVDRIP
-		if isOTWSameSeasonEpisodeResolutionMismatch(meta, tracker, each, targetSeason, targetEpisode, targetResolution) {
+		if policy.RejectEpisodeResolutionMismatch && isSameSeasonEpisodeResolutionMismatch(meta, each, targetSeason, targetEpisode, targetResolution) {
 			return true
 		}
 		if !skipResolutionCheck {
 			if targetResolution != "" && !strings.Contains(each, targetResolution) {
 				return true
 			}
-			if !hasMatchingHDR(fileHDR, targetHDR, meta, tracker) {
+			if !hasMatchingHDR(fileHDR, targetHDR, meta, tracker, registry) {
 				return true
 			}
 		}
 
-		if isDVD && tracker != "BHD" && containsResolution(each, []int{1080, 720, 2160}) {
+		if isDVD && !policy.CompareDVDResolution && containsResolution(each, []int{1080, 720, 2160}) {
 			return false
 		}
 
@@ -233,7 +242,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			}
 		}
 
-		if strings.EqualFold(meta.ExternalIDs.Category, "TV") || strings.EqualFold(meta.MediaInfoCategory, "TV") {
+		if strings.EqualFold(string(meta.Identity.Category), "TV") {
 			seasonMatch, isSeason := isSeasonEpisodeMatch(normalized, targetSeason, targetEpisode)
 			if !seasonMatch {
 				return true
@@ -252,7 +261,9 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 			return false
 		}
 
-		if len(dupes) == 1 && !strings.EqualFold(meta.DiscType, "BDMV") && (tracker == "AITHER" || tracker == "BHD" || tracker == "OE" || tracker == "ULCX") && fileSize > 0 && strings.Contains(targetResolution, "1080") && strings.Contains(videoEncode, "x264") {
+		if len(dupes) == 1 && !strings.EqualFold(meta.DiscType, "BDMV") && policy.AllowSizeVariance1080 && fileSize > 0 &&
+			strings.Contains(targetResolution, "1080") &&
+			strings.Contains(videoEncode, "x264") {
 			if entry.SizeKnown && entry.SizeBytes > 0 {
 				sizeDiff := float64(fileSize-entry.SizeBytes) / float64(entry.SizeBytes)
 				if sizeDiff >= 0.20 {
@@ -260,7 +271,7 @@ func FilterDupes(dupes []api.DupeEntry, meta api.PreparedMetadata, tracker strin
 				}
 			}
 		}
-		if len(dupes) == 1 && !strings.EqualFold(meta.DiscType, "BDMV") && tracker == "RF" {
+		if len(dupes) == 1 && !strings.EqualFold(meta.DiscType, "BDMV") && policy.RequireReleaseGroup {
 			if tag != "" && strings.Contains(normalized, tag) {
 				return false
 			}
@@ -309,7 +320,7 @@ func normalizeMTVName(value string) string {
 	return normalized
 }
 
-func resolveFileNames(meta api.PreparedMetadata) ([]string, []string) {
+func resolveFileNames(meta api.DuplicateSubject) ([]string, []string) {
 	if strings.TrimSpace(meta.DiscType) != "" {
 		return nil, nil
 	}
@@ -320,7 +331,7 @@ func resolveFileNames(meta api.PreparedMetadata) ([]string, []string) {
 	return files, meta.FileList
 }
 
-func resolvePrimaryFileSize(meta api.PreparedMetadata) int64 {
+func resolvePrimaryFileSize(meta api.DuplicateSubject) int64 {
 	if strings.TrimSpace(meta.VideoPath) != "" {
 		if info, err := os.Stat(meta.VideoPath); err == nil && !info.IsDir() {
 			return info.Size()
@@ -364,8 +375,9 @@ func refineHDRFromEntry(entry api.DupeEntry, normalized string) map[string]struc
 	return terms
 }
 
-func hasMatchingHDR(fileHDR, targetHDR map[string]struct{}, meta api.PreparedMetadata, tracker string) bool {
-	simplify := func(hdr map[string]struct{}, trackerName string) map[string]struct{} {
+func hasMatchingHDR(fileHDR, targetHDR map[string]struct{}, meta api.DuplicateSubject, tracker string, registry *trackers.Registry) bool {
+	policy, _ := registry.LookupDupePolicy(tracker)
+	simplify := func(hdr map[string]struct{}, _ string) map[string]struct{} {
 		out := make(map[string]struct{})
 		if _, ok := hdr["HDR"]; ok {
 			out["HDR"] = struct{}{}
@@ -382,7 +394,7 @@ func hasMatchingHDR(fileHDR, targetHDR map[string]struct{}, meta api.PreparedMet
 			if !strings.Contains(metaType, "web") {
 				out["HDR"] = struct{}{}
 			}
-			if trackerName == "ANT" {
+			if policy.DolbyVisionImpliesHDR {
 				out["HDR"] = struct{}{}
 			}
 		}
@@ -433,7 +445,22 @@ func parseSeasonEpisode(value string) (string, string) {
 	return season, episode
 }
 
-func resolveSeasonEpisode(meta api.PreparedMetadata) (string, string) {
+func normalizeSeasonEpisode(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	upper := strings.ToUpper(trimmed)
+	if strings.HasPrefix(upper, "S") {
+		return upper
+	}
+	if number, err := strconv.Atoi(trimmed); err == nil {
+		return "S" + strconv.Itoa(number)
+	}
+	return upper
+}
+
+func resolveSeasonEpisode(meta api.DuplicateSubject) (string, string) {
 	season := ""
 	episode := ""
 	if meta.ReleaseNameOverrides.Season != nil {
@@ -540,8 +567,8 @@ func episodeTokenRegex(value int) *regexp.Regexp {
 	return regexp.MustCompile(`(?i)E0*` + strconv.Itoa(value) + `(?:[^0-9]|$)`)
 }
 
-func isOTWSameSeasonEpisodeResolutionMismatch(meta api.PreparedMetadata, tracker string, name string, targetSeason string, targetEpisode string, targetResolution string) bool {
-	if !strings.EqualFold(tracker, "OTW") || meta.TVPack || !strings.EqualFold(meta.ExternalIDs.Category, "TV") {
+func isSameSeasonEpisodeResolutionMismatch(meta api.DuplicateSubject, name string, targetSeason string, targetEpisode string, targetResolution string) bool {
+	if meta.TVPack || !strings.EqualFold(string(meta.Identity.Category), "TV") {
 		return false
 	}
 	if strings.TrimSpace(targetEpisode) == "" || strings.TrimSpace(targetResolution) == "" {
diff --git a/internal/dupechecking/filter_test.go b/internal/trackers/dupe/filter_test.go
similarity index 83%
rename from internal/dupechecking/filter_test.go
rename to internal/trackers/dupe/filter_test.go
index 39160fe2..0ce9e704 100644
--- a/internal/dupechecking/filter_test.go
+++ b/internal/trackers/dupe/filter_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package dupechecking
+package dupe
 
 import (
 	"testing"
@@ -12,7 +12,7 @@ import (
 
 func TestFilterDupesEmpty(t *testing.T) {
 	t.Parallel()
-	filtered, match := FilterDupes(nil, api.PreparedMetadata{}, "AITHER", config.Config{}, api.NopLogger{})
+	filtered, match := FilterDupes(nil, api.DuplicateSubject{}, "AITHER", config.Config{}, api.NopLogger{})
 	if len(filtered) != 0 {
 		t.Fatalf("expected no filtered dupes")
 	}
@@ -23,7 +23,7 @@ func TestFilterDupesEmpty(t *testing.T) {
 
 func TestFilterDupesKeepsExactMatch(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Movie.2024.1080p.WEBDL.x264-GRP",
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
 		Type:        "WEBDL",
@@ -99,9 +99,9 @@ func TestIsSeasonEpisodeMatchAllowsUnpaddedSeasonEpisode(t *testing.T) {
 func TestFilterDupesKeepsMatchingDailyEpisode(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName:      "Show.2026.03.27.1080p.WEB-DL.x264-GRP",
-		ExternalIDs:      api.ExternalIDs{Category: "TV"},
+		Identity:         api.ExternalIdentity{Category: "TV"},
 		DailyEpisodeDate: "2026-03-27",
 		Release:          api.ReleaseInfo{Resolution: "1080p"},
 		Type:             "WEBDL",
@@ -124,16 +124,20 @@ func TestFilterDupesKeepsMatchingDailyEpisode(t *testing.T) {
 func TestFilterDupesSingleEpisodeKeepsMatchingSeasonPack(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Show.S01E02.1080p.WEB-DL.x264-GRP",
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
+		Identity:    api.ExternalIdentity{Category: "TV"},
 		SeasonStr:   "S01",
 		EpisodeStr:  "E02",
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
 		Type:        "WEBDL",
 		SourcePath:  "x",
 	}
-	dupes := []api.DupeEntry{{Name: "Show.S01.1080p.WEB-DL.x264-OTHER", Link: "https://example.invalid/pack", ID: "pack-1"}}
+	dupes := []api.DupeEntry{{
+		Name: "Show.S01.1080p.WEB-DL.x264-OTHER",
+		Link: "https://example.invalid/pack",
+		ID:   "pack-1",
+	}}
 
 	filtered, match := FilterDupes(dupes, meta, "AITHER", config.Config{}, api.NopLogger{})
 	if len(filtered) != 1 {
@@ -150,9 +154,9 @@ func TestFilterDupesSingleEpisodeKeepsMatchingSeasonPack(t *testing.T) {
 func TestFilterDupesTVPackExcludesSingleEpisodes(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Show.S01.1080p.WEB-DL.x264-GRP",
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
+		Identity:    api.ExternalIdentity{Category: "TV"},
 		SeasonStr:   "S01",
 		TVPack:      true,
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
@@ -176,9 +180,9 @@ func TestFilterDupesTVPackExcludesSingleEpisodes(t *testing.T) {
 func TestFilterDupesTVPackDoesNotCrossMatchSeason(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Show.S01.1080p.WEB-DL.x264-GRP",
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
+		Identity:    api.ExternalIdentity{Category: "TV"},
 		SeasonStr:   "S1",
 		TVPack:      true,
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
@@ -196,9 +200,9 @@ func TestFilterDupesTVPackDoesNotCrossMatchSeason(t *testing.T) {
 func TestFilterDupesOTWDropsSameSeasonEpisodeResolutionMismatch(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Show.S1E02.1080p.WEB-DL.H264-GRP",
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
+		Identity:    api.ExternalIdentity{Category: "TV"},
 		SeasonStr:   "S1",
 		EpisodeStr:  "E02",
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
@@ -219,32 +223,32 @@ func TestFilterDupesOTWDropsSameSeasonEpisodeResolutionMismatch(t *testing.T) {
 	}
 }
 
-func TestOTWSameSeasonEpisodeResolutionMismatchIgnoresTVPacks(t *testing.T) {
+func TestSameSeasonEpisodeResolutionMismatchIgnoresTVPacks(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.DuplicateSubject{
 		ReleaseName: "Show.S01.1080p.WEB-DL.H264-GRP",
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
+		Identity:    api.ExternalIdentity{Category: "TV"},
 		SeasonInt:   1,
 		TVPack:      true,
 		Release:     api.ReleaseInfo{Resolution: "1080p"},
 		Type:        "WEBDL",
 	}
 
-	if isOTWSameSeasonEpisodeResolutionMismatch(meta, "OTW", "Show.S01E02.720p.WEB-DL.H264-OTHER", "S01", "E02", "1080p") {
+	if isSameSeasonEpisodeResolutionMismatch(meta, "Show.S01E02.720p.WEB-DL.H264-OTHER", "S01", "E02", "1080p") {
 		t.Fatalf("did not expect OTW same-season episode guard for TV packs")
 	}
 }
 
-func TestOTWSameSeasonEpisodeResolutionMismatchMatchesAnyEpisodeInSeason(t *testing.T) {
+func TestSameSeasonEpisodeResolutionMismatchMatchesAnyEpisodeInSeason(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{Category: "TV"},
+		Release:  api.ReleaseInfo{Resolution: "1080p"},
 	}
 
-	if !isOTWSameSeasonEpisodeResolutionMismatch(meta, "OTW", "Show.S01E01.720p.WEB-DL.H264-OTHER", "S01", "E02", "1080p") {
+	if !isSameSeasonEpisodeResolutionMismatch(meta, "Show.S01E01.720p.WEB-DL.H264-OTHER", "S01", "E02", "1080p") {
 		t.Fatalf("expected same-season episode with different resolution to be excluded")
 	}
 }
diff --git a/internal/trackers/dupe/service.go b/internal/trackers/dupe/service.go
new file mode 100644
index 00000000..64da32ac
--- /dev/null
+++ b/internal/trackers/dupe/service.go
@@ -0,0 +1,586 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package dupe coordinates tracker-owned duplicate searches and shared matching.
+package dupe
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/redaction"
+	trackerspkg "github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const maxDupeWorkers = 4
+const duplicateCancelWarningThreshold = 5 * time.Second
+
+type indexedTracker struct {
+	index   int
+	tracker string
+}
+
+type indexedResult struct {
+	index  int
+	result api.DupeCheckResult
+	entry  assessmentEntry
+}
+
+// CheckOptions controls structural duplicate evaluation without synthesizing caller-side outcomes.
+type CheckOptions struct {
+	// SkipRemote suppresses tracker network search while preserving definitive local-client checks.
+	SkipRemote bool
+}
+
+// Service coordinates bounded duplicate checks through tracker-bound adapters.
+type Service struct {
+	cfg      config.Config
+	logger   api.Logger
+	http     *http.Client
+	banned   *trackerspkg.BannedGroupChecker
+	registry *trackerspkg.Registry
+	adapters map[string]Adapter
+	filter   func([]api.DupeEntry, api.DuplicateSubject, string, config.Config, api.Logger) ([]api.DupeEntry, api.DupeMatch)
+	initErr  error
+
+	cancelWarningThreshold time.Duration
+}
+
+// NewServiceWithRegistry constructs one tracker-bound adapter for every
+// registered definition using a shared 20-second HTTP client. Construction
+// failures are retained and returned by later checks rather than panicking.
+func NewServiceWithRegistry(cfg config.Config, logger api.Logger, registry *trackerspkg.Registry) *Service {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	httpClient := &http.Client{Timeout: 20 * time.Second}
+	service := &Service{
+		cfg:                    cfg,
+		logger:                 logger,
+		http:                   httpClient,
+		banned:                 trackerspkg.NewBannedGroupCheckerWithRegistry(cfg.MainSettings.DBPath, registry),
+		registry:               registry,
+		adapters:               make(map[string]Adapter),
+		cancelWarningThreshold: duplicateCancelWarningThreshold,
+	}
+	service.filter = func(entries []api.DupeEntry, meta api.DuplicateSubject, tracker string, _ config.Config, _ api.Logger) ([]api.DupeEntry, api.DupeMatch) {
+		return filterDupes(entries, meta, tracker, registry)
+	}
+	if registry == nil {
+		service.initErr = errors.New("dupechecking: tracker registry is nil")
+		return service
+	}
+	for _, name := range registry.Names() {
+		definition, ok := registry.Lookup(name)
+		if !ok {
+			service.initErr = fmt.Errorf("dupechecking: tracker definition unavailable: %s", name)
+			return service
+		}
+		factory, ok := definition.(Factory)
+		if !ok {
+			service.initErr = fmt.Errorf("dupechecking: tracker duplicate factory unavailable: %s", name)
+			return service
+		}
+		trackerConfig := effectiveTrackerConfig(cfg, name)
+		dependencies := NewDependencies(name, trackerConfig, cfg.MainSettings.DBPath, httpClient, logger)
+		dependencies.registry = registry
+		adapter := factory.NewDuplicateAdapter(dependencies)
+		if adapter == nil {
+			service.initErr = fmt.Errorf("dupechecking: tracker duplicate adapter unavailable: %s", name)
+			return service
+		}
+		service.adapters[name] = adapter
+	}
+	return service
+}
+
+// Check searches requested trackers. Normal completion returns exactly one result per tracker in resolved order.
+// Cancellation stops enqueueing, waits for every started adapter, and returns completed evidence with the context error.
+func (s *Service) Check(ctx context.Context, meta api.DuplicateSubject, trackerNames []string) (api.DupeCheckSummary, error) {
+	summary, _, err := s.CheckWithAssessment(ctx, meta, trackerNames, CheckOptions{})
+	return summary, err
+}
+
+// CheckWithAssessment runs at most four tracker adapters concurrently, returns
+// public-safe results in requested order, and binds private evidence into an
+// immutable assessment. Cancellation stops enqueueing, waits for started
+// adapters, returns completed public evidence, and discards reusable assessment.
+func (s *Service) CheckWithAssessment(
+	ctx context.Context,
+	meta api.DuplicateSubject,
+	trackerNames []string,
+	options CheckOptions,
+) (api.DupeCheckSummary, Assessment, error) {
+	summary := api.DupeCheckSummary{SourcePath: meta.SourcePath}
+	if strings.TrimSpace(meta.SourcePath) == "" {
+		return summary, EmptyAssessment(), errors.New("dupechecking: missing source path")
+	}
+	if s == nil || s.initErr != nil {
+		if s == nil {
+			return summary, EmptyAssessment(), errors.New("dupechecking: service is nil")
+		}
+		return summary, EmptyAssessment(), s.initErr
+	}
+	resolved := dedupeTrackers(trackerNames)
+	if len(resolved) == 0 {
+		summary.Notes = []string{"no trackers configured for dupe checking"}
+		s.logger.Infof("dupechecking: no trackers configured source=%s", meta.SourcePath)
+		return summary, EmptyAssessment(), nil
+	}
+
+	total := len(resolved)
+	for _, tracker := range resolved {
+		s.emitDupeProgress(ctx, api.DupeProgressUpdate{
+			SourcePath: meta.SourcePath,
+			Tracker:    tracker,
+			Status:     "queued",
+			Message:    "queued",
+			Total:      total,
+		})
+	}
+
+	jobs := make(chan indexedTracker)
+	results := make(chan indexedResult, total)
+	workerCount := min(total, maxDupeWorkers)
+	var workers sync.WaitGroup
+	for range workerCount {
+		workers.Go(func() {
+			for job := range jobs {
+				if ctx.Err() != nil {
+					continue
+				}
+				s.emitDupeProgress(ctx, api.DupeProgressUpdate{
+					SourcePath: meta.SourcePath,
+					Tracker:    job.tracker,
+					Status:     "running",
+					Message:    "searching",
+					Total:      total,
+				})
+				result, entry, operationCanceled := s.checkTracker(ctx, meta, job.tracker, options)
+				if operationCanceled {
+					continue
+				}
+				results <- indexedResult{
+					index:  job.index,
+					result: result,
+					entry:  entry,
+				}
+			}
+		})
+	}
+	workersDone := make(chan struct{})
+	go func() {
+		workers.Wait()
+		close(results)
+		close(workersDone)
+	}()
+	go func() {
+		defer close(jobs)
+		for index, tracker := range resolved {
+			select {
+			case <-ctx.Done():
+				return
+			case jobs <- indexedTracker{index: index, tracker: tracker}:
+			}
+		}
+	}()
+
+	watchdogDone := make(chan struct{})
+	go s.warnOnSlowCancellation(ctx, workersDone, watchdogDone, meta.SourcePath)
+	byIndex := make([]*api.DupeCheckResult, total)
+	assessmentByIndex := make([]*assessmentEntry, total)
+	completed := 0
+	for completedResult := range results {
+		result := completedResult.result
+		byIndex[completedResult.index] = &result
+		entry := completedResult.entry
+		assessmentByIndex[completedResult.index] = &entry
+		completed++
+		s.emitDupeProgress(ctx, api.DupeProgressUpdate{
+			SourcePath: meta.SourcePath,
+			Tracker:    result.Tracker,
+			Status:     result.Status,
+			Message:    dupeProgressMessage(result),
+			Completed:  completed,
+			Total:      total,
+			Result:     result,
+		})
+	}
+	<-watchdogDone
+	for _, result := range byIndex {
+		if result != nil {
+			summary.Results = append(summary.Results, *result)
+		}
+	}
+	if err := ctx.Err(); err != nil {
+		return summary, EmptyAssessment(), fmt.Errorf("context canceled: %w", err)
+	}
+	assessment := Assessment{entries: make(map[string]assessmentEntry, total), assessed: true}
+	for _, entry := range assessmentByIndex {
+		if entry != nil {
+			assessment.entries[entry.tracker] = cloneAssessmentEntry(*entry)
+		}
+	}
+	return summary, assessment, nil
+}
+
+func (s *Service) warnOnSlowCancellation(ctx context.Context, workersDone <-chan struct{}, done chan<- struct{}, sourcePath string) {
+	defer close(done)
+	select {
+	case <-workersDone:
+		return
+	case <-ctx.Done():
+	}
+	threshold := s.cancelWarningThreshold
+	if threshold <= 0 {
+		threshold = duplicateCancelWarningThreshold
+	}
+	timer := time.NewTimer(threshold)
+	defer timer.Stop()
+	select {
+	case <-workersDone:
+	case <-timer.C:
+		s.logger.Warnf("dupechecking: cancellation drain still active source=%s", sourcePath)
+		<-workersDone
+	}
+}
+
+func (s *Service) emitDupeProgress(ctx context.Context, update api.DupeProgressUpdate) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			s.logger.Warnf(
+				"dupechecking: progress reporter panicked tracker=%s status=%s err=%s",
+				update.Tracker,
+				update.Status,
+				panicProgressMessage(recovered),
+			)
+		}
+	}()
+	api.EmitDupeProgress(ctx, update)
+}
+
+func (s *Service) checkTracker(
+	ctx context.Context,
+	meta api.DuplicateSubject,
+	tracker string,
+	options CheckOptions,
+) (result api.DupeCheckResult, entry assessmentEntry, operationCanceled bool) {
+	checkedAt := time.Now().UTC()
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			message := panicFailureMessage(recovered)
+			result = failedPublicResult(tracker, FailureInternal, message, checkedAt)
+			entry = newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil)
+			s.logger.Warnf("dupechecking: search panicked tracker=%s source=%s err=%s", tracker, meta.SourcePath, message)
+		}
+	}()
+
+	if containsTracker(meta.MatchedTrackers, tracker) {
+		match := api.DupeMatch{MatchedReason: "in_client"}
+		result = api.DupeCheckResult{
+			Tracker:   tracker,
+			HasDupes:  true,
+			Match:     match,
+			Status:    "completed",
+			CheckedAt: checkedAt,
+		}
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionResolved, "", true, match, nil), false
+	}
+	if options.SkipRemote {
+		result = notRunPublicResult(tracker, NotRunUserRequested, "duplicate search skipped by user request", checkedAt)
+		entry = newAssessmentEntry(meta, s.cfg, tracker, DispositionNotRun, NotRunUserRequested, false, api.DupeMatch{}, nil)
+		entry.authorization = AuthorizationWaiver
+		entry.verdict = VerdictWaived
+		return result, entry, false
+	}
+
+	if trackerspkg.NormalizeBannedReleaseGroup(meta.Tag) != "" {
+		if err := s.banned.RefreshDynamic(ctx, s.cfg, []string{tracker}, s.logger); err != nil {
+			if ctx.Err() != nil && (errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)) {
+				return api.DupeCheckResult{}, assessmentEntry{}, true
+			}
+			message := bannedGroupCheckFailureMessage(err)
+			s.logger.Warnf(
+				"dupechecking: banned-group refresh failed tracker=%s source=%s err=%s",
+				tracker,
+				meta.SourcePath,
+				redaction.RedactValue(err.Error(), nil),
+			)
+			result = failedPublicResult(tracker, FailureInternal, message, checkedAt)
+			return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil), false
+		}
+	}
+	if reason, err := s.bannedGroupSkipReason(tracker, meta.Tag); reason != "" || err != nil {
+		if err != nil {
+			message := bannedGroupCheckFailureMessage(err)
+			s.logger.Warnf(
+				"dupechecking: banned-group check failed tracker=%s source=%s err=%s",
+				tracker,
+				meta.SourcePath,
+				redaction.RedactValue(err.Error(), nil),
+			)
+			result = failedPublicResult(tracker, FailureInternal, message, checkedAt)
+			return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil), false
+		}
+		result = notRunPublicResult(tracker, NotRunBannedGroup, reason, checkedAt)
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionNotRun, NotRunBannedGroup, false, api.DupeMatch{}, nil), false
+	}
+
+	adapter, ok := s.adapters[tracker]
+	if !ok || adapter == nil {
+		result = failedPublicResult(tracker, FailureInternal, "duplicate adapter unavailable", checkedAt)
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil), false
+	}
+	adapterResult := adapter.Search(ctx, cloneDuplicateSubject(meta))
+	if err := adapterResult.cause(); err != nil && (errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)) && ctx.Err() != nil {
+		return api.DupeCheckResult{}, assessmentEntry{}, true
+	}
+	result, entry = s.projectAdapterResult(tracker, meta, adapterResult, checkedAt)
+	return result, entry, false
+}
+
+func (s *Service) projectAdapterResult(
+	tracker string,
+	meta api.DuplicateSubject,
+	adapterResult AdapterResult,
+	checkedAt time.Time,
+) (api.DupeCheckResult, assessmentEntry) {
+	switch adapterResult.Disposition() {
+	case DispositionInvalid:
+		result := failedPublicResult(tracker, FailureInternal, "duplicate adapter returned invalid disposition", checkedAt)
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil)
+	case DispositionResolved:
+		raw := trimEntries(adapterResult.Entries())
+		filter := s.filter
+		if filter == nil {
+			filter = FilterDupes
+		}
+		filtered, match := filter(raw, meta, tracker, s.cfg, s.logger)
+		result := api.DupeCheckResult{
+			Tracker:   tracker,
+			Raw:       publicEntries(raw),
+			Filtered:  publicEntries(filtered),
+			HasDupes:  len(filtered) > 0,
+			Match:     publicMatch(match),
+			Notes:     cloneNotes(adapterResult.Notes()),
+			Status:    "completed",
+			CheckedAt: checkedAt,
+		}
+		s.logger.Tracef(
+			"dupechecking: checked tracker=%s source=%s raw=%d filtered=%d dupes=%t",
+			tracker,
+			meta.SourcePath,
+			len(raw),
+			len(filtered),
+			result.HasDupes,
+		)
+		entry := newAssessmentEntry(meta, s.cfg, tracker, DispositionResolved, "", result.HasDupes, match, raw)
+		return result, entry
+	case DispositionNotRun:
+		code := adapterResult.Code()
+		if !validNotRunCode(code) {
+			result := failedPublicResult(tracker, FailureInternal, "duplicate adapter returned invalid not-run code", checkedAt)
+			return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil)
+		}
+		message := sanitizeSafeMessage(adapterResult.SafeMessage(), "duplicate search not run")
+		result := api.DupeCheckResult{
+			Tracker:    tracker,
+			Notes:      cloneNotes(adapterResult.Notes()),
+			Skipped:    true,
+			SkipReason: message,
+			SkipCode:   code,
+			Status:     "skipped",
+			CheckedAt:  checkedAt,
+		}
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionNotRun, code, false, api.DupeMatch{}, nil)
+	case DispositionFailed:
+		code := adapterResult.Code()
+		if !validFailureCode(code) {
+			code = FailureInternal
+		}
+		message := sanitizeSafeMessage(adapterResult.SafeMessage(), "duplicate search failed")
+		if cause := adapterResult.cause(); cause != nil {
+			s.logger.Warnf(
+				"dupechecking: adapter failed tracker=%s source=%s code=%s err=%s",
+				tracker,
+				meta.SourcePath,
+				code,
+				redaction.RedactValue(cause.Error(), nil),
+			)
+		}
+		result := failedPublicResult(tracker, code, message, checkedAt)
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, code, false, api.DupeMatch{}, nil)
+	default:
+		result := failedPublicResult(tracker, FailureInternal, "duplicate adapter returned invalid result", checkedAt)
+		return result, newAssessmentEntry(meta, s.cfg, tracker, DispositionFailed, FailureInternal, false, api.DupeMatch{}, nil)
+	}
+}
+
+func containsTracker(trackers []string, tracker string) bool {
+	for _, candidate := range trackers {
+		if normalizeTracker(candidate) == normalizeTracker(tracker) {
+			return true
+		}
+	}
+	return false
+}
+
+func notRunPublicResult(tracker string, code string, message string, checkedAt time.Time) api.DupeCheckResult {
+	message = sanitizeSafeMessage(message, "duplicate search not run")
+	return api.DupeCheckResult{
+		Tracker:    tracker,
+		Notes:      []string{message},
+		Skipped:    true,
+		SkipReason: message,
+		SkipCode:   code,
+		Status:     "skipped",
+		CheckedAt:  checkedAt,
+	}
+}
+
+func failedPublicResult(tracker string, _ string, message string, checkedAt time.Time) api.DupeCheckResult {
+	message = sanitizeSafeMessage(message, "duplicate search failed")
+	return api.DupeCheckResult{
+		Tracker:   tracker,
+		Status:    "failed",
+		Error:     message,
+		CheckedAt: checkedAt,
+	}
+}
+
+func sanitizeSafeMessage(message string, fallback string) string {
+	message = strings.TrimSpace(logging.SanitizeMessage(message))
+	if message == "" {
+		return fallback
+	}
+	return message
+}
+
+func publicEntries(entries []api.DupeEntry) []api.DupeEntry {
+	out := cloneEntries(entries)
+	for idx := range out {
+		out[idx].Download = ""
+		out[idx].Link = sanitizePublicURL(out[idx].Link)
+	}
+	return out
+}
+
+func publicMatch(match api.DupeMatch) api.DupeMatch {
+	match.MatchedDownload = ""
+	match.MatchedLink = sanitizePublicURL(match.MatchedLink)
+	match.SeasonPackLink = sanitizePublicURL(match.SeasonPackLink)
+	match.MatchedEpisodeIDs = append([]api.DupeEpisodeMatch(nil), match.MatchedEpisodeIDs...)
+	for idx := range match.MatchedEpisodeIDs {
+		match.MatchedEpisodeIDs[idx].Link = sanitizePublicURL(match.MatchedEpisodeIDs[idx].Link)
+	}
+	return match
+}
+
+func sanitizePublicURL(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	parsed, err := url.Parse(value)
+	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+		return ""
+	}
+	parsed.RawQuery = ""
+	parsed.Fragment = ""
+	parsed.User = nil
+	return parsed.String()
+}
+
+func (s *Service) bannedGroupSkipReason(tracker string, tag string) (string, error) {
+	group := trackerspkg.NormalizeBannedReleaseGroup(tag)
+	if group == "" {
+		return "", nil
+	}
+	banned, err := s.banned.IsBanned(tracker, group)
+	if err != nil {
+		return "", fmt.Errorf("dupechecking: %s banned group: %w", normalizeTracker(tracker), err)
+	}
+	if !banned {
+		return "", nil
+	}
+	return fmt.Sprintf("group %s is banned on %s", group, normalizeTracker(tracker)), nil
+}
+
+func effectiveTrackerConfig(cfg config.Config, tracker string) config.TrackerConfig {
+	for name, trackerConfig := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), tracker) {
+			return trackerConfig
+		}
+	}
+	return config.TrackerConfig{}
+}
+
+func cloneDuplicateSubject(meta api.DuplicateSubject) api.DuplicateSubject {
+	// Prepared metadata is already immutable at the Core boundary; copying the value
+	// prevents adapter replacement while slice/map fields remain read-only by contract.
+	return meta
+}
+
+func dedupeTrackers(trackers []string) []string {
+	resolved := make([]string, 0, len(trackers))
+	seen := make(map[string]struct{}, len(trackers))
+	for _, trackerName := range trackers {
+		tracker := normalizeTracker(trackerName)
+		if tracker == "" {
+			continue
+		}
+		if _, ok := seen[tracker]; ok {
+			continue
+		}
+		seen[tracker] = struct{}{}
+		resolved = append(resolved, tracker)
+	}
+	return resolved
+}
+
+func dupeProgressMessage(result api.DupeCheckResult) string {
+	switch result.Status {
+	case "failed":
+		return sanitizeSafeMessage(result.Error, "duplicate search failed")
+	case "skipped":
+		return sanitizeSafeMessage(result.SkipReason, "duplicate search not run")
+	default:
+		if result.HasDupes {
+			return fmt.Sprintf("%d dupes found", len(result.Filtered))
+		}
+		return "no dupes found"
+	}
+}
+
+func panicFailureMessage(recovered any) string {
+	detail := strings.TrimSpace(redaction.RedactValue(fmt.Sprint(recovered), nil))
+	if detail == "" {
+		return "duplicate search panicked"
+	}
+	return "duplicate search panicked: " + detail
+}
+
+func bannedGroupCheckFailureMessage(err error) string {
+	detail := strings.TrimSpace(redaction.RedactValue(err.Error(), nil))
+	if detail == "" {
+		detail = "unknown error"
+	}
+	return "banned group check failed: " + detail + "; action=fix banned-group configuration and retry"
+}
+
+func panicProgressMessage(recovered any) string {
+	detail := strings.TrimSpace(redaction.RedactValue(fmt.Sprint(recovered), nil))
+	if detail == "" {
+		return "duplicate progress reporter panicked"
+	}
+	return "duplicate progress reporter panicked: " + detail
+}
diff --git a/internal/trackers/dupe/service_test.go b/internal/trackers/dupe/service_test.go
new file mode 100644
index 00000000..92015290
--- /dev/null
+++ b/internal/trackers/dupe/service_test.go
@@ -0,0 +1,226 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dupe
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func testService(adapters map[string]Adapter) *Service {
+	return &Service{
+		cfg:      adaptersConfig(adapters),
+		logger:   api.NopLogger{},
+		adapters: adapters,
+		filter: func(entries []api.DupeEntry, _ api.DuplicateSubject, _ string, _ config.Config, _ api.Logger) ([]api.DupeEntry, api.DupeMatch) {
+			return cloneEntries(entries), api.DupeMatch{}
+		},
+		cancelWarningThreshold: time.Second,
+	}
+}
+
+func adaptersConfig(adapters map[string]Adapter) config.Config {
+	trackers := make(map[string]config.TrackerConfig, len(adapters))
+	for name := range adapters {
+		trackers[name] = config.TrackerConfig{}
+	}
+	return config.Config{Trackers: config.TrackersConfig{Trackers: trackers}}
+}
+
+func TestAdapterResultDefensiveCopies(t *testing.T) {
+	entries := []api.DupeEntry{{Name: "Example.Release.2026.1080p-GRP", Files: []string{"one.mkv"}}}
+	notes := []string{"display only"}
+	result := Resolved(entries, notes)
+	entries[0].Name = "mutated"
+	entries[0].Files[0] = "mutated"
+	notes[0] = "mutated"
+
+	gotEntries := result.Entries()
+	gotNotes := result.Notes()
+	if gotEntries[0].Name != "Example.Release.2026.1080p-GRP" || gotEntries[0].Files[0] != "one.mkv" || gotNotes[0] != "display only" {
+		t.Fatalf("result changed through caller mutation: %#v %#v", gotEntries, gotNotes)
+	}
+	gotEntries[0].Files[0] = "again"
+	if result.Entries()[0].Files[0] != "one.mkv" {
+		t.Fatal("result accessor exposed mutable state")
+	}
+}
+
+func TestCheckReturnsResolvedOrderAndActualCompletionProgress(t *testing.T) {
+	startedA := make(chan struct{})
+	startedB := make(chan struct{})
+	releaseA := make(chan struct{})
+	releaseB := make(chan struct{})
+	service := testService(map[string]Adapter{
+		"A": AdapterFunc(func(context.Context, api.DuplicateSubject) AdapterResult {
+			close(startedA)
+			<-releaseA
+			return Resolved(nil, nil)
+		}),
+		"B": AdapterFunc(func(context.Context, api.DuplicateSubject) AdapterResult {
+			close(startedB)
+			<-releaseB
+			return Resolved(nil, nil)
+		}),
+	})
+
+	var mu sync.Mutex
+	completed := make([]string, 0, 2)
+	completedB := make(chan struct{})
+	ctx := api.WithDupeProgressReporter(context.Background(), func(update api.DupeProgressUpdate) {
+		if update.Status == "completed" {
+			mu.Lock()
+			completed = append(completed, update.Tracker)
+			mu.Unlock()
+			if update.Tracker == "B" {
+				close(completedB)
+			}
+		}
+	})
+	done := make(chan api.DupeCheckSummary, 1)
+	go func() {
+		summary, _ := service.Check(ctx, api.DuplicateSubject{SourcePath: "C:/media/example.mkv"}, []string{"A", "B"})
+		done <- summary
+	}()
+	waitForSignal := func(label string, signal <-chan struct{}) {
+		t.Helper()
+		select {
+		case <-signal:
+		case <-time.After(10 * time.Second):
+			t.Fatalf("timeout waiting for %s", label)
+		}
+	}
+	waitForSignal("adapter A to start", startedA)
+	waitForSignal("adapter B to start", startedB)
+	close(releaseB)
+	waitForSignal("adapter B completion progress", completedB)
+	close(releaseA)
+	var summary api.DupeCheckSummary
+	select {
+	case summary = <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for duplicate check summary")
+	}
+	if len(summary.Results) != 2 || summary.Results[0].Tracker != "A" || summary.Results[1].Tracker != "B" {
+		t.Fatalf("resolved order not preserved: %#v", summary.Results)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(completed) != 2 || completed[0] != "B" || completed[1] != "A" {
+		t.Fatalf("completion progress not actual order: %v", completed)
+	}
+}
+
+func TestCheckLimitsConcurrencyToFour(t *testing.T) {
+	var active atomic.Int32
+	var maximum atomic.Int32
+	release := make(chan struct{})
+	adapters := make(map[string]Adapter)
+	for _, name := range []string{"A", "B", "C", "D", "E", "F"} {
+		adapters[name] = AdapterFunc(func(context.Context, api.DuplicateSubject) AdapterResult {
+			current := active.Add(1)
+			for {
+				previous := maximum.Load()
+				if current <= previous || maximum.CompareAndSwap(previous, current) {
+					break
+				}
+			}
+			<-release
+			active.Add(-1)
+			return Resolved(nil, nil)
+		})
+	}
+	done := make(chan struct{})
+	go func() {
+		_, _ = testService(adapters).Check(context.Background(), api.DuplicateSubject{SourcePath: "C:/media/example.mkv"}, []string{"A", "B", "C", "D", "E", "F"})
+		close(done)
+	}()
+	deadline := time.After(2 * time.Second)
+	for maximum.Load() < 4 {
+		select {
+		case <-deadline:
+			t.Fatal("workers did not start")
+		default:
+			time.Sleep(time.Millisecond)
+		}
+	}
+	if maximum.Load() > maxDupeWorkers {
+		t.Fatalf("maximum concurrency = %d", maximum.Load())
+	}
+	close(release)
+	<-done
+}
+
+func TestCheckCancellationWaitsForStartedAdapterAndReturnsCompletedEvidence(t *testing.T) {
+	started := make(chan struct{})
+	completed := make(chan struct{})
+	release := make(chan struct{})
+	service := testService(map[string]Adapter{
+		"A": AdapterFunc(func(ctx context.Context, _ api.DuplicateSubject) AdapterResult {
+			close(started)
+			<-ctx.Done()
+			<-release
+			return Failed(FailureRequest, "canceled", ctx.Err())
+		}),
+		"B": AdapterFunc(func(context.Context, api.DuplicateSubject) AdapterResult {
+			close(completed)
+			return Resolved(nil, nil)
+		}),
+	})
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct {
+		summary api.DupeCheckSummary
+		err     error
+	}, 1)
+	go func() {
+		summary, err := service.Check(ctx, api.DuplicateSubject{SourcePath: "C:/media/example.mkv"}, []string{"B", "A"})
+		done <- struct {
+			summary api.DupeCheckSummary
+			err     error
+		}{summary: summary, err: err}
+	}()
+	<-started
+	<-completed
+	cancel()
+	select {
+	case <-done:
+		t.Fatal("cancellation detached a started adapter")
+	case <-time.After(25 * time.Millisecond):
+	}
+	close(release)
+	got := <-done
+	if !errors.Is(got.err, context.Canceled) {
+		t.Fatalf("error = %v", got.err)
+	}
+	if len(got.summary.Results) != 1 || got.summary.Results[0].Tracker != "B" {
+		t.Fatalf("completed evidence lost: %#v", got.summary.Results)
+	}
+}
+
+func TestPublicProjectionBlanksPrivateDownloadsAndURLQueries(t *testing.T) {
+	service := testService(map[string]Adapter{
+		"A": AdapterFunc(func(context.Context, api.DuplicateSubject) AdapterResult {
+			return Resolved([]api.DupeEntry{{
+				Name:     "Example.Release.2026.1080p-GRP",
+				Link:     "https://tracker.example/torrents/1?token=secret",
+				Download: "https://tracker.example/download/1?passkey=secret",
+			}}, nil)
+		}),
+	})
+	summary, err := service.Check(context.Background(), api.DuplicateSubject{SourcePath: "C:/media/example.mkv"}, []string{"A"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	entry := summary.Results[0].Raw[0]
+	if entry.Download != "" || entry.Link != "https://tracker.example/torrents/1" {
+		t.Fatalf("private URL leaked: %#v", entry)
+	}
+}
diff --git a/internal/trackers/dupe/types.go b/internal/trackers/dupe/types.go
new file mode 100644
index 00000000..4eeac302
--- /dev/null
+++ b/internal/trackers/dupe/types.go
@@ -0,0 +1,300 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dupe
+
+import (
+	"context"
+	"maps"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	trackerspkg "github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Disposition identifies whether a tracker search resolved, did not run, or failed.
+type Disposition uint8
+
+const (
+	// DispositionInvalid is the zero value and represents a malformed adapter result.
+	DispositionInvalid Disposition = iota
+	// DispositionResolved indicates that tracker search completed with usable evidence.
+	DispositionResolved
+	// DispositionNotRun indicates an intentional structurally classified skip.
+	DispositionNotRun
+	// DispositionFailed indicates that attempted tracker work failed.
+	DispositionFailed
+)
+
+// Stable not-run codes.
+const (
+	NotRunUserRequested       = "user_requested"
+	NotRunBannedGroup         = "banned_group"
+	NotRunAuthNotReady        = "auth_not_ready"
+	NotRunMissingCredentials  = "missing_credentials"
+	NotRunMissingMetadata     = "missing_metadata"
+	NotRunUnsupportedContent  = "unsupported_content"
+	NotRunManualCheckRequired = "manual_check_required"
+	NotRunNotImplemented      = "not_implemented"
+)
+
+// Stable failure codes.
+const (
+	FailureRequest        = "request"
+	FailureAuthentication = "authentication"
+	FailureResponseStatus = "response_status"
+	FailureResponseParse  = "response_parse"
+	FailureInternal       = "internal"
+)
+
+var validNotRunCodes = map[string]struct{}{
+	NotRunUserRequested:       {},
+	NotRunBannedGroup:         {},
+	NotRunAuthNotReady:        {},
+	NotRunMissingCredentials:  {},
+	NotRunMissingMetadata:     {},
+	NotRunUnsupportedContent:  {},
+	NotRunManualCheckRequired: {},
+	NotRunNotImplemented:      {},
+}
+
+var validFailureCodes = map[string]struct{}{
+	FailureRequest:        {},
+	FailureAuthentication: {},
+	FailureResponseStatus: {},
+	FailureResponseParse:  {},
+	FailureInternal:       {},
+}
+
+// Dependencies are the narrow, construction-bound inputs for one duplicate adapter.
+// Config contains only the effective tracker entry; DBPath anchors credential/session access.
+type Dependencies struct {
+	tracker  string
+	config   config.TrackerConfig
+	dbPath   string
+	http     *http.Client
+	logger   api.Logger
+	registry *trackerspkg.Registry
+}
+
+// NewDependencies binds one adapter to its normalized tracker identity and effective config.
+func NewDependencies(
+	tracker string,
+	trackerConfig config.TrackerConfig,
+	dbPath string,
+	httpClient *http.Client,
+	logger api.Logger,
+) Dependencies {
+	tracker = strings.ToUpper(strings.TrimSpace(tracker))
+	trackerConfig.InternalGroups = append([]string(nil), trackerConfig.InternalGroups...)
+	trackerConfig.Unknown = maps.Clone(trackerConfig.Unknown)
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return Dependencies{
+		tracker: tracker,
+		config:  trackerConfig,
+		dbPath:  strings.TrimSpace(dbPath),
+		http:    httpClient,
+		logger:  logger,
+	}
+}
+
+// NewAdapter is a convenience constructor that narrows a runtime config before invoking a factory.
+func NewAdapter(
+	factory Factory,
+	tracker string,
+	cfg config.Config,
+	httpClient *http.Client,
+	logger api.Logger,
+	registries ...*trackerspkg.Registry,
+) Adapter {
+	tracker = strings.ToUpper(strings.TrimSpace(tracker))
+	var trackerConfig config.TrackerConfig
+	for name, candidate := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), tracker) {
+			trackerConfig = candidate
+			break
+		}
+	}
+	dependencies := NewDependencies(tracker, trackerConfig, cfg.MainSettings.DBPath, httpClient, logger)
+	if len(registries) > 0 {
+		dependencies.registry = registries[0]
+	}
+	return factory.NewDuplicateAdapter(dependencies)
+}
+
+// Tracker returns the normalized tracker identity bound to the adapter.
+func (d Dependencies) Tracker() string { return d.tracker }
+
+// TrackerConfig returns a defensive copy of the effective tracker config.
+func (d Dependencies) TrackerConfig() config.TrackerConfig {
+	copied := d.config
+	copied.InternalGroups = append([]string(nil), d.config.InternalGroups...)
+	copied.Unknown = maps.Clone(d.config.Unknown)
+	return copied
+}
+
+// DBPath returns the credential/session store path.
+func (d Dependencies) DBPath() string { return d.dbPath }
+
+// HTTPClient returns the shared bounded client.
+func (d Dependencies) HTTPClient() *http.Client { return d.http }
+
+// Logger returns the adapter diagnostic sink.
+func (d Dependencies) Logger() api.Logger { return d.logger }
+
+// Registry returns the composed tracker registry when construction occurs through the duplicate service.
+func (d Dependencies) Registry() *trackerspkg.Registry { return d.registry }
+
+// BoundConfig returns a minimal config snapshot containing only this adapter's bound inputs.
+// It exists for tracker protocol helpers shared with upload/auth code; it never contains unrelated app config.
+func (d Dependencies) BoundConfig() config.Config {
+	return config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: d.dbPath},
+		Trackers:     config.TrackersConfig{Trackers: map[string]config.TrackerConfig{d.tracker: d.TrackerConfig()}},
+	}
+}
+
+// Factory constructs one tracker-bound duplicate adapter.
+type Factory interface {
+	// NewDuplicateAdapter constructs an adapter bound to one tracker and dependency set.
+	NewDuplicateAdapter(Dependencies) Adapter
+}
+
+// Adapter returns tracker protocol facts for one immutable Prepared release view.
+type Adapter interface {
+	// Search performs one tracker protocol lookup and returns a structural outcome.
+	Search(context.Context, api.DuplicateSubject) AdapterResult
+}
+
+// AdapterFunc adapts a function to Adapter.
+type AdapterFunc func(context.Context, api.DuplicateSubject) AdapterResult
+
+// Search invokes f.
+func (f AdapterFunc) Search(ctx context.Context, meta api.DuplicateSubject) AdapterResult {
+	return f(ctx, meta)
+}
+
+type adapterResultData struct {
+	disposition Disposition
+	entries     []api.DupeEntry
+	notes       []string
+	code        string
+	safeMessage string
+	cause       error
+}
+
+// AdapterResult is an immutable, constructor-created tracker protocol outcome.
+type AdapterResult struct{ data *adapterResultData }
+
+// Resolved constructs a successful adapter outcome.
+func Resolved(entries []api.DupeEntry, notes []string) AdapterResult {
+	return AdapterResult{data: &adapterResultData{
+		disposition: DispositionResolved,
+		entries:     cloneEntries(entries),
+		notes:       cloneNotes(notes),
+	}}
+}
+
+// NotRun constructs an explicit non-executed adapter outcome.
+func NotRun(code string, safeMessage string, notes []string) AdapterResult {
+	return AdapterResult{data: &adapterResultData{
+		disposition: DispositionNotRun,
+		code:        strings.TrimSpace(code),
+		safeMessage: strings.TrimSpace(safeMessage),
+		notes:       cloneNotes(notes),
+	}}
+}
+
+// Failed constructs an explicit failed adapter outcome. Cause remains diagnostic-only.
+func Failed(code string, safeMessage string, cause error) AdapterResult {
+	return AdapterResult{data: &adapterResultData{
+		disposition: DispositionFailed,
+		code:        strings.TrimSpace(code),
+		safeMessage: strings.TrimSpace(safeMessage),
+		cause:       cause,
+	}}
+}
+
+// Disposition returns the structural adapter outcome class.
+func (r AdapterResult) Disposition() Disposition {
+	if r.data == nil {
+		return DispositionInvalid
+	}
+	return r.data.disposition
+}
+
+// Entries returns a defensive copy of resolved evidence.
+func (r AdapterResult) Entries() []api.DupeEntry {
+	if r.data == nil {
+		return nil
+	}
+	return cloneEntries(r.data.entries)
+}
+
+// Notes returns display-only notes.
+func (r AdapterResult) Notes() []string {
+	if r.data == nil {
+		return nil
+	}
+	return cloneNotes(r.data.notes)
+}
+
+// Code returns the stable disposition code.
+func (r AdapterResult) Code() string {
+	if r.data == nil {
+		return ""
+	}
+	return r.data.code
+}
+
+// SafeMessage returns the adapter-provided public-safe message.
+func (r AdapterResult) SafeMessage() string {
+	if r.data == nil {
+		return ""
+	}
+	return r.data.safeMessage
+}
+
+// Cause returns the diagnostic failure cause. Callers must not project it publicly.
+func (r AdapterResult) Cause() error { return r.cause() }
+
+func (r AdapterResult) cause() error {
+	if r.data == nil {
+		return nil
+	}
+	return r.data.cause
+}
+
+func validNotRunCode(code string) bool {
+	_, ok := validNotRunCodes[strings.TrimSpace(code)]
+	return ok
+}
+
+func validFailureCode(code string) bool {
+	_, ok := validFailureCodes[strings.TrimSpace(code)]
+	return ok
+}
+
+func cloneNotes(notes []string) []string {
+	out := make([]string, 0, len(notes))
+	for _, note := range notes {
+		if note = strings.TrimSpace(note); note != "" {
+			out = append(out, note)
+		}
+	}
+	return out
+}
+
+func cloneEntries(entries []api.DupeEntry) []api.DupeEntry {
+	out := make([]api.DupeEntry, len(entries))
+	for idx, entry := range entries {
+		entry.Files = append([]string(nil), entry.Files...)
+		entry.Flags = append([]string(nil), entry.Flags...)
+		out[idx] = entry
+	}
+	return out
+}
diff --git a/internal/trackers/family.go b/internal/trackers/family.go
new file mode 100644
index 00000000..9b446021
--- /dev/null
+++ b/internal/trackers/family.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+// Family identifies a tracker protocol family.
+type Family string
+
+const (
+	// FamilyUnknown identifies an unclassified tracker.
+	FamilyUnknown Family = ""
+	// FamilyUnit3D identifies trackers built on Unit3D.
+	FamilyUnit3D Family = "unit3d"
+	// FamilyAZFamily identifies trackers using the AvistaZ-family protocol.
+	FamilyAZFamily Family = "azfamily"
+	// FamilyStandalone identifies trackers with standalone implementations.
+	FamilyStandalone Family = "standalone"
+)
diff --git a/internal/trackers/image_host_policy.go b/internal/trackers/image_host_policy.go
index 20c57638..1179d641 100644
--- a/internal/trackers/image_host_policy.go
+++ b/internal/trackers/image_host_policy.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
+	imagehostpolicy "github.com/autobrr/upbrr/internal/imagehosting/policy"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -21,10 +21,14 @@ type imageHostPolicy struct {
 	fallbackOK  bool
 }
 
+// ImageUploadTarget identifies one host upload required by a tracker set.
 type ImageUploadTarget struct {
-	Host       string
+	// Host is the normalized uploader name.
+	Host string
+	// UsageScope groups uploads that may share one hosted variant.
 	UsageScope string
-	Trackers   []string
+	// Trackers lists the trackers whose policies require this target.
+	Trackers []string
 }
 
 type imageUploadPolicyTarget struct {
@@ -33,21 +37,27 @@ type imageUploadPolicyTarget struct {
 	candidates []string
 }
 
-func policyForTracker(tracker string, trackerCfg config.TrackerConfig) imageHostPolicy {
-	return policyFromShared(imagehostpolicy.ForTracker(tracker, trackerCfg.ImgRehost, trackerCfg.ImgAPI))
+func policyForTrackerWithRegistry(registry *Registry, tracker string, trackerCfg config.TrackerConfig) imageHostPolicy {
+	if declared, ok := registry.LookupImageHostPolicy(tracker); ok {
+		if declared.DisableWithoutRehost && !trackerCfg.ImgRehost {
+			return imageHostPolicy{}
+		}
+		if declared.DisableWithoutAPI && strings.TrimSpace(trackerCfg.ImgAPI) == "" {
+			return imageHostPolicy{}
+		}
+		return newImageHostPolicy(declared.AllowedHosts...)
+	}
+	return imageHostPolicy{}
 }
 
-func policyForTrackerWithConfig(tracker string, appCfg config.Config, trackerCfg config.TrackerConfig) imageHostPolicy {
-	if lostimgEnabledForTracker(appCfg, tracker) {
-		return newImageHostPolicy("lostimg")
+func policyForTrackerWithConfigAndRegistry(registry *Registry, tracker string, appCfg config.Config, trackerCfg config.TrackerConfig) imageHostPolicy {
+	if host, enabled := conditionalImageHost(registry, appCfg, tracker, trackerCfg); enabled {
+		return newImageHostPolicy(host)
 	}
-	if reelflixEnabledForTracker(tracker, trackerCfg) {
-		return newImageHostPolicy("reelflix")
-	}
-	return policyForTracker(tracker, trackerCfg)
+	return policyForTrackerWithRegistry(registry, tracker, trackerCfg)
 }
 
-func applyImageHostOverrides(tracker string, policy imageHostPolicy, overrides api.ImageHostOverrides) (imageHostPolicy, error) {
+func applyImageHostOverrides(registry *Registry, tracker string, policy imageHostPolicy, overrides api.ImageHostOverrides) (imageHostPolicy, error) {
 	if overrides.PreferredHost == nil {
 		return policy, nil
 	}
@@ -55,7 +65,7 @@ func applyImageHostOverrides(tracker string, policy imageHostPolicy, overrides a
 	if host == "" {
 		return policy, nil
 	}
-	if owner := trackerForOwnedHost(host); owner != "" && !strings.EqualFold(owner, tracker) {
+	if owner := trackerForOwnedHost(registry, host); owner != "" && !strings.EqualFold(owner, tracker) {
 		return imageHostPolicy{}, fmt.Errorf("trackers: %s image host override %q is owned by %s", strings.TrimSpace(tracker), host, owner)
 	}
 	if !supportedUploadImageHost(host) {
@@ -65,23 +75,33 @@ func applyImageHostOverrides(tracker string, policy imageHostPolicy, overrides a
 		return newPreferredImageHostPolicy(host), nil
 	}
 	if !hostAllowed(host, policy.allowed) {
-		return imageHostPolicy{}, fmt.Errorf("trackers: %s image host override %q is not allowed (allowed: %s)", strings.TrimSpace(tracker), host, strings.Join(policy.allowed, ", "))
+		return imageHostPolicy{}, fmt.Errorf(
+			"trackers: %s image host override %q is not allowed (allowed: %s)",
+			strings.TrimSpace(tracker),
+			host,
+			strings.Join(policy.allowed, ", "),
+		)
 	}
 	policy.preferred = prependHost(host, policy.preferred)
 	policy.fallbackOK = true
 	return policy, nil
 }
 
-func resolveImageHostPolicy(tracker string, trackerCfg config.TrackerConfig, overrides api.ImageHostOverrides) (imageHostPolicy, error) {
-	policy := policyForTracker(tracker, trackerCfg)
+func resolveImageHostPolicyWithRegistry(
+	registry *Registry,
+	tracker string,
+	trackerCfg config.TrackerConfig,
+	overrides api.ImageHostOverrides,
+) (imageHostPolicy, error) {
+	policy := policyForTrackerWithRegistry(registry, tracker, trackerCfg)
 	host := strings.ToLower(strings.TrimSpace(trackerCfg.ImageHost))
 	if host == "" {
-		return applyImageHostOverrides(tracker, policy, overrides)
+		return applyImageHostOverrides(registry, tracker, policy, overrides)
 	}
 	if !supportedUploadImageHost(host) {
 		return imageHostPolicy{}, fmt.Errorf("trackers: %s configured image_host %q is unsupported", strings.TrimSpace(tracker), trackerCfg.ImageHost)
 	}
-	if owner := trackerForOwnedHost(host); owner != "" && !strings.EqualFold(owner, tracker) {
+	if owner := trackerForOwnedHost(registry, host); owner != "" && !strings.EqualFold(owner, tracker) {
 		return imageHostPolicy{}, fmt.Errorf("trackers: %s configured image_host %q is owned by %s", strings.TrimSpace(tracker), trackerCfg.ImageHost, owner)
 	}
 	if len(policy.allowed) > 0 && !hostAllowed(host, policy.allowed) {
@@ -95,38 +115,55 @@ func resolveImageHostPolicy(tracker string, trackerCfg config.TrackerConfig, ove
 	return policy, nil
 }
 
-func resolveImageHostPolicyForMetadata(tracker string, appCfg config.Config, trackerCfg config.TrackerConfig, _ api.PreparedMetadata, overrides api.ImageHostOverrides) (imageHostPolicy, error) {
+func resolveImageHostPolicyForMetadataWithRegistry(
+	registry *Registry,
+	tracker string,
+	appCfg config.Config,
+	trackerCfg config.TrackerConfig,
+	overrides api.ImageHostOverrides,
+) (imageHostPolicy, error) {
 	host := strings.ToLower(strings.TrimSpace(trackerCfg.ImageHost))
-	if host == "lostimg" && !lostimgEnabledForTracker(appCfg, tracker) {
-		trackerCfg.ImageHost = ""
-	}
-	if host == "reelflix" && !reelflixEnabledForTracker(tracker, trackerCfg) {
+	if conditionalHost, enabled := conditionalImageHost(registry, appCfg, tracker, trackerCfg); host == conditionalHost && !enabled {
 		trackerCfg.ImageHost = ""
 	}
 	if strings.TrimSpace(trackerCfg.ImageHost) != "" || overrides.PreferredHost != nil {
-		policy, err := resolveImageHostPolicy(tracker, trackerCfg, overrides)
+		policy, err := resolveImageHostPolicyWithRegistry(registry, tracker, trackerCfg, overrides)
 		if err != nil {
 			return imageHostPolicy{}, err
 		}
-		return withUnrestrictedImageHostFallbacks(tracker, policy, appCfg), nil
+		return withUnrestrictedImageHostFallbacks(registry, tracker, policy, appCfg), nil
 	}
-	policy := policyForTrackerWithConfig(tracker, appCfg, trackerCfg)
-	policy, err := applyImageHostOverrides(tracker, policy, overrides)
+	policy := policyForTrackerWithConfigAndRegistry(registry, tracker, appCfg, trackerCfg)
+	policy, err := applyImageHostOverrides(registry, tracker, policy, overrides)
 	if err != nil {
 		return imageHostPolicy{}, err
 	}
-	return withUnrestrictedImageHostFallbacks(tracker, policy, appCfg), nil
+	return withUnrestrictedImageHostFallbacks(registry, tracker, policy, appCfg), nil
 }
 
-func PreferredImageUploadHost(tracker string, trackerCfg config.TrackerConfig, overrides api.ImageHostOverrides) (string, error) {
-	policy, err := resolveImageHostPolicy(tracker, trackerCfg, overrides)
+// PreferredImageUploadHostWithRegistry resolves a preferred host from the tracker's registered policy.
+func PreferredImageUploadHostWithRegistry(
+	registry *Registry,
+	tracker string,
+	trackerCfg config.TrackerConfig,
+	overrides api.ImageHostOverrides,
+) (string, error) {
+	policy, err := resolveImageHostPolicyWithRegistry(registry, tracker, trackerCfg, overrides)
 	if err != nil {
 		return "", err
 	}
 	return preferredHost(policy), nil
 }
 
-func RequiredImageUploadTargets(appCfg config.Config, trackerNames []string, overrides api.ImageHostOverrides) ([]ImageUploadTarget, error) {
+// RequiredImageUploadTargets returns policy-preferred upload targets in tracker
+// order, deduplicated by host and usage scope while retaining every dependent
+// tracker.
+func RequiredImageUploadTargets(
+	registry *Registry,
+	appCfg config.Config,
+	trackerNames []string,
+	overrides api.ImageHostOverrides,
+) ([]ImageUploadTarget, error) {
 	targets := make([]ImageUploadTarget, 0, len(trackerNames))
 	seen := make(map[string]int, len(trackerNames))
 	for _, tracker := range trackerNames {
@@ -135,7 +172,7 @@ func RequiredImageUploadTargets(appCfg config.Config, trackerNames []string, ove
 			continue
 		}
 		trackerCfg := trackerConfigForImageHostPolicy(appCfg, name)
-		policy, err := resolveImageHostPolicy(name, trackerCfg, overrides)
+		policy, err := resolveImageHostPolicyWithRegistry(registry, name, trackerCfg, overrides)
 		if err != nil {
 			return nil, err
 		}
@@ -143,7 +180,7 @@ func RequiredImageUploadTargets(appCfg config.Config, trackerNames []string, ove
 		if host == "" {
 			continue
 		}
-		scope := usageScopeForHost(host)
+		scope := usageScopeForHost(registry, host)
 		// Use a null-byte separator to build an unambiguous host+scope dedupe key.
 		// Host/scope values are expected not to contain \x00, avoiding concat collisions.
 		key := host + "\x00" + scope
@@ -161,7 +198,9 @@ func RequiredImageUploadTargets(appCfg config.Config, trackerNames []string, ove
 	return targets, nil
 }
 
-func ConfiguredImageUploadTargets(appCfg config.Config, trackerNames []string) ([]ImageUploadTarget, error) {
+// ConfiguredImageUploadTargets returns only explicitly configured tracker image
+// hosts, deduplicated by host and usage scope in tracker order.
+func ConfiguredImageUploadTargets(registry *Registry, appCfg config.Config, trackerNames []string) ([]ImageUploadTarget, error) {
 	targets := make([]ImageUploadTarget, 0, len(trackerNames))
 	seen := make(map[string]int, len(trackerNames))
 	for _, tracker := range trackerNames {
@@ -173,7 +212,7 @@ func ConfiguredImageUploadTargets(appCfg config.Config, trackerNames []string) (
 		if strings.TrimSpace(trackerCfg.ImageHost) == "" {
 			continue
 		}
-		policy, err := resolveImageHostPolicy(name, trackerCfg, api.ImageHostOverrides{})
+		policy, err := resolveImageHostPolicyWithRegistry(registry, name, trackerCfg, api.ImageHostOverrides{})
 		if err != nil {
 			return nil, err
 		}
@@ -181,7 +220,7 @@ func ConfiguredImageUploadTargets(appCfg config.Config, trackerNames []string) (
 		if host == "" {
 			continue
 		}
-		scope := usageScopeForHost(host)
+		scope := usageScopeForHost(registry, host)
 		// Use a null-byte separator to build an unambiguous host+scope dedupe key.
 		// Host/scope values are expected not to contain \x00, avoiding concat collisions.
 		key := host + "\x00" + scope
@@ -199,15 +238,32 @@ func ConfiguredImageUploadTargets(appCfg config.Config, trackerNames []string) (
 	return targets, nil
 }
 
-func NeededImageUploadTargets(appCfg config.Config, trackerNames []string, selectedHost string) ([]ImageUploadTarget, error) {
-	return neededImageUploadTargets(appCfg, trackerNames, selectedHost, nil, nil)
-}
-
-func NeededImageUploadTargetsForMetadata(appCfg config.Config, trackerNames []string, selectedHost string, meta api.PreparedMetadata) ([]ImageUploadTarget, error) {
-	return neededImageUploadTargets(appCfg, trackerNames, selectedHost, nil, &meta)
-}
-
-func NeededImageUploadTargetsExcluding(appCfg config.Config, trackerNames []string, selectedHost string, excludedHosts []string) ([]ImageUploadTarget, error) {
+// NeededImageUploadTargetsWithRegistry chooses the smallest policy-compatible
+// host set not already satisfied by selectedHost, preserving deterministic
+// tracker and host preference order.
+func NeededImageUploadTargetsWithRegistry(registry *Registry, appCfg config.Config, trackerNames []string, selectedHost string) ([]ImageUploadTarget, error) {
+	return neededImageUploadTargets(registry, appCfg, trackerNames, selectedHost, nil, nil)
+}
+
+// NeededImageUploadTargetsForMetadataWithRegistry resolves image upload targets from tracker-owned policies.
+func NeededImageUploadTargetsForMetadataWithRegistry(
+	registry *Registry,
+	appCfg config.Config,
+	trackerNames []string,
+	selectedHost string,
+	meta api.UploadSubject,
+) ([]ImageUploadTarget, error) {
+	return neededImageUploadTargets(registry, appCfg, trackerNames, selectedHost, nil, &meta)
+}
+
+// NeededImageUploadTargetsExcludingWithRegistry returns unsatisfied targets except excluded hosts.
+func NeededImageUploadTargetsExcludingWithRegistry(
+	registry *Registry,
+	appCfg config.Config,
+	trackerNames []string,
+	selectedHost string,
+	excludedHosts []string,
+) ([]ImageUploadTarget, error) {
 	excluded := make(map[string]struct{}, len(excludedHosts))
 	for _, host := range excludedHosts {
 		normalized := strings.ToLower(strings.TrimSpace(host))
@@ -215,10 +271,18 @@ func NeededImageUploadTargetsExcluding(appCfg config.Config, trackerNames []stri
 			excluded[normalized] = struct{}{}
 		}
 	}
-	return neededImageUploadTargets(appCfg, trackerNames, selectedHost, excluded, nil)
+	return neededImageUploadTargets(registry, appCfg, trackerNames, selectedHost, excluded, nil)
 }
 
-func NeededImageUploadTargetsForMetadataExcluding(appCfg config.Config, trackerNames []string, selectedHost string, excludedHosts []string, meta api.PreparedMetadata) ([]ImageUploadTarget, error) {
+// NeededImageUploadTargetsForMetadataExcludingWithRegistry resolves fallback targets from tracker-owned policies.
+func NeededImageUploadTargetsForMetadataExcludingWithRegistry(
+	registry *Registry,
+	appCfg config.Config,
+	trackerNames []string,
+	selectedHost string,
+	excludedHosts []string,
+	meta api.UploadSubject,
+) ([]ImageUploadTarget, error) {
 	excluded := make(map[string]struct{}, len(excludedHosts))
 	for _, host := range excludedHosts {
 		normalized := strings.ToLower(strings.TrimSpace(host))
@@ -226,12 +290,19 @@ func NeededImageUploadTargetsForMetadataExcluding(appCfg config.Config, trackerN
 			excluded[normalized] = struct{}{}
 		}
 	}
-	return neededImageUploadTargets(appCfg, trackerNames, selectedHost, excluded, &meta)
+	return neededImageUploadTargets(registry, appCfg, trackerNames, selectedHost, excluded, &meta)
 }
 
-func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selectedHost string, excludedHosts map[string]struct{}, meta *api.PreparedMetadata) ([]ImageUploadTarget, error) {
+func neededImageUploadTargets(
+	registry *Registry,
+	appCfg config.Config,
+	trackerNames []string,
+	selectedHost string,
+	excludedHosts map[string]struct{},
+	meta *api.UploadSubject,
+) ([]ImageUploadTarget, error) {
 	selectedHost = strings.ToLower(strings.TrimSpace(selectedHost))
-	userHosts := configuredImageUploadHosts(appCfg)
+	userHosts := configuredImageUploadHosts(registry, appCfg)
 	targets := make([]ImageUploadTarget, 0, len(trackerNames)+1)
 	seen := make(map[string]int, len(trackerNames)+1)
 
@@ -244,7 +315,7 @@ func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selec
 			return
 		}
 		name := strings.ToUpper(strings.TrimSpace(tracker))
-		scope := usageScopeForHost(host)
+		scope := usageScopeForHost(registry, host)
 		key := host + "\x00" + scope
 		if idx, ok := seen[key]; ok {
 			targets[idx].Trackers = appendUniqueTracker(targets[idx].Trackers, name)
@@ -266,7 +337,7 @@ func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selec
 		}
 		trackerCfg := trackerConfigForImageHostPolicy(appCfg, name)
 		if strings.TrimSpace(trackerCfg.ImageHost) != "" {
-			policy, err := resolveImageHostPolicyForTarget(name, appCfg, trackerCfg, meta)
+			policy, err := resolveImageHostPolicyForTarget(registry, name, appCfg, trackerCfg, meta)
 			if err != nil {
 				return nil, err
 			}
@@ -276,21 +347,29 @@ func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selec
 					continue
 				}
 			}
-			flexibleTargets = append(flexibleTargets, imageUploadPolicyTarget{tracker: name, policy: policy, candidates: userHosts})
+			flexibleTargets = append(flexibleTargets, imageUploadPolicyTarget{
+				tracker:    name,
+				policy:     policy,
+				candidates: userHosts,
+			})
 			continue
 		}
 
-		policy := policyForTrackerForTarget(name, appCfg, trackerCfg)
-		candidates := imageUploadCandidatesForTracker(appCfg, name, userHosts)
-		candidates = appendOwnedPolicyUploadHosts(candidates, name, policy)
-		flexibleTargets = append(flexibleTargets, imageUploadPolicyTarget{tracker: name, policy: policy, candidates: candidates})
+		policy := policyForTrackerForTarget(registry, name, appCfg, trackerCfg)
+		candidates := imageUploadCandidatesForTracker(registry, appCfg, name, userHosts)
+		candidates = appendOwnedPolicyUploadHosts(registry, candidates, name, policy)
+		flexibleTargets = append(flexibleTargets, imageUploadPolicyTarget{
+			tracker:    name,
+			policy:     policy,
+			candidates: candidates,
+		})
 	}
 
-	if selectedHost != "" && trackerForOwnedHost(selectedHost) == "" && hostInList(selectedHost, userHosts) {
+	if selectedHost != "" && trackerForOwnedHost(registry, selectedHost) == "" && hostInList(selectedHost, userHosts) {
 		if _, excluded := excludedHosts[selectedHost]; !excluded && len(flexibleTargets) > 0 {
 			usableForAllFlexible := true
 			for _, target := range flexibleTargets {
-				if !imageHostUsableForPolicy(target.tracker, selectedHost, target.policy) {
+				if !imageHostUsableForPolicy(registry, target.tracker, selectedHost, target.policy) {
 					usableForAllFlexible = false
 					break
 				}
@@ -304,9 +383,9 @@ func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selec
 		}
 	}
 
-	assignFlexibleImageUploadTargets(flexibleTargets, excludedHosts, targets, addTarget)
+	assignFlexibleImageUploadTargets(registry, flexibleTargets, excludedHosts, targets, addTarget)
 
-	if len(targets) == 0 && selectedHost != "" && trackerForOwnedHost(selectedHost) == "" && hostInList(selectedHost, userHosts) {
+	if len(targets) == 0 && selectedHost != "" && trackerForOwnedHost(registry, selectedHost) == "" && hostInList(selectedHost, userHosts) {
 		if _, excluded := excludedHosts[selectedHost]; excluded {
 			return targets, nil
 		}
@@ -316,10 +395,16 @@ func neededImageUploadTargets(appCfg config.Config, trackerNames []string, selec
 	return targets, nil
 }
 
-func assignFlexibleImageUploadTargets(flexibleTargets []imageUploadPolicyTarget, excludedHosts map[string]struct{}, targets []ImageUploadTarget, addTarget func(string, string)) {
+func assignFlexibleImageUploadTargets(
+	registry *Registry,
+	flexibleTargets []imageUploadPolicyTarget,
+	excludedHosts map[string]struct{},
+	targets []ImageUploadTarget,
+	addTarget func(string, string),
+) {
 	unassigned := make([]imageUploadPolicyTarget, 0, len(flexibleTargets))
 	for _, target := range flexibleTargets {
-		if host, ok := existingImageUploadTargetHost(target.tracker, target.policy, target.candidates, targets); ok {
+		if host, ok := existingImageUploadTargetHost(registry, target.tracker, target.policy, target.candidates, targets); ok {
 			addTarget(host, target.tracker)
 			continue
 		}
@@ -327,13 +412,13 @@ func assignFlexibleImageUploadTargets(flexibleTargets []imageUploadPolicyTarget,
 	}
 
 	for len(unassigned) > 0 {
-		host := bestImageUploadTargetHost(unassigned, excludedHosts)
+		host := bestImageUploadTargetHost(registry, unassigned, excludedHosts)
 		if host == "" {
 			break
 		}
 		next := unassigned[:0]
 		for _, target := range unassigned {
-			if imageHostUsableForPolicy(target.tracker, host, target.policy) {
+			if imageHostUsableForPolicy(registry, target.tracker, host, target.policy) {
 				addTarget(host, target.tracker)
 				continue
 			}
@@ -343,22 +428,28 @@ func assignFlexibleImageUploadTargets(flexibleTargets []imageUploadPolicyTarget,
 	}
 }
 
-func existingImageUploadTargetHost(tracker string, policy imageHostPolicy, candidates []string, targets []ImageUploadTarget) (string, bool) {
+func existingImageUploadTargetHost(
+	registry *Registry,
+	tracker string,
+	policy imageHostPolicy,
+	candidates []string,
+	targets []ImageUploadTarget,
+) (string, bool) {
 	for _, target := range targets {
 		if !hostInList(target.Host, candidates) {
 			continue
 		}
-		if imageHostUsableForPolicy(tracker, target.Host, policy) {
+		if imageHostUsableForPolicy(registry, tracker, target.Host, policy) {
 			return target.Host, true
 		}
 	}
 	return "", false
 }
 
-func bestImageUploadTargetHost(targets []imageUploadPolicyTarget, excludedHosts map[string]struct{}) string {
+func bestImageUploadTargetHost(registry *Registry, targets []imageUploadPolicyTarget, excludedHosts map[string]struct{}) string {
 	rankings := make(map[string]imageUploadHostRanking, len(targets))
 	for _, target := range targets {
-		for idx, host := range candidateImageUploadTargetHosts(target.tracker, target.policy, target.candidates, excludedHosts) {
+		for idx, host := range candidateImageUploadTargetHosts(registry, target.tracker, target.policy, target.candidates, excludedHosts) {
 			ranking := rankings[host]
 			ranking.host = host
 			ranking.count++
@@ -398,14 +489,20 @@ func betterImageUploadHostRanking(candidate imageUploadHostRanking, current imag
 	return candidate.host < current.host
 }
 
-func candidateImageUploadTargetHosts(tracker string, policy imageHostPolicy, candidates []string, excludedHosts map[string]struct{}) []string {
+func candidateImageUploadTargetHosts(
+	registry *Registry,
+	tracker string,
+	policy imageHostPolicy,
+	candidates []string,
+	excludedHosts map[string]struct{},
+) []string {
 	hostsByName := make(map[string]struct{}, len(candidates))
 	for _, host := range candidates {
 		normalizedHost := strings.ToLower(strings.TrimSpace(host))
 		if _, excluded := excludedHosts[normalizedHost]; excluded {
 			continue
 		}
-		if imageHostUsableForPolicy(tracker, normalizedHost, policy) {
+		if imageHostUsableForPolicy(registry, tracker, normalizedHost, policy) {
 			hostsByName[normalizedHost] = struct{}{}
 		}
 	}
@@ -429,28 +526,31 @@ func candidateImageUploadTargetHosts(tracker string, policy imageHostPolicy, can
 	return hosts
 }
 
-func resolveImageHostPolicyForTarget(tracker string, appCfg config.Config, trackerCfg config.TrackerConfig, meta *api.PreparedMetadata) (imageHostPolicy, error) {
+func resolveImageHostPolicyForTarget(
+	registry *Registry,
+	tracker string,
+	appCfg config.Config,
+	trackerCfg config.TrackerConfig,
+	meta *api.UploadSubject,
+) (imageHostPolicy, error) {
 	if meta == nil {
-		policy, err := resolveImageHostPolicy(tracker, trackerCfg, api.ImageHostOverrides{})
+		policy, err := resolveImageHostPolicyWithRegistry(registry, tracker, trackerCfg, api.ImageHostOverrides{})
 		if err != nil {
 			return imageHostPolicy{}, err
 		}
-		return withUnrestrictedImageHostFallbacks(tracker, policy, appCfg), nil
+		return withUnrestrictedImageHostFallbacks(registry, tracker, policy, appCfg), nil
 	}
-	return resolveImageHostPolicyForMetadata(tracker, appCfg, trackerCfg, *meta, api.ImageHostOverrides{})
+	return resolveImageHostPolicyForMetadataWithRegistry(registry, tracker, appCfg, trackerCfg, api.ImageHostOverrides{})
 }
 
-func policyForTrackerForTarget(tracker string, appCfg config.Config, trackerCfg config.TrackerConfig) imageHostPolicy {
-	return policyForTrackerWithConfig(tracker, appCfg, trackerCfg)
+func policyForTrackerForTarget(registry *Registry, tracker string, appCfg config.Config, trackerCfg config.TrackerConfig) imageHostPolicy {
+	return policyForTrackerWithConfigAndRegistry(registry, tracker, appCfg, trackerCfg)
 }
 
-func imageUploadCandidatesForTracker(appCfg config.Config, tracker string, userHosts []string) []string {
+func imageUploadCandidatesForTracker(registry *Registry, appCfg config.Config, tracker string, userHosts []string) []string {
 	candidates := append([]string(nil), userHosts...)
-	if lostimgEnabledForTracker(appCfg, tracker) {
-		candidates = appendUniqueHost(candidates, "lostimg")
-	}
-	if reelflixEnabledForTracker(tracker, trackerConfigForImageHostPolicy(appCfg, tracker)) {
-		candidates = appendUniqueHost(candidates, "reelflix")
+	if host, enabled := conditionalImageHost(registry, appCfg, tracker, trackerConfigForImageHostPolicy(appCfg, tracker)); enabled {
+		candidates = appendUniqueHost(candidates, host)
 	}
 	return candidates
 }
@@ -458,43 +558,46 @@ func imageUploadCandidatesForTracker(appCfg config.Config, tracker string, userH
 // appendOwnedPolicyUploadHosts adds upload-capable policy hosts owned by the
 // target tracker. Owned hosts are intentionally absent from the global host
 // list and must retain their tracker-scoped upload target.
-func appendOwnedPolicyUploadHosts(candidates []string, tracker string, policy imageHostPolicy) []string {
+func appendOwnedPolicyUploadHosts(registry *Registry, candidates []string, tracker string, policy imageHostPolicy) []string {
 	for _, host := range policy.uploadHosts {
-		if owner := trackerForOwnedHost(host); owner != "" && strings.EqualFold(owner, tracker) {
+		if owner := trackerForOwnedHost(registry, host); owner != "" && strings.EqualFold(owner, tracker) {
 			candidates = appendUniqueHost(candidates, host)
 		}
 	}
 	return candidates
 }
 
-func configuredImageUploadHosts(appCfg config.Config) []string {
+func configuredImageUploadHosts(registry *Registry, appCfg config.Config) []string {
 	cfg := appCfg.ImageHosting
-	return normalizeConfiguredImageUploadHosts(cfg.Host1, cfg.Host2, cfg.Host3, cfg.Host4, cfg.Host5, cfg.Host6)
+	return normalizeConfiguredImageUploadHosts(registry, cfg.Host1, cfg.Host2, cfg.Host3, cfg.Host4, cfg.Host5, cfg.Host6)
 }
 
-func lostimgEnabledForTracker(appCfg config.Config, tracker string) bool {
-	if !strings.EqualFold(strings.TrimSpace(tracker), "LST") {
-		return false
+func conditionalImageHost(registry *Registry, appCfg config.Config, tracker string, trackerCfg config.TrackerConfig) (string, bool) {
+	declared, ok := registry.LookupImageHostPolicy(tracker)
+	if !ok {
+		return "", false
 	}
-	cfg := appCfg.ImageHosting
-	return cfg.LostimgEnabled
-}
-
-func reelflixEnabledForTracker(tracker string, trackerCfg config.TrackerConfig) bool {
-	if !strings.EqualFold(strings.TrimSpace(tracker), "RF") {
-		return false
+	host := strings.ToLower(strings.TrimSpace(declared.ConditionalHost))
+	if host == "" {
+		return "", false
 	}
-	return strings.EqualFold(strings.TrimSpace(trackerCfg.ImageHost), "reelflix")
+	if declared.EnableWithLostimg && appCfg.ImageHosting.LostimgEnabled {
+		return host, true
+	}
+	if declared.EnableWhenConfigured && strings.EqualFold(strings.TrimSpace(trackerCfg.ImageHost), host) {
+		return host, true
+	}
+	return host, false
 }
 
-func normalizeConfiguredImageUploadHosts(hosts ...string) []string {
+func normalizeConfiguredImageUploadHosts(registry *Registry, hosts ...string) []string {
 	out := make([]string, 0, len(hosts))
 	for _, host := range hosts {
 		normalized := strings.ToLower(strings.TrimSpace(host))
 		if normalized == "" || !supportedUploadImageHost(normalized) {
 			continue
 		}
-		if trackerForOwnedHost(normalized) != "" {
+		if trackerForOwnedHost(registry, normalized) != "" {
 			continue
 		}
 		out = appendUniqueHost(out, normalized)
@@ -502,12 +605,12 @@ func normalizeConfiguredImageUploadHosts(hosts ...string) []string {
 	return out
 }
 
-func imageHostUsableForPolicy(tracker string, host string, policy imageHostPolicy) bool {
+func imageHostUsableForPolicy(registry *Registry, tracker string, host string, policy imageHostPolicy) bool {
 	host = strings.ToLower(strings.TrimSpace(host))
 	if host == "" || !supportedUploadImageHost(host) {
 		return false
 	}
-	if owner := trackerForOwnedHost(host); owner != "" && !strings.EqualFold(owner, tracker) {
+	if owner := trackerForOwnedHost(registry, host); owner != "" && !strings.EqualFold(owner, tracker) {
 		return false
 	}
 	return len(policy.allowed) == 0 || hostAllowed(host, policy.allowed)
@@ -572,12 +675,12 @@ func newPreferredImageHostPolicy(host string, fallbackHosts ...string) imageHost
 	}
 }
 
-func withUnrestrictedImageHostFallbacks(tracker string, policy imageHostPolicy, appCfg config.Config) imageHostPolicy {
+func withUnrestrictedImageHostFallbacks(registry *Registry, tracker string, policy imageHostPolicy, appCfg config.Config) imageHostPolicy {
 	if !policy.required || len(policy.allowed) > 0 || !policy.fallbackOK {
 		return policy
 	}
-	for _, host := range imageUploadCandidatesForTracker(appCfg, tracker, configuredImageUploadHosts(appCfg)) {
-		if !imageHostUsableForPolicy(tracker, host, policy) {
+	for _, host := range imageUploadCandidatesForTracker(registry, appCfg, tracker, configuredImageUploadHosts(registry, appCfg)) {
+		if !imageHostUsableForPolicy(registry, tracker, host, policy) {
 			continue
 		}
 		policy.uploadHosts = appendUniqueHost(policy.uploadHosts, host)
@@ -586,15 +689,6 @@ func withUnrestrictedImageHostFallbacks(tracker string, policy imageHostPolicy,
 	return policy
 }
 
-func policyFromShared(policy imagehostpolicy.Policy) imageHostPolicy {
-	return imageHostPolicy{
-		allowed:     append([]string(nil), policy.AllowedHosts...),
-		uploadHosts: append([]string(nil), policy.UploadHosts...),
-		preferred:   append([]string(nil), policy.PreferredHosts...),
-		required:    policy.Required,
-	}
-}
-
 func uploadHostsFor(hosts []string) []string {
 	out := make([]string, 0, len(hosts))
 	for _, host := range hosts {
diff --git a/internal/trackers/image_host_policy_test.go b/internal/trackers/image_host_policy_test.go
index fc52bed4..5c55c36a 100644
--- a/internal/trackers/image_host_policy_test.go
+++ b/internal/trackers/image_host_policy_test.go
@@ -10,6 +10,23 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+func imageHostPolicyTestRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	for _, name := range []string{"AITHER", "GPW", "HDB", "HHD", "LST", "OE", "PTP", "RF", "STC"} {
+		policy := testImageHostPolicyForTracker(name)
+		if err := registry.RegisterDescriptor(Descriptor{
+			Name:       name,
+			Definition: stubDefinition{name: name},
+			Family:     testTrackerFamily(name),
+			ImageHost:  policy,
+		}); err != nil {
+			t.Fatalf("register %s image host policy: %v", name, err)
+		}
+	}
+	return registry
+}
+
 func TestResolveImageHostPolicy(t *testing.T) {
 	t.Parallel()
 
@@ -74,7 +91,7 @@ func TestResolveImageHostPolicy(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			policy, err := resolveImageHostPolicy(tc.tracker, tc.cfg, tc.overrides)
+			policy, err := resolveImageHostPolicyWithRegistry(imageHostPolicyTestRegistry(t), tc.tracker, tc.cfg, tc.overrides)
 			if (err != nil) != tc.wantErr {
 				if tc.wantErr {
 					t.Fatal("expected owned host override to fail for other tracker")
@@ -130,7 +147,7 @@ func TestResolveImageHostPolicy(t *testing.T) {
 func TestNeededImageUploadTargetsFallsBackFromTrackerConfiguredHostForUnrestrictedTracker(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargetsExcluding(config.Config{
+	targets, err := NeededImageUploadTargetsExcludingWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "pixhost",
 			Host2: "imgbb",
@@ -152,7 +169,7 @@ func TestNeededImageUploadTargetsFallsBackFromTrackerConfiguredHostForUnrestrict
 func TestNeededImageUploadTargetsDoesNotFallbackToUnsupportedHostForRestrictedTracker(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargetsExcluding(config.Config{
+	targets, err := NeededImageUploadTargetsExcludingWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "pixhost",
 			Host2: "imgbox",
@@ -174,7 +191,7 @@ func TestNeededImageUploadTargetsDoesNotFallbackToUnsupportedHostForRestrictedTr
 func TestNeededImageUploadTargetsChoosesSharedApprovedHost(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 			Host2: "imgbox",
@@ -197,7 +214,7 @@ func TestNeededImageUploadTargetsChoosesSharedApprovedHost(t *testing.T) {
 func TestNeededImageUploadTargetsUsesConfiguredHostPriority(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "pixhost",
 			Host2: "imgbox",
@@ -218,7 +235,7 @@ func TestNeededImageUploadTargetsUsesConfiguredHostPriority(t *testing.T) {
 func TestNeededImageUploadTargetsDoesNotUseUnconfiguredPolicyHost(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
@@ -237,8 +254,9 @@ func TestNeededImageUploadTargetsDoesNotUseUnconfiguredPolicyHost(t *testing.T)
 func TestCandidateImageUploadTargetHostsUsesTrackerPolicyPreference(t *testing.T) {
 	t.Parallel()
 
-	policy := policyForTracker("PTP", config.TrackerConfig{})
-	hosts := candidateImageUploadTargetHosts("PTP", policy, []string{"imgbb", "pixhost"}, map[string]struct{}{})
+	registry := imageHostPolicyTestRegistry(t)
+	policy := policyForTrackerWithRegistry(registry, "PTP", config.TrackerConfig{})
+	hosts := candidateImageUploadTargetHosts(registry, "PTP", policy, []string{"imgbb", "pixhost"}, map[string]struct{}{})
 	if got, want := len(hosts), 2; got != want {
 		t.Fatalf("expected %d hosts, got %#v", want, hosts)
 	}
@@ -250,7 +268,7 @@ func TestCandidateImageUploadTargetHostsUsesTrackerPolicyPreference(t *testing.T
 func TestNeededImageUploadTargetsAllowsTrackerConfiguredHost(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
@@ -271,7 +289,7 @@ func TestNeededImageUploadTargetsAllowsTrackerConfiguredHost(t *testing.T) {
 func TestNeededImageUploadTargetsDoesNotShareTrackerConfiguredHostUnlessGloballyConfigured(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
@@ -299,7 +317,7 @@ func TestNeededImageUploadTargetsDoesNotShareTrackerConfiguredHostUnlessGlobally
 func TestNeededImageUploadTargetsUsesConfiguredLostimgForLST(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1:          "imgbb",
 			LostimgEnabled: true,
@@ -320,7 +338,7 @@ func TestNeededImageUploadTargetsUsesConfiguredLostimgForLST(t *testing.T) {
 func TestNeededImageUploadTargetsSkipsLostimgWhenDisabled(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
@@ -336,7 +354,7 @@ func TestNeededImageUploadTargetsSkipsLostimgWhenDisabled(t *testing.T) {
 func TestNeededImageUploadTargetsUsesConfiguredReelflixForRF(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
@@ -360,7 +378,7 @@ func TestNeededImageUploadTargetsUsesConfiguredReelflixForRF(t *testing.T) {
 func TestNeededImageUploadTargetsSkipsReelflixWhenDisabled(t *testing.T) {
 	t.Parallel()
 
-	targets, err := NeededImageUploadTargets(config.Config{
+	targets, err := NeededImageUploadTargetsWithRegistry(imageHostPolicyTestRegistry(t), config.Config{
 		ImageHosting: config.ImageHostingConfig{
 			Host1: "imgbb",
 		},
diff --git a/internal/trackers/image_host_resolution.go b/internal/trackers/image_host_resolution.go
index 879fb91d..e68667fc 100644
--- a/internal/trackers/image_host_resolution.go
+++ b/internal/trackers/image_host_resolution.go
@@ -19,10 +19,10 @@ import (
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
 	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	dbsvc "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -52,35 +52,33 @@ var descriptionSlotImageBlockedIPRanges = []netip.Prefix{
 
 var descriptionSlotImageLookupIPAddrs = net.DefaultResolver.LookupIPAddr
 
-func ensureDescriptionImageHost(
+func ensureDescriptionImageHostWithRegistry(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
+	meta api.UploadSubject,
 	appCfg config.Config,
 	trackerCfg config.TrackerConfig,
-	repo api.MetadataRepository,
+	repo UploadPersistence,
 	images api.ImageHostingService,
-	logger api.Logger,
+	registry *Registry,
 ) (descriptionImageHostResolution, error) {
-	return ensureDescriptionImageHostWithData(ctx, tracker, meta, appCfg, trackerCfg, repo, images, logger, nil)
+	return ensureDescriptionImageHostWithDataAndRegistry(ctx, tracker, meta, appCfg, trackerCfg, repo, images, api.NopLogger{}, registry, nil)
 }
 
-// ensureDescriptionImageHostWithData resolves description screenshots against a
-// tracker's image-host rules, uploading local-only slots when a preferred host
-// is supplied and no reusable hosted variant already exists.
-func ensureDescriptionImageHostWithData(
+func ensureDescriptionImageHostWithDataAndRegistry(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
+	meta api.UploadSubject,
 	appCfg config.Config,
 	trackerCfg config.TrackerConfig,
-	repo api.MetadataRepository,
+	repo UploadPersistence,
 	images api.ImageHostingService,
 	logger api.Logger,
+	registry *Registry,
 	preloaded *preloadedDescriptionAssetData,
 	preferredHosts ...string,
 ) (descriptionImageHostResolution, error) {
-	policy, err := resolveImageHostPolicyForMetadata(tracker, appCfg, trackerCfg, meta, meta.ImageHostOverrides)
+	policy, err := resolveImageHostPolicyForMetadataWithRegistry(registry, tracker, appCfg, trackerCfg, meta.ImageHostOverrides)
 	if err != nil {
 		return descriptionImageHostResolution{}, err
 	}
@@ -94,7 +92,7 @@ func ensureDescriptionImageHostWithData(
 		return descriptionImageHostResolution{feedback: feedback}, nil
 	}
 
-	slots, err := screenshotSlotsForImageHostResolution(ctx, tracker, meta, repo, logger, preloaded, skipUpload)
+	slots, err := screenshotSlotsForImageHostResolution(ctx, tracker, meta, repo, logger, preloaded, registry, skipUpload)
 	if err != nil {
 		if logger != nil {
 			logger.Debugf("trackers: image host resolution screenshot slots failed tracker=%s: %v", tracker, err)
@@ -119,7 +117,11 @@ func ensureDescriptionImageHostWithData(
 		if err == nil && len(screenshots) > 0 {
 			feedback.SelectedHost = host
 			feedback.Message = buildReuseMessage(tracker, host, usageScope, false)
-			return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
+			return descriptionImageHostResolution{
+				screenshots: screenshots,
+				feedback:    feedback,
+				usageScope:  usageScope,
+			}, nil
 		}
 		urls := resolveTrackerImageURLs(ctx, tracker, meta, repo, logger, preloaded)
 		screenshots = resolveTrackerScreenshots(urls)
@@ -128,23 +130,41 @@ func ensureDescriptionImageHostWithData(
 			feedback.Message = buildReuseMessage(tracker, feedback.SelectedHost, globalImageUsageScope, false)
 		}
 		if len(screenshots) > 0 || preferredHost == "" {
-			return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: globalImageUsageScope}, nil
+			return descriptionImageHostResolution{
+				screenshots: screenshots,
+				feedback:    feedback,
+				usageScope:  globalImageUsageScope,
+			}, nil
 		}
 		policy = optionalImageHostUploadPolicy(policy, preferredHosts...)
 		selectionPolicy = reusableImageHostSelectionPolicy(policy, preferredHosts...)
 	}
 
-	if screenshots, host, usageScope, err := selectScreenshotsFromSlots(tracker, slots, selectionPolicy); err == nil && len(screenshots) > 0 && reusableSelectionMatchesPolicy(host, selectionPolicy) {
+	if screenshots, host, usageScope, err := selectScreenshotsFromSlots(
+		tracker,
+		slots,
+		selectionPolicy,
+	); err == nil && len(screenshots) > 0 &&
+		reusableSelectionMatchesPolicy(host, selectionPolicy) {
 		feedback.SelectedHost = host
 		feedback.Message = buildReuseMessage(tracker, host, usageScope, host != preferredHost(selectionPolicy))
-		return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
-	} else if err != nil && allRenderableSlotsHaveEligibleVariant(slots, tracker, selectionPolicy) {
+		return descriptionImageHostResolution{
+			screenshots: screenshots,
+			feedback:    feedback,
+			usageScope:  usageScope,
+		}, nil
+	} else if err != nil &&
+		allRenderableSlotsHaveEligibleVariant(slots, tracker, selectionPolicy) {
 		return descriptionImageHostResolution{}, err
 	}
 
 	if skipUpload {
 		feedback.Status = "warning"
-		feedback.Message = fmt.Sprintf("%s requires screenshots from %s, but automatic image-host uploads are disabled.", tracker, imageHostRequirementLabel(policy))
+		feedback.Message = fmt.Sprintf(
+			"%s requires screenshots from %s, but automatic image-host uploads are disabled.",
+			tracker,
+			imageHostRequirementLabel(policy),
+		)
 		return descriptionImageHostResolution{feedback: feedback}, nil
 	}
 
@@ -163,7 +183,15 @@ func ensureDescriptionImageHostWithData(
 		if appendSourceImageSlots(&slots, meta.SourcePath, localTrackerImages) {
 			changed = true
 		}
-		if materialized, materializeChanged := materializeDescriptionSlotImages(ctx, meta, appCfg, tracker, slots, logger); len(materialized) > 0 || materializeChanged {
+		if materialized, materializeChanged := materializeDescriptionSlotImages(
+			ctx,
+			meta,
+			appCfg,
+			tracker,
+			slots,
+			logger,
+		); len(materialized) > 0 ||
+			materializeChanged {
 			changed = changed || materializeChanged
 		}
 		if changed {
@@ -176,18 +204,30 @@ func ensureDescriptionImageHostWithData(
 	}
 	if len(sourceImages) == 0 {
 		urls := resolveTrackerImageURLs(ctx, tracker, meta, repo, logger, preloaded)
-		if screenshots, host := resolveTrackerScreenshotsForAllowedHost(urls, selectionPolicy); len(screenshots) > 0 && reusableSelectionMatchesPolicy(host, selectionPolicy) {
+		if screenshots, host := resolveTrackerScreenshotsForAllowedHost(
+			urls,
+			selectionPolicy,
+		); len(screenshots) > 0 &&
+			reusableSelectionMatchesPolicy(host, selectionPolicy) {
 			feedback.SelectedHost = host
 			feedback.Message = buildReuseMessage(tracker, host, globalImageUsageScope, host != preferredHost(selectionPolicy))
-			return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: globalImageUsageScope}, nil
+			return descriptionImageHostResolution{
+				screenshots: screenshots,
+				feedback:    feedback,
+				usageScope:  globalImageUsageScope,
+			}, nil
 		}
 		feedback.Status = "warning"
-		feedback.Message = fmt.Sprintf("%s requires screenshots from %s, but no local screenshots are available to rehost.", tracker, imageHostRequirementLabel(policy))
+		feedback.Message = fmt.Sprintf(
+			"%s requires screenshots from %s, but no local screenshots are available to rehost.",
+			tracker,
+			imageHostRequirementLabel(policy),
+		)
 		return descriptionImageHostResolution{feedback: feedback}, nil
 	}
 
 	for _, host := range reusableHostCandidates(selectionPolicy) {
-		usageScope := usageScopeForHost(host)
+		usageScope := usageScopeForHost(registry, host)
 		screenshots, err := reusableUploadedScreenshotsForHost(ctx, tracker, meta, repo, preloaded, host, usageScope, sourceImages)
 		if err != nil {
 			return descriptionImageHostResolution{}, err
@@ -195,7 +235,11 @@ func ensureDescriptionImageHostWithData(
 		if len(screenshots) > 0 {
 			feedback.SelectedHost = host
 			feedback.Message = buildReuseMessage(tracker, host, usageScope, host != preferredHost(selectionPolicy))
-			return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
+			return descriptionImageHostResolution{
+				screenshots: screenshots,
+				feedback:    feedback,
+				usageScope:  usageScope,
+			}, nil
 		}
 	}
 
@@ -204,10 +248,14 @@ func ensureDescriptionImageHostWithData(
 		if screenshots, host, usageScope, err := selectScreenshotsFromSlots(tracker, slots, fallbackPolicy); err == nil && len(screenshots) > 0 {
 			feedback.SelectedHost = host
 			feedback.Message = buildReuseMessage(tracker, host, usageScope, host != preferredHost(selectionPolicy))
-			return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
+			return descriptionImageHostResolution{
+				screenshots: screenshots,
+				feedback:    feedback,
+				usageScope:  usageScope,
+			}, nil
 		}
 		for _, host := range reusableHostCandidates(fallbackPolicy) {
-			usageScope := usageScopeForHost(host)
+			usageScope := usageScopeForHost(registry, host)
 			screenshots, err := reusableUploadedScreenshotsForHost(ctx, tracker, meta, repo, preloaded, host, usageScope, sourceImages)
 			if err != nil {
 				return descriptionImageHostResolution{}, err
@@ -215,7 +263,11 @@ func ensureDescriptionImageHostWithData(
 			if len(screenshots) > 0 {
 				feedback.SelectedHost = host
 				feedback.Message = buildReuseMessage(tracker, host, usageScope, host != preferredHost(selectionPolicy))
-				return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
+				return descriptionImageHostResolution{
+					screenshots: screenshots,
+					feedback:    feedback,
+					usageScope:  usageScope,
+				}, nil
 			}
 		}
 		feedback.Status = "warning"
@@ -225,8 +277,8 @@ func ensureDescriptionImageHostWithData(
 
 	var lastErr error
 	for _, host := range uploadAttemptHosts(policy, preferredHosts...) {
-		usageScope := usageScopeForHost(host)
-		uploaded, err := images.Upload(ctx, meta, host, usageScope, sourceImages)
+		usageScope := usageScopeForHost(registry, host)
+		uploaded, err := images.Upload(ctx, imageHostingSubject(meta), host, usageScope, sourceImages)
 		if err != nil {
 			lastErr = err
 			if len(uploaded) > 0 {
@@ -285,7 +337,11 @@ func ensureDescriptionImageHostWithData(
 		} else {
 			feedback.Message = uploadSuccessMessage(tracker, host, usageScope, feedback.Warnings)
 		}
-		return descriptionImageHostResolution{screenshots: screenshots, feedback: feedback, usageScope: usageScope}, nil
+		return descriptionImageHostResolution{
+			screenshots: screenshots,
+			feedback:    feedback,
+			usageScope:  usageScope,
+		}, nil
 	}
 
 	feedback.Status = "warning"
@@ -301,6 +357,23 @@ func ensureDescriptionImageHostWithData(
 	return descriptionImageHostResolution{feedback: feedback, blocking: true}, nil
 }
 
+func imageHostingSubject(meta api.UploadSubject) api.ImageHostingSubject {
+	galleryName := ""
+	for _, candidate := range []string{
+		meta.ReleaseName,
+		meta.ReleaseNameNoTag,
+		meta.Release.Title,
+		meta.Filename,
+		filepath.Base(meta.SourcePath),
+	} {
+		if trimmed := strings.TrimSpace(candidate); trimmed != "" {
+			galleryName = trimmed
+			break
+		}
+	}
+	return api.ImageHostingSubject{SourcePath: meta.SourcePath, GalleryName: galleryName}
+}
+
 func firstPreferredDescriptionImageHost(hosts []string) string {
 	for _, host := range hosts {
 		normalized := strings.ToLower(strings.TrimSpace(host))
@@ -354,32 +427,34 @@ func imageHostRequirementLabel(policy imageHostPolicy) string {
 	return "a configured image host"
 }
 
-func imageHostUploadSkipped(meta api.PreparedMetadata) bool {
+func imageHostUploadSkipped(meta api.UploadSubject) bool {
 	return meta.ImageHostOverrides.SkipUpload != nil && *meta.ImageHostOverrides.SkipUpload
 }
 
 func screenshotSlotsForImageHostResolution(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	logger api.Logger,
 	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
 	skipUpload bool,
 ) ([]api.ScreenshotSlot, error) {
 	if !skipUpload {
-		return screenshotSlotsFromSource(ctx, tracker, meta, repo, logger, preloaded)
+		return screenshotSlotsFromSource(ctx, tracker, meta, repo, logger, preloaded, registry)
 	}
-	return screenshotSlotsFromSourceWithoutPersist(ctx, tracker, meta, repo, logger, preloaded)
+	return screenshotSlotsFromSourceWithoutPersist(ctx, tracker, meta, repo, logger, preloaded, registry)
 }
 
 func screenshotSlotsFromSourceWithoutPersist(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	logger api.Logger,
 	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
 ) ([]api.ScreenshotSlot, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("trackers: load screenshot slots canceled: %w", err)
@@ -413,7 +488,7 @@ func screenshotSlotsFromSourceWithoutPersist(
 		return cloneScreenshotSlots(slots), nil
 	}
 
-	slots, err = synthesizeScreenshotSlots(ctx, tracker, meta, repo, logger, preloaded)
+	slots, err = synthesizeScreenshotSlots(ctx, tracker, meta, repo, logger, preloaded, registry)
 	if err != nil {
 		return nil, err
 	}
@@ -423,8 +498,8 @@ func screenshotSlotsFromSourceWithoutPersist(
 func reusableUploadedScreenshotsForHost(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	preloaded *preloadedDescriptionAssetData,
 	host string,
 	usageScope string,
@@ -482,7 +557,7 @@ func reusableUploadedScreenshotsForHost(
 	return screenshots, nil
 }
 
-func cleanupUploadedImages(ctx context.Context, repo api.MetadataRepository, sourcePath string, uploaded []api.UploadedImageLink, logger api.Logger) {
+func cleanupUploadedImages(ctx context.Context, repo UploadPersistence, sourcePath string, uploaded []api.UploadedImageLink, logger api.Logger) {
 	if repo == nil || len(uploaded) == 0 || strings.TrimSpace(sourcePath) == "" {
 		return
 	}
@@ -499,7 +574,13 @@ func cleanupUploadedImages(ctx context.Context, repo api.MetadataRepository, sou
 		}
 		seen[key] = struct{}{}
 		if err := repo.DeleteUploadedImage(ctx, sourcePath, pathValue, hostValue); err != nil && logger != nil {
-			logger.Warnf("trackers: failed to roll back uploaded image tracker=%s host=%s path=%s: %v", strings.TrimSpace(sourcePath), hostValue, pathValue, err)
+			logger.Warnf(
+				"trackers: failed to roll back uploaded image tracker=%s host=%s path=%s: %v",
+				strings.TrimSpace(sourcePath),
+				hostValue,
+				pathValue,
+				err,
+			)
 		}
 	}
 }
@@ -657,7 +738,7 @@ func resolveTrackerScreenshotsForAllowedHost(urls []string, policy imageHostPoli
 	return nil, ""
 }
 
-func resolveLocalTrackerScreenshots(meta api.PreparedMetadata, appCfg config.Config, tracker string, logger api.Logger) []api.ScreenshotImage {
+func resolveLocalTrackerScreenshots(meta api.UploadSubject, appCfg config.Config, tracker string, logger api.Logger) []api.ScreenshotImage {
 	if strings.TrimSpace(meta.SourcePath) == "" {
 		return nil
 	}
@@ -668,7 +749,7 @@ func resolveLocalTrackerScreenshots(meta api.PreparedMetadata, appCfg config.Con
 		}
 		return nil
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		if logger != nil {
 			logger.Debugf("trackers: local tracker screenshots release dir failed tracker=%s: %v", tracker, err)
@@ -720,7 +801,7 @@ func slotsContainComparison(slots []api.ScreenshotSlot) bool {
 
 func materializeDescriptionSlotImages(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta api.UploadSubject,
 	appCfg config.Config,
 	tracker string,
 	slots []api.ScreenshotSlot,
@@ -736,7 +817,7 @@ func materializeDescriptionSlotImages(
 		}
 		return nil, false
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		if logger != nil {
 			logger.Debugf("trackers: description slot image release dir failed tracker=%s: %v", tracker, err)
@@ -966,7 +1047,8 @@ func resolveDescriptionSlotImagePublicAddrs(ctx context.Context, host string) ([
 
 func isDescriptionSlotPublicIP(addr netip.Addr) bool {
 	addr = addr.Unmap()
-	if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() || addr.IsUnspecified() {
+	if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() ||
+		addr.IsUnspecified() {
 		return false
 	}
 	for _, blocked := range descriptionSlotImageBlockedIPRanges {
@@ -981,7 +1063,7 @@ func isDescriptionSlotImageContentType(contentType string) bool {
 	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(contentType)), "image/")
 }
 
-func prioritizedTrackerRecords(meta api.PreparedMetadata, tracker string) []api.TrackerMetadata {
+func prioritizedTrackerRecords(meta api.UploadSubject, tracker string) []api.TrackerMetadata {
 	if len(meta.TrackerData) == 0 {
 		return nil
 	}
diff --git a/internal/trackers/image_host_resolution_test.go b/internal/trackers/image_host_resolution_test.go
index b0ee07e2..85309b1a 100644
--- a/internal/trackers/image_host_resolution_test.go
+++ b/internal/trackers/image_host_resolution_test.go
@@ -52,7 +52,7 @@ func TestEnsureDescriptionImageHostSkipUploadDoesNotMaterializeURLOnlySlots(t *t
 	skipUpload := true
 	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
 	repo := &imageHostResolutionRepo{stubRepo: &stubRepo{}}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath:          sourcePath,
 		DescriptionOverride: "[center][img]http://8.8.8.8/image.gif[/img][/center]",
 		ImageHostOverrides: api.ImageHostOverrides{
@@ -62,7 +62,9 @@ func TestEnsureDescriptionImageHostSkipUploadDoesNotMaterializeURLOnlySlots(t *t
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")}}
 	trackerCfg := config.TrackerConfig{ImageHost: "imgbox"}
 
-	resolution, err := ensureDescriptionImageHostWithData(context.Background(), "MTV", meta, cfg, trackerCfg, repo, &stubImageService{}, api.NopLogger{}, nil)
+	resolution, err := ensureDescriptionImageHostWithDataAndRegistry(
+		context.Background(), "MTV", meta, cfg, trackerCfg, repo, &stubImageService{}, api.NopLogger{}, descriptionAssetsTestRegistry(t), nil,
+	)
 	if err != nil {
 		t.Fatalf("ensure image host: %v", err)
 	}
@@ -285,7 +287,7 @@ func TestMaterializeDescriptionSlotImagesKeepsRetryStateOnDownloadFailure(t *tes
 		SectionKind:         screenshotSectionWrapped,
 		RenderInScreenshots: true,
 	}}
-	meta := api.PreparedMetadata{SourcePath: "source.mkv"}
+	meta := api.UploadSubject{SourcePath: "source.mkv"}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")}}
 
 	results, changed := materializeDescriptionSlotImages(context.Background(), meta, cfg, "AITHER", slots, api.NopLogger{})
@@ -323,7 +325,7 @@ func TestMaterializeDescriptionSlotImagesPreservesExistingLocalImagePath(t *test
 		SectionKind:         screenshotSectionWrapped,
 		RenderInScreenshots: true,
 	}}
-	meta := api.PreparedMetadata{SourcePath: "source.mkv"}
+	meta := api.UploadSubject{SourcePath: "source.mkv"}
 	cfg := config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "upbrr.db")}}
 
 	results, changed := materializeDescriptionSlotImages(context.Background(), meta, cfg, "AITHER", slots, api.NopLogger{})
diff --git a/internal/trackers/image_host_scope.go b/internal/trackers/image_host_scope.go
index 3d010a55..950b1c09 100644
--- a/internal/trackers/image_host_scope.go
+++ b/internal/trackers/image_host_scope.go
@@ -3,11 +3,7 @@
 
 package trackers
 
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
-)
+import "strings"
 
 const globalImageUsageScope = "global"
 
@@ -37,21 +33,21 @@ func trackerImageUsageScope(tracker string) string {
 	return "tracker:" + trimmed
 }
 
-func usageScopeForHost(host string) string {
-	owner := trackerForOwnedHost(host)
+func usageScopeForHost(registry *Registry, host string) string {
+	owner := trackerForOwnedHost(registry, host)
 	if owner == "" {
 		return globalImageUsageScope
 	}
 	return trackerImageUsageScope(owner)
 }
 
-func trackerForOwnedHost(host string) string {
-	return imagehostpolicy.OwnerForHost(host)
+func trackerForOwnedHost(registry *Registry, host string) string {
+	return registry.OwnerForImageHost(host)
 }
 
-// TrackerForOwnedImageHost returns the owning tracker name for the provided image host string, or an empty string when unowned.
-func TrackerForOwnedImageHost(host string) string {
-	return trackerForOwnedHost(host)
+// TrackerForOwnedImageHost returns the registry owner for an image host.
+func TrackerForOwnedImageHost(registry *Registry, host string) string {
+	return trackerForOwnedHost(registry, host)
 }
 
 // TrackerImageUsageScope returns the normalized image usage scope string for the provided tracker name.
diff --git a/internal/trackers/impl/ant/definition.go b/internal/trackers/impl/ant/definition.go
deleted file mode 100644
index 7c5d3dd3..00000000
--- a/internal/trackers/impl/ant/definition.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ant
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "ANT"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-
-	return trackers.DescriptionResult{
-		Group:       "ant",
-		Description: strings.TrimSpace(description),
-	}, nil
-}
diff --git a/internal/trackers/impl/ant/definition_test.go b/internal/trackers/impl/ant/definition_test.go
deleted file mode 100644
index cff91031..00000000
--- a/internal/trackers/impl/ant/definition_test.go
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ant
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildUploadDryRunIncludesQuestionnaire(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "ANT",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Genres: "Adult", Keywords: "adult"},
-			},
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		AppConfig:     config.Config{},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Questionnaire == nil {
-		t.Fatal("expected questionnaire")
-	}
-	if got := len(entry.Questionnaire.Fields); got != 3 {
-		t.Fatalf("expected 3 questionnaire fields, got %d", got)
-	}
-	if entry.Questionnaire.Fields[0].Key != "type" {
-		t.Fatalf("expected type field first, got %q", entry.Questionnaire.Fields[0].Key)
-	}
-	if entry.Questionnaire.Fields[0].Kind != "select" {
-		t.Fatalf("expected type field to use select control, got %q", entry.Questionnaire.Fields[0].Kind)
-	}
-	if got := len(entry.Questionnaire.Fields[0].Options); got != 4 {
-		t.Fatalf("expected 4 type options, got %d", got)
-	}
-	if entry.Questionnaire.Fields[2].Kind != "select" {
-		t.Fatalf("expected adult screens field to use select control, got %q", entry.Questionnaire.Fields[2].Kind)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunMarksManualTagsWhenOnlyIMDbGenresExist(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "ANT",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123},
-			ExternalMetadata: api.ExternalMetadata{
-				IMDB: &api.IMDBMetadata{Genres: "Action, Drama"},
-			},
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		AppConfig:     config.Config{},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got := entry.Payload["flagchangereason"]; got != "User prompted to add tags manually" {
-		t.Fatalf("expected manual tag prompt reason, got %q", got)
-	}
-	if _, ok := entry.Payload["tags"]; ok {
-		t.Fatalf("expected imdb fallback genres to avoid automatic ANT tags, got %#v", entry.Payload)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunUsesBDInfoForBDMV(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "db.sqlite")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	sourcePath := filepath.Join(tmp, "Movie", "BDMV")
-	if err := os.MkdirAll(sourcePath, 0o700); err != nil {
-		t.Fatalf("create source path: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		SourcePath:            sourcePath,
-		TorrentPath:           torrentPath,
-		DiscType:              "BDMV",
-		SelectedBDMVPlaylists: []api.PlaylistInfo{{File: "00001.MPLS"}},
-		ExternalIDs:           api.ExternalIDs{TMDBID: 123},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{Genres: "Action"},
-		},
-		TrackerQuestionnaireAnswers: map[string]map[string]string{
-			"ANT": {"type": "Feature Film"},
-		},
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(filepath.Join(tmp, "tmp"), meta, sourcePath)
-	if err != nil {
-		t.Fatalf("resolve temp dir: %v", err)
-	}
-	bdinfoPath := paths.BDMVSummaryPath(tmpDir, "00001.MPLS")
-	if err := os.WriteFile(bdinfoPath, []byte("BDINFO_CONTENT"), 0o600); err != nil {
-		t.Fatalf("write bdinfo: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker:       "ANT",
-		Meta:          meta,
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got := entry.Payload["bdinfo"]; got != "BDINFO_CONTENT" {
-		t.Fatalf("expected BDInfo payload, got %q", got)
-	}
-	if got := entry.Payload["container_type"]; got != "m2ts" {
-		t.Fatalf("expected m2ts container type, got %q", got)
-	}
-	if _, ok := entry.Payload["mediainfo"]; ok {
-		t.Fatalf("expected BDMV upload to omit mediainfo, got %#v", entry.Payload)
-	}
-	if _, ok := entry.Payload["media"]; ok {
-		t.Fatalf("expected BDMV upload to omit media field, got %#v", entry.Payload)
-	}
-}
-
-func TestResolveFlagsIncludesIMAXAndCriterionEdition(t *testing.T) {
-	t.Parallel()
-
-	flags := resolveFlags(api.PreparedMetadata{Edition: "IMAX Criterion Collection"})
-	if !containsString(flags, "IMAX") {
-		t.Fatalf("expected IMAX flag, got %#v", flags)
-	}
-	if !containsString(flags, "Criterion") {
-		t.Fatalf("expected Criterion flag from edition, got %#v", flags)
-	}
-}
-
-func TestResolveReleaseGroupBansUpdatedGroups(t *testing.T) {
-	t.Parallel()
-
-	for _, group := range []string{"EVO", "SM737"} {
-		if got, ok := resolveReleaseGroup(group); ok || got != "" {
-			t.Fatalf("expected %s to be banned, got %q ok=%t", group, got, ok)
-		}
-	}
-	if got, ok := resolveReleaseGroup("Flights"); !ok || got != "Flights" {
-		t.Fatalf("expected Flights to be allowed, got %q ok=%t", got, ok)
-	}
-}
-
-func TestBuildDescriptionRemovesScreenshotOnlyBlockAndDefaultSignature(t *testing.T) {
-	description := buildDescription(trackers.UploadRequest{}, trackers.DescriptionAssets{
-		Description: `[align=center]
-[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
-[/align]
-
-[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
-	})
-	if strings.TrimSpace(description) != "" {
-		t.Fatalf("expected screenshot-only/signature-only description removed, got %q", description)
-	}
-}
-
-func containsString(values []string, target string) bool {
-	return slices.Contains(values, target)
-}
diff --git a/internal/trackers/impl/ant/description_assets_test.go b/internal/trackers/impl/ant/description_assets_test.go
deleted file mode 100644
index 1e6064d0..00000000
--- a/internal/trackers/impl/ant/description_assets_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ant
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
-		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
-	}
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "ANT",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader: "Disc menu token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "https://images.example.invalid/menu.png")
-	if strings.Contains(result.Description, "normal.png") {
-		t.Fatalf("normal screenshot leaked into ANT description: %q", result.Description)
-	}
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = New().BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "ANT", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/ant/upload.go b/internal/trackers/impl/ant/upload.go
deleted file mode 100644
index e532253e..00000000
--- a/internal/trackers/impl/ant/upload.go
+++ /dev/null
@@ -1,790 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ant
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const antUploadURL = "https://anthelion.me/api.php"
-
-var antTorrentIDPattern = regexp.MustCompile(`id=(\d+)`)
-var antDefaultSignaturePattern = regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`)
-var antEmptyURLPattern = regexp.MustCompile(`(?is)\[url=[^\]]*]\s*\[/url\]`)
-
-var antBannedReleaseGroups = map[string]struct{}{
-	"3LTON": {}, "4yEo": {}, "ADE": {}, "AFG": {}, "AniHLS": {}, "AnimeRG": {}, "AniURL": {}, "AROMA": {}, "aXXo": {}, "Brrip": {},
-	"CHD": {}, "CM8": {}, "CrEwSaDe": {}, "d3g": {}, "DDR": {}, "DNL": {}, "DeadFish": {}, "ELiTE": {}, "eSc": {}, "EVO": {}, "FaNGDiNG0": {},
-	"FGT": {}, "FRDS": {}, "FUM": {}, "HAiKU": {}, "HD2DVD": {}, "HDS": {}, "HDTime": {}, "Hi10": {}, "ION10": {},
-	"iPlanet": {}, "JIVE": {}, "KiNGDOM": {}, "Leffe": {}, "LiGaS": {}, "LOAD": {}, "MeGusta": {}, "MkvCage": {}, "mHD": {}, "mSD": {},
-	"NhaNc3": {}, "nHD": {}, "NOIVTC": {}, "nSD": {}, "Oj": {}, "Ozlem": {}, "PiRaTeS": {}, "PRoDJi": {}, "RAPiDCOWS": {}, "RARBG": {},
-	"RetroPeeps": {}, "RDN": {}, "REsuRRecTioN": {}, "RMTeam": {}, "SANTi": {}, "SicFoI": {}, "SPASM": {}, "SM737": {}, "SPDVD": {}, "STUTTERSHIT": {}, "TBS": {},
-	"Telly": {}, "TM": {}, "UPiNSMOKE": {}, "URANiME": {}, "WAF": {}, "xRed": {}, "XS": {}, "YIFY": {}, "YTS": {}, "Zeus": {}, "ZKBL": {}, "ZmN": {}, "ZMNT": {},
-}
-
-type uploadState struct {
-	torrentPath  string
-	description  string
-	fields       map[string]string
-	adultContent bool
-	manualTags   bool
-	typeName     string
-	tags         string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, antUploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ANT request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ANT upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ANT read response: %w", err)
-	}
-
-	payload := map[string]any{}
-	if len(bodyBytes) > 0 {
-		if err := json.Unmarshal(bodyBytes, &payload); err != nil {
-			if resp.StatusCode >= 200 && resp.StatusCode < 300 {
-				return api.UploadSummary{}, errors.New("trackers: ANT json decode error, the API is probably down")
-			}
-		}
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 || !antUploadSuccess(payload) {
-		return api.UploadSummary{}, antUploadError(resp.StatusCode, payload, bodyBytes)
-	}
-
-	viewURL := strings.TrimSpace(stringValue(payload["view"]))
-	if viewURL == "" {
-		viewURL = strings.TrimSpace(stringValue(payload["link"]))
-	}
-	torrentID := ""
-	if matches := antTorrentIDPattern.FindStringSubmatch(viewURL); len(matches) > 1 {
-		torrentID = strings.TrimSpace(matches[1])
-	}
-
-	artifactPath := ""
-	if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "ANT")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, viewURL, "ANT"); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "ANT",
-			TorrentID:   torrentID,
-			DownloadURL: viewURL,
-			TorrentURL:  viewURL,
-			TorrentPath: artifactPath,
-		}},
-	}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "ANT",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "ant",
-		Description:      state.description,
-		Endpoint:         antUploadURL,
-		Payload:          state.fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file_input",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-		Questionnaire: buildQuestionnaire(req.Meta, state),
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	select {
-	case <-ctx.Done():
-		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: ANT missing api_key")
-	}
-	if req.Meta.ExternalIDs.TMDBID == 0 {
-		return uploadState{}, errors.New("trackers: ANT missing tmdb id")
-	}
-
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	descriptionAssets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		descriptionAssets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, descriptionAssets)
-
-	answers := questionnaireAnswers(req.Meta)
-	typeName, typeID := resolveType(req.Meta, answers)
-	audio := resolveAudioFormat(req.Meta)
-	flags := resolveFlags(req.Meta)
-	tags, manualTags := resolveTags(req.Meta, answers)
-	adultContent := detectAdult(req.Meta)
-	safeScreens := resolveAdultScreensAllowed(answers, adultContent)
-	screenshots := resolveScreenshotPayload(descriptionAssets.Screenshots, safeScreens)
-	mediaFields, err := resolveMediaFields(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, err
-	}
-
-	fields := map[string]string{
-		"api_key":      strings.TrimSpace(req.TrackerConfig.APIKey),
-		"action":       "upload",
-		"tmdbid":       strconv.Itoa(req.Meta.ExternalIDs.TMDBID),
-		"type":         strconv.Itoa(typeID),
-		"audioformat":  audio,
-		"release_desc": description,
-		"screenshots":  screenshots,
-	}
-	maps.Copy(fields, mediaFields)
-	if len(flags) > 0 {
-		fields["flags[]"] = strings.Join(flags, ",")
-	}
-	if req.Meta.Scene {
-		fields["censored"] = "1"
-	}
-	if tags != "" {
-		fields["tags"] = tags
-	}
-	if releaseGroup, ok := resolveReleaseGroup(req.Meta.Tag); ok {
-		fields["releasegroup"] = releaseGroup
-	} else {
-		fields["noreleasegroup"] = "1"
-	}
-	if adultContent && screenshots != "" {
-		if !manualTags {
-			fields["flagchangereason"] = "Adult with screens uploaded with upbrr"
-		} else {
-			fields["flagchangereason"] = "Adult with screens uploaded with upbrr. User to add tags manually."
-		}
-	} else if manualTags {
-		fields["flagchangereason"] = "User prompted to add tags manually"
-	}
-
-	return uploadState{
-		torrentPath:  torrentPath,
-		description:  description,
-		fields:       fields,
-		adultContent: adultContent,
-		manualTags:   manualTags,
-		typeName:     typeName,
-		tags:         tags,
-	}, nil
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	var parts []string
-
-	// Base description
-	base := strings.TrimSpace(antDefaultSignaturePattern.ReplaceAllString(assets.Description, ""))
-	report := bbcode.CleanPTPDescription(base, meta.DiscType)
-	userDesc := strings.TrimSpace(report.Description)
-	if userDesc == "" && base != "" && len(report.Images) == 0 {
-		userDesc = base
-	}
-
-	if userDesc != "" {
-		// Custom Header
-		if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-			parts = append(parts, header)
-		}
-
-		// Logo
-		logoURL, _ := unit3d.ResolveLogo(meta, req.AppConfig)
-		if logoURL != "" {
-			if strings.HasSuffix(logoURL, ".svg") {
-				logoURL = strings.ReplaceAll(logoURL, ".svg", ".png")
-			}
-			parts = append(parts, "[align=center][img]"+logoURL+"[/img][/align]")
-		}
-
-		// User Description
-		parts = append(parts, userDesc)
-	}
-
-	// Disc menus
-	if len(assets.MenuImages) > 0 {
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		var shotParts []string
-		for _, img := range assets.MenuImages {
-			url := metautil.FirstNonEmptyTrimmed(img.RawURL, img.ImgURL, img.WebURL)
-			if url != "" {
-				shotParts = append(shotParts, "[img]"+url+"[/img]")
-			}
-		}
-		if len(shotParts) > 0 {
-			parts = append(parts, "[align=center]"+strings.Join(shotParts, " ")+"[/align]")
-		}
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && unit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// Join and finalize
-	description := strings.Join(parts, "\n\n")
-
-	finalized := bbcode.FinalizeTrackerDescription("ANT", description)
-
-	// Character replacements
-	replacer := strings.NewReplacer("•", "-", "’", "'", "–", "-")
-	finalized = replacer.Replace(finalized)
-
-	finalized = strings.TrimSpace(antEmptyURLPattern.ReplaceAllString(finalized, ""))
-
-	// Debug saving
-	if meta.Options.Debug {
-		unit3d.SaveDescriptionDebug(meta, "ANT", req.AppConfig.MainSettings.DBPath, finalized, req.Logger)
-	}
-
-	return finalized
-}
-
-func resolveMediaFields(meta api.PreparedMetadata, dbPath string) (map[string]string, error) {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		bdinfo, err := resolveBDInfo(meta, dbPath)
-		if err != nil {
-			return nil, err
-		}
-		if strings.TrimSpace(bdinfo) == "" {
-			return nil, errors.New("trackers: ANT missing BDInfo text")
-		}
-		return map[string]string{
-			"bdinfo":         bdinfo,
-			"container_type": "m2ts",
-		}, nil
-	}
-
-	if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
-		return nil, errors.New("trackers: ANT missing mediainfo text")
-	}
-	payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: ANT read mediainfo: %w", err)
-	}
-	return map[string]string{"mediainfo": string(payload)}, nil
-}
-
-func resolveBDInfo(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if summary, ok := meta.BDInfo["summary"].(string); ok && strings.TrimSpace(summary) != "" {
-		return summary, nil
-	}
-
-	path, err := resolveBDInfoPath(meta, dbPath)
-	if err != nil {
-		return "", err
-	}
-	if strings.TrimSpace(path) == "" {
-		return "", nil
-	}
-	payload, err := os.ReadFile(path)
-	if err != nil {
-		return "", fmt.Errorf("trackers: ANT read BDInfo: %w", err)
-	}
-	return string(payload), nil
-}
-
-func resolveBDInfoPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return "", nil
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return wrapTrackerResult(paths.PrimaryBDMVSummaryPath(tmpRoot, meta))
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, state uploadState) *api.TrackerQuestionnaire {
-	current := questionnaireAnswers(meta)
-	fields := make([]api.TrackerQuestionnaireField, 0, 3)
-	if strings.TrimSpace(state.typeName) == "" {
-		fields = append(fields, api.TrackerQuestionnaireField{
-			Key:         "type",
-			Label:       "ANT Type",
-			Kind:        "select",
-			Options:     []string{"Feature Film", "Short Film", "Miniseries", "Other"},
-			Value:       strings.TrimSpace(current["type"]),
-			Placeholder: "Select a release type",
-			Help:        "Pick the ANT content type for this release",
-			Required:    true,
-		})
-	}
-	if strings.TrimSpace(state.tags) == "" {
-		fields = append(fields, api.TrackerQuestionnaireField{Key: "tags", Label: "Tags", Kind: "text", Value: strings.TrimSpace(current["tags"]), Placeholder: "action, drama", Help: "Comma-separated ANT tags", Required: true})
-	}
-	if state.adultContent {
-		fields = append(fields, api.TrackerQuestionnaireField{
-			Key:         "adult_screens",
-			Label:       "Upload Screenshots",
-			Kind:        "select",
-			Options:     []string{"no", "yes"},
-			Value:       metautil.FirstNonEmptyTrimmed(strings.TrimSpace(current["adult_screens"]), "no"),
-			Placeholder: "Select yes or no",
-			Help:        "Set to yes to include screenshots for adult content",
-			Required:    true,
-		})
-	}
-	if len(fields) == 0 {
-		return nil
-	}
-	return &api.TrackerQuestionnaire{Tracker: "ANT", Fields: fields}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["ANT"]
-}
-
-func resolveType(meta api.PreparedMetadata, answers map[string]string) (string, int) {
-	if text := normalizeTypeName(answers["type"]); text != "" {
-		return text, antTypeID(text)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		imdbType := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Type))
-		runtime := meta.ExternalMetadata.IMDB.RuntimeMinutes
-		switch imdbType {
-		case "movie", "tv movie", "tvmovie":
-			if runtime >= 45 || runtime == 0 {
-				return "Feature Film", 0
-			}
-			return "Short Film", 1
-		case "short":
-			return "Short Film", 1
-		case "tv mini series":
-			return "Miniseries", 2
-		case "comedy":
-			return "Other", 3
-		}
-	}
-	keywords := strings.ToLower(strings.TrimSpace(resolveKeywords(meta)))
-	category := strings.ToLower(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "movie" {
-		runtime := 0
-		if meta.ExternalMetadata.TMDB != nil {
-			runtime = meta.ExternalMetadata.TMDB.Runtime
-		}
-		if runtime >= 45 || runtime == 0 {
-			return "Feature Film", 0
-		}
-		return "Short Film", 1
-	}
-	if strings.Contains(keywords, "miniseries") {
-		return "Miniseries", 2
-	}
-	if strings.Contains(keywords, "short") || strings.Contains(keywords, "short film") {
-		return "Short Film", 1
-	}
-	if strings.Contains(keywords, "stand-up comedy") {
-		return "Other", 3
-	}
-	return "", 0
-}
-
-func normalizeTypeName(value string) string {
-	switch strings.ToLower(strings.TrimSpace(value)) {
-	case "feature film", "feature", "movie":
-		return "Feature Film"
-	case "short film", "short":
-		return "Short Film"
-	case "miniseries", "mini series", "mini-series":
-		return "Miniseries"
-	case "other", "comedy":
-		return "Other"
-	default:
-		return ""
-	}
-}
-
-func antTypeID(value string) int {
-	switch normalizeTypeName(value) {
-	case "Short Film":
-		return 1
-	case "Miniseries":
-		return 2
-	case "Other":
-		return 3
-	default:
-		return 0
-	}
-}
-
-func resolveAudioFormat(meta api.PreparedMetadata) string {
-	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
-	switch {
-	case strings.Contains(audio, "DD+"), strings.Contains(audio, "EAC3"):
-		return "EAC3"
-	case strings.Contains(audio, " DD "), strings.HasPrefix(audio, "DD"), strings.Contains(audio, "AC3"):
-		return "AC3"
-	case strings.Contains(audio, "DTS-HD MA"), strings.Contains(audio, "DTS MA"):
-		return "DTSMA"
-	case strings.Contains(audio, "DTS"):
-		return "DTS"
-	case strings.Contains(audio, "TRUEHD"):
-		return "TrueHD"
-	case strings.Contains(audio, "FLAC"):
-		return "FLAC"
-	case strings.Contains(audio, "PCM"):
-		return "PCM"
-	case strings.Contains(audio, "OPUS"):
-		return "Opus"
-	case strings.Contains(audio, "AAC"):
-		return "AAC"
-	case strings.Contains(audio, "MP3"):
-		return "MP3"
-	case strings.Contains(audio, "MP2"):
-		return "MP2"
-	default:
-		return "Other"
-	}
-}
-
-func resolveFlags(meta api.PreparedMetadata) []string {
-	flags := make([]string, 0, 12)
-	edition := strings.ReplaceAll(meta.Edition, "'", "")
-	for _, candidate := range []string{"Directors", "Extended", "Uncut", "Unrated", "4KRemaster", "IMAX"} {
-		if strings.Contains(edition, candidate) {
-			flags = append(flags, candidate)
-		}
-	}
-	if strings.Contains(meta.Audio, "Dual-Audio") {
-		flags = append(flags, "DualAudio")
-	}
-	if strings.Contains(meta.Audio, "Atmos") {
-		flags = append(flags, "Atmos")
-	}
-	if meta.HasCommentary {
-		flags = append(flags, "Commentary")
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
-		flags = append(flags, "3D")
-	}
-	if strings.Contains(strings.ToUpper(meta.HDR), "HDR") {
-		flags = append(flags, "HDR10")
-	}
-	if strings.Contains(strings.ToUpper(meta.HDR), "DV") {
-		flags = append(flags, "DV")
-	}
-	if strings.Contains(strings.ToUpper(meta.Distributor), "CRITERION") || strings.Contains(strings.ToUpper(meta.Edition), "CRITERION") {
-		flags = append(flags, "Criterion")
-	}
-	if strings.Contains(strings.ToUpper(meta.Type), "REMUX") {
-		flags = append(flags, "Remux")
-	}
-	return dedupeStrings(flags)
-}
-
-func resolveTags(meta api.PreparedMetadata, answers map[string]string) (string, bool) {
-	if tagValue := normalizeTags(strings.TrimSpace(answers["tags"])); tagValue != "" {
-		return tagValue, true
-	}
-	values := make([]string, 0, 8)
-	if meta.ExternalMetadata.TMDB != nil {
-		values = append(values, splitTags(meta.ExternalMetadata.TMDB.Genres)...)
-	}
-	if len(values) == 0 {
-		if meta.ExternalMetadata.IMDB != nil && len(splitTags(meta.ExternalMetadata.IMDB.Genres)) > 0 {
-			return "", true
-		}
-		return "", true
-	}
-	allowed := map[string]struct{}{"action": {}, "adventure": {}, "animation": {}, "comedy": {}, "crime": {}, "documentary": {}, "drama": {}, "family": {}, "fantasy": {}, "history": {}, "horror": {}, "music": {}, "mystery": {}, "romance": {}, "sci.fi": {}, "thriller": {}, "war": {}, "western": {}}
-	filtered := make([]string, 0, len(values))
-	for _, value := range values {
-		if _, ok := allowed[value]; ok {
-			filtered = append(filtered, value)
-		}
-	}
-	return strings.Join(dedupeStrings(filtered), ","), false
-}
-
-func normalizeTags(value string) string {
-	if strings.TrimSpace(value) == "" {
-		return ""
-	}
-	return strings.Join(dedupeStrings(splitTags(value)), ",")
-}
-
-func splitTags(value string) []string {
-	items := strings.FieldsFunc(value, func(r rune) bool { return r == ',' || r == ';' })
-	result := make([]string, 0, len(items))
-	for _, item := range items {
-		normalized := strings.ToLower(strings.TrimSpace(strings.ReplaceAll(item, " ", ".")))
-		if normalized != "" {
-			result = append(result, normalized)
-		}
-	}
-	return result
-}
-
-func resolveReleaseGroup(tag string) (string, bool) {
-	trimmed := strings.TrimSpace(strings.TrimPrefix(tag, "-"))
-	if trimmed == "" {
-		return "", false
-	}
-	if _, banned := antBannedReleaseGroups[trimmed]; banned {
-		return "", false
-	}
-	return trimmed, true
-}
-
-func detectAdult(meta api.PreparedMetadata) bool {
-	candidates := []string{meta.Release.Genre, resolveKeywords(meta)}
-	if meta.ExternalMetadata.TMDB != nil {
-		candidates = append(candidates, meta.ExternalMetadata.TMDB.Genres)
-	}
-	for _, candidate := range candidates {
-		lower := strings.ToLower(candidate)
-		for _, token := range []string{"xxx", "erotic", "porn", "adult", "orgy"} {
-			if strings.Contains(lower, token) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func resolveAdultScreensAllowed(answers map[string]string, adultContent bool) bool {
-	if !adultContent {
-		return true
-	}
-	switch strings.ToLower(strings.TrimSpace(answers["adult_screens"])) {
-	case "y", "yes", "true", "1":
-		return true
-	default:
-		return false
-	}
-}
-
-func resolveScreenshotPayload(images []api.ScreenshotImage, allow bool) string {
-	if !allow || len(images) == 0 {
-		return ""
-	}
-	urls := make([]string, 0, 4)
-	for _, image := range images {
-		rawURL := strings.TrimSpace(image.RawURL)
-		if rawURL == "" {
-			rawURL = strings.TrimSpace(image.ImgURL)
-		}
-		if rawURL == "" {
-			continue
-		}
-		urls = append(urls, rawURL)
-		if len(urls) == 4 {
-			break
-		}
-	}
-	return strings.Join(urls, "\n")
-}
-
-func resolveKeywords(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-	}
-	return ""
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.Filename); name != "" {
-		return name
-	}
-	return pathutil.Base(meta.SourcePath)
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	for key, value := range fields {
-		if key == "flags[]" {
-			for item := range strings.SplitSeq(value, ",") {
-				trimmed := strings.TrimSpace(item)
-				if trimmed == "" {
-					continue
-				}
-				if err := writer.WriteField(key, trimmed); err != nil {
-					_ = writer.Close()
-					return nil, "", fmt.Errorf("trackers: ANT write multipart field %q: %w", key, err)
-				}
-			}
-			continue
-		}
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: ANT write multipart field %q: %w", key, err)
-		}
-	}
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: ANT open torrent file: %w", err)
-	}
-	defer file.Close()
-	part, err := writer.CreateFormFile("file_input", "torrent.torrent")
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: ANT create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: ANT copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: ANT close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func antUploadSuccess(payload map[string]any) bool {
-	if success, ok := payload["success"]; ok {
-		switch value := success.(type) {
-		case bool:
-			return value
-		case string:
-			return strings.EqualFold(strings.TrimSpace(value), "true") || strings.EqualFold(strings.TrimSpace(value), "success")
-		}
-	}
-	return strings.EqualFold(strings.TrimSpace(stringValue(payload["status"])), "success")
-}
-
-func antUploadError(status int, payload map[string]any, body []byte) error {
-	text := strings.ToLower(compactJSON(payload))
-	if status == http.StatusBadRequest {
-		switch {
-		case strings.Contains(text, "same infohash"):
-			if viewURL := strings.TrimSpace(stringValue(payload["view"])); viewURL != "" {
-				return fmt.Errorf("trackers: ANT same infohash already exists: %s", commonhttp.RedactErrorDetail(viewURL))
-			}
-			return errors.New("trackers: ANT same infohash already exists")
-		case strings.Contains(text, "exact same"):
-			return errors.New("trackers: ANT exact same media file already exists")
-		}
-	}
-	if detail := commonhttp.ExtractHTTPErrorDetail(body); detail != "" {
-		return fmt.Errorf("trackers: ANT upload failed status=%d: %s", status, detail)
-	}
-	switch status {
-	case http.StatusForbidden:
-		return errors.New("trackers: ANT wrong API key or insufficient permissions")
-	case http.StatusInternalServerError:
-		return errors.New("trackers: ANT internal server error")
-	case http.StatusBadGateway:
-		return errors.New("trackers: ANT bad gateway")
-	}
-	if message := strings.TrimSpace(stringValue(payload["error"])); message != "" {
-		return fmt.Errorf("trackers: ANT api error: %s", commonhttp.RedactErrorDetail(message))
-	}
-	return commonhttp.UploadHTTPError("ANT", status, body)
-}
-
-func compactJSON(payload map[string]any) string {
-	if len(payload) == 0 {
-		return ""
-	}
-	encoded, err := json.Marshal(payload)
-	if err != nil {
-		return ""
-	}
-	return string(encoded)
-}
-
-func stringValue(value any) string {
-	switch typed := value.(type) {
-	case string:
-		return strings.TrimSpace(typed)
-	default:
-		return strings.TrimSpace(fmt.Sprint(value))
-	}
-}
-
-func dedupeStrings(values []string) []string {
-	seen := make(map[string]struct{}, len(values))
-	result := make([]string, 0, len(values))
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		result = append(result, trimmed)
-	}
-	return result
-}
diff --git a/internal/trackers/impl/ant/wrap_errors.go b/internal/trackers/impl/ant/wrap_errors.go
deleted file mode 100644
index 8c88f345..00000000
--- a/internal/trackers/impl/ant/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ant
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/ar/definition.go b/internal/trackers/impl/ar/definition.go
deleted file mode 100644
index a6b28a06..00000000
--- a/internal/trackers/impl/ar/definition.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ar
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "AR"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	var (
-		err    error
-		assets trackers.DescriptionAssets
-	)
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-
-	description := buildDescription(req.Meta, req.AppConfig.MainSettings.DBPath, assets)
-	return trackers.DescriptionResult{
-		Group:       "ar",
-		Description: strings.TrimSpace(description),
-	}, nil
-}
diff --git a/internal/trackers/impl/ar/definition_test.go b/internal/trackers/impl/ar/definition_test.go
deleted file mode 100644
index 280f605a..00000000
--- a/internal/trackers/impl/ar/definition_test.go
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ar
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveTypeID(t *testing.T) {
-	t.Parallel()
-
-	if got := resolveTypeID(api.PreparedMetadata{
-		Type:   "REMUX",
-		Source: "Blu-ray",
-	}); got != "14" {
-		t.Fatalf("expected bluray remux type 14, got %q", got)
-	}
-
-	if got := resolveTypeID(api.PreparedMetadata{
-		Anime:   true,
-		Release: api.ReleaseInfo{Resolution: "1080p"},
-	}); got != "16" {
-		t.Fatalf("expected anime hd type 16, got %q", got)
-	}
-
-	if got := resolveTypeID(api.PreparedMetadata{
-		TVPack:      true,
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		Release:     api.ReleaseInfo{Resolution: "480p"},
-	}); got != "4" {
-		t.Fatalf("expected tv pack sd type 4, got %q", got)
-	}
-
-	if got := resolveTypeID(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{Genres: "Drama", Keywords: "adult"},
-		},
-	}); got != "13" {
-		t.Fatalf("expected adult movie type 13, got %q", got)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunBlockedWithoutPoster(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "AR",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			Release:     api.ReleaseInfo{Title: "Movie", Resolution: "1080p"},
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		},
-		TrackerConfig: config.TrackerConfig{},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Status != "blocked" {
-		t.Fatalf("expected blocked status, got %q", entry.Status)
-	}
-	if entry.Message != "missing poster URL" {
-		t.Fatalf("expected poster block message, got %q", entry.Message)
-	}
-}
diff --git a/internal/trackers/impl/ar/upload.go b/internal/trackers/impl/ar/upload.go
deleted file mode 100644
index ca1128d6..00000000
--- a/internal/trackers/impl/ar/upload.go
+++ /dev/null
@@ -1,1029 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ar
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerauth"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	arBaseURL    = "https://alpharatio.cc"
-	arUploadURL  = arBaseURL + "/upload.php"
-	arLoginURL   = arBaseURL + "/login.php"
-	arBrowseURL  = arBaseURL + "/torrents.php"
-	arAuthFile   = "AR_auth.txt"
-	arAuthKeyKey = "auth_key"
-	arUserAgent  = "upbrr"
-	arSourceFlag = "AlphaRatio"
-)
-
-var (
-	arLoginFailurePattern = regexp.MustCompile(`login\.php\?act=recover|Forgot your password`)
-	arURLPattern          = regexp.MustCompile(`torrents\.php\?id=(\d+)(?:&torrentid=(\d+))?`)
-	arDownloadPattern     = regexp.MustCompile(`torrents\.php\?action=download&id=(\d+)`)
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	fields        map[string]string
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, client, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: AR %s", state.blockedReason)
-	}
-
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, arUploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: AR request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", arUserAgent)
-
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: AR upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	bodyBytes, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: AR read upload response: %w", err)
-	}
-	groupID, torrentID := parseUploadIDs(finalURL, string(bodyBytes))
-	if resp.StatusCode == http.StatusOK && groupID != "" {
-		torrentURL := buildTorrentURL(groupID, torrentID)
-		downloadURL := buildDownloadURL(torrentID, torrentURL)
-		artifactPath := ""
-		if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "AR")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, arSourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		id := metautil.FirstNonEmptyTrimmed(torrentID, groupID)
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "AR",
-				TorrentID:   id,
-				DownloadURL: downloadURL,
-				TorrentURL:  torrentURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	failurePath := ""
-	if pathValue, pathErr := resolveFailurePath(req.Meta, req.AppConfig.MainSettings.DBPath); pathErr == nil {
-		failurePath = pathValue
-		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
-		_ = os.WriteFile(failurePath, redactedBody, 0o600)
-	}
-	if failurePath != "" {
-		return api.UploadSummary{}, fmt.Errorf("%w failure=%s", commonhttp.UploadHTTPErrorWithURL("AR", resp.StatusCode, finalURL, responsePreview), failurePath)
-	}
-	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("AR", resp.StatusCode, finalURL, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "AR",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      resolveARName(req.Meta),
-		DescriptionGroup: "ar",
-		Description:      state.description,
-		Endpoint:         arUploadURL,
-		Payload:          state.fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file_input",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, *http.Client, error) {
-	select {
-	case <-ctx.Done():
-		return uploadState{}, nil, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	var assets trackers.DescriptionAssets
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	description := buildDescription(req.Meta, req.AppConfig.MainSettings.DBPath, assets)
-
-	fields := map[string]string{
-		"submit": "true",
-		"type":   resolveTypeID(req.Meta),
-		"title":  resolveARName(req.Meta),
-		"tags":   resolveTags(req.Meta),
-		"image":  resolvePoster(req.Meta),
-		"desc":   description,
-	}
-	state := uploadState{
-		torrentPath: torrentPath,
-		description: description,
-		fields:      fields,
-	}
-	if strings.TrimSpace(fields["image"]) == "" {
-		state.blockedReason = "missing poster URL"
-	}
-
-	if dryRun {
-		if authProblem := dryRunAuthProblem(ctx, req.TrackerConfig, req.AppConfig.MainSettings.DBPath); authProblem != "" && state.blockedReason == "" {
-			state.blockedReason = authProblem
-		}
-		fields["auth"] = "dry-run-auth"
-		return state, nil, nil
-	}
-
-	client, authKey, err := resolveSession(ctx, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, req.Logger)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	fields["auth"] = authKey
-	return state, client, nil
-}
-
-func buildDescription(meta api.PreparedMetadata, dbPath string, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-
-	var parts []string
-	title := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ReleaseName), strings.TrimSpace(meta.Release.Title), pathutil.Base(meta.SourcePath))
-	parts = append(parts, fmt.Sprintf("[color=green][size=6]%s[/size][/color]", title))
-
-	if links := buildDatabaseLinks(meta); links != "" {
-		parts = append(parts, "[color=red][size=4]Links[/size][/color]\n"+links)
-	}
-
-	mediaLabel := "MEDIAINFO"
-	var mediaText string
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		mediaLabel = "BDINFO"
-		mediaText, _ = readBDSummary(meta, dbPath)
-	case "DVD":
-		mediaText = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
-	default:
-		mediaText = readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath))
-	}
-	if strings.TrimSpace(mediaText) != "" {
-		parts = append(parts, fmt.Sprintf("[color=red][size=4]%s[/size][/color]\n[hide][code]%s[/code][/hide]", mediaLabel, strings.TrimSpace(mediaText)))
-	}
-
-	if overview := resolveOverview(meta); overview != "" {
-		parts = append(parts, "[color=red][size=4]PLOT[/size][/color]\n"+overview)
-	}
-	if genres := resolveGenres(meta); genres != "" {
-		parts = append(parts, "[color=red][size=4]Genres[/size][/color]\n"+genres)
-	}
-	if screenshots := buildScreenshotSection(assets.Screenshots); screenshots != "" {
-		parts = append(parts, "[color=red][size=4]Screenshots[/size][/color]\n"+screenshots)
-	}
-	if youtube := resolveYouTube(meta); youtube != "" {
-		parts = append(parts, "[color=red][size=4]Youtube[/size][/color]\n"+youtube)
-	}
-	if notes := cleanNotes(assets.Description); notes != "" {
-		parts = append(parts, "[color=red][size=4]Notes[/size][/color]\n"+notes)
-	}
-
-	return strings.TrimSpace(strings.Join(parts, "\n\n"))
-}
-
-func buildDatabaseLinks(meta api.PreparedMetadata) string {
-	links := make([]string, 0, 5)
-	if imdb := resolveIMDbURL(meta); imdb != "" {
-		links = append(links, imdb)
-	}
-	category := strings.ToLower(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = "movie"
-	}
-	if id := meta.ExternalIDs.TMDBID; id > 0 {
-		links = append(links, fmt.Sprintf("https://www.themoviedb.org/%s/%d", category, id))
-	}
-	if isTVDBCategory(meta) && meta.ExternalIDs.TVDBID > 0 {
-		id := meta.ExternalIDs.TVDBID
-		links = append(links, fmt.Sprintf("https://www.thetvdb.com/?id=%d&tab=series", id))
-	}
-	if id := meta.ExternalIDs.TVmazeID; id > 0 {
-		links = append(links, fmt.Sprintf("https://www.tvmaze.com/shows/%d", id))
-	}
-	if meta.ExternalIDs.MALID > 0 {
-		links = append(links, fmt.Sprintf("https://myanimelist.net/anime/%d", meta.ExternalIDs.MALID))
-	}
-	return strings.Join(links, "\n")
-}
-
-// isTVDBCategory reports whether AR descriptions may include a TVDB series link.
-// Explicit movie categories suppress TVDB links even when MediaInfo or episode hints classify the release as TV.
-func isTVDBCategory(meta api.PreparedMetadata) bool {
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "MOVIE") {
-		return false
-	}
-	return strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV") ||
-		meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0
-}
-
-func buildScreenshotSection(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(images))
-	for _, image := range images {
-		if strings.TrimSpace(image.RawURL) == "" || strings.TrimSpace(image.ImgURL) == "" {
-			continue
-		}
-		parts = append(parts, "[url="+image.RawURL+"][img]"+image.ImgURL+"[/img][/url]")
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return "[align=center]" + strings.Join(parts, "") + "[/align]"
-}
-
-func cleanNotes(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	replacer := strings.NewReplacer("\r\n", "\n", "\r", "\n")
-	trimmed = replacer.Replace(trimmed)
-	sceneBlocks := []*regexp.Regexp{
-		regexp.MustCompile(`(?is)\[center\]\[spoiler=Scene NFO:\].*?\[/center\]`),
-		regexp.MustCompile(`(?is)\[center\]\[spoiler=FraMeSToR NFO:\].*?\[/center\]`),
-		regexp.MustCompile(`(?is)\[color=red\]\[size=4\]Screenshots\[/size\]\[/color\]\s*\[align=center\].*?\[/align\]`),
-		regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`),
-	}
-	for _, pattern := range sceneBlocks {
-		trimmed = pattern.ReplaceAllString(trimmed, "")
-	}
-	return strings.TrimSpace(trimmed)
-}
-
-func resolveTypeID(meta api.PreparedMetadata) string {
-	genres := strings.ToLower(resolveGenres(meta) + " " + resolveKeywords(meta))
-	adultKeywords := []string{"xxx", "erotic", "porn", "adult", "orgy"}
-	if (strings.EqualFold(meta.Type, "DISC") || strings.EqualFold(meta.Type, "REMUX")) && strings.EqualFold(meta.Source, "Blu-ray") {
-		return "14"
-	}
-	if meta.Anime {
-		if isSD(meta.Release.Resolution) {
-			return "15"
-		}
-		return "16"
-	}
-	if strings.EqualFold(meta.ExternalIDs.Category, "TV") {
-		if meta.TVPack {
-			if isSD(meta.Release.Resolution) {
-				return "4"
-			}
-			if isHighTier(meta.Release.Resolution) {
-				return "6"
-			}
-			return "5"
-		}
-		if isSD(meta.Release.Resolution) {
-			return "0"
-		}
-		if isHighTier(meta.Release.Resolution) {
-			return "2"
-		}
-		return "1"
-	}
-	if isSD(meta.Release.Resolution) {
-		return "7"
-	}
-	for _, keyword := range adultKeywords {
-		if strings.Contains(genres, keyword) {
-			return "13"
-		}
-	}
-	if isHighTier(meta.Release.Resolution) {
-		return "9"
-	}
-	return "8"
-}
-
-func resolveARName(meta api.PreparedMetadata) string {
-	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
-		return strings.TrimSpace(meta.SceneName)
-	}
-	name := paths.ReleaseTempBase(meta, meta.SourcePath)
-	if ext := strings.TrimSpace(filepath.Ext(name)); ext != "" {
-		name = strings.TrimSuffix(name, ext)
-	}
-	replacer := strings.NewReplacer(
-		"_", ".", " ", ".", "'", "", ":", "", "(", ".", ")", ".", "[", ".", "]", ".", "{", ".", "}", ".",
-	)
-	name = replacer.Replace(strings.TrimSpace(name))
-	name = collapseDots(name)
-
-	tagLower := strings.ToLower(strings.TrimSpace(meta.Tag))
-	invalidTags := []string{"nogrp", "nogroup", "unknown", "-unk-"}
-	if tagLower == "" || containsAny(tagLower, invalidTags) {
-		for _, invalid := range invalidTags {
-			name = regexp.MustCompile(`(?i)-?`+regexp.QuoteMeta(invalid)).ReplaceAllString(name, "")
-		}
-		name = strings.Trim(strings.TrimSpace(name), ".-")
-		if name == "" {
-			name = "release"
-		}
-		return name + "-NoGRP"
-	}
-	return name
-}
-
-func resolveTags(meta api.PreparedMetadata) string {
-	values := make([]string, 0, 8)
-	if meta.ExternalIDs.IMDBID > 0 {
-		values = append(values, "tt"+strconv.Itoa(meta.ExternalIDs.IMDBID))
-	}
-	for value := range strings.SplitSeq(resolveGenres(meta), ",") {
-		for sub := range strings.SplitSeq(value, "&") {
-			tag := strings.TrimSpace(collapseDots(sub))
-			if tag == "" {
-				continue
-			}
-			values = append(values, tag)
-		}
-	}
-	return strings.Join(uniqueStrings(values), ", ")
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	}
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	}
-	if meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Poster) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.Poster)
-	}
-	if meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster)
-	}
-	return ""
-}
-
-func resolveOverview(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Overview) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.Overview)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Summary) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Summary)
-	default:
-		return strings.TrimSpace(meta.EpisodeOverview)
-	}
-}
-
-func resolveGenres(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Genres) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.Genres)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Genres) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Genres)
-	default:
-		return strings.TrimSpace(meta.Release.Genre)
-	}
-}
-
-func resolveKeywords(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-	}
-	return ""
-}
-
-func resolveYouTube(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	return ""
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func dryRunAuthProblem(ctx context.Context, cfg config.TrackerConfig, dbPath string) string {
-	if _, err := os.Stat(authPath(dbPath)); err == nil {
-		return ""
-	}
-	if cookies, err := loadCookies(ctx, dbPath); err == nil && len(cookies) > 0 {
-		return ""
-	}
-	if strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != "" {
-		return ""
-	}
-	return "missing valid AR cookies/auth and username/password are not configured"
-}
-
-// resolveSession returns an authenticated AR client and auth key from stored
-// cookies/auth state or by logging in with configured credentials.
-func resolveSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, logger api.Logger) (*http.Client, string, error) {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: AR create cookie jar: %w", err)
-	}
-	base, _ := url.Parse(arBaseURL + "/")
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	if cookies, err := loadCookies(ctx, dbPath); err == nil && len(cookies) > 0 {
-		jar.SetCookies(base, cookies)
-		authKey, valid, authErr := validateSession(ctx, client, dbPath)
-		if authErr == nil && valid {
-			return client, authKey, nil
-		}
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, "", errors.New("trackers: AR cookie invalid/missing and username/password not configured")
-	}
-	if err := ensureLoginPersistenceAvailable(dbPath); err != nil {
-		return nil, "", err
-	}
-	authKey, err := login(ctx, client, cfg, dbPath)
-	if err != nil {
-		return nil, "", err
-	}
-	if err := persistLoginAuth(ctx, dbPath, logger, jar.Cookies(base), authKey); err != nil {
-		return nil, "", err
-	}
-	return client, authKey, nil
-}
-
-func persistLoginAuth(ctx context.Context, dbPath string, logger api.Logger, values []*http.Cookie, authKey string) error {
-	return persistLoginAuthWithWriter(ctx, dbPath, logger, values, authKey, writeAuthKey)
-}
-
-// persistLoginAuthWithWriter persists login cookies before the encrypted AR
-// auth key so cookie persistence failures cannot commit a new key alone. If
-// auth key persistence fails after cookies were saved, it restores the previous
-// cookie state before returning the auth key error.
-func persistLoginAuthWithWriter(
-	ctx context.Context,
-	dbPath string,
-	logger api.Logger,
-	values []*http.Cookie,
-	authKey string,
-	write func(context.Context, string, string) error,
-) error {
-	previous, hadPrevious, err := snapshotLoginCookies(ctx, dbPath)
-	if err != nil {
-		return err
-	}
-	if err := persistLoginCookies(ctx, dbPath, logger, values); err != nil {
-		return err
-	}
-	if err := write(ctx, dbPath, authKey); err != nil {
-		if rollbackErr := restoreLoginCookies(context.WithoutCancel(ctx), dbPath, previous, hadPrevious); rollbackErr != nil {
-			return errors.Join(err, fmt.Errorf("trackers: AR rollback login cookies: %w", rollbackErr))
-		}
-		return err
-	}
-	return nil
-}
-
-func snapshotLoginCookies(ctx context.Context, dbPath string) ([]*http.Cookie, bool, error) {
-	values, err := loadCookies(ctx, dbPath)
-	if err == nil {
-		return values, len(values) > 0, nil
-	}
-	if errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) || strings.Contains(strings.ToLower(err.Error()), "no cookies found") {
-		return nil, false, nil
-	}
-	return nil, false, err
-}
-
-func restoreLoginCookies(ctx context.Context, dbPath string, previous []*http.Cookie, hadPrevious bool) error {
-	if hadPrevious {
-		return saveCookies(ctx, dbPath, previous)
-	}
-	return wrapTrackerError(cookiepkg.DeleteTrackerCookies(ctx, dbPath, "AR"))
-}
-
-// persistLoginCookies saves encrypted cookies after login; persistence failures
-// are returned so callers do not report login success without durable cookies.
-func persistLoginCookies(ctx context.Context, dbPath string, logger api.Logger, values []*http.Cookie) error {
-	_ = logger
-	if len(usableHTTPCookies(values)) == 0 {
-		return errors.New("trackers: AR login returned no usable cookies")
-	}
-	if err := saveCookies(ctx, dbPath, values); err != nil {
-		return err
-	}
-	return nil
-}
-
-func ensureLoginPersistenceAvailable(dbPath string) error {
-	if _, err := authmaterial.LoadFromDBPath(dbPath); err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return fmt.Errorf("trackers: AR encrypted auth storage unavailable before credential login: %w", cookiepkg.ErrAuthHelperUnavailable)
-		}
-		return fmt.Errorf("trackers: AR check encrypted auth storage before credential login: %w", err)
-	}
-	return nil
-}
-
-// validateSession checks the current AR session and refreshes encrypted auth
-// state when the response exposes an auth key.
-func validateSession(ctx context.Context, client *http.Client, dbPath string) (string, bool, error) {
-	return validateSessionWithAuthKeyPersistence(ctx, client, dbPath, true)
-}
-
-// validateSessionAfterLogin checks the just-authenticated AR session without
-// persisting the auth key before login cookies are durably saved.
-func validateSessionAfterLogin(ctx context.Context, client *http.Client, dbPath string) (string, bool, error) {
-	return validateSessionWithAuthKeyPersistence(ctx, client, dbPath, false)
-}
-
-func validateSessionWithAuthKeyPersistence(ctx context.Context, client *http.Client, dbPath string, persistAuthKey bool) (string, bool, error) {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, arBrowseURL, nil)
-	if err != nil {
-		return "", false, fmt.Errorf("trackers: AR session validation request build: %w", err)
-	}
-	httpReq.Header.Set("User-Agent", arUserAgent)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return "", false, fmt.Errorf("trackers: AR session validation request: %w", err)
-	}
-	defer resp.Body.Close()
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", false, fmt.Errorf("trackers: AR read session response: %w", err)
-	}
-	body := string(bodyBytes)
-	if resp.StatusCode != http.StatusOK || arLoginFailurePattern.MatchString(body) {
-		return "", false, nil
-	}
-	authKey := extractAuthKey(body)
-	if authKey == "" {
-		if authKey := readAuthKey(ctx, dbPath); authKey != "" {
-			return authKey, true, nil
-		}
-		return "", false, nil
-	}
-	if !persistAuthKey {
-		return authKey, true, nil
-	}
-	if err := writeAuthKey(ctx, dbPath, authKey); err != nil {
-		return "", false, err
-	}
-	return authKey, true, nil
-}
-
-func login(ctx context.Context, client *http.Client, cfg config.TrackerConfig, dbPath string) (string, error) {
-	values := url.Values{
-		"username":   {strings.TrimSpace(cfg.Username)},
-		"password":   {strings.TrimSpace(cfg.Password)},
-		"keeplogged": {"1"},
-		"login":      {"Login"},
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, arLoginURL, strings.NewReader(values.Encode()))
-	if err != nil {
-		return "", fmt.Errorf("trackers: AR login request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	httpReq.Header.Set("User-Agent", arUserAgent)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("trackers: AR login request: %w", err)
-	}
-	defer resp.Body.Close()
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("trackers: AR read login response: %w", err)
-	}
-	body := string(bodyBytes)
-	if resp.StatusCode != http.StatusOK || arLoginFailurePattern.MatchString(body) {
-		return "", errors.New("trackers: AR login failed")
-	}
-	authKey := extractAuthKey(body)
-	if authKey != "" {
-		return authKey, nil
-	}
-	authKey, valid, err := validateSessionAfterLogin(ctx, client, dbPath)
-	if err != nil {
-		return "", err
-	}
-	if !valid || authKey == "" {
-		return "", errors.New("trackers: AR auth key not found after login")
-	}
-	return authKey, nil
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	file, err := os.Open(strings.TrimSpace(torrentPath))
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: AR open torrent file: %w", err)
-	}
-	defer file.Close()
-
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			return nil, "", fmt.Errorf("trackers: AR write multipart field %q: %w", key, err)
-		}
-	}
-	part, err := writer.CreateFormFile("file_input", filepath.Base(torrentPath))
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: AR create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		return nil, "", fmt.Errorf("trackers: AR copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: AR close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func parseUploadIDs(finalURL string, body string) (string, string) {
-	if matches := arURLPattern.FindStringSubmatch(finalURL); len(matches) >= 2 {
-		return strings.TrimSpace(matches[1]), strings.TrimSpace(matchAt(matches, 2))
-	}
-	if matches := arURLPattern.FindStringSubmatch(body); len(matches) >= 2 {
-		return strings.TrimSpace(matches[1]), strings.TrimSpace(matchAt(matches, 2))
-	}
-	torrentID := ""
-	if matches := arDownloadPattern.FindStringSubmatch(body); len(matches) == 2 {
-		torrentID = strings.TrimSpace(matches[1])
-	}
-	return "", torrentID
-}
-
-func buildTorrentURL(groupID string, torrentID string) string {
-	if groupID == "" {
-		return ""
-	}
-	if torrentID != "" {
-		return arBaseURL + "/torrents.php?id=" + url.QueryEscape(groupID) + "&torrentid=" + url.QueryEscape(torrentID)
-	}
-	return arBaseURL + "/torrents.php?id=" + url.QueryEscape(groupID)
-}
-
-func buildDownloadURL(torrentID string, fallback string) string {
-	if torrentID == "" {
-		return fallback
-	}
-	return arBaseURL + "/torrents.php?action=download&id=" + url.QueryEscape(torrentID)
-}
-
-func readBDSummary(meta api.PreparedMetadata, dbPath string) (string, error) {
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta)))
-}
-
-func resolveFailurePath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return filepath.Join(tmpDir, "[AR]upload_failure.html"), nil
-}
-
-func authPath(dbPath string) string {
-	if strings.TrimSpace(dbPath) == "" {
-		return ""
-	}
-	path, err := db.CookiePath(dbPath, arAuthFile)
-	if err != nil {
-		return ""
-	}
-	return path
-}
-
-// readAuthKey prefers encrypted AR auth state and falls back to the legacy
-// plaintext auth key file.
-func readAuthKey(ctx context.Context, dbPath string) string {
-	if authKey, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); err == nil && strings.TrimSpace(authKey) != "" {
-		return strings.TrimSpace(authKey)
-	}
-	payload, err := os.ReadFile(authPath(dbPath))
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(payload))
-}
-
-// writeAuthKey persists AR auth keys only to encrypted tracker auth state and
-// deletes any legacy plaintext key after a successful write. If legacy cleanup
-// fails, the encrypted write is rolled back so callers never commit split auth
-// state. Existing legacy installs without web auth keep using the legacy path.
-func writeAuthKey(ctx context.Context, dbPath string, authKey string) error {
-	authKey = strings.TrimSpace(authKey)
-	if authKey == "" {
-		return nil
-	}
-	previous, err := snapshotEncryptedAuthKey(ctx, dbPath)
-	if err != nil {
-		return err
-	}
-	if !previous.available {
-		return writeLegacyAuthKeyIfPresent(dbPath, authKey, previous.err)
-	}
-	if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, authKey); err != nil {
-		return fmt.Errorf("trackers: AR write encrypted auth key: %w", err)
-	}
-	if legacyPath := authPath(dbPath); legacyPath != "" {
-		if err := os.Remove(legacyPath); err != nil && !errors.Is(err, os.ErrNotExist) {
-			if rollbackErr := restoreEncryptedAuthKey(context.WithoutCancel(ctx), dbPath, previous); rollbackErr != nil {
-				return errors.Join(fmt.Errorf("trackers: AR remove legacy auth key: %w", err), fmt.Errorf("trackers: AR rollback encrypted auth key: %w", rollbackErr))
-			}
-			return fmt.Errorf("trackers: AR remove legacy auth key: %w", err)
-		}
-	}
-	return nil
-}
-
-type encryptedAuthKeySnapshot struct {
-	value     string
-	existed   bool
-	available bool
-	err       error
-}
-
-func snapshotEncryptedAuthKey(ctx context.Context, dbPath string) (encryptedAuthKeySnapshot, error) {
-	value, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey)
-	if err == nil {
-		return encryptedAuthKeySnapshot{value: value, existed: true, available: true}, nil
-	}
-	if errors.Is(err, trackerauth.ErrAuthStateNotFound) {
-		return encryptedAuthKeySnapshot{available: true}, nil
-	}
-	if errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
-		return encryptedAuthKeySnapshot{available: false, err: err}, nil
-	}
-	return encryptedAuthKeySnapshot{}, fmt.Errorf("trackers: AR snapshot encrypted auth key: %w", err)
-}
-
-func restoreEncryptedAuthKey(ctx context.Context, dbPath string, previous encryptedAuthKeySnapshot) error {
-	if previous.existed {
-		if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, previous.value); err != nil {
-			return fmt.Errorf("trackers: AR restore encrypted auth key: %w", err)
-		}
-		return nil
-	}
-	err := trackerauth.DeleteAuthState(ctx, dbPath, "AR", arAuthKeyKey)
-	if errors.Is(err, trackerauth.ErrAuthStateNotFound) {
-		return nil
-	}
-	if err != nil {
-		return fmt.Errorf("trackers: AR remove restored encrypted auth key: %w", err)
-	}
-	return nil
-}
-
-func writeLegacyAuthKeyIfPresent(dbPath string, authKey string, encryptedErr error) error {
-	legacyPath := authPath(dbPath)
-	if legacyPath == "" {
-		return fmt.Errorf("trackers: AR write encrypted auth key: %w", encryptedErr)
-	}
-	info, statErr := os.Stat(legacyPath)
-	if statErr != nil {
-		if errors.Is(statErr, os.ErrNotExist) {
-			return fmt.Errorf("trackers: AR write encrypted auth key: %w", encryptedErr)
-		}
-		return fmt.Errorf("trackers: AR stat legacy auth key: %w", statErr)
-	}
-	if info.IsDir() {
-		return errors.New("trackers: AR legacy auth key path is a directory")
-	}
-	if err := os.WriteFile(legacyPath, []byte(authKey), 0o600); err != nil {
-		return fmt.Errorf("trackers: AR write legacy auth key: %w", err)
-	}
-	return nil
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookiepkg.LoadTrackerHTTPCookies(ctx, dbPath, "AR", "alpharatio.cc"))
-}
-
-func saveCookies(ctx context.Context, dbPath string, values []*http.Cookie) error {
-	valid := usableHTTPCookies(values)
-	if len(valid) == 0 {
-		return errors.New("trackers: AR login returned no usable cookies")
-	}
-	return wrapTrackerError(cookiepkg.SaveTrackerHTTPCookies(ctx, dbPath, "AR", valid))
-}
-
-func usableHTTPCookies(values []*http.Cookie) []*http.Cookie {
-	out := make([]*http.Cookie, 0, len(values))
-	for _, cookie := range values {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		out = append(out, cookie)
-	}
-	return out
-}
-
-func extractAuthKey(body string) string {
-	tokenizer := html.NewTokenizer(strings.NewReader(body))
-	for {
-		//nolint:exhaustive // We only inspect tokens relevant to extracting the auth key.
-		switch tokenizer.Next() {
-		case html.ErrorToken:
-			return ""
-		case html.StartTagToken, html.SelfClosingTagToken:
-			token := tokenizer.Token()
-			if !strings.EqualFold(token.Data, "a") {
-				continue
-			}
-			href := ""
-			for _, attr := range token.Attr {
-				if strings.EqualFold(attr.Key, "href") {
-					href = attr.Val
-					break
-				}
-			}
-			if href == "" || !strings.Contains(href, "auth=") {
-				continue
-			}
-			parsed, err := url.Parse(href)
-			if err != nil {
-				continue
-			}
-			authKey := strings.TrimSpace(parsed.Query().Get("auth"))
-			if authKey != "" {
-				return authKey
-			}
-		}
-	}
-}
-
-func readTextFile(path string) (string, error) {
-	payload, err := os.ReadFile(strings.TrimSpace(path))
-	if err != nil {
-		return "", fmt.Errorf("trackers: AR read text file: %w", err)
-	}
-	return string(payload), nil
-}
-
-func readTextFileNoErr(path string) string {
-	payload, err := readTextFile(path)
-	if err != nil {
-		return ""
-	}
-	return payload
-}
-
-func isSD(resolution string) bool {
-	value := strings.ToLower(strings.TrimSpace(resolution))
-	return strings.Contains(value, "576") || strings.Contains(value, "480")
-}
-
-func isHighTier(resolution string) bool {
-	value := strings.ToLower(strings.TrimSpace(resolution))
-	return strings.Contains(value, "2160") || strings.Contains(value, "4320") || strings.Contains(value, "8640")
-}
-
-func collapseDots(value string) string {
-	cleaned := strings.TrimSpace(value)
-	for strings.Contains(cleaned, "..") {
-		cleaned = strings.ReplaceAll(cleaned, "..", ".")
-	}
-	return strings.Trim(cleaned, ".")
-}
-
-func containsAny(value string, needles []string) bool {
-	for _, needle := range needles {
-		if strings.Contains(value, needle) {
-			return true
-		}
-	}
-	return false
-}
-
-func uniqueStrings(values []string) []string {
-	seen := map[string]struct{}{}
-	result := make([]string, 0, len(values))
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		key := strings.ToLower(trimmed)
-		if _, ok := seen[key]; ok {
-			continue
-		}
-		seen[key] = struct{}{}
-		result = append(result, trimmed)
-	}
-	return result
-}
-
-func matchAt(values []string, idx int) string {
-	if idx < len(values) {
-		return values[idx]
-	}
-	return ""
-}
diff --git a/internal/trackers/impl/ar/upload_test.go b/internal/trackers/impl/ar/upload_test.go
deleted file mode 100644
index 89610900..00000000
--- a/internal/trackers/impl/ar/upload_test.go
+++ /dev/null
@@ -1,464 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ar
-
-import (
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerauth"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveARNameAddsNoGRP(t *testing.T) {
-	t.Parallel()
-
-	got := resolveARName(api.PreparedMetadata{
-		SourcePath: "C:/data/My Movie (2024).mkv",
-		Release:    api.ReleaseInfo{Title: "My Movie", Year: 2024},
-	})
-	if got != "My.Movie.2024-NoGRP" {
-		t.Fatalf("unexpected AR name %q", got)
-	}
-}
-
-func TestResolveARNameUsesSceneName(t *testing.T) {
-	t.Parallel()
-
-	got := resolveARName(api.PreparedMetadata{
-		Scene:     true,
-		SceneName: "Scene.Release-GRP",
-		Tag:       "-GRP",
-	})
-	if got != "Scene.Release-GRP" {
-		t.Fatalf("expected scene name, got %q", got)
-	}
-}
-
-type captureLogger struct {
-	warnings []string
-}
-
-func (l *captureLogger) Tracef(string, ...any) {}
-func (l *captureLogger) Debugf(string, ...any) {}
-func (l *captureLogger) Infof(string, ...any)  {}
-func (l *captureLogger) Errorf(string, ...any) {}
-func (l *captureLogger) Warnf(format string, _ ...any) {
-	l.warnings = append(l.warnings, strings.TrimSpace(format))
-}
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return fn(req)
-}
-
-func arTestResponse(req *http.Request, body string) *http.Response {
-	return &http.Response{
-		StatusCode: http.StatusOK,
-		Header:     make(http.Header),
-		Body:       io.NopCloser(strings.NewReader(body)),
-		Request:    req,
-	}
-}
-
-func TestPersistLoginCookiesReturnsAuthHelperUnavailable(t *testing.T) {
-	t.Parallel()
-
-	logger := &captureLogger{}
-	err := persistLoginCookies(context.Background(), filepath.Join(t.TempDir(), "upbrr.db"), logger, []*http.Cookie{{Name: "session", Value: "abc"}})
-	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
-		t.Fatalf("expected auth helper unavailable error, got %v", err)
-	}
-	if len(logger.warnings) != 0 {
-		t.Fatalf("unexpected warning after hard persistence failure: %v", logger.warnings)
-	}
-}
-
-func TestPersistLoginCookiesRejectsEmptyJarWithoutReplacingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-
-	err := persistLoginCookies(ctx, dbPath, api.NopLogger{}, nil)
-	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
-		t.Fatalf("expected empty login cookie error, got %v", err)
-	}
-	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("empty jar must preserve previous cookies")
-	}
-}
-
-func TestEnsureLoginPersistenceAvailableRequiresWebAuth(t *testing.T) {
-	t.Parallel()
-
-	err := ensureLoginPersistenceAvailable(filepath.Join(t.TempDir(), "upbrr.db"))
-	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
-		t.Fatalf("expected auth helper unavailable preflight, got %v", err)
-	}
-}
-
-func TestWriteAuthKeyUsesEncryptedStateAndDeletesLegacyFile(t *testing.T) {
-	t.Parallel()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	legacyPath := authPath(dbPath)
-	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o755); err != nil {
-		t.Fatalf("mkdir legacy dir: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, []byte("legacy-key"), 0o600); err != nil {
-		t.Fatalf("seed legacy auth key: %v", err)
-	}
-
-	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err != nil {
-		t.Fatalf("writeAuthKey: %v", err)
-	}
-	if got := readAuthKey(context.Background(), dbPath); got != "encrypted-key" {
-		t.Fatal("expected encrypted auth key")
-	}
-	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
-		t.Fatalf("expected legacy auth key removed, stat err=%v", err)
-	}
-}
-
-func TestWriteAuthKeyRollsBackEncryptedStateOnLegacyDeleteFailure(t *testing.T) {
-	t.Parallel()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	legacyPath := authPath(dbPath)
-	if err := os.MkdirAll(filepath.Join(legacyPath, "blocked"), 0o755); err != nil {
-		t.Fatalf("seed legacy auth path as non-empty dir: %v", err)
-	}
-
-	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err == nil {
-		t.Fatal("expected legacy cleanup failure")
-	} else if !strings.Contains(err.Error(), "remove legacy auth key") {
-		t.Fatalf("expected legacy cleanup error, got %v", err)
-	}
-	if _, err := trackerauth.LoadAuthState(context.Background(), dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
-		t.Fatalf("expected encrypted auth key rollback, got %v", err)
-	}
-	if _, err := os.Stat(legacyPath); err != nil {
-		t.Fatalf("expected failed legacy cleanup path to remain, stat err=%v", err)
-	}
-}
-
-func TestWriteAuthKeyFallsBackToExistingLegacyFileWhenWebAuthUnavailable(t *testing.T) {
-	t.Parallel()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	legacyPath := authPath(dbPath)
-	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o755); err != nil {
-		t.Fatalf("mkdir legacy dir: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, []byte("legacy-key"), 0o600); err != nil {
-		t.Fatalf("seed legacy auth key: %v", err)
-	}
-
-	if err := writeAuthKey(context.Background(), dbPath, "updated-legacy-key"); err != nil {
-		t.Fatalf("writeAuthKey: %v", err)
-	}
-	if got := readAuthKey(context.Background(), dbPath); got != "updated-legacy-key" {
-		t.Fatal("expected updated legacy auth key")
-	}
-}
-
-func TestWriteAuthKeySucceedsWhenLegacyFileAbsent(t *testing.T) {
-	t.Parallel()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-
-	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err != nil {
-		t.Fatalf("writeAuthKey: %v", err)
-	}
-	if got := readAuthKey(context.Background(), dbPath); got != "encrypted-key" {
-		t.Fatal("expected encrypted auth key")
-	}
-}
-
-func TestWriteAuthKeyWithoutWebAuthReturnsPersistenceFailure(t *testing.T) {
-	t.Parallel()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := writeAuthKey(context.Background(), dbPath, "session-key"); !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
-		t.Fatalf("expected auth helper unavailable error, got %v", err)
-	}
-	if _, err := os.Stat(authPath(dbPath)); !os.IsNotExist(err) {
-		t.Fatalf("expected no plaintext auth key, stat err=%v", err)
-	}
-}
-
-func TestPersistLoginAuthRestoresPreviousCookiesWhenAuthKeyWriteFails(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	forcedErr := errors.New("forced auth key failure")
-
-	err := persistLoginAuthWithWriter(
-		ctx,
-		dbPath,
-		api.NopLogger{},
-		[]*http.Cookie{{Name: "session", Value: "new"}},
-		"new-auth-key",
-		func(context.Context, string, string) error { return forcedErr },
-	)
-	if !errors.Is(err, forcedErr) {
-		t.Fatalf("expected forced auth key failure, got %v", err)
-	}
-	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("expected previous cookies restored")
-	}
-}
-
-func TestPersistLoginAuthRestoresPreviousCookiesWhenCallerContextCanceledDuringWrite(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := cookiepkg.SaveTrackerCookieMap(context.Background(), dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	forcedErr := errors.New("forced auth key failure")
-
-	err := persistLoginAuthWithWriter(
-		ctx,
-		dbPath,
-		api.NopLogger{},
-		[]*http.Cookie{{Name: "session", Value: "new"}},
-		"new-auth-key",
-		func(context.Context, string, string) error {
-			cancel()
-			return forcedErr
-		},
-	)
-	if !errors.Is(err, forcedErr) {
-		t.Fatalf("expected forced auth key failure, got %v", err)
-	}
-	values, err := cookiepkg.LoadTrackerCookieMap(context.Background(), dbPath, "AR")
-	if err != nil {
-		t.Fatalf("LoadTrackerCookieMap: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatal("expected previous cookies restored after cancellation")
-	}
-}
-
-func TestPersistLoginAuthRemovesNewCookiesWhenAuthKeyWriteFails(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	forcedErr := errors.New("forced auth key failure")
-
-	err := persistLoginAuthWithWriter(
-		ctx,
-		dbPath,
-		api.NopLogger{},
-		[]*http.Cookie{{Name: "session", Value: "new"}},
-		"new-auth-key",
-		func(context.Context, string, string) error { return forcedErr },
-	)
-	if !errors.Is(err, forcedErr) {
-		t.Fatalf("expected forced auth key failure, got %v", err)
-	}
-	if _, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
-		t.Fatal("expected rollback to remove newly persisted cookies")
-	}
-}
-
-func TestLoginFallbackDoesNotPersistAuthKeyBeforeCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		t.Fatalf("cookiejar.New: %v", err)
-	}
-	client := &http.Client{
-		Jar: jar,
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			switch req.URL.String() {
-			case arLoginURL:
-				return arTestResponse(req, "<html>logged in without inline auth</html>"), nil
-			case arBrowseURL:
-				return arTestResponse(req, `<a href="/torrents.php?action=download&id=1&auth=session-key">Download</a>`), nil
-			default:
-				t.Fatalf("unexpected request URL %s", req.URL.String())
-				return nil, nil
-			}
-		}),
-	}
-
-	authKey, err := login(ctx, client, config.TrackerConfig{Username: "user", Password: "pass"}, dbPath)
-	if err != nil {
-		t.Fatalf("login: %v", err)
-	}
-	if authKey != "session-key" {
-		t.Fatalf("expected auth key from validation page, got %q", authKey)
-	}
-	if _, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
-		t.Fatalf("login fallback must not persist auth key before cookie save, got %v", err)
-	}
-
-	if err := persistLoginAuth(ctx, dbPath, api.NopLogger{}, nil, authKey); err == nil || !strings.Contains(err.Error(), "no usable cookies") {
-		t.Fatalf("expected cookie persistence failure, got %v", err)
-	}
-	if _, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
-		t.Fatalf("cookie persistence failure must leave no new auth key, got %v", err)
-	}
-}
-
-func TestLoginFallbackPrefersCurrentResponseKeyAndPreservesPreviousAuthKeyOnCookieFailure(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newARAuthTestDB(t)
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, "previous-key"); err != nil {
-		t.Fatalf("SaveAuthState: %v", err)
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		t.Fatalf("cookiejar.New: %v", err)
-	}
-	client := &http.Client{
-		Jar: jar,
-		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-			switch req.URL.String() {
-			case arLoginURL:
-				return arTestResponse(req, "<html>logged in without inline auth</html>"), nil
-			case arBrowseURL:
-				return arTestResponse(req, `<a href="/torrents.php?action=download&id=1&auth=new-key">Download</a>`), nil
-			default:
-				t.Fatalf("unexpected request URL %s", req.URL.String())
-				return nil, nil
-			}
-		}),
-	}
-
-	authKey, err := login(ctx, client, config.TrackerConfig{Username: "user", Password: "pass"}, dbPath)
-	if err != nil {
-		t.Fatalf("login: %v", err)
-	}
-	if authKey != "new-key" {
-		t.Fatalf("expected current response auth key, got %q", authKey)
-	}
-	if err := persistLoginAuth(ctx, dbPath, api.NopLogger{}, nil, authKey); err == nil || !strings.Contains(err.Error(), "no usable cookies") {
-		t.Fatalf("expected cookie persistence failure, got %v", err)
-	}
-	got, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey)
-	if err != nil {
-		t.Fatalf("LoadAuthState: %v", err)
-	}
-	if got != "previous-key" {
-		t.Fatal("cookie persistence failure changed previous auth key")
-	}
-}
-
-func newARAuthTestDB(t *testing.T) string {
-	t.Helper()
-
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	repo, err := servicedb.OpenWithLogger(dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	if err := repo.Migrate(); err != nil {
-		_ = repo.Close()
-		t.Fatalf("migrate repo: %v", err)
-	}
-	if err := repo.Close(); err != nil {
-		t.Fatalf("close repo: %v", err)
-	}
-	return dbPath
-}
-
-func TestBuildDatabaseLinksSkipsTVDBForMovie(t *testing.T) {
-	t.Parallel()
-
-	got := buildDatabaseLinks(api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE", TVDBID: 456},
-	})
-	if strings.Contains(got, "thetvdb.com") {
-		t.Fatalf("did not expect tvdb link for movie description, got %q", got)
-	}
-}
-
-func TestBuildDatabaseLinksIncludesTVDBForMediaInfoTV(t *testing.T) {
-	t.Parallel()
-
-	got := buildDatabaseLinks(api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{TVDBID: 456},
-	})
-	if !strings.Contains(got, "thetvdb.com/?id=456") {
-		t.Fatalf("expected tvdb link for MediaInfo TV description, got %q", got)
-	}
-}
-
-func TestBuildDatabaseLinksIncludesTVDBForTV(t *testing.T) {
-	t.Parallel()
-
-	got := buildDatabaseLinks(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 456},
-	})
-	if !strings.Contains(got, "thetvdb.com/?id=456") {
-		t.Fatalf("expected tvdb link for TV description, got %q", got)
-	}
-}
diff --git a/internal/trackers/impl/ar/wrap_errors.go b/internal/trackers/impl/ar/wrap_errors.go
deleted file mode 100644
index 18e55cfd..00000000
--- a/internal/trackers/impl/ar/wrap_errors.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ar
-
-import "fmt"
-
-func wrapTrackerError(err error) error {
-	if err != nil {
-		return fmt.Errorf("trackers: %w", err)
-	}
-	return nil
-}
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/asc/definition.go b/internal/trackers/impl/asc/definition.go
deleted file mode 100644
index 4d6105cb..00000000
--- a/internal/trackers/impl/asc/definition.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "ASC"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(ctx, req.Meta, req.AppConfig, assets, req.TrackerConfig.CustomLayout)
-	return trackers.DescriptionResult{
-		Group:       "asc",
-		Description: strings.TrimSpace(description),
-	}, nil
-}
diff --git a/internal/trackers/impl/asc/definition_test.go b/internal/trackers/impl/asc/definition_test.go
deleted file mode 100644
index 5256c743..00000000
--- a/internal/trackers/impl/asc/definition_test.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const testCookieFileName = "ASC.txt"
-
-func TestDefinitionBuildUploadDryRunBlockedWithoutCookies(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "ASC",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "movie.mkv"),
-			TorrentPath: torrentPath,
-			Release:     api.ReleaseInfo{Title: "Movie", Year: 2024, Resolution: "1080p"},
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Poster: "https://img/poster.jpg", Overview: "Overview", Genres: "Drama"},
-				IMDB: &api.IMDBMetadata{IMDbIDText: "tt1234567"},
-			},
-		},
-		AppConfig: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")},
-		},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Status != "blocked" {
-		t.Fatalf("expected blocked status, got %q", entry.Status)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunQuestionnaireForMissingMetadata(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	cookieDir := filepath.Join(tmp, "cookies")
-	if err := os.MkdirAll(cookieDir, 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-	content := "# Netscape HTTP Cookie File\n.cliente.amigos-share.club\tTRUE\t/\tTRUE\t0\tsession\tcookievalue\n"
-	if err := os.WriteFile(filepath.Join(cookieDir, testCookieFileName), []byte(content), 0o600); err != nil {
-		t.Fatalf("write cookie: %v", err)
-	}
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "ASC",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "movie.mkv"),
-			TorrentPath: torrentPath,
-			Release:     api.ReleaseInfo{Title: "Movie", Year: 2024, Resolution: "1080p"},
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Poster: "https://img/poster.jpg"},
-				IMDB: &api.IMDBMetadata{IMDbIDText: "tt1234567"},
-			},
-		},
-		AppConfig: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")},
-		},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Questionnaire == nil {
-		t.Fatal("expected questionnaire")
-	}
-	if got := len(entry.Questionnaire.Fields); got != 2 {
-		t.Fatalf("expected 2 questionnaire fields, got %d", got)
-	}
-}
diff --git a/internal/trackers/impl/asc/description.go b/internal/trackers/impl/asc/description.go
deleted file mode 100644
index c68793e2..00000000
--- a/internal/trackers/impl/asc/description.go
+++ /dev/null
@@ -1,741 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/metadata/tmdb"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type layoutData struct {
-	Images  map[string]string
-	Ratings []map[string]any
-}
-
-type richCreditItem struct {
-	ID          int    `json:"id"`
-	Name        string `json:"name"`
-	Character   string `json:"character"`
-	ProfilePath string `json:"profile_path"`
-}
-
-type richSeasonItem struct {
-	AirDate      string `json:"air_date"`
-	EpisodeCount *int   `json:"episode_count"`
-	ID           int    `json:"id"`
-	Name         string `json:"name"`
-	Overview     string `json:"overview"`
-	PosterPath   string `json:"poster_path"`
-	SeasonNumber int    `json:"season_number"`
-}
-
-type richEpisodeDetails struct {
-	Name      string `json:"name"`
-	Overview  string `json:"overview"`
-	StillPath string `json:"still_path"`
-}
-
-type richMediaResponse struct {
-	VoteAverage float64 `json:"vote_average"`
-	Homepage    string  `json:"homepage"`
-}
-
-func tmdbCachePath(dbPath string, tmdbID int, suffix string) string {
-	if strings.TrimSpace(dbPath) == "" {
-		return ""
-	}
-	cacheRoot, err := db.Subdir(dbPath, "cache")
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(cacheRoot, fmt.Sprintf("tmdb_localized_%d_%s.json", tmdbID, suffix))
-}
-
-func fetchRichMedia(ctx context.Context, client *tmdb.Client, tmdbID int, category string, cachePath string) (richMediaResponse, error) {
-	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
-		TMDBID:    tmdbID,
-		Category:  strings.ToLower(category),
-		DataType:  "main",
-		CachePath: cachePath,
-	})
-	if err != nil {
-		return richMediaResponse{}, fmt.Errorf("fetch rich media: %w", err)
-	}
-	var resp richMediaResponse
-	if vote, ok := data["vote_average"].(float64); ok {
-		resp.VoteAverage = vote
-	}
-	if homepage, ok := data["homepage"].(string); ok {
-		resp.Homepage = homepage
-	}
-	return resp, nil
-}
-
-func fetchRichCredits(ctx context.Context, client *tmdb.Client, tmdbID int, category string, cachePath string) ([]richCreditItem, error) {
-	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
-		TMDBID:           tmdbID,
-		Category:         strings.ToLower(category),
-		DataType:         "main",
-		AppendToResponse: "credits",
-		CachePath:        cachePath,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("fetch rich credits: %w", err)
-	}
-	credits, ok := data["credits"].(map[string]any)
-	if !ok {
-		credits = data
-	}
-	castRaw, ok := credits["cast"].([]any)
-	if !ok {
-		return nil, errors.New("no cast found")
-	}
-	var cast []richCreditItem
-	for _, item := range castRaw {
-		m, ok := item.(map[string]any)
-		if !ok {
-			continue
-		}
-		var credit richCreditItem
-		if idVal, ok := m["id"].(float64); ok {
-			credit.ID = int(idVal)
-		}
-		if nameVal, ok := m["name"].(string); ok {
-			credit.Name = nameVal
-		}
-		if charVal, ok := m["character"].(string); ok {
-			credit.Character = charVal
-		}
-		if profileVal, ok := m["profile_path"].(string); ok {
-			credit.ProfilePath = profileVal
-		}
-		cast = append(cast, credit)
-	}
-	return cast, nil
-}
-
-func fetchRichSeasons(ctx context.Context, client *tmdb.Client, tmdbID int, cachePath string) ([]richSeasonItem, error) {
-	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
-		TMDBID:    tmdbID,
-		Category:  "tv",
-		DataType:  "main",
-		Language:  "pt-BR",
-		CachePath: cachePath,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("fetch rich seasons: %w", err)
-	}
-	seasonsRaw, ok := data["seasons"].([]any)
-	if !ok {
-		return nil, errors.New("no seasons found")
-	}
-	var seasons []richSeasonItem
-	for _, item := range seasonsRaw {
-		m, ok := item.(map[string]any)
-		if !ok {
-			continue
-		}
-		var season richSeasonItem
-		if airVal, ok := m["air_date"].(string); ok {
-			season.AirDate = airVal
-		}
-		if countVal, ok := m["episode_count"].(float64); ok {
-			c := int(countVal)
-			season.EpisodeCount = &c
-		}
-		if idVal, ok := m["id"].(float64); ok {
-			season.ID = int(idVal)
-		}
-		if nameVal, ok := m["name"].(string); ok {
-			season.Name = nameVal
-		}
-		if overVal, ok := m["overview"].(string); ok {
-			season.Overview = overVal
-		}
-		if posterVal, ok := m["poster_path"].(string); ok {
-			season.PosterPath = posterVal
-		}
-		if numVal, ok := m["season_number"].(float64); ok {
-			season.SeasonNumber = int(numVal)
-		}
-		seasons = append(seasons, season)
-	}
-	return seasons, nil
-}
-
-func fetchRichEpisode(ctx context.Context, client *tmdb.Client, tmdbID, season, episode int, cachePath string) (richEpisodeDetails, error) {
-	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
-		TMDBID:    tmdbID,
-		Category:  "tv",
-		DataType:  "episode",
-		Season:    season,
-		Episode:   episode,
-		Language:  "pt-BR",
-		CachePath: cachePath,
-	})
-	if err != nil {
-		return richEpisodeDetails{}, fmt.Errorf("fetch rich episode: %w", err)
-	}
-	var ep richEpisodeDetails
-	if nameVal, ok := data["name"].(string); ok {
-		ep.Name = nameVal
-	}
-	if overVal, ok := data["overview"].(string); ok {
-		ep.Overview = overVal
-	}
-	if stillVal, ok := data["still_path"].(string); ok {
-		ep.StillPath = stillVal
-	}
-	return ep, nil
-}
-
-func buildDescription(ctx context.Context, meta api.PreparedMetadata, cfg config.Config, assets trackers.DescriptionAssets, layoutID string) string {
-	if assets.Override && strings.TrimSpace(assets.Description) != "" {
-		return strings.TrimSpace(assets.Description)
-	}
-	layout, _ := fetchLayout(ctx, cfg.MainSettings.DBPath, meta, layoutID)
-	parts := []string{"[center]"}
-
-	for idx := 1; idx <= 3; idx++ {
-		if image := layout.Images[fmt.Sprintf("BARRINHA_CUSTOM_T_%d", idx)]; image != "" {
-			parts = append(parts, formatImage(image))
-		}
-	}
-	if image := layout.Images["BARRINHA_APRESENTA"]; image != "" {
-		parts = append(parts, formatImage(image))
-	}
-	parts = append(parts, "[size=3]"+resolveUploadTitle(meta)+"[/size]")
-
-	appendSection := func(key string, content string) {
-		if strings.TrimSpace(content) == "" {
-			return
-		}
-		if image := layout.Images[key]; image != "" {
-			parts = append(parts, formatImage(image))
-		}
-		parts = append(parts, content)
-	}
-
-	apiKey := strings.TrimSpace(cfg.MainSettings.TMDBAPI)
-	tmdbID := meta.ExternalIDs.TMDBID
-
-	// TMDB Sub-queries
-	var richMedia *richMediaResponse
-	var richCast []richCreditItem
-	var richSeasons []richSeasonItem
-	var richEpisode *richEpisodeDetails
-
-	if apiKey != "" && tmdbID > 0 {
-		tmdbClient := tmdb.NewClient(nil, nil, apiKey)
-		dbPath := cfg.MainSettings.DBPath
-
-		if media, err := fetchRichMedia(ctx, tmdbClient, tmdbID, categoryOf(meta), tmdbCachePath(dbPath, tmdbID, "main")); err == nil {
-			richMedia = &media
-		}
-		if castList, err := fetchRichCredits(ctx, tmdbClient, tmdbID, categoryOf(meta), tmdbCachePath(dbPath, tmdbID, "credits")); err == nil {
-			richCast = castList
-		}
-		if categoryOf(meta) == "TV" {
-			if seasons, err := fetchRichSeasons(ctx, tmdbClient, tmdbID, tmdbCachePath(dbPath, tmdbID, "pt_seasons")); err == nil {
-				richSeasons = seasons
-			}
-			if meta.SeasonInt > 0 && meta.EpisodeInt > 0 {
-				suffix := fmt.Sprintf("ep_%d_%d", meta.SeasonInt, meta.EpisodeInt)
-				if ep, err := fetchRichEpisode(ctx, tmdbClient, tmdbID, meta.SeasonInt, meta.EpisodeInt, tmdbCachePath(dbPath, tmdbID, suffix)); err == nil {
-					richEpisode = &ep
-				}
-			}
-		}
-	}
-
-	// 1. Poster
-	if poster := resolvePoster(meta); poster != "" {
-		poster = strings.ReplaceAll(poster, "/t/p/original/", "/t/p/w500/")
-		appendSection("BARRINHA_CAPA", formatImage(poster))
-	}
-
-	// 2. Overview
-	appendSection("BARRINHA_SINOPSE", resolveOverview(meta, questionnaireAnswers(meta)))
-
-	// 3. Episode Specific Section
-	if categoryOf(meta) == "TV" && richEpisode != nil {
-		if richEpisode.Name != "" && richEpisode.Overview != "" {
-			parts = append(parts, fmt.Sprintf("[size=4][b]Episódio:[/b] %s[/size]", richEpisode.Name))
-			if strings.TrimSpace(richEpisode.StillPath) != "" {
-				stillURL := "https://image.tmdb.org/t/p/w300" + strings.TrimSpace(richEpisode.StillPath)
-				parts = append(parts, formatImage(stillURL))
-			}
-			parts = append(parts, richEpisode.Overview)
-		}
-	}
-
-	// 4. Technical Sheet
-	appendSection("BARRINHA_FICHA_TECNICA", buildTechnicalSheet(meta, richMedia))
-
-	// 5. Production Companies
-	if prodComp := buildProductionCompanies(meta); prodComp != "" {
-		parts = append(parts, prodComp)
-	}
-
-	// 6. Cast
-	appendSection("BARRINHA_ELENCO", buildCastSection(meta, richCast))
-
-	// 7. Seasons Section (TV Packs / TV Seasons list)
-	if categoryOf(meta) == "TV" && len(richSeasons) > 0 {
-		var seasonsContent []string
-		for _, s := range richSeasons {
-			seasonName := strings.TrimSpace(s.Name)
-			if seasonName == "" {
-				seasonName = fmt.Sprintf("Temporada %d", s.SeasonNumber)
-			}
-			posterTemp := ""
-			if strings.TrimSpace(s.PosterPath) != "" {
-				posterTemp = formatImage("https://image.tmdb.org/t/p/w185" + strings.TrimSpace(s.PosterPath))
-			}
-			overviewTemp := ""
-			if strings.TrimSpace(s.Overview) != "" {
-				overviewTemp = "\n\nSinopse:\n" + strings.TrimSpace(s.Overview)
-			}
-			var innerContentParts []string
-			if s.AirDate != "" {
-				innerContentParts = append(innerContentParts, "Data: "+formatDate(s.AirDate))
-			}
-			if s.EpisodeCount != nil {
-				innerContentParts = append(innerContentParts, fmt.Sprintf("Episódios: %d", *s.EpisodeCount))
-			}
-			if posterTemp != "" {
-				innerContentParts = append(innerContentParts, posterTemp)
-			}
-			if overviewTemp != "" {
-				innerContentParts = append(innerContentParts, overviewTemp)
-			}
-			innerContent := strings.Join(innerContentParts, "\n")
-			seasonsContent = append(seasonsContent, fmt.Sprintf("\n[spoiler=%s]%s[/spoiler]\n", seasonName, innerContent))
-		}
-		appendSection("BARRINHA_EPISODIOS", strings.Join(seasonsContent, ""))
-	}
-
-	// 8. Ratings Section
-	var ratingsList []map[string]any
-	ratingsList = append(ratingsList, layout.Ratings...)
-	hasIMDbRating := false
-	hasTMDbRating := false
-	for _, r := range ratingsList {
-		source, _ := r["Source"].(string)
-		if source == "Internet Movie Database" {
-			hasIMDbRating = true
-		}
-		if source == "TMDb" {
-			hasTMDbRating = true
-		}
-	}
-	if !hasIMDbRating && meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Rating > 0 {
-		ratingsList = append(ratingsList, map[string]any{
-			"Source": "Internet Movie Database",
-			"Value":  fmt.Sprintf("%.1f/10", meta.ExternalMetadata.IMDB.Rating),
-		})
-	}
-	if !hasTMDbRating && richMedia != nil && richMedia.VoteAverage > 0 {
-		ratingsList = append(ratingsList, map[string]any{
-			"Source": "TMDb",
-			"Value":  fmt.Sprintf("%.1f/10", richMedia.VoteAverage),
-		})
-	}
-
-	criticsKey := "BARRINHA_CRITICAS" //nolint:misspell
-	if categoryOf(meta) == "MOVIE" && layout.Images["BARRINHA_INFORMACOES"] != "" {
-		criticsKey = "BARRINHA_INFORMACOES"
-	}
-	appendSection(criticsKey, buildRatingsBBCode(meta, ratingsList))
-
-	// 9. MediaInfo/BDInfo
-	if media := buildMediaInfo(meta, cfg.MainSettings.DBPath); media != "" {
-		parts = append(parts, "[spoiler=Informações do Arquivo]\n[left][font=Courier New]"+media+"[/font][/left][/spoiler]")
-	}
-	if notes := sanitizeDescriptionNotes(assets.Description); notes != "" {
-		parts = append(parts, notes)
-	}
-	if customHeader := strings.TrimSpace(cfg.Description.CustomDescriptionHeader); customHeader != "" {
-		parts = append(parts, customHeader)
-	}
-
-	for idx := 1; idx <= 3; idx++ {
-		if image := layout.Images[fmt.Sprintf("BARRINHA_CUSTOM_B_%d", idx)]; image != "" {
-			parts = append(parts, formatImage(image))
-		}
-	}
-	parts = append(parts, "[/center]")
-	parts = append(parts, "[center][url=https://github.com/autobrr/upbrr]Upload realizado via upbrr[/url][/center]")
-	return strings.TrimSpace(strings.Join(filterEmpty(parts), "\n\n"))
-}
-
-func fetchLayout(ctx context.Context, dbPath string, meta api.PreparedMetadata, layoutID string) (layoutData, error) {
-	cached, err := readLayoutCache(dbPath, layoutID)
-	if err == nil {
-		return cached, nil
-	}
-	cookies, _, err := LoadCookies(ctx, dbPath)
-	if err != nil {
-		return layoutData{}, err
-	}
-	form := url.Values{
-		"imdb":   {metautil.FirstNonEmptyTrimmed(resolveIMDbIDText(meta), "tt0013442")},
-		"layout": {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(layoutID), "2")},
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/search.php", strings.NewReader(form.Encode()))
-	if err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC create layout request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", userAgent)
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
-	if err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC fetch layout: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return layoutData{}, fmt.Errorf("layout fetch status %d", resp.StatusCode)
-	}
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC read layout response: %w", err)
-	}
-	var payload map[string]json.RawMessage
-	if err := json.Unmarshal(body, &payload); err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout response: %s", redaction.RedactValue(err.Error(), nil))
-	}
-	var raw map[string]any
-	if err := json.Unmarshal(payload["ASC"], &raw); err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout data: %s", redaction.RedactValue(err.Error(), nil))
-	}
-	layout := normalizeLayout(raw)
-	_ = writeLayoutCache(dbPath, layoutID, payload["ASC"])
-	return layout, nil
-}
-
-func normalizeLayout(raw map[string]any) layoutData {
-	layout := layoutData{Images: make(map[string]string)}
-	for key, value := range raw {
-		if strings.HasPrefix(key, "BARRINHA_") {
-			text := strings.TrimSpace(fmt.Sprint(value))
-			if text != "" && text != "<nil>" {
-				layout.Images[key] = text
-			}
-		}
-	}
-	if ratingsVal, ok := raw["Ratings"]; ok {
-		if ratingsSlice, ok := ratingsVal.([]any); ok {
-			for _, r := range ratingsSlice {
-				if rMap, ok := r.(map[string]any); ok {
-					layout.Ratings = append(layout.Ratings, rMap)
-				}
-			}
-		}
-	}
-	return layout
-}
-
-func readLayoutCache(dbPath string, layoutID string) (layoutData, error) {
-	payload, err := os.ReadFile(layoutCachePath(dbPath, layoutID))
-	if err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC read layout cache: %w", err)
-	}
-	var raw map[string]any
-	if err := json.Unmarshal(payload, &raw); err != nil {
-		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout cache: %w", err)
-	}
-	return normalizeLayout(raw), nil
-}
-
-func writeLayoutCache(dbPath string, layoutID string, payload []byte) error {
-	path := layoutCachePath(dbPath, layoutID)
-	if path == "" {
-		return errors.New("missing layout cache path")
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		return fmt.Errorf("trackers: ASC create layout cache dir: %w", err)
-	}
-	if err := os.WriteFile(path, payload, 0o600); err != nil {
-		return fmt.Errorf("trackers: ASC write layout cache: %w", err)
-	}
-	return nil
-}
-
-func layoutCachePath(dbPath string, layoutID string) string {
-	if strings.TrimSpace(dbPath) == "" {
-		return ""
-	}
-	cacheRoot, err := db.Subdir(dbPath, "cache")
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(cacheRoot, "asc_layout_"+metautil.FirstNonEmptyTrimmed(strings.TrimSpace(layoutID), "2")+".json")
-}
-
-func buildTechnicalSheet(meta api.PreparedMetadata, richMedia *richMediaResponse) string {
-	items := make([]string, 0, 5)
-	if runtime := resolveRuntime(meta); runtime != "" {
-		items = append(items, "Duração: "+runtime)
-	}
-	if countries := resolveCountries(meta); countries != "" {
-		items = append(items, "País de Origem: "+countries)
-	}
-	if genres := resolveGenres(meta, questionnaireAnswers(meta)); genres != "" {
-		items = append(items, "Gêneros: "+genres)
-	}
-	if releaseDate := resolveReleaseDate(meta); releaseDate != "" {
-		items = append(items, "Data de Lançamento: "+formatDate(releaseDate))
-	}
-	if richMedia != nil {
-		if homepageURL := sanitizeHomepageURL(richMedia.Homepage); homepageURL != "" {
-			items = append(items, fmt.Sprintf("Site: [url=%s]Clique aqui[/url]", homepageURL))
-		}
-	}
-	return strings.Join(items, "\n")
-}
-
-// sanitizeHomepageURL returns an absolute http or https homepage safe for ASC
-// BBCode URL attributes, rejecting literal or escaped URL-attribute delimiters.
-func sanitizeHomepageURL(rawURL string) string {
-	trimmed := strings.TrimSpace(rawURL)
-	if trimmed == "" || containsBBCodeURLAttributeUnsafeChar(trimmed) {
-		return ""
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil || !parsed.IsAbs() || strings.TrimSpace(parsed.Host) == "" {
-		return ""
-	}
-	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
-	if scheme != "http" && scheme != "https" {
-		return ""
-	}
-	normalized := parsed.String()
-	if containsBBCodeURLAttributeUnsafeChar(normalized) || hasEscapedBBCodeURLAttributeUnsafeChar(parsed) {
-		return ""
-	}
-	return normalized
-}
-
-func containsBBCodeURLAttributeUnsafeChar(value string) bool {
-	if strings.ContainsAny(value, "[]\"'") {
-		return true
-	}
-	for _, r := range value {
-		if r < ' ' || r == 0x7f {
-			return true
-		}
-	}
-	return false
-}
-
-func hasEscapedBBCodeURLAttributeUnsafeChar(parsed *url.URL) bool {
-	if slices.ContainsFunc([]string{parsed.Path, parsed.Fragment}, containsBBCodeURLAttributeUnsafeChar) {
-		return true
-	}
-	encodedValues := []string{parsed.RawQuery}
-	if parsed.User != nil {
-		encodedValues = append(encodedValues, parsed.User.String())
-	}
-	for _, encoded := range encodedValues {
-		if encoded == "" {
-			continue
-		}
-		decoded, err := url.QueryUnescape(encoded)
-		if err != nil || containsBBCodeURLAttributeUnsafeChar(decoded) {
-			return true
-		}
-	}
-	return false
-}
-
-func buildProductionCompanies(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil || len(meta.ExternalMetadata.TMDB.ProductionCompanies) == 0 {
-		return ""
-	}
-	var parts []string
-	parts = append(parts, "[size=4][b]Produtoras[/b][/size]")
-	for _, comp := range meta.ExternalMetadata.TMDB.ProductionCompanies {
-		if strings.TrimSpace(comp.Name) == "" {
-			continue
-		}
-		logo := ""
-		if logoPath := strings.TrimSpace(comp.LogoPath); logoPath != "" {
-			logo = formatImage("https://image.tmdb.org/t/p/w45" + logoPath)
-		}
-		if logo != "" {
-			parts = append(parts, fmt.Sprintf("%s[size=2] - [b]%s[/b][/size]", logo, comp.Name))
-		} else {
-			parts = append(parts, fmt.Sprintf("[size=2][b]%s[/b][/size]", comp.Name))
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-func buildCastSection(meta api.PreparedMetadata, richCast []richCreditItem) string {
-	if len(richCast) == 0 {
-		names := resolveCast(meta)
-		if len(names) == 0 {
-			return ""
-		}
-		limit := min(len(names), 10)
-		parts := make([]string, 0, limit)
-		for idx := range limit {
-			parts = append(parts, "[size=2][b]"+names[idx]+"[/b][/size]")
-		}
-		return strings.Join(parts, "\n")
-	}
-
-	limit := min(len(richCast), 10)
-	var parts []string
-	for _, person := range richCast[:limit] {
-		profileURL := "https://i.imgur.com/eCCCtFA.png"
-		if strings.TrimSpace(person.ProfilePath) != "" {
-			profileURL = "https://image.tmdb.org/t/p/w45" + strings.TrimSpace(person.ProfilePath)
-		}
-		tmdbURL := fmt.Sprintf("https://www.themoviedb.org/person/%d?language=pt-BR", person.ID)
-		imgTag := formatImage(profileURL)
-
-		charName := strings.TrimSpace(person.Character)
-		characterInfo := fmt.Sprintf("(%s)", person.Name)
-		if charName != "" {
-			characterInfo = fmt.Sprintf("(%s) como %s", person.Name, charName)
-		}
-
-		parts = append(parts, fmt.Sprintf("[url=%s]%s[/url]\n[size=2][b]%s[/b][/size]\n", tmdbURL, imgTag, characterInfo))
-	}
-	return strings.Join(parts, "")
-}
-
-func buildRatingsBBCode(meta api.PreparedMetadata, ratingsList []map[string]any) string {
-	if len(ratingsList) == 0 {
-		return ""
-	}
-	ratingsMap := map[string]string{
-		"Internet Movie Database": "[img]https://i.postimg.cc/Pr8Gv4RQ/IMDB.png[/img]",
-		"Rotten Tomatoes":         "[img]https://i.postimg.cc/rppL76qC/rotten.png[/img]",
-		"Metacritic":              "[img]https://i.postimg.cc/SKkH5pNg/Metacritic45x45.png[/img]",
-		"TMDb":                    "[img]https://i.postimg.cc/T13yyzyY/tmdb.png[/img]",
-	}
-	var parts []string
-	for _, rating := range ratingsList {
-		source, _ := rating["Source"].(string)
-		valueRaw := rating["Value"]
-		if source == "" || valueRaw == nil {
-			continue
-		}
-		value := strings.TrimSpace(fmt.Sprint(valueRaw))
-		imgTag, ok := ratingsMap[source]
-		if !ok {
-			continue
-		}
-		switch source {
-		case "Internet Movie Database":
-			imdbURL := ""
-			if meta.ExternalMetadata.IMDB != nil {
-				imdbURL = meta.ExternalMetadata.IMDB.IMDbURL
-			}
-			if imdbURL == "" && meta.ExternalIDs.IMDBID > 0 {
-				imdbURL = fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-			}
-			parts = append(parts, fmt.Sprintf("\n[url=%s]%s[/url]\n[b]%s[/b]\n", imdbURL, imgTag, value))
-		case "TMDb":
-			category := strings.ToLower(categoryOf(meta))
-			tmdbID := meta.ExternalIDs.TMDBID
-			parts = append(parts, fmt.Sprintf("[url=https://www.themoviedb.org/%s/%d]%s[/url]\n[b]%s[/b]\n", category, tmdbID, imgTag, value))
-		default:
-			parts = append(parts, fmt.Sprintf("%s\n[b]%s[/b]\n", imgTag, value))
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-func formatDate(dateStr string) string {
-	dateStr = strings.TrimSpace(dateStr)
-	if dateStr == "" || strings.EqualFold(dateStr, "N/A") {
-		return "N/A"
-	}
-	if t, err := time.Parse("2006-01-02", dateStr); err == nil {
-		return t.Format("02/01/2006")
-	}
-	return dateStr
-}
-
-func buildMediaInfo(meta api.PreparedMetadata, dbPath string) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		text, _ := readBDSummary(meta, dbPath)
-		return text
-	case "DVD":
-		return metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
-	default:
-		return readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath))
-	}
-}
-
-func readBDSummary(meta api.PreparedMetadata, dbPath string) (string, error) {
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta)))
-}
-
-func sanitizeDescriptionNotes(value string) string {
-	replacer := strings.NewReplacer(
-		"[user]", "", "[/user]", "",
-		"[align=left]", "", "[/align]", "",
-		"[align=right]", "", "[/align]", "",
-		"[alert]", "", "[/alert]", "",
-		"[note]", "", "[/note]", "",
-		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
-	)
-	return strings.TrimSpace(replacer.Replace(value))
-}
-
-func formatImage(value string) string {
-	if strings.TrimSpace(value) == "" {
-		return ""
-	}
-	return "[img]" + strings.TrimSpace(value) + "[/img]"
-}
-
-func filterEmpty(values []string) []string {
-	out := values[:0]
-	for _, value := range values {
-		if strings.TrimSpace(value) == "" {
-			continue
-		}
-		out = append(out, value)
-	}
-	return out
-}
diff --git a/internal/trackers/impl/asc/description_test.go b/internal/trackers/impl/asc/description_test.go
deleted file mode 100644
index 74582c90..00000000
--- a/internal/trackers/impl/asc/description_test.go
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"strings"
-	"testing"
-
-	descsvc "github.com/autobrr/upbrr/internal/services/description"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildTechnicalSheetHomepageURL(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		homepage string
-		want     string
-	}{
-		{
-			name:     "valid https",
-			homepage: "https://example.com/movie",
-			want:     "Site: [url=https://example.com/movie]Clique aqui[/url]",
-		},
-		{
-			name:     "valid http path and query",
-			homepage: "http://example.com/path/to/movie?utm_source=tmdb&lang=pt-BR",
-			want:     "Site: [url=http://example.com/path/to/movie?utm_source=tmdb&lang=pt-BR]Clique aqui[/url]",
-		},
-		{
-			name:     "valid encoded path query and fragment",
-			homepage: "https://example.com/path%20to/movie?name=A%2BB&ok=%25#frag%20ment",
-			want:     "Site: [url=https://example.com/path%20to/movie?name=A%2BB&ok=%25#frag%20ment]Clique aqui[/url]",
-		},
-		{
-			name:     "missing scheme",
-			homepage: "example.com/movie",
-		},
-		{
-			name:     "protocol relative",
-			homepage: "//example.com/movie",
-		},
-		{
-			name:     "missing host",
-			homepage: "https:///movie",
-		},
-		{
-			name:     "unsupported scheme",
-			homepage: "javascript:alert(1)",
-		},
-		{
-			name:     "bracket boundary",
-			homepage: "https://example.com/movie]broken",
-		},
-		{
-			name:     "quote boundary",
-			homepage: "https://example.com/movie\"broken",
-		},
-		{
-			name:     "newline boundary",
-			homepage: "https://example.com/movie\n[url=https://evil.test]",
-		},
-		{
-			name:     "encoded closing bracket boundary",
-			homepage: "https://example.com/movie%5Dbroken",
-		},
-		{
-			name:     "mixed case encoded opening bracket boundary",
-			homepage: "https://example.com/movie%5bbroken",
-		},
-		{
-			name:     "encoded quote boundary",
-			homepage: "https://example.com/movie?title=%22broken",
-		},
-		{
-			name:     "encoded single quote boundary",
-			homepage: "https://example.com/movie?title=%27broken",
-		},
-		{
-			name:     "encoded line feed boundary",
-			homepage: "https://example.com/movie?title=good%0Abad",
-		},
-		{
-			name:     "encoded carriage return boundary",
-			homepage: "https://example.com/movie?title=good%0Dbad",
-		},
-		{
-			name:     "encoded close tag payload",
-			homepage: "https://example.com/movie%5D%5B/url%5D%5Burl=https://evil.test%5D",
-		},
-		{
-			name:     "malformed percent escape",
-			homepage: "https://example.com/movie?title=%zz",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			got := buildTechnicalSheet(api.PreparedMetadata{}, &richMediaResponse{Homepage: tc.homepage})
-			if got != tc.want {
-				t.Fatalf("expected %q, got %q", tc.want, got)
-			}
-		})
-	}
-}
-
-func TestBuildTechnicalSheetHomepageURLRejectsEncodedDelimiterThroughRender(t *testing.T) {
-	t.Parallel()
-
-	homepage := "https://example.com/movie%5D%5B/url%5D%5Burl=https://evil.test%5D"
-	sheet := buildTechnicalSheet(api.PreparedMetadata{}, &richMediaResponse{Homepage: homepage})
-	if sheet != "" {
-		t.Fatalf("expected encoded delimiter homepage to be omitted, got %q", sheet)
-	}
-	rendered := descsvc.Render(sheet)
-	if strings.Contains(rendered, "evil.test") || strings.Contains(rendered, "<a href=") {
-		t.Fatalf("expected encoded delimiter homepage to be absent from rendered output, got %q", rendered)
-	}
-}
-
-func TestHomepageURLFixLeavesOtherASCLinksUnchanged(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{
-			Category: "MOVIE",
-			IMDBID:   7654321,
-			TMDBID:   123,
-		},
-	}
-
-	cast := buildCastSection(meta, []richCreditItem{
-		{ID: 42, Name: "Jane Example", Character: "Hero", ProfilePath: "/profile.jpg"},
-	})
-	if !strings.Contains(cast, "[url=https://www.themoviedb.org/person/42?language=pt-BR]") {
-		t.Fatalf("expected TMDB cast link to stay unchanged, got %q", cast)
-	}
-
-	ratings := buildRatingsBBCode(meta, []map[string]any{
-		{"Source": "Internet Movie Database", "Value": "7.8/10"},
-		{"Source": "TMDb", "Value": "8.2/10"},
-	})
-	if !strings.Contains(ratings, "[url=https://www.imdb.com/title/tt7654321]") {
-		t.Fatalf("expected IMDb rating link to stay unchanged, got %q", ratings)
-	}
-	if !strings.Contains(ratings, "[url=https://www.themoviedb.org/movie/123]") {
-		t.Fatalf("expected TMDB rating link to stay unchanged, got %q", ratings)
-	}
-}
diff --git a/internal/trackers/impl/asc/metadata.go b/internal/trackers/impl/asc/metadata.go
deleted file mode 100644
index b5534038..00000000
--- a/internal/trackers/impl/asc/metadata.go
+++ /dev/null
@@ -1,654 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"encoding/json"
-	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func resolveContainer(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		return "5"
-	case "DVD":
-		return "15"
-	}
-	ext := strings.ToLower(strings.TrimSpace(meta.Container))
-	if ext == "" {
-		ext = strings.ToLower(strings.TrimPrefix(filepath.Ext(metautil.FirstNonEmptyTrimmed(meta.VideoPath, meta.SourcePath)), "."))
-	}
-	switch ext {
-	case "mkv":
-		return "6"
-	case "mp4":
-		return "8"
-	default:
-		return ""
-	}
-}
-
-func resolveQuality(meta api.PreparedMetadata) string {
-	if !strings.EqualFold(meta.Type, "DISC") {
-		switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-		case "ENCODE":
-			return "9"
-		case "REMUX":
-			return "39"
-		case "WEBDL":
-			return "23"
-		case "WEBRIP":
-			return "38"
-		case "BDRIP":
-			return "8"
-		case "DVDRIP":
-			return "3"
-		default:
-			return "0"
-		}
-	}
-	if strings.EqualFold(meta.DiscType, "DVD") {
-		if meta.SourceSize > 7_500_000_000 {
-			return "46"
-		}
-		return "45"
-	}
-	if strings.EqualFold(meta.DiscType, "HDDVD") {
-		return "15"
-	}
-	switch size := meta.SourceSize; {
-	case size > 66<<30:
-		return "43"
-	case size > 50<<30:
-		return "42"
-	case size > 25<<30:
-		return "41"
-	default:
-		return "40"
-	}
-}
-
-func resolveResolution(meta api.PreparedMetadata) map[string]string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		heightStr := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
-		heightNum, err := strconv.Atoi(heightStr)
-		if err == nil && heightNum > 0 {
-			widthNum := int(math.Round((16.0 / 9.0) * float64(heightNum)))
-			return map[string]string{
-				"width":  strconv.Itoa(widthNum),
-				"height": strconv.Itoa(heightNum),
-			}
-		}
-	}
-
-	if meta.MediaInfoJSONPath != "" {
-		if payload, err := os.ReadFile(meta.MediaInfoJSONPath); err == nil {
-			type mediaInfoDoc struct {
-				Media struct {
-					Track []map[string]any `json:"track"`
-				} `json:"media"`
-			}
-			var doc mediaInfoDoc
-			if err := json.Unmarshal(payload, &doc); err == nil {
-				for _, track := range doc.Media.Track {
-					trackType, _ := track["@type"].(string)
-					if strings.ToLower(trackType) == "video" {
-						widthVal := track["Width"]
-						heightVal := track["Height"]
-
-						widthStr := parseDimensionStr(widthVal)
-						heightStr := parseDimensionStr(heightVal)
-
-						if widthStr != "" && heightStr != "" {
-							return map[string]string{
-								"width":  widthStr,
-								"height": heightStr,
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	height := parseResolutionHeight(meta.Release.Resolution)
-	if height == 0 {
-		height = parseResolutionHeight(meta.ReleaseName)
-	}
-	width := 0
-	if height > 0 {
-		width = int(float64(height) * (16.0 / 9.0))
-	}
-	return map[string]string{
-		"width":  intString(width),
-		"height": intString(height),
-	}
-}
-
-func resolveVideoCodec(meta api.PreparedMetadata) string {
-	codec := strings.ToUpper(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
-	codecClean := codec
-	if strings.Contains(codec, "264") {
-		codecClean = "H264"
-	} else if strings.Contains(codec, "265") {
-		codecClean = "HEVC"
-	}
-	switch {
-	case strings.Contains(strings.ToUpper(meta.HDR), "HDR") && (codecClean == "HEVC" || codecClean == "H265"):
-		return "28"
-	case strings.Contains(strings.ToUpper(meta.HDR), "HDR") && (codecClean == "AVC" || codecClean == "H264"):
-		return "32"
-	case strings.Contains(codec, "AV1"):
-		return "29"
-	case strings.Contains(codec, "HEVC"):
-		return "27"
-	case strings.Contains(codec, "H265"):
-		return "18"
-	case strings.Contains(codec, "AVC"):
-		return "30"
-	case strings.Contains(codec, "H264"):
-		return "17"
-	case strings.Contains(codec, "VC-1"):
-		return "21"
-	case strings.Contains(codec, "MPEG-2"):
-		return "11"
-	default:
-		return "16"
-	}
-}
-
-func resolveAudioCodec(meta api.PreparedMetadata) string {
-	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
-	switch {
-	case strings.Contains(audio, "ATMOS"):
-		return "43"
-	case strings.Contains(audio, "DTS:X"):
-		return "25"
-	case strings.Contains(audio, "DTS-HD MA"):
-		return "24"
-	case strings.Contains(audio, "DTS-HD"):
-		return "23"
-	case strings.Contains(audio, "TRUEHD"):
-		return "29"
-	case strings.Contains(audio, "DD+"), strings.Contains(audio, "E-AC-3"):
-		return "26"
-	case strings.Contains(audio, "DD"), strings.Contains(audio, "AC3"):
-		return "11"
-	case strings.Contains(audio, "DTS"):
-		return "12"
-	case strings.Contains(audio, "FLAC"):
-		return "13"
-	case strings.Contains(audio, "LPCM"):
-		return "21"
-	case strings.Contains(audio, "PCM"):
-		return "28"
-	case strings.Contains(audio, "AAC"):
-		return "10"
-	case strings.Contains(audio, "OPUS"):
-		return "27"
-	case strings.Contains(audio, "MPEG"):
-		return "17"
-	default:
-		return "20"
-	}
-}
-
-func resolveAudio(meta api.PreparedMetadata) string {
-	original := strings.ToLower(strings.TrimSpace(resolveOriginalLanguage(meta)))
-	audioLangs := lowerStrings(meta.AudioLanguages)
-	hasPTAudio := containsAny(audioLangs, []string{"portuguese", "português", "pt"})
-	hasPTSubs := resolveSubtitle(meta) == "Embutida"
-	isOriginalPT := containsAny([]string{original}, []string{"portuguese", "português", "pt"})
-	switch {
-	case hasPTAudio && isOriginalPT:
-		return "4"
-	case hasPTAudio && countNonPortuguese(audioLangs) > 0:
-		return "2"
-	case hasPTAudio:
-		return "3"
-	case hasPTSubs:
-		return "1"
-	default:
-		return "7"
-	}
-}
-
-func resolveSubtitle(meta api.PreparedMetadata) string {
-	if containsAny(lowerStrings(meta.SubtitleLanguages), []string{"portuguese", "português", "pt", "brazilian portuguese"}) {
-		return "Embutida"
-	}
-	return "S_legenda"
-}
-
-func resolveLanguage(meta api.PreparedMetadata) string {
-	return mapLanguage(resolveOriginalLanguage(meta), map[string]string{
-		"bg": "15", "da": "12", "de": "3", "en": "1", "es": "6", "fi": "14", "fr": "2",
-		"hi": "23", "it": "4", "ja": "5", "ko": "20", "nl": "17", "no": "16", "pl": "19",
-		"pt": "8", "ru": "7", "sv": "13", "th": "21", "tr": "25", "zh": "10",
-	}, "11")
-}
-
-func resolveAnimeLanguage(meta api.PreparedMetadata) string {
-	return mapLanguage(resolveOriginalLanguage(meta), map[string]string{
-		"de": "3", "en": "4", "es": "1", "ja": "8", "ko": "11", "pt": "5", "ru": "2", "zh": "9",
-	}, "6")
-}
-
-func resolveAnimeAudioLanguage(meta api.PreparedMetadata) string {
-	if audio := resolveAudio(meta); audio == "2" || audio == "3" || audio == "4" {
-		return "8"
-	}
-	return resolveLanguage(meta)
-}
-
-func resolveAnimeType(meta api.PreparedMetadata) string {
-	if categoryOf(meta) == "TV" {
-		return "118"
-	}
-	return "116"
-}
-
-func resolveUploadTitle(meta api.PreparedMetadata) string {
-	base := resolveDisplayTitle(meta)
-	if categoryOf(meta) == "TV" {
-		return strings.TrimSpace(base + " - " + metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.SeasonStr)+strings.TrimSpace(meta.EpisodeStr), seasonEpisodeText(meta)))
-	}
-	return base
-}
-
-func resolveDisplayTitle(meta api.PreparedMetadata) string {
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	if tmdb := meta.ExternalMetadata.TMDB; tmdb != nil {
-		main := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(ptBR.Title, tmdb.Title, meta.Release.Title))
-		alt := strings.TrimSpace(tmdb.OriginalTitle)
-		if categoryOf(meta) == "TV" {
-			alt = strings.TrimSpace(metautil.FirstNonEmptyTrimmed(tmdb.Title, meta.Release.Title))
-		}
-		if main != "" && alt != "" && !strings.EqualFold(main, alt) {
-			return main + " (" + alt + ")"
-		}
-		if main != "" {
-			return main
-		}
-	}
-	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName, pathutil.Base(meta.SourcePath)))
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		if meta.ExternalMetadata.TMDB.Localized != nil {
-			if localized, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
-				return strings.TrimSpace(localized.Poster)
-			}
-		}
-		if strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster) != "" {
-			return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-		}
-	}
-	switch {
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Poster) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.Poster)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster)
-	default:
-		return ""
-	}
-}
-
-func resolveOverview(meta api.PreparedMetadata, answers map[string]string) string {
-	if strings.TrimSpace(answers["overview"]) != "" {
-		return strings.TrimSpace(answers["overview"])
-	}
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
-		return strings.TrimSpace(ptBR.EpisodeOverview)
-	}
-	if ptBR.Overview != "" {
-		return strings.TrimSpace(ptBR.Overview)
-	}
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Overview) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.Overview)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Summary) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Summary)
-	default:
-		return strings.TrimSpace(meta.EpisodeOverview)
-	}
-}
-
-// shouldUseScopedTVOverview reports whether ASC should prefer season or
-// episode localized overview over title-level synopsis text.
-func shouldUseScopedTVOverview(meta api.PreparedMetadata) bool {
-	if meta.SeasonInt <= 0 {
-		return false
-	}
-	if categoryOf(meta) != "TV" {
-		return false
-	}
-	if meta.TVPack {
-		return true
-	}
-	return meta.EpisodeInt > 0
-}
-
-func resolveGenres(meta api.PreparedMetadata, answers map[string]string) string {
-	if strings.TrimSpace(answers["genre"]) != "" {
-		return strings.TrimSpace(answers["genre"])
-	}
-	ptBR := api.ExtractLocalizedPTBR(meta)
-
-	// 1. Use localized if available
-	if ptBR.Genres != "" {
-		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
-		out := make([]string, 0, len(genres))
-		for _, genre := range genres {
-			g := strings.TrimSpace(genre)
-			capitalized := metautil.CapitalizeGenre(g)
-			if capitalized != "" {
-				out = append(out, capitalized)
-			}
-		}
-		return strings.Join(out, ", ")
-	}
-
-	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
-	var genreText string
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.TVDB.Genres)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.TVmaze.Genres)
-	default:
-		genreText = strings.TrimSpace(meta.Release.Genre)
-	}
-
-	if genreText == "" {
-		return ""
-	}
-
-	genres := strings.Split(genreText, ",")
-	out := make([]string, 0, len(genres))
-	for _, genre := range genres {
-		g := strings.TrimSpace(genre)
-		if g == "" {
-			continue
-		}
-		translated := metautil.TranslateGenreToPortugueseStrict(g)
-		if translated == "" {
-			translated = g
-		}
-		capitalized := metautil.CapitalizeGenre(translated)
-		if capitalized != "" {
-			out = append(out, capitalized)
-		}
-	}
-	return strings.Join(out, ", ")
-}
-
-func resolveTrailer(meta api.PreparedMetadata) string {
-	value := ""
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	if ptBR.TrailerURL != "" {
-		value = ptBR.TrailerURL
-	}
-	if value == "" && meta.ExternalMetadata.TMDB != nil {
-		value = strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	if value == "" {
-		return ""
-	}
-	if strings.HasPrefix(value, "http://") || strings.HasPrefix(value, "https://") {
-		return value
-	}
-	return "https://www.youtube.com/watch?v=" + value
-}
-
-func resolveIMDbIDText(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbIDText)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveOriginalLanguage(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.OriginalLanguage) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.OriginalLanguage)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Language) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Language)
-	default:
-		return ""
-	}
-}
-
-func resolveRuntime(meta api.PreparedMetadata) string {
-	minutes := 0
-	switch {
-	case meta.ExternalMetadata.TMDB != nil:
-		minutes = meta.ExternalMetadata.TMDB.Runtime
-	case meta.ExternalMetadata.IMDB != nil:
-		minutes = meta.ExternalMetadata.IMDB.RuntimeMinutes
-	case meta.ExternalMetadata.TVmaze != nil:
-		minutes = meta.ExternalMetadata.TVmaze.Runtime
-	}
-	if minutes <= 0 {
-		return ""
-	}
-	hours := minutes / 60
-	remain := minutes % 60
-	if hours == 0 {
-		return fmt.Sprintf("%02d minutos", remain)
-	}
-	return fmt.Sprintf("%d hora%s e %02d minutos", hours, pluralSuffix(hours), remain)
-}
-
-func resolveCountries(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.ProductionCountries) > 0 {
-		names := make([]string, 0, len(meta.ExternalMetadata.TMDB.ProductionCountries))
-		for _, country := range meta.ExternalMetadata.TMDB.ProductionCountries {
-			if strings.TrimSpace(country.Name) != "" {
-				names = append(names, strings.TrimSpace(country.Name))
-			}
-		}
-		return strings.Join(names, ", ")
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.CountryList)
-	}
-	return ""
-}
-
-func resolveCast(meta api.PreparedMetadata) []string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Cast) > 0:
-		return append([]string{}, meta.ExternalMetadata.TMDB.Cast...)
-	case meta.ExternalMetadata.IMDB != nil && len(meta.ExternalMetadata.IMDB.Stars) > 0:
-		names := make([]string, 0, len(meta.ExternalMetadata.IMDB.Stars))
-		for _, person := range meta.ExternalMetadata.IMDB.Stars {
-			if strings.TrimSpace(person.Name) != "" {
-				names = append(names, strings.TrimSpace(person.Name))
-			}
-		}
-		return names
-	default:
-		return nil
-	}
-}
-
-func resolveReleaseDate(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.ReleaseDate) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.ReleaseDate)
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.FirstAirDate) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.FirstAirDate)
-	case meta.ExternalMetadata.TVDB != nil && strings.TrimSpace(meta.ExternalMetadata.TVDB.FirstAired) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVDB.FirstAired)
-	case meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Premiered) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Premiered)
-	default:
-		return ""
-	}
-}
-
-func resolveYear(meta api.PreparedMetadata) int {
-	switch {
-	case meta.Release.Year > 0:
-		return meta.Release.Year
-	case meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0:
-		return meta.ExternalMetadata.TMDB.Year
-	case meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0:
-		return meta.ExternalMetadata.IMDB.Year
-	case meta.ExternalMetadata.TVDB != nil && meta.ExternalMetadata.TVDB.Year > 0:
-		return meta.ExternalMetadata.TVDB.Year
-	default:
-		return 0
-	}
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category)) {
-	case "TV":
-		return "TV"
-	case "MOVIE":
-		return "MOVIE"
-	}
-	if meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 {
-		return "TV"
-	}
-	return "MOVIE"
-}
-
-func seasonEpisodeText(meta api.PreparedMetadata) string {
-	if meta.EpisodeInt > 0 {
-		return fmt.Sprintf("S%02dE%02d", meta.SeasonInt, meta.EpisodeInt)
-	}
-	if meta.SeasonInt > 0 {
-		return fmt.Sprintf("S%02d", meta.SeasonInt)
-	}
-	return ""
-}
-
-func boolFlag(ok bool) string {
-	if ok {
-		return "1"
-	}
-	return "2"
-}
-
-func parseResolutionHeight(value string) int {
-	re := regexp.MustCompile(`(?i)(\d{3,4})(?:p|i)`)
-	matches := re.FindStringSubmatch(value)
-	if len(matches) != 2 {
-		return 0
-	}
-	height, _ := strconv.Atoi(matches[1])
-	return height
-}
-
-func intString(value int) string {
-	if value <= 0 {
-		return ""
-	}
-	return strconv.Itoa(value)
-}
-
-func mapLanguage(value string, mappings map[string]string, fallback string) string {
-	key := strings.ToLower(strings.TrimSpace(value))
-	if mapped, ok := mappings[key]; ok {
-		return mapped
-	}
-	return fallback
-}
-
-func lowerStrings(values []string) []string {
-	out := make([]string, 0, len(values))
-	for _, value := range values {
-		if strings.TrimSpace(value) == "" {
-			continue
-		}
-		out = append(out, strings.ToLower(strings.TrimSpace(value)))
-	}
-	return out
-}
-
-func countNonPortuguese(values []string) int {
-	count := 0
-	for _, value := range values {
-		if !containsAny([]string{value}, []string{"portuguese", "português", "pt"}) {
-			count++
-		}
-	}
-	return count
-}
-
-func containsAny(values []string, targets []string) bool {
-	for _, value := range values {
-		for _, target := range targets {
-			if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func containsFold(values []string, target string) bool {
-	for _, value := range values {
-		if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
-			return true
-		}
-	}
-	return false
-}
-
-func pluralSuffix(value int) string {
-	if value == 1 {
-		return ""
-	}
-	return "s"
-}
-
-func readTextFile(path string) (string, error) {
-	payload, err := os.ReadFile(strings.TrimSpace(path))
-	if err != nil {
-		return "", fmt.Errorf("trackers: ASC read text file: %w", err)
-	}
-	return strings.ReplaceAll(string(payload), "\r", ""), nil
-}
-
-func readTextFileNoErr(path string) string {
-	value, _ := readTextFile(path)
-	return value
-}
-
-func parseDimensionStr(val any) string {
-	return metautil.ParseDimensionStr(val)
-}
diff --git a/internal/trackers/impl/asc/metadata_test.go b/internal/trackers/impl/asc/metadata_test.go
deleted file mode 100644
index 39b417bf..00000000
--- a/internal/trackers/impl/asc/metadata_test.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveGenresPreservesUnknownGenres(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Genre: "Sci-Fi,MyCustomGenre",
-		},
-	}
-	answers := map[string]string{}
-
-	got := resolveGenres(meta, answers)
-	expected := "Ficção científica, MyCustomGenre"
-	if got != expected {
-		t.Fatalf("expected genres %q, got %q", expected, got)
-	}
-}
-
-func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
-	t.Parallel()
-
-	answers := map[string]string{}
-	ptBR := api.TMDBLocalizedData{
-		Overview:        "Series Overview",
-		EpisodeOverview: "Episode Overview",
-	}
-
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-		want string
-	}{
-		{
-			name: "episode upload uses episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
-				},
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "season pack uses season overview from episode field",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				TVPack:      true,
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
-				},
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "series upload uses title overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
-				},
-			},
-			want: "Series Overview",
-		},
-		{
-			name: "movie ignores episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
-				},
-			},
-			want: "Series Overview",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := resolveOverview(tc.meta, answers); got != tc.want {
-				t.Fatalf("expected overview %q, got %q", tc.want, got)
-			}
-		})
-	}
-}
diff --git a/internal/trackers/impl/asc/upload.go b/internal/trackers/impl/asc/upload.go
deleted file mode 100644
index c7d9cb13..00000000
--- a/internal/trackers/impl/asc/upload.go
+++ /dev/null
@@ -1,400 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package asc
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var ascIDPattern = regexp.MustCompile(`torrents-details\.php\?id=(\d+)`)
-
-type uploadState struct {
-	uploadURL     string
-	torrentPath   string
-	description   string
-	fields        map[string]string
-	blockedReason string
-	questionnaire *api.TrackerQuestionnaire
-	releaseName   string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ASC %s", state.blockedReason)
-	}
-
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ASC request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", userAgent)
-	for _, cookie := range cookies {
-		httpReq.AddCookie(cookie)
-	}
-
-	client := httpclient.New(httpclient.DefaultTimeout)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ASC upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	bodyBytes, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: ASC read upload response: %w", err)
-	}
-	torrentID := parseUploadID(finalURL, string(bodyBytes))
-	if resp.StatusCode == http.StatusOK && torrentID != "" {
-		torrentURL := baseURL + "/torrents-details.php?id=" + url.QueryEscape(torrentID)
-		artifactPath := ""
-		if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "ASC")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		maybeAutoApprove(ctx, client, cookies, req.TrackerConfig, torrentID, req.Logger)
-		maybeSetInternal(ctx, client, cookies, req.TrackerConfig, req.Meta, torrentID, req.Logger)
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "ASC",
-				TorrentID:   torrentID,
-				TorrentURL:  torrentURL,
-				DownloadURL: torrentURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	failurePath := ""
-	if pathValue, pathErr := resolveFailurePath(req.Meta, req.AppConfig.MainSettings.DBPath); pathErr == nil {
-		failurePath = pathValue
-		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
-		_ = os.WriteFile(failurePath, redactedBody, 0o600)
-	}
-	if failurePath != "" {
-		return api.UploadSummary{}, fmt.Errorf("%w failure=%s", commonhttp.UploadHTTPErrorWithURL("ASC", resp.StatusCode, finalURL, responsePreview), failurePath)
-	}
-	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("ASC", resp.StatusCode, finalURL, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "ASC",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "asc",
-		Description:      state.description,
-		Endpoint:         state.uploadURL,
-		Payload:          state.fields,
-		Questionnaire:    state.questionnaire,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "torrent",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-
-	description := buildDescription(ctx, req.Meta, req.AppConfig, assets, req.TrackerConfig.CustomLayout)
-
-	fields, releaseName := buildPayload(req.Meta, req.TrackerConfig, assets, description)
-	state := uploadState{
-		uploadURL:     resolveUploadURL(req.Meta),
-		torrentPath:   torrentPath,
-		description:   description,
-		fields:        fields,
-		releaseName:   releaseName,
-		questionnaire: buildQuestionnaire(req.Meta),
-	}
-	if reason := validatePayload(ctx, req.Meta, fields, req.AppConfig.MainSettings.DBPath); reason != "" {
-		state.blockedReason = reason
-	}
-	if dryRun {
-		return state, nil, nil
-	}
-
-	cookies, _, err := LoadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: ASC load cookies: %w", err)
-	}
-	return state, cookies, nil
-}
-
-func buildPayload(meta api.PreparedMetadata, trackerCfg config.TrackerConfig, assets trackers.DescriptionAssets, description string) (map[string]string, string) {
-	answers := questionnaireAnswers(meta)
-	releaseName := resolveUploadTitle(meta)
-	fields := map[string]string{
-		"ano":        strconv.Itoa(resolveYear(meta)),
-		"audio":      resolveAudio(meta),
-		"capa":       resolvePoster(meta),
-		"codecaudio": resolveAudioCodec(meta),
-		"codecvideo": resolveVideoCodec(meta),
-		"descr":      description,
-		"extencao":   resolveContainer(meta),
-		"genre":      resolveGenres(meta, answers),
-		"imdb":       resolveIMDbIDText(meta),
-		"layout":     metautil.FirstNonEmptyTrimmed(strings.TrimSpace(trackerCfg.CustomLayout), "2"),
-		"legenda":    resolveSubtitle(meta),
-		"name":       releaseName,
-		"qualidade":  resolveQuality(meta),
-		"takeupload": "yes",
-		"tresd":      boolFlag(meta.Is3D != ""),
-		"tube":       resolveTrailer(meta),
-	}
-	resolution := resolveResolution(meta)
-	fields["largura"] = resolution["width"]
-	fields["altura"] = resolution["height"]
-	fields["lang"] = resolveLanguage(meta)
-	count := 1
-	for _, image := range assets.Screenshots {
-		if count > 4 {
-			break
-		}
-		raw := strings.TrimSpace(image.RawURL)
-		if raw == "" {
-			continue
-		}
-		lower := strings.ToLower(raw)
-		if strings.Contains(lower, "amigos-share.club") || strings.Contains(lower, "tmdb.org") || strings.Contains(lower, "imdb.com") || strings.Contains(lower, "themoviedb.org") {
-			continue
-		}
-		fields[fmt.Sprintf("screens%d", count)] = raw
-		count++
-	}
-	if meta.Anime {
-		fields["type"] = resolveAnimeType(meta)
-		fields["idioma"] = resolveAnimeLanguage(meta)
-		fields["lang"] = resolveAnimeAudioLanguage(meta)
-	}
-	return fields, releaseName
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata) *api.TrackerQuestionnaire {
-	answers := questionnaireAnswers(meta)
-	fields := make([]api.TrackerQuestionnaireField, 0, 2)
-	if strings.TrimSpace(resolveOverview(meta, answers)) == "" {
-		fields = append(fields, api.TrackerQuestionnaireField{
-			Key: "overview", Label: "Sinopse", Kind: "textarea", Value: strings.TrimSpace(answers["overview"]), Required: true,
-		})
-	}
-	if strings.TrimSpace(resolveGenres(meta, answers)) == "" {
-		fields = append(fields, api.TrackerQuestionnaireField{
-			Key: "genre", Label: "Gêneros", Kind: "text", Value: strings.TrimSpace(answers["genre"]), Placeholder: "Drama, Action", Required: true,
-		})
-	}
-	if len(fields) == 0 {
-		return nil
-	}
-	return &api.TrackerQuestionnaire{Tracker: "ASC", Fields: fields}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["ASC"]
-}
-
-func validatePayload(ctx context.Context, meta api.PreparedMetadata, fields map[string]string, dbPath string) string {
-	if reason := authProblem(ctx, dbPath); reason != "" {
-		return reason
-	}
-	if !meta.Anime && strings.TrimSpace(fields["imdb"]) == "" {
-		return "missing IMDb ID"
-	}
-	if strings.TrimSpace(fields["capa"]) == "" {
-		return "missing poster URL"
-	}
-	if strings.TrimSpace(fields["genre"]) == "" {
-		return "missing genre"
-	}
-	if strings.TrimSpace(resolveOverview(meta, questionnaireAnswers(meta))) == "" {
-		return "missing overview"
-	}
-	return ""
-}
-
-func resolveUploadURL(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return baseURL + "/enviar-anime.php"
-	}
-	if categoryOf(meta) == "TV" {
-		return baseURL + "/enviar-series.php"
-	}
-	return baseURL + "/enviar-filme.php"
-}
-
-func parseUploadID(finalURL string, body string) string {
-	if matches := ascIDPattern.FindStringSubmatch(finalURL); len(matches) == 2 {
-		return strings.TrimSpace(matches[1])
-	}
-	if matches := ascIDPattern.FindStringSubmatch(body); len(matches) == 2 {
-		return strings.TrimSpace(matches[1])
-	}
-	return ""
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	file, err := os.Open(strings.TrimSpace(torrentPath))
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: ASC open torrent file: %w", err)
-	}
-	defer file.Close()
-
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			return nil, "", fmt.Errorf("trackers: ASC write multipart field %q: %w", key, err)
-		}
-	}
-	part, err := writer.CreateFormFile("torrent", filepath.Base(torrentPath))
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: ASC create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		return nil, "", fmt.Errorf("trackers: ASC copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: ASC close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func maybeAutoApprove(ctx context.Context, client *http.Client, cookies []*http.Cookie, cfg config.TrackerConfig, torrentID string, logger api.Logger) {
-	if client == nil {
-		logger.Warnf("trackers: ASC auto approval skipped: client is nil")
-		return
-	}
-	if !cfg.UploaderStatus {
-		logger.Debugf("trackers: ASC auto approval skipped: uploader status disabled")
-		return
-	}
-	if strings.TrimSpace(torrentID) == "" {
-		logger.Warnf("trackers: ASC auto approval skipped: empty torrentID")
-		return
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/uploader_app.php?id="+url.QueryEscape(torrentID), nil)
-	if err != nil {
-		logger.Warnf("trackers: ASC auto approval failed: %v", err)
-		return
-	}
-	req.Header.Set("User-Agent", userAgent)
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	resp, err := client.Do(req)
-	if err != nil && logger != nil {
-		logger.Warnf("trackers: ASC auto approval failed: %v", err)
-	}
-	if resp != nil {
-		resp.Body.Close()
-	}
-}
-
-func maybeSetInternal(ctx context.Context, client *http.Client, cookies []*http.Cookie, cfg config.TrackerConfig, meta api.PreparedMetadata, torrentID string, logger api.Logger) {
-	if client == nil || !cfg.Internal || strings.TrimSpace(torrentID) == "" {
-		logger.Debugf("trackers: ASC internal flag skipped: %v", "client is nil or internal is false or torrentID is empty")
-		return
-	}
-	group := strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
-	if group == "" || !containsFold(cfg.InternalGroups, group) {
-		logger.Debugf("trackers: ASC internal flag skipped: %v", "group is empty or not in internal groups")
-		return
-	}
-	values := url.Values{"id": {torrentID}, "internal": {"yes"}}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/torrents-edit.php?action=doedit", strings.NewReader(values.Encode()))
-	if err != nil {
-		return
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", userAgent)
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	resp, err := client.Do(req)
-	if err != nil && logger != nil {
-		logger.Warnf("trackers: ASC internal flag failed: %v", err)
-	}
-	if resp != nil {
-		resp.Body.Close()
-	}
-}
-
-func resolveFailurePath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return filepath.Join(tmpDir, "[ASC]upload_failure.html"), nil
-}
diff --git a/internal/trackers/impl/azfamily/auth.go b/internal/trackers/impl/azfamily/auth.go
new file mode 100644
index 00000000..7ab2a9e0
--- /dev/null
+++ b/internal/trackers/impl/azfamily/auth.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package azfamily
+
+import "github.com/autobrr/upbrr/pkg/api"
+
+// AuthCapability returns the stored-cookie authentication contract for this
+// AZ-family profile.
+func (d *Definition) AuthCapability() api.TrackerAuthCapability {
+	return api.TrackerAuthCapability{
+		TrackerID:          d.Name(),
+		DisplayName:        d.Name(),
+		AuthKind:           "cookies",
+		SupportsCookieFile: true,
+	}
+}
diff --git a/internal/trackers/impl/azfamily/common.go b/internal/trackers/impl/azfamily/common.go
index 25b4993e..bd549f25 100644
--- a/internal/trackers/impl/azfamily/common.go
+++ b/internal/trackers/impl/azfamily/common.go
@@ -39,20 +39,15 @@ type languageBundle struct {
 	Subtitles []string
 }
 
-func category(meta api.PreparedMetadata) string {
-	if value := strings.TrimSpace(meta.ExternalIDs.Category); value != "" {
-		return value
-	}
-	if value := strings.TrimSpace(meta.MediaInfoCategory); value != "" {
-		return value
-	}
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Category) != "" {
-		return meta.ExternalMetadata.TMDB.Category
+func category(meta api.UploadSubject) string {
+	value, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
 	}
-	return "MOVIE"
+	return string(value)
 }
 
-func categoryID(meta api.PreparedMetadata) string {
+func categoryID(meta api.UploadSubject) string {
 	switch strings.ToUpper(strings.TrimSpace(category(meta))) {
 	case "MOVIE":
 		return "1"
@@ -63,52 +58,56 @@ func categoryID(meta api.PreparedMetadata) string {
 	}
 }
 
-func categorySlug(meta api.PreparedMetadata) string {
-	if strings.EqualFold(category(meta), "TV") {
+func categorySlug(meta api.UploadSubject) string {
+	switch strings.ToUpper(category(meta)) {
+	case "TV":
 		return "tv"
+	case "MOVIE":
+		return "movie"
+	default:
+		return ""
 	}
-	return "movie"
 }
 
-func isTV(meta api.PreparedMetadata) bool {
+func isTV(meta api.UploadSubject) bool {
 	return strings.EqualFold(category(meta), "TV")
 }
 
-func imdbForLookup(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID != 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
+func imdbForLookup(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID != 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
 	}
 	return ""
 }
 
-func tmdbForLookup(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.TMDBID != 0 {
-		return strconv.Itoa(meta.ExternalIDs.TMDBID)
+func tmdbForLookup(meta api.UploadSubject) string {
+	if meta.Identity.TMDBID != 0 {
+		return strconv.Itoa(meta.Identity.TMDBID)
 	}
 	return ""
 }
 
 // tvdbForLookup returns a TVDB search value only for identified TV content.
-func tvdbForLookup(meta api.PreparedMetadata) string {
-	if isTV(meta) && meta.ExternalIDs.TVDBID > 0 {
-		return strconv.Itoa(meta.ExternalIDs.TVDBID)
+func tvdbForLookup(meta api.UploadSubject) string {
+	if isTV(meta) && meta.Identity.TVDBID > 0 {
+		return strconv.Itoa(meta.Identity.TVDBID)
 	}
 	return ""
 }
 
-func lookupTitle(meta api.PreparedMetadata) string {
+func lookupTitle(meta api.UploadSubject) string {
 	if title := strings.TrimSpace(meta.Release.Title); title != "" {
 		return title
 	}
-	if meta.ExternalMetadata.TMDB != nil {
-		if title := strings.TrimSpace(meta.ExternalMetadata.TMDB.Title); title != "" {
+	if meta.ProviderMetadata.TMDB != nil {
+		if title := strings.TrimSpace(meta.ProviderMetadata.TMDB.Title); title != "" {
 			return title
 		}
 	}
 	return strings.TrimSpace(meta.Filename)
 }
 
-func tvCode(meta api.PreparedMetadata) string {
+func tvCode(meta api.UploadSubject) string {
 	if meta.SeasonInt <= 0 || meta.EpisodeInt <= 0 {
 		return ""
 	}
@@ -125,7 +124,7 @@ func detectResolution(value string) string {
 	return ""
 }
 
-func resolutionValue(meta api.PreparedMetadata) string {
+func resolutionValue(meta api.UploadSubject) string {
 	resolution := strings.TrimSpace(meta.Release.Resolution)
 	if resolution == "" {
 		resolution = detectResolution(meta.ReleaseName)
@@ -139,7 +138,7 @@ func resolutionValue(meta api.PreparedMetadata) string {
 	return resolution
 }
 
-func videoQualityID(site siteDefinition, meta api.PreparedMetadata) string {
+func videoQualityID(site siteDefinition, meta api.UploadSubject) string {
 	resolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
 	if resolution == "" {
 		resolution = strings.ToLower(detectResolution(meta.ReleaseName))
@@ -166,7 +165,7 @@ func videoQualityID(site siteDefinition, meta api.PreparedMetadata) string {
 	}
 }
 
-func ripTypeName(meta api.PreparedMetadata) string {
+func ripTypeName(meta api.UploadSubject) string {
 	typeValue := strings.ToLower(strings.TrimSpace(meta.Type))
 	source := strings.ToLower(strings.TrimSpace(meta.Source))
 	discType := strings.ToLower(strings.TrimSpace(meta.DiscType))
@@ -218,7 +217,7 @@ func ripTypeName(meta api.PreparedMetadata) string {
 	}
 }
 
-func ripTypeID(meta api.PreparedMetadata) string {
+func ripTypeID(meta api.UploadSubject) string {
 	switch ripTypeName(meta) {
 	case "BDRip":
 		return "1"
@@ -259,7 +258,7 @@ func ripTypeID(meta api.PreparedMetadata) string {
 	}
 }
 
-func anonEnabled(req trackers.UploadRequest) bool {
+func anonEnabled(req trackers.PreparationInput) bool {
 	return req.TrackerConfig.Anon
 }
 
diff --git a/internal/trackers/impl/azfamily/definition.go b/internal/trackers/impl/azfamily/definition.go
index 7a70b951..3a49ab57 100644
--- a/internal/trackers/impl/azfamily/definition.go
+++ b/internal/trackers/impl/azfamily/definition.go
@@ -12,34 +12,119 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Definition provides one AZ-family tracker profile through the shared contracts.
 type Definition struct {
 	site siteDefinition
 }
 
+// New returns the CZ or PHD profile for those normalized names and the AZ
+// profile for every other value.
 func New(name string) *Definition {
 	return &Definition{site: siteFor(name)}
 }
 
+// Name returns the stable tracker identifier for this AZ-family profile.
 func (d *Definition) Name() string {
 	return d.site.Name
 }
 
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, applyTrackerConfig(d.site, req.TrackerConfig), req)
+// TrackerFamily identifies the definition as AZ-family-backed.
+func (d *Definition) TrackerFamily() trackers.Family { return trackers.FamilyAZFamily }
+
+// UploadContentMode declares the aggregate description workflow shared by AZ-family sites.
+func (d *Definition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+
+// DefaultBaseURL returns the profile-owned tracker endpoint.
+func (d *Definition) DefaultBaseURL() string { return d.site.BaseURL }
+
+// TorrentIdentityPolicy returns this site's tracker announce identity patterns.
+func (d *Definition) TorrentIdentityPolicy() *trackers.TorrentIdentityPolicy {
+	return &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{d.site.DefaultAnnounceURL}}
+}
+
+// UploadArtifactPolicy returns torrent personalization for this AZ-family profile.
+func (d *Definition) UploadArtifactPolicy() *trackers.UploadArtifactPolicy {
+	return &trackers.UploadArtifactPolicy{
+		Source:          d.site.SourceFlag,
+		DefaultAnnounce: d.site.DefaultAnnounceURL,
+	}
+}
+
+// MetadataPolicy returns metadata requirements for this AZ-family profile.
+func (d *Definition) MetadataPolicy() *trackers.TrackerMetadataPolicy {
+	return &trackers.TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []trackers.MetadataRequirement{
+		{
+			Scope:       trackers.MetadataScopeMovie,
+			AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDBIDOnly, trackers.MetadataFieldIMDBIDOnly},
+			Disposition: api.RuleDispositionStrict,
+		},
+		{
+			Scope:       trackers.MetadataScopeTV,
+			AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDBIDOnly, trackers.MetadataFieldIMDBIDOnly, trackers.MetadataFieldTVDBIDOnly},
+			Disposition: api.RuleDispositionStrict,
+		},
+	}}
+}
+
+// BannedGroups returns the static banned release-group list for this AZ-family profile.
+func (d *Definition) BannedGroups() []string {
+	if d.site.Name != "PHD" {
+		return nil
+	}
+	return []string{
+		"RARBG",
+		"STUTTERSHIT",
+		"LiGaS",
+		"DDR",
+		"Zeus",
+		"TBS",
+		"SWTYBLZ",
+		"EASports",
+		"C4K",
+		"d3g",
+		"MeGusta",
+		"YTS",
+		"YIFY",
+		"Tigole",
+		"x0r",
+		"nikt0",
+		"NhaNc3",
+		"PRoDJi",
+		"RDN",
+		"SANTi",
+		"FaNGDiNG0",
+		"FRDS",
+		"HD2DVD",
+		"HDTime",
+		"iPlanet",
+		"KiNGDOM",
+		"Leffe",
+		"4K4U",
+		"Xiaomi",
+		"VisionXpert",
+		"WKS",
+	}
+}
+
+// Prepare builds a fresh intent-scoped tracker plan for this AZ-family profile.
+func (d *Definition) Prepare(ctx context.Context, input trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.PrepareAdapter(ctx, input, d.prepareDescription, d.prepareUpload)
 }
 
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, applyTrackerConfig(d.site, req.TrackerConfig), req)
+func (d *Definition) prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	return prepareUpload(ctx, applyTrackerConfig(d.site, req.TrackerConfig), req)
 }
 
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
+func (d *Definition) prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
 	select {
 	case <-ctx.Done():
 		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
 	if err != nil {
 		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 			return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
diff --git a/internal/trackers/impl/azfamily/definition_test.go b/internal/trackers/impl/azfamily/definition_test.go
index e2ec98f9..8153a8d5 100644
--- a/internal/trackers/impl/azfamily/definition_test.go
+++ b/internal/trackers/impl/azfamily/definition_test.go
@@ -14,13 +14,19 @@ import (
 	"strconv"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+func testDefinitionAt(baseURL string) *Definition {
+	site := siteFor("AZ")
+	site.BaseURL = baseURL
+	site.RequestsURL = strings.TrimRight(baseURL, "/") + "/requests"
+	return &Definition{site: site}
+}
+
 func TestBuildUploadDryRunBlockedWhenMediaMissing(t *testing.T) {
 	tmp := t.TempDir()
 
@@ -38,16 +44,18 @@ func TestBuildUploadDryRunBlockedWhenMediaMissing(t *testing.T) {
 	parsedServerURL, _ := url.Parse(server.URL)
 	writeAZCookieFile(t, tmp, "AZ", parsedServerURL.Hostname())
 
-	entry, err := New("AZ").BuildUploadDryRun(context.Background(), trackers.UploadRequest{
+	plan, failure := testDefinitionAt(server.URL).Prepare(context.Background(), trackers.PreparationInput{
+		Intent:        trackers.PreparationIntentDryRun,
 		Tracker:       "AZ",
-		Meta:          api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 123}},
-		TrackerConfig: config.TrackerConfig{URL: server.URL},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
+		Meta:          api.UploadSubject{Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 123}},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
 		Logger:        api.NopLogger{},
 	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+	if failure != nil {
+		t.Fatalf("unexpected error: %v", failure)
 	}
+	entry := plan.DryRun()
 	if entry.Status != "blocked" {
 		t.Fatalf("expected blocked status, got %q", entry.Status)
 	}
@@ -94,34 +102,39 @@ func TestUploadSuccess(t *testing.T) {
 	parsedServerURL, _ := url.Parse(server.URL)
 	writeAZCookieFile(t, tmp, "AZ", parsedServerURL.Hostname())
 
-	repo := azRepoStub{
-		images: []string{
-			server.URL + imagePaths[0],
-			server.URL + imagePaths[1],
-			server.URL + imagePaths[2],
-		},
-	}
-
-	result, err := New("AZ").Upload(context.Background(), trackers.UploadRequest{
+	plan, failure := testDefinitionAt(server.URL).Prepare(context.Background(), trackers.PreparationInput{
+		Intent:  trackers.PreparationIntentUpload,
 		Tracker: "AZ",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Example.Release.2026.mkv"),
 			TorrentPath:       torrentPath,
 			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{Category: "MOVIE", IMDBID: 123},
-			ReleaseName:       "Movie.2024.1080p.WEB-DL.x265-GRP",
-			Release:           api.ReleaseInfo{Title: "Movie", Year: 2024, Resolution: "1080p"},
+			Identity:          api.ExternalIdentity{Category: "MOVIE", IMDBID: 123},
+			ReleaseName:       "Example.Release.2026.1080p.WEB-DL.x265-GRP",
+			Release: api.ReleaseInfo{
+				Title:      "Example Release",
+				Year:       2026,
+				Resolution: "1080p",
+			},
 			Type:              "WEBDL",
 			Container:         "mkv",
 			AudioLanguages:    []string{"English"},
 			SubtitleLanguages: []string{"English"},
 			Options:           api.UploadOptions{KeepImages: true},
 		},
-		TrackerConfig: config.TrackerConfig{URL: server.URL},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
 		Logger:        api.NopLogger{},
-		Repo:          repo,
+		Assets: &trackers.DescriptionAssets{Screenshots: []api.ScreenshotImage{
+			{RawURL: server.URL + imagePaths[0]},
+			{RawURL: server.URL + imagePaths[1]},
+			{RawURL: server.URL + imagePaths[2]},
+		}},
 	})
+	if failure != nil {
+		t.Fatalf("unexpected upload preparation error: %v", failure)
+	}
+	result, err := plan.Submit(context.Background())
 	if err != nil {
 		t.Fatalf("unexpected upload error: %v", err)
 	}
@@ -163,17 +176,18 @@ func TestBuildUploadDryRunAllowsTVWebDLRipType(t *testing.T) {
 	parsedServerURL, _ := url.Parse(server.URL)
 	writeAZCookieFile(t, tmp, "AZ", parsedServerURL.Hostname())
 
-	entry, err := New("AZ").BuildUploadDryRun(context.Background(), trackers.UploadRequest{
+	plan, failure := testDefinitionAt(server.URL).Prepare(context.Background(), trackers.PreparationInput{
+		Intent:  trackers.PreparationIntentDryRun,
 		Tracker: "AZ",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Show.S01E02.1080p.WEB-DL.mkv"),
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Example.Show.S01E02.1080p.WEB-DL.mkv"),
 			TorrentPath:       torrentPath,
 			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{Category: "TV", IMDBID: 123},
-			ReleaseName:       "Show.S01E02.1080p.WEB-DL-GRP",
+			Identity:          api.ExternalIdentity{Category: "TV", IMDBID: 123},
+			ReleaseName:       "Example.Show.S01E02.1080p.WEB-DL-GRP",
 			Release: api.ReleaseInfo{
 				Category:   "TV",
-				Title:      "Show",
+				Title:      "Example Show",
 				Resolution: "1080p",
 				Source:     "WEB-DL",
 				Type:       "WEB-DL",
@@ -186,14 +200,15 @@ func TestBuildUploadDryRunAllowsTVWebDLRipType(t *testing.T) {
 			SeasonInt:         1,
 			EpisodeInt:        2,
 		},
-		TrackerConfig: config.TrackerConfig{URL: server.URL},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
 		Logger:        api.NopLogger{},
-		Repo:          azRepoStub{},
+		Assets:        &trackers.DescriptionAssets{},
 	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+	if failure != nil {
+		t.Fatalf("unexpected error: %v", failure)
 	}
+	entry := plan.DryRun()
 	if entry.Status == "blocked" && strings.Contains(entry.Message, "rip type") {
 		t.Fatalf("expected WEB-DL TV release not to be blocked by rip type, got %q", entry.Message)
 	}
@@ -213,99 +228,3 @@ func writeAZCookieFile(t *testing.T, tmp string, tracker string, domain string)
 		t.Fatalf("write cookie file: %v", err)
 	}
 }
-
-type azRepoStub struct {
-	images []string
-}
-
-func (a azRepoStub) GetByPath(context.Context, string) (api.FileMetadata, error) {
-	return api.FileMetadata{}, nil
-}
-func (a azRepoStub) Save(context.Context, api.FileMetadata) error { return nil }
-func (a azRepoStub) GetExternalIDs(context.Context, string) (api.ExternalIDs, error) {
-	return api.ExternalIDs{}, nil
-}
-func (a azRepoStub) SaveExternalIDs(context.Context, api.ExternalIDs) error { return nil }
-func (a azRepoStub) GetExternalMetadata(context.Context, string) (api.ExternalMetadata, error) {
-	return api.ExternalMetadata{}, nil
-}
-func (a azRepoStub) SaveExternalMetadata(context.Context, api.ExternalMetadata) error { return nil }
-func (a azRepoStub) GetDVDMediaInfo(context.Context, string) (api.DVDMediaInfo, error) {
-	return api.DVDMediaInfo{}, nil
-}
-func (a azRepoStub) SaveDVDMediaInfo(context.Context, api.DVDMediaInfo) error { return nil }
-func (a azRepoStub) GetReleaseNameOverrides(context.Context, string) (api.ReleaseNameOverrides, error) {
-	return api.ReleaseNameOverrides{}, nil
-}
-func (a azRepoStub) SaveReleaseNameOverrides(context.Context, string, api.ReleaseNameOverrides) error {
-	return nil
-}
-func (a azRepoStub) DeleteReleaseNameOverrides(context.Context, string) error { return nil }
-func (a azRepoStub) GetDescriptionOverride(context.Context, string, string) (api.DescriptionOverride, error) {
-	return api.DescriptionOverride{}, nil
-}
-func (a azRepoStub) ListDescriptionOverridesByPath(context.Context, string) ([]api.DescriptionOverride, error) {
-	return nil, nil
-}
-func (a azRepoStub) SaveDescriptionOverride(context.Context, api.DescriptionOverride) error {
-	return nil
-}
-func (a azRepoStub) DeleteDescriptionOverride(context.Context, string, string) error { return nil }
-func (a azRepoStub) GetPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
-	return api.PlaylistSelection{}, nil
-}
-func (a azRepoStub) SavePlaylistSelection(context.Context, string, []string, bool) error { return nil }
-func (a azRepoStub) DeletePlaylistSelection(context.Context, string) error               { return nil }
-func (a azRepoStub) ListHistoryEntries(context.Context) ([]api.HistoryEntry, error)      { return nil, nil }
-func (a azRepoStub) ListUploadHistoryByPath(context.Context, string) ([]api.UploadRecord, error) {
-	return nil, nil
-}
-func (a azRepoStub) ListPendingUploads(context.Context) ([]api.UploadRecord, error) { return nil, nil }
-func (a azRepoStub) CreateUploadRecord(context.Context, api.UploadRecord) error     { return nil }
-func (a azRepoStub) UpdateLatestUploadRecordStatus(context.Context, string, string, string) error {
-	return nil
-}
-func (a azRepoStub) SaveTrackerRuleFailures(context.Context, string, string, []api.TrackerRuleFailure) error {
-	return nil
-}
-func (a azRepoStub) ListTrackerRuleFailuresByPath(context.Context, string) ([]api.TrackerRuleFailure, error) {
-	return nil, nil
-}
-func (a azRepoStub) GetTrackerTimestamp(context.Context, string) (time.Time, error) {
-	return time.Time{}, nil
-}
-func (a azRepoStub) SaveTrackerTimestamp(context.Context, api.TrackerTimestamp) error { return nil }
-func (a azRepoStub) SaveTrackerMetadata(context.Context, api.TrackerMetadata) error   { return nil }
-func (a azRepoStub) ListTrackerMetadataByPath(context.Context, string) ([]api.TrackerMetadata, error) {
-	return []api.TrackerMetadata{{Tracker: "AZ", ImageURLs: a.images}}, nil
-}
-func (a azRepoStub) SaveScreenshot(context.Context, api.Screenshot) error { return nil }
-func (a azRepoStub) ListScreenshotsByPath(context.Context, string) ([]api.Screenshot, error) {
-	return nil, nil
-}
-func (a azRepoStub) DeleteScreenshot(context.Context, string) error { return nil }
-func (a azRepoStub) SaveFinalSelections(context.Context, string, []api.ScreenshotFinalSelection) error {
-	return nil
-}
-func (a azRepoStub) ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error) {
-	return nil, nil
-}
-func (a azRepoStub) DeleteFinalSelection(context.Context, string) error { return nil }
-func (a azRepoStub) ReplaceScreenshotSlots(context.Context, string, []api.ScreenshotSlot) error {
-	return nil
-}
-func (a azRepoStub) ListScreenshotSlotsByPath(context.Context, string) ([]api.ScreenshotSlot, error) {
-	return nil, nil
-}
-func (a azRepoStub) UpsertScreenshotSlotVariants(context.Context, string, []api.ScreenshotSlotVariant) error {
-	return nil
-}
-func (a azRepoStub) SaveUploadedImages(context.Context, string, string, []api.UploadedImageLink) error {
-	return nil
-}
-func (a azRepoStub) ListUploadedImagesByPath(context.Context, string) ([]api.UploadedImageLink, error) {
-	return nil, nil
-}
-func (a azRepoStub) DeleteUploadedImage(context.Context, string, string, string) error { return nil }
-func (a azRepoStub) ListStoredReleasePaths(context.Context) ([]string, error)          { return nil, nil }
-func (a azRepoStub) PurgeContentData(context.Context, string) error                    { return nil }
diff --git a/internal/trackers/impl/azfamily/description.go b/internal/trackers/impl/azfamily/description.go
index f66b911d..58f3cd1a 100644
--- a/internal/trackers/impl/azfamily/description.go
+++ b/internal/trackers/impl/azfamily/description.go
@@ -48,15 +48,15 @@ func buildDescription(raw string) string {
 	return strings.Join(cleaned, "<br>\n")
 }
 
-func buildDescriptionFromAssets(ctx context.Context, req trackers.UploadRequest) string {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
+func buildDescriptionFromAssets(_ context.Context, req trackers.PreparationInput) string {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
 	if err != nil {
 		return ""
 	}
 	return buildDescription(assets.Description)
 }
 
-func editName(site siteDefinition, meta api.PreparedMetadata) string {
+func editName(site siteDefinition, meta api.UploadSubject) string {
 	name := strings.TrimSpace(meta.ReleaseName)
 	if name == "" {
 		name = strings.TrimSpace(meta.ReleaseNameNoTag)
@@ -65,8 +65,8 @@ func editName(site siteDefinition, meta api.PreparedMetadata) string {
 		name = strings.TrimSpace(meta.Filename)
 	}
 	aka := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		aka = strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalTitle)
+	if meta.ProviderMetadata.TMDB != nil {
+		aka = strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalTitle)
 	}
 	if aka != "" {
 		name = strings.ReplaceAll(name, aka, "")
diff --git a/internal/trackers/impl/azfamily/dupe.go b/internal/trackers/impl/azfamily/dupe.go
new file mode 100644
index 00000000..ecd38e80
--- /dev/null
+++ b/internal/trackers/impl/azfamily/dupe.go
@@ -0,0 +1,397 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package azfamily
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	tracker string
+	baseURL string
+	cfg     config.Config
+	http    *http.Client
+	logger  api.Logger
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func (d *Definition) NewDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		tracker: deps.Tracker(),
+		baseURL: d.site.BaseURL,
+		cfg:     cfg,
+		http:    httpClient,
+		logger:  logger,
+	}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	tracker := h.tracker
+	if h.http == nil {
+		return dupe.Failed(dupe.FailureInternal, "AZ-family handler misconfigured: no HTTP client", nil)
+	}
+	site := azDupeSiteDef{baseURL: h.baseURL}
+	loadedCookies, err := loadAZFamilyCookies(ctx, h.cfg, tracker, site.baseURL)
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, fmt.Sprintf("missing valid %s cookies", strings.ToUpper(strings.TrimSpace(tracker))), nil)
+	}
+	mediaCode, err := h.lookupMediaCode(ctx, site, loadedCookies, meta)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, strings.ToUpper(strings.TrimSpace(tracker))+" request failed", err)
+	}
+	if mediaCode == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, strings.ToUpper(strings.TrimSpace(tracker))+" media missing from tracker database", nil)
+	}
+	pageURL := site.baseURL + "/movies/torrents/" + mediaCode + "?quality=" + url.QueryEscape(azDupeResolution(meta))
+	entries, err := h.fetchTorrentList(ctx, site, loadedCookies, pageURL, meta)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, strings.ToUpper(strings.TrimSpace(tracker))+" search failed", err)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func (h dupeSearcher) lookupMediaCode(ctx context.Context, site azDupeSiteDef, cookies []*http.Cookie, meta api.DuplicateSubject) (string, error) {
+	term := lookupAZDupeTitle(meta)
+	imdb := ""
+	if meta.Identity.IMDBID != 0 {
+		imdb = fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return "", fmt.Errorf("AZ dupe search: require canonical category: %w", err)
+	}
+	categoryID := "1"
+	if category == api.CanonicalCategoryTV {
+		categoryID = "2"
+	}
+	search := func(term string) ([]map[string]any, error) {
+		if strings.TrimSpace(term) == "" {
+			return nil, nil
+		}
+		endpoint := fmt.Sprintf("%s/ajax/movies/%s?term=%s", site.baseURL, categoryID, url.QueryEscape(term))
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+		if err != nil {
+			return nil, fmt.Errorf("dupechecking: create %s media lookup request: %w", site.baseURL, err)
+		}
+		req.Header.Set("User-Agent", "upbrr")
+		req.Header.Set("X-Requested-With", "XMLHttpRequest")
+		for _, cookie := range cookies {
+			req.AddCookie(cookie)
+		}
+		resp, err := h.http.Do(req)
+		if err != nil {
+			return nil, fmt.Errorf("dupechecking: fetch %s media lookup: %w", site.baseURL, err)
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+			return nil, fmt.Errorf("status %d", resp.StatusCode)
+		}
+		var payload struct {
+			Data []map[string]any `json:"data"`
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+			return nil, fmt.Errorf("dupechecking: decode %s media lookup: %w", site.baseURL, err)
+		}
+		return payload.Data, nil
+	}
+
+	items, err := search(imdb)
+	if err != nil {
+		return "", err
+	}
+	if len(items) == 0 {
+		items, err = search(term)
+		if err != nil {
+			return "", err
+		}
+	}
+	for _, item := range items {
+		if imdb != "" && strings.EqualFold(stringFromAny(item["imdb"]), imdb) {
+			return stringFromAny(item["id"]), nil
+		}
+	}
+	if len(items) > 0 {
+		return stringFromAny(items[0]["id"]), nil
+	}
+	return "", nil
+}
+
+func (h dupeSearcher) fetchTorrentList(
+	ctx context.Context,
+	site azDupeSiteDef,
+	cookies []*http.Cookie,
+	pageURL string,
+	meta api.DuplicateSubject,
+) ([]api.DupeEntry, error) {
+	results := make([]api.DupeEntry, 0)
+	visited := make(map[string]struct{})
+	ripType := azDupeRipType(meta)
+	for strings.TrimSpace(pageURL) != "" {
+		if _, ok := visited[pageURL]; ok {
+			break
+		}
+		visited[pageURL] = struct{}{}
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, pageURL, nil)
+		if err != nil {
+			return nil, fmt.Errorf("dupechecking: create %s torrent list request: %w", site.baseURL, err)
+		}
+		req.Header.Set("User-Agent", "upbrr")
+		for _, cookie := range cookies {
+			req.AddCookie(cookie)
+		}
+		resp, err := h.http.Do(req)
+		if err != nil {
+			return nil, fmt.Errorf("dupechecking: fetch %s torrent list: %w", site.baseURL, err)
+		}
+		root, err := xhtml.Parse(resp.Body)
+		_ = resp.Body.Close()
+		if err != nil {
+			return nil, fmt.Errorf("dupechecking: parse %s search response: %w", site.baseURL, err)
+		}
+		rows := findTorrentRows(root)
+		for _, row := range rows {
+			entry := parseAZDupeRow(row, site)
+			if entry.Name == "" {
+				continue
+			}
+			if ripType != "" && !containsFlag(entry.Flags, ripType) {
+				continue
+			}
+			results = append(results, entry)
+		}
+		pageURL = nextAZPage(root, site.baseURL)
+	}
+	return results, nil
+}
+
+type azDupeSiteDef struct {
+	baseURL string
+}
+
+func loadAZFamilyCookies(ctx context.Context, cfg config.Config, tracker string, baseURL string) ([]*http.Cookie, error) {
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return nil, fmt.Errorf("parse baseURL %q: %w", baseURL, err)
+	}
+	host := parsed.Hostname()
+	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, cfg.MainSettings.DBPath, strings.ToUpper(strings.TrimSpace(tracker)), host)
+	if err != nil {
+		return nil, fmt.Errorf("dupechecking: load AZ-family cookies: %w", err)
+	}
+	return loaded, nil
+}
+
+func lookupAZDupeTitle(meta api.DuplicateSubject) string {
+	if title := strings.TrimSpace(meta.Release.Title); title != "" {
+		return title
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		if title := strings.TrimSpace(meta.ProviderMetadata.TMDB.Title); title != "" {
+			return title
+		}
+	}
+	return strings.TrimSpace(meta.Filename)
+}
+
+func azDupeResolution(meta api.DuplicateSubject) string {
+	value := strings.TrimSpace(meta.Release.Resolution)
+	if value == "" {
+		value = detectResolution(meta.ReleaseName)
+	}
+	switch strings.ToLower(value) {
+	case "2160p":
+		return "UHD"
+	case "720p", "1080p":
+		return value
+	default:
+		return "all"
+	}
+}
+
+func azDupeRipType(meta api.DuplicateSubject) string {
+	switch strings.ToLower(strings.TrimSpace(meta.Type)) {
+	case "bdrip":
+		return "BDRip"
+	case "encode":
+		return "BluRay"
+	case "brrip":
+		return "BRRip"
+	case "dvdrip":
+		return "DVDRip"
+	case "hdrip":
+		return "HDRip"
+	case "hdtv":
+		return "HDTV"
+	case "sdtv":
+		return "SDTV"
+	case "webdl":
+		return "WEB-DL"
+	case "webrip":
+		return "WEBRip"
+	case "remux":
+		if strings.Contains(strings.ToLower(strings.TrimSpace(meta.Source)), "dvd") {
+			return "DVD Remux"
+		}
+		return "BluRay REMUX"
+	default:
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+			return "BluRay Raw"
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+			return "DVD"
+		}
+		return ""
+	}
+}
+
+func findTorrentRows(root *xhtml.Node) []*xhtml.Node {
+	rows := make([]*xhtml.Node, 0)
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil {
+			return
+		}
+		if node.Type == xhtml.ElementNode && node.Data == "tr" {
+			rows = append(rows, node)
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(root)
+	return rows
+}
+
+func parseAZDupeRow(row *xhtml.Node, site azDupeSiteDef) api.DupeEntry {
+	entry := api.DupeEntry{}
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil {
+			return
+		}
+		if node.Type == xhtml.ElementNode && node.Data == "span" && strings.Contains(attrValueHTML(node, "class"), "badge-extra") {
+			if value := strings.TrimSpace(nodeTextHTML(node)); value != "" {
+				entry.Flags = append(entry.Flags, value)
+			}
+		}
+		if node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "class"), "torrent-filename") {
+			entry.Name = strings.TrimSpace(nodeTextHTML(node))
+			href := strings.TrimSpace(attrValueHTML(node, "href"))
+			if href != "" {
+				entry.Link = absoluteAZURL(site.baseURL, href)
+				if id := extractAZTorrentID(entry.Link); id != "" {
+					entry.ID = id
+				}
+			}
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(row)
+	return entry
+}
+
+func nextAZPage(root *xhtml.Node, baseURL string) string {
+	var next string
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil || next != "" {
+			return
+		}
+		if node.Type == xhtml.ElementNode && node.Data == "a" && strings.EqualFold(attrValueHTML(node, "rel"), "next") {
+			next = absoluteAZURL(baseURL, attrValueHTML(node, "href"))
+			return
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(root)
+	return next
+}
+
+func containsFlag(flags []string, want string) bool {
+	for _, flag := range flags {
+		if strings.EqualFold(strings.TrimSpace(flag), strings.TrimSpace(want)) {
+			return true
+		}
+	}
+	return false
+}
+
+func attrValueHTML(node *xhtml.Node, key string) string {
+	for _, attr := range node.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return strings.TrimSpace(attr.Val)
+		}
+	}
+	return ""
+}
+
+func nodeTextHTML(node *xhtml.Node) string {
+	if node == nil {
+		return ""
+	}
+	if node.Type == xhtml.TextNode {
+		return node.Data
+	}
+	var builder strings.Builder
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		builder.WriteString(nodeTextHTML(child))
+	}
+	return builder.String()
+}
+
+func absoluteAZURL(baseURL, value string) string {
+	trimmed := strings.TrimSpace(value)
+	if strings.HasPrefix(trimmed, "http://") || strings.HasPrefix(trimmed, "https://") {
+		return trimmed
+	}
+	return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(trimmed, "/")
+}
+
+func extractAZTorrentID(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	parts := strings.Split(strings.Trim(trimmed, "/"), "/")
+	last := parts[len(parts)-1]
+	if _, err := strconv.Atoi(last); err == nil {
+		return last
+	}
+	return ""
+}
+
+func stringFromAny(value any) string {
+	if value == nil {
+		return ""
+	}
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case json.Number:
+		return typed.String()
+	default:
+		return strings.TrimSpace(fmt.Sprint(value))
+	}
+}
diff --git a/internal/trackers/impl/azfamily/dupe_test.go b/internal/trackers/impl/azfamily/dupe_test.go
new file mode 100644
index 00000000..350f20a1
--- /dev/null
+++ b/internal/trackers/impl/azfamily/dupe_test.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package azfamily
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+func TestAZNetworkHandlerSearchParsesHTMLResults(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "ua.db")
+	cookieDir := filepath.Join(tmp, "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/ajax/movies/1":
+			_, _ = io.WriteString(w, `{"data":[{"id":"77","imdb":"tt0000123"}]}`)
+		case "/movies/torrents/77":
+			_, _ = io.WriteString(w, `<table class="table-bordered"><tbody><tr><td><a class="torrent-filename" href="/torrent/123">Movie.2024.1080p.WEB-DL.x265-GRP</a><span class="badge-extra">WEB-DL</span></td></tr></tbody></table>`)
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	parsed, _ := url.Parse(server.URL)
+	cookieText := "# Netscape HTTP Cookie File\n" + parsed.Hostname() + "\tTRUE\t/\tTRUE\t0\tsession\tcookievalue\n"
+	if err := os.WriteFile(filepath.Join(cookieDir, "AZ.txt"), []byte(cookieText), 0o600); err != nil {
+		t.Fatalf("write cookie file: %v", err)
+	}
+
+	handler := dupe.NewAdapter(testDefinitionAt(server.URL), "AZ",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+			Trackers:     config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"AZ": {}}},
+		}, server.Client(), api.NopLogger{})
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 123},
+		Release:  api.ReleaseInfo{Title: "Movie", Resolution: "1080p"},
+		Type:     "WEBDL",
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(entries))
+	}
+	if entries[0].ID != "123" {
+		t.Fatalf("expected torrent id 123, got %q", entries[0].ID)
+	}
+}
diff --git a/internal/trackers/impl/azfamily/language.go b/internal/trackers/impl/azfamily/language.go
index 4a201798..8f1e37de 100644
--- a/internal/trackers/impl/azfamily/language.go
+++ b/internal/trackers/impl/azfamily/language.go
@@ -9,7 +9,7 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func languageValues(meta api.PreparedMetadata) languageBundle {
+func languageValues(meta api.UploadSubject) languageBundle {
 	audioSet := make(map[string]struct{})
 	for _, value := range meta.AudioLanguages {
 		if id, ok := languageID(value); ok {
diff --git a/internal/trackers/impl/azfamily/payload.go b/internal/trackers/impl/azfamily/payload.go
index 7497555c..1a67ae2a 100644
--- a/internal/trackers/impl/azfamily/payload.go
+++ b/internal/trackers/impl/azfamily/payload.go
@@ -24,7 +24,16 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func buildFinalPayload(ctx context.Context, site siteDefinition, state sessionState, req trackers.UploadRequest, mediaCode string, task taskInfo, fileInfo string, screenshotIDs []string) (url.Values, error) {
+func buildFinalPayload(
+	ctx context.Context,
+	site siteDefinition,
+	state sessionState,
+	req trackers.PreparationInput,
+	mediaCode string,
+	task taskInfo,
+	fileInfo string,
+	screenshotIDs []string,
+) (url.Values, error) {
 	langs := languageValues(req.Meta)
 	tags, err := resolveTags(ctx, site, state, req)
 	if err != nil {
@@ -75,7 +84,7 @@ func buildFinalPayload(ctx context.Context, site siteDefinition, state sessionSt
 	return values, nil
 }
 
-func resolveTags(ctx context.Context, site siteDefinition, state sessionState, req trackers.UploadRequest) ([]string, error) {
+func resolveTags(ctx context.Context, site siteDefinition, state sessionState, req trackers.PreparationInput) ([]string, error) {
 	seen := make(map[string]struct{})
 	add := func(value string) {
 		if trimmed := strings.TrimSpace(value); trimmed != "" {
@@ -85,7 +94,7 @@ func resolveTags(ctx context.Context, site siteDefinition, state sessionState, r
 	if req.Meta.PersonalRelease {
 		add(site.PersonalReleaseTag)
 	}
-	if trackers.IsInternalGroup(req.AppConfig, site.Name, req.Meta) {
+	if req.Runtime.Internal {
 		add(site.InternalTagID)
 	}
 	for _, keyword := range splitKeywords(keywordsFor(req.Meta)) {
@@ -131,8 +140,8 @@ func fetchTagID(ctx context.Context, site siteDefinition, state sessionState, wo
 	return "", nil
 }
 
-func uploadScreenshots(ctx context.Context, site siteDefinition, state sessionState, req trackers.UploadRequest) ([]string, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
+func uploadScreenshots(ctx context.Context, site siteDefinition, state sessionState, req trackers.PreparationInput) ([]string, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
 	if err != nil {
 		return nil, fmt.Errorf("trackers: %w", err)
 	}
@@ -245,9 +254,9 @@ func screenshotBytes(ctx context.Context, client *http.Client, shot api.Screensh
 	return data, filename, nil
 }
 
-func keywordsFor(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
+func keywordsFor(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
 	}
 	return ""
 }
diff --git a/internal/trackers/impl/azfamily/rules.go b/internal/trackers/impl/azfamily/rules.go
new file mode 100644
index 00000000..80bf1c59
--- /dev/null
+++ b/internal/trackers/impl/azfamily/rules.go
@@ -0,0 +1,588 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package azfamily
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules returns the profile's country, age, and technical eligibility checks.
+// Country routing and blocking, PHD SD content, and H.264 above 1080p are
+// strict failures; remaining failures are waivable.
+func (d *Definition) Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{Check: d.evaluateRules}
+}
+
+func (d *Definition) evaluateRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0)
+	add := func(rule, reason string) {
+		failures = append(failures, trackers.NewRuleFailure(rule, reason, api.RuleDispositionWaivable))
+	}
+	addStrict := func(rule, reason string) {
+		failures = append(failures, trackers.NewRuleFailure(rule, reason, api.RuleDispositionStrict))
+	}
+	category := strings.ToUpper(strings.TrimSpace(trackers.ResolveRuleCategory(meta)))
+	if category != "MOVIE" && category != "TV" {
+		add("content_type", "only movies and TV shows are allowed")
+	}
+	if meta.Anime {
+		add("anime_redirect", "anime should be uploaded to AnimeTorrents instead")
+	}
+	origin := originCountries(meta)
+	switch d.site.Name {
+	case "AZ":
+		if intersects(origin, phdCountries()) {
+			addStrict("country_redirect", "major English-language content belongs on PrivateHD")
+		} else if intersects(origin, cinemaZCountries()) {
+			addStrict("country_redirect", "non-Asian western content belongs on CinemaZ")
+		}
+	case "CZ":
+		switch {
+		case intersects(origin, phdCountries()) && !isOlderThan50Years(meta):
+			addStrict("country_redirect", "recent mainstream English content belongs on PrivateHD")
+		case intersects(origin, azCountries()):
+			addStrict("country_redirect", "Asian content belongs on AvistaZ")
+		case len(origin) > 0 && !intersects(origin, czAllowedCountries()):
+			addStrict("country_block", "content origin is outside CinemaZ allowed regions")
+		}
+	case "PHD":
+		if isOlderThan50Years(meta) {
+			add("age_redirect", "50+ year-old content belongs on CinemaZ")
+		}
+		switch {
+		case intersects(origin, cinemaZCountries()):
+			addStrict("country_redirect", "European, South American, and African content belongs on CinemaZ")
+		case intersects(origin, azCountries()):
+			addStrict("country_redirect", "Asian content belongs on AvistaZ")
+		case len(origin) > 0 && !intersects(origin, phdCountries()):
+			addStrict("country_block", "PrivateHD only allows major English-language territories")
+		}
+		evaluatePHDTechnicalRules(meta, add, addStrict)
+	}
+	return failures, nil
+}
+
+func evaluatePHDTechnicalRules(meta api.RuleSubject, add func(string, string), addStrict func(string, string)) {
+	resolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
+	if resolution == "480p" || resolution == "576p" || resolution == "480i" || resolution == "576i" {
+		addStrict("sd_forbidden", "SD content is forbidden")
+	}
+	if !trackers.IsDiscType(meta.DiscType) {
+		container := strings.ToLower(strings.TrimSpace(meta.Container))
+		if container != "" && container != "mkv" && container != "mp4" {
+			add("container", "allowed containers: MKV, MP4")
+		}
+	}
+	group := strings.ToUpper(strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-"))
+	switch group {
+	case "RARBG", "FGT", "GRYM", "TBS":
+		add("group_block", "RARBG, FGT, Grym, and TBS are not allowed")
+	}
+	if group == "EVO" && !strings.EqualFold(strings.TrimSpace(meta.Source), "WEB") {
+		add("group_block", "non-web EVO releases are not allowed")
+	}
+	codec := strings.ToLower(strings.TrimSpace(meta.VideoCodec))
+	encode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
+	releaseType := strings.ToLower(strings.TrimSpace(trackers.ResolveRuleType(meta)))
+	source := strings.ToLower(strings.TrimSpace(meta.Source))
+	if releaseType == "remux" && codec != "" && codec != "mpeg-2" && codec != "vc-1" && codec != "h.264" && codec != "h.265" && codec != "avc" {
+		add("video_codec", "BluRay remuxes require MPEG-2, VC-1, H.264, or H.265")
+	}
+	if releaseType == "encode" && strings.Contains(source, "bluray") && encode != "" && encode != "h.264" && encode != "h.265" && encode != "x264" &&
+		encode != "x265" {
+		add("video_encode", "BluRay encodes require H.264/H.265 with x264/x265")
+	}
+	if (releaseType == "webdl" || releaseType == "web-dl") && source == "web" && encode != "" && encode != "h.264" && encode != "h.265" && encode != "vp9" {
+		add("video_encode", "WEB-DL requires H.264, H.265, or VP9")
+	}
+	if releaseType == "encode" && source == "web" && encode != "" && encode != "h.264" && encode != "h.265" && encode != "x264" && encode != "x265" {
+		add("video_encode", "WEB encodes require H.264/H.265 with x264/x265")
+	}
+	if releaseType == "encode" && encode == "x265" && strings.TrimSpace(meta.BitDepth) != "10" {
+		add("bit_depth", "x265 encodes must be 10-bit")
+	}
+	if res := trackers.ResolveRuleResolution(meta); strings.HasSuffix(res, "p") {
+		if height, err := strconv.Atoi(strings.TrimSuffix(res, "p")); err == nil && height > 1080 && (encode == "h.264" || encode == "x264") {
+			addStrict("h264_resolution_limit", "H.264/x264 is only allowed for 1080p and below")
+		}
+	}
+}
+
+func originCountries(meta api.RuleSubject) []string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return meta.ProviderMetadata.TMDB.OriginCountry
+	}
+	return nil
+}
+
+func isOlderThan50Years(meta api.RuleSubject) bool {
+	year := meta.Release.Year
+	if year == 0 && meta.ProviderMetadata.TMDB != nil {
+		year = meta.ProviderMetadata.TMDB.Year
+	}
+	return year > 0 && time.Now().UTC().Year()-year >= 50
+}
+
+func intersects(left []string, right map[string]struct{}) bool {
+	for _, value := range left {
+		if _, ok := right[strings.ToUpper(strings.TrimSpace(value))]; ok {
+			return true
+		}
+	}
+	return false
+}
+
+func countrySet(values ...string) map[string]struct{} {
+	out := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		out[value] = struct{}{}
+	}
+	return out
+}
+
+func azCountries() map[string]struct{} {
+	return countrySet(
+		"BD",
+		"BN",
+		"BT",
+		"CN",
+		"HK",
+		"ID",
+		"IN",
+		"JP",
+		"KH",
+		"KP",
+		"KR",
+		"LA",
+		"LK",
+		"MM",
+		"MN",
+		"MO",
+		"MY",
+		"NP",
+		"PH",
+		"PK",
+		"SG",
+		"TH",
+		"TL",
+		"TW",
+		"VN",
+	)
+}
+func phdCountries() map[string]struct{} {
+	return countrySet(
+		"AG",
+		"AI",
+		"AU",
+		"BB",
+		"BM",
+		"BS",
+		"BZ",
+		"CA",
+		"CW",
+		"DM",
+		"GB",
+		"GD",
+		"IE",
+		"JM",
+		"KN",
+		"KY",
+		"LC",
+		"MS",
+		"NZ",
+		"PR",
+		"TC",
+		"TT",
+		"US",
+		"VC",
+		"VG",
+		"VI",
+	)
+}
+
+func cinemaZCountries() map[string]struct{} {
+	all := countrySet(
+		"AO",
+		"BF",
+		"BI",
+		"BJ",
+		"BW",
+		"CD",
+		"CF",
+		"CG",
+		"CI",
+		"CM",
+		"CV",
+		"DJ",
+		"DZ",
+		"EG",
+		"EH",
+		"ER",
+		"ET",
+		"GA",
+		"GH",
+		"GM",
+		"GN",
+		"GQ",
+		"GW",
+		"IO",
+		"KE",
+		"KM",
+		"LR",
+		"LS",
+		"LY",
+		"MA",
+		"MG",
+		"ML",
+		"MR",
+		"MU",
+		"MW",
+		"MZ",
+		"NA",
+		"NE",
+		"NG",
+		"RE",
+		"RW",
+		"SC",
+		"SD",
+		"SH",
+		"SL",
+		"SN",
+		"SO",
+		"SS",
+		"ST",
+		"SZ",
+		"TD",
+		"TF",
+		"TG",
+		"TN",
+		"TZ",
+		"UG",
+		"YT",
+		"ZA",
+		"ZM",
+		"ZW",
+		"AG",
+		"AI",
+		"AR",
+		"AW",
+		"BB",
+		"BL",
+		"BM",
+		"BO",
+		"BQ",
+		"BR",
+		"BS",
+		"BV",
+		"BZ",
+		"CA",
+		"CL",
+		"CO",
+		"CR",
+		"CU",
+		"CW",
+		"DM",
+		"DO",
+		"EC",
+		"FK",
+		"GD",
+		"GF",
+		"GL",
+		"GP",
+		"GS",
+		"GT",
+		"GY",
+		"HN",
+		"HT",
+		"JM",
+		"KN",
+		"KY",
+		"LC",
+		"MF",
+		"MQ",
+		"MS",
+		"MX",
+		"NI",
+		"PA",
+		"PE",
+		"PM",
+		"PR",
+		"PY",
+		"SR",
+		"SV",
+		"SX",
+		"TC",
+		"TT",
+		"US",
+		"UY",
+		"VC",
+		"VE",
+		"VG",
+		"VI",
+		"AD",
+		"AL",
+		"AT",
+		"AX",
+		"BA",
+		"BE",
+		"BG",
+		"BY",
+		"CH",
+		"CZ",
+		"DE",
+		"DK",
+		"EE",
+		"ES",
+		"FI",
+		"FO",
+		"FR",
+		"GB",
+		"GG",
+		"GI",
+		"GR",
+		"HR",
+		"HU",
+		"IE",
+		"IM",
+		"IS",
+		"IT",
+		"JE",
+		"LI",
+		"LT",
+		"LU",
+		"LV",
+		"MC",
+		"MD",
+		"ME",
+		"MK",
+		"MT",
+		"NL",
+		"NO",
+		"PL",
+		"PT",
+		"RO",
+		"RS",
+		"RU",
+		"SE",
+		"SI",
+		"SJ",
+		"SK",
+		"SM",
+		"SU",
+		"UA",
+		"VA",
+		"XC",
+		"AS",
+		"AU",
+		"CC",
+		"CK",
+		"CX",
+		"FJ",
+		"FM",
+		"GU",
+		"HM",
+		"KI",
+		"MH",
+		"MP",
+		"NC",
+		"NF",
+		"NR",
+		"NU",
+		"NZ",
+		"PF",
+		"PG",
+		"PN",
+		"PW",
+		"SB",
+		"TK",
+		"TO",
+		"TV",
+		"UM",
+		"VU",
+		"WF",
+		"WS",
+	)
+	for code := range phdCountries() {
+		delete(all, code)
+	}
+	for code := range azCountries() {
+		delete(all, code)
+	}
+	return all
+}
+
+func czAllowedCountries() map[string]struct{} {
+	return countrySet(
+		"AD",
+		"AL",
+		"AT",
+		"AX",
+		"BA",
+		"BE",
+		"BG",
+		"BY",
+		"CH",
+		"CZ",
+		"DE",
+		"DK",
+		"EE",
+		"ES",
+		"FI",
+		"FO",
+		"FR",
+		"GI",
+		"GR",
+		"HR",
+		"HU",
+		"IS",
+		"IT",
+		"LI",
+		"LT",
+		"LU",
+		"LV",
+		"MC",
+		"MD",
+		"ME",
+		"MK",
+		"MT",
+		"NL",
+		"NO",
+		"PL",
+		"PT",
+		"RO",
+		"RS",
+		"RU",
+		"SE",
+		"SI",
+		"SJ",
+		"SK",
+		"SM",
+		"SU",
+		"UA",
+		"VA",
+		"XC",
+		"AG",
+		"AI",
+		"AR",
+		"AW",
+		"BL",
+		"BO",
+		"BQ",
+		"BR",
+		"BV",
+		"CL",
+		"CO",
+		"CU",
+		"DO",
+		"EC",
+		"FK",
+		"GF",
+		"GL",
+		"GP",
+		"GS",
+		"GT",
+		"GY",
+		"HN",
+		"HT",
+		"MF",
+		"MQ",
+		"MX",
+		"NI",
+		"PA",
+		"PE",
+		"PM",
+		"PY",
+		"SR",
+		"SV",
+		"SX",
+		"UY",
+		"VE",
+		"AO",
+		"BF",
+		"BI",
+		"BJ",
+		"BW",
+		"CD",
+		"CF",
+		"CG",
+		"CI",
+		"CM",
+		"CV",
+		"DJ",
+		"DZ",
+		"EG",
+		"EH",
+		"ER",
+		"ET",
+		"GA",
+		"GH",
+		"GM",
+		"GN",
+		"GQ",
+		"GW",
+		"IO",
+		"KE",
+		"KM",
+		"LR",
+		"LS",
+		"LY",
+		"MA",
+		"MG",
+		"ML",
+		"MR",
+		"MU",
+		"MW",
+		"MZ",
+		"NA",
+		"NE",
+		"NG",
+		"RE",
+		"RW",
+		"SC",
+		"SD",
+		"SH",
+		"SL",
+		"SN",
+		"SO",
+		"SS",
+		"ST",
+		"SZ",
+		"TD",
+		"TF",
+		"TG",
+		"TN",
+		"TZ",
+		"UG",
+		"YT",
+		"ZA",
+		"ZM",
+		"ZW",
+		"AE",
+		"BH",
+		"CY",
+		"IR",
+		"IQ",
+		"IL",
+		"JO",
+		"KW",
+		"LB",
+		"OM",
+		"PS",
+		"QA",
+		"SA",
+		"SY",
+		"TR",
+		"YE",
+	)
+}
diff --git a/internal/trackers/impl/azfamily/rules_test.go b/internal/trackers/impl/azfamily/rules_test.go
new file mode 100644
index 00000000..66ff3fdc
--- /dev/null
+++ b/internal/trackers/impl/azfamily/rules_test.go
@@ -0,0 +1,112 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package azfamily
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func evaluateSiteRules(t *testing.T, tracker string, meta api.RuleSubject) []api.RuleFailure {
+	t.Helper()
+	failures, err := New(tracker).evaluateRules(context.Background(), meta, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("evaluate %s rules: %v", tracker, err)
+	}
+	return failures
+}
+
+func TestEvaluateRulesAZRedirectsEnglishTerritories(t *testing.T) {
+	t.Parallel()
+
+	failures := evaluateSiteRules(t, "AZ", api.RuleSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{OriginCountry: []string{"US"}},
+		},
+	})
+	if len(failures) == 0 {
+		t.Fatal("expected AZ rule failure")
+	}
+}
+
+func TestEvaluateRulesCZRejectsAsianContent(t *testing.T) {
+	t.Parallel()
+
+	failures := evaluateSiteRules(t, "CZ", api.RuleSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{OriginCountry: []string{"JP"}},
+		},
+	})
+	if len(failures) == 0 {
+		t.Fatal("expected CZ rule failure")
+	}
+}
+
+func TestEvaluateRulesCountryRestrictionsAreStrict(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		tracker string
+		country string
+		rule    string
+	}{
+		{
+name: "AZ redirect",
+ tracker: "AZ",
+ country: "US",
+ rule: "country_redirect",
+},
+		{
+name: "CZ block",
+ tracker: "CZ",
+ country: "AQ",
+ rule: "country_block",
+},
+		{
+name: "PHD block",
+ tracker: "PHD",
+ country: "AQ",
+ rule: "country_block",
+},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			failures := evaluateSiteRules(t, test.tracker, api.RuleSubject{
+				Identity: api.ExternalIdentity{Category: "MOVIE"},
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{OriginCountry: []string{test.country}},
+				},
+			})
+			for _, failure := range failures {
+				if failure.Rule == test.rule {
+					if failure.Disposition != api.RuleDispositionStrict {
+						t.Fatalf("%s disposition = %q, want strict", test.rule, failure.Disposition)
+					}
+					return
+				}
+			}
+			t.Fatalf("missing %s failure: %#v", test.rule, failures)
+		})
+	}
+}
+
+func TestEvaluateRulesPHDRejectsSDAndBlockedGroup(t *testing.T) {
+	t.Parallel()
+
+	failures := evaluateSiteRules(t, "PHD", api.RuleSubject{
+		Identity:  api.ExternalIdentity{Category: "MOVIE"},
+		Release:   api.ReleaseInfo{Resolution: "480p"},
+		Container: "avi",
+		Tag:       "-RARBG",
+	})
+	if len(failures) < 2 {
+		t.Fatalf("expected multiple PHD failures, got %v", failures)
+	}
+}
diff --git a/internal/trackers/impl/azfamily/session.go b/internal/trackers/impl/azfamily/session.go
index ecaae4f5..34cd7ee1 100644
--- a/internal/trackers/impl/azfamily/session.go
+++ b/internal/trackers/impl/azfamily/session.go
@@ -54,7 +54,12 @@ func newSession(ctx context.Context, site siteDefinition, dbPath string, logger
 	defer resp.Body.Close()
 	body, readErr := io.ReadAll(io.LimitReader(resp.Body, 4096))
 	if readErr != nil && logger != nil {
-		logger.Debugf("trackers: %s cookie validation body read failed status=%d err=%s", site.Name, resp.StatusCode, redaction.RedactValue(readErr.Error(), nil))
+		logger.Debugf(
+			"trackers: %s cookie validation body read failed status=%d err=%s",
+			site.Name,
+			resp.StatusCode,
+			redaction.RedactValue(readErr.Error(), nil),
+		)
 	}
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 || strings.Contains(strings.ToLower(string(body)), "page not found") {
 		return sessionState{}, fmt.Errorf("trackers: %s missing valid cookies", site.Name)
@@ -66,7 +71,7 @@ func newSession(ctx context.Context, site siteDefinition, dbPath string, logger
 	return sessionState{client: client, token: token}, nil
 }
 
-func lookupMediaCode(ctx context.Context, site siteDefinition, state sessionState, meta api.PreparedMetadata) (mediaLookupResult, error) {
+func lookupMediaCode(ctx context.Context, site siteDefinition, state sessionState, meta api.UploadSubject) (mediaLookupResult, error) {
 	categoryIDValue := categoryID(meta)
 	if categoryIDValue == "" {
 		return mediaLookupResult{}, fmt.Errorf("trackers: %s unsupported category", site.Name)
@@ -150,7 +155,7 @@ func mediaItemMatchesIDs(item map[string]any, imdbID, tmdbID, tvdbID string) boo
 		(tvdbID != "" && strings.EqualFold(stringValue(item["tvdb"]), tvdbID))
 }
 
-func searchRequests(ctx context.Context, site siteDefinition, state sessionState, meta api.PreparedMetadata) ([]string, error) {
+func searchRequests(ctx context.Context, site siteDefinition, state sessionState, meta api.UploadSubject) ([]string, error) {
 	query := lookupTitle(meta)
 	if isTV(meta) {
 		query = strings.TrimSpace(query + " " + tvCode(meta))
diff --git a/internal/trackers/impl/azfamily/session_test.go b/internal/trackers/impl/azfamily/session_test.go
index 0a2f88da..c5b47c04 100644
--- a/internal/trackers/impl/azfamily/session_test.go
+++ b/internal/trackers/impl/azfamily/session_test.go
@@ -47,8 +47,8 @@ func TestLookupMediaCodeSupportsTVDBOnlyTV(t *testing.T) {
 	}))
 	t.Cleanup(server.Close)
 
-	result, err := lookupMediaCode(context.Background(), siteDefinition{Name: "AZ", BaseURL: server.URL}, sessionState{client: server.Client()}, api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 456789},
+	result, err := lookupMediaCode(context.Background(), siteDefinition{Name: "AZ", BaseURL: server.URL}, sessionState{client: server.Client()}, api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 456789},
 	})
 	if err != nil {
 		t.Fatalf("lookup TVDB media: %v", err)
@@ -62,13 +62,13 @@ func TestLookupMediaCodeReturnsExactMatchBeforeLaterProviderFailure(t *testing.T
 	t.Parallel()
 	tests := []struct {
 		name      string
-		meta      api.PreparedMetadata
+		meta      api.UploadSubject
 		responses map[string]mediaSearchResponse
 		wantCode  string
 	}{
 		{
 			name: "imdb before tmdb failure",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{
 				Category: "MOVIE",
 				IMDBID:   123,
 				TMDBID:   456,
@@ -81,7 +81,7 @@ func TestLookupMediaCodeReturnsExactMatchBeforeLaterProviderFailure(t *testing.T
 		},
 		{
 			name: "tmdb before tvdb failure",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{
 				Category: "TV",
 				IMDBID:   123,
 				TMDBID:   456,
@@ -96,7 +96,7 @@ func TestLookupMediaCodeReturnsExactMatchBeforeLaterProviderFailure(t *testing.T
 		},
 		{
 			name: "tvdb after earlier misses",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{
 				Category: "TV",
 				IMDBID:   123,
 				TMDBID:   456,
@@ -142,7 +142,11 @@ func TestLookupMediaCodeReturnsProviderErrorWithoutEarlierExactMatch(t *testing.
 		context.Background(),
 		siteDefinition{Name: "AZ", BaseURL: server.URL},
 		sessionState{client: server.Client()},
-		api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 123, TMDBID: 456}},
+		api.UploadSubject{Identity: api.ExternalIdentity{
+			Category: "MOVIE",
+			IMDBID:   123,
+			TMDBID:   456,
+		}},
 	)
 	if err == nil || !strings.Contains(err.Error(), "media search by tmdb failed") {
 		t.Fatal("expected later provider failure when no earlier exact match exists")
@@ -160,9 +164,9 @@ func TestLookupMediaCodeSelectsExactIDFromTitleResults(t *testing.T) {
 		context.Background(),
 		siteDefinition{Name: "AZ", BaseURL: server.URL},
 		sessionState{client: server.Client()},
-		api.PreparedMetadata{
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", TMDBID: 456},
-			Release:     api.ReleaseInfo{Title: "Example Release 2026", Year: 2026},
+		api.UploadSubject{
+			Identity: api.ExternalIdentity{Category: "MOVIE", TMDBID: 456},
+			Release:  api.ReleaseInfo{Title: "Example Release 2026", Year: 2026},
 		},
 	)
 	if err != nil {
@@ -187,9 +191,9 @@ func TestLookupMediaCodeRejectsUnmatchedTitleResults(t *testing.T) {
 		context.Background(),
 		siteDefinition{Name: "AZ", BaseURL: server.URL},
 		sessionState{client: server.Client()},
-		api.PreparedMetadata{
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", TMDBID: 456},
-			Release:     api.ReleaseInfo{Title: "Example Release 2026", Year: 2026},
+		api.UploadSubject{
+			Identity: api.ExternalIdentity{Category: "MOVIE", TMDBID: 456},
+			Release:  api.ReleaseInfo{Title: "Example Release 2026", Year: 2026},
 		},
 	)
 	if err != nil {
diff --git a/internal/trackers/impl/azfamily/sites.go b/internal/trackers/impl/azfamily/sites.go
index 447832fa..c7d0673d 100644
--- a/internal/trackers/impl/azfamily/sites.go
+++ b/internal/trackers/impl/azfamily/sites.go
@@ -54,10 +54,6 @@ func siteFor(name string) siteDefinition {
 	}
 }
 
-func applyTrackerConfig(site siteDefinition, trackerCfg config.TrackerConfig) siteDefinition {
-	if value := strings.TrimSpace(trackerCfg.URL); value != "" {
-		site.BaseURL = strings.TrimRight(value, "/")
-		site.RequestsURL = site.BaseURL + "/requests"
-	}
+func applyTrackerConfig(site siteDefinition, _ config.TrackerConfig) siteDefinition {
 	return site
 }
diff --git a/internal/trackers/impl/azfamily/upload.go b/internal/trackers/impl/azfamily/upload.go
index cd53ede6..4449b362 100644
--- a/internal/trackers/impl/azfamily/upload.go
+++ b/internal/trackers/impl/azfamily/upload.go
@@ -16,54 +16,103 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func upload(ctx context.Context, site siteDefinition, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := newSession(ctx, site, req.AppConfig.MainSettings.DBPath, req.Logger)
+// prepareUpload performs authenticated lookup for every intent. Upload intent
+// also creates the remote task and uploads screenshots during preparation, then
+// captures the finalized form, client session, redirect, and local torrent
+// target for one later submission.
+func prepareUpload(ctx context.Context, site siteDefinition, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	if req.Intent != trackers.PreparationIntentUpload {
+		preview, err := buildUploadDryRun(ctx, site, req)
+		if err != nil {
+			return trackers.PreparedOperation{}, err
+		}
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	state, err := newSession(ctx, site, req.Runtime.DBPath, req.Logger)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	media, err := lookupMediaCode(ctx, site, state, req.Meta)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	if media.Missing || strings.TrimSpace(media.MediaCode) == "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %s media missing from tracker database; add it on-site at %s/add/%s then retry", site.Name, site.BaseURL, categorySlug(req.Meta))
+		return trackers.PreparedOperation{}, fmt.Errorf(
+			"trackers: %s media missing from tracker database; add it on-site at %s/add/%s then retry",
+			site.Name,
+			site.BaseURL,
+			categorySlug(req.Meta),
+		)
 	}
 	if requests, err := searchRequests(ctx, site, state, req.Meta); err == nil && len(requests) > 0 && req.Logger != nil {
 		req.Logger.Infof("trackers: %s matched %d open request(s)", site.Name, len(requests))
 	}
 
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	fileInfo, err := resolveMediaInfoText(req.Meta)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	task, err := createTask(ctx, site, state, req, media.MediaCode, fileInfo, torrentPath)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	screenshots, err := uploadScreenshots(ctx, site, state, req)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
 	if len(screenshots) < 3 {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %s image host returned fewer than 3 screenshots", site.Name)
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %s image host returned fewer than 3 screenshots", site.Name)
 	}
 	payload, err := buildFinalPayload(ctx, site, state, req, media.MediaCode, task, fileInfo, screenshots)
 	if err != nil {
-		return api.UploadSummary{}, err
+		return trackers.PreparedOperation{}, err
 	}
-	resp, err := postForm(ctx, noRedirectClient(state.client), task.RedirectURL, payload, map[string]string{
-		"Referer":    task.RedirectURL,
+	trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.Runtime.DBPath, site.Name)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := api.TrackerDryRunEntry{
+		Tracker:          site.Name,
+		Status:           "ready",
+		Message:          "upload payload prepared",
+		ReleaseName:      editName(site, req.Meta),
+		DescriptionGroup: "azfamily",
+		Description:      payload.Get("description"),
+		Endpoint:         site.BaseURL + "/upload/" + categorySlug(req.Meta),
+		Payload:          valuesToMap(payload),
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent_file",
+			Path:    torrentPath,
+			Present: true,
+		}},
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, site, state.client, task.RedirectURL, payload, trackerTorrentPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	site siteDefinition,
+	client *http.Client,
+	redirectURL string,
+	payload url.Values,
+	trackerTorrentPath string,
+) (api.UploadSummary, error) {
+	resp, err := postForm(ctx, noRedirectClient(client), redirectURL, payload, map[string]string{
+		"Referer":    redirectURL,
 		"User-Agent": azCookieUserAgent,
 	})
 	if err != nil {
@@ -82,11 +131,7 @@ func upload(ctx context.Context, site siteDefinition, req trackers.UploadRequest
 		return api.UploadSummary{}, fmt.Errorf("trackers: %s upload failed: missing torrent id", site.Name)
 	}
 	downloadURL := strings.Replace(torrentURL, "/torrent/", "/download/torrent/", 1)
-	trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, site.Name)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if err := downloadTrackerTorrent(ctx, state.client, downloadURL, trackerTorrentPath); err != nil {
+	if err := downloadTrackerTorrent(ctx, client, downloadURL, trackerTorrentPath); err != nil {
 		return api.UploadSummary{}, fmt.Errorf("trackers: %s personalized torrent download: %w", site.Name, err)
 	}
 	return api.UploadSummary{
@@ -101,8 +146,8 @@ func upload(ctx context.Context, site siteDefinition, req trackers.UploadRequest
 	}, nil
 }
 
-func buildUploadDryRun(ctx context.Context, site siteDefinition, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := newSession(ctx, site, req.AppConfig.MainSettings.DBPath, req.Logger)
+func buildUploadDryRun(ctx context.Context, site siteDefinition, req trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	state, err := newSession(ctx, site, req.Runtime.DBPath, req.Logger)
 	if err != nil {
 		return api.TrackerDryRunEntry{}, err
 	}
@@ -110,7 +155,7 @@ func buildUploadDryRun(ctx context.Context, site siteDefinition, req trackers.Up
 	if err != nil {
 		return api.TrackerDryRunEntry{}, err
 	}
-	torrentPath, _ := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
+	torrentPath, _ := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
 	if media.Missing || strings.TrimSpace(media.MediaCode) == "" {
 		return api.TrackerDryRunEntry{
 			Tracker: site.Name,
@@ -152,7 +197,13 @@ func buildUploadDryRun(ctx context.Context, site siteDefinition, req trackers.Up
 	}, nil
 }
 
-func createTask(ctx context.Context, site siteDefinition, state sessionState, req trackers.UploadRequest, mediaCode, fileInfo, torrentPath string) (taskInfo, error) {
+func createTask(
+	ctx context.Context,
+	site siteDefinition,
+	state sessionState,
+	req trackers.PreparationInput,
+	mediaCode, fileInfo, torrentPath string,
+) (taskInfo, error) {
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 	for key, value := range map[string]string{
@@ -210,7 +261,7 @@ func createTask(ctx context.Context, site siteDefinition, state sessionState, re
 	}, nil
 }
 
-func resolveMediaInfoText(meta api.PreparedMetadata) (string, error) {
+func resolveMediaInfoText(meta api.UploadSubject) (string, error) {
 	if path := strings.TrimSpace(meta.MediaInfoTextPath); path != "" {
 		if data, err := os.ReadFile(path); err == nil {
 			return string(data), nil
@@ -219,7 +270,7 @@ func resolveMediaInfoText(meta api.PreparedMetadata) (string, error) {
 	return "", errors.New("trackers: missing MediaInfo/BDInfo text")
 }
 
-func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
+func resolveTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
 	for _, candidate := range []string{strings.TrimSpace(meta.TorrentPath), strings.TrimSpace(meta.ClientTorrentPath)} {
 		if candidate == "" {
 			continue
@@ -231,7 +282,7 @@ func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error
 	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
 		tmpRoot, err := db.Subdir(dbPath, "tmp")
 		if err == nil {
-			tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+			tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 			if err == nil {
 				guessed := filepath.Join(tmpDir, base+".torrent")
 				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
@@ -243,12 +294,12 @@ func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error
 	return "", errors.New("trackers: torrent file not found")
 }
 
-func resolveTrackerTorrentPath(meta api.PreparedMetadata, dbPath string, tracker string) (string, error) {
+func resolveTrackerTorrentPath(meta api.UploadSubject, dbPath string, tracker string) (string, error) {
 	tmpRoot, err := db.Subdir(dbPath, "tmp")
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
diff --git a/internal/trackers/impl/bhd/definition.go b/internal/trackers/impl/bhd/definition.go
deleted file mode 100644
index a1ea433d..00000000
--- a/internal/trackers/impl/bhd/definition.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhd
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "BHD"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	var err error
-	var assets trackers.DescriptionAssets
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
-			}
-			if req.Logger != nil {
-				req.Logger.Warnf("trackers: BHD description assets failed: %v", err)
-			}
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-
-	description := buildDescription(req.Meta, req.AppConfig, assets)
-	return trackers.DescriptionResult{
-		Group:       "bhd",
-		Description: description,
-	}, nil
-}
diff --git a/internal/trackers/impl/bhd/definition_test.go b/internal/trackers/impl/bhd/definition_test.go
deleted file mode 100644
index 143649a4..00000000
--- a/internal/trackers/impl/bhd/definition_test.go
+++ /dev/null
@@ -1,640 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhd
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123, IMDBID: 456, Category: "TV"},
-			ReleaseName:       "Movie.2025.1080p.WEB-DL.DD+5.1.H264-GRP",
-			Release:           api.ReleaseInfo{Resolution: "1080p"},
-			Type:              "WEBDL",
-			Source:            "WEB",
-			Audio:             "DD+ 5.1",
-			HDR:               "HDR10+ DV",
-			Edition:           "Hybrid Director",
-			TVPack:            true,
-			SeasonStr:         "S00",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token", DraftDefault: true},
-		AppConfig: config.Config{
-			Trackers: config.TrackersConfig{
-				Trackers: map[string]config.TrackerConfig{
-					"BHD": {DraftDefault: true},
-				},
-			},
-		},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Payload["category_id"] != "2" {
-		t.Fatalf("expected tv category 2, got %q", entry.Payload["category_id"])
-	}
-	if entry.Payload["type"] != "1080p" {
-		t.Fatalf("expected type 1080p, got %q", entry.Payload["type"])
-	}
-	if entry.Payload["source"] != "WEB" {
-		t.Fatalf("expected source WEB, got %q", entry.Payload["source"])
-	}
-	if entry.Payload["imdb_id"] != "456" {
-		t.Fatalf("expected numeric imdb_id, got %q", entry.Payload["imdb_id"])
-	}
-	if entry.Payload["tmdb_id"] != "123" {
-		t.Fatalf("expected numeric tmdb_id, got %q", entry.Payload["tmdb_id"])
-	}
-	if entry.Payload["live"] != "0" {
-		t.Fatalf("expected live=0 for draft default, got %q", entry.Payload["live"])
-	}
-	if entry.Payload["pack"] != "1" {
-		t.Fatalf("expected pack=1, got %q", entry.Payload["pack"])
-	}
-	if entry.Payload["special"] != "1" {
-		t.Fatalf("expected special=1, got %q", entry.Payload["special"])
-	}
-	if entry.Payload["edition"] != "Director" {
-		t.Fatalf("expected title-cased edition, got %q", entry.Payload["edition"])
-	}
-	if got := entry.Payload["tags"]; !strings.Contains(got, "WEBDL") || !strings.Contains(got, "HDR10+") || !strings.Contains(got, "DV") {
-		t.Fatalf("expected BHD tags in payload, got %q", got)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunPrerequisiteMessagesIncludeAction(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name       string
-		req        trackers.UploadRequest
-		wantCause  string
-		wantAction string
-	}{
-		{
-			name: "missing api key",
-			req: trackers.UploadRequest{
-				Tracker: "BHD",
-				Meta:    api.PreparedMetadata{ExternalIDs: api.ExternalIDs{TMDBID: 123}},
-				Logger:  api.NopLogger{},
-			},
-			wantCause:  "missing api_key",
-			wantAction: "configure the BHD api_key",
-		},
-		{
-			name: "missing tmdb id",
-			req: trackers.UploadRequest{
-				Tracker:       "BHD",
-				TrackerConfig: config.TrackerConfig{APIKey: "token"},
-				Logger:        api.NopLogger{},
-			},
-			wantCause:  "missing tmdb id",
-			wantAction: "refresh metadata or set a TMDB id",
-		},
-		{
-			name: "missing mediainfo text",
-			req: trackers.UploadRequest{
-				Tracker:       "BHD",
-				TrackerConfig: config.TrackerConfig{APIKey: "token"},
-				Meta:          api.PreparedMetadata{ExternalIDs: api.ExternalIDs{TMDBID: 123}},
-				Logger:        api.NopLogger{},
-			},
-			wantCause:  "missing mediainfo text",
-			wantAction: "generate or attach MediaInfo",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := New().BuildUploadDryRun(context.Background(), tc.req)
-			if err == nil {
-				t.Fatalf("expected prerequisite error")
-			}
-			message := err.Error()
-			if !strings.Contains(message, tc.wantCause) {
-				t.Fatalf("expected cause %q in error, got %q", tc.wantCause, message)
-			}
-			if !strings.Contains(message, tc.wantAction) {
-				t.Fatalf("expected action %q in error, got %q", tc.wantAction, message)
-			}
-		})
-	}
-}
-
-func TestDefinitionBuildUploadDryRunRejectsInvalidContainer(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	_, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.avi"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123, Category: "MOVIE"},
-			Type:              "REMUX",
-			Container:         "avi",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		Logger:        api.NopLogger{},
-	})
-	if err == nil || !strings.Contains(err.Error(), "container") {
-		t.Fatalf("expected container validation error, got %v", err)
-	}
-}
-
-func TestResolveTypeRejectsBHD576iResolution(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "576i"}}
-	if got := resolveType(meta); got != "Other" {
-		t.Fatalf("expected BHD type Other for 576i, got %q", got)
-	}
-}
-
-func TestResolveTypeRejectsHDDVDRemuxEvenWithUHD(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{Type: "REMUX", Source: "HDDVD", UHD: "UHD"}
-	if got := resolveType(meta); got != "Other" {
-		t.Fatalf("expected BHD type Other for HD-DVD remux, got %q", got)
-	}
-}
-
-func TestDefinitionBuildUploadDryRunRejectsInvalidSource(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Example.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	_, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Example.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123, Category: "MOVIE"},
-			Release:           api.ReleaseInfo{Resolution: "1080p"},
-			Type:              "WEBDL",
-			Source:            "CAM",
-			Container:         "mkv",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		Logger:        api.NopLogger{},
-	})
-	if err == nil || !strings.Contains(err.Error(), "unsupported source") {
-		t.Fatalf("expected unsupported source error, got %v", err)
-	}
-}
-
-func TestUploadRetriesInvalidIMDb(t *testing.T) {
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	calls := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/upload/token" {
-			http.NotFound(w, r)
-			return
-		}
-		if err := r.ParseMultipartForm(4 << 20); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		if len(r.MultipartForm.File["mediainfo"]) != 1 {
-			t.Errorf("expected mediainfo file part")
-			return
-		}
-		if filename := r.MultipartForm.File["mediainfo"][0].Filename; filename != "upload" {
-			t.Errorf("expected Upload-Assistant-compatible mediainfo filename, got %q", filename)
-			return
-		}
-		if len(r.MultipartForm.File["file"]) != 1 {
-			t.Errorf("expected torrent file part")
-			return
-		}
-		if contentType := r.MultipartForm.File["file"][0].Header.Get("Content-Type"); contentType != "application/x-bittorrent" {
-			t.Errorf("expected Upload-Assistant-compatible torrent content type, got %q", contentType)
-			return
-		}
-		calls++
-		imdbID := r.FormValue("imdb_id")
-		tmdbID := r.FormValue("tmdb_id")
-		if tmdbID != "123" {
-			t.Errorf("expected tmdb_id 123, got %q", tmdbID)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		if calls == 1 {
-			if imdbID != "456" {
-				t.Errorf("expected first imdb_id 456, got %q", imdbID)
-				return
-			}
-			_, _ = fmt.Fprint(w, `{"status_code":0,"status_message":"Invalid imdb_id"}`)
-			return
-		}
-		if imdbID != "1" {
-			t.Errorf("expected retried imdb_id 1, got %q", imdbID)
-			return
-		}
-		_, _ = fmt.Fprint(w, `{"status_code":1,"status_message":"https://beyond-hd.me/torrent/download/example.7890.torrent"}`)
-	}))
-	defer server.Close()
-
-	originalBaseURL := bhdBaseURL
-	bhdBaseURL = server.URL
-	defer func() { bhdBaseURL = originalBaseURL }()
-
-	summary, err := New().Upload(context.Background(), trackers.UploadRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123, IMDBID: 456, Category: "MOVIE"},
-			ReleaseName:       "Movie.2025.1080p.BluRay.DD+5.1.H264-GRP",
-			Release:           api.ReleaseInfo{Resolution: "1080p"},
-			Type:              "REMUX",
-			Source:            "BluRay",
-			Audio:             "DD+ 5.1",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		AppConfig:     config.Config{},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if calls != 2 {
-		t.Fatalf("expected 2 upload attempts, got %d", calls)
-	}
-	if summary.Uploaded != 1 {
-		t.Fatalf("expected one upload, got %d", summary.Uploaded)
-	}
-	if len(summary.UploadedTorrents) != 1 || summary.UploadedTorrents[0].TorrentID != "7890" {
-		t.Fatalf("unexpected uploaded torrents: %+v", summary.UploadedTorrents)
-	}
-}
-
-func TestSendUploadRejectsOversizedResponseBody(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "Example.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = fmt.Fprint(w, strings.Repeat("x", int(bhdUploadResponseMaxBytes)+1))
-	}))
-	defer server.Close()
-
-	originalBaseURL := bhdBaseURL
-	bhdBaseURL = server.URL
-	defer func() { bhdBaseURL = originalBaseURL }()
-
-	_, _, err := sendUpload(context.Background(), trackers.UploadRequest{
-		Tracker:       "BHD",
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	}, uploadState{
-		torrentPath: torrentPath,
-		fields: map[string]string{
-			"name":        "Example.Release.2026.1080p-GRP",
-			"category_id": "1",
-			"type":        "1080p",
-			"source":      "WEB",
-			"tmdb_id":     "movie/123456",
-			"description": "Example description",
-		},
-	})
-	if err == nil || !strings.Contains(err.Error(), "response body exceeds") {
-		t.Fatalf("expected oversized response error, got %v", err)
-	}
-}
-
-func TestSendUploadRejectsNonSuccessHTTPStatus(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "Example.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	tests := []struct {
-		name       string
-		statusCode int
-		body       string
-		wantDetail string
-	}{
-		{
-			name:       "valid-looking success body",
-			statusCode: http.StatusInternalServerError,
-			body:       `{"status_code":1,"status_message":"https://beyond-hd.me/torrent/download/example.123456.torrent"}`,
-		},
-		{
-			name:       "ordinary error body",
-			statusCode: http.StatusUnprocessableEntity,
-			body:       `{"message":"upload rejected"}`,
-			wantDetail: "upload rejected",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(tt.statusCode)
-				_, _ = fmt.Fprint(w, tt.body)
-			}))
-			defer server.Close()
-
-			originalBaseURL := bhdBaseURL
-			bhdBaseURL = server.URL
-			defer func() { bhdBaseURL = originalBaseURL }()
-
-			_, responseBody, err := sendUpload(context.Background(), trackers.UploadRequest{
-				Tracker:       "BHD",
-				TrackerConfig: config.TrackerConfig{APIKey: "token"},
-			}, uploadState{
-				torrentPath: torrentPath,
-				fields: map[string]string{
-					"name":        "Example.Release.2026.1080p-GRP",
-					"category_id": "1",
-					"type":        "1080p",
-					"source":      "WEB",
-					"tmdb_id":     "movie/123456",
-					"description": "Example description",
-				},
-			})
-			if err == nil {
-				t.Fatal("expected non-success HTTP status error")
-			}
-			if !strings.Contains(err.Error(), fmt.Sprintf("status=%d", tt.statusCode)) {
-				t.Fatal("expected HTTP status in upload error")
-			}
-			if tt.wantDetail != "" && !strings.Contains(err.Error(), tt.wantDetail) {
-				t.Fatal("expected redacted response detail in upload error")
-			}
-			if string(responseBody) != tt.body {
-				t.Fatal("expected bounded response body to be returned")
-			}
-		})
-	}
-}
-
-func TestWriteFailureArtifactPreservesRepeatedFailures(t *testing.T) {
-	tmp := t.TempDir()
-	req := trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			SourcePath: filepath.Join(tmp, "Example.Release.2026.1080p-GRP.mkv"),
-		},
-		AppConfig: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "upbrr.db")},
-		},
-	}
-
-	firstPayload := []byte(`{"message":"first failure"}`)
-	firstPath, err := writeFailureArtifact(req, firstPayload, "upload_failure")
-	if err != nil {
-		t.Fatalf("write first failure artifact: %v", err)
-	}
-	secondPayload := []byte(`{"message":"second failure"}`)
-	secondPath, err := writeFailureArtifact(req, secondPayload, "upload_failure")
-	if err != nil {
-		t.Fatalf("write second failure artifact: %v", err)
-	}
-
-	firstInfo, err := os.Stat(firstPath)
-	if err != nil {
-		t.Fatalf("stat first failure artifact: %v", err)
-	}
-	secondInfo, err := os.Stat(secondPath)
-	if err != nil {
-		t.Fatalf("stat second failure artifact: %v", err)
-	}
-	if os.SameFile(firstInfo, secondInfo) {
-		t.Fatal("repeated failures must use distinct artifacts")
-	}
-	firstStored, err := os.ReadFile(firstPath)
-	if err != nil {
-		t.Fatalf("read first failure artifact: %v", err)
-	}
-	secondStored, err := os.ReadFile(secondPath)
-	if err != nil {
-		t.Fatalf("read second failure artifact: %v", err)
-	}
-	if string(firstStored) != string(firstPayload) || string(secondStored) != string(secondPayload) {
-		t.Fatal("repeated failure artifacts did not preserve both payloads")
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesProvidedAssets(t *testing.T) {
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			Options: api.UploadOptions{Screens: 4},
-		},
-		AppConfig: config.Config{},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: `[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
-			Screenshots: []api.ScreenshotImage{{
-				RawURL: "https://img.hdbits.org/full.jpg",
-				ImgURL: "https://t.hdbits.org/thumb.jpg",
-				WebURL: "https://img.hdbits.org/page",
-			}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
-		t.Fatalf("expected single signature, got %q", result.Description)
-	}
-	if !strings.Contains(result.Description, "[img width=350]https://img.hdbits.org/full.jpg[/img]") {
-		t.Fatalf("expected raw image url to be used, got %q", result.Description)
-	}
-}
-
-func TestBuildScreenshotSectionUsesTwoImagesPerRow(t *testing.T) {
-	images := []api.ScreenshotImage{
-		{RawURL: "https://img.example/1.png", WebURL: "https://img.example/1"},
-		{RawURL: "https://img.example/2.png", WebURL: "https://img.example/2"},
-		{RawURL: "https://img.example/3.png", WebURL: "https://img.example/3"},
-		{RawURL: "https://img.example/4.png", WebURL: "https://img.example/4"},
-	}
-
-	got := buildScreenshotSection(images, len(images))
-	want := strings.Join([]string{
-		`[align=center][url=https://img.example/1][img width=350]https://img.example/1.png[/img][/url] [url=https://img.example/2][img width=350]https://img.example/2.png[/img][/url]`,
-		``,
-		`[url=https://img.example/3][img width=350]https://img.example/3.png[/img][/url] [url=https://img.example/4][img width=350]https://img.example/4.png[/img][/url][/align]`,
-	}, "\n")
-	if got != want {
-		t.Fatalf("unexpected BHD screenshot layout: %q", got)
-	}
-}
-
-func TestDefinitionBuildDescriptionStripsLegacyCreatedFooter(t *testing.T) {
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			Options: api.UploadOptions{Screens: 4},
-		},
-		AppConfig: config.Config{},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: strings.Join([]string{
-				"Body",
-				`[align=right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/align]`,
-			}, "\n\n"),
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(result.Description, "Created by upbrr") {
-		t.Fatalf("expected legacy footer stripped, got %q", result.Description)
-	}
-	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
-		t.Fatalf("expected single current footer, got %q", result.Description)
-	}
-	if !strings.Contains(result.Description, "Body") {
-		t.Fatalf("expected body preserved, got %q", result.Description)
-	}
-}
-
-func TestDefinitionBuildDescriptionDoesNotRestoreRawImagesOnlyBody(t *testing.T) {
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			Options: api.UploadOptions{Screens: 4},
-		},
-		AppConfig: config.Config{},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: strings.Join([]string{
-				`[url=https://example.com/page][img]https://example.com/full.jpg[/img][/url]`,
-				`[right]Created by Upload Assistant[/right]`,
-			}, "\n\n"),
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(result.Description, "Upload Assistant") {
-		t.Fatalf("expected bot footer stripped, got %q", result.Description)
-	}
-	if strings.Count(result.Description, "https://example.com/full.jpg") != 1 {
-		t.Fatalf("expected one screenshot instance, got %q", result.Description)
-	}
-	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
-		t.Fatalf("expected single current footer, got %q", result.Description)
-	}
-}
-
-func TestDefinitionBuildDescriptionStripsRightFormUpbrrFooter(t *testing.T) {
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			Options: api.UploadOptions{Screens: 4},
-		},
-		AppConfig: config.Config{},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: strings.Join([]string{
-				"Body",
-				`[right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/right]`,
-			}, "\n\n"),
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
-		t.Fatalf("expected only current BHD footer, got %q", result.Description)
-	}
-	if strings.Contains(result.Description, "[right]") || strings.Contains(result.Description, "[size=10]upbrr[/size]") {
-		t.Fatalf("expected right-form footer stripped, got %q", result.Description)
-	}
-	if !strings.Contains(result.Description, "Body") {
-		t.Fatalf("expected body preserved, got %q", result.Description)
-	}
-}
-
-func TestDefinitionBuildDescriptionDoesNotRestoreBotOnlyBody(t *testing.T) {
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "BHD",
-		Meta: api.PreparedMetadata{
-			Options: api.UploadOptions{Screens: 4},
-		},
-		AppConfig: config.Config{},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: `[right]Created by Upload Assistant[/right]`,
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(result.Description, "Upload Assistant") {
-		t.Fatalf("expected bot-only body stripped, got %q", result.Description)
-	}
-	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
-		t.Fatalf("expected single current footer, got %q", result.Description)
-	}
-}
diff --git a/internal/trackers/impl/bhd/description.go b/internal/trackers/impl/bhd/description.go
deleted file mode 100644
index 3926bd17..00000000
--- a/internal/trackers/impl/bhd/description.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhd
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func buildDescription(meta api.PreparedMetadata, cfg config.Config, assets trackers.DescriptionAssets) string {
-	base := strings.TrimSpace(assets.Description)
-	if assets.Final {
-		return base
-	}
-
-	cleaned := bbcode.CleanBHDDescription(base, bbcode.BHDOptions{
-		Framestor: hasGroup(meta.Tag, "framestor"),
-		Flux:      hasGroup(meta.Tag, "flux"),
-	})
-
-	descriptionBody := strings.TrimSpace(cleaned.Description)
-	descriptionBody = stripUASignature(descriptionBody)
-	descriptionBody = strings.ReplaceAll(descriptionBody, "[img]", "[img width=300]")
-
-	images := assets.Screenshots
-	if len(images) == 0 {
-		images = screenshotsFromReport(cleaned.Images)
-	}
-
-	parts := make([]string, 0, 5)
-	if discSection := buildDiscSection(meta, cfg.MainSettings.DBPath); discSection != "" {
-		parts = append(parts, discSection)
-	}
-	if descriptionBody != "" {
-		parts = append(parts, descriptionBody)
-	}
-	if screenshots := buildScreenshotSection(images, maxInt(1, meta.Options.Screens)); screenshots != "" {
-		parts = append(parts, screenshots)
-	}
-	parts = append(parts, `[align=right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/align]`)
-	return strings.TrimSpace(strings.Join(parts, "\n\n"))
-}
-
-func buildDiscSection(meta api.PreparedMetadata, dbPath string) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "DVD":
-		media := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
-		if media == "" {
-			return ""
-		}
-		return fmt.Sprintf("[spoiler=VOB MediaInfo][code]%s[/code][/spoiler]", media)
-	case "BDMV":
-		text := readBDInfoNoErr(dbPath, meta)
-		if text == "" {
-			return ""
-		}
-		return fmt.Sprintf("[spoiler=BDINFO][code]%s[/code][/spoiler]", text)
-	default:
-		return ""
-	}
-}
-
-func buildScreenshotSection(images []api.ScreenshotImage, limit int) string {
-	if len(images) == 0 || limit <= 0 {
-		return ""
-	}
-
-	var section strings.Builder
-	section.WriteString("[align=center]")
-	count := 0
-	for _, image := range images {
-		if count >= limit {
-			break
-		}
-		imgURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.RawURL), strings.TrimSpace(image.ImgURL))
-		webURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.WebURL), strings.TrimSpace(image.RawURL), imgURL)
-		if imgURL == "" || webURL == "" {
-			continue
-		}
-		if count > 0 {
-			if count%2 == 0 {
-				section.WriteString("\n\n")
-			} else {
-				section.WriteByte(' ')
-			}
-		}
-		line := fmt.Sprintf("[url=%s][img width=350]%s[/img][/url]", webURL, imgURL)
-		section.WriteString(line)
-		count++
-	}
-	if count == 0 {
-		return ""
-	}
-	section.WriteString("[/align]")
-	return section.String()
-}
-
-func screenshotsFromReport(images []bbcode.Image) []api.ScreenshotImage {
-	if len(images) == 0 {
-		return nil
-	}
-	out := make([]api.ScreenshotImage, 0, len(images))
-	for idx, image := range images {
-		imgURL := strings.TrimSpace(image.ImgURL)
-		rawURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.RawURL), imgURL)
-		webURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.WebURL), rawURL, imgURL)
-		if imgURL == "" && rawURL == "" {
-			continue
-		}
-		out = append(out, api.ScreenshotImage{
-			Index:  idx,
-			Host:   strings.TrimSpace(image.Host),
-			ImgURL: metautil.FirstNonEmptyTrimmed(imgURL, rawURL),
-			RawURL: rawURL,
-			WebURL: webURL,
-		})
-	}
-	return out
-}
-
-func stripUASignature(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	signatures := []string{
-		`[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
-		`[align=right][url=https://github.com/autobrr/upbrr]upbrr[/url][/align]`,
-		`[align=right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/align]`,
-		`[align=right]Created by upbrr[/align]`,
-		`[align=right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/align]`,
-		`[right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/right]`,
-		`[right][url=https://github.com/autobrr/upbrr]upbrr[/url][/right]`,
-		`[right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/right]`,
-		`[right]Created by upbrr[/right]`,
-		`[right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/right]`,
-	}
-	for _, signature := range signatures {
-		trimmed = strings.TrimSpace(strings.ReplaceAll(trimmed, signature, ""))
-	}
-	return trimmed
-}
-
-func readTextFileNoErr(path string) string {
-	trimmed := strings.TrimSpace(path)
-	if trimmed == "" {
-		return ""
-	}
-	payload, err := os.ReadFile(trimmed)
-	if err != nil {
-		return ""
-	}
-	return string(payload)
-}
-
-func readBDInfoNoErr(dbPath string, meta api.PreparedMetadata) string {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return ""
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return ""
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return ""
-	}
-	return readTextFileNoErr(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta)))
-}
-
-func hasGroup(tag string, name string) bool {
-	trimmed := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(tag, "-")))
-	return trimmed == strings.ToLower(strings.TrimSpace(name))
-}
-
-func maxInt(left int, right int) int {
-	if left > right {
-		return left
-	}
-	return right
-}
diff --git a/internal/trackers/impl/bhd/upload.go b/internal/trackers/impl/bhd/upload.go
deleted file mode 100644
index 7bf6f373..00000000
--- a/internal/trackers/impl/bhd/upload.go
+++ /dev/null
@@ -1,591 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhd
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"mime/multipart"
-	"net/http"
-	"net/textproto"
-	"os"
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/bhdmeta"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	bhdBaseURL            = "https://beyond-hd.me"
-	bhdTorrentIDPattern   = regexp.MustCompile(`https://beyond-hd\.me/torrent/download/[^\"'\s]+?\.(\d+)\.`)
-	bhdInvalidIMDbPattern = regexp.MustCompile(`(?i)^invalid imdb_id`)
-)
-
-const bhdUploadResponseMaxBytes = commonhttp.DefaultResponsePreviewBytes
-
-type uploadState struct {
-	torrentPath string
-	mediaDump   string
-	description string
-	fields      map[string]string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	response, responseBody, err := sendUpload(ctx, req, state)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if response.StatusCode == 0 && bhdInvalidIMDbPattern.MatchString(response.StatusMessage) {
-		state.fields["imdb_id"] = "1"
-		response, responseBody, err = sendUpload(ctx, req, state)
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-	}
-	if response.StatusCode == 0 {
-		artifactPath, artifactErr := writeFailureArtifact(req, responseBody, "upload_failure")
-		if artifactErr != nil && req.Logger != nil {
-			req.Logger.Warnf("trackers: BHD failure artifact write failed: %v", artifactErr)
-		}
-		if artifactPath != "" && req.Logger != nil {
-			req.Logger.Warnf("trackers: BHD upload failure artifact saved to %s", artifactPath)
-		}
-		message := commonhttp.ExtractHTTPErrorDetail(responseBody)
-		if message == "" {
-			message = commonhttp.RedactErrorDetail(response.StatusMessage)
-		}
-		if message == "" {
-			message = "upload failed"
-		}
-		return api.UploadSummary{}, fmt.Errorf("trackers: BHD api error: %s", message)
-	}
-
-	torrentID := extractTorrentID(response.StatusMessage)
-	if torrentID == "" {
-		return api.UploadSummary{}, errors.New("trackers: BHD upload succeeded but torrent id was not returned")
-	}
-	torrentURL := strings.TrimRight(bhdBaseURL, "/") + "/details/" + torrentID
-	downloadURL := strings.TrimRight(bhdBaseURL, "/") + "/torrent/download/" + torrentID
-
-	artifactPath := ""
-	if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "BHD")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, "BHD"); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "BHD",
-			TorrentID:   torrentID,
-			DownloadURL: downloadURL,
-			TorrentURL:  torrentURL,
-			TorrentPath: artifactPath,
-		}},
-	}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "BHD",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      state.fields["name"],
-		DescriptionGroup: "bhd",
-		Description:      state.description,
-		Endpoint:         uploadEndpoint(strings.TrimSpace(req.TrackerConfig.APIKey)),
-		Payload:          cloneFields(state.fields),
-		Files: []api.TrackerDryRunFile{
-			{Field: "mediainfo", Path: resolveMediaPath(req.Meta, req.AppConfig.MainSettings.DBPath), Present: strings.TrimSpace(state.mediaDump) != ""},
-			{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""},
-		},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	select {
-	case <-ctx.Done():
-		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: BHD missing api_key; configure the BHD api_key in tracker settings before uploading")
-	}
-	if req.Meta.ExternalIDs.TMDBID == 0 {
-		return uploadState{}, errors.New("trackers: BHD missing tmdb id; refresh metadata or set a TMDB id before uploading")
-	}
-	if err := validateBHDContainer(req.Meta); err != nil {
-		return uploadState{}, err
-	}
-
-	var err error
-	var assets trackers.DescriptionAssets
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	description := buildDescription(req.Meta, req.AppConfig, assets)
-	mediaDump, err := resolveMediaDump(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, err
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	tags := resolveTags(req.Meta)
-	customEdition, edition := resolveEdition(req.Meta, tags)
-	source, ok := resolveSource(req.Meta)
-	if !ok {
-		return uploadState{}, fmt.Errorf("trackers: BHD unsupported source %q", req.Meta.Source)
-	}
-	fields := map[string]string{
-		"name":        resolveUploadName(req.Meta),
-		"category_id": resolveCategoryID(req.Meta),
-		"type":        resolveType(req.Meta),
-		"source":      source,
-		"imdb_id":     resolveIMDbID(req.Meta),
-		"tmdb_id":     resolveTMDBID(req.Meta),
-		"description": description,
-		"anon":        resolveAnon(req.TrackerConfig),
-		"sd":          boolFlag(isSD(req.Meta)),
-		"live":        resolveLive(req.TrackerConfig),
-	}
-	if trackers.IsInternalGroup(req.AppConfig, "BHD", req.Meta) {
-		fields["internal"] = "1"
-	}
-	if req.Meta.TVPack {
-		fields["pack"] = "1"
-	}
-	if strings.EqualFold(strings.TrimSpace(req.Meta.SeasonStr), "S00") {
-		fields["special"] = "1"
-	}
-	if region := resolveRegion(req.Meta.Region); region != "" {
-		fields["region"] = region
-	}
-	if customEdition {
-		fields["custom_edition"] = edition
-	} else if edition != "" {
-		fields["edition"] = edition
-	}
-	if len(tags) > 0 {
-		fields["tags"] = strings.Join(tags, ",")
-	}
-
-	return uploadState{
-		torrentPath: torrentPath,
-		mediaDump:   mediaDump,
-		description: description,
-		fields:      fields,
-	}, nil
-}
-
-func sendUpload(ctx context.Context, req trackers.UploadRequest, state uploadState) (uploadResponse, []byte, error) {
-	body, contentType, err := buildMultipartPayload(state.fields, state.mediaDump, state.torrentPath)
-	if err != nil {
-		return uploadResponse{}, nil, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadEndpoint(strings.TrimSpace(req.TrackerConfig.APIKey)), bytes.NewReader(body))
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	responseBody, err := readUploadResponseBody(resp.Body)
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD read response: %w", err)
-	}
-	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
-		return uploadResponse{}, responseBody, commonhttp.UploadHTTPError("BHD", resp.StatusCode, responseBody)
-	}
-	decoded := uploadResponse{}
-	if len(responseBody) > 0 {
-		if err := json.Unmarshal(responseBody, &decoded); err != nil {
-			return uploadResponse{}, responseBody, fmt.Errorf("trackers: BHD decode response: %w", err)
-		}
-	}
-	return decoded, responseBody, nil
-}
-
-func readUploadResponseBody(r io.Reader) ([]byte, error) {
-	responseBody, err := io.ReadAll(io.LimitReader(r, bhdUploadResponseMaxBytes+1))
-	if err != nil {
-		return nil, fmt.Errorf("read upload response body: %w", err)
-	}
-	if int64(len(responseBody)) > bhdUploadResponseMaxBytes {
-		return nil, fmt.Errorf("response body exceeds %d bytes", bhdUploadResponseMaxBytes)
-	}
-	return responseBody, nil
-}
-
-type uploadResponse struct {
-	StatusCode    int    `json:"status_code"`
-	StatusMessage string `json:"status_message"`
-}
-
-func buildMultipartPayload(fields map[string]string, mediaDump string, torrentPath string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: BHD write multipart field %q: %w", key, err)
-		}
-	}
-	part, err := writer.CreateFormFile("mediainfo", "upload")
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHD create mediainfo form file: %w", err)
-	}
-	if _, err := io.WriteString(part, mediaDump); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHD write mediainfo form file: %w", err)
-	}
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHD open torrent file: %w", err)
-	}
-	defer file.Close()
-	part, err = writer.CreatePart(textproto.MIMEHeader{
-		"Content-Disposition": {`form-data; name="file"; filename="torrent.torrent"`},
-		"Content-Type":        {"application/x-bittorrent"},
-	})
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHD create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHD copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: BHD close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveMediaDump(meta api.PreparedMetadata, dbPath string) (string, error) {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		text := readBDInfoNoErr(dbPath, meta)
-		if text == "" {
-			return "", errors.New("trackers: BHD missing BDInfo text; generate or attach BDInfo before uploading")
-		}
-		return text, nil
-	case "DVD":
-		text := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
-		if text == "" {
-			return "", errors.New("trackers: BHD missing DVD MediaInfo text; generate or attach DVD MediaInfo before uploading")
-		}
-		return text, nil
-	default:
-		if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
-			return "", errors.New("trackers: BHD missing mediainfo text; generate or attach MediaInfo before uploading")
-		}
-		payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-		if err != nil {
-			return "", fmt.Errorf("trackers: BHD read mediainfo: %w", err)
-		}
-		return string(payload), nil
-	}
-}
-
-func resolveMediaPath(meta api.PreparedMetadata, dbPath string) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-			return ""
-		}
-		tmpRoot, err := db.Subdir(dbPath, "tmp")
-		if err != nil {
-			return ""
-		}
-		tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-		if err != nil {
-			return ""
-		}
-		return paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta))
-	default:
-		return strings.TrimSpace(meta.MediaInfoTextPath)
-	}
-}
-
-func uploadEndpoint(apiKey string) string {
-	return strings.TrimRight(bhdBaseURL, "/") + "/api/upload/" + strings.TrimSpace(apiKey)
-}
-
-func extractTorrentID(statusMessage string) string {
-	matches := bhdTorrentIDPattern.FindStringSubmatch(strings.TrimSpace(statusMessage))
-	if len(matches) < 2 {
-		return ""
-	}
-	return strings.TrimSpace(matches[1])
-}
-
-func writeFailureArtifact(req trackers.UploadRequest, payload []byte, name string) (string, error) {
-	if strings.TrimSpace(req.AppConfig.MainSettings.DBPath) == "" || strings.TrimSpace(req.Meta.SourcePath) == "" {
-		return "", nil
-	}
-	tmpRoot, err := db.Subdir(req.AppConfig.MainSettings.DBPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, req.Meta, req.Meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	ext := ".txt"
-	if bytes.Contains(bytes.ToLower(payload), []byte("<html")) {
-		ext = ".html"
-	}
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
-		return "", fmt.Errorf("trackers: BHD create failure artifact dir: %w", err)
-	}
-	payload = []byte(redaction.RedactValue(string(payload), nil))
-	file, err := os.CreateTemp(tmpDir, "[BHD]"+name+"-*"+ext)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BHD create failure artifact: %w", err)
-	}
-	path := file.Name()
-	if _, err := file.Write(payload); err != nil {
-		_ = file.Close()
-		_ = os.Remove(path)
-		return "", fmt.Errorf("trackers: BHD write failure artifact: %w", err)
-	}
-	if err := file.Close(); err != nil {
-		_ = os.Remove(path)
-		return "", fmt.Errorf("trackers: BHD close failure artifact: %w", err)
-	}
-	return path, nil
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	name := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ReleaseName), strings.TrimSpace(meta.ReleaseNameNoTag), strings.TrimSpace(meta.Filename), pathutil.Base(meta.SourcePath))
-	if bhdmeta.IsDVDSource(meta.Source) {
-		audio := strings.Join(strings.Fields(strings.TrimSpace(meta.Audio)), " ")
-		if audio != "" && strings.TrimSpace(meta.VideoCodec) != "" {
-			name = strings.Replace(name, audio, strings.TrimSpace(meta.VideoCodec)+" "+audio, 1)
-		}
-	}
-	return strings.ReplaceAll(name, "DD+", "DDP")
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") {
-		return "2"
-	}
-	return "1"
-}
-
-func resolveTMDBID(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.TMDBID == 0 {
-		return ""
-	}
-	return strconv.Itoa(meta.ExternalIDs.TMDBID)
-}
-
-func validateBHDContainer(meta api.PreparedMetadata) error {
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "REMUX", "ENCODE", "WEBDL", "WEBRIP":
-		container := strings.ToLower(strings.TrimSpace(meta.Container))
-		if container != "" && container != "mkv" && container != "mp4" {
-			return fmt.Errorf("trackers: BHD container %q is not allowed for %s: only MKV and MP4 are permitted", meta.Container, meta.Type)
-		}
-	}
-	return nil
-}
-
-func resolveSource(meta api.PreparedMetadata) (string, bool) {
-	return bhdmeta.SourceForMetadata(meta)
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	return bhdmeta.Type(meta)
-}
-
-func resolveEdition(meta api.PreparedMetadata, tags []string) (bool, string) {
-	edition := strings.TrimSpace(meta.Edition)
-	if slices.Contains(tags, "Hybrid") {
-		edition = strings.TrimSpace(strings.ReplaceAll(edition, "Hybrid", ""))
-	}
-	if edition == "" {
-		return false, ""
-	}
-	for _, token := range []string{"collector", "director", "extended", "limited", "special", "theatrical", "uncut", "unrated"} {
-		if strings.Contains(strings.ToLower(edition), token) {
-			switch token {
-			case "director":
-				return false, "Director"
-			default:
-				return false, strings.ToUpper(token[:1]) + token[1:]
-			}
-		}
-	}
-	return true, edition
-}
-
-func resolveTags(meta api.PreparedMetadata) []string {
-	tags := make([]string, 0, 12)
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "WEBRIP":
-		tags = append(tags, "WEBRip")
-	case "WEBDL", "WEB-DL":
-		tags = append(tags, "WEBDL")
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
-		tags = append(tags, "3D")
-	}
-	audio := strings.ToLower(strings.TrimSpace(meta.Audio))
-	if strings.Contains(audio, "dual-audio") {
-		tags = append(tags, "DualAudio")
-	}
-	if strings.Contains(audio, "dubbed") {
-		tags = append(tags, "EnglishDub")
-	}
-	if strings.Contains(strings.ToLower(meta.Edition), "open matte") {
-		tags = append(tags, "OpenMatte")
-	}
-	if meta.Scene {
-		tags = append(tags, "Scene")
-	}
-	if meta.PersonalRelease {
-		tags = append(tags, "Personal")
-	}
-	if strings.Contains(strings.ToLower(meta.Edition), "hybrid") {
-		tags = append(tags, "Hybrid")
-	}
-	if meta.HasCommentary {
-		tags = append(tags, "Commentary")
-	}
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	if strings.Contains(hdr, "DV") {
-		tags = append(tags, "DV")
-	}
-	if strings.Contains(hdr, "HDR") {
-		if strings.Contains(hdr, "HDR10+") {
-			tags = append(tags, "HDR10+")
-		} else {
-			tags = append(tags, "HDR10")
-		}
-	}
-	if strings.Contains(hdr, "HLG") {
-		tags = append(tags, "HLG")
-	}
-	return dedupeStrings(tags)
-}
-
-func resolveIMDbID(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID > 0 {
-		return strconv.Itoa(meta.ExternalIDs.IMDBID)
-	}
-	return "1"
-}
-
-func resolveAnon(cfg config.TrackerConfig) string {
-	if cfg.Anon {
-		return "1"
-	}
-	return "0"
-}
-
-func resolveLive(cfg config.TrackerConfig) string {
-	if cfg.DraftDefault || cfg.Draft {
-		return "0"
-	}
-	return "1"
-}
-
-func resolveRegion(region string) string {
-	allowed := map[string]struct{}{
-		"AUS": {}, "CAN": {}, "CEE": {}, "CHN": {}, "ESP": {}, "EUR": {}, "FRA": {}, "GBR": {},
-		"GER": {}, "HKG": {}, "ITA": {}, "JPN": {}, "KOR": {}, "NOR": {}, "NLD": {}, "RUS": {},
-		"TWN": {}, "USA": {},
-	}
-	upper := strings.ToUpper(strings.TrimSpace(region))
-	if _, ok := allowed[upper]; ok {
-		return upper
-	}
-	return ""
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	return bhdmeta.IsSD(meta)
-}
-
-func boolFlag(value bool) string {
-	if value {
-		return "1"
-	}
-	return "0"
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
-
-func dedupeStrings(values []string) []string {
-	seen := make(map[string]struct{}, len(values))
-	result := make([]string, 0, len(values))
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		result = append(result, trimmed)
-	}
-	return result
-}
diff --git a/internal/trackers/impl/bhdtv/definition.go b/internal/trackers/impl/bhdtv/definition.go
deleted file mode 100644
index 3eaaed53..00000000
--- a/internal/trackers/impl/bhdtv/definition.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhdtv
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "BHDTV"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-
-	description := buildDescription(assets)
-	return trackers.DescriptionResult{
-		Group:       "bhdtv",
-		Description: description,
-	}, nil
-}
diff --git a/internal/trackers/impl/bhdtv/definition_test.go b/internal/trackers/impl/bhdtv/definition_test.go
deleted file mode 100644
index c2021f6e..00000000
--- a/internal/trackers/impl/bhdtv/definition_test.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhdtv
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
-	t.Parallel()
-
-	tempDir := t.TempDir()
-	torrentPath := filepath.Join(tempDir, "input.torrent")
-	mediaPath := filepath.Join(tempDir, "MEDIAINFO_CLEANPATH.txt")
-	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	if err := os.WriteFile(mediaPath, []byte("mediainfo text"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	def := New()
-	entry, err := def.BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "BHDTV",
-		Meta: api.PreparedMetadata{
-			SourcePath:                  filepath.Join(tempDir, "Show.S01E01.mkv"),
-			TorrentPath:                 torrentPath,
-			MediaInfoTextPath:           mediaPath,
-			Type:                        "WEBDL",
-			MediaInfoCategory:           "TV",
-			TVPack:                      false,
-			ReleaseName:                 "Show: S01E01 DD+ 1080p WEB-DL H.265",
-			ReleaseNameNoTag:            "Show: S01E01 DD+ 1080p WEB-DL H.265",
-			ExternalIDs:                 api.ExternalIDs{Category: "TV", TVmazeID: 321},
-			ExternalMetadata:            api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDbURL: "https://www.imdb.com/title/tt1234567/"}},
-			TrackerQuestionnaireAnswers: map[string]map[string]string{},
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("dry run: %v", err)
-	}
-
-	if entry.Tracker != "BHDTV" {
-		t.Fatalf("unexpected tracker %q", entry.Tracker)
-	}
-	if entry.Payload["cat"] != "10" {
-		t.Fatalf("expected tv episode cat 10, got %q", entry.Payload["cat"])
-	}
-	if entry.Payload["subcat"] != "8" {
-		t.Fatalf("expected tv web subcat 8, got %q", entry.Payload["subcat"])
-	}
-	if entry.Payload["resolution"] != "3" {
-		t.Fatalf("expected 1080p resolution 3, got %q", entry.Payload["resolution"])
-	}
-	if entry.Payload["url"] != "https://www.tvmaze.com/shows/321" {
-		t.Fatalf("unexpected url %q", entry.Payload["url"])
-	}
-	if entry.Payload["name"] != "Show.S01E01.DDP.1080p.WEB-DL.H.265" {
-		t.Fatalf("unexpected name %q", entry.Payload["name"])
-	}
-}
-
-func TestUploadParsesViewAndWritesArtifact(t *testing.T) {
-	tempDir := t.TempDir()
-	torrentPath := filepath.Join(tempDir, "input.torrent")
-	mediaPath := filepath.Join(tempDir, "MEDIAINFO_CLEANPATH.txt")
-	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	if err := os.WriteFile(mediaPath, []byte("mediainfo text"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := r.ParseMultipartForm(2 << 20); err != nil {
-			t.Errorf("parse multipart: %v", err)
-			return
-		}
-		if got := r.FormValue("api_key"); got != "token" {
-			t.Error("unexpected api key")
-			return
-		}
-		if got := r.FormValue("cat"); got != "7" {
-			t.Errorf("unexpected cat %q", got)
-			return
-		}
-		if got := r.FormValue("subcat"); got != "48" {
-			t.Errorf("unexpected subcat %q", got)
-			return
-		}
-		if got := r.FormValue("resolution"); got != "4" {
-			t.Errorf("unexpected resolution %q", got)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"data":{"view":"https://www.bit-hdtv.com/details.php?id=99"}}`))
-	}))
-	defer server.Close()
-
-	originalURL := uploadURL
-	uploadURL = server.URL
-	defer func() { uploadURL = originalURL }()
-
-	summary, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker: "BHDTV",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tempDir, "Movie.2160p.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaPath,
-			Type:              "REMUX",
-			ReleaseName:       "Movie 2160p REMUX x265",
-			ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		},
-		TrackerConfig: config.TrackerConfig{
-			APIKey: "token",
-		},
-		AppConfig: config.Config{
-			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "ua.db")},
-		},
-	})
-	if err != nil {
-		t.Fatalf("upload: %v", err)
-	}
-	if summary.Uploaded != 1 || len(summary.UploadedTorrents) != 1 {
-		t.Fatalf("unexpected summary %#v", summary)
-	}
-	if got := summary.UploadedTorrents[0].TorrentURL; got != "https://www.bit-hdtv.com/details.php?id=99" {
-		t.Fatalf("unexpected torrent url %q", got)
-	}
-	if strings.TrimSpace(summary.UploadedTorrents[0].TorrentPath) != "" {
-		t.Fatal("expected no personalized torrent path without my_announce_url")
-	}
-}
diff --git a/internal/trackers/impl/bhdtv/upload.go b/internal/trackers/impl/bhdtv/upload.go
deleted file mode 100644
index a6132423..00000000
--- a/internal/trackers/impl/bhdtv/upload.go
+++ /dev/null
@@ -1,496 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bhdtv
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	uploadURL  = "https://www.bit-hdtv.com/takeupload.php"
-	sourceFlag = "BIT-HDTV"
-)
-
-type uploadState struct {
-	torrentPath  string
-	releaseName  string
-	screenBlock  string
-	inlineDescr  string
-	mediaDump    string
-	fields       map[string]string
-	artifactPath string
-}
-
-type uploadResponse struct {
-	Status  string `json:"status"`
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-	Data    struct {
-		View string `json:"view"`
-	} `json:"data"`
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	response, responseBody, err := sendUpload(ctx, state)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	viewURL := strings.TrimSpace(response.Data.View)
-	if viewURL == "" {
-		artifactPath, artifactErr := writeFailureArtifact(req, responseBody, "upload_failure")
-		if artifactErr != nil && req.Logger != nil {
-			req.Logger.Warnf("trackers: BHDTV failure artifact write failed: %v", artifactErr)
-		}
-		message := metautil.FirstNonEmptyTrimmed(commonhttp.ExtractHTTPErrorDetail(responseBody), commonhttp.RedactErrorDetail(response.Message), commonhttp.RedactErrorDetail(response.Status), "upload response did not include a view URL")
-		if artifactPath != "" {
-			message += " (" + artifactPath + ")"
-		}
-		return api.UploadSummary{}, fmt.Errorf("trackers: BHDTV %s", message)
-	}
-
-	if strings.TrimSpace(req.TrackerConfig.MyAnnounceURL) != "" {
-		artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "BHDTV")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, req.TrackerConfig.MyAnnounceURL, viewURL, sourceFlag); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		state.artifactPath = artifactPath
-	}
-
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "BHDTV",
-			TorrentURL:  viewURL,
-			DownloadURL: viewURL,
-			TorrentPath: state.artifactPath,
-		}},
-	}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "BHDTV",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "bhdtv",
-		Description:      state.screenBlock,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Files: []api.TrackerDryRunFile{
-			{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""},
-		},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	select {
-	case <-ctx.Done():
-		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: BHDTV missing api_key")
-	}
-
-	descriptionAssets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		descriptionAssets = trackers.DescriptionAssets{}
-	}
-
-	screenBlock := buildDescription(descriptionAssets)
-
-	mediaDump, err := resolveMediaDump(req.Meta)
-	if err != nil {
-		return uploadState{}, err
-	}
-
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	fields := map[string]string{
-		"api_key":    strings.TrimSpace(req.TrackerConfig.APIKey),
-		"name":       resolveUploadName(req.Meta),
-		"mediainfo":  mediaDump,
-		"cat":        resolveCategoryID(req.Meta),
-		"subcat":     resolveSubcategoryID(req.Meta),
-		"resolution": resolveResolutionID(req.Meta),
-		"sdescr":     " ",
-		"descr":      resolveInlineDescription(req.Meta),
-		"screen":     screenBlock,
-		"url":        resolveReferenceURL(req.Meta),
-		"format":     "json",
-	}
-
-	return uploadState{
-		torrentPath: torrentPath,
-		releaseName: fields["name"],
-		screenBlock: screenBlock,
-		inlineDescr: fields["descr"],
-		mediaDump:   mediaDump,
-		fields:      fields,
-	}, nil
-}
-
-func sendUpload(ctx context.Context, state uploadState) (uploadResponse, []byte, error) {
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
-	if err != nil {
-		return uploadResponse{}, nil, err
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV read response: %w", err)
-	}
-
-	var decoded uploadResponse
-	if len(responseBody) > 0 {
-		if err := json.Unmarshal(responseBody, &decoded); err != nil {
-			return uploadResponse{}, responseBody, fmt.Errorf("trackers: BHDTV decode response: %w", err)
-		}
-	}
-	return decoded, responseBody, nil
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: BHDTV write multipart field %q: %w", key, err)
-		}
-	}
-
-	file, err := os.Open(strings.TrimSpace(torrentPath))
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHDTV open torrent file: %w", err)
-	}
-	defer file.Close()
-
-	part, err := writer.CreateFormFile("file", filepath.Base(torrentPath))
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHDTV create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: BHDTV copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: BHDTV close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveMediaDump(meta api.PreparedMetadata) (string, error) {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		text := readBDInfoNoErr("", meta)
-		if text == "" {
-			return "", errors.New("trackers: BHDTV missing BD summary")
-		}
-		return text, nil
-	}
-
-	text := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
-	if strings.EqualFold(text, strings.TrimSpace(meta.MediaInfoTextPath)) {
-		payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-		if err != nil {
-			return "", fmt.Errorf("trackers: BHDTV read mediainfo: %w", err)
-		}
-		return string(payload), nil
-	}
-	if strings.TrimSpace(text) != "" {
-		return text, nil
-	}
-	return "", errors.New("trackers: BHDTV missing mediainfo text")
-}
-
-func resolveInlineDescription(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return "Disc so Check Mediainfo dump "
-	}
-	text, err := resolveMediaDump(meta)
-	if err != nil {
-		return ""
-	}
-	return text
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	name := metautil.FirstNonEmptyTrimmed(
-		strings.TrimSpace(meta.ReleaseName),
-		strings.TrimSpace(meta.ReleaseNameNoTag),
-		strings.TrimSpace(meta.Filename),
-		pathutil.Base(meta.SourcePath),
-	)
-	replacer := strings.NewReplacer(" ", ".", ":.", ".", ":", ".", "DD+", "DDP")
-	normalized := replacer.Replace(name)
-	for strings.Contains(normalized, "..") {
-		normalized = strings.ReplaceAll(normalized, "..", ".")
-	}
-	return strings.Trim(normalized, ".")
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) string {
-	if categoryOf(meta) == "TV" {
-		if meta.TVPack {
-			return "12"
-		}
-		return "10"
-	}
-	return "7"
-}
-
-func resolveSubcategoryID(meta api.PreparedMetadata) string {
-	if categoryOf(meta) != "TV" {
-		return resolveMovieSubcategory(meta)
-	}
-	if meta.TVPack {
-		return resolveTVPackSubcategory(meta.Type)
-	}
-	return resolveTVEpisodeSubcategory(meta.Type)
-}
-
-func resolveMovieSubcategory(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "DISC":
-		if meta.Is3D != "" {
-			return "46"
-		}
-		return "2"
-	case "REMUX":
-		switch {
-		case strings.Contains(strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.ReleaseNameNoTag)), "265"):
-			return "48"
-		case meta.Is3D != "":
-			return "45"
-		default:
-			return "2"
-		}
-	case "HDTV":
-		return "6"
-	case "ENCODE":
-		switch {
-		case strings.Contains(strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.ReleaseNameNoTag)), "265"):
-			return "43"
-		case meta.Is3D != "":
-			return "44"
-		default:
-			return "1"
-		}
-	case "WEBDL", "WEBRIP":
-		return "5"
-	default:
-		return "0"
-	}
-}
-
-func resolveTVEpisodeSubcategory(typeValue string) string {
-	switch strings.ToUpper(strings.TrimSpace(typeValue)) {
-	case "HDTV":
-		return "7"
-	case "WEBDL", "WEBRIP":
-		return "8"
-	case "ENCODE":
-		return "10"
-	case "REMUX":
-		return "11"
-	case "DISC":
-		return "12"
-	default:
-		return "0"
-	}
-}
-
-func resolveTVPackSubcategory(typeValue string) string {
-	switch strings.ToUpper(strings.TrimSpace(typeValue)) {
-	case "HDTV":
-		return "13"
-	case "WEBDL":
-		return "14"
-	case "WEBRIP":
-		return "8"
-	case "ENCODE":
-		return "16"
-	case "REMUX":
-		return "17"
-	case "DISC":
-		return "18"
-	default:
-		return "0"
-	}
-}
-
-func resolveResolutionID(meta api.PreparedMetadata) string {
-	switch normalizeResolution(metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.ReleaseName, meta.Filename)) {
-	case "2160P":
-		return "4"
-	case "1080P":
-		return "3"
-	case "1080I":
-		return "2"
-	case "720P":
-		return "1"
-	default:
-		return "10"
-	}
-}
-
-func resolveReferenceURL(meta api.PreparedMetadata) string {
-	if categoryOf(meta) == "TV" && meta.ExternalIDs.TVmazeID != 0 {
-		return fmt.Sprintf("https://www.tvmaze.com/shows/%d", meta.ExternalIDs.TVmazeID)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	return ""
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	switch {
-	case strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV"):
-		return "TV"
-	case strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV"):
-		return "TV"
-	default:
-		return "MOVIE"
-	}
-}
-
-func buildDescription(assets trackers.DescriptionAssets) string {
-	base := strings.ReplaceAll(strings.TrimSpace(assets.Description), "[img=250]", "[img=250x250]")
-	parts := make([]string, 0, 1+len(assets.Screenshots))
-	if base != "" {
-		parts = append(parts, base)
-	}
-	for _, image := range assets.Screenshots {
-		webURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.WebURL, image.RawURL))
-		imgURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL, image.WebURL))
-		if webURL == "" || imgURL == "" {
-			continue
-		}
-		parts = append(parts, fmt.Sprintf("[url=%s][img]%s[/img][/url]", webURL, imgURL))
-	}
-	return strings.Join(parts, " ")
-}
-
-func writeFailureArtifact(req trackers.UploadRequest, payload []byte, name string) (string, error) {
-	if strings.TrimSpace(req.AppConfig.MainSettings.DBPath) == "" || strings.TrimSpace(req.Meta.SourcePath) == "" {
-		return "", nil
-	}
-	tmpRoot, err := db.Subdir(req.AppConfig.MainSettings.DBPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, req.Meta, req.Meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	ext := ".txt"
-	if bytes.Contains(bytes.ToLower(payload), []byte("<html")) {
-		ext = ".html"
-	}
-	path := filepath.Join(tmpDir, "[BHDTV]"+name+ext)
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return "", fmt.Errorf("trackers: BHDTV create failure artifact dir: %w", err)
-	}
-	payload = []byte(redaction.RedactValue(string(payload), nil))
-	if err := os.WriteFile(path, payload, 0o600); err != nil {
-		return "", fmt.Errorf("trackers: BHDTV write failure artifact: %w", err)
-	}
-	return path, nil
-}
-
-func readBDInfoNoErr(_ string, meta api.PreparedMetadata) string {
-	if summary, ok := meta.BDInfo["summary"].(string); ok {
-		return strings.TrimSpace(summary)
-	}
-	if infoPath := guessBDInfoPath(meta); infoPath != "" {
-		payload, err := os.ReadFile(infoPath)
-		if err == nil {
-			return strings.TrimSpace(string(payload))
-		}
-	}
-	return ""
-}
-
-func guessBDInfoPath(meta api.PreparedMetadata) string {
-	if len(meta.SelectedBDMVPlaylists) == 0 {
-		return ""
-	}
-	base := strings.TrimSpace(meta.MediaInfoTextPath)
-	if base != "" {
-		return filepath.Join(filepath.Dir(base), paths.BDMVSummaryFilename(paths.PrimaryBDMVPlaylist(meta)))
-	}
-	return ""
-}
-
-func normalizeResolution(value string) string {
-	upper := strings.ToUpper(strings.TrimSpace(value))
-	for _, candidate := range []string{"2160P", "1080P", "1080I", "720P"} {
-		if strings.Contains(upper, candidate) {
-			return candidate
-		}
-	}
-	return upper
-}
-
-func cloneFields(fields map[string]string) map[string]string {
-	cloned := make(map[string]string, len(fields))
-	maps.Copy(cloned, fields)
-	return cloned
-}
diff --git a/internal/trackers/impl/bjs/definition.go b/internal/trackers/impl/bjs/definition.go
deleted file mode 100644
index f5f0171a..00000000
--- a/internal/trackers/impl/bjs/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bjs
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "BJS"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "bjs", Description: description}, nil
-}
diff --git a/internal/trackers/impl/bjs/upload.go b/internal/trackers/impl/bjs/upload.go
deleted file mode 100644
index 57b836ef..00000000
--- a/internal/trackers/impl/bjs/upload.go
+++ /dev/null
@@ -1,1158 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bjs
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"math"
-	"net/http"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-
-	"golang.org/x/text/runes"
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
-)
-
-const (
-	baseURL    = "https://bj-share.info"
-	uploadURL  = baseURL + "/upload.php"
-	torrentURL = baseURL + "/torrents.php?torrentid="
-	sourceFlag = "BJ"
-)
-
-var (
-	authPattern                   = regexp.MustCompile(`name="auth"\s+value="([^"]+)"`)
-	idPattern                     = regexp.MustCompile(`action=download&id=(\d+)|torrentid=(\d+)`)
-	mediaInfoDurationLinePattern  = regexp.MustCompile(`(?im)^\s*duration(?:\s*/\s*string[123]?)?\s*:\s*(.+)$`)
-	mediaInfoDurationTokenPattern = regexp.MustCompile(`(?i)(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|hours?|hrs?|hr|h|minutes?|mins?|min|mn|m|seconds?|secs?|sec|s)\b`)
-	isoDurationPattern            = regexp.MustCompile(`(?i)^pt(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?(?:(\d+(?:\.\d+)?)s)?$`)
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	blockedReason string
-	questionnaire *api.TrackerQuestionnaire
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BJS %s", state.blockedReason)
-	}
-	files := []commonhttp.FileField{{
-		FieldName: "file_input",
-		FileName:  filepath.Base(state.torrentPath),
-		Path:      state.torrentPath,
-	}}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BJS request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	httpReq.Header.Set("Referer", uploadURL)
-	commonhttp.ApplyCookies(httpReq, cookies)
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BJS upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BJS read upload response: %w", err)
-	}
-	match := idPattern.FindStringSubmatch(finalURL + "\n" + string(responseBody))
-	id := metautil.FirstNonEmptyTrimmed(matchValue(match, 1), matchValue(match, 2))
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 && id != "" {
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "BJS")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "BJS",
-				TorrentID:   id,
-				TorrentURL:  tURL,
-				DownloadURL: tURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "BJS", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("BJS", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "BJS",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "bjs",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file_input", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	auth := "dry-run-auth"
-	if !dryRun {
-		auth, err = fetchAuth(ctx, cookies)
-		if err != nil {
-			return uploadState{}, nil, err
-		}
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	fields := buildFields(req.Meta, description, auth, questionnaireAnswers(req.Meta))
-	state := uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
-		fields:        fields,
-		questionnaire: buildQuestionnaire(req.Meta, fields),
-	}
-	if reason := validateFields(fields); reason != "" {
-		state.blockedReason = reason
-	}
-	return state, cookies, nil
-}
-
-func buildFields(meta api.PreparedMetadata, description string, auth string, answers map[string]string) map[string]string {
-	width, height := resolveResolution(meta)
-	runtimeMinutes := resolveRuntime(meta)
-	ptBR := api.ExtractLocalizedPTBR(meta)
-
-	var tmdbOriginalTitle, tmdbTitle string
-	if meta.ExternalMetadata.TMDB != nil {
-		tmdbOriginalTitle = meta.ExternalMetadata.TMDB.OriginalTitle
-		tmdbTitle = meta.ExternalMetadata.TMDB.Title
-	}
-
-	fields := map[string]string{
-		"audio":            resolveAudio(meta),
-		"auth":             auth,
-		"codecaudio":       resolveAudioCodec(meta),
-		"codecvideo":       resolveVideoCodec(meta),
-		"duracaoHR":        strconv.Itoa(runtimeMinutes / 60),
-		"duracaoMIN":       strconv.Itoa(runtimeMinutes % 60),
-		"duracaotipo":      "selectbox",
-		"fichatecnica":     description,
-		"formato":          resolveContainer(meta),
-		"idioma":           resolveLanguage(meta),
-		"imdblink":         resolveIDLink(meta),
-		"qualidade":        resolveQuality(meta),
-		"release":          strings.TrimSpace(meta.ServiceLongName),
-		"remaster_title":   resolveRemasterTitle(meta),
-		"resolucaoh":       height,
-		"resolucaow":       width,
-		"sinopse":          metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["overview"]), resolveOverview(meta, ptBR)),
-		"submit":           "true",
-		"tags":             metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta, ptBR)),
-		"tipolegenda":      resolveSubtitle(meta),
-		"title":            metautil.FirstNonEmptyTrimmed(tmdbOriginalTitle, meta.Release.Title),
-		"titulobrasileiro": metautil.FirstNonEmptyTrimmed(ptBR.Title, tmdbTitle, meta.Release.Title),
-		"traileryoutube":   resolveYouTube(meta, ptBR),
-		"type":             resolveType(meta),
-		"year":             resolveYearLabel(meta),
-	}
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	if category == "MOVIE" {
-		fields["adulto"] = resolveAdult(meta)
-		fields["diretor"] = resolveDirectors(meta)
-		fields["datalancamento"] = resolveReleaseDate(meta)
-	}
-	if category == "TV" {
-		fields["diretor"] = resolveCreators(meta)
-		if meta.TVPack {
-			fields["tipo"] = "season"
-		} else {
-			fields["tipo"] = "episode"
-		}
-		fields["season"] = strconv.Itoa(meta.SeasonInt)
-		fields["episode"] = strconv.Itoa(meta.EpisodeInt)
-		fields["network"] = resolveNetworks(meta)
-
-		numSeasons := 0
-		if meta.ExternalMetadata.IMDB != nil {
-			numSeasons = len(meta.ExternalMetadata.IMDB.SeasonsSummary)
-		}
-		fields["numtemporadas"] = strconv.Itoa(numSeasons)
-
-		var originCountry []string
-		if meta.ExternalMetadata.TMDB != nil {
-			for _, code := range meta.ExternalMetadata.TMDB.OriginCountry {
-				originCountry = append(originCountry, metautil.ISO3166PortugueseName(code, code))
-			}
-		}
-		fields["pais"] = strings.Join(originCountry, ", ")
-
-		fields["diretorserie"] = resolveDirectors(meta)
-		fields["avaliacao"] = resolveIMDbRating(meta)
-		fields["datalancamento"] = resolveReleaseDate(meta)
-	}
-	if !meta.Anime {
-		fields["validimdb"] = "yes"
-		fields["imdbrating"] = resolveIMDbRating(meta)
-		fields["elenco"] = resolveCast(meta)
-	}
-	if meta.Anime && category == "MOVIE" {
-		fields["tipo"] = "movie"
-	}
-	if meta.Anime && category == "TV" {
-		fields["adulto"] = resolveAdult(meta)
-	}
-	if strings.TrimSpace(meta.Repack) != "" {
-		fields["repack"] = "on"
-	}
-	if resolvePoster(meta) != "" {
-		fields["image"] = resolvePoster(meta)
-	}
-	screens := resolveScreens(meta)
-	if len(screens) > 0 {
-		fields["screenshots[]"] = strings.Join(screens, ",")
-	}
-	return fields
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, fields map[string]string) *api.TrackerQuestionnaire {
-	current := questionnaireAnswers(meta)
-	var items []api.TrackerQuestionnaireField
-	if strings.TrimSpace(fields["sinopse"]) == "" {
-		items = append(items, api.TrackerQuestionnaireField{Key: "overview", Label: "Overview", Kind: "textarea", Value: current["overview"], Required: true})
-	}
-	if strings.TrimSpace(fields["tags"]) == "" {
-		items = append(items, api.TrackerQuestionnaireField{Key: "tags", Label: "Tags", Kind: "text", Value: current["tags"], Required: true})
-	}
-	if len(items) == 0 {
-		return nil
-	}
-	return &api.TrackerQuestionnaire{Tracker: "BJS", Fields: items}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["BJS"]
-}
-
-func validateFields(fields map[string]string) string {
-	if strings.TrimSpace(fields["imdblink"]) == "" {
-		return "missing IMDb or TMDb identifier"
-	}
-	if strings.TrimSpace(fields["sinopse"]) == "" {
-		return "missing overview"
-	}
-	if strings.TrimSpace(fields["diretor"]) == "" || strings.EqualFold(strings.TrimSpace(fields["diretor"]), "skipped") {
-		return "missing director/creator credits"
-	}
-	return ""
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	meta := req.Meta
-	var parts []string
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Logo
-	if logo := resolveLogo(meta); logo != "" {
-		parts = append(parts, "[align=center][img]"+logo+"[/img][/align]")
-	}
-
-	// TV Episode details
-	epTitle := meta.EpisodeTitle
-	epOverview := meta.EpisodeOverview
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Localized != nil {
-		if ptBR, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]; ok {
-			if ptBR.EpisodeTitle != "" {
-				epTitle = ptBR.EpisodeTitle
-			}
-			if ptBR.EpisodeOverview != "" {
-				epOverview = ptBR.EpisodeOverview
-			}
-		}
-	}
-	epTitle = strings.TrimSpace(epTitle)
-	epOverview = strings.TrimSpace(epOverview)
-	if epOverview != "" {
-		if epTitle != "" {
-			parts = append(parts, "[align=center]"+epTitle+"[/align]")
-		}
-		parts = append(parts, "[align=center]"+epOverview+"[/align]")
-	}
-
-	// File information
-	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
-	if discType == "DVD" || discType == "HDDVD" {
-		mediainfo := strings.TrimSpace(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath))
-		if mediainfo != "" {
-			parts = append(parts, "[hide=DVD MediaInfo][pre]"+mediainfo+"[/pre][/hide]")
-		}
-	}
-	if discType == "BDMV" {
-		bdinfo, _ := trackers.ReadBDInfo(req.AppConfig.MainSettings.DBPath, meta)
-		parts = append(parts, "[hide=BDInfo][pre]"+bdinfo+"[/pre][/hide]")
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// Signature
-	link, _ := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[align=center][url=%s]Upload realizado via %s[/url][/align]", link, "upbrr"))
-
-	// Join and finalize
-	description := strings.Join(parts, "\n\n")
-	finalized := bbcode.FinalizeTrackerDescription("BJS", description)
-
-	// Debug saving
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "BJS", req.AppConfig.MainSettings.DBPath, finalized, req.Logger)
-	}
-
-	return finalized
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "BJS", "bj-share.info"))
-}
-
-func fetchAuth(ctx context.Context, cookies []*http.Cookie) (string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uploadURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BJS auth token request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, cookies)
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BJS auth token request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	match := authPattern.FindStringSubmatch(string(body))
-	if len(match) < 2 {
-		return "", errors.New("trackers: BJS auth token not found")
-	}
-	return strings.TrimSpace(match[1]), nil
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return "13"
-	}
-	if strings.EqualFold(categoryOf(meta), "TV") {
-		return "1"
-	}
-	return "0"
-}
-
-func resolveContainer(meta api.PreparedMetadata) string {
-	container := strings.ToLower(strings.TrimSpace(meta.Container))
-	switch container {
-	case "mkv", "mp4", "avi", "vob", "m2ts", "ts":
-		return strings.ToUpper(container)
-	default:
-		return "Outro"
-	}
-}
-
-func resolveAudio(meta api.PreparedMetadata) string {
-	for _, lang := range meta.AudioLanguages {
-		lower := strings.ToLower(strings.TrimSpace(lang))
-		if lower == "portuguese" || lower == "português" || lower == "pt" {
-			if len(meta.AudioLanguages) > 1 {
-				return "Dual Áudio"
-			}
-			return "Dublado"
-		}
-	}
-	return "Legendado"
-}
-
-func resolveLanguage(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return "Outro"
-	}
-
-	langCode := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage))
-	if langCode == "" {
-		return "Outro"
-	}
-
-	if langCode == "pt" {
-		for _, country := range meta.ExternalMetadata.TMDB.OriginCountry {
-			if strings.ToUpper(strings.TrimSpace(country)) == "PT" {
-				return "Português (pt)"
-			}
-		}
-		return "Português"
-	}
-
-	return metautil.ISO639PortugueseName(langCode, "Outro")
-}
-
-func resolveSubtitle(meta api.PreparedMetadata) string {
-	for _, lang := range meta.SubtitleLanguages {
-		lower := strings.ToLower(strings.TrimSpace(lang))
-		if lower == "portuguese" || lower == "português" || lower == "pt" {
-			return "Embutida"
-		}
-	}
-	return "Nenhuma"
-}
-
-func resolveResolution(meta api.PreparedMetadata) (string, string) {
-	height := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
-	switch height {
-	case "2160":
-		return "3840", "2160"
-	case "1080":
-		return "1920", "1080"
-	case "720":
-		return "1280", "720"
-	default:
-		return "0", "0"
-	}
-}
-
-func resolveVideoCodec(meta api.PreparedMetadata) string {
-	value := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
-	switch {
-	case strings.Contains(value, "265"), strings.Contains(value, "hevc"):
-		return "H.265"
-	case strings.Contains(value, "264"), strings.Contains(value, "avc"):
-		return "H.264"
-	case strings.Contains(value, "av1"):
-		return "AV1"
-	case strings.Contains(value, "vp9"):
-		return "VP9"
-	case strings.Contains(value, "xvid"):
-		return "XviD"
-	default:
-		return metautil.FirstNonEmptyTrimmed(meta.VideoCodec, "Outro")
-	}
-}
-
-func resolveAudioCodec(meta api.PreparedMetadata) string {
-	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
-	switch {
-	case strings.Contains(audio, "DTS:X"):
-		return "DTS-X"
-	case strings.Contains(audio, "ATMOS"):
-		return "E-AC-3 JOC"
-	case strings.Contains(audio, "TRUEHD"):
-		return "TrueHD"
-	case strings.Contains(audio, "DTS-HD"):
-		return "DTS-HD"
-	case strings.Contains(audio, "FLAC"):
-		return "FLAC"
-	case strings.Contains(audio, "LPCM"), strings.Contains(audio, "PCM"):
-		return "PCM"
-	case strings.Contains(audio, "DTS"):
-		return "DTS"
-	case strings.Contains(audio, "DD+"), strings.Contains(audio, "E-AC-3"):
-		return "E-AC-3"
-	case strings.Contains(audio, "DD"), strings.Contains(audio, "AC3"):
-		return "AC3"
-	case strings.Contains(audio, "AAC"):
-		return "AAC"
-	default:
-		return "Outro"
-	}
-}
-
-func resolveQuality(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "DISC":
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-			if meta.SourceSize > 66<<30 {
-				return "BD100"
-			}
-			if meta.SourceSize > 50<<30 {
-				return "BD66"
-			}
-			if meta.SourceSize > 25<<30 {
-				return "BD50"
-			}
-			return "BD25"
-		}
-		return "DVD9"
-	case "REMUX":
-		return "Remux"
-	case "WEBDL":
-		return "WEB-DL"
-	case "WEBRIP":
-		return "WEBRip"
-	case "HDTV":
-		return "HDTV"
-	default:
-		return "Outro"
-	}
-}
-
-func resolveRuntime(meta api.PreparedMetadata) int {
-	for _, candidate := range []string{
-		commonhttp.ReadOptionalFile(meta.MediaInfoTextPath),
-		strings.TrimSpace(meta.DVDVOBMediaInfoText),
-	} {
-		if minutes := parseMediaInfoDurationMinutes(candidate); minutes > 0 {
-			return minutes
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		if minutes := parseBDInfoLengthMinutes(meta.BDInfo["length"]); minutes > 0 {
-			return minutes
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.RuntimeMinutes > 0 {
-		return meta.ExternalMetadata.IMDB.RuntimeMinutes
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return meta.ExternalMetadata.TMDB.Runtime
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		return meta.ExternalMetadata.TVmaze.Runtime
-	}
-	return 0
-}
-
-func parseBDInfoLengthMinutes(value any) int {
-	text := strings.TrimSpace(fmt.Sprint(value))
-	if text == "" || text == "<nil>" {
-		return 0
-	}
-	parts := strings.Split(text, ":")
-	if len(parts) != 3 {
-		return 0
-	}
-	hours, err := strconv.ParseFloat(strings.TrimSpace(parts[0]), 64)
-	if err != nil || hours < 0 {
-		return 0
-	}
-	minutes, err := strconv.ParseFloat(strings.TrimSpace(parts[1]), 64)
-	if err != nil || minutes < 0 {
-		return 0
-	}
-	seconds, err := strconv.ParseFloat(strings.TrimSpace(parts[2]), 64)
-	if err != nil || seconds < 0 {
-		return 0
-	}
-	totalSeconds := hours*3600 + minutes*60 + seconds
-	if totalSeconds <= 0 {
-		return 0
-	}
-	return int(math.Round(totalSeconds / 60))
-}
-
-// parseMediaInfoDurationMinutes returns rounded minutes from the first parseable
-// MediaInfo Duration or Duration/String[1-3] line, including ISO-8601-like values.
-func parseMediaInfoDurationMinutes(text string) int {
-	for _, matches := range mediaInfoDurationLinePattern.FindAllStringSubmatch(text, -1) {
-		if len(matches) != 2 {
-			continue
-		}
-		if minutes := parseMediaInfoDurationValueMinutes(matches[1]); minutes > 0 {
-			return minutes
-		}
-	}
-	return 0
-}
-
-func parseMediaInfoDurationValueMinutes(value string) int {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 0
-	}
-	if matches := isoDurationPattern.FindStringSubmatch(trimmed); len(matches) == 4 {
-		return mediaInfoDurationSecondsToMinutes(durationComponentSeconds(matches[1], matches[2], matches[3], ""))
-	}
-	if strings.Contains(trimmed, ":") {
-		return mediaInfoDurationSecondsToMinutes(parseMediaInfoDurationColonSeconds(trimmed))
-	}
-	if seconds := parseMediaInfoDurationTokenSeconds(trimmed); seconds > 0 {
-		return mediaInfoDurationSecondsToMinutes(seconds)
-	}
-	if fields := strings.Fields(trimmed); len(fields) > 0 {
-		if ms, err := strconv.ParseFloat(strings.ReplaceAll(fields[0], ",", ""), 64); err == nil && ms > 10000 {
-			return int(math.Round(ms / 60000.0))
-		}
-	}
-	return 0
-}
-
-func parseMediaInfoDurationTokenSeconds(value string) float64 {
-	var total float64
-	for _, matches := range mediaInfoDurationTokenPattern.FindAllStringSubmatch(value, -1) {
-		if len(matches) != 3 {
-			continue
-		}
-		amount, err := strconv.ParseFloat(strings.ReplaceAll(matches[1], ",", ""), 64)
-		if err != nil || amount <= 0 {
-			continue
-		}
-		switch strings.ToLower(matches[2]) {
-		case "h", "hr", "hrs", "hour", "hours":
-			total += amount * 3600
-		case "m", "mn", "min", "mins", "minute", "minutes":
-			total += amount * 60
-		case "s", "sec", "secs", "second", "seconds":
-			total += amount
-		case "ms", "msec", "msecs", "millisecond", "milliseconds":
-			total += amount / 1000
-		}
-	}
-	return total
-}
-
-func parseMediaInfoDurationColonSeconds(value string) float64 {
-	parts := strings.Split(strings.TrimSpace(value), ":")
-	if len(parts) < 2 {
-		return 0
-	}
-	var total float64
-	multiplier := 1.0
-	for i := len(parts) - 1; i >= 0; i-- {
-		part := strings.TrimSpace(parts[i])
-		if part == "" {
-			continue
-		}
-		amount, err := strconv.ParseFloat(strings.ReplaceAll(part, ",", ""), 64)
-		if err != nil || amount < 0 {
-			return 0
-		}
-		total += amount * multiplier
-		multiplier *= 60
-	}
-	return total
-}
-
-func durationComponentSeconds(hours string, minutes string, seconds string, milliseconds string) float64 {
-	totalSeconds := parseDurationComponent(hours) * 3600
-	totalSeconds += parseDurationComponent(minutes) * 60
-	totalSeconds += parseDurationComponent(seconds)
-	totalSeconds += parseDurationComponent(milliseconds) / 1000
-	return totalSeconds
-}
-
-func mediaInfoDurationSecondsToMinutes(seconds float64) int {
-	if seconds <= 0 {
-		return 0
-	}
-	return int(math.Round(seconds / 60.0))
-}
-
-func parseDurationComponent(value string) float64 {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 0
-	}
-	parsed, err := strconv.ParseFloat(trimmed, 64)
-	if err != nil || parsed < 0 {
-		return 0
-	}
-	return parsed
-}
-
-func resolveIDLink(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	if meta.ExternalIDs.TMDBID > 0 {
-		if strings.EqualFold(categoryOf(meta), "TV") {
-			return fmt.Sprintf("tv/%d", meta.ExternalIDs.TMDBID)
-		}
-		return fmt.Sprintf("movie/%d", meta.ExternalIDs.TMDBID)
-	}
-	return ""
-}
-
-// resolveOverview prefers scoped TV synopsis for episode/season-pack uploads,
-// then localized title-level overview, then TMDB or IMDB fallback text.
-func resolveOverview(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
-		return strings.TrimSpace(ptBR.EpisodeOverview)
-	}
-	if ptBR.Overview != "" {
-		return strings.TrimSpace(ptBR.Overview)
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	}
-	return ""
-}
-
-// shouldUseScopedTVOverview reports whether BJS should prefer season or
-// episode localized overview over title-level synopsis text.
-func shouldUseScopedTVOverview(meta api.PreparedMetadata) bool {
-	if meta.SeasonInt <= 0 {
-		return false
-	}
-	if !isTVUpload(meta) {
-		return false
-	}
-	if meta.TVPack {
-		return true
-	}
-	return meta.EpisodeInt > 0
-}
-
-// isTVUpload reports whether BJS should treat the upload as TV from category or episode fields.
-func isTVUpload(meta api.PreparedMetadata) bool {
-	category := strings.TrimSpace(categoryOf(meta))
-	if strings.EqualFold(category, "TV") {
-		return true
-	}
-	if category == "" {
-		return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0
-	}
-	return false
-}
-
-// resolveTags returns BJS tag text from localized genres or translated fallback
-// genres, preserving unknown fallback genre names after tag normalization.
-func resolveTags(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	// 1. Use localized if available
-	if ptBR.Genres != "" {
-		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
-		out := make([]string, 0, len(genres))
-		for _, g := range genres {
-			g = strings.TrimSpace(g)
-			t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-			g, _, _ = transform.String(t, g)
-			g = strings.ReplaceAll(g, " ", ".")
-			g = strings.ToLower(g)
-			if g != "" {
-				out = append(out, g)
-			}
-		}
-		return strings.Join(out, ", ")
-	}
-
-	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
-	var genreText string
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	default:
-		genreText = strings.TrimSpace(meta.Release.Genre)
-	}
-
-	if genreText == "" {
-		return ""
-	}
-
-	genres := strings.Split(genreText, ",")
-	out := make([]string, 0, len(genres))
-	for _, g := range genres {
-		g = strings.TrimSpace(g)
-		if g == "" {
-			continue
-		}
-		translated := metautil.TranslateGenreToPortugueseStrict(g)
-		if translated == "" {
-			translated = g
-		}
-		t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-		tag, _, _ := transform.String(t, translated)
-		tag = strings.ReplaceAll(strings.TrimSpace(tag), " ", ".")
-		if tag != "" {
-			out = append(out, strings.ToLower(tag))
-		}
-	}
-	return strings.Join(out, ", ")
-}
-
-func resolveYouTube(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	if ptBR.TrailerURL != "" {
-		return strings.TrimSpace(ptBR.TrailerURL)
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	return ""
-}
-
-func resolveNetworks(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Networks) > 0 {
-		names := make([]string, 0, len(meta.ExternalMetadata.TMDB.Networks))
-		for _, n := range meta.ExternalMetadata.TMDB.Networks {
-			if strings.TrimSpace(n.Name) != "" {
-				names = append(names, strings.TrimSpace(n.Name))
-			}
-		}
-		return strings.Join(names, ", ")
-	}
-	return ""
-}
-
-func resolveReleaseDate(meta api.PreparedMetadata) string {
-	rawDate := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		rawDate = metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.ReleaseDate, meta.ExternalMetadata.TMDB.FirstAirDate)
-	}
-	if rawDate == "" {
-		return ""
-	}
-	t, err := time.Parse("2006-01-02", rawDate)
-	if err == nil {
-		return t.Format("02 Jan 2006")
-	}
-	return ""
-}
-
-func resolveYearLabel(meta api.PreparedMetadata) string {
-	year := resolveYear(meta)
-	if strings.EqualFold(categoryOf(meta), "TV") {
-		if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.EndYear > 0 {
-			return fmt.Sprintf("%d-%d", year, meta.ExternalMetadata.IMDB.EndYear)
-		}
-		return fmt.Sprintf("%d-", year)
-	}
-	return strconv.Itoa(year)
-}
-
-func resolveRemasterTitle(meta api.PreparedMetadata) string {
-	var tags []string
-
-	edition := strings.TrimSpace(meta.Edition)
-	editionLower := strings.ToLower(edition)
-	editionEntries := []struct{ keyword, label string }{
-		{"director's cut", "Director's Cut"},
-		{"extended", "Extended Edition"},
-		{"imax", "IMAX"},
-		{"open matte", "Open Matte"},
-		{"noir", "Noir Edition"},
-		{"theatrical", "Theatrical Cut"},
-		{"uncut", "Uncut"},
-		{"unrated", "Unrated"},
-		{"uncensored", "Uncensored"},
-	}
-	for _, entry := range editionEntries {
-		if strings.Contains(editionLower, entry.keyword) {
-			tags = append(tags, entry.label)
-			break
-		}
-	}
-
-	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
-	if strings.Contains(audio, "ATMOS") {
-		tags = append(tags, "Dolby Atmos")
-	}
-
-	if meta.BitDepth == "10" {
-		tags = append(tags, "10-bit")
-	}
-
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	if strings.Contains(hdr, "DV") || strings.Contains(hdr, "DOLBY VISION") {
-		tags = append(tags, "Dolby Vision")
-	}
-	if strings.Contains(hdr, "HDR10+") {
-		tags = append(tags, "HDR10+")
-	}
-	if strings.Contains(hdr, "HDR") && !strings.Contains(hdr, "HDR10+") {
-		tags = append(tags, "HDR10")
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-		tags = append(tags, "Remux")
-	}
-
-	if meta.HasCommentary {
-		tags = append(tags, "Com comentários")
-	}
-
-	priority := []string{
-		"Dolby Atmos",
-		"Remux",
-		"Director's Cut",
-		"Extended Edition",
-		"IMAX",
-		"Open Matte",
-		"Noir Edition",
-		"Theatrical Cut",
-		"Uncut",
-		"Unrated",
-		"Uncensored",
-		"10-bit",
-		"Dolby Vision",
-		"HDR10+",
-		"HDR10",
-		"Com extras",
-		"Com comentários",
-	}
-
-	tagSet := make(map[string]bool)
-	for _, t := range tags {
-		tagSet[t] = true
-	}
-
-	var ordered []string
-	for _, p := range priority {
-		if tagSet[p] {
-			ordered = append(ordered, p)
-		}
-	}
-
-	return strings.Join(ordered, " / ")
-}
-
-func resolveYear(meta api.PreparedMetadata) int {
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		return meta.ExternalMetadata.TMDB.Year
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		return meta.ExternalMetadata.IMDB.Year
-	}
-	return meta.Release.Year
-}
-
-// resolveAdult returns the BJS adult flag from localized, TMDB, IMDB, and
-// release genre text after accent-insensitive keyword matching.
-func resolveAdult(meta api.PreparedMetadata) string {
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	parts := []string{resolveTags(meta, ptBR), ptBR.Genres}
-	if meta.ExternalMetadata.TMDB != nil {
-		parts = append(parts, meta.ExternalMetadata.TMDB.Keywords, meta.ExternalMetadata.TMDB.Genres)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		parts = append(parts, meta.ExternalMetadata.IMDB.Genres)
-	}
-	parts = append(parts, meta.Release.Genre)
-	genres := normalizeAdultText(strings.Join(parts, " "))
-	if meta.Anime && strings.Contains(genres, "hentai") {
-		return "1"
-	}
-	for _, keyword := range []string{"xxx", "erotic", "erotico", "porn", "adult", "adulto", "orgy", "orgia"} {
-		if strings.Contains(genres, keyword) {
-			return "1"
-		}
-	}
-	return "2"
-}
-
-// normalizeAdultText folds case and diacritics before adult keyword matching.
-func normalizeAdultText(value string) string {
-	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-	normalized, _, _ := transform.String(t, strings.ToLower(value))
-	return normalized
-}
-
-func resolveDirectors(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Directors) > 0 {
-		return firstTrimmed(meta.ExternalMetadata.TMDB.Directors)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		names := make([]string, 0, len(meta.ExternalMetadata.IMDB.Directors))
-		for _, p := range meta.ExternalMetadata.IMDB.Directors {
-			if strings.TrimSpace(p.Name) != "" {
-				names = append(names, strings.TrimSpace(p.Name))
-			}
-		}
-		if len(names) > 0 {
-			return names[0]
-		}
-	}
-	return ""
-}
-
-func resolveCreators(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Creators) > 0 {
-		return firstTrimmed(meta.ExternalMetadata.TMDB.Creators)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		names := make([]string, 0, len(meta.ExternalMetadata.IMDB.Creators))
-		for _, p := range meta.ExternalMetadata.IMDB.Creators {
-			if strings.TrimSpace(p.Name) != "" {
-				names = append(names, strings.TrimSpace(p.Name))
-			}
-		}
-		if len(names) > 0 {
-			return names[0]
-		}
-	}
-	return ""
-}
-
-func resolveCast(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Cast) > 0 {
-		return strings.Join(firstNTrimmed(meta.ExternalMetadata.TMDB.Cast, 5), ", ")
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		names := make([]string, 0, len(meta.ExternalMetadata.IMDB.Stars))
-		for _, p := range meta.ExternalMetadata.IMDB.Stars {
-			if strings.TrimSpace(p.Name) != "" {
-				names = append(names, strings.TrimSpace(p.Name))
-			}
-		}
-		return strings.Join(firstNTrimmed(names, 5), ", ")
-	}
-	return ""
-}
-
-func resolveIMDbRating(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Rating > 0 {
-		return strconv.FormatFloat(meta.ExternalMetadata.IMDB.Rating, 'f', 1, 64)
-	}
-	return ""
-}
-
-func resolveLogo(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo) != "" {
-		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo), "/")
-	}
-	return ""
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		if meta.ExternalMetadata.TMDB.Localized != nil {
-			if localized, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
-				return strings.TrimSpace(localized.Poster)
-			}
-		}
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	}
-	return ""
-}
-
-func resolveScreens(_ api.PreparedMetadata) []string {
-	return nil
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
-
-func firstTrimmed(values []string) string {
-	for _, value := range values {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func firstNTrimmed(values []string, limit int) []string {
-	if limit <= 0 {
-		return nil
-	}
-	out := make([]string, 0, limit)
-	seen := make(map[string]struct{}, limit)
-	for _, value := range values {
-		trimmed := strings.TrimSpace(value)
-		if trimmed == "" {
-			continue
-		}
-		if _, ok := seen[trimmed]; ok {
-			continue
-		}
-		seen[trimmed] = struct{}{}
-		out = append(out, trimmed)
-		if len(out) == limit {
-			break
-		}
-	}
-	return out
-}
-
-func matchValue(values []string, idx int) string {
-	if idx >= 0 && idx < len(values) {
-		return values[idx]
-	}
-	return ""
-}
diff --git a/internal/trackers/impl/bjs/upload_test.go b/internal/trackers/impl/bjs/upload_test.go
deleted file mode 100644
index 132ab33d..00000000
--- a/internal/trackers/impl/bjs/upload_test.go
+++ /dev/null
@@ -1,559 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bjs
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveRuntimePrefersMediaInfoDuration(t *testing.T) {
-	root := t.TempDir()
-	miPath := filepath.Join(root, "MEDIAINFO.txt")
-	if err := os.WriteFile(miPath, []byte("General\nDuration                                 : 1 h 31 min\n"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		MediaInfoTextPath: miPath,
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{RuntimeMinutes: 120},
-		},
-	}
-
-	if got := resolveRuntime(meta); got != 91 {
-		t.Fatalf("expected MediaInfo runtime 91 minutes, got %d", got)
-	}
-}
-
-func TestResolveRuntimeFallsBackToExternalMetadata(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{RuntimeMinutes: 95},
-		},
-	}
-
-	if got := resolveRuntime(meta); got != 95 {
-		t.Fatalf("expected IMDb runtime fallback, got %d", got)
-	}
-}
-
-func TestResolveRuntimePrefersBDInfoLengthForBDMV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType: "BDMV",
-		BDInfo: map[string]any{
-			"length": "01:40:00.000",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{RuntimeMinutes: 120},
-		},
-	}
-
-	if got := resolveRuntime(meta); got != 100 {
-		t.Fatalf("expected BDInfo runtime 100 minutes, got %d", got)
-	}
-}
-
-func TestParseMediaInfoDurationMinutes(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		content  string
-		expected int
-	}{
-		{
-			name:     "valid hours and minutes",
-			content:  "duration : 2 h 15 m",
-			expected: 135,
-		},
-		{
-			name:     "duration string label",
-			content:  "Duration/String : 2 h 5 min 2 s",
-			expected: 125,
-		},
-		{
-			name:     "duration string1 label",
-			content:  "\tDuRaTiOn/String1   : 2 h 5 min 2 s",
-			expected: 125,
-		},
-		{
-			name:     "duration spaced slash label",
-			content:  "Duration / String2 : 2 hrs 5 mins 2 secs",
-			expected: 125,
-		},
-		{
-			name:     "duration string3 colon label",
-			content:  "Duration/String3 : 02:05:02.000",
-			expected: 125,
-		},
-		{
-			name:     "iso duration value",
-			content:  "Duration/String : PT2H5M2S",
-			expected: 125,
-		},
-		{
-			name:     "valid milliseconds",
-			content:  "duration : 120000",
-			expected: 2,
-		},
-		{
-			name:     "empty fields",
-			content:  "duration :    ",
-			expected: 0,
-		},
-		{
-			name:     "invalid string1 skips to later duration",
-			content:  "Duration/String1 : not a duration\nDuration/String2 : 01:30:00.000",
-			expected: 90,
-		},
-		{
-			name:     "duration string4 remains ignored",
-			content:  "Duration/String4 : 01:30:00.000",
-			expected: 0,
-		},
-		{
-			name:     "adjacent duration fields remain ignored",
-			content:  "Source_Duration : 01:30:00.000\nDuration_Start : 01:30:00.000",
-			expected: 0,
-		},
-		{
-			name:     "no duration keyword",
-			content:  "something else",
-			expected: 0,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := parseMediaInfoDurationMinutes(tc.content)
-			if got != tc.expected {
-				t.Fatalf("expected %d, got %d", tc.expected, got)
-			}
-		})
-	}
-}
-
-func TestBuildFieldsLimitsDirectorCreatorAndSetsRepack(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Repack: "REPACK",
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Creators:      []string{"Creator One", "Creator Two"},
-				Directors:     []string{"Director One", "Director Two"},
-				OriginCountry: []string{"BR", "US"},
-				Title:         "Title",
-			},
-			IMDB: &api.IMDBMetadata{Year: 2026},
-		},
-	}
-
-	fields := buildFields(meta, "description", "auth", nil)
-	if got := fields["diretor"]; got != "Creator One" {
-		t.Fatalf("expected first creator only, got %q", got)
-	}
-	if got := fields["diretorserie"]; got != "Director One" {
-		t.Fatalf("expected first director only, got %q", got)
-	}
-	if got := fields["repack"]; got != "on" {
-		t.Fatalf("expected repack flag, got %q", got)
-	}
-	if got := fields["pais"]; got != "Brasil, Estados Unidos da América" {
-		t.Fatalf("expected translated countries, got %q", got)
-	}
-}
-
-func TestBuildFieldsWithNilMetadata(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Title: "Test TV Title",
-		},
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: nil,
-			IMDB: nil,
-		},
-	}
-
-	// Make sure buildFields does not panic and populates fallback title from release
-	fields := buildFields(meta, "description", "auth", nil)
-	if got := fields["title"]; got != "Test TV Title" {
-		t.Fatalf("expected title to fall back to release title, got %q", got)
-	}
-	if got := fields["pais"]; got != "" {
-		t.Fatalf("expected empty country for nil TMDB, got %q", got)
-	}
-	if got := fields["numtemporadas"]; got != "0" {
-		t.Fatalf("expected 0 seasons for nil IMDB, got %q", got)
-	}
-	if got := fields["idioma"]; got != "Outro" {
-		t.Fatalf("expected idioma to fall back to 'Outro' for nil TMDB, got %q", got)
-	}
-	if got := fields["network"]; got != "" {
-		t.Fatalf("expected network to be empty for nil TMDB, got %q", got)
-	}
-	if got := fields["avaliacao"]; got != "" {
-		t.Fatalf("expected avaliacao to be empty for nil IMDB, got %q", got)
-	}
-	if got := fields["elenco"]; got != "" {
-		t.Fatalf("expected elenco to be empty for nil TMDB/IMDB, got %q", got)
-	}
-	if got := fields["traileryoutube"]; got != "" {
-		t.Fatalf("expected traileryoutube to be empty for nil TMDB, got %q", got)
-	}
-}
-
-func TestBuildFieldsWithTMDBNilAndIMDBPresent(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Title: "Test TV Title",
-		},
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: nil,
-			IMDB: &api.IMDBMetadata{
-				Rating: 8.5,
-				Stars:  []api.IMDBPerson{{Name: "Star One"}, {Name: "Star Two"}},
-			},
-		},
-	}
-
-	fields := buildFields(meta, "description", "auth", nil)
-	if got := fields["avaliacao"]; got != "8.5" {
-		t.Fatalf("expected avaliacao from IMDB, got %q", got)
-	}
-	if got := fields["elenco"]; got != "Star One, Star Two" {
-		t.Fatalf("expected elenco from IMDB stars, got %q", got)
-	}
-	if got := fields["idioma"]; got != "Outro" {
-		t.Fatalf("expected idioma to fall back to 'Outro' for nil TMDB, got %q", got)
-	}
-}
-
-func TestBuildFieldsWithTMDBPresentAndIMDBNil(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Title: "Test TV Title",
-		},
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				OriginalTitle:    "Original Title",
-				Title:            "Title",
-				OriginalLanguage: "en",
-				Networks:         []api.TMDBNetwork{{Name: "HBO"}},
-				Cast:             []string{"Cast One", "Cast Two"},
-				YouTube:          "https://youtube.com/watch?v=123",
-			},
-			IMDB: nil,
-		},
-	}
-
-	fields := buildFields(meta, "description", "auth", nil)
-	if got := fields["title"]; got != "Original Title" {
-		t.Fatalf("expected title from TMDB OriginalTitle, got %q", got)
-	}
-	if got := fields["idioma"]; got != "Inglês" {
-		t.Fatalf("expected idioma from TMDB original language, got %q", got)
-	}
-	if got := fields["network"]; got != "HBO" {
-		t.Fatalf("expected network from TMDB, got %q", got)
-	}
-	if got := fields["elenco"]; got != "Cast One, Cast Two" {
-		t.Fatalf("expected elenco from TMDB cast, got %q", got)
-	}
-	if got := fields["traileryoutube"]; got != "https://youtube.com/watch?v=123" {
-		t.Fatalf("expected traileryoutube URL from TMDB, got %q", got)
-	}
-	if got := fields["avaliacao"]; got != "" {
-		t.Fatalf("expected empty avaliacao for nil IMDB, got %q", got)
-	}
-}
-
-func TestBuildFieldsWithTMDBLocalizedAndIMDBNil(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Title: "Test TV Title",
-		},
-		ExternalIDs: api.ExternalIDs{
-			Category: "TV",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				OriginalTitle: "Original Title",
-				Title:         "Title",
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {
-						Title:      "Título Localizado",
-						TrailerURL: "https://youtube.com/watch?v=localized",
-					},
-				},
-			},
-			IMDB: nil,
-		},
-	}
-
-	fields := buildFields(meta, "description", "auth", nil)
-	if got := fields["titulobrasileiro"]; got != "Título Localizado" {
-		t.Fatalf("expected titulobrasileiro from TMDB localized title, got %q", got)
-	}
-	if got := fields["traileryoutube"]; got != "https://youtube.com/watch?v=localized" {
-		t.Fatalf("expected traileryoutube URL from TMDB localized trailer, got %q", got)
-	}
-}
-
-func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
-	t.Parallel()
-
-	ptBR := api.TMDBLocalizedData{
-		Overview:        "Series Overview",
-		EpisodeOverview: "Episode Overview",
-	}
-
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-		want string
-	}{
-		{
-			name: "episode upload uses episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "lowercase episode upload uses episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "tv"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "season pack uses season overview from episode field",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				TVPack:      true,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "series upload uses title overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-			},
-			want: "Series Overview",
-		},
-		{
-			name: "movie ignores episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Series Overview",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := resolveOverview(tc.meta, ptBR); got != tc.want {
-				t.Fatalf("expected overview %q, got %q", tc.want, got)
-			}
-		})
-	}
-}
-
-func TestBuildDescriptionOmitsBlankEpisodeTitle(t *testing.T) {
-	t.Parallel()
-
-	req := trackers.UploadRequest{Meta: api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {
-						EpisodeOverview: "Overview Localizado",
-					},
-				},
-			},
-		},
-	}}
-
-	got := buildDescription(req, trackers.DescriptionAssets{})
-	if strings.Contains(got, "[align=center][/align]") {
-		t.Fatalf("expected blank episode title row to be omitted, got %q", got)
-	}
-	if !strings.Contains(got, "[align=center]Overview Localizado[/align]") {
-		t.Fatalf("expected localized episode overview row, got %q", got)
-	}
-}
-
-func TestBuildDescriptionKeepsEpisodeTitleWhenPresent(t *testing.T) {
-	t.Parallel()
-
-	req := trackers.UploadRequest{Meta: api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Localized: map[string]api.TMDBLocalizedData{
-					"pt-BR": {
-						EpisodeTitle:    "Titulo Localizado",
-						EpisodeOverview: "Overview Localizado",
-					},
-				},
-			},
-		},
-	}}
-
-	got := buildDescription(req, trackers.DescriptionAssets{})
-	if !strings.Contains(got, "[align=center]Titulo Localizado[/align]") {
-		t.Fatalf("expected localized episode title row, got %q", got)
-	}
-	if !strings.Contains(got, "[align=center]Overview Localizado[/align]") {
-		t.Fatalf("expected localized episode overview row, got %q", got)
-	}
-}
-
-func TestResolveTagsPreservesUnknownFallbackGenres(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Genre: "Sci-Fi, MyCustomGenre",
-		},
-	}
-
-	got := resolveTags(meta, api.TMDBLocalizedData{})
-	expected := "ficcao.cientifica, mycustomgenre"
-	if got != expected {
-		t.Fatalf("expected tags %q, got %q", expected, got)
-	}
-}
-
-func TestResolveTagsFallbackPriority(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{Genre: "ReleaseGenre"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{Genres: "Drama"},
-			IMDB: &api.IMDBMetadata{Genres: "Comedy"},
-		},
-	}
-
-	if got := resolveTags(meta, api.TMDBLocalizedData{Genres: "Ação"}); got != "acao" {
-		t.Fatalf("expected localized tags to win, got %q", got)
-	}
-	if got := resolveTags(meta, api.TMDBLocalizedData{}); got != "drama" {
-		t.Fatalf("expected TMDB tags to beat IMDb and release, got %q", got)
-	}
-
-	meta.ExternalMetadata.TMDB = nil
-	if got := resolveTags(meta, api.TMDBLocalizedData{}); got != "comedia" {
-		t.Fatalf("expected IMDb tags to beat release, got %q", got)
-	}
-}
-
-func TestBuildFieldsTagsAnswerOverridesComputedTags(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{Genre: "Drama"},
-	}
-
-	fields := buildFields(meta, "description", "auth", map[string]string{"tags": "manual.tag"})
-	if got := fields["tags"]; got != "manual.tag" {
-		t.Fatalf("expected manual tags answer, got %q", got)
-	}
-}
-
-func TestResolveAdultLocalizedAndCanonicalGenres(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-		want string
-	}{
-		{
-			name: "localized Portuguese adult genre",
-			meta: api.PreparedMetadata{
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{
-						"pt-BR": {Genres: "Adulto"},
-					}},
-				},
-			},
-			want: "1",
-		},
-		{
-			name: "IMDb-only adult genre",
-			meta: api.PreparedMetadata{
-				ExternalMetadata: api.ExternalMetadata{
-					IMDB: &api.IMDBMetadata{Genres: "Adult"},
-				},
-			},
-			want: "1",
-		},
-		{
-			name: "anime hentai detection remains adult",
-			meta: api.PreparedMetadata{
-				Anime:   true,
-				Release: api.ReleaseInfo{Genre: "Hentai"},
-			},
-			want: "1",
-		},
-		{
-			name: "nonadult Portuguese genre stays nonadult",
-			meta: api.PreparedMetadata{
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{
-						"pt-BR": {Genres: "Drama"},
-					}},
-				},
-			},
-			want: "2",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := resolveAdult(tc.meta); got != tc.want {
-				t.Fatalf("expected adulto=%q, got %q", tc.want, got)
-			}
-		})
-	}
-}
diff --git a/internal/trackers/impl/bjs/wrap_errors.go b/internal/trackers/impl/bjs/wrap_errors.go
deleted file mode 100644
index e731c379..00000000
--- a/internal/trackers/impl/bjs/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bjs
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/bt/definition.go b/internal/trackers/impl/bt/definition.go
deleted file mode 100644
index 7945b6df..00000000
--- a/internal/trackers/impl/bt/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bt
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "BT"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "bt", Description: description}, nil
-}
diff --git a/internal/trackers/impl/bt/upload.go b/internal/trackers/impl/bt/upload.go
deleted file mode 100644
index c76fd10d..00000000
--- a/internal/trackers/impl/bt/upload.go
+++ /dev/null
@@ -1,1371 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bt
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-
-	"golang.org/x/text/runes"
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
-)
-
-const (
-	baseURL    = "https://brasiltracker.org"
-	uploadURL  = baseURL + "/upload.php"
-	torrentURL = baseURL + "/torrents.php?id="
-	sourceFlag = "BT"
-)
-
-var authPattern = regexp.MustCompile(`name="auth"\s+value="([^"]+)"`)
-var groupPattern = regexp.MustCompile(`groupid=(\d+)|torrents\.php\?id=(\d+)`)
-var mediaInfoDurationLinePattern = regexp.MustCompile(`(?im)^\s*duration(?:\s*/\s*string[123]?)?\s*:\s*(.+)$`)
-var mediaInfoDurationTokenPattern = regexp.MustCompile(`(?i)(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|hours?|hrs?|h|minutes?|mins?|min|m|seconds?|secs?|sec|s)\b`)
-var isoDurationPattern = regexp.MustCompile(`(?i)^pt(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?(?:(\d+(?:\.\d+)?)s)?$`)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string][]string
-	blockedReason string
-	questionnaire *api.TrackerQuestionnaire
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BT %s", state.blockedReason)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayloadMulti(state.fields, []commonhttp.FileField{{
-		FieldName: "file_input",
-		FileName:  filepath.Base(state.torrentPath),
-		Path:      state.torrentPath,
-	}})
-
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BT request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BT upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BT read upload response: %w", err)
-	}
-	match := groupPattern.FindStringSubmatch(finalURL + "\n" + string(responseBody))
-	id := metautil.FirstNonEmptyTrimmed(matchValue(match, 1), matchValue(match, 2))
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 && id != "" {
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "BT")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "BT",
-				TorrentID:   id,
-				TorrentURL:  tURL,
-				DownloadURL: tURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "BT", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("BT", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "BT",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "bt",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          flattenFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file_input", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	auth := "dry-run-auth"
-	if !dryRun {
-		auth, err = fetchAuth(ctx, cookies)
-		if err != nil {
-			return uploadState{}, nil, err
-		}
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	fields := buildFields(req, description, auth, req.TrackerConfig, assets)
-	state := uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
-		fields:        fields,
-		questionnaire: buildQuestionnaire(req.Meta, fields),
-	}
-	switch {
-	case len(fields["image"]) == 0 || strings.TrimSpace(fields["image"][0]) == "":
-		state.blockedReason = "missing poster URL"
-	case len(fields["sinopse"]) == 0 || strings.TrimSpace(fields["sinopse"][0]) == "":
-		state.blockedReason = "missing overview"
-	case len(fields["tags"]) == 0 || strings.TrimSpace(fields["tags"][0]) == "":
-		state.blockedReason = "missing tags"
-	}
-
-	return state, cookies, nil
-}
-
-func buildFields(req trackers.UploadRequest, description string, auth string, trackerCfg config.TrackerConfig, assets trackers.DescriptionAssets) map[string][]string {
-	meta := req.Meta
-	answers := questionnaireAnswers(meta)
-	hasPT, subtitleIDs := resolveSubtitle(meta)
-	width, height := resolveResolution(meta)
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	fields := map[string][]string{
-		"audio_c":     {resolveAudioCodec(meta)},
-		"audio":       {resolveAudio(meta)},
-		"auth":        {auth},
-		"bitrate":     {resolveBitrate(meta)},
-		"desc":        {""},
-		"diretor":     {resolveDirectors(meta)},
-		"duracao":     {fmt.Sprintf("%d min", resolveRuntime(meta))},
-		"especificas": {description},
-		"format":      {resolveContainer(meta)},
-		"idioma_ori":  {resolveLanguage(meta)},
-		"image":       {resolvePoster(meta)},
-		"legenda":     {hasPT},
-		"mediainfo":   {trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta)},
-		"resolucao_1": {width},
-		"resolucao_2": {height},
-		"sinopse":     {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["overview"]), resolveOverview(meta, ptBR))},
-		"submit":      {"true"},
-		"tags":        {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta, ptBR))},
-		"title":       {resolveTitle(meta)},
-		"type":        {resolveType(meta)},
-		"video_c":     {resolveVideoCodec(meta)},
-		"year":        {strconv.Itoa(resolveYear(meta))},
-		"youtube":     {resolveYouTube(meta, ptBR)},
-	}
-
-	fields["subtitles[]"] = append(fields["subtitles[]"], subtitleIDs...)
-
-	screens := resolveScreens(assets)
-	fields["screen[]"] = append(fields["screen[]"], screens...)
-
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	if !meta.Anime && (category == "MOVIE" || category == "TV") {
-		fields["3d"] = []string{yesNo(meta.Is3D != "")}
-		fields["adulto"] = []string{"0"}
-		fields["imdb_input"] = []string{resolveIMDbText(meta)}
-		fields["nota_imdb"] = []string{resolveIMDbRating(meta)}
-		fields["title_br"] = []string{resolveLocalizedTitle(meta, ptBR)}
-	}
-	if meta.Scene {
-		fields["scene"] = []string{"on"}
-	}
-	if category == "TV" || meta.Anime {
-		fields["episodio"] = []string{meta.EpisodeStr}
-		fields["ntorrent"] = []string{meta.SeasonStr + meta.EpisodeStr}
-		if meta.TVPack {
-			fields["temporada"] = []string{meta.SeasonStr}
-			fields["tipo"] = []string{"completa"}
-		} else {
-			fields["temporada_e"] = []string{meta.SeasonStr}
-			fields["tipo"] = []string{"ep_individual"}
-		}
-	}
-	if category == "MOVIE" {
-		fields["versao"] = []string{resolveEdition(meta)}
-	}
-	if meta.Anime {
-		fields["fundo_torrent"] = []string{resolveBackdrop(meta)}
-		fields["rating"] = []string{resolveIMDbRating(meta)}
-		fields["releasedate"] = []string{strconv.Itoa(resolveYear(meta))}
-		fields["horas"] = []string{""}
-		fields["minutos"] = []string{""}
-		fields["vote"] = []string{""}
-	}
-	if trackerCfg.Anon {
-		fields["anonymous"] = []string{"1"}
-	}
-	if trackers.IsInternalGroup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BT": trackerCfg}}}, "BT", meta) {
-		fields["internal"] = []string{"1"}
-	}
-	return fields
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	meta := req.Meta
-	var parts []string
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Logo
-	if logo := resolveLogo(meta); logo != "" {
-		parts = append(parts, "[center][img]"+logo+"[/img][/center]")
-	}
-
-	// TV Episode details
-	epTitle := meta.EpisodeTitle
-	epOverview := meta.EpisodeOverview
-	ptBR := api.ExtractLocalizedPTBR(meta)
-	if ptBR.EpisodeTitle != "" {
-		epTitle = ptBR.EpisodeTitle
-	}
-	if ptBR.EpisodeOverview != "" {
-		epOverview = ptBR.EpisodeOverview
-	}
-	if episode := strings.TrimSpace(epOverview); episode != "" {
-		if title := strings.TrimSpace(epTitle); title != "" {
-			parts = append(parts, "[center]"+title+"[/center]")
-		}
-		parts = append(parts, "[center]"+episode+"[/center]")
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// Signature
-	link, _ := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[center][url=%s]Upload realizado via %s[/url][/center]", link, "upbrr"))
-
-	// Join and finalize
-	description := strings.Join(parts, "\n\n")
-	finalized := bbcode.FinalizeTrackerDescription("BT", description)
-
-	// Debug saving
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "BT", req.AppConfig.MainSettings.DBPath, finalized, req.Logger)
-	}
-
-	return finalized
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "BT", "brasiltracker.org"))
-}
-
-func fetchAuth(ctx context.Context, cookies []*http.Cookie) (string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uploadURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BT auth token request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(req, cookies)
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BT auth token request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	match := authPattern.FindStringSubmatch(string(body))
-	if len(match) < 2 {
-		return "", errors.New("trackers: BT auth token not found")
-	}
-	return strings.TrimSpace(match[1]), nil
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return "5"
-	}
-	if strings.EqualFold(categoryOf(meta), "TV") {
-		return "1"
-	}
-	return "0"
-}
-
-func resolveContainer(meta api.PreparedMetadata) string {
-	container := strings.ToLower(strings.TrimSpace(meta.Container))
-	switch container {
-	case "avi", "m2ts", "m4v", "mkv", "mp4", "ts", "vob", "wmv":
-		return strings.ToUpper(container)
-	default:
-		return "Outro"
-	}
-}
-
-func resolveAudio(meta api.PreparedMetadata) string {
-	pt := false
-	for _, lang := range meta.AudioLanguages {
-		lower := strings.ToLower(strings.TrimSpace(lang))
-		if lower == "portuguese" || lower == "português" || lower == "pt" {
-			pt = true
-			break
-		}
-	}
-	orig := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		orig = strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage))
-	}
-	if pt {
-		if orig == "pt" {
-			return "Nacional"
-		}
-		if len(meta.AudioLanguages) > 1 {
-			return "Dual Audio"
-		}
-		return "Dublado"
-	}
-	return "Legendado"
-}
-
-var targetSiteIDs = map[string]string{
-	"arabic":            "22",
-	"bulgarian":         "29",
-	"chinese":           "14",
-	"croatian":          "23",
-	"czech":             "30",
-	"danish":            "10",
-	"dutch":             "9",
-	"english - forçada": "50",
-	"english":           "3",
-	"estonian":          "38",
-	"finnish":           "15",
-	"french":            "5",
-	"german":            "6",
-	"greek":             "26",
-	"hebrew":            "40",
-	"hindi":             "41",
-	"hungarian":         "24",
-	"icelandic":         "28",
-	"indonesian":        "47",
-	"italian":           "16",
-	"japanese":          "8",
-	"korean":            "19",
-	"latvian":           "37",
-	"lithuanian":        "39",
-	"norwegian":         "12",
-	"persian":           "52",
-	"polish":            "17",
-	"português":         "49",
-	"romanian":          "13",
-	"russian":           "7",
-	"serbian":           "31",
-	"slovak":            "42",
-	"slovenian":         "43",
-	"spanish":           "4",
-	"swedish":           "11",
-	"thai":              "20",
-	"turkish":           "18",
-	"ukrainian":         "34",
-	"vietnamese":        "25",
-}
-
-var sourceAliasMap = map[string]string{
-	"arabic":                "arabic",
-	"ara":                   "arabic",
-	"ar":                    "arabic",
-	"brazilian portuguese":  "português",
-	"brazilian":             "português",
-	"portuguese-br":         "português",
-	"pt-br":                 "português",
-	"portuguese":            "português",
-	"por":                   "português",
-	"pt":                    "português",
-	"pt-pt":                 "português",
-	"português brasileiro":  "português",
-	"português":             "português",
-	"bulgarian":             "bulgarian",
-	"bul":                   "bulgarian",
-	"bg":                    "bulgarian",
-	"chinese":               "chinese",
-	"chi":                   "chinese",
-	"zh":                    "chinese",
-	"chinese (simplified)":  "chinese",
-	"chinese (traditional)": "chinese",
-	"cmn-hant":              "chinese",
-	"cmn-hans":              "chinese",
-	"yue-hant":              "chinese",
-	"yue-hans":              "chinese",
-	"croatian":              "croatian",
-	"hrv":                   "croatian",
-	"hr":                    "croatian",
-	"scr":                   "croatian",
-	"czech":                 "czech",
-	"cze":                   "czech",
-	"cz":                    "czech",
-	"cs":                    "czech",
-	"danish":                "danish",
-	"dan":                   "danish",
-	"da":                    "danish",
-	"dutch":                 "dutch",
-	"dut":                   "dutch",
-	"nl":                    "dutch",
-	"english - forced":      "english - forçada",
-	"english (forced)":      "english - forçada",
-	"en (forced)":           "english - forçada",
-	"en-us (forced)":        "english - forçada",
-	"english":               "english",
-	"eng":                   "english",
-	"en":                    "english",
-	"en-us":                 "english",
-	"en-gb":                 "english",
-	"english (cc)":          "english",
-	"english - sdh":         "english",
-	"estonian":              "estonian",
-	"est":                   "estonian",
-	"et":                    "estonian",
-	"finnish":               "finnish",
-	"fin":                   "finnish",
-	"fi":                    "finnish",
-	"french":                "french",
-	"fre":                   "french",
-	"fr":                    "french",
-	"fr-fr":                 "french",
-	"fr-ca":                 "french",
-	"german":                "german",
-	"ger":                   "german",
-	"de":                    "german",
-	"greek":                 "greek",
-	"gre":                   "greek",
-	"el":                    "greek",
-	"hebrew":                "hebrew",
-	"heb":                   "hebrew",
-	"he":                    "hebrew",
-	"hindi":                 "hindi",
-	"hin":                   "hindi",
-	"hi":                    "hindi",
-	"hungarian":             "hungarian",
-	"hun":                   "hungarian",
-	"hu":                    "hungarian",
-	"icelandic":             "icelandic",
-	"ice":                   "icelandic",
-	"is":                    "icelandic",
-	"indonesian":            "indonesian",
-	"ind":                   "indonesian",
-	"id":                    "indonesian",
-	"italian":               "italian",
-	"ita":                   "italian",
-	"it":                    "italian",
-	"japanese":              "japanese",
-	"jpn":                   "japanese",
-	"ja":                    "japanese",
-	"korean":                "korean",
-	"kor":                   "korean",
-	"ko":                    "korean",
-	"latvian":               "latvian",
-	"lav":                   "latvian",
-	"lv":                    "latvian",
-	"lithuanian":            "lithuanian",
-	"lit":                   "lithuanian",
-	"lt":                    "lithuanian",
-	"norwegian":             "norwegian",
-	"nor":                   "norwegian",
-	"no":                    "norwegian",
-	"persian":               "persian",
-	"fa":                    "persian",
-	"far":                   "persian",
-	"polish":                "polish",
-	"pol":                   "polish",
-	"pl":                    "polish",
-	"romanian":              "romanian",
-	"rum":                   "romanian",
-	"ro":                    "romanian",
-	"russian":               "russian",
-	"rus":                   "russian",
-	"ru":                    "russian",
-	"serbian":               "serbian",
-	"srp":                   "serbian",
-	"sr":                    "serbian",
-	"scc":                   "serbian",
-	"slovak":                "slovak",
-	"slo":                   "slovak",
-	"sk":                    "slovak",
-	"slovenian":             "slovenian",
-	"slv":                   "slovenian",
-	"sl":                    "slovenian",
-	"spanish":               "spanish",
-	"spa":                   "spanish",
-	"es":                    "spanish",
-	"es-es":                 "spanish",
-	"es-419":                "spanish",
-	"swedish":               "swedish",
-	"swe":                   "swedish",
-	"sv":                    "swedish",
-	"thai":                  "thai",
-	"tha":                   "thai",
-	"th":                    "thai",
-	"turkish":               "turkish",
-	"tur":                   "turkish",
-	"tr":                    "turkish",
-	"ukrainian":             "ukrainian",
-	"ukr":                   "ukrainian",
-	"uk":                    "ukrainian",
-	"vietnamese":            "vietnamese",
-	"vie":                   "vietnamese",
-	"vi":                    "vietnamese",
-}
-
-func resolveSubtitle(meta api.PreparedMetadata) (string, []string) {
-	hasPT := "Nao"
-	ids := make([]string, 0)
-	seen := make(map[string]struct{})
-
-	for _, lang := range meta.SubtitleLanguages {
-		cleanLang := strings.ToLower(strings.TrimSpace(lang))
-
-		targetKey, ok := sourceAliasMap[cleanLang]
-		if !ok {
-			targetKey = cleanLang
-		}
-
-		if id, exists := targetSiteIDs[targetKey]; exists {
-			if _, alreadySeen := seen[id]; !alreadySeen {
-				seen[id] = struct{}{}
-				ids = append(ids, id)
-
-				if id == "49" {
-					hasPT = "Sim"
-				}
-			}
-		}
-	}
-
-	if len(ids) == 0 {
-		return "Nao", []string{"44"}
-	}
-
-	return hasPT, ids
-}
-
-func resolveResolution(meta api.PreparedMetadata) (string, string) {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		heightStr := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
-		heightNum, err := strconv.Atoi(heightStr)
-		if err == nil && heightNum > 0 {
-			widthNum := int(math.Round((16.0 / 9.0) * float64(heightNum)))
-			return strconv.Itoa(widthNum), strconv.Itoa(heightNum)
-		}
-	}
-
-	if meta.MediaInfoJSONPath != "" {
-		if payload, err := os.ReadFile(meta.MediaInfoJSONPath); err == nil {
-			type mediaInfoDoc struct {
-				Media struct {
-					Track []map[string]any `json:"track"`
-				} `json:"media"`
-			}
-			var doc mediaInfoDoc
-			if err := json.Unmarshal(payload, &doc); err == nil {
-				for _, track := range doc.Media.Track {
-					trackType, _ := track["@type"].(string)
-					if strings.ToLower(trackType) == "video" {
-						widthVal := track["Width"]
-						heightVal := track["Height"]
-
-						widthStr := parseDimensionStr(widthVal)
-						heightStr := parseDimensionStr(heightVal)
-
-						if widthStr != "" && heightStr != "" {
-							return widthStr, heightStr
-						}
-					}
-				}
-			}
-		}
-	}
-
-	height := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
-	switch height {
-	case "2160":
-		return "3840", "2160"
-	case "1080":
-		return "1920", "1080"
-	case "720":
-		return "1280", "720"
-	case "576":
-		return "1024", "576"
-	case "480":
-		return "854", "480"
-	default:
-		return "", ""
-	}
-}
-
-func parseDimensionStr(val any) string {
-	return metautil.ParseDimensionStr(val)
-}
-
-func resolveVideoCodec(meta api.PreparedMetadata) string {
-	videoEncode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
-	codecFinal := strings.TrimSpace(meta.VideoCodec)
-	isHDR := meta.HDR != ""
-
-	encodeMap := []struct{ Key, Value string }{
-		{"x265", "x265"},
-		{"h.265", "H.265"},
-		{"x264", "x264"},
-		{"h.264", "H.264"},
-		{"vp9", "VP9"},
-		{"xvid", "XviD"},
-	}
-
-	for _, item := range encodeMap {
-		if strings.Contains(videoEncode, item.Key) {
-			if (item.Value == "x265" || item.Value == "H.265") && isHDR {
-				return item.Value + " HDR"
-			}
-			return item.Value
-		}
-	}
-
-	codecLower := strings.ToLower(codecFinal)
-	codecMap := []struct{ Key, Value string }{
-		{"hevc", "x265"},
-		{"265", "x265"},
-		{"avc", "x264"},
-		{"264", "x264"},
-		{"mpeg-2", "MPEG-2"},
-		{"vc-1", "VC-1"},
-	}
-
-	for _, item := range codecMap {
-		if strings.Contains(codecLower, item.Key) {
-			if item.Value == "x265" && isHDR {
-				return "x265 HDR"
-			}
-			return item.Value
-		}
-	}
-
-	if codecFinal != "" {
-		return codecFinal
-	}
-	return "Outro"
-}
-
-func resolveAudioCodec(meta api.PreparedMetadata) string {
-	priorityOrder := []string{
-		"DTS-X", "E-AC-3 JOC", "TrueHD", "DTS-HD", "PCM", "FLAC", "DTS-ES",
-		"DTS", "E-AC-3", "AC3", "AAC", "Opus", "Vorbis", "MP3", "MP2",
-	}
-
-	codecMap := map[string][]string{
-		"DTS-X":      {"DTS:X"},
-		"E-AC-3 JOC": {"DD+ 5.1 Atmos", "DD+ 7.1 Atmos", "ATMOS"},
-		"TrueHD":     {"TRUEHD"},
-		"DTS-HD":     {"DTS-HD"},
-		"PCM":        {"LPCM", "PCM"},
-		"FLAC":       {"FLAC"},
-		"DTS-ES":     {"DTS-ES"},
-		"DTS":        {"DTS"},
-		"E-AC-3":     {"DD+", "E-AC-3"},
-		"AC3":        {"DD", "AC3"},
-		"AAC":        {"AAC"},
-		"Opus":       {"OPUS"},
-		"Vorbis":     {"VORBIS"},
-		"MP2":        {"MP2"},
-		"MP3":        {"MP3"},
-	}
-
-	audioDescription := strings.ToUpper(strings.TrimSpace(meta.Audio))
-	if audioDescription == "" {
-		return "Outro"
-	}
-
-	for _, codecName := range priorityOrder {
-		searchTerms := codecMap[codecName]
-		for _, term := range searchTerms {
-			if strings.Contains(audioDescription, term) {
-				return codecName
-			}
-		}
-	}
-
-	return "Outro"
-}
-
-func resolveBitrate(meta api.PreparedMetadata) string {
-	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
-	if strings.ToUpper(strings.TrimSpace(meta.Type)) == "DISC" || discType == "BDMV" || discType == "DVD" {
-		if discType == "BDMV" {
-			size := meta.SourceSize
-			switch {
-			case size > 66000000000:
-				return "BD100"
-			case size > 50000000000:
-				return "BD66"
-			case size > 25000000000:
-				return "BD50"
-			default:
-				return "BD25"
-			}
-		}
-		if discType == "DVD" {
-			dvdSize := strings.ToUpper(strings.TrimSpace(meta.Release.Size))
-			if dvdSize == "DVD9" || dvdSize == "DVD5" {
-				return dvdSize
-			}
-			return "DVD9"
-		}
-	}
-
-	sourceType := strings.ToLower(strings.TrimSpace(meta.Type))
-	keywordMap := map[string]string{
-		"remux":  "Remux",
-		"webdl":  "WEB-DL",
-		"webrip": "WEBRip",
-		"web":    "WEB",
-		"encode": "Blu-ray",
-		"bdrip":  "BDRip",
-		"brrip":  "BRRip",
-		"hdtv":   "HDTV",
-		"sdtv":   "SDTV",
-		"dvdrip": "DVDRip",
-		"hd-dvd": "HD-DVD",
-		"tvrip":  "TVRip",
-	}
-
-	if val, ok := keywordMap[sourceType]; ok {
-		return val
-	}
-
-	source := strings.ToLower(strings.TrimSpace(meta.Release.Source))
-	if val, ok := keywordMap[source]; ok {
-		return val
-	}
-
-	return "Outro"
-}
-
-func resolveEdition(meta api.PreparedMetadata) string {
-	edition := strings.ToLower(strings.TrimSpace(meta.Edition))
-	switch {
-	case strings.Contains(edition, "director"):
-		return "Director's Cut"
-	case strings.Contains(edition, "theatrical"):
-		return "Theatrical Cut"
-	case strings.Contains(edition, "extended"):
-		return "Extended"
-	case strings.Contains(edition, "uncut"):
-		return "Uncut"
-	case strings.Contains(edition, "unrated"):
-		return "Unrated"
-	case strings.Contains(edition, "imax"):
-		return "IMAX"
-	case strings.Contains(edition, "noir"):
-		return "Noir"
-	case strings.Contains(edition, "remaster"):
-		return "Remastered"
-	default:
-		return ""
-	}
-}
-
-func removeDiacritics(s string) string {
-	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-	result, _, _ := transform.String(t, s)
-	return result
-}
-
-func resolveTags(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	// 1. Use localized if available
-	if ptBR.Genres != "" {
-		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
-		out := make([]string, 0, len(genres))
-		for _, genre := range genres {
-			cleaned := removeDiacritics(genre)
-			tag := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(cleaned), " ", "."))
-			if tag != "" {
-				out = append(out, tag)
-			}
-		}
-		return strings.Join(out, ", ")
-	}
-
-	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
-	var genreText string
-	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres) != "":
-		genreText = strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	default:
-		genreText = strings.TrimSpace(meta.Release.Genre)
-	}
-
-	if genreText == "" {
-		return ""
-	}
-
-	genres := strings.Split(genreText, ",")
-	out := make([]string, 0, len(genres))
-	for _, genre := range genres {
-		translated := metautil.TranslateGenreToPortugueseStrict(genre)
-		if translated == "" {
-			translated = genre
-		}
-		cleaned := removeDiacritics(translated)
-		tag := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(cleaned), " ", "."))
-		if tag != "" {
-			out = append(out, tag)
-		}
-	}
-	return strings.Join(out, ", ")
-}
-
-func resolveRuntime(meta api.PreparedMetadata) int {
-	if meta.MediaInfoTextPath != "" {
-		if payload, err := os.ReadFile(meta.MediaInfoTextPath); err == nil {
-			if minutes := parseMediaInfoDurationMinutes(string(payload)); minutes > 0 {
-				return minutes
-			}
-		}
-	}
-	if meta.DVDVOBMediaInfoText != "" {
-		if minutes := parseMediaInfoDurationMinutes(meta.DVDVOBMediaInfoText); minutes > 0 {
-			return minutes
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") && meta.BDInfo != nil {
-		if minutes := parseBDInfoLengthMinutes(meta.BDInfo["length"]); minutes > 0 {
-			return minutes
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.RuntimeMinutes > 0 {
-		return meta.ExternalMetadata.IMDB.RuntimeMinutes
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return meta.ExternalMetadata.TMDB.Runtime
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		return meta.ExternalMetadata.TVmaze.Runtime
-	}
-	return 0
-}
-
-// parseMediaInfoDurationMinutes returns rounded minutes from the first parseable
-// MediaInfo Duration or Duration/String[1-3] line.
-func parseMediaInfoDurationMinutes(content string) int {
-	for _, match := range mediaInfoDurationLinePattern.FindAllStringSubmatch(content, -1) {
-		if len(match) != 2 {
-			continue
-		}
-		if minutes := parseMediaInfoDurationValueMinutes(match[1]); minutes > 0 {
-			return minutes
-		}
-	}
-	return 0
-}
-
-// parseMediaInfoDurationValueMinutes accepts colon time, unit-token text, or
-// raw millisecond values as emitted by MediaInfo duration fields.
-func parseMediaInfoDurationValueMinutes(value string) int {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 0
-	}
-	if matches := isoDurationPattern.FindStringSubmatch(trimmed); len(matches) == 4 {
-		return mediaInfoDurationSecondsToMinutes(durationComponentSeconds(matches[1], matches[2], matches[3], ""))
-	}
-	if strings.Contains(trimmed, ":") {
-		return mediaInfoDurationSecondsToMinutes(parseMediaInfoDurationColonSeconds(trimmed))
-	}
-	if seconds := parseMediaInfoDurationTokenSeconds(trimmed); seconds > 0 {
-		return mediaInfoDurationSecondsToMinutes(seconds)
-	}
-	if fields := strings.Fields(trimmed); len(fields) > 0 {
-		if ms, err := strconv.ParseFloat(strings.ReplaceAll(fields[0], ",", ""), 64); err == nil && ms > 10000 {
-			return int(math.Round(ms / 60000.0))
-		}
-	}
-	return 0
-}
-
-// parseMediaInfoDurationTokenSeconds sums h/m/s/ms duration tokens into seconds.
-func parseMediaInfoDurationTokenSeconds(value string) float64 {
-	var total float64
-	for _, match := range mediaInfoDurationTokenPattern.FindAllStringSubmatch(value, -1) {
-		if len(match) != 3 {
-			continue
-		}
-		amount, err := strconv.ParseFloat(strings.ReplaceAll(match[1], ",", ""), 64)
-		if err != nil || amount <= 0 {
-			continue
-		}
-		switch strings.ToLower(match[2]) {
-		case "h", "hr", "hrs", "hour", "hours":
-			total += amount * 3600
-		case "m", "min", "mins", "minute", "minutes":
-			total += amount * 60
-		case "s", "sec", "secs", "second", "seconds":
-			total += amount
-		case "ms", "msec", "msecs", "millisecond", "milliseconds":
-			total += amount / 1000
-		}
-	}
-	return total
-}
-
-// parseMediaInfoDurationColonSeconds parses MediaInfo colon duration values into seconds.
-func parseMediaInfoDurationColonSeconds(value string) float64 {
-	parts := strings.Split(strings.TrimSpace(value), ":")
-	if len(parts) < 2 {
-		return 0
-	}
-	var seconds float64
-	multiplier := 1.0
-	for i := len(parts) - 1; i >= 0; i-- {
-		part := strings.TrimSpace(parts[i])
-		if part == "" {
-			continue
-		}
-		amount, err := strconv.ParseFloat(strings.ReplaceAll(part, ",", ""), 64)
-		if err != nil || amount < 0 {
-			return 0
-		}
-		seconds += amount * multiplier
-		multiplier *= 60
-	}
-	return seconds
-}
-
-func mediaInfoDurationSecondsToMinutes(seconds float64) int {
-	if seconds <= 0 {
-		return 0
-	}
-	return int(math.Round(seconds / 60.0))
-}
-
-func durationComponentSeconds(hours string, minutes string, seconds string, milliseconds string) float64 {
-	totalSeconds := parseDurationComponent(hours) * 3600
-	totalSeconds += parseDurationComponent(minutes) * 60
-	totalSeconds += parseDurationComponent(seconds)
-	totalSeconds += parseDurationComponent(milliseconds) / 1000
-	return totalSeconds
-}
-
-func parseDurationComponent(value string) float64 {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return 0
-	}
-	parsed, err := strconv.ParseFloat(trimmed, 64)
-	if err != nil || parsed < 0 {
-		return 0
-	}
-	return parsed
-}
-
-func parseBDInfoLengthMinutes(value any) int {
-	text := strings.TrimSpace(fmt.Sprint(value))
-	if text == "" || text == "<nil>" {
-		return 0
-	}
-	parts := strings.Split(text, ":")
-	if len(parts) != 3 {
-		return 0
-	}
-	hours, err := strconv.ParseFloat(strings.TrimSpace(parts[0]), 64)
-	if err != nil || hours < 0 {
-		return 0
-	}
-	minutes, err := strconv.ParseFloat(strings.TrimSpace(parts[1]), 64)
-	if err != nil || minutes < 0 {
-		return 0
-	}
-	seconds, err := strconv.ParseFloat(strings.TrimSpace(parts[2]), 64)
-	if err != nil || seconds < 0 {
-		return 0
-	}
-	totalSeconds := hours*3600 + minutes*60 + seconds
-	if totalSeconds <= 0 {
-		return 0
-	}
-	return int(math.Round(totalSeconds / 60.0))
-}
-
-func resolveDirectors(meta api.PreparedMetadata) string {
-	var directors []string
-	seen := make(map[string]struct{})
-
-	addDirector := func(name string) {
-		name = strings.TrimSpace(name)
-		if name == "" {
-			return
-		}
-		if _, ok := seen[name]; !ok {
-			seen[name] = struct{}{}
-			directors = append(directors, name)
-		}
-	}
-
-	if meta.ExternalMetadata.TMDB != nil {
-		for _, name := range meta.ExternalMetadata.TMDB.Directors {
-			addDirector(name)
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		for _, person := range meta.ExternalMetadata.IMDB.Directors {
-			addDirector(person.Name)
-		}
-	}
-
-	if len(directors) > 0 {
-		limit := min(len(directors), 5)
-		return strings.Join(directors[:limit], ", ")
-	}
-
-	return "N/A"
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		if meta.ExternalMetadata.TMDB.Localized != nil {
-			if localized, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
-				return strings.TrimSpace(localized.Poster)
-			}
-		}
-		if strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster) != "" {
-			return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	}
-	return ""
-}
-
-func resolveScreens(assets trackers.DescriptionAssets) []string {
-	var screens []string
-	seen := make(map[string]struct{})
-
-	for _, image := range assets.MenuImages {
-		u := strings.TrimSpace(image.RawURL)
-		if u == "" {
-			u = strings.TrimSpace(image.ImgURL)
-		}
-		if u != "" && !isSeen(seen, u) {
-			screens = append(screens, u)
-			seen[u] = struct{}{}
-		}
-	}
-	for _, image := range assets.Screenshots {
-		u := strings.TrimSpace(image.RawURL)
-		if u == "" {
-			u = strings.TrimSpace(image.ImgURL)
-		}
-		if u != "" && !isSeen(seen, u) {
-			screens = append(screens, u)
-			seen[u] = struct{}{}
-		}
-	}
-	return screens
-}
-
-func isSeen(seen map[string]struct{}, url string) bool {
-	_, ok := seen[url]
-	return ok
-}
-
-// resolveOverview prefers scoped TV synopsis for episode/season-pack uploads,
-// then localized title-level overview, then TMDB or IMDB fallback text.
-func resolveOverview(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
-		return strings.TrimSpace(ptBR.EpisodeOverview)
-	}
-	if ptBR.Overview != "" {
-		return strings.TrimSpace(ptBR.Overview)
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	}
-	return ""
-}
-
-// shouldUseScopedTVOverview reports whether BT should prefer season or
-// episode localized overview over title-level synopsis text.
-func shouldUseScopedTVOverview(meta api.PreparedMetadata) bool {
-	if meta.SeasonInt <= 0 {
-		return false
-	}
-	if !isTVUpload(meta) {
-		return false
-	}
-	if meta.TVPack {
-		return true
-	}
-	return meta.EpisodeInt > 0
-}
-
-// isTVUpload reports whether BT should treat the upload as TV from category or episode fields.
-func isTVUpload(meta api.PreparedMetadata) bool {
-	category := strings.TrimSpace(categoryOf(meta))
-	if strings.EqualFold(category, "TV") {
-		return true
-	}
-	if category == "" {
-		return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0
-	}
-	return false
-}
-
-func resolveYouTube(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	youtube := ""
-	if ptBR.TrailerURL != "" {
-		youtube = strings.TrimSpace(ptBR.TrailerURL)
-	} else if meta.ExternalMetadata.TMDB != nil {
-		youtube = strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-
-	if strings.Contains(youtube, "youtube.com") || strings.Contains(youtube, "youtu.be") {
-		switch {
-		case strings.Contains(youtube, "v="):
-			parts := strings.Split(youtube, "v=")
-			if len(parts) > 1 {
-				youtube = parts[1]
-			}
-		case strings.Contains(youtube, "embed/"):
-			parts := strings.Split(youtube, "embed/")
-			if len(parts) > 1 {
-				youtube = parts[1]
-			}
-		case strings.Contains(youtube, "youtu.be/"):
-			parts := strings.Split(youtube, "youtu.be/")
-			if len(parts) > 1 {
-				youtube = parts[1]
-			}
-		}
-	}
-
-	if idx := strings.Index(youtube, "&"); idx != -1 {
-		youtube = youtube[:idx]
-	}
-	if idx := strings.Index(youtube, "?"); idx != -1 {
-		youtube = youtube[:idx]
-	}
-	youtube = strings.ReplaceAll(youtube, "/", "")
-	return youtube
-}
-
-func resolveLogo(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo) != "" {
-		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo), "/")
-	}
-	return ""
-}
-
-func resolveYear(meta api.PreparedMetadata) int {
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		return meta.ExternalMetadata.TMDB.Year
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		return meta.ExternalMetadata.IMDB.Year
-	}
-	return meta.Release.Year
-}
-
-func resolveTitle(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Title, meta.Release.Title)
-	}
-	return meta.Release.Title
-}
-
-func resolveLocalizedTitle(meta api.PreparedMetadata, ptBR api.TMDBLocalizedData) string {
-	if ptBR.Title != "" {
-		if meta.ExternalMetadata.TMDB != nil {
-			return metautil.FirstNonEmptyTrimmed(ptBR.Title, meta.ExternalMetadata.TMDB.OriginalTitle)
-		}
-		return ptBR.Title
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Title, meta.ExternalMetadata.TMDB.OriginalTitle)
-	}
-	return ""
-}
-
-func resolveLanguage(meta api.PreparedMetadata) string {
-	var lang string
-	if meta.ExternalMetadata.TMDB != nil {
-		lang = strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage)
-	}
-	if lang == "" {
-		if len(meta.Release.Language) > 0 {
-			lang = meta.Release.Language[0]
-		}
-	}
-	lang = strings.ToLower(lang)
-	if lang == "" {
-		return ""
-	}
-
-	return metautil.ISO639PortugueseName(lang, lang)
-}
-
-func resolveBackdrop(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Backdrop)
-	}
-	return ""
-}
-
-func resolveIMDbText(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveIMDbRating(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Rating > 0 {
-		return strconv.FormatFloat(meta.ExternalMetadata.IMDB.Rating, 'f', 1, 64)
-	}
-	return ""
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func yesNo(value bool) string {
-	if value {
-		return "Sim"
-	}
-	return "Nao"
-}
-
-func flattenFields(in map[string][]string) map[string]string {
-	out := make(map[string]string, len(in))
-	for key, values := range in {
-		if len(values) > 0 {
-			out[key] = strings.Join(values, ", ")
-		}
-	}
-	return out
-}
-
-func matchValue(values []string, idx int) string {
-	if idx >= 0 && idx < len(values) {
-		return values[idx]
-	}
-	return ""
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, fields map[string][]string) *api.TrackerQuestionnaire {
-	current := questionnaireAnswers(meta)
-	var items []api.TrackerQuestionnaireField
-
-	sinopse := ""
-	if len(fields["sinopse"]) > 0 {
-		sinopse = strings.TrimSpace(fields["sinopse"][0])
-	}
-	if sinopse == "" {
-		items = append(items, api.TrackerQuestionnaireField{
-			Key: "overview", Label: "Overview", Kind: "textarea", Value: current["overview"], Required: true,
-		})
-	}
-
-	tags := ""
-	if len(fields["tags"]) > 0 {
-		tags = strings.TrimSpace(fields["tags"][0])
-	}
-	if tags == "" {
-		items = append(items, api.TrackerQuestionnaireField{
-			Key: "tags", Label: "Tags", Kind: "text", Value: current["tags"], Required: true,
-		})
-	}
-
-	if len(items) == 0 {
-		return nil
-	}
-	return &api.TrackerQuestionnaire{Tracker: "BT", Fields: items}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["BT"]
-}
diff --git a/internal/trackers/impl/bt/upload_test.go b/internal/trackers/impl/bt/upload_test.go
deleted file mode 100644
index 5d790b1e..00000000
--- a/internal/trackers/impl/bt/upload_test.go
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bt
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
-	t.Parallel()
-
-	ptBR := api.TMDBLocalizedData{
-		Overview:        "Series Overview",
-		EpisodeOverview: "Episode Overview",
-	}
-
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-		want string
-	}{
-		{
-			name: "episode upload uses episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "lowercase episode upload uses episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "tv"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "season pack uses season overview from episode field",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				SeasonInt:   1,
-				TVPack:      true,
-			},
-			want: "Episode Overview",
-		},
-		{
-			name: "series upload uses title overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-			},
-			want: "Series Overview",
-		},
-		{
-			name: "movie ignores episode overview",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-				SeasonInt:   1,
-				EpisodeInt:  2,
-			},
-			want: "Series Overview",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := resolveOverview(tc.meta, ptBR); got != tc.want {
-				t.Fatalf("expected overview %q, got %q", tc.want, got)
-			}
-		})
-	}
-}
-
-func TestResolveTagsPreservesUnknownGenres(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{
-			Genre: "Sci-Fi,MyCustomGenre",
-		},
-	}
-	ptBR := api.TMDBLocalizedData{}
-
-	// Sci-Fi maps to "ficção científica", MyCustomGenre does not map but should be preserved
-	got := resolveTags(meta, ptBR)
-	expected := "ficcao.cientifica, mycustomgenre"
-	if got != expected {
-		t.Fatalf("expected tags %q, got %q", expected, got)
-	}
-}
-
-func TestBuildDescriptionOmitsBlankLocalizedEpisodeTitleRow(t *testing.T) {
-	t.Parallel()
-
-	description := buildDescription(trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{
-					Localized: map[string]api.TMDBLocalizedData{
-						"pt-BR": {EpisodeOverview: "Resumo do episodio"},
-					},
-				},
-			},
-		},
-	}, trackers.DescriptionAssets{})
-
-	if strings.Contains(description, "[center][/center]") {
-		t.Fatalf("expected no blank centered title row, got %q", description)
-	}
-	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
-		t.Fatalf("expected localized episode overview, got %q", description)
-	}
-}
-
-func TestBuildDescriptionKeepsLocalizedEpisodeTitleWhenPresent(t *testing.T) {
-	t.Parallel()
-
-	description := buildDescription(trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{
-					Localized: map[string]api.TMDBLocalizedData{
-						"pt-BR": {
-							EpisodeTitle:    "Titulo do episodio",
-							EpisodeOverview: "Resumo do episodio",
-						},
-					},
-				},
-			},
-		},
-	}, trackers.DescriptionAssets{})
-
-	if !strings.Contains(description, "[center]Titulo do episodio[/center]") {
-		t.Fatalf("expected localized episode title, got %q", description)
-	}
-	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
-		t.Fatalf("expected localized episode overview, got %q", description)
-	}
-}
-
-func TestBuildDescriptionTreatsWhitespaceLocalizedEpisodeTitleAsEmpty(t *testing.T) {
-	t.Parallel()
-
-	description := buildDescription(trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{
-					Localized: map[string]api.TMDBLocalizedData{
-						"pt-BR": {
-							EpisodeTitle:    " \t ",
-							EpisodeOverview: "Resumo do episodio",
-						},
-					},
-				},
-			},
-		},
-	}, trackers.DescriptionAssets{})
-
-	if strings.Contains(description, "[center][/center]") {
-		t.Fatalf("expected no blank centered title row, got %q", description)
-	}
-	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
-		t.Fatalf("expected localized episode overview, got %q", description)
-	}
-}
-
-func TestResolveVideoCodecMapsH264H265(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		codec    string
-		isHDR    bool
-		expected string
-	}{
-		{codec: "H264", isHDR: false, expected: "x264"},
-		{codec: "H265", isHDR: false, expected: "x265"},
-		{codec: "H265", isHDR: true, expected: "x265 HDR"},
-		{codec: "hevc", isHDR: false, expected: "x265"},
-		{codec: "avc", isHDR: false, expected: "x264"},
-		{codec: "OtherCodec", isHDR: false, expected: "OtherCodec"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.codec, func(t *testing.T) {
-			meta := api.PreparedMetadata{
-				VideoCodec: tc.codec,
-			}
-			if tc.isHDR {
-				meta.HDR = "HDR10"
-			}
-			got := resolveVideoCodec(meta)
-			if got != tc.expected {
-				t.Fatalf("expected %q for codec %q (HDR=%t), got %q", tc.expected, tc.codec, tc.isHDR, got)
-			}
-		})
-	}
-}
-
-func TestParseMediaInfoDurationMinutes(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		content  string
-		expected int
-	}{
-		{
-			name:     "valid hours and minutes",
-			content:  "duration : 2 h 15 m",
-			expected: 135,
-		},
-		{
-			name:     "duration string label",
-			content:  "Duration/String : 2 h 5 min 2 s",
-			expected: 125,
-		},
-		{
-			name:     "duration string1 label",
-			content:  "\tDuRaTiOn/String1   : 2 h 5 min 2 s",
-			expected: 125,
-		},
-		{
-			name:     "duration spaced slash label",
-			content:  "Duration / String2 : 2 hrs 5 mins 2 secs",
-			expected: 125,
-		},
-		{
-			name:     "duration string3 colon label",
-			content:  "Duration/String3 : 02:05:02.000",
-			expected: 125,
-		},
-		{
-			name:     "iso duration value",
-			content:  "Duration/String : PT2H5M2S",
-			expected: 125,
-		},
-		{
-			name:     "valid milliseconds",
-			content:  "duration : 120000",
-			expected: 2,
-		},
-		{
-			name:     "empty fields (potential panic)",
-			content:  "duration :    ",
-			expected: 0,
-		},
-		{
-			name:     "invalid string1 skips to later duration",
-			content:  "Duration/String1 : not a duration\nDuration/String2 : 01:30:00.000",
-			expected: 90,
-		},
-		{
-			name:     "duration string4 remains ignored",
-			content:  "Duration/String4 : 01:30:00.000",
-			expected: 0,
-		},
-		{
-			name:     "adjacent duration fields remain ignored",
-			content:  "Source_Duration : 01:30:00.000\nDuration_Start : 01:30:00.000",
-			expected: 0,
-		},
-		{
-			name:     "no duration keyword",
-			content:  "something else",
-			expected: 0,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := parseMediaInfoDurationMinutes(tc.content)
-			if got != tc.expected {
-				t.Fatalf("expected %d, got %d", tc.expected, got)
-			}
-		})
-	}
-}
-
-func TestResolveRuntimeFallsBackWhenMediaInfoDurationInvalid(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		DVDVOBMediaInfoText: "Duration/String : not a duration",
-		DiscType:            "BDMV",
-		BDInfo: map[string]any{
-			"length": "01:30:00.000",
-		},
-	}
-
-	if got := resolveRuntime(meta); got != 90 {
-		t.Fatalf("expected BDInfo runtime fallback, got %d", got)
-	}
-}
diff --git a/internal/trackers/impl/bt/wrap_errors.go b/internal/trackers/impl/bt/wrap_errors.go
deleted file mode 100644
index 2f8fbf23..00000000
--- a/internal/trackers/impl/bt/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package bt
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/btn/definition.go b/internal/trackers/impl/btn/definition.go
deleted file mode 100644
index b2fa53b0..00000000
--- a/internal/trackers/impl/btn/definition.go
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package btn
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "BTN"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-
-	description := strings.TrimSpace(assets.Description)
-	if description == "" {
-		description = strings.TrimSpace(req.Meta.DescriptionOverride)
-	}
-	if description == "" {
-		description = "No description provided."
-	}
-
-	return trackers.DescriptionResult{
-		Group:       "btn",
-		Description: description,
-	}, nil
-}
-
-func validateBTNRequest(req trackers.UploadRequest) error {
-	if !strings.EqualFold(strings.TrimSpace(req.Meta.ExternalIDs.Category), "TV") && !strings.EqualFold(strings.TrimSpace(req.Meta.MediaInfoCategory), "TV") {
-		return errors.New("trackers: BTN only supports TV uploads")
-	}
-	if strings.TrimSpace(config.ResolveBTNAPIToken(req.AppConfig)) == "" {
-		return errors.New("trackers: BTN requires trackers.BTN.api_key")
-	}
-	return nil
-}
-
-var btnInternalGroups = []string{
-	"BTW",
-	"ESPNtb",
-	"HiSD",
-	"HRiP",
-	"iPRiP",
-	"iT00NZ",
-	"JJ",
-	"LoTV",
-	"NTb",
-	"PreBS",
-	"RAWR",
-	"TTVa",
-	"TVSmash",
-}
-
-func isBTNInternalGroup(meta api.PreparedMetadata) bool {
-	if strings.TrimSpace(meta.Tag) == "" {
-		return false
-	}
-
-	group := strings.ToLower(strings.TrimPrefix(meta.Tag, "-"))
-	for _, value := range btnInternalGroups {
-		if strings.ToLower(value) == group {
-			return true
-		}
-	}
-	return false
-}
diff --git a/internal/trackers/impl/btn/definition_test.go b/internal/trackers/impl/btn/definition_test.go
deleted file mode 100644
index 7698395d..00000000
--- a/internal/trackers/impl/btn/definition_test.go
+++ /dev/null
@@ -1,999 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package btn
-
-import (
-	"bytes"
-	"context"
-	"net"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionName(t *testing.T) {
-	t.Parallel()
-
-	def := New()
-	if def.Name() != "BTN" {
-		t.Fatalf("expected BTN, got %q", def.Name())
-	}
-}
-
-func TestApplyBTNNameMapping(t *testing.T) {
-	t.Parallel()
-
-	name := "Example.Show.S01E01.1080p.WEB-DL.x265-GRP"
-	mapped := applyBTNNameMapping(name, "H.265", "WEB-DL")
-	if mapped == "" {
-		t.Fatalf("expected mapped name")
-	}
-	if mapped != "Example.Show.S01E01.1080p.WEB-DL.H.265-GRP" {
-		t.Fatalf("unexpected mapped name: %s", mapped)
-	}
-}
-
-func TestCleanAndNormalizeBTNName(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected string
-	}{
-		{
-			name:     "spaces become dots",
-			input:    "Example Show S01E01 1080p Web-DL DD+ 5.1 x265-GRP",
-			expected: "Example.Show.S01E01.1080p.Web-DL.DDP5.1.x265-GRP",
-		},
-		{
-			name:     "DDP Atmos compacts before generic DDP channel",
-			input:    "Some.Movie.2023.DDP.5.1.Atmos.x264",
-			expected: "Some.Movie.2023.DDPA5.1.x264",
-		},
-		{
-			name:     "duplicate dots collapse after DD channel",
-			input:    "Another.Show..S02E03.DD.2.0.x264",
-			expected: "Another.Show.S02E03.DD2.0.x264",
-		},
-		{
-			name:     "AC3 and DTS channel joins",
-			input:    "Test.AC3.5.1.and.DTS.5.1.Show",
-			expected: "Test.AC35.1.and.DTS5.1.Show",
-		},
-		{
-			name:     "TrueHD Atmos compacts before generic TrueHD channel",
-			input:    "Movie.TrueHD.7.1.Atmos.x264",
-			expected: "Movie.TrueHDA7.1.x264",
-		},
-		{
-			name:     "DDP channel joins",
-			input:    "Movie.DDP.5.1.x264",
-			expected: "Movie.DDP5.1.x264",
-		},
-		{
-			name:     "AAC channel joins",
-			input:    "Movie.AAC.2.0.x264",
-			expected: "Movie.AAC2.0.x264",
-		},
-		{
-			name:     "FLAC channel joins",
-			input:    "Movie.FLAC.2.0.x264",
-			expected: "Movie.FLAC2.0.x264",
-		},
-		{
-			name:     "TrueHD channel joins case-insensitively",
-			input:    "Movie.truehd.7.1.x264",
-			expected: "Movie.TrueHD7.1.x264",
-		},
-		{
-			name:     "PCM channel joins case-insensitively",
-			input:    "Movie.pcm.2.0.x264",
-			expected: "Movie.PCM2.0.x264",
-		},
-		{
-			name:     "LPCM channel joins case-insensitively",
-			input:    "Movie.lpcm.2.0.x264",
-			expected: "Movie.LPCM2.0.x264",
-		},
-		{
-			name:     "non-alphanumeric chars become dots",
-			input:    "Movie:Title[Cut].DDP.5.1-GRP",
-			expected: "Movie.Title.Cut.DDP5.1-GRP",
-		},
-		{
-			name:     "diacritics are removed",
-			input:    "Éxample Shōw S01E01",
-			expected: "Example.Show.S01E01",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := cleanAndNormalizeBTNName(tc.input)
-			if result != tc.expected {
-				t.Errorf("cleanAndNormalizeBTNName(%q) = %q; expected %q", tc.input, result, tc.expected)
-			}
-		})
-	}
-}
-
-func TestResolveUploadNameGroupTag(t *testing.T) {
-	tests := []struct {
-		name     string
-		meta     api.PreparedMetadata
-		expected string
-	}{
-		{
-			name: "Valid group tag in meta.Tag",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
-				Tag:         "GRP",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
-		},
-		{
-			name: "Valid group tag appended to ReleaseNameNoTag",
-			meta: api.PreparedMetadata{
-				ReleaseNameNoTag: "Example.Show.S01E01.1080p.Web-DL",
-				Tag:              "GRP",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL-GRP",
-		},
-		{
-			name: "Missing group tag",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265",
-				Tag:         "",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
-		},
-		{
-			name: "Missing parsed tag preserves existing release suffix",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
-				Tag:         "",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
-		},
-		{
-			name: "Unknown group tag in meta.Tag",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265",
-				Tag:         "nogrp",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
-		},
-		{
-			name: "Existing unknown group tag in ReleaseName",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-unknown",
-				Tag:         "unknown",
-			},
-			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
-		},
-		{
-			name: "Generated episode title absent from filename stripped",
-			meta: api.PreparedMetadata{
-				Filename:     "Example.Show.S01E01.1080p.WEB-DL.x265-GRP.mkv",
-				ReleaseName:  "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
-				EpisodeTitle: "Episode One",
-				Tag:          "GRP",
-			},
-			expected: "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
-		},
-		{
-			name: "Filename episode title preserved",
-			meta: api.PreparedMetadata{
-				Filename:     "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP.mkv",
-				ReleaseName:  "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
-				EpisodeTitle: "Episode One",
-				Tag:          "GRP",
-			},
-			expected: "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
-		},
-		{
-			name: "Episode title substring preserved",
-			meta: api.PreparedMetadata{
-				Filename:     "Example.Show.S01E01.1080p.WEB-DL.x265-GRP.mkv",
-				ReleaseName:  "Example.Show.S01E01.Someone.1080p.WEB-DL.x265-GRP",
-				EpisodeTitle: "One",
-				Tag:          "GRP",
-			},
-			expected: "Example.Show.S01E01.Someone.1080p.WEB-DL.x265-GRP",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := resolveUploadName(tc.meta)
-			if result != tc.expected {
-				t.Errorf("resolveUploadName() = %q; expected %q", result, tc.expected)
-			}
-		})
-	}
-}
-
-func TestResolveOrigin(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		meta     api.PreparedMetadata
-		expected string
-	}{
-		{
-			name:     "scene metadata",
-			meta:     api.PreparedMetadata{Scene: true},
-			expected: "Scene",
-		},
-		{
-			name:     "scene name metadata",
-			meta:     api.PreparedMetadata{SceneName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP"},
-			expected: "Scene",
-		},
-		{
-			name:     "non-scene metadata",
-			meta:     api.PreparedMetadata{ReleaseName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP"},
-			expected: "P2P",
-		},
-		{
-			name: "mixed season pack groups",
-			meta: api.PreparedMetadata{
-				TVPack: true,
-				FileList: []string{
-					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
-					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv`,
-				},
-			},
-			expected: "Mixed",
-		},
-		{
-			name: "same season pack groups",
-			meta: api.PreparedMetadata{
-				TVPack: true,
-				FileList: []string{
-					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
-					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-GRP.mkv`,
-				},
-			},
-			expected: "P2P",
-		},
-		{
-			name: "mixed file groups ignored outside season packs",
-			meta: api.PreparedMetadata{
-				FileList: []string{
-					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
-					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv`,
-				},
-			},
-			expected: "P2P",
-		},
-		{
-			name: "none origin for no group tag",
-			meta: api.PreparedMetadata{
-				Release: api.ReleaseInfo{Group: "nogrp"},
-			},
-			expected: "None",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := resolveOrigin(tc.meta); got != tc.expected {
-				t.Fatalf("expected origin %q, got %q", tc.expected, got)
-			}
-		})
-	}
-}
-
-func TestResolveBTNUploadFilesSceneNFO(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	torrentPath := filepath.Join(dir, "upload.torrent")
-	if err := os.WriteFile(torrentPath, []byte("d8:announce13:https://x.ee"), 0o600); err != nil {
-		t.Fatalf("write torrent fixture: %v", err)
-	}
-	nfoPath := filepath.Join(dir, "scene.nfo")
-	if err := os.WriteFile(nfoPath, []byte("scene nfo"), 0o600); err != nil {
-		t.Fatalf("write nfo fixture: %v", err)
-	}
-
-	tests := []struct {
-		name       string
-		meta       api.PreparedMetadata
-		wantFields []string
-	}{
-		{
-			name:       "scene release attaches nfo",
-			meta:       api.PreparedMetadata{Scene: true, SceneNFOPath: nfoPath},
-			wantFields: []string{"file_input", "nfo"},
-		},
-		{
-			name:       "scene name attaches nfo",
-			meta:       api.PreparedMetadata{SceneName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP", SceneNFOPath: nfoPath},
-			wantFields: []string{"file_input", "nfo"},
-		},
-		{
-			name:       "non-scene ignores nfo path",
-			meta:       api.PreparedMetadata{SceneNFOPath: nfoPath},
-			wantFields: []string{"file_input"},
-		},
-		{
-			name:       "scene release skips missing nfo path",
-			meta:       api.PreparedMetadata{Scene: true, SceneNFOPath: filepath.Join(dir, "missing.nfo")},
-			wantFields: []string{"file_input"},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			files := resolveBTNUploadFiles(tc.meta, torrentPath)
-			gotFields := make([]string, 0, len(files))
-			for _, file := range files {
-				gotFields = append(gotFields, file.FieldName)
-			}
-			if strings.Join(gotFields, ",") != strings.Join(tc.wantFields, ",") {
-				t.Fatalf("expected fields %#v, got %#v", tc.wantFields, gotFields)
-			}
-
-			dryRunFiles := resolveBTNDryRunFiles(tc.meta, torrentPath)
-			gotDryRunFields := make([]string, 0, len(dryRunFiles))
-			for _, file := range dryRunFiles {
-				gotDryRunFields = append(gotDryRunFields, file.Field)
-			}
-			if strings.Join(gotDryRunFields, ",") != strings.Join(tc.wantFields, ",") {
-				t.Fatalf("expected dry-run fields %#v, got %#v", tc.wantFields, gotDryRunFields)
-			}
-		})
-	}
-}
-
-func TestResolveCountryIDUsesExactAliases(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		meta     api.PreparedMetadata
-		expected string
-	}{
-		{
-			name: "TVDB alpha3 exact",
-			meta: api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-				TVDB: &api.TVDBMetadata{OriginalCountry: "usa"},
-			}},
-			expected: "2",
-		},
-		{
-			name: "TMDB alpha2 exact",
-			meta: api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{OriginCountry: []string{"GB"}},
-			}},
-			expected: "12",
-		},
-		{
-			name: "IMDB compound alias",
-			meta: api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-				IMDB: &api.IMDBMetadata{Country: "Trinidad and Tobago"},
-			}},
-			expected: "75",
-		},
-		{
-			name: "punctuation normalized exact alias",
-			meta: api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-				IMDB: &api.IMDBMetadata{Country: "Bosnia & Herzegovina"},
-			}},
-			expected: "64",
-		},
-		{
-			name: "ambiguous partial name rejected",
-			meta: api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-				IMDB: &api.IMDBMetadata{Country: "Korea"},
-			}},
-			expected: "",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := resolveCountryID(tc.meta); got != tc.expected {
-				t.Fatalf("expected country id %q, got %q", tc.expected, got)
-			}
-		})
-	}
-}
-
-func TestResolveCountryIDSupportsBTNCountryOptions(t *testing.T) {
-	t.Parallel()
-
-	countries := map[string]string{
-		"Afghanistan":                    "51",
-		"Albania":                        "62",
-		"Algeria":                        "32",
-		"Andorra":                        "65",
-		"Angola":                         "33",
-		"Antigua Barbuda":                "86",
-		"Arab League":                    "107",
-		"Argentina":                      "19",
-		"Australia":                      "20",
-		"Austria":                        "34",
-		"Bahamas":                        "79",
-		"Bangladesh":                     "83",
-		"Barbados":                       "82",
-		"Belgium":                        "16",
-		"Belize":                         "31",
-		"Bosnia Herzegovina":             "64",
-		"Brazil":                         "18",
-		"Brunei":                         "113",
-		"Bulgaria":                       "100",
-		"Burkina Faso":                   "57",
-		"Cambodia":                       "81",
-		"Canada":                         "5",
-		"Chile":                          "48",
-		"China":                          "8",
-		"Colombia":                       "95",
-		"Congo":                          "50",
-		"Costa Rica":                     "98",
-		"Croatia":                        "93",
-		"Cuba":                           "49",
-		"Czech Republic":                 "43",
-		"Denmark":                        "10",
-		"Dominican Republic":             "38",
-		"Ecuador":                        "78",
-		"Egypt":                          "99",
-		"Estonia":                        "94",
-		"Fiji":                           "102",
-		"Finland":                        "4",
-		"France":                         "6",
-		"Germany":                        "7",
-		"Greece":                         "39",
-		"Guatemala":                      "40",
-		"Honduras":                       "76",
-		"Hong Kong":                      "30",
-		"Hungary":                        "71",
-		"Iceland":                        "59",
-		"India":                          "67",
-		"Indonesia":                      "111",
-		"Iran":                           "106",
-		"Ireland":                        "13",
-		"Isle de Muerte":                 "101",
-		"Israel":                         "41",
-		"Italy":                          "9",
-		"Jamaica":                        "28",
-		"Japan":                          "17",
-		"Kiribati":                       "55",
-		"Kuwait":                         "104",
-		"Kyrgyzstan":                     "77",
-		"Laos":                           "84",
-		"Latvia":                         "97",
-		"Lebanon":                        "96",
-		"Lithuania":                      "66",
-		"Luxembourg":                     "29",
-		"Macedonia":                      "103",
-		"Malaysia":                       "37",
-		"Mexico":                         "24",
-		"Nauru":                          "60",
-		"Netherlands":                    "15",
-		"Netherlands Antilles":           "68",
-		"New Zealand":                    "21",
-		"Nigeria":                        "58",
-		"North Korea":                    "92",
-		"Norway":                         "11",
-		"Pakistan":                       "42",
-		"Paraguay":                       "87",
-		"Peru":                           "80",
-		"Philippines":                    "56",
-		"Poland":                         "14",
-		"Portugal":                       "23",
-		"Puerto Rico":                    "47",
-		"Romania":                        "72",
-		"Russia":                         "3",
-		"Saudi Arabia":                   "108",
-		"Scotland":                       "109",
-		"Senegal":                        "90",
-		"Serbia":                         "44",
-		"Seychelles":                     "45",
-		"Singapore":                      "25",
-		"Slovakia":                       "110",
-		"Slovenia":                       "61",
-		"South Africa":                   "26",
-		"South Korea":                    "27",
-		"Spain":                          "22",
-		"Sri Lanka":                      "105",
-		"Sweden":                         "1",
-		"Switzerland":                    "54",
-		"Taiwan":                         "46",
-		"Thailand":                       "89",
-		"Togo":                           "91",
-		"Trinidad & Tobago":              "75",
-		"Turkey":                         "52",
-		"Turkmenistan":                   "63",
-		"Ukraine":                        "69",
-		"Union of Soviet Socialist Repu": "88",
-		"United Kingdom":                 "12",
-		"United States of America":       "2",
-		"Uruguay":                        "85",
-		"Uzbekistan":                     "53",
-		"Vanuatu":                        "73",
-		"Venezuela":                      "70",
-		"Vietnam":                        "74",
-		"Wales":                          "112",
-		"Western Samoa":                  "36",
-		"Yugoslavia":                     "35",
-	}
-
-	for name, expected := range countries {
-		meta := api.PreparedMetadata{ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Country: name},
-		}}
-		if got := resolveCountryID(meta); got != expected {
-			t.Fatalf("expected BTN country %q to resolve to %q, got %q", name, expected, got)
-		}
-	}
-}
-
-func TestValidateBTNAPIDownloadURLAllowsOnlySameOriginPrivateFallback(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	if err := validateBTNAPIDownloadURL(ctx, "http://127.0.0.1:1/rpc", "http://127.0.0.1:1/mock-download"); err != nil {
-		t.Fatalf("expected same-origin private download URL to be allowed: %v", err)
-	}
-	if err := validateBTNAPIDownloadURL(ctx, "http://127.0.0.1:1/rpc", "http://127.0.0.1:2/mock-download"); err == nil {
-		t.Fatalf("expected cross-origin private download URL to be rejected")
-	}
-	if err := validateBTNAPIDownloadURL(ctx, "ftp://127.0.0.1/rpc", "ftp://127.0.0.1/mock-download"); err == nil {
-		t.Fatalf("expected unsupported same-origin scheme to be rejected")
-	}
-}
-
-func TestBTNAPIDownloadOriginRejectsSameHostPrivateRebind(t *testing.T) {
-	ctx := context.Background()
-	lookupCalls := 0
-	lookup := func(context.Context, string) ([]net.IPAddr, error) {
-		lookupCalls++
-		if lookupCalls == 1 {
-			return []net.IPAddr{{IP: net.IPv4(93, 184, 216, 34)}}, nil
-		}
-		return []net.IPAddr{{IP: net.IPv4(10, 0, 0, 7)}}, nil
-	}
-
-	origin, err := newBTNAPIDownloadOriginWithLookup(ctx, "https://api.example.test/rpc", lookup)
-	if err != nil {
-		t.Fatalf("pin BTN API origin: %v", err)
-	}
-	if err := origin.validateDownloadURL(ctx, "https://api.example.test/download"); err == nil {
-		t.Fatalf("expected same-host private rebind to be rejected")
-	}
-}
-
-func TestBTNDropdownMappingsPreferMetadataThenAutofill(t *testing.T) {
-	t.Parallel()
-
-	autofillFields := map[string]string{
-		"format":     "MP4",
-		"bitrate":    "H.264",
-		"media":      "HDTV",
-		"resolution": "2160p",
-	}
-	metadata := api.PreparedMetadata{
-		Container:   "mkv",
-		VideoEncode: "x265",
-		Source:      "WEB-DL",
-		Type:        "WEBDL",
-		Release:     api.ReleaseInfo{Resolution: "1080p"},
-	}
-	if got := mapContainer(metadata, autofillFields); got != "MKV" {
-		t.Fatalf("expected metadata format, got %q", got)
-	}
-	if got := mapCodec(metadata, autofillFields); got != "H.265" {
-		t.Fatalf("expected metadata bitrate, got %q", got)
-	}
-	if got := mapSource(metadata, autofillFields); got != "WEB-DL" {
-		t.Fatalf("expected metadata media, got %q", got)
-	}
-	if got := mapResolution(metadata, autofillFields); got != "1080p" {
-		t.Fatalf("expected metadata resolution, got %q", got)
-	}
-
-	invalidMetadata := api.PreparedMetadata{
-		Container:   "unknown-container",
-		VideoEncode: "unknown-codec",
-		Source:      "unknown-source",
-		Type:        "unknown-type",
-		Release:     api.ReleaseInfo{Resolution: "unknown-resolution"},
-	}
-	if got := mapContainer(invalidMetadata, autofillFields); got != "MP4" {
-		t.Fatalf("expected autofill format, got %q", got)
-	}
-	if got := mapCodec(invalidMetadata, autofillFields); got != "H.264" {
-		t.Fatalf("expected autofill bitrate, got %q", got)
-	}
-	if got := mapSource(invalidMetadata, autofillFields); got != "HDTV" {
-		t.Fatalf("expected autofill media, got %q", got)
-	}
-	if got := mapResolution(invalidMetadata, autofillFields); got != "2160p" {
-		t.Fatalf("expected autofill resolution, got %q", got)
-	}
-	if got := mapResolution(api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "Portable Device"}}, autofillFields); got != "Portable Device" {
-		t.Fatalf("expected metadata portable-device resolution, got %q", got)
-	}
-	if got := mapResolution(api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "Mixed"}}, autofillFields); got != "Mixed" {
-		t.Fatalf("expected metadata mixed resolution, got %q", got)
-	}
-}
-
-func TestResolveBTNTagsUsesAutofillThenMetadataGenres(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{Genres: "Drama, Science-Fiction, Mystery, Unlisted"},
-			IMDB: &api.IMDBMetadata{Genres: "Comedy, Crime"},
-		},
-	}
-	if got := resolveBTNTags(meta, map[string]string{"tags": "Drama, Comedy"}); got != "Drama, Comedy" {
-		t.Fatalf("expected autofill tags, got %q", got)
-	}
-	if got := resolveBTNTags(meta, map[string]string{}); got != "Drama, Mystery, Science Fiction" {
-		t.Fatalf("expected TVDB fallback tags, got %q", got)
-	}
-
-	meta.ExternalMetadata.TVDB.Genres = ""
-	if got := resolveBTNTags(meta, map[string]string{}); got != "Comedy, Crime" {
-		t.Fatalf("expected IMDb fallback tags, got %q", got)
-	}
-	if got := resolveBTNTags(api.PreparedMetadata{}, map[string]string{}); got != "" {
-		t.Fatalf("expected empty tags without autofill or provider genres, got %q", got)
-	}
-}
-
-func TestResolveBTNImageUsesAutofillThenMetadataPosters(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB:   &api.TVDBMetadata{Poster: "https://img.example/tvdb.jpg"},
-			IMDB:   &api.IMDBMetadata{Cover: "https://img.example/imdb.jpg"},
-			TVmaze: &api.TVmazeMetadata{Poster: "https://img.example/tvmaze.jpg", PosterMedium: "https://img.example/tvmaze-medium.jpg"},
-			TMDB:   &api.TMDBMetadata{Poster: "https://img.example/tmdb.jpg"},
-		},
-	}
-	if got := resolveBTNImage(meta, map[string]string{"image": "https://img.example/autofill.jpg"}); got != "https://img.example/autofill.jpg" {
-		t.Fatalf("expected autofill poster, got %q", got)
-	}
-	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvdb.jpg" {
-		t.Fatalf("expected TVDB poster, got %q", got)
-	}
-
-	meta.ExternalMetadata.TVDB = nil
-	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/imdb.jpg" {
-		t.Fatalf("expected IMDb poster, got %q", got)
-	}
-	meta.ExternalMetadata.IMDB = nil
-	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvmaze.jpg" {
-		t.Fatalf("expected TVmaze poster, got %q", got)
-	}
-	meta.ExternalMetadata.TVmaze.Poster = ""
-	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvmaze-medium.jpg" {
-		t.Fatalf("expected TVmaze medium poster, got %q", got)
-	}
-	meta.ExternalMetadata.TVmaze = nil
-	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tmdb.jpg" {
-		t.Fatalf("expected TMDB poster, got %q", got)
-	}
-}
-
-func TestDecodeBTNAPIJSONRejectsDuplicateKeysAndLargeBodies(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		payload     []byte
-		expectedErr string
-	}{
-		{
-			name:        "root duplicate",
-			payload:     []byte(`{"result":{},"result":{}}`),
-			expectedErr: `duplicate JSON object key "result"`,
-		},
-		{
-			name:        "nested duplicate",
-			payload:     []byte(`{"result":{"DownloadURL":"https://example.test/one","DownloadURL":"https://example.test/two"}}`),
-			expectedErr: `duplicate JSON object key "DownloadURL" at "result"`,
-		},
-		{
-			name:        "oversized",
-			payload:     bytes.Repeat([]byte(" "), btnAPIJSONMaxBytes+1),
-			expectedErr: "response body exceeds",
-		},
-		{
-			name:        "multiple values",
-			payload:     []byte(`{} {}`),
-			expectedErr: "multiple JSON values",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			var decoded struct {
-				Result map[string]any `json:"result"`
-			}
-			err := decodeBTNAPIJSON(bytes.NewReader(tc.payload), &decoded)
-			if err == nil || !strings.Contains(err.Error(), tc.expectedErr) {
-				t.Fatalf("expected error containing %q", tc.expectedErr)
-			}
-		})
-	}
-
-	var decoded struct {
-		Result struct {
-			DownloadURL string `json:"DownloadURL"`
-		} `json:"result"`
-	}
-	if err := decodeBTNAPIJSON(strings.NewReader(`{"result":{"DownloadURL":"https://example.test/download"}}`), &decoded); err != nil {
-		t.Fatalf("decode valid BTN API JSON: %v", err)
-	}
-	if decoded.Result.DownloadURL != "https://example.test/download" {
-		t.Fatalf("unexpected decoded DownloadURL")
-	}
-}
-
-func TestBTNUploadPayloadUsesCanonicalSeasonEpisodeOnly(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		Release:     api.ReleaseInfo{Season: 4, Episode: 9},
-	}
-
-	if got := resolveUploadType(meta); got != "Season" {
-		t.Fatalf("expected upload type Season without canonical episode, got %q", got)
-	}
-	desc := buildAlbumDesc(meta, nil)
-	for _, value := range []string{"[b]Season:[/b] 0", "[b]Episode:[/b] 0"} {
-		if !strings.Contains(desc, value) {
-			t.Fatalf("expected album description to contain %q, got %q", value, desc)
-		}
-	}
-	if strings.Contains(desc, "[b]Season:[/b] 4") || strings.Contains(desc, "[b]Episode:[/b] 9") {
-		t.Fatalf("album description used parsed fallback values: %q", desc)
-	}
-	if got := btnTVPayloadMetadataMessage(meta); got != "canonical TV season/episode missing; BTN upload requires TVDB or metadata season/episode ints and ignores parsed season/episode fallback; refresh metadata or correct canonical season/episode before upload" {
-		t.Fatalf("unexpected metadata message %q", got)
-	}
-}
-
-func TestBTNUploadTypeUsesCanonicalEpisode(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		SeasonInt:   4,
-		EpisodeInt:  9,
-		Release:     api.ReleaseInfo{Season: 1, Episode: 2},
-	}
-
-	if got := resolveUploadType(meta); got != "Episode" {
-		t.Fatalf("expected upload type Episode, got %q", got)
-	}
-	if got := btnTVPayloadMetadataMessage(meta); got != "" {
-		t.Fatalf("unexpected metadata message %q", got)
-	}
-}
-
-func TestResolveBTNTVSeasonEpisodePrefersTVDBThenIMDBThenMetadata(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		SeasonInt:  2,
-		EpisodeInt: 7,
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{EpisodeSeason: 4, EpisodeNumber: 12},
-		},
-	}
-
-	season, episode := resolveBTNTVSeasonEpisode(meta)
-	if season != 4 || episode != 12 {
-		t.Fatalf("expected TVDB season/episode 4/12, got %d/%d", season, episode)
-	}
-	if got := btnTVPayloadMetadataMessage(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{EpisodeSeason: 4, EpisodeNumber: 12},
-		},
-	}); got != "" {
-		t.Fatalf("expected TVDB season/episode to satisfy BTN metadata check, got %q", got)
-	}
-
-	meta.ExternalMetadata.TVDB = &api.TVDBMetadata{}
-	meta.ExternalMetadata.IMDB = &api.IMDBMetadata{Episodes: []api.IMDBEpisode{{Season: 2, EpisodeText: "E07"}}}
-	season, episode = resolveBTNTVSeasonEpisode(meta)
-	if season != 2 || episode != 7 {
-		t.Fatalf("expected IMDb season/episode 2/7, got %d/%d", season, episode)
-	}
-
-	if got := btnTVPayloadMetadataMessage(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Episodes: []api.IMDBEpisode{{Season: 3, EpisodeText: "Episode 8"}}},
-		},
-	}); got != "" {
-		t.Fatalf("expected sole IMDb episode to satisfy BTN metadata check, got %q", got)
-	}
-
-	meta.ExternalMetadata.TVDB = nil
-	meta.ExternalMetadata.IMDB = nil
-	season, episode = resolveBTNTVSeasonEpisode(meta)
-	if season != 2 || episode != 7 {
-		t.Fatalf("expected metadata season/episode 2/7, got %d/%d", season, episode)
-	}
-}
-
-func TestBuildAlbumDescFallsBackToIMDBEpisodeMetadata(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs:     api.ExternalIDs{Category: "TV"},
-		SeasonInt:       2,
-		EpisodeInt:      7,
-		EpisodeTitle:    "Metadata Episode",
-		EpisodeOverview: "Metadata overview",
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{},
-			IMDB: &api.IMDBMetadata{
-				Plot: "IMDb overview",
-				Episodes: []api.IMDBEpisode{{
-					Title:       "IMDb Episode",
-					Season:      2,
-					EpisodeText: "7",
-					ReleaseDate: api.IMDBReleaseDate{Year: 2026, Month: 3, Day: 4},
-				}},
-			},
-		},
-	}
-
-	if desc := buildAlbumDesc(meta, map[string]string{"album_desc": "Autofill overview"}); desc != "Autofill overview" {
-		t.Fatalf("expected BTN autofill album_desc to win, got %q", desc)
-	}
-
-	desc := buildAlbumDesc(meta, nil)
-	for _, value := range []string{"[b]Episode Name:[/b] IMDb Episode", "[b]Season:[/b] 2", "[b]Episode:[/b] 7", "[b]Aired:[/b] 2026-03-04", "[b]Episode overview:[/b]\nIMDb overview"} {
-		if !strings.Contains(desc, value) {
-			t.Fatalf("expected album_desc to contain %q, got %q", value, desc)
-		}
-	}
-}
-
-func TestBuildAlbumDescUsesSingleTVDBEpisodeBlock(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		SeasonInt:   2,
-		EpisodeInt:  1,
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{
-				Episodes: []api.TVDBEpisodeMetadata{
-					{
-						SeasonNumber:    2,
-						EpisodeNumber:   1,
-						EpisodeName:     "Example Episode One",
-						EpisodeOverview: "Example overview one.",
-						EpisodeAired:    "2026-04-23",
-						EpisodeImage:    "https://img.example/tvdb-episode-1.jpg",
-					},
-					{
-						SeasonNumber:    2,
-						EpisodeNumber:   2,
-						EpisodeName:     "Example Episode Two",
-						EpisodeOverview: "Example overview two.",
-						EpisodeAired:    "2026-04-30",
-						EpisodeImage:    "https://img.example/tvdb-episode-2.jpg",
-					},
-				},
-			},
-		},
-	}
-
-	desc := buildAlbumDesc(meta, nil)
-	want := "[b]Episode Name:[/b] Example Episode One\n" +
-		"[b]Season:[/b] 2\n" +
-		"[b]Episode:[/b] 1\n" +
-		"[b]Aired:[/b] 2026-04-23\n\n" +
-		"[b]Episode overview:[/b]\n" +
-		"Example overview one.\n\n" +
-		"[b]Episode image:[/b]\n" +
-		"[img=https://img.example/tvdb-episode-1.jpg]"
-	if desc != want {
-		t.Fatalf("unexpected single episode album_desc:\n%s", desc)
-	}
-	if strings.Contains(desc, "Example Episode Two") {
-		t.Fatalf("single episode album_desc included another episode: %q", desc)
-	}
-}
-
-func TestBuildAlbumDescUsesTVDBSeasonEpisodeBlocks(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		SeasonInt:   2,
-		TVPack:      true,
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{
-				Episodes: []api.TVDBEpisodeMetadata{
-					{
-						SeasonNumber:    2,
-						EpisodeNumber:   2,
-						EpisodeName:     "Example Episode Two",
-						EpisodeOverview: "Example overview two.",
-						EpisodeAired:    "2026-04-30",
-						EpisodeImage:    "https://img.example/tvdb-episode-2.jpg",
-					},
-					{
-						SeasonNumber:    1,
-						EpisodeNumber:   1,
-						EpisodeName:     "Wrong Season",
-						EpisodeOverview: "Wrong season overview.",
-						EpisodeAired:    "2025-04-23",
-					},
-					{
-						SeasonNumber:    2,
-						EpisodeNumber:   1,
-						EpisodeName:     "Example Episode One",
-						EpisodeOverview: "Example overview one.",
-						EpisodeAired:    "2026-04-23",
-						EpisodeImage:    "https://img.example/tvdb-episode-1.jpg",
-					},
-				},
-			},
-		},
-	}
-
-	desc := buildAlbumDesc(meta, nil)
-	if strings.Contains(desc, "Wrong Season") {
-		t.Fatalf("season pack album_desc included another season: %q", desc)
-	}
-	first := strings.Index(desc, "Example Episode One")
-	second := strings.Index(desc, "Example Episode Two")
-	if first < 0 || second < 0 || first > second {
-		t.Fatalf("season pack album_desc did not include sorted season episodes: %q", desc)
-	}
-	for _, value := range []string{
-		"[b]Episode Name:[/b] Example Episode One",
-		"[b]Episode image:[/b]\n[img=https://img.example/tvdb-episode-1.jpg]",
-		"[b]Episode Name:[/b] Example Episode Two",
-		"[b]Episode image:[/b]\n[img=https://img.example/tvdb-episode-2.jpg]",
-	} {
-		if !strings.Contains(desc, value) {
-			t.Fatalf("expected season pack album_desc to contain %q, got %q", value, desc)
-		}
-	}
-}
-
-func TestResolveBTNOriginalLanguageUsesTVDBThenIMDB(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ExternalMetadata: api.ExternalMetadata{
-			TVDB: &api.TVDBMetadata{OriginalLanguage: "jpn"},
-			IMDB: &api.IMDBMetadata{OriginalLanguage: "fra"},
-		},
-	}
-	if got := resolveBTNOriginalLanguage(meta); got != "jpn" {
-		t.Fatalf("expected TVDB language, got %q", got)
-	}
-	meta.ExternalMetadata.TVDB.OriginalLanguage = ""
-	if got := resolveBTNOriginalLanguage(meta); got != "fra" {
-		t.Fatalf("expected IMDb fallback language, got %q", got)
-	}
-	for _, value := range []string{"en", "eng", "English"} {
-		if !isBTNEnglishLanguage(value) {
-			t.Fatalf("expected %q to be treated as English", value)
-		}
-	}
-}
diff --git a/internal/trackers/impl/btn/upload.go b/internal/trackers/impl/btn/upload.go
deleted file mode 100644
index 55cf37e0..00000000
--- a/internal/trackers/impl/btn/upload.go
+++ /dev/null
@@ -1,2856 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package btn
-
-import (
-	"bytes"
-	"context"
-	"crypto/hmac"
-	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
-	"encoding/base32"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"html"
-	"io"
-	"net"
-	"net/http"
-	"net/http/cookiejar"
-	"net/netip"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	xhtml "golang.org/x/net/html"
-	"golang.org/x/text/runes"
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	btnDefaultBaseURL  = "https://backup.landof.tv"
-	btnUploadPath      = "/upload.php"
-	btnLoginPath       = "/login.php"
-	btnAPIRPCURL       = "https://api.broadcasthe.net/"
-	btnAPIJSONMaxBytes = 1024 * 1024
-	btnTorrentMaxBytes = 8 * 1024 * 1024
-)
-
-var (
-	btnInputPattern       = regexp.MustCompile(`(?is)<input[^>]*name=["']([^"']+)["'][^>]*value=["']([^"']*)["'][^>]*>`)
-	btnTextAreaPattern    = regexp.MustCompile(`(?is)<textarea[^>]*name=["']album_desc["'][^>]*>(.*?)</textarea>`)
-	btnSelectPattern      = regexp.MustCompile(`(?is)<select[^>]*name=["']([^"']+)["'][^>]*>(.*?)</select>`)
-	btnSuccessURLPattern  = regexp.MustCompile(`torrents\.php\?id=(\d+)(?:&torrentid=(\d+))?`)
-	btnHTMLURLAttrPattern = regexp.MustCompile(`(?is)\b(?:href|action)=["']([^"']+)["']`)
-	btnIMDBEpisodePattern = regexp.MustCompile(`(?i)(?:^|\bE|episode\s*)(\d{1,4})(?:\b|$)`)
-	// btnCountryMap maps normalized BTN country option labels and exact
-	// metadata-source country codes to BTN's country select values.
-	btnCountryMap = map[string]string{
-		"se": "1", "swe": "1", "sweden": "1",
-		"us": "2", "usa": "2", "united states": "2", "united states of america": "2",
-		"ru": "3", "rus": "3", "russia": "3", "russian federation": "3",
-		"fi": "4", "fin": "4", "finland": "4",
-		"ca": "5", "can": "5", "canada": "5",
-		"fr": "6", "fra": "6", "france": "6",
-		"de": "7", "deu": "7", "germany": "7",
-		"cn": "8", "chn": "8", "china": "8",
-		"it": "9", "ita": "9", "italy": "9",
-		"dk": "10", "dnk": "10", "denmark": "10",
-		"no": "11", "nor": "11", "norway": "11",
-		"gb": "12", "uk": "12", "gbr": "12", "united kingdom": "12",
-		"ie": "13", "irl": "13", "ireland": "13",
-		"pl": "14", "pol": "14", "poland": "14",
-		"nl": "15", "nld": "15", "netherlands": "15",
-		"be": "16", "bel": "16", "belgium": "16",
-		"jp": "17", "jpn": "17", "japan": "17",
-		"br": "18", "bra": "18", "brazil": "18",
-		"ar": "19", "arg": "19", "argentina": "19",
-		"au": "20", "aus": "20", "australia": "20",
-		"nz": "21", "nzl": "21", "new zealand": "21",
-		"es": "22", "esp": "22", "spain": "22",
-		"pt": "23", "prt": "23", "portugal": "23",
-		"mx": "24", "mex": "24", "mexico": "24",
-		"sg": "25", "sgp": "25", "singapore": "25",
-		"za": "26", "zaf": "26", "south africa": "26",
-		"kr": "27", "kor": "27", "south korea": "27",
-		"jm": "28", "jam": "28", "jamaica": "28",
-		"lu": "29", "lux": "29", "luxembourg": "29",
-		"hk": "30", "hkg": "30", "hong kong": "30",
-		"bz": "31", "blz": "31", "belize": "31",
-		"dz": "32", "dza": "32", "algeria": "32",
-		"ao": "33", "ago": "33", "angola": "33",
-		"at": "34", "aut": "34", "austria": "34",
-		"yu": "35", "yug": "35", "yugoslavia": "35",
-		"ws": "36", "wsm": "36", "western samoa": "36",
-		"my": "37", "mys": "37", "malaysia": "37",
-		"do": "38", "dom": "38", "dominican republic": "38",
-		"gr": "39", "grc": "39", "greece": "39",
-		"gt": "40", "gtm": "40", "guatemala": "40",
-		"il": "41", "isr": "41", "israel": "41",
-		"pk": "42", "pak": "42", "pakistan": "42",
-		"cz": "43", "cze": "43", "czech republic": "43", "czechia": "43",
-		"rs": "44", "srb": "44", "serbia": "44",
-		"sc": "45", "syc": "45", "seychelles": "45",
-		"tw": "46", "twn": "46", "taiwan": "46",
-		"pr": "47", "pri": "47", "puerto rico": "47",
-		"cl": "48", "chl": "48", "chile": "48",
-		"cu": "49", "cub": "49", "cuba": "49",
-		"cg": "50", "cog": "50", "congo": "50",
-		"af": "51", "afg": "51", "afghanistan": "51",
-		"tr": "52", "tur": "52", "turkey": "52",
-		"uz": "53", "uzb": "53", "uzbekistan": "53",
-		"ch": "54", "che": "54", "switzerland": "54",
-		"ki": "55", "kir": "55", "kiribati": "55",
-		"ph": "56", "phl": "56", "philippines": "56",
-		"bf": "57", "bfa": "57", "burkina faso": "57",
-		"ng": "58", "nga": "58", "nigeria": "58",
-		"is": "59", "isl": "59", "iceland": "59",
-		"nr": "60", "nru": "60", "nauru": "60",
-		"si": "61", "svn": "61", "slovenia": "61",
-		"al": "62", "alb": "62", "albania": "62",
-		"tm": "63", "tkm": "63", "turkmenistan": "63",
-		"ba": "64", "bih": "64", "bosnia herzegovina": "64", "bosnia and herzegovina": "64",
-		"ad": "65", "and": "65", "andorra": "65",
-		"lt": "66", "ltu": "66", "lithuania": "66",
-		"in": "67", "ind": "67", "india": "67",
-		"an": "68", "ant": "68", "netherlands antilles": "68",
-		"ua": "69", "ukr": "69", "ukraine": "69",
-		"ve": "70", "ven": "70", "venezuela": "70",
-		"hu": "71", "hun": "71", "hungary": "71",
-		"ro": "72", "rou": "72", "romania": "72",
-		"vu": "73", "vut": "73", "vanuatu": "73",
-		"vn": "74", "vnm": "74", "vietnam": "74",
-		"tt": "75", "tto": "75", "trinidad": "75", "trinidad and tobago": "75",
-		"hn": "76", "hnd": "76", "honduras": "76",
-		"kg": "77", "kgz": "77", "kyrgyzstan": "77",
-		"ec": "78", "ecu": "78", "ecuador": "78",
-		"bs": "79", "bhs": "79", "bahamas": "79",
-		"pe": "80", "per": "80", "peru": "80",
-		"kh": "81", "khm": "81", "cambodia": "81",
-		"bb": "82", "brb": "82", "barbados": "82",
-		"bd": "83", "bgd": "83", "bangladesh": "83",
-		"la": "84", "lao": "84", "laos": "84",
-		"uy": "85", "ury": "85", "uruguay": "85",
-		"ag": "86", "atg": "86", "antigua barbuda": "86", "antigua and barbuda": "86",
-		"py": "87", "pry": "87", "paraguay": "87",
-		"su": "88", "sun": "88", "soviet": "88", "soviet union": "88", "ussr": "88", "union of soviet socialist repu": "88",
-		"th": "89", "tha": "89", "thailand": "89",
-		"sn": "90", "sen": "90", "senegal": "90",
-		"tg": "91", "tgo": "91", "togo": "91",
-		"kp": "92", "prk": "92", "north korea": "92",
-		"hr": "93", "hrv": "93", "croatia": "93",
-		"ee": "94", "est": "94", "estonia": "94",
-		"co": "95", "col": "95", "colombia": "95",
-		"lb": "96", "lbn": "96", "lebanon": "96",
-		"lv": "97", "lva": "97", "latvia": "97",
-		"cr": "98", "cri": "98", "costa rica": "98",
-		"eg": "99", "egy": "99", "egypt": "99",
-		"bg": "100", "bgr": "100", "bulgaria": "100",
-		"isle de muerte": "101",
-		"fj":             "102", "fji": "102", "fiji": "102",
-		"mk": "103", "mkd": "103", "macedonia": "103",
-		"kw": "104", "kwt": "104", "kuwait": "104",
-		"lk": "105", "lka": "105", "sri lanka": "105",
-		"ir": "106", "irn": "106", "iran": "106",
-		"arab league": "107",
-		"sa":          "108", "sau": "108", "saudi arabia": "108",
-		"scotland": "109",
-		"sk":       "110", "svk": "110", "slovakia": "110",
-		"id": "111", "idn": "111", "indonesia": "111",
-		"wales": "112",
-		"bn":    "113", "brn": "113", "brunei": "113",
-	}
-)
-
-// ErrSubmitted2FARejected marks a BTN failure after a submitted manual 2FA code
-// reached the tracker and was rejected.
-var ErrSubmitted2FARejected = errors.New("trackers: BTN submitted 2FA rejected")
-
-var (
-	errBTNCookiesMissing          = errors.New("trackers: BTN cookies not configured")
-	errBTNSessionConfirmedInvalid = errors.New("trackers: BTN stored session confirmed invalid")
-)
-
-type uploadContext struct {
-	baseURL   string
-	uploadURL string
-	apiToken  string
-	apiURL    string
-	client    *http.Client
-}
-
-// btnNameNormalizationRule applies one ordered rewrite to the BTN scene name.
-type btnNameNormalizationRule struct {
-	pattern     *regexp.Regexp
-	replacement string
-}
-
-// btnNameNormalizationRules normalizes release-name tokens after whitespace and
-// DD+ cleanup. The order is significant: Atmos-specific compaction must happen
-// before generic audio channel joins, and dot collapse must run after character
-// replacement.
-var btnNameNormalizationRules = []btnNameNormalizationRule{
-	{pattern: regexp.MustCompile(`(?i)\.DDP\.(\d+(?:\.\d+)?)\.Atmos`), replacement: `.DDPA$1`},
-	{pattern: regexp.MustCompile(`(?i)\.TrueHD\.(\d+(?:\.\d+)?)\.Atmos`), replacement: `.TrueHDA$1`},
-	{pattern: regexp.MustCompile(`\.DDP\.(\d)`), replacement: `.DDP$1`},
-	{pattern: regexp.MustCompile(`\.DD\.(\d)`), replacement: `.DD$1`},
-	{pattern: regexp.MustCompile(`\.AC3\.(\d)`), replacement: `.AC3$1`},
-	{pattern: regexp.MustCompile(`\.DTS\.(\d)`), replacement: `.DTS$1`},
-	{pattern: regexp.MustCompile(`\.AAC\.(\d)`), replacement: `.AAC$1`},
-	{pattern: regexp.MustCompile(`\.FLAC\.(\d)`), replacement: `.FLAC$1`},
-	{pattern: regexp.MustCompile(`(?i)\.TrueHD\.(\d)`), replacement: `.TrueHD$1`},
-	{pattern: regexp.MustCompile(`(?i)\.PCM\.(\d)`), replacement: `.PCM$1`},
-	{pattern: regexp.MustCompile(`(?i)\.LPCM\.(\d)`), replacement: `.LPCM$1`},
-	{pattern: regexp.MustCompile(`[^a-zA-Z0-9.\-]`), replacement: `.`},
-	{pattern: regexp.MustCompile(`\.{2,}`), replacement: `.`},
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	if err := validateBTNRequest(req); err != nil {
-		return api.UploadSummary{}, err
-	}
-	if message, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
-		if req.Logger != nil {
-			req.Logger.Warnf("trackers: BTN %s", message)
-		}
-		return api.UploadSummary{}, err
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	uploadCtx, err := newUploadContext(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	client, err := ensureBTNUploadSession(ctx, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, uploadCtx)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	uploadCtx.client = client
-
-	if err := checkBTNSeasonPackReservation(ctx, uploadCtx, req); err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	data, err := prepareUploadData(ctx, req, uploadCtx)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	files := resolveBTNUploadFiles(req.Meta, torrentPath)
-	body, contentType, err := commonhttp.BuildMultipartPayload(data, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadCtx.uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BTN request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := uploadCtx.client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: BTN upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, "BTN")
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	groupID, torrentID, matched := btnUploadIDsFromText(finalURL)
-	torrentDownloaded := false
-	if !matched {
-		responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, 2048)
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: BTN read upload response: %w", err)
-		}
-		intermediate, handled, err := resolveBTNUploadIntermediatePage(ctx, uploadCtx.client, uploadCtx.baseURL, finalURL, responseBody)
-		if handled {
-			if err != nil {
-				if req.Logger != nil {
-					req.Logger.Warnf("trackers: BTN intermediate upload page fallback to API search: %s", commonhttp.RedactErrorDetail(err.Error()))
-				}
-				groupID = intermediate.groupID
-				selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
-				if err != nil {
-					return api.UploadSummary{}, err
-				}
-				torrentID = selectedID
-				if selectedGroupID != "" {
-					groupID = selectedGroupID
-				}
-				torrentDownloaded = true
-			} else {
-				groupID = intermediate.groupID
-				torrentID = intermediate.torrentID
-			}
-		} else {
-			groupID, torrentID, matched = btnUploadIDsFromText(string(responseBody))
-		}
-		if !matched && groupID == "" && torrentID == "" {
-			failurePath, _ := commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "BTN", "upload-failure", responsePreview, ".html")
-			if failurePath != "" {
-				return api.UploadSummary{}, fmt.Errorf("%w failure=%s", commonhttp.UploadHTTPErrorWithURL("BTN", resp.StatusCode, finalURL, responsePreview), failurePath)
-			}
-			return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("BTN", resp.StatusCode, finalURL, responsePreview)
-		}
-	}
-	torrentURL := buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
-
-	if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" && torrentID != "" && !torrentDownloaded {
-		if err := writeBTNTorrentArtifact(torrentPath, trackerTorrentPath, announceURL, torrentURL); err != nil {
-			return api.UploadSummary{}, err
-		}
-		torrentDownloaded = true
-	}
-
-	if torrentID != "" && !torrentDownloaded {
-		if err := downloadTrackerTorrent(ctx, uploadCtx.client, uploadCtx.baseURL, torrentID, trackerTorrentPath); err != nil {
-			if req.Logger != nil {
-				req.Logger.Warnf("trackers: BTN torrent download fallback to API search: %s", commonhttp.RedactErrorDetail(err.Error()))
-			}
-			selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
-			if err != nil {
-				return api.UploadSummary{}, err
-			}
-			torrentID = selectedID
-			if selectedGroupID != "" {
-				groupID = selectedGroupID
-			}
-			torrentURL = buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
-		}
-	} else if torrentID == "" {
-		selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		torrentID = selectedID
-		if selectedGroupID != "" {
-			groupID = selectedGroupID
-		}
-		torrentURL = buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
-	}
-
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "BTN",
-			TorrentID:   torrentID,
-			TorrentURL:  torrentURL,
-			DownloadURL: torrentURL,
-			TorrentPath: trackerTorrentPath,
-		}},
-	}, nil
-}
-
-// buildUploadDryRun returns a BTN preview entry with the exact payload that
-// would be submitted locally. TV payloads that would serialize missing
-// canonical season or episode metadata as zero are returned as blocked so the
-// operator sees the remediation before upload.
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	if err := validateBTNRequest(req); err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	uploadCtx, err := newUploadContext(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	if err := validateBTNDryRunUploadAuth(ctx, req, uploadCtx); err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	autofillPayload, uploadType := buildBTNAutofillPayload(req.Meta)
-	debugSections := make([]api.TrackerDryRunDebugSection, 0, 2)
-	if req.Meta.Options.Debug {
-		debugSections = append(debugSections, api.TrackerDryRunDebugSection{
-			Title:    "BTN autofill request",
-			Endpoint: uploadCtx.uploadURL,
-			Payload:  urlValuesToPayloadMap(autofillPayload),
-		})
-	}
-
-	payload := map[string]string{
-		"submit":       "true",
-		"type":         uploadType,
-		"scenename":    resolveUploadName(req.Meta),
-		"origin":       resolveOrigin(req.Meta),
-		"release_desc": resolveBTNReleaseDesc(req.Meta),
-		"tvdb":         "autofilled",
-	}
-	if resolveFastTorrent(req.TrackerConfig) {
-		payload["fasttorrent"] = "on"
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	message := "dry-run payload generated"
-	status := "ready"
-	if metadataMessage, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
-		message += "; " + metadataMessage
-		status = "blocked"
-	}
-	if req.Meta.Options.Debug && status == "ready" {
-		client, err := ensureBTNUploadSession(ctx, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, uploadCtx)
-		if err != nil {
-			return api.TrackerDryRunEntry{}, err
-		}
-		uploadCtx.client = client
-		fields, err := requestBTNAutofillFields(ctx, uploadCtx, autofillPayload, uploadType)
-		if err != nil {
-			return api.TrackerDryRunEntry{}, err
-		}
-		payload, err = buildBTNUploadPayload(req, fields)
-		if err != nil {
-			return api.TrackerDryRunEntry{}, err
-		}
-		message += "; BTN autofill debug completed"
-		debugSections = append(debugSections, api.TrackerDryRunDebugSection{
-			Title:    "BTN final upload payload after autofill",
-			Endpoint: uploadCtx.uploadURL,
-			Payload:  payload,
-			Files:    resolveBTNDryRunFiles(req.Meta, torrentPath),
-		})
-	}
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "BTN",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "btn",
-		Description:      payload["release_desc"],
-		Endpoint:         uploadCtx.uploadURL,
-		Payload:          payload,
-		Files:            resolveBTNDryRunFiles(req.Meta, torrentPath),
-		DebugSections:    debugSections,
-	}, nil
-}
-
-// validateBTNDryRunUploadAuth checks auth prerequisites needed before an upload
-// can authenticate. Stored cookies must pass the same upload-page session gate
-// as live upload; credential fallback remains local-only and does not log in or
-// persist cookies during dry-run.
-func validateBTNDryRunUploadAuth(ctx context.Context, req trackers.UploadRequest, uploadCtx uploadContext) error {
-	values, cookieErr := loadBTNCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if cookieErr == nil && len(values) > 0 {
-		client, err := newBTNClientWithCookies(uploadCtx.baseURL, values)
-		if err != nil {
-			return err
-		}
-		if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err == nil {
-			return nil
-		} else if !errors.Is(err, errBTNSessionConfirmedInvalid) {
-			return err
-		} else if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
-			return err
-		}
-	}
-	if cookieErr != nil && !errors.Is(cookieErr, errBTNCookiesMissing) {
-		return cookieErr
-	}
-	if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
-		return errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
-	}
-	return nil
-}
-
-func newUploadContext(ctx context.Context, req trackers.UploadRequest) (uploadContext, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return uploadContext{}, fmt.Errorf("trackers: BTN create cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 45 * time.Second, Jar: jar}
-	baseURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if baseURL == "" {
-		baseURL = btnDefaultBaseURL
-	}
-	uploadCtx := uploadContext{
-		baseURL:   baseURL,
-		uploadURL: baseURL + btnUploadPath,
-		apiToken:  config.ResolveBTNAPIToken(req.AppConfig),
-		apiURL:    resolveBTNAPIURL(req.TrackerConfig),
-		client:    client,
-	}
-	loadBTNCookiesIntoJar(ctx, client, req.AppConfig.MainSettings.DBPath, baseURL)
-	return uploadCtx, nil
-}
-
-// ensureBTNUploadSession validates imported BTN cookies before credential login.
-// Credential login cookies are persisted only after the refreshed client reaches
-// the upload page, so failed or incomplete logins do not replace stored auth.
-func ensureBTNUploadSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, uploadCtx uploadContext) (*http.Client, error) {
-	values, cookieErr := loadBTNCookies(ctx, dbPath)
-	if cookieErr == nil && len(values) > 0 {
-		if client, err := newBTNClientWithCookies(uploadCtx.baseURL, values); err == nil {
-			if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err == nil {
-				return client, nil
-			} else if !errors.Is(err, errBTNSessionConfirmedInvalid) {
-				return nil, err
-			}
-		}
-	}
-	if cookieErr != nil && !errors.Is(cookieErr, errBTNCookiesMissing) {
-		return nil, cookieErr
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
-	}
-	client, err := loginBTNSession(ctx, cfg, uploadCtx.baseURL, api.TrackerAuthLoginRequest{})
-	if err != nil {
-		return nil, err
-	}
-	if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err != nil {
-		return nil, err
-	}
-	if err := persistBTNCookies(ctx, dbPath, uploadCtx.baseURL, client.Jar); err != nil {
-		return nil, fmt.Errorf("trackers: BTN persist cookies after successful login: %w", err)
-	}
-	return client, nil
-}
-
-// ResolveSessionForTrackerAuth validates BTN stored cookies or logs in with
-// configured credentials. Credential login must produce reusable cookies before
-// refreshed cookies are persisted.
-func ResolveSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string) error {
-	return ResolveSessionForTrackerAuthLogin(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{})
-}
-
-// ResolveSessionForTrackerAuthLogin validates BTN stored cookies or logs in
-// with configured credentials. Refreshed cookies are persisted only after the
-// upload page confirms the session. Manual login.Code is preferred over
-// configured TOTP. Missing 2FA input preserves existing cookies; a rejected
-// submitted code returns [ErrSubmitted2FARejected] before persistence.
-func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
-	baseURL := strings.TrimRight(strings.TrimSpace(cfg.URL), "/")
-	if baseURL == "" {
-		baseURL = btnDefaultBaseURL
-	}
-	err := validateBTNStoredCookies(ctx, baseURL, dbPath)
-	if err == nil {
-		return nil
-	}
-	if !errors.Is(err, errBTNCookiesMissing) && !errors.Is(err, errBTNSessionConfirmedInvalid) {
-		return err
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		if errors.Is(err, errBTNSessionConfirmedInvalid) {
-			return err
-		}
-		return errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
-	}
-	client, err := loginBTNSession(ctx, cfg, baseURL, login)
-	if err != nil {
-		return err
-	}
-	if err := validateBTNClientSession(ctx, client, baseURL); err != nil {
-		if strings.TrimSpace(login.Code) != "" && errors.Is(err, errBTNSessionConfirmedInvalid) {
-			return fmt.Errorf("trackers: BTN submitted 2FA validation failed: %w", ErrSubmitted2FARejected)
-		}
-		return err
-	}
-	if err := persistBTNCookies(ctx, dbPath, baseURL, client.Jar); err != nil {
-		return fmt.Errorf("trackers: BTN persist cookies after successful login: %w", err)
-	}
-	return nil
-}
-
-// validateBTNStoredCookies checks persisted BTN cookies against the upload page.
-// Confirmed logged-out evidence is returned distinctly so tracker auth can delete
-// stale cookies; storage/decrypt failures and ambiguous remote/parser failures
-// preserve stored cookies and block credential login.
-func validateBTNStoredCookies(ctx context.Context, baseURL string, dbPath string) error {
-	values, err := loadBTNCookies(ctx, dbPath)
-	if err != nil {
-		return err
-	}
-	if len(values) == 0 {
-		return errBTNCookiesMissing
-	}
-	client, err := newBTNClientWithCookies(baseURL, values)
-	if err != nil {
-		return err
-	}
-	return validateBTNClientSession(ctx, client, baseURL)
-}
-
-// loginBTNSession performs the credential login step and leaves cookie
-// persistence to callers after they validate the resulting upload session.
-func loginBTNSession(ctx context.Context, cfg config.TrackerConfig, baseURL string, login api.TrackerAuthLoginRequest) (*http.Client, error) {
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, errors.New("trackers: BTN requires username/password")
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 45 * time.Second, Jar: jar}
-	values := url.Values{}
-	values.Set("username", strings.TrimSpace(cfg.Username))
-	values.Set("password", strings.TrimSpace(cfg.Password))
-	values.Set("keeplogged", "1")
-	if code, err := resolveBTN2FACode(cfg, login); err == nil && code != "" {
-		values.Set("codenumber", code)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, "/")+btnLoginPath, strings.NewReader(values.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN login request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", "upbrr")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN login request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, readErr := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
-	if readErr != nil {
-		return nil, fmt.Errorf("trackers: BTN read login response: %w", readErr)
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 400 {
-		if strings.TrimSpace(login.Code) != "" && resp.StatusCode == http.StatusForbidden {
-			return nil, fmt.Errorf("trackers: BTN login failed status=%d: %w", resp.StatusCode, ErrSubmitted2FARejected)
-		}
-		return nil, fmt.Errorf("trackers: BTN login failed status=%d", resp.StatusCode)
-	}
-	bodyText := string(body)
-	if btnLoginNeeds2FA(bodyText) {
-		if strings.TrimSpace(login.Code) != "" {
-			return nil, fmt.Errorf("trackers: BTN login failed: %w", ErrSubmitted2FARejected)
-		}
-		if _, err := resolveBTN2FACode(config.TrackerConfig{OTPURI: cfg.OTPURI}, api.TrackerAuthLoginRequest{}); err != nil {
-			return nil, fmt.Errorf("trackers: BTN 2FA required: %w", err)
-		}
-	}
-	if btnLoginFailed(bodyText) {
-		if strings.TrimSpace(login.Code) != "" {
-			return nil, fmt.Errorf("trackers: BTN login failed: %w", ErrSubmitted2FARejected)
-		}
-		return nil, errors.New("trackers: BTN login failed")
-	}
-	return client, nil
-}
-
-// validateBTNClientSession confirms the client can reach BTN's upload page.
-// It treats explicit login redirects and logged-out markers as invalid session
-// evidence while keeping layout misses and upstream failures transient.
-func validateBTNClientSession(ctx context.Context, client *http.Client, baseURL string) error {
-	if client == nil {
-		return errors.New("trackers: BTN session client missing")
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+btnUploadPath, nil)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN upload auth request build: %w", err)
-	}
-	req.Header.Set("User-Agent", "upbrr")
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN upload auth request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalPath := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalPath = strings.ToLower(resp.Request.URL.EscapedPath())
-	}
-	body, readErr := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
-	if readErr != nil {
-		return fmt.Errorf("trackers: BTN read upload auth response: %w", readErr)
-	}
-	bodyText := string(body)
-	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || strings.Contains(finalPath, "login") || btnLoggedOutPage(bodyText) {
-		return fmt.Errorf("%w: login required", errBTNSessionConfirmedInvalid)
-	}
-	if resp.StatusCode >= 500 {
-		return fmt.Errorf("trackers: BTN upload auth unavailable status=%d", resp.StatusCode)
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("trackers: BTN upload auth failed status=%d", resp.StatusCode)
-	}
-	if !btnLooksLikeUploadPage(bodyText) {
-		return errors.New("trackers: BTN upload auth page validation failed")
-	}
-	return nil
-}
-
-func prepareUploadData(ctx context.Context, req trackers.UploadRequest, uploadCtx uploadContext) (map[string]string, error) {
-	if _, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
-		return nil, err
-	}
-
-	autofillPayload, uploadType := buildBTNAutofillPayload(req.Meta)
-	fields, err := requestBTNAutofillFields(ctx, uploadCtx, autofillPayload, uploadType)
-	if err != nil {
-		return nil, err
-	}
-	return buildBTNUploadPayload(req, fields)
-}
-
-// buildBTNAutofillPayload returns the form fields for BTN's first upload.php
-// POST. TVDB-backed uploads submit the series id plus season or episode token;
-// scene-name autofill is used only when no TVDB series id is available.
-func buildBTNAutofillPayload(meta api.PreparedMetadata) (url.Values, string) {
-	autofillPayload := url.Values{}
-	uploadType := resolveUploadType(meta)
-	season, episode := resolveBTNTVSeasonEpisode(meta)
-	autofillPayload.Set("type", uploadType)
-	autofillPayload.Set("tvdb", "Get Info")
-
-	if meta.ExternalMetadata.TVDB != nil && meta.ExternalMetadata.TVDB.TVDBID > 0 {
-		autofillPayload.Set("scene_yesno", "No")
-		autofillPayload.Set("auto_series", strconv.Itoa(meta.ExternalMetadata.TVDB.TVDBID))
-
-		if uploadType == "Episode" {
-			autofillPayload.Set("auto_title", fmt.Sprintf("S%02dE%02d", season, episode))
-		} else {
-			autofillPayload.Set("auto_season", fmt.Sprintf("S%02d", season))
-		}
-	} else {
-		autofillPayload.Set("scene_yesno", "Yes")
-		autofillPayload.Set("autofill", resolveUploadName(meta))
-	}
-
-	return autofillPayload, uploadType
-}
-
-// requestBTNAutofillFields performs BTN's autofill POST and extracts the form
-// values returned for the final upload payload. A validation failure means BTN
-// did not return enough series/title data for the requested upload type.
-func requestBTNAutofillFields(ctx context.Context, uploadCtx uploadContext, autofillPayload url.Values, uploadType string) (map[string]string, error) {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadCtx.uploadURL, strings.NewReader(autofillPayload.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN autofill request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := uploadCtx.client.Do(httpReq)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN autofill request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, fmt.Errorf("trackers: BTN autofill failed status=%d", resp.StatusCode)
-	}
-	htmlPayload, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN read autofill response: %w", err)
-	}
-	fields := extractAutofillFields(string(htmlPayload))
-	if !validateAutofill(fields, uploadType) {
-		return nil, errors.New("trackers: BTN autofill validation failed")
-	}
-	return fields, nil
-}
-
-// buildBTNUploadPayload merges BTN autofill fields with local metadata for the
-// final upload form. BTN text fields such as album_desc are retained, release_desc
-// is populated only from MediaInfo text, and local MediaInfo-derived dropdown
-// mappings win when both sources provide a BTN-supported value.
-func buildBTNUploadPayload(req trackers.UploadRequest, fields map[string]string) (map[string]string, error) {
-	format := mapContainer(req.Meta, fields)
-	bitrate := mapCodec(req.Meta, fields)
-	media := mapSource(req.Meta, fields)
-	if format == "" || bitrate == "" || media == "" {
-		return nil, fmt.Errorf("trackers: BTN dropdown mapping failed format=%q bitrate=%q media=%q", format, bitrate, media)
-	}
-
-	title := metautil.FirstNonEmptyTrimmed(fields["title"])
-	if resolveUploadType(req.Meta) == "Season" && title != "" {
-		isNumeric := true
-		for _, r := range title {
-			if r < '0' || r > '9' {
-				isNumeric = false
-				break
-			}
-		}
-		if isNumeric {
-			title = "Season " + title
-		}
-	}
-
-	resolution := mapResolution(req.Meta, fields)
-	logBTNAutofillMismatch(req.Logger, "format", format, fields["format"])
-	logBTNAutofillMismatch(req.Logger, "bitrate", bitrate, fields["bitrate"])
-	logBTNAutofillMismatch(req.Logger, "media", media, fields["media"])
-	logBTNAutofillMismatch(req.Logger, "resolution", resolution, fields["resolution"])
-	payload := map[string]string{
-		"submit":       "true",
-		"type":         resolveUploadType(req.Meta),
-		"scenename":    applyBTNNameMapping(resolveUploadName(req.Meta), bitrate, media),
-		"seriesid":     metautil.FirstNonEmptyTrimmed(fields["seriesid"]),
-		"artist":       metautil.FirstNonEmptyTrimmed(fields["artist"]),
-		"title":        title,
-		"actors":       metautil.FirstNonEmptyTrimmed(fields["actors"]),
-		"origin":       resolveOrigin(req.Meta),
-		"year":         metautil.FirstNonEmptyTrimmed(fields["year"]),
-		"tags":         resolveBTNTags(req.Meta, fields),
-		"image":        resolveBTNImage(req.Meta, fields),
-		"album_desc":   buildAlbumDesc(req.Meta, fields),
-		"format":       format,
-		"bitrate":      bitrate,
-		"media":        media,
-		"resolution":   resolution,
-		"release_desc": resolveBTNReleaseDesc(req.Meta),
-		"tvdb":         "autofilled",
-	}
-	if resolveFastTorrent(req.TrackerConfig) {
-		payload["fasttorrent"] = "on"
-	}
-	if language := resolveBTNOriginalLanguage(req.Meta); language != "" && !isBTNEnglishLanguage(language) {
-		payload["foreign"] = "on"
-		if countryID := resolveCountryID(req.Meta); countryID != "" {
-			payload["country"] = countryID
-		}
-	}
-	clean := make(map[string]string, len(payload))
-	for key, value := range payload {
-		if key != "release_desc" && strings.TrimSpace(value) == "" {
-			continue
-		}
-		clean[key] = value
-	}
-	return clean, nil
-}
-
-// resolveBTNReleaseDesc returns the MediaInfo text BTN expects in release_desc.
-// Description overrides are intentionally ignored for this field.
-func resolveBTNReleaseDesc(meta api.PreparedMetadata) string {
-	return strings.TrimSpace(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath))
-}
-
-// urlValuesToPayloadMap flattens form values for debug display; BTN autofill
-// fields are single-valued, so later values are intentionally ignored.
-func urlValuesToPayloadMap(values url.Values) map[string]string {
-	out := make(map[string]string, len(values))
-	for key, value := range values {
-		if len(value) == 0 {
-			continue
-		}
-		out[key] = value[0]
-	}
-	return out
-}
-
-// logBTNAutofillMismatch records when BTN autofill selected a different
-// dropdown value than local metadata. The upload still uses metadata because
-// autofill runs before MediaInfo or final upload fields are submitted.
-func logBTNAutofillMismatch(logger api.Logger, field string, metadataValue string, autofillValue string) {
-	if logger == nil {
-		return
-	}
-	field = strings.TrimSpace(field)
-	metadataValue = strings.TrimSpace(metadataValue)
-	autofillValue = strings.TrimSpace(autofillValue)
-	if field == "" || metadataValue == "" || autofillValue == "" || metadataValue == autofillValue {
-		return
-	}
-	logger.Infof("trackers: BTN autofill %s mismatch metadata_%s=%q autofill_%s=%q decision=metadata", field, field, metadataValue, field, autofillValue)
-}
-
-// resolveBTNTags keeps BTN autofill genres when present and otherwise maps
-// TVDB then IMDb genres to BTN-supported tag labels.
-func resolveBTNTags(meta api.PreparedMetadata, fields map[string]string) string {
-	if tags := strings.TrimSpace(fields["tags"]); tags != "" {
-		return tags
-	}
-	if meta.ExternalMetadata.TVDB != nil {
-		if tags := mapBTNGenres(meta.ExternalMetadata.TVDB.Genres); tags != "" {
-			return tags
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return mapBTNGenres(meta.ExternalMetadata.IMDB.Genres)
-	}
-	return ""
-}
-
-// resolveBTNImage keeps BTN autofill poster data when present. Empty autofill
-// falls back through TVDB, IMDb, TVmaze, then TMDB poster metadata.
-func resolveBTNImage(meta api.PreparedMetadata, fields map[string]string) string {
-	if image := strings.TrimSpace(fields["image"]); image != "" {
-		return image
-	}
-	if meta.ExternalMetadata.TVDB != nil {
-		if poster := strings.TrimSpace(meta.ExternalMetadata.TVDB.Poster); poster != "" {
-			return poster
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		if poster := strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover); poster != "" {
-			return poster
-		}
-	}
-	if meta.ExternalMetadata.TVmaze != nil {
-		if poster := strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster); poster != "" {
-			return poster
-		}
-		if poster := strings.TrimSpace(meta.ExternalMetadata.TVmaze.PosterMedium); poster != "" {
-			return poster
-		}
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	}
-	return ""
-}
-
-// mapBTNGenres converts provider genre text to comma-separated BTN genre tags.
-// Unrecognized genres are omitted instead of being submitted as free-form tags.
-func mapBTNGenres(genres string) string {
-	normalized := normalizeBTNGenreText(genres)
-	if normalized == "" {
-		return ""
-	}
-	type genreAlias struct {
-		label   string
-		aliases []string
-	}
-	allowed := []genreAlias{
-		{label: "Action", aliases: []string{"action"}},
-		{label: "Adventure", aliases: []string{"adventure"}},
-		{label: "Animation", aliases: []string{"animation"}},
-		{label: "Anime", aliases: []string{"anime"}},
-		{label: "Awards Show", aliases: []string{"awards show"}},
-		{label: "Children", aliases: []string{"children", "kids"}},
-		{label: "Comedy", aliases: []string{"comedy"}},
-		{label: "Crime", aliases: []string{"crime"}},
-		{label: "Documentary", aliases: []string{"documentary"}},
-		{label: "Drama", aliases: []string{"drama"}},
-		{label: "Family", aliases: []string{"family"}},
-		{label: "Fantasy", aliases: []string{"fantasy"}},
-		{label: "Food", aliases: []string{"food"}},
-		{label: "Game Show", aliases: []string{"game show"}},
-		{label: "History", aliases: []string{"history"}},
-		{label: "Home and Garden", aliases: []string{"home and garden", "home garden"}},
-		{label: "Horror", aliases: []string{"horror"}},
-		{label: "Indie", aliases: []string{"indie"}},
-		{label: "Martial Arts", aliases: []string{"martial arts"}},
-		{label: "Mini-Series", aliases: []string{"mini series", "miniseries"}},
-		{label: "Musical", aliases: []string{"musical", "music"}},
-		{label: "Mystery", aliases: []string{"mystery"}},
-		{label: "News", aliases: []string{"news"}},
-		{label: "Podcast", aliases: []string{"podcast"}},
-		{label: "Reality", aliases: []string{"reality"}},
-		{label: "Romance", aliases: []string{"romance"}},
-		{label: "Science Fiction", aliases: []string{"science fiction", "sci fi", "scifi"}},
-		{label: "Soap", aliases: []string{"soap"}},
-		{label: "Sport", aliases: []string{"sport", "sports"}},
-		{label: "Suspense", aliases: []string{"suspense"}},
-		{label: "Talk Show", aliases: []string{"talk show"}},
-		{label: "Thriller", aliases: []string{"thriller"}},
-		{label: "Travel", aliases: []string{"travel"}},
-		{label: "War", aliases: []string{"war"}},
-		{label: "Western", aliases: []string{"western"}},
-	}
-	tags := make([]string, 0, len(allowed))
-	for _, genre := range allowed {
-		for _, alias := range genre.aliases {
-			if normalizedBTNGenreContains(normalized, alias) {
-				tags = append(tags, genre.label)
-				break
-			}
-		}
-	}
-	return strings.Join(tags, ", ")
-}
-
-// normalizeBTNGenreText lowercases and strips common separators so source
-// genre text and local aliases can be compared consistently.
-func normalizeBTNGenreText(value string) string {
-	replacer := strings.NewReplacer(
-		"&", " and ",
-		"/", " ",
-		";", " ",
-		":", " ",
-		".", " ",
-		",", " ",
-		"-", " ",
-		"_", " ",
-		"(", " ",
-		")", " ",
-	)
-	return strings.Join(strings.Fields(replacer.Replace(strings.ToLower(strings.TrimSpace(value)))), " ")
-}
-
-// normalizedBTNGenreContains reports whether a normalized genre list contains
-// an alias as a complete token sequence.
-func normalizedBTNGenreContains(normalized string, alias string) bool {
-	alias = normalizeBTNGenreText(alias)
-	return strings.Contains(" "+normalized+" ", " "+alias+" ")
-}
-
-// extractAutofillFields reads BTN's autofilled upload form into the field map
-// consumed by final payload construction. Input values, selected dropdown
-// values, and the album_desc textarea are normalized to lower-case field names.
-func extractAutofillFields(htmlRaw string) map[string]string {
-	fields := map[string]string{}
-	for _, match := range btnInputPattern.FindAllStringSubmatch(htmlRaw, -1) {
-		if len(match) < 3 {
-			continue
-		}
-		fields[strings.ToLower(strings.TrimSpace(match[1]))] = html.UnescapeString(strings.TrimSpace(match[2]))
-	}
-	if match := btnTextAreaPattern.FindStringSubmatch(htmlRaw); len(match) > 1 {
-		fields["album_desc"] = html.UnescapeString(strings.TrimSpace(stripHTML(match[1])))
-	}
-	for _, selectMatch := range btnSelectPattern.FindAllStringSubmatch(htmlRaw, -1) {
-		if len(selectMatch) < 3 {
-			continue
-		}
-		name := strings.ToLower(strings.TrimSpace(selectMatch[1]))
-		body := selectMatch[2]
-		if value := selectedBTNAutofillOptionValue(body); value != "" {
-			fields[name] = value
-		}
-	}
-	return fields
-}
-
-// selectedBTNAutofillOptionValue returns the selected option value regardless
-// of attribute order, falling back to the first option value when no option is
-// marked selected.
-func selectedBTNAutofillOptionValue(body string) string {
-	tokenizer := xhtml.NewTokenizer(strings.NewReader(body))
-	firstValue := ""
-	for {
-		switch tokenizer.Next() {
-		case xhtml.ErrorToken:
-			return firstValue
-		case xhtml.StartTagToken, xhtml.SelfClosingTagToken:
-			token := tokenizer.Token()
-			if !strings.EqualFold(token.Data, "option") {
-				continue
-			}
-			value := ""
-			selected := false
-			for _, attr := range token.Attr {
-				switch {
-				case strings.EqualFold(attr.Key, "value"):
-					value = html.UnescapeString(strings.TrimSpace(attr.Val))
-				case strings.EqualFold(attr.Key, "selected"):
-					selected = true
-				}
-			}
-			if value == "" {
-				continue
-			}
-			if firstValue == "" {
-				firstValue = value
-			}
-			if selected {
-				return value
-			}
-		case xhtml.TextToken, xhtml.EndTagToken, xhtml.CommentToken, xhtml.DoctypeToken:
-			continue
-		}
-	}
-}
-
-// validateAutofill reports whether BTN returned the minimum autofill fields
-// needed for the requested upload type. Episodes require a title; season packs
-// only require a series artist.
-func validateAutofill(fields map[string]string, uploadType string) bool {
-	artist := strings.TrimSpace(fields["artist"])
-	title := strings.TrimSpace(fields["title"])
-	if artist == "" {
-		return false
-	}
-	if uploadType == "Episode" && title == "" {
-		return false
-	}
-	if strings.EqualFold(artist, "autofill fail") || strings.EqualFold(title, "autofill fail") {
-		return false
-	}
-	return true
-}
-
-// preferredBTNTVDBEpisodeTitle returns TVDB's English episode title when it is
-// available, falling back to the original-language title.
-func preferredBTNTVDBEpisodeTitle(tvdb *api.TVDBMetadata) string {
-	if tvdb == nil {
-		return ""
-	}
-	return metautil.FirstNonEmptyTrimmed(strings.TrimSpace(tvdb.EpisodeNameEnglish), strings.TrimSpace(tvdb.EpisodeName))
-}
-
-// preferredBTNIMDBEpisodeTitle returns the selected IMDb episode title when an
-// episode-specific IMDb entry can be matched to the upload metadata.
-func preferredBTNIMDBEpisodeTitle(meta api.PreparedMetadata) string {
-	if episode := preferredBTNIMDBEpisode(meta); episode != nil {
-		return strings.TrimSpace(episode.Title)
-	}
-	return ""
-}
-
-// preferredBTNTVDBOverview returns TVDB episode overview text before series
-// overview text, using English translations before original-language values.
-func preferredBTNTVDBOverview(tvdb *api.TVDBMetadata) string {
-	if tvdb == nil {
-		return ""
-	}
-	return metautil.FirstNonEmptyTrimmed(
-		strings.TrimSpace(tvdb.EpisodeOverviewEnglish),
-		strings.TrimSpace(tvdb.EpisodeOverview),
-		strings.TrimSpace(tvdb.OverviewEnglish),
-		strings.TrimSpace(tvdb.Overview),
-	)
-}
-
-// preferredBTNIMDBOverview returns IMDb plot text when TVDB overview data is
-// unavailable for the BTN description block.
-func preferredBTNIMDBOverview(imdb *api.IMDBMetadata) string {
-	if imdb == nil {
-		return ""
-	}
-	return strings.TrimSpace(imdb.Plot)
-}
-
-// buildAlbumDesc keeps BTN's autofilled album_desc when available. If BTN did
-// not return one, TV uploads fall back to BBCode episode blocks from TVDB or
-// provider/local episode metadata.
-func buildAlbumDesc(meta api.PreparedMetadata, fields map[string]string) string {
-	if desc := metautil.FirstNonEmptyTrimmed(fields["album_desc"]); desc != "" {
-		return desc
-	}
-	if !strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") {
-		return ""
-	}
-	if desc := buildTVDBAlbumDesc(meta); desc != "" {
-		return desc
-	}
-	tvdb := meta.ExternalMetadata.TVDB
-	overview := metautil.FirstNonEmptyTrimmed(preferredBTNTVDBOverview(tvdb), preferredBTNIMDBOverview(meta.ExternalMetadata.IMDB), strings.TrimSpace(meta.EpisodeOverview))
-	aired := metautil.FirstNonEmptyTrimmed(btnTVDBEpisodeAired(tvdb), btnIMDBEpisodeAired(meta), strings.TrimSpace(meta.TVDBAiredDate), strings.TrimSpace(meta.DailyEpisodeDate), "TBA")
-	season, episode := resolveBTNTVSeasonEpisode(meta)
-	episodeTitle := metautil.FirstNonEmptyTrimmed(preferredBTNTVDBEpisodeTitle(tvdb), preferredBTNIMDBEpisodeTitle(meta), strings.TrimSpace(meta.EpisodeTitle), "TBA")
-	return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{{
-		SeasonNumber:    season,
-		EpisodeNumber:   episode,
-		EpisodeName:     episodeTitle,
-		EpisodeOverview: overview,
-		EpisodeAired:    aired,
-	}})
-}
-
-// buildTVDBAlbumDesc builds BTN album_desc from TVDB data only. Episode uploads
-// use the selected episode; season-pack uploads use every fetched episode in
-// the selected season.
-func buildTVDBAlbumDesc(meta api.PreparedMetadata) string {
-	tvdb := meta.ExternalMetadata.TVDB
-	if tvdb == nil {
-		return ""
-	}
-	season, episode := resolveBTNTVSeasonEpisode(meta)
-	if resolveUploadType(meta) == "Season" {
-		episodes := make([]api.TVDBEpisodeMetadata, 0, len(tvdb.Episodes))
-		for _, candidate := range tvdb.Episodes {
-			if candidate.SeasonNumber == season {
-				episodes = append(episodes, candidate)
-			}
-		}
-		sort.SliceStable(episodes, func(i, j int) bool {
-			return episodes[i].EpisodeNumber < episodes[j].EpisodeNumber
-		})
-		return formatBTNEpisodeAlbumDesc(episodes)
-	}
-	for _, candidate := range tvdb.Episodes {
-		if candidate.SeasonNumber == season && candidate.EpisodeNumber == episode {
-			return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{candidate})
-		}
-	}
-	if tvdb.EpisodeSeason > 0 || tvdb.EpisodeNumber > 0 || strings.TrimSpace(tvdb.EpisodeName) != "" || strings.TrimSpace(tvdb.EpisodeOverview) != "" {
-		return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{{
-			SeasonNumber:           tvdb.EpisodeSeason,
-			EpisodeNumber:          tvdb.EpisodeNumber,
-			EpisodeName:            tvdb.EpisodeName,
-			EpisodeNameEnglish:     tvdb.EpisodeNameEnglish,
-			EpisodeOverview:        tvdb.EpisodeOverview,
-			EpisodeOverviewEnglish: tvdb.EpisodeOverviewEnglish,
-			EpisodeAired:           tvdb.EpisodeAired,
-			EpisodeImage:           tvdb.EpisodeImage,
-		}})
-	}
-	return ""
-}
-
-// formatBTNEpisodeAlbumDesc renders each episode as the BBCode block expected
-// by BTN's album_desc field. Empty input returns an empty string.
-func formatBTNEpisodeAlbumDesc(episodes []api.TVDBEpisodeMetadata) string {
-	blocks := make([]string, 0, len(episodes))
-	for _, episode := range episodes {
-		title := metautil.FirstNonEmptyTrimmed(episode.EpisodeNameEnglish, episode.EpisodeName, "TBA")
-		overview := metautil.FirstNonEmptyTrimmed(episode.EpisodeOverviewEnglish, episode.EpisodeOverview)
-		aired := metautil.FirstNonEmptyTrimmed(episode.EpisodeAired, "TBA")
-		var block strings.Builder
-		block.WriteString("[b]Episode Name:[/b] ")
-		block.WriteString(title)
-		block.WriteString("\n[b]Season:[/b] ")
-		block.WriteString(strconv.Itoa(episode.SeasonNumber))
-		block.WriteString("\n[b]Episode:[/b] ")
-		block.WriteString(strconv.Itoa(episode.EpisodeNumber))
-		block.WriteString("\n[b]Aired:[/b] ")
-		block.WriteString(aired)
-		block.WriteString("\n\n[b]Episode overview:[/b]\n")
-		block.WriteString(overview)
-		if image := strings.TrimSpace(episode.EpisodeImage); image != "" {
-			block.WriteString("\n\n[b]Episode image:[/b]\n[img=")
-			block.WriteString(image)
-			block.WriteString("]")
-		}
-		blocks = append(blocks, strings.TrimSpace(block.String()))
-	}
-	return strings.Join(blocks, "\n\n")
-}
-
-// btnTVDBEpisodeAired returns the TVDB episode air date used in BTN-generated
-// description text. An empty value leaves metadata date fallbacks in control.
-func btnTVDBEpisodeAired(tvdb *api.TVDBMetadata) string {
-	if tvdb == nil {
-		return ""
-	}
-	return strings.TrimSpace(tvdb.EpisodeAired)
-}
-
-// btnIMDBEpisodeAired returns the selected IMDb episode release date in the
-// most specific YYYY[-MM[-DD]] form available.
-func btnIMDBEpisodeAired(meta api.PreparedMetadata) string {
-	episode := preferredBTNIMDBEpisode(meta)
-	if episode == nil || episode.ReleaseDate.Year <= 0 {
-		return ""
-	}
-	if episode.ReleaseDate.Month <= 0 {
-		return strconv.Itoa(episode.ReleaseDate.Year)
-	}
-	if episode.ReleaseDate.Day <= 0 {
-		return fmt.Sprintf("%04d-%02d", episode.ReleaseDate.Year, episode.ReleaseDate.Month)
-	}
-	return fmt.Sprintf("%04d-%02d-%02d", episode.ReleaseDate.Year, episode.ReleaseDate.Month, episode.ReleaseDate.Day)
-}
-
-// preferredBTNIMDBEpisode returns the IMDb episode entry for this upload when
-// the canonical season and episode identify one, or the sole available IMDb
-// episode when the metadata payload already represents a single episode.
-func preferredBTNIMDBEpisode(meta api.PreparedMetadata) *api.IMDBEpisode {
-	if meta.ExternalMetadata.IMDB == nil || len(meta.ExternalMetadata.IMDB.Episodes) == 0 {
-		return nil
-	}
-	episodes := meta.ExternalMetadata.IMDB.Episodes
-	season, episode := meta.CanonicalSeasonEpisode()
-	if season > 0 && episode > 0 {
-		for i := range episodes {
-			if episodes[i].Season != season {
-				continue
-			}
-			if btnIMDBEpisodeNumber(episodes[i].EpisodeText) == episode {
-				return &episodes[i]
-			}
-		}
-	}
-	if len(episodes) == 1 {
-		return &episodes[0]
-	}
-	return nil
-}
-
-// btnIMDBEpisodeNumber parses IMDb episode text such as "7", "E07", or
-// "Episode 7" into the numeric episode value BTN expects.
-func btnIMDBEpisodeNumber(value string) int {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return 0
-	}
-	if parsed, err := strconv.Atoi(value); err == nil {
-		return parsed
-	}
-	matches := btnIMDBEpisodePattern.FindStringSubmatch(value)
-	if len(matches) < 2 {
-		return 0
-	}
-	parsed, err := strconv.Atoi(matches[1])
-	if err != nil {
-		return 0
-	}
-	return parsed
-}
-
-// validateBTNTVPayloadMetadata returns the shared BTN TV metadata block reason
-// used by live upload, autofill, and dry-run when canonical season or episode
-// data is missing.
-func validateBTNTVPayloadMetadata(meta api.PreparedMetadata) (string, error) {
-	message := btnTVPayloadMetadataMessage(meta)
-	if message == "" {
-		return "", nil
-	}
-	return message, errors.New("trackers: BTN " + message)
-}
-
-func resolveUploadType(meta api.PreparedMetadata) string {
-	if meta.TVPack {
-		return "Season"
-	}
-	_, episode := resolveBTNTVSeasonEpisode(meta)
-	if episode > 0 {
-		return "Episode"
-	}
-	return "Season"
-}
-
-// resolveBTNTVSeasonEpisode returns the season and episode numbers BTN should
-// use for generated request and description fields. TVDB episode numbers win
-// over IMDb episode data, then metadata ints; missing values fall back
-// independently.
-func resolveBTNTVSeasonEpisode(meta api.PreparedMetadata) (int, int) {
-	season, episode := meta.CanonicalSeasonEpisode()
-	tvdb := meta.ExternalMetadata.TVDB
-	imdbEpisode := preferredBTNIMDBEpisode(meta)
-	if tvdb != nil && tvdb.EpisodeSeason > 0 {
-		season = meta.ExternalMetadata.TVDB.EpisodeSeason
-	} else if imdbEpisode != nil && imdbEpisode.Season > 0 {
-		season = imdbEpisode.Season
-	}
-	if tvdb != nil && tvdb.EpisodeNumber > 0 {
-		episode = meta.ExternalMetadata.TVDB.EpisodeNumber
-	} else if imdbEpisode != nil {
-		if imdbEpisodeNumber := btnIMDBEpisodeNumber(imdbEpisode.EpisodeText); imdbEpisodeNumber > 0 {
-			episode = imdbEpisodeNumber
-		}
-	}
-	return season, episode
-}
-
-// btnTVPayloadMetadataMessage explains when BTN cannot build TV season or
-// episode fields because canonical metadata is absent. Parsed release values are
-// reported only as ignored signals, and the message includes the operator action
-// required by blocked dry-run entries.
-func btnTVPayloadMetadataMessage(meta api.PreparedMetadata) string {
-	if !strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") {
-		return ""
-	}
-	missing := make([]string, 0, 2)
-	ignored := make([]string, 0, 2)
-	season, episode := resolveBTNTVSeasonEpisode(meta)
-	if season <= 0 {
-		missing = append(missing, "season")
-		if meta.Release.Season > 0 {
-			ignored = append(ignored, "season")
-		}
-	}
-	if episode <= 0 && !meta.TVPack {
-		missing = append(missing, "episode")
-		if meta.Release.Episode > 0 {
-			ignored = append(ignored, "episode")
-		}
-	}
-	if len(missing) == 0 {
-		return ""
-	}
-	message := "canonical TV " + strings.Join(missing, "/") + " missing; BTN upload requires TVDB or metadata season/episode ints"
-	if len(ignored) > 0 {
-		message += " and ignores parsed " + strings.Join(ignored, "/") + " fallback"
-	}
-	message += "; refresh metadata or correct canonical season/episode before upload"
-	return message
-}
-
-// resolveOrigin derives the origin from
-// prepared scene and season-pack metadata, group tag and username
-func resolveOrigin(meta api.PreparedMetadata) string {
-	group := strings.TrimSpace(meta.Release.Group)
-	if metadata.DetectSeasonPackGroupTags(meta).Mixed {
-		return "Mixed"
-	}
-	if isBTNSceneRelease(meta) {
-		return "Scene"
-	}
-	if group != "" && isNoGroupTag(group) || isBTNInternalGroup(meta) {
-		return "None"
-	}
-	return "P2P"
-}
-
-// stripEpisodeTitle removes generated episode-title text from BTN upload names
-// unless the original filename already carried the same token sequence.
-func stripEpisodeTitle(name string, episodeTitle string, filename string) string {
-	if episodeTitle == "" || name == "" {
-		return name
-	}
-	if metautil.ReleaseNameContainsEpisodeTitle(filename, episodeTitle) {
-		return name
-	}
-	return metautil.RemoveEpisodeTitleFromReleaseName(name, episodeTitle)
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	var name string
-	if n := strings.TrimSpace(meta.ReleaseName); n != "" {
-		name = n
-	} else if n := strings.TrimSpace(meta.ReleaseNameNoTag); n != "" {
-		name = n
-	} else if n := strings.TrimSpace(meta.Filename); n != "" {
-		name = n
-	} else {
-		name = pathutil.Base(meta.SourcePath)
-	}
-	name = stripEpisodeTitle(name, meta.EpisodeTitle, btnEpisodeTitleFilename(meta))
-	name = cleanAndNormalizeBTNName(name)
-	return applyBTNNoGroupSuffix(name, meta)
-}
-
-// btnEpisodeTitleFilename returns the original filename text used to decide
-// whether BTN should preserve an episode title in the upload name.
-func btnEpisodeTitleFilename(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(meta.Filename, pathutil.Base(meta.SourcePath))
-}
-
-// applyBTNNoGroupSuffix preserves a valid prepared group tag for no-tag names
-// and falls back to BTN's NOGRP marker when no usable tag is available.
-func applyBTNNoGroupSuffix(name string, meta api.PreparedMetadata) string {
-	tag := strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-"))
-
-	if tag != "" && !isNoGroupTag(tag) {
-		if selectedBTNReleaseNameNoTag(name, meta) || !hasBTNGroupSuffix(name) {
-			return strings.TrimRight(name, ".-") + "-" + tag
-		}
-		return name
-	}
-
-	// Preserve an existing release-name suffix when parsing did not provide a
-	// group tag; only known placeholder suffixes should be normalized below.
-	if tag == "" && hasBTNGroupSuffix(name) && !hasBTNNoGroupSuffix(name) {
-		return name
-	}
-
-	noGroupPattern := regexp.MustCompile(`(?i)-(nogrp|nogroup|unknown|unk)$`)
-	normalizedName := noGroupPattern.ReplaceAllString(name, "")
-	normalizedName = strings.TrimRight(normalizedName, ".-")
-
-	return normalizedName + "-NOGRP"
-}
-
-// selectedBTNReleaseNameNoTag reports whether name is the normalized
-// ReleaseNameNoTag value chosen by resolveUploadName.
-func selectedBTNReleaseNameNoTag(name string, meta api.PreparedMetadata) bool {
-	if strings.TrimSpace(meta.ReleaseName) != "" || strings.TrimSpace(meta.ReleaseNameNoTag) == "" {
-		return false
-	}
-	candidate := stripEpisodeTitle(strings.TrimSpace(meta.ReleaseNameNoTag), meta.EpisodeTitle, btnEpisodeTitleFilename(meta))
-	candidate = cleanAndNormalizeBTNName(candidate)
-	return strings.TrimSpace(name) == candidate
-}
-
-// hasBTNGroupSuffix reports whether name already ends with a hyphenated BTN
-// group suffix.
-func hasBTNGroupSuffix(name string) bool {
-	return regexp.MustCompile(`-[^-.\s]+$`).MatchString(strings.TrimSpace(name))
-}
-
-// hasBTNNoGroupSuffix reports whether name ends with a placeholder group suffix
-// that BTN should normalize to NOGRP.
-func hasBTNNoGroupSuffix(name string) bool {
-	return regexp.MustCompile(`(?i)-(nogrp|nogroup|unknown|unk)$`).MatchString(strings.TrimSpace(name))
-}
-
-func isNoGroupTag(tag string) bool {
-	value := strings.ToLower(strings.TrimSpace(tag))
-	switch value {
-	case "nogrp", "nogroup", "unknown", "unk":
-		return true
-	default:
-		return false
-	}
-}
-
-func removeDiacritics(s string) string {
-	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-	result, _, _ := transform.String(t, s)
-	return result
-}
-
-// cleanAndNormalizeBTNName converts prepared release names into BTN scene-name
-// syntax. It removes diacritics, uses dots as token separators, compacts known
-// audio channel tokens, and keeps hyphens for group tags.
-func cleanAndNormalizeBTNName(value string) string {
-	// 0. Remove diacritics
-	value = removeDiacritics(value)
-
-	// 1. Dot normalization (spaces to dots, collapse dots)
-	value = strings.Join(strings.Fields(value), " ")
-	value = strings.ReplaceAll(value, " ", ".")
-
-	// 2. Replace plus in DD+
-	value = strings.ReplaceAll(value, "DD+", "DDP")
-
-	for _, rule := range btnNameNormalizationRules {
-		value = rule.pattern.ReplaceAllString(value, rule.replacement)
-	}
-
-	return strings.TrimSpace(value)
-}
-
-func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	candidates := []string{strings.TrimSpace(meta.TorrentPath), strings.TrimSpace(meta.ClientTorrentPath), strings.TrimSpace(meta.SourcePath)}
-	for _, candidate := range candidates {
-		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
-			continue
-		}
-		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
-			return candidate, nil
-		}
-	}
-	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
-		tmpRoot, err := db.Subdir(dbPath, "tmp")
-		if err == nil {
-			tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-			if err == nil {
-				guessed := filepath.Join(tmpDir, base+".torrent")
-				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
-					return guessed, nil
-				}
-			}
-		}
-	}
-	return "", errors.New("trackers: BTN torrent file not found")
-}
-
-// resolveBTNUploadFiles returns the multipart file parts BTN accepts for an
-// upload. Scene NFOs are attached only when scene metadata confirms the release
-// and the prepared NFO file still exists.
-func resolveBTNUploadFiles(meta api.PreparedMetadata, torrentPath string) []commonhttp.FileField {
-	files := []commonhttp.FileField{{
-		FieldName: "file_input",
-		Path:      torrentPath,
-		FileName:  "torrent.torrent",
-	}}
-	if nfoPath := resolveBTNSceneNFOPath(meta); nfoPath != "" {
-		files = append(files, commonhttp.FileField{
-			FieldName: "nfo",
-			Path:      nfoPath,
-			FileName:  filepath.Base(nfoPath),
-		})
-	}
-	return files
-}
-
-// resolveBTNDryRunFiles mirrors the upload file parts without reading file
-// content so previews show whether BTN will receive an NFO.
-func resolveBTNDryRunFiles(meta api.PreparedMetadata, torrentPath string) []api.TrackerDryRunFile {
-	files := []api.TrackerDryRunFile{{
-		Field:   "file_input",
-		Path:    torrentPath,
-		Present: strings.TrimSpace(torrentPath) != "",
-	}}
-	if nfoPath := resolveBTNSceneNFOPath(meta); nfoPath != "" {
-		files = append(files, api.TrackerDryRunFile{Field: "nfo", Path: nfoPath, Present: true})
-	}
-	return files
-}
-
-func resolveBTNSceneNFOPath(meta api.PreparedMetadata) string {
-	if !isBTNSceneRelease(meta) {
-		return ""
-	}
-	nfoPath := strings.TrimSpace(meta.SceneNFOPath)
-	if nfoPath == "" {
-		return ""
-	}
-	if info, err := os.Stat(nfoPath); err == nil && !info.IsDir() {
-		return nfoPath
-	}
-	return ""
-}
-
-func isBTNSceneRelease(meta api.PreparedMetadata) bool {
-	return meta.Scene || strings.TrimSpace(meta.SceneName) != ""
-}
-
-func resolveTrackerTorrentPath(meta api.PreparedMetadata, dbPath string, tracker string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return "", errors.New("trackers: BTN tracker torrent path requires db path and source path")
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: BTN tmp root: %w", err)
-	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BTN tmp release dir: %w", err)
-	}
-	name := strings.ToLower(strings.TrimSpace(tracker))
-	if name == "" {
-		name = "tracker"
-	}
-	return filepath.Join(tmpDir, base+"."+name+".torrent"), nil
-}
-
-// writeBTNTorrentArtifact rewrites the uploaded torrent with the configured BTN
-// announce URL once the canonical torrent URL is known. A successful write lets
-// upload skip downloading BTN's generated torrent file.
-func writeBTNTorrentArtifact(sourcePath string, outputPath string, announceURL string, torrentURL string) error {
-	if err := trackers.WritePersonalizedTorrent(sourcePath, outputPath, announceURL, torrentURL, "BTN"); err != nil {
-		return fmt.Errorf("trackers: BTN write torrent artifact: %w", err)
-	}
-	return nil
-}
-
-// downloadTrackerTorrent fetches BTN's generated torrent file for uploads that
-// do not have a configured announce URL. Non-torrent responses are rejected so
-// callers can fall back to API resolution.
-func downloadTrackerTorrent(ctx context.Context, client *http.Client, baseURL string, torrentID string, outputPath string) error {
-	if strings.TrimSpace(torrentID) == "" {
-		return errors.New("trackers: BTN torrent_id missing")
-	}
-	downloadURL := strings.TrimRight(baseURL, "/") + "/torrents.php?action=download&id=" + url.QueryEscape(strings.TrimSpace(torrentID))
-	return downloadBTNTorrentURL(ctx, client, downloadURL, outputPath)
-}
-
-// downloadBTNTorrentURL fetches a BTN torrent download URL and writes only a
-// bencoded torrent payload to outputPath.
-func downloadBTNTorrentURL(ctx context.Context, client *http.Client, downloadURL string, outputPath string) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN torrent download request build: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN torrent download request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("status %d", resp.StatusCode)
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 8*1024*1024))
-	if err != nil {
-		return fmt.Errorf("trackers: BTN read torrent response: %w", err)
-	}
-	if len(body) == 0 || body[0] != 'd' {
-		return errors.New("not a torrent payload")
-	}
-	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
-		return fmt.Errorf("trackers: BTN create torrent output dir: %w", err)
-	}
-	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
-		return fmt.Errorf("trackers: BTN write torrent output: %w", err)
-	}
-	return nil
-}
-
-type btnUploadIntermediateResult struct {
-	groupID   string
-	torrentID string
-}
-
-// resolveBTNUploadIntermediatePage handles BTN's post-upload warning page that
-// requires continuing to the canonical torrent page before the final torrent id
-// is available. It returns handled=false for ordinary upload responses.
-func resolveBTNUploadIntermediatePage(ctx context.Context, client *http.Client, baseURL string, currentURL string, body []byte) (btnUploadIntermediateResult, bool, error) {
-	if !isBTNUploadIntermediatePage(body) {
-		return btnUploadIntermediateResult{}, false, nil
-	}
-
-	result := btnUploadIntermediateResult{}
-	detailURL, detailGroupID, detailTorrentID, ok := findBTNUploadDetailURL(baseURL, currentURL, body)
-	canonicalTorrentID := false
-	if ok {
-		result.groupID = detailGroupID
-		if detailTorrentID != "" {
-			result.torrentID = detailTorrentID
-			canonicalTorrentID = true
-		}
-	}
-
-	if !ok {
-		return result, true, errors.New("trackers: BTN intermediate page missing torrent detail link")
-	}
-	detailBody, detailFinalURL, err := fetchBTNTorrentDetailPage(ctx, client, detailURL)
-	if err != nil {
-		return result, true, err
-	}
-	if groupID, torrentID, matched := btnUploadIDsFromText(detailFinalURL); matched {
-		result.groupID = groupID
-		if torrentID != "" {
-			result.torrentID = torrentID
-			return result, true, nil
-		}
-	}
-	if groupID, torrentID, matched := btnUploadIDsFromText(string(detailBody)); matched {
-		result.groupID = groupID
-		if torrentID != "" {
-			result.torrentID = torrentID
-			return result, true, nil
-		}
-	}
-	if result.groupID == "" || !canonicalTorrentID {
-		return result, true, errors.New("trackers: BTN intermediate detail page missing canonical torrent id")
-	}
-	return result, true, nil
-}
-
-// isBTNUploadIntermediatePage detects BTN's warning page that appears after a
-// successful upload before the user has downloaded the generated torrent file.
-func isBTNUploadIntermediatePage(body []byte) bool {
-	normalized := strings.ToLower(html.UnescapeString(string(body)))
-	return strings.Contains(normalized, "download the torrent file") ||
-		strings.Contains(normalized, "need to download the torrent")
-}
-
-// findBTNUploadDetailURL extracts the same-origin canonical torrent page URL
-// from an intermediate BTN upload page.
-func findBTNUploadDetailURL(baseURL string, currentURL string, body []byte) (string, string, string, bool) {
-	for _, raw := range btnHTMLURLAttrPattern.FindAllStringSubmatch(string(body), -1) {
-		if len(raw) < 2 {
-			continue
-		}
-		candidate, ok := resolveBTNSameOriginURL(baseURL, currentURL, raw[1])
-		if !ok || !strings.EqualFold(candidate.Path, "/torrents.php") {
-			continue
-		}
-		query := candidate.Query()
-		if strings.EqualFold(query.Get("action"), "download") {
-			continue
-		}
-		groupID := strings.TrimSpace(query.Get("id"))
-		if groupID == "" {
-			continue
-		}
-		torrentID := strings.TrimSpace(query.Get("torrentid"))
-		return candidate.String(), groupID, torrentID, true
-	}
-	return "", "", "", false
-}
-
-// resolveBTNSameOriginURL resolves an HTML URL attribute against the current
-// BTN page and accepts only URLs on the configured BTN origin.
-func resolveBTNSameOriginURL(baseURL string, currentURL string, rawURL string) (*url.URL, bool) {
-	base, err := url.Parse(baseURL)
-	if err != nil || base.Scheme == "" || base.Host == "" {
-		return nil, false
-	}
-	referenceBase := base
-	if parsedCurrent, err := url.Parse(currentURL); err == nil && parsedCurrent.Scheme != "" && parsedCurrent.Host != "" {
-		referenceBase = parsedCurrent
-	}
-	rawURL = strings.TrimSpace(html.UnescapeString(rawURL))
-	if rawURL == "" {
-		return nil, false
-	}
-	parsed, err := url.Parse(rawURL)
-	if err != nil {
-		return nil, false
-	}
-	resolved := referenceBase.ResolveReference(parsed)
-	if !strings.EqualFold(resolved.Scheme, base.Scheme) || !strings.EqualFold(resolved.Host, base.Host) {
-		return nil, false
-	}
-	return resolved, true
-}
-
-// fetchBTNTorrentDetailPage follows the intermediate-page continue target and
-// returns the bounded HTML body with the final URL after redirects.
-func fetchBTNTorrentDetailPage(ctx context.Context, client *http.Client, detailURL string) ([]byte, string, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, detailURL, nil)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: BTN intermediate detail request build: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: BTN intermediate detail request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalURL := detailURL
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, finalURL, fmt.Errorf("trackers: BTN intermediate detail failed status=%d", resp.StatusCode)
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
-	if err != nil {
-		return nil, finalURL, fmt.Errorf("trackers: BTN read intermediate detail response: %w", err)
-	}
-	return body, finalURL, nil
-}
-
-// btnUploadIDsFromText extracts BTN group and torrent ids from a URL or HTML
-// fragment, including HTML-escaped query separators.
-func btnUploadIDsFromText(value string) (string, string, bool) {
-	matches := btnSuccessURLPattern.FindStringSubmatch(html.UnescapeString(value))
-	if len(matches) < 2 {
-		return "", "", false
-	}
-	groupID := strings.TrimSpace(matches[1])
-	torrentID := ""
-	if len(matches) > 2 {
-		torrentID = strings.TrimSpace(matches[2])
-	}
-	return groupID, torrentID, groupID != ""
-}
-
-// buildBTNTorrentURL returns BTN's canonical torrent detail URL for a group and
-// optional torrent id.
-func buildBTNTorrentURL(baseURL string, groupID string, torrentID string) string {
-	torrentURL := strings.TrimRight(baseURL, "/") + "/torrents.php?id=" + url.QueryEscape(strings.TrimSpace(groupID))
-	if strings.TrimSpace(torrentID) != "" {
-		torrentURL += "&torrentid=" + url.QueryEscape(strings.TrimSpace(torrentID))
-	}
-	return torrentURL
-}
-
-// decodeBTNAPIJSON reads a bounded BTN JSON-RPC response, rejects duplicate
-// object keys, and unmarshals the single JSON value into dest.
-func decodeBTNAPIJSON(r io.Reader, dest any) error {
-	payload, err := io.ReadAll(io.LimitReader(r, btnAPIJSONMaxBytes+1))
-	if err != nil {
-		return fmt.Errorf("read response body: %w", err)
-	}
-	if len(payload) > btnAPIJSONMaxBytes {
-		return fmt.Errorf("response body exceeds %d bytes", btnAPIJSONMaxBytes)
-	}
-	if err := validateBTNJSONNoDuplicateObjectNames(payload); err != nil {
-		return err
-	}
-	if err := json.Unmarshal(payload, dest); err != nil {
-		return fmt.Errorf("unmarshal response body: %w", err)
-	}
-	return nil
-}
-
-func callBTNAPI(ctx context.Context, apiURL, id, method string, params []any, dest any) error {
-	payload := map[string]any{
-		"jsonrpc": "2.0",
-		"id":      id,
-		"method":  method,
-		"params":  params,
-	}
-	encoded, err := json.Marshal(payload)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN API %s encode: %w", method, err)
-	}
-	apiReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(encoded))
-	if err != nil {
-		return fmt.Errorf("trackers: BTN API %s request build: %w", method, err)
-	}
-	apiReq.Header.Set("Content-Type", "application/json")
-	apiResp, err := (&http.Client{Timeout: 30 * time.Second}).Do(apiReq)
-	if err != nil {
-		return fmt.Errorf("trackers: BTN API %s request: %w", method, err)
-	}
-	defer apiResp.Body.Close()
-	if apiResp.StatusCode < 200 || apiResp.StatusCode >= 300 {
-		return fmt.Errorf("trackers: BTN API %s failed status=%d", method, apiResp.StatusCode)
-	}
-	if err := decodeBTNAPIJSON(apiResp.Body, dest); err != nil {
-		return fmt.Errorf("trackers: BTN API decode %s response: %w", method, err)
-	}
-	return nil
-}
-
-// validateBTNJSONNoDuplicateObjectNames scans one JSON value before unmarshal
-// so duplicate object names cannot collapse into the last decoded value.
-func validateBTNJSONNoDuplicateObjectNames(payload []byte) error {
-	dec := json.NewDecoder(bytes.NewReader(payload))
-	dec.UseNumber()
-	if err := validateBTNJSONValueNoDuplicateObjectNames(dec, ""); err != nil {
-		return err
-	}
-	if _, err := dec.Token(); err != io.EOF {
-		if err == nil {
-			return errors.New("multiple JSON values")
-		}
-		return fmt.Errorf("read trailing JSON token: %w", err)
-	}
-	return nil
-}
-
-// validateBTNJSONValueNoDuplicateObjectNames consumes one JSON value and
-// reports duplicate object member names with their object path.
-func validateBTNJSONValueNoDuplicateObjectNames(dec *json.Decoder, path string) error {
-	token, err := dec.Token()
-	if err != nil {
-		return fmt.Errorf("read JSON token at %q: %w", path, err)
-	}
-	delim, ok := token.(json.Delim)
-	if !ok {
-		return nil
-	}
-
-	switch delim {
-	case '{':
-		seen := map[string]struct{}{}
-		for dec.More() {
-			keyToken, err := dec.Token()
-			if err != nil {
-				return fmt.Errorf("read JSON object key at %q: %w", path, err)
-			}
-			key, ok := keyToken.(string)
-			if !ok {
-				return fmt.Errorf("invalid JSON object key at %q", path)
-			}
-			if _, exists := seen[key]; exists {
-				if path == "" {
-					return fmt.Errorf("duplicate JSON object key %q", key)
-				}
-				return fmt.Errorf("duplicate JSON object key %q at %q", key, path)
-			}
-			seen[key] = struct{}{}
-			childPath := key
-			if path != "" {
-				childPath = path + "." + key
-			}
-			if err := validateBTNJSONValueNoDuplicateObjectNames(dec, childPath); err != nil {
-				return err
-			}
-		}
-		return consumeBTNJSONDelim(dec, '}')
-	case '[':
-		index := 0
-		for dec.More() {
-			childPath := fmt.Sprintf("%s[%d]", path, index)
-			if err := validateBTNJSONValueNoDuplicateObjectNames(dec, childPath); err != nil {
-				return err
-			}
-			index++
-		}
-		return consumeBTNJSONDelim(dec, ']')
-	default:
-		return fmt.Errorf("unexpected JSON delimiter %q at %q", delim, path)
-	}
-}
-
-// consumeBTNJSONDelim consumes and verifies a JSON closing delimiter.
-func consumeBTNJSONDelim(dec *json.Decoder, want json.Delim) error {
-	token, err := dec.Token()
-	if err != nil {
-		return fmt.Errorf("read JSON delimiter %q: %w", want, err)
-	}
-	if delim, ok := token.(json.Delim); !ok || delim != want {
-		return fmt.Errorf("expected JSON delimiter %q", want)
-	}
-	return nil
-}
-
-// resolveAndDownloadViaAPI finds the uploaded torrent through BTN's JSON-RPC
-// API, validates the returned DownloadURL, and writes the fetched bencoded
-// torrent to outputPath. The selected BTN torrent and group ids are returned
-// so upload summaries reflect the torrent that was actually downloaded.
-func resolveAndDownloadViaAPI(ctx context.Context, apiURL string, apiToken string, req trackers.UploadRequest, groupID string, outputPath string) (string, string, error) {
-	if strings.TrimSpace(apiToken) == "" {
-		return "", "", errors.New("trackers: BTN api token missing for torrent resolution")
-	}
-	if strings.TrimSpace(apiURL) == "" {
-		apiURL = btnAPIRPCURL
-	}
-	downloadOrigin, err := newBTNAPIDownloadOrigin(ctx, apiURL)
-	if err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API download origin: %w", err)
-	}
-	releaseName := resolveUploadName(req.Meta)
-	filter := map[string]any{"searchstr": releaseName}
-	if strings.TrimSpace(groupID) != "" {
-		filter["group"] = groupID
-	}
-
-	var response struct {
-		Result struct {
-			Torrents map[string]map[string]any `json:"torrents"`
-		} `json:"result"`
-	}
-	if err := callBTNAPI(ctx, apiURL, "ua-btn-upload", "getTorrentsSearch", []any{apiToken, filter, 50}, &response); err != nil {
-		return "", "", err
-	}
-
-	selection := selectBTNAPITorrent(response.Result.Torrents, releaseName, groupID)
-	if selection.ID == "" {
-		return "", "", errors.New("trackers: BTN API did not return a matching torrent id")
-	}
-
-	var downloadResult struct {
-		Result struct {
-			DownloadURL string `json:"DownloadURL"`
-		} `json:"result"`
-	}
-	if err := callBTNAPI(ctx, apiURL, "ua-btn-download", "getTorrentById", []any{apiToken, selection.ID}, &downloadResult); err != nil {
-		return "", "", err
-	}
-
-	if downloadResult.Result.DownloadURL == "" {
-		return "", "", errors.New("trackers: BTN API did not return DownloadURL")
-	}
-
-	if err := downloadOrigin.validateDownloadURL(ctx, downloadResult.Result.DownloadURL); err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API invalid download url: %w", err)
-	}
-
-	dlReq, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadResult.Result.DownloadURL, nil)
-	if err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API torrent fetch request build: %w", err)
-	}
-	client := &http.Client{
-		Timeout: 30 * time.Second,
-		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			if err := downloadOrigin.validateDownloadURL(req.Context(), req.URL.String()); err != nil {
-				return err
-			}
-			if len(via) >= 10 {
-				return errors.New("stopped after 10 redirects")
-			}
-			return nil
-		},
-	}
-	dlResp, err := client.Do(dlReq)
-	if err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API torrent fetch request: %w", err)
-	}
-	defer dlResp.Body.Close()
-	if dlResp.StatusCode < 200 || dlResp.StatusCode >= 300 {
-		return "", "", fmt.Errorf("trackers: BTN API download fetch failed status=%d", dlResp.StatusCode)
-	}
-	body, err := readBTNTorrentResponseBody(dlResp.Body)
-	if err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API read torrent response: %w", err)
-	}
-	if len(body) == 0 || body[0] != 'd' {
-		return "", "", errors.New("trackers: BTN API did not return torrent payload")
-	}
-	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API create torrent output dir: %w", err)
-	}
-	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
-		return "", "", fmt.Errorf("trackers: BTN API write torrent output: %w", err)
-	}
-	return selection.ID, selection.GroupID, nil
-}
-
-// readBTNTorrentResponseBody rejects bodies beyond BTN's accepted torrent
-// response cap before callers validate or persist the payload.
-func readBTNTorrentResponseBody(r io.Reader) ([]byte, error) {
-	body, err := io.ReadAll(io.LimitReader(r, btnTorrentMaxBytes+1))
-	if err != nil {
-		return nil, fmt.Errorf("read torrent response: %w", err)
-	}
-	if len(body) > btnTorrentMaxBytes {
-		return nil, fmt.Errorf("torrent response exceeds %d bytes", btnTorrentMaxBytes)
-	}
-	return body, nil
-}
-
-// loadBTNCookiesIntoJar best-effort seeds an upload client with persisted BTN
-// cookies. Missing or unreadable cookies leave the caller's client unchanged.
-func loadBTNCookiesIntoJar(ctx context.Context, client *http.Client, dbPath string, baseURL string) {
-	if client == nil || client.Jar == nil {
-		return
-	}
-	values, err := loadBTNCookies(ctx, dbPath)
-	if err != nil {
-		return
-	}
-	setBTNCookies(client.Jar, baseURL, values)
-}
-
-// loadBTNCookies reads persisted BTN cookies and maps only typed not-found
-// results to the BTN missing-cookie sentinel. Storage, parse, and decrypt errors
-// are returned with tracker context so callers can avoid replacing valid state.
-func loadBTNCookies(ctx context.Context, dbPath string) (map[string]string, error) {
-	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "BTN")
-	if err != nil {
-		if errors.Is(err, cookies.ErrTrackerCookiesNotFound) {
-			return nil, errBTNCookiesMissing
-		}
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	return values, nil
-}
-
-// newBTNClientWithCookies creates a short-lived BTN client with a fresh cookie
-// jar populated from the supplied stored cookie map.
-func newBTNClientWithCookies(baseURL string, values map[string]string) (*http.Client, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN create session cookie jar: %w", err)
-	}
-	setBTNCookies(jar, baseURL, values)
-	return &http.Client{Timeout: 45 * time.Second, Jar: jar}, nil
-}
-
-// setBTNCookies mirrors stored BTN cookie values into jar for baseURL. Invalid
-// base URLs or nil jars are ignored because callers treat cookie seeding as
-// best-effort before explicit session validation.
-func setBTNCookies(jar http.CookieJar, baseURL string, values map[string]string) {
-	if jar == nil {
-		return
-	}
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return
-	}
-	jarCookies := make([]*http.Cookie, 0, len(values))
-	for name, value := range values {
-		// #nosec G124 -- Outbound tracker jar cookie mirrors configured BTN session values.
-		jarCookies = append(jarCookies, &http.Cookie{Name: name, Value: value, Domain: parsed.Hostname(), Path: "/"})
-	}
-	jar.SetCookies(parsed, jarCookies)
-}
-
-// persistBTNCookies saves cookies extracted from a caller-validated BTN client jar.
-func persistBTNCookies(ctx context.Context, dbPath string, baseURL string, jar http.CookieJar) error {
-	values, err := btnCookiesFromJar(baseURL, jar)
-	if err != nil {
-		return err
-	}
-	if len(values) == 0 {
-		return errors.New("trackers: BTN login returned no usable cookies")
-	}
-	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", values); err != nil {
-		return fmt.Errorf("trackers: BTN save cookies: %w", err)
-	}
-	return nil
-}
-
-// btnCookiesFromJar extracts non-empty BTN cookie names and values for baseURL
-// after a caller has validated that the jar represents a usable session.
-func btnCookiesFromJar(baseURL string, jar http.CookieJar) (map[string]string, error) {
-	if jar == nil {
-		return nil, errors.New("trackers: BTN login returned no cookie jar")
-	}
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: BTN parse cookie URL: %w", err)
-	}
-	out := make(map[string]string)
-	for _, cookie := range jar.Cookies(parsed) {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		out[strings.TrimSpace(cookie.Name)] = cookie.Value
-	}
-	return out, nil
-}
-
-// resolveBTN2FACode returns a manually submitted code before falling back to
-// the configured TOTP URI.
-func resolveBTN2FACode(cfg config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
-	if code := strings.TrimSpace(login.Code); code != "" {
-		return code, nil
-	}
-	return resolve2FACode(strings.TrimSpace(cfg.OTPURI))
-}
-
-// btnLoginNeeds2FA recognizes BTN login responses that render the manual 2FA
-// challenge field instead of accepting the submitted credentials.
-func btnLoginNeeds2FA(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "name=\"codenumber\"") ||
-		strings.Contains(lower, "name='codenumber'")
-}
-
-// btnLoginFailed recognizes explicit BTN credential or submitted-code failures
-// in successful HTTP responses.
-func btnLoginFailed(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "invalid login") ||
-		strings.Contains(lower, "incorrect password") ||
-		strings.Contains(lower, "invalid code") ||
-		strings.Contains(lower, "incorrect code") ||
-		strings.Contains(lower, "login failed")
-}
-
-// btnLoggedOutPage recognizes upload-page responses that prove the session is
-// logged out and safe to classify as confirmed-invalid auth.
-func btnLoggedOutPage(body string) bool {
-	lower := strings.ToLower(body)
-	return strings.Contains(lower, "<form") && (strings.Contains(lower, "password") || strings.Contains(lower, "login.php")) ||
-		strings.Contains(lower, "you must be logged in") ||
-		strings.Contains(lower, "please log in")
-}
-
-// btnLooksLikeUploadPage recognizes enough upload-page structure to confirm a
-// BTN session without depending on one exact page layout.
-func btnLooksLikeUploadPage(body string) bool {
-	lower := strings.ToLower(body)
-	hasForm := strings.Contains(lower, "<form")
-	hasUploadAction := strings.Contains(lower, "action=\"/upload.php") ||
-		strings.Contains(lower, "action='/upload.php") ||
-		strings.Contains(lower, "action=\"upload.php") ||
-		strings.Contains(lower, "action='upload.php")
-	hasFileInput := strings.Contains(lower, "name=\"file_input\"") ||
-		strings.Contains(lower, "name='file_input'")
-	hasAutofill := strings.Contains(lower, "name=\"autofill\"") ||
-		strings.Contains(lower, "name='autofill'")
-	return hasForm && (hasFileInput || (hasUploadAction && hasAutofill))
-}
-
-func resolve2FACode(otpURI string) (string, error) {
-	trimmed := strings.TrimSpace(otpURI)
-	if trimmed == "" {
-		return "", errors.New("otp_uri not configured")
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("trackers: BTN parse otp_uri: %w", err)
-	}
-	secret := strings.TrimSpace(parsed.Query().Get("secret"))
-	if secret == "" {
-		return "", errors.New("otp_uri missing secret")
-	}
-	period := 30
-	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
-		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
-			period = parsedValue
-		}
-	}
-	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
-	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
-	if err != nil {
-		return "", fmt.Errorf("trackers: BTN decode otp secret: %w", err)
-	}
-	counterTime := time.Now().Unix() / int64(period)
-	if counterTime < 0 {
-		return "", errors.New("totp counter before unix epoch")
-	}
-	counter := uint64(counterTime)
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint64(buf, counter)
-	mac := hmac.New(sha1.New, secretBytes)
-	_, _ = mac.Write(buf)
-	hash := mac.Sum(nil)
-	offset := hash[len(hash)-1] & 0x0f
-	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
-	return fmt.Sprintf("%06d", code%1000000), nil
-}
-
-func resolveBTNAPIURL(cfg config.TrackerConfig) string {
-	if cfg.Unknown != nil {
-		if raw, ok := cfg.Unknown["api_url"]; ok {
-			if value := strings.TrimSpace(fmt.Sprint(raw)); value != "" {
-				return value
-			}
-		}
-	}
-	return btnAPIRPCURL
-}
-
-func resolveFastTorrent(cfg config.TrackerConfig) bool {
-	if cfg.Unknown != nil {
-		if raw, ok := cfg.Unknown["fast_torrent"]; ok {
-			if b, ok := raw.(bool); ok {
-				return b
-			}
-			if s, ok := raw.(string); ok {
-				return strings.EqualFold(strings.TrimSpace(s), "true") || strings.TrimSpace(s) == "1"
-			}
-		}
-	}
-	return false
-}
-
-func stripHTML(value string) string {
-	replacer := strings.NewReplacer("<br>", "\n", "<br/>", "\n", "<br />", "\n")
-	cleaned := replacer.Replace(value)
-	cleaned = regexp.MustCompile(`(?s)<[^>]*>`).ReplaceAllString(cleaned, "")
-	return strings.TrimSpace(cleaned)
-}
-
-// mapContainer maps local container metadata to BTN's format dropdown. Autofill
-// is used only when metadata does not resolve to a BTN-supported value.
-func mapContainer(meta api.PreparedMetadata, fields map[string]string) string {
-	allowed := map[string]struct{}{"AVI": {}, "MKV": {}, "VOB": {}, "MPEG": {}, "MP4": {}, "ISO": {}, "WMV": {}, "TS": {}, "M4V": {}, "M2TS": {}, "Mixed": {}}
-	container := strings.ToLower(strings.TrimSpace(meta.Container))
-	mapped := map[string]string{"avi": "AVI", "mkv": "MKV", "vob": "VOB", "mpg": "MPEG", "mpeg": "MPEG", "mp4": "MP4", "iso": "ISO", "wmv": "WMV", "ts": "TS", "m4v": "M4V", "m2ts": "M2TS"}[container]
-	if mapped == "" && strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		mapped = "M2TS"
-	}
-	if mapped == "" && strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		mapped = "VOB"
-	}
-	for _, candidate := range []string{mapped, fields["format"], "Mixed"} {
-		if _, ok := allowed[candidate]; ok {
-			return candidate
-		}
-	}
-	return ""
-}
-
-// mapCodec maps local video codec metadata to BTN's bitrate dropdown. Autofill
-// is used only when metadata does not resolve to a BTN-supported value.
-func mapCodec(meta api.PreparedMetadata, fields map[string]string) string {
-	allowed := map[string]struct{}{"XViD": {}, "MPEG2": {}, "DiVX": {}, "DVDR": {}, "VC-1": {}, "H.264": {}, "H.265": {}, "WMV": {}, "BD": {}, "x264-Hi10P": {}, "VP9": {}, "Mixed": {}}
-	videoEncode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
-	videoCodec := strings.ToLower(strings.TrimSpace(meta.VideoCodec))
-	bitDepth := strings.TrimSpace(meta.BitDepth)
-	mapped := ""
-	if (strings.Contains(videoEncode, "hi10") || bitDepth == "10") && (strings.Contains(videoEncode, "x264") || strings.Contains(videoCodec, "avc") || strings.Contains(videoCodec, "h.264")) {
-		mapped = "x264-Hi10P"
-	}
-	if mapped == "" {
-		lookup := map[string]string{"xvid": "XViD", "divx": "DiVX", "mpeg-2": "MPEG2", "mpeg2": "MPEG2", "vc-1": "VC-1", "wmv": "WMV", "vp9": "VP9", "avc": "H.264", "h.264": "H.264", "h264": "H.264", "x264": "H.264", "hevc": "H.265", "h.265": "H.265", "h265": "H.265", "x265": "H.265"}
-		for _, value := range []string{videoEncode, videoCodec} {
-			for needle, resolved := range lookup {
-				if strings.Contains(value, needle) {
-					mapped = resolved
-					break
-				}
-			}
-			if mapped != "" {
-				break
-			}
-		}
-	}
-	for _, candidate := range []string{mapped, fields["bitrate"], "Mixed"} {
-		if _, ok := allowed[candidate]; ok {
-			return candidate
-		}
-	}
-	return ""
-}
-
-// mapSource maps local source metadata to BTN's media dropdown. Autofill is
-// used only when metadata does not resolve to a BTN-supported value.
-func mapSource(meta api.PreparedMetadata, fields map[string]string) string {
-	allowed := map[string]struct{}{"HDTV": {}, "PDTV": {}, "DSR": {}, "DVDRip": {}, "TVRip": {}, "VHSRip": {}, "Bluray": {}, "BDRip": {}, "BRRip": {}, "DVD5": {}, "DVD9": {}, "HDDVD": {}, "WEB-DL": {}, "WEBRip": {}, "BD5": {}, "BD9": {}, "BD25": {}, "BD50": {}, "Mixed": {}, "Unknown": {}}
-	source := strings.ToLower(strings.TrimSpace(meta.Source))
-	typeName := strings.ToUpper(strings.TrimSpace(meta.Type))
-	resolution := strings.ToUpper(strings.TrimSpace(meta.Release.Resolution))
-	var mapped string
-	switch {
-	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
-		mapped = "DVD9"
-	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "HDDVD"):
-		mapped = "HDDVD"
-	case typeName == "WEBDL":
-		mapped = "WEB-DL"
-	case typeName == "WEBRIP":
-		mapped = "WEBRip"
-	case typeName == "HDTV" || source == "hdtv":
-		mapped = "HDTV"
-	case typeName == "DVDRIP":
-		mapped = "DVDRip"
-	case resolution == "SD" && (source == "bluray" || source == "blu-ray"):
-		mapped = "BDRip"
-	default:
-		mapped = map[string]string{"bluray": "Bluray", "blu-ray": "Bluray", "bdrip": "BDRip", "brrip": "BRRip", "dvd5": "DVD5", "dvd9": "DVD9", "web-dl": "WEB-DL", "webrip": "WEBRip", "pdtv": "PDTV", "dsr": "DSR", "tvrip": "TVRip", "vhsrip": "VHSRip", "bd5": "BD5", "bd9": "BD9", "bd25": "BD25", "bd50": "BD50"}[source]
-	}
-	for _, candidate := range []string{mapped, fields["media"], "Unknown"} {
-		if _, ok := allowed[candidate]; ok {
-			return candidate
-		}
-	}
-	return ""
-}
-
-// mapResolution returns the BTN resolution value derived from local metadata,
-// falling back to BTN autofill only when metadata does not map to a BTN option.
-func mapResolution(meta api.PreparedMetadata, fields map[string]string) string {
-	switch strings.ToLower(strings.TrimSpace(meta.Release.Resolution)) {
-	case "2160p", "4320p", "8640p", "4k", "8k":
-		return "2160p"
-	case "1080p", "1440p":
-		return "1080p"
-	case "1080i":
-		return "1080i"
-	case "720p":
-		return "720p"
-	case "sd":
-		return "SD"
-	case "portable device":
-		return "Portable Device"
-	case "mixed":
-		return "Mixed"
-	}
-	switch strings.TrimSpace(fields["resolution"]) {
-	case "SD", "720p", "1080p", "1080i", "2160p", "Portable Device", "Mixed":
-		return strings.TrimSpace(fields["resolution"])
-	default:
-		return "SD"
-	}
-}
-
-func applyBTNNameMapping(releaseName string, mappedCodec string, mappedSource string) string {
-	updated := releaseName
-	if mappedSource != "" {
-		sourcePattern := regexp.MustCompile(`(?i)\b(bluray|blu-ray|bdrip|brrip|web-dl|webrip|hdtv|dvdrip|hddvd|dvd5|dvd9|bd5|bd9|bd25|bd50)\b`)
-		updated = sourcePattern.ReplaceAllString(updated, mappedSource)
-	}
-	if mappedCodec != "" {
-		codecPatterns := map[string]*regexp.Regexp{
-			"H.264":      regexp.MustCompile(`(?i)\b(x264|h\.264|h264|avc)\b`),
-			"H.265":      regexp.MustCompile(`(?i)\b(x265|h\.265|h265|hevc)\b`),
-			"x264-Hi10P": regexp.MustCompile(`(?i)\b(x264-hi10p|hi10p)\b`),
-			"XViD":       regexp.MustCompile(`(?i)\b(xvid)\b`),
-			"DiVX":       regexp.MustCompile(`(?i)\b(divx)\b`),
-			"MPEG2":      regexp.MustCompile(`(?i)\b(mpeg-2|mpeg2)\b`),
-			"VC-1":       regexp.MustCompile(`(?i)\b(vc-1)\b`),
-			"WMV":        regexp.MustCompile(`(?i)\b(wmv)\b`),
-			"VP9":        regexp.MustCompile(`(?i)\b(vp9)\b`),
-		}
-		if pattern, ok := codecPatterns[mappedCodec]; ok {
-			updated = pattern.ReplaceAllString(updated, mappedCodec)
-		}
-	}
-	return updated
-}
-
-// resolveCountryID extracts the first available country from TVDB, TMDB, then
-// IMDB metadata and returns its BTN country id. Country codes and names are
-// matched only against normalized exact aliases so ambiguous inputs do not
-// depend on map iteration order.
-func resolveCountryID(meta api.PreparedMetadata) string {
-	var countryStr string
-
-	// Try TVDB first (ISO 3166-1 alpha-3, lowercase)
-	if meta.ExternalMetadata.TVDB != nil && meta.ExternalMetadata.TVDB.OriginalCountry != "" {
-		countryStr = meta.ExternalMetadata.TVDB.OriginalCountry
-	}
-
-	// Fall back to TMDB (ISO 3166-1 alpha-2, uppercase)
-	if countryStr == "" && meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.OriginCountry) > 0 {
-		countryStr = meta.ExternalMetadata.TMDB.OriginCountry[0]
-	}
-
-	// Fall back to IMDB (full country names)
-	if countryStr == "" && meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Country != "" {
-		// IMDB can have multiple countries separated by commas, take the first one
-		parts := strings.Split(meta.ExternalMetadata.IMDB.Country, ",")
-		if len(parts) > 0 {
-			countryStr = strings.TrimSpace(parts[0])
-		}
-	}
-
-	if countryStr == "" {
-		return ""
-	}
-
-	if id, ok := btnCountryMap[normalizeBTNCountryAlias(countryStr)]; ok {
-		return id
-	}
-
-	return ""
-}
-
-// resolveBTNOriginalLanguage returns provider original language in BTN
-// priority order: TVDB first, then IMDb when TVDB has no value.
-func resolveBTNOriginalLanguage(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TVDB != nil {
-		if language := strings.TrimSpace(meta.ExternalMetadata.TVDB.OriginalLanguage); language != "" {
-			return language
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage)
-	}
-	return ""
-}
-
-// isBTNEnglishLanguage reports whether a provider language value represents
-// English and should therefore not trigger BTN's foreign flag.
-func isBTNEnglishLanguage(language string) bool {
-	switch strings.ToLower(strings.TrimSpace(language)) {
-	case "en", "eng", "english":
-		return true
-	default:
-		return false
-	}
-}
-
-// normalizeBTNCountryAlias lowercases and collapses punctuation so metadata
-// country names can be compared against BTN's exact alias table.
-func normalizeBTNCountryAlias(value string) string {
-	normalized := strings.ToLower(strings.TrimSpace(value))
-	normalized = strings.NewReplacer(
-		"&", " and ",
-		".", " ",
-		",", " ",
-		"-", " ",
-		"_", " ",
-		"'", " ",
-		"(", " ",
-		")", " ",
-	).Replace(normalized)
-	return strings.Join(strings.Fields(normalized), " ")
-}
-
-// btnLookupIPAddrFunc matches net.Resolver lookups so tests can model DNS
-// changes without relying on external name service.
-type btnLookupIPAddrFunc func(context.Context, string) ([]net.IPAddr, error)
-
-// btnAPIDownloadOrigin records the resolved BTN API origin that download URLs
-// may reuse when they would otherwise fail public-address validation.
-type btnAPIDownloadOrigin struct {
-	scheme string
-	host   string
-	addrs  map[netip.Addr]struct{}
-	lookup btnLookupIPAddrFunc
-}
-
-// resolveBTNURLAddrs resolves a URL host to unmapped IP addresses, preserving
-// literal IP hosts without DNS.
-func resolveBTNURLAddrs(ctx context.Context, parsed *url.URL, lookup btnLookupIPAddrFunc) ([]netip.Addr, error) {
-	host := strings.TrimSpace(parsed.Hostname())
-	if addr, err := netip.ParseAddr(host); err == nil {
-		return []netip.Addr{addr.Unmap()}, nil
-	}
-
-	resolved, err := lookup(ctx, host)
-	if err != nil {
-		return nil, fmt.Errorf("resolve host %q: %w", host, err)
-	}
-	addrs := make([]netip.Addr, 0, len(resolved))
-	for _, item := range resolved {
-		if addr, ok := netip.AddrFromSlice(item.IP); ok {
-			addrs = append(addrs, addr.Unmap())
-		}
-	}
-	if len(addrs) == 0 {
-		return nil, fmt.Errorf("host %q resolved to no usable addresses", host)
-	}
-	return addrs, nil
-}
-
-// validateBTNPublicResolvedAddrs rejects private, loopback, link-local,
-// multicast, unspecified, and otherwise non-global-unicast addresses.
-func validateBTNPublicResolvedAddrs(host string, addrs []netip.Addr) error {
-	for _, addr := range addrs {
-		if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() || addr.IsUnspecified() {
-			return fmt.Errorf("host %q resolved to blocked address %q", host, addr)
-		}
-	}
-	return nil
-}
-
-type btnAPITorrentSelection struct {
-	ID      string
-	GroupID string
-}
-
-// selectBTNAPITorrent returns the BTN torrent that matches the uploaded
-// release. It prefers an exact release-name match inside the uploaded group and
-// only accepts a group-only match when that group has a single candidate.
-func selectBTNAPITorrent(torrents map[string]map[string]any, releaseName string, groupID string) btnAPITorrentSelection {
-	expectedRelease := normalizeBTNAPIMatchValue(releaseName)
-	expectedGroup := strings.TrimSpace(groupID)
-
-	ids := make([]string, 0, len(torrents))
-	for id := range torrents {
-		if trimmed := strings.TrimSpace(id); trimmed != "" {
-			ids = append(ids, trimmed)
-		}
-	}
-	sortBTNAPITorrentIDs(ids)
-
-	groupMatches := make([]string, 0, len(ids))
-	for _, id := range ids {
-		torrentData := torrents[id]
-		if expectedGroup != "" {
-			torrentGroup := btnAPITorrentGroupID(torrentData)
-			if strings.TrimSpace(torrentGroup) != expectedGroup {
-				continue
-			}
-		}
-		groupMatches = append(groupMatches, id)
-		if expectedRelease != "" && btnAPITorrentMatchesRelease(torrentData, expectedRelease) {
-			return btnAPITorrentSelection{ID: id, GroupID: btnAPITorrentGroupID(torrentData)}
-		}
-	}
-	if len(groupMatches) == 1 {
-		return btnAPITorrentSelection{ID: groupMatches[0], GroupID: btnAPITorrentGroupID(torrents[groupMatches[0]])}
-	}
-	return btnAPITorrentSelection{}
-}
-
-// btnAPITorrentGroupID extracts BTN's group id from known API field spellings.
-func btnAPITorrentGroupID(torrentData map[string]any) string {
-	return metautil.FirstNonEmptyTrimmed(
-		btnAPIStringField(torrentData, "GroupID"),
-		btnAPIStringField(torrentData, "groupId"),
-		btnAPIStringField(torrentData, "GroupId"),
-		btnAPIStringField(torrentData, "group_id"),
-	)
-}
-
-// sortBTNAPITorrentIDs orders API result ids deterministically, newest numeric
-// ids first when all compared ids are numeric.
-func sortBTNAPITorrentIDs(ids []string) {
-	sort.Slice(ids, func(i, j int) bool {
-		left, leftErr := strconv.Atoi(ids[i])
-		right, rightErr := strconv.Atoi(ids[j])
-		if leftErr == nil && rightErr == nil {
-			return left > right
-		}
-		return ids[i] > ids[j]
-	})
-}
-
-// btnAPITorrentMatchesRelease reports whether a known BTN API name field is an
-// exact normalized match for the release name we uploaded.
-func btnAPITorrentMatchesRelease(torrentData map[string]any, expectedRelease string) bool {
-	for _, field := range []string{"ReleaseName", "releaseName", "TorrentName", "torrentName", "Name", "name", "Release", "release"} {
-		if normalizeBTNAPIMatchValue(btnAPIStringField(torrentData, field)) == expectedRelease {
-			return true
-		}
-	}
-	return false
-}
-
-// btnAPIStringField returns an API field as a trimmed string. Missing or null
-// fields produce an empty value; numeric fields keep their decimal form.
-func btnAPIStringField(data map[string]any, field string) string {
-	if data == nil {
-		return ""
-	}
-	value, ok := data[field]
-	if !ok || value == nil {
-		return ""
-	}
-	switch typed := value.(type) {
-	case string:
-		return typed
-	case json.Number:
-		return typed.String()
-	case float64:
-		if typed == float64(int64(typed)) {
-			return strconv.FormatInt(int64(typed), 10)
-		}
-		return strconv.FormatFloat(typed, 'f', -1, 64)
-	case int:
-		return strconv.Itoa(typed)
-	case int64:
-		return strconv.FormatInt(typed, 10)
-	default:
-		return strings.TrimSpace(fmt.Sprint(value))
-	}
-}
-
-// normalizeBTNAPIMatchValue canonicalizes BTN API comparison values for exact,
-// case-insensitive release-name matching.
-func normalizeBTNAPIMatchValue(value string) string {
-	return strings.ToLower(strings.TrimSpace(value))
-}
-
-// validateBTNAPIDownloadURL applies public-address validation to a BTN API
-// DownloadURL, but permits a same-origin private URL when the caller explicitly
-// configured the API endpoint to that pinned private address. The pinned-origin
-// exception keeps local test servers usable without allowing arbitrary private
-// redirects or same-host DNS rebinding.
-func validateBTNAPIDownloadURL(ctx context.Context, apiURL string, rawURL string) error {
-	origin, err := newBTNAPIDownloadOrigin(ctx, apiURL)
-	if err != nil {
-		return err
-	}
-	return origin.validateDownloadURL(ctx, rawURL)
-}
-
-func newBTNAPIDownloadOrigin(ctx context.Context, apiURL string) (*btnAPIDownloadOrigin, error) {
-	return newBTNAPIDownloadOriginWithLookup(ctx, apiURL, net.DefaultResolver.LookupIPAddr)
-}
-
-// newBTNAPIDownloadOriginWithLookup parses and pins the API URL's scheme, host,
-// and current resolved addresses for later download redirect validation.
-func newBTNAPIDownloadOriginWithLookup(ctx context.Context, apiURL string, lookup btnLookupIPAddrFunc) (*btnAPIDownloadOrigin, error) {
-	parsed, err := url.Parse(strings.TrimSpace(apiURL))
-	if err != nil {
-		return nil, fmt.Errorf("parse url: %w", err)
-	}
-	scheme := strings.ToLower(parsed.Scheme)
-	if scheme != "http" && scheme != "https" {
-		return nil, fmt.Errorf("unsupported scheme %q", parsed.Scheme)
-	}
-	if strings.TrimSpace(parsed.Hostname()) == "" {
-		return nil, errors.New("missing host")
-	}
-	if strings.Contains(parsed.Hostname(), "%") {
-		return nil, fmt.Errorf("blocked private host %q", parsed.Hostname())
-	}
-	addrs, err := resolveBTNURLAddrs(ctx, parsed, lookup)
-	if err != nil {
-		return nil, err
-	}
-	pinned := make(map[netip.Addr]struct{}, len(addrs))
-	for _, addr := range addrs {
-		pinned[addr] = struct{}{}
-	}
-	return &btnAPIDownloadOrigin{
-		scheme: scheme,
-		host:   parsed.Host,
-		addrs:  pinned,
-		lookup: lookup,
-	}, nil
-}
-
-// validateDownloadURL accepts public HTTP(S) destinations and otherwise only
-// permits same-origin destinations that still resolve to the pinned API address.
-func (origin *btnAPIDownloadOrigin) validateDownloadURL(ctx context.Context, rawURL string) error {
-	parsed, err := url.Parse(strings.TrimSpace(rawURL))
-	if err != nil {
-		return fmt.Errorf("parse url: %w", err)
-	}
-	scheme := strings.ToLower(parsed.Scheme)
-	if scheme != "http" && scheme != "https" {
-		return fmt.Errorf("unsupported scheme %q", parsed.Scheme)
-	}
-	host := strings.TrimSpace(parsed.Hostname())
-	if host == "" {
-		return errors.New("missing host")
-	}
-	addrs, err := resolveBTNURLAddrs(ctx, parsed, origin.lookup)
-	if err != nil {
-		return err
-	}
-	publicErr := validateBTNPublicResolvedAddrs(host, addrs)
-	lowerHost := strings.ToLower(host)
-	if publicErr == nil && lowerHost != "localhost" && !strings.HasSuffix(lowerHost, ".localhost") && !strings.Contains(lowerHost, "%") {
-		return nil
-	}
-
-	if !origin.sameOrigin(parsed) {
-		if publicErr != nil {
-			return publicErr
-		}
-		return fmt.Errorf("blocked private host %q", host)
-	}
-
-	for _, addr := range addrs {
-		if _, ok := origin.addrs[addr]; !ok {
-			return fmt.Errorf("blocked address %q not pinned to BTN API origin", addr)
-		}
-	}
-
-	return nil
-}
-
-// sameOrigin reports whether a URL has the pinned API origin's scheme and host.
-func (origin *btnAPIDownloadOrigin) sameOrigin(parsed *url.URL) bool {
-	if origin == nil || parsed == nil {
-		return false
-	}
-	return strings.EqualFold(origin.scheme, parsed.Scheme) &&
-		strings.EqualFold(origin.host, parsed.Host) &&
-		origin.host != ""
-}
-
-// checkBTNSeasonPackReservation enforces BTN's 2-hour internal season-pack
-// reservation using the same canonical season source as the final upload
-// payload, including TVDB/IMDb translated episode metadata.
-func checkBTNSeasonPackReservation(ctx context.Context, uploadCtx uploadContext, req trackers.UploadRequest) error {
-	if resolveUploadType(req.Meta) != "Season" {
-		return nil
-	}
-	// The 2-hour reservation ONLY applies to season packs made of internal releases.
-	if !isBTNInternalGroup(req.Meta) {
-		return nil
-	}
-
-	tvdbID := req.Meta.ExternalIDs.TVDBID
-	if tvdbID == 0 {
-		return nil
-	}
-
-	group := strings.TrimPrefix(req.Meta.Tag, "-")
-	if group == "" {
-		return nil
-	}
-
-	filter := map[string]any{
-		"tvdb":     strconv.Itoa(tvdbID),
-		"category": "Episode",
-		"group":    group,
-	}
-
-	// We only need the most recent episodes to check the 2-hour window
-	torrentsMap, err := btnAPISearchTorrents(ctx, uploadCtx.apiURL, uploadCtx.apiToken, filter, 50)
-	if err != nil {
-		return err
-	}
-
-	seasonPrefix := ""
-	season, _ := resolveBTNTVSeasonEpisode(req.Meta)
-	if season > 0 {
-		seasonPrefix = fmt.Sprintf("S%02dE", season)
-	}
-
-	var newestInternal time.Time
-	for _, t := range torrentsMap {
-		name, _ := t["ReleaseName"].(string)
-		if seasonPrefix != "" && !strings.Contains(strings.ToUpper(name), seasonPrefix) {
-			continue
-		}
-
-		tTime := parseBTNTimestamp(t["Time"])
-		if tTime.After(newestInternal) {
-			newestInternal = tTime
-		}
-	}
-
-	if !newestInternal.IsZero() && time.Since(newestInternal) < 2*time.Hour {
-		return errors.New("trackers: BTN 2-hour reservation period for internal season packs has not expired")
-	}
-
-	return nil
-}
-
-func btnAPISearchTorrents(ctx context.Context, apiURL, apiToken string, filter map[string]any, limit int) (map[string]map[string]any, error) {
-	var response struct {
-		Result struct {
-			Torrents json.RawMessage `json:"torrents"`
-		} `json:"result"`
-	}
-	if err := callBTNAPI(ctx, apiURL, "ua-btn-upload-check", "getTorrentsSearch", []any{apiToken, filter, limit}, &response); err != nil {
-		return nil, err
-	}
-
-	if len(response.Result.Torrents) == 0 || string(response.Result.Torrents) == "false" || string(response.Result.Torrents) == "[]" {
-		return nil, nil
-	}
-
-	var torrentsMap map[string]map[string]any
-	if err := json.Unmarshal(response.Result.Torrents, &torrentsMap); err != nil {
-		return nil, fmt.Errorf("trackers: BTN API parse torrents search response: %s", redaction.RedactValue(err.Error(), nil))
-	}
-	return torrentsMap, nil
-}
-
-func parseBTNTimestamp(val any) time.Time {
-	var epoch int64
-	switch v := val.(type) {
-	case string:
-		epoch, _ = strconv.ParseInt(v, 10, 64)
-	case float64:
-		epoch = int64(v)
-	}
-	if epoch > 0 {
-		return time.Unix(epoch, 0)
-	}
-	return time.Time{}
-}
diff --git a/internal/trackers/impl/commonhttp/commonhttp.go b/internal/trackers/impl/commonhttp/commonhttp.go
index 48da3bb9..26deb0fd 100644
--- a/internal/trackers/impl/commonhttp/commonhttp.go
+++ b/internal/trackers/impl/commonhttp/commonhttp.go
@@ -21,7 +21,7 @@ import (
 	"strings"
 
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/pkg/api"
@@ -365,7 +365,7 @@ func ResponseBodyPreview(body []byte, previewLimit int64) []byte {
 // WriteFailureArtifact stores a tracker failure response under the release temp
 // directory and returns the written path. It returns an empty path when dbPath or
 // the source path is unavailable.
-func WriteFailureArtifact(meta api.PreparedMetadata, dbPath string, tracker string, name string, body []byte, ext string) (string, error) {
+func WriteFailureArtifact(meta api.UploadSubject, dbPath string, tracker string, name string, body []byte, ext string) (string, error) {
 	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
 		return "", nil
 	}
@@ -373,7 +373,7 @@ func WriteFailureArtifact(meta api.PreparedMetadata, dbPath string, tracker stri
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
diff --git a/internal/trackers/impl/commonhttp/commonhttp_test.go b/internal/trackers/impl/commonhttp/commonhttp_test.go
index cfc933b8..80379cd2 100644
--- a/internal/trackers/impl/commonhttp/commonhttp_test.go
+++ b/internal/trackers/impl/commonhttp/commonhttp_test.go
@@ -84,7 +84,7 @@ func TestWriteFailureArtifactRedactsSensitiveBody(t *testing.T) {
 
 	root := t.TempDir()
 	dbPath := filepath.Join(root, "state", "upbrr.db")
-	meta := api.PreparedMetadata{SourcePath: filepath.Join(root, "source.mkv")}
+	meta := api.UploadSubject{SourcePath: filepath.Join(root, "source.mkv")}
 	body := []byte(`{"message":"failed","api_key":"secret-key","detail":"token=plain-secret"}`)
 
 	path, err := WriteFailureArtifact(meta, dbPath, "GPW", "upload_failure", body, ".json")
diff --git a/internal/trackers/impl/commonhttp/html.go b/internal/trackers/impl/commonhttp/html.go
new file mode 100644
index 00000000..3419bd17
--- /dev/null
+++ b/internal/trackers/impl/commonhttp/html.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package commonhttp
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+)
+
+var sizePattern = regexp.MustCompile(`(?i)([0-9]+(?:\.[0-9]+)?)\s*(KB|MB|GB|TB|KiB|MiB|GiB|TiB|B)\b`)
+
+// GetText performs a tracker GET request and reads the full response body for
+// every HTTP status. Non-success status codes are returned as data, not errors.
+func GetText(ctx context.Context, client *http.Client, endpoint string, params url.Values, cookies []*http.Cookie) (int, string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return 0, "", fmt.Errorf("commonhttp: create text GET request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	ApplyCookies(req, cookies)
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, "", fmt.Errorf("commonhttp: text GET request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp.StatusCode, "", fmt.Errorf("commonhttp: read text response: %w", err)
+	}
+	return resp.StatusCode, string(body), nil
+}
+
+// GetHTML performs a tracker GET request and parses successful responses.
+// Non-2xx responses return their status with a nil document and nil error.
+func GetHTML(ctx context.Context, client *http.Client, endpoint string, params url.Values, cookies []*http.Cookie) (int, *xhtml.Node, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return 0, nil, fmt.Errorf("commonhttp: create HTML GET request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	ApplyCookies(req, cookies)
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, nil, fmt.Errorf("commonhttp: HTML GET request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return resp.StatusCode, nil, nil
+	}
+	root, err := xhtml.Parse(resp.Body)
+	if err != nil {
+		return resp.StatusCode, nil, fmt.Errorf("commonhttp: parse HTML response: %w", err)
+	}
+	return resp.StatusCode, root, nil
+}
+
+// FindNodes returns matching nodes in document order.
+func FindNodes(root *xhtml.Node, match func(*xhtml.Node) bool) []*xhtml.Node {
+	nodes := make([]*xhtml.Node, 0)
+	WalkNodes(root, func(node *xhtml.Node) {
+		if match(node) {
+			nodes = append(nodes, node)
+		}
+	})
+	return nodes
+}
+
+// FirstNode returns the first matching node in document order.
+func FirstNode(root *xhtml.Node, match func(*xhtml.Node) bool) *xhtml.Node {
+	var found *xhtml.Node
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil || found != nil {
+			return
+		}
+		if match(node) {
+			found = node
+			return
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(root)
+	return found
+}
+
+// WalkNodes visits an HTML tree in document order.
+func WalkNodes(root *xhtml.Node, visit func(*xhtml.Node)) {
+	if root == nil {
+		return
+	}
+	visit(root)
+	for child := root.FirstChild; child != nil; child = child.NextSibling {
+		WalkNodes(child, visit)
+	}
+}
+
+// Attr returns a trimmed HTML attribute value.
+func Attr(node *xhtml.Node, key string) string {
+	if node == nil {
+		return ""
+	}
+	for _, attr := range node.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return strings.TrimSpace(attr.Val)
+		}
+	}
+	return ""
+}
+
+// HasClass reports whether an HTML node has a class token.
+func HasClass(node *xhtml.Node, className string) bool {
+	for value := range strings.FieldsSeq(Attr(node, "class")) {
+		if strings.EqualFold(value, strings.TrimSpace(className)) {
+			return true
+		}
+	}
+	return false
+}
+
+// NodeText returns concatenated descendant text.
+func NodeText(node *xhtml.Node) string {
+	if node == nil {
+		return ""
+	}
+	if node.Type == xhtml.TextNode {
+		return node.Data
+	}
+	var builder strings.Builder
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		builder.WriteString(NodeText(child))
+	}
+	return builder.String()
+}
+
+// AbsoluteURL resolves a possibly relative tracker link.
+func AbsoluteURL(baseURL, value string) string {
+	base, baseErr := url.Parse(strings.TrimSpace(baseURL))
+	ref, refErr := url.Parse(strings.TrimSpace(value))
+	if baseErr == nil && refErr == nil {
+		return base.ResolveReference(ref).String()
+	}
+	return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(value, "/")
+}
+
+// ParseSizeBytes parses decimal and binary byte units.
+func ParseSizeBytes(value string) (int64, bool) {
+	match := sizePattern.FindStringSubmatch(strings.TrimSpace(value))
+	if len(match) != 3 {
+		return 0, false
+	}
+	amount, err := strconv.ParseFloat(match[1], 64)
+	if err != nil {
+		return 0, false
+	}
+	multipliers := map[string]float64{
+		"b":   1,
+		"kb":  1e3,
+		"mb":  1e6,
+		"gb":  1e9,
+		"tb":  1e12,
+		"kib": 1024,
+		"mib": 1024 * 1024,
+		"gib": 1024 * 1024 * 1024,
+		"tib": 1024 * 1024 * 1024 * 1024,
+	}
+	return int64(math.Round(amount * multipliers[strings.ToLower(match[2])])), true
+}
diff --git a/internal/trackers/impl/commonhttp/upload_executor.go b/internal/trackers/impl/commonhttp/upload_executor.go
new file mode 100644
index 00000000..323124b5
--- /dev/null
+++ b/internal/trackers/impl/commonhttp/upload_executor.go
@@ -0,0 +1,153 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package commonhttp
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/redaction"
+)
+
+const defaultSuccessBodyBytes int64 = 1024 * 1024
+
+// SuccessBodyPolicy selects bounded or protocol-required full reads for a
+// successful tracker response.
+type SuccessBodyPolicy uint8
+
+const (
+	// BoundedSuccessBody rejects successful response bodies above the configured limit.
+	BoundedSuccessBody SuccessBodyPolicy = iota
+	// FullSuccessBody permits a full successful response read for protocols that return artifacts inline.
+	FullSuccessBody
+)
+
+// UploadExecutionOptions controls response classification and body bounds.
+type UploadExecutionOptions struct {
+	Tracker          string
+	SuccessStatus    func(int) bool
+	SuccessBody      SuccessBodyPolicy
+	SuccessBodyLimit int64
+	PreviewLimit     int64
+}
+
+// UploadExecution contains one closed HTTP response projected for tracker-local
+// parsing. Failure Body and Preview are bounded and redacted; successful Body
+// retains parser input while Preview remains bounded and redacted.
+type UploadExecution struct {
+	StatusCode int
+	Header     http.Header
+	Body       []byte
+	Preview    []byte
+	FinalURL   string
+	Success    bool
+}
+
+// ExecuteUpload performs one prepared request and closes its response. It
+// rejects oversized success bodies unless full reads are explicitly selected,
+// clones response headers, and redacts the final URL and diagnostic previews.
+func ExecuteUpload(client *http.Client, req *http.Request, options UploadExecutionOptions) (UploadExecution, error) {
+	if client == nil {
+		return UploadExecution{}, errors.New("tracker upload client is nil")
+	}
+	if req == nil {
+		return UploadExecution{}, errors.New("tracker upload request is nil")
+	}
+	tracker := strings.ToUpper(strings.TrimSpace(options.Tracker))
+	if tracker == "" {
+		tracker = "TRACKER"
+	}
+	successStatus := options.SuccessStatus
+	if successStatus == nil {
+		successStatus = func(status int) bool { return status >= http.StatusOK && status < http.StatusMultipleChoices }
+	}
+	previewLimit := options.PreviewLimit
+	if previewLimit <= 0 {
+		previewLimit = DefaultResponsePreviewBytes
+	}
+
+	// The caller constructs requests from tracker-profile endpoints; this helper
+	// deliberately accepts an injected client/request pair for redirects and tests.
+	resp, err := client.Do(req) //nolint:gosec // Tracker-owned endpoint request, not user-selected SSRF input.
+	if err != nil {
+		return UploadExecution{}, fmt.Errorf("trackers: %s upload request: %w", tracker, safeWrappedError(err))
+	}
+	success := successStatus(resp.StatusCode)
+	body, readErr := readExecutedUploadBody(resp.Body, success, options.SuccessBody, options.SuccessBodyLimit, previewLimit)
+	closeErr := resp.Body.Close()
+	if readErr != nil || closeErr != nil {
+		return UploadExecution{}, fmt.Errorf("trackers: %s read upload response: %w", tracker, errors.Join(readErr, closeErr))
+	}
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = redaction.RedactValue(resp.Request.URL.String(), nil)
+	}
+	preview := ResponseBodyPreview(body, previewLimit)
+	preview = []byte(redaction.RedactValue(string(preview), nil))
+	if !success {
+		body = append([]byte(nil), preview...)
+	}
+	return UploadExecution{
+		StatusCode: resp.StatusCode,
+		Header:     resp.Header.Clone(),
+		Body:       body,
+		Preview:    preview,
+		FinalURL:   finalURL,
+		Success:    success,
+	}, nil
+}
+
+func readExecutedUploadBody(
+	body io.Reader,
+	success bool,
+	policy SuccessBodyPolicy,
+	successLimit int64,
+	previewLimit int64,
+) ([]byte, error) {
+	if !success {
+		payload, err := io.ReadAll(io.LimitReader(body, previewLimit))
+		if err != nil {
+			return nil, fmt.Errorf("read bounded upload failure response: %w", err)
+		}
+		return payload, nil
+	}
+	if policy == FullSuccessBody {
+		payload, err := io.ReadAll(body)
+		if err != nil {
+			return nil, fmt.Errorf("read full upload success response: %w", err)
+		}
+		return payload, nil
+	}
+	if successLimit <= 0 {
+		successLimit = defaultSuccessBodyBytes
+	}
+	payload, err := io.ReadAll(io.LimitReader(body, successLimit+1))
+	if err != nil {
+		return nil, fmt.Errorf("read bounded upload success response: %w", err)
+	}
+	if int64(len(payload)) > successLimit {
+		return nil, fmt.Errorf("successful upload response exceeds %d bytes", successLimit)
+	}
+	return payload, nil
+}
+
+type wrappedSafeError struct {
+	message string
+	cause   error
+}
+
+func (e wrappedSafeError) Error() string { return e.message }
+
+func (e wrappedSafeError) Unwrap() error { return e.cause }
+
+func safeWrappedError(err error) error {
+	if err == nil {
+		return nil
+	}
+	return wrappedSafeError{message: redaction.RedactValue(err.Error(), nil), cause: err}
+}
diff --git a/internal/trackers/impl/commonhttp/upload_executor_test.go b/internal/trackers/impl/commonhttp/upload_executor_test.go
new file mode 100644
index 00000000..3756ef9e
--- /dev/null
+++ b/internal/trackers/impl/commonhttp/upload_executor_test.go
@@ -0,0 +1,74 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package commonhttp
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+type uploadRoundTripper func(*http.Request) (*http.Response, error)
+
+func (roundTrip uploadRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	return roundTrip(req)
+}
+
+func TestExecuteUploadBoundsAndRedactsFailure(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{Transport: uploadRoundTripper(func(req *http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: http.StatusBadRequest,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader(`api_key=secret-value ` + strings.Repeat("x", 128))),
+			Request:    req,
+		}, nil
+	})}
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, "https://tracker.invalid/upload", nil)
+	if err != nil {
+		t.Fatalf("build request: %v", err)
+	}
+	result, err := ExecuteUpload(client, req, UploadExecutionOptions{Tracker: "DC", PreviewLimit: 32})
+	if err != nil {
+		t.Fatalf("execute upload: %v", err)
+	}
+	if result.Success || len(result.Body) > 32 || strings.Contains(string(result.Preview), "secret-value") {
+		t.Fatalf("unsafe failure projection: %#v", result)
+	}
+}
+
+func TestExecuteUploadRejectsOversizedSuccessUnlessFullBodyIsExplicit(t *testing.T) {
+	t.Parallel()
+
+	newClient := func() *http.Client {
+		return &http.Client{Transport: uploadRoundTripper(func(req *http.Request) (*http.Response, error) {
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     make(http.Header),
+				Body:       io.NopCloser(strings.NewReader("artifact")),
+				Request:    req,
+			}, nil
+		})}
+	}
+	newRequest := func() *http.Request {
+		req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, "https://tracker.invalid/upload", nil)
+		if err != nil {
+			t.Fatalf("build request: %v", err)
+		}
+		return req
+	}
+	if _, err := ExecuteUpload(newClient(), newRequest(), UploadExecutionOptions{Tracker: "CZT", SuccessBodyLimit: 4}); err == nil {
+		t.Fatal("expected bounded success body failure")
+	}
+	result, err := ExecuteUpload(newClient(), newRequest(), UploadExecutionOptions{Tracker: "CZT", SuccessBody: FullSuccessBody})
+	if err != nil {
+		t.Fatalf("execute full-body upload: %v", err)
+	}
+	if string(result.Body) != "artifact" {
+		t.Fatalf("success body = %q", result.Body)
+	}
+}
diff --git a/internal/trackers/impl/czt/definition.go b/internal/trackers/impl/czt/definition.go
deleted file mode 100644
index 9debe629..00000000
--- a/internal/trackers/impl/czt/definition.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package czt
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-// New returns the CZTeam tracker definition used by the tracker registry.
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "CZT" }
-
-// Upload submits a CZTeam upload request and returns the persisted registered
-// torrent artifact on tracker success.
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-// BuildUploadDryRun builds the CZTeam multipart payload preview without
-// sending it to the tracker.
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-// BuildDescription renders the CZTeam user description, preferring caller
-// supplied description assets and resolving assets only as a fallback.
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		resolved, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err == nil {
-			assets = resolved
-		}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: descGroup, Description: description}, nil
-}
diff --git a/internal/trackers/impl/czt/upload.go b/internal/trackers/impl/czt/upload.go
deleted file mode 100644
index b5ba2e3c..00000000
--- a/internal/trackers/impl/czt/upload.go
+++ /dev/null
@@ -1,1081 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-// Package czt implements uploads to CZTeam (CZT) via its dedicated JSON
-// endpoint takeupload_api.php.
-//
-// Unlike most impls in this repo CZTeam is not a UNIT3D site and does not need a
-// cookie jar: the user's passkey authenticates the multipart POST. The endpoint
-// returns the registered .torrent inline as base64, already personalized with
-// the uploader's announce passkey and source=CzT.
-package czt
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"maps"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/anacrolix/torrent/metainfo"
-
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	trackerName               = "CZT"
-	descGroup                 = "czt"
-	defaultBaseURL            = "https://czteam.me"
-	uploadPath                = "/takeupload_api.php"
-	uploadTimeout             = 120 * time.Second
-	defaultCZTPostCancelGrace = 5 * time.Second
-	cztUploadDecodeFieldBytes = 512
-)
-
-var cztPostCancelGrace atomic.Int64
-
-func init() {
-	cztPostCancelGrace.Store(int64(defaultCZTPostCancelGrace))
-}
-
-var (
-	newCZTUploadHTTPClient = func() *http.Client {
-		return &http.Client{Timeout: uploadTimeout}
-	}
-	cztBaseURL = defaultBaseURL
-)
-
-// uploadResponse mirrors the JSON returned by takeupload_api.php. A 201 carries
-// the full set; a 409 duplicate still returns id/name/download_url/torrent_b64.
-type uploadResponse struct {
-	ID          int    `json:"id"`
-	Name        string `json:"name"`
-	InfoHash    string `json:"infohash"`
-	DownloadURL string `json:"download_url"`
-	TorrentB64  string `json:"torrent_b64"`
-	Error       string `json:"error"`
-}
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	files         []commonhttp.FileField
-	endpoint      string
-	baseURL       string
-	questionnaire *api.TrackerQuestionnaire
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, state.files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	if err := ctx.Err(); err != nil {
-		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(context.WithoutCancel(ctx), http.MethodPost, state.endpoint, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: CZT build upload request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	// Once the CZT upload POST is sent, cancellation can race with an
-	// irreversible remote 201. Give the tracker a short grace to return that
-	// result, but do not wait for the full client timeout after caller cancel.
-	postCtx, startPost, cancelPost := newCZTPostRequestContext(ctx)
-	defer cancelPost()
-	client := cztUploadHTTPClientWithStartHook(newCZTUploadHTTPClient(), startPost)
-	resp, err := client.Do(httpReq.WithContext(postCtx))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: CZT upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusCreated, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: CZT read upload response: %w", err)
-	}
-	if resp.StatusCode != http.StatusCreated {
-		if err := ctx.Err(); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
-		}
-	}
-
-	// Only a fresh 201 with a torrent id is a successful upload. A 409 means the
-	// release name already exists; surface it as an error (the response still
-	// carries the existing torrent for callers who want to cross-seed).
-	if resp.StatusCode != http.StatusCreated {
-		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName, "upload_failure", responsePreview, ".json")
-		return api.UploadSummary{}, commonhttp.UploadHTTPError(trackerName, resp.StatusCode, responsePreview)
-	}
-
-	torrentIDValue, err := parseCZTUploadID(responseBody)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: CZT parse upload response id: %w", err)
-	}
-	if torrentIDValue <= 0 {
-		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName, "upload_failure", responsePreview, ".json")
-		return api.UploadSummary{}, commonhttp.UploadHTTPError(trackerName, resp.StatusCode, responsePreview)
-	}
-
-	torrentID := strconv.Itoa(torrentIDValue)
-	torrentURL := state.baseURL + "/details.php?id=" + torrentID
-	summary := api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
-		Tracker:    trackerName,
-		TorrentID:  torrentID,
-		TorrentURL: torrentURL,
-	}}}
-
-	parsed, err := parseCZTUploadResponse(responseBody)
-	if err != nil {
-		warnCZTLocalUploadFailure(req.Logger, "parse upload response", err)
-	}
-
-	if strings.TrimSpace(parsed.DownloadURL) != "" {
-		downloadURL, err := joinCZTURL(state.baseURL, parsed.DownloadURL)
-		if err != nil {
-			warnCZTLocalUploadFailure(req.Logger, "upload response download_url", err)
-		} else {
-			summary.UploadedTorrents[0].DownloadURL = downloadURL
-		}
-	}
-
-	if err := ctx.Err(); err != nil {
-		warnCZTLocalUploadFailure(req.Logger, "post-success cancellation", err)
-		return finalizeCZTUploadSummary(summary), nil
-	}
-
-	// The endpoint returns the registered .torrent inline (base64), already
-	// personalized with the uploader's announce passkey and source=CzT, so we
-	// persist that directly rather than re-deriving an announce URL.
-	artifactPath, err := persistReturnedTorrent(req, parsed.TorrentB64)
-	if err != nil {
-		warnCZTLocalUploadFailure(req.Logger, "persist returned torrent", err)
-		return finalizeCZTUploadSummary(summary), nil
-	}
-	if strings.TrimSpace(artifactPath) != "" {
-		summary.UploadedTorrents[0].TorrentPath = artifactPath
-	}
-
-	if err := ctx.Err(); err != nil {
-		warnCZTLocalUploadFailure(req.Logger, "post-success cancellation", err)
-		return finalizeCZTUploadSummary(summary), nil
-	}
-
-	return finalizeCZTUploadSummary(summary), nil
-}
-
-func warnCZTLocalUploadFailure(logger api.Logger, step string, err error) {
-	if logger == nil || err == nil {
-		return
-	}
-	logger.Warnf("trackers: CZT upload completed remotely but local %s failed: %v", step, err)
-}
-
-// newCZTPostRequestContext lets an in-flight POST outlive caller cancellation
-// for a short grace period so an irreversible 201 response can still be
-// accounted for, then cancels the request before the full client timeout.
-func newCZTPostRequestContext(ctx context.Context) (context.Context, func() error, context.CancelFunc) {
-	postCtx, cancelPost := context.WithCancel(context.WithoutCancel(ctx))
-	startPost := func() error { return nil }
-	if ctx.Done() == nil {
-		return postCtx, startPost, cancelPost
-	}
-
-	started := make(chan struct{})
-	done := make(chan struct{})
-	var startedFlag atomic.Bool
-	var startOnce sync.Once
-	var cancelOnce sync.Once
-	startPost = func() error {
-		if startedFlag.Load() {
-			return nil
-		}
-		if err := ctx.Err(); err != nil {
-			cancelPost()
-			return fmt.Errorf("context canceled: %w", err)
-		}
-		startOnce.Do(func() {
-			startedFlag.Store(true)
-			close(started)
-		})
-		return nil
-	}
-
-	waitGrace := func() {
-		timer := time.NewTimer(time.Duration(cztPostCancelGrace.Load()))
-		defer timer.Stop()
-		select {
-		case <-timer.C:
-			cancelPost()
-		case <-done:
-		}
-	}
-
-	go func() {
-		select {
-		case <-started:
-			select {
-			case <-ctx.Done():
-				waitGrace()
-			case <-done:
-			}
-		case <-ctx.Done():
-			select {
-			case <-started:
-				waitGrace()
-			default:
-				cancelPost()
-			}
-		case <-done:
-		}
-	}()
-
-	return postCtx, startPost, func() {
-		cancelOnce.Do(func() {
-			close(done)
-			cancelPost()
-		})
-	}
-}
-
-type cztPostStartTransport struct {
-	base  http.RoundTripper
-	start func() error
-}
-
-// RoundTrip records the exact start of the irreversible CZT POST and rejects
-// the request if the caller canceled before the transport begins sending it.
-func (t cztPostStartTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	if err := t.start(); err != nil {
-		return nil, fmt.Errorf("start CZT upload request: %w", err)
-	}
-	resp, err := t.base.RoundTrip(req)
-	if err != nil {
-		return nil, fmt.Errorf("CZT upload round trip: %w", err)
-	}
-	return resp, nil
-}
-
-func cztUploadHTTPClientWithStartHook(client *http.Client, start func() error) *http.Client {
-	if client == nil {
-		client = &http.Client{Timeout: uploadTimeout}
-	}
-	base := client.Transport
-	if base == nil {
-		base = http.DefaultTransport
-	}
-	out := *client
-	out.Transport = cztPostStartTransport{base: base, start: start}
-	return &out
-}
-
-// finalizeCZTUploadSummary drops uploaded rows that cannot be injected or
-// downloaded locally while preserving the accepted remote upload count.
-func finalizeCZTUploadSummary(summary api.UploadSummary) api.UploadSummary {
-	if len(summary.UploadedTorrents) == 0 {
-		return summary
-	}
-	out := summary.UploadedTorrents[:0]
-	for _, uploaded := range summary.UploadedTorrents {
-		if strings.TrimSpace(uploaded.TorrentPath) != "" || strings.TrimSpace(uploaded.DownloadURL) != "" {
-			out = append(out, uploaded)
-		}
-	}
-	summary.UploadedTorrents = out
-	return summary
-}
-
-func parseCZTUploadID(body []byte) (int, error) {
-	var fields map[string]json.RawMessage
-	if err := json.Unmarshal(body, &fields); err != nil {
-		return 0, redactCZTUploadDecodeError("decode CZT upload response fields", err)
-	}
-	var id int
-	if err := json.Unmarshal(fields["id"], &id); err != nil {
-		return 0, redactCZTUploadDecodeError("decode CZT upload response id", err)
-	}
-	return id, nil
-}
-
-func parseCZTUploadResponse(body []byte) (uploadResponse, error) {
-	var parsed uploadResponse
-	var fields map[string]json.RawMessage
-	if err := json.Unmarshal(body, &fields); err != nil {
-		return parsed, redactCZTUploadDecodeError("decode CZT upload response fields", err)
-	}
-	if err := json.Unmarshal(fields["id"], &parsed.ID); err != nil {
-		return parsed, redactCZTUploadDecodeError("decode CZT upload response id", err)
-	}
-	var fieldErrs []error
-	parseOptionalStringField(fields, "name", &parsed.Name, &fieldErrs)
-	parseOptionalStringField(fields, "infohash", &parsed.InfoHash, &fieldErrs)
-	parseOptionalStringField(fields, "download_url", &parsed.DownloadURL, &fieldErrs)
-	parseOptionalStringField(fields, "torrent_b64", &parsed.TorrentB64, &fieldErrs)
-	parseOptionalStringField(fields, "error", &parsed.Error, &fieldErrs)
-	return parsed, errors.Join(fieldErrs...)
-}
-
-// redactCZTUploadDecodeError preserves parse context while removing any
-// secret-bearing fragments that encoding/json may echo from the response body.
-func redactCZTUploadDecodeError(context string, err error) error {
-	return fmt.Errorf("%s: %s", context, redaction.RedactValue(err.Error(), nil))
-}
-
-func parseOptionalStringField(fields map[string]json.RawMessage, name string, dest *string, errs *[]error) {
-	raw := fields[name]
-	if len(raw) == 0 {
-		return
-	}
-	if err := json.Unmarshal(raw, dest); err != nil {
-		preview := string(raw)
-		if len(preview) > cztUploadDecodeFieldBytes {
-			preview = preview[:cztUploadDecodeFieldBytes] + "..."
-		}
-		*errs = append(*errs, fmt.Errorf("%s: %s", name, redaction.RedactValue(fmt.Sprintf("value=%s: %s", preview, err.Error()), nil)))
-	}
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if missingRequiredCategory(state) {
-		status = "blocked"
-		message = "answer the category questionnaire to continue"
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          trackerName,
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: descGroup,
-		Description:      state.description,
-		Endpoint:         state.endpoint,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, requireCategory bool) (uploadState, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	assets := uploadDescriptionAssets(ctx, req)
-
-	// CZTeam stores two description fields separately: `descr` holds the raw
-	// MediaInfo/BDInfo dump, and `user_descr` holds the free-form BBCode body
-	// (user notes + screenshot images).
-	mediaInfo := buildMediaInfo(req)
-	userDescr := buildDescription(req, assets)
-	releaseName := resolveName(req.Meta)
-	baseURL := resolveBaseURL()
-	passkey := strings.TrimSpace(req.TrackerConfig.Passkey)
-	if passkey == "" {
-		return uploadState{}, errors.New("trackers: CZT missing passkey")
-	}
-
-	category, err := resolveCategory(req.Meta)
-	if err != nil {
-		if requireCategory {
-			return uploadState{}, err
-		}
-		category = ""
-	}
-
-	fields := map[string]string{
-		"name": releaseName,
-	}
-	if category != "" {
-		fields["category"] = category
-	}
-	if strings.TrimSpace(mediaInfo) != "" {
-		fields["descr"] = mediaInfo
-	}
-	if strings.TrimSpace(userDescr) != "" {
-		fields["user_descr"] = userDescr
-	}
-	if imdb := imdbID(req.Meta); imdb != "" {
-		fields["imdb_id"] = imdb
-	}
-	// resolution/codec/container/source are validated server-side against the
-	// tracker's allowed value set; unknown values are dropped, not rejected.
-	if res := strings.TrimSpace(req.Meta.Release.Resolution); res != "" {
-		fields["resolution"] = res
-	}
-	if codec := firstCodec(req.Meta); codec != "" {
-		fields["codec"] = codec
-	}
-	if container := strings.TrimSpace(req.Meta.Container); container != "" {
-		fields["container"] = container
-	}
-	if source := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(req.Meta.Source, req.Meta.Release.Source)); source != "" {
-		fields["source"] = source
-	}
-	fields["passkey"] = passkey
-
-	return uploadState{
-		torrentPath: torrentPath,
-		description: userDescr,
-		releaseName: releaseName,
-		fields:      fields,
-		files: []commonhttp.FileField{{
-			FieldName: "file",
-			FileName:  releaseName + ".torrent",
-			Path:      torrentPath,
-		}},
-		endpoint:      baseURL + uploadPath,
-		baseURL:       baseURL,
-		questionnaire: categoryQuestionnaire(req.Meta),
-	}, nil
-}
-
-// uploadDescriptionAssets uses caller-prepared assets when available, falling
-// back to local resolution and an empty asset set on resolution failure.
-func uploadDescriptionAssets(ctx context.Context, req trackers.UploadRequest) trackers.DescriptionAssets {
-	if req.Assets != nil {
-		return *req.Assets
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		return trackers.DescriptionAssets{}
-	}
-	return assets
-}
-
-// persistReturnedTorrent decodes the tracker-returned base64 torrent, verifies
-// it parses as metainfo, and writes the registered torrent artifact with user
-// read/write permissions only. Cleanup errors after replacement return the
-// artifact path with a non-nil error so callers can avoid reporting it as
-// successfully persisted.
-func persistReturnedTorrent(req trackers.UploadRequest, b64 string) (string, error) {
-	if strings.TrimSpace(b64) == "" {
-		return "", errors.New("empty torrent_b64")
-	}
-	decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(b64))
-	if err != nil {
-		return "", fmt.Errorf("decode torrent_b64: %w", err)
-	}
-	if len(decoded) == 0 {
-		return "", errors.New("decoded torrent_b64 is empty")
-	}
-	torrentMeta, err := metainfo.Load(bytes.NewReader(decoded))
-	if err != nil {
-		return "", fmt.Errorf("load returned torrent: %w", err)
-	}
-	if _, err := torrentMeta.UnmarshalInfo(); err != nil {
-		return "", fmt.Errorf("unmarshal returned torrent info: %w", err)
-	}
-	path, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName)
-	if err != nil {
-		return "", fmt.Errorf("resolve returned torrent path: %w", err)
-	}
-	if err := writeReturnedTorrent(path, decoded); err != nil {
-		var cleanupErr returnedTorrentCleanupError
-		if errors.As(err, &cleanupErr) {
-			return path, fmt.Errorf("write returned torrent: %w", err)
-		}
-		return "", fmt.Errorf("write returned torrent: %w", err)
-	}
-	return path, nil
-}
-
-// writeReturnedTorrent stages returned torrent bytes in the destination
-// directory before replacing the final artifact path, so a failed write does
-// not truncate an existing registered torrent.
-func writeReturnedTorrent(path string, data []byte) error {
-	dir := filepath.Dir(path)
-	tmpFile, err := os.CreateTemp(dir, filepath.Base(path)+".tmp-*")
-	if err != nil {
-		return fmt.Errorf("create temp returned torrent: %w", err)
-	}
-	tmpPath := tmpFile.Name()
-	removeTemp := true
-	defer func() {
-		if removeTemp {
-			_ = os.Remove(tmpPath)
-		}
-	}()
-
-	if err := tmpFile.Chmod(0o600); err != nil {
-		_ = tmpFile.Close()
-		return fmt.Errorf("chmod temp returned torrent: %w", err)
-	}
-	if _, err := tmpFile.Write(data); err != nil {
-		_ = tmpFile.Close()
-		return fmt.Errorf("write temp returned torrent: %w", err)
-	}
-	if err := tmpFile.Sync(); err != nil {
-		_ = tmpFile.Close()
-		return fmt.Errorf("sync temp returned torrent: %w", err)
-	}
-	if err := tmpFile.Close(); err != nil {
-		return fmt.Errorf("close temp returned torrent: %w", err)
-	}
-	if err := replaceStagedReturnedTorrent(tmpPath, path); err != nil {
-		return err
-	}
-	removeTemp = false
-	return nil
-}
-
-// replaceStagedReturnedTorrent moves a staged torrent into place. Existing
-// artifacts are first moved to a temporary backup and restored if the final
-// rename fails.
-func replaceStagedReturnedTorrent(tmpPath string, outputPath string) error {
-	info, err := os.Stat(outputPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			if renameErr := os.Rename(tmpPath, outputPath); renameErr != nil {
-				return fmt.Errorf("rename staged returned torrent into place: %w", renameErr)
-			}
-			return nil
-		}
-		return fmt.Errorf("stat returned torrent: %w", err)
-	}
-	if info.IsDir() {
-		return fmt.Errorf("%s is a directory", outputPath)
-	}
-
-	backupPath, err := reserveReturnedTorrentBackupPath(filepath.Dir(outputPath), filepath.Base(outputPath)+".backup-*")
-	if err != nil {
-		return err
-	}
-	if err := os.Rename(outputPath, backupPath); err != nil {
-		_ = os.Remove(backupPath)
-		return fmt.Errorf("backup existing returned torrent: %w", err)
-	}
-	if err := os.Rename(tmpPath, outputPath); err != nil {
-		restoreErr := os.Rename(backupPath, outputPath)
-		if restoreErr != nil {
-			return errors.Join(err, fmt.Errorf("restore existing returned torrent: %w", restoreErr))
-		}
-		return fmt.Errorf("replace existing returned torrent: %w", err)
-	}
-	if err := removeReturnedTorrentBackup(backupPath); err != nil {
-		return returnedTorrentCleanupError{cause: fmt.Errorf("remove returned torrent backup: %w", err)}
-	}
-	return nil
-}
-
-type returnedTorrentCleanupError struct {
-	cause error
-}
-
-func (e returnedTorrentCleanupError) Error() string {
-	return e.cause.Error()
-}
-
-func (e returnedTorrentCleanupError) Unwrap() error {
-	return e.cause
-}
-
-var removeReturnedTorrentBackup = os.Remove
-
-// reserveReturnedTorrentBackupPath reserves and releases a same-directory path
-// suitable for temporarily holding the existing registered torrent.
-func reserveReturnedTorrentBackupPath(dir string, pattern string) (string, error) {
-	file, err := os.CreateTemp(dir, pattern)
-	if err != nil {
-		return "", fmt.Errorf("create temp returned torrent backup marker: %w", err)
-	}
-	path := file.Name()
-	closeErr := file.Close()
-	removeErr := os.Remove(path)
-	if closeErr != nil || removeErr != nil {
-		return "", errors.Join(closeErr, removeErr)
-	}
-	return path, nil
-}
-
-// buildMediaInfo returns the raw MediaInfo/BDInfo text for the CZTeam `descr`
-// field.
-func buildMediaInfo(req trackers.UploadRequest) string {
-	return strings.TrimSpace(trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, req.Meta))
-}
-
-// buildDescription assembles the CZTeam `user_descr` body: the (possibly
-// user-edited) description text followed by a BBCode screenshot block. Kept as a
-// separate function so definition.BuildDescription can drive the description
-// builder UI with the same output.
-func buildDescription(_ trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	// A "final" description is the already-assembled body (saved override or
-	// canonical group description) with screenshots embedded; the resolver does
-	// not clear assets.Screenshots here, so re-appending would duplicate them.
-	// Use it verbatim, matching the assets.Final convention other impls follow.
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	parts := make([]string, 0, 2)
-	if body := strings.TrimSpace(assets.Description); body != "" {
-		parts = append(parts, body)
-	}
-	if shots := bbcodeScreenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-	return strings.TrimSpace(strings.Join(parts, "\n\n"))
-}
-
-// bbcodeScreenshotBlock renders at most two raw screenshot image URLs. CZTeam's
-// formatter accepts plain [img] tags here; linked/thumbnail URLs are ignored.
-func bbcodeScreenshotBlock(images []api.ScreenshotImage) string {
-	parts := make([]string, 0, 2)
-	for _, image := range images {
-		raw := strings.TrimSpace(image.RawURL)
-		if raw == "" {
-			continue
-		}
-		parts = append(parts, "[img]"+raw+"[/img]")
-		if len(parts) == 2 {
-			break
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-// resolveBaseURL returns the fixed CZTeam origin used for upload, details, and
-// returned download URLs. CZTeam is not a tracker family/configurable endpoint.
-func resolveBaseURL() string {
-	if trimmed := strings.TrimRight(strings.TrimSpace(cztBaseURL), "/"); trimmed != "" {
-		return trimmed
-	}
-	return defaultBaseURL
-}
-
-// joinCZTURL resolves a tracker-provided download URL against the CZTeam base
-// URL, strips URL userinfo, and rejects empty, non-addressable, or
-// cross-host results.
-func joinCZTURL(baseURL string, rawRef string) (string, error) {
-	trimmedRef := strings.TrimSpace(rawRef)
-	if trimmedRef == "" {
-		return "", errors.New("empty URL")
-	}
-	base, err := url.Parse(resolveCZTURLBase(baseURL) + "/")
-	if err != nil {
-		return "", fmt.Errorf("parse base URL: %w", err)
-	}
-	if base.Scheme == "" || base.Host == "" {
-		return "", errors.New("base URL must be absolute")
-	}
-	ref, err := url.Parse(trimmedRef)
-	if err != nil {
-		return "", fmt.Errorf("parse URL: %w", err)
-	}
-	resolved := base.ResolveReference(ref)
-	if resolved.Scheme == "" || resolved.Host == "" {
-		return "", errors.New("resolved URL must be absolute")
-	}
-	if !strings.EqualFold(resolved.Scheme, base.Scheme) || !strings.EqualFold(resolved.Host, base.Host) {
-		return "", errors.New("resolved URL must stay on configured CZT host")
-	}
-	if !hasUsableCZTDownloadPath(resolved.Path) {
-		return "", errors.New("resolved URL has no torrent path")
-	}
-	resolved.User = nil
-	return resolved.String(), nil
-}
-
-func hasUsableCZTDownloadPath(path string) bool {
-	trimmed := strings.TrimSpace(path)
-	return trimmed != "" && trimmed != "/"
-}
-
-// resolveCZTURLBase normalizes a base URL before resolving tracker-provided
-// relative download URLs against it.
-func resolveCZTURLBase(baseURL string) string {
-	trimmed := strings.TrimSpace(baseURL)
-	parsed, err := url.Parse(trimmed)
-	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-		return strings.TrimRight(trimmed, "/")
-	}
-	parsed.Path = ""
-	parsed.RawPath = ""
-	parsed.RawQuery = ""
-	parsed.ForceQuery = false
-	parsed.Fragment = ""
-	parsed.User = nil
-	return strings.TrimRight(parsed.String(), "/")
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.SceneName); name != "" {
-		return name
-	}
-	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename))
-}
-
-// cztCategory pairs a CZTeam categories.id with its display name.
-type cztCategory struct {
-	id   string
-	name string
-}
-
-// cztCategories lists CZTeam upload categories for the upload-time override
-// dropdown. upbrr auto-detects only video categories from metadata; everything
-// else (software, games, music, XXX, images, docs, …) is chosen here.
-var cztCategories = []cztCategory{
-	{"1", "XxX"},
-	{"4", "Games/PC ISO"},
-	{"5", "TvEps/HD"},
-	{"6", "Music/Audio"},
-	{"7", "TvEps"},
-	{"9", "Mobile"},
-	{"12", "Games/Consoles"},
-	{"19", "Movies/XviD"},
-	{"20", "Movies/DVD-R"},
-	{"21", "Games/PC Rips"},
-	{"22", "Software"},
-	{"23", "Anime"},
-	{"24", "Images"},
-	{"25", "Docs"},
-	{"28", "Movies/DVD-RO"},
-	{"29", "Movies/HD"},
-	{"30", "Music/MVID"},
-	{"31", "MAC"},
-	{"32", "Sports"},
-	{"33", "Movies/HDTV-RO"},
-	{"34", "TvEps/HD-RO"},
-	{"35", "Music/Lossless"},
-	{"36", "Full BluRay-RO"},
-	{"37", "Movies/3D"},
-	{"38", "Movies-RO"},
-}
-
-func categoryNames() []string {
-	out := make([]string, 0, len(cztCategories))
-	for _, c := range cztCategories {
-		out = append(out, c.name)
-	}
-	return out
-}
-
-func categoryIDForName(name string) string {
-	name = strings.TrimSpace(name)
-	for _, c := range cztCategories {
-		if strings.EqualFold(c.name, name) {
-			return c.id
-		}
-	}
-	return ""
-}
-
-func categoryNameForID(id string) string {
-	for _, c := range cztCategories {
-		if c.id == id {
-			return c.name
-		}
-	}
-	return ""
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers[trackerName]
-}
-
-// categoryQuestionnaire offers a (non-blocking) category dropdown pre-filled
-// with the auto-detected category, so the user can override it for content
-// upbrr can't classify from video metadata.
-func categoryQuestionnaire(meta api.PreparedMetadata) *api.TrackerQuestionnaire {
-	auto := autoCategory(meta)
-	return &api.TrackerQuestionnaire{
-		Tracker: trackerName,
-		Fields: []api.TrackerQuestionnaireField{{
-			Key:      "category",
-			Label:    "Category",
-			Kind:     "select",
-			Options:  categoryNames(),
-			Value:    categoryNameForID(auto),
-			Help:     "Auto-detected from video metadata. Override for software, games, music, XXX, etc.",
-			Required: auto == "",
-		}},
-	}
-}
-
-// resolveCategory returns the CZTeam category id: an explicit questionnaire
-// override when the user picked one, otherwise the auto-detected video category.
-func resolveCategory(meta api.PreparedMetadata) (string, error) {
-	if id := resolveQuestionnaireCategory(questionnaireAnswers(meta)["category"]); id != "" {
-		return id, nil
-	}
-	if id := autoCategory(meta); id != "" {
-		return id, nil
-	}
-	return "", errors.New("trackers: CZT category requires explicit questionnaire selection for non-video content")
-}
-
-func resolveQuestionnaireCategory(value string) string {
-	if id := categoryIDForName(value); id != "" {
-		return id
-	}
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	for _, c := range cztCategories {
-		if c.id == trimmed {
-			return c.id
-		}
-	}
-	return ""
-}
-
-// autoCategory maps prepared metadata to a CZTeam numeric categories.id when
-// metadata supports automatic classification. Unknown non-video content returns
-// empty so callers can require an explicit questionnaire category instead of
-// falling back to a movie bucket.
-func autoCategory(meta api.PreparedMetadata) string {
-	if id, ok := nonVideoCategory(meta); ok {
-		return id
-	}
-
-	ro := hasRomanianSubs(meta)
-	hd := isHD(meta.Release.Resolution)
-
-	switch {
-	case meta.Anime:
-		return "23" // Anime
-	case isTV(meta):
-		if hd && ro {
-			return "34" // TvEps/HD-RO
-		}
-		if hd {
-			return "5" // TvEps/HD
-		}
-		return "7" // TvEps (no SD-RO TV category exists)
-	}
-
-	// Movies.
-	src := strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.Source, meta.Release.Source))
-	isDVD := strings.Contains(src, "DVD") || strings.EqualFold(meta.DiscType, "DVD") || strings.EqualFold(meta.Type, "DVDRIP")
-	isFullBluRay := strings.EqualFold(meta.DiscType, "BDMV") ||
-		(strings.EqualFold(meta.Type, "REMUX") && strings.Contains(src, "BLURAY"))
-	if !hasMovieCategoryEvidence(meta, src) && !isDVD && !isFullBluRay {
-		return ""
-	}
-
-	if ro {
-		switch {
-		case isFullBluRay:
-			return "36" // Full BluRay-RO
-		case isDVD:
-			return "28" // Movies/DVD-RO
-		case hd:
-			return "33" // Movies/HDTV-RO
-		default:
-			return "38" // Movies-RO
-		}
-	}
-	switch {
-	case isDVD:
-		return "20" // Movies/DVD-R
-	case hd:
-		return "29" // Movies/HD
-	case hasCodec(meta, "XviD"):
-		return "19" // Movies/XviD
-	default:
-		return "29" // default to Movies/HD when movie evidence exists
-	}
-}
-
-func hasMovieCategoryEvidence(meta api.PreparedMetadata, upperSource string) bool {
-	for _, hint := range []string{meta.ExternalIDs.Category, meta.MediaInfoCategory, meta.Release.Category} {
-		normalized := normalizeCategoryHint(hint)
-		if isVideoCategoryHint(normalized) {
-			return true
-		}
-	}
-	return strings.TrimSpace(upperSource) != "" ||
-		strings.TrimSpace(meta.Release.Resolution) != "" ||
-		firstCodec(meta) != "" ||
-		strings.TrimSpace(meta.DiscType) != "" ||
-		strings.TrimSpace(meta.Type) != ""
-}
-
-// nonVideoCategory classifies explicit non-video category hints. Video hints are
-// ignored here so mixed hints can still use video classification; the boolean
-// reports whether a non-video hint was found even when it still requires a
-// manual questionnaire answer.
-func nonVideoCategory(meta api.PreparedMetadata) (string, bool) {
-	hints := []string{
-		meta.ExternalIDs.Category,
-		meta.MediaInfoCategory,
-		meta.Release.Category,
-	}
-	for _, hint := range hints {
-		normalized := normalizeCategoryHint(hint)
-		if normalized == "" {
-			continue
-		}
-		if isMusicVideoCategoryHint(normalized) {
-			return "30", true
-		}
-		switch {
-		case hasCategoryHintToken(normalized, "anime"):
-			return "23", true
-		case hasCategoryHintToken(normalized, "xxx", "adult"):
-			return "1", true
-		case isVideoCategoryHint(normalized):
-			continue
-		case hasCategoryHintToken(normalized, "console", "consoles"):
-			return "12", true
-		case hasCategoryHintToken(normalized, "game", "games"):
-			return "4", true
-		case hasCategoryHintToken(normalized, "lossless", "flac"):
-			return "35", true
-		case hasCategoryHintToken(normalized, "music", "audio"):
-			return "6", true
-		case hasCategoryHintToken(normalized, "software", "app", "apps", "application", "applications"):
-			return "22", true
-		case hasCategoryHintToken(normalized, "mobile", "android", "ios"):
-			return "9", true
-		case hasCategoryHintToken(normalized, "image", "images", "photo", "photos"):
-			return "24", true
-		case hasCategoryHintToken(normalized, "doc", "docs", "book", "books", "ebook", "ebooks"):
-			return "25", true
-		case hasCategoryHintToken(normalized, "mac"):
-			return "31", true
-		case hasCategoryHintToken(normalized, "sport", "sports"):
-			return "32", true
-		default:
-			return "", true
-		}
-	}
-	return "", false
-}
-
-func missingRequiredCategory(state uploadState) bool {
-	if state.questionnaire == nil {
-		return false
-	}
-	if strings.TrimSpace(state.fields["category"]) != "" {
-		return false
-	}
-	for _, field := range state.questionnaire.Fields {
-		if field.Key == "category" && field.Required {
-			return true
-		}
-	}
-	return false
-}
-
-func normalizeCategoryHint(value string) string {
-	replacer := strings.NewReplacer("-", " ", "_", " ", ".", " ", "/", " ", "\\", " ", ":", " ")
-	return strings.ToLower(strings.TrimSpace(replacer.Replace(value)))
-}
-
-func isMusicVideoCategoryHint(value string) bool {
-	fields := strings.Fields(value)
-	for i, field := range fields {
-		if field == "mvid" {
-			return true
-		}
-		if field == "music" && i+1 < len(fields) && fields[i+1] == "video" {
-			return true
-		}
-	}
-	compact := strings.Join(fields, "")
-	return strings.Contains(compact, "musicvideo") || strings.Contains(compact, "mvid")
-}
-
-func isVideoCategoryHint(value string) bool {
-	return hasCategoryHintToken(value, "movie", "movies", "film", "films", "tv", "tveps", "episode", "episodes", "anime", "video", "videos", "documentary", "documentaries")
-}
-
-func hasCategoryHintToken(value string, want ...string) bool {
-	for field := range strings.FieldsSeq(value) {
-		if slices.Contains(want, field) {
-			return true
-		}
-	}
-	return false
-}
-
-func hasRomanianSubs(meta api.PreparedMetadata) bool {
-	for _, s := range meta.SubtitleLanguages {
-		v := strings.ToLower(strings.TrimSpace(s))
-		if v == "ro" || v == "rum" || v == "ron" || strings.HasPrefix(v, "roman") {
-			return true
-		}
-	}
-	return false
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
-
-func isHD(res string) bool {
-	res = strings.TrimSpace(res)
-	for _, prefix := range []string{"720", "1080", "2160", "4320"} {
-		if strings.HasPrefix(res, prefix) {
-			return true
-		}
-	}
-	return false
-}
-
-func hasCodec(meta api.PreparedMetadata, want string) bool {
-	for _, c := range meta.Release.Codec {
-		if strings.EqualFold(strings.TrimSpace(c), want) {
-			return true
-		}
-	}
-	return false
-}
-
-func firstCodec(meta api.PreparedMetadata) string {
-	for _, c := range meta.Release.Codec {
-		if v := strings.TrimSpace(c); v != "" {
-			return v
-		}
-	}
-	return ""
-}
-
-func imdbID(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
diff --git a/internal/trackers/impl/czt/upload_test.go b/internal/trackers/impl/czt/upload_test.go
deleted file mode 100644
index 6c251c16..00000000
--- a/internal/trackers/impl/czt/upload_test.go
+++ /dev/null
@@ -1,1060 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package czt
-
-import (
-	"context"
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	mkbrr "github.com/autobrr/mkbrr/torrent"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestUploadSuccessPersistsReturnedTorrentAndUsesProvidedAssets(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	server.assertNoHandlerError(t)
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected one uploaded torrent, got %+v", result)
-	}
-	uploaded := result.UploadedTorrents[0]
-	if uploaded.TorrentURL != server.URL+"/details.php?id=123" {
-		t.Fatalf("unexpected torrent URL: %q", uploaded.TorrentURL)
-	}
-	if uploaded.DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("unexpected download URL: %q", uploaded.DownloadURL)
-	}
-	if strings.TrimSpace(uploaded.TorrentPath) == "" {
-		t.Fatal("expected persisted returned torrent path")
-	}
-	payload, err := os.ReadFile(uploaded.TorrentPath)
-	if err != nil {
-		t.Fatalf("read persisted torrent: %v", err)
-	}
-	if string(payload) != string(returnedTorrent) {
-		t.Fatalf("persisted torrent did not match returned bytes")
-	}
-}
-
-func TestUploadIgnoresStaleConfigURLAndAPIKey(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
-	defer server.Close()
-
-	req := cztUploadRequest(t, server.URL)
-	req.TrackerConfig.URL = "https://unused.example"
-	req.TrackerConfig.APIKey = "stale-api-key"
-
-	result, err := upload(context.Background(), req)
-	server.assertNoHandlerError(t)
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected upload success, got %+v", result)
-	}
-}
-
-func TestUploadRequiresPasskey(t *testing.T) {
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		w.WriteHeader(http.StatusCreated)
-	}))
-	defer server.Close()
-
-	req := cztUploadRequest(t, server.URL)
-	req.TrackerConfig.Passkey = ""
-
-	result, err := upload(context.Background(), req)
-	if err == nil {
-		t.Fatal("expected missing passkey error")
-	}
-	if !strings.Contains(err.Error(), "missing passkey") {
-		t.Fatalf("expected missing passkey error, got %v", err)
-	}
-	if requests.Load() != 0 {
-		t.Fatalf("expected no remote request without passkey, got %d", requests.Load())
-	}
-	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no uploaded result, got %+v", result)
-	}
-}
-
-func TestUploadTestServerReportsHandlerAssertionOnTestGoroutine(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	server := newCZTUploadTestServer(t, returnedTorrent, "/wrong-upload-path")
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	server.assertHandlerErrorContains(t, `expected upload path "/wrong-upload-path"`)
-	if err == nil {
-		t.Fatal("expected upload error")
-	}
-	if !strings.Contains(err.Error(), "status=400") {
-		t.Fatalf("expected HTTP 400 upload error, got %v", err)
-	}
-	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no uploaded result on handler assertion failure, got %+v", result)
-	}
-}
-
-func TestUploadReportsRemoteSuccessWhenReturnedTorrentB64IsInvalid(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":"not-base64"}`))
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success without artifact failure, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentPath != "" {
-		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-}
-
-func TestUploadReportsRemoteSuccessWhenReturnedTorrentB64IsEmpty(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":" "}`))
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success without artifact failure, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentPath != "" {
-		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-}
-
-func TestUploadReportsRemoteSuccessWhenReturnedTorrentIsCorrupt(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":%q}`,
-			base64.StdEncoding.EncodeToString([]byte("registered-torrent")),
-		)
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success without artifact failure, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentPath != "" {
-		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-}
-
-func TestUploadReportsRemoteSuccessWhenDownloadURLIsOffsite(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"id":123,"name":"Release","download_url":"https://evil.example/download.php?id=123","torrent_b64":%q}`,
-			base64.StdEncoding.EncodeToString(returnedTorrent),
-		)
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success with artifact, got %+v", result)
-	}
-	if result.UploadedTorrents[0].DownloadURL != "" {
-		t.Fatalf("expected rejected download URL to be omitted, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-	if strings.TrimSpace(result.UploadedTorrents[0].TorrentPath) == "" {
-		t.Fatal("expected persisted returned torrent path")
-	}
-}
-
-func TestUploadKeepsRemoteSuccessWhenNoInjectableArtifactExists(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"https://evil.example/download.php?id=123","torrent_b64":"not-base64"}`))
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected remote success count without injectable artifacts, got %+v", result)
-	}
-	if len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no injectable artifact entry, got %+v", result.UploadedTorrents)
-	}
-}
-
-func TestUploadResponseParseBoundaries(t *testing.T) {
-	tests := []struct {
-		name       string
-		statusCode int
-		body       string
-		want       string
-	}{
-		{
-			name:       "malformed 201",
-			statusCode: http.StatusCreated,
-			body:       `{`,
-			want:       "parse upload response",
-		},
-		{
-			name:       "malformed non-201 stays http failure",
-			statusCode: http.StatusInternalServerError,
-			body:       `{`,
-			want:       "status=500",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(tt.statusCode)
-				_, _ = w.Write([]byte(tt.body))
-			}))
-			defer server.Close()
-
-			_, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-			if err == nil {
-				t.Fatal("expected upload error")
-			}
-			if !strings.Contains(err.Error(), tt.want) {
-				t.Fatalf("expected error containing %q, got %v", tt.want, err)
-			}
-		})
-	}
-}
-
-func TestCZTUploadDecodeErrorsAreRedacted(t *testing.T) {
-	err := redactCZTUploadDecodeError("decode CZT upload response fields", errors.New("api_key=secret-passkey Cookie=session-token"))
-	if err == nil {
-		t.Fatal("expected redacted error")
-	}
-	got := err.Error()
-	if strings.Contains(got, "secret-passkey") || strings.Contains(got, "session-token") {
-		t.Fatalf("expected redacted decode error")
-	}
-	if !strings.Contains(got, "decode CZT upload response fields") || !strings.Contains(got, "[REDACTED]") {
-		t.Fatalf("expected context and redaction marker, got %q", got)
-	}
-
-	if _, err := parseCZTUploadID([]byte(`{`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response fields") {
-		t.Fatalf("expected redacted fields decode path, got %v", err)
-	}
-	if _, err := parseCZTUploadID([]byte(`{"id":"bad"}`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response id") {
-		t.Fatalf("expected redacted id decode path, got %v", err)
-	}
-	if _, err := parseCZTUploadResponse([]byte(`{`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response fields") {
-		t.Fatalf("expected redacted response fields decode path, got %v", err)
-	}
-	if _, err := parseCZTUploadResponse([]byte(`{"id":"bad"}`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response id") {
-		t.Fatalf("expected redacted response id decode path, got %v", err)
-	}
-	if _, err := parseCZTUploadResponse([]byte(`{"id":123,"error":{"api_key":"secret-passkey"}}`)); err == nil {
-		t.Fatal("expected redacted optional field decode path")
-	} else if got := err.Error(); !strings.Contains(got, "error") || !strings.Contains(got, "[REDACTED]") || strings.Contains(got, "secret-passkey") {
-		t.Fatalf("expected redacted optional field decode error, got %q", got)
-	}
-}
-
-func TestUploadSuccessParsesLargeResponse(t *testing.T) {
-	padding := strings.Repeat("a", 70*1024)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"name":%q,"id":123,"download_url":"/download.php?id=123","torrent_b64":" "}`,
-			padding,
-		)
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success without artifact failure, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentID != "123" {
-		t.Fatalf("expected torrent ID 123, got %q", result.UploadedTorrents[0].TorrentID)
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected download URL from large response, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-}
-
-func TestUploadResponseBadLocalFieldPreservesRemoteSuccess(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = w.Write([]byte(`{"id":123,"download_url":"/download.php?id=123","torrent_b64":123}`))
-	}))
-	defer server.Close()
-
-	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success without artifact, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentID != "123" || result.UploadedTorrents[0].TorrentPath != "" {
-		t.Fatalf("unexpected uploaded torrent: %+v", result.UploadedTorrents[0])
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected usable download URL despite bad local field, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-}
-
-func TestUploadPreCanceledContextStopsBeforeRemoteRequest(t *testing.T) {
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	result, err := upload(ctx, cztUploadRequest(t, server.URL))
-	if err == nil {
-		t.Fatal("expected cancellation error")
-	}
-	if !strings.Contains(err.Error(), "context canceled") {
-		t.Fatalf("expected context cancellation error, got %v", err)
-	}
-	if requests.Load() != 0 {
-		t.Fatalf("expected no remote request after pre-send cancellation, got %d", requests.Load())
-	}
-	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no uploaded result after pre-send cancellation, got %+v", result)
-	}
-}
-
-func TestUploadCancellationAfterRequestBuildStopsBeforeRemoteRequest(t *testing.T) {
-	var requests atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer server.Close()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	originalFactory := newCZTUploadHTTPClient
-	newCZTUploadHTTPClient = func() *http.Client {
-		cancel()
-		return server.Client()
-	}
-	t.Cleanup(func() {
-		newCZTUploadHTTPClient = originalFactory
-	})
-
-	result, err := upload(ctx, cztUploadRequest(t, server.URL))
-	if err == nil {
-		t.Fatal("expected cancellation error")
-	}
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected context cancellation error, got %v", err)
-	}
-	if requests.Load() != 0 {
-		t.Fatalf("expected no remote request after post-build cancellation, got %d", requests.Load())
-	}
-	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no uploaded result after post-build cancellation, got %+v", result)
-	}
-}
-
-func TestUploadCancellationAfterResponsePreservesRemoteSuccessWithoutPersistingArtifact(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"id":123,"name":"Release","download_url":"download.php?id=123","torrent_b64":%q}`,
-			base64.StdEncoding.EncodeToString(returnedTorrent),
-		)
-		if flusher, ok := w.(http.Flusher); ok {
-			flusher.Flush()
-		}
-		cancel()
-	}))
-	defer server.Close()
-
-	req := cztUploadRequest(t, server.URL)
-	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName)
-	if err != nil {
-		t.Fatalf("resolve artifact path: %v", err)
-	}
-	result, err := upload(ctx, req)
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success after cancellation, got %+v", result)
-	}
-	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
-		t.Fatalf("expected download URL preserved, got %q", result.UploadedTorrents[0].DownloadURL)
-	}
-	if result.UploadedTorrents[0].TorrentPath != "" {
-		t.Fatalf("expected no persisted artifact path, got %q", result.UploadedTorrents[0].TorrentPath)
-	}
-	if _, statErr := os.Stat(artifactPath); !os.IsNotExist(statErr) {
-		t.Fatalf("expected no persisted artifact, stat err=%v", statErr)
-	}
-}
-
-func TestUploadCancellationBeforeNonCreatedResponseReturnsCancellation(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		cancel()
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte(`{"error":"failed"}`))
-	}))
-	defer server.Close()
-
-	result, err := upload(ctx, cztUploadRequest(t, server.URL))
-	if err == nil {
-		t.Fatal("expected cancellation error")
-	}
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected context cancellation error, got %v", err)
-	}
-	if strings.Contains(err.Error(), "status=500") {
-		t.Fatalf("expected cancellation before HTTP error, got %v", err)
-	}
-	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected no uploaded result after non-201 cancellation, got %+v", result)
-	}
-}
-
-func TestUploadCancellationDuringPostCancelsBeforeUploadTimeout(t *testing.T) {
-	oldGrace := cztPostCancelGrace.Swap(int64(25 * time.Millisecond))
-	t.Cleanup(func() {
-		cztPostCancelGrace.Store(oldGrace)
-	})
-
-	requestStarted := make(chan struct{})
-	releaseHandler := make(chan struct{})
-	server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
-		close(requestStarted)
-		select {
-		case <-r.Context().Done():
-		case <-releaseHandler:
-		}
-	}))
-	defer server.Close()
-	defer close(releaseHandler)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	req := cztUploadRequest(t, server.URL)
-	done := make(chan struct {
-		summary api.UploadSummary
-		err     error
-	}, 1)
-	go func() {
-		summary, err := upload(ctx, req)
-		done <- struct {
-			summary api.UploadSummary
-			err     error
-		}{summary: summary, err: err}
-	}()
-
-	select {
-	case <-requestStarted:
-	case <-time.After(time.Second):
-		t.Fatal("expected remote request to start")
-	}
-
-	started := time.Now()
-	cancel()
-	select {
-	case result := <-done:
-		if result.err == nil {
-			t.Fatal("expected cancellation error")
-		}
-		if !errors.Is(result.err, context.Canceled) {
-			t.Fatalf("expected context cancellation error, got %v", result.err)
-		}
-		if result.summary.Uploaded != 0 || len(result.summary.UploadedTorrents) != 0 {
-			t.Fatalf("expected no uploaded result after canceled POST, got %+v", result.summary)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("expected canceled POST to return before upload timeout")
-	}
-	if elapsed := time.Since(started); elapsed >= time.Second {
-		t.Fatalf("expected canceled POST below upload timeout, elapsed %s", elapsed)
-	}
-}
-
-func TestUploadCancellationAfterPersistPreservesArtifactSummary(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
-	defer server.Close()
-
-	req := cztUploadRequest(t, server.URL)
-	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName)
-	if err != nil {
-		t.Fatalf("resolve artifact path: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
-		t.Fatalf("create artifact dir: %v", err)
-	}
-	if err := os.WriteFile(artifactPath, []byte("existing artifact"), 0o600); err != nil {
-		t.Fatalf("write existing artifact: %v", err)
-	}
-
-	oldRemove := removeReturnedTorrentBackup
-	removeReturnedTorrentBackup = func(path string) error {
-		err := oldRemove(path)
-		if strings.Contains(filepath.Base(path), ".backup-") {
-			cancel()
-		}
-		return err
-	}
-	defer func() {
-		removeReturnedTorrentBackup = oldRemove
-	}()
-
-	result, err := upload(ctx, req)
-	server.assertNoHandlerError(t)
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected remote success with artifact after cancellation, got %+v", result)
-	}
-	if result.UploadedTorrents[0].TorrentPath != artifactPath {
-		t.Fatalf("expected artifact path %q, got %q", artifactPath, result.UploadedTorrents[0].TorrentPath)
-	}
-}
-
-func TestReplaceStagedReturnedTorrentRestoresExistingOnFailure(t *testing.T) {
-	tmp := t.TempDir()
-	outputPath := filepath.Join(tmp, "registered.torrent")
-	original := []byte("existing artifact")
-	if err := os.WriteFile(outputPath, original, 0o600); err != nil {
-		t.Fatalf("write existing artifact: %v", err)
-	}
-
-	err := replaceStagedReturnedTorrent(filepath.Join(tmp, "missing.tmp"), outputPath)
-	if err == nil {
-		t.Fatal("expected replacement error")
-	}
-	got, readErr := os.ReadFile(outputPath)
-	if readErr != nil {
-		t.Fatalf("read restored artifact: %v", readErr)
-	}
-	if string(got) != string(original) {
-		t.Fatalf("expected existing artifact preserved, got %q", got)
-	}
-}
-
-func TestUploadOmitsArtifactPathWhenBackupCleanupFails(t *testing.T) {
-	returnedTorrent := validTorrentBytes(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"id":123,"name":"Release","torrent_b64":%q}`,
-			base64.StdEncoding.EncodeToString(returnedTorrent),
-		)
-	}))
-	defer server.Close()
-
-	req := cztUploadRequest(t, server.URL)
-	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName)
-	if err != nil {
-		t.Fatalf("resolve artifact path: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
-		t.Fatalf("create artifact dir: %v", err)
-	}
-	if err := os.WriteFile(artifactPath, []byte("existing artifact"), 0o600); err != nil {
-		t.Fatalf("write existing artifact: %v", err)
-	}
-
-	oldRemove := removeReturnedTorrentBackup
-	removeReturnedTorrentBackup = func(path string) error {
-		if strings.Contains(filepath.Base(path), ".backup-") {
-			return os.ErrPermission
-		}
-		return oldRemove(path)
-	}
-	defer func() {
-		removeReturnedTorrentBackup = oldRemove
-	}()
-
-	result, err := upload(context.Background(), req)
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 || len(result.UploadedTorrents) != 0 {
-		t.Fatalf("expected cleanup-error artifact omitted while preserving remote success, got %+v", result)
-	}
-}
-
-func TestPersistReturnedTorrentReturnsPathWhenBackupCleanupFails(t *testing.T) {
-	req := cztUploadRequest(t, defaultBaseURL)
-	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, trackerName)
-	if err != nil {
-		t.Fatalf("resolve artifact path: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
-		t.Fatalf("create artifact dir: %v", err)
-	}
-	original := []byte("existing artifact")
-	if err := os.WriteFile(artifactPath, original, 0o600); err != nil {
-		t.Fatalf("write existing artifact: %v", err)
-	}
-
-	oldRemove := removeReturnedTorrentBackup
-	removeReturnedTorrentBackup = func(path string) error {
-		if strings.Contains(filepath.Base(path), ".backup-") {
-			return os.ErrPermission
-		}
-		return oldRemove(path)
-	}
-	defer func() {
-		removeReturnedTorrentBackup = oldRemove
-	}()
-
-	gotPath, err := persistReturnedTorrent(req, base64.StdEncoding.EncodeToString(validTorrentBytes(t)))
-	if err == nil {
-		t.Fatal("expected cleanup error")
-	}
-	var cleanupErr returnedTorrentCleanupError
-	if !errors.As(err, &cleanupErr) {
-		t.Fatalf("expected cleanup error, got %v", err)
-	}
-	if gotPath != artifactPath {
-		t.Fatalf("expected artifact path %q, got %q", artifactPath, gotPath)
-	}
-	payload, readErr := os.ReadFile(artifactPath)
-	if readErr != nil {
-		t.Fatalf("read artifact: %v", readErr)
-	}
-	if string(payload) == string(original) {
-		t.Fatal("expected replacement artifact to remain after cleanup failure")
-	}
-}
-
-func TestJoinCZTURL(t *testing.T) {
-	tests := []struct {
-		name    string
-		base    string
-		raw     string
-		want    string
-		wantErr bool
-	}{
-		{name: "leading slash", base: "https://czteam.me", raw: "/download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "no leading slash", base: "https://czteam.me", raw: "download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "same host absolute", base: "https://czteam.me", raw: "https://czteam.me/download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "base userinfo stripped", base: "https://user:pass@czteam.me", raw: "download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "same host absolute userinfo stripped", base: "https://czteam.me", raw: "https://user:pass@czteam.me/download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "same host scheme relative", base: "https://czteam.me", raw: "//czteam.me/download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "base path ignored", base: "https://czteam.me/nested/path?x=1", raw: "download.php?id=1", want: "https://czteam.me/download.php?id=1"},
-		{name: "absolute offsite", base: "https://czteam.me", raw: "https://cdn.example/download/1", wantErr: true},
-		{name: "scheme-relative offsite", base: "https://czteam.me", raw: "//cdn.example/download/1", wantErr: true},
-		{name: "same host wrong scheme", base: "https://czteam.me", raw: "http://czteam.me/download.php?id=1", wantErr: true},
-		{name: "root path", base: "https://czteam.me", raw: "/", wantErr: true},
-		{name: "root query", base: "https://czteam.me", raw: "/?id=1", wantErr: true},
-		{name: "query only", base: "https://czteam.me", raw: "?id=1", wantErr: true},
-		{name: "pathless", base: "https://czteam.me", raw: "https://czteam.me", wantErr: true},
-		{name: "empty", base: "https://czteam.me", raw: " ", wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := joinCZTURL(tt.base, tt.raw)
-			if tt.wantErr {
-				if err == nil {
-					t.Fatal("expected error")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if got != tt.want {
-				t.Fatalf("expected %q, got %q", tt.want, got)
-			}
-		})
-	}
-}
-
-func TestResolveCategoryMatrix(t *testing.T) {
-	tests := []struct {
-		name    string
-		meta    api.PreparedMetadata
-		want    string
-		wantErr bool
-	}{
-		{name: "display name answer", meta: api.PreparedMetadata{TrackerQuestionnaireAnswers: map[string]map[string]string{trackerName: {"category": "Software"}}}, want: "22"},
-		{name: "numeric answer", meta: api.PreparedMetadata{TrackerQuestionnaireAnswers: map[string]map[string]string{trackerName: {"category": "6"}}}, want: "6"},
-		{name: "movie hd", meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "MOVIE"}, Release: api.ReleaseInfo{Resolution: "1080p"}}, want: "29"},
-		{name: "tv hd ro", meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}, Release: api.ReleaseInfo{Resolution: "1080p"}, SeasonInt: 1, SubtitleLanguages: []string{"ro"}}, want: "34"},
-		{name: "anime", meta: api.PreparedMetadata{Anime: true}, want: "23"},
-		{name: "anime hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Anime-Video"}}, want: "23"},
-		{name: "video game hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "video-game"}}, want: "29"},
-		{name: "game video hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "game-video"}}, want: "29"},
-		{name: "game movie hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "game movie"}}, want: "29"},
-		{name: "videogame compound", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "videogame"}}, wantErr: true},
-		{name: "gameplay compound", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "gameplay"}}, wantErr: true},
-		{name: "console hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Games/Consoles"}}, want: "12"},
-		{name: "release source dvd", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Source: "DVD"}}, want: "20"},
-		{name: "documentary hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Documentary"}}, want: "29"},
-		{name: "movie documentary hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Movie Documentary"}}, want: "29"},
-		{name: "docs hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Docs"}}, want: "25"},
-		{name: "ebook hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "eBook"}}, want: "25"},
-		{name: "software", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Software"}}, want: "22"},
-		{name: "music", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Music/Audio"}}, want: "6"},
-		{name: "music video phrase", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Music Video"}}, want: "30"},
-		{name: "music video separator", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "music-video"}}, want: "30"},
-		{name: "music video dotted uppercase", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "MUSIC.VIDEO"}}, want: "30"},
-		{name: "mvid", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "MVID"}}, want: "30"},
-		{name: "generic video hint", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Video", Resolution: "1080p"}}, want: "29"},
-		{name: "no hints unknown metadata", meta: api.PreparedMetadata{}, wantErr: true},
-		{name: "unknown non-video", meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Other Data"}}, wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := resolveCategory(tt.meta)
-			if tt.wantErr {
-				if err == nil {
-					t.Fatal("expected category error")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if got != tt.want {
-				t.Fatalf("expected category %q, got %q", tt.want, got)
-			}
-		})
-	}
-}
-
-func TestCategoryQuestionnaireRequiresUnknownNonVideo(t *testing.T) {
-	questionnaire := categoryQuestionnaire(api.PreparedMetadata{Release: api.ReleaseInfo{Category: "Other Data"}})
-	if questionnaire == nil || len(questionnaire.Fields) != 1 {
-		t.Fatalf("expected one category questionnaire field, got %+v", questionnaire)
-	}
-	field := questionnaire.Fields[0]
-	if !field.Required {
-		t.Fatal("expected unknown non-video category to require an explicit answer")
-	}
-	if field.Value != "" {
-		t.Fatalf("expected no default category value, got %q", field.Value)
-	}
-}
-
-func TestBuildUploadDryRunBlocksMissingRequiredCategory(t *testing.T) {
-	req := cztUploadRequest(t, defaultBaseURL)
-	req.Meta.ExternalIDs.Category = ""
-	req.Meta.Release.Category = "Other Data"
-
-	entry, err := buildUploadDryRun(context.Background(), req)
-	if err != nil {
-		t.Fatalf("unexpected dry-run error: %v", err)
-	}
-	if entry.Status != "blocked" {
-		t.Fatalf("expected blocked dry-run status, got %q", entry.Status)
-	}
-	if !strings.Contains(entry.Message, "category questionnaire") {
-		t.Fatalf("expected category questionnaire message, got %q", entry.Message)
-	}
-	if _, ok := entry.Payload["category"]; ok {
-		t.Fatalf("expected unresolved category omitted from payload, got %q", entry.Payload["category"])
-	}
-	if entry.Questionnaire == nil || len(entry.Questionnaire.Fields) != 1 || !entry.Questionnaire.Fields[0].Required {
-		t.Fatalf("expected required category questionnaire, got %+v", entry.Questionnaire)
-	}
-
-	if _, err := prepareUploadState(context.Background(), req, true); err == nil {
-		t.Fatal("expected actual upload state to still require category")
-	}
-}
-
-func TestBuildDescriptionAndDryRunUseProvidedAssets(t *testing.T) {
-	req := cztUploadRequest(t, defaultBaseURL)
-
-	entry, err := buildUploadDryRun(context.Background(), req)
-	if err != nil {
-		t.Fatalf("unexpected dry-run error: %v", err)
-	}
-	if !strings.Contains(entry.Description, "[img]https://img.example/raw.jpg[/img]") {
-		t.Fatalf("expected provided screenshot in dry-run description, got %q", entry.Description)
-	}
-	if !strings.Contains(entry.Payload["user_descr"], "[img]https://img.example/raw.jpg[/img]") {
-		t.Fatalf("expected provided screenshot in dry-run payload, got %q", entry.Payload["user_descr"])
-	}
-	if strings.Contains(entry.Payload["user_descr"], "[url=") || strings.Contains(entry.Payload["user_descr"], "[center]") {
-		t.Fatalf("expected CZT screenshot BBCode to use only img tags, got %q", entry.Payload["user_descr"])
-	}
-
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "CZT",
-		Meta:    req.Meta,
-		Logger:  api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: "[center]final rewritten body[/center]",
-			Screenshots: []api.ScreenshotImage{{
-				ImgURL: "https://img.example/should-not-append.jpg",
-			}},
-			Final: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected description error: %v", err)
-	}
-	if result.Description != "[center]final rewritten body[/center]" {
-		t.Fatalf("expected final description verbatim, got %q", result.Description)
-	}
-}
-
-func TestBBCODEScreenshotBlockUsesRawURLsAndCapsAtTwo(t *testing.T) {
-	got := bbcodeScreenshotBlock([]api.ScreenshotImage{
-		{ImgURL: "https://img.example/rehosted-only.jpg", WebURL: "https://img.example/page-only"},
-		{ImgURL: "https://img.example/rehosted-1.jpg", WebURL: "https://img.example/page-1", RawURL: "https://img.example/raw-1.jpg"},
-		{ImgURL: "https://img.example/rehosted-2.jpg", WebURL: "https://img.example/page-2", RawURL: "https://img.example/raw-2.jpg"},
-		{ImgURL: "https://img.example/rehosted-3.jpg", WebURL: "https://img.example/page-3", RawURL: "https://img.example/raw-3.jpg"},
-	})
-	want := "[img]https://img.example/raw-1.jpg[/img]\n[img]https://img.example/raw-2.jpg[/img]"
-	if got != want {
-		t.Fatalf("unexpected screenshot block:\nwant %q\ngot  %q", want, got)
-	}
-	if strings.Contains(got, "[url=") || strings.Contains(got, "[center]") {
-		t.Fatalf("expected only img BBCode, got %q", got)
-	}
-	if strings.Contains(got, "rehosted") || strings.Contains(got, "page-") || strings.Contains(got, "raw-3") {
-		t.Fatalf("expected raw-only first two images, got %q", got)
-	}
-}
-
-func validTorrentBytes(t *testing.T) []byte {
-	t.Helper()
-	tmp := t.TempDir()
-	sourcePath := filepath.Join(tmp, "source.bin")
-	torrentPath := filepath.Join(tmp, "source.torrent")
-	if err := os.WriteFile(sourcePath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	_, err := mkbrr.Create(mkbrr.CreateOptions{
-		Path:       sourcePath,
-		OutputPath: torrentPath,
-		IsPrivate:  true,
-	})
-	if err != nil {
-		t.Fatalf("create torrent: %v", err)
-	}
-	payload, err := os.ReadFile(torrentPath)
-	if err != nil {
-		t.Fatalf("read torrent: %v", err)
-	}
-	return payload
-}
-
-type cztUploadTestServer struct {
-	*httptest.Server
-	handlerErr chan error
-}
-
-func newCZTUploadTestServer(t *testing.T, returnedTorrent []byte, expectedPath string) *cztUploadTestServer {
-	t.Helper()
-	handlerErr := make(chan error, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := assertCZTUploadRequest(r, expectedPath); err != nil {
-			recordCZTUploadHandlerError(handlerErr, err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		w.WriteHeader(http.StatusCreated)
-		_, _ = fmt.Fprintf(
-			w,
-			`{"id":123,"name":"Release","download_url":"download.php?id=123","torrent_b64":%q}`,
-			base64.StdEncoding.EncodeToString(returnedTorrent),
-		)
-	}))
-	return &cztUploadTestServer{Server: server, handlerErr: handlerErr}
-}
-
-func assertCZTUploadRequest(r *http.Request, expectedPath string) error {
-	if r.URL.Path != expectedPath {
-		return fmt.Errorf("expected upload path %q, got %q", expectedPath, r.URL.Path)
-	}
-	if got := r.Header.Get("Authorization"); got != "" {
-		return errors.New("expected no authorization header")
-	}
-	if err := r.ParseMultipartForm(5 << 20); err != nil {
-		return fmt.Errorf("parse multipart: %w", err)
-	}
-	if got := r.FormValue("passkey"); got != "pass" {
-		return errors.New("expected passkey form field")
-	}
-	if got := r.FormValue("user_descr"); !strings.Contains(got, "[img]https://img.example/raw.jpg[/img]") {
-		return fmt.Errorf("expected raw screenshot img tag in payload, got %q", got)
-	} else if strings.Contains(got, "[url=") || strings.Contains(got, "[center]") || strings.Contains(got, "rehosted.jpg") || strings.Contains(got, "page") {
-		return fmt.Errorf("expected only raw screenshot img tags in payload, got %q", got)
-	}
-	files := r.MultipartForm.File["file"]
-	if len(files) != 1 {
-		return fmt.Errorf("expected one torrent file, got %d", len(files))
-	}
-	file, err := files[0].Open()
-	if err != nil {
-		return fmt.Errorf("open multipart file: %w", err)
-	}
-	defer func() {
-		_ = file.Close()
-	}()
-	if _, err := io.ReadAll(file); err != nil {
-		return fmt.Errorf("read multipart file: %w", err)
-	}
-	return nil
-}
-
-func recordCZTUploadHandlerError(handlerErr chan<- error, err error) {
-	select {
-	case handlerErr <- err:
-	default:
-	}
-}
-
-func (s *cztUploadTestServer) assertNoHandlerError(t *testing.T) {
-	t.Helper()
-	if err := s.handlerError(); err != nil {
-		t.Fatalf("upload handler assertion: %v", err)
-	}
-}
-
-func (s *cztUploadTestServer) assertHandlerErrorContains(t *testing.T, want string) {
-	t.Helper()
-	err := s.handlerError()
-	if err == nil {
-		t.Fatal("expected upload handler assertion error")
-	}
-	if !strings.Contains(err.Error(), want) {
-		t.Fatalf("expected upload handler assertion containing %q, got %v", want, err)
-	}
-}
-
-func (s *cztUploadTestServer) handlerError() error {
-	select {
-	case err := <-s.handlerErr:
-		return err
-	default:
-		return nil
-	}
-}
-
-func cztUploadRequest(t *testing.T, trackerURL string) trackers.UploadRequest {
-	t.Helper()
-	if strings.TrimSpace(trackerURL) != "" {
-		withCZTBaseURL(t, trackerURL)
-	}
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "Release.torrent")
-	if err := os.WriteFile(torrentPath, []byte("source-torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	sourcePath := filepath.Join(tmp, "Release.mkv")
-	if err := os.WriteFile(sourcePath, []byte("video"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	return trackers.UploadRequest{
-		Tracker: "CZT",
-		Meta: api.PreparedMetadata{
-			SourcePath:  sourcePath,
-			TorrentPath: torrentPath,
-			ReleaseName: "Release.2026.1080p.WEB-DL",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Release:     api.ReleaseInfo{Resolution: "1080p"},
-		},
-		TrackerConfig: config.TrackerConfig{
-			Passkey: "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "state", "upbrr.db")}},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: "kept description",
-			Screenshots: []api.ScreenshotImage{{
-				ImgURL: "https://img.example/rehosted.jpg",
-				WebURL: "https://img.example/page",
-				RawURL: "https://img.example/raw.jpg",
-			}, {
-				ImgURL: "https://img.example/rehosted-2.jpg",
-				WebURL: "https://img.example/page-2",
-				RawURL: "https://img.example/raw-2.jpg",
-			}, {
-				ImgURL: "https://img.example/rehosted-3.jpg",
-				WebURL: "https://img.example/page-3",
-				RawURL: "https://img.example/raw-3.jpg",
-			}},
-		},
-	}
-}
-
-func withCZTBaseURL(t *testing.T, baseURL string) {
-	t.Helper()
-	old := cztBaseURL
-	cztBaseURL = baseURL
-	t.Cleanup(func() {
-		cztBaseURL = old
-	})
-}
diff --git a/internal/trackers/impl/czt_dupe_contract_test.go b/internal/trackers/impl/czt_dupe_contract_test.go
new file mode 100644
index 00000000..04c1f0bc
--- /dev/null
+++ b/internal/trackers/impl/czt_dupe_contract_test.go
@@ -0,0 +1,42 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestCZTServiceIgnoresAPIKeyOnlyConfig(t *testing.T) {
+	t.Parallel()
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"CZT": {APIKey: "bearer-token"}}}}
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("registry: %v", err)
+	}
+	svc := dupe.NewServiceWithRegistry(cfg, api.NopLogger{}, registry)
+	summary, err := svc.Check(context.Background(), api.DuplicateSubject{SourcePath: "source.mkv", Release: api.ReleaseInfo{Title: "Movie"}}, []string{"CZT"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(summary.Results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(summary.Results))
+	}
+	result := summary.Results[0]
+	if result.Status != "skipped" || !result.Skipped || result.Error != "" || result.SkipCode != dupe.NotRunMissingCredentials {
+		t.Fatalf("unexpected skipped result: %#v", result)
+	}
+	if !strings.Contains(result.SkipReason, "missing passkey") {
+		t.Fatalf("expected passkey skip, got %q", result.SkipReason)
+	}
+	if strings.Contains(result.SkipReason, "bearer-token") || strings.Contains(strings.Join(result.Notes, " "), "bearer-token") {
+		t.Fatalf("skip result leaked API key: %#v", result)
+	}
+}
diff --git a/internal/trackers/impl/data_contract_test.go b/internal/trackers/impl/data_contract_test.go
new file mode 100644
index 00000000..da8f7dff
--- /dev/null
+++ b/internal/trackers/impl/data_contract_test.go
@@ -0,0 +1,379 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	ptpimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/ptp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func unit3DTestConfig() config.Config {
+	return config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"BLU": {AnnounceURL: "https://blutopia.cc/announce"},
+	}}}
+}
+
+func newUnit3DDataClient(t *testing.T, httpClient *http.Client) *trackerdata.Client {
+	t.Helper()
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		t.Fatalf("create tracker registry: %v", err)
+	}
+	return trackerdata.NewClientWithRegistry(unit3DTestConfig(), api.NopLogger{}, httpClient, registry)
+}
+
+type rewriteHostTransport struct {
+	base *url.URL
+	rt   http.RoundTripper
+}
+
+func (t rewriteHostTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	clone := req.Clone(req.Context())
+	clone.URL.Scheme = t.base.Scheme
+	clone.URL.Host = t.base.Host
+	clone.Host = t.base.Host
+	resp, err := t.rt.RoundTrip(clone)
+	if err != nil {
+		return resp, fmt.Errorf("rewrite host round trip: %w", err)
+	}
+	return resp, nil
+}
+
+func TestLookupPTP(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/torrents.php":
+			switch {
+			case r.URL.Query().Get("torrentid") != "":
+				_ = json.NewEncoder(w).Encode(map[string]any{
+					"ImdbId": "1122334",
+					"Torrents": []any{
+						map[string]any{"Id": "777", "InfoHash": "abc123"},
+					},
+				})
+			case r.URL.Query().Get("action") == "get_description":
+				_, _ = w.Write([]byte("Desc\nhttps://pixhost.to/abc.png"))
+			default:
+				http.NotFound(w, r)
+			}
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	cfg := config.Config{
+		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"PTP": {PTPAPIUser: "user", PTPAPIKey: "key"},
+		}},
+	}
+	baseURL, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+	httpClient := server.Client()
+	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: httpClient.Transport}
+	registry := trackers.NewRegistry()
+	if err := registry.Register(ptpimpl.New()); err != nil {
+		t.Fatalf("register PTP: %v", err)
+	}
+	client := trackerdata.NewClientWithRegistry(cfg, api.NopLogger{}, httpClient, registry)
+
+	ptpResult, err := client.Lookup(context.Background(), "PTP", "777", api.UploadSubject{}, "release.mkv", false, true)
+	if err != nil {
+		t.Fatalf("ptp lookup failed: %v", err)
+	}
+	if ptpResult.IMDBID != 1122334 || ptpResult.TrackerID != "777" || ptpResult.InfoHash != "abc123" {
+		t.Fatalf("unexpected ptp result: %+v", ptpResult)
+	}
+	if ptpResult.Description != "Desc" || len(ptpResult.Images) != 1 {
+		t.Fatalf("unexpected ptp description/images: %+v", ptpResult)
+	}
+}
+
+func TestLookupUnit3DOnlyIDKeepsImages(t *testing.T) {
+	t.Parallel()
+
+	pngBytes := []byte{
+		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
+		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
+		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
+		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
+		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
+		0x44, 0xae, 0x42, 0x60, 0x82,
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
+			imageURL := "http://93.184.216.34/images/shot.png"
+			description := "[url=https://example.com/view][img]" + imageURL + "[/img][/url]"
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"attributes": map[string]any{
+					"tmdb_id":     100,
+					"description": description,
+				},
+			})
+		case r.URL.Path == "/images/shot.png":
+			w.Header().Set("Content-Type", "image/png")
+			_, _ = w.Write(pngBytes)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	baseURL, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+
+	httpClient := server.Client()
+	transport := httpClient.Transport
+	if transport == nil {
+		transport = http.DefaultTransport
+	}
+	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
+
+	client := newUnit3DDataClient(t, httpClient)
+
+	result, err := client.Lookup(context.Background(), "BLU", "777", api.UploadSubject{}, "release.mkv", true, true)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if result.TMDBID != 100 {
+		t.Fatalf("expected tmdb id, got %+v", result)
+	}
+	if result.Description != "" {
+		t.Fatalf("expected onlyID to clear description, got %q", result.Description)
+	}
+	if len(result.Images) != 1 {
+		t.Fatalf("expected keepImages to retain images with onlyID=true, got %d", len(result.Images))
+	}
+}
+
+func TestLookupUnit3DRejectsLinkedPrivateRawURLBeforeFetch(t *testing.T) {
+	t.Parallel()
+
+	var privateRequests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
+			description := "[url=http://127.0.0.1/private.png][img]http://93.184.216.34/thumb.png[/img][/url]"
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"attributes": map[string]any{
+					"tmdb_id":     100,
+					"description": description,
+				},
+			})
+		case r.URL.Path == "/private.png":
+			privateRequests.Add(1)
+			http.Error(w, "private image should not be fetched", http.StatusInternalServerError)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	baseURL, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+
+	httpClient := server.Client()
+	transport := httpClient.Transport
+	if transport == nil {
+		transport = http.DefaultTransport
+	}
+	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
+
+	client := newUnit3DDataClient(t, httpClient)
+	result, err := client.Lookup(context.Background(), "BLU", "777", api.UploadSubject{}, "release.mkv", false, true)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if len(result.Images) != 0 || len(result.Validated) != 0 {
+		t.Fatalf("expected private linked image to be rejected, got images=%+v validated=%+v", result.Images, result.Validated)
+	}
+	if got := privateRequests.Load(); got != 0 {
+		t.Fatalf("expected private raw URL not to be fetched, got %d request(s)", got)
+	}
+}
+
+func TestLookupUnit3DAllowsPublicLinkedRawURL(t *testing.T) {
+	t.Parallel()
+
+	pngBytes := []byte{
+		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
+		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
+		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
+		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
+		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
+		0x44, 0xae, 0x42, 0x60, 0x82,
+	}
+
+	var fullRequests atomic.Int32
+	var thumbRequests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
+			description := "[url=http://93.184.216.34/images/full.png][img]http://93.184.216.34/images/thumb.png[/img][/url]"
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"attributes": map[string]any{
+					"tmdb_id":     100,
+					"description": description,
+				},
+			})
+		case r.URL.Path == "/images/full.png":
+			fullRequests.Add(1)
+			w.Header().Set("Content-Type", "image/png")
+			_, _ = w.Write(pngBytes)
+		case r.URL.Path == "/images/thumb.png":
+			thumbRequests.Add(1)
+			http.Error(w, "thumbnail should not be validated when linked full-size URL is public", http.StatusInternalServerError)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	baseURL, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+
+	httpClient := server.Client()
+	transport := httpClient.Transport
+	if transport == nil {
+		transport = http.DefaultTransport
+	}
+	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
+
+	client := newUnit3DDataClient(t, httpClient)
+	result, err := client.Lookup(context.Background(), "BLU", "777", api.UploadSubject{}, "release.mkv", false, true)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if len(result.Images) != 1 || len(result.Validated) != 1 {
+		t.Fatalf("expected public linked image to validate, got images=%+v validated=%+v", result.Images, result.Validated)
+	}
+	if got := result.Images[0].RawURL; got != "http://93.184.216.34/images/full.png" {
+		t.Fatalf("expected linked full-size raw URL, got %q", got)
+	}
+	if got := result.Images[0].ImgURL; got != "http://93.184.216.34/images/thumb.png" {
+		t.Fatalf("expected thumbnail image URL preserved, got %q", got)
+	}
+	if got := fullRequests.Load(); got != 1 {
+		t.Fatalf("expected one public full-size fetch, got %d", got)
+	}
+	if got := thumbRequests.Load(); got != 0 {
+		t.Fatalf("expected thumbnail not to be fetched, got %d request(s)", got)
+	}
+}
+
+func TestLookupUnit3DDescriptionFlagsGateDescriptionAndImages(t *testing.T) {
+	t.Parallel()
+
+	pngBytes := []byte{
+		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+		0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+		0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
+		0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
+		0x54, 0x08, 0x99, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
+		0x00, 0x03, 0x01, 0x01, 0x00, 0xc9, 0xfe, 0x92,
+		0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
+		0x44, 0xae, 0x42, 0x60, 0x82,
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/api/torrents/"):
+			imageURL := "http://93.184.216.34/images/shot.png"
+			description := "[center]Fetched tracker body[/center]\n\n[center][url=https://example.com/view][img]" + imageURL + "[/img][/url][/center]"
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"attributes": map[string]any{
+					"tmdb_id":     100,
+					"description": description,
+				},
+			})
+		case r.URL.Path == "/images/shot.png":
+			w.Header().Set("Content-Type", "image/png")
+			_, _ = w.Write(pngBytes)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	baseURL, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+
+	httpClient := server.Client()
+	transport := httpClient.Transport
+	if transport == nil {
+		transport = http.DefaultTransport
+	}
+	httpClient.Transport = rewriteHostTransport{base: baseURL, rt: transport}
+
+	client := newUnit3DDataClient(t, httpClient)
+	ctx := context.Background()
+
+	result, err := client.Lookup(ctx, "BLU", "777", api.UploadSubject{}, "release.mkv", false, false)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if result.Description != "[center]Fetched tracker body[/center]" {
+		t.Fatalf("expected cleaned description when onlyID=false, got %q", result.Description)
+	}
+	if len(result.Images) != 0 {
+		t.Fatalf("expected keepImages=false to skip images, got %d", len(result.Images))
+	}
+
+	result, err = client.Lookup(ctx, "BLU", "777", api.UploadSubject{}, "release.mkv", true, false)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if result.Description != "" {
+		t.Fatalf("expected onlyID=true to clear description, got %q", result.Description)
+	}
+	if len(result.Images) != 0 {
+		t.Fatalf("expected keepImages=false to skip images with onlyID=true, got %d", len(result.Images))
+	}
+
+	result, err = client.Lookup(ctx, "BLU", "777", api.UploadSubject{}, "release.mkv", false, true)
+	if err != nil {
+		t.Fatalf("unit3d lookup failed: %v", err)
+	}
+	if result.Description != "[center]Fetched tracker body[/center]" {
+		t.Fatalf("expected cleaned description with keepImages=true, got %q", result.Description)
+	}
+	if len(result.Images) != 1 {
+		t.Fatalf("expected keepImages=true to retain images, got %d", len(result.Images))
+	}
+}
diff --git a/internal/trackers/impl/dc/definition.go b/internal/trackers/impl/dc/definition.go
deleted file mode 100644
index f007078f..00000000
--- a/internal/trackers/impl/dc/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dc
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "DC"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "dc", Description: description}, nil
-}
diff --git a/internal/trackers/impl/dc/upload.go b/internal/trackers/impl/dc/upload.go
deleted file mode 100644
index 92a279ed..00000000
--- a/internal/trackers/impl/dc/upload.go
+++ /dev/null
@@ -1,386 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package dc
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://digitalcore.club"
-	apiBaseURL = baseURL + "/api/v1/torrents"
-	sourceFlag = "DigitalCore.club"
-)
-
-type uploadState struct {
-	torrentPath   string
-	releaseName   string
-	description   string
-	mediaInfo     string
-	fields        map[string]string
-	blockedReason string
-}
-
-type uploadResponse struct {
-	ID      any    `json:"id"`
-	Message string `json:"message"`
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: DC %s", state.blockedReason)
-	}
-
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
-		FieldName: "file",
-		FileName:  state.releaseName + ".torrent",
-		Path:      state.torrentPath,
-	}})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiBaseURL+"/upload", strings.NewReader(string(body)))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: DC request build: %w", err)
-	}
-	httpReq.Body = io.NopCloser(strings.NewReader(string(body)))
-	httpReq.ContentLength = int64(len(body))
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	httpReq.Header.Set("X-Api-Key", strings.TrimSpace(req.TrackerConfig.APIKey))
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: DC upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: DC read upload response: %w", err)
-	}
-	var decoded uploadResponse
-	if len(responseBody) > 0 {
-		if err := json.Unmarshal(responseBody, &decoded); err != nil {
-			if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-				return api.UploadSummary{}, commonhttp.UploadHTTPError("DC", resp.StatusCode, responsePreview)
-			}
-			return api.UploadSummary{}, fmt.Errorf("trackers: DC decode response: %w", err)
-		}
-	}
-	torrentID := strings.TrimSpace(fmt.Sprint(decoded.ID))
-	if resp.StatusCode >= 200 && resp.StatusCode < 300 && torrentID != "" && torrentID != "<nil>" {
-		torrentURL := baseURL + "/torrent/" + torrentID + "/"
-		downloadURL := apiBaseURL + "/download/" + torrentID
-		artifactPath := ""
-		if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "DC")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "DC",
-				TorrentID:   torrentID,
-				TorrentURL:  torrentURL,
-				DownloadURL: downloadURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	if _, artifactErr := commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "DC", "upload_failure", responsePreview, ".json"); artifactErr != nil && req.Logger != nil {
-		req.Logger.Warnf("trackers: DC failure artifact write failed: %v", artifactErr)
-	}
-	message := metautil.FirstNonEmptyTrimmed(commonhttp.ExtractHTTPErrorDetail(responsePreview), commonhttp.RedactErrorDetail(decoded.Message), commonhttp.RedactErrorDetail(string(responsePreview)), "upload failed")
-	return api.UploadSummary{}, fmt.Errorf("trackers: DC %s", message)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "DC",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "dc",
-		Description:      state.description,
-		Endpoint:         apiBaseURL + "/upload",
-		Payload:          cloneFields(state.fields),
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: DC missing api_key")
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	mediaInfo, err := resolveMediaInfo(req.Meta)
-	if err != nil {
-		return uploadState{}, err
-	}
-	releaseName := resolveUploadName(req.Meta)
-	fields := map[string]string{
-		"category":        strconv.Itoa(resolveCategoryID(req.Meta)),
-		"imdbId":          resolveIMDbID(req.Meta),
-		"nfo":             description,
-		"mediainfo":       mediaInfo,
-		"reqid":           "0",
-		"section":         "new",
-		"frileech":        "1",
-		"anonymousUpload": resolveAnon(req),
-		"p2p":             "0",
-		"unrar":           "1",
-	}
-	state := uploadState{
-		torrentPath: torrentPath,
-		releaseName: releaseName,
-		description: description,
-		mediaInfo:   mediaInfo,
-		fields:      fields,
-	}
-	if strings.TrimSpace(fields["imdbId"]) == "" {
-		state.blockedReason = "missing IMDb ID"
-	}
-	return state, nil
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	meta := req.Meta
-	var parts []string
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// TV Episode details
-	if strings.TrimSpace(meta.EpisodeOverview) != "" {
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
-	}
-
-	// File information
-	if media := resolveMedia(req, meta); media != "" {
-		parts = append(parts, strings.TrimSpace(media))
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// Combined Screenshots
-	allShots := make([]api.ScreenshotImage, 0, len(assets.MenuImages)+len(assets.Screenshots))
-	allShots = append(allShots, assets.MenuImages...)
-	allShots = append(allShots, assets.Screenshots...)
-	if shots := screenshotBlock(allShots); shots != "" {
-		parts = append(parts, shots)
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// Signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[center][url=%s]%s[/url][/center]", link, text))
-
-	// Join and finalize
-	description := strings.Join(parts, "\n\n")
-	finalized := bbcode.FinalizeTrackerDescription("DC", description)
-
-	// Debug saving
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "DC", req.AppConfig.MainSettings.DBPath, finalized, req.Logger)
-	}
-
-	return finalized
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	resolution := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.ReleaseNameNoTag, meta.ReleaseName)))
-	category := categoryOf(meta)
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		if category == "TV" {
-			return 14
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "2160p") {
-			return 38
-		}
-		return 3
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		if category == "TV" {
-			return 11
-		}
-		return 1
-	}
-	if category == "TV" && meta.TVPack {
-		return 12
-	}
-	if isSD(meta) {
-		if category == "TV" {
-			return 10
-		}
-		return 2
-	}
-	switch category {
-	case "TV":
-		switch strings.TrimSpace(meta.Release.Resolution) {
-		case "2160p":
-			return 13
-		case "1080p", "1080i":
-			return 9
-		default:
-			return 8
-		}
-	default:
-		switch strings.TrimSpace(meta.Release.Resolution) {
-		case "2160p":
-			return 4
-		case "1080p", "1080i":
-			return 6
-		default:
-			_ = resolution
-			return 5
-		}
-	}
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	name := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.SceneName), strings.TrimSpace(meta.ReleaseNameClean), strings.TrimSpace(meta.ReleaseName), strings.TrimSpace(meta.Filename))
-	if name == "" {
-		name = "release"
-	}
-	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
-		return strings.TrimSpace(meta.SceneName) + " [UNRAR]"
-	}
-	name = strings.NewReplacer("DD+", "DDP", "DTS:", "DTS-", "HDR10+", "HDR10P").Replace(name)
-	out := strings.Builder{}
-	for _, r := range name {
-		if r > 127 {
-			continue
-		}
-		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == ' ' || r == '.' || r == '-' {
-			out.WriteRune(r)
-		}
-	}
-	return strings.TrimSpace(out.String())
-}
-
-func resolveMediaInfo(meta api.PreparedMetadata) (string, error) {
-	if text := metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText)); text != "" {
-		return text, nil
-	}
-	return "", errors.New("trackers: DC missing mediainfo")
-}
-
-func resolveMedia(req trackers.UploadRequest, meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		bdinfo, _ := trackers.ReadBDInfo(req.AppConfig.MainSettings.DBPath, meta)
-		return strings.TrimSpace(bdinfo)
-	}
-	return metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
-}
-
-func resolveIMDbID(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID > 0 {
-		return "tt" + strconv.Itoa(meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveAnon(req trackers.UploadRequest) string {
-	if req.TrackerConfig.Anon {
-		return "1"
-	}
-	return "0"
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category)); category != "" {
-		return category
-	}
-	return strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(images))
-	for _, image := range images {
-		if strings.TrimSpace(image.WebURL) == "" || strings.TrimSpace(image.RawURL) == "" {
-			continue
-		}
-		parts = append(parts, "[url="+strings.TrimSpace(image.WebURL)+"][img=350]"+strings.TrimSpace(image.RawURL)+"[/img][/url]")
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return "[center]" + strings.Join(parts, " ") + "[/center]"
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	return resolution == "480p" || resolution == "576p" || resolution == ""
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/dupe_contract_test.go b/internal/trackers/impl/dupe_contract_test.go
new file mode 100644
index 00000000..30851ae6
--- /dev/null
+++ b/internal/trackers/impl/dupe_contract_test.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestEveryTrackerExposesOneStructuralDuplicateFactory(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range registry.Names() {
+		t.Run(name, func(t *testing.T) {
+			definition, ok := registry.Lookup(name)
+			if !ok {
+				t.Fatal("definition missing")
+			}
+			factory, ok := definition.(dupe.Factory)
+			if !ok {
+				t.Fatalf("%s does not expose dupe.Factory", name)
+			}
+			adapter := dupe.NewAdapter(factory, name, config.Config{}, http.DefaultClient, api.NopLogger{}, registry)
+			if adapter == nil {
+				t.Fatal("factory returned nil adapter")
+			}
+			result := adapter.Search(context.Background(), api.DuplicateSubject{
+				SourcePath:  "C:/media/Example.Release.2026.1080p-GRP.mkv",
+				ReleaseName: "Example.Release.2026.1080p-GRP",
+			})
+			switch result.Disposition() {
+			case dupe.DispositionInvalid:
+				t.Fatalf("invalid disposition %v", result.Disposition())
+			case dupe.DispositionResolved:
+			case dupe.DispositionNotRun:
+				if strings.TrimSpace(result.Code()) == "" || strings.TrimSpace(result.SafeMessage()) == "" {
+					t.Fatalf("invalid not-run result code=%q message=%q", result.Code(), result.SafeMessage())
+				}
+			case dupe.DispositionFailed:
+				if strings.TrimSpace(result.Code()) == "" || strings.TrimSpace(result.SafeMessage()) == "" {
+					t.Fatalf("invalid failed result code=%q message=%q", result.Code(), result.SafeMessage())
+				}
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/dupe_handlers_contract_test.go b/internal/trackers/impl/dupe_handlers_contract_test.go
new file mode 100644
index 00000000..00316d69
--- /dev/null
+++ b/internal/trackers/impl/dupe_handlers_contract_test.go
@@ -0,0 +1,360 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	bjsimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/bjs"
+	btimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/bt"
+	ffimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/ff"
+	flimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/fl"
+	hdsimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/hds"
+	hdtimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/hdt"
+	isimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/is"
+	ptsimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/pts"
+	thrimpl "github.com/autobrr/upbrr/internal/trackers/impl/standalone/thr"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type handlerRewriteTransport struct {
+	base *url.URL
+	rt   http.RoundTripper
+}
+
+func (t handlerRewriteTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	clone := req.Clone(req.Context())
+	clone.URL.Scheme = t.base.Scheme
+	clone.URL.Host = t.base.Host
+	clone.Host = t.base.Host
+	response, err := t.rt.RoundTrip(clone)
+	if err != nil {
+		return response, fmt.Errorf("rewrite tracker request: %w", err)
+	}
+	return response, nil
+}
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+func TestSiteHandlersSearch(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		tracker  string
+		meta     api.DuplicateSubject
+		setup    func(t *testing.T, baseURL string, dbPath string)
+		handler  func(cfg config.Config, client *http.Client) dupe.Adapter
+		validate func(t *testing.T, entries []api.DupeEntry)
+	}{
+		{
+			name:    "BT",
+			tracker: "BT",
+			meta: api.DuplicateSubject{
+				Identity:   api.ExternalIdentity{IMDBID: 123},
+				Release:    api.ReleaseInfo{Title: "Movie"},
+				SourcePath: "x",
+			},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "BT", hostFromBaseURL(t, "https://brasiltracker.org"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(btimpl.New(), "BT", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.WEB-DL-GRP" {
+					t.Fatalf("unexpected BT entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "FL",
+			tracker: "FL",
+			meta: api.DuplicateSubject{
+				Identity:   api.ExternalIdentity{IMDBID: 123},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+				SourcePath: "x",
+			},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeJSONCookie(t, dbPath, "FL", `{"sid":"cookie"}`)
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(flimpl.New(), "FL", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].ID != "1234" {
+					t.Fatalf("unexpected FL entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "FF",
+			tracker: "FF",
+			meta:    api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 123}, SourcePath: "x"},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "FF", hostFromBaseURL(t, "https://www.funfile.org"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(ffimpl.New(), "FF", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "Fun.Movie.2024.1080p.BluRay.x264-GRP" {
+					t.Fatalf("unexpected FF entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "BJS",
+			tracker: "BJS",
+			meta:    api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 123}, SourcePath: "x"},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "BJS", hostFromBaseURL(t, "https://bj-share.info"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(bjsimpl.New(), "BJS", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].ID != "44" {
+					t.Fatalf("unexpected BJS entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "HDS",
+			tracker: "HDS",
+			meta: api.DuplicateSubject{
+				Identity:   api.ExternalIdentity{IMDBID: 123},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+				SourcePath: "x",
+			},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "HDS", hostFromBaseURL(t, "https://hd-space.org"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(hdsimpl.New(), "HDS", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || !entries[0].SizeKnown {
+					t.Fatalf("unexpected HDS entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "HDT",
+			tracker: "HDT",
+			meta: api.DuplicateSubject{
+				Identity:   api.ExternalIdentity{IMDBID: 123},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+				SourcePath: "x",
+			},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "HDT", hostFromBaseURL(t, "https://hd-torrents.me"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(hdtimpl.New(), "HDT", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.REMUX-GRP" {
+					t.Fatalf("unexpected HDT entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "IS",
+			tracker: "IS",
+			meta:    api.DuplicateSubject{Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 123}, SourcePath: "x"},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "IS", hostFromBaseURL(t, "https://immortalseed.me"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(isimpl.New(), "IS", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "Movie.2024.1080p.WEB-DL-GRP" {
+					t.Fatalf("unexpected IS entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "PTS",
+			tracker: "PTS",
+			meta:    api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 123}, SourcePath: "x"},
+			setup: func(t *testing.T, _ string, dbPath string) {
+				writeTextCookie(t, dbPath, "PTS", hostFromBaseURL(t, "https://www.ptskit.org"))
+			},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(ptsimpl.New(), "PTS", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "PTS.Movie.2024.1080p.WEB-DL-GRP" {
+					t.Fatalf("unexpected PTS entries: %#v", entries)
+				}
+			},
+		},
+		{
+			name:    "THR",
+			tracker: "THR",
+			meta:    api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 123}, SourcePath: "x"},
+			setup:   func(_ *testing.T, _ string, _ string) {},
+			handler: func(cfg config.Config, client *http.Client) dupe.Adapter {
+				return dupe.NewAdapter(thrimpl.New(), "THR", cfg, client, api.NopLogger{})
+			},
+			validate: func(t *testing.T, entries []api.DupeEntry) {
+				if len(entries) != 1 || entries[0].Name != "THR.Movie.2024.1080p.BluRay-GRP" {
+					t.Fatalf("unexpected THR entries: %#v", entries)
+				}
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			tmp := t.TempDir()
+			dbPath := filepath.Join(tmp, "ua.db")
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				switch tc.tracker {
+				case "BT":
+					if r.URL.Path == "/torrents.php" {
+						if r.URL.RawQuery == "id=99" {
+							_, _ = w.Write([]byte(`<html><body><div id="files_99"><div class="filelist_path">Movie.2024.1080p.WEB-DL-GRP</div></div><table id="torrent_table"><tr id="torrent99"><td><a onclick="gtoggle()">m2ts</a></td></tr></table></body></html>`))
+							return
+						}
+						if strings.Contains(r.URL.RawQuery, "searchstr=") {
+							_, _ = w.Write([]byte(`<html><body><table id="torrent_table"><tr><td><a href="torrents.php?id=99">group</a></td></tr></table></body></html>`))
+							return
+						}
+					}
+				case "FL":
+					if r.URL.Path == "/browse.php" {
+						_, _ = w.Write([]byte(`<a href="details.php?id=1234" title="FileList.Movie.2024.1080p.BluRay-GRP">x</a>`))
+						return
+					}
+				case "FF":
+					if r.URL.Path == "/torrents.php" && r.URL.RawQuery == "id=55" {
+						_, _ = w.Write([]byte(`<html><body><table><tr id="torrent123"><td><a onclick="gtoggle()">Fun.Movie.2024.1080p.BluRay.x264-GRP</a></td></tr></table></body></html>`))
+						return
+					}
+					if r.URL.Path == "/torrents.php" {
+						_, _ = w.Write([]byte(`<html><body><table id="torrent_table"><tr><td><a href="torrents.php?id=55">group</a></td></tr></table></body></html>`))
+						return
+					}
+				case "BJS":
+					if r.URL.Path == "/torrents.php" {
+						_, _ = w.Write([]byte(`<html><body><div class="main_column"><table><tr id="torrent44"><td><a onclick="loadIfNeeded('44', '99')">BJS Movie 2024 1080p WEB-DL</a></td></tr></table></div></body></html>`))
+						return
+					}
+				case "HDS":
+					if r.URL.Path == "/index.php" {
+						_, _ = w.Write([]byte(`Show/Hide Categories<table><tr><td class="lista"><a href="index.php?page=torrent-details&id=7">HDS.Movie.2024.1080p.BluRay-GRP</a></td><td class="lista">10.5 GB</td></tr></table>`))
+						return
+					}
+				case "HDT":
+					if r.URL.Path == "/torrents.php" {
+						_, _ = w.Write([]byte(`<html><body><table><tr><td class="mainblockcontent"><a href="details.php?id=77">Movie.2024.1080p.REMUX-GRP</a></td><td class="mainblockcontent">15.2 GiB</td></tr></table></body></html>`))
+						return
+					}
+				case "IS":
+					if r.URL.Path == "/browse.php" {
+						_, _ = w.Write([]byte(`<table id="sortabletable"><tbody><tr><td></td><td><a href="details.php?id=12">Movie.2024.1080p.WEB-DL-GRP</a></td><td></td><td></td><td>8.2 GB</td></tr></tbody></table>`))
+						return
+					}
+				case "PTS":
+					if r.URL.Path == "/torrents.php" {
+						_, _ = w.Write([]byte(`<table class="torrents"><table class="torrentname"><b>PTS.Movie.2024.1080p.WEB-DL-GRP</b></table></table>`))
+						return
+					}
+				case "THR":
+					if r.URL.Path == "/login.php" {
+						_, _ = w.Write([]byte(`<form><input type="hidden" name="returnto" value="/browse.php"></form>`))
+						return
+					}
+					if r.URL.Path == "/takelogin.php" {
+						http.SetCookie(w, &http.Cookie{
+							Name:  "session",
+							Value: "cookie",
+							Path:  "/",
+						})
+						_, _ = w.Write([]byte("ok"))
+						return
+					}
+					if r.URL.Path == "/browse.php" {
+						_, _ = w.Write([]byte(`<a href="details.php?id=91" onmousemove="return overlibImage('THR.Movie.2024.1080p.BluRay-GRP','/images/test.png')">link</a>`))
+						return
+					}
+				}
+				http.NotFound(w, r)
+			}))
+			defer server.Close()
+
+			tc.setup(t, server.URL, dbPath)
+			cfg := config.Config{
+				MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+				Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+					tc.tracker: {
+						Username: "user",
+						Password: "pass",
+					},
+				}},
+			}
+			base, err := url.Parse(server.URL)
+			if err != nil {
+				t.Fatalf("parse test server URL: %v", err)
+			}
+			client := &http.Client{Transport: handlerRewriteTransport{base: base, rt: server.Client().Transport}}
+			entries, notes, err := adapterEvidence(tc.handler(cfg, client).Search(context.Background(), tc.meta))
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if len(notes) != 0 {
+				t.Fatalf("unexpected notes: %v", notes)
+			}
+			tc.validate(t, entries)
+		})
+	}
+}
+
+func writeTextCookie(t *testing.T, dbPath string, tracker string, domain string) {
+	t.Helper()
+	cookieDir := filepath.Join(filepath.Dir(dbPath), "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+	line := domain + "\tTRUE\t/\tFALSE\t0\tsession\tcookie\n"
+	if err := os.WriteFile(filepath.Join(cookieDir, tracker+".txt"), []byte(line), 0o600); err != nil {
+		t.Fatalf("write cookie file: %v", err)
+	}
+}
+
+func writeJSONCookie(t *testing.T, dbPath string, tracker string, payload string) {
+	t.Helper()
+	cookieDir := filepath.Join(filepath.Dir(dbPath), "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(cookieDir, tracker+".json"), []byte(payload), 0o600); err != nil {
+		t.Fatalf("write cookie file: %v", err)
+	}
+}
+
+func hostFromBaseURL(t *testing.T, baseURL string) string {
+	t.Helper()
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		t.Fatalf("parse base URL: %v", err)
+	}
+	return parsed.Hostname()
+}
diff --git a/internal/trackers/impl/ff/definition.go b/internal/trackers/impl/ff/definition.go
deleted file mode 100644
index f0bc4ecd..00000000
--- a/internal/trackers/impl/ff/definition.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ff
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "FF"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(assets)
-	return trackers.DescriptionResult{Group: "ff", Description: description}, nil
-}
diff --git a/internal/trackers/impl/ff/upload.go b/internal/trackers/impl/ff/upload.go
deleted file mode 100644
index 93492cd3..00000000
--- a/internal/trackers/impl/ff/upload.go
+++ /dev/null
@@ -1,396 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ff
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://www.funfile.org"
-	loginURL   = baseURL + "/takelogin.php"
-	uploadURL  = baseURL + "/takeupload.php"
-	torrentURL = baseURL + "/details.php?id="
-	sourceFlag = "FunFile"
-)
-
-var idPattern = regexp.MustCompile(`details\.php\?id=(\d+)`)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	extraFiles    []commonhttp.FileField
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FF %s", state.blockedReason)
-	}
-	files := append([]commonhttp.FileField{{
-		FieldName: "file",
-		FileName:  state.releaseName + ".torrent",
-		Path:      state.torrentPath,
-	}}, state.extraFiles...)
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FF request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-	client := httpclient.CloneWithTimeout(&http.Client{CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}, httpclient.DefaultTimeout)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FF upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	location := resp.Header.Get("Location")
-	match := idPattern.FindStringSubmatch(location)
-	bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
-	if resp.StatusCode == http.StatusFound && len(match) >= 2 {
-		id := match[1]
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "FF")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{Tracker: "FF", TorrentID: id, TorrentURL: tURL, DownloadURL: tURL, TorrentPath: artifactPath}}}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "FF", "upload_failure", bodyBytes, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("FF", resp.StatusCode, bodyBytes)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "FF",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "ff",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	cookies, err := resolveCookies(ctx, req.Logger, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, dryRun)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(assets)
-	fields := map[string]string{
-		"MAX_FILE_SIZE": "10000000",
-		"type":          resolveTypeID(req.Meta),
-		"tags":          "",
-		"descr":         description,
-	}
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(req.Meta)))
-	switch {
-	case req.Meta.Anime:
-		fields["anime_type"] = resolveAnimeType(req.Meta)
-		fields["anime_source"] = resolveAnimeSource(req.Meta)
-		fields["anime_container"] = "mkv"
-		fields["anime_v_res"] = req.Meta.Release.Resolution
-		fields["anime_v_dar"] = "16_9"
-		fields["anime_v_codec"] = resolveAnimeVCodec(req.Meta)
-	case category == "MOVIE":
-		fields["movie_type"] = resolveMovieType(req.Meta)
-		fields["movie_source"] = resolveMovieSource(req.Meta)
-		fields["movie_imdb"] = resolveIMDbURL(req.Meta)
-		fields["pack"] = "0"
-	default:
-		fields["tv_type"] = resolveTVType(req.Meta)
-		fields["tv_source"] = resolveTVSource(req.Meta)
-		fields["tv_imdb"] = resolveIMDbURL(req.Meta)
-		fields["pack"] = "0"
-		if req.Meta.TVPack {
-			fields["pack"] = "1"
-		}
-	}
-	state := uploadState{
-		torrentPath: torrentPath,
-		description: description,
-		releaseName: resolveName(req.Meta),
-		fields:      fields,
-		extraFiles:  resolveExtraFiles(ctx, req.Meta),
-	}
-	return state, cookies, nil
-}
-
-func resolveCookies(ctx context.Context, logger api.Logger, cfg config.TrackerConfig, dbPath string, dryRun bool) ([]*http.Cookie, error) {
-	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FF", "www.funfile.org")
-	if err != nil {
-		if logger != nil {
-			logger.Debugf("trackers: LoadTrackerHTTPCookies failed for FF/www.funfile.org, dbPath=%s: %v", dbPath, err)
-		}
-	} else if len(loaded) > 0 {
-		return loaded, nil
-	}
-	if dryRun {
-		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-			return nil, errors.New("trackers: FF cookies not found")
-		}
-		// #nosec G124 -- Dry-run sentinel is an outbound tracker jar cookie, not a browser-set cookie.
-		return []*http.Cookie{{Name: "dryrun", Value: "1", Domain: ".funfile.org", Path: "/"}}, nil
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, errors.New("trackers: FF cookie invalid/missing and username/password not configured")
-	}
-	data := url.Values{}
-	data.Set("returnto", "/index.php")
-	data.Set("username", strings.TrimSpace(cfg.Username))
-	data.Set("password", strings.TrimSpace(cfg.Password))
-	data.Set("login", "Login")
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(data.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FF login request build: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", "upbrr")
-	client := httpclient.CloneWithTimeout(&http.Client{CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}, httpclient.DefaultTimeout)
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FF login request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusFound {
-		return nil, fmt.Errorf("trackers: FF login failed status=%d", resp.StatusCode)
-	}
-	return resp.Cookies(), nil
-}
-
-func buildDescription(assets trackers.DescriptionAssets) string {
-	if strings.TrimSpace(assets.Description) != "" {
-		return bbcode.FinalizeTrackerDescription("FF", strings.TrimSpace(assets.Description))
-	}
-	return ""
-}
-
-func resolveExtraFiles(ctx context.Context, meta api.PreparedMetadata) []commonhttp.FileField {
-	files := make([]commonhttp.FileField, 0, 2)
-	if ctx == nil {
-		return files
-	}
-	if poster := resolvePoster(meta); poster != "" {
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, poster, nil)
-		if err == nil {
-			resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
-			if err == nil {
-				defer resp.Body.Close()
-				if body, err := io.ReadAll(resp.Body); err == nil && len(body) > 0 {
-					files = append(files, commonhttp.FileField{FieldName: "poster", FileName: "poster.jpg", Content: body})
-				}
-			}
-		}
-	}
-	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
-	if payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo"); err == nil {
-		files = append(files, commonhttp.FileField{FieldName: "nfo", FileName: filepath.Base(path), Content: payload})
-	}
-	return files
-}
-
-func resolveTypeID(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return "44"
-	}
-	if strings.EqualFold(categoryOf(meta), "TV") {
-		return "7"
-	}
-	return "19"
-}
-
-func resolveMovieType(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.Source), "DVD") {
-		return "DVDR"
-	}
-	if strings.Contains(strings.ToLower(meta.VideoCodec), "hevc") || strings.Contains(strings.ToLower(meta.VideoEncode), "265") {
-		return "x265"
-	}
-	return "x264"
-}
-
-func resolveTVType(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.Source), "DVD") {
-		return "DVDR"
-	}
-	if strings.Contains(strings.ToLower(meta.Source), "web") {
-		if isSD(meta) {
-			return "Web-SD"
-		}
-		return "Web-HD"
-	}
-	if strings.Contains(strings.ToLower(meta.VideoCodec), "hevc") || strings.Contains(strings.ToLower(meta.VideoEncode), "265") {
-		if isSD(meta) {
-			return "x265-SD"
-		}
-		return "x265-HD"
-	}
-	if isSD(meta) {
-		return "x264-SD"
-	}
-	return "x264-HD"
-}
-
-func resolveAnimeType(meta api.PreparedMetadata) string {
-	if meta.SeasonInt == 0 {
-		return "TVSpecial"
-	}
-	if strings.EqualFold(categoryOf(meta), "MOVIE") {
-		return "Movie"
-	}
-	return "TVSeries"
-}
-
-func resolveMovieSource(meta api.PreparedMetadata) string {
-	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
-	case "dvd":
-		return "DVD"
-	case "blu-ray", "bluray":
-		return "BluRay"
-	case "hdtv":
-		return "HDTV"
-	case "webrip", "webdl", "web":
-		return "WebRIP"
-	default:
-		return "BluRay"
-	}
-}
-
-func resolveTVSource(meta api.PreparedMetadata) string {
-	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
-	case "dvd":
-		return "DVD"
-	case "blu-ray", "bluray":
-		return "BluRay"
-	case "hdtv":
-		return "HDTV"
-	case "webrip", "webdl", "web":
-		return "WebRIP"
-	default:
-		return "HDTV"
-	}
-}
-
-func resolveAnimeSource(meta api.PreparedMetadata) string {
-	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
-	case "dvd":
-		return "DVD"
-	case "blu-ray", "bluray":
-		return "BluRay"
-	default:
-		return "Anime Series"
-	}
-}
-
-func resolveAnimeVCodec(meta api.PreparedMetadata) string {
-	if strings.Contains(strings.ToLower(meta.VideoCodec), "vc-1") {
-		return "VC1"
-	}
-	if strings.Contains(strings.ToLower(meta.VideoEncode), "h.264") {
-		return "h264"
-	}
-	return "x264"
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
-		return strings.TrimSpace(meta.SceneName)
-	}
-	return strings.ReplaceAll(metautil.FirstNonEmptyTrimmed(meta.ReleaseNameClean, meta.ReleaseName, meta.Filename), " ", ".")
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	}
-	return ""
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	return strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "480p") || strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "576p")
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/fl/definition.go b/internal/trackers/impl/fl/definition.go
deleted file mode 100644
index fbb4d76a..00000000
--- a/internal/trackers/impl/fl/definition.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package fl
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "FL"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(assets)
-	return trackers.DescriptionResult{Group: "fl", Description: description}, nil
-}
diff --git a/internal/trackers/impl/fl/upload.go b/internal/trackers/impl/fl/upload.go
deleted file mode 100644
index e2d1e03e..00000000
--- a/internal/trackers/impl/fl/upload.go
+++ /dev/null
@@ -1,466 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package fl
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL      = "https://filelist.io"
-	loginPageURL = baseURL + "/login.php"
-	loginURL     = baseURL + "/takelogin.php"
-	uploadURL    = baseURL + "/takeupload.php"
-	downloadURL  = baseURL + "/download.php?id="
-)
-
-var (
-	validatorPattern = regexp.MustCompile(`name="validator"\s+value="([^"]+)"`)
-	successPattern   = regexp.MustCompile(`details\.php\?id=(\d+)&uploaded=`)
-	newHTTPClient    = httpclient.New
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	questionnaire *api.TrackerQuestionnaire
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FL %s", state.blockedReason)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
-		FieldName: "file",
-		FileName:  resolveTorrentFileName(req.Meta, state.releaseName) + ".torrent",
-		Path:      state.torrentPath,
-	}})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FL create cookie jar: %w", err)
-	}
-	base, _ := url.Parse(baseURL)
-	jar.SetCookies(base, cookies)
-	client := httpclient.CloneWithTimeout(&http.Client{Jar: jar}, httpclient.DefaultTimeout)
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FL request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: FL upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, _ := io.ReadAll(resp.Body)
-	match := successPattern.FindStringSubmatch(finalURL)
-	if len(match) >= 2 {
-		id := match[1]
-		artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "FL")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := downloadPersonalizedTorrent(ctx, client, id, artifactPath); err != nil {
-			return api.UploadSummary{}, err
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "FL",
-				TorrentID:   id,
-				TorrentURL:  baseURL + "/details.php?id=" + id,
-				DownloadURL: downloadURL + id,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "FL", "upload_failure", responseBody, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("FL", resp.StatusCode, finalURL, responseBody)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "FL",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "fl",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	cookies, err := resolveCookies(ctx, req.Logger, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, dryRun)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(assets)
-	name := resolveName(req.Meta, questionnaireAnswers(req.Meta))
-	fields := map[string]string{
-		"name":  name,
-		"type":  strconv.Itoa(resolveCategoryID(req.Meta)),
-		"descr": description,
-		"nfo":   resolveMedia(req.Meta),
-	}
-	if req.Meta.ExternalIDs.IMDBID > 0 {
-		fields["imdbid"] = strconv.Itoa(req.Meta.ExternalIDs.IMDBID)
-		fields["description"] = resolveGenres(req.Meta)
-	}
-	if strings.TrimSpace(req.TrackerConfig.UploaderName) != "" && !req.TrackerConfig.Anon {
-		fields["epenis"] = strings.TrimSpace(req.TrackerConfig.UploaderName)
-	}
-	if hasRomanianAudio(req.Meta) {
-		fields["materialro"] = "on"
-	}
-	if strings.EqualFold(strings.TrimSpace(req.Meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(req.Meta.Type), "REMUX") || req.Meta.TVPack {
-		fields["freeleech"] = "on"
-	}
-	state := uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   name,
-		fields:        fields,
-		questionnaire: buildQuestionnaire(req.Meta, name),
-	}
-	if strings.TrimSpace(name) == "" {
-		state.blockedReason = "missing release name"
-	}
-	return state, cookies, nil
-}
-
-// resolveCookies returns usable stored FL cookies or performs credential login.
-// Login-page read errors are reported before token parsing, and successful
-// credential login requires durable cookie persistence.
-func resolveCookies(ctx context.Context, logger api.Logger, cfg config.TrackerConfig, dbPath string, dryRun bool) ([]*http.Cookie, error) {
-	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FL", ".filelist.io")
-	if err != nil {
-		if logger != nil {
-			logger.Debugf("trackers: LoadTrackerHTTPCookies failed for FL/.filelist.io, dbPath=%s: %v", dbPath, err)
-		}
-	} else if valid := validFLCookies(loaded); len(valid) > 0 {
-		return valid, nil
-	} else if logger != nil {
-		logger.Debugf("trackers: FL loaded cookies were missing/expired, falling back to credential login, dbPath=%s", dbPath)
-	}
-	if dryRun {
-		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-			return nil, errors.New("trackers: FL cookies not found")
-		}
-		// #nosec G124 -- Dry-run sentinel is an outbound tracker jar cookie, not a browser-set cookie.
-		return []*http.Cookie{{Name: "dryrun", Value: "1", Domain: ".filelist.io", Path: "/"}}, nil
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, errors.New("trackers: FL cookie invalid/missing and username/password not configured")
-	}
-	if err := ensureLoginCookieStorageAvailable(dbPath); err != nil {
-		return nil, err
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL create login cookie jar: %w", err)
-	}
-	client := newHTTPClient(httpclient.DefaultTimeout)
-	client.Jar = jar
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, loginPageURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL login page request build: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL login page request: %w", err)
-	}
-	body, err := io.ReadAll(resp.Body)
-	resp.Body.Close()
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL read login page response: %w", err)
-	}
-	match := validatorPattern.FindStringSubmatch(string(body))
-	if len(match) < 2 {
-		return nil, errors.New("trackers: FL validator token not found")
-	}
-	data := url.Values{}
-	data.Set("validator", match[1])
-	data.Set("username", strings.TrimSpace(cfg.Username))
-	data.Set("password", strings.TrimSpace(cfg.Password))
-	data.Set("unlock", "1")
-	loginReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(data.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL login request build: %w", err)
-	}
-	loginReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	loginResp, err := client.Do(loginReq)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: FL login request: %w", err)
-	}
-	defer loginResp.Body.Close()
-	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 {
-		return nil, fmt.Errorf("trackers: FL login failed status=%d", loginResp.StatusCode)
-	}
-	base, _ := url.Parse(baseURL)
-	loginCookies := client.Jar.Cookies(base)
-	if err := persistLoginCookies(ctx, dbPath, loginCookies); err != nil {
-		return nil, err
-	}
-	return loginCookies, nil
-}
-
-// persistLoginCookies saves FL login cookies and returns any persistence error
-// so callers do not report login success without durable cookie storage.
-func persistLoginCookies(ctx context.Context, dbPath string, values []*http.Cookie) error {
-	valid := validFLCookies(values)
-	if len(valid) == 0 {
-		return errors.New("trackers: FL login returned no usable cookies")
-	}
-	if err := cookies.SaveTrackerHTTPCookies(ctx, dbPath, "FL", valid); err != nil {
-		return fmt.Errorf("trackers: FL persist login cookies: %w", err)
-	}
-	return nil
-}
-
-func ensureLoginCookieStorageAvailable(dbPath string) error {
-	if _, err := authmaterial.LoadFromDBPath(dbPath); err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return fmt.Errorf("trackers: FL encrypted cookie storage unavailable before credential login: %w", cookies.ErrAuthHelperUnavailable)
-		}
-		return fmt.Errorf("trackers: FL check encrypted cookie storage before credential login: %w", err)
-	}
-	return nil
-}
-
-func validFLCookies(values []*http.Cookie) []*http.Cookie {
-	now := time.Now()
-	valid := make([]*http.Cookie, 0, len(values))
-	for _, cookie := range values {
-		if cookie == nil {
-			continue
-		}
-		if strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		if !cookie.Expires.IsZero() && cookie.Expires.Before(now) {
-			continue
-		}
-		valid = append(valid, cookie)
-	}
-	return valid
-}
-
-func downloadPersonalizedTorrent(ctx context.Context, client *http.Client, id string, outputPath string) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL+id, nil)
-	if err != nil {
-		return fmt.Errorf("trackers: FL torrent download request build: %w", err)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: FL torrent download request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("trackers: FL read torrent response: %w", err)
-	}
-	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
-		return fmt.Errorf("trackers: FL write torrent output: %w", err)
-	}
-	return nil
-}
-
-func buildDescription(assets trackers.DescriptionAssets) string {
-	return bbcode.FinalizeTrackerDescription("FL", strings.TrimSpace(assets.Description))
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, computedName string) *api.TrackerQuestionnaire {
-	answers := questionnaireAnswers(meta)
-	return &api.TrackerQuestionnaire{Tracker: "FL", Fields: []api.TrackerQuestionnaireField{{
-		Key: "name", Label: "FileList Name", Kind: "text", Value: metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["name"]), computedName), Required: true,
-	}}}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["FL"]
-}
-
-func resolveName(meta api.PreparedMetadata, answers map[string]string) string {
-	if answers != nil && strings.TrimSpace(answers["name"]) != "" {
-		return strings.TrimSpace(answers["name"])
-	}
-	name := strings.TrimSpace(meta.ReleaseName)
-	name = strings.ReplaceAll(name, " DV ", " DoVi ")
-	name = strings.ReplaceAll(name, "BluRay REMUX", "Remux")
-	name = strings.ReplaceAll(name, "BluRay Remux", "Remux")
-	name = strings.ReplaceAll(name, "PQ10", "HDR")
-	name = strings.ReplaceAll(name, "HDR10+", "HDR")
-	name = strings.ReplaceAll(name, "DD+", "DDP")
-	name = strings.Join(strings.Fields(name), ".")
-	return strings.Trim(name, ".")
-}
-
-func resolveTorrentFileName(meta api.PreparedMetadata, releaseName string) string {
-	if meta.Anime && strings.EqualFold(strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-")), "SubsPlease") {
-		return releaseName
-	}
-	return strings.TrimSuffix(strings.TrimSpace(meta.Filename), filepath.Ext(strings.TrimSpace(meta.Filename)))
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	if meta.Anime {
-		return 24
-	}
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	switch {
-	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
-		if hasRomanianSub(meta) {
-			return 3
-		}
-		return 2
-	case category == "TV":
-		if resolution == "2160p" {
-			return 27
-		}
-		if isSD(meta) {
-			return 23
-		}
-		return 21
-	default:
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-			if resolution == "2160p" {
-				return 26
-			}
-			return 20
-		}
-		if resolution == "2160p" {
-			return 6
-		}
-		if isSD(meta) {
-			return 1
-		}
-		if hasRomanianSub(meta) {
-			return 19
-		}
-		return 4
-	}
-}
-
-func hasRomanianAudio(meta api.PreparedMetadata) bool {
-	for _, lang := range meta.AudioLanguages {
-		lower := strings.ToLower(strings.TrimSpace(lang))
-		if lower == "romanian" || lower == "ro" {
-			return true
-		}
-	}
-	return false
-}
-
-func hasRomanianSub(meta api.PreparedMetadata) bool {
-	for _, lang := range meta.SubtitleLanguages {
-		lower := strings.ToLower(strings.TrimSpace(lang))
-		if lower == "romanian" || lower == "ro" {
-			return true
-		}
-	}
-	return false
-}
-
-func resolveMedia(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		if summary, ok := meta.BDInfo["summary"].(string); ok {
-			return strings.TrimSpace(summary)
-		}
-	}
-	return metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
-}
-
-func resolveGenres(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	}
-	return strings.TrimSpace(meta.Release.Genre)
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	return resolution == "480p" || resolution == "576p"
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/gpw/definition.go b/internal/trackers/impl/gpw/definition.go
deleted file mode 100644
index ab73fdf7..00000000
--- a/internal/trackers/impl/gpw/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package gpw
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "GPW"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "gpw", Description: description}, nil
-}
diff --git a/internal/trackers/impl/gpw/description_assets_test.go b/internal/trackers/impl/gpw/description_assets_test.go
deleted file mode 100644
index 28c16e65..00000000
--- a/internal/trackers/impl/gpw/description_assets_test.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package gpw
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
-		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
-	}
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "GPW",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader:   "Disc menu token",
-			ScreenshotHeader: "Screenshots token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "GPW", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/gpw/upload.go b/internal/trackers/impl/gpw/upload.go
deleted file mode 100644
index 01690138..00000000
--- a/internal/trackers/impl/gpw/upload.go
+++ /dev/null
@@ -1,592 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package gpw
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://greatposterwall.com"
-	torrentURL = baseURL + "/torrents.php?torrentid="
-	sourceFlag = "GreatPosterWall"
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	groupID       string
-	questionnaire *api.TrackerQuestionnaire
-	blockedReason string
-}
-
-type apiResponse struct {
-	Status   any    `json:"status"`
-	Response any    `json:"response"`
-	Error    string `json:"error"`
-	Message  string `json:"message"`
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: GPW %s", state.blockedReason)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
-		FieldName: "file_input",
-		FileName:  "GPW.placeholder.torrent",
-		Path:      state.torrentPath,
-	}})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/api.php?api_key="+req.TrackerConfig.APIKey+"&action=upload", bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: GPW upload request build: %s", commonhttp.RedactErrorDetail(err.Error()))
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: GPW upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: GPW read upload response: %w", err)
-	}
-	var decoded apiResponse
-	if err := json.Unmarshal(responseBody, &decoded); err != nil {
-		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-			return api.UploadSummary{}, commonhttp.UploadHTTPError("GPW", resp.StatusCode, responsePreview)
-		}
-		return api.UploadSummary{}, fmt.Errorf("trackers: GPW decode response: %w", err)
-	}
-	id := extractTorrentID(decoded.Response)
-	status := strings.ToLower(strings.TrimSpace(fmt.Sprint(decoded.Status)))
-	if (status == "success" || status == "ok" || status == "200") && id != "" {
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "GPW")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{Tracker: "GPW", TorrentID: id, TorrentURL: tURL, DownloadURL: tURL, TorrentPath: artifactPath}}}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "GPW", "upload_failure", responsePreview, ".json")
-	return api.UploadSummary{}, fmt.Errorf("trackers: GPW %s", metautil.FirstNonEmptyTrimmed(commonhttp.ExtractHTTPErrorDetail(responsePreview), commonhttp.RedactErrorDetail(decoded.Error), commonhttp.RedactErrorDetail(decoded.Message), "upload failed"))
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.groupID == "" {
-		message += " for new group"
-	} else {
-		message += " for existing group"
-	}
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "GPW",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "gpw",
-		Description:      state.description,
-		Endpoint:         baseURL + "/api.php?api_key=" + req.TrackerConfig.APIKey + "&action=upload",
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file_input", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: GPW missing api_key")
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	groupID, _ := lookupGroupID(ctx, req.TrackerConfig.APIKey, req.Meta)
-	answers := questionnaireAnswers(req.Meta)
-	fields := buildFields(req, req.TrackerConfig, description, groupID, answers)
-	state := uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
-		fields:        fields,
-		groupID:       groupID,
-		questionnaire: buildQuestionnaire(req.Meta, groupID, answers),
-	}
-	if reason := validateFields(groupID, fields); reason != "" {
-		state.blockedReason = reason
-	}
-	return state, nil
-}
-
-func lookupGroupID(ctx context.Context, apiKey string, meta api.PreparedMetadata) (string, error) {
-	if meta.ExternalIDs.IMDBID == 0 {
-		return "", nil
-	}
-	url := fmt.Sprintf("%s/api.php?api_key=%s&action=torrent&req=group&imdbID=tt%07d", baseURL, apiKey, meta.ExternalIDs.IMDBID)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: GPW torrent URL lookup request build: %s", commonhttp.RedactErrorDetail(err.Error()))
-	}
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
-	if err != nil {
-		return "", fmt.Errorf("trackers: GPW torrent URL lookup request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	var decoded apiResponse
-	if err := json.Unmarshal(body, &decoded); err != nil {
-		return "", nil
-	}
-	if responseMap, ok := decoded.Response.(map[string]any); ok {
-		if value, ok := responseMap["ID"]; ok {
-			return strings.TrimSpace(fmt.Sprint(value)), nil
-		}
-	}
-	return "", nil
-}
-
-func buildFields(req trackers.UploadRequest, trackerCfg config.TrackerConfig, description string, groupID string, answers map[string]string) map[string]string {
-	meta := req.Meta
-	fields := map[string]string{
-		"codec_other":               "",
-		"codec":                     resolveCodec(meta),
-		"container_other":           "",
-		"container":                 resolveContainer(meta),
-		"mediainfo[]":               trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta),
-		"movie_edition_information": onOff(strings.TrimSpace(meta.Edition) != ""),
-		"processing_other":          "",
-		"processing":                resolveProcessing(meta),
-		"release_desc":              description,
-		"remaster_custom_title":     "",
-		"remaster_title":            strings.TrimSpace(meta.Edition),
-		"remaster_year":             "",
-		"resolution_height":         "",
-		"resolution_width":          "",
-		"resolution":                resolveResolution(meta),
-		"source_other":              "",
-		"source":                    resolveSource(meta),
-		"submit":                    "true",
-		"subtitle_type":             resolveSubtitleType(meta),
-		"subtitles[]":               strings.Join(resolveSubtitles(meta), ","),
-	}
-	if groupID != "" {
-		fields["groupid"] = groupID
-	} else {
-		fields["data_source"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["data_source"]), "imdb")
-		fields["identifier"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["identifier"]), resolveIdentifier(meta))
-		fields["desc"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["desc"]), resolveOverview(meta))
-		fields["image"] = strings.TrimSpace(answers["poster_url"])
-		fields["maindesc"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["main_desc"]), resolveOverview(meta))
-		fields["name"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["title"]), meta.Release.Title)
-		fields["releasetype"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["release_type"]), resolveMovieType(meta))
-		fields["subname"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["subname"]), meta.Release.Title)
-		fields["tags"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta))
-		fields["year"] = strconv.Itoa(resolveYear(meta))
-		fields["artists[]"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["director_name"]), resolveDirectorName(meta))
-		fields["importance[]"] = "1"
-		fields["artist_ids[]"] = strings.TrimSpace(answers["director_imdb"])
-		fields["artist_subs[]"] = strings.TrimSpace(answers["director_chinese"])
-		fields["characters[]"] = ""
-		fields["main_artist_number"] = "1"
-	}
-	maps.Copy(fields, resolveMediaFlags(meta))
-	if meta.Scene {
-		fields["scene"] = "on"
-	}
-	if meta.PersonalRelease {
-		if isDiscUpload(meta) {
-			fields["buy"] = "on"
-		} else {
-			fields["diy"] = "on"
-		}
-	}
-	if trackerCfg.Exclusive {
-		fields["jinzhuan"] = "on"
-	}
-	return fields
-}
-
-func isDiscUpload(meta api.PreparedMetadata) bool {
-	return strings.TrimSpace(meta.DiscType) != "" || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC")
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, groupID string, answers map[string]string) *api.TrackerQuestionnaire {
-	if groupID != "" {
-		return nil
-	}
-	fields := []api.TrackerQuestionnaireField{
-		{Key: "poster_url", Label: "Poster URL", Kind: "text", Value: metautil.FirstNonEmptyTrimmed(answers["poster_url"], resolvePoster(meta)), Required: true},
-		{Key: "director_imdb", Label: "Director IMDb ID", Kind: "text", Value: answers["director_imdb"], Placeholder: "nm0000138", Required: true},
-		{Key: "director_name", Label: "Director Name", Kind: "text", Value: metautil.FirstNonEmptyTrimmed(answers["director_name"], resolveDirectorName(meta)), Required: true},
-		{Key: "director_chinese", Label: "Director Chinese", Kind: "text", Value: answers["director_chinese"]},
-		{Key: "tags", Label: "Tags", Kind: "text", Value: metautil.FirstNonEmptyTrimmed(answers["tags"], resolveTags(meta)), Required: true},
-	}
-	return &api.TrackerQuestionnaire{Tracker: "GPW", Fields: fields}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["GPW"]
-}
-
-func validateFields(groupID string, fields map[string]string) string {
-	if groupID == "" {
-		for _, key := range []string{"image", "artists[]", "artist_ids[]", "tags"} {
-			if strings.TrimSpace(fields[key]) == "" {
-				return "missing required new-group data"
-			}
-		}
-	}
-	return ""
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	parts := make([]string, 0, 3)
-	// custom header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// logo
-	logoURL, logoSize := descriptionunit3d.ResolveLogo(meta, req.AppConfig)
-	if logoURL != "" {
-		if strings.HasSuffix(logoURL, ".svg") {
-			logoURL = strings.ReplaceAll(logoURL, ".svg", ".png")
-		}
-		parts = append(parts, fmt.Sprintf("[center][img=%d]%s[/img][/center]", logoSize, logoURL))
-	}
-
-	// description
-	if base := strings.TrimSpace(assets.Description); base != "" {
-		parts = append(parts, base)
-	}
-
-	// menu
-	if len(assets.MenuImages) > 0 {
-		// header
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		// images
-		if shots := screenshotBlock(assets.MenuImages); shots != "" {
-			parts = append(parts, shots)
-		}
-	}
-	// Screenshot Header
-	if header := strings.TrimSpace(req.AppConfig.Description.ScreenshotHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// screenshots
-	if shots := screenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-
-	// custom user signature
-	if signature := strings.TrimSpace(req.AppConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	// upbrr signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[align=right][url=%s][size=1]%s[/size][/url][/align]", link, text))
-
-	// finalize description
-	finalDescription := bbcode.FinalizeTrackerDescription("GPW", strings.TrimSpace(strings.Join(parts, "\n\n")))
-
-	// save debug description
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "GPW", req.AppConfig.MainSettings.DBPath, finalDescription, req.Logger)
-	}
-
-	return finalDescription
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(images))
-	for _, image := range images {
-		if strings.TrimSpace(image.RawURL) == "" {
-			continue
-		}
-		parts = append(parts, "[img]"+strings.TrimSpace(image.RawURL)+"[/img]")
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return "[center]" + strings.Join(parts, " ") + "[/center]"
-}
-
-func extractTorrentID(value any) string {
-	switch typed := value.(type) {
-	case map[string]any:
-		if torrentID, ok := typed["torrent_id"]; ok {
-			return strings.TrimSpace(fmt.Sprint(torrentID))
-		}
-	case []any:
-		if len(typed) > 0 {
-			if first, ok := typed[0].(map[string]any); ok {
-				if torrentID, ok := first["torrent_id"]; ok {
-					return strings.TrimSpace(fmt.Sprint(torrentID))
-				}
-			}
-		}
-	}
-	return ""
-}
-
-func resolveCodec(meta api.PreparedMetadata) string {
-	codec := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
-	switch {
-	case strings.Contains(codec, "hevc"), strings.Contains(codec, "265"):
-		return "HEVC"
-	case strings.Contains(codec, "avc"), strings.Contains(codec, "264"):
-		return "AVC"
-	case strings.Contains(codec, "vc-1"):
-		return "VC-1"
-	default:
-		return "Other"
-	}
-}
-
-func resolveContainer(meta api.PreparedMetadata) string {
-	container := strings.ToLower(strings.TrimSpace(meta.Container))
-	switch container {
-	case "mkv", "mp4", "avi", "vob", "m2ts":
-		return strings.ToUpper(container)
-	default:
-		return "Other"
-	}
-}
-
-func resolveProcessing(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "ENCODE":
-		return "Encode"
-	case "REMUX":
-		return "Remux"
-	case "DIY":
-		return "DIY"
-	default:
-		return "Untouched"
-	}
-}
-
-func resolveResolution(meta api.PreparedMetadata) string {
-	resolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
-	switch resolution {
-	case "480p", "576p", "720p", "1080i", "1080p", "2160p":
-		return resolution
-	default:
-		return "Other"
-	}
-}
-
-func resolveSource(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
-	case "DISC":
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-			return "Blu-ray"
-		}
-		return "DVD"
-	case "WEBDL", "WEBRIP":
-		return "WEB"
-	case "REMUX", "ENCODE":
-		return "Blu-ray"
-	case "HDTV":
-		return "HDTV"
-	default:
-		return "Other"
-	}
-}
-
-func resolveSubtitleType(meta api.PreparedMetadata) string {
-	if len(meta.SubtitleLanguages) > 0 {
-		return "1"
-	}
-	return "3"
-}
-
-func resolveSubtitles(meta api.PreparedMetadata) []string {
-	out := make([]string, 0, len(meta.SubtitleLanguages))
-	for _, lang := range meta.SubtitleLanguages {
-		switch strings.ToLower(strings.TrimSpace(lang)) {
-		case "english", "en":
-			out = append(out, "English")
-		case "chinese", "zh":
-			out = append(out, "Chinese")
-		case "portuguese", "pt":
-			out = append(out, "Portuguese")
-		}
-	}
-	return out
-}
-
-func resolveIdentifier(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	if meta.ExternalIDs.TMDBID > 0 {
-		return strconv.Itoa(meta.ExternalIDs.TMDBID)
-	}
-	return ""
-}
-
-func resolveOverview(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	}
-	return ""
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	}
-	return ""
-}
-
-func resolveMovieType(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.RuntimeMinutes > 0 && meta.ExternalMetadata.IMDB.RuntimeMinutes < 45 {
-		return "2"
-	}
-	return "1"
-}
-
-func resolveTags(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(strings.ToLower(strings.ReplaceAll(meta.ExternalMetadata.TMDB.Genres, ", ", ",")))
-	}
-	return strings.TrimSpace(strings.ToLower(meta.Release.Genre))
-}
-
-func resolveDirectorName(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Directors) > 0 {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Directors[0])
-	}
-	if meta.ExternalMetadata.IMDB != nil && len(meta.ExternalMetadata.IMDB.Directors) > 0 {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Directors[0].Name)
-	}
-	return ""
-}
-
-func resolveYear(meta api.PreparedMetadata) int {
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Year > 0 {
-		return meta.ExternalMetadata.TMDB.Year
-	}
-	if meta.ExternalMetadata.IMDB != nil && meta.ExternalMetadata.IMDB.Year > 0 {
-		return meta.ExternalMetadata.IMDB.Year
-	}
-	return meta.Release.Year
-}
-
-func resolveMediaFlags(meta api.PreparedMetadata) map[string]string {
-	flags := map[string]string{}
-	audio := strings.ToLower(strings.TrimSpace(meta.Audio))
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	if strings.Contains(audio, "atmos") {
-		flags["dolby_atmos"] = "on"
-	}
-	if strings.Contains(audio, "dts:x") {
-		flags["dts_x"] = "on"
-	}
-	if meta.Channels == "5.1" {
-		flags["audio_51"] = "on"
-	}
-	if meta.Channels == "7.1" {
-		flags["audio_71"] = "on"
-	}
-	if meta.BitDepth == "10" && hdr == "" {
-		flags["10_bit"] = "on"
-	}
-	if strings.Contains(hdr, "DV") {
-		flags["dolby_vision"] = "on"
-	}
-	if strings.Contains(hdr, "HDR10+") {
-		flags["hdr10plus"] = "on"
-	} else if strings.Contains(hdr, "HDR") {
-		flags["hdr10"] = "on"
-	}
-	return flags
-}
-
-func onOff(value bool) string {
-	if value {
-		return "on"
-	}
-	return ""
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/gpw/upload_test.go b/internal/trackers/impl/gpw/upload_test.go
deleted file mode 100644
index 6d0b4042..00000000
--- a/internal/trackers/impl/gpw/upload_test.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package gpw
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildFieldsPersonalReleaseAndExclusiveFlags(t *testing.T) {
-	t.Parallel()
-
-	base := api.PreparedMetadata{PersonalRelease: true}
-
-	nonDisc := buildFields(trackers.UploadRequest{Meta: base}, config.TrackerConfig{Exclusive: true}, "description", "group", nil)
-	if nonDisc["diy"] != "on" {
-		t.Fatalf("expected non-disc personal release to use diy flag, got %#v", nonDisc)
-	}
-	if _, ok := nonDisc["self_rip"]; ok {
-		t.Fatalf("did not expect legacy self_rip flag, got %#v", nonDisc)
-	}
-	if nonDisc["jinzhuan"] != "on" {
-		t.Fatalf("expected exclusive flag to set jinzhuan, got %#v", nonDisc)
-	}
-
-	discMeta := base
-	discMeta.DiscType = "BDMV"
-	disc := buildFields(trackers.UploadRequest{Meta: discMeta}, config.TrackerConfig{}, "description", "group", nil)
-	if disc["buy"] != "on" {
-		t.Fatalf("expected disc personal release to use buy flag, got %#v", disc)
-	}
-	if _, ok := disc["diy"]; ok {
-		t.Fatalf("did not expect diy for disc personal release, got %#v", disc)
-	}
-}
diff --git a/internal/trackers/impl/hdb/definition.go b/internal/trackers/impl/hdb/definition.go
deleted file mode 100644
index 66e83df6..00000000
--- a/internal/trackers/impl/hdb/definition.go
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	descriptionhdb "github.com/autobrr/upbrr/internal/services/description/hdb"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "HDB"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets, err := resolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-			return trackers.DescriptionResult{}, err
-		}
-		if req.Logger != nil {
-			req.Logger.Warnf("trackers: HDB description assets failed: %v", err)
-		}
-		assets = trackers.DescriptionAssets{}
-	}
-
-	description := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		description, err = descriptionhdb.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.MenuImages, assets.Screenshots)
-		if err != nil {
-			return trackers.DescriptionResult{}, fmt.Errorf("trackers: HDB description build: %w", err)
-		}
-	}
-
-	if strings.TrimSpace(description) == "" && req.Logger != nil {
-		req.Logger.Infof("trackers: HDB preparation description empty")
-	}
-
-	return trackers.DescriptionResult{
-		Group:       "hdb",
-		Description: description,
-	}, nil
-}
diff --git a/internal/trackers/impl/hdb/definition_test.go b/internal/trackers/impl/hdb/definition_test.go
deleted file mode 100644
index 4c882647..00000000
--- a/internal/trackers/impl/hdb/definition_test.go
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildDescriptionUsesHDBGroup(t *testing.T) {
-	d := New()
-	result, err := d.BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "HDB",
-		Meta:    api.PreparedMetadata{},
-		Logger:  api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if result.Group != "hdb" {
-		t.Fatalf("expected hdb group, got %q", result.Group)
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesProvidedAssets(t *testing.T) {
-	d := New()
-	result, err := d.BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "HDB",
-		Meta:    api.PreparedMetadata{},
-		Logger:  api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: "kept description",
-			Screenshots: []api.ScreenshotImage{{
-				ImgURL: "https://t.hdbits.org/example.jpg",
-				WebURL: "https://img.hdbits.org/example",
-				RawURL: "https://img.hdbits.org/example",
-			}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(result.Description, "https://t.hdbits.org/example.jpg") {
-		t.Fatalf("expected provided screenshot in description, got %q", result.Description)
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesProvidedMenuImages(t *testing.T) {
-	d := New()
-	result, err := d.BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "HDB",
-		Meta:    api.PreparedMetadata{},
-		Logger:  api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			MenuImages: []api.ScreenshotImage{{
-				Purpose: api.ScreenshotPurposeMenu,
-				ImgURL:  "https://t.hdbits.org/menu.jpg",
-				WebURL:  "https://img.hdbits.org/menu",
-			}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(result.Description, "https://t.hdbits.org/menu.jpg") {
-		t.Fatalf("expected provided menu image in description, got %q", result.Description)
-	}
-}
-
-func TestDefinitionUploadMissingCredentials(t *testing.T) {
-	d := New()
-	_, err := d.Upload(context.Background(), trackers.UploadRequest{Tracker: "HDB", Logger: api.NopLogger{}})
-	if err == nil {
-		t.Fatal("expected missing credentials error")
-	}
-}
-
-func TestDefinitionUploadSuccess(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	dbPath := filepath.Join(tmp, "ua.db")
-	cookieDir := filepath.Join(tmp, "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	cookieText := "# Netscape HTTP Cookie File\n.hdbits.org\tTRUE\t/\tTRUE\t0\tuid\tcookievalue\n"
-	if err := os.WriteFile(filepath.Join(cookieDir, "HDB.txt"), []byte(cookieText), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-
-	uploadSeen := false
-	downloadSeen := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/upload/upload":
-			uploadSeen = true
-			if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "multipart/form-data") {
-				t.Errorf("expected multipart content-type, got %q", ct)
-				return
-			}
-			if err := r.ParseMultipartForm(5 << 20); err != nil {
-				t.Errorf("parse multipart: %v", err)
-				return
-			}
-			if r.FormValue("name") == "" {
-				t.Error("expected upload name field")
-				return
-			}
-			if descr := r.FormValue("descr"); !strings.Contains(descr, "https://t.hdbits.org/rehosted.jpg") {
-				t.Errorf("expected provided rehosted screenshot in description, got %q", descr)
-				return
-			}
-			files := r.MultipartForm.File["file"]
-			if len(files) == 0 {
-				t.Error("expected torrent file in multipart form")
-				return
-			}
-			f, err := files[0].Open()
-			if err != nil {
-				t.Errorf("open uploaded file: %v", err)
-				return
-			}
-			_, _ = io.ReadAll(f)
-			_ = f.Close()
-			http.Redirect(w, r, "/details.php?id=123&uploaded=1", http.StatusFound)
-		case r.URL.Path == "/details.php":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("ok"))
-		case strings.HasPrefix(r.URL.Path, "/download.php/"):
-			downloadSeen = true
-			if r.URL.Query().Get("id") != "123" {
-				t.Errorf("expected id=123, got %q", r.URL.Query().Get("id"))
-				return
-			}
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("reseed-torrent-bytes"))
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	d := New()
-	result, err := d.Upload(context.Background(), trackers.UploadRequest{
-		Tracker: "HDB",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			VideoCodec:  "HEVC",
-			ReleaseName: "My.Release.2026.2160p.WEBDL.HEVC",
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
-			Username: "user",
-			Passkey:  "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: "kept description",
-			Screenshots: []api.ScreenshotImage{{
-				ImgURL: "https://t.hdbits.org/rehosted.jpg",
-				WebURL: "https://img.hdbits.org/rehosted",
-				RawURL: "https://img.hdbits.org/rehosted",
-			}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
-	}
-	if len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected one uploaded torrent artifact, got %d", len(result.UploadedTorrents))
-	}
-	if result.UploadedTorrents[0].Tracker != "HDB" {
-		t.Fatalf("expected tracker HDB, got %q", result.UploadedTorrents[0].Tracker)
-	}
-	if result.UploadedTorrents[0].TorrentID != "123" {
-		t.Fatalf("expected torrent id 123, got %q", result.UploadedTorrents[0].TorrentID)
-	}
-	if !uploadSeen {
-		t.Fatal("expected upload endpoint to be called")
-	}
-	if !downloadSeen {
-		t.Fatal("expected download endpoint to be called")
-	}
-	artifactPath := result.UploadedTorrents[0].TorrentPath
-	if strings.TrimSpace(artifactPath) == "" {
-		t.Fatal("expected tracker-specific torrent path")
-	}
-	updated, err := os.ReadFile(artifactPath)
-	if err != nil {
-		t.Fatalf("read updated torrent: %v", err)
-	}
-	if string(updated) != "reseed-torrent-bytes" {
-		t.Fatalf("expected downloaded torrent bytes, got %q", string(updated))
-	}
-	original, err := os.ReadFile(torrentPath)
-	if err != nil {
-		t.Fatalf("read original torrent: %v", err)
-	}
-	if string(original) != "dummy" {
-		t.Fatalf("expected original torrent to remain unchanged, got %q", string(original))
-	}
-}
-
-func TestDefinitionBuildUploadDryRunUsesProvidedAssets(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "Movie.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := buildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "HDB",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			VideoCodec:  "HEVC",
-			ReleaseName: "My.Release.2026.2160p.WEBDL.HEVC",
-		},
-		TrackerConfig: config.TrackerConfig{
-			Username: "user",
-			Passkey:  "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
-		Logger:    api.NopLogger{},
-		Assets: &trackers.DescriptionAssets{
-			Description: "kept description",
-			Screenshots: []api.ScreenshotImage{{
-				ImgURL: "https://t.hdbits.org/dryrun.jpg",
-				WebURL: "https://img.hdbits.org/dryrun",
-				RawURL: "https://img.hdbits.org/dryrun",
-			}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected dry-run error: %v", err)
-	}
-	if !strings.Contains(entry.Description, "https://t.hdbits.org/dryrun.jpg") {
-		t.Fatalf("expected provided screenshot in dry-run description, got %q", entry.Description)
-	}
-}
-
-func TestBuildUploadFieldsSkipsTVDBForMovie(t *testing.T) {
-	fields := buildUploadFields(api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE", TVDBID: 765432},
-	}, config.Config{}, 1, 5, 6, "description")
-
-	if _, ok := fields["tvdb"]; ok {
-		t.Fatalf("did not expect tvdb for movie payload")
-	}
-	if _, ok := fields["tvdb_season"]; ok {
-		t.Fatalf("did not expect tvdb_season for movie payload")
-	}
-	if _, ok := fields["tvdb_episode"]; ok {
-		t.Fatalf("did not expect tvdb_episode for movie payload")
-	}
-}
-
-func TestBuildUploadFieldsIncludesTVDBForTV(t *testing.T) {
-	fields := buildUploadFields(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 765432},
-		SeasonInt:   2,
-		EpisodeInt:  3,
-	}, config.Config{}, 2, 5, 6, "description")
-
-	if got := fields["tvdb"]; got != "765432" {
-		t.Fatalf("expected tvdb=765432, got %q", got)
-	}
-	if got := fields["tvdb_season"]; got != "2" {
-		t.Fatalf("expected tvdb_season=2, got %q", got)
-	}
-	if got := fields["tvdb_episode"]; got != "3" {
-		t.Fatalf("expected tvdb_episode=3, got %q", got)
-	}
-}
diff --git a/internal/trackers/impl/hdb/upload.go b/internal/trackers/impl/hdb/upload.go
deleted file mode 100644
index b4d599d7..00000000
--- a/internal/trackers/impl/hdb/upload.go
+++ /dev/null
@@ -1,636 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/db"
-	descriptionhdb "github.com/autobrr/upbrr/internal/services/description/hdb"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	hdbBaseURL    = "https://hdbits.org"
-	hdbUploadPath = "/upload/upload"
-)
-
-var hdbSuccessURLPattern = regexp.MustCompile(`(?i)details\.php\?id=(\d+)&uploaded=\d+`)
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	select {
-	case <-ctx.Done():
-		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	username := strings.TrimSpace(req.TrackerConfig.Username)
-	passkey := strings.TrimSpace(req.TrackerConfig.Passkey)
-	if username == "" || passkey == "" {
-		return api.UploadSummary{}, errors.New("trackers: HDB missing username/passkey")
-	}
-
-	category := hdbCategoryID(req.Meta)
-	codec := hdbCodecID(req.Meta)
-	medium := hdbMediumID(req.Meta)
-	if category == 0 || codec == 0 || medium == 0 {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDB mapping failed category=%d codec=%d medium=%d", category, codec, medium)
-	}
-
-	assets, err := resolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-			return api.UploadSummary{}, err
-		}
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	descriptionText := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		descriptionText, err = descriptionhdb.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.MenuImages, assets.Screenshots)
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	uploadURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if uploadURL == "" {
-		uploadURL = hdbBaseURL
-	}
-	uploadURL += hdbUploadPath
-
-	cookies, err := resolveHDBCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	fields := buildUploadFields(req.Meta, req.AppConfig, category, codec, medium, descriptionText)
-	body, contentType, err := buildMultipartPayload(fields, torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDB request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	for _, cookie := range cookies {
-		httpReq.AddCookie(cookie)
-	}
-
-	client := &http.Client{Timeout: 40 * time.Second}
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDB upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	matches := hdbSuccessURLPattern.FindStringSubmatch(finalURL)
-	if len(matches) < 2 {
-		bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("HDB", resp.StatusCode, finalURL, bodyPreview)
-	}
-
-	torrentID := strings.TrimSpace(matches[1])
-	trackerTorrentPath := ""
-	if torrentID != "" {
-		trackerTorrentPath, err = resolveTrackerTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, "HDB")
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		if err := downloadPersonalizedTorrent(ctx, uploadURL, req.Meta, trackerTorrentPath, torrentID, passkey, cookies); err != nil && req.Logger != nil {
-			req.Logger.Warnf("trackers: HDB torrent redownload failed: %v", err)
-		}
-	}
-
-	downloadURL := buildHDBDownloadURL(uploadURL, req.Meta, torrentID, passkey)
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "HDB",
-			TorrentID:   torrentID,
-			DownloadURL: downloadURL,
-			TorrentPath: trackerTorrentPath,
-		}},
-	}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	select {
-	case <-ctx.Done():
-		return api.TrackerDryRunEntry{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	username := strings.TrimSpace(req.TrackerConfig.Username)
-	passkey := strings.TrimSpace(req.TrackerConfig.Passkey)
-	if username == "" || passkey == "" {
-		return api.TrackerDryRunEntry{}, errors.New("trackers: HDB missing username/passkey")
-	}
-
-	category := hdbCategoryID(req.Meta)
-	codec := hdbCodecID(req.Meta)
-	medium := hdbMediumID(req.Meta)
-	if category == 0 || codec == 0 || medium == 0 {
-		return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: HDB mapping failed category=%d codec=%d medium=%d", category, codec, medium)
-	}
-
-	assets, err := resolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-			return api.TrackerDryRunEntry{}, err
-		}
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	descriptionText := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		descriptionText, err = descriptionhdb.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.MenuImages, assets.Screenshots)
-		if err != nil {
-			return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	uploadURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if uploadURL == "" {
-		uploadURL = hdbBaseURL
-	}
-	uploadURL += hdbUploadPath
-
-	fields := buildUploadFields(req.Meta, req.AppConfig, category, codec, medium, descriptionText)
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "HDB",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "hdb",
-		Description:      descriptionText,
-		Endpoint:         uploadURL,
-		Payload:          fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file",
-			Path:    torrentPath,
-			Present: strings.TrimSpace(torrentPath) != "",
-		}},
-	}, nil
-}
-
-func buildUploadFields(meta api.PreparedMetadata, appConfig config.Config, categoryID int, codecID int, mediumID int, description string) map[string]string {
-	fields := map[string]string{
-		"name":     resolveUploadName(meta),
-		"category": strconv.Itoa(categoryID),
-		"codec":    strconv.Itoa(codecID),
-		"medium":   strconv.Itoa(mediumID),
-		"origin":   "0",
-		"descr":    strings.TrimSpace(description),
-		"techinfo": "",
-	}
-
-	if trackers.IsInternalGroup(appConfig, "HDB", meta) {
-		fields["origin"] = "1"
-	}
-
-	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		if strings.TrimSpace(meta.MediaInfoTextPath) != "" {
-			content, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-			if err == nil {
-				fields["techinfo"] = strings.TrimSpace(string(content))
-			}
-		}
-	}
-
-	if isHDBTVCategory(meta) && meta.ExternalIDs.TVDBID != 0 {
-		fields["tvdb"] = strconv.Itoa(meta.ExternalIDs.TVDBID)
-	}
-	if imdb := resolveIMDbURL(meta); imdb != "" {
-		fields["imdb"] = imdb
-	} else {
-		fields["imdb"] = "0"
-	}
-	if isHDBTVCategory(meta) {
-		season := meta.SeasonInt
-		episode := meta.EpisodeInt
-		if season <= 0 {
-			season = 1
-		}
-		if episode <= 0 {
-			episode = 1
-		}
-		fields["tvdb_season"] = strconv.Itoa(season)
-		fields["tvdb_episode"] = strconv.Itoa(episode)
-	}
-
-	return fields
-}
-
-// isHDBTVCategory reports whether HDB upload payloads may include TVDB fields.
-// Explicit movie categories suppress TVDB fields even when MediaInfo or overrides classify the release as TV.
-func isHDBTVCategory(meta api.PreparedMetadata) bool {
-	if isHDBMovieCategory(meta) {
-		return false
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV") {
-		return true
-	}
-	if meta.ReleaseNameOverrides.Category != nil {
-		return strings.EqualFold(strings.TrimSpace(*meta.ReleaseNameOverrides.Category), "TV")
-	}
-	return false
-}
-
-func isHDBMovieCategory(meta api.PreparedMetadata) bool {
-	if strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "MOVIE") {
-		return true
-	}
-	if meta.ReleaseNameOverrides.Category != nil {
-		return strings.EqualFold(strings.TrimSpace(*meta.ReleaseNameOverrides.Category), "MOVIE")
-	}
-	return false
-}
-
-func resolveDescriptionAssets(
-	ctx context.Context,
-	tracker string,
-	meta api.PreparedMetadata,
-	repo db.MetadataRepository,
-	logger api.Logger,
-	provided *trackers.DescriptionAssets,
-) (trackers.DescriptionAssets, error) {
-	if provided != nil {
-		return *provided, nil
-	}
-	return wrapTrackerResult(trackers.ResolveDescriptionAssets(ctx, tracker, meta, repo, logger))
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.Filename); name != "" {
-		return name
-	}
-	return pathutil.Base(meta.SourcePath)
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		if value := strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL); value != "" {
-			if !strings.HasSuffix(value, "/") {
-				return value + "/"
-			}
-			return value
-		}
-	}
-	if meta.ExternalIDs.IMDBID != 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: HDB write multipart field %q: %w", key, err)
-		}
-	}
-
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: HDB open torrent file: %w", err)
-	}
-	defer file.Close()
-
-	part, err := writer.CreateFormFile("file", filepath.Base(torrentPath))
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: HDB create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: HDB copy torrent file: %w", err)
-	}
-
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: HDB close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	candidates := []string{
-		strings.TrimSpace(meta.TorrentPath),
-		strings.TrimSpace(meta.ClientTorrentPath),
-		strings.TrimSpace(meta.SourcePath),
-	}
-	for _, candidate := range candidates {
-		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
-			continue
-		}
-		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
-			return candidate, nil
-		}
-	}
-
-	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
-		tmpRoot, err := db.Subdir(dbPath, "tmp")
-		if err == nil {
-			tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-			if err == nil {
-				guessed := filepath.Join(tmpDir, base+".torrent")
-				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
-					return guessed, nil
-				}
-			}
-		}
-	}
-
-	return "", errors.New("trackers: HDB torrent file not found")
-}
-
-func resolveTrackerTorrentPath(meta api.PreparedMetadata, dbPath string, tracker string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return "", errors.New("trackers: HDB tracker torrent path requires db path and source path")
-	}
-
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: HDB tmp root: %w", err)
-	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: HDB tmp release dir: %w", err)
-	}
-	name := strings.ToLower(strings.TrimSpace(tracker))
-	name = strings.NewReplacer("/", "-", "\\", "-", " ", "-").Replace(name)
-	if name == "" {
-		name = "tracker"
-	}
-	return filepath.Join(tmpDir, base+"."+name+".torrent"), nil
-}
-
-func resolveHDBCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookiepkg.LoadTrackerHTTPCookies(ctx, dbPath, "HDB", "hdbits.org"))
-}
-
-func downloadPersonalizedTorrent(ctx context.Context, uploadURL string, meta api.PreparedMetadata, torrentPath string, torrentID string, passkey string, cookies []*http.Cookie) error {
-	downloadURL := buildHDBDownloadURL(uploadURL, meta, torrentID, passkey)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
-	if err != nil {
-		return fmt.Errorf("trackers: HDB create personalized torrent request: %w", err)
-	}
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-
-	client := &http.Client{Timeout: 40 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("trackers: HDB download personalized torrent: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("status %d", resp.StatusCode)
-	}
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("trackers: HDB read personalized torrent response: %w", err)
-	}
-	if len(body) == 0 {
-		return errors.New("empty torrent response")
-	}
-	if err := os.MkdirAll(filepath.Dir(torrentPath), 0o700); err != nil {
-		return fmt.Errorf("trackers: HDB create torrent output dir: %w", err)
-	}
-	if err := os.WriteFile(torrentPath, body, 0o600); err != nil {
-		return fmt.Errorf("trackers: HDB write torrent output: %w", err)
-	}
-	return nil
-}
-
-func buildHDBDownloadURL(uploadURL string, meta api.PreparedMetadata, torrentID string, passkey string) string {
-	if strings.TrimSpace(torrentID) == "" || strings.TrimSpace(passkey) == "" {
-		return ""
-	}
-	base := strings.TrimSuffix(uploadURL, hdbUploadPath)
-	filePart := pathutil.Base(meta.SourcePath)
-	if filePart == "" || filePart == "." || filePart == string(filepath.Separator) {
-		filePart = "download"
-	}
-	return fmt.Sprintf("%s/download.php/%s?id=%s&passkey=%s", strings.TrimRight(base, "/"), url.PathEscape(filePart), url.QueryEscape(torrentID), url.QueryEscape(passkey))
-}
-
-func hdbCategoryID(meta api.PreparedMetadata) int {
-	category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	if category == "" && meta.ReleaseNameOverrides.Category != nil {
-		category = strings.ToUpper(strings.TrimSpace(*meta.ReleaseNameOverrides.Category))
-	}
-	switch category {
-	case "MOVIE":
-		return 1
-	case "TV":
-		return 2
-	}
-	genres := ""
-	keywords := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		genres = strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres))
-		keywords = strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords))
-	}
-	if strings.Contains(genres, "documentary") || strings.Contains(keywords, "documentary") {
-		return 3
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		imdbType := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Type))
-		imdbGenres := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres))
-		if strings.Contains(imdbType, "concert") || (strings.Contains(imdbType, "video") && strings.Contains(imdbGenres, "music")) {
-			return 4
-		}
-	}
-	return 0
-}
-
-func hdbCodecID(meta api.PreparedMetadata) int {
-	codec := strings.ToUpper(strings.TrimSpace(meta.VideoCodec))
-	if codec == "" {
-		codec = strings.ToUpper(strings.TrimSpace(meta.VideoEncode))
-	}
-	switch codec {
-	case "AVC", "H.264":
-		return 1
-	case "MPEG-2":
-		return 2
-	case "VC-1":
-		return 3
-	case "XVID":
-		return 4
-	case "HEVC", "H.265":
-		return 5
-	case "VP9":
-		return 6
-	default:
-		return 0
-	}
-}
-
-func hdbMediumID(meta api.PreparedMetadata) int {
-	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
-	contentType := resolveHDBType(meta)
-	if discType == "BDMV" || discType == "HD DVD" {
-		return 1
-	}
-	if contentType == "HDTV" {
-		if meta.HasEncodeSettings {
-			return 3
-		}
-		return 4
-	}
-	switch contentType {
-	case "ENCODE", "WEBRIP":
-		return 3
-	case "REMUX":
-		return 5
-	case "WEBDL":
-		return 6
-	default:
-		return 0
-	}
-}
-
-func resolveHDBType(meta api.PreparedMetadata) string {
-	typeValue := normalizeHDBType(meta.Type)
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if meta.ReleaseNameOverrides.Type != nil {
-			typeValue = normalizeHDBType(*meta.ReleaseNameOverrides.Type)
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = normalizeHDBType(meta.Release.Type)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.DiscType) != "" {
-			typeValue = "DISC"
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = inferHDBTypeFromSource(meta.Source)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		typeValue = inferHDBTypeFromPath(meta.SourcePath)
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.VideoEncode) != "" {
-			typeValue = "ENCODE"
-		}
-	}
-	if typeValue == "" || isHDBCategoryType(typeValue) {
-		if strings.TrimSpace(meta.VideoCodec) != "" || strings.TrimSpace(meta.Release.Resolution) != "" || strings.TrimSpace(meta.Release.Ext) != "" {
-			typeValue = "ENCODE"
-		}
-	}
-	return typeValue
-}
-
-func normalizeHDBType(value string) string {
-	upper := strings.ToUpper(strings.TrimSpace(value))
-	if upper == "" {
-		return ""
-	}
-	upper = strings.ReplaceAll(upper, "-", "")
-	upper = strings.ReplaceAll(upper, " ", "")
-	upper = strings.ReplaceAll(upper, "_", "")
-	switch upper {
-	case "WEBDL":
-		return "WEBDL"
-	case "WEBRIP":
-		return "WEBRIP"
-	}
-	return upper
-}
-
-func isHDBCategoryType(value string) bool {
-	upper := strings.ToUpper(strings.TrimSpace(value))
-	return upper == "MOVIE" || upper == "TV"
-}
-
-func inferHDBTypeFromSource(source string) string {
-	upper := normalizeHDBType(source)
-	switch {
-	case strings.Contains(upper, "WEBDL"):
-		return "WEBDL"
-	case strings.Contains(upper, "WEBRIP"):
-		return "WEBRIP"
-	case strings.Contains(upper, "HDTV"):
-		return "HDTV"
-	}
-	return ""
-}
-
-func inferHDBTypeFromPath(path string) string {
-	base := strings.ToUpper(strings.TrimSpace(path))
-	compact := strings.NewReplacer(".", "", "-", "", "_", "", " ", "").Replace(base)
-	switch {
-	case strings.Contains(compact, "REMUX"):
-		return "REMUX"
-	case strings.Contains(compact, "WEBDL"):
-		return "WEBDL"
-	case strings.Contains(compact, "WEBRIP"):
-		return "WEBRIP"
-	case strings.Contains(compact, "HDTV"):
-		return "HDTV"
-	case strings.Contains(compact, "DVDRIP"):
-		return "DVDRIP"
-	}
-	return ""
-}
diff --git a/internal/trackers/impl/hdb/wrap_errors.go b/internal/trackers/impl/hdb/wrap_errors.go
deleted file mode 100644
index 4d817827..00000000
--- a/internal/trackers/impl/hdb/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdb
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/hds/definition.go b/internal/trackers/impl/hds/definition.go
deleted file mode 100644
index bbf6083e..00000000
--- a/internal/trackers/impl/hds/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hds
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "HDS"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "hds", Description: description}, nil
-}
diff --git a/internal/trackers/impl/hds/description_assets_test.go b/internal/trackers/impl/hds/description_assets_test.go
deleted file mode 100644
index 6ee67fe8..00000000
--- a/internal/trackers/impl/hds/description_assets_test.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hds
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages: []api.ScreenshotImage{{
-			RawURL: "https://images.example.invalid/menu.png",
-			ImgURL: "https://images.example.invalid/menu-thumb.png",
-			WebURL: "https://images.example.invalid/menu-view",
-		}},
-		Screenshots: []api.ScreenshotImage{{
-			RawURL: "https://images.example.invalid/normal.png",
-			ImgURL: "https://images.example.invalid/normal-thumb.png",
-			WebURL: "https://images.example.invalid/normal-view",
-		}},
-	}
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "HDS",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader:   "Disc menu token",
-			ScreenshotHeader: "Screenshots token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu-thumb.png", "Screenshots token", "normal-thumb.png")
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "HDS", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/hds/upload.go b/internal/trackers/impl/hds/upload.go
deleted file mode 100644
index 39da1b0e..00000000
--- a/internal/trackers/impl/hds/upload.go
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hds
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"maps"
-	"net/http"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://hd-space.org"
-	uploadURL  = baseURL + "/index.php?page=upload"
-	torrentURL = baseURL + "/index.php?page=torrent-details&id="
-	sourceFlag = "HD-Space"
-)
-
-var idPattern = regexp.MustCompile(`download\.php\?id=([a-zA-Z0-9]+)`)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	nfo           *commonhttp.FileField
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDS %s", state.blockedReason)
-	}
-	files := []commonhttp.FileField{{
-		FieldName: "torrent",
-		FileName:  filepath.Base(state.torrentPath),
-		Path:      state.torrentPath,
-	}}
-	if state.nfo != nil {
-		files = append(files, *state.nfo)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDS request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDS upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDS read upload response: %w", err)
-	}
-	combined := finalURL + "\n" + string(responseBody)
-	match := idPattern.FindStringSubmatch(combined)
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 && len(match) >= 2 {
-		id := strings.TrimSpace(match[1])
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "HDS")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "HDS",
-				TorrentID:   id,
-				TorrentURL:  tURL,
-				DownloadURL: baseURL + "/download.php?id=" + id,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "HDS", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("HDS", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "HDS",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "hds",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Files:            []api.TrackerDryRunFile{{Field: "torrent", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, []*http.Cookie, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	fields := map[string]string{
-		"category":      strconv.Itoa(resolveCategoryID(req.Meta)),
-		"filename":      metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Filename, pathutil.Base(req.Meta.SourcePath)),
-		"genre":         resolveGenres(req.Meta),
-		"imdb":          resolveIMDbURL(req.Meta),
-		"info":          description,
-		"nuk_rea":       "",
-		"nuk":           "false",
-		"req":           "false",
-		"submit":        "Send",
-		"t3d":           boolString(req.Meta.Is3D != ""),
-		"user_id":       "",
-		"youtube_video": resolveYouTube(req.Meta),
-		"anonymous":     boolString(req.TrackerConfig.Anon),
-	}
-	state := uploadState{torrentPath: torrentPath, description: description, releaseName: fields["filename"], fields: fields}
-	if !supportsHDSResolution(req.Meta.Release.Resolution) {
-		state.blockedReason = "resolution must be at least 720p"
-	}
-	if id := resolveIMDbURL(req.Meta); strings.TrimSpace(id) == "" {
-		state.blockedReason = "missing IMDb ID"
-	}
-	if file, ok := resolveNFO(req.Meta); ok {
-		state.nfo = &file
-	}
-	return state, cookies, nil
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDS", "hd-space.org"))
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return 15
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-		return 40
-	}
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	if strings.Contains(strings.ToLower(resolveGenres(meta)+" "+resolveKeywords(meta)), "documentary") {
-		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "2160p") {
-			return 47
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "1080p") || strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "1080i") {
-			return 25
-		}
-		return 24
-	}
-	if meta.Anime {
-		switch strings.TrimSpace(meta.Release.Resolution) {
-		case "2160p":
-			return 48
-		case "1080p", "1080i":
-			return 28
-		default:
-			return 27
-		}
-	}
-	if category == "TV" {
-		switch strings.TrimSpace(meta.Release.Resolution) {
-		case "2160p":
-			return 45
-		case "1080p", "1080i":
-			return 22
-		default:
-			return 21
-		}
-	}
-	switch strings.TrimSpace(meta.Release.Resolution) {
-	case "2160p":
-		return 46
-	case "1080p", "1080i":
-		return 19
-	default:
-		return 18
-	}
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	parts := make([]string, 0, 12)
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Logo
-	if req.AppConfig.Description.AddLogo {
-		if logo := resolveLogo(meta); logo != "" {
-			parts = append(parts, "[center][img]"+logo+"[/img][/center]")
-		}
-	}
-
-	// TV Episode details
-	if strings.TrimSpace(meta.EpisodeOverview) != "" {
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
-	}
-
-	// File information (BDInfo or MediaInfo)
-	if media := trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta); media != "" {
-		parts = append(parts, "[pre]"+media+"[/pre]")
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// menu
-	if len(assets.MenuImages) > 0 {
-		// header
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		// images
-		if shots := screenshotBlock(assets.MenuImages); shots != "" {
-			parts = append(parts, shots)
-		}
-	}
-	// Screenshot Header
-	if header := strings.TrimSpace(req.AppConfig.Description.ScreenshotHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// screenshots
-	if shots := screenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-
-	// custom user signature
-	if signature := strings.TrimSpace(req.AppConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	// upbrr signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[center][url=%s][size=2]%s[/size][/url][/center]", link, text))
-
-	// finalize description
-	finalDescription := bbcode.FinalizeTrackerDescription("HDS", strings.TrimSpace(strings.Join(parts, "\n\n")))
-
-	// save debug description
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "HDS", req.AppConfig.MainSettings.DBPath, finalDescription, req.Logger)
-	}
-
-	return finalDescription
-}
-
-func resolveLogo(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo) != "" {
-		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo), "/")
-	}
-	return ""
-}
-
-func resolveGenres(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	case meta.ExternalMetadata.IMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	default:
-		return strings.TrimSpace(meta.Release.Genre)
-	}
-}
-
-func resolveKeywords(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-	}
-	return ""
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL) != "" {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveYouTube(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	return ""
-}
-
-func resolveNFO(meta api.PreparedMetadata) (commonhttp.FileField, bool) {
-	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
-	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
-	if err != nil {
-		return commonhttp.FileField{}, false
-	}
-	return commonhttp.FileField{FieldName: "nfo", FileName: filepath.Base(path), Content: payload}, true
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	var sb strings.Builder
-	for _, image := range images {
-		if strings.TrimSpace(image.WebURL) == "" || strings.TrimSpace(image.ImgURL) == "" {
-			continue
-		}
-		sb.WriteString("[url=" + image.WebURL + "][img]" + image.ImgURL + "[/img][/url]")
-
-		// HDS cannot resize images. If the image host does not provide small thumbnails(<400px), place only one image per line.
-		// imgbox provides small thumbnails, so we can place them side-by-side.
-		if !strings.Contains(strings.ToLower(image.WebURL), "imgbox") {
-			sb.WriteString("\n")
-		}
-	}
-	content := strings.TrimSpace(sb.String())
-	if content == "" {
-		return ""
-	}
-	return "[center]\n" + content + "\n[/center]"
-}
-
-func boolString(value bool) string {
-	if value {
-		return "true"
-	}
-	return "false"
-}
-
-func supportsHDSResolution(value string) bool {
-	switch strings.TrimSpace(value) {
-	case "2160p", "1080p", "1080i", "720p":
-		return true
-	default:
-		return false
-	}
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/hds/upload_test.go b/internal/trackers/impl/hds/upload_test.go
deleted file mode 100644
index 22334676..00000000
--- a/internal/trackers/impl/hds/upload_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hds
-
-import "testing"
-
-func TestSupportsHDSResolution(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name       string
-		resolution string
-		expected   bool
-	}{
-		{name: "2160p", resolution: "2160p", expected: true},
-		{name: "1080i", resolution: "1080i", expected: true},
-		{name: "720p", resolution: "720p", expected: true},
-		{name: "576p", resolution: "576p", expected: false},
-		{name: "480p", resolution: "480p", expected: false},
-	}
-
-	for _, tc := range cases {
-		if got := supportsHDSResolution(tc.resolution); got != tc.expected {
-			t.Fatalf("%s: expected %t, got %t", tc.name, tc.expected, got)
-		}
-	}
-}
diff --git a/internal/trackers/impl/hds/wrap_errors.go b/internal/trackers/impl/hds/wrap_errors.go
deleted file mode 100644
index 010bdc92..00000000
--- a/internal/trackers/impl/hds/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hds
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/hdt/definition.go b/internal/trackers/impl/hdt/definition.go
deleted file mode 100644
index bc5fff19..00000000
--- a/internal/trackers/impl/hdt/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdt
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "HDT"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "hdt", Description: description}, nil
-}
diff --git a/internal/trackers/impl/hdt/description_assets_test.go b/internal/trackers/impl/hdt/description_assets_test.go
deleted file mode 100644
index 7afa8c4f..00000000
--- a/internal/trackers/impl/hdt/description_assets_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdt
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages: []api.ScreenshotImage{{
-			RawURL: "https://images.example.invalid/menu.png",
-			ImgURL: "https://images.example.invalid/menu-thumb.png",
-		}},
-		Screenshots: []api.ScreenshotImage{{
-			RawURL: "https://images.example.invalid/normal.png",
-			ImgURL: "https://images.example.invalid/normal-thumb.png",
-		}},
-	}
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "HDT",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader:   "Disc menu token",
-			ScreenshotHeader: "Screenshots token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "HDT", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/hdt/upload.go b/internal/trackers/impl/hdt/upload.go
deleted file mode 100644
index 5f64b6a2..00000000
--- a/internal/trackers/impl/hdt/upload.go
+++ /dev/null
@@ -1,444 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdt
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var tokenPattern = regexp.MustCompile(`name="csrfToken"\s+value="([^"]+)"`)
-var successPattern = regexp.MustCompile(`details\.php\?id=([a-zA-Z0-9]+)|Upload successful!`)
-var detailsPattern = regexp.MustCompile(`details\.php\?id=([a-zA-Z0-9]+)`)
-
-type uploadState struct {
-	baseURL       string
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	nfo           *commonhttp.FileField
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDT %s", state.blockedReason)
-	}
-	files := []commonhttp.FileField{{FieldName: "torrent", FileName: filepath.Base(state.torrentPath), Path: state.torrentPath}}
-	if state.nfo != nil {
-		files = append(files, *state.nfo)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.baseURL+"/upload.php", bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDT request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDT upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: HDT read upload response: %w", err)
-	}
-	combined := finalURL + "\n" + string(responseBody)
-	id := ""
-	if match := detailsPattern.FindStringSubmatch(combined); len(match) >= 2 {
-		id = match[1]
-	}
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 && successPattern.MatchString(combined) {
-		tURL := finalURL
-		if id != "" && !strings.Contains(tURL, "details.php?id=") {
-			tURL = state.baseURL + "/details.php?id=" + id
-		}
-		artifactPath := ""
-		if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "HDT")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, "hd-torrents.org"); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "HDT",
-				TorrentID:   id,
-				TorrentURL:  tURL,
-				DownloadURL: tURL,
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "HDT", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("HDT", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "HDT",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "hdt",
-		Description:      state.description,
-		Endpoint:         state.baseURL + "/upload.php",
-		Payload:          cloneFields(state.fields),
-		Files:            []api.TrackerDryRunFile{{Field: "torrent", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, []*http.Cookie, error) {
-	base := resolveBaseURL(req.TrackerConfig.URL)
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath, base)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	token := strings.Join([]string{"dry", "run", "token"}, "-")
-	if !dryRun {
-		token, err = fetchToken(ctx, base, cookies)
-		if err != nil {
-			return uploadState{}, nil, err
-		}
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	fields := map[string]string{
-		"filename":  resolveName(req.Meta),
-		"category":  strconv.Itoa(resolveCategoryID(req.Meta)),
-		"info":      description,
-		"csrfToken": token,
-		"season":    boolString(req.Meta.TVPack),
-		"anonymous": boolString(req.TrackerConfig.Anon),
-	}
-	if req.Meta.Is3D != "" {
-		fields["3d"] = "true"
-	}
-	hdr := strings.ToUpper(strings.TrimSpace(req.Meta.HDR))
-	if strings.Contains(hdr, "HDR10+") {
-		fields["HDR10"] = "true"
-		fields["HDR10Plus"] = "true"
-	} else if strings.Contains(hdr, "HDR") {
-		fields["HDR10"] = "true"
-	}
-	if strings.Contains(hdr, "DV") {
-		fields["DolbyVision"] = "true"
-	}
-	if imdb := resolveIMDbURL(req.Meta); imdb != "" {
-		fields["infosite"] = imdb + "/"
-	}
-	state := uploadState{
-		baseURL:     base,
-		torrentPath: torrentPath,
-		description: description,
-		releaseName: fields["filename"],
-		fields:      fields,
-	}
-	if strings.TrimSpace(req.Meta.Release.Resolution) == "" {
-		state.blockedReason = "missing resolution"
-	}
-	if file, ok := resolveNFO(req.Meta); ok {
-		state.nfo = &file
-	}
-	return state, cookies, nil
-}
-
-func resolveBaseURL(configURL string) string {
-	trimmed := strings.TrimSpace(configURL)
-	if trimmed == "" {
-		return "https://hd-torrents.me"
-	}
-	parsed, err := url.Parse(trimmed)
-	if err == nil && parsed.Host != "" {
-		return "https://" + parsed.Host
-	}
-	return strings.TrimRight(trimmed, "/")
-}
-
-func loadCookies(ctx context.Context, dbPath string, baseURL string) ([]*http.Cookie, error) {
-	host := "hd-torrents.me"
-	if parsed, err := url.Parse(baseURL); err == nil && parsed.Host != "" {
-		host = parsed.Host
-	}
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDT", host))
-}
-
-func fetchToken(ctx context.Context, baseURL string, cookies []*http.Cookie) (string, error) {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/upload.php", nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: HDT token request build: %w", err)
-	}
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("trackers: HDT token request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	match := tokenPattern.FindStringSubmatch(string(body))
-	if len(match) < 2 {
-		return "", errors.New("trackers: HDT csrf token not found")
-	}
-	return strings.TrimSpace(match[1]), nil
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if category == "TV" {
-		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
-			if resolution == "2160p" {
-				return 72
-			}
-			return 59
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-			if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
-				return 73
-			}
-			return 60
-		}
-		switch resolution {
-		case "2160p":
-			return 65
-		case "1080p", "1080i":
-			return 30
-		default:
-			return 38
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
-		if resolution == "2160p" {
-			return 70
-		}
-		return 1
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
-			return 71
-		}
-		return 2
-	}
-	switch resolution {
-	case "2160p":
-		return 64
-	case "1080p", "1080i":
-		return 5
-	default:
-		return 3
-	}
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	parts := make([]string, 0, 15)
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Logo
-	if req.AppConfig.Description.AddLogo {
-		if logo := resolveLogo(meta); logo != "" {
-			parts = append(parts, "[center][img]"+logo+"[/img][/center]")
-		}
-	}
-
-	// TV Episode details
-	if strings.TrimSpace(meta.EpisodeOverview) != "" {
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
-	}
-
-	// File information (BDInfo or MediaInfo)
-	if media := trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta); media != "" {
-		parts = append(parts, "[pre]"+media+"[/pre]")
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// menu
-	if len(assets.MenuImages) > 0 {
-		// header
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		// images
-		if shots := screenshotBlock(assets.MenuImages); shots != "" {
-			parts = append(parts, shots)
-		}
-	}
-	// Screenshot Header
-	if header := strings.TrimSpace(req.AppConfig.Description.ScreenshotHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// screenshots
-	if shots := screenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-
-	// custom user signature
-	if signature := strings.TrimSpace(req.AppConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	// upbrr signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[right][url=%s][size=1]%s[/size][/url][/right]", link, text))
-
-	// finalize description
-	finalDescription := bbcode.FinalizeTrackerDescription("HDT", strings.TrimSpace(strings.Join(parts, "\n\n")))
-
-	// save debug description
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "HDT", req.AppConfig.MainSettings.DBPath, finalDescription, req.Logger)
-	}
-
-	return finalDescription
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(images))
-	for _, image := range images {
-		if strings.TrimSpace(image.RawURL) == "" {
-			continue
-		}
-		parts = append(parts, "<a href='"+strings.TrimSpace(image.RawURL)+"'><img src='"+strings.TrimSpace(image.ImgURL)+"' height=137></a> ")
-	}
-	if len(parts) == 0 {
-		return ""
-	}
-	return "[center]" + strings.Join(parts, " ") + "[/center]"
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	name := strings.TrimSpace(meta.ReleaseName)
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") || strings.EqualFold(strings.TrimSpace(meta.Type), "WEBRIP") || strings.EqualFold(strings.TrimSpace(meta.Type), "ENCODE") {
-		name = strings.Replace(name, meta.Audio, strings.Replace(meta.Audio, " ", "", 1), 1)
-	}
-	name = strings.ReplaceAll(name, " DV ", " DoVi ")
-	name = strings.ReplaceAll(name, "BluRay REMUX", "Blu-ray Remux")
-	name = strings.Join(strings.Fields(name), " ")
-	name = strings.ReplaceAll(name, ":", "")
-	return strings.TrimSpace(name)
-}
-
-func resolveLogo(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo) != "" {
-		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ExternalMetadata.TMDB.TMDBLogo), "/")
-	}
-	return ""
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveNFO(meta api.PreparedMetadata) (commonhttp.FileField, bool) {
-	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
-	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
-	if err != nil {
-		return commonhttp.FileField{}, false
-	}
-	return commonhttp.FileField{FieldName: "nfos", FileName: filepath.Base(path), Content: payload}, true
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func boolString(value bool) string {
-	if value {
-		return "true"
-	}
-	return "false"
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/hdt/wrap_errors.go b/internal/trackers/impl/hdt/wrap_errors.go
deleted file mode 100644
index 4abd447a..00000000
--- a/internal/trackers/impl/hdt/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package hdt
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/is/definition.go b/internal/trackers/impl/is/definition.go
deleted file mode 100644
index 9a283aee..00000000
--- a/internal/trackers/impl/is/definition.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package is
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition {
-	return definition{}
-}
-
-func (definition) Name() string {
-	return "IS"
-}
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "is", Description: description}, nil
-}
diff --git a/internal/trackers/impl/is/description_assets_test.go b/internal/trackers/impl/is/description_assets_test.go
deleted file mode 100644
index 791b0c86..00000000
--- a/internal/trackers/impl/is/description_assets_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package is
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
-		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
-	}
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "IS",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader: "Disc menu token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots:", "normal.png")
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "IS", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/is/upload.go b/internal/trackers/impl/is/upload.go
deleted file mode 100644
index e23e55b8..00000000
--- a/internal/trackers/impl/is/upload.go
+++ /dev/null
@@ -1,448 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package is
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"maps"
-	"net/http"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://immortalseed.me"
-	uploadURL  = baseURL + "/upload.php"
-	torrentURL = baseURL + "/details.php?hash="
-	sourceFlag = "https://immortalseed.me"
-)
-
-var (
-	sslPattern   = regexp.MustCompile(`details\.php\?hash=([a-zA-Z0-9]+)|download\.php\?id=([a-zA-Z0-9]+)`)
-	successTexts = []string{"Download Torrent (SSL)", "Thank you for uploading"}
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	nfo           *commonhttp.FileField
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: IS %s", state.blockedReason)
-	}
-
-	files := []commonhttp.FileField{{
-		FieldName: "torrentfile",
-		FileName:  metautil.FirstNonEmptyTrimmed(state.releaseName, filepath.Base(state.torrentPath)),
-		Path:      state.torrentPath,
-	}}
-	if state.nfo != nil {
-		files = append(files, *state.nfo)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: IS request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: IS upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: IS read upload response: %w", err)
-	}
-	id, success := successfulUploadResponse(finalURL, string(responseBody))
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 && success {
-		if id != "" {
-			tURL := torrentURL + id
-			artifactPath := ""
-			if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-				artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "IS")
-				if err != nil {
-					return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-				}
-				if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
-					return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-				}
-			}
-			return api.UploadSummary{
-				Uploaded: 1,
-				UploadedTorrents: []api.UploadedTorrent{{
-					Tracker:     "IS",
-					TorrentID:   id,
-					TorrentURL:  tURL,
-					DownloadURL: tURL,
-					TorrentPath: artifactPath,
-				}},
-			}, nil
-		}
-		return api.UploadSummary{Uploaded: 1}, nil
-	}
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "IS", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("IS", resp.StatusCode, responsePreview)
-}
-
-func successfulUploadResponse(finalURL string, responseBody string) (string, bool) {
-	match := sslPattern.FindStringSubmatch(finalURL + "\n" + responseBody)
-	if len(match) >= 3 {
-		if id := metautil.FirstNonEmptyTrimmed(match[1], match[2]); id != "" {
-			return id, true
-		}
-	}
-	for _, text := range successTexts {
-		if strings.Contains(responseBody, text) {
-			return "", true
-		}
-	}
-	return "", false
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "IS",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "is",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Files:            []api.TrackerDryRunFile{{Field: "torrentfile", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, []*http.Cookie, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	fields := map[string]string{
-		"UseNFOasDescr": "no",
-		"message":       buildMessage(req.Meta),
-		"category":      strconv.Itoa(resolveCategoryID(req.Meta)),
-		"subject":       resolveSubject(req.Meta),
-		"nothingtopost": "1",
-		"t_image_url":   resolvePoster(req.Meta),
-		"submit":        "Upload Torrent",
-		"anonymous":     yesNo(req.TrackerConfig.Anon),
-	}
-	if strings.EqualFold(categoryOf(req.Meta), "MOVIE") {
-		fields["t_link"] = resolveIMDbURL(req.Meta)
-	}
-	state := uploadState{torrentPath: torrentPath, description: description, releaseName: fields["subject"], fields: fields}
-	if strings.TrimSpace(fields["t_image_url"]) == "" {
-		state.blockedReason = "missing poster URL"
-	}
-	if file, ok := resolveNFO(req.Meta); ok {
-		state.nfo = &file
-	}
-	return state, cookies, nil
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "IS", "immortalseed.me"))
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	parts := make([]string, 0, 8)
-	if strings.TrimSpace(meta.EpisodeOverview) != "" {
-		parts = append(parts, "Title: "+strings.TrimSpace(meta.EpisodeTitle), "Overview: "+strings.TrimSpace(meta.EpisodeOverview))
-	}
-	if media := trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta); media != "" {
-		parts = append(parts, media)
-	}
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-	if len(assets.MenuImages) > 0 {
-		var menuLines []string
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			menuLines = append(menuLines, header)
-		}
-		for _, image := range assets.MenuImages {
-			if strings.TrimSpace(image.RawURL) != "" {
-				menuLines = append(menuLines, image.RawURL)
-			}
-		}
-		if len(menuLines) > 0 {
-			parts = append(parts, strings.Join(menuLines, "\n"))
-		}
-	}
-	if len(assets.Screenshots) > 0 {
-		var shotLines []string
-		for _, image := range assets.Screenshots {
-			if strings.TrimSpace(image.RawURL) != "" {
-				shotLines = append(shotLines, image.RawURL)
-			}
-		}
-		if len(shotLines) > 0 {
-			parts = append(parts, "Screenshots:\n"+strings.Join(shotLines, "\n"))
-		}
-	}
-	return bbcode.FinalizeTrackerDescription("IS", strings.TrimSpace(strings.Join(parts, "\n\n")))
-}
-
-func buildMessage(meta api.PreparedMetadata) string {
-	message := strings.TrimSpace(resolveOverview(meta))
-	if trailer := resolveYouTube(meta); trailer != "" {
-		if message != "" {
-			message += "\n\n"
-		}
-		message += "[youtube]" + trailer + "[/youtube]"
-	}
-	return message
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	genres := strings.ToLower(resolveGenres(meta) + " " + resolveKeywords(meta))
-	nonEnglish := !hasEnglishAudio(meta)
-	switch category {
-	case "TV":
-		if strings.Contains(genres, "documentary") {
-			if isSD(meta) {
-				return 13
-			}
-			return 15
-		}
-		if meta.Anime {
-			return 6
-		}
-		if strings.Contains(genres, "children") || strings.Contains(genres, "cartoon") {
-			return 5
-		}
-		if meta.TVPack {
-			if resolution == "2160p" {
-				return 63
-			}
-			if isSD(meta) {
-				return 6
-			}
-			return 4
-		}
-		if resolution == "2160p" {
-			return 64
-		}
-		if resolution == "1080p" || resolution == "1080i" || resolution == "720p" {
-			return 8
-		}
-		if isSD(meta) {
-			if strings.Contains(strings.ToLower(meta.VideoEncode), "xvid") {
-				return 9
-			}
-			return 48
-		}
-		return 47
-	default:
-		if strings.Contains(genres, "documentary") {
-			if isSD(meta) {
-				return 13
-			}
-			return 15
-		}
-		if meta.Anime {
-			return 6
-		}
-		if resolution == "2160p" {
-			if nonEnglish {
-				return 60
-			}
-			return 62
-		}
-		if !isSD(meta) {
-			if nonEnglish {
-				return 18
-			}
-			return 16
-		}
-		if isSD(meta) {
-			if nonEnglish {
-				return 33
-			}
-			return 14
-		}
-		if nonEnglish {
-			return 34
-		}
-		return 17
-	}
-}
-
-func hasEnglishAudio(meta api.PreparedMetadata) bool {
-	for _, language := range meta.AudioLanguages {
-		lower := strings.ToLower(strings.TrimSpace(language))
-		if lower == "english" || lower == "en" {
-			return true
-		}
-	}
-	return false
-}
-
-func resolveSubject(meta api.PreparedMetadata) string {
-	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
-		return strings.TrimSpace(meta.SceneName)
-	}
-	name := strings.TrimSpace(meta.ReleaseName)
-	name = strings.ReplaceAll(name, strings.TrimSpace(meta.Release.Alt), "")
-	name = strings.ReplaceAll(name, "Dubbed", "")
-	name = strings.ReplaceAll(name, "Dual-Audio", "")
-	name = strings.Join(strings.Fields(name), ".")
-	return strings.Trim(name, ".")
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster)
-	case meta.ExternalMetadata.IMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	case meta.ExternalMetadata.TVmaze != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Poster)
-	default:
-		return ""
-	}
-}
-
-func resolveIMDbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL)
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-	}
-	return ""
-}
-
-func resolveOverview(meta api.PreparedMetadata) string {
-	switch {
-	case meta.ExternalMetadata.TMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview)
-	case meta.ExternalMetadata.IMDB != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot)
-	case meta.ExternalMetadata.TVmaze != nil:
-		return strings.TrimSpace(meta.ExternalMetadata.TVmaze.Summary)
-	default:
-		return strings.TrimSpace(meta.EpisodeOverview)
-	}
-}
-
-func resolveYouTube(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	return ""
-}
-
-func resolveGenres(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
-	}
-	return strings.TrimSpace(meta.Release.Genre)
-}
-
-func resolveKeywords(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-	}
-	return ""
-}
-
-func resolveNFO(meta api.PreparedMetadata) (commonhttp.FileField, bool) {
-	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
-	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
-	if err != nil {
-		return commonhttp.FileField{}, false
-	}
-	return commonhttp.FileField{FieldName: "nfofile", FileName: filepath.Base(path), Content: payload}, true
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	return resolution == "" || resolution == "480p" || resolution == "576p"
-}
-
-func categoryOf(meta api.PreparedMetadata) string {
-	if category := strings.TrimSpace(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	return strings.TrimSpace(meta.MediaInfoCategory)
-}
-
-func yesNo(value bool) string {
-	if value {
-		return "yes"
-	}
-	return "no"
-}
-
-func cloneFields(in map[string]string) map[string]string {
-	out := make(map[string]string, len(in))
-	maps.Copy(out, in)
-	return out
-}
diff --git a/internal/trackers/impl/is/wrap_errors.go b/internal/trackers/impl/is/wrap_errors.go
deleted file mode 100644
index 954f2cb9..00000000
--- a/internal/trackers/impl/is/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package is
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/manifest_locality_test.go b/internal/trackers/impl/manifest_locality_test.go
new file mode 100644
index 00000000..0101fcec
--- /dev/null
+++ b/internal/trackers/impl/manifest_locality_test.go
@@ -0,0 +1,222 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	imagehostpolicy "github.com/autobrr/upbrr/internal/imagehosting/policy"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func TestTrackerImplementationsUseFamilyRoots(t *testing.T) {
+	t.Parallel()
+
+	allowed := map[string]struct{}{
+		"azfamily":   {},
+		"commonhttp": {},
+		"standalone": {},
+		"unit3d":     {},
+	}
+	root := filepath.Join(trackerManifestRepoRoot(t), "internal", "trackers", "impl")
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatalf("read tracker implementation root: %v", err)
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		if _, ok := allowed[entry.Name()]; !ok {
+			t.Errorf("tracker implementation directory must be under a family root: %s", entry.Name())
+		}
+	}
+}
+
+func TestStandaloneRegistryMatchesPackageDirectories(t *testing.T) {
+	t.Parallel()
+
+	registry := MustNewRegistry()
+	want := make(map[string]struct{})
+	for _, name := range registry.NamesByFamily(trackers.FamilyStandalone) {
+		want[strings.ToLower(name)] = struct{}{}
+	}
+
+	root := filepath.Join(trackerManifestRepoRoot(t), "internal", "trackers", "impl", "standalone")
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatalf("read standalone implementation root: %v", err)
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		if entry.Name() == "internal" {
+			continue
+		}
+		if _, err := os.Stat(filepath.Join(root, entry.Name(), "profile.go")); err != nil {
+			t.Errorf("standalone tracker package must own profile.go: tracker=%s error=%v", entry.Name(), err)
+		}
+		if _, ok := want[entry.Name()]; !ok {
+			t.Errorf("unregistered standalone tracker directory: %s", entry.Name())
+			continue
+		}
+		delete(want, entry.Name())
+	}
+	for name := range want {
+		t.Errorf("standalone registry entry has no package directory: %s", name)
+	}
+}
+
+func TestGenericTrackerPolicyFilesContainNoSupportedTrackerDispatch(t *testing.T) {
+	t.Parallel()
+
+	registry := MustNewRegistry()
+	supported := make(map[string]struct{}, len(registry.Names()))
+	for _, name := range registry.Names() {
+		supported[strings.ToUpper(name)] = struct{}{}
+	}
+	repoRoot := trackerManifestRepoRoot(t)
+	paths := []string{
+		"internal/metadata/media_details.go",
+		"internal/metadata/source_lookup.go",
+		"internal/metadata/tracker_data.go",
+		"internal/torrentclient/search.go",
+	}
+	for _, directory := range []string{"internal/trackers/auth", "internal/imagehosting/policy"} {
+		err := filepath.WalkDir(filepath.Join(repoRoot, filepath.FromSlash(directory)), func(path string, entry fs.DirEntry, walkErr error) error {
+			if walkErr != nil {
+				return fmt.Errorf("walk generic tracker policy path: %w", walkErr)
+			}
+			if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") && !strings.HasSuffix(entry.Name(), "_test.go") {
+				relative, err := filepath.Rel(repoRoot, path)
+				if err != nil {
+					return fmt.Errorf("resolve generic tracker policy path: %w", err)
+				}
+				paths = append(paths, filepath.ToSlash(relative))
+			}
+			return nil
+		})
+		if err != nil {
+			t.Fatalf("scan %s: %v", directory, err)
+		}
+	}
+	for _, relative := range paths {
+		ignored := map[string]struct{}{}
+		if strings.HasPrefix(relative, "internal/imagehosting/policy/") {
+			for _, host := range imagehostpolicy.KnownUploadHosts() {
+				ignored[strings.ToUpper(host)] = struct{}{}
+			}
+		}
+		assertNoSupportedTrackerStringLiterals(t, repoRoot, relative, supported, ignored)
+	}
+	for _, relative := range []string{
+		"webui/src/hooks/useSettingsState.tsx",
+		"webui/src/pages/settings/index.tsx",
+	} {
+		assertNoSupportedTrackerTypeScriptLiterals(t, repoRoot, relative, supported)
+	}
+}
+
+func TestUnit3DBaseURLsRemainInSiteProfiles(t *testing.T) {
+	t.Parallel()
+
+	repoRoot := trackerManifestRepoRoot(t)
+	sitesRoot := filepath.Join(repoRoot, "internal", "trackers", "impl", "unit3d", "sites")
+	err := filepath.WalkDir(sitesRoot, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return fmt.Errorf("walk Unit3D site path: %w", walkErr)
+		}
+		if entry.IsDir() || entry.Name() == "profile.go" || strings.HasSuffix(entry.Name(), "_test.go") || !strings.HasSuffix(entry.Name(), ".go") {
+			return nil
+		}
+		relative, err := filepath.Rel(repoRoot, path)
+		if err != nil {
+			return fmt.Errorf("resolve Unit3D site path: %w", err)
+		}
+		parsed, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+		if err != nil {
+			return fmt.Errorf("parse Unit3D site source: %w", err)
+		}
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			literal, ok := node.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return true
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err == nil && (strings.HasPrefix(value, "https://") || strings.HasPrefix(value, "http://")) {
+				t.Errorf("Unit3D endpoint literal outside profile: file=%s value=%s", filepath.ToSlash(relative), value)
+			}
+			return true
+		})
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("scan Unit3D site profiles: %v", err)
+	}
+}
+
+func trackerManifestRepoRoot(t *testing.T) string {
+	t.Helper()
+	_, currentFile, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatal("resolve manifest-locality test path")
+	}
+	return filepath.Clean(filepath.Join(filepath.Dir(currentFile), "..", "..", ".."))
+}
+
+func assertNoSupportedTrackerStringLiterals(
+	t *testing.T,
+	repoRoot string,
+	relative string,
+	supported map[string]struct{},
+	ignored map[string]struct{},
+) {
+	t.Helper()
+	path := filepath.Join(repoRoot, filepath.FromSlash(relative))
+	parsed, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatalf("parse %s: %v", relative, err)
+	}
+	ast.Inspect(parsed, func(node ast.Node) bool {
+		literal, ok := node.(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		value, err := strconv.Unquote(literal.Value)
+		if err == nil {
+			normalized := strings.ToUpper(strings.TrimSpace(value))
+			_, allowed := ignored[normalized]
+			if _, found := supported[normalized]; found && !allowed {
+				t.Errorf("generic tracker dispatch literal: file=%s value=%q", relative, value)
+			}
+		}
+		return true
+	})
+}
+
+func assertNoSupportedTrackerTypeScriptLiterals(t *testing.T, repoRoot string, relative string, supported map[string]struct{}) {
+	t.Helper()
+	payload, err := os.ReadFile(filepath.Join(repoRoot, filepath.FromSlash(relative)))
+	if err != nil {
+		t.Fatalf("read %s: %v", relative, err)
+	}
+	quoted := regexp.MustCompile(`["']([A-Za-z0-9]+)["']`)
+	for _, match := range quoted.FindAllSubmatch(payload, -1) {
+		if _, found := supported[strings.ToUpper(string(match[1]))]; found {
+			t.Errorf("generic frontend tracker dispatch literal: file=%s value=%q", relative, match[1])
+		}
+	}
+}
diff --git a/internal/trackers/impl/mtv/definition.go b/internal/trackers/impl/mtv/definition.go
deleted file mode 100644
index 783c08e7..00000000
--- a/internal/trackers/impl/mtv/definition.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	descriptionmtv "github.com/autobrr/upbrr/internal/services/description/mtv"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "MTV"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	var err error
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
-			}
-			if req.Logger != nil {
-				req.Logger.Warnf("trackers: MTV description assets failed: %v", err)
-			}
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-
-	description := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		description, err = descriptionmtv.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.Screenshots)
-		if err != nil {
-			return trackers.DescriptionResult{}, fmt.Errorf("trackers: MTV description build: %w", err)
-		}
-	}
-
-	if strings.TrimSpace(description) == "" && req.Logger != nil {
-		req.Logger.Infof("trackers: MTV preparation description empty")
-	}
-
-	return trackers.DescriptionResult{
-		Group:       "mtv",
-		Description: description,
-	}, nil
-}
diff --git a/internal/trackers/impl/mtv/definition_test.go b/internal/trackers/impl/mtv/definition_test.go
deleted file mode 100644
index 02e8c72b..00000000
--- a/internal/trackers/impl/mtv/definition_test.go
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildDescriptionUsesMTVGroup(t *testing.T) {
-	d := New()
-	result, err := d.BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "MTV",
-		Meta:    api.PreparedMetadata{},
-		Logger:  api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if result.Group != "mtv" {
-		t.Fatalf("expected mtv group, got %q", result.Group)
-	}
-}
-
-func TestDefinitionUploadMissingCookieFile(t *testing.T) {
-	d := New()
-	_, err := d.Upload(context.Background(), trackers.UploadRequest{
-		Tracker:   "MTV",
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "ua.db")}},
-		Logger:    api.NopLogger{},
-	})
-	if err == nil {
-		t.Fatal("expected missing cookie file error")
-	}
-}
-
-func TestDefinitionUploadSuccess(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "ua.db")
-	cookieDir := filepath.Join(tmp, "cookies")
-	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
-		t.Fatalf("mkdir cookie dir: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(cookieDir, "MTV.json"), []byte(`{"session":"cookievalue"}`), 0o600); err != nil {
-		t.Fatalf("write cookie file: %v", err)
-	}
-	torrentPath := filepath.Join(tmp, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("...authkey=1234567890abcdef1234567890abcdef..."))
-		case "/upload.php":
-			if err := r.ParseMultipartForm(5 << 20); err != nil {
-				t.Errorf("parse multipart: %v", err)
-				return
-			}
-			if r.FormValue("auth") == "" {
-				t.Error("expected auth field")
-				return
-			}
-			http.Redirect(w, r, "/torrents.php?id=55", http.StatusFound)
-		case "/torrents.php":
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	d := New()
-	result, err := d.Upload(context.Background(), trackers.UploadRequest{
-		Tracker: "MTV",
-		Meta: api.PreparedMetadata{
-			SourcePath:      filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:     torrentPath,
-			ExternalIDs:     api.ExternalIDs{Category: "MOVIE"},
-			Type:            "WEBDL",
-			VideoCodec:      "HEVC",
-			ReleaseName:     "My.Release.2026.2160p.WEBDL.HEVC",
-			ServiceLongName: "Netflix",
-		},
-		TrackerConfig: config.TrackerConfig{URL: server.URL},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
-	}
-}
-
-func TestDefinitionUploadLoginBootstrapSuccess(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "ua.db")
-	torrentPath := filepath.Join(tmp, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			if r.Method == http.MethodGet {
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte(`<input name="token" value="123456789012345678901234567890123456789012345678"/>`))
-				return
-			}
-			if err := r.ParseForm(); err != nil {
-				t.Errorf("parse login form: %v", err)
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
-				t.Error("unexpected login credentials")
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "cookievalue", Path: "/"})
-			http.Redirect(w, r, "/index.php", http.StatusFound)
-		case "/index.php":
-			if _, err := r.Cookie("session"); err != nil {
-				w.WriteHeader(http.StatusUnauthorized)
-				return
-			}
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("...authkey=abcdefabcdefabcdefabcdefabcdefab..."))
-		case "/upload.php":
-			if err := r.ParseMultipartForm(5 << 20); err != nil {
-				t.Errorf("parse multipart: %v", err)
-				return
-			}
-			if r.FormValue("auth") == "" {
-				t.Error("expected auth field")
-				return
-			}
-			http.Redirect(w, r, "/torrents.php?id=99", http.StatusFound)
-		case "/torrents.php":
-			if _, err := url.ParseRequestURI(r.RequestURI); err != nil {
-				t.Errorf("invalid request uri: %v", err)
-				return
-			}
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	d := New()
-	result, err := d.Upload(context.Background(), trackers.UploadRequest{
-		Tracker: "MTV",
-		Meta: api.PreparedMetadata{
-			SourcePath:      filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:     torrentPath,
-			ExternalIDs:     api.ExternalIDs{Category: "MOVIE"},
-			Type:            "WEBDL",
-			VideoCodec:      "HEVC",
-			ReleaseName:     "My.Release.2026.2160p.WEBDL.HEVC",
-			ServiceLongName: "Netflix",
-		},
-		TrackerConfig: config.TrackerConfig{URL: server.URL, Username: "user", Password: "pass"},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
-	}
-	if _, err := os.Stat(filepath.Join(tmp, "cookies", "MTV.json")); !os.IsNotExist(err) {
-		if err == nil {
-			t.Fatalf("expected no legacy MTV cookie file after login bootstrap; file exists")
-		}
-		t.Fatalf("expected no legacy MTV cookie file after login bootstrap; unexpected stat error: %v", err)
-	}
-}
diff --git a/internal/trackers/impl/mtv/upload.go b/internal/trackers/impl/mtv/upload.go
deleted file mode 100644
index 70b5ae0e..00000000
--- a/internal/trackers/impl/mtv/upload.go
+++ /dev/null
@@ -1,847 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"bytes"
-	"context"
-	"crypto/hmac"
-	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
-	"encoding/base32"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/services/db"
-	descriptionmtv "github.com/autobrr/upbrr/internal/services/description/mtv"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	mtvBaseURL      = "https://www.morethantv.me"
-	mtvUploadPath   = "/upload.php"
-	mtvIndexPath    = "/index.php"
-	mtvUserAgentWeb = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-)
-
-var mtvTokenPattern = regexp.MustCompile(`name="token"\s+value="([^"]{16,128})"`)
-
-// ErrSubmitted2FARejected marks an MTV failure after a submitted manual 2FA code
-// reached the tracker and was rejected.
-var ErrSubmitted2FARejected = errors.New("trackers: MTV submitted 2FA rejected")
-
-var errMTVAuthKeyNotFound = errors.New("trackers: MTV auth key not found")
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	select {
-	case <-ctx.Done():
-		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	baseURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if baseURL == "" {
-		baseURL = mtvBaseURL
-	}
-	uploadURL := baseURL + mtvUploadPath
-
-	cookies, err := loadMTVCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		cookies = nil
-	}
-	auth, client, err := resolveAuthKey(ctx, baseURL, cookies)
-	if err != nil {
-		if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
-			if cookies == nil {
-				return api.UploadSummary{}, errors.New("trackers: MTV cookie invalid/missing and username/password not configured")
-			}
-			return api.UploadSummary{}, err
-		}
-		var effectiveBaseURL string
-		auth, client, cookies, effectiveBaseURL, err = loginAndResolveAuthKey(ctx, req.TrackerConfig, baseURL, api.TrackerAuthLoginRequest{})
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		if strings.TrimSpace(effectiveBaseURL) != "" && !strings.EqualFold(effectiveBaseURL, baseURL) {
-			baseURL = effectiveBaseURL
-			uploadURL = baseURL + mtvUploadPath
-		}
-		if persistErr := saveMTVCookies(ctx, req.AppConfig.MainSettings.DBPath, cookies); persistErr != nil && req.Logger != nil {
-			req.Logger.Warnf("trackers: MTV failed to persist cookies: %v", persistErr)
-		}
-	}
-
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	descText := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		descText, err = descriptionmtv.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.Screenshots)
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	fields := buildUploadFields(req, auth, descText)
-	body, contentType, err := buildMultipartPayload(fields, torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: MTV request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", mtvUserAgentWeb)
-
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: MTV upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
-
-	if resp.StatusCode == http.StatusBadRequest {
-		preview := string(bodyPreview)
-		if strings.Contains(preview, "Request Header") || strings.Contains(preview, "Cookie Too Large") || strings.Contains(preview, "Header Too Large") {
-			return api.UploadSummary{}, errors.New("trackers: MTV data error (request header/cookie too large)")
-		}
-	}
-
-	if strings.Contains(finalURL, "torrents.php") {
-		return api.UploadSummary{Uploaded: 1}, nil
-	}
-
-	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("MTV", resp.StatusCode, finalURL, bodyPreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	select {
-	case <-ctx.Done():
-		return api.TrackerDryRunEntry{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	var err error
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	descText := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		descText, err = descriptionmtv.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.Screenshots)
-		if err != nil {
-			return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-
-	baseURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if baseURL == "" {
-		baseURL = mtvBaseURL
-	}
-	uploadURL := baseURL + mtvUploadPath
-
-	const dryRunAuthPlaceholder = "dry-run-auth"
-	fields := buildUploadFields(req, dryRunAuthPlaceholder, descText)
-
-	return api.TrackerDryRunEntry{
-		Tracker:          "MTV",
-		Status:           "ready",
-		Message:          "dry-run payload generated (auth placeholder used)",
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "mtv",
-		Description:      descText,
-		Endpoint:         uploadURL,
-		Payload:          fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file_input",
-			Path:    torrentPath,
-			Present: strings.TrimSpace(torrentPath) != "",
-		}},
-	}, nil
-}
-
-func resolveAuthKey(ctx context.Context, baseURL string, cookies map[string]string) (string, *http.Client, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV create auth cookie jar: %w", err)
-	}
-	parsedBase, err := url.Parse(baseURL)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV parse base URL: %w", err)
-	}
-	jarCookies := make([]*http.Cookie, 0, len(cookies))
-	for name, value := range cookies {
-		if strings.TrimSpace(name) == "" || strings.TrimSpace(value) == "" {
-			continue
-		}
-		// #nosec G124 -- Outbound tracker jar cookie mirrors configured MTV session values.
-		jarCookies = append(jarCookies, &http.Cookie{Name: name, Value: value, Path: "/", Domain: parsedBase.Hostname()})
-	}
-	jar.SetCookies(parsedBase, jarCookies)
-
-	client := &http.Client{Timeout: 20 * time.Second, Jar: jar}
-	indexURL := strings.TrimRight(baseURL, "/") + mtvIndexPath
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, indexURL, nil)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV build auth request: %w", err)
-	}
-	req.Header.Set("User-Agent", mtvUserAgentWeb)
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV auth request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return "", nil, fmt.Errorf("trackers: MTV auth key lookup failed %s: auth status %d", mtvResponseTrace(resp), resp.StatusCode)
-	}
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV read auth response: %w", err)
-	}
-	auth := extractMTVAuthKey(string(body))
-	if auth == "" {
-		return "", nil, fmt.Errorf("%w: %s", errMTVAuthKeyNotFound, mtvResponseTrace(resp))
-	}
-	return auth, client, nil
-}
-
-func loadMTVCookies(ctx context.Context, dbPath string) (map[string]string, error) {
-	return wrapTrackerResult(cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "MTV"))
-}
-
-func saveMTVCookies(ctx context.Context, dbPath string, values map[string]string) error {
-	return wrapTrackerError(cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "MTV", values))
-}
-
-// ResolveSessionForTrackerAuth validates MTV stored cookies or logs in with
-// configured credentials. After a successful login, cookie persistence failures
-// are returned distinctly from remote authentication failures.
-func ResolveSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string) error {
-	return ResolveSessionForTrackerAuthLogin(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{})
-}
-
-// ResolveSessionForTrackerAuthLogin validates MTV stored cookies or logs in
-// with configured credentials. When MTV requires 2FA, login.Code is used before
-// falling back to the configured OTP URI; if neither yields a code, the error
-// is returned before stored cookies are replaced. A rejected submitted code can
-// return [ErrSubmitted2FARejected] with the auth-key lookup failure before
-// refreshed cookies are persisted. Response read errors are returned directly
-// and are not classified as submitted-code rejections.
-func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
-	baseURL := strings.TrimRight(strings.TrimSpace(cfg.URL), "/")
-	if baseURL == "" {
-		baseURL = mtvBaseURL
-	}
-	cookies, err := loadMTVCookies(ctx, dbPath)
-	if err == nil && len(cookies) > 0 {
-		if _, _, err := resolveAuthKey(ctx, baseURL, cookies); err == nil {
-			return nil
-		} else if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-			return err
-		}
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return errors.New("trackers: MTV cookie invalid/missing and username/password not configured")
-	}
-	_, _, values, _, err := loginAndResolveAuthKey(ctx, cfg, baseURL, login)
-	if err != nil {
-		return err
-	}
-	if len(values) == 0 {
-		return errors.New("trackers: MTV login returned no usable cookies")
-	}
-	if err := saveMTVCookies(ctx, dbPath, values); err != nil {
-		return fmt.Errorf("trackers: MTV persist cookies after successful login: %w", err)
-	}
-	return nil
-}
-
-// loginAndResolveAuthKey performs MTV login, optional TOTP submission, and auth
-// key discovery. MTV can return authkey in the final login response, so that
-// body is checked before falling back to the index page. Missing form tokens
-// and auth-key parser failures remain ordinary errors unless an auth-key miss
-// follows a submitted manual code. Authenticated cookies and the effective base
-// URL are returned only after auth-key discovery so upload can reuse any
-// canonical host reached during login redirects.
-func loginAndResolveAuthKey(ctx context.Context, cfg config.TrackerConfig, baseURL string, login api.TrackerAuthLoginRequest) (string, *http.Client, map[string]string, string, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 25 * time.Second, Jar: jar}
-
-	loginURL := strings.TrimRight(baseURL, "/") + "/login"
-	loginReq, err := http.NewRequestWithContext(ctx, http.MethodGet, loginURL, nil)
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV build login page request: %w", err)
-	}
-	loginReq.Header.Set("User-Agent", mtvUserAgentWeb)
-	loginResp, err := client.Do(loginReq)
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV login page request: %w", err)
-	}
-	loginBody, err := io.ReadAll(loginResp.Body)
-	_ = loginResp.Body.Close()
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV read login page response: %w", err)
-	}
-	effectiveBaseURL := mtvEffectiveBaseURL(baseURL, loginResp)
-	effectiveLoginURL := strings.TrimRight(effectiveBaseURL, "/") + "/login"
-	match := mtvTokenPattern.FindStringSubmatch(string(loginBody))
-	if len(match) < 2 {
-		return "", nil, nil, "", errors.New("trackers: MTV login token not found")
-	}
-	token := strings.TrimSpace(match[1])
-
-	form := url.Values{}
-	form.Set("username", strings.TrimSpace(cfg.Username))
-	form.Set("password", strings.TrimSpace(cfg.Password))
-	form.Set("keeploggedin", "1")
-	form.Set("cinfo", "1920|1080|24|0")
-	form.Set("submit", "login")
-	form.Set("iplocked", "1")
-	form.Set("token", token)
-
-	postReq, err := http.NewRequestWithContext(ctx, http.MethodPost, effectiveLoginURL, strings.NewReader(form.Encode()))
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV build login request: %w", err)
-	}
-	postReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	postReq.Header.Set("User-Agent", mtvUserAgentWeb)
-	postResp, err := client.Do(postReq)
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV login request: %w", err)
-	}
-	body, err := io.ReadAll(postResp.Body)
-	_ = postResp.Body.Close()
-	if err != nil {
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV read login response: %w", err)
-	}
-	finalAuthBody := string(body)
-	finalAuthTrace := mtvResponseTrace(postResp)
-
-	submittedManualCode := false
-	if postResp.Request != nil && postResp.Request.URL != nil && strings.Contains(postResp.Request.URL.Path, "/twofactor/login") {
-		twoFactorTokenMatch := mtvTokenPattern.FindStringSubmatch(string(body))
-		if len(twoFactorTokenMatch) < 2 {
-			return "", nil, nil, "", errors.New("trackers: MTV 2FA token not found")
-		}
-		code, err := resolveMTV2FACode(cfg, login)
-		if err != nil {
-			return "", nil, nil, "", err
-		}
-		twoFactorForm := url.Values{}
-		twoFactorForm.Set("token", twoFactorTokenMatch[1])
-		twoFactorForm.Set("code", code)
-		twoFactorForm.Set("submit", "login")
-		twoReq, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(effectiveBaseURL, "/")+"/twofactor/login", strings.NewReader(twoFactorForm.Encode()))
-		if err != nil {
-			return "", nil, nil, "", fmt.Errorf("trackers: MTV build 2FA login request: %w", err)
-		}
-		twoReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		twoReq.Header.Set("User-Agent", mtvUserAgentWeb)
-		twoResp, err := client.Do(twoReq)
-		if err != nil {
-			return "", nil, nil, "", fmt.Errorf("trackers: MTV 2FA login request: %w", err)
-		}
-		twoFactorBody, err := io.ReadAll(twoResp.Body)
-		_ = twoResp.Body.Close()
-		if err != nil {
-			return "", nil, nil, "", fmt.Errorf("trackers: MTV read 2FA login response: %w", err)
-		}
-		finalAuthBody = string(twoFactorBody)
-		finalAuthTrace = mtvResponseTrace(twoResp)
-		submittedManualCode = strings.TrimSpace(login.Code) != ""
-	}
-
-	if auth := extractMTVAuthKey(finalAuthBody); auth != "" {
-		cookieMap := cookiesFromJar(effectiveBaseURL, client.Jar)
-		return auth, client, cookieMap, effectiveBaseURL, nil
-	}
-	auth, authedClient, err := resolveAuthKeyFromClient(ctx, effectiveBaseURL, client)
-	if err != nil {
-		if submittedManualCode && errors.Is(err, errMTVAuthKeyNotFound) {
-			return "", nil, nil, "", fmt.Errorf("trackers: MTV auth key not found after submitted 2FA final_%s: %w: %w", finalAuthTrace, err, ErrSubmitted2FARejected)
-		}
-		if errors.Is(err, errMTVAuthKeyNotFound) {
-			return "", nil, nil, "", fmt.Errorf("trackers: MTV auth key not found after login final_%s: %w", finalAuthTrace, err)
-		}
-		return "", nil, nil, "", fmt.Errorf("trackers: MTV auth key lookup after login final_%s: %w", finalAuthTrace, err)
-	}
-	cookieMap := cookiesFromJar(effectiveBaseURL, authedClient.Jar)
-	return auth, authedClient, cookieMap, effectiveBaseURL, nil
-}
-
-func mtvEffectiveBaseURL(fallback string, resp *http.Response) string {
-	if resp == nil || resp.Request == nil || resp.Request.URL == nil {
-		return strings.TrimRight(fallback, "/")
-	}
-	u := resp.Request.URL
-	if strings.TrimSpace(u.Scheme) == "" || strings.TrimSpace(u.Host) == "" {
-		return strings.TrimRight(fallback, "/")
-	}
-	return u.Scheme + "://" + u.Host
-}
-
-func mtvResponseTrace(resp *http.Response) string {
-	if resp == nil {
-		return "path=unknown status=0"
-	}
-	path := "unknown"
-	if resp.Request != nil && resp.Request.URL != nil {
-		path = resp.Request.URL.EscapedPath()
-		if strings.TrimSpace(path) == "" {
-			path = "/"
-		}
-	}
-	return fmt.Sprintf("path=%s status=%d", path, resp.StatusCode)
-}
-
-func extractMTVAuthKey(body string) string {
-	const marker = "authkey="
-	idx := strings.LastIndex(body, marker)
-	if idx < 0 {
-		return ""
-	}
-	raw := strings.TrimSpace(body[idx+len(marker):])
-	if len(raw) < 32 {
-		return ""
-	}
-	return raw[:32]
-}
-
-// resolveMTV2FACode prefers a submitted manual code so users can continue a
-// browser-visible challenge when no reusable OTP URI is configured.
-func resolveMTV2FACode(cfg config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
-	if code := strings.TrimSpace(login.Code); code != "" {
-		return code, nil
-	}
-	code, err := totpFromOTPURI(strings.TrimSpace(cfg.OTPURI), time.Now())
-	if err != nil {
-		return "", fmt.Errorf("trackers: MTV 2FA required but otp_uri invalid: %w", err)
-	}
-	return code, nil
-}
-
-func resolveAuthKeyFromClient(ctx context.Context, baseURL string, client *http.Client) (string, *http.Client, error) {
-	indexURL := strings.TrimRight(baseURL, "/") + mtvIndexPath
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, indexURL, nil)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV build auth request: %w", err)
-	}
-	req.Header.Set("User-Agent", mtvUserAgentWeb)
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV auth request: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return "", nil, fmt.Errorf("trackers: MTV auth key lookup failed %s: auth status %d", mtvResponseTrace(resp), resp.StatusCode)
-	}
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", nil, fmt.Errorf("trackers: MTV read auth response: %w", err)
-	}
-	auth := extractMTVAuthKey(string(body))
-	if auth == "" {
-		return "", nil, fmt.Errorf("%w: %s", errMTVAuthKeyNotFound, mtvResponseTrace(resp))
-	}
-	return auth, client, nil
-}
-
-func cookiesFromJar(baseURL string, jar http.CookieJar) map[string]string {
-	if jar == nil {
-		return nil
-	}
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return nil
-	}
-	out := make(map[string]string)
-	for _, cookie := range jar.Cookies(parsed) {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		out[strings.TrimSpace(cookie.Name)] = cookie.Value
-	}
-	return out
-}
-
-func totpFromOTPURI(otpURI string, now time.Time) (string, error) {
-	trimmed := strings.TrimSpace(otpURI)
-	if trimmed == "" {
-		return "", errors.New("empty otp_uri")
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("trackers: MTV parse otp_uri: %w", err)
-	}
-	query := parsed.Query()
-	secret := strings.TrimSpace(query.Get("secret"))
-	if secret == "" {
-		return "", errors.New("missing secret query parameter")
-	}
-	interval := 30
-	if period := strings.TrimSpace(query.Get("period")); period != "" {
-		if value, err := strconv.Atoi(period); err == nil && value > 0 {
-			interval = value
-		}
-	}
-	counterTime := now.Unix() / int64(interval)
-	if counterTime < 0 {
-		return "", errors.New("totp counter before unix epoch")
-	}
-	counter := uint64(counterTime)
-
-	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
-	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
-	if err != nil {
-		return "", fmt.Errorf("trackers: MTV decode otp secret: %w", err)
-	}
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint64(buf, counter)
-	mac := hmac.New(sha1.New, secretBytes)
-	_, _ = mac.Write(buf)
-	hash := mac.Sum(nil)
-	offset := hash[len(hash)-1] & 0x0f
-	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
-	return fmt.Sprintf("%06d", code%1000000), nil
-}
-
-func buildUploadFields(req trackers.UploadRequest, auth string, description string) map[string]string {
-	meta := req.Meta
-	anon := "1"
-	if !req.TrackerConfig.Anon {
-		anon = "0"
-	}
-	return map[string]string{
-		"image":               "",
-		"title":               resolveUploadName(meta),
-		"category":            resolveCategoryID(meta),
-		"Resolution":          resolveResolutionID(meta),
-		"source":              resolveSourceID(meta),
-		"origin":              resolveOriginID(meta),
-		"taglist":             resolveTags(meta),
-		"desc":                strings.TrimSpace(description),
-		"groupDesc":           resolveGroupDescription(meta),
-		"ignoredupes":         "1",
-		"genre_tags":          "---",
-		"autocomplete_toggle": "on",
-		"fontfont":            "-1",
-		"fontsize":            "-1",
-		"auth":                auth,
-		"anonymous":           anon,
-		"submit":              "true",
-	}
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: MTV write multipart field %q: %w", key, err)
-		}
-	}
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: MTV open torrent file: %w", err)
-	}
-	defer file.Close()
-	part, err := writer.CreateFormFile("file_input", "[MTV].torrent")
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: MTV create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: MTV copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: MTV close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	candidates := []string{
-		strings.TrimSpace(meta.TorrentPath),
-		strings.TrimSpace(meta.ClientTorrentPath),
-		strings.TrimSpace(meta.SourcePath),
-	}
-	for _, candidate := range candidates {
-		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
-			continue
-		}
-		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
-			return candidate, nil
-		}
-	}
-	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
-		tmpRoot, err := db.Subdir(dbPath, "tmp")
-		if err == nil {
-			tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-			if err == nil {
-				guessed := filepath.Join(tmpDir, base+".torrent")
-				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
-					return guessed, nil
-				}
-			}
-		}
-	}
-	return "", errors.New("trackers: MTV torrent file not found")
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
-		return cleanName(name)
-	}
-	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
-		return cleanName(name)
-	}
-	if name := strings.TrimSpace(meta.Filename); name != "" {
-		return cleanName(name)
-	}
-	return cleanName(pathutil.Base(meta.SourcePath))
-}
-
-func cleanName(value string) string {
-	value = strings.Join(strings.Fields(value), " ")
-	value = strings.ReplaceAll(value, " ", ".")
-	value = strings.ReplaceAll(value, "..", ".")
-	return strings.TrimSpace(value)
-}
-
-func resolveResolution(meta api.PreparedMetadata) string {
-	if value := strings.TrimSpace(meta.Release.Resolution); value != "" {
-		return value
-	}
-	if strings.TrimSpace(meta.UHD) != "" {
-		return "2160p"
-	}
-	return ""
-}
-
-func resolveResolutionID(meta api.PreparedMetadata) string {
-	res := strings.ToLower(strings.TrimSpace(resolveResolution(meta)))
-	values := map[string]string{
-		"8640p": "0", "4320p": "4000", "2160p": "2160", "1440p": "1440", "1080p": "1080", "1080i": "1080", "720p": "720", "576p": "0", "576i": "0", "480p": "480", "480i": "480",
-	}
-	if value, ok := values[res]; ok {
-		return value
-	}
-	return "10"
-}
-
-func isSD(meta api.PreparedMetadata) bool {
-	res := strings.ToLower(resolveResolution(meta))
-	return strings.Contains(res, "480") || strings.Contains(res, "576")
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	category := strings.ToUpper(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToUpper(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	return category
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) string {
-	category := resolveCategory(meta)
-	if category == "MOVIE" {
-		if isSD(meta) {
-			return "2"
-		}
-		return "1"
-	}
-	if category == "TV" {
-		if meta.TVPack {
-			if isSD(meta) {
-				return "6"
-			}
-			return "5"
-		}
-		if isSD(meta) {
-			return "4"
-		}
-		return "3"
-	}
-	return "0"
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	value := strings.ToUpper(strings.TrimSpace(meta.Type))
-	if value == "" {
-		value = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
-	}
-	return strings.ReplaceAll(strings.ReplaceAll(value, "-", ""), " ", "")
-}
-
-func resolveSourceID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return "1"
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || resolveType(meta) == "REMUX" {
-		return "7"
-	}
-	mapping := map[string]string{
-		"DISC": "1", "WEBDL": "9", "WEBRIP": "10", "HDTV": "1", "SDTV": "2", "TVRIP": "3", "DVD": "4", "DVDRIP": "5", "BDRIP": "8", "VHS": "6", "MIXED": "11", "ENCODE": "7",
-	}
-	if value, ok := mapping[resolveType(meta)]; ok {
-		return value
-	}
-	return "0"
-}
-
-func resolveOriginID(meta api.PreparedMetadata) string {
-	if meta.PersonalRelease {
-		return "4"
-	}
-	if meta.Scene {
-		return "2"
-	}
-	return "3"
-}
-
-func resolveTags(meta api.PreparedMetadata) string {
-	tags := make([]string, 0, 12)
-	resolution := strings.ToLower(strings.TrimSpace(resolveResolution(meta)))
-	if resolution != "" {
-		tags = append(tags, resolution)
-	}
-	switch {
-	case isSD(meta):
-		tags = append(tags, "sd")
-	case resolution == "2160p" || resolution == "4320p":
-		tags = append(tags, "uhd")
-	default:
-		tags = append(tags, "hd")
-	}
-	if service := strings.TrimSpace(meta.ServiceLongName); service != "" {
-		svc := strings.ToLower(strings.ReplaceAll(service, " ", "."))
-		svc = strings.ReplaceAll(svc, "+", "plus")
-		tags = append(tags, svc+".source")
-	}
-	switch category := resolveCategory(meta); category {
-	case "TV":
-		switch {
-		case meta.TVPack && isSD(meta):
-			tags = append(tags, "sd.season")
-		case meta.TVPack:
-			tags = append(tags, "hd.season")
-		case isSD(meta):
-			tags = append(tags, "sd.episode")
-		default:
-			tags = append(tags, "hd.episode")
-		}
-	case "MOVIE":
-		if isSD(meta) {
-			tags = append(tags, "sd.movie")
-		} else {
-			tags = append(tags, "hd.movie")
-		}
-	}
-	audio := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(meta.Audio, "+", "p"), "-", "."), " ", "."))
-	for _, token := range []string{"dd", "ddp", "aac", "truehd", "mp3", "mp2", "dts", "dts.hd", "dts.x"} {
-		if strings.Contains(audio, token) {
-			tags = append(tags, token+".audio")
-			break
-		}
-	}
-	if strings.Contains(strings.ToLower(meta.Audio), "atmos") {
-		tags = append(tags, "atmos.audio")
-	}
-	codec := strings.ReplaceAll(strings.ReplaceAll(strings.ToLower(meta.VideoCodec), "avc", "h264"), "hevc", "h265")
-	codec = strings.ReplaceAll(codec, "-", "")
-	if strings.TrimSpace(codec) != "" {
-		tags = append(tags, strings.TrimSpace(codec))
-	}
-	if tag := strings.TrimSpace(meta.Tag); tag != "" {
-		tags = append(tags, strings.TrimPrefix(strings.ReplaceAll(tag, " ", "."), "-")+".release")
-	} else {
-		tags = append(tags, "NOGRP.release")
-	}
-	if meta.Scene {
-		tags = append(tags, "scene.group.release")
-	} else {
-		tags = append(tags, "p2p.group.release")
-	}
-	return strings.Join(tags, " ")
-}
-
-func resolveGroupDescription(meta api.PreparedMetadata) string {
-	parts := make([]string, 0, 5)
-	if meta.ExternalMetadata.IMDB != nil {
-		if imdbURL := strings.TrimSpace(meta.ExternalMetadata.IMDB.IMDbURL); imdbURL != "" {
-			parts = append(parts, imdbURL)
-		}
-	}
-	if meta.ExternalIDs.TMDBID != 0 {
-		category := strings.ToLower(strings.TrimSpace(resolveCategory(meta)))
-		if category == "" {
-			category = "movie"
-		}
-		parts = append(parts, "https://www.themoviedb.org/"+category+"/"+strconv.Itoa(meta.ExternalIDs.TMDBID))
-	}
-	if strings.EqualFold(resolveCategory(meta), "TV") && meta.ExternalIDs.TVDBID != 0 {
-		parts = append(parts, "https://www.thetvdb.com/?id="+strconv.Itoa(meta.ExternalIDs.TVDBID))
-	}
-	if meta.ExternalIDs.TVmazeID != 0 {
-		parts = append(parts, "https://www.tvmaze.com/shows/"+strconv.Itoa(meta.ExternalIDs.TVmazeID))
-	}
-	if meta.ExternalIDs.MALID != 0 {
-		parts = append(parts, "https://myanimelist.net/anime/"+strconv.Itoa(meta.ExternalIDs.MALID))
-	}
-	return strings.Join(parts, "\n")
-}
diff --git a/internal/trackers/impl/mtv/upload_test.go b/internal/trackers/impl/mtv/upload_test.go
deleted file mode 100644
index ec67f087..00000000
--- a/internal/trackers/impl/mtv/upload_test.go
+++ /dev/null
@@ -1,734 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestResolveGroupDescriptionSkipsTVDBForMovie(t *testing.T) {
-	got := resolveGroupDescription(api.PreparedMetadata{
-		MediaInfoCategory: "TV",
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE", TVDBID: 456},
-	})
-	if strings.Contains(got, "thetvdb.com") {
-		t.Fatalf("did not expect tvdb link for movie description, got %q", got)
-	}
-}
-
-func TestResolveGroupDescriptionIncludesTVDBForTV(t *testing.T) {
-	got := resolveGroupDescription(api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV", TVDBID: 456},
-	})
-	if !strings.Contains(got, "thetvdb.com/?id=456") {
-		t.Fatalf("expected tvdb link for TV description, got %q", got)
-	}
-}
-
-func TestExtractMTVAuthKeyMatchesUploadAssistantShape(t *testing.T) {
-	t.Parallel()
-
-	auth := "abcdefghijklmnopqrstuvwxyzABCDEF"
-	tests := map[string]string{
-		"plain":       "authkey=" + auth,
-		"query tail":  "https://example.test/upload?authkey=" + auth + "&x=1",
-		"last marker": "authkey=oldoldoldoldoldoldoldoldoldoldoldold authkey=" + auth + `">`,
-	}
-	for name, body := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			if got := extractMTVAuthKey(body); got != auth {
-				t.Fatal("expected extracted auth key")
-			}
-		})
-	}
-}
-
-func TestResolveSessionForTrackerAuthPreservesCookiesOnTransientAuthFetch(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("saveMTVCookies: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
-	baseURL := server.URL
-	server.Close()
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      baseURL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath)
-	if err == nil {
-		t.Fatal("expected transient auth fetch error")
-	}
-	got, loadErr := loadMTVCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadMTVCookies after transient error: %v", loadErr)
-	}
-	if got["session"] != "abc" {
-		t.Fatalf("expected transient failure to preserve cookies, got %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthReportsPostLoginCookiePersistenceFailure(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "abc", Path: "/"})
-			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-		case "/index.php":
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuth(context.Background(), config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, filepath.Join(t.TempDir(), "upbrr.db"))
-	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
-		t.Fatalf("expected auth helper unavailable error, got %v", err)
-	}
-	if !strings.Contains(err.Error(), "persist cookies after successful login") {
-		t.Fatalf("expected distinct persistence failure, got %v", err)
-	}
-}
-
-func TestResolveSessionForTrackerAuthSavesCookiesWhenLoginResponseContainsAuthKey(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	indexRequests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "fresh", Path: "/"})
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		case "/index.php":
-			indexRequests++
-			_, _ = w.Write([]byte(`<html>logged out</html>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath)
-	if err != nil {
-		t.Fatalf("ResolveSessionForTrackerAuth: %v", err)
-	}
-	if indexRequests != 0 {
-		t.Fatalf("expected login response authkey to avoid index lookup, got %d", indexRequests)
-	}
-	got, err := loadMTVCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadMTVCookies: %v", err)
-	}
-	if got["session"] != "fresh" {
-		t.Fatalf("expected saved login cookies, got %#v", got)
-	}
-}
-
-func TestLoginAndResolveAuthKeyReturnsLoginPageReadError(t *testing.T) {
-	t.Parallel()
-
-	handlerErrs := make(chan string, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/login" && r.Method == http.MethodGet:
-			if err := writeMalformedChunkedResponse(w); err != nil {
-				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
-			}
-		default:
-			recordHandlerError(handlerErrs, "unexpected request %s %s", r.Method, r.URL.Path)
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	_, _, _, _, err := loginAndResolveAuthKey(context.Background(), config.TrackerConfig{
-		Username: "user",
-		Password: "pass",
-	}, server.URL, api.TrackerAuthLoginRequest{})
-	assertNoHandlerError(t, handlerErrs)
-	if err == nil {
-		t.Fatal("expected login page read error")
-	}
-	if !strings.Contains(err.Error(), "read login page response") {
-		t.Fatalf("expected login page read-error context, got %v", err)
-	}
-}
-
-func TestLoginAndResolveAuthKeyReturnsLoginPostReadError(t *testing.T) {
-	t.Parallel()
-
-	handlerErrs := make(chan string, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/login" && r.Method == http.MethodGet:
-			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-		case r.URL.Path == "/login" && r.Method == http.MethodPost:
-			if err := writeMalformedChunkedResponse(w); err != nil {
-				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
-			}
-		default:
-			recordHandlerError(handlerErrs, "unexpected request %s %s", r.Method, r.URL.Path)
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	_, _, _, _, err := loginAndResolveAuthKey(context.Background(), config.TrackerConfig{
-		Username: "user",
-		Password: "pass",
-	}, server.URL, api.TrackerAuthLoginRequest{})
-	assertNoHandlerError(t, handlerErrs)
-	if err == nil {
-		t.Fatal("expected login response read error")
-	}
-	if !strings.Contains(err.Error(), "read login response") {
-		t.Fatalf("expected login response read-error context, got %v", err)
-	}
-}
-
-func TestResolveSessionForTrackerAuthPostsLoginToRedirectedHost(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	var canonicalURL string
-	postedCanonicalLogin := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/login" && r.Method == http.MethodGet && strings.HasPrefix(r.Host, "localhost:"):
-			http.Redirect(w, r, canonicalURL+"/login", http.StatusFound)
-		case r.URL.Path == "/login" && r.Method == http.MethodGet:
-			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-		case r.URL.Path == "/login" && r.Method == http.MethodPost && strings.HasPrefix(r.Host, "localhost:"):
-			t.Error("login POST used original host")
-			return
-		case r.URL.Path == "/login" && r.Method == http.MethodPost:
-			postedCanonicalLogin = true
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "fresh", Path: "/"})
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-	canonicalURL = server.URL
-	sourceURL := strings.Replace(server.URL, "127.0.0.1", "localhost", 1)
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      sourceURL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath)
-	if err != nil {
-		t.Fatalf("ResolveSessionForTrackerAuth: %v", err)
-	}
-	if !postedCanonicalLogin {
-		t.Fatal("expected login POST on redirected host")
-	}
-	got, err := loadMTVCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadMTVCookies: %v", err)
-	}
-	if got["session"] != "fresh" {
-		t.Fatalf("expected saved redirected-login cookies, got %#v", got)
-	}
-}
-
-func TestUploadPostsToRedirectedLoginHost(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	torrentPath := filepath.Join(t.TempDir(), "release.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	var canonicalURL string
-	postedCanonicalUpload := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/login" && r.Method == http.MethodGet && strings.HasPrefix(r.Host, "localhost:"):
-			http.Redirect(w, r, canonicalURL+"/login", http.StatusFound)
-		case r.URL.Path == "/login" && r.Method == http.MethodGet:
-			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-		case r.URL.Path == "/login" && r.Method == http.MethodPost:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "fresh", Path: "/"})
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		case r.URL.Path == mtvUploadPath && r.Method == http.MethodPost && strings.HasPrefix(r.Host, "localhost:"):
-			t.Error("upload POST used original host")
-			return
-		case r.URL.Path == mtvUploadPath && r.Method == http.MethodPost:
-			postedCanonicalUpload = true
-			if _, err := r.Cookie("session"); err != nil {
-				t.Errorf("expected session cookie on canonical upload: %v", err)
-				return
-			}
-			http.Redirect(w, r, canonicalURL+"/torrents.php?id=1", http.StatusFound)
-		case r.URL.Path == "/torrents.php":
-			_, _ = w.Write([]byte("ok"))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-	canonicalURL = server.URL
-	sourceURL := strings.Replace(server.URL, "127.0.0.1", "localhost", 1)
-
-	summary, err := upload(ctx, trackers.UploadRequest{
-		Tracker: "MTV",
-		Meta: api.PreparedMetadata{
-			TorrentPath: torrentPath,
-			ReleaseName: "Release",
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:      sourceURL,
-			Username: "user",
-			Password: "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Assets:    &trackers.DescriptionAssets{Final: true, Description: "desc"},
-	})
-	if err != nil {
-		t.Fatalf("upload: %v", err)
-	}
-	if summary.Uploaded != 1 {
-		t.Fatalf("expected upload success, got %#v", summary)
-	}
-	if !postedCanonicalUpload {
-		t.Fatal("expected upload POST on redirected host")
-	}
-}
-
-func TestResolveSessionForTrackerAuthRejectsEmptyLoginCookiesWithoutReplacingStoredCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("saveMTVCookies: %v", err)
-	}
-	indexRequests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			_, _ = w.Write([]byte(`<html>ok</html>`))
-		case "/index.php":
-			indexRequests++
-			if indexRequests == 1 {
-				_, _ = w.Write([]byte(`<html>logged out</html>`))
-				return
-			}
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath)
-	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
-		t.Fatalf("expected empty login cookie error, got %v", err)
-	}
-	got, loadErr := loadMTVCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadMTVCookies after empty login cookies: %v", loadErr)
-	}
-	if got["session"] != "existing" {
-		t.Fatalf("expected empty login cookies to preserve stored cookies, got %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthDoesNotPersistCookiesBeforeAuthKeyValidation(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "unverified", Path: "/"})
-			_, _ = w.Write([]byte(`<html>logged in without auth key</html>`))
-		case "/index.php":
-			_, _ = w.Write([]byte(`<html>temporary account notice</html>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath)
-	if err == nil || !strings.Contains(err.Error(), "auth key not found") {
-		t.Fatalf("expected auth-key validation failure, got %v", err)
-	}
-	if values, loadErr := loadMTVCookies(ctx, dbPath); !errors.Is(loadErr, cookiepkg.ErrTrackerCookiesNotFound) {
-		t.Fatalf("unverified login cookies persisted or unexpected load error values=%#v err=%v", values, loadErr)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginUsesManual2FACode(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	var gotCode string
-	indexRequests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			indexRequests++
-			_, _ = w.Write([]byte(`<html>logged out</html>`))
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
-		case "/twofactor/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
-				return
-			}
-			if err := r.ParseForm(); err != nil {
-				t.Errorf("ParseForm: %v", err)
-				return
-			}
-			gotCode = r.FormValue("code")
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "654321"})
-	if err != nil {
-		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
-	}
-	if gotCode != "654321" {
-		t.Fatalf("expected manual 2FA code, got %q", gotCode)
-	}
-	if indexRequests != 0 {
-		t.Fatalf("expected 2FA response authkey to avoid index lookup, got %d", indexRequests)
-	}
-	got, err := loadMTVCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadMTVCookies: %v", err)
-	}
-	if got["session"] != "new" {
-		t.Fatalf("expected saved 2FA login cookies, got %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginMarksSubmitted2FAAuthKeyMiss(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("saveMTVCookies: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			_, _ = w.Write([]byte(`<html>logged out</html>`))
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
-		case "/twofactor/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
-				return
-			}
-			_, _ = w.Write([]byte(`<html>invalid code</html>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"})
-	if !errors.Is(err, ErrSubmitted2FARejected) {
-		t.Fatalf("expected submitted 2FA rejection marker, got %v", err)
-	}
-	if !strings.Contains(err.Error(), "final_path=/twofactor/login status=200") || !strings.Contains(err.Error(), "path=/index.php status=200") {
-		t.Fatalf("expected safe path/status diagnostics, got %v", err)
-	}
-	got, loadErr := loadMTVCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadMTVCookies: %v", loadErr)
-	}
-	if got["session"] != "existing" {
-		t.Fatalf("submitted 2FA rejection must preserve stored cookies, got %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginReturns2FAReadError(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("saveMTVCookies: %v", err)
-	}
-	handlerErrs := make(chan string, 1)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			_, _ = w.Write([]byte(`<html>logged out</html>`))
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
-		case "/twofactor/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
-				return
-			}
-			if err := writeMalformedChunkedResponse(w); err != nil {
-				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
-			}
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "123456"})
-	assertNoHandlerError(t, handlerErrs)
-	if err == nil {
-		t.Fatal("expected 2FA response read error")
-	}
-	if errors.Is(err, ErrSubmitted2FARejected) {
-		t.Fatalf("read error must not be classified as submitted 2FA rejection: %v", err)
-	}
-	if !strings.Contains(err.Error(), "read 2FA login response") {
-		t.Fatalf("expected read-error context, got %v", err)
-	}
-	got, loadErr := loadMTVCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadMTVCookies: %v", loadErr)
-	}
-	if got["session"] != "existing" {
-		t.Fatalf("2FA read error must preserve stored cookies, got %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginReportsSafeAuthKeyDiagnostics(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-			_, _ = w.Write([]byte(`<html>login accepted but no upload token secret-response-body</html>`))
-		case "/index.php":
-			_, _ = w.Write([]byte(`<html>logged in but no upload token other-secret-body</html>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
-	if !errors.Is(err, errMTVAuthKeyNotFound) {
-		t.Fatalf("expected auth key miss, got %v", err)
-	}
-	if !strings.Contains(err.Error(), "final_path=/login status=200") || !strings.Contains(err.Error(), "path=/index.php status=200") {
-		t.Fatalf("expected path/status diagnostics, got %v", err)
-	}
-	for _, secret := range []string{"secret-response-body", "other-secret-body"} {
-		if strings.Contains(err.Error(), secret) {
-			t.Fatalf("diagnostic leaked response body %q: %v", secret, err)
-		}
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginMissing2FACodePreservesCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newMTVAuthDB(t)
-	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("saveMTVCookies: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/index.php":
-			_, _ = w.Write([]byte(`<html>logged out</html>`))
-		case "/login":
-			if r.Method == http.MethodGet {
-				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
-				return
-			}
-			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
-		case "/twofactor/login":
-			_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
-		Username: "user",
-		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
-	if err == nil || !strings.Contains(err.Error(), "2FA required") {
-		t.Fatalf("expected missing 2FA error, got %v", err)
-	}
-	got, loadErr := loadMTVCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadMTVCookies: %v", loadErr)
-	}
-	if got["session"] != "existing" {
-		t.Fatalf("missing 2FA code must preserve stored cookies, got %#v", got)
-	}
-}
-
-func newMTVAuthDB(t *testing.T) string {
-	t.Helper()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	_ = repo.Close()
-	return dbPath
-}
-
-// recordHandlerError preserves handler failures for assertion from the test
-// goroutine, where testing.T failures are safe to report.
-func recordHandlerError(errs chan<- string, format string, args ...any) {
-	select {
-	case errs <- fmt.Sprintf(format, args...):
-	default:
-	}
-}
-
-// assertNoHandlerError fails the test if the server handler recorded a setup or
-// routing error while servicing the request under test.
-func assertNoHandlerError(t *testing.T, errs <-chan string) {
-	t.Helper()
-
-	select {
-	case err := <-errs:
-		t.Fatal(err)
-	default:
-	}
-}
-
-// writeMalformedChunkedResponse sends an intentionally truncated chunked body so
-// callers exercise response-body read errors after headers are received.
-func writeMalformedChunkedResponse(w http.ResponseWriter) error {
-	hijacker, ok := w.(http.Hijacker)
-	if !ok {
-		return errors.New("response writer does not support hijacking")
-	}
-	conn, rw, err := hijacker.Hijack()
-	if err != nil {
-		return fmt.Errorf("hijack response: %w", err)
-	}
-	if _, err := rw.WriteString("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nTransfer-Encoding: chunked\r\n\r\n20\r\npartial"); err != nil {
-		_ = conn.Close()
-		return fmt.Errorf("write response: %w", err)
-	}
-	if err := rw.Flush(); err != nil {
-		_ = conn.Close()
-		return fmt.Errorf("flush response: %w", err)
-	}
-	_ = conn.Close()
-	return nil
-}
diff --git a/internal/trackers/impl/mtv/wrap_errors.go b/internal/trackers/impl/mtv/wrap_errors.go
deleted file mode 100644
index 867b93b3..00000000
--- a/internal/trackers/impl/mtv/wrap_errors.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package mtv
-
-import "fmt"
-
-func wrapTrackerError(err error) error {
-	if err != nil {
-		return fmt.Errorf("trackers: %w", err)
-	}
-	return nil
-}
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/nbl/definition.go b/internal/trackers/impl/nbl/definition.go
deleted file mode 100644
index 006f3f2c..00000000
--- a/internal/trackers/impl/nbl/definition.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package nbl
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "NBL"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	var err error
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			if req.Logger != nil {
-				req.Logger.Errorf(
-					"trackers: %s description assets resolution failed source=%s: %v",
-					strings.ToUpper(strings.TrimSpace(req.Tracker)),
-					strings.TrimSpace(req.Meta.SourcePath),
-					err,
-				)
-			}
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-
-	return trackers.DescriptionResult{
-		Group:       "nbl",
-		Description: strings.TrimSpace(assets.Description),
-	}, nil
-}
diff --git a/internal/trackers/impl/nbl/definition_test.go b/internal/trackers/impl/nbl/definition_test.go
deleted file mode 100644
index 45d8107a..00000000
--- a/internal/trackers/impl/nbl/definition_test.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package nbl
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
-	torrentPath := filepath.Join(tmp, "Show.torrent")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "NBL",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Show.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-			ExternalIDs:       api.ExternalIDs{TVmazeID: 987},
-			TVPack:            true,
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-		AppConfig:     config.Config{},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if entry.Payload["tvmazeid"] != "987" {
-		t.Fatalf("expected tvmazeid 987, got %q", entry.Payload["tvmazeid"])
-	}
-	if entry.Payload["category"] != "3" {
-		t.Fatalf("expected pack category 3, got %q", entry.Payload["category"])
-	}
-	if entry.Questionnaire != nil {
-		t.Fatal("expected no questionnaire")
-	}
-}
diff --git a/internal/trackers/impl/nbl/upload.go b/internal/trackers/impl/nbl/upload.go
deleted file mode 100644
index 6bcc07ab..00000000
--- a/internal/trackers/impl/nbl/upload.go
+++ /dev/null
@@ -1,239 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package nbl
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/httpclient"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const nblUploadURL = "https://nebulance.io/api.php"
-
-var nblTorrentIDPattern = regexp.MustCompile(`id=(\d+)`)
-
-type uploadState struct {
-	torrentPath string
-	fields      map[string]string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, nblUploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: NBL request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: NBL upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	bodyBytes, bodyPreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 300, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: NBL read response: %w", err)
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return api.UploadSummary{}, commonhttp.UploadHTTPError("NBL", resp.StatusCode, bodyPreview)
-	}
-
-	payload := map[string]any{}
-	if len(bodyBytes) > 0 {
-		if err := json.Unmarshal(bodyBytes, &payload); err != nil {
-			return api.UploadSummary{}, errors.New("trackers: NBL json decode error, the API is probably down")
-		}
-	}
-
-	torrentURL, torrentID := extractUploadLinkAndID(payload)
-
-	artifactPath := ""
-	if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" {
-		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "NBL")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, "NBL"); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-
-	return api.UploadSummary{
-		Uploaded: 1,
-		UploadedTorrents: []api.UploadedTorrent{{
-			Tracker:     "NBL",
-			TorrentID:   torrentID,
-			DownloadURL: torrentURL,
-			TorrentURL:  torrentURL,
-			TorrentPath: artifactPath,
-		}},
-	}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "NBL",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "nbl",
-		Endpoint:         nblUploadURL,
-		Payload:          state.fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file_input",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	select {
-	case <-ctx.Done():
-		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: NBL missing api_key")
-	}
-
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	mediaInfo, err := resolveMediaInfo(req.Meta)
-	if err != nil {
-		return uploadState{}, err
-	}
-
-	fields := map[string]string{
-		"action":      "upload",
-		"api_key":     strings.TrimSpace(req.TrackerConfig.APIKey),
-		"tvmazeid":    strconv.Itoa(req.Meta.ExternalIDs.TVmazeID),
-		"mediainfo":   mediaInfo,
-		"category":    strconv.Itoa(resolveCategoryID(req.Meta)),
-		"ignoredupes": "1",
-	}
-
-	return uploadState{torrentPath: torrentPath, fields: fields}, nil
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	for key, value := range fields {
-		if err := writer.WriteField(key, value); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: NBL write multipart field %q: %w", key, err)
-		}
-	}
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: NBL open torrent file: %w", err)
-	}
-	defer file.Close()
-	part, err := writer.CreateFormFile("file_input", "torrent.torrent")
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: NBL create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: NBL copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: NBL close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveMediaInfo(meta api.PreparedMetadata) (string, error) {
-	if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
-		return "", errors.New("trackers: NBL missing mediainfo text")
-	}
-	payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
-	if err != nil {
-		return "", fmt.Errorf("trackers: NBL read mediainfo: %w", err)
-	}
-	return string(payload), nil
-}
-
-func resolveCategoryID(meta api.PreparedMetadata) int {
-	if meta.TVPack {
-		return 3
-	}
-	return 1
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.Filename); name != "" {
-		return name
-	}
-	return pathutil.Base(meta.SourcePath)
-}
-
-func nblString(value any) string {
-	if value == nil {
-		return ""
-	}
-
-	switch typed := value.(type) {
-	case string:
-		return strings.TrimSpace(typed)
-	default:
-		return strings.TrimSpace(fmt.Sprint(value))
-	}
-}
-
-func extractUploadLinkAndID(payload map[string]any) (string, string) {
-	torrentURL := strings.TrimSpace(nblString(payload["link"]))
-	if torrentURL == "" {
-		if result, ok := payload["result"].(map[string]any); ok {
-			torrentURL = strings.TrimSpace(nblString(result["link"]))
-		}
-	}
-
-	torrentID := ""
-	if matches := nblTorrentIDPattern.FindStringSubmatch(torrentURL); len(matches) > 1 {
-		torrentID = strings.TrimSpace(matches[1])
-	}
-
-	return torrentURL, torrentID
-}
diff --git a/internal/trackers/impl/nbl/upload_test.go b/internal/trackers/impl/nbl/upload_test.go
deleted file mode 100644
index c608b783..00000000
--- a/internal/trackers/impl/nbl/upload_test.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package nbl
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestPrepareUploadStateUsesNumericIgnoreDupes(t *testing.T) {
-	t.Parallel()
-
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
-	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	if err := os.WriteFile(mediaInfoPath, []byte("mediainfo"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	state, err := prepareUploadState(context.Background(), trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			TorrentPath:       torrentPath,
-			MediaInfoTextPath: mediaInfoPath,
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "api-key"},
-	})
-	if err != nil {
-		t.Fatalf("prepare upload state: %v", err)
-	}
-	if got := state.fields["ignoredupes"]; got != "1" {
-		t.Fatalf("expected ignoredupes=1, got %q", got)
-	}
-}
-
-func TestExtractUploadLinkAndIDFromRootLink(t *testing.T) {
-	t.Parallel()
-
-	payload := map[string]any{
-		"link": "https://nebulance.io/torrents.php?id=12345",
-	}
-
-	link, id := extractUploadLinkAndID(payload)
-	if link != "https://nebulance.io/torrents.php?id=12345" {
-		t.Fatalf("expected upload link from root, got %q", link)
-	}
-	if id != "12345" {
-		t.Fatalf("expected torrent id 12345, got %q", id)
-	}
-}
-
-func TestExtractUploadLinkAndIDFromResultLink(t *testing.T) {
-	t.Parallel()
-
-	payload := map[string]any{
-		"result": map[string]any{
-			"link": "https://nebulance.io/torrents.php?id=67890",
-		},
-	}
-
-	link, id := extractUploadLinkAndID(payload)
-	if link != "https://nebulance.io/torrents.php?id=67890" {
-		t.Fatalf("expected upload link from nested result, got %q", link)
-	}
-	if id != "67890" {
-		t.Fatalf("expected torrent id 67890, got %q", id)
-	}
-}
-
-func TestExtractUploadLinkAndIDEmptyWhenMissingLink(t *testing.T) {
-	t.Parallel()
-
-	payload := map[string]any{"status": "ok"}
-
-	link, id := extractUploadLinkAndID(payload)
-	if link != "" {
-		t.Fatalf("expected empty upload link when missing, got %q", link)
-	}
-	if id != "" {
-		t.Fatalf("expected empty torrent id when link missing, got %q", id)
-	}
-}
diff --git a/internal/trackers/impl/ptp/definition.go b/internal/trackers/impl/ptp/definition.go
deleted file mode 100644
index 00187e38..00000000
--- a/internal/trackers/impl/ptp/definition.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ptp
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Definition struct{}
-
-func New() *Definition {
-	return &Definition{}
-}
-
-func (d *Definition) Name() string {
-	return "PTP"
-}
-
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	select {
-	case <-ctx.Done():
-		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		resolvedAssets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
-			}
-			if req.Logger != nil {
-				req.Logger.Warnf("trackers: PTP description assets failed: %v", err)
-			}
-		} else {
-			assets = resolvedAssets
-		}
-	}
-
-	description := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		description = buildDescription(req.Meta, req.TrackerConfig, req.AppConfig, assets)
-	}
-	if strings.TrimSpace(description) == "" && req.Logger != nil {
-		req.Logger.Infof("trackers: PTP preparation description empty")
-	}
-
-	return trackers.DescriptionResult{
-		Group:       "ptp",
-		Description: description,
-	}, nil
-}
diff --git a/internal/trackers/impl/ptp/definition_test.go b/internal/trackers/impl/ptp/definition_test.go
deleted file mode 100644
index a2d37fbf..00000000
--- a/internal/trackers/impl/ptp/definition_test.go
+++ /dev/null
@@ -1,646 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ptp
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/netip"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/anacrolix/torrent/metainfo"
-	mkbrr "github.com/autobrr/mkbrr/torrent"
-
-	"github.com/autobrr/upbrr/internal/config"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestDefinitionBuildDescriptionUsesPTPGroup(t *testing.T) {
-	d := New()
-	result, err := d.BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "PTP",
-		Meta:    api.PreparedMetadata{},
-		Logger:  api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if result.Group != "ptp" {
-		t.Fatalf("expected ptp group, got %q", result.Group)
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesResolvedAssetsAndMediaInfo(t *testing.T) {
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			MediaInfoTextPath: mediaInfoPath,
-			Options:           api.UploadOptions{Screens: 1},
-		},
-		Assets: &trackers.DescriptionAssets{
-			Description: "kept https://pixhost.to/show/encoded.png",
-			Screenshots: []api.ScreenshotImage{{
-				Host:   "pixhost",
-				RawURL: "https://pixhost.to/show/encoded.png",
-			}},
-		},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(result.Description, "[mediainfo]General\nUnique ID : 123[/mediainfo]") {
-		t.Fatalf("expected mediainfo section, got %q", result.Description)
-	}
-	if !strings.Contains(result.Description, "kept") || !strings.Contains(result.Description, "[img]https://pixhost.to/show/encoded.png[/img]") {
-		t.Fatalf("expected resolved asset description, got %q", result.Description)
-	}
-	if strings.Contains(result.Description, "lostimg.cc") {
-		t.Fatalf("expected no stale image hosts, got %q", result.Description)
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesAllResolvedPixhostScreenshots(t *testing.T) {
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	screenshots := []api.ScreenshotImage{
-		{Host: "pixhost", RawURL: "https://pixhost.to/1.png"},
-		{Host: "pixhost", RawURL: "https://pixhost.to/2.png"},
-		{Host: "pixhost", RawURL: "https://pixhost.to/3.png"},
-	}
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			MediaInfoTextPath: mediaInfoPath,
-			Options:           api.UploadOptions{Screens: 2},
-		},
-		Assets: &trackers.DescriptionAssets{Screenshots: screenshots},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	for _, screenshot := range screenshots {
-		if !strings.Contains(result.Description, "[img]"+screenshot.RawURL+"[/img]") {
-			t.Fatalf("expected screenshot %q in description, got %q", screenshot.RawURL, result.Description)
-		}
-	}
-}
-
-func TestDefinitionBuildDescriptionUsesAllowedNonPixhostRawScreenshots(t *testing.T) {
-	tmp := t.TempDir()
-	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	screenshots := []api.ScreenshotImage{
-		{Host: "imgbb", RawURL: "https://i.ibb.co/raw-1/source.png", ImgURL: "https://i.ibb.co/thumb-1/source.png"},
-		{Host: "onlyimage", RawURL: "https://onlyimage.org/images/raw-2.png", ImgURL: "https://onlyimage.org/images/medium-2.png"},
-		{Host: "ptscreens", RawURL: "https://ptscreens.com/images/raw-3.png", ImgURL: "https://ptscreens.com/images/medium-3.png"},
-	}
-	result, err := New().BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			MediaInfoTextPath: mediaInfoPath,
-			Options:           api.UploadOptions{Screens: 2},
-		},
-		Assets: &trackers.DescriptionAssets{Screenshots: screenshots},
-		Logger: api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	for _, screenshot := range screenshots {
-		if !strings.Contains(result.Description, "[img]"+screenshot.RawURL+"[/img]") {
-			t.Fatalf("expected raw screenshot %q in description, got %q", screenshot.RawURL, result.Description)
-		}
-		if strings.Contains(result.Description, screenshot.ImgURL) {
-			t.Fatalf("expected PTP description to avoid non-raw URL %q, got %q", screenshot.ImgURL, result.Description)
-		}
-	}
-}
-
-func TestDefinitionBuildUploadDryRunForExistingGroup(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ptpTorrentPath:
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"Movies": []map[string]any{{"GroupId": "1234"}},
-			})
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			ReleaseName: "Movie.2026.1080p.BluRay.x264",
-			Source:      "BluRay",
-			VideoCodec:  "AVC",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Title: "Movie", Year: 2026, Poster: "https://img.example/poster.jpg", Genres: "Action"},
-			},
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:        server.URL,
-			PTPAPIUser: "user",
-			PTPAPIKey:  "key",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
-		Logger:    api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected dry-run error: %v", err)
-	}
-	if got := entry.Payload["groupid"]; got != "1234" {
-		t.Fatalf("expected existing group id, got %q", got)
-	}
-	if _, exists := entry.Payload["title"]; exists {
-		t.Fatal("did not expect new-group title field when group already exists")
-	}
-	if entry.Questionnaire != nil {
-		t.Fatal("did not expect questionnaire for existing group upload")
-	}
-}
-
-func TestDefinitionBuildUploadDryRunForNewGroupIncludesQuestionnaire(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
-
-	entry, err := New().BuildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			ReleaseName: "Movie.2026.1080p.BluRay.x264",
-			Source:      "BluRay",
-			VideoCodec:  "AVC",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{
-					Title:    "Movie",
-					Year:     2026,
-					Poster:   "https://img.example/poster.jpg",
-					Genres:   "Action",
-					Overview: "Plot",
-				},
-			},
-		},
-		TrackerConfig: config.TrackerConfig{},
-		AppConfig:     config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
-		Logger:        api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected dry-run error: %v", err)
-	}
-	if entry.Questionnaire == nil {
-		t.Fatal("expected questionnaire for new group upload")
-	}
-	if got := len(entry.Questionnaire.Fields); got == 0 {
-		t.Fatal("expected questionnaire fields")
-	}
-	if entry.Questionnaire.Fields[0].Key != "title" {
-		t.Fatalf("expected first questionnaire field to be title, got %q", entry.Questionnaire.Fields[0].Key)
-	}
-	if got := entry.Payload["imdb"]; got != "0" {
-		t.Fatalf("expected missing IMDb dry-run payload value 0, got %q", got)
-	}
-}
-
-func TestResolveUploadTorrentPathReusesPreparedPTPArtifact(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "ua.db")
-	sourcePath := filepath.Join(tmp, "Movie.mkv")
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
-
-	preparedMeta, err := trackers.PrepareTrackerUploadTorrent(
-		api.PreparedMetadata{SourcePath: sourcePath, TorrentPath: torrentPath},
-		dbPath,
-		"PTP",
-		config.TrackerConfig{AnnounceURL: "https://please.passthepopcorn.me/passkey/announce"},
-	)
-	if err != nil {
-		t.Fatalf("prepare tracker torrent: %v", err)
-	}
-
-	resolvedPath, err := resolveUploadTorrentPath(preparedMeta, dbPath)
-	if err != nil {
-		t.Fatalf("resolve upload torrent path: %v", err)
-	}
-	if resolvedPath != preparedMeta.TorrentPath {
-		t.Fatalf("expected prepared artifact path %q, got %q", preparedMeta.TorrentPath, resolvedPath)
-	}
-
-	torrentMeta, err := metainfo.LoadFromFile(resolvedPath)
-	if err != nil {
-		t.Fatalf("load prepared artifact: %v", err)
-	}
-	if torrentMeta.Announce != "https://please.passthepopcorn.me/passkey/announce" {
-		t.Fatal("expected prepared announce preserved")
-	}
-	info, err := torrentMeta.UnmarshalInfo()
-	if err != nil {
-		t.Fatalf("unmarshal prepared info: %v", err)
-	}
-	if info.Source != "PTP" {
-		t.Fatalf("expected prepared source preserved, got %q", info.Source)
-	}
-}
-
-func TestDefinitionUploadSuccess(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := newPTPAuthDB(t)
-	torrentPath := filepath.Join(tmp, "release.torrent")
-	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
-	markTorrentWithPrivateMetadata(t, torrentPath)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.RequestURI() {
-		case ptpLoginPath:
-			if err := r.ParseForm(); err != nil {
-				t.Errorf("parse login: %v", err)
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
-				t.Error("unexpected login credentials")
-				return
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "cookievalue", Path: "/"})
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"Result":        "Ok",
-				"AntiCsrfToken": "csrf-token",
-			})
-		default:
-			switch r.URL.Path {
-			case ptpUploadPath:
-				if err := r.ParseMultipartForm(5 << 20); err != nil {
-					t.Errorf("parse multipart: %v", err)
-					return
-				}
-				files := r.MultipartForm.File["file_input"]
-				if len(files) != 1 {
-					t.Errorf("expected one torrent file, got %d", len(files))
-					return
-				}
-				uploaded, err := files[0].Open()
-				if err != nil {
-					t.Errorf("open uploaded torrent: %v", err)
-					return
-				}
-				defer uploaded.Close()
-				payload, err := io.ReadAll(uploaded)
-				if err != nil {
-					t.Errorf("read uploaded torrent: %v", err)
-					return
-				}
-				uploadedMeta, err := metainfo.Load(bytes.NewReader(payload))
-				if err != nil {
-					t.Errorf("load uploaded torrent: %v", err)
-					return
-				}
-				if uploadedMeta.Comment != "upbrr" {
-					t.Errorf("expected cleaned upload torrent comment, got %q", uploadedMeta.Comment)
-					return
-				}
-				if uploadedMeta.CreatedBy != "uploaded with upbrr" {
-					t.Errorf("expected cleaned upload torrent created-by, got %q", uploadedMeta.CreatedBy)
-					return
-				}
-				if uploadedMeta.Announce != "" {
-					t.Error("expected upload torrent announce stripped")
-					return
-				}
-				if r.FormValue("AntiCsrfToken") != "csrf-token" {
-					t.Error("expected csrf token")
-					return
-				}
-				if r.FormValue("title") != "Movie" {
-					t.Error("expected new-group title field")
-					return
-				}
-				http.Redirect(w, r, "/torrents.php?id=555&torrentid=666", http.StatusFound)
-			case ptpTorrentPath:
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte("ok"))
-			default:
-				w.WriteHeader(http.StatusNotFound)
-			}
-		}
-	}))
-	defer server.Close()
-
-	result, err := New().Upload(context.Background(), trackers.UploadRequest{
-		Tracker: "PTP",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath: torrentPath,
-			ReleaseName: "Movie.2026.1080p.BluRay.x264",
-			Source:      "BluRay",
-			VideoCodec:  "AVC",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE", IMDBID: 1234567},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{
-					Title:    "Movie",
-					Year:     2026,
-					Poster:   "https://img.example/poster.jpg",
-					Genres:   "Action",
-					Overview: "Plot",
-				},
-			},
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:         server.URL,
-			Username:    "user",
-			Password:    "pass",
-			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:    api.NopLogger{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected upload error: %v", err)
-	}
-	if result.Uploaded != 1 {
-		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
-	}
-	if len(result.UploadedTorrents) != 1 {
-		t.Fatalf("expected uploaded torrent artifact")
-	}
-	if result.UploadedTorrents[0].TorrentID != "666" {
-		t.Fatalf("expected torrent id 666, got %q", result.UploadedTorrents[0].TorrentID)
-	}
-	artifactPath := result.UploadedTorrents[0].TorrentPath
-	if strings.TrimSpace(artifactPath) == "" {
-		t.Fatal("expected tracker torrent path")
-	}
-	if _, err := os.Stat(artifactPath); err != nil {
-		t.Fatalf("expected tracker torrent file: %v", err)
-	}
-	legacyCookiePath, err := servicedb.CookiePath(dbPath, ptpCookieFile)
-	if err != nil {
-		t.Fatalf("resolve legacy PTP cookie path: %v", err)
-	}
-	if _, err := os.Stat(legacyCookiePath); !os.IsNotExist(err) {
-		t.Fatalf("expected no legacy PTP cookie file after upload, got err=%v", err)
-	}
-}
-
-func TestLoginAndFetchAntiCsrfTokenHandles2FA(t *testing.T) {
-	secondLogin := false
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.RequestURI() != ptpLoginPath {
-			w.WriteHeader(http.StatusNotFound)
-			return
-		}
-		if err := r.ParseForm(); err != nil {
-			t.Errorf("parse login: %v", err)
-			return
-		}
-		if r.FormValue("username") != "user" || r.FormValue("password") != "pass" || r.FormValue("passkey") != "passkey" || r.FormValue("keeplogged") != "1" {
-			t.Error("unexpected login form")
-			return
-		}
-		if r.FormValue("TfaCode") == "" {
-			_ = json.NewEncoder(w).Encode(map[string]any{"Result": "TfaRequired"})
-			return
-		}
-		secondLogin = true
-		if r.FormValue("TfaType") != "normal" {
-			t.Errorf("expected TfaType normal, got %q", r.FormValue("TfaType"))
-			return
-		}
-		code := r.FormValue("TfaCode")
-		if len(code) != 6 || strings.Trim(code, "0123456789") != "" {
-			t.Errorf("expected six digit TfaCode, got %q", code)
-			return
-		}
-		http.SetCookie(w, &http.Cookie{Name: "session", Value: "cookievalue", Path: "/"})
-		_ = json.NewEncoder(w).Encode(map[string]any{
-			"Result":        "Ok",
-			"AntiCsrfToken": "csrf-token",
-		})
-	}))
-	defer server.Close()
-
-	dbPath := newPTPAuthDB(t)
-	client, token, err := loginAndFetchAntiCsrfToken(context.Background(), config.TrackerConfig{
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-		OTPURI:      "otpauth://totp/PTP:user?secret=JBSWY3DPEHPK3PXP&issuer=PTP",
-	}, dbPath, server.URL, api.NopLogger{}, api.TrackerAuthLoginRequest{})
-	if err != nil {
-		t.Fatalf("login: %v", err)
-	}
-	if token != "csrf-token" {
-		t.Fatalf("expected csrf token, got %q", token)
-	}
-	if client == nil {
-		t.Fatal("expected authenticated client")
-	}
-	if !secondLogin {
-		t.Fatal("expected second 2FA login request")
-	}
-}
-
-func TestRehostPosterToSelectedHostUploadsPoster(t *testing.T) {
-	tmp := t.TempDir()
-	dbPath := filepath.Join(tmp, "ua.db")
-	sourcePath := filepath.Join(tmp, "Movie.mkv")
-	if err := os.WriteFile(sourcePath, []byte("movie"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-
-	posterServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "image/png")
-		_, _ = w.Write([]byte("poster-bytes"))
-	}))
-	defer posterServer.Close()
-	originalClientFactory := newPosterHTTPClient
-	newPosterHTTPClient = posterServer.Client
-	t.Cleanup(func() {
-		newPosterHTTPClient = originalClientFactory
-	})
-
-	images := &stubPTPImageHosting{
-		uploaded: []api.UploadedImageLink{{
-			Host:   "pixhost",
-			RawURL: "https://pixhost.to/rehosted.png",
-		}},
-	}
-	got := rehostPosterToSelectedHost(context.Background(), trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			SourcePath: sourcePath,
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-		Logger:    api.NopLogger{},
-		Images:    images,
-	}, posterServer.URL+"/poster")
-
-	if got != "https://pixhost.to/rehosted.png" {
-		t.Fatalf("expected rehosted poster URL, got %q", got)
-	}
-	if images.host != "pixhost" {
-		t.Fatalf("expected pixhost upload host, got %q", images.host)
-	}
-	if len(images.images) != 1 {
-		t.Fatalf("expected one uploaded poster, got %d", len(images.images))
-	}
-	posterPath := images.images[0].Path
-	if filepath.Base(posterPath) != "PTP_POSTER.png" {
-		t.Fatalf("expected content-type poster extension, got %q", filepath.Base(posterPath))
-	}
-	body, err := os.ReadFile(posterPath)
-	if err != nil {
-		t.Fatalf("read poster: %v", err)
-	}
-	if string(body) != "poster-bytes" {
-		t.Fatalf("unexpected poster body %q", string(body))
-	}
-}
-
-func TestRehostPosterToSelectedHostRejectsLoopbackPoster(t *testing.T) {
-	tmp := t.TempDir()
-	sourcePath := filepath.Join(tmp, "Movie.mkv")
-	if err := os.WriteFile(sourcePath, []byte("movie"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	posterServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte("poster-bytes"))
-	}))
-	defer posterServer.Close()
-
-	images := &stubPTPImageHosting{
-		uploaded: []api.UploadedImageLink{{
-			Host:   "pixhost",
-			RawURL: "https://pixhost.to/rehosted.png",
-		}},
-	}
-	got := rehostPosterToSelectedHost(context.Background(), trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
-			SourcePath: sourcePath,
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}},
-		Logger:    api.NopLogger{},
-		Images:    images,
-	}, posterServer.URL+"/poster")
-
-	if got != posterServer.URL+"/poster" {
-		t.Fatalf("expected original poster URL after blocked rehost, got %q", got)
-	}
-	if len(images.images) != 0 {
-		t.Fatalf("expected no upload for blocked loopback poster")
-	}
-}
-
-func TestIsPublicPosterIPRejectsPrivateRanges(t *testing.T) {
-	t.Parallel()
-
-	for _, value := range []string{"127.0.0.1", "10.0.0.1", "192.168.1.20", "169.254.1.1", "::1", "fc00::1"} {
-		if isPublicPosterIP(netip.MustParseAddr(value)) {
-			t.Fatalf("expected %s to be rejected", value)
-		}
-	}
-	if !isPublicPosterIP(netip.MustParseAddr("93.184.216.34")) {
-		t.Fatal("expected public address to be accepted")
-	}
-}
-
-func TestRehostPosterToSelectedHostSkipsSelectedHost(t *testing.T) {
-	images := &stubPTPImageHosting{}
-	got := rehostPosterToSelectedHost(context.Background(), trackers.UploadRequest{
-		Images: images,
-	}, "https://pixhost.to/existing.jpg")
-	if got != "https://pixhost.to/existing.jpg" {
-		t.Fatalf("expected original poster URL, got %q", got)
-	}
-	if len(images.images) != 0 {
-		t.Fatalf("expected no upload for selected host poster")
-	}
-}
-
-type stubPTPImageHosting struct {
-	host     string
-	scope    string
-	images   []api.ScreenshotImage
-	uploaded []api.UploadedImageLink
-}
-
-func (s *stubPTPImageHosting) ListCandidates(context.Context, api.PreparedMetadata) ([]api.ScreenshotImage, error) {
-	return nil, nil
-}
-
-func (s *stubPTPImageHosting) Upload(_ context.Context, _ api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
-	s.host = host
-	s.scope = usageScope
-	s.images = append([]api.ScreenshotImage(nil), images...)
-	return s.uploaded, nil
-}
-
-func createTestTorrent(t *testing.T, sourcePath string, torrentPath string) {
-	t.Helper()
-
-	if err := os.WriteFile(sourcePath, []byte("data"), 0o600); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	_, err := mkbrr.Create(mkbrr.CreateOptions{
-		Path:       sourcePath,
-		OutputPath: torrentPath,
-		IsPrivate:  true,
-	})
-	if err != nil {
-		t.Fatalf("create torrent: %v", err)
-	}
-}
-
-func markTorrentWithPrivateMetadata(t *testing.T, torrentPath string) {
-	t.Helper()
-
-	torrentMeta, err := metainfo.LoadFromFile(torrentPath)
-	if err != nil {
-		t.Fatalf("load torrent: %v", err)
-	}
-	torrentMeta.Announce = "https://private.example/passkey/announce"
-	torrentMeta.Comment = "Created by Upload Assistant https://private.example/download/1"
-	file, err := os.Create(torrentPath)
-	if err != nil {
-		t.Fatalf("rewrite torrent: %v", err)
-	}
-	defer file.Close()
-	if err := torrentMeta.Write(file); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-}
diff --git a/internal/trackers/impl/ptp/upload.go b/internal/trackers/impl/ptp/upload.go
deleted file mode 100644
index 9deecbc7..00000000
--- a/internal/trackers/impl/ptp/upload.go
+++ /dev/null
@@ -1,1513 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ptp
-
-import (
-	"bytes"
-	"context"
-	"crypto/hmac"
-	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
-	"encoding/base32"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net"
-	"net/http"
-	"net/http/cookiejar"
-	"net/netip"
-	"net/url"
-	"os"
-	"path" //nolint:depguard // Reads poster URL path extension, not local filesystem extension.
-	"path/filepath"
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	ptpBaseURL     = "https://passthepopcorn.me"
-	ptpUploadPath  = "/upload.php"
-	ptpTorrentPath = "/torrents.php"
-	ptpLoginPath   = "/ajax.php?action=login"
-	ptpCookieFile  = "PTP.json"
-	ptpUserAgent   = "upbrr"
-)
-
-var (
-	ptpAntiCsrfPattern     = regexp.MustCompile(`data-AntiCsrfToken="([^"]+)"`)
-	ptpSuccessPattern      = regexp.MustCompile(`torrents\.php\?id=(\d+)&torrentid=(\d+)`)
-	newPosterHTTPClient    = newPublicPosterHTTPClient
-	reservedPosterPrefixes = []netip.Prefix{
-		netip.MustParsePrefix("0.0.0.0/8"),
-		netip.MustParsePrefix("100.64.0.0/10"),
-		netip.MustParsePrefix("192.0.0.0/24"),
-		netip.MustParsePrefix("192.0.2.0/24"),
-		netip.MustParsePrefix("198.18.0.0/15"),
-		netip.MustParsePrefix("198.51.100.0/24"),
-		netip.MustParsePrefix("203.0.113.0/24"),
-		netip.MustParsePrefix("240.0.0.0/4"),
-		netip.MustParsePrefix("2001:db8::/32"),
-		netip.MustParsePrefix("fc00::/7"),
-		netip.MustParsePrefix("fe80::/10"),
-	}
-)
-
-// ErrSubmitted2FARejected marks a PTP failure after a submitted manual 2FA code
-// reached the tracker and was rejected.
-var ErrSubmitted2FARejected = errors.New("trackers: PTP submitted 2FA rejected")
-
-type uploadState struct {
-	baseURL     string
-	uploadURL   string
-	announceURL string
-	client      *http.Client
-	groupID     string
-	torrentPath string
-	description string
-	fields      map[string]string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req, false)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath, "file_input")
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTP request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", ptpUserAgent)
-
-	resp, err := state.client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTP upload request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	_, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTP read upload response: %w", err)
-	}
-	if matches := ptpSuccessPattern.FindStringSubmatch(finalURL); len(matches) == 3 {
-		groupID := strings.TrimSpace(matches[1])
-		torrentID := strings.TrimSpace(matches[2])
-		torrentURL := strings.TrimRight(state.baseURL, "/") + "/torrents.php?id=" + url.QueryEscape(groupID) + "&torrentid=" + url.QueryEscape(torrentID)
-		trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, "PTP")
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, trackerTorrentPath, state.announceURL, torrentURL, "PTP"); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: PTP write torrent artifact: %w", err)
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "PTP",
-				TorrentID:   torrentID,
-				TorrentURL:  torrentURL,
-				DownloadURL: torrentURL,
-				TorrentPath: trackerTorrentPath,
-			}},
-		}, nil
-	}
-
-	failurePath := ""
-	if pathValue, pathErr := resolveFailurePath(req.Meta, req.AppConfig.MainSettings.DBPath); pathErr == nil {
-		failurePath = pathValue
-		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
-		_ = os.WriteFile(failurePath, redactedBody, 0o600)
-	}
-	errText := commonhttp.RedactErrorDetail(extractAlertError(string(responsePreview)))
-	if errText == "" {
-		errText = commonhttp.ExtractHTTPErrorDetail(responsePreview)
-	}
-	if errText == "" {
-		errText = "upload failed"
-	}
-	if failurePath != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTP upload failed status=%d url=%s error=%s failure=%s", resp.StatusCode, commonhttp.RedactErrorDetail(finalURL), compactError(errText), failurePath)
-	}
-	return api.UploadSummary{}, fmt.Errorf("trackers: PTP upload failed status=%d url=%s error=%s", resp.StatusCode, commonhttp.RedactErrorDetail(finalURL), compactError(errText))
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req, true)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	message := "dry-run payload generated"
-	if state.groupID != "" {
-		message += " for existing group"
-	} else {
-		message += " for new group"
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "PTP",
-		Status:           "ready",
-		Message:          message,
-		ReleaseName:      resolveUploadName(req.Meta),
-		DescriptionGroup: "ptp",
-		Description:      state.description,
-		Endpoint:         state.uploadURL,
-		Payload:          state.fields,
-		Files: []api.TrackerDryRunFile{{
-			Field:   "file_input",
-			Path:    state.torrentPath,
-			Present: strings.TrimSpace(state.torrentPath) != "",
-		}},
-		Questionnaire: buildQuestionnaire(req.Meta, state.groupID),
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest, dryRun bool) (uploadState, error) {
-	baseURL := strings.TrimRight(strings.TrimSpace(req.TrackerConfig.URL), "/")
-	if baseURL == "" {
-		baseURL = ptpBaseURL
-	}
-	announceURL := normalizedAnnounceURL(req.TrackerConfig.AnnounceURL)
-	torrentPath, err := resolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: PTP resolve upload torrent: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, req.TrackerConfig, req.AppConfig, assets)
-	groupID, err := lookupGroupID(ctx, baseURL, req.TrackerConfig, req.Meta)
-	if err != nil {
-		return uploadState{}, err
-	}
-	answers := questionnaireAnswers(req.Meta, "PTP")
-	poster := metautil.FirstNonEmptyTrimmed(answers["poster"], resolvePoster(req.Meta))
-	if !dryRun {
-		poster = rehostPosterToSelectedHost(ctx, req, poster)
-	}
-	fields, err := buildUploadFields(req.Meta, description, groupID, answers, poster)
-	if err != nil {
-		return uploadState{}, err
-	}
-	fields["AntiCsrfToken"] = "dry-run-token"
-
-	var client *http.Client
-	if !dryRun {
-		client, fields["AntiCsrfToken"], err = resolveSession(ctx, req.TrackerConfig, req.AppConfig.MainSettings.DBPath, baseURL, req.Logger)
-		if err != nil {
-			return uploadState{}, err
-		}
-	}
-
-	return uploadState{
-		baseURL:     baseURL,
-		uploadURL:   baseURL + ptpUploadPath,
-		announceURL: announceURL,
-		client:      client,
-		groupID:     groupID,
-		torrentPath: torrentPath,
-		description: description,
-		fields:      fields,
-	}, nil
-}
-
-func resolveUploadTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	preparedPath, err := trackers.ResolveTrackerTorrentArtifactPath(meta, dbPath, "PTP")
-	if err == nil && strings.TrimSpace(meta.TorrentPath) == preparedPath {
-		if info, statErr := os.Stat(preparedPath); statErr == nil && !info.IsDir() {
-			return preparedPath, nil
-		}
-	}
-	path, err := trackers.ResolveUploadTorrentPath(meta, dbPath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: resolve upload torrent path: %w", err)
-	}
-	return path, nil
-}
-
-func buildDescription(meta api.PreparedMetadata, trackerConfig config.TrackerConfig, appConfig config.Config, assets trackers.DescriptionAssets) string {
-	baseDescription := strings.TrimSpace(assets.Description)
-	if assets.Final {
-		return baseDescription
-	}
-	if baseDescription != "" {
-		report := bbcode.CleanPTPDescription(baseDescription, meta.DiscType)
-		baseDescription = strings.TrimSpace(report.Description)
-	}
-
-	var sections []string
-	if mediaSection, err := buildMediaSection(meta, appConfig.MainSettings.DBPath); err == nil && mediaSection != "" {
-		sections = append(sections, mediaSection)
-	}
-	if strings.TrimSpace(baseDescription) != "" {
-		sections = append(sections, convertDescription(baseDescription))
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" && trackerConfig.AddWebSourceToDesc {
-		sections = append(sections, fmt.Sprintf("[quote][align=center]This release is sourced from %s[/align][/quote]", strings.TrimSpace(meta.ServiceLongName)))
-	}
-	if shots := buildScreenshotSection(meta, assets.Screenshots); shots != "" {
-		sections = append(sections, shots)
-	}
-	return strings.TrimSpace(strings.Join(sections, "\n\n"))
-}
-
-func buildMediaSection(meta api.PreparedMetadata, dbPath string) (string, error) {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		text, err := readBDSummary(meta, dbPath)
-		if err != nil {
-			return "", err
-		}
-		if strings.TrimSpace(text) == "" {
-			return "", nil
-		}
-		return "[mediainfo]" + strings.TrimSpace(text) + "[/mediainfo]", nil
-	default:
-		text, err := readTextFile(strings.TrimSpace(meta.MediaInfoTextPath))
-		if err != nil {
-			return "", err
-		}
-		if strings.TrimSpace(text) == "" {
-			return "", nil
-		}
-		return "[mediainfo]" + strings.TrimSpace(text) + "[/mediainfo]", nil
-	}
-}
-
-func buildScreenshotSection(meta api.PreparedMetadata, screenshots []api.ScreenshotImage) string {
-	if len(screenshots) == 0 {
-		return ""
-	}
-	minimum := meta.Options.Screens
-	if minimum <= 0 {
-		minimum = 2
-	}
-	if requiresMinimumTwoScreens(meta) && minimum < 2 {
-		minimum = 2
-	}
-	allowed := make([]string, 0, len(screenshots))
-	for _, screenshot := range screenshots {
-		rawURL := strings.TrimSpace(screenshot.RawURL)
-		if rawURL == "" {
-			rawURL = strings.TrimSpace(screenshot.ImgURL)
-		}
-		if rawURL == "" {
-			continue
-		}
-		host := strings.ToLower(strings.TrimSpace(screenshot.Host))
-		if host == "" {
-			host = imagehost.ExtractHost(rawURL)
-		}
-		if !isPTPImageHost(host) {
-			continue
-		}
-		allowed = append(allowed, "[img]"+rawURL+"[/img]")
-	}
-	if len(allowed) < minimum {
-		return ""
-	}
-	return strings.Join(allowed, "\n")
-}
-
-func isPTPImageHost(host string) bool {
-	switch strings.ToLower(strings.TrimSpace(host)) {
-	case "pixhost", "imgbb", "onlyimage", "ptscreens":
-		return true
-	default:
-		return false
-	}
-}
-
-func requiresMinimumTwoScreens(meta api.PreparedMetadata) bool {
-	if len(meta.FileList) > 1 {
-		return true
-	}
-	return strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV")
-}
-
-func convertDescription(value string) string {
-	replacer := strings.NewReplacer(
-		"[spoiler", "[hide",
-		"[/spoiler]", "[/hide]",
-		"[center]", "[align=center]",
-		"[/center]", "[/align]",
-		"[left]", "[align=left]",
-		"[/left]", "[/align]",
-		"[right]", "[align=right]",
-		"[/right]", "[/align]",
-		"[h1]", "[u][b]",
-		"[/h1]", "[/b][/u]",
-		"[h2]", "[u][b]",
-		"[/h2]", "[/b][/u]",
-		"[h3]", "[u][b]",
-		"[/h3]", "[/b][/u]",
-	)
-	return replacer.Replace(strings.TrimSpace(value))
-}
-
-func lookupGroupID(ctx context.Context, baseURL string, trackerConfig config.TrackerConfig, meta api.PreparedMetadata) (string, error) {
-	apiUser := strings.TrimSpace(trackerConfig.PTPAPIUser)
-	apiKey := strings.TrimSpace(trackerConfig.PTPAPIKey)
-	if apiUser == "" || apiKey == "" || meta.ExternalIDs.IMDBID == 0 {
-		return "", nil
-	}
-	headers := map[string]string{
-		"ApiUser":    apiUser,
-		"ApiKey":     apiKey,
-		"User-Agent": ptpUserAgent,
-	}
-	values := url.Values{}
-	values.Set("imdb", fmt.Sprintf("tt%07d", meta.ExternalIDs.IMDBID))
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+ptpTorrentPath+"?"+values.Encode(), nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP build group lookup request: %w", err)
-	}
-	for key, value := range headers {
-		httpReq.Header.Set(key, value)
-	}
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return "", nil
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return "", nil
-	}
-	var payload map[string]any
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return "", nil
-	}
-	if movies, ok := payload["Movies"].([]any); ok && len(movies) > 0 {
-		if movie, ok := movies[0].(map[string]any); ok {
-			if groupID := stringFromAny(movie["GroupId"]); groupID != "" {
-				return groupID, nil
-			}
-		}
-	}
-	return stringFromAny(payload["GroupId"]), nil
-}
-
-func rehostPosterToSelectedHost(ctx context.Context, req trackers.UploadRequest, imageURL string) string {
-	trimmedURL := strings.TrimSpace(imageURL)
-	if trimmedURL == "" {
-		return ""
-	}
-	if req.Images == nil {
-		return trimmedURL
-	}
-	if req.Meta.ImageHostOverrides.SkipUpload != nil && *req.Meta.ImageHostOverrides.SkipUpload {
-		return trimmedURL
-	}
-
-	selectedHost, err := trackers.PreferredImageUploadHost("PTP", req.TrackerConfig, req.Meta.ImageHostOverrides)
-	if err != nil {
-		logPosterRehostFailure(req.Logger, "", err)
-		return trimmedURL
-	}
-	selectedHost = strings.ToLower(strings.TrimSpace(selectedHost))
-	if selectedHost == "" {
-		return trimmedURL
-	}
-	if strings.EqualFold(strings.TrimSpace(imagehost.ExtractHost(trimmedURL)), selectedHost) {
-		return trimmedURL
-	}
-
-	posterPath, err := downloadPoster(ctx, req.Meta, req.AppConfig.MainSettings.DBPath, trimmedURL)
-	if err != nil {
-		logPosterRehostFailure(req.Logger, selectedHost, err)
-		return trimmedURL
-	}
-	uploaded, err := req.Images.Upload(ctx, req.Meta, selectedHost, "global", []api.ScreenshotImage{{Path: posterPath}})
-	if err != nil {
-		logPosterRehostFailure(req.Logger, selectedHost, err)
-		return trimmedURL
-	}
-	if len(uploaded) == 0 {
-		logPosterRehostFailure(req.Logger, selectedHost, errors.New("upload returned no links"))
-		return trimmedURL
-	}
-	uploadedURL := metautil.FirstNonEmptyTrimmed(uploaded[0].RawURL, uploaded[0].ImgURL, uploaded[0].WebURL)
-	if strings.TrimSpace(uploadedURL) == "" {
-		logPosterRehostFailure(req.Logger, selectedHost, errors.New("upload returned blank link"))
-		return trimmedURL
-	}
-	if req.Logger != nil {
-		req.Logger.Infof("trackers: PTP poster rehosted to %s", selectedHost)
-	}
-	return strings.TrimSpace(uploadedURL)
-}
-
-func downloadPoster(ctx context.Context, meta api.PreparedMetadata, dbPath string, imageURL string) (string, error) {
-	if err := validatePosterURL(imageURL); err != nil {
-		return "", err
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, imageURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("poster request: %w", err)
-	}
-	httpReq.Header.Set("User-Agent", ptpUserAgent)
-
-	client := newPosterHTTPClient()
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("poster download: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return "", fmt.Errorf("poster download status=%d", resp.StatusCode)
-	}
-
-	const maxPosterBytes = 25 << 20
-	body, err := io.ReadAll(io.LimitReader(resp.Body, maxPosterBytes+1))
-	if err != nil {
-		return "", fmt.Errorf("poster read: %w", err)
-	}
-	if len(body) == 0 {
-		return "", errors.New("poster download returned empty body")
-	}
-	if len(body) > maxPosterBytes {
-		return "", errors.New("poster exceeds maximum size")
-	}
-
-	posterPath := filepath.Join(tmpDir, "PTP_POSTER"+posterExtension(imageURL, resp.Header.Get("Content-Type")))
-	if err := os.WriteFile(posterPath, body, 0o600); err != nil {
-		return "", fmt.Errorf("poster write: %w", err)
-	}
-	return posterPath, nil
-}
-
-func posterExtension(imageURL string, contentType string) string {
-	if parsed, err := url.Parse(imageURL); err == nil {
-		switch ext := strings.ToLower(path.Ext(parsed.Path)); ext {
-		case ".jpg", ".jpeg", ".png", ".webp":
-			return ext
-		}
-	}
-	mediaType := strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
-	switch mediaType {
-	case "image/png":
-		return ".png"
-	case "image/webp":
-		return ".webp"
-	case "image/jpeg":
-		return ".jpg"
-	default:
-		return ".jpg"
-	}
-}
-
-func validatePosterURL(rawURL string) error {
-	parsed, err := url.Parse(strings.TrimSpace(rawURL))
-	if err != nil {
-		return fmt.Errorf("poster URL: %w", err)
-	}
-	if parsed.Scheme != "http" && parsed.Scheme != "https" {
-		return errors.New("poster URL must use http or https")
-	}
-	if strings.TrimSpace(parsed.Hostname()) == "" {
-		return errors.New("poster URL host is required")
-	}
-	return nil
-}
-
-func newPublicPosterHTTPClient() *http.Client {
-	dialer := &net.Dialer{Timeout: 30 * time.Second}
-	transport := &http.Transport{
-		DialContext: func(ctx context.Context, network string, addr string) (net.Conn, error) {
-			host, port, err := net.SplitHostPort(addr)
-			if err != nil {
-				return nil, fmt.Errorf("poster dial address: %w", err)
-			}
-			target, err := resolvePublicPosterAddress(ctx, host, port)
-			if err != nil {
-				return nil, err
-			}
-			return dialer.DialContext(ctx, network, target)
-		},
-	}
-	return &http.Client{Timeout: 30 * time.Second, Transport: transport}
-}
-
-func resolvePublicPosterAddress(ctx context.Context, host string, port string) (string, error) {
-	if ip := net.ParseIP(host); ip != nil {
-		addr, ok := netip.AddrFromSlice(ip)
-		if !ok || !isPublicPosterIP(addr.Unmap()) {
-			return "", fmt.Errorf("poster host %q resolves to non-public IP", host)
-		}
-		return net.JoinHostPort(addr.String(), port), nil
-	}
-	resolved, err := net.DefaultResolver.LookupIPAddr(ctx, host)
-	if err != nil {
-		return "", fmt.Errorf("poster DNS lookup %q: %w", host, err)
-	}
-	for _, candidate := range resolved {
-		addr, ok := netip.AddrFromSlice(candidate.IP)
-		if !ok {
-			continue
-		}
-		addr = addr.Unmap()
-		if isPublicPosterIP(addr) {
-			return net.JoinHostPort(addr.String(), port), nil
-		}
-	}
-	return "", fmt.Errorf("poster host %q has no public IP addresses", host)
-}
-
-func isPublicPosterIP(ip netip.Addr) bool {
-	if !ip.IsValid() || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsInterfaceLocalMulticast() || ip.IsMulticast() || ip.IsUnspecified() {
-		return false
-	}
-	return !ipInPrefixes(ip, reservedPosterPrefixes)
-}
-
-func ipInPrefixes(ip netip.Addr, prefixes []netip.Prefix) bool {
-	for _, prefix := range prefixes {
-		if prefix.Contains(ip) {
-			return true
-		}
-	}
-	return false
-}
-
-func logPosterRehostFailure(logger api.Logger, host string, err error) {
-	if logger == nil || err == nil {
-		return
-	}
-	if strings.TrimSpace(host) == "" {
-		logger.Warnf("trackers: PTP poster rehost failed: %v", err)
-		return
-	}
-	logger.Warnf("trackers: PTP poster rehost to %s failed: %v", strings.TrimSpace(host), err)
-}
-
-func buildUploadFields(meta api.PreparedMetadata, description string, groupID string, answers map[string]string, poster string) (map[string]string, error) {
-	resolution, otherResolution := resolveResolution(meta)
-	fields := map[string]string{
-		"submit":          "true",
-		"remaster_year":   "",
-		"remaster_title":  resolveRemasterTitle(meta),
-		"type":            resolveType(meta),
-		"codec":           "Other",
-		"other_codec":     resolveCodec(meta),
-		"container":       "Other",
-		"other_container": resolveContainer(meta),
-		"resolution":      resolution,
-		"source":          "Other",
-		"other_source":    resolveSource(meta.Source),
-		"release_desc":    description,
-		"nfo_text":        "",
-		"subtitles[]":     joinInts(resolveSubtitles(meta)),
-		"trumpable[]":     "",
-	}
-	if resolution == "Other" && otherResolution != "" {
-		fields["other_resolution"] = otherResolution
-	}
-	if fields["remaster_title"] != "" {
-		fields["remaster"] = "on"
-	}
-	if meta.Scene {
-		fields["scene"] = "on"
-	}
-	if meta.PersonalRelease {
-		fields["internalrip"] = "on"
-	}
-	if meta.ExternalIDs.IMDBID == 0 {
-		fields["imdb"] = "0"
-	} else {
-		fields["imdb"] = fmt.Sprintf("%07d", meta.ExternalIDs.IMDBID)
-	}
-	if groupID != "" {
-		fields["groupid"] = groupID
-		return fields, nil
-	}
-
-	title, year := resolveGroupTitleYear(meta)
-	title = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["title"]), title)
-	year = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["year"]), year)
-	if strings.TrimSpace(title) == "" {
-		return nil, errors.New("trackers: PTP missing title for new group upload")
-	}
-	fields["title"] = title
-	fields["year"] = year
-	fields["image"] = strings.TrimSpace(poster)
-	fields["tags"] = metautil.FirstNonEmptyTrimmed(answers["tags"], resolveTags(meta))
-	fields["album_desc"] = metautil.FirstNonEmptyTrimmed(answers["album_desc"], resolveOverview(meta))
-	fields["trailer"] = metautil.FirstNonEmptyTrimmed(answers["trailer"], resolveTrailer(meta))
-	directors := resolveDirectors(meta)
-	if len(directors) > 0 {
-		fields["artist[]"] = strings.Join(directors, "\n")
-		fields["importance[]"] = "1"
-	}
-	if fields["image"] == "" {
-		return nil, errors.New("trackers: PTP missing poster for new group upload")
-	}
-	return fields, nil
-}
-
-func resolveSession(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, baseURL string, logger api.Logger) (*http.Client, string, error) {
-	return resolveSessionLogin(ctx, trackerConfig, dbPath, baseURL, logger, api.TrackerAuthLoginRequest{})
-}
-
-func resolveSessionLogin(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, baseURL string, logger api.Logger, login api.TrackerAuthLoginRequest) (*http.Client, string, error) {
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-
-	cookies, err := loadCookies(ctx, dbPath)
-	if err == nil && len(cookies) > 0 {
-		client, token, tokenErr := fetchAntiCsrfToken(ctx, baseURL, cookies)
-		if tokenErr == nil {
-			return client, token, nil
-		}
-		if strings.TrimSpace(trackerConfig.Username) == "" || strings.TrimSpace(trackerConfig.Password) == "" || strings.TrimSpace(normalizedAnnounceURL(trackerConfig.AnnounceURL)) == "" {
-			return nil, "", tokenErr
-		}
-	}
-	return loginAndFetchAntiCsrfToken(ctx, trackerConfig, dbPath, baseURL, logger, login)
-}
-
-// ResolveSessionForTrackerAuth validates PTP stored cookies or logs in with
-// configured credentials. Credential login must produce an anti-CSRF token
-// before refreshed cookies are persisted.
-func ResolveSessionForTrackerAuth(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string) error {
-	return ResolveSessionForTrackerAuthLogin(ctx, trackerConfig, dbPath, api.TrackerAuthLoginRequest{})
-}
-
-// ResolveSessionForTrackerAuthLogin validates PTP stored cookies or logs in
-// with configured credentials. When PTP requires 2FA, login.Code is used before
-// falling back to the configured OTP URI; if neither yields a code, the error
-// is returned before stored cookies are replaced. A rejected submitted code
-// returns [ErrSubmitted2FARejected] with the login-failed error before refreshed
-// cookies are persisted.
-func ResolveSessionForTrackerAuthLogin(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
-	baseURL := strings.TrimRight(strings.TrimSpace(trackerConfig.URL), "/")
-	if baseURL == "" {
-		baseURL = ptpBaseURL
-	}
-	_, _, err := resolveSessionLogin(ctx, trackerConfig, dbPath, baseURL, api.NopLogger{}, login)
-	return err
-}
-
-func fetchAntiCsrfToken(ctx context.Context, baseURL string, cookies map[string]string) (*http.Client, string, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP create session cookie jar: %w", err)
-	}
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP parse base URL: %w", err)
-	}
-	jarCookies := make([]*http.Cookie, 0, len(cookies))
-	for name, value := range cookies {
-		if strings.TrimSpace(name) == "" || strings.TrimSpace(value) == "" {
-			continue
-		}
-		// #nosec G124 -- Outbound tracker jar cookie mirrors configured PTP session values.
-		jarCookies = append(jarCookies, &http.Cookie{Name: name, Value: value, Path: "/", Domain: parsed.Hostname()})
-	}
-	jar.SetCookies(parsed, jarCookies)
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	token, err := requestAntiCsrfToken(ctx, client, baseURL)
-	if err != nil {
-		return nil, "", err
-	}
-	return client, token, nil
-}
-
-func loginAndFetchAntiCsrfToken(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, baseURL string, _ api.Logger, login api.TrackerAuthLoginRequest) (*http.Client, string, error) {
-	username := strings.TrimSpace(trackerConfig.Username)
-	password := strings.TrimSpace(trackerConfig.Password)
-	announceURL := normalizedAnnounceURL(trackerConfig.AnnounceURL)
-	if username == "" || password == "" || announceURL == "" {
-		return nil, "", errors.New("trackers: PTP requires username, password, and announce_url")
-	}
-	passkey, err := passkeyFromAnnounce(announceURL)
-	if err != nil {
-		return nil, "", err
-	}
-
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	form := url.Values{
-		"username":   {username},
-		"password":   {password},
-		"passkey":    {passkey},
-		"keeplogged": {"1"},
-	}
-	loginURL := strings.TrimRight(baseURL, "/") + ptpLoginPath
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(form.Encode()))
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP build login request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	httpReq.Header.Set("User-Agent", ptpUserAgent)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP login request: %w", err)
-	}
-	defer resp.Body.Close()
-	var payload map[string]any
-	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP login decode: %w", err)
-	}
-	switch strings.TrimSpace(stringFromAny(payload["Result"])) {
-	case "Ok":
-	case "TfaRequired":
-		code, codeErr := resolvePTP2FACode(trackerConfig, login)
-		if codeErr != nil {
-			return nil, "", fmt.Errorf("trackers: PTP 2FA required: %w", codeErr)
-		}
-		form.Set("TfaType", "normal")
-		form.Set("TfaCode", code)
-		httpReq, err = http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(form.Encode()))
-		if err != nil {
-			return nil, "", fmt.Errorf("trackers: PTP build 2FA request: %w", err)
-		}
-		httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		httpReq.Header.Set("User-Agent", ptpUserAgent)
-		resp, err = client.Do(httpReq)
-		if err != nil {
-			return nil, "", fmt.Errorf("trackers: PTP 2FA request: %w", err)
-		}
-		defer resp.Body.Close()
-		payload = map[string]any{}
-		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
-			return nil, "", fmt.Errorf("trackers: PTP 2FA decode: %w", err)
-		}
-		if strings.TrimSpace(stringFromAny(payload["Result"])) != "Ok" {
-			return nil, "", fmt.Errorf("trackers: PTP login failed: %w", ErrSubmitted2FARejected)
-		}
-	default:
-		return nil, "", errors.New("trackers: PTP login failed")
-	}
-
-	token := strings.TrimSpace(stringFromAny(payload["AntiCsrfToken"]))
-	if token == "" {
-		return nil, "", errors.New("trackers: PTP login missing anti csrf token")
-	}
-	if err := saveCookies(ctx, dbPath, client, baseURL); err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP persist login cookies: %w", err)
-	}
-	return client, token, nil
-}
-
-// resolvePTP2FACode prefers a submitted manual code so users can continue a
-// browser-visible challenge when no reusable OTP URI is configured.
-func resolvePTP2FACode(trackerConfig config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
-	if code := strings.TrimSpace(login.Code); code != "" {
-		return code, nil
-	}
-	return resolve2FACode(trackerConfig.OTPURI)
-}
-
-func requestAntiCsrfToken(ctx context.Context, client *http.Client, baseURL string) (string, error) {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+ptpUploadPath, nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP build upload page request: %w", err)
-	}
-	httpReq.Header.Set("User-Agent", ptpUserAgent)
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP upload page: %w", err)
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP read upload page: %w", err)
-	}
-	matches := ptpAntiCsrfPattern.FindStringSubmatch(string(body))
-	if len(matches) < 2 {
-		return "", errors.New("trackers: PTP anti csrf token not found")
-	}
-	return strings.TrimSpace(matches[1]), nil
-}
-
-func buildMultipartPayload(fields map[string]string, torrentPath string, fileField string) ([]byte, string, error) {
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	keys := make([]string, 0, len(fields))
-	for key := range fields {
-		keys = append(keys, key)
-	}
-	slices.Sort(keys)
-	for _, key := range keys {
-		if key == "artist[]" {
-			for value := range strings.SplitSeq(fields[key], "\n") {
-				if strings.TrimSpace(value) == "" {
-					continue
-				}
-				if err := writer.WriteField(key, value); err != nil {
-					_ = writer.Close()
-					return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
-				}
-			}
-			continue
-		}
-		if key == "subtitles[]" || key == "trumpable[]" {
-			for value := range strings.SplitSeq(fields[key], ",") {
-				trimmed := strings.TrimSpace(value)
-				if trimmed == "" {
-					continue
-				}
-				if err := writer.WriteField(key, trimmed); err != nil {
-					_ = writer.Close()
-					return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
-				}
-			}
-			continue
-		}
-		if err := writer.WriteField(key, fields[key]); err != nil {
-			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
-		}
-	}
-
-	file, err := os.Open(torrentPath)
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: PTP open torrent file: %w", err)
-	}
-	defer file.Close()
-	part, err := writer.CreateFormFile(fileField, "placeholder.torrent")
-	if err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: PTP create torrent form file: %w", err)
-	}
-	if _, err := io.Copy(part, file); err != nil {
-		_ = writer.Close()
-		return nil, "", fmt.Errorf("trackers: PTP copy torrent file: %w", err)
-	}
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: PTP close multipart writer: %w", err)
-	}
-	return body.Bytes(), writer.FormDataContentType(), nil
-}
-
-func resolveTrackerTorrentPath(meta api.PreparedMetadata, dbPath string, tracker string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return "", errors.New("trackers: PTP tracker torrent path requires db path and source path")
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return filepath.Join(tmpDir, base+"."+strings.ToLower(strings.TrimSpace(tracker))+".torrent"), nil
-}
-
-func resolveFailurePath(meta api.PreparedMetadata, dbPath string) (string, error) {
-	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
-		return "", errors.New("trackers: PTP failure path requires db path and source path")
-	}
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return filepath.Join(tmpDir, "[PTP]upload_failure.html"), nil
-}
-
-func loadCookies(ctx context.Context, dbPath string) (map[string]string, error) {
-	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "PTP")
-	if err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	return values, nil
-}
-
-func saveCookies(ctx context.Context, dbPath string, client *http.Client, baseURL string) error {
-	if client == nil || client.Jar == nil {
-		return errors.New("trackers: PTP login returned no cookie jar")
-	}
-	parsed, err := url.Parse(baseURL)
-	if err != nil {
-		return fmt.Errorf("trackers: PTP parse cookie URL: %w", err)
-	}
-	cookies := make(map[string]string)
-	for _, cookie := range client.Jar.Cookies(parsed) {
-		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
-			continue
-		}
-		if strings.TrimSpace(cookie.Value) == "" {
-			continue
-		}
-		cookies[strings.TrimSpace(cookie.Name)] = cookie.Value
-	}
-	if len(cookies) == 0 {
-		return errors.New("trackers: PTP login returned no usable cookies")
-	}
-	return wrapTrackerError(cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", cookies))
-}
-
-func passkeyFromAnnounce(announceURL string) (string, error) {
-	parsed, err := url.Parse(announceURL)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP parse announce URL: %w", err)
-	}
-	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
-	if len(parts) < 2 {
-		return "", errors.New("trackers: PTP failed to extract passkey from announce_url")
-	}
-	return parts[0], nil
-}
-
-func resolve2FACode(otpURI string) (string, error) {
-	trimmed := strings.TrimSpace(otpURI)
-	if trimmed == "" {
-		return "", errors.New("otp_uri not configured")
-	}
-	parsed, err := url.Parse(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP parse otp_uri: %w", err)
-	}
-	secret := strings.TrimSpace(parsed.Query().Get("secret"))
-	if secret == "" {
-		return "", errors.New("otp_uri missing secret")
-	}
-	period := 30
-	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
-		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
-			period = parsedValue
-		}
-	}
-	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
-	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP decode otp secret: %w", err)
-	}
-	counterTime := time.Now().Unix() / int64(period)
-	if counterTime < 0 {
-		return "", errors.New("totp counter before unix epoch")
-	}
-	counter := uint64(counterTime)
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint64(buf, counter)
-	mac := hmac.New(sha1.New, secretBytes)
-	_, _ = mac.Write(buf)
-	hash := mac.Sum(nil)
-	offset := hash[len(hash)-1] & 0x0f
-	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
-	return fmt.Sprintf("%06d", code%1000000), nil
-}
-
-func resolveUploadName(meta api.PreparedMetadata) string {
-	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(meta.Filename); name != "" {
-		return name
-	}
-	return pathutil.Base(meta.SourcePath)
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	category := strings.ToLower(strings.TrimSpace(meta.ExternalIDs.Category))
-	if category == "" {
-		category = strings.ToLower(strings.TrimSpace(meta.MediaInfoCategory))
-	}
-	if meta.ExternalMetadata.IMDB != nil && strings.Contains(strings.ToLower(meta.ExternalMetadata.IMDB.Type), "concert") {
-		return "Music"
-	}
-	if meta.ExternalMetadata.TMDB != nil && (strings.Contains(strings.ToLower(meta.ExternalMetadata.TMDB.Genres), "documentary") || strings.Contains(strings.ToLower(meta.ExternalMetadata.TMDB.Keywords), "documentary")) {
-		return "Documentary"
-	}
-	if category == "movie" {
-		return "Feature Film"
-	}
-	if category == "tv" {
-		if meta.TVPack {
-			return "Miniseries"
-		}
-		return "Short Film"
-	}
-	return "Feature Film"
-}
-
-func resolveCodec(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return "BD50"
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return "DVD9"
-	}
-	codec := strings.TrimSpace(meta.VideoCodec)
-	if codec == "" {
-		codec = strings.TrimSpace(meta.VideoEncode)
-	}
-	replacer := strings.NewReplacer("AVC", "H.264", "HEVC", "H.265")
-	codec = replacer.Replace(codec)
-	if meta.HasEncodeSettings {
-		codec = strings.ReplaceAll(codec, "H.", "x")
-	}
-	if codec == "" {
-		return "Other"
-	}
-	return codec
-}
-
-func resolveResolution(meta api.PreparedMetadata) (string, string) {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if resolution == "" {
-		resolution = "Other"
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		source := strings.TrimSpace(meta.Source)
-		source = strings.ReplaceAll(source, " DVD", "")
-		if source != "" {
-			return source, ""
-		}
-	}
-	if strings.EqualFold(resolution, "OTHER") {
-		return "Other", "Other"
-	}
-	return resolution, ""
-}
-
-func resolveContainer(meta api.PreparedMetadata) string {
-	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
-	case "BDMV":
-		return "m2ts"
-	case "DVD":
-		return "VOB IFO"
-	default:
-		switch strings.ToLower(filepath.Ext(firstFile(meta))) {
-		case ".mkv":
-			return "MKV"
-		case ".mp4":
-			return "MP4"
-		default:
-			return "Other"
-		}
-	}
-}
-
-func resolveSource(source string) string {
-	switch strings.TrimSpace(source) {
-	case "Blu-ray", "BluRay":
-		return "Blu-ray"
-	case "HD DVD", "HDDVD":
-		return "HD-DVD"
-	case "Web":
-		return "WEB"
-	case "HDTV", "UHDTV":
-		return "HDTV"
-	case "NTSC", "PAL":
-		return "DVD"
-	default:
-		return "OtherR"
-	}
-}
-
-func resolveSubtitles(meta api.PreparedMetadata) []int {
-	if len(meta.SubtitleLanguages) == 0 {
-		return []int{44}
-	}
-	ids := make([]int, 0, len(meta.SubtitleLanguages))
-	seen := make(map[int]struct{})
-	for _, language := range meta.SubtitleLanguages {
-		if value, ok := subtitleIDs[strings.ToLower(strings.TrimSpace(language))]; ok {
-			if _, exists := seen[value]; exists {
-				continue
-			}
-			seen[value] = struct{}{}
-			ids = append(ids, value)
-		}
-	}
-	if len(ids) == 0 {
-		return []int{44}
-	}
-	return ids
-}
-
-func resolveRemasterTitle(meta api.PreparedMetadata) string {
-	parts := make([]string, 0, 8)
-	distributor := strings.ToUpper(strings.TrimSpace(meta.Distributor))
-	switch distributor {
-	case "WARNER ARCHIVE", "WARNER ARCHIVE COLLECTION", "WAC":
-		parts = append(parts, "Warner Archive Collection")
-	case "CRITERION", "CRITERION COLLECTION", "CC":
-		parts = append(parts, "The Criterion Collection")
-	case "MASTERS OF CINEMA", "MOC":
-		parts = append(parts, "Masters of Cinema")
-	}
-	edition := strings.TrimSpace(meta.Edition)
-	switch {
-	case strings.Contains(strings.ToLower(edition), "director's cut"):
-		parts = append(parts, "Director's Cut")
-	case strings.Contains(strings.ToLower(edition), "extended"):
-		parts = append(parts, "Extended Edition")
-	case strings.Contains(strings.ToLower(edition), "theatrical"):
-		parts = append(parts, "Theatrical Cut")
-	case strings.Contains(strings.ToLower(edition), "uncut"):
-		parts = append(parts, "Uncut")
-	case strings.Contains(strings.ToLower(edition), "unrated"):
-		parts = append(parts, "Unrated")
-	case edition != "":
-		parts = append(parts, edition)
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
-		parts = append(parts, "Remux")
-	}
-	audio := strings.TrimSpace(meta.Audio)
-	if strings.Contains(audio, "DTS:X") {
-		parts = append(parts, "DTS:X")
-	}
-	if strings.Contains(audio, "Atmos") {
-		parts = append(parts, "Dolby Atmos")
-	}
-	if strings.Contains(audio, "Dual") {
-		parts = append(parts, "Dual Audio")
-	}
-	if strings.Contains(audio, "Dubbed") {
-		parts = append(parts, "English Dub")
-	}
-	if meta.HDR == "" && meta.BitDepth == "10" {
-		parts = append(parts, "10-bit")
-	}
-	if strings.Contains(meta.HDR, "DV") {
-		parts = append(parts, "Dolby Vision")
-	}
-	if strings.Contains(meta.HDR, "HDR10+") {
-		parts = append(parts, "HDR10+")
-	} else if strings.Contains(meta.HDR, "HDR") {
-		parts = append(parts, "HDR10")
-	}
-	if strings.Contains(meta.HDR, "HLG") {
-		parts = append(parts, "HLG")
-	}
-	if meta.HasCommentary {
-		parts = append(parts, "With Commentary")
-	}
-	return strings.Join(parts, " / ")
-}
-
-func resolveGroupTitleYear(meta api.PreparedMetadata) (string, string) {
-	title := ""
-	year := 0
-	if meta.ExternalMetadata.TMDB != nil {
-		title = strings.TrimSpace(meta.ExternalMetadata.TMDB.Title)
-		year = meta.ExternalMetadata.TMDB.Year
-	}
-	if title == "" && meta.ExternalMetadata.IMDB != nil {
-		title = strings.TrimSpace(meta.ExternalMetadata.IMDB.Title)
-		year = meta.ExternalMetadata.IMDB.Year
-	}
-	if title == "" {
-		title = strings.TrimSpace(meta.Release.Title)
-	}
-	if year == 0 {
-		year = meta.Release.Year
-	}
-	if year == 0 {
-		return title, ""
-	}
-	return title, strconv.Itoa(year)
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		if value := strings.TrimSpace(meta.ExternalMetadata.TMDB.Poster); value != "" {
-			return value
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Cover)
-	}
-	return ""
-}
-
-func resolveOverview(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		if value := strings.TrimSpace(meta.ExternalMetadata.TMDB.Overview); value != "" {
-			return value
-		}
-	}
-	if meta.ExternalMetadata.IMDB != nil {
-		if value := strings.TrimSpace(meta.ExternalMetadata.IMDB.Plot); value != "" {
-			return value
-		}
-	}
-	return ""
-}
-
-func resolveTrailer(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.YouTube)
-	}
-	return ""
-}
-
-func resolveDirectors(meta api.PreparedMetadata) []string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.Directors) > 0 {
-		return append([]string{}, meta.ExternalMetadata.TMDB.Directors...)
-	}
-	if meta.ExternalMetadata.IMDB != nil && len(meta.ExternalMetadata.IMDB.Directors) > 0 {
-		names := make([]string, 0, len(meta.ExternalMetadata.IMDB.Directors))
-		for _, person := range meta.ExternalMetadata.IMDB.Directors {
-			if strings.TrimSpace(person.Name) != "" {
-				names = append(names, strings.TrimSpace(person.Name))
-			}
-		}
-		return names
-	}
-	return nil
-}
-
-func resolveTags(meta api.PreparedMetadata) string {
-	values := make([]string, 0, 8)
-	if meta.ExternalMetadata.TMDB != nil {
-		for item := range strings.SplitSeq(meta.ExternalMetadata.TMDB.Genres, ",") {
-			trimmed := strings.ToLower(strings.TrimSpace(item))
-			if trimmed != "" {
-				values = append(values, trimmed)
-			}
-		}
-	}
-	if len(values) == 0 && strings.TrimSpace(meta.Release.Genre) != "" {
-		for item := range strings.SplitSeq(meta.Release.Genre, ",") {
-			trimmed := strings.ToLower(strings.TrimSpace(item))
-			if trimmed != "" {
-				values = append(values, trimmed)
-			}
-		}
-	}
-	if len(values) == 0 {
-		values = append(values, "action")
-	}
-	seen := make(map[string]struct{}, len(values))
-	filtered := make([]string, 0, len(values))
-	for _, value := range values {
-		if _, ok := seen[value]; ok {
-			continue
-		}
-		seen[value] = struct{}{}
-		filtered = append(filtered, value)
-	}
-	return strings.Join(filtered, ", ")
-}
-
-func firstFile(meta api.PreparedMetadata) string {
-	if len(meta.FileList) > 0 {
-		return meta.FileList[0]
-	}
-	return meta.SourcePath
-}
-
-func normalizedAnnounceURL(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if strings.HasPrefix(trimmed, "http://please.passthepopcorn.me") {
-		return strings.Replace(trimmed, "http://", "https://", 1)
-	}
-	return trimmed
-}
-
-func extractAlertError(body string) string {
-	start := strings.Index(body, `alert alert--error`)
-	if start == -1 {
-		return ""
-	}
-	segment := body[start:]
-	end := strings.Index(segment, "</div>")
-	if end != -1 {
-		segment = segment[:end]
-	}
-	return stripTags(segment)
-}
-
-func stripTags(value string) string {
-	inTag := false
-	var builder strings.Builder
-	for _, r := range value {
-		switch r {
-		case '<':
-			inTag = true
-		case '>':
-			inTag = false
-		default:
-			if !inTag {
-				builder.WriteRune(r)
-			}
-		}
-	}
-	return strings.Join(strings.Fields(builder.String()), " ")
-}
-
-func compactError(value string) string {
-	trimmed := strings.Join(strings.Fields(strings.TrimSpace(value)), " ")
-	if len(trimmed) > 220 {
-		return trimmed[:220]
-	}
-	return trimmed
-}
-
-func stringFromAny(value any) string {
-	switch typed := value.(type) {
-	case nil:
-		return ""
-	case string:
-		return strings.TrimSpace(typed)
-	case float64:
-		return strconv.Itoa(int(typed))
-	case int:
-		return strconv.Itoa(typed)
-	case int64:
-		return strconv.FormatInt(typed, 10)
-	default:
-		return strings.TrimSpace(fmt.Sprint(value))
-	}
-}
-
-func joinInts(values []int) string {
-	if len(values) == 0 {
-		return ""
-	}
-	parts := make([]string, 0, len(values))
-	for _, value := range values {
-		parts = append(parts, strconv.Itoa(value))
-	}
-	return strings.Join(parts, ",")
-}
-
-func readBDSummary(meta api.PreparedMetadata, dbPath string) (string, error) {
-	tmpRoot, err := db.Subdir(dbPath, "tmp")
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
-	if err != nil {
-		return "", fmt.Errorf("trackers: %w", err)
-	}
-	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta)))
-}
-
-func readTextFile(path string) (string, error) {
-	trimmed := strings.TrimSpace(path)
-	if trimmed == "" {
-		return "", nil
-	}
-	payload, err := os.ReadFile(trimmed)
-	if err != nil {
-		return "", fmt.Errorf("trackers: PTP read text file: %w", err)
-	}
-	return string(payload), nil
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata, groupID string) *api.TrackerQuestionnaire {
-	if strings.TrimSpace(groupID) != "" {
-		return nil
-	}
-	title, year := resolveGroupTitleYear(meta)
-	fields := []api.TrackerQuestionnaireField{
-		{Key: "title", Label: "Group Title", Kind: "text", Value: title, Required: true},
-		{Key: "year", Label: "Year", Kind: "text", Value: year, Required: false, Placeholder: "Release year"},
-		{Key: "poster", Label: "Poster URL", Kind: "text", Value: resolvePoster(meta), Required: true},
-		{Key: "tags", Label: "Tags", Kind: "text", Value: resolveTags(meta), Required: true, Placeholder: "Comma separated tags"},
-		{Key: "trailer", Label: "Trailer URL", Kind: "text", Value: resolveTrailer(meta), Required: false, Placeholder: "YouTube trailer URL"},
-		{Key: "album_desc", Label: "Group Description", Kind: "textarea", Value: resolveOverview(meta), Required: false},
-	}
-	return &api.TrackerQuestionnaire{
-		Tracker: "PTP",
-		Fields:  fields,
-	}
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata, tracker string) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers[strings.ToUpper(strings.TrimSpace(tracker))]
-}
-
-var subtitleIDs = map[string]int{
-	"arabic":               22,
-	"brazilian portuguese": 49,
-	"bulgarian":            29,
-	"chinese":              14,
-	"croatian":             23,
-	"czech":                30,
-	"danish":               10,
-	"dutch":                9,
-	"english":              3,
-	"english - forced":     50,
-	"english forced":       50,
-	"english intertitles":  51,
-	"estonian":             38,
-	"finnish":              15,
-	"french":               5,
-	"german":               6,
-	"greek":                26,
-	"hebrew":               40,
-	"hindi":                41,
-	"hungarian":            24,
-	"icelandic":            28,
-	"indonesian":           47,
-	"italian":              16,
-	"japanese":             8,
-	"korean":               19,
-	"latvian":              37,
-	"lithuanian":           39,
-	"norwegian":            12,
-	"polish":               17,
-	"portuguese":           21,
-	"romanian":             13,
-	"russian":              7,
-	"serbian":              31,
-	"slovak":               42,
-	"slovenian":            43,
-	"spanish":              4,
-	"swedish":              11,
-	"thai":                 20,
-	"turkish":              18,
-	"ukrainian":            34,
-	"vietnamese":           25,
-}
diff --git a/internal/trackers/impl/ptp/upload_test.go b/internal/trackers/impl/ptp/upload_test.go
deleted file mode 100644
index 6d9a7b76..00000000
--- a/internal/trackers/impl/ptp/upload_test.go
+++ /dev/null
@@ -1,395 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ptp
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/authmaterial"
-	"github.com/autobrr/upbrr/internal/config"
-	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestLoadCookiesSuccessReturnsNilError(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-
-	got, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if got["session"] != "abc" {
-		t.Fatalf("unexpected cookies: %#v", got)
-	}
-}
-
-func TestResolveSessionForTrackerAuthPreservesCookiesOnTransientTokenFetch(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
-	baseURL := server.URL
-	server.Close()
-
-	err := ResolveSessionForTrackerAuth(ctx, config.TrackerConfig{
-		URL:         baseURL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath)
-	if err == nil {
-		t.Fatal("expected transient token fetch error")
-	}
-	got, loadErr := loadCookies(ctx, dbPath)
-	if loadErr != nil {
-		t.Fatalf("loadCookies after transient error: %v", loadErr)
-	}
-	if got["session"] != "abc" {
-		t.Fatalf("expected transient failure to preserve cookies, got %#v", got)
-	}
-}
-
-func TestLoginAndFetchAntiCsrfTokenReturnsPersistenceError(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	_, _, err := resolveSession(context.Background(), config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, filepath.Join(t.TempDir(), "upbrr.db"), server.URL, api.NopLogger{})
-	if err == nil {
-		t.Fatal("expected persistence error")
-	}
-	if !strings.Contains(err.Error(), "persist login cookies") {
-		t.Fatalf("expected persistence error, got %v", err)
-	}
-}
-
-func TestLoginAndFetchAntiCsrfTokenDoesNotOverwriteCookiesWhenTokenMissing(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == ptpUploadPath {
-			_, _ = w.Write([]byte("<html>logged out</html>"))
-			return
-		}
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-		_, _ = w.Write([]byte(`{"Result":"Ok"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	_, _, err := resolveSession(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, server.URL, api.NopLogger{})
-	if err == nil {
-		t.Fatal("expected missing token error")
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatalf("missing token must not overwrite stored cookies, got %#v", values)
-	}
-}
-
-func TestLoginAndFetchAntiCsrfTokenPersistsCookiesAfterTokenGate(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	_, token, err := resolveSession(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, server.URL, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("resolveSession: %v", err)
-	}
-	if token != "token" {
-		t.Fatalf("unexpected token %q", token)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "new" {
-		t.Fatalf("expected saved login cookies, got %#v", values)
-	}
-}
-
-func TestLoginAndFetchAntiCsrfTokenRejectsEmptyJarWithoutReplacingCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == ptpUploadPath:
-			_, _ = w.Write([]byte("<html>logged out</html>"))
-		case r.URL.Path == "/ajax.php" && r.URL.RawQuery == "action=login":
-			_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	_, _, err := resolveSession(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, server.URL, api.NopLogger{})
-	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
-		t.Fatalf("expected empty cookie jar error, got %v", err)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatalf("empty login jar must preserve stored cookies, got %#v", values)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginUsesManual2FACode(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	var gotCode string
-	loginRequests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		if err := r.ParseForm(); err != nil {
-			t.Errorf("ParseForm: %v", err)
-			return
-		}
-		loginRequests++
-		if loginRequests == 1 {
-			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
-			return
-		}
-		gotCode = r.FormValue("TfaCode")
-		http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "654321"})
-	if err != nil {
-		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
-	}
-	if gotCode != "654321" {
-		t.Fatalf("expected manual 2FA code, got %q", gotCode)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "new" {
-		t.Fatalf("expected saved 2FA login cookies, got %#v", values)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginMarksSubmitted2FARejected(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	loginRequests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		loginRequests++
-		if loginRequests == 1 {
-			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
-			return
-		}
-		_, _ = w.Write([]byte(`{"Result":"Invalid"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"})
-	if !errors.Is(err, ErrSubmitted2FARejected) {
-		t.Fatalf("expected submitted 2FA rejection marker, got %v", err)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatalf("submitted 2FA rejection must preserve stored cookies, got %#v", values)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginPreCodeFailureIsNotSubmitted2FARejected(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
-			http.NotFound(w, r)
-			return
-		}
-		_, _ = w.Write([]byte(`{"Result":"Invalid"}`))
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"})
-	if err == nil || !strings.Contains(err.Error(), "login failed") {
-		t.Fatalf("expected pre-code login failed error, got %v", err)
-	}
-	if errors.Is(err, ErrSubmitted2FARejected) {
-		t.Fatalf("pre-code login failure must not carry submitted 2FA marker: %v", err)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatalf("pre-code login failure must preserve stored cookies, got %#v", values)
-	}
-}
-
-func TestResolveSessionForTrackerAuthLoginMissing2FACodePreservesCookies(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	dbPath := newPTPAuthDB(t)
-	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
-		t.Fatalf("SaveTrackerCookieMap: %v", err)
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == ptpUploadPath:
-			_, _ = w.Write([]byte("<html>logged out</html>"))
-		case r.URL.Path == "/ajax.php" && r.URL.RawQuery == "action=login":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
-			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:         server.URL,
-		Username:    "user",
-		Password:    "pass",
-		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
-	}, dbPath, api.TrackerAuthLoginRequest{})
-	if err == nil || !strings.Contains(err.Error(), "2FA required") {
-		t.Fatalf("expected missing 2FA error, got %v", err)
-	}
-	values, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		t.Fatalf("loadCookies: %v", err)
-	}
-	if values["session"] != "existing" {
-		t.Fatalf("missing 2FA code must preserve stored cookies, got %#v", values)
-	}
-}
-
-func newPTPAuthDB(t *testing.T) string {
-	t.Helper()
-
-	ctx := context.Background()
-	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
-	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
-	if err != nil {
-		t.Fatalf("OpenWithLoggerContext: %v", err)
-	}
-	if err := repo.MigrateContext(ctx); err != nil {
-		_ = repo.Close()
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	_ = repo.Close()
-	return dbPath
-}
diff --git a/internal/trackers/impl/ptp/wrap_errors.go b/internal/trackers/impl/ptp/wrap_errors.go
deleted file mode 100644
index f27a5764..00000000
--- a/internal/trackers/impl/ptp/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package ptp
-
-import "fmt"
-
-func wrapTrackerError(err error) error {
-	if err != nil {
-		return fmt.Errorf("trackers: %w", err)
-	}
-	return nil
-}
diff --git a/internal/trackers/impl/pts/definition.go b/internal/trackers/impl/pts/definition.go
deleted file mode 100644
index 52bade36..00000000
--- a/internal/trackers/impl/pts/definition.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package pts
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition { return definition{} }
-
-func (definition) Name() string { return "PTS" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, assets)
-	return trackers.DescriptionResult{Group: "pts", Description: description}, nil
-}
diff --git a/internal/trackers/impl/pts/upload.go b/internal/trackers/impl/pts/upload.go
deleted file mode 100644
index f122dd1e..00000000
--- a/internal/trackers/impl/pts/upload.go
+++ /dev/null
@@ -1,293 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package pts
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"maps"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://www.ptskit.org"
-	uploadURL  = baseURL + "/takeupload.php"
-	sourceFlag = "[www.ptskit.org] PTSKIT"
-)
-
-var idPattern = regexp.MustCompile(`download\.php\?id=([^&]+)`)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	questionnaire *api.TrackerQuestionnaire
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, cookies, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTS %s", state.blockedReason)
-	}
-
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
-		FieldName: "file",
-		FileName:  "PTS.torrent",
-		Path:      state.torrentPath,
-	}})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTS request build: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-	commonhttp.ApplyCookies(httpReq, cookies)
-
-	resp, err := (&http.Client{
-		CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse },
-	}).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTS upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusFound || resp.StatusCode == http.StatusSeeOther, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: PTS read upload response: %w", err)
-	}
-
-	location := strings.TrimSpace(resp.Header.Get("Location"))
-	torrentID := parseUploadID(location, string(responseBody))
-	if (resp.StatusCode == http.StatusFound || resp.StatusCode == http.StatusSeeOther) && torrentID != "" {
-		tURL := baseURL + "/details.php?id=" + url.QueryEscape(torrentID)
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "PTS")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "PTS",
-				TorrentID:   torrentID,
-				TorrentURL:  tURL,
-				DownloadURL: baseURL + "/download.php?id=" + url.QueryEscape(torrentID),
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "PTS", "upload_failure", responsePreview, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("PTS", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "PTS",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "pts",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, []*http.Cookie, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, assets)
-
-	state := uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
-		fields:        buildPayload(req.Meta, description),
-		questionnaire: buildQuestionnaire(req.Meta),
-		blockedReason: validateUpload(req.Meta),
-	}
-	cookies, err := loadCookies(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: PTS load cookies: %w", err)
-	}
-	return state, cookies, nil
-}
-
-func buildPayload(meta api.PreparedMetadata, description string) map[string]string {
-	return map[string]string{
-		"name":  metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename),
-		"url":   imdbURL(meta),
-		"descr": description,
-		"type":  resolveType(meta),
-	}
-}
-
-func buildDescription(meta api.PreparedMetadata, assets trackers.DescriptionAssets) string {
-	parts := make([]string, 0, 4)
-	if info := commonhttp.ReadOptionalFile(strings.TrimSpace(meta.MediaInfoTextPath)); strings.TrimSpace(info) != "" {
-		parts = append(parts, info)
-	}
-	if base := strings.TrimSpace(assets.Description); base != "" {
-		parts = append(parts, sanitizeDescription(base))
-	}
-	if shots := screenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-	parts = append(parts, "[right][url=https://github.com/autobrr/upbrr][size=1]upbrr[/size][/url][/right]")
-	return bbcode.FinalizeTrackerDescription("PTS", strings.TrimSpace(strings.Join(parts, "\n\n")))
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata) *api.TrackerQuestionnaire {
-	if hasMandarin(meta) {
-		return nil
-	}
-	answer := strings.ToLower(strings.TrimSpace(questionnaireAnswers(meta)["mandarin_override"]))
-	return &api.TrackerQuestionnaire{
-		Tracker: "PTS",
-		Fields: []api.TrackerQuestionnaireField{{
-			Key:      "mandarin_override",
-			Label:    "Mandarin Requirement",
-			Kind:     "select",
-			Options:  []string{"no", "yes"},
-			Value:    metautil.FirstNonEmptyTrimmed(answer, "no"),
-			Help:     "PTS expects Mandarin audio or subtitles. Choose yes to override and upload anyway.",
-			Required: true,
-		}},
-	}
-}
-
-func validateUpload(meta api.PreparedMetadata) string {
-	if hasMandarin(meta) {
-		return ""
-	}
-	if strings.EqualFold(strings.TrimSpace(questionnaireAnswers(meta)["mandarin_override"]), "yes") {
-		return ""
-	}
-	return "missing Mandarin audio/subtitles; answer the override questionnaire to continue"
-}
-
-func hasMandarin(meta api.PreparedMetadata) bool {
-	for _, values := range [][]string{meta.AudioLanguages, meta.SubtitleLanguages} {
-		for _, value := range values {
-			lower := strings.ToLower(strings.TrimSpace(value))
-			if strings.Contains(lower, "mandarin") || strings.Contains(lower, "chinese") {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "PTS", "ptskit.org"))
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return "407"
-	}
-	if isTV(meta) {
-		return "405"
-	}
-	return "404"
-}
-
-func sanitizeDescription(input string) string {
-	return bbcode.FinalizeTrackerDescription("PTS", input)
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	lines := []string{"[center][b]Screenshots[/b]"}
-	for _, image := range images {
-		imgURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL))
-		webURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.WebURL, imgURL))
-		if imgURL == "" || webURL == "" {
-			continue
-		}
-		lines = append(lines, fmt.Sprintf("[url=%s][img]%s[/img][/url]", webURL, imgURL))
-	}
-	lines = append(lines, "[/center]")
-	return strings.Join(lines, "\n")
-}
-
-func parseUploadID(location string, body string) string {
-	for _, value := range []string{location, body} {
-		match := idPattern.FindStringSubmatch(value)
-		if len(match) == 2 {
-			return strings.TrimSpace(match[1])
-		}
-	}
-	return ""
-}
-
-func imdbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["PTS"]
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
diff --git a/internal/trackers/impl/pts/wrap_errors.go b/internal/trackers/impl/pts/wrap_errors.go
deleted file mode 100644
index 99a82eb1..00000000
--- a/internal/trackers/impl/pts/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package pts
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/registry.go b/internal/trackers/impl/registry.go
index da4a4240..54bccede 100644
--- a/internal/trackers/impl/registry.go
+++ b/internal/trackers/impl/registry.go
@@ -7,123 +7,125 @@ import (
 	"fmt"
 
 	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ant"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ar"
-	"github.com/autobrr/upbrr/internal/trackers/impl/asc"
 	"github.com/autobrr/upbrr/internal/trackers/impl/azfamily"
-	"github.com/autobrr/upbrr/internal/trackers/impl/bhd"
-	"github.com/autobrr/upbrr/internal/trackers/impl/bhdtv"
-	"github.com/autobrr/upbrr/internal/trackers/impl/bjs"
-	"github.com/autobrr/upbrr/internal/trackers/impl/bt"
-	"github.com/autobrr/upbrr/internal/trackers/impl/btn"
-	"github.com/autobrr/upbrr/internal/trackers/impl/czt"
-	"github.com/autobrr/upbrr/internal/trackers/impl/dc"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ff"
-	"github.com/autobrr/upbrr/internal/trackers/impl/fl"
-	"github.com/autobrr/upbrr/internal/trackers/impl/gpw"
-	"github.com/autobrr/upbrr/internal/trackers/impl/hdb"
-	"github.com/autobrr/upbrr/internal/trackers/impl/hds"
-	"github.com/autobrr/upbrr/internal/trackers/impl/hdt"
-	"github.com/autobrr/upbrr/internal/trackers/impl/is"
-	"github.com/autobrr/upbrr/internal/trackers/impl/mtv"
-	"github.com/autobrr/upbrr/internal/trackers/impl/nbl"
-	"github.com/autobrr/upbrr/internal/trackers/impl/ptp"
-	"github.com/autobrr/upbrr/internal/trackers/impl/pts"
-	"github.com/autobrr/upbrr/internal/trackers/impl/rtf"
-	"github.com/autobrr/upbrr/internal/trackers/impl/spd"
-	"github.com/autobrr/upbrr/internal/trackers/impl/thr"
-	"github.com/autobrr/upbrr/internal/trackers/impl/tl"
-	"github.com/autobrr/upbrr/internal/trackers/impl/tvc"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ant"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ar"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/asc"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/bhd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/bhdtv"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/bjs"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/bt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/btn"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/czt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/dc"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ff"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/fl"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/gpw"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/hdb"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/hds"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/hdt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/is"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/mtv"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/nbl"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/ptp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/pts"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/rtf"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/spd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/thr"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/tl"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/tvc"
 	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/a4k"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/acm"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/aither"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/blu"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/cbr"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/dp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/emuw"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/friki"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/hhd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ihd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/itt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/lcd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ldu"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/lst"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/lt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/lume"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/mns"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/oe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/otw"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/pt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ptt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/r4e"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ras"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/rf"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/rhd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/sam"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/shri"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/sp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/stc"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/tik"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/tlz"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/tos"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ttr"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ulcx"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/utp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/yus"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/znth"
 )
 
+// NewRegistry composes the complete built-in Unit3D, AZ-family, and standalone
+// manifest, then installs the metadata-source priority order. It returns an
+// error if any compiled definition violates registry invariants.
 func NewRegistry() (*trackers.Registry, error) {
 	registry := trackers.NewRegistry()
-	if err := unit3d.Register(registry, unit3d.DefaultTrackers()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(hdb.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(mtv.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(ant.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(ar.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(asc.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(bhd.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(bhdtv.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(bjs.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(btn.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(bt.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(czt.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(dc.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(ff.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(fl.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(gpw.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(hds.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(hdt.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(is.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(nbl.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(ptp.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(pts.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(rtf.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(spd.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(thr.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(tl.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	if err := registry.Register(tvc.New()); err != nil {
-		return nil, fmt.Errorf("trackers: %w", err)
-	}
-	for _, name := range []string{"AZ", "CZ", "PHD"} {
-		if err := registry.Register(azfamily.New(name)); err != nil {
+	for _, definition := range builtInDefinitions() {
+		if err := registry.Register(definition); err != nil {
 			return nil, fmt.Errorf("trackers: %w", err)
 		}
 	}
+	registry.SetPriorityOrder([]string{"aither", "ulcx", "lst", "blu", "oe", "btn", "bhd", "hdb", "ant", "rf", "otw", "yus", "dp", "sp", "ptp"})
 	return registry, nil
 }
+
+// MustNewRegistry returns the built-in tracker registry or panics when the
+// compiled manifest violates registry invariants.
+func MustNewRegistry() *trackers.Registry {
+	registry, err := NewRegistry()
+	if err != nil {
+		panic(fmt.Sprintf("trackers: invalid built-in registry: %v", err))
+	}
+	return registry
+}
+
+func unit3DDefinitions() []trackers.Definition {
+	profiles := []unit3d.Profile{
+		a4k.Profile(), acm.Profile(), aither.Profile(), blu.Profile(), cbr.Profile(), dp.Profile(), emuw.Profile(), friki.Profile(), hhd.Profile(),
+		ihd.Profile(), itt.Profile(), lcd.Profile(), ldu.Profile(), lst.Profile(), lt.Profile(), lume.Profile(), mns.Profile(), oe.Profile(), otw.Profile(),
+		pt.Profile(), ptt.Profile(), r4e.Profile(), ras.Profile(), rf.Profile(), rhd.Profile(), sam.Profile(), shri.Profile(), sp.Profile(), stc.Profile(),
+		tik.Profile(), tlz.Profile(), tos.Profile(), ttr.Profile(), ulcx.Profile(), utp.Profile(), yus.Profile(), znth.Profile(),
+	}
+	definitions := make([]trackers.Definition, 0, len(profiles))
+	for _, profile := range profiles {
+		definitions = append(definitions, unit3d.NewWithProfile(profile))
+	}
+	return definitions
+}
+
+func azFamilyDefinitions() []trackers.Definition {
+	return []trackers.Definition{azfamily.New("AZ"), azfamily.New("CZ"), azfamily.New("PHD")}
+}
+
+func standaloneDefinitions() []trackers.Definition {
+	return []trackers.Definition{
+		hdb.New(), mtv.New(), ant.New(), ar.New(), asc.New(), bhd.New(), bhdtv.New(), bjs.New(), btn.New(), bt.New(), czt.New(), dc.New(), ff.New(),
+		fl.New(), gpw.New(), hds.New(), hdt.New(), is.New(), nbl.New(), ptp.New(), pts.New(), rtf.New(), spd.New(), thr.New(), tl.New(), tvc.New(),
+	}
+}
+
+func builtInDefinitions() []trackers.Definition {
+	definitions := unit3DDefinitions()
+	definitions = append(definitions, azFamilyDefinitions()...)
+	definitions = append(definitions, standaloneDefinitions()...)
+	return definitions
+}
diff --git a/internal/trackers/impl/registry_test.go b/internal/trackers/impl/registry_test.go
index 8c3dab76..a051d6a8 100644
--- a/internal/trackers/impl/registry_test.go
+++ b/internal/trackers/impl/registry_test.go
@@ -3,7 +3,16 @@
 
 package impl
 
-import "testing"
+import (
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+)
 
 func TestNewRegistryIncludesHDB(t *testing.T) {
 	registry, err := NewRegistry()
@@ -92,3 +101,383 @@ func TestNewRegistryIncludesHDB(t *testing.T) {
 		t.Fatal("expected PHD definition to be registered")
 	}
 }
+
+func TestNewRegistryCapabilityInventory(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	names := registry.Names()
+	if !slices.IsSorted(names) {
+		t.Fatalf("registry names are not deterministic: %v", names)
+	}
+	schemas, err := config.OrderedTrackerSchemas()
+	if err != nil {
+		t.Fatalf("ordered tracker schemas: %v", err)
+	}
+	want := make([]string, 0, len(schemas))
+	for _, schema := range schemas {
+		want = append(want, schema.Name)
+	}
+	slices.Sort(want)
+	if !slices.Equal(names, want) {
+		t.Fatalf("registered trackers = %v, want %v", names, want)
+	}
+	if slices.Contains(names, "MANUAL") {
+		t.Fatal("MANUAL must not be registered")
+	}
+	specialModes := map[string]trackers.UploadContentMode{
+		"ANT": trackers.UploadContentModeScreenshots,
+		"BTN": trackers.UploadContentModeNone,
+		"NBL": trackers.UploadContentModeNone,
+		"RTF": trackers.UploadContentModeScreenshots,
+	}
+	for _, name := range names {
+		mode, ok := registry.LookupUploadContentMode(name)
+		if !ok || !mode.Valid() {
+			t.Fatalf("%s upload content mode = %q, %t", name, mode, ok)
+		}
+		want := trackers.UploadContentModeDescription
+		if special, exists := specialModes[name]; exists {
+			want = special
+		}
+		if mode != want {
+			t.Fatalf("%s upload content mode = %q, want %q", name, mode, want)
+		}
+	}
+	if definition, ok := registry.Lookup("BHDTV"); !ok {
+		t.Fatal("expected BHDTV definition")
+	} else if _, ok := definition.(dupe.Factory); !ok {
+		t.Fatal("expected BHDTV tracker-owned dupe capability")
+	}
+	if definition, ok := registry.Lookup("ANT"); !ok {
+		t.Fatal("expected ANT definition")
+	} else if _, ok := definition.(dupe.Factory); !ok {
+		t.Fatal("expected ANT tracker-owned dupe factory")
+	}
+	if _, ok := registry.LookupDataFactory("ANT"); !ok {
+		t.Fatal("expected ANT tracker-owned data factory")
+	}
+	if policy, ok := registry.LookupArtifactPolicy("ANT"); !ok || policy.MaxTorrentBytes != 250<<10 {
+		t.Fatalf("ANT artifact policy = %#v, %t", policy, ok)
+	}
+	if _, ok := registry.LookupRules("ANT"); !ok {
+		t.Fatal("expected ANT tracker-owned rules")
+	}
+	if groups, ok := registry.LookupBannedGroups("ANT"); !ok || !slices.Contains(groups, "ZMNT") {
+		t.Fatalf("ANT banned groups = %#v, %t", groups, ok)
+	}
+	if policy, ok := registry.LookupUploadArtifactPolicy("ANT"); !ok || policy.Source != "ANT" {
+		t.Fatalf("ANT upload artifact policy = %#v, %t", policy, ok)
+	}
+	if _, ok := registry.LookupMetadataPolicy("ANT"); !ok {
+		t.Fatal("expected ANT tracker-owned metadata policy")
+	}
+	if policy, ok := registry.LookupDupePolicy("ANT"); !ok || !policy.DolbyVisionImpliesHDR {
+		t.Fatalf("ANT dupe policy = %#v, %t", policy, ok)
+	}
+}
+
+func TestNewRegistryOwnsUploadArtifactPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	want := map[string]trackers.UploadArtifactPolicy{
+		"ACM":   {Source: "AsianCinema"},
+		"AR":    {Source: "AlphaRatio"},
+		"ASC":   {Source: "ASC"},
+		"AZ":    {Source: "AvistaZ", DefaultAnnounce: "https://tracker.avistaz.to/announce"},
+		"BHDTV": {Source: "BIT-HDTV", UseMyAnnounce: true},
+		"BJS":   {Source: "BJ"},
+		"BT":    {Source: "BT"},
+		"CZ":    {Source: "CinemaZ", DefaultAnnounce: "https://tracker.cinemaz.to/announce"},
+		"CZT":   {Source: "CzT"},
+		"DC":    {Source: "DigitalCore.club"},
+		"FF":    {Source: "FunFile"},
+		"FL":    {Source: "FL"},
+		"GPW":   {Source: "GreatPosterWall"},
+		"HDS":   {Source: "HD-Space"},
+		"HDT":   {Source: "hd-torrents.org"},
+		"IS":    {Source: "https://immortalseed.me"},
+		"MTV":   {Source: "MTV"},
+		"NBL":   {Source: "NBL"},
+		"PHD":   {Source: "PrivateHD", DefaultAnnounce: "https://tracker.privatehd.to/announce"},
+		"PTS":   {Source: "[www.ptskit.org] PTSKIT"},
+		"RTF":   {Source: "sunshine"},
+		"THR":   {Source: "[https://www.torrenthr.org] TorrentHR.org"},
+		"TL":    {Source: "TorrentLeech.org"},
+		"TOS":   {Source: "TheOldSchool"},
+		"TVC":   {Source: "TVCHAOS"},
+	}
+	for name, expected := range want {
+		got, ok := registry.LookupUploadArtifactPolicy(name)
+		if !ok || got != expected {
+			t.Errorf("%s upload artifact policy = %#v, %t; want %#v", name, got, ok, expected)
+		}
+	}
+}
+
+func TestNewRegistryOwnsMetadataPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	for _, name := range []string{"AR", "AZ", "BJS", "CZ", "CZT", "MTV", "NBL", "PHD", "PTP", "SPD", "THR", "TL", "TVC", "AITHER"} {
+		if _, ok := registry.LookupMetadataPolicy(name); !ok {
+			t.Errorf("expected %s tracker-owned metadata policy", name)
+		}
+	}
+
+	mtvPolicy, ok := registry.LookupMetadataPolicy("MTV")
+	if !ok || len(mtvPolicy.Requirements) != 1 {
+		t.Fatalf("MTV metadata policy = %#v, %t; want one requirement", mtvPolicy, ok)
+	}
+	mtvRequirement := mtvPolicy.Requirements[0]
+	wantFields := []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB, trackers.MetadataFieldTVDB}
+	if mtvRequirement.Scope != trackers.MetadataScopeAny || !slices.Equal(mtvRequirement.AnyOf, wantFields) {
+		t.Errorf("MTV metadata requirement = %#v; want any of %#v", mtvRequirement, wantFields)
+	}
+}
+
+func TestNewRegistryIncludesUnit3DRuleCapabilities(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+
+	trackersWithRules := []string{
+		"A4K", "AITHER", "BLU", "DP", "HHD", "LST", "LUME", "MNS", "OE", "OTW", "RAS",
+		"RF", "RHD", "SHRI", "SP", "STC", "TIK", "TOS", "TTR", "ULCX", "ZNTH",
+	}
+	for _, name := range trackersWithRules {
+		if _, ok := registry.LookupRules(name); !ok {
+			t.Errorf("expected %s tracker-owned rule capability", name)
+		}
+	}
+	if baseURL, ok := registry.LookupBaseURL("AITHER"); !ok || baseURL != "https://aither.cc" {
+		t.Fatalf("AITHER base URL = %q, %t", baseURL, ok)
+	}
+}
+
+func TestNewRegistryIncludesBHDPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if _, ok := registry.LookupRules("BHD"); !ok {
+		t.Fatal("expected BHD rules")
+	}
+	if _, ok := registry.LookupMetadataPolicy("BHD"); !ok {
+		t.Fatal("expected BHD metadata policy")
+	}
+	if policy, ok := registry.LookupUploadArtifactPolicy("BHD"); !ok || policy.Source != "BHD" {
+		t.Fatalf("BHD upload artifact policy = %#v, %t", policy, ok)
+	}
+	if policy, ok := registry.LookupAudioPolicy("BHD"); !ok || !policy.BlockEnglishOriginalWithForeign {
+		t.Fatalf("BHD audio policy = %#v, %t", policy, ok)
+	}
+	if groups, ok := registry.LookupBannedGroups("BHD"); !ok || !slices.Contains(groups, "TGS") {
+		t.Fatalf("BHD banned groups = %#v, %t", groups, ok)
+	}
+	if policy, ok := registry.LookupDupePolicy("BHD"); !ok || !policy.MatchAggregateSize || !policy.NormalizeDDPlusName {
+		t.Fatalf("BHD dupe policy = %#v, %t", policy, ok)
+	}
+	if definition, ok := registry.Lookup("BHD"); !ok {
+		t.Fatal("expected BHD definition")
+	} else if _, ok := definition.(dupe.Factory); !ok {
+		t.Fatal("expected BHD dupe factory")
+	}
+	if _, ok := registry.LookupDataFactory("BHD"); !ok {
+		t.Fatal("expected BHD data factory")
+	}
+}
+
+func TestNewRegistryIncludesBTNPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if _, ok := registry.LookupMetadataPolicy("BTN"); !ok {
+		t.Fatal("expected BTN metadata policy")
+	}
+	if policy, ok := registry.LookupUploadArtifactPolicy("BTN"); !ok || policy.Source != "BTN" || !policy.RequireAnnounce {
+		t.Fatalf("BTN upload artifact policy = %#v, %t", policy, ok)
+	}
+	if groups, ok := registry.LookupBannedGroups("BTN"); !ok || !slices.Contains(groups, "ZMNT") {
+		t.Fatalf("BTN banned groups = %#v, %t", groups, ok)
+	}
+	if definition, ok := registry.Lookup("BTN"); !ok {
+		t.Fatal("expected BTN definition")
+	} else if _, ok := definition.(dupe.Factory); !ok {
+		t.Fatal("expected BTN dupe factory")
+	}
+	if _, ok := registry.LookupDataFactory("BTN"); !ok {
+		t.Fatal("expected BTN data factory")
+	}
+	if _, ok := registry.LookupClaimCheckerFactory("BTN"); !ok {
+		t.Fatal("expected BTN claim checker factory")
+	}
+	btnConfig := config.Config{Metadata: config.MetadataConfig{BTNAPI: strings.Repeat("x", 25)}}
+	if ready, owned := registry.DataLookupConfigured("BTN", btnConfig); !owned || !ready {
+		t.Fatalf("BTN lookup readiness = %t, %t", ready, owned)
+	}
+}
+
+func TestNewRegistryIncludesHDBPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if _, ok := registry.LookupMetadataPolicy("HDB"); !ok {
+		t.Fatal("expected HDB metadata policy")
+	}
+	if policy, ok := registry.LookupUploadArtifactPolicy("HDB"); !ok || policy.Source != "HDBits" {
+		t.Fatalf("HDB upload artifact policy = %#v, %t", policy, ok)
+	}
+	if policy, ok := registry.LookupArtifactPolicy("HDB"); !ok || policy.MaxPieceSizeMiB != 16 {
+		t.Fatalf("HDB artifact policy = %#v, %t", policy, ok)
+	}
+	if _, ok := registry.LookupDataFactory("HDB"); !ok {
+		t.Fatal("expected HDB data factory")
+	}
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"HDB": {Username: "user", Passkey: "pass"}}}}
+	if ready, owned := registry.DataLookupConfigured("HDB", cfg); !owned || !ready {
+		t.Fatalf("HDB lookup readiness = %t, %t", ready, owned)
+	}
+}
+
+func TestNewRegistryIncludesPTPDataPolicy(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	policy, ok := registry.LookupDataPolicy("PTP")
+	if !ok || policy.Cooldown != time.Minute {
+		t.Fatalf("PTP data policy = %#v, %t", policy, ok)
+	}
+}
+
+func TestNewRegistryIncludesImageHostPolicies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	tests := []struct {
+		tracker              string
+		host                 string
+		conditionalHost      string
+		disableWithoutRehost bool
+		disableWithoutAPI    bool
+	}{
+		{tracker: "A4K", host: "onlyimage"},
+		{tracker: "BHD", host: "bhd"},
+		{
+			tracker:              "HDB",
+			host:                 "hdb",
+			disableWithoutRehost: true,
+		},
+		{tracker: "PTP", host: "passtheimage"},
+		{
+			tracker:           "THR",
+			host:              "thr",
+			disableWithoutAPI: true,
+		},
+		{tracker: "LST", conditionalHost: "lostimg"},
+		{tracker: "RF", conditionalHost: "reelflix"},
+	}
+	for _, test := range tests {
+		policy, ok := registry.LookupImageHostPolicy(test.tracker)
+		if !ok || (test.host != "" && !slices.Contains(policy.AllowedHosts, test.host)) {
+			t.Errorf("%s image policy = %#v, %t", test.tracker, policy, ok)
+			continue
+		}
+		if policy.DisableWithoutRehost != test.disableWithoutRehost || policy.DisableWithoutAPI != test.disableWithoutAPI {
+			t.Errorf("%s image policy flags = %#v", test.tracker, policy)
+		}
+		if policy.ConditionalHost != test.conditionalHost {
+			t.Errorf("%s conditional image host = %q", test.tracker, policy.ConditionalHost)
+		}
+	}
+}
+
+func TestNewRegistryIncludesAuthResolvers(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	for _, tracker := range []string{"BTN", "FF", "FL", "HDB", "MTV", "PTP", "RTF"} {
+		if _, ok := registry.LookupAuthSessionResolver(tracker); !ok {
+			t.Errorf("expected %s tracker-owned auth resolver", tracker)
+		}
+		capability, ok := registry.LookupAuthCapability(tracker)
+		if !ok || capability.TrackerID != tracker {
+			t.Errorf("%s auth capability = %#v, %t", tracker, capability, ok)
+		}
+		if tracker != "HDB" && !capability.SupportsLogin {
+			t.Errorf("expected %s login capability", tracker)
+		}
+	}
+}
+
+func TestNewRegistryIncludesAuthCapabilities(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	trackersWithAuth := []string{"AR", "ASC", "AZ", "BJS", "BT", "BTN", "CZ", "FF", "FL", "HDB", "HDS", "HDT", "IS", "MTV", "PHD", "PTP", "PTS", "RTF", "THR", "TL"}
+	for _, tracker := range trackersWithAuth {
+		capability, ok := registry.LookupAuthCapability(tracker)
+		if !ok || capability.TrackerID != tracker {
+			t.Errorf("%s auth capability = %#v, %t", tracker, capability, ok)
+		}
+	}
+}
+
+func TestNewRegistryClassifiesTrackerFamilies(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if family, ok := registry.LookupFamily("AITHER"); !ok || family != trackers.FamilyUnit3D {
+		t.Fatalf("AITHER family = %q, %t", family, ok)
+	}
+	if family, ok := registry.LookupFamily("AZ"); !ok || family != trackers.FamilyAZFamily {
+		t.Fatalf("AZ family = %q, %t", family, ok)
+	}
+	if family, ok := registry.LookupFamily("PTP"); !ok || family != trackers.FamilyStandalone {
+		t.Fatalf("PTP family = %q, %t", family, ok)
+	}
+	if !slices.Contains(registry.NamesByFamily(trackers.FamilyUnit3D), "AITHER") {
+		t.Fatal("expected AITHER in Unit3D registry names")
+	}
+}
+
+func TestNewRegistryDeclaresLocalizedMetadataConsumers(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if !registry.NeedsLocalizedMetadata([]string{"ASC", "BJS", "BT"}, "pt-BR") {
+		t.Fatal("expected pt-BR localized metadata consumers")
+	}
+	if registry.NeedsLocalizedMetadata([]string{"PTP"}, "pt-BR") {
+		t.Fatal("did not expect PTP to consume pt-BR metadata")
+	}
+}
+
+func TestNewRegistryDeclaresDescriptionGroups(t *testing.T) {
+	registry, err := NewRegistry()
+	if err != nil {
+		t.Fatalf("new registry: %v", err)
+	}
+	if got := trackers.DescriptionOverrideGroupForTrackerWithRegistry("ACM", registry); got != "acm" {
+		t.Fatalf("ACM description group = %q", got)
+	}
+	if got := trackers.DescriptionOverrideGroupForTrackerWithRegistry("AITHER", registry); got != "unit3d" {
+		t.Fatalf("AITHER description group = %q", got)
+	}
+	if policy, ok := registry.LookupClaimPolicy("AITHER"); !ok || !policy.APIBacked {
+		t.Fatalf("AITHER claim policy = %#v, %t", policy, ok)
+	}
+}
diff --git a/internal/trackers/impl/rtf/definition.go b/internal/trackers/impl/rtf/definition.go
deleted file mode 100644
index d6f5602d..00000000
--- a/internal/trackers/impl/rtf/definition.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package rtf
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "RTF" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	var (
-		err    error
-		assets trackers.DescriptionAssets
-	)
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	description := buildDescription(assets)
-	return trackers.DescriptionResult{Group: "rtf", Description: description}, nil
-}
diff --git a/internal/trackers/impl/rtf/upload.go b/internal/trackers/impl/rtf/upload.go
deleted file mode 100644
index de704e54..00000000
--- a/internal/trackers/impl/rtf/upload.go
+++ /dev/null
@@ -1,482 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package rtf
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	defaultBaseURL = "https://retroflix.club"
-	sourceFlag     = "sunshine"
-)
-
-var newHTTPClient = func() *http.Client { return &http.Client{Timeout: 40 * time.Second} }
-
-type uploadResponse struct {
-	Error   bool   `json:"error"`
-	Message string `json:"message"`
-	Torrent struct {
-		ID any `json:"id"`
-	} `json:"torrent"`
-}
-
-type uploadState struct {
-	torrentPath   string
-	releaseName   string
-	description   string
-	payload       map[string]any
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	baseURL := resolveBaseURL(req.TrackerConfig)
-	uploadURL, err := joinURL(baseURL, "/api/upload")
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: RTF %s", state.blockedReason)
-	}
-
-	apiKey, err := resolveAPIKey(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-
-	body, err := json.Marshal(state.payload)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: RTF marshal upload payload: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, strings.NewReader(string(body)))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: RTF create upload request: %w", err)
-	}
-	httpReq.Header.Set("Accept", "application/json")
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", apiKey)
-
-	resp, err := newHTTPClient().Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: RTF upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, _ := io.ReadAll(resp.Body)
-
-	var decoded uploadResponse
-	_ = json.Unmarshal(responseBody, &decoded)
-	if resp.StatusCode == http.StatusCreated && !decoded.Error {
-		id := strings.TrimSpace(fmt.Sprint(decoded.Torrent.ID))
-		if id == "" {
-			return api.UploadSummary{}, errors.New("trackers: RTF upload succeeded but torrent id missing")
-		}
-		torrentURL, err := joinURL(baseURL, "/browse/t/")
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		downloadURL, err := joinURL(baseURL, "/api/torrent/")
-		if err != nil {
-			return api.UploadSummary{}, err
-		}
-		tURL := torrentURL + id
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "RTF")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, tURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "RTF",
-				TorrentID:   id,
-				TorrentURL:  tURL,
-				DownloadURL: downloadURL + id + "/download",
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "RTF", "upload_failure", responseBody, ".json")
-	return api.UploadSummary{}, fmt.Errorf("trackers: RTF %s", metautil.FirstNonEmptyTrimmed(commonhttp.ExtractHTTPErrorDetail(responseBody), commonhttp.RedactErrorDetail(decoded.Message), fmt.Sprintf("upload failed with status %d", resp.StatusCode)))
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	payload := make(map[string]string, len(state.payload))
-	for key, value := range state.payload {
-		payload[key] = strings.TrimSpace(fmt.Sprint(value))
-	}
-	endpoint, err := joinURL(resolveBaseURL(req.TrackerConfig), "/api/upload")
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "RTF",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "rtf",
-		Description:      state.description,
-		Endpoint:         endpoint,
-		Payload:          payload,
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" && (strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "") {
-		return uploadState{}, errors.New("trackers: RTF missing api_key or username/password")
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	var assets trackers.DescriptionAssets
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-		if err != nil {
-			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	description := buildDescription(assets)
-	torrentBytes, err := os.ReadFile(torrentPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: RTF read torrent file: %w", err)
-	}
-	releaseName := metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename)
-	payload := map[string]any{
-		"name":        releaseName,
-		"description": description,
-		"mediaInfo":   commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
-		"nfo":         "",
-		"url":         imdbURL(req.Meta),
-		"descr":       description,
-		"poster":      resolvePoster(req.Meta),
-		"type":        resolveType(req.Meta),
-		"screenshots": screenshots(assets.Screenshots),
-		"isAnonymous": req.TrackerConfig.Anon,
-		"file":        base64.StdEncoding.EncodeToString(torrentBytes),
-	}
-	return uploadState{
-		torrentPath:   torrentPath,
-		releaseName:   releaseName,
-		description:   description,
-		payload:       payload,
-		blockedReason: validateEligibility(req.Meta),
-	}, nil
-}
-
-// resolveAPIKey validates configured RTF API auth and persists a refreshed token when credentials are used.
-// Callers must complete no-upload eligibility gates before invoking it.
-func resolveAPIKey(ctx context.Context, req trackers.UploadRequest) (string, error) {
-	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
-	baseURL := resolveBaseURL(req.TrackerConfig)
-	if apiKey != "" {
-		valid, err := testAPIKey(ctx, baseURL, apiKey)
-		if err == nil && valid {
-			return apiKey, nil
-		}
-		if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
-			if err != nil {
-				return "", fmt.Errorf("trackers: RTF API key validation failed and username/password not configured: %w", err)
-			}
-			return "", errors.New("trackers: RTF API key invalid and username/password not configured")
-		}
-	}
-	if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
-		return "", errors.New("trackers: RTF missing api_key or username/password")
-	}
-	refreshed, err := refreshAPIKey(ctx, baseURL, req.TrackerConfig)
-	if err != nil {
-		return "", err
-	}
-	if err := persistRefreshedAPIKey(ctx, req.AppConfig.MainSettings.DBPath, refreshed); err != nil && req.Logger != nil {
-		req.Logger.Warnf("trackers: RTF failed to persist refreshed API key: %v", err)
-	}
-	return refreshed, nil
-}
-
-// ResolveSessionForTrackerAuthLogin validates RTF API auth or refreshes and
-// persists the API key with configured credentials for tracker-auth checks.
-func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
-	apiKey := strings.TrimSpace(cfg.APIKey)
-	baseURL := resolveBaseURL(cfg)
-	if apiKey != "" {
-		valid, err := testAPIKey(ctx, baseURL, apiKey)
-		if err == nil && valid {
-			return nil
-		}
-		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-			if err != nil {
-				return fmt.Errorf("trackers: RTF API key validation failed and username/password not configured: %w", err)
-			}
-			return errors.New("trackers: RTF API key invalid and username/password not configured")
-		}
-	}
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return errors.New("trackers: RTF missing api_key or username/password")
-	}
-	refreshed, err := refreshAPIKey(ctx, baseURL, cfg)
-	if err != nil {
-		return err
-	}
-	if err := persistRefreshedAPIKey(ctx, dbPath, refreshed); err != nil {
-		return err
-	}
-	return nil
-}
-
-func testAPIKey(ctx context.Context, baseURL string, apiKey string) (bool, error) {
-	testURL, err := joinURL(baseURL, "/api/test")
-	if err != nil {
-		return false, err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, testURL, nil)
-	if err != nil {
-		return false, fmt.Errorf("trackers: RTF create API test request: %w", err)
-	}
-	httpReq.Header.Set("Accept", "application/json")
-	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
-	resp, err := newHTTPClient().Do(httpReq)
-	if err != nil {
-		return false, fmt.Errorf("trackers: RTF API test request: %w", err)
-	}
-	defer resp.Body.Close()
-	return resp.StatusCode == http.StatusOK, nil
-}
-
-func refreshAPIKey(ctx context.Context, baseURL string, cfg config.TrackerConfig) (string, error) {
-	payload := map[string]string{
-		"username": strings.TrimSpace(cfg.Username),
-		"password": strings.TrimSpace(cfg.Password),
-	}
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("trackers: RTF marshal API login payload: %w", err)
-	}
-	loginURL, err := joinURL(baseURL, "/api/login")
-	if err != nil {
-		return "", err
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(string(body)))
-	if err != nil {
-		return "", fmt.Errorf("trackers: RTF create API login request: %w", err)
-	}
-	httpReq.Header.Set("Accept", "application/json")
-	httpReq.Header.Set("Content-Type", "application/json")
-	resp, err := newHTTPClient().Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("trackers: RTF API login request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, _ := io.ReadAll(resp.Body)
-	if resp.StatusCode != http.StatusCreated {
-		return "", fmt.Errorf("trackers: RTF API login failed status=%d", resp.StatusCode)
-	}
-	var decoded struct {
-		Token string `json:"token"`
-	}
-	if err := json.Unmarshal(responseBody, &decoded); err != nil {
-		return "", fmt.Errorf("trackers: RTF decode API login response: %w", err)
-	}
-	token := strings.TrimSpace(decoded.Token)
-	if token == "" {
-		return "", errors.New("trackers: RTF API login response missing token")
-	}
-	return token, nil
-}
-
-func persistRefreshedAPIKey(ctx context.Context, dbPath string, token string) error {
-	dbPath = strings.TrimSpace(dbPath)
-	if dbPath == "" {
-		return errors.New("trackers: RTF persist refreshed API key: db path not configured")
-	}
-	repo, err := servicedb.OpenContext(ctx, dbPath)
-	if err != nil {
-		return fmt.Errorf("trackers: RTF persist refreshed API key open db: %w", err)
-	}
-	defer repo.Close()
-	cfg, err := config.LoadFromDatabase(ctx, repo)
-	if err != nil {
-		return fmt.Errorf("trackers: RTF persist refreshed API key load config: %w", err)
-	}
-	if cfg.Trackers.Trackers == nil {
-		cfg.Trackers.Trackers = map[string]config.TrackerConfig{}
-	}
-	trackerKey := "RTF"
-	for key := range cfg.Trackers.Trackers {
-		if strings.EqualFold(strings.TrimSpace(key), "RTF") {
-			trackerKey = key
-			break
-		}
-	}
-	trackerCfg := cfg.Trackers.Trackers[trackerKey]
-	trackerCfg.APIKey = strings.TrimSpace(token)
-	cfg.Trackers.Trackers[trackerKey] = trackerCfg
-	if err := config.SaveToDatabase(ctx, cfg, repo); err != nil {
-		return fmt.Errorf("trackers: RTF persist refreshed API key: %w", err)
-	}
-	return nil
-}
-
-func resolveBaseURL(cfg config.TrackerConfig) string {
-	if value := strings.TrimRight(strings.TrimSpace(cfg.URL), "/"); value != "" {
-		return value
-	}
-	return defaultBaseURL
-}
-
-// joinURL resolves path against baseURL and rejects malformed configured URLs instead of falling back to the default tracker host.
-func joinURL(baseURL string, path string) (string, error) {
-	parsed, err := url.Parse(strings.TrimRight(baseURL, "/") + "/")
-	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
-		return "", fmt.Errorf("trackers: RTF invalid base URL %q", baseURL)
-	}
-	ref, err := url.Parse(strings.TrimLeft(path, "/"))
-	if err != nil {
-		return "", fmt.Errorf("trackers: RTF invalid URL path %q: %w", path, err)
-	}
-	return parsed.ResolveReference(ref).String(), nil
-}
-
-func buildDescription(assets trackers.DescriptionAssets) string {
-	return strings.TrimSpace(assets.Description)
-}
-
-func validateEligibility(meta api.PreparedMetadata) string {
-	genres := strings.ToLower(genresText(meta) + "," + keywordsText(meta))
-	for _, value := range []string{"xxx", "erotic", "porn", "adult", "orgy"} {
-		if strings.Contains(genres, value) {
-			return "adult content is not allowed"
-		}
-	}
-	limit := time.Now().UTC().AddDate(-10, 0, 3)
-	if t := releaseDate(meta); !t.IsZero() {
-		if t.After(limit) {
-			return "content must be at least 10 years old"
-		}
-		return ""
-	}
-	if year := resolveYear(meta); year > limit.Year() {
-		return "content must be at least 10 years old"
-	}
-	return ""
-}
-
-func releaseDate(meta api.PreparedMetadata) time.Time {
-	if meta.ExternalMetadata.TMDB == nil {
-		return time.Time{}
-	}
-	for _, value := range []string{
-		strings.TrimSpace(meta.ExternalMetadata.TMDB.ReleaseDate),
-		strings.TrimSpace(meta.ExternalMetadata.TMDB.LastAirDate),
-		strings.TrimSpace(meta.ExternalMetadata.TMDB.FirstAirDate),
-	} {
-		if value == "" {
-			continue
-		}
-		if t, err := time.Parse("2006-01-02", value); err == nil {
-			return t
-		}
-	}
-	return time.Time{}
-}
-
-func resolveYear(meta api.PreparedMetadata) int {
-	if meta.Release.Year > 0 {
-		return meta.Release.Year
-	}
-	if meta.ExternalMetadata.TMDB == nil {
-		return 0
-	}
-	return meta.ExternalMetadata.TMDB.Year
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	if !isTV(meta) {
-		return "401"
-	}
-	return "402"
-}
-
-func screenshots(images []api.ScreenshotImage) []string {
-	out := make([]string, 0, len(images))
-	for _, image := range images {
-		if raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL)); raw != "" {
-			out = append(out, raw)
-		}
-	}
-	return out
-}
-
-func imdbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.ExternalIDs.IMDBID)
-}
-
-func resolvePoster(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return ""
-	}
-	return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Poster)
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
-
-func genresText(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Genres, meta.Release.Genre)
-	}
-	return metautil.FirstNonEmptyTrimmed(meta.Release.Genre)
-}
-
-func keywordsText(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return ""
-	}
-	return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-}
diff --git a/internal/trackers/impl/rtf/upload_test.go b/internal/trackers/impl/rtf/upload_test.go
deleted file mode 100644
index aa95bafc..00000000
--- a/internal/trackers/impl/rtf/upload_test.go
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package rtf
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	servicedb "github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildUploadDryRunUsesDescriptionPayloadAndLeavesNFOEmpty(t *testing.T) {
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	entry, err := buildUploadDryRun(context.Background(), trackers.UploadRequest{
-		Tracker: "RTF",
-		Meta: api.PreparedMetadata{
-			TorrentPath:         torrentPath,
-			DescriptionOverride: "Custom description",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if entry.Payload["description"] != "Custom description" {
-		t.Fatalf("expected description payload, got %#v", entry.Payload)
-	}
-	if entry.Payload["descr"] != "Custom description" {
-		t.Fatalf("expected descr payload mirror, got %#v", entry.Payload)
-	}
-	if entry.Payload["nfo"] != "" {
-		t.Fatalf("expected empty nfo payload, got %#v", entry.Payload["nfo"])
-	}
-}
-
-func TestUploadRefreshesExpiredAPIKeyAndPersistsIt(t *testing.T) {
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	dbPath := filepath.Join(root, "upbrr.db")
-	seedRTFConfig(t, dbPath, config.TrackerConfig{APIKey: "old-token", Username: "user", Password: "pass"})
-
-	var testedToken string
-	var loginCalled bool
-	var uploadToken string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/test":
-			testedToken = r.Header.Get("Authorization")
-			w.WriteHeader(http.StatusUnauthorized)
-		case "/api/login":
-			loginCalled = true
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"token":"new-token"}`))
-		case "/api/upload":
-			uploadToken = r.Header.Get("Authorization")
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	summary, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker: "RTF",
-		Meta: api.PreparedMetadata{
-			TorrentPath: torrentPath,
-			ReleaseName: "Release",
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
-			APIKey:   "old-token",
-			Username: "user",
-			Password: "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-	})
-	if err != nil {
-		t.Fatalf("upload: %v", err)
-	}
-	if summary.Uploaded != 1 {
-		t.Fatalf("expected upload success, got %#v", summary)
-	}
-	if testedToken != "old-token" {
-		t.Fatal("expected old token to be tested")
-	}
-	if !loginCalled {
-		t.Fatal("expected expired token to trigger API login")
-	}
-	if uploadToken != "new-token" {
-		t.Fatal("expected upload to use refreshed token")
-	}
-	if got := loadStoredRTFAPIKey(t, dbPath); got != "new-token" {
-		t.Fatal("expected refreshed token persisted")
-	}
-}
-
-func TestUploadBlockedExpiredAPIKeyDoesNotRefreshOrPersist(t *testing.T) {
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	dbPath := filepath.Join(root, "upbrr.db")
-	seedRTFConfig(t, dbPath, config.TrackerConfig{APIKey: "old-token", Username: "user", Password: "pass"})
-
-	requests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requests++
-		http.NotFound(w, r)
-	}))
-	t.Cleanup(server.Close)
-
-	_, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker: "RTF",
-		Meta: api.PreparedMetadata{
-			TorrentPath: torrentPath,
-			ReleaseName: "Recent Release",
-			Release:     api.ReleaseInfo{Year: 9999},
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
-			APIKey:   "old-token",
-			Username: "user",
-			Password: "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-	})
-	if err == nil {
-		t.Fatal("expected blocked upload error")
-	}
-	if !strings.Contains(err.Error(), "content must be at least 10 years old") {
-		t.Fatalf("expected eligibility error, got %v", err)
-	}
-	if requests != 0 {
-		t.Fatalf("blocked upload must not call RTF auth or upload endpoints, got %d requests", requests)
-	}
-	if got := loadStoredRTFAPIKey(t, dbPath); got != "old-token" {
-		t.Fatal("blocked upload must leave stored token unchanged")
-	}
-}
-
-func TestUploadUsesValidAPIKeyWithoutRefresh(t *testing.T) {
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	var loginCalled bool
-	var uploadToken string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/test":
-			w.WriteHeader(http.StatusOK)
-		case "/api/login":
-			loginCalled = true
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"token":"new-token"}`))
-		case "/api/upload":
-			uploadToken = r.Header.Get("Authorization")
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	if _, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker: "RTF",
-		Meta: api.PreparedMetadata{
-			TorrentPath: torrentPath,
-			ReleaseName: "Release",
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:    server.URL,
-			APIKey: "valid-token",
-		},
-	}); err != nil {
-		t.Fatalf("upload: %v", err)
-	}
-	if loginCalled {
-		t.Fatal("valid token should not trigger API login")
-	}
-	if uploadToken != "valid-token" {
-		t.Fatal("expected upload to use original token")
-	}
-}
-
-func TestUploadGeneratesMissingAPIKeyFromCredentials(t *testing.T) {
-	root := t.TempDir()
-	torrentPath := filepath.Join(root, "test.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-	dbPath := filepath.Join(root, "upbrr.db")
-	seedRTFConfig(t, dbPath, config.TrackerConfig{Username: "user", Password: "pass"})
-
-	var testCalled bool
-	var uploadToken string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/test":
-			testCalled = true
-			w.WriteHeader(http.StatusOK)
-		case "/api/login":
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"token":"generated-token"}`))
-		case "/api/upload":
-			uploadToken = r.Header.Get("Authorization")
-			w.WriteHeader(http.StatusCreated)
-			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	if _, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker: "RTF",
-		Meta: api.PreparedMetadata{
-			TorrentPath: torrentPath,
-			ReleaseName: "Release",
-		},
-		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
-			Username: "user",
-			Password: "pass",
-		},
-		AppConfig: config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}},
-	}); err != nil {
-		t.Fatalf("upload: %v", err)
-	}
-	if testCalled {
-		t.Fatal("missing token should refresh directly without API test")
-	}
-	if uploadToken != "generated-token" {
-		t.Fatal("expected upload to use generated token")
-	}
-	if got := loadStoredRTFAPIKey(t, dbPath); got != "generated-token" {
-		t.Fatal("expected generated token persisted")
-	}
-}
-
-func TestUploadRejectsMalformedBaseURL(t *testing.T) {
-	_, err := upload(context.Background(), trackers.UploadRequest{
-		Tracker:       "RTF",
-		TrackerConfig: config.TrackerConfig{URL: "not a url", APIKey: "token"},
-	})
-	if err == nil {
-		t.Fatal("expected malformed base URL error")
-	}
-	if !strings.Contains(err.Error(), "invalid base URL") {
-		t.Fatalf("expected invalid base URL error, got %v", err)
-	}
-}
-
-func seedRTFConfig(t *testing.T, dbPath string, trackerCfg config.TrackerConfig) {
-	t.Helper()
-
-	repo, err := servicedb.OpenContext(context.Background(), dbPath)
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	defer repo.Close()
-	if err := repo.MigrateContext(context.Background()); err != nil {
-		t.Fatalf("MigrateContext: %v", err)
-	}
-	cfg := config.Config{
-		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
-		Trackers: config.TrackersConfig{
-			Trackers: map[string]config.TrackerConfig{"RTF": trackerCfg},
-		},
-	}
-	if err := config.SaveToDatabase(context.Background(), &cfg, repo); err != nil {
-		t.Fatalf("SaveToDatabase: %v", err)
-	}
-}
-
-func loadStoredRTFAPIKey(t *testing.T, dbPath string) string {
-	t.Helper()
-
-	repo, err := servicedb.OpenContext(context.Background(), dbPath)
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	defer repo.Close()
-	cfg, err := config.LoadFromDatabase(context.Background(), repo)
-	if err != nil {
-		t.Fatalf("LoadFromDatabase: %v", err)
-	}
-	return cfg.Trackers.Trackers["RTF"].APIKey
-}
diff --git a/internal/trackers/impl/spd/definition.go b/internal/trackers/impl/spd/definition.go
deleted file mode 100644
index d88e785a..00000000
--- a/internal/trackers/impl/spd/definition.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package spd
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "SPD" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "spd", Description: description}, nil
-}
diff --git a/internal/trackers/impl/spd/upload.go b/internal/trackers/impl/spd/upload.go
deleted file mode 100644
index 9ccd18ea..00000000
--- a/internal/trackers/impl/spd/upload.go
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package spd
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL   = "https://speedapp.io"
-	uploadURL = baseURL + "/api/upload"
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	payload       map[string]any
-	questionnaire *api.TrackerQuestionnaire
-	blockedReason string
-}
-
-type uploadResponse struct {
-	Status      bool   `json:"status"`
-	Error       bool   `json:"error"`
-	DownloadURL string `json:"downloadUrl"`
-	Torrent     struct {
-		ID any `json:"id"`
-	} `json:"torrent"`
-}
-
-type channelResult struct {
-	ID  any    `json:"id"`
-	Tag string `json:"tag"`
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD %s", state.blockedReason)
-	}
-
-	body, err := json.Marshal(state.payload)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD marshal upload payload: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, strings.NewReader(string(body)))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD build upload request: %w", err)
-	}
-	httpReq.Header.Set("Accept", "application/json")
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", strings.TrimSpace(req.TrackerConfig.APIKey))
-
-	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD read upload response: %w", err)
-	}
-
-	var decoded uploadResponse
-	if err := json.Unmarshal(responseBody, &decoded); err != nil {
-		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "SPD", "upload_failure", responsePreview, ".txt")
-		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-			return api.UploadSummary{}, commonhttp.UploadHTTPError("SPD", resp.StatusCode, responsePreview)
-		}
-		return api.UploadSummary{}, fmt.Errorf("trackers: SPD decode response: %w", err)
-	}
-	if resp.StatusCode == http.StatusOK && decoded.Status && !decoded.Error {
-		torrentID := strings.TrimSpace(fmt.Sprint(decoded.Torrent.ID))
-		artifactPath := ""
-		if torrentID != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "SPD")
-			if err == nil {
-				if dlErr := downloadTrackerTorrent(ctx, baseURL+"/api/torrent/"+torrentID+"/download", req.TrackerConfig.APIKey, artifactPath); dlErr != nil {
-					artifactPath = ""
-				}
-			}
-		}
-		return api.UploadSummary{
-			Uploaded: 1,
-			UploadedTorrents: []api.UploadedTorrent{{
-				Tracker:     "SPD",
-				TorrentID:   torrentID,
-				TorrentURL:  baseURL + "/browse/" + torrentID,
-				DownloadURL: baseURL + "/api/torrent/" + torrentID + "/download",
-				TorrentPath: artifactPath,
-			}},
-		}, nil
-	}
-
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "SPD", "upload_failure", responsePreview, ".json")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("SPD", resp.StatusCode, responsePreview)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	payload := make(map[string]string, len(state.payload))
-	for key, value := range state.payload {
-		payload[key] = strings.TrimSpace(fmt.Sprint(value))
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "SPD",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "spd",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          payload,
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "file", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: SPD missing api_key")
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-	channelID, blockedReason, questionnaire := resolveChannel(ctx, req)
-	torrentBytes, err := os.ReadFile(torrentPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: SPD read torrent file: %w", err)
-	}
-	releaseName := normalizeName(metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename))
-	payload := map[string]any{
-		"bdInfo":           trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, req.Meta),
-		"coverPhotoUrl":    metautil.FirstNonEmptyTrimmed(req.Meta.ExternalMetadata.TMDB.Backdrop, req.Meta.ExternalMetadata.TMDB.Poster),
-		"description":      genresText(req.Meta),
-		"media_info":       commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
-		"name":             releaseName,
-		"nfo":              "",
-		"plot":             metautil.FirstNonEmptyTrimmed(req.Meta.EpisodeOverview, req.Meta.ExternalMetadata.TMDB.Overview),
-		"poster":           metautil.FirstNonEmptyTrimmed(req.Meta.ExternalMetadata.TMDB.Poster),
-		"technicalDetails": description,
-		"screenshots":      combineUniqueScreenshots(assets.MenuImages, assets.Screenshots),
-		"type":             resolveCategory(req.Meta),
-		"url":              imdbURL(req.Meta),
-		"channel":          channelID,
-		"file":             base64.StdEncoding.EncodeToString(torrentBytes),
-	}
-	return uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   releaseName,
-		payload:       payload,
-		questionnaire: questionnaire,
-		blockedReason: blockedReason,
-	}, nil
-}
-
-func resolveChannel(ctx context.Context, req trackers.UploadRequest) (string, string, *api.TrackerQuestionnaire) {
-	answers := questionnaireAnswers(req.Meta)
-	input := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["channel"]), strings.TrimSpace(req.TrackerConfig.Channel))
-	if input == "" {
-		return "1", "", nil
-	}
-	if digitsOnly(input) {
-		return input, "", nil
-	}
-	id, err := lookupChannelID(ctx, req.TrackerConfig.APIKey, input)
-	if err == nil && id != "" {
-		return id, "", nil
-	}
-	return "", "answer the channel questionnaire with a valid channel id or tag", &api.TrackerQuestionnaire{
-		Tracker: "SPD",
-		Fields: []api.TrackerQuestionnaireField{{
-			Key: "channel", Label: "Channel", Kind: "text", Value: input, Placeholder: "1 or channel tag", Required: true,
-		}},
-	}
-}
-
-func lookupChannelID(ctx context.Context, apiKey string, input string) (string, error) {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/api/channel?search="+url.QueryEscape(input), nil)
-	if err != nil {
-		return "", fmt.Errorf("trackers: SPD build channel lookup request: %w", err)
-	}
-	httpReq.Header.Set("Accept", "application/json")
-	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
-	resp, err := (&http.Client{Timeout: 15 * time.Second}).Do(httpReq)
-	if err != nil {
-		return "", fmt.Errorf("trackers: SPD channel lookup request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	var decoded []channelResult
-	if err := json.Unmarshal(body, &decoded); err != nil {
-		return "", fmt.Errorf("trackers: SPD unmarshal channel lookup response: %w", err)
-	}
-	for _, item := range decoded {
-		if strings.EqualFold(strings.TrimSpace(item.Tag), strings.TrimSpace(input)) {
-			return strings.TrimSpace(fmt.Sprint(item.ID)), nil
-		}
-	}
-	return "", errors.New("channel not found")
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	meta := req.Meta
-	var parts []string
-
-	// Avoid unnecessary descriptions
-	if strings.TrimSpace(assets.Description) != "" || strings.TrimSpace(meta.EpisodeOverview) != "" {
-		// Custom Header
-		if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-			parts = append(parts, header)
-		}
-
-		// Logo
-		if logo, logoSize := descriptionunit3d.ResolveLogo(meta, req.AppConfig); logo != "" {
-			parts = append(parts, fmt.Sprintf("[center][img=%d]https://image.tmdb.org/t/p/w300/%s[/img][/center]", logoSize, logo))
-		}
-
-		// TV Details
-		if strings.TrimSpace(meta.EpisodeOverview) != "" {
-			parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
-			parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
-		}
-
-		// User Description
-		if strings.TrimSpace(assets.Description) != "" {
-			parts = append(parts, strings.TrimSpace(assets.Description))
-		}
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// custom user signature
-	if signature := strings.TrimSpace(req.AppConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	// Signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("[url=%s]%s[/url]", link, text))
-
-	// Join and finalize
-	description := strings.Join(parts, "\n\n")
-	finalized := bbcode.FinalizeTrackerDescription("SPD", description)
-
-	// Debug saving
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "SPD", req.AppConfig.MainSettings.DBPath, finalized, req.Logger)
-	}
-
-	return finalized
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	romanian := hasRomanian(meta)
-	if containsWord(genresText(meta), "documentary") || containsWord(keywordsText(meta), "documentary") {
-		if romanian {
-			return "63"
-		}
-		return "9"
-	}
-	if meta.Anime {
-		return "3"
-	}
-	if isTV(meta) {
-		if meta.TVPack {
-			if romanian {
-				return "66"
-			}
-			return "41"
-		}
-		if isSD(meta.Release.Resolution) {
-			if romanian {
-				return "46"
-			}
-			return "45"
-		}
-		if romanian {
-			return "44"
-		}
-		return "43"
-	}
-	if meta.Release.Resolution == "2160p" && !strings.EqualFold(meta.Type, "DISC") {
-		if romanian {
-			return "57"
-		}
-		return "61"
-	}
-	if strings.EqualFold(meta.Type, "DISC") {
-		if romanian {
-			return "24"
-		}
-		return "17"
-	}
-	if romanian {
-		return "29"
-	}
-	return "8"
-}
-
-func hasRomanian(meta api.PreparedMetadata) bool {
-	for _, value := range append([]string{}, append(meta.AudioLanguages, meta.SubtitleLanguages...)...) {
-		if strings.EqualFold(strings.TrimSpace(value), "romanian") {
-			return true
-		}
-	}
-	for _, code := range meta.ExternalMetadata.TMDB.OriginCountry {
-		if strings.EqualFold(strings.TrimSpace(code), "RO") {
-			return true
-		}
-	}
-	return false
-}
-
-func combineUniqueScreenshots(menu []api.ScreenshotImage, normal []api.ScreenshotImage) []string {
-	var out []string
-	seen := make(map[string]struct{})
-
-	for _, image := range menu {
-		u := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
-		if u != "" && !isSeen(seen, u) {
-			out = append(out, u)
-			seen[u] = struct{}{}
-		}
-	}
-	for _, image := range normal {
-		u := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
-		if u != "" && !isSeen(seen, u) {
-			out = append(out, u)
-			seen[u] = struct{}{}
-		}
-	}
-	return out
-}
-
-func isSeen(seen map[string]struct{}, url string) bool {
-	_, ok := seen[url]
-	return ok
-}
-
-func normalizeName(input string) string {
-	mapper := func(r rune) rune {
-		if r > unicode.MaxASCII {
-			return -1
-		}
-		if strings.ContainsRune(`\/*?"<>|`, r) {
-			return -1
-		}
-		return r
-	}
-	return strings.Join(strings.Fields(strings.Map(mapper, strings.ReplaceAll(input, ":", " -"))), " ")
-}
-
-func imdbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-}
-
-func downloadTrackerTorrent(ctx context.Context, urlValue string, apiKey string, output string) error {
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, urlValue, nil)
-	if err != nil {
-		return fmt.Errorf("trackers: SPD build torrent download request: %w", err)
-	}
-	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
-	resp, err := (&http.Client{Timeout: 20 * time.Second}).Do(httpReq)
-	if err != nil {
-		return fmt.Errorf("trackers: SPD torrent download request: %w", err)
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("trackers: SPD read torrent response: %w", err)
-	}
-	if err := os.MkdirAll(filepath.Dir(output), 0o700); err != nil {
-		return fmt.Errorf("trackers: SPD create torrent output dir: %w", err)
-	}
-	if err := os.WriteFile(output, body, 0o600); err != nil {
-		return fmt.Errorf("trackers: SPD write torrent output: %w", err)
-	}
-	return nil
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["SPD"]
-}
-
-func digitsOnly(value string) bool {
-	_, err := strconv.Atoi(strings.TrimSpace(value))
-	return err == nil
-}
-
-func containsWord(a string, b string) bool {
-	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
-}
-
-func isSD(res string) bool {
-	return strings.HasPrefix(strings.TrimSpace(res), "480") || strings.HasPrefix(strings.TrimSpace(res), "576") || strings.HasPrefix(strings.TrimSpace(res), "540")
-}
-
-func genresText(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Genres, meta.Release.Genre)
-}
-
-func keywordsText(meta api.PreparedMetadata) string {
-	return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
diff --git a/internal/trackers/impl/standalone/ant/bbcode.go b/internal/trackers/impl/standalone/ant/bbcode.go
new file mode 100644
index 00000000..0d1ee3b8
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/bbcode.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.ConvertToAlign(value)
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.RemoveSup(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/ant/bbcode_test.go b/internal/trackers/impl/standalone/ant/bbcode_test.go
new file mode 100644
index 00000000..242a1bd9
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/bbcode_test.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFinalizeDescription(t *testing.T) {
+	input := "[center][img=350]https://img.example/a.png[/img][/center]\n[sup]x[/sup]\n[sub]y[/sub]\n[list]z[/list]"
+	got := finalizeDescription(input)
+	if !strings.Contains(got, "[align=center][img]https://img.example/a.png[/img][/align]") {
+		t.Fatalf("expected center/img tags normalized for ANT, got %q", got)
+	}
+	if strings.Contains(got, "[sup]") || strings.Contains(got, "[sub]") || strings.Contains(got, "[list]") {
+		t.Fatalf("expected ANT cleanup to strip unsupported tags, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/ant/data.go b/internal/trackers/impl/standalone/ant/data.go
new file mode 100644
index 00000000..89e1b295
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/data.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dataLookup struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDataLookup returns an ANT lookup bound to cfg and httpClient.
+func (d *Definition) NewDataLookup(cfg config.Config, httpClient *http.Client, _ api.Logger) trackers.DataLookup {
+	return &dataLookup{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://anthelion.me/api.php",
+	}
+}
+
+// Lookup searches ANT by filename and returns IMDb and TMDB identifiers from
+// the sole result or the result containing the requested file. Disc uploads,
+// missing credentials or names, non-success responses, and no match produce an
+// empty result without an error.
+func (l *dataLookup) Lookup(ctx context.Context, req trackers.DataLookupRequest) (trackers.DataLookupResult, error) {
+	if strings.TrimSpace(req.Meta.DiscType) != "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	apiKey := antAPIKey(l.cfg)
+	fileName := strings.TrimSpace(req.SearchName)
+	if apiKey == "" || fileName == "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	params := url.Values{
+		"t":        {"search"},
+		"filename": {fileName},
+		"o":        {"json"},
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, l.endpoint, nil)
+	if err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: ant request: %w", err)
+	}
+	httpReq.URL.RawQuery = params.Encode()
+	httpReq.Header.Set("User-Agent", "upbrr")
+	httpReq.Header.Set("X-Api-Key", apiKey)
+	resp, err := l.http.Do(httpReq)
+	if err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: ant request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return trackers.DataLookupResult{}, nil
+	}
+	var decoded struct {
+		Items []map[string]any `json:"item"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: ant decode: %w", err)
+	}
+	item := matchDataItem(decoded.Items, fileName)
+	if len(item) == 0 {
+		return trackers.DataLookupResult{}, nil
+	}
+	return trackers.DataLookupResult{
+		TrackerID: "1",
+		IMDBID:    antIMDB(item["imdb"]),
+		TMDBID:    int(antInt(item["tmdb"])),
+	}, nil
+}
+
+func matchDataItem(items []map[string]any, fileName string) map[string]any {
+	if len(items) == 1 {
+		return items[0]
+	}
+	baseName := strings.ToLower(strings.TrimSpace(strings.TrimSuffix(fileName, filepath.Ext(fileName))))
+	for _, item := range items {
+		files, _ := item["files"].([]any)
+		for _, raw := range files {
+			entry, _ := raw.(map[string]any)
+			name := strings.ToLower(antString(entry["name"]))
+			if strings.EqualFold(name, fileName) || strings.TrimSuffix(name, filepath.Ext(name)) == baseName {
+				return item
+			}
+		}
+	}
+	return nil
+}
+
+func antIMDB(value any) int {
+	text := strings.TrimPrefix(strings.ToLower(antString(value)), "tt")
+	parsed, _ := strconv.Atoi(text)
+	return parsed
+}
diff --git a/internal/trackers/impl/standalone/ant/data_test.go b/internal/trackers/impl/standalone/ant/data_test.go
new file mode 100644
index 00000000..0668a18b
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/data_test.go
@@ -0,0 +1,42 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func TestDataLookupSendsAPIKeyHeader(t *testing.T) {
+	t.Parallel()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("apikey") != "" || r.URL.Query().Get("t") != "search" || r.URL.Query().Get("filename") != "Example.Release.mkv" {
+			t.Errorf("unexpected query: %s", r.URL.RawQuery)
+		}
+		if r.Header.Get("X-Api-Key") != "token" || r.Header.Get("User-Agent") == "" {
+			t.Error("unexpected request headers")
+		}
+		_ = json.NewEncoder(w).Encode(map[string]any{"item": []map[string]any{{"imdb": "tt1234567", "tmdb": 765}}})
+	}))
+	defer server.Close()
+
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"ANT": {APIKey: "token"}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected ANT data lookup")
+	}
+	lookup.endpoint = server.URL
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{SearchName: "Example.Release.mkv"})
+	if err != nil {
+		t.Fatalf("lookup: %v", err)
+	}
+	if result.IMDBID != 1234567 || result.TMDBID != 765 {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+}
diff --git a/internal/trackers/impl/standalone/ant/definition.go b/internal/trackers/impl/standalone/ant/definition.go
new file mode 100644
index 00000000..aa42e984
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/definition.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	assets.Description = trackers.StripDefaultDescriptionSignature(assets.Description)
+
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+
+	return trackers.DescriptionResult{
+		Group:       "ant",
+		Description: strings.TrimSpace(description),
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/ant/definition_test.go b/internal/trackers/impl/standalone/ant/definition_test.go
new file mode 100644
index 00000000..221d3635
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/definition_test.go
@@ -0,0 +1,219 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func (d *Definition) prepareDryRun(ctx context.Context, input trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	input.Intent = trackers.PreparationIntentDryRun
+	plan, failure := d.Prepare(ctx, input)
+	if failure != nil {
+		return api.TrackerDryRunEntry{}, failure
+	}
+	return plan.DryRun(), nil
+}
+
+func TestDefinitionBuildUploadDryRunIncludesQuestionnaire(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "ANT",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity:          api.ExternalIdentity{TMDBID: 123},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Genres: "Adult", Keywords: "adult"},
+			},
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if entry.Questionnaire == nil {
+		t.Fatal("expected questionnaire")
+	}
+	if got := len(entry.Questionnaire.Fields); got != 3 {
+		t.Fatalf("expected 3 questionnaire fields, got %d", got)
+	}
+	if entry.Questionnaire.Fields[0].Key != "type" {
+		t.Fatalf("expected type field first, got %q", entry.Questionnaire.Fields[0].Key)
+	}
+	if entry.Questionnaire.Fields[0].Kind != "select" {
+		t.Fatalf("expected type field to use select control, got %q", entry.Questionnaire.Fields[0].Kind)
+	}
+	if got := len(entry.Questionnaire.Fields[0].Options); got != 4 {
+		t.Fatalf("expected 4 type options, got %d", got)
+	}
+	if entry.Questionnaire.Fields[2].Kind != "select" {
+		t.Fatalf("expected adult screens field to use select control, got %q", entry.Questionnaire.Fields[2].Kind)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunMarksManualTagsWhenOnlyIMDbGenresExist(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "ANT",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity:          api.ExternalIdentity{TMDBID: 123},
+			ProviderMetadata: api.SourceScopedMetadata{
+				IMDB: &api.IMDBMetadata{Genres: "Action, Drama"},
+			},
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got := entry.Payload["flagchangereason"]; got != "User prompted to add tags manually" {
+		t.Fatalf("expected manual tag prompt reason, got %q", got)
+	}
+	if _, ok := entry.Payload["tags"]; ok {
+		t.Fatalf("expected imdb fallback genres to avoid automatic ANT tags, got %#v", entry.Payload)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunUsesBDInfoForBDMV(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "db.sqlite")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	sourcePath := filepath.Join(tmp, "Movie", "BDMV")
+	if err := os.MkdirAll(sourcePath, 0o700); err != nil {
+		t.Fatalf("create source path: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	meta := api.UploadSubject{
+		SourcePath:            sourcePath,
+		TorrentPath:           torrentPath,
+		DiscType:              "BDMV",
+		SelectedBDMVPlaylists: []api.PlaylistInfo{{File: "00001.MPLS"}},
+		Identity:              api.ExternalIdentity{TMDBID: 123},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{Genres: "Action"},
+		},
+		TrackerQuestionnaireAnswers: map[string]map[string]string{
+			"ANT": {"type": "Feature Film"},
+		},
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(filepath.Join(tmp, "tmp"), sourcePath, meta.Release)
+	if err != nil {
+		t.Fatalf("resolve temp dir: %v", err)
+	}
+	bdinfoPath := paths.BDMVSummaryPath(tmpDir, "00001.MPLS")
+	if err := os.WriteFile(bdinfoPath, []byte("BDINFO_CONTENT"), 0o600); err != nil {
+		t.Fatalf("write bdinfo: %v", err)
+	}
+
+	entry, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker:       "ANT",
+		Meta:          meta,
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got := entry.Payload["bdinfo"]; got != "BDINFO_CONTENT" {
+		t.Fatalf("expected BDInfo payload, got %q", got)
+	}
+	if got := entry.Payload["container_type"]; got != "m2ts" {
+		t.Fatalf("expected m2ts container type, got %q", got)
+	}
+	if _, ok := entry.Payload["mediainfo"]; ok {
+		t.Fatalf("expected BDMV upload to omit mediainfo, got %#v", entry.Payload)
+	}
+	if _, ok := entry.Payload["media"]; ok {
+		t.Fatalf("expected BDMV upload to omit media field, got %#v", entry.Payload)
+	}
+}
+
+func TestResolveFlagsIncludesIMAXAndCriterionEdition(t *testing.T) {
+	t.Parallel()
+
+	flags := resolveFlags(api.UploadSubject{Edition: "IMAX Criterion Collection"})
+	if !containsString(flags, "IMAX") {
+		t.Fatalf("expected IMAX flag, got %#v", flags)
+	}
+	if !containsString(flags, "Criterion") {
+		t.Fatalf("expected Criterion flag from edition, got %#v", flags)
+	}
+}
+
+func TestResolveReleaseGroupBansUpdatedGroups(t *testing.T) {
+	t.Parallel()
+
+	for _, group := range []string{"EVO", "SM737"} {
+		if got, ok := resolveReleaseGroup(group); ok || got != "" {
+			t.Fatalf("expected %s to be banned, got %q ok=%t", group, got, ok)
+		}
+	}
+	if got, ok := resolveReleaseGroup("Flights"); !ok || got != "Flights" {
+		t.Fatalf("expected Flights to be allowed, got %q ok=%t", got, ok)
+	}
+}
+
+func TestBuildDescriptionRemovesScreenshotOnlyBlockAndDefaultSignature(t *testing.T) {
+	description := buildDescription(trackers.PreparationInput{}, trackers.DescriptionAssets{
+		Description: `[align=center]
+[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
+[/align]
+
+[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
+	})
+	if strings.TrimSpace(description) != "" {
+		t.Fatalf("expected screenshot-only/signature-only description removed, got %q", description)
+	}
+}
+
+func containsString(values []string, target string) bool {
+	return slices.Contains(values, target)
+}
diff --git a/internal/trackers/impl/standalone/ant/description_assets_test.go b/internal/trackers/impl/standalone/ant/description_assets_test.go
new file mode 100644
index 00000000..0b039832
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/description_assets_test.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
+		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "ANT",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader: "Disc menu token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "https://images.example.invalid/menu.png")
+	if strings.Contains(result.Description, "normal.png") {
+		t.Fatalf("normal screenshot leaked into ANT description: %q", result.Description)
+	}
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "ANT", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/ant/dupe.go b/internal/trackers/impl/standalone/ant/dupe.go
new file mode 100644
index 00000000..93c99fb8
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/dupe.go
@@ -0,0 +1,165 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://anthelion.me/api.php",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := antAPIKey(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	params := url.Values{"t": {"search"}, "o": {"json"}}
+	switch {
+	case meta.Identity.TMDBID != 0:
+		params.Set("tmdb", strconv.Itoa(meta.Identity.TMDBID))
+	case meta.Identity.IMDBID != 0:
+		params.Set("imdb", strconv.Itoa(meta.Identity.IMDBID))
+	default:
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing tmdb/imdb id for ANT dupe search", nil)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.endpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "ANT request failed", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("User-Agent", "upbrr")
+	req.Header.Set("X-Api-Key", apiKey)
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "ANT request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "ANT search failed", nil)
+	}
+	var payload map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&payload); err != nil || len(payload) == 0 {
+		return dupe.Failed(dupe.FailureResponseParse, "ANT search failed", err)
+	}
+	return dupe.Resolved(antDupeEntries(payload, meta.Release.Resolution), nil)
+}
+
+func antDupeEntries(payload map[string]any, resolution string) []api.DupeEntry {
+	items, _ := payload["item"].([]any)
+	entries := make([]api.DupeEntry, 0, len(items))
+	targetResolution := strings.ToLower(strings.TrimSpace(resolution))
+	for _, raw := range items {
+		item, ok := raw.(map[string]any)
+		if !ok || targetResolution != "" && strings.ToLower(antString(item["resolution"])) != targetResolution {
+			continue
+		}
+		files := antFiles(item["files"])
+		fileCount := int(antInt(item["fileCount"]))
+		if fileCount == 0 {
+			fileCount = len(files)
+		}
+		entry := api.DupeEntry{
+			Name:      antString(item["fileName"]),
+			Files:     files,
+			FileCount: fileCount,
+			Link:      antString(item["guid"]),
+			Download:  strings.ReplaceAll(antString(item["link"]), "&amp;", "&"),
+		}
+		if entry.Name == "" && len(files) > 0 {
+			entry.Name = files[0]
+		}
+		if size := antInt(item["size"]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		if flags, ok := item["flags"].([]any); ok {
+			for _, rawFlag := range flags {
+				if flag := antString(rawFlag); flag != "" {
+					entry.Flags = append(entry.Flags, flag)
+				}
+			}
+		}
+		entries = append(entries, entry)
+	}
+	return entries
+}
+
+func antAPIKey(cfg config.Config) string {
+	for name, trackerCfg := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "ANT") {
+			return strings.TrimSpace(trackerCfg.APIKey)
+		}
+	}
+	return ""
+}
+
+func antFiles(value any) []string {
+	rawFiles, _ := value.([]any)
+	files := make([]string, 0, len(rawFiles))
+	for _, raw := range rawFiles {
+		if file, ok := raw.(map[string]any); ok {
+			if name := antString(file["name"]); name != "" {
+				files = append(files, name)
+			}
+		}
+	}
+	return files
+}
+
+func antString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(strings.TrimSuffix(strings.TrimSuffix(fmt.Sprint(value), ".0"), ".00"))
+}
+
+func antInt(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case int:
+		return int64(typed)
+	case int64:
+		return typed
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/ant/dupe_test.go b/internal/trackers/impl/standalone/ant/dupe_test.go
new file mode 100644
index 00000000..1caee39f
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/dupe_test.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return fn(req) }
+
+func TestDupeSearcherSendsAPIKeyHeader(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		query := req.URL.Query()
+		if query.Get("apikey") != "" {
+			t.Fatal("apikey should not be sent as a query parameter")
+		}
+		for key, want := range map[string]string{
+			"t":    "search",
+			"o":    "json",
+			"tmdb": "123",
+		} {
+			if got := query.Get(key); got != want {
+				t.Fatalf("query %s = %q, want %q", key, got, want)
+			}
+		}
+		if got := req.Header.Get("X-Api-Key"); got != "token" {
+			t.Fatal("unexpected X-API-Key header")
+		}
+		if req.Header.Get("User-Agent") == "" {
+			t.Fatal("expected User-Agent header")
+		}
+		body := `{"item":[{"fileName":"Example.Release.2026.1080p-GRP","resolution":"1080p","guid":"https://example.invalid/torrents.php?id=1","link":"https://example.invalid/download.php?id=1"}]}`
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(strings.NewReader(body)),
+			Header:     make(http.Header),
+		}, nil
+	})}
+
+	cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"ANT": {APIKey: "token"}}}}
+	searcher := dupe.NewAdapter(New(), "ANT", cfg, client, api.NopLogger{})
+	entries, notes, err := adapterEvidence(searcher.Search(context.Background(), api.DuplicateSubject{Identity: api.ExternalIdentity{TMDBID: 123}, Release: api.ReleaseInfo{Resolution: "1080p"}}))
+	if err != nil {
+		t.Fatalf("search: %v", err)
+	}
+	if len(notes) != 0 || len(entries) != 1 {
+		t.Fatalf("entries=%#v notes=%#v", entries, notes)
+	}
+}
+
+func TestDupeSearcherMissingCredentialsSkips(t *testing.T) {
+	t.Parallel()
+	searcher := dupe.NewAdapter(New(), "ANT", config.Config{}, http.DefaultClient, api.NopLogger{})
+	result := searcher.Search(context.Background(), api.DuplicateSubject{Identity: api.ExternalIdentity{TMDBID: 1}})
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunMissingCredentials || result.SafeMessage() == "" {
+		t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+	}
+}
diff --git a/internal/trackers/impl/standalone/ant/profile.go b/internal/trackers/impl/standalone/ant/profile.go
new file mode 100644
index 00000000..a66293c9
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/profile.go
@@ -0,0 +1,53 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"maps"
+	"slices"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns ANT identity, preparation, dupe, rules, bans, and policies.
+func Profile() standalone.Profile {
+	groups := slices.Collect(maps.Keys(antBannedReleaseGroups))
+	slices.Sort(groups)
+	return standalone.Profile{
+		Name:                 "ANT",
+		BaseURL:              "https://anthelion.me",
+		DescriptionGroup:     "ant",
+		UploadContentMode:    trackers.UploadContentModeScreenshots,
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  newDuplicateAdapter,
+		Rules:                &trackers.RuleSet{RequireMovieOnly: true},
+		ArtifactPolicy:       &trackers.ArtifactPolicy{MaxPieceSizeMiB: 128, MaxTorrentBytes: 250 << 10},
+		BannedGroups:         groups,
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "ANT"},
+		DupePolicy:           &trackers.DupePolicy{DolbyVisionImpliesHDR: true},
+		AudioPolicy: &trackers.AudioPolicy{
+			AllowedLanguages: []string{"english"}, BlockEnglishOriginalWithForeign: true,
+		},
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeMovie,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"tracker.anthelion.me"}, WorkingTrackerID: "1",
+		},
+	}
+}
+
+// Definition extends the shared standalone definition with ANT data lookup.
+type Definition struct{ *standalone.Definition }
+
+// New returns a fresh ANT definition from its tracker-local profile.
+func New() *Definition { return &Definition{Definition: standalone.MustNew(Profile())} }
diff --git a/internal/trackers/impl/standalone/ant/upload.go b/internal/trackers/impl/standalone/ant/upload.go
new file mode 100644
index 00000000..59cbdbc1
--- /dev/null
+++ b/internal/trackers/impl/standalone/ant/upload.go
@@ -0,0 +1,902 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ant
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	"github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const antUploadURL = "https://anthelion.me/api.php"
+
+var antTorrentIDPattern = regexp.MustCompile(`id=(\d+)`)
+
+var antDefaultSignaturePattern = regexp.MustCompile(
+	`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`,
+)
+var antEmptyURLPattern = regexp.MustCompile(`(?is)\[url=[^\]]*]\s*\[/url\]`)
+
+var antBannedReleaseGroups = map[string]struct{}{
+	"3LTON":        {},
+	"4yEo":         {},
+	"ADE":          {},
+	"AFG":          {},
+	"AniHLS":       {},
+	"AnimeRG":      {},
+	"AniURL":       {},
+	"AROMA":        {},
+	"aXXo":         {},
+	"Brrip":        {},
+	"CHD":          {},
+	"CM8":          {},
+	"CrEwSaDe":     {},
+	"d3g":          {},
+	"DDR":          {},
+	"DNL":          {},
+	"DeadFish":     {},
+	"ELiTE":        {},
+	"eSc":          {},
+	"EVO":          {},
+	"FaNGDiNG0":    {},
+	"FGT":          {},
+	"FRDS":         {},
+	"FUM":          {},
+	"HAiKU":        {},
+	"HD2DVD":       {},
+	"HDS":          {},
+	"HDTime":       {},
+	"Hi10":         {},
+	"ION10":        {},
+	"iPlanet":      {},
+	"JIVE":         {},
+	"KiNGDOM":      {},
+	"Leffe":        {},
+	"LiGaS":        {},
+	"LOAD":         {},
+	"MeGusta":      {},
+	"MkvCage":      {},
+	"mHD":          {},
+	"mSD":          {},
+	"NhaNc3":       {},
+	"nHD":          {},
+	"NOIVTC":       {},
+	"nSD":          {},
+	"Oj":           {},
+	"Ozlem":        {},
+	"PiRaTeS":      {},
+	"PRoDJi":       {},
+	"RAPiDCOWS":    {},
+	"RARBG":        {},
+	"RetroPeeps":   {},
+	"RDN":          {},
+	"REsuRRecTioN": {},
+	"RMTeam":       {},
+	"SANTi":        {},
+	"SicFoI":       {},
+	"SPASM":        {},
+	"SM737":        {},
+	"SPDVD":        {},
+	"STUTTERSHIT":  {},
+	"TBS":          {},
+	"Telly":        {},
+	"TM":           {},
+	"UPiNSMOKE":    {},
+	"URANiME":      {},
+	"WAF":          {},
+	"xRed":         {},
+	"XS":           {},
+	"YIFY":         {},
+	"YTS":          {},
+	"Zeus":         {},
+	"ZKBL":         {},
+	"ZmN":          {},
+	"ZMNT":         {},
+}
+
+type uploadState struct {
+	torrentPath  string
+	description  string
+	fields       map[string]string
+	adultContent bool
+	manualTags   bool
+	typeName     string
+	tags         string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state, req.Meta)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "ANT")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, state, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	state uploadState,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, antUploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ANT request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ANT upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ANT read response: %w", err)
+	}
+
+	payload := map[string]any{}
+	if len(bodyBytes) > 0 {
+		if err := json.Unmarshal(bodyBytes, &payload); err != nil {
+			if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+				return api.UploadSummary{}, errors.New("trackers: ANT json decode error, the API is probably down")
+			}
+		}
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 || !antUploadSuccess(payload) {
+		return api.UploadSummary{}, antUploadError(resp.StatusCode, payload, bodyBytes)
+	}
+
+	viewURL := strings.TrimSpace(stringValue(payload["view"]))
+	if viewURL == "" {
+		viewURL = strings.TrimSpace(stringValue(payload["link"]))
+	}
+	torrentID := ""
+	if matches := antTorrentIDPattern.FindStringSubmatch(viewURL); len(matches) > 1 {
+		torrentID = strings.TrimSpace(matches[1])
+	}
+
+	if announceURL != "" {
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, viewURL, "ANT"); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "ANT",
+			TorrentID:   torrentID,
+			DownloadURL: viewURL,
+			TorrentURL:  viewURL,
+			TorrentPath: artifactPath,
+		}},
+	}, nil
+}
+
+func buildUploadPreview(state uploadState, meta api.UploadSubject) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "ANT",
+		ReleaseName:      resolveUploadName(meta),
+		DescriptionGroup: "ant",
+		Description:      state.description,
+		Endpoint:         antUploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+		Questionnaire: buildQuestionnaire(meta, state),
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	select {
+	case <-ctx.Done():
+		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: ANT missing api_key")
+	}
+	if req.Meta.Identity.TMDBID == 0 {
+		return uploadState{}, errors.New("trackers: ANT missing tmdb id")
+	}
+
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	descriptionAssets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		descriptionAssets = trackers.DescriptionAssets{}
+	}
+	descriptionAssets.Description = trackers.StripDefaultDescriptionSignature(descriptionAssets.Description)
+	description := buildDescription(req, descriptionAssets)
+
+	answers := standalone.QuestionnaireAnswers(req.Meta, "ANT")
+	typeName, typeID := resolveType(req.Meta, answers)
+	audio := resolveAudioFormat(req.Meta)
+	flags := resolveFlags(req.Meta)
+	tags, manualTags := resolveTags(req.Meta, answers)
+	adultContent := detectAdult(req.Meta)
+	safeScreens := resolveAdultScreensAllowed(answers, adultContent)
+	screenshots := resolveScreenshotPayload(descriptionAssets.Screenshots, safeScreens)
+	mediaFields, err := resolveMediaFields(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, err
+	}
+
+	fields := map[string]string{
+		"api_key":      strings.TrimSpace(req.TrackerConfig.APIKey),
+		"action":       "upload",
+		"tmdbid":       strconv.Itoa(req.Meta.Identity.TMDBID),
+		"type":         strconv.Itoa(typeID),
+		"audioformat":  audio,
+		"release_desc": description,
+		"screenshots":  screenshots,
+	}
+	maps.Copy(fields, mediaFields)
+	if len(flags) > 0 {
+		fields["flags[]"] = strings.Join(flags, ",")
+	}
+	if req.Meta.Scene {
+		fields["censored"] = "1"
+	}
+	if tags != "" {
+		fields["tags"] = tags
+	}
+	if releaseGroup, ok := resolveReleaseGroup(req.Meta.Tag); ok {
+		fields["releasegroup"] = releaseGroup
+	} else {
+		fields["noreleasegroup"] = "1"
+	}
+	if adultContent && screenshots != "" {
+		if !manualTags {
+			fields["flagchangereason"] = "Adult with screens uploaded with upbrr"
+		} else {
+			fields["flagchangereason"] = "Adult with screens uploaded with upbrr. User to add tags manually."
+		}
+	} else if manualTags {
+		fields["flagchangereason"] = "User prompted to add tags manually"
+	}
+
+	return uploadState{
+		torrentPath:  torrentPath,
+		description:  description,
+		fields:       fields,
+		adultContent: adultContent,
+		manualTags:   manualTags,
+		typeName:     typeName,
+		tags:         tags,
+	}, nil
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	var parts []string
+
+	// Base description
+	base := strings.TrimSpace(antDefaultSignaturePattern.ReplaceAllString(assets.Description, ""))
+	report := bbcode.CleanPTPDescription(base, meta.DiscType)
+	userDesc := strings.TrimSpace(report.Description)
+	if userDesc == "" && base != "" && len(report.Images) == 0 {
+		userDesc = base
+	}
+
+	if userDesc != "" {
+		// Custom Header
+		if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+			parts = append(parts, header)
+		}
+
+		// Logo
+		logoURL, _ := unit3d.ResolveLogo(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig())
+		if logoURL != "" {
+			if strings.HasSuffix(logoURL, ".svg") {
+				logoURL = strings.ReplaceAll(logoURL, ".svg", ".png")
+			}
+			parts = append(parts, "[align=center][img]"+logoURL+"[/img][/align]")
+		}
+
+		// User Description
+		parts = append(parts, userDesc)
+	}
+
+	// Disc menus
+	if len(assets.MenuImages) > 0 {
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		var shotParts []string
+		for _, img := range assets.MenuImages {
+			url := metautil.FirstNonEmptyTrimmed(img.RawURL, img.ImgURL, img.WebURL)
+			if url != "" {
+				shotParts = append(shotParts, "[img]"+url+"[/img]")
+			}
+		}
+		if len(shotParts) > 0 {
+			parts = append(parts, "[align=center]"+strings.Join(shotParts, " ")+"[/align]")
+		}
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		unit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// Join and finalize
+	description := strings.Join(parts, "\n\n")
+
+	finalized := finalizeDescription(description)
+
+	// Character replacements
+	replacer := strings.NewReplacer("•", "-", "’", "'", "–", "-")
+	finalized = replacer.Replace(finalized)
+
+	finalized = strings.TrimSpace(antEmptyURLPattern.ReplaceAllString(finalized, ""))
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		unit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "ANT", req.Runtime.DBPath, finalized, req.Logger)
+	}
+
+	return finalized
+}
+
+func resolveMediaFields(meta api.UploadSubject, dbPath string) (map[string]string, error) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		bdinfo, err := resolveBDInfo(meta, dbPath)
+		if err != nil {
+			return nil, err
+		}
+		if strings.TrimSpace(bdinfo) == "" {
+			return nil, errors.New("trackers: ANT missing BDInfo text")
+		}
+		return map[string]string{
+			"bdinfo":         bdinfo,
+			"container_type": "m2ts",
+		}, nil
+	}
+
+	if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
+		return nil, errors.New("trackers: ANT missing mediainfo text")
+	}
+	payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: ANT read mediainfo: %w", err)
+	}
+	return map[string]string{"mediainfo": string(payload)}, nil
+}
+
+func resolveBDInfo(meta api.UploadSubject, dbPath string) (string, error) {
+	if summary := strings.TrimSpace(meta.Disc.Summary); summary != "" {
+		return summary, nil
+	}
+
+	path, err := resolveBDInfoPath(meta, dbPath)
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(path) == "" {
+		return "", nil
+	}
+	payload, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("trackers: ANT read BDInfo: %w", err)
+	}
+	return string(payload), nil
+}
+
+func resolveBDInfoPath(meta api.UploadSubject, dbPath string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return "", nil
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	path, err := paths.PrimaryBDMVSummaryPathFor(tmpRoot, meta.SourcePath, meta.Release, meta.SelectedBDMVPlaylists)
+	if err != nil {
+		return path, fmt.Errorf("trackers: ANT resolve BDInfo path: %w", err)
+	}
+	return path, nil
+}
+
+func buildQuestionnaire(meta api.UploadSubject, state uploadState) *api.TrackerQuestionnaire {
+	current := standalone.QuestionnaireAnswers(meta, "ANT")
+	fields := make([]api.TrackerQuestionnaireField, 0, 3)
+	if strings.TrimSpace(state.typeName) == "" {
+		fields = append(fields, api.TrackerQuestionnaireField{
+			Key:         "type",
+			Label:       "ANT Type",
+			Kind:        "select",
+			Options:     []string{"Feature Film", "Short Film", "Miniseries", "Other"},
+			Value:       strings.TrimSpace(current["type"]),
+			Placeholder: "Select a release type",
+			Help:        "Pick the ANT content type for this release",
+			Required:    true,
+		})
+	}
+	if strings.TrimSpace(state.tags) == "" {
+		fields = append(fields, api.TrackerQuestionnaireField{
+			Key:         "tags",
+			Label:       "Tags",
+			Kind:        "text",
+			Value:       strings.TrimSpace(current["tags"]),
+			Placeholder: "action, drama",
+			Help:        "Comma-separated ANT tags",
+			Required:    true,
+		})
+	}
+	if state.adultContent {
+		fields = append(fields, api.TrackerQuestionnaireField{
+			Key:         "adult_screens",
+			Label:       "Upload Screenshots",
+			Kind:        "select",
+			Options:     []string{"no", "yes"},
+			Value:       metautil.FirstNonEmptyTrimmed(strings.TrimSpace(current["adult_screens"]), "no"),
+			Placeholder: "Select yes or no",
+			Help:        "Set to yes to include screenshots for adult content",
+			Required:    true,
+		})
+	}
+	if len(fields) == 0 {
+		return nil
+	}
+	return &api.TrackerQuestionnaire{Tracker: "ANT", Fields: fields}
+}
+
+func resolveType(meta api.UploadSubject, answers map[string]string) (string, int) {
+	if text := normalizeTypeName(answers["type"]); text != "" {
+		return text, antTypeID(text)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		imdbType := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.IMDB.Type))
+		runtime := meta.ProviderMetadata.IMDB.RuntimeMinutes
+		switch imdbType {
+		case "movie", "tv movie", "tvmovie":
+			if runtime >= 45 || runtime == 0 {
+				return "Feature Film", 0
+			}
+			return "Short Film", 1
+		case "short":
+			return "Short Film", 1
+		case "tv mini series":
+			return "Miniseries", 2
+		case "comedy":
+			return "Other", 3
+		}
+	}
+	keywords := strings.ToLower(strings.TrimSpace(resolveKeywords(meta)))
+	category := strings.ToLower(strings.TrimSpace(string(meta.Identity.Category)))
+	if category == "movie" {
+		runtime := 0
+		if meta.ProviderMetadata.TMDB != nil {
+			runtime = meta.ProviderMetadata.TMDB.Runtime
+		}
+		if runtime >= 45 || runtime == 0 {
+			return "Feature Film", 0
+		}
+		return "Short Film", 1
+	}
+	if strings.Contains(keywords, "miniseries") {
+		return "Miniseries", 2
+	}
+	if strings.Contains(keywords, "short") || strings.Contains(keywords, "short film") {
+		return "Short Film", 1
+	}
+	if strings.Contains(keywords, "stand-up comedy") {
+		return "Other", 3
+	}
+	return "", 0
+}
+
+func normalizeTypeName(value string) string {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "feature film", "feature", "movie":
+		return "Feature Film"
+	case "short film", "short":
+		return "Short Film"
+	case "miniseries", "mini series", "mini-series":
+		return "Miniseries"
+	case "other", "comedy":
+		return "Other"
+	default:
+		return ""
+	}
+}
+
+func antTypeID(value string) int {
+	switch normalizeTypeName(value) {
+	case "Short Film":
+		return 1
+	case "Miniseries":
+		return 2
+	case "Other":
+		return 3
+	default:
+		return 0
+	}
+}
+
+func resolveAudioFormat(meta api.UploadSubject) string {
+	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
+	switch {
+	case strings.Contains(audio, "DD+"), strings.Contains(audio, "EAC3"):
+		return "EAC3"
+	case strings.Contains(audio, " DD "), strings.HasPrefix(audio, "DD"), strings.Contains(audio, "AC3"):
+		return "AC3"
+	case strings.Contains(audio, "DTS-HD MA"), strings.Contains(audio, "DTS MA"):
+		return "DTSMA"
+	case strings.Contains(audio, "DTS"):
+		return "DTS"
+	case strings.Contains(audio, "TRUEHD"):
+		return "TrueHD"
+	case strings.Contains(audio, "FLAC"):
+		return "FLAC"
+	case strings.Contains(audio, "PCM"):
+		return "PCM"
+	case strings.Contains(audio, "OPUS"):
+		return "Opus"
+	case strings.Contains(audio, "AAC"):
+		return "AAC"
+	case strings.Contains(audio, "MP3"):
+		return "MP3"
+	case strings.Contains(audio, "MP2"):
+		return "MP2"
+	default:
+		return "Other"
+	}
+}
+
+func resolveFlags(meta api.UploadSubject) []string {
+	flags := make([]string, 0, 12)
+	edition := strings.ReplaceAll(meta.Edition, "'", "")
+	for _, candidate := range []string{"Directors", "Extended", "Uncut", "Unrated", "4KRemaster", "IMAX"} {
+		if strings.Contains(edition, candidate) {
+			flags = append(flags, candidate)
+		}
+	}
+	if strings.Contains(meta.Audio, "Dual-Audio") {
+		flags = append(flags, "DualAudio")
+	}
+	if strings.Contains(meta.Audio, "Atmos") {
+		flags = append(flags, "Atmos")
+	}
+	if meta.HasCommentary {
+		flags = append(flags, "Commentary")
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
+		flags = append(flags, "3D")
+	}
+	if strings.Contains(strings.ToUpper(meta.HDR), "HDR") {
+		flags = append(flags, "HDR10")
+	}
+	if strings.Contains(strings.ToUpper(meta.HDR), "DV") {
+		flags = append(flags, "DV")
+	}
+	if strings.Contains(strings.ToUpper(meta.Distributor), "CRITERION") || strings.Contains(strings.ToUpper(meta.Edition), "CRITERION") {
+		flags = append(flags, "Criterion")
+	}
+	if strings.Contains(strings.ToUpper(meta.Type), "REMUX") {
+		flags = append(flags, "Remux")
+	}
+	return dedupeStrings(flags)
+}
+
+func resolveTags(meta api.UploadSubject, answers map[string]string) (string, bool) {
+	if tagValue := normalizeTags(strings.TrimSpace(answers["tags"])); tagValue != "" {
+		return tagValue, true
+	}
+	values := make([]string, 0, 8)
+	if meta.ProviderMetadata.TMDB != nil {
+		values = append(values, splitTags(meta.ProviderMetadata.TMDB.Genres)...)
+	}
+	if len(values) == 0 {
+		if meta.ProviderMetadata.IMDB != nil && len(splitTags(meta.ProviderMetadata.IMDB.Genres)) > 0 {
+			return "", true
+		}
+		return "", true
+	}
+	allowed := map[string]struct{}{
+		"action":      {},
+		"adventure":   {},
+		"animation":   {},
+		"comedy":      {},
+		"crime":       {},
+		"documentary": {},
+		"drama":       {},
+		"family":      {},
+		"fantasy":     {},
+		"history":     {},
+		"horror":      {},
+		"music":       {},
+		"mystery":     {},
+		"romance":     {},
+		"sci.fi":      {},
+		"thriller":    {},
+		"war":         {},
+		"western":     {},
+	}
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		if _, ok := allowed[value]; ok {
+			filtered = append(filtered, value)
+		}
+	}
+	return strings.Join(dedupeStrings(filtered), ","), false
+}
+
+func normalizeTags(value string) string {
+	if strings.TrimSpace(value) == "" {
+		return ""
+	}
+	return strings.Join(dedupeStrings(splitTags(value)), ",")
+}
+
+func splitTags(value string) []string {
+	items := strings.FieldsFunc(value, func(r rune) bool { return r == ',' || r == ';' })
+	result := make([]string, 0, len(items))
+	for _, item := range items {
+		normalized := strings.ToLower(strings.TrimSpace(strings.ReplaceAll(item, " ", ".")))
+		if normalized != "" {
+			result = append(result, normalized)
+		}
+	}
+	return result
+}
+
+func resolveReleaseGroup(tag string) (string, bool) {
+	trimmed := strings.TrimSpace(strings.TrimPrefix(tag, "-"))
+	if trimmed == "" {
+		return "", false
+	}
+	if _, banned := antBannedReleaseGroups[trimmed]; banned {
+		return "", false
+	}
+	return trimmed, true
+}
+
+func detectAdult(meta api.UploadSubject) bool {
+	candidates := []string{meta.Release.Genre, resolveKeywords(meta)}
+	if meta.ProviderMetadata.TMDB != nil {
+		candidates = append(candidates, meta.ProviderMetadata.TMDB.Genres)
+	}
+	for _, candidate := range candidates {
+		lower := strings.ToLower(candidate)
+		for _, token := range []string{"xxx", "erotic", "porn", "adult", "orgy"} {
+			if strings.Contains(lower, token) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func resolveAdultScreensAllowed(answers map[string]string, adultContent bool) bool {
+	if !adultContent {
+		return true
+	}
+	switch strings.ToLower(strings.TrimSpace(answers["adult_screens"])) {
+	case "y", "yes", "true", "1":
+		return true
+	default:
+		return false
+	}
+}
+
+func resolveScreenshotPayload(images []api.ScreenshotImage, allow bool) string {
+	if !allow || len(images) == 0 {
+		return ""
+	}
+	urls := make([]string, 0, 4)
+	for _, image := range images {
+		rawURL := strings.TrimSpace(image.RawURL)
+		if rawURL == "" {
+			rawURL = strings.TrimSpace(image.ImgURL)
+		}
+		if rawURL == "" {
+			continue
+		}
+		urls = append(urls, rawURL)
+		if len(urls) == 4 {
+			break
+		}
+	}
+	return strings.Join(urls, "\n")
+}
+
+func resolveKeywords(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+	}
+	return ""
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.Filename); name != "" {
+		return name
+	}
+	return pathutil.Base(meta.SourcePath)
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	for key, value := range fields {
+		if key == "flags[]" {
+			for item := range strings.SplitSeq(value, ",") {
+				trimmed := strings.TrimSpace(item)
+				if trimmed == "" {
+					continue
+				}
+				if err := writer.WriteField(key, trimmed); err != nil {
+					_ = writer.Close()
+					return nil, "", fmt.Errorf("trackers: ANT write multipart field %q: %w", key, err)
+				}
+			}
+			continue
+		}
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: ANT write multipart field %q: %w", key, err)
+		}
+	}
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: ANT open torrent file: %w", err)
+	}
+	defer file.Close()
+	part, err := writer.CreateFormFile("file_input", "torrent.torrent")
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: ANT create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: ANT copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: ANT close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func antUploadSuccess(payload map[string]any) bool {
+	if success, ok := payload["success"]; ok {
+		switch value := success.(type) {
+		case bool:
+			return value
+		case string:
+			return strings.EqualFold(strings.TrimSpace(value), "true") || strings.EqualFold(strings.TrimSpace(value), "success")
+		}
+	}
+	return strings.EqualFold(strings.TrimSpace(stringValue(payload["status"])), "success")
+}
+
+func antUploadError(status int, payload map[string]any, body []byte) error {
+	text := strings.ToLower(compactJSON(payload))
+	if status == http.StatusBadRequest {
+		switch {
+		case strings.Contains(text, "same infohash"):
+			if viewURL := strings.TrimSpace(stringValue(payload["view"])); viewURL != "" {
+				return fmt.Errorf("trackers: ANT same infohash already exists: %s", commonhttp.RedactErrorDetail(viewURL))
+			}
+			return errors.New("trackers: ANT same infohash already exists")
+		case strings.Contains(text, "exact same"):
+			return errors.New("trackers: ANT exact same media file already exists")
+		}
+	}
+	if detail := commonhttp.ExtractHTTPErrorDetail(body); detail != "" {
+		return fmt.Errorf("trackers: ANT upload failed status=%d: %s", status, detail)
+	}
+	switch status {
+	case http.StatusForbidden:
+		return errors.New("trackers: ANT wrong API key or insufficient permissions")
+	case http.StatusInternalServerError:
+		return errors.New("trackers: ANT internal server error")
+	case http.StatusBadGateway:
+		return errors.New("trackers: ANT bad gateway")
+	}
+	if message := strings.TrimSpace(stringValue(payload["error"])); message != "" {
+		return fmt.Errorf("trackers: ANT api error: %s", commonhttp.RedactErrorDetail(message))
+	}
+	return commonhttp.UploadHTTPError("ANT", status, body)
+}
+
+func compactJSON(payload map[string]any) string {
+	if len(payload) == 0 {
+		return ""
+	}
+	encoded, err := json.Marshal(payload)
+	if err != nil {
+		return ""
+	}
+	return string(encoded)
+}
+
+func stringValue(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	default:
+		return strings.TrimSpace(fmt.Sprint(value))
+	}
+}
+
+func dedupeStrings(values []string) []string {
+	seen := make(map[string]struct{}, len(values))
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}
diff --git a/internal/trackers/impl/standalone/ar/definition.go b/internal/trackers/impl/standalone/ar/definition.go
new file mode 100644
index 00000000..01671cac
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/definition.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	var (
+		err    error
+		assets trackers.DescriptionAssets
+	)
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+
+	description := buildDescription(req.Meta, req.Runtime.DBPath, assets)
+	return trackers.DescriptionResult{
+		Group:       "ar",
+		Description: strings.TrimSpace(description),
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/ar/definition_test.go b/internal/trackers/impl/standalone/ar/definition_test.go
new file mode 100644
index 00000000..549b1ec1
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/definition_test.go
@@ -0,0 +1,92 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func prepareDryRun(ctx context.Context, input trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	input.Intent = trackers.PreparationIntentDryRun
+	plan, failure := New().Prepare(ctx, input)
+	if failure != nil {
+		return api.TrackerDryRunEntry{}, failure
+	}
+	return plan.DryRun(), nil
+}
+
+func TestResolveTypeID(t *testing.T) {
+	t.Parallel()
+
+	if got := resolveTypeID(api.UploadSubject{
+		Type:   "REMUX",
+		Source: "Blu-ray",
+	}); got != "14" {
+		t.Fatalf("expected bluray remux type 14, got %q", got)
+	}
+
+	if got := resolveTypeID(api.UploadSubject{
+		Anime:   true,
+		Release: api.ReleaseInfo{Resolution: "1080p"},
+	}); got != "16" {
+		t.Fatalf("expected anime hd type 16, got %q", got)
+	}
+
+	if got := resolveTypeID(api.UploadSubject{
+		TVPack:   true,
+		Identity: api.ExternalIdentity{Category: "TV"},
+		Release:  api.ReleaseInfo{Resolution: "480p"},
+	}); got != "4" {
+		t.Fatalf("expected tv pack sd type 4, got %q", got)
+	}
+
+	if got := resolveTypeID(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		Release:  api.ReleaseInfo{Resolution: "1080p"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{Genres: "Drama", Keywords: "adult"},
+		},
+	}); got != "13" {
+		t.Fatalf("expected adult movie type 13, got %q", got)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunBlockedWithoutPoster(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "AR",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			Release:     api.ReleaseInfo{Title: "Movie", Resolution: "1080p"},
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
+		},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if entry.Status != "blocked" {
+		t.Fatalf("expected blocked status, got %q", entry.Status)
+	}
+	if entry.Message != "missing poster URL" {
+		t.Fatalf("expected poster block message, got %q", entry.Message)
+	}
+}
diff --git a/internal/trackers/impl/standalone/ar/dupe.go b/internal/trackers/impl/standalone/ar/dupe.go
new file mode 100644
index 00000000..50e48dcc
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/dupe.go
@@ -0,0 +1,220 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	arBrowseEndpoint = "https://alpharatio.cc/ajax.php"
+)
+
+type dupeSearcher struct {
+	cfg    config.Config
+	http   *http.Client
+	logger api.Logger
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:    cfg,
+		http:   httpClient,
+		logger: logger,
+	}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if h.http == nil {
+		return dupe.Failed(dupe.FailureInternal, "AR handler misconfigured: no HTTP client", nil)
+	}
+
+	query := arSearchQuery(meta)
+	if query == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing title for AR dupe search", nil)
+	}
+
+	cookies, cookiePath, err := h.resolveCookies(ctx)
+	if err != nil || len(cookies) == 0 {
+		if err != nil && h.logger != nil {
+			h.logger.Debugf("dupechecking: AR cookie resolution failed: %v", err)
+		}
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid AR cookies", nil)
+	}
+	if h.logger != nil && cookiePath != "" {
+		h.logger.Debugf("dupechecking: AR using stored cookies from %s", cookiePath)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, arBrowseEndpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "AR request failed", fmt.Errorf("build AR request: %w", err))
+	}
+	params := req.URL.Query()
+	params.Set("action", "browse")
+	params.Set("searchstr", query)
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+
+	resp, err := h.http.Do(req)
+	if err != nil {
+		if h.logger != nil {
+			h.logger.Debugf("dupechecking: AR request failed: %v", err)
+		}
+		return dupe.Failed(dupe.FailureRequest, "AR request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		if h.logger != nil {
+			h.logger.Debugf("dupechecking: AR returned status %d", resp.StatusCode)
+		}
+		return dupe.Failed(dupe.FailureResponseStatus, "AR search returned non-success status", nil)
+	}
+
+	var payload arResponse
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		if h.logger != nil {
+			h.logger.Debugf("dupechecking: AR response decode failed: %v", err)
+		}
+		return dupe.Failed(dupe.FailureResponseParse, "AR response decode failed", err)
+	}
+	if !strings.EqualFold(strings.TrimSpace(payload.Status), "success") {
+		return dupe.Failed(dupe.FailureResponseStatus, "AR API returned non-success status", nil)
+	}
+
+	entries := make([]api.DupeEntry, 0, len(payload.Response.Results))
+	for _, result := range payload.Response.Results {
+		name := strings.TrimSpace(result.GroupName)
+		if name == "" {
+			continue
+		}
+		entry := api.DupeEntry{
+			Name:      name,
+			Files:     []string{name},
+			FileCount: result.FileCount,
+			ID:        strconv.FormatInt(result.TorrentID, 10),
+			Link: "https://alpharatio.cc/torrents.php?id=" + strconv.FormatInt(
+				result.GroupID,
+				10,
+			) + "&torrentid=" + strconv.FormatInt(
+				result.TorrentID,
+				10,
+			),
+			Download: "https://alpharatio.cc/torrents.php?action=download&id=" + strconv.FormatInt(result.TorrentID, 10),
+		}
+		if result.Size > 0 {
+			entry.SizeKnown = true
+			entry.SizeBytes = result.Size
+		}
+		entries = append(entries, entry)
+	}
+
+	return dupe.Resolved(entries, nil)
+}
+
+func (h dupeSearcher) resolveCookies(ctx context.Context) ([]*http.Cookie, string, error) {
+	arURL, _ := url.Parse("https://alpharatio.cc/")
+	merged := map[string]*http.Cookie{}
+
+	if h.http != nil && h.http.Jar != nil && arURL != nil {
+		for _, cookie := range h.http.Jar.Cookies(arURL) {
+			if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
+				continue
+			}
+			merged[cookie.Name] = cookie
+		}
+	}
+	if len(merged) > 0 {
+		if h.logger != nil {
+			h.logger.Debugf("dupechecking: AR using %d cookies from HTTP client jar", len(merged))
+		}
+		return mapCookiesToSlice(merged), "", nil
+	}
+
+	loaded, err := cookiepkg.LoadTrackerHTTPCookies(ctx, h.cfg.MainSettings.DBPath, "AR", "alpharatio.cc")
+	if err != nil {
+		return nil, "", fmt.Errorf("dupechecking: %w", err)
+	}
+	for _, cookie := range loaded {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
+			continue
+		}
+		merged[cookie.Name] = cookie
+	}
+	if len(merged) == 0 {
+		return nil, "", errors.New("no valid cookies found")
+	}
+	return mapCookiesToSlice(merged), "shared store", nil
+}
+
+func mapCookiesToSlice(values map[string]*http.Cookie) []*http.Cookie {
+	if len(values) == 0 {
+		return nil
+	}
+	out := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		out = append(out, cookie)
+	}
+	return out
+}
+
+func arSearchQuery(meta api.DuplicateSubject) string {
+	title := strings.TrimSpace(meta.Release.Title)
+	if title == "" && meta.ProviderMetadata.TMDB != nil {
+		title = strings.TrimSpace(meta.ProviderMetadata.TMDB.Title)
+	}
+	if title == "" && meta.ProviderMetadata.IMDB != nil {
+		title = strings.TrimSpace(meta.ProviderMetadata.IMDB.Title)
+	}
+	if title == "" {
+		title = strings.TrimSpace(meta.ReleaseName)
+	}
+	if title == "" {
+		return ""
+	}
+
+	year := meta.Release.Year
+	if year == 0 && meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		year = meta.ProviderMetadata.TMDB.Year
+	}
+	if year == 0 && meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		year = meta.ProviderMetadata.IMDB.Year
+	}
+	if year > 0 {
+		return strings.TrimSpace(title + " " + strconv.Itoa(year))
+	}
+	return title
+}
+
+type arResponse struct {
+	Status   string `json:"status"`
+	Response struct {
+		Results []struct {
+			GroupName string `json:"groupName"`
+			Size      int64  `json:"size"`
+			FileCount int    `json:"fileCount"`
+			GroupID   int64  `json:"groupId"`
+			TorrentID int64  `json:"torrentId"`
+		} `json:"results"`
+	} `json:"response"`
+}
diff --git a/internal/trackers/impl/standalone/ar/dupe_test.go b/internal/trackers/impl/standalone/ar/dupe_test.go
new file mode 100644
index 00000000..dba0c01c
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/dupe_test.go
@@ -0,0 +1,128 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+type arRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f arRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
+
+func TestARHandlerSearchParsesResultsWithCookieFile(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	cookieDir := filepath.Join(tmpDir, "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookies: %v", err)
+	}
+	cookiePath := filepath.Join(cookieDir, "AR.txt")
+	cookieText := `# Netscape HTTP Cookie File
+.alpharatio.cc	TRUE	/	TRUE	2147483647	session	abc123
+`
+	if err := os.WriteFile(cookiePath, []byte(cookieText), 0o644); err != nil {
+		t.Fatalf("write cookies: %v", err)
+	}
+
+	client := &http.Client{
+		Transport: arRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			if req.Method != http.MethodGet {
+				t.Fatalf("expected GET request, got %s", req.Method)
+			}
+			if got := req.URL.String(); !strings.HasPrefix(got, "https://alpharatio.cc/ajax.php?") {
+				t.Fatalf("unexpected request url %q", got)
+			}
+			query := req.URL.Query()
+			if got := query.Get("action"); got != "browse" {
+				t.Fatalf("expected action=browse, got %q", got)
+			}
+			if got := query.Get("searchstr"); got != "Movie Title 2023" {
+				t.Fatalf("expected searchstr to include title+year, got %q", got)
+			}
+			if got := req.Header.Get("User-Agent"); got == "" {
+				t.Fatalf("expected User-Agent header")
+			}
+			if raw := req.Header.Get("Cookie"); !strings.Contains(raw, "session=abc123") {
+				t.Fatal("expected cookie header to include session token")
+			}
+
+			body := `{"status":"success","response":{"results":[{"groupName":"Movie.Title.2023.1080p.BluRay-GRP","size":123456789,"fileCount":1,"groupId":44,"torrentId":55}]}}`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "AR",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmpDir, "ua.db")},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{Release: api.ReleaseInfo{Title: "Movie Title", Year: 2023}}
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected one entry, got %d", len(entries))
+	}
+	entry := entries[0]
+	if entry.Name != "Movie.Title.2023.1080p.BluRay-GRP" {
+		t.Fatalf("unexpected name %q", entry.Name)
+	}
+	if entry.FileCount != 1 {
+		t.Fatalf("expected file_count=1, got %d", entry.FileCount)
+	}
+	if !entry.SizeKnown || entry.SizeBytes != 123456789 {
+		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
+	}
+	if len(entry.Files) != 1 || entry.Files[0] != entry.Name {
+		t.Fatalf("expected files to contain group name, got %#v", entry.Files)
+	}
+	if entry.ID != "55" {
+		t.Fatalf("expected ID=55, got %q", entry.ID)
+	}
+	if entry.Link != "https://alpharatio.cc/torrents.php?id=44&torrentid=55" {
+		t.Fatalf("unexpected link %q", entry.Link)
+	}
+	if entry.Download != "https://alpharatio.cc/torrents.php?action=download&id=55" {
+		t.Fatalf("unexpected download %q", entry.Download)
+	}
+}
+
+func TestARHandlerMissingCookieFileReturnsSkipNote(t *testing.T) {
+	t.Parallel()
+
+	handler := dupe.NewAdapter(New(), "AR",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "ua.db")},
+		}, &http.Client{}, api.NopLogger{})
+	meta := api.DuplicateSubject{Release: api.ReleaseInfo{Title: "Movie Title", Year: 2023}}
+
+	result := handler.Search(context.Background(), meta)
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunMissingCredentials {
+		t.Fatalf("unexpected result disposition=%v code=%q", result.Disposition(), result.Code())
+	}
+}
diff --git a/internal/trackers/impl/standalone/ar/profile.go b/internal/trackers/impl/standalone/ar/profile.go
new file mode 100644
index 00000000..a5fb3a3c
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/profile.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns AR identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "AR",
+		BaseURL:             arBaseURL,
+		DescriptionGroup:    "ar",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{
+				{
+					Scope:       trackers.MetadataScopeMovie,
+					AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB},
+					Disposition: api.RuleDispositionStrict,
+				},
+				{
+					Scope: trackers.MetadataScopeTV,
+					AnyOf: []trackers.MetadataField{
+						trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB, trackers.MetadataFieldTVDB,
+					},
+					Disposition: api.RuleDispositionStrict,
+				},
+				{Scope: trackers.MetadataScopeAny, AnyOf: []trackers.MetadataField{trackers.MetadataFieldPoster}},
+			},
+		},
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: arSourceFlag},
+		DupePolicy:            &trackers.DupePolicy{ContainsFilenameMatch: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"tracker.alpharatio"}},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:          "AR",
+			DisplayName:        "AR",
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
+			_, _, err := resolveSession(ctx, cfg, dbPath, nil)
+			return err
+		},
+		AuthStateManager: trackerauth.NewKeyedFileStateManager("AR", arAuthKeyKey, arAuthFile),
+	}
+}
+
+// New returns a fresh AR definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/ar/upload.go b/internal/trackers/impl/standalone/ar/upload.go
new file mode 100644
index 00000000..2a85f30a
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/upload.go
@@ -0,0 +1,1057 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"mime/multipart"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	arBaseURL    = "https://alpharatio.cc"
+	arUploadURL  = arBaseURL + "/upload.php"
+	arLoginURL   = arBaseURL + "/login.php"
+	arBrowseURL  = arBaseURL + "/torrents.php"
+	arAuthFile   = "AR_auth.txt"
+	arAuthKeyKey = "auth_key"
+	arUserAgent  = "upbrr"
+	arSourceFlag = "AlphaRatio"
+)
+
+var (
+	arLoginFailurePattern = regexp.MustCompile(`login\.php\?act=recover|Forgot your password`)
+	arURLPattern          = regexp.MustCompile(`torrents\.php\?id=(\d+)(?:&torrentid=(\d+))?`)
+	arDownloadPattern     = regexp.MustCompile(`torrents\.php\?action=download&id=(\d+)`)
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	fields        map[string]string
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, client, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state, req.Meta)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: AR %s", state.blockedReason)
+	}
+
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "AR")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, client, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	client *http.Client,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, arUploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: AR request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", arUserAgent)
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: AR upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	bodyBytes, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: AR read upload response: %w", err)
+	}
+	groupID, torrentID := parseUploadIDs(finalURL, string(bodyBytes))
+	if resp.StatusCode == http.StatusOK && groupID != "" {
+		torrentURL := buildTorrentURL(groupID, torrentID)
+		downloadURL := buildDownloadURL(torrentID, torrentURL)
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, arSourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		id := metautil.FirstNonEmptyTrimmed(torrentID, groupID)
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "AR",
+				TorrentID:   id,
+				DownloadURL: downloadURL,
+				TorrentURL:  torrentURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	failurePath := ""
+	if pathValue, pathErr := resolveFailurePath(req.Meta, req.Runtime.DBPath); pathErr == nil {
+		failurePath = pathValue
+		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
+		_ = os.WriteFile(failurePath, redactedBody, 0o600)
+	}
+	if failurePath != "" {
+		return api.UploadSummary{}, fmt.Errorf(
+			"%w failure=%s",
+			commonhttp.UploadHTTPErrorWithURL("AR", resp.StatusCode, finalURL, responsePreview),
+			failurePath,
+		)
+	}
+	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("AR", resp.StatusCode, finalURL, responsePreview)
+}
+
+func buildUploadPreview(state uploadState, meta api.UploadSubject) api.TrackerDryRunEntry {
+	fields := maps.Clone(state.fields)
+	if _, ok := fields["auth"]; ok {
+		fields["auth"] = "[redacted]"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "AR",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      resolveARName(meta),
+		DescriptionGroup: "ar",
+		Description:      state.description,
+		Endpoint:         arUploadURL,
+		Payload:          fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, *http.Client, error) {
+	select {
+	case <-ctx.Done():
+		return uploadState{}, nil, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	var assets trackers.DescriptionAssets
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+	description := buildDescription(req.Meta, req.Runtime.DBPath, assets)
+
+	fields := map[string]string{
+		"submit": "true",
+		"type":   resolveTypeID(req.Meta),
+		"title":  resolveARName(req.Meta),
+		"tags":   resolveTags(req.Meta),
+		"image":  resolvePoster(req.Meta),
+		"desc":   description,
+	}
+	state := uploadState{
+		torrentPath: torrentPath,
+		description: description,
+		fields:      fields,
+	}
+	if strings.TrimSpace(fields["image"]) == "" {
+		state.blockedReason = "missing poster URL"
+	}
+
+	if dryRun {
+		if authProblem := dryRunAuthProblem(ctx, req.TrackerConfig, req.Runtime.DBPath); authProblem != "" && state.blockedReason == "" {
+			state.blockedReason = authProblem
+		}
+		fields["auth"] = "dry-run-auth"
+		return state, nil, nil
+	}
+
+	client, authKey, err := resolveSession(ctx, req.TrackerConfig, req.Runtime.DBPath, req.Logger)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	fields["auth"] = authKey
+	return state, client, nil
+}
+
+func buildDescription(meta api.UploadSubject, dbPath string, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+
+	var parts []string
+	title := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.ReleaseName), strings.TrimSpace(meta.Release.Title), pathutil.Base(meta.SourcePath))
+	parts = append(parts, fmt.Sprintf("[color=green][size=6]%s[/size][/color]", title))
+
+	if links := buildDatabaseLinks(meta); links != "" {
+		parts = append(parts, "[color=red][size=4]Links[/size][/color]\n"+links)
+	}
+
+	mediaLabel := "MEDIAINFO"
+	var mediaText string
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		mediaLabel = "BDINFO"
+		mediaText, _ = readBDSummary(meta, dbPath)
+	case "DVD":
+		mediaText = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
+	default:
+		mediaText = readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath))
+	}
+	if strings.TrimSpace(mediaText) != "" {
+		parts = append(parts, fmt.Sprintf("[color=red][size=4]%s[/size][/color]\n[hide][code]%s[/code][/hide]", mediaLabel, strings.TrimSpace(mediaText)))
+	}
+
+	if overview := resolveOverview(meta); overview != "" {
+		parts = append(parts, "[color=red][size=4]PLOT[/size][/color]\n"+overview)
+	}
+	if genres := resolveGenres(meta); genres != "" {
+		parts = append(parts, "[color=red][size=4]Genres[/size][/color]\n"+genres)
+	}
+	if screenshots := buildScreenshotSection(assets.Screenshots); screenshots != "" {
+		parts = append(parts, "[color=red][size=4]Screenshots[/size][/color]\n"+screenshots)
+	}
+	if youtube := resolveYouTube(meta); youtube != "" {
+		parts = append(parts, "[color=red][size=4]Youtube[/size][/color]\n"+youtube)
+	}
+	if notes := cleanNotes(assets.Description); notes != "" {
+		parts = append(parts, "[color=red][size=4]Notes[/size][/color]\n"+notes)
+	}
+
+	return strings.TrimSpace(strings.Join(parts, "\n\n"))
+}
+
+func buildDatabaseLinks(meta api.UploadSubject) string {
+	links := make([]string, 0, 5)
+	if imdb := resolveIMDbURL(meta); imdb != "" {
+		links = append(links, imdb)
+	}
+	category, categoryErr := meta.Identity.RequireCategory()
+	if id := meta.Identity.TMDBID; id > 0 && categoryErr == nil {
+		links = append(links, fmt.Sprintf("https://www.themoviedb.org/%s/%d", category, id))
+	}
+	if isTVDBCategory(meta) && meta.Identity.TVDBID > 0 {
+		id := meta.Identity.TVDBID
+		links = append(links, fmt.Sprintf("https://www.thetvdb.com/?id=%d&tab=series", id))
+	}
+	if id := meta.Identity.TVmazeID; id > 0 {
+		links = append(links, fmt.Sprintf("https://www.tvmaze.com/shows/%d", id))
+	}
+	if meta.Identity.MALID > 0 {
+		links = append(links, fmt.Sprintf("https://myanimelist.net/anime/%d", meta.Identity.MALID))
+	}
+	return strings.Join(links, "\n")
+}
+
+// isTVDBCategory reports whether AR descriptions may include a TVDB series link.
+// Canonical movie identity suppresses TVDB links even when episode facts exist.
+func isTVDBCategory(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func buildScreenshotSection(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(images))
+	for _, image := range images {
+		if strings.TrimSpace(image.RawURL) == "" || strings.TrimSpace(image.ImgURL) == "" {
+			continue
+		}
+		parts = append(parts, "[url="+image.RawURL+"][img]"+image.ImgURL+"[/img][/url]")
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	return "[align=center]" + strings.Join(parts, "") + "[/align]"
+}
+
+func cleanNotes(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	replacer := strings.NewReplacer("\r\n", "\n", "\r", "\n")
+	trimmed = replacer.Replace(trimmed)
+	sceneBlocks := []*regexp.Regexp{
+		regexp.MustCompile(`(?is)\[center\]\[spoiler=Scene NFO:\].*?\[/center\]`),
+		regexp.MustCompile(`(?is)\[center\]\[spoiler=FraMeSToR NFO:\].*?\[/center\]`),
+		regexp.MustCompile(`(?is)\[color=red\]\[size=4\]Screenshots\[/size\]\[/color\]\s*\[align=center\].*?\[/align\]`),
+		regexp.MustCompile(`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`),
+	}
+	for _, pattern := range sceneBlocks {
+		trimmed = pattern.ReplaceAllString(trimmed, "")
+	}
+	return strings.TrimSpace(trimmed)
+}
+
+func resolveTypeID(meta api.UploadSubject) string {
+	genres := strings.ToLower(resolveGenres(meta) + " " + resolveKeywords(meta))
+	adultKeywords := []string{"xxx", "erotic", "porn", "adult", "orgy"}
+	if (strings.EqualFold(meta.Type, "DISC") || strings.EqualFold(meta.Type, "REMUX")) && strings.EqualFold(meta.Source, "Blu-ray") {
+		return "14"
+	}
+	if meta.Anime {
+		if isSD(meta.Release.Resolution) {
+			return "15"
+		}
+		return "16"
+	}
+	if strings.EqualFold(string(meta.Identity.Category), "TV") {
+		if meta.TVPack {
+			if isSD(meta.Release.Resolution) {
+				return "4"
+			}
+			if isHighTier(meta.Release.Resolution) {
+				return "6"
+			}
+			return "5"
+		}
+		if isSD(meta.Release.Resolution) {
+			return "0"
+		}
+		if isHighTier(meta.Release.Resolution) {
+			return "2"
+		}
+		return "1"
+	}
+	if isSD(meta.Release.Resolution) {
+		return "7"
+	}
+	for _, keyword := range adultKeywords {
+		if strings.Contains(genres, keyword) {
+			return "13"
+		}
+	}
+	if isHighTier(meta.Release.Resolution) {
+		return "9"
+	}
+	return "8"
+}
+
+func resolveARName(meta api.UploadSubject) string {
+	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
+		return strings.TrimSpace(meta.SceneName)
+	}
+	name := paths.ReleaseTempBaseFor(meta.SourcePath, meta.Release)
+	if ext := strings.TrimSpace(filepath.Ext(name)); ext != "" {
+		name = strings.TrimSuffix(name, ext)
+	}
+	replacer := strings.NewReplacer(
+		"_", ".", " ", ".", "'", "", ":", "", "(", ".", ")", ".", "[", ".", "]", ".", "{", ".", "}", ".",
+	)
+	name = replacer.Replace(strings.TrimSpace(name))
+	name = collapseDots(name)
+
+	tagLower := strings.ToLower(strings.TrimSpace(meta.Tag))
+	invalidTags := []string{"nogrp", "nogroup", "unknown", "-unk-"}
+	if tagLower == "" || containsAny(tagLower, invalidTags) {
+		for _, invalid := range invalidTags {
+			name = regexp.MustCompile(`(?i)-?`+regexp.QuoteMeta(invalid)).ReplaceAllString(name, "")
+		}
+		name = strings.Trim(strings.TrimSpace(name), ".-")
+		if name == "" {
+			name = "release"
+		}
+		return name + "-NoGRP"
+	}
+	return name
+}
+
+func resolveTags(meta api.UploadSubject) string {
+	values := make([]string, 0, 8)
+	if meta.Identity.IMDBID > 0 {
+		values = append(values, "tt"+strconv.Itoa(meta.Identity.IMDBID))
+	}
+	for value := range strings.SplitSeq(resolveGenres(meta), ",") {
+		for sub := range strings.SplitSeq(value, "&") {
+			tag := strings.TrimSpace(collapseDots(sub))
+			if tag == "" {
+				continue
+			}
+			values = append(values, tag)
+		}
+	}
+	return strings.Join(uniqueStrings(values), ", ")
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	}
+	if meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	}
+	if meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Poster) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.Poster)
+	}
+	if meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster)
+	}
+	return ""
+}
+
+func resolveOverview(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Overview) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.Overview)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Summary) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Summary)
+	default:
+		return strings.TrimSpace(meta.EpisodeOverview)
+	}
+}
+
+func resolveGenres(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Genres) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.Genres)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Genres) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Genres)
+	default:
+		return strings.TrimSpace(meta.Release.Genre)
+	}
+}
+
+func resolveKeywords(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+	}
+	return ""
+}
+
+func resolveYouTube(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	return ""
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func dryRunAuthProblem(ctx context.Context, cfg config.TrackerConfig, dbPath string) string {
+	if _, err := os.Stat(authPath(dbPath)); err == nil {
+		return ""
+	}
+	if cookies, err := loadCookies(ctx, dbPath); err == nil && len(cookies) > 0 {
+		return ""
+	}
+	if strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != "" {
+		return ""
+	}
+	return "missing valid AR cookies/auth and username/password are not configured"
+}
+
+// resolveSession returns an authenticated AR client and auth key from stored
+// cookies/auth state or by logging in with configured credentials.
+func resolveSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, logger api.Logger) (*http.Client, string, error) {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: AR create cookie jar: %w", err)
+	}
+	base, _ := url.Parse(arBaseURL + "/")
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+	if cookies, err := loadCookies(ctx, dbPath); err == nil && len(cookies) > 0 {
+		jar.SetCookies(base, cookies)
+		authKey, valid, authErr := validateSession(ctx, client, dbPath)
+		if authErr == nil && valid {
+			return client, authKey, nil
+		}
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, "", errors.New("trackers: AR cookie invalid/missing and username/password not configured")
+	}
+	if err := ensureLoginPersistenceAvailable(dbPath); err != nil {
+		return nil, "", err
+	}
+	authKey, err := login(ctx, client, cfg, dbPath)
+	if err != nil {
+		return nil, "", err
+	}
+	if err := persistLoginAuth(ctx, dbPath, logger, jar.Cookies(base), authKey); err != nil {
+		return nil, "", err
+	}
+	return client, authKey, nil
+}
+
+func persistLoginAuth(ctx context.Context, dbPath string, logger api.Logger, values []*http.Cookie, authKey string) error {
+	return persistLoginAuthWithWriter(ctx, dbPath, logger, values, authKey, writeAuthKey)
+}
+
+// persistLoginAuthWithWriter persists login cookies before the encrypted AR
+// auth key so cookie persistence failures cannot commit a new key alone. If
+// auth key persistence fails after cookies were saved, it restores the previous
+// cookie state before returning the auth key error.
+func persistLoginAuthWithWriter(
+	ctx context.Context,
+	dbPath string,
+	logger api.Logger,
+	values []*http.Cookie,
+	authKey string,
+	write func(context.Context, string, string) error,
+) error {
+	previous, hadPrevious, err := snapshotLoginCookies(ctx, dbPath)
+	if err != nil {
+		return err
+	}
+	if err := persistLoginCookies(ctx, dbPath, logger, values); err != nil {
+		return err
+	}
+	if err := write(ctx, dbPath, authKey); err != nil {
+		if rollbackErr := restoreLoginCookies(context.WithoutCancel(ctx), dbPath, previous, hadPrevious); rollbackErr != nil {
+			return errors.Join(err, fmt.Errorf("trackers: AR rollback login cookies: %w", rollbackErr))
+		}
+		return err
+	}
+	return nil
+}
+
+func snapshotLoginCookies(ctx context.Context, dbPath string) ([]*http.Cookie, bool, error) {
+	values, err := loadCookies(ctx, dbPath)
+	if err == nil {
+		return values, len(values) > 0, nil
+	}
+	if errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) || strings.Contains(strings.ToLower(err.Error()), "no cookies found") {
+		return nil, false, nil
+	}
+	return nil, false, err
+}
+
+func restoreLoginCookies(ctx context.Context, dbPath string, previous []*http.Cookie, hadPrevious bool) error {
+	if hadPrevious {
+		return saveCookies(ctx, dbPath, previous)
+	}
+	if err := cookiepkg.DeleteTrackerCookies(ctx, dbPath, "AR"); err != nil {
+		return fmt.Errorf("trackers: AR delete cookies: %w", err)
+	}
+	return nil
+}
+
+// persistLoginCookies saves encrypted cookies after login; persistence failures
+// are returned so callers do not report login success without durable cookies.
+func persistLoginCookies(ctx context.Context, dbPath string, logger api.Logger, values []*http.Cookie) error {
+	_ = logger
+	if len(usableHTTPCookies(values)) == 0 {
+		return errors.New("trackers: AR login returned no usable cookies")
+	}
+	if err := saveCookies(ctx, dbPath, values); err != nil {
+		return err
+	}
+	return nil
+}
+
+func ensureLoginPersistenceAvailable(dbPath string) error {
+	if _, err := authmaterial.LoadFromDBPath(dbPath); err != nil {
+		if errors.Is(err, authmaterial.ErrUnavailable) {
+			return fmt.Errorf("trackers: AR encrypted auth storage unavailable before credential login: %w", cookiepkg.ErrAuthHelperUnavailable)
+		}
+		return fmt.Errorf("trackers: AR check encrypted auth storage before credential login: %w", err)
+	}
+	return nil
+}
+
+// validateSession checks the current AR session and refreshes encrypted auth
+// state when the response exposes an auth key.
+func validateSession(ctx context.Context, client *http.Client, dbPath string) (string, bool, error) {
+	return validateSessionWithAuthKeyPersistence(ctx, client, dbPath, true)
+}
+
+// validateSessionAfterLogin checks the just-authenticated AR session without
+// persisting the auth key before login cookies are durably saved.
+func validateSessionAfterLogin(ctx context.Context, client *http.Client, dbPath string) (string, bool, error) {
+	return validateSessionWithAuthKeyPersistence(ctx, client, dbPath, false)
+}
+
+func validateSessionWithAuthKeyPersistence(ctx context.Context, client *http.Client, dbPath string, persistAuthKey bool) (string, bool, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, arBrowseURL, nil)
+	if err != nil {
+		return "", false, fmt.Errorf("trackers: AR session validation request build: %w", err)
+	}
+	httpReq.Header.Set("User-Agent", arUserAgent)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return "", false, fmt.Errorf("trackers: AR session validation request: %w", err)
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", false, fmt.Errorf("trackers: AR read session response: %w", err)
+	}
+	body := string(bodyBytes)
+	if resp.StatusCode != http.StatusOK || arLoginFailurePattern.MatchString(body) {
+		return "", false, nil
+	}
+	authKey := extractAuthKey(body)
+	if authKey == "" {
+		if authKey := readAuthKey(ctx, dbPath); authKey != "" {
+			return authKey, true, nil
+		}
+		return "", false, nil
+	}
+	if !persistAuthKey {
+		return authKey, true, nil
+	}
+	if err := writeAuthKey(ctx, dbPath, authKey); err != nil {
+		return "", false, err
+	}
+	return authKey, true, nil
+}
+
+func login(ctx context.Context, client *http.Client, cfg config.TrackerConfig, dbPath string) (string, error) {
+	values := url.Values{
+		"username":   {strings.TrimSpace(cfg.Username)},
+		"password":   {strings.TrimSpace(cfg.Password)},
+		"keeplogged": {"1"},
+		"login":      {"Login"},
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, arLoginURL, strings.NewReader(values.Encode()))
+	if err != nil {
+		return "", fmt.Errorf("trackers: AR login request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	httpReq.Header.Set("User-Agent", arUserAgent)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("trackers: AR login request: %w", err)
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("trackers: AR read login response: %w", err)
+	}
+	body := string(bodyBytes)
+	if resp.StatusCode != http.StatusOK || arLoginFailurePattern.MatchString(body) {
+		return "", errors.New("trackers: AR login failed")
+	}
+	authKey := extractAuthKey(body)
+	if authKey != "" {
+		return authKey, nil
+	}
+	authKey, valid, err := validateSessionAfterLogin(ctx, client, dbPath)
+	if err != nil {
+		return "", err
+	}
+	if !valid || authKey == "" {
+		return "", errors.New("trackers: AR auth key not found after login")
+	}
+	return authKey, nil
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	file, err := os.Open(strings.TrimSpace(torrentPath))
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: AR open torrent file: %w", err)
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			return nil, "", fmt.Errorf("trackers: AR write multipart field %q: %w", key, err)
+		}
+	}
+	part, err := writer.CreateFormFile("file_input", filepath.Base(torrentPath))
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: AR create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		return nil, "", fmt.Errorf("trackers: AR copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: AR close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func parseUploadIDs(finalURL string, body string) (string, string) {
+	if matches := arURLPattern.FindStringSubmatch(finalURL); len(matches) >= 2 {
+		return strings.TrimSpace(matches[1]), strings.TrimSpace(matchAt(matches, 2))
+	}
+	if matches := arURLPattern.FindStringSubmatch(body); len(matches) >= 2 {
+		return strings.TrimSpace(matches[1]), strings.TrimSpace(matchAt(matches, 2))
+	}
+	torrentID := ""
+	if matches := arDownloadPattern.FindStringSubmatch(body); len(matches) == 2 {
+		torrentID = strings.TrimSpace(matches[1])
+	}
+	return "", torrentID
+}
+
+func buildTorrentURL(groupID string, torrentID string) string {
+	if groupID == "" {
+		return ""
+	}
+	if torrentID != "" {
+		return arBaseURL + "/torrents.php?id=" + url.QueryEscape(groupID) + "&torrentid=" + url.QueryEscape(torrentID)
+	}
+	return arBaseURL + "/torrents.php?id=" + url.QueryEscape(groupID)
+}
+
+func buildDownloadURL(torrentID string, fallback string) string {
+	if torrentID == "" {
+		return fallback
+	}
+	return arBaseURL + "/torrents.php?action=download&id=" + url.QueryEscape(torrentID)
+}
+
+func readBDSummary(meta api.UploadSubject, dbPath string) (string, error) {
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)))
+}
+
+func resolveFailurePath(meta api.UploadSubject, dbPath string) (string, error) {
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return filepath.Join(tmpDir, "[AR]upload_failure.html"), nil
+}
+
+func authPath(dbPath string) string {
+	if strings.TrimSpace(dbPath) == "" {
+		return ""
+	}
+	path, err := db.CookiePath(dbPath, arAuthFile)
+	if err != nil {
+		return ""
+	}
+	return path
+}
+
+// readAuthKey prefers encrypted AR auth state and falls back to the legacy
+// plaintext auth key file.
+func readAuthKey(ctx context.Context, dbPath string) string {
+	if authKey, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); err == nil && strings.TrimSpace(authKey) != "" {
+		return strings.TrimSpace(authKey)
+	}
+	payload, err := os.ReadFile(authPath(dbPath))
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(payload))
+}
+
+// writeAuthKey persists AR auth keys only to encrypted tracker auth state and
+// deletes any legacy plaintext key after a successful write. If legacy cleanup
+// fails, the encrypted write is rolled back so callers never commit split auth
+// state. Existing legacy installs without web auth keep using the legacy path.
+func writeAuthKey(ctx context.Context, dbPath string, authKey string) error {
+	authKey = strings.TrimSpace(authKey)
+	if authKey == "" {
+		return nil
+	}
+	previous, err := snapshotEncryptedAuthKey(ctx, dbPath)
+	if err != nil {
+		return err
+	}
+	if !previous.available {
+		return writeLegacyAuthKeyIfPresent(dbPath, authKey, previous.err)
+	}
+	if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, authKey); err != nil {
+		return fmt.Errorf("trackers: AR write encrypted auth key: %w", err)
+	}
+	if legacyPath := authPath(dbPath); legacyPath != "" {
+		if err := os.Remove(legacyPath); err != nil && !errors.Is(err, os.ErrNotExist) {
+			if rollbackErr := restoreEncryptedAuthKey(context.WithoutCancel(ctx), dbPath, previous); rollbackErr != nil {
+				return errors.Join(
+					fmt.Errorf("trackers: AR remove legacy auth key: %w", err),
+					fmt.Errorf("trackers: AR rollback encrypted auth key: %w", rollbackErr),
+				)
+			}
+			return fmt.Errorf("trackers: AR remove legacy auth key: %w", err)
+		}
+	}
+	return nil
+}
+
+type encryptedAuthKeySnapshot struct {
+	value     string
+	existed   bool
+	available bool
+	err       error
+}
+
+func snapshotEncryptedAuthKey(ctx context.Context, dbPath string) (encryptedAuthKeySnapshot, error) {
+	value, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey)
+	if err == nil {
+		return encryptedAuthKeySnapshot{
+			value:     value,
+			existed:   true,
+			available: true,
+		}, nil
+	}
+	if errors.Is(err, trackerauth.ErrAuthStateNotFound) {
+		return encryptedAuthKeySnapshot{available: true}, nil
+	}
+	if errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
+		return encryptedAuthKeySnapshot{available: false, err: err}, nil
+	}
+	return encryptedAuthKeySnapshot{}, fmt.Errorf("trackers: AR snapshot encrypted auth key: %w", err)
+}
+
+func restoreEncryptedAuthKey(ctx context.Context, dbPath string, previous encryptedAuthKeySnapshot) error {
+	if previous.existed {
+		if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, previous.value); err != nil {
+			return fmt.Errorf("trackers: AR restore encrypted auth key: %w", err)
+		}
+		return nil
+	}
+	err := trackerauth.DeleteAuthState(ctx, dbPath, "AR", arAuthKeyKey)
+	if errors.Is(err, trackerauth.ErrAuthStateNotFound) {
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("trackers: AR remove restored encrypted auth key: %w", err)
+	}
+	return nil
+}
+
+func writeLegacyAuthKeyIfPresent(dbPath string, authKey string, encryptedErr error) error {
+	legacyPath := authPath(dbPath)
+	if legacyPath == "" {
+		return fmt.Errorf("trackers: AR write encrypted auth key: %w", encryptedErr)
+	}
+	info, statErr := os.Stat(legacyPath)
+	if statErr != nil {
+		if errors.Is(statErr, os.ErrNotExist) {
+			return fmt.Errorf("trackers: AR write encrypted auth key: %w", encryptedErr)
+		}
+		return fmt.Errorf("trackers: AR stat legacy auth key: %w", statErr)
+	}
+	if info.IsDir() {
+		return errors.New("trackers: AR legacy auth key path is a directory")
+	}
+	if err := os.WriteFile(legacyPath, []byte(authKey), 0o600); err != nil {
+		return fmt.Errorf("trackers: AR write legacy auth key: %w", err)
+	}
+	return nil
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookiepkg.LoadTrackerHTTPCookies(ctx, dbPath, "AR", "alpharatio.cc")
+	if err != nil {
+		return values, fmt.Errorf("trackers: AR load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func saveCookies(ctx context.Context, dbPath string, values []*http.Cookie) error {
+	valid := usableHTTPCookies(values)
+	if len(valid) == 0 {
+		return errors.New("trackers: AR login returned no usable cookies")
+	}
+	if err := cookiepkg.SaveTrackerHTTPCookies(ctx, dbPath, "AR", valid); err != nil {
+		return fmt.Errorf("trackers: AR save cookies: %w", err)
+	}
+	return nil
+}
+
+func usableHTTPCookies(values []*http.Cookie) []*http.Cookie {
+	out := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		out = append(out, cookie)
+	}
+	return out
+}
+
+func extractAuthKey(body string) string {
+	tokenizer := html.NewTokenizer(strings.NewReader(body))
+	for {
+		//nolint:exhaustive // We only inspect tokens relevant to extracting the auth key.
+		switch tokenizer.Next() {
+		case html.ErrorToken:
+			return ""
+		case html.StartTagToken, html.SelfClosingTagToken:
+			token := tokenizer.Token()
+			if !strings.EqualFold(token.Data, "a") {
+				continue
+			}
+			href := ""
+			for _, attr := range token.Attr {
+				if strings.EqualFold(attr.Key, "href") {
+					href = attr.Val
+					break
+				}
+			}
+			if href == "" || !strings.Contains(href, "auth=") {
+				continue
+			}
+			parsed, err := url.Parse(href)
+			if err != nil {
+				continue
+			}
+			authKey := strings.TrimSpace(parsed.Query().Get("auth"))
+			if authKey != "" {
+				return authKey
+			}
+		}
+	}
+}
+
+func readTextFile(path string) (string, error) {
+	payload, err := os.ReadFile(strings.TrimSpace(path))
+	if err != nil {
+		return "", fmt.Errorf("trackers: AR read text file: %w", err)
+	}
+	return string(payload), nil
+}
+
+func readTextFileNoErr(path string) string {
+	payload, err := readTextFile(path)
+	if err != nil {
+		return ""
+	}
+	return payload
+}
+
+func isSD(resolution string) bool {
+	value := strings.ToLower(strings.TrimSpace(resolution))
+	return strings.Contains(value, "576") || strings.Contains(value, "480")
+}
+
+func isHighTier(resolution string) bool {
+	value := strings.ToLower(strings.TrimSpace(resolution))
+	return strings.Contains(value, "2160") || strings.Contains(value, "4320") || strings.Contains(value, "8640")
+}
+
+func collapseDots(value string) string {
+	cleaned := strings.TrimSpace(value)
+	for strings.Contains(cleaned, "..") {
+		cleaned = strings.ReplaceAll(cleaned, "..", ".")
+	}
+	return strings.Trim(cleaned, ".")
+}
+
+func containsAny(value string, needles []string) bool {
+	for _, needle := range needles {
+		if strings.Contains(value, needle) {
+			return true
+		}
+	}
+	return false
+}
+
+func uniqueStrings(values []string) []string {
+	seen := map[string]struct{}{}
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		key := strings.ToLower(trimmed)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}
+
+func matchAt(values []string, idx int) string {
+	if idx < len(values) {
+		return values[idx]
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/ar/upload_test.go b/internal/trackers/impl/standalone/ar/upload_test.go
new file mode 100644
index 00000000..ff2f2e25
--- /dev/null
+++ b/internal/trackers/impl/standalone/ar/upload_test.go
@@ -0,0 +1,462 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ar
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveARNameAddsNoGRP(t *testing.T) {
+	t.Parallel()
+
+	got := resolveARName(api.UploadSubject{
+		SourcePath: "C:/data/My Movie (2024).mkv",
+		Release:    api.ReleaseInfo{Title: "My Movie", Year: 2024},
+	})
+	if got != "My.Movie.2024-NoGRP" {
+		t.Fatalf("unexpected AR name %q", got)
+	}
+}
+
+func TestResolveARNameUsesSceneName(t *testing.T) {
+	t.Parallel()
+
+	got := resolveARName(api.UploadSubject{
+		Scene:     true,
+		SceneName: "Scene.Release-GRP",
+		Tag:       "-GRP",
+	})
+	if got != "Scene.Release-GRP" {
+		t.Fatalf("expected scene name, got %q", got)
+	}
+}
+
+type captureLogger struct {
+	warnings []string
+}
+
+func (l *captureLogger) Tracef(string, ...any) {}
+func (l *captureLogger) Debugf(string, ...any) {}
+func (l *captureLogger) Infof(string, ...any)  {}
+func (l *captureLogger) Errorf(string, ...any) {}
+func (l *captureLogger) Warnf(format string, _ ...any) {
+	l.warnings = append(l.warnings, strings.TrimSpace(format))
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+func arTestResponse(req *http.Request, body string) *http.Response {
+	return &http.Response{
+		StatusCode: http.StatusOK,
+		Header:     make(http.Header),
+		Body:       io.NopCloser(strings.NewReader(body)),
+		Request:    req,
+	}
+}
+
+func TestPersistLoginCookiesReturnsAuthHelperUnavailable(t *testing.T) {
+	t.Parallel()
+
+	logger := &captureLogger{}
+	err := persistLoginCookies(context.Background(), filepath.Join(t.TempDir(), "upbrr.db"), logger, []*http.Cookie{{Name: "session", Value: "abc"}})
+	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
+		t.Fatalf("expected auth helper unavailable error, got %v", err)
+	}
+	if len(logger.warnings) != 0 {
+		t.Fatalf("unexpected warning after hard persistence failure: %v", logger.warnings)
+	}
+}
+
+func TestPersistLoginCookiesRejectsEmptyJarWithoutReplacingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+
+	err := persistLoginCookies(ctx, dbPath, api.NopLogger{}, nil)
+	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
+		t.Fatalf("expected empty login cookie error, got %v", err)
+	}
+	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR")
+	if err != nil {
+		t.Fatalf("LoadTrackerCookieMap: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatal("empty jar must preserve previous cookies")
+	}
+}
+
+func TestEnsureLoginPersistenceAvailableRequiresWebAuth(t *testing.T) {
+	t.Parallel()
+
+	err := ensureLoginPersistenceAvailable(filepath.Join(t.TempDir(), "upbrr.db"))
+	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
+		t.Fatalf("expected auth helper unavailable preflight, got %v", err)
+	}
+}
+
+func TestWriteAuthKeyUsesEncryptedStateAndDeletesLegacyFile(t *testing.T) {
+	t.Parallel()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	legacyPath := authPath(dbPath)
+	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o755); err != nil {
+		t.Fatalf("mkdir legacy dir: %v", err)
+	}
+	if err := os.WriteFile(legacyPath, []byte("legacy-key"), 0o600); err != nil {
+		t.Fatalf("seed legacy auth key: %v", err)
+	}
+
+	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err != nil {
+		t.Fatalf("writeAuthKey: %v", err)
+	}
+	if got := readAuthKey(context.Background(), dbPath); got != "encrypted-key" {
+		t.Fatal("expected encrypted auth key")
+	}
+	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
+		t.Fatalf("expected legacy auth key removed, stat err=%v", err)
+	}
+}
+
+func TestWriteAuthKeyRollsBackEncryptedStateOnLegacyDeleteFailure(t *testing.T) {
+	t.Parallel()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	legacyPath := authPath(dbPath)
+	if err := os.MkdirAll(filepath.Join(legacyPath, "blocked"), 0o755); err != nil {
+		t.Fatalf("seed legacy auth path as non-empty dir: %v", err)
+	}
+
+	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err == nil {
+		t.Fatal("expected legacy cleanup failure")
+	} else if !strings.Contains(err.Error(), "remove legacy auth key") {
+		t.Fatalf("expected legacy cleanup error, got %v", err)
+	}
+	if _, err := trackerauth.LoadAuthState(context.Background(), dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
+		t.Fatalf("expected encrypted auth key rollback, got %v", err)
+	}
+	if _, err := os.Stat(legacyPath); err != nil {
+		t.Fatalf("expected failed legacy cleanup path to remain, stat err=%v", err)
+	}
+}
+
+func TestWriteAuthKeyFallsBackToExistingLegacyFileWhenWebAuthUnavailable(t *testing.T) {
+	t.Parallel()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	legacyPath := authPath(dbPath)
+	if err := os.MkdirAll(filepath.Dir(legacyPath), 0o755); err != nil {
+		t.Fatalf("mkdir legacy dir: %v", err)
+	}
+	if err := os.WriteFile(legacyPath, []byte("legacy-key"), 0o600); err != nil {
+		t.Fatalf("seed legacy auth key: %v", err)
+	}
+
+	if err := writeAuthKey(context.Background(), dbPath, "updated-legacy-key"); err != nil {
+		t.Fatalf("writeAuthKey: %v", err)
+	}
+	if got := readAuthKey(context.Background(), dbPath); got != "updated-legacy-key" {
+		t.Fatal("expected updated legacy auth key")
+	}
+}
+
+func TestWriteAuthKeySucceedsWhenLegacyFileAbsent(t *testing.T) {
+	t.Parallel()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+
+	if err := writeAuthKey(context.Background(), dbPath, "encrypted-key"); err != nil {
+		t.Fatalf("writeAuthKey: %v", err)
+	}
+	if got := readAuthKey(context.Background(), dbPath); got != "encrypted-key" {
+		t.Fatal("expected encrypted auth key")
+	}
+}
+
+func TestWriteAuthKeyWithoutWebAuthReturnsPersistenceFailure(t *testing.T) {
+	t.Parallel()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := writeAuthKey(context.Background(), dbPath, "session-key"); !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
+		t.Fatalf("expected auth helper unavailable error, got %v", err)
+	}
+	if _, err := os.Stat(authPath(dbPath)); !os.IsNotExist(err) {
+		t.Fatalf("expected no plaintext auth key, stat err=%v", err)
+	}
+}
+
+func TestPersistLoginAuthRestoresPreviousCookiesWhenAuthKeyWriteFails(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	forcedErr := errors.New("forced auth key failure")
+
+	err := persistLoginAuthWithWriter(
+		ctx,
+		dbPath,
+		api.NopLogger{},
+		[]*http.Cookie{{Name: "session", Value: "new"}},
+		"new-auth-key",
+		func(context.Context, string, string) error { return forcedErr },
+	)
+	if !errors.Is(err, forcedErr) {
+		t.Fatalf("expected forced auth key failure, got %v", err)
+	}
+	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR")
+	if err != nil {
+		t.Fatalf("LoadTrackerCookieMap: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatal("expected previous cookies restored")
+	}
+}
+
+func TestPersistLoginAuthRestoresPreviousCookiesWhenCallerContextCanceledDuringWrite(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := cookiepkg.SaveTrackerCookieMap(context.Background(), dbPath, "AR", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	forcedErr := errors.New("forced auth key failure")
+
+	err := persistLoginAuthWithWriter(
+		ctx,
+		dbPath,
+		api.NopLogger{},
+		[]*http.Cookie{{Name: "session", Value: "new"}},
+		"new-auth-key",
+		func(context.Context, string, string) error {
+			cancel()
+			return forcedErr
+		},
+	)
+	if !errors.Is(err, forcedErr) {
+		t.Fatalf("expected forced auth key failure, got %v", err)
+	}
+	values, err := cookiepkg.LoadTrackerCookieMap(context.Background(), dbPath, "AR")
+	if err != nil {
+		t.Fatalf("LoadTrackerCookieMap: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatal("expected previous cookies restored after cancellation")
+	}
+}
+
+func TestPersistLoginAuthRemovesNewCookiesWhenAuthKeyWriteFails(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	forcedErr := errors.New("forced auth key failure")
+
+	err := persistLoginAuthWithWriter(
+		ctx,
+		dbPath,
+		api.NopLogger{},
+		[]*http.Cookie{{Name: "session", Value: "new"}},
+		"new-auth-key",
+		func(context.Context, string, string) error { return forcedErr },
+	)
+	if !errors.Is(err, forcedErr) {
+		t.Fatalf("expected forced auth key failure, got %v", err)
+	}
+	if _, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "AR"); err == nil {
+		t.Fatal("expected rollback to remove newly persisted cookies")
+	}
+}
+
+func TestLoginFallbackDoesNotPersistAuthKeyBeforeCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		t.Fatalf("cookiejar.New: %v", err)
+	}
+	client := &http.Client{
+		Jar: jar,
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			switch req.URL.String() {
+			case arLoginURL:
+				return arTestResponse(req, "<html>logged in without inline auth</html>"), nil
+			case arBrowseURL:
+				return arTestResponse(req, `<a href="/torrents.php?action=download&id=1&auth=session-key">Download</a>`), nil
+			default:
+				t.Fatalf("unexpected request URL %s", req.URL.String())
+				return nil, nil
+			}
+		}),
+	}
+
+	authKey, err := login(ctx, client, config.TrackerConfig{Username: "user", Password: "pass"}, dbPath)
+	if err != nil {
+		t.Fatalf("login: %v", err)
+	}
+	if authKey != "session-key" {
+		t.Fatalf("expected auth key from validation page, got %q", authKey)
+	}
+	if _, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
+		t.Fatalf("login fallback must not persist auth key before cookie save, got %v", err)
+	}
+
+	if err := persistLoginAuth(ctx, dbPath, api.NopLogger{}, nil, authKey); err == nil || !strings.Contains(err.Error(), "no usable cookies") {
+		t.Fatalf("expected cookie persistence failure, got %v", err)
+	}
+	if _, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey); !errors.Is(err, trackerauth.ErrAuthStateNotFound) {
+		t.Fatalf("cookie persistence failure must leave no new auth key, got %v", err)
+	}
+}
+
+func TestLoginFallbackPrefersCurrentResponseKeyAndPreservesPreviousAuthKeyOnCookieFailure(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newARAuthTestDB(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	if err := trackerauth.SaveAuthState(ctx, dbPath, "AR", arAuthKeyKey, "previous-key"); err != nil {
+		t.Fatalf("SaveAuthState: %v", err)
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		t.Fatalf("cookiejar.New: %v", err)
+	}
+	client := &http.Client{
+		Jar: jar,
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			switch req.URL.String() {
+			case arLoginURL:
+				return arTestResponse(req, "<html>logged in without inline auth</html>"), nil
+			case arBrowseURL:
+				return arTestResponse(req, `<a href="/torrents.php?action=download&id=1&auth=new-key">Download</a>`), nil
+			default:
+				t.Fatalf("unexpected request URL %s", req.URL.String())
+				return nil, nil
+			}
+		}),
+	}
+
+	authKey, err := login(ctx, client, config.TrackerConfig{Username: "user", Password: "pass"}, dbPath)
+	if err != nil {
+		t.Fatalf("login: %v", err)
+	}
+	if authKey != "new-key" {
+		t.Fatalf("expected current response auth key, got %q", authKey)
+	}
+	if err := persistLoginAuth(ctx, dbPath, api.NopLogger{}, nil, authKey); err == nil || !strings.Contains(err.Error(), "no usable cookies") {
+		t.Fatalf("expected cookie persistence failure, got %v", err)
+	}
+	got, err := trackerauth.LoadAuthState(ctx, dbPath, "AR", arAuthKeyKey)
+	if err != nil {
+		t.Fatalf("LoadAuthState: %v", err)
+	}
+	if got != "previous-key" {
+		t.Fatal("cookie persistence failure changed previous auth key")
+	}
+}
+
+func newARAuthTestDB(t *testing.T) string {
+	t.Helper()
+
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	repo, err := servicedb.OpenWithLogger(dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("open repo: %v", err)
+	}
+	if err := repo.Migrate(); err != nil {
+		_ = repo.Close()
+		t.Fatalf("migrate repo: %v", err)
+	}
+	if err := repo.Close(); err != nil {
+		t.Fatalf("close repo: %v", err)
+	}
+	return dbPath
+}
+
+func TestBuildDatabaseLinksSkipsTVDBForMovie(t *testing.T) {
+	t.Parallel()
+
+	got := buildDatabaseLinks(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE", TVDBID: 456},
+	})
+	if strings.Contains(got, "thetvdb.com") {
+		t.Fatalf("did not expect tvdb link for movie description, got %q", got)
+	}
+}
+
+func TestBuildDatabaseLinksIncludesTVDBForMediaInfoTV(t *testing.T) {
+	t.Parallel()
+
+	got := buildDatabaseLinks(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 456},
+	})
+	if !strings.Contains(got, "thetvdb.com/?id=456") {
+		t.Fatalf("expected tvdb link for MediaInfo TV description, got %q", got)
+	}
+}
+
+func TestBuildDatabaseLinksIncludesTVDBForTV(t *testing.T) {
+	t.Parallel()
+
+	got := buildDatabaseLinks(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 456},
+	})
+	if !strings.Contains(got, "thetvdb.com/?id=456") {
+		t.Fatalf("expected tvdb link for TV description, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/asc/constants.go b/internal/trackers/impl/standalone/asc/constants.go
similarity index 100%
rename from internal/trackers/impl/asc/constants.go
rename to internal/trackers/impl/standalone/asc/constants.go
diff --git a/internal/trackers/impl/standalone/asc/definition.go b/internal/trackers/impl/standalone/asc/definition.go
new file mode 100644
index 00000000..03ba7367
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/definition.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets, req.TrackerConfig.CustomLayout)
+	return trackers.DescriptionResult{
+		Group:       "asc",
+		Description: strings.TrimSpace(description),
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/asc/definition_test.go b/internal/trackers/impl/standalone/asc/definition_test.go
new file mode 100644
index 00000000..3501cf7a
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/definition_test.go
@@ -0,0 +1,117 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func prepareDryRun(ctx context.Context, input trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	input.Intent = trackers.PreparationIntentDryRun
+	plan, failure := New().Prepare(ctx, input)
+	if failure != nil {
+		return api.TrackerDryRunEntry{}, failure
+	}
+	return plan.DryRun(), nil
+}
+
+const testCookieFileName = "ASC.txt"
+
+func TestDefinitionBuildUploadDryRunBlockedWithoutCookies(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "ASC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "movie.mkv"),
+			TorrentPath: torrentPath,
+			Release: api.ReleaseInfo{
+				Title:      "Movie",
+				Year:       2024,
+				Resolution: "1080p",
+			},
+			Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Poster:   "https://img/poster.jpg",
+					Overview: "Overview",
+					Genres:   "Drama",
+				},
+				IMDB: &api.IMDBMetadata{IMDbIDText: "tt1234567"},
+			},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")},
+		}),
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if entry.Status != "blocked" {
+		t.Fatalf("expected blocked status, got %q", entry.Status)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunQuestionnaireForMissingMetadata(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	cookieDir := filepath.Join(tmp, "cookies")
+	if err := os.MkdirAll(cookieDir, 0o700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	content := "# Netscape HTTP Cookie File\n.cliente.amigos-share.club\tTRUE\t/\tTRUE\t0\tsession\tcookievalue\n"
+	if err := os.WriteFile(filepath.Join(cookieDir, testCookieFileName), []byte(content), 0o600); err != nil {
+		t.Fatalf("write cookie: %v", err)
+	}
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "ASC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "movie.mkv"),
+			TorrentPath: torrentPath,
+			Release: api.ReleaseInfo{
+				Title:      "Movie",
+				Year:       2024,
+				Resolution: "1080p",
+			},
+			Identity: api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Poster: "https://img/poster.jpg"},
+				IMDB: &api.IMDBMetadata{IMDbIDText: "tt1234567"},
+			},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")},
+		}),
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if entry.Questionnaire == nil {
+		t.Fatal("expected questionnaire")
+	}
+	if got := len(entry.Questionnaire.Fields); got != 2 {
+		t.Fatalf("expected 2 questionnaire fields, got %d", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/asc/description.go b/internal/trackers/impl/standalone/asc/description.go
new file mode 100644
index 00000000..f4b0919d
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/description.go
@@ -0,0 +1,742 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/metadata/tmdb"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type layoutData struct {
+	Images  map[string]string
+	Ratings []map[string]any
+}
+
+type richCreditItem struct {
+	ID          int    `json:"id"`
+	Name        string `json:"name"`
+	Character   string `json:"character"`
+	ProfilePath string `json:"profile_path"`
+}
+
+type richSeasonItem struct {
+	AirDate      string `json:"air_date"`
+	EpisodeCount *int   `json:"episode_count"`
+	ID           int    `json:"id"`
+	Name         string `json:"name"`
+	Overview     string `json:"overview"`
+	PosterPath   string `json:"poster_path"`
+	SeasonNumber int    `json:"season_number"`
+}
+
+type richEpisodeDetails struct {
+	Name      string `json:"name"`
+	Overview  string `json:"overview"`
+	StillPath string `json:"still_path"`
+}
+
+type richMediaResponse struct {
+	VoteAverage float64 `json:"vote_average"`
+	Homepage    string  `json:"homepage"`
+}
+
+func tmdbCachePath(dbPath string, tmdbID int, suffix string) string {
+	if strings.TrimSpace(dbPath) == "" {
+		return ""
+	}
+	cacheRoot, err := db.Subdir(dbPath, "cache")
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(cacheRoot, fmt.Sprintf("tmdb_localized_%d_%s.json", tmdbID, suffix))
+}
+
+func fetchRichMedia(ctx context.Context, client *tmdb.Client, tmdbID int, category string, cachePath string) (richMediaResponse, error) {
+	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
+		TMDBID:    tmdbID,
+		Category:  strings.ToLower(category),
+		DataType:  "main",
+		CachePath: cachePath,
+	})
+	if err != nil {
+		return richMediaResponse{}, fmt.Errorf("fetch rich media: %w", err)
+	}
+	var resp richMediaResponse
+	if vote, ok := data["vote_average"].(float64); ok {
+		resp.VoteAverage = vote
+	}
+	if homepage, ok := data["homepage"].(string); ok {
+		resp.Homepage = homepage
+	}
+	return resp, nil
+}
+
+func fetchRichCredits(ctx context.Context, client *tmdb.Client, tmdbID int, category string, cachePath string) ([]richCreditItem, error) {
+	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
+		TMDBID:           tmdbID,
+		Category:         strings.ToLower(category),
+		DataType:         "main",
+		AppendToResponse: "credits",
+		CachePath:        cachePath,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("fetch rich credits: %w", err)
+	}
+	credits, ok := data["credits"].(map[string]any)
+	if !ok {
+		credits = data
+	}
+	castRaw, ok := credits["cast"].([]any)
+	if !ok {
+		return nil, errors.New("no cast found")
+	}
+	var cast []richCreditItem
+	for _, item := range castRaw {
+		m, ok := item.(map[string]any)
+		if !ok {
+			continue
+		}
+		var credit richCreditItem
+		if idVal, ok := m["id"].(float64); ok {
+			credit.ID = int(idVal)
+		}
+		if nameVal, ok := m["name"].(string); ok {
+			credit.Name = nameVal
+		}
+		if charVal, ok := m["character"].(string); ok {
+			credit.Character = charVal
+		}
+		if profileVal, ok := m["profile_path"].(string); ok {
+			credit.ProfilePath = profileVal
+		}
+		cast = append(cast, credit)
+	}
+	return cast, nil
+}
+
+func fetchRichSeasons(ctx context.Context, client *tmdb.Client, tmdbID int, cachePath string) ([]richSeasonItem, error) {
+	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
+		TMDBID:    tmdbID,
+		Category:  "tv",
+		DataType:  "main",
+		Language:  "pt-BR",
+		CachePath: cachePath,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("fetch rich seasons: %w", err)
+	}
+	seasonsRaw, ok := data["seasons"].([]any)
+	if !ok {
+		return nil, errors.New("no seasons found")
+	}
+	var seasons []richSeasonItem
+	for _, item := range seasonsRaw {
+		m, ok := item.(map[string]any)
+		if !ok {
+			continue
+		}
+		var season richSeasonItem
+		if airVal, ok := m["air_date"].(string); ok {
+			season.AirDate = airVal
+		}
+		if countVal, ok := m["episode_count"].(float64); ok {
+			c := int(countVal)
+			season.EpisodeCount = &c
+		}
+		if idVal, ok := m["id"].(float64); ok {
+			season.ID = int(idVal)
+		}
+		if nameVal, ok := m["name"].(string); ok {
+			season.Name = nameVal
+		}
+		if overVal, ok := m["overview"].(string); ok {
+			season.Overview = overVal
+		}
+		if posterVal, ok := m["poster_path"].(string); ok {
+			season.PosterPath = posterVal
+		}
+		if numVal, ok := m["season_number"].(float64); ok {
+			season.SeasonNumber = int(numVal)
+		}
+		seasons = append(seasons, season)
+	}
+	return seasons, nil
+}
+
+func fetchRichEpisode(ctx context.Context, client *tmdb.Client, tmdbID, season, episode int, cachePath string) (richEpisodeDetails, error) {
+	data, err := client.GetLocalizedData(ctx, tmdb.LocalizedDataInput{
+		TMDBID:    tmdbID,
+		Category:  "tv",
+		DataType:  "episode",
+		Season:    season,
+		Episode:   episode,
+		Language:  "pt-BR",
+		CachePath: cachePath,
+	})
+	if err != nil {
+		return richEpisodeDetails{}, fmt.Errorf("fetch rich episode: %w", err)
+	}
+	var ep richEpisodeDetails
+	if nameVal, ok := data["name"].(string); ok {
+		ep.Name = nameVal
+	}
+	if overVal, ok := data["overview"].(string); ok {
+		ep.Overview = overVal
+	}
+	if stillVal, ok := data["still_path"].(string); ok {
+		ep.StillPath = stillVal
+	}
+	return ep, nil
+}
+
+func buildDescription(ctx context.Context, meta api.UploadSubject, cfg config.Config, assets trackers.DescriptionAssets, layoutID string) string {
+	if assets.Override && strings.TrimSpace(assets.Description) != "" {
+		return strings.TrimSpace(assets.Description)
+	}
+	layout, _ := fetchLayout(ctx, cfg.MainSettings.DBPath, meta, layoutID)
+	parts := []string{"[center]"}
+
+	for idx := 1; idx <= 3; idx++ {
+		if image := layout.Images[fmt.Sprintf("BARRINHA_CUSTOM_T_%d", idx)]; image != "" {
+			parts = append(parts, formatImage(image))
+		}
+	}
+	if image := layout.Images["BARRINHA_APRESENTA"]; image != "" {
+		parts = append(parts, formatImage(image))
+	}
+	parts = append(parts, "[size=3]"+resolveUploadTitle(meta)+"[/size]")
+
+	appendSection := func(key string, content string) {
+		if strings.TrimSpace(content) == "" {
+			return
+		}
+		if image := layout.Images[key]; image != "" {
+			parts = append(parts, formatImage(image))
+		}
+		parts = append(parts, content)
+	}
+
+	apiKey := strings.TrimSpace(cfg.MainSettings.TMDBAPI)
+	tmdbID := meta.Identity.TMDBID
+
+	// TMDB Sub-queries
+	var richMedia *richMediaResponse
+	var richCast []richCreditItem
+	var richSeasons []richSeasonItem
+	var richEpisode *richEpisodeDetails
+
+	if apiKey != "" && tmdbID > 0 {
+		tmdbClient := tmdb.NewClient(nil, nil, apiKey)
+		dbPath := cfg.MainSettings.DBPath
+
+		if media, err := fetchRichMedia(ctx, tmdbClient, tmdbID, categoryOf(meta), tmdbCachePath(dbPath, tmdbID, "main")); err == nil {
+			richMedia = &media
+		}
+		if castList, err := fetchRichCredits(ctx, tmdbClient, tmdbID, categoryOf(meta), tmdbCachePath(dbPath, tmdbID, "credits")); err == nil {
+			richCast = castList
+		}
+		if categoryOf(meta) == "TV" {
+			if seasons, err := fetchRichSeasons(ctx, tmdbClient, tmdbID, tmdbCachePath(dbPath, tmdbID, "pt_seasons")); err == nil {
+				richSeasons = seasons
+			}
+			if meta.SeasonInt > 0 && meta.EpisodeInt > 0 {
+				suffix := fmt.Sprintf("ep_%d_%d", meta.SeasonInt, meta.EpisodeInt)
+				if ep, err := fetchRichEpisode(ctx, tmdbClient, tmdbID, meta.SeasonInt, meta.EpisodeInt, tmdbCachePath(dbPath, tmdbID, suffix)); err == nil {
+					richEpisode = &ep
+				}
+			}
+		}
+	}
+
+	// 1. Poster
+	if poster := resolvePoster(meta); poster != "" {
+		poster = strings.ReplaceAll(poster, "/t/p/original/", "/t/p/w500/")
+		appendSection("BARRINHA_CAPA", formatImage(poster))
+	}
+
+	// 2. Overview
+	appendSection("BARRINHA_SINOPSE", resolveOverview(meta, standalone.QuestionnaireAnswers(meta, "ASC")))
+
+	// 3. Episode Specific Section
+	if categoryOf(meta) == "TV" && richEpisode != nil {
+		if richEpisode.Name != "" && richEpisode.Overview != "" {
+			parts = append(parts, fmt.Sprintf("[size=4][b]Episódio:[/b] %s[/size]", richEpisode.Name))
+			if strings.TrimSpace(richEpisode.StillPath) != "" {
+				stillURL := "https://image.tmdb.org/t/p/w300" + strings.TrimSpace(richEpisode.StillPath)
+				parts = append(parts, formatImage(stillURL))
+			}
+			parts = append(parts, richEpisode.Overview)
+		}
+	}
+
+	// 4. Technical Sheet
+	appendSection("BARRINHA_FICHA_TECNICA", buildTechnicalSheet(meta, richMedia))
+
+	// 5. Production Companies
+	if prodComp := buildProductionCompanies(meta); prodComp != "" {
+		parts = append(parts, prodComp)
+	}
+
+	// 6. Cast
+	appendSection("BARRINHA_ELENCO", buildCastSection(meta, richCast))
+
+	// 7. Seasons Section (TV Packs / TV Seasons list)
+	if categoryOf(meta) == "TV" && len(richSeasons) > 0 {
+		var seasonsContent []string
+		for _, s := range richSeasons {
+			seasonName := strings.TrimSpace(s.Name)
+			if seasonName == "" {
+				seasonName = fmt.Sprintf("Temporada %d", s.SeasonNumber)
+			}
+			posterTemp := ""
+			if strings.TrimSpace(s.PosterPath) != "" {
+				posterTemp = formatImage("https://image.tmdb.org/t/p/w185" + strings.TrimSpace(s.PosterPath))
+			}
+			overviewTemp := ""
+			if strings.TrimSpace(s.Overview) != "" {
+				overviewTemp = "\n\nSinopse:\n" + strings.TrimSpace(s.Overview)
+			}
+			var innerContentParts []string
+			if s.AirDate != "" {
+				innerContentParts = append(innerContentParts, "Data: "+formatDate(s.AirDate))
+			}
+			if s.EpisodeCount != nil {
+				innerContentParts = append(innerContentParts, fmt.Sprintf("Episódios: %d", *s.EpisodeCount))
+			}
+			if posterTemp != "" {
+				innerContentParts = append(innerContentParts, posterTemp)
+			}
+			if overviewTemp != "" {
+				innerContentParts = append(innerContentParts, overviewTemp)
+			}
+			innerContent := strings.Join(innerContentParts, "\n")
+			seasonsContent = append(seasonsContent, fmt.Sprintf("\n[spoiler=%s]%s[/spoiler]\n", seasonName, innerContent))
+		}
+		appendSection("BARRINHA_EPISODIOS", strings.Join(seasonsContent, ""))
+	}
+
+	// 8. Ratings Section
+	var ratingsList []map[string]any
+	ratingsList = append(ratingsList, layout.Ratings...)
+	hasIMDbRating := false
+	hasTMDbRating := false
+	for _, r := range ratingsList {
+		source, _ := r["Source"].(string)
+		if source == "Internet Movie Database" {
+			hasIMDbRating = true
+		}
+		if source == "TMDb" {
+			hasTMDbRating = true
+		}
+	}
+	if !hasIMDbRating && meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Rating > 0 {
+		ratingsList = append(ratingsList, map[string]any{
+			"Source": "Internet Movie Database",
+			"Value":  fmt.Sprintf("%.1f/10", meta.ProviderMetadata.IMDB.Rating),
+		})
+	}
+	if !hasTMDbRating && richMedia != nil && richMedia.VoteAverage > 0 {
+		ratingsList = append(ratingsList, map[string]any{
+			"Source": "TMDb",
+			"Value":  fmt.Sprintf("%.1f/10", richMedia.VoteAverage),
+		})
+	}
+
+	criticsKey := "BARRINHA_CRITICAS" //nolint:misspell
+	if categoryOf(meta) == "MOVIE" && layout.Images["BARRINHA_INFORMACOES"] != "" {
+		criticsKey = "BARRINHA_INFORMACOES"
+	}
+	appendSection(criticsKey, buildRatingsBBCode(meta, ratingsList))
+
+	// 9. MediaInfo/BDInfo
+	if media := buildMediaInfo(meta, cfg.MainSettings.DBPath); media != "" {
+		parts = append(parts, "[spoiler=Informações do Arquivo]\n[left][font=Courier New]"+media+"[/font][/left][/spoiler]")
+	}
+	if notes := sanitizeDescriptionNotes(assets.Description); notes != "" {
+		parts = append(parts, notes)
+	}
+	if customHeader := strings.TrimSpace(cfg.Description.CustomDescriptionHeader); customHeader != "" {
+		parts = append(parts, customHeader)
+	}
+
+	for idx := 1; idx <= 3; idx++ {
+		if image := layout.Images[fmt.Sprintf("BARRINHA_CUSTOM_B_%d", idx)]; image != "" {
+			parts = append(parts, formatImage(image))
+		}
+	}
+	parts = append(parts, "[/center]")
+	parts = append(parts, "[center][url=https://github.com/autobrr/upbrr]Upload realizado via upbrr[/url][/center]")
+	return strings.TrimSpace(strings.Join(filterEmpty(parts), "\n\n"))
+}
+
+func fetchLayout(ctx context.Context, dbPath string, meta api.UploadSubject, layoutID string) (layoutData, error) {
+	cached, err := readLayoutCache(dbPath, layoutID)
+	if err == nil {
+		return cached, nil
+	}
+	cookies, _, err := LoadCookies(ctx, dbPath)
+	if err != nil {
+		return layoutData{}, err
+	}
+	form := url.Values{
+		"imdb":   {metautil.FirstNonEmptyTrimmed(resolveIMDbIDText(meta), "tt0013442")},
+		"layout": {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(layoutID), "2")},
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/search.php", strings.NewReader(form.Encode()))
+	if err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC create layout request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", userAgent)
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
+	if err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC fetch layout: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return layoutData{}, fmt.Errorf("layout fetch status %d", resp.StatusCode)
+	}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC read layout response: %w", err)
+	}
+	var payload map[string]json.RawMessage
+	if err := json.Unmarshal(body, &payload); err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout response: %s", redaction.RedactValue(err.Error(), nil))
+	}
+	var raw map[string]any
+	if err := json.Unmarshal(payload["ASC"], &raw); err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout data: %s", redaction.RedactValue(err.Error(), nil))
+	}
+	layout := normalizeLayout(raw)
+	_ = writeLayoutCache(dbPath, layoutID, payload["ASC"])
+	return layout, nil
+}
+
+func normalizeLayout(raw map[string]any) layoutData {
+	layout := layoutData{Images: make(map[string]string)}
+	for key, value := range raw {
+		if strings.HasPrefix(key, "BARRINHA_") {
+			text := strings.TrimSpace(fmt.Sprint(value))
+			if text != "" && text != "<nil>" {
+				layout.Images[key] = text
+			}
+		}
+	}
+	if ratingsVal, ok := raw["Ratings"]; ok {
+		if ratingsSlice, ok := ratingsVal.([]any); ok {
+			for _, r := range ratingsSlice {
+				if rMap, ok := r.(map[string]any); ok {
+					layout.Ratings = append(layout.Ratings, rMap)
+				}
+			}
+		}
+	}
+	return layout
+}
+
+func readLayoutCache(dbPath string, layoutID string) (layoutData, error) {
+	payload, err := os.ReadFile(layoutCachePath(dbPath, layoutID))
+	if err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC read layout cache: %w", err)
+	}
+	var raw map[string]any
+	if err := json.Unmarshal(payload, &raw); err != nil {
+		return layoutData{}, fmt.Errorf("trackers: ASC unmarshal layout cache: %w", err)
+	}
+	return normalizeLayout(raw), nil
+}
+
+func writeLayoutCache(dbPath string, layoutID string, payload []byte) error {
+	path := layoutCachePath(dbPath, layoutID)
+	if path == "" {
+		return errors.New("missing layout cache path")
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return fmt.Errorf("trackers: ASC create layout cache dir: %w", err)
+	}
+	if err := os.WriteFile(path, payload, 0o600); err != nil {
+		return fmt.Errorf("trackers: ASC write layout cache: %w", err)
+	}
+	return nil
+}
+
+func layoutCachePath(dbPath string, layoutID string) string {
+	if strings.TrimSpace(dbPath) == "" {
+		return ""
+	}
+	cacheRoot, err := db.Subdir(dbPath, "cache")
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(cacheRoot, "asc_layout_"+metautil.FirstNonEmptyTrimmed(strings.TrimSpace(layoutID), "2")+".json")
+}
+
+func buildTechnicalSheet(meta api.UploadSubject, richMedia *richMediaResponse) string {
+	items := make([]string, 0, 5)
+	if runtime := resolveRuntime(meta); runtime != "" {
+		items = append(items, "Duração: "+runtime)
+	}
+	if countries := resolveCountries(meta); countries != "" {
+		items = append(items, "País de Origem: "+countries)
+	}
+	if genres := resolveGenres(meta, standalone.QuestionnaireAnswers(meta, "ASC")); genres != "" {
+		items = append(items, "Gêneros: "+genres)
+	}
+	if releaseDate := resolveReleaseDate(meta); releaseDate != "" {
+		items = append(items, "Data de Lançamento: "+formatDate(releaseDate))
+	}
+	if richMedia != nil {
+		if homepageURL := sanitizeHomepageURL(richMedia.Homepage); homepageURL != "" {
+			items = append(items, fmt.Sprintf("Site: [url=%s]Clique aqui[/url]", homepageURL))
+		}
+	}
+	return strings.Join(items, "\n")
+}
+
+// sanitizeHomepageURL returns an absolute http or https homepage safe for ASC
+// BBCode URL attributes, rejecting literal or escaped URL-attribute delimiters.
+func sanitizeHomepageURL(rawURL string) string {
+	trimmed := strings.TrimSpace(rawURL)
+	if trimmed == "" || containsBBCodeURLAttributeUnsafeChar(trimmed) {
+		return ""
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil || !parsed.IsAbs() || strings.TrimSpace(parsed.Host) == "" {
+		return ""
+	}
+	scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
+	if scheme != "http" && scheme != "https" {
+		return ""
+	}
+	normalized := parsed.String()
+	if containsBBCodeURLAttributeUnsafeChar(normalized) || hasEscapedBBCodeURLAttributeUnsafeChar(parsed) {
+		return ""
+	}
+	return normalized
+}
+
+func containsBBCodeURLAttributeUnsafeChar(value string) bool {
+	if strings.ContainsAny(value, "[]\"'") {
+		return true
+	}
+	for _, r := range value {
+		if r < ' ' || r == 0x7f {
+			return true
+		}
+	}
+	return false
+}
+
+func hasEscapedBBCodeURLAttributeUnsafeChar(parsed *url.URL) bool {
+	if slices.ContainsFunc([]string{parsed.Path, parsed.Fragment}, containsBBCodeURLAttributeUnsafeChar) {
+		return true
+	}
+	encodedValues := []string{parsed.RawQuery}
+	if parsed.User != nil {
+		encodedValues = append(encodedValues, parsed.User.String())
+	}
+	for _, encoded := range encodedValues {
+		if encoded == "" {
+			continue
+		}
+		decoded, err := url.QueryUnescape(encoded)
+		if err != nil || containsBBCodeURLAttributeUnsafeChar(decoded) {
+			return true
+		}
+	}
+	return false
+}
+
+func buildProductionCompanies(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil || len(meta.ProviderMetadata.TMDB.ProductionCompanies) == 0 {
+		return ""
+	}
+	var parts []string
+	parts = append(parts, "[size=4][b]Produtoras[/b][/size]")
+	for _, comp := range meta.ProviderMetadata.TMDB.ProductionCompanies {
+		if strings.TrimSpace(comp.Name) == "" {
+			continue
+		}
+		logo := ""
+		if logoPath := strings.TrimSpace(comp.LogoPath); logoPath != "" {
+			logo = formatImage("https://image.tmdb.org/t/p/w45" + logoPath)
+		}
+		if logo != "" {
+			parts = append(parts, fmt.Sprintf("%s[size=2] - [b]%s[/b][/size]", logo, comp.Name))
+		} else {
+			parts = append(parts, fmt.Sprintf("[size=2][b]%s[/b][/size]", comp.Name))
+		}
+	}
+	return strings.Join(parts, "\n")
+}
+
+func buildCastSection(meta api.UploadSubject, richCast []richCreditItem) string {
+	if len(richCast) == 0 {
+		names := resolveCast(meta)
+		if len(names) == 0 {
+			return ""
+		}
+		limit := min(len(names), 10)
+		parts := make([]string, 0, limit)
+		for idx := range limit {
+			parts = append(parts, "[size=2][b]"+names[idx]+"[/b][/size]")
+		}
+		return strings.Join(parts, "\n")
+	}
+
+	limit := min(len(richCast), 10)
+	var parts []string
+	for _, person := range richCast[:limit] {
+		profileURL := "https://i.imgur.com/eCCCtFA.png"
+		if strings.TrimSpace(person.ProfilePath) != "" {
+			profileURL = "https://image.tmdb.org/t/p/w45" + strings.TrimSpace(person.ProfilePath)
+		}
+		tmdbURL := fmt.Sprintf("https://www.themoviedb.org/person/%d?language=pt-BR", person.ID)
+		imgTag := formatImage(profileURL)
+
+		charName := strings.TrimSpace(person.Character)
+		characterInfo := fmt.Sprintf("(%s)", person.Name)
+		if charName != "" {
+			characterInfo = fmt.Sprintf("(%s) como %s", person.Name, charName)
+		}
+
+		parts = append(parts, fmt.Sprintf("[url=%s]%s[/url]\n[size=2][b]%s[/b][/size]\n", tmdbURL, imgTag, characterInfo))
+	}
+	return strings.Join(parts, "")
+}
+
+func buildRatingsBBCode(meta api.UploadSubject, ratingsList []map[string]any) string {
+	if len(ratingsList) == 0 {
+		return ""
+	}
+	ratingsMap := map[string]string{
+		"Internet Movie Database": "[img]https://i.postimg.cc/Pr8Gv4RQ/IMDB.png[/img]",
+		"Rotten Tomatoes":         "[img]https://i.postimg.cc/rppL76qC/rotten.png[/img]",
+		"Metacritic":              "[img]https://i.postimg.cc/SKkH5pNg/Metacritic45x45.png[/img]",
+		"TMDb":                    "[img]https://i.postimg.cc/T13yyzyY/tmdb.png[/img]",
+	}
+	var parts []string
+	for _, rating := range ratingsList {
+		source, _ := rating["Source"].(string)
+		valueRaw := rating["Value"]
+		if source == "" || valueRaw == nil {
+			continue
+		}
+		value := strings.TrimSpace(fmt.Sprint(valueRaw))
+		imgTag, ok := ratingsMap[source]
+		if !ok {
+			continue
+		}
+		switch source {
+		case "Internet Movie Database":
+			imdbURL := ""
+			if meta.ProviderMetadata.IMDB != nil {
+				imdbURL = meta.ProviderMetadata.IMDB.IMDbURL
+			}
+			if imdbURL == "" && meta.Identity.IMDBID > 0 {
+				imdbURL = fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+			}
+			parts = append(parts, fmt.Sprintf("\n[url=%s]%s[/url]\n[b]%s[/b]\n", imdbURL, imgTag, value))
+		case "TMDb":
+			category := strings.ToLower(categoryOf(meta))
+			tmdbID := meta.Identity.TMDBID
+			parts = append(parts, fmt.Sprintf("[url=https://www.themoviedb.org/%s/%d]%s[/url]\n[b]%s[/b]\n", category, tmdbID, imgTag, value))
+		default:
+			parts = append(parts, fmt.Sprintf("%s\n[b]%s[/b]\n", imgTag, value))
+		}
+	}
+	return strings.Join(parts, "\n")
+}
+
+func formatDate(dateStr string) string {
+	dateStr = strings.TrimSpace(dateStr)
+	if dateStr == "" || strings.EqualFold(dateStr, "N/A") {
+		return "N/A"
+	}
+	if t, err := time.Parse("2006-01-02", dateStr); err == nil {
+		return t.Format("02/01/2006")
+	}
+	return dateStr
+}
+
+func buildMediaInfo(meta api.UploadSubject, dbPath string) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		text, _ := readBDSummary(meta, dbPath)
+		return text
+	case "DVD":
+		return metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
+	default:
+		return readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath))
+	}
+}
+
+func readBDSummary(meta api.UploadSubject, dbPath string) (string, error) {
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)))
+}
+
+func sanitizeDescriptionNotes(value string) string {
+	replacer := strings.NewReplacer(
+		"[user]", "", "[/user]", "",
+		"[align=left]", "", "[/align]", "",
+		"[align=right]", "", "[/align]", "",
+		"[alert]", "", "[/alert]", "",
+		"[note]", "", "[/note]", "",
+		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
+		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
+		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
+	)
+	return strings.TrimSpace(replacer.Replace(value))
+}
+
+func formatImage(value string) string {
+	if strings.TrimSpace(value) == "" {
+		return ""
+	}
+	return "[img]" + strings.TrimSpace(value) + "[/img]"
+}
+
+func filterEmpty(values []string) []string {
+	out := values[:0]
+	for _, value := range values {
+		if strings.TrimSpace(value) == "" {
+			continue
+		}
+		out = append(out, value)
+	}
+	return out
+}
diff --git a/internal/trackers/impl/standalone/asc/description_test.go b/internal/trackers/impl/standalone/asc/description_test.go
new file mode 100644
index 00000000..b3a4819e
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/description_test.go
@@ -0,0 +1,158 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"strings"
+	"testing"
+
+	descsvc "github.com/autobrr/upbrr/internal/description"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildTechnicalSheetHomepageURL(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		homepage string
+		want     string
+	}{
+		{
+			name:     "valid https",
+			homepage: "https://example.com/movie",
+			want:     "Site: [url=https://example.com/movie]Clique aqui[/url]",
+		},
+		{
+			name:     "valid http path and query",
+			homepage: "http://example.com/path/to/movie?utm_source=tmdb&lang=pt-BR",
+			want:     "Site: [url=http://example.com/path/to/movie?utm_source=tmdb&lang=pt-BR]Clique aqui[/url]",
+		},
+		{
+			name:     "valid encoded path query and fragment",
+			homepage: "https://example.com/path%20to/movie?name=A%2BB&ok=%25#frag%20ment",
+			want:     "Site: [url=https://example.com/path%20to/movie?name=A%2BB&ok=%25#frag%20ment]Clique aqui[/url]",
+		},
+		{
+			name:     "missing scheme",
+			homepage: "example.com/movie",
+		},
+		{
+			name:     "protocol relative",
+			homepage: "//example.com/movie",
+		},
+		{
+			name:     "missing host",
+			homepage: "https:///movie",
+		},
+		{
+			name:     "unsupported scheme",
+			homepage: "javascript:alert(1)",
+		},
+		{
+			name:     "bracket boundary",
+			homepage: "https://example.com/movie]broken",
+		},
+		{
+			name:     "quote boundary",
+			homepage: "https://example.com/movie\"broken",
+		},
+		{
+			name:     "newline boundary",
+			homepage: "https://example.com/movie\n[url=https://evil.test]",
+		},
+		{
+			name:     "encoded closing bracket boundary",
+			homepage: "https://example.com/movie%5Dbroken",
+		},
+		{
+			name:     "mixed case encoded opening bracket boundary",
+			homepage: "https://example.com/movie%5bbroken",
+		},
+		{
+			name:     "encoded quote boundary",
+			homepage: "https://example.com/movie?title=%22broken",
+		},
+		{
+			name:     "encoded single quote boundary",
+			homepage: "https://example.com/movie?title=%27broken",
+		},
+		{
+			name:     "encoded line feed boundary",
+			homepage: "https://example.com/movie?title=good%0Abad",
+		},
+		{
+			name:     "encoded carriage return boundary",
+			homepage: "https://example.com/movie?title=good%0Dbad",
+		},
+		{
+			name:     "encoded close tag payload",
+			homepage: "https://example.com/movie%5D%5B/url%5D%5Burl=https://evil.test%5D",
+		},
+		{
+			name:     "malformed percent escape",
+			homepage: "https://example.com/movie?title=%zz",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := buildTechnicalSheet(api.UploadSubject{}, &richMediaResponse{Homepage: tc.homepage})
+			if got != tc.want {
+				t.Fatalf("expected %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestBuildTechnicalSheetHomepageURLRejectsEncodedDelimiterThroughRender(t *testing.T) {
+	t.Parallel()
+
+	homepage := "https://example.com/movie%5D%5B/url%5D%5Burl=https://evil.test%5D"
+	sheet := buildTechnicalSheet(api.UploadSubject{}, &richMediaResponse{Homepage: homepage})
+	if sheet != "" {
+		t.Fatalf("expected encoded delimiter homepage to be omitted, got %q", sheet)
+	}
+	rendered := descsvc.Render(sheet)
+	if strings.Contains(rendered, "evil.test") || strings.Contains(rendered, "<a href=") {
+		t.Fatalf("expected encoded delimiter homepage to be absent from rendered output, got %q", rendered)
+	}
+}
+
+func TestHomepageURLFixLeavesOtherASCLinksUnchanged(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity: api.ExternalIdentity{
+			Category: "MOVIE",
+			IMDBID:   7654321,
+			TMDBID:   123,
+		},
+	}
+
+	cast := buildCastSection(meta, []richCreditItem{
+		{
+			ID:          42,
+			Name:        "Jane Example",
+			Character:   "Hero",
+			ProfilePath: "/profile.jpg",
+		},
+	})
+	if !strings.Contains(cast, "[url=https://www.themoviedb.org/person/42?language=pt-BR]") {
+		t.Fatalf("expected TMDB cast link to stay unchanged, got %q", cast)
+	}
+
+	ratings := buildRatingsBBCode(meta, []map[string]any{
+		{"Source": "Internet Movie Database", "Value": "7.8/10"},
+		{"Source": "TMDb", "Value": "8.2/10"},
+	})
+	if !strings.Contains(ratings, "[url=https://www.imdb.com/title/tt7654321]") {
+		t.Fatalf("expected IMDb rating link to stay unchanged, got %q", ratings)
+	}
+	if !strings.Contains(ratings, "[url=https://www.themoviedb.org/movie/123]") {
+		t.Fatalf("expected TMDB rating link to stay unchanged, got %q", ratings)
+	}
+}
diff --git a/internal/trackers/impl/standalone/asc/dupe.go b/internal/trackers/impl/standalone/asc/dupe.go
new file mode 100644
index 00000000..0d005743
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/dupe.go
@@ -0,0 +1,432 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+
+	"golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg    config.Config
+	http   *http.Client
+	logger api.Logger
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:    cfg,
+		http:   httpClient,
+		logger: logger,
+	}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if h.http == nil {
+		return dupe.Failed(dupe.FailureInternal, "ASC handler misconfigured: no HTTP client", nil)
+	}
+	if !meta.Anime && resolveASCIMDb(meta) == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for ASC dupe search", nil)
+	}
+
+	cookies, _, err := LoadCookies(ctx, h.cfg.MainSettings.DBPath)
+	if err != nil || len(cookies) == 0 {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid ASC cookies", nil)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, buildASCSearchURL(meta), nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "ASC request failed", fmt.Errorf("build ASC request: %w", err))
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+
+	resp, err := h.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "ASC request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return dupe.Failed(dupe.FailureResponseStatus, "ASC search returned non-success status", nil)
+	}
+
+	doc, err := html.Parse(resp.Body)
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "ASC response parse failed", err)
+	}
+
+	var entries []api.DupeEntry
+	var tasks []ascDetailTask
+	seen := make(map[string]struct{})
+	walkASCNodes(doc, &entries, &tasks, seen, resolveASCTitle(meta))
+
+	if len(tasks) > 0 {
+		var mu sync.Mutex
+		var wg sync.WaitGroup
+		sem := make(chan struct{}, 5)
+	taskLoop:
+		for _, t := range tasks {
+			select {
+			case <-ctx.Done():
+				break taskLoop
+			case sem <- struct{}{}:
+			}
+
+			wg.Add(1)
+			go func(t ascDetailTask) {
+				defer wg.Done()
+				defer func() { <-sem }()
+
+				name := "N/A"
+				reqFile, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://cliente.amigos-share.club/torrents-arquivos.php?id="+t.ID, nil)
+				if err != nil {
+					h.logger.Debugf("ASC filename request creation failed for ID %s: %v", t.ID, err)
+				} else {
+					reqFile.Header.Set("User-Agent", "upbrr")
+					for _, cookie := range cookies {
+						reqFile.AddCookie(cookie)
+					}
+					fileResp, err := h.http.Do(reqFile)
+					if err != nil {
+						h.logger.Debugf("ASC filename request failed for ID %s: %v", t.ID, err)
+					} else {
+						defer fileResp.Body.Close()
+						if fileResp.StatusCode < 200 || fileResp.StatusCode >= 300 {
+							h.logger.Debugf("ASC filename request returned non-success status %d for ID %s", fileResp.StatusCode, t.ID)
+						} else {
+							fileDoc, err := html.Parse(fileResp.Body)
+							if err != nil {
+								h.logger.Debugf("ASC filename parse failed for ID %s: %v", t.ID, err)
+							} else {
+								if parsedName := getASCFilenameFromFiles(fileDoc); parsedName != "" {
+									name = parsedName
+								} else {
+									h.logger.Debugf("ASC filename not found in response for ID %s", t.ID)
+								}
+							}
+						}
+					}
+				}
+
+				mu.Lock()
+				entries = append(entries, api.DupeEntry{
+					Name:     name,
+					ID:       t.ID,
+					Link:     t.Link,
+					SizeText: t.Size,
+				})
+				mu.Unlock()
+			}(t)
+		}
+		wg.Wait()
+	}
+
+	if err := ctx.Err(); err != nil {
+		return dupe.Failed(dupe.FailureRequest, "ASC search canceled", err)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func buildASCSearchURL(meta api.DuplicateSubject) string {
+	base := "https://cliente.amigos-share.club"
+	if meta.Anime {
+		return base + "/torrents-search.php?search=" + url.QueryEscape(resolveASCTitle(meta))
+	}
+	if strings.EqualFold(resolveASCCategory(meta), "TV") {
+		return base + "/busca-series.php?search=" + url.QueryEscape(resolveASCSeasonEpisode(meta)) + "&imdb=" + url.QueryEscape(resolveASCIMDb(meta))
+	}
+	return base + "/busca-filmes.php?search=&imdb=" + url.QueryEscape(resolveASCIMDb(meta))
+}
+
+type ascDetailTask struct {
+	ID   string
+	Link string
+	Size string
+}
+
+func walkASCNodes(n *html.Node, entries *[]api.DupeEntry, tasks *[]ascDetailTask, seen map[string]struct{}, baseTitle string) {
+	if n.Type == html.ElementNode && strings.EqualFold(n.Data, "li") {
+		if ascHasClass(n, "list-group-item") && ascHasClass(n, "dark-gray") {
+			processASCListItem(n, entries, tasks, seen, baseTitle)
+			return
+		}
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		walkASCNodes(c, entries, tasks, seen, baseTitle)
+	}
+}
+
+func processASCListItem(n *html.Node, entries *[]api.DupeEntry, tasks *[]ascDetailTask, seen map[string]struct{}, baseTitle string) {
+	var detailsHref string
+	var sizeText string
+	var badges []string
+
+	var walk func(*html.Node)
+	walk = func(child *html.Node) {
+		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "a") {
+			href := ascGetAttr(child, "href")
+			if strings.Contains(href, "torrents-details.php?id=") {
+				detailsHref = href
+			}
+		}
+		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "span") {
+			if ascHasClass(child, "badge-info") {
+				txt := strings.ToUpper(ascGetText(child))
+				if strings.Contains(txt, "GB") || strings.Contains(txt, "MB") {
+					sizeText = strings.TrimSpace(ascGetText(child))
+				}
+			} else if ascHasClass(child, "badge") {
+				badges = append(badges, strings.TrimSpace(ascGetText(child)))
+			}
+		}
+		for c := child.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(n)
+
+	if detailsHref == "" {
+		return
+	}
+
+	id := parseASCTorrentID(detailsHref)
+	if id == "" {
+		return
+	}
+	if _, ok := seen[id]; ok {
+		return
+	}
+	seen[id] = struct{}{}
+
+	link := absolutizeASCLink(detailsHref)
+
+	discTypes := []string{"BD25", "BD50", "BD66", "BD100", "DVD5", "DVD9"}
+	isDisc := false
+	for _, b := range badges {
+		bUp := strings.ToUpper(b)
+		if ascContainsAny(bUp, discTypes) {
+			isDisc = true
+			break
+		}
+	}
+
+	if isDisc {
+		year := "N/A"
+		resolution := "N/A"
+		diskType := "N/A"
+		videoCodec := "N/A"
+		audioCodec := "N/A"
+
+		codecTerms := []string{"MPEG-4", "AV1", "AVC", "H264", "H265", "HEVC", "MPEG-1", "MPEG-2", "VC-1", "VP6", "VP9"}
+		audioTerms := []string{"DTS", "AC3", "DDP", "E-AC-3", "TRUEHD", "ATMOS", "LPCM", "AAC", "FLAC"}
+		resTypes := []string{"4K", "2160P", "1080P", "720P", "480P"}
+
+		for _, b := range badges {
+			bUp := strings.ToUpper(b)
+			switch {
+			case len(bUp) == 4 && ascIsDigit(bUp):
+				year = bUp
+			case ascContainsAnyStrict(bUp, resTypes):
+				if bUp == "4K" {
+					resolution = "2160p"
+				} else {
+					resolution = bUp
+				}
+			case ascContainsAny(bUp, codecTerms):
+				videoCodec = strings.TrimSpace(b)
+			case ascContainsAny(bUp, audioTerms):
+				audioCodec = strings.TrimSpace(b)
+			case ascContainsAny(bUp, discTypes):
+				diskType = strings.TrimSpace(b)
+			}
+		}
+
+		name := fmt.Sprintf("%s %s %s %s %s %s", baseTitle, year, resolution, diskType, strings.ToUpper(videoCodec), strings.ToUpper(audioCodec))
+		*entries = append(*entries, api.DupeEntry{
+			Name:     strings.TrimSpace(name),
+			ID:       id,
+			Link:     link,
+			SizeText: sizeText,
+		})
+	} else {
+		*tasks = append(*tasks, ascDetailTask{
+			ID:   id,
+			Link: link,
+			Size: sizeText,
+		})
+	}
+}
+
+func ascContainsAnyStrict(s string, terms []string) bool {
+	return slices.Contains(terms, s)
+}
+
+func ascContainsAny(s string, terms []string) bool {
+	for _, t := range terms {
+		if strings.Contains(s, t) {
+			return true
+		}
+	}
+	return false
+}
+
+func ascIsDigit(s string) bool {
+	for _, c := range s {
+		if c < '0' || c > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+func ascHasClass(n *html.Node, class string) bool {
+	for _, attr := range n.Attr {
+		if strings.EqualFold(attr.Key, "class") {
+			for c := range strings.FieldsSeq(attr.Val) {
+				if strings.EqualFold(c, class) {
+					return true
+				}
+			}
+			return false
+		}
+	}
+	return false
+}
+
+func ascGetAttr(n *html.Node, key string) string {
+	for _, attr := range n.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return strings.TrimSpace(attr.Val)
+		}
+	}
+	return ""
+}
+
+func ascGetText(n *html.Node) string {
+	var b strings.Builder
+	var walk func(*html.Node)
+	walk = func(child *html.Node) {
+		if child.Type == html.TextNode {
+			b.WriteString(child.Data)
+		}
+		for c := child.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(n)
+	return b.String()
+}
+
+func getASCFilenameFromFiles(n *html.Node) string {
+	var walk func(*html.Node) string
+	walk = func(child *html.Node) string {
+		if child.Type == html.ElementNode && strings.EqualFold(child.Data, "li") && ascHasClass(child, "list-group-item") {
+			for c := child.FirstChild; c != nil; c = c.NextSibling {
+				switch c.Type {
+				case html.TextNode:
+					txt := strings.TrimSpace(c.Data)
+					if txt != "" {
+						return txt
+					}
+				case html.ElementNode:
+					txt := strings.TrimSpace(ascGetText(c))
+					if txt != "" {
+						return txt
+					}
+				case html.ErrorNode, html.DocumentNode, html.CommentNode, html.DoctypeNode, html.RawNode:
+					// ignore
+				}
+			}
+		}
+		for c := child.FirstChild; c != nil; c = c.NextSibling {
+			if txt := walk(c); txt != "" {
+				return txt
+			}
+		}
+		return ""
+	}
+	return walk(n)
+}
+
+func parseASCTorrentID(href string) string {
+	parsed, err := url.Parse(href)
+	if err == nil {
+		if id := strings.TrimSpace(parsed.Query().Get("id")); id != "" {
+			return id
+		}
+	}
+	parts := strings.Split(href, "id=")
+	if len(parts) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(strings.Split(parts[len(parts)-1], "&")[0])
+}
+
+func absolutizeASCLink(href string) string {
+	if strings.HasPrefix(href, "http://") || strings.HasPrefix(href, "https://") {
+		return href
+	}
+	return "https://cliente.amigos-share.club/" + strings.TrimPrefix(href, "/")
+}
+
+func resolveASCIMDb(meta api.DuplicateSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveASCCategory(meta api.DuplicateSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func resolveASCTitle(meta api.DuplicateSubject) string {
+	if strings.TrimSpace(meta.Release.Title) != "" {
+		return strings.TrimSpace(meta.Release.Title)
+	}
+	if strings.TrimSpace(meta.ReleaseName) != "" {
+		return strings.TrimSpace(meta.ReleaseName)
+	}
+	return strings.TrimSpace(meta.SourcePath)
+}
+
+func resolveASCSeasonEpisode(meta api.DuplicateSubject) string {
+	if meta.EpisodeInt > 0 {
+		return "S" + padASC2(meta.SeasonInt) + "E" + padASC2(meta.EpisodeInt)
+	}
+	if meta.SeasonInt > 0 {
+		return "S" + padASC2(meta.SeasonInt)
+	}
+	return ""
+}
+
+func padASC2(value int) string {
+	if value < 10 {
+		return "0" + strconv.Itoa(value)
+	}
+	return strconv.Itoa(value)
+}
diff --git a/internal/trackers/impl/standalone/asc/metadata.go b/internal/trackers/impl/standalone/asc/metadata.go
new file mode 100644
index 00000000..386e732b
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/metadata.go
@@ -0,0 +1,672 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func resolveContainer(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		return "5"
+	case "DVD":
+		return "15"
+	}
+	ext := strings.ToLower(strings.TrimSpace(meta.Container))
+	if ext == "" {
+		ext = strings.ToLower(strings.TrimPrefix(filepath.Ext(metautil.FirstNonEmptyTrimmed(meta.VideoPath, meta.SourcePath)), "."))
+	}
+	switch ext {
+	case "mkv":
+		return "6"
+	case "mp4":
+		return "8"
+	default:
+		return ""
+	}
+}
+
+func resolveQuality(meta api.UploadSubject) string {
+	if !strings.EqualFold(meta.Type, "DISC") {
+		switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+		case "ENCODE":
+			return "9"
+		case "REMUX":
+			return "39"
+		case "WEBDL":
+			return "23"
+		case "WEBRIP":
+			return "38"
+		case "BDRIP":
+			return "8"
+		case "DVDRIP":
+			return "3"
+		default:
+			return "0"
+		}
+	}
+	if strings.EqualFold(meta.DiscType, "DVD") {
+		if meta.SourceSize > 7_500_000_000 {
+			return "46"
+		}
+		return "45"
+	}
+	if strings.EqualFold(meta.DiscType, "HDDVD") {
+		return "15"
+	}
+	switch size := meta.SourceSize; {
+	case size > 66<<30:
+		return "43"
+	case size > 50<<30:
+		return "42"
+	case size > 25<<30:
+		return "41"
+	default:
+		return "40"
+	}
+}
+
+func resolveResolution(meta api.UploadSubject) map[string]string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		heightStr := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
+		heightNum, err := strconv.Atoi(heightStr)
+		if err == nil && heightNum > 0 {
+			widthNum := int(math.Round((16.0 / 9.0) * float64(heightNum)))
+			return map[string]string{
+				"width":  strconv.Itoa(widthNum),
+				"height": strconv.Itoa(heightNum),
+			}
+		}
+	}
+
+	if meta.MediaInfoJSONPath != "" {
+		if payload, err := os.ReadFile(meta.MediaInfoJSONPath); err == nil {
+			type mediaInfoDoc struct {
+				Media struct {
+					Track []map[string]any `json:"track"`
+				} `json:"media"`
+			}
+			var doc mediaInfoDoc
+			if err := json.Unmarshal(payload, &doc); err == nil {
+				for _, track := range doc.Media.Track {
+					trackType, _ := track["@type"].(string)
+					if strings.ToLower(trackType) == "video" {
+						widthVal := track["Width"]
+						heightVal := track["Height"]
+
+						widthStr := parseDimensionStr(widthVal)
+						heightStr := parseDimensionStr(heightVal)
+
+						if widthStr != "" && heightStr != "" {
+							return map[string]string{
+								"width":  widthStr,
+								"height": heightStr,
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	height := parseResolutionHeight(meta.Release.Resolution)
+	if height == 0 {
+		height = parseResolutionHeight(meta.ReleaseName)
+	}
+	width := 0
+	if height > 0 {
+		width = int(float64(height) * (16.0 / 9.0))
+	}
+	return map[string]string{
+		"width":  intString(width),
+		"height": intString(height),
+	}
+}
+
+func resolveVideoCodec(meta api.UploadSubject) string {
+	codec := strings.ToUpper(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
+	codecClean := codec
+	if strings.Contains(codec, "264") {
+		codecClean = "H264"
+	} else if strings.Contains(codec, "265") {
+		codecClean = "HEVC"
+	}
+	switch {
+	case strings.Contains(strings.ToUpper(meta.HDR), "HDR") && (codecClean == "HEVC" || codecClean == "H265"):
+		return "28"
+	case strings.Contains(strings.ToUpper(meta.HDR), "HDR") && (codecClean == "AVC" || codecClean == "H264"):
+		return "32"
+	case strings.Contains(codec, "AV1"):
+		return "29"
+	case strings.Contains(codec, "HEVC"):
+		return "27"
+	case strings.Contains(codec, "H265"):
+		return "18"
+	case strings.Contains(codec, "AVC"):
+		return "30"
+	case strings.Contains(codec, "H264"):
+		return "17"
+	case strings.Contains(codec, "VC-1"):
+		return "21"
+	case strings.Contains(codec, "MPEG-2"):
+		return "11"
+	default:
+		return "16"
+	}
+}
+
+func resolveAudioCodec(meta api.UploadSubject) string {
+	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
+	switch {
+	case strings.Contains(audio, "ATMOS"):
+		return "43"
+	case strings.Contains(audio, "DTS:X"):
+		return "25"
+	case strings.Contains(audio, "DTS-HD MA"):
+		return "24"
+	case strings.Contains(audio, "DTS-HD"):
+		return "23"
+	case strings.Contains(audio, "TRUEHD"):
+		return "29"
+	case strings.Contains(audio, "DD+"), strings.Contains(audio, "E-AC-3"):
+		return "26"
+	case strings.Contains(audio, "DD"), strings.Contains(audio, "AC3"):
+		return "11"
+	case strings.Contains(audio, "DTS"):
+		return "12"
+	case strings.Contains(audio, "FLAC"):
+		return "13"
+	case strings.Contains(audio, "LPCM"):
+		return "21"
+	case strings.Contains(audio, "PCM"):
+		return "28"
+	case strings.Contains(audio, "AAC"):
+		return "10"
+	case strings.Contains(audio, "OPUS"):
+		return "27"
+	case strings.Contains(audio, "MPEG"):
+		return "17"
+	default:
+		return "20"
+	}
+}
+
+func resolveAudio(meta api.UploadSubject) string {
+	original := strings.ToLower(strings.TrimSpace(resolveOriginalLanguage(meta)))
+	audioLangs := lowerStrings(meta.AudioLanguages)
+	hasPTAudio := containsAny(audioLangs, []string{"portuguese", "português", "pt"})
+	hasPTSubs := resolveSubtitle(meta) == "Embutida"
+	isOriginalPT := containsAny([]string{original}, []string{"portuguese", "português", "pt"})
+	switch {
+	case hasPTAudio && isOriginalPT:
+		return "4"
+	case hasPTAudio && countNonPortuguese(audioLangs) > 0:
+		return "2"
+	case hasPTAudio:
+		return "3"
+	case hasPTSubs:
+		return "1"
+	default:
+		return "7"
+	}
+}
+
+func resolveSubtitle(meta api.UploadSubject) string {
+	if containsAny(lowerStrings(meta.SubtitleLanguages), []string{"portuguese", "português", "pt", "brazilian portuguese"}) {
+		return "Embutida"
+	}
+	return "S_legenda"
+}
+
+func resolveLanguage(meta api.UploadSubject) string {
+	return mapLanguage(resolveOriginalLanguage(meta), map[string]string{
+		"bg": "15",
+		"da": "12",
+		"de": "3",
+		"en": "1",
+		"es": "6",
+		"fi": "14",
+		"fr": "2",
+		"hi": "23",
+		"it": "4",
+		"ja": "5",
+		"ko": "20",
+		"nl": "17",
+		"no": "16",
+		"pl": "19",
+		"pt": "8",
+		"ru": "7",
+		"sv": "13",
+		"th": "21",
+		"tr": "25",
+		"zh": "10",
+	}, "11")
+}
+
+func resolveAnimeLanguage(meta api.UploadSubject) string {
+	return mapLanguage(resolveOriginalLanguage(meta), map[string]string{
+		"de": "3",
+		"en": "4",
+		"es": "1",
+		"ja": "8",
+		"ko": "11",
+		"pt": "5",
+		"ru": "2",
+		"zh": "9",
+	}, "6")
+}
+
+func resolveAnimeAudioLanguage(meta api.UploadSubject) string {
+	if audio := resolveAudio(meta); audio == "2" || audio == "3" || audio == "4" {
+		return "8"
+	}
+	return resolveLanguage(meta)
+}
+
+func resolveAnimeType(meta api.UploadSubject) string {
+	if categoryOf(meta) == "TV" {
+		return "118"
+	}
+	return "116"
+}
+
+func resolveUploadTitle(meta api.UploadSubject) string {
+	base := resolveDisplayTitle(meta)
+	if categoryOf(meta) == "TV" {
+		return strings.TrimSpace(
+			base + " - " + metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.SeasonStr)+strings.TrimSpace(meta.EpisodeStr), seasonEpisodeText(meta)),
+		)
+	}
+	return base
+}
+
+func resolveDisplayTitle(meta api.UploadSubject) string {
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	if tmdb := meta.ProviderMetadata.TMDB; tmdb != nil {
+		main := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(ptBR.Title, tmdb.Title, meta.Release.Title))
+		alt := strings.TrimSpace(tmdb.OriginalTitle)
+		if categoryOf(meta) == "TV" {
+			alt = strings.TrimSpace(metautil.FirstNonEmptyTrimmed(tmdb.Title, meta.Release.Title))
+		}
+		if main != "" && alt != "" && !strings.EqualFold(main, alt) {
+			return main + " (" + alt + ")"
+		}
+		if main != "" {
+			return main
+		}
+	}
+	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName, pathutil.Base(meta.SourcePath)))
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		if meta.ProviderMetadata.TMDB.Localized != nil {
+			if localized, ok := meta.ProviderMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
+				return strings.TrimSpace(localized.Poster)
+			}
+		}
+		if strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster) != "" {
+			return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+		}
+	}
+	switch {
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Poster) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.Poster)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster)
+	default:
+		return ""
+	}
+}
+
+func resolveOverview(meta api.UploadSubject, answers map[string]string) string {
+	if strings.TrimSpace(answers["overview"]) != "" {
+		return strings.TrimSpace(answers["overview"])
+	}
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
+		return strings.TrimSpace(ptBR.EpisodeOverview)
+	}
+	if ptBR.Overview != "" {
+		return strings.TrimSpace(ptBR.Overview)
+	}
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Overview) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.Overview)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Summary) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Summary)
+	default:
+		return strings.TrimSpace(meta.EpisodeOverview)
+	}
+}
+
+// shouldUseScopedTVOverview reports whether ASC should prefer season or
+// episode localized overview over title-level synopsis text.
+func shouldUseScopedTVOverview(meta api.UploadSubject) bool {
+	if meta.SeasonInt <= 0 {
+		return false
+	}
+	if categoryOf(meta) != "TV" {
+		return false
+	}
+	if meta.TVPack {
+		return true
+	}
+	return meta.EpisodeInt > 0
+}
+
+func resolveGenres(meta api.UploadSubject, answers map[string]string) string {
+	if strings.TrimSpace(answers["genre"]) != "" {
+		return strings.TrimSpace(answers["genre"])
+	}
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+
+	// 1. Use localized if available
+	if ptBR.Genres != "" {
+		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
+		out := make([]string, 0, len(genres))
+		for _, genre := range genres {
+			g := strings.TrimSpace(genre)
+			capitalized := metautil.CapitalizeGenre(g)
+			if capitalized != "" {
+				out = append(out, capitalized)
+			}
+		}
+		return strings.Join(out, ", ")
+	}
+
+	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
+	var genreText string
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.TVDB.Genres)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.TVmaze.Genres)
+	default:
+		genreText = strings.TrimSpace(meta.Release.Genre)
+	}
+
+	if genreText == "" {
+		return ""
+	}
+
+	genres := strings.Split(genreText, ",")
+	out := make([]string, 0, len(genres))
+	for _, genre := range genres {
+		g := strings.TrimSpace(genre)
+		if g == "" {
+			continue
+		}
+		translated := metautil.TranslateGenreToPortugueseStrict(g)
+		if translated == "" {
+			translated = g
+		}
+		capitalized := metautil.CapitalizeGenre(translated)
+		if capitalized != "" {
+			out = append(out, capitalized)
+		}
+	}
+	return strings.Join(out, ", ")
+}
+
+func resolveTrailer(meta api.UploadSubject) string {
+	value := ""
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	if ptBR.TrailerURL != "" {
+		value = ptBR.TrailerURL
+	}
+	if value == "" && meta.ProviderMetadata.TMDB != nil {
+		value = strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	if value == "" {
+		return ""
+	}
+	if strings.HasPrefix(value, "http://") || strings.HasPrefix(value, "https://") {
+		return value
+	}
+	return "https://www.youtube.com/watch?v=" + value
+}
+
+func resolveIMDbIDText(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveOriginalLanguage(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.OriginalLanguage) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.OriginalLanguage)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Language) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Language)
+	default:
+		return ""
+	}
+}
+
+func resolveRuntime(meta api.UploadSubject) string {
+	minutes := 0
+	switch {
+	case meta.ProviderMetadata.TMDB != nil:
+		minutes = meta.ProviderMetadata.TMDB.Runtime
+	case meta.ProviderMetadata.IMDB != nil:
+		minutes = meta.ProviderMetadata.IMDB.RuntimeMinutes
+	case meta.ProviderMetadata.TVmaze != nil:
+		minutes = meta.ProviderMetadata.TVmaze.Runtime
+	}
+	if minutes <= 0 {
+		return ""
+	}
+	hours := minutes / 60
+	remain := minutes % 60
+	if hours == 0 {
+		return fmt.Sprintf("%02d minutos", remain)
+	}
+	return fmt.Sprintf("%d hora%s e %02d minutos", hours, pluralSuffix(hours), remain)
+}
+
+func resolveCountries(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.ProductionCountries) > 0 {
+		names := make([]string, 0, len(meta.ProviderMetadata.TMDB.ProductionCountries))
+		for _, country := range meta.ProviderMetadata.TMDB.ProductionCountries {
+			if strings.TrimSpace(country.Name) != "" {
+				names = append(names, strings.TrimSpace(country.Name))
+			}
+		}
+		return strings.Join(names, ", ")
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.CountryList)
+	}
+	return ""
+}
+
+func resolveCast(meta api.UploadSubject) []string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Cast) > 0:
+		return append([]string{}, meta.ProviderMetadata.TMDB.Cast...)
+	case meta.ProviderMetadata.IMDB != nil && len(meta.ProviderMetadata.IMDB.Stars) > 0:
+		names := make([]string, 0, len(meta.ProviderMetadata.IMDB.Stars))
+		for _, person := range meta.ProviderMetadata.IMDB.Stars {
+			if strings.TrimSpace(person.Name) != "" {
+				names = append(names, strings.TrimSpace(person.Name))
+			}
+		}
+		return names
+	default:
+		return nil
+	}
+}
+
+func resolveReleaseDate(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.ReleaseDate) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.ReleaseDate)
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.FirstAirDate) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.FirstAirDate)
+	case meta.ProviderMetadata.TVDB != nil && strings.TrimSpace(meta.ProviderMetadata.TVDB.FirstAired) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVDB.FirstAired)
+	case meta.ProviderMetadata.TVmaze != nil && strings.TrimSpace(meta.ProviderMetadata.TVmaze.Premiered) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Premiered)
+	default:
+		return ""
+	}
+}
+
+func resolveYear(meta api.UploadSubject) int {
+	switch {
+	case meta.Release.Year > 0:
+		return meta.Release.Year
+	case meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0:
+		return meta.ProviderMetadata.TMDB.Year
+	case meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0:
+		return meta.ProviderMetadata.IMDB.Year
+	case meta.ProviderMetadata.TVDB != nil && meta.ProviderMetadata.TVDB.Year > 0:
+		return meta.ProviderMetadata.TVDB.Year
+	default:
+		return 0
+	}
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func seasonEpisodeText(meta api.UploadSubject) string {
+	if meta.EpisodeInt > 0 {
+		return fmt.Sprintf("S%02dE%02d", meta.SeasonInt, meta.EpisodeInt)
+	}
+	if meta.SeasonInt > 0 {
+		return fmt.Sprintf("S%02d", meta.SeasonInt)
+	}
+	return ""
+}
+
+func boolFlag(ok bool) string {
+	if ok {
+		return "1"
+	}
+	return "2"
+}
+
+func parseResolutionHeight(value string) int {
+	re := regexp.MustCompile(`(?i)(\d{3,4})(?:p|i)`)
+	matches := re.FindStringSubmatch(value)
+	if len(matches) != 2 {
+		return 0
+	}
+	height, _ := strconv.Atoi(matches[1])
+	return height
+}
+
+func intString(value int) string {
+	if value <= 0 {
+		return ""
+	}
+	return strconv.Itoa(value)
+}
+
+func mapLanguage(value string, mappings map[string]string, fallback string) string {
+	key := strings.ToLower(strings.TrimSpace(value))
+	if mapped, ok := mappings[key]; ok {
+		return mapped
+	}
+	return fallback
+}
+
+func lowerStrings(values []string) []string {
+	out := make([]string, 0, len(values))
+	for _, value := range values {
+		if strings.TrimSpace(value) == "" {
+			continue
+		}
+		out = append(out, strings.ToLower(strings.TrimSpace(value)))
+	}
+	return out
+}
+
+func countNonPortuguese(values []string) int {
+	count := 0
+	for _, value := range values {
+		if !containsAny([]string{value}, []string{"portuguese", "português", "pt"}) {
+			count++
+		}
+	}
+	return count
+}
+
+func containsAny(values []string, targets []string) bool {
+	for _, value := range values {
+		for _, target := range targets {
+			if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func containsFold(values []string, target string) bool {
+	for _, value := range values {
+		if strings.EqualFold(strings.TrimSpace(value), strings.TrimSpace(target)) {
+			return true
+		}
+	}
+	return false
+}
+
+func pluralSuffix(value int) string {
+	if value == 1 {
+		return ""
+	}
+	return "s"
+}
+
+func readTextFile(path string) (string, error) {
+	payload, err := os.ReadFile(strings.TrimSpace(path))
+	if err != nil {
+		return "", fmt.Errorf("trackers: ASC read text file: %w", err)
+	}
+	return strings.ReplaceAll(string(payload), "\r", ""), nil
+}
+
+func readTextFileNoErr(path string) string {
+	value, _ := readTextFile(path)
+	return value
+}
+
+func parseDimensionStr(val any) string {
+	return metautil.ParseDimensionStr(val)
+}
diff --git a/internal/trackers/impl/standalone/asc/metadata_test.go b/internal/trackers/impl/standalone/asc/metadata_test.go
new file mode 100644
index 00000000..484f3ed5
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/metadata_test.go
@@ -0,0 +1,100 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveGenresPreservesUnknownGenres(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Genre: "Sci-Fi,MyCustomGenre",
+		},
+	}
+	answers := map[string]string{}
+
+	got := resolveGenres(meta, answers)
+	expected := "Ficção científica, MyCustomGenre"
+	if got != expected {
+		t.Fatalf("expected genres %q, got %q", expected, got)
+	}
+}
+
+func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
+	t.Parallel()
+
+	answers := map[string]string{}
+	ptBR := api.TMDBLocalizedData{
+		Overview:        "Series Overview",
+		EpisodeOverview: "Episode Overview",
+	}
+
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+		want string
+	}{
+		{
+			name: "episode upload uses episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "TV"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
+				},
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "season pack uses season overview from episode field",
+			meta: api.UploadSubject{
+				Identity:  api.ExternalIdentity{Category: "TV"},
+				SeasonInt: 1,
+				TVPack:    true,
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
+				},
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "series upload uses title overview",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "TV"},
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
+				},
+			},
+			want: "Series Overview",
+		},
+		{
+			name: "movie ignores episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "MOVIE"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{"pt-BR": ptBR}},
+				},
+			},
+			want: "Series Overview",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := resolveOverview(tc.meta, answers); got != tc.want {
+				t.Fatalf("expected overview %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/asc/profile.go b/internal/trackers/impl/standalone/asc/profile.go
new file mode 100644
index 00000000..3cfa177f
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/profile.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns ASC identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                    "ASC",
+		BaseURL:                 baseURL,
+		DescriptionGroup:        "asc",
+		UploadContentMode:       trackers.UploadContentModeDescription,
+		LocalizedMetadataLocale: "pt-BR",
+		PrepareDescription:      prepareDescription,
+		PrepareUpload:           prepareUpload,
+		NewDuplicateAdapter:     newDuplicateAdapter,
+		UploadArtifactPolicy:    &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		AudioPolicy:             &trackers.AudioPolicy{AllowBloat: true},
+		TorrentIdentityPolicy:   &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"amigos-share.club"}},
+		AuthCapability:          standalone.CookieAuthCapability("ASC"),
+	}
+}
+
+// New returns a fresh ASC definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/asc/session.go b/internal/trackers/impl/standalone/asc/session.go
similarity index 79%
rename from internal/trackers/impl/asc/session.go
rename to internal/trackers/impl/standalone/asc/session.go
index 6af34179..d3e0c8e6 100644
--- a/internal/trackers/impl/asc/session.go
+++ b/internal/trackers/impl/standalone/asc/session.go
@@ -11,8 +11,9 @@ import (
 	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
 )
 
-// LoadCookies loads ASC cookies from shared storage.
-// Callers must pass a valid non-nil context.
+// LoadCookies loads ASC cookies from shared storage for the ASC web domain.
+// The legacy source-label return value is always empty. Callers must pass a
+// valid non-nil context.
 func LoadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, string, error) {
 	loaded, err := cookiepkg.LoadTrackerHTTPCookies(ctx, dbPath, sourceFlag, "cliente.amigos-share.club")
 	if err != nil {
diff --git a/internal/trackers/impl/standalone/asc/upload.go b/internal/trackers/impl/standalone/asc/upload.go
new file mode 100644
index 00000000..bfbaaa15
--- /dev/null
+++ b/internal/trackers/impl/standalone/asc/upload.go
@@ -0,0 +1,429 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package asc
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var ascIDPattern = regexp.MustCompile(`torrents-details\.php\?id=(\d+)`)
+
+type uploadState struct {
+	uploadURL     string
+	torrentPath   string
+	description   string
+	fields        map[string]string
+	blockedReason string
+	questionnaire *api.TrackerQuestionnaire
+	releaseName   string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: ASC %s", state.blockedReason)
+	}
+
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "ASC")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ASC request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", userAgent)
+	for _, cookie := range cookies {
+		httpReq.AddCookie(cookie)
+	}
+
+	client := httpclient.New(httpclient.DefaultTimeout)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ASC upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	bodyBytes, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: ASC read upload response: %w", err)
+	}
+	torrentID := parseUploadID(finalURL, string(bodyBytes))
+	if resp.StatusCode == http.StatusOK && torrentID != "" {
+		torrentURL := baseURL + "/torrents-details.php?id=" + url.QueryEscape(torrentID)
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		maybeAutoApprove(ctx, client, cookies, req.TrackerConfig, torrentID, req.Logger)
+		maybeSetInternal(ctx, client, cookies, req.TrackerConfig, req.Meta, torrentID, req.Logger)
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "ASC",
+				TorrentID:   torrentID,
+				TorrentURL:  torrentURL,
+				DownloadURL: torrentURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	failurePath := ""
+	if pathValue, pathErr := resolveFailurePath(req.Meta, req.Runtime.DBPath); pathErr == nil {
+		failurePath = pathValue
+		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
+		_ = os.WriteFile(failurePath, redactedBody, 0o600)
+	}
+	if failurePath != "" {
+		return api.UploadSummary{}, fmt.Errorf(
+			"%w failure=%s",
+			commonhttp.UploadHTTPErrorWithURL("ASC", resp.StatusCode, finalURL, responsePreview),
+			failurePath,
+		)
+	}
+	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("ASC", resp.StatusCode, finalURL, responsePreview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "ASC",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "asc",
+		Description:      state.description,
+		Endpoint:         state.uploadURL,
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+
+	description := buildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets, req.TrackerConfig.CustomLayout)
+
+	fields, releaseName := buildPayload(req.Meta, req.TrackerConfig, assets, description)
+	state := uploadState{
+		uploadURL:     resolveUploadURL(req.Meta),
+		torrentPath:   torrentPath,
+		description:   description,
+		fields:        fields,
+		releaseName:   releaseName,
+		questionnaire: buildQuestionnaire(req.Meta),
+	}
+	if reason := validatePayload(ctx, req.Meta, fields, req.Runtime.DBPath); reason != "" {
+		state.blockedReason = reason
+	}
+	if dryRun {
+		return state, nil, nil
+	}
+
+	cookies, _, err := LoadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: ASC load cookies: %w", err)
+	}
+	return state, cookies, nil
+}
+
+func buildPayload(
+	meta api.UploadSubject,
+	trackerCfg config.TrackerConfig,
+	assets trackers.DescriptionAssets,
+	description string,
+) (map[string]string, string) {
+	answers := standalone.QuestionnaireAnswers(meta, "ASC")
+	releaseName := resolveUploadTitle(meta)
+	fields := map[string]string{
+		"ano":        strconv.Itoa(resolveYear(meta)),
+		"audio":      resolveAudio(meta),
+		"capa":       resolvePoster(meta),
+		"codecaudio": resolveAudioCodec(meta),
+		"codecvideo": resolveVideoCodec(meta),
+		"descr":      description,
+		"extencao":   resolveContainer(meta),
+		"genre":      resolveGenres(meta, answers),
+		"imdb":       resolveIMDbIDText(meta),
+		"layout":     metautil.FirstNonEmptyTrimmed(strings.TrimSpace(trackerCfg.CustomLayout), "2"),
+		"legenda":    resolveSubtitle(meta),
+		"name":       releaseName,
+		"qualidade":  resolveQuality(meta),
+		"takeupload": "yes",
+		"tresd":      boolFlag(meta.Is3D != ""),
+		"tube":       resolveTrailer(meta),
+	}
+	resolution := resolveResolution(meta)
+	fields["largura"] = resolution["width"]
+	fields["altura"] = resolution["height"]
+	fields["lang"] = resolveLanguage(meta)
+	count := 1
+	for _, image := range assets.Screenshots {
+		if count > 4 {
+			break
+		}
+		raw := strings.TrimSpace(image.RawURL)
+		if raw == "" {
+			continue
+		}
+		lower := strings.ToLower(raw)
+		if strings.Contains(lower, "amigos-share.club") || strings.Contains(lower, "tmdb.org") || strings.Contains(lower, "imdb.com") ||
+			strings.Contains(lower, "themoviedb.org") {
+			continue
+		}
+		fields[fmt.Sprintf("screens%d", count)] = raw
+		count++
+	}
+	if meta.Anime {
+		fields["type"] = resolveAnimeType(meta)
+		fields["idioma"] = resolveAnimeLanguage(meta)
+		fields["lang"] = resolveAnimeAudioLanguage(meta)
+	}
+	return fields, releaseName
+}
+
+func buildQuestionnaire(meta api.UploadSubject) *api.TrackerQuestionnaire {
+	answers := standalone.QuestionnaireAnswers(meta, "ASC")
+	fields := make([]api.TrackerQuestionnaireField, 0, 2)
+	if strings.TrimSpace(resolveOverview(meta, answers)) == "" {
+		fields = append(fields, api.TrackerQuestionnaireField{
+			Key:      "overview",
+			Label:    "Sinopse",
+			Kind:     "textarea",
+			Value:    strings.TrimSpace(answers["overview"]),
+			Required: true,
+		})
+	}
+	if strings.TrimSpace(resolveGenres(meta, answers)) == "" {
+		fields = append(fields, api.TrackerQuestionnaireField{
+			Key:         "genre",
+			Label:       "Gêneros",
+			Kind:        "text",
+			Value:       strings.TrimSpace(answers["genre"]),
+			Placeholder: "Drama, Action",
+			Required:    true,
+		})
+	}
+	if len(fields) == 0 {
+		return nil
+	}
+	return &api.TrackerQuestionnaire{Tracker: "ASC", Fields: fields}
+}
+
+func validatePayload(ctx context.Context, meta api.UploadSubject, fields map[string]string, dbPath string) string {
+	if reason := authProblem(ctx, dbPath); reason != "" {
+		return reason
+	}
+	if !meta.Anime && strings.TrimSpace(fields["imdb"]) == "" {
+		return "missing IMDb ID"
+	}
+	if strings.TrimSpace(fields["capa"]) == "" {
+		return "missing poster URL"
+	}
+	if strings.TrimSpace(fields["genre"]) == "" {
+		return "missing genre"
+	}
+	if strings.TrimSpace(resolveOverview(meta, standalone.QuestionnaireAnswers(meta, "ASC"))) == "" {
+		return "missing overview"
+	}
+	return ""
+}
+
+func resolveUploadURL(meta api.UploadSubject) string {
+	if meta.Anime {
+		return baseURL + "/enviar-anime.php"
+	}
+	if categoryOf(meta) == "TV" {
+		return baseURL + "/enviar-series.php"
+	}
+	return baseURL + "/enviar-filme.php"
+}
+
+func parseUploadID(finalURL string, body string) string {
+	if matches := ascIDPattern.FindStringSubmatch(finalURL); len(matches) == 2 {
+		return strings.TrimSpace(matches[1])
+	}
+	if matches := ascIDPattern.FindStringSubmatch(body); len(matches) == 2 {
+		return strings.TrimSpace(matches[1])
+	}
+	return ""
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	file, err := os.Open(strings.TrimSpace(torrentPath))
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: ASC open torrent file: %w", err)
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			return nil, "", fmt.Errorf("trackers: ASC write multipart field %q: %w", key, err)
+		}
+	}
+	part, err := writer.CreateFormFile("torrent", filepath.Base(torrentPath))
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: ASC create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		return nil, "", fmt.Errorf("trackers: ASC copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: ASC close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func maybeAutoApprove(ctx context.Context, client *http.Client, cookies []*http.Cookie, cfg config.TrackerConfig, torrentID string, logger api.Logger) {
+	if client == nil {
+		logger.Warnf("trackers: ASC auto approval skipped: client is nil")
+		return
+	}
+	if !cfg.UploaderStatus {
+		logger.Debugf("trackers: ASC auto approval skipped: uploader status disabled")
+		return
+	}
+	if strings.TrimSpace(torrentID) == "" {
+		logger.Warnf("trackers: ASC auto approval skipped: empty torrentID")
+		return
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/uploader_app.php?id="+url.QueryEscape(torrentID), nil)
+	if err != nil {
+		logger.Warnf("trackers: ASC auto approval failed: %v", err)
+		return
+	}
+	req.Header.Set("User-Agent", userAgent)
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+	resp, err := client.Do(req)
+	if err != nil && logger != nil {
+		logger.Warnf("trackers: ASC auto approval failed: %v", err)
+	}
+	if resp != nil {
+		resp.Body.Close()
+	}
+}
+
+func maybeSetInternal(
+	ctx context.Context,
+	client *http.Client,
+	cookies []*http.Cookie,
+	cfg config.TrackerConfig,
+	meta api.UploadSubject,
+	torrentID string,
+	logger api.Logger,
+) {
+	if client == nil || !cfg.Internal || strings.TrimSpace(torrentID) == "" {
+		logger.Debugf("trackers: ASC internal flag skipped: %v", "client is nil or internal is false or torrentID is empty")
+		return
+	}
+	group := strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
+	if group == "" || !containsFold(cfg.InternalGroups, group) {
+		logger.Debugf("trackers: ASC internal flag skipped: %v", "group is empty or not in internal groups")
+		return
+	}
+	values := url.Values{"id": {torrentID}, "internal": {"yes"}}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/torrents-edit.php?action=doedit", strings.NewReader(values.Encode()))
+	if err != nil {
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", userAgent)
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+	resp, err := client.Do(req)
+	if err != nil && logger != nil {
+		logger.Warnf("trackers: ASC internal flag failed: %v", err)
+	}
+	if resp != nil {
+		resp.Body.Close()
+	}
+}
+
+func resolveFailurePath(meta api.UploadSubject, dbPath string) (string, error) {
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return filepath.Join(tmpDir, "[ASC]upload_failure.html"), nil
+}
diff --git a/internal/trackers/impl/standalone/bhd/bbcode.go b/internal/trackers/impl/standalone/bhd/bbcode.go
new file mode 100644
index 00000000..17bca845
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/bbcode.go
@@ -0,0 +1,166 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
+)
+
+// BBCodeOptions controls tracker-specific description cleanup and artifact
+// extraction. BaseDir and UUID are retained inputs but are not currently read.
+type BBCodeOptions struct {
+	// Framestor preserves the original description as a bhd.nfo artifact.
+	Framestor bool
+	// Flux wraps non-empty cleaned text in a code block.
+	Flux    bool
+	BaseDir string
+	UUID    string
+	// OnNFO receives the original description before cleanup when Framestor is set.
+	// Callback failures are recorded as report notes rather than returned.
+	OnNFO func(text string) error
+}
+
+var (
+	bhdSizePattern   = regexp.MustCompile(`(?i)\[size=.*?\]`)
+	bhdURLImgPattern = regexp.MustCompile(`(?is)\[url=(https?://[^\]]+)\]\s*\[img(?:=[^\]]*)?\](https?://[^\[]+?)\[/img\]\s*\[/url\]`)
+	bhdImgTagPattern = regexp.MustCompile(`(?is)\[img(?:=[^\]]*)?\](https?://[^\[]+?)\[/img\]`)
+	bhdLooseImg      = regexp.MustCompile(`(?i)(https?://[^\s\[\]]+\.(?:png|jpe?g|webp|gif)(?:\?[^\s\[\]]*)?)`)
+	bhdEmptyCenter   = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
+	bhdEmptyAlign    = regexp.MustCompile(`(?i)\[align=[^\]]+\]\s*\[/align\]`)
+	bhdTonemapNotice = regexp.MustCompile(
+		`(?is)\[(?:center|align=center)\]\s*\[code\]\s*Screenshots\s+have\s+been\s+tonemapped\s+for\s+reference\s*\[/code\]\s*\[/(?:center|align)\]`,
+	)
+	bhdBotSignature = regexp.MustCompile(
+		`(?is)(?:\[(?:center|right|align=right)\]\s*(?:\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\]\s*)?\[b\]?Uploaded\s+Using\s+\[url=https://github\.com/HDInnovations/UNIT3D\]UNIT3D\[/url\]\s+Auto\s+Uploader\[/b\]?(?:\s*\[img=\d+\]https://blutopia\.xyz/favicon\.ico\[/img\])?\s*\[/(?:center|right|align)\])|(?:\[center\]\s*\[url=https://github\.com/z-ink/uploadrr\]\[img=\d+\]https://i\.ibb\.co/2NVWb0c/uploadrr\.webp\[/img\]\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=https://github\.com/edge20200/Only-Uploader\]Powered\s+by\s+Only-Uploader\[/url\]\s*\[/center\])|(?:\[center\]\s*\[url=/torrents\?perPage=\d+&name=[^\]]*\]\s*\[/url\]\s*\[/center\])|(?:\[center\]\s*(?:\[b\]\s*(?:\[size=\d+\])?brush(?:\[/size\])?\s*\[/b\]\s*)?This is an internal release which was first released exclusively on Aither\.\s*Cheers to all the Aither(?:\s+users)?\s*\[/center\])|(?:\[(?:center|right|align=right)\]\s*(?:\[url=[^\]]+\]\s*)?(?:\[size=[^\]]+\]\s*)?Created by(?:\s+[^[]*?)?\s*Upload Assistant(?:\s*\[/size\])?(?:\s*\[/url\])?\s*\[/(?:center|right|align)\])`,
+	)
+)
+
+// CleanDescription removes unsupported BHD formatting and uploader signatures,
+// extracts unique image URLs, and applies the requested Framestor and Flux
+// behavior. Image extraction preserves the first occurrence of each raw URL.
+func CleanDescription(description string, options BBCodeOptions) bbcode.Report {
+	desc := bbcode.NormalizeNewlines(description)
+	report := bbcode.Report{}
+	imagelist := make([]bbcode.Image, 0)
+
+	if options.Framestor {
+		if options.OnNFO != nil {
+			if err := options.OnNFO(desc); err != nil {
+				report.Notes = append(report.Notes, bbcode.Note{Kind: "nfo", Message: err.Error()})
+			}
+		}
+		report.Artifacts = append(report.Artifacts, bbcode.Artifact{
+			Name:    "bhd.nfo",
+			Kind:    "nfo",
+			Content: desc,
+		})
+	}
+
+	desc = bhdSizePattern.ReplaceAllString(desc, "")
+	desc = strings.ReplaceAll(desc, "[/size]", "")
+	desc = bhdBotSignature.ReplaceAllString(desc, "")
+	desc = strings.ReplaceAll(desc, "<", "/")
+	desc = strings.ReplaceAll(desc, "<", "\\")
+
+	seen := make(map[string]struct{})
+	appendImage := func(imgURL, webURL string) {
+		imgURL = strings.TrimSpace(imgURL)
+		if imgURL == "" {
+			return
+		}
+		key := strings.ToLower(imgURL)
+		if _, ok := seen[key]; ok {
+			return
+		}
+		seen[key] = struct{}{}
+		host := imagehost.ExtractHost(imgURL)
+		web := strings.TrimSpace(webURL)
+		if web == "" {
+			web = imgURL
+		}
+		rawURL := bbcode.NormalizeImageRawURL(imgURL)
+		imagelist = append(imagelist, bbcode.Image{
+			ImgURL: imgURL,
+			RawURL: rawURL,
+			WebURL: web,
+			Host:   host,
+		})
+	}
+
+	urlImgMatches := bhdURLImgPattern.FindAllStringSubmatch(desc, -1)
+	for _, match := range urlImgMatches {
+		if len(match) < 3 {
+			continue
+		}
+		appendImage(match[2], match[1])
+	}
+	desc = bhdURLImgPattern.ReplaceAllString(desc, "")
+
+	imgTagMatches := bhdImgTagPattern.FindAllStringSubmatch(desc, -1)
+	for _, match := range imgTagMatches {
+		if len(match) < 2 {
+			continue
+		}
+		appendImage(match[1], "")
+	}
+	desc = bhdImgTagPattern.ReplaceAllString(desc, "")
+
+	looseImages := bhdLooseImg.FindAllString(desc, -1)
+	for _, imgURL := range looseImages {
+		appendImage(imgURL, "")
+		desc = strings.ReplaceAll(desc, imgURL, "")
+	}
+
+	for _, image := range imagelist {
+		imgURL := regexp.QuoteMeta(image.ImgURL)
+		urlTag := regexp.MustCompile(`(?i)\[URL=` + imgURL + `\]\[/URL\]`)
+		desc = urlTag.ReplaceAllString(desc, "")
+		urlImg := regexp.MustCompile(`(?i)\[URL=` + imgURL + `\]\[img[^\]]*\]` + imgURL + `\[/img\]\[/URL\]`)
+		desc = urlImg.ReplaceAllString(desc, "")
+	}
+
+	desc = regexp.MustCompile(`(?i)\[URL=[\s\S]*?\]\[/URL\]`).ReplaceAllString(desc, "")
+	desc = bhdTonemapNotice.ReplaceAllString(desc, "")
+	desc = bhdEmptyCenter.ReplaceAllString(desc, "")
+	desc = bhdEmptyAlign.ReplaceAllString(desc, "")
+	desc = bbcode.RemoveExtraLines(desc)
+	desc = strings.TrimSpace(desc)
+
+	if options.Flux {
+		desc = strings.TrimRight(desc, " \t\n")
+		desc = strings.Trim(desc, "\n")
+		desc = regexp.MustCompile(`\n\n+`).ReplaceAllString(desc, "\n\n")
+		for strings.HasPrefix(desc, "\n") {
+			desc = strings.TrimPrefix(desc, "\n")
+		}
+		desc = strings.Trim(desc, "\n")
+		if strings.TrimSpace(strings.ReplaceAll(desc, "\n", "")) == "" {
+			return bbcode.Report{Images: imagelist}
+		}
+		report.Description = "[code]" + desc + "[/code]"
+	} else {
+		report.Description = desc
+	}
+
+	if report.Description == "" {
+		report.Description = ""
+	}
+	if bbcode.IsOnlyTags(report.Description) {
+		return bbcode.Report{
+			Images:    imagelist,
+			Notes:     report.Notes,
+			Artifacts: report.Artifacts,
+		}
+	}
+	return bbcode.Report{
+		Description: report.Description,
+		Images:      imagelist,
+		Notes:       report.Notes,
+		Artifacts:   report.Artifacts,
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/data.go b/internal/trackers/impl/standalone/bhd/data.go
new file mode 100644
index 00000000..7b7c8306
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/data.go
@@ -0,0 +1,159 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const minDataTokenLength = 25
+
+type dataLookup struct {
+	cfg     config.Config
+	http    *http.Client
+	baseURL string
+}
+
+// NewDataLookup returns a BHD lookup bound to cfg and httpClient.
+func (d *Definition) NewDataLookup(cfg config.Config, httpClient *http.Client, _ api.Logger) trackers.DataLookup {
+	return &dataLookup{
+		cfg:     cfg,
+		http:    httpClient,
+		baseURL: "https://beyond-hd.me/api/torrents",
+	}
+}
+
+// Lookup resolves a BHD torrent by tracker ID or by folder/file name. Missing
+// API or RSS credentials, an unusable search filter, non-success responses, and
+// empty API results produce an empty result without an error. Description and
+// image fields honor OnlyID and KeepImages independently.
+func (l *dataLookup) Lookup(ctx context.Context, req trackers.DataLookupRequest) (trackers.DataLookupResult, error) {
+	cfg, apiKey := bhdConfig(l.cfg)
+	rssKey := strings.TrimSpace(cfg.BhdRSSKey)
+	if len(apiKey) < minDataTokenLength || len(rssKey) < minDataTokenLength {
+		return trackers.DataLookupResult{}, nil
+	}
+	endpoint := strings.TrimRight(l.baseURL, "/") + "/" + apiKey
+	payload := map[string]any{}
+	if id := strings.TrimSpace(req.TrackerID); id != "" {
+		payload["action"], payload["torrent_id"] = "details", id
+	} else {
+		payload["action"], payload["rsskey"] = "search", rssKey
+		hasFilter := false
+		if strings.TrimSpace(req.Meta.DiscType) != "" || len(req.Meta.FileList) != 1 {
+			payload["folder_name"], hasFilter = pathutil.Base(req.Meta.SourcePath), true
+		} else if name := strings.TrimSpace(req.SearchName); name != "" {
+			payload["file_name"], hasFilter = name, true
+		}
+		if !hasFilter {
+			return trackers.DataLookupResult{}, nil
+		}
+	}
+	first, err := l.requestFirst(ctx, endpoint, payload)
+	if err != nil || len(first) == 0 {
+		return trackers.DataLookupResult{}, err
+	}
+	result := trackers.DataLookupResult{TrackerID: req.TrackerID, IMDBID: bhdIMDBInt(first["imdb_id"])}
+	result.Category, result.TMDBID = parseTMDB(first["tmdb_id"])
+	description := ""
+	if bhdString(first["description"]) == "1" {
+		torrentID := bhdString(first["id"])
+		if torrentID == "" {
+			torrentID = strings.TrimSpace(req.TrackerID)
+		}
+		if torrentID != "" {
+			if body, requestErr := l.request(ctx, endpoint, map[string]any{"action": "description", "torrent_id": torrentID}); requestErr == nil {
+				description = bhdString(body["result"])
+			}
+		}
+	} else {
+		description = bhdString(first["description"])
+	}
+	if req.OnlyID && !req.KeepImages {
+		return result, nil
+	}
+	report := CleanDescription(description, BBCodeOptions{})
+	if !req.OnlyID {
+		result.Description = strings.TrimSpace(report.Description)
+	}
+	if req.KeepImages {
+		result.Images = report.Images
+	}
+	if strings.TrimSpace(result.TrackerID) == "" {
+		result.TrackerID = bhdString(first["id"])
+	}
+	return result, nil
+}
+
+func (l *dataLookup) requestFirst(ctx context.Context, endpoint string, payload map[string]any) (map[string]any, error) {
+	body, err := l.request(ctx, endpoint, payload)
+	if err != nil || len(body) == 0 {
+		return nil, err
+	}
+	if items, ok := body["results"].([]any); ok && len(items) > 0 {
+		item, _ := items[0].(map[string]any)
+		return item, nil
+	}
+	item, _ := body["result"].(map[string]any)
+	return item, nil
+}
+
+func (l *dataLookup) request(ctx context.Context, endpoint string, payload map[string]any) (map[string]any, error) {
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: bhd encode request: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(raw))
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: bhd request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := l.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: bhd request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return nil, nil
+	}
+	result := map[string]any{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("trackerdata: bhd decode: %w", err)
+	}
+	if bhdInt(result["status_code"]) == 0 {
+		return nil, nil
+	}
+	if success, ok := result["success"].(bool); ok && !success {
+		return nil, nil
+	}
+	return result, nil
+}
+
+func parseTMDB(value any) (string, int) {
+	raw := strings.ToLower(bhdString(value))
+	if raw == "" || raw == "0" {
+		return "", 0
+	}
+	if after, ok := strings.CutPrefix(raw, "tv/"); ok {
+		return "TV", int(bhdInt(after))
+	}
+	if after, ok := strings.CutPrefix(raw, "movie/"); ok {
+		return "MOVIE", int(bhdInt(after))
+	}
+	return "", int(bhdInt(raw))
+}
+
+func bhdIMDBInt(value any) int {
+	return int(bhdInt(strings.TrimPrefix(strings.ToLower(bhdString(value)), "tt")))
+}
diff --git a/internal/trackers/impl/standalone/bhd/data_test.go b/internal/trackers/impl/standalone/bhd/data_test.go
new file mode 100644
index 00000000..a221fb8d
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/data_test.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDataLookup(t *testing.T) {
+	t.Parallel()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasPrefix(r.URL.Path, "/bhd/") {
+			http.NotFound(w, r)
+			return
+		}
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"status_code": 1,
+			"success":     true,
+			"results": []any{map[string]any{
+				"id":          "99",
+				"imdb_id":     "tt1234567",
+				"tmdb_id":     "movie/765",
+				"description": "hello\n[url=https://pixhost.to/full/example][img]https://pixhost.to/example.png[/img][/url]",
+			}},
+		})
+	}))
+	defer server.Close()
+
+	token := strings.Repeat("a", minDataTokenLength)
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BHD": {APIKey: token, BhdRSSKey: token}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected BHD data lookup")
+	}
+	lookup.baseURL = server.URL + "/bhd"
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{
+		Meta:       api.UploadSubject{SourcePath: "/tmp/release"},
+		SearchName: "release.mkv",
+		KeepImages: true,
+	})
+	if err != nil {
+		t.Fatalf("lookup: %v", err)
+	}
+	if result.TrackerID != "99" || result.IMDBID != 1234567 || result.TMDBID != 765 || result.Category != "MOVIE" || result.Description != "hello" || len(result.Images) != 1 {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+}
+
+func TestDataLookupSkipsUnfilteredSearch(t *testing.T) {
+	t.Parallel()
+	requested := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requested = true
+		http.Error(w, "unexpected request", http.StatusInternalServerError)
+	}))
+	defer server.Close()
+	token := strings.Repeat("a", minDataTokenLength)
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BHD": {APIKey: token, BhdRSSKey: token}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected BHD data lookup")
+	}
+	lookup.baseURL = server.URL
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{Meta: api.UploadSubject{SourcePath: `D:\TV\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`, FileList: []string{"Example.Show.S04E01.2160p.WEB.h265-GRP.mkv"}}, KeepImages: true})
+	if err != nil || result.HasData() || requested {
+		t.Fatalf("err=%v data=%t requested=%t", err, result.HasData(), requested)
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/definition.go b/internal/trackers/impl/standalone/bhd/definition.go
new file mode 100644
index 00000000..64461c93
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/definition.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func bannedGroups() []string {
+	return []string{
+		"Sicario", "TOMMY", "x0r", "nikt0", "FGT", "d3g", "MeGusta", "YIFY", "tigole", "TEKNO3D",
+		"C4K", "RARBG", "4K4U", "EASports", "ReaLHD", "Telly", "AOC", "WKS", "SasukeducK", "CRUCiBLE",
+		"iFT", "ProRes", "MezRips", "Flights", "BiTOR", "iVy", "QxR", "SyncUP", "OFT", "TGS",
+	}
+}
+
+// DataLookupConfigured reports whether BHD metadata lookup credentials are available.
+func (d *Definition) DataLookupConfigured(cfg config.Config) bool {
+	entry, _ := bhdConfig(cfg)
+	return len(strings.TrimSpace(entry.APIKey)) >= minDataTokenLength && len(strings.TrimSpace(entry.BhdRSSKey)) >= minDataTokenLength
+}
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	var err error
+	var assets trackers.DescriptionAssets
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
+			}
+			if req.Logger != nil {
+				req.Logger.Warnf("trackers: BHD description assets failed: %v", err)
+			}
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+
+	description := buildDescription(req.Meta, req.Runtime.DescriptionConfig(), assets)
+	return trackers.DescriptionResult{
+		Group:       "bhd",
+		Description: description,
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/bhd/definition_test.go b/internal/trackers/impl/standalone/bhd/definition_test.go
new file mode 100644
index 00000000..43f6f785
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/definition_test.go
@@ -0,0 +1,688 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func (d *Definition) prepareDryRun(ctx context.Context, input trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	input.Intent = trackers.PreparationIntentDryRun
+	plan, failure := d.Prepare(ctx, input)
+	if failure != nil {
+		return api.TrackerDryRunEntry{}, failure
+	}
+	return plan.DryRun(), nil
+}
+
+func (d *Definition) submit(ctx context.Context, input trackers.PreparationInput) (api.UploadSummary, error) {
+	input.Intent = trackers.PreparationIntentUpload
+	plan, failure := d.Prepare(ctx, input)
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("submit prepared BHD test upload: %w", err)
+	}
+	return summary, nil
+}
+
+func sendUpload(ctx context.Context, req trackers.PreparationInput, state uploadState) ([]byte, error) {
+	body, contentType, err := buildMultipartPayload(state.fields, state.mediaDump, state.torrentPath)
+	if err != nil {
+		return nil, err
+	}
+	_, responseBody, err := sendPreparedUpload(ctx, uploadEndpoint(req.TrackerConfig.APIKey), body, contentType)
+	return responseBody, err
+}
+
+func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	entry, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity: api.ExternalIdentity{
+				TMDBID:   123,
+				IMDBID:   456,
+				Category: "TV",
+			},
+			ReleaseName: "Movie.2025.1080p.WEB-DL.DD+5.1.H264-GRP",
+			Release:     api.ReleaseInfo{Resolution: "1080p"},
+			Type:        "WEBDL",
+			Source:      "WEB",
+			Audio:       "DD+ 5.1",
+			HDR:         "HDR10+ DV",
+			Edition:     "Hybrid Director",
+			TVPack:      true,
+			SeasonStr:   "S00",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token", DraftDefault: true},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"BHD": {DraftDefault: true},
+				},
+			},
+		}),
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if entry.Payload["category_id"] != "2" {
+		t.Fatalf("expected tv category 2, got %q", entry.Payload["category_id"])
+	}
+	if entry.Payload["type"] != "1080p" {
+		t.Fatalf("expected type 1080p, got %q", entry.Payload["type"])
+	}
+	if entry.Payload["source"] != "WEB" {
+		t.Fatalf("expected source WEB, got %q", entry.Payload["source"])
+	}
+	if entry.Payload["imdb_id"] != "456" {
+		t.Fatalf("expected numeric imdb_id, got %q", entry.Payload["imdb_id"])
+	}
+	if entry.Payload["tmdb_id"] != "123" {
+		t.Fatalf("expected numeric tmdb_id, got %q", entry.Payload["tmdb_id"])
+	}
+	if entry.Payload["live"] != "0" {
+		t.Fatalf("expected live=0 for draft default, got %q", entry.Payload["live"])
+	}
+	if entry.Payload["pack"] != "1" {
+		t.Fatalf("expected pack=1, got %q", entry.Payload["pack"])
+	}
+	if entry.Payload["special"] != "1" {
+		t.Fatalf("expected special=1, got %q", entry.Payload["special"])
+	}
+	if entry.Payload["edition"] != "Director" {
+		t.Fatalf("expected title-cased edition, got %q", entry.Payload["edition"])
+	}
+	if got := entry.Payload["tags"]; !strings.Contains(got, "WEBDL") || !strings.Contains(got, "HDR10+") || !strings.Contains(got, "DV") {
+		t.Fatalf("expected BHD tags in payload, got %q", got)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunPrerequisiteMessagesIncludeAction(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name       string
+		req        trackers.PreparationInput
+		wantCause  string
+		wantAction string
+	}{
+		{
+			name: "missing api key",
+			req: trackers.PreparationInput{
+				Tracker: "BHD",
+				Meta:    api.UploadSubject{Identity: api.ExternalIdentity{TMDBID: 123}},
+				Logger:  api.NopLogger{},
+			},
+			wantCause:  "missing api_key",
+			wantAction: "configure the BHD api_key",
+		},
+		{
+			name: "missing tmdb id",
+			req: trackers.PreparationInput{
+				Tracker:       "BHD",
+				TrackerConfig: config.TrackerConfig{APIKey: "token"},
+				Logger:        api.NopLogger{},
+			},
+			wantCause:  "missing tmdb id",
+			wantAction: "refresh metadata or set a TMDB id",
+		},
+		{
+			name: "missing mediainfo text",
+			req: trackers.PreparationInput{
+				Tracker:       "BHD",
+				TrackerConfig: config.TrackerConfig{APIKey: "token"},
+				Meta:          api.UploadSubject{Identity: api.ExternalIdentity{TMDBID: 123}},
+				Logger:        api.NopLogger{},
+			},
+			wantCause:  "missing mediainfo text",
+			wantAction: "generate or attach MediaInfo",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			_, err := New().prepareDryRun(context.Background(), tc.req)
+			if err == nil {
+				t.Fatalf("expected prerequisite error")
+			}
+			message := err.Error()
+			if !strings.Contains(message, tc.wantCause) {
+				t.Fatalf("expected cause %q in error, got %q", tc.wantCause, message)
+			}
+			if !strings.Contains(message, tc.wantAction) {
+				t.Fatalf("expected action %q in error, got %q", tc.wantAction, message)
+			}
+		})
+	}
+}
+
+func TestDefinitionBuildUploadDryRunKeepsWaivableContainerDiagnosticOutOfPayloadReadiness(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	preview, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Movie.avi"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity:          api.ExternalIdentity{TMDBID: 123, Category: "MOVIE"},
+			Type:              "REMUX",
+			Source:            "BLURAY",
+			Container:         "avi",
+			Release:           api.ReleaseInfo{Resolution: "1080p"},
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("prepare dry run: %v", err)
+	}
+	if preview.Status != "ready" {
+		t.Fatalf("dry-run status = %q, want ready", preview.Status)
+	}
+}
+
+func TestResolveTypeRejectsBHD576iResolution(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{Release: api.ReleaseInfo{Resolution: "576i"}}
+	if got := resolveType(meta); got != "Other" {
+		t.Fatalf("expected BHD type Other for 576i, got %q", got)
+	}
+}
+
+func TestResolveTypeRejectsHDDVDRemuxEvenWithUHD(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Type:   "REMUX",
+		Source: "HDDVD",
+		UHD:    "UHD",
+	}
+	if got := resolveType(meta); got != "Other" {
+		t.Fatalf("expected BHD type Other for HD-DVD remux, got %q", got)
+	}
+}
+
+func TestDefinitionBuildUploadDryRunRejectsInvalidSource(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Example.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	_, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Example.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity:          api.ExternalIdentity{TMDBID: 123, Category: "MOVIE"},
+			Release:           api.ReleaseInfo{Resolution: "1080p"},
+			Type:              "WEBDL",
+			Source:            "CAM",
+			Container:         "mkv",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Logger:        api.NopLogger{},
+	})
+	if err == nil || !strings.Contains(err.Error(), "unsupported source") {
+		t.Fatalf("expected unsupported source error, got %v", err)
+	}
+}
+
+func TestUploadRetriesInvalidIMDb(t *testing.T) {
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	calls := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/upload/token" {
+			http.NotFound(w, r)
+			return
+		}
+		if err := r.ParseMultipartForm(4 << 20); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		if len(r.MultipartForm.File["mediainfo"]) != 1 {
+			t.Errorf("expected mediainfo file part")
+			return
+		}
+		if filename := r.MultipartForm.File["mediainfo"][0].Filename; filename != "upload" {
+			t.Errorf("expected Upload-Assistant-compatible mediainfo filename, got %q", filename)
+			return
+		}
+		if len(r.MultipartForm.File["file"]) != 1 {
+			t.Errorf("expected torrent file part")
+			return
+		}
+		if contentType := r.MultipartForm.File["file"][0].Header.Get("Content-Type"); contentType != "application/x-bittorrent" {
+			t.Errorf("expected Upload-Assistant-compatible torrent content type, got %q", contentType)
+			return
+		}
+		calls++
+		imdbID := r.FormValue("imdb_id")
+		tmdbID := r.FormValue("tmdb_id")
+		if tmdbID != "123" {
+			t.Errorf("expected tmdb_id 123, got %q", tmdbID)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if calls == 1 {
+			if imdbID != "456" {
+				t.Errorf("expected first imdb_id 456, got %q", imdbID)
+				return
+			}
+			_, _ = fmt.Fprint(w, `{"status_code":0,"status_message":"Invalid imdb_id"}`)
+			return
+		}
+		if imdbID != "1" {
+			t.Errorf("expected retried imdb_id 1, got %q", imdbID)
+			return
+		}
+		_, _ = fmt.Fprint(w, `{"status_code":1,"status_message":"https://beyond-hd.me/torrent/download/example.7890.torrent"}`)
+	}))
+	defer server.Close()
+
+	originalBaseURL := bhdBaseURL
+	bhdBaseURL = server.URL
+	defer func() { bhdBaseURL = originalBaseURL }()
+
+	summary, err := New().submit(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity: api.ExternalIdentity{
+				TMDBID:   123,
+				IMDBID:   456,
+				Category: "MOVIE",
+			},
+			ReleaseName: "Movie.2025.1080p.BluRay.DD+5.1.H264-GRP",
+			Release:     api.ReleaseInfo{Resolution: "1080p"},
+			Type:        "REMUX",
+			Source:      "BluRay",
+			Audio:       "DD+ 5.1",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if calls != 2 {
+		t.Fatalf("expected 2 upload attempts, got %d", calls)
+	}
+	if summary.Uploaded != 1 {
+		t.Fatalf("expected one upload, got %d", summary.Uploaded)
+	}
+	if len(summary.UploadedTorrents) != 1 || summary.UploadedTorrents[0].TorrentID != "7890" {
+		t.Fatalf("unexpected uploaded torrents: %+v", summary.UploadedTorrents)
+	}
+}
+
+func TestSendUploadRejectsOversizedResponseBody(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "Example.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = fmt.Fprint(w, strings.Repeat("x", int(bhdUploadResponseMaxBytes)+1))
+	}))
+	defer server.Close()
+
+	originalBaseURL := bhdBaseURL
+	bhdBaseURL = server.URL
+	defer func() { bhdBaseURL = originalBaseURL }()
+
+	_, err := sendUpload(context.Background(), trackers.PreparationInput{
+		Tracker:       "BHD",
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	}, uploadState{
+		torrentPath: torrentPath,
+		fields: map[string]string{
+			"name":        "Example.Release.2026.1080p-GRP",
+			"category_id": "1",
+			"type":        "1080p",
+			"source":      "WEB",
+			"tmdb_id":     "movie/123456",
+			"description": "Example description",
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "response body exceeds") {
+		t.Fatalf("expected oversized response error, got %v", err)
+	}
+}
+
+func TestSendUploadRejectsNonSuccessHTTPStatus(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "Example.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	tests := []struct {
+		name       string
+		statusCode int
+		body       string
+		wantDetail string
+	}{
+		{
+			name:       "valid-looking success body",
+			statusCode: http.StatusInternalServerError,
+			body:       `{"status_code":1,"status_message":"https://beyond-hd.me/torrent/download/example.123456.torrent"}`,
+		},
+		{
+			name:       "ordinary error body",
+			statusCode: http.StatusUnprocessableEntity,
+			body:       `{"message":"upload rejected"}`,
+			wantDetail: "upload rejected",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(tt.statusCode)
+				_, _ = fmt.Fprint(w, tt.body)
+			}))
+			defer server.Close()
+
+			originalBaseURL := bhdBaseURL
+			bhdBaseURL = server.URL
+			defer func() { bhdBaseURL = originalBaseURL }()
+
+			responseBody, err := sendUpload(context.Background(), trackers.PreparationInput{
+				Tracker:       "BHD",
+				TrackerConfig: config.TrackerConfig{APIKey: "token"},
+			}, uploadState{
+				torrentPath: torrentPath,
+				fields: map[string]string{
+					"name":        "Example.Release.2026.1080p-GRP",
+					"category_id": "1",
+					"type":        "1080p",
+					"source":      "WEB",
+					"tmdb_id":     "movie/123456",
+					"description": "Example description",
+				},
+			})
+			if err == nil {
+				t.Fatal("expected non-success HTTP status error")
+			}
+			if !strings.Contains(err.Error(), fmt.Sprintf("status=%d", tt.statusCode)) {
+				t.Fatal("expected HTTP status in upload error")
+			}
+			if tt.wantDetail != "" && !strings.Contains(err.Error(), tt.wantDetail) {
+				t.Fatal("expected redacted response detail in upload error")
+			}
+			if string(responseBody) != tt.body {
+				t.Fatal("expected bounded response body to be returned")
+			}
+		})
+	}
+}
+
+func TestWriteFailureArtifactPreservesRepeatedFailures(t *testing.T) {
+	tmp := t.TempDir()
+	req := trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			SourcePath: filepath.Join(tmp, "Example.Release.2026.1080p-GRP.mkv"),
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "upbrr.db")},
+		}),
+	}
+
+	firstPayload := []byte(`{"message":"first failure"}`)
+	firstPath, err := writeFailureArtifact(req, firstPayload, "upload_failure")
+	if err != nil {
+		t.Fatalf("write first failure artifact: %v", err)
+	}
+	secondPayload := []byte(`{"message":"second failure"}`)
+	secondPath, err := writeFailureArtifact(req, secondPayload, "upload_failure")
+	if err != nil {
+		t.Fatalf("write second failure artifact: %v", err)
+	}
+
+	firstInfo, err := os.Stat(firstPath)
+	if err != nil {
+		t.Fatalf("stat first failure artifact: %v", err)
+	}
+	secondInfo, err := os.Stat(secondPath)
+	if err != nil {
+		t.Fatalf("stat second failure artifact: %v", err)
+	}
+	if os.SameFile(firstInfo, secondInfo) {
+		t.Fatal("repeated failures must use distinct artifacts")
+	}
+	firstStored, err := os.ReadFile(firstPath)
+	if err != nil {
+		t.Fatalf("read first failure artifact: %v", err)
+	}
+	secondStored, err := os.ReadFile(secondPath)
+	if err != nil {
+		t.Fatalf("read second failure artifact: %v", err)
+	}
+	if string(firstStored) != string(firstPayload) || string(secondStored) != string(secondPayload) {
+		t.Fatal("repeated failure artifacts did not preserve both payloads")
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesProvidedAssets(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			Options: api.UploadOptions{Screens: 4},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: `[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
+			Screenshots: []api.ScreenshotImage{{
+				RawURL: "https://img.hdbits.org/full.jpg",
+				ImgURL: "https://t.hdbits.org/thumb.jpg",
+				WebURL: "https://img.hdbits.org/page",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
+		t.Fatalf("expected single signature, got %q", result.Description)
+	}
+	if !strings.Contains(result.Description, "[img width=350]https://img.hdbits.org/full.jpg[/img]") {
+		t.Fatalf("expected raw image url to be used, got %q", result.Description)
+	}
+}
+
+func TestBuildScreenshotSectionUsesTwoImagesPerRow(t *testing.T) {
+	images := []api.ScreenshotImage{
+		{RawURL: "https://img.example/1.png", WebURL: "https://img.example/1"},
+		{RawURL: "https://img.example/2.png", WebURL: "https://img.example/2"},
+		{RawURL: "https://img.example/3.png", WebURL: "https://img.example/3"},
+		{RawURL: "https://img.example/4.png", WebURL: "https://img.example/4"},
+	}
+
+	got := buildScreenshotSection(images, len(images))
+	want := strings.Join([]string{
+		`[align=center][url=https://img.example/1][img width=350]https://img.example/1.png[/img][/url] [url=https://img.example/2][img width=350]https://img.example/2.png[/img][/url]`,
+		``,
+		`[url=https://img.example/3][img width=350]https://img.example/3.png[/img][/url] [url=https://img.example/4][img width=350]https://img.example/4.png[/img][/url][/align]`,
+	}, "\n")
+	if got != want {
+		t.Fatalf("unexpected BHD screenshot layout: %q", got)
+	}
+}
+
+func TestDefinitionBuildDescriptionStripsLegacyCreatedFooter(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			Options: api.UploadOptions{Screens: 4},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: strings.Join([]string{
+				"Body",
+				`[align=right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/align]`,
+			}, "\n\n"),
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(result.Description, "Created by upbrr") {
+		t.Fatalf("expected legacy footer stripped, got %q", result.Description)
+	}
+	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
+		t.Fatalf("expected single current footer, got %q", result.Description)
+	}
+	if !strings.Contains(result.Description, "Body") {
+		t.Fatalf("expected body preserved, got %q", result.Description)
+	}
+}
+
+func TestDefinitionBuildDescriptionDoesNotRestoreRawImagesOnlyBody(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			Options: api.UploadOptions{Screens: 4},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: strings.Join([]string{
+				`[url=https://example.com/page][img]https://example.com/full.jpg[/img][/url]`,
+				`[right]Created by Upload Assistant[/right]`,
+			}, "\n\n"),
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(result.Description, "Upload Assistant") {
+		t.Fatalf("expected bot footer stripped, got %q", result.Description)
+	}
+	if strings.Count(result.Description, "https://example.com/full.jpg") != 1 {
+		t.Fatalf("expected one screenshot instance, got %q", result.Description)
+	}
+	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
+		t.Fatalf("expected single current footer, got %q", result.Description)
+	}
+}
+
+func TestDefinitionBuildDescriptionStripsRightFormUpbrrFooter(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			Options: api.UploadOptions{Screens: 4},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: strings.Join([]string{
+				"Body",
+				`[right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/right]`,
+			}, "\n\n"),
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
+		t.Fatalf("expected only current BHD footer, got %q", result.Description)
+	}
+	if strings.Contains(result.Description, "[right]") || strings.Contains(result.Description, "[size=10]upbrr[/size]") {
+		t.Fatalf("expected right-form footer stripped, got %q", result.Description)
+	}
+	if !strings.Contains(result.Description, "Body") {
+		t.Fatalf("expected body preserved, got %q", result.Description)
+	}
+}
+
+func TestDefinitionBuildDescriptionDoesNotRestoreBotOnlyBody(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "BHD",
+		Meta: api.UploadSubject{
+			Options: api.UploadOptions{Screens: 4},
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: `[right]Created by Upload Assistant[/right]`,
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(result.Description, "Upload Assistant") {
+		t.Fatalf("expected bot-only body stripped, got %q", result.Description)
+	}
+	if strings.Count(result.Description, "Uploaded by upbrr") != 1 {
+		t.Fatalf("expected single current footer, got %q", result.Description)
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/description.go b/internal/trackers/impl/standalone/bhd/description.go
new file mode 100644
index 00000000..ca967c6a
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/description.go
@@ -0,0 +1,191 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func buildDescription(meta api.UploadSubject, cfg config.Config, assets trackers.DescriptionAssets) string {
+	base := strings.TrimSpace(assets.Description)
+	if assets.Final {
+		return base
+	}
+
+	cleaned := CleanDescription(base, BBCodeOptions{
+		Framestor: hasGroup(meta.Tag, "framestor"),
+		Flux:      hasGroup(meta.Tag, "flux"),
+	})
+
+	descriptionBody := strings.TrimSpace(cleaned.Description)
+	descriptionBody = stripUASignature(descriptionBody)
+	descriptionBody = strings.ReplaceAll(descriptionBody, "[img]", "[img width=300]")
+
+	images := assets.Screenshots
+	if len(images) == 0 {
+		images = screenshotsFromReport(cleaned.Images)
+	}
+
+	parts := make([]string, 0, 5)
+	if discSection := buildDiscSection(meta, cfg.MainSettings.DBPath); discSection != "" {
+		parts = append(parts, discSection)
+	}
+	if descriptionBody != "" {
+		parts = append(parts, descriptionBody)
+	}
+	if screenshots := buildScreenshotSection(images, maxInt(1, meta.Options.Screens)); screenshots != "" {
+		parts = append(parts, screenshots)
+	}
+	parts = append(parts, `[align=right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/align]`)
+	return strings.TrimSpace(strings.Join(parts, "\n\n"))
+}
+
+func buildDiscSection(meta api.UploadSubject, dbPath string) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "DVD":
+		media := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
+		if media == "" {
+			return ""
+		}
+		return fmt.Sprintf("[spoiler=VOB MediaInfo][code]%s[/code][/spoiler]", media)
+	case "BDMV":
+		text := readBDInfoNoErr(dbPath, meta)
+		if text == "" {
+			return ""
+		}
+		return fmt.Sprintf("[spoiler=BDINFO][code]%s[/code][/spoiler]", text)
+	default:
+		return ""
+	}
+}
+
+func buildScreenshotSection(images []api.ScreenshotImage, limit int) string {
+	if len(images) == 0 || limit <= 0 {
+		return ""
+	}
+
+	var section strings.Builder
+	section.WriteString("[align=center]")
+	count := 0
+	for _, image := range images {
+		if count >= limit {
+			break
+		}
+		imgURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.RawURL), strings.TrimSpace(image.ImgURL))
+		webURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.WebURL), strings.TrimSpace(image.RawURL), imgURL)
+		if imgURL == "" || webURL == "" {
+			continue
+		}
+		if count > 0 {
+			if count%2 == 0 {
+				section.WriteString("\n\n")
+			} else {
+				section.WriteByte(' ')
+			}
+		}
+		line := fmt.Sprintf("[url=%s][img width=350]%s[/img][/url]", webURL, imgURL)
+		section.WriteString(line)
+		count++
+	}
+	if count == 0 {
+		return ""
+	}
+	section.WriteString("[/align]")
+	return section.String()
+}
+
+func screenshotsFromReport(images []bbcode.Image) []api.ScreenshotImage {
+	if len(images) == 0 {
+		return nil
+	}
+	out := make([]api.ScreenshotImage, 0, len(images))
+	for idx, image := range images {
+		imgURL := strings.TrimSpace(image.ImgURL)
+		rawURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.RawURL), imgURL)
+		webURL := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(image.WebURL), rawURL, imgURL)
+		if imgURL == "" && rawURL == "" {
+			continue
+		}
+		out = append(out, api.ScreenshotImage{
+			Index:  idx,
+			Host:   strings.TrimSpace(image.Host),
+			ImgURL: metautil.FirstNonEmptyTrimmed(imgURL, rawURL),
+			RawURL: rawURL,
+			WebURL: webURL,
+		})
+	}
+	return out
+}
+
+func stripUASignature(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	signatures := []string{
+		`[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`,
+		`[align=right][url=https://github.com/autobrr/upbrr]upbrr[/url][/align]`,
+		`[align=right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/align]`,
+		`[align=right]Created by upbrr[/align]`,
+		`[align=right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/align]`,
+		`[right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/right]`,
+		`[right][url=https://github.com/autobrr/upbrr]upbrr[/url][/right]`,
+		`[right][url=https://github.com/autobrr/upbrr]Created by upbrr[/url][/right]`,
+		`[right]Created by upbrr[/right]`,
+		`[right][url=https://github.com/autobrr/upbrr]Uploaded by upbrr[/url][/right]`,
+	}
+	for _, signature := range signatures {
+		trimmed = strings.TrimSpace(strings.ReplaceAll(trimmed, signature, ""))
+	}
+	return trimmed
+}
+
+func readTextFileNoErr(path string) string {
+	trimmed := strings.TrimSpace(path)
+	if trimmed == "" {
+		return ""
+	}
+	payload, err := os.ReadFile(trimmed)
+	if err != nil {
+		return ""
+	}
+	return string(payload)
+}
+
+func readBDInfoNoErr(dbPath string, meta api.UploadSubject) string {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return ""
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return ""
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return ""
+	}
+	return readTextFileNoErr(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)))
+}
+
+func hasGroup(tag string, name string) bool {
+	trimmed := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(tag, "-")))
+	return trimmed == strings.ToLower(strings.TrimSpace(name))
+}
+
+func maxInt(left int, right int) int {
+	if left > right {
+		return left
+	}
+	return right
+}
diff --git a/internal/trackers/impl/standalone/bhd/dupe.go b/internal/trackers/impl/standalone/bhd/dupe.go
new file mode 100644
index 00000000..b3910e11
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/dupe.go
@@ -0,0 +1,262 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var seasonPattern = regexp.MustCompile(`(?i)S(\d{1,2})`)
+
+type dupeSearcher struct {
+	cfg     config.Config
+	http    *http.Client
+	baseURL string
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:     cfg,
+		http:    httpClient,
+		baseURL: "https://beyond-hd.me/api/torrents/",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	cfg, apiKey := bhdConfig(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	tmdbID, imdbID := meta.Identity.TMDBID, bhdIMDB(meta.Identity.IMDBID)
+	if tmdbID == 0 && imdbID == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing tmdb/imdb id for BHD dupe search", nil)
+	}
+	category, tmdbPrefix := "Movies", "movie"
+	if strings.EqualFold(string(meta.Identity.Category), "TV") {
+		category, tmdbPrefix = "TV", "tv"
+	}
+	payload := map[string]any{"action": "search", "categories": category}
+	if searchType, ok := dupeSearchType(meta); ok {
+		payload["types"] = searchType
+	} else {
+		payload["types"] = nil
+	}
+	if dupeIsSD(meta) {
+		payload["categories"], payload["types"] = nil, nil
+	}
+	if tmdbID != 0 {
+		payload["tmdb_id"] = tmdbPrefix + "/" + strconv.Itoa(tmdbID)
+	} else {
+		payload["imdb_id"] = imdbID
+	}
+	if season := bhdSeason(meta); season != "" && category == "TV" {
+		payload["search"] = season
+	}
+	if rss := strings.TrimSpace(cfg.BhdRSSKey); rss != "" {
+		payload["rsskey"] = rss
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "BHD request failed", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.baseURL+apiKey, bytes.NewReader(body))
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "BHD request failed", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "BHD request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "BHD search failed", nil)
+	}
+	var decoded map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&decoded); err != nil || len(decoded) == 0 {
+		return dupe.Failed(dupe.FailureResponseParse, "BHD search failed", err)
+	}
+	if bhdInt(decoded["status_code"]) == 0 {
+		return dupe.Failed(dupe.FailureResponseStatus, "BHD api rejected search", nil)
+	}
+	return dupe.Resolved(bhdEntries(decoded), nil)
+}
+
+func bhdEntries(payload map[string]any) []api.DupeEntry {
+	results, _ := payload["results"].([]any)
+	entries := make([]api.DupeEntry, 0, len(results))
+	for _, raw := range results {
+		item, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		entry := api.DupeEntry{Name: bhdString(item["name"]), Link: bhdString(item["url"])}
+		if size := bhdInt(item["size"]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		if bhdInt(item["dv"]) == 1 {
+			entry.Flags = append(entry.Flags, "DV")
+		}
+		if bhdInt(item["hdr10"]) == 1 || bhdInt(item["hdr10+"]) == 1 {
+			entry.Flags = append(entry.Flags, "HDR")
+		}
+		entries = append(entries, entry)
+	}
+	return entries
+}
+
+func bhdConfig(cfg config.Config) (config.TrackerConfig, string) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "BHD") {
+			return entry, strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return config.TrackerConfig{}, ""
+}
+
+func bhdSeason(meta api.DuplicateSubject) string {
+	if meta.ReleaseNameOverrides.Season != nil {
+		return normalizeBHDSeason(*meta.ReleaseNameOverrides.Season)
+	}
+	match := seasonPattern.FindStringSubmatch(meta.ReleaseName)
+	if len(match) == 2 {
+		return normalizeBHDSeason(match[1])
+	}
+	return ""
+}
+
+func dupeSearchType(meta api.DuplicateSubject) (string, bool) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return "", false
+	}
+	return dupeType(meta), true
+}
+
+func dupeType(meta api.DuplicateSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		size := 100
+		for _, candidate := range []int{25, 50, 66, 100} {
+			if meta.SourceSize > 0 && meta.SourceSize < int64(candidate)<<30 {
+				size = candidate
+				break
+			}
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && size != 25 {
+			if size == 50 || size == 66 || size == 100 {
+				return fmt.Sprintf("UHD %d", size)
+			}
+			return "Other"
+		}
+		if size == 25 || size == 50 {
+			return fmt.Sprintf("BD %d", size)
+		}
+		return "Other"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		upper := strings.ToUpper(strings.TrimSpace(meta.Release.Size))
+		switch {
+		case strings.Contains(upper, "DVD5"):
+			return "DVD 5"
+		case strings.Contains(upper, "DVD9"):
+			return "DVD 9"
+		default:
+			return "Other"
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(firstNonEmpty(meta.Type, meta.Release.Type)), "REMUX") {
+		source := firstNonEmpty(meta.Source, meta.Release.Source)
+		switch {
+		case isHDDVDSource(source):
+			return "Other"
+		case strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD"):
+			return "UHD Remux"
+		case isDVDSource(source):
+			return "DVD Remux"
+		case strings.EqualFold(strings.TrimSpace(source), "BluRay"), strings.EqualFold(strings.TrimSpace(source), "Blu-ray"):
+			return "BD Remux"
+		default:
+			return "Other"
+		}
+	}
+	resolution := normalizeResolution(meta.Release.Resolution)
+	switch resolution {
+	case "2160p", "1080p", "1080i", "720p", "576p", "540p", "480p":
+		return resolution
+	default:
+		return "Other"
+	}
+}
+
+func dupeIsSD(meta api.DuplicateSubject) bool {
+	resolution := normalizeResolution(meta.Release.Resolution)
+	return strings.Contains(resolution, "480") || strings.Contains(resolution, "540") || strings.Contains(resolution, "576")
+}
+
+func normalizeBHDSeason(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	if strings.HasPrefix(strings.ToUpper(trimmed), "S") {
+		return strings.ToUpper(trimmed)
+	}
+	if number, err := strconv.Atoi(trimmed); err == nil {
+		return "S" + strconv.Itoa(number)
+	}
+	return strings.ToUpper(trimmed)
+}
+
+func bhdIMDB(id int) string {
+	if id == 0 {
+		return ""
+	}
+	return fmt.Sprintf("tt%07d", id)
+}
+
+func bhdString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func bhdInt(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case int:
+		return int64(typed)
+	case int64:
+		return typed
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/dupe_test.go b/internal/trackers/impl/standalone/bhd/dupe_test.go
new file mode 100644
index 00000000..c37707d4
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/dupe_test.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+type bhdRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f bhdRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
+
+func bhdStringFromAny(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func TestBHDSearchUsesExternalIDs(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name         string
+		meta         api.DuplicateSubject
+		wantTMDBID   string
+		wantIMDBID   string
+		wantCategory string
+		wantType     string
+		wantNilType  bool
+		wantNilCat   bool
+	}{
+		{
+			name: "tv tmdb id",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				Identity:   api.ExternalIdentity{TMDBID: 123, Category: "TV"},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+			},
+			wantTMDBID:   "tv/123",
+			wantCategory: "TV",
+			wantType:     "1080p",
+		},
+		{
+			name: "movie tmdb id",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				Identity:   api.ExternalIdentity{TMDBID: 234, Category: "MOVIE"},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+			},
+			wantTMDBID:   "movie/234",
+			wantCategory: "Movies",
+			wantType:     "1080p",
+		},
+		{
+			name: "tmdb takes precedence over imdb",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				Identity: api.ExternalIdentity{
+					TMDBID:   123,
+					IMDBID:   7654321,
+					Category: "MOVIE",
+				},
+				Release: api.ReleaseInfo{Resolution: "2160p"},
+			},
+			wantTMDBID:   "movie/123",
+			wantCategory: "Movies",
+			wantType:     "2160p",
+		},
+		{
+			name: "imdb id",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				Identity:   api.ExternalIdentity{IMDBID: 1234567, Category: "MOVIE"},
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+			},
+			wantIMDBID:   "tt1234567",
+			wantCategory: "Movies",
+			wantType:     "1080p",
+		},
+		{
+			name: "sd clears category and type filters",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				Identity:   api.ExternalIdentity{TMDBID: 123, Category: "MOVIE"},
+				Release:    api.ReleaseInfo{Resolution: "576p"},
+			},
+			wantTMDBID:  "movie/123",
+			wantNilType: true,
+			wantNilCat:  true,
+		},
+		{
+			name: "dvd clears type filter",
+			meta: api.DuplicateSubject{
+				SourcePath: "source",
+				DiscType:   "DVD",
+				Identity:   api.ExternalIdentity{TMDBID: 123, Category: "MOVIE"},
+				Release:    api.ReleaseInfo{Size: "DVD9"},
+			},
+			wantTMDBID:   "movie/123",
+			wantCategory: "Movies",
+			wantNilType:  true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			var payload map[string]any
+			client := &http.Client{Transport: bhdRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+				body, err := io.ReadAll(req.Body)
+				if err != nil {
+					t.Fatalf("read request body: %v", err)
+				}
+				if err := json.Unmarshal(body, &payload); err != nil {
+					t.Fatalf("decode request body: %v", err)
+				}
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body: io.NopCloser(bytes.NewBufferString(
+						`{"status_code":1,"results":[{"name":"Example.Release.2026.1080p-GRP"}]}`,
+					)),
+					Header: make(http.Header),
+				}, nil
+			})}
+			cfg := config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+				"BHD": {APIKey: "placeholder"},
+			}}}
+			handler := dupe.NewAdapter(New(), "BHD", cfg, client, api.NopLogger{})
+
+			entries, notes, err := adapterEvidence(handler.Search(context.Background(), tc.meta))
+			if err != nil {
+				t.Fatalf("search failed: %v", err)
+			}
+			if len(notes) != 0 {
+				t.Fatalf("unexpected display notes: %v", notes)
+			}
+			if len(entries) != 1 {
+				t.Fatalf("expected one result, got %#v", entries)
+			}
+			if got := bhdStringFromAny(payload["tmdb_id"]); got != tc.wantTMDBID {
+				t.Fatalf("expected tmdb_id %q, got %q", tc.wantTMDBID, got)
+			}
+			if got := bhdStringFromAny(payload["imdb_id"]); got != tc.wantIMDBID {
+				t.Fatalf("expected imdb_id %q, got %q", tc.wantIMDBID, got)
+			}
+			if tc.wantNilCat {
+				if value, ok := payload["categories"]; !ok || value != nil {
+					t.Fatalf("expected nil category filter, got %#v", value)
+				}
+			} else if got := bhdStringFromAny(payload["categories"]); got != tc.wantCategory {
+				t.Fatalf("expected category %q, got %q", tc.wantCategory, got)
+			}
+			if tc.wantNilType {
+				if value, ok := payload["types"]; !ok || value != nil {
+					t.Fatalf("expected nil type filter, got %#v", value)
+				}
+			} else if got := bhdStringFromAny(payload["types"]); got != tc.wantType {
+				t.Fatalf("expected type %q, got %q", tc.wantType, got)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/metadata.go b/internal/trackers/impl/standalone/bhd/metadata.go
new file mode 100644
index 00000000..56eaea88
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/metadata.go
@@ -0,0 +1,137 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Source maps local source labels to BHD's upload source enum.
+// The boolean is false when BHD has no supported source value for the input.
+func Source(source string) (string, bool) {
+	switch strings.ToUpper(strings.TrimSpace(source)) {
+	case "BLURAY", "BLU-RAY":
+		return "Blu-ray", true
+	case "HDDVD", "HD DVD", "HD-DVD":
+		return "HD-DVD", true
+	case "WEB", "WEB-DL", "WEBDL", "WEBRIP":
+		return "WEB", true
+	case "HDTV", "UHDTV":
+		return "HDTV", true
+	case "NTSC", "PAL", "NTSC DVD", "PAL DVD", "DVD":
+		return "DVD", true
+	default:
+		return "", false
+	}
+}
+
+// SourceForMetadata maps the canonical prepared source.
+func SourceForMetadata(meta api.UploadSubject) (string, bool) {
+	return Source(meta.Source)
+}
+
+// Type maps prepared metadata to BHD's upload/search type enum. Unknown or
+// unsupported combinations return Other, including direct 576i releases and
+// HD-DVD remuxes.
+func Type(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		size := 100
+		for _, candidate := range []int{25, 50, 66, 100} {
+			if meta.SourceSize > 0 && meta.SourceSize < int64(candidate)<<30 {
+				size = candidate
+				break
+			}
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && size != 25 {
+			if size == 50 || size == 66 || size == 100 {
+				return fmt.Sprintf("UHD %d", size)
+			}
+			return "Other"
+		}
+		if size == 25 || size == 50 {
+			return fmt.Sprintf("BD %d", size)
+		}
+		return "Other"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		upper := strings.ToUpper(strings.TrimSpace(meta.Release.Size))
+		switch {
+		case strings.Contains(upper, "DVD5"):
+			return "DVD 5"
+		case strings.Contains(upper, "DVD9"):
+			return "DVD 9"
+		default:
+			return "Other"
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(firstNonEmpty(meta.Type, meta.Release.Type)), "REMUX") {
+		source := firstNonEmpty(meta.Source, meta.Release.Source)
+		switch {
+		case isHDDVDSource(source):
+			return "Other"
+		case strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD"):
+			return "UHD Remux"
+		case isDVDSource(source):
+			return "DVD Remux"
+		case strings.EqualFold(strings.TrimSpace(source), "BluRay"), strings.EqualFold(strings.TrimSpace(source), "Blu-ray"):
+			return "BD Remux"
+		default:
+			return "Other"
+		}
+	}
+	resolution := normalizeResolution(meta.Release.Resolution)
+	switch resolution {
+	case "2160p", "1080p", "1080i", "720p", "576p", "540p", "480p":
+		return resolution
+	default:
+		return "Other"
+	}
+}
+
+// SearchType returns the BHD search type filter. The boolean is false for DVD
+// searches because BHD matching is broader when the type filter is omitted.
+func SearchType(meta api.UploadSubject) (string, bool) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return "", false
+	}
+	return Type(meta), true
+}
+
+// IsSD reports whether BHD should mark the release as SD or omit HD-only dupe
+// filters.
+func IsSD(meta api.UploadSubject) bool {
+	resolution := normalizeResolution(meta.Release.Resolution)
+	return strings.Contains(resolution, "480") || strings.Contains(resolution, "540") || strings.Contains(resolution, "576")
+}
+
+// IsDVDSource reports whether a source label maps to BHD's DVD source.
+func IsDVDSource(source string) bool {
+	return isDVDSource(source)
+}
+
+func normalizeResolution(value string) string {
+	return strings.ToLower(strings.TrimSpace(value))
+}
+
+func isDVDSource(source string) bool {
+	upper := strings.ToUpper(strings.TrimSpace(source))
+	return upper == "PAL DVD" || upper == "NTSC DVD" || upper == "DVD" || upper == "PAL" || upper == "NTSC"
+}
+
+func isHDDVDSource(source string) bool {
+	upper := strings.ToUpper(strings.TrimSpace(source))
+	return upper == "HDDVD" || upper == "HD DVD" || upper == "HD-DVD"
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/bhd/metadata_test.go b/internal/trackers/impl/standalone/bhd/metadata_test.go
new file mode 100644
index 00000000..0c372e16
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/metadata_test.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestSourceForMetadataDoesNotFallbackToParsedSource(t *testing.T) {
+	t.Parallel()
+
+	got, ok := SourceForMetadata(api.UploadSubject{
+		Release: api.ReleaseInfo{Source: "WEB"},
+	})
+	if ok || got != "" {
+		t.Fatalf("expected missing canonical source to remain unsupported, got source=%q ok=%t", got, ok)
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhd/profile.go b/internal/trackers/impl/standalone/bhd/profile.go
new file mode 100644
index 00000000..70a31592
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/profile.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns BHD identity, preparation, dupe, rules, bans, and policies.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                 "BHD",
+		BaseURL:              bhdBaseURL,
+		DescriptionGroup:     "bhd",
+		UploadContentMode:    trackers.UploadContentModeDescription,
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  newDuplicateAdapter,
+		Rules:                rules(),
+		BannedGroups:         bannedGroups(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "BHD"},
+		AudioPolicy:          &trackers.AudioPolicy{BlockEnglishOriginalWithForeign: true},
+		ImageHostPolicy:      &trackers.ImageHostPolicy{AllowedHosts: []string{"imgbox", "imgbb", "pixhost", "bhd", "bam"}},
+		DupePolicy: &trackers.DupePolicy{
+			MatchAggregateSize:    true,
+			NormalizeDDPlusName:   true,
+			SDMatchesHD:           true,
+			CompareDVDResolution:  true,
+			AllowSizeVariance1080: true,
+		},
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeMovie,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"https://beyond-hd.me", "tracker.beyond-hd.me"},
+			CommentURLPatterns: []string{"https://beyond-hd.me"},
+			DetailIDPattern:    "details/(\\d+)",
+		},
+	}
+}
+
+// Definition extends the shared standalone definition with BHD data lookup.
+type Definition struct{ *standalone.Definition }
+
+// New returns a fresh BHD definition from its tracker-local profile.
+func New() *Definition { return &Definition{Definition: standalone.MustNew(Profile())} }
diff --git a/internal/trackers/impl/standalone/bhd/rules.go b/internal/trackers/impl/standalone/bhd/rules.go
new file mode 100644
index 00000000..614847e2
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/rules.go
@@ -0,0 +1,44 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		RequireValidMISetting: true,
+		BlockAdult:            true,
+		AdultMessage:          "Porn/xxx is not allowed at BHD.",
+		Check:                 checkRequirements,
+	}
+}
+
+func checkRequirements(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "REMUX", "ENCODE", "WEBDL", "WEBRIP":
+		container := strings.ToLower(strings.TrimSpace(meta.Container))
+		if container != "" && container != "mkv" && container != "mp4" {
+			return []api.RuleFailure{trackers.NewRuleFailure(
+				"container",
+				fmt.Sprintf(
+					"Container %q is not allowed for %s. Only MKV and MP4 are permitted.",
+					meta.Container,
+					strings.ToUpper(strings.TrimSpace(meta.Type)),
+				),
+				api.RuleDispositionStrict,
+			)}, nil
+		}
+	}
+	return nil, nil
+}
diff --git a/internal/trackers/impl/standalone/bhd/upload.go b/internal/trackers/impl/standalone/bhd/upload.go
new file mode 100644
index 00000000..cd94d4ea
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhd/upload.go
@@ -0,0 +1,622 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"mime/multipart"
+	"net/http"
+	"net/textproto"
+	"os"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	bhdBaseURL            = "https://beyond-hd.me"
+	bhdTorrentIDPattern   = regexp.MustCompile(`https://beyond-hd\.me/torrent/download/[^\"'\s]+?\.(\d+)\.`)
+	bhdInvalidIMDbPattern = regexp.MustCompile(`(?i)^invalid imdb_id`)
+)
+
+const bhdUploadResponseMaxBytes = commonhttp.DefaultResponsePreviewBytes
+
+type uploadState struct {
+	torrentPath string
+	mediaDump   string
+	description string
+	fields      map[string]string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state, req)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	body, contentType, err := buildMultipartPayload(state.fields, state.mediaDump, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	fallbackFields := maps.Clone(state.fields)
+	fallbackFields["imdb_id"] = "1"
+	fallbackBody, fallbackContentType, err := buildMultipartPayload(fallbackFields, state.mediaDump, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	endpoint := uploadEndpoint(strings.TrimSpace(req.TrackerConfig.APIKey))
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "BHD")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(
+			submitCtx, req, state, endpoint, body, contentType, fallbackBody, fallbackContentType, announceURL, artifactPath,
+		)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	endpoint string,
+	body []byte,
+	contentType string,
+	fallbackBody []byte,
+	fallbackContentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	response, responseBody, err := sendPreparedUpload(ctx, endpoint, body, contentType)
+	if err != nil {
+		return api.UploadSummary{}, err
+	}
+	if response.StatusCode == 0 && bhdInvalidIMDbPattern.MatchString(response.StatusMessage) {
+		response, responseBody, err = sendPreparedUpload(ctx, endpoint, fallbackBody, fallbackContentType)
+		if err != nil {
+			return api.UploadSummary{}, err
+		}
+	}
+	if response.StatusCode == 0 {
+		artifactPath, artifactErr := writeFailureArtifact(req, responseBody, "upload_failure")
+		if artifactErr != nil && req.Logger != nil {
+			req.Logger.Warnf("trackers: BHD failure artifact write failed: %v", artifactErr)
+		}
+		if artifactPath != "" && req.Logger != nil {
+			req.Logger.Warnf("trackers: BHD upload failure artifact saved to %s", artifactPath)
+		}
+		message := commonhttp.ExtractHTTPErrorDetail(responseBody)
+		if message == "" {
+			message = commonhttp.RedactErrorDetail(response.StatusMessage)
+		}
+		if message == "" {
+			message = "upload failed"
+		}
+		return api.UploadSummary{}, fmt.Errorf("trackers: BHD api error: %s", message)
+	}
+
+	torrentID := extractTorrentID(response.StatusMessage)
+	if torrentID == "" {
+		return api.UploadSummary{}, errors.New("trackers: BHD upload succeeded but torrent id was not returned")
+	}
+	torrentURL := strings.TrimRight(bhdBaseURL, "/") + "/details/" + torrentID
+	downloadURL := strings.TrimRight(bhdBaseURL, "/") + "/torrent/download/" + torrentID
+
+	if announceURL != "" {
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, "BHD"); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "BHD",
+			TorrentID:   torrentID,
+			DownloadURL: downloadURL,
+			TorrentURL:  torrentURL,
+			TorrentPath: artifactPath,
+		}},
+	}, nil
+}
+
+func buildUploadPreview(state uploadState, req trackers.PreparationInput) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "BHD",
+		ReleaseName:      state.fields["name"],
+		DescriptionGroup: "bhd",
+		Description:      state.description,
+		Endpoint:         strings.TrimRight(bhdBaseURL, "/") + "/api/upload/[redacted]",
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{
+			{
+				Field:   "mediainfo",
+				Path:    resolveMediaPath(req.Meta, req.Runtime.DBPath),
+				Present: strings.TrimSpace(state.mediaDump) != "",
+			},
+			{
+				Field:   "file",
+				Path:    state.torrentPath,
+				Present: strings.TrimSpace(state.torrentPath) != "",
+			},
+		},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	select {
+	case <-ctx.Done():
+		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: BHD missing api_key; configure the BHD api_key in tracker settings before uploading")
+	}
+	if req.Meta.Identity.TMDBID == 0 {
+		return uploadState{}, errors.New("trackers: BHD missing tmdb id; refresh metadata or set a TMDB id before uploading")
+	}
+	var err error
+	var assets trackers.DescriptionAssets
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+	description := buildDescription(req.Meta, req.Runtime.DescriptionConfig(), assets)
+	mediaDump, err := resolveMediaDump(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, err
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+
+	tags := resolveTags(req.Meta)
+	customEdition, edition := resolveEdition(req.Meta, tags)
+	source, ok := resolveSource(req.Meta)
+	if !ok {
+		return uploadState{}, fmt.Errorf("trackers: BHD unsupported source %q", req.Meta.Source)
+	}
+	fields := map[string]string{
+		"name":        resolveUploadName(req.Meta),
+		"category_id": resolveCategoryID(req.Meta),
+		"type":        resolveType(req.Meta),
+		"source":      source,
+		"imdb_id":     resolveIMDbID(req.Meta),
+		"tmdb_id":     resolveTMDBID(req.Meta),
+		"description": description,
+		"anon":        resolveAnon(req.TrackerConfig),
+		"sd":          boolFlag(isSD(req.Meta)),
+		"live":        resolveLive(req.TrackerConfig),
+	}
+	if req.Runtime.Internal {
+		fields["internal"] = "1"
+	}
+	if req.Meta.TVPack {
+		fields["pack"] = "1"
+	}
+	if strings.EqualFold(strings.TrimSpace(req.Meta.SeasonStr), "S00") {
+		fields["special"] = "1"
+	}
+	if region := resolveRegion(req.Meta.Region); region != "" {
+		fields["region"] = region
+	}
+	if customEdition {
+		fields["custom_edition"] = edition
+	} else if edition != "" {
+		fields["edition"] = edition
+	}
+	if len(tags) > 0 {
+		fields["tags"] = strings.Join(tags, ",")
+	}
+
+	return uploadState{
+		torrentPath: torrentPath,
+		mediaDump:   mediaDump,
+		description: description,
+		fields:      fields,
+	}, nil
+}
+
+func sendPreparedUpload(ctx context.Context, endpoint string, body []byte, contentType string) (uploadResponse, []byte, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	responseBody, err := readUploadResponseBody(resp.Body)
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHD read response: %w", err)
+	}
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return uploadResponse{}, responseBody, commonhttp.UploadHTTPError("BHD", resp.StatusCode, responseBody)
+	}
+	decoded := uploadResponse{}
+	if len(responseBody) > 0 {
+		if err := json.Unmarshal(responseBody, &decoded); err != nil {
+			return uploadResponse{}, responseBody, fmt.Errorf("trackers: BHD decode response: %w", err)
+		}
+	}
+	return decoded, responseBody, nil
+}
+
+func readUploadResponseBody(r io.Reader) ([]byte, error) {
+	responseBody, err := io.ReadAll(io.LimitReader(r, bhdUploadResponseMaxBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("read upload response body: %w", err)
+	}
+	if int64(len(responseBody)) > bhdUploadResponseMaxBytes {
+		return nil, fmt.Errorf("response body exceeds %d bytes", bhdUploadResponseMaxBytes)
+	}
+	return responseBody, nil
+}
+
+type uploadResponse struct {
+	StatusCode    int    `json:"status_code"`
+	StatusMessage string `json:"status_message"`
+}
+
+func buildMultipartPayload(fields map[string]string, mediaDump string, torrentPath string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: BHD write multipart field %q: %w", key, err)
+		}
+	}
+	part, err := writer.CreateFormFile("mediainfo", "upload")
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHD create mediainfo form file: %w", err)
+	}
+	if _, err := io.WriteString(part, mediaDump); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHD write mediainfo form file: %w", err)
+	}
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHD open torrent file: %w", err)
+	}
+	defer file.Close()
+	part, err = writer.CreatePart(textproto.MIMEHeader{
+		"Content-Disposition": {`form-data; name="file"; filename="torrent.torrent"`},
+		"Content-Type":        {"application/x-bittorrent"},
+	})
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHD create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHD copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: BHD close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveMediaDump(meta api.UploadSubject, dbPath string) (string, error) {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		text := readBDInfoNoErr(dbPath, meta)
+		if text == "" {
+			return "", errors.New("trackers: BHD missing BDInfo text; generate or attach BDInfo before uploading")
+		}
+		return text, nil
+	case "DVD":
+		text := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.DVDVOBMediaInfoText), readTextFileNoErr(strings.TrimSpace(meta.MediaInfoTextPath)))
+		if text == "" {
+			return "", errors.New("trackers: BHD missing DVD MediaInfo text; generate or attach DVD MediaInfo before uploading")
+		}
+		return text, nil
+	default:
+		if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
+			return "", errors.New("trackers: BHD missing mediainfo text; generate or attach MediaInfo before uploading")
+		}
+		payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+		if err != nil {
+			return "", fmt.Errorf("trackers: BHD read mediainfo: %w", err)
+		}
+		return string(payload), nil
+	}
+}
+
+func resolveMediaPath(meta api.UploadSubject, dbPath string) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+			return ""
+		}
+		tmpRoot, err := db.Subdir(dbPath, "tmp")
+		if err != nil {
+			return ""
+		}
+		tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+		if err != nil {
+			return ""
+		}
+		return paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists))
+	default:
+		return strings.TrimSpace(meta.MediaInfoTextPath)
+	}
+}
+
+func uploadEndpoint(apiKey string) string {
+	return strings.TrimRight(bhdBaseURL, "/") + "/api/upload/" + strings.TrimSpace(apiKey)
+}
+
+func extractTorrentID(statusMessage string) string {
+	matches := bhdTorrentIDPattern.FindStringSubmatch(strings.TrimSpace(statusMessage))
+	if len(matches) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(matches[1])
+}
+
+func writeFailureArtifact(req trackers.PreparationInput, payload []byte, name string) (string, error) {
+	if strings.TrimSpace(req.Runtime.DBPath) == "" || strings.TrimSpace(req.Meta.SourcePath) == "" {
+		return "", nil
+	}
+	tmpRoot, err := db.Subdir(req.Runtime.DBPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, req.Meta.SourcePath, req.Meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	ext := ".txt"
+	if bytes.Contains(bytes.ToLower(payload), []byte("<html")) {
+		ext = ".html"
+	}
+	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+		return "", fmt.Errorf("trackers: BHD create failure artifact dir: %w", err)
+	}
+	payload = []byte(redaction.RedactValue(string(payload), nil))
+	file, err := os.CreateTemp(tmpDir, "[BHD]"+name+"-*"+ext)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BHD create failure artifact: %w", err)
+	}
+	path := file.Name()
+	if _, err := file.Write(payload); err != nil {
+		_ = file.Close()
+		_ = os.Remove(path)
+		return "", fmt.Errorf("trackers: BHD write failure artifact: %w", err)
+	}
+	if err := file.Close(); err != nil {
+		_ = os.Remove(path)
+		return "", fmt.Errorf("trackers: BHD close failure artifact: %w", err)
+	}
+	return path, nil
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	name := metautil.FirstNonEmptyTrimmed(
+		strings.TrimSpace(meta.ReleaseName),
+		strings.TrimSpace(meta.ReleaseNameNoTag),
+		strings.TrimSpace(meta.Filename),
+		pathutil.Base(meta.SourcePath),
+	)
+	if IsDVDSource(meta.Source) {
+		audio := strings.Join(strings.Fields(strings.TrimSpace(meta.Audio)), " ")
+		if audio != "" && strings.TrimSpace(meta.VideoCodec) != "" {
+			name = strings.Replace(name, audio, strings.TrimSpace(meta.VideoCodec)+" "+audio, 1)
+		}
+	}
+	return strings.ReplaceAll(name, "DD+", "DDP")
+}
+
+func resolveCategoryID(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(string(meta.Identity.Category)), "TV") {
+		return "2"
+	}
+	return "1"
+}
+
+func resolveTMDBID(meta api.UploadSubject) string {
+	if meta.Identity.TMDBID == 0 {
+		return ""
+	}
+	return strconv.Itoa(meta.Identity.TMDBID)
+}
+
+func resolveSource(meta api.UploadSubject) (string, bool) {
+	return SourceForMetadata(meta)
+}
+
+func resolveType(meta api.UploadSubject) string {
+	return Type(meta)
+}
+
+func resolveEdition(meta api.UploadSubject, tags []string) (bool, string) {
+	edition := strings.TrimSpace(meta.Edition)
+	if slices.Contains(tags, "Hybrid") {
+		edition = strings.TrimSpace(strings.ReplaceAll(edition, "Hybrid", ""))
+	}
+	if edition == "" {
+		return false, ""
+	}
+	for _, token := range []string{"collector", "director", "extended", "limited", "special", "theatrical", "uncut", "unrated"} {
+		if strings.Contains(strings.ToLower(edition), token) {
+			switch token {
+			case "director":
+				return false, "Director"
+			default:
+				return false, strings.ToUpper(token[:1]) + token[1:]
+			}
+		}
+	}
+	return true, edition
+}
+
+func resolveTags(meta api.UploadSubject) []string {
+	tags := make([]string, 0, 12)
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "WEBRIP":
+		tags = append(tags, "WEBRip")
+	case "WEBDL", "WEB-DL":
+		tags = append(tags, "WEBDL")
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
+		tags = append(tags, "3D")
+	}
+	audio := strings.ToLower(strings.TrimSpace(meta.Audio))
+	if strings.Contains(audio, "dual-audio") {
+		tags = append(tags, "DualAudio")
+	}
+	if strings.Contains(audio, "dubbed") {
+		tags = append(tags, "EnglishDub")
+	}
+	if strings.Contains(strings.ToLower(meta.Edition), "open matte") {
+		tags = append(tags, "OpenMatte")
+	}
+	if meta.Scene {
+		tags = append(tags, "Scene")
+	}
+	if meta.PersonalRelease {
+		tags = append(tags, "Personal")
+	}
+	if strings.Contains(strings.ToLower(meta.Edition), "hybrid") {
+		tags = append(tags, "Hybrid")
+	}
+	if meta.HasCommentary {
+		tags = append(tags, "Commentary")
+	}
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	if strings.Contains(hdr, "DV") {
+		tags = append(tags, "DV")
+	}
+	if strings.Contains(hdr, "HDR") {
+		if strings.Contains(hdr, "HDR10+") {
+			tags = append(tags, "HDR10+")
+		} else {
+			tags = append(tags, "HDR10")
+		}
+	}
+	if strings.Contains(hdr, "HLG") {
+		tags = append(tags, "HLG")
+	}
+	return dedupeStrings(tags)
+}
+
+func resolveIMDbID(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return strconv.Itoa(meta.Identity.IMDBID)
+	}
+	return "1"
+}
+
+func resolveAnon(cfg config.TrackerConfig) string {
+	if cfg.Anon {
+		return "1"
+	}
+	return "0"
+}
+
+func resolveLive(cfg config.TrackerConfig) string {
+	if cfg.DraftDefault || cfg.Draft {
+		return "0"
+	}
+	return "1"
+}
+
+func resolveRegion(region string) string {
+	allowed := map[string]struct{}{
+		"AUS": {},
+		"CAN": {},
+		"CEE": {},
+		"CHN": {},
+		"ESP": {},
+		"EUR": {},
+		"FRA": {},
+		"GBR": {},
+		"GER": {},
+		"HKG": {},
+		"ITA": {},
+		"JPN": {},
+		"KOR": {},
+		"NOR": {},
+		"NLD": {},
+		"RUS": {},
+		"TWN": {},
+		"USA": {},
+	}
+	upper := strings.ToUpper(strings.TrimSpace(region))
+	if _, ok := allowed[upper]; ok {
+		return upper
+	}
+	return ""
+}
+
+func isSD(meta api.UploadSubject) bool {
+	return IsSD(meta)
+}
+
+func boolFlag(value bool) string {
+	if value {
+		return "1"
+	}
+	return "0"
+}
+
+func dedupeStrings(values []string) []string {
+	seen := make(map[string]struct{}, len(values))
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}
diff --git a/internal/trackers/impl/standalone/bhdtv/definition.go b/internal/trackers/impl/standalone/bhdtv/definition.go
new file mode 100644
index 00000000..781c4e2d
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhdtv/definition.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhdtv
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+
+	description := buildDescription(assets)
+	return trackers.DescriptionResult{
+		Group:       "bhdtv",
+		Description: description,
+	}, nil
+}
+
+type bhdtvDuplicateAdapter struct{}
+
+func (bhdtvDuplicateAdapter) Search(context.Context, api.DuplicateSubject) dupe.AdapterResult {
+	return dupe.NotRun(dupe.NotRunManualCheckRequired, "BHDTV duplicate search requires a manual check", nil)
+}
diff --git a/internal/trackers/impl/standalone/bhdtv/definition_test.go b/internal/trackers/impl/standalone/bhdtv/definition_test.go
new file mode 100644
index 00000000..f138e708
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhdtv/definition_test.go
@@ -0,0 +1,150 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhdtv
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
+	t.Parallel()
+
+	tempDir := t.TempDir()
+	torrentPath := filepath.Join(tempDir, "input.torrent")
+	mediaPath := filepath.Join(tempDir, "MEDIAINFO_CLEANPATH.txt")
+	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	if err := os.WriteFile(mediaPath, []byte("mediainfo text"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	plan, failure := New().Prepare(context.Background(), trackers.PreparationInput{
+		Tracker: "BHDTV",
+		Intent:  trackers.PreparationIntentDryRun,
+		Meta: api.UploadSubject{
+			SourcePath:                  filepath.Join(tempDir, "Show.S01E01.mkv"),
+			TorrentPath:                 torrentPath,
+			MediaInfoTextPath:           mediaPath,
+			Type:                        "WEBDL",
+			TVPack:                      false,
+			ReleaseName:                 "Show: S01E01 DD+ 1080p WEB-DL H.265",
+			ReleaseNameNoTag:            "Show: S01E01 DD+ 1080p WEB-DL H.265",
+			Identity:                    api.ExternalIdentity{Category: "TV", TVmazeID: 321},
+			ProviderMetadata:            api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDbURL: "https://www.imdb.com/title/tt1234567/"}},
+			TrackerQuestionnaireAnswers: map[string]map[string]string{},
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	})
+	if failure != nil {
+		t.Fatalf("dry run: %v", failure)
+	}
+	entry := plan.DryRun()
+
+	if entry.Tracker != "BHDTV" {
+		t.Fatalf("unexpected tracker %q", entry.Tracker)
+	}
+	if entry.Payload["cat"] != "10" {
+		t.Fatalf("expected tv episode cat 10, got %q", entry.Payload["cat"])
+	}
+	if entry.Payload["subcat"] != "8" {
+		t.Fatalf("expected tv web subcat 8, got %q", entry.Payload["subcat"])
+	}
+	if entry.Payload["resolution"] != "3" {
+		t.Fatalf("expected 1080p resolution 3, got %q", entry.Payload["resolution"])
+	}
+	if entry.Payload["url"] != "https://www.tvmaze.com/shows/321" {
+		t.Fatalf("unexpected url %q", entry.Payload["url"])
+	}
+	if entry.Payload["name"] != "Show.S01E01.DDP.1080p.WEB-DL.H.265" {
+		t.Fatalf("unexpected name %q", entry.Payload["name"])
+	}
+}
+
+func TestUploadParsesViewAndWritesArtifact(t *testing.T) {
+	tempDir := t.TempDir()
+	torrentPath := filepath.Join(tempDir, "input.torrent")
+	mediaPath := filepath.Join(tempDir, "MEDIAINFO_CLEANPATH.txt")
+	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	if err := os.WriteFile(mediaPath, []byte("mediainfo text"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := r.ParseMultipartForm(2 << 20); err != nil {
+			t.Errorf("parse multipart: %v", err)
+			return
+		}
+		if got := r.FormValue("api_key"); got != "token" {
+			t.Error("unexpected api key")
+			return
+		}
+		if got := r.FormValue("cat"); got != "7" {
+			t.Errorf("unexpected cat %q", got)
+			return
+		}
+		if got := r.FormValue("subcat"); got != "48" {
+			t.Errorf("unexpected subcat %q", got)
+			return
+		}
+		if got := r.FormValue("resolution"); got != "4" {
+			t.Errorf("unexpected resolution %q", got)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"data":{"view":"https://www.bit-hdtv.com/details.php?id=99"}}`))
+	}))
+	defer server.Close()
+
+	originalURL := uploadURL
+	uploadURL = server.URL
+	defer func() { uploadURL = originalURL }()
+
+	plan, failure := New().Prepare(context.Background(), trackers.PreparationInput{
+		Tracker: "BHDTV",
+		Intent:  trackers.PreparationIntentUpload,
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tempDir, "Movie.2160p.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaPath,
+			Type:              "REMUX",
+			ReleaseName:       "Movie 2160p REMUX x265",
+			Identity:          api.ExternalIdentity{Category: "MOVIE"},
+		},
+		TrackerConfig: config.TrackerConfig{
+			APIKey: "token",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
+			MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tempDir, "ua.db")},
+		}),
+	})
+	if failure != nil {
+		t.Fatalf("prepare upload: %v", failure)
+	}
+	summary, err := plan.Submit(context.Background())
+	if err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+	if summary.Uploaded != 1 || len(summary.UploadedTorrents) != 1 {
+		t.Fatalf("unexpected summary %#v", summary)
+	}
+	if got := summary.UploadedTorrents[0].TorrentURL; got != "https://www.bit-hdtv.com/details.php?id=99" {
+		t.Fatalf("unexpected torrent url %q", got)
+	}
+	if strings.TrimSpace(summary.UploadedTorrents[0].TorrentPath) != "" {
+		t.Fatal("expected no personalized torrent path without my_announce_url")
+	}
+}
diff --git a/internal/trackers/impl/standalone/bhdtv/profile.go b/internal/trackers/impl/standalone/bhdtv/profile.go
new file mode 100644
index 00000000..1702f0fb
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhdtv/profile.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhdtv
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns BHDTV identity, preparation, dupe, and artifact behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                 "BHDTV",
+		BaseURL:              "https://www.bit-hdtv.com",
+		DescriptionGroup:     "bhdtv",
+		UploadContentMode:    trackers.UploadContentModeDescription,
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  func(dupe.Dependencies) dupe.Adapter { return bhdtvDuplicateAdapter{} },
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "BIT-HDTV", UseMyAnnounce: true},
+	}
+}
+
+// New returns a fresh BHDTV definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/bhdtv/upload.go b/internal/trackers/impl/standalone/bhdtv/upload.go
new file mode 100644
index 00000000..9bb41275
--- /dev/null
+++ b/internal/trackers/impl/standalone/bhdtv/upload.go
@@ -0,0 +1,501 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bhdtv
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	uploadURL  = "https://www.bit-hdtv.com/takeupload.php"
+	sourceFlag = "BIT-HDTV"
+)
+
+type uploadState struct {
+	torrentPath  string
+	releaseName  string
+	screenBlock  string
+	inlineDescr  string
+	mediaDump    string
+	fields       map[string]string
+	artifactPath string
+}
+
+type uploadResponse struct {
+	Status  string `json:"status"`
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	Data    struct {
+		View string `json:"view"`
+	} `json:"data"`
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+) (api.UploadSummary, error) {
+	response, responseBody, err := sendUpload(ctx, body, contentType)
+	if err != nil {
+		return api.UploadSummary{}, err
+	}
+	viewURL := strings.TrimSpace(response.Data.View)
+	if viewURL == "" {
+		artifactPath, artifactErr := writeFailureArtifact(req, responseBody, "upload_failure")
+		if artifactErr != nil && req.Logger != nil {
+			req.Logger.Warnf("trackers: BHDTV failure artifact write failed: %v", artifactErr)
+		}
+		message := metautil.FirstNonEmptyTrimmed(
+			commonhttp.ExtractHTTPErrorDetail(responseBody),
+			commonhttp.RedactErrorDetail(response.Message),
+			commonhttp.RedactErrorDetail(response.Status),
+			"upload response did not include a view URL",
+		)
+		if artifactPath != "" {
+			message += " (" + artifactPath + ")"
+		}
+		return api.UploadSummary{}, fmt.Errorf("trackers: BHDTV %s", message)
+	}
+
+	if strings.TrimSpace(req.TrackerConfig.MyAnnounceURL) != "" {
+		artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "BHDTV")
+		if err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, req.TrackerConfig.MyAnnounceURL, viewURL, sourceFlag); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+		state.artifactPath = artifactPath
+	}
+
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "BHDTV",
+			TorrentURL:  viewURL,
+			DownloadURL: viewURL,
+			TorrentPath: state.artifactPath,
+		}},
+	}, nil
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "BHDTV",
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "bhdtv",
+		Description:      state.screenBlock,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	select {
+	case <-ctx.Done():
+		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: BHDTV missing api_key")
+	}
+
+	descriptionAssets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		descriptionAssets = trackers.DescriptionAssets{}
+	}
+
+	screenBlock := buildDescription(descriptionAssets)
+
+	mediaDump, err := resolveMediaDump(req.Meta)
+	if err != nil {
+		return uploadState{}, err
+	}
+
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+
+	fields := map[string]string{
+		"api_key":    strings.TrimSpace(req.TrackerConfig.APIKey),
+		"name":       resolveUploadName(req.Meta),
+		"mediainfo":  mediaDump,
+		"cat":        resolveCategoryID(req.Meta),
+		"subcat":     resolveSubcategoryID(req.Meta),
+		"resolution": resolveResolutionID(req.Meta),
+		"sdescr":     " ",
+		"descr":      resolveInlineDescription(req.Meta),
+		"screen":     screenBlock,
+		"url":        resolveReferenceURL(req.Meta),
+		"format":     "json",
+	}
+
+	return uploadState{
+		torrentPath: torrentPath,
+		releaseName: fields["name"],
+		screenBlock: screenBlock,
+		inlineDescr: fields["descr"],
+		mediaDump:   mediaDump,
+		fields:      fields,
+	}, nil
+}
+
+func sendUpload(ctx context.Context, body []byte, contentType string) (uploadResponse, []byte, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return uploadResponse{}, nil, fmt.Errorf("trackers: BHDTV read response: %w", err)
+	}
+
+	var decoded uploadResponse
+	if len(responseBody) > 0 {
+		if err := json.Unmarshal(responseBody, &decoded); err != nil {
+			return uploadResponse{}, responseBody, fmt.Errorf("trackers: BHDTV decode response: %w", err)
+		}
+	}
+	return decoded, responseBody, nil
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: BHDTV write multipart field %q: %w", key, err)
+		}
+	}
+
+	file, err := os.Open(strings.TrimSpace(torrentPath))
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHDTV open torrent file: %w", err)
+	}
+	defer file.Close()
+
+	part, err := writer.CreateFormFile("file", filepath.Base(torrentPath))
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHDTV create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: BHDTV copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: BHDTV close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveMediaDump(meta api.UploadSubject) (string, error) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		text := readBDInfoNoErr("", meta)
+		if text == "" {
+			return "", errors.New("trackers: BHDTV missing BD summary")
+		}
+		return text, nil
+	}
+
+	text := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
+	if strings.EqualFold(text, strings.TrimSpace(meta.MediaInfoTextPath)) {
+		payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+		if err != nil {
+			return "", fmt.Errorf("trackers: BHDTV read mediainfo: %w", err)
+		}
+		return string(payload), nil
+	}
+	if strings.TrimSpace(text) != "" {
+		return text, nil
+	}
+	return "", errors.New("trackers: BHDTV missing mediainfo text")
+}
+
+func resolveInlineDescription(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return "Disc so Check Mediainfo dump "
+	}
+	text, err := resolveMediaDump(meta)
+	if err != nil {
+		return ""
+	}
+	return text
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	name := metautil.FirstNonEmptyTrimmed(
+		strings.TrimSpace(meta.ReleaseName),
+		strings.TrimSpace(meta.ReleaseNameNoTag),
+		strings.TrimSpace(meta.Filename),
+		pathutil.Base(meta.SourcePath),
+	)
+	replacer := strings.NewReplacer(" ", ".", ":.", ".", ":", ".", "DD+", "DDP")
+	normalized := replacer.Replace(name)
+	for strings.Contains(normalized, "..") {
+		normalized = strings.ReplaceAll(normalized, "..", ".")
+	}
+	return strings.Trim(normalized, ".")
+}
+
+func resolveCategoryID(meta api.UploadSubject) string {
+	if categoryOf(meta) == "TV" {
+		if meta.TVPack {
+			return "12"
+		}
+		return "10"
+	}
+	return "7"
+}
+
+func resolveSubcategoryID(meta api.UploadSubject) string {
+	if categoryOf(meta) != "TV" {
+		return resolveMovieSubcategory(meta)
+	}
+	if meta.TVPack {
+		return resolveTVPackSubcategory(meta.Type)
+	}
+	return resolveTVEpisodeSubcategory(meta.Type)
+}
+
+func resolveMovieSubcategory(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "DISC":
+		if meta.Is3D != "" {
+			return "46"
+		}
+		return "2"
+	case "REMUX":
+		switch {
+		case strings.Contains(strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.ReleaseNameNoTag)), "265"):
+			return "48"
+		case meta.Is3D != "":
+			return "45"
+		default:
+			return "2"
+		}
+	case "HDTV":
+		return "6"
+	case "ENCODE":
+		switch {
+		case strings.Contains(strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.ReleaseNameNoTag)), "265"):
+			return "43"
+		case meta.Is3D != "":
+			return "44"
+		default:
+			return "1"
+		}
+	case "WEBDL", "WEBRIP":
+		return "5"
+	default:
+		return "0"
+	}
+}
+
+func resolveTVEpisodeSubcategory(typeValue string) string {
+	switch strings.ToUpper(strings.TrimSpace(typeValue)) {
+	case "HDTV":
+		return "7"
+	case "WEBDL", "WEBRIP":
+		return "8"
+	case "ENCODE":
+		return "10"
+	case "REMUX":
+		return "11"
+	case "DISC":
+		return "12"
+	default:
+		return "0"
+	}
+}
+
+func resolveTVPackSubcategory(typeValue string) string {
+	switch strings.ToUpper(strings.TrimSpace(typeValue)) {
+	case "HDTV":
+		return "13"
+	case "WEBDL":
+		return "14"
+	case "WEBRIP":
+		return "8"
+	case "ENCODE":
+		return "16"
+	case "REMUX":
+		return "17"
+	case "DISC":
+		return "18"
+	default:
+		return "0"
+	}
+}
+
+func resolveResolutionID(meta api.UploadSubject) string {
+	switch normalizeResolution(metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.ReleaseName, meta.Filename)) {
+	case "2160P":
+		return "4"
+	case "1080P":
+		return "3"
+	case "1080I":
+		return "2"
+	case "720P":
+		return "1"
+	default:
+		return "10"
+	}
+}
+
+func resolveReferenceURL(meta api.UploadSubject) string {
+	if categoryOf(meta) == "TV" && meta.Identity.TVmazeID != 0 {
+		return fmt.Sprintf("https://www.tvmaze.com/shows/%d", meta.Identity.TVmazeID)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	return ""
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func buildDescription(assets trackers.DescriptionAssets) string {
+	base := strings.ReplaceAll(strings.TrimSpace(assets.Description), "[img=250]", "[img=250x250]")
+	parts := make([]string, 0, 1+len(assets.Screenshots))
+	if base != "" {
+		parts = append(parts, base)
+	}
+	for _, image := range assets.Screenshots {
+		webURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.WebURL, image.RawURL))
+		imgURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL, image.WebURL))
+		if webURL == "" || imgURL == "" {
+			continue
+		}
+		parts = append(parts, fmt.Sprintf("[url=%s][img]%s[/img][/url]", webURL, imgURL))
+	}
+	return strings.Join(parts, " ")
+}
+
+func writeFailureArtifact(req trackers.PreparationInput, payload []byte, name string) (string, error) {
+	if strings.TrimSpace(req.Runtime.DBPath) == "" || strings.TrimSpace(req.Meta.SourcePath) == "" {
+		return "", nil
+	}
+	tmpRoot, err := db.Subdir(req.Runtime.DBPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, req.Meta.SourcePath, req.Meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	ext := ".txt"
+	if bytes.Contains(bytes.ToLower(payload), []byte("<html")) {
+		ext = ".html"
+	}
+	path := filepath.Join(tmpDir, "[BHDTV]"+name+ext)
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return "", fmt.Errorf("trackers: BHDTV create failure artifact dir: %w", err)
+	}
+	payload = []byte(redaction.RedactValue(string(payload), nil))
+	if err := os.WriteFile(path, payload, 0o600); err != nil {
+		return "", fmt.Errorf("trackers: BHDTV write failure artifact: %w", err)
+	}
+	return path, nil
+}
+
+func readBDInfoNoErr(_ string, meta api.UploadSubject) string {
+	if summary := strings.TrimSpace(meta.Disc.Summary); summary != "" {
+		return summary
+	}
+	if infoPath := guessBDInfoPath(meta); infoPath != "" {
+		payload, err := os.ReadFile(infoPath)
+		if err == nil {
+			return strings.TrimSpace(string(payload))
+		}
+	}
+	return ""
+}
+
+func guessBDInfoPath(meta api.UploadSubject) string {
+	if len(meta.SelectedBDMVPlaylists) == 0 {
+		return ""
+	}
+	base := strings.TrimSpace(meta.MediaInfoTextPath)
+	if base != "" {
+		return filepath.Join(filepath.Dir(base), paths.BDMVSummaryFilename(paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)))
+	}
+	return ""
+}
+
+func normalizeResolution(value string) string {
+	upper := strings.ToUpper(strings.TrimSpace(value))
+	for _, candidate := range []string{"2160P", "1080P", "1080I", "720P"} {
+		if strings.Contains(upper, candidate) {
+			return candidate
+		}
+	}
+	return upper
+}
diff --git a/internal/trackers/impl/standalone/bjs/bbcode.go b/internal/trackers/impl/standalone/bjs/bbcode.go
new file mode 100644
index 00000000..be50e040
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/bbcode.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.ConvertNamedSpoilerToNamedHide(value)
+	value = bbcode.ConvertSpoilerToHide(value)
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.ConvertToAlign(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/bjs/definition.go b/internal/trackers/impl/standalone/bjs/definition.go
new file mode 100644
index 00000000..26160558
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/definition.go
@@ -0,0 +1,25 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "bjs", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/bjs/dupe.go b/internal/trackers/impl/standalone/bjs/dupe.go
new file mode 100644
index 00000000..7282d0bb
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/dupe.go
@@ -0,0 +1,257 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	imdb := imdbForLookup(meta)
+	if imdb == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for BJS dupe search", nil)
+	}
+	baseURL := trackerBaseURL(h.cfg, "BJS", "https://bj-share.info")
+	cookies, err := loadTrackerCookies(ctx, h.cfg, "BJS", trackerHost(baseURL, "bj-share.info"))
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid BJS cookies", nil)
+	}
+	resp, root, err := doHTMLGet(ctx, h.http, baseURL+"/torrents.php", url.Values{"searchstr": {imdb}}, cookies)
+	if err != nil || !resp.ok() {
+		return dupe.Failed(dupe.FailureRequest, "BJS search failed", err)
+	}
+	mainColumn := firstNode(root, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "div" && hasClass(node, "main_column")
+	})
+	if mainColumn == nil {
+		return dupe.Resolved(nil, nil)
+	}
+	return dupe.Resolved(extractBJSResults(baseURL, mainColumn, meta), nil)
+}
+
+func extractBJSResults(baseURL string, root *xhtml.Node, meta api.DuplicateSubject) []api.DupeEntry {
+	rows := findNodes(root, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "tr"
+	})
+	entries := make([]api.DupeEntry, 0)
+	currentSeason := ""
+	currentResolution := ""
+	currentEpisode := ""
+	currentPack := false
+	for _, row := range rows {
+		if updateBJSContext(row, &currentSeason, &currentResolution, &currentEpisode, &currentPack) {
+			continue
+		}
+
+		rowID := attrValueHTML(row, "id")
+		if !strings.HasPrefix(rowID, "torrent") || strings.HasPrefix(rowID, "torrent_") {
+			continue
+		}
+		if !shouldProcessBJSRow(currentSeason, currentResolution, currentEpisode, currentPack, meta) {
+			continue
+		}
+
+		entry := bjsEntryFromRow(baseURL, row)
+		if entry.ID != "" || entry.Name != "" {
+			entries = append(entries, entry)
+		}
+	}
+	return entries
+}
+
+func updateBJSContext(row *xhtml.Node, currentSeason *string, currentResolution *string, currentEpisode *string, currentPack *bool) bool {
+	for className := range strings.FieldsSeq(attrValueHTML(row, "class")) {
+		switch className {
+		case "resolution_header":
+			if match := regexp.MustCompile(`(?i)(\d{3,4}p|\d{3,4}i)`).FindStringSubmatch(nodeTextHTML(row)); len(match) == 2 {
+				*currentResolution = strings.ToLower(match[1])
+			}
+			return true
+		case "season_header":
+			if match := regexp.MustCompile(`(?i)temporada\s+(\d+)`).FindStringSubmatch(nodeTextHTML(row)); len(match) == 2 {
+				*currentSeason = match[1]
+			}
+			return true
+		}
+	}
+
+	rowspanCell := firstNode(row, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "td" && attrValueHTML(node, "rowspan") != ""
+	})
+	if rowspanCell == nil {
+		return false
+	}
+	link := firstNode(rowspanCell, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(attrValueHTML(node, "href"), "torrents.php?id=")
+	})
+	if link == nil {
+		return false
+	}
+	text := strings.TrimSpace(nodeTextHTML(link))
+	if strings.Contains(strings.ToLower(text), "temporada") {
+		*currentPack = true
+		*currentEpisode = ""
+		return false
+	}
+	if match := regexp.MustCompile(`(?i)S(\d+)E(\d+)`).FindStringSubmatch(text); len(match) == 3 {
+		*currentPack = false
+		*currentEpisode = match[2]
+	}
+	return false
+}
+
+func shouldProcessBJSRow(currentSeason string, currentResolution string, currentEpisode string, currentPack bool, meta api.DuplicateSubject) bool {
+	category := strings.ToUpper(strings.TrimSpace(string(meta.Identity.Category)))
+	switch category {
+	case "TV":
+		if meta.SeasonInt <= 0 || strings.TrimSpace(currentSeason) == "" {
+			return false
+		}
+		season, err := strconv.Atoi(strings.TrimSpace(currentSeason))
+		if err != nil || season != meta.SeasonInt {
+			return false
+		}
+		if meta.TVPack {
+			return currentPack
+		}
+		if currentPack {
+			return true
+		}
+		episode, err := strconv.Atoi(strings.TrimSpace(currentEpisode))
+		return err == nil && episode == meta.EpisodeInt
+	case "MOVIE":
+		wantResolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
+		if wantResolution == "" || strings.TrimSpace(currentResolution) == "" {
+			return true
+		}
+		return strings.EqualFold(currentResolution, wantResolution)
+	default:
+		return true
+	}
+}
+
+func bjsEntryFromRow(baseURL string, row *xhtml.Node) api.DupeEntry {
+	link := firstNode(row, func(node *xhtml.Node) bool {
+		if node.Type != xhtml.ElementNode || node.Data != "a" {
+			return false
+		}
+		href := attrValueHTML(node, "href")
+		return strings.Contains(href, "torrentid=") || strings.Contains(attrValueHTML(node, "onclick"), "loadIfNeeded")
+	})
+	entry := api.DupeEntry{}
+	if link != nil {
+		entry.Name = strings.Join(strings.Fields(nodeTextHTML(link)), " ")
+		entry.ID = bjsTorrentIDFromLink(link)
+		if entry.ID != "" {
+			entry.Link = strings.TrimRight(baseURL, "/") + "/torrents.php?torrentid=" + entry.ID
+		}
+	}
+	if entry.ID == "" {
+		entry.ID = strings.TrimPrefix(attrValueHTML(row, "id"), "torrent")
+		if entry.ID != "" {
+			entry.Link = strings.TrimRight(baseURL, "/") + "/torrents.php?torrentid=" + entry.ID
+		}
+	}
+	sizeCell := firstNode(row, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "td" && hasClass(node, "number_column") && hasClass(node, "nobr")
+	})
+	if sizeCell != nil {
+		addSize(&entry, nodeTextHTML(sizeCell))
+	}
+	return entry
+}
+
+func bjsTorrentIDFromLink(link *xhtml.Node) string {
+	if link == nil {
+		return ""
+	}
+	href := attrValueHTML(link, "href")
+	if match := regexp.MustCompile(`(?i)torrentid=(\d+)`).FindStringSubmatch(href); len(match) == 2 {
+		return match[1]
+	}
+	if match := regexp.MustCompile(`loadIfNeeded\('(\d+)',\s*'(\d+)'`).FindStringSubmatch(attrValueHTML(link, "onclick")); len(match) >= 2 {
+		return match[1]
+	}
+	return ""
+}
+
+type responseInfo struct{ StatusCode int }
+
+func (r responseInfo) ok() bool {
+	return r.StatusCode >= http.StatusOK && r.StatusCode < http.StatusMultipleChoices
+}
+func imdbForLookup(meta api.DuplicateSubject) string {
+	if meta.Identity.IMDBID == 0 {
+		return ""
+	}
+	return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+}
+func trackerBaseURL(_ config.Config, _ string, fallback string) string {
+	return strings.TrimRight(fallback, "/")
+}
+func trackerHost(baseURL, fallback string) string {
+	parsed, err := url.Parse(baseURL)
+	if err == nil && parsed.Hostname() != "" {
+		return parsed.Hostname()
+	}
+	return fallback
+}
+func loadTrackerCookies(ctx context.Context, cfg config.Config, tracker, domain string) ([]*http.Cookie, error) {
+	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, cfg.MainSettings.DBPath, tracker, domain)
+	if err != nil {
+		return nil, fmt.Errorf("bjs: load tracker cookies: %w", err)
+	}
+	return loaded, nil
+}
+func doHTMLGet(ctx context.Context, client *http.Client, endpoint string, params url.Values, trackerCookies []*http.Cookie) (responseInfo, *xhtml.Node, error) {
+	status, root, err := commonhttp.GetHTML(ctx, client, endpoint, params, trackerCookies)
+	if err != nil {
+		return responseInfo{StatusCode: status}, nil, fmt.Errorf("bjs: HTML request: %w", err)
+	}
+	return responseInfo{StatusCode: status}, root, nil
+}
+func firstNode(root *xhtml.Node, match func(*xhtml.Node) bool) *xhtml.Node {
+	return commonhttp.FirstNode(root, match)
+}
+func findNodes(root *xhtml.Node, match func(*xhtml.Node) bool) []*xhtml.Node {
+	return commonhttp.FindNodes(root, match)
+}
+func hasClass(node *xhtml.Node, name string) bool       { return commonhttp.HasClass(node, name) }
+func attrValueHTML(node *xhtml.Node, key string) string { return commonhttp.Attr(node, key) }
+func nodeTextHTML(node *xhtml.Node) string              { return commonhttp.NodeText(node) }
+func addSize(entry *api.DupeEntry, value string) {
+	trimmed := strings.TrimSpace(value)
+	entry.SizeText = trimmed
+	if size, ok := commonhttp.ParseSizeBytes(trimmed); ok {
+		entry.SizeKnown, entry.SizeBytes = true, size
+	}
+}
diff --git a/internal/trackers/impl/standalone/bjs/dupe_test.go b/internal/trackers/impl/standalone/bjs/dupe_test.go
new file mode 100644
index 00000000..9dfad602
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/dupe_test.go
@@ -0,0 +1,77 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"strings"
+	"testing"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestExtractBJSResultsNewTVLayout(t *testing.T) {
+	t.Parallel()
+
+	root := mustParseHTML(t, `
+<div class="main_column">
+  <table>
+    <tr class="resolution_header"><td>1080p</td></tr>
+    <tr class="season_header"><td>Temporada 1</td></tr>
+    <tr><td rowspan="2"><a href="torrents.php?id=77">Example S01E02</a></td></tr>
+    <tr id="torrent123"><td><a href="torrents.php?torrentid=123">Example.S01E02.1080p-GRP</a></td><td class="number_column nobr">1.5 GiB</td></tr>
+    <tr><td rowspan="2"><a href="torrents.php?id=78">Example S01E03</a></td></tr>
+    <tr id="torrent124"><td><a href="torrents.php?torrentid=124">Example.S01E03.1080p-GRP</a></td><td class="number_column nobr">1.7 GiB</td></tr>
+  </table>
+</div>`)
+
+	entries := extractBJSResults("https://bj-share.info", root, api.DuplicateSubject{
+		Identity:   api.ExternalIdentity{Category: "TV"},
+		SeasonInt:  1,
+		EpisodeInt: 2,
+		Release:    api.ReleaseInfo{Resolution: "1080p"},
+	})
+
+	if len(entries) != 1 {
+		t.Fatalf("expected one matching episode entry, got %#v", entries)
+	}
+	if entries[0].ID != "123" || entries[0].Name != "Example.S01E02.1080p-GRP" {
+		t.Fatalf("unexpected entry: %#v", entries[0])
+	}
+	if !entries[0].SizeKnown || entries[0].SizeBytes == 0 {
+		t.Fatalf("expected parsed size, got %#v", entries[0])
+	}
+}
+
+func TestExtractBJSResultsLegacyLoadIfNeededLayout(t *testing.T) {
+	t.Parallel()
+
+	root := mustParseHTML(t, `
+<div class="main_column">
+  <table>
+    <tr id="torrent555">
+      <td><a onclick="loadIfNeeded('555', '42')">Movie.2026.2160p-GRP</a></td>
+    </tr>
+  </table>
+</div>`)
+
+	entries := extractBJSResults("https://bj-share.info", root, api.DuplicateSubject{})
+	if len(entries) != 1 {
+		t.Fatalf("expected one legacy entry, got %#v", entries)
+	}
+	if entries[0].ID != "555" || entries[0].Link != "https://bj-share.info/torrents.php?torrentid=555" {
+		t.Fatalf("unexpected legacy entry: %#v", entries[0])
+	}
+}
+
+func mustParseHTML(t *testing.T, value string) *xhtml.Node {
+	t.Helper()
+
+	root, err := xhtml.Parse(strings.NewReader(value))
+	if err != nil {
+		t.Fatalf("parse html: %v", err)
+	}
+	return root
+}
diff --git a/internal/trackers/impl/standalone/bjs/profile.go b/internal/trackers/impl/standalone/bjs/profile.go
new file mode 100644
index 00000000..9afdf33e
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/profile.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns BJS identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                    "BJS",
+		BaseURL:                 baseURL,
+		DescriptionGroup:        "bjs",
+		UploadContentMode:       trackers.UploadContentModeDescription,
+		LocalizedMetadataLocale: "pt-BR",
+		PrepareDescription:      prepareDescription,
+		PrepareUpload:           prepareUpload,
+		NewDuplicateAdapter:     newDuplicateAdapter,
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		AudioPolicy:           &trackers.AudioPolicy{AllowBloat: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"tracker.bj-share.info"}},
+		AuthCapability:        standalone.CookieAuthCapability("BJS"),
+	}
+}
+
+// New returns a fresh BJS definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/bjs/upload.go b/internal/trackers/impl/standalone/bjs/upload.go
new file mode 100644
index 00000000..33f93ebc
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/upload.go
@@ -0,0 +1,1156 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"math"
+	"net/http"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/autobrr/upbrr/internal/cookies"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+const (
+	baseURL    = "https://bj-share.info"
+	uploadURL  = baseURL + "/upload.php"
+	torrentURL = baseURL + "/torrents.php?torrentid="
+	sourceFlag = "BJ"
+)
+
+var (
+	authPattern                   = regexp.MustCompile(`name="auth"\s+value="([^"]+)"`)
+	idPattern                     = regexp.MustCompile(`action=download&id=(\d+)|torrentid=(\d+)`)
+	mediaInfoDurationLinePattern  = regexp.MustCompile(`(?im)^\s*duration(?:\s*/\s*string[123]?)?\s*:\s*(.+)$`)
+	mediaInfoDurationTokenPattern = regexp.MustCompile(
+		`(?i)(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|hours?|hrs?|hr|h|minutes?|mins?|min|mn|m|seconds?|secs?|sec|s)\b`,
+	)
+	isoDurationPattern = regexp.MustCompile(`(?i)^pt(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?(?:(\d+(?:\.\d+)?)s)?$`)
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	blockedReason string
+	questionnaire *api.TrackerQuestionnaire
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: BJS %s", state.blockedReason)
+	}
+	files := []commonhttp.FileField{{
+		FieldName: "file_input",
+		FileName:  filepath.Base(state.torrentPath),
+		Path:      state.torrentPath,
+	}}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "BJS")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BJS request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	httpReq.Header.Set("Referer", uploadURL)
+	commonhttp.ApplyCookies(httpReq, cookies)
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BJS upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode >= 200 && resp.StatusCode < 400,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BJS read upload response: %w", err)
+	}
+	match := idPattern.FindStringSubmatch(finalURL + "\n" + string(responseBody))
+	id := metautil.FirstNonEmptyTrimmed(matchValue(match, 1), matchValue(match, 2))
+	if resp.StatusCode >= 200 && resp.StatusCode < 400 && id != "" {
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "BJS",
+				TorrentID:   id,
+				TorrentURL:  tURL,
+				DownloadURL: tURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "BJS", "upload_failure", responsePreview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("BJS", resp.StatusCode, responsePreview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	fields := maps.Clone(state.fields)
+	if _, ok := fields["auth"]; ok {
+		fields["auth"] = "[redacted]"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "BJS",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "bjs",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	auth := "dry-run-auth"
+	if !dryRun {
+		auth, err = fetchAuth(ctx, cookies)
+		if err != nil {
+			return uploadState{}, nil, err
+		}
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	fields := buildFields(req.Meta, description, auth, standalone.QuestionnaireAnswers(req.Meta, "BJS"))
+	state := uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
+		fields:        fields,
+		questionnaire: buildQuestionnaire(req.Meta, fields),
+	}
+	if reason := validateFields(fields); reason != "" {
+		state.blockedReason = reason
+	}
+	return state, cookies, nil
+}
+
+func buildFields(meta api.UploadSubject, description string, auth string, answers map[string]string) map[string]string {
+	width, height := resolveResolution(meta)
+	runtimeMinutes := resolveRuntime(meta)
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+
+	var tmdbOriginalTitle, tmdbTitle string
+	if meta.ProviderMetadata.TMDB != nil {
+		tmdbOriginalTitle = meta.ProviderMetadata.TMDB.OriginalTitle
+		tmdbTitle = meta.ProviderMetadata.TMDB.Title
+	}
+
+	fields := map[string]string{
+		"audio":            resolveAudio(meta),
+		"auth":             auth,
+		"codecaudio":       resolveAudioCodec(meta),
+		"codecvideo":       resolveVideoCodec(meta),
+		"duracaoHR":        strconv.Itoa(runtimeMinutes / 60),
+		"duracaoMIN":       strconv.Itoa(runtimeMinutes % 60),
+		"duracaotipo":      "selectbox",
+		"fichatecnica":     description,
+		"formato":          resolveContainer(meta),
+		"idioma":           resolveLanguage(meta),
+		"imdblink":         resolveIDLink(meta),
+		"qualidade":        resolveQuality(meta),
+		"release":          strings.TrimSpace(meta.ServiceLongName),
+		"remaster_title":   resolveRemasterTitle(meta),
+		"resolucaoh":       height,
+		"resolucaow":       width,
+		"sinopse":          metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["overview"]), resolveOverview(meta, ptBR)),
+		"submit":           "true",
+		"tags":             metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta, ptBR)),
+		"tipolegenda":      resolveSubtitle(meta),
+		"title":            metautil.FirstNonEmptyTrimmed(tmdbOriginalTitle, meta.Release.Title),
+		"titulobrasileiro": metautil.FirstNonEmptyTrimmed(ptBR.Title, tmdbTitle, meta.Release.Title),
+		"traileryoutube":   resolveYouTube(meta, ptBR),
+		"type":             resolveType(meta),
+		"year":             resolveYearLabel(meta),
+	}
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	if category == "MOVIE" {
+		fields["adulto"] = resolveAdult(meta)
+		fields["diretor"] = resolveDirectors(meta)
+		fields["datalancamento"] = resolveReleaseDate(meta)
+	}
+	if category == "TV" {
+		fields["diretor"] = resolveCreators(meta)
+		if meta.TVPack {
+			fields["tipo"] = "season"
+		} else {
+			fields["tipo"] = "episode"
+		}
+		fields["season"] = strconv.Itoa(meta.SeasonInt)
+		fields["episode"] = strconv.Itoa(meta.EpisodeInt)
+		fields["network"] = resolveNetworks(meta)
+
+		numSeasons := 0
+		if meta.ProviderMetadata.IMDB != nil {
+			numSeasons = len(meta.ProviderMetadata.IMDB.SeasonsSummary)
+		}
+		fields["numtemporadas"] = strconv.Itoa(numSeasons)
+
+		var originCountry []string
+		if meta.ProviderMetadata.TMDB != nil {
+			for _, code := range meta.ProviderMetadata.TMDB.OriginCountry {
+				originCountry = append(originCountry, metautil.ISO3166PortugueseName(code, code))
+			}
+		}
+		fields["pais"] = strings.Join(originCountry, ", ")
+
+		fields["diretorserie"] = resolveDirectors(meta)
+		fields["avaliacao"] = resolveIMDbRating(meta)
+		fields["datalancamento"] = resolveReleaseDate(meta)
+	}
+	if !meta.Anime {
+		fields["validimdb"] = "yes"
+		fields["imdbrating"] = resolveIMDbRating(meta)
+		fields["elenco"] = resolveCast(meta)
+	}
+	if meta.Anime && category == "MOVIE" {
+		fields["tipo"] = "movie"
+	}
+	if meta.Anime && category == "TV" {
+		fields["adulto"] = resolveAdult(meta)
+	}
+	if strings.TrimSpace(meta.Repack) != "" {
+		fields["repack"] = "on"
+	}
+	if resolvePoster(meta) != "" {
+		fields["image"] = resolvePoster(meta)
+	}
+	screens := resolveScreens(meta)
+	if len(screens) > 0 {
+		fields["screenshots[]"] = strings.Join(screens, ",")
+	}
+	return fields
+}
+
+func buildQuestionnaire(meta api.UploadSubject, fields map[string]string) *api.TrackerQuestionnaire {
+	current := standalone.QuestionnaireAnswers(meta, "BJS")
+	var items []api.TrackerQuestionnaireField
+	if strings.TrimSpace(fields["sinopse"]) == "" {
+		items = append(items, api.TrackerQuestionnaireField{
+			Key:      "overview",
+			Label:    "Overview",
+			Kind:     "textarea",
+			Value:    current["overview"],
+			Required: true,
+		})
+	}
+	if strings.TrimSpace(fields["tags"]) == "" {
+		items = append(items, api.TrackerQuestionnaireField{
+			Key:      "tags",
+			Label:    "Tags",
+			Kind:     "text",
+			Value:    current["tags"],
+			Required: true,
+		})
+	}
+	if len(items) == 0 {
+		return nil
+	}
+	return &api.TrackerQuestionnaire{Tracker: "BJS", Fields: items}
+}
+
+func validateFields(fields map[string]string) string {
+	if strings.TrimSpace(fields["imdblink"]) == "" {
+		return "missing IMDb or TMDb identifier"
+	}
+	if strings.TrimSpace(fields["sinopse"]) == "" {
+		return "missing overview"
+	}
+	if strings.TrimSpace(fields["diretor"]) == "" || strings.EqualFold(strings.TrimSpace(fields["diretor"]), "skipped") {
+		return "missing director/creator credits"
+	}
+	return ""
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	meta := req.Meta
+	var parts []string
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Logo
+	if logo := resolveLogo(meta); logo != "" {
+		parts = append(parts, "[align=center][img]"+logo+"[/img][/align]")
+	}
+
+	// TV Episode details
+	epTitle := meta.EpisodeTitle
+	epOverview := meta.EpisodeOverview
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Localized != nil {
+		if ptBR, ok := meta.ProviderMetadata.TMDB.Localized["pt-BR"]; ok {
+			if ptBR.EpisodeTitle != "" {
+				epTitle = ptBR.EpisodeTitle
+			}
+			if ptBR.EpisodeOverview != "" {
+				epOverview = ptBR.EpisodeOverview
+			}
+		}
+	}
+	epTitle = strings.TrimSpace(epTitle)
+	epOverview = strings.TrimSpace(epOverview)
+	if epOverview != "" {
+		if epTitle != "" {
+			parts = append(parts, "[align=center]"+epTitle+"[/align]")
+		}
+		parts = append(parts, "[align=center]"+epOverview+"[/align]")
+	}
+
+	// File information
+	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
+	if discType == "DVD" || discType == "HDDVD" {
+		mediainfo := strings.TrimSpace(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath))
+		if mediainfo != "" {
+			parts = append(parts, "[hide=DVD MediaInfo][pre]"+mediainfo+"[/pre][/hide]")
+		}
+	}
+	if discType == "BDMV" {
+		bdinfo, _ := trackers.ReadBDInfo(req.Runtime.DBPath, meta)
+		parts = append(parts, "[hide=BDInfo][pre]"+bdinfo+"[/pre][/hide]")
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// Signature
+	link, _ := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[align=center][url=%s]Upload realizado via %s[/url][/align]", link, "upbrr"))
+
+	// Join and finalize
+	description := strings.Join(parts, "\n\n")
+	finalized := finalizeDescription(description)
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "BJS", req.Runtime.DBPath, finalized, req.Logger)
+	}
+
+	return finalized
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "BJS", "bj-share.info")
+	if err != nil {
+		return values, fmt.Errorf("trackers: BJS load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func fetchAuth(ctx context.Context, cookies []*http.Cookie) (string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uploadURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BJS auth token request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(req, cookies)
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BJS auth token request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	match := authPattern.FindStringSubmatch(string(body))
+	if len(match) < 2 {
+		return "", errors.New("trackers: BJS auth token not found")
+	}
+	return strings.TrimSpace(match[1]), nil
+}
+
+func resolveType(meta api.UploadSubject) string {
+	if meta.Anime {
+		return "13"
+	}
+	if strings.EqualFold(categoryOf(meta), "TV") {
+		return "1"
+	}
+	return "0"
+}
+
+func resolveContainer(meta api.UploadSubject) string {
+	container := strings.ToLower(strings.TrimSpace(meta.Container))
+	switch container {
+	case "mkv", "mp4", "avi", "vob", "m2ts", "ts":
+		return strings.ToUpper(container)
+	default:
+		return "Outro"
+	}
+}
+
+func resolveAudio(meta api.UploadSubject) string {
+	for _, lang := range meta.AudioLanguages {
+		lower := strings.ToLower(strings.TrimSpace(lang))
+		if lower == "portuguese" || lower == "português" || lower == "pt" {
+			if len(meta.AudioLanguages) > 1 {
+				return "Dual Áudio"
+			}
+			return "Dublado"
+		}
+	}
+	return "Legendado"
+}
+
+func resolveLanguage(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return "Outro"
+	}
+
+	langCode := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage))
+	if langCode == "" {
+		return "Outro"
+	}
+
+	if langCode == "pt" {
+		for _, country := range meta.ProviderMetadata.TMDB.OriginCountry {
+			if strings.ToUpper(strings.TrimSpace(country)) == "PT" {
+				return "Português (pt)"
+			}
+		}
+		return "Português"
+	}
+
+	return metautil.ISO639PortugueseName(langCode, "Outro")
+}
+
+func resolveSubtitle(meta api.UploadSubject) string {
+	for _, lang := range meta.SubtitleLanguages {
+		lower := strings.ToLower(strings.TrimSpace(lang))
+		if lower == "portuguese" || lower == "português" || lower == "pt" {
+			return "Embutida"
+		}
+	}
+	return "Nenhuma"
+}
+
+func resolveResolution(meta api.UploadSubject) (string, string) {
+	height := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
+	switch height {
+	case "2160":
+		return "3840", "2160"
+	case "1080":
+		return "1920", "1080"
+	case "720":
+		return "1280", "720"
+	default:
+		return "0", "0"
+	}
+}
+
+func resolveVideoCodec(meta api.UploadSubject) string {
+	value := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
+	switch {
+	case strings.Contains(value, "265"), strings.Contains(value, "hevc"):
+		return "H.265"
+	case strings.Contains(value, "264"), strings.Contains(value, "avc"):
+		return "H.264"
+	case strings.Contains(value, "av1"):
+		return "AV1"
+	case strings.Contains(value, "vp9"):
+		return "VP9"
+	case strings.Contains(value, "xvid"):
+		return "XviD"
+	default:
+		return metautil.FirstNonEmptyTrimmed(meta.VideoCodec, "Outro")
+	}
+}
+
+func resolveAudioCodec(meta api.UploadSubject) string {
+	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
+	switch {
+	case strings.Contains(audio, "DTS:X"):
+		return "DTS-X"
+	case strings.Contains(audio, "ATMOS"):
+		return "E-AC-3 JOC"
+	case strings.Contains(audio, "TRUEHD"):
+		return "TrueHD"
+	case strings.Contains(audio, "DTS-HD"):
+		return "DTS-HD"
+	case strings.Contains(audio, "FLAC"):
+		return "FLAC"
+	case strings.Contains(audio, "LPCM"), strings.Contains(audio, "PCM"):
+		return "PCM"
+	case strings.Contains(audio, "DTS"):
+		return "DTS"
+	case strings.Contains(audio, "DD+"), strings.Contains(audio, "E-AC-3"):
+		return "E-AC-3"
+	case strings.Contains(audio, "DD"), strings.Contains(audio, "AC3"):
+		return "AC3"
+	case strings.Contains(audio, "AAC"):
+		return "AAC"
+	default:
+		return "Outro"
+	}
+}
+
+func resolveQuality(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "DISC":
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+			if meta.SourceSize > 66<<30 {
+				return "BD100"
+			}
+			if meta.SourceSize > 50<<30 {
+				return "BD66"
+			}
+			if meta.SourceSize > 25<<30 {
+				return "BD50"
+			}
+			return "BD25"
+		}
+		return "DVD9"
+	case "REMUX":
+		return "Remux"
+	case "WEBDL":
+		return "WEB-DL"
+	case "WEBRIP":
+		return "WEBRip"
+	case "HDTV":
+		return "HDTV"
+	default:
+		return "Outro"
+	}
+}
+
+func resolveRuntime(meta api.UploadSubject) int {
+	for _, candidate := range []string{
+		commonhttp.ReadOptionalFile(meta.MediaInfoTextPath),
+		strings.TrimSpace(meta.DVDVOBMediaInfoText),
+	} {
+		if minutes := parseMediaInfoDurationMinutes(candidate); minutes > 0 {
+			return minutes
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		if meta.Disc.DurationSeconds > 0 {
+			return int(math.Round(meta.Disc.DurationSeconds / 60))
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.RuntimeMinutes > 0 {
+		return meta.ProviderMetadata.IMDB.RuntimeMinutes
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return meta.ProviderMetadata.TMDB.Runtime
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		return meta.ProviderMetadata.TVmaze.Runtime
+	}
+	return 0
+}
+
+// parseMediaInfoDurationMinutes returns rounded minutes from the first parseable
+// MediaInfo Duration or Duration/String[1-3] line, including ISO-8601-like values.
+func parseMediaInfoDurationMinutes(text string) int {
+	for _, matches := range mediaInfoDurationLinePattern.FindAllStringSubmatch(text, -1) {
+		if len(matches) != 2 {
+			continue
+		}
+		if minutes := parseMediaInfoDurationValueMinutes(matches[1]); minutes > 0 {
+			return minutes
+		}
+	}
+	return 0
+}
+
+func parseMediaInfoDurationValueMinutes(value string) int {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 0
+	}
+	if matches := isoDurationPattern.FindStringSubmatch(trimmed); len(matches) == 4 {
+		return mediaInfoDurationSecondsToMinutes(durationComponentSeconds(matches[1], matches[2], matches[3], ""))
+	}
+	if strings.Contains(trimmed, ":") {
+		return mediaInfoDurationSecondsToMinutes(parseMediaInfoDurationColonSeconds(trimmed))
+	}
+	if seconds := parseMediaInfoDurationTokenSeconds(trimmed); seconds > 0 {
+		return mediaInfoDurationSecondsToMinutes(seconds)
+	}
+	if fields := strings.Fields(trimmed); len(fields) > 0 {
+		if ms, err := strconv.ParseFloat(strings.ReplaceAll(fields[0], ",", ""), 64); err == nil && ms > 10000 {
+			return int(math.Round(ms / 60000.0))
+		}
+	}
+	return 0
+}
+
+func parseMediaInfoDurationTokenSeconds(value string) float64 {
+	var total float64
+	for _, matches := range mediaInfoDurationTokenPattern.FindAllStringSubmatch(value, -1) {
+		if len(matches) != 3 {
+			continue
+		}
+		amount, err := strconv.ParseFloat(strings.ReplaceAll(matches[1], ",", ""), 64)
+		if err != nil || amount <= 0 {
+			continue
+		}
+		switch strings.ToLower(matches[2]) {
+		case "h", "hr", "hrs", "hour", "hours":
+			total += amount * 3600
+		case "m", "mn", "min", "mins", "minute", "minutes":
+			total += amount * 60
+		case "s", "sec", "secs", "second", "seconds":
+			total += amount
+		case "ms", "msec", "msecs", "millisecond", "milliseconds":
+			total += amount / 1000
+		}
+	}
+	return total
+}
+
+func parseMediaInfoDurationColonSeconds(value string) float64 {
+	parts := strings.Split(strings.TrimSpace(value), ":")
+	if len(parts) < 2 {
+		return 0
+	}
+	var total float64
+	multiplier := 1.0
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := strings.TrimSpace(parts[i])
+		if part == "" {
+			continue
+		}
+		amount, err := strconv.ParseFloat(strings.ReplaceAll(part, ",", ""), 64)
+		if err != nil || amount < 0 {
+			return 0
+		}
+		total += amount * multiplier
+		multiplier *= 60
+	}
+	return total
+}
+
+func durationComponentSeconds(hours string, minutes string, seconds string, milliseconds string) float64 {
+	totalSeconds := parseDurationComponent(hours) * 3600
+	totalSeconds += parseDurationComponent(minutes) * 60
+	totalSeconds += parseDurationComponent(seconds)
+	totalSeconds += parseDurationComponent(milliseconds) / 1000
+	return totalSeconds
+}
+
+func mediaInfoDurationSecondsToMinutes(seconds float64) int {
+	if seconds <= 0 {
+		return 0
+	}
+	return int(math.Round(seconds / 60.0))
+}
+
+func parseDurationComponent(value string) float64 {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 0
+	}
+	parsed, err := strconv.ParseFloat(trimmed, 64)
+	if err != nil || parsed < 0 {
+		return 0
+	}
+	return parsed
+}
+
+func resolveIDLink(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	if meta.Identity.TMDBID > 0 {
+		if strings.EqualFold(categoryOf(meta), "TV") {
+			return fmt.Sprintf("tv/%d", meta.Identity.TMDBID)
+		}
+		return fmt.Sprintf("movie/%d", meta.Identity.TMDBID)
+	}
+	return ""
+}
+
+// resolveOverview prefers scoped TV synopsis for episode/season-pack uploads,
+// then localized title-level overview, then TMDB or IMDB fallback text.
+func resolveOverview(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
+		return strings.TrimSpace(ptBR.EpisodeOverview)
+	}
+	if ptBR.Overview != "" {
+		return strings.TrimSpace(ptBR.Overview)
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	}
+	return ""
+}
+
+// shouldUseScopedTVOverview reports whether BJS should prefer season or
+// episode localized overview over title-level synopsis text.
+func shouldUseScopedTVOverview(meta api.UploadSubject) bool {
+	if meta.SeasonInt <= 0 {
+		return false
+	}
+	if !isTVUpload(meta) {
+		return false
+	}
+	if meta.TVPack {
+		return true
+	}
+	return meta.EpisodeInt > 0
+}
+
+// isTVUpload reports whether canonical identity classifies the upload as TV.
+func isTVUpload(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+// resolveTags returns BJS tag text from localized genres or translated fallback
+// genres, preserving unknown fallback genre names after tag normalization.
+func resolveTags(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	// 1. Use localized if available
+	if ptBR.Genres != "" {
+		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
+		out := make([]string, 0, len(genres))
+		for _, g := range genres {
+			g = strings.TrimSpace(g)
+			t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+			g, _, _ = transform.String(t, g)
+			g = strings.ReplaceAll(g, " ", ".")
+			g = strings.ToLower(g)
+			if g != "" {
+				out = append(out, g)
+			}
+		}
+		return strings.Join(out, ", ")
+	}
+
+	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
+	var genreText string
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	default:
+		genreText = strings.TrimSpace(meta.Release.Genre)
+	}
+
+	if genreText == "" {
+		return ""
+	}
+
+	genres := strings.Split(genreText, ",")
+	out := make([]string, 0, len(genres))
+	for _, g := range genres {
+		g = strings.TrimSpace(g)
+		if g == "" {
+			continue
+		}
+		translated := metautil.TranslateGenreToPortugueseStrict(g)
+		if translated == "" {
+			translated = g
+		}
+		t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+		tag, _, _ := transform.String(t, translated)
+		tag = strings.ReplaceAll(strings.TrimSpace(tag), " ", ".")
+		if tag != "" {
+			out = append(out, strings.ToLower(tag))
+		}
+	}
+	return strings.Join(out, ", ")
+}
+
+func resolveYouTube(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	if ptBR.TrailerURL != "" {
+		return strings.TrimSpace(ptBR.TrailerURL)
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	return ""
+}
+
+func resolveNetworks(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Networks) > 0 {
+		names := make([]string, 0, len(meta.ProviderMetadata.TMDB.Networks))
+		for _, n := range meta.ProviderMetadata.TMDB.Networks {
+			if strings.TrimSpace(n.Name) != "" {
+				names = append(names, strings.TrimSpace(n.Name))
+			}
+		}
+		return strings.Join(names, ", ")
+	}
+	return ""
+}
+
+func resolveReleaseDate(meta api.UploadSubject) string {
+	rawDate := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		rawDate = metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.ReleaseDate, meta.ProviderMetadata.TMDB.FirstAirDate)
+	}
+	if rawDate == "" {
+		return ""
+	}
+	t, err := time.Parse("2006-01-02", rawDate)
+	if err == nil {
+		return t.Format("02 Jan 2006")
+	}
+	return ""
+}
+
+func resolveYearLabel(meta api.UploadSubject) string {
+	year := resolveYear(meta)
+	if strings.EqualFold(categoryOf(meta), "TV") {
+		if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.EndYear > 0 {
+			return fmt.Sprintf("%d-%d", year, meta.ProviderMetadata.IMDB.EndYear)
+		}
+		return fmt.Sprintf("%d-", year)
+	}
+	return strconv.Itoa(year)
+}
+
+func resolveRemasterTitle(meta api.UploadSubject) string {
+	var tags []string
+
+	edition := strings.TrimSpace(meta.Edition)
+	editionLower := strings.ToLower(edition)
+	editionEntries := []struct{ keyword, label string }{
+		{"director's cut", "Director's Cut"},
+		{"extended", "Extended Edition"},
+		{"imax", "IMAX"},
+		{"open matte", "Open Matte"},
+		{"noir", "Noir Edition"},
+		{"theatrical", "Theatrical Cut"},
+		{"uncut", "Uncut"},
+		{"unrated", "Unrated"},
+		{"uncensored", "Uncensored"},
+	}
+	for _, entry := range editionEntries {
+		if strings.Contains(editionLower, entry.keyword) {
+			tags = append(tags, entry.label)
+			break
+		}
+	}
+
+	audio := strings.ToUpper(strings.TrimSpace(meta.Audio))
+	if strings.Contains(audio, "ATMOS") {
+		tags = append(tags, "Dolby Atmos")
+	}
+
+	if meta.BitDepth == "10" {
+		tags = append(tags, "10-bit")
+	}
+
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	if strings.Contains(hdr, "DV") || strings.Contains(hdr, "DOLBY VISION") {
+		tags = append(tags, "Dolby Vision")
+	}
+	if strings.Contains(hdr, "HDR10+") {
+		tags = append(tags, "HDR10+")
+	}
+	if strings.Contains(hdr, "HDR") && !strings.Contains(hdr, "HDR10+") {
+		tags = append(tags, "HDR10")
+	}
+
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+		tags = append(tags, "Remux")
+	}
+
+	if meta.HasCommentary {
+		tags = append(tags, "Com comentários")
+	}
+
+	priority := []string{
+		"Dolby Atmos",
+		"Remux",
+		"Director's Cut",
+		"Extended Edition",
+		"IMAX",
+		"Open Matte",
+		"Noir Edition",
+		"Theatrical Cut",
+		"Uncut",
+		"Unrated",
+		"Uncensored",
+		"10-bit",
+		"Dolby Vision",
+		"HDR10+",
+		"HDR10",
+		"Com extras",
+		"Com comentários",
+	}
+
+	tagSet := make(map[string]bool)
+	for _, t := range tags {
+		tagSet[t] = true
+	}
+
+	var ordered []string
+	for _, p := range priority {
+		if tagSet[p] {
+			ordered = append(ordered, p)
+		}
+	}
+
+	return strings.Join(ordered, " / ")
+}
+
+func resolveYear(meta api.UploadSubject) int {
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		return meta.ProviderMetadata.TMDB.Year
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		return meta.ProviderMetadata.IMDB.Year
+	}
+	return meta.Release.Year
+}
+
+// resolveAdult returns the BJS adult flag from localized, TMDB, IMDB, and
+// release genre text after accent-insensitive keyword matching.
+func resolveAdult(meta api.UploadSubject) string {
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	parts := []string{resolveTags(meta, ptBR), ptBR.Genres}
+	if meta.ProviderMetadata.TMDB != nil {
+		parts = append(parts, meta.ProviderMetadata.TMDB.Keywords, meta.ProviderMetadata.TMDB.Genres)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		parts = append(parts, meta.ProviderMetadata.IMDB.Genres)
+	}
+	parts = append(parts, meta.Release.Genre)
+	genres := normalizeAdultText(strings.Join(parts, " "))
+	if meta.Anime && strings.Contains(genres, "hentai") {
+		return "1"
+	}
+	for _, keyword := range []string{"xxx", "erotic", "erotico", "porn", "adult", "adulto", "orgy", "orgia"} {
+		if strings.Contains(genres, keyword) {
+			return "1"
+		}
+	}
+	return "2"
+}
+
+// normalizeAdultText folds case and diacritics before adult keyword matching.
+func normalizeAdultText(value string) string {
+	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	normalized, _, _ := transform.String(t, strings.ToLower(value))
+	return normalized
+}
+
+func resolveDirectors(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Directors) > 0 {
+		return firstTrimmed(meta.ProviderMetadata.TMDB.Directors)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		names := make([]string, 0, len(meta.ProviderMetadata.IMDB.Directors))
+		for _, p := range meta.ProviderMetadata.IMDB.Directors {
+			if strings.TrimSpace(p.Name) != "" {
+				names = append(names, strings.TrimSpace(p.Name))
+			}
+		}
+		if len(names) > 0 {
+			return names[0]
+		}
+	}
+	return ""
+}
+
+func resolveCreators(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Creators) > 0 {
+		return firstTrimmed(meta.ProviderMetadata.TMDB.Creators)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		names := make([]string, 0, len(meta.ProviderMetadata.IMDB.Creators))
+		for _, p := range meta.ProviderMetadata.IMDB.Creators {
+			if strings.TrimSpace(p.Name) != "" {
+				names = append(names, strings.TrimSpace(p.Name))
+			}
+		}
+		if len(names) > 0 {
+			return names[0]
+		}
+	}
+	return ""
+}
+
+func resolveCast(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Cast) > 0 {
+		return strings.Join(firstNTrimmed(meta.ProviderMetadata.TMDB.Cast, 5), ", ")
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		names := make([]string, 0, len(meta.ProviderMetadata.IMDB.Stars))
+		for _, p := range meta.ProviderMetadata.IMDB.Stars {
+			if strings.TrimSpace(p.Name) != "" {
+				names = append(names, strings.TrimSpace(p.Name))
+			}
+		}
+		return strings.Join(firstNTrimmed(names, 5), ", ")
+	}
+	return ""
+}
+
+func resolveIMDbRating(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Rating > 0 {
+		return strconv.FormatFloat(meta.ProviderMetadata.IMDB.Rating, 'f', 1, 64)
+	}
+	return ""
+}
+
+func resolveLogo(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo) != "" {
+		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo), "/")
+	}
+	return ""
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		if meta.ProviderMetadata.TMDB.Localized != nil {
+			if localized, ok := meta.ProviderMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
+				return strings.TrimSpace(localized.Poster)
+			}
+		}
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	}
+	return ""
+}
+
+func resolveScreens(_ api.UploadSubject) []string {
+	return nil
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func firstTrimmed(values []string) string {
+	for _, value := range values {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
+
+func firstNTrimmed(values []string, limit int) []string {
+	if limit <= 0 {
+		return nil
+	}
+	out := make([]string, 0, limit)
+	seen := make(map[string]struct{}, limit)
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		out = append(out, trimmed)
+		if len(out) == limit {
+			break
+		}
+	}
+	return out
+}
+
+func matchValue(values []string, idx int) string {
+	if idx >= 0 && idx < len(values) {
+		return values[idx]
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/bjs/upload_test.go b/internal/trackers/impl/standalone/bjs/upload_test.go
new file mode 100644
index 00000000..997875b6
--- /dev/null
+++ b/internal/trackers/impl/standalone/bjs/upload_test.go
@@ -0,0 +1,557 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bjs
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveRuntimePrefersMediaInfoDuration(t *testing.T) {
+	root := t.TempDir()
+	miPath := filepath.Join(root, "MEDIAINFO.txt")
+	if err := os.WriteFile(miPath, []byte("General\nDuration                                 : 1 h 31 min\n"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	meta := api.UploadSubject{
+		MediaInfoTextPath: miPath,
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{RuntimeMinutes: 120},
+		},
+	}
+
+	if got := resolveRuntime(meta); got != 91 {
+		t.Fatalf("expected MediaInfo runtime 91 minutes, got %d", got)
+	}
+}
+
+func TestResolveRuntimeFallsBackToExternalMetadata(t *testing.T) {
+	meta := api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{RuntimeMinutes: 95},
+		},
+	}
+
+	if got := resolveRuntime(meta); got != 95 {
+		t.Fatalf("expected IMDb runtime fallback, got %d", got)
+	}
+}
+
+func TestResolveRuntimePrefersBDInfoLengthForBDMV(t *testing.T) {
+	meta := api.UploadSubject{
+		DiscType: "BDMV",
+		Disc:     api.DiscFacts{DurationSeconds: 6000},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{RuntimeMinutes: 120},
+		},
+	}
+
+	if got := resolveRuntime(meta); got != 100 {
+		t.Fatalf("expected BDInfo runtime 100 minutes, got %d", got)
+	}
+}
+
+func TestParseMediaInfoDurationMinutes(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		content  string
+		expected int
+	}{
+		{
+			name:     "valid hours and minutes",
+			content:  "duration : 2 h 15 m",
+			expected: 135,
+		},
+		{
+			name:     "duration string label",
+			content:  "Duration/String : 2 h 5 min 2 s",
+			expected: 125,
+		},
+		{
+			name:     "duration string1 label",
+			content:  "\tDuRaTiOn/String1   : 2 h 5 min 2 s",
+			expected: 125,
+		},
+		{
+			name:     "duration spaced slash label",
+			content:  "Duration / String2 : 2 hrs 5 mins 2 secs",
+			expected: 125,
+		},
+		{
+			name:     "duration string3 colon label",
+			content:  "Duration/String3 : 02:05:02.000",
+			expected: 125,
+		},
+		{
+			name:     "iso duration value",
+			content:  "Duration/String : PT2H5M2S",
+			expected: 125,
+		},
+		{
+			name:     "valid milliseconds",
+			content:  "duration : 120000",
+			expected: 2,
+		},
+		{
+			name:     "empty fields",
+			content:  "duration :    ",
+			expected: 0,
+		},
+		{
+			name:     "invalid string1 skips to later duration",
+			content:  "Duration/String1 : not a duration\nDuration/String2 : 01:30:00.000",
+			expected: 90,
+		},
+		{
+			name:     "duration string4 remains ignored",
+			content:  "Duration/String4 : 01:30:00.000",
+			expected: 0,
+		},
+		{
+			name:     "adjacent duration fields remain ignored",
+			content:  "Source_Duration : 01:30:00.000\nDuration_Start : 01:30:00.000",
+			expected: 0,
+		},
+		{
+			name:     "no duration keyword",
+			content:  "something else",
+			expected: 0,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := parseMediaInfoDurationMinutes(tc.content)
+			if got != tc.expected {
+				t.Fatalf("expected %d, got %d", tc.expected, got)
+			}
+		})
+	}
+}
+
+func TestBuildFieldsLimitsDirectorCreatorAndSetsRepack(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Repack: "REPACK",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Creators:      []string{"Creator One", "Creator Two"},
+				Directors:     []string{"Director One", "Director Two"},
+				OriginCountry: []string{"BR", "US"},
+				Title:         "Title",
+			},
+			IMDB: &api.IMDBMetadata{Year: 2026},
+		},
+	}
+
+	fields := buildFields(meta, "description", "auth", nil)
+	if got := fields["diretor"]; got != "Creator One" {
+		t.Fatalf("expected first creator only, got %q", got)
+	}
+	if got := fields["diretorserie"]; got != "Director One" {
+		t.Fatalf("expected first director only, got %q", got)
+	}
+	if got := fields["repack"]; got != "on" {
+		t.Fatalf("expected repack flag, got %q", got)
+	}
+	if got := fields["pais"]; got != "Brasil, Estados Unidos da América" {
+		t.Fatalf("expected translated countries, got %q", got)
+	}
+}
+
+func TestBuildFieldsWithNilMetadata(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Title: "Test TV Title",
+		},
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: nil,
+			IMDB: nil,
+		},
+	}
+
+	// Make sure buildFields does not panic and populates fallback title from release
+	fields := buildFields(meta, "description", "auth", nil)
+	if got := fields["title"]; got != "Test TV Title" {
+		t.Fatalf("expected title to fall back to release title, got %q", got)
+	}
+	if got := fields["pais"]; got != "" {
+		t.Fatalf("expected empty country for nil TMDB, got %q", got)
+	}
+	if got := fields["numtemporadas"]; got != "0" {
+		t.Fatalf("expected 0 seasons for nil IMDB, got %q", got)
+	}
+	if got := fields["idioma"]; got != "Outro" {
+		t.Fatalf("expected idioma to fall back to 'Outro' for nil TMDB, got %q", got)
+	}
+	if got := fields["network"]; got != "" {
+		t.Fatalf("expected network to be empty for nil TMDB, got %q", got)
+	}
+	if got := fields["avaliacao"]; got != "" {
+		t.Fatalf("expected avaliacao to be empty for nil IMDB, got %q", got)
+	}
+	if got := fields["elenco"]; got != "" {
+		t.Fatalf("expected elenco to be empty for nil TMDB/IMDB, got %q", got)
+	}
+	if got := fields["traileryoutube"]; got != "" {
+		t.Fatalf("expected traileryoutube to be empty for nil TMDB, got %q", got)
+	}
+}
+
+func TestBuildFieldsWithTMDBNilAndIMDBPresent(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Title: "Test TV Title",
+		},
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: nil,
+			IMDB: &api.IMDBMetadata{
+				Rating: 8.5,
+				Stars:  []api.IMDBPerson{{Name: "Star One"}, {Name: "Star Two"}},
+			},
+		},
+	}
+
+	fields := buildFields(meta, "description", "auth", nil)
+	if got := fields["avaliacao"]; got != "8.5" {
+		t.Fatalf("expected avaliacao from IMDB, got %q", got)
+	}
+	if got := fields["elenco"]; got != "Star One, Star Two" {
+		t.Fatalf("expected elenco from IMDB stars, got %q", got)
+	}
+	if got := fields["idioma"]; got != "Outro" {
+		t.Fatalf("expected idioma to fall back to 'Outro' for nil TMDB, got %q", got)
+	}
+}
+
+func TestBuildFieldsWithTMDBPresentAndIMDBNil(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Title: "Test TV Title",
+		},
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				OriginalTitle:    "Original Title",
+				Title:            "Title",
+				OriginalLanguage: "en",
+				Networks:         []api.TMDBNetwork{{Name: "HBO"}},
+				Cast:             []string{"Cast One", "Cast Two"},
+				YouTube:          "https://youtube.com/watch?v=123",
+			},
+			IMDB: nil,
+		},
+	}
+
+	fields := buildFields(meta, "description", "auth", nil)
+	if got := fields["title"]; got != "Original Title" {
+		t.Fatalf("expected title from TMDB OriginalTitle, got %q", got)
+	}
+	if got := fields["idioma"]; got != "Inglês" {
+		t.Fatalf("expected idioma from TMDB original language, got %q", got)
+	}
+	if got := fields["network"]; got != "HBO" {
+		t.Fatalf("expected network from TMDB, got %q", got)
+	}
+	if got := fields["elenco"]; got != "Cast One, Cast Two" {
+		t.Fatalf("expected elenco from TMDB cast, got %q", got)
+	}
+	if got := fields["traileryoutube"]; got != "https://youtube.com/watch?v=123" {
+		t.Fatalf("expected traileryoutube URL from TMDB, got %q", got)
+	}
+	if got := fields["avaliacao"]; got != "" {
+		t.Fatalf("expected empty avaliacao for nil IMDB, got %q", got)
+	}
+}
+
+func TestBuildFieldsWithTMDBLocalizedAndIMDBNil(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Title: "Test TV Title",
+		},
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				OriginalTitle: "Original Title",
+				Title:         "Title",
+				Localized: map[string]api.TMDBLocalizedData{
+					"pt-BR": {
+						Title:      "Título Localizado",
+						TrailerURL: "https://youtube.com/watch?v=localized",
+					},
+				},
+			},
+			IMDB: nil,
+		},
+	}
+
+	fields := buildFields(meta, "description", "auth", nil)
+	if got := fields["titulobrasileiro"]; got != "Título Localizado" {
+		t.Fatalf("expected titulobrasileiro from TMDB localized title, got %q", got)
+	}
+	if got := fields["traileryoutube"]; got != "https://youtube.com/watch?v=localized" {
+		t.Fatalf("expected traileryoutube URL from TMDB localized trailer, got %q", got)
+	}
+}
+
+func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
+	t.Parallel()
+
+	ptBR := api.TMDBLocalizedData{
+		Overview:        "Series Overview",
+		EpisodeOverview: "Episode Overview",
+	}
+
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+		want string
+	}{
+		{
+			name: "episode upload uses episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "TV"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "lowercase episode upload uses episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "tv"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "season pack uses season overview from episode field",
+			meta: api.UploadSubject{
+				Identity:  api.ExternalIdentity{Category: "TV"},
+				SeasonInt: 1,
+				TVPack:    true,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "series upload uses title overview",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "TV"},
+			},
+			want: "Series Overview",
+		},
+		{
+			name: "movie ignores episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "MOVIE"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Series Overview",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := resolveOverview(tc.meta, ptBR); got != tc.want {
+				t.Fatalf("expected overview %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestBuildDescriptionOmitsBlankEpisodeTitle(t *testing.T) {
+	t.Parallel()
+
+	req := trackers.PreparationInput{Meta: api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Localized: map[string]api.TMDBLocalizedData{
+					"pt-BR": {
+						EpisodeOverview: "Overview Localizado",
+					},
+				},
+			},
+		},
+	}}
+
+	got := buildDescription(req, trackers.DescriptionAssets{})
+	if strings.Contains(got, "[align=center][/align]") {
+		t.Fatalf("expected blank episode title row to be omitted, got %q", got)
+	}
+	if !strings.Contains(got, "[align=center]Overview Localizado[/align]") {
+		t.Fatalf("expected localized episode overview row, got %q", got)
+	}
+}
+
+func TestBuildDescriptionKeepsEpisodeTitleWhenPresent(t *testing.T) {
+	t.Parallel()
+
+	req := trackers.PreparationInput{Meta: api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Localized: map[string]api.TMDBLocalizedData{
+					"pt-BR": {
+						EpisodeTitle:    "Titulo Localizado",
+						EpisodeOverview: "Overview Localizado",
+					},
+				},
+			},
+		},
+	}}
+
+	got := buildDescription(req, trackers.DescriptionAssets{})
+	if !strings.Contains(got, "[align=center]Titulo Localizado[/align]") {
+		t.Fatalf("expected localized episode title row, got %q", got)
+	}
+	if !strings.Contains(got, "[align=center]Overview Localizado[/align]") {
+		t.Fatalf("expected localized episode overview row, got %q", got)
+	}
+}
+
+func TestResolveTagsPreservesUnknownFallbackGenres(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Genre: "Sci-Fi, MyCustomGenre",
+		},
+	}
+
+	got := resolveTags(meta, api.TMDBLocalizedData{})
+	expected := "ficcao.cientifica, mycustomgenre"
+	if got != expected {
+		t.Fatalf("expected tags %q, got %q", expected, got)
+	}
+}
+
+func TestResolveTagsFallbackPriority(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{Genre: "ReleaseGenre"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{Genres: "Drama"},
+			IMDB: &api.IMDBMetadata{Genres: "Comedy"},
+		},
+	}
+
+	if got := resolveTags(meta, api.TMDBLocalizedData{Genres: "Ação"}); got != "acao" {
+		t.Fatalf("expected localized tags to win, got %q", got)
+	}
+	if got := resolveTags(meta, api.TMDBLocalizedData{}); got != "drama" {
+		t.Fatalf("expected TMDB tags to beat IMDb and release, got %q", got)
+	}
+
+	meta.ProviderMetadata.TMDB = nil
+	if got := resolveTags(meta, api.TMDBLocalizedData{}); got != "comedia" {
+		t.Fatalf("expected IMDb tags to beat release, got %q", got)
+	}
+}
+
+func TestBuildFieldsTagsAnswerOverridesComputedTags(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{Genre: "Drama"},
+	}
+
+	fields := buildFields(meta, "description", "auth", map[string]string{"tags": "manual.tag"})
+	if got := fields["tags"]; got != "manual.tag" {
+		t.Fatalf("expected manual tags answer, got %q", got)
+	}
+}
+
+func TestResolveAdultLocalizedAndCanonicalGenres(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+		want string
+	}{
+		{
+			name: "localized Portuguese adult genre",
+			meta: api.UploadSubject{
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{
+						"pt-BR": {Genres: "Adulto"},
+					}},
+				},
+			},
+			want: "1",
+		},
+		{
+			name: "IMDb-only adult genre",
+			meta: api.UploadSubject{
+				ProviderMetadata: api.SourceScopedMetadata{
+					IMDB: &api.IMDBMetadata{Genres: "Adult"},
+				},
+			},
+			want: "1",
+		},
+		{
+			name: "anime hentai detection remains adult",
+			meta: api.UploadSubject{
+				Anime:   true,
+				Release: api.ReleaseInfo{Genre: "Hentai"},
+			},
+			want: "1",
+		},
+		{
+			name: "nonadult Portuguese genre stays nonadult",
+			meta: api.UploadSubject{
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{Localized: map[string]api.TMDBLocalizedData{
+						"pt-BR": {Genres: "Drama"},
+					}},
+				},
+			},
+			want: "2",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := resolveAdult(tc.meta); got != tc.want {
+				t.Fatalf("expected adulto=%q, got %q", tc.want, got)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/bt/bbcode.go b/internal/trackers/impl/standalone/bt/bbcode.go
new file mode 100644
index 00000000..e7b21e49
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/bbcode.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/bt/definition.go b/internal/trackers/impl/standalone/bt/definition.go
new file mode 100644
index 00000000..8cc2c184
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/definition.go
@@ -0,0 +1,25 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "bt", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/bt/dupe.go b/internal/trackers/impl/standalone/bt/dupe.go
new file mode 100644
index 00000000..ab357ce1
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/dupe.go
@@ -0,0 +1,437 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+
+	"golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg    config.Config
+	http   *http.Client
+	logger api.Logger
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:    cfg,
+		http:   httpClient,
+		logger: logger,
+	}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	cookies, err := loadTrackerCookies(ctx, h.cfg, "BT", trackerHost(trackerBaseURL(h.cfg, "BT", "https://brasiltracker.org"), "brasiltracker.org"))
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid BT cookies", nil)
+	}
+
+	imdbID := resolveBTIMDbIDText(meta)
+
+	if imdbID == "" && !meta.Anime {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for BT dupe search", nil)
+	}
+
+	isTVPack := meta.TVPack
+
+	searchStr := imdbID
+	if meta.Anime {
+		tvdbNameEnglish := ""
+		tvdbName := ""
+		if meta.ProviderMetadata.TVDB != nil {
+			tvdbNameEnglish = strings.TrimSpace(meta.ProviderMetadata.TVDB.NameEnglish)
+			tvdbName = strings.TrimSpace(meta.ProviderMetadata.TVDB.Name)
+		}
+
+		tmdbTitle := ""
+		tmdbOriginalTitle := ""
+		if meta.ProviderMetadata.TMDB != nil {
+			tmdbTitle = strings.TrimSpace(meta.ProviderMetadata.TMDB.Title)
+			tmdbOriginalTitle = strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalTitle)
+		}
+
+		imdbTitle := ""
+		if meta.ProviderMetadata.IMDB != nil {
+			imdbTitle = strings.TrimSpace(meta.ProviderMetadata.IMDB.Title)
+		}
+
+		releaseName := strings.TrimSpace(meta.ReleaseName)
+
+		switch {
+		// English
+		case tvdbNameEnglish != "":
+			searchStr = tvdbNameEnglish
+		case tmdbTitle != "":
+			searchStr = tmdbTitle
+		case imdbTitle != "":
+			searchStr = imdbTitle
+
+		// Original
+		case tvdbName != "":
+			searchStr = tvdbName
+		case tmdbOriginalTitle != "":
+			searchStr = tmdbOriginalTitle
+
+		// Release Name
+		case releaseName != "":
+			searchStr = releaseName
+		}
+	}
+
+	if searchStr == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing search term for BT dupe search", nil)
+	}
+
+	baseURL := trackerBaseURL(h.cfg, "BT", "https://brasiltracker.org")
+
+	resp, stringBody, err := doTextGet(ctx, h.http, baseURL+"/torrents.php", url.Values{"searchstr": {searchStr}}, nil, cookies)
+	if err != nil || !resp.ok() {
+		return dupe.Failed(dupe.FailureRequest, "BT search request failed", err)
+	}
+	if strings.Contains(strings.ToLower(resp.FinalURL), "login") {
+		return dupe.NotRun(dupe.NotRunAuthNotReady, "BT authentication required", nil)
+	}
+
+	node, err := html.Parse(strings.NewReader(stringBody))
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "BT search html parse failed", err)
+	}
+
+	torrentTable := findBTNodeByID(node, "torrent_table")
+	if torrentTable == nil {
+		return dupe.Resolved(nil, nil)
+	}
+
+	groupLinks := make(map[string]struct{})
+	findBTGroupLinks(torrentTable, groupLinks)
+
+	if len(groupLinks) == 0 {
+		return dupe.Resolved(nil, nil)
+	}
+
+	var foundItems []string
+	if len(groupLinks) > 0 {
+		var mu sync.Mutex
+		var wg sync.WaitGroup
+		sem := make(chan struct{}, 5)
+	linkLoop:
+		for groupLink := range groupLinks {
+			select {
+			case <-ctx.Done():
+				break linkLoop
+			case sem <- struct{}{}:
+			}
+
+			wg.Add(1)
+			go func(link string) {
+				defer wg.Done()
+				defer func() { <-sem }()
+
+				groupResp, groupBody, groupErr := doTextGet(ctx, h.http, baseURL+"/"+link, nil, nil, cookies)
+				if groupErr != nil {
+					if h.logger != nil {
+						h.logger.Debugf("BT group link request failed for %s: %v", link, groupErr)
+					}
+					return
+				}
+				if !groupResp.ok() {
+					if h.logger != nil {
+						h.logger.Debugf("BT group link request returned non-success status %d for %s", groupResp.StatusCode, link)
+					}
+					return
+				}
+
+				groupNode, nodeErr := html.Parse(strings.NewReader(groupBody))
+				if nodeErr != nil {
+					if h.logger != nil {
+						h.logger.Debugf("BT group link html parse failed for %s: %v", link, nodeErr)
+					}
+					return
+				}
+
+				var localFound []string
+				processBTGroupPage(groupNode, isTVPack, &localFound)
+
+				if len(localFound) > 0 {
+					mu.Lock()
+					foundItems = append(foundItems, localFound...)
+					mu.Unlock()
+				}
+			}(groupLink)
+		}
+		wg.Wait()
+	}
+
+	var entries []api.DupeEntry
+	for _, item := range foundItems {
+		if trimmed := strings.TrimSpace(item); trimmed != "" {
+			entries = append(entries, api.DupeEntry{Name: trimmed})
+		}
+	}
+
+	if err := ctx.Err(); err != nil {
+		return dupe.Failed(dupe.FailureRequest, "BT search canceled", err)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func resolveBTIMDbIDText(meta api.DuplicateSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func findBTNodeByID(n *html.Node, id string) *html.Node {
+	if n.Type == html.ElementNode {
+		for _, a := range n.Attr {
+			if a.Key == "id" && a.Val == id {
+				return n
+			}
+		}
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		if res := findBTNodeByID(c, id); res != nil {
+			return res
+		}
+	}
+	return nil
+}
+
+func findBTGroupLinks(n *html.Node, links map[string]struct{}) {
+	if n.Type == html.ElementNode && n.Data == "a" {
+		href := ""
+		for _, a := range n.Attr {
+			if a.Key == "href" {
+				href = a.Val
+			}
+		}
+		if strings.Contains(href, "torrents.php?id=") && !strings.Contains(href, "torrentid") {
+			links[href] = struct{}{}
+		}
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		findBTGroupLinks(c, links)
+	}
+}
+
+func processBTGroupPage(n *html.Node, isTVPack bool, foundItems *[]string) {
+	trs := findBTAllNodes(n, func(node *html.Node) bool {
+		if node.Type == html.ElementNode && node.Data == "tr" {
+			for _, a := range node.Attr {
+				if a.Key == "id" && strings.HasPrefix(a.Val, "torrent") {
+					suffix := strings.TrimPrefix(a.Val, "torrent")
+					if _, err := strconv.Atoi(suffix); err == nil {
+						return true
+					}
+				}
+			}
+		}
+		return false
+	})
+
+	for _, tr := range trs {
+		descLink := findBTNode(tr, func(node *html.Node) bool {
+			if node.Type == html.ElementNode && node.Data == "a" {
+				for _, a := range node.Attr {
+					if a.Key == "onclick" && strings.Contains(a.Val, "gtoggle") {
+						return true
+					}
+				}
+			}
+			return false
+		})
+
+		if descLink == nil {
+			continue
+		}
+
+		descText := strings.ToLower(extractBTText(descLink))
+		isDisc := false
+		for _, kw := range []string{"bd25", "bd50", "bd66", "bd100", "dvd5", "dvd9", "m2ts"} {
+			if strings.Contains(descText, kw) {
+				isDisc = true
+				break
+			}
+		}
+
+		idVal := ""
+		for _, a := range tr.Attr {
+			if a.Key == "id" {
+				idVal = a.Val
+			}
+		}
+		torrentID := strings.TrimPrefix(idVal, "torrent")
+
+		fileDiv := findBTNodeByID(n, "files_"+torrentID)
+		if fileDiv == nil {
+			continue
+		}
+
+		if isDisc || isTVPack {
+			pathDiv := findBTNode(fileDiv, func(node *html.Node) bool {
+				return node.Type == html.ElementNode && node.Data == "div" && hasBTClass(node, "filelist_path")
+			})
+			if pathDiv != nil {
+				folderName := strings.Trim(strings.TrimSpace(extractBTText(pathDiv)), "/")
+				if folderName != "" {
+					*foundItems = append(*foundItems, folderName)
+				}
+			}
+		} else {
+			fileTable := findBTNode(fileDiv, func(node *html.Node) bool {
+				return node.Type == html.ElementNode && node.Data == "table" && hasBTClass(node, "filelist_table")
+			})
+			if fileTable != nil {
+				rows := findBTAllNodes(fileTable, func(node *html.Node) bool {
+					return node.Type == html.ElementNode && node.Data == "tr"
+				})
+				for _, row := range rows {
+					if hasBTClass(row, "colhead_dark") {
+						continue
+					}
+					cell := findBTNode(row, func(node *html.Node) bool {
+						return node.Type == html.ElementNode && node.Data == "td"
+					})
+					if cell != nil {
+						filename := strings.TrimSpace(extractBTText(cell))
+						if filename != "" {
+							*foundItems = append(*foundItems, filename)
+							break
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func findBTNode(n *html.Node, match func(*html.Node) bool) *html.Node {
+	if match(n) {
+		return n
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		if res := findBTNode(c, match); res != nil {
+			return res
+		}
+	}
+	return nil
+}
+
+func findBTAllNodes(n *html.Node, match func(*html.Node) bool) []*html.Node {
+	var nodes []*html.Node
+	if match(n) {
+		nodes = append(nodes, n)
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		nodes = append(nodes, findBTAllNodes(c, match)...)
+	}
+	return nodes
+}
+
+func hasBTClass(n *html.Node, class string) bool {
+	for _, a := range n.Attr {
+		if a.Key == "class" {
+			classes := strings.Fields(a.Val)
+			if slices.Contains(classes, class) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func extractBTText(n *html.Node) string {
+	if n.Type == html.TextNode {
+		return n.Data
+	}
+	var b strings.Builder
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		b.WriteString(extractBTText(c))
+	}
+	return b.String()
+}
+
+type responseInfo struct {
+	StatusCode int
+	FinalURL   string
+}
+
+func (r responseInfo) ok() bool {
+	return r.StatusCode >= http.StatusOK && r.StatusCode < http.StatusMultipleChoices
+}
+func trackerBaseURL(_ config.Config, _ string, fallback string) string {
+	return strings.TrimRight(fallback, "/")
+}
+func trackerHost(baseURL, fallback string) string {
+	parsed, err := url.Parse(baseURL)
+	if err == nil && parsed.Hostname() != "" {
+		return parsed.Hostname()
+	}
+	return fallback
+}
+func loadTrackerCookies(ctx context.Context, cfg config.Config, tracker, domain string) ([]*http.Cookie, error) {
+	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, cfg.MainSettings.DBPath, tracker, domain)
+	if err != nil {
+		return nil, fmt.Errorf("bt: load tracker cookies: %w", err)
+	}
+	return loaded, nil
+}
+
+func doTextGet(
+	ctx context.Context,
+	client *http.Client,
+	endpoint string,
+	params url.Values,
+	headers map[string]string,
+	trackerCookies []*http.Cookie,
+) (responseInfo, string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return responseInfo{}, "", fmt.Errorf("bt: create GET request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	commonhttp.ApplyCookies(req, trackerCookies)
+	resp, err := client.Do(req)
+	if err != nil {
+		return responseInfo{}, "", fmt.Errorf("bt: GET request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return responseInfo{StatusCode: resp.StatusCode}, "", fmt.Errorf("bt: read response: %w", err)
+	}
+	info := responseInfo{StatusCode: resp.StatusCode}
+	if resp.Request != nil && resp.Request.URL != nil {
+		info.FinalURL = resp.Request.URL.String()
+	}
+	return info, string(body), nil
+}
diff --git a/internal/trackers/impl/standalone/bt/profile.go b/internal/trackers/impl/standalone/bt/profile.go
new file mode 100644
index 00000000..4086821d
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/profile.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns BT identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                    "BT",
+		BaseURL:                 baseURL,
+		DescriptionGroup:        "bt",
+		UploadContentMode:       trackers.UploadContentModeDescription,
+		LocalizedMetadataLocale: "pt-BR",
+		PrepareDescription:      prepareDescription,
+		PrepareUpload:           prepareUpload,
+		NewDuplicateAdapter:     newDuplicateAdapter,
+		UploadArtifactPolicy:    &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		AudioPolicy:             &trackers.AudioPolicy{AllowBloat: true},
+		TorrentIdentityPolicy:   &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"t.brasiltracker.org"}},
+		AuthCapability:          standalone.CookieAuthCapability("BT"),
+	}
+}
+
+// New returns a fresh BT definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/bt/upload.go b/internal/trackers/impl/standalone/bt/upload.go
new file mode 100644
index 00000000..93d812b6
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/upload.go
@@ -0,0 +1,1376 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+const (
+	baseURL    = "https://brasiltracker.org"
+	uploadURL  = baseURL + "/upload.php"
+	torrentURL = baseURL + "/torrents.php?id="
+	sourceFlag = "BT"
+)
+
+var authPattern = regexp.MustCompile(`name="auth"\s+value="([^"]+)"`)
+var groupPattern = regexp.MustCompile(`groupid=(\d+)|torrents\.php\?id=(\d+)`)
+var mediaInfoDurationLinePattern = regexp.MustCompile(`(?im)^\s*duration(?:\s*/\s*string[123]?)?\s*:\s*(.+)$`)
+
+var mediaInfoDurationTokenPattern = regexp.MustCompile(
+	`(?i)(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|hours?|hrs?|h|minutes?|mins?|min|m|seconds?|secs?|sec|s)\b`,
+)
+var isoDurationPattern = regexp.MustCompile(`(?i)^pt(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?(?:(\d+(?:\.\d+)?)s)?$`)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string][]string
+	blockedReason string
+	questionnaire *api.TrackerQuestionnaire
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: BT %s", state.blockedReason)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayloadMulti(state.fields, []commonhttp.FileField{{
+		FieldName: "file_input",
+		FileName:  filepath.Base(state.torrentPath),
+		Path:      state.torrentPath,
+	}})
+
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "BT")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BT request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BT upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode >= 200 && resp.StatusCode < 400,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BT read upload response: %w", err)
+	}
+	match := groupPattern.FindStringSubmatch(finalURL + "\n" + string(responseBody))
+	id := metautil.FirstNonEmptyTrimmed(matchValue(match, 1), matchValue(match, 2))
+	if resp.StatusCode >= 200 && resp.StatusCode < 400 && id != "" {
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "BT",
+				TorrentID:   id,
+				TorrentURL:  tURL,
+				DownloadURL: tURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "BT", "upload_failure", responsePreview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("BT", resp.StatusCode, responsePreview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	fields := flattenFields(state.fields)
+	if _, ok := fields["auth"]; ok {
+		fields["auth"] = "[redacted]"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "BT",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "bt",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	auth := "dry-run-auth"
+	if !dryRun {
+		auth, err = fetchAuth(ctx, cookies)
+		if err != nil {
+			return uploadState{}, nil, err
+		}
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	fields := buildFields(req, description, auth, req.TrackerConfig, assets)
+	state := uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
+		fields:        fields,
+		questionnaire: buildQuestionnaire(req.Meta, fields),
+	}
+	switch {
+	case len(fields["image"]) == 0 || strings.TrimSpace(fields["image"][0]) == "":
+		state.blockedReason = "missing poster URL"
+	case len(fields["sinopse"]) == 0 || strings.TrimSpace(fields["sinopse"][0]) == "":
+		state.blockedReason = "missing overview"
+	case len(fields["tags"]) == 0 || strings.TrimSpace(fields["tags"][0]) == "":
+		state.blockedReason = "missing tags"
+	}
+
+	return state, cookies, nil
+}
+
+func buildFields(
+	req trackers.PreparationInput,
+	description string,
+	auth string,
+	trackerCfg config.TrackerConfig,
+	assets trackers.DescriptionAssets,
+) map[string][]string {
+	meta := req.Meta
+	answers := standalone.QuestionnaireAnswers(meta, "BT")
+	hasPT, subtitleIDs := resolveSubtitle(meta)
+	width, height := resolveResolution(meta)
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	fields := map[string][]string{
+		"audio_c":     {resolveAudioCodec(meta)},
+		"audio":       {resolveAudio(meta)},
+		"auth":        {auth},
+		"bitrate":     {resolveBitrate(meta)},
+		"desc":        {""},
+		"diretor":     {resolveDirectors(meta)},
+		"duracao":     {fmt.Sprintf("%d min", resolveRuntime(meta))},
+		"especificas": {description},
+		"format":      {resolveContainer(meta)},
+		"idioma_ori":  {resolveLanguage(meta)},
+		"image":       {resolvePoster(meta)},
+		"legenda":     {hasPT},
+		"mediainfo":   {trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta)},
+		"resolucao_1": {width},
+		"resolucao_2": {height},
+		"sinopse":     {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["overview"]), resolveOverview(meta, ptBR))},
+		"submit":      {"true"},
+		"tags":        {metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta, ptBR))},
+		"title":       {resolveTitle(meta)},
+		"type":        {resolveType(meta)},
+		"video_c":     {resolveVideoCodec(meta)},
+		"year":        {strconv.Itoa(resolveYear(meta))},
+		"youtube":     {resolveYouTube(meta, ptBR)},
+	}
+
+	fields["subtitles[]"] = append(fields["subtitles[]"], subtitleIDs...)
+
+	screens := resolveScreens(assets)
+	fields["screen[]"] = append(fields["screen[]"], screens...)
+
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	if !meta.Anime && (category == "MOVIE" || category == "TV") {
+		fields["3d"] = []string{yesNo(meta.Is3D != "")}
+		fields["adulto"] = []string{"0"}
+		fields["imdb_input"] = []string{resolveIMDbText(meta)}
+		fields["nota_imdb"] = []string{resolveIMDbRating(meta)}
+		fields["title_br"] = []string{resolveLocalizedTitle(meta, ptBR)}
+	}
+	if meta.Scene {
+		fields["scene"] = []string{"on"}
+	}
+	if category == "TV" || meta.Anime {
+		fields["episodio"] = []string{meta.EpisodeStr}
+		fields["ntorrent"] = []string{meta.SeasonStr + meta.EpisodeStr}
+		if meta.TVPack {
+			fields["temporada"] = []string{meta.SeasonStr}
+			fields["tipo"] = []string{"completa"}
+		} else {
+			fields["temporada_e"] = []string{meta.SeasonStr}
+			fields["tipo"] = []string{"ep_individual"}
+		}
+	}
+	if category == "MOVIE" {
+		fields["versao"] = []string{resolveEdition(meta)}
+	}
+	if meta.Anime {
+		fields["fundo_torrent"] = []string{resolveBackdrop(meta)}
+		fields["rating"] = []string{resolveIMDbRating(meta)}
+		fields["releasedate"] = []string{strconv.Itoa(resolveYear(meta))}
+		fields["horas"] = []string{""}
+		fields["minutos"] = []string{""}
+		fields["vote"] = []string{""}
+	}
+	if trackerCfg.Anon {
+		fields["anonymous"] = []string{"1"}
+	}
+	if trackers.IsInternalGroup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BT": trackerCfg}}}, "BT", meta) {
+		fields["internal"] = []string{"1"}
+	}
+	return fields
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	meta := req.Meta
+	var parts []string
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Logo
+	if logo := resolveLogo(meta); logo != "" {
+		parts = append(parts, "[center][img]"+logo+"[/img][/center]")
+	}
+
+	// TV Episode details
+	epTitle := meta.EpisodeTitle
+	epOverview := meta.EpisodeOverview
+	ptBR := api.ExtractTrackerLocalizedPTBR(meta)
+	if ptBR.EpisodeTitle != "" {
+		epTitle = ptBR.EpisodeTitle
+	}
+	if ptBR.EpisodeOverview != "" {
+		epOverview = ptBR.EpisodeOverview
+	}
+	if episode := strings.TrimSpace(epOverview); episode != "" {
+		if title := strings.TrimSpace(epTitle); title != "" {
+			parts = append(parts, "[center]"+title+"[/center]")
+		}
+		parts = append(parts, "[center]"+episode+"[/center]")
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// Signature
+	link, _ := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[center][url=%s]Upload realizado via %s[/url][/center]", link, "upbrr"))
+
+	// Join and finalize
+	description := strings.Join(parts, "\n\n")
+	finalized := finalizeDescription(description)
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "BT", req.Runtime.DBPath, finalized, req.Logger)
+	}
+
+	return finalized
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "BT", "brasiltracker.org")
+	if err != nil {
+		return values, fmt.Errorf("trackers: BT load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func fetchAuth(ctx context.Context, cookies []*http.Cookie) (string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uploadURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BT auth token request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(req, cookies)
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BT auth token request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	match := authPattern.FindStringSubmatch(string(body))
+	if len(match) < 2 {
+		return "", errors.New("trackers: BT auth token not found")
+	}
+	return strings.TrimSpace(match[1]), nil
+}
+
+func resolveType(meta api.UploadSubject) string {
+	if meta.Anime {
+		return "5"
+	}
+	if strings.EqualFold(categoryOf(meta), "TV") {
+		return "1"
+	}
+	return "0"
+}
+
+func resolveContainer(meta api.UploadSubject) string {
+	container := strings.ToLower(strings.TrimSpace(meta.Container))
+	switch container {
+	case "avi", "m2ts", "m4v", "mkv", "mp4", "ts", "vob", "wmv":
+		return strings.ToUpper(container)
+	default:
+		return "Outro"
+	}
+}
+
+func resolveAudio(meta api.UploadSubject) string {
+	pt := false
+	for _, lang := range meta.AudioLanguages {
+		lower := strings.ToLower(strings.TrimSpace(lang))
+		if lower == "portuguese" || lower == "português" || lower == "pt" {
+			pt = true
+			break
+		}
+	}
+	orig := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		orig = strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage))
+	}
+	if pt {
+		if orig == "pt" {
+			return "Nacional"
+		}
+		if len(meta.AudioLanguages) > 1 {
+			return "Dual Audio"
+		}
+		return "Dublado"
+	}
+	return "Legendado"
+}
+
+var targetSiteIDs = map[string]string{
+	"arabic":            "22",
+	"bulgarian":         "29",
+	"chinese":           "14",
+	"croatian":          "23",
+	"czech":             "30",
+	"danish":            "10",
+	"dutch":             "9",
+	"english - forçada": "50",
+	"english":           "3",
+	"estonian":          "38",
+	"finnish":           "15",
+	"french":            "5",
+	"german":            "6",
+	"greek":             "26",
+	"hebrew":            "40",
+	"hindi":             "41",
+	"hungarian":         "24",
+	"icelandic":         "28",
+	"indonesian":        "47",
+	"italian":           "16",
+	"japanese":          "8",
+	"korean":            "19",
+	"latvian":           "37",
+	"lithuanian":        "39",
+	"norwegian":         "12",
+	"persian":           "52",
+	"polish":            "17",
+	"português":         "49",
+	"romanian":          "13",
+	"russian":           "7",
+	"serbian":           "31",
+	"slovak":            "42",
+	"slovenian":         "43",
+	"spanish":           "4",
+	"swedish":           "11",
+	"thai":              "20",
+	"turkish":           "18",
+	"ukrainian":         "34",
+	"vietnamese":        "25",
+}
+
+var sourceAliasMap = map[string]string{
+	"arabic":                "arabic",
+	"ara":                   "arabic",
+	"ar":                    "arabic",
+	"brazilian portuguese":  "português",
+	"brazilian":             "português",
+	"portuguese-br":         "português",
+	"pt-br":                 "português",
+	"portuguese":            "português",
+	"por":                   "português",
+	"pt":                    "português",
+	"pt-pt":                 "português",
+	"português brasileiro":  "português",
+	"português":             "português",
+	"bulgarian":             "bulgarian",
+	"bul":                   "bulgarian",
+	"bg":                    "bulgarian",
+	"chinese":               "chinese",
+	"chi":                   "chinese",
+	"zh":                    "chinese",
+	"chinese (simplified)":  "chinese",
+	"chinese (traditional)": "chinese",
+	"cmn-hant":              "chinese",
+	"cmn-hans":              "chinese",
+	"yue-hant":              "chinese",
+	"yue-hans":              "chinese",
+	"croatian":              "croatian",
+	"hrv":                   "croatian",
+	"hr":                    "croatian",
+	"scr":                   "croatian",
+	"czech":                 "czech",
+	"cze":                   "czech",
+	"cz":                    "czech",
+	"cs":                    "czech",
+	"danish":                "danish",
+	"dan":                   "danish",
+	"da":                    "danish",
+	"dutch":                 "dutch",
+	"dut":                   "dutch",
+	"nl":                    "dutch",
+	"english - forced":      "english - forçada",
+	"english (forced)":      "english - forçada",
+	"en (forced)":           "english - forçada",
+	"en-us (forced)":        "english - forçada",
+	"english":               "english",
+	"eng":                   "english",
+	"en":                    "english",
+	"en-us":                 "english",
+	"en-gb":                 "english",
+	"english (cc)":          "english",
+	"english - sdh":         "english",
+	"estonian":              "estonian",
+	"est":                   "estonian",
+	"et":                    "estonian",
+	"finnish":               "finnish",
+	"fin":                   "finnish",
+	"fi":                    "finnish",
+	"french":                "french",
+	"fre":                   "french",
+	"fr":                    "french",
+	"fr-fr":                 "french",
+	"fr-ca":                 "french",
+	"german":                "german",
+	"ger":                   "german",
+	"de":                    "german",
+	"greek":                 "greek",
+	"gre":                   "greek",
+	"el":                    "greek",
+	"hebrew":                "hebrew",
+	"heb":                   "hebrew",
+	"he":                    "hebrew",
+	"hindi":                 "hindi",
+	"hin":                   "hindi",
+	"hi":                    "hindi",
+	"hungarian":             "hungarian",
+	"hun":                   "hungarian",
+	"hu":                    "hungarian",
+	"icelandic":             "icelandic",
+	"ice":                   "icelandic",
+	"is":                    "icelandic",
+	"indonesian":            "indonesian",
+	"ind":                   "indonesian",
+	"id":                    "indonesian",
+	"italian":               "italian",
+	"ita":                   "italian",
+	"it":                    "italian",
+	"japanese":              "japanese",
+	"jpn":                   "japanese",
+	"ja":                    "japanese",
+	"korean":                "korean",
+	"kor":                   "korean",
+	"ko":                    "korean",
+	"latvian":               "latvian",
+	"lav":                   "latvian",
+	"lv":                    "latvian",
+	"lithuanian":            "lithuanian",
+	"lit":                   "lithuanian",
+	"lt":                    "lithuanian",
+	"norwegian":             "norwegian",
+	"nor":                   "norwegian",
+	"no":                    "norwegian",
+	"persian":               "persian",
+	"fa":                    "persian",
+	"far":                   "persian",
+	"polish":                "polish",
+	"pol":                   "polish",
+	"pl":                    "polish",
+	"romanian":              "romanian",
+	"rum":                   "romanian",
+	"ro":                    "romanian",
+	"russian":               "russian",
+	"rus":                   "russian",
+	"ru":                    "russian",
+	"serbian":               "serbian",
+	"srp":                   "serbian",
+	"sr":                    "serbian",
+	"scc":                   "serbian",
+	"slovak":                "slovak",
+	"slo":                   "slovak",
+	"sk":                    "slovak",
+	"slovenian":             "slovenian",
+	"slv":                   "slovenian",
+	"sl":                    "slovenian",
+	"spanish":               "spanish",
+	"spa":                   "spanish",
+	"es":                    "spanish",
+	"es-es":                 "spanish",
+	"es-419":                "spanish",
+	"swedish":               "swedish",
+	"swe":                   "swedish",
+	"sv":                    "swedish",
+	"thai":                  "thai",
+	"tha":                   "thai",
+	"th":                    "thai",
+	"turkish":               "turkish",
+	"tur":                   "turkish",
+	"tr":                    "turkish",
+	"ukrainian":             "ukrainian",
+	"ukr":                   "ukrainian",
+	"uk":                    "ukrainian",
+	"vietnamese":            "vietnamese",
+	"vie":                   "vietnamese",
+	"vi":                    "vietnamese",
+}
+
+func resolveSubtitle(meta api.UploadSubject) (string, []string) {
+	hasPT := "Nao"
+	ids := make([]string, 0)
+	seen := make(map[string]struct{})
+
+	for _, lang := range meta.SubtitleLanguages {
+		cleanLang := strings.ToLower(strings.TrimSpace(lang))
+
+		targetKey, ok := sourceAliasMap[cleanLang]
+		if !ok {
+			targetKey = cleanLang
+		}
+
+		if id, exists := targetSiteIDs[targetKey]; exists {
+			if _, alreadySeen := seen[id]; !alreadySeen {
+				seen[id] = struct{}{}
+				ids = append(ids, id)
+
+				if id == "49" {
+					hasPT = "Sim"
+				}
+			}
+		}
+	}
+
+	if len(ids) == 0 {
+		return "Nao", []string{"44"}
+	}
+
+	return hasPT, ids
+}
+
+func resolveResolution(meta api.UploadSubject) (string, string) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		heightStr := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
+		heightNum, err := strconv.Atoi(heightStr)
+		if err == nil && heightNum > 0 {
+			widthNum := int(math.Round((16.0 / 9.0) * float64(heightNum)))
+			return strconv.Itoa(widthNum), strconv.Itoa(heightNum)
+		}
+	}
+
+	if meta.MediaInfoJSONPath != "" {
+		if payload, err := os.ReadFile(meta.MediaInfoJSONPath); err == nil {
+			type mediaInfoDoc struct {
+				Media struct {
+					Track []map[string]any `json:"track"`
+				} `json:"media"`
+			}
+			var doc mediaInfoDoc
+			if err := json.Unmarshal(payload, &doc); err == nil {
+				for _, track := range doc.Media.Track {
+					trackType, _ := track["@type"].(string)
+					if strings.ToLower(trackType) == "video" {
+						widthVal := track["Width"]
+						heightVal := track["Height"]
+
+						widthStr := parseDimensionStr(widthVal)
+						heightStr := parseDimensionStr(heightVal)
+
+						if widthStr != "" && heightStr != "" {
+							return widthStr, heightStr
+						}
+					}
+				}
+			}
+		}
+	}
+
+	height := strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(meta.Release.Resolution), "p"), "i")
+	switch height {
+	case "2160":
+		return "3840", "2160"
+	case "1080":
+		return "1920", "1080"
+	case "720":
+		return "1280", "720"
+	case "576":
+		return "1024", "576"
+	case "480":
+		return "854", "480"
+	default:
+		return "", ""
+	}
+}
+
+func parseDimensionStr(val any) string {
+	return metautil.ParseDimensionStr(val)
+}
+
+func resolveVideoCodec(meta api.UploadSubject) string {
+	videoEncode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
+	codecFinal := strings.TrimSpace(meta.VideoCodec)
+	isHDR := meta.HDR != ""
+
+	encodeMap := []struct{ Key, Value string }{
+		{"x265", "x265"},
+		{"h.265", "H.265"},
+		{"x264", "x264"},
+		{"h.264", "H.264"},
+		{"vp9", "VP9"},
+		{"xvid", "XviD"},
+	}
+
+	for _, item := range encodeMap {
+		if strings.Contains(videoEncode, item.Key) {
+			if (item.Value == "x265" || item.Value == "H.265") && isHDR {
+				return item.Value + " HDR"
+			}
+			return item.Value
+		}
+	}
+
+	codecLower := strings.ToLower(codecFinal)
+	codecMap := []struct{ Key, Value string }{
+		{"hevc", "x265"},
+		{"265", "x265"},
+		{"avc", "x264"},
+		{"264", "x264"},
+		{"mpeg-2", "MPEG-2"},
+		{"vc-1", "VC-1"},
+	}
+
+	for _, item := range codecMap {
+		if strings.Contains(codecLower, item.Key) {
+			if item.Value == "x265" && isHDR {
+				return "x265 HDR"
+			}
+			return item.Value
+		}
+	}
+
+	if codecFinal != "" {
+		return codecFinal
+	}
+	return "Outro"
+}
+
+func resolveAudioCodec(meta api.UploadSubject) string {
+	priorityOrder := []string{
+		"DTS-X", "E-AC-3 JOC", "TrueHD", "DTS-HD", "PCM", "FLAC", "DTS-ES",
+		"DTS", "E-AC-3", "AC3", "AAC", "Opus", "Vorbis", "MP3", "MP2",
+	}
+
+	codecMap := map[string][]string{
+		"DTS-X":      {"DTS:X"},
+		"E-AC-3 JOC": {"DD+ 5.1 Atmos", "DD+ 7.1 Atmos", "ATMOS"},
+		"TrueHD":     {"TRUEHD"},
+		"DTS-HD":     {"DTS-HD"},
+		"PCM":        {"LPCM", "PCM"},
+		"FLAC":       {"FLAC"},
+		"DTS-ES":     {"DTS-ES"},
+		"DTS":        {"DTS"},
+		"E-AC-3":     {"DD+", "E-AC-3"},
+		"AC3":        {"DD", "AC3"},
+		"AAC":        {"AAC"},
+		"Opus":       {"OPUS"},
+		"Vorbis":     {"VORBIS"},
+		"MP2":        {"MP2"},
+		"MP3":        {"MP3"},
+	}
+
+	audioDescription := strings.ToUpper(strings.TrimSpace(meta.Audio))
+	if audioDescription == "" {
+		return "Outro"
+	}
+
+	for _, codecName := range priorityOrder {
+		searchTerms := codecMap[codecName]
+		for _, term := range searchTerms {
+			if strings.Contains(audioDescription, term) {
+				return codecName
+			}
+		}
+	}
+
+	return "Outro"
+}
+
+func resolveBitrate(meta api.UploadSubject) string {
+	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
+	if strings.ToUpper(strings.TrimSpace(meta.Type)) == "DISC" || discType == "BDMV" || discType == "DVD" {
+		if discType == "BDMV" {
+			size := meta.SourceSize
+			switch {
+			case size > 66000000000:
+				return "BD100"
+			case size > 50000000000:
+				return "BD66"
+			case size > 25000000000:
+				return "BD50"
+			default:
+				return "BD25"
+			}
+		}
+		if discType == "DVD" {
+			dvdSize := strings.ToUpper(strings.TrimSpace(meta.Release.Size))
+			if dvdSize == "DVD9" || dvdSize == "DVD5" {
+				return dvdSize
+			}
+			return "DVD9"
+		}
+	}
+
+	sourceType := strings.ToLower(strings.TrimSpace(meta.Type))
+	keywordMap := map[string]string{
+		"remux":  "Remux",
+		"webdl":  "WEB-DL",
+		"webrip": "WEBRip",
+		"web":    "WEB",
+		"encode": "Blu-ray",
+		"bdrip":  "BDRip",
+		"brrip":  "BRRip",
+		"hdtv":   "HDTV",
+		"sdtv":   "SDTV",
+		"dvdrip": "DVDRip",
+		"hd-dvd": "HD-DVD",
+		"tvrip":  "TVRip",
+	}
+
+	if val, ok := keywordMap[sourceType]; ok {
+		return val
+	}
+
+	source := strings.ToLower(strings.TrimSpace(meta.Release.Source))
+	if val, ok := keywordMap[source]; ok {
+		return val
+	}
+
+	return "Outro"
+}
+
+func resolveEdition(meta api.UploadSubject) string {
+	edition := strings.ToLower(strings.TrimSpace(meta.Edition))
+	switch {
+	case strings.Contains(edition, "director"):
+		return "Director's Cut"
+	case strings.Contains(edition, "theatrical"):
+		return "Theatrical Cut"
+	case strings.Contains(edition, "extended"):
+		return "Extended"
+	case strings.Contains(edition, "uncut"):
+		return "Uncut"
+	case strings.Contains(edition, "unrated"):
+		return "Unrated"
+	case strings.Contains(edition, "imax"):
+		return "IMAX"
+	case strings.Contains(edition, "noir"):
+		return "Noir"
+	case strings.Contains(edition, "remaster"):
+		return "Remastered"
+	default:
+		return ""
+	}
+}
+
+func removeDiacritics(s string) string {
+	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	result, _, _ := transform.String(t, s)
+	return result
+}
+
+func resolveTags(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	// 1. Use localized if available
+	if ptBR.Genres != "" {
+		genres := strings.Split(strings.TrimSpace(ptBR.Genres), ",")
+		out := make([]string, 0, len(genres))
+		for _, genre := range genres {
+			cleaned := removeDiacritics(genre)
+			tag := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(cleaned), " ", "."))
+			if tag != "" {
+				out = append(out, tag)
+			}
+		}
+		return strings.Join(out, ", ")
+	}
+
+	// 2. Use metautil.TranslateGenreToPortugueseStrict to translate
+	var genreText string
+	switch {
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres) != "":
+		genreText = strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	default:
+		genreText = strings.TrimSpace(meta.Release.Genre)
+	}
+
+	if genreText == "" {
+		return ""
+	}
+
+	genres := strings.Split(genreText, ",")
+	out := make([]string, 0, len(genres))
+	for _, genre := range genres {
+		translated := metautil.TranslateGenreToPortugueseStrict(genre)
+		if translated == "" {
+			translated = genre
+		}
+		cleaned := removeDiacritics(translated)
+		tag := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(cleaned), " ", "."))
+		if tag != "" {
+			out = append(out, tag)
+		}
+	}
+	return strings.Join(out, ", ")
+}
+
+func resolveRuntime(meta api.UploadSubject) int {
+	if meta.MediaInfoTextPath != "" {
+		if payload, err := os.ReadFile(meta.MediaInfoTextPath); err == nil {
+			if minutes := parseMediaInfoDurationMinutes(string(payload)); minutes > 0 {
+				return minutes
+			}
+		}
+	}
+	if meta.DVDVOBMediaInfoText != "" {
+		if minutes := parseMediaInfoDurationMinutes(meta.DVDVOBMediaInfoText); minutes > 0 {
+			return minutes
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") && meta.Disc.DurationSeconds > 0 {
+		return int(math.Round(meta.Disc.DurationSeconds / 60))
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.RuntimeMinutes > 0 {
+		return meta.ProviderMetadata.IMDB.RuntimeMinutes
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return meta.ProviderMetadata.TMDB.Runtime
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		return meta.ProviderMetadata.TVmaze.Runtime
+	}
+	return 0
+}
+
+// parseMediaInfoDurationMinutes returns rounded minutes from the first parseable
+// MediaInfo Duration or Duration/String[1-3] line.
+func parseMediaInfoDurationMinutes(content string) int {
+	for _, match := range mediaInfoDurationLinePattern.FindAllStringSubmatch(content, -1) {
+		if len(match) != 2 {
+			continue
+		}
+		if minutes := parseMediaInfoDurationValueMinutes(match[1]); minutes > 0 {
+			return minutes
+		}
+	}
+	return 0
+}
+
+// parseMediaInfoDurationValueMinutes accepts colon time, unit-token text, or
+// raw millisecond values as emitted by MediaInfo duration fields.
+func parseMediaInfoDurationValueMinutes(value string) int {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 0
+	}
+	if matches := isoDurationPattern.FindStringSubmatch(trimmed); len(matches) == 4 {
+		return mediaInfoDurationSecondsToMinutes(durationComponentSeconds(matches[1], matches[2], matches[3], ""))
+	}
+	if strings.Contains(trimmed, ":") {
+		return mediaInfoDurationSecondsToMinutes(parseMediaInfoDurationColonSeconds(trimmed))
+	}
+	if seconds := parseMediaInfoDurationTokenSeconds(trimmed); seconds > 0 {
+		return mediaInfoDurationSecondsToMinutes(seconds)
+	}
+	if fields := strings.Fields(trimmed); len(fields) > 0 {
+		if ms, err := strconv.ParseFloat(strings.ReplaceAll(fields[0], ",", ""), 64); err == nil && ms > 10000 {
+			return int(math.Round(ms / 60000.0))
+		}
+	}
+	return 0
+}
+
+// parseMediaInfoDurationTokenSeconds sums h/m/s/ms duration tokens into seconds.
+func parseMediaInfoDurationTokenSeconds(value string) float64 {
+	var total float64
+	for _, match := range mediaInfoDurationTokenPattern.FindAllStringSubmatch(value, -1) {
+		if len(match) != 3 {
+			continue
+		}
+		amount, err := strconv.ParseFloat(strings.ReplaceAll(match[1], ",", ""), 64)
+		if err != nil || amount <= 0 {
+			continue
+		}
+		switch strings.ToLower(match[2]) {
+		case "h", "hr", "hrs", "hour", "hours":
+			total += amount * 3600
+		case "m", "min", "mins", "minute", "minutes":
+			total += amount * 60
+		case "s", "sec", "secs", "second", "seconds":
+			total += amount
+		case "ms", "msec", "msecs", "millisecond", "milliseconds":
+			total += amount / 1000
+		}
+	}
+	return total
+}
+
+// parseMediaInfoDurationColonSeconds parses MediaInfo colon duration values into seconds.
+func parseMediaInfoDurationColonSeconds(value string) float64 {
+	parts := strings.Split(strings.TrimSpace(value), ":")
+	if len(parts) < 2 {
+		return 0
+	}
+	var seconds float64
+	multiplier := 1.0
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := strings.TrimSpace(parts[i])
+		if part == "" {
+			continue
+		}
+		amount, err := strconv.ParseFloat(strings.ReplaceAll(part, ",", ""), 64)
+		if err != nil || amount < 0 {
+			return 0
+		}
+		seconds += amount * multiplier
+		multiplier *= 60
+	}
+	return seconds
+}
+
+func mediaInfoDurationSecondsToMinutes(seconds float64) int {
+	if seconds <= 0 {
+		return 0
+	}
+	return int(math.Round(seconds / 60.0))
+}
+
+func durationComponentSeconds(hours string, minutes string, seconds string, milliseconds string) float64 {
+	totalSeconds := parseDurationComponent(hours) * 3600
+	totalSeconds += parseDurationComponent(minutes) * 60
+	totalSeconds += parseDurationComponent(seconds)
+	totalSeconds += parseDurationComponent(milliseconds) / 1000
+	return totalSeconds
+}
+
+func parseDurationComponent(value string) float64 {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return 0
+	}
+	parsed, err := strconv.ParseFloat(trimmed, 64)
+	if err != nil || parsed < 0 {
+		return 0
+	}
+	return parsed
+}
+
+func resolveDirectors(meta api.UploadSubject) string {
+	var directors []string
+	seen := make(map[string]struct{})
+
+	addDirector := func(name string) {
+		name = strings.TrimSpace(name)
+		if name == "" {
+			return
+		}
+		if _, ok := seen[name]; !ok {
+			seen[name] = struct{}{}
+			directors = append(directors, name)
+		}
+	}
+
+	if meta.ProviderMetadata.TMDB != nil {
+		for _, name := range meta.ProviderMetadata.TMDB.Directors {
+			addDirector(name)
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		for _, person := range meta.ProviderMetadata.IMDB.Directors {
+			addDirector(person.Name)
+		}
+	}
+
+	if len(directors) > 0 {
+		limit := min(len(directors), 5)
+		return strings.Join(directors[:limit], ", ")
+	}
+
+	return "N/A"
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		if meta.ProviderMetadata.TMDB.Localized != nil {
+			if localized, ok := meta.ProviderMetadata.TMDB.Localized["pt-BR"]; ok && strings.TrimSpace(localized.Poster) != "" {
+				return strings.TrimSpace(localized.Poster)
+			}
+		}
+		if strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster) != "" {
+			return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	}
+	return ""
+}
+
+func resolveScreens(assets trackers.DescriptionAssets) []string {
+	var screens []string
+	seen := make(map[string]struct{})
+
+	for _, image := range assets.MenuImages {
+		u := strings.TrimSpace(image.RawURL)
+		if u == "" {
+			u = strings.TrimSpace(image.ImgURL)
+		}
+		if u != "" && !isSeen(seen, u) {
+			screens = append(screens, u)
+			seen[u] = struct{}{}
+		}
+	}
+	for _, image := range assets.Screenshots {
+		u := strings.TrimSpace(image.RawURL)
+		if u == "" {
+			u = strings.TrimSpace(image.ImgURL)
+		}
+		if u != "" && !isSeen(seen, u) {
+			screens = append(screens, u)
+			seen[u] = struct{}{}
+		}
+	}
+	return screens
+}
+
+func isSeen(seen map[string]struct{}, url string) bool {
+	_, ok := seen[url]
+	return ok
+}
+
+// resolveOverview prefers scoped TV synopsis for episode/season-pack uploads,
+// then localized title-level overview, then TMDB or IMDB fallback text.
+func resolveOverview(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	if shouldUseScopedTVOverview(meta) && ptBR.EpisodeOverview != "" {
+		return strings.TrimSpace(ptBR.EpisodeOverview)
+	}
+	if ptBR.Overview != "" {
+		return strings.TrimSpace(ptBR.Overview)
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	}
+	return ""
+}
+
+// shouldUseScopedTVOverview reports whether BT should prefer season or
+// episode localized overview over title-level synopsis text.
+func shouldUseScopedTVOverview(meta api.UploadSubject) bool {
+	if meta.SeasonInt <= 0 {
+		return false
+	}
+	if !isTVUpload(meta) {
+		return false
+	}
+	if meta.TVPack {
+		return true
+	}
+	return meta.EpisodeInt > 0
+}
+
+// isTVUpload reports whether canonical identity classifies the upload as TV.
+func isTVUpload(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func resolveYouTube(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	youtube := ""
+	if ptBR.TrailerURL != "" {
+		youtube = strings.TrimSpace(ptBR.TrailerURL)
+	} else if meta.ProviderMetadata.TMDB != nil {
+		youtube = strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+
+	if strings.Contains(youtube, "youtube.com") || strings.Contains(youtube, "youtu.be") {
+		switch {
+		case strings.Contains(youtube, "v="):
+			parts := strings.Split(youtube, "v=")
+			if len(parts) > 1 {
+				youtube = parts[1]
+			}
+		case strings.Contains(youtube, "embed/"):
+			parts := strings.Split(youtube, "embed/")
+			if len(parts) > 1 {
+				youtube = parts[1]
+			}
+		case strings.Contains(youtube, "youtu.be/"):
+			parts := strings.Split(youtube, "youtu.be/")
+			if len(parts) > 1 {
+				youtube = parts[1]
+			}
+		}
+	}
+
+	if idx := strings.Index(youtube, "&"); idx != -1 {
+		youtube = youtube[:idx]
+	}
+	if idx := strings.Index(youtube, "?"); idx != -1 {
+		youtube = youtube[:idx]
+	}
+	youtube = strings.ReplaceAll(youtube, "/", "")
+	return youtube
+}
+
+func resolveLogo(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo) != "" {
+		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo), "/")
+	}
+	return ""
+}
+
+func resolveYear(meta api.UploadSubject) int {
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		return meta.ProviderMetadata.TMDB.Year
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		return meta.ProviderMetadata.IMDB.Year
+	}
+	return meta.Release.Year
+}
+
+func resolveTitle(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Title, meta.Release.Title)
+	}
+	return meta.Release.Title
+}
+
+func resolveLocalizedTitle(meta api.UploadSubject, ptBR api.TMDBLocalizedData) string {
+	if ptBR.Title != "" {
+		if meta.ProviderMetadata.TMDB != nil {
+			return metautil.FirstNonEmptyTrimmed(ptBR.Title, meta.ProviderMetadata.TMDB.OriginalTitle)
+		}
+		return ptBR.Title
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Title, meta.ProviderMetadata.TMDB.OriginalTitle)
+	}
+	return ""
+}
+
+func resolveLanguage(meta api.UploadSubject) string {
+	var lang string
+	if meta.ProviderMetadata.TMDB != nil {
+		lang = strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage)
+	}
+	if lang == "" {
+		if len(meta.Release.Language) > 0 {
+			lang = meta.Release.Language[0]
+		}
+	}
+	lang = strings.ToLower(lang)
+	if lang == "" {
+		return ""
+	}
+
+	return metautil.ISO639PortugueseName(lang, lang)
+}
+
+func resolveBackdrop(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Backdrop)
+	}
+	return ""
+}
+
+func resolveIMDbText(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveIMDbRating(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Rating > 0 {
+		return strconv.FormatFloat(meta.ProviderMetadata.IMDB.Rating, 'f', 1, 64)
+	}
+	return ""
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func yesNo(value bool) string {
+	if value {
+		return "Sim"
+	}
+	return "Nao"
+}
+
+func flattenFields(in map[string][]string) map[string]string {
+	out := make(map[string]string, len(in))
+	for key, values := range in {
+		if len(values) > 0 {
+			out[key] = strings.Join(values, ", ")
+		}
+	}
+	return out
+}
+
+func matchValue(values []string, idx int) string {
+	if idx >= 0 && idx < len(values) {
+		return values[idx]
+	}
+	return ""
+}
+
+func buildQuestionnaire(meta api.UploadSubject, fields map[string][]string) *api.TrackerQuestionnaire {
+	current := standalone.QuestionnaireAnswers(meta, "BT")
+	var items []api.TrackerQuestionnaireField
+
+	sinopse := ""
+	if len(fields["sinopse"]) > 0 {
+		sinopse = strings.TrimSpace(fields["sinopse"][0])
+	}
+	if sinopse == "" {
+		items = append(items, api.TrackerQuestionnaireField{
+			Key:      "overview",
+			Label:    "Overview",
+			Kind:     "textarea",
+			Value:    current["overview"],
+			Required: true,
+		})
+	}
+
+	tags := ""
+	if len(fields["tags"]) > 0 {
+		tags = strings.TrimSpace(fields["tags"][0])
+	}
+	if tags == "" {
+		items = append(items, api.TrackerQuestionnaireField{
+			Key:      "tags",
+			Label:    "Tags",
+			Kind:     "text",
+			Value:    current["tags"],
+			Required: true,
+		})
+	}
+
+	if len(items) == 0 {
+		return nil
+	}
+	return &api.TrackerQuestionnaire{Tracker: "BT", Fields: items}
+}
diff --git a/internal/trackers/impl/standalone/bt/upload_test.go b/internal/trackers/impl/standalone/bt/upload_test.go
new file mode 100644
index 00000000..b51eec8b
--- /dev/null
+++ b/internal/trackers/impl/standalone/bt/upload_test.go
@@ -0,0 +1,324 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package bt
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveOverviewUsesScopedTVOverviewOnlyForEpisodeOrSeasonPack(t *testing.T) {
+	t.Parallel()
+
+	ptBR := api.TMDBLocalizedData{
+		Overview:        "Series Overview",
+		EpisodeOverview: "Episode Overview",
+	}
+
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+		want string
+	}{
+		{
+			name: "episode upload uses episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "TV"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "lowercase episode upload uses episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "tv"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "season pack uses season overview from episode field",
+			meta: api.UploadSubject{
+				Identity:  api.ExternalIdentity{Category: "TV"},
+				SeasonInt: 1,
+				TVPack:    true,
+			},
+			want: "Episode Overview",
+		},
+		{
+			name: "series upload uses title overview",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "TV"},
+			},
+			want: "Series Overview",
+		},
+		{
+			name: "movie ignores episode overview",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: "MOVIE"},
+				SeasonInt:  1,
+				EpisodeInt: 2,
+			},
+			want: "Series Overview",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := resolveOverview(tc.meta, ptBR); got != tc.want {
+				t.Fatalf("expected overview %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestResolveTagsPreservesUnknownGenres(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Release: api.ReleaseInfo{
+			Genre: "Sci-Fi,MyCustomGenre",
+		},
+	}
+	ptBR := api.TMDBLocalizedData{}
+
+	// Sci-Fi maps to "ficção científica", MyCustomGenre does not map but should be preserved
+	got := resolveTags(meta, ptBR)
+	expected := "ficcao.cientifica, mycustomgenre"
+	if got != expected {
+		t.Fatalf("expected tags %q, got %q", expected, got)
+	}
+}
+
+func TestBuildDescriptionOmitsBlankLocalizedEpisodeTitleRow(t *testing.T) {
+	t.Parallel()
+
+	description := buildDescription(trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Localized: map[string]api.TMDBLocalizedData{
+						"pt-BR": {EpisodeOverview: "Resumo do episodio"},
+					},
+				},
+			},
+		},
+	}, trackers.DescriptionAssets{})
+
+	if strings.Contains(description, "[center][/center]") {
+		t.Fatalf("expected no blank centered title row, got %q", description)
+	}
+	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
+		t.Fatalf("expected localized episode overview, got %q", description)
+	}
+}
+
+func TestBuildDescriptionKeepsLocalizedEpisodeTitleWhenPresent(t *testing.T) {
+	t.Parallel()
+
+	description := buildDescription(trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Localized: map[string]api.TMDBLocalizedData{
+						"pt-BR": {
+							EpisodeTitle:    "Titulo do episodio",
+							EpisodeOverview: "Resumo do episodio",
+						},
+					},
+				},
+			},
+		},
+	}, trackers.DescriptionAssets{})
+
+	if !strings.Contains(description, "[center]Titulo do episodio[/center]") {
+		t.Fatalf("expected localized episode title, got %q", description)
+	}
+	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
+		t.Fatalf("expected localized episode overview, got %q", description)
+	}
+}
+
+func TestBuildDescriptionTreatsWhitespaceLocalizedEpisodeTitleAsEmpty(t *testing.T) {
+	t.Parallel()
+
+	description := buildDescription(trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Localized: map[string]api.TMDBLocalizedData{
+						"pt-BR": {
+							EpisodeTitle:    " \t ",
+							EpisodeOverview: "Resumo do episodio",
+						},
+					},
+				},
+			},
+		},
+	}, trackers.DescriptionAssets{})
+
+	if strings.Contains(description, "[center][/center]") {
+		t.Fatalf("expected no blank centered title row, got %q", description)
+	}
+	if !strings.Contains(description, "[center]Resumo do episodio[/center]") {
+		t.Fatalf("expected localized episode overview, got %q", description)
+	}
+}
+
+func TestResolveVideoCodecMapsH264H265(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		codec    string
+		isHDR    bool
+		expected string
+	}{
+		{
+			codec:    "H264",
+			isHDR:    false,
+			expected: "x264",
+		},
+		{
+			codec:    "H265",
+			isHDR:    false,
+			expected: "x265",
+		},
+		{
+			codec:    "H265",
+			isHDR:    true,
+			expected: "x265 HDR",
+		},
+		{
+			codec:    "hevc",
+			isHDR:    false,
+			expected: "x265",
+		},
+		{
+			codec:    "avc",
+			isHDR:    false,
+			expected: "x264",
+		},
+		{
+			codec:    "OtherCodec",
+			isHDR:    false,
+			expected: "OtherCodec",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.codec, func(t *testing.T) {
+			meta := api.UploadSubject{
+				VideoCodec: tc.codec,
+			}
+			if tc.isHDR {
+				meta.HDR = "HDR10"
+			}
+			got := resolveVideoCodec(meta)
+			if got != tc.expected {
+				t.Fatalf("expected %q for codec %q (HDR=%t), got %q", tc.expected, tc.codec, tc.isHDR, got)
+			}
+		})
+	}
+}
+
+func TestParseMediaInfoDurationMinutes(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		content  string
+		expected int
+	}{
+		{
+			name:     "valid hours and minutes",
+			content:  "duration : 2 h 15 m",
+			expected: 135,
+		},
+		{
+			name:     "duration string label",
+			content:  "Duration/String : 2 h 5 min 2 s",
+			expected: 125,
+		},
+		{
+			name:     "duration string1 label",
+			content:  "\tDuRaTiOn/String1   : 2 h 5 min 2 s",
+			expected: 125,
+		},
+		{
+			name:     "duration spaced slash label",
+			content:  "Duration / String2 : 2 hrs 5 mins 2 secs",
+			expected: 125,
+		},
+		{
+			name:     "duration string3 colon label",
+			content:  "Duration/String3 : 02:05:02.000",
+			expected: 125,
+		},
+		{
+			name:     "iso duration value",
+			content:  "Duration/String : PT2H5M2S",
+			expected: 125,
+		},
+		{
+			name:     "valid milliseconds",
+			content:  "duration : 120000",
+			expected: 2,
+		},
+		{
+			name:     "empty fields (potential panic)",
+			content:  "duration :    ",
+			expected: 0,
+		},
+		{
+			name:     "invalid string1 skips to later duration",
+			content:  "Duration/String1 : not a duration\nDuration/String2 : 01:30:00.000",
+			expected: 90,
+		},
+		{
+			name:     "duration string4 remains ignored",
+			content:  "Duration/String4 : 01:30:00.000",
+			expected: 0,
+		},
+		{
+			name:     "adjacent duration fields remain ignored",
+			content:  "Source_Duration : 01:30:00.000\nDuration_Start : 01:30:00.000",
+			expected: 0,
+		},
+		{
+			name:     "no duration keyword",
+			content:  "something else",
+			expected: 0,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := parseMediaInfoDurationMinutes(tc.content)
+			if got != tc.expected {
+				t.Fatalf("expected %d, got %d", tc.expected, got)
+			}
+		})
+	}
+}
+
+func TestResolveRuntimeFallsBackWhenMediaInfoDurationInvalid(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		DVDVOBMediaInfoText: "Duration/String : not a duration",
+		DiscType:            "BDMV",
+		Disc:                api.DiscFacts{DurationSeconds: 5400},
+	}
+
+	if got := resolveRuntime(meta); got != 90 {
+		t.Fatalf("expected BDInfo runtime fallback, got %d", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/btn/claims.go b/internal/trackers/impl/standalone/btn/claims.go
new file mode 100644
index 00000000..a9aad8b5
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/claims.go
@@ -0,0 +1,1046 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
+	"encoding/base32"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	htmlnode "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	btnSiteBaseURL             = "https://broadcasthe.net"
+	btnBackupBaseURL           = "https://backup.landof.tv"
+	btnUserPath                = "/user.php"
+	btnClaimsLoginPath         = "/login.php"
+	btnClaimedShowsURL         = "https://broadcasthe.net/forums.php?action=viewthread&threadid=30793"
+	btnClaimedShowsPostID      = "post1405482"
+	btnClaimedShowsCacheTTL    = 48 * time.Hour
+	btnClaimWindowBaseHours    = 48
+	btnClaimWindowDefaultGrace = 24
+)
+
+var (
+	btnLineBreakPattern  = regexp.MustCompile(`(?i)<br\s*/?>`)
+	btnTagPattern        = regexp.MustCompile(`(?s)<[^>]*>`)
+	btnAKAExtractPattern = regexp.MustCompile(`(?i)\(\s*aka\s*:\s*([^\)]*?)\)`)
+	btnSxxExxCutPattern  = regexp.MustCompile(`(?i)\bS\d{1,2}E\d{1,3}\b`)
+	btnSeasonCutPattern  = regexp.MustCompile(`(?i)\bS\d{1,2}\b`)
+	btnDateCutPattern    = regexp.MustCompile(`\b\d{4}[\-\.]\d{2}[\-\.]\d{2}\b`)
+	btnNonAlnumPattern   = regexp.MustCompile(`[^a-z0-9]+`)
+	btnSpacePattern      = regexp.MustCompile(`\s+`)
+	btnTime24Pattern     = regexp.MustCompile(`^(\d{1,2}):(\d{2})(?::(\d{2}))?$`)
+	btnTime12Pattern     = regexp.MustCompile(`^(\d{1,2}):(\d{2})\s*([AaPp][Mm])$`)
+)
+
+type btnClaimedShowsCache struct {
+	FetchedAt int64    `json:"fetched_at"`
+	SourceURL string   `json:"source_url"`
+	PostID    string   `json:"post_id"`
+	Titles    []string `json:"titles"`
+}
+
+type claimChecker struct {
+	cfg    config.Config
+	logger api.Logger
+}
+
+// NewClaimChecker returns a BTN claim checker backed by the configured claim
+// cache and tracker credentials. A nil logger is replaced with a no-op logger.
+func (d *Definition) NewClaimChecker(cfg config.Config, logger api.Logger) trackers.ClaimChecker {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &claimChecker{cfg: cfg, logger: logger}
+}
+
+// HasClaim reports whether a TV title appears in BTN's claimed-show list and
+// remains inside its claim window. Non-TV content and unavailable claim data
+// fail open as unclaimed; malformed or missing air dates keep a matched claim
+// active because expiry cannot be established.
+func (s *claimChecker) HasClaim(ctx context.Context, meta api.UploadSubject) (bool, error) {
+	if !btnIsTVCategory(meta) {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims skipped for non-TV content")
+		}
+		return false, nil
+	}
+
+	cachePath, err := btnClaimsPath(s.cfg.MainSettings.DBPath)
+	if err != nil {
+		return false, fmt.Errorf("metadata: BTN claims cache path: %w", err)
+	}
+
+	claimedTitles, err := s.loadBTNClaimedTitles(ctx, cachePath, btnClaimedShowsCacheTTL)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claim list unavailable: %v", err)
+		}
+		return false, nil
+	}
+	if len(claimedTitles) == 0 {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims loaded 0 titles")
+		}
+		return false, nil
+	}
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims loaded %d titles", len(claimedTitles))
+	}
+
+	matched, matchedTitle := matchBTNClaimedTitle(meta, claimedTitles)
+	if !matched {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims found no title match for release=%q", meta.ReleaseName)
+		}
+		return false, nil
+	}
+
+	graceHours := s.btnClaimWindowGraceHours()
+	expired, thresholdHours, hoursSinceAir := btnClaimWindowExpired(meta, graceHours)
+	if expired {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claim window expired for %q (hours_since_air=%.2f threshold=%d)", matchedTitle, hoursSinceAir, thresholdHours)
+		}
+		return false, nil
+	}
+
+	if s.logger != nil {
+		s.logger.Warnf("metadata: BTN claim match found title=%q threshold_hours=%d cache_ttl=%s", matchedTitle, thresholdHours, btnClaimedShowsCacheTTL)
+	}
+	return true, nil
+}
+
+func (s *claimChecker) btnClaimWindowGraceHours() int {
+	grace := btnClaimWindowDefaultGrace
+	entry, ok := trackerConfigFor(s.cfg, "BTN")
+	if !ok || entry.Unknown == nil {
+		return grace
+	}
+	value, ok := entry.Unknown["claim_window_grace_hours"]
+	if !ok {
+		return grace
+	}
+	parsed := parseOptionalInt(value)
+	if parsed < 0 {
+		return 0
+	}
+	if parsed == 0 {
+		return grace
+	}
+	return parsed
+}
+
+func (s *claimChecker) loadBTNClaimedTitles(ctx context.Context, cachePath string, cacheTTL time.Duration) (map[string]struct{}, error) {
+	cached, fetchedAt, cacheErr := readBTNClaimedCache(cachePath)
+	if cacheErr != nil {
+		if s.logger != nil && !errors.Is(cacheErr, os.ErrNotExist) {
+			s.logger.Warnf("metadata: BTN claims cache read failed path=%s err=%s", cachePath, redaction.RedactValue(cacheErr.Error(), nil))
+		}
+	} else if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims cache loaded path=%s titles=%d fetched_at=%d", cachePath, len(cached), fetchedAt)
+	}
+	if len(cached) > 0 && time.Since(time.Unix(fetchedAt, 0)) < cacheTTL {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims cache hit path=%s age=%s ttl=%s", cachePath, time.Since(time.Unix(fetchedAt, 0)).Round(time.Second), cacheTTL)
+		}
+		return cached, nil
+	}
+	if s.logger != nil {
+		if len(cached) == 0 {
+			s.logger.Debugf("metadata: BTN claims cache miss path=%s", cachePath)
+		} else {
+			s.logger.Debugf(
+				"metadata: BTN claims cache stale path=%s age=%s ttl=%s",
+				cachePath,
+				time.Since(time.Unix(fetchedAt, 0)).Round(time.Second),
+				cacheTTL,
+			)
+		}
+	}
+
+	fresh, fetchErr := s.fetchBTNClaimedTitles(ctx)
+	if fetchErr == nil && len(fresh) > 0 {
+		if err := writeBTNClaimedCache(cachePath, fresh); err != nil && s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims cache write failed: %v", err)
+		} else if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims cache saved path=%s titles=%d", cachePath, len(fresh))
+		}
+		return fresh, nil
+	}
+	if fetchErr == nil && len(fresh) == 0 && s.logger != nil {
+		s.logger.Warnf("metadata: BTN claims fetch succeeded but returned no titles")
+	}
+	if fetchErr != nil && s.logger != nil {
+		s.logger.Warnf("metadata: BTN claims fetch failed; falling back to cache: %v", fetchErr)
+	}
+	if len(cached) > 0 {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims using cached titles after fetch failure path=%s titles=%d", cachePath, len(cached))
+		}
+		return cached, nil
+	}
+	return nil, fetchErr
+}
+
+func (s *claimChecker) fetchBTNClaimedTitles(ctx context.Context) (map[string]struct{}, error) {
+	jar, _ := cookiejar.New(nil)
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims fetch starting url=%s", btnClaimedShowsURL)
+	}
+	if err := s.loadBTNCookiesForClaims(ctx, client); err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims cookie load failed: %v", err)
+		}
+	} else if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims cookie load completed")
+	}
+	isLoggedIn, err := s.btnClaimsSessionValid(ctx, client)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims session validation failed: %v", err)
+		}
+	} else if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims session valid=%t", isLoggedIn)
+	}
+	if !isLoggedIn {
+		if err := s.loginBTNForClaims(ctx, client); err != nil {
+			if s.logger != nil {
+				s.logger.Warnf("metadata: BTN claims login failed: %v", err)
+			}
+			return nil, err
+		} else if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims login completed")
+		}
+	} else if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims login skipped; existing session is valid")
+	}
+	if !isLoggedIn && s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims continuing after login attempt")
+	}
+	mirrorBTNCookiesForClaimedThread(client)
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims mirrored cookies for broadcasthe thread")
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, btnClaimedShowsURL, nil)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims request build failed: %v", err)
+		}
+		return nil, fmt.Errorf("metadata: build BTN claims request: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims fetch request failed: %v", err)
+		}
+		return nil, fmt.Errorf("metadata: execute BTN claims request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims fetch returned status=%d", resp.StatusCode)
+		}
+		return nil, fmt.Errorf("status %d", resp.StatusCode)
+	}
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims fetch returned status=%d", resp.StatusCode)
+	}
+
+	payload, err := ioReadAllLimit(resp, 1<<20)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims response read failed: %v", err)
+		}
+		return nil, err
+	}
+	titles := extractBTNClaimedShows(string(payload))
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims parsed %d titles from claimed thread", len(titles))
+	}
+	return titles, nil
+}
+
+func (s *claimChecker) loginBTNForClaims(ctx context.Context, client *http.Client) error {
+	entry, ok := trackerConfigFor(s.cfg, "BTN")
+	if !ok {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims login skipped; tracker not configured")
+		}
+		return nil
+	}
+	baseURL := resolveBTNLoginBaseURL(entry)
+	username := strings.TrimSpace(entry.Username)
+	password := strings.TrimSpace(entry.Password)
+	if username == "" || password == "" {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims login skipped; missing username or password")
+		}
+		return nil
+	}
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims login attempting with configured credentials")
+	}
+
+	values := map[string]string{
+		"username":   username,
+		"password":   password,
+		"keeplogged": "1",
+		"login":      "Log In!",
+	}
+	if code, err := resolveBTNClaims2FACode(strings.TrimSpace(entry.OTPURI)); err == nil && code != "" {
+		values["code"] = code
+	} else if err != nil && s.logger != nil {
+		s.logger.Warnf("metadata: BTN claims TOTP generation failed: %v", err)
+	}
+	encoded := encodeForm(values)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, "/")+btnClaimsLoginPath, strings.NewReader(encoded))
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims login request build failed: %v", err)
+		}
+		return fmt.Errorf("metadata: build BTN claims login request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "upbrr")
+	resp, err := client.Do(req)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims login request failed: %v", err)
+		}
+		return fmt.Errorf("metadata: execute BTN claims login request: %w", err)
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 400 {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims login returned status=%d", resp.StatusCode)
+		}
+		return fmt.Errorf("login status %d", resp.StatusCode)
+	}
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims login returned status=%d", resp.StatusCode)
+	}
+	if valid, err := s.btnClaimsSessionValid(ctx, client); err != nil {
+		if s.logger != nil {
+			s.logger.Warnf("metadata: BTN claims post-login validation failed: %v", err)
+		}
+		return err
+	} else if !valid {
+		return errors.New("BTN login failed to establish a valid session")
+	}
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims login established a valid session; leaving cookie file unchanged")
+	}
+	return nil
+}
+
+func resolveBTNLoginBaseURL(entry config.TrackerConfig) string {
+	if baseURL := sanitizeBTNWebBaseURL(entry.AnnounceURL); baseURL != "" {
+		return baseURL
+	}
+	if baseURL := sanitizeBTNWebBaseURL(entry.MyAnnounceURL); baseURL != "" {
+		return baseURL
+	}
+
+	return btnSiteBaseURL
+}
+
+func (s *claimChecker) loadBTNCookiesForClaims(ctx context.Context, client *http.Client) error {
+	if client == nil || client.Jar == nil {
+		return nil
+	}
+
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "BTN", "")
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Debugf("metadata: BTN claims cookie load skipped: %v", err)
+		}
+		return nil
+	}
+
+	if err := setBTNJarCookiesFromNetscape(client, btnSiteBaseURL, trackerCookies); err != nil {
+		return err
+	}
+	if err := setBTNJarCookiesFromNetscape(client, btnBackupBaseURL, trackerCookies); err != nil {
+		return err
+	}
+
+	if s.logger != nil {
+		s.logger.Debugf("metadata: BTN claims loaded %d cookies from shared store", len(trackerCookies))
+	}
+	return nil
+}
+
+func setBTNJarCookiesFromNetscape(client *http.Client, rawURL string, values []*http.Cookie) error {
+	if client == nil || client.Jar == nil || len(values) == 0 {
+		return nil
+	}
+
+	parsed, err := url.Parse(rawURL)
+	if err != nil {
+		return fmt.Errorf("metadata: parse BTN cookie URL: %w", err)
+	}
+
+	jarCookies := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		copied := *cookie // #nosec G124 -- Outbound tracker jar cookie mirrors imported BTN cookie attributes.
+		copied.Domain = parsed.Hostname()
+		if strings.TrimSpace(copied.Path) == "" {
+			copied.Path = "/"
+		}
+		// #nosec G124 -- Outbound tracker jar cookie mirrors imported BTN cookie attributes.
+		jarCookies = append(jarCookies, &copied)
+	}
+	if len(jarCookies) == 0 {
+		return nil
+	}
+
+	client.Jar.SetCookies(parsed, jarCookies)
+	return nil
+}
+
+func (s *claimChecker) btnClaimsSessionValid(ctx context.Context, client *http.Client) (bool, error) {
+	if client == nil {
+		return false, nil
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, btnSiteBaseURL+btnUserPath, nil)
+	if err != nil {
+		return false, fmt.Errorf("metadata: build BTN claims session validation request: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return false, fmt.Errorf("metadata: execute BTN claims session validation request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	if strings.Contains(strings.ToLower(finalURL), strings.ToLower(btnClaimsLoginPath)) {
+		return false, nil
+	}
+	return resp.StatusCode >= 200 && resp.StatusCode < 400, nil
+}
+
+func resolveBTNClaims2FACode(otpURI string) (string, error) {
+	trimmed := strings.TrimSpace(otpURI)
+	if trimmed == "" {
+		return "", errors.New("otp_uri not configured")
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", fmt.Errorf("metadata: parse BTN claims otp_uri: %w", err)
+	}
+	secret := strings.TrimSpace(parsed.Query().Get("secret"))
+	if secret == "" {
+		return "", errors.New("otp_uri missing secret")
+	}
+	period := 30
+	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
+		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
+			period = parsedValue
+		}
+	}
+	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
+	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
+	if err != nil {
+		return "", fmt.Errorf("metadata: decode BTN otp secret: %w", err)
+	}
+	counterTime := time.Now().Unix() / int64(period)
+	if counterTime < 0 {
+		return "", errors.New("totp counter before unix epoch")
+	}
+	counter := uint64(counterTime)
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, counter)
+	mac := hmac.New(sha1.New, secretBytes)
+	_, _ = mac.Write(buf)
+	hash := mac.Sum(nil)
+	offset := hash[len(hash)-1] & 0x0f
+	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
+	return fmt.Sprintf("%06d", code%1000000), nil
+}
+
+func sanitizeBTNWebBaseURL(raw string) string {
+	trimmed := strings.TrimSpace(raw)
+	if trimmed == "" {
+		return ""
+	}
+
+	parsed, err := url.Parse(trimmed)
+	if err != nil || parsed.Host == "" {
+		return ""
+	}
+	if parsed.Scheme == "" {
+		parsed.Scheme = "https"
+	}
+
+	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
+	switch host {
+	case "", "landof.tv":
+		return ""
+	case "broadcasthe.net", "www.broadcasthe.net":
+		host = "broadcasthe.net"
+	default:
+		return ""
+	}
+
+	lowerPath := strings.ToLower(strings.TrimSpace(parsed.Path))
+	if lowerPath != "" && lowerPath != "/" {
+		return ""
+	}
+
+	parsed.Host = host
+	parsed.Path = ""
+	parsed.RawPath = ""
+	parsed.RawQuery = ""
+	parsed.Fragment = ""
+	return strings.TrimRight(parsed.String(), "/")
+}
+
+func extractBTNClaimedShows(rawHTML string) map[string]struct{} {
+	scopedHTML := extractBTNClaimedPostHTML(rawHTML)
+	normalized := btnLineBreakPattern.ReplaceAllString(scopedHTML, "\n")
+	normalized = btnTagPattern.ReplaceAllString(normalized, "")
+	normalized = html.UnescapeString(normalized)
+
+	lines := strings.Split(normalized, "\n")
+	inCurrentShows := false
+	out := make(map[string]struct{})
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			continue
+		}
+		lower := strings.ToLower(trimmed)
+		if strings.Contains(lower, "current shows:") {
+			inCurrentShows = true
+			continue
+		}
+		if !inCurrentShows {
+			continue
+		}
+		if strings.Contains(lower, "upcoming shows:") || strings.Contains(lower, "available shows:") {
+			break
+		}
+		if !strings.Contains(trimmed, "--") || !strings.Contains(strings.ToUpper(trimmed), "BTN") {
+			continue
+		}
+		title := strings.TrimSpace(strings.SplitN(trimmed, "--", 2)[0])
+		if strings.EqualFold(title, "show") || title == "" {
+			continue
+		}
+		for variant := range btnTitleVariants(title) {
+			out[variant] = struct{}{}
+		}
+	}
+	return out
+}
+
+func extractBTNClaimedPostHTML(rawHTML string) string {
+	if strings.TrimSpace(rawHTML) == "" {
+		return rawHTML
+	}
+
+	doc, err := htmlnode.Parse(strings.NewReader(rawHTML))
+	if err != nil {
+		return rawHTML
+	}
+
+	scope := findBTNHTMLNode(doc, func(node *htmlnode.Node) bool {
+		return node.Type == htmlnode.ElementNode && node.Data == "table" && btnHTMLNodeID(node) == btnClaimedShowsPostID
+	})
+	if scope == nil {
+		return rawHTML
+	}
+
+	content := findBTNHTMLNode(scope, func(node *htmlnode.Node) bool {
+		if node.Type != htmlnode.ElementNode || node.Data != "div" {
+			return false
+		}
+		if btnHTMLNodeID(node) == "content1405482" {
+			return true
+		}
+		return btnHTMLNodeHasClass(node, "postcontent")
+	})
+	if content != nil {
+		if rendered := renderBTNHTMLChildren(content); rendered != "" {
+			return rendered
+		}
+	}
+
+	if rendered := renderBTNHTMLChildren(scope); rendered != "" {
+		return rendered
+	}
+
+	return rawHTML
+}
+
+func findBTNHTMLNode(root *htmlnode.Node, match func(*htmlnode.Node) bool) *htmlnode.Node {
+	if root == nil {
+		return nil
+	}
+	if match(root) {
+		return root
+	}
+	for child := root.FirstChild; child != nil; child = child.NextSibling {
+		if found := findBTNHTMLNode(child, match); found != nil {
+			return found
+		}
+	}
+	return nil
+}
+
+func btnHTMLNodeID(node *htmlnode.Node) string {
+	return strings.TrimSpace(btnHTMLAttr(node, "id"))
+}
+
+func btnHTMLNodeHasClass(node *htmlnode.Node, className string) bool {
+	classes := strings.FieldsSeq(strings.TrimSpace(btnHTMLAttr(node, "class")))
+	for candidate := range classes {
+		if strings.EqualFold(candidate, className) {
+			return true
+		}
+	}
+	return false
+}
+
+func btnHTMLAttr(node *htmlnode.Node, key string) string {
+	if node == nil {
+		return ""
+	}
+	for _, attr := range node.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return attr.Val
+		}
+	}
+	return ""
+}
+
+func renderBTNHTMLChildren(node *htmlnode.Node) string {
+	if node == nil {
+		return ""
+	}
+	var buf bytes.Buffer
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		if err := htmlnode.Render(&buf, child); err != nil {
+			return ""
+		}
+	}
+	return buf.String()
+}
+
+func matchBTNClaimedTitle(meta api.UploadSubject, claimed map[string]struct{}) (bool, string) {
+	for candidate := range btnCandidateTitles(meta) {
+		if _, ok := claimed[candidate]; ok {
+			return true, candidate
+		}
+	}
+	return false, ""
+}
+
+func btnCandidateTitles(meta api.UploadSubject) map[string]struct{} {
+	candidates := []string{
+		meta.ReleaseName,
+		meta.ReleaseNameNoTag,
+		meta.Filename,
+		pathutil.Base(meta.SourcePath),
+	}
+	if meta.ProviderMetadata.TVDB != nil {
+		candidates = append(candidates, meta.ProviderMetadata.TVDB.Name, meta.ProviderMetadata.TVDB.NameEnglish)
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		candidates = append(candidates, meta.ProviderMetadata.TMDB.Title, meta.ProviderMetadata.TMDB.OriginalTitle)
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		candidates = append(candidates, meta.ProviderMetadata.TVmaze.Name)
+	}
+
+	out := make(map[string]struct{})
+	for _, title := range candidates {
+		trimmed := strings.TrimSpace(title)
+		if trimmed == "" {
+			continue
+		}
+		for variant := range btnTitleVariants(trimmed) {
+			out[variant] = struct{}{}
+		}
+		derived := btnDeriveShowTitleFromRelease(trimmed)
+		for variant := range btnTitleVariants(derived) {
+			out[variant] = struct{}{}
+		}
+	}
+	return out
+}
+
+func btnDeriveShowTitleFromRelease(value string) string {
+	candidate := strings.ReplaceAll(value, ".", " ")
+	candidate = strings.ReplaceAll(candidate, "_", " ")
+	candidate = strings.TrimSpace(candidate)
+	if candidate == "" {
+		return ""
+	}
+	cutAt := len(candidate)
+	for _, pattern := range []*regexp.Regexp{btnSxxExxCutPattern, btnSeasonCutPattern, btnDateCutPattern} {
+		if match := pattern.FindStringIndex(candidate); match != nil && match[0] < cutAt {
+			cutAt = match[0]
+		}
+	}
+	return strings.TrimSpace(candidate[:cutAt])
+}
+
+func btnTitleVariants(value string) map[string]struct{} {
+	canonical, aliases := extractAKAAliases(value)
+	out := make(map[string]struct{})
+	for _, candidate := range append([]string{canonical}, aliases...) {
+		if normalized := normalizeBTNTitle(candidate); normalized != "" {
+			out[normalized] = struct{}{}
+		}
+	}
+	return out
+}
+
+func extractAKAAliases(value string) (string, []string) {
+	cleaned := strings.TrimSpace(value)
+	if cleaned == "" {
+		return "", nil
+	}
+	match := btnAKAExtractPattern.FindStringSubmatch(cleaned)
+	if len(match) < 2 {
+		return cleaned, nil
+	}
+	aliases := make([]string, 0)
+	for _, part := range strings.FieldsFunc(match[1], func(r rune) bool {
+		switch r {
+		case ',', '/', ';':
+			return true
+		default:
+			return false
+		}
+	}) {
+		if alias := strings.TrimSpace(part); alias != "" {
+			aliases = append(aliases, alias)
+		}
+	}
+	cleaned = strings.TrimSpace(btnAKAExtractPattern.ReplaceAllString(cleaned, ""))
+	return cleaned, aliases
+}
+
+func normalizeBTNTitle(value string) string {
+	cleaned := strings.TrimSpace(value)
+	if cleaned == "" {
+		return ""
+	}
+	cleaned = html.UnescapeString(cleaned)
+	cleaned = strings.ReplaceAll(cleaned, "\u2018", "'")
+	cleaned = strings.ReplaceAll(cleaned, "\u2019", "'")
+	cleaned = strings.ReplaceAll(cleaned, "\u0060", "'")
+	cleaned = strings.ReplaceAll(cleaned, "&", " and ")
+	cleaned = strings.ToLower(cleaned)
+	cleaned = btnNonAlnumPattern.ReplaceAllString(cleaned, " ")
+	cleaned = btnSpacePattern.ReplaceAllString(cleaned, " ")
+	return strings.TrimSpace(cleaned)
+}
+
+func btnClaimWindowExpired(meta api.UploadSubject, graceHours int) (bool, int, float64) {
+	airedDate := strings.TrimSpace(meta.TVDBAiredDate)
+	thresholdHours := btnClaimWindowBaseHours + graceHours
+	if airedDate == "" {
+		return false, thresholdHours, 0
+	}
+	airedDateValue, err := time.Parse("2006-01-02", airedDate)
+	if err != nil {
+		return false, thresholdHours, 0
+	}
+
+	airsTime, hasTime := parseBTNTime(strings.TrimSpace(meta.TVDBAirsTime))
+	graceHoursUsed := graceHours
+	location := time.UTC
+	if hasTime {
+		graceHoursUsed = 0
+		if tz := strings.TrimSpace(meta.TVDBAirsTimezone); tz != "" {
+			if loaded, err := time.LoadLocation(tz); err == nil {
+				location = loaded
+			} else {
+				location = time.Now().Location()
+			}
+		} else {
+			location = time.Now().Location()
+		}
+	}
+	thresholdHours = btnClaimWindowBaseHours + graceHoursUsed
+
+	var airedAt time.Time
+	if hasTime {
+		airedAt = time.Date(
+			airedDateValue.Year(),
+			airedDateValue.Month(),
+			airedDateValue.Day(),
+			airsTime.Hour(),
+			airsTime.Minute(),
+			airsTime.Second(),
+			0,
+			location,
+		)
+	} else {
+		airedAt = time.Date(airedDateValue.Year(), airedDateValue.Month(), airedDateValue.Day(), 0, 0, 0, 0, time.UTC)
+	}
+
+	hoursSinceAir := time.Since(airedAt.UTC()).Hours()
+	return hoursSinceAir > float64(thresholdHours), thresholdHours, hoursSinceAir
+}
+
+func btnClaimFailureReason(meta api.UploadSubject, graceHours int) string {
+	expired, thresholdHours, hoursSinceAir := btnClaimWindowExpired(meta, graceHours)
+	if expired {
+		return "BTN claim window has expired"
+	}
+	if thresholdHours <= 0 {
+		return "BTN has an active claim for this release"
+	}
+	if hoursSinceAir <= 0 {
+		return fmt.Sprintf("BTN has an active claim for this release; up to %d hours remain in the claim window", thresholdHours)
+	}
+	hoursRemaining := max(int(float64(thresholdHours)-hoursSinceAir+0.999999999), 1)
+	return fmt.Sprintf("BTN has an active claim for this release; approximately %d hours remain in the %d-hour claim window", hoursRemaining, thresholdHours)
+}
+
+func parseBTNTime(value string) (time.Time, bool) {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return time.Time{}, false
+	}
+	if match := btnTime24Pattern.FindStringSubmatch(trimmed); len(match) == 4 {
+		hour, _ := strconv.Atoi(match[1])
+		minute, _ := strconv.Atoi(match[2])
+		second := 0
+		if match[3] != "" {
+			second, _ = strconv.Atoi(match[3])
+		}
+		if hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59 {
+			return time.Date(2000, 1, 1, hour, minute, second, 0, time.UTC), true
+		}
+	}
+	if match := btnTime12Pattern.FindStringSubmatch(trimmed); len(match) == 4 {
+		hour, _ := strconv.Atoi(match[1])
+		minute, _ := strconv.Atoi(match[2])
+		if hour >= 1 && hour <= 12 && minute >= 0 && minute <= 59 {
+			hour %= 12
+			if strings.EqualFold(match[3], "pm") {
+				hour += 12
+			}
+			return time.Date(2000, 1, 1, hour, minute, 0, 0, time.UTC), true
+		}
+	}
+	return time.Time{}, false
+}
+
+func readBTNClaimedCache(path string) (map[string]struct{}, int64, error) {
+	payload, err := os.ReadFile(path)
+	if err != nil {
+		return nil, 0, fmt.Errorf("metadata: read BTN claimed cache: %w", err)
+	}
+	var cache btnClaimedShowsCache
+	if err := json.Unmarshal(payload, &cache); err != nil {
+		return nil, 0, fmt.Errorf("metadata: unmarshal BTN claimed cache: %w", err)
+	}
+	titles := make(map[string]struct{}, len(cache.Titles))
+	for _, title := range cache.Titles {
+		if normalized := normalizeBTNTitle(title); normalized != "" {
+			titles[normalized] = struct{}{}
+		}
+	}
+	return titles, cache.FetchedAt, nil
+}
+
+func writeBTNClaimedCache(path string, titles map[string]struct{}) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return fmt.Errorf("metadata: create BTN claimed cache dir: %w", err)
+	}
+	serializedTitles := make([]string, 0, len(titles))
+	for title := range titles {
+		serializedTitles = append(serializedTitles, title)
+	}
+	sort.Strings(serializedTitles)
+	cache := btnClaimedShowsCache{
+		FetchedAt: time.Now().Unix(),
+		SourceURL: btnClaimedShowsURL,
+		PostID:    btnClaimedShowsPostID,
+		Titles:    serializedTitles,
+	}
+	encoded, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return fmt.Errorf("metadata: marshal BTN claimed cache: %w", err)
+	}
+	if err := os.WriteFile(path, encoded, 0o600); err != nil {
+		return fmt.Errorf("metadata: write BTN claimed cache: %w", err)
+	}
+	return nil
+}
+
+func parseOptionalInt(value any) int {
+	switch typed := value.(type) {
+	case int:
+		return typed
+	case int64:
+		return int(typed)
+	case float64:
+		return int(typed)
+	case string:
+		parsed, err := strconv.Atoi(strings.TrimSpace(typed))
+		if err == nil {
+			return parsed
+		}
+	}
+	return 0
+}
+
+func mirrorBTNCookiesForClaimedThread(client *http.Client) {
+	if client == nil || client.Jar == nil {
+		return
+	}
+
+	backupURL, backupErr := url.Parse("https://backup.landof.tv/")
+	broadcastURL, broadcastErr := url.Parse("https://broadcasthe.net/")
+	if backupErr != nil || broadcastErr != nil {
+		return
+	}
+
+	backupCookies := client.Jar.Cookies(backupURL)
+	if len(backupCookies) == 0 {
+		return
+	}
+
+	mirrored := make([]*http.Cookie, 0, len(backupCookies)*2)
+	for _, cookie := range backupCookies {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
+			continue
+		}
+		copied := *cookie // #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
+		copied.Domain = "broadcasthe.net"
+		if copied.Path == "" {
+			copied.Path = "/"
+		}
+		// #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
+		mirrored = append(mirrored, &copied)
+
+		dotted := copied // #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
+		dotted.Domain = ".broadcasthe.net"
+		// #nosec G124 -- Outbound tracker jar cookie mirrors backup BTN session attributes.
+		mirrored = append(mirrored, &dotted)
+	}
+	if len(mirrored) == 0 {
+		return
+	}
+	client.Jar.SetCookies(broadcastURL, mirrored)
+}
+
+// FailureReason describes an active BTN claim using the configured grace
+// period and the remaining or expired claim-window state.
+func (s *claimChecker) FailureReason(meta api.UploadSubject) string {
+	return btnClaimFailureReason(meta, s.btnClaimWindowGraceHours())
+}
+
+func btnClaimsPath(dbPath string) (string, error) {
+	path, err := db.FileInSubdir(dbPath, "cache", filepath.Join("banned", "BTN_claimed_releases.json"))
+	if err != nil {
+		return "", fmt.Errorf("metadata: resolve tracker claims path: %w", err)
+	}
+	return path, nil
+}
+
+func trackerConfigFor(cfg config.Config, tracker string) (config.TrackerConfig, bool) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), strings.TrimSpace(tracker)) {
+			return entry, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+
+func btnIsTVCategory(meta api.UploadSubject) bool {
+	return meta.SeasonInt > 0 || meta.EpisodeInt > 0 || meta.Release.Season > 0 || meta.Release.Episode > 0 ||
+		meta.TVPack || strings.TrimSpace(meta.DailyEpisodeDate) != ""
+}
+
+// NormalizeClaimTitle exposes BTN's claim-title normalization for contract tests.
+func NormalizeClaimTitle(value string) string { return normalizeBTNTitle(value) }
+
+// ExtractClaimedShows exposes BTN's claimed-thread parser for contract tests.
+func ExtractClaimedShows(value string) map[string]struct{} { return extractBTNClaimedShows(value) }
+
+// MirrorCookiesForClaimedThread exposes BTN's backup-domain mirroring behavior for contract tests.
+func MirrorCookiesForClaimedThread(client *http.Client) { mirrorBTNCookiesForClaimedThread(client) }
+
+// ClaimWindowExpired exposes BTN's claim-window calculation for contract tests.
+func ClaimWindowExpired(meta api.UploadSubject, graceHours int) (bool, int, float64) {
+	return btnClaimWindowExpired(meta, graceHours)
+}
+
+// LoadClaimedTitles exposes BTN cache/fetch behavior for contract tests.
+func LoadClaimedTitles(ctx context.Context, cfg config.Config, logger api.Logger, cachePath string, cacheTTL time.Duration) (map[string]struct{}, error) {
+	return (&claimChecker{cfg: cfg, logger: logger}).loadBTNClaimedTitles(ctx, cachePath, cacheTTL)
+}
+
+// FetchClaimedTitles exposes BTN remote claim retrieval for contract tests.
+func FetchClaimedTitles(ctx context.Context, cfg config.Config, logger api.Logger) (map[string]struct{}, error) {
+	return (&claimChecker{cfg: cfg, logger: logger}).fetchBTNClaimedTitles(ctx)
+}
+
+func encodeForm(values map[string]string) string {
+	encoded := url.Values{}
+	for key, value := range values {
+		encoded.Set(key, value)
+	}
+	return encoded.Encode()
+}
+
+func ioReadAllLimit(resp *http.Response, maxBytes int64) ([]byte, error) {
+	if resp == nil || resp.Body == nil {
+		return nil, errors.New("nil response body")
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBytes))
+	if err != nil {
+		return nil, fmt.Errorf("read limited response body: %w", err)
+	}
+	return body, nil
+}
diff --git a/internal/trackers/impl/standalone/btn/data.go b/internal/trackers/impl/standalone/btn/data.go
new file mode 100644
index 00000000..5ed09f50
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/data.go
@@ -0,0 +1,105 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dataLookup struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDataLookup returns a BTN JSON-RPC lookup bound to cfg and httpClient.
+func (d *Definition) NewDataLookup(cfg config.Config, httpClient *http.Client, _ api.Logger) trackers.DataLookup {
+	return &dataLookup{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://api.broadcasthe.net/",
+	}
+}
+
+// Lookup resolves IMDb and TVDB identifiers for a BTN torrent ID. Missing or
+// short API tokens, missing tracker IDs, non-success responses, API errors, and
+// empty torrent results produce an empty result without an error.
+func (l *dataLookup) Lookup(ctx context.Context, req trackers.DataLookupRequest) (trackers.DataLookupResult, error) {
+	token := strings.TrimSpace(config.ResolveBTNAPIToken(l.cfg))
+	trackerID := strings.TrimSpace(req.TrackerID)
+	if len(token) < 25 || trackerID == "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	payload := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      "ua-go",
+		"method":  "getTorrentsSearch",
+		"params":  []any{token, map[string]any{"id": trackerID}, 50},
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: btn encode request: %w", err)
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, l.endpoint, bytes.NewReader(body))
+	if err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: btn request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	resp, err := l.http.Do(httpReq)
+	if err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: btn request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return trackers.DataLookupResult{}, nil
+	}
+	var decoded struct {
+		Error  map[string]any `json:"error"`
+		Result struct {
+			Torrents map[string]map[string]any `json:"torrents"`
+		} `json:"result"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
+		return trackers.DataLookupResult{}, fmt.Errorf("trackerdata: btn decode: %w", err)
+	}
+	if len(decoded.Error) > 0 {
+		return trackers.DataLookupResult{}, nil
+	}
+	for _, value := range decoded.Result.Torrents {
+		return trackers.DataLookupResult{
+			TrackerID: trackerID,
+			IMDBID:    int(btnInt(value["ImdbID"])),
+			TVDBID:    int(btnInt(value["TvdbID"])),
+		}, nil
+	}
+	return trackers.DataLookupResult{}, nil
+}
+
+func btnInt(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case int:
+		return int64(typed)
+	case int64:
+		return typed
+	case string:
+		parsed, _ := json.Number(strings.TrimSpace(typed)).Int64()
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/btn/data_test.go b/internal/trackers/impl/standalone/btn/data_test.go
new file mode 100644
index 00000000..581f72a3
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/data_test.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func TestDataLookup(t *testing.T) {
+	t.Parallel()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/btn" {
+			http.NotFound(w, r)
+			return
+		}
+		_ = json.NewEncoder(w).Encode(map[string]any{"result": map[string]any{"torrents": map[string]any{"1": map[string]any{"ImdbID": 1234567, "TvdbID": 76543}}}})
+	}))
+	defer server.Close()
+	token := strings.Repeat("a", 30)
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"BTN": {APIKey: token}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected BTN data lookup")
+	}
+	lookup.endpoint = server.URL + "/btn"
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{TrackerID: "42", OnlyID: true})
+	if err != nil {
+		t.Fatalf("lookup: %v", err)
+	}
+	if result.IMDBID != 1234567 || result.TVDBID != 76543 {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+}
diff --git a/internal/trackers/impl/standalone/btn/definition.go b/internal/trackers/impl/standalone/btn/definition.go
new file mode 100644
index 00000000..740c3c2b
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/definition.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// DataLookupConfigured reports whether the BTN API token is available.
+func (d *Definition) DataLookupConfigured(cfg config.Config) bool {
+	return len(config.ResolveBTNAPIToken(cfg)) >= 25
+}
+
+func bannedGroups() []string {
+	return []string{
+		"3LTON", "4yEo", "7VFr33104D", "AFG", "AniHLS", "AnimeRG", "AniURL", "DeadFish", "ELiTE", "eSc",
+		"EVO", "FGT", "FUM", "GalaxyTV", "GRANiTEN", "HAiKU", "Hi10", "ION10", "JFF", "JIVE", "LOAD", "MeGusta",
+		"mSD", "NhaNc3", "NOIVTC", "PHOENiX", "PlaySD", "playXD", "Pr1M371M3", "RAPiDCOWS", "REsuRRecTioN", "RMTeam",
+		"ROBOTS", "RUBiK", "SPASM", "Telly", "TM", "URANiME", "ViSiON", "W45Ps", "xRed", "XS", "ZKBL", "ZmN", "ZMNT", "[Oj]",
+	}
+}
+
+func validateBTNRequest(req trackers.PreparationInput) error {
+	category, err := req.Meta.Identity.RequireCategory()
+	if err != nil || category != api.CanonicalCategoryTV {
+		return errors.New("trackers: BTN only supports TV uploads")
+	}
+	if strings.TrimSpace(req.Runtime.BTNAPIToken) == "" {
+		return errors.New("trackers: BTN requires trackers.BTN.api_key")
+	}
+	return nil
+}
+
+var btnInternalGroups = []string{
+	"BTW",
+	"ESPNtb",
+	"HiSD",
+	"HRiP",
+	"iPRiP",
+	"iT00NZ",
+	"JJ",
+	"LoTV",
+	"NTb",
+	"PreBS",
+	"RAWR",
+	"TTVa",
+	"TVSmash",
+}
+
+func isBTNInternalGroup(meta api.UploadSubject) bool {
+	if strings.TrimSpace(meta.Tag) == "" {
+		return false
+	}
+
+	group := strings.ToLower(strings.TrimPrefix(meta.Tag, "-"))
+	for _, value := range btnInternalGroups {
+		if strings.ToLower(value) == group {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/trackers/impl/standalone/btn/definition_test.go b/internal/trackers/impl/standalone/btn/definition_test.go
new file mode 100644
index 00000000..5409790d
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/definition_test.go
@@ -0,0 +1,1003 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"bytes"
+	"context"
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDefinitionName(t *testing.T) {
+	t.Parallel()
+
+	def := New()
+	if def.Name() != "BTN" {
+		t.Fatalf("expected BTN, got %q", def.Name())
+	}
+}
+
+func TestApplyBTNNameMapping(t *testing.T) {
+	t.Parallel()
+
+	name := "Example.Show.S01E01.1080p.WEB-DL.x265-GRP"
+	mapped := applyBTNNameMapping(name, "H.265", "WEB-DL")
+	if mapped == "" {
+		t.Fatalf("expected mapped name")
+	}
+	if mapped != "Example.Show.S01E01.1080p.WEB-DL.H.265-GRP" {
+		t.Fatalf("unexpected mapped name: %s", mapped)
+	}
+}
+
+func TestCleanAndNormalizeBTNName(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "spaces become dots",
+			input:    "Example Show S01E01 1080p Web-DL DD+ 5.1 x265-GRP",
+			expected: "Example.Show.S01E01.1080p.Web-DL.DDP5.1.x265-GRP",
+		},
+		{
+			name:     "DDP Atmos compacts before generic DDP channel",
+			input:    "Some.Movie.2023.DDP.5.1.Atmos.x264",
+			expected: "Some.Movie.2023.DDPA5.1.x264",
+		},
+		{
+			name:     "duplicate dots collapse after DD channel",
+			input:    "Another.Show..S02E03.DD.2.0.x264",
+			expected: "Another.Show.S02E03.DD2.0.x264",
+		},
+		{
+			name:     "AC3 and DTS channel joins",
+			input:    "Test.AC3.5.1.and.DTS.5.1.Show",
+			expected: "Test.AC35.1.and.DTS5.1.Show",
+		},
+		{
+			name:     "TrueHD Atmos compacts before generic TrueHD channel",
+			input:    "Movie.TrueHD.7.1.Atmos.x264",
+			expected: "Movie.TrueHDA7.1.x264",
+		},
+		{
+			name:     "DDP channel joins",
+			input:    "Movie.DDP.5.1.x264",
+			expected: "Movie.DDP5.1.x264",
+		},
+		{
+			name:     "AAC channel joins",
+			input:    "Movie.AAC.2.0.x264",
+			expected: "Movie.AAC2.0.x264",
+		},
+		{
+			name:     "FLAC channel joins",
+			input:    "Movie.FLAC.2.0.x264",
+			expected: "Movie.FLAC2.0.x264",
+		},
+		{
+			name:     "TrueHD channel joins case-insensitively",
+			input:    "Movie.truehd.7.1.x264",
+			expected: "Movie.TrueHD7.1.x264",
+		},
+		{
+			name:     "PCM channel joins case-insensitively",
+			input:    "Movie.pcm.2.0.x264",
+			expected: "Movie.PCM2.0.x264",
+		},
+		{
+			name:     "LPCM channel joins case-insensitively",
+			input:    "Movie.lpcm.2.0.x264",
+			expected: "Movie.LPCM2.0.x264",
+		},
+		{
+			name:     "non-alphanumeric chars become dots",
+			input:    "Movie:Title[Cut].DDP.5.1-GRP",
+			expected: "Movie.Title.Cut.DDP5.1-GRP",
+		},
+		{
+			name:     "diacritics are removed",
+			input:    "Éxample Shōw S01E01",
+			expected: "Example.Show.S01E01",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := cleanAndNormalizeBTNName(tc.input)
+			if result != tc.expected {
+				t.Errorf("cleanAndNormalizeBTNName(%q) = %q; expected %q", tc.input, result, tc.expected)
+			}
+		})
+	}
+}
+
+func TestResolveUploadNameGroupTag(t *testing.T) {
+	tests := []struct {
+		name     string
+		meta     api.UploadSubject
+		expected string
+	}{
+		{
+			name: "Valid group tag in meta.Tag",
+			meta: api.UploadSubject{
+				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
+				Tag:         "GRP",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
+		},
+		{
+			name: "Valid group tag appended to ReleaseNameNoTag",
+			meta: api.UploadSubject{
+				ReleaseNameNoTag: "Example.Show.S01E01.1080p.Web-DL",
+				Tag:              "GRP",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL-GRP",
+		},
+		{
+			name: "Missing group tag",
+			meta: api.UploadSubject{
+				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265",
+				Tag:         "",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
+		},
+		{
+			name: "Missing parsed tag preserves existing release suffix",
+			meta: api.UploadSubject{
+				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
+				Tag:         "",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL.x265-GRP",
+		},
+		{
+			name: "Unknown group tag in meta.Tag",
+			meta: api.UploadSubject{
+				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265",
+				Tag:         "nogrp",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
+		},
+		{
+			name: "Existing unknown group tag in ReleaseName",
+			meta: api.UploadSubject{
+				ReleaseName: "Example.Show.S01E01.1080p.Web-DL.x265-unknown",
+				Tag:         "unknown",
+			},
+			expected: "Example.Show.S01E01.1080p.Web-DL.x265-NOGRP",
+		},
+		{
+			name: "Generated episode title absent from filename stripped",
+			meta: api.UploadSubject{
+				Filename:     "Example.Show.S01E01.1080p.WEB-DL.x265-GRP.mkv",
+				ReleaseName:  "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
+				EpisodeTitle: "Episode One",
+				Tag:          "GRP",
+			},
+			expected: "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
+		},
+		{
+			name: "Filename episode title preserved",
+			meta: api.UploadSubject{
+				Filename:     "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP.mkv",
+				ReleaseName:  "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
+				EpisodeTitle: "Episode One",
+				Tag:          "GRP",
+			},
+			expected: "Example.Show.S01E01.Episode.One.1080p.WEB-DL.x265-GRP",
+		},
+		{
+			name: "Episode title substring preserved",
+			meta: api.UploadSubject{
+				Filename:     "Example.Show.S01E01.1080p.WEB-DL.x265-GRP.mkv",
+				ReleaseName:  "Example.Show.S01E01.Someone.1080p.WEB-DL.x265-GRP",
+				EpisodeTitle: "One",
+				Tag:          "GRP",
+			},
+			expected: "Example.Show.S01E01.Someone.1080p.WEB-DL.x265-GRP",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := resolveUploadName(tc.meta)
+			if result != tc.expected {
+				t.Errorf("resolveUploadName() = %q; expected %q", result, tc.expected)
+			}
+		})
+	}
+}
+
+func TestResolveOrigin(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		meta     api.UploadSubject
+		expected string
+	}{
+		{
+			name:     "scene metadata",
+			meta:     api.UploadSubject{Scene: true},
+			expected: "Scene",
+		},
+		{
+			name:     "scene name metadata",
+			meta:     api.UploadSubject{SceneName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP"},
+			expected: "Scene",
+		},
+		{
+			name:     "non-scene metadata",
+			meta:     api.UploadSubject{ReleaseName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP"},
+			expected: "P2P",
+		},
+		{
+			name: "mixed season pack groups",
+			meta: api.UploadSubject{
+				TVPack: true,
+				FileList: []string{
+					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
+					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv`,
+				},
+			},
+			expected: "Mixed",
+		},
+		{
+			name: "same season pack groups",
+			meta: api.UploadSubject{
+				TVPack: true,
+				FileList: []string{
+					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
+					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-GRP.mkv`,
+				},
+			},
+			expected: "P2P",
+		},
+		{
+			name: "mixed file groups ignored outside season packs",
+			meta: api.UploadSubject{
+				FileList: []string{
+					`C:\media\Example.Show.S01E01.1080p.WEB-DL.x264-GRP.mkv`,
+					`C:\media\Example.Show.S01E02.1080p.WEB-DL.x264-ALT.mkv`,
+				},
+			},
+			expected: "P2P",
+		},
+		{
+			name: "none origin for no group tag",
+			meta: api.UploadSubject{
+				Release: api.ReleaseInfo{Group: "nogrp"},
+			},
+			expected: "None",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := resolveOrigin(tc.meta); got != tc.expected {
+				t.Fatalf("expected origin %q, got %q", tc.expected, got)
+			}
+		})
+	}
+}
+
+func TestResolveBTNUploadFilesSceneNFO(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	torrentPath := filepath.Join(dir, "upload.torrent")
+	if err := os.WriteFile(torrentPath, []byte("d8:announce13:https://x.ee"), 0o600); err != nil {
+		t.Fatalf("write torrent fixture: %v", err)
+	}
+	nfoPath := filepath.Join(dir, "scene.nfo")
+	if err := os.WriteFile(nfoPath, []byte("scene nfo"), 0o600); err != nil {
+		t.Fatalf("write nfo fixture: %v", err)
+	}
+
+	tests := []struct {
+		name       string
+		meta       api.UploadSubject
+		wantFields []string
+	}{
+		{
+			name:       "scene release attaches nfo",
+			meta:       api.UploadSubject{Scene: true, SceneNFOPath: nfoPath},
+			wantFields: []string{"file_input", "nfo"},
+		},
+		{
+			name:       "scene name attaches nfo",
+			meta:       api.UploadSubject{SceneName: "Example.Show.S01E01.1080p.WEB-DL.x264-GRP", SceneNFOPath: nfoPath},
+			wantFields: []string{"file_input", "nfo"},
+		},
+		{
+			name:       "non-scene ignores nfo path",
+			meta:       api.UploadSubject{SceneNFOPath: nfoPath},
+			wantFields: []string{"file_input"},
+		},
+		{
+			name:       "scene release skips missing nfo path",
+			meta:       api.UploadSubject{Scene: true, SceneNFOPath: filepath.Join(dir, "missing.nfo")},
+			wantFields: []string{"file_input"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			files := resolveBTNUploadFiles(tc.meta, torrentPath)
+			gotFields := make([]string, 0, len(files))
+			for _, file := range files {
+				gotFields = append(gotFields, file.FieldName)
+			}
+			if strings.Join(gotFields, ",") != strings.Join(tc.wantFields, ",") {
+				t.Fatalf("expected fields %#v, got %#v", tc.wantFields, gotFields)
+			}
+
+			dryRunFiles := resolveBTNDryRunFiles(tc.meta, torrentPath)
+			gotDryRunFields := make([]string, 0, len(dryRunFiles))
+			for _, file := range dryRunFiles {
+				gotDryRunFields = append(gotDryRunFields, file.Field)
+			}
+			if strings.Join(gotDryRunFields, ",") != strings.Join(tc.wantFields, ",") {
+				t.Fatalf("expected dry-run fields %#v, got %#v", tc.wantFields, gotDryRunFields)
+			}
+		})
+	}
+}
+
+func TestResolveCountryIDUsesExactAliases(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		meta     api.UploadSubject
+		expected string
+	}{
+		{
+			name: "TVDB alpha3 exact",
+			meta: api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+				TVDB: &api.TVDBMetadata{OriginalCountry: "usa"},
+			}},
+			expected: "2",
+		},
+		{
+			name: "TMDB alpha2 exact",
+			meta: api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{OriginCountry: []string{"GB"}},
+			}},
+			expected: "12",
+		},
+		{
+			name: "IMDB compound alias",
+			meta: api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+				IMDB: &api.IMDBMetadata{Country: "Trinidad and Tobago"},
+			}},
+			expected: "75",
+		},
+		{
+			name: "punctuation normalized exact alias",
+			meta: api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+				IMDB: &api.IMDBMetadata{Country: "Bosnia & Herzegovina"},
+			}},
+			expected: "64",
+		},
+		{
+			name: "ambiguous partial name rejected",
+			meta: api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+				IMDB: &api.IMDBMetadata{Country: "Korea"},
+			}},
+			expected: "",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := resolveCountryID(tc.meta); got != tc.expected {
+				t.Fatalf("expected country id %q, got %q", tc.expected, got)
+			}
+		})
+	}
+}
+
+func TestResolveCountryIDSupportsBTNCountryOptions(t *testing.T) {
+	t.Parallel()
+
+	countries := map[string]string{
+		"Afghanistan":                    "51",
+		"Albania":                        "62",
+		"Algeria":                        "32",
+		"Andorra":                        "65",
+		"Angola":                         "33",
+		"Antigua Barbuda":                "86",
+		"Arab League":                    "107",
+		"Argentina":                      "19",
+		"Australia":                      "20",
+		"Austria":                        "34",
+		"Bahamas":                        "79",
+		"Bangladesh":                     "83",
+		"Barbados":                       "82",
+		"Belgium":                        "16",
+		"Belize":                         "31",
+		"Bosnia Herzegovina":             "64",
+		"Brazil":                         "18",
+		"Brunei":                         "113",
+		"Bulgaria":                       "100",
+		"Burkina Faso":                   "57",
+		"Cambodia":                       "81",
+		"Canada":                         "5",
+		"Chile":                          "48",
+		"China":                          "8",
+		"Colombia":                       "95",
+		"Congo":                          "50",
+		"Costa Rica":                     "98",
+		"Croatia":                        "93",
+		"Cuba":                           "49",
+		"Czech Republic":                 "43",
+		"Denmark":                        "10",
+		"Dominican Republic":             "38",
+		"Ecuador":                        "78",
+		"Egypt":                          "99",
+		"Estonia":                        "94",
+		"Fiji":                           "102",
+		"Finland":                        "4",
+		"France":                         "6",
+		"Germany":                        "7",
+		"Greece":                         "39",
+		"Guatemala":                      "40",
+		"Honduras":                       "76",
+		"Hong Kong":                      "30",
+		"Hungary":                        "71",
+		"Iceland":                        "59",
+		"India":                          "67",
+		"Indonesia":                      "111",
+		"Iran":                           "106",
+		"Ireland":                        "13",
+		"Isle de Muerte":                 "101",
+		"Israel":                         "41",
+		"Italy":                          "9",
+		"Jamaica":                        "28",
+		"Japan":                          "17",
+		"Kiribati":                       "55",
+		"Kuwait":                         "104",
+		"Kyrgyzstan":                     "77",
+		"Laos":                           "84",
+		"Latvia":                         "97",
+		"Lebanon":                        "96",
+		"Lithuania":                      "66",
+		"Luxembourg":                     "29",
+		"Macedonia":                      "103",
+		"Malaysia":                       "37",
+		"Mexico":                         "24",
+		"Nauru":                          "60",
+		"Netherlands":                    "15",
+		"Netherlands Antilles":           "68",
+		"New Zealand":                    "21",
+		"Nigeria":                        "58",
+		"North Korea":                    "92",
+		"Norway":                         "11",
+		"Pakistan":                       "42",
+		"Paraguay":                       "87",
+		"Peru":                           "80",
+		"Philippines":                    "56",
+		"Poland":                         "14",
+		"Portugal":                       "23",
+		"Puerto Rico":                    "47",
+		"Romania":                        "72",
+		"Russia":                         "3",
+		"Saudi Arabia":                   "108",
+		"Scotland":                       "109",
+		"Senegal":                        "90",
+		"Serbia":                         "44",
+		"Seychelles":                     "45",
+		"Singapore":                      "25",
+		"Slovakia":                       "110",
+		"Slovenia":                       "61",
+		"South Africa":                   "26",
+		"South Korea":                    "27",
+		"Spain":                          "22",
+		"Sri Lanka":                      "105",
+		"Sweden":                         "1",
+		"Switzerland":                    "54",
+		"Taiwan":                         "46",
+		"Thailand":                       "89",
+		"Togo":                           "91",
+		"Trinidad & Tobago":              "75",
+		"Turkey":                         "52",
+		"Turkmenistan":                   "63",
+		"Ukraine":                        "69",
+		"Union of Soviet Socialist Repu": "88",
+		"United Kingdom":                 "12",
+		"United States of America":       "2",
+		"Uruguay":                        "85",
+		"Uzbekistan":                     "53",
+		"Vanuatu":                        "73",
+		"Venezuela":                      "70",
+		"Vietnam":                        "74",
+		"Wales":                          "112",
+		"Western Samoa":                  "36",
+		"Yugoslavia":                     "35",
+	}
+
+	for name, expected := range countries {
+		meta := api.UploadSubject{ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Country: name},
+		}}
+		if got := resolveCountryID(meta); got != expected {
+			t.Fatalf("expected BTN country %q to resolve to %q, got %q", name, expected, got)
+		}
+	}
+}
+
+func TestValidateBTNAPIDownloadURLAllowsOnlySameOriginPrivateFallback(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	if err := validateBTNAPIDownloadURL(ctx, "http://127.0.0.1:1/rpc", "http://127.0.0.1:1/mock-download"); err != nil {
+		t.Fatalf("expected same-origin private download URL to be allowed: %v", err)
+	}
+	if err := validateBTNAPIDownloadURL(ctx, "http://127.0.0.1:1/rpc", "http://127.0.0.1:2/mock-download"); err == nil {
+		t.Fatalf("expected cross-origin private download URL to be rejected")
+	}
+	if err := validateBTNAPIDownloadURL(ctx, "ftp://127.0.0.1/rpc", "ftp://127.0.0.1/mock-download"); err == nil {
+		t.Fatalf("expected unsupported same-origin scheme to be rejected")
+	}
+}
+
+func TestBTNAPIDownloadOriginRejectsSameHostPrivateRebind(t *testing.T) {
+	ctx := context.Background()
+	lookupCalls := 0
+	lookup := func(context.Context, string) ([]net.IPAddr, error) {
+		lookupCalls++
+		if lookupCalls == 1 {
+			return []net.IPAddr{{IP: net.IPv4(93, 184, 216, 34)}}, nil
+		}
+		return []net.IPAddr{{IP: net.IPv4(10, 0, 0, 7)}}, nil
+	}
+
+	origin, err := newBTNAPIDownloadOriginWithLookup(ctx, "https://api.example.test/rpc", lookup)
+	if err != nil {
+		t.Fatalf("pin BTN API origin: %v", err)
+	}
+	if err := origin.validateDownloadURL(ctx, "https://api.example.test/download"); err == nil {
+		t.Fatalf("expected same-host private rebind to be rejected")
+	}
+}
+
+func TestBTNDropdownMappingsPreferMetadataThenAutofill(t *testing.T) {
+	t.Parallel()
+
+	autofillFields := map[string]string{
+		"format":     "MP4",
+		"bitrate":    "H.264",
+		"media":      "HDTV",
+		"resolution": "2160p",
+	}
+	metadata := api.UploadSubject{
+		Container:   "mkv",
+		VideoEncode: "x265",
+		Source:      "WEB-DL",
+		Type:        "WEBDL",
+		Release:     api.ReleaseInfo{Resolution: "1080p"},
+	}
+	if got := mapContainer(metadata, autofillFields); got != "MKV" {
+		t.Fatalf("expected metadata format, got %q", got)
+	}
+	if got := mapCodec(metadata, autofillFields); got != "H.265" {
+		t.Fatalf("expected metadata bitrate, got %q", got)
+	}
+	if got := mapSource(metadata, autofillFields); got != "WEB-DL" {
+		t.Fatalf("expected metadata media, got %q", got)
+	}
+	if got := mapResolution(metadata, autofillFields); got != "1080p" {
+		t.Fatalf("expected metadata resolution, got %q", got)
+	}
+
+	invalidMetadata := api.UploadSubject{
+		Container:   "unknown-container",
+		VideoEncode: "unknown-codec",
+		Source:      "unknown-source",
+		Type:        "unknown-type",
+		Release:     api.ReleaseInfo{Resolution: "unknown-resolution"},
+	}
+	if got := mapContainer(invalidMetadata, autofillFields); got != "MP4" {
+		t.Fatalf("expected autofill format, got %q", got)
+	}
+	if got := mapCodec(invalidMetadata, autofillFields); got != "H.264" {
+		t.Fatalf("expected autofill bitrate, got %q", got)
+	}
+	if got := mapSource(invalidMetadata, autofillFields); got != "HDTV" {
+		t.Fatalf("expected autofill media, got %q", got)
+	}
+	if got := mapResolution(invalidMetadata, autofillFields); got != "2160p" {
+		t.Fatalf("expected autofill resolution, got %q", got)
+	}
+	if got := mapResolution(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "Portable Device"}}, autofillFields); got != "Portable Device" {
+		t.Fatalf("expected metadata portable-device resolution, got %q", got)
+	}
+	if got := mapResolution(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "Mixed"}}, autofillFields); got != "Mixed" {
+		t.Fatalf("expected metadata mixed resolution, got %q", got)
+	}
+}
+
+func TestResolveBTNTagsUsesAutofillThenMetadataGenres(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{Genres: "Drama, Science-Fiction, Mystery, Unlisted"},
+			IMDB: &api.IMDBMetadata{Genres: "Comedy, Crime"},
+		},
+	}
+	if got := resolveBTNTags(meta, map[string]string{"tags": "Drama, Comedy"}); got != "Drama, Comedy" {
+		t.Fatalf("expected autofill tags, got %q", got)
+	}
+	if got := resolveBTNTags(meta, map[string]string{}); got != "Drama, Mystery, Science Fiction" {
+		t.Fatalf("expected TVDB fallback tags, got %q", got)
+	}
+
+	meta.ProviderMetadata.TVDB.Genres = ""
+	if got := resolveBTNTags(meta, map[string]string{}); got != "Comedy, Crime" {
+		t.Fatalf("expected IMDb fallback tags, got %q", got)
+	}
+	if got := resolveBTNTags(api.UploadSubject{}, map[string]string{}); got != "" {
+		t.Fatalf("expected empty tags without autofill or provider genres, got %q", got)
+	}
+}
+
+func TestResolveBTNImageUsesAutofillThenMetadataPosters(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB:   &api.TVDBMetadata{Poster: "https://img.example/tvdb.jpg"},
+			IMDB:   &api.IMDBMetadata{Cover: "https://img.example/imdb.jpg"},
+			TVmaze: &api.TVmazeMetadata{Poster: "https://img.example/tvmaze.jpg", PosterMedium: "https://img.example/tvmaze-medium.jpg"},
+			TMDB:   &api.TMDBMetadata{Poster: "https://img.example/tmdb.jpg"},
+		},
+	}
+	if got := resolveBTNImage(meta, map[string]string{"image": "https://img.example/autofill.jpg"}); got != "https://img.example/autofill.jpg" {
+		t.Fatalf("expected autofill poster, got %q", got)
+	}
+	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvdb.jpg" {
+		t.Fatalf("expected TVDB poster, got %q", got)
+	}
+
+	meta.ProviderMetadata.TVDB = nil
+	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/imdb.jpg" {
+		t.Fatalf("expected IMDb poster, got %q", got)
+	}
+	meta.ProviderMetadata.IMDB = nil
+	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvmaze.jpg" {
+		t.Fatalf("expected TVmaze poster, got %q", got)
+	}
+	meta.ProviderMetadata.TVmaze.Poster = ""
+	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tvmaze-medium.jpg" {
+		t.Fatalf("expected TVmaze medium poster, got %q", got)
+	}
+	meta.ProviderMetadata.TVmaze = nil
+	if got := resolveBTNImage(meta, map[string]string{}); got != "https://img.example/tmdb.jpg" {
+		t.Fatalf("expected TMDB poster, got %q", got)
+	}
+}
+
+func TestDecodeBTNAPIJSONRejectsDuplicateKeysAndLargeBodies(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name        string
+		payload     []byte
+		expectedErr string
+	}{
+		{
+			name:        "root duplicate",
+			payload:     []byte(`{"result":{},"result":{}}`),
+			expectedErr: `duplicate JSON object key "result"`,
+		},
+		{
+			name:        "nested duplicate",
+			payload:     []byte(`{"result":{"DownloadURL":"https://example.test/one","DownloadURL":"https://example.test/two"}}`),
+			expectedErr: `duplicate JSON object key "DownloadURL" at "result"`,
+		},
+		{
+			name:        "oversized",
+			payload:     bytes.Repeat([]byte(" "), btnAPIJSONMaxBytes+1),
+			expectedErr: "response body exceeds",
+		},
+		{
+			name:        "multiple values",
+			payload:     []byte(`{} {}`),
+			expectedErr: "multiple JSON values",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var decoded struct {
+				Result map[string]any `json:"result"`
+			}
+			err := decodeBTNAPIJSON(bytes.NewReader(tc.payload), &decoded)
+			if err == nil || !strings.Contains(err.Error(), tc.expectedErr) {
+				t.Fatalf("expected error containing %q", tc.expectedErr)
+			}
+		})
+	}
+
+	var decoded struct {
+		Result struct {
+			DownloadURL string `json:"DownloadURL"`
+		} `json:"result"`
+	}
+	if err := decodeBTNAPIJSON(strings.NewReader(`{"result":{"DownloadURL":"https://example.test/download"}}`), &decoded); err != nil {
+		t.Fatalf("decode valid BTN API JSON: %v", err)
+	}
+	if decoded.Result.DownloadURL != "https://example.test/download" {
+		t.Fatalf("unexpected decoded DownloadURL")
+	}
+}
+
+func TestBTNUploadPayloadUsesCanonicalSeasonEpisodeOnly(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV"},
+		Release:  api.ReleaseInfo{Season: 4, Episode: 9},
+	}
+
+	if got := resolveUploadType(meta); got != "Season" {
+		t.Fatalf("expected upload type Season without canonical episode, got %q", got)
+	}
+	desc := buildAlbumDesc(meta, nil)
+	for _, value := range []string{"[b]Season:[/b] 0", "[b]Episode:[/b] 0"} {
+		if !strings.Contains(desc, value) {
+			t.Fatalf("expected album description to contain %q, got %q", value, desc)
+		}
+	}
+	if strings.Contains(desc, "[b]Season:[/b] 4") || strings.Contains(desc, "[b]Episode:[/b] 9") {
+		t.Fatalf("album description used parsed fallback values: %q", desc)
+	}
+	if got := btnTVPayloadMetadataMessage(meta); got != "canonical TV season/episode missing; BTN upload requires TVDB or metadata season/episode ints and ignores parsed season/episode fallback; refresh metadata or correct canonical season/episode before upload" {
+		t.Fatalf("unexpected metadata message %q", got)
+	}
+}
+
+func TestBTNUploadTypeUsesCanonicalEpisode(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity:   api.ExternalIdentity{Category: "TV"},
+		SeasonInt:  4,
+		EpisodeInt: 9,
+		Release:    api.ReleaseInfo{Season: 1, Episode: 2},
+	}
+
+	if got := resolveUploadType(meta); got != "Episode" {
+		t.Fatalf("expected upload type Episode, got %q", got)
+	}
+	if got := btnTVPayloadMetadataMessage(meta); got != "" {
+		t.Fatalf("unexpected metadata message %q", got)
+	}
+}
+
+func TestResolveBTNTVSeasonEpisodePrefersTVDBThenIMDBThenMetadata(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		SeasonInt:  2,
+		EpisodeInt: 7,
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{EpisodeSeason: 4, EpisodeNumber: 12},
+		},
+	}
+
+	season, episode := resolveBTNTVSeasonEpisode(meta)
+	if season != 4 || episode != 12 {
+		t.Fatalf("expected TVDB season/episode 4/12, got %d/%d", season, episode)
+	}
+	if got := btnTVPayloadMetadataMessage(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{EpisodeSeason: 4, EpisodeNumber: 12},
+		},
+	}); got != "" {
+		t.Fatalf("expected TVDB season/episode to satisfy BTN metadata check, got %q", got)
+	}
+
+	meta.ProviderMetadata.TVDB = &api.TVDBMetadata{}
+	meta.ProviderMetadata.IMDB = &api.IMDBMetadata{Episodes: []api.IMDBEpisode{{Season: 2, EpisodeText: "E07"}}}
+	season, episode = resolveBTNTVSeasonEpisode(meta)
+	if season != 2 || episode != 7 {
+		t.Fatalf("expected IMDb season/episode 2/7, got %d/%d", season, episode)
+	}
+
+	if got := btnTVPayloadMetadataMessage(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Episodes: []api.IMDBEpisode{{Season: 3, EpisodeText: "Episode 8"}}},
+		},
+	}); got != "" {
+		t.Fatalf("expected sole IMDb episode to satisfy BTN metadata check, got %q", got)
+	}
+
+	meta.ProviderMetadata.TVDB = nil
+	meta.ProviderMetadata.IMDB = nil
+	season, episode = resolveBTNTVSeasonEpisode(meta)
+	if season != 2 || episode != 7 {
+		t.Fatalf("expected metadata season/episode 2/7, got %d/%d", season, episode)
+	}
+}
+
+func TestBuildAlbumDescFallsBackToIMDBEpisodeMetadata(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity:        api.ExternalIdentity{Category: "TV"},
+		SeasonInt:       2,
+		EpisodeInt:      7,
+		EpisodeTitle:    "Metadata Episode",
+		EpisodeOverview: "Metadata overview",
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{},
+			IMDB: &api.IMDBMetadata{
+				Plot: "IMDb overview",
+				Episodes: []api.IMDBEpisode{{
+					Title:       "IMDb Episode",
+					Season:      2,
+					EpisodeText: "7",
+					ReleaseDate: api.IMDBReleaseDate{
+						Year:  2026,
+						Month: 3,
+						Day:   4,
+					},
+				}},
+			},
+		},
+	}
+
+	if desc := buildAlbumDesc(meta, map[string]string{"album_desc": "Autofill overview"}); desc != "Autofill overview" {
+		t.Fatalf("expected BTN autofill album_desc to win, got %q", desc)
+	}
+
+	desc := buildAlbumDesc(meta, nil)
+	for _, value := range []string{"[b]Episode Name:[/b] IMDb Episode", "[b]Season:[/b] 2", "[b]Episode:[/b] 7", "[b]Aired:[/b] 2026-03-04", "[b]Episode overview:[/b]\nIMDb overview"} {
+		if !strings.Contains(desc, value) {
+			t.Fatalf("expected album_desc to contain %q, got %q", value, desc)
+		}
+	}
+}
+
+func TestBuildAlbumDescUsesSingleTVDBEpisodeBlock(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity:   api.ExternalIdentity{Category: "TV"},
+		SeasonInt:  2,
+		EpisodeInt: 1,
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{
+				Episodes: []api.TVDBEpisodeMetadata{
+					{
+						SeasonNumber:    2,
+						EpisodeNumber:   1,
+						EpisodeName:     "Example Episode One",
+						EpisodeOverview: "Example overview one.",
+						EpisodeAired:    "2026-04-23",
+						EpisodeImage:    "https://img.example/tvdb-episode-1.jpg",
+					},
+					{
+						SeasonNumber:    2,
+						EpisodeNumber:   2,
+						EpisodeName:     "Example Episode Two",
+						EpisodeOverview: "Example overview two.",
+						EpisodeAired:    "2026-04-30",
+						EpisodeImage:    "https://img.example/tvdb-episode-2.jpg",
+					},
+				},
+			},
+		},
+	}
+
+	desc := buildAlbumDesc(meta, nil)
+	want := "[b]Episode Name:[/b] Example Episode One\n" +
+		"[b]Season:[/b] 2\n" +
+		"[b]Episode:[/b] 1\n" +
+		"[b]Aired:[/b] 2026-04-23\n\n" +
+		"[b]Episode overview:[/b]\n" +
+		"Example overview one.\n\n" +
+		"[b]Episode image:[/b]\n" +
+		"[img=https://img.example/tvdb-episode-1.jpg]"
+	if desc != want {
+		t.Fatalf("unexpected single episode album_desc:\n%s", desc)
+	}
+	if strings.Contains(desc, "Example Episode Two") {
+		t.Fatalf("single episode album_desc included another episode: %q", desc)
+	}
+}
+
+func TestBuildAlbumDescUsesTVDBSeasonEpisodeBlocks(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		Identity:  api.ExternalIdentity{Category: "TV"},
+		SeasonInt: 2,
+		TVPack:    true,
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{
+				Episodes: []api.TVDBEpisodeMetadata{
+					{
+						SeasonNumber:    2,
+						EpisodeNumber:   2,
+						EpisodeName:     "Example Episode Two",
+						EpisodeOverview: "Example overview two.",
+						EpisodeAired:    "2026-04-30",
+						EpisodeImage:    "https://img.example/tvdb-episode-2.jpg",
+					},
+					{
+						SeasonNumber:    1,
+						EpisodeNumber:   1,
+						EpisodeName:     "Wrong Season",
+						EpisodeOverview: "Wrong season overview.",
+						EpisodeAired:    "2025-04-23",
+					},
+					{
+						SeasonNumber:    2,
+						EpisodeNumber:   1,
+						EpisodeName:     "Example Episode One",
+						EpisodeOverview: "Example overview one.",
+						EpisodeAired:    "2026-04-23",
+						EpisodeImage:    "https://img.example/tvdb-episode-1.jpg",
+					},
+				},
+			},
+		},
+	}
+
+	desc := buildAlbumDesc(meta, nil)
+	if strings.Contains(desc, "Wrong Season") {
+		t.Fatalf("season pack album_desc included another season: %q", desc)
+	}
+	first := strings.Index(desc, "Example Episode One")
+	second := strings.Index(desc, "Example Episode Two")
+	if first < 0 || second < 0 || first > second {
+		t.Fatalf("season pack album_desc did not include sorted season episodes: %q", desc)
+	}
+	for _, value := range []string{
+		"[b]Episode Name:[/b] Example Episode One",
+		"[b]Episode image:[/b]\n[img=https://img.example/tvdb-episode-1.jpg]",
+		"[b]Episode Name:[/b] Example Episode Two",
+		"[b]Episode image:[/b]\n[img=https://img.example/tvdb-episode-2.jpg]",
+	} {
+		if !strings.Contains(desc, value) {
+			t.Fatalf("expected season pack album_desc to contain %q, got %q", value, desc)
+		}
+	}
+}
+
+func TestResolveBTNOriginalLanguageUsesTVDBThenIMDB(t *testing.T) {
+	t.Parallel()
+
+	meta := api.UploadSubject{
+		ProviderMetadata: api.SourceScopedMetadata{
+			TVDB: &api.TVDBMetadata{OriginalLanguage: "jpn"},
+			IMDB: &api.IMDBMetadata{OriginalLanguage: "fra"},
+		},
+	}
+	if got := resolveBTNOriginalLanguage(meta); got != "jpn" {
+		t.Fatalf("expected TVDB language, got %q", got)
+	}
+	meta.ProviderMetadata.TVDB.OriginalLanguage = ""
+	if got := resolveBTNOriginalLanguage(meta); got != "fra" {
+		t.Fatalf("expected IMDb fallback language, got %q", got)
+	}
+	for _, value := range []string{"en", "eng", "English"} {
+		if !isBTNEnglishLanguage(value) {
+			t.Fatalf("expected %q to be treated as English", value)
+		}
+	}
+}
diff --git a/internal/trackers/impl/standalone/btn/dupe.go b/internal/trackers/impl/standalone/btn/dupe.go
new file mode 100644
index 00000000..f88c1eb1
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/dupe.go
@@ -0,0 +1,193 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://api.broadcasthe.net/",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	token := strings.TrimSpace(config.ResolveBTNAPIToken(s.cfg))
+	if token == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	if !isTV(meta) {
+		return dupe.NotRun(dupe.NotRunUnsupportedContent, "BTN only supports TV dupe search", nil)
+	}
+	filter := make(map[string]any)
+	switch {
+	case trackerID(meta) != "":
+		filter["id"] = trackerID(meta)
+	case meta.Identity.IMDBID != 0:
+		filter["imdb"] = fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	case meta.Identity.TVDBID != 0:
+		filter["tvdb"] = meta.Identity.TVDBID
+	case searchTitle(meta) != "":
+		filter["searchstr"] = searchTitle(meta)
+	default:
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing btn/imdb/tvdb id and title for BTN dupe search", nil)
+	}
+	payload := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      "upbrr-btn-search",
+		"method":  "getTorrentsSearch",
+		"params":  []any{token, filter, 50},
+	}
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "BTN request failed", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.endpoint, bytes.NewReader(raw))
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "BTN request failed", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "BTN request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "BTN search failed", nil)
+	}
+	var response map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&response); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "BTN search failed", err)
+	}
+	if errorPayload, ok := response["error"].(map[string]any); ok && len(errorPayload) > 0 {
+		return dupe.Failed(dupe.FailureResponseStatus, "BTN api rejected search", nil)
+	}
+	result, _ := response["result"].(map[string]any)
+	torrents, _ := result["torrents"].(map[string]any)
+	entries := make([]api.DupeEntry, 0, len(torrents))
+	for id, rawTorrent := range torrents {
+		torrent, ok := rawTorrent.(map[string]any)
+		if !ok {
+			continue
+		}
+		entry := api.DupeEntry{
+			Name: releaseName(id, torrent),
+			ID:   strings.TrimSpace(id),
+			Link: torrentLink(id, torrent),
+			Res:  btnString(first(torrent, "Resolution", "resolution")),
+			Type: btnString(first(torrent, "Source", "source", "Type", "type")),
+		}
+		if size := btnInt(first(torrent, "Size", "size")); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		entry.Flags = flags(torrent)
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func isTV(meta api.DuplicateSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func trackerID(meta api.DuplicateSubject) string {
+	for key, value := range meta.TrackerIDs {
+		if strings.EqualFold(strings.TrimSpace(key), "BTN") {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
+func searchTitle(meta api.DuplicateSubject) string {
+	candidates := []string{strings.TrimSpace(meta.Release.Title)}
+	if meta.ProviderMetadata.TVDB != nil {
+		candidates = append(candidates, strings.TrimSpace(meta.ProviderMetadata.TVDB.Name), strings.TrimSpace(meta.ProviderMetadata.TVDB.NameEnglish))
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		candidates = append(candidates, strings.TrimSpace(meta.ProviderMetadata.TVmaze.Name))
+	}
+	candidates = append(candidates, strings.TrimSpace(meta.Filename), strings.TrimSpace(meta.ReleaseName))
+	for _, candidate := range candidates {
+		if candidate != "" {
+			return candidate
+		}
+	}
+	return ""
+}
+
+func releaseName(id string, torrent map[string]any) string {
+	for _, candidate := range []string{btnString(first(torrent, "ReleaseName", "releaseName")), btnString(first(torrent, "SceneName", "Name", "name")), btnString(first(torrent, "Series", "series")), strings.TrimSpace(id)} {
+		if candidate != "" {
+			return candidate
+		}
+	}
+	return ""
+}
+
+func torrentLink(id string, torrent map[string]any) string {
+	groupID := btnString(first(torrent, "GroupID", "groupId"))
+	if groupID == "" || strings.TrimSpace(id) == "" {
+		return ""
+	}
+	return "https://broadcasthe.net/torrents.php?id=" + groupID + "&torrentid=" + strings.TrimSpace(id)
+}
+
+func flags(torrent map[string]any) []string {
+	out := make([]string, 0, 2)
+	for _, value := range []string{btnString(first(torrent, "HDR", "hdr")), btnString(first(torrent, "DolbyVision", "dolbyVision", "DV", "dv"))} {
+		upper := strings.ToUpper(strings.TrimSpace(value))
+		switch upper {
+		case "", "0", "FALSE", "NO", "1", "TRUE", "YES":
+			continue
+		}
+		out = append(out, upper)
+	}
+	return out
+}
+
+func first(values map[string]any, keys ...string) any {
+	for _, key := range keys {
+		if value, ok := values[key]; ok {
+			return value
+		}
+	}
+	return nil
+}
+
+func btnString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
diff --git a/internal/trackers/impl/standalone/btn/dupe_test.go b/internal/trackers/impl/standalone/btn/dupe_test.go
new file mode 100644
index 00000000..e1b066e8
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/dupe_test.go
@@ -0,0 +1,321 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+func btnTestInt(value any) int64 {
+	switch typed := value.(type) {
+	case float64:
+		return int64(typed)
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
+
+func btnTestString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func TestBTNHandlerSkipsWithoutAPIKey(t *testing.T) {
+	t.Parallel()
+
+	handler := dupe.NewAdapter(New(), "BTN", config.Config{}, http.DefaultClient, nil)
+	result := handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+	})
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunMissingCredentials || result.SafeMessage() != "missing api_key for tracker" {
+		t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+	}
+}
+
+func TestBTNHandlerSkipsNonTV(t *testing.T) {
+	t.Parallel()
+
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), http.DefaultClient, nil)
+	result := handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "MOVIE",
+		},
+	})
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunUnsupportedContent || result.SafeMessage() != "BTN only supports TV dupe search" {
+		t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+	}
+}
+
+func TestBTNHandlerUsesTrackerIDFirst(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	_, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		TrackerIDs: map[string]string{"btn": "1234"},
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			IMDBID:   7654321,
+			TVDBID:   8899,
+		},
+		Release: api.ReleaseInfo{Title: "Ignored"},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %v", notes)
+	}
+	filter := payloads.lastFilter(t)
+	assertBTNFilterValue(t, filter, "id", "1234")
+	if _, ok := filter["imdb"]; ok {
+		t.Fatalf("did not expect imdb when btn id is present: %#v", filter)
+	}
+	if _, ok := filter["tvdb"]; ok {
+		t.Fatalf("did not expect tvdb when btn id is present: %#v", filter)
+	}
+	if _, ok := filter["searchstr"]; ok {
+		t.Fatalf("did not expect searchstr when btn id is present: %#v", filter)
+	}
+}
+
+func TestBTNHandlerFallsBackToIMDb(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	_, _, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			IMDBID:   1234567,
+		},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	filter := payloads.lastFilter(t)
+	assertBTNFilterValue(t, filter, "imdb", "tt1234567")
+}
+
+func TestBTNHandlerFallsBackToTVDB(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	_, _, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+			TVDBID:   998877,
+		},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	filter := payloads.lastFilter(t)
+	if got := btnTestInt(filter["tvdb"]); got != 998877 {
+		t.Fatalf("expected tvdb 998877, got %#v", filter["tvdb"])
+	}
+}
+
+func TestBTNHandlerFallsBackToTitleSearch(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"result":{"torrents":{}}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	_, _, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		Release: api.ReleaseInfo{Title: "Example Show"},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	filter := payloads.lastFilter(t)
+	assertBTNFilterValue(t, filter, "searchstr", "Example Show")
+}
+
+func TestBTNHandlerNormalizesEntries(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"result":{"torrents":{"777":{"GroupID":"333","ReleaseName":"Example.Show.S01E01.1080p.WEB-DL.HDR.DV","Size":12345,"Resolution":"1080p","Source":"WEB-DL","HDR":"HDR10","DolbyVision":"DV"}}}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		Release: api.ReleaseInfo{Title: "Example Show"},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(entries))
+	}
+	entry := entries[0]
+	if entry.Name != "Example.Show.S01E01.1080p.WEB-DL.HDR.DV" {
+		t.Fatalf("unexpected name: %#v", entry)
+	}
+	if entry.ID != "777" {
+		t.Fatalf("unexpected id: %#v", entry)
+	}
+	if entry.Link != "https://broadcasthe.net/torrents.php?id=333&torrentid=777" {
+		t.Fatalf("unexpected link: %#v", entry)
+	}
+	if !entry.SizeKnown || entry.SizeBytes != 12345 {
+		t.Fatalf("unexpected size fields: %#v", entry)
+	}
+	if entry.Res != "1080p" {
+		t.Fatalf("unexpected resolution: %#v", entry)
+	}
+	if entry.Type != "WEB-DL" {
+		t.Fatalf("unexpected type: %#v", entry)
+	}
+	if len(entry.Flags) != 2 || entry.Flags[0] != "HDR10" || entry.Flags[1] != "DV" {
+		t.Fatalf("unexpected flags: %#v", entry.Flags)
+	}
+}
+
+func TestBTNHandlerAPIErrorReturnsNoDupes(t *testing.T) {
+	t.Parallel()
+
+	payloads := captureBTNPayloads(t, `{"error":{"message":"bad request"}}`)
+	handler := dupe.NewAdapter(New(), "BTN", configWithBTNAPIKey(), payloads.client, nil)
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		SourcePath: "x",
+		Identity: api.ExternalIdentity{
+			Category: "TV",
+		},
+		Release: api.ReleaseInfo{Title: "Example Show"},
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %v", notes)
+	}
+}
+
+type btnPayloadCapture struct {
+	client  *http.Client
+	payload map[string]any
+	mu      sync.Mutex
+}
+
+func captureBTNPayloads(t *testing.T, response string) *btnPayloadCapture {
+	t.Helper()
+
+	capture := &btnPayloadCapture{}
+	capture.client = &http.Client{
+		Transport: btnRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			body, err := io.ReadAll(req.Body)
+			if err != nil {
+				return nil, fmt.Errorf("read BTN payload request body: %w", err)
+			}
+			_ = req.Body.Close()
+
+			capture.mu.Lock()
+			defer capture.mu.Unlock()
+			if err := json.Unmarshal(body, &capture.payload); err != nil {
+				return nil, fmt.Errorf("unmarshal BTN payload request body: %w", err)
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(response)),
+				Request:    req,
+			}, nil
+		}),
+	}
+	return capture
+}
+
+func (c *btnPayloadCapture) lastFilter(t *testing.T) map[string]any {
+	t.Helper()
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	params, ok := c.payload["params"].([]any)
+	if !ok || len(params) < 2 {
+		t.Fatalf("expected JSON-RPC params, got %#v", c.payload)
+	}
+	filter, ok := params[1].(map[string]any)
+	if !ok {
+		t.Fatalf("expected filter map, got %#v", params[1])
+	}
+	return filter
+}
+
+func configWithBTNAPIKey() config.Config {
+	return config.Config{
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{
+				"BTN": {APIKey: strings.Repeat("x", 30)},
+			},
+		},
+	}
+}
+
+func assertBTNFilterValue(t *testing.T, filter map[string]any, key string, want string) {
+	t.Helper()
+	if got := btnTestString(filter[key]); got != want {
+		t.Fatalf("expected %s=%q, got %#v", key, want, filter)
+	}
+}
+
+type btnRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn btnRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
diff --git a/internal/trackers/impl/standalone/btn/profile.go b/internal/trackers/impl/standalone/btn/profile.go
new file mode 100644
index 00000000..630f6223
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/profile.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns BTN identity, preparation, dupe, auth, bans, and policies.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:              "BTN",
+		BaseURL:           btnDefaultBaseURL,
+		DescriptionGroup:  "btn",
+		UploadContentMode: trackers.UploadContentModeNone,
+		PrepareUpload: func(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return prepareUploadAt(ctx, req, btnDefaultBaseURL)
+		},
+		NewDuplicateAdapter: newDuplicateAdapter,
+		BannedGroups:        bannedGroups(),
+		DataPolicy:          &trackers.DataLookupPolicy{DeferWhenCollectingImages: true},
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeTV,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDB, trackers.MetadataFieldTVDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "BTN", RequireAnnounce: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns:       []string{"https://broadcasthe.net", "https://backup.landof.tv", "https://landof.tv", "landof.tv/"},
+			CommentURLPatterns:       []string{"https://broadcasthe.net", "https://backup.landof.tv", "https://landof.tv"},
+			DetailIDPattern:          "id=(\\d+)",
+			InferMatchFromResolvedID: true,
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:          "BTN",
+			DisplayName:        "BTN",
+			AuthKind:           "api_key_cookies_login_manual_2fa",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+			SupportsTOTP:       true,
+			SupportsManual2FA:  true,
+			RequiresAPIKey:     true,
+			Notes:              []string{"API key is required for torrent resolution; cookies/login cover upload auth."},
+		},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+			return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, login, btnDefaultBaseURL)
+		},
+		AuthPolicy: &trackers.AuthPolicy{ //nolint:gosec // Operator messages name API keys; no credential is embedded.
+			ResolveAPIKey:               func(cfg config.Config, _ config.TrackerConfig) string { return config.ResolveBTNAPIToken(cfg) },
+			APIKeyRequiresUploadSession: true,
+			MissingAPIKeyMessage:        "API key is required for torrent resolution; imported cookies or login credentials cover upload auth",
+			UploadSessionMissingMessage: "API key covers torrent resolution; imported cookies or login credentials required for upload auth",
+		},
+	}
+}
+
+// Definition extends the shared standalone definition with BTN data and claim lookup.
+type Definition struct {
+	*standalone.Definition
+	baseURL string
+}
+
+// New returns a fresh BTN definition from its tracker-local profile.
+func New() *Definition {
+	return &Definition{Definition: standalone.MustNew(Profile()), baseURL: btnDefaultBaseURL}
+}
diff --git a/internal/trackers/impl/standalone/btn/upload.go b/internal/trackers/impl/standalone/btn/upload.go
new file mode 100644
index 00000000..365f2525
--- /dev/null
+++ b/internal/trackers/impl/standalone/btn/upload.go
@@ -0,0 +1,3078 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btn
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
+	"encoding/base32"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html"
+	"io"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/netip"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/moistari/rls"
+	xhtml "golang.org/x/net/html"
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	btnDefaultBaseURL  = "https://backup.landof.tv"
+	btnUploadPath      = "/upload.php"
+	btnLoginPath       = "/login.php"
+	btnAPIRPCURL       = "https://api.broadcasthe.net/"
+	btnAPIJSONMaxBytes = 1024 * 1024
+	btnTorrentMaxBytes = 8 * 1024 * 1024
+)
+
+var (
+	btnInputPattern       = regexp.MustCompile(`(?is)<input[^>]*name=["']([^"']+)["'][^>]*value=["']([^"']*)["'][^>]*>`)
+	btnTextAreaPattern    = regexp.MustCompile(`(?is)<textarea[^>]*name=["']album_desc["'][^>]*>(.*?)</textarea>`)
+	btnSelectPattern      = regexp.MustCompile(`(?is)<select[^>]*name=["']([^"']+)["'][^>]*>(.*?)</select>`)
+	btnSuccessURLPattern  = regexp.MustCompile(`torrents\.php\?id=(\d+)(?:&torrentid=(\d+))?`)
+	btnHTMLURLAttrPattern = regexp.MustCompile(`(?is)\b(?:href|action)=["']([^"']+)["']`)
+	btnIMDBEpisodePattern = regexp.MustCompile(`(?i)(?:^|\bE|episode\s*)(\d{1,4})(?:\b|$)`)
+	// btnCountryMap maps normalized BTN country option labels and exact
+	// metadata-source country codes to BTN's country select values.
+	//literalpolicy:allow aliases are grouped by BTN country value
+	btnCountryMap = map[string]string{
+		"se": "1", "swe": "1", "sweden": "1",
+		"us": "2", "usa": "2", "united states": "2", "united states of america": "2",
+		"ru": "3", "rus": "3", "russia": "3", "russian federation": "3",
+		"fi": "4", "fin": "4", "finland": "4",
+		"ca": "5", "can": "5", "canada": "5",
+		"fr": "6", "fra": "6", "france": "6",
+		"de": "7", "deu": "7", "germany": "7",
+		"cn": "8", "chn": "8", "china": "8",
+		"it": "9", "ita": "9", "italy": "9",
+		"dk": "10", "dnk": "10", "denmark": "10",
+		"no": "11", "nor": "11", "norway": "11",
+		"gb": "12", "uk": "12", "gbr": "12", "united kingdom": "12",
+		"ie": "13", "irl": "13", "ireland": "13",
+		"pl": "14", "pol": "14", "poland": "14",
+		"nl": "15", "nld": "15", "netherlands": "15",
+		"be": "16", "bel": "16", "belgium": "16",
+		"jp": "17", "jpn": "17", "japan": "17",
+		"br": "18", "bra": "18", "brazil": "18",
+		"ar": "19", "arg": "19", "argentina": "19",
+		"au": "20", "aus": "20", "australia": "20",
+		"nz": "21", "nzl": "21", "new zealand": "21",
+		"es": "22", "esp": "22", "spain": "22",
+		"pt": "23", "prt": "23", "portugal": "23",
+		"mx": "24", "mex": "24", "mexico": "24",
+		"sg": "25", "sgp": "25", "singapore": "25",
+		"za": "26", "zaf": "26", "south africa": "26",
+		"kr": "27", "kor": "27", "south korea": "27",
+		"jm": "28", "jam": "28", "jamaica": "28",
+		"lu": "29", "lux": "29", "luxembourg": "29",
+		"hk": "30", "hkg": "30", "hong kong": "30",
+		"bz": "31", "blz": "31", "belize": "31",
+		"dz": "32", "dza": "32", "algeria": "32",
+		"ao": "33", "ago": "33", "angola": "33",
+		"at": "34", "aut": "34", "austria": "34",
+		"yu": "35", "yug": "35", "yugoslavia": "35",
+		"ws": "36", "wsm": "36", "western samoa": "36",
+		"my": "37", "mys": "37", "malaysia": "37",
+		"do": "38", "dom": "38", "dominican republic": "38",
+		"gr": "39", "grc": "39", "greece": "39",
+		"gt": "40", "gtm": "40", "guatemala": "40",
+		"il": "41", "isr": "41", "israel": "41",
+		"pk": "42", "pak": "42", "pakistan": "42",
+		"cz": "43", "cze": "43", "czech republic": "43", "czechia": "43",
+		"rs": "44", "srb": "44", "serbia": "44",
+		"sc": "45", "syc": "45", "seychelles": "45",
+		"tw": "46", "twn": "46", "taiwan": "46",
+		"pr": "47", "pri": "47", "puerto rico": "47",
+		"cl": "48", "chl": "48", "chile": "48",
+		"cu": "49", "cub": "49", "cuba": "49",
+		"cg": "50", "cog": "50", "congo": "50",
+		"af": "51", "afg": "51", "afghanistan": "51",
+		"tr": "52", "tur": "52", "turkey": "52",
+		"uz": "53", "uzb": "53", "uzbekistan": "53",
+		"ch": "54", "che": "54", "switzerland": "54",
+		"ki": "55", "kir": "55", "kiribati": "55",
+		"ph": "56", "phl": "56", "philippines": "56",
+		"bf": "57", "bfa": "57", "burkina faso": "57",
+		"ng": "58", "nga": "58", "nigeria": "58",
+		"is": "59", "isl": "59", "iceland": "59",
+		"nr": "60", "nru": "60", "nauru": "60",
+		"si": "61", "svn": "61", "slovenia": "61",
+		"al": "62", "alb": "62", "albania": "62",
+		"tm": "63", "tkm": "63", "turkmenistan": "63",
+		"ba": "64", "bih": "64", "bosnia herzegovina": "64", "bosnia and herzegovina": "64",
+		"ad": "65", "and": "65", "andorra": "65",
+		"lt": "66", "ltu": "66", "lithuania": "66",
+		"in": "67", "ind": "67", "india": "67",
+		"an": "68", "ant": "68", "netherlands antilles": "68",
+		"ua": "69", "ukr": "69", "ukraine": "69",
+		"ve": "70", "ven": "70", "venezuela": "70",
+		"hu": "71", "hun": "71", "hungary": "71",
+		"ro": "72", "rou": "72", "romania": "72",
+		"vu": "73", "vut": "73", "vanuatu": "73",
+		"vn": "74", "vnm": "74", "vietnam": "74",
+		"tt": "75", "tto": "75", "trinidad": "75", "trinidad and tobago": "75",
+		"hn": "76", "hnd": "76", "honduras": "76",
+		"kg": "77", "kgz": "77", "kyrgyzstan": "77",
+		"ec": "78", "ecu": "78", "ecuador": "78",
+		"bs": "79", "bhs": "79", "bahamas": "79",
+		"pe": "80", "per": "80", "peru": "80",
+		"kh": "81", "khm": "81", "cambodia": "81",
+		"bb": "82", "brb": "82", "barbados": "82",
+		"bd": "83", "bgd": "83", "bangladesh": "83",
+		"la": "84", "lao": "84", "laos": "84",
+		"uy": "85", "ury": "85", "uruguay": "85",
+		"ag": "86", "atg": "86", "antigua barbuda": "86", "antigua and barbuda": "86",
+		"py": "87", "pry": "87", "paraguay": "87",
+		"su": "88", "sun": "88", "soviet": "88", "soviet union": "88", "ussr": "88", "union of soviet socialist repu": "88",
+		"th": "89", "tha": "89", "thailand": "89",
+		"sn": "90", "sen": "90", "senegal": "90",
+		"tg": "91", "tgo": "91", "togo": "91",
+		"kp": "92", "prk": "92", "north korea": "92",
+		"hr": "93", "hrv": "93", "croatia": "93",
+		"ee": "94", "est": "94", "estonia": "94",
+		"co": "95", "col": "95", "colombia": "95",
+		"lb": "96", "lbn": "96", "lebanon": "96",
+		"lv": "97", "lva": "97", "latvia": "97",
+		"cr": "98", "cri": "98", "costa rica": "98",
+		"eg": "99", "egy": "99", "egypt": "99",
+		"bg": "100", "bgr": "100", "bulgaria": "100",
+		"isle de muerte": "101",
+		"fj":             "102", "fji": "102", "fiji": "102",
+		"mk": "103", "mkd": "103", "macedonia": "103",
+		"kw": "104", "kwt": "104", "kuwait": "104",
+		"lk": "105", "lka": "105", "sri lanka": "105",
+		"ir": "106", "irn": "106", "iran": "106",
+		"arab league": "107",
+		"sa":          "108", "sau": "108", "saudi arabia": "108",
+		"scotland": "109",
+		"sk":       "110", "svk": "110", "slovakia": "110",
+		"id": "111", "idn": "111", "indonesia": "111",
+		"wales": "112",
+		"bn":    "113", "brn": "113", "brunei": "113",
+	}
+)
+
+// ErrSubmitted2FARejected marks a BTN failure after a submitted manual 2FA code
+// reached the tracker and was rejected.
+var ErrSubmitted2FARejected = trackers.ErrSubmitted2FARejected
+
+var (
+	errBTNCookiesMissing          = errors.New("trackers: BTN cookies not configured")
+	errBTNSessionConfirmedInvalid = errors.New("trackers: BTN stored session confirmed invalid")
+)
+
+type uploadContext struct {
+	baseURL   string
+	uploadURL string
+	apiToken  string
+	apiURL    string
+	client    *http.Client
+}
+
+// btnNameNormalizationRule applies one ordered rewrite to the BTN scene name.
+type btnNameNormalizationRule struct {
+	pattern     *regexp.Regexp
+	replacement string
+}
+
+// btnNameNormalizationRules normalizes release-name tokens after whitespace and
+// DD+ cleanup. The order is significant: Atmos-specific compaction must happen
+// before generic audio channel joins, and dot collapse must run after character
+// replacement.
+var btnNameNormalizationRules = []btnNameNormalizationRule{
+	{pattern: regexp.MustCompile(`(?i)\.DDP\.(\d+(?:\.\d+)?)\.Atmos`), replacement: `.DDPA$1`},
+	{pattern: regexp.MustCompile(`(?i)\.TrueHD\.(\d+(?:\.\d+)?)\.Atmos`), replacement: `.TrueHDA$1`},
+	{pattern: regexp.MustCompile(`\.DDP\.(\d)`), replacement: `.DDP$1`},
+	{pattern: regexp.MustCompile(`\.DD\.(\d)`), replacement: `.DD$1`},
+	{pattern: regexp.MustCompile(`\.AC3\.(\d)`), replacement: `.AC3$1`},
+	{pattern: regexp.MustCompile(`\.DTS\.(\d)`), replacement: `.DTS$1`},
+	{pattern: regexp.MustCompile(`\.AAC\.(\d)`), replacement: `.AAC$1`},
+	{pattern: regexp.MustCompile(`\.FLAC\.(\d)`), replacement: `.FLAC$1`},
+	{pattern: regexp.MustCompile(`(?i)\.TrueHD\.(\d)`), replacement: `.TrueHD$1`},
+	{pattern: regexp.MustCompile(`(?i)\.PCM\.(\d)`), replacement: `.PCM$1`},
+	{pattern: regexp.MustCompile(`(?i)\.LPCM\.(\d)`), replacement: `.LPCM$1`},
+	{pattern: regexp.MustCompile(`[^a-zA-Z0-9.\-]`), replacement: `.`},
+	{pattern: regexp.MustCompile(`\.{2,}`), replacement: `.`},
+}
+
+func uploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (api.UploadSummary, error) {
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, baseURL)
+	})
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BTN submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (trackers.PreparedOperation, error) {
+	if req.Intent != trackers.PreparationIntentUpload {
+		preview, err := buildUploadDryRunAt(ctx, req, baseURL)
+		if err != nil {
+			return trackers.PreparedOperation{}, err
+		}
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if err := validateBTNRequest(req); err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	if message, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
+		if req.Logger != nil {
+			req.Logger.Warnf("trackers: BTN %s", message)
+		}
+		return trackers.PreparedOperation{}, err
+	}
+
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	uploadCtx, err := newUploadContextAt(ctx, req, baseURL)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	client, err := ensureBTNUploadSession(ctx, req.TrackerConfig, req.Runtime.DBPath, uploadCtx)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	uploadCtx.client = client
+
+	if err := checkBTNSeasonPackReservation(ctx, uploadCtx, req); err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	data, err := prepareUploadData(ctx, req, uploadCtx)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	files := resolveBTNUploadFiles(req.Meta, torrentPath)
+	body, contentType, err := commonhttp.BuildMultipartPayload(data, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.Runtime.DBPath, "BTN")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "BTN",
+		ReleaseName:      resolveUploadName(req.Meta),
+		DescriptionGroup: "btn",
+		Description:      data["release_desc"],
+		Endpoint:         uploadCtx.uploadURL,
+		Payload:          data,
+		Files:            resolveBTNDryRunFiles(req.Meta, torrentPath),
+	})
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, uploadCtx, torrentPath, trackerTorrentPath, body, contentType)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	uploadCtx uploadContext,
+	torrentPath string,
+	trackerTorrentPath string,
+	body []byte,
+	contentType string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadCtx.uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BTN request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := uploadCtx.client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: BTN upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	groupID, torrentID, matched := btnUploadIDsFromText(finalURL)
+	torrentDownloaded := false
+	if !matched {
+		responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= 200 && resp.StatusCode < 400, 2048)
+		if err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: BTN read upload response: %w", err)
+		}
+		intermediate, handled, err := resolveBTNUploadIntermediatePage(ctx, uploadCtx.client, uploadCtx.baseURL, finalURL, responseBody)
+		if handled {
+			if err != nil {
+				if req.Logger != nil {
+					req.Logger.Warnf("trackers: BTN intermediate upload page fallback to API search: %s", commonhttp.RedactErrorDetail(err.Error()))
+				}
+				groupID = intermediate.groupID
+				selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
+				if err != nil {
+					return api.UploadSummary{}, err
+				}
+				torrentID = selectedID
+				if selectedGroupID != "" {
+					groupID = selectedGroupID
+				}
+				torrentDownloaded = true
+			} else {
+				groupID = intermediate.groupID
+				torrentID = intermediate.torrentID
+			}
+		} else {
+			groupID, torrentID, matched = btnUploadIDsFromText(string(responseBody))
+		}
+		if !matched && groupID == "" && torrentID == "" {
+			failurePath, _ := commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "BTN", "upload-failure", responsePreview, ".html")
+			if failurePath != "" {
+				return api.UploadSummary{}, fmt.Errorf(
+					"%w failure=%s",
+					commonhttp.UploadHTTPErrorWithURL("BTN", resp.StatusCode, finalURL, responsePreview),
+					failurePath,
+				)
+			}
+			return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("BTN", resp.StatusCode, finalURL, responsePreview)
+		}
+	}
+	torrentURL := buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
+
+	if announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announceURL != "" && torrentID != "" && !torrentDownloaded {
+		if err := writeBTNTorrentArtifact(torrentPath, trackerTorrentPath, announceURL, torrentURL); err != nil {
+			return api.UploadSummary{}, err
+		}
+		torrentDownloaded = true
+	}
+
+	if torrentID != "" && !torrentDownloaded {
+		if err := downloadTrackerTorrent(ctx, uploadCtx.client, uploadCtx.baseURL, torrentID, trackerTorrentPath); err != nil {
+			if req.Logger != nil {
+				req.Logger.Warnf("trackers: BTN torrent download fallback to API search: %s", commonhttp.RedactErrorDetail(err.Error()))
+			}
+			selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
+			if err != nil {
+				return api.UploadSummary{}, err
+			}
+			torrentID = selectedID
+			if selectedGroupID != "" {
+				groupID = selectedGroupID
+			}
+			torrentURL = buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
+		}
+	} else if torrentID == "" {
+		selectedID, selectedGroupID, err := resolveAndDownloadViaAPI(ctx, uploadCtx.apiURL, uploadCtx.apiToken, req, groupID, trackerTorrentPath)
+		if err != nil {
+			return api.UploadSummary{}, err
+		}
+		torrentID = selectedID
+		if selectedGroupID != "" {
+			groupID = selectedGroupID
+		}
+		torrentURL = buildBTNTorrentURL(uploadCtx.baseURL, groupID, torrentID)
+	}
+
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "BTN",
+			TorrentID:   torrentID,
+			TorrentURL:  torrentURL,
+			DownloadURL: torrentURL,
+			TorrentPath: trackerTorrentPath,
+		}},
+	}, nil
+}
+
+// buildUploadDryRun returns a BTN preview entry with the exact payload that
+// would be submitted locally. TV payloads that would serialize missing
+// canonical season or episode metadata as zero are returned as blocked so the
+// operator sees the remediation before upload.
+func buildUploadDryRun(ctx context.Context, req trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	return buildUploadDryRunAt(ctx, req, btnDefaultBaseURL)
+}
+
+func buildUploadDryRunAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (api.TrackerDryRunEntry, error) {
+	if err := validateBTNRequest(req); err != nil {
+		return api.TrackerDryRunEntry{}, err
+	}
+
+	uploadCtx, err := newUploadContextAt(ctx, req, baseURL)
+	if err != nil {
+		return api.TrackerDryRunEntry{}, err
+	}
+	if err := validateBTNDryRunUploadAuth(ctx, req, uploadCtx); err != nil {
+		return api.TrackerDryRunEntry{}, err
+	}
+
+	autofillPayload, uploadType := buildBTNAutofillPayload(req.Meta)
+	debugSections := make([]api.TrackerDryRunDebugSection, 0, 2)
+	if req.Intent == trackers.PreparationIntentDryRun {
+		debugSections = append(debugSections, api.TrackerDryRunDebugSection{
+			Title:    "BTN autofill request",
+			Endpoint: uploadCtx.uploadURL,
+			Payload:  urlValuesToPayloadMap(autofillPayload),
+		})
+	}
+
+	payload := map[string]string{
+		"submit":       "true",
+		"type":         uploadType,
+		"scenename":    resolveUploadName(req.Meta),
+		"origin":       resolveOrigin(req.Meta),
+		"release_desc": resolveBTNReleaseDesc(req.Meta),
+		"tvdb":         "autofilled",
+	}
+	if resolveFastTorrent(req.TrackerConfig) {
+		payload["fasttorrent"] = "on"
+	}
+
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return api.TrackerDryRunEntry{}, err
+	}
+
+	message := "dry-run payload generated"
+	status := "ready"
+	if metadataMessage, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
+		message += "; " + metadataMessage
+		status = "blocked"
+	}
+	if req.Intent == trackers.PreparationIntentDryRun && status == "ready" {
+		client, err := ensureBTNUploadSession(ctx, req.TrackerConfig, req.Runtime.DBPath, uploadCtx)
+		if err != nil {
+			return api.TrackerDryRunEntry{}, err
+		}
+		uploadCtx.client = client
+		fields, err := requestBTNAutofillFields(ctx, uploadCtx, autofillPayload, uploadType)
+		if err != nil {
+			return api.TrackerDryRunEntry{}, err
+		}
+		payload, err = buildBTNUploadPayload(req, fields)
+		if err != nil {
+			return api.TrackerDryRunEntry{}, err
+		}
+		message += "; BTN autofill debug completed"
+		debugSections = append(debugSections, api.TrackerDryRunDebugSection{
+			Title:    "BTN final upload payload after autofill",
+			Endpoint: uploadCtx.uploadURL,
+			Payload:  payload,
+			Files:    resolveBTNDryRunFiles(req.Meta, torrentPath),
+		})
+	}
+
+	return api.TrackerDryRunEntry{
+		Tracker:          "BTN",
+		Status:           status,
+		Message:          message,
+		ReleaseName:      resolveUploadName(req.Meta),
+		DescriptionGroup: "btn",
+		Description:      payload["release_desc"],
+		Endpoint:         uploadCtx.uploadURL,
+		Payload:          payload,
+		Files:            resolveBTNDryRunFiles(req.Meta, torrentPath),
+		DebugSections:    debugSections,
+	}, nil
+}
+
+// validateBTNDryRunUploadAuth checks auth prerequisites needed before an upload
+// can authenticate. Stored cookies must pass the same upload-page session gate
+// as live upload; credential fallback remains local-only and does not log in or
+// persist cookies during dry-run.
+func validateBTNDryRunUploadAuth(ctx context.Context, req trackers.PreparationInput, uploadCtx uploadContext) error {
+	values, cookieErr := loadBTNCookies(ctx, req.Runtime.DBPath)
+	if cookieErr == nil && len(values) > 0 {
+		client, err := newBTNClientWithCookies(uploadCtx.baseURL, values)
+		if err != nil {
+			return err
+		}
+		if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err == nil {
+			return nil
+		} else if !errors.Is(err, errBTNSessionConfirmedInvalid) {
+			return err
+		} else if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
+			return err
+		}
+	}
+	if cookieErr != nil && !errors.Is(cookieErr, errBTNCookiesMissing) {
+		return cookieErr
+	}
+	if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
+		return errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
+	}
+	return nil
+}
+
+func newUploadContextAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (uploadContext, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return uploadContext{}, fmt.Errorf("trackers: BTN create cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 45 * time.Second, Jar: jar}
+	uploadCtx := uploadContext{
+		baseURL:   baseURL,
+		uploadURL: baseURL + btnUploadPath,
+		apiToken:  req.Runtime.BTNAPIToken,
+		apiURL:    resolveBTNAPIURL(req.TrackerConfig),
+		client:    client,
+	}
+	loadBTNCookiesIntoJar(ctx, client, req.Runtime.DBPath, baseURL)
+	return uploadCtx, nil
+}
+
+// ensureBTNUploadSession validates imported BTN cookies before credential login.
+// Credential login cookies are persisted only after the refreshed client reaches
+// the upload page, so failed or incomplete logins do not replace stored auth.
+func ensureBTNUploadSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, uploadCtx uploadContext) (*http.Client, error) {
+	values, cookieErr := loadBTNCookies(ctx, dbPath)
+	if cookieErr == nil && len(values) > 0 {
+		if client, err := newBTNClientWithCookies(uploadCtx.baseURL, values); err == nil {
+			if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err == nil {
+				return client, nil
+			} else if !errors.Is(err, errBTNSessionConfirmedInvalid) {
+				return nil, err
+			}
+		}
+	}
+	if cookieErr != nil && !errors.Is(cookieErr, errBTNCookiesMissing) {
+		return nil, cookieErr
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
+	}
+	client, err := loginBTNSession(ctx, cfg, uploadCtx.baseURL, api.TrackerAuthLoginRequest{})
+	if err != nil {
+		return nil, err
+	}
+	if err := validateBTNClientSession(ctx, client, uploadCtx.baseURL); err != nil {
+		return nil, err
+	}
+	if err := persistBTNCookies(ctx, dbPath, uploadCtx.baseURL, client.Jar); err != nil {
+		return nil, fmt.Errorf("trackers: BTN persist cookies after successful login: %w", err)
+	}
+	return client, nil
+}
+
+// ResolveSessionForTrackerAuth validates BTN stored cookies or logs in with
+// configured credentials. Credential login must produce reusable cookies before
+// refreshed cookies are persisted.
+func ResolveSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string) error {
+	return resolveSessionForTrackerAuthAt(ctx, cfg, dbPath, btnDefaultBaseURL)
+}
+
+func resolveSessionForTrackerAuthAt(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{}, baseURL)
+}
+
+// ResolveSessionForTrackerAuthLogin validates BTN stored cookies or logs in
+// with configured credentials. Refreshed cookies are persisted only after the
+// upload page confirms the session. Manual login.Code is preferred over
+// configured TOTP. Missing 2FA input preserves existing cookies; a rejected
+// submitted code returns [ErrSubmitted2FARejected] before persistence.
+func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, login, btnDefaultBaseURL)
+}
+
+func resolveSessionForTrackerAuthLoginAt(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	dbPath string,
+	login api.TrackerAuthLoginRequest,
+	baseURL string,
+) error {
+	err := validateBTNStoredCookies(ctx, baseURL, dbPath)
+	if err == nil {
+		return nil
+	}
+	if !errors.Is(err, errBTNCookiesMissing) && !errors.Is(err, errBTNSessionConfirmedInvalid) {
+		return err
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		if errors.Is(err, errBTNSessionConfirmedInvalid) {
+			return err
+		}
+		return errors.New("trackers: BTN cookie invalid/missing and username/password not configured")
+	}
+	client, err := loginBTNSession(ctx, cfg, baseURL, login)
+	if err != nil {
+		return err
+	}
+	if err := validateBTNClientSession(ctx, client, baseURL); err != nil {
+		if strings.TrimSpace(login.Code) != "" && errors.Is(err, errBTNSessionConfirmedInvalid) {
+			return fmt.Errorf("trackers: BTN submitted 2FA validation failed: %w", ErrSubmitted2FARejected)
+		}
+		return err
+	}
+	if err := persistBTNCookies(ctx, dbPath, baseURL, client.Jar); err != nil {
+		return fmt.Errorf("trackers: BTN persist cookies after successful login: %w", err)
+	}
+	return nil
+}
+
+// validateBTNStoredCookies checks persisted BTN cookies against the upload page.
+// Confirmed logged-out evidence is returned distinctly so tracker auth can delete
+// stale cookies; storage/decrypt failures and ambiguous remote/parser failures
+// preserve stored cookies and block credential login.
+func validateBTNStoredCookies(ctx context.Context, baseURL string, dbPath string) error {
+	values, err := loadBTNCookies(ctx, dbPath)
+	if err != nil {
+		return err
+	}
+	if len(values) == 0 {
+		return errBTNCookiesMissing
+	}
+	client, err := newBTNClientWithCookies(baseURL, values)
+	if err != nil {
+		return err
+	}
+	return validateBTNClientSession(ctx, client, baseURL)
+}
+
+// loginBTNSession performs the credential login step and leaves cookie
+// persistence to callers after they validate the resulting upload session.
+func loginBTNSession(ctx context.Context, cfg config.TrackerConfig, baseURL string, login api.TrackerAuthLoginRequest) (*http.Client, error) {
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, errors.New("trackers: BTN requires username/password")
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN create login cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 45 * time.Second, Jar: jar}
+	values := url.Values{}
+	values.Set("username", strings.TrimSpace(cfg.Username))
+	values.Set("password", strings.TrimSpace(cfg.Password))
+	values.Set("keeplogged", "1")
+	if code, err := resolveBTN2FACode(cfg, login); err == nil && code != "" {
+		values.Set("codenumber", code)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, "/")+btnLoginPath, strings.NewReader(values.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN login request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "upbrr")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN login request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, readErr := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
+	if readErr != nil {
+		return nil, fmt.Errorf("trackers: BTN read login response: %w", readErr)
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 400 {
+		if strings.TrimSpace(login.Code) != "" && resp.StatusCode == http.StatusForbidden {
+			return nil, fmt.Errorf("trackers: BTN login failed status=%d: %w", resp.StatusCode, ErrSubmitted2FARejected)
+		}
+		return nil, fmt.Errorf("trackers: BTN login failed status=%d", resp.StatusCode)
+	}
+	bodyText := string(body)
+	if btnLoginNeeds2FA(bodyText) {
+		if strings.TrimSpace(login.Code) != "" {
+			return nil, fmt.Errorf("trackers: BTN login failed: %w", ErrSubmitted2FARejected)
+		}
+		if _, err := resolveBTN2FACode(config.TrackerConfig{OTPURI: cfg.OTPURI}, api.TrackerAuthLoginRequest{}); err != nil {
+			return nil, fmt.Errorf("trackers: BTN 2FA required: %w", err)
+		}
+	}
+	if btnLoginFailed(bodyText) {
+		if strings.TrimSpace(login.Code) != "" {
+			return nil, fmt.Errorf("trackers: BTN login failed: %w", ErrSubmitted2FARejected)
+		}
+		return nil, errors.New("trackers: BTN login failed")
+	}
+	return client, nil
+}
+
+// validateBTNClientSession confirms the client can reach BTN's upload page.
+// It treats explicit login redirects and logged-out markers as invalid session
+// evidence while keeping layout misses and upstream failures transient.
+func validateBTNClientSession(ctx context.Context, client *http.Client, baseURL string) error {
+	if client == nil {
+		return errors.New("trackers: BTN session client missing")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+btnUploadPath, nil)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN upload auth request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN upload auth request: %w", err)
+	}
+	defer resp.Body.Close()
+	finalPath := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalPath = strings.ToLower(resp.Request.URL.EscapedPath())
+	}
+	body, readErr := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
+	if readErr != nil {
+		return fmt.Errorf("trackers: BTN read upload auth response: %w", readErr)
+	}
+	bodyText := string(body)
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || strings.Contains(finalPath, "login") ||
+		btnLoggedOutPage(bodyText) {
+		return fmt.Errorf("%w: login required", errBTNSessionConfirmedInvalid)
+	}
+	if resp.StatusCode >= 500 {
+		return fmt.Errorf("trackers: BTN upload auth unavailable status=%d", resp.StatusCode)
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("trackers: BTN upload auth failed status=%d", resp.StatusCode)
+	}
+	if !btnLooksLikeUploadPage(bodyText) {
+		return errors.New("trackers: BTN upload auth page validation failed")
+	}
+	return nil
+}
+
+func prepareUploadData(ctx context.Context, req trackers.PreparationInput, uploadCtx uploadContext) (map[string]string, error) {
+	if _, err := validateBTNTVPayloadMetadata(req.Meta); err != nil {
+		return nil, err
+	}
+
+	autofillPayload, uploadType := buildBTNAutofillPayload(req.Meta)
+	fields, err := requestBTNAutofillFields(ctx, uploadCtx, autofillPayload, uploadType)
+	if err != nil {
+		return nil, err
+	}
+	return buildBTNUploadPayload(req, fields)
+}
+
+// buildBTNAutofillPayload returns the form fields for BTN's first upload.php
+// POST. TVDB-backed uploads submit the series id plus season or episode token;
+// scene-name autofill is used only when no TVDB series id is available.
+func buildBTNAutofillPayload(meta api.UploadSubject) (url.Values, string) {
+	autofillPayload := url.Values{}
+	uploadType := resolveUploadType(meta)
+	season, episode := resolveBTNTVSeasonEpisode(meta)
+	autofillPayload.Set("type", uploadType)
+	autofillPayload.Set("tvdb", "Get Info")
+
+	if meta.Identity.TVDBID > 0 {
+		autofillPayload.Set("scene_yesno", "No")
+		autofillPayload.Set("auto_series", strconv.Itoa(meta.Identity.TVDBID))
+
+		if uploadType == "Episode" {
+			autofillPayload.Set("auto_title", fmt.Sprintf("S%02dE%02d", season, episode))
+		} else {
+			autofillPayload.Set("auto_season", fmt.Sprintf("S%02d", season))
+		}
+	} else {
+		autofillPayload.Set("scene_yesno", "Yes")
+		autofillPayload.Set("autofill", resolveUploadName(meta))
+	}
+
+	return autofillPayload, uploadType
+}
+
+// requestBTNAutofillFields performs BTN's autofill POST and extracts the form
+// values returned for the final upload payload. A validation failure means BTN
+// did not return enough series/title data for the requested upload type.
+func requestBTNAutofillFields(ctx context.Context, uploadCtx uploadContext, autofillPayload url.Values, uploadType string) (map[string]string, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadCtx.uploadURL, strings.NewReader(autofillPayload.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN autofill request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := uploadCtx.client.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN autofill request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("trackers: BTN autofill failed status=%d", resp.StatusCode)
+	}
+	htmlPayload, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN read autofill response: %w", err)
+	}
+	fields := extractAutofillFields(string(htmlPayload))
+	if !validateAutofill(fields, uploadType) {
+		return nil, errors.New("trackers: BTN autofill validation failed")
+	}
+	return fields, nil
+}
+
+// buildBTNUploadPayload merges BTN autofill fields with local metadata for the
+// final upload form. BTN text fields such as album_desc are retained, release_desc
+// is populated only from MediaInfo text, and local MediaInfo-derived dropdown
+// mappings win when both sources provide a BTN-supported value.
+func buildBTNUploadPayload(req trackers.PreparationInput, fields map[string]string) (map[string]string, error) {
+	format := mapContainer(req.Meta, fields)
+	bitrate := mapCodec(req.Meta, fields)
+	media := mapSource(req.Meta, fields)
+	if format == "" || bitrate == "" || media == "" {
+		return nil, fmt.Errorf("trackers: BTN dropdown mapping failed format=%q bitrate=%q media=%q", format, bitrate, media)
+	}
+
+	title := metautil.FirstNonEmptyTrimmed(fields["title"])
+	if resolveUploadType(req.Meta) == "Season" && title != "" {
+		isNumeric := true
+		for _, r := range title {
+			if r < '0' || r > '9' {
+				isNumeric = false
+				break
+			}
+		}
+		if isNumeric {
+			title = "Season " + title
+		}
+	}
+
+	resolution := mapResolution(req.Meta, fields)
+	logBTNAutofillMismatch(req.Logger, "format", format, fields["format"])
+	logBTNAutofillMismatch(req.Logger, "bitrate", bitrate, fields["bitrate"])
+	logBTNAutofillMismatch(req.Logger, "media", media, fields["media"])
+	logBTNAutofillMismatch(req.Logger, "resolution", resolution, fields["resolution"])
+	payload := map[string]string{
+		"submit":       "true",
+		"type":         resolveUploadType(req.Meta),
+		"scenename":    applyBTNNameMapping(resolveUploadName(req.Meta), bitrate, media),
+		"seriesid":     metautil.FirstNonEmptyTrimmed(fields["seriesid"]),
+		"artist":       metautil.FirstNonEmptyTrimmed(fields["artist"]),
+		"title":        title,
+		"actors":       metautil.FirstNonEmptyTrimmed(fields["actors"]),
+		"origin":       resolveOrigin(req.Meta),
+		"year":         metautil.FirstNonEmptyTrimmed(fields["year"]),
+		"tags":         resolveBTNTags(req.Meta, fields),
+		"image":        resolveBTNImage(req.Meta, fields),
+		"album_desc":   buildAlbumDesc(req.Meta, fields),
+		"format":       format,
+		"bitrate":      bitrate,
+		"media":        media,
+		"resolution":   resolution,
+		"release_desc": resolveBTNReleaseDesc(req.Meta),
+		"tvdb":         "autofilled",
+	}
+	if resolveFastTorrent(req.TrackerConfig) {
+		payload["fasttorrent"] = "on"
+	}
+	if language := resolveBTNOriginalLanguage(req.Meta); language != "" && !isBTNEnglishLanguage(language) {
+		payload["foreign"] = "on"
+		if countryID := resolveCountryID(req.Meta); countryID != "" {
+			payload["country"] = countryID
+		}
+	}
+	clean := make(map[string]string, len(payload))
+	for key, value := range payload {
+		if key != "release_desc" && strings.TrimSpace(value) == "" {
+			continue
+		}
+		clean[key] = value
+	}
+	return clean, nil
+}
+
+// resolveBTNReleaseDesc returns the MediaInfo text BTN expects in release_desc.
+// Description overrides are intentionally ignored for this field.
+func resolveBTNReleaseDesc(meta api.UploadSubject) string {
+	return strings.TrimSpace(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath))
+}
+
+// urlValuesToPayloadMap flattens form values for debug display; BTN autofill
+// fields are single-valued, so later values are intentionally ignored.
+func urlValuesToPayloadMap(values url.Values) map[string]string {
+	out := make(map[string]string, len(values))
+	for key, value := range values {
+		if len(value) == 0 {
+			continue
+		}
+		out[key] = value[0]
+	}
+	return out
+}
+
+// logBTNAutofillMismatch records when BTN autofill selected a different
+// dropdown value than local metadata. The upload still uses metadata because
+// autofill runs before MediaInfo or final upload fields are submitted.
+func logBTNAutofillMismatch(logger api.Logger, field string, metadataValue string, autofillValue string) {
+	if logger == nil {
+		return
+	}
+	field = strings.TrimSpace(field)
+	metadataValue = strings.TrimSpace(metadataValue)
+	autofillValue = strings.TrimSpace(autofillValue)
+	if field == "" || metadataValue == "" || autofillValue == "" || metadataValue == autofillValue {
+		return
+	}
+	logger.Infof("trackers: BTN autofill %s mismatch metadata_%s=%q autofill_%s=%q decision=metadata", field, field, metadataValue, field, autofillValue)
+}
+
+// resolveBTNTags keeps BTN autofill genres when present and otherwise maps
+// TVDB then IMDb genres to BTN-supported tag labels.
+func resolveBTNTags(meta api.UploadSubject, fields map[string]string) string {
+	if tags := strings.TrimSpace(fields["tags"]); tags != "" {
+		return tags
+	}
+	if meta.ProviderMetadata.TVDB != nil {
+		if tags := mapBTNGenres(meta.ProviderMetadata.TVDB.Genres); tags != "" {
+			return tags
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return mapBTNGenres(meta.ProviderMetadata.IMDB.Genres)
+	}
+	return ""
+}
+
+// resolveBTNImage keeps BTN autofill poster data when present. Empty autofill
+// falls back through TVDB, IMDb, TVmaze, then TMDB poster metadata.
+func resolveBTNImage(meta api.UploadSubject, fields map[string]string) string {
+	if image := strings.TrimSpace(fields["image"]); image != "" {
+		return image
+	}
+	if meta.ProviderMetadata.TVDB != nil {
+		if poster := strings.TrimSpace(meta.ProviderMetadata.TVDB.Poster); poster != "" {
+			return poster
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		if poster := strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover); poster != "" {
+			return poster
+		}
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		if poster := strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster); poster != "" {
+			return poster
+		}
+		if poster := strings.TrimSpace(meta.ProviderMetadata.TVmaze.PosterMedium); poster != "" {
+			return poster
+		}
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	}
+	return ""
+}
+
+// mapBTNGenres converts provider genre text to comma-separated BTN genre tags.
+// Unrecognized genres are omitted instead of being submitted as free-form tags.
+func mapBTNGenres(genres string) string {
+	normalized := normalizeBTNGenreText(genres)
+	if normalized == "" {
+		return ""
+	}
+	type genreAlias struct {
+		label   string
+		aliases []string
+	}
+	allowed := []genreAlias{
+		{label: "Action", aliases: []string{"action"}},
+		{label: "Adventure", aliases: []string{"adventure"}},
+		{label: "Animation", aliases: []string{"animation"}},
+		{label: "Anime", aliases: []string{"anime"}},
+		{label: "Awards Show", aliases: []string{"awards show"}},
+		{label: "Children", aliases: []string{"children", "kids"}},
+		{label: "Comedy", aliases: []string{"comedy"}},
+		{label: "Crime", aliases: []string{"crime"}},
+		{label: "Documentary", aliases: []string{"documentary"}},
+		{label: "Drama", aliases: []string{"drama"}},
+		{label: "Family", aliases: []string{"family"}},
+		{label: "Fantasy", aliases: []string{"fantasy"}},
+		{label: "Food", aliases: []string{"food"}},
+		{label: "Game Show", aliases: []string{"game show"}},
+		{label: "History", aliases: []string{"history"}},
+		{label: "Home and Garden", aliases: []string{"home and garden", "home garden"}},
+		{label: "Horror", aliases: []string{"horror"}},
+		{label: "Indie", aliases: []string{"indie"}},
+		{label: "Martial Arts", aliases: []string{"martial arts"}},
+		{label: "Mini-Series", aliases: []string{"mini series", "miniseries"}},
+		{label: "Musical", aliases: []string{"musical", "music"}},
+		{label: "Mystery", aliases: []string{"mystery"}},
+		{label: "News", aliases: []string{"news"}},
+		{label: "Podcast", aliases: []string{"podcast"}},
+		{label: "Reality", aliases: []string{"reality"}},
+		{label: "Romance", aliases: []string{"romance"}},
+		{label: "Science Fiction", aliases: []string{"science fiction", "sci fi", "scifi"}},
+		{label: "Soap", aliases: []string{"soap"}},
+		{label: "Sport", aliases: []string{"sport", "sports"}},
+		{label: "Suspense", aliases: []string{"suspense"}},
+		{label: "Talk Show", aliases: []string{"talk show"}},
+		{label: "Thriller", aliases: []string{"thriller"}},
+		{label: "Travel", aliases: []string{"travel"}},
+		{label: "War", aliases: []string{"war"}},
+		{label: "Western", aliases: []string{"western"}},
+	}
+	tags := make([]string, 0, len(allowed))
+	for _, genre := range allowed {
+		for _, alias := range genre.aliases {
+			if normalizedBTNGenreContains(normalized, alias) {
+				tags = append(tags, genre.label)
+				break
+			}
+		}
+	}
+	return strings.Join(tags, ", ")
+}
+
+// normalizeBTNGenreText lowercases and strips common separators so source
+// genre text and local aliases can be compared consistently.
+func normalizeBTNGenreText(value string) string {
+	replacer := strings.NewReplacer(
+		"&", " and ",
+		"/", " ",
+		";", " ",
+		":", " ",
+		".", " ",
+		",", " ",
+		"-", " ",
+		"_", " ",
+		"(", " ",
+		")", " ",
+	)
+	return strings.Join(strings.Fields(replacer.Replace(strings.ToLower(strings.TrimSpace(value)))), " ")
+}
+
+// normalizedBTNGenreContains reports whether a normalized genre list contains
+// an alias as a complete token sequence.
+func normalizedBTNGenreContains(normalized string, alias string) bool {
+	alias = normalizeBTNGenreText(alias)
+	return strings.Contains(" "+normalized+" ", " "+alias+" ")
+}
+
+// extractAutofillFields reads BTN's autofilled upload form into the field map
+// consumed by final payload construction. Input values, selected dropdown
+// values, and the album_desc textarea are normalized to lower-case field names.
+func extractAutofillFields(htmlRaw string) map[string]string {
+	fields := map[string]string{}
+	for _, match := range btnInputPattern.FindAllStringSubmatch(htmlRaw, -1) {
+		if len(match) < 3 {
+			continue
+		}
+		fields[strings.ToLower(strings.TrimSpace(match[1]))] = html.UnescapeString(strings.TrimSpace(match[2]))
+	}
+	if match := btnTextAreaPattern.FindStringSubmatch(htmlRaw); len(match) > 1 {
+		fields["album_desc"] = html.UnescapeString(strings.TrimSpace(stripHTML(match[1])))
+	}
+	for _, selectMatch := range btnSelectPattern.FindAllStringSubmatch(htmlRaw, -1) {
+		if len(selectMatch) < 3 {
+			continue
+		}
+		name := strings.ToLower(strings.TrimSpace(selectMatch[1]))
+		body := selectMatch[2]
+		if value := selectedBTNAutofillOptionValue(body); value != "" {
+			fields[name] = value
+		}
+	}
+	return fields
+}
+
+// selectedBTNAutofillOptionValue returns the selected option value regardless
+// of attribute order, falling back to the first option value when no option is
+// marked selected.
+func selectedBTNAutofillOptionValue(body string) string {
+	tokenizer := xhtml.NewTokenizer(strings.NewReader(body))
+	firstValue := ""
+	for {
+		switch tokenizer.Next() {
+		case xhtml.ErrorToken:
+			return firstValue
+		case xhtml.StartTagToken, xhtml.SelfClosingTagToken:
+			token := tokenizer.Token()
+			if !strings.EqualFold(token.Data, "option") {
+				continue
+			}
+			value := ""
+			selected := false
+			for _, attr := range token.Attr {
+				switch {
+				case strings.EqualFold(attr.Key, "value"):
+					value = html.UnescapeString(strings.TrimSpace(attr.Val))
+				case strings.EqualFold(attr.Key, "selected"):
+					selected = true
+				}
+			}
+			if value == "" {
+				continue
+			}
+			if firstValue == "" {
+				firstValue = value
+			}
+			if selected {
+				return value
+			}
+		case xhtml.TextToken, xhtml.EndTagToken, xhtml.CommentToken, xhtml.DoctypeToken:
+			continue
+		}
+	}
+}
+
+// validateAutofill reports whether BTN returned the minimum autofill fields
+// needed for the requested upload type. Episodes require a title; season packs
+// only require a series artist.
+func validateAutofill(fields map[string]string, uploadType string) bool {
+	artist := strings.TrimSpace(fields["artist"])
+	title := strings.TrimSpace(fields["title"])
+	if artist == "" {
+		return false
+	}
+	if uploadType == "Episode" && title == "" {
+		return false
+	}
+	if strings.EqualFold(artist, "autofill fail") || strings.EqualFold(title, "autofill fail") {
+		return false
+	}
+	return true
+}
+
+// preferredBTNTVDBEpisodeTitle returns TVDB's English episode title when it is
+// available, falling back to the original-language title.
+func preferredBTNTVDBEpisodeTitle(tvdb *api.TVDBMetadata) string {
+	if tvdb == nil {
+		return ""
+	}
+	return metautil.FirstNonEmptyTrimmed(strings.TrimSpace(tvdb.EpisodeNameEnglish), strings.TrimSpace(tvdb.EpisodeName))
+}
+
+// preferredBTNIMDBEpisodeTitle returns the selected IMDb episode title when an
+// episode-specific IMDb entry can be matched to the upload metadata.
+func preferredBTNIMDBEpisodeTitle(meta api.UploadSubject) string {
+	if episode := preferredBTNIMDBEpisode(meta); episode != nil {
+		return strings.TrimSpace(episode.Title)
+	}
+	return ""
+}
+
+// preferredBTNTVDBOverview returns TVDB episode overview text before series
+// overview text, using English translations before original-language values.
+func preferredBTNTVDBOverview(tvdb *api.TVDBMetadata) string {
+	if tvdb == nil {
+		return ""
+	}
+	return metautil.FirstNonEmptyTrimmed(
+		strings.TrimSpace(tvdb.EpisodeOverviewEnglish),
+		strings.TrimSpace(tvdb.EpisodeOverview),
+		strings.TrimSpace(tvdb.OverviewEnglish),
+		strings.TrimSpace(tvdb.Overview),
+	)
+}
+
+// preferredBTNIMDBOverview returns IMDb plot text when TVDB overview data is
+// unavailable for the BTN description block.
+func preferredBTNIMDBOverview(imdb *api.IMDBMetadata) string {
+	if imdb == nil {
+		return ""
+	}
+	return strings.TrimSpace(imdb.Plot)
+}
+
+// buildAlbumDesc keeps BTN's autofilled album_desc when available. If BTN did
+// not return one, TV uploads fall back to BBCode episode blocks from TVDB or
+// provider/local episode metadata.
+func buildAlbumDesc(meta api.UploadSubject, fields map[string]string) string {
+	if desc := metautil.FirstNonEmptyTrimmed(fields["album_desc"]); desc != "" {
+		return desc
+	}
+	if !strings.EqualFold(strings.TrimSpace(string(meta.Identity.Category)), "TV") {
+		return ""
+	}
+	if desc := buildTVDBAlbumDesc(meta); desc != "" {
+		return desc
+	}
+	tvdb := meta.ProviderMetadata.TVDB
+	overview := metautil.FirstNonEmptyTrimmed(
+		preferredBTNTVDBOverview(tvdb),
+		preferredBTNIMDBOverview(meta.ProviderMetadata.IMDB),
+		strings.TrimSpace(meta.EpisodeOverview),
+	)
+	aired := metautil.FirstNonEmptyTrimmed(
+		btnTVDBEpisodeAired(tvdb),
+		btnIMDBEpisodeAired(meta),
+		strings.TrimSpace(meta.TVDBAiredDate),
+		strings.TrimSpace(meta.DailyEpisodeDate),
+		"TBA",
+	)
+	season, episode := resolveBTNTVSeasonEpisode(meta)
+	episodeTitle := metautil.FirstNonEmptyTrimmed(
+		preferredBTNTVDBEpisodeTitle(tvdb),
+		preferredBTNIMDBEpisodeTitle(meta),
+		strings.TrimSpace(meta.EpisodeTitle),
+		"TBA",
+	)
+	return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{{
+		SeasonNumber:    season,
+		EpisodeNumber:   episode,
+		EpisodeName:     episodeTitle,
+		EpisodeOverview: overview,
+		EpisodeAired:    aired,
+	}})
+}
+
+// buildTVDBAlbumDesc builds BTN album_desc from TVDB data only. Episode uploads
+// use the selected episode; season-pack uploads use every fetched episode in
+// the selected season.
+func buildTVDBAlbumDesc(meta api.UploadSubject) string {
+	tvdb := meta.ProviderMetadata.TVDB
+	if tvdb == nil {
+		return ""
+	}
+	season, episode := resolveBTNTVSeasonEpisode(meta)
+	if resolveUploadType(meta) == "Season" {
+		episodes := make([]api.TVDBEpisodeMetadata, 0, len(tvdb.Episodes))
+		for _, candidate := range tvdb.Episodes {
+			if candidate.SeasonNumber == season {
+				episodes = append(episodes, candidate)
+			}
+		}
+		sort.SliceStable(episodes, func(i, j int) bool {
+			return episodes[i].EpisodeNumber < episodes[j].EpisodeNumber
+		})
+		return formatBTNEpisodeAlbumDesc(episodes)
+	}
+	for _, candidate := range tvdb.Episodes {
+		if candidate.SeasonNumber == season && candidate.EpisodeNumber == episode {
+			return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{candidate})
+		}
+	}
+	if tvdb.EpisodeSeason > 0 || tvdb.EpisodeNumber > 0 || strings.TrimSpace(tvdb.EpisodeName) != "" || strings.TrimSpace(tvdb.EpisodeOverview) != "" {
+		return formatBTNEpisodeAlbumDesc([]api.TVDBEpisodeMetadata{{
+			SeasonNumber:           tvdb.EpisodeSeason,
+			EpisodeNumber:          tvdb.EpisodeNumber,
+			EpisodeName:            tvdb.EpisodeName,
+			EpisodeNameEnglish:     tvdb.EpisodeNameEnglish,
+			EpisodeOverview:        tvdb.EpisodeOverview,
+			EpisodeOverviewEnglish: tvdb.EpisodeOverviewEnglish,
+			EpisodeAired:           tvdb.EpisodeAired,
+			EpisodeImage:           tvdb.EpisodeImage,
+		}})
+	}
+	return ""
+}
+
+// formatBTNEpisodeAlbumDesc renders each episode as the BBCode block expected
+// by BTN's album_desc field. Empty input returns an empty string.
+func formatBTNEpisodeAlbumDesc(episodes []api.TVDBEpisodeMetadata) string {
+	blocks := make([]string, 0, len(episodes))
+	for _, episode := range episodes {
+		title := metautil.FirstNonEmptyTrimmed(episode.EpisodeNameEnglish, episode.EpisodeName, "TBA")
+		overview := metautil.FirstNonEmptyTrimmed(episode.EpisodeOverviewEnglish, episode.EpisodeOverview)
+		aired := metautil.FirstNonEmptyTrimmed(episode.EpisodeAired, "TBA")
+		var block strings.Builder
+		block.WriteString("[b]Episode Name:[/b] ")
+		block.WriteString(title)
+		block.WriteString("\n[b]Season:[/b] ")
+		block.WriteString(strconv.Itoa(episode.SeasonNumber))
+		block.WriteString("\n[b]Episode:[/b] ")
+		block.WriteString(strconv.Itoa(episode.EpisodeNumber))
+		block.WriteString("\n[b]Aired:[/b] ")
+		block.WriteString(aired)
+		block.WriteString("\n\n[b]Episode overview:[/b]\n")
+		block.WriteString(overview)
+		if image := strings.TrimSpace(episode.EpisodeImage); image != "" {
+			block.WriteString("\n\n[b]Episode image:[/b]\n[img=")
+			block.WriteString(image)
+			block.WriteString("]")
+		}
+		blocks = append(blocks, strings.TrimSpace(block.String()))
+	}
+	return strings.Join(blocks, "\n\n")
+}
+
+// btnTVDBEpisodeAired returns the TVDB episode air date used in BTN-generated
+// description text. An empty value leaves metadata date fallbacks in control.
+func btnTVDBEpisodeAired(tvdb *api.TVDBMetadata) string {
+	if tvdb == nil {
+		return ""
+	}
+	return strings.TrimSpace(tvdb.EpisodeAired)
+}
+
+// btnIMDBEpisodeAired returns the selected IMDb episode release date in the
+// most specific YYYY[-MM[-DD]] form available.
+func btnIMDBEpisodeAired(meta api.UploadSubject) string {
+	episode := preferredBTNIMDBEpisode(meta)
+	if episode == nil || episode.ReleaseDate.Year <= 0 {
+		return ""
+	}
+	if episode.ReleaseDate.Month <= 0 {
+		return strconv.Itoa(episode.ReleaseDate.Year)
+	}
+	if episode.ReleaseDate.Day <= 0 {
+		return fmt.Sprintf("%04d-%02d", episode.ReleaseDate.Year, episode.ReleaseDate.Month)
+	}
+	return fmt.Sprintf("%04d-%02d-%02d", episode.ReleaseDate.Year, episode.ReleaseDate.Month, episode.ReleaseDate.Day)
+}
+
+// preferredBTNIMDBEpisode returns the IMDb episode entry for this upload when
+// the canonical season and episode identify one, or the sole available IMDb
+// episode when the metadata payload already represents a single episode.
+func preferredBTNIMDBEpisode(meta api.UploadSubject) *api.IMDBEpisode {
+	if meta.ProviderMetadata.IMDB == nil || len(meta.ProviderMetadata.IMDB.Episodes) == 0 {
+		return nil
+	}
+	episodes := meta.ProviderMetadata.IMDB.Episodes
+	season, episode := meta.CanonicalSeasonEpisode()
+	if season > 0 && episode > 0 {
+		for i := range episodes {
+			if episodes[i].Season != season {
+				continue
+			}
+			if btnIMDBEpisodeNumber(episodes[i].EpisodeText) == episode {
+				return &episodes[i]
+			}
+		}
+	}
+	if len(episodes) == 1 {
+		return &episodes[0]
+	}
+	return nil
+}
+
+// btnIMDBEpisodeNumber parses IMDb episode text such as "7", "E07", or
+// "Episode 7" into the numeric episode value BTN expects.
+func btnIMDBEpisodeNumber(value string) int {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return 0
+	}
+	if parsed, err := strconv.Atoi(value); err == nil {
+		return parsed
+	}
+	matches := btnIMDBEpisodePattern.FindStringSubmatch(value)
+	if len(matches) < 2 {
+		return 0
+	}
+	parsed, err := strconv.Atoi(matches[1])
+	if err != nil {
+		return 0
+	}
+	return parsed
+}
+
+// validateBTNTVPayloadMetadata returns the shared BTN TV metadata block reason
+// used by live upload, autofill, and dry-run when canonical season or episode
+// data is missing.
+func validateBTNTVPayloadMetadata(meta api.UploadSubject) (string, error) {
+	message := btnTVPayloadMetadataMessage(meta)
+	if message == "" {
+		return "", nil
+	}
+	return message, errors.New("trackers: BTN " + message)
+}
+
+func resolveUploadType(meta api.UploadSubject) string {
+	if meta.TVPack {
+		return "Season"
+	}
+	_, episode := resolveBTNTVSeasonEpisode(meta)
+	if episode > 0 {
+		return "Episode"
+	}
+	return "Season"
+}
+
+// resolveBTNTVSeasonEpisode returns the season and episode numbers BTN should
+// use for generated request and description fields. TVDB episode numbers win
+// over IMDb episode data, then metadata ints; missing values fall back
+// independently.
+func resolveBTNTVSeasonEpisode(meta api.UploadSubject) (int, int) {
+	season, episode := meta.CanonicalSeasonEpisode()
+	tvdb := meta.ProviderMetadata.TVDB
+	imdbEpisode := preferredBTNIMDBEpisode(meta)
+	if tvdb != nil && tvdb.EpisodeSeason > 0 {
+		season = meta.ProviderMetadata.TVDB.EpisodeSeason
+	} else if imdbEpisode != nil && imdbEpisode.Season > 0 {
+		season = imdbEpisode.Season
+	}
+	if tvdb != nil && tvdb.EpisodeNumber > 0 {
+		episode = meta.ProviderMetadata.TVDB.EpisodeNumber
+	} else if imdbEpisode != nil {
+		if imdbEpisodeNumber := btnIMDBEpisodeNumber(imdbEpisode.EpisodeText); imdbEpisodeNumber > 0 {
+			episode = imdbEpisodeNumber
+		}
+	}
+	return season, episode
+}
+
+// btnTVPayloadMetadataMessage explains when BTN cannot build TV season or
+// episode fields because canonical metadata is absent. Parsed release values are
+// reported only as ignored signals, and the message includes the operator action
+// required by blocked dry-run entries.
+func btnTVPayloadMetadataMessage(meta api.UploadSubject) string {
+	if !strings.EqualFold(strings.TrimSpace(string(meta.Identity.Category)), "TV") {
+		return ""
+	}
+	missing := make([]string, 0, 2)
+	ignored := make([]string, 0, 2)
+	season, episode := resolveBTNTVSeasonEpisode(meta)
+	if season <= 0 {
+		missing = append(missing, "season")
+		if meta.Release.Season > 0 {
+			ignored = append(ignored, "season")
+		}
+	}
+	if episode <= 0 && !meta.TVPack {
+		missing = append(missing, "episode")
+		if meta.Release.Episode > 0 {
+			ignored = append(ignored, "episode")
+		}
+	}
+	if len(missing) == 0 {
+		return ""
+	}
+	message := "canonical TV " + strings.Join(missing, "/") + " missing; BTN upload requires TVDB or metadata season/episode ints"
+	if len(ignored) > 0 {
+		message += " and ignores parsed " + strings.Join(ignored, "/") + " fallback"
+	}
+	message += "; refresh metadata or correct canonical season/episode before upload"
+	return message
+}
+
+// resolveOrigin derives the origin from
+// prepared scene and season-pack metadata, group tag and username
+func resolveOrigin(meta api.UploadSubject) string {
+	group := strings.TrimSpace(meta.Release.Group)
+	if seasonPackHasMixedGroups(meta) {
+		return "Mixed"
+	}
+	if isBTNSceneRelease(meta) {
+		return "Scene"
+	}
+	if group != "" && isNoGroupTag(group) || isBTNInternalGroup(meta) {
+		return "None"
+	}
+	return "P2P"
+}
+
+func seasonPackHasMixedGroups(meta api.UploadSubject) bool {
+	if !meta.TVPack || len(meta.FileList) < 2 {
+		return false
+	}
+
+	groups := make(map[string]struct{})
+	for _, file := range meta.FileList {
+		base := pathutil.Base(strings.TrimSpace(file))
+		if base == "" || base == "." || base == "/" {
+			continue
+		}
+		parsed := rls.ParseString(base)
+		group := strings.TrimSpace(parsed.Group)
+		if group == "" {
+			site := strings.TrimSpace(parsed.Site)
+			if site != "" && strings.HasPrefix(strings.TrimSpace(base), "["+site+"]") {
+				group = site
+			}
+		}
+		group = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(group, "-")))
+		switch group {
+		case "", "nogrp", "nogroup", "unknown", "unk":
+			continue
+		}
+		groups[group] = struct{}{}
+		if len(groups) > 1 {
+			return true
+		}
+	}
+	return false
+}
+
+// stripEpisodeTitle removes generated episode-title text from BTN upload names
+// unless the original filename already carried the same token sequence.
+func stripEpisodeTitle(name string, episodeTitle string, filename string) string {
+	if episodeTitle == "" || name == "" {
+		return name
+	}
+	if metautil.ReleaseNameContainsEpisodeTitle(filename, episodeTitle) {
+		return name
+	}
+	return metautil.RemoveEpisodeTitleFromReleaseName(name, episodeTitle)
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	var name string
+	if n := strings.TrimSpace(meta.ReleaseName); n != "" {
+		name = n
+	} else if n := strings.TrimSpace(meta.ReleaseNameNoTag); n != "" {
+		name = n
+	} else if n := strings.TrimSpace(meta.Filename); n != "" {
+		name = n
+	} else {
+		name = pathutil.Base(meta.SourcePath)
+	}
+	name = stripEpisodeTitle(name, meta.EpisodeTitle, btnEpisodeTitleFilename(meta))
+	name = cleanAndNormalizeBTNName(name)
+	return applyBTNNoGroupSuffix(name, meta)
+}
+
+// btnEpisodeTitleFilename returns the original filename text used to decide
+// whether BTN should preserve an episode title in the upload name.
+func btnEpisodeTitleFilename(meta api.UploadSubject) string {
+	return metautil.FirstNonEmptyTrimmed(meta.Filename, pathutil.Base(meta.SourcePath))
+}
+
+// applyBTNNoGroupSuffix preserves a valid prepared group tag for no-tag names
+// and falls back to BTN's NOGRP marker when no usable tag is available.
+func applyBTNNoGroupSuffix(name string, meta api.UploadSubject) string {
+	tag := strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-"))
+
+	if tag != "" && !isNoGroupTag(tag) {
+		if selectedBTNReleaseNameNoTag(name, meta) || !hasBTNGroupSuffix(name) {
+			return strings.TrimRight(name, ".-") + "-" + tag
+		}
+		return name
+	}
+
+	// Preserve an existing release-name suffix when parsing did not provide a
+	// group tag; only known placeholder suffixes should be normalized below.
+	if tag == "" && hasBTNGroupSuffix(name) && !hasBTNNoGroupSuffix(name) {
+		return name
+	}
+
+	noGroupPattern := regexp.MustCompile(`(?i)-(nogrp|nogroup|unknown|unk)$`)
+	normalizedName := noGroupPattern.ReplaceAllString(name, "")
+	normalizedName = strings.TrimRight(normalizedName, ".-")
+
+	return normalizedName + "-NOGRP"
+}
+
+// selectedBTNReleaseNameNoTag reports whether name is the normalized
+// ReleaseNameNoTag value chosen by resolveUploadName.
+func selectedBTNReleaseNameNoTag(name string, meta api.UploadSubject) bool {
+	if strings.TrimSpace(meta.ReleaseName) != "" || strings.TrimSpace(meta.ReleaseNameNoTag) == "" {
+		return false
+	}
+	candidate := stripEpisodeTitle(strings.TrimSpace(meta.ReleaseNameNoTag), meta.EpisodeTitle, btnEpisodeTitleFilename(meta))
+	candidate = cleanAndNormalizeBTNName(candidate)
+	return strings.TrimSpace(name) == candidate
+}
+
+// hasBTNGroupSuffix reports whether name already ends with a hyphenated BTN
+// group suffix.
+func hasBTNGroupSuffix(name string) bool {
+	return regexp.MustCompile(`-[^-.\s]+$`).MatchString(strings.TrimSpace(name))
+}
+
+// hasBTNNoGroupSuffix reports whether name ends with a placeholder group suffix
+// that BTN should normalize to NOGRP.
+func hasBTNNoGroupSuffix(name string) bool {
+	return regexp.MustCompile(`(?i)-(nogrp|nogroup|unknown|unk)$`).MatchString(strings.TrimSpace(name))
+}
+
+func isNoGroupTag(tag string) bool {
+	value := strings.ToLower(strings.TrimSpace(tag))
+	switch value {
+	case "nogrp", "nogroup", "unknown", "unk":
+		return true
+	default:
+		return false
+	}
+}
+
+func removeDiacritics(s string) string {
+	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	result, _, _ := transform.String(t, s)
+	return result
+}
+
+// cleanAndNormalizeBTNName converts prepared release names into BTN scene-name
+// syntax. It removes diacritics, uses dots as token separators, compacts known
+// audio channel tokens, and keeps hyphens for group tags.
+func cleanAndNormalizeBTNName(value string) string {
+	// 0. Remove diacritics
+	value = removeDiacritics(value)
+
+	// 1. Dot normalization (spaces to dots, collapse dots)
+	value = strings.Join(strings.Fields(value), " ")
+	value = strings.ReplaceAll(value, " ", ".")
+
+	// 2. Replace plus in DD+
+	value = strings.ReplaceAll(value, "DD+", "DDP")
+
+	for _, rule := range btnNameNormalizationRules {
+		value = rule.pattern.ReplaceAllString(value, rule.replacement)
+	}
+
+	return strings.TrimSpace(value)
+}
+
+func resolveTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
+	candidates := []string{strings.TrimSpace(meta.TorrentPath), strings.TrimSpace(meta.ClientTorrentPath), strings.TrimSpace(meta.SourcePath)}
+	for _, candidate := range candidates {
+		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
+			continue
+		}
+		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+			return candidate, nil
+		}
+	}
+	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
+		tmpRoot, err := db.Subdir(dbPath, "tmp")
+		if err == nil {
+			tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+			if err == nil {
+				guessed := filepath.Join(tmpDir, base+".torrent")
+				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
+					return guessed, nil
+				}
+			}
+		}
+	}
+	return "", errors.New("trackers: BTN torrent file not found")
+}
+
+// resolveBTNUploadFiles returns the multipart file parts BTN accepts for an
+// upload. Scene NFOs are attached only when scene metadata confirms the release
+// and the prepared NFO file still exists.
+func resolveBTNUploadFiles(meta api.UploadSubject, torrentPath string) []commonhttp.FileField {
+	files := []commonhttp.FileField{{
+		FieldName: "file_input",
+		Path:      torrentPath,
+		FileName:  "torrent.torrent",
+	}}
+	if nfoPath := resolveBTNSceneNFOPath(meta); nfoPath != "" {
+		files = append(files, commonhttp.FileField{
+			FieldName: "nfo",
+			Path:      nfoPath,
+			FileName:  filepath.Base(nfoPath),
+		})
+	}
+	return files
+}
+
+// resolveBTNDryRunFiles mirrors the upload file parts without reading file
+// content so previews show whether BTN will receive an NFO.
+func resolveBTNDryRunFiles(meta api.UploadSubject, torrentPath string) []api.TrackerDryRunFile {
+	files := []api.TrackerDryRunFile{{
+		Field:   "file_input",
+		Path:    torrentPath,
+		Present: strings.TrimSpace(torrentPath) != "",
+	}}
+	if nfoPath := resolveBTNSceneNFOPath(meta); nfoPath != "" {
+		files = append(files, api.TrackerDryRunFile{
+			Field:   "nfo",
+			Path:    nfoPath,
+			Present: true,
+		})
+	}
+	return files
+}
+
+func resolveBTNSceneNFOPath(meta api.UploadSubject) string {
+	if !isBTNSceneRelease(meta) {
+		return ""
+	}
+	nfoPath := strings.TrimSpace(meta.SceneNFOPath)
+	if nfoPath == "" {
+		return ""
+	}
+	if info, err := os.Stat(nfoPath); err == nil && !info.IsDir() {
+		return nfoPath
+	}
+	return ""
+}
+
+func isBTNSceneRelease(meta api.UploadSubject) bool {
+	return meta.Scene || strings.TrimSpace(meta.SceneName) != ""
+}
+
+func resolveTrackerTorrentPath(meta api.UploadSubject, dbPath string, tracker string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return "", errors.New("trackers: BTN tracker torrent path requires db path and source path")
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: BTN tmp root: %w", err)
+	}
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BTN tmp release dir: %w", err)
+	}
+	name := strings.ToLower(strings.TrimSpace(tracker))
+	if name == "" {
+		name = "tracker"
+	}
+	return filepath.Join(tmpDir, base+"."+name+".torrent"), nil
+}
+
+// writeBTNTorrentArtifact rewrites the uploaded torrent with the configured BTN
+// announce URL once the canonical torrent URL is known. A successful write lets
+// upload skip downloading BTN's generated torrent file.
+func writeBTNTorrentArtifact(sourcePath string, outputPath string, announceURL string, torrentURL string) error {
+	if err := trackers.WritePersonalizedTorrent(sourcePath, outputPath, announceURL, torrentURL, "BTN"); err != nil {
+		return fmt.Errorf("trackers: BTN write torrent artifact: %w", err)
+	}
+	return nil
+}
+
+// downloadTrackerTorrent fetches BTN's generated torrent file for uploads that
+// do not have a configured announce URL. Non-torrent responses are rejected so
+// callers can fall back to API resolution.
+func downloadTrackerTorrent(ctx context.Context, client *http.Client, baseURL string, torrentID string, outputPath string) error {
+	if strings.TrimSpace(torrentID) == "" {
+		return errors.New("trackers: BTN torrent_id missing")
+	}
+	downloadURL := strings.TrimRight(baseURL, "/") + "/torrents.php?action=download&id=" + url.QueryEscape(strings.TrimSpace(torrentID))
+	return downloadBTNTorrentURL(ctx, client, downloadURL, outputPath)
+}
+
+// downloadBTNTorrentURL fetches a BTN torrent download URL and writes only a
+// bencoded torrent payload to outputPath.
+func downloadBTNTorrentURL(ctx context.Context, client *http.Client, downloadURL string, outputPath string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN torrent download request build: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN torrent download request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("status %d", resp.StatusCode)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 8*1024*1024))
+	if err != nil {
+		return fmt.Errorf("trackers: BTN read torrent response: %w", err)
+	}
+	if len(body) == 0 || body[0] != 'd' {
+		return errors.New("not a torrent payload")
+	}
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
+		return fmt.Errorf("trackers: BTN create torrent output dir: %w", err)
+	}
+	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
+		return fmt.Errorf("trackers: BTN write torrent output: %w", err)
+	}
+	return nil
+}
+
+type btnUploadIntermediateResult struct {
+	groupID   string
+	torrentID string
+}
+
+// resolveBTNUploadIntermediatePage handles BTN's post-upload warning page that
+// requires continuing to the canonical torrent page before the final torrent id
+// is available. It returns handled=false for ordinary upload responses.
+func resolveBTNUploadIntermediatePage(
+	ctx context.Context,
+	client *http.Client,
+	baseURL string,
+	currentURL string,
+	body []byte,
+) (btnUploadIntermediateResult, bool, error) {
+	if !isBTNUploadIntermediatePage(body) {
+		return btnUploadIntermediateResult{}, false, nil
+	}
+
+	result := btnUploadIntermediateResult{}
+	detailURL, detailGroupID, detailTorrentID, ok := findBTNUploadDetailURL(baseURL, currentURL, body)
+	canonicalTorrentID := false
+	if ok {
+		result.groupID = detailGroupID
+		if detailTorrentID != "" {
+			result.torrentID = detailTorrentID
+			canonicalTorrentID = true
+		}
+	}
+
+	if !ok {
+		return result, true, errors.New("trackers: BTN intermediate page missing torrent detail link")
+	}
+	detailBody, detailFinalURL, err := fetchBTNTorrentDetailPage(ctx, client, detailURL)
+	if err != nil {
+		return result, true, err
+	}
+	if groupID, torrentID, matched := btnUploadIDsFromText(detailFinalURL); matched {
+		result.groupID = groupID
+		if torrentID != "" {
+			result.torrentID = torrentID
+			return result, true, nil
+		}
+	}
+	if groupID, torrentID, matched := btnUploadIDsFromText(string(detailBody)); matched {
+		result.groupID = groupID
+		if torrentID != "" {
+			result.torrentID = torrentID
+			return result, true, nil
+		}
+	}
+	if result.groupID == "" || !canonicalTorrentID {
+		return result, true, errors.New("trackers: BTN intermediate detail page missing canonical torrent id")
+	}
+	return result, true, nil
+}
+
+// isBTNUploadIntermediatePage detects BTN's warning page that appears after a
+// successful upload before the user has downloaded the generated torrent file.
+func isBTNUploadIntermediatePage(body []byte) bool {
+	normalized := strings.ToLower(html.UnescapeString(string(body)))
+	return strings.Contains(normalized, "download the torrent file") ||
+		strings.Contains(normalized, "need to download the torrent")
+}
+
+// findBTNUploadDetailURL extracts the same-origin canonical torrent page URL
+// from an intermediate BTN upload page.
+func findBTNUploadDetailURL(baseURL string, currentURL string, body []byte) (string, string, string, bool) {
+	for _, raw := range btnHTMLURLAttrPattern.FindAllStringSubmatch(string(body), -1) {
+		if len(raw) < 2 {
+			continue
+		}
+		candidate, ok := resolveBTNSameOriginURL(baseURL, currentURL, raw[1])
+		if !ok || !strings.EqualFold(candidate.Path, "/torrents.php") {
+			continue
+		}
+		query := candidate.Query()
+		if strings.EqualFold(query.Get("action"), "download") {
+			continue
+		}
+		groupID := strings.TrimSpace(query.Get("id"))
+		if groupID == "" {
+			continue
+		}
+		torrentID := strings.TrimSpace(query.Get("torrentid"))
+		return candidate.String(), groupID, torrentID, true
+	}
+	return "", "", "", false
+}
+
+// resolveBTNSameOriginURL resolves an HTML URL attribute against the current
+// BTN page and accepts only URLs on the configured BTN origin.
+func resolveBTNSameOriginURL(baseURL string, currentURL string, rawURL string) (*url.URL, bool) {
+	base, err := url.Parse(baseURL)
+	if err != nil || base.Scheme == "" || base.Host == "" {
+		return nil, false
+	}
+	referenceBase := base
+	if parsedCurrent, err := url.Parse(currentURL); err == nil && parsedCurrent.Scheme != "" && parsedCurrent.Host != "" {
+		referenceBase = parsedCurrent
+	}
+	rawURL = strings.TrimSpace(html.UnescapeString(rawURL))
+	if rawURL == "" {
+		return nil, false
+	}
+	parsed, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, false
+	}
+	resolved := referenceBase.ResolveReference(parsed)
+	if !strings.EqualFold(resolved.Scheme, base.Scheme) || !strings.EqualFold(resolved.Host, base.Host) {
+		return nil, false
+	}
+	return resolved, true
+}
+
+// fetchBTNTorrentDetailPage follows the intermediate-page continue target and
+// returns the bounded HTML body with the final URL after redirects.
+func fetchBTNTorrentDetailPage(ctx context.Context, client *http.Client, detailURL string) ([]byte, string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, detailURL, nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: BTN intermediate detail request build: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: BTN intermediate detail request: %w", err)
+	}
+	defer resp.Body.Close()
+	finalURL := detailURL
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, finalURL, fmt.Errorf("trackers: BTN intermediate detail failed status=%d", resp.StatusCode)
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
+	if err != nil {
+		return nil, finalURL, fmt.Errorf("trackers: BTN read intermediate detail response: %w", err)
+	}
+	return body, finalURL, nil
+}
+
+// btnUploadIDsFromText extracts BTN group and torrent ids from a URL or HTML
+// fragment, including HTML-escaped query separators.
+func btnUploadIDsFromText(value string) (string, string, bool) {
+	matches := btnSuccessURLPattern.FindStringSubmatch(html.UnescapeString(value))
+	if len(matches) < 2 {
+		return "", "", false
+	}
+	groupID := strings.TrimSpace(matches[1])
+	torrentID := ""
+	if len(matches) > 2 {
+		torrentID = strings.TrimSpace(matches[2])
+	}
+	return groupID, torrentID, groupID != ""
+}
+
+// buildBTNTorrentURL returns BTN's canonical torrent detail URL for a group and
+// optional torrent id.
+func buildBTNTorrentURL(baseURL string, groupID string, torrentID string) string {
+	torrentURL := strings.TrimRight(baseURL, "/") + "/torrents.php?id=" + url.QueryEscape(strings.TrimSpace(groupID))
+	if strings.TrimSpace(torrentID) != "" {
+		torrentURL += "&torrentid=" + url.QueryEscape(strings.TrimSpace(torrentID))
+	}
+	return torrentURL
+}
+
+// decodeBTNAPIJSON reads a bounded BTN JSON-RPC response, rejects duplicate
+// object keys, and unmarshals the single JSON value into dest.
+func decodeBTNAPIJSON(r io.Reader, dest any) error {
+	payload, err := io.ReadAll(io.LimitReader(r, btnAPIJSONMaxBytes+1))
+	if err != nil {
+		return fmt.Errorf("read response body: %w", err)
+	}
+	if len(payload) > btnAPIJSONMaxBytes {
+		return fmt.Errorf("response body exceeds %d bytes", btnAPIJSONMaxBytes)
+	}
+	if err := validateBTNJSONNoDuplicateObjectNames(payload); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(payload, dest); err != nil {
+		return fmt.Errorf("unmarshal response body: %w", err)
+	}
+	return nil
+}
+
+func callBTNAPI(ctx context.Context, apiURL, id, method string, params []any, dest any) error {
+	payload := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      id,
+		"method":  method,
+		"params":  params,
+	}
+	encoded, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN API %s encode: %w", method, err)
+	}
+	apiReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(encoded))
+	if err != nil {
+		return fmt.Errorf("trackers: BTN API %s request build: %w", method, err)
+	}
+	apiReq.Header.Set("Content-Type", "application/json")
+	apiResp, err := (&http.Client{Timeout: 30 * time.Second}).Do(apiReq)
+	if err != nil {
+		return fmt.Errorf("trackers: BTN API %s request: %w", method, err)
+	}
+	defer apiResp.Body.Close()
+	if apiResp.StatusCode < 200 || apiResp.StatusCode >= 300 {
+		return fmt.Errorf("trackers: BTN API %s failed status=%d", method, apiResp.StatusCode)
+	}
+	if err := decodeBTNAPIJSON(apiResp.Body, dest); err != nil {
+		return fmt.Errorf("trackers: BTN API decode %s response: %w", method, err)
+	}
+	return nil
+}
+
+// validateBTNJSONNoDuplicateObjectNames scans one JSON value before unmarshal
+// so duplicate object names cannot collapse into the last decoded value.
+func validateBTNJSONNoDuplicateObjectNames(payload []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(payload))
+	dec.UseNumber()
+	if err := validateBTNJSONValueNoDuplicateObjectNames(dec, ""); err != nil {
+		return err
+	}
+	if _, err := dec.Token(); err != io.EOF {
+		if err == nil {
+			return errors.New("multiple JSON values")
+		}
+		return fmt.Errorf("read trailing JSON token: %w", err)
+	}
+	return nil
+}
+
+// validateBTNJSONValueNoDuplicateObjectNames consumes one JSON value and
+// reports duplicate object member names with their object path.
+func validateBTNJSONValueNoDuplicateObjectNames(dec *json.Decoder, path string) error {
+	token, err := dec.Token()
+	if err != nil {
+		return fmt.Errorf("read JSON token at %q: %w", path, err)
+	}
+	delim, ok := token.(json.Delim)
+	if !ok {
+		return nil
+	}
+
+	switch delim {
+	case '{':
+		seen := map[string]struct{}{}
+		for dec.More() {
+			keyToken, err := dec.Token()
+			if err != nil {
+				return fmt.Errorf("read JSON object key at %q: %w", path, err)
+			}
+			key, ok := keyToken.(string)
+			if !ok {
+				return fmt.Errorf("invalid JSON object key at %q", path)
+			}
+			if _, exists := seen[key]; exists {
+				if path == "" {
+					return fmt.Errorf("duplicate JSON object key %q", key)
+				}
+				return fmt.Errorf("duplicate JSON object key %q at %q", key, path)
+			}
+			seen[key] = struct{}{}
+			childPath := key
+			if path != "" {
+				childPath = path + "." + key
+			}
+			if err := validateBTNJSONValueNoDuplicateObjectNames(dec, childPath); err != nil {
+				return err
+			}
+		}
+		return consumeBTNJSONDelim(dec, '}')
+	case '[':
+		index := 0
+		for dec.More() {
+			childPath := fmt.Sprintf("%s[%d]", path, index)
+			if err := validateBTNJSONValueNoDuplicateObjectNames(dec, childPath); err != nil {
+				return err
+			}
+			index++
+		}
+		return consumeBTNJSONDelim(dec, ']')
+	default:
+		return fmt.Errorf("unexpected JSON delimiter %q at %q", delim, path)
+	}
+}
+
+// consumeBTNJSONDelim consumes and verifies a JSON closing delimiter.
+func consumeBTNJSONDelim(dec *json.Decoder, want json.Delim) error {
+	token, err := dec.Token()
+	if err != nil {
+		return fmt.Errorf("read JSON delimiter %q: %w", want, err)
+	}
+	if delim, ok := token.(json.Delim); !ok || delim != want {
+		return fmt.Errorf("expected JSON delimiter %q", want)
+	}
+	return nil
+}
+
+// resolveAndDownloadViaAPI finds the uploaded torrent through BTN's JSON-RPC
+// API, validates the returned DownloadURL, and writes the fetched bencoded
+// torrent to outputPath. The selected BTN torrent and group ids are returned
+// so upload summaries reflect the torrent that was actually downloaded.
+func resolveAndDownloadViaAPI(
+	ctx context.Context,
+	apiURL string,
+	apiToken string,
+	req trackers.PreparationInput,
+	groupID string,
+	outputPath string,
+) (string, string, error) {
+	if strings.TrimSpace(apiToken) == "" {
+		return "", "", errors.New("trackers: BTN api token missing for torrent resolution")
+	}
+	if strings.TrimSpace(apiURL) == "" {
+		apiURL = btnAPIRPCURL
+	}
+	downloadOrigin, err := newBTNAPIDownloadOrigin(ctx, apiURL)
+	if err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API download origin: %w", err)
+	}
+	releaseName := resolveUploadName(req.Meta)
+	filter := map[string]any{"searchstr": releaseName}
+	if strings.TrimSpace(groupID) != "" {
+		filter["group"] = groupID
+	}
+
+	var response struct {
+		Result struct {
+			Torrents map[string]map[string]any `json:"torrents"`
+		} `json:"result"`
+	}
+	if err := callBTNAPI(ctx, apiURL, "ua-btn-upload", "getTorrentsSearch", []any{apiToken, filter, 50}, &response); err != nil {
+		return "", "", err
+	}
+
+	selection := selectBTNAPITorrent(response.Result.Torrents, releaseName, groupID)
+	if selection.ID == "" {
+		return "", "", errors.New("trackers: BTN API did not return a matching torrent id")
+	}
+
+	var downloadResult struct {
+		Result struct {
+			DownloadURL string `json:"DownloadURL"`
+		} `json:"result"`
+	}
+	if err := callBTNAPI(ctx, apiURL, "ua-btn-download", "getTorrentById", []any{apiToken, selection.ID}, &downloadResult); err != nil {
+		return "", "", err
+	}
+
+	if downloadResult.Result.DownloadURL == "" {
+		return "", "", errors.New("trackers: BTN API did not return DownloadURL")
+	}
+
+	if err := downloadOrigin.validateDownloadURL(ctx, downloadResult.Result.DownloadURL); err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API invalid download url: %w", err)
+	}
+
+	dlReq, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadResult.Result.DownloadURL, nil)
+	if err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API torrent fetch request build: %w", err)
+	}
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			if err := downloadOrigin.validateDownloadURL(req.Context(), req.URL.String()); err != nil {
+				return err
+			}
+			if len(via) >= 10 {
+				return errors.New("stopped after 10 redirects")
+			}
+			return nil
+		},
+	}
+	dlResp, err := client.Do(dlReq)
+	if err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API torrent fetch request: %w", err)
+	}
+	defer dlResp.Body.Close()
+	if dlResp.StatusCode < 200 || dlResp.StatusCode >= 300 {
+		return "", "", fmt.Errorf("trackers: BTN API download fetch failed status=%d", dlResp.StatusCode)
+	}
+	body, err := readBTNTorrentResponseBody(dlResp.Body)
+	if err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API read torrent response: %w", err)
+	}
+	if len(body) == 0 || body[0] != 'd' {
+		return "", "", errors.New("trackers: BTN API did not return torrent payload")
+	}
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0o700); err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API create torrent output dir: %w", err)
+	}
+	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
+		return "", "", fmt.Errorf("trackers: BTN API write torrent output: %w", err)
+	}
+	return selection.ID, selection.GroupID, nil
+}
+
+// readBTNTorrentResponseBody rejects bodies beyond BTN's accepted torrent
+// response cap before callers validate or persist the payload.
+func readBTNTorrentResponseBody(r io.Reader) ([]byte, error) {
+	body, err := io.ReadAll(io.LimitReader(r, btnTorrentMaxBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("read torrent response: %w", err)
+	}
+	if len(body) > btnTorrentMaxBytes {
+		return nil, fmt.Errorf("torrent response exceeds %d bytes", btnTorrentMaxBytes)
+	}
+	return body, nil
+}
+
+// loadBTNCookiesIntoJar best-effort seeds an upload client with persisted BTN
+// cookies. Missing or unreadable cookies leave the caller's client unchanged.
+func loadBTNCookiesIntoJar(ctx context.Context, client *http.Client, dbPath string, baseURL string) {
+	if client == nil || client.Jar == nil {
+		return
+	}
+	values, err := loadBTNCookies(ctx, dbPath)
+	if err != nil {
+		return
+	}
+	setBTNCookies(client.Jar, baseURL, values)
+}
+
+// loadBTNCookies reads persisted BTN cookies and maps only typed not-found
+// results to the BTN missing-cookie sentinel. Storage, parse, and decrypt errors
+// are returned with tracker context so callers can avoid replacing valid state.
+func loadBTNCookies(ctx context.Context, dbPath string) (map[string]string, error) {
+	values, err := cookies.LoadTrackerCookieMap(ctx, dbPath, "BTN")
+	if err != nil {
+		if errors.Is(err, cookies.ErrTrackerCookiesNotFound) {
+			return nil, errBTNCookiesMissing
+		}
+		return nil, fmt.Errorf("trackers: %w", err)
+	}
+	return values, nil
+}
+
+// newBTNClientWithCookies creates a short-lived BTN client with a fresh cookie
+// jar populated from the supplied stored cookie map.
+func newBTNClientWithCookies(baseURL string, values map[string]string) (*http.Client, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN create session cookie jar: %w", err)
+	}
+	setBTNCookies(jar, baseURL, values)
+	return &http.Client{Timeout: 45 * time.Second, Jar: jar}, nil
+}
+
+// setBTNCookies mirrors stored BTN cookie values into jar for baseURL. Invalid
+// base URLs or nil jars are ignored because callers treat cookie seeding as
+// best-effort before explicit session validation.
+func setBTNCookies(jar http.CookieJar, baseURL string, values map[string]string) {
+	if jar == nil {
+		return
+	}
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return
+	}
+	jarCookies := make([]*http.Cookie, 0, len(values))
+	for name, value := range values {
+		// #nosec G124 -- Outbound tracker jar cookie mirrors configured BTN session values.
+		jarCookies = append(jarCookies, &http.Cookie{
+			Name:   name,
+			Value:  value,
+			Domain: parsed.Hostname(),
+			Path:   "/",
+		})
+	}
+	jar.SetCookies(parsed, jarCookies)
+}
+
+// persistBTNCookies saves cookies extracted from a caller-validated BTN client jar.
+func persistBTNCookies(ctx context.Context, dbPath string, baseURL string, jar http.CookieJar) error {
+	values, err := btnCookiesFromJar(baseURL, jar)
+	if err != nil {
+		return err
+	}
+	if len(values) == 0 {
+		return errors.New("trackers: BTN login returned no usable cookies")
+	}
+	if err := cookies.SaveTrackerCookieMap(ctx, dbPath, "BTN", values); err != nil {
+		return fmt.Errorf("trackers: BTN save cookies: %w", err)
+	}
+	return nil
+}
+
+// btnCookiesFromJar extracts non-empty BTN cookie names and values for baseURL
+// after a caller has validated that the jar represents a usable session.
+func btnCookiesFromJar(baseURL string, jar http.CookieJar) (map[string]string, error) {
+	if jar == nil {
+		return nil, errors.New("trackers: BTN login returned no cookie jar")
+	}
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: BTN parse cookie URL: %w", err)
+	}
+	out := make(map[string]string)
+	for _, cookie := range jar.Cookies(parsed) {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		out[strings.TrimSpace(cookie.Name)] = cookie.Value
+	}
+	return out, nil
+}
+
+// resolveBTN2FACode returns a manually submitted code before falling back to
+// the configured TOTP URI.
+func resolveBTN2FACode(cfg config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
+	if code := strings.TrimSpace(login.Code); code != "" {
+		return code, nil
+	}
+	return resolve2FACode(strings.TrimSpace(cfg.OTPURI))
+}
+
+// btnLoginNeeds2FA recognizes BTN login responses that render the manual 2FA
+// challenge field instead of accepting the submitted credentials.
+func btnLoginNeeds2FA(body string) bool {
+	lower := strings.ToLower(body)
+	return strings.Contains(lower, "name=\"codenumber\"") ||
+		strings.Contains(lower, "name='codenumber'")
+}
+
+// btnLoginFailed recognizes explicit BTN credential or submitted-code failures
+// in successful HTTP responses.
+func btnLoginFailed(body string) bool {
+	lower := strings.ToLower(body)
+	return strings.Contains(lower, "invalid login") ||
+		strings.Contains(lower, "incorrect password") ||
+		strings.Contains(lower, "invalid code") ||
+		strings.Contains(lower, "incorrect code") ||
+		strings.Contains(lower, "login failed")
+}
+
+// btnLoggedOutPage recognizes upload-page responses that prove the session is
+// logged out and safe to classify as confirmed-invalid auth.
+func btnLoggedOutPage(body string) bool {
+	lower := strings.ToLower(body)
+	return strings.Contains(lower, "<form") && (strings.Contains(lower, "password") || strings.Contains(lower, "login.php")) ||
+		strings.Contains(lower, "you must be logged in") ||
+		strings.Contains(lower, "please log in")
+}
+
+// btnLooksLikeUploadPage recognizes enough upload-page structure to confirm a
+// BTN session without depending on one exact page layout.
+func btnLooksLikeUploadPage(body string) bool {
+	lower := strings.ToLower(body)
+	hasForm := strings.Contains(lower, "<form")
+	hasUploadAction := strings.Contains(lower, "action=\"/upload.php") ||
+		strings.Contains(lower, "action='/upload.php") ||
+		strings.Contains(lower, "action=\"upload.php") ||
+		strings.Contains(lower, "action='upload.php")
+	hasFileInput := strings.Contains(lower, "name=\"file_input\"") ||
+		strings.Contains(lower, "name='file_input'")
+	hasAutofill := strings.Contains(lower, "name=\"autofill\"") ||
+		strings.Contains(lower, "name='autofill'")
+	return hasForm && (hasFileInput || (hasUploadAction && hasAutofill))
+}
+
+func resolve2FACode(otpURI string) (string, error) {
+	trimmed := strings.TrimSpace(otpURI)
+	if trimmed == "" {
+		return "", errors.New("otp_uri not configured")
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", fmt.Errorf("trackers: BTN parse otp_uri: %w", err)
+	}
+	secret := strings.TrimSpace(parsed.Query().Get("secret"))
+	if secret == "" {
+		return "", errors.New("otp_uri missing secret")
+	}
+	period := 30
+	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
+		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
+			period = parsedValue
+		}
+	}
+	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
+	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
+	if err != nil {
+		return "", fmt.Errorf("trackers: BTN decode otp secret: %w", err)
+	}
+	counterTime := time.Now().Unix() / int64(period)
+	if counterTime < 0 {
+		return "", errors.New("totp counter before unix epoch")
+	}
+	counter := uint64(counterTime)
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, counter)
+	mac := hmac.New(sha1.New, secretBytes)
+	_, _ = mac.Write(buf)
+	hash := mac.Sum(nil)
+	offset := hash[len(hash)-1] & 0x0f
+	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
+	return fmt.Sprintf("%06d", code%1000000), nil
+}
+
+func resolveBTNAPIURL(cfg config.TrackerConfig) string {
+	if cfg.Unknown != nil {
+		if raw, ok := cfg.Unknown["api_url"]; ok {
+			if value := strings.TrimSpace(fmt.Sprint(raw)); value != "" {
+				return value
+			}
+		}
+	}
+	return btnAPIRPCURL
+}
+
+func resolveFastTorrent(cfg config.TrackerConfig) bool {
+	if cfg.Unknown != nil {
+		if raw, ok := cfg.Unknown["fast_torrent"]; ok {
+			if b, ok := raw.(bool); ok {
+				return b
+			}
+			if s, ok := raw.(string); ok {
+				return strings.EqualFold(strings.TrimSpace(s), "true") || strings.TrimSpace(s) == "1"
+			}
+		}
+	}
+	return false
+}
+
+func stripHTML(value string) string {
+	replacer := strings.NewReplacer("<br>", "\n", "<br/>", "\n", "<br />", "\n")
+	cleaned := replacer.Replace(value)
+	cleaned = regexp.MustCompile(`(?s)<[^>]*>`).ReplaceAllString(cleaned, "")
+	return strings.TrimSpace(cleaned)
+}
+
+// mapContainer maps local container metadata to BTN's format dropdown. Autofill
+// is used only when metadata does not resolve to a BTN-supported value.
+func mapContainer(meta api.UploadSubject, fields map[string]string) string {
+	allowed := map[string]struct{}{
+		"AVI":   {},
+		"MKV":   {},
+		"VOB":   {},
+		"MPEG":  {},
+		"MP4":   {},
+		"ISO":   {},
+		"WMV":   {},
+		"TS":    {},
+		"M4V":   {},
+		"M2TS":  {},
+		"Mixed": {},
+	}
+	container := strings.ToLower(strings.TrimSpace(meta.Container))
+	mapped := map[string]string{
+		"avi":  "AVI",
+		"mkv":  "MKV",
+		"vob":  "VOB",
+		"mpg":  "MPEG",
+		"mpeg": "MPEG",
+		"mp4":  "MP4",
+		"iso":  "ISO",
+		"wmv":  "WMV",
+		"ts":   "TS",
+		"m4v":  "M4V",
+		"m2ts": "M2TS",
+	}[container]
+	if mapped == "" && strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		mapped = "M2TS"
+	}
+	if mapped == "" && strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		mapped = "VOB"
+	}
+	for _, candidate := range []string{mapped, fields["format"], "Mixed"} {
+		if _, ok := allowed[candidate]; ok {
+			return candidate
+		}
+	}
+	return ""
+}
+
+// mapCodec maps local video codec metadata to BTN's bitrate dropdown. Autofill
+// is used only when metadata does not resolve to a BTN-supported value.
+func mapCodec(meta api.UploadSubject, fields map[string]string) string {
+	allowed := map[string]struct{}{
+		"XViD":       {},
+		"MPEG2":      {},
+		"DiVX":       {},
+		"DVDR":       {},
+		"VC-1":       {},
+		"H.264":      {},
+		"H.265":      {},
+		"WMV":        {},
+		"BD":         {},
+		"x264-Hi10P": {},
+		"VP9":        {},
+		"Mixed":      {},
+	}
+	videoEncode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
+	videoCodec := strings.ToLower(strings.TrimSpace(meta.VideoCodec))
+	bitDepth := strings.TrimSpace(meta.BitDepth)
+	mapped := ""
+	if (strings.Contains(videoEncode, "hi10") || bitDepth == "10") &&
+		(strings.Contains(videoEncode, "x264") || strings.Contains(videoCodec, "avc") || strings.Contains(videoCodec, "h.264")) {
+		mapped = "x264-Hi10P"
+	}
+	if mapped == "" {
+		lookup := map[string]string{
+			"xvid":   "XViD",
+			"divx":   "DiVX",
+			"mpeg-2": "MPEG2",
+			"mpeg2":  "MPEG2",
+			"vc-1":   "VC-1",
+			"wmv":    "WMV",
+			"vp9":    "VP9",
+			"avc":    "H.264",
+			"h.264":  "H.264",
+			"h264":   "H.264",
+			"x264":   "H.264",
+			"hevc":   "H.265",
+			"h.265":  "H.265",
+			"h265":   "H.265",
+			"x265":   "H.265",
+		}
+		for _, value := range []string{videoEncode, videoCodec} {
+			for needle, resolved := range lookup {
+				if strings.Contains(value, needle) {
+					mapped = resolved
+					break
+				}
+			}
+			if mapped != "" {
+				break
+			}
+		}
+	}
+	for _, candidate := range []string{mapped, fields["bitrate"], "Mixed"} {
+		if _, ok := allowed[candidate]; ok {
+			return candidate
+		}
+	}
+	return ""
+}
+
+// mapSource maps local source metadata to BTN's media dropdown. Autofill is
+// used only when metadata does not resolve to a BTN-supported value.
+func mapSource(meta api.UploadSubject, fields map[string]string) string {
+	allowed := map[string]struct{}{
+		"HDTV":    {},
+		"PDTV":    {},
+		"DSR":     {},
+		"DVDRip":  {},
+		"TVRip":   {},
+		"VHSRip":  {},
+		"Bluray":  {},
+		"BDRip":   {},
+		"BRRip":   {},
+		"DVD5":    {},
+		"DVD9":    {},
+		"HDDVD":   {},
+		"WEB-DL":  {},
+		"WEBRip":  {},
+		"BD5":     {},
+		"BD9":     {},
+		"BD25":    {},
+		"BD50":    {},
+		"Mixed":   {},
+		"Unknown": {},
+	}
+	source := strings.ToLower(strings.TrimSpace(meta.Source))
+	typeName := strings.ToUpper(strings.TrimSpace(meta.Type))
+	resolution := strings.ToUpper(strings.TrimSpace(meta.Release.Resolution))
+	var mapped string
+	switch {
+	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
+		mapped = "DVD9"
+	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "HDDVD"):
+		mapped = "HDDVD"
+	case typeName == "WEBDL":
+		mapped = "WEB-DL"
+	case typeName == "WEBRIP":
+		mapped = "WEBRip"
+	case typeName == "HDTV" || source == "hdtv":
+		mapped = "HDTV"
+	case typeName == "DVDRIP":
+		mapped = "DVDRip"
+	case resolution == "SD" && (source == "bluray" || source == "blu-ray"):
+		mapped = "BDRip"
+	default:
+		mapped = map[string]string{
+			"bluray":  "Bluray",
+			"blu-ray": "Bluray",
+			"bdrip":   "BDRip",
+			"brrip":   "BRRip",
+			"dvd5":    "DVD5",
+			"dvd9":    "DVD9",
+			"web-dl":  "WEB-DL",
+			"webrip":  "WEBRip",
+			"pdtv":    "PDTV",
+			"dsr":     "DSR",
+			"tvrip":   "TVRip",
+			"vhsrip":  "VHSRip",
+			"bd5":     "BD5",
+			"bd9":     "BD9",
+			"bd25":    "BD25",
+			"bd50":    "BD50",
+		}[source]
+	}
+	for _, candidate := range []string{mapped, fields["media"], "Unknown"} {
+		if _, ok := allowed[candidate]; ok {
+			return candidate
+		}
+	}
+	return ""
+}
+
+// mapResolution returns the BTN resolution value derived from local metadata,
+// falling back to BTN autofill only when metadata does not map to a BTN option.
+func mapResolution(meta api.UploadSubject, fields map[string]string) string {
+	switch strings.ToLower(strings.TrimSpace(meta.Release.Resolution)) {
+	case "2160p", "4320p", "8640p", "4k", "8k":
+		return "2160p"
+	case "1080p", "1440p":
+		return "1080p"
+	case "1080i":
+		return "1080i"
+	case "720p":
+		return "720p"
+	case "sd":
+		return "SD"
+	case "portable device":
+		return "Portable Device"
+	case "mixed":
+		return "Mixed"
+	}
+	switch strings.TrimSpace(fields["resolution"]) {
+	case "SD", "720p", "1080p", "1080i", "2160p", "Portable Device", "Mixed":
+		return strings.TrimSpace(fields["resolution"])
+	default:
+		return "SD"
+	}
+}
+
+func applyBTNNameMapping(releaseName string, mappedCodec string, mappedSource string) string {
+	updated := releaseName
+	if mappedSource != "" {
+		sourcePattern := regexp.MustCompile(`(?i)\b(bluray|blu-ray|bdrip|brrip|web-dl|webrip|hdtv|dvdrip|hddvd|dvd5|dvd9|bd5|bd9|bd25|bd50)\b`)
+		updated = sourcePattern.ReplaceAllString(updated, mappedSource)
+	}
+	if mappedCodec != "" {
+		codecPatterns := map[string]*regexp.Regexp{
+			"H.264":      regexp.MustCompile(`(?i)\b(x264|h\.264|h264|avc)\b`),
+			"H.265":      regexp.MustCompile(`(?i)\b(x265|h\.265|h265|hevc)\b`),
+			"x264-Hi10P": regexp.MustCompile(`(?i)\b(x264-hi10p|hi10p)\b`),
+			"XViD":       regexp.MustCompile(`(?i)\b(xvid)\b`),
+			"DiVX":       regexp.MustCompile(`(?i)\b(divx)\b`),
+			"MPEG2":      regexp.MustCompile(`(?i)\b(mpeg-2|mpeg2)\b`),
+			"VC-1":       regexp.MustCompile(`(?i)\b(vc-1)\b`),
+			"WMV":        regexp.MustCompile(`(?i)\b(wmv)\b`),
+			"VP9":        regexp.MustCompile(`(?i)\b(vp9)\b`),
+		}
+		if pattern, ok := codecPatterns[mappedCodec]; ok {
+			updated = pattern.ReplaceAllString(updated, mappedCodec)
+		}
+	}
+	return updated
+}
+
+// resolveCountryID extracts the first available country from TVDB, TMDB, then
+// IMDB metadata and returns its BTN country id. Country codes and names are
+// matched only against normalized exact aliases so ambiguous inputs do not
+// depend on map iteration order.
+func resolveCountryID(meta api.UploadSubject) string {
+	var countryStr string
+
+	// Try TVDB first (ISO 3166-1 alpha-3, lowercase)
+	if meta.ProviderMetadata.TVDB != nil && meta.ProviderMetadata.TVDB.OriginalCountry != "" {
+		countryStr = meta.ProviderMetadata.TVDB.OriginalCountry
+	}
+
+	// Fall back to TMDB (ISO 3166-1 alpha-2, uppercase)
+	if countryStr == "" && meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.OriginCountry) > 0 {
+		countryStr = meta.ProviderMetadata.TMDB.OriginCountry[0]
+	}
+
+	// Fall back to IMDB (full country names)
+	if countryStr == "" && meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Country != "" {
+		// IMDB can have multiple countries separated by commas, take the first one
+		parts := strings.Split(meta.ProviderMetadata.IMDB.Country, ",")
+		if len(parts) > 0 {
+			countryStr = strings.TrimSpace(parts[0])
+		}
+	}
+
+	if countryStr == "" {
+		return ""
+	}
+
+	if id, ok := btnCountryMap[normalizeBTNCountryAlias(countryStr)]; ok {
+		return id
+	}
+
+	return ""
+}
+
+// resolveBTNOriginalLanguage returns provider original language in BTN
+// priority order: TVDB first, then IMDb when TVDB has no value.
+func resolveBTNOriginalLanguage(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TVDB != nil {
+		if language := strings.TrimSpace(meta.ProviderMetadata.TVDB.OriginalLanguage); language != "" {
+			return language
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage)
+	}
+	return ""
+}
+
+// isBTNEnglishLanguage reports whether a provider language value represents
+// English and should therefore not trigger BTN's foreign flag.
+func isBTNEnglishLanguage(language string) bool {
+	switch strings.ToLower(strings.TrimSpace(language)) {
+	case "en", "eng", "english":
+		return true
+	default:
+		return false
+	}
+}
+
+// normalizeBTNCountryAlias lowercases and collapses punctuation so metadata
+// country names can be compared against BTN's exact alias table.
+func normalizeBTNCountryAlias(value string) string {
+	normalized := strings.ToLower(strings.TrimSpace(value))
+	normalized = strings.NewReplacer(
+		"&", " and ",
+		".", " ",
+		",", " ",
+		"-", " ",
+		"_", " ",
+		"'", " ",
+		"(", " ",
+		")", " ",
+	).Replace(normalized)
+	return strings.Join(strings.Fields(normalized), " ")
+}
+
+// btnLookupIPAddrFunc matches net.Resolver lookups so tests can model DNS
+// changes without relying on external name service.
+type btnLookupIPAddrFunc func(context.Context, string) ([]net.IPAddr, error)
+
+// btnAPIDownloadOrigin records the resolved BTN API origin that download URLs
+// may reuse when they would otherwise fail public-address validation.
+type btnAPIDownloadOrigin struct {
+	scheme string
+	host   string
+	addrs  map[netip.Addr]struct{}
+	lookup btnLookupIPAddrFunc
+}
+
+// resolveBTNURLAddrs resolves a URL host to unmapped IP addresses, preserving
+// literal IP hosts without DNS.
+func resolveBTNURLAddrs(ctx context.Context, parsed *url.URL, lookup btnLookupIPAddrFunc) ([]netip.Addr, error) {
+	host := strings.TrimSpace(parsed.Hostname())
+	if addr, err := netip.ParseAddr(host); err == nil {
+		return []netip.Addr{addr.Unmap()}, nil
+	}
+
+	resolved, err := lookup(ctx, host)
+	if err != nil {
+		return nil, fmt.Errorf("resolve host %q: %w", host, err)
+	}
+	addrs := make([]netip.Addr, 0, len(resolved))
+	for _, item := range resolved {
+		if addr, ok := netip.AddrFromSlice(item.IP); ok {
+			addrs = append(addrs, addr.Unmap())
+		}
+	}
+	if len(addrs) == 0 {
+		return nil, fmt.Errorf("host %q resolved to no usable addresses", host)
+	}
+	return addrs, nil
+}
+
+// validateBTNPublicResolvedAddrs rejects private, loopback, link-local,
+// multicast, unspecified, and otherwise non-global-unicast addresses.
+func validateBTNPublicResolvedAddrs(host string, addrs []netip.Addr) error {
+	for _, addr := range addrs {
+		if !addr.IsValid() || !addr.IsGlobalUnicast() || addr.IsPrivate() || addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsMulticast() ||
+			addr.IsUnspecified() {
+			return fmt.Errorf("host %q resolved to blocked address %q", host, addr)
+		}
+	}
+	return nil
+}
+
+type btnAPITorrentSelection struct {
+	ID      string
+	GroupID string
+}
+
+// selectBTNAPITorrent returns the BTN torrent that matches the uploaded
+// release. It prefers an exact release-name match inside the uploaded group and
+// only accepts a group-only match when that group has a single candidate.
+func selectBTNAPITorrent(torrents map[string]map[string]any, releaseName string, groupID string) btnAPITorrentSelection {
+	expectedRelease := normalizeBTNAPIMatchValue(releaseName)
+	expectedGroup := strings.TrimSpace(groupID)
+
+	ids := make([]string, 0, len(torrents))
+	for id := range torrents {
+		if trimmed := strings.TrimSpace(id); trimmed != "" {
+			ids = append(ids, trimmed)
+		}
+	}
+	sortBTNAPITorrentIDs(ids)
+
+	groupMatches := make([]string, 0, len(ids))
+	for _, id := range ids {
+		torrentData := torrents[id]
+		if expectedGroup != "" {
+			torrentGroup := btnAPITorrentGroupID(torrentData)
+			if strings.TrimSpace(torrentGroup) != expectedGroup {
+				continue
+			}
+		}
+		groupMatches = append(groupMatches, id)
+		if expectedRelease != "" && btnAPITorrentMatchesRelease(torrentData, expectedRelease) {
+			return btnAPITorrentSelection{ID: id, GroupID: btnAPITorrentGroupID(torrentData)}
+		}
+	}
+	if len(groupMatches) == 1 {
+		return btnAPITorrentSelection{ID: groupMatches[0], GroupID: btnAPITorrentGroupID(torrents[groupMatches[0]])}
+	}
+	return btnAPITorrentSelection{}
+}
+
+// btnAPITorrentGroupID extracts BTN's group id from known API field spellings.
+func btnAPITorrentGroupID(torrentData map[string]any) string {
+	return metautil.FirstNonEmptyTrimmed(
+		btnAPIStringField(torrentData, "GroupID"),
+		btnAPIStringField(torrentData, "groupId"),
+		btnAPIStringField(torrentData, "GroupId"),
+		btnAPIStringField(torrentData, "group_id"),
+	)
+}
+
+// sortBTNAPITorrentIDs orders API result ids deterministically, newest numeric
+// ids first when all compared ids are numeric.
+func sortBTNAPITorrentIDs(ids []string) {
+	sort.Slice(ids, func(i, j int) bool {
+		left, leftErr := strconv.Atoi(ids[i])
+		right, rightErr := strconv.Atoi(ids[j])
+		if leftErr == nil && rightErr == nil {
+			return left > right
+		}
+		return ids[i] > ids[j]
+	})
+}
+
+// btnAPITorrentMatchesRelease reports whether a known BTN API name field is an
+// exact normalized match for the release name we uploaded.
+func btnAPITorrentMatchesRelease(torrentData map[string]any, expectedRelease string) bool {
+	for _, field := range []string{"ReleaseName", "releaseName", "TorrentName", "torrentName", "Name", "name", "Release", "release"} {
+		if normalizeBTNAPIMatchValue(btnAPIStringField(torrentData, field)) == expectedRelease {
+			return true
+		}
+	}
+	return false
+}
+
+// btnAPIStringField returns an API field as a trimmed string. Missing or null
+// fields produce an empty value; numeric fields keep their decimal form.
+func btnAPIStringField(data map[string]any, field string) string {
+	if data == nil {
+		return ""
+	}
+	value, ok := data[field]
+	if !ok || value == nil {
+		return ""
+	}
+	switch typed := value.(type) {
+	case string:
+		return typed
+	case json.Number:
+		return typed.String()
+	case float64:
+		if typed == float64(int64(typed)) {
+			return strconv.FormatInt(int64(typed), 10)
+		}
+		return strconv.FormatFloat(typed, 'f', -1, 64)
+	case int:
+		return strconv.Itoa(typed)
+	case int64:
+		return strconv.FormatInt(typed, 10)
+	default:
+		return strings.TrimSpace(fmt.Sprint(value))
+	}
+}
+
+// normalizeBTNAPIMatchValue canonicalizes BTN API comparison values for exact,
+// case-insensitive release-name matching.
+func normalizeBTNAPIMatchValue(value string) string {
+	return strings.ToLower(strings.TrimSpace(value))
+}
+
+// validateBTNAPIDownloadURL applies public-address validation to a BTN API
+// DownloadURL, but permits a same-origin private URL when the caller explicitly
+// configured the API endpoint to that pinned private address. The pinned-origin
+// exception keeps local test servers usable without allowing arbitrary private
+// redirects or same-host DNS rebinding.
+func validateBTNAPIDownloadURL(ctx context.Context, apiURL string, rawURL string) error {
+	origin, err := newBTNAPIDownloadOrigin(ctx, apiURL)
+	if err != nil {
+		return err
+	}
+	return origin.validateDownloadURL(ctx, rawURL)
+}
+
+func newBTNAPIDownloadOrigin(ctx context.Context, apiURL string) (*btnAPIDownloadOrigin, error) {
+	return newBTNAPIDownloadOriginWithLookup(ctx, apiURL, net.DefaultResolver.LookupIPAddr)
+}
+
+// newBTNAPIDownloadOriginWithLookup parses and pins the API URL's scheme, host,
+// and current resolved addresses for later download redirect validation.
+func newBTNAPIDownloadOriginWithLookup(ctx context.Context, apiURL string, lookup btnLookupIPAddrFunc) (*btnAPIDownloadOrigin, error) {
+	parsed, err := url.Parse(strings.TrimSpace(apiURL))
+	if err != nil {
+		return nil, fmt.Errorf("parse url: %w", err)
+	}
+	scheme := strings.ToLower(parsed.Scheme)
+	if scheme != "http" && scheme != "https" {
+		return nil, fmt.Errorf("unsupported scheme %q", parsed.Scheme)
+	}
+	if strings.TrimSpace(parsed.Hostname()) == "" {
+		return nil, errors.New("missing host")
+	}
+	if strings.Contains(parsed.Hostname(), "%") {
+		return nil, fmt.Errorf("blocked private host %q", parsed.Hostname())
+	}
+	addrs, err := resolveBTNURLAddrs(ctx, parsed, lookup)
+	if err != nil {
+		return nil, err
+	}
+	pinned := make(map[netip.Addr]struct{}, len(addrs))
+	for _, addr := range addrs {
+		pinned[addr] = struct{}{}
+	}
+	return &btnAPIDownloadOrigin{
+		scheme: scheme,
+		host:   parsed.Host,
+		addrs:  pinned,
+		lookup: lookup,
+	}, nil
+}
+
+// validateDownloadURL accepts public HTTP(S) destinations and otherwise only
+// permits same-origin destinations that still resolve to the pinned API address.
+func (origin *btnAPIDownloadOrigin) validateDownloadURL(ctx context.Context, rawURL string) error {
+	parsed, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil {
+		return fmt.Errorf("parse url: %w", err)
+	}
+	scheme := strings.ToLower(parsed.Scheme)
+	if scheme != "http" && scheme != "https" {
+		return fmt.Errorf("unsupported scheme %q", parsed.Scheme)
+	}
+	host := strings.TrimSpace(parsed.Hostname())
+	if host == "" {
+		return errors.New("missing host")
+	}
+	addrs, err := resolveBTNURLAddrs(ctx, parsed, origin.lookup)
+	if err != nil {
+		return err
+	}
+	publicErr := validateBTNPublicResolvedAddrs(host, addrs)
+	lowerHost := strings.ToLower(host)
+	if publicErr == nil && lowerHost != "localhost" && !strings.HasSuffix(lowerHost, ".localhost") && !strings.Contains(lowerHost, "%") {
+		return nil
+	}
+
+	if !origin.sameOrigin(parsed) {
+		if publicErr != nil {
+			return publicErr
+		}
+		return fmt.Errorf("blocked private host %q", host)
+	}
+
+	for _, addr := range addrs {
+		if _, ok := origin.addrs[addr]; !ok {
+			return fmt.Errorf("blocked address %q not pinned to BTN API origin", addr)
+		}
+	}
+
+	return nil
+}
+
+// sameOrigin reports whether a URL has the pinned API origin's scheme and host.
+func (origin *btnAPIDownloadOrigin) sameOrigin(parsed *url.URL) bool {
+	if origin == nil || parsed == nil {
+		return false
+	}
+	return strings.EqualFold(origin.scheme, parsed.Scheme) &&
+		strings.EqualFold(origin.host, parsed.Host) &&
+		origin.host != ""
+}
+
+// checkBTNSeasonPackReservation enforces BTN's 2-hour internal season-pack
+// reservation using the same canonical season source as the final upload
+// payload, including TVDB/IMDb translated episode metadata.
+func checkBTNSeasonPackReservation(ctx context.Context, uploadCtx uploadContext, req trackers.PreparationInput) error {
+	if resolveUploadType(req.Meta) != "Season" {
+		return nil
+	}
+	// The 2-hour reservation ONLY applies to season packs made of internal releases.
+	if !isBTNInternalGroup(req.Meta) {
+		return nil
+	}
+
+	tvdbID := req.Meta.Identity.TVDBID
+	if tvdbID == 0 {
+		return nil
+	}
+
+	group := strings.TrimPrefix(req.Meta.Tag, "-")
+	if group == "" {
+		return nil
+	}
+
+	filter := map[string]any{
+		"tvdb":     strconv.Itoa(tvdbID),
+		"category": "Episode",
+		"group":    group,
+	}
+
+	// We only need the most recent episodes to check the 2-hour window
+	torrentsMap, err := btnAPISearchTorrents(ctx, uploadCtx.apiURL, uploadCtx.apiToken, filter, 50)
+	if err != nil {
+		return err
+	}
+
+	seasonPrefix := ""
+	season, _ := resolveBTNTVSeasonEpisode(req.Meta)
+	if season > 0 {
+		seasonPrefix = fmt.Sprintf("S%02dE", season)
+	}
+
+	var newestInternal time.Time
+	for _, t := range torrentsMap {
+		name, _ := t["ReleaseName"].(string)
+		if seasonPrefix != "" && !strings.Contains(strings.ToUpper(name), seasonPrefix) {
+			continue
+		}
+
+		tTime := parseBTNTimestamp(t["Time"])
+		if tTime.After(newestInternal) {
+			newestInternal = tTime
+		}
+	}
+
+	if !newestInternal.IsZero() && time.Since(newestInternal) < 2*time.Hour {
+		return errors.New("trackers: BTN 2-hour reservation period for internal season packs has not expired")
+	}
+
+	return nil
+}
+
+func btnAPISearchTorrents(ctx context.Context, apiURL, apiToken string, filter map[string]any, limit int) (map[string]map[string]any, error) {
+	var response struct {
+		Result struct {
+			Torrents json.RawMessage `json:"torrents"`
+		} `json:"result"`
+	}
+	if err := callBTNAPI(ctx, apiURL, "ua-btn-upload-check", "getTorrentsSearch", []any{apiToken, filter, limit}, &response); err != nil {
+		return nil, err
+	}
+
+	if len(response.Result.Torrents) == 0 || string(response.Result.Torrents) == "false" || string(response.Result.Torrents) == "[]" {
+		return nil, nil
+	}
+
+	var torrentsMap map[string]map[string]any
+	if err := json.Unmarshal(response.Result.Torrents, &torrentsMap); err != nil {
+		return nil, fmt.Errorf("trackers: BTN API parse torrents search response: %s", redaction.RedactValue(err.Error(), nil))
+	}
+	return torrentsMap, nil
+}
+
+func parseBTNTimestamp(val any) time.Time {
+	var epoch int64
+	switch v := val.(type) {
+	case string:
+		epoch, _ = strconv.ParseInt(v, 10, 64)
+	case float64:
+		epoch = int64(v)
+	}
+	if epoch > 0 {
+		return time.Unix(epoch, 0)
+	}
+	return time.Time{}
+}
diff --git a/internal/trackers/impl/btn/upload_integration_test.go b/internal/trackers/impl/standalone/btn/upload_integration_test.go
similarity index 92%
rename from internal/trackers/impl/btn/upload_integration_test.go
rename to internal/trackers/impl/standalone/btn/upload_integration_test.go
index 55f4f001..48da11a6 100644
--- a/internal/trackers/impl/btn/upload_integration_test.go
+++ b/internal/trackers/impl/standalone/btn/upload_integration_test.go
@@ -131,7 +131,11 @@ func TestBTNUploadEndToEndSuccess(t *testing.T) {
 		switch {
 		case r.URL.Path == "/login.php" && r.Method == http.MethodPost:
 			loginCalls.Add(1)
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			w.WriteHeader(http.StatusOK)
 			_, _ = w.Write([]byte("ok"))
 		case r.URL.Path == "/upload.php" && r.Method == http.MethodGet:
@@ -201,9 +205,9 @@ func TestBTNUploadEndToEndSuccess(t *testing.T) {
 	mediaInfoText := "General\nFormat: Matroska\nVideo\nCodec: H.265"
 	mediaInfoPath := writeBTNTestMediaInfo(t, tempDir, mediaInfoText)
 
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "BTN",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			SourcePath:        sourcePath,
 			TorrentPath:       torrentPath,
 			MediaInfoTextPath: mediaInfoPath,
@@ -218,7 +222,7 @@ func TestBTNUploadEndToEndSuccess(t *testing.T) {
 			EpisodeTitle:      "Episode One",
 			EpisodeOverview:   "Overview",
 			TVDBAiredDate:     "2025-01-01",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 			},
 			Release: api.ReleaseInfo{
@@ -230,19 +234,18 @@ func TestBTNUploadEndToEndSuccess(t *testing.T) {
 			Tag:                 "GRP",
 		},
 		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
 			Username: "user",
 			Password: "pass",
 		},
-		AppConfig: config.Config{
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
 				"BTN": {APIKey: strings.Repeat("x", 30)},
 			}},
-		},
+		}),
 	}
 
-	summary, err := upload(context.Background(), req)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
@@ -320,7 +323,11 @@ func TestBTNUploadAnnounceURLWritesTorrentArtifact(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.URL.Path == "/login.php" && r.Method == http.MethodPost:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			w.WriteHeader(http.StatusOK)
 			_, _ = w.Write([]byte("ok"))
 		case r.URL.Path == "/upload.php" && r.Method == http.MethodGet:
@@ -354,13 +361,13 @@ func TestBTNUploadAnnounceURLWritesTorrentArtifact(t *testing.T) {
 	}))
 	defer server.Close()
 
-	req := newBTNUploadTestRequest(t, server.URL)
+	req := newBTNUploadTestRequest(t)
 	torrentPath := filepath.Join(t.TempDir(), "input.torrent")
 	writeBTNTestTorrent(t, torrentPath)
 	req.Meta.TorrentPath = torrentPath
 	req.TrackerConfig.AnnounceURL = "https://tracker.btn.example/announce/passkey"
 
-	summary, err := upload(context.Background(), req)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
 	}
@@ -453,9 +460,9 @@ func TestBTNUploadUsesValidImportedCookiesWithoutCredentials(t *testing.T) {
 		t.Fatalf("write torrent: %v", err)
 	}
 
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "BTN",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			SourcePath:  sourcePath,
 			TorrentPath: torrentPath,
 			ReleaseName: "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
@@ -466,19 +473,23 @@ func TestBTNUploadUsesValidImportedCookiesWithoutCredentials(t *testing.T) {
 			VideoCodec:  "HEVC",
 			SeasonInt:   1,
 			EpisodeInt:  1,
-			ExternalIDs: api.ExternalIDs{Category: "TV"},
-			Release:     api.ReleaseInfo{Resolution: "1080p", Season: 1, Episode: 1},
+			Identity:    api.ExternalIdentity{Category: "TV"},
+			Release: api.ReleaseInfo{
+				Resolution: "1080p",
+				Season:     1,
+				Episode:    1,
+			},
 		},
-		TrackerConfig: config.TrackerConfig{URL: server.URL},
-		AppConfig: config.Config{
+		TrackerConfig: config.TrackerConfig{},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
 				"BTN": {APIKey: strings.Repeat("x", 30)},
 			}},
-		},
+		}),
 	}
 
-	summary, err := upload(context.Background(), req)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
@@ -502,7 +513,11 @@ func TestBTNUploadStoredCookieLoadErrorPreventsLogin(t *testing.T) {
 		switch r.URL.Path {
 		case "/login.php":
 			loginCalls.Add(1)
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			_, _ = w.Write([]byte("ok"))
 		case "/upload.php":
 			_, _ = w.Write([]byte(`<form action="/upload.php"><input name="file_input" /></form>`))
@@ -518,7 +533,6 @@ func TestBTNUploadStoredCookieLoadErrorPreventsLogin(t *testing.T) {
 	}
 
 	_, err := ensureBTNUploadSession(context.Background(), config.TrackerConfig{
-		URL:      server.URL,
 		Username: "user",
 		Password: "pass",
 	}, dbPath, uploadContext{baseURL: server.URL})
@@ -575,8 +589,7 @@ func TestBTNDryRunRequiresUploadAuthPrerequisites(t *testing.T) {
 	}))
 	defer server.Close()
 	cookieReq := newBTNDryRunTestRequest(t, cookieDBPath)
-	cookieReq.TrackerConfig.URL = server.URL
-	entry, err = buildUploadDryRun(context.Background(), cookieReq)
+	entry, err = buildUploadDryRunAt(context.Background(), cookieReq, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("BuildUploadDryRun with stored cookies: %v", err)
@@ -611,9 +624,8 @@ func TestBTNDryRunRejectsStaleStoredCookiesWithoutCredentials(t *testing.T) {
 	defer server.Close()
 
 	req := newBTNDryRunTestRequest(t, dbPath)
-	req.TrackerConfig.URL = server.URL
 
-	_, err := buildUploadDryRun(context.Background(), req)
+	_, err := buildUploadDryRunAt(context.Background(), req, server.URL)
 	handlerErrs.Check()
 	if !errors.Is(err, errBTNSessionConfirmedInvalid) {
 		t.Fatalf("expected stale stored cookies to block dry-run readiness, got %v", err)
@@ -643,7 +655,7 @@ func TestBTNDryRunBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 	}
 }
 
-func TestBTNDryRunDebugRunsBTNAutofillAndReportsBothPayloads(t *testing.T) {
+func TestBTNExplicitDryRunRunsAutofillAndReportsBothPayloads(t *testing.T) {
 	t.Parallel()
 
 	dbPath := newBTNAuthDB(t)
@@ -699,20 +711,20 @@ func TestBTNDryRunDebugRunsBTNAutofillAndReportsBothPayloads(t *testing.T) {
 	defer server.Close()
 
 	req := newBTNDryRunTestRequest(t, dbPath)
-	req.TrackerConfig.URL = server.URL
 	req.Meta.MediaInfoTextPath = writeBTNTestMediaInfo(t, filepath.Dir(req.Meta.SourcePath), "General\nFormat: Matroska")
-	req.Meta.Options.Debug = true
+	req.Intent = trackers.PreparationIntentDryRun
 	req.Meta.TVPack = true
 	req.Meta.EpisodeInt = 0
 	req.Meta.ReleaseName = "Example.Show.S05.1080p.WEB-DL.x265-GRP"
 	req.Meta.SeasonInt = 3
-	req.Meta.ExternalMetadata.TVDB = &api.TVDBMetadata{
+	req.Meta.Identity.TVDBID = 12345
+	req.Meta.ProviderMetadata.TVDB = &api.TVDBMetadata{
 		TVDBID:           12345,
 		EpisodeSeason:    5,
 		OriginalLanguage: "en",
 	}
 
-	entry, err := buildUploadDryRun(context.Background(), req)
+	entry, err := buildUploadDryRunAt(context.Background(), req, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("BuildUploadDryRun: %v", err)
@@ -773,7 +785,6 @@ func TestBTNUploadBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 
 	logger := &captureBTNLogger{}
 	req := newBTNDryRunTestRequest(t, newBTNAuthDB(t))
-	req.TrackerConfig.URL = server.URL
 	req.TrackerConfig.Username = "user"
 	req.TrackerConfig.Password = "pass"
 	req.Logger = logger
@@ -782,7 +793,7 @@ func TestBTNUploadBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 	req.Meta.Release.Season = 1
 	req.Meta.Release.Episode = 1
 
-	_, err := upload(context.Background(), req)
+	_, err := uploadAt(context.Background(), req, server.URL)
 	if err == nil {
 		t.Fatal("expected canonical TV metadata gap to block upload")
 	}
@@ -820,11 +831,10 @@ func TestResolveSessionForTrackerAuthLoginStorageErrorPreventsLogin(t *testing.T
 		t.Fatalf("write corrupt db: %v", err)
 	}
 
-	err := ResolveSessionForTrackerAuthLogin(context.Background(), config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(context.Background(), config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
 	if err == nil {
 		t.Fatal("expected stored cookie load error")
 	}
@@ -844,7 +854,11 @@ func TestResolveSessionForTrackerAuthLoginDecryptErrorPreventsPersistence(t *tes
 		switch r.URL.Path {
 		case "/login.php":
 			loginCalls.Add(1)
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			_, _ = w.Write([]byte("ok"))
 		case "/upload.php":
 			_, _ = w.Write([]byte(`<form action="/upload.php"><input name="file_input" /></form>`))
@@ -861,11 +875,10 @@ func TestResolveSessionForTrackerAuthLoginDecryptErrorPreventsPersistence(t *tes
 	}
 	corruptBTNCookieAuthTag(t, dbPath)
 
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
 	if err == nil {
 		t.Fatal("expected stored cookie decrypt error")
 	}
@@ -901,7 +914,18 @@ func TestBTNPrepareUploadDataFailsOnAutofillFailure(t *testing.T) {
 		client:    server.Client(),
 	}
 
-	req := trackers.UploadRequest{Meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}, ReleaseName: "Show.S01E01", Type: "WEBDL", Source: "WEB-DL", Container: "MKV", VideoEncode: "x265", VideoCodec: "HEVC", SeasonInt: 1, EpisodeInt: 1, Release: api.ReleaseInfo{Resolution: "1080p"}}}
+	req := trackers.PreparationInput{Meta: api.UploadSubject{
+		Identity:    api.ExternalIdentity{Category: "TV"},
+		ReleaseName: "Show.S01E01",
+		Type:        "WEBDL",
+		Source:      "WEB-DL",
+		Container:   "MKV",
+		VideoEncode: "x265",
+		VideoCodec:  "HEVC",
+		SeasonInt:   1,
+		EpisodeInt:  1,
+		Release:     api.ReleaseInfo{Resolution: "1080p"},
+	}}
 	_, err := prepareUploadData(context.Background(), req, uploadCtx)
 	if err == nil {
 		t.Fatalf("expected autofill validation error")
@@ -955,9 +979,9 @@ func TestBTNPrepareUploadDataUsesEpisodeIntForTVDBAutoTitle(t *testing.T) {
 		client:    server.Client(),
 	}
 	logger := &captureBTNLogger{}
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Logger: logger,
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName:         "Example.Show.S02E07.1080p.WEB-DL.x265-GRP",
 			Type:                "WEBDL",
 			Source:              "WEB-DL",
@@ -969,8 +993,8 @@ func TestBTNPrepareUploadDataUsesEpisodeIntForTVDBAutoTitle(t *testing.T) {
 			EpisodeTitle:        "Episode Seven",
 			EpisodeOverview:     "Overview",
 			DescriptionOverride: "Description",
-			ExternalIDs:         api.ExternalIDs{Category: "TV"},
-			ExternalMetadata: api.ExternalMetadata{
+			Identity:            api.ExternalIdentity{Category: "TV", TVDBID: 12345},
+			ProviderMetadata: api.SourceScopedMetadata{
 				TVDB: &api.TVDBMetadata{
 					TVDBID:                 12345,
 					Name:                   "Native Show",
@@ -1107,8 +1131,8 @@ func TestBTNPrepareUploadDataUsesSeasonIntForTVDBSeasonPack(t *testing.T) {
 		uploadURL: server.URL + "/upload.php",
 		client:    server.Client(),
 	}
-	req := trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
+	req := trackers.PreparationInput{
+		Meta: api.UploadSubject{
 			ReleaseName:         "Example.Show.S03.1080p.WEB-DL.x265-GRP",
 			Type:                "WEBDL",
 			Source:              "WEB-DL",
@@ -1118,9 +1142,15 @@ func TestBTNPrepareUploadDataUsesSeasonIntForTVDBSeasonPack(t *testing.T) {
 			SeasonInt:           3,
 			TVPack:              true,
 			DescriptionOverride: "Description",
-			ExternalIDs:         api.ExternalIDs{Category: "TV"},
-			ExternalMetadata: api.ExternalMetadata{
-				TVDB: &api.TVDBMetadata{TVDBID: 12345, OriginalLanguage: "en", EpisodeSeason: 5, Genres: "Drama, Science-Fiction", Poster: "https://img.example/tvdb.jpg"},
+			Identity:            api.ExternalIdentity{Category: "TV", TVDBID: 12345},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TVDB: &api.TVDBMetadata{
+					TVDBID:           12345,
+					OriginalLanguage: "en",
+					EpisodeSeason:    5,
+					Genres:           "Drama, Science-Fiction",
+					Poster:           "https://img.example/tvdb.jpg",
+				},
 			},
 			Release: api.ReleaseInfo{
 				Resolution: "1080p",
@@ -1176,16 +1206,16 @@ func TestBTNPrepareUploadDataBlocksMissingCanonicalTVMetadataBeforeAutofill(t *t
 		uploadURL: server.URL + "/upload.php",
 		client:    server.Client(),
 	}
-	req := trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
+	req := trackers.PreparationInput{
+		Meta: api.UploadSubject{
 			ReleaseName: "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
 			Type:        "WEBDL",
 			Source:      "WEB-DL",
 			Container:   "MKV",
 			VideoEncode: "x265",
 			VideoCodec:  "HEVC",
-			ExternalIDs: api.ExternalIDs{Category: "TV"},
-			ExternalMetadata: api.ExternalMetadata{
+			Identity:    api.ExternalIdentity{Category: "TV"},
+			ProviderMetadata: api.SourceScopedMetadata{
 				TVDB: &api.TVDBMetadata{TVDBID: 12345, OriginalLanguage: "en"},
 			},
 			Release: api.ReleaseInfo{
@@ -1217,7 +1247,11 @@ func TestBTNUploadCredentialLoginDoesNotPersistInvalidSession(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/login.php":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			_, _ = w.Write([]byte("ok"))
 		case "/upload.php":
 			_, _ = w.Write([]byte(`<form action="/login.php"><input type="password" name="password" /></form>`))
@@ -1228,7 +1262,6 @@ func TestBTNUploadCredentialLoginDoesNotPersistInvalidSession(t *testing.T) {
 	t.Cleanup(server.Close)
 
 	_, err := ensureBTNUploadSession(ctx, config.TrackerConfig{
-		URL:      server.URL,
 		Username: "user",
 		Password: "pass",
 	}, dbPath, uploadContext{baseURL: server.URL})
@@ -1401,7 +1434,11 @@ func TestResolveSessionForTrackerAuthLoginPersistsCookies(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/login.php":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			_, _ = w.Write([]byte("ok"))
 		case "/upload.php":
 			if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=new") {
@@ -1416,11 +1453,10 @@ func TestResolveSessionForTrackerAuthLoginPersistsCookies(t *testing.T) {
 	}))
 	t.Cleanup(server.Close)
 
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
@@ -1443,7 +1479,11 @@ func TestResolveSessionForTrackerAuthLoginIgnoresIncidentalTwoFactorText(t *test
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/login.php":
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			_, _ = w.Write([]byte(`<html><p>Keep your two-factor recovery codes safe.</p></html>`))
 		case "/upload.php":
 			if got := r.Header.Get("Cookie"); !strings.Contains(got, "session=new") {
@@ -1458,11 +1498,10 @@ func TestResolveSessionForTrackerAuthLoginIgnoresIncidentalTwoFactorText(t *test
 	}))
 	t.Cleanup(server.Close)
 
-	err := ResolveSessionForTrackerAuthLogin(ctx, config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
 	handlerErrs.Check()
 	if err != nil {
 		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
@@ -1489,11 +1528,10 @@ func TestResolveSessionForTrackerAuthLoginRequiresManual2FA(t *testing.T) {
 	}))
 	t.Cleanup(server.Close)
 
-	err := ResolveSessionForTrackerAuthLogin(context.Background(), config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(context.Background(), config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{})
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
 	if err == nil || !strings.Contains(err.Error(), "2FA required") {
 		t.Fatalf("expected 2FA required error, got %v", err)
 	}
@@ -1512,11 +1550,10 @@ func TestResolveSessionForTrackerAuthLoginMarksSubmitted2FARejected(t *testing.T
 	}))
 	t.Cleanup(server.Close)
 
-	err := ResolveSessionForTrackerAuthLogin(context.Background(), config.TrackerConfig{
-		URL:      server.URL,
+	err := resolveSessionForTrackerAuthLoginAt(context.Background(), config.TrackerConfig{
 		Username: "user",
 		Password: "pass",
-	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"})
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"}, server.URL)
 	if !errors.Is(err, ErrSubmitted2FARejected) {
 		t.Fatalf("expected submitted 2FA rejection marker, got %v", err)
 	}
@@ -1532,7 +1569,11 @@ func TestBTNUploadFallsBackToAPIResolution(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.URL.Path == "/login.php" && r.Method == http.MethodPost:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			w.WriteHeader(http.StatusOK)
 			_, _ = w.Write([]byte("ok"))
 		case r.URL.Path == "/upload.php" && r.Method == http.MethodGet:
@@ -1597,9 +1638,9 @@ func TestBTNUploadFallsBackToAPIResolution(t *testing.T) {
 		t.Fatalf("write torrent: %v", err)
 	}
 
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "BTN",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			SourcePath:          sourcePath,
 			TorrentPath:         torrentPath,
 			ReleaseName:         "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
@@ -1614,7 +1655,7 @@ func TestBTNUploadFallsBackToAPIResolution(t *testing.T) {
 			EpisodeOverview:     "Overview",
 			TVDBAiredDate:       "2025-01-01",
 			DescriptionOverride: "[b]Test[/b] description",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 			},
 			Release: api.ReleaseInfo{
@@ -1625,22 +1666,21 @@ func TestBTNUploadFallsBackToAPIResolution(t *testing.T) {
 			Tag: "GRP",
 		},
 		TrackerConfig: config.TrackerConfig{
-			URL:      server.URL,
 			Username: "user",
 			Password: "pass",
 			Unknown: map[string]any{
 				"api_url": server.URL + "/rpc",
 			},
 		},
-		AppConfig: config.Config{
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
 				"BTN": {APIKey: strings.Repeat("x", 30)},
 			}},
-		},
+		}),
 	}
 
-	summary, err := upload(context.Background(), req)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
 	}
@@ -1699,12 +1739,12 @@ func TestBTNSeasonPackReservationFailsClosedOnMalformedAPISearch(t *testing.T) {
 	}))
 	defer server.Close()
 
-	req := trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
+	req := trackers.PreparationInput{
+		Meta: api.UploadSubject{
 			TVPack:    true,
 			SeasonInt: 1,
 			Tag:       "NTb",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				TVDBID:   123456,
 				Category: "TV",
 			},
@@ -1750,16 +1790,16 @@ func TestBTNSeasonPackReservationUsesTranslatedTVDBSeason(t *testing.T) {
 	}))
 	defer server.Close()
 
-	req := trackers.UploadRequest{
-		Meta: api.PreparedMetadata{
+	req := trackers.PreparationInput{
+		Meta: api.UploadSubject{
 			TVPack:    true,
 			SeasonInt: 3,
 			Tag:       "NTb",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				TVDBID:   123456,
 				Category: "TV",
 			},
-			ExternalMetadata: api.ExternalMetadata{
+			ProviderMetadata: api.SourceScopedMetadata{
 				TVDB: &api.TVDBMetadata{EpisodeSeason: 5},
 			},
 		},
@@ -1787,7 +1827,11 @@ func TestBTNUploadFollowsIntermediateDetailPage(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.URL.Path == "/login.php" && r.Method == http.MethodPost:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			w.WriteHeader(http.StatusOK)
 			_, _ = w.Write([]byte("ok"))
 		case r.URL.Path == "/upload.php" && r.Method == http.MethodGet:
@@ -1826,8 +1870,8 @@ func TestBTNUploadFollowsIntermediateDetailPage(t *testing.T) {
 	}))
 	defer server.Close()
 
-	req := newBTNUploadTestRequest(t, server.URL)
-	summary, err := upload(context.Background(), req)
+	req := newBTNUploadTestRequest(t)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
 	}
@@ -1864,7 +1908,11 @@ func TestBTNUploadIntermediateFailureFallsBackToAPI(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.URL.Path == "/login.php" && r.Method == http.MethodPost:
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "new", Path: "/"})
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
 			w.WriteHeader(http.StatusOK)
 			_, _ = w.Write([]byte("ok"))
 		case r.URL.Path == "/upload.php" && r.Method == http.MethodGet:
@@ -1914,9 +1962,9 @@ func TestBTNUploadIntermediateFailureFallsBackToAPI(t *testing.T) {
 	}))
 	defer server.Close()
 
-	req := newBTNUploadTestRequest(t, server.URL)
+	req := newBTNUploadTestRequest(t)
 	req.TrackerConfig.Unknown = map[string]any{"api_url": server.URL + "/rpc"}
-	summary, err := upload(context.Background(), req)
+	summary, err := uploadAt(context.Background(), req, server.URL)
 	if err != nil {
 		t.Fatalf("upload failed: %v", err)
 	}
@@ -1934,7 +1982,7 @@ func TestBTNUploadIntermediateFailureFallsBackToAPI(t *testing.T) {
 	}
 }
 
-func newBTNUploadTestRequest(t *testing.T, serverURL string) trackers.UploadRequest {
+func newBTNUploadTestRequest(t *testing.T) trackers.PreparationInput {
 	t.Helper()
 
 	tempDir := t.TempDir()
@@ -1948,9 +1996,9 @@ func newBTNUploadTestRequest(t *testing.T, serverURL string) trackers.UploadRequ
 		t.Fatalf("write torrent: %v", err)
 	}
 
-	return trackers.UploadRequest{
+	return trackers.PreparationInput{
 		Tracker: "BTN",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			SourcePath:          sourcePath,
 			TorrentPath:         torrentPath,
 			ReleaseName:         "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
@@ -1965,7 +2013,7 @@ func newBTNUploadTestRequest(t *testing.T, serverURL string) trackers.UploadRequ
 			EpisodeOverview:     "Overview",
 			TVDBAiredDate:       "2025-01-01",
 			DescriptionOverride: "[b]Test[/b] description",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 			},
 			Release: api.ReleaseInfo{
@@ -1976,16 +2024,15 @@ func newBTNUploadTestRequest(t *testing.T, serverURL string) trackers.UploadRequ
 			Tag: "GRP",
 		},
 		TrackerConfig: config.TrackerConfig{
-			URL:      serverURL,
 			Username: "user",
 			Password: "pass",
 		},
-		AppConfig: config.Config{
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
 				"BTN": {APIKey: strings.Repeat("x", 30)},
 			}},
-		},
+		}),
 	}
 }
 
@@ -2078,7 +2125,7 @@ func corruptBTNCookieAuthTag(t *testing.T, dbPath string) {
 
 // newBTNDryRunTestRequest returns a minimal TV upload request with a BTN API key.
 // Callers add credentials or stored cookies to exercise dry-run auth gating.
-func newBTNDryRunTestRequest(t *testing.T, dbPath string) trackers.UploadRequest {
+func newBTNDryRunTestRequest(t *testing.T, dbPath string) trackers.PreparationInput {
 	t.Helper()
 
 	tempDir := t.TempDir()
@@ -2090,9 +2137,9 @@ func newBTNDryRunTestRequest(t *testing.T, dbPath string) trackers.UploadRequest
 	if err := os.WriteFile(torrentPath, []byte("d8:announce13:https://x.ee"), 0o600); err != nil {
 		t.Fatalf("write torrent: %v", err)
 	}
-	return trackers.UploadRequest{
+	return trackers.PreparationInput{
 		Tracker: "BTN",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			SourcePath:          sourcePath,
 			TorrentPath:         torrentPath,
 			ReleaseName:         "Example.Show.S01E01.1080p.WEB-DL.x265-GRP",
@@ -2107,7 +2154,7 @@ func newBTNDryRunTestRequest(t *testing.T, dbPath string) trackers.UploadRequest
 			EpisodeOverview:     "Overview",
 			TVDBAiredDate:       "2025-01-01",
 			DescriptionOverride: "[b]Test[/b] description",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 			},
 			Release: api.ReleaseInfo{
@@ -2117,11 +2164,11 @@ func newBTNDryRunTestRequest(t *testing.T, dbPath string) trackers.UploadRequest
 			},
 		},
 		TrackerConfig: config.TrackerConfig{},
-		AppConfig: config.Config{
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 			Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
 				"BTN": {APIKey: strings.Repeat("x", 30)},
 			}},
-		},
+		}),
 	}
 }
diff --git a/internal/trackers/impl/standalone/czt/definition.go b/internal/trackers/impl/standalone/czt/definition.go
new file mode 100644
index 00000000..c234cfa0
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/definition.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package czt
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+// prepareDescription renders the CZTeam user description from caller-supplied
+// prepared assets, using an empty asset set when none are available.
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets := trackers.DescriptionAssets{}
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		resolved, err := trackers.PreparedDescriptionAssets(req.Assets)
+		if err == nil {
+			assets = resolved
+		}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: descGroup, Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/czt/dupe.go b/internal/trackers/impl/standalone/czt/dupe.go
new file mode 100644
index 00000000..260bb870
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/dupe.go
@@ -0,0 +1,269 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package czt
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const cztDefaultBaseURL = "https://czteam.me"
+
+// cztHandler searches CZTeam for existing releases via its JSON search API:
+//
+//	GET {base}/api.php?action=search-torrents&type=name&query=...&passkey=<16-hex>
+//
+// The endpoint authenticates with the user's passkey (the same one used by
+// upload, announce, and download) and normally returns torrent objects either
+// as a bare array or under a small response wrapper.
+type cztHandler struct {
+	cfg     config.Config
+	http    *http.Client
+	logger  api.Logger
+	baseURL string
+}
+
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return cztHandler{
+		cfg:     cfg,
+		http:    httpClient,
+		logger:  logger,
+		baseURL: cztDefaultBaseURL,
+	}
+}
+
+// Search queries CZTeam by the most specific prepared release name available.
+func (h cztHandler) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	tracker, ok := cztTrackerConfig(h.cfg)
+	if !ok {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing passkey for tracker", nil)
+	}
+	passkey := strings.TrimSpace(tracker.Passkey)
+	if passkey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing passkey for tracker", nil)
+	}
+
+	query := cztSearchQuery(meta)
+	if query == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing title for CZT dupe search", nil)
+	}
+
+	base := strings.TrimRight(strings.TrimSpace(h.baseURL), "/")
+	if base == "" {
+		base = cztDefaultBaseURL
+	}
+
+	params := url.Values{}
+	params.Set("action", "search-torrents")
+	params.Set("type", "name")
+	params.Set("query", query)
+	params.Set("passkey", passkey)
+	params.Set("incldead", "1")
+
+	status, payload, err := cztJSONGet(ctx, h.http, base+"/api.php", params)
+	if err != nil {
+		if ctxErr := ctx.Err(); ctxErr != nil {
+			return dupe.Failed(dupe.FailureRequest, "CZT search canceled", ctxErr)
+		}
+		return dupe.Failed(dupe.FailureRequest, "CZT search failed", redactedError(err))
+	}
+	if err := ctx.Err(); err != nil {
+		return dupe.Failed(dupe.FailureRequest, "CZT search canceled", err)
+	}
+	if status < 200 || status >= 300 {
+		return dupe.Failed(dupe.FailureResponseStatus, "CZT search failed", fmt.Errorf("HTTP status %d", status))
+	}
+	if payload == nil {
+		return dupe.Failed(dupe.FailureResponseParse, "CZT search failed: empty response", errors.New("CZT search failed: empty response"))
+	}
+
+	items, ok := cztResultItems(payload)
+	if !ok {
+		return dupe.Failed(
+			dupe.FailureResponseParse,
+			"CZT search failed: unexpected response shape",
+			errors.New("CZT search failed: unexpected response shape"),
+		)
+	}
+
+	entries := make([]api.DupeEntry, 0, len(items))
+	for _, raw := range items {
+		if err := ctx.Err(); err != nil {
+			return dupe.Failed(dupe.FailureRequest, "CZT search canceled", err)
+		}
+		item, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		name := strings.TrimSpace(stringFromAny(firstValue(item,
+			"name", "Name",
+			"torrent_name", "torrentName", "torrentname",
+			"release_name", "releaseName",
+			"title", "Title",
+			"filename", "fileName",
+		)))
+		if name == "" {
+			continue
+		}
+		entry := api.DupeEntry{
+			Name: name,
+			ID:   stringFromAny(firstValue(item, "id", "ID", "torrent_id", "torrentId", "torrentid")),
+			Link: stringFromAny(firstValue(item, "url", "URL", "details_url", "detailsUrl", "link")),
+		}
+		if size := intFromAny(firstValue(item, "size", "Size", "size_bytes", "sizeBytes")); size > 0 {
+			entry.SizeKnown = true
+			entry.SizeBytes = size
+		}
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+// cztSearchQuery prefers exact upload/client names before media titles because
+// CZTeam's name search matches torrent release names.
+func cztSearchQuery(meta api.DuplicateSubject) string {
+	return metautil.FirstNonEmptyTrimmed(
+		meta.SceneName,
+		meta.ReleaseName,
+		meta.Release.Title,
+		meta.Filename,
+	)
+}
+
+// cztResultItems extracts torrent rows from the CZTeam search response. Auth or
+// validation objects without a recognizable result container return false so
+// callers fail the dupe check instead of treating the search as empty.
+func cztResultItems(payload any) ([]any, bool) {
+	if items, ok := payload.([]any); ok {
+		return items, true
+	}
+	obj, ok := payload.(map[string]any)
+	if !ok {
+		return nil, false
+	}
+	for _, key := range []string{"data", "results", "torrents", "response"} {
+		value, ok := obj[key]
+		if !ok {
+			continue
+		}
+		if items, ok := value.([]any); ok {
+			return items, true
+		}
+		if nested, ok := cztResultItems(value); ok {
+			return nested, true
+		}
+	}
+	if values, ok := cztObjectItems(obj); ok {
+		return values, true
+	}
+	return nil, false
+}
+
+// cztObjectItems accepts API shapes that key torrent rows by id. Mixed scalar
+// fields are rejected because those shapes are usually error/status payloads.
+func cztObjectItems(obj map[string]any) ([]any, bool) {
+	if len(obj) == 0 {
+		return nil, false
+	}
+	items := make([]any, 0, len(obj))
+	for _, value := range obj {
+		if _, ok := value.(map[string]any); !ok {
+			return nil, false
+		}
+		items = append(items, value)
+	}
+	return items, true
+}
+
+// redactedError returns an error whose text has passed through the repository
+// redactor, preventing passkeys embedded in transport errors from surfacing in
+// duplicate-check results or progress messages.
+func redactedError(err error) error {
+	if err == nil {
+		return nil
+	}
+	return errors.New(redaction.RedactValue(err.Error(), nil))
+}
+
+func cztJSONGet(ctx context.Context, client *http.Client, endpoint string, params url.Values) (int, any, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return 0, nil, fmt.Errorf("CZT create request: %w", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, nil, fmt.Errorf("CZT request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return resp.StatusCode, nil, nil
+	}
+	var payload any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&payload); err != nil {
+		return resp.StatusCode, nil, fmt.Errorf("dupechecking: decode JSON GET response: %w", err)
+	}
+	return resp.StatusCode, payload, nil
+}
+
+func cztTrackerConfig(cfg config.Config) (config.TrackerConfig, bool) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "CZT") {
+			return entry, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+
+func firstValue(values map[string]any, keys ...string) any {
+	for _, key := range keys {
+		if value, ok := values[key]; ok {
+			return value
+		}
+	}
+	return nil
+}
+
+func stringFromAny(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func intFromAny(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/czt/dupe_test.go b/internal/trackers/impl/standalone/czt/dupe_test.go
new file mode 100644
index 00000000..add7f7d2
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/dupe_test.go
@@ -0,0 +1,501 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package czt
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+func TestCZTHandlerSearchUsesPasskeyAndParsesArray(t *testing.T) {
+	t.Parallel()
+
+	const title = "Movie & Show/2024"
+
+	tests := []struct {
+		name string
+		cfg  config.TrackerConfig
+		meta api.DuplicateSubject
+	}{
+		{
+			name: "passkey only",
+			cfg:  config.TrackerConfig{Passkey: "passkey123"},
+			meta: api.DuplicateSubject{Release: api.ReleaseInfo{Title: title}},
+		},
+		{
+			name: "both credentials use passkey",
+			cfg:  config.TrackerConfig{APIKey: "bearer-token", Passkey: "passkey123"},
+			meta: api.DuplicateSubject{Release: api.ReleaseInfo{Title: title}},
+		},
+		{
+			name: "padded passkey and title fallback",
+			cfg:  config.TrackerConfig{Passkey: " passkey123 "},
+			meta: api.DuplicateSubject{ReleaseName: title},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			handlerErr := make(chan error, 1)
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if err := assertCZTSearchRequest(r, title); err != nil {
+					select {
+					case handlerErr <- err:
+					default:
+					}
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+				_, _ = io.WriteString(w, `[{"id":"77","name":"Movie.2024.1080p.WEB-DL-GRP","url":"https://czteam.me/details.php?id=77","size":12345}]`)
+			}))
+			defer server.Close()
+
+			handler := cztHandler{
+				cfg:     cztTestConfig(tc.cfg),
+				http:    server.Client(),
+				logger:  api.NopLogger{},
+				baseURL: server.URL,
+			}
+			entries, notes, err := adapterEvidence(handler.Search(context.Background(), tc.meta))
+			select {
+			case err := <-handlerErr:
+				t.Fatalf("handler: %v", err)
+			default:
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if len(notes) != 0 {
+				t.Fatalf("unexpected notes: %v", notes)
+			}
+			if len(entries) != 1 {
+				t.Fatalf("expected 1 entry, got %d", len(entries))
+			}
+			entry := entries[0]
+			if entry.ID != "77" || entry.Name != "Movie.2024.1080p.WEB-DL-GRP" || entry.Link == "" {
+				t.Fatalf("unexpected entry: %#v", entry)
+			}
+			if !entry.SizeKnown || entry.SizeBytes != 12345 {
+				t.Fatalf("unexpected size fields: %#v", entry)
+			}
+		})
+	}
+}
+
+func TestCZTHandlerSearchPrefersFullReleaseName(t *testing.T) {
+	t.Parallel()
+
+	const releaseName = "Movie.2024.1080p.WEB-DL-GRP"
+
+	handlerErr := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := assertCZTSearchRequest(r, releaseName); err != nil {
+			select {
+			case handlerErr <- err:
+			default:
+			}
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		_, _ = io.WriteString(w, `[{"id":"77","name":"Movie.2024.1080p.WEB-DL-GRP","url":"https://czteam.me/details.php?id=77"}]`)
+	}))
+	defer server.Close()
+
+	handler := cztHandler{
+		cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+		http:    server.Client(),
+		logger:  api.NopLogger{},
+		baseURL: server.URL,
+	}
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		ReleaseName: releaseName,
+		Release:     api.ReleaseInfo{Title: "Movie"},
+	}))
+	select {
+	case err := <-handlerErr:
+		t.Fatalf("handler: %v", err)
+	default:
+	}
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("unexpected notes: %v", notes)
+	}
+	if len(entries) != 1 || entries[0].Name != releaseName {
+		t.Fatalf("expected release-name result, got %#v", entries)
+	}
+}
+
+func TestCZTHandlerSearchParsesWrappedAndAliasedResults(t *testing.T) {
+	t.Parallel()
+
+	const title = "Movie.2024.1080p.WEB-DL-GRP"
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := assertCZTSearchRequest(r, title); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		_, _ = io.WriteString(w, `{"data":{"results":[{"torrent_id":77,"torrent_name":"Movie.2024.1080p.WEB-DL-GRP","details_url":"https://czteam.me/details.php?id=77","size_bytes":12345}]}}`)
+	}))
+	defer server.Close()
+
+	handler := cztHandler{
+		cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+		http:    server.Client(),
+		logger:  api.NopLogger{},
+		baseURL: server.URL,
+	}
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+		ReleaseName: title,
+	}))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("unexpected notes: %v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected one entry, got %#v", entries)
+	}
+	entry := entries[0]
+	if entry.ID != "77" || entry.Name != title || entry.Link != "https://czteam.me/details.php?id=77" {
+		t.Fatalf("unexpected entry: %#v", entry)
+	}
+	if !entry.SizeKnown || entry.SizeBytes != 12345 {
+		t.Fatalf("unexpected size fields: %#v", entry)
+	}
+}
+
+func TestCZTHandlerSearchCancellationAfterResponseReturnsNoEntries(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	client := &http.Client{Transport: cztRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		cancel()
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader(`[{"id":"77","name":"Movie","url":"https://czteam.me/details.php?id=77"}]`)),
+			Request:    req,
+		}, nil
+	})}
+	handler := cztHandler{
+		cfg:    cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+		http:   client,
+		logger: api.NopLogger{},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(ctx, api.DuplicateSubject{
+		Release: api.ReleaseInfo{Title: "Movie"},
+	}))
+	if err == nil {
+		t.Fatal("expected context cancellation error")
+	}
+	if len(entries) != 0 || len(notes) != 0 {
+		t.Fatalf("expected no entries or notes after cancellation, got entries=%v notes=%v", entries, notes)
+	}
+}
+
+func TestCZTHandlerSearchCancellationDuringRequestPropagatesContext(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	client := &http.Client{Transport: cztRoundTripFunc(func(_ *http.Request) (*http.Response, error) {
+		cancel()
+		return nil, context.Canceled
+	})}
+	handler := cztHandler{
+		cfg:    cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+		http:   client,
+		logger: api.NopLogger{},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(ctx, api.DuplicateSubject{
+		Release: api.ReleaseInfo{Title: "Movie"},
+	}))
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected context cancellation error, got %v", err)
+	}
+	if err != nil && strings.Contains(err.Error(), "CZT search failed") {
+		t.Fatalf("expected cancellation before CZT search wrapping, got %v", err)
+	}
+	if len(entries) != 0 || len(notes) != 0 {
+		t.Fatalf("expected no entries or notes after cancellation, got entries=%v notes=%v", entries, notes)
+	}
+}
+
+type cztRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f cztRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+func TestCZTHandlerSearchRequestAssertionReportsOnTestGoroutine(t *testing.T) {
+	t.Parallel()
+
+	const title = "Movie & Show/2024"
+
+	tests := []struct {
+		name        string
+		target      func(baseURL string) string
+		wantErrPart string
+	}{
+		{
+			name: "wrong path",
+			target: func(baseURL string) string {
+				return baseURL + "/wrong"
+			},
+			wantErrPart: "unexpected path",
+		},
+		{
+			name: "wrong query",
+			target: func(baseURL string) string {
+				return baseURL + "/api.php?action=search-torrents&type=name&passkey=passkey123&query=Wrong&incldead=1"
+			},
+			wantErrPart: "query",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			handlerErr := make(chan error, 1)
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if err := assertCZTSearchRequest(r, title); err != nil {
+					select {
+					case handlerErr <- err:
+					default:
+					}
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+				w.WriteHeader(http.StatusOK)
+			}))
+			defer server.Close()
+
+			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, tc.target(server.URL), nil)
+			if err != nil {
+				t.Fatalf("new request: %v", err)
+			}
+			resp, err := server.Client().Do(req)
+			if err != nil {
+				t.Fatalf("do request: %v", err)
+			}
+			defer resp.Body.Close()
+			if resp.StatusCode != http.StatusInternalServerError {
+				t.Fatalf("expected status %d, got %d", http.StatusInternalServerError, resp.StatusCode)
+			}
+
+			select {
+			case err := <-handlerErr:
+				if !strings.Contains(err.Error(), tc.wantErrPart) {
+					t.Fatalf("expected handler assertion error containing %q, got %v", tc.wantErrPart, err)
+				}
+			default:
+				t.Fatalf("expected handler assertion error")
+			}
+		})
+	}
+}
+
+func TestCZTHandlerSearchCredentialMatrix(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		cfg       config.TrackerConfig
+		wantSkip  string
+		wantError string
+	}{
+		{
+			name:     "missing all credentials skips",
+			cfg:      config.TrackerConfig{},
+			wantSkip: "missing passkey",
+		},
+		{
+			name:     "api key only is ignored",
+			cfg:      config.TrackerConfig{APIKey: "bearer-token"},
+			wantSkip: "missing passkey",
+		},
+		{
+			name:     "padded api key only is ignored",
+			cfg:      config.TrackerConfig{APIKey: " bearer-token "},
+			wantSkip: "missing passkey",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			handler := cztHandler{
+				cfg:    cztTestConfig(tc.cfg),
+				http:   http.DefaultClient,
+				logger: api.NopLogger{},
+			}
+			result := handler.Search(context.Background(), api.DuplicateSubject{
+				Release: api.ReleaseInfo{Title: "Movie"},
+			})
+			notes, err := result.Notes(), result.Cause()
+			if tc.wantError != "" {
+				if err == nil || !strings.Contains(err.Error(), tc.wantError) {
+					t.Fatalf("expected error containing %q, got %v", tc.wantError, err)
+				}
+				if len(notes) != 0 {
+					t.Fatalf("expected no skip notes on failure, got %v", notes)
+				}
+				return
+			}
+			if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunMissingCredentials ||
+				!strings.Contains(result.SafeMessage(), tc.wantSkip) {
+				t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+			}
+		})
+	}
+}
+
+func TestCZTHandlerSearchRemoteFailuresReturnErrors(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		statusCode int
+		body       string
+		wantError  string
+	}{
+		{
+			name:       "non 2xx",
+			statusCode: http.StatusUnauthorized,
+			body:       `{"error":"bad auth"}`,
+			wantError:  "HTTP status 401",
+		},
+		{
+			name:       "auth object",
+			statusCode: http.StatusOK,
+			body:       `{"error":"bad auth"}`,
+			wantError:  "unexpected response shape",
+		},
+		{
+			name:       "null",
+			statusCode: http.StatusOK,
+			body:       `null`,
+			wantError:  "empty response",
+		},
+		{
+			name:       "scalar",
+			statusCode: http.StatusOK,
+			body:       `"ok"`,
+			wantError:  "unexpected response shape",
+		},
+		{
+			name:       "malformed",
+			statusCode: http.StatusOK,
+			body:       `{`,
+			wantError:  "decode JSON GET response",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(tc.statusCode)
+				_, _ = io.WriteString(w, tc.body)
+			}))
+			defer server.Close()
+
+			handler := cztHandler{
+				cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+				http:    server.Client(),
+				logger:  api.NopLogger{},
+				baseURL: server.URL,
+			}
+			_, notes, err := adapterEvidence(handler.Search(context.Background(), api.DuplicateSubject{
+				Release: api.ReleaseInfo{Title: "Movie"},
+			}))
+			if err == nil || !strings.Contains(err.Error(), tc.wantError) {
+				t.Fatalf("expected error containing %q, got %v", tc.wantError, err)
+			}
+			if len(notes) != 0 {
+				t.Fatalf("expected no skip notes on failure, got %v", notes)
+			}
+			if strings.Contains(err.Error(), "passkey123") {
+				t.Fatalf("error leaked passkey: %v", err)
+			}
+		})
+	}
+}
+
+func TestCZTHandlerSearchMissingTitleSkipsWithoutHTTP(t *testing.T) {
+	t.Parallel()
+
+	var called atomic.Bool
+	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
+		called.Store(true)
+	}))
+	defer server.Close()
+
+	handler := cztHandler{
+		cfg:     cztTestConfig(config.TrackerConfig{Passkey: "passkey123"}),
+		http:    server.Client(),
+		logger:  api.NopLogger{},
+		baseURL: server.URL,
+	}
+	result := handler.Search(context.Background(), api.DuplicateSubject{})
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunMissingMetadata ||
+		!strings.Contains(result.SafeMessage(), "missing title") {
+		t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+	}
+	if called.Load() {
+		t.Fatalf("expected no HTTP call")
+	}
+}
+
+func cztTestConfig(tracker config.TrackerConfig) config.Config {
+	return config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"CZT": tracker,
+	}}}
+}
+
+func assertCZTSearchRequest(r *http.Request, title string) error {
+	if r.URL.Path != "/api.php" {
+		return fmt.Errorf("unexpected path: %s", r.URL.Path)
+	}
+	if got := r.URL.Query().Get("action"); got != "search-torrents" {
+		return fmt.Errorf("action query: got %q", got)
+	}
+	if got := r.URL.Query().Get("type"); got != "name" {
+		return fmt.Errorf("type query: got %q", got)
+	}
+	if got := r.URL.Query().Get("passkey"); got != "passkey123" {
+		return errors.New("passkey query mismatch")
+	}
+	if got := r.URL.Query().Get("query"); got != title {
+		return fmt.Errorf("query: got %q", got)
+	}
+	if got := r.URL.Query().Get("incldead"); got != "1" {
+		return fmt.Errorf("incldead query: got %q", got)
+	}
+	if got := r.Header.Get("Authorization"); got != "" {
+		return errors.New("unexpected authorization header")
+	}
+	return nil
+}
diff --git a/internal/trackers/impl/standalone/czt/profile.go b/internal/trackers/impl/standalone/czt/profile.go
new file mode 100644
index 00000000..9872b6d1
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/profile.go
@@ -0,0 +1,35 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package czt
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns CZT identity, preparation, dupe, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                trackerName,
+		BaseURL:             defaultBaseURL,
+		DescriptionGroup:    descGroup,
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDBIDOnly},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: "CzT"},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"czteam.me"}},
+	}
+}
+
+// New returns a fresh CZT definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/czt/upload.go b/internal/trackers/impl/standalone/czt/upload.go
new file mode 100644
index 00000000..0caacc1c
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/upload.go
@@ -0,0 +1,999 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package czt implements uploads to CZTeam (CZT) via its dedicated JSON
+// endpoint takeupload_api.php.
+//
+// Unlike most impls in this repo CZTeam is not a UNIT3D site and does not need a
+// cookie jar: the user's passkey authenticates the multipart POST. The endpoint
+// returns the registered .torrent inline as base64, already personalized with
+// the uploader's announce passkey and source=CzT.
+package czt
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"maps"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/anacrolix/torrent/metainfo"
+
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	trackerName               = "CZT"
+	descGroup                 = "czt"
+	defaultBaseURL            = "https://czteam.me"
+	uploadPath                = "/takeupload_api.php"
+	uploadTimeout             = 120 * time.Second
+	defaultCZTPostCancelGrace = 5 * time.Second
+	cztUploadDecodeFieldBytes = 512
+)
+
+var cztPostCancelGrace atomic.Int64
+
+func init() {
+	cztPostCancelGrace.Store(int64(defaultCZTPostCancelGrace))
+}
+
+var (
+	newCZTUploadHTTPClient = func() *http.Client {
+		return &http.Client{Timeout: uploadTimeout}
+	}
+	cztBaseURL = defaultBaseURL
+)
+
+// uploadResponse mirrors the JSON returned by takeupload_api.php. A 201 carries
+// the full set; a 409 duplicate still returns id/name/download_url/torrent_b64.
+type uploadResponse struct {
+	ID          int    `json:"id"`
+	Name        string `json:"name"`
+	InfoHash    string `json:"infohash"`
+	DownloadURL string `json:"download_url"`
+	TorrentB64  string `json:"torrent_b64"`
+	Error       string `json:"error"`
+}
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	files         []commonhttp.FileField
+	endpoint      string
+	baseURL       string
+	questionnaire *api.TrackerQuestionnaire
+}
+
+func upload(ctx context.Context, req trackers.PreparationInput) (api.UploadSummary, error) {
+	if err := ctx.Err(); err != nil {
+		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
+	}
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, prepareUpload)
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: CZT submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req, req.Intent == trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, state.files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+) (api.UploadSummary, error) {
+	if err := ctx.Err(); err != nil {
+		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
+	}
+
+	httpReq, err := http.NewRequestWithContext(context.WithoutCancel(ctx), http.MethodPost, state.endpoint, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: CZT build upload request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	// Once the CZT upload POST is sent, cancellation can race with an
+	// irreversible remote 201. Give the tracker a short grace to return that
+	// result, but do not wait for the full client timeout after caller cancel.
+	postCtx, startPost, cancelPost := newCZTPostRequestContext(ctx)
+	defer cancelPost()
+	client := cztUploadHTTPClientWithStartHook(newCZTUploadHTTPClient(), startPost)
+	execution, err := commonhttp.ExecuteUpload(client, httpReq.WithContext(postCtx), commonhttp.UploadExecutionOptions{
+		Tracker:       trackerName,
+		SuccessStatus: func(status int) bool { return status == http.StatusCreated },
+		SuccessBody:   commonhttp.FullSuccessBody,
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: CZT execute upload: %w", err)
+	}
+	responseBody, responsePreview := execution.Body, execution.Preview
+	if execution.StatusCode != http.StatusCreated {
+		if err := ctx.Err(); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
+		}
+	}
+
+	// Only a fresh 201 with a torrent id is a successful upload. A 409 means the
+	// release name already exists; surface it as an error (the response still
+	// carries the existing torrent for callers who want to cross-seed).
+	if execution.StatusCode != http.StatusCreated {
+		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, trackerName, "upload_failure", responsePreview, ".json")
+		return api.UploadSummary{}, commonhttp.UploadHTTPError(trackerName, execution.StatusCode, responsePreview)
+	}
+
+	torrentIDValue, err := parseCZTUploadID(responseBody)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: CZT parse upload response id: %w", err)
+	}
+	if torrentIDValue <= 0 {
+		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, trackerName, "upload_failure", responsePreview, ".json")
+		return api.UploadSummary{}, commonhttp.UploadHTTPError(trackerName, execution.StatusCode, responsePreview)
+	}
+
+	torrentID := strconv.Itoa(torrentIDValue)
+	torrentURL := state.baseURL + "/details.php?id=" + torrentID
+	summary := api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+		Tracker:    trackerName,
+		TorrentID:  torrentID,
+		TorrentURL: torrentURL,
+	}}}
+
+	parsed, err := parseCZTUploadResponse(responseBody)
+	if err != nil {
+		warnCZTLocalUploadFailure(req.Logger, "parse upload response", err)
+	}
+
+	if strings.TrimSpace(parsed.DownloadURL) != "" {
+		downloadURL, err := joinCZTURL(state.baseURL, parsed.DownloadURL)
+		if err != nil {
+			warnCZTLocalUploadFailure(req.Logger, "upload response download_url", err)
+		} else {
+			summary.UploadedTorrents[0].DownloadURL = downloadURL
+		}
+	}
+
+	if err := ctx.Err(); err != nil {
+		warnCZTLocalUploadFailure(req.Logger, "post-success cancellation", err)
+		return finalizeCZTUploadSummary(summary), nil
+	}
+
+	// The endpoint returns the registered .torrent inline (base64), already
+	// personalized with the uploader's announce passkey and source=CzT, so we
+	// persist that directly rather than re-deriving an announce URL.
+	artifactPath, err := persistReturnedTorrent(req, parsed.TorrentB64)
+	if err != nil {
+		warnCZTLocalUploadFailure(req.Logger, "persist returned torrent", err)
+		return finalizeCZTUploadSummary(summary), nil
+	}
+	if strings.TrimSpace(artifactPath) != "" {
+		summary.UploadedTorrents[0].TorrentPath = artifactPath
+	}
+
+	if err := ctx.Err(); err != nil {
+		warnCZTLocalUploadFailure(req.Logger, "post-success cancellation", err)
+		return finalizeCZTUploadSummary(summary), nil
+	}
+
+	return finalizeCZTUploadSummary(summary), nil
+}
+
+func warnCZTLocalUploadFailure(logger api.Logger, step string, err error) {
+	if logger == nil || err == nil {
+		return
+	}
+	logger.Warnf("trackers: CZT upload completed remotely but local %s failed: %v", step, err)
+}
+
+// newCZTPostRequestContext lets an in-flight POST outlive caller cancellation
+// for a short grace period so an irreversible 201 response can still be
+// accounted for, then cancels the request before the full client timeout.
+func newCZTPostRequestContext(ctx context.Context) (context.Context, func() error, context.CancelFunc) {
+	postCtx, cancelPost := context.WithCancel(context.WithoutCancel(ctx))
+	startPost := func() error { return nil }
+	if ctx.Done() == nil {
+		return postCtx, startPost, cancelPost
+	}
+
+	started := make(chan struct{})
+	done := make(chan struct{})
+	var startedFlag atomic.Bool
+	var startOnce sync.Once
+	var cancelOnce sync.Once
+	startPost = func() error {
+		if startedFlag.Load() {
+			return nil
+		}
+		if err := ctx.Err(); err != nil {
+			cancelPost()
+			return fmt.Errorf("context canceled: %w", err)
+		}
+		startOnce.Do(func() {
+			startedFlag.Store(true)
+			close(started)
+		})
+		return nil
+	}
+
+	waitGrace := func() {
+		timer := time.NewTimer(time.Duration(cztPostCancelGrace.Load()))
+		defer timer.Stop()
+		select {
+		case <-timer.C:
+			cancelPost()
+		case <-done:
+		}
+	}
+
+	go func() {
+		select {
+		case <-started:
+			select {
+			case <-ctx.Done():
+				waitGrace()
+			case <-done:
+			}
+		case <-ctx.Done():
+			select {
+			case <-started:
+				waitGrace()
+			default:
+				cancelPost()
+			}
+		case <-done:
+		}
+	}()
+
+	return postCtx, startPost, func() {
+		cancelOnce.Do(func() {
+			close(done)
+			cancelPost()
+		})
+	}
+}
+
+type cztPostStartTransport struct {
+	base  http.RoundTripper
+	start func() error
+}
+
+// RoundTrip records the exact start of the irreversible CZT POST and rejects
+// the request if the caller canceled before the transport begins sending it.
+func (t cztPostStartTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if err := t.start(); err != nil {
+		return nil, fmt.Errorf("start CZT upload request: %w", err)
+	}
+	resp, err := t.base.RoundTrip(req)
+	if err != nil {
+		return nil, fmt.Errorf("CZT upload round trip: %w", err)
+	}
+	return resp, nil
+}
+
+func cztUploadHTTPClientWithStartHook(client *http.Client, start func() error) *http.Client {
+	if client == nil {
+		client = &http.Client{Timeout: uploadTimeout}
+	}
+	base := client.Transport
+	if base == nil {
+		base = http.DefaultTransport
+	}
+	out := *client
+	out.Transport = cztPostStartTransport{base: base, start: start}
+	return &out
+}
+
+// finalizeCZTUploadSummary drops uploaded rows that cannot be injected or
+// downloaded locally while preserving the accepted remote upload count.
+func finalizeCZTUploadSummary(summary api.UploadSummary) api.UploadSummary {
+	if len(summary.UploadedTorrents) == 0 {
+		return summary
+	}
+	out := summary.UploadedTorrents[:0]
+	for _, uploaded := range summary.UploadedTorrents {
+		if strings.TrimSpace(uploaded.TorrentPath) != "" || strings.TrimSpace(uploaded.DownloadURL) != "" {
+			out = append(out, uploaded)
+		}
+	}
+	summary.UploadedTorrents = out
+	return summary
+}
+
+func parseCZTUploadID(body []byte) (int, error) {
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(body, &fields); err != nil {
+		return 0, redactCZTUploadDecodeError("decode CZT upload response fields", err)
+	}
+	var id int
+	if err := json.Unmarshal(fields["id"], &id); err != nil {
+		return 0, redactCZTUploadDecodeError("decode CZT upload response id", err)
+	}
+	return id, nil
+}
+
+func parseCZTUploadResponse(body []byte) (uploadResponse, error) {
+	var parsed uploadResponse
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(body, &fields); err != nil {
+		return parsed, redactCZTUploadDecodeError("decode CZT upload response fields", err)
+	}
+	if err := json.Unmarshal(fields["id"], &parsed.ID); err != nil {
+		return parsed, redactCZTUploadDecodeError("decode CZT upload response id", err)
+	}
+	var fieldErrs []error
+	parseOptionalStringField(fields, "name", &parsed.Name, &fieldErrs)
+	parseOptionalStringField(fields, "infohash", &parsed.InfoHash, &fieldErrs)
+	parseOptionalStringField(fields, "download_url", &parsed.DownloadURL, &fieldErrs)
+	parseOptionalStringField(fields, "torrent_b64", &parsed.TorrentB64, &fieldErrs)
+	parseOptionalStringField(fields, "error", &parsed.Error, &fieldErrs)
+	return parsed, errors.Join(fieldErrs...)
+}
+
+// redactCZTUploadDecodeError preserves parse context while removing any
+// secret-bearing fragments that encoding/json may echo from the response body.
+func redactCZTUploadDecodeError(context string, err error) error {
+	return fmt.Errorf("%s: %s", context, redaction.RedactValue(err.Error(), nil))
+}
+
+func parseOptionalStringField(fields map[string]json.RawMessage, name string, dest *string, errs *[]error) {
+	raw := fields[name]
+	if len(raw) == 0 {
+		return
+	}
+	if err := json.Unmarshal(raw, dest); err != nil {
+		preview := string(raw)
+		if len(preview) > cztUploadDecodeFieldBytes {
+			preview = preview[:cztUploadDecodeFieldBytes] + "..."
+		}
+		*errs = append(*errs, fmt.Errorf("%s: %s", name, redaction.RedactValue(fmt.Sprintf("value=%s: %s", preview, err.Error()), nil)))
+	}
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	fields := maps.Clone(state.fields)
+	if _, ok := fields["passkey"]; ok {
+		fields["passkey"] = "[redacted]"
+	}
+	blockedReason := ""
+	if missingRequiredCategory(state) {
+		blockedReason = "answer the category questionnaire to continue"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          trackerName,
+		BlockedReason:    blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: descGroup,
+		Description:      state.description,
+		Endpoint:         state.endpoint,
+		Payload:          fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, requireCategory bool) (uploadState, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+
+	assets := uploadDescriptionAssets(ctx, req)
+
+	// CZTeam stores two description fields separately: `descr` holds the raw
+	// MediaInfo/BDInfo dump, and `user_descr` holds the free-form BBCode body
+	// (user notes + screenshot images).
+	mediaInfo := buildMediaInfo(req)
+	userDescr := buildDescription(req, assets)
+	releaseName := resolveName(req.Meta)
+	baseURL := resolveBaseURL()
+	passkey := strings.TrimSpace(req.TrackerConfig.Passkey)
+	if passkey == "" {
+		return uploadState{}, errors.New("trackers: CZT missing passkey")
+	}
+
+	category, err := resolveCategory(req.Meta)
+	if err != nil {
+		if requireCategory {
+			return uploadState{}, err
+		}
+		category = ""
+	}
+
+	fields := map[string]string{
+		"name": releaseName,
+	}
+	if category != "" {
+		fields["category"] = category
+	}
+	if strings.TrimSpace(mediaInfo) != "" {
+		fields["descr"] = mediaInfo
+	}
+	if strings.TrimSpace(userDescr) != "" {
+		fields["user_descr"] = userDescr
+	}
+	if imdb := imdbID(req.Meta); imdb != "" {
+		fields["imdb_id"] = imdb
+	}
+	// resolution/codec/container/source are validated server-side against the
+	// tracker's allowed value set; unknown values are dropped, not rejected.
+	if res := strings.TrimSpace(req.Meta.Release.Resolution); res != "" {
+		fields["resolution"] = res
+	}
+	if codec := firstCodec(req.Meta); codec != "" {
+		fields["codec"] = codec
+	}
+	if container := strings.TrimSpace(req.Meta.Container); container != "" {
+		fields["container"] = container
+	}
+	if source := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(req.Meta.Source, req.Meta.Release.Source)); source != "" {
+		fields["source"] = source
+	}
+	fields["passkey"] = passkey
+
+	return uploadState{
+		torrentPath: torrentPath,
+		description: userDescr,
+		releaseName: releaseName,
+		fields:      fields,
+		files: []commonhttp.FileField{{
+			FieldName: "file",
+			FileName:  releaseName + ".torrent",
+			Path:      torrentPath,
+		}},
+		endpoint:      baseURL + uploadPath,
+		baseURL:       baseURL,
+		questionnaire: categoryQuestionnaire(req.Meta),
+	}, nil
+}
+
+// uploadDescriptionAssets uses caller-prepared assets when available, falling
+// back to local resolution and an empty asset set on resolution failure.
+func uploadDescriptionAssets(_ context.Context, req trackers.PreparationInput) trackers.DescriptionAssets {
+	if req.Assets != nil {
+		return *req.Assets
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		return trackers.DescriptionAssets{}
+	}
+	return assets
+}
+
+// persistReturnedTorrent decodes the tracker-returned base64 torrent, verifies
+// it parses as metainfo, and writes the registered torrent artifact with user
+// read/write permissions only. Cleanup errors after replacement return the
+// artifact path with a non-nil error so callers can avoid reporting it as
+// successfully persisted.
+func persistReturnedTorrent(req trackers.PreparationInput, b64 string) (string, error) {
+	if strings.TrimSpace(b64) == "" {
+		return "", errors.New("empty torrent_b64")
+	}
+	decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(b64))
+	if err != nil {
+		return "", fmt.Errorf("decode torrent_b64: %w", err)
+	}
+	if len(decoded) == 0 {
+		return "", errors.New("decoded torrent_b64 is empty")
+	}
+	torrentMeta, err := metainfo.Load(bytes.NewReader(decoded))
+	if err != nil {
+		return "", fmt.Errorf("load returned torrent: %w", err)
+	}
+	if _, err := torrentMeta.UnmarshalInfo(); err != nil {
+		return "", fmt.Errorf("unmarshal returned torrent info: %w", err)
+	}
+	path, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, trackerName)
+	if err != nil {
+		return "", fmt.Errorf("resolve returned torrent path: %w", err)
+	}
+	if err := writeReturnedTorrent(path, decoded); err != nil {
+		var cleanupErr returnedTorrentCleanupError
+		if errors.As(err, &cleanupErr) {
+			return path, fmt.Errorf("write returned torrent: %w", err)
+		}
+		return "", fmt.Errorf("write returned torrent: %w", err)
+	}
+	return path, nil
+}
+
+// writeReturnedTorrent stages returned torrent bytes in the destination
+// directory before replacing the final artifact path, so a failed write does
+// not truncate an existing registered torrent.
+func writeReturnedTorrent(path string, data []byte) error {
+	dir := filepath.Dir(path)
+	tmpFile, err := os.CreateTemp(dir, filepath.Base(path)+".tmp-*")
+	if err != nil {
+		return fmt.Errorf("create temp returned torrent: %w", err)
+	}
+	tmpPath := tmpFile.Name()
+	removeTemp := true
+	defer func() {
+		if removeTemp {
+			_ = os.Remove(tmpPath)
+		}
+	}()
+
+	if err := tmpFile.Chmod(0o600); err != nil {
+		_ = tmpFile.Close()
+		return fmt.Errorf("chmod temp returned torrent: %w", err)
+	}
+	if _, err := tmpFile.Write(data); err != nil {
+		_ = tmpFile.Close()
+		return fmt.Errorf("write temp returned torrent: %w", err)
+	}
+	if err := tmpFile.Sync(); err != nil {
+		_ = tmpFile.Close()
+		return fmt.Errorf("sync temp returned torrent: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		return fmt.Errorf("close temp returned torrent: %w", err)
+	}
+	if err := replaceStagedReturnedTorrent(tmpPath, path); err != nil {
+		return err
+	}
+	removeTemp = false
+	return nil
+}
+
+// replaceStagedReturnedTorrent moves a staged torrent into place. Existing
+// artifacts are first moved to a temporary backup and restored if the final
+// rename fails.
+func replaceStagedReturnedTorrent(tmpPath string, outputPath string) error {
+	info, err := os.Stat(outputPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			if renameErr := os.Rename(tmpPath, outputPath); renameErr != nil {
+				return fmt.Errorf("rename staged returned torrent into place: %w", renameErr)
+			}
+			return nil
+		}
+		return fmt.Errorf("stat returned torrent: %w", err)
+	}
+	if info.IsDir() {
+		return fmt.Errorf("%s is a directory", outputPath)
+	}
+
+	backupPath, err := reserveReturnedTorrentBackupPath(filepath.Dir(outputPath), filepath.Base(outputPath)+".backup-*")
+	if err != nil {
+		return err
+	}
+	if err := os.Rename(outputPath, backupPath); err != nil {
+		_ = os.Remove(backupPath)
+		return fmt.Errorf("backup existing returned torrent: %w", err)
+	}
+	if err := os.Rename(tmpPath, outputPath); err != nil {
+		restoreErr := os.Rename(backupPath, outputPath)
+		if restoreErr != nil {
+			return errors.Join(err, fmt.Errorf("restore existing returned torrent: %w", restoreErr))
+		}
+		return fmt.Errorf("replace existing returned torrent: %w", err)
+	}
+	if err := removeReturnedTorrentBackup(backupPath); err != nil {
+		return returnedTorrentCleanupError{cause: fmt.Errorf("remove returned torrent backup: %w", err)}
+	}
+	return nil
+}
+
+type returnedTorrentCleanupError struct {
+	cause error
+}
+
+func (e returnedTorrentCleanupError) Error() string {
+	return e.cause.Error()
+}
+
+func (e returnedTorrentCleanupError) Unwrap() error {
+	return e.cause
+}
+
+var removeReturnedTorrentBackup = os.Remove
+
+// reserveReturnedTorrentBackupPath reserves and releases a same-directory path
+// suitable for temporarily holding the existing registered torrent.
+func reserveReturnedTorrentBackupPath(dir string, pattern string) (string, error) {
+	file, err := os.CreateTemp(dir, pattern)
+	if err != nil {
+		return "", fmt.Errorf("create temp returned torrent backup marker: %w", err)
+	}
+	path := file.Name()
+	closeErr := file.Close()
+	removeErr := os.Remove(path)
+	if closeErr != nil || removeErr != nil {
+		return "", errors.Join(closeErr, removeErr)
+	}
+	return path, nil
+}
+
+// buildMediaInfo returns the raw MediaInfo/BDInfo text for the CZTeam `descr`
+// field.
+func buildMediaInfo(req trackers.PreparationInput) string {
+	return strings.TrimSpace(trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, req.Meta))
+}
+
+// buildDescription assembles the CZTeam `user_descr` body: the (possibly
+// user-edited) description text followed by a BBCode screenshot block. Kept as a
+// separate function so definition.BuildDescription can drive the description
+// builder UI with the same output.
+func buildDescription(_ trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	// A "final" description is the already-assembled body (saved override or
+	// canonical group description) with screenshots embedded; the resolver does
+	// not clear assets.Screenshots here, so re-appending would duplicate them.
+	// Use it verbatim, matching the assets.Final convention other impls follow.
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	parts := make([]string, 0, 2)
+	if body := strings.TrimSpace(assets.Description); body != "" {
+		parts = append(parts, body)
+	}
+	if shots := bbcodeScreenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+	return strings.TrimSpace(strings.Join(parts, "\n\n"))
+}
+
+// bbcodeScreenshotBlock renders at most two raw screenshot image URLs. CZTeam's
+// formatter accepts plain [img] tags here; linked/thumbnail URLs are ignored.
+func bbcodeScreenshotBlock(images []api.ScreenshotImage) string {
+	parts := make([]string, 0, 2)
+	for _, image := range images {
+		raw := strings.TrimSpace(image.RawURL)
+		if raw == "" {
+			continue
+		}
+		parts = append(parts, "[img]"+raw+"[/img]")
+		if len(parts) == 2 {
+			break
+		}
+	}
+	return strings.Join(parts, "\n")
+}
+
+// resolveBaseURL returns the fixed CZTeam origin used for upload, details, and
+// returned download URLs. CZTeam is not a tracker family/configurable endpoint.
+func resolveBaseURL() string {
+	if trimmed := strings.TrimRight(strings.TrimSpace(cztBaseURL), "/"); trimmed != "" {
+		return trimmed
+	}
+	return defaultBaseURL
+}
+
+// joinCZTURL resolves a tracker-provided download URL against the CZTeam base
+// URL, strips URL userinfo, and rejects empty, non-addressable, or
+// cross-host results.
+func joinCZTURL(baseURL string, rawRef string) (string, error) {
+	trimmedRef := strings.TrimSpace(rawRef)
+	if trimmedRef == "" {
+		return "", errors.New("empty URL")
+	}
+	base, err := url.Parse(resolveCZTURLBase(baseURL) + "/")
+	if err != nil {
+		return "", fmt.Errorf("parse base URL: %w", err)
+	}
+	if base.Scheme == "" || base.Host == "" {
+		return "", errors.New("base URL must be absolute")
+	}
+	ref, err := url.Parse(trimmedRef)
+	if err != nil {
+		return "", fmt.Errorf("parse URL: %w", err)
+	}
+	resolved := base.ResolveReference(ref)
+	if resolved.Scheme == "" || resolved.Host == "" {
+		return "", errors.New("resolved URL must be absolute")
+	}
+	if !strings.EqualFold(resolved.Scheme, base.Scheme) || !strings.EqualFold(resolved.Host, base.Host) {
+		return "", errors.New("resolved URL must stay on configured CZT host")
+	}
+	if !hasUsableCZTDownloadPath(resolved.Path) {
+		return "", errors.New("resolved URL has no torrent path")
+	}
+	resolved.User = nil
+	return resolved.String(), nil
+}
+
+func hasUsableCZTDownloadPath(path string) bool {
+	trimmed := strings.TrimSpace(path)
+	return trimmed != "" && trimmed != "/"
+}
+
+// resolveCZTURLBase normalizes a base URL before resolving tracker-provided
+// relative download URLs against it.
+func resolveCZTURLBase(baseURL string) string {
+	trimmed := strings.TrimSpace(baseURL)
+	parsed, err := url.Parse(trimmed)
+	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+		return strings.TrimRight(trimmed, "/")
+	}
+	parsed.Path = ""
+	parsed.RawPath = ""
+	parsed.RawQuery = ""
+	parsed.ForceQuery = false
+	parsed.Fragment = ""
+	parsed.User = nil
+	return strings.TrimRight(parsed.String(), "/")
+}
+
+func resolveName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.SceneName); name != "" {
+		return name
+	}
+	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename))
+}
+
+// cztCategory pairs a CZTeam categories.id with its display name.
+type cztCategory struct {
+	id   string
+	name string
+}
+
+// cztCategories lists CZTeam upload categories for the upload-time override
+// dropdown. upbrr auto-detects only video categories from metadata; everything
+// else (software, games, music, XXX, images, docs, …) is chosen here.
+var cztCategories = []cztCategory{
+	{"1", "XxX"},
+	{"4", "Games/PC ISO"},
+	{"5", "TvEps/HD"},
+	{"6", "Music/Audio"},
+	{"7", "TvEps"},
+	{"9", "Mobile"},
+	{"12", "Games/Consoles"},
+	{"19", "Movies/XviD"},
+	{"20", "Movies/DVD-R"},
+	{"21", "Games/PC Rips"},
+	{"22", "Software"},
+	{"23", "Anime"},
+	{"24", "Images"},
+	{"25", "Docs"},
+	{"28", "Movies/DVD-RO"},
+	{"29", "Movies/HD"},
+	{"30", "Music/MVID"},
+	{"31", "MAC"},
+	{"32", "Sports"},
+	{"33", "Movies/HDTV-RO"},
+	{"34", "TvEps/HD-RO"},
+	{"35", "Music/Lossless"},
+	{"36", "Full BluRay-RO"},
+	{"37", "Movies/3D"},
+	{"38", "Movies-RO"},
+}
+
+func categoryNames() []string {
+	out := make([]string, 0, len(cztCategories))
+	for _, c := range cztCategories {
+		out = append(out, c.name)
+	}
+	return out
+}
+
+func categoryIDForName(name string) string {
+	name = strings.TrimSpace(name)
+	for _, c := range cztCategories {
+		if strings.EqualFold(c.name, name) {
+			return c.id
+		}
+	}
+	return ""
+}
+
+func categoryNameForID(id string) string {
+	for _, c := range cztCategories {
+		if c.id == id {
+			return c.name
+		}
+	}
+	return ""
+}
+
+// categoryQuestionnaire offers a (non-blocking) category dropdown pre-filled
+// with the auto-detected category, so the user can override it for content
+// upbrr can't classify from video metadata.
+func categoryQuestionnaire(meta api.UploadSubject) *api.TrackerQuestionnaire {
+	auto := autoCategory(meta)
+	return &api.TrackerQuestionnaire{
+		Tracker: trackerName,
+		Fields: []api.TrackerQuestionnaireField{{
+			Key:      "category",
+			Label:    "Category",
+			Kind:     "select",
+			Options:  categoryNames(),
+			Value:    categoryNameForID(auto),
+			Help:     "Auto-detected from video metadata. Override for software, games, music, XXX, etc.",
+			Required: auto == "",
+		}},
+	}
+}
+
+// resolveCategory returns the CZTeam category id: an explicit questionnaire
+// override when the user picked one, otherwise the auto-detected video category.
+func resolveCategory(meta api.UploadSubject) (string, error) {
+	if id := resolveQuestionnaireCategory(standalone.QuestionnaireAnswers(meta, trackerName)["category"]); id != "" {
+		return id, nil
+	}
+	if id := autoCategory(meta); id != "" {
+		return id, nil
+	}
+	return "", errors.New("trackers: CZT category requires explicit questionnaire selection for non-video content")
+}
+
+func resolveQuestionnaireCategory(value string) string {
+	if id := categoryIDForName(value); id != "" {
+		return id
+	}
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	for _, c := range cztCategories {
+		if c.id == trimmed {
+			return c.id
+		}
+	}
+	return ""
+}
+
+// autoCategory maps prepared metadata to a CZTeam numeric categories.id when
+// metadata supports automatic classification. Unknown non-video content returns
+// empty so callers can require an explicit questionnaire category instead of
+// falling back to a movie bucket.
+func autoCategory(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+
+	ro := hasRomanianSubs(meta)
+	hd := isHD(meta.Release.Resolution)
+
+	switch {
+	case meta.Anime:
+		return "23" // Anime
+	case category == api.CanonicalCategoryTV:
+		if hd && ro {
+			return "34" // TvEps/HD-RO
+		}
+		if hd {
+			return "5" // TvEps/HD
+		}
+		return "7" // TvEps (no SD-RO TV category exists)
+	}
+
+	// Movies.
+	src := strings.ToUpper(metautil.FirstNonEmptyTrimmed(meta.Source, meta.Release.Source))
+	isDVD := strings.Contains(src, "DVD") || strings.EqualFold(meta.DiscType, "DVD") || strings.EqualFold(meta.Type, "DVDRIP")
+	isFullBluRay := strings.EqualFold(meta.DiscType, "BDMV") ||
+		(strings.EqualFold(meta.Type, "REMUX") && strings.Contains(src, "BLURAY"))
+	if category != api.CanonicalCategoryMovie {
+		return ""
+	}
+
+	if ro {
+		switch {
+		case isFullBluRay:
+			return "36" // Full BluRay-RO
+		case isDVD:
+			return "28" // Movies/DVD-RO
+		case hd:
+			return "33" // Movies/HDTV-RO
+		default:
+			return "38" // Movies-RO
+		}
+	}
+	switch {
+	case isDVD:
+		return "20" // Movies/DVD-R
+	case hd:
+		return "29" // Movies/HD
+	case hasCodec(meta, "XviD"):
+		return "19" // Movies/XviD
+	default:
+		return "29" // default to Movies/HD when movie evidence exists
+	}
+}
+
+func missingRequiredCategory(state uploadState) bool {
+	if state.questionnaire == nil {
+		return false
+	}
+	if strings.TrimSpace(state.fields["category"]) != "" {
+		return false
+	}
+	for _, field := range state.questionnaire.Fields {
+		if field.Key == "category" && field.Required {
+			return true
+		}
+	}
+	return false
+}
+
+func hasRomanianSubs(meta api.UploadSubject) bool {
+	for _, s := range meta.SubtitleLanguages {
+		v := strings.ToLower(strings.TrimSpace(s))
+		if v == "ro" || v == "rum" || v == "ron" || strings.HasPrefix(v, "roman") {
+			return true
+		}
+	}
+	return false
+}
+
+func isHD(res string) bool {
+	res = strings.TrimSpace(res)
+	for _, prefix := range []string{"720", "1080", "2160", "4320"} {
+		if strings.HasPrefix(res, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasCodec(meta api.UploadSubject, want string) bool {
+	for _, c := range meta.Release.Codec {
+		if strings.EqualFold(strings.TrimSpace(c), want) {
+			return true
+		}
+	}
+	return false
+}
+
+func firstCodec(meta api.UploadSubject) string {
+	for _, c := range meta.Release.Codec {
+		if v := strings.TrimSpace(c); v != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func imdbID(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+}
diff --git a/internal/trackers/impl/standalone/czt/upload_test.go b/internal/trackers/impl/standalone/czt/upload_test.go
new file mode 100644
index 00000000..956c7d1d
--- /dev/null
+++ b/internal/trackers/impl/standalone/czt/upload_test.go
@@ -0,0 +1,1271 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package czt
+
+import (
+	"context"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	mkbrr "github.com/autobrr/mkbrr/torrent"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestUploadSuccessPersistsReturnedTorrentAndUsesProvidedAssets(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	server.assertNoHandlerError(t)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected one uploaded torrent, got %+v", result)
+	}
+	uploaded := result.UploadedTorrents[0]
+	if uploaded.TorrentURL != server.URL+"/details.php?id=123" {
+		t.Fatalf("unexpected torrent URL: %q", uploaded.TorrentURL)
+	}
+	if uploaded.DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("unexpected download URL: %q", uploaded.DownloadURL)
+	}
+	if strings.TrimSpace(uploaded.TorrentPath) == "" {
+		t.Fatal("expected persisted returned torrent path")
+	}
+	payload, err := os.ReadFile(uploaded.TorrentPath)
+	if err != nil {
+		t.Fatalf("read persisted torrent: %v", err)
+	}
+	if string(payload) != string(returnedTorrent) {
+		t.Fatalf("persisted torrent did not match returned bytes")
+	}
+}
+
+func TestUploadUsesProfileEndpointAndIgnoresAPIKey(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
+	defer server.Close()
+
+	req := cztUploadRequest(t, server.URL)
+	req.TrackerConfig.APIKey = "stale-api-key"
+
+	result, err := upload(context.Background(), req)
+	server.assertNoHandlerError(t)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected upload success, got %+v", result)
+	}
+}
+
+func TestUploadRequiresPasskey(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requests.Add(1)
+		w.WriteHeader(http.StatusCreated)
+	}))
+	defer server.Close()
+
+	req := cztUploadRequest(t, server.URL)
+	req.TrackerConfig.Passkey = ""
+
+	result, err := upload(context.Background(), req)
+	if err == nil {
+		t.Fatal("expected missing passkey error")
+	}
+	if !strings.Contains(err.Error(), "missing passkey") {
+		t.Fatalf("expected missing passkey error, got %v", err)
+	}
+	if requests.Load() != 0 {
+		t.Fatalf("expected no remote request without passkey, got %d", requests.Load())
+	}
+	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no uploaded result, got %+v", result)
+	}
+}
+
+func TestUploadTestServerReportsHandlerAssertionOnTestGoroutine(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	server := newCZTUploadTestServer(t, returnedTorrent, "/wrong-upload-path")
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	server.assertHandlerErrorContains(t, `expected upload path "/wrong-upload-path"`)
+	if err == nil {
+		t.Fatal("expected upload error")
+	}
+	if !strings.Contains(err.Error(), "status=400") {
+		t.Fatalf("expected HTTP 400 upload error, got %v", err)
+	}
+	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no uploaded result on handler assertion failure, got %+v", result)
+	}
+}
+
+func TestUploadReportsRemoteSuccessWhenReturnedTorrentB64IsInvalid(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":"not-base64"}`))
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success without artifact failure, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentPath != "" {
+		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+}
+
+func TestUploadReportsRemoteSuccessWhenReturnedTorrentB64IsEmpty(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":" "}`))
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success without artifact failure, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentPath != "" {
+		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+}
+
+func TestUploadReportsRemoteSuccessWhenReturnedTorrentIsCorrupt(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"id":123,"name":"Release","download_url":"/download.php?id=123","torrent_b64":%q}`,
+			base64.StdEncoding.EncodeToString([]byte("registered-torrent")),
+		)
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success without artifact failure, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentPath != "" {
+		t.Fatalf("expected no persisted torrent path, got %q", result.UploadedTorrents[0].TorrentPath)
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected download URL fallback, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+}
+
+func TestUploadReportsRemoteSuccessWhenDownloadURLIsOffsite(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"id":123,"name":"Release","download_url":"https://evil.example/download.php?id=123","torrent_b64":%q}`,
+			base64.StdEncoding.EncodeToString(returnedTorrent),
+		)
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success with artifact, got %+v", result)
+	}
+	if result.UploadedTorrents[0].DownloadURL != "" {
+		t.Fatalf("expected rejected download URL to be omitted, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+	if strings.TrimSpace(result.UploadedTorrents[0].TorrentPath) == "" {
+		t.Fatal("expected persisted returned torrent path")
+	}
+}
+
+func TestUploadKeepsRemoteSuccessWhenNoInjectableArtifactExists(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = w.Write([]byte(`{"id":123,"name":"Release","download_url":"https://evil.example/download.php?id=123","torrent_b64":"not-base64"}`))
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected remote success count without injectable artifacts, got %+v", result)
+	}
+	if len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no injectable artifact entry, got %+v", result.UploadedTorrents)
+	}
+}
+
+func TestUploadResponseParseBoundaries(t *testing.T) {
+	tests := []struct {
+		name       string
+		statusCode int
+		body       string
+		want       string
+	}{
+		{
+			name:       "malformed 201",
+			statusCode: http.StatusCreated,
+			body:       `{`,
+			want:       "parse upload response",
+		},
+		{
+			name:       "malformed non-201 stays http failure",
+			statusCode: http.StatusInternalServerError,
+			body:       `{`,
+			want:       "status=500",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(tt.statusCode)
+				_, _ = w.Write([]byte(tt.body))
+			}))
+			defer server.Close()
+
+			_, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+			if err == nil {
+				t.Fatal("expected upload error")
+			}
+			if !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("expected error containing %q, got %v", tt.want, err)
+			}
+		})
+	}
+}
+
+func TestCZTUploadDecodeErrorsAreRedacted(t *testing.T) {
+	err := redactCZTUploadDecodeError("decode CZT upload response fields", errors.New("api_key=secret-passkey Cookie=session-token"))
+	if err == nil {
+		t.Fatal("expected redacted error")
+	}
+	got := err.Error()
+	if strings.Contains(got, "secret-passkey") || strings.Contains(got, "session-token") {
+		t.Fatalf("expected redacted decode error")
+	}
+	if !strings.Contains(got, "decode CZT upload response fields") || !strings.Contains(got, "[REDACTED]") {
+		t.Fatalf("expected context and redaction marker, got %q", got)
+	}
+
+	if _, err := parseCZTUploadID([]byte(`{`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response fields") {
+		t.Fatalf("expected redacted fields decode path, got %v", err)
+	}
+	if _, err := parseCZTUploadID([]byte(`{"id":"bad"}`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response id") {
+		t.Fatalf("expected redacted id decode path, got %v", err)
+	}
+	if _, err := parseCZTUploadResponse([]byte(`{`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response fields") {
+		t.Fatalf("expected redacted response fields decode path, got %v", err)
+	}
+	if _, err := parseCZTUploadResponse([]byte(`{"id":"bad"}`)); err == nil || !strings.Contains(err.Error(), "decode CZT upload response id") {
+		t.Fatalf("expected redacted response id decode path, got %v", err)
+	}
+	if _, err := parseCZTUploadResponse([]byte(`{"id":123,"error":{"api_key":"secret-passkey"}}`)); err == nil {
+		t.Fatal("expected redacted optional field decode path")
+	} else if got := err.Error(); !strings.Contains(got, "error") || !strings.Contains(got, "[REDACTED]") || strings.Contains(got, "secret-passkey") {
+		t.Fatalf("expected redacted optional field decode error, got %q", got)
+	}
+}
+
+func TestUploadSuccessParsesLargeResponse(t *testing.T) {
+	padding := strings.Repeat("a", 70*1024)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"name":%q,"id":123,"download_url":"/download.php?id=123","torrent_b64":" "}`,
+			padding,
+		)
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success without artifact failure, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentID != "123" {
+		t.Fatalf("expected torrent ID 123, got %q", result.UploadedTorrents[0].TorrentID)
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected download URL from large response, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+}
+
+func TestUploadResponseBadLocalFieldPreservesRemoteSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = w.Write([]byte(`{"id":123,"download_url":"/download.php?id=123","torrent_b64":123}`))
+	}))
+	defer server.Close()
+
+	result, err := upload(context.Background(), cztUploadRequest(t, server.URL))
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success without artifact, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentID != "123" || result.UploadedTorrents[0].TorrentPath != "" {
+		t.Fatalf("unexpected uploaded torrent: %+v", result.UploadedTorrents[0])
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected usable download URL despite bad local field, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+}
+
+func TestUploadPreCanceledContextStopsBeforeRemoteRequest(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requests.Add(1)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer server.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	result, err := upload(ctx, cztUploadRequest(t, server.URL))
+	if err == nil {
+		t.Fatal("expected cancellation error")
+	}
+	if !strings.Contains(err.Error(), "context canceled") {
+		t.Fatalf("expected context cancellation error, got %v", err)
+	}
+	if requests.Load() != 0 {
+		t.Fatalf("expected no remote request after pre-send cancellation, got %d", requests.Load())
+	}
+	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no uploaded result after pre-send cancellation, got %+v", result)
+	}
+}
+
+func TestUploadCancellationAfterRequestBuildStopsBeforeRemoteRequest(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requests.Add(1)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer server.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	originalFactory := newCZTUploadHTTPClient
+	newCZTUploadHTTPClient = func() *http.Client {
+		cancel()
+		return server.Client()
+	}
+	t.Cleanup(func() {
+		newCZTUploadHTTPClient = originalFactory
+	})
+
+	result, err := upload(ctx, cztUploadRequest(t, server.URL))
+	if err == nil {
+		t.Fatal("expected cancellation error")
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected context cancellation error, got %v", err)
+	}
+	if requests.Load() != 0 {
+		t.Fatalf("expected no remote request after post-build cancellation, got %d", requests.Load())
+	}
+	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no uploaded result after post-build cancellation, got %+v", result)
+	}
+}
+
+func TestUploadCancellationAfterResponsePreservesRemoteSuccessWithoutPersistingArtifact(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"id":123,"name":"Release","download_url":"download.php?id=123","torrent_b64":%q}`,
+			base64.StdEncoding.EncodeToString(returnedTorrent),
+		)
+		if flusher, ok := w.(http.Flusher); ok {
+			flusher.Flush()
+		}
+		cancel()
+	}))
+	defer server.Close()
+
+	req := cztUploadRequest(t, server.URL)
+	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, trackerName)
+	if err != nil {
+		t.Fatalf("resolve artifact path: %v", err)
+	}
+	result, err := upload(ctx, req)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success after cancellation, got %+v", result)
+	}
+	if result.UploadedTorrents[0].DownloadURL != server.URL+"/download.php?id=123" {
+		t.Fatalf("expected download URL preserved, got %q", result.UploadedTorrents[0].DownloadURL)
+	}
+	if result.UploadedTorrents[0].TorrentPath != "" {
+		t.Fatalf("expected no persisted artifact path, got %q", result.UploadedTorrents[0].TorrentPath)
+	}
+	if _, statErr := os.Stat(artifactPath); !os.IsNotExist(statErr) {
+		t.Fatalf("expected no persisted artifact, stat err=%v", statErr)
+	}
+}
+
+func TestUploadCancellationBeforeNonCreatedResponseReturnsCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		cancel()
+		w.WriteHeader(http.StatusInternalServerError)
+		_, _ = w.Write([]byte(`{"error":"failed"}`))
+	}))
+	defer server.Close()
+
+	result, err := upload(ctx, cztUploadRequest(t, server.URL))
+	if err == nil {
+		t.Fatal("expected cancellation error")
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected context cancellation error, got %v", err)
+	}
+	if strings.Contains(err.Error(), "status=500") {
+		t.Fatalf("expected cancellation before HTTP error, got %v", err)
+	}
+	if result.Uploaded != 0 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected no uploaded result after non-201 cancellation, got %+v", result)
+	}
+}
+
+func TestUploadCancellationDuringPostCancelsBeforeUploadTimeout(t *testing.T) {
+	oldGrace := cztPostCancelGrace.Swap(int64(25 * time.Millisecond))
+	t.Cleanup(func() {
+		cztPostCancelGrace.Store(oldGrace)
+	})
+
+	requestStarted := make(chan struct{})
+	releaseHandler := make(chan struct{})
+	server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
+		close(requestStarted)
+		select {
+		case <-r.Context().Done():
+		case <-releaseHandler:
+		}
+	}))
+	defer server.Close()
+	defer close(releaseHandler)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	req := cztUploadRequest(t, server.URL)
+	done := make(chan struct {
+		summary api.UploadSummary
+		err     error
+	}, 1)
+	go func() {
+		summary, err := upload(ctx, req)
+		done <- struct {
+			summary api.UploadSummary
+			err     error
+		}{summary: summary, err: err}
+	}()
+
+	select {
+	case <-requestStarted:
+	case <-time.After(time.Second):
+		t.Fatal("expected remote request to start")
+	}
+
+	started := time.Now()
+	cancel()
+	select {
+	case result := <-done:
+		if result.err == nil {
+			t.Fatal("expected cancellation error")
+		}
+		if !errors.Is(result.err, context.Canceled) {
+			t.Fatalf("expected context cancellation error, got %v", result.err)
+		}
+		if result.summary.Uploaded != 0 || len(result.summary.UploadedTorrents) != 0 {
+			t.Fatalf("expected no uploaded result after canceled POST, got %+v", result.summary)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("expected canceled POST to return before upload timeout")
+	}
+	if elapsed := time.Since(started); elapsed >= time.Second {
+		t.Fatalf("expected canceled POST below upload timeout, elapsed %s", elapsed)
+	}
+}
+
+func TestUploadCancellationAfterPersistPreservesArtifactSummary(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	server := newCZTUploadTestServer(t, returnedTorrent, uploadPath)
+	defer server.Close()
+
+	req := cztUploadRequest(t, server.URL)
+	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, trackerName)
+	if err != nil {
+		t.Fatalf("resolve artifact path: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
+		t.Fatalf("create artifact dir: %v", err)
+	}
+	if err := os.WriteFile(artifactPath, []byte("existing artifact"), 0o600); err != nil {
+		t.Fatalf("write existing artifact: %v", err)
+	}
+
+	oldRemove := removeReturnedTorrentBackup
+	removeReturnedTorrentBackup = func(path string) error {
+		err := oldRemove(path)
+		if strings.Contains(filepath.Base(path), ".backup-") {
+			cancel()
+		}
+		return err
+	}
+	defer func() {
+		removeReturnedTorrentBackup = oldRemove
+	}()
+
+	result, err := upload(ctx, req)
+	server.assertNoHandlerError(t)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected remote success with artifact after cancellation, got %+v", result)
+	}
+	if result.UploadedTorrents[0].TorrentPath != artifactPath {
+		t.Fatalf("expected artifact path %q, got %q", artifactPath, result.UploadedTorrents[0].TorrentPath)
+	}
+}
+
+func TestReplaceStagedReturnedTorrentRestoresExistingOnFailure(t *testing.T) {
+	tmp := t.TempDir()
+	outputPath := filepath.Join(tmp, "registered.torrent")
+	original := []byte("existing artifact")
+	if err := os.WriteFile(outputPath, original, 0o600); err != nil {
+		t.Fatalf("write existing artifact: %v", err)
+	}
+
+	err := replaceStagedReturnedTorrent(filepath.Join(tmp, "missing.tmp"), outputPath)
+	if err == nil {
+		t.Fatal("expected replacement error")
+	}
+	got, readErr := os.ReadFile(outputPath)
+	if readErr != nil {
+		t.Fatalf("read restored artifact: %v", readErr)
+	}
+	if string(got) != string(original) {
+		t.Fatalf("expected existing artifact preserved, got %q", got)
+	}
+}
+
+func TestUploadOmitsArtifactPathWhenBackupCleanupFails(t *testing.T) {
+	returnedTorrent := validTorrentBytes(t)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"id":123,"name":"Release","torrent_b64":%q}`,
+			base64.StdEncoding.EncodeToString(returnedTorrent),
+		)
+	}))
+	defer server.Close()
+
+	req := cztUploadRequest(t, server.URL)
+	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, trackerName)
+	if err != nil {
+		t.Fatalf("resolve artifact path: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
+		t.Fatalf("create artifact dir: %v", err)
+	}
+	if err := os.WriteFile(artifactPath, []byte("existing artifact"), 0o600); err != nil {
+		t.Fatalf("write existing artifact: %v", err)
+	}
+
+	oldRemove := removeReturnedTorrentBackup
+	removeReturnedTorrentBackup = func(path string) error {
+		if strings.Contains(filepath.Base(path), ".backup-") {
+			return os.ErrPermission
+		}
+		return oldRemove(path)
+	}
+	defer func() {
+		removeReturnedTorrentBackup = oldRemove
+	}()
+
+	result, err := upload(context.Background(), req)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 || len(result.UploadedTorrents) != 0 {
+		t.Fatalf("expected cleanup-error artifact omitted while preserving remote success, got %+v", result)
+	}
+}
+
+func TestPersistReturnedTorrentReturnsPathWhenBackupCleanupFails(t *testing.T) {
+	req := cztUploadRequest(t, defaultBaseURL)
+	artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, trackerName)
+	if err != nil {
+		t.Fatalf("resolve artifact path: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(artifactPath), 0o700); err != nil {
+		t.Fatalf("create artifact dir: %v", err)
+	}
+	original := []byte("existing artifact")
+	if err := os.WriteFile(artifactPath, original, 0o600); err != nil {
+		t.Fatalf("write existing artifact: %v", err)
+	}
+
+	oldRemove := removeReturnedTorrentBackup
+	removeReturnedTorrentBackup = func(path string) error {
+		if strings.Contains(filepath.Base(path), ".backup-") {
+			return os.ErrPermission
+		}
+		return oldRemove(path)
+	}
+	defer func() {
+		removeReturnedTorrentBackup = oldRemove
+	}()
+
+	gotPath, err := persistReturnedTorrent(req, base64.StdEncoding.EncodeToString(validTorrentBytes(t)))
+	if err == nil {
+		t.Fatal("expected cleanup error")
+	}
+	var cleanupErr returnedTorrentCleanupError
+	if !errors.As(err, &cleanupErr) {
+		t.Fatalf("expected cleanup error, got %v", err)
+	}
+	if gotPath != artifactPath {
+		t.Fatalf("expected artifact path %q, got %q", artifactPath, gotPath)
+	}
+	payload, readErr := os.ReadFile(artifactPath)
+	if readErr != nil {
+		t.Fatalf("read artifact: %v", readErr)
+	}
+	if string(payload) == string(original) {
+		t.Fatal("expected replacement artifact to remain after cleanup failure")
+	}
+}
+
+func TestJoinCZTURL(t *testing.T) {
+	tests := []struct {
+		name    string
+		base    string
+		raw     string
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "leading slash",
+			base: "https://czteam.me",
+			raw:  "/download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "no leading slash",
+			base: "https://czteam.me",
+			raw:  "download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "same host absolute",
+			base: "https://czteam.me",
+			raw:  "https://czteam.me/download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "base userinfo stripped",
+			base: "https://user:pass@czteam.me",
+			raw:  "download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "same host absolute userinfo stripped",
+			base: "https://czteam.me",
+			raw:  "https://user:pass@czteam.me/download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "same host scheme relative",
+			base: "https://czteam.me",
+			raw:  "//czteam.me/download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name: "base path ignored",
+			base: "https://czteam.me/nested/path?x=1",
+			raw:  "download.php?id=1",
+			want: "https://czteam.me/download.php?id=1",
+		},
+		{
+			name:    "absolute offsite",
+			base:    "https://czteam.me",
+			raw:     "https://cdn.example/download/1",
+			wantErr: true,
+		},
+		{
+			name:    "scheme-relative offsite",
+			base:    "https://czteam.me",
+			raw:     "//cdn.example/download/1",
+			wantErr: true,
+		},
+		{
+			name:    "same host wrong scheme",
+			base:    "https://czteam.me",
+			raw:     "http://czteam.me/download.php?id=1",
+			wantErr: true,
+		},
+		{
+			name:    "root path",
+			base:    "https://czteam.me",
+			raw:     "/",
+			wantErr: true,
+		},
+		{
+			name:    "root query",
+			base:    "https://czteam.me",
+			raw:     "/?id=1",
+			wantErr: true,
+		},
+		{
+			name:    "query only",
+			base:    "https://czteam.me",
+			raw:     "?id=1",
+			wantErr: true,
+		},
+		{
+			name:    "pathless",
+			base:    "https://czteam.me",
+			raw:     "https://czteam.me",
+			wantErr: true,
+		},
+		{
+			name:    "empty",
+			base:    "https://czteam.me",
+			raw:     " ",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := joinCZTURL(tt.base, tt.raw)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected error")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("expected %q, got %q", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestResolveCategoryMatrix(t *testing.T) {
+	tests := []struct {
+		name    string
+		meta    api.UploadSubject
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "display name answer",
+			meta: api.UploadSubject{TrackerQuestionnaireAnswers: map[string]map[string]string{trackerName: {"category": "Software"}}},
+			want: "22",
+		},
+		{
+			name: "numeric answer",
+			meta: api.UploadSubject{TrackerQuestionnaireAnswers: map[string]map[string]string{trackerName: {"category": "6"}}},
+			want: "6",
+		},
+		{
+			name: "movie hd",
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{Category: "MOVIE"}, Release: api.ReleaseInfo{Resolution: "1080p"}},
+			want: "29",
+		},
+		{
+			name: "tv hd ro",
+			meta: api.UploadSubject{
+				Identity:          api.ExternalIdentity{Category: "TV"},
+				Release:           api.ReleaseInfo{Resolution: "1080p"},
+				SeasonInt:         1,
+				SubtitleLanguages: []string{"ro"},
+			},
+			want: "34",
+		},
+		{
+			name: "anime",
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie}, Anime: true},
+			want: "23",
+		},
+		{
+			name:    "parsed anime hint is not canonical identity",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Anime-Video"}},
+			wantErr: true,
+		},
+		{
+			name:    "video game hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "video-game"}},
+			wantErr: true,
+		},
+		{
+			name:    "game video hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "game-video"}},
+			wantErr: true,
+		},
+		{
+			name:    "game movie hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "game movie"}},
+			wantErr: true,
+		},
+		{
+			name:    "videogame compound",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "videogame"}},
+			wantErr: true,
+		},
+		{
+			name:    "gameplay compound",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "gameplay"}},
+			wantErr: true,
+		},
+		{
+			name:    "console hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Games/Consoles"}},
+			wantErr: true,
+		},
+		{
+			name: "release source dvd",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie},
+				Release:  api.ReleaseInfo{Source: "DVD"},
+			},
+			want: "20",
+		},
+		{
+			name: "documentary hint",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie},
+				Release:  api.ReleaseInfo{Category: "Documentary"},
+			},
+			want: "29",
+		},
+		{
+			name: "movie documentary hint",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie},
+				Release:  api.ReleaseInfo{Category: "Movie Documentary"},
+			},
+			want: "29",
+		},
+		{
+			name:    "docs hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Docs"}},
+			wantErr: true,
+		},
+		{
+			name:    "ebook hint",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "eBook"}},
+			wantErr: true,
+		},
+		{
+			name:    "software",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Software"}},
+			wantErr: true,
+		},
+		{
+			name:    "music",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Music/Audio"}},
+			wantErr: true,
+		},
+		{
+			name:    "music video phrase",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Music Video"}},
+			wantErr: true,
+		},
+		{
+			name:    "music video separator",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "music-video"}},
+			wantErr: true,
+		},
+		{
+			name:    "music video dotted uppercase",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "MUSIC.VIDEO"}},
+			wantErr: true,
+		},
+		{
+			name:    "mvid",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "MVID"}},
+			wantErr: true,
+		},
+		{
+			name: "generic video hint",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie},
+				Release:  api.ReleaseInfo{Category: "Video", Resolution: "1080p"},
+			},
+			want: "29",
+		},
+		{
+			name:    "no hints unknown metadata",
+			meta:    api.UploadSubject{},
+			wantErr: true,
+		},
+		{
+			name:    "unknown non-video",
+			meta:    api.UploadSubject{Release: api.ReleaseInfo{Category: "Other Data"}},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := resolveCategory(tt.meta)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected category error")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("expected category %q, got %q", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestCategoryQuestionnaireRequiresUnknownNonVideo(t *testing.T) {
+	questionnaire := categoryQuestionnaire(api.UploadSubject{Release: api.ReleaseInfo{Category: "Other Data"}})
+	if questionnaire == nil || len(questionnaire.Fields) != 1 {
+		t.Fatalf("expected one category questionnaire field, got %+v", questionnaire)
+	}
+	field := questionnaire.Fields[0]
+	if !field.Required {
+		t.Fatal("expected unknown non-video category to require an explicit answer")
+	}
+	if field.Value != "" {
+		t.Fatalf("expected no default category value, got %q", field.Value)
+	}
+}
+
+func TestBuildUploadDryRunBlocksMissingRequiredCategory(t *testing.T) {
+	req := cztUploadRequest(t, defaultBaseURL)
+	req.Meta.Identity.Category = api.CanonicalCategoryUnknown
+	req.Meta.Release.Category = "Other Data"
+
+	req.Intent = trackers.PreparationIntentDryRun
+	plan, failure := New().Prepare(context.Background(), req)
+	if failure != nil {
+		t.Fatalf("unexpected dry-run error: %v", failure)
+	}
+	entry := plan.DryRun()
+	if entry.Status != "blocked" {
+		t.Fatalf("expected blocked dry-run status, got %q", entry.Status)
+	}
+	if !strings.Contains(entry.Message, "category questionnaire") {
+		t.Fatalf("expected category questionnaire message, got %q", entry.Message)
+	}
+	if _, ok := entry.Payload["category"]; ok {
+		t.Fatalf("expected unresolved category omitted from payload, got %q", entry.Payload["category"])
+	}
+	if entry.Questionnaire == nil || len(entry.Questionnaire.Fields) != 1 || !entry.Questionnaire.Fields[0].Required {
+		t.Fatalf("expected required category questionnaire, got %+v", entry.Questionnaire)
+	}
+
+	if _, err := prepareUploadState(context.Background(), req, true); err == nil {
+		t.Fatal("expected actual upload state to still require category")
+	}
+}
+
+func TestBuildDescriptionAndDryRunUseProvidedAssets(t *testing.T) {
+	req := cztUploadRequest(t, defaultBaseURL)
+
+	req.Intent = trackers.PreparationIntentDryRun
+	plan, failure := New().Prepare(context.Background(), req)
+	if failure != nil {
+		t.Fatalf("unexpected dry-run error: %v", failure)
+	}
+	entry := plan.DryRun()
+	if !strings.Contains(entry.Description, "[img]https://img.example/raw.jpg[/img]") {
+		t.Fatalf("expected provided screenshot in dry-run description, got %q", entry.Description)
+	}
+	if !strings.Contains(entry.Payload["user_descr"], "[img]https://img.example/raw.jpg[/img]") {
+		t.Fatalf("expected provided screenshot in dry-run payload, got %q", entry.Payload["user_descr"])
+	}
+	if strings.Contains(entry.Payload["user_descr"], "[url=") || strings.Contains(entry.Payload["user_descr"], "[center]") {
+		t.Fatalf("expected CZT screenshot BBCode to use only img tags, got %q", entry.Payload["user_descr"])
+	}
+
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "CZT",
+		Meta:    req.Meta,
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: "[center]final rewritten body[/center]",
+			Screenshots: []api.ScreenshotImage{{
+				ImgURL: "https://img.example/should-not-append.jpg",
+			}},
+			Final: true,
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected description error: %v", err)
+	}
+	if result.Description != "[center]final rewritten body[/center]" {
+		t.Fatalf("expected final description verbatim, got %q", result.Description)
+	}
+}
+
+func TestBBCODEScreenshotBlockUsesRawURLsAndCapsAtTwo(t *testing.T) {
+	got := bbcodeScreenshotBlock([]api.ScreenshotImage{
+		{ImgURL: "https://img.example/rehosted-only.jpg", WebURL: "https://img.example/page-only"},
+		{
+			ImgURL: "https://img.example/rehosted-1.jpg",
+			WebURL: "https://img.example/page-1",
+			RawURL: "https://img.example/raw-1.jpg",
+		},
+		{
+			ImgURL: "https://img.example/rehosted-2.jpg",
+			WebURL: "https://img.example/page-2",
+			RawURL: "https://img.example/raw-2.jpg",
+		},
+		{
+			ImgURL: "https://img.example/rehosted-3.jpg",
+			WebURL: "https://img.example/page-3",
+			RawURL: "https://img.example/raw-3.jpg",
+		},
+	})
+	want := "[img]https://img.example/raw-1.jpg[/img]\n[img]https://img.example/raw-2.jpg[/img]"
+	if got != want {
+		t.Fatalf("unexpected screenshot block:\nwant %q\ngot  %q", want, got)
+	}
+	if strings.Contains(got, "[url=") || strings.Contains(got, "[center]") {
+		t.Fatalf("expected only img BBCode, got %q", got)
+	}
+	if strings.Contains(got, "rehosted") || strings.Contains(got, "page-") || strings.Contains(got, "raw-3") {
+		t.Fatalf("expected raw-only first two images, got %q", got)
+	}
+}
+
+func validTorrentBytes(t *testing.T) []byte {
+	t.Helper()
+	tmp := t.TempDir()
+	sourcePath := filepath.Join(tmp, "source.bin")
+	torrentPath := filepath.Join(tmp, "source.torrent")
+	if err := os.WriteFile(sourcePath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	_, err := mkbrr.Create(mkbrr.CreateOptions{
+		Path:       sourcePath,
+		OutputPath: torrentPath,
+		IsPrivate:  true,
+	})
+	if err != nil {
+		t.Fatalf("create torrent: %v", err)
+	}
+	payload, err := os.ReadFile(torrentPath)
+	if err != nil {
+		t.Fatalf("read torrent: %v", err)
+	}
+	return payload
+}
+
+type cztUploadTestServer struct {
+	*httptest.Server
+	handlerErr chan error
+}
+
+func newCZTUploadTestServer(t *testing.T, returnedTorrent []byte, expectedPath string) *cztUploadTestServer {
+	t.Helper()
+	handlerErr := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := assertCZTUploadRequest(r, expectedPath); err != nil {
+			recordCZTUploadHandlerError(handlerErr, err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		w.WriteHeader(http.StatusCreated)
+		_, _ = fmt.Fprintf(
+			w,
+			`{"id":123,"name":"Release","download_url":"download.php?id=123","torrent_b64":%q}`,
+			base64.StdEncoding.EncodeToString(returnedTorrent),
+		)
+	}))
+	return &cztUploadTestServer{Server: server, handlerErr: handlerErr}
+}
+
+func assertCZTUploadRequest(r *http.Request, expectedPath string) error {
+	if r.URL.Path != expectedPath {
+		return fmt.Errorf("expected upload path %q, got %q", expectedPath, r.URL.Path)
+	}
+	if got := r.Header.Get("Authorization"); got != "" {
+		return errors.New("expected no authorization header")
+	}
+	if err := r.ParseMultipartForm(5 << 20); err != nil {
+		return fmt.Errorf("parse multipart: %w", err)
+	}
+	if got := r.FormValue("passkey"); got != "pass" {
+		return errors.New("expected passkey form field")
+	}
+	if got := r.FormValue("user_descr"); !strings.Contains(got, "[img]https://img.example/raw.jpg[/img]") {
+		return fmt.Errorf("expected raw screenshot img tag in payload, got %q", got)
+	} else if strings.Contains(got, "[url=") || strings.Contains(got, "[center]") || strings.Contains(got, "rehosted.jpg") || strings.Contains(got, "page") {
+		return fmt.Errorf("expected only raw screenshot img tags in payload, got %q", got)
+	}
+	files := r.MultipartForm.File["file"]
+	if len(files) != 1 {
+		return fmt.Errorf("expected one torrent file, got %d", len(files))
+	}
+	file, err := files[0].Open()
+	if err != nil {
+		return fmt.Errorf("open multipart file: %w", err)
+	}
+	defer func() {
+		_ = file.Close()
+	}()
+	if _, err := io.ReadAll(file); err != nil {
+		return fmt.Errorf("read multipart file: %w", err)
+	}
+	return nil
+}
+
+func recordCZTUploadHandlerError(handlerErr chan<- error, err error) {
+	select {
+	case handlerErr <- err:
+	default:
+	}
+}
+
+func (s *cztUploadTestServer) assertNoHandlerError(t *testing.T) {
+	t.Helper()
+	if err := s.handlerError(); err != nil {
+		t.Fatalf("upload handler assertion: %v", err)
+	}
+}
+
+func (s *cztUploadTestServer) assertHandlerErrorContains(t *testing.T, want string) {
+	t.Helper()
+	err := s.handlerError()
+	if err == nil {
+		t.Fatal("expected upload handler assertion error")
+	}
+	if !strings.Contains(err.Error(), want) {
+		t.Fatalf("expected upload handler assertion containing %q, got %v", want, err)
+	}
+}
+
+func (s *cztUploadTestServer) handlerError() error {
+	select {
+	case err := <-s.handlerErr:
+		return err
+	default:
+		return nil
+	}
+}
+
+func cztUploadRequest(t *testing.T, trackerURL string) trackers.PreparationInput {
+	t.Helper()
+	if strings.TrimSpace(trackerURL) != "" {
+		withCZTBaseURL(t, trackerURL)
+	}
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "Release.torrent")
+	if err := os.WriteFile(torrentPath, []byte("source-torrent"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	sourcePath := filepath.Join(tmp, "Release.mkv")
+	if err := os.WriteFile(sourcePath, []byte("video"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	return trackers.PreparationInput{
+		Tracker: "CZT",
+		Meta: api.UploadSubject{
+			SourcePath:  sourcePath,
+			TorrentPath: torrentPath,
+			ReleaseName: "Release.2026.1080p.WEB-DL",
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
+			Release:     api.ReleaseInfo{Resolution: "1080p"},
+		},
+		TrackerConfig: config.TrackerConfig{
+			Passkey: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "state", "upbrr.db")}}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: "kept description",
+			Screenshots: []api.ScreenshotImage{{
+				ImgURL: "https://img.example/rehosted.jpg",
+				WebURL: "https://img.example/page",
+				RawURL: "https://img.example/raw.jpg",
+			}, {
+				ImgURL: "https://img.example/rehosted-2.jpg",
+				WebURL: "https://img.example/page-2",
+				RawURL: "https://img.example/raw-2.jpg",
+			}, {
+				ImgURL: "https://img.example/rehosted-3.jpg",
+				WebURL: "https://img.example/page-3",
+				RawURL: "https://img.example/raw-3.jpg",
+			}},
+		},
+	}
+}
+
+func withCZTBaseURL(t *testing.T, baseURL string) {
+	t.Helper()
+	old := cztBaseURL
+	cztBaseURL = baseURL
+	t.Cleanup(func() {
+		cztBaseURL = old
+	})
+}
diff --git a/internal/trackers/impl/standalone/dc/bbcode.go b/internal/trackers/impl/standalone/dc/bbcode.go
new file mode 100644
index 00000000..6a8e03e2
--- /dev/null
+++ b/internal/trackers/impl/standalone/dc/bbcode.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dc
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.RemoveSup(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.ConvertNamedSpoilerToNormalSpoiler(value)
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/dc/dupe.go b/internal/trackers/impl/standalone/dc/dupe.go
new file mode 100644
index 00000000..754847ee
--- /dev/null
+++ b/internal/trackers/impl/standalone/dc/dupe.go
@@ -0,0 +1,65 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dc
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/internal/jsondupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://digitalcore.club/api/v1/torrents",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := dcAPIKey(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb id for DC dupe search", nil)
+	}
+	return jsondupe.Search(ctx, s.http, jsondupe.ListSpec{
+		Endpoint:       s.endpoint,
+		Query:          url.Values{"searchText": {"tt" + strconv.Itoa(meta.Identity.IMDBID)}},
+		Headers:        http.Header{"X-Api-Key": {apiKey}},
+		IDField:        "id",
+		NameField:      "name",
+		SizeField:      "size",
+		Link:           func(id string) string { return "https://digitalcore.club/torrent/" + id + "/" },
+		FailureMessage: "DC search failed",
+	})
+}
+
+func dcAPIKey(cfg config.Config) string {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "DC") {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/dc/dupe_test.go b/internal/trackers/impl/standalone/dc/dupe_test.go
new file mode 100644
index 00000000..adaf0359
--- /dev/null
+++ b/internal/trackers/impl/standalone/dc/dupe_test.go
@@ -0,0 +1,50 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dc
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDuplicateSearchUsesDCQueryHeadersAndProjection(t *testing.T) {
+	requestErr := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("searchText") != "tt1234567" || r.Header.Get("X-Api-Key") != "secret" {
+			requestErr <- errors.New("unexpected DC duplicate request shape")
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		_, _ = w.Write([]byte(`[{"id":42,"name":"Example.Release.2026.1080p-GRP","size":1234}]`))
+	}))
+	defer server.Close()
+
+	searcher := &dupeSearcher{
+		cfg: config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"DC": {APIKey: "secret"},
+		}}},
+		http:     server.Client(),
+		endpoint: server.URL,
+	}
+	result := searcher.Search(context.Background(), api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 1234567}})
+	select {
+	case err := <-requestErr:
+		t.Fatal(err)
+	default:
+	}
+	if result.Disposition() != dupe.DispositionResolved {
+		t.Fatalf("unexpected disposition=%v code=%q cause=%v", result.Disposition(), result.Code(), result.Cause())
+	}
+	entries := result.Entries()
+	if len(entries) != 1 || entries[0].ID != "42" || entries[0].Link != "https://digitalcore.club/torrent/42/" || entries[0].SizeBytes != 1234 {
+		t.Fatalf("unexpected entries: %#v", entries)
+	}
+}
diff --git a/internal/trackers/impl/standalone/dc/profile.go b/internal/trackers/impl/standalone/dc/profile.go
new file mode 100644
index 00000000..42d59de0
--- /dev/null
+++ b/internal/trackers/impl/standalone/dc/profile.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dc
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns DC identity, preparation, dupe, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "DC",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "dc",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: sourceFlag,
+		},
+		AudioPolicy: &trackers.AudioPolicy{
+			AllowBloat: true,
+		},
+		ImageHostPolicy: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"imgbox", "imgbb", "bhd", "imgur", "postimg", "sharex"},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"tracker.digitalcore.club", "trackerprxy.digitalcore.club"},
+		},
+	}
+}
+
+// New returns a fresh DC definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "dc", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/dc/upload.go b/internal/trackers/impl/standalone/dc/upload.go
new file mode 100644
index 00000000..cfcf523a
--- /dev/null
+++ b/internal/trackers/impl/standalone/dc/upload.go
@@ -0,0 +1,403 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dc
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://digitalcore.club"
+	apiBaseURL = baseURL + "/api/v1/torrents"
+	sourceFlag = "DigitalCore.club"
+)
+
+type uploadState struct {
+	torrentPath   string
+	releaseName   string
+	description   string
+	mediaInfo     string
+	fields        map[string]string
+	blockedReason string
+}
+
+type uploadResponse struct {
+	ID      any    `json:"id"`
+	Message string `json:"message"`
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: DC %s", state.blockedReason)
+	}
+
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
+		FieldName: "file",
+		FileName:  state.releaseName + ".torrent",
+		Path:      state.torrentPath,
+	}})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	artifactPath := ""
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "DC")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType, apiKey, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+	apiKey string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiBaseURL+"/upload", strings.NewReader(string(body)))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: DC request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	httpReq.Header.Set("X-Api-Key", apiKey)
+
+	result, err := commonhttp.ExecuteUpload(httpclient.New(httpclient.DefaultTimeout), httpReq, commonhttp.UploadExecutionOptions{Tracker: "DC"})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: DC execute upload: %w", err)
+	}
+	var decoded uploadResponse
+	if len(result.Body) > 0 {
+		if err := json.Unmarshal(result.Body, &decoded); err != nil {
+			if !result.Success {
+				return api.UploadSummary{}, commonhttp.UploadHTTPError("DC", result.StatusCode, result.Preview)
+			}
+			return api.UploadSummary{}, fmt.Errorf("trackers: DC decode response: %s", commonhttp.RedactErrorDetail(err.Error()))
+		}
+	}
+	torrentID := strings.TrimSpace(fmt.Sprint(decoded.ID))
+	if result.Success && torrentID != "" && torrentID != "<nil>" {
+		torrentURL := baseURL + "/torrent/" + torrentID + "/"
+		downloadURL := apiBaseURL + "/download/" + torrentID
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "DC",
+				TorrentID:   torrentID,
+				TorrentURL:  torrentURL,
+				DownloadURL: downloadURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	if _, artifactErr := commonhttp.WriteFailureArtifact(
+		req.Meta,
+		req.Runtime.DBPath,
+		"DC",
+		"upload_failure",
+		result.Preview,
+		".json",
+	); artifactErr != nil &&
+		req.Logger != nil {
+		req.Logger.Warnf("trackers: DC failure artifact write failed: %v", artifactErr)
+	}
+	message := metautil.FirstNonEmptyTrimmed(
+		commonhttp.ExtractHTTPErrorDetail(result.Preview),
+		commonhttp.RedactErrorDetail(decoded.Message),
+		commonhttp.RedactErrorDetail(string(result.Preview)),
+		"upload failed",
+	)
+	return api.UploadSummary{}, fmt.Errorf("trackers: DC %s", message)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "DC",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "dc",
+		Description:      state.description,
+		Endpoint:         apiBaseURL + "/upload",
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(_ context.Context, req trackers.PreparationInput) (uploadState, error) {
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: DC missing api_key")
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	mediaInfo, err := resolveMediaInfo(req.Meta)
+	if err != nil {
+		return uploadState{}, err
+	}
+	releaseName := resolveUploadName(req.Meta)
+	fields := map[string]string{
+		"category":        strconv.Itoa(resolveCategoryID(req.Meta)),
+		"imdbId":          resolveIMDbID(req.Meta),
+		"nfo":             description,
+		"mediainfo":       mediaInfo,
+		"reqid":           "0",
+		"section":         "new",
+		"frileech":        "1",
+		"anonymousUpload": resolveAnon(req),
+		"p2p":             "0",
+		"unrar":           "1",
+	}
+	state := uploadState{
+		torrentPath: torrentPath,
+		releaseName: releaseName,
+		description: description,
+		mediaInfo:   mediaInfo,
+		fields:      fields,
+	}
+	if strings.TrimSpace(fields["imdbId"]) == "" {
+		state.blockedReason = "missing IMDb ID"
+	}
+	return state, nil
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	meta := req.Meta
+	var parts []string
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// TV Episode details
+	if strings.TrimSpace(meta.EpisodeOverview) != "" {
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
+	}
+
+	// File information
+	if media := resolveMedia(req, meta); media != "" {
+		parts = append(parts, strings.TrimSpace(media))
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// Combined Screenshots
+	allShots := make([]api.ScreenshotImage, 0, len(assets.MenuImages)+len(assets.Screenshots))
+	allShots = append(allShots, assets.MenuImages...)
+	allShots = append(allShots, assets.Screenshots...)
+	if shots := screenshotBlock(allShots); shots != "" {
+		parts = append(parts, shots)
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// Signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[center][url=%s]%s[/url][/center]", link, text))
+
+	// Join and finalize
+	description := strings.Join(parts, "\n\n")
+	finalized := finalizeDescription(description)
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "DC", req.Runtime.DBPath, finalized, req.Logger)
+	}
+
+	return finalized
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	resolution := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.ReleaseNameNoTag, meta.ReleaseName)))
+	category := categoryOf(meta)
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		if category == "TV" {
+			return 14
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "2160p") {
+			return 38
+		}
+		return 3
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		if category == "TV" {
+			return 11
+		}
+		return 1
+	}
+	if category == "TV" && meta.TVPack {
+		return 12
+	}
+	if isSD(meta) {
+		if category == "TV" {
+			return 10
+		}
+		return 2
+	}
+	switch category {
+	case "TV":
+		switch strings.TrimSpace(meta.Release.Resolution) {
+		case "2160p":
+			return 13
+		case "1080p", "1080i":
+			return 9
+		default:
+			return 8
+		}
+	default:
+		switch strings.TrimSpace(meta.Release.Resolution) {
+		case "2160p":
+			return 4
+		case "1080p", "1080i":
+			return 6
+		default:
+			_ = resolution
+			return 5
+		}
+	}
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	name := metautil.FirstNonEmptyTrimmed(
+		strings.TrimSpace(meta.SceneName),
+		strings.TrimSpace(meta.ReleaseNameClean),
+		strings.TrimSpace(meta.ReleaseName),
+		strings.TrimSpace(meta.Filename),
+	)
+	if name == "" {
+		name = "release"
+	}
+	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
+		return strings.TrimSpace(meta.SceneName) + " [UNRAR]"
+	}
+	name = strings.NewReplacer("DD+", "DDP", "DTS:", "DTS-", "HDR10+", "HDR10P").Replace(name)
+	out := strings.Builder{}
+	for _, r := range name {
+		if r > 127 {
+			continue
+		}
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == ' ' || r == '.' || r == '-' {
+			out.WriteRune(r)
+		}
+	}
+	return strings.TrimSpace(out.String())
+}
+
+func resolveMediaInfo(meta api.UploadSubject) (string, error) {
+	if text := metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText)); text != "" {
+		return text, nil
+	}
+	return "", errors.New("trackers: DC missing mediainfo")
+}
+
+func resolveMedia(req trackers.PreparationInput, meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		bdinfo, _ := trackers.ReadBDInfo(req.Runtime.DBPath, meta)
+		return strings.TrimSpace(bdinfo)
+	}
+	return metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
+}
+
+func resolveIMDbID(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return "tt" + strconv.Itoa(meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveAnon(req trackers.PreparationInput) string {
+	if req.TrackerConfig.Anon {
+		return "1"
+	}
+	return "0"
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(images))
+	for _, image := range images {
+		if strings.TrimSpace(image.WebURL) == "" || strings.TrimSpace(image.RawURL) == "" {
+			continue
+		}
+		parts = append(parts, "[url="+strings.TrimSpace(image.WebURL)+"][img=350]"+strings.TrimSpace(image.RawURL)+"[/img][/url]")
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	return "[center]" + strings.Join(parts, " ") + "[/center]"
+}
+
+func isSD(meta api.UploadSubject) bool {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	return resolution == "480p" || resolution == "576p" || resolution == ""
+}
diff --git a/internal/trackers/impl/standalone/definition.go b/internal/trackers/impl/standalone/definition.go
new file mode 100644
index 00000000..cce59706
--- /dev/null
+++ b/internal/trackers/impl/standalone/definition.go
@@ -0,0 +1,262 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Definition implements shared standalone identity, preparation, duplicate,
+// and declarative capability contracts from one immutable profile.
+type Definition struct {
+	profile Profile
+}
+
+// New validates, normalizes, and defensively copies a standalone profile.
+func New(profile Profile) (*Definition, error) {
+	profile.Name = strings.ToUpper(strings.TrimSpace(profile.Name))
+	profile.BaseURL = strings.TrimRight(strings.TrimSpace(profile.BaseURL), "/")
+	profile.DescriptionGroup = strings.ToLower(strings.TrimSpace(profile.DescriptionGroup))
+	profile.LocalizedMetadataLocale = strings.TrimSpace(profile.LocalizedMetadataLocale)
+	if profile.DescriptionGroup == "" {
+		profile.DescriptionGroup = strings.ToLower(profile.Name)
+	}
+	switch {
+	case profile.Name == "":
+		return nil, errors.New("standalone tracker profile has empty name")
+	case profile.BaseURL == "":
+		return nil, fmt.Errorf("standalone tracker profile %s has empty base URL", profile.Name)
+	case !profile.UploadContentMode.Valid():
+		return nil, fmt.Errorf("standalone tracker profile %s has invalid upload content mode %q", profile.Name, profile.UploadContentMode)
+	case profile.UploadContentMode.UsesDescription() && profile.PrepareDescription == nil:
+		return nil, fmt.Errorf("standalone tracker profile %s has no description preparer", profile.Name)
+	case profile.PrepareUpload == nil:
+		return nil, fmt.Errorf("standalone tracker profile %s has no upload preparer", profile.Name)
+	case profile.NewDuplicateAdapter == nil:
+		return nil, fmt.Errorf("standalone tracker profile %s has no duplicate adapter", profile.Name)
+	}
+	profile = cloneProfile(profile)
+	if profile.AuthCapability != nil {
+		profile.AuthCapability.TrackerID = profile.Name
+		if strings.TrimSpace(profile.AuthCapability.DisplayName) == "" {
+			profile.AuthCapability.DisplayName = profile.Name
+		}
+	}
+	return &Definition{profile: profile}, nil
+}
+
+// MustNew returns a validated standalone definition or panics for an invalid
+// compiled profile.
+func MustNew(profile Profile) *Definition {
+	definition, err := New(profile)
+	if err != nil {
+		panic(err)
+	}
+	return definition
+}
+
+// Name returns the normalized tracker identifier.
+func (d *Definition) Name() string { return d.profile.Name }
+
+// TrackerFamily identifies the definition as standalone.
+func (*Definition) TrackerFamily() trackers.Family { return trackers.FamilyStandalone }
+
+// DefaultBaseURL returns the profile-owned tracker endpoint.
+func (d *Definition) DefaultBaseURL() string { return d.profile.BaseURL }
+
+// DescriptionGroup returns the profile-owned description override group.
+func (d *Definition) DescriptionGroup() string { return d.profile.DescriptionGroup }
+
+// LocalizedMetadataLocale returns the optional tracker-owned metadata locale.
+func (d *Definition) LocalizedMetadataLocale() string { return d.profile.LocalizedMetadataLocale }
+
+// UploadContentMode returns the profile-owned shared content workflow.
+func (d *Definition) UploadContentMode() trackers.UploadContentMode {
+	return d.profile.UploadContentMode
+}
+
+// Prepare dispatches intent through the tracker-local profile callbacks.
+func (d *Definition) Prepare(ctx context.Context, input trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	if input.Intent == trackers.PreparationIntentDescriptionPreview && !d.profile.UploadContentMode.UsesDescription() {
+		return trackers.TrackerPlan{}, trackers.NewPreparationFailure(
+			input.Tracker,
+			"capability",
+			"tracker does not support shared description preparation",
+			nil,
+		)
+	}
+	return trackers.PrepareAdapter(ctx, input, d.profile.PrepareDescription, d.profile.PrepareUpload)
+}
+
+// NewDuplicateAdapter builds the tracker-local duplicate-search adapter.
+func (d *Definition) NewDuplicateAdapter(dependencies dupe.Dependencies) dupe.Adapter {
+	return d.profile.NewDuplicateAdapter(dependencies)
+}
+
+// Rules returns a defensive copy of tracker-owned validation rules.
+func (d *Definition) Rules() *trackers.RuleSet { return cloneRules(d.profile.Rules) }
+
+// ClaimPolicy returns tracker-owned claim orchestration policy.
+func (d *Definition) ClaimPolicy() *trackers.ClaimPolicy { return cloneValue(d.profile.ClaimPolicy) }
+
+// DataLookupPolicy returns tracker-owned lookup orchestration policy.
+func (d *Definition) DataLookupPolicy() *trackers.DataLookupPolicy {
+	return cloneValue(d.profile.DataPolicy)
+}
+
+// ArtifactPolicy returns tracker-owned torrent artifact limits.
+func (d *Definition) ArtifactPolicy() *trackers.ArtifactPolicy {
+	return cloneValue(d.profile.ArtifactPolicy)
+}
+
+// BannedGroups returns a defensive copy of static tracker bans.
+func (d *Definition) BannedGroups() []string { return slices.Clone(d.profile.BannedGroups) }
+
+// BannedGroupPolicy returns tracker-owned dynamic ban retrieval settings.
+func (d *Definition) BannedGroupPolicy() *trackers.BannedGroupPolicy {
+	return cloneValue(d.profile.BannedGroupPolicy)
+}
+
+// MetadataPolicy returns a defensive copy of tracker metadata requirements.
+func (d *Definition) MetadataPolicy() *trackers.TrackerMetadataPolicy {
+	return cloneMetadataPolicy(d.profile.MetadataPolicy)
+}
+
+// UploadArtifactPolicy returns tracker torrent personalization settings.
+func (d *Definition) UploadArtifactPolicy() *trackers.UploadArtifactPolicy {
+	return cloneValue(d.profile.UploadArtifactPolicy)
+}
+
+// DupePolicy returns tracker-specific duplicate comparison settings.
+func (d *Definition) DupePolicy() *trackers.DupePolicy { return cloneValue(d.profile.DupePolicy) }
+
+// AudioPolicy returns a defensive copy of tracker audio constraints.
+func (d *Definition) AudioPolicy() *trackers.AudioPolicy {
+	return cloneAudioPolicy(d.profile.AudioPolicy)
+}
+
+// ImageHostPolicy returns a defensive copy of tracker image-host constraints.
+func (d *Definition) ImageHostPolicy() *trackers.ImageHostPolicy {
+	return cloneImageHostPolicy(d.profile.ImageHostPolicy)
+}
+
+// TorrentIdentityPolicy returns a defensive copy of tracker identity patterns.
+func (d *Definition) TorrentIdentityPolicy() *trackers.TorrentIdentityPolicy {
+	return cloneTorrentIdentityPolicy(d.profile.TorrentIdentityPolicy)
+}
+
+// AuthCapabilityDescriptor returns optional profile-owned auth metadata.
+func (d *Definition) AuthCapabilityDescriptor() *api.TrackerAuthCapability {
+	return cloneAuthCapability(d.profile.AuthCapability)
+}
+
+// AuthSessionResolver returns optional tracker-owned auth resolution behavior.
+func (d *Definition) AuthSessionResolver() trackers.AuthSessionResolver {
+	return d.profile.AuthResolver
+}
+
+// AuthPolicy returns optional tracker-owned auth coordinator settings.
+func (d *Definition) AuthPolicy() *trackers.AuthPolicy { return cloneValue(d.profile.AuthPolicy) }
+
+// AuthStateManager returns optional tracker-owned persisted auth management.
+func (d *Definition) AuthStateManager() trackers.AuthStateManager { return d.profile.AuthStateManager }
+
+func cloneProfile(profile Profile) Profile {
+	profile.Rules = cloneRules(profile.Rules)
+	profile.ClaimPolicy = cloneValue(profile.ClaimPolicy)
+	profile.DataPolicy = cloneValue(profile.DataPolicy)
+	profile.ArtifactPolicy = cloneValue(profile.ArtifactPolicy)
+	profile.BannedGroups = slices.Clone(profile.BannedGroups)
+	profile.BannedGroupPolicy = cloneValue(profile.BannedGroupPolicy)
+	profile.MetadataPolicy = cloneMetadataPolicy(profile.MetadataPolicy)
+	profile.UploadArtifactPolicy = cloneValue(profile.UploadArtifactPolicy)
+	profile.DupePolicy = cloneValue(profile.DupePolicy)
+	profile.AudioPolicy = cloneAudioPolicy(profile.AudioPolicy)
+	profile.ImageHostPolicy = cloneImageHostPolicy(profile.ImageHostPolicy)
+	profile.TorrentIdentityPolicy = cloneTorrentIdentityPolicy(profile.TorrentIdentityPolicy)
+	profile.AuthCapability = cloneAuthCapability(profile.AuthCapability)
+	profile.AuthPolicy = cloneValue(profile.AuthPolicy)
+	return profile
+}
+
+func cloneRules(rules *trackers.RuleSet) *trackers.RuleSet {
+	if rules == nil {
+		return nil
+	}
+	clone := *rules
+	clone.RequireHEVCForTypes = slices.Clone(rules.RequireHEVCForTypes)
+	clone.BlockGroups = slices.Clone(rules.BlockGroups)
+	clone.BlockGroupUnlessType = make(map[string][]string, len(rules.BlockGroupUnlessType))
+	for group, releaseTypes := range rules.BlockGroupUnlessType {
+		clone.BlockGroupUnlessType[group] = slices.Clone(releaseTypes)
+	}
+	if rules.Language != nil {
+		language := *rules.Language
+		language.Languages = slices.Clone(rules.Language.Languages)
+		clone.Language = &language
+	}
+	return &clone
+}
+
+func cloneMetadataPolicy(policy *trackers.TrackerMetadataPolicy) *trackers.TrackerMetadataPolicy {
+	if policy == nil {
+		return nil
+	}
+	clone := *policy
+	clone.Requirements = slices.Clone(policy.Requirements)
+	for idx := range clone.Requirements {
+		clone.Requirements[idx].AnyOf = slices.Clone(clone.Requirements[idx].AnyOf)
+	}
+	return &clone
+}
+
+func cloneAudioPolicy(policy *trackers.AudioPolicy) *trackers.AudioPolicy {
+	clone := cloneValue(policy)
+	if clone != nil {
+		clone.AllowedLanguages = slices.Clone(policy.AllowedLanguages)
+	}
+	return clone
+}
+
+func cloneImageHostPolicy(policy *trackers.ImageHostPolicy) *trackers.ImageHostPolicy {
+	clone := cloneValue(policy)
+	if clone != nil {
+		clone.AllowedHosts = slices.Clone(policy.AllowedHosts)
+		clone.OwnedHosts = slices.Clone(policy.OwnedHosts)
+	}
+	return clone
+}
+
+func cloneTorrentIdentityPolicy(policy *trackers.TorrentIdentityPolicy) *trackers.TorrentIdentityPolicy {
+	clone := cloneValue(policy)
+	if clone != nil {
+		clone.TrackerURLPatterns = slices.Clone(policy.TrackerURLPatterns)
+		clone.CommentURLPatterns = slices.Clone(policy.CommentURLPatterns)
+	}
+	return clone
+}
+
+func cloneAuthCapability(capability *api.TrackerAuthCapability) *api.TrackerAuthCapability {
+	clone := cloneValue(capability)
+	if clone != nil {
+		clone.Notes = slices.Clone(capability.Notes)
+	}
+	return clone
+}
+
+func cloneValue[T any](value *T) *T {
+	if value == nil {
+		return nil
+	}
+	clone := *value
+	return &clone
+}
diff --git a/internal/trackers/impl/standalone/definition_test.go b/internal/trackers/impl/standalone/definition_test.go
new file mode 100644
index 00000000..305b5682
--- /dev/null
+++ b/internal/trackers/impl/standalone/definition_test.go
@@ -0,0 +1,96 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type profileDupeAdapter struct{}
+
+func (profileDupeAdapter) Search(context.Context, api.DuplicateSubject) dupe.AdapterResult {
+	return dupe.NotRun(dupe.NotRunManualCheckRequired, "test", nil)
+}
+
+func validProfile() Profile {
+	return Profile{
+		Name:              " dc ",
+		BaseURL:           "https://tracker.invalid/",
+		UploadContentMode: trackers.UploadContentModeDescription,
+		PrepareDescription: func(context.Context, trackers.PreparationInput) (trackers.DescriptionResult, error) {
+			return trackers.DescriptionResult{Group: "dc"}, nil
+		},
+		PrepareUpload: func(context.Context, trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return trackers.NewPreparedOperation(api.TrackerDryRunEntry{Tracker: "DC"}, nil, nil), nil
+		},
+		NewDuplicateAdapter: func(dupe.Dependencies) dupe.Adapter { return profileDupeAdapter{} },
+	}
+}
+
+func TestNewDefinitionNormalizesAndDefensivelyCopiesProfile(t *testing.T) {
+	t.Parallel()
+
+	profile := validProfile()
+	profile.BannedGroups = []string{"GRP"}
+	profile.AuthCapability = &api.TrackerAuthCapability{Notes: []string{"configured"}}
+	definition, err := New(profile)
+	if err != nil {
+		t.Fatalf("new definition: %v", err)
+	}
+	profile.BannedGroups[0] = "mutated"
+	profile.AuthCapability.Notes[0] = "mutated"
+	if definition.Name() != "DC" || definition.DefaultBaseURL() != "https://tracker.invalid" || definition.TrackerFamily() != trackers.FamilyStandalone {
+		t.Fatalf("definition identity = %q %q %q", definition.Name(), definition.DefaultBaseURL(), definition.TrackerFamily())
+	}
+	if definition.DescriptionGroup() != "dc" || definition.BannedGroups()[0] != "GRP" {
+		t.Fatalf("definition profile = %q %#v", definition.DescriptionGroup(), definition.BannedGroups())
+	}
+	capability := definition.AuthCapabilityDescriptor()
+	if capability == nil || capability.TrackerID != "DC" || capability.Notes[0] != "configured" {
+		t.Fatalf("auth capability = %#v", capability)
+	}
+}
+
+func TestNewDefinitionRejectsMissingRequiredProfileFields(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		mutate func(*Profile)
+	}{
+		{name: "name", mutate: func(profile *Profile) { profile.Name = "" }},
+		{name: "base URL", mutate: func(profile *Profile) { profile.BaseURL = "" }},
+		{name: "description", mutate: func(profile *Profile) { profile.PrepareDescription = nil }},
+		{name: "upload", mutate: func(profile *Profile) { profile.PrepareUpload = nil }},
+		{name: "duplicate", mutate: func(profile *Profile) { profile.NewDuplicateAdapter = nil }},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			profile := validProfile()
+			test.mutate(&profile)
+			if _, err := New(profile); err == nil {
+				t.Fatal("expected profile validation error")
+			}
+		})
+	}
+}
+
+func TestCookieAuthCapabilityNormalizesTrackerID(t *testing.T) {
+	capability := CookieAuthCapability(" tl ")
+	if capability.TrackerID != "TL" || capability.DisplayName != "TL" || capability.AuthKind != "cookies" || !capability.SupportsCookieFile {
+		t.Fatalf("unexpected capability: %#v", capability)
+	}
+}
+
+func TestDefinitionLeavesUndeclaredAuthCapabilityAbsent(t *testing.T) {
+	definition := MustNew(validProfile())
+	if capability := definition.AuthCapabilityDescriptor(); capability != nil {
+		t.Fatalf("expected absent auth capability, got %#v", capability)
+	}
+}
diff --git a/internal/trackers/impl/standalone/ff/auth.go b/internal/trackers/impl/standalone/ff/auth.go
new file mode 100644
index 00000000..c33afa72
--- /dev/null
+++ b/internal/trackers/impl/standalone/ff/auth.go
@@ -0,0 +1,156 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ff
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+)
+
+const ffAuthResponseMaxBytes = 1 << 20
+
+// validateAuthCookies checks bounded FF upload-page evidence. Explicit login
+// evidence and a missing authenticated-page marker are confirmed-invalid;
+// transport, read, and other HTTP failures remain transient.
+func validateAuthCookies(ctx context.Context, baseURL string, values []*http.Cookie) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/upload.php", nil)
+	if err != nil {
+		return fmt.Errorf("trackers: FF session validation request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range values {
+		if cookie != nil && strings.TrimSpace(cookie.Name) != "" && strings.TrimSpace(cookie.Value) != "" {
+			req.AddCookie(cookie)
+		}
+	}
+	resp, err := ffAuthHTTPClient().Do(req)
+	if err != nil {
+		return &trackerauth.ValidationError{
+			TrackerID: "FF",
+			Transient: true,
+			Reason:    "remote validation unavailable",
+			Err:       fmt.Errorf("trackers: FF session validation request: %w", err),
+		}
+	}
+	defer resp.Body.Close()
+	body, err := readFFAuthBody(resp)
+	if err != nil {
+		return &trackerauth.ValidationError{
+			TrackerID: "FF",
+			Transient: true,
+			Reason:    "remote validation unavailable",
+			Err:       err,
+		}
+	}
+	lower := strings.ToLower(string(body))
+	location := strings.ToLower(resp.Header.Get("Location"))
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || strings.Contains(location, "login") ||
+		strings.Contains(lower, "takelogin.php") ||
+		strings.Contains(lower, "name=\"username\"") ||
+		strings.Contains(lower, "name=\"password\"") {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FF",
+			ConfirmedInvalid: true,
+			Reason:           "stored session expired",
+			Err:              fmt.Errorf("trackers: FF session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return &trackerauth.ValidationError{
+			TrackerID: "FF",
+			Transient: true,
+			Reason:    "remote validation failed",
+			Err:       fmt.Errorf("trackers: FF session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if !strings.Contains(lower, "friends.php") {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FF",
+			ConfirmedInvalid: true,
+			Reason:           "stored session expired",
+			Err:              errors.New("trackers: FF login marker not found"),
+		}
+	}
+	return nil
+}
+
+// loginAuthSession logs in with configured credentials and persists only
+// non-empty cookies that pass the same remote session validation.
+func loginAuthSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
+	data := url.Values{
+		"returnto": {"/index.php"},
+		"username": {strings.TrimSpace(cfg.Username)},
+		"password": {strings.TrimSpace(cfg.Password)},
+		"login":    {"Login"},
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/takelogin.php", strings.NewReader(data.Encode()))
+	if err != nil {
+		return fmt.Errorf("trackers: FF login request build: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "upbrr")
+	resp, err := ffAuthHTTPClient().Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: FF login request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusFound {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FF",
+			ConfirmedInvalid: true,
+			Reason:           "login failed",
+			Err:              fmt.Errorf("trackers: FF login failed status=%d", resp.StatusCode),
+		}
+	}
+	loginCookies := usableFFAuthCookies(resp.Cookies())
+	if len(loginCookies) == 0 {
+		return errors.New("trackers: FF login returned no usable cookies")
+	}
+	if err := validateAuthCookies(ctx, baseURL, loginCookies); err != nil {
+		return fmt.Errorf("trackers: FF validate login cookies: %w", err)
+	}
+	if err := cookies.SaveTrackerHTTPCookies(ctx, dbPath, "FF", loginCookies); err != nil {
+		return fmt.Errorf("trackers: FF persist login cookies: %w", err)
+	}
+	return nil
+}
+
+func ffAuthHTTPClient() *http.Client {
+	return &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}
+}
+
+func readFFAuthBody(resp *http.Response) ([]byte, error) {
+	body, err := io.ReadAll(io.LimitReader(resp.Body, ffAuthResponseMaxBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FF read auth response: %w", err)
+	}
+	if len(body) > ffAuthResponseMaxBytes {
+		return nil, errors.New("trackers: FF auth response exceeds limit")
+	}
+	return body, nil
+}
+
+func usableFFAuthCookies(values []*http.Cookie) []*http.Cookie {
+	usable := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		if cookie != nil && strings.TrimSpace(cookie.Name) != "" && strings.TrimSpace(cookie.Value) != "" {
+			usable = append(usable, cookie)
+		}
+	}
+	return usable
+}
+
+func ffHasLoginCredentials(cfg config.TrackerConfig) bool {
+	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
+}
diff --git a/internal/trackers/impl/standalone/ff/bbcode.go b/internal/trackers/impl/standalone/ff/bbcode.go
new file mode 100644
index 00000000..0373e149
--- /dev/null
+++ b/internal/trackers/impl/standalone/ff/bbcode.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ff
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+var (
+	urlSizedImagePattern = regexp.MustCompile(`(?i)\[url=(?P<href>[^\]]+)\]\[img=(?P<width>\d+)\](?P<src>[^\[]+)\[/img\]\[/url\]`)
+	urlImagePattern      = regexp.MustCompile(`(?i)\[url=(?P<href>[^\]]+)\]\[img\](?P<src>[^\[]+)\[/img\]\[/url\]`)
+	sizedImagePattern    = regexp.MustCompile(`(?i)\[img=(?P<width>\d+)\](?P<src>[^\[]+)\[/img\]`)
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = strings.NewReplacer(
+		"[user]",
+		"",
+		"[/user]",
+		"",
+		"[align=left]",
+		"",
+		"[/align]",
+		"",
+		"[right]",
+		"",
+		"[/right]",
+		"",
+		"[align=right]",
+		"",
+		"[alert]",
+		"",
+		"[/alert]",
+		"",
+		"[note]",
+		"",
+		"[/note]",
+		"",
+		"[hr]",
+		"",
+		"[/hr]",
+		"",
+		"[h1]",
+		"[u][b]",
+		"[/h1]",
+		"[/b][/u]",
+		"[h2]",
+		"[u][b]",
+		"[/h2]",
+		"[/b][/u]",
+		"[h3]",
+		"[u][b]",
+		"[/h3]",
+		"[/b][/u]",
+		"[ul]",
+		"",
+		"[/ul]",
+		"",
+		"[ol]",
+		"",
+		"[/ol]",
+		"",
+		"[hide]",
+		"",
+		"[/hide]",
+		"",
+		"•",
+		"-",
+		"“",
+		`"`,
+		"”",
+		`"`,
+	).Replace(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.RemoveSup(value)
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveSpoiler(value)
+	value = urlSizedImagePattern.ReplaceAllString(value, `<a href="$href" target="_blank"><img src="$src" width="$width"></a>`)
+	value = urlImagePattern.ReplaceAllString(value, `<a href="$href" target="_blank"><img src="$src" width="220"></a>`)
+	value = sizedImagePattern.ReplaceAllString(value, `<img src="$src" width="$width">`)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/ff/dupe.go b/internal/trackers/impl/standalone/ff/dupe.go
new file mode 100644
index 00000000..092eee10
--- /dev/null
+++ b/internal/trackers/impl/standalone/ff/dupe.go
@@ -0,0 +1,103 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ff
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var ffGroupPattern = regexp.MustCompile(`torrents\.php\?id=(\d+)`)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if !meta.Anime && meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for FF dupe search", nil)
+	}
+	baseURL := ffBaseURL(s.cfg)
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "FF search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "FF", parsed.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid FF cookies", nil)
+	}
+	query := fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	if meta.Anime {
+		query = metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)
+	}
+	status, root, err := commonhttp.GetHTML(ctx, s.http, baseURL+"/torrents.php", url.Values{"searchstr": {query}}, trackerCookies)
+	if err != nil || status < http.StatusOK || status >= http.StatusMultipleChoices || root == nil {
+		return dupe.Failed(dupe.FailureRequest, "FF search failed", err)
+	}
+	groupLinks := commonhttp.FindNodes(root, func(node *xhtml.Node) bool {
+		href := commonhttp.Attr(node, "href")
+		return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(href, "torrents.php?id=") && !strings.Contains(href, "torrentid")
+	})
+	seen := make(map[string]struct{}, len(groupLinks))
+	entries := make([]api.DupeEntry, 0)
+	for _, linkNode := range groupLinks {
+		groupLink := commonhttp.AbsoluteURL(baseURL, commonhttp.Attr(linkNode, "href"))
+		if groupLink == "" {
+			continue
+		}
+		if _, ok := seen[groupLink]; ok {
+			continue
+		}
+		seen[groupLink] = struct{}{}
+		groupStatus, groupRoot, getErr := commonhttp.GetHTML(ctx, s.http, groupLink, nil, trackerCookies)
+		if getErr != nil || groupStatus < http.StatusOK || groupStatus >= http.StatusMultipleChoices || groupRoot == nil {
+			continue
+		}
+		for _, row := range commonhttp.FindNodes(groupRoot, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "tr" && strings.HasPrefix(commonhttp.Attr(node, "id"), "torrent")
+		}) {
+			link := commonhttp.FirstNode(row, func(node *xhtml.Node) bool {
+				return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(commonhttp.Attr(node, "onclick"), "gtoggle")
+			})
+			if link == nil {
+				continue
+			}
+			entry := api.DupeEntry{Name: strings.TrimSpace(commonhttp.NodeText(link)), Link: groupLink}
+			if match := ffGroupPattern.FindStringSubmatch(groupLink); len(match) == 2 {
+				entry.ID = match[1]
+			}
+			if entry.Name != "" {
+				entries = append(entries, entry)
+			}
+		}
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func ffBaseURL(_ config.Config) string {
+	return "https://www.funfile.org"
+}
diff --git a/internal/trackers/impl/standalone/ff/profile.go b/internal/trackers/impl/standalone/ff/profile.go
new file mode 100644
index 00000000..ece09a1f
--- /dev/null
+++ b/internal/trackers/impl/standalone/ff/profile.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ff
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/internal/cookieauth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns FF identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "FF",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "ff",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: sourceFlag,
+		},
+		AudioPolicy: &trackers.AudioPolicy{
+			AllowBloat: true,
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"tracker.funfile.org"},
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		AuthResolver: cookieauth.CookieLoginResolver(cookieauth.CookieLoginSpec{
+			TrackerID:     "FF",
+			BaseURL:       baseURL,
+			CookieDomain:  "www.funfile.org",
+			Validate:      validateAuthCookies,
+			HasCredential: ffHasLoginCredentials,
+			Login:         loginAuthSession,
+		}),
+	}
+}
+
+// New returns a fresh FF definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	return trackers.DescriptionResult{Group: "ff", Description: buildDescription(assets)}, nil
+}
diff --git a/internal/trackers/impl/standalone/ff/upload.go b/internal/trackers/impl/standalone/ff/upload.go
new file mode 100644
index 00000000..de2e71a8
--- /dev/null
+++ b/internal/trackers/impl/standalone/ff/upload.go
@@ -0,0 +1,431 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ff
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://www.funfile.org"
+	loginURL   = baseURL + "/takelogin.php"
+	uploadURL  = baseURL + "/takeupload.php"
+	torrentURL = baseURL + "/details.php?id="
+	sourceFlag = "FunFile"
+)
+
+var idPattern = regexp.MustCompile(`details\.php\?id=(\d+)`)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	extraFiles    []commonhttp.FileField
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: FF %s", state.blockedReason)
+	}
+	files := append([]commonhttp.FileField{{
+		FieldName: "file",
+		FileName:  state.releaseName + ".torrent",
+		Path:      state.torrentPath,
+	}}, state.extraFiles...)
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	artifactPath := ""
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "FF")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: FF request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+	client := httpclient.CloneWithTimeout(
+		&http.Client{CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }},
+		httpclient.DefaultTimeout,
+	)
+	result, err := commonhttp.ExecuteUpload(client, httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "FF",
+		SuccessStatus: func(status int) bool { return status == http.StatusFound },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: FF execute upload: %w", err)
+	}
+	location := result.Header.Get("Location")
+	match := idPattern.FindStringSubmatch(location)
+	if result.Success && len(match) >= 2 {
+		id := match[1]
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "FF",
+			TorrentID:   id,
+			TorrentURL:  tURL,
+			DownloadURL: tURL,
+			TorrentPath: artifactPath,
+		}}}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "FF", "upload_failure", result.Preview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("FF", result.StatusCode, result.Preview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "FF",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "ff",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	cookies, err := resolveCookies(ctx, req.Logger, req.TrackerConfig, req.Runtime.DBPath, dryRun)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(assets)
+	fields := map[string]string{
+		"MAX_FILE_SIZE": "10000000",
+		"type":          resolveTypeID(req.Meta),
+		"tags":          "",
+		"descr":         description,
+	}
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(req.Meta)))
+	switch {
+	case req.Meta.Anime:
+		fields["anime_type"] = resolveAnimeType(req.Meta)
+		fields["anime_source"] = resolveAnimeSource(req.Meta)
+		fields["anime_container"] = "mkv"
+		fields["anime_v_res"] = req.Meta.Release.Resolution
+		fields["anime_v_dar"] = "16_9"
+		fields["anime_v_codec"] = resolveAnimeVCodec(req.Meta)
+	case category == "MOVIE":
+		fields["movie_type"] = resolveMovieType(req.Meta)
+		fields["movie_source"] = resolveMovieSource(req.Meta)
+		fields["movie_imdb"] = resolveIMDbURL(req.Meta)
+		fields["pack"] = "0"
+	default:
+		fields["tv_type"] = resolveTVType(req.Meta)
+		fields["tv_source"] = resolveTVSource(req.Meta)
+		fields["tv_imdb"] = resolveIMDbURL(req.Meta)
+		fields["pack"] = "0"
+		if req.Meta.TVPack {
+			fields["pack"] = "1"
+		}
+	}
+	state := uploadState{
+		torrentPath: torrentPath,
+		description: description,
+		releaseName: resolveName(req.Meta),
+		fields:      fields,
+		extraFiles:  resolveExtraFiles(ctx, req.Meta),
+	}
+	return state, cookies, nil
+}
+
+func resolveCookies(ctx context.Context, logger api.Logger, cfg config.TrackerConfig, dbPath string, dryRun bool) ([]*http.Cookie, error) {
+	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FF", "www.funfile.org")
+	if err != nil {
+		if logger != nil {
+			logger.Debugf("trackers: LoadTrackerHTTPCookies failed for FF/www.funfile.org, dbPath=%s: %v", dbPath, err)
+		}
+	} else if len(loaded) > 0 {
+		return loaded, nil
+	}
+	if dryRun {
+		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+			return nil, errors.New("trackers: FF cookies not found")
+		}
+		// #nosec G124 -- Dry-run sentinel is an outbound tracker jar cookie, not a browser-set cookie.
+		return []*http.Cookie{{
+			Name:   "dryrun",
+			Value:  "1",
+			Domain: ".funfile.org",
+			Path:   "/",
+		}}, nil
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, errors.New("trackers: FF cookie invalid/missing and username/password not configured")
+	}
+	data := url.Values{}
+	data.Set("returnto", "/index.php")
+	data.Set("username", strings.TrimSpace(cfg.Username))
+	data.Set("password", strings.TrimSpace(cfg.Password))
+	data.Set("login", "Login")
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FF login request build: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "upbrr")
+	client := httpclient.CloneWithTimeout(
+		&http.Client{CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }},
+		httpclient.DefaultTimeout,
+	)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FF login request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusFound {
+		return nil, fmt.Errorf("trackers: FF login failed status=%d", resp.StatusCode)
+	}
+	return resp.Cookies(), nil
+}
+
+func buildDescription(assets trackers.DescriptionAssets) string {
+	if strings.TrimSpace(assets.Description) != "" {
+		return finalizeDescription(strings.TrimSpace(assets.Description))
+	}
+	return ""
+}
+
+func resolveExtraFiles(ctx context.Context, meta api.UploadSubject) []commonhttp.FileField {
+	files := make([]commonhttp.FileField, 0, 2)
+	if ctx == nil {
+		return files
+	}
+	if poster := resolvePoster(meta); poster != "" {
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, poster, nil)
+		if err == nil {
+			resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
+			if err == nil {
+				defer resp.Body.Close()
+				if body, err := io.ReadAll(resp.Body); err == nil && len(body) > 0 {
+					files = append(files, commonhttp.FileField{
+						FieldName: "poster",
+						FileName:  "poster.jpg",
+						Content:   body,
+					})
+				}
+			}
+		}
+	}
+	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
+	if payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo"); err == nil {
+		files = append(files, commonhttp.FileField{
+			FieldName: "nfo",
+			FileName:  filepath.Base(path),
+			Content:   payload,
+		})
+	}
+	return files
+}
+
+func resolveTypeID(meta api.UploadSubject) string {
+	if meta.Anime {
+		return "44"
+	}
+	if strings.EqualFold(categoryOf(meta), "TV") {
+		return "7"
+	}
+	return "19"
+}
+
+func resolveMovieType(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.Source), "DVD") {
+		return "DVDR"
+	}
+	if strings.Contains(strings.ToLower(meta.VideoCodec), "hevc") || strings.Contains(strings.ToLower(meta.VideoEncode), "265") {
+		return "x265"
+	}
+	return "x264"
+}
+
+func resolveTVType(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.Source), "DVD") {
+		return "DVDR"
+	}
+	if strings.Contains(strings.ToLower(meta.Source), "web") {
+		if isSD(meta) {
+			return "Web-SD"
+		}
+		return "Web-HD"
+	}
+	if strings.Contains(strings.ToLower(meta.VideoCodec), "hevc") || strings.Contains(strings.ToLower(meta.VideoEncode), "265") {
+		if isSD(meta) {
+			return "x265-SD"
+		}
+		return "x265-HD"
+	}
+	if isSD(meta) {
+		return "x264-SD"
+	}
+	return "x264-HD"
+}
+
+func resolveAnimeType(meta api.UploadSubject) string {
+	if meta.SeasonInt == 0 {
+		return "TVSpecial"
+	}
+	if strings.EqualFold(categoryOf(meta), "MOVIE") {
+		return "Movie"
+	}
+	return "TVSeries"
+}
+
+func resolveMovieSource(meta api.UploadSubject) string {
+	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
+	case "dvd":
+		return "DVD"
+	case "blu-ray", "bluray":
+		return "BluRay"
+	case "hdtv":
+		return "HDTV"
+	case "webrip", "webdl", "web":
+		return "WebRIP"
+	default:
+		return "BluRay"
+	}
+}
+
+func resolveTVSource(meta api.UploadSubject) string {
+	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
+	case "dvd":
+		return "DVD"
+	case "blu-ray", "bluray":
+		return "BluRay"
+	case "hdtv":
+		return "HDTV"
+	case "webrip", "webdl", "web":
+		return "WebRIP"
+	default:
+		return "HDTV"
+	}
+}
+
+func resolveAnimeSource(meta api.UploadSubject) string {
+	switch strings.ToLower(strings.TrimSpace(meta.Source)) {
+	case "dvd":
+		return "DVD"
+	case "blu-ray", "bluray":
+		return "BluRay"
+	default:
+		return "Anime Series"
+	}
+}
+
+func resolveAnimeVCodec(meta api.UploadSubject) string {
+	if strings.Contains(strings.ToLower(meta.VideoCodec), "vc-1") {
+		return "VC1"
+	}
+	if strings.Contains(strings.ToLower(meta.VideoEncode), "h.264") {
+		return "h264"
+	}
+	return "x264"
+}
+
+func resolveName(meta api.UploadSubject) string {
+	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
+		return strings.TrimSpace(meta.SceneName)
+	}
+	return strings.ReplaceAll(metautil.FirstNonEmptyTrimmed(meta.ReleaseNameClean, meta.ReleaseName, meta.Filename), " ", ".")
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	}
+	return ""
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func isSD(meta api.UploadSubject) bool {
+	return strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "480p") || strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "576p")
+}
diff --git a/internal/trackers/impl/standalone/fl/auth.go b/internal/trackers/impl/standalone/fl/auth.go
new file mode 100644
index 00000000..5963a59c
--- /dev/null
+++ b/internal/trackers/impl/standalone/fl/auth.go
@@ -0,0 +1,192 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package fl
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+)
+
+const flAuthResponseMaxBytes = 1 << 20
+
+var flAuthValidatorPattern = regexp.MustCompile(`name="validator"\s+value="([^"]+)"`)
+
+// validateAuthCookies checks bounded FL home-page evidence. Explicit login
+// evidence and a missing logout marker are confirmed-invalid; transport, read,
+// and other HTTP failures remain transient.
+func validateAuthCookies(ctx context.Context, baseURL string, values []*http.Cookie) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/index.php", nil)
+	if err != nil {
+		return fmt.Errorf("trackers: FL session validation request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range values {
+		if cookie != nil && strings.TrimSpace(cookie.Name) != "" && strings.TrimSpace(cookie.Value) != "" {
+			req.AddCookie(cookie)
+		}
+	}
+	resp, err := flAuthHTTPClient(nil).Do(req)
+	if err != nil {
+		return &trackerauth.ValidationError{
+			TrackerID: "FL",
+			Transient: true,
+			Reason:    "remote validation unavailable",
+			Err:       fmt.Errorf("trackers: FL session validation request: %w", err),
+		}
+	}
+	defer resp.Body.Close()
+	body, err := readFLAuthBody(resp)
+	if err != nil {
+		return &trackerauth.ValidationError{
+			TrackerID: "FL",
+			Transient: true,
+			Reason:    "remote validation unavailable",
+			Err:       err,
+		}
+	}
+	lower := strings.ToLower(string(body))
+	location := strings.ToLower(resp.Header.Get("Location"))
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || strings.Contains(location, "login") ||
+		strings.Contains(lower, "login.php") ||
+		strings.Contains(lower, "name=\"username\"") ||
+		strings.Contains(lower, "name=\"password\"") {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FL",
+			ConfirmedInvalid: true,
+			Reason:           "stored session expired",
+			Err:              fmt.Errorf("trackers: FL session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return &trackerauth.ValidationError{
+			TrackerID: "FL",
+			Transient: true,
+			Reason:    "remote validation failed",
+			Err:       fmt.Errorf("trackers: FL session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if !strings.Contains(lower, "logout") {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FL",
+			ConfirmedInvalid: true,
+			Reason:           "stored session expired",
+			Err:              errors.New("trackers: FL logout marker not found"),
+		}
+	}
+	return nil
+}
+
+// loginAuthSession fetches FL's validator token, submits configured
+// credentials, and persists only non-empty cookies that pass remote validation.
+func loginAuthSession(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return fmt.Errorf("trackers: FL create login cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/login.php", nil)
+	if err != nil {
+		return fmt.Errorf("trackers: FL login page request build: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: FL login page request: %w", err)
+	}
+	body, readErr := readFLAuthBody(resp)
+	closeErr := resp.Body.Close()
+	if readErr != nil {
+		return fmt.Errorf("trackers: FL read login page response: %w", readErr)
+	}
+	if closeErr != nil {
+		return fmt.Errorf("trackers: FL close login page response: %w", closeErr)
+	}
+	match := flAuthValidatorPattern.FindStringSubmatch(string(body))
+	if len(match) < 2 {
+		return errors.New("trackers: FL validator token not found")
+	}
+	data := url.Values{
+		"validator": {match[1]},
+		"username":  {strings.TrimSpace(cfg.Username)},
+		"password":  {strings.TrimSpace(cfg.Password)},
+		"unlock":    {"1"},
+	}
+	loginReq, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/takelogin.php", strings.NewReader(data.Encode()))
+	if err != nil {
+		return fmt.Errorf("trackers: FL login request build: %w", err)
+	}
+	loginReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	loginResp, err := client.Do(loginReq)
+	if err != nil {
+		return fmt.Errorf("trackers: FL login request: %w", err)
+	}
+	defer loginResp.Body.Close()
+	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 {
+		return &trackerauth.ValidationError{
+			TrackerID:        "FL",
+			ConfirmedInvalid: true,
+			Reason:           "login failed",
+			Err:              fmt.Errorf("trackers: FL login failed status=%d", loginResp.StatusCode),
+		}
+	}
+	base, err := url.Parse(baseURL + "/")
+	if err != nil {
+		return fmt.Errorf("trackers: FL parse base URL: %w", err)
+	}
+	loginCookies := jar.Cookies(base)
+	if len(usableFLAuthCookies(loginCookies)) == 0 {
+		return errors.New("trackers: FL login returned no usable cookies")
+	}
+	if err := validateAuthCookies(ctx, baseURL, loginCookies); err != nil {
+		return fmt.Errorf("trackers: FL validate login cookies: %w", err)
+	}
+	if err := cookies.SaveTrackerHTTPCookies(ctx, dbPath, "FL", usableFLAuthCookies(loginCookies)); err != nil {
+		return fmt.Errorf("trackers: FL persist login cookies: %w", err)
+	}
+	return nil
+}
+
+func flAuthHTTPClient(jar http.CookieJar) *http.Client {
+	return &http.Client{
+		Timeout:       30 * time.Second,
+		Jar:           jar,
+		CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse },
+	}
+}
+
+func readFLAuthBody(resp *http.Response) ([]byte, error) {
+	body, err := io.ReadAll(io.LimitReader(resp.Body, flAuthResponseMaxBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL read auth response: %w", err)
+	}
+	if len(body) > flAuthResponseMaxBytes {
+		return nil, errors.New("trackers: FL auth response exceeds limit")
+	}
+	return body, nil
+}
+
+func usableFLAuthCookies(values []*http.Cookie) []*http.Cookie {
+	usable := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		if cookie != nil && strings.TrimSpace(cookie.Name) != "" && strings.TrimSpace(cookie.Value) != "" {
+			usable = append(usable, cookie)
+		}
+	}
+	return usable
+}
+
+func flHasLoginCredentials(cfg config.TrackerConfig) bool {
+	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
+}
diff --git a/internal/trackers/impl/standalone/fl/bbcode.go b/internal/trackers/impl/standalone/fl/bbcode.go
new file mode 100644
index 00000000..029d5a57
--- /dev/null
+++ b/internal/trackers/impl/standalone/fl/bbcode.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package fl
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.RemoveSpoiler(value)
+	value = bbcode.ConvertCodeToQuote(value)
+	value = bbcode.ConvertComparisonToCentered(value, 900)
+	value = bbcode.RemoveImageResize(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/fl/dupe.go b/internal/trackers/impl/standalone/fl/dupe.go
new file mode 100644
index 00000000..50d22c3b
--- /dev/null
+++ b/internal/trackers/impl/standalone/fl/dupe.go
@@ -0,0 +1,182 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package fl
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	baseURL := flBaseURL(s.cfg)
+	parsedBase, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "FL search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "FL", parsedBase.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid FL cookies", nil)
+	}
+	params := url.Values{"cat": {strconv.Itoa(flCategoryID(meta))}}
+	if meta.Identity.IMDBID != 0 {
+		params.Set("search", fmt.Sprintf("tt%07d", meta.Identity.IMDBID))
+		params.Set("searchin", "3")
+	} else {
+		query := metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)
+		if query == "" {
+			return dupe.NotRun(dupe.NotRunMissingMetadata, "missing FL search query", nil)
+		}
+		params.Set("search", query)
+		params.Set("searchin", "0")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/browse.php", nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "FL search failed", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(req, trackerCookies)
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "FL search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "FL search failed", nil)
+	}
+	root, err := xhtml.Parse(resp.Body)
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "FL search failed", err)
+	}
+	entries := make([]api.DupeEntry, 0)
+	flWalk(root, func(node *xhtml.Node) {
+		if node.Type != xhtml.ElementNode || node.Data != "a" {
+			return
+		}
+		href := flAttr(node, "href")
+		if !strings.HasPrefix(href, "details.php?id=") || strings.Contains(href, "&") {
+			return
+		}
+		name := metautil.FirstNonEmptyTrimmed(flAttr(node, "title"), flText(node))
+		if name == "" {
+			return
+		}
+		link := flAbsoluteURL(baseURL, href)
+		id := ""
+		if parsed, parseErr := url.Parse(link); parseErr == nil {
+			id = strings.TrimSpace(parsed.Query().Get("id"))
+		}
+		entries = append(entries, api.DupeEntry{
+			Name: name,
+			ID:   id,
+			Link: link,
+		})
+	})
+	return dupe.Resolved(entries, nil)
+}
+
+func flBaseURL(_ config.Config) string {
+	return "https://filelist.io"
+}
+func flCategoryID(meta api.DuplicateSubject) int {
+	if meta.Anime {
+		return 24
+	}
+	category := strings.ToUpper(strings.TrimSpace(string(meta.Identity.Category)))
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	switch {
+	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
+		return 2
+	case category == "TV":
+		if resolution == "2160p" {
+			return 27
+		}
+		if resolution == "480p" || resolution == "576p" {
+			return 23
+		}
+		return 21
+	default:
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+			if resolution == "2160p" {
+				return 26
+			}
+			return 20
+		}
+		if resolution == "2160p" {
+			return 6
+		}
+		if resolution == "480p" || resolution == "576p" {
+			return 1
+		}
+		return 4
+	}
+}
+func flWalk(node *xhtml.Node, visit func(*xhtml.Node)) {
+	if node == nil {
+		return
+	}
+	visit(node)
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		flWalk(child, visit)
+	}
+}
+func flAttr(node *xhtml.Node, key string) string {
+	for _, attr := range node.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return strings.TrimSpace(attr.Val)
+		}
+	}
+	return ""
+}
+func flText(node *xhtml.Node) string {
+	if node == nil {
+		return ""
+	}
+	if node.Type == xhtml.TextNode {
+		return node.Data
+	}
+	var builder strings.Builder
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		builder.WriteString(flText(child))
+	}
+	return strings.TrimSpace(builder.String())
+}
+func flAbsoluteURL(baseURL, value string) string {
+	parsed, err := url.Parse(value)
+	if err != nil {
+		return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(value, "/")
+	}
+	base, err := url.Parse(baseURL)
+	if err != nil {
+		return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(value, "/")
+	}
+	return base.ResolveReference(parsed).String()
+}
diff --git a/internal/trackers/impl/standalone/fl/profile.go b/internal/trackers/impl/standalone/fl/profile.go
new file mode 100644
index 00000000..6aacae8a
--- /dev/null
+++ b/internal/trackers/impl/standalone/fl/profile.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package fl
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/internal/cookieauth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns FL identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "FL",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "fl",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: "FL",
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"reactor.filelist", "reactor.thefl.org"},
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			AuthKind:           "cookies_login",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+		},
+		AuthResolver: cookieauth.CookieLoginResolver(cookieauth.CookieLoginSpec{
+			TrackerID:     "FL",
+			BaseURL:       baseURL,
+			CookieDomain:  ".filelist.io",
+			Validate:      validateAuthCookies,
+			HasCredential: flHasLoginCredentials,
+			Login:         loginAuthSession,
+		}),
+	}
+}
+
+// New returns a fresh FL definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	return trackers.DescriptionResult{Group: "fl", Description: buildDescription(assets)}, nil
+}
diff --git a/internal/trackers/impl/standalone/fl/upload.go b/internal/trackers/impl/standalone/fl/upload.go
new file mode 100644
index 00000000..3de88ddc
--- /dev/null
+++ b/internal/trackers/impl/standalone/fl/upload.go
@@ -0,0 +1,466 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package fl
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL      = "https://filelist.io"
+	loginPageURL = baseURL + "/login.php"
+	loginURL     = baseURL + "/takelogin.php"
+	uploadURL    = baseURL + "/takeupload.php"
+	downloadURL  = baseURL + "/download.php?id="
+)
+
+var (
+	validatorPattern = regexp.MustCompile(`name="validator"\s+value="([^"]+)"`)
+	successPattern   = regexp.MustCompile(`details\.php\?id=(\d+)&uploaded=`)
+	newHTTPClient    = httpclient.New
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	questionnaire *api.TrackerQuestionnaire
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: FL %s", state.blockedReason)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
+		FieldName: "file",
+		FileName:  resolveTorrentFileName(req.Meta, state.releaseName) + ".torrent",
+		Path:      state.torrentPath,
+	}})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: FL create cookie jar: %w", err)
+	}
+	base, _ := url.Parse(baseURL)
+	jar.SetCookies(base, cookies)
+	client := httpclient.CloneWithTimeout(&http.Client{Jar: jar}, httpclient.DefaultTimeout)
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, client, body, contentType)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	client *http.Client,
+	body []byte,
+	contentType string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: FL request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	result, err := commonhttp.ExecuteUpload(client, httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "FL",
+		SuccessStatus: func(status int) bool { return status >= 200 && status < 400 },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: FL execute upload: %w", err)
+	}
+	match := successPattern.FindStringSubmatch(result.FinalURL)
+	if len(match) >= 2 {
+		id := match[1]
+		artifactPath, err := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "FL")
+		if err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+		if err := downloadPersonalizedTorrent(ctx, client, id, artifactPath); err != nil {
+			return api.UploadSummary{}, err
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "FL",
+				TorrentID:   id,
+				TorrentURL:  baseURL + "/details.php?id=" + id,
+				DownloadURL: downloadURL + id,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "FL", "upload_failure", result.Preview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("FL", result.StatusCode, result.FinalURL, result.Preview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "FL",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "fl",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	cookies, err := resolveCookies(ctx, req.Logger, req.TrackerConfig, req.Runtime.DBPath, dryRun)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(assets)
+	name := resolveName(req.Meta, standalone.QuestionnaireAnswers(req.Meta, "FL"))
+	fields := map[string]string{
+		"name":  name,
+		"type":  strconv.Itoa(resolveCategoryID(req.Meta)),
+		"descr": description,
+		"nfo":   resolveMedia(req.Meta),
+	}
+	if req.Meta.Identity.IMDBID > 0 {
+		fields["imdbid"] = strconv.Itoa(req.Meta.Identity.IMDBID)
+		fields["description"] = resolveGenres(req.Meta)
+	}
+	if strings.TrimSpace(req.TrackerConfig.UploaderName) != "" && !req.TrackerConfig.Anon {
+		fields["epenis"] = strings.TrimSpace(req.TrackerConfig.UploaderName)
+	}
+	if hasRomanianAudio(req.Meta) {
+		fields["materialro"] = "on"
+	}
+	if strings.EqualFold(strings.TrimSpace(req.Meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(req.Meta.Type), "REMUX") || req.Meta.TVPack {
+		fields["freeleech"] = "on"
+	}
+	state := uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   name,
+		fields:        fields,
+		questionnaire: buildQuestionnaire(req.Meta, name),
+	}
+	if strings.TrimSpace(name) == "" {
+		state.blockedReason = "missing release name"
+	}
+	return state, cookies, nil
+}
+
+// resolveCookies returns usable stored FL cookies or performs credential login.
+// Login-page read errors are reported before token parsing, and successful
+// credential login requires durable cookie persistence.
+func resolveCookies(ctx context.Context, logger api.Logger, cfg config.TrackerConfig, dbPath string, dryRun bool) ([]*http.Cookie, error) {
+	loaded, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "FL", ".filelist.io")
+	if err != nil {
+		if logger != nil {
+			logger.Debugf("trackers: LoadTrackerHTTPCookies failed for FL/.filelist.io, dbPath=%s: %v", dbPath, err)
+		}
+	} else if valid := validFLCookies(loaded); len(valid) > 0 {
+		return valid, nil
+	} else if logger != nil {
+		logger.Debugf("trackers: FL loaded cookies were missing/expired, falling back to credential login, dbPath=%s", dbPath)
+	}
+	if dryRun {
+		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+			return nil, errors.New("trackers: FL cookies not found")
+		}
+		// #nosec G124 -- Dry-run sentinel is an outbound tracker jar cookie, not a browser-set cookie.
+		return []*http.Cookie{{
+			Name:   "dryrun",
+			Value:  "1",
+			Domain: ".filelist.io",
+			Path:   "/",
+		}}, nil
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, errors.New("trackers: FL cookie invalid/missing and username/password not configured")
+	}
+	if err := ensureLoginCookieStorageAvailable(dbPath); err != nil {
+		return nil, err
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL create login cookie jar: %w", err)
+	}
+	client := newHTTPClient(httpclient.DefaultTimeout)
+	client.Jar = jar
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, loginPageURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL login page request build: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL login page request: %w", err)
+	}
+	body, err := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL read login page response: %w", err)
+	}
+	match := validatorPattern.FindStringSubmatch(string(body))
+	if len(match) < 2 {
+		return nil, errors.New("trackers: FL validator token not found")
+	}
+	data := url.Values{}
+	data.Set("validator", match[1])
+	data.Set("username", strings.TrimSpace(cfg.Username))
+	data.Set("password", strings.TrimSpace(cfg.Password))
+	data.Set("unlock", "1")
+	loginReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL login request build: %w", err)
+	}
+	loginReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	loginResp, err := client.Do(loginReq)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: FL login request: %w", err)
+	}
+	defer loginResp.Body.Close()
+	if loginResp.StatusCode < 200 || loginResp.StatusCode >= 400 {
+		return nil, fmt.Errorf("trackers: FL login failed status=%d", loginResp.StatusCode)
+	}
+	base, _ := url.Parse(baseURL)
+	loginCookies := client.Jar.Cookies(base)
+	if err := persistLoginCookies(ctx, dbPath, loginCookies); err != nil {
+		return nil, err
+	}
+	return loginCookies, nil
+}
+
+// persistLoginCookies saves FL login cookies and returns any persistence error
+// so callers do not report login success without durable cookie storage.
+func persistLoginCookies(ctx context.Context, dbPath string, values []*http.Cookie) error {
+	valid := validFLCookies(values)
+	if len(valid) == 0 {
+		return errors.New("trackers: FL login returned no usable cookies")
+	}
+	if err := cookies.SaveTrackerHTTPCookies(ctx, dbPath, "FL", valid); err != nil {
+		return fmt.Errorf("trackers: FL persist login cookies: %w", err)
+	}
+	return nil
+}
+
+func ensureLoginCookieStorageAvailable(dbPath string) error {
+	if _, err := authmaterial.LoadFromDBPath(dbPath); err != nil {
+		if errors.Is(err, authmaterial.ErrUnavailable) {
+			return fmt.Errorf("trackers: FL encrypted cookie storage unavailable before credential login: %w", cookies.ErrAuthHelperUnavailable)
+		}
+		return fmt.Errorf("trackers: FL check encrypted cookie storage before credential login: %w", err)
+	}
+	return nil
+}
+
+func validFLCookies(values []*http.Cookie) []*http.Cookie {
+	now := time.Now()
+	valid := make([]*http.Cookie, 0, len(values))
+	for _, cookie := range values {
+		if cookie == nil {
+			continue
+		}
+		if strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		if !cookie.Expires.IsZero() && cookie.Expires.Before(now) {
+			continue
+		}
+		valid = append(valid, cookie)
+	}
+	return valid
+}
+
+func downloadPersonalizedTorrent(ctx context.Context, client *http.Client, id string, outputPath string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL+id, nil)
+	if err != nil {
+		return fmt.Errorf("trackers: FL torrent download request build: %w", err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: FL torrent download request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("trackers: FL read torrent response: %w", err)
+	}
+	if err := os.WriteFile(outputPath, body, 0o600); err != nil {
+		return fmt.Errorf("trackers: FL write torrent output: %w", err)
+	}
+	return nil
+}
+
+func buildDescription(assets trackers.DescriptionAssets) string {
+	return finalizeDescription(strings.TrimSpace(assets.Description))
+}
+
+func buildQuestionnaire(meta api.UploadSubject, computedName string) *api.TrackerQuestionnaire {
+	answers := standalone.QuestionnaireAnswers(meta, "FL")
+	return &api.TrackerQuestionnaire{Tracker: "FL", Fields: []api.TrackerQuestionnaireField{{
+		Key:      "name",
+		Label:    "FileList Name",
+		Kind:     "text",
+		Value:    metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["name"]), computedName),
+		Required: true,
+	}}}
+}
+
+func resolveName(meta api.UploadSubject, answers map[string]string) string {
+	if answers != nil && strings.TrimSpace(answers["name"]) != "" {
+		return strings.TrimSpace(answers["name"])
+	}
+	name := strings.TrimSpace(meta.ReleaseName)
+	name = strings.ReplaceAll(name, " DV ", " DoVi ")
+	name = strings.ReplaceAll(name, "BluRay REMUX", "Remux")
+	name = strings.ReplaceAll(name, "BluRay Remux", "Remux")
+	name = strings.ReplaceAll(name, "PQ10", "HDR")
+	name = strings.ReplaceAll(name, "HDR10+", "HDR")
+	name = strings.ReplaceAll(name, "DD+", "DDP")
+	name = strings.Join(strings.Fields(name), ".")
+	return strings.Trim(name, ".")
+}
+
+func resolveTorrentFileName(meta api.UploadSubject, releaseName string) string {
+	if meta.Anime && strings.EqualFold(strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-")), "SubsPlease") {
+		return releaseName
+	}
+	return strings.TrimSuffix(strings.TrimSpace(meta.Filename), filepath.Ext(strings.TrimSpace(meta.Filename)))
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	if meta.Anime {
+		return 24
+	}
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	switch {
+	case strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD"):
+		if hasRomanianSub(meta) {
+			return 3
+		}
+		return 2
+	case category == "TV":
+		if resolution == "2160p" {
+			return 27
+		}
+		if isSD(meta) {
+			return 23
+		}
+		return 21
+	default:
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+			if resolution == "2160p" {
+				return 26
+			}
+			return 20
+		}
+		if resolution == "2160p" {
+			return 6
+		}
+		if isSD(meta) {
+			return 1
+		}
+		if hasRomanianSub(meta) {
+			return 19
+		}
+		return 4
+	}
+}
+
+func hasRomanianAudio(meta api.UploadSubject) bool {
+	for _, lang := range meta.AudioLanguages {
+		lower := strings.ToLower(strings.TrimSpace(lang))
+		if lower == "romanian" || lower == "ro" {
+			return true
+		}
+	}
+	return false
+}
+
+func hasRomanianSub(meta api.UploadSubject) bool {
+	for _, lang := range meta.SubtitleLanguages {
+		lower := strings.ToLower(strings.TrimSpace(lang))
+		if lower == "romanian" || lower == "ro" {
+			return true
+		}
+	}
+	return false
+}
+
+func resolveMedia(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return strings.TrimSpace(meta.Disc.Summary)
+	}
+	return metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), strings.TrimSpace(meta.DVDVOBMediaInfoText))
+}
+
+func resolveGenres(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	}
+	return strings.TrimSpace(meta.Release.Genre)
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func isSD(meta api.UploadSubject) bool {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	return resolution == "480p" || resolution == "576p"
+}
diff --git a/internal/trackers/impl/fl/upload_test.go b/internal/trackers/impl/standalone/fl/upload_test.go
similarity index 100%
rename from internal/trackers/impl/fl/upload_test.go
rename to internal/trackers/impl/standalone/fl/upload_test.go
diff --git a/internal/trackers/impl/standalone/gpw/banned_groups.go b/internal/trackers/impl/standalone/gpw/banned_groups.go
new file mode 100644
index 00000000..daf6559b
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/banned_groups.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+// bannedGroups returns GPW's static release-group blacklist.
+func bannedGroups() []string {
+	return []string{
+		"ALT",
+		"aXXo",
+		"BATWEB",
+		"BlackTV",
+		"BitsTV",
+		"BMDRu",
+		"BRrip",
+		"CM8",
+		"CrEwSaDe",
+		"CTFOH",
+		"CTRLHD",
+		"DDHDTV",
+		"DNL",
+		"DreamHD",
+		"ENTHD",
+		"FaNGDiNG0",
+		"FGT",
+		"HD2DVD",
+		"HDTime",
+		"HDT",
+		"Huawei",
+		"GPTHD",
+		"ION10",
+		"iPlanet",
+		"KiNGDOM",
+		"Leffe",
+		"Mp4Ba",
+		"mHD",
+		"MiniHD",
+		"mSD",
+		"MOMOWEB",
+		"nHD",
+		"nikt0",
+		"NSBC",
+		"nSD",
+		"NhaNc3",
+		"NukeHD",
+		"OFT",
+		"PRODJi",
+		"RARBG",
+		"RDN",
+		"SANTi",
+		"SeeHD",
+		"SeeWEB",
+		"SM737",
+		"SonyHD",
+		"STUTTERSHIT",
+		"TAGWEB",
+		"ViSION",
+		"VXT",
+		"WAF",
+		"x0r",
+		"Xiaomi",
+		"YIFY",
+	}
+}
diff --git a/internal/trackers/impl/standalone/gpw/bbcode.go b/internal/trackers/impl/standalone/gpw/bbcode.go
new file mode 100644
index 00000000..feda3be0
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/bbcode.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.RemoveSup(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.ConvertToAlign(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/gpw/definition.go b/internal/trackers/impl/standalone/gpw/definition.go
new file mode 100644
index 00000000..2e237aa5
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/definition.go
@@ -0,0 +1,25 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "gpw", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/gpw/description_assets_test.go b/internal/trackers/impl/standalone/gpw/description_assets_test.go
new file mode 100644
index 00000000..a48a69ef
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/description_assets_test.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
+		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "GPW",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader:   "Disc menu token",
+			ScreenshotHeader: "Screenshots token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "GPW", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/gpw/dupe.go b/internal/trackers/impl/standalone/gpw/dupe.go
new file mode 100644
index 00000000..85621250
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/dupe.go
@@ -0,0 +1,109 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://greatposterwall.com/api.php",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := gpwAPIKey(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb id for GPW dupe search", nil)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.endpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "GPW search failed", err)
+	}
+	req.URL.RawQuery = url.Values{
+		"api_key": {apiKey},
+		"action":  {"torrent"},
+		"imdbID":  {"tt" + strconv.Itoa(meta.Identity.IMDBID)},
+	}.Encode()
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "GPW search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "GPW search failed", nil)
+	}
+	var payload struct {
+		Status   int              `json:"status"`
+		Response []map[string]any `json:"response"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "GPW search failed", err)
+	}
+	if payload.Status != http.StatusOK {
+		return dupe.Failed(dupe.FailureResponseStatus, "GPW api rejected search", nil)
+	}
+	entries := make([]api.DupeEntry, 0, len(payload.Response))
+	for _, item := range payload.Response {
+		parts := []string{
+			gpwString(item["Name"]),
+			gpwString(item["Year"]),
+			gpwString(item["Resolution"]),
+			gpwString(item["Source"]),
+			gpwString(item["Processing"]),
+			gpwString(item["RemasterTitle"]),
+			gpwString(item["Codec"]),
+		}
+		entries = append(entries, api.DupeEntry{Name: strings.Join(strings.Fields(strings.Join(parts, " ")), " ")})
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func gpwAPIKey(cfg config.Config) string {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "GPW") {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
+
+func gpwString(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case float64:
+		return strconv.FormatFloat(typed, 'f', -1, 64)
+	case json.Number:
+		return typed.String()
+	default:
+		return ""
+	}
+}
diff --git a/internal/trackers/impl/standalone/gpw/profile.go b/internal/trackers/impl/standalone/gpw/profile.go
new file mode 100644
index 00000000..7f06597c
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/profile.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns GPW identity, preparation, dupe, bans, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                 "GPW",
+		BaseURL:              baseURL,
+		DescriptionGroup:     "gpw",
+		UploadContentMode:    trackers.UploadContentModeDescription,
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  newDuplicateAdapter,
+		BannedGroups:         bannedGroups(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		ImageHostPolicy: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"kshare", "pixhost", "pterclub", "ilikeshots", "imgbox"},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"https://tracker.greatposterwall.com"},
+		},
+	}
+}
+
+// New returns a fresh GPW definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/gpw/upload.go b/internal/trackers/impl/standalone/gpw/upload.go
new file mode 100644
index 00000000..1743b46c
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/upload.go
@@ -0,0 +1,659 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://greatposterwall.com"
+	torrentURL = baseURL + "/torrents.php?torrentid="
+	sourceFlag = "GreatPosterWall"
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	groupID       string
+	questionnaire *api.TrackerQuestionnaire
+	blockedReason string
+}
+
+type apiResponse struct {
+	Status   any    `json:"status"`
+	Response any    `json:"response"`
+	Error    string `json:"error"`
+	Message  string `json:"message"`
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: GPW %s", state.blockedReason)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
+		FieldName: "file_input",
+		FileName:  "GPW.placeholder.torrent",
+		Path:      state.torrentPath,
+	}})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	uploadEndpoint := baseURL + "/api.php?api_key=" + req.TrackerConfig.APIKey + "&action=upload"
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "GPW")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType, uploadEndpoint, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+	uploadEndpoint string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(
+		ctx,
+		http.MethodPost,
+		uploadEndpoint,
+		bytes.NewReader(body),
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: GPW upload request build: %s", commonhttp.RedactErrorDetail(err.Error()))
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: GPW upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode >= 200 && resp.StatusCode < 300,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: GPW read upload response: %w", err)
+	}
+	var decoded apiResponse
+	if err := json.Unmarshal(responseBody, &decoded); err != nil {
+		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+			return api.UploadSummary{}, commonhttp.UploadHTTPError("GPW", resp.StatusCode, responsePreview)
+		}
+		return api.UploadSummary{}, fmt.Errorf("trackers: GPW decode response: %w", err)
+	}
+	id := extractTorrentID(decoded.Response)
+	status := strings.ToLower(strings.TrimSpace(fmt.Sprint(decoded.Status)))
+	if (status == "success" || status == "ok" || status == "200") && id != "" {
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "GPW",
+			TorrentID:   id,
+			TorrentURL:  tURL,
+			DownloadURL: tURL,
+			TorrentPath: artifactPath,
+		}}}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "GPW", "upload_failure", responsePreview, ".json")
+	return api.UploadSummary{}, fmt.Errorf(
+		"trackers: GPW %s",
+		metautil.FirstNonEmptyTrimmed(
+			commonhttp.ExtractHTTPErrorDetail(responsePreview),
+			commonhttp.RedactErrorDetail(decoded.Error),
+			commonhttp.RedactErrorDetail(decoded.Message),
+			"upload failed",
+		),
+	)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	message := "dry-run payload generated"
+	if state.groupID == "" {
+		message += " for new group"
+	} else {
+		message += " for existing group"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "GPW",
+		ReadyMessage:     message,
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "gpw",
+		Description:      state.description,
+		Endpoint:         baseURL + "/api.php?action=upload",
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: GPW missing api_key")
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	groupID, _ := lookupGroupID(ctx, req.TrackerConfig.APIKey, req.Meta)
+	answers := standalone.QuestionnaireAnswers(req.Meta, "GPW")
+	fields := buildFields(req, req.TrackerConfig, description, groupID, answers)
+	state := uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
+		fields:        fields,
+		groupID:       groupID,
+		questionnaire: buildQuestionnaire(req.Meta, groupID, answers),
+	}
+	if reason := validateFields(groupID, fields); reason != "" {
+		state.blockedReason = reason
+	}
+	return state, nil
+}
+
+func lookupGroupID(ctx context.Context, apiKey string, meta api.UploadSubject) (string, error) {
+	if meta.Identity.IMDBID == 0 {
+		return "", nil
+	}
+	url := fmt.Sprintf("%s/api.php?api_key=%s&action=torrent&req=group&imdbID=tt%07d", baseURL, apiKey, meta.Identity.IMDBID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: GPW torrent URL lookup request build: %s", commonhttp.RedactErrorDetail(err.Error()))
+	}
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(req)
+	if err != nil {
+		return "", fmt.Errorf("trackers: GPW torrent URL lookup request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	var decoded apiResponse
+	if err := json.Unmarshal(body, &decoded); err != nil {
+		return "", nil
+	}
+	if responseMap, ok := decoded.Response.(map[string]any); ok {
+		if value, ok := responseMap["ID"]; ok {
+			return strings.TrimSpace(fmt.Sprint(value)), nil
+		}
+	}
+	return "", nil
+}
+
+func buildFields(
+	req trackers.PreparationInput,
+	trackerCfg config.TrackerConfig,
+	description string,
+	groupID string,
+	answers map[string]string,
+) map[string]string {
+	meta := req.Meta
+	fields := map[string]string{
+		"codec_other":               "",
+		"codec":                     resolveCodec(meta),
+		"container_other":           "",
+		"container":                 resolveContainer(meta),
+		"mediainfo[]":               trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta),
+		"movie_edition_information": onOff(strings.TrimSpace(meta.Edition) != ""),
+		"processing_other":          "",
+		"processing":                resolveProcessing(meta),
+		"release_desc":              description,
+		"remaster_custom_title":     "",
+		"remaster_title":            strings.TrimSpace(meta.Edition),
+		"remaster_year":             "",
+		"resolution_height":         "",
+		"resolution_width":          "",
+		"resolution":                resolveResolution(meta),
+		"source_other":              "",
+		"source":                    resolveSource(meta),
+		"submit":                    "true",
+		"subtitle_type":             resolveSubtitleType(meta),
+		"subtitles[]":               strings.Join(resolveSubtitles(meta), ","),
+	}
+	if groupID != "" {
+		fields["groupid"] = groupID
+	} else {
+		fields["data_source"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["data_source"]), "imdb")
+		fields["identifier"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["identifier"]), resolveIdentifier(meta))
+		fields["desc"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["desc"]), resolveOverview(meta))
+		fields["image"] = strings.TrimSpace(answers["poster_url"])
+		fields["maindesc"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["main_desc"]), resolveOverview(meta))
+		fields["name"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["title"]), meta.Release.Title)
+		fields["releasetype"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["release_type"]), resolveMovieType(meta))
+		fields["subname"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["subname"]), meta.Release.Title)
+		fields["tags"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["tags"]), resolveTags(meta))
+		fields["year"] = strconv.Itoa(resolveYear(meta))
+		fields["artists[]"] = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["director_name"]), resolveDirectorName(meta))
+		fields["importance[]"] = "1"
+		fields["artist_ids[]"] = strings.TrimSpace(answers["director_imdb"])
+		fields["artist_subs[]"] = strings.TrimSpace(answers["director_chinese"])
+		fields["characters[]"] = ""
+		fields["main_artist_number"] = "1"
+	}
+	maps.Copy(fields, resolveMediaFlags(meta))
+	if meta.Scene {
+		fields["scene"] = "on"
+	}
+	if meta.PersonalRelease {
+		if isDiscUpload(meta) {
+			fields["buy"] = "on"
+		} else {
+			fields["diy"] = "on"
+		}
+	}
+	if trackerCfg.Exclusive {
+		fields["jinzhuan"] = "on"
+	}
+	return fields
+}
+
+func isDiscUpload(meta api.UploadSubject) bool {
+	return strings.TrimSpace(meta.DiscType) != "" || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC")
+}
+
+func buildQuestionnaire(meta api.UploadSubject, groupID string, answers map[string]string) *api.TrackerQuestionnaire {
+	if groupID != "" {
+		return nil
+	}
+	fields := []api.TrackerQuestionnaireField{
+		{
+			Key:      "poster_url",
+			Label:    "Poster URL",
+			Kind:     "text",
+			Value:    metautil.FirstNonEmptyTrimmed(answers["poster_url"], resolvePoster(meta)),
+			Required: true,
+		},
+		{
+			Key:         "director_imdb",
+			Label:       "Director IMDb ID",
+			Kind:        "text",
+			Value:       answers["director_imdb"],
+			Placeholder: "nm0000138",
+			Required:    true,
+		},
+		{
+			Key:      "director_name",
+			Label:    "Director Name",
+			Kind:     "text",
+			Value:    metautil.FirstNonEmptyTrimmed(answers["director_name"], resolveDirectorName(meta)),
+			Required: true,
+		},
+		{
+			Key:   "director_chinese",
+			Label: "Director Chinese",
+			Kind:  "text",
+			Value: answers["director_chinese"],
+		},
+		{
+			Key:      "tags",
+			Label:    "Tags",
+			Kind:     "text",
+			Value:    metautil.FirstNonEmptyTrimmed(answers["tags"], resolveTags(meta)),
+			Required: true,
+		},
+	}
+	return &api.TrackerQuestionnaire{Tracker: "GPW", Fields: fields}
+}
+
+func validateFields(groupID string, fields map[string]string) string {
+	if groupID == "" {
+		for _, key := range []string{"image", "artists[]", "artist_ids[]", "tags"} {
+			if strings.TrimSpace(fields[key]) == "" {
+				return "missing required new-group data"
+			}
+		}
+	}
+	return ""
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	parts := make([]string, 0, 3)
+	// custom header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// logo
+	logoURL, logoSize := descriptionunit3d.ResolveLogo(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig())
+	if logoURL != "" {
+		if strings.HasSuffix(logoURL, ".svg") {
+			logoURL = strings.ReplaceAll(logoURL, ".svg", ".png")
+		}
+		parts = append(parts, fmt.Sprintf("[center][img=%d]%s[/img][/center]", logoSize, logoURL))
+	}
+
+	// description
+	if base := strings.TrimSpace(assets.Description); base != "" {
+		parts = append(parts, base)
+	}
+
+	// menu
+	if len(assets.MenuImages) > 0 {
+		// header
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		// images
+		if shots := screenshotBlock(assets.MenuImages); shots != "" {
+			parts = append(parts, shots)
+		}
+	}
+	// Screenshot Header
+	if header := strings.TrimSpace(req.Runtime.Description.ScreenshotHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// screenshots
+	if shots := screenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+
+	// custom user signature
+	if signature := strings.TrimSpace(req.Runtime.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	// upbrr signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[align=right][url=%s][size=1]%s[/size][/url][/align]", link, text))
+
+	// finalize description
+	finalDescription := finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "GPW", req.Runtime.DBPath, finalDescription, req.Logger)
+	}
+
+	return finalDescription
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(images))
+	for _, image := range images {
+		if strings.TrimSpace(image.RawURL) == "" {
+			continue
+		}
+		parts = append(parts, "[img]"+strings.TrimSpace(image.RawURL)+"[/img]")
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	return "[center]" + strings.Join(parts, " ") + "[/center]"
+}
+
+func extractTorrentID(value any) string {
+	switch typed := value.(type) {
+	case map[string]any:
+		if torrentID, ok := typed["torrent_id"]; ok {
+			return strings.TrimSpace(fmt.Sprint(torrentID))
+		}
+	case []any:
+		if len(typed) > 0 {
+			if first, ok := typed[0].(map[string]any); ok {
+				if torrentID, ok := first["torrent_id"]; ok {
+					return strings.TrimSpace(fmt.Sprint(torrentID))
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func resolveCodec(meta api.UploadSubject) string {
+	codec := strings.ToLower(strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.VideoEncode, meta.VideoCodec)))
+	switch {
+	case strings.Contains(codec, "hevc"), strings.Contains(codec, "265"):
+		return "HEVC"
+	case strings.Contains(codec, "avc"), strings.Contains(codec, "264"):
+		return "AVC"
+	case strings.Contains(codec, "vc-1"):
+		return "VC-1"
+	default:
+		return "Other"
+	}
+}
+
+func resolveContainer(meta api.UploadSubject) string {
+	container := strings.ToLower(strings.TrimSpace(meta.Container))
+	switch container {
+	case "mkv", "mp4", "avi", "vob", "m2ts":
+		return strings.ToUpper(container)
+	default:
+		return "Other"
+	}
+}
+
+func resolveProcessing(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "ENCODE":
+		return "Encode"
+	case "REMUX":
+		return "Remux"
+	case "DIY":
+		return "DIY"
+	default:
+		return "Untouched"
+	}
+}
+
+func resolveResolution(meta api.UploadSubject) string {
+	resolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
+	switch resolution {
+	case "480p", "576p", "720p", "1080i", "1080p", "2160p":
+		return resolution
+	default:
+		return "Other"
+	}
+}
+
+func resolveSource(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.Type)) {
+	case "DISC":
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+			return "Blu-ray"
+		}
+		return "DVD"
+	case "WEBDL", "WEBRIP":
+		return "WEB"
+	case "REMUX", "ENCODE":
+		return "Blu-ray"
+	case "HDTV":
+		return "HDTV"
+	default:
+		return "Other"
+	}
+}
+
+func resolveSubtitleType(meta api.UploadSubject) string {
+	if len(meta.SubtitleLanguages) > 0 {
+		return "1"
+	}
+	return "3"
+}
+
+func resolveSubtitles(meta api.UploadSubject) []string {
+	out := make([]string, 0, len(meta.SubtitleLanguages))
+	for _, lang := range meta.SubtitleLanguages {
+		switch strings.ToLower(strings.TrimSpace(lang)) {
+		case "english", "en":
+			out = append(out, "English")
+		case "chinese", "zh":
+			out = append(out, "Chinese")
+		case "portuguese", "pt":
+			out = append(out, "Portuguese")
+		}
+	}
+	return out
+}
+
+func resolveIdentifier(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("tt%07d", meta.Identity.IMDBID)
+	}
+	if meta.Identity.TMDBID > 0 {
+		return strconv.Itoa(meta.Identity.TMDBID)
+	}
+	return ""
+}
+
+func resolveOverview(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	}
+	return ""
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	}
+	return ""
+}
+
+func resolveMovieType(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.RuntimeMinutes > 0 && meta.ProviderMetadata.IMDB.RuntimeMinutes < 45 {
+		return "2"
+	}
+	return "1"
+}
+
+func resolveTags(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(strings.ToLower(strings.ReplaceAll(meta.ProviderMetadata.TMDB.Genres, ", ", ",")))
+	}
+	return strings.TrimSpace(strings.ToLower(meta.Release.Genre))
+}
+
+func resolveDirectorName(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Directors) > 0 {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Directors[0])
+	}
+	if meta.ProviderMetadata.IMDB != nil && len(meta.ProviderMetadata.IMDB.Directors) > 0 {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Directors[0].Name)
+	}
+	return ""
+}
+
+func resolveYear(meta api.UploadSubject) int {
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		return meta.ProviderMetadata.TMDB.Year
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		return meta.ProviderMetadata.IMDB.Year
+	}
+	return meta.Release.Year
+}
+
+func resolveMediaFlags(meta api.UploadSubject) map[string]string {
+	flags := map[string]string{}
+	audio := strings.ToLower(strings.TrimSpace(meta.Audio))
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	if strings.Contains(audio, "atmos") {
+		flags["dolby_atmos"] = "on"
+	}
+	if strings.Contains(audio, "dts:x") {
+		flags["dts_x"] = "on"
+	}
+	if meta.Channels == "5.1" {
+		flags["audio_51"] = "on"
+	}
+	if meta.Channels == "7.1" {
+		flags["audio_71"] = "on"
+	}
+	if meta.BitDepth == "10" && hdr == "" {
+		flags["10_bit"] = "on"
+	}
+	if strings.Contains(hdr, "DV") {
+		flags["dolby_vision"] = "on"
+	}
+	if strings.Contains(hdr, "HDR10+") {
+		flags["hdr10plus"] = "on"
+	} else if strings.Contains(hdr, "HDR") {
+		flags["hdr10"] = "on"
+	}
+	return flags
+}
+
+func onOff(value bool) string {
+	if value {
+		return "on"
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/gpw/upload_test.go b/internal/trackers/impl/standalone/gpw/upload_test.go
new file mode 100644
index 00000000..c7dc204b
--- /dev/null
+++ b/internal/trackers/impl/standalone/gpw/upload_test.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package gpw
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildFieldsPersonalReleaseAndExclusiveFlags(t *testing.T) {
+	t.Parallel()
+
+	base := api.UploadSubject{PersonalRelease: true}
+
+	nonDisc := buildFields(trackers.PreparationInput{Meta: base}, config.TrackerConfig{Exclusive: true}, "description", "group", nil)
+	if nonDisc["diy"] != "on" {
+		t.Fatalf("expected non-disc personal release to use diy flag, got %#v", nonDisc)
+	}
+	if _, ok := nonDisc["self_rip"]; ok {
+		t.Fatalf("did not expect legacy self_rip flag, got %#v", nonDisc)
+	}
+	if nonDisc["jinzhuan"] != "on" {
+		t.Fatalf("expected exclusive flag to set jinzhuan, got %#v", nonDisc)
+	}
+
+	discMeta := base
+	discMeta.DiscType = "BDMV"
+	disc := buildFields(trackers.PreparationInput{Meta: discMeta}, config.TrackerConfig{}, "description", "group", nil)
+	if disc["buy"] != "on" {
+		t.Fatalf("expected disc personal release to use buy flag, got %#v", disc)
+	}
+	if _, ok := disc["diy"]; ok {
+		t.Fatalf("did not expect diy for disc personal release, got %#v", disc)
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/auth.go b/internal/trackers/impl/standalone/hdb/auth.go
new file mode 100644
index 00000000..5b0da41c
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/auth.go
@@ -0,0 +1,117 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const hdbAuthResponseMaxBytes = 1 << 20
+
+// resolveAuthSessionAt validates required HDB credentials and stored cookies
+// without attempting login. Missing auth material requires operator action;
+// explicit login evidence is confirmed-invalid, while ambiguous remote or read
+// failures remain transient.
+func resolveAuthSessionAt(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	dbPath string,
+	_ api.TrackerAuthLoginRequest,
+	baseURL string,
+	httpClient *http.Client,
+) error {
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Passkey) == "" {
+		return &trackers.AuthResolutionError{
+			Reason:       "username/passkey missing",
+			AuthRequired: true,
+			Err:          errors.New("trackers: HDB missing username/passkey"),
+		}
+	}
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDB", "hdbits.org")
+	if err != nil || len(values) == 0 {
+		if err == nil {
+			err = cookies.ErrTrackerCookiesNotFound
+		}
+		return &trackers.AuthResolutionError{
+			Reason:       "cookies missing",
+			AuthRequired: true,
+			Err:          fmt.Errorf("trackers: HDB cookies unavailable: %w", err),
+		}
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/upload/upload", nil)
+	if err != nil {
+		return fmt.Errorf("trackers: HDB session validation request build: %w", err)
+	}
+	req.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range values {
+		if cookie != nil && strings.TrimSpace(cookie.Name) != "" && strings.TrimSpace(cookie.Value) != "" {
+			req.AddCookie(cookie)
+		}
+	}
+	client := httpClient
+	if client == nil {
+		client = &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return &trackers.AuthResolutionError{
+			Reason:    "remote validation unavailable",
+			Transient: true,
+			Err:       fmt.Errorf("trackers: HDB session validation request: %w", err),
+		}
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(io.LimitReader(resp.Body, hdbAuthResponseMaxBytes+1))
+	if err != nil {
+		return &trackers.AuthResolutionError{
+			Reason:    "remote validation unavailable",
+			Transient: true,
+			Err:       fmt.Errorf("trackers: HDB read validation response: %w", err),
+		}
+	}
+	if len(body) > hdbAuthResponseMaxBytes {
+		return &trackers.AuthResolutionError{
+			Reason:    "remote validation unavailable",
+			Transient: true,
+			Err:       errors.New("trackers: HDB validation response exceeds limit"),
+		}
+	}
+	bodyText := strings.ToLower(string(body))
+	location := strings.ToLower(resp.Header.Get("Location"))
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden || strings.Contains(location, "login") ||
+		strings.Contains(bodyText, "name=\"username\"") ||
+		strings.Contains(bodyText, "login.php") {
+		return &trackers.AuthResolutionError{
+			Reason:           "stored session expired",
+			ConfirmedInvalid: true,
+			Err:              fmt.Errorf("trackers: HDB session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return &trackers.AuthResolutionError{
+			Reason:    "remote validation failed",
+			Transient: true,
+			Err:       fmt.Errorf("trackers: HDB session validation failed status=%d", resp.StatusCode),
+		}
+	}
+	if !strings.Contains(bodyText, "upload") && !strings.Contains(bodyText, "torrent") {
+		return &trackers.AuthResolutionError{
+			Reason:           "stored session expired",
+			ConfirmedInvalid: true,
+			Err:              errors.New("trackers: HDB upload marker not found"),
+		}
+	}
+	return nil
+}
diff --git a/internal/trackers/impl/standalone/hdb/bbcode.go b/internal/trackers/impl/standalone/hdb/bbcode.go
new file mode 100644
index 00000000..b4582cc5
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/bbcode.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
+)
+
+var (
+	hdbComparisonSectionPattern = regexp.MustCompile(`(?i)\[center\]\s*\[b\].*?(Comparison|vs).*?\[/b\][\s\S]*?\[/center\]`)
+	hdbComparisonLinePattern    = regexp.MustCompile(`(?i)(.*comparison.*)\n`)
+	hdbEmptyURLPattern          = regexp.MustCompile(`(?i)\[url=https?://(img\.|t\.)?hdbits\.org[^\]]*\]\[/url\]`)
+	hdbEmptyAnyURLPattern       = regexp.MustCompile(`(?is)\[url\s*=\s*]\s*\[/url\]`)
+	hdbURLTagPattern            = regexp.MustCompile(`(?i)(\[url[=]]https?://(img\.|t\.)?hdbits\.org[^\]]+\])(.*?)(\[/url\])?`)
+	hdbImgPattern               = regexp.MustCompile(`(?i)\[img\][\s\S]*?(img\.|t\.)?hdbits\.org[\s\S]*?\[/img\]`)
+	hdbStandalonePattern        = regexp.MustCompile(`(?i)https?://(img\.|t\.)?hdbits\.org/[^\s\[\]]+`)
+	hdbURLTagAnyPattern         = regexp.MustCompile(`(?i)\[url[^\]]*hdbits\.org[^\]]*\](.*?)\[/url\]`)
+	hdbSelfClosingPattern       = regexp.MustCompile(`(?i)\[url=https?://[^\]]*hdbits\.org[^\]]*\]\[/url\]`)
+	hdbCenterEmptyPattern       = regexp.MustCompile(`(?i)\[center\]\s*\[/center\]`)
+	hdbBBCodeURLImgPattern      = regexp.MustCompile(`(?i)\[url=(https?://[^\]]+)\]\[img\](https?://[^\]]+)\[/img\]\[/url\]`)
+)
+
+// CleanDescription removes HDB-hosted images, links, and comparison sections
+// while extracting non-HDB linked images into the report. Empty or tag-only
+// cleaned text is omitted without discarding extracted images.
+func CleanDescription(description string) bbcode.Report {
+	desc := bbcode.NormalizeNewlines(description)
+	imagelist := make([]bbcode.Image, 0)
+
+	sections := hdbComparisonSectionPattern.FindAllString(desc, -1)
+	for _, section := range sections {
+		if strings.Contains(strings.ToLower(section), "hdbits.org") {
+			desc = strings.ReplaceAll(desc, section, "")
+		}
+	}
+
+	lines := hdbComparisonLinePattern.FindAllStringIndex(desc, -1)
+	for _, match := range lines {
+		start := match[0]
+		end := min(start+500, len(desc))
+		segment := desc[start:end]
+		parts := strings.SplitN(segment, "\n", 4)
+		if len(parts) > 3 {
+			parts = parts[:3]
+		}
+		nextLines := strings.Join(parts, "\n")
+		if strings.Contains(strings.ToLower(nextLines), "hdbits.org") {
+			desc = strings.ReplaceAll(desc, nextLines, "")
+		}
+	}
+
+	desc = hdbEmptyURLPattern.ReplaceAllString(desc, "")
+	urlTags := hdbURLTagPattern.FindAllString(desc, -1)
+	for _, urlTag := range urlTags {
+		desc = strings.ReplaceAll(desc, urlTag, "")
+	}
+
+	imgTags := hdbImgPattern.FindAllString(desc, -1)
+	for _, imgTag := range imgTags {
+		desc = strings.ReplaceAll(desc, imgTag, "")
+	}
+
+	standalone := hdbStandalonePattern.FindAllString(desc, -1)
+	for _, url := range standalone {
+		desc = strings.ReplaceAll(desc, url, "")
+	}
+
+	desc = hdbURLTagAnyPattern.ReplaceAllString(desc, "")
+	desc = hdbSelfClosingPattern.ReplaceAllString(desc, "")
+	desc = hdbEmptyAnyURLPattern.ReplaceAllString(desc, "")
+	desc = hdbComparisonSectionPattern.ReplaceAllString(desc, "")
+	desc = hdbCenterEmptyPattern.ReplaceAllString(desc, "")
+	desc = bbcode.RemoveExtraLines(desc)
+
+	desc = hdbBBCodeURLImgPattern.ReplaceAllStringFunc(desc, func(value string) string {
+		parts := hdbBBCodeURLImgPattern.FindStringSubmatch(value)
+		if len(parts) < 3 {
+			return value
+		}
+		webURL := parts[1]
+		imgURL := parts[2]
+		lower := strings.ToLower(webURL + imgURL)
+		if strings.Contains(lower, "hdbits.org") {
+			return ""
+		}
+		rawURL := imgURL
+		rawURL = bbcode.NormalizeImageRawURL(rawURL)
+		host := imagehost.ExtractHost(imgURL)
+		imagelist = append(imagelist, bbcode.Image{
+			ImgURL: imgURL,
+			RawURL: rawURL,
+			WebURL: webURL,
+			Host:   host,
+		})
+		return ""
+	})
+
+	desc = strings.TrimSpace(desc)
+	if desc == "" || bbcode.IsOnlyTags(desc) {
+		return bbcode.Report{Images: imagelist}
+	}
+	return bbcode.Report{Description: desc, Images: imagelist}
+}
diff --git a/internal/trackers/impl/standalone/hdb/data.go b/internal/trackers/impl/standalone/hdb/data.go
new file mode 100644
index 00000000..81d941ca
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/data.go
@@ -0,0 +1,147 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dataLookup struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// NewDataLookup returns an HDB lookup bound to the definition's base URL, cfg,
+// and httpClient.
+func (d *Definition) NewDataLookup(cfg config.Config, httpClient *http.Client, _ api.Logger) trackers.DataLookup {
+	return &dataLookup{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: strings.TrimRight(d.baseURL, "/") + "/api/torrents",
+	}
+}
+
+// Lookup resolves the first HDB torrent by tracker ID or folder/file search.
+// Missing credentials or filters, non-success responses, API rejection, and
+// empty data produce an empty result without an error. OnlyID and KeepImages
+// independently control description and image projection.
+func (l *dataLookup) Lookup(ctx context.Context, req trackers.DataLookupRequest) (trackers.DataLookupResult, error) {
+	username, passkey := hdbCredentials(l.cfg)
+	if username == "" || passkey == "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	payload := map[string]any{"username": username, "passkey": passkey}
+	if id := strings.TrimSpace(req.TrackerID); id != "" {
+		payload["id"] = id
+	} else {
+		payload["limit"] = 100
+		hasFilter := false
+		if strings.TrimSpace(req.Meta.DiscType) != "" || len(req.Meta.FileList) != 1 {
+			payload["search"], hasFilter = pathutil.Base(req.Meta.SourcePath), true
+		} else if name := strings.TrimSpace(req.SearchName); name != "" {
+			payload["file_in_torrent"], hasFilter = name, true
+		}
+		if !hasFilter {
+			return trackers.DataLookupResult{}, nil
+		}
+	}
+	first, err := l.requestFirst(ctx, payload)
+	if err != nil || len(first) == 0 {
+		return trackers.DataLookupResult{}, err
+	}
+	result := trackers.DataLookupResult{
+		TrackerID: hdbString(first["id"]),
+		IMDBID:    hdbNestedInt(first, "imdb", "id"),
+		TVDBID:    hdbNestedInt(first, "tvdb", "id"),
+		InfoHash:  hdbString(first["hash"]),
+	}
+	if result.TrackerID == "" {
+		result.TrackerID = strings.TrimSpace(req.TrackerID)
+	}
+	if req.OnlyID && !req.KeepImages {
+		return result, nil
+	}
+	report := CleanDescription(hdbString(first["descr"]))
+	if !req.OnlyID {
+		result.Description = strings.TrimSpace(report.Description)
+	}
+	if req.KeepImages {
+		result.Images = report.Images
+	}
+	return result, nil
+}
+
+func (l *dataLookup) requestFirst(ctx context.Context, payload map[string]any) (map[string]any, error) {
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: hdb encode request: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, l.endpoint, bytes.NewReader(raw))
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: hdb request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := l.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: hdb request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return nil, nil
+	}
+	result := map[string]any{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("trackerdata: hdb decode: %w", err)
+	}
+	if hdbInt(result["status"]) != 0 {
+		return nil, nil
+	}
+	items, _ := result["data"].([]any)
+	if len(items) == 0 {
+		return nil, nil
+	}
+	item, _ := items[0].(map[string]any)
+	return item, nil
+}
+
+func hdbCredentials(cfg config.Config) (string, string) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "HDB") {
+			return strings.TrimSpace(entry.Username), strings.TrimSpace(entry.Passkey)
+		}
+	}
+	return "", ""
+}
+
+func hdbString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func hdbInt(value any) int {
+	var result int
+	_, _ = fmt.Sscan(hdbString(value), &result)
+	return result
+}
+
+func hdbNestedInt(value map[string]any, root, key string) int {
+	node, _ := value[root].(map[string]any)
+	return hdbInt(node[key])
+}
diff --git a/internal/trackers/impl/standalone/hdb/data_test.go b/internal/trackers/impl/standalone/hdb/data_test.go
new file mode 100644
index 00000000..9a003540
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/data_test.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDataLookup(t *testing.T) {
+	t.Parallel()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_ = json.NewEncoder(w).Encode(map[string]any{"status": 0, "data": []any{map[string]any{
+			"id":    "321",
+			"hash":  "deadbeef",
+			"imdb":  map[string]any{"id": "998877"},
+			"tvdb":  map[string]any{"id": "5544"},
+			"descr": "Text\n[url=https://imgbox.com/abc][img]https://thumbs2.imgbox.com/abc_t.png[/img][/url]",
+		}}})
+	}))
+	defer server.Close()
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"HDB": {Username: "user", Passkey: "pass"}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected HDB data lookup")
+	}
+	lookup.endpoint = server.URL
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{TrackerID: "321", KeepImages: true})
+	if err != nil {
+		t.Fatalf("lookup: %v", err)
+	}
+	if result.IMDBID != 998877 || result.TVDBID != 5544 || result.InfoHash != "deadbeef" || result.Description != "Text" || len(result.Images) != 1 {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+}
+
+func TestDataLookupSkipsUnfilteredSearch(t *testing.T) {
+	t.Parallel()
+	requested := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requested = true
+		http.Error(w, "unexpected request", http.StatusInternalServerError)
+	}))
+	defer server.Close()
+	lookup, ok := New().NewDataLookup(config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{"HDB": {Username: "user", Passkey: "pass"}}}}, server.Client(), nil).(*dataLookup)
+	if !ok {
+		t.Fatal("expected HDB data lookup")
+	}
+	lookup.endpoint = server.URL
+	result, err := lookup.Lookup(context.Background(), trackers.DataLookupRequest{Meta: api.UploadSubject{SourcePath: `D:\TV\Example.Show.S04E01.2160p.WEB.h265-GRP.mkv`, FileList: []string{"Example.Show.S04E01.2160p.WEB.h265-GRP.mkv"}}, KeepImages: true})
+	if err != nil || result.HasData() || requested {
+		t.Fatalf("err=%v data=%t requested=%t", err, result.HasData(), requested)
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/definition.go b/internal/trackers/impl/standalone/hdb/definition.go
new file mode 100644
index 00000000..23b25f68
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/definition.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+// DataLookupConfigured reports whether HDB metadata lookup credentials are available.
+func (d *Definition) DataLookupConfigured(cfg config.Config) bool {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "HDB") {
+			return strings.TrimSpace(entry.Username) != "" && strings.TrimSpace(entry.Passkey) != ""
+		}
+	}
+	return false
+}
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+			return trackers.DescriptionResult{}, fmt.Errorf("trackers: HDB description assets: %w", err)
+		}
+		if req.Logger != nil {
+			req.Logger.Warnf("trackers: HDB description assets failed: %v", err)
+		}
+		assets = trackers.DescriptionAssets{}
+	}
+
+	description := strings.TrimSpace(assets.Description)
+	if !assets.Final {
+		description, err = BuildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets.Description, assets.MenuImages, assets.Screenshots)
+		if err != nil {
+			return trackers.DescriptionResult{}, fmt.Errorf("trackers: HDB description build: %w", err)
+		}
+	}
+
+	if strings.TrimSpace(description) == "" && req.Logger != nil {
+		req.Logger.Infof("trackers: HDB preparation description empty")
+	}
+
+	return trackers.DescriptionResult{
+		Group:       "hdb",
+		Description: description,
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/hdb/definition_test.go b/internal/trackers/impl/standalone/hdb/definition_test.go
new file mode 100644
index 00000000..2ca16b52
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/definition_test.go
@@ -0,0 +1,301 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func (d *Definition) submit(ctx context.Context, input trackers.PreparationInput) (api.UploadSummary, error) {
+	return uploadAt(ctx, input, d.baseURL, d.httpClient)
+}
+
+func TestDefinitionBuildDescriptionUsesHDBGroup(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "HDB",
+		Meta:    api.UploadSubject{},
+		Logger:  api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result.Group != "hdb" {
+		t.Fatalf("expected hdb group, got %q", result.Group)
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesProvidedAssets(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "HDB",
+		Meta:    api.UploadSubject{},
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: "kept description",
+			Screenshots: []api.ScreenshotImage{{
+				ImgURL: "https://t.hdbits.org/example.jpg",
+				WebURL: "https://img.hdbits.org/example",
+				RawURL: "https://img.hdbits.org/example",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(result.Description, "https://t.hdbits.org/example.jpg") {
+		t.Fatalf("expected provided screenshot in description, got %q", result.Description)
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesProvidedMenuImages(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "HDB",
+		Meta:    api.UploadSubject{},
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			MenuImages: []api.ScreenshotImage{{
+				Purpose: api.ScreenshotPurposeMenu,
+				ImgURL:  "https://t.hdbits.org/menu.jpg",
+				WebURL:  "https://img.hdbits.org/menu",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(result.Description, "https://t.hdbits.org/menu.jpg") {
+		t.Fatalf("expected provided menu image in description, got %q", result.Description)
+	}
+}
+
+func TestDefinitionUploadMissingCredentials(t *testing.T) {
+	d := New()
+	_, err := d.submit(context.Background(), trackers.PreparationInput{Tracker: "HDB", Logger: api.NopLogger{}})
+	if err == nil {
+		t.Fatal("expected missing credentials error")
+	}
+}
+
+func TestDefinitionUploadSuccess(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	dbPath := filepath.Join(tmp, "ua.db")
+	cookieDir := filepath.Join(tmp, "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+	cookieText := "# Netscape HTTP Cookie File\n.hdbits.org\tTRUE\t/\tTRUE\t0\tuid\tcookievalue\n"
+	if err := os.WriteFile(filepath.Join(cookieDir, "HDB.txt"), []byte(cookieText), 0o600); err != nil {
+		t.Fatalf("write cookie file: %v", err)
+	}
+
+	uploadSeen := false
+	downloadSeen := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/upload/upload":
+			uploadSeen = true
+			if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "multipart/form-data") {
+				t.Errorf("expected multipart content-type, got %q", ct)
+				return
+			}
+			if err := r.ParseMultipartForm(5 << 20); err != nil {
+				t.Errorf("parse multipart: %v", err)
+				return
+			}
+			if r.FormValue("name") == "" {
+				t.Error("expected upload name field")
+				return
+			}
+			if descr := r.FormValue("descr"); !strings.Contains(descr, "https://t.hdbits.org/rehosted.jpg") {
+				t.Errorf("expected provided rehosted screenshot in description, got %q", descr)
+				return
+			}
+			files := r.MultipartForm.File["file"]
+			if len(files) == 0 {
+				t.Error("expected torrent file in multipart form")
+				return
+			}
+			f, err := files[0].Open()
+			if err != nil {
+				t.Errorf("open uploaded file: %v", err)
+				return
+			}
+			_, _ = io.ReadAll(f)
+			_ = f.Close()
+			http.Redirect(w, r, "/details.php?id=123&uploaded=1", http.StatusFound)
+		case r.URL.Path == "/details.php":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("ok"))
+		case strings.HasPrefix(r.URL.Path, "/download.php/"):
+			downloadSeen = true
+			if r.URL.Query().Get("id") != "123" {
+				t.Errorf("expected id=123, got %q", r.URL.Query().Get("id"))
+				return
+			}
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("reseed-torrent-bytes"))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	d := &Definition{baseURL: server.URL, httpClient: server.Client()}
+	result, err := d.submit(context.Background(), trackers.PreparationInput{
+		Tracker: "HDB",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
+			Type:        "WEBDL",
+			VideoCodec:  "HEVC",
+			ReleaseName: "My.Release.2026.2160p.WEBDL.HEVC",
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username: "user",
+			Passkey:  "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: "kept description",
+			Screenshots: []api.ScreenshotImage{{
+				ImgURL: "https://t.hdbits.org/rehosted.jpg",
+				WebURL: "https://img.hdbits.org/rehosted",
+				RawURL: "https://img.hdbits.org/rehosted",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
+	}
+	if len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected one uploaded torrent artifact, got %d", len(result.UploadedTorrents))
+	}
+	if result.UploadedTorrents[0].Tracker != "HDB" {
+		t.Fatalf("expected tracker HDB, got %q", result.UploadedTorrents[0].Tracker)
+	}
+	if result.UploadedTorrents[0].TorrentID != "123" {
+		t.Fatalf("expected torrent id 123, got %q", result.UploadedTorrents[0].TorrentID)
+	}
+	if !uploadSeen {
+		t.Fatal("expected upload endpoint to be called")
+	}
+	if !downloadSeen {
+		t.Fatal("expected download endpoint to be called")
+	}
+	artifactPath := result.UploadedTorrents[0].TorrentPath
+	if strings.TrimSpace(artifactPath) == "" {
+		t.Fatal("expected tracker-specific torrent path")
+	}
+	updated, err := os.ReadFile(artifactPath)
+	if err != nil {
+		t.Fatalf("read updated torrent: %v", err)
+	}
+	if string(updated) != "reseed-torrent-bytes" {
+		t.Fatalf("expected downloaded torrent bytes, got %q", string(updated))
+	}
+	original, err := os.ReadFile(torrentPath)
+	if err != nil {
+		t.Fatalf("read original torrent: %v", err)
+	}
+	if string(original) != "dummy" {
+		t.Fatalf("expected original torrent to remain unchanged, got %q", string(original))
+	}
+}
+
+func TestDefinitionBuildUploadDryRunUsesProvidedAssets(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "Movie.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	input := trackers.PreparationInput{
+		Intent:  trackers.PreparationIntentDryRun,
+		Tracker: "HDB",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
+			Type:        "WEBDL",
+			VideoCodec:  "HEVC",
+			ReleaseName: "My.Release.2026.2160p.WEBDL.HEVC",
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username: "user",
+			Passkey:  "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
+		Logger:  api.NopLogger{},
+		Assets: &trackers.DescriptionAssets{
+			Description: "kept description",
+			Screenshots: []api.ScreenshotImage{{
+				ImgURL: "https://t.hdbits.org/dryrun.jpg",
+				WebURL: "https://img.hdbits.org/dryrun",
+				RawURL: "https://img.hdbits.org/dryrun",
+			}},
+		},
+	}
+	plan, failure := New().Prepare(context.Background(), input)
+	if failure != nil {
+		t.Fatalf("unexpected dry-run error: %v", failure)
+	}
+	entry := plan.DryRun()
+	if !strings.Contains(entry.Description, "https://t.hdbits.org/dryrun.jpg") {
+		t.Fatalf("expected provided screenshot in dry-run description, got %q", entry.Description)
+	}
+}
+
+func TestBuildUploadFieldsSkipsTVDBForMovie(t *testing.T) {
+	fields := buildUploadFields(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE", TVDBID: 765432},
+	}, config.Config{}, 1, 5, 6, "description")
+
+	if _, ok := fields["tvdb"]; ok {
+		t.Fatalf("did not expect tvdb for movie payload")
+	}
+	if _, ok := fields["tvdb_season"]; ok {
+		t.Fatalf("did not expect tvdb_season for movie payload")
+	}
+	if _, ok := fields["tvdb_episode"]; ok {
+		t.Fatalf("did not expect tvdb_episode for movie payload")
+	}
+}
+
+func TestBuildUploadFieldsIncludesTVDBForTV(t *testing.T) {
+	fields := buildUploadFields(api.UploadSubject{
+		Identity:   api.ExternalIdentity{Category: "TV", TVDBID: 765432},
+		SeasonInt:  2,
+		EpisodeInt: 3,
+	}, config.Config{}, 2, 5, 6, "description")
+
+	if got := fields["tvdb"]; got != "765432" {
+		t.Fatalf("expected tvdb=765432, got %q", got)
+	}
+	if got := fields["tvdb_season"]; got != "2" {
+		t.Fatalf("expected tvdb_season=2, got %q", got)
+	}
+	if got := fields["tvdb_episode"]; got != "3" {
+		t.Fatalf("expected tvdb_episode=3, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/description_builder.go b/internal/trackers/impl/standalone/hdb/description_builder.go
new file mode 100644
index 00000000..2323facd
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/description_builder.go
@@ -0,0 +1,250 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	hdbImgSizedPattern = regexp.MustCompile(`(?i)\[img=\d+\]`)
+	hdbSizePattern     = regexp.MustCompile(`(?i)\[/size\]|\[size=\d+\]`)
+	hdbSpoilerPattern  = regexp.MustCompile(`(?i)\[spoiler([^\]]*)\]`)
+	hdbCompPattern     = regexp.MustCompile(`(?i)\[comparison=([^\]]+)\]([\s\S]*?)\[/comparison\]`)
+	hdbImgURLPattern   = regexp.MustCompile(`(?i)(https?://[^\s\]]+\.(?:png|jpg|jpeg|webp))`)
+	hdbURLImgPattern   = regexp.MustCompile(`(?is)\[url=(https?://[^\]]+)\]\s*\[img(?:[^\]]*)?\](https?://[^\[]+?)\[/img\]\s*\[/url\]`)
+	hdbImgBlockPattern = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\](https?://[^\[]+?)\[/img\]`)
+	hdbUARegex         = regexp.MustCompile(
+		`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`,
+	)
+	hdbEmptyWrapperTag = regexp.MustCompile(`(?is)\[(?:center|align=center)\]\s*\[/(?:center|align)\]`)
+)
+
+// BuildDescription builds HDB-compatible BBCode from retained description
+// text and resolved image assets. Disc-menu images render in their own section
+// before normal screenshots; cancellation and disc-metadata read failures are
+// returned to the caller.
+func BuildDescription(
+	ctx context.Context,
+	meta api.UploadSubject,
+	appConfig config.Config,
+	keptDescription string,
+	menuImages []api.ScreenshotImage,
+	screenshots []api.ScreenshotImage,
+) (string, error) {
+	select {
+	case <-ctx.Done():
+		return "", fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	parts := make([]string, 0, 8)
+
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" && strings.TrimSpace(keptDescription) == "" {
+		parts = append(parts, fmt.Sprintf("[center][quote]This release is sourced from %s[/quote][/center]", strings.TrimSpace(meta.ServiceLongName)))
+	}
+
+	discSection, err := buildDiscSection(meta, appConfig.MainSettings.DBPath)
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(discSection) != "" {
+		parts = append(parts, discSection)
+	}
+
+	if transformed := transformBaseDescription(keptDescription, len(menuImages) > 0 || len(screenshots) > 0); strings.TrimSpace(transformed) != "" {
+		parts = append(parts, transformed)
+	}
+
+	if len(menuImages) > 0 {
+		if header := strings.TrimSpace(appConfig.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		if section := buildScreenshotSection(menuImages, 0); section != "" {
+			parts = append(parts, section)
+		}
+	}
+
+	if section := buildScreenshotSection(screenshots, meta.Options.Screens); section != "" {
+		parts = append(parts, section)
+	}
+
+	if signature := strings.TrimSpace(appConfig.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	return normalize(strings.Join(parts, "\n\n")), nil
+}
+
+func buildDiscSection(meta api.UploadSubject, dbPath string) (string, error) {
+	if strings.TrimSpace(meta.DVDVOBMediaInfoText) != "" {
+		return "[quote=VOB MediaInfo]" + strings.TrimSpace(meta.DVDVOBMediaInfoText) + "[/quote]", nil
+	}
+
+	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return "", nil
+	}
+
+	if strings.TrimSpace(dbPath) == "" {
+		return "", nil
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("description: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("description: %w", err)
+	}
+	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists))
+	if strings.TrimSpace(path) == "" {
+		return "", nil
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", nil
+		}
+		return "", fmt.Errorf("description: HDB read MediaInfo file: %w", err)
+	}
+	trimmed := strings.TrimSpace(string(content))
+	if trimmed == "" {
+		return "", nil
+	}
+	return "[quote]" + trimmed + "[/quote]", nil
+}
+
+func transformBaseDescription(value string, stripScreens bool) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	transformed := trimmed
+	transformed = hdbUARegex.ReplaceAllString(transformed, "")
+	if stripScreens {
+		transformed = hdbURLImgPattern.ReplaceAllString(transformed, "")
+		transformed = hdbImgBlockPattern.ReplaceAllString(transformed, "")
+		transformed = hdbEmptyWrapperTag.ReplaceAllString(transformed, "")
+	}
+	transformed = strings.ReplaceAll(transformed, "[code]", "[font=monospace]")
+	transformed = strings.ReplaceAll(transformed, "[/code]", "[/font]")
+	for _, tag := range []string{"user", "left", "right", "sup", "sub", "alert", "note", "hr", "ul", "ol"} {
+		transformed = strings.ReplaceAll(transformed, "["+tag+"]", "")
+		transformed = strings.ReplaceAll(transformed, "[/"+tag+"]", "")
+	}
+	transformed = strings.ReplaceAll(transformed, "[align=left]", "")
+	transformed = strings.ReplaceAll(transformed, "[align=right]", "")
+	transformed = strings.ReplaceAll(transformed, "[/align]", "")
+	transformed = strings.ReplaceAll(transformed, "[h1]", "[u][b]")
+	transformed = strings.ReplaceAll(transformed, "[/h1]", "[/b][/u]")
+	transformed = strings.ReplaceAll(transformed, "[h2]", "[u][b]")
+	transformed = strings.ReplaceAll(transformed, "[/h2]", "[/b][/u]")
+	transformed = strings.ReplaceAll(transformed, "[h3]", "[u][b]")
+	transformed = strings.ReplaceAll(transformed, "[/h3]", "[/b][/u]")
+	transformed = strings.ReplaceAll(transformed, "[*]", "* ")
+	transformed = hdbSpoilerPattern.ReplaceAllString(transformed, "[hide$1]")
+	transformed = strings.ReplaceAll(transformed, "[/spoiler]", "[/hide]")
+	transformed = convertComparisonToCentered(transformed, 1000)
+	transformed = hdbImgSizedPattern.ReplaceAllString(transformed, "[img]")
+	transformed = hdbSizePattern.ReplaceAllString(transformed, "")
+	return normalize(transformed)
+}
+
+func convertComparisonToCentered(value string, maxWidth int) string {
+	return hdbCompPattern.ReplaceAllStringFunc(value, func(match string) string {
+		parts := hdbCompPattern.FindStringSubmatch(match)
+		if len(parts) < 3 {
+			return match
+		}
+		sourcePart := strings.TrimSpace(parts[1])
+		imagePart := strings.TrimSpace(parts[2])
+		sources := splitCSV(sourcePart)
+		if len(sources) == 0 {
+			return match
+		}
+		images := hdbImgURLPattern.FindAllString(imagePart, -1)
+		if len(images) == 0 {
+			return match
+		}
+		screensPerLine := len(sources)
+		if screensPerLine <= 0 {
+			return match
+		}
+		imgSize := min(maxWidth/screensPerLine, 350)
+		rows := make([]string, 0)
+		line := make([]string, 0, screensPerLine)
+		for _, img := range images {
+			u := strings.TrimSpace(img)
+			if u == "" {
+				continue
+			}
+			line = append(line, "[url="+u+"][img="+strconv.Itoa(imgSize)+"]"+u+"[/img][/url]")
+			if len(line) == screensPerLine {
+				rows = append(rows, strings.Join(line, ""))
+				line = line[:0]
+			}
+		}
+		return "[center]" + strings.Join(sources, " | ") + "\n" + strings.Join(rows, "\n") + "[/center]"
+	})
+}
+
+func splitCSV(value string) []string {
+	parts := strings.Split(value, ",")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed != "" {
+			out = append(out, trimmed)
+		}
+	}
+	return out
+}
+
+func buildScreenshotSection(images []api.ScreenshotImage, maxCount int) string {
+	if len(images) == 0 {
+		return ""
+	}
+	limit := len(images)
+	if maxCount > 0 && maxCount < limit {
+		limit = maxCount
+	}
+	parts := make([]string, 0, limit+2)
+	parts = append(parts, "[center]")
+	for _, image := range images[:limit] {
+		imgURL := strings.TrimSpace(image.ImgURL)
+		if imgURL == "" {
+			imgURL = strings.TrimSpace(image.RawURL)
+		}
+		webURL := strings.TrimSpace(image.WebURL)
+		if imgURL == "" {
+			continue
+		}
+		if webURL != "" {
+			parts = append(parts, "[url="+webURL+"][img]"+imgURL+"[/img][/url]")
+			continue
+		}
+		parts = append(parts, "[img]"+imgURL+"[/img]")
+	}
+	parts = append(parts, "[/center]")
+	return strings.Join(parts, "")
+}
+
+func normalize(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	re := regexp.MustCompile(`\n{3,}`)
+	return strings.TrimSpace(re.ReplaceAllString(trimmed, "\n\n"))
+}
diff --git a/internal/trackers/impl/standalone/hdb/description_builder_test.go b/internal/trackers/impl/standalone/hdb/description_builder_test.go
new file mode 100644
index 00000000..379bf2c1
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/description_builder_test.go
@@ -0,0 +1,143 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionAddsWebDLSource(t *testing.T) {
+	meta := api.UploadSubject{
+		Type:            "WEBDL",
+		ServiceLongName: "Netflix",
+	}
+	description, err := BuildDescription(context.Background(), meta, config.Config{}, "", nil, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(description, "This release is sourced from Netflix") {
+		t.Fatalf("expected web source quote, got %q", description)
+	}
+}
+
+func TestBuildDescriptionTransformsBaseAndAddsScreens(t *testing.T) {
+	meta := api.UploadSubject{
+		Options: api.UploadOptions{Screens: 1},
+	}
+	base := "[code]x[/code]\n[spoiler=Comp][comparison=A, B]https://img/a.jpg https://img/b.jpg[/comparison][/spoiler]\n[size=3][img=300]https://img/x.jpg[/img][/size]"
+	screens := []api.ScreenshotImage{{ImgURL: "https://img/s1.jpg", WebURL: "https://web/s1"}, {ImgURL: "https://img/s2.jpg"}}
+
+	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(description, "[font=monospace]x[/font]") {
+		t.Fatalf("expected code tag conversion, got %q", description)
+	}
+	if !strings.Contains(description, "[hide=Comp]") {
+		t.Fatalf("expected spoiler-to-hide conversion, got %q", description)
+	}
+	if !strings.Contains(description, "[center][url=https://web/s1][img]https://img/s1.jpg[/img][/url][/center]") {
+		t.Fatalf("expected screenshot section with one image due to limit, got %q", description)
+	}
+	if strings.Contains(description, "https://img/s2.jpg") {
+		t.Fatalf("expected second screenshot omitted by limit, got %q", description)
+	}
+}
+
+func TestBuildDescriptionAddsRehostedMenuImagesSeparately(t *testing.T) {
+	menuImages := []api.ScreenshotImage{{
+		Purpose: api.ScreenshotPurposeMenu,
+		ImgURL:  "https://t.hdbits.org/menu.jpg",
+		WebURL:  "https://img.hdbits.org/menu",
+	}}
+	screens := []api.ScreenshotImage{{
+		Purpose: api.ScreenshotPurposeFinal,
+		ImgURL:  "https://t.hdbits.org/screen.jpg",
+		WebURL:  "https://img.hdbits.org/screen",
+	}}
+	appConfig := config.Config{Description: config.DescriptionSettingsConfig{DiscMenuHeader: "[b]Disc menu[/b]"}}
+
+	description, err := BuildDescription(context.Background(), api.UploadSubject{}, appConfig, "", menuImages, screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	menuPos := strings.Index(description, "https://t.hdbits.org/menu.jpg")
+	screenPos := strings.Index(description, "https://t.hdbits.org/screen.jpg")
+	if menuPos < 0 || screenPos < 0 {
+		t.Fatalf("expected menu and screenshot sections, got %q", description)
+	}
+	if !strings.Contains(description, "[b]Disc menu[/b]") {
+		t.Fatalf("expected disc menu header, got %q", description)
+	}
+	if menuPos >= screenPos {
+		t.Fatalf("expected menu before screenshots, got %q", description)
+	}
+}
+
+func TestBuildDescriptionReplacesExistingScreenshotBlock(t *testing.T) {
+	meta := api.UploadSubject{
+		Options: api.UploadOptions{Screens: 4},
+	}
+	base := `[align=center]
+[url=https://pixhost.to/8ca234.png][img width=350]https://pixhost.to/8ca234.png[/img][/url]
+[url=https://pixhost.to/4oh0bz.png][img width=350]https://pixhost.to/4oh0bz.png[/img][/url]
+[/align]
+
+[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
+	screens := []api.ScreenshotImage{
+		{
+			ImgURL: "https://t.hdbits.org/51q8jo2.jpg",
+			RawURL: "https://img.hdbits.org/51q8jo2.jpg",
+			WebURL: "https://img.hdbits.org/51q8jo2",
+		},
+		{
+			ImgURL: "https://t.hdbits.org/w0S7ltI.jpg",
+			RawURL: "https://img.hdbits.org/w0S7ltI.jpg",
+			WebURL: "https://img.hdbits.org/w0S7ltI",
+		},
+	}
+
+	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(description, "pixhost.to/8ca234.png") || strings.Contains(description, "pixhost.to/4oh0bz.png") {
+		t.Fatalf("expected old screenshot block to be removed, got %q", description)
+	}
+	if count := strings.Count(description, "[center][url=https://img.hdbits.org/"); count != 1 {
+		t.Fatalf("expected one rebuilt screenshot section, got %d in %q", count, description)
+	}
+	if !strings.Contains(description, "img.hdbits.org/51q8jo2") || !strings.Contains(description, "img.hdbits.org/w0S7ltI") {
+		t.Fatalf("expected new HDB screenshots, got %q", description)
+	}
+}
+
+func TestBuildDescriptionPreservesExistingScreensWhenNoNewScreensProvided(t *testing.T) {
+	meta := api.UploadSubject{
+		Options: api.UploadOptions{Screens: 4},
+	}
+	base := `[align=center]
+[url=https://pixhost.to/8ca234.png][img width=350]https://pixhost.to/8ca234.png[/img][/url]
+[url=https://pixhost.to/4oh0bz.png][img width=350]https://pixhost.to/4oh0bz.png[/img][/url]
+[/align]
+
+[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
+
+	description, err := BuildDescription(context.Background(), meta, config.Config{}, base, nil, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(description, "pixhost.to/8ca234.png") || !strings.Contains(description, "pixhost.to/4oh0bz.png") {
+		t.Fatalf("expected existing screenshot block preserved, got %q", description)
+	}
+	if strings.Contains(description, "upbrr") {
+		t.Fatalf("expected default signature removed, got %q", description)
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/dupe.go b/internal/trackers/impl/standalone/hdb/dupe.go
new file mode 100644
index 00000000..f6e06f56
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/dupe.go
@@ -0,0 +1,256 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	logger   api.Logger
+	endpoint string
+}
+
+// newDuplicateAdapterAt returns a duplicate-search adapter bound to one
+// immutable dependency set and tracker base URL.
+func newDuplicateAdapterAt(deps dupe.Dependencies, baseURL string) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		logger:   logger,
+		endpoint: strings.TrimRight(baseURL, "/") + "/api/torrents",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if s.http == nil {
+		return dupe.Failed(dupe.FailureInternal, "HDB handler misconfigured: no HTTP client", nil)
+	}
+	username, passkey := hdbCredentials(s.cfg)
+	if username == "" || passkey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing username/passkey for tracker", nil)
+	}
+	payload := map[string]any{
+		"username": username,
+		"passkey":  passkey,
+		"category": hdbDupeCategoryID(meta),
+		"codec":    hdbDupeCodecID(meta),
+		"medium":   hdbDupeMediumID(meta),
+	}
+	searchMethod := "id"
+	if meta.Identity.IMDBID != 0 {
+		payload["imdb"] = map[string]any{"id": fmt.Sprintf("%07d", meta.Identity.IMDBID)}
+	} else if isHDBDupeTVCategory(meta) && meta.Identity.TVDBID != 0 {
+		payload["tvdb"] = map[string]any{"id": meta.Identity.TVDBID}
+	}
+	if _, hasIMDB := payload["imdb"]; !hasIMDB {
+		if _, hasTVDB := payload["tvdb"]; !hasTVDB {
+			query := firstHDBText(meta.ReleaseName, meta.Filename, meta.Release.Title)
+			if query == "" {
+				s.logger.Warnf("dupechecking: HDB missing imdb/tvdb IDs and search text for %s", meta.SourcePath)
+				return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb/tvdb id for HDB dupe search", nil)
+			}
+			payload["search"], searchMethod = query, "text_fallback"
+			s.logger.Debugf("dupechecking: HDB falling back to text search for %s", meta.SourcePath)
+		}
+	}
+	if logPayload, err := json.Marshal(redaction.RedactPrivateInfo(payload, nil)); err != nil {
+		s.logger.Debugf("dupechecking: HDB search payload_marshal_failed=%v source=%s", err, meta.SourcePath)
+	} else {
+		s.logger.Debugf("dupechecking: HDB search payload=%s source=%s", string(logPayload), meta.SourcePath)
+	}
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "HDB request failed", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.endpoint, bytes.NewReader(raw))
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "HDB request failed", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		s.logger.Warnf("dupechecking: HDB request failed for %s: %v", meta.SourcePath, err)
+		return dupe.Failed(dupe.FailureRequest, "HDB request failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		s.logger.Warnf("dupechecking: HDB search failed for %s with status=%d", meta.SourcePath, resp.StatusCode)
+		return dupe.Failed(dupe.FailureResponseStatus, "HDB search failed", nil)
+	}
+	var body map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&body); err != nil || len(body) == 0 {
+		return dupe.Failed(dupe.FailureResponseParse, "HDB search failed", err)
+	}
+	if hdbInt(body["status"]) != 0 {
+		s.logger.Warnf("dupechecking: HDB API rejected search for %s", meta.SourcePath)
+		return dupe.Failed(dupe.FailureResponseStatus, "HDB api rejected search", nil)
+	}
+	items, _ := body["data"].([]any)
+	entries := make([]api.DupeEntry, 0, len(items))
+	for _, rawItem := range items {
+		item, ok := rawItem.(map[string]any)
+		if !ok {
+			continue
+		}
+		id, filename := hdbString(item["id"]), hdbString(item["filename"])
+		entry := api.DupeEntry{
+			Name:      hdbString(item["name"]),
+			ID:        id,
+			Link:      "https://hdbits.org/details.php?id=" + id,
+			Download:  "https://hdbits.org/download.php/" + url.QueryEscape(filename) + "?id=" + id + "&passkey=" + passkey,
+			FileCount: hdbInt(item["numfiles"]),
+		}
+		if size := hdbInt(item["size"]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, int64(size)
+		}
+		entries = append(entries, entry)
+	}
+	s.logger.Debugf("dupechecking: HDB returned %d entries for %s method=%s", len(entries), meta.SourcePath, searchMethod)
+	return dupe.Resolved(entries, nil)
+}
+
+func firstHDBText(values ...string) string {
+	for _, value := range values {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
+
+func isHDBDupeTVCategory(meta api.DuplicateSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func hdbDupeCategoryID(meta api.DuplicateSubject) int {
+	category, _ := meta.Identity.RequireCategory()
+	switch category {
+	case api.CanonicalCategoryMovie:
+		return 1
+	case api.CanonicalCategoryTV:
+		return 2
+	case api.CanonicalCategoryUnknown:
+	}
+	genres, keywords := "", ""
+	if meta.ProviderMetadata.TMDB != nil {
+		genres = strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres))
+		keywords = strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords))
+	}
+	if strings.Contains(genres, "documentary") || strings.Contains(keywords, "documentary") {
+		return 3
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		imdbType := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.IMDB.Type))
+		imdbGenres := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres))
+		if strings.Contains(imdbType, "concert") || (strings.Contains(imdbType, "video") && strings.Contains(imdbGenres, "music")) {
+			return 4
+		}
+	}
+	return 0
+}
+
+func hdbDupeCodecID(meta api.DuplicateSubject) int {
+	codec := strings.ToUpper(strings.TrimSpace(meta.VideoCodec))
+	if codec == "" {
+		codec = strings.ToUpper(strings.TrimSpace(meta.VideoEncode))
+	}
+	switch codec {
+	case "AVC", "H.264":
+		return 1
+	case "MPEG-2":
+		return 2
+	case "VC-1":
+		return 3
+	case "XVID":
+		return 4
+	case "HEVC", "H.265":
+		return 5
+	case "VP9":
+		return 6
+	default:
+		return 0
+	}
+}
+
+func hdbDupeMediumID(meta api.DuplicateSubject) int {
+	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
+	contentType := resolveHDBDupeType(meta)
+	if discType == "BDMV" || discType == "HD DVD" {
+		return 1
+	}
+	if contentType == "HDTV" {
+		if meta.HasEncodeSettings {
+			return 3
+		}
+		return 4
+	}
+	switch contentType {
+	case "ENCODE", "WEBRIP":
+		return 3
+	case "REMUX":
+		return 5
+	case "WEBDL":
+		return 6
+	default:
+		return 0
+	}
+}
+
+func resolveHDBDupeType(meta api.DuplicateSubject) string {
+	typeValue := normalizeHDBType(meta.Type)
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if meta.ReleaseNameOverrides.Type != nil {
+			typeValue = normalizeHDBType(*meta.ReleaseNameOverrides.Type)
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = normalizeHDBType(meta.Release.Type)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.DiscType) != "" {
+			typeValue = "DISC"
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = inferHDBTypeFromSource(meta.Source)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = inferHDBTypeFromPath(meta.SourcePath)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.VideoEncode) != "" {
+			typeValue = "ENCODE"
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.VideoCodec) != "" || strings.TrimSpace(meta.Release.Resolution) != "" || strings.TrimSpace(meta.Release.Ext) != "" {
+			typeValue = "ENCODE"
+		}
+	}
+	return typeValue
+}
diff --git a/internal/trackers/impl/standalone/hdb/dupe_integration_test.go b/internal/trackers/impl/standalone/hdb/dupe_integration_test.go
new file mode 100644
index 00000000..adeaf0bd
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/dupe_integration_test.go
@@ -0,0 +1,418 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+type hdbRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f hdbRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
+
+func hdbTestInt(value any) int64 {
+	switch typed := value.(type) {
+	case float64:
+		return int64(typed)
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
+
+func hdbTestString(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+
+func TestHDBHandlerSearchBuildsPayloadAndParsesResults(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+
+	client := &http.Client{
+		Transport: hdbRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			if req.Method != http.MethodPost {
+				t.Fatalf("expected POST request, got %s", req.Method)
+			}
+			if req.URL.String() != "https://hdbits.org/api/torrents" {
+				t.Fatalf("unexpected endpoint %q", req.URL.String())
+			}
+
+			var payload map[string]any
+			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+				t.Fatalf("decode request payload: %v", err)
+			}
+			if got := hdbTestString(payload["username"]); got != "user" {
+				t.Fatalf("unexpected username %q", got)
+			}
+			if got := hdbTestString(payload["passkey"]); got != "pk" {
+				t.Fatalf("unexpected passkey %q", got)
+			}
+			if got := hdbTestInt(payload["category"]); got != 1 {
+				t.Fatalf("unexpected category %d", got)
+			}
+			if got := hdbTestInt(payload["codec"]); got != 5 {
+				t.Fatalf("unexpected codec %d", got)
+			}
+			if got := hdbTestInt(payload["medium"]); got != 6 {
+				t.Fatalf("unexpected medium %d", got)
+			}
+			imdb, ok := payload["imdb"].(map[string]any)
+			if !ok || hdbTestString(imdb["id"]) != "1234567" {
+				t.Fatalf("unexpected imdb payload %#v", payload["imdb"])
+			}
+			if _, hasTVDB := payload["tvdb"]; hasTVDB {
+				t.Fatalf("did not expect tvdb payload when imdb is present")
+			}
+
+			body := `{"status":0,"data":[{"id":42,"name":"Movie.Title.2024.1080p.WEB-DL.DDP5.1.H.265-GRP","filename":"Movie Title (2024).torrent","size":1234567890,"numfiles":3}]}`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "HDB",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{
+				DBPath: filepath.Join(tmpDir, "ua.db"),
+			},
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"HDB": {
+						Username: "user",
+						Passkey:  "pk",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		SourcePath: "C:/media/movie",
+		Identity: api.ExternalIdentity{
+			IMDBID:   1234567,
+			TVDBID:   765432,
+			Category: "MOVIE",
+		},
+		VideoCodec: "HEVC",
+		Type:       "WEBDL",
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected one entry, got %d", len(entries))
+	}
+
+	entry := entries[0]
+	if entry.Name != "Movie.Title.2024.1080p.WEB-DL.DDP5.1.H.265-GRP" {
+		t.Fatalf("expected entry name from 'name', got %q", entry.Name)
+	}
+	if entry.ID != "42" {
+		t.Fatalf("unexpected id %q", entry.ID)
+	}
+	if entry.Link != "https://hdbits.org/details.php?id=42" {
+		t.Fatalf("unexpected link %q", entry.Link)
+	}
+	if entry.Download != "https://hdbits.org/download.php/Movie+Title+%282024%29.torrent?id=42&passkey=pk" {
+		t.Fatalf("unexpected download %q", entry.Download)
+	}
+	if !entry.SizeKnown || entry.SizeBytes != 1234567890 {
+		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
+	}
+	if entry.FileCount != 3 {
+		t.Fatalf("unexpected file count %d", entry.FileCount)
+	}
+}
+
+func TestHDBHandlerSearchFallsBackToTextSearchWhenIDsMissing(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+
+	client := &http.Client{
+		Transport: hdbRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			var payload map[string]any
+			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+				t.Fatalf("decode request payload: %v", err)
+			}
+			if _, hasIMDB := payload["imdb"]; hasIMDB {
+				t.Fatalf("did not expect imdb in payload")
+			}
+			if _, hasTVDB := payload["tvdb"]; hasTVDB {
+				t.Fatalf("did not expect tvdb in payload")
+			}
+			if got := hdbTestString(payload["search"]); got != "Some.Release.Name.2024.1080p.WEB-DL" {
+				t.Fatalf("unexpected fallback search %q", got)
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "HDB",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{
+				DBPath: filepath.Join(tmpDir, "ua.db"),
+			},
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"HDB": {
+						Username: "user",
+						Passkey:  "pk",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		SourcePath:  "C:/media/no-ids",
+		ReleaseName: "Some.Release.Name.2024.1080p.WEB-DL",
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+func TestHDBHandlerSearchUsesTVDBWhenIMDbMissing(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+
+	client := &http.Client{
+		Transport: hdbRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			var payload map[string]any
+			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+				t.Fatalf("decode request payload: %v", err)
+			}
+
+			if _, hasIMDB := payload["imdb"]; hasIMDB {
+				t.Fatalf("did not expect imdb in payload")
+			}
+			tvdb, ok := payload["tvdb"].(map[string]any)
+			if !ok || hdbTestInt(tvdb["id"]) != 765432 {
+				t.Fatalf("unexpected tvdb payload %#v", payload["tvdb"])
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "HDB",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{
+				DBPath: filepath.Join(tmpDir, "ua.db"),
+			},
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"HDB": {
+						Username: "user",
+						Passkey:  "pk",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		SourcePath: "C:/media/show",
+		Identity: api.ExternalIdentity{
+			TVDBID:   765432,
+			Category: "TV",
+		},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+func TestHDBHandlerSearchSkipsTVDBForMovie(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+
+	client := &http.Client{
+		Transport: hdbRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			var payload map[string]any
+			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+				t.Fatalf("decode request payload: %v", err)
+			}
+			if _, hasTVDB := payload["tvdb"]; hasTVDB {
+				t.Fatalf("did not expect tvdb in movie payload")
+			}
+			if got := hdbTestString(payload["search"]); got != "Movie.Release.2024.1080p.WEB-DL" {
+				t.Fatalf("unexpected fallback search %q", got)
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "HDB",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{
+				DBPath: filepath.Join(tmpDir, "ua.db"),
+			},
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"HDB": {
+						Username: "user",
+						Passkey:  "pk",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		SourcePath:  "C:/media/movie",
+		ReleaseName: "Movie.Release.2024.1080p.WEB-DL",
+		Identity: api.ExternalIdentity{
+			TVDBID:   765432,
+			Category: "MOVIE",
+		},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+func TestHDBHandlerSearchIncludesZeroValuedFilters(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+
+	client := &http.Client{
+		Transport: hdbRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			var payload map[string]any
+			if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+				t.Fatalf("decode request payload: %v", err)
+			}
+
+			category, hasCategory := payload["category"]
+			if !hasCategory {
+				t.Fatalf("expected category key to be present")
+			}
+			if got := hdbTestInt(category); got != 0 {
+				t.Fatalf("expected category 0, got %d", got)
+			}
+
+			codec, hasCodec := payload["codec"]
+			if !hasCodec {
+				t.Fatalf("expected codec key to be present")
+			}
+			if got := hdbTestInt(codec); got != 0 {
+				t.Fatalf("expected codec 0, got %d", got)
+			}
+
+			medium, hasMedium := payload["medium"]
+			if !hasMedium {
+				t.Fatalf("expected medium key to be present")
+			}
+			if got := hdbTestInt(medium); got != 0 {
+				t.Fatalf("expected medium 0, got %d", got)
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(`{"status":0,"data":[]}`)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "HDB",
+		config.Config{
+			MainSettings: config.MainSettingsConfig{
+				DBPath: filepath.Join(tmpDir, "ua.db"),
+			},
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"HDB": {
+						Username: "user",
+						Passkey:  "pk",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		SourcePath:  "C:/media/zero-filters",
+		ReleaseName: "Unknown.Release.2024",
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/dupe_test.go b/internal/trackers/impl/standalone/hdb/dupe_test.go
new file mode 100644
index 00000000..2acf21aa
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/dupe_test.go
@@ -0,0 +1,79 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestHDBMediumIDTypePrecedence(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name string
+		meta api.DuplicateSubject
+		want int
+	}{
+		{
+			name: "metadata type takes precedence",
+			meta: api.DuplicateSubject{
+				Type:                 "WEBDL",
+				ReleaseNameOverrides: api.ReleaseNameOverrides{Type: new("WEBRIP")},
+				Release:              api.ReleaseInfo{Type: "REMUX"},
+			},
+			want: 6,
+		},
+		{
+			name: "falls back to override type",
+			meta: api.DuplicateSubject{ReleaseNameOverrides: api.ReleaseNameOverrides{Type: new("WEBRIP")}, Release: api.ReleaseInfo{Type: "REMUX"}},
+			want: 3,
+		},
+		{
+			name: "falls back to release type",
+			meta: api.DuplicateSubject{Release: api.ReleaseInfo{Type: "REMUX"}},
+			want: 5,
+		},
+		{
+			name: "disc type takes precedence",
+			meta: api.DuplicateSubject{
+				DiscType:             "BDMV",
+				Type:                 "WEBDL",
+				ReleaseNameOverrides: api.ReleaseNameOverrides{Type: new("WEBRIP")},
+				Release:              api.ReleaseInfo{Type: "REMUX"},
+			},
+			want: 1,
+		},
+		{
+			name: "hdtv with encode settings maps to encode medium",
+			meta: api.DuplicateSubject{Type: "HDTV", HasEncodeSettings: true},
+			want: 3,
+		},
+		{
+			name: "category type infers encode medium from metadata",
+			meta: api.DuplicateSubject{
+				Type:       "movie",
+				Source:     "BluRay",
+				VideoCodec: "AVC",
+				Release:    api.ReleaseInfo{Resolution: "1080p"},
+			},
+			want: 3,
+		},
+		{
+			name: "category type uses source hint for webdl medium",
+			meta: api.DuplicateSubject{Type: "movie", Source: "Web-DL"},
+			want: 6,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			if got := hdbDupeMediumID(tc.meta); got != tc.want {
+				t.Fatalf("hdbDupeMediumID() = %d, want %d", got, tc.want)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdb/profile.go b/internal/trackers/impl/standalone/hdb/profile.go
new file mode 100644
index 00000000..5b52dbae
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/profile.go
@@ -0,0 +1,80 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns HDB identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:               "HDB",
+		BaseURL:            hdbBaseURL,
+		DescriptionGroup:   "hdb",
+		UploadContentMode:  trackers.UploadContentModeDescription,
+		PrepareDescription: prepareDescription,
+		PrepareUpload: func(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return prepareUploadAt(ctx, req, hdbBaseURL, nil)
+		},
+		NewDuplicateAdapter: func(deps dupe.Dependencies) dupe.Adapter { return newDuplicateAdapterAt(deps, hdbBaseURL) },
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{
+				{
+					Scope:       trackers.MetadataScopeMovie,
+					AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDBIDOnly},
+					Disposition: api.RuleDispositionStrict,
+				},
+				{
+					Scope:       trackers.MetadataScopeTV,
+					AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDBIDOnly, trackers.MetadataFieldTVDBIDOnly},
+					Disposition: api.RuleDispositionStrict,
+				},
+			},
+		},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "HDBits"},
+		ArtifactPolicy:       &trackers.ArtifactPolicy{MaxPieceSizeMiB: 16},
+		ImageHostPolicy: &trackers.ImageHostPolicy{
+			AllowedHosts:         []string{"hdb"},
+			OwnedHosts:           []string{"hdb"},
+			DisableWithoutRehost: true,
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"https://tracker.hdbits.org"},
+			CommentURLPatterns: []string{hdbBaseURL},
+			DetailIDPattern:    "id=(\\d+)",
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:          "HDB",
+			DisplayName:        "HDB",
+			AuthKind:           "passkey_cookies",
+			SupportsCookieFile: true,
+			RequiresPasskey:    true,
+		},
+		AuthPolicy: &trackers.AuthPolicy{PasskeyRequiresUsername: true, PasskeyRequiresCookie: true},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, request api.TrackerAuthLoginRequest) error {
+			return resolveAuthSessionAt(ctx, cfg, dbPath, request, hdbBaseURL, nil)
+		},
+	}
+}
+
+// Definition extends the shared standalone definition with HDB data lookup and testable endpoints.
+type Definition struct {
+	*standalone.Definition
+	baseURL    string
+	httpClient *http.Client
+}
+
+// New returns a fresh HDB definition from its tracker-local profile.
+func New() *Definition {
+	return &Definition{Definition: standalone.MustNew(Profile()), baseURL: hdbBaseURL}
+}
diff --git a/internal/trackers/impl/standalone/hdb/upload.go b/internal/trackers/impl/standalone/hdb/upload.go
new file mode 100644
index 00000000..be18273e
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdb/upload.go
@@ -0,0 +1,621 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdb
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	hdbBaseURL    = "https://hdbits.org"
+	hdbUploadPath = "/upload/upload"
+)
+
+var hdbSuccessURLPattern = regexp.MustCompile(`(?i)details\.php\?id=(\d+)&uploaded=\d+`)
+
+type preparedUploadState struct {
+	torrentPath string
+	description string
+	fields      map[string]string
+	uploadURL   string
+	cookies     []*http.Cookie
+	body        []byte
+	contentType string
+	passkey     string
+	client      *http.Client
+}
+
+func uploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string, httpClient *http.Client) (api.UploadSummary, error) {
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, baseURL, httpClient)
+	})
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDB submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUploadAt(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	baseURL string,
+	httpClient *http.Client,
+) (trackers.PreparedOperation, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.PreparedOperation{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	username := strings.TrimSpace(req.TrackerConfig.Username)
+	passkey := strings.TrimSpace(req.TrackerConfig.Passkey)
+	if username == "" || passkey == "" {
+		return trackers.PreparedOperation{}, errors.New("trackers: HDB missing username/passkey")
+	}
+
+	category := hdbCategoryID(req.Meta)
+	codec := hdbCodecID(req.Meta)
+	medium := hdbMediumID(req.Meta)
+	if category == 0 || codec == 0 || medium == 0 {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: HDB mapping failed category=%d codec=%d medium=%d", category, codec, medium)
+	}
+
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: HDB description assets: %w", err)
+		}
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	descriptionText := strings.TrimSpace(assets.Description)
+	if !assets.Final {
+		descriptionText, err = BuildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets.Description, assets.MenuImages, assets.Screenshots)
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	uploadURL := strings.TrimRight(baseURL, "/")
+	uploadURL += hdbUploadPath
+
+	fields := buildUploadFields(req.Meta, req.Runtime.DescriptionConfig(), category, codec, medium, descriptionText)
+	preview := standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "HDB",
+		ReleaseName:      resolveUploadName(req.Meta),
+		DescriptionGroup: "hdb",
+		Description:      descriptionText,
+		Endpoint:         uploadURL,
+		Payload:          fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    torrentPath,
+			Present: strings.TrimSpace(torrentPath) != "",
+		}},
+	})
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	cookies, err := resolveHDBCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	body, contentType, err := buildMultipartPayload(fields, torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	client := httpClient
+	if client == nil {
+		client = &http.Client{Timeout: 40 * time.Second}
+	}
+	state := preparedUploadState{
+		torrentPath: torrentPath,
+		description: descriptionText,
+		fields:      fields,
+		uploadURL:   uploadURL,
+		cookies:     cookies,
+		body:        body,
+		contentType: contentType,
+		passkey:     passkey,
+		client:      client,
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state)
+	}, nil), nil
+}
+
+func submitPreparedUpload(ctx context.Context, req trackers.PreparationInput, state preparedUploadState) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.uploadURL, bytes.NewReader(state.body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDB request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", state.contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	for _, cookie := range state.cookies {
+		httpReq.AddCookie(cookie)
+	}
+
+	resp, err := state.client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDB upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	matches := hdbSuccessURLPattern.FindStringSubmatch(finalURL)
+	if len(matches) < 2 {
+		bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+		return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("HDB", resp.StatusCode, finalURL, bodyPreview)
+	}
+
+	torrentID := strings.TrimSpace(matches[1])
+	trackerTorrentPath := ""
+	if torrentID != "" {
+		trackerTorrentPath, err = resolveTrackerTorrentPath(req.Meta, req.Runtime.DBPath, "HDB")
+		if err != nil {
+			return api.UploadSummary{}, err
+		}
+		if err := downloadPersonalizedTorrent(
+			ctx,
+			state.client,
+			state.uploadURL,
+			req.Meta,
+			trackerTorrentPath,
+			torrentID,
+			state.passkey,
+			state.cookies,
+		); err != nil &&
+			req.Logger != nil {
+			req.Logger.Warnf("trackers: HDB torrent redownload failed: %v", err)
+		}
+	}
+
+	downloadURL := buildHDBDownloadURL(state.uploadURL, req.Meta, torrentID, state.passkey)
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "HDB",
+			TorrentID:   torrentID,
+			DownloadURL: downloadURL,
+			TorrentPath: trackerTorrentPath,
+		}},
+	}, nil
+}
+
+func buildUploadFields(meta api.UploadSubject, appConfig config.Config, categoryID int, codecID int, mediumID int, description string) map[string]string {
+	fields := map[string]string{
+		"name":     resolveUploadName(meta),
+		"category": strconv.Itoa(categoryID),
+		"codec":    strconv.Itoa(codecID),
+		"medium":   strconv.Itoa(mediumID),
+		"origin":   "0",
+		"descr":    strings.TrimSpace(description),
+		"techinfo": "",
+	}
+
+	if trackers.IsInternalGroup(appConfig, "HDB", meta) {
+		fields["origin"] = "1"
+	}
+
+	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		if strings.TrimSpace(meta.MediaInfoTextPath) != "" {
+			content, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+			if err == nil {
+				fields["techinfo"] = strings.TrimSpace(string(content))
+			}
+		}
+	}
+
+	if isHDBTVCategory(meta) && meta.Identity.TVDBID != 0 {
+		fields["tvdb"] = strconv.Itoa(meta.Identity.TVDBID)
+	}
+	if imdb := resolveIMDbURL(meta); imdb != "" {
+		fields["imdb"] = imdb
+	} else {
+		fields["imdb"] = "0"
+	}
+	if isHDBTVCategory(meta) {
+		season := meta.SeasonInt
+		episode := meta.EpisodeInt
+		if season <= 0 {
+			season = 1
+		}
+		if episode <= 0 {
+			episode = 1
+		}
+		fields["tvdb_season"] = strconv.Itoa(season)
+		fields["tvdb_episode"] = strconv.Itoa(episode)
+	}
+
+	return fields
+}
+
+// isHDBTVCategory reports whether HDB upload payloads may include TVDB fields.
+// Canonical movie identity suppresses TVDB fields even when episode facts exist.
+func isHDBTVCategory(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.Filename); name != "" {
+		return name
+	}
+	return pathutil.Base(meta.SourcePath)
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		if value := strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL); value != "" {
+			if !strings.HasSuffix(value, "/") {
+				return value + "/"
+			}
+			return value
+		}
+	}
+	if meta.Identity.IMDBID != 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: HDB write multipart field %q: %w", key, err)
+		}
+	}
+
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: HDB open torrent file: %w", err)
+	}
+	defer file.Close()
+
+	part, err := writer.CreateFormFile("file", filepath.Base(torrentPath))
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: HDB create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: HDB copy torrent file: %w", err)
+	}
+
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: HDB close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
+	candidates := []string{
+		strings.TrimSpace(meta.TorrentPath),
+		strings.TrimSpace(meta.ClientTorrentPath),
+		strings.TrimSpace(meta.SourcePath),
+	}
+	for _, candidate := range candidates {
+		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
+			continue
+		}
+		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+			return candidate, nil
+		}
+	}
+
+	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
+		tmpRoot, err := db.Subdir(dbPath, "tmp")
+		if err == nil {
+			tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+			if err == nil {
+				guessed := filepath.Join(tmpDir, base+".torrent")
+				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
+					return guessed, nil
+				}
+			}
+		}
+	}
+
+	return "", errors.New("trackers: HDB torrent file not found")
+}
+
+func resolveTrackerTorrentPath(meta api.UploadSubject, dbPath string, tracker string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return "", errors.New("trackers: HDB tracker torrent path requires db path and source path")
+	}
+
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: HDB tmp root: %w", err)
+	}
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: HDB tmp release dir: %w", err)
+	}
+	name := strings.ToLower(strings.TrimSpace(tracker))
+	name = strings.NewReplacer("/", "-", "\\", "-", " ", "-").Replace(name)
+	if name == "" {
+		name = "tracker"
+	}
+	return filepath.Join(tmpDir, base+"."+name+".torrent"), nil
+}
+
+func resolveHDBCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookiepkg.LoadTrackerHTTPCookies(ctx, dbPath, "HDB", "hdbits.org")
+	if err != nil {
+		return values, fmt.Errorf("trackers: HDB load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func downloadPersonalizedTorrent(
+	ctx context.Context,
+	client *http.Client,
+	uploadURL string,
+	meta api.UploadSubject,
+	torrentPath string,
+	torrentID string,
+	passkey string,
+	cookies []*http.Cookie,
+) error {
+	downloadURL := buildHDBDownloadURL(uploadURL, meta, torrentID, passkey)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("trackers: HDB create personalized torrent request: %w", err)
+	}
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("trackers: HDB download personalized torrent: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("status %d", resp.StatusCode)
+	}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("trackers: HDB read personalized torrent response: %w", err)
+	}
+	if len(body) == 0 {
+		return errors.New("empty torrent response")
+	}
+	if err := os.MkdirAll(filepath.Dir(torrentPath), 0o700); err != nil {
+		return fmt.Errorf("trackers: HDB create torrent output dir: %w", err)
+	}
+	if err := os.WriteFile(torrentPath, body, 0o600); err != nil {
+		return fmt.Errorf("trackers: HDB write torrent output: %w", err)
+	}
+	return nil
+}
+
+func buildHDBDownloadURL(uploadURL string, meta api.UploadSubject, torrentID string, passkey string) string {
+	if strings.TrimSpace(torrentID) == "" || strings.TrimSpace(passkey) == "" {
+		return ""
+	}
+	base := strings.TrimSuffix(uploadURL, hdbUploadPath)
+	filePart := pathutil.Base(meta.SourcePath)
+	if filePart == "" || filePart == "." || filePart == string(filepath.Separator) {
+		filePart = "download"
+	}
+	return fmt.Sprintf(
+		"%s/download.php/%s?id=%s&passkey=%s",
+		strings.TrimRight(base, "/"),
+		url.PathEscape(filePart),
+		url.QueryEscape(torrentID),
+		url.QueryEscape(passkey),
+	)
+}
+
+func hdbCategoryID(meta api.UploadSubject) int {
+	category, _ := meta.Identity.RequireCategory()
+	switch category {
+	case api.CanonicalCategoryMovie:
+		return 1
+	case api.CanonicalCategoryTV:
+		return 2
+	case api.CanonicalCategoryUnknown:
+	}
+	genres := ""
+	keywords := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		genres = strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres))
+		keywords = strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords))
+	}
+	if strings.Contains(genres, "documentary") || strings.Contains(keywords, "documentary") {
+		return 3
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		imdbType := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.IMDB.Type))
+		imdbGenres := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres))
+		if strings.Contains(imdbType, "concert") || (strings.Contains(imdbType, "video") && strings.Contains(imdbGenres, "music")) {
+			return 4
+		}
+	}
+	return 0
+}
+
+func hdbCodecID(meta api.UploadSubject) int {
+	codec := strings.ToUpper(strings.TrimSpace(meta.VideoCodec))
+	if codec == "" {
+		codec = strings.ToUpper(strings.TrimSpace(meta.VideoEncode))
+	}
+	switch codec {
+	case "AVC", "H.264":
+		return 1
+	case "MPEG-2":
+		return 2
+	case "VC-1":
+		return 3
+	case "XVID":
+		return 4
+	case "HEVC", "H.265":
+		return 5
+	case "VP9":
+		return 6
+	default:
+		return 0
+	}
+}
+
+func hdbMediumID(meta api.UploadSubject) int {
+	discType := strings.ToUpper(strings.TrimSpace(meta.DiscType))
+	contentType := resolveHDBType(meta)
+	if discType == "BDMV" || discType == "HD DVD" {
+		return 1
+	}
+	if contentType == "HDTV" {
+		if meta.HasEncodeSettings {
+			return 3
+		}
+		return 4
+	}
+	switch contentType {
+	case "ENCODE", "WEBRIP":
+		return 3
+	case "REMUX":
+		return 5
+	case "WEBDL":
+		return 6
+	default:
+		return 0
+	}
+}
+
+func resolveHDBType(meta api.UploadSubject) string {
+	typeValue := normalizeHDBType(meta.Type)
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if meta.ReleaseNameOverrides.Type != nil {
+			typeValue = normalizeHDBType(*meta.ReleaseNameOverrides.Type)
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = normalizeHDBType(meta.Release.Type)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.DiscType) != "" {
+			typeValue = "DISC"
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = inferHDBTypeFromSource(meta.Source)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		typeValue = inferHDBTypeFromPath(meta.SourcePath)
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.VideoEncode) != "" {
+			typeValue = "ENCODE"
+		}
+	}
+	if typeValue == "" || isHDBCategoryType(typeValue) {
+		if strings.TrimSpace(meta.VideoCodec) != "" || strings.TrimSpace(meta.Release.Resolution) != "" || strings.TrimSpace(meta.Release.Ext) != "" {
+			typeValue = "ENCODE"
+		}
+	}
+	return typeValue
+}
+
+func normalizeHDBType(value string) string {
+	upper := strings.ToUpper(strings.TrimSpace(value))
+	if upper == "" {
+		return ""
+	}
+	upper = strings.ReplaceAll(upper, "-", "")
+	upper = strings.ReplaceAll(upper, " ", "")
+	upper = strings.ReplaceAll(upper, "_", "")
+	switch upper {
+	case "WEBDL":
+		return "WEBDL"
+	case "WEBRIP":
+		return "WEBRIP"
+	}
+	return upper
+}
+
+func isHDBCategoryType(value string) bool {
+	upper := strings.ToUpper(strings.TrimSpace(value))
+	return upper == "MOVIE" || upper == "TV"
+}
+
+func inferHDBTypeFromSource(source string) string {
+	upper := normalizeHDBType(source)
+	switch {
+	case strings.Contains(upper, "WEBDL"):
+		return "WEBDL"
+	case strings.Contains(upper, "WEBRIP"):
+		return "WEBRIP"
+	case strings.Contains(upper, "HDTV"):
+		return "HDTV"
+	}
+	return ""
+}
+
+func inferHDBTypeFromPath(path string) string {
+	base := strings.ToUpper(strings.TrimSpace(path))
+	compact := strings.NewReplacer(".", "", "-", "", "_", "", " ", "").Replace(base)
+	switch {
+	case strings.Contains(compact, "REMUX"):
+		return "REMUX"
+	case strings.Contains(compact, "WEBDL"):
+		return "WEBDL"
+	case strings.Contains(compact, "WEBRIP"):
+		return "WEBRIP"
+	case strings.Contains(compact, "HDTV"):
+		return "HDTV"
+	case strings.Contains(compact, "DVDRIP"):
+		return "DVDRIP"
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/hds/bbcode.go b/internal/trackers/impl/standalone/hds/bbcode.go
new file mode 100644
index 00000000..b61eec04
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/bbcode.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	replacer := strings.NewReplacer(
+		"[user]", "", "[/user]", "",
+		"[align=left]", "", "[/align]", "",
+		"[right]", "", "[/right]", "",
+		"[align=right]", "", "[/align]", "",
+		"[alert]", "", "[/alert]", "",
+		"[note]", "", "[/note]", "",
+		"[hr]", "", "[/hr]", "",
+		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
+		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
+		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
+		"[ul]", "", "[/ul]", "",
+		"[ol]", "", "[/ol]", "",
+	)
+	value = replacer.Replace(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.RemoveSup(value)
+	value = bbcode.RemoveHide(value)
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveSpoiler(value)
+	value = bbcode.RemoveColor(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/hds/description_assets_test.go b/internal/trackers/impl/standalone/hds/description_assets_test.go
new file mode 100644
index 00000000..0da793e2
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/description_assets_test.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages: []api.ScreenshotImage{{
+			RawURL: "https://images.example.invalid/menu.png",
+			ImgURL: "https://images.example.invalid/menu-thumb.png",
+			WebURL: "https://images.example.invalid/menu-view",
+		}},
+		Screenshots: []api.ScreenshotImage{{
+			RawURL: "https://images.example.invalid/normal.png",
+			ImgURL: "https://images.example.invalid/normal-thumb.png",
+			WebURL: "https://images.example.invalid/normal-view",
+		}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "HDS",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader:   "Disc menu token",
+			ScreenshotHeader: "Screenshots token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu-thumb.png", "Screenshots token", "normal-thumb.png")
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "HDS", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/hds/dupe.go b/internal/trackers/impl/standalone/hds/dupe.go
new file mode 100644
index 00000000..7f65dc9c
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/dupe.go
@@ -0,0 +1,119 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var hdsPagePattern = regexp.MustCompile(`pages=(\d+)`)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	if resolution != "2160p" && resolution != "1080p" && resolution != "1080i" && resolution != "720p" {
+		return dupe.NotRun(dupe.NotRunUnsupportedContent, "resolution below HDS dupe-check minimum", nil)
+	}
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for HDS dupe search", nil)
+	}
+	baseURL := hdsBaseURL(s.cfg)
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "HDS search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "HDS", parsed.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid HDS cookies", nil)
+	}
+	entries := make([]api.DupeEntry, 0)
+	for page := 0; page <= 10; page++ {
+		params := url.Values{
+			"page":    {"torrents"},
+			"search":  {fmt.Sprintf("tt%07d", meta.Identity.IMDBID)},
+			"active":  {"0"},
+			"options": {"2"},
+			"pages":   {strconv.Itoa(page)},
+		}
+		status, body, err := commonhttp.GetText(ctx, s.http, baseURL+"/index.php", params, trackerCookies)
+		if err != nil || status < http.StatusOK || status >= http.StatusMultipleChoices {
+			return dupe.Failed(dupe.FailureRequest, "HDS search failed", err)
+		}
+		parts := strings.SplitN(body, "Show/Hide Categories", 2)
+		if len(parts) < 2 {
+			break
+		}
+		root, err := xhtml.Parse(strings.NewReader(parts[1]))
+		if err != nil {
+			return dupe.Failed(dupe.FailureResponseParse, "HDS response parse failed", err)
+		}
+		before := len(entries)
+		for _, row := range commonhttp.FindNodes(root, func(node *xhtml.Node) bool { return node.Type == xhtml.ElementNode && node.Data == "tr" }) {
+			nameNode := commonhttp.FirstNode(row, func(node *xhtml.Node) bool {
+				return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(commonhttp.Attr(node, "href"), "page=torrent-details")
+			})
+			if nameNode == nil {
+				continue
+			}
+			entry := api.DupeEntry{
+				Name: metautil.FirstNonEmptyTrimmed(commonhttp.NodeText(nameNode), commonhttp.Attr(nameNode, "title")),
+				Link: commonhttp.AbsoluteURL(baseURL, commonhttp.Attr(nameNode, "href")),
+			}
+			for _, cell := range commonhttp.FindNodes(row, func(node *xhtml.Node) bool {
+				return node.Type == xhtml.ElementNode && node.Data == "td" && commonhttp.HasClass(node, "lista")
+			}) {
+				if size, ok := commonhttp.ParseSizeBytes(commonhttp.NodeText(cell)); ok {
+					entry.SizeText = strings.TrimSpace(commonhttp.NodeText(cell))
+					entry.SizeKnown, entry.SizeBytes = true, size
+					break
+				}
+			}
+			if entry.Name != "" {
+				entries = append(entries, entry)
+			}
+		}
+		next := commonhttp.FirstNode(root, func(node *xhtml.Node) bool {
+			if node.Type != xhtml.ElementNode || node.Data != "a" {
+				return false
+			}
+			href, text := commonhttp.Attr(node, "href"), strings.TrimSpace(commonhttp.NodeText(node))
+			return strings.Contains(href, "pages=") && (strings.EqualFold(text, "Next") || text == ">>" || hdsPagePattern.MatchString(href))
+		})
+		if next == nil || len(entries) == before {
+			break
+		}
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func hdsBaseURL(_ config.Config) string {
+	return "https://hd-space.org"
+}
diff --git a/internal/trackers/impl/standalone/hds/profile.go b/internal/trackers/impl/standalone/hds/profile.go
new file mode 100644
index 00000000..252db2d0
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/profile.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns HDS identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "HDS",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "hds",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		Rules:               rules(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: sourceFlag,
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"hd-space.pw"},
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			AuthKind:           "cookies",
+			SupportsCookieFile: true,
+		},
+	}
+}
+
+// New returns a fresh HDS definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "hds", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/hds/rules.go b/internal/trackers/impl/standalone/hds/rules.go
new file mode 100644
index 00000000..f6486fe6
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/rules.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// rules requires a supported HD resolution as a strict block and reports a
+// missing IMDb identifier as waivable.
+func rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkRules} }
+
+func checkRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0, 2)
+	resolution := trackers.ResolveRuleResolution(meta)
+	if !supportsHDSResolution(resolution) {
+		failures = append(failures, trackers.NewRuleFailure(
+			"min_resolution",
+			"resolution must be at least 720p",
+			api.RuleDispositionStrict,
+		))
+	}
+	hasIMDb := meta.Identity.IMDBID > 0
+	if !hasIMDb && meta.ProviderMetadata.IMDB != nil {
+		hasIMDb = meta.ProviderMetadata.IMDB.IMDBID > 0 || strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL) != ""
+	}
+	if !hasIMDb {
+		failures = append(failures, trackers.NewRuleFailure("require_imdb", "missing IMDb ID", api.RuleDispositionWaivable))
+	}
+	return failures, nil
+}
diff --git a/internal/trackers/impl/standalone/hds/upload.go b/internal/trackers/impl/standalone/hds/upload.go
new file mode 100644
index 00000000..ba96d0ef
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/upload.go
@@ -0,0 +1,431 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/cookies"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://hd-space.org"
+	uploadURL  = baseURL + "/index.php?page=upload"
+	torrentURL = baseURL + "/index.php?page=torrent-details&id="
+	sourceFlag = "HD-Space"
+)
+
+var idPattern = regexp.MustCompile(`download\.php\?id=([a-zA-Z0-9]+)`)
+
+type uploadState struct {
+	torrentPath string
+	description string
+	releaseName string
+	fields      map[string]string
+	nfo         *commonhttp.FileField
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if !supportsHDSResolution(trackers.ResolveRuleResolution(api.NewRuleSubject(req.Meta))) {
+		return trackers.PreparedOperation{}, errors.New("trackers: HDS resolution must be at least 720p")
+	}
+	files := []commonhttp.FileField{{
+		FieldName: "torrent",
+		FileName:  filepath.Base(state.torrentPath),
+		Path:      state.torrentPath,
+	}}
+	if state.nfo != nil {
+		files = append(files, *state.nfo)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	artifactPath := ""
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "HDS")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDS request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+
+	result, err := commonhttp.ExecuteUpload(httpclient.New(httpclient.DefaultTimeout), httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "HDS",
+		SuccessStatus: func(status int) bool { return status >= 200 && status < 400 },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDS execute upload: %w", err)
+	}
+	combined := result.FinalURL + "\n" + string(result.Body)
+	match := idPattern.FindStringSubmatch(combined)
+	if result.Success && len(match) >= 2 {
+		id := strings.TrimSpace(match[1])
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "HDS",
+				TorrentID:   id,
+				TorrentURL:  tURL,
+				DownloadURL: baseURL + "/download.php?id=" + id,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "HDS", "upload_failure", result.Preview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("HDS", result.StatusCode, result.Preview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "HDS",
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "hds",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, []*http.Cookie, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	fields := map[string]string{
+		"category":      strconv.Itoa(resolveCategoryID(req.Meta)),
+		"filename":      metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Filename, pathutil.Base(req.Meta.SourcePath)),
+		"genre":         resolveGenres(req.Meta),
+		"imdb":          resolveIMDbURL(req.Meta),
+		"info":          description,
+		"nuk_rea":       "",
+		"nuk":           "false",
+		"req":           "false",
+		"submit":        "Send",
+		"t3d":           boolString(req.Meta.Is3D != ""),
+		"user_id":       "",
+		"youtube_video": resolveYouTube(req.Meta),
+		"anonymous":     boolString(req.TrackerConfig.Anon),
+	}
+	state := uploadState{
+		torrentPath: torrentPath,
+		description: description,
+		releaseName: fields["filename"],
+		fields:      fields,
+	}
+	if file, ok := resolveNFO(req.Meta); ok {
+		state.nfo = &file
+	}
+	return state, cookies, nil
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDS", "hd-space.org")
+	if err != nil {
+		return values, fmt.Errorf("trackers: HDS load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return 15
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+		return 40
+	}
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	if strings.Contains(strings.ToLower(resolveGenres(meta)+" "+resolveKeywords(meta)), "documentary") {
+		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "2160p") {
+			return 47
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "1080p") || strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "1080i") {
+			return 25
+		}
+		return 24
+	}
+	if meta.Anime {
+		switch strings.TrimSpace(meta.Release.Resolution) {
+		case "2160p":
+			return 48
+		case "1080p", "1080i":
+			return 28
+		default:
+			return 27
+		}
+	}
+	if category == "TV" {
+		switch strings.TrimSpace(meta.Release.Resolution) {
+		case "2160p":
+			return 45
+		case "1080p", "1080i":
+			return 22
+		default:
+			return 21
+		}
+	}
+	switch strings.TrimSpace(meta.Release.Resolution) {
+	case "2160p":
+		return 46
+	case "1080p", "1080i":
+		return 19
+	default:
+		return 18
+	}
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	parts := make([]string, 0, 12)
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Logo
+	if req.Runtime.Description.AddLogo {
+		if logo := resolveLogo(meta); logo != "" {
+			parts = append(parts, "[center][img]"+logo+"[/img][/center]")
+		}
+	}
+
+	// TV Episode details
+	if strings.TrimSpace(meta.EpisodeOverview) != "" {
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
+	}
+
+	// File information (BDInfo or MediaInfo)
+	if media := trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta); media != "" {
+		parts = append(parts, "[pre]"+media+"[/pre]")
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// menu
+	if len(assets.MenuImages) > 0 {
+		// header
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		// images
+		if shots := screenshotBlock(assets.MenuImages); shots != "" {
+			parts = append(parts, shots)
+		}
+	}
+	// Screenshot Header
+	if header := strings.TrimSpace(req.Runtime.Description.ScreenshotHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// screenshots
+	if shots := screenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+
+	// custom user signature
+	if signature := strings.TrimSpace(req.Runtime.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	// upbrr signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[center][url=%s][size=2]%s[/size][/url][/center]", link, text))
+
+	// finalize description
+	finalDescription := finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "HDS", req.Runtime.DBPath, finalDescription, req.Logger)
+	}
+
+	return finalDescription
+}
+
+func resolveLogo(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo) != "" {
+		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo), "/")
+	}
+	return ""
+}
+
+func resolveGenres(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	case meta.ProviderMetadata.IMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	default:
+		return strings.TrimSpace(meta.Release.Genre)
+	}
+}
+
+func resolveKeywords(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+	}
+	return ""
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveYouTube(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	return ""
+}
+
+func resolveNFO(meta api.UploadSubject) (commonhttp.FileField, bool) {
+	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
+	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
+	if err != nil {
+		return commonhttp.FileField{}, false
+	}
+	return commonhttp.FileField{
+		FieldName: "nfo",
+		FileName:  filepath.Base(path),
+		Content:   payload,
+	}, true
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	var sb strings.Builder
+	for _, image := range images {
+		if strings.TrimSpace(image.WebURL) == "" || strings.TrimSpace(image.ImgURL) == "" {
+			continue
+		}
+		sb.WriteString("[url=" + image.WebURL + "][img]" + image.ImgURL + "[/img][/url]")
+
+		// HDS cannot resize images. If the image host does not provide small thumbnails(<400px), place only one image per line.
+		// imgbox provides small thumbnails, so we can place them side-by-side.
+		if !strings.Contains(strings.ToLower(image.WebURL), "imgbox") {
+			sb.WriteString("\n")
+		}
+	}
+	content := strings.TrimSpace(sb.String())
+	if content == "" {
+		return ""
+	}
+	return "[center]\n" + content + "\n[/center]"
+}
+
+func boolString(value bool) string {
+	if value {
+		return "true"
+	}
+	return "false"
+}
+
+func supportsHDSResolution(value string) bool {
+	switch strings.TrimSpace(value) {
+	case "2160p", "1080p", "1080i", "720p":
+		return true
+	default:
+		return false
+	}
+}
diff --git a/internal/trackers/impl/standalone/hds/upload_test.go b/internal/trackers/impl/standalone/hds/upload_test.go
new file mode 100644
index 00000000..4c858f4f
--- /dev/null
+++ b/internal/trackers/impl/standalone/hds/upload_test.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hds
+
+import "testing"
+
+func TestSupportsHDSResolution(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name       string
+		resolution string
+		expected   bool
+	}{
+		{
+			name:       "2160p",
+			resolution: "2160p",
+			expected:   true,
+		},
+		{
+			name:       "1080i",
+			resolution: "1080i",
+			expected:   true,
+		},
+		{
+			name:       "720p",
+			resolution: "720p",
+			expected:   true,
+		},
+		{
+			name:       "576p",
+			resolution: "576p",
+			expected:   false,
+		},
+		{
+			name:       "480p",
+			resolution: "480p",
+			expected:   false,
+		},
+	}
+
+	for _, tc := range cases {
+		if got := supportsHDSResolution(tc.resolution); got != tc.expected {
+			t.Fatalf("%s: expected %t, got %t", tc.name, tc.expected, got)
+		}
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdt/bbcode.go b/internal/trackers/impl/standalone/hdt/bbcode.go
new file mode 100644
index 00000000..2a1d2c20
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/bbcode.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	replacer := strings.NewReplacer(
+		"[user]", "", "[/user]", "",
+		"[align=left]", "", "[/align]", "",
+		"[align=right]", "", "[/align]", "",
+		"[alert]", "", "[/alert]", "",
+		"[note]", "", "[/note]", "",
+		"[hr]", "", "[/hr]", "",
+		"[h1]", "[u][b]", "[/h1]", "[/b][/u]",
+		"[h2]", "[u][b]", "[/h2]", "[/b][/u]",
+		"[h3]", "[u][b]", "[/h3]", "[/b][/u]",
+		"[ul]", "", "[/ul]", "",
+		"[ol]", "", "[/ol]", "",
+	)
+	value = replacer.Replace(value)
+	value = bbcode.RemoveSub(value)
+	value = bbcode.RemoveSup(value)
+	value = bbcode.ConvertSpoilerToHide(value)
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveSpoiler(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/hdt/description_assets_test.go b/internal/trackers/impl/standalone/hdt/description_assets_test.go
new file mode 100644
index 00000000..114d315d
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/description_assets_test.go
@@ -0,0 +1,67 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages: []api.ScreenshotImage{{
+			RawURL: "https://images.example.invalid/menu.png",
+			ImgURL: "https://images.example.invalid/menu-thumb.png",
+		}},
+		Screenshots: []api.ScreenshotImage{{
+			RawURL: "https://images.example.invalid/normal.png",
+			ImgURL: "https://images.example.invalid/normal-thumb.png",
+		}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "HDT",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader:   "Disc menu token",
+			ScreenshotHeader: "Screenshots token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "HDT", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/hdt/dupe.go b/internal/trackers/impl/standalone/hdt/dupe.go
new file mode 100644
index 00000000..c4bab814
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/dupe.go
@@ -0,0 +1,137 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	if resolution != "2160p" && resolution != "1080p" && resolution != "1080i" && resolution != "720p" {
+		return dupe.NotRun(dupe.NotRunUnsupportedContent, "resolution below HDT dupe-check minimum", nil)
+	}
+	baseURL := hdtBaseURL(s.cfg)
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "HDT search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "HDT", parsed.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid HDT cookies", nil)
+	}
+	params := url.Values{"active": {"0"}, "category[]": {strconv.Itoa(hdtCategoryID(meta))}}
+	if meta.Identity.IMDBID != 0 {
+		params.Set("search", fmt.Sprintf("tt%07d", meta.Identity.IMDBID))
+		params.Set("options", "2")
+	} else {
+		params.Set("search", metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName))
+		params.Set("options", "3")
+	}
+	status, root, err := commonhttp.GetHTML(ctx, s.http, baseURL+"/torrents.php", params, trackerCookies)
+	if err != nil || status < http.StatusOK || status >= http.StatusMultipleChoices || root == nil {
+		return dupe.Failed(dupe.FailureRequest, "HDT search failed", err)
+	}
+	entries := make([]api.DupeEntry, 0)
+	for _, row := range commonhttp.FindNodes(root, func(node *xhtml.Node) bool { return node.Type == xhtml.ElementNode && node.Data == "tr" }) {
+		nameNode := commonhttp.FirstNode(row, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(commonhttp.Attr(node, "href"), "details.php?id=")
+		})
+		if nameNode == nil {
+			continue
+		}
+		entry := api.DupeEntry{Name: strings.TrimSpace(commonhttp.NodeText(nameNode)), Link: commonhttp.AbsoluteURL(baseURL, commonhttp.Attr(nameNode, "href"))}
+		for _, cell := range commonhttp.FindNodes(row, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "td" && commonhttp.HasClass(node, "mainblockcontent")
+		}) {
+			if size, ok := commonhttp.ParseSizeBytes(commonhttp.NodeText(cell)); ok {
+				entry.SizeKnown, entry.SizeBytes = true, size
+				break
+			}
+		}
+		if entry.Name != "" {
+			entries = append(entries, entry)
+		}
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func hdtBaseURL(_ config.Config) string {
+	return "https://hd-torrents.me"
+}
+func hdtCategoryID(meta api.DuplicateSubject) int {
+	category := strings.ToUpper(strings.TrimSpace(string(meta.Identity.Category)))
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	disc := strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC")
+	remux := strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX")
+	uhd := strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p"
+	if category == "TV" {
+		if disc {
+			if resolution == "2160p" {
+				return 72
+			}
+			return 59
+		}
+		if remux {
+			if uhd {
+				return 73
+			}
+			return 60
+		}
+		if resolution == "2160p" {
+			return 65
+		}
+		if resolution == "1080p" || resolution == "1080i" {
+			return 30
+		}
+		return 38
+	}
+	if disc {
+		if resolution == "2160p" {
+			return 70
+		}
+		return 1
+	}
+	if remux {
+		if uhd {
+			return 71
+		}
+		return 2
+	}
+	if resolution == "2160p" {
+		return 64
+	}
+	if resolution == "1080p" || resolution == "1080i" {
+		return 5
+	}
+	return 3
+}
diff --git a/internal/trackers/impl/standalone/hdt/profile.go b/internal/trackers/impl/standalone/hdt/profile.go
new file mode 100644
index 00000000..ac3f100b
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/profile.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns HDT identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "HDT",
+		BaseURL:             resolveBaseURL(),
+		DescriptionGroup:    "hdt",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		Rules:               rules(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{
+			Source: "hd-torrents.org",
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"https://hdts-announce.ru"},
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			AuthKind:           "cookies",
+			SupportsCookieFile: true,
+		},
+	}
+}
+
+// New returns a fresh HDT definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "hdt", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/hdt/rules.go b/internal/trackers/impl/standalone/hdt/rules.go
new file mode 100644
index 00000000..920802ed
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/rules.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// rules strictly blocks uploads whose resolution is unknown.
+func rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkRules} }
+
+func checkRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	if trackers.ResolveRuleResolution(meta) == "" {
+		return []api.RuleFailure{trackers.NewRuleFailure(
+			"resolution_required",
+			"missing resolution",
+			api.RuleDispositionStrict,
+		)}, nil
+	}
+	return nil, nil
+}
diff --git a/internal/trackers/impl/standalone/hdt/upload.go b/internal/trackers/impl/standalone/hdt/upload.go
new file mode 100644
index 00000000..ed0be1a6
--- /dev/null
+++ b/internal/trackers/impl/standalone/hdt/upload.go
@@ -0,0 +1,455 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hdt
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/cookies"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var tokenPattern = regexp.MustCompile(`name="csrfToken"\s+value="([^"]+)"`)
+var successPattern = regexp.MustCompile(`details\.php\?id=([a-zA-Z0-9]+)|Upload successful!`)
+var detailsPattern = regexp.MustCompile(`details\.php\?id=([a-zA-Z0-9]+)`)
+
+type uploadState struct {
+	baseURL       string
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	nfo           *commonhttp.FileField
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req, req.Intent != trackers.PreparationIntentUpload)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if trackers.ResolveRuleResolution(api.NewRuleSubject(req.Meta)) == "" {
+		return trackers.PreparedOperation{}, errors.New("trackers: HDT missing resolution")
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: HDT %s", state.blockedReason)
+	}
+	files := []commonhttp.FileField{{
+		FieldName: "torrent",
+		FileName:  filepath.Base(state.torrentPath),
+		Path:      state.torrentPath,
+	}}
+	if state.nfo != nil {
+		files = append(files, *state.nfo)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	artifactPath := ""
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "HDT")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.baseURL+"/upload.php", bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDT request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+
+	result, err := commonhttp.ExecuteUpload(httpclient.New(httpclient.DefaultTimeout), httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "HDT",
+		SuccessStatus: func(status int) bool { return status >= 200 && status < 400 },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: HDT execute upload: %w", err)
+	}
+	combined := result.FinalURL + "\n" + string(result.Body)
+	id := ""
+	if match := detailsPattern.FindStringSubmatch(combined); len(match) >= 2 {
+		id = match[1]
+	}
+	if result.Success && successPattern.MatchString(combined) {
+		tURL := result.FinalURL
+		if id != "" && !strings.Contains(tURL, "details.php?id=") {
+			tURL = state.baseURL + "/details.php?id=" + id
+		}
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, "hd-torrents.org"); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "HDT",
+				TorrentID:   id,
+				TorrentURL:  tURL,
+				DownloadURL: tURL,
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "HDT", "upload_failure", result.Preview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("HDT", result.StatusCode, result.Preview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "HDT",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "hdt",
+		Description:      state.description,
+		Endpoint:         state.baseURL + "/upload.php",
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput, dryRun bool) (uploadState, []*http.Cookie, error) {
+	base := resolveBaseURL()
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath, base)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	token := strings.Join([]string{"dry", "run", "token"}, "-")
+	if !dryRun {
+		token, err = fetchToken(ctx, base, cookies)
+		if err != nil {
+			return uploadState{}, nil, err
+		}
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	fields := map[string]string{
+		"filename":  resolveName(req.Meta),
+		"category":  strconv.Itoa(resolveCategoryID(req.Meta)),
+		"info":      description,
+		"csrfToken": token,
+		"season":    boolString(req.Meta.TVPack),
+		"anonymous": boolString(req.TrackerConfig.Anon),
+	}
+	if req.Meta.Is3D != "" {
+		fields["3d"] = "true"
+	}
+	hdr := strings.ToUpper(strings.TrimSpace(req.Meta.HDR))
+	if strings.Contains(hdr, "HDR10+") {
+		fields["HDR10"] = "true"
+		fields["HDR10Plus"] = "true"
+	} else if strings.Contains(hdr, "HDR") {
+		fields["HDR10"] = "true"
+	}
+	if strings.Contains(hdr, "DV") {
+		fields["DolbyVision"] = "true"
+	}
+	if imdb := resolveIMDbURL(req.Meta); imdb != "" {
+		fields["infosite"] = imdb + "/"
+	}
+	state := uploadState{
+		baseURL:     base,
+		torrentPath: torrentPath,
+		description: description,
+		releaseName: fields["filename"],
+		fields:      fields,
+	}
+	if file, ok := resolveNFO(req.Meta); ok {
+		state.nfo = &file
+	}
+	return state, cookies, nil
+}
+
+func resolveBaseURL() string {
+	return "https://hd-torrents.me"
+}
+
+func loadCookies(ctx context.Context, dbPath string, baseURL string) ([]*http.Cookie, error) {
+	host := "hd-torrents.me"
+	if parsed, err := url.Parse(baseURL); err == nil && parsed.Host != "" {
+		host = parsed.Host
+	}
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "HDT", host)
+	if err != nil {
+		return values, fmt.Errorf("trackers: HDT load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func fetchToken(ctx context.Context, baseURL string, cookies []*http.Cookie) (string, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/upload.php", nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: HDT token request build: %w", err)
+	}
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("trackers: HDT token request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	match := tokenPattern.FindStringSubmatch(string(body))
+	if len(match) < 2 {
+		return "", errors.New("trackers: HDT csrf token not found")
+	}
+	return strings.TrimSpace(match[1]), nil
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	if category == "TV" {
+		if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
+			if resolution == "2160p" {
+				return 72
+			}
+			return 59
+		}
+		if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+			if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
+				return 73
+			}
+			return 60
+		}
+		switch resolution {
+		case "2160p":
+			return 65
+		case "1080p", "1080i":
+			return 30
+		default:
+			return 38
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") {
+		if resolution == "2160p" {
+			return 70
+		}
+		return 1
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && resolution == "2160p" {
+			return 71
+		}
+		return 2
+	}
+	switch resolution {
+	case "2160p":
+		return 64
+	case "1080p", "1080i":
+		return 5
+	default:
+		return 3
+	}
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	parts := make([]string, 0, 15)
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Logo
+	if req.Runtime.Description.AddLogo {
+		if logo := resolveLogo(meta); logo != "" {
+			parts = append(parts, "[center][img]"+logo+"[/img][/center]")
+		}
+	}
+
+	// TV Episode details
+	if strings.TrimSpace(meta.EpisodeOverview) != "" {
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
+	}
+
+	// File information (BDInfo or MediaInfo)
+	if media := trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta); media != "" {
+		parts = append(parts, "[pre]"+media+"[/pre]")
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// menu
+	if len(assets.MenuImages) > 0 {
+		// header
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		// images
+		if shots := screenshotBlock(assets.MenuImages); shots != "" {
+			parts = append(parts, shots)
+		}
+	}
+	// Screenshot Header
+	if header := strings.TrimSpace(req.Runtime.Description.ScreenshotHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// screenshots
+	if shots := screenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+
+	// custom user signature
+	if signature := strings.TrimSpace(req.Runtime.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	// upbrr signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[right][url=%s][size=1]%s[/size][/url][/right]", link, text))
+
+	// finalize description
+	finalDescription := finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "HDT", req.Runtime.DBPath, finalDescription, req.Logger)
+	}
+
+	return finalDescription
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(images))
+	for _, image := range images {
+		if strings.TrimSpace(image.RawURL) == "" {
+			continue
+		}
+		parts = append(parts, "<a href='"+strings.TrimSpace(image.RawURL)+"'><img src='"+strings.TrimSpace(image.ImgURL)+"' height=137></a> ")
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	return "[center]" + strings.Join(parts, " ") + "[/center]"
+}
+
+func resolveName(meta api.UploadSubject) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") || strings.EqualFold(strings.TrimSpace(meta.Type), "WEBRIP") ||
+		strings.EqualFold(strings.TrimSpace(meta.Type), "ENCODE") {
+		name = strings.Replace(name, meta.Audio, strings.Replace(meta.Audio, " ", "", 1), 1)
+	}
+	name = strings.ReplaceAll(name, " DV ", " DoVi ")
+	name = strings.ReplaceAll(name, "BluRay REMUX", "Blu-ray Remux")
+	name = strings.Join(strings.Fields(name), " ")
+	name = strings.ReplaceAll(name, ":", "")
+	return strings.TrimSpace(name)
+}
+
+func resolveLogo(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo) != "" {
+		return "https://image.tmdb.org/t/p/w300/" + strings.TrimPrefix(strings.TrimSpace(meta.ProviderMetadata.TMDB.TMDBLogo), "/")
+	}
+	return ""
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveNFO(meta api.UploadSubject) (commonhttp.FileField, bool) {
+	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
+	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
+	if err != nil {
+		return commonhttp.FileField{}, false
+	}
+	return commonhttp.FileField{
+		FieldName: "nfos",
+		FileName:  filepath.Base(path),
+		Content:   payload,
+	}, true
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func boolString(value bool) string {
+	if value {
+		return "true"
+	}
+	return "false"
+}
diff --git a/internal/trackers/impl/standalone/internal/cookieauth/login.go b/internal/trackers/impl/standalone/internal/cookieauth/login.go
new file mode 100644
index 00000000..0252a6a9
--- /dev/null
+++ b/internal/trackers/impl/standalone/internal/cookieauth/login.go
@@ -0,0 +1,77 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package cookieauth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// CookieLoginSpec describes one stored-cookie validation and credential-login lifecycle.
+type CookieLoginSpec struct {
+	TrackerID     string
+	BaseURL       string
+	CookieDomain  string
+	Load          func(context.Context, string) ([]*http.Cookie, error)
+	Validate      func(context.Context, string, []*http.Cookie) error
+	HasCredential func(config.TrackerConfig) bool
+	Login         func(context.Context, config.TrackerConfig, string, string) error
+}
+
+// CookieLoginResolver returns a resolver that reuses valid cookies, preserves
+// transient validation failures, and logs in only after confirmed invalid or
+// missing cookie state when credentials are available.
+func CookieLoginResolver(spec CookieLoginSpec) trackers.AuthSessionResolver {
+	trackerID := strings.ToUpper(strings.TrimSpace(spec.TrackerID))
+	baseURL := strings.TrimRight(strings.TrimSpace(spec.BaseURL), "/")
+	if spec.Load == nil {
+		spec.Load = func(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+			return cookies.LoadTrackerHTTPCookies(ctx, dbPath, trackerID, spec.CookieDomain)
+		}
+	}
+	return func(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
+		return resolveCookieLogin(ctx, cfg, dbPath, trackerID, baseURL, spec)
+	}
+}
+
+func resolveCookieLogin(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	dbPath string,
+	trackerID string,
+	baseURL string,
+	spec CookieLoginSpec,
+) error {
+	values, loadErr := spec.Load(ctx, dbPath)
+	if loadErr == nil && len(values) > 0 {
+		validationErr := spec.Validate(ctx, baseURL, values)
+		if validationErr == nil {
+			return nil
+		}
+		var validation *trackerauth.ValidationError
+		if !errors.As(validationErr, &validation) || !validation.ConfirmedInvalid || validation.Transient || !spec.HasCredential(cfg) {
+			return validationErr
+		}
+	}
+	if !spec.HasCredential(cfg) {
+		if loadErr == nil {
+			loadErr = cookies.ErrTrackerCookiesNotFound
+		}
+		return &trackerauth.AuthRequiredError{
+			TrackerID: trackerID,
+			Reason:    "cookies or username/password missing",
+			Err:       fmt.Errorf("trackers: %s cookies unavailable: %w", trackerID, loadErr),
+		}
+	}
+	return spec.Login(ctx, cfg, dbPath, baseURL)
+}
diff --git a/internal/trackers/impl/standalone/internal/cookieauth/login_test.go b/internal/trackers/impl/standalone/internal/cookieauth/login_test.go
new file mode 100644
index 00000000..c41ec868
--- /dev/null
+++ b/internal/trackers/impl/standalone/internal/cookieauth/login_test.go
@@ -0,0 +1,114 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package cookieauth
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"sync/atomic"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestCookieLoginResolverLifecycle(t *testing.T) {
+	t.Parallel()
+
+	transientErr := &trackerauth.ValidationError{
+		TrackerID: "FF",
+		Transient: true,
+		Reason:    "unavailable",
+	}
+	tests := []struct {
+		name              string
+		load              func(context.Context, string) ([]*http.Cookie, error)
+		validationErr     error
+		hasCredentials    bool
+		wantLoginCalls    int32
+		wantValidationErr bool
+		wantAuthRequired  bool
+	}{
+		{
+			name: "valid stored cookies",
+			load: func(context.Context, string) ([]*http.Cookie, error) {
+				return []*http.Cookie{{Name: "session", Value: "valid"}}, nil
+			},
+			hasCredentials: true,
+		},
+		{
+			name: "confirmed invalid cookies login",
+			load: func(context.Context, string) ([]*http.Cookie, error) {
+				return []*http.Cookie{{Name: "session", Value: "invalid"}}, nil
+			},
+			validationErr: &trackerauth.ValidationError{
+				TrackerID:        "FF",
+				ConfirmedInvalid: true,
+				Reason:           "invalid",
+			},
+			hasCredentials: true,
+			wantLoginCalls: 1,
+		},
+		{
+			name: "transient validation failure",
+			load: func(context.Context, string) ([]*http.Cookie, error) {
+				return []*http.Cookie{{Name: "session", Value: "unknown"}}, nil
+			},
+			validationErr:     transientErr,
+			hasCredentials:    true,
+			wantValidationErr: true,
+		},
+		{
+			name: "missing credentials",
+			load: func(context.Context, string) ([]*http.Cookie, error) {
+				return nil, cookies.ErrTrackerCookiesNotFound
+			},
+			wantAuthRequired: true,
+		},
+		{
+			name: "missing cookies login",
+			load: func(context.Context, string) ([]*http.Cookie, error) {
+				return nil, cookies.ErrTrackerCookiesNotFound
+			},
+			hasCredentials: true,
+			wantLoginCalls: 1,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			var loginCalls atomic.Int32
+			resolver := CookieLoginResolver(CookieLoginSpec{
+				TrackerID: "FF",
+				BaseURL:   "https://tracker.invalid",
+				Load:      test.load,
+				Validate: func(context.Context, string, []*http.Cookie) error {
+					return test.validationErr
+				},
+				HasCredential: func(config.TrackerConfig) bool { return test.hasCredentials },
+				Login: func(context.Context, config.TrackerConfig, string, string) error {
+					loginCalls.Add(1)
+					return nil
+				},
+			})
+			err := resolver(context.Background(), config.TrackerConfig{}, "test.db", api.TrackerAuthLoginRequest{})
+			if test.wantValidationErr && !errors.Is(err, transientErr) {
+				t.Fatalf("resolver error = %v", err)
+			}
+			var authRequired *trackerauth.AuthRequiredError
+			if test.wantAuthRequired != errors.As(err, &authRequired) {
+				t.Fatalf("auth-required error = %v", err)
+			}
+			if !test.wantValidationErr && !test.wantAuthRequired && err != nil {
+				t.Fatalf("resolver error = %v", err)
+			}
+			if loginCalls.Load() != test.wantLoginCalls {
+				t.Fatalf("login calls = %d, want %d", loginCalls.Load(), test.wantLoginCalls)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/internal/jsondupe/list.go b/internal/trackers/impl/standalone/internal/jsondupe/list.go
new file mode 100644
index 00000000..19bedd90
--- /dev/null
+++ b/internal/trackers/impl/standalone/internal/jsondupe/list.go
@@ -0,0 +1,110 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package jsondupe executes the authenticated JSON-list search protocol shared
+// by standalone trackers while leaving query and result identity tracker-local.
+package jsondupe
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const maxResponseBytes = 4 << 20
+
+// ListSpec describes one JSON-array duplicate-search request and projection.
+type ListSpec struct {
+	Endpoint       string
+	Query          url.Values
+	Headers        http.Header
+	IDField        string
+	NameField      string
+	SizeField      string
+	Link           func(string) string
+	FailureMessage string
+}
+
+// Search executes a JSON-list duplicate search with number-preserving decoding.
+// It rejects non-2xx responses and bodies above 4 MiB through typed adapter
+// failure results rather than returning Go errors directly.
+func Search(ctx context.Context, client *http.Client, spec ListSpec) dupe.AdapterResult {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, spec.Endpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, spec.FailureMessage, err)
+	}
+	req.URL.RawQuery = spec.Query.Encode()
+	for name, values := range spec.Headers {
+		for _, value := range values {
+			req.Header.Add(name, value)
+		}
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, spec.FailureMessage, err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, spec.FailureMessage, nil)
+	}
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBytes+1))
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, spec.FailureMessage, err)
+	}
+	if len(body) > maxResponseBytes {
+		return dupe.Failed(dupe.FailureResponseParse, spec.FailureMessage, fmt.Errorf("duplicate response exceeds %d bytes", maxResponseBytes))
+	}
+	var items []map[string]any
+	decoder := json.NewDecoder(bytes.NewReader(body))
+	decoder.UseNumber()
+	if err := decoder.Decode(&items); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, spec.FailureMessage, err)
+	}
+
+	entries := make([]api.DupeEntry, 0, len(items))
+	for _, item := range items {
+		id := scalarString(item[spec.IDField])
+		entry := api.DupeEntry{Name: scalarString(item[spec.NameField]), ID: id}
+		if spec.Link != nil {
+			entry.Link = spec.Link(id)
+		}
+		if size := scalarInt64(item[spec.SizeField]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func scalarString(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case json.Number:
+		return typed.String()
+	default:
+		return ""
+	}
+}
+
+func scalarInt64(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/internal/jsondupe/list_test.go b/internal/trackers/impl/standalone/internal/jsondupe/list_test.go
new file mode 100644
index 00000000..c2054619
--- /dev/null
+++ b/internal/trackers/impl/standalone/internal/jsondupe/list_test.go
@@ -0,0 +1,93 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jsondupe
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+)
+
+func TestSearchProjectsAuthenticatedJSONList(t *testing.T) {
+	requestErr := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("imdb") != "1234567" || r.Header.Get("Authorization") != "secret" {
+			requestErr <- errors.New("unexpected JSON duplicate request shape")
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`[{"id":9007199254740993,"name":" Example Release ","size":1234}]`))
+	}))
+	defer server.Close()
+
+	result := Search(context.Background(), server.Client(), ListSpec{
+		Endpoint: server.URL,
+		Query: url.Values{
+			"imdb": {"1234567"},
+		},
+		Headers:        http.Header{"Authorization": {"secret"}},
+		IDField:        "id",
+		NameField:      "name",
+		SizeField:      "size",
+		Link:           func(id string) string { return server.URL + "/" + id },
+		FailureMessage: "search failed",
+	})
+	select {
+	case err := <-requestErr:
+		t.Fatal(err)
+	default:
+	}
+	if result.Disposition() != dupe.DispositionResolved {
+		t.Fatalf("expected resolved result, got %v: %v", result.Disposition(), result.Cause())
+	}
+	entries := result.Entries()
+	if len(entries) != 1 || entries[0].ID != "9007199254740993" || entries[0].Name != "Example Release" {
+		t.Fatalf("unexpected entries: %#v", entries)
+	}
+	if !entries[0].SizeKnown || entries[0].SizeBytes != 1234 {
+		t.Fatalf("expected known size, got %#v", entries[0])
+	}
+}
+
+func TestSearchClassifiesStatusAndParseFailures(t *testing.T) {
+	tests := []struct {
+		name string
+		code int
+		body string
+		want string
+	}{
+		{
+			name: "status",
+			code: http.StatusUnauthorized,
+			body: `{}`,
+			want: dupe.FailureResponseStatus,
+		},
+		{
+			name: "parse",
+			code: http.StatusOK,
+			body: `{}`,
+			want: dupe.FailureResponseParse,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(test.code)
+				_, _ = w.Write([]byte(test.body))
+			}))
+			defer server.Close()
+
+			result := Search(context.Background(), server.Client(), ListSpec{Endpoint: server.URL, FailureMessage: "safe failure"})
+			if result.Disposition() != dupe.DispositionFailed || result.Code() != test.want || result.SafeMessage() != "safe failure" {
+				t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/is/bbcode.go b/internal/trackers/impl/standalone/is/bbcode.go
new file mode 100644
index 00000000..f4b68a2a
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/bbcode.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	return bbcode.RemoveExtraLines(strings.TrimSpace(bbcode.NormalizeNewlines(value)))
+}
diff --git a/internal/trackers/impl/standalone/is/definition.go b/internal/trackers/impl/standalone/is/definition.go
new file mode 100644
index 00000000..fdce9acc
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/definition.go
@@ -0,0 +1,25 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "is", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/is/description_assets_test.go b/internal/trackers/impl/standalone/is/description_assets_test.go
new file mode 100644
index 00000000..90275bde
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/description_assets_test.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
+		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "IS",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader: "Disc menu token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots:", "normal.png")
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "IS", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/is/dupe.go b/internal/trackers/impl/standalone/is/dupe.go
new file mode 100644
index 00000000..6fc053c5
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/dupe.go
@@ -0,0 +1,206 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var isSizePattern = regexp.MustCompile(`(?i)([0-9]+(?:\.[0-9]+)?)\s*(KB|MB|GB|TB|KiB|MiB|GiB|TiB|B)\b`)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	baseURL := isBaseURL(s.cfg)
+	parsedBase, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "IS search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "IS", parsedBase.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid IS cookies", nil)
+	}
+	params := url.Values{"do": {"search"}}
+	category := strings.ToUpper(strings.TrimSpace(string(meta.Identity.Category)))
+	if category == "MOVIE" {
+		if meta.Identity.IMDBID == 0 {
+			return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for IS movie dupe search", nil)
+		}
+		params.Set("search_type", "t_genre")
+		params.Set("keywords", fmt.Sprintf("tt%07d", meta.Identity.IMDBID))
+	} else {
+		query := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName) + " " + isSeasonEpisode(meta))
+		params.Set("search_type", "t_name")
+		params.Set("keywords", query)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/browse.php", nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "IS search failed", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(req, trackerCookies)
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "IS search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "IS search failed", nil)
+	}
+	root, err := xhtml.Parse(resp.Body)
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "IS search failed", err)
+	}
+	table := isFirst(root, func(node *xhtml.Node) bool {
+		return node.Type == xhtml.ElementNode && node.Data == "table" && isAttr(node, "id") == "sortabletable"
+	})
+	if table == nil {
+		return dupe.Resolved(nil, nil)
+	}
+	entries := make([]api.DupeEntry, 0)
+	for _, row := range isFind(table, func(node *xhtml.Node) bool { return node.Type == xhtml.ElementNode && node.Data == "tr" }) {
+		link := isFirst(row, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(isAttr(node, "href"), "details.php?id=")
+		})
+		if link == nil {
+			continue
+		}
+		entry := api.DupeEntry{Name: strings.TrimSpace(isText(link)), Link: isAbsoluteURL(baseURL, isAttr(link, "href"))}
+		cells := isFind(row, func(node *xhtml.Node) bool { return node.Type == xhtml.ElementNode && node.Data == "td" })
+		if len(cells) >= 5 {
+			if size, ok := isParseSize(isText(cells[4])); ok {
+				entry.SizeKnown, entry.SizeBytes = true, size
+			}
+		}
+		if entry.Name != "" {
+			entries = append(entries, entry)
+		}
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func isBaseURL(_ config.Config) string {
+	return "https://immortalseed.me"
+}
+func isSeasonEpisode(meta api.DuplicateSubject) string {
+	if meta.SeasonInt > 0 && meta.EpisodeInt > 0 {
+		return fmt.Sprintf("S%02dE%02d", meta.SeasonInt, meta.EpisodeInt)
+	}
+	return strings.TrimSpace(meta.SeasonStr + meta.EpisodeStr)
+}
+func isFind(root *xhtml.Node, match func(*xhtml.Node) bool) []*xhtml.Node {
+	result := make([]*xhtml.Node, 0)
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil {
+			return
+		}
+		if match(node) {
+			result = append(result, node)
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(root)
+	return result
+}
+func isFirst(root *xhtml.Node, match func(*xhtml.Node) bool) *xhtml.Node {
+	var found *xhtml.Node
+	var walk func(*xhtml.Node)
+	walk = func(node *xhtml.Node) {
+		if node == nil || found != nil {
+			return
+		}
+		if match(node) {
+			found = node
+			return
+		}
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			walk(child)
+		}
+	}
+	walk(root)
+	return found
+}
+func isAttr(node *xhtml.Node, key string) string {
+	for _, attr := range node.Attr {
+		if strings.EqualFold(attr.Key, key) {
+			return strings.TrimSpace(attr.Val)
+		}
+	}
+	return ""
+}
+func isText(node *xhtml.Node) string {
+	if node == nil {
+		return ""
+	}
+	if node.Type == xhtml.TextNode {
+		return node.Data
+	}
+	var builder strings.Builder
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		builder.WriteString(isText(child))
+	}
+	return builder.String()
+}
+func isAbsoluteURL(baseURL, value string) string {
+	base, baseErr := url.Parse(baseURL)
+	ref, refErr := url.Parse(value)
+	if baseErr == nil && refErr == nil {
+		return base.ResolveReference(ref).String()
+	}
+	return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(value, "/")
+}
+func isParseSize(value string) (int64, bool) {
+	match := isSizePattern.FindStringSubmatch(strings.TrimSpace(value))
+	if len(match) != 3 {
+		return 0, false
+	}
+	amount, err := strconv.ParseFloat(match[1], 64)
+	if err != nil {
+		return 0, false
+	}
+	multipliers := map[string]float64{
+		"b":   1,
+		"kb":  1e3,
+		"mb":  1e6,
+		"gb":  1e9,
+		"tb":  1e12,
+		"kib": 1024,
+		"mib": 1024 * 1024,
+		"gib": 1024 * 1024 * 1024,
+		"tib": 1024 * 1024 * 1024 * 1024,
+	}
+	return int64(math.Round(amount * multipliers[strings.ToLower(match[2])])), true
+}
diff --git a/internal/trackers/impl/standalone/is/profile.go b/internal/trackers/impl/standalone/is/profile.go
new file mode 100644
index 00000000..3c444317
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/profile.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns IS identity, preparation, dupe, auth, and artifact behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                  "IS",
+		BaseURL:               baseURL,
+		DescriptionGroup:      "is",
+		UploadContentMode:     trackers.UploadContentModeDescription,
+		PrepareDescription:    prepareDescription,
+		PrepareUpload:         prepareUpload,
+		NewDuplicateAdapter:   newDuplicateAdapter,
+		AuthCapability:        standalone.CookieAuthCapability("IS"),
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{baseURL}},
+	}
+}
+
+// New returns a fresh IS definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/is/upload.go b/internal/trackers/impl/standalone/is/upload.go
new file mode 100644
index 00000000..ad1ba2d5
--- /dev/null
+++ b/internal/trackers/impl/standalone/is/upload.go
@@ -0,0 +1,473 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package is
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/httpclient"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://immortalseed.me"
+	uploadURL  = baseURL + "/upload.php"
+	torrentURL = baseURL + "/details.php?hash="
+	sourceFlag = "https://immortalseed.me"
+)
+
+var (
+	sslPattern   = regexp.MustCompile(`details\.php\?hash=([a-zA-Z0-9]+)|download\.php\?id=([a-zA-Z0-9]+)`)
+	successTexts = []string{"Download Torrent (SSL)", "Thank you for uploading"}
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	nfo           *commonhttp.FileField
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: IS %s", state.blockedReason)
+	}
+
+	files := []commonhttp.FileField{{
+		FieldName: "torrentfile",
+		FileName:  metautil.FirstNonEmptyTrimmed(state.releaseName, filepath.Base(state.torrentPath)),
+		Path:      state.torrentPath,
+	}}
+	if state.nfo != nil {
+		files = append(files, *state.nfo)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "IS")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: IS request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+
+	resp, err := httpclient.New(httpclient.DefaultTimeout).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: IS upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode >= 200 && resp.StatusCode < 400,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: IS read upload response: %w", err)
+	}
+	id, success := successfulUploadResponse(finalURL, string(responseBody))
+	if resp.StatusCode >= 200 && resp.StatusCode < 400 && success {
+		if id != "" {
+			tURL := torrentURL + id
+			if announceURL != "" {
+				if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+					return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+				}
+			}
+			return api.UploadSummary{
+				Uploaded: 1,
+				UploadedTorrents: []api.UploadedTorrent{{
+					Tracker:     "IS",
+					TorrentID:   id,
+					TorrentURL:  tURL,
+					DownloadURL: tURL,
+					TorrentPath: artifactPath,
+				}},
+			}, nil
+		}
+		return api.UploadSummary{Uploaded: 1}, nil
+	}
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "IS", "upload_failure", responsePreview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("IS", resp.StatusCode, responsePreview)
+}
+
+func successfulUploadResponse(finalURL string, responseBody string) (string, bool) {
+	match := sslPattern.FindStringSubmatch(finalURL + "\n" + responseBody)
+	if len(match) >= 3 {
+		if id := metautil.FirstNonEmptyTrimmed(match[1], match[2]); id != "" {
+			return id, true
+		}
+	}
+	for _, text := range successTexts {
+		if strings.Contains(responseBody, text) {
+			return "", true
+		}
+	}
+	return "", false
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "IS",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "is",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrentfile",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, []*http.Cookie, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	fields := map[string]string{
+		"UseNFOasDescr": "no",
+		"message":       buildMessage(req.Meta),
+		"category":      strconv.Itoa(resolveCategoryID(req.Meta)),
+		"subject":       resolveSubject(req.Meta),
+		"nothingtopost": "1",
+		"t_image_url":   resolvePoster(req.Meta),
+		"submit":        "Upload Torrent",
+		"anonymous":     yesNo(req.TrackerConfig.Anon),
+	}
+	if strings.EqualFold(categoryOf(req.Meta), "MOVIE") {
+		fields["t_link"] = resolveIMDbURL(req.Meta)
+	}
+	state := uploadState{
+		torrentPath: torrentPath,
+		description: description,
+		releaseName: fields["subject"],
+		fields:      fields,
+	}
+	if strings.TrimSpace(fields["t_image_url"]) == "" {
+		state.blockedReason = "missing poster URL"
+	}
+	if file, ok := resolveNFO(req.Meta); ok {
+		state.nfo = &file
+	}
+	return state, cookies, nil
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "IS", "immortalseed.me")
+	if err != nil {
+		return values, fmt.Errorf("trackers: IS load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	parts := make([]string, 0, 8)
+	if strings.TrimSpace(meta.EpisodeOverview) != "" {
+		parts = append(parts, "Title: "+strings.TrimSpace(meta.EpisodeTitle), "Overview: "+strings.TrimSpace(meta.EpisodeOverview))
+	}
+	if media := trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta); media != "" {
+		parts = append(parts, media)
+	}
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+	if len(assets.MenuImages) > 0 {
+		var menuLines []string
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			menuLines = append(menuLines, header)
+		}
+		for _, image := range assets.MenuImages {
+			if strings.TrimSpace(image.RawURL) != "" {
+				menuLines = append(menuLines, image.RawURL)
+			}
+		}
+		if len(menuLines) > 0 {
+			parts = append(parts, strings.Join(menuLines, "\n"))
+		}
+	}
+	if len(assets.Screenshots) > 0 {
+		var shotLines []string
+		for _, image := range assets.Screenshots {
+			if strings.TrimSpace(image.RawURL) != "" {
+				shotLines = append(shotLines, image.RawURL)
+			}
+		}
+		if len(shotLines) > 0 {
+			parts = append(parts, "Screenshots:\n"+strings.Join(shotLines, "\n"))
+		}
+	}
+	return finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+}
+
+func buildMessage(meta api.UploadSubject) string {
+	message := strings.TrimSpace(resolveOverview(meta))
+	if trailer := resolveYouTube(meta); trailer != "" {
+		if message != "" {
+			message += "\n\n"
+		}
+		message += "[youtube]" + trailer + "[/youtube]"
+	}
+	return message
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	category := strings.ToUpper(strings.TrimSpace(categoryOf(meta)))
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	genres := strings.ToLower(resolveGenres(meta) + " " + resolveKeywords(meta))
+	nonEnglish := !hasEnglishAudio(meta)
+	switch category {
+	case "TV":
+		if strings.Contains(genres, "documentary") {
+			if isSD(meta) {
+				return 13
+			}
+			return 15
+		}
+		if meta.Anime {
+			return 6
+		}
+		if strings.Contains(genres, "children") || strings.Contains(genres, "cartoon") {
+			return 5
+		}
+		if meta.TVPack {
+			if resolution == "2160p" {
+				return 63
+			}
+			if isSD(meta) {
+				return 6
+			}
+			return 4
+		}
+		if resolution == "2160p" {
+			return 64
+		}
+		if resolution == "1080p" || resolution == "1080i" || resolution == "720p" {
+			return 8
+		}
+		if isSD(meta) {
+			if strings.Contains(strings.ToLower(meta.VideoEncode), "xvid") {
+				return 9
+			}
+			return 48
+		}
+		return 47
+	default:
+		if strings.Contains(genres, "documentary") {
+			if isSD(meta) {
+				return 13
+			}
+			return 15
+		}
+		if meta.Anime {
+			return 6
+		}
+		if resolution == "2160p" {
+			if nonEnglish {
+				return 60
+			}
+			return 62
+		}
+		if !isSD(meta) {
+			if nonEnglish {
+				return 18
+			}
+			return 16
+		}
+		if isSD(meta) {
+			if nonEnglish {
+				return 33
+			}
+			return 14
+		}
+		if nonEnglish {
+			return 34
+		}
+		return 17
+	}
+}
+
+func hasEnglishAudio(meta api.UploadSubject) bool {
+	for _, language := range meta.AudioLanguages {
+		lower := strings.ToLower(strings.TrimSpace(language))
+		if lower == "english" || lower == "en" {
+			return true
+		}
+	}
+	return false
+}
+
+func resolveSubject(meta api.UploadSubject) string {
+	if meta.Scene && strings.TrimSpace(meta.SceneName) != "" {
+		return strings.TrimSpace(meta.SceneName)
+	}
+	name := strings.TrimSpace(meta.ReleaseName)
+	name = strings.ReplaceAll(name, strings.TrimSpace(meta.Release.Alt), "")
+	name = strings.ReplaceAll(name, "Dubbed", "")
+	name = strings.ReplaceAll(name, "Dual-Audio", "")
+	name = strings.Join(strings.Fields(name), ".")
+	return strings.Trim(name, ".")
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster)
+	case meta.ProviderMetadata.IMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	case meta.ProviderMetadata.TVmaze != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Poster)
+	default:
+		return ""
+	}
+}
+
+func resolveIMDbURL(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL)
+	}
+	if meta.Identity.IMDBID > 0 {
+		return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+	}
+	return ""
+}
+
+func resolveOverview(meta api.UploadSubject) string {
+	switch {
+	case meta.ProviderMetadata.TMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview)
+	case meta.ProviderMetadata.IMDB != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot)
+	case meta.ProviderMetadata.TVmaze != nil:
+		return strings.TrimSpace(meta.ProviderMetadata.TVmaze.Summary)
+	default:
+		return strings.TrimSpace(meta.EpisodeOverview)
+	}
+}
+
+func resolveYouTube(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	return ""
+}
+
+func resolveGenres(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
+	}
+	return strings.TrimSpace(meta.Release.Genre)
+}
+
+func resolveKeywords(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+	}
+	return ""
+}
+
+func resolveNFO(meta api.UploadSubject) (commonhttp.FileField, bool) {
+	dir := filepath.Dir(metautil.FirstNonEmptyTrimmed(meta.MediaInfoTextPath, meta.SourcePath))
+	payload, path, err := commonhttp.ReadFirstMatching(dir, "*.nfo")
+	if err != nil {
+		return commonhttp.FileField{}, false
+	}
+	return commonhttp.FileField{
+		FieldName: "nfofile",
+		FileName:  filepath.Base(path),
+		Content:   payload,
+	}, true
+}
+
+func isSD(meta api.UploadSubject) bool {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	return resolution == "" || resolution == "480p" || resolution == "576p"
+}
+
+func categoryOf(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return string(category)
+}
+
+func yesNo(value bool) string {
+	if value {
+		return "yes"
+	}
+	return "no"
+}
diff --git a/internal/trackers/impl/is/upload_test.go b/internal/trackers/impl/standalone/is/upload_test.go
similarity index 100%
rename from internal/trackers/impl/is/upload_test.go
rename to internal/trackers/impl/standalone/is/upload_test.go
diff --git a/internal/trackers/impl/standalone/mtv/banned_groups.go b/internal/trackers/impl/standalone/mtv/banned_groups.go
new file mode 100644
index 00000000..5018ff96
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/banned_groups.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+// bannedGroups returns MTV's static release-group blacklist.
+func bannedGroups() []string {
+	return []string{
+		"3LTON",
+		"[Oj]",
+		"aXXo",
+		"BDP",
+		"BRrip",
+		"CM8",
+		"CrEwSaDe",
+		"CMCT",
+		"DeadFish",
+		"DNL",
+		"ELiTE",
+		"AFG",
+		"ZMNT",
+		"FaNGDiNG0",
+		"FRDS",
+		"FUM",
+		"h65",
+		"HD2DVD",
+		"HDTime",
+		"ION10",
+		"iPlanet",
+		"JIVE",
+		"KiNGDOM",
+		"LAMA",
+		"Leffe",
+		"LOAD",
+		"mHD",
+		"mRS",
+		"mSD",
+		"NhaNc3",
+		"nHD",
+		"nikt0",
+		"nSD",
+		"PandaRG",
+		"PRODJi",
+		"QxR",
+		"RARBG",
+		"RDN",
+		"SANTi",
+		"STUTTERSHIT",
+		"TERMiNAL",
+		"TM",
+		"ViSiON",
+		"WAF",
+		"x0r",
+		"XS",
+		"YIFY",
+		"ZKBL",
+		"ZmN",
+	}
+}
diff --git a/internal/trackers/impl/standalone/mtv/definition.go b/internal/trackers/impl/standalone/mtv/definition.go
new file mode 100644
index 00000000..1c4d4443
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/definition.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	var err error
+	assets := trackers.DescriptionAssets{}
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
+			}
+			if req.Logger != nil {
+				req.Logger.Warnf("trackers: MTV description assets failed: %v", err)
+			}
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+
+	description := strings.TrimSpace(assets.Description)
+	if !assets.Final {
+		description, err = BuildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets.Description, assets.Screenshots)
+		if err != nil {
+			return trackers.DescriptionResult{}, fmt.Errorf("trackers: MTV description build: %w", err)
+		}
+	}
+
+	if strings.TrimSpace(description) == "" && req.Logger != nil {
+		req.Logger.Infof("trackers: MTV preparation description empty")
+	}
+
+	return trackers.DescriptionResult{
+		Group:       "mtv",
+		Description: description,
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/mtv/definition_test.go b/internal/trackers/impl/standalone/mtv/definition_test.go
new file mode 100644
index 00000000..ffe2c452
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/definition_test.go
@@ -0,0 +1,195 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDefinitionBuildDescriptionUsesMTVGroup(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "MTV",
+		Meta:    api.UploadSubject{},
+		Logger:  api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result.Group != "mtv" {
+		t.Fatalf("expected mtv group, got %q", result.Group)
+	}
+}
+
+func TestDefinitionUploadMissingCookieFile(t *testing.T) {
+	_, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "MTV",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(t.TempDir(), "ua.db")}}),
+		Logger:  api.NopLogger{},
+	}, mtvBaseURL)
+	if err == nil {
+		t.Fatal("expected missing cookie file error")
+	}
+}
+
+func TestDefinitionUploadSuccess(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "ua.db")
+	cookieDir := filepath.Join(tmp, "cookies")
+	if err := os.MkdirAll(cookieDir, 0o755); err != nil {
+		t.Fatalf("mkdir cookie dir: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(cookieDir, "MTV.json"), []byte(`{"session":"cookievalue"}`), 0o600); err != nil {
+		t.Fatalf("write cookie file: %v", err)
+	}
+	torrentPath := filepath.Join(tmp, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/index.php":
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("...authkey=1234567890abcdef1234567890abcdef..."))
+		case "/upload.php":
+			if err := r.ParseMultipartForm(5 << 20); err != nil {
+				t.Errorf("parse multipart: %v", err)
+				return
+			}
+			if r.FormValue("auth") == "" {
+				t.Error("expected auth field")
+				return
+			}
+			http.Redirect(w, r, "/torrents.php?id=55", http.StatusFound)
+		case "/torrents.php":
+			w.WriteHeader(http.StatusOK)
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	result, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "MTV",
+		Meta: api.UploadSubject{
+			SourcePath:      filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:     torrentPath,
+			Identity:        api.ExternalIdentity{Category: "MOVIE"},
+			Type:            "WEBDL",
+			VideoCodec:      "HEVC",
+			ReleaseName:     "My.Release.2026.2160p.WEBDL.HEVC",
+			ServiceLongName: "Netflix",
+		},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:        api.NopLogger{},
+	}, server.URL)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
+	}
+}
+
+func TestDefinitionUploadLoginBootstrapSuccess(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "ua.db")
+	torrentPath := filepath.Join(tmp, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			if r.Method == http.MethodGet {
+				w.WriteHeader(http.StatusOK)
+				_, _ = w.Write([]byte(`<input name="token" value="123456789012345678901234567890123456789012345678"/>`))
+				return
+			}
+			if err := r.ParseForm(); err != nil {
+				t.Errorf("parse login form: %v", err)
+				return
+			}
+			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
+				t.Error("unexpected login credentials")
+				return
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "cookievalue",
+				Path:  "/",
+			})
+			http.Redirect(w, r, "/index.php", http.StatusFound)
+		case "/index.php":
+			if _, err := r.Cookie("session"); err != nil {
+				w.WriteHeader(http.StatusUnauthorized)
+				return
+			}
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("...authkey=abcdefabcdefabcdefabcdefabcdefab..."))
+		case "/upload.php":
+			if err := r.ParseMultipartForm(5 << 20); err != nil {
+				t.Errorf("parse multipart: %v", err)
+				return
+			}
+			if r.FormValue("auth") == "" {
+				t.Error("expected auth field")
+				return
+			}
+			http.Redirect(w, r, "/torrents.php?id=99", http.StatusFound)
+		case "/torrents.php":
+			if _, err := url.ParseRequestURI(r.RequestURI); err != nil {
+				t.Errorf("invalid request uri: %v", err)
+				return
+			}
+			w.WriteHeader(http.StatusOK)
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	result, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "MTV",
+		Meta: api.UploadSubject{
+			SourcePath:      filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath:     torrentPath,
+			Identity:        api.ExternalIdentity{Category: "MOVIE"},
+			Type:            "WEBDL",
+			VideoCodec:      "HEVC",
+			ReleaseName:     "My.Release.2026.2160p.WEBDL.HEVC",
+			ServiceLongName: "Netflix",
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username: "user",
+			Password: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:  api.NopLogger{},
+	}, server.URL)
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
+	}
+	if _, err := os.Stat(filepath.Join(tmp, "cookies", "MTV.json")); !os.IsNotExist(err) {
+		if err == nil {
+			t.Fatalf("expected no legacy MTV cookie file after login bootstrap; file exists")
+		}
+		t.Fatalf("expected no legacy MTV cookie file after login bootstrap; unexpected stat error: %v", err)
+	}
+}
diff --git a/internal/trackers/impl/standalone/mtv/description.go b/internal/trackers/impl/standalone/mtv/description.go
new file mode 100644
index 00000000..2f05f2fc
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/description.go
@@ -0,0 +1,198 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var mtvQuoteTagPattern = regexp.MustCompile(`(?i)\[/?quote\]`)
+var mtvCollapseLinesPattern = regexp.MustCompile(`\n{3,}`)
+
+var mtvNFOBlockPattern = regexp.MustCompile(
+	`(?is)(?:\[(?:center|align=center)\]\s*)?\[(?:spoiler|hide)=(?:Scene|FraMeSToR) NFO:\](?:\[(?:code|pre)\])?.*?(?:\[/(?:code|pre)\])?\[/(?:spoiler|hide)\](?:\s*\[/(?:center|align)\])?`,
+)
+var mtvURLImagePattern = regexp.MustCompile(`(?is)\[url=[^\]]+\]\s*\[img(?:[^\]]*)?\][^\[]+\[/img\]\s*\[/url\]`)
+var mtvImagePattern = regexp.MustCompile(`(?is)\[img(?:[^\]]*)?\][^\[]+\[/img\]`)
+
+var mtvSignaturePattern = regexp.MustCompile(
+	`(?is)\[(?:right|align=right)\]\s*\[url=https://github\.com/(?:Audionut|autobrr)/upbrr\].*?\[/url\]\s*\[/(?:right|align)\]`,
+)
+var mtvEmptyAlignPattern = regexp.MustCompile(`(?is)\[(?:center|right|left|align=(?:center|right|left))\]\s*\[/(?:center|right|left|align)\]`)
+
+// BuildDescription assembles MTV's media details, eligible tone-mapping header,
+// screenshots, and sanitized kept notes. Missing media files are ignored, while
+// other read failures and context cancellation are returned.
+func BuildDescription(
+	ctx context.Context,
+	meta api.UploadSubject,
+	appConfig config.Config,
+	keptDescription string,
+	screenshots []api.ScreenshotImage,
+) (string, error) {
+	select {
+	case <-ctx.Done():
+		return "", fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	parts := make([]string, 0, 8)
+
+	mediaBlock, err := buildMediaInfoBlock(meta, appConfig.MainSettings.DBPath)
+	if err != nil {
+		return "", err
+	}
+	if mediaBlock != "" {
+		parts = append(parts, mediaBlock)
+	}
+
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") && strings.TrimSpace(meta.DVDVOBMediaInfoText) != "" {
+		parts = append(parts, "[mediainfo]"+strings.TrimSpace(meta.DVDVOBMediaInfoText)+"[/mediainfo]")
+	}
+
+	if shouldIncludeTonemappedHeader(meta, appConfig, screenshots) {
+		header := strings.TrimSpace(appConfig.Description.TonemappedHeader)
+		if header != "" {
+			parts = append(parts, header)
+		}
+	}
+
+	if section := buildScreenshotSection(screenshots); section != "" {
+		parts = append(parts, section)
+	}
+
+	base := sanitizeNotes(keptDescription)
+	if base != "" {
+		parts = append(parts, "[spoiler=Notes]"+base+"[/spoiler]")
+	}
+
+	return normalize(strings.Join(parts, "\n\n")), nil
+}
+
+func buildMediaInfoBlock(meta api.UploadSubject, dbPath string) (string, error) {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		bdInfoPath, err := resolveBDInfoPath(meta, dbPath)
+		if err != nil {
+			return "", err
+		}
+		if strings.TrimSpace(bdInfoPath) != "" {
+			text, err := os.ReadFile(bdInfoPath)
+			if err != nil {
+				if !os.IsNotExist(err) {
+					return "", fmt.Errorf("description: MTV read BDInfo file: %w", err)
+				}
+			} else {
+				trimmed := strings.TrimSpace(string(text))
+				if trimmed != "" {
+					return "[mediainfo]" + trimmed + "[/mediainfo]", nil
+				}
+			}
+		}
+	}
+
+	if strings.TrimSpace(meta.MediaInfoTextPath) != "" {
+		text, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+		if err != nil {
+			if !os.IsNotExist(err) {
+				return "", fmt.Errorf("description: MTV read MediaInfo file: %w", err)
+			}
+		} else {
+			trimmed := strings.TrimSpace(string(text))
+			if trimmed != "" {
+				return "[mediainfo]" + trimmed + "[/mediainfo]", nil
+			}
+		}
+	}
+
+	return "", nil
+}
+
+func resolveBDInfoPath(meta api.UploadSubject, dbPath string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" {
+		return "", nil
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("description: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("description: %w", err)
+	}
+	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists))
+	if strings.TrimSpace(path) == "" {
+		return "", nil
+	}
+	if _, err := os.Stat(path); err != nil {
+		if os.IsNotExist(err) {
+			return "", nil
+		}
+		return "", fmt.Errorf("description: MTV stat BDInfo summary: %w", err)
+	}
+	return path, nil
+}
+
+func buildScreenshotSection(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(images))
+	for _, image := range images {
+		imgURL := strings.TrimSpace(image.ImgURL)
+		if imgURL == "" {
+			imgURL = strings.TrimSpace(image.RawURL)
+		}
+		rawURL := strings.TrimSpace(image.RawURL)
+		if rawURL == "" {
+			rawURL = imgURL
+		}
+		if imgURL == "" {
+			continue
+		}
+		if rawURL != "" {
+			parts = append(parts, "[url="+rawURL+"][img=250]"+imgURL+"[/img][/url]")
+			continue
+		}
+		parts = append(parts, "[img=250]"+imgURL+"[/img]")
+	}
+	return strings.Join(parts, "")
+}
+
+func normalize(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	return strings.TrimSpace(mtvCollapseLinesPattern.ReplaceAllString(trimmed, "\n\n"))
+}
+
+func sanitizeNotes(value string) string {
+	cleaned := mtvQuoteTagPattern.ReplaceAllString(value, "")
+	cleaned = mtvNFOBlockPattern.ReplaceAllString(cleaned, "")
+	cleaned = mtvURLImagePattern.ReplaceAllString(cleaned, "")
+	cleaned = mtvImagePattern.ReplaceAllString(cleaned, "")
+	cleaned = mtvSignaturePattern.ReplaceAllString(cleaned, "")
+	cleaned = mtvEmptyAlignPattern.ReplaceAllString(cleaned, "")
+	return normalize(cleaned)
+}
+
+func shouldIncludeTonemappedHeader(meta api.UploadSubject, appConfig config.Config, screenshots []api.ScreenshotImage) bool {
+	if !appConfig.ScreenshotHandling.ToneMap {
+		return false
+	}
+	if len(screenshots) == 0 {
+		return false
+	}
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	return strings.Contains(hdr, "HDR") || strings.Contains(hdr, "DV")
+}
diff --git a/internal/trackers/impl/standalone/mtv/description_test.go b/internal/trackers/impl/standalone/mtv/description_test.go
new file mode 100644
index 00000000..6512f6b1
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/description_test.go
@@ -0,0 +1,132 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesMediaInfoAndNotes(t *testing.T) {
+	dir := t.TempDir()
+	miPath := filepath.Join(dir, "MEDIAINFO.txt")
+	if err := os.WriteFile(miPath, []byte("MI_CONTENT"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	meta := api.UploadSubject{
+		MediaInfoTextPath: miPath,
+	}
+
+	desc, err := BuildDescription(context.Background(), meta, config.Config{}, "[quote]note[/quote]", nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(desc, "[mediainfo]MI_CONTENT[/mediainfo]") {
+		t.Fatalf("expected mediainfo block, got %q", desc)
+	}
+	if !strings.Contains(desc, "[spoiler=Notes]note[/spoiler]") {
+		t.Fatalf("expected notes spoiler, got %q", desc)
+	}
+}
+
+func TestBuildDescriptionIncludesTonemapAndScreenshots(t *testing.T) {
+	meta := api.UploadSubject{HDR: "HDR10"}
+	cfg := config.Config{
+		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
+		Description:        config.DescriptionSettingsConfig{TonemappedHeader: "[center]tone[/center]"},
+	}
+	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
+
+	desc, err := BuildDescription(context.Background(), meta, cfg, "", screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(desc, "[center]tone[/center]") {
+		t.Fatalf("expected tonemap header, got %q", desc)
+	}
+	if !strings.Contains(desc, "[url=https://raw/1][img=250]https://img/1.jpg[/img][/url]") {
+		t.Fatalf("expected mtv screenshot bbcode, got %q", desc)
+	}
+}
+
+func TestBuildDescriptionSkipsTonemapHeaderForNonHDR(t *testing.T) {
+	meta := api.UploadSubject{}
+	cfg := config.Config{
+		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
+		Description:        config.DescriptionSettingsConfig{TonemappedHeader: "[center]tone[/center]"},
+	}
+	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
+
+	desc, err := BuildDescription(context.Background(), meta, cfg, "", screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(desc, "[center]tone[/center]") {
+		t.Fatalf("did not expect tonemap header for non-HDR content, got %q", desc)
+	}
+}
+
+func TestBuildDescriptionStripsNFOFromNotes(t *testing.T) {
+	meta := api.UploadSubject{}
+	kept := "[center][spoiler=Scene NFO:][code]scene nfo[/code][/spoiler][/center]\n\nActual note"
+
+	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(desc, "scene nfo") {
+		t.Fatalf("expected nfo removed from notes, got %q", desc)
+	}
+	if !strings.Contains(desc, "[spoiler=Notes]Actual note[/spoiler]") {
+		t.Fatalf("expected cleaned notes spoiler, got %q", desc)
+	}
+}
+
+func TestBuildDescriptionStripsImagesFromNotesWhenScreenshotsProvided(t *testing.T) {
+	meta := api.UploadSubject{}
+	kept := "[url=https://raw/1][img=250]https://img/1.jpg[/img][/url]\n\nSome note"
+	screens := []api.ScreenshotImage{{RawURL: "https://raw/1", ImgURL: "https://img/1.jpg"}}
+
+	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Count(desc, "https://img/1.jpg") != 1 {
+		t.Fatalf("expected screenshot included once, got %q", desc)
+	}
+	if !strings.Contains(desc, "[spoiler=Notes]Some note[/spoiler]") {
+		t.Fatalf("expected notes without duplicated screenshot tags, got %q", desc)
+	}
+}
+
+func TestBuildDescriptionStripsWidthImagesAndSignatureFromNotes(t *testing.T) {
+	meta := api.UploadSubject{}
+	kept := `[align=center]
+[url=https://pixhost.to/fv71hr.png][img width=350]https://pixhost.to/fv71hr.png[/img][/url]
+[/align]
+
+[align=right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/align]`
+	screens := []api.ScreenshotImage{{RawURL: "https://pixhost.to/fv71hr.png", ImgURL: "https://pixhost.to/fv71hr.png"}}
+
+	desc, err := BuildDescription(context.Background(), meta, config.Config{}, kept, screens)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if strings.Contains(desc, "[spoiler=Notes]") {
+		t.Fatalf("expected notes section omitted when only screenshots/signature remain, got %q", desc)
+	}
+	if strings.Count(desc, "https://pixhost.to/fv71hr.png") != 2 {
+		t.Fatalf("expected one screenshot block only, got %q", desc)
+	}
+	if strings.Contains(desc, "upbrr") {
+		t.Fatalf("expected default signature removed from notes, got %q", desc)
+	}
+}
diff --git a/internal/trackers/impl/standalone/mtv/dupe.go b/internal/trackers/impl/standalone/mtv/dupe.go
new file mode 100644
index 00000000..c437435b
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/dupe.go
@@ -0,0 +1,211 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const mtvTorznabEndpoint = "https://www.morethantv.me/api/torznab"
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := mtvAPIKey(h.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+
+	params := url.Values{}
+	params.Set("t", "search")
+	params.Set("apikey", apiKey)
+	params.Set("limit", "100")
+
+	switch {
+	case meta.Identity.IMDBID != 0:
+		params.Set("imdbid", "tt"+strconv.Itoa(meta.Identity.IMDBID))
+	case meta.Identity.TMDBID != 0:
+		params.Set("tmdbid", strconv.Itoa(meta.Identity.TMDBID))
+	case isMTVTVCategory(meta) && meta.Identity.TVDBID != 0:
+		params.Set("tvdbid", strconv.Itoa(meta.Identity.TVDBID))
+	default:
+		query := cleanMTVSearchTitle(meta)
+		if query == "" {
+			return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb/tmdb/tvdb id or title for MTV dupe search", nil)
+		}
+		params.Set("q", query)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, mtvTorznabEndpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "MTV search failed", fmt.Errorf("build MTV request: %w", err))
+	}
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := h.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "MTV search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return dupe.Failed(dupe.FailureResponseStatus, "MTV search failed", nil)
+	}
+
+	var payload mtvRSS
+	if err := xml.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "MTV response parse failed", err)
+	}
+
+	entries := make([]api.DupeEntry, 0, len(payload.Channel.Items))
+	for _, item := range payload.Channel.Items {
+		title := strings.TrimSpace(item.Title)
+		if title == "" {
+			continue
+		}
+
+		fileCount := parsePositiveInt(item.Files)
+		sizeBytes := parsePositiveInt64(item.Size)
+		for _, attr := range item.allAttrs() {
+			name := strings.ToLower(strings.TrimSpace(attr.Name))
+			value := strings.TrimSpace(attr.Value)
+			switch {
+			case fileCount == 0 && (name == "files" || name == "file_count" || name == "filecount"):
+				fileCount = parsePositiveInt(value)
+			case sizeBytes == 0 && name == "size":
+				sizeBytes = parsePositiveInt64(value)
+			}
+		}
+
+		guid := strings.TrimSpace(item.GUID)
+		download := strings.TrimSpace(item.Link)
+		if download == "" {
+			download = strings.TrimSpace(item.Enclosure.URL)
+		}
+
+		entry := api.DupeEntry{
+			Name:      title,
+			Files:     []string{title},
+			FileCount: fileCount,
+			ID:        guid,
+			Link:      guid,
+			Download:  strings.ReplaceAll(download, "&amp;", "&"),
+		}
+		if sizeBytes > 0 {
+			entry.SizeKnown = true
+			entry.SizeBytes = sizeBytes
+		}
+		entries = append(entries, entry)
+	}
+
+	return dupe.Resolved(entries, nil)
+}
+
+// isMTVTVCategory reports whether MTV torznab searches may use a TVDB ID query.
+// Canonical movie identity suppresses TVDB queries.
+func isMTVTVCategory(meta api.DuplicateSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func cleanMTVSearchTitle(meta api.DuplicateSubject) string {
+	query := strings.TrimSpace(meta.Release.Title)
+	if query == "" {
+		query = strings.TrimSpace(meta.ReleaseName)
+	}
+	if query == "" {
+		return ""
+	}
+	query = strings.ReplaceAll(query, ": ", " ")
+	query = strings.ReplaceAll(query, "’", "")
+	query = strings.ReplaceAll(query, "'", "")
+	return strings.Join(strings.Fields(query), " ")
+}
+
+func parsePositiveInt(value string) int {
+	parsed, err := strconv.Atoi(strings.TrimSpace(value))
+	if err != nil || parsed <= 0 {
+		return 0
+	}
+	return parsed
+}
+
+func parsePositiveInt64(value string) int64 {
+	parsed, err := strconv.ParseInt(strings.TrimSpace(value), 10, 64)
+	if err != nil || parsed <= 0 {
+		return 0
+	}
+	return parsed
+}
+
+type mtvRSS struct {
+	Channel mtvChannel `xml:"channel"`
+}
+
+type mtvChannel struct {
+	Items []mtvItem `xml:"item"`
+}
+
+type mtvItem struct {
+	Title        string       `xml:"title"`
+	Files        string       `xml:"files"`
+	Size         string       `xml:"size"`
+	GUID         string       `xml:"guid"`
+	Link         string       `xml:"link"`
+	Enclosure    mtvEnclosure `xml:"enclosure"`
+	Attrs        []mtvAttr    `xml:"attr"`
+	TorznabAttrs []mtvAttr    `xml:"http://torznab.com/schemas/2015/feed attr"`
+}
+
+func (i mtvItem) allAttrs() []mtvAttr {
+	if len(i.Attrs) == 0 {
+		return i.TorznabAttrs
+	}
+	if len(i.TorznabAttrs) == 0 {
+		return i.Attrs
+	}
+	combined := make([]mtvAttr, 0, len(i.Attrs)+len(i.TorznabAttrs))
+	combined = append(combined, i.Attrs...)
+	combined = append(combined, i.TorznabAttrs...)
+	return combined
+}
+
+type mtvAttr struct {
+	Name  string `xml:"name,attr"`
+	Value string `xml:"value,attr"`
+}
+
+type mtvEnclosure struct {
+	URL string `xml:"url,attr"`
+}
+
+func mtvAPIKey(cfg config.Config) string {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "MTV") {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/mtv/dupe_test.go b/internal/trackers/impl/standalone/mtv/dupe_test.go
new file mode 100644
index 00000000..f64530f1
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/dupe_test.go
@@ -0,0 +1,281 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+func TestMTVHandlerUsesIMDBPriorityAndParsesXML(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			if req.Method != http.MethodGet {
+				t.Fatalf("expected GET request, got %s", req.Method)
+			}
+			if got := req.URL.String(); !strings.HasPrefix(got, mtvTorznabEndpoint+"?") {
+				t.Fatalf("unexpected endpoint %q", got)
+			}
+
+			query := req.URL.Query()
+			assertQueryParam(t, query, "t", "search")
+			assertQueryParam(t, query, "apikey", "token")
+			assertQueryParam(t, query, "limit", "100")
+			assertQueryParam(t, query, "imdbid", "tt123456")
+			if got := query.Get("tmdbid"); got != "" {
+				t.Fatalf("tmdbid should be empty when imdbid is present, got %q", got)
+			}
+			if got := query.Get("tvdbid"); got != "" {
+				t.Fatalf("tvdbid should be empty when imdbid is present, got %q", got)
+			}
+			if got := query.Get("q"); got != "" {
+				t.Fatalf("q should be empty when imdbid is present, got %q", got)
+			}
+
+			body := `<?xml version="1.0" encoding="UTF-8"?>
+<rss xmlns:torznab="http://torznab.com/schemas/2015/feed">
+  <channel>
+    <item>
+      <title>Example.Release.1080p.WEB-DL.DDP5.1.H.264-GRP</title>
+      <files>3</files>
+      <size>123456789</size>
+      <guid>https://www.morethantv.me/torrents.php?id=100</guid>
+      <link>https://www.morethantv.me/download.php/100?torrent_pass=abc&amp;https=1</link>
+    </item>
+    <item>
+      <title>Example.Release.2160p.WEB-DL.DDP5.1.HEVC-GRP</title>
+      <guid>https://www.morethantv.me/torrents.php?id=101</guid>
+      <link>https://www.morethantv.me/download.php/101?torrent_pass=abc&amp;https=1</link>
+      <torznab:attr name="files" value="7" />
+      <torznab:attr name="size" value="222333444" />
+    </item>
+  </channel>
+</rss>`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "MTV",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"MTV": {APIKey: "token"},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{
+			IMDBID: 123456,
+			TMDBID: 999,
+			TVDBID: 888,
+		},
+		Release: api.ReleaseInfo{Title: "Ignored Title"},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 2 {
+		t.Fatalf("expected 2 entries, got %d", len(entries))
+	}
+
+	first := entries[0]
+	if first.Name != "Example.Release.1080p.WEB-DL.DDP5.1.H.264-GRP" {
+		t.Fatalf("unexpected first entry name %q", first.Name)
+	}
+	if first.FileCount != 3 {
+		t.Fatalf("expected file_count=3, got %d", first.FileCount)
+	}
+	if !first.SizeKnown || first.SizeBytes != 123456789 {
+		t.Fatalf("expected parsed size for first entry, got known=%t size=%d", first.SizeKnown, first.SizeBytes)
+	}
+	if first.ID != "https://www.morethantv.me/torrents.php?id=100" {
+		t.Fatalf("unexpected first entry ID %q", first.ID)
+	}
+	if first.Link != "https://www.morethantv.me/torrents.php?id=100" {
+		t.Fatalf("unexpected first entry link %q", first.Link)
+	}
+	if first.Download != "https://www.morethantv.me/download.php/100?torrent_pass=abc&https=1" {
+		t.Fatalf("unexpected first entry download %q", first.Download)
+	}
+	if len(first.Files) != 1 || first.Files[0] != first.Name {
+		t.Fatalf("expected first entry files to contain release title, got %#v", first.Files)
+	}
+
+	second := entries[1]
+	if second.FileCount != 7 {
+		t.Fatalf("expected attr-derived file_count=7, got %d", second.FileCount)
+	}
+	if !second.SizeKnown || second.SizeBytes != 222333444 {
+		t.Fatalf("expected attr-derived size, got known=%t size=%d", second.SizeKnown, second.SizeBytes)
+	}
+}
+
+func TestMTVHandlerFallsBackToCleanedTitleQuery(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			query := req.URL.Query()
+			assertQueryParam(t, query, "t", "search")
+			assertQueryParam(t, query, "apikey", "token")
+			assertQueryParam(t, query, "limit", "100")
+			assertQueryParam(t, query, "q", "Johns Story The Return")
+			if got := query.Get("imdbid"); got != "" {
+				t.Fatalf("imdbid should be empty, got %q", got)
+			}
+			body := `<rss><channel></channel></rss>`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "MTV",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"MTV": {APIKey: "token"},
+				},
+			},
+		}, client, api.NopLogger{})
+	meta := api.DuplicateSubject{Release: api.ReleaseInfo{Title: "John's Story: The Return"}}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+func TestMTVHandlerSkipsTVDBForMovie(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			query := req.URL.Query()
+			assertQueryParam(t, query, "q", "Movie Title")
+			if got := query.Get("tvdbid"); got != "" {
+				t.Fatalf("tvdbid should be empty for movie category, got %q", got)
+			}
+			body := `<rss><channel></channel></rss>`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "MTV",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"MTV": {APIKey: "token"},
+				},
+			},
+		}, client, api.NopLogger{})
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE", TVDBID: 888},
+		Release:  api.ReleaseInfo{Title: "Movie Title"},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+func TestMTVHandlerUsesTVDBForTV(t *testing.T) {
+	t.Parallel()
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			query := req.URL.Query()
+			assertQueryParam(t, query, "tvdbid", "888")
+			if got := query.Get("q"); got != "" {
+				t.Fatalf("q should be empty when tvdbid is present, got %q", got)
+			}
+			body := `<rss><channel></channel></rss>`
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader(body)),
+				Header:     make(http.Header),
+			}, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "MTV",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"MTV": {APIKey: "token"},
+				},
+			},
+		}, client, api.NopLogger{})
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 888},
+		Release:  api.ReleaseInfo{Title: "Show Title"},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+func assertQueryParam(t *testing.T, query url.Values, key string, expected string) {
+	t.Helper()
+	if got := query.Get(key); got != expected {
+		t.Fatalf("unexpected %s query value: got %q want %q", key, got, expected)
+	}
+}
diff --git a/internal/trackers/impl/standalone/mtv/profile.go b/internal/trackers/impl/standalone/mtv/profile.go
new file mode 100644
index 00000000..0bbf8bba
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/profile.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns MTV identity, preparation, dupe, auth, bans, and policies.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:               "MTV",
+		BaseURL:            mtvBaseURL,
+		DescriptionGroup:   "mtv",
+		UploadContentMode:  trackers.UploadContentModeDescription,
+		PrepareDescription: prepareDescription,
+		PrepareUpload: func(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return prepareUploadAt(ctx, req, mtvBaseURL)
+		},
+		NewDuplicateAdapter: newDuplicateAdapter,
+		BannedGroups:        bannedGroups(),
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{
+				{
+					Scope:       trackers.MetadataScopeAny,
+					AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB, trackers.MetadataFieldTVDB},
+					Disposition: api.RuleDispositionStrict,
+				},
+			},
+		},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "MTV"},
+		AudioPolicy:          &trackers.AudioPolicy{BlockEnglishOriginalWithForeign: true},
+		ImageHostPolicy:      &trackers.ImageHostPolicy{AllowedHosts: []string{"imgbox", "imgbb"}},
+		DupePolicy:           &trackers.DupePolicy{ContainsFilenameMatch: true, NormalizeMTVName: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"tracker.morethantv"}, SearchPreference: trackers.TorrentSearchPreferenceSmallPieces,
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:          "MTV",
+			DisplayName:        "MTV",
+			AuthKind:           "api_key_cookies_login_manual_2fa",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+			SupportsTOTP:       true,
+			SupportsManual2FA:  true,
+			RequiresAPIKey:     true,
+			Notes:              []string{"API key covers Torznab/search; cookies/login cover upload authkey."},
+		},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+			return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, login, mtvBaseURL)
+		},
+		AuthPolicy: &trackers.AuthPolicy{
+			APIKeyRequiresUploadSession: true,
+			CookieCompletesAPIKeyAuth:   true,
+			UploadSessionMissingMessage: "API key covers Torznab/search; imported cookies or login credentials required for upload auth",
+		},
+	}
+}
+
+// New returns a fresh MTV definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/mtv/upload.go b/internal/trackers/impl/standalone/mtv/upload.go
new file mode 100644
index 00000000..64825bf5
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/upload.go
@@ -0,0 +1,884 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
+	"encoding/base32"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	mtvBaseURL      = "https://www.morethantv.me"
+	mtvUploadPath   = "/upload.php"
+	mtvIndexPath    = "/index.php"
+	mtvUserAgentWeb = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+)
+
+var mtvTokenPattern = regexp.MustCompile(`name="token"\s+value="([^"]{16,128})"`)
+
+// ErrSubmitted2FARejected marks an MTV failure after a submitted manual 2FA code
+// reached the tracker and was rejected.
+var ErrSubmitted2FARejected = trackers.ErrSubmitted2FARejected
+
+var errMTVAuthKeyNotFound = errors.New("trackers: MTV auth key not found")
+
+func uploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (api.UploadSummary, error) {
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, baseURL)
+	})
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: MTV submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (trackers.PreparedOperation, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.PreparedOperation{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	uploadURL := baseURL + mtvUploadPath
+
+	assets := trackers.DescriptionAssets{}
+	var err error
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+	descText := strings.TrimSpace(assets.Description)
+	if !assets.Final {
+		descText, err = BuildDescription(ctx, req.Meta, req.Runtime.DescriptionConfig(), assets.Description, assets.Screenshots)
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	previewFields := buildUploadFields(req, "[redacted]", descText)
+	preview := standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "MTV",
+		ReadyMessage:     "dry-run payload generated (auth placeholder used)",
+		ReleaseName:      resolveUploadName(req.Meta),
+		DescriptionGroup: "mtv",
+		Description:      descText,
+		Endpoint:         uploadURL,
+		Payload:          previewFields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    torrentPath,
+			Present: strings.TrimSpace(torrentPath) != "",
+		}},
+	})
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	cookies, err := loadMTVCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		cookies = nil
+	}
+	auth, client, err := resolveAuthKey(ctx, baseURL, cookies)
+	if err != nil {
+		if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
+			if cookies == nil {
+				return trackers.PreparedOperation{}, errors.New("trackers: MTV cookie invalid/missing and username/password not configured")
+			}
+			return trackers.PreparedOperation{}, err
+		}
+		var effectiveBaseURL string
+		auth, client, cookies, effectiveBaseURL, err = loginAndResolveAuthKey(ctx, req.TrackerConfig, baseURL, api.TrackerAuthLoginRequest{})
+		if err != nil {
+			return trackers.PreparedOperation{}, err
+		}
+		if strings.TrimSpace(effectiveBaseURL) != "" && !strings.EqualFold(effectiveBaseURL, baseURL) {
+			baseURL = effectiveBaseURL
+			uploadURL = baseURL + mtvUploadPath
+		}
+		if persistErr := saveMTVCookies(ctx, req.Runtime.DBPath, cookies); persistErr != nil && req.Logger != nil {
+			req.Logger.Warnf("trackers: MTV failed to persist cookies: %v", persistErr)
+		}
+	}
+
+	fields := buildUploadFields(req, auth, descText)
+	body, contentType, err := buildMultipartPayload(fields, torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, uploadURL, client, body, contentType)
+	}, nil), nil
+}
+
+func submitPreparedUpload(ctx context.Context, uploadURL string, client *http.Client, body []byte, contentType string) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: MTV request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", mtvUserAgentWeb)
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: MTV upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+
+	if resp.StatusCode == http.StatusBadRequest {
+		preview := string(bodyPreview)
+		if strings.Contains(preview, "Request Header") || strings.Contains(preview, "Cookie Too Large") || strings.Contains(preview, "Header Too Large") {
+			return api.UploadSummary{}, errors.New("trackers: MTV data error (request header/cookie too large)")
+		}
+	}
+
+	if strings.Contains(finalURL, "torrents.php") {
+		return api.UploadSummary{Uploaded: 1}, nil
+	}
+
+	return api.UploadSummary{}, commonhttp.UploadHTTPErrorWithURL("MTV", resp.StatusCode, finalURL, bodyPreview)
+}
+
+func resolveAuthKey(ctx context.Context, baseURL string, cookies map[string]string) (string, *http.Client, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV create auth cookie jar: %w", err)
+	}
+	parsedBase, err := url.Parse(baseURL)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV parse base URL: %w", err)
+	}
+	jarCookies := make([]*http.Cookie, 0, len(cookies))
+	for name, value := range cookies {
+		if strings.TrimSpace(name) == "" || strings.TrimSpace(value) == "" {
+			continue
+		}
+		// #nosec G124 -- Outbound tracker jar cookie mirrors configured MTV session values.
+		jarCookies = append(jarCookies, &http.Cookie{
+			Name:   name,
+			Value:  value,
+			Path:   "/",
+			Domain: parsedBase.Hostname(),
+		})
+	}
+	jar.SetCookies(parsedBase, jarCookies)
+
+	client := &http.Client{Timeout: 20 * time.Second, Jar: jar}
+	indexURL := strings.TrimRight(baseURL, "/") + mtvIndexPath
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, indexURL, nil)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV build auth request: %w", err)
+	}
+	req.Header.Set("User-Agent", mtvUserAgentWeb)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV auth request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", nil, fmt.Errorf("trackers: MTV auth key lookup failed %s: auth status %d", mtvResponseTrace(resp), resp.StatusCode)
+	}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV read auth response: %w", err)
+	}
+	auth := extractMTVAuthKey(string(body))
+	if auth == "" {
+		return "", nil, fmt.Errorf("%w: %s", errMTVAuthKeyNotFound, mtvResponseTrace(resp))
+	}
+	return auth, client, nil
+}
+
+func loadMTVCookies(ctx context.Context, dbPath string) (map[string]string, error) {
+	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "MTV")
+	if err != nil {
+		return values, fmt.Errorf("trackers: MTV load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func saveMTVCookies(ctx context.Context, dbPath string, values map[string]string) error {
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "MTV", values); err != nil {
+		return fmt.Errorf("trackers: MTV save cookies: %w", err)
+	}
+	return nil
+}
+
+// ResolveSessionForTrackerAuth validates MTV stored cookies or logs in with
+// configured credentials. After a successful login, cookie persistence failures
+// are returned distinctly from remote authentication failures.
+func ResolveSessionForTrackerAuth(ctx context.Context, cfg config.TrackerConfig, dbPath string) error {
+	return resolveSessionForTrackerAuthAt(ctx, cfg, dbPath, mtvBaseURL)
+}
+
+func resolveSessionForTrackerAuthAt(ctx context.Context, cfg config.TrackerConfig, dbPath string, baseURL string) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{}, baseURL)
+}
+
+// ResolveSessionForTrackerAuthLogin validates MTV stored cookies or logs in
+// with configured credentials. When MTV requires 2FA, login.Code is used before
+// falling back to the configured OTP URI; if neither yields a code, the error
+// is returned before stored cookies are replaced. A rejected submitted code can
+// return [ErrSubmitted2FARejected] with the auth-key lookup failure before
+// refreshed cookies are persisted. Response read errors are returned directly
+// and are not classified as submitted-code rejections.
+func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, login, mtvBaseURL)
+}
+
+func resolveSessionForTrackerAuthLoginAt(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	dbPath string,
+	login api.TrackerAuthLoginRequest,
+	baseURL string,
+) error {
+	cookies, err := loadMTVCookies(ctx, dbPath)
+	if err == nil && len(cookies) > 0 {
+		if _, _, err := resolveAuthKey(ctx, baseURL, cookies); err == nil {
+			return nil
+		} else if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+			return err
+		}
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return errors.New("trackers: MTV cookie invalid/missing and username/password not configured")
+	}
+	_, _, values, _, err := loginAndResolveAuthKey(ctx, cfg, baseURL, login)
+	if err != nil {
+		return err
+	}
+	if len(values) == 0 {
+		return errors.New("trackers: MTV login returned no usable cookies")
+	}
+	if err := saveMTVCookies(ctx, dbPath, values); err != nil {
+		return fmt.Errorf("trackers: MTV persist cookies after successful login: %w", err)
+	}
+	return nil
+}
+
+// loginAndResolveAuthKey performs MTV login, optional TOTP submission, and auth
+// key discovery. MTV can return authkey in the final login response, so that
+// body is checked before falling back to the index page. Missing form tokens
+// and auth-key parser failures remain ordinary errors unless an auth-key miss
+// follows a submitted manual code. Authenticated cookies and the effective base
+// URL are returned only after auth-key discovery so upload can reuse any
+// canonical host reached during login redirects.
+func loginAndResolveAuthKey(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	baseURL string,
+	login api.TrackerAuthLoginRequest,
+) (string, *http.Client, map[string]string, string, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV create login cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 25 * time.Second, Jar: jar}
+
+	loginURL := strings.TrimRight(baseURL, "/") + "/login"
+	loginReq, err := http.NewRequestWithContext(ctx, http.MethodGet, loginURL, nil)
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV build login page request: %w", err)
+	}
+	loginReq.Header.Set("User-Agent", mtvUserAgentWeb)
+	loginResp, err := client.Do(loginReq)
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV login page request: %w", err)
+	}
+	loginBody, err := io.ReadAll(loginResp.Body)
+	_ = loginResp.Body.Close()
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV read login page response: %w", err)
+	}
+	effectiveBaseURL := mtvEffectiveBaseURL(baseURL, loginResp)
+	effectiveLoginURL := strings.TrimRight(effectiveBaseURL, "/") + "/login"
+	match := mtvTokenPattern.FindStringSubmatch(string(loginBody))
+	if len(match) < 2 {
+		return "", nil, nil, "", errors.New("trackers: MTV login token not found")
+	}
+	token := strings.TrimSpace(match[1])
+
+	form := url.Values{}
+	form.Set("username", strings.TrimSpace(cfg.Username))
+	form.Set("password", strings.TrimSpace(cfg.Password))
+	form.Set("keeploggedin", "1")
+	form.Set("cinfo", "1920|1080|24|0")
+	form.Set("submit", "login")
+	form.Set("iplocked", "1")
+	form.Set("token", token)
+
+	postReq, err := http.NewRequestWithContext(ctx, http.MethodPost, effectiveLoginURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV build login request: %w", err)
+	}
+	postReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	postReq.Header.Set("User-Agent", mtvUserAgentWeb)
+	postResp, err := client.Do(postReq)
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV login request: %w", err)
+	}
+	body, err := io.ReadAll(postResp.Body)
+	_ = postResp.Body.Close()
+	if err != nil {
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV read login response: %w", err)
+	}
+	finalAuthBody := string(body)
+	finalAuthTrace := mtvResponseTrace(postResp)
+
+	submittedManualCode := false
+	if postResp.Request != nil && postResp.Request.URL != nil && strings.Contains(postResp.Request.URL.Path, "/twofactor/login") {
+		twoFactorTokenMatch := mtvTokenPattern.FindStringSubmatch(string(body))
+		if len(twoFactorTokenMatch) < 2 {
+			return "", nil, nil, "", errors.New("trackers: MTV 2FA token not found")
+		}
+		code, err := resolveMTV2FACode(cfg, login)
+		if err != nil {
+			return "", nil, nil, "", err
+		}
+		twoFactorForm := url.Values{}
+		twoFactorForm.Set("token", twoFactorTokenMatch[1])
+		twoFactorForm.Set("code", code)
+		twoFactorForm.Set("submit", "login")
+		twoReq, err := http.NewRequestWithContext(
+			ctx,
+			http.MethodPost,
+			strings.TrimRight(effectiveBaseURL, "/")+"/twofactor/login",
+			strings.NewReader(twoFactorForm.Encode()),
+		)
+		if err != nil {
+			return "", nil, nil, "", fmt.Errorf("trackers: MTV build 2FA login request: %w", err)
+		}
+		twoReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		twoReq.Header.Set("User-Agent", mtvUserAgentWeb)
+		twoResp, err := client.Do(twoReq)
+		if err != nil {
+			return "", nil, nil, "", fmt.Errorf("trackers: MTV 2FA login request: %w", err)
+		}
+		twoFactorBody, err := io.ReadAll(twoResp.Body)
+		_ = twoResp.Body.Close()
+		if err != nil {
+			return "", nil, nil, "", fmt.Errorf("trackers: MTV read 2FA login response: %w", err)
+		}
+		finalAuthBody = string(twoFactorBody)
+		finalAuthTrace = mtvResponseTrace(twoResp)
+		submittedManualCode = strings.TrimSpace(login.Code) != ""
+	}
+
+	if auth := extractMTVAuthKey(finalAuthBody); auth != "" {
+		cookieMap := cookiesFromJar(effectiveBaseURL, client.Jar)
+		return auth, client, cookieMap, effectiveBaseURL, nil
+	}
+	auth, authedClient, err := resolveAuthKeyFromClient(ctx, effectiveBaseURL, client)
+	if err != nil {
+		if submittedManualCode && errors.Is(err, errMTVAuthKeyNotFound) {
+			return "", nil, nil, "", fmt.Errorf(
+				"trackers: MTV auth key not found after submitted 2FA final_%s: %w: %w",
+				finalAuthTrace,
+				err,
+				ErrSubmitted2FARejected,
+			)
+		}
+		if errors.Is(err, errMTVAuthKeyNotFound) {
+			return "", nil, nil, "", fmt.Errorf("trackers: MTV auth key not found after login final_%s: %w", finalAuthTrace, err)
+		}
+		return "", nil, nil, "", fmt.Errorf("trackers: MTV auth key lookup after login final_%s: %w", finalAuthTrace, err)
+	}
+	cookieMap := cookiesFromJar(effectiveBaseURL, authedClient.Jar)
+	return auth, authedClient, cookieMap, effectiveBaseURL, nil
+}
+
+func mtvEffectiveBaseURL(fallback string, resp *http.Response) string {
+	if resp == nil || resp.Request == nil || resp.Request.URL == nil {
+		return strings.TrimRight(fallback, "/")
+	}
+	u := resp.Request.URL
+	if strings.TrimSpace(u.Scheme) == "" || strings.TrimSpace(u.Host) == "" {
+		return strings.TrimRight(fallback, "/")
+	}
+	return u.Scheme + "://" + u.Host
+}
+
+func mtvResponseTrace(resp *http.Response) string {
+	if resp == nil {
+		return "path=unknown status=0"
+	}
+	path := "unknown"
+	if resp.Request != nil && resp.Request.URL != nil {
+		path = resp.Request.URL.EscapedPath()
+		if strings.TrimSpace(path) == "" {
+			path = "/"
+		}
+	}
+	return fmt.Sprintf("path=%s status=%d", path, resp.StatusCode)
+}
+
+func extractMTVAuthKey(body string) string {
+	const marker = "authkey="
+	idx := strings.LastIndex(body, marker)
+	if idx < 0 {
+		return ""
+	}
+	raw := strings.TrimSpace(body[idx+len(marker):])
+	if len(raw) < 32 {
+		return ""
+	}
+	return raw[:32]
+}
+
+// resolveMTV2FACode prefers a submitted manual code so users can continue a
+// browser-visible challenge when no reusable OTP URI is configured.
+func resolveMTV2FACode(cfg config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
+	if code := strings.TrimSpace(login.Code); code != "" {
+		return code, nil
+	}
+	code, err := totpFromOTPURI(strings.TrimSpace(cfg.OTPURI), time.Now())
+	if err != nil {
+		return "", fmt.Errorf("trackers: MTV 2FA required but otp_uri invalid: %w", err)
+	}
+	return code, nil
+}
+
+func resolveAuthKeyFromClient(ctx context.Context, baseURL string, client *http.Client) (string, *http.Client, error) {
+	indexURL := strings.TrimRight(baseURL, "/") + mtvIndexPath
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, indexURL, nil)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV build auth request: %w", err)
+	}
+	req.Header.Set("User-Agent", mtvUserAgentWeb)
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV auth request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", nil, fmt.Errorf("trackers: MTV auth key lookup failed %s: auth status %d", mtvResponseTrace(resp), resp.StatusCode)
+	}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", nil, fmt.Errorf("trackers: MTV read auth response: %w", err)
+	}
+	auth := extractMTVAuthKey(string(body))
+	if auth == "" {
+		return "", nil, fmt.Errorf("%w: %s", errMTVAuthKeyNotFound, mtvResponseTrace(resp))
+	}
+	return auth, client, nil
+}
+
+func cookiesFromJar(baseURL string, jar http.CookieJar) map[string]string {
+	if jar == nil {
+		return nil
+	}
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return nil
+	}
+	out := make(map[string]string)
+	for _, cookie := range jar.Cookies(parsed) {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" || strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		out[strings.TrimSpace(cookie.Name)] = cookie.Value
+	}
+	return out
+}
+
+func totpFromOTPURI(otpURI string, now time.Time) (string, error) {
+	trimmed := strings.TrimSpace(otpURI)
+	if trimmed == "" {
+		return "", errors.New("empty otp_uri")
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", fmt.Errorf("trackers: MTV parse otp_uri: %w", err)
+	}
+	query := parsed.Query()
+	secret := strings.TrimSpace(query.Get("secret"))
+	if secret == "" {
+		return "", errors.New("missing secret query parameter")
+	}
+	interval := 30
+	if period := strings.TrimSpace(query.Get("period")); period != "" {
+		if value, err := strconv.Atoi(period); err == nil && value > 0 {
+			interval = value
+		}
+	}
+	counterTime := now.Unix() / int64(interval)
+	if counterTime < 0 {
+		return "", errors.New("totp counter before unix epoch")
+	}
+	counter := uint64(counterTime)
+
+	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
+	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
+	if err != nil {
+		return "", fmt.Errorf("trackers: MTV decode otp secret: %w", err)
+	}
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, counter)
+	mac := hmac.New(sha1.New, secretBytes)
+	_, _ = mac.Write(buf)
+	hash := mac.Sum(nil)
+	offset := hash[len(hash)-1] & 0x0f
+	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
+	return fmt.Sprintf("%06d", code%1000000), nil
+}
+
+func buildUploadFields(req trackers.PreparationInput, auth string, description string) map[string]string {
+	meta := req.Meta
+	anon := "1"
+	if !req.TrackerConfig.Anon {
+		anon = "0"
+	}
+	return map[string]string{
+		"image":               "",
+		"title":               resolveUploadName(meta),
+		"category":            resolveCategoryID(meta),
+		"Resolution":          resolveResolutionID(meta),
+		"source":              resolveSourceID(meta),
+		"origin":              resolveOriginID(meta),
+		"taglist":             resolveTags(meta),
+		"desc":                strings.TrimSpace(description),
+		"groupDesc":           resolveGroupDescription(meta),
+		"ignoredupes":         "1",
+		"genre_tags":          "---",
+		"autocomplete_toggle": "on",
+		"fontfont":            "-1",
+		"fontsize":            "-1",
+		"auth":                auth,
+		"anonymous":           anon,
+		"submit":              "true",
+	}
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: MTV write multipart field %q: %w", key, err)
+		}
+	}
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: MTV open torrent file: %w", err)
+	}
+	defer file.Close()
+	part, err := writer.CreateFormFile("file_input", "[MTV].torrent")
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: MTV create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: MTV copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: MTV close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
+	candidates := []string{
+		strings.TrimSpace(meta.TorrentPath),
+		strings.TrimSpace(meta.ClientTorrentPath),
+		strings.TrimSpace(meta.SourcePath),
+	}
+	for _, candidate := range candidates {
+		if candidate == "" || !strings.EqualFold(filepath.Ext(candidate), ".torrent") {
+			continue
+		}
+		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+			return candidate, nil
+		}
+	}
+	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
+		tmpRoot, err := db.Subdir(dbPath, "tmp")
+		if err == nil {
+			tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+			if err == nil {
+				guessed := filepath.Join(tmpDir, base+".torrent")
+				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
+					return guessed, nil
+				}
+			}
+		}
+	}
+	return "", errors.New("trackers: MTV torrent file not found")
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
+		return cleanName(name)
+	}
+	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
+		return cleanName(name)
+	}
+	if name := strings.TrimSpace(meta.Filename); name != "" {
+		return cleanName(name)
+	}
+	return cleanName(pathutil.Base(meta.SourcePath))
+}
+
+func cleanName(value string) string {
+	value = strings.Join(strings.Fields(value), " ")
+	value = strings.ReplaceAll(value, " ", ".")
+	value = strings.ReplaceAll(value, "..", ".")
+	return strings.TrimSpace(value)
+}
+
+func resolveResolution(meta api.UploadSubject) string {
+	if value := strings.TrimSpace(meta.Release.Resolution); value != "" {
+		return value
+	}
+	if strings.TrimSpace(meta.UHD) != "" {
+		return "2160p"
+	}
+	return ""
+}
+
+func resolveResolutionID(meta api.UploadSubject) string {
+	res := strings.ToLower(strings.TrimSpace(resolveResolution(meta)))
+	values := map[string]string{
+		"8640p": "0",
+		"4320p": "4000",
+		"2160p": "2160",
+		"1440p": "1440",
+		"1080p": "1080",
+		"1080i": "1080",
+		"720p":  "720",
+		"576p":  "0",
+		"576i":  "0",
+		"480p":  "480",
+		"480i":  "480",
+	}
+	if value, ok := values[res]; ok {
+		return value
+	}
+	return "10"
+}
+
+func isSD(meta api.UploadSubject) bool {
+	res := strings.ToLower(resolveResolution(meta))
+	return strings.Contains(res, "480") || strings.Contains(res, "576")
+}
+
+func resolveCategory(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func resolveCategoryID(meta api.UploadSubject) string {
+	category := resolveCategory(meta)
+	if category == "MOVIE" {
+		if isSD(meta) {
+			return "2"
+		}
+		return "1"
+	}
+	if category == "TV" {
+		if meta.TVPack {
+			if isSD(meta) {
+				return "6"
+			}
+			return "5"
+		}
+		if isSD(meta) {
+			return "4"
+		}
+		return "3"
+	}
+	return "0"
+}
+
+func resolveType(meta api.UploadSubject) string {
+	value := strings.ToUpper(strings.TrimSpace(meta.Type))
+	if value == "" {
+		value = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
+	}
+	return strings.ReplaceAll(strings.ReplaceAll(value, "-", ""), " ", "")
+}
+
+func resolveSourceID(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return "1"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") || resolveType(meta) == "REMUX" {
+		return "7"
+	}
+	mapping := map[string]string{
+		"DISC":   "1",
+		"WEBDL":  "9",
+		"WEBRIP": "10",
+		"HDTV":   "1",
+		"SDTV":   "2",
+		"TVRIP":  "3",
+		"DVD":    "4",
+		"DVDRIP": "5",
+		"BDRIP":  "8",
+		"VHS":    "6",
+		"MIXED":  "11",
+		"ENCODE": "7",
+	}
+	if value, ok := mapping[resolveType(meta)]; ok {
+		return value
+	}
+	return "0"
+}
+
+func resolveOriginID(meta api.UploadSubject) string {
+	if meta.PersonalRelease {
+		return "4"
+	}
+	if meta.Scene {
+		return "2"
+	}
+	return "3"
+}
+
+func resolveTags(meta api.UploadSubject) string {
+	tags := make([]string, 0, 12)
+	resolution := strings.ToLower(strings.TrimSpace(resolveResolution(meta)))
+	if resolution != "" {
+		tags = append(tags, resolution)
+	}
+	switch {
+	case isSD(meta):
+		tags = append(tags, "sd")
+	case resolution == "2160p" || resolution == "4320p":
+		tags = append(tags, "uhd")
+	default:
+		tags = append(tags, "hd")
+	}
+	if service := strings.TrimSpace(meta.ServiceLongName); service != "" {
+		svc := strings.ToLower(strings.ReplaceAll(service, " ", "."))
+		svc = strings.ReplaceAll(svc, "+", "plus")
+		tags = append(tags, svc+".source")
+	}
+	switch category := resolveCategory(meta); category {
+	case "TV":
+		switch {
+		case meta.TVPack && isSD(meta):
+			tags = append(tags, "sd.season")
+		case meta.TVPack:
+			tags = append(tags, "hd.season")
+		case isSD(meta):
+			tags = append(tags, "sd.episode")
+		default:
+			tags = append(tags, "hd.episode")
+		}
+	case "MOVIE":
+		if isSD(meta) {
+			tags = append(tags, "sd.movie")
+		} else {
+			tags = append(tags, "hd.movie")
+		}
+	}
+	audio := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(meta.Audio, "+", "p"), "-", "."), " ", "."))
+	for _, token := range []string{"dd", "ddp", "aac", "truehd", "mp3", "mp2", "dts", "dts.hd", "dts.x"} {
+		if strings.Contains(audio, token) {
+			tags = append(tags, token+".audio")
+			break
+		}
+	}
+	if strings.Contains(strings.ToLower(meta.Audio), "atmos") {
+		tags = append(tags, "atmos.audio")
+	}
+	codec := strings.ReplaceAll(strings.ReplaceAll(strings.ToLower(meta.VideoCodec), "avc", "h264"), "hevc", "h265")
+	codec = strings.ReplaceAll(codec, "-", "")
+	if strings.TrimSpace(codec) != "" {
+		tags = append(tags, strings.TrimSpace(codec))
+	}
+	if tag := strings.TrimSpace(meta.Tag); tag != "" {
+		tags = append(tags, strings.TrimPrefix(strings.ReplaceAll(tag, " ", "."), "-")+".release")
+	} else {
+		tags = append(tags, "NOGRP.release")
+	}
+	if meta.Scene {
+		tags = append(tags, "scene.group.release")
+	} else {
+		tags = append(tags, "p2p.group.release")
+	}
+	return strings.Join(tags, " ")
+}
+
+func resolveGroupDescription(meta api.UploadSubject) string {
+	parts := make([]string, 0, 5)
+	if meta.ProviderMetadata.IMDB != nil {
+		if imdbURL := strings.TrimSpace(meta.ProviderMetadata.IMDB.IMDbURL); imdbURL != "" {
+			parts = append(parts, imdbURL)
+		}
+	}
+	if meta.Identity.TMDBID != 0 {
+		category := strings.ToLower(strings.TrimSpace(resolveCategory(meta)))
+		if category == "" {
+			category = "movie"
+		}
+		parts = append(parts, "https://www.themoviedb.org/"+category+"/"+strconv.Itoa(meta.Identity.TMDBID))
+	}
+	if strings.EqualFold(resolveCategory(meta), "TV") && meta.Identity.TVDBID != 0 {
+		parts = append(parts, "https://www.thetvdb.com/?id="+strconv.Itoa(meta.Identity.TVDBID))
+	}
+	if meta.Identity.TVmazeID != 0 {
+		parts = append(parts, "https://www.tvmaze.com/shows/"+strconv.Itoa(meta.Identity.TVmazeID))
+	}
+	if meta.Identity.MALID != 0 {
+		parts = append(parts, "https://myanimelist.net/anime/"+strconv.Itoa(meta.Identity.MALID))
+	}
+	return strings.Join(parts, "\n")
+}
diff --git a/internal/trackers/impl/standalone/mtv/upload_test.go b/internal/trackers/impl/standalone/mtv/upload_test.go
new file mode 100644
index 00000000..835b5c4c
--- /dev/null
+++ b/internal/trackers/impl/standalone/mtv/upload_test.go
@@ -0,0 +1,749 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mtv
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveGroupDescriptionSkipsTVDBForMovie(t *testing.T) {
+	got := resolveGroupDescription(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE", TVDBID: 456},
+	})
+	if strings.Contains(got, "thetvdb.com") {
+		t.Fatalf("did not expect tvdb link for movie description, got %q", got)
+	}
+}
+
+func TestResolveGroupDescriptionIncludesTVDBForTV(t *testing.T) {
+	got := resolveGroupDescription(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV", TVDBID: 456},
+	})
+	if !strings.Contains(got, "thetvdb.com/?id=456") {
+		t.Fatalf("expected tvdb link for TV description, got %q", got)
+	}
+}
+
+func TestExtractMTVAuthKeyMatchesUploadAssistantShape(t *testing.T) {
+	t.Parallel()
+
+	auth := "abcdefghijklmnopqrstuvwxyzABCDEF"
+	tests := map[string]string{
+		"plain":       "authkey=" + auth,
+		"query tail":  "https://example.test/upload?authkey=" + auth + "&x=1",
+		"last marker": "authkey=oldoldoldoldoldoldoldoldoldoldoldold authkey=" + auth + `">`,
+	}
+	for name, body := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := extractMTVAuthKey(body); got != auth {
+				t.Fatal("expected extracted auth key")
+			}
+		})
+	}
+}
+
+func TestResolveSessionForTrackerAuthPreservesCookiesOnTransientAuthFetch(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("saveMTVCookies: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
+	baseURL := server.URL
+	server.Close()
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, baseURL)
+	if err == nil {
+		t.Fatal("expected transient auth fetch error")
+	}
+	got, loadErr := loadMTVCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadMTVCookies after transient error: %v", loadErr)
+	}
+	if got["session"] != "abc" {
+		t.Fatalf("expected transient failure to preserve cookies, got %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthReportsPostLoginCookiePersistenceFailure(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "abc",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+		case "/index.php":
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthAt(context.Background(), config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, filepath.Join(t.TempDir(), "upbrr.db"), server.URL)
+	if !errors.Is(err, cookiepkg.ErrAuthHelperUnavailable) {
+		t.Fatalf("expected auth helper unavailable error, got %v", err)
+	}
+	if !strings.Contains(err.Error(), "persist cookies after successful login") {
+		t.Fatalf("expected distinct persistence failure, got %v", err)
+	}
+}
+
+func TestResolveSessionForTrackerAuthSavesCookiesWhenLoginResponseContainsAuthKey(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	indexRequests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "fresh",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		case "/index.php":
+			indexRequests++
+			_, _ = w.Write([]byte(`<html>logged out</html>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, server.URL)
+	if err != nil {
+		t.Fatalf("ResolveSessionForTrackerAuth: %v", err)
+	}
+	if indexRequests != 0 {
+		t.Fatalf("expected login response authkey to avoid index lookup, got %d", indexRequests)
+	}
+	got, err := loadMTVCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadMTVCookies: %v", err)
+	}
+	if got["session"] != "fresh" {
+		t.Fatalf("expected saved login cookies, got %#v", got)
+	}
+}
+
+func TestLoginAndResolveAuthKeyReturnsLoginPageReadError(t *testing.T) {
+	t.Parallel()
+
+	handlerErrs := make(chan string, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/login" && r.Method == http.MethodGet:
+			if err := writeMalformedChunkedResponse(w); err != nil {
+				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
+			}
+		default:
+			recordHandlerError(handlerErrs, "unexpected request %s %s", r.Method, r.URL.Path)
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	_, _, _, _, err := loginAndResolveAuthKey(context.Background(), config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, server.URL, api.TrackerAuthLoginRequest{})
+	assertNoHandlerError(t, handlerErrs)
+	if err == nil {
+		t.Fatal("expected login page read error")
+	}
+	if !strings.Contains(err.Error(), "read login page response") {
+		t.Fatalf("expected login page read-error context, got %v", err)
+	}
+}
+
+func TestLoginAndResolveAuthKeyReturnsLoginPostReadError(t *testing.T) {
+	t.Parallel()
+
+	handlerErrs := make(chan string, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/login" && r.Method == http.MethodGet:
+			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+		case r.URL.Path == "/login" && r.Method == http.MethodPost:
+			if err := writeMalformedChunkedResponse(w); err != nil {
+				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
+			}
+		default:
+			recordHandlerError(handlerErrs, "unexpected request %s %s", r.Method, r.URL.Path)
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	_, _, _, _, err := loginAndResolveAuthKey(context.Background(), config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, server.URL, api.TrackerAuthLoginRequest{})
+	assertNoHandlerError(t, handlerErrs)
+	if err == nil {
+		t.Fatal("expected login response read error")
+	}
+	if !strings.Contains(err.Error(), "read login response") {
+		t.Fatalf("expected login response read-error context, got %v", err)
+	}
+}
+
+func TestResolveSessionForTrackerAuthPostsLoginToRedirectedHost(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	var canonicalURL string
+	postedCanonicalLogin := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/login" && r.Method == http.MethodGet && strings.HasPrefix(r.Host, "localhost:"):
+			http.Redirect(w, r, canonicalURL+"/login", http.StatusFound)
+		case r.URL.Path == "/login" && r.Method == http.MethodGet:
+			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+		case r.URL.Path == "/login" && r.Method == http.MethodPost && strings.HasPrefix(r.Host, "localhost:"):
+			t.Error("login POST used original host")
+			return
+		case r.URL.Path == "/login" && r.Method == http.MethodPost:
+			postedCanonicalLogin = true
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "fresh",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+	canonicalURL = server.URL
+	sourceURL := strings.Replace(server.URL, "127.0.0.1", "localhost", 1)
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, sourceURL)
+	if err != nil {
+		t.Fatalf("ResolveSessionForTrackerAuth: %v", err)
+	}
+	if !postedCanonicalLogin {
+		t.Fatal("expected login POST on redirected host")
+	}
+	got, err := loadMTVCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadMTVCookies: %v", err)
+	}
+	if got["session"] != "fresh" {
+		t.Fatalf("expected saved redirected-login cookies, got %#v", got)
+	}
+}
+
+func TestUploadPostsToRedirectedLoginHost(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	torrentPath := filepath.Join(t.TempDir(), "release.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	var canonicalURL string
+	postedCanonicalUpload := false
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/login" && r.Method == http.MethodGet && strings.HasPrefix(r.Host, "localhost:"):
+			http.Redirect(w, r, canonicalURL+"/login", http.StatusFound)
+		case r.URL.Path == "/login" && r.Method == http.MethodGet:
+			_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+		case r.URL.Path == "/login" && r.Method == http.MethodPost:
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "fresh",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		case r.URL.Path == mtvUploadPath && r.Method == http.MethodPost && strings.HasPrefix(r.Host, "localhost:"):
+			t.Error("upload POST used original host")
+			return
+		case r.URL.Path == mtvUploadPath && r.Method == http.MethodPost:
+			postedCanonicalUpload = true
+			if _, err := r.Cookie("session"); err != nil {
+				t.Errorf("expected session cookie on canonical upload: %v", err)
+				return
+			}
+			http.Redirect(w, r, canonicalURL+"/torrents.php?id=1", http.StatusFound)
+		case r.URL.Path == "/torrents.php":
+			_, _ = w.Write([]byte("ok"))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+	canonicalURL = server.URL
+	sourceURL := strings.Replace(server.URL, "127.0.0.1", "localhost", 1)
+
+	summary, err := uploadAt(ctx, trackers.PreparationInput{
+		Tracker: "MTV",
+		Meta: api.UploadSubject{
+			TorrentPath: torrentPath,
+			ReleaseName: "Release",
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username: "user",
+			Password: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Assets:  &trackers.DescriptionAssets{Final: true, Description: "desc"},
+	}, sourceURL)
+	if err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+	if summary.Uploaded != 1 {
+		t.Fatalf("expected upload success, got %#v", summary)
+	}
+	if !postedCanonicalUpload {
+		t.Fatal("expected upload POST on redirected host")
+	}
+}
+
+func TestResolveSessionForTrackerAuthRejectsEmptyLoginCookiesWithoutReplacingStoredCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("saveMTVCookies: %v", err)
+	}
+	indexRequests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			_, _ = w.Write([]byte(`<html>ok</html>`))
+		case "/index.php":
+			indexRequests++
+			if indexRequests == 1 {
+				_, _ = w.Write([]byte(`<html>logged out</html>`))
+				return
+			}
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, server.URL)
+	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
+		t.Fatalf("expected empty login cookie error, got %v", err)
+	}
+	got, loadErr := loadMTVCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadMTVCookies after empty login cookies: %v", loadErr)
+	}
+	if got["session"] != "existing" {
+		t.Fatalf("expected empty login cookies to preserve stored cookies, got %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthDoesNotPersistCookiesBeforeAuthKeyValidation(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "unverified",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`<html>logged in without auth key</html>`))
+		case "/index.php":
+			_, _ = w.Write([]byte(`<html>temporary account notice</html>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, server.URL)
+	if err == nil || !strings.Contains(err.Error(), "auth key not found") {
+		t.Fatalf("expected auth-key validation failure, got %v", err)
+	}
+	if values, loadErr := loadMTVCookies(ctx, dbPath); !errors.Is(loadErr, cookiepkg.ErrTrackerCookiesNotFound) {
+		t.Fatalf("unverified login cookies persisted or unexpected load error values=%#v err=%v", values, loadErr)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginUsesManual2FACode(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	var gotCode string
+	indexRequests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/index.php":
+			indexRequests++
+			_, _ = w.Write([]byte(`<html>logged out</html>`))
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
+		case "/twofactor/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
+				return
+			}
+			if err := r.ParseForm(); err != nil {
+				t.Errorf("ParseForm: %v", err)
+				return
+			}
+			gotCode = r.FormValue("code")
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "654321"}, server.URL)
+	if err != nil {
+		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
+	}
+	if gotCode != "654321" {
+		t.Fatalf("expected manual 2FA code, got %q", gotCode)
+	}
+	if indexRequests != 0 {
+		t.Fatalf("expected 2FA response authkey to avoid index lookup, got %d", indexRequests)
+	}
+	got, err := loadMTVCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadMTVCookies: %v", err)
+	}
+	if got["session"] != "new" {
+		t.Fatalf("expected saved 2FA login cookies, got %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginMarksSubmitted2FAAuthKeyMiss(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("saveMTVCookies: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/index.php":
+			_, _ = w.Write([]byte(`<html>logged out</html>`))
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
+		case "/twofactor/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
+				return
+			}
+			_, _ = w.Write([]byte(`<html>invalid code</html>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"}, server.URL)
+	if !errors.Is(err, ErrSubmitted2FARejected) {
+		t.Fatalf("expected submitted 2FA rejection marker, got %v", err)
+	}
+	if !strings.Contains(err.Error(), "final_path=/twofactor/login status=200") || !strings.Contains(err.Error(), "path=/index.php status=200") {
+		t.Fatalf("expected safe path/status diagnostics, got %v", err)
+	}
+	got, loadErr := loadMTVCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadMTVCookies: %v", loadErr)
+	}
+	if got["session"] != "existing" {
+		t.Fatalf("submitted 2FA rejection must preserve stored cookies, got %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginReturns2FAReadError(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("saveMTVCookies: %v", err)
+	}
+	handlerErrs := make(chan string, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/index.php":
+			_, _ = w.Write([]byte(`<html>logged out</html>`))
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
+		case "/twofactor/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
+				return
+			}
+			if err := writeMalformedChunkedResponse(w); err != nil {
+				recordHandlerError(handlerErrs, "write malformed chunked response: %v", err)
+			}
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "123456"}, server.URL)
+	assertNoHandlerError(t, handlerErrs)
+	if err == nil {
+		t.Fatal("expected 2FA response read error")
+	}
+	if errors.Is(err, ErrSubmitted2FARejected) {
+		t.Fatalf("read error must not be classified as submitted 2FA rejection: %v", err)
+	}
+	if !strings.Contains(err.Error(), "read 2FA login response") {
+		t.Fatalf("expected read-error context, got %v", err)
+	}
+	got, loadErr := loadMTVCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadMTVCookies: %v", loadErr)
+	}
+	if got["session"] != "existing" {
+		t.Fatalf("2FA read error must preserve stored cookies, got %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginReportsSafeAuthKeyDiagnostics(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`<html>login accepted but no upload token secret-response-body</html>`))
+		case "/index.php":
+			_, _ = w.Write([]byte(`<html>logged in but no upload token other-secret-body</html>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
+	if !errors.Is(err, errMTVAuthKeyNotFound) {
+		t.Fatalf("expected auth key miss, got %v", err)
+	}
+	if !strings.Contains(err.Error(), "final_path=/login status=200") || !strings.Contains(err.Error(), "path=/index.php status=200") {
+		t.Fatalf("expected path/status diagnostics, got %v", err)
+	}
+	for _, secret := range []string{"secret-response-body", "other-secret-body"} {
+		if strings.Contains(err.Error(), secret) {
+			t.Fatalf("diagnostic leaked response body %q: %v", secret, err)
+		}
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginMissing2FACodePreservesCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newMTVAuthDB(t)
+	if err := saveMTVCookies(ctx, dbPath, map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("saveMTVCookies: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/index.php":
+			_, _ = w.Write([]byte(`<html>logged out</html>`))
+		case "/login":
+			if r.Method == http.MethodGet {
+				_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">`))
+				return
+			}
+			http.Redirect(w, r, "/twofactor/login", http.StatusFound)
+		case "/twofactor/login":
+			_, _ = w.Write([]byte(`<input name="token" value="ponmlkjihgfedcba">`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
+	if err == nil || !strings.Contains(err.Error(), "2FA required") {
+		t.Fatalf("expected missing 2FA error, got %v", err)
+	}
+	got, loadErr := loadMTVCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadMTVCookies: %v", loadErr)
+	}
+	if got["session"] != "existing" {
+		t.Fatalf("missing 2FA code must preserve stored cookies, got %#v", got)
+	}
+}
+
+func newMTVAuthDB(t *testing.T) string {
+	t.Helper()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("OpenWithLoggerContext: %v", err)
+	}
+	if err := repo.MigrateContext(ctx); err != nil {
+		_ = repo.Close()
+		t.Fatalf("MigrateContext: %v", err)
+	}
+	_ = repo.Close()
+	return dbPath
+}
+
+// recordHandlerError preserves handler failures for assertion from the test
+// goroutine, where testing.T failures are safe to report.
+func recordHandlerError(errs chan<- string, format string, args ...any) {
+	select {
+	case errs <- fmt.Sprintf(format, args...):
+	default:
+	}
+}
+
+// assertNoHandlerError fails the test if the server handler recorded a setup or
+// routing error while servicing the request under test.
+func assertNoHandlerError(t *testing.T, errs <-chan string) {
+	t.Helper()
+
+	select {
+	case err := <-errs:
+		t.Fatal(err)
+	default:
+	}
+}
+
+// writeMalformedChunkedResponse sends an intentionally truncated chunked body so
+// callers exercise response-body read errors after headers are received.
+func writeMalformedChunkedResponse(w http.ResponseWriter) error {
+	hijacker, ok := w.(http.Hijacker)
+	if !ok {
+		return errors.New("response writer does not support hijacking")
+	}
+	conn, rw, err := hijacker.Hijack()
+	if err != nil {
+		return fmt.Errorf("hijack response: %w", err)
+	}
+	if _, err := rw.WriteString("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nTransfer-Encoding: chunked\r\n\r\n20\r\npartial"); err != nil {
+		_ = conn.Close()
+		return fmt.Errorf("write response: %w", err)
+	}
+	if err := rw.Flush(); err != nil {
+		_ = conn.Close()
+		return fmt.Errorf("flush response: %w", err)
+	}
+	_ = conn.Close()
+	return nil
+}
diff --git a/internal/trackers/impl/standalone/nbl/banned_groups.go b/internal/trackers/impl/standalone/nbl/banned_groups.go
new file mode 100644
index 00000000..1825b580
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/banned_groups.go
@@ -0,0 +1,77 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+// bannedGroups returns NBL's static release-group blacklist.
+func bannedGroups() []string {
+	return []string{
+		"0neshot",
+		"3LTON",
+		"4yEo",
+		"[Oj]",
+		"AFG",
+		"AkihitoSubs",
+		"AniHLS",
+		"Anime Time",
+		"AnimeRG",
+		"AniURL",
+		"ASW",
+		"BakedFish",
+		"bonkai77",
+		"Cleo",
+		"DeadFish",
+		"DeeJayAhmed",
+		"ELiTE",
+		"EMBER",
+		"eSc",
+		"EVO",
+		"FGT",
+		"FUM",
+		"GERMini",
+		"HAiKU",
+		"Hi10",
+		"ION10",
+		"JacobSwaggedUp",
+		"JIVE",
+		"Judas",
+		"LOAD",
+		"MeGusta",
+		"Mr.Deadpool",
+		"mSD",
+		"NemDiggers",
+		"neoHEVC",
+		"NhaNc3",
+		"NOIVTC",
+		"PlaySD",
+		"playXD",
+		"project-gxs",
+		"PSA",
+		"QaS",
+		"Ranger",
+		"RAPiDCOWS",
+		"Raze",
+		"Reaktor",
+		"REsuRRecTioN",
+		"RMTeam",
+		"ROBOTS",
+		"SpaceFish",
+		"SPASM",
+		"SSA",
+		"Telly",
+		"Tenrai-Sensei",
+		"TM",
+		"Trix",
+		"URANiME",
+		"VipapkStudios",
+		"ViSiON",
+		"Wardevil",
+		"xRed",
+		"XS",
+		"YakuboEncodes",
+		"YuiSubs",
+		"ZKBL",
+		"ZmN",
+		"ZMNT",
+	}
+}
diff --git a/internal/trackers/impl/standalone/nbl/definition_test.go b/internal/trackers/impl/standalone/nbl/definition_test.go
new file mode 100644
index 00000000..10ea45d3
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/definition_test.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDefinitionBuildUploadDryRunBuildsPayload(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "MEDIAINFO.txt")
+	torrentPath := filepath.Join(tmp, "Show.torrent")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	plan, failure := New().Prepare(context.Background(), trackers.PreparationInput{
+		Tracker: "NBL",
+		Intent:  trackers.PreparationIntentDryRun,
+		Meta: api.UploadSubject{
+			SourcePath:        filepath.Join(tmp, "Show.mkv"),
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Identity:          api.ExternalIdentity{TVmazeID: 987},
+			TVPack:            true,
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{}),
+		Logger:        api.NopLogger{},
+	})
+	if failure != nil {
+		t.Fatalf("unexpected failure: %v", failure)
+	}
+	entry := plan.DryRun()
+	if entry.Payload["tvmazeid"] != "987" {
+		t.Fatalf("expected tvmazeid 987, got %q", entry.Payload["tvmazeid"])
+	}
+	if entry.Payload["category"] != "3" {
+		t.Fatalf("expected pack category 3, got %q", entry.Payload["category"])
+	}
+	if entry.Questionnaire != nil {
+		t.Fatal("expected no questionnaire")
+	}
+}
diff --git a/internal/trackers/impl/standalone/nbl/dupe.go b/internal/trackers/impl/standalone/nbl/dupe.go
new file mode 100644
index 00000000..ecfb9168
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/dupe.go
@@ -0,0 +1,120 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := nblAPIKey(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	searchTerm := map[string]any{}
+	switch {
+	case meta.Identity.TVmazeID != 0:
+		searchTerm["tvmaze"] = meta.Identity.TVmazeID
+	case meta.Identity.IMDBID != 0:
+		searchTerm["imdb"] = strconv.Itoa(meta.Identity.IMDBID)
+	default:
+		searchTerm["series"] = strings.TrimSpace(meta.Release.Title)
+	}
+	raw, err := json.Marshal(map[string]any{
+		"jsonrpc": "2.0",
+		"id":      1,
+		"method":  "getTorrents",
+		"params":  []any{apiKey, searchTerm},
+	})
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "NBL search failed", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://nebulance.io/api.php", bytes.NewReader(raw))
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "NBL search failed", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "NBL search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "NBL search failed", nil)
+	}
+	var payload struct {
+		Result struct {
+			Items []map[string]any `json:"items"`
+		} `json:"result"`
+	}
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&payload); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "NBL search failed", err)
+	}
+	entries := make([]api.DupeEntry, 0, len(payload.Result.Items))
+	for _, item := range payload.Result.Items {
+		entry := api.DupeEntry{
+			Name:     nblString(item["rls_name"]),
+			Link:     "https://nebulance.io/torrents.php?id=" + nblString(item["group_id"]),
+			Download: nblString(item["download"]),
+		}
+		if size := nblInt64(item["size"]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		if files, ok := item["file_list"].([]any); ok {
+			entry.FileCount = len(files)
+			for _, file := range files {
+				if name := nblString(file); name != "" {
+					entry.Files = append(entry.Files, name)
+				}
+			}
+		}
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func nblAPIKey(cfg config.Config) string {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "NBL") {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
+func nblInt64(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/nbl/profile.go b/internal/trackers/impl/standalone/nbl/profile.go
new file mode 100644
index 00000000..ad2c8070
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/profile.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns NBL identity, preparation, dupe, rules, bans, and policies,
+// including the strict TVmaze metadata requirement for TV uploads.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "NBL",
+		BaseURL:             "https://nebulance.io",
+		DescriptionGroup:    "nbl",
+		UploadContentMode:   trackers.UploadContentModeNone,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		Rules:               rules(),
+		BannedGroups:        bannedGroups(),
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeTV,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTVmaze},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: "NBL"},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"tracker.nebulance"}},
+	}
+}
+
+// New returns a fresh NBL definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/nbl/rules.go b/internal/trackers/impl/standalone/nbl/rules.go
new file mode 100644
index 00000000..479817ea
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/rules.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// rules declares NBL's TV-only and English-language requirements.
+func rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		RequireTVOnly: true,
+		Language: &trackers.LanguageRule{
+			Languages:      []string{"english", "en", "eng"},
+			RequireAudio:   true,
+			RequireSubs:    true,
+			AllowOriginal:  true,
+			ApplyIfNonBDMV: true,
+		},
+	}
+}
diff --git a/internal/trackers/impl/standalone/nbl/upload.go b/internal/trackers/impl/standalone/nbl/upload.go
new file mode 100644
index 00000000..9beeea39
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/upload.go
@@ -0,0 +1,253 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/httpclient"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const nblUploadURL = "https://nebulance.io/api.php"
+
+var nblTorrentIDPattern = regexp.MustCompile(`id=(\d+)`)
+
+type uploadState struct {
+	torrentPath string
+	releaseName string
+	fields      map[string]string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "NBL")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, state, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	state uploadState,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, nblUploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: NBL request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	result, err := commonhttp.ExecuteUpload(httpclient.New(httpclient.DefaultTimeout), httpReq, commonhttp.UploadExecutionOptions{Tracker: "NBL"})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: NBL execute upload: %w", err)
+	}
+	if !result.Success {
+		return api.UploadSummary{}, commonhttp.UploadHTTPError("NBL", result.StatusCode, result.Preview)
+	}
+
+	payload := map[string]any{}
+	if len(result.Body) > 0 {
+		if err := json.Unmarshal(result.Body, &payload); err != nil {
+			return api.UploadSummary{}, errors.New("trackers: NBL json decode error, the API is probably down")
+		}
+	}
+
+	torrentURL, torrentID := extractUploadLinkAndID(payload)
+
+	if announceURL != "" {
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, torrentURL, "NBL"); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+
+	return api.UploadSummary{
+		Uploaded: 1,
+		UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "NBL",
+			TorrentID:   torrentID,
+			DownloadURL: torrentURL,
+			TorrentURL:  torrentURL,
+			TorrentPath: artifactPath,
+		}},
+	}, nil
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "NBL",
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "nbl",
+		Endpoint:         nblUploadURL,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	select {
+	case <-ctx.Done():
+		return uploadState{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: NBL missing api_key")
+	}
+
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	mediaInfo, err := resolveMediaInfo(req.Meta)
+	if err != nil {
+		return uploadState{}, err
+	}
+
+	fields := map[string]string{
+		"action":      "upload",
+		"api_key":     strings.TrimSpace(req.TrackerConfig.APIKey),
+		"tvmazeid":    strconv.Itoa(req.Meta.Identity.TVmazeID),
+		"mediainfo":   mediaInfo,
+		"category":    strconv.Itoa(resolveCategoryID(req.Meta)),
+		"ignoredupes": "1",
+	}
+
+	return uploadState{
+		torrentPath: torrentPath,
+		releaseName: resolveUploadName(req.Meta),
+		fields:      fields,
+	}, nil
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	for key, value := range fields {
+		if err := writer.WriteField(key, value); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: NBL write multipart field %q: %w", key, err)
+		}
+	}
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: NBL open torrent file: %w", err)
+	}
+	defer file.Close()
+	part, err := writer.CreateFormFile("file_input", "torrent.torrent")
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: NBL create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: NBL copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: NBL close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveMediaInfo(meta api.UploadSubject) (string, error) {
+	if strings.TrimSpace(meta.MediaInfoTextPath) == "" {
+		return "", errors.New("trackers: NBL missing mediainfo text")
+	}
+	payload, err := os.ReadFile(strings.TrimSpace(meta.MediaInfoTextPath))
+	if err != nil {
+		return "", fmt.Errorf("trackers: NBL read mediainfo: %w", err)
+	}
+	return string(payload), nil
+}
+
+func resolveCategoryID(meta api.UploadSubject) int {
+	if meta.TVPack {
+		return 3
+	}
+	return 1
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.Filename); name != "" {
+		return name
+	}
+	return pathutil.Base(meta.SourcePath)
+}
+
+func nblString(value any) string {
+	if value == nil {
+		return ""
+	}
+
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	default:
+		return strings.TrimSpace(fmt.Sprint(value))
+	}
+}
+
+func extractUploadLinkAndID(payload map[string]any) (string, string) {
+	torrentURL := strings.TrimSpace(nblString(payload["link"]))
+	if torrentURL == "" {
+		if result, ok := payload["result"].(map[string]any); ok {
+			torrentURL = strings.TrimSpace(nblString(result["link"]))
+		}
+	}
+
+	torrentID := ""
+	if matches := nblTorrentIDPattern.FindStringSubmatch(torrentURL); len(matches) > 1 {
+		torrentID = strings.TrimSpace(matches[1])
+	}
+
+	return torrentURL, torrentID
+}
diff --git a/internal/trackers/impl/standalone/nbl/upload_test.go b/internal/trackers/impl/standalone/nbl/upload_test.go
new file mode 100644
index 00000000..3a2a1a2c
--- /dev/null
+++ b/internal/trackers/impl/standalone/nbl/upload_test.go
@@ -0,0 +1,91 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package nbl
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestPrepareUploadStateUsesNumericIgnoreDupes(t *testing.T) {
+	t.Parallel()
+
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
+	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	if err := os.WriteFile(mediaInfoPath, []byte("mediainfo"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	state, err := prepareUploadState(context.Background(), trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "api-key"},
+	})
+	if err != nil {
+		t.Fatalf("prepare upload state: %v", err)
+	}
+	if got := state.fields["ignoredupes"]; got != "1" {
+		t.Fatalf("expected ignoredupes=1, got %q", got)
+	}
+}
+
+func TestExtractUploadLinkAndIDFromRootLink(t *testing.T) {
+	t.Parallel()
+
+	payload := map[string]any{
+		"link": "https://nebulance.io/torrents.php?id=12345",
+	}
+
+	link, id := extractUploadLinkAndID(payload)
+	if link != "https://nebulance.io/torrents.php?id=12345" {
+		t.Fatalf("expected upload link from root, got %q", link)
+	}
+	if id != "12345" {
+		t.Fatalf("expected torrent id 12345, got %q", id)
+	}
+}
+
+func TestExtractUploadLinkAndIDFromResultLink(t *testing.T) {
+	t.Parallel()
+
+	payload := map[string]any{
+		"result": map[string]any{
+			"link": "https://nebulance.io/torrents.php?id=67890",
+		},
+	}
+
+	link, id := extractUploadLinkAndID(payload)
+	if link != "https://nebulance.io/torrents.php?id=67890" {
+		t.Fatalf("expected upload link from nested result, got %q", link)
+	}
+	if id != "67890" {
+		t.Fatalf("expected torrent id 67890, got %q", id)
+	}
+}
+
+func TestExtractUploadLinkAndIDEmptyWhenMissingLink(t *testing.T) {
+	t.Parallel()
+
+	payload := map[string]any{"status": "ok"}
+
+	link, id := extractUploadLinkAndID(payload)
+	if link != "" {
+		t.Fatalf("expected empty upload link when missing, got %q", link)
+	}
+	if id != "" {
+		t.Fatalf("expected empty torrent id when link missing, got %q", id)
+	}
+}
diff --git a/internal/trackers/impl/standalone/preview.go b/internal/trackers/impl/standalone/preview.go
new file mode 100644
index 00000000..f5175926
--- /dev/null
+++ b/internal/trackers/impl/standalone/preview.go
@@ -0,0 +1,71 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package standalone owns shared lifecycle and definition behavior for tracker
+// implementations that do not belong to a protocol family.
+package standalone
+
+import (
+	"maps"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// PreviewSpec contains tracker-local facts projected into an upload preview.
+type PreviewSpec struct {
+	Tracker          string
+	ReadyMessage     string
+	BlockedReason    string
+	ReleaseName      string
+	DescriptionGroup string
+	Description      string
+	Endpoint         string
+	Payload          map[string]string
+	Files            []api.TrackerDryRunFile
+	Questionnaire    *api.TrackerQuestionnaire
+	DebugSections    []api.TrackerDryRunDebugSection
+	ImageHost        api.ImageHostFeedback
+}
+
+// BuildPreview returns a defensively copied ready or blocked preview from
+// tracker-local prepared facts.
+func BuildPreview(spec PreviewSpec) api.TrackerDryRunEntry {
+	status := "ready"
+	message := strings.TrimSpace(spec.ReadyMessage)
+	if message == "" {
+		message = "dry-run payload generated"
+	}
+	if reason := strings.TrimSpace(spec.BlockedReason); reason != "" {
+		status = "blocked"
+		message = reason
+	}
+	entry := api.TrackerDryRunEntry{
+		Tracker:          strings.ToUpper(strings.TrimSpace(spec.Tracker)),
+		Status:           status,
+		Message:          message,
+		ReleaseName:      strings.TrimSpace(spec.ReleaseName),
+		DescriptionGroup: strings.ToLower(strings.TrimSpace(spec.DescriptionGroup)),
+		Description:      spec.Description,
+		Endpoint:         strings.TrimSpace(spec.Endpoint),
+		Payload:          maps.Clone(spec.Payload),
+		Files:            append([]api.TrackerDryRunFile(nil), spec.Files...),
+		DebugSections:    append([]api.TrackerDryRunDebugSection(nil), spec.DebugSections...),
+		ImageHost:        spec.ImageHost,
+	}
+	for idx := range entry.DebugSections {
+		entry.DebugSections[idx].Payload = maps.Clone(entry.DebugSections[idx].Payload)
+		entry.DebugSections[idx].Files = append([]api.TrackerDryRunFile(nil), entry.DebugSections[idx].Files...)
+	}
+	if spec.Questionnaire != nil {
+		questionnaire := *spec.Questionnaire
+		questionnaire.Fields = append([]api.TrackerQuestionnaireField(nil), questionnaire.Fields...)
+		for idx := range questionnaire.Fields {
+			questionnaire.Fields[idx].Options = append([]string(nil), questionnaire.Fields[idx].Options...)
+		}
+		entry.Questionnaire = &questionnaire
+	}
+	entry.ImageHost.AllowedHosts = append([]string(nil), spec.ImageHost.AllowedHosts...)
+	entry.ImageHost.Warnings = append([]api.ImageHostWarning(nil), spec.ImageHost.Warnings...)
+	return entry
+}
diff --git a/internal/trackers/impl/standalone/preview_test.go b/internal/trackers/impl/standalone/preview_test.go
new file mode 100644
index 00000000..979e06b3
--- /dev/null
+++ b/internal/trackers/impl/standalone/preview_test.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildPreviewNormalizesStatusAndDefensivelyCopies(t *testing.T) {
+	t.Parallel()
+
+	spec := PreviewSpec{
+		Tracker:          " dc ",
+		BlockedReason:    "missing metadata",
+		ReleaseName:      " Example.Release.2026.1080p-GRP ",
+		DescriptionGroup: " DC ",
+		Payload:          map[string]string{"name": "prepared"},
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    "example.torrent",
+			Present: true,
+		}},
+	}
+	entry := BuildPreview(spec)
+	spec.Payload["name"] = "mutated"
+	spec.Files[0].Path = "mutated"
+	if entry.Tracker != "DC" || entry.Status != "blocked" || entry.Message != "missing metadata" {
+		t.Fatalf("preview identity/status = %#v", entry)
+	}
+	if entry.ReleaseName != "Example.Release.2026.1080p-GRP" || entry.DescriptionGroup != "dc" {
+		t.Fatalf("preview projection = %#v", entry)
+	}
+	if entry.Payload["name"] != "prepared" || entry.Files[0].Path != "example.torrent" {
+		t.Fatalf("preview retained caller mutation: %#v", entry)
+	}
+}
diff --git a/internal/trackers/impl/standalone/profile.go b/internal/trackers/impl/standalone/profile.go
new file mode 100644
index 00000000..52c3b5ca
--- /dev/null
+++ b/internal/trackers/impl/standalone/profile.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"context"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// CookieAuthCapability returns the standard stored-cookie capability for a tracker.
+func CookieAuthCapability(name string) *api.TrackerAuthCapability {
+	name = strings.ToUpper(strings.TrimSpace(name))
+	return &api.TrackerAuthCapability{
+		TrackerID:          name,
+		DisplayName:        name,
+		AuthKind:           "cookies",
+		SupportsCookieFile: true,
+	}
+}
+
+// DescriptionPreparer builds tracker-local description content for one intent.
+type DescriptionPreparer func(context.Context, trackers.PreparationInput) (trackers.DescriptionResult, error)
+
+// Profile is the construction input for one standalone tracker's identity,
+// preparation callbacks, duplicate adapter, and declarative capabilities.
+// [New] normalizes identity fields and copies mutable policy data before the
+// definition is published.
+type Profile struct {
+	Name                    string
+	BaseURL                 string
+	DescriptionGroup        string
+	LocalizedMetadataLocale string
+	UploadContentMode       trackers.UploadContentMode
+	PrepareDescription      DescriptionPreparer
+	PrepareUpload           trackers.UploadPreparer
+	NewDuplicateAdapter     func(dupe.Dependencies) dupe.Adapter
+	Rules                   *trackers.RuleSet
+	ClaimPolicy             *trackers.ClaimPolicy
+	DataPolicy              *trackers.DataLookupPolicy
+	ArtifactPolicy          *trackers.ArtifactPolicy
+	BannedGroups            []string
+	BannedGroupPolicy       *trackers.BannedGroupPolicy
+	MetadataPolicy          *trackers.TrackerMetadataPolicy
+	UploadArtifactPolicy    *trackers.UploadArtifactPolicy
+	DupePolicy              *trackers.DupePolicy
+	AudioPolicy             *trackers.AudioPolicy
+	ImageHostPolicy         *trackers.ImageHostPolicy
+	TorrentIdentityPolicy   *trackers.TorrentIdentityPolicy
+	AuthCapability          *api.TrackerAuthCapability
+	AuthResolver            trackers.AuthSessionResolver
+	AuthPolicy              *trackers.AuthPolicy
+	AuthStateManager        trackers.AuthStateManager
+}
diff --git a/internal/trackers/impl/standalone/ptp/bbcode.go b/internal/trackers/impl/standalone/ptp/bbcode.go
new file mode 100644
index 00000000..faaae03d
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/bbcode.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import "github.com/autobrr/upbrr/internal/bbcode"
+
+// CleanDescription removes PTP-specific description markup and returns the
+// cleaned text together with extracted non-comparison images.
+func CleanDescription(description string, discType string) bbcode.Report {
+	return bbcode.CleanPTPDescription(description, discType)
+}
diff --git a/internal/trackers/impl/standalone/ptp/data.go b/internal/trackers/impl/standalone/ptp/data.go
new file mode 100644
index 00000000..a14ac623
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/data.go
@@ -0,0 +1,201 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dataLookup struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+type ptpLookup struct {
+	trackerID string
+	imdbID    int
+	infoHash  string
+}
+
+// NewDataLookup returns a PTP lookup using the definition's endpoint and the
+// supplied immutable config and HTTP client.
+func (d *Definition) NewDataLookup(cfg config.Config, httpClient *http.Client, _ api.Logger) trackers.DataLookup {
+	return &dataLookup{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: strings.TrimRight(d.baseURL, "/") + ptpTorrentPath,
+	}
+}
+
+// Lookup resolves a torrent by tracker ID or release-name search, then
+// independently projects its identifiers, cleaned description, and images.
+// Missing credentials, non-success responses, and misses return an empty or
+// partial result without error.
+func (l *dataLookup) Lookup(ctx context.Context, req trackers.DataLookupRequest) (trackers.DataLookupResult, error) {
+	apiUser, apiKey := ptpAPIKeys(l.cfg)
+	if apiUser == "" || apiKey == "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	headers := map[string]string{"ApiUser": apiUser, "ApiKey": apiKey}
+	foundID := strings.TrimSpace(req.TrackerID)
+	var found ptpLookup
+	var err error
+	if foundID != "" {
+		found, err = l.fetchByID(ctx, headers, foundID)
+	} else {
+		found, err = l.search(ctx, headers, req.SearchName)
+		foundID = found.trackerID
+	}
+	if err != nil {
+		return trackers.DataLookupResult{}, err
+	}
+	if found.imdbID == 0 && foundID == "" {
+		return trackers.DataLookupResult{}, nil
+	}
+	result := trackers.DataLookupResult{
+		TrackerID: foundID,
+		IMDBID:    found.imdbID,
+		InfoHash:  found.infoHash,
+	}
+	if foundID == "" || req.OnlyID && !req.KeepImages {
+		return result, nil
+	}
+	description, err := l.description(ctx, headers, foundID)
+	if err != nil {
+		return result, err
+	}
+	report := CleanDescription(description, req.Meta.DiscType)
+	if !req.OnlyID {
+		result.Description = strings.TrimSpace(report.Description)
+	}
+	if req.KeepImages {
+		result.Images = report.Images
+	}
+	return result, nil
+}
+
+func (l *dataLookup) fetchByID(ctx context.Context, headers map[string]string, id string) (ptpLookup, error) {
+	body, err := l.getJSON(ctx, url.Values{"torrentid": {id}}, headers)
+	if err != nil || len(body) == 0 {
+		return ptpLookup{}, err
+	}
+	return parsePTPResponse(body, id, ""), nil
+}
+
+func (l *dataLookup) search(ctx context.Context, headers map[string]string, search string) (ptpLookup, error) {
+	if strings.TrimSpace(search) == "" {
+		return ptpLookup{}, nil
+	}
+	body, err := l.getJSON(ctx, url.Values{"searchstr": {search}}, headers)
+	if err != nil || len(body) == 0 {
+		return ptpLookup{}, err
+	}
+	for _, raw := range ptpSlice(body["Movies"]) {
+		item := ptpMap(raw)
+		lookup := parsePTPResponse(item, "", search)
+		if id := ptpInt(item["ImdbId"]); id != 0 {
+			lookup.imdbID = id
+		}
+		if lookup.imdbID != 0 || lookup.trackerID != "" {
+			return lookup, nil
+		}
+	}
+	return ptpLookup{}, nil
+}
+
+func (l *dataLookup) description(ctx context.Context, headers map[string]string, id string) (string, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, l.endpoint, nil)
+	if err != nil {
+		return "", fmt.Errorf("trackerdata: ptp description request: %w", err)
+	}
+	req.URL.RawQuery = url.Values{"id": {id}, "action": {"get_description"}}.Encode()
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	resp, err := l.http.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("trackerdata: ptp description request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return "", nil
+	}
+	payload, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("trackerdata: ptp description read: %w", err)
+	}
+	return string(payload), nil
+}
+
+func (l *dataLookup) getJSON(ctx context.Context, params url.Values, headers map[string]string) (map[string]any, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, l.endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: request: %w", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	resp, err := l.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackerdata: request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return nil, nil
+	}
+	var result map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&result); err != nil {
+		return nil, fmt.Errorf("trackerdata: decode: %w", err)
+	}
+	return result, nil
+}
+
+func parsePTPResponse(body map[string]any, trackerID, searchTerm string) ptpLookup {
+	selectedID, infoHash := strings.TrimSpace(trackerID), ""
+	needle := strings.ToLower(strings.TrimSpace(searchTerm))
+	for _, raw := range ptpSlice(body["Torrents"]) {
+		item := ptpMap(raw)
+		id := ptpString(item["Id"])
+		releaseName := strings.ToLower(ptpString(item["ReleaseName"]))
+		if selectedID == "" && needle != "" && strings.Contains(releaseName, needle) {
+			selectedID, infoHash = id, ptpString(item["InfoHash"])
+			break
+		}
+		if selectedID != "" && selectedID == id {
+			infoHash = ptpString(item["InfoHash"])
+			break
+		}
+		if selectedID == "" {
+			selectedID, infoHash = id, ptpString(item["InfoHash"])
+		}
+	}
+	return ptpLookup{
+		trackerID: selectedID,
+		imdbID:    ptpInt(body["ImdbId"]),
+		infoHash:  infoHash,
+	}
+}
+
+func ptpMap(value any) map[string]any { result, _ := value.(map[string]any); return result }
+func ptpSlice(value any) []any        { result, _ := value.([]any); return result }
+func ptpInt(value any) int {
+	trimmed := strings.TrimPrefix(ptpString(value), "tt")
+	parsed, _ := strconv.Atoi(trimmed)
+	return parsed
+}
diff --git a/internal/trackers/impl/standalone/ptp/definition.go b/internal/trackers/impl/standalone/ptp/definition.go
new file mode 100644
index 00000000..56ea81d2
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/definition.go
@@ -0,0 +1,99 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+// DataLookupConfigured reports whether PTP metadata lookup credentials are available.
+func (d *Definition) DataLookupConfigured(cfg config.Config) bool {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "PTP") {
+			return strings.TrimSpace(entry.PTPAPIUser) != "" && strings.TrimSpace(entry.PTPAPIKey) != ""
+		}
+	}
+	return false
+}
+func bannedGroups() []string {
+	return []string{
+		"aXXo",
+		"BMDru",
+		"BRrip",
+		"CM8",
+		"CrEwSaDe",
+		"CTFOH",
+		"d3g",
+		"DNL",
+		"FaNGDiNG0",
+		"HD2DVD",
+		"HDT",
+		"HDTime",
+		"ION10",
+		"iPlanet",
+		"KiNGDOM",
+		"mHD",
+		"mSD",
+		"nHD",
+		"nikt0",
+		"nSD",
+		"NhaNc3",
+		"OFT",
+		"PRODJi",
+		"SANTi",
+		"SPiRiT",
+		"STUTTERSHIT",
+		"ViSION",
+		"VXT",
+		"WAF",
+		"x0r",
+		"YIFY",
+		"LAMA",
+		"WORLD",
+	}
+}
+
+func prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	select {
+	case <-ctx.Done():
+		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
+	default:
+	}
+
+	assets := trackers.DescriptionAssets{}
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		resolvedAssets, err := trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
+			}
+			if req.Logger != nil {
+				req.Logger.Warnf("trackers: PTP description assets failed: %v", err)
+			}
+		} else {
+			assets = resolvedAssets
+		}
+	}
+
+	description := strings.TrimSpace(assets.Description)
+	if !assets.Final {
+		description = buildDescription(req.Meta, req.TrackerConfig, req.Runtime.DescriptionConfig(), assets)
+	}
+	if strings.TrimSpace(description) == "" && req.Logger != nil {
+		req.Logger.Infof("trackers: PTP preparation description empty")
+	}
+
+	return trackers.DescriptionResult{
+		Group:       "ptp",
+		Description: description,
+	}, nil
+}
diff --git a/internal/trackers/impl/standalone/ptp/definition_test.go b/internal/trackers/impl/standalone/ptp/definition_test.go
new file mode 100644
index 00000000..f52a7ede
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/definition_test.go
@@ -0,0 +1,692 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/netip"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/anacrolix/torrent/metainfo"
+	mkbrr "github.com/autobrr/mkbrr/torrent"
+
+	"github.com/autobrr/upbrr/internal/config"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func (d *Definition) prepareDryRun(ctx context.Context, input trackers.PreparationInput) (api.TrackerDryRunEntry, error) {
+	input.Intent = trackers.PreparationIntentDryRun
+	plan, failure := trackers.PrepareAdapter(ctx, input, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, d.baseURL)
+	})
+	if failure != nil {
+		return api.TrackerDryRunEntry{}, failure
+	}
+	return plan.DryRun(), nil
+}
+
+func (d *Definition) submit(ctx context.Context, input trackers.PreparationInput) (api.UploadSummary, error) {
+	return uploadAt(ctx, input, d.baseURL)
+}
+
+func TestDefinitionBuildDescriptionUsesPTPGroup(t *testing.T) {
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta:    api.UploadSubject{},
+		Logger:  api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result.Group != "ptp" {
+		t.Fatalf("expected ptp group, got %q", result.Group)
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesResolvedAssetsAndMediaInfo(t *testing.T) {
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			MediaInfoTextPath: mediaInfoPath,
+			Options:           api.UploadOptions{Screens: 1},
+		},
+		Assets: &trackers.DescriptionAssets{
+			Description: "kept https://pixhost.to/show/encoded.png",
+			Screenshots: []api.ScreenshotImage{{
+				Host:   "pixhost",
+				RawURL: "https://pixhost.to/show/encoded.png",
+			}},
+		},
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(result.Description, "[mediainfo]General\nUnique ID : 123[/mediainfo]") {
+		t.Fatalf("expected mediainfo section, got %q", result.Description)
+	}
+	if !strings.Contains(result.Description, "kept") || !strings.Contains(result.Description, "[img]https://pixhost.to/show/encoded.png[/img]") {
+		t.Fatalf("expected resolved asset description, got %q", result.Description)
+	}
+	if strings.Contains(result.Description, "lostimg.cc") {
+		t.Fatalf("expected no stale image hosts, got %q", result.Description)
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesAllResolvedPixhostScreenshots(t *testing.T) {
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	screenshots := []api.ScreenshotImage{
+		{Host: "pixhost", RawURL: "https://pixhost.to/1.png"},
+		{Host: "pixhost", RawURL: "https://pixhost.to/2.png"},
+		{Host: "pixhost", RawURL: "https://pixhost.to/3.png"},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			MediaInfoTextPath: mediaInfoPath,
+			Options:           api.UploadOptions{Screens: 2},
+		},
+		Assets: &trackers.DescriptionAssets{Screenshots: screenshots},
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	for _, screenshot := range screenshots {
+		if !strings.Contains(result.Description, "[img]"+screenshot.RawURL+"[/img]") {
+			t.Fatalf("expected screenshot %q in description, got %q", screenshot.RawURL, result.Description)
+		}
+	}
+}
+
+func TestDefinitionBuildDescriptionUsesAllowedNonPixhostRawScreenshots(t *testing.T) {
+	tmp := t.TempDir()
+	mediaInfoPath := filepath.Join(tmp, "mediainfo.txt")
+	if err := os.WriteFile(mediaInfoPath, []byte("General\nUnique ID : 123"), 0o600); err != nil {
+		t.Fatalf("write mediainfo: %v", err)
+	}
+
+	screenshots := []api.ScreenshotImage{
+		{
+			Host:   "imgbb",
+			RawURL: "https://i.ibb.co/raw-1/source.png",
+			ImgURL: "https://i.ibb.co/thumb-1/source.png",
+		},
+		{
+			Host:   "onlyimage",
+			RawURL: "https://onlyimage.org/images/raw-2.png",
+			ImgURL: "https://onlyimage.org/images/medium-2.png",
+		},
+		{
+			Host:   "ptscreens",
+			RawURL: "https://ptscreens.com/images/raw-3.png",
+			ImgURL: "https://ptscreens.com/images/medium-3.png",
+		},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			MediaInfoTextPath: mediaInfoPath,
+			Options:           api.UploadOptions{Screens: 2},
+		},
+		Assets: &trackers.DescriptionAssets{Screenshots: screenshots},
+		Logger: api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	for _, screenshot := range screenshots {
+		if !strings.Contains(result.Description, "[img]"+screenshot.RawURL+"[/img]") {
+			t.Fatalf("expected raw screenshot %q in description, got %q", screenshot.RawURL, result.Description)
+		}
+		if strings.Contains(result.Description, screenshot.ImgURL) {
+			t.Fatalf("expected PTP description to avoid non-raw URL %q, got %q", screenshot.ImgURL, result.Description)
+		}
+	}
+}
+
+func TestDefinitionBuildUploadDryRunForExistingGroup(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case ptpTorrentPath:
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"Movies": []map[string]any{{"GroupId": "1234"}},
+			})
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	entry, err := (&Definition{baseURL: server.URL}).prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			ReleaseName: "Movie.2026.1080p.BluRay.x264",
+			Source:      "BluRay",
+			VideoCodec:  "AVC",
+			Identity:    api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Title:  "Movie",
+					Year:   2026,
+					Poster: "https://img.example/poster.jpg",
+					Genres: "Action",
+				},
+			},
+		},
+		TrackerConfig: config.TrackerConfig{
+			PTPAPIUser: "user",
+			PTPAPIKey:  "key",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
+		Logger:  api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected dry-run error: %v", err)
+	}
+	if got := entry.Payload["groupid"]; got != "1234" {
+		t.Fatalf("expected existing group id, got %q", got)
+	}
+	if _, exists := entry.Payload["title"]; exists {
+		t.Fatal("did not expect new-group title field when group already exists")
+	}
+	if entry.Questionnaire != nil {
+		t.Fatal("did not expect questionnaire for existing group upload")
+	}
+}
+
+func TestDefinitionBuildUploadDryRunForNewGroupIncludesQuestionnaire(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
+
+	entry, err := New().prepareDryRun(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			ReleaseName: "Movie.2026.1080p.BluRay.x264",
+			Source:      "BluRay",
+			VideoCodec:  "AVC",
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Title:    "Movie",
+					Year:     2026,
+					Poster:   "https://img.example/poster.jpg",
+					Genres:   "Action",
+					Overview: "Plot",
+				},
+			},
+		},
+		TrackerConfig: config.TrackerConfig{},
+		Runtime:       trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
+		Logger:        api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected dry-run error: %v", err)
+	}
+	if entry.Questionnaire == nil {
+		t.Fatal("expected questionnaire for new group upload")
+	}
+	if got := len(entry.Questionnaire.Fields); got == 0 {
+		t.Fatal("expected questionnaire fields")
+	}
+	if entry.Questionnaire.Fields[0].Key != "title" {
+		t.Fatalf("expected first questionnaire field to be title, got %q", entry.Questionnaire.Fields[0].Key)
+	}
+	if got := entry.Payload["imdb"]; got != "0" {
+		t.Fatalf("expected missing IMDb dry-run payload value 0, got %q", got)
+	}
+}
+
+func TestResolveUploadTorrentPathReusesPreparedPTPArtifact(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "ua.db")
+	sourcePath := filepath.Join(tmp, "Movie.mkv")
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
+
+	preparedMeta, err := trackers.PrepareTrackerUploadTorrent(
+		api.UploadSubject{SourcePath: sourcePath, TorrentPath: torrentPath},
+		dbPath,
+		"PTP",
+		config.TrackerConfig{AnnounceURL: "https://please.passthepopcorn.me/passkey/announce"},
+	)
+	if err != nil {
+		t.Fatalf("prepare tracker torrent: %v", err)
+	}
+
+	resolvedPath, err := resolveUploadTorrentPath(preparedMeta, dbPath)
+	if err != nil {
+		t.Fatalf("resolve upload torrent path: %v", err)
+	}
+	if resolvedPath != preparedMeta.TorrentPath {
+		t.Fatalf("expected prepared artifact path %q, got %q", preparedMeta.TorrentPath, resolvedPath)
+	}
+
+	torrentMeta, err := metainfo.LoadFromFile(resolvedPath)
+	if err != nil {
+		t.Fatalf("load prepared artifact: %v", err)
+	}
+	if torrentMeta.Announce != "https://please.passthepopcorn.me/passkey/announce" {
+		t.Fatal("expected prepared announce preserved")
+	}
+	info, err := torrentMeta.UnmarshalInfo()
+	if err != nil {
+		t.Fatalf("unmarshal prepared info: %v", err)
+	}
+	if info.Source != "PTP" {
+		t.Fatalf("expected prepared source preserved, got %q", info.Source)
+	}
+}
+
+func TestDefinitionUploadSuccess(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := newPTPAuthDB(t)
+	torrentPath := filepath.Join(tmp, "release.torrent")
+	createTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
+	markTorrentWithPrivateMetadata(t, torrentPath)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.RequestURI() {
+		case ptpLoginPath:
+			if err := r.ParseForm(); err != nil {
+				t.Errorf("parse login: %v", err)
+				return
+			}
+			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" {
+				t.Error("unexpected login credentials")
+				return
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "cookievalue",
+				Path:  "/",
+			})
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"Result":        "Ok",
+				"AntiCsrfToken": "csrf-token",
+			})
+		default:
+			switch r.URL.Path {
+			case ptpUploadPath:
+				if err := r.ParseMultipartForm(5 << 20); err != nil {
+					t.Errorf("parse multipart: %v", err)
+					return
+				}
+				files := r.MultipartForm.File["file_input"]
+				if len(files) != 1 {
+					t.Errorf("expected one torrent file, got %d", len(files))
+					return
+				}
+				uploaded, err := files[0].Open()
+				if err != nil {
+					t.Errorf("open uploaded torrent: %v", err)
+					return
+				}
+				defer uploaded.Close()
+				payload, err := io.ReadAll(uploaded)
+				if err != nil {
+					t.Errorf("read uploaded torrent: %v", err)
+					return
+				}
+				uploadedMeta, err := metainfo.Load(bytes.NewReader(payload))
+				if err != nil {
+					t.Errorf("load uploaded torrent: %v", err)
+					return
+				}
+				if uploadedMeta.Comment != "upbrr" {
+					t.Errorf("expected cleaned upload torrent comment, got %q", uploadedMeta.Comment)
+					return
+				}
+				if uploadedMeta.CreatedBy != "uploaded with upbrr" {
+					t.Errorf("expected cleaned upload torrent created-by, got %q", uploadedMeta.CreatedBy)
+					return
+				}
+				if uploadedMeta.Announce != "" {
+					t.Error("expected upload torrent announce stripped")
+					return
+				}
+				if r.FormValue("AntiCsrfToken") != "csrf-token" {
+					t.Error("expected csrf token")
+					return
+				}
+				if r.FormValue("title") != "Movie" {
+					t.Error("expected new-group title field")
+					return
+				}
+				http.Redirect(w, r, "/torrents.php?id=555&torrentid=666", http.StatusFound)
+			case ptpTorrentPath:
+				w.WriteHeader(http.StatusOK)
+				_, _ = w.Write([]byte("ok"))
+			default:
+				w.WriteHeader(http.StatusNotFound)
+			}
+		}
+	}))
+	defer server.Close()
+
+	result, err := (&Definition{baseURL: server.URL}).submit(context.Background(), trackers.PreparationInput{
+		Tracker: "PTP",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			ReleaseName: "Movie.2026.1080p.BluRay.x264",
+			Source:      "BluRay",
+			VideoCodec:  "AVC",
+			Identity:    api.ExternalIdentity{Category: "MOVIE", IMDBID: 1234567},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					Title:    "Movie",
+					Year:     2026,
+					Poster:   "https://img.example/poster.jpg",
+					Genres:   "Action",
+					Overview: "Plot",
+				},
+			},
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username:    "user",
+			Password:    "pass",
+			AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:  api.NopLogger{},
+	})
+	if err != nil {
+		t.Fatalf("unexpected upload error: %v", err)
+	}
+	if result.Uploaded != 1 {
+		t.Fatalf("expected uploaded=1, got %d", result.Uploaded)
+	}
+	if len(result.UploadedTorrents) != 1 {
+		t.Fatalf("expected uploaded torrent artifact")
+	}
+	if result.UploadedTorrents[0].TorrentID != "666" {
+		t.Fatalf("expected torrent id 666, got %q", result.UploadedTorrents[0].TorrentID)
+	}
+	artifactPath := result.UploadedTorrents[0].TorrentPath
+	if strings.TrimSpace(artifactPath) == "" {
+		t.Fatal("expected tracker torrent path")
+	}
+	if _, err := os.Stat(artifactPath); err != nil {
+		t.Fatalf("expected tracker torrent file: %v", err)
+	}
+	legacyCookiePath, err := servicedb.CookiePath(dbPath, ptpCookieFile)
+	if err != nil {
+		t.Fatalf("resolve legacy PTP cookie path: %v", err)
+	}
+	if _, err := os.Stat(legacyCookiePath); !os.IsNotExist(err) {
+		t.Fatalf("expected no legacy PTP cookie file after upload, got err=%v", err)
+	}
+}
+
+func TestLoginAndFetchAntiCsrfTokenHandles2FA(t *testing.T) {
+	secondLogin := false
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.RequestURI() != ptpLoginPath {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		if err := r.ParseForm(); err != nil {
+			t.Errorf("parse login: %v", err)
+			return
+		}
+		if r.FormValue("username") != "user" || r.FormValue("password") != "pass" || r.FormValue("passkey") != "passkey" || r.FormValue("keeplogged") != "1" {
+			t.Error("unexpected login form")
+			return
+		}
+		if r.FormValue("TfaCode") == "" {
+			_ = json.NewEncoder(w).Encode(map[string]any{"Result": "TfaRequired"})
+			return
+		}
+		secondLogin = true
+		if r.FormValue("TfaType") != "normal" {
+			t.Errorf("expected TfaType normal, got %q", r.FormValue("TfaType"))
+			return
+		}
+		code := r.FormValue("TfaCode")
+		if len(code) != 6 || strings.Trim(code, "0123456789") != "" {
+			t.Errorf("expected six digit TfaCode, got %q", code)
+			return
+		}
+		http.SetCookie(w, &http.Cookie{
+			Name:  "session",
+			Value: "cookievalue",
+			Path:  "/",
+		})
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"Result":        "Ok",
+			"AntiCsrfToken": "csrf-token",
+		})
+	}))
+	defer server.Close()
+
+	dbPath := newPTPAuthDB(t)
+	client, token, err := loginAndFetchAntiCsrfToken(context.Background(), config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+		OTPURI:      "otpauth://totp/PTP:user?secret=JBSWY3DPEHPK3PXP&issuer=PTP",
+	}, dbPath, server.URL, api.NopLogger{}, api.TrackerAuthLoginRequest{})
+	if err != nil {
+		t.Fatalf("login: %v", err)
+	}
+	if token != "csrf-token" {
+		t.Fatalf("expected csrf token, got %q", token)
+	}
+	if client == nil {
+		t.Fatal("expected authenticated client")
+	}
+	if !secondLogin {
+		t.Fatal("expected second 2FA login request")
+	}
+}
+
+func TestRehostPosterToSelectedHostUploadsPoster(t *testing.T) {
+	tmp := t.TempDir()
+	dbPath := filepath.Join(tmp, "ua.db")
+	sourcePath := filepath.Join(tmp, "Movie.mkv")
+	if err := os.WriteFile(sourcePath, []byte("movie"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+
+	posterServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "image/png")
+		_, _ = w.Write([]byte("poster-bytes"))
+	}))
+	defer posterServer.Close()
+	originalClientFactory := newPosterHTTPClient
+	newPosterHTTPClient = posterServer.Client
+	t.Cleanup(func() {
+		newPosterHTTPClient = originalClientFactory
+	})
+
+	images := &stubPTPImageHosting{
+		uploaded: []api.UploadedImageLink{{
+			Host:   "pixhost",
+			RawURL: "https://pixhost.to/rehosted.png",
+		}},
+	}
+	got := rehostPosterToSelectedHost(context.Background(), trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			SourcePath: sourcePath,
+		},
+		Runtime:           trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+		Logger:            api.NopLogger{},
+		SelectedImageHost: "pixhost",
+		UploadImages: func(ctx context.Context, uploaded []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+			return images.Upload(ctx, api.ImageHostingSubject{}, "pixhost", "global", uploaded)
+		},
+	}, posterServer.URL+"/poster")
+
+	if got != "https://pixhost.to/rehosted.png" {
+		t.Fatalf("expected rehosted poster URL, got %q", got)
+	}
+	if images.host != "pixhost" {
+		t.Fatalf("expected pixhost upload host, got %q", images.host)
+	}
+	if len(images.images) != 1 {
+		t.Fatalf("expected one uploaded poster, got %d", len(images.images))
+	}
+	posterPath := images.images[0].Path
+	if filepath.Base(posterPath) != "PTP_POSTER.png" {
+		t.Fatalf("expected content-type poster extension, got %q", filepath.Base(posterPath))
+	}
+	body, err := os.ReadFile(posterPath)
+	if err != nil {
+		t.Fatalf("read poster: %v", err)
+	}
+	if string(body) != "poster-bytes" {
+		t.Fatalf("unexpected poster body %q", string(body))
+	}
+}
+
+func TestRehostPosterToSelectedHostRejectsLoopbackPoster(t *testing.T) {
+	tmp := t.TempDir()
+	sourcePath := filepath.Join(tmp, "Movie.mkv")
+	if err := os.WriteFile(sourcePath, []byte("movie"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	posterServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write([]byte("poster-bytes"))
+	}))
+	defer posterServer.Close()
+
+	images := &stubPTPImageHosting{
+		uploaded: []api.UploadedImageLink{{
+			Host:   "pixhost",
+			RawURL: "https://pixhost.to/rehosted.png",
+		}},
+	}
+	got := rehostPosterToSelectedHost(context.Background(), trackers.PreparationInput{
+		Meta: api.UploadSubject{
+			SourcePath: sourcePath,
+		},
+		Runtime:           trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: filepath.Join(tmp, "ua.db")}}),
+		Logger:            api.NopLogger{},
+		SelectedImageHost: "pixhost",
+		UploadImages: func(ctx context.Context, uploaded []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+			return images.Upload(ctx, api.ImageHostingSubject{}, "pixhost", "global", uploaded)
+		},
+	}, posterServer.URL+"/poster")
+
+	if got != posterServer.URL+"/poster" {
+		t.Fatalf("expected original poster URL after blocked rehost, got %q", got)
+	}
+	if len(images.images) != 0 {
+		t.Fatalf("expected no upload for blocked loopback poster")
+	}
+}
+
+func TestIsPublicPosterIPRejectsPrivateRanges(t *testing.T) {
+	t.Parallel()
+
+	for _, value := range []string{"127.0.0.1", "10.0.0.1", "192.168.1.20", "169.254.1.1", "::1", "fc00::1"} {
+		if isPublicPosterIP(netip.MustParseAddr(value)) {
+			t.Fatalf("expected %s to be rejected", value)
+		}
+	}
+	if !isPublicPosterIP(netip.MustParseAddr("93.184.216.34")) {
+		t.Fatal("expected public address to be accepted")
+	}
+}
+
+func TestRehostPosterToSelectedHostSkipsSelectedHost(t *testing.T) {
+	images := &stubPTPImageHosting{}
+	got := rehostPosterToSelectedHost(context.Background(), trackers.PreparationInput{
+		SelectedImageHost: "pixhost",
+		UploadImages: func(ctx context.Context, uploaded []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+			return images.Upload(ctx, api.ImageHostingSubject{}, "pixhost", "global", uploaded)
+		},
+	}, "https://pixhost.to/existing.jpg")
+	if got != "https://pixhost.to/existing.jpg" {
+		t.Fatalf("expected original poster URL, got %q", got)
+	}
+	if len(images.images) != 0 {
+		t.Fatalf("expected no upload for selected host poster")
+	}
+}
+
+type stubPTPImageHosting struct {
+	host     string
+	scope    string
+	images   []api.ScreenshotImage
+	uploaded []api.UploadedImageLink
+}
+
+func (s *stubPTPImageHosting) ListCandidates(context.Context, api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
+	return nil, nil
+}
+
+func (s *stubPTPImageHosting) Upload(_ context.Context, _ api.ImageHostingSubject, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+	s.host = host
+	s.scope = usageScope
+	s.images = append([]api.ScreenshotImage(nil), images...)
+	return s.uploaded, nil
+}
+
+func createTestTorrent(t *testing.T, sourcePath string, torrentPath string) {
+	t.Helper()
+
+	if err := os.WriteFile(sourcePath, []byte("data"), 0o600); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	_, err := mkbrr.Create(mkbrr.CreateOptions{
+		Path:       sourcePath,
+		OutputPath: torrentPath,
+		IsPrivate:  true,
+	})
+	if err != nil {
+		t.Fatalf("create torrent: %v", err)
+	}
+}
+
+func markTorrentWithPrivateMetadata(t *testing.T, torrentPath string) {
+	t.Helper()
+
+	torrentMeta, err := metainfo.LoadFromFile(torrentPath)
+	if err != nil {
+		t.Fatalf("load torrent: %v", err)
+	}
+	torrentMeta.Announce = "https://private.example/passkey/announce"
+	torrentMeta.Comment = "Created by Upload Assistant https://private.example/download/1"
+	file, err := os.Create(torrentPath)
+	if err != nil {
+		t.Fatalf("rewrite torrent: %v", err)
+	}
+	defer file.Close()
+	if err := torrentMeta.Write(file); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+}
diff --git a/internal/trackers/impl/standalone/ptp/dupe.go b/internal/trackers/impl/standalone/ptp/dupe.go
new file mode 100644
index 00000000..71eb2f28
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/dupe.go
@@ -0,0 +1,144 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// newDuplicateAdapterAt returns a duplicate-search adapter bound to one
+// immutable dependency set and base URL.
+func newDuplicateAdapterAt(deps dupe.Dependencies, baseURL string) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: strings.TrimRight(baseURL, "/") + ptpTorrentPath,
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiUser, apiKey := ptpAPIKeys(s.cfg)
+	if apiUser == "" || apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing ApiUser/ApiKey for tracker", nil)
+	}
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb id for PTP dupe search", nil)
+	}
+	headers := map[string]string{"ApiUser": apiUser, "ApiKey": apiKey}
+	groupPayload, err := s.get(ctx, url.Values{"imdb": {"tt" + strconv.Itoa(meta.Identity.IMDBID)}}, headers)
+	if err != nil || len(groupPayload) == 0 {
+		return dupe.Failed(dupe.FailureRequest, "PTP group search failed", err)
+	}
+	groupID := ptpGroupID(groupPayload)
+	if groupID == "" {
+		return dupe.Resolved(nil, nil)
+	}
+	payload, err := s.get(ctx, url.Values{"id": {groupID}}, headers)
+	if err != nil || len(payload) == 0 {
+		return dupe.Failed(dupe.FailureRequest, "PTP torrent search failed", err)
+	}
+	return dupe.Resolved(ptpDupeEntries(payload, meta.Release.Resolution, strings.TrimSuffix(s.endpoint, ptpTorrentPath)), nil)
+}
+
+func (s *dupeSearcher) get(ctx context.Context, params url.Values, headers map[string]string) (map[string]any, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("ptp dupe request: %w", err)
+	}
+	req.URL.RawQuery = params.Encode()
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("ptp dupe request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return nil, strconv.ErrSyntax
+	}
+	var payload map[string]any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&payload); err != nil {
+		return nil, fmt.Errorf("ptp dupe decode: %w", err)
+	}
+	return payload, nil
+}
+
+func ptpAPIKeys(cfg config.Config) (string, string) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "PTP") {
+			return strings.TrimSpace(entry.PTPAPIUser), strings.TrimSpace(entry.PTPAPIKey)
+		}
+	}
+	return "", ""
+}
+
+func ptpGroupID(payload map[string]any) string {
+	if movies, ok := payload["Movies"].([]any); ok && len(movies) > 0 {
+		if movie, ok := movies[0].(map[string]any); ok {
+			return ptpString(movie["GroupId"])
+		}
+	}
+	return ptpString(payload["GroupId"])
+}
+
+func ptpDupeEntries(payload map[string]any, resolution string, baseURL string) []api.DupeEntry {
+	quality := "High Definition"
+	res := strings.ToLower(strings.TrimSpace(resolution))
+	if res == "480p" || res == "480i" || res == "576p" || res == "576i" || res == "sd" {
+		quality = "Standard Definition"
+	} else if strings.Contains(res, "2160") || strings.Contains(res, "4320") || strings.Contains(res, "8640") {
+		quality = "Ultra High Definition"
+	}
+	torrents, _ := payload["Torrents"].([]any)
+	entries := make([]api.DupeEntry, 0, len(torrents))
+	for _, raw := range torrents {
+		item, ok := raw.(map[string]any)
+		if !ok || ptpString(item["Quality"]) != "" && !strings.EqualFold(ptpString(item["Quality"]), quality) {
+			continue
+		}
+		id := ptpString(item["Id"])
+		entries = append(entries, api.DupeEntry{
+			Name: strings.TrimSpace("[" + ptpString(item["Resolution"]) + "] " + ptpString(item["ReleaseName"])),
+			ID:   id,
+			Link: strings.TrimRight(baseURL, "/") + ptpTorrentPath + "?torrentid=" + id,
+		})
+	}
+	return entries
+}
+
+func ptpString(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case json.Number:
+		return typed.String()
+	case float64:
+		return strconv.FormatFloat(typed, 'f', -1, 64)
+	default:
+		return ""
+	}
+}
diff --git a/internal/trackers/impl/standalone/ptp/profile.go b/internal/trackers/impl/standalone/ptp/profile.go
new file mode 100644
index 00000000..ec9c542a
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/profile.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"context"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns PTP identity, preparation, dupe, auth, bans, and policies.
+// Its missing-IMDb metadata result is advisory and does not block upload.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:               "PTP",
+		BaseURL:            ptpBaseURL,
+		DescriptionGroup:   "ptp",
+		UploadContentMode:  trackers.UploadContentModeDescription,
+		PrepareDescription: prepareDescription,
+		PrepareUpload: func(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+			return prepareUploadAt(ctx, req, ptpBaseURL)
+		},
+		NewDuplicateAdapter: func(deps dupe.Dependencies) dupe.Adapter { return newDuplicateAdapterAt(deps, ptpBaseURL) },
+		Rules:               &trackers.RuleSet{RequireMovieUnlessTVPack: true},
+		BannedGroups:        bannedGroups(),
+		DataPolicy:          &trackers.DataLookupPolicy{Cooldown: time.Minute},
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{Requirements: []trackers.MetadataRequirement{{
+			Scope:       trackers.MetadataScopeAny,
+			AnyOf:       []trackers.MetadataField{trackers.MetadataFieldIMDBIDOnly},
+			Disposition: api.RuleDispositionAdvisory,
+		}}},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: "PTP"},
+		ImageHostPolicy: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"pixhost", "imgbb", "onlyimage", "ptscreens", "passtheimage"},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{ptpBaseURL},
+			CommentURLPatterns: []string{ptpBaseURL},
+			DetailIDPattern:    "torrentid=(\\d+)",
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:          "PTP",
+			DisplayName:        "PTP",
+			AuthKind:           "cookies_login_manual_2fa",
+			SupportsCookieFile: true,
+			SupportsLogin:      true,
+			SupportsAutoLogin:  true,
+			SupportsTOTP:       true,
+			SupportsManual2FA:  true,
+		},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+			return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, login, ptpBaseURL)
+		},
+		AuthPolicy: &trackers.AuthPolicy{LoginRequiresAnnounceURL: true},
+	}
+}
+
+// Definition extends the shared standalone definition with PTP data lookup and testable endpoints.
+type Definition struct {
+	*standalone.Definition
+	baseURL string
+}
+
+// New returns a fresh PTP definition from its tracker-local profile.
+func New() *Definition {
+	return &Definition{Definition: standalone.MustNew(Profile()), baseURL: ptpBaseURL}
+}
diff --git a/internal/trackers/impl/standalone/ptp/upload.go b/internal/trackers/impl/standalone/ptp/upload.go
new file mode 100644
index 00000000..4e6f36cf
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/upload.go
@@ -0,0 +1,1619 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1" //nolint:gosec // TOTP interoperability requires SHA-1.
+	"encoding/base32"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"mime/multipart"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/netip"
+	"net/url"
+	"os"
+	"path" //nolint:depguard // Reads poster URL path extension, not local filesystem extension.
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	ptpBaseURL     = "https://passthepopcorn.me"
+	ptpUploadPath  = "/upload.php"
+	ptpTorrentPath = "/torrents.php"
+	ptpLoginPath   = "/ajax.php?action=login"
+	ptpCookieFile  = "PTP.json"
+	ptpUserAgent   = "upbrr"
+)
+
+var (
+	ptpAntiCsrfPattern     = regexp.MustCompile(`data-AntiCsrfToken="([^"]+)"`)
+	ptpSuccessPattern      = regexp.MustCompile(`torrents\.php\?id=(\d+)&torrentid=(\d+)`)
+	newPosterHTTPClient    = newPublicPosterHTTPClient
+	reservedPosterPrefixes = []netip.Prefix{
+		netip.MustParsePrefix("0.0.0.0/8"),
+		netip.MustParsePrefix("100.64.0.0/10"),
+		netip.MustParsePrefix("192.0.0.0/24"),
+		netip.MustParsePrefix("192.0.2.0/24"),
+		netip.MustParsePrefix("198.18.0.0/15"),
+		netip.MustParsePrefix("198.51.100.0/24"),
+		netip.MustParsePrefix("203.0.113.0/24"),
+		netip.MustParsePrefix("240.0.0.0/4"),
+		netip.MustParsePrefix("2001:db8::/32"),
+		netip.MustParsePrefix("fc00::/7"),
+		netip.MustParsePrefix("fe80::/10"),
+	}
+)
+
+// ErrSubmitted2FARejected marks a PTP failure after a submitted manual 2FA code
+// reached the tracker and was rejected.
+var ErrSubmitted2FARejected = trackers.ErrSubmitted2FARejected
+
+type uploadState struct {
+	baseURL     string
+	uploadURL   string
+	announceURL string
+	client      *http.Client
+	groupID     string
+	torrentPath string
+	description string
+	fields      map[string]string
+}
+
+func uploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (api.UploadSummary, error) {
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, baseURL)
+	})
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTP submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadStateAt(ctx, req, req.Intent != trackers.PreparationIntentUpload, baseURL)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state, req.Meta)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+
+	body, contentType, err := buildMultipartPayload(state.fields, state.torrentPath, "file_input")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	trackerTorrentPath, err := resolveTrackerTorrentPath(req.Meta, req.Runtime.DBPath, "PTP")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType, trackerTorrentPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+	trackerTorrentPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTP request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", ptpUserAgent)
+
+	resp, err := state.client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTP upload request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	_, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTP read upload response: %w", err)
+	}
+	if matches := ptpSuccessPattern.FindStringSubmatch(finalURL); len(matches) == 3 {
+		groupID := strings.TrimSpace(matches[1])
+		torrentID := strings.TrimSpace(matches[2])
+		torrentURL := strings.TrimRight(state.baseURL, "/") + "/torrents.php?id=" + url.QueryEscape(groupID) + "&torrentid=" + url.QueryEscape(torrentID)
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, trackerTorrentPath, state.announceURL, torrentURL, "PTP"); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: PTP write torrent artifact: %w", err)
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "PTP",
+				TorrentID:   torrentID,
+				TorrentURL:  torrentURL,
+				DownloadURL: torrentURL,
+				TorrentPath: trackerTorrentPath,
+			}},
+		}, nil
+	}
+
+	failurePath := ""
+	if pathValue, pathErr := resolveFailurePath(req.Meta, req.Runtime.DBPath); pathErr == nil {
+		failurePath = pathValue
+		redactedBody := []byte(redaction.RedactValue(string(responsePreview), nil))
+		_ = os.WriteFile(failurePath, redactedBody, 0o600)
+	}
+	errText := commonhttp.RedactErrorDetail(extractAlertError(string(responsePreview)))
+	if errText == "" {
+		errText = commonhttp.ExtractHTTPErrorDetail(responsePreview)
+	}
+	if errText == "" {
+		errText = "upload failed"
+	}
+	if failurePath != "" {
+		return api.UploadSummary{}, fmt.Errorf(
+			"trackers: PTP upload failed status=%d url=%s error=%s failure=%s",
+			resp.StatusCode,
+			commonhttp.RedactErrorDetail(finalURL),
+			compactError(errText),
+			failurePath,
+		)
+	}
+	return api.UploadSummary{}, fmt.Errorf(
+		"trackers: PTP upload failed status=%d url=%s error=%s",
+		resp.StatusCode,
+		commonhttp.RedactErrorDetail(finalURL),
+		compactError(errText),
+	)
+}
+
+func buildUploadPreview(state uploadState, meta api.UploadSubject) api.TrackerDryRunEntry {
+	message := "dry-run payload generated"
+	if state.groupID != "" {
+		message += " for existing group"
+	} else {
+		message += " for new group"
+	}
+	fields := maps.Clone(state.fields)
+	if _, ok := fields["AntiCsrfToken"]; ok {
+		fields["AntiCsrfToken"] = "[redacted]"
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "PTP",
+		ReadyMessage:     message,
+		ReleaseName:      resolveUploadName(meta),
+		DescriptionGroup: "ptp",
+		Description:      state.description,
+		Endpoint:         state.uploadURL,
+		Payload:          fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file_input",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+		Questionnaire: buildQuestionnaire(meta, state.groupID),
+	})
+}
+
+func prepareUploadStateAt(ctx context.Context, req trackers.PreparationInput, dryRun bool, baseURL string) (uploadState, error) {
+	announceURL := normalizedAnnounceURL(req.TrackerConfig.AnnounceURL)
+	torrentPath, err := resolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: PTP resolve upload torrent: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, req.TrackerConfig, req.Runtime.DescriptionConfig(), assets)
+	groupID, err := lookupGroupID(ctx, baseURL, req.TrackerConfig, req.Meta)
+	if err != nil {
+		return uploadState{}, err
+	}
+	answers := standalone.QuestionnaireAnswers(req.Meta, "PTP")
+	poster := metautil.FirstNonEmptyTrimmed(answers["poster"], resolvePoster(req.Meta))
+	if !dryRun {
+		poster = rehostPosterToSelectedHost(ctx, req, poster)
+	}
+	fields, err := buildUploadFields(req.Meta, description, groupID, answers, poster)
+	if err != nil {
+		return uploadState{}, err
+	}
+	fields["AntiCsrfToken"] = "dry-run-token"
+
+	var client *http.Client
+	if !dryRun {
+		client, fields["AntiCsrfToken"], err = resolveSession(ctx, req.TrackerConfig, req.Runtime.DBPath, baseURL, req.Logger)
+		if err != nil {
+			return uploadState{}, err
+		}
+	}
+
+	return uploadState{
+		baseURL:     baseURL,
+		uploadURL:   baseURL + ptpUploadPath,
+		announceURL: announceURL,
+		client:      client,
+		groupID:     groupID,
+		torrentPath: torrentPath,
+		description: description,
+		fields:      fields,
+	}, nil
+}
+
+func resolveUploadTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
+	preparedPath, err := trackers.ResolveTrackerTorrentArtifactPath(meta, dbPath, "PTP")
+	if err == nil && strings.TrimSpace(meta.TorrentPath) == preparedPath {
+		if info, statErr := os.Stat(preparedPath); statErr == nil && !info.IsDir() {
+			return preparedPath, nil
+		}
+	}
+	path, err := trackers.ResolveUploadTorrentPath(meta, dbPath)
+	if err != nil {
+		return "", fmt.Errorf("trackers: resolve upload torrent path: %w", err)
+	}
+	return path, nil
+}
+
+func buildDescription(meta api.UploadSubject, trackerConfig config.TrackerConfig, appConfig config.Config, assets trackers.DescriptionAssets) string {
+	baseDescription := strings.TrimSpace(assets.Description)
+	if assets.Final {
+		return baseDescription
+	}
+	if baseDescription != "" {
+		report := CleanDescription(baseDescription, meta.DiscType)
+		baseDescription = strings.TrimSpace(report.Description)
+	}
+
+	var sections []string
+	if mediaSection, err := buildMediaSection(meta, appConfig.MainSettings.DBPath); err == nil && mediaSection != "" {
+		sections = append(sections, mediaSection)
+	}
+	if strings.TrimSpace(baseDescription) != "" {
+		sections = append(sections, convertDescription(baseDescription))
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" && trackerConfig.AddWebSourceToDesc {
+		sections = append(
+			sections,
+			fmt.Sprintf("[quote][align=center]This release is sourced from %s[/align][/quote]", strings.TrimSpace(meta.ServiceLongName)),
+		)
+	}
+	if shots := buildScreenshotSection(meta, assets.Screenshots); shots != "" {
+		sections = append(sections, shots)
+	}
+	return strings.TrimSpace(strings.Join(sections, "\n\n"))
+}
+
+func buildMediaSection(meta api.UploadSubject, dbPath string) (string, error) {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		text, err := readBDSummary(meta, dbPath)
+		if err != nil {
+			return "", err
+		}
+		if strings.TrimSpace(text) == "" {
+			return "", nil
+		}
+		return "[mediainfo]" + strings.TrimSpace(text) + "[/mediainfo]", nil
+	default:
+		text, err := readTextFile(strings.TrimSpace(meta.MediaInfoTextPath))
+		if err != nil {
+			return "", err
+		}
+		if strings.TrimSpace(text) == "" {
+			return "", nil
+		}
+		return "[mediainfo]" + strings.TrimSpace(text) + "[/mediainfo]", nil
+	}
+}
+
+func buildScreenshotSection(meta api.UploadSubject, screenshots []api.ScreenshotImage) string {
+	if len(screenshots) == 0 {
+		return ""
+	}
+	minimum := meta.Options.Screens
+	if minimum <= 0 {
+		minimum = 2
+	}
+	if requiresMinimumTwoScreens(meta) && minimum < 2 {
+		minimum = 2
+	}
+	allowed := make([]string, 0, len(screenshots))
+	for _, screenshot := range screenshots {
+		rawURL := strings.TrimSpace(screenshot.RawURL)
+		if rawURL == "" {
+			rawURL = strings.TrimSpace(screenshot.ImgURL)
+		}
+		if rawURL == "" {
+			continue
+		}
+		host := strings.ToLower(strings.TrimSpace(screenshot.Host))
+		if host == "" {
+			host = imagehost.ExtractHost(rawURL)
+		}
+		if !isPTPImageHost(host) {
+			continue
+		}
+		allowed = append(allowed, "[img]"+rawURL+"[/img]")
+	}
+	if len(allowed) < minimum {
+		return ""
+	}
+	return strings.Join(allowed, "\n")
+}
+
+func isPTPImageHost(host string) bool {
+	switch strings.ToLower(strings.TrimSpace(host)) {
+	case "pixhost", "imgbb", "onlyimage", "ptscreens":
+		return true
+	default:
+		return false
+	}
+}
+
+func requiresMinimumTwoScreens(meta api.UploadSubject) bool {
+	if len(meta.FileList) > 1 {
+		return true
+	}
+	return strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV")
+}
+
+func convertDescription(value string) string {
+	replacer := strings.NewReplacer(
+		"[spoiler", "[hide",
+		"[/spoiler]", "[/hide]",
+		"[center]", "[align=center]",
+		"[/center]", "[/align]",
+		"[left]", "[align=left]",
+		"[/left]", "[/align]",
+		"[right]", "[align=right]",
+		"[/right]", "[/align]",
+		"[h1]", "[u][b]",
+		"[/h1]", "[/b][/u]",
+		"[h2]", "[u][b]",
+		"[/h2]", "[/b][/u]",
+		"[h3]", "[u][b]",
+		"[/h3]", "[/b][/u]",
+	)
+	return replacer.Replace(strings.TrimSpace(value))
+}
+
+func lookupGroupID(ctx context.Context, baseURL string, trackerConfig config.TrackerConfig, meta api.UploadSubject) (string, error) {
+	apiUser := strings.TrimSpace(trackerConfig.PTPAPIUser)
+	apiKey := strings.TrimSpace(trackerConfig.PTPAPIKey)
+	if apiUser == "" || apiKey == "" || meta.Identity.IMDBID == 0 {
+		return "", nil
+	}
+	headers := map[string]string{
+		"ApiUser":    apiUser,
+		"ApiKey":     apiKey,
+		"User-Agent": ptpUserAgent,
+	}
+	values := url.Values{}
+	values.Set("imdb", fmt.Sprintf("tt%07d", meta.Identity.IMDBID))
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+ptpTorrentPath+"?"+values.Encode(), nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP build group lookup request: %w", err)
+	}
+	for key, value := range headers {
+		httpReq.Header.Set(key, value)
+	}
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return "", nil
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", nil
+	}
+	var payload map[string]any
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return "", nil
+	}
+	if movies, ok := payload["Movies"].([]any); ok && len(movies) > 0 {
+		if movie, ok := movies[0].(map[string]any); ok {
+			if groupID := stringFromAny(movie["GroupId"]); groupID != "" {
+				return groupID, nil
+			}
+		}
+	}
+	return stringFromAny(payload["GroupId"]), nil
+}
+
+func rehostPosterToSelectedHost(ctx context.Context, req trackers.PreparationInput, imageURL string) string {
+	trimmedURL := strings.TrimSpace(imageURL)
+	if trimmedURL == "" {
+		return ""
+	}
+	if req.UploadImages == nil {
+		return trimmedURL
+	}
+	if req.Meta.ImageHostOverrides.SkipUpload != nil && *req.Meta.ImageHostOverrides.SkipUpload {
+		return trimmedURL
+	}
+
+	selectedHost := strings.ToLower(strings.TrimSpace(req.SelectedImageHost))
+	if selectedHost == "" {
+		return trimmedURL
+	}
+	if strings.EqualFold(strings.TrimSpace(imagehost.ExtractHost(trimmedURL)), selectedHost) {
+		return trimmedURL
+	}
+
+	posterPath, err := downloadPoster(ctx, req.Meta, req.Runtime.DBPath, trimmedURL)
+	if err != nil {
+		logPosterRehostFailure(req.Logger, selectedHost, err)
+		return trimmedURL
+	}
+	uploaded, err := req.UploadImages(ctx, []api.ScreenshotImage{{Path: posterPath}})
+	if err != nil {
+		logPosterRehostFailure(req.Logger, selectedHost, err)
+		return trimmedURL
+	}
+	if len(uploaded) == 0 {
+		logPosterRehostFailure(req.Logger, selectedHost, errors.New("upload returned no links"))
+		return trimmedURL
+	}
+	uploadedURL := metautil.FirstNonEmptyTrimmed(uploaded[0].RawURL, uploaded[0].ImgURL, uploaded[0].WebURL)
+	if strings.TrimSpace(uploadedURL) == "" {
+		logPosterRehostFailure(req.Logger, selectedHost, errors.New("upload returned blank link"))
+		return trimmedURL
+	}
+	if req.Logger != nil {
+		req.Logger.Infof("trackers: PTP poster rehosted to %s", selectedHost)
+	}
+	return strings.TrimSpace(uploadedURL)
+}
+
+func downloadPoster(ctx context.Context, meta api.UploadSubject, dbPath string, imageURL string) (string, error) {
+	if err := validatePosterURL(imageURL); err != nil {
+		return "", err
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, imageURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("poster request: %w", err)
+	}
+	httpReq.Header.Set("User-Agent", ptpUserAgent)
+
+	client := newPosterHTTPClient()
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("poster download: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", fmt.Errorf("poster download status=%d", resp.StatusCode)
+	}
+
+	const maxPosterBytes = 25 << 20
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxPosterBytes+1))
+	if err != nil {
+		return "", fmt.Errorf("poster read: %w", err)
+	}
+	if len(body) == 0 {
+		return "", errors.New("poster download returned empty body")
+	}
+	if len(body) > maxPosterBytes {
+		return "", errors.New("poster exceeds maximum size")
+	}
+
+	posterPath := filepath.Join(tmpDir, "PTP_POSTER"+posterExtension(imageURL, resp.Header.Get("Content-Type")))
+	if err := os.WriteFile(posterPath, body, 0o600); err != nil {
+		return "", fmt.Errorf("poster write: %w", err)
+	}
+	return posterPath, nil
+}
+
+func posterExtension(imageURL string, contentType string) string {
+	if parsed, err := url.Parse(imageURL); err == nil {
+		switch ext := strings.ToLower(path.Ext(parsed.Path)); ext {
+		case ".jpg", ".jpeg", ".png", ".webp":
+			return ext
+		}
+	}
+	mediaType := strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
+	switch mediaType {
+	case "image/png":
+		return ".png"
+	case "image/webp":
+		return ".webp"
+	case "image/jpeg":
+		return ".jpg"
+	default:
+		return ".jpg"
+	}
+}
+
+func validatePosterURL(rawURL string) error {
+	parsed, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil {
+		return fmt.Errorf("poster URL: %w", err)
+	}
+	if parsed.Scheme != "http" && parsed.Scheme != "https" {
+		return errors.New("poster URL must use http or https")
+	}
+	if strings.TrimSpace(parsed.Hostname()) == "" {
+		return errors.New("poster URL host is required")
+	}
+	return nil
+}
+
+func newPublicPosterHTTPClient() *http.Client {
+	dialer := &net.Dialer{Timeout: 30 * time.Second}
+	transport := &http.Transport{
+		DialContext: func(ctx context.Context, network string, addr string) (net.Conn, error) {
+			host, port, err := net.SplitHostPort(addr)
+			if err != nil {
+				return nil, fmt.Errorf("poster dial address: %w", err)
+			}
+			target, err := resolvePublicPosterAddress(ctx, host, port)
+			if err != nil {
+				return nil, err
+			}
+			return dialer.DialContext(ctx, network, target)
+		},
+	}
+	return &http.Client{Timeout: 30 * time.Second, Transport: transport}
+}
+
+func resolvePublicPosterAddress(ctx context.Context, host string, port string) (string, error) {
+	if ip := net.ParseIP(host); ip != nil {
+		addr, ok := netip.AddrFromSlice(ip)
+		if !ok || !isPublicPosterIP(addr.Unmap()) {
+			return "", fmt.Errorf("poster host %q resolves to non-public IP", host)
+		}
+		return net.JoinHostPort(addr.String(), port), nil
+	}
+	resolved, err := net.DefaultResolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return "", fmt.Errorf("poster DNS lookup %q: %w", host, err)
+	}
+	for _, candidate := range resolved {
+		addr, ok := netip.AddrFromSlice(candidate.IP)
+		if !ok {
+			continue
+		}
+		addr = addr.Unmap()
+		if isPublicPosterIP(addr) {
+			return net.JoinHostPort(addr.String(), port), nil
+		}
+	}
+	return "", fmt.Errorf("poster host %q has no public IP addresses", host)
+}
+
+func isPublicPosterIP(ip netip.Addr) bool {
+	if !ip.IsValid() || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() ||
+		ip.IsInterfaceLocalMulticast() ||
+		ip.IsMulticast() ||
+		ip.IsUnspecified() {
+		return false
+	}
+	return !ipInPrefixes(ip, reservedPosterPrefixes)
+}
+
+func ipInPrefixes(ip netip.Addr, prefixes []netip.Prefix) bool {
+	for _, prefix := range prefixes {
+		if prefix.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}
+
+func logPosterRehostFailure(logger api.Logger, host string, err error) {
+	if logger == nil || err == nil {
+		return
+	}
+	if strings.TrimSpace(host) == "" {
+		logger.Warnf("trackers: PTP poster rehost failed: %v", err)
+		return
+	}
+	logger.Warnf("trackers: PTP poster rehost to %s failed: %v", strings.TrimSpace(host), err)
+}
+
+func buildUploadFields(meta api.UploadSubject, description string, groupID string, answers map[string]string, poster string) (map[string]string, error) {
+	resolution, otherResolution := resolveResolution(meta)
+	fields := map[string]string{
+		"submit":          "true",
+		"remaster_year":   "",
+		"remaster_title":  resolveRemasterTitle(meta),
+		"type":            resolveType(meta),
+		"codec":           "Other",
+		"other_codec":     resolveCodec(meta),
+		"container":       "Other",
+		"other_container": resolveContainer(meta),
+		"resolution":      resolution,
+		"source":          "Other",
+		"other_source":    resolveSource(meta.Source),
+		"release_desc":    description,
+		"nfo_text":        "",
+		"subtitles[]":     joinInts(resolveSubtitles(meta)),
+		"trumpable[]":     "",
+	}
+	if resolution == "Other" && otherResolution != "" {
+		fields["other_resolution"] = otherResolution
+	}
+	if fields["remaster_title"] != "" {
+		fields["remaster"] = "on"
+	}
+	if meta.Scene {
+		fields["scene"] = "on"
+	}
+	if meta.PersonalRelease {
+		fields["internalrip"] = "on"
+	}
+	if meta.Identity.IMDBID == 0 {
+		fields["imdb"] = "0"
+	} else {
+		fields["imdb"] = fmt.Sprintf("%07d", meta.Identity.IMDBID)
+	}
+	if groupID != "" {
+		fields["groupid"] = groupID
+		return fields, nil
+	}
+
+	title, year := resolveGroupTitleYear(meta)
+	title = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["title"]), title)
+	year = metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["year"]), year)
+	if strings.TrimSpace(title) == "" {
+		return nil, errors.New("trackers: PTP missing title for new group upload")
+	}
+	fields["title"] = title
+	fields["year"] = year
+	fields["image"] = strings.TrimSpace(poster)
+	fields["tags"] = metautil.FirstNonEmptyTrimmed(answers["tags"], resolveTags(meta))
+	fields["album_desc"] = metautil.FirstNonEmptyTrimmed(answers["album_desc"], resolveOverview(meta))
+	fields["trailer"] = metautil.FirstNonEmptyTrimmed(answers["trailer"], resolveTrailer(meta))
+	directors := resolveDirectors(meta)
+	if len(directors) > 0 {
+		fields["artist[]"] = strings.Join(directors, "\n")
+		fields["importance[]"] = "1"
+	}
+	if fields["image"] == "" {
+		return nil, errors.New("trackers: PTP missing poster for new group upload")
+	}
+	return fields, nil
+}
+
+func resolveSession(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, baseURL string, logger api.Logger) (*http.Client, string, error) {
+	return resolveSessionLogin(ctx, trackerConfig, dbPath, baseURL, logger, api.TrackerAuthLoginRequest{})
+}
+
+func resolveSessionLogin(
+	ctx context.Context,
+	trackerConfig config.TrackerConfig,
+	dbPath string,
+	baseURL string,
+	logger api.Logger,
+	login api.TrackerAuthLoginRequest,
+) (*http.Client, string, error) {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+
+	cookies, err := loadCookies(ctx, dbPath)
+	if err == nil && len(cookies) > 0 {
+		client, token, tokenErr := fetchAntiCsrfToken(ctx, baseURL, cookies)
+		if tokenErr == nil {
+			return client, token, nil
+		}
+		if strings.TrimSpace(trackerConfig.Username) == "" || strings.TrimSpace(trackerConfig.Password) == "" ||
+			strings.TrimSpace(normalizedAnnounceURL(trackerConfig.AnnounceURL)) == "" {
+			return nil, "", tokenErr
+		}
+	}
+	return loginAndFetchAntiCsrfToken(ctx, trackerConfig, dbPath, baseURL, logger, login)
+}
+
+// ResolveSessionForTrackerAuth validates PTP stored cookies or logs in with
+// configured credentials. Credential login must produce an anti-CSRF token
+// before refreshed cookies are persisted.
+func ResolveSessionForTrackerAuth(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string) error {
+	return resolveSessionForTrackerAuthAt(ctx, trackerConfig, dbPath, ptpBaseURL)
+}
+
+func resolveSessionForTrackerAuthAt(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, baseURL string) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, trackerConfig, dbPath, api.TrackerAuthLoginRequest{}, baseURL)
+}
+
+// ResolveSessionForTrackerAuthLogin validates PTP stored cookies or logs in
+// with configured credentials. When PTP requires 2FA, login.Code is used before
+// falling back to the configured OTP URI; if neither yields a code, the error
+// is returned before stored cookies are replaced. A rejected submitted code
+// returns [ErrSubmitted2FARejected] with the login-failed error before refreshed
+// cookies are persisted.
+func ResolveSessionForTrackerAuthLogin(ctx context.Context, trackerConfig config.TrackerConfig, dbPath string, login api.TrackerAuthLoginRequest) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, trackerConfig, dbPath, login, ptpBaseURL)
+}
+
+func resolveSessionForTrackerAuthLoginAt(
+	ctx context.Context,
+	trackerConfig config.TrackerConfig,
+	dbPath string,
+	login api.TrackerAuthLoginRequest,
+	baseURL string,
+) error {
+	_, _, err := resolveSessionLogin(ctx, trackerConfig, dbPath, baseURL, api.NopLogger{}, login)
+	return err
+}
+
+func fetchAntiCsrfToken(ctx context.Context, baseURL string, cookies map[string]string) (*http.Client, string, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP create session cookie jar: %w", err)
+	}
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP parse base URL: %w", err)
+	}
+	jarCookies := make([]*http.Cookie, 0, len(cookies))
+	for name, value := range cookies {
+		if strings.TrimSpace(name) == "" || strings.TrimSpace(value) == "" {
+			continue
+		}
+		// #nosec G124 -- Outbound tracker jar cookie mirrors configured PTP session values.
+		jarCookies = append(jarCookies, &http.Cookie{
+			Name:   name,
+			Value:  value,
+			Path:   "/",
+			Domain: parsed.Hostname(),
+		})
+	}
+	jar.SetCookies(parsed, jarCookies)
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+	token, err := requestAntiCsrfToken(ctx, client, baseURL)
+	if err != nil {
+		return nil, "", err
+	}
+	return client, token, nil
+}
+
+func loginAndFetchAntiCsrfToken(
+	ctx context.Context,
+	trackerConfig config.TrackerConfig,
+	dbPath string,
+	baseURL string,
+	_ api.Logger,
+	login api.TrackerAuthLoginRequest,
+) (*http.Client, string, error) {
+	username := strings.TrimSpace(trackerConfig.Username)
+	password := strings.TrimSpace(trackerConfig.Password)
+	announceURL := normalizedAnnounceURL(trackerConfig.AnnounceURL)
+	if username == "" || password == "" || announceURL == "" {
+		return nil, "", errors.New("trackers: PTP requires username, password, and announce_url")
+	}
+	passkey, err := passkeyFromAnnounce(announceURL)
+	if err != nil {
+		return nil, "", err
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP create login cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+	form := url.Values{
+		"username":   {username},
+		"password":   {password},
+		"passkey":    {passkey},
+		"keeplogged": {"1"},
+	}
+	loginURL := strings.TrimRight(baseURL, "/") + ptpLoginPath
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP build login request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	httpReq.Header.Set("User-Agent", ptpUserAgent)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP login request: %w", err)
+	}
+	defer resp.Body.Close()
+	var payload map[string]any
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP login decode: %w", err)
+	}
+	switch strings.TrimSpace(stringFromAny(payload["Result"])) {
+	case "Ok":
+	case "TfaRequired":
+		code, codeErr := resolvePTP2FACode(trackerConfig, login)
+		if codeErr != nil {
+			return nil, "", fmt.Errorf("trackers: PTP 2FA required: %w", codeErr)
+		}
+		form.Set("TfaType", "normal")
+		form.Set("TfaCode", code)
+		httpReq, err = http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(form.Encode()))
+		if err != nil {
+			return nil, "", fmt.Errorf("trackers: PTP build 2FA request: %w", err)
+		}
+		httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		httpReq.Header.Set("User-Agent", ptpUserAgent)
+		resp, err = client.Do(httpReq)
+		if err != nil {
+			return nil, "", fmt.Errorf("trackers: PTP 2FA request: %w", err)
+		}
+		defer resp.Body.Close()
+		payload = map[string]any{}
+		if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+			return nil, "", fmt.Errorf("trackers: PTP 2FA decode: %w", err)
+		}
+		if strings.TrimSpace(stringFromAny(payload["Result"])) != "Ok" {
+			return nil, "", fmt.Errorf("trackers: PTP login failed: %w", ErrSubmitted2FARejected)
+		}
+	default:
+		return nil, "", errors.New("trackers: PTP login failed")
+	}
+
+	token := strings.TrimSpace(stringFromAny(payload["AntiCsrfToken"]))
+	if token == "" {
+		return nil, "", errors.New("trackers: PTP login missing anti csrf token")
+	}
+	if err := saveCookies(ctx, dbPath, client, baseURL); err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP persist login cookies: %w", err)
+	}
+	return client, token, nil
+}
+
+// resolvePTP2FACode prefers a submitted manual code so users can continue a
+// browser-visible challenge when no reusable OTP URI is configured.
+func resolvePTP2FACode(trackerConfig config.TrackerConfig, login api.TrackerAuthLoginRequest) (string, error) {
+	if code := strings.TrimSpace(login.Code); code != "" {
+		return code, nil
+	}
+	return resolve2FACode(trackerConfig.OTPURI)
+}
+
+func requestAntiCsrfToken(ctx context.Context, client *http.Client, baseURL string) (string, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+ptpUploadPath, nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP build upload page request: %w", err)
+	}
+	httpReq.Header.Set("User-Agent", ptpUserAgent)
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP upload page: %w", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP read upload page: %w", err)
+	}
+	matches := ptpAntiCsrfPattern.FindStringSubmatch(string(body))
+	if len(matches) < 2 {
+		return "", errors.New("trackers: PTP anti csrf token not found")
+	}
+	return strings.TrimSpace(matches[1]), nil
+}
+
+func buildMultipartPayload(fields map[string]string, torrentPath string, fileField string) ([]byte, string, error) {
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	keys := make([]string, 0, len(fields))
+	for key := range fields {
+		keys = append(keys, key)
+	}
+	slices.Sort(keys)
+	for _, key := range keys {
+		if key == "artist[]" {
+			for value := range strings.SplitSeq(fields[key], "\n") {
+				if strings.TrimSpace(value) == "" {
+					continue
+				}
+				if err := writer.WriteField(key, value); err != nil {
+					_ = writer.Close()
+					return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
+				}
+			}
+			continue
+		}
+		if key == "subtitles[]" || key == "trumpable[]" {
+			for value := range strings.SplitSeq(fields[key], ",") {
+				trimmed := strings.TrimSpace(value)
+				if trimmed == "" {
+					continue
+				}
+				if err := writer.WriteField(key, trimmed); err != nil {
+					_ = writer.Close()
+					return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
+				}
+			}
+			continue
+		}
+		if err := writer.WriteField(key, fields[key]); err != nil {
+			_ = writer.Close()
+			return nil, "", fmt.Errorf("trackers: PTP write multipart field %q: %w", key, err)
+		}
+	}
+
+	file, err := os.Open(torrentPath)
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: PTP open torrent file: %w", err)
+	}
+	defer file.Close()
+	part, err := writer.CreateFormFile(fileField, "placeholder.torrent")
+	if err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: PTP create torrent form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		_ = writer.Close()
+		return nil, "", fmt.Errorf("trackers: PTP copy torrent file: %w", err)
+	}
+	if err := writer.Close(); err != nil {
+		return nil, "", fmt.Errorf("trackers: PTP close multipart writer: %w", err)
+	}
+	return body.Bytes(), writer.FormDataContentType(), nil
+}
+
+func resolveTrackerTorrentPath(meta api.UploadSubject, dbPath string, tracker string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return "", errors.New("trackers: PTP tracker torrent path requires db path and source path")
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return filepath.Join(tmpDir, base+"."+strings.ToLower(strings.TrimSpace(tracker))+".torrent"), nil
+}
+
+func resolveFailurePath(meta api.UploadSubject, dbPath string) (string, error) {
+	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
+		return "", errors.New("trackers: PTP failure path requires db path and source path")
+	}
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return filepath.Join(tmpDir, "[PTP]upload_failure.html"), nil
+}
+
+func loadCookies(ctx context.Context, dbPath string) (map[string]string, error) {
+	values, err := cookiepkg.LoadTrackerCookieMap(ctx, dbPath, "PTP")
+	if err != nil {
+		return nil, fmt.Errorf("trackers: %w", err)
+	}
+	return values, nil
+}
+
+func saveCookies(ctx context.Context, dbPath string, client *http.Client, baseURL string) error {
+	if client == nil || client.Jar == nil {
+		return errors.New("trackers: PTP login returned no cookie jar")
+	}
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return fmt.Errorf("trackers: PTP parse cookie URL: %w", err)
+	}
+	cookies := make(map[string]string)
+	for _, cookie := range client.Jar.Cookies(parsed) {
+		if cookie == nil || strings.TrimSpace(cookie.Name) == "" {
+			continue
+		}
+		if strings.TrimSpace(cookie.Value) == "" {
+			continue
+		}
+		cookies[strings.TrimSpace(cookie.Name)] = cookie.Value
+	}
+	if len(cookies) == 0 {
+		return errors.New("trackers: PTP login returned no usable cookies")
+	}
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", cookies); err != nil {
+		return fmt.Errorf("trackers: PTP save cookies: %w", err)
+	}
+	return nil
+}
+
+func passkeyFromAnnounce(announceURL string) (string, error) {
+	parsed, err := url.Parse(announceURL)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP parse announce URL: %w", err)
+	}
+	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
+	if len(parts) < 2 {
+		return "", errors.New("trackers: PTP failed to extract passkey from announce_url")
+	}
+	return parts[0], nil
+}
+
+func resolve2FACode(otpURI string) (string, error) {
+	trimmed := strings.TrimSpace(otpURI)
+	if trimmed == "" {
+		return "", errors.New("otp_uri not configured")
+	}
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP parse otp_uri: %w", err)
+	}
+	secret := strings.TrimSpace(parsed.Query().Get("secret"))
+	if secret == "" {
+		return "", errors.New("otp_uri missing secret")
+	}
+	period := 30
+	if value := strings.TrimSpace(parsed.Query().Get("period")); value != "" {
+		if parsedValue, parseErr := strconv.Atoi(value); parseErr == nil && parsedValue > 0 {
+			period = parsedValue
+		}
+	}
+	decoder := base32.StdEncoding.WithPadding(base32.NoPadding)
+	secretBytes, err := decoder.DecodeString(strings.ToUpper(secret))
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP decode otp secret: %w", err)
+	}
+	counterTime := time.Now().Unix() / int64(period)
+	if counterTime < 0 {
+		return "", errors.New("totp counter before unix epoch")
+	}
+	counter := uint64(counterTime)
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, counter)
+	mac := hmac.New(sha1.New, secretBytes)
+	_, _ = mac.Write(buf)
+	hash := mac.Sum(nil)
+	offset := hash[len(hash)-1] & 0x0f
+	code := (int(hash[offset])&0x7f)<<24 | int(hash[offset+1])<<16 | int(hash[offset+2])<<8 | int(hash[offset+3])
+	return fmt.Sprintf("%06d", code%1000000), nil
+}
+
+func resolveUploadName(meta api.UploadSubject) string {
+	if name := strings.TrimSpace(meta.ReleaseName); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.ReleaseNameNoTag); name != "" {
+		return name
+	}
+	if name := strings.TrimSpace(meta.Filename); name != "" {
+		return name
+	}
+	return pathutil.Base(meta.SourcePath)
+}
+
+func resolveType(meta api.UploadSubject) string {
+	category := strings.ToLower(strings.TrimSpace(string(meta.Identity.Category)))
+	if category == "" {
+		category = strings.ToLower(strings.TrimSpace(string(meta.Identity.Category)))
+	}
+	if meta.ProviderMetadata.IMDB != nil && strings.Contains(strings.ToLower(meta.ProviderMetadata.IMDB.Type), "concert") {
+		return "Music"
+	}
+	if meta.ProviderMetadata.TMDB != nil &&
+		(strings.Contains(strings.ToLower(meta.ProviderMetadata.TMDB.Genres), "documentary") || strings.Contains(strings.ToLower(meta.ProviderMetadata.TMDB.Keywords), "documentary")) {
+		return "Documentary"
+	}
+	if category == "movie" {
+		return "Feature Film"
+	}
+	if category == "tv" {
+		if meta.TVPack {
+			return "Miniseries"
+		}
+		return "Short Film"
+	}
+	return "Feature Film"
+}
+
+func resolveCodec(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return "BD50"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return "DVD9"
+	}
+	codec := strings.TrimSpace(meta.VideoCodec)
+	if codec == "" {
+		codec = strings.TrimSpace(meta.VideoEncode)
+	}
+	replacer := strings.NewReplacer("AVC", "H.264", "HEVC", "H.265")
+	codec = replacer.Replace(codec)
+	if meta.HasEncodeSettings {
+		codec = strings.ReplaceAll(codec, "H.", "x")
+	}
+	if codec == "" {
+		return "Other"
+	}
+	return codec
+}
+
+func resolveResolution(meta api.UploadSubject) (string, string) {
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	if resolution == "" {
+		resolution = "Other"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		source := strings.TrimSpace(meta.Source)
+		source = strings.ReplaceAll(source, " DVD", "")
+		if source != "" {
+			return source, ""
+		}
+	}
+	if strings.EqualFold(resolution, "OTHER") {
+		return "Other", "Other"
+	}
+	return resolution, ""
+}
+
+func resolveContainer(meta api.UploadSubject) string {
+	switch strings.ToUpper(strings.TrimSpace(meta.DiscType)) {
+	case "BDMV":
+		return "m2ts"
+	case "DVD":
+		return "VOB IFO"
+	default:
+		switch strings.ToLower(filepath.Ext(firstFile(meta))) {
+		case ".mkv":
+			return "MKV"
+		case ".mp4":
+			return "MP4"
+		default:
+			return "Other"
+		}
+	}
+}
+
+func resolveSource(source string) string {
+	switch strings.TrimSpace(source) {
+	case "Blu-ray", "BluRay":
+		return "Blu-ray"
+	case "HD DVD", "HDDVD":
+		return "HD-DVD"
+	case "Web":
+		return "WEB"
+	case "HDTV", "UHDTV":
+		return "HDTV"
+	case "NTSC", "PAL":
+		return "DVD"
+	default:
+		return "OtherR"
+	}
+}
+
+func resolveSubtitles(meta api.UploadSubject) []int {
+	if len(meta.SubtitleLanguages) == 0 {
+		return []int{44}
+	}
+	ids := make([]int, 0, len(meta.SubtitleLanguages))
+	seen := make(map[int]struct{})
+	for _, language := range meta.SubtitleLanguages {
+		if value, ok := subtitleIDs[strings.ToLower(strings.TrimSpace(language))]; ok {
+			if _, exists := seen[value]; exists {
+				continue
+			}
+			seen[value] = struct{}{}
+			ids = append(ids, value)
+		}
+	}
+	if len(ids) == 0 {
+		return []int{44}
+	}
+	return ids
+}
+
+func resolveRemasterTitle(meta api.UploadSubject) string {
+	parts := make([]string, 0, 8)
+	distributor := strings.ToUpper(strings.TrimSpace(meta.Distributor))
+	switch distributor {
+	case "WARNER ARCHIVE", "WARNER ARCHIVE COLLECTION", "WAC":
+		parts = append(parts, "Warner Archive Collection")
+	case "CRITERION", "CRITERION COLLECTION", "CC":
+		parts = append(parts, "The Criterion Collection")
+	case "MASTERS OF CINEMA", "MOC":
+		parts = append(parts, "Masters of Cinema")
+	}
+	edition := strings.TrimSpace(meta.Edition)
+	switch {
+	case strings.Contains(strings.ToLower(edition), "director's cut"):
+		parts = append(parts, "Director's Cut")
+	case strings.Contains(strings.ToLower(edition), "extended"):
+		parts = append(parts, "Extended Edition")
+	case strings.Contains(strings.ToLower(edition), "theatrical"):
+		parts = append(parts, "Theatrical Cut")
+	case strings.Contains(strings.ToLower(edition), "uncut"):
+		parts = append(parts, "Uncut")
+	case strings.Contains(strings.ToLower(edition), "unrated"):
+		parts = append(parts, "Unrated")
+	case edition != "":
+		parts = append(parts, edition)
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+		parts = append(parts, "Remux")
+	}
+	audio := strings.TrimSpace(meta.Audio)
+	if strings.Contains(audio, "DTS:X") {
+		parts = append(parts, "DTS:X")
+	}
+	if strings.Contains(audio, "Atmos") {
+		parts = append(parts, "Dolby Atmos")
+	}
+	if strings.Contains(audio, "Dual") {
+		parts = append(parts, "Dual Audio")
+	}
+	if strings.Contains(audio, "Dubbed") {
+		parts = append(parts, "English Dub")
+	}
+	if meta.HDR == "" && meta.BitDepth == "10" {
+		parts = append(parts, "10-bit")
+	}
+	if strings.Contains(meta.HDR, "DV") {
+		parts = append(parts, "Dolby Vision")
+	}
+	if strings.Contains(meta.HDR, "HDR10+") {
+		parts = append(parts, "HDR10+")
+	} else if strings.Contains(meta.HDR, "HDR") {
+		parts = append(parts, "HDR10")
+	}
+	if strings.Contains(meta.HDR, "HLG") {
+		parts = append(parts, "HLG")
+	}
+	if meta.HasCommentary {
+		parts = append(parts, "With Commentary")
+	}
+	return strings.Join(parts, " / ")
+}
+
+func resolveGroupTitleYear(meta api.UploadSubject) (string, string) {
+	title := ""
+	year := 0
+	if meta.ProviderMetadata.TMDB != nil {
+		title = strings.TrimSpace(meta.ProviderMetadata.TMDB.Title)
+		year = meta.ProviderMetadata.TMDB.Year
+	}
+	if title == "" && meta.ProviderMetadata.IMDB != nil {
+		title = strings.TrimSpace(meta.ProviderMetadata.IMDB.Title)
+		year = meta.ProviderMetadata.IMDB.Year
+	}
+	if title == "" {
+		title = strings.TrimSpace(meta.Release.Title)
+	}
+	if year == 0 {
+		year = meta.Release.Year
+	}
+	if year == 0 {
+		return title, ""
+	}
+	return title, strconv.Itoa(year)
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		if value := strings.TrimSpace(meta.ProviderMetadata.TMDB.Poster); value != "" {
+			return value
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Cover)
+	}
+	return ""
+}
+
+func resolveOverview(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		if value := strings.TrimSpace(meta.ProviderMetadata.TMDB.Overview); value != "" {
+			return value
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		if value := strings.TrimSpace(meta.ProviderMetadata.IMDB.Plot); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func resolveTrailer(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.YouTube)
+	}
+	return ""
+}
+
+func resolveDirectors(meta api.UploadSubject) []string {
+	if meta.ProviderMetadata.TMDB != nil && len(meta.ProviderMetadata.TMDB.Directors) > 0 {
+		return append([]string{}, meta.ProviderMetadata.TMDB.Directors...)
+	}
+	if meta.ProviderMetadata.IMDB != nil && len(meta.ProviderMetadata.IMDB.Directors) > 0 {
+		names := make([]string, 0, len(meta.ProviderMetadata.IMDB.Directors))
+		for _, person := range meta.ProviderMetadata.IMDB.Directors {
+			if strings.TrimSpace(person.Name) != "" {
+				names = append(names, strings.TrimSpace(person.Name))
+			}
+		}
+		return names
+	}
+	return nil
+}
+
+func resolveTags(meta api.UploadSubject) string {
+	values := make([]string, 0, 8)
+	if meta.ProviderMetadata.TMDB != nil {
+		for item := range strings.SplitSeq(meta.ProviderMetadata.TMDB.Genres, ",") {
+			trimmed := strings.ToLower(strings.TrimSpace(item))
+			if trimmed != "" {
+				values = append(values, trimmed)
+			}
+		}
+	}
+	if len(values) == 0 && strings.TrimSpace(meta.Release.Genre) != "" {
+		for item := range strings.SplitSeq(meta.Release.Genre, ",") {
+			trimmed := strings.ToLower(strings.TrimSpace(item))
+			if trimmed != "" {
+				values = append(values, trimmed)
+			}
+		}
+	}
+	if len(values) == 0 {
+		values = append(values, "action")
+	}
+	seen := make(map[string]struct{}, len(values))
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		filtered = append(filtered, value)
+	}
+	return strings.Join(filtered, ", ")
+}
+
+func firstFile(meta api.UploadSubject) string {
+	if len(meta.FileList) > 0 {
+		return meta.FileList[0]
+	}
+	return meta.SourcePath
+}
+
+func normalizedAnnounceURL(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if strings.HasPrefix(trimmed, "http://please.passthepopcorn.me") {
+		return strings.Replace(trimmed, "http://", "https://", 1)
+	}
+	return trimmed
+}
+
+func extractAlertError(body string) string {
+	start := strings.Index(body, `alert alert--error`)
+	if start == -1 {
+		return ""
+	}
+	segment := body[start:]
+	end := strings.Index(segment, "</div>")
+	if end != -1 {
+		segment = segment[:end]
+	}
+	return stripTags(segment)
+}
+
+func stripTags(value string) string {
+	inTag := false
+	var builder strings.Builder
+	for _, r := range value {
+		switch r {
+		case '<':
+			inTag = true
+		case '>':
+			inTag = false
+		default:
+			if !inTag {
+				builder.WriteRune(r)
+			}
+		}
+	}
+	return strings.Join(strings.Fields(builder.String()), " ")
+}
+
+func compactError(value string) string {
+	trimmed := strings.Join(strings.Fields(strings.TrimSpace(value)), " ")
+	if len(trimmed) > 220 {
+		return trimmed[:220]
+	}
+	return trimmed
+}
+
+func stringFromAny(value any) string {
+	switch typed := value.(type) {
+	case nil:
+		return ""
+	case string:
+		return strings.TrimSpace(typed)
+	case float64:
+		return strconv.Itoa(int(typed))
+	case int:
+		return strconv.Itoa(typed)
+	case int64:
+		return strconv.FormatInt(typed, 10)
+	default:
+		return strings.TrimSpace(fmt.Sprint(value))
+	}
+}
+
+func joinInts(values []int) string {
+	if len(values) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(values))
+	for _, value := range values {
+		parts = append(parts, strconv.Itoa(value))
+	}
+	return strings.Join(parts, ",")
+}
+
+func readBDSummary(meta api.UploadSubject, dbPath string) (string, error) {
+	tmpRoot, err := db.Subdir(dbPath, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return readTextFile(paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists)))
+}
+
+func readTextFile(path string) (string, error) {
+	trimmed := strings.TrimSpace(path)
+	if trimmed == "" {
+		return "", nil
+	}
+	payload, err := os.ReadFile(trimmed)
+	if err != nil {
+		return "", fmt.Errorf("trackers: PTP read text file: %w", err)
+	}
+	return string(payload), nil
+}
+
+func buildQuestionnaire(meta api.UploadSubject, groupID string) *api.TrackerQuestionnaire {
+	if strings.TrimSpace(groupID) != "" {
+		return nil
+	}
+	title, year := resolveGroupTitleYear(meta)
+	fields := []api.TrackerQuestionnaireField{
+		{
+			Key:      "title",
+			Label:    "Group Title",
+			Kind:     "text",
+			Value:    title,
+			Required: true,
+		},
+		{
+			Key:         "year",
+			Label:       "Year",
+			Kind:        "text",
+			Value:       year,
+			Required:    false,
+			Placeholder: "Release year",
+		},
+		{
+			Key:      "poster",
+			Label:    "Poster URL",
+			Kind:     "text",
+			Value:    resolvePoster(meta),
+			Required: true,
+		},
+		{
+			Key:         "tags",
+			Label:       "Tags",
+			Kind:        "text",
+			Value:       resolveTags(meta),
+			Required:    true,
+			Placeholder: "Comma separated tags",
+		},
+		{
+			Key:         "trailer",
+			Label:       "Trailer URL",
+			Kind:        "text",
+			Value:       resolveTrailer(meta),
+			Required:    false,
+			Placeholder: "YouTube trailer URL",
+		},
+		{
+			Key:      "album_desc",
+			Label:    "Group Description",
+			Kind:     "textarea",
+			Value:    resolveOverview(meta),
+			Required: false,
+		},
+	}
+	return &api.TrackerQuestionnaire{
+		Tracker: "PTP",
+		Fields:  fields,
+	}
+}
+
+var subtitleIDs = map[string]int{
+	"arabic":               22,
+	"brazilian portuguese": 49,
+	"bulgarian":            29,
+	"chinese":              14,
+	"croatian":             23,
+	"czech":                30,
+	"danish":               10,
+	"dutch":                9,
+	"english":              3,
+	"english - forced":     50,
+	"english forced":       50,
+	"english intertitles":  51,
+	"estonian":             38,
+	"finnish":              15,
+	"french":               5,
+	"german":               6,
+	"greek":                26,
+	"hebrew":               40,
+	"hindi":                41,
+	"hungarian":            24,
+	"icelandic":            28,
+	"indonesian":           47,
+	"italian":              16,
+	"japanese":             8,
+	"korean":               19,
+	"latvian":              37,
+	"lithuanian":           39,
+	"norwegian":            12,
+	"polish":               17,
+	"portuguese":           21,
+	"romanian":             13,
+	"russian":              7,
+	"serbian":              31,
+	"slovak":               42,
+	"slovenian":            43,
+	"spanish":              4,
+	"swedish":              11,
+	"thai":                 20,
+	"turkish":              18,
+	"ukrainian":            34,
+	"vietnamese":           25,
+}
diff --git a/internal/trackers/impl/standalone/ptp/upload_test.go b/internal/trackers/impl/standalone/ptp/upload_test.go
new file mode 100644
index 00000000..dd98d661
--- /dev/null
+++ b/internal/trackers/impl/standalone/ptp/upload_test.go
@@ -0,0 +1,406 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptp
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	cookiepkg "github.com/autobrr/upbrr/internal/cookies"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestLoadCookiesSuccessReturnsNilError(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+
+	got, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if got["session"] != "abc" {
+		t.Fatalf("unexpected cookies: %#v", got)
+	}
+}
+
+func TestResolveSessionForTrackerAuthPreservesCookiesOnTransientTokenFetch(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "abc"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
+	baseURL := server.URL
+	server.Close()
+
+	err := resolveSessionForTrackerAuthAt(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, baseURL)
+	if err == nil {
+		t.Fatal("expected transient token fetch error")
+	}
+	got, loadErr := loadCookies(ctx, dbPath)
+	if loadErr != nil {
+		t.Fatalf("loadCookies after transient error: %v", loadErr)
+	}
+	if got["session"] != "abc" {
+		t.Fatalf("expected transient failure to preserve cookies, got %#v", got)
+	}
+}
+
+func TestLoginAndFetchAntiCsrfTokenReturnsPersistenceError(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		http.SetCookie(w, &http.Cookie{
+			Name:  "session",
+			Value: "new",
+			Path:  "/",
+		})
+		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	_, _, err := resolveSession(context.Background(), config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, filepath.Join(t.TempDir(), "upbrr.db"), server.URL, api.NopLogger{})
+	if err == nil {
+		t.Fatal("expected persistence error")
+	}
+	if !strings.Contains(err.Error(), "persist login cookies") {
+		t.Fatalf("expected persistence error, got %v", err)
+	}
+}
+
+func TestLoginAndFetchAntiCsrfTokenDoesNotOverwriteCookiesWhenTokenMissing(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == ptpUploadPath {
+			_, _ = w.Write([]byte("<html>logged out</html>"))
+			return
+		}
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		http.SetCookie(w, &http.Cookie{
+			Name:  "session",
+			Value: "new",
+			Path:  "/",
+		})
+		_, _ = w.Write([]byte(`{"Result":"Ok"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	_, _, err := resolveSession(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, server.URL, api.NopLogger{})
+	if err == nil {
+		t.Fatal("expected missing token error")
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatalf("missing token must not overwrite stored cookies, got %#v", values)
+	}
+}
+
+func TestLoginAndFetchAntiCsrfTokenPersistsCookiesAfterTokenGate(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		http.SetCookie(w, &http.Cookie{
+			Name:  "session",
+			Value: "new",
+			Path:  "/",
+		})
+		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	_, token, err := resolveSession(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, server.URL, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("resolveSession: %v", err)
+	}
+	if token != "token" {
+		t.Fatalf("unexpected token %q", token)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "new" {
+		t.Fatalf("expected saved login cookies, got %#v", values)
+	}
+}
+
+func TestLoginAndFetchAntiCsrfTokenRejectsEmptyJarWithoutReplacingCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == ptpUploadPath:
+			_, _ = w.Write([]byte("<html>logged out</html>"))
+		case r.URL.Path == "/ajax.php" && r.URL.RawQuery == "action=login":
+			_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	_, _, err := resolveSession(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, server.URL, api.NopLogger{})
+	if err == nil || !strings.Contains(err.Error(), "no usable cookies") {
+		t.Fatalf("expected empty cookie jar error, got %v", err)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatalf("empty login jar must preserve stored cookies, got %#v", values)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginUsesManual2FACode(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	var gotCode string
+	loginRequests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		if err := r.ParseForm(); err != nil {
+			t.Errorf("ParseForm: %v", err)
+			return
+		}
+		loginRequests++
+		if loginRequests == 1 {
+			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
+			return
+		}
+		gotCode = r.FormValue("TfaCode")
+		http.SetCookie(w, &http.Cookie{
+			Name:  "session",
+			Value: "new",
+			Path:  "/",
+		})
+		_, _ = w.Write([]byte(`{"Result":"Ok","AntiCsrfToken":"token"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "654321"}, server.URL)
+	if err != nil {
+		t.Fatalf("ResolveSessionForTrackerAuthLogin: %v", err)
+	}
+	if gotCode != "654321" {
+		t.Fatalf("expected manual 2FA code, got %q", gotCode)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "new" {
+		t.Fatalf("expected saved 2FA login cookies, got %#v", values)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginMarksSubmitted2FARejected(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	loginRequests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		loginRequests++
+		if loginRequests == 1 {
+			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
+			return
+		}
+		_, _ = w.Write([]byte(`{"Result":"Invalid"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"}, server.URL)
+	if !errors.Is(err, ErrSubmitted2FARejected) {
+		t.Fatalf("expected submitted 2FA rejection marker, got %v", err)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatalf("submitted 2FA rejection must preserve stored cookies, got %#v", values)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginPreCodeFailureIsNotSubmitted2FARejected(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/ajax.php" || r.URL.RawQuery != "action=login" {
+			http.NotFound(w, r)
+			return
+		}
+		_, _ = w.Write([]byte(`{"Result":"Invalid"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, api.TrackerAuthLoginRequest{Code: "000000"}, server.URL)
+	if err == nil || !strings.Contains(err.Error(), "login failed") {
+		t.Fatalf("expected pre-code login failed error, got %v", err)
+	}
+	if errors.Is(err, ErrSubmitted2FARejected) {
+		t.Fatalf("pre-code login failure must not carry submitted 2FA marker: %v", err)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatalf("pre-code login failure must preserve stored cookies, got %#v", values)
+	}
+}
+
+func TestResolveSessionForTrackerAuthLoginMissing2FACodePreservesCookies(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	dbPath := newPTPAuthDB(t)
+	if err := cookiepkg.SaveTrackerCookieMap(ctx, dbPath, "PTP", map[string]string{"session": "existing"}); err != nil {
+		t.Fatalf("SaveTrackerCookieMap: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == ptpUploadPath:
+			_, _ = w.Write([]byte("<html>logged out</html>"))
+		case r.URL.Path == "/ajax.php" && r.URL.RawQuery == "action=login":
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "new",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`{"Result":"TfaRequired"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	err := resolveSessionForTrackerAuthLoginAt(ctx, config.TrackerConfig{
+		Username:    "user",
+		Password:    "pass",
+		AnnounceURL: "https://please.passthepopcorn.me/passkey/announce",
+	}, dbPath, api.TrackerAuthLoginRequest{}, server.URL)
+	if err == nil || !strings.Contains(err.Error(), "2FA required") {
+		t.Fatalf("expected missing 2FA error, got %v", err)
+	}
+	values, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		t.Fatalf("loadCookies: %v", err)
+	}
+	if values["session"] != "existing" {
+		t.Fatalf("missing 2FA code must preserve stored cookies, got %#v", values)
+	}
+}
+
+func newPTPAuthDB(t *testing.T) string {
+	t.Helper()
+
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "upbrr.db")
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	repo, err := servicedb.OpenWithLoggerContext(ctx, dbPath, api.NopLogger{})
+	if err != nil {
+		t.Fatalf("OpenWithLoggerContext: %v", err)
+	}
+	if err := repo.MigrateContext(ctx); err != nil {
+		_ = repo.Close()
+		t.Fatalf("MigrateContext: %v", err)
+	}
+	_ = repo.Close()
+	return dbPath
+}
diff --git a/internal/trackers/impl/standalone/pts/bbcode.go b/internal/trackers/impl/standalone/pts/bbcode.go
new file mode 100644
index 00000000..cef77917
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/bbcode.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+var sceneNFOPattern = regexp.MustCompile(`(?is)\[center\]\[spoiler=.*? nfo:\]\[code\].*?\[/code\]\[/spoiler\]\[/center\]`)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = strings.NewReplacer(
+		"[user]",
+		"",
+		"[/user]",
+		"",
+		"[align=left]",
+		"",
+		"[/align]",
+		"",
+		"[right]",
+		"",
+		"[/right]",
+		"",
+		"[align=right]",
+		"",
+		"[/align=right]",
+		"",
+		"[sup]",
+		"",
+		"[/sup]",
+		"",
+		"[sub]",
+		"",
+		"[/sub]",
+		"",
+		"[alert]",
+		"",
+		"[/alert]",
+		"",
+		"[note]",
+		"",
+		"[/note]",
+		"",
+		"[hr]",
+		"",
+		"[/hr]",
+		"",
+		"[h1]",
+		"[u][b]",
+		"[/h1]",
+		"[/b][/u]",
+		"[h2]",
+		"[u][b]",
+		"[/h2]",
+		"[/b][/u]",
+		"[h3]",
+		"[u][b]",
+		"[/h3]",
+		"[/b][/u]",
+		"[ul]",
+		"",
+		"[/ul]",
+		"",
+		"[ol]",
+		"",
+		"[/ol]",
+		"",
+		"[hide]",
+		"",
+		"[/hide]",
+		"",
+	).Replace(value)
+	value = sceneNFOPattern.ReplaceAllString(value, "")
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveSpoiler(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/pts/bbcode_test.go b/internal/trackers/impl/standalone/pts/bbcode_test.go
new file mode 100644
index 00000000..e214ea1c
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/bbcode_test.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFinalizeDescription(t *testing.T) {
+	input := "[hide]x[/hide]\n[comparison=A, B]https://img.example/a.png https://img.example/b.png[/comparison]"
+	got := finalizeDescription(input)
+	if strings.Contains(got, "[hide]") {
+		t.Fatalf("expected hide tags removed for PTS, got %q", got)
+	}
+	if !strings.Contains(got, "[center]A | B") {
+		t.Fatalf("expected comparison centered for PTS, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/pts/definition.go b/internal/trackers/impl/standalone/pts/definition.go
new file mode 100644
index 00000000..0367eb75
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/definition.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, assets)
+	return trackers.DescriptionResult{Group: "pts", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/pts/dupe.go b/internal/trackers/impl/standalone/pts/dupe.go
new file mode 100644
index 00000000..7e76a664
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/dupe.go
@@ -0,0 +1,110 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for PTS dupe search", nil)
+	}
+	baseURL := ptsBaseURL(s.cfg)
+	parsed, err := url.Parse(baseURL)
+	if err != nil {
+		return dupe.Failed(dupe.FailureInternal, "PTS search failed", err)
+	}
+	trackerCookies, err := cookies.LoadTrackerHTTPCookies(ctx, s.cfg.MainSettings.DBPath, "PTS", parsed.Hostname())
+	if err != nil {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing valid PTS cookies", nil)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/torrents.php", nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "PTS search failed", err)
+	}
+	req.URL.RawQuery = url.Values{
+		"incldead":    {"1"},
+		"search":      {fmt.Sprintf("tt%07d", meta.Identity.IMDBID)},
+		"search_area": {"4"},
+	}.Encode()
+	req.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(req, trackerCookies)
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "PTS search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "PTS search failed", nil)
+	}
+	root, err := xhtml.Parse(resp.Body)
+	if err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "PTS search failed", err)
+	}
+	entries := make([]api.DupeEntry, 0)
+	ptsWalk(root, func(node *xhtml.Node) {
+		if node.Type != xhtml.ElementNode || node.Data != "b" {
+			return
+		}
+		if name := strings.TrimSpace(ptsNodeText(node)); name != "" {
+			entries = append(entries, api.DupeEntry{Name: name})
+		}
+	})
+	return dupe.Resolved(entries, nil)
+}
+
+func ptsBaseURL(_ config.Config) string {
+	return "https://www.ptskit.org"
+}
+
+func ptsWalk(node *xhtml.Node, visit func(*xhtml.Node)) {
+	if node == nil {
+		return
+	}
+	visit(node)
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		ptsWalk(child, visit)
+	}
+}
+
+func ptsNodeText(node *xhtml.Node) string {
+	if node == nil {
+		return ""
+	}
+	if node.Type == xhtml.TextNode {
+		return node.Data
+	}
+	var builder strings.Builder
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		builder.WriteString(ptsNodeText(child))
+	}
+	return builder.String()
+}
diff --git a/internal/trackers/impl/standalone/pts/profile.go b/internal/trackers/impl/standalone/pts/profile.go
new file mode 100644
index 00000000..398fde1e
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/profile.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+)
+
+// Profile returns PTS identity, preparation, dupe, auth, and artifact behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                  "PTS",
+		BaseURL:               baseURL,
+		DescriptionGroup:      "pts",
+		UploadContentMode:     trackers.UploadContentModeDescription,
+		PrepareDescription:    prepareDescription,
+		PrepareUpload:         prepareUpload,
+		NewDuplicateAdapter:   newDuplicateAdapter,
+		AuthCapability:        standalone.CookieAuthCapability("PTS"),
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"https://tracker.ptskit.com"}},
+	}
+}
+
+// New returns a fresh PTS definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/pts/upload.go b/internal/trackers/impl/standalone/pts/upload.go
new file mode 100644
index 00000000..25617ab6
--- /dev/null
+++ b/internal/trackers/impl/standalone/pts/upload.go
@@ -0,0 +1,305 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pts
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://www.ptskit.org"
+	uploadURL  = baseURL + "/takeupload.php"
+	sourceFlag = "[www.ptskit.org] PTSKIT"
+)
+
+var idPattern = regexp.MustCompile(`download\.php\?id=([^&]+)`)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	questionnaire *api.TrackerQuestionnaire
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, cookies, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: PTS %s", state.blockedReason)
+	}
+
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
+		FieldName: "file",
+		FileName:  "PTS.torrent",
+		Path:      state.torrentPath,
+	}})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "PTS")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, cookies, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	cookies []*http.Cookie,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTS request build: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+	commonhttp.ApplyCookies(httpReq, cookies)
+
+	resp, err := (&http.Client{
+		CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse },
+	}).Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTS upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode == http.StatusFound || resp.StatusCode == http.StatusSeeOther,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: PTS read upload response: %w", err)
+	}
+
+	location := strings.TrimSpace(resp.Header.Get("Location"))
+	torrentID := parseUploadID(location, string(responseBody))
+	if (resp.StatusCode == http.StatusFound || resp.StatusCode == http.StatusSeeOther) && torrentID != "" {
+		tURL := baseURL + "/details.php?id=" + url.QueryEscape(torrentID)
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "PTS",
+				TorrentID:   torrentID,
+				TorrentURL:  tURL,
+				DownloadURL: baseURL + "/download.php?id=" + url.QueryEscape(torrentID),
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "PTS", "upload_failure", responsePreview, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("PTS", resp.StatusCode, responsePreview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "PTS",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "pts",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, []*http.Cookie, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, assets)
+
+	state := uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename),
+		fields:        buildPayload(req.Meta, description),
+		questionnaire: buildQuestionnaire(req.Meta),
+		blockedReason: validateUpload(req.Meta),
+	}
+	cookies, err := loadCookies(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: PTS load cookies: %w", err)
+	}
+	return state, cookies, nil
+}
+
+func buildPayload(meta api.UploadSubject, description string) map[string]string {
+	return map[string]string{
+		"name":  metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename),
+		"url":   imdbURL(meta),
+		"descr": description,
+		"type":  resolveType(meta),
+	}
+}
+
+func buildDescription(meta api.UploadSubject, assets trackers.DescriptionAssets) string {
+	parts := make([]string, 0, 4)
+	if info := commonhttp.ReadOptionalFile(strings.TrimSpace(meta.MediaInfoTextPath)); strings.TrimSpace(info) != "" {
+		parts = append(parts, info)
+	}
+	if base := strings.TrimSpace(assets.Description); base != "" {
+		parts = append(parts, sanitizeDescription(base))
+	}
+	if shots := screenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+	parts = append(parts, "[right][url=https://github.com/autobrr/upbrr][size=1]upbrr[/size][/url][/right]")
+	return finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+}
+
+func buildQuestionnaire(meta api.UploadSubject) *api.TrackerQuestionnaire {
+	if hasMandarin(meta) {
+		return nil
+	}
+	answer := strings.ToLower(strings.TrimSpace(standalone.QuestionnaireAnswers(meta, "PTS")["mandarin_override"]))
+	return &api.TrackerQuestionnaire{
+		Tracker: "PTS",
+		Fields: []api.TrackerQuestionnaireField{{
+			Key:      "mandarin_override",
+			Label:    "Mandarin Requirement",
+			Kind:     "select",
+			Options:  []string{"no", "yes"},
+			Value:    metautil.FirstNonEmptyTrimmed(answer, "no"),
+			Help:     "PTS expects Mandarin audio or subtitles. Choose yes to override and upload anyway.",
+			Required: true,
+		}},
+	}
+}
+
+func validateUpload(meta api.UploadSubject) string {
+	if hasMandarin(meta) {
+		return ""
+	}
+	if strings.EqualFold(strings.TrimSpace(standalone.QuestionnaireAnswers(meta, "PTS")["mandarin_override"]), "yes") {
+		return ""
+	}
+	return "missing Mandarin audio/subtitles; answer the override questionnaire to continue"
+}
+
+func hasMandarin(meta api.UploadSubject) bool {
+	for _, values := range [][]string{meta.AudioLanguages, meta.SubtitleLanguages} {
+		for _, value := range values {
+			lower := strings.ToLower(strings.TrimSpace(value))
+			if strings.Contains(lower, "mandarin") || strings.Contains(lower, "chinese") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "PTS", "ptskit.org")
+	if err != nil {
+		return values, fmt.Errorf("trackers: PTS load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func resolveType(meta api.UploadSubject) string {
+	if _, err := meta.Identity.RequireCategory(); err != nil {
+		return ""
+	}
+	if meta.Anime {
+		return "407"
+	}
+	if isTV(meta) {
+		return "405"
+	}
+	return "404"
+}
+
+func sanitizeDescription(input string) string {
+	return finalizeDescription(input)
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	lines := []string{"[center][b]Screenshots[/b]"}
+	for _, image := range images {
+		imgURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL))
+		webURL := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.WebURL, imgURL))
+		if imgURL == "" || webURL == "" {
+			continue
+		}
+		lines = append(lines, fmt.Sprintf("[url=%s][img]%s[/img][/url]", webURL, imgURL))
+	}
+	lines = append(lines, "[/center]")
+	return strings.Join(lines, "\n")
+}
+
+func parseUploadID(location string, body string) string {
+	for _, value := range []string{location, body} {
+		match := idPattern.FindStringSubmatch(value)
+		if len(match) == 2 {
+			return strings.TrimSpace(match[1])
+		}
+	}
+	return ""
+}
+
+func imdbURL(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+}
+
+func isTV(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
diff --git a/internal/trackers/impl/standalone/questionnaire.go b/internal/trackers/impl/standalone/questionnaire.go
new file mode 100644
index 00000000..af887209
--- /dev/null
+++ b/internal/trackers/impl/standalone/questionnaire.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// QuestionnaireAnswers returns the answers stored under a normalized tracker ID.
+// Tracker answer maps use canonical uppercase IDs; missing or non-canonical keys return nil.
+func QuestionnaireAnswers(meta api.UploadSubject, tracker string) map[string]string {
+	if len(meta.TrackerQuestionnaireAnswers) == 0 {
+		return nil
+	}
+	return meta.TrackerQuestionnaireAnswers[strings.ToUpper(strings.TrimSpace(tracker))]
+}
diff --git a/internal/trackers/impl/standalone/questionnaire_test.go b/internal/trackers/impl/standalone/questionnaire_test.go
new file mode 100644
index 00000000..866b6d80
--- /dev/null
+++ b/internal/trackers/impl/standalone/questionnaire_test.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package standalone
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestQuestionnaireAnswersNormalizesRequestedTrackerID(t *testing.T) {
+	want := map[string]string{"category": "movie"}
+	meta := api.UploadSubject{TrackerQuestionnaireAnswers: map[string]map[string]string{"PTP": want}}
+
+	if got := QuestionnaireAnswers(meta, " ptp "); got["category"] != want["category"] {
+		t.Fatalf("expected canonical tracker answers, got %#v", got)
+	}
+}
+
+func TestQuestionnaireAnswersRequiresCanonicalStoredTrackerID(t *testing.T) {
+	meta := api.UploadSubject{TrackerQuestionnaireAnswers: map[string]map[string]string{"ptp": {"category": "movie"}}}
+	if got := QuestionnaireAnswers(meta, "PTP"); got != nil {
+		t.Fatalf("expected non-canonical stored key to be ignored, got %#v", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/rtf/definition.go b/internal/trackers/impl/standalone/rtf/definition.go
new file mode 100644
index 00000000..2043db60
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/definition.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	var (
+		err    error
+		assets trackers.DescriptionAssets
+	)
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+	description := buildDescription(assets)
+	return trackers.DescriptionResult{Group: "rtf", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/rtf/dupe.go b/internal/trackers/impl/standalone/rtf/dupe.go
new file mode 100644
index 00000000..00a19e4b
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/dupe.go
@@ -0,0 +1,481 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	rtfTorrentEndpoint = "https://retroflix.club/api/torrent"
+	rtfLoginEndpoint   = "https://retroflix.club/api/login"
+	rtfBrowsePrefix    = "https://retroflix.club/browse/t/"
+	rtfAgeGraceDays    = 365*10 + 3
+)
+
+type dupeSearcher struct {
+	cfg    config.Config
+	http   *http.Client
+	logger api.Logger
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:    cfg,
+		http:   httpClient,
+		logger: logger,
+	}
+}
+
+func (h dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	cfg, ok := rtfTrackerConfig(h.cfg)
+	if !ok || (rtfAPIKey(cfg) == "" && !rtfHasCredentials(cfg)) {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	if h.http == nil {
+		return dupe.Failed(dupe.FailureInternal, "RTF handler misconfigured: no HTTP client", nil)
+	}
+	if !isRTFContentOldEnough(meta, time.Now().UTC()) {
+		return dupe.NotRun(dupe.NotRunUnsupportedContent, "RTF requires content older than 10 years", nil)
+	}
+
+	params, ok := buildRTFSearchParams(meta)
+	if !ok {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb/title for RTF dupe search", nil)
+	}
+
+	apiKey, err := h.ensureAPIKey(ctx, cfg)
+	if err != nil {
+		return dupe.Failed(dupe.FailureAuthentication, "RTF api key refresh failed", err)
+	}
+
+	status, payload, err := h.search(ctx, params, apiKey)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "RTF request failed", err)
+	}
+	if status == http.StatusUnauthorized || status == http.StatusForbidden {
+		if !rtfHasCredentials(cfg) {
+			return dupe.NotRun(dupe.NotRunMissingCredentials, "RTF api key expired and username/password are missing", nil)
+		}
+		refreshedKey, refreshErr := h.refreshToken(ctx, cfg)
+		if refreshErr != nil {
+			return dupe.Failed(dupe.FailureAuthentication, "RTF api key refresh failed", refreshErr)
+		}
+		h.cacheRTFAPIKey(cfg, refreshedKey)
+		status, payload, err = h.search(ctx, params, refreshedKey)
+		if err != nil {
+			return dupe.Failed(dupe.FailureRequest, "RTF request failed", err)
+		}
+	}
+	if status < 200 || status >= 300 {
+		return dupe.Failed(dupe.FailureResponseStatus, "RTF search failed", nil)
+	}
+	list, ok := anyToSlice(payload)
+	if !ok {
+		return dupe.Failed(dupe.FailureResponseParse, "RTF response parse failed", nil)
+	}
+	entries := make([]api.DupeEntry, 0, len(list))
+	for _, raw := range list {
+		item, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		id := stringFromAny(item["id"])
+		entry := api.DupeEntry{
+			Name:     stringFromAny(item["name"]),
+			ID:       id,
+			Link:     buildRTFLink(item, id),
+			Download: buildRTFDownloadLink(id),
+		}
+		size := intFromAny(item["size"])
+		if size > 0 {
+			entry.SizeKnown = true
+			entry.SizeBytes = size
+		}
+		if files, ok := item["files"].([]any); ok {
+			entry.FileCount = len(files)
+			for _, f := range files {
+				if fileMap, ok := f.(map[string]any); ok {
+					name := stringFromAny(fileMap["name"])
+					if name != "" {
+						entry.Files = append(entry.Files, name)
+					}
+				}
+			}
+		}
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func buildRTFSearchParams(meta api.DuplicateSubject) (url.Values, bool) {
+	params := url.Values{}
+	params.Set("includingDead", "1")
+	if meta.Identity.IMDBID != 0 {
+		params.Set("imdbId", fmt.Sprintf("tt%07d", meta.Identity.IMDBID))
+		return params, true
+	}
+	query := cleanRTFSearchTitle(meta)
+	if query == "" {
+		return nil, false
+	}
+	params.Set("search", query)
+	return params, true
+}
+
+func cleanRTFSearchTitle(meta api.DuplicateSubject) string {
+	query := strings.TrimSpace(meta.Release.Title)
+	if query == "" {
+		query = strings.TrimSpace(meta.ReleaseName)
+	}
+	if query == "" {
+		return ""
+	}
+	replacer := strings.NewReplacer(
+		":", " ",
+		",", "",
+		"'", "",
+		"’", "",
+	)
+	query = replacer.Replace(query)
+	return strings.Join(strings.Fields(query), " ")
+}
+
+func (h dupeSearcher) search(ctx context.Context, params url.Values, apiKey string) (int, any, error) {
+	headers := map[string]string{
+		"accept":        "application/json",
+		"Authorization": strings.TrimSpace(apiKey),
+	}
+	return rtfJSONRequest(ctx, h.http, http.MethodGet, rtfTorrentEndpoint, params, nil, headers)
+}
+
+func (h dupeSearcher) ensureAPIKey(ctx context.Context, cfg config.TrackerConfig) (string, error) {
+	apiKey := rtfAPIKey(cfg)
+	if apiKey != "" {
+		return apiKey, nil
+	}
+	if !rtfHasCredentials(cfg) {
+		return "", errors.New("RTF api key unavailable: missing username/password for refresh")
+	}
+	token, err := h.refreshToken(ctx, cfg)
+	if err != nil {
+		return "", fmt.Errorf("RTF api key unavailable: %w", err)
+	}
+	h.cacheRTFAPIKey(cfg, token)
+	return token, nil
+}
+
+func (h dupeSearcher) refreshToken(ctx context.Context, cfg config.TrackerConfig) (string, error) {
+	body := map[string]any{
+		"username": strings.TrimSpace(cfg.Username),
+		"password": strings.TrimSpace(cfg.Password),
+	}
+	status, payload, err := rtfJSONRequest(ctx, h.http, http.MethodPost, rtfLoginEndpoint, nil, body, map[string]string{"accept": "application/json"})
+	if err != nil {
+		return "", fmt.Errorf("RTF login request failed: %w", err)
+	}
+	if status < 200 || status >= 300 {
+		return "", fmt.Errorf("RTF login returned status %d", status)
+	}
+	obj, ok := payload.(map[string]any)
+	if !ok {
+		return "", errors.New("RTF login returned invalid payload")
+	}
+	token := strings.TrimSpace(stringFromAny(obj["token"]))
+	if token == "" {
+		return "", errors.New("RTF login response missing token")
+	}
+	return token, nil
+}
+
+// cacheRTFAPIKey updates the in-memory config map so later searches in this
+// process can reuse a refreshed token. Writing back to durable config storage
+// is handled elsewhere.
+func (h dupeSearcher) cacheRTFAPIKey(cfg config.TrackerConfig, token string) {
+	if strings.TrimSpace(token) == "" || len(h.cfg.Trackers.Trackers) == 0 {
+		return
+	}
+	for key, current := range h.cfg.Trackers.Trackers {
+		if !strings.EqualFold(key, "RTF") {
+			continue
+		}
+		current.APIKey = token
+		current.PTPAPIKey = token
+		h.cfg.Trackers.Trackers[key] = current
+		return
+	}
+	cfg.APIKey = token
+	cfg.PTPAPIKey = token
+	h.cfg.Trackers.Trackers["RTF"] = cfg
+}
+
+func rtfAPIKey(cfg config.TrackerConfig) string {
+	if key := strings.TrimSpace(cfg.APIKey); key != "" {
+		return key
+	}
+	return strings.TrimSpace(cfg.PTPAPIKey)
+}
+
+func rtfHasCredentials(cfg config.TrackerConfig) bool {
+	return strings.TrimSpace(cfg.Username) != "" && strings.TrimSpace(cfg.Password) != ""
+}
+
+func buildRTFLink(item map[string]any, id string) string {
+	if link := strings.TrimSpace(stringFromAny(item["url"])); link != "" {
+		return link
+	}
+	if id == "" {
+		return ""
+	}
+	return rtfBrowsePrefix + url.PathEscape(id)
+}
+
+func buildRTFDownloadLink(id string) string {
+	if strings.TrimSpace(id) == "" {
+		return ""
+	}
+	return rtfTorrentEndpoint + "/" + url.PathEscape(id) + "/download"
+}
+
+func isRTFContentOldEnough(meta api.DuplicateSubject, now time.Time) bool {
+	cutoff := now.UTC().AddDate(0, 0, -rtfAgeGraceDays)
+	if date, ok := rtfReferenceDate(meta); ok {
+		return !date.After(cutoff)
+	}
+	year := rtfReferenceYear(meta)
+	if year == 0 {
+		return true
+	}
+	// Year-based fallback is intentionally looser than the date-based check
+	// because month/day precision is unavailable when only year is known.
+	return now.UTC().Year()-year > 9
+}
+
+func rtfReferenceDate(meta api.DuplicateSubject) (time.Time, bool) {
+	category := rtfCategory(meta)
+	switch category {
+	case "MOVIE":
+		return rtfMovieReleaseDate(meta)
+	case "TV":
+		return rtfMostRecentTVDate(meta)
+	default:
+		if date, ok := rtfMovieReleaseDate(meta); ok {
+			return date, true
+		}
+		return rtfMostRecentTVDate(meta)
+	}
+}
+
+func rtfMovieReleaseDate(meta api.DuplicateSubject) (time.Time, bool) {
+	if meta.ProviderMetadata.TMDB == nil {
+		return time.Time{}, false
+	}
+	return parseRTFDate(meta.ProviderMetadata.TMDB.ReleaseDate)
+}
+
+func rtfMostRecentTVDate(meta api.DuplicateSubject) (time.Time, bool) {
+	candidates := make([]time.Time, 0, 8)
+	if meta.ProviderMetadata.TMDB != nil {
+		if date, ok := parseRTFDate(meta.ProviderMetadata.TMDB.LastAirDate); ok {
+			candidates = append(candidates, date)
+		}
+		if date, ok := parseRTFDate(meta.ProviderMetadata.TMDB.FirstAirDate); ok {
+			candidates = append(candidates, date)
+		}
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		if date, ok := parseRTFDate(meta.ProviderMetadata.TVmaze.Premiered); ok {
+			candidates = append(candidates, date)
+		}
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		for _, episode := range meta.ProviderMetadata.IMDB.Episodes {
+			if date, ok := rtfEpisodeDate(episode); ok {
+				candidates = append(candidates, date)
+			}
+		}
+	}
+	if len(candidates) == 0 {
+		return time.Time{}, false
+	}
+	latest := candidates[0]
+	for _, candidate := range candidates[1:] {
+		if candidate.After(latest) {
+			latest = candidate
+		}
+	}
+	return latest, true
+}
+
+func rtfEpisodeDate(episode api.IMDBEpisode) (time.Time, bool) {
+	if episode.ReleaseDate.Year > 0 {
+		month := episode.ReleaseDate.Month
+		if month <= 0 {
+			month = 1
+		}
+		day := episode.ReleaseDate.Day
+		if day <= 0 {
+			day = 1
+		}
+		return time.Date(episode.ReleaseDate.Year, time.Month(month), day, 0, 0, 0, 0, time.UTC), true
+	}
+	if episode.ReleaseYear > 0 {
+		return time.Date(episode.ReleaseYear, time.January, 1, 0, 0, 0, 0, time.UTC), true
+	}
+	return time.Time{}, false
+}
+
+func parseRTFDate(raw string) (time.Time, bool) {
+	value := strings.TrimSpace(raw)
+	if value == "" {
+		return time.Time{}, false
+	}
+	for _, layout := range []string{"2006-01-02", time.RFC3339} {
+		parsed, err := time.Parse(layout, value)
+		if err != nil {
+			continue
+		}
+		return time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, time.UTC), true
+	}
+	return time.Time{}, false
+}
+
+func rtfReferenceYear(meta api.DuplicateSubject) int {
+	if date, ok := rtfReferenceDate(meta); ok {
+		return date.Year()
+	}
+	if meta.Release.Year > 0 {
+		return meta.Release.Year
+	}
+	if meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Year > 0 {
+		return meta.ProviderMetadata.TMDB.Year
+	}
+	if meta.ProviderMetadata.IMDB != nil && meta.ProviderMetadata.IMDB.Year > 0 {
+		return meta.ProviderMetadata.IMDB.Year
+	}
+	if meta.ProviderMetadata.TVmaze != nil {
+		if date, ok := parseRTFDate(meta.ProviderMetadata.TVmaze.Premiered); ok {
+			return date.Year()
+		}
+	}
+	return 0
+}
+
+func rtfCategory(meta api.DuplicateSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	return strings.ToUpper(string(category))
+}
+
+func rtfJSONRequest(
+	ctx context.Context,
+	client *http.Client,
+	method, endpoint string,
+	params url.Values,
+	body map[string]any,
+	headers map[string]string,
+) (int, any, error) {
+	var payload []byte
+	var err error
+	if body != nil {
+		payload, err = json.Marshal(body)
+		if err != nil {
+			return 0, nil, fmt.Errorf("rtf: encode request: %w", err)
+		}
+	}
+	req, err := http.NewRequestWithContext(ctx, method, endpoint, bytes.NewReader(payload))
+	if err != nil {
+		return 0, nil, fmt.Errorf("rtf: create request: %w", err)
+	}
+	if len(params) > 0 {
+		req.URL.RawQuery = params.Encode()
+	}
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, nil, fmt.Errorf("rtf: request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return resp.StatusCode, nil, nil
+	}
+	var result any
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&result); err != nil {
+		return resp.StatusCode, nil, fmt.Errorf("rtf: decode response: %w", err)
+	}
+	return resp.StatusCode, result, nil
+}
+
+func rtfTrackerConfig(cfg config.Config) (config.TrackerConfig, bool) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "RTF") {
+			return entry, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+func anyToSlice(value any) ([]any, bool) {
+	items, ok := value.([]any)
+	if ok {
+		return items, true
+	}
+	if object, ok := value.(map[string]any); ok {
+		for _, key := range []string{"data", "results", "torrents", "response"} {
+			if items, ok := object[key].([]any); ok {
+				return items, true
+			}
+		}
+	}
+	return nil, false
+}
+func stringFromAny(value any) string {
+	if value == nil {
+		return ""
+	}
+	if text, ok := value.(string); ok {
+		return strings.TrimSpace(text)
+	}
+	return strings.TrimSpace(fmt.Sprint(value))
+}
+func intFromAny(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/rtf/dupe_test.go b/internal/trackers/impl/standalone/rtf/dupe_test.go
new file mode 100644
index 00000000..a939da45
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/dupe_test.go
@@ -0,0 +1,232 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func adapterEvidence(result dupe.AdapterResult) ([]api.DupeEntry, []string, error) {
+	return result.Entries(), result.Notes(), result.Cause()
+}
+
+type rtfRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f rtfRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
+
+func TestRTFHandlerUsesIMDBIDParamAndParsesResults(t *testing.T) {
+	t.Parallel()
+
+	sawSearch := false
+	client := &http.Client{
+		Transport: rtfRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			switch req.URL.Path {
+			case "/api/torrent":
+				sawSearch = true
+				query := req.URL.Query()
+				if got := query.Get("includingDead"); got != "1" {
+					t.Fatalf("unexpected includingDead value %q", got)
+				}
+				if got := query.Get("imdbId"); got != "tt0123456" {
+					t.Fatalf("unexpected imdbId value %q", got)
+				}
+				if got := query.Get("imdb"); got != "" {
+					t.Fatalf("unexpected imdb query value %q", got)
+				}
+				body := `[{"id":"42","name":"Movie.1990.1080p.BluRay-GRP","size":123456789,"files":[{"name":"Movie.1990.1080p.BluRay-GRP.mkv"}]}]`
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(strings.NewReader(body)),
+					Header:     make(http.Header),
+				}, nil
+			default:
+				t.Fatalf("unexpected request path %q", req.URL.Path)
+				return nil, nil
+			}
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "RTF",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"RTF": {APIKey: "good-key"},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{IMDBID: 123456, Category: "MOVIE"},
+		Release:  api.ReleaseInfo{Year: 1990},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected one entry, got %d", len(entries))
+	}
+	if !sawSearch {
+		t.Fatalf("expected /api/torrent call")
+	}
+
+	entry := entries[0]
+	if entry.ID != "42" {
+		t.Fatalf("unexpected ID %q", entry.ID)
+	}
+	if entry.Link != "https://retroflix.club/browse/t/42" {
+		t.Fatalf("unexpected link %q", entry.Link)
+	}
+	if entry.Download != "https://retroflix.club/api/torrent/42/download" {
+		t.Fatalf("unexpected download %q", entry.Download)
+	}
+	if !entry.SizeKnown || entry.SizeBytes != 123456789 {
+		t.Fatalf("unexpected size known=%t size=%d", entry.SizeKnown, entry.SizeBytes)
+	}
+	if entry.FileCount != 1 || len(entry.Files) != 1 {
+		t.Fatalf("unexpected files payload count=%d files=%#v", entry.FileCount, entry.Files)
+	}
+}
+
+func TestRTFHandlerRefreshesAndRetriesOn401(t *testing.T) {
+	t.Parallel()
+
+	searchCalls := 0
+	loginCalls := 0
+	client := &http.Client{
+		Transport: rtfRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			switch req.URL.Path {
+			case "/api/login":
+				loginCalls++
+				raw, err := io.ReadAll(req.Body)
+				if err != nil {
+					t.Fatalf("read login body: %v", err)
+				}
+				body := string(raw)
+				if !strings.Contains(body, `"username":"user"`) || !strings.Contains(body, `"password":"pass"`) {
+					t.Fatal("unexpected login body fields")
+				}
+				return &http.Response{
+					StatusCode: http.StatusCreated,
+					Body:       io.NopCloser(strings.NewReader(`{"token":"new-key"}`)),
+					Header:     make(http.Header),
+				}, nil
+			case "/api/torrent":
+				searchCalls++
+				auth := req.Header.Get("Authorization")
+				if searchCalls == 1 {
+					if auth != "old-key" {
+						t.Fatal("expected first search to use old key")
+					}
+					return &http.Response{
+						StatusCode: http.StatusUnauthorized,
+						Body:       io.NopCloser(strings.NewReader(``)),
+						Header:     make(http.Header),
+					}, nil
+				}
+				if auth != "new-key" {
+					t.Fatal("expected retry search to use new key")
+				}
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(strings.NewReader(`[]`)),
+					Header:     make(http.Header),
+				}, nil
+			default:
+				t.Fatalf("unexpected request path %q", req.URL.Path)
+				return nil, nil
+			}
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "RTF",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"RTF": {
+						APIKey:   "old-key",
+						Username: "user",
+						Password: "pass",
+					},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{IMDBID: 123456, Category: "MOVIE"},
+		Release:  api.ReleaseInfo{Year: 1990},
+	}
+
+	entries, notes, err := adapterEvidence(handler.Search(context.Background(), meta))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("expected no notes, got %#v", notes)
+	}
+	if len(entries) != 0 {
+		t.Fatalf("expected no entries, got %d", len(entries))
+	}
+	if searchCalls != 2 {
+		t.Fatalf("expected 2 search calls, got %d", searchCalls)
+	}
+	if loginCalls != 1 {
+		t.Fatalf("expected 1 login call, got %d", loginCalls)
+	}
+}
+
+func TestRTFHandlerSkipsTooRecentContent(t *testing.T) {
+	t.Parallel()
+
+	called := false
+	client := &http.Client{
+		Transport: rtfRoundTripFunc(func(_ *http.Request) (*http.Response, error) {
+			called = true
+			t.Fatalf("no request should be sent for too-recent content")
+			return nil, nil
+		}),
+	}
+
+	handler := dupe.NewAdapter(New(), "RTF",
+		config.Config{
+			Trackers: config.TrackersConfig{
+				Trackers: map[string]config.TrackerConfig{
+					"RTF": {APIKey: "good-key"},
+				},
+			},
+		}, client, api.NopLogger{})
+
+	meta := api.DuplicateSubject{
+		Identity: api.ExternalIdentity{Category: "MOVIE"},
+		Release:  api.ReleaseInfo{Title: "Recent Movie"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Category:    "MOVIE",
+				ReleaseDate: time.Now().UTC().AddDate(-1, 0, 0).Format("2006-01-02"),
+			},
+		},
+	}
+
+	result := handler.Search(context.Background(), meta)
+	if result.Disposition() != dupe.DispositionNotRun || result.Code() != dupe.NotRunUnsupportedContent ||
+		!strings.Contains(strings.ToLower(result.SafeMessage()), "10 years") {
+		t.Fatalf("unexpected result disposition=%v code=%q message=%q", result.Disposition(), result.Code(), result.SafeMessage())
+	}
+	if called {
+		t.Fatalf("request should not have been made")
+	}
+}
diff --git a/internal/trackers/impl/standalone/rtf/profile.go b/internal/trackers/impl/standalone/rtf/profile.go
new file mode 100644
index 00000000..0c5f6686
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/profile.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns RTF identity, preparation, dupe, auth, and policy behavior.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                 "RTF",
+		BaseURL:              defaultBaseURL,
+		DescriptionGroup:     "rtf",
+		UploadContentMode:    trackers.UploadContentModeScreenshots,
+		PrepareDescription:   prepareDescription,
+		PrepareUpload:        prepareUpload,
+		NewDuplicateAdapter:  newDuplicateAdapter,
+		Rules:                rules(),
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		DupePolicy:           &trackers.DupePolicy{ContainsFilenameMatch: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"peer.retroflix"},
+			CommentURLPatterns: []string{defaultBaseURL},
+			DetailIDPattern:    "(?i)retroflix\\.club/browse/t/(\\d+)",
+		},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:         "RTF",
+			DisplayName:       "RTF",
+			AuthKind:          "api_key_credential_refresh",
+			SupportsLogin:     true,
+			SupportsAutoLogin: true,
+			RequiresAPIKey:    true,
+		},
+		AuthResolver: func(ctx context.Context, cfg config.TrackerConfig, dbPath string, request api.TrackerAuthLoginRequest) error {
+			return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, request, defaultBaseURL)
+		},
+	}
+}
+
+// New returns a fresh RTF definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/rtf/rules.go b/internal/trackers/impl/standalone/rtf/rules.go
new file mode 100644
index 00000000..46e4c835
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/rules.go
@@ -0,0 +1,70 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const minimumContentAgeReason = "content must be at least 10 years old"
+
+// rules strictly blocks content newer than RTF's ten-year eligibility cutoff.
+func rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkRules} }
+
+func checkRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	if minimumContentAgeViolation(meta, time.Now().UTC()) {
+		return []api.RuleFailure{trackers.NewRuleFailure(
+			"minimum_content_age",
+			minimumContentAgeReason,
+			api.RuleDispositionStrict,
+		)}, nil
+	}
+	return nil, nil
+}
+
+func minimumContentAgeViolation(meta api.RuleSubject, now time.Time) bool {
+	limit := now.UTC().AddDate(-10, 0, 3)
+	if releaseDate := ruleReleaseDate(meta); !releaseDate.IsZero() {
+		return releaseDate.After(limit)
+	}
+	return ruleReleaseYear(meta) > limit.Year()
+}
+
+func ruleReleaseDate(meta api.RuleSubject) time.Time {
+	if meta.ProviderMetadata.TMDB == nil {
+		return time.Time{}
+	}
+	for _, value := range []string{
+		strings.TrimSpace(meta.ProviderMetadata.TMDB.ReleaseDate),
+		strings.TrimSpace(meta.ProviderMetadata.TMDB.LastAirDate),
+		strings.TrimSpace(meta.ProviderMetadata.TMDB.FirstAirDate),
+	} {
+		if value == "" {
+			continue
+		}
+		if releaseDate, err := time.Parse("2006-01-02", value); err == nil {
+			return releaseDate
+		}
+	}
+	return time.Time{}
+}
+
+func ruleReleaseYear(meta api.RuleSubject) int {
+	if meta.Release.Year > 0 {
+		return meta.Release.Year
+	}
+	if meta.ProviderMetadata.TMDB == nil {
+		return 0
+	}
+	return meta.ProviderMetadata.TMDB.Year
+}
diff --git a/internal/trackers/impl/standalone/rtf/rules_test.go b/internal/trackers/impl/standalone/rtf/rules_test.go
new file mode 100644
index 00000000..64bccf93
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/rules_test.go
@@ -0,0 +1,50 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestMinimumContentAgeRuleIsStrict(t *testing.T) {
+	t.Parallel()
+
+	ruleSet := Profile().Rules
+	if ruleSet == nil || ruleSet.Check == nil {
+		t.Fatal("RTF minimum content age rule is not registered")
+	}
+	failures, err := ruleSet.Check(context.Background(), api.RuleSubject{
+		Release: api.ReleaseInfo{Year: 9999},
+	}, nil)
+	if err != nil {
+		t.Fatalf("check RTF rules: %v", err)
+	}
+	if len(failures) != 1 {
+		t.Fatalf("RTF age failures = %#v, want one", failures)
+	}
+	failure := failures[0]
+	if failure.Rule != "minimum_content_age" || failure.Reason != minimumContentAgeReason || failure.Disposition != api.RuleDispositionStrict {
+		t.Fatalf("RTF age failure = %#v, want strict minimum_content_age", failure)
+	}
+}
+
+func TestMinimumContentAgeBoundary(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, time.July, 18, 0, 0, 0, 0, time.UTC)
+	if minimumContentAgeViolation(api.RuleSubject{
+		ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{ReleaseDate: "2016-07-21"}},
+	}, now) {
+		t.Fatal("content on the age boundary was rejected")
+	}
+	if !minimumContentAgeViolation(api.RuleSubject{
+		ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{ReleaseDate: "2016-07-22"}},
+	}, now) {
+		t.Fatal("content newer than the age boundary was allowed")
+	}
+}
diff --git a/internal/trackers/impl/standalone/rtf/upload.go b/internal/trackers/impl/standalone/rtf/upload.go
new file mode 100644
index 00000000..0e5cf06c
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/upload.go
@@ -0,0 +1,496 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	defaultBaseURL = "https://retroflix.club"
+	sourceFlag     = "sunshine"
+)
+
+var newHTTPClient = func() *http.Client { return &http.Client{Timeout: 40 * time.Second} }
+
+type uploadResponse struct {
+	Error   bool   `json:"error"`
+	Message string `json:"message"`
+	Torrent struct {
+		ID any `json:"id"`
+	} `json:"torrent"`
+}
+
+type uploadState struct {
+	torrentPath   string
+	releaseName   string
+	description   string
+	payload       map[string]any
+	blockedReason string
+}
+
+func uploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (api.UploadSummary, error) {
+	req.Intent = trackers.PreparationIntentUpload
+	plan, failure := trackers.PrepareAdapter(ctx, req, nil, func(ctx context.Context, input trackers.PreparationInput) (trackers.PreparedOperation, error) {
+		return prepareUploadAt(ctx, input, baseURL)
+	})
+	if failure != nil {
+		return api.UploadSummary{}, failure
+	}
+	summary, err := plan.Submit(ctx)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: RTF submit prepared upload: %w", err)
+	}
+	return summary, nil
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	return prepareUploadAt(ctx, req, defaultBaseURL)
+}
+
+func prepareUploadAt(ctx context.Context, req trackers.PreparationInput, baseURL string) (trackers.PreparedOperation, error) {
+	uploadURL, err := joinURL(baseURL, "/api/upload")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview, err := buildUploadPreview(state, baseURL)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: RTF %s", state.blockedReason)
+	}
+
+	apiKey, err := resolveAPIKey(ctx, req, baseURL)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+
+	body, err := json.Marshal(state.payload)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: RTF marshal upload payload: %w", err)
+	}
+	torrentURL, err := joinURL(baseURL, "/browse/t/")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	downloadURL, err := joinURL(baseURL, "/api/torrent/")
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "RTF")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(
+			submitCtx, req, state, uploadURL, body, apiKey, torrentURL, downloadURL, announceURL, artifactPath,
+		)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	uploadURL string,
+	body []byte,
+	apiKey string,
+	torrentURL string,
+	downloadURL string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, strings.NewReader(string(body)))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: RTF create upload request: %w", err)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Authorization", apiKey)
+
+	resp, err := newHTTPClient().Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: RTF upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	responseBody, _ := io.ReadAll(resp.Body)
+
+	var decoded uploadResponse
+	_ = json.Unmarshal(responseBody, &decoded)
+	if resp.StatusCode == http.StatusCreated && !decoded.Error {
+		id := strings.TrimSpace(fmt.Sprint(decoded.Torrent.ID))
+		if id == "" {
+			return api.UploadSummary{}, errors.New("trackers: RTF upload succeeded but torrent id missing")
+		}
+		tURL := torrentURL + id
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, tURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "RTF",
+				TorrentID:   id,
+				TorrentURL:  tURL,
+				DownloadURL: downloadURL + id + "/download",
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "RTF", "upload_failure", responseBody, ".json")
+	return api.UploadSummary{}, fmt.Errorf(
+		"trackers: RTF %s",
+		metautil.FirstNonEmptyTrimmed(
+			commonhttp.ExtractHTTPErrorDetail(responseBody),
+			commonhttp.RedactErrorDetail(decoded.Message),
+			fmt.Sprintf("upload failed with status %d", resp.StatusCode),
+		),
+	)
+}
+
+func buildUploadPreview(state uploadState, baseURL string) (api.TrackerDryRunEntry, error) {
+	payload := make(map[string]string, len(state.payload))
+	for key, value := range state.payload {
+		payload[key] = strings.TrimSpace(fmt.Sprint(value))
+	}
+	endpoint, err := joinURL(baseURL, "/api/upload")
+	if err != nil {
+		return api.TrackerDryRunEntry{}, err
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "RTF",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "rtf",
+		Description:      state.description,
+		Endpoint:         endpoint,
+		Payload:          payload,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	}), nil
+}
+
+func prepareUploadState(_ context.Context, req trackers.PreparationInput) (uploadState, error) {
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" &&
+		(strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "") {
+		return uploadState{}, errors.New("trackers: RTF missing api_key or username/password")
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	var assets trackers.DescriptionAssets
+	if req.Assets != nil {
+		assets = *req.Assets
+	} else {
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
+		if err != nil {
+			trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+			assets = trackers.DescriptionAssets{}
+		}
+	}
+	description := buildDescription(assets)
+	torrentBytes, err := os.ReadFile(torrentPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: RTF read torrent file: %w", err)
+	}
+	releaseName := metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename)
+	payload := map[string]any{
+		"name":        releaseName,
+		"description": description,
+		"mediaInfo":   commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
+		"nfo":         "",
+		"url":         imdbURL(req.Meta),
+		"descr":       description,
+		"poster":      resolvePoster(req.Meta),
+		"type":        resolveType(req.Meta),
+		"screenshots": screenshots(assets.Screenshots),
+		"isAnonymous": req.TrackerConfig.Anon,
+		"file":        base64.StdEncoding.EncodeToString(torrentBytes),
+	}
+	return uploadState{
+		torrentPath:   torrentPath,
+		releaseName:   releaseName,
+		description:   description,
+		payload:       payload,
+		blockedReason: validateEligibility(req.Meta),
+	}, nil
+}
+
+// resolveAPIKey validates configured RTF API auth and persists a refreshed token when credentials are used.
+// Callers must complete no-upload eligibility gates before invoking it.
+func resolveAPIKey(ctx context.Context, req trackers.PreparationInput, baseURL string) (string, error) {
+	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
+	if apiKey != "" {
+		valid, err := testAPIKey(ctx, baseURL, apiKey)
+		if err == nil && valid {
+			return apiKey, nil
+		}
+		if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
+			if err != nil {
+				return "", fmt.Errorf("trackers: RTF API key validation failed and username/password not configured: %w", err)
+			}
+			return "", errors.New("trackers: RTF API key invalid and username/password not configured")
+		}
+	}
+	if strings.TrimSpace(req.TrackerConfig.Username) == "" || strings.TrimSpace(req.TrackerConfig.Password) == "" {
+		return "", errors.New("trackers: RTF missing api_key or username/password")
+	}
+	refreshed, err := refreshAPIKey(ctx, baseURL, req.TrackerConfig)
+	if err != nil {
+		return "", err
+	}
+	if err := persistRefreshedAPIKey(ctx, req.Runtime.DBPath, refreshed); err != nil && req.Logger != nil {
+		req.Logger.Warnf("trackers: RTF failed to persist refreshed API key: %v", err)
+	}
+	return refreshed, nil
+}
+
+// ResolveSessionForTrackerAuthLogin validates RTF API auth or refreshes and
+// persists the API key with configured credentials for tracker-auth checks.
+func ResolveSessionForTrackerAuthLogin(ctx context.Context, cfg config.TrackerConfig, dbPath string, _ api.TrackerAuthLoginRequest) error {
+	return resolveSessionForTrackerAuthLoginAt(ctx, cfg, dbPath, api.TrackerAuthLoginRequest{}, defaultBaseURL)
+}
+
+func resolveSessionForTrackerAuthLoginAt(
+	ctx context.Context,
+	cfg config.TrackerConfig,
+	dbPath string,
+	_ api.TrackerAuthLoginRequest,
+	baseURL string,
+) error {
+	apiKey := strings.TrimSpace(cfg.APIKey)
+	if apiKey != "" {
+		valid, err := testAPIKey(ctx, baseURL, apiKey)
+		if err == nil && valid {
+			return nil
+		}
+		if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+			if err != nil {
+				return fmt.Errorf("trackers: RTF API key validation failed and username/password not configured: %w", err)
+			}
+			return errors.New("trackers: RTF API key invalid and username/password not configured")
+		}
+	}
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return errors.New("trackers: RTF missing api_key or username/password")
+	}
+	refreshed, err := refreshAPIKey(ctx, baseURL, cfg)
+	if err != nil {
+		return err
+	}
+	if err := persistRefreshedAPIKey(ctx, dbPath, refreshed); err != nil {
+		return err
+	}
+	return nil
+}
+
+func testAPIKey(ctx context.Context, baseURL string, apiKey string) (bool, error) {
+	testURL, err := joinURL(baseURL, "/api/test")
+	if err != nil {
+		return false, err
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, testURL, nil)
+	if err != nil {
+		return false, fmt.Errorf("trackers: RTF create API test request: %w", err)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
+	resp, err := newHTTPClient().Do(httpReq)
+	if err != nil {
+		return false, fmt.Errorf("trackers: RTF API test request: %w", err)
+	}
+	defer resp.Body.Close()
+	return resp.StatusCode == http.StatusOK, nil
+}
+
+func refreshAPIKey(ctx context.Context, baseURL string, cfg config.TrackerConfig) (string, error) {
+	payload := map[string]string{
+		"username": strings.TrimSpace(cfg.Username),
+		"password": strings.TrimSpace(cfg.Password),
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("trackers: RTF marshal API login payload: %w", err)
+	}
+	loginURL, err := joinURL(baseURL, "/api/login")
+	if err != nil {
+		return "", err
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, loginURL, strings.NewReader(string(body)))
+	if err != nil {
+		return "", fmt.Errorf("trackers: RTF create API login request: %w", err)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	httpReq.Header.Set("Content-Type", "application/json")
+	resp, err := newHTTPClient().Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("trackers: RTF API login request: %w", err)
+	}
+	defer resp.Body.Close()
+	responseBody, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("trackers: RTF API login failed status=%d", resp.StatusCode)
+	}
+	var decoded struct {
+		Token string `json:"token"`
+	}
+	if err := json.Unmarshal(responseBody, &decoded); err != nil {
+		return "", fmt.Errorf("trackers: RTF decode API login response: %w", err)
+	}
+	token := strings.TrimSpace(decoded.Token)
+	if token == "" {
+		return "", errors.New("trackers: RTF API login response missing token")
+	}
+	return token, nil
+}
+
+func persistRefreshedAPIKey(ctx context.Context, dbPath string, token string) error {
+	dbPath = strings.TrimSpace(dbPath)
+	if dbPath == "" {
+		return errors.New("trackers: RTF persist refreshed API key: db path not configured")
+	}
+	repo, err := servicedb.OpenContext(ctx, dbPath)
+	if err != nil {
+		return fmt.Errorf("trackers: RTF persist refreshed API key open db: %w", err)
+	}
+	defer repo.Close()
+	cfg, err := config.LoadFromDatabase(ctx, repo)
+	if err != nil {
+		return fmt.Errorf("trackers: RTF persist refreshed API key load config: %w", err)
+	}
+	if cfg.Trackers.Trackers == nil {
+		cfg.Trackers.Trackers = map[string]config.TrackerConfig{}
+	}
+	trackerKey := "RTF"
+	for key := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(key), "RTF") {
+			trackerKey = key
+			break
+		}
+	}
+	trackerCfg := cfg.Trackers.Trackers[trackerKey]
+	trackerCfg.APIKey = strings.TrimSpace(token)
+	cfg.Trackers.Trackers[trackerKey] = trackerCfg
+	if err := config.SaveToDatabase(ctx, cfg, repo); err != nil {
+		return fmt.Errorf("trackers: RTF persist refreshed API key: %w", err)
+	}
+	return nil
+}
+
+// joinURL resolves path against a profile-owned base URL.
+func joinURL(baseURL string, path string) (string, error) {
+	parsed, err := url.Parse(strings.TrimRight(baseURL, "/") + "/")
+	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+		return "", fmt.Errorf("trackers: RTF invalid base URL %q", baseURL)
+	}
+	ref, err := url.Parse(strings.TrimLeft(path, "/"))
+	if err != nil {
+		return "", fmt.Errorf("trackers: RTF invalid URL path %q: %w", path, err)
+	}
+	return parsed.ResolveReference(ref).String(), nil
+}
+
+func buildDescription(assets trackers.DescriptionAssets) string {
+	return strings.TrimSpace(assets.Description)
+}
+
+func validateEligibility(meta api.UploadSubject) string {
+	genres := strings.ToLower(genresText(meta) + "," + keywordsText(meta))
+	for _, value := range []string{"xxx", "erotic", "porn", "adult", "orgy"} {
+		if strings.Contains(genres, value) {
+			return "adult content is not allowed"
+		}
+	}
+	if minimumContentAgeViolation(api.NewRuleSubject(meta), time.Now().UTC()) {
+		return minimumContentAgeReason
+	}
+	return ""
+}
+
+func resolveType(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	if category == api.CanonicalCategoryMovie {
+		return "401"
+	}
+	return "402"
+}
+
+func screenshots(images []api.ScreenshotImage) []string {
+	out := make([]string, 0, len(images))
+	for _, image := range images {
+		if raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL)); raw != "" {
+			out = append(out, raw)
+		}
+	}
+	return out
+}
+
+func imdbURL(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.Identity.IMDBID)
+}
+
+func resolvePoster(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return ""
+	}
+	return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Poster)
+}
+
+func genresText(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Genres, meta.Release.Genre)
+	}
+	return metautil.FirstNonEmptyTrimmed(meta.Release.Genre)
+}
+
+func keywordsText(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return ""
+	}
+	return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+}
diff --git a/internal/trackers/impl/standalone/rtf/upload_test.go b/internal/trackers/impl/standalone/rtf/upload_test.go
new file mode 100644
index 00000000..be37b481
--- /dev/null
+++ b/internal/trackers/impl/standalone/rtf/upload_test.go
@@ -0,0 +1,320 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rtf
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	servicedb "github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildUploadDryRunUsesDescriptionPayloadAndLeavesNFOEmpty(t *testing.T) {
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	input := trackers.PreparationInput{
+		Intent:  trackers.PreparationIntentDryRun,
+		Tracker: "RTF",
+		Meta: api.UploadSubject{
+			TorrentPath:         torrentPath,
+			DescriptionOverride: "Custom description",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+		Assets:        &trackers.DescriptionAssets{Description: "Custom description"},
+	}
+	plan, failure := New().Prepare(context.Background(), input)
+	if failure != nil {
+		t.Fatalf("unexpected error: %v", failure)
+	}
+	entry := plan.DryRun()
+
+	if entry.Payload["description"] != "Custom description" {
+		t.Fatalf("expected description payload, got %#v", entry.Payload)
+	}
+	if entry.Payload["descr"] != "Custom description" {
+		t.Fatalf("expected descr payload mirror, got %#v", entry.Payload)
+	}
+	if entry.Payload["nfo"] != "" {
+		t.Fatalf("expected empty nfo payload, got %#v", entry.Payload["nfo"])
+	}
+}
+
+func TestUploadRefreshesExpiredAPIKeyAndPersistsIt(t *testing.T) {
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	dbPath := filepath.Join(root, "upbrr.db")
+	seedRTFConfig(t, dbPath, config.TrackerConfig{
+		APIKey:   "old-token",
+		Username: "user",
+		Password: "pass",
+	})
+
+	var testedToken string
+	var loginCalled bool
+	var uploadToken string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/test":
+			testedToken = r.Header.Get("Authorization")
+			w.WriteHeader(http.StatusUnauthorized)
+		case "/api/login":
+			loginCalled = true
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"token":"new-token"}`))
+		case "/api/upload":
+			uploadToken = r.Header.Get("Authorization")
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	summary, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "RTF",
+		Meta: api.UploadSubject{
+			TorrentPath: torrentPath,
+			ReleaseName: "Release",
+		},
+		TrackerConfig: config.TrackerConfig{
+			APIKey:   "old-token",
+			Username: "user",
+			Password: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+	}, server.URL)
+	if err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+	if summary.Uploaded != 1 {
+		t.Fatalf("expected upload success, got %#v", summary)
+	}
+	if testedToken != "old-token" {
+		t.Fatal("expected old token to be tested")
+	}
+	if !loginCalled {
+		t.Fatal("expected expired token to trigger API login")
+	}
+	if uploadToken != "new-token" {
+		t.Fatal("expected upload to use refreshed token")
+	}
+	if got := loadStoredRTFAPIKey(t, dbPath); got != "new-token" {
+		t.Fatal("expected refreshed token persisted")
+	}
+}
+
+func TestUploadBlockedExpiredAPIKeyDoesNotRefreshOrPersist(t *testing.T) {
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	dbPath := filepath.Join(root, "upbrr.db")
+	seedRTFConfig(t, dbPath, config.TrackerConfig{
+		APIKey:   "old-token",
+		Username: "user",
+		Password: "pass",
+	})
+
+	requests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requests++
+		http.NotFound(w, r)
+	}))
+	t.Cleanup(server.Close)
+
+	_, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "RTF",
+		Meta: api.UploadSubject{
+			TorrentPath: torrentPath,
+			ReleaseName: "Recent Release",
+			Release:     api.ReleaseInfo{Year: 9999},
+		},
+		TrackerConfig: config.TrackerConfig{
+			APIKey:   "old-token",
+			Username: "user",
+			Password: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+	}, server.URL)
+	if err == nil {
+		t.Fatal("expected blocked upload error")
+	}
+	if !strings.Contains(err.Error(), "content must be at least 10 years old") {
+		t.Fatalf("expected eligibility error, got %v", err)
+	}
+	if requests != 0 {
+		t.Fatalf("blocked upload must not call RTF auth or upload endpoints, got %d requests", requests)
+	}
+	if got := loadStoredRTFAPIKey(t, dbPath); got != "old-token" {
+		t.Fatal("blocked upload must leave stored token unchanged")
+	}
+}
+
+func TestUploadUsesValidAPIKeyWithoutRefresh(t *testing.T) {
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	var loginCalled bool
+	var uploadToken string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/test":
+			w.WriteHeader(http.StatusOK)
+		case "/api/login":
+			loginCalled = true
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"token":"new-token"}`))
+		case "/api/upload":
+			uploadToken = r.Header.Get("Authorization")
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	if _, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "RTF",
+		Meta: api.UploadSubject{
+			TorrentPath: torrentPath,
+			ReleaseName: "Release",
+		},
+		TrackerConfig: config.TrackerConfig{
+			APIKey: "valid-token",
+		},
+	}, server.URL); err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+	if loginCalled {
+		t.Fatal("valid token should not trigger API login")
+	}
+	if uploadToken != "valid-token" {
+		t.Fatal("expected upload to use original token")
+	}
+}
+
+func TestUploadGeneratesMissingAPIKeyFromCredentials(t *testing.T) {
+	root := t.TempDir()
+	torrentPath := filepath.Join(root, "test.torrent")
+	if err := os.WriteFile(torrentPath, []byte("torrent-bytes"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+	dbPath := filepath.Join(root, "upbrr.db")
+	seedRTFConfig(t, dbPath, config.TrackerConfig{Username: "user", Password: "pass"})
+
+	var testCalled bool
+	var uploadToken string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/test":
+			testCalled = true
+			w.WriteHeader(http.StatusOK)
+		case "/api/login":
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"token":"generated-token"}`))
+		case "/api/upload":
+			uploadToken = r.Header.Get("Authorization")
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"error":false,"torrent":{"id":123}}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	if _, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker: "RTF",
+		Meta: api.UploadSubject{
+			TorrentPath: torrentPath,
+			ReleaseName: "Release",
+		},
+		TrackerConfig: config.TrackerConfig{
+			Username: "user",
+			Password: "pass",
+		},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}}),
+	}, server.URL); err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+	if testCalled {
+		t.Fatal("missing token should refresh directly without API test")
+	}
+	if uploadToken != "generated-token" {
+		t.Fatal("expected upload to use generated token")
+	}
+	if got := loadStoredRTFAPIKey(t, dbPath); got != "generated-token" {
+		t.Fatal("expected generated token persisted")
+	}
+}
+
+func TestUploadRejectsMalformedBaseURL(t *testing.T) {
+	_, err := uploadAt(context.Background(), trackers.PreparationInput{
+		Tracker:       "RTF",
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	}, "not a url")
+	if err == nil {
+		t.Fatal("expected malformed base URL error")
+	}
+	if !strings.Contains(err.Error(), "invalid base URL") {
+		t.Fatalf("expected invalid base URL error, got %v", err)
+	}
+}
+
+func seedRTFConfig(t *testing.T, dbPath string, trackerCfg config.TrackerConfig) {
+	t.Helper()
+
+	repo, err := servicedb.OpenContext(context.Background(), dbPath)
+	if err != nil {
+		t.Fatalf("open repo: %v", err)
+	}
+	defer repo.Close()
+	if err := repo.MigrateContext(context.Background()); err != nil {
+		t.Fatalf("MigrateContext: %v", err)
+	}
+	cfg := config.Config{
+		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
+		Trackers: config.TrackersConfig{
+			Trackers: map[string]config.TrackerConfig{"RTF": trackerCfg},
+		},
+	}
+	if err := config.SaveToDatabase(context.Background(), &cfg, repo); err != nil {
+		t.Fatalf("SaveToDatabase: %v", err)
+	}
+}
+
+func loadStoredRTFAPIKey(t *testing.T, dbPath string) string {
+	t.Helper()
+
+	repo, err := servicedb.OpenContext(context.Background(), dbPath)
+	if err != nil {
+		t.Fatalf("open repo: %v", err)
+	}
+	defer repo.Close()
+	cfg, err := config.LoadFromDatabase(context.Background(), repo)
+	if err != nil {
+		t.Fatalf("LoadFromDatabase: %v", err)
+	}
+	return cfg.Trackers.Trackers["RTF"].APIKey
+}
diff --git a/internal/trackers/impl/standalone/spd/bbcode.go b/internal/trackers/impl/standalone/spd/bbcode.go
new file mode 100644
index 00000000..534a4c58
--- /dev/null
+++ b/internal/trackers/impl/standalone/spd/bbcode.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package spd
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.RemoveImageResize(value)
+	value = bbcode.ConvertNamedSpoilerToNormalSpoiler(value)
+	value = strings.NewReplacer("[note]", "Note: ", "[/note]", "", "[code]", "", "[/code]", "", "[*]", "• ").Replace(value)
+	value = bbcode.RemoveSpoiler(value)
+	value = bbcode.RemoveList(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/spd/dupe.go b/internal/trackers/impl/standalone/spd/dupe.go
new file mode 100644
index 00000000..0f0415a8
--- /dev/null
+++ b/internal/trackers/impl/standalone/spd/dupe.go
@@ -0,0 +1,71 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package spd
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone/internal/jsondupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg      config.Config
+	http     *http.Client
+	endpoint string
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		cfg:      cfg,
+		http:     httpClient,
+		endpoint: "https://speedapp.io/api/torrent",
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	apiKey := spdAPIKey(s.cfg)
+	if apiKey == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	params := url.Values{}
+	switch {
+	case meta.Identity.IMDBID != 0:
+		params.Set("imdbId", strconv.Itoa(meta.Identity.IMDBID))
+	case strings.TrimSpace(meta.Release.Title) != "":
+		params.Set("search", strings.TrimSpace(meta.Release.Title))
+	default:
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing imdb/title for SPD dupe search", nil)
+	}
+	return jsondupe.Search(ctx, s.http, jsondupe.ListSpec{
+		Endpoint:       s.endpoint,
+		Query:          params,
+		Headers:        http.Header{"Authorization": {apiKey}, "Accept": {"application/json"}},
+		IDField:        "id",
+		NameField:      "name",
+		SizeField:      "size",
+		Link:           func(id string) string { return "https://speedapp.io/browse/" + id + "/" },
+		FailureMessage: "SPD search failed",
+	})
+}
+
+func spdAPIKey(cfg config.Config) string {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "SPD") {
+			return strings.TrimSpace(entry.APIKey)
+		}
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/spd/dupe_test.go b/internal/trackers/impl/standalone/spd/dupe_test.go
new file mode 100644
index 00000000..e26d974e
--- /dev/null
+++ b/internal/trackers/impl/standalone/spd/dupe_test.go
@@ -0,0 +1,50 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package spd
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDuplicateSearchUsesSPDQueryHeadersAndProjection(t *testing.T) {
+	requestErr := make(chan error, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("imdbId") != "1234567" || r.Header.Get("Authorization") != "secret" || r.Header.Get("Accept") != "application/json" {
+			requestErr <- errors.New("unexpected SPD duplicate request shape")
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		_, _ = w.Write([]byte(`[{"id":"84","name":"Example.Release.2026.1080p-GRP","size":4321}]`))
+	}))
+	defer server.Close()
+
+	searcher := &dupeSearcher{
+		cfg: config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+			"SPD": {APIKey: "secret"},
+		}}},
+		http:     server.Client(),
+		endpoint: server.URL,
+	}
+	result := searcher.Search(context.Background(), api.DuplicateSubject{Identity: api.ExternalIdentity{IMDBID: 1234567}})
+	select {
+	case err := <-requestErr:
+		t.Fatal(err)
+	default:
+	}
+	if result.Disposition() != dupe.DispositionResolved {
+		t.Fatalf("unexpected disposition=%v code=%q cause=%v", result.Disposition(), result.Code(), result.Cause())
+	}
+	entries := result.Entries()
+	if len(entries) != 1 || entries[0].ID != "84" || entries[0].Link != "https://speedapp.io/browse/84/" || entries[0].SizeBytes != 4321 {
+		t.Fatalf("unexpected entries: %#v", entries)
+	}
+}
diff --git a/internal/trackers/impl/standalone/spd/profile.go b/internal/trackers/impl/standalone/spd/profile.go
new file mode 100644
index 00000000..78a4dda5
--- /dev/null
+++ b/internal/trackers/impl/standalone/spd/profile.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package spd
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns SPD identity, preparation, dupe, and policy behavior,
+// including the strict requirement for matching TMDB or IMDb metadata.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "SPD",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "spd",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		BannedGroupPolicy: &trackers.BannedGroupPolicy{
+			DefaultEndpoint:   baseURL + "/api/torrent/release-group/blacklist",
+			EndpointPath:      "/api/torrent/release-group/blacklist",
+			RequireAPIKey:     true,
+			RawAPIKeyFallback: true,
+		},
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		AudioPolicy: &trackers.AudioPolicy{
+			AllowedLanguages: []string{"romanian"},
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"ramjet.speedapp.io", "ramjet.speedapp.to", "ramjet.speedappio.org"},
+		},
+	}
+}
+
+// New returns a fresh SPD definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "spd", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/spd/upload.go b/internal/trackers/impl/standalone/spd/upload.go
new file mode 100644
index 00000000..db1a52e5
--- /dev/null
+++ b/internal/trackers/impl/standalone/spd/upload.go
@@ -0,0 +1,472 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package spd
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL   = "https://speedapp.io"
+	uploadURL = baseURL + "/api/upload"
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	payload       map[string]any
+	questionnaire *api.TrackerQuestionnaire
+	blockedReason string
+}
+
+type uploadResponse struct {
+	Status      bool   `json:"status"`
+	Error       bool   `json:"error"`
+	DownloadURL string `json:"downloadUrl"`
+	Torrent     struct {
+		ID any `json:"id"`
+	} `json:"torrent"`
+}
+
+type channelResult struct {
+	ID  any    `json:"id"`
+	Tag string `json:"tag"`
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: SPD %s", state.blockedReason)
+	}
+
+	body, err := json.Marshal(state.payload)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: SPD marshal upload payload: %w", err)
+	}
+	artifactPath, _ := trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "SPD")
+	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, body, apiKey, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	body []byte,
+	apiKey string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, strings.NewReader(string(body)))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: SPD build upload request: %w", err)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Authorization", apiKey)
+
+	result, err := commonhttp.ExecuteUpload(&http.Client{Timeout: 30 * time.Second}, httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "SPD",
+		SuccessStatus: func(status int) bool { return status == http.StatusOK },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: SPD execute upload: %w", err)
+	}
+
+	var decoded uploadResponse
+	if err := json.Unmarshal(result.Body, &decoded); err != nil {
+		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "SPD", "upload_failure", result.Preview, ".txt")
+		if !result.Success {
+			return api.UploadSummary{}, commonhttp.UploadHTTPError("SPD", result.StatusCode, result.Preview)
+		}
+		return api.UploadSummary{}, fmt.Errorf("trackers: SPD decode response: %s", commonhttp.RedactErrorDetail(err.Error()))
+	}
+	if result.Success && decoded.Status && !decoded.Error {
+		torrentID := strings.TrimSpace(fmt.Sprint(decoded.Torrent.ID))
+		if torrentID != "" && artifactPath != "" {
+			if dlErr := downloadTrackerTorrent(ctx, baseURL+"/api/torrent/"+torrentID+"/download", apiKey, artifactPath); dlErr != nil {
+				artifactPath = ""
+			}
+		}
+		return api.UploadSummary{
+			Uploaded: 1,
+			UploadedTorrents: []api.UploadedTorrent{{
+				Tracker:     "SPD",
+				TorrentID:   torrentID,
+				TorrentURL:  baseURL + "/browse/" + torrentID,
+				DownloadURL: baseURL + "/api/torrent/" + torrentID + "/download",
+				TorrentPath: artifactPath,
+			}},
+		}, nil
+	}
+
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "SPD", "upload_failure", result.Preview, ".json")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("SPD", result.StatusCode, result.Preview)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	payload := make(map[string]string, len(state.payload))
+	for key, value := range state.payload {
+		payload[key] = strings.TrimSpace(fmt.Sprint(value))
+	}
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "SPD",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "spd",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          payload,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "file",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, error) {
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: SPD missing api_key")
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+	channelID, blockedReason, questionnaire := resolveChannel(ctx, req)
+	torrentBytes, err := os.ReadFile(torrentPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: SPD read torrent file: %w", err)
+	}
+	releaseName := normalizeName(metautil.FirstNonEmptyTrimmed(req.Meta.ReleaseName, req.Meta.Release.Title, req.Meta.Filename))
+	payload := map[string]any{
+		"bdInfo":           trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, req.Meta),
+		"coverPhotoUrl":    metautil.FirstNonEmptyTrimmed(req.Meta.ProviderMetadata.TMDB.Backdrop, req.Meta.ProviderMetadata.TMDB.Poster),
+		"description":      genresText(req.Meta),
+		"media_info":       commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
+		"name":             releaseName,
+		"nfo":              "",
+		"plot":             metautil.FirstNonEmptyTrimmed(req.Meta.EpisodeOverview, req.Meta.ProviderMetadata.TMDB.Overview),
+		"poster":           metautil.FirstNonEmptyTrimmed(req.Meta.ProviderMetadata.TMDB.Poster),
+		"technicalDetails": description,
+		"screenshots":      combineUniqueScreenshots(assets.MenuImages, assets.Screenshots),
+		"type":             resolveCategory(req.Meta),
+		"url":              imdbURL(req.Meta),
+		"channel":          channelID,
+		"file":             base64.StdEncoding.EncodeToString(torrentBytes),
+	}
+	return uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   releaseName,
+		payload:       payload,
+		questionnaire: questionnaire,
+		blockedReason: blockedReason,
+	}, nil
+}
+
+func resolveChannel(ctx context.Context, req trackers.PreparationInput) (string, string, *api.TrackerQuestionnaire) {
+	answers := standalone.QuestionnaireAnswers(req.Meta, "SPD")
+	input := metautil.FirstNonEmptyTrimmed(strings.TrimSpace(answers["channel"]), strings.TrimSpace(req.TrackerConfig.Channel))
+	if input == "" {
+		return "1", "", nil
+	}
+	if digitsOnly(input) {
+		return input, "", nil
+	}
+	id, err := lookupChannelID(ctx, req.TrackerConfig.APIKey, input)
+	if err == nil && id != "" {
+		return id, "", nil
+	}
+	return "", "answer the channel questionnaire with a valid channel id or tag", &api.TrackerQuestionnaire{
+		Tracker: "SPD",
+		Fields: []api.TrackerQuestionnaireField{{
+			Key:         "channel",
+			Label:       "Channel",
+			Kind:        "text",
+			Value:       input,
+			Placeholder: "1 or channel tag",
+			Required:    true,
+		}},
+	}
+}
+
+func lookupChannelID(ctx context.Context, apiKey string, input string) (string, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+"/api/channel?search="+url.QueryEscape(input), nil)
+	if err != nil {
+		return "", fmt.Errorf("trackers: SPD build channel lookup request: %w", err)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
+	resp, err := (&http.Client{Timeout: 15 * time.Second}).Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("trackers: SPD channel lookup request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	var decoded []channelResult
+	if err := json.Unmarshal(body, &decoded); err != nil {
+		return "", fmt.Errorf("trackers: SPD unmarshal channel lookup response: %w", err)
+	}
+	for _, item := range decoded {
+		if strings.EqualFold(strings.TrimSpace(item.Tag), strings.TrimSpace(input)) {
+			return strings.TrimSpace(fmt.Sprint(item.ID)), nil
+		}
+	}
+	return "", errors.New("channel not found")
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	meta := req.Meta
+	var parts []string
+
+	// Avoid unnecessary descriptions
+	if strings.TrimSpace(assets.Description) != "" || strings.TrimSpace(meta.EpisodeOverview) != "" {
+		// Custom Header
+		if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+			parts = append(parts, header)
+		}
+
+		// Logo
+		if logo, logoSize := descriptionunit3d.ResolveLogo(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig()); logo != "" {
+			parts = append(parts, fmt.Sprintf("[center][img=%d]https://image.tmdb.org/t/p/w300/%s[/img][/center]", logoSize, logo))
+		}
+
+		// TV Details
+		if strings.TrimSpace(meta.EpisodeOverview) != "" {
+			parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
+			parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
+		}
+
+		// User Description
+		if strings.TrimSpace(assets.Description) != "" {
+			parts = append(parts, strings.TrimSpace(assets.Description))
+		}
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// custom user signature
+	if signature := strings.TrimSpace(req.Runtime.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	// Signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("[url=%s]%s[/url]", link, text))
+
+	// Join and finalize
+	description := strings.Join(parts, "\n\n")
+	finalized := finalizeDescription(description)
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "SPD", req.Runtime.DBPath, finalized, req.Logger)
+	}
+
+	return finalized
+}
+
+func resolveCategory(meta api.UploadSubject) string {
+	if _, err := meta.Identity.RequireCategory(); err != nil {
+		return ""
+	}
+	romanian := hasRomanian(meta)
+	if containsWord(genresText(meta), "documentary") || containsWord(keywordsText(meta), "documentary") {
+		if romanian {
+			return "63"
+		}
+		return "9"
+	}
+	if meta.Anime {
+		return "3"
+	}
+	if isTV(meta) {
+		if meta.TVPack {
+			if romanian {
+				return "66"
+			}
+			return "41"
+		}
+		if isSD(meta.Release.Resolution) {
+			if romanian {
+				return "46"
+			}
+			return "45"
+		}
+		if romanian {
+			return "44"
+		}
+		return "43"
+	}
+	if meta.Release.Resolution == "2160p" && !strings.EqualFold(meta.Type, "DISC") {
+		if romanian {
+			return "57"
+		}
+		return "61"
+	}
+	if strings.EqualFold(meta.Type, "DISC") {
+		if romanian {
+			return "24"
+		}
+		return "17"
+	}
+	if romanian {
+		return "29"
+	}
+	return "8"
+}
+
+func hasRomanian(meta api.UploadSubject) bool {
+	for _, value := range append([]string{}, append(meta.AudioLanguages, meta.SubtitleLanguages...)...) {
+		if strings.EqualFold(strings.TrimSpace(value), "romanian") {
+			return true
+		}
+	}
+	for _, code := range meta.ProviderMetadata.TMDB.OriginCountry {
+		if strings.EqualFold(strings.TrimSpace(code), "RO") {
+			return true
+		}
+	}
+	return false
+}
+
+func combineUniqueScreenshots(menu []api.ScreenshotImage, normal []api.ScreenshotImage) []string {
+	var out []string
+	seen := make(map[string]struct{})
+
+	for _, image := range menu {
+		u := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
+		if u != "" && !isSeen(seen, u) {
+			out = append(out, u)
+			seen[u] = struct{}{}
+		}
+	}
+	for _, image := range normal {
+		u := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
+		if u != "" && !isSeen(seen, u) {
+			out = append(out, u)
+			seen[u] = struct{}{}
+		}
+	}
+	return out
+}
+
+func isSeen(seen map[string]struct{}, url string) bool {
+	_, ok := seen[url]
+	return ok
+}
+
+func normalizeName(input string) string {
+	mapper := func(r rune) rune {
+		if r > unicode.MaxASCII {
+			return -1
+		}
+		if strings.ContainsRune(`\/*?"<>|`, r) {
+			return -1
+		}
+		return r
+	}
+	return strings.Join(strings.Fields(strings.Map(mapper, strings.ReplaceAll(input, ":", " -"))), " ")
+}
+
+func imdbURL(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+}
+
+func downloadTrackerTorrent(ctx context.Context, urlValue string, apiKey string, output string) error {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, urlValue, nil)
+	if err != nil {
+		return fmt.Errorf("trackers: SPD build torrent download request: %w", err)
+	}
+	httpReq.Header.Set("Authorization", strings.TrimSpace(apiKey))
+	resp, err := (&http.Client{Timeout: 20 * time.Second}).Do(httpReq)
+	if err != nil {
+		return fmt.Errorf("trackers: SPD torrent download request: %w", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("trackers: SPD read torrent response: %w", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(output), 0o700); err != nil {
+		return fmt.Errorf("trackers: SPD create torrent output dir: %w", err)
+	}
+	if err := os.WriteFile(output, body, 0o600); err != nil {
+		return fmt.Errorf("trackers: SPD write torrent output: %w", err)
+	}
+	return nil
+}
+
+func digitsOnly(value string) bool {
+	_, err := strconv.Atoi(strings.TrimSpace(value))
+	return err == nil
+}
+
+func containsWord(a string, b string) bool {
+	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
+}
+
+func isSD(res string) bool {
+	return strings.HasPrefix(strings.TrimSpace(res), "480") || strings.HasPrefix(strings.TrimSpace(res), "576") ||
+		strings.HasPrefix(strings.TrimSpace(res), "540")
+}
+
+func genresText(meta api.UploadSubject) string {
+	return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Genres, meta.Release.Genre)
+}
+
+func keywordsText(meta api.UploadSubject) string {
+	return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+}
+
+func isTV(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
diff --git a/internal/trackers/impl/standalone/thr/bbcode.go b/internal/trackers/impl/standalone/thr/bbcode.go
new file mode 100644
index 00000000..4f764fa3
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/bbcode.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+var sceneNFOPattern = regexp.MustCompile(`(?is)(\[hide=(?:Scene|FraMeSToR) NFO:\]\[pre\])(.*?)(\[/pre\]\[/hide\])`)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.ConvertNamedSpoilerToNamedHide(value)
+	value = bbcode.ConvertSpoilerToHide(value)
+	value = bbcode.ConvertCodeToPre(value)
+	value = sceneNFOPattern.ReplaceAllString(value, `$1[align=left]$2[/align]$3`)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/thr/definition.go b/internal/trackers/impl/standalone/thr/definition.go
new file mode 100644
index 00000000..baa6526c
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/definition.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, assets)
+	return trackers.DescriptionResult{Group: "thr", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/thr/dupe.go b/internal/trackers/impl/standalone/thr/dupe.go
new file mode 100644
index 00000000..4d12d4f4
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/dupe.go
@@ -0,0 +1,143 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var thrNamePattern = regexp.MustCompile(`overlibImage\('(.+?)','/images`)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if meta.Identity.IMDBID == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing IMDb ID for THR dupe search", nil)
+	}
+	trackerCfg, ok := thrConfig(s.cfg)
+	if !ok || strings.TrimSpace(trackerCfg.Username) == "" || strings.TrimSpace(trackerCfg.Password) == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing THR username/password", nil)
+	}
+	baseURL := thrBaseURL(trackerCfg)
+	sessionCookies, err := thrLogin(ctx, s.http, baseURL, trackerCfg.Username, trackerCfg.Password)
+	if err != nil {
+		return dupe.Failed(dupe.FailureAuthentication, "THR login failed", err)
+	}
+	entries := make([]api.DupeEntry, 0)
+	for page := 0; page <= 10; page++ {
+		params := url.Values{
+			"search":   {fmt.Sprintf("tt%07d", meta.Identity.IMDBID)},
+			"blah":     {"2"},
+			"incldead": {"1"},
+		}
+		if page > 0 {
+			params.Set("page", strconv.Itoa(page))
+		}
+		status, root, err := commonhttp.GetHTML(ctx, s.http, baseURL+"/browse.php", params, sessionCookies)
+		if err != nil || status < http.StatusOK || status >= http.StatusMultipleChoices || root == nil {
+			return dupe.Failed(dupe.FailureRequest, "THR search failed", err)
+		}
+		before := len(entries)
+		for _, link := range commonhttp.FindNodes(root, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.HasPrefix(commonhttp.Attr(node, "href"), "details.php")
+		}) {
+			name := thrName(commonhttp.Attr(link, "onmousemove"))
+			if name == "" {
+				name = strings.TrimSpace(commonhttp.NodeText(link))
+			}
+			if name != "" {
+				entries = append(entries, api.DupeEntry{Name: name, Link: commonhttp.AbsoluteURL(baseURL, commonhttp.Attr(link, "href"))})
+			}
+		}
+		next := commonhttp.FirstNode(root, func(node *xhtml.Node) bool {
+			return node.Type == xhtml.ElementNode && node.Data == "a" && strings.Contains(strings.ToLower(commonhttp.NodeText(node)), "next")
+		})
+		if next == nil || len(entries) == before {
+			break
+		}
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func thrLogin(ctx context.Context, client *http.Client, baseURL, username, password string) ([]*http.Cookie, error) {
+	status, root, err := commonhttp.GetHTML(ctx, client, baseURL+"/login.php", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("fetch login page: %w", err)
+	}
+	if status < http.StatusOK || status >= http.StatusMultipleChoices || root == nil {
+		return nil, fmt.Errorf("fetch login page: status=%d", status)
+	}
+	form := url.Values{}
+	for _, input := range commonhttp.FindNodes(root, func(node *xhtml.Node) bool { return node.Type == xhtml.ElementNode && node.Data == "input" }) {
+		if name := commonhttp.Attr(input, "name"); name != "" {
+			form.Set(name, commonhttp.Attr(input, "value"))
+		}
+	}
+	form.Set("username", strings.TrimSpace(username))
+	form.Set("password", strings.TrimSpace(password))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/takelogin.php", strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: create THR login request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Referer", baseURL+"/login.php")
+	req.Header.Set("User-Agent", "upbrr")
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: submit THR login: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusBadRequest {
+		return nil, fmt.Errorf("status %d", resp.StatusCode)
+	}
+	if len(resp.Cookies()) == 0 {
+		return nil, errors.New("no cookies returned")
+	}
+	return resp.Cookies(), nil
+}
+
+func thrConfig(cfg config.Config) (config.TrackerConfig, bool) {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "THR") {
+			return entry, true
+		}
+	}
+	return config.TrackerConfig{}, false
+}
+func thrBaseURL(_ config.TrackerConfig) string {
+	return "https://www.torrenthr.org"
+}
+func thrName(value string) string {
+	match := thrNamePattern.FindStringSubmatch(strings.TrimSpace(value))
+	if len(match) == 2 {
+		return strings.TrimSpace(match[1])
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/standalone/thr/profile.go b/internal/trackers/impl/standalone/thr/profile.go
new file mode 100644
index 00000000..bd3036d8
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/profile.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns THR identity, preparation, dupe, auth, and policy behavior,
+// including the strict requirement for matching TMDB or IMDb metadata.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "THR",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "thr",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		ImageHostPolicy: &trackers.ImageHostPolicy{
+			AllowedHosts:      []string{"thr"},
+			OwnedHosts:        []string{"thr"},
+			DisableWithoutAPI: true,
+		},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"torrenthr"}},
+		AuthCapability: &api.TrackerAuthCapability{
+			TrackerID:         "THR",
+			DisplayName:       "THR",
+			AuthKind:          "credential_login",
+			SupportsLogin:     true,
+			SupportsAutoLogin: true,
+		},
+		AuthResolver: resolveAuthSession,
+	}
+}
+
+// New returns a fresh THR definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
+
+func resolveAuthSession(ctx context.Context, cfg config.TrackerConfig, _ string, _ api.TrackerAuthLoginRequest) error {
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return errors.New("trackers: THR username/password not configured")
+	}
+	if _, err := LoginSession(ctx, cfg); err != nil {
+		if errors.Is(err, ErrLoginFailed) {
+			return &trackers.AuthResolutionError{
+				Reason:           "login failed",
+				ConfirmedInvalid: true,
+				Err:              err,
+			}
+		}
+		return &trackers.AuthResolutionError{
+			Reason:    "remote login unavailable",
+			Transient: true,
+			Err:       err,
+		}
+	}
+	return nil
+}
diff --git a/internal/trackers/impl/standalone/thr/upload.go b/internal/trackers/impl/standalone/thr/upload.go
new file mode 100644
index 00000000..447e22a2
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/upload.go
@@ -0,0 +1,501 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"golang.org/x/net/html"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL              = "https://www.torrenthr.org"
+	loginPagePath        = "/login.php"
+	takeLoginPath        = "/takelogin.php"
+	uploadURL            = baseURL + "/takeupload.php"
+	sourceFlag           = "[https://www.torrenthr.org] TorrentHR.org"
+	loginResponseMaxSize = 1024 * 1024
+)
+
+// ErrLoginFailed marks a completed THR login exchange that did not produce
+// authenticated index-page evidence.
+var ErrLoginFailed = errors.New("trackers: THR login failed")
+
+var (
+	subtitleMap = map[string]string{
+		"croatian":  "1",
+		"english":   "2",
+		"bosnian":   "3",
+		"serbian":   "4",
+		"slovenian": "5",
+	}
+	idPattern = regexp.MustCompile(`id=(\d+)`)
+)
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	questionnaire *api.TrackerQuestionnaire
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, client, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{
+		{
+			FieldName: "tfile",
+			FileName:  state.releaseName + ".torrent",
+			Path:      state.torrentPath,
+		},
+		{
+			FieldName: "nfo",
+			FileName:  "MEDIAINFO.txt",
+			Content:   []byte(commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath))),
+		},
+	})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "THR")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, client, body, contentType, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	client *http.Client,
+	body []byte,
+	contentType string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: THR build upload request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: THR upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+
+	finalURL := ""
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL.String()
+	}
+	if strings.Contains(finalURL, "uploaded=1") {
+		torrentID := ""
+		if match := idPattern.FindStringSubmatch(finalURL); len(match) == 2 {
+			torrentID = match[1]
+		}
+		if announceURL != "" {
+			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, finalURL, sourceFlag); err != nil {
+				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+			}
+		}
+		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+			Tracker:     "THR",
+			TorrentID:   torrentID,
+			TorrentURL:  finalURL,
+			DownloadURL: finalURL,
+			TorrentPath: artifactPath,
+		}}}, nil
+	}
+
+	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "THR", "upload_failure", bodyBytes, ".html")
+	return api.UploadSummary{}, commonhttp.UploadHTTPError("THR", resp.StatusCode, bodyBytes)
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "THR",
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "thr",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "tfile",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, *http.Client, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, assets)
+	releaseName := resolveName(req.Meta)
+	if override := strings.TrimSpace(standalone.QuestionnaireAnswers(req.Meta, "THR")["name_override"]); override != "" {
+		releaseName = override
+	}
+	fields := map[string]string{
+		"name":  releaseName,
+		"descr": description,
+		"type":  resolveCategory(req.Meta),
+		"url":   imdbURL(req.Meta),
+		"tube":  strings.TrimSpace(req.Meta.ProviderMetadata.TMDB.YouTube),
+	}
+	for idx, sub := range resolveSubtitles(req.Meta) {
+		fields["subs["+strconv.Itoa(idx)+"]"] = sub
+	}
+	client, err := login(ctx, req.TrackerConfig)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	return uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   releaseName,
+		fields:        fields,
+		questionnaire: buildQuestionnaire(req.Meta),
+	}, client, nil
+}
+
+func login(ctx context.Context, cfg config.TrackerConfig) (*http.Client, error) {
+	return LoginSession(ctx, cfg)
+}
+
+// LoginSession performs THR's browser-style login flow. It first loads the
+// login page into a cookie jar, carries all non-empty hidden form fields into
+// the credential POST, follows the redirect to the authenticated page, and
+// returns the live client only after the final index page contains a structured
+// logout link on the same scheme and hostname.
+func LoginSession(ctx context.Context, cfg config.TrackerConfig) (*http.Client, error) {
+	return loginSessionAt(ctx, cfg, baseURL)
+}
+
+func loginSessionAt(ctx context.Context, cfg config.TrackerConfig, endpoint string) (*http.Client, error) {
+	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
+		return nil, errors.New("trackers: THR missing username/password")
+	}
+	resolvedBaseURL := strings.TrimRight(strings.TrimSpace(endpoint), "/")
+	if resolvedBaseURL == "" {
+		resolvedBaseURL = baseURL
+	}
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: THR create login cookie jar: %w", err)
+	}
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+	loginPageURL := resolvedBaseURL + loginPagePath
+	pageReq, err := http.NewRequestWithContext(ctx, http.MethodGet, loginPageURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: THR build login page request: %w", err)
+	}
+	pageReq.Header.Set("User-Agent", "upbrr")
+	pageResp, err := client.Do(pageReq)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: THR login page request: %w", err)
+	}
+	pageBody, readErr := readLoginResponse(pageResp)
+	pageResp.Body.Close()
+	if readErr != nil {
+		return nil, fmt.Errorf("trackers: THR read login page: %w", readErr)
+	}
+	if pageResp.StatusCode < 200 || pageResp.StatusCode >= 300 {
+		return nil, fmt.Errorf("trackers: THR login page failed status=%d", pageResp.StatusCode)
+	}
+
+	form := hiddenLoginFields(pageBody)
+	form.Set("username", strings.TrimSpace(cfg.Username))
+	form.Set("password", strings.TrimSpace(cfg.Password))
+	form.Set("ssl", "yes")
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, resolvedBaseURL+takeLoginPath, strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, fmt.Errorf("trackers: THR build login request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "upbrr")
+	req.Header.Set("Referer", loginPageURL)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: THR login request: %w", err)
+	}
+	body, readErr := readLoginResponse(resp)
+	resp.Body.Close()
+	if readErr != nil {
+		return nil, fmt.Errorf("trackers: THR read login response: %w", readErr)
+	}
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {
+		return nil, fmt.Errorf("%w: status=%d", ErrLoginFailed, resp.StatusCode)
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("trackers: THR login response status=%d", resp.StatusCode)
+	}
+	var finalURL *url.URL
+	if resp.Request != nil && resp.Request.URL != nil {
+		finalURL = resp.Request.URL
+	}
+	if !isAuthenticatedLoginPage(finalURL, body) {
+		return nil, fmt.Errorf("%w: authenticated marker not found", ErrLoginFailed)
+	}
+	return client, nil
+}
+
+// isAuthenticatedLoginPage requires THR's post-login index path and a parsed
+// logout anchor on the same scheme and hostname. Path fragments or incidental
+// response text cannot independently prove authentication.
+func isAuthenticatedLoginPage(finalURL *url.URL, body []byte) bool {
+	if finalURL == nil || !strings.EqualFold(strings.Trim(finalURL.Path, "/"), "index.php") {
+		return false
+	}
+	tokenizer := html.NewTokenizer(bytes.NewReader(body))
+	for {
+		switch tokenizer.Next() {
+		case html.ErrorToken:
+			return false
+		case html.StartTagToken, html.SelfClosingTagToken:
+			token := tokenizer.Token()
+			if !strings.EqualFold(token.Data, "a") {
+				continue
+			}
+			for _, attr := range token.Attr {
+				if !strings.EqualFold(attr.Key, "href") {
+					continue
+				}
+				candidate, err := url.Parse(strings.TrimSpace(attr.Val))
+				if err != nil || !strings.EqualFold(strings.TrimPrefix(candidate.Path, "/"), "logout.php") {
+					continue
+				}
+				if candidate.Scheme != "" && !strings.EqualFold(candidate.Scheme, finalURL.Scheme) {
+					continue
+				}
+				if candidate.Host != "" && !strings.EqualFold(candidate.Hostname(), finalURL.Hostname()) {
+					continue
+				}
+				return true
+			}
+		case html.TextToken, html.EndTagToken, html.CommentToken, html.DoctypeToken:
+			continue
+		}
+	}
+}
+
+func readLoginResponse(resp *http.Response) ([]byte, error) {
+	if resp == nil || resp.Body == nil {
+		return nil, errors.New("empty response")
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, loginResponseMaxSize+1))
+	if err != nil {
+		return nil, fmt.Errorf("read response body: %w", err)
+	}
+	if len(body) > loginResponseMaxSize {
+		return nil, fmt.Errorf("response exceeds %d bytes", loginResponseMaxSize)
+	}
+	return body, nil
+}
+
+func hiddenLoginFields(body []byte) url.Values {
+	fields := url.Values{}
+	tokenizer := html.NewTokenizer(bytes.NewReader(body))
+	for {
+		switch tokenizer.Next() {
+		case html.ErrorToken:
+			return fields
+		case html.StartTagToken, html.SelfClosingTagToken:
+			token := tokenizer.Token()
+			if !strings.EqualFold(token.Data, "input") {
+				continue
+			}
+			name, value, inputType := "", "", ""
+			for _, attr := range token.Attr {
+				switch {
+				case strings.EqualFold(attr.Key, "name"):
+					name = strings.TrimSpace(attr.Val)
+				case strings.EqualFold(attr.Key, "value"):
+					value = attr.Val
+				case strings.EqualFold(attr.Key, "type"):
+					inputType = strings.TrimSpace(attr.Val)
+				}
+			}
+			if strings.EqualFold(inputType, "hidden") && name != "" && value != "" {
+				fields.Set(name, value)
+			}
+		case html.TextToken, html.EndTagToken, html.CommentToken, html.DoctypeToken:
+			continue
+		}
+	}
+}
+
+func buildDescription(meta api.UploadSubject, assets trackers.DescriptionAssets) string {
+	parts := []string{
+		"[quote=Info]",
+		"Name: " + strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)),
+		"",
+		"Overview: " + strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.EpisodeOverview, meta.ProviderMetadata.TMDB.Overview)),
+		"",
+		metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.Release.Source) + " / " + strings.TrimSpace(meta.Type),
+		"",
+		"Category: " + categoryName(meta),
+	}
+	if tmdb := meta.Identity.TMDBID; tmdb > 0 {
+		parts = append(parts, fmt.Sprintf("TMDB: https://www.themoviedb.org/%s/%d", strings.ToLower(categoryName(meta)), tmdb))
+	}
+	if imdb := imdbURL(meta); imdb != "" {
+		parts = append(parts, "IMDb: "+imdb)
+	}
+	parts = append(parts, "[/quote]")
+	if base := strings.TrimSpace(assets.Description); base != "" {
+		parts = append(parts, base)
+	}
+	for _, image := range assets.Screenshots {
+		raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
+		if raw != "" {
+			parts = append(parts, "[img]"+raw+"[/img]")
+		}
+	}
+	parts = append(parts, `[size=2][url=https://www.torrenthr.org/forums.php?action=viewtopic&topicid=8977]upbrr[/url][/size]`)
+	return finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n")))
+}
+
+func buildQuestionnaire(meta api.UploadSubject) *api.TrackerQuestionnaire {
+	return &api.TrackerQuestionnaire{
+		Tracker: "THR",
+		Fields: []api.TrackerQuestionnaireField{{
+			Key:      "name_override",
+			Label:    "Upload Name",
+			Kind:     "text",
+			Value:    resolveName(meta),
+			Required: true,
+		}},
+	}
+}
+
+func resolveName(meta api.UploadSubject) string {
+	base := strings.ReplaceAll(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename), "DD+", "DDP")
+	return regexp.MustCompile(`[^0-9a-zA-Z. '\-\[\]]+`).ReplaceAllString(base, " ")
+}
+
+func resolveCategory(meta api.UploadSubject) string {
+	if _, err := meta.Identity.RequireCategory(); err != nil {
+		return ""
+	}
+	if containsWord(genresText(meta), "documentary") || containsWord(keywordsText(meta), "documentary") {
+		return "12"
+	}
+	switch categoryName(meta) {
+	case "MOVIE":
+		if strings.EqualFold(meta.DiscType, "BDMV") {
+			return "40"
+		}
+		if strings.EqualFold(meta.DiscType, "DVD") || strings.EqualFold(meta.DiscType, "HDDVD") {
+			return "14"
+		}
+		if isSD(meta.Release.Resolution) {
+			return "4"
+		}
+		return "17"
+	case "TV":
+		if isSD(meta.Release.Resolution) {
+			return "7"
+		}
+		return "34"
+	default:
+		if meta.Anime {
+			return "31"
+		}
+	}
+	return ""
+}
+
+func resolveSubtitles(meta api.UploadSubject) []string {
+	result := make([]string, 0, len(meta.SubtitleLanguages))
+	seen := map[string]struct{}{}
+	for _, lang := range meta.SubtitleLanguages {
+		id := subtitleMap[strings.ToLower(strings.TrimSpace(lang))]
+		if id == "" {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		result = append(result, id)
+	}
+	return result
+}
+
+func imdbURL(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.Identity.IMDBID)
+}
+
+func isSD(res string) bool {
+	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
+}
+
+func containsWord(a string, b string) bool {
+	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
+}
+
+func categoryName(meta api.UploadSubject) string {
+	category, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return ""
+	}
+	if category == api.CanonicalCategoryTV {
+		return "TV"
+	}
+	return "MOVIE"
+}
+
+func genresText(meta api.UploadSubject) string {
+	return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Genres, meta.Release.Genre)
+}
+
+func keywordsText(meta api.UploadSubject) string {
+	return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+}
diff --git a/internal/trackers/impl/standalone/thr/upload_test.go b/internal/trackers/impl/standalone/thr/upload_test.go
new file mode 100644
index 00000000..9216e163
--- /dev/null
+++ b/internal/trackers/impl/standalone/thr/upload_test.go
@@ -0,0 +1,164 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package thr
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+)
+
+func TestLoginSessionBootstrapsHiddenFieldsAndFollowsRedirect(t *testing.T) {
+	t.Parallel()
+
+	handlerErr := make(chan error, 8)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case loginPagePath:
+			http.SetCookie(w, &http.Cookie{
+				Name:  "bootstrap",
+				Value: "ready",
+				Path:  "/",
+			})
+			_, _ = w.Write([]byte(`<form><input type="hidden" name="token" value="login-token"><input type="hidden" name="blank" value=""></form>`))
+		case takeLoginPath:
+			if err := r.ParseForm(); err != nil {
+				handlerErr <- fmt.Errorf("parse login form: %w", err)
+				return
+			}
+			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" || r.FormValue("ssl") != "yes" || r.FormValue("token") != "login-token" {
+				handlerErr <- errors.New("login form did not preserve credentials and hidden fields")
+			}
+			if r.Form.Has("blank") {
+				handlerErr <- errors.New("empty hidden field should not be submitted")
+			}
+			if cookie, err := r.Cookie("bootstrap"); err != nil || cookie.Value != "ready" {
+				handlerErr <- errors.New("login bootstrap cookie missing")
+			}
+			if r.Referer() != "http://"+r.Host+loginPagePath {
+				handlerErr <- fmt.Errorf("unexpected login referer %q", r.Referer())
+			}
+			http.SetCookie(w, &http.Cookie{
+				Name:  "session",
+				Value: "authenticated",
+				Path:  "/",
+			})
+			http.Redirect(w, r, "/index.php", http.StatusFound)
+		case "/index.php":
+			if cookie, err := r.Cookie("session"); err != nil || cookie.Value != "authenticated" {
+				_, _ = w.Write([]byte(`<form action="/login.php"></form>`))
+				return
+			}
+			_, _ = w.Write([]byte(`<a href="logout.php">Logout</a>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := loginSessionAt(context.Background(), config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, server.URL)
+	if err != nil {
+		t.Fatalf("LoginSession: %v", err)
+	}
+	if client == nil || client.Jar == nil {
+		t.Fatal("expected authenticated client with cookie jar")
+	}
+	close(handlerErr)
+	for err := range handlerErr {
+		t.Error(err)
+	}
+}
+
+func TestLoginSessionRejectsRedirectWithoutAuthenticatedMarker(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case loginPagePath:
+			_, _ = w.Write([]byte(`<input type="hidden" name="token" value="login-token">`))
+		case takeLoginPath:
+			http.Redirect(w, r, "/home.php", http.StatusFound)
+		case "/home.php":
+			_, _ = w.Write([]byte(`<form action="/login.php"><input name="username"></form>`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := loginSessionAt(context.Background(), config.TrackerConfig{
+		Username: "user",
+		Password: "pass",
+	}, server.URL)
+	if !errors.Is(err, ErrLoginFailed) {
+		t.Fatalf("expected ErrLoginFailed, got %v", err)
+	}
+	if client != nil {
+		t.Fatal("expected rejected login to return no client")
+	}
+}
+
+func TestLoginSessionRejectsWeakAuthenticatedMarkers(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		finalPath string
+		body      string
+	}{
+		{
+			name:      "public index path without logout anchor",
+			finalPath: "/index.php",
+			body:      `<form action="/login.php"><input name="username"></form>`,
+		},
+		{
+			name:      "incidental logout text off index",
+			finalPath: "/help.php",
+			body:      `<p>Read the logout.php troubleshooting guide.</p>`,
+		},
+		{
+			name:      "logout anchor off index",
+			finalPath: "/home.php",
+			body:      `<a href="/logout.php">Logout</a>`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				switch r.URL.Path {
+				case loginPagePath:
+					_, _ = w.Write([]byte(`<input type="hidden" name="token" value="login-token">`))
+				case takeLoginPath:
+					http.Redirect(w, r, tt.finalPath, http.StatusFound)
+				case tt.finalPath:
+					_, _ = w.Write([]byte(tt.body))
+				default:
+					http.NotFound(w, r)
+				}
+			}))
+			t.Cleanup(server.Close)
+
+			client, err := loginSessionAt(context.Background(), config.TrackerConfig{
+				Username: "user",
+				Password: "pass",
+			}, server.URL)
+			if !errors.Is(err, ErrLoginFailed) {
+				t.Fatalf("expected ErrLoginFailed, got %v", err)
+			}
+			if client != nil {
+				t.Fatal("expected weak marker login to return no client")
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/standalone/tl/bbcode.go b/internal/trackers/impl/standalone/tl/bbcode.go
new file mode 100644
index 00000000..6011f6d4
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/bbcode.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+var (
+	codeTagPattern  = regexp.MustCompile(`(?is)\[c\](.*?)\[/c\]`)
+	imageTagPattern = regexp.MustCompile(`(?i)\[img=[\d"x]+\]`)
+	listItemPattern = regexp.MustCompile(`(?i)\[\*\]`)
+	hrPattern       = regexp.MustCompile(`(?i)\[hr\]`)
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = strings.ReplaceAll(value, "[center]", "<center>")
+	value = strings.ReplaceAll(value, "[/center]", "</center>")
+	value = listItemPattern.ReplaceAllString(value, "\n[*]")
+	value = codeTagPattern.ReplaceAllString(value, "[code]$1[/code]")
+	value = hrPattern.ReplaceAllString(value, "---")
+	value = imageTagPattern.ReplaceAllString(value, "[img]")
+	value = strings.NewReplacer("[*] ", "• ", "[*]", "• ", "[note]", "Note: ", "[/note]", "", "[code]", "", "[/code]", "").Replace(value)
+	value = bbcode.RemoveList(value)
+	value = bbcode.ConvertComparisonToCentered(value, 1000)
+	value = bbcode.RemoveSpoiler(value)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/tl/bbcode_test.go b/internal/trackers/impl/standalone/tl/bbcode_test.go
new file mode 100644
index 00000000..8455229e
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/bbcode_test.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFinalizeDescription(t *testing.T) {
+	input := "[center]x[/center]\n[comparison=A, B]https://img.example/a.png https://img.example/b.png[/comparison]\n[note]n[/note]"
+	got := finalizeDescription(input)
+	if !strings.Contains(got, "<center>x</center>") {
+		t.Fatalf("expected center tags converted for TL, got %q", got)
+	}
+	if !strings.Contains(got, "Note: n") {
+		t.Fatalf("expected note tag rewritten for TL, got %q", got)
+	}
+	if strings.Contains(got, "[comparison=") {
+		t.Fatalf("expected comparison converted for TL, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/standalone/tl/definition.go b/internal/trackers/impl/standalone/tl/definition.go
new file mode 100644
index 00000000..0bd495cd
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/definition.go
@@ -0,0 +1,25 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(trackers.PreparationInput{
+		Tracker:       req.Tracker,
+		Meta:          req.Meta,
+		TrackerConfig: req.TrackerConfig,
+		Runtime:       req.Runtime,
+		Logger:        req.Logger,
+	}, assets)
+	return trackers.DescriptionResult{Group: "tl", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/tl/description_assets_test.go b/internal/trackers/impl/standalone/tl/description_assets_test.go
new file mode 100644
index 00000000..270cc1e9
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/description_assets_test.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
+	t.Parallel()
+
+	assets := trackers.DescriptionAssets{
+		Description: "Body token",
+		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
+		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
+	}
+	result, err := prepareDescription(context.Background(), trackers.PreparationInput{
+		Tracker: "TL",
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{Description: config.DescriptionSettingsConfig{
+			DiscMenuHeader:   "Disc menu token",
+			ScreenshotHeader: "Screenshots token",
+		}}),
+		Assets: &assets,
+	})
+	if err != nil {
+		t.Fatalf("build description: %v", err)
+	}
+	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
+
+	final := trackers.DescriptionAssets{
+		Description: " Authoritative final token ",
+		Final:       true,
+		MenuImages:  assets.MenuImages,
+	}
+	result, err = prepareDescription(context.Background(), trackers.PreparationInput{Tracker: "TL", Assets: &final})
+	if err != nil {
+		t.Fatalf("build final description: %v", err)
+	}
+	if result.Description != "Authoritative final token" {
+		t.Fatalf("final description = %q", result.Description)
+	}
+}
+
+func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
+	t.Helper()
+	previous := -1
+	for _, token := range tokens {
+		position := strings.Index(description, token)
+		if position <= previous {
+			t.Fatalf("description tokens out of order at %q: %q", token, description)
+		}
+		previous = position
+	}
+}
diff --git a/internal/trackers/impl/standalone/tl/dupe.go b/internal/trackers/impl/standalone/tl/dupe.go
new file mode 100644
index 00000000..acf8bd98
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/dupe.go
@@ -0,0 +1,115 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	cfg  config.Config
+	http *http.Client
+}
+
+// newDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func newDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{cfg: cfg, http: httpClient}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	if !tlConfigured(s.cfg) {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing passkey for tracker", nil)
+	}
+	query := strings.TrimSpace(meta.Release.Title)
+	if query == "" {
+		query = strings.TrimSpace(meta.ReleaseName)
+	}
+	if query == "" {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing title for TL dupe search", nil)
+	}
+	endpoint := "https://www.torrentleech.org/torrents/browse/list/query/" + url.PathEscape(query)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "TL search failed", err)
+	}
+	req.Header.Set("Accept", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "TL search failed", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return dupe.Failed(dupe.FailureResponseStatus, "TL search failed", nil)
+	}
+	var payload struct {
+		Torrents []map[string]any `json:"torrentList"`
+	}
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	if err := decoder.Decode(&payload); err != nil {
+		return dupe.Failed(dupe.FailureResponseParse, "TL search failed", err)
+	}
+	entries := make([]api.DupeEntry, 0, len(payload.Torrents))
+	for _, item := range payload.Torrents {
+		id := tlString(item["fid"])
+		entry := api.DupeEntry{
+			Name: tlString(item["name"]),
+			ID:   id,
+			Link: "https://www.torrentleech.org/torrent/" + id,
+		}
+		if size := tlInt64(item["size"]); size > 0 {
+			entry.SizeKnown, entry.SizeBytes = true, size
+		}
+		entries = append(entries, entry)
+	}
+	return dupe.Resolved(entries, nil)
+}
+
+func tlConfigured(cfg config.Config) bool {
+	for name, entry := range cfg.Trackers.Trackers {
+		if strings.EqualFold(strings.TrimSpace(name), "TL") {
+			return strings.TrimSpace(entry.Passkey) != ""
+		}
+	}
+	return false
+}
+
+func tlString(value any) string {
+	switch typed := value.(type) {
+	case string:
+		return strings.TrimSpace(typed)
+	case json.Number:
+		return typed.String()
+	default:
+		return ""
+	}
+}
+
+func tlInt64(value any) int64 {
+	switch typed := value.(type) {
+	case json.Number:
+		parsed, _ := typed.Int64()
+		return parsed
+	case float64:
+		return int64(typed)
+	case string:
+		parsed, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+		return parsed
+	default:
+		return 0
+	}
+}
diff --git a/internal/trackers/impl/standalone/tl/profile.go b/internal/trackers/impl/standalone/tl/profile.go
new file mode 100644
index 00000000..df551cb1
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/profile.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns TL identity, preparation, dupe, auth, and policy behavior,
+// including the strict requirement for matching TMDB or IMDb metadata.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "TL",
+		BaseURL:             baseURL,
+		DescriptionGroup:    "tl",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy: &trackers.UploadArtifactPolicy{Source: sourceFlag},
+		AudioPolicy:          &trackers.AudioPolicy{AllowBloat: true},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"tracker.tleechreload", "tracker.torrentleech"},
+		},
+		AuthCapability: standalone.CookieAuthCapability("TL"),
+	}
+}
+
+// New returns a fresh TL definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/tl/upload.go b/internal/trackers/impl/standalone/tl/upload.go
new file mode 100644
index 00000000..33fdb844
--- /dev/null
+++ b/internal/trackers/impl/standalone/tl/upload.go
@@ -0,0 +1,490 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tl
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/cookies"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL       = "https://www.torrentleech.org"
+	apiUploadURL  = baseURL + "/torrents/upload/apiupload"
+	httpUploadURL = baseURL + "/torrents/upload/"
+	torrentURL    = baseURL + "/torrent/"
+	sourceFlag    = "TorrentLeech.org"
+)
+
+type uploadState struct {
+	torrentPath string
+	description string
+	releaseName string
+	fields      map[string]string
+	files       []commonhttp.FileField
+	endpoint    string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, client, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, state.files)
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	announces := announceList(req.TrackerConfig)
+	artifactPath := ""
+	if len(announces) > 0 {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "TL")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, client, body, contentType, announces, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	client *http.Client,
+	body []byte,
+	contentType string,
+	announces []string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.endpoint, bytes.NewReader(body))
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TL build upload request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "upbrr")
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TL upload request: %w", err)
+	}
+	defer resp.Body.Close()
+	successCandidate := resp.StatusCode == http.StatusFound || (req.TrackerConfig.APIUpload && resp.StatusCode >= 200 && resp.StatusCode < 300)
+	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, successCandidate, commonhttp.DefaultResponsePreviewBytes)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TL read upload response: %w", err)
+	}
+
+	torrentID := ""
+	if req.TrackerConfig.APIUpload {
+		text := strings.TrimSpace(string(responseBody))
+		if _, err := strconv.Atoi(text); err == nil {
+			torrentID = text
+		}
+	} else if resp.StatusCode == http.StatusFound {
+		torrentID = strings.TrimPrefix(strings.TrimSpace(resp.Header.Get("Location")), "/successfulupload?torrentID=")
+	}
+	if torrentID == "" {
+		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "TL", "upload_failure", responsePreview, ".html")
+		return api.UploadSummary{}, commonhttp.UploadHTTPError("TL", resp.StatusCode, responsePreview)
+	}
+
+	urlValue := torrentURL + torrentID
+	if len(announces) > 0 {
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announces[0], urlValue, sourceFlag); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+		Tracker:     "TL",
+		TorrentID:   torrentID,
+		TorrentURL:  urlValue,
+		DownloadURL: urlValue,
+		TorrentPath: artifactPath,
+	}}}, nil
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "TL",
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "tl",
+		Description:      state.description,
+		Endpoint:         state.endpoint,
+		Payload:          state.fields,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(ctx context.Context, req trackers.PreparationInput) (uploadState, *http.Client, error) {
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req, assets)
+
+	releaseName := resolveName(req.Meta)
+	state := uploadState{
+		torrentPath: torrentPath,
+		description: description,
+		releaseName: releaseName,
+	}
+
+	if req.TrackerConfig.APIUpload {
+		state.endpoint = apiUploadURL
+		state.fields = map[string]string{
+			"announcekey": announceKey(req.TrackerConfig),
+			"category":    resolveCategory(req.Meta),
+			"description": description,
+			"name":        releaseName,
+			"nonscene":    boolWord(!req.Meta.Scene, "on", "off"),
+		}
+		category, _ := req.Meta.Identity.RequireCategory()
+		switch {
+		case req.Meta.Anime && req.Meta.Identity.MALID > 0:
+			state.fields["animeid"] = tlAnimeIDURL(req.Meta.Identity.MALID)
+		case category == api.CanonicalCategoryMovie && req.Meta.Identity.IMDBID > 0:
+			state.fields["imdb"] = fmt.Sprintf("tt%07d", req.Meta.Identity.IMDBID)
+		case category == api.CanonicalCategoryTV:
+			state.fields["tvmazeid"] = strconv.Itoa(req.Meta.Identity.TVmazeID)
+			if req.Meta.TVPack {
+				state.fields["tvmazetype"] = "true"
+			}
+		}
+		if req.TrackerConfig.Anon {
+			state.fields["is_anonymous_upload"] = "on"
+		}
+		state.files = []commonhttp.FileField{{
+			FieldName: "torrent",
+			FileName:  releaseName + ".torrent",
+			Path:      torrentPath,
+		}}
+		return state, &http.Client{Timeout: 30 * time.Second}, nil
+	}
+
+	state.endpoint = httpUploadURL
+	state.fields = map[string]string{
+		"name":                releaseName,
+		"category":            resolveCategory(req.Meta),
+		"nonscene":            boolWord(!req.Meta.Scene, "on", "off"),
+		"imdbURL":             imdbURL(req.Meta),
+		"tvMazeURL":           tvmazeURL(req.Meta),
+		"igdbURL":             "",
+		"torrentNFO":          "0",
+		"torrentDesc":         "1",
+		"nfotextbox":          "",
+		"torrentComment":      "0",
+		"uploaderComments":    "",
+		"is_anonymous_upload": boolWord(req.TrackerConfig.Anon, "on", "off"),
+	}
+	if req.TrackerConfig.ImgRehost {
+		for idx, shot := range screenshots(assets.Screenshots) {
+			state.fields["screenshots["+strconv.Itoa(idx)+"]"] = shot
+		}
+	}
+	state.files = []commonhttp.FileField{
+		{
+			FieldName: "torrent",
+			FileName:  "torrent.torrent",
+			Path:      torrentPath,
+		},
+		{
+			FieldName: "nfo",
+			FileName:  "description.txt",
+			Content:   []byte(description),
+		},
+	}
+	client, err := cookieClient(ctx, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, nil, err
+	}
+	return state, client, nil
+}
+
+// tlAnimeIDURL formats TorrentLeech's animeid field. TL names the value as an
+// AniList URL, while upbrr's canonical MALID carries the same anime identifier
+// for this tracker payload.
+func tlAnimeIDURL(malID int) string {
+	return fmt.Sprintf("https://anilist.co/anime/%d", malID)
+}
+
+func cookieClient(ctx context.Context, dbPath string) (*http.Client, error) {
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("trackers: TL create cookie jar: %w", err)
+	}
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+		Jar:     jar,
+		CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+	cookies, err := loadCookies(ctx, dbPath)
+	if err != nil {
+		return nil, err
+	}
+	target, _ := url.Parse(baseURL)
+	jar.SetCookies(target, cookies)
+	return client, nil
+}
+
+func buildDescription(req trackers.PreparationInput, assets trackers.DescriptionAssets) string {
+	if assets.Final {
+		return strings.TrimSpace(assets.Description)
+	}
+	meta := req.Meta
+	parts := make([]string, 0, 8)
+
+	// Custom Header
+	if header := strings.TrimSpace(req.Runtime.Description.CustomDescriptionHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Logo
+	if req.Runtime.Description.AddLogo {
+		if logo, _ := descriptionunit3d.ResolveLogo(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig()); logo != "" {
+			parts = append(parts, `<center><img src="`+logo+`" style="max-width: 300px;"></center>`)
+		}
+	}
+
+	// TV Episode details
+	if strings.TrimSpace(meta.EpisodeOverview) != "" {
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
+		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
+	}
+
+	// File information (BDInfo or MediaInfo)
+	if media := trackers.ReadBDinfoOrMediaInfo(req.Runtime.DBPath, meta); media != "" {
+		parts = append(parts, media)
+	}
+
+	// User description
+	if strings.TrimSpace(assets.Description) != "" {
+		parts = append(parts, strings.TrimSpace(assets.Description))
+	}
+
+	// menu
+	if len(assets.MenuImages) > 0 {
+		// header
+		if header := strings.TrimSpace(req.Runtime.Description.DiscMenuHeader); header != "" {
+			parts = append(parts, header)
+		}
+		// images
+		if shots := screenshotBlock(assets.MenuImages); shots != "" {
+			parts = append(parts, shots)
+		}
+	}
+	// Screenshot Header
+	if header := strings.TrimSpace(req.Runtime.Description.ScreenshotHeader); header != "" {
+		parts = append(parts, header)
+	}
+
+	// Tonemapped Header
+	if tonemapHeader := strings.TrimSpace(
+		req.Runtime.Description.TonemappedHeader,
+	); tonemapHeader != "" &&
+		descriptionunit3d.ShouldIncludeTonemappedHeader(api.NewDescriptionSubject(meta), req.Runtime.DescriptionConfig(), assets.Screenshots) {
+		parts = append(parts, tonemapHeader)
+	}
+
+	// screenshots
+	if shots := screenshotBlock(assets.Screenshots); shots != "" {
+		parts = append(parts, shots)
+	}
+
+	// custom user signature
+	if signature := strings.TrimSpace(req.Runtime.Description.CustomSignature); signature != "" {
+		parts = append(parts, signature)
+	}
+
+	// upbrr signature
+	link, text := descriptionunit3d.UppbrrSignatureLink()
+	parts = append(parts, fmt.Sprintf("<div style=\"text-align: right; font-size: 11px;\"><a href=\"%s\">%s</a></div>", link, text))
+
+	// finalize description
+	finalDescription := finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+
+	// Explicit dry runs retain the local diagnostic description artifact.
+	if req.Intent == trackers.PreparationIntentDryRun {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(meta), "TL", req.Runtime.DBPath, finalDescription, req.Logger)
+	}
+
+	return finalDescription
+}
+
+func resolveCategory(meta api.UploadSubject) string {
+	if _, err := meta.Identity.RequireCategory(); err != nil {
+		return ""
+	}
+	if meta.Anime {
+		return "34"
+	}
+	if !isTV(meta) {
+		if meta.ProviderMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "en") {
+			return "36"
+		}
+		if containsWord(genresText(meta), "Documentary") {
+			return "29"
+		}
+		if meta.Release.Resolution == "2160p" {
+			return "47"
+		}
+		if strings.EqualFold(meta.DiscType, "BDMV") || strings.EqualFold(meta.Type, "REMUX") && strings.EqualFold(meta.Source, "BluRay") {
+			return "13"
+		}
+		if strings.EqualFold(meta.Type, "ENCODE") && strings.EqualFold(meta.Source, "BluRay") {
+			return "14"
+		}
+		if strings.EqualFold(meta.DiscType, "DVD") || strings.Contains(strings.ToUpper(meta.Source), "DVD") && strings.EqualFold(meta.Type, "REMUX") {
+			return "12"
+		}
+		if strings.Contains(strings.ToUpper(meta.Source), "DVD") || strings.EqualFold(meta.Type, "DVDRIP") {
+			return "11"
+		}
+		if strings.Contains(strings.ToUpper(meta.Type), "WEB") {
+			return "37"
+		}
+		if strings.EqualFold(meta.Type, "HDTV") {
+			return "43"
+		}
+	}
+	if isTV(meta) && meta.ProviderMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "en") {
+		return "44"
+	}
+	if meta.TVPack {
+		return "27"
+	}
+	if isSD(meta.Release.Resolution) {
+		return "26"
+	}
+	return "32"
+}
+
+func resolveName(meta api.UploadSubject) string {
+	if strings.TrimSpace(meta.SceneName) != "" {
+		return strings.TrimSpace(meta.SceneName)
+	}
+	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename))
+}
+
+func announceKey(cfg config.TrackerConfig) string {
+	return strings.TrimSpace(cfg.Passkey)
+}
+
+func announceList(cfg config.TrackerConfig) []string {
+	passkey := strings.TrimSpace(cfg.Passkey)
+	if passkey == "" {
+		return nil
+	}
+	return []string{
+		"https://tracker.torrentleech.org/a/" + passkey + "/announce",
+		"https://tracker.tleechreload.org/a/" + passkey + "/announce",
+	}
+}
+
+func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
+	values, err := cookies.LoadTrackerHTTPCookies(ctx, dbPath, "TL", "torrentleech.org")
+	if err != nil {
+		return values, fmt.Errorf("trackers: TL load cookies: %w", err)
+	}
+	return values, nil
+}
+
+func imdbURL(meta api.UploadSubject) string {
+	if meta.Identity.IMDBID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.Identity.IMDBID)
+}
+
+func tvmazeURL(meta api.UploadSubject) string {
+	if meta.Identity.TVmazeID <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("https://www.tvmaze.com/shows/%d", meta.Identity.TVmazeID)
+}
+
+func screenshots(images []api.ScreenshotImage) []string {
+	out := make([]string, 0, len(images))
+	for _, image := range images {
+		if raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL)); raw != "" {
+			out = append(out, raw)
+		}
+	}
+	return out
+}
+
+func screenshotBlock(images []api.ScreenshotImage) string {
+	if len(images) == 0 {
+		return ""
+	}
+	parts := []string{"<center>"}
+	for idx, image := range images {
+		img := metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL)
+		web := metautil.FirstNonEmptyTrimmed(image.WebURL, img)
+		if img == "" || web == "" {
+			continue
+		}
+		parts = append(parts, `<a href="`+web+`"><img src="`+img+`" style="max-width: 350px;"></a>`)
+		if (idx+1)%2 == 0 {
+			parts = append(parts, "<br><br>")
+		}
+	}
+	parts = append(parts, "</center>")
+	return strings.Join(parts, "  ")
+}
+
+func containsWord(a string, b string) bool {
+	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
+}
+
+func isSD(res string) bool {
+	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
+}
+
+func boolWord(cond bool, yes string, no string) string {
+	if cond {
+		return yes
+	}
+	return no
+}
+
+func isTV(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func genresText(meta api.UploadSubject) string {
+	return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Genres, meta.Release.Genre)
+}
diff --git a/internal/trackers/impl/standalone/tvc/bbcode.go b/internal/trackers/impl/standalone/tvc/bbcode.go
new file mode 100644
index 00000000..e28aeb0e
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/bbcode.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/bbcode"
+)
+
+func finalizeDescription(value string) string {
+	value = strings.TrimSpace(bbcode.NormalizeNewlines(value))
+	value = bbcode.ConvertPreToCode(value)
+	value = bbcode.ConvertHideToSpoiler(value)
+	value = bbcode.ConvertComparisonToCollapse(value, 1000)
+	return bbcode.RemoveExtraLines(value)
+}
diff --git a/internal/trackers/impl/standalone/tvc/definition.go b/internal/trackers/impl/standalone/tvc/definition.go
new file mode 100644
index 00000000..e901999e
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/definition.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"context"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func newDuplicateAdapter(dupe.Dependencies) dupe.Adapter { return tvcDuplicateAdapter{} }
+
+type tvcDuplicateAdapter struct{}
+
+func (tvcDuplicateAdapter) Search(_ context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	resolution := strings.ToLower(strings.TrimSpace(meta.Release.Resolution))
+	if strings.Contains(resolution, "2160") || strings.EqualFold(meta.Type, "REMUX") || strings.TrimSpace(meta.DiscType) != "" {
+		return dupe.NotRun(dupe.NotRunUnsupportedContent, "TVC disallows UHD, disc, and remux content", nil)
+	}
+	return dupe.NotRun(dupe.NotRunManualCheckRequired, "TVC duplicate search requires a manual check", nil)
+}
+
+func prepareDescription(_ context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, req.TrackerConfig, assets)
+	return trackers.DescriptionResult{Group: "tvc", Description: description}, nil
+}
diff --git a/internal/trackers/impl/standalone/tvc/profile.go b/internal/trackers/impl/standalone/tvc/profile.go
new file mode 100644
index 00000000..28f11c2d
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/profile.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns TVC identity, preparation, dupe, and policy behavior,
+// including strict metadata, UHD, BDMV-disc, and remux restrictions.
+func Profile() standalone.Profile {
+	return standalone.Profile{
+		Name:                "TVC",
+		BaseURL:             "https://tvchaosuk.com",
+		DescriptionGroup:    "tvc",
+		UploadContentMode:   trackers.UploadContentModeDescription,
+		PrepareDescription:  prepareDescription,
+		PrepareUpload:       prepareUpload,
+		NewDuplicateAdapter: newDuplicateAdapter,
+		Rules:               rules(),
+		MetadataPolicy: &trackers.TrackerMetadataPolicy{
+			RequireKnownCategory: true,
+			Requirements: []trackers.MetadataRequirement{{
+				Scope:       trackers.MetadataScopeAny,
+				AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB, trackers.MetadataFieldIMDB},
+				Disposition: api.RuleDispositionStrict,
+			}},
+		},
+		UploadArtifactPolicy:  &trackers.UploadArtifactPolicy{Source: "TVCHAOS"},
+		ImageHostPolicy:       &trackers.ImageHostPolicy{AllowedHosts: []string{"imgbb", "imgbox", "pixhost", "bam", "onlyimage"}},
+		TorrentIdentityPolicy: &trackers.TorrentIdentityPolicy{TrackerURLPatterns: []string{"https://tvchaosuk.com"}},
+	}
+}
+
+// New returns a fresh TVC definition from its tracker-local profile.
+func New() *standalone.Definition { return standalone.MustNew(Profile()) }
diff --git a/internal/trackers/impl/standalone/tvc/rules.go b/internal/trackers/impl/standalone/tvc/rules.go
new file mode 100644
index 00000000..ad623f3b
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/rules.go
@@ -0,0 +1,45 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// rules strictly blocks UHD, BDMV-disc, and remux uploads.
+func rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkRules} }
+
+func checkRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0, 3)
+	if strings.EqualFold(trackers.ResolveRuleResolution(meta), "2160p") {
+		failures = append(failures, trackers.NewRuleFailure(
+			"uhd_forbidden",
+			"TVC disallows UHD uploads",
+			api.RuleDispositionStrict,
+		))
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		failures = append(failures, trackers.NewRuleFailure(
+			"disc_forbidden",
+			"TVC disallows disc uploads",
+			api.RuleDispositionStrict,
+		))
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "REMUX") {
+		failures = append(failures, trackers.NewRuleFailure(
+			"remux_forbidden",
+			"TVC disallows remux uploads",
+			api.RuleDispositionStrict,
+		))
+	}
+	return failures, nil
+}
diff --git a/internal/trackers/impl/standalone/tvc/upload.go b/internal/trackers/impl/standalone/tvc/upload.go
new file mode 100644
index 00000000..70be40b8
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/upload.go
@@ -0,0 +1,488 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path" //nolint:depguard // Extracts tracker response URL path basename.
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
+	"github.com/autobrr/upbrr/internal/metadata/metautil"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/standalone"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const (
+	baseURL    = "https://tvchaosuk.com"
+	uploadURL  = baseURL + "/api/torrents/upload"
+	sourceFlag = "TVCHAOS"
+)
+
+var categoryMap = map[string]string{
+	"comedy":          "29",
+	"current affairs": "45",
+	"documentary":     "5",
+	"drama":           "11",
+	"entertainment":   "14",
+	"factual":         "19",
+	"foreign":         "43",
+	"kids":            "32",
+	"movies":          "44",
+	"news":            "54",
+	"reality":         "52",
+	"soaps":           "30",
+	"sci-fi":          "33",
+	"sport":           "42",
+	"holding bin":     "53",
+}
+
+type uploadState struct {
+	torrentPath   string
+	description   string
+	releaseName   string
+	fields        map[string]string
+	questionnaire *api.TrackerQuestionnaire
+	blockedReason string
+}
+
+func prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	state, err := prepareUploadState(ctx, req)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	preview := buildUploadPreview(state)
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if strings.EqualFold(trackers.ResolveRuleResolution(api.NewRuleSubject(req.Meta)), "2160p") {
+		return trackers.PreparedOperation{}, errors.New("trackers: TVC disallows UHD uploads")
+	}
+	if state.blockedReason != "" {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: TVC %s", state.blockedReason)
+	}
+	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
+		FieldName: "torrent",
+		FileName:  filepath.Base(state.torrentPath),
+		Path:      state.torrentPath,
+	}})
+	if err != nil {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+	}
+	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
+	announceURL := strings.TrimSpace(req.TrackerConfig.AnnounceURL)
+	artifactPath := ""
+	if announceURL != "" {
+		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.Runtime.DBPath, "TVC")
+		if err != nil {
+			return trackers.PreparedOperation{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitPreparedUpload(submitCtx, req, state, body, contentType, apiKey, announceURL, artifactPath)
+	}, nil), nil
+}
+
+func submitPreparedUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	state uploadState,
+	body []byte,
+	contentType string,
+	apiKey string,
+	announceURL string,
+	artifactPath string,
+) (api.UploadSummary, error) {
+	httpReq, err := http.NewRequestWithContext(
+		ctx,
+		http.MethodPost,
+		uploadURL+"?api_token="+url.QueryEscape(apiKey),
+		bytes.NewReader(body),
+	)
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TVC build upload request: %s", commonhttp.RedactErrorDetail(err.Error()))
+	}
+	httpReq.Header.Set("Content-Type", contentType)
+	httpReq.Header.Set("User-Agent", "Mozilla/5.0")
+
+	result, err := commonhttp.ExecuteUpload(&http.Client{Timeout: 30 * time.Second}, httpReq, commonhttp.UploadExecutionOptions{
+		Tracker:       "TVC",
+		SuccessStatus: func(status int) bool { return status == http.StatusOK },
+	})
+	if err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TVC execute upload: %w", err)
+	}
+	if !result.Success {
+		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.Runtime.DBPath, "TVC", "upload_failure", result.Preview, ".txt")
+		return api.UploadSummary{}, commonhttp.UploadHTTPError("TVC", result.StatusCode, result.Preview)
+	}
+
+	payload := string(result.Body)
+	if strings.Contains(payload, "\n") {
+		payload = strings.SplitN(payload, "\n", 2)[1]
+	}
+	var decoded map[string]any
+	if err := json.Unmarshal([]byte(payload), &decoded); err != nil {
+		return api.UploadSummary{}, fmt.Errorf("trackers: TVC decode response: %w", err)
+	}
+	dataURL := strings.TrimSpace(fmt.Sprint(decoded["data"]))
+	torrentID := path.Base(strings.TrimRight(dataURL, "/"))
+
+	if announceURL != "" {
+		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announceURL, dataURL, sourceFlag); err != nil {
+			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
+		Tracker:     "TVC",
+		TorrentID:   torrentID,
+		TorrentURL:  dataURL,
+		DownloadURL: dataURL,
+		TorrentPath: artifactPath,
+	}}}, nil
+}
+
+func buildUploadPreview(state uploadState) api.TrackerDryRunEntry {
+	return standalone.BuildPreview(standalone.PreviewSpec{
+		Tracker:          "TVC",
+		BlockedReason:    state.blockedReason,
+		ReleaseName:      state.releaseName,
+		DescriptionGroup: "tvc",
+		Description:      state.description,
+		Endpoint:         uploadURL,
+		Payload:          state.fields,
+		Questionnaire:    state.questionnaire,
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    state.torrentPath,
+			Present: strings.TrimSpace(state.torrentPath) != "",
+		}},
+	})
+}
+
+func prepareUploadState(_ context.Context, req trackers.PreparationInput) (uploadState, error) {
+	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
+		return uploadState{}, errors.New("trackers: TVC missing api_key")
+	}
+	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.Runtime.DBPath)
+	if err != nil {
+		return uploadState{}, fmt.Errorf("trackers: %w", err)
+	}
+	assets, err := trackers.PreparedDescriptionAssets(req.Assets)
+	if err != nil {
+		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
+		assets = trackers.DescriptionAssets{}
+	}
+	description := buildDescription(req.Meta, req.TrackerConfig, assets)
+	releaseName := resolveName(req.Meta)
+	if override := strings.TrimSpace(standalone.QuestionnaireAnswers(req.Meta, "TVC")["name_override"]); override != "" {
+		releaseName = override
+	}
+
+	fields := map[string]string{
+		"name":             releaseName,
+		"description":      description,
+		"mediainfo":        commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
+		"bdinfo":           "",
+		"category_id":      resolveCategory(req.Meta),
+		"type":             resolveResolution(req.Meta),
+		"tmdb":             strconv.Itoa(req.Meta.Identity.TMDBID),
+		"imdb":             strconv.Itoa(req.Meta.Identity.IMDBID),
+		"mal":              strconv.Itoa(req.Meta.Identity.MALID),
+		"igdb":             "0",
+		"anonymous":        boolNum(req.TrackerConfig.Anon),
+		"stream":           boolNum(req.Meta.StreamOptimized > 0),
+		"sd":               boolNum(isSD(req.Meta.Release.Resolution)),
+		"keywords":         keywordsText(req.Meta),
+		"personal_release": boolNum(req.Meta.PersonalRelease),
+		"internal":         "0",
+		"featured":         "0",
+		"free":             "0",
+		"doubleup":         "0",
+		"sticky":           "0",
+	}
+	if isTV(req.Meta) {
+		if isTVCategory(req.Meta) {
+			fields["tvdb"] = strconv.Itoa(req.Meta.Identity.TVDBID)
+		}
+		fields["season_number"] = strconv.Itoa(maxInt(req.Meta.SeasonInt, 0))
+		fields["episode_number"] = strconv.Itoa(maxInt(req.Meta.EpisodeInt, 0))
+	}
+
+	return uploadState{
+		torrentPath:   torrentPath,
+		description:   description,
+		releaseName:   releaseName,
+		fields:        fields,
+		questionnaire: buildQuestionnaire(req.Meta),
+		blockedReason: validateUpload(req.TrackerConfig, assets),
+	}, nil
+}
+
+func buildDescription(meta api.UploadSubject, cfg config.TrackerConfig, assets trackers.DescriptionAssets) string {
+	parts := make([]string, 0, 6)
+	if logo := strings.TrimSpace(meta.ProviderMetadata.TMDB.Logo); logo != "" {
+		parts = append(parts, fmt.Sprintf("[center][img=%d]%s[/img][/center]", maxInt(cfg.ImageCount, 300), logo))
+	}
+	if title := strings.TrimSpace(meta.EpisodeTitle); title != "" {
+		parts = append(parts, "[center][b]Episode Title:[/b] "+title+"[/center]")
+	}
+	if overview := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.EpisodeOverview, meta.ProviderMetadata.TMDB.Overview)); overview != "" {
+		parts = append(parts, "[center]"+overview+"[/center]")
+	}
+	if links := externalLinks(meta); links != "" {
+		parts = append(parts, "[center]"+links+"[/center]")
+	}
+	if shots := screenshotBlock(assets.Screenshots, maxInt(cfg.ImageCount, 2)); shots != "" {
+		parts = append(parts, "[center]"+shots+"[/center]")
+	}
+	if base := strings.TrimSpace(assets.Description); base != "" {
+		parts = append(parts, "[center][b]Notes / Extra Info[/b]\n"+base+"[/center]")
+	}
+	return finalizeDescription(strings.TrimSpace(strings.Join(parts, "\n\n")))
+}
+
+func buildQuestionnaire(meta api.UploadSubject) *api.TrackerQuestionnaire {
+	return &api.TrackerQuestionnaire{
+		Tracker: "TVC",
+		Fields: []api.TrackerQuestionnaireField{{
+			Key:      "name_override",
+			Label:    "Upload Name",
+			Kind:     "text",
+			Value:    resolveName(meta),
+			Required: true,
+		}},
+	}
+}
+
+func validateUpload(cfg config.TrackerConfig, assets trackers.DescriptionAssets) string {
+	required := maxInt(cfg.ImageCount, 2)
+	if len(assets.Screenshots) < required {
+		return fmt.Sprintf("TVC requires at least %d screenshots", required)
+	}
+	for _, image := range assets.Screenshots {
+		host := strings.ToLower(strings.TrimSpace(imagehost.ExtractHost(metautil.FirstNonEmptyTrimmed(image.WebURL, image.ImgURL, image.RawURL))))
+		switch host {
+		case "imgbb", "imgbox", "pixhost", "bam", "onlyimage":
+		default:
+			return "TVC screenshots must use an approved image host"
+		}
+	}
+	return ""
+}
+
+func resolveCategory(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "en") &&
+		!strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "ga") &&
+		!strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "gd") &&
+		!strings.EqualFold(meta.ProviderMetadata.TMDB.OriginalLanguage, "cy") {
+		return categoryMap["foreign"]
+	}
+	genres := strings.ToLower(genresText(meta))
+	for key, value := range categoryMap {
+		if key != "foreign" && strings.Contains(genres, key) {
+			return value
+		}
+	}
+	if !isTV(meta) {
+		return categoryMap["movies"]
+	}
+	return categoryMap["holding bin"]
+}
+
+func resolveResolution(meta api.UploadSubject) string {
+	if meta.TVPack {
+		switch meta.Release.Resolution {
+		case "1080p", "1080i":
+			return "HD1080p Pack"
+		case "720p":
+			return "HD720p Pack"
+		default:
+			return "SD Pack"
+		}
+	}
+	switch meta.Release.Resolution {
+	case "1080p", "1080i":
+		return "HD1080p"
+	case "720p":
+		return "HD720p"
+	default:
+		return "SD"
+	}
+}
+
+func resolveName(meta api.UploadSubject) string {
+	typeName := strings.ReplaceAll(meta.Type, "WEBDL", "WEB-DL")
+	var name string
+	switch {
+	case !isTV(meta):
+		name = fmt.Sprintf(
+			"%s (%d) [%s %s %s]",
+			metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName),
+			maxInt(meta.Release.Year, meta.ProviderMetadata.TMDB.Year),
+			meta.Release.Resolution,
+			typeName,
+			videoSuffix(meta.VideoCodec),
+		)
+	case meta.TVPack:
+		name = fmt.Sprintf(
+			"%s - Series %d (%d) [%s %s %s]",
+			metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName),
+			maxInt(meta.SeasonInt, 1),
+			maxInt(meta.Release.Year, meta.ProviderMetadata.TMDB.Year),
+			meta.Release.Resolution,
+			typeName,
+			videoSuffix(meta.VideoCodec),
+		)
+	default:
+		name = fmt.Sprintf(
+			"%s S%02dE%02d [%s %s %s]",
+			metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName),
+			maxInt(meta.SeasonInt, 1),
+			maxInt(meta.EpisodeInt, 1),
+			meta.Release.Resolution,
+			typeName,
+			videoSuffix(meta.VideoCodec),
+		)
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.VideoCodec), "HEVC") {
+		name = strings.Replace(name, "]", " HEVC]", 1)
+	}
+	return appendCountryCode(meta, name)
+}
+
+func appendCountryCode(meta api.UploadSubject, name string) string {
+	mapping := map[string]string{
+		"AT": "AUT",
+		"AU": "AUS",
+		"BE": "BEL",
+		"CA": "CAN",
+		"CH": "CHE",
+		"CZ": "CZE",
+		"DE": "GER",
+		"DK": "DNK",
+		"EE": "EST",
+		"ES": "SPA",
+		"FI": "FIN",
+		"FR": "FRA",
+		"IE": "IRL",
+		"IS": "ISL",
+		"IT": "ITA",
+		"NL": "NLD",
+		"NO": "NOR",
+		"NZ": "NZL",
+		"PL": "POL",
+		"PT": "POR",
+		"RU": "RUS",
+		"SE": "SWE",
+	}
+	for _, code := range meta.ProviderMetadata.TMDB.OriginCountry {
+		if mapped := mapping[strings.ToUpper(strings.TrimSpace(code))]; mapped != "" {
+			return name + " [" + mapped + "]"
+		}
+	}
+	return name
+}
+
+func externalLinks(meta api.UploadSubject) string {
+	parts := make([]string, 0, 3)
+	if category := categoryName(meta); meta.Identity.TMDBID > 0 && category != "" {
+		parts = append(parts, fmt.Sprintf("[url=https://www.themoviedb.org/%s/%d]TMDB[/url]", strings.ToLower(category), meta.Identity.TMDBID))
+	}
+	if meta.Identity.IMDBID > 0 {
+		parts = append(parts, fmt.Sprintf("[url=https://www.imdb.com/title/tt%07d]IMDb[/url]", meta.Identity.IMDBID))
+	}
+	if isTVCategory(meta) && meta.Identity.TVDBID > 0 {
+		parts = append(parts, fmt.Sprintf("[url=https://www.thetvdb.com/?id=%d&tab=series]TVDB[/url]", meta.Identity.TVDBID))
+	}
+	return strings.Join(parts, " | ")
+}
+
+func screenshotBlock(images []api.ScreenshotImage, count int) string {
+	if len(images) < count {
+		return ""
+	}
+	parts := []string{"[b]Screenshots[/b]"}
+	for _, image := range images[:count] {
+		web := metautil.FirstNonEmptyTrimmed(image.WebURL, image.ImgURL, image.RawURL)
+		img := metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL)
+		if web == "" || img == "" {
+			continue
+		}
+		parts = append(parts, fmt.Sprintf("[url=%s][img=350]%s[/img][/url]", web, img))
+	}
+	return strings.Join(parts, " ")
+}
+
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func boolNum(v bool) string {
+	if v {
+		return "1"
+	}
+	return "0"
+}
+
+func isSD(res string) bool {
+	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
+}
+
+func videoSuffix(codec string) string {
+	value := strings.ToUpper(strings.TrimSpace(codec))
+	if len(value) <= 3 {
+		return value
+	}
+	return value[len(value)-3:]
+}
+
+func isTV(meta api.UploadSubject) bool {
+	return isTVCategory(meta)
+}
+
+// isTVCategory reports whether TVC payloads may include TVDB-specific fields.
+// Only canonical TV identity enables TVDB-specific fields.
+func isTVCategory(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryTV
+}
+
+func isMovieCategory(meta api.UploadSubject) bool {
+	category, err := meta.Identity.RequireCategory()
+	return err == nil && category == api.CanonicalCategoryMovie
+}
+
+func categoryName(meta api.UploadSubject) string {
+	if isTV(meta) {
+		return "TV"
+	}
+	if isMovieCategory(meta) {
+		return "MOVIE"
+	}
+	return ""
+}
+
+func genresText(meta api.UploadSubject) string {
+	return metautil.FirstNonEmptyTrimmed(meta.ProviderMetadata.TMDB.Genres, meta.Release.Genre)
+}
+
+func keywordsText(meta api.UploadSubject) string {
+	return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
+}
diff --git a/internal/trackers/impl/standalone/tvc/upload_test.go b/internal/trackers/impl/standalone/tvc/upload_test.go
new file mode 100644
index 00000000..445988ba
--- /dev/null
+++ b/internal/trackers/impl/standalone/tvc/upload_test.go
@@ -0,0 +1,167 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tvc
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestPrepareUploadStateSkipsTVDBForMovie(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "movie.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	state, err := prepareUploadState(context.Background(), trackers.PreparationInput{
+		Tracker: "TVC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Movie.mkv"),
+			TorrentPath: torrentPath,
+			Identity: api.ExternalIdentity{
+				Category: "MOVIE",
+				TMDBID:   123,
+				TVDBID:   456,
+			},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Title: "Movie", Year: 2025},
+			},
+			Release: api.ReleaseInfo{
+				Title:      "Movie",
+				Year:       2025,
+				Resolution: "1080p",
+			},
+			Type: "WEBDL",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	})
+	if err != nil {
+		t.Fatalf("prepare upload state: %v", err)
+	}
+	if _, ok := state.fields["tvdb"]; ok {
+		t.Fatalf("did not expect tvdb for movie payload")
+	}
+}
+
+func TestPrepareUploadStateIncludesTVDBForTV(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "show.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	state, err := prepareUploadState(context.Background(), trackers.PreparationInput{
+		Tracker: "TVC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Show.S02E03.mkv"),
+			TorrentPath: torrentPath,
+			Identity: api.ExternalIdentity{
+				Category: "TV",
+				TMDBID:   123,
+				TVDBID:   456,
+			},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
+			},
+			Release: api.ReleaseInfo{
+				Title:      "Show",
+				Year:       2025,
+				Resolution: "1080p",
+			},
+			Type:       "WEBDL",
+			SeasonInt:  2,
+			EpisodeInt: 3,
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	})
+	if err != nil {
+		t.Fatalf("prepare upload state: %v", err)
+	}
+	if got := state.fields["tvdb"]; got != "456" {
+		t.Fatalf("expected tvdb=456, got %q", got)
+	}
+}
+
+func TestPrepareUploadStateIncludesTVDBForMediaInfoTV(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "show.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	state, err := prepareUploadState(context.Background(), trackers.PreparationInput{
+		Tracker: "TVC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Show.mkv"),
+			TorrentPath: torrentPath,
+			Identity: api.ExternalIdentity{
+				Category: "TV",
+				TMDBID:   123,
+				TVDBID:   456,
+			},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
+			},
+			Release: api.ReleaseInfo{
+				Title:      "Show",
+				Year:       2025,
+				Resolution: "1080p",
+			},
+			Type: "WEBDL",
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	})
+	if err != nil {
+		t.Fatalf("prepare upload state: %v", err)
+	}
+	if got := state.fields["tvdb"]; got != "456" {
+		t.Fatalf("expected tvdb=456, got %q", got)
+	}
+}
+
+func TestPrepareUploadStateIncludesTVDBForCanonicalTVSeasonPack(t *testing.T) {
+	tmp := t.TempDir()
+	torrentPath := filepath.Join(tmp, "season.torrent")
+	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
+		t.Fatalf("write torrent: %v", err)
+	}
+
+	state, err := prepareUploadState(context.Background(), trackers.PreparationInput{
+		Tracker: "TVC",
+		Meta: api.UploadSubject{
+			SourcePath:  filepath.Join(tmp, "Show.S02.mkv"),
+			TorrentPath: torrentPath,
+			Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryTV,
+				TMDBID:   123,
+				TVDBID:   456,
+			},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
+			},
+			Release: api.ReleaseInfo{
+				Title:      "Show",
+				Year:       2025,
+				Resolution: "1080p",
+			},
+			Type:      "WEBDL",
+			TVPack:    true,
+			SeasonInt: 2,
+		},
+		TrackerConfig: config.TrackerConfig{APIKey: "token"},
+	})
+	if err != nil {
+		t.Fatalf("prepare upload state: %v", err)
+	}
+	if got := state.fields["tvdb"]; got != "456" {
+		t.Fatalf("expected tvdb=456, got %q", got)
+	}
+}
diff --git a/internal/trackers/impl/thr/definition.go b/internal/trackers/impl/thr/definition.go
deleted file mode 100644
index 3fe255f0..00000000
--- a/internal/trackers/impl/thr/definition.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package thr
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "THR" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, assets)
-	return trackers.DescriptionResult{Group: "thr", Description: description}, nil
-}
diff --git a/internal/trackers/impl/thr/upload.go b/internal/trackers/impl/thr/upload.go
deleted file mode 100644
index 4e0911d7..00000000
--- a/internal/trackers/impl/thr/upload.go
+++ /dev/null
@@ -1,466 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package thr
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"maps"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"golang.org/x/net/html"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL              = "https://www.torrenthr.org"
-	loginPagePath        = "/login.php"
-	takeLoginPath        = "/takelogin.php"
-	uploadURL            = baseURL + "/takeupload.php"
-	sourceFlag           = "[https://www.torrenthr.org] TorrentHR.org"
-	loginResponseMaxSize = 1024 * 1024
-)
-
-// ErrLoginFailed marks a completed THR login exchange that did not produce
-// authenticated index-page evidence.
-var ErrLoginFailed = errors.New("trackers: THR login failed")
-
-var (
-	subtitleMap = map[string]string{"croatian": "1", "english": "2", "bosnian": "3", "serbian": "4", "slovenian": "5"}
-	idPattern   = regexp.MustCompile(`id=(\d+)`)
-)
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	questionnaire *api.TrackerQuestionnaire
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, client, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{
-		{FieldName: "tfile", FileName: state.releaseName + ".torrent", Path: state.torrentPath},
-		{FieldName: "nfo", FileName: "MEDIAINFO.txt", Content: []byte(commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)))},
-	})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: THR build upload request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: THR upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
-
-	finalURL := ""
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL.String()
-	}
-	if strings.Contains(finalURL, "uploaded=1") {
-		torrentID := ""
-		if match := idPattern.FindStringSubmatch(finalURL); len(match) == 2 {
-			torrentID = match[1]
-		}
-		artifactPath := ""
-		if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-			artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "THR")
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, finalURL, sourceFlag); err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-		}
-		return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
-			Tracker: "THR", TorrentID: torrentID, TorrentURL: finalURL, DownloadURL: finalURL, TorrentPath: artifactPath,
-		}}}, nil
-	}
-
-	_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "THR", "upload_failure", bodyBytes, ".html")
-	return api.UploadSummary{}, commonhttp.UploadHTTPError("THR", resp.StatusCode, bodyBytes)
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "THR",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "thr",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "tfile", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, *http.Client, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, assets)
-	releaseName := resolveName(req.Meta)
-	if override := strings.TrimSpace(questionnaireAnswers(req.Meta)["name_override"]); override != "" {
-		releaseName = override
-	}
-	fields := map[string]string{
-		"name":  releaseName,
-		"descr": description,
-		"type":  resolveCategory(req.Meta),
-		"url":   imdbURL(req.Meta),
-		"tube":  strings.TrimSpace(req.Meta.ExternalMetadata.TMDB.YouTube),
-	}
-	for idx, sub := range resolveSubtitles(req.Meta) {
-		fields["subs["+strconv.Itoa(idx)+"]"] = sub
-	}
-	client, err := login(ctx, req.TrackerConfig)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	return uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   releaseName,
-		fields:        fields,
-		questionnaire: buildQuestionnaire(req.Meta),
-	}, client, nil
-}
-
-func login(ctx context.Context, cfg config.TrackerConfig) (*http.Client, error) {
-	return LoginSession(ctx, cfg)
-}
-
-// LoginSession performs THR's browser-style login flow. It first loads the
-// login page into a cookie jar, carries all non-empty hidden form fields into
-// the credential POST, follows the redirect to the authenticated page, and
-// returns the live client only after the final index page contains a structured
-// logout link on the same scheme and hostname.
-func LoginSession(ctx context.Context, cfg config.TrackerConfig) (*http.Client, error) {
-	if strings.TrimSpace(cfg.Username) == "" || strings.TrimSpace(cfg.Password) == "" {
-		return nil, errors.New("trackers: THR missing username/password")
-	}
-	resolvedBaseURL := strings.TrimRight(strings.TrimSpace(cfg.URL), "/")
-	if resolvedBaseURL == "" {
-		resolvedBaseURL = baseURL
-	}
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: THR create login cookie jar: %w", err)
-	}
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-	loginPageURL := resolvedBaseURL + loginPagePath
-	pageReq, err := http.NewRequestWithContext(ctx, http.MethodGet, loginPageURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: THR build login page request: %w", err)
-	}
-	pageReq.Header.Set("User-Agent", "upbrr")
-	pageResp, err := client.Do(pageReq)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: THR login page request: %w", err)
-	}
-	pageBody, readErr := readLoginResponse(pageResp)
-	pageResp.Body.Close()
-	if readErr != nil {
-		return nil, fmt.Errorf("trackers: THR read login page: %w", readErr)
-	}
-	if pageResp.StatusCode < 200 || pageResp.StatusCode >= 300 {
-		return nil, fmt.Errorf("trackers: THR login page failed status=%d", pageResp.StatusCode)
-	}
-
-	form := hiddenLoginFields(pageBody)
-	form.Set("username", strings.TrimSpace(cfg.Username))
-	form.Set("password", strings.TrimSpace(cfg.Password))
-	form.Set("ssl", "yes")
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, resolvedBaseURL+takeLoginPath, strings.NewReader(form.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("trackers: THR build login request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("User-Agent", "upbrr")
-	req.Header.Set("Referer", loginPageURL)
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: THR login request: %w", err)
-	}
-	body, readErr := readLoginResponse(resp)
-	resp.Body.Close()
-	if readErr != nil {
-		return nil, fmt.Errorf("trackers: THR read login response: %w", readErr)
-	}
-	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {
-		return nil, fmt.Errorf("%w: status=%d", ErrLoginFailed, resp.StatusCode)
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, fmt.Errorf("trackers: THR login response status=%d", resp.StatusCode)
-	}
-	var finalURL *url.URL
-	if resp.Request != nil && resp.Request.URL != nil {
-		finalURL = resp.Request.URL
-	}
-	if !isAuthenticatedLoginPage(finalURL, body) {
-		return nil, fmt.Errorf("%w: authenticated marker not found", ErrLoginFailed)
-	}
-	return client, nil
-}
-
-// isAuthenticatedLoginPage requires THR's post-login index path and a parsed
-// logout anchor on the same scheme and hostname. Path fragments or incidental
-// response text cannot independently prove authentication.
-func isAuthenticatedLoginPage(finalURL *url.URL, body []byte) bool {
-	if finalURL == nil || !strings.EqualFold(strings.Trim(finalURL.Path, "/"), "index.php") {
-		return false
-	}
-	tokenizer := html.NewTokenizer(bytes.NewReader(body))
-	for {
-		switch tokenizer.Next() {
-		case html.ErrorToken:
-			return false
-		case html.StartTagToken, html.SelfClosingTagToken:
-			token := tokenizer.Token()
-			if !strings.EqualFold(token.Data, "a") {
-				continue
-			}
-			for _, attr := range token.Attr {
-				if !strings.EqualFold(attr.Key, "href") {
-					continue
-				}
-				candidate, err := url.Parse(strings.TrimSpace(attr.Val))
-				if err != nil || !strings.EqualFold(strings.TrimPrefix(candidate.Path, "/"), "logout.php") {
-					continue
-				}
-				if candidate.Scheme != "" && !strings.EqualFold(candidate.Scheme, finalURL.Scheme) {
-					continue
-				}
-				if candidate.Host != "" && !strings.EqualFold(candidate.Hostname(), finalURL.Hostname()) {
-					continue
-				}
-				return true
-			}
-		case html.TextToken, html.EndTagToken, html.CommentToken, html.DoctypeToken:
-			continue
-		}
-	}
-}
-
-func readLoginResponse(resp *http.Response) ([]byte, error) {
-	if resp == nil || resp.Body == nil {
-		return nil, errors.New("empty response")
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, loginResponseMaxSize+1))
-	if err != nil {
-		return nil, fmt.Errorf("read response body: %w", err)
-	}
-	if len(body) > loginResponseMaxSize {
-		return nil, fmt.Errorf("response exceeds %d bytes", loginResponseMaxSize)
-	}
-	return body, nil
-}
-
-func hiddenLoginFields(body []byte) url.Values {
-	fields := url.Values{}
-	tokenizer := html.NewTokenizer(bytes.NewReader(body))
-	for {
-		switch tokenizer.Next() {
-		case html.ErrorToken:
-			return fields
-		case html.StartTagToken, html.SelfClosingTagToken:
-			token := tokenizer.Token()
-			if !strings.EqualFold(token.Data, "input") {
-				continue
-			}
-			name, value, inputType := "", "", ""
-			for _, attr := range token.Attr {
-				switch {
-				case strings.EqualFold(attr.Key, "name"):
-					name = strings.TrimSpace(attr.Val)
-				case strings.EqualFold(attr.Key, "value"):
-					value = attr.Val
-				case strings.EqualFold(attr.Key, "type"):
-					inputType = strings.TrimSpace(attr.Val)
-				}
-			}
-			if strings.EqualFold(inputType, "hidden") && name != "" && value != "" {
-				fields.Set(name, value)
-			}
-		case html.TextToken, html.EndTagToken, html.CommentToken, html.DoctypeToken:
-			continue
-		}
-	}
-}
-
-func buildDescription(meta api.PreparedMetadata, assets trackers.DescriptionAssets) string {
-	parts := []string{
-		"[quote=Info]",
-		"Name: " + strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName)),
-		"",
-		"Overview: " + strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.EpisodeOverview, meta.ExternalMetadata.TMDB.Overview)),
-		"",
-		metautil.FirstNonEmptyTrimmed(meta.Release.Resolution, meta.Release.Source) + " / " + strings.TrimSpace(meta.Type),
-		"",
-		"Category: " + categoryName(meta),
-	}
-	if tmdb := meta.ExternalIDs.TMDBID; tmdb > 0 {
-		parts = append(parts, fmt.Sprintf("TMDB: https://www.themoviedb.org/%s/%d", strings.ToLower(categoryName(meta)), tmdb))
-	}
-	if imdb := imdbURL(meta); imdb != "" {
-		parts = append(parts, "IMDb: "+imdb)
-	}
-	parts = append(parts, "[/quote]")
-	if base := strings.TrimSpace(assets.Description); base != "" {
-		parts = append(parts, base)
-	}
-	for _, image := range assets.Screenshots {
-		raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL))
-		if raw != "" {
-			parts = append(parts, "[img]"+raw+"[/img]")
-		}
-	}
-	parts = append(parts, `[size=2][url=https://www.torrenthr.org/forums.php?action=viewtopic&topicid=8977]upbrr[/url][/size]`)
-	return bbcode.FinalizeTrackerDescription("THR", strings.TrimSpace(strings.Join(parts, "\n")))
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata) *api.TrackerQuestionnaire {
-	return &api.TrackerQuestionnaire{
-		Tracker: "THR",
-		Fields: []api.TrackerQuestionnaireField{{
-			Key: "name_override", Label: "Upload Name", Kind: "text", Value: resolveName(meta), Required: true,
-		}},
-	}
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	base := strings.ReplaceAll(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename), "DD+", "DDP")
-	return regexp.MustCompile(`[^0-9a-zA-Z. '\-\[\]]+`).ReplaceAllString(base, " ")
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	if containsWord(genresText(meta), "documentary") || containsWord(keywordsText(meta), "documentary") {
-		return "12"
-	}
-	switch categoryName(meta) {
-	case "MOVIE":
-		if strings.EqualFold(meta.DiscType, "BDMV") {
-			return "40"
-		}
-		if strings.EqualFold(meta.DiscType, "DVD") || strings.EqualFold(meta.DiscType, "HDDVD") {
-			return "14"
-		}
-		if isSD(meta.Release.Resolution) {
-			return "4"
-		}
-		return "17"
-	case "TV":
-		if isSD(meta.Release.Resolution) {
-			return "7"
-		}
-		return "34"
-	default:
-		if meta.Anime {
-			return "31"
-		}
-	}
-	return "17"
-}
-
-func resolveSubtitles(meta api.PreparedMetadata) []string {
-	result := make([]string, 0, len(meta.SubtitleLanguages))
-	seen := map[string]struct{}{}
-	for _, lang := range meta.SubtitleLanguages {
-		id := subtitleMap[strings.ToLower(strings.TrimSpace(lang))]
-		if id == "" {
-			continue
-		}
-		if _, ok := seen[id]; ok {
-			continue
-		}
-		seen[id] = struct{}{}
-		result = append(result, id)
-	}
-	return result
-}
-
-func imdbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.imdb.com/title/tt%07d/", meta.ExternalIDs.IMDBID)
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["THR"]
-}
-
-func isSD(res string) bool {
-	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
-}
-
-func containsWord(a string, b string) bool {
-	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
-
-func categoryName(meta api.PreparedMetadata) string {
-	if isTV(meta) {
-		return "TV"
-	}
-	return "MOVIE"
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
-
-func genresText(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Genres, meta.Release.Genre)
-}
-
-func keywordsText(meta api.PreparedMetadata) string {
-	return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-}
diff --git a/internal/trackers/impl/thr/upload_test.go b/internal/trackers/impl/thr/upload_test.go
deleted file mode 100644
index 34571a69..00000000
--- a/internal/trackers/impl/thr/upload_test.go
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package thr
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-)
-
-func TestLoginSessionBootstrapsHiddenFieldsAndFollowsRedirect(t *testing.T) {
-	t.Parallel()
-
-	handlerErr := make(chan error, 8)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case loginPagePath:
-			http.SetCookie(w, &http.Cookie{Name: "bootstrap", Value: "ready", Path: "/"})
-			_, _ = w.Write([]byte(`<form><input type="hidden" name="token" value="login-token"><input type="hidden" name="blank" value=""></form>`))
-		case takeLoginPath:
-			if err := r.ParseForm(); err != nil {
-				handlerErr <- fmt.Errorf("parse login form: %w", err)
-				return
-			}
-			if r.FormValue("username") != "user" || r.FormValue("password") != "pass" || r.FormValue("ssl") != "yes" || r.FormValue("token") != "login-token" {
-				handlerErr <- errors.New("login form did not preserve credentials and hidden fields")
-			}
-			if r.Form.Has("blank") {
-				handlerErr <- errors.New("empty hidden field should not be submitted")
-			}
-			if cookie, err := r.Cookie("bootstrap"); err != nil || cookie.Value != "ready" {
-				handlerErr <- errors.New("login bootstrap cookie missing")
-			}
-			if r.Referer() != "http://"+r.Host+loginPagePath {
-				handlerErr <- fmt.Errorf("unexpected login referer %q", r.Referer())
-			}
-			http.SetCookie(w, &http.Cookie{Name: "session", Value: "authenticated", Path: "/"})
-			http.Redirect(w, r, "/index.php", http.StatusFound)
-		case "/index.php":
-			if cookie, err := r.Cookie("session"); err != nil || cookie.Value != "authenticated" {
-				_, _ = w.Write([]byte(`<form action="/login.php"></form>`))
-				return
-			}
-			_, _ = w.Write([]byte(`<a href="logout.php">Logout</a>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	client, err := LoginSession(context.Background(), config.TrackerConfig{URL: server.URL, Username: "user", Password: "pass"})
-	if err != nil {
-		t.Fatalf("LoginSession: %v", err)
-	}
-	if client == nil || client.Jar == nil {
-		t.Fatal("expected authenticated client with cookie jar")
-	}
-	close(handlerErr)
-	for err := range handlerErr {
-		t.Error(err)
-	}
-}
-
-func TestLoginSessionRejectsRedirectWithoutAuthenticatedMarker(t *testing.T) {
-	t.Parallel()
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case loginPagePath:
-			_, _ = w.Write([]byte(`<input type="hidden" name="token" value="login-token">`))
-		case takeLoginPath:
-			http.Redirect(w, r, "/home.php", http.StatusFound)
-		case "/home.php":
-			_, _ = w.Write([]byte(`<form action="/login.php"><input name="username"></form>`))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	t.Cleanup(server.Close)
-
-	client, err := LoginSession(context.Background(), config.TrackerConfig{URL: server.URL, Username: "user", Password: "pass"})
-	if !errors.Is(err, ErrLoginFailed) {
-		t.Fatalf("expected ErrLoginFailed, got %v", err)
-	}
-	if client != nil {
-		t.Fatal("expected rejected login to return no client")
-	}
-}
-
-func TestLoginSessionRejectsWeakAuthenticatedMarkers(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name      string
-		finalPath string
-		body      string
-	}{
-		{
-			name:      "public index path without logout anchor",
-			finalPath: "/index.php",
-			body:      `<form action="/login.php"><input name="username"></form>`,
-		},
-		{
-			name:      "incidental logout text off index",
-			finalPath: "/help.php",
-			body:      `<p>Read the logout.php troubleshooting guide.</p>`,
-		},
-		{
-			name:      "logout anchor off index",
-			finalPath: "/home.php",
-			body:      `<a href="/logout.php">Logout</a>`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				switch r.URL.Path {
-				case loginPagePath:
-					_, _ = w.Write([]byte(`<input type="hidden" name="token" value="login-token">`))
-				case takeLoginPath:
-					http.Redirect(w, r, tt.finalPath, http.StatusFound)
-				case tt.finalPath:
-					_, _ = w.Write([]byte(tt.body))
-				default:
-					http.NotFound(w, r)
-				}
-			}))
-			t.Cleanup(server.Close)
-
-			client, err := LoginSession(context.Background(), config.TrackerConfig{URL: server.URL, Username: "user", Password: "pass"})
-			if !errors.Is(err, ErrLoginFailed) {
-				t.Fatalf("expected ErrLoginFailed, got %v", err)
-			}
-			if client != nil {
-				t.Fatal("expected weak marker login to return no client")
-			}
-		})
-	}
-}
diff --git a/internal/trackers/impl/tl/definition.go b/internal/trackers/impl/tl/definition.go
deleted file mode 100644
index a3f8b210..00000000
--- a/internal/trackers/impl/tl/definition.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tl
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "TL" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(trackers.UploadRequest{
-		Tracker:       req.Tracker,
-		Meta:          req.Meta,
-		TrackerConfig: req.TrackerConfig,
-		AppConfig:     req.AppConfig,
-		Logger:        req.Logger,
-		Repo:          req.Repo,
-	}, assets)
-	return trackers.DescriptionResult{Group: "tl", Description: description}, nil
-}
diff --git a/internal/trackers/impl/tl/description_assets_test.go b/internal/trackers/impl/tl/description_assets_test.go
deleted file mode 100644
index 97c1f6e5..00000000
--- a/internal/trackers/impl/tl/description_assets_test.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tl
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildDescriptionUsesPreparedDiscMenuAssets(t *testing.T) {
-	t.Parallel()
-
-	assets := trackers.DescriptionAssets{
-		Description: "Body token",
-		MenuImages:  []api.ScreenshotImage{{RawURL: "https://images.example.invalid/menu.png"}},
-		Screenshots: []api.ScreenshotImage{{RawURL: "https://images.example.invalid/normal.png"}},
-	}
-	result, err := (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{
-		Tracker: "TL",
-		AppConfig: config.Config{Description: config.DescriptionSettingsConfig{
-			DiscMenuHeader:   "Disc menu token",
-			ScreenshotHeader: "Screenshots token",
-		}},
-		Assets: &assets,
-	})
-	if err != nil {
-		t.Fatalf("build description: %v", err)
-	}
-	assertDescriptionTokensInOrder(t, result.Description, "Body token", "Disc menu token", "menu.png", "Screenshots token", "normal.png")
-
-	final := trackers.DescriptionAssets{Description: " Authoritative final token ", Final: true, MenuImages: assets.MenuImages}
-	result, err = (definition{}).BuildDescription(context.Background(), trackers.DescriptionRequest{Tracker: "TL", Assets: &final})
-	if err != nil {
-		t.Fatalf("build final description: %v", err)
-	}
-	if result.Description != "Authoritative final token" {
-		t.Fatalf("final description = %q", result.Description)
-	}
-}
-
-func assertDescriptionTokensInOrder(t *testing.T, description string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		position := strings.Index(description, token)
-		if position <= previous {
-			t.Fatalf("description tokens out of order at %q: %q", token, description)
-		}
-		previous = position
-	}
-}
diff --git a/internal/trackers/impl/tl/upload.go b/internal/trackers/impl/tl/upload.go
deleted file mode 100644
index 3d7b2991..00000000
--- a/internal/trackers/impl/tl/upload.go
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tl
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"maps"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/cookies"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL       = "https://www.torrentleech.org"
-	apiUploadURL  = baseURL + "/torrents/upload/apiupload"
-	httpUploadURL = baseURL + "/torrents/upload/"
-	torrentURL    = baseURL + "/torrent/"
-	sourceFlag    = "TorrentLeech.org"
-)
-
-type uploadState struct {
-	torrentPath string
-	description string
-	releaseName string
-	fields      map[string]string
-	files       []commonhttp.FileField
-	endpoint    string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, client, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, state.files)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, state.endpoint, bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TL build upload request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "upbrr")
-
-	resp, err := client.Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TL upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	successCandidate := resp.StatusCode == http.StatusFound || (req.TrackerConfig.APIUpload && resp.StatusCode >= 200 && resp.StatusCode < 300)
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, successCandidate, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TL read upload response: %w", err)
-	}
-
-	torrentID := ""
-	if req.TrackerConfig.APIUpload {
-		text := strings.TrimSpace(string(responseBody))
-		if _, err := strconv.Atoi(text); err == nil {
-			torrentID = text
-		}
-	} else if resp.StatusCode == http.StatusFound {
-		torrentID = strings.TrimPrefix(strings.TrimSpace(resp.Header.Get("Location")), "/successfulupload?torrentID=")
-	}
-	if torrentID == "" {
-		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "TL", "upload_failure", responsePreview, ".html")
-		return api.UploadSummary{}, commonhttp.UploadHTTPError("TL", resp.StatusCode, responsePreview)
-	}
-
-	urlValue := torrentURL + torrentID
-	artifactPath := ""
-	if announces := announceList(req.TrackerConfig); len(announces) > 0 {
-		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "TL")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announces[0], urlValue, sourceFlag); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-	return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
-		Tracker: "TL", TorrentID: torrentID, TorrentURL: urlValue, DownloadURL: urlValue, TorrentPath: artifactPath,
-	}}}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, _, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "TL",
-		Status:           "ready",
-		Message:          "dry-run payload generated",
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "tl",
-		Description:      state.description,
-		Endpoint:         state.endpoint,
-		Payload:          cloneFields(state.fields),
-		Files:            []api.TrackerDryRunFile{{Field: "torrent", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, *http.Client, error) {
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssetsWithPrepared(ctx, req.Tracker, req.Meta, req.Repo, req.Logger, req.Assets)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req, assets)
-
-	releaseName := resolveName(req.Meta)
-	state := uploadState{
-		torrentPath: torrentPath,
-		description: description,
-		releaseName: releaseName,
-	}
-
-	if req.TrackerConfig.APIUpload {
-		state.endpoint = apiUploadURL
-		state.fields = map[string]string{
-			"announcekey": announceKey(req.TrackerConfig),
-			"category":    resolveCategory(req.Meta),
-			"description": description,
-			"name":        releaseName,
-			"nonscene":    boolWord(!req.Meta.Scene, "on", "off"),
-		}
-		switch {
-		case req.Meta.Anime && req.Meta.ExternalIDs.MALID > 0:
-			state.fields["animeid"] = tlAnimeIDURL(req.Meta.ExternalIDs.MALID)
-		case !isTV(req.Meta) && req.Meta.ExternalIDs.IMDBID > 0:
-			state.fields["imdb"] = fmt.Sprintf("tt%07d", req.Meta.ExternalIDs.IMDBID)
-		case isTV(req.Meta):
-			state.fields["tvmazeid"] = strconv.Itoa(req.Meta.ExternalIDs.TVmazeID)
-			if req.Meta.TVPack {
-				state.fields["tvmazetype"] = "true"
-			}
-		}
-		if req.TrackerConfig.Anon {
-			state.fields["is_anonymous_upload"] = "on"
-		}
-		state.files = []commonhttp.FileField{{
-			FieldName: "torrent",
-			FileName:  releaseName + ".torrent",
-			Path:      torrentPath,
-		}}
-		return state, &http.Client{Timeout: 30 * time.Second}, nil
-	}
-
-	state.endpoint = httpUploadURL
-	state.fields = map[string]string{
-		"name":                releaseName,
-		"category":            resolveCategory(req.Meta),
-		"nonscene":            boolWord(!req.Meta.Scene, "on", "off"),
-		"imdbURL":             imdbURL(req.Meta),
-		"tvMazeURL":           tvmazeURL(req.Meta),
-		"igdbURL":             "",
-		"torrentNFO":          "0",
-		"torrentDesc":         "1",
-		"nfotextbox":          "",
-		"torrentComment":      "0",
-		"uploaderComments":    "",
-		"is_anonymous_upload": boolWord(req.TrackerConfig.Anon, "on", "off"),
-	}
-	if req.TrackerConfig.ImgRehost {
-		for idx, shot := range screenshots(assets.Screenshots) {
-			state.fields["screenshots["+strconv.Itoa(idx)+"]"] = shot
-		}
-	}
-	state.files = []commonhttp.FileField{
-		{FieldName: "torrent", FileName: "torrent.torrent", Path: torrentPath},
-		{FieldName: "nfo", FileName: "description.txt", Content: []byte(description)},
-	}
-	client, err := cookieClient(ctx, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, nil, err
-	}
-	return state, client, nil
-}
-
-// tlAnimeIDURL formats TorrentLeech's animeid field. TL names the value as an
-// AniList URL, while upbrr's canonical MALID carries the same anime identifier
-// for this tracker payload.
-func tlAnimeIDURL(malID int) string {
-	return fmt.Sprintf("https://anilist.co/anime/%d", malID)
-}
-
-func cookieClient(ctx context.Context, dbPath string) (*http.Client, error) {
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return nil, fmt.Errorf("trackers: TL create cookie jar: %w", err)
-	}
-	client := &http.Client{
-		Timeout: 30 * time.Second,
-		Jar:     jar,
-		CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
-			return http.ErrUseLastResponse
-		},
-	}
-	cookies, err := loadCookies(ctx, dbPath)
-	if err != nil {
-		return nil, err
-	}
-	target, _ := url.Parse(baseURL)
-	jar.SetCookies(target, cookies)
-	return client, nil
-}
-
-func buildDescription(req trackers.UploadRequest, assets trackers.DescriptionAssets) string {
-	if assets.Final {
-		return strings.TrimSpace(assets.Description)
-	}
-	meta := req.Meta
-	parts := make([]string, 0, 8)
-
-	// Custom Header
-	if header := strings.TrimSpace(req.AppConfig.Description.CustomDescriptionHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Logo
-	if req.AppConfig.Description.AddLogo {
-		if logo, _ := descriptionunit3d.ResolveLogo(meta, req.AppConfig); logo != "" {
-			parts = append(parts, `<center><img src="`+logo+`" style="max-width: 300px;"></center>`)
-		}
-	}
-
-	// TV Episode details
-	if strings.TrimSpace(meta.EpisodeOverview) != "" {
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeTitle)+"[/center]")
-		parts = append(parts, "[center]"+strings.TrimSpace(meta.EpisodeOverview)+"[/center]")
-	}
-
-	// File information (BDInfo or MediaInfo)
-	if media := trackers.ReadBDinfoOrMediaInfo(req.AppConfig.MainSettings.DBPath, meta); media != "" {
-		parts = append(parts, media)
-	}
-
-	// User description
-	if strings.TrimSpace(assets.Description) != "" {
-		parts = append(parts, strings.TrimSpace(assets.Description))
-	}
-
-	// menu
-	if len(assets.MenuImages) > 0 {
-		// header
-		if header := strings.TrimSpace(req.AppConfig.Description.DiscMenuHeader); header != "" {
-			parts = append(parts, header)
-		}
-		// images
-		if shots := screenshotBlock(assets.MenuImages); shots != "" {
-			parts = append(parts, shots)
-		}
-	}
-	// Screenshot Header
-	if header := strings.TrimSpace(req.AppConfig.Description.ScreenshotHeader); header != "" {
-		parts = append(parts, header)
-	}
-
-	// Tonemapped Header
-	if tonemapHeader := strings.TrimSpace(req.AppConfig.Description.TonemappedHeader); tonemapHeader != "" && descriptionunit3d.ShouldIncludeTonemappedHeader(meta, req.AppConfig, assets.Screenshots) {
-		parts = append(parts, tonemapHeader)
-	}
-
-	// screenshots
-	if shots := screenshotBlock(assets.Screenshots); shots != "" {
-		parts = append(parts, shots)
-	}
-
-	// custom user signature
-	if signature := strings.TrimSpace(req.AppConfig.Description.CustomSignature); signature != "" {
-		parts = append(parts, signature)
-	}
-
-	// upbrr signature
-	link, text := descriptionunit3d.UppbrrSignatureLink()
-	parts = append(parts, fmt.Sprintf("<div style=\"text-align: right; font-size: 11px;\"><a href=\"%s\">%s</a></div>", link, text))
-
-	// finalize description
-	finalDescription := bbcode.FinalizeTrackerDescription("TL", strings.TrimSpace(strings.Join(parts, "\n\n")))
-
-	// save debug description
-	if meta.Options.Debug {
-		descriptionunit3d.SaveDescriptionDebug(meta, "TL", req.AppConfig.MainSettings.DBPath, finalDescription, req.Logger)
-	}
-
-	return finalDescription
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	if meta.Anime {
-		return "34"
-	}
-	if !isTV(meta) {
-		if meta.ExternalMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "en") {
-			return "36"
-		}
-		if containsWord(genresText(meta), "Documentary") {
-			return "29"
-		}
-		if meta.Release.Resolution == "2160p" {
-			return "47"
-		}
-		if strings.EqualFold(meta.DiscType, "BDMV") || strings.EqualFold(meta.Type, "REMUX") && strings.EqualFold(meta.Source, "BluRay") {
-			return "13"
-		}
-		if strings.EqualFold(meta.Type, "ENCODE") && strings.EqualFold(meta.Source, "BluRay") {
-			return "14"
-		}
-		if strings.EqualFold(meta.DiscType, "DVD") || strings.Contains(strings.ToUpper(meta.Source), "DVD") && strings.EqualFold(meta.Type, "REMUX") {
-			return "12"
-		}
-		if strings.Contains(strings.ToUpper(meta.Source), "DVD") || strings.EqualFold(meta.Type, "DVDRIP") {
-			return "11"
-		}
-		if strings.Contains(strings.ToUpper(meta.Type), "WEB") {
-			return "37"
-		}
-		if strings.EqualFold(meta.Type, "HDTV") {
-			return "43"
-		}
-	}
-	if isTV(meta) && meta.ExternalMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "en") {
-		return "44"
-	}
-	if meta.TVPack {
-		return "27"
-	}
-	if isSD(meta.Release.Resolution) {
-		return "26"
-	}
-	return "32"
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	if strings.TrimSpace(meta.SceneName) != "" {
-		return strings.TrimSpace(meta.SceneName)
-	}
-	return strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.ReleaseName, meta.Release.Title, meta.Filename))
-}
-
-func announceKey(cfg config.TrackerConfig) string {
-	return strings.TrimSpace(cfg.Passkey)
-}
-
-func announceList(cfg config.TrackerConfig) []string {
-	passkey := strings.TrimSpace(cfg.Passkey)
-	if passkey == "" {
-		return nil
-	}
-	return []string{
-		"https://tracker.torrentleech.org/a/" + passkey + "/announce",
-		"https://tracker.tleechreload.org/a/" + passkey + "/announce",
-	}
-}
-
-func loadCookies(ctx context.Context, dbPath string) ([]*http.Cookie, error) {
-	return wrapTrackerResult(cookies.LoadTrackerHTTPCookies(ctx, dbPath, "TL", "torrentleech.org"))
-}
-
-func imdbURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.IMDBID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.imdb.com/title/tt%07d", meta.ExternalIDs.IMDBID)
-}
-
-func tvmazeURL(meta api.PreparedMetadata) string {
-	if meta.ExternalIDs.TVmazeID <= 0 {
-		return ""
-	}
-	return fmt.Sprintf("https://www.tvmaze.com/shows/%d", meta.ExternalIDs.TVmazeID)
-}
-
-func screenshots(images []api.ScreenshotImage) []string {
-	out := make([]string, 0, len(images))
-	for _, image := range images {
-		if raw := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(image.RawURL, image.ImgURL)); raw != "" {
-			out = append(out, raw)
-		}
-	}
-	return out
-}
-
-func screenshotBlock(images []api.ScreenshotImage) string {
-	if len(images) == 0 {
-		return ""
-	}
-	parts := []string{"<center>"}
-	for idx, image := range images {
-		img := metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL)
-		web := metautil.FirstNonEmptyTrimmed(image.WebURL, img)
-		if img == "" || web == "" {
-			continue
-		}
-		parts = append(parts, `<a href="`+web+`"><img src="`+img+`" style="max-width: 350px;"></a>`)
-		if (idx+1)%2 == 0 {
-			parts = append(parts, "<br><br>")
-		}
-	}
-	parts = append(parts, "</center>")
-	return strings.Join(parts, "  ")
-}
-
-func containsWord(a string, b string) bool {
-	return strings.Contains(strings.ToLower(a), strings.ToLower(b))
-}
-
-func isSD(res string) bool {
-	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
-}
-
-func boolWord(cond bool, yes string, no string) string {
-	if cond {
-		return yes
-	}
-	return no
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0 || strings.EqualFold(meta.ExternalIDs.Category, "TV")
-}
-
-func genresText(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Genres, meta.Release.Genre)
-}
diff --git a/internal/trackers/impl/tl/wrap_errors.go b/internal/trackers/impl/tl/wrap_errors.go
deleted file mode 100644
index 99d45c4e..00000000
--- a/internal/trackers/impl/tl/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tl
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/tvc/definition.go b/internal/trackers/impl/tvc/definition.go
deleted file mode 100644
index 4d24e6bb..00000000
--- a/internal/trackers/impl/tvc/definition.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tvc
-
-import (
-	"context"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type definition struct{}
-
-func New() trackers.Definition  { return definition{} }
-func (definition) Name() string { return "TVC" }
-
-func (definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	return upload(ctx, req)
-}
-
-func (definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	return buildUploadDryRun(ctx, req)
-}
-
-func (definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, req.TrackerConfig, assets)
-	return trackers.DescriptionResult{Group: "tvc", Description: description}, nil
-}
diff --git a/internal/trackers/impl/tvc/upload.go b/internal/trackers/impl/tvc/upload.go
deleted file mode 100644
index a1bbdec8..00000000
--- a/internal/trackers/impl/tvc/upload.go
+++ /dev/null
@@ -1,419 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tvc
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"maps"
-	"net/http"
-	"net/url"
-	"path" //nolint:depguard // Extracts tracker response URL path basename.
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/services/bbcode"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-const (
-	baseURL    = "https://tvchaosuk.com"
-	uploadURL  = baseURL + "/api/torrents/upload"
-	sourceFlag = "TVCHAOS"
-)
-
-var categoryMap = map[string]string{
-	"comedy": "29", "current affairs": "45", "documentary": "5", "drama": "11", "entertainment": "14",
-	"factual": "19", "foreign": "43", "kids": "32", "movies": "44", "news": "54", "reality": "52", "soaps": "30", "sci-fi": "33", "sport": "42", "holding bin": "53",
-}
-
-type uploadState struct {
-	torrentPath   string
-	description   string
-	releaseName   string
-	fields        map[string]string
-	questionnaire *api.TrackerQuestionnaire
-	blockedReason string
-}
-
-func upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.UploadSummary{}, err
-	}
-	if state.blockedReason != "" {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TVC %s", state.blockedReason)
-	}
-	body, contentType, err := commonhttp.BuildMultipartPayload(state.fields, []commonhttp.FileField{{
-		FieldName: "torrent",
-		FileName:  filepath.Base(state.torrentPath),
-		Path:      state.torrentPath,
-	}})
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL+"?api_token="+url.QueryEscape(strings.TrimSpace(req.TrackerConfig.APIKey)), bytes.NewReader(body))
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TVC build upload request: %s", commonhttp.RedactErrorDetail(err.Error()))
-	}
-	httpReq.Header.Set("Content-Type", contentType)
-	httpReq.Header.Set("User-Agent", "Mozilla/5.0")
-
-	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(httpReq)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TVC upload request: %w", err)
-	}
-	defer resp.Body.Close()
-	responseBody, responsePreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode == http.StatusOK, commonhttp.DefaultResponsePreviewBytes)
-	if err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TVC read upload response: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		_, _ = commonhttp.WriteFailureArtifact(req.Meta, req.AppConfig.MainSettings.DBPath, "TVC", "upload_failure", responsePreview, ".txt")
-		return api.UploadSummary{}, commonhttp.UploadHTTPError("TVC", resp.StatusCode, responsePreview)
-	}
-
-	payload := string(responseBody)
-	if strings.Contains(payload, "\n") {
-		payload = strings.SplitN(payload, "\n", 2)[1]
-	}
-	var decoded map[string]any
-	if err := json.Unmarshal([]byte(payload), &decoded); err != nil {
-		return api.UploadSummary{}, fmt.Errorf("trackers: TVC decode response: %w", err)
-	}
-	dataURL := strings.TrimSpace(fmt.Sprint(decoded["data"]))
-	torrentID := path.Base(strings.TrimRight(dataURL, "/"))
-
-	artifactPath := ""
-	if announce := strings.TrimSpace(req.TrackerConfig.AnnounceURL); announce != "" {
-		artifactPath, err = trackers.ResolveTrackerTorrentArtifactPath(req.Meta, req.AppConfig.MainSettings.DBPath, "TVC")
-		if err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-		if err := trackers.WritePersonalizedTorrent(state.torrentPath, artifactPath, announce, dataURL, sourceFlag); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-		}
-	}
-	return api.UploadSummary{Uploaded: 1, UploadedTorrents: []api.UploadedTorrent{{
-		Tracker: "TVC", TorrentID: torrentID, TorrentURL: dataURL, DownloadURL: dataURL, TorrentPath: artifactPath,
-	}}}, nil
-}
-
-func buildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	state, err := prepareUploadState(ctx, req)
-	if err != nil {
-		return api.TrackerDryRunEntry{}, err
-	}
-	status := "ready"
-	message := "dry-run payload generated"
-	if state.blockedReason != "" {
-		status = "blocked"
-		message = state.blockedReason
-	}
-	return api.TrackerDryRunEntry{
-		Tracker:          "TVC",
-		Status:           status,
-		Message:          message,
-		ReleaseName:      state.releaseName,
-		DescriptionGroup: "tvc",
-		Description:      state.description,
-		Endpoint:         uploadURL,
-		Payload:          cloneFields(state.fields),
-		Questionnaire:    state.questionnaire,
-		Files:            []api.TrackerDryRunFile{{Field: "torrent", Path: state.torrentPath, Present: strings.TrimSpace(state.torrentPath) != ""}},
-	}, nil
-}
-
-func prepareUploadState(ctx context.Context, req trackers.UploadRequest) (uploadState, error) {
-	if strings.TrimSpace(req.TrackerConfig.APIKey) == "" {
-		return uploadState{}, errors.New("trackers: TVC missing api_key")
-	}
-	torrentPath, err := trackers.ResolveUploadTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath)
-	if err != nil {
-		return uploadState{}, fmt.Errorf("trackers: %w", err)
-	}
-	assets, err := trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
-	if err != nil {
-		trackers.LogDescriptionAssetResolutionFailure(req.Logger, req.Tracker, err)
-		assets = trackers.DescriptionAssets{}
-	}
-	description := buildDescription(req.Meta, req.TrackerConfig, assets)
-	releaseName := resolveName(req.Meta)
-	if override := strings.TrimSpace(questionnaireAnswers(req.Meta)["name_override"]); override != "" {
-		releaseName = override
-	}
-
-	fields := map[string]string{
-		"name":             releaseName,
-		"description":      description,
-		"mediainfo":        commonhttp.ReadOptionalFile(strings.TrimSpace(req.Meta.MediaInfoTextPath)),
-		"bdinfo":           "",
-		"category_id":      resolveCategory(req.Meta),
-		"type":             resolveResolution(req.Meta),
-		"tmdb":             strconv.Itoa(req.Meta.ExternalIDs.TMDBID),
-		"imdb":             strconv.Itoa(req.Meta.ExternalIDs.IMDBID),
-		"mal":              strconv.Itoa(req.Meta.ExternalIDs.MALID),
-		"igdb":             "0",
-		"anonymous":        boolNum(req.TrackerConfig.Anon),
-		"stream":           boolNum(req.Meta.StreamOptimized > 0),
-		"sd":               boolNum(isSD(req.Meta.Release.Resolution)),
-		"keywords":         keywordsText(req.Meta),
-		"personal_release": boolNum(req.Meta.PersonalRelease),
-		"internal":         "0",
-		"featured":         "0",
-		"free":             "0",
-		"doubleup":         "0",
-		"sticky":           "0",
-	}
-	if isTV(req.Meta) {
-		if isTVCategory(req.Meta) {
-			fields["tvdb"] = strconv.Itoa(req.Meta.ExternalIDs.TVDBID)
-		}
-		fields["season_number"] = strconv.Itoa(maxInt(req.Meta.SeasonInt, 0))
-		fields["episode_number"] = strconv.Itoa(maxInt(req.Meta.EpisodeInt, 0))
-	}
-
-	return uploadState{
-		torrentPath:   torrentPath,
-		description:   description,
-		releaseName:   releaseName,
-		fields:        fields,
-		questionnaire: buildQuestionnaire(req.Meta),
-		blockedReason: validateUpload(req.Meta, req.TrackerConfig, assets),
-	}, nil
-}
-
-func buildDescription(meta api.PreparedMetadata, cfg config.TrackerConfig, assets trackers.DescriptionAssets) string {
-	parts := make([]string, 0, 6)
-	if logo := strings.TrimSpace(meta.ExternalMetadata.TMDB.Logo); logo != "" {
-		parts = append(parts, fmt.Sprintf("[center][img=%d]%s[/img][/center]", maxInt(cfg.ImageCount, 300), logo))
-	}
-	if title := strings.TrimSpace(meta.EpisodeTitle); title != "" {
-		parts = append(parts, "[center][b]Episode Title:[/b] "+title+"[/center]")
-	}
-	if overview := strings.TrimSpace(metautil.FirstNonEmptyTrimmed(meta.EpisodeOverview, meta.ExternalMetadata.TMDB.Overview)); overview != "" {
-		parts = append(parts, "[center]"+overview+"[/center]")
-	}
-	if links := externalLinks(meta); links != "" {
-		parts = append(parts, "[center]"+links+"[/center]")
-	}
-	if shots := screenshotBlock(assets.Screenshots, maxInt(cfg.ImageCount, 2)); shots != "" {
-		parts = append(parts, "[center]"+shots+"[/center]")
-	}
-	if base := strings.TrimSpace(assets.Description); base != "" {
-		parts = append(parts, "[center][b]Notes / Extra Info[/b]\n"+base+"[/center]")
-	}
-	return bbcode.FinalizeTrackerDescription("TVC", strings.TrimSpace(strings.Join(parts, "\n\n")))
-}
-
-func buildQuestionnaire(meta api.PreparedMetadata) *api.TrackerQuestionnaire {
-	return &api.TrackerQuestionnaire{
-		Tracker: "TVC",
-		Fields: []api.TrackerQuestionnaireField{{
-			Key: "name_override", Label: "Upload Name", Kind: "text", Value: resolveName(meta), Required: true,
-		}},
-	}
-}
-
-func validateUpload(meta api.PreparedMetadata, cfg config.TrackerConfig, assets trackers.DescriptionAssets) string {
-	if meta.Release.Resolution == "2160p" || strings.EqualFold(meta.DiscType, "BDMV") || strings.EqualFold(meta.Type, "REMUX") {
-		return "TVC disallows UHD, disc, and remux uploads"
-	}
-	required := maxInt(cfg.ImageCount, 2)
-	if len(assets.Screenshots) < required {
-		return fmt.Sprintf("TVC requires at least %d screenshots", required)
-	}
-	for _, image := range assets.Screenshots {
-		host := strings.ToLower(strings.TrimSpace(imagehost.ExtractHost(metautil.FirstNonEmptyTrimmed(image.WebURL, image.ImgURL, image.RawURL))))
-		switch host {
-		case "imgbb", "imgbox", "pixhost", "bam", "onlyimage":
-		default:
-			return "TVC screenshots must use an approved image host"
-		}
-	}
-	return ""
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB.OriginalLanguage != "" && !strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "en") &&
-		!strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "ga") &&
-		!strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "gd") &&
-		!strings.EqualFold(meta.ExternalMetadata.TMDB.OriginalLanguage, "cy") {
-		return categoryMap["foreign"]
-	}
-	genres := strings.ToLower(genresText(meta))
-	for key, value := range categoryMap {
-		if key != "foreign" && strings.Contains(genres, key) {
-			return value
-		}
-	}
-	if !isTV(meta) {
-		return categoryMap["movies"]
-	}
-	return categoryMap["holding bin"]
-}
-
-func resolveResolution(meta api.PreparedMetadata) string {
-	if meta.TVPack {
-		switch meta.Release.Resolution {
-		case "1080p", "1080i":
-			return "HD1080p Pack"
-		case "720p":
-			return "HD720p Pack"
-		default:
-			return "SD Pack"
-		}
-	}
-	switch meta.Release.Resolution {
-	case "1080p", "1080i":
-		return "HD1080p"
-	case "720p":
-		return "HD720p"
-	default:
-		return "SD"
-	}
-}
-
-func resolveName(meta api.PreparedMetadata) string {
-	typeName := strings.ReplaceAll(meta.Type, "WEBDL", "WEB-DL")
-	var name string
-	switch {
-	case !isTV(meta):
-		name = fmt.Sprintf("%s (%d) [%s %s %s]", metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName), maxInt(meta.Release.Year, meta.ExternalMetadata.TMDB.Year), meta.Release.Resolution, typeName, videoSuffix(meta.VideoCodec))
-	case meta.TVPack:
-		name = fmt.Sprintf("%s - Series %d (%d) [%s %s %s]", metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName), maxInt(meta.SeasonInt, 1), maxInt(meta.Release.Year, meta.ExternalMetadata.TMDB.Year), meta.Release.Resolution, typeName, videoSuffix(meta.VideoCodec))
-	default:
-		name = fmt.Sprintf("%s S%02dE%02d [%s %s %s]", metautil.FirstNonEmptyTrimmed(meta.Release.Title, meta.ReleaseName), maxInt(meta.SeasonInt, 1), maxInt(meta.EpisodeInt, 1), meta.Release.Resolution, typeName, videoSuffix(meta.VideoCodec))
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.VideoCodec), "HEVC") {
-		name = strings.Replace(name, "]", " HEVC]", 1)
-	}
-	return appendCountryCode(meta, name)
-}
-
-func appendCountryCode(meta api.PreparedMetadata, name string) string {
-	mapping := map[string]string{"AT": "AUT", "AU": "AUS", "BE": "BEL", "CA": "CAN", "CH": "CHE", "CZ": "CZE", "DE": "GER", "DK": "DNK", "EE": "EST", "ES": "SPA", "FI": "FIN", "FR": "FRA", "IE": "IRL", "IS": "ISL", "IT": "ITA", "NL": "NLD", "NO": "NOR", "NZ": "NZL", "PL": "POL", "PT": "POR", "RU": "RUS", "SE": "SWE"}
-	for _, code := range meta.ExternalMetadata.TMDB.OriginCountry {
-		if mapped := mapping[strings.ToUpper(strings.TrimSpace(code))]; mapped != "" {
-			return name + " [" + mapped + "]"
-		}
-	}
-	return name
-}
-
-func externalLinks(meta api.PreparedMetadata) string {
-	parts := make([]string, 0, 3)
-	if meta.ExternalIDs.TMDBID > 0 {
-		parts = append(parts, fmt.Sprintf("[url=https://www.themoviedb.org/%s/%d]TMDB[/url]", strings.ToLower(categoryName(meta)), meta.ExternalIDs.TMDBID))
-	}
-	if meta.ExternalIDs.IMDBID > 0 {
-		parts = append(parts, fmt.Sprintf("[url=https://www.imdb.com/title/tt%07d]IMDb[/url]", meta.ExternalIDs.IMDBID))
-	}
-	if isTVCategory(meta) && meta.ExternalIDs.TVDBID > 0 {
-		parts = append(parts, fmt.Sprintf("[url=https://www.thetvdb.com/?id=%d&tab=series]TVDB[/url]", meta.ExternalIDs.TVDBID))
-	}
-	return strings.Join(parts, " | ")
-}
-
-func screenshotBlock(images []api.ScreenshotImage, count int) string {
-	if len(images) < count {
-		return ""
-	}
-	parts := []string{"[b]Screenshots[/b]"}
-	for _, image := range images[:count] {
-		web := metautil.FirstNonEmptyTrimmed(image.WebURL, image.ImgURL, image.RawURL)
-		img := metautil.FirstNonEmptyTrimmed(image.ImgURL, image.RawURL)
-		if web == "" || img == "" {
-			continue
-		}
-		parts = append(parts, fmt.Sprintf("[url=%s][img=350]%s[/img][/url]", web, img))
-	}
-	return strings.Join(parts, " ")
-}
-
-func questionnaireAnswers(meta api.PreparedMetadata) map[string]string {
-	if len(meta.TrackerQuestionnaireAnswers) == 0 {
-		return nil
-	}
-	return meta.TrackerQuestionnaireAnswers["TVC"]
-}
-
-func maxInt(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-func boolNum(v bool) string {
-	if v {
-		return "1"
-	}
-	return "0"
-}
-
-func isSD(res string) bool {
-	return strings.HasPrefix(res, "480") || strings.HasPrefix(res, "576") || strings.HasPrefix(res, "540")
-}
-
-func videoSuffix(codec string) string {
-	value := strings.ToUpper(strings.TrimSpace(codec))
-	if len(value) <= 3 {
-		return value
-	}
-	return value[len(value)-3:]
-}
-
-func cloneFields(input map[string]string) map[string]string {
-	out := make(map[string]string, len(input))
-	maps.Copy(out, input)
-	return out
-}
-
-func isTV(meta api.PreparedMetadata) bool {
-	return isTVCategory(meta)
-}
-
-// isTVCategory reports whether TVC payloads may include TVDB-specific fields.
-// Explicit movie categories suppress TVDB fields; otherwise TVPack, episode data, and MediaInfo TV are enough.
-func isTVCategory(meta api.PreparedMetadata) bool {
-	if isMovieCategory(meta) {
-		return false
-	}
-	return strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "TV") ||
-		meta.TVPack || meta.SeasonInt > 0 || meta.EpisodeInt > 0
-}
-
-func isMovieCategory(meta api.PreparedMetadata) bool {
-	return strings.EqualFold(strings.TrimSpace(meta.ExternalIDs.Category), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "MOVIE") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Category), "MOVIE")
-}
-
-func categoryName(meta api.PreparedMetadata) string {
-	if isTV(meta) {
-		return "TV"
-	}
-	return "MOVIE"
-}
-
-func genresText(meta api.PreparedMetadata) string {
-	return metautil.FirstNonEmptyTrimmed(meta.ExternalMetadata.TMDB.Genres, meta.Release.Genre)
-}
-
-func keywordsText(meta api.PreparedMetadata) string {
-	return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
-}
diff --git a/internal/trackers/impl/tvc/upload_test.go b/internal/trackers/impl/tvc/upload_test.go
deleted file mode 100644
index 2a20059f..00000000
--- a/internal/trackers/impl/tvc/upload_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package tvc
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestPrepareUploadStateSkipsTVDBForMovie(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "movie.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	state, err := prepareUploadState(context.Background(), trackers.UploadRequest{
-		Tracker: "TVC",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Movie.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoCategory: "TV",
-			ExternalIDs: api.ExternalIDs{
-				Category: "MOVIE",
-				TMDBID:   123,
-				TVDBID:   456,
-			},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Title: "Movie", Year: 2025},
-			},
-			Release: api.ReleaseInfo{Title: "Movie", Year: 2025, Resolution: "1080p"},
-			Type:    "WEBDL",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("prepare upload state: %v", err)
-	}
-	if _, ok := state.fields["tvdb"]; ok {
-		t.Fatalf("did not expect tvdb for movie payload")
-	}
-}
-
-func TestPrepareUploadStateIncludesTVDBForTV(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "show.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	state, err := prepareUploadState(context.Background(), trackers.UploadRequest{
-		Tracker: "TVC",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Show.S02E03.mkv"),
-			TorrentPath: torrentPath,
-			ExternalIDs: api.ExternalIDs{
-				Category: "TV",
-				TMDBID:   123,
-				TVDBID:   456,
-			},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
-			},
-			Release:    api.ReleaseInfo{Title: "Show", Year: 2025, Resolution: "1080p"},
-			Type:       "WEBDL",
-			SeasonInt:  2,
-			EpisodeInt: 3,
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("prepare upload state: %v", err)
-	}
-	if got := state.fields["tvdb"]; got != "456" {
-		t.Fatalf("expected tvdb=456, got %q", got)
-	}
-}
-
-func TestPrepareUploadStateIncludesTVDBForMediaInfoTV(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "show.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	state, err := prepareUploadState(context.Background(), trackers.UploadRequest{
-		Tracker: "TVC",
-		Meta: api.PreparedMetadata{
-			SourcePath:        filepath.Join(tmp, "Show.mkv"),
-			TorrentPath:       torrentPath,
-			MediaInfoCategory: "TV",
-			ExternalIDs:       api.ExternalIDs{TMDBID: 123, TVDBID: 456},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
-			},
-			Release: api.ReleaseInfo{Title: "Show", Year: 2025, Resolution: "1080p"},
-			Type:    "WEBDL",
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("prepare upload state: %v", err)
-	}
-	if got := state.fields["tvdb"]; got != "456" {
-		t.Fatalf("expected tvdb=456, got %q", got)
-	}
-}
-
-func TestPrepareUploadStateIncludesTVDBForSeasonPackWithoutCategory(t *testing.T) {
-	tmp := t.TempDir()
-	torrentPath := filepath.Join(tmp, "season.torrent")
-	if err := os.WriteFile(torrentPath, []byte("dummy"), 0o600); err != nil {
-		t.Fatalf("write torrent: %v", err)
-	}
-
-	state, err := prepareUploadState(context.Background(), trackers.UploadRequest{
-		Tracker: "TVC",
-		Meta: api.PreparedMetadata{
-			SourcePath:  filepath.Join(tmp, "Show.S02.mkv"),
-			TorrentPath: torrentPath,
-			ExternalIDs: api.ExternalIDs{
-				TMDBID: 123,
-				TVDBID: 456,
-			},
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Title: "Show", Year: 2025},
-			},
-			Release:   api.ReleaseInfo{Title: "Show", Year: 2025, Resolution: "1080p"},
-			Type:      "WEBDL",
-			TVPack:    true,
-			SeasonInt: 2,
-		},
-		TrackerConfig: config.TrackerConfig{APIKey: "token"},
-	})
-	if err != nil {
-		t.Fatalf("prepare upload state: %v", err)
-	}
-	if got := state.fields["tvdb"]; got != "456" {
-		t.Fatalf("expected tvdb=456, got %q", got)
-	}
-}
diff --git a/internal/trackers/impl/unit3d/a4k.go b/internal/trackers/impl/unit3d/a4k.go
deleted file mode 100644
index 73888bee..00000000
--- a/internal/trackers/impl/unit3d/a4k.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteA4KProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DA4KTypeID,
-		resolveResolutionID: resolveUnit3DA4KResolutionID,
-	}
-}
-
-func resolveUnit3DA4KTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"WEBDL":  "4",
-		"ENCODE": "3",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
-
-func resolveUnit3DA4KResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/acm.go b/internal/trackers/impl/unit3d/acm.go
deleted file mode 100644
index 49f96d65..00000000
--- a/internal/trackers/impl/unit3d/acm.go
+++ /dev/null
@@ -1,515 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/config"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	acmSceneNFOPattern = regexp.MustCompile(`(?is)\[center\]\[spoiler=Scene NFO:\].*?\[/center\]`)
-	acmSubtitleCodes   = map[string]string{
-		"arabic":                "Ara",
-		"ara":                   "Ara",
-		"ar":                    "Ara",
-		"brazilian portuguese":  "Por-BR",
-		"brazilian":             "Por-BR",
-		"portuguese-br":         "Por-BR",
-		"pt-br":                 "Por-BR",
-		"bulgarian":             "Bul",
-		"bul":                   "Bul",
-		"bg":                    "Bul",
-		"chinese":               "Chi",
-		"chi":                   "Chi",
-		"zh":                    "Chi",
-		"chinese (simplified)":  "Chi",
-		"chinese (traditional)": "Chi",
-		"croatian":              "Cro",
-		"hrv":                   "Cro",
-		"hr":                    "Cro",
-		"scr":                   "Cro",
-		"czech":                 "Cze",
-		"cze":                   "Cze",
-		"cz":                    "Cze",
-		"cs":                    "Cze",
-		"danish":                "Dan",
-		"dan":                   "Dan",
-		"da":                    "Dan",
-		"dutch":                 "Dut",
-		"dut":                   "Dut",
-		"nl":                    "Dut",
-		"english":               "Eng",
-		"eng":                   "Eng",
-		"en":                    "Eng",
-		"english (cc)":          "Eng",
-		"english - sdh":         "Eng",
-		"english - forced":      "Eng",
-		"english (forced)":      "Eng",
-		"en (forced)":           "Eng",
-		"english intertitles":   "Eng",
-		"english (intertitles)": "Eng",
-		"english - intertitles": "Eng",
-		"en (intertitles)":      "Eng",
-		"estonian":              "Est",
-		"est":                   "Est",
-		"et":                    "Est",
-		"finnish":               "Fin",
-		"fin":                   "Fin",
-		"fi":                    "Fin",
-		"french":                "Fre",
-		"fre":                   "Fre",
-		"fr":                    "Fre",
-		"german":                "Ger",
-		"ger":                   "Ger",
-		"de":                    "Ger",
-		"greek":                 "Gre",
-		"gre":                   "Gre",
-		"el":                    "Gre",
-		"hebrew":                "Heb",
-		"heb":                   "Heb",
-		"he":                    "Heb",
-		"hindi":                 "Hin",
-		"hin":                   "Hin",
-		"hi":                    "Hin",
-		"hungarian":             "Hun",
-		"hun":                   "Hun",
-		"hu":                    "Hun",
-		"icelandic":             "Ice",
-		"ice":                   "Ice",
-		"is":                    "Ice",
-		"indonesian":            "Ind",
-		"ind":                   "Ind",
-		"id":                    "Ind",
-		"italian":               "Ita",
-		"ita":                   "Ita",
-		"it":                    "Ita",
-		"japanese":              "Jpn",
-		"jpn":                   "Jpn",
-		"ja":                    "Jpn",
-		"korean":                "Kor",
-		"kor":                   "Kor",
-		"ko":                    "Kor",
-		"latvian":               "Lav",
-		"lav":                   "Lav",
-		"lv":                    "Lav",
-		"lithuanian":            "Lit",
-		"lit":                   "Lit",
-		"lt":                    "Lit",
-		"norwegian":             "Nor",
-		"nor":                   "Nor",
-		"no":                    "Nor",
-		"persian":               "Per",
-		"fa":                    "Per",
-		"far":                   "Per",
-		"polish":                "Pol",
-		"pol":                   "Pol",
-		"pl":                    "Pol",
-		"portuguese":            "Por",
-		"por":                   "Por",
-		"pt":                    "Por",
-		"romanian":              "Rom",
-		"rum":                   "Rom",
-		"ro":                    "Rom",
-		"russian":               "Rus",
-		"rus":                   "Rus",
-		"ru":                    "Rus",
-		"serbian":               "Ser",
-		"srp":                   "Ser",
-		"sr":                    "Ser",
-		"scc":                   "Ser",
-		"slovak":                "Slo",
-		"slo":                   "Slo",
-		"sk":                    "Slo",
-		"slovenian":             "Slv",
-		"slv":                   "Slv",
-		"sl":                    "Slv",
-		"spanish":               "Spa",
-		"spa":                   "Spa",
-		"es":                    "Spa",
-		"swedish":               "Swe",
-		"swe":                   "Swe",
-		"sv":                    "Swe",
-		"thai":                  "Tha",
-		"tha":                   "Tha",
-		"th":                    "Tha",
-		"turkish":               "Tur",
-		"tur":                   "Tur",
-		"tr":                    "Tur",
-		"ukrainian":             "Ukr",
-		"ukr":                   "Ukr",
-		"uk":                    "Ukr",
-		"vietnamese":            "Vie",
-		"vie":                   "Vie",
-		"vi":                    "Vie",
-	}
-)
-
-func siteACMProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DACMTypeID,
-		resolveResolutionID: resolveUnit3DACMResolutionID,
-		applyAdditionalPayload: func(req trackers.UploadRequest, data map[string]string) {
-			if regionID := numericValue(req.Meta.Region); regionID != "" {
-				data["region_id"] = regionID
-			}
-			if distributorID := numericValue(req.Meta.Distributor); distributorID != "" {
-				data["distributor_id"] = distributorID
-			}
-		},
-	}
-}
-
-func resolveUnit3DACMTypeID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		sizeBucket := acmDiscBucket(meta.SourceSize)
-		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && sizeBucket != 25 {
-			switch sizeBucket {
-			case 50:
-				return "3"
-			case 66:
-				return "2"
-			case 100:
-				return "1"
-			}
-		}
-		switch sizeBucket {
-		case 25:
-			return "5"
-		case 50:
-			return "4"
-		}
-		return "0"
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		switch acmDVDType(meta) {
-		case "DVD 5":
-			return "14"
-		case "DVD 9":
-			return "16"
-		default:
-			return "0"
-		}
-	}
-
-	switch acmNonDiscType(meta) {
-	case "UHD REMUX":
-		return "12"
-	case "REMUX":
-		return "7"
-	case "WEBDL":
-		return "9"
-	case "SDTV":
-		return "13"
-	case "HDTV":
-		return "17"
-	default:
-		return "0"
-	}
-}
-
-func resolveUnit3DACMResolutionID(meta api.PreparedMetadata) string {
-	switch strings.ToLower(strings.TrimSpace(resolveResolution(meta))) {
-	case "2160p":
-		return "1"
-	case "1080p", "1080i":
-		return "2"
-	case "720p":
-		return "3"
-	case "576p", "576i":
-		return "4"
-	case "480p", "480i":
-		return "5"
-	default:
-		return "10"
-	}
-}
-
-func buildACMName(meta api.PreparedMetadata) string {
-	name := baseReleaseName(meta)
-	if name == "" {
-		return ""
-	}
-
-	title := strings.TrimSpace(resolveACMTitle(meta))
-	originalTitle := strings.TrimSpace(resolveACMOriginalTitle(meta))
-	if title != "" && originalTitle != "" && !strings.EqualFold(title, originalTitle) {
-		name = strings.Replace(name, title, title+" / "+originalTitle+" \u202A", 1)
-	}
-
-	audio := strings.TrimSpace(meta.Audio)
-	if strings.Contains(audio, "AAC") {
-		normalizedAudio := strings.Join(strings.Fields(audio), " ")
-		name = strings.Replace(name, normalizedAudio, strings.ReplaceAll(normalizedAudio, "AAC ", "AAC"), 1)
-	}
-	name = strings.ReplaceAll(name, "DD+ ", "DD+")
-	name = strings.ReplaceAll(name, "UHD BluRay REMUX", "Remux")
-	name = strings.ReplaceAll(name, "BluRay REMUX", "Remux")
-	name = strings.ReplaceAll(name, "H.265", "HEVC")
-	name = strings.ReplaceAll(name, " Atmos", "")
-
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		source := strings.TrimSpace(meta.Source)
-		resolution := strings.TrimSpace(resolveResolution(meta))
-		if source != "" && resolution != "" {
-			name = strings.ReplaceAll(name, source+" DVD5", resolution+" DVD "+source)
-			name = strings.ReplaceAll(name, source+" DVD9", resolution+" DVD "+source)
-		}
-		if audio != "" && audio == strings.TrimSpace(meta.Channels) {
-			name = strings.ReplaceAll(name, audio, "MPEG "+audio)
-		}
-	}
-
-	return strings.TrimSpace(strings.Join(strings.Fields(name), " ")) + acmSubtitleTag(acmSubtitleCodesFor(meta))
-}
-
-func buildACMDescription(ctx context.Context, meta api.PreparedMetadata, appConfig config.Config, trackerConfig config.TrackerConfig, logger api.Logger, keptDescription string, menuImages []api.ScreenshotImage, screenshots []api.ScreenshotImage) (string, error) {
-	base := acmSceneNFOPattern.ReplaceAllString(strings.TrimSpace(keptDescription), "")
-	base = strings.ReplaceAll(base, "\r\n", "\n")
-	base = strings.ReplaceAll(base, "[pre]", "[code]")
-	base = strings.ReplaceAll(base, "[/pre]", "[/code]")
-	base = strings.ReplaceAll(base, "[hide", "[spoiler")
-	base = strings.ReplaceAll(base, "[/hide]", "[/spoiler]")
-	base = convertACMComparisonToCollapse(base, 1000)
-	base = strings.ReplaceAll(base, "[img]", "[img=300]")
-	base = descriptionunit3d.AppendDVDVOBMediaInfoBlock(base, meta)
-
-	cfg := appConfig
-	if cfg.Description.ThumbnailSize <= 0 {
-		cfg.Description.ThumbnailSize = 350
-	}
-	if len(screenshots) > 0 {
-		cfg.Description.ScreensPerRow = strconv.Itoa(len(screenshots))
-	} else if strings.TrimSpace(cfg.Description.ScreensPerRow) == "" {
-		cfg.Description.ScreensPerRow = "1"
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" {
-		header := fmt.Sprintf(
-			"[center][b][color=#ff00ff][size=18]This release is sourced from %s and is not transcoded, just remuxed from the direct %s stream[/size][/color][/b][/center]",
-			strings.TrimSpace(meta.ServiceLongName),
-			strings.TrimSpace(meta.ServiceLongName),
-		)
-		base = strings.TrimSpace(strings.Join([]string{header, base}, "\n"))
-	}
-
-	return wrapTrackerResult(descriptionunit3d.BuildDescription(ctx, meta, cfg, trackerConfig, logger, base, menuImages, screenshots))
-}
-
-func resolveACMKeywords(meta api.PreparedMetadata) string {
-	raw := resolveKeywords(meta)
-	if raw == "" {
-		return ""
-	}
-	parts := strings.Split(raw, ",")
-	filtered := make([]string, 0, len(parts))
-	for _, part := range parts {
-		trimmed := strings.TrimSpace(part)
-		if trimmed == "" || strings.Contains(trimmed, " ") {
-			continue
-		}
-		filtered = append(filtered, trimmed)
-		if len(filtered) >= 10 {
-			break
-		}
-	}
-	return strings.Join(filtered, ", ")
-}
-
-func acmDiscBucket(sourceSize int64) int {
-	if sourceSize <= 0 {
-		return 100
-	}
-	sizeGiB := float64(sourceSize) / float64(1<<30)
-	for _, bucket := range []int{25, 50, 66, 100} {
-		if sizeGiB < float64(bucket) {
-			return bucket
-		}
-	}
-	return 100
-}
-
-func acmDVDType(meta api.PreparedMetadata) string {
-	name := strings.ToUpper(strings.TrimSpace(baseReleaseName(meta)))
-	switch {
-	case strings.Contains(name, "DVD5"):
-		return "DVD 5"
-	case strings.Contains(name, "DVD9"):
-		return "DVD 9"
-	case meta.SourceSize > 0 && meta.SourceSize <= 5*(1<<30):
-		return "DVD 5"
-	case meta.SourceSize > 0:
-		return "DVD 9"
-	default:
-		return ""
-	}
-}
-
-func acmNonDiscType(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(inferUnit3DType(meta)), "REMUX") && strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") {
-		return "UHD REMUX"
-	}
-	switch strings.ToUpper(strings.TrimSpace(inferUnit3DType(meta))) {
-	case "WEBDL", "WEB-DL":
-		return "WEBDL"
-	case "HDTV":
-		if strings.HasPrefix(strings.TrimSpace(resolveResolution(meta)), "4") || strings.HasPrefix(strings.TrimSpace(resolveResolution(meta)), "5") {
-			return "SDTV"
-		}
-		return "HDTV"
-	case "REMUX":
-		return "REMUX"
-	default:
-		return ""
-	}
-}
-
-func resolveACMTitle(meta api.PreparedMetadata) string {
-	for _, value := range []string{
-		meta.Release.Title,
-		resolveACMTMDBTitle(meta),
-		resolveACMIMDBTitle(meta),
-	} {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func resolveACMOriginalTitle(meta api.PreparedMetadata) string {
-	for _, value := range []string{
-		resolveACMTMDBOriginalTitle(meta),
-		resolveACMTMDBRetrievedAKA(meta),
-		resolveACMIMDBAKA(meta),
-		meta.Release.Alt,
-	} {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return strings.TrimPrefix(trimmed, "AKA ")
-		}
-	}
-	return ""
-}
-
-func acmSubtitleCodesFor(meta api.PreparedMetadata) []string {
-	out := make([]string, 0, len(meta.SubtitleLanguages))
-	seen := make(map[string]struct{}, len(meta.SubtitleLanguages))
-	for _, language := range meta.SubtitleLanguages {
-		key := strings.ToLower(strings.TrimSpace(language))
-		if key == "" {
-			continue
-		}
-		code, ok := acmSubtitleCodes[key]
-		if !ok {
-			continue
-		}
-		if _, exists := seen[code]; exists {
-			continue
-		}
-		seen[code] = struct{}{}
-		out = append(out, code)
-	}
-	return out
-}
-
-func acmSubtitleTag(subtitles []string) string {
-	if len(subtitles) == 0 {
-		return " [No subs]"
-	}
-	if slices.Contains(subtitles, "Eng") {
-		return ""
-	}
-	if len(subtitles) > 1 {
-		return " [No Eng subs]"
-	}
-	return " [" + subtitles[0] + " subs only]"
-}
-
-// convertACMComparisonToCollapse rewrites UNIT3D comparison blocks into ACM
-// spoiler markup while leaving malformed blocks unchanged when no image URLs
-// can be paired with the source labels.
-func convertACMComparisonToCollapse(value string, maxWidth int) string {
-	re := regexp.MustCompile(`(?is)\[comparison=[\s\S]*?\[/comparison\]`)
-	return re.ReplaceAllStringFunc(value, func(block string) string {
-		parts := strings.SplitN(block, "]", 2)
-		if len(parts) < 2 {
-			return block
-		}
-		sources := strings.Split(strings.ReplaceAll(strings.TrimPrefix(parts[0], "[comparison="), " ", ""), ",")
-		if len(sources) == 0 {
-			return block
-		}
-		imgSize := min(maxWidth/len(sources), 350)
-		body := strings.TrimSuffix(parts[1], "[/comparison]")
-		fields := strings.Fields(strings.ReplaceAll(body, ",", " "))
-		images := make([]string, 0, len(fields))
-		for _, field := range fields {
-			trimmed := strings.TrimSpace(field)
-			if strings.HasPrefix(strings.ToLower(trimmed), "http://") || strings.HasPrefix(strings.ToLower(trimmed), "https://") {
-				images = append(images, trimmed)
-			}
-		}
-		if len(images) == 0 {
-			return block
-		}
-		lines := make([]string, 0, len(images)/len(sources)+1)
-		row := make([]string, 0, len(sources))
-		for _, image := range images {
-			row = append(row, fmt.Sprintf("[url=%s][img=%d]%s[/img][/url]", image, imgSize, image))
-			if len(row) == len(sources) {
-				lines = append(lines, strings.Join(row, ""))
-				row = row[:0]
-			}
-		}
-		if len(row) > 0 {
-			lines = append(lines, strings.Join(row, ""))
-		}
-		return fmt.Sprintf("[spoiler=%s][center]%s[/center]\n%s[/spoiler]", strings.Join(sources, " vs "), strings.Join(sources, " | "), strings.Join(lines, "\n"))
-	})
-}
-
-func resolveACMTMDBTitle(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return ""
-	}
-	return meta.ExternalMetadata.TMDB.Title
-}
-
-func resolveACMTMDBOriginalTitle(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return ""
-	}
-	return meta.ExternalMetadata.TMDB.OriginalTitle
-}
-
-func resolveACMTMDBRetrievedAKA(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB == nil {
-		return ""
-	}
-	return meta.ExternalMetadata.TMDB.RetrievedAKA
-}
-
-func resolveACMIMDBTitle(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB == nil {
-		return ""
-	}
-	return meta.ExternalMetadata.IMDB.Title
-}
-
-func resolveACMIMDBAKA(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB == nil {
-		return ""
-	}
-	return meta.ExternalMetadata.IMDB.AKA
-}
diff --git a/internal/trackers/impl/unit3d/additional/common_rules.go b/internal/trackers/impl/unit3d/additional/common_rules.go
deleted file mode 100644
index 0ebaad80..00000000
--- a/internal/trackers/impl/unit3d/additional/common_rules.go
+++ /dev/null
@@ -1,340 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package additional
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var resolutionOrder = map[string]int{
-	"480i":  1,
-	"480p":  2,
-	"576i":  3,
-	"576p":  4,
-	"720p":  5,
-	"1080i": 6,
-	"1080p": 7,
-	"1440p": 8,
-	"2160p": 9,
-	"4320p": 10,
-	"8640p": 11,
-}
-
-func checkLUMEResolution(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	if isDiscType(meta.DiscType) {
-		return Pass()
-	}
-
-	resolution := resolveResolution(meta)
-	if resolution == "" {
-		return Fail("LUME requires a known resolution")
-	}
-	if resolutionOrder[resolution] < resolutionOrder["720p"] {
-		return Fail("LUME only allows SD releases when the content does not have a higher resolution release.")
-	}
-	return Pass()
-}
-
-func checkLUMERequirements(ctx context.Context, meta api.PreparedMetadata, logger api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	if !isDiscType(meta.DiscType) && !strings.EqualFold(strings.TrimSpace(meta.Container), "mkv") {
-		return Fail("LUME only allows MKV containers for non-disc uploads.")
-	}
-	return checkLUMEResolution(ctx, meta, logger)
-}
-
-func checkBHDRequirements(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	switch resolveType(meta) {
-	case "REMUX", "ENCODE", "WEBDL", "WEBRIP":
-		container := strings.ToLower(strings.TrimSpace(meta.Container))
-		if container != "" && container != "mkv" && container != "mp4" {
-			return Fail(fmt.Sprintf("Container %q is not allowed for %s. Only MKV and MP4 are permitted.", meta.Container, resolveType(meta)))
-		}
-	}
-	return Pass()
-}
-
-func checkBLUContainer(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	if isDiscType(meta.DiscType) {
-		return Pass()
-	}
-
-	container := strings.ToLower(strings.TrimSpace(meta.Container))
-	if container == "" {
-		return Pass()
-	}
-
-	allowed := []string{"mkv"}
-	typeValue := resolveType(meta)
-	if typeValue == "HDTV" {
-		allowed = append(allowed, "ts")
-	}
-	if (typeValue == "WEBDL" || typeValue == "HDTV") && isDolbyVisionOnly(meta) {
-		allowed = append(allowed, "mp4")
-	}
-	if containsAny([]string{container}, allowed) {
-		return Pass()
-	}
-	return Fail("BLU requires one of the following containers for this release: " + strings.ToUpper(strings.Join(allowed, ", ")))
-}
-
-func isDolbyVisionOnly(meta api.PreparedMetadata) bool {
-	if meta.WebDV {
-		return true
-	}
-	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
-	return strings.Contains(hdr, "DV") && !strings.Contains(hdr, "HDR")
-}
-
-func checkOTWGenres(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	genres := collectGenres(meta)
-	if !containsAny(genres, []string{"animation", "family"}) {
-		return Fail("Genre does not match Animation or Family for OTW.")
-	}
-
-	if isAdultContent(meta) {
-		return Fail("Adult animation not allowed at OTW.")
-	}
-
-	if containsAny(genres, []string{"reality", "game show", "game-show", "reality tv", "reality television"}) {
-		return Fail("Reality / Game Show content not allowed at OTW.")
-	}
-
-	typeValue := resolveType(meta)
-	group := resolveGroup(meta)
-	if group != "" && typeValue != "WEBDL" && !isDiscType(meta.DiscType) {
-		restricted := map[string]bool{"CMRG": true, "EVO": true, "TERMINAL": true, "VISION": true}
-		if restricted[strings.ToUpper(group)] {
-			return Fail(fmt.Sprintf("Group %s is only allowed for raw type content at OTW", group))
-		}
-	}
-
-	return Pass()
-}
-
-func checkSHRIRegion(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") && !strings.EqualFold(strings.TrimSpace(meta.DiscType), "HDDVD") {
-		return Pass()
-	}
-	if strings.TrimSpace(meta.Region) == "" {
-		return Fail("Region required; skipping SHRI.")
-	}
-	return Pass()
-}
-
-func checkTTRSubtitleOnly(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	if !containsAny(normalizeStrings(meta.Release.Language), []string{"spanish", "es", "spa"}) {
-		return Fail("TTR requires at least one Spanish audio or subtitle track.")
-	}
-	return Pass()
-}
-
-func checkULCXRules(ctx context.Context, meta api.PreparedMetadata, _ api.Logger) Result {
-	select {
-	case <-ctx.Done():
-		return Fail(fmt.Errorf("context canceled: %w", ctx.Err()).Error())
-	default:
-	}
-
-	keywords := collectKeywords(meta)
-	if containsAny(keywords, []string{"concert"}) {
-		return Fail("Concerts not allowed at ULCX.")
-	}
-
-	resolution := resolveResolution(meta)
-	if strings.EqualFold(strings.TrimSpace(meta.VideoCodec), "HEVC") && resolution != "2160p" && !isAnimation(meta) && !isAnime(meta) {
-		return Fail("This content might not fit HEVC rules for ULCX.")
-	}
-
-	typeValue := resolveType(meta)
-	if (typeValue == "ENCODE" || typeValue == "HDTV") && resolutionOrder[resolution] < resolutionOrder["720p"] {
-		return Fail("Encodes must be at least 720p resolution for ULCX.")
-	}
-
-	if typeValue == "DVDRIP" {
-		return Fail("DVDRIPs are not allowed for ULCX.")
-	}
-
-	return Pass()
-}
-
-func resolveResolution(meta api.PreparedMetadata) string {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
-	if resolution == "" {
-		resolution = detectResolution(meta.ReleaseName)
-	}
-	return resolution
-}
-
-func detectResolution(value string) string {
-	clean := strings.ToLower(value)
-	for _, candidate := range []string{"8640p", "4320p", "2160p", "1440p", "1080p", "1080i", "720p", "576p", "576i", "480p", "480i"} {
-		if strings.Contains(clean, candidate) {
-			return candidate
-		}
-	}
-	return ""
-}
-
-func resolveType(meta api.PreparedMetadata) string {
-	typeValue := strings.ToUpper(strings.TrimSpace(meta.Type))
-	if typeValue == "" {
-		typeValue = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
-	}
-	return typeValue
-}
-
-func resolveGroup(meta api.PreparedMetadata) string {
-	if group := strings.TrimSpace(meta.Release.Group); group != "" {
-		return group
-	}
-	return strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
-}
-
-func isDiscType(value string) bool {
-	switch strings.ToUpper(strings.TrimSpace(value)) {
-	case "BDMV", "DVD", "HDDVD":
-		return true
-	default:
-		return false
-	}
-}
-
-func isAdultContent(meta api.PreparedMetadata) bool {
-	candidates := append([]string{}, collectGenres(meta)...)
-	candidates = append(candidates, collectKeywords(meta)...)
-	for _, token := range candidates {
-		switch strings.ToLower(strings.TrimSpace(token)) {
-		case "adult", "porn", "pornography", "xxx", "erotic":
-			return true
-		}
-	}
-	return false
-}
-
-func isAnime(meta api.PreparedMetadata) bool {
-	if meta.ExternalMetadata.TMDB != nil && externalMetadataMatchesCurrentSource(meta) && meta.ExternalMetadata.TMDB.Anime {
-		return true
-	}
-	return containsAny(collectKeywords(meta), []string{"anime"})
-}
-
-func isAnimation(meta api.PreparedMetadata) bool {
-	return containsAny(collectGenres(meta), []string{"animation"})
-}
-
-func collectGenres(meta api.PreparedMetadata) []string {
-	values := []string{}
-	values = append(values, splitList(meta.Release.Genre)...)
-	if meta.ExternalMetadata.TMDB != nil && externalMetadataMatchesCurrentSource(meta) {
-		values = append(values, splitList(meta.ExternalMetadata.TMDB.Genres)...)
-	}
-	if meta.ExternalMetadata.IMDB != nil && externalMetadataMatchesCurrentSource(meta) {
-		values = append(values, splitList(meta.ExternalMetadata.IMDB.Genres)...)
-	}
-	return normalizeStrings(values)
-}
-
-func collectKeywords(meta api.PreparedMetadata) []string {
-	values := []string{}
-	if meta.ExternalMetadata.TMDB != nil && externalMetadataMatchesCurrentSource(meta) {
-		values = append(values, splitList(meta.ExternalMetadata.TMDB.Keywords)...)
-	}
-	return normalizeStrings(values)
-}
-
-func externalMetadataMatchesCurrentSource(meta api.PreparedMetadata) bool {
-	storedSource := strings.TrimSpace(meta.ExternalMetadata.SourcePath)
-	return storedSource == "" || strings.EqualFold(storedSource, strings.TrimSpace(meta.SourcePath))
-}
-
-func splitList(value string) []string {
-	if strings.TrimSpace(value) == "" {
-		return nil
-	}
-	parts := strings.Split(value, ",")
-	out := make([]string, 0, len(parts))
-	for _, part := range parts {
-		trimmed := strings.TrimSpace(part)
-		if trimmed != "" {
-			out = append(out, trimmed)
-		}
-	}
-	return out
-}
-
-func normalizeStrings(values []string) []string {
-	out := make([]string, 0, len(values))
-	seen := make(map[string]bool, len(values))
-	for _, value := range values {
-		trimmed := strings.ToLower(strings.TrimSpace(value))
-		if trimmed == "" || seen[trimmed] {
-			continue
-		}
-		seen[trimmed] = true
-		out = append(out, trimmed)
-	}
-	return out
-}
-
-func containsAny(values []string, targets []string) bool {
-	if len(values) == 0 || len(targets) == 0 {
-		return false
-	}
-	targetSet := make(map[string]bool, len(targets))
-	for _, target := range targets {
-		targetSet[strings.ToLower(strings.TrimSpace(target))] = true
-	}
-	for _, value := range values {
-		if targetSet[strings.ToLower(strings.TrimSpace(value))] {
-			return true
-		}
-	}
-	return false
-}
diff --git a/internal/trackers/impl/unit3d/additional/rules.go b/internal/trackers/impl/unit3d/additional/rules.go
deleted file mode 100644
index 133b5557..00000000
--- a/internal/trackers/impl/unit3d/additional/rules.go
+++ /dev/null
@@ -1,281 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package additional
-
-import "strings"
-
-var (
-	languagesEnglish = []string{"english", "en", "eng"}
-	languagesFrench  = []string{"french", "fr", "fra", "fre"}
-	languagesGerman  = []string{"german", "ger", "de", "deu", "gsw"}
-	languagesSpanish = []string{"spanish", "es", "spa"}
-	languagesNordic  = []string{
-		"english",
-		"norwegian",
-		"norsk",
-		"no",
-		"nb",
-		"nn",
-		"swedish",
-		"sv",
-		"danish",
-		"da",
-		"finnish",
-		"fi",
-		"icelandic",
-		"is",
-	}
-)
-
-var trackerRuleFactories = map[string]func() RuleSet{
-	"AITHER": rulesAITHER,
-	"ANT":    rulesANT,
-	"A4K":    rulesA4K,
-	"BHD":    rulesBHD,
-	"BLU":    rulesBLU,
-	"DP":     rulesDP,
-	"HHD":    rulesHHD,
-	"LST":    rulesLST,
-	"LUME":   rulesLUME,
-	"MNS":    rulesMNS,
-	"OE":     rulesOE,
-	"OTW":    rulesOTW,
-	"RAS":    rulesRAS,
-	"RF":     rulesRF,
-	"RHD":    rulesRHD,
-	"SHRI":   rulesSHRI,
-	"SP":     rulesSP,
-	"STC":    rulesSTC,
-	"TIK":    rulesTIK,
-	"TOS":    rulesTOS,
-	"TTR":    rulesTTR,
-	"ULCX":   rulesULCX,
-	"NBL":    rulesNBL,
-	"ZNTH":   rulesZNTH,
-}
-
-func RulesFor(tracker string) (RuleSet, bool) {
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	factory, ok := trackerRuleFactories[key]
-	if !ok {
-		return RuleSet{}, false
-	}
-	return factory(), true
-}
-
-func nonDiscEnglishAudioSubsRule() *LanguageRule {
-	return &LanguageRule{
-		Languages:      languagesEnglish,
-		RequireAudio:   true,
-		RequireSubs:    true,
-		AllowOriginal:  true,
-		ApplyIfNonDisc: true,
-	}
-}
-
-func rulesAITHER() RuleSet {
-	return RuleSet{
-		RequireUniqueID: true,
-		Language:        nonDiscEnglishAudioSubsRule(),
-	}
-}
-
-func rulesANT() RuleSet {
-	return RuleSet{RequireMovieOnly: true}
-}
-
-func rulesA4K() RuleSet {
-	return RuleSet{Language: nonDiscEnglishAudioSubsRule()}
-}
-
-func rulesBHD() RuleSet {
-	return RuleSet{
-		RequireValidMISetting: true,
-		BlockAdult:            true,
-		AdultMessage:          "Porn/xxx is not allowed at BHD.",
-		ExtraCheck:            checkBHDRequirements,
-	}
-}
-
-func rulesBLU() RuleSet {
-	return RuleSet{ExtraCheck: checkBLUContainer}
-}
-
-func rulesHHD() RuleSet {
-	return RuleSet{BlockDVDRip: true}
-}
-
-func rulesLST() RuleSet {
-	return RuleSet{
-		RequireValidMISetting: true,
-		Language:              nonDiscEnglishAudioSubsRule(),
-	}
-}
-
-func rulesTIK() RuleSet {
-	return RuleSet{RequireDiscOnly: true}
-}
-
-func rulesNBL() RuleSet {
-	return RuleSet{
-		RequireTVOnly: true,
-		Language: &LanguageRule{
-			Languages:      languagesEnglish,
-			RequireAudio:   true,
-			RequireSubs:    true,
-			AllowOriginal:  true,
-			ApplyIfNonBDMV: true,
-		},
-	}
-}
-
-func rulesDP() RuleSet {
-	return RuleSet{
-		BlockSingleFileFolder: true,
-		BlockHardcodedSubs:    true,
-		BlockGroupUnlessType:  map[string][]string{"EVO": {"WEBDL"}},
-		Language: &LanguageRule{
-			Languages:    languagesNordic,
-			RequireAudio: true,
-			RequireSubs:  true,
-		},
-	}
-}
-
-func rulesLUME() RuleSet {
-	return RuleSet{
-		RequireValidMISetting: true,
-		BlockAdult:            true,
-		AdultMessage:          "Porn is not allowed on LUME.",
-		Language: &LanguageRule{
-			Languages:      languagesEnglish,
-			RequireAudio:   true,
-			RequireSubs:    true,
-			AllowOriginal:  true,
-			ApplyIfNonDisc: true,
-		},
-		ExtraCheck: checkLUMERequirements,
-	}
-}
-
-func rulesMNS() RuleSet {
-	return RuleSet{
-		BlockAdult:   true,
-		AdultMessage: "Adult content is not allowed",
-	}
-}
-
-func rulesOE() RuleSet {
-	return RuleSet{
-		BlockAdult:   true,
-		AdultMessage: "Porn is not allowed",
-		Language: &LanguageRule{
-			Languages:      languagesEnglish,
-			RequireAudio:   true,
-			RequireSubs:    true,
-			ApplyIfNonDisc: true,
-		},
-	}
-}
-
-func rulesOTW() RuleSet {
-	return RuleSet{ExtraCheck: checkOTWGenres}
-}
-
-func rulesRAS() RuleSet {
-	return RuleSet{
-		Language: &LanguageRule{
-			Languages:    languagesNordic,
-			RequireAudio: true,
-			RequireSubs:  true,
-		},
-	}
-}
-
-func rulesRF() RuleSet {
-	return RuleSet{
-		BlockAdult:       true,
-		AdultMessage:     "Porn is not allowed",
-		RequireMovieOnly: true,
-	}
-}
-
-// rulesRHD requires German audio for every upload type, including full discs
-// whose RHD release names do not carry language tags.
-func rulesRHD() RuleSet {
-	return RuleSet{
-		BlockAdult:    true,
-		MinResolution: "720p",
-		Language: &LanguageRule{
-			Languages:    languagesGerman,
-			RequireAudio: true,
-		},
-		RequireSceneNFO: true,
-	}
-}
-
-func rulesSHRI() RuleSet {
-	return RuleSet{ExtraCheck: checkSHRIRegion}
-}
-
-func rulesSP() RuleSet {
-	return RuleSet{
-		BlockAdult:    true,
-		AdultMessage:  "Porn is not allowed",
-		MinResolution: "1080p",
-	}
-}
-
-func rulesSTC() RuleSet {
-	return RuleSet{
-		BlockAdult:    true,
-		AdultMessage:  "Porn is not allowed",
-		RequireTVOnly: true,
-	}
-}
-
-func rulesTOS() RuleSet {
-	return RuleSet{
-		Language: &LanguageRule{
-			Languages:     languagesFrench,
-			RequireAudio:  true,
-			RequireSubs:   true,
-			AllowOriginal: true,
-		},
-		RequireSceneNFO: true,
-	}
-}
-
-func rulesTTR() RuleSet {
-	return RuleSet{
-		Language: &LanguageRule{
-			Languages:    languagesSpanish,
-			RequireAudio: true,
-			RequireSubs:  true,
-		},
-		ExtraCheck: checkTTRSubtitleOnly,
-	}
-}
-
-func rulesULCX() RuleSet {
-	return RuleSet{
-		RequireValidMISetting: true,
-		BlockDVDRip:           true,
-		Language: &LanguageRule{
-			Languages:      languagesEnglish,
-			RequireAudio:   true,
-			RequireSubs:    true,
-			ApplyIfNonDisc: true,
-		},
-		ExtraCheck: checkULCXRules,
-	}
-}
-
-// rulesZNTH blocks adult uploads using ZNTH's tracker-facing rejection text.
-func rulesZNTH() RuleSet {
-	return RuleSet{
-		BlockAdult:   true,
-		AdultMessage: "Porn/xxx is not allowed at ZNTH.",
-	}
-}
diff --git a/internal/trackers/impl/unit3d/additional/types.go b/internal/trackers/impl/unit3d/additional/types.go
deleted file mode 100644
index f217f19c..00000000
--- a/internal/trackers/impl/unit3d/additional/types.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package additional
-
-import (
-	"context"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-type Result struct {
-	Allowed bool
-	Reason  string
-}
-
-func Pass() Result {
-	return Result{Allowed: true}
-}
-
-func Fail(reason string) Result {
-	return Result{Allowed: false, Reason: strings.TrimSpace(reason)}
-}
-
-type ExtraCheck func(ctx context.Context, meta api.PreparedMetadata, logger api.Logger) Result
-
-type LanguageRule struct {
-	Languages      []string
-	RequireAudio   bool
-	RequireSubs    bool
-	RequireBoth    bool
-	AllowOriginal  bool
-	ApplyIfNonDisc bool
-	ApplyIfNonBDMV bool
-}
-
-type RuleSet struct {
-	RequireUniqueID       bool
-	RequireValidMISetting bool
-	RequireAudioLanguages bool
-	RequireDiscOnly       bool
-	RequireMovieOnly      bool
-	RequireTVOnly         bool
-	RequireHEVCForTypes   []string
-	MinResolution         string
-	BlockAdult            bool
-	AdultMessage          string
-	Language              *LanguageRule
-	BlockDVDRip           bool
-	BlockExternalSubs     bool
-	BlockSingleFileFolder bool
-	BlockHardcodedSubs    bool
-	BlockGroups           []string
-	BlockGroupUnlessType  map[string][]string
-	RequireSceneNFO       bool
-	ExtraCheck            ExtraCheck
-}
diff --git a/internal/trackers/impl/unit3d/additional_rules.go b/internal/trackers/impl/unit3d/additional_rules.go
new file mode 100644
index 00000000..55e0ee44
--- /dev/null
+++ b/internal/trackers/impl/unit3d/additional_rules.go
@@ -0,0 +1,150 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var ruleResolutionOrder = map[string]int{
+	"480i":  1,
+	"480p":  2,
+	"576i":  3,
+	"576p":  4,
+	"720p":  5,
+	"1080i": 6,
+	"1080p": 7,
+	"1440p": 8,
+	"2160p": 9,
+	"4320p": 10,
+	"8640p": 11,
+}
+
+// ResolutionBelow reports whether value ranks below minimum in the Unit3D resolution order.
+func ResolutionBelow(value, minimum string) bool {
+	return ruleResolutionOrder[value] < ruleResolutionOrder[minimum]
+}
+
+// RuleType returns the normalized release type used by site-specific rules.
+func RuleType(meta api.RuleSubject) string {
+	value := strings.ToUpper(strings.TrimSpace(meta.Type))
+	if value == "" {
+		value = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
+	}
+	return value
+}
+
+// RuleGroup returns the parsed release group or the normalized tag fallback.
+func RuleGroup(meta api.RuleSubject) string {
+	if group := strings.TrimSpace(meta.Release.Group); group != "" {
+		return group
+	}
+	return strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
+}
+
+// DolbyVisionOnly reports whether the release has Dolby Vision without HDR fallback.
+func DolbyVisionOnly(meta api.RuleSubject) bool {
+	if meta.WebDV {
+		return true
+	}
+	hdr := strings.ToUpper(strings.TrimSpace(meta.HDR))
+	return strings.Contains(hdr, "DV") && !strings.Contains(hdr, "HDR")
+}
+
+// RuleGenres returns normalized current-source release and provider genres.
+func RuleGenres(meta api.RuleSubject) []string {
+	values := splitRuleList(meta.Release.Genre)
+	if ruleMetadataMatchesSource(meta) && meta.ProviderMetadata.TMDB != nil {
+		values = append(values, splitRuleList(meta.ProviderMetadata.TMDB.Genres)...)
+	}
+	if ruleMetadataMatchesSource(meta) && meta.ProviderMetadata.IMDB != nil {
+		values = append(values, splitRuleList(meta.ProviderMetadata.IMDB.Genres)...)
+	}
+	return NormalizeRuleValues(values)
+}
+
+// RuleKeywords returns normalized current-source TMDB keywords.
+func RuleKeywords(meta api.RuleSubject) []string {
+	if !ruleMetadataMatchesSource(meta) || meta.ProviderMetadata.TMDB == nil {
+		return nil
+	}
+	return NormalizeRuleValues(splitRuleList(meta.ProviderMetadata.TMDB.Keywords))
+}
+
+// AdultContent reports whether current genres or keywords contain an adult marker.
+func AdultContent(meta api.RuleSubject) bool {
+	for _, token := range append(RuleGenres(meta), RuleKeywords(meta)...) {
+		switch token {
+		case "adult", "porn", "pornography", "xxx", "erotic":
+			return true
+		}
+	}
+	return false
+}
+
+// Anime reports whether current metadata classifies the release as anime.
+func Anime(meta api.RuleSubject) bool {
+	if ruleMetadataMatchesSource(meta) && meta.ProviderMetadata.TMDB != nil && meta.ProviderMetadata.TMDB.Anime {
+		return true
+	}
+	return ContainsRuleValue(RuleKeywords(meta), []string{"anime"})
+}
+
+// Animation reports whether current metadata contains the animation genre.
+func Animation(meta api.RuleSubject) bool {
+	return ContainsRuleValue(RuleGenres(meta), []string{"animation"})
+}
+
+// NormalizeRuleValues trims, lowercases, and deduplicates values while preserving order.
+func NormalizeRuleValues(values []string) []string {
+	out := make([]string, 0, len(values))
+	seen := make(map[string]bool, len(values))
+	for _, value := range values {
+		trimmed := strings.ToLower(strings.TrimSpace(value))
+		if trimmed == "" || seen[trimmed] {
+			continue
+		}
+		seen[trimmed] = true
+		out = append(out, trimmed)
+	}
+	return out
+}
+
+// ContainsRuleValue reports whether normalized values and targets intersect.
+func ContainsRuleValue(values, targets []string) bool {
+	if len(values) == 0 || len(targets) == 0 {
+		return false
+	}
+	targetSet := make(map[string]bool, len(targets))
+	for _, target := range targets {
+		targetSet[strings.ToLower(strings.TrimSpace(target))] = true
+	}
+	for _, value := range values {
+		if targetSet[strings.ToLower(strings.TrimSpace(value))] {
+			return true
+		}
+	}
+	return false
+}
+
+func ruleMetadataMatchesSource(meta api.RuleSubject) bool {
+	storedSource := strings.TrimSpace(meta.ProviderMetadata.SourcePath)
+	return storedSource == "" || strings.EqualFold(storedSource, strings.TrimSpace(meta.SourcePath))
+}
+
+func splitRuleList(value string) []string {
+	if strings.TrimSpace(value) == "" {
+		return nil
+	}
+	parts := strings.Split(value, ",")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if trimmed := strings.TrimSpace(part); trimmed != "" {
+			out = append(out, trimmed)
+		}
+	}
+	return out
+}
diff --git a/internal/trackers/impl/unit3d/aither.go b/internal/trackers/impl/unit3d/aither.go
deleted file mode 100644
index 1182ec29..00000000
--- a/internal/trackers/impl/unit3d/aither.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func BuildAitherName(meta api.PreparedMetadata) string {
-	name := strings.TrimSpace(meta.ReleaseName)
-	if name == "" {
-		name = strings.TrimSpace(meta.ReleaseNameNoTag)
-	}
-	if name == "" {
-		return ""
-	}
-
-	resolution := resolveResolution(meta)
-	videoCodec := strings.TrimSpace(meta.VideoCodec)
-	videoEncode := strings.TrimSpace(meta.VideoEncode)
-	nameType := strings.ToUpper(strings.TrimSpace(meta.Type))
-	source := strings.TrimSpace(meta.Source)
-	audio := strings.TrimSpace(meta.Audio)
-
-	languages := append([]string{}, meta.Release.Language...)
-	if len(languages) > 0 && !hasEnglishLanguage(languages) {
-		foreignLang := strings.ToUpper(strings.TrimSpace(languages[0]))
-		if nameType == "REMUX" && isDVDSource(source) {
-			if meta.Release.Year > 0 {
-				name = strings.Replace(name, formatOptionalInt(meta.Release.Year), formatOptionalInt(meta.Release.Year)+" "+foreignLang, 1)
-			}
-		} else if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-			if resolution != "" {
-				name = strings.Replace(name, resolution, foreignLang+" "+resolution, 1)
-			}
-		}
-	}
-
-	if nameType == "DVDRIP" {
-		source = "DVDRip"
-		if meta.Source != "" {
-			name = strings.Replace(name, meta.Source+" ", "", 1)
-		}
-		if videoEncode != "" {
-			name = strings.Replace(name, videoEncode, "", 1)
-		}
-		if resolution != "" {
-			name = strings.Replace(name, source, resolution+" "+source, 1)
-		}
-		if audio != "" && videoEncode != "" {
-			name = strings.Replace(name, audio, audio+videoEncode, 1)
-		}
-	} else if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || (nameType == "REMUX" && isDVDSource(source)) {
-		if resolution != "" && source != "" {
-			name = strings.Replace(name, source, resolution+" "+source, 1)
-		}
-		if audio != "" && videoCodec != "" {
-			name = strings.Replace(name, audio, videoCodec+" "+audio, 1)
-		}
-	}
-
-	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-}
-
-func isDVDSource(source string) bool {
-	value := strings.ToUpper(strings.TrimSpace(source))
-	switch value {
-	case "PAL DVD", "NTSC DVD", "DVD":
-		return true
-	default:
-		return false
-	}
-}
diff --git a/internal/trackers/impl/unit3d/aither_profile.go b/internal/trackers/impl/unit3d/aither_profile.go
deleted file mode 100644
index 3c4a0aa1..00000000
--- a/internal/trackers/impl/unit3d/aither_profile.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-)
-
-func siteAITHERProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		applyAdditionalPayload: func(req trackers.UploadRequest, data map[string]string) {
-			hdrValue := strings.ToUpper(strings.TrimSpace(req.Meta.HDR))
-			hasHDR10P := strings.Contains(hdrValue, "HDR10+")
-
-			data["dv"] = boolFlag(strings.Contains(hdrValue, "DV"))
-			if hasHDR10P {
-				data["hdr10p"] = "1"
-				return
-			}
-			if strings.Contains(hdrValue, "HDR") || strings.Contains(hdrValue, "HLG") {
-				data["hdr"] = "1"
-			}
-		},
-	}
-}
diff --git a/internal/trackers/impl/unit3d/authentication_doc.go b/internal/trackers/impl/unit3d/authentication_doc.go
new file mode 100644
index 00000000..8876d639
--- /dev/null
+++ b/internal/trackers/impl/unit3d/authentication_doc.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+// Unit3D API authentication
+//
+// UNIT3D documents three API-token transports: an api_token query parameter,
+// an api_token form field, or an Authorization header using the Bearer scheme.
+// upbrr deliberately uses only Bearer authentication for Unit3D upload, lookup,
+// and filter requests. trackerdata.SetUnit3DAPIHeaders trims the configured key,
+// sets Authorization when the key is non-empty, and requests JSON responses.
+// It does not add api_token to URLs or multipart form data, which keeps tokens out
+// of request URLs and upload payload diagnostics.
+//
+// API keys come from the effective tracker configuration resolved by
+// trackerdata.TrackerAPIKey. A missing key leaves the request unauthenticated;
+// callers decide whether that is a configuration failure or a request the remote
+// server may reject. Credentials, authorization headers, and token-bearing URLs
+// must remain excluded from logs, errors, dry-run payloads, and failure artifacts.
+//
+// Source: https://github.com/HDInnovations/UNIT3D/blob/master/book/src/torrent_api.md
diff --git a/internal/trackers/impl/unit3d/blu.go b/internal/trackers/impl/unit3d/blu.go
deleted file mode 100644
index a1145a72..00000000
--- a/internal/trackers/impl/unit3d/blu.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteBLUProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DBLUTypeID,
-		resolveResolutionID: resolveUnit3DBLUResolutionID,
-		resolveCategoryID:   resolveUnit3DBLUCategoryID,
-	}
-}
-
-func resolveUnit3DBLUCategoryID(meta api.PreparedMetadata) string {
-	if strings.Contains(strings.ToUpper(strings.TrimSpace(meta.Edition)), "FANRES") {
-		return "3"
-	}
-	return resolveUnit3DCategoryID(meta)
-}
-
-func resolveUnit3DBLUTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "3",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-		"ENCODE": "12",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
-
-func resolveUnit3DBLUResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"8640p": "10",
-		"4320p": "11",
-		"2160p": "1",
-		"1440p": "2",
-		"1080p": "2",
-		"1080i": "3",
-		"720p":  "5",
-		"576p":  "6",
-		"576i":  "7",
-		"480p":  "8",
-		"480i":  "9",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/cbr.go b/internal/trackers/impl/unit3d/cbr.go
deleted file mode 100644
index c3014fc0..00000000
--- a/internal/trackers/impl/unit3d/cbr.go
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var cbrCodecReplacer = strings.NewReplacer(
-	"DD+ ", "DDP",
-	"DD ", "DD",
-	"AAC ", "AAC",
-	"FLAC ", "FLAC",
-)
-
-var cbrAudioMarkerReplacer = strings.NewReplacer(
-	"Dubbed", "",
-	"Dual-Audio", "",
-)
-
-var audioTagRegex = regexp.MustCompile(`(?i)-([^.-]+)\.(?:DUAL|MULTI)`)
-
-var ptbrMap = map[string]struct{}{
-	"português": {}, "portuguese": {}, "pt-br": {}, "pt": {},
-}
-
-func siteCBRProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveCategoryID: resolveUnit3DCBRCategoryID}
-}
-
-func resolveUnit3DCBRCategoryID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(resolveUnit3DCategory(meta), "TV") && meta.Anime {
-		return "4"
-	}
-	return resolveUnit3DCategoryID(meta)
-}
-
-func BuildCBRName(meta api.PreparedMetadata, customTag string) string {
-	name := baseReleaseName(meta)
-	if name == "" {
-		return ""
-	}
-
-	name = cbrCodecReplacer.Replace(name)
-
-	category := resolveUnit3DCategory(meta)
-	if category == "TV" || meta.Anime {
-		if meta.Release.Year > 0 {
-			yearStr := strconv.Itoa(meta.Release.Year)
-			if strings.Contains(name, yearStr) {
-				name = strings.ReplaceAll(name, "("+yearStr+")", "")
-				name = strings.ReplaceAll(name, yearStr, "")
-				name = strings.TrimSpace(name)
-			}
-		}
-	}
-
-	origLang := strings.ToLower(resolveOriginalLanguage(meta))
-	aka := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		aka = meta.ExternalMetadata.TMDB.RetrievedAKA
-	}
-
-	_, isPtBR := ptbrMap[origLang]
-
-	if !isPtBR && aka != "" {
-		name = strings.ReplaceAll(name, aka, "")
-		name = strings.Join(strings.Fields(name), " ")
-	}
-
-	if isPtBR && aka != "" {
-		akaClean := strings.TrimSpace(strings.ReplaceAll(aka, "AKA", ""))
-		title := meta.Release.Title
-
-		name = strings.ReplaceAll(name, aka, "")
-		name = strings.ReplaceAll(name, strings.ReplaceAll(aka, " ", "."), "")
-		name = strings.ReplaceAll(name, title, akaClean)
-		name = strings.ReplaceAll(name, strings.ReplaceAll(title, " ", "."), akaClean)
-		name = strings.Join(strings.Fields(name), " ")
-	}
-
-	cbrName := name
-
-	if !isDiscType(meta.DiscType) {
-		audioTag := ""
-		hasPortuguese := false
-		for _, l := range meta.AudioLanguages {
-			if _, ok := ptbrMap[strings.ToLower(l)]; ok {
-				hasPortuguese = true
-				break
-			}
-		}
-
-		if hasPortuguese {
-			uniqueLangs := make(map[string]struct{})
-			for _, l := range meta.AudioLanguages {
-				trimmed := strings.TrimSpace(l)
-				if trimmed == "" {
-					continue
-				}
-				if code, _, ok := languageCode(trimmed); ok {
-					uniqueLangs[code] = struct{}{}
-				}
-			}
-
-			count := len(uniqueLangs)
-			if count >= 3 {
-				audioTag = " MULTI"
-			} else if count == 2 {
-				audioTag = " DUAL"
-			}
-		}
-
-		if audioTag != "" {
-			cbrName = cbrAudioMarkerReplacer.Replace(cbrName)
-			cbrName = strings.Join(strings.Fields(cbrName), " ")
-			if idx := strings.LastIndex(cbrName, "-"); idx != -1 {
-				prefix := cbrName[:idx]
-				suffix := cbrName[idx+1:]
-
-				cleanCustomTag := strings.TrimPrefix(customTag, "-")
-				if cleanCustomTag != "" && strings.EqualFold(strings.TrimSpace(suffix), cleanCustomTag) {
-					searchStr := meta.Filename
-					if searchStr == "" {
-						searchStr = meta.ReleaseName
-					}
-
-					if match := audioTagRegex.FindStringSubmatch(searchStr); len(match) > 1 {
-						originalGroupTag := match[1]
-						if !strings.EqualFold(originalGroupTag, meta.Release.Group) {
-							cbrName = prefix + "-" + originalGroupTag + audioTag + "-" + suffix
-						} else {
-							cbrName = prefix + audioTag + "-" + suffix
-						}
-					} else {
-						cbrName = prefix + audioTag + "-" + suffix
-					}
-				} else {
-					cbrName = prefix + audioTag + "-" + suffix
-				}
-			} else {
-				cbrName += audioTag
-			}
-		}
-	}
-
-	return addNoGroupSuffix(cbrName, meta, "NoGroup")
-}
diff --git a/internal/trackers/impl/unit3d/cbr_test.go b/internal/trackers/impl/unit3d/cbr_test.go
deleted file mode 100644
index 937f4600..00000000
--- a/internal/trackers/impl/unit3d/cbr_test.go
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestBuildCBRName(t *testing.T) {
-	tests := []struct {
-		name      string
-		meta      api.PreparedMetadata
-		customTag string
-		want      string
-	}{
-		{
-			name: "Basic movie",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Movie 2023 1080p WEB-DL DDP5.1 H.264-GRP",
-				Release:     api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				Tag:         "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL DDP5.1 H.264-GRP",
-		},
-		{
-			name: "Portuguese DUAL",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
-		},
-		{
-			name: "Custom tag with original group (same as internal)",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-CBR",
-				Filename:       "Movie.2023.1080p.WEB-DL.H.264-GRP.DUAL.mkv",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "CBR",
-			},
-			customTag: "-CBR",
-			want:      "Movie 2023 1080p WEB-DL H.264 DUAL-CBR",
-		},
-		{
-			name: "Brazilian PT override",
-			meta: api.PreparedMetadata{
-				ReleaseName: "A Foreign Movie 2023 1080p WEB-DL H.264-GRP",
-				Release: api.ReleaseInfo{
-					Title: "A Foreign Movie",
-					Year:  2023,
-					Group: "GRP",
-				},
-				ExternalIDs: api.ExternalIDs{
-					Category: "MOVIE",
-				},
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{
-						OriginalLanguage: "pt",
-						RetrievedAKA:     "Filme Brasileiro AKA",
-					},
-				},
-				Tag: "-GRP",
-			},
-			want: "Filme Brasileiro 2023 1080p WEB-DL H.264-GRP",
-		},
-		{
-			name: "TV year stripping",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Show Series 2023 S01E01 1080p WEB-DL-GRP",
-				Release:     api.ReleaseInfo{Title: "Show Series", Year: 2023, Group: "GRP"},
-				ExternalIDs: api.ExternalIDs{Category: "TV"},
-				Tag:         "GRP",
-			},
-			want: "Show Series S01E01 1080p WEB-DL-GRP",
-		},
-		{
-			name: "Anime year stripping",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Anime Movie (2023) 1080p-GRP",
-				Release:     api.ReleaseInfo{Title: "Anime Movie", Year: 2023, Group: "GRP"},
-				Anime:       true,
-				Tag:         "GRP",
-			},
-			want: "Anime Movie 1080p-GRP",
-		},
-		{
-			name: "Non-pt AKA removal (with spaces)",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Title AKA Some AKA 2023 1080p-GRP",
-				Release:     api.ReleaseInfo{Title: "Title", Year: 2023, Group: "GRP"},
-				ExternalMetadata: api.ExternalMetadata{
-					TMDB: &api.TMDBMetadata{
-						OriginalLanguage: "en",
-						RetrievedAKA:     "Some AKA",
-					},
-				},
-				Tag: "-GRP",
-			},
-			want: "Title AKA 2023 1080p-GRP",
-		},
-		{
-			name: "Portuguese MULTI",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese", "French"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL H.264 MULTI-GRP",
-		},
-		{
-			name: "Disc type bypass",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p BluRay REMUX AVC-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				DiscType:       "BDMV",
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p BluRay REMUX AVC-GRP",
-		},
-		{
-			name: "Custom tag with original group from filename",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL-CBR",
-				Filename:       "Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "NEWGRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "CBR",
-			},
-			customTag: "-CBR",
-			want:      "Movie 2023 1080p WEB-DL-ORIGGRP DUAL-CBR",
-		},
-		{
-			name: "Custom tag and same group from filename",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL-CBR",
-				Filename:       "Movie.2023.1080p.WEB-DL-GRP.DUAL.mkv",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "CBR",
-			},
-			customTag: "-CBR",
-			want:      "Movie 2023 1080p WEB-DL DUAL-CBR",
-		},
-		{
-			name: "No group suffix",
-			meta: api.PreparedMetadata{
-				ReleaseName: "Movie 2023 1080p WEB-DL-NoGrp",
-				Release:     api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-			},
-			want: "Movie 2023 1080p WEB-DL-NoGroup",
-		},
-		{
-			name: "Blank audio entries with one usable language",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"", "Portuguese", "   "},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL H.264-GRP",
-		},
-		{
-			name: "Blank audio entries with two usable languages",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "", "Portuguese", "   "},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
-		},
-		{
-			name: "Blank audio entries with three usable languages",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "", "Portuguese", "   ", "French"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL H.264 MULTI-GRP",
-		},
-		{
-			name: "Custom tag substring in title / source must not inject filename group",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "CBR Movie 2023 1080p WEB-DL H.264-GRP",
-				Filename:       "CBR.Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
-				Release:        api.ReleaseInfo{Title: "CBR Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "GRP",
-			},
-			customTag: "-CBR",
-			want:      "CBR Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
-		},
-		{
-			name: "Real configured custom suffix should still inject filename group",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie 2023 1080p WEB-DL H.264-CBR",
-				Filename:       "Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "CBR",
-			},
-			customTag: "-CBR",
-			want:      "Movie 2023 1080p WEB-DL H.264-ORIGGRP DUAL-CBR",
-		},
-		{
-			name: "Dubbed inputs with Portuguese replacement eligibility",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie Dubbed 2023 1080p WEB-DL-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL DUAL-GRP",
-		},
-		{
-			name: "Dubbed inputs without Portuguese replacement eligibility",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie Dubbed 2023 1080p WEB-DL-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English"},
-				Tag:            "GRP",
-			},
-			want: "Movie Dubbed 2023 1080p WEB-DL-GRP",
-		},
-		{
-			name: "Dual-Audio inputs with Portuguese replacement eligibility",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English", "Portuguese"},
-				Tag:            "GRP",
-			},
-			want: "Movie 2023 1080p WEB-DL DUAL-GRP",
-		},
-		{
-			name: "Dual-Audio inputs without Portuguese replacement eligibility",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English"},
-				Tag:            "GRP",
-			},
-			want: "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
-		},
-		{
-			name: "Existing DD / DDP / AAC / FLAC normalization",
-			meta: api.PreparedMetadata{
-				ReleaseName:    "Movie DD+ 5.1 DD 5.1 AAC 2.0 FLAC 2.0-GRP",
-				Release:        api.ReleaseInfo{Title: "Movie", Year: 2023, Group: "GRP"},
-				AudioLanguages: []string{"English"},
-				Tag:            "GRP",
-			},
-			want: "Movie DDP5.1 DD5.1 AAC2.0 FLAC2.0-GRP",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := BuildCBRName(tt.meta, tt.customTag); got != tt.want {
-				t.Errorf("BuildCBRName() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}
diff --git a/internal/trackers/impl/unit3d/definition.go b/internal/trackers/impl/unit3d/definition.go
index 65df5a4b..db2d0a89 100644
--- a/internal/trackers/impl/unit3d/definition.go
+++ b/internal/trackers/impl/unit3d/definition.go
@@ -7,99 +7,264 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"slices"
 	"strings"
 
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Definition provides one Unit3D site profile through the shared tracker contracts.
 type Definition struct {
-	name string
+	profile Profile
 }
 
+// Profile declares Unit3D site identity, endpoint, and site-owned policies.
+type Profile struct {
+	// Name is the stable normalized tracker identifier.
+	Name string
+	// BaseURL is the site's default Unit3D endpoint.
+	BaseURL string
+	// Site contains optional site-specific payload callbacks.
+	Site SiteProfile
+	// Rules contains site-specific release validation requirements.
+	Rules *trackers.RuleSet
+	// MetadataPolicy overrides the Unit3D metadata requirements for this site.
+	MetadataPolicy *trackers.TrackerMetadataPolicy
+	// AudioPolicy contains site-specific multi-language constraints.
+	AudioPolicy *trackers.AudioPolicy
+	// DupePolicy contains site-specific duplicate comparison settings.
+	DupePolicy *trackers.DupePolicy
+	// UploadArtifact contains site-specific torrent personalization settings.
+	UploadArtifact *trackers.UploadArtifactPolicy
+	// BannedPolicy contains optional dynamic banned-group retrieval settings.
+	BannedPolicy *trackers.BannedGroupPolicy
+	// BannedGroups is the site's static banned release-group list.
+	BannedGroups []string
+	// ImageHost contains accepted image-host restrictions.
+	ImageHost *trackers.ImageHostPolicy
+	// TorrentIdentity contains site-specific torrent identity aliases or overrides.
+	TorrentIdentity *trackers.TorrentIdentityPolicy
+	// ClaimPolicy contains generic claim-orchestration settings.
+	ClaimPolicy *trackers.ClaimPolicy
+	// DescriptionGroup identifies the site's description override group.
+	DescriptionGroup string
+}
+
+// New returns a Unit3D definition for the requested registered profile name.
 func New(name string) *Definition {
-	return &Definition{name: strings.ToUpper(strings.TrimSpace(name))}
+	return NewWithProfile(Profile{Name: name})
 }
 
-func (d *Definition) Name() string {
-	return d.name
+// NewWithProfile normalizes profile identity, copies static banned groups and
+// metadata requirements, and retains the remaining site callbacks and policy
+// pointers as immutable compiled configuration.
+func NewWithProfile(profile Profile) *Definition {
+	profile.Name = strings.ToUpper(strings.TrimSpace(profile.Name))
+	profile.BaseURL = strings.TrimSpace(profile.BaseURL)
+	profile.DescriptionGroup = strings.ToLower(strings.TrimSpace(profile.DescriptionGroup))
+	profile.BannedGroups = append([]string(nil), profile.BannedGroups...)
+	profile.MetadataPolicy = cloneMetadataPolicy(profile.MetadataPolicy)
+	return &Definition{profile: profile}
 }
 
-func (d *Definition) Upload(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	if unit3dmeta.IsKnown(d.name) {
-		return uploadUnit3D(ctx, req)
+// DescriptionGroup returns the site-specific description override group.
+func (d *Definition) DescriptionGroup() string { return d.profile.DescriptionGroup }
+
+// DefaultBaseURL returns the site's endpoint used when configuration supplies none.
+func (d *Definition) DefaultBaseURL() string { return d.profile.BaseURL }
+
+// ClaimPolicy returns an independent copy of the site's claim policy.
+func (d *Definition) ClaimPolicy() *trackers.ClaimPolicy {
+	if d.profile.ClaimPolicy == nil {
+		return nil
 	}
-	select {
-	case <-ctx.Done():
-		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
+	policy := *d.profile.ClaimPolicy
+	return &policy
+}
+
+// UploadArtifactPolicy returns an independent copy of the site's torrent personalization policy.
+func (d *Definition) UploadArtifactPolicy() *trackers.UploadArtifactPolicy {
+	if d.profile.UploadArtifact == nil {
+		return nil
 	}
-	if req.Logger != nil {
-		req.Logger.Infof("trackers: %s upload not implemented (unit3d scaffold)", d.name)
+	policy := *d.profile.UploadArtifact
+	return &policy
+}
+
+// MetadataPolicy returns an independent copy of this site's metadata
+// requirements. Profiles without an override require TMDB metadata as a strict
+// failure for every category.
+func (d *Definition) MetadataPolicy() *trackers.TrackerMetadataPolicy {
+	if d.profile.MetadataPolicy != nil {
+		return cloneMetadataPolicy(d.profile.MetadataPolicy)
+	}
+	return &trackers.TrackerMetadataPolicy{
+		Requirements: []trackers.MetadataRequirement{{
+			Scope:       trackers.MetadataScopeAny,
+			AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB},
+			Disposition: api.RuleDispositionStrict,
+		}},
+	}
+}
+
+func cloneMetadataPolicy(policy *trackers.TrackerMetadataPolicy) *trackers.TrackerMetadataPolicy {
+	if policy == nil {
+		return nil
+	}
+	cloned := *policy
+	cloned.Requirements = slices.Clone(policy.Requirements)
+	for i := range cloned.Requirements {
+		cloned.Requirements[i].AnyOf = slices.Clone(cloned.Requirements[i].AnyOf)
+	}
+	return &cloned
+}
+
+// Rules returns a shallow copy of the site rules with valid MediaInfo settings
+// required for every Unit3D upload.
+func (d *Definition) Rules() *trackers.RuleSet {
+	if d.profile.Rules == nil {
+		return &trackers.RuleSet{RequireValidMISetting: true}
+	}
+	rules := *d.profile.Rules
+	rules.RequireValidMISetting = true
+	return &rules
+}
+
+// BannedGroups returns a defensive copy of the site's static release-group blacklist.
+func (d *Definition) BannedGroups() []string { return append([]string(nil), d.profile.BannedGroups...) }
+
+// BannedGroupPolicy returns the site's dynamic banned-group retrieval settings.
+func (d *Definition) BannedGroupPolicy() *trackers.BannedGroupPolicy { return d.profile.BannedPolicy }
+
+// DupePolicy returns the site's duplicate comparison settings.
+func (d *Definition) DupePolicy() *trackers.DupePolicy { return d.profile.DupePolicy }
+
+// AudioPolicy returns the site's multi-language constraints.
+func (d *Definition) AudioPolicy() *trackers.AudioPolicy { return d.profile.AudioPolicy }
+
+// ImageHostPolicy returns the site's accepted image-host restrictions.
+func (d *Definition) ImageHostPolicy() *trackers.ImageHostPolicy { return d.profile.ImageHost }
+
+// TorrentIdentityPolicy returns common Unit3D identity behavior plus site aliases.
+func (d *Definition) TorrentIdentityPolicy() *trackers.TorrentIdentityPolicy {
+	policy := trackers.TorrentIdentityPolicy{
+		TrackerURLPatterns: []string{d.profile.BaseURL},
+		CommentURLPatterns: []string{d.profile.BaseURL},
+		DetailIDPattern:    `/(\d+)`,
+	}
+	if d.profile.TorrentIdentity != nil {
+		policy.TrackerURLPatterns = append(policy.TrackerURLPatterns, d.profile.TorrentIdentity.TrackerURLPatterns...)
+		policy.CommentURLPatterns = append(policy.CommentURLPatterns, d.profile.TorrentIdentity.CommentURLPatterns...)
+		if d.profile.TorrentIdentity.DetailIDPattern != "" {
+			policy.DetailIDPattern = d.profile.TorrentIdentity.DetailIDPattern
+		}
+		policy.WorkingTrackerID = d.profile.TorrentIdentity.WorkingTrackerID
+		policy.SearchPreference = d.profile.TorrentIdentity.SearchPreference
 	}
-	return api.UploadSummary{}, internalerrors.ErrNotImplemented
+	return &policy
+}
+
+// Name returns the stable tracker identifier for this Unit3D profile.
+func (d *Definition) Name() string {
+	return d.profile.Name
 }
 
-func (d *Definition) BuildUploadDryRun(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
-	if unit3dmeta.IsKnown(d.name) {
-		return buildUploadDryRunUnit3D(ctx, req)
+// TrackerFamily identifies the definition as Unit3D-backed.
+func (d *Definition) TrackerFamily() trackers.Family { return trackers.FamilyUnit3D }
+
+// UploadContentMode declares the aggregate description workflow shared by Unit3D sites.
+func (d *Definition) UploadContentMode() trackers.UploadContentMode {
+	return trackers.UploadContentModeDescription
+}
+
+// AuthCapability declares the API key required by standard Unit3D APIs.
+func (d *Definition) AuthCapability() api.TrackerAuthCapability {
+	return api.TrackerAuthCapability{
+		TrackerID:      d.profile.Name,
+		DisplayName:    d.profile.Name,
+		AuthKind:       "api_key",
+		RequiresAPIKey: true,
+	}
+}
+
+// Prepare builds a fresh intent-scoped tracker plan for this Unit3D profile.
+func (d *Definition) Prepare(ctx context.Context, input trackers.PreparationInput) (trackers.TrackerPlan, *trackers.PreparationFailure) {
+	return trackers.PrepareAdapter(ctx, input, d.prepareDescription, d.prepareUpload)
+}
+
+func (d *Definition) prepareUpload(ctx context.Context, req trackers.PreparationInput) (trackers.PreparedOperation, error) {
+	if d.profile.BaseURL != "" {
+		return prepareUnit3DUpload(ctx, req, d.profile.BaseURL, d.profile.Site)
 	}
 	select {
 	case <-ctx.Done():
-		return api.TrackerDryRunEntry{}, fmt.Errorf("context canceled: %w", ctx.Err())
+		return trackers.PreparedOperation{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 	if req.Logger != nil {
-		req.Logger.Infof("trackers: dry-run decision=not_implemented tracker=%s", d.name)
+		req.Logger.Infof("trackers: preparation decision=not_implemented tracker=%s", d.profile.Name)
 	}
-	return api.TrackerDryRunEntry{}, internalerrors.ErrNotImplemented
+	return trackers.PreparedOperation{}, internalerrors.ErrNotImplemented
 }
 
-func (d *Definition) BuildDescription(ctx context.Context, req trackers.DescriptionRequest) (trackers.DescriptionResult, error) {
+func (d *Definition) prepareDescription(ctx context.Context, req trackers.PreparationInput) (trackers.DescriptionResult, error) {
 	select {
 	case <-ctx.Done():
 		return trackers.DescriptionResult{}, fmt.Errorf("context canceled: %w", ctx.Err())
 	default:
 	}
 	if req.Logger != nil {
-		req.Logger.Debugf("trackers: %s building unit3d description", d.name)
+		req.Logger.Debugf("trackers: %s building unit3d description", d.profile.Name)
 	}
 	var err error
 	assets := trackers.DescriptionAssets{}
 	if req.Assets != nil {
 		assets = *req.Assets
 	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, req.Logger)
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
 		if err != nil {
 			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 				return trackers.DescriptionResult{}, fmt.Errorf("trackers: %w", err)
 			}
 			if req.Logger != nil {
-				req.Logger.Warnf("trackers: description assets failed tracker=%s err=%s", d.name, redaction.RedactValue(err.Error(), nil))
+				req.Logger.Warnf("trackers: description assets failed tracker=%s err=%s", d.profile.Name, redaction.RedactValue(err.Error(), nil))
 			}
 			assets = trackers.DescriptionAssets{}
 		}
 	}
 	description := strings.TrimSpace(assets.Description)
 	if !assets.Final {
-		description, err = buildUnit3DDescription(ctx, d.name, req.Meta, req.AppConfig, req.TrackerConfig, req.Logger, assets.Description, assets.MenuImages, assets.Screenshots)
+		description, err = buildUnit3DDescription(
+			ctx,
+			d.profile.Name,
+			req.Meta,
+			req.Runtime.DescriptionConfig(),
+			req.TrackerConfig,
+			req.Logger,
+			assets.Description,
+			assets.MenuImages,
+			assets.Screenshots,
+			d.profile.Site,
+		)
 		if err != nil {
 			return trackers.DescriptionResult{}, err
 		}
 	}
+	if req.Intent == trackers.PreparationIntentDryRun && description != "" {
+		descriptionunit3d.SaveDescriptionDebug(api.NewDescriptionSubject(req.Meta), "unit3d", req.Runtime.DBPath, description, req.Logger)
+	}
 	return trackers.DescriptionResult{
 		Group:       "unit3d",
 		Description: description,
 	}, nil
 }
 
-func DefaultTrackers() []string {
-	return trackers.Unit3DTrackers()
-}
-
+// Register adds scaffolded Unit3D definitions for the supplied tracker names,
+// stops at the first registry error, and treats a nil registry as a no-op.
 func Register(registry *trackers.Registry, trackersList []string) error {
 	if registry == nil {
 		return nil
@@ -111,3 +276,22 @@ func Register(registry *trackers.Registry, trackersList []string) error {
 	}
 	return nil
 }
+
+// RegisterProfiles registers composed Unit3D site profiles, rejects an empty
+// profile name, stops at the first registry error, and treats a nil registry as
+// a no-op.
+func RegisterProfiles(registry *trackers.Registry, profiles []Profile) error {
+	if registry == nil {
+		return nil
+	}
+	for _, profile := range profiles {
+		if strings.TrimSpace(profile.Name) == "" {
+			return errors.New("trackers: unit3d profile has empty name")
+		}
+		definition := NewWithProfile(profile)
+		if err := registry.Register(definition); err != nil {
+			return fmt.Errorf("trackers: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/internal/trackers/impl/unit3d/description.go b/internal/trackers/impl/unit3d/description.go
index 8af57964..7fde9d53 100644
--- a/internal/trackers/impl/unit3d/description.go
+++ b/internal/trackers/impl/unit3d/description.go
@@ -6,23 +6,43 @@ package unit3d
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/autobrr/upbrr/internal/config"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func buildUnit3DDescription(ctx context.Context, tracker string, meta api.PreparedMetadata, appConfig config.Config, trackerConfig config.TrackerConfig, logger api.Logger, keptDescription string, menuImages []api.ScreenshotImage, screenshots []api.ScreenshotImage) (string, error) {
-	if strings.EqualFold(strings.TrimSpace(tracker), "ACM") {
-		return buildACMDescription(ctx, meta, appConfig, trackerConfig, logger, keptDescription, menuImages, screenshots)
+func buildUnit3DDescription(
+	ctx context.Context,
+	_ string,
+	meta api.UploadSubject,
+	appConfig config.Config,
+	trackerConfig config.TrackerConfig,
+	logger api.Logger,
+	keptDescription string,
+	menuImages []api.ScreenshotImage,
+	screenshots []api.ScreenshotImage,
+	profiles ...SiteProfile,
+) (string, error) {
+	profile := firstSiteProfile(profiles)
+	if profile.BuildDescription != nil {
+		return profile.BuildDescription(ctx, meta, appConfig, trackerConfig, logger, keptDescription, menuImages, screenshots)
 	}
-	description, err := descriptionunit3d.BuildDescription(ctx, meta, appConfig, trackerConfig, logger, keptDescription, menuImages, screenshots)
+	description, err := descriptionunit3d.BuildDescription(
+		ctx,
+		api.NewDescriptionSubject(meta),
+		appConfig,
+		trackerConfig,
+		logger,
+		keptDescription,
+		menuImages,
+		screenshots,
+	)
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
-	if strings.EqualFold(strings.TrimSpace(tracker), "SHRI") {
-		return applySHRIDescriptionNotes(description, meta), nil
+	if profile.FinalizeDescription != nil {
+		return profile.FinalizeDescription(description, meta), nil
 	}
 	return description, nil
 }
diff --git a/internal/trackers/impl/unit3d/description_test.go b/internal/trackers/impl/unit3d/description_test.go
index eb1cff4e..23e3db3f 100644
--- a/internal/trackers/impl/unit3d/description_test.go
+++ b/internal/trackers/impl/unit3d/description_test.go
@@ -11,14 +11,14 @@ import (
 	"testing"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
 	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 func TestBuildUnit3DDescriptionTemplate(t *testing.T) {
-	meta := api.PreparedMetadata{DescriptionTemplate: "  Example Template  "}
+	meta := api.UploadSubject{DescriptionTemplate: "  Example Template  "}
 	cfg := config.Config{}
 	result, err := buildUnit3DDescription(context.Background(), "AITHER", meta, cfg, config.TrackerConfig{}, api.NopLogger{}, "", nil, nil)
 	if err != nil {
@@ -33,7 +33,7 @@ func TestBuildUnit3DDescriptionTemplate(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionKeptAppendsScreenshots(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	cfg := config.Config{Description: config.DescriptionSettingsConfig{ThumbnailSize: 350}}
 	kept := "Kept Description"
 	screens := []api.ScreenshotImage{{ImgURL: "https://img.example/s1.png"}}
@@ -53,7 +53,7 @@ func TestBuildUnit3DDescriptionKeptAppendsScreenshots(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionAppliesDescriptionConfig(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	cfg := config.Config{
 		Description: config.DescriptionSettingsConfig{
 			ThumbnailSize:    300,
@@ -87,9 +87,9 @@ func TestBuildUnit3DDescriptionAppliesDescriptionConfig(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionAddsLogoEpisodeOverviewAndMenuImages(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		EpisodeOverview: "Episode [b]overview[/b] text",
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{Logo: "https://image.tmdb.org/t/p/original/logo.png"},
 		},
 	}
@@ -121,9 +121,9 @@ func TestBuildUnit3DDescriptionAddsLogoEpisodeOverviewAndMenuImages(t *testing.T
 }
 
 func TestBuildUnit3DDescriptionAddsBlurayLinkAndImages(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DiscType: "BDMV",
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			Bluray: &api.BlurayMetadata{
 				SelectedReleaseID: "123",
 				Candidates: []api.BlurayReleaseCandidate{
@@ -172,9 +172,9 @@ func TestBuildUnit3DDescriptionSanitizesBlurayLink(t *testing.T) {
 			AddBlurayLink: true,
 		},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DiscType: "BDMV",
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			Bluray: &api.BlurayMetadata{
 				SelectedReleaseID: "123",
 				Candidates: []api.BlurayReleaseCandidate{
@@ -198,7 +198,7 @@ func TestBuildUnit3DDescriptionSanitizesBlurayLink(t *testing.T) {
 		t.Fatalf("expected raw BBCode brackets to be escaped, got %q", result)
 	}
 
-	meta.ExternalMetadata.Bluray.Candidates[0].URL = "not a url"
+	meta.ProviderMetadata.Bluray.Candidates[0].URL = "not a url"
 	result, err = buildUnit3DDescription(context.Background(), "AITHER", meta, cfg, config.TrackerConfig{}, api.NopLogger{}, "", nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -209,7 +209,7 @@ func TestBuildUnit3DDescriptionSanitizesBlurayLink(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionKeptIncludesScreenshots(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	cfg := config.Config{Description: config.DescriptionSettingsConfig{ThumbnailSize: 350}}
 	kept := "Kept [img]https://img.example/keep.png[/img]"
 	screens := []api.ScreenshotImage{{ImgURL: "https://img.example/s1.png"}}
@@ -229,7 +229,7 @@ func TestBuildUnit3DDescriptionSkipsBDInfo(t *testing.T) {
 		MainSettings: config.MainSettingsConfig{DBPath: dbPath},
 		Description:  config.DescriptionSettingsConfig{CustomDescriptionHeader: "Header"},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: filepath.Join(root, "Movie.mkv"),
 		DiscType:   "BDMV",
 		SelectedBDMVPlaylists: []api.PlaylistInfo{
@@ -241,7 +241,7 @@ func TestBuildUnit3DDescriptionSkipsBDInfo(t *testing.T) {
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -270,7 +270,7 @@ func TestBuildUnit3DDescriptionSkipsMediaInfo(t *testing.T) {
 	}
 
 	cfg := config.Config{}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath:        filepath.Join(root, "Movie.mkv"),
 		MediaInfoTextPath: miPath,
 	}
@@ -285,7 +285,7 @@ func TestBuildUnit3DDescriptionSkipsMediaInfo(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionIncludesDVDVOBMediaInfo(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DiscType:            "DVD",
 		DVDVOBMediaInfoText: "VOB_MI_CONTENT",
 	}
@@ -303,7 +303,7 @@ func TestBuildUnit3DDescriptionIncludesDVDVOBMediaInfo(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionSkipsDVDVOBMediaInfoForNonDVD(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DiscType:            "BDMV",
 		DVDVOBMediaInfoText: "VOB_MI_CONTENT",
 	}
@@ -318,7 +318,7 @@ func TestBuildUnit3DDescriptionSkipsDVDVOBMediaInfoForNonDVD(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionSkipsDVDVOBMediaInfoWhenEmpty(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		DiscType:            "DVD",
 		DVDVOBMediaInfoText: "   \n\t",
 	}
@@ -333,7 +333,7 @@ func TestBuildUnit3DDescriptionSkipsDVDVOBMediaInfoWhenEmpty(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionIncludesTonemapHeaderForHDRScreens(t *testing.T) {
-	meta := api.PreparedMetadata{HDR: "HDR10"}
+	meta := api.UploadSubject{HDR: "HDR10"}
 	cfg := config.Config{
 		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
 		Description: config.DescriptionSettingsConfig{
@@ -352,7 +352,7 @@ func TestBuildUnit3DDescriptionIncludesTonemapHeaderForHDRScreens(t *testing.T)
 }
 
 func TestBuildUnit3DDescriptionSkipsTonemapHeaderForNonHDR(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	cfg := config.Config{
 		ScreenshotHandling: config.ScreenshotHandlingConfig{ToneMap: true},
 		Description: config.DescriptionSettingsConfig{
@@ -370,31 +370,8 @@ func TestBuildUnit3DDescriptionSkipsTonemapHeaderForNonHDR(t *testing.T) {
 	}
 }
 
-func TestBuildUnit3DDescriptionACMTransformsBaseDescription(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Type:            "WEBDL",
-		ServiceLongName: "Netflix",
-	}
-	result, err := buildUnit3DDescription(context.Background(), "ACM", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, "[pre]x[/pre]\n[hide=test]y[/hide]\n[img]https://img.example/z.png[/img]", nil, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(result, "[code]x[/code]") {
-		t.Fatalf("expected pre converted to code, got %q", result)
-	}
-	if !strings.Contains(result, "[spoiler=test]y[/spoiler]") {
-		t.Fatalf("expected hide converted to spoiler, got %q", result)
-	}
-	if !strings.Contains(result, "not transcoded, just remuxed from the direct Netflix stream") {
-		t.Fatalf("expected ACM web source header, got %q", result)
-	}
-	if !strings.Contains(result, "[img=300]https://img.example/z.png[/img]") {
-		t.Fatalf("expected img resize normalization, got %q", result)
-	}
-}
-
 func TestBuildUnit3DDescriptionFinalizesUnit3DBBCode(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	kept := "[hide=Extras]notes[/hide]\n[user]name[/user]\n[comparison=Source, Encode]https://img.example/a.png https://img.example/b.png[/comparison]"
 
 	result, err := buildUnit3DDescription(context.Background(), "AITHER", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
@@ -415,37 +392,6 @@ func TestBuildUnit3DDescriptionFinalizesUnit3DBBCode(t *testing.T) {
 	}
 }
 
-func TestBuildUnit3DDescriptionAddsSHRIIslandReleaseNotes(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{Group: "island"},
-	}
-
-	result, err := buildUnit3DDescription(context.Background(), "SHRI", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, "Base description", nil, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(result, "Release Shareisland 🏴‍☠️") {
-		t.Fatalf("expected Shareisland notes, got %q", result)
-	}
-	if !strings.Contains(result, "Base description") {
-		t.Fatalf("expected base description to be preserved, got %q", result)
-	}
-}
-
-func TestBuildUnit3DDescriptionSkipsSHRIIslandReleaseNotesForOtherGroups(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Release: api.ReleaseInfo{Group: "other"},
-	}
-
-	result, err := buildUnit3DDescription(context.Background(), "SHRI", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, "Base description", nil, nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if strings.Contains(result, "Release Shareisland") {
-		t.Fatalf("did not expect Shareisland notes, got %q", result)
-	}
-}
-
 func TestBuildUnit3DDescriptionSkipsDuplicateTemplateAndKeptContent(t *testing.T) {
 	block := `[center]
 [url=https://pixhost.to/8ca234.png][img=350]https://pixhost.to/8ca234.png[/img][/url]
@@ -453,7 +399,7 @@ func TestBuildUnit3DDescriptionSkipsDuplicateTemplateAndKeptContent(t *testing.T
 [/center]
 
 [right][url=https://github.com/autobrr/upbrr][size=10]upbrr[/size][/url][/right]`
-	meta := api.PreparedMetadata{DescriptionTemplate: block}
+	meta := api.UploadSubject{DescriptionTemplate: block}
 
 	result, err := buildUnit3DDescription(context.Background(), "AITHER", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, block, nil, nil)
 	if err != nil {
@@ -479,7 +425,7 @@ func TestBuildUnit3DDescriptionStripsKnownBotSignatures(t *testing.T) {
 		"[right]Created by Upload Assistant[/right]",
 	}, "\n")
 
-	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.PreparedMetadata{}, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
+	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.UploadSubject{}, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -500,7 +446,7 @@ func TestBuildUnit3DDescriptionKeepsCenteredScreenshotsBeforeAitherFooter(t *tes
 		"[center][b][size=20]brush[/size][/b] This is an internal release which was first released exclusively on Aither. Cheers to all the Aither users[/center]",
 	}, "\n\n")
 
-	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.PreparedMetadata{}, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
+	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.UploadSubject{}, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -532,7 +478,7 @@ func TestBuildUnit3DDescriptionReplacesExistingScreenshotBlock(t *testing.T) {
 		{RawURL: "https://new.example/4.png", WebURL: "https://web.example/4"},
 	}
 
-	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.PreparedMetadata{}, config.Config{
+	result, err := buildUnit3DDescription(context.Background(), "AITHER", api.UploadSubject{}, config.Config{
 		Description: config.DescriptionSettingsConfig{ThumbnailSize: 350, ScreensPerRow: "2"},
 	}, config.TrackerConfig{}, api.NopLogger{}, base, nil, screens)
 	if err != nil {
@@ -556,7 +502,7 @@ func TestBuildUnit3DDescriptionStripsExistingSceneNFOBlock(t *testing.T) {
 	kept := `[center][spoiler=Scene NFO:][code]stale scene nfo[/code][/spoiler][/center]
 
 Custom body`
-	meta := api.PreparedMetadata{Scene: true}
+	meta := api.UploadSubject{Scene: true}
 
 	result, err := buildUnit3DDescription(context.Background(), "AITHER", meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, kept, nil, nil)
 	if err != nil {
@@ -575,12 +521,12 @@ Custom body`
 
 func TestDefinitionBuildDescriptionFormatsOverrideContent(t *testing.T) {
 	definition := New("AITHER")
-	result, err := definition.BuildDescription(context.Background(), trackers.DescriptionRequest{
+	result, err := definition.prepareDescription(context.Background(), trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta:    api.PreparedMetadata{},
-		AppConfig: config.Config{
+		Meta:    api.UploadSubject{},
+		Runtime: trackers.PreparationRuntimeFromConfig(config.Config{
 			Description: config.DescriptionSettingsConfig{ThumbnailSize: 350},
-		},
+		}),
 		Logger: api.NopLogger{},
 		Assets: &trackers.DescriptionAssets{
 			Description: "[align=center][img width=350]https://img.example/a.png[/img][/align]",
@@ -599,7 +545,7 @@ func TestDefinitionBuildDescriptionFormatsOverrideContent(t *testing.T) {
 }
 
 func TestBuildUnit3DDescriptionFiltersMenuImagesFromScreenshots(t *testing.T) {
-	meta := api.PreparedMetadata{}
+	meta := api.UploadSubject{}
 	cfg := config.Config{}
 	menuImages := []api.ScreenshotImage{{ImgURL: "https://img.example/menu1.png"}}
 	screenshots := []api.ScreenshotImage{
diff --git a/internal/trackers/impl/unit3d/doc.go b/internal/trackers/impl/unit3d/doc.go
index 0805b529..451a24fd 100644
--- a/internal/trackers/impl/unit3d/doc.go
+++ b/internal/trackers/impl/unit3d/doc.go
@@ -10,52 +10,46 @@
 //
 // # Architecture
 //
-// The implementation is split into:
-//   - definition.go: Tracker registry and routing to specific implementations
-//   - upload.go: Core Unit3D upload logic (multipart form, API calls)
-//   - <tracker>_name.go: Tracker-specific name formatting rules
+// Shared protocol behavior lives in this package. Site-owned profiles, rules,
+// banned groups, and payload hooks live under sites/<tracker>.
 //
-// # Adding a New Unit3D Tracker
+// # Adding a Standard Unit3D Tracker
 //
 // To add support for a new Unit3D tracker (e.g., "EXAMPLE"):
 //
-// 1. Add the tracker to the known list in definition.go:
+// 1. Create sites/example/profile.go. Profile owns the tracker identity,
+// endpoint, and composed site policies:
 //
-//	knownUnit3DTrackers = []string{"AITHER", "BLU", "LST", "LUME", "EXAMPLE"}
-//
-// 2. Create a name formatter in example_name.go:
-//
-//	func buildExampleName(meta api.PreparedMetadata) string {
-//	    name := meta.ReleaseName
-//	    // Apply EXAMPLE-specific name formatting rules
-//	    return name
+//	func Profile() unit3d.Profile {
+//	    return unit3d.Profile{
+//	        Name:    "EXAMPLE",
+//	        BaseURL: "https://example.invalid",
+//	        Rules:   Rules(),
+//	    }
 //	}
 //
-// 3. Add the name formatter to the routing in definition.go Upload():
-//
-//	case "EXAMPLE":
-//	    name = buildExampleName(meta)
-//
-// 4. Add configuration in config.yaml:
+// 2. Create sites/example/rules.go for release eligibility and typed policies
+// such as language and audio handling. Optional site-owned behavior stays beside
+// these files, for example banned_groups.go, auth.go, or custom payload hooks.
 //
-//	EXAMPLE:
-//	  api_key: "your-api-key"
-//	  announce_url: "https://example.tracker/announce/PASSKEY"
-//	  anon: false
-//	  modq: false
+// 3. Add one import and one Profile() entry to unit3DDefinitions in
+// internal/trackers/impl/registry.go.
 //
-// 5. Register in impl/registry.go if not auto-registered:
+// 4. Add one credential/config stanza to internal/config/defaults/example.yaml.
+// Do not add a tracker URL; Profile.BaseURL is authoritative.
 //
-//	registry.Register(unit3d.New())
+// 5. Add cross-tracker rule cases to internal/trackers/rules_test.go. Add
+// focused site tests only for behavior that differs from shared Unit3D handling.
 //
-// That's it! The core upload logic in upload.go is tracker-agnostic and will
-// handle the API interaction, torrent/NFO attachments, and response parsing.
+// No generic metadata, auth, image-hosting, torrent-client, or frontend
+// tracker-name edit is required. Unsupported saved entries remain inert; the
+// runtime does not infer or register custom Unit3D trackers.
 //
 // # Testing
 //
-// Unit tests live in upload_test.go and cover:
+// Shared unit tests live in upload_test.go and cover:
 //   - Category/type/resolution mapping
-//   - Name formatting per tracker
+//   - Site profile callbacks
 //   - Form payload construction
 //   - Response parsing
 //
diff --git a/internal/trackers/impl/unit3d/dupe.go b/internal/trackers/impl/unit3d/dupe.go
new file mode 100644
index 00000000..d611964b
--- /dev/null
+++ b/internal/trackers/impl/unit3d/dupe.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"context"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
+	"github.com/autobrr/upbrr/internal/trackers/dupe"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dupeSearcher struct {
+	trackerID string
+	cfg       config.Config
+	client    *trackerdata.Client
+}
+
+// NewDuplicateAdapter returns a duplicate-search adapter bound to one immutable dependency set.
+func (d *Definition) NewDuplicateAdapter(deps dupe.Dependencies) dupe.Adapter {
+	cfg := deps.BoundConfig()
+	httpClient := deps.HTTPClient()
+	logger := deps.Logger()
+	_ = logger
+	return &dupeSearcher{
+		trackerID: deps.Tracker(),
+		cfg:       cfg,
+		client:    trackerdata.NewClientWithRegistry(cfg, logger, httpClient, deps.Registry()),
+	}
+}
+
+func (s *dupeSearcher) Search(ctx context.Context, meta api.DuplicateSubject) dupe.AdapterResult {
+	tracker := s.trackerID
+	if strings.TrimSpace(trackerdata.TrackerAPIKey(s.cfg, tracker)) == "" {
+		return dupe.NotRun(dupe.NotRunMissingCredentials, "missing api_key for tracker", nil)
+	}
+	params := buildDupeSearchParams(meta, tracker)
+	if len(params) == 0 {
+		return dupe.NotRun(dupe.NotRunMissingMetadata, "missing required metadata for dupe search", nil)
+	}
+	entries, warning, err := s.client.SearchTorrents(ctx, tracker, params, strings.TrimSpace(meta.DiscType) != "")
+	if err != nil {
+		return dupe.Failed(dupe.FailureRequest, "duplicate search failed", err)
+	}
+	if warning != "" {
+		return dupe.Resolved(entries, []string{warning})
+	}
+	return dupe.Resolved(entries, nil)
+}
diff --git a/internal/trackers/impl/unit3d/dupe_params.go b/internal/trackers/impl/unit3d/dupe_params.go
new file mode 100644
index 00000000..d8369ded
--- /dev/null
+++ b/internal/trackers/impl/unit3d/dupe_params.go
@@ -0,0 +1,159 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var dupeSeasonPattern = regexp.MustCompile(`(?i)\bS(\d{1,2})`)
+
+func buildDupeSearchParams(meta api.DuplicateSubject, tracker string) url.Values {
+	tmdbID := meta.Identity.TMDBID
+	if tmdbID == 0 {
+		return nil
+	}
+
+	categoryValue, err := meta.Identity.RequireCategory()
+	if err != nil {
+		return nil
+	}
+	category := strings.ToUpper(string(categoryValue))
+	categoryID := resolveUnit3DDupeCategoryID(tracker, category)
+	if categoryID == "" {
+		return nil
+	}
+
+	typeValue := strings.ToUpper(strings.TrimSpace(meta.Type))
+	if typeValue == "" {
+		typeValue = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
+	}
+	if typeValue == "" && strings.TrimSpace(meta.DiscType) != "" {
+		typeValue = "DISC"
+	}
+	if typeValue == "" {
+		if meta.ReleaseNameOverrides.Type != nil {
+			typeValue = strings.ToUpper(strings.TrimSpace(*meta.ReleaseNameOverrides.Type))
+		}
+	}
+	typeID := resolveUnit3DDupeTypeID(tracker, typeValue)
+
+	resolution := strings.TrimSpace(meta.Release.Resolution)
+	if resolution == "" {
+		if meta.ReleaseNameOverrides.Resolution != nil {
+			resolution = strings.TrimSpace(*meta.ReleaseNameOverrides.Resolution)
+		}
+	}
+	resolutionID := resolveUnit3DDupeResolutionID(tracker, resolution)
+	if resolutionID == "" {
+		resolutionID = resolveUnit3DDupeResolutionID(tracker, "8640p")
+	}
+
+	params := url.Values{}
+	params.Set("tmdbId", strconv.Itoa(tmdbID))
+	params.Set("categories[]", categoryID)
+	params.Set("name", "")
+	params.Set("perPage", "100")
+
+	if !strings.EqualFold(tracker, "OTW") {
+		if resolutionID == "3" || resolutionID == "4" {
+			params.Add("resolutions[]", "3")
+			params.Add("resolutions[]", "4")
+		} else {
+			params.Set("resolutions[]", resolutionID)
+		}
+	}
+
+	if typeID != "" && !strings.EqualFold(tracker, "SP") && !strings.EqualFold(tracker, "STC") {
+		params.Set("types[]", typeID)
+	}
+
+	if strings.EqualFold(category, "TV") {
+		season := resolveSeasonValue(meta)
+		if season != "" {
+			params.Set("name", " "+season)
+		}
+	}
+
+	return params
+}
+
+func resolveUnit3DDupeCategoryID(tracker string, category string) string {
+	if strings.EqualFold(tracker, "EMUW") {
+		switch strings.ToUpper(strings.TrimSpace(category)) {
+		case "MOVIE", "FANRES":
+			return "1"
+		case "TV":
+			return "2"
+		default:
+			return ""
+		}
+	}
+	return trackerdata.CategoryID(category)
+}
+
+func resolveUnit3DDupeTypeID(tracker string, typeValue string) string {
+	if strings.EqualFold(tracker, "EMUW") {
+		mapping := map[string]string{
+			"DISC":   "1",
+			"REMUX":  "2",
+			"ENCODE": "3",
+			"WEBDL":  "4",
+			"WEBRIP": "5",
+			"HDTV":   "6",
+			"SD":     "7",
+		}
+		return mapping[strings.ToUpper(strings.TrimSpace(typeValue))]
+	}
+	return trackerdata.TypeID(typeValue)
+}
+
+func resolveUnit3DDupeResolutionID(tracker string, resolution string) string {
+	if strings.EqualFold(tracker, "EMUW") {
+		mapping := map[string]string{
+			"4320p": "1",
+			"2160p": "2",
+			"1080p": "3",
+			"1080i": "4",
+			"720p":  "5",
+			"576p":  "6",
+			"540p":  "7",
+			"480p":  "8",
+			"8640p": "10",
+		}
+		return mapping[strings.ToLower(strings.TrimSpace(resolution))]
+	}
+	return trackerdata.ResolutionID(resolution)
+}
+
+func resolveSeasonValue(meta api.DuplicateSubject) string {
+	if meta.ReleaseNameOverrides.Season != nil {
+		return normalizeSeasonEpisode(*meta.ReleaseNameOverrides.Season)
+	}
+	if match := dupeSeasonPattern.FindStringSubmatch(meta.ReleaseName); len(match) == 2 {
+		return "S" + match[1]
+	}
+	return ""
+}
+
+func normalizeSeasonEpisode(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	upper := strings.ToUpper(trimmed)
+	if strings.HasPrefix(upper, "S") {
+		return upper
+	}
+	if num, err := strconv.Atoi(trimmed); err == nil {
+		return "S" + strconv.Itoa(num)
+	}
+	return upper
+}
diff --git a/internal/trackers/impl/unit3d/dupe_params_test.go b/internal/trackers/impl/unit3d/dupe_params_test.go
new file mode 100644
index 00000000..531f6cbc
--- /dev/null
+++ b/internal/trackers/impl/unit3d/dupe_params_test.go
@@ -0,0 +1,98 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildUnit3DSearchParamsSkipsResolutionForOTW(t *testing.T) {
+	t.Parallel()
+
+	meta := api.DuplicateSubject{
+		Identity:    api.ExternalIdentity{TMDBID: 123, Category: "TV"},
+		Type:        "WEBDL",
+		Release:     api.ReleaseInfo{Resolution: "1080p"},
+		ReleaseName: "Show.S01E02.1080p.WEB-DL.H264-GRP",
+	}
+
+	params := buildDupeSearchParams(meta, "OTW")
+	if _, ok := params["resolutions[]"]; ok {
+		t.Fatalf("did not expect OTW resolution filter, got %#v", params["resolutions[]"])
+	}
+	if got := params.Get("name"); got != " S01" {
+		t.Fatalf("expected season search name, got %q", got)
+	}
+}
+
+func TestBuildUnit3DSearchParamsKeepsResolutionForOtherTrackers(t *testing.T) {
+	t.Parallel()
+
+	meta := api.DuplicateSubject{
+		Identity:    api.ExternalIdentity{TMDBID: 123, Category: "TV"},
+		Type:        "WEBDL",
+		Release:     api.ReleaseInfo{Resolution: "1080p"},
+		ReleaseName: "Show.S01E02.1080p.WEB-DL.H264-GRP",
+	}
+
+	params := buildDupeSearchParams(meta, "AITHER")
+	if got := params["resolutions[]"]; len(got) != 2 || got[0] != "3" || got[1] != "4" {
+		t.Fatalf("expected 1080p/1080i search filters, got %#v", got)
+	}
+}
+
+func TestBuildUnit3DSearchParamsUsesEMUWTrackerMappings(t *testing.T) {
+	t.Parallel()
+
+	meta := api.DuplicateSubject{
+		Identity:    api.ExternalIdentity{TMDBID: 123, Category: "MOVIE"},
+		Type:        "WEBDL",
+		Release:     api.ReleaseInfo{Resolution: "540p"},
+		ReleaseName: "Movie.2025.540p.WEB-DL.H264-GRP",
+	}
+
+	params := buildDupeSearchParams(meta, "EMUW")
+	if got := params.Get("name"); got != "" {
+		t.Fatalf("expected empty movie search name, got %q", got)
+	}
+	if got := params.Get("categories[]"); got != "1" {
+		t.Fatalf("expected EMUW movie category 1, got %q", got)
+	}
+	if got := params.Get("types[]"); got != "4" {
+		t.Fatalf("expected EMUW WEBDL type 4, got %q", got)
+	}
+	if got := params.Get("resolutions[]"); got != "7" {
+		t.Fatalf("expected EMUW 540p resolution 7, got %q", got)
+	}
+	if got := params.Get("perPage"); got != "100" {
+		t.Fatalf("expected perPage=100, got %q", got)
+	}
+}
+
+func TestBuildUnit3DSearchParamsUsesEMUWPaired1080Resolution(t *testing.T) {
+	t.Parallel()
+
+	meta := api.DuplicateSubject{
+		Identity:    api.ExternalIdentity{TMDBID: 123, Category: "TV"},
+		Type:        "SD",
+		Release:     api.ReleaseInfo{Resolution: "1080i"},
+		ReleaseName: "Show.S02E03.1080i.HDTV.H264-GRP",
+	}
+
+	params := buildDupeSearchParams(meta, "EMUW")
+	if got := params.Get("name"); got != " S02" {
+		t.Fatalf("expected season search name, got %q", got)
+	}
+	if got := params.Get("categories[]"); got != "2" {
+		t.Fatalf("expected EMUW TV category 2, got %q", got)
+	}
+	if got := params.Get("types[]"); got != "7" {
+		t.Fatalf("expected EMUW SD type 7, got %q", got)
+	}
+	if got := params["resolutions[]"]; len(got) != 2 || got[0] != "3" || got[1] != "4" {
+		t.Fatalf("expected EMUW 1080p/1080i filters, got %#v", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/emuw.go b/internal/trackers/impl/unit3d/emuw.go
deleted file mode 100644
index ae880bf3..00000000
--- a/internal/trackers/impl/unit3d/emuw.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteEMUWProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DEMUWTypeID,
-		resolveResolutionID: resolveUnit3DEMUWResolutionID,
-	}
-}
-
-func resolveUnit3DEMUWTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"ENCODE": "3",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-	}
-	typeID := mapping[inferUnit3DType(meta)]
-	if typeID == "" {
-		return "3"
-	}
-	return typeID
-}
-
-func resolveUnit3DEMUWResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1080p": "3",
-		"1080i": "4",
-		"720p":  "5",
-		"576p":  "6",
-		"540p":  "7",
-		"480p":  "8",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/filter_doc.go b/internal/trackers/impl/unit3d/filter_doc.go
new file mode 100644
index 00000000..de0d1b4c
--- /dev/null
+++ b/internal/trackers/impl/unit3d/filter_doc.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+// Unit3D filter contract
+//
+// The upstream torrent filter endpoint is GET /api/torrents/filter. It returns
+// a paginated torrent index and accepts optional query parameters in these
+// groups:
+//
+//   - Pagination and ordering: perPage, sortField, and sortDirection.
+//   - Text matching: name, description, mediainfo, bdinfo, uploader, keywords,
+//     and file_name.
+//   - Release dates and taxonomy: startYear, endYear, categories[], types[],
+//     resolutions[], and genres[].
+//   - External IDs: tmdbId, imdbId, tvdbId, and malId.
+//   - Collection membership: playlistId and collectionId.
+//   - Promotion and provenance: free, doubleup, featured, refundable,
+//     highspeed, internal, and personalRelease.
+//   - Swarm state: alive, dying, and dead.
+//   - TV coordinates: seasonNumber and episodeNumber.
+//
+// upbrr builds only the subset needed for duplicate detection in dupe_params.go,
+// encodes parameters with net/url.Values, and normalizes returned torrents in
+// the shared tracker-data client. Some deployments expose additional endpoints,
+// such as /api/torrents/pending; those are site compatibility extensions and not
+// part of the upstream filter contract.
+//
+// Source: https://github.com/HDInnovations/UNIT3D/blob/master/book/src/torrent_api.md
diff --git a/internal/trackers/impl/unit3d/ihd.go b/internal/trackers/impl/unit3d/ihd.go
deleted file mode 100644
index 4396b5b3..00000000
--- a/internal/trackers/impl/unit3d/ihd.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteIHDProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveResolutionID: resolveUnit3DIHDResolutionID,
-		resolveCategoryID:   resolveUnit3DIHDCategoryID,
-	}
-}
-
-func resolveUnit3DIHDCategoryID(meta api.PreparedMetadata) string {
-	category := resolveUnit3DCategory(meta)
-	if strings.EqualFold(category, "TV") && meta.Anime {
-		return "3"
-	}
-	if strings.EqualFold(category, "MOVIE") && meta.Anime {
-		return "4"
-	}
-	return resolveUnit3DCategoryID(meta)
-}
-
-func resolveUnit3DIHDResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1440p": "3",
-		"1080p": "3",
-		"1080i": "4",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/itt.go b/internal/trackers/impl/unit3d/itt.go
deleted file mode 100644
index f1e9130f..00000000
--- a/internal/trackers/impl/unit3d/itt.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteITTProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DITTTypeID}
-}
-
-func resolveUnit3DITTTypeID(meta api.PreparedMetadata) string {
-	name := strings.ToUpper(strings.TrimSpace(meta.ReleaseName))
-	switch {
-	case strings.Contains(name, "DLMUX"):
-		return "27"
-	case strings.Contains(name, "BDMUX"):
-		return "29"
-	case strings.Contains(name, "WEBMUX"):
-		return "26"
-	case strings.Contains(name, "DVDMUX"):
-		return "39"
-	case strings.Contains(name, "BDRIP"):
-		return "25"
-	}
-
-	mapping := map[string]string{
-		"DISC":      "1",
-		"REMUX":     "2",
-		"WEBDL":     "4",
-		"WEBRIP":    "5",
-		"HDTV":      "6",
-		"ENCODE":    "3",
-		"DVDRIP":    "24",
-		"CINEMA-MD": "14",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
diff --git a/internal/trackers/impl/unit3d/ldu.go b/internal/trackers/impl/unit3d/ldu.go
deleted file mode 100644
index c2ee3f9d..00000000
--- a/internal/trackers/impl/unit3d/ldu.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteLDUProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveCategoryID: resolveUnit3DLDUCategoryID}
-}
-
-func resolveUnit3DLDUCategoryID(meta api.PreparedMetadata) string {
-	category := resolveUnit3DCategory(meta)
-	genres := strings.ToLower(strings.TrimSpace(strings.Join([]string{
-		strings.TrimSpace(meta.Release.Genre),
-		resolveKeywords(meta),
-		resolveTMDBGenres(meta),
-		resolveIMDBGenres(meta),
-	}, ",")))
-	hasEnglishAudio := hasEnglishLanguage(meta.AudioLanguages)
-	hasEnglishSubs := hasEnglishLanguage(meta.SubtitleLanguages)
-	containsDubbed := strings.Contains(strings.ToLower(strings.TrimSpace(meta.Audio)), "dubbed")
-	edition := strings.ToLower(strings.TrimSpace(meta.Edition))
-
-	if strings.EqualFold(category, "MOVIE") {
-		if meta.Anime || meta.ExternalIDs.MALID != 0 {
-			return "8"
-		}
-		if strings.Contains(edition, "fanedit") || strings.Contains(edition, "fanres") {
-			return "12"
-		}
-		if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
-			return "21"
-		}
-		if hasAdultToken(genres) {
-			if !hasEnglishAudio && !hasEnglishSubs {
-				return "45"
-			}
-			return "6"
-		}
-		if strings.Contains(genres, "documentary") {
-			return "17"
-		}
-		if strings.Contains(genres, "musical") {
-			return "25"
-		}
-		if !hasEnglishAudio && !hasEnglishSubs {
-			return "22"
-		}
-		if containsDubbed {
-			return "27"
-		}
-		return "1"
-	}
-
-	if strings.EqualFold(category, "TV") {
-		if meta.Anime || meta.ExternalIDs.MALID != 0 {
-			return "9"
-		}
-		if strings.Contains(genres, "documentary") {
-			return "40"
-		}
-		if !hasEnglishAudio && !hasEnglishSubs {
-			return "29"
-		}
-		if meta.TVPack {
-			return "2"
-		}
-		if containsDubbed {
-			return "31"
-		}
-		return "41"
-	}
-
-	return resolveUnit3DCategoryID(meta)
-}
diff --git a/internal/trackers/impl/unit3d/localized_name.go b/internal/trackers/impl/unit3d/localized_name.go
new file mode 100644
index 00000000..7ae512a5
--- /dev/null
+++ b/internal/trackers/impl/unit3d/localized_name.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var localizedCodecReplacer = strings.NewReplacer("DD+ ", "DDP", "DD ", "DD", "AAC ", "AAC", "FLAC ", "FLAC")
+var localizedAudioMarkerReplacer = strings.NewReplacer("Dubbed", "", "Dual-Audio", "")
+var localizedAudioTagRegex = regexp.MustCompile(`(?i)-([^.-]+)\.(?:DUAL|MULTI)`)
+var portugueseLanguageNames = map[string]struct{}{
+	"português":  {},
+	"portuguese": {},
+	"pt-br":      {},
+	"pt":         {},
+}
+
+// FormatLocalizedName applies the shared Portuguese-localized naming convention
+// used by Unit3D sites that opt into it.
+func FormatLocalizedName(meta api.UploadSubject, customTag string) string {
+	name := baseReleaseName(meta)
+	if name == "" {
+		return ""
+	}
+	name = localizedCodecReplacer.Replace(name)
+	category := resolveUnit3DCategory(meta)
+	if (category == "TV" || meta.Anime) && meta.Release.Year > 0 {
+		year := strconv.Itoa(meta.Release.Year)
+		if strings.Contains(name, year) {
+			name = strings.ReplaceAll(name, "("+year+")", "")
+			name = strings.ReplaceAll(name, year, "")
+			name = strings.TrimSpace(name)
+		}
+	}
+	originalLanguage := strings.ToLower(resolveOriginalLanguage(meta))
+	aka := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		aka = meta.ProviderMetadata.TMDB.RetrievedAKA
+	}
+	_, portuguese := portugueseLanguageNames[originalLanguage]
+	if !portuguese && aka != "" {
+		name = strings.ReplaceAll(name, aka, "")
+		name = strings.Join(strings.Fields(name), " ")
+	}
+	if portuguese && aka != "" {
+		cleanAKA := strings.TrimSpace(strings.ReplaceAll(aka, "AKA", ""))
+		title := meta.Release.Title
+		name = strings.ReplaceAll(name, aka, "")
+		name = strings.ReplaceAll(name, strings.ReplaceAll(aka, " ", "."), "")
+		name = strings.ReplaceAll(name, title, cleanAKA)
+		name = strings.ReplaceAll(name, strings.ReplaceAll(title, " ", "."), cleanAKA)
+		name = strings.Join(strings.Fields(name), " ")
+	}
+	formatted := name
+	if !isDiscType(meta.DiscType) {
+		audioTag, hasPortuguese := "", false
+		for _, language := range meta.AudioLanguages {
+			if _, ok := portugueseLanguageNames[strings.ToLower(language)]; ok {
+				hasPortuguese = true
+				break
+			}
+		}
+		if hasPortuguese {
+			languages := make(map[string]struct{})
+			for _, language := range meta.AudioLanguages {
+				trimmed := strings.TrimSpace(language)
+				if trimmed == "" {
+					continue
+				}
+				if code, _, ok := languageCode(trimmed); ok {
+					languages[code] = struct{}{}
+				}
+			}
+			if len(languages) >= 3 {
+				audioTag = " MULTI"
+			} else if len(languages) == 2 {
+				audioTag = " DUAL"
+			}
+		}
+		if audioTag != "" {
+			formatted = localizedAudioMarkerReplacer.Replace(formatted)
+			formatted = strings.Join(strings.Fields(formatted), " ")
+			if index := strings.LastIndex(formatted, "-"); index != -1 {
+				prefix, suffix := formatted[:index], formatted[index+1:]
+				cleanTag := strings.TrimPrefix(customTag, "-")
+				if cleanTag != "" && strings.EqualFold(strings.TrimSpace(suffix), cleanTag) {
+					search := meta.Filename
+					if search == "" {
+						search = meta.ReleaseName
+					}
+					if match := localizedAudioTagRegex.FindStringSubmatch(search); len(match) > 1 {
+						group := match[1]
+						if !strings.EqualFold(group, meta.Release.Group) {
+							formatted = prefix + "-" + group + audioTag + "-" + suffix
+						} else {
+							formatted = prefix + audioTag + "-" + suffix
+						}
+					} else {
+						formatted = prefix + audioTag + "-" + suffix
+					}
+				} else {
+					formatted = prefix + audioTag + "-" + suffix
+				}
+			} else {
+				formatted += audioTag
+			}
+		}
+	}
+	return addNoGroupSuffix(formatted, meta, "NoGroup")
+}
diff --git a/internal/trackers/impl/unit3d/localized_name_test.go b/internal/trackers/impl/unit3d/localized_name_test.go
new file mode 100644
index 00000000..236dd44f
--- /dev/null
+++ b/internal/trackers/impl/unit3d/localized_name_test.go
@@ -0,0 +1,357 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestFormatLocalizedNamePortugueseConvention(t *testing.T) {
+	tests := []struct {
+		name      string
+		meta      api.UploadSubject
+		customTag string
+		want      string
+	}{
+		{
+			name: "Basic movie",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL DDP5.1 H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				Tag: "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL DDP5.1 H.264-GRP",
+		},
+		{
+			name: "Portuguese DUAL",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
+		},
+		{
+			name: "Custom tag with original group (same as internal)",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-CBR",
+				Filename:    "Movie.2023.1080p.WEB-DL.H.264-GRP.DUAL.mkv",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "CBR",
+			},
+			customTag: "-CBR",
+			want:      "Movie 2023 1080p WEB-DL H.264 DUAL-CBR",
+		},
+		{
+			name: "Brazilian PT override",
+			meta: api.UploadSubject{
+				ReleaseName: "A Foreign Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "A Foreign Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				Identity: api.ExternalIdentity{
+					Category: "MOVIE",
+				},
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{
+						OriginalLanguage: "pt",
+						RetrievedAKA:     "Filme Brasileiro AKA",
+					},
+				},
+				Tag: "-GRP",
+			},
+			want: "Filme Brasileiro 2023 1080p WEB-DL H.264-GRP",
+		},
+		{
+			name: "TV year stripping",
+			meta: api.UploadSubject{
+				ReleaseName: "Show Series 2023 S01E01 1080p WEB-DL-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Show Series",
+					Year:  2023,
+					Group: "GRP",
+				},
+				Identity: api.ExternalIdentity{Category: "TV"},
+				Tag:      "GRP",
+			},
+			want: "Show Series S01E01 1080p WEB-DL-GRP",
+		},
+		{
+			name: "Anime year stripping",
+			meta: api.UploadSubject{
+				ReleaseName: "Anime Movie (2023) 1080p-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Anime Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				Anime: true,
+				Tag:   "GRP",
+			},
+			want: "Anime Movie 1080p-GRP",
+		},
+		{
+			name: "Non-pt AKA removal (with spaces)",
+			meta: api.UploadSubject{
+				ReleaseName: "Title AKA Some AKA 2023 1080p-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Title",
+					Year:  2023,
+					Group: "GRP",
+				},
+				ProviderMetadata: api.SourceScopedMetadata{
+					TMDB: &api.TMDBMetadata{
+						OriginalLanguage: "en",
+						RetrievedAKA:     "Some AKA",
+					},
+				},
+				Tag: "-GRP",
+			},
+			want: "Title AKA 2023 1080p-GRP",
+		},
+		{
+			name: "Portuguese MULTI",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese", "French"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL H.264 MULTI-GRP",
+		},
+		{
+			name: "Disc type bypass",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p BluRay REMUX AVC-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				DiscType:       "BDMV",
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p BluRay REMUX AVC-GRP",
+		},
+		{
+			name: "Custom tag with original group from filename",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL-CBR",
+				Filename:    "Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "NEWGRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "CBR",
+			},
+			customTag: "-CBR",
+			want:      "Movie 2023 1080p WEB-DL-ORIGGRP DUAL-CBR",
+		},
+		{
+			name: "Custom tag and same group from filename",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL-CBR",
+				Filename:    "Movie.2023.1080p.WEB-DL-GRP.DUAL.mkv",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "CBR",
+			},
+			customTag: "-CBR",
+			want:      "Movie 2023 1080p WEB-DL DUAL-CBR",
+		},
+		{
+			name: "No group suffix",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL-NoGrp",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+			},
+			want: "Movie 2023 1080p WEB-DL-NoGroup",
+		},
+		{
+			name: "Blank audio entries with one usable language",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"", "Portuguese", "   "},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL H.264-GRP",
+		},
+		{
+			name: "Blank audio entries with two usable languages",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "", "Portuguese", "   "},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
+		},
+		{
+			name: "Blank audio entries with three usable languages",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "", "Portuguese", "   ", "French"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL H.264 MULTI-GRP",
+		},
+		{
+			name: "Custom tag substring in title / source must not inject filename group",
+			meta: api.UploadSubject{
+				ReleaseName: "CBR Movie 2023 1080p WEB-DL H.264-GRP",
+				Filename:    "CBR.Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
+				Release: api.ReleaseInfo{
+					Title: "CBR Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "GRP",
+			},
+			customTag: "-CBR",
+			want:      "CBR Movie 2023 1080p WEB-DL H.264 DUAL-GRP",
+		},
+		{
+			name: "Real configured custom suffix should still inject filename group",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie 2023 1080p WEB-DL H.264-CBR",
+				Filename:    "Movie.2023.1080p.WEB-DL-ORIGGRP.DUAL.mkv",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "CBR",
+			},
+			customTag: "-CBR",
+			want:      "Movie 2023 1080p WEB-DL H.264-ORIGGRP DUAL-CBR",
+		},
+		{
+			name: "Dubbed inputs with Portuguese replacement eligibility",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie Dubbed 2023 1080p WEB-DL-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL DUAL-GRP",
+		},
+		{
+			name: "Dubbed inputs without Portuguese replacement eligibility",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie Dubbed 2023 1080p WEB-DL-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English"},
+				Tag:            "GRP",
+			},
+			want: "Movie Dubbed 2023 1080p WEB-DL-GRP",
+		},
+		{
+			name: "Dual-Audio inputs with Portuguese replacement eligibility",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English", "Portuguese"},
+				Tag:            "GRP",
+			},
+			want: "Movie 2023 1080p WEB-DL DUAL-GRP",
+		},
+		{
+			name: "Dual-Audio inputs without Portuguese replacement eligibility",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English"},
+				Tag:            "GRP",
+			},
+			want: "Movie Dual-Audio 2023 1080p WEB-DL-GRP",
+		},
+		{
+			name: "Existing DD / DDP / AAC / FLAC normalization",
+			meta: api.UploadSubject{
+				ReleaseName: "Movie DD+ 5.1 DD 5.1 AAC 2.0 FLAC 2.0-GRP",
+				Release: api.ReleaseInfo{
+					Title: "Movie",
+					Year:  2023,
+					Group: "GRP",
+				},
+				AudioLanguages: []string{"English"},
+				Tag:            "GRP",
+			},
+			want: "Movie DDP5.1 DD5.1 AAC2.0 FLAC2.0-GRP",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := FormatLocalizedName(tt.meta, tt.customTag); got != tt.want {
+				t.Errorf("FormatLocalizedName() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/trackers/impl/unit3d/lst.go b/internal/trackers/impl/unit3d/lst.go
deleted file mode 100644
index 30564027..00000000
--- a/internal/trackers/impl/unit3d/lst.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-)
-
-func siteLSTProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		applyAdditionalPayload: func(req trackers.UploadRequest, data map[string]string) {
-			data["draft_queue_opt_in"] = boolFlag(req.TrackerConfig.Draft)
-			if editionID, ok := resolveLSTEditionID(req.Meta.Edition); ok {
-				data["edition_id"] = editionID
-			}
-		},
-	}
-}
-
-func resolveLSTEditionID(edition string) (string, bool) {
-	normalized := strings.ToLower(strings.TrimSpace(edition))
-	normalized = strings.ReplaceAll(normalized, "’", "'")
-	mapping := map[string]string{
-		"collector's edition": "1",
-		"director's cut":      "2",
-		"extended cut":        "3",
-		"extended uncut":      "4",
-		"extended unrated":    "5",
-		"limited edition":     "6",
-		"special edition":     "7",
-		"theatrical cut":      "8",
-		"uncut":               "9",
-		"unrated":             "10",
-		"x cut":               "11",
-		"alternative cut":     "12",
-		"other":               "0",
-	}
-	value, ok := mapping[normalized]
-	return value, ok
-}
diff --git a/internal/trackers/impl/unit3d/metadata_policy_test.go b/internal/trackers/impl/unit3d/metadata_policy_test.go
new file mode 100644
index 00000000..db6eedca
--- /dev/null
+++ b/internal/trackers/impl/unit3d/metadata_policy_test.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestMetadataPolicyDefaultsToStrictTMDB(t *testing.T) {
+	t.Parallel()
+
+	definition := NewWithProfile(Profile{Name: "EXAMPLE"})
+	policy := definition.MetadataPolicy()
+	if len(policy.Requirements) != 1 {
+		t.Fatalf("requirements = %#v", policy.Requirements)
+	}
+	requirement := policy.Requirements[0]
+	if requirement.Disposition != api.RuleDispositionStrict ||
+		len(requirement.AnyOf) != 1 || requirement.AnyOf[0] != trackers.MetadataFieldTMDB {
+		t.Fatalf("default requirement = %#v", requirement)
+	}
+
+	policy.Requirements[0].Disposition = api.RuleDispositionWaivable
+	if got := definition.MetadataPolicy().Requirements[0].Disposition; got != api.RuleDispositionStrict {
+		t.Fatalf("mutated default disposition = %q", got)
+	}
+}
+
+func TestMetadataPolicyAllowsSiteOverride(t *testing.T) {
+	t.Parallel()
+
+	override := &trackers.TrackerMetadataPolicy{Requirements: []trackers.MetadataRequirement{{
+		Scope:       trackers.MetadataScopeAny,
+		AnyOf:       []trackers.MetadataField{trackers.MetadataFieldTMDB},
+		Disposition: api.RuleDispositionWaivable,
+	}}}
+	definition := NewWithProfile(Profile{Name: "EXAMPLE", MetadataPolicy: override})
+	override.Requirements[0].Disposition = api.RuleDispositionStrict
+	override.Requirements[0].AnyOf[0] = trackers.MetadataFieldIMDB
+
+	policy := definition.MetadataPolicy()
+	if policy.Requirements[0].Disposition != api.RuleDispositionWaivable ||
+		policy.Requirements[0].AnyOf[0] != trackers.MetadataFieldTMDB {
+		t.Fatalf("site override = %#v", policy.Requirements[0])
+	}
+
+	policy.Requirements[0].AnyOf[0] = trackers.MetadataFieldIMDB
+	if got := definition.MetadataPolicy().Requirements[0].AnyOf[0]; got != trackers.MetadataFieldTMDB {
+		t.Fatalf("mutated site override field = %q", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/names.go b/internal/trackers/impl/unit3d/names.go
index 0bf1fe23..7f6af9f7 100644
--- a/internal/trackers/impl/unit3d/names.go
+++ b/internal/trackers/impl/unit3d/names.go
@@ -5,11 +5,8 @@ package unit3d
 
 import (
 	"regexp"
-	"strconv"
 	"strings"
 	"sync"
-	"unicode"
-	"unicode/utf8"
 
 	"golang.org/x/text/language"
 	"golang.org/x/text/language/display"
@@ -25,46 +22,20 @@ var (
 	languageTagLookup     map[string]language.Tag
 )
 
-func buildUnit3DName(tracker string, meta api.PreparedMetadata, cfg config.TrackerConfig) string {
-	trackerName := strings.ToUpper(strings.TrimSpace(tracker))
-	if trackerName == "RHD" {
-		return buildRHDName(meta)
+func buildUnit3DName(_ string, meta api.UploadSubject, cfg config.TrackerConfig, profiles ...SiteProfile) string {
+	profile := firstSiteProfile(profiles)
+	if profile.BuildName != nil {
+		return profile.BuildName(meta, cfg)
 	}
-
 	name := baseReleaseName(meta)
 	if name == "" {
 		return ""
 	}
 
-	switch trackerName {
-	case "AITHER":
-		return BuildAitherName(meta)
-	case "ACM":
-		return buildACMName(meta)
-	case "CBR":
-		return BuildCBRName(meta, cfg.TagForCustomRelease)
-	case "DP":
-		return buildDPName(name, meta)
-	case "LCD":
-		return BuildCBRName(meta, cfg.TagForCustomRelease)
-	case "LDU":
-		return buildLDUName(name, meta)
-	case "RF":
-		return addNoGroupSuffix(name, meta, "NoGroup")
-	case "SAM":
-		return BuildCBRName(meta, cfg.TagForCustomRelease)
-	case "OE":
-		return addNoGroupSuffix(name, meta, "NOGRP")
-	case "ULCX":
-		return buildULCXName(name, meta)
-	case "ZNTH":
-		return buildZNTHName(name, meta)
-	default:
-		return name
-	}
+	return name
 }
 
-func baseReleaseName(meta api.PreparedMetadata) string {
+func baseReleaseName(meta api.UploadSubject) string {
 	name := strings.TrimSpace(meta.ReleaseName)
 	if name == "" {
 		name = strings.TrimSpace(meta.ReleaseNameNoTag)
@@ -72,47 +43,7 @@ func baseReleaseName(meta api.PreparedMetadata) string {
 	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
 }
 
-func buildDPName(name string, meta api.PreparedMetadata) string {
-	audioLabel := resolveDPAudioLabel(meta.AudioLanguages)
-	if audioLabel != "" {
-		name = strings.Replace(name, "Dual-Audio", audioLabel, 1)
-	}
-	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-}
-
-func buildULCXName(name string, meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && (strings.Contains(strings.ToLower(strings.TrimSpace(meta.Edition)), "hybrid") || meta.WebDV) {
-		name = strings.Replace(name, "Hybrid ", "", 1)
-	}
-	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-}
-
-func resolveDPAudioLabel(languages []string) string {
-	normalized := make(map[string]struct{}, len(languages))
-	for _, language := range languages {
-		trimmed := strings.TrimSpace(language)
-		if trimmed == "" {
-			continue
-		}
-		normalized[strings.ToUpper(trimmed)] = struct{}{}
-	}
-
-	switch len(normalized) {
-	case 0:
-		return ""
-	case 1:
-		for value := range normalized {
-			return value
-		}
-		return ""
-	case 2:
-		return "Dual-Audio"
-	default:
-		return "MULTi"
-	}
-}
-
-func addNoGroupSuffix(name string, meta api.PreparedMetadata, suffix string) string {
+func addNoGroupSuffix(name string, meta api.UploadSubject, suffix string) string {
 	tag := strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-"))
 	normalizedName := noGroupTagPattern.ReplaceAllString(name, "")
 	normalizedName = strings.TrimSpace(strings.Join(strings.Fields(normalizedName), " "))
@@ -128,54 +59,6 @@ func addNoGroupSuffix(name string, meta api.PreparedMetadata, suffix string) str
 	return normalizedName + "-" + suffix
 }
 
-func buildLDUName(name string, meta api.PreparedMetadata) string {
-	catID := resolveUnit3DLDUCategoryID(meta)
-	nonEnglishOriginal := !isEnglishLanguageToken(resolveOriginalLanguage(meta))
-	isoAudio, nonEnglishAudio := firstAudioLanguageCode(meta.AudioLanguages)
-	isoSubtitle := firstSubtitleLanguageCode(meta.SubtitleLanguages)
-
-	if catID == "18" && isoSubtitle != "" {
-		return strings.TrimSpace(strings.Join(strings.Fields(name+" [Subs "+isoSubtitle+"]"), " "))
-	}
-
-	if !nonEnglishOriginal && !nonEnglishAudio {
-		return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-	}
-
-	languageParts := make([]string, 0, 2)
-	if isoAudio != "" {
-		languageParts = append(languageParts, "["+isoAudio+"]")
-	}
-	if isoSubtitle != "" {
-		languageParts = append(languageParts, "[Subs "+isoSubtitle+"]")
-	}
-	if len(languageParts) == 0 {
-		return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-	}
-
-	return strings.TrimSpace(strings.Join(strings.Fields(name+" "+strings.Join(languageParts, " ")), " "))
-}
-
-func firstAudioLanguageCode(languages []string) (string, bool) {
-	for _, value := range languages {
-		code, english, ok := languageCode(value)
-		if ok {
-			return code, !english
-		}
-	}
-	return "", false
-}
-
-func firstSubtitleLanguageCode(languages []string) string {
-	for _, value := range languages {
-		code, _, ok := languageCode(value)
-		if ok {
-			return code
-		}
-	}
-	return ""
-}
-
 func languageCode(value string) (string, bool, bool) {
 	normalized := languageutil.NormalizeLanguageDisplay(value)
 	if normalized == "" {
@@ -231,25 +114,17 @@ func buildLanguageTagLookup() {
 	}
 }
 
-func resolveOriginalLanguage(meta api.PreparedMetadata) string {
+func resolveOriginalLanguage(meta api.UploadSubject) string {
 	switch {
-	case meta.ExternalMetadata.TMDB != nil && strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage)
-	case meta.ExternalMetadata.IMDB != nil && strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage) != "":
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage)
+	case meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage)
+	case meta.ProviderMetadata.IMDB != nil && strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage) != "":
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage)
 	default:
 		return ""
 	}
 }
 
-func isEnglishLanguageToken(value string) bool {
-	normalized := languageutil.NormalizeLanguageDisplay(value)
-	if normalized != "" {
-		value = normalized
-	}
-	return isEnglishLanguageTag(strings.TrimSpace(value))
-}
-
 func isEnglishLanguageTag(value string) bool {
 	switch strings.ToLower(strings.TrimSpace(value)) {
 	case "english", "en", "eng", "en-us", "en-gb":
@@ -268,209 +143,3 @@ func isNoGroupTag(tag string) bool {
 		return false
 	}
 }
-
-// buildZNTHName applies ZNTH release-name policy before upload.
-// TV names drop episode-title text when it appears before the resolution, while
-// non-TV names prefer the IMDb year when it disagrees with the parsed release year.
-func buildZNTHName(name string, meta api.PreparedMetadata) string {
-	category := resolveUnit3DCategory(meta)
-	if category == "TV" && strings.TrimSpace(meta.EpisodeTitle) != "" {
-		resolution := resolveResolution(meta)
-		if resolution != "" {
-			name = replaceZNTHEpisodeTitle(name, meta.EpisodeTitle, resolution)
-		}
-	}
-
-	if category != "TV" {
-		imdbYear := 0
-		if meta.ExternalMetadata.IMDB != nil {
-			imdbYear = meta.ExternalMetadata.IMDB.Year
-		}
-		year := meta.Release.Year
-		if imdbYear > 0 && year > 0 && imdbYear != year {
-			name = replaceZNTHMovieYear(name, meta, year, imdbYear)
-		}
-	}
-	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
-}
-
-// replaceZNTHEpisodeTitle removes the episode-title segment only when its
-// normalized text appears immediately before a matching resolution token.
-func replaceZNTHEpisodeTitle(name string, episodeTitle string, resolution string) string {
-	normalizedTitle := normalizeZNTHAlphaNum(episodeTitle)
-	if normalizedTitle == "" {
-		return name
-	}
-
-	for _, resolutionStart := range findZNTHTokenIndexes(name, resolution) {
-		titleStart, ok := findZNTHTitleStartBefore(name[:resolutionStart], normalizedTitle)
-		if !ok {
-			continue
-		}
-		return name[:titleStart] + name[resolutionStart:]
-	}
-	return name
-}
-
-// findZNTHTitleStartBefore returns the byte offset of the trailing segment in
-// prefix whose alphanumeric-normalized text matches normalizedTitle.
-func findZNTHTitleStartBefore(prefix string, normalizedTitle string) (int, bool) {
-	candidates := []int{0}
-	for i, r := range prefix {
-		if !isZNTHAlphaNum(r) {
-			candidates = append(candidates, i+len(string(r)))
-		}
-	}
-
-	for i := len(candidates) - 1; i >= 0; i-- {
-		start := candidates[i]
-		if normalizeZNTHAlphaNum(prefix[start:]) == normalizedTitle {
-			return start, true
-		}
-	}
-	return 0, false
-}
-
-// replaceZNTHMovieYear replaces the parsed release-year token before the first
-// matching resolution token, or before a trailing metadata release-group suffix
-// when no resolution is known.
-func replaceZNTHMovieYear(name string, meta api.PreparedMetadata, year int, imdbYear int) string {
-	yearToken := strconv.Itoa(year)
-	yearIndexes := findZNTHTokenIndexes(name, yearToken)
-	if len(yearIndexes) == 0 {
-		return name
-	}
-
-	searchEnd := len(name)
-	if resolution := resolveResolution(meta); resolution != "" {
-		resolutionIndexes := findZNTHTokenIndexes(name, resolution)
-		if len(resolutionIndexes) > 0 {
-			searchEnd = resolutionIndexes[0]
-		}
-	} else if groupStart, ok := findZNTHReleaseGroupStart(name, meta.Release.Group); ok {
-		searchEnd = groupStart
-	}
-
-	replaceStart := -1
-	for _, yearStart := range yearIndexes {
-		if yearStart < searchEnd {
-			replaceStart = yearStart
-		}
-	}
-	if replaceStart == -1 {
-		return name
-	}
-
-	replacement := strconv.Itoa(imdbYear)
-	return name[:replaceStart] + replacement + name[replaceStart+len(yearToken):]
-}
-
-// findZNTHTokenIndexes returns original-string byte offsets for
-// case-insensitive token matches bounded by non-alphanumeric ZNTH separators.
-func findZNTHTokenIndexes(value string, token string) []int {
-	token = strings.TrimSpace(token)
-	if token == "" {
-		return nil
-	}
-
-	tokenRunes := utf8.RuneCountInString(token)
-	indexes := []int{}
-	for start := range value {
-		end, ok := endAfterZNTHRunes(value, start, tokenRunes)
-		if !ok {
-			break
-		}
-		if strings.EqualFold(value[start:end], token) && hasZNTHTokenBoundaries(value, start, end) {
-			indexes = append(indexes, start)
-		}
-	}
-	return indexes
-}
-
-// findZNTHReleaseGroupStart returns the byte offset of a trailing "-group"
-// suffix only when group is a real parsed release group.
-func findZNTHReleaseGroupStart(name string, group string) (int, bool) {
-	group = strings.TrimSpace(group)
-	if group == "" || isNoGroupTag(group) {
-		return 0, false
-	}
-
-	trimmedName := strings.TrimRightFunc(name, unicode.IsSpace)
-	groupStart, ok := foldSuffixStart(trimmedName, group)
-	if !ok {
-		return 0, false
-	}
-
-	boundary := groupStart
-	for boundary > 0 {
-		r, size := utf8.DecodeLastRuneInString(trimmedName[:boundary])
-		if !unicode.IsSpace(r) {
-			break
-		}
-		boundary -= size
-	}
-	if boundary > 0 && trimmedName[boundary-1] == '-' {
-		return boundary - 1, true
-	}
-	return 0, false
-}
-
-// foldSuffixStart returns the byte offset where suffix starts when value ends
-// with suffix under Unicode case folding.
-func foldSuffixStart(value string, suffix string) (int, bool) {
-	start := len(value)
-	for range suffix {
-		if start == 0 {
-			return 0, false
-		}
-		_, size := utf8.DecodeLastRuneInString(value[:start])
-		start -= size
-	}
-	return start, strings.EqualFold(value[start:], suffix)
-}
-
-// endAfterZNTHRunes returns the byte offset after count runes from start.
-func endAfterZNTHRunes(value string, start int, count int) (int, bool) {
-	end := start
-	for range count {
-		if end >= len(value) {
-			return 0, false
-		}
-		_, size := utf8.DecodeRuneInString(value[end:])
-		end += size
-	}
-	return end, true
-}
-
-// hasZNTHTokenBoundaries reports whether start and end are outside adjacent
-// letters or digits in value.
-func hasZNTHTokenBoundaries(value string, start int, end int) bool {
-	if start > 0 {
-		r, _ := utf8.DecodeLastRuneInString(value[:start])
-		if isZNTHAlphaNum(r) {
-			return false
-		}
-	}
-	if end < len(value) {
-		r, _ := utf8.DecodeRuneInString(value[end:])
-		if isZNTHAlphaNum(r) {
-			return false
-		}
-	}
-	return true
-}
-
-// normalizeZNTHAlphaNum lowercases value and drops every non-alphanumeric rune.
-func normalizeZNTHAlphaNum(value string) string {
-	var b strings.Builder
-	for _, r := range value {
-		if isZNTHAlphaNum(r) {
-			b.WriteRune(unicode.ToLower(r))
-		}
-	}
-	return b.String()
-}
-
-func isZNTHAlphaNum(r rune) bool {
-	return unicode.IsLetter(r) || unicode.IsDigit(r)
-}
diff --git a/internal/trackers/impl/unit3d/oe.go b/internal/trackers/impl/unit3d/oe.go
deleted file mode 100644
index 9601ea8c..00000000
--- a/internal/trackers/impl/unit3d/oe.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteOEProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DOETypeID}
-}
-
-func resolveUnit3DOETypeID(meta api.PreparedMetadata) string {
-	typeValue := inferUnit3DType(meta)
-	if typeValue == "DVDRIP" {
-		typeValue = "ENCODE"
-	}
-
-	switch typeValue {
-	case "DISC":
-		return "19"
-	case "REMUX":
-		return "20"
-	case "WEBDL":
-		return "21"
-	case "WEBRIP", "ENCODE":
-		switch normalizeUnit3DVideoCodec(meta.VideoCodec) {
-		case "HEVC":
-			return "10"
-		case "AV1":
-			return "14"
-		case "AVC":
-			return "15"
-		default:
-			return "16"
-		}
-	default:
-		return "16"
-	}
-}
-
-func normalizeUnit3DVideoCodec(value string) string {
-	codec := strings.ToUpper(strings.TrimSpace(value))
-	switch {
-	case strings.Contains(codec, "AV1"):
-		return "AV1"
-	case strings.Contains(codec, "HEVC") || strings.Contains(codec, "H.265") || strings.Contains(codec, "H265") || strings.Contains(codec, "X265"):
-		return "HEVC"
-	case strings.Contains(codec, "AVC") || strings.Contains(codec, "H.264") || strings.Contains(codec, "H264") || strings.Contains(codec, "X264"):
-		return "AVC"
-	default:
-		return ""
-	}
-}
diff --git a/internal/trackers/impl/unit3d/otw.go b/internal/trackers/impl/unit3d/otw.go
deleted file mode 100644
index 65dd49e0..00000000
--- a/internal/trackers/impl/unit3d/otw.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteOTWProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DOTWTypeID}
-}
-
-func resolveUnit3DOTWTypeID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return "1"
-	}
-	if isDiscType(meta.DiscType) {
-		return "7"
-	}
-
-	typeValue := inferUnit3DType(meta)
-	if typeValue == "DVDRIP" {
-		return "8"
-	}
-
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-		"ENCODE": "3",
-	}
-	return mapping[typeValue]
-}
diff --git a/internal/trackers/impl/unit3d/profiles.go b/internal/trackers/impl/unit3d/profiles.go
index 40a9c713..49334d23 100644
--- a/internal/trackers/impl/unit3d/profiles.go
+++ b/internal/trackers/impl/unit3d/profiles.go
@@ -4,51 +4,36 @@
 package unit3d
 
 import (
-	"strings"
+	"context"
 
+	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-type unit3DSiteProfile struct {
-	resolveTypeID          func(meta api.PreparedMetadata) string
-	resolveResolutionID    func(meta api.PreparedMetadata) string
-	resolveCategoryID      func(meta api.PreparedMetadata) string
-	applyAdditionalPayload func(req trackers.UploadRequest, data map[string]string)
+// SiteProfile contains optional site-owned Unit3D payload callbacks.
+type SiteProfile struct {
+	// BuildName optionally overrides the generic Unit3D release-name builder.
+	BuildName func(meta api.UploadSubject, cfg config.TrackerConfig) string
+	// BuildDescription optionally renders site-specific tracker markup.
+	BuildDescription func(ctx context.Context, meta api.UploadSubject, appConfig config.Config, trackerConfig config.TrackerConfig, logger api.Logger, keptDescription string, menuImages []api.ScreenshotImage, screenshots []api.ScreenshotImage) (string, error)
+	// ResolveKeywords optionally maps prepared metadata to Unit3D keywords.
+	ResolveKeywords func(meta api.UploadSubject) string
+	// ResolveTypeID optionally maps prepared metadata to a site type identifier.
+	ResolveTypeID func(meta api.UploadSubject) string
+	// ResolveResolutionID optionally maps prepared metadata to a site resolution identifier.
+	ResolveResolutionID func(meta api.UploadSubject) string
+	// ResolveCategoryID optionally maps prepared metadata to a site category identifier.
+	ResolveCategoryID func(meta api.UploadSubject) string
+	// ApplyAdditionalPayload appends site-owned fields to a prepared payload.
+	ApplyAdditionalPayload func(req trackers.PreparationInput, data map[string]string)
+	// FinalizeDescription applies final site-owned description transformations.
+	FinalizeDescription func(description string, meta api.UploadSubject) string
 }
 
-var unit3DSiteProfiles = map[string]unit3DSiteProfile{
-	"A4K":    siteA4KProfile(),
-	"ACM":    siteACMProfile(),
-	"AITHER": siteAITHERProfile(),
-	"BLU":    siteBLUProfile(),
-	"CBR":    siteCBRProfile(),
-	"EMUW":   siteEMUWProfile(),
-	"IHD":    siteIHDProfile(),
-	"ITT":    siteITTProfile(),
-	"LDU":    siteLDUProfile(),
-	"LST":    siteLSTProfile(),
-	"OE":     siteOEProfile(),
-	"OTW":    siteOTWProfile(),
-	"PT":     sitePTProfile(),
-	"R4E":    siteR4EProfile(),
-	"RF":     siteRFProfile(),
-	"RHD":    siteRHDProfile(),
-	"SHRI":   siteSHRIProfile(),
-	"STC":    siteSTCProfile(),
-	"TIK":    siteTIKProfile(),
-	"TLZ":    siteTLZProfile(),
-	"TOS":    siteTOSProfile(),
-	"UTP":    siteUTPProfile(),
-	"YUS":    siteYUSProfile(),
-	"ZNTH":   siteZNTHProfile(),
-}
-
-func unit3DSiteProfileFor(tracker string) (unit3DSiteProfile, bool) {
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	if key == "" {
-		return unit3DSiteProfile{}, false
+func firstSiteProfile(profiles []SiteProfile) SiteProfile {
+	if len(profiles) == 0 {
+		return SiteProfile{}
 	}
-	profile, ok := unit3DSiteProfiles[key]
-	return profile, ok
+	return profiles[0]
 }
diff --git a/internal/trackers/impl/unit3d/pt.go b/internal/trackers/impl/unit3d/pt.go
deleted file mode 100644
index 69430110..00000000
--- a/internal/trackers/impl/unit3d/pt.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func sitePTProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DPTTypeID,
-		resolveResolutionID: resolveUnit3DPTResolutionID,
-		applyAdditionalPayload: func(req trackers.UploadRequest, data map[string]string) {
-			data["audio_pt"] = boolFlag(hasEuropeanPortuguese(req.Meta.AudioLanguages))
-			data["legenda_pt"] = boolFlag(hasEuropeanPortuguese(req.Meta.SubtitleLanguages))
-		},
-	}
-}
-
-func hasEuropeanPortuguese(languages []string) bool {
-	for _, language := range languages {
-		lower := strings.ToLower(strings.TrimSpace(language))
-		if lower == "" {
-			continue
-		}
-		if strings.Contains(lower, "brazil") || strings.Contains(lower, "brasil") || strings.Contains(lower, "pt-br") || strings.Contains(lower, "ptbr") {
-			continue
-		}
-		if strings.Contains(lower, "portuguese") || strings.EqualFold(lower, "pt") || strings.Contains(lower, "português") {
-			return true
-		}
-	}
-	return false
-}
-
-func resolveUnit3DPTTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"WEBDL":  "4",
-		"WEBRIP": "39",
-		"HDTV":   "6",
-		"ENCODE": "3",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
-
-func resolveUnit3DPTResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1440p": "13",
-		"1080p": "3",
-		"1080i": "4",
-		"720p":  "5",
-		"576p":  "6",
-		"576i":  "7",
-		"540p":  "11",
-		"480p":  "8",
-		"480i":  "9",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/r4e.go b/internal/trackers/impl/unit3d/r4e.go
deleted file mode 100644
index e8d539fb..00000000
--- a/internal/trackers/impl/unit3d/r4e.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteR4EProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveCategoryID: resolveUnit3DR4ECategoryID}
-}
-
-func resolveUnit3DR4ECategoryID(meta api.PreparedMetadata) string {
-	genreIDs := ""
-	if meta.ExternalMetadata.TMDB != nil {
-		genreIDs = strings.TrimSpace(meta.ExternalMetadata.TMDB.GenreIDs)
-	}
-	isDoc := false
-	if genreIDs != "" {
-		for value := range strings.SplitSeq(genreIDs, ",") {
-			if strings.TrimSpace(value) == "99" {
-				isDoc = true
-				break
-			}
-		}
-	}
-	category := resolveUnit3DCategory(meta)
-	if strings.EqualFold(category, "MOVIE") {
-		if isDoc {
-			return "66"
-		}
-		return "70"
-	}
-	if strings.EqualFold(category, "TV") {
-		if isDoc {
-			return "2"
-		}
-		return "79"
-	}
-	return "24"
-}
diff --git a/internal/trackers/impl/unit3d/rf.go b/internal/trackers/impl/unit3d/rf.go
deleted file mode 100644
index 0df2a60f..00000000
--- a/internal/trackers/impl/unit3d/rf.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteRFProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DRFTypeID,
-		resolveResolutionID: resolveUnit3DRFResolutionID,
-	}
-}
-
-func resolveUnit3DRFTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "43",
-		"REMUX":  "40",
-		"WEBDL":  "42",
-		"WEBRIP": "45",
-		"ENCODE": "41",
-		"HDTV":   "35",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
-
-func resolveUnit3DRFResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1080p": "3",
-		"1080i": "4",
-		"720p":  "5",
-		"576p":  "6",
-		"576i":  "7",
-		"480p":  "8",
-		"480i":  "9",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
diff --git a/internal/trackers/impl/unit3d/rhd.go b/internal/trackers/impl/unit3d/rhd.go
deleted file mode 100644
index a8494485..00000000
--- a/internal/trackers/impl/unit3d/rhd.go
+++ /dev/null
@@ -1,357 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-
-	"golang.org/x/text/language"
-	"golang.org/x/text/language/display"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-var (
-	rhdRegradedRegex   = rhdTokenRegex(`regraded`)
-	rhdUpscaleRegex    = rhdTokenRegex(`upscaled?`, `upscl`, `upsuhd`)
-	rhdInternalRegex   = rhdTokenRegex(`internal`)
-	rhdIncompleteRegex = rhdTokenRegex(`incomplete`)
-	rhdDubbedRegex     = rhdTokenRegex(`dubbed`, `synced`, `ac3d`, `ld`, `line`, `mic`, `md`)
-)
-
-// rhdTokenRegex matches RHD marker tokens only when they are delimited outside
-// alphanumeric release-name text.
-func rhdTokenRegex(tokens ...string) *regexp.Regexp {
-	return regexp.MustCompile(`(?i)(^|[^[:alnum:]])(?:` + strings.Join(tokens, "|") + `)([^[:alnum:]]|$)`)
-}
-
-func siteRHDProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveResolutionID: resolveUnit3DRHDResolutionID,
-	}
-}
-
-func resolveUnit3DRHDResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1080p": "3",
-		"1080i": "4",
-		"720p":  "5",
-		"576p":  "12",
-		"576i":  "13",
-		"480p":  "11",
-		"480i":  "18",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "10"
-}
-
-// buildRHDName formats RocketHD names. Full-disc names intentionally omit the
-// language tag segment even though RHD upload rules still require German audio.
-func buildRHDName(meta api.PreparedMetadata) string {
-	parts := make([]string, 0)
-	isFullDisc := strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") || isDiscType(meta.DiscType)
-	markerText := rhdMarkerText(meta)
-
-	// 1. Title (German title preferred)
-	title := ""
-	tmdb := meta.ExternalMetadata.TMDB
-	if tmdb != nil && tmdb.LocalizedTitles != nil {
-		if t, ok := tmdb.LocalizedTitles["de"]; ok && strings.TrimSpace(t) != "" {
-			title = strings.TrimSpace(t)
-		}
-	}
-	if title == "" {
-		title = strings.TrimSpace(meta.Release.Title)
-	}
-	if title == "" && tmdb != nil {
-		title = strings.TrimSpace(tmdb.Title)
-	}
-	if title == "" && tmdb != nil {
-		title = strings.TrimSpace(tmdb.OriginalTitle)
-	}
-	if title != "" {
-		parts = append(parts, title)
-	}
-
-	// 2. Year (always)
-	year := meta.Release.Year
-	if year == 0 && meta.ExternalMetadata.TMDB != nil {
-		year = meta.ExternalMetadata.TMDB.Year
-	}
-	yearStr := strconv.Itoa(year)
-	if year == 0 {
-		yearStr = "0000"
-	}
-	parts = append(parts, yearStr)
-
-	// 2.5 Season / Episode
-	if meta.SeasonStr != "" || meta.EpisodeStr != "" {
-		parts = append(parts, strings.TrimSpace(meta.SeasonStr+meta.EpisodeStr))
-
-		if rhdIncompleteRegex.MatchString(markerText) {
-			parts = append(parts, "iNCOMPLETE")
-		}
-	}
-
-	// 3. CUT / Edition / 3D
-	if meta.Edition != "" {
-		parts = append(parts, meta.Edition)
-	}
-	if meta.Is3D != "" {
-		parts = append(parts, meta.Is3D)
-	}
-
-	// 4. Language. RHD full-disc naming uses COMPLETE/region/source details
-	// instead of GERMAN/DL/ML language tags.
-	if !isFullDisc {
-		parts = append(parts, resolveRHDLanguage(meta))
-	}
-
-	// 5. REPACK
-	if meta.Repack != "" {
-		parts = append(parts, meta.Repack)
-	}
-
-	// 6. Resolution
-	if meta.Release.Resolution != "" {
-		parts = append(parts, meta.Release.Resolution)
-
-		// Rocket-HD naming requires REGRADED and UPSCALE tags after resolution
-		if rhdRegradedRegex.MatchString(markerText) {
-			parts = append(parts, "REGRADED")
-		}
-		if rhdUpscaleRegex.MatchString(markerText) {
-			parts = append(parts, "UPSCALE")
-		}
-	}
-
-	// 7. Service/UHD
-	if strings.Contains(strings.ToUpper(meta.Type), "WEB") && meta.Service != "" {
-		parts = append(parts, meta.Service)
-	} else if meta.UHD != "" {
-		parts = append(parts, meta.UHD)
-	}
-
-	// 8. Type/Source
-	parts = append(parts, resolveRHDTypeAndSource(meta)...)
-
-	// 9. AudioCodec & Channels
-	if meta.Audio != "" {
-		parts = append(parts, meta.Audio)
-	}
-	if meta.Channels != "" && !strings.Contains(meta.Audio, meta.Channels) {
-		parts = append(parts, meta.Channels)
-	}
-
-	// 10. HDR
-	if meta.HDR != "" {
-		parts = append(parts, meta.HDR)
-	}
-
-	// 11. BitDepth
-	if meta.BitDepth != "" && meta.BitDepth != "8" && meta.BitDepth != "0" {
-		if strings.Contains(strings.ToLower(meta.BitDepth), "bit") {
-			parts = append(parts, meta.BitDepth)
-		} else {
-			parts = append(parts, meta.BitDepth+"bit")
-		}
-	}
-
-	// 12. VideoCodec
-	videoCodec := meta.VideoEncode
-	if videoCodec == "" {
-		videoCodec = meta.VideoCodec
-	}
-	if videoCodec != "" {
-		parts = append(parts, videoCodec)
-	}
-
-	// 13. INTERNAL
-	if rhdInternalRegex.MatchString(markerText) {
-		parts = append(parts, "iNTERNAL")
-	}
-
-	// Group
-	group := meta.Tag
-	if group == "" || isNoGroupTag(group) {
-		group = "NOGRP"
-	} else {
-		group = strings.TrimPrefix(group, "-")
-	}
-
-	name := strings.Join(parts, " ")
-	name = strings.Join(strings.Fields(name), " ")
-	return name + "-" + group
-}
-
-// resolveRHDTypeAndSource formats RHD source/type segments, promoting an empty
-// type with a disc-like DiscType to the full-disc COMPLETE form.
-func resolveRHDTypeAndSource(meta api.PreparedMetadata) []string {
-	var parts []string
-	typeName := strings.TrimSpace(meta.Type)
-	if typeName == "" && isDiscType(meta.DiscType) {
-		typeName = "DISC"
-	}
-	if typeName == "" {
-		return nil
-	}
-
-	switch strings.ToUpper(typeName) {
-	case "WEBDL":
-		typeName = "WEB-DL"
-	case "WEBRIP":
-		typeName = "WEBRip"
-	case "ENCODE":
-		if meta.Source != "" {
-			parts = append(parts, meta.Source)
-			typeName = ""
-		}
-	case "REMUX":
-		if meta.Source != "" {
-			parts = append(parts, meta.Source)
-		}
-	case "DISC":
-		parts = append(parts, "COMPLETE")
-		if meta.Region != "" {
-			parts = append(parts, meta.Region)
-		}
-		if meta.Release.Source != "" {
-			parts = append(parts, meta.Release.Source)
-		}
-		if meta.Release.Size != "" {
-			parts = append(parts, meta.Release.Size)
-		}
-		typeName = ""
-	}
-
-	if typeName != "" {
-		parts = append(parts, typeName)
-	}
-	return parts
-}
-
-// rhdMarkerText strips the terminal release group tag before scanning for RHD
-// marker tokens, so short group tags do not look like language or source flags.
-func rhdMarkerText(meta api.PreparedMetadata) string {
-	value := strings.TrimSpace(meta.ReleaseName)
-	tag := strings.TrimSpace(meta.Tag)
-	if value == "" || tag == "" {
-		return value
-	}
-	tag = strings.TrimPrefix(tag, "-")
-	if tag == "" {
-		return value
-	}
-	for _, suffix := range []string{"-" + tag, "." + tag, "_" + tag, " " + tag} {
-		if strings.HasSuffix(strings.ToLower(value), strings.ToLower(suffix)) {
-			return strings.TrimSpace(value[:len(value)-len(suffix)])
-		}
-	}
-	return value
-}
-
-// resolveRHDLanguage builds the RHD language segment from unique parseable audio
-// languages, with German subtitle-only and dubbed markers handled separately.
-func resolveRHDLanguage(meta api.PreparedMetadata) string {
-	audioLanguages := normalizedRHDAudioLanguages(meta.AudioLanguages)
-	hasGermanAudio := slices.ContainsFunc(audioLanguages, isGermanLanguage)
-
-	numAudio := len(audioLanguages)
-	var baseTag string
-
-	if hasGermanAudio {
-		baseTag = "GERMAN"
-	} else {
-		// No German audio, check subs
-		hasGermanSubs := slices.ContainsFunc(meta.SubtitleLanguages, isGermanLanguage)
-		if hasGermanSubs {
-			return "GERMAN SUBBED"
-		}
-
-		// Use main language name
-		if numAudio > 0 {
-			baseTag = getRHDLanguageName(audioLanguages[0])
-		} else {
-			baseTag = "ENGLISH"
-		}
-	}
-
-	isDubbed := rhdDubbedRegex.MatchString(rhdMarkerText(meta))
-	if isDubbed {
-		baseTag += " DUBBED"
-	}
-
-	if numAudio == 2 {
-		return baseTag + " DL"
-	} else if numAudio > 2 {
-		return baseTag + " ML"
-	}
-	return baseTag
-}
-
-// normalizedRHDAudioLanguages returns first-seen base language subtags, dropping
-// blank, unparsable, undefined, and duplicate audio entries before DL/ML counting.
-func normalizedRHDAudioLanguages(values []string) []string {
-	languages := make([]string, 0, len(values))
-	seen := make(map[string]struct{}, len(values))
-	for _, value := range values {
-		tag, ok := parseLanguageTag(value)
-		if !ok {
-			continue
-		}
-		base, _ := tag.Base()
-		key := base.String()
-		if key == "" || key == "und" {
-			continue
-		}
-		if isGermanLanguage(key) {
-			key = "de"
-		}
-		if _, exists := seen[key]; exists {
-			continue
-		}
-		seen[key] = struct{}{}
-		languages = append(languages, key)
-	}
-	return languages
-}
-
-// isGermanLanguage accepts common German names, ISO codes, and Swiss German
-// tags for RHD audio and subtitle language decisions.
-func isGermanLanguage(l string) bool {
-	tag, ok := parseLanguageTag(l)
-	if !ok {
-		l = strings.ToLower(strings.TrimSpace(l))
-		return slices.Contains([]string{"german", "ger", "de", "deu", "gsw"}, l)
-	}
-	base, _ := tag.Base()
-	switch base.String() {
-	case "de", "gsw":
-		return true
-	default:
-		return false
-	}
-}
-
-// getRHDLanguageName returns the English display name RHD expects for a
-// parseable language tag, falling back to the uppercased input.
-func getRHDLanguageName(l string) string {
-	tag, ok := parseLanguageTag(l)
-	if !ok {
-		return strings.ToUpper(strings.TrimSpace(l))
-	}
-	name := display.Languages(language.English).Name(tag)
-	if name == "" {
-		return strings.ToUpper(strings.TrimSpace(l))
-	}
-	return strings.ToUpper(name)
-}
diff --git a/internal/trackers/impl/unit3d/shri.go b/internal/trackers/impl/unit3d/shri.go
deleted file mode 100644
index f3fc9343..00000000
--- a/internal/trackers/impl/unit3d/shri.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/internal/trackers"
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteSHRIProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID: resolveUnit3DSHRITypeID,
-		applyAdditionalPayload: func(req trackers.UploadRequest, data map[string]string) {
-			if regionID := numericValue(req.Meta.Region); regionID != "" {
-				data["region_id"] = regionID
-			}
-			if distributorID := numericValue(req.Meta.Distributor); distributorID != "" {
-				data["distributor_id"] = distributorID
-			}
-		},
-	}
-}
-
-func resolveUnit3DSHRITypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "26",
-		"REMUX":  "7",
-		"WEBDL":  "27",
-		"WEBRIP": "15",
-		"HDTV":   "33",
-		"ENCODE": "15",
-		"DVDRIP": "15",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
-
-func applySHRIDescriptionNotes(description string, meta api.PreparedMetadata) string {
-	if !strings.EqualFold(resolveSHRIReleaseGroup(meta), "island") {
-		return description
-	}
-	const shareislandNotes = "Release Shareisland 🏴‍☠️\nFalla girare, condividila e contribuisci a mantenerla viva restando in seed il più possi" + "bile.\nGrazie per il supporto!"
-	trimmed := strings.TrimSpace(description)
-	if strings.Contains(trimmed, shareislandNotes) {
-		return trimmed
-	}
-	if trimmed == "" {
-		return shareislandNotes
-	}
-	return trimmed + "\n\n" + shareislandNotes
-}
-
-func resolveSHRIReleaseGroup(meta api.PreparedMetadata) string {
-	for _, value := range []string{meta.Release.Group, meta.ArrReleaseGroup, strings.TrimPrefix(meta.Tag, "-")} {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func numericValue(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return ""
-	}
-	for _, r := range trimmed {
-		if r < '0' || r > '9' {
-			return ""
-		}
-	}
-	return trimmed
-}
diff --git a/internal/trackers/impl/unit3d/site_contract.go b/internal/trackers/impl/unit3d/site_contract.go
new file mode 100644
index 00000000..bbaa4666
--- /dev/null
+++ b/internal/trackers/impl/unit3d/site_contract.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package unit3d
+
+import (
+	"golang.org/x/text/language"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// InferType returns the common normalized Unit3D release type.
+func InferType(meta api.UploadSubject) string { return inferUnit3DType(meta) }
+
+// Resolution returns the common normalized release resolution.
+func Resolution(meta api.UploadSubject) string { return resolveResolution(meta) }
+
+// RuleResolution returns the common normalized release resolution from the
+// narrower rule-evaluation read model.
+func RuleResolution(meta api.RuleSubject) string {
+	return resolveResolutionValues(meta.Release, meta.ReleaseName)
+}
+
+// Category returns the common normalized Unit3D category.
+func Category(meta api.UploadSubject) string { return resolveUnit3DCategory(meta) }
+
+// DefaultCategoryID returns the common Unit3D category mapping.
+func DefaultCategoryID(meta api.UploadSubject) string { return resolveUnit3DCategoryID(meta) }
+
+// IsDiscType reports whether value is a supported disc marker.
+func IsDiscType(value string) bool { return isDiscType(value) }
+
+// IsSDResolution reports whether value is a standard-definition resolution.
+func IsSDResolution(value string) bool { return isSDResolution(value) }
+
+// Keywords returns common TMDB keyword metadata.
+func Keywords(meta api.UploadSubject) string { return resolveKeywords(meta) }
+
+// TMDBGenres returns common TMDB genre metadata.
+func TMDBGenres(meta api.UploadSubject) string { return resolveTMDBGenres(meta) }
+
+// IMDBGenres returns common IMDb genre metadata.
+func IMDBGenres(meta api.UploadSubject) string { return resolveIMDBGenres(meta) }
+
+// HasEnglishLanguage reports whether languages contains an English marker.
+func HasEnglishLanguage(languages []string) bool { return hasEnglishLanguage(languages) }
+
+// HasAdultToken reports whether value contains a common adult-content marker.
+func HasAdultToken(value string) bool { return hasAdultToken(value) }
+
+// ParseLanguageTag resolves common language names and codes.
+func ParseLanguageTag(value string) (language.Tag, bool) { return parseLanguageTag(value) }
+
+// IsNoGroupTag reports whether tag is a no-group placeholder.
+func IsNoGroupTag(tag string) bool { return isNoGroupTag(tag) }
diff --git a/internal/trackers/impl/unit3d/site_helpers.go b/internal/trackers/impl/unit3d/site_helpers.go
index de35ed97..331db1ff 100644
--- a/internal/trackers/impl/unit3d/site_helpers.go
+++ b/internal/trackers/impl/unit3d/site_helpers.go
@@ -9,16 +9,16 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func resolveTMDBGenres(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Genres)
+func resolveTMDBGenres(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Genres)
 	}
 	return ""
 }
 
-func resolveIMDBGenres(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.IMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.IMDB.Genres)
+func resolveIMDBGenres(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.Genres)
 	}
 	return ""
 }
diff --git a/internal/trackers/impl/unit3d/sites/a4k/banned_groups.go b/internal/trackers/impl/unit3d/sites/a4k/banned_groups.go
new file mode 100644
index 00000000..21383c4a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/a4k/banned_groups.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package a4k
+
+// BannedGroups returns A4K's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"BiTOR",
+		"DepraveD",
+		"Flights",
+		"SasukeducK",
+		"SPDVD",
+		"TEKNO3D",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/a4k/profile.go b/internal/trackers/impl/unit3d/sites/a4k/profile.go
new file mode 100644
index 00000000..8fb9597c
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/a4k/profile.go
@@ -0,0 +1,41 @@
+package a4k
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns A4K's restricted type and resolution mappings together with
+// its tracker-owned rules, banned groups, and image-host policy.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "A4K",
+		BaseURL:      "https://aura4k.net",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+		},
+		ImageHost: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"onlyimage", "imgbox", "ptscreens", "imgbb", "imgur", "postimg"},
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"WEBDL":  "4",
+		"ENCODE": "3",
+	}[unit3d.InferType(meta)]
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{"4320p": "1", "2160p": "2"}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/a4k/rules.go b/internal/trackers/impl/unit3d/sites/a4k/rules.go
new file mode 100644
index 00000000..443a399e
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/a4k/rules.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package a4k
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns A4K's strict non-disc English audio-or-subtitle requirement,
+// which accepts original-language audio when English subtitles are present.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{Language: &trackers.LanguageRule{
+		Languages:      []string{"english", "en", "eng"},
+		RequireAudio:   true,
+		RequireSubs:    true,
+		AllowOriginal:  true,
+		ApplyIfNonDisc: true,
+	}}
+}
diff --git a/internal/trackers/impl/unit3d/sites/acm/profile.go b/internal/trackers/impl/unit3d/sites/acm/profile.go
new file mode 100644
index 00000000..126e3b08
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/acm/profile.go
@@ -0,0 +1,580 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package acm
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	acmSceneNFOPattern = regexp.MustCompile(`(?is)\[center\]\[spoiler=Scene NFO:\].*?\[/center\]`)
+	acmSubtitleCodes   = map[string]string{
+		"arabic":                "Ara",
+		"ara":                   "Ara",
+		"ar":                    "Ara",
+		"brazilian portuguese":  "Por-BR",
+		"brazilian":             "Por-BR",
+		"portuguese-br":         "Por-BR",
+		"pt-br":                 "Por-BR",
+		"bulgarian":             "Bul",
+		"bul":                   "Bul",
+		"bg":                    "Bul",
+		"chinese":               "Chi",
+		"chi":                   "Chi",
+		"zh":                    "Chi",
+		"chinese (simplified)":  "Chi",
+		"chinese (traditional)": "Chi",
+		"croatian":              "Cro",
+		"hrv":                   "Cro",
+		"hr":                    "Cro",
+		"scr":                   "Cro",
+		"czech":                 "Cze",
+		"cze":                   "Cze",
+		"cz":                    "Cze",
+		"cs":                    "Cze",
+		"danish":                "Dan",
+		"dan":                   "Dan",
+		"da":                    "Dan",
+		"dutch":                 "Dut",
+		"dut":                   "Dut",
+		"nl":                    "Dut",
+		"english":               "Eng",
+		"eng":                   "Eng",
+		"en":                    "Eng",
+		"english (cc)":          "Eng",
+		"english - sdh":         "Eng",
+		"english - forced":      "Eng",
+		"english (forced)":      "Eng",
+		"en (forced)":           "Eng",
+		"english intertitles":   "Eng",
+		"english (intertitles)": "Eng",
+		"english - intertitles": "Eng",
+		"en (intertitles)":      "Eng",
+		"estonian":              "Est",
+		"est":                   "Est",
+		"et":                    "Est",
+		"finnish":               "Fin",
+		"fin":                   "Fin",
+		"fi":                    "Fin",
+		"french":                "Fre",
+		"fre":                   "Fre",
+		"fr":                    "Fre",
+		"german":                "Ger",
+		"ger":                   "Ger",
+		"de":                    "Ger",
+		"greek":                 "Gre",
+		"gre":                   "Gre",
+		"el":                    "Gre",
+		"hebrew":                "Heb",
+		"heb":                   "Heb",
+		"he":                    "Heb",
+		"hindi":                 "Hin",
+		"hin":                   "Hin",
+		"hi":                    "Hin",
+		"hungarian":             "Hun",
+		"hun":                   "Hun",
+		"hu":                    "Hun",
+		"icelandic":             "Ice",
+		"ice":                   "Ice",
+		"is":                    "Ice",
+		"indonesian":            "Ind",
+		"ind":                   "Ind",
+		"id":                    "Ind",
+		"italian":               "Ita",
+		"ita":                   "Ita",
+		"it":                    "Ita",
+		"japanese":              "Jpn",
+		"jpn":                   "Jpn",
+		"ja":                    "Jpn",
+		"korean":                "Kor",
+		"kor":                   "Kor",
+		"ko":                    "Kor",
+		"latvian":               "Lav",
+		"lav":                   "Lav",
+		"lv":                    "Lav",
+		"lithuanian":            "Lit",
+		"lit":                   "Lit",
+		"lt":                    "Lit",
+		"norwegian":             "Nor",
+		"nor":                   "Nor",
+		"no":                    "Nor",
+		"persian":               "Per",
+		"fa":                    "Per",
+		"far":                   "Per",
+		"polish":                "Pol",
+		"pol":                   "Pol",
+		"pl":                    "Pol",
+		"portuguese":            "Por",
+		"por":                   "Por",
+		"pt":                    "Por",
+		"romanian":              "Rom",
+		"rum":                   "Rom",
+		"ro":                    "Rom",
+		"russian":               "Rus",
+		"rus":                   "Rus",
+		"ru":                    "Rus",
+		"serbian":               "Ser",
+		"srp":                   "Ser",
+		"sr":                    "Ser",
+		"scc":                   "Ser",
+		"slovak":                "Slo",
+		"slo":                   "Slo",
+		"sk":                    "Slo",
+		"slovenian":             "Slv",
+		"slv":                   "Slv",
+		"sl":                    "Slv",
+		"spanish":               "Spa",
+		"spa":                   "Spa",
+		"es":                    "Spa",
+		"swedish":               "Swe",
+		"swe":                   "Swe",
+		"sv":                    "Swe",
+		"thai":                  "Tha",
+		"tha":                   "Tha",
+		"th":                    "Tha",
+		"turkish":               "Tur",
+		"tur":                   "Tur",
+		"tr":                    "Tur",
+		"ukrainian":             "Ukr",
+		"ukr":                   "Ukr",
+		"uk":                    "Ukr",
+		"vietnamese":            "Vie",
+		"vie":                   "Vie",
+		"vi":                    "Vie",
+	}
+)
+
+// Profile returns ACM's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:             "ACM",
+		BaseURL:          "https://eiga.moi",
+		DescriptionGroup: "acm",
+		UploadArtifact: &trackers.UploadArtifactPolicy{
+			Source: "AsianCinema",
+		},
+		Site: unit3d.SiteProfile{
+			BuildName:              buildName,
+			BuildDescription:       buildACMDescription,
+			ResolveKeywords:        resolveACMKeywords,
+			ResolveTypeID:          resolveUnit3DACMTypeID,
+			ResolveResolutionID:    resolveUnit3DACMResolutionID,
+			ApplyAdditionalPayload: additionalPayload,
+		},
+	}
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string { return buildACMName(meta) }
+
+func additionalPayload(req trackers.PreparationInput, data map[string]string) {
+	if regionID := numericValue(req.Meta.Region); regionID != "" {
+		data["region_id"] = regionID
+	}
+	if distributorID := numericValue(req.Meta.Distributor); distributorID != "" {
+		data["distributor_id"] = distributorID
+	}
+}
+
+func resolveUnit3DACMTypeID(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		sizeBucket := acmDiscBucket(meta.SourceSize)
+		if strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") && sizeBucket != 25 {
+			switch sizeBucket {
+			case 50:
+				return "3"
+			case 66:
+				return "2"
+			case 100:
+				return "1"
+			}
+		}
+		switch sizeBucket {
+		case 25:
+			return "5"
+		case 50:
+			return "4"
+		}
+		return "0"
+	}
+
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		switch acmDVDType(meta) {
+		case "DVD 5":
+			return "14"
+		case "DVD 9":
+			return "16"
+		default:
+			return "0"
+		}
+	}
+
+	switch acmNonDiscType(meta) {
+	case "UHD REMUX":
+		return "12"
+	case "REMUX":
+		return "7"
+	case "WEBDL":
+		return "9"
+	case "SDTV":
+		return "13"
+	case "HDTV":
+		return "17"
+	default:
+		return "0"
+	}
+}
+
+func resolveUnit3DACMResolutionID(meta api.UploadSubject) string {
+	switch strings.ToLower(strings.TrimSpace(unit3d.Resolution(meta))) {
+	case "2160p":
+		return "1"
+	case "1080p", "1080i":
+		return "2"
+	case "720p":
+		return "3"
+	case "576p", "576i":
+		return "4"
+	case "480p", "480i":
+		return "5"
+	default:
+		return "10"
+	}
+}
+
+func buildACMName(meta api.UploadSubject) string {
+	name := baseName(meta)
+	if name == "" {
+		return ""
+	}
+
+	title := strings.TrimSpace(resolveACMTitle(meta))
+	originalTitle := strings.TrimSpace(resolveACMOriginalTitle(meta))
+	if title != "" && originalTitle != "" && !strings.EqualFold(title, originalTitle) {
+		name = strings.Replace(name, title, title+" / "+originalTitle+" \u202A", 1)
+	}
+
+	audio := strings.TrimSpace(meta.Audio)
+	if strings.Contains(audio, "AAC") {
+		normalizedAudio := strings.Join(strings.Fields(audio), " ")
+		name = strings.Replace(name, normalizedAudio, strings.ReplaceAll(normalizedAudio, "AAC ", "AAC"), 1)
+	}
+	name = strings.ReplaceAll(name, "DD+ ", "DD+")
+	name = strings.ReplaceAll(name, "UHD BluRay REMUX", "Remux")
+	name = strings.ReplaceAll(name, "BluRay REMUX", "Remux")
+	name = strings.ReplaceAll(name, "H.265", "HEVC")
+	name = strings.ReplaceAll(name, " Atmos", "")
+
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		source := strings.TrimSpace(meta.Source)
+		resolution := strings.TrimSpace(unit3d.Resolution(meta))
+		if source != "" && resolution != "" {
+			name = strings.ReplaceAll(name, source+" DVD5", resolution+" DVD "+source)
+			name = strings.ReplaceAll(name, source+" DVD9", resolution+" DVD "+source)
+		}
+		if audio != "" && audio == strings.TrimSpace(meta.Channels) {
+			name = strings.ReplaceAll(name, audio, "MPEG "+audio)
+		}
+	}
+
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " ")) + acmSubtitleTag(acmSubtitleCodesFor(meta))
+}
+
+func buildACMDescription(
+	ctx context.Context,
+	meta api.UploadSubject,
+	appConfig config.Config,
+	trackerConfig config.TrackerConfig,
+	logger api.Logger,
+	keptDescription string,
+	menuImages []api.ScreenshotImage,
+	screenshots []api.ScreenshotImage,
+) (string, error) {
+	base := acmSceneNFOPattern.ReplaceAllString(strings.TrimSpace(keptDescription), "")
+	base = strings.ReplaceAll(base, "\r\n", "\n")
+	base = strings.ReplaceAll(base, "[pre]", "[code]")
+	base = strings.ReplaceAll(base, "[/pre]", "[/code]")
+	base = strings.ReplaceAll(base, "[hide", "[spoiler")
+	base = strings.ReplaceAll(base, "[/hide]", "[/spoiler]")
+	base = convertACMComparisonToCollapse(base, 1000)
+	base = strings.ReplaceAll(base, "[img]", "[img=300]")
+	base = descriptionunit3d.AppendDVDVOBMediaInfoBlock(base, api.NewDescriptionSubject(meta))
+
+	cfg := appConfig
+	if cfg.Description.ThumbnailSize <= 0 {
+		cfg.Description.ThumbnailSize = 350
+	}
+	if len(screenshots) > 0 {
+		cfg.Description.ScreensPerRow = strconv.Itoa(len(screenshots))
+	} else if strings.TrimSpace(cfg.Description.ScreensPerRow) == "" {
+		cfg.Description.ScreensPerRow = "1"
+	}
+
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") && strings.TrimSpace(meta.ServiceLongName) != "" {
+		header := fmt.Sprintf(
+			"[center][b][color=#ff00ff][size=18]This release is sourced from %s and is not transcoded, just remuxed from the direct %s stream[/size][/color][/b][/center]",
+			strings.TrimSpace(meta.ServiceLongName),
+			strings.TrimSpace(meta.ServiceLongName),
+		)
+		base = strings.TrimSpace(strings.Join([]string{header, base}, "\n"))
+	}
+
+	value, err := descriptionunit3d.BuildDescription(
+		ctx,
+		api.NewDescriptionSubject(meta),
+		cfg,
+		trackerConfig,
+		logger,
+		base,
+		menuImages,
+		screenshots,
+	)
+	if err != nil {
+		return "", fmt.Errorf("trackers: %w", err)
+	}
+	return value, nil
+}
+
+func resolveACMKeywords(meta api.UploadSubject) string {
+	raw := unit3d.Keywords(meta)
+	if raw == "" {
+		return ""
+	}
+	parts := strings.Split(raw, ",")
+	filtered := make([]string, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed == "" || strings.Contains(trimmed, " ") {
+			continue
+		}
+		filtered = append(filtered, trimmed)
+		if len(filtered) >= 10 {
+			break
+		}
+	}
+	return strings.Join(filtered, ", ")
+}
+
+func acmDiscBucket(sourceSize int64) int {
+	if sourceSize <= 0 {
+		return 100
+	}
+	sizeGiB := float64(sourceSize) / float64(1<<30)
+	for _, bucket := range []int{25, 50, 66, 100} {
+		if sizeGiB < float64(bucket) {
+			return bucket
+		}
+	}
+	return 100
+}
+
+func acmDVDType(meta api.UploadSubject) string {
+	name := strings.ToUpper(strings.TrimSpace(baseName(meta)))
+	switch {
+	case strings.Contains(name, "DVD5"):
+		return "DVD 5"
+	case strings.Contains(name, "DVD9"):
+		return "DVD 9"
+	case meta.SourceSize > 0 && meta.SourceSize <= 5*(1<<30):
+		return "DVD 5"
+	case meta.SourceSize > 0:
+		return "DVD 9"
+	default:
+		return ""
+	}
+}
+
+func acmNonDiscType(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(unit3d.InferType(meta)), "REMUX") && strings.EqualFold(strings.TrimSpace(meta.UHD), "UHD") {
+		return "UHD REMUX"
+	}
+	switch strings.ToUpper(strings.TrimSpace(unit3d.InferType(meta))) {
+	case "WEBDL", "WEB-DL":
+		return "WEBDL"
+	case "HDTV":
+		if strings.HasPrefix(strings.TrimSpace(unit3d.Resolution(meta)), "4") || strings.HasPrefix(strings.TrimSpace(unit3d.Resolution(meta)), "5") {
+			return "SDTV"
+		}
+		return "HDTV"
+	case "REMUX":
+		return "REMUX"
+	default:
+		return ""
+	}
+}
+
+func resolveACMTitle(meta api.UploadSubject) string {
+	for _, value := range []string{
+		meta.Release.Title,
+		resolveACMTMDBTitle(meta),
+		resolveACMIMDBTitle(meta),
+	} {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
+
+func resolveACMOriginalTitle(meta api.UploadSubject) string {
+	for _, value := range []string{
+		resolveACMTMDBOriginalTitle(meta),
+		resolveACMTMDBRetrievedAKA(meta),
+		resolveACMIMDBAKA(meta),
+		meta.Release.Alt,
+	} {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return strings.TrimPrefix(trimmed, "AKA ")
+		}
+	}
+	return ""
+}
+
+func acmSubtitleCodesFor(meta api.UploadSubject) []string {
+	out := make([]string, 0, len(meta.SubtitleLanguages))
+	seen := make(map[string]struct{}, len(meta.SubtitleLanguages))
+	for _, language := range meta.SubtitleLanguages {
+		key := strings.ToLower(strings.TrimSpace(language))
+		if key == "" {
+			continue
+		}
+		code, ok := acmSubtitleCodes[key]
+		if !ok {
+			continue
+		}
+		if _, exists := seen[code]; exists {
+			continue
+		}
+		seen[code] = struct{}{}
+		out = append(out, code)
+	}
+	return out
+}
+
+func acmSubtitleTag(subtitles []string) string {
+	if len(subtitles) == 0 {
+		return " [No subs]"
+	}
+	if slices.Contains(subtitles, "Eng") {
+		return ""
+	}
+	if len(subtitles) > 1 {
+		return " [No Eng subs]"
+	}
+	return " [" + subtitles[0] + " subs only]"
+}
+
+// convertACMComparisonToCollapse rewrites UNIT3D comparison blocks into ACM
+// spoiler markup while leaving malformed blocks unchanged when no image URLs
+// can be paired with the source labels.
+func convertACMComparisonToCollapse(value string, maxWidth int) string {
+	re := regexp.MustCompile(`(?is)\[comparison=[\s\S]*?\[/comparison\]`)
+	return re.ReplaceAllStringFunc(value, func(block string) string {
+		parts := strings.SplitN(block, "]", 2)
+		if len(parts) < 2 {
+			return block
+		}
+		sources := strings.Split(strings.ReplaceAll(strings.TrimPrefix(parts[0], "[comparison="), " ", ""), ",")
+		if len(sources) == 0 {
+			return block
+		}
+		imgSize := min(maxWidth/len(sources), 350)
+		body := strings.TrimSuffix(parts[1], "[/comparison]")
+		fields := strings.Fields(strings.ReplaceAll(body, ",", " "))
+		images := make([]string, 0, len(fields))
+		for _, field := range fields {
+			trimmed := strings.TrimSpace(field)
+			if strings.HasPrefix(strings.ToLower(trimmed), "http://") || strings.HasPrefix(strings.ToLower(trimmed), "https://") {
+				images = append(images, trimmed)
+			}
+		}
+		if len(images) == 0 {
+			return block
+		}
+		lines := make([]string, 0, len(images)/len(sources)+1)
+		row := make([]string, 0, len(sources))
+		for _, image := range images {
+			row = append(row, fmt.Sprintf("[url=%s][img=%d]%s[/img][/url]", image, imgSize, image))
+			if len(row) == len(sources) {
+				lines = append(lines, strings.Join(row, ""))
+				row = row[:0]
+			}
+		}
+		if len(row) > 0 {
+			lines = append(lines, strings.Join(row, ""))
+		}
+		return fmt.Sprintf(
+			"[spoiler=%s][center]%s[/center]\n%s[/spoiler]",
+			strings.Join(sources, " vs "),
+			strings.Join(sources, " | "),
+			strings.Join(lines, "\n"),
+		)
+	})
+}
+
+func resolveACMTMDBTitle(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return ""
+	}
+	return meta.ProviderMetadata.TMDB.Title
+}
+
+func resolveACMTMDBOriginalTitle(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return ""
+	}
+	return meta.ProviderMetadata.TMDB.OriginalTitle
+}
+
+func resolveACMTMDBRetrievedAKA(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB == nil {
+		return ""
+	}
+	return meta.ProviderMetadata.TMDB.RetrievedAKA
+}
+
+func resolveACMIMDBTitle(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB == nil {
+		return ""
+	}
+	return meta.ProviderMetadata.IMDB.Title
+}
+
+func resolveACMIMDBAKA(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.IMDB == nil {
+		return ""
+	}
+	return meta.ProviderMetadata.IMDB.AKA
+}
+
+func baseName(meta api.UploadSubject) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
+
+func numericValue(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	for _, r := range trimmed {
+		if r < '0' || r > '9' {
+			return ""
+		}
+	}
+	return trimmed
+}
diff --git a/internal/trackers/impl/unit3d/sites/acm/profile_test.go b/internal/trackers/impl/unit3d/sites/acm/profile_test.go
new file mode 100644
index 00000000..b67498c9
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/acm/profile_test.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package acm
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestProfileParity(t *testing.T) {
+	profile := Profile().Site
+	if got := profile.ResolveTypeID(api.UploadSubject{
+		DiscType:   "BDMV",
+		UHD:        "UHD",
+		SourceSize: 60 * (1 << 30),
+	}); got != "2" {
+		t.Fatalf("type = %q", got)
+	}
+	if got := profile.ResolveResolutionID(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "1080i"}}); got != "2" {
+		t.Fatalf("resolution = %q", got)
+	}
+	meta := api.UploadSubject{
+		ReleaseName:       "Example.2024.1080p.BluRay.REMUX.H.265.DD+ 5.1 Atmos-GRP",
+		Audio:             "DD+ 5.1",
+		ProviderMetadata:  api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Title: "Example", OriginalTitle: "Original Example"}},
+		SubtitleLanguages: []string{"Japanese"},
+	}
+	name := profile.BuildName(meta, config.TrackerConfig{})
+	if !strings.Contains(name, "Example / Original Example") || strings.Contains(name, "H.265") || !strings.Contains(name, "[Jpn subs only]") {
+		t.Fatalf("name = %q", name)
+	}
+	keywordsMeta := api.UploadSubject{
+		Region:           "3",
+		Distributor:      "42",
+		ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Keywords: "one, two words, three,four,five,six,seven,eight,nine,ten,eleven,twelve"}},
+	}
+	if got := profile.ResolveKeywords(keywordsMeta); got != "one, three, four, five, six, seven, eight, nine, ten, eleven" {
+		t.Fatalf("keywords = %q", got)
+	}
+	data := map[string]string{}
+	profile.ApplyAdditionalPayload(trackers.PreparationInput{Meta: keywordsMeta}, data)
+	if data["region_id"] != "3" || data["distributor_id"] != "42" {
+		t.Fatalf("payload = %#v", data)
+	}
+}
+
+func TestDescriptionParity(t *testing.T) {
+	meta := api.UploadSubject{Type: "WEBDL", ServiceLongName: "Example Stream"}
+	result, err := Profile().Site.BuildDescription(context.Background(), meta, config.Config{}, config.TrackerConfig{}, api.NopLogger{}, "[pre]x[/pre]\n[hide=test]y[/hide]\n[img]https://img.example/z.png[/img]", nil, nil)
+	if err != nil {
+		t.Fatalf("description: %v", err)
+	}
+	for _, want := range []string{"[code]x[/code]", "[spoiler=test]y[/spoiler]", "not transcoded, just remuxed from the direct Example Stream stream", "[img=300]https://img.example/z.png[/img]"} {
+		if !strings.Contains(result, want) {
+			t.Fatalf("missing %q in %q", want, result)
+		}
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/aither/api_doc.go b/internal/trackers/impl/unit3d/sites/aither/api_doc.go
new file mode 100644
index 00000000..fec67ad8
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/aither/api_doc.go
@@ -0,0 +1,114 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package aither
+
+// Aither API contract
+//
+// Aither is UNIT3D-based but publishes a site-specific API reference and adds
+// behavior beyond the upstream UNIT3D baseline. This package owns Aither's
+// deviations; shared request construction remains in the parent unit3d package.
+// All requests use the configured AITHER base URL and Bearer API key.
+//
+// Upload
+//
+// POST /api/torrents/upload uses the shared multipart UNIT3D upload contract.
+// Aither additionally receives these HDR classification fields:
+//
+//   - dv: 1 when the release contains Dolby Vision; otherwise 0.
+//   - hdr10p: 1 when HDR10+ is present.
+//   - hdr: 1 for other HDR or HLG content. HDR10+ takes precedence, so hdr is
+//     not added by the Aither profile when hdr10p is set.
+//
+// The shared payload also carries deployment-supported fields such as stream,
+// sd, pack, internalrip, keywords, and mod_queue_opt_in when applicable. Their
+// inclusion is driven by prepared metadata and effective tracker configuration.
+//
+// Torrent lookup and duplicate search
+//
+// GET /api/torrents/:id fetches one torrent record. When no tracker ID is known,
+// GET /api/torrents/filter supplies the standard UNIT3D filter fallback.
+// Duplicate search uses tmdbId, categories[], resolutions[], optional types[],
+// perPage=100, and an optional season token. Returned candidates are evaluated
+// with Aither policy: trumpable IDs are tracked, DVD groups must match, SD may
+// match HD, and 1080p size variance is permitted.
+//
+// Release-group blacklist
+//
+// GET /api/blacklists/releasegroups returns Aither's dynamic banned release
+// groups. This endpoint is an Aither extension, not part of the standard UNIT3D
+// torrent API.
+//
+// Request contract:
+//
+//   - Method: GET.
+//   - Authentication: Authorization: Bearer <API key>.
+//   - Response format: application/json.
+//   - Query: per_page=100 on every request; cursor=<next_cursor> after the first
+//     page.
+//   - Timeout: 20 seconds per HTTP request.
+//
+// Accepted response shapes are intentionally tolerant because deployed UNIT3D
+// variants have returned several compatible representations. The decoder accepts
+// a top-level array, a single group record, or a paginated object containing data
+// and meta.next_cursor. Each data item may be a string or an object whose group
+// name is stored under name, group, release_group, releaseGroup, or the same keys
+// beneath a JSON:API attributes object. Blank or unrecognized records are ignored.
+// Pagination stops when next_cursor is blank, rejects repeated cursors, and is
+// capped at 1,000 pages.
+//
+// Successful bodies are bounded to 4 MiB and must contain exactly one JSON value.
+// Non-2xx responses are reported by status only; response bodies are not copied
+// into errors or logs. The normalized names and raw source records are persisted
+// under the application's banned-group cache with mode 0600. A cache remains
+// fresh for 24 hours. Refresh failure preserves the previous cache; cancellation
+// is checked before fetching and before durable replacement.
+//
+// Aither registers this endpoint through BannedGroupPolicy with RequireAPIKey.
+// Therefore a missing key skips remote refresh rather than making an anonymous
+// request. The generic banned-group evaluator merges cached names with static
+// tracker-owned groups and compares normalized release-group names.
+//
+// Internal-release claims
+//
+// GET /api/internals/claim returns active internal-release claims. This endpoint
+// is also Aither-specific and is enabled by Aither's API-backed ClaimPolicy.
+//
+// Request contract:
+//
+//   - Method: GET.
+//   - Authentication: Authorization: Bearer <API key>.
+//   - Response format: application/json.
+//   - Query: per_page=100 and optional cursor from the previous response.
+//   - Timeout: 20 seconds per HTTP request.
+//
+// The response is a JSON:API-style object. data contains records with an
+// attributes object; meta.next_cursor selects the next page. Relevant attributes
+// are title, season, tmdb_id, categories, resolutions, and types. season and
+// tmdb_id may be JSON numbers or numeric strings. Records without a non-zero,
+// parseable tmdb_id are discarded. Category, resolution, and type arrays are
+// copied before caching so decoded response storage is not retained by callers.
+//
+// Claims are cached for 24 hours in the application's cache/banned directory as
+// AITHER_claimed_releases.json with mode 0600. A fresh cache avoids network I/O.
+// Missing base URL or API key produces no claims and no anonymous request. Any
+// request construction, transport, non-2xx, or decode failure aborts claim
+// evaluation and is returned with tracker context; remote response bodies are not
+// included.
+//
+// Matching uses upload identity, not title alone. A claim requires the current
+// release's TMDB ID, canonical Unit3D category, type, and resolution to match the
+// claim. TV claims additionally require the canonical provider-resolved season;
+// parsed filename season fallbacks are deliberately ignored. A semantic match
+// adds the claim tracker block and claim_active rule failure before dupe checking
+// or upload. A non-match leaves the release eligible.
+//
+// Naming and validation
+//
+// Aither naming inserts foreign-language markers for applicable non-English
+// releases and applies DVD/DVD-rip normalization. Upload rules require a unique
+// external ID and English audio or subtitles for non-disc releases, while
+// allowing the original language.
+//
+// Site reference: https://aither.cc/pages/api#torrent-POSTapi-torrents-upload
+// Upstream reference: https://github.com/HDInnovations/UNIT3D/blob/master/book/src/torrent_api.md
diff --git a/internal/trackers/impl/unit3d/sites/aither/profile.go b/internal/trackers/impl/unit3d/sites/aither/profile.go
new file mode 100644
index 00000000..64fea99a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/aither/profile.go
@@ -0,0 +1,114 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package aither
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns AITHER's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:        "AITHER",
+		BaseURL:     "https://aither.cc",
+		Rules:       Rules(),
+		AudioPolicy: AudioPolicy(),
+		Site: unit3d.SiteProfile{
+			BuildName:              buildName,
+			ApplyAdditionalPayload: additionalPayload,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			TrackTrumpableID:      true,
+			MatchDVDReleaseGroup:  true,
+			SDMatchesHD:           true,
+			AllowSizeVariance1080: true,
+		},
+		BannedPolicy: &trackers.BannedGroupPolicy{
+			EndpointPath:  "/api/blacklists/releasegroups",
+			RequireAPIKey: true,
+		},
+		ClaimPolicy: &trackers.ClaimPolicy{
+			APIBacked: true,
+		},
+	}
+}
+
+func additionalPayload(req trackers.PreparationInput, data map[string]string) {
+	hdr := strings.ToUpper(strings.TrimSpace(req.Meta.HDR))
+	data["dv"] = boolString(strings.Contains(hdr, "DV"))
+	if strings.Contains(hdr, "HDR10+") {
+		data["hdr10p"] = "1"
+		return
+	}
+	if strings.Contains(hdr, "HDR") || strings.Contains(hdr, "HLG") {
+		data["hdr"] = "1"
+	}
+}
+
+func boolString(value bool) string {
+	if value {
+		return "1"
+	}
+	return "0"
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	if name == "" {
+		return ""
+	}
+	resolution, videoCodec, videoEncode := unit3d.Resolution(meta), strings.TrimSpace(meta.VideoCodec), strings.TrimSpace(meta.VideoEncode)
+	nameType, source, audio := strings.ToUpper(strings.TrimSpace(meta.Type)), strings.TrimSpace(meta.Source), strings.TrimSpace(meta.Audio)
+	languages := append([]string{}, meta.Release.Language...)
+	if len(languages) > 0 && !unit3d.HasEnglishLanguage(languages) {
+		foreign := strings.ToUpper(strings.TrimSpace(languages[0]))
+		if nameType == "REMUX" && isDVDSource(source) && meta.Release.Year > 0 {
+			year := strconv.Itoa(meta.Release.Year)
+			name = strings.Replace(name, year, year+" "+foreign, 1)
+		} else if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") && resolution != "" {
+			name = strings.Replace(name, resolution, foreign+" "+resolution, 1)
+		}
+	}
+	if nameType == "DVDRIP" {
+		source = "DVDRip"
+		if meta.Source != "" {
+			name = strings.Replace(name, meta.Source+" ", "", 1)
+		}
+		if videoEncode != "" {
+			name = strings.Replace(name, videoEncode, "", 1)
+		}
+		if resolution != "" {
+			name = strings.Replace(name, source, resolution+" "+source, 1)
+		}
+		if audio != "" && videoEncode != "" {
+			name = strings.Replace(name, audio, audio+videoEncode, 1)
+		}
+	} else if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || (nameType == "REMUX" && isDVDSource(source)) {
+		if resolution != "" && source != "" {
+			name = strings.Replace(name, source, resolution+" "+source, 1)
+		}
+		if audio != "" && videoCodec != "" {
+			name = strings.Replace(name, audio, videoCodec+" "+audio, 1)
+		}
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
+
+func isDVDSource(source string) bool {
+	switch strings.ToUpper(strings.TrimSpace(source)) {
+	case "PAL DVD", "NTSC DVD", "DVD":
+		return true
+	default:
+		return false
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/aither/rules.go b/internal/trackers/impl/unit3d/sites/aither/rules.go
new file mode 100644
index 00000000..c7988bbb
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/aither/rules.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package aither
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+)
+
+// Rules returns AITHER's strict unique-ID requirement and strict non-disc
+// English audio-or-subtitle requirement, accepting original-language audio
+// when English subtitles are present.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{RequireUniqueID: true, Language: englishNonDisc()}
+}
+
+// AudioPolicy allows English as an additional audio language.
+func AudioPolicy() *trackers.AudioPolicy {
+	return &trackers.AudioPolicy{AllowedLanguages: []string{"english"}}
+}
+func englishNonDisc() *trackers.LanguageRule {
+	return &trackers.LanguageRule{
+		Languages:      []string{"english", "en", "eng"},
+		RequireAudio:   true,
+		RequireSubs:    true,
+		AllowOriginal:  true,
+		ApplyIfNonDisc: true,
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/blu/banned_groups.go b/internal/trackers/impl/unit3d/sites/blu/banned_groups.go
new file mode 100644
index 00000000..358a1e48
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/blu/banned_groups.go
@@ -0,0 +1,97 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package blu
+
+// BannedGroups returns BLU's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"[Oj]",
+		"3LTON",
+		"4yEo",
+		"ADE",
+		"AFG",
+		"AniHLS",
+		"AnimeRG",
+		"AniURL",
+		"AROMA",
+		"aXXo",
+		"B3LLUM",
+		"BHDStudio",
+		"Brrip",
+		"CHD",
+		"CM8",
+		"CrEwSaDe",
+		"d3g",
+		"DeadFish",
+		"DNL",
+		"DTLegacy",
+		"ELiTE",
+		"eSc",
+		"EZTV",
+		"EZTV.RE",
+		"F13",
+		"FaNGDiNG0",
+		"FGT",
+		"Flights",
+		"flower",
+		"FRDS",
+		"FUM",
+		"HAiKU",
+		"hallowed",
+		"HD2DVD",
+		"HDS",
+		"HDTime",
+		"Hi10",
+		"ION10",
+		"iPlanet",
+		"JIVE",
+		"KiNGDOM",
+		"LAMA",
+		"Leffe",
+		"LEGi0N",
+		"LOAD",
+		"MeGusta",
+		"mHD",
+		"mSD",
+		"NhaNc3",
+		"nHD",
+		"nikt0",
+		"NOIVTC",
+		"nSD",
+		"OFT",
+		"PiRaTeS",
+		"playBD",
+		"PlaySD",
+		"playXD",
+		"PRODJi",
+		"RAPiDCOWS",
+		"RARBG",
+		"RetroPeeps",
+		"RDN",
+		"REsuRRecTioN",
+		"RMTeam",
+		"SANTi",
+		"SasukeducK",
+		"SicFoI",
+		"SPASM",
+		"SPDVD",
+		"STUTTERSHIT",
+		"Telly",
+		"TheFarm",
+		"TM",
+		"TRiToN",
+		"UPiNSMOKE",
+		"URANiME",
+		"VN_Foxcore",
+		"WAF",
+		"WKS",
+		"x0r",
+		"xRed",
+		"XS",
+		"YIFY",
+		"ZKBL",
+		"ZmN",
+		"ZMNT",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/blu/profile.go b/internal/trackers/impl/unit3d/sites/blu/profile.go
new file mode 100644
index 00000000..9082294b
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/blu/profile.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package blu
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns BLU's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "BLU",
+		BaseURL:      "https://blutopia.cc",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+			ResolveCategoryID:   categoryID,
+		},
+	}
+}
+
+func categoryID(meta api.UploadSubject) string {
+	if strings.Contains(strings.ToUpper(strings.TrimSpace(meta.Edition)), "FANRES") {
+		return "3"
+	}
+	return unit3d.DefaultCategoryID(meta)
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "3",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+		"ENCODE": "12",
+	}[unit3d.InferType(meta)]
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"8640p": "10",
+		"4320p": "11",
+		"2160p": "1",
+		"1440p": "2",
+		"1080p": "2",
+		"1080i": "3",
+		"720p":  "5",
+		"576p":  "6",
+		"576i":  "7",
+		"480p":  "8",
+		"480i":  "9",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/blu/rules.go b/internal/trackers/impl/unit3d/sites/blu/rules.go
new file mode 100644
index 00000000..f703a760
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/blu/rules.go
@@ -0,0 +1,47 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package blu
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules strictly limits non-disc uploads to MKV, with TS allowed for HDTV and
+// MP4 allowed for Dolby Vision-only WEBDL or HDTV releases.
+func Rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkContainer} }
+
+func checkContainer(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	if unit3d.IsDiscType(meta.DiscType) {
+		return nil, nil
+	}
+	container := strings.ToLower(strings.TrimSpace(meta.Container))
+	if container == "" {
+		return nil, nil
+	}
+	allowed := []string{"mkv"}
+	typeValue := unit3d.RuleType(meta)
+	if typeValue == "HDTV" {
+		allowed = append(allowed, "ts")
+	}
+	if (typeValue == "WEBDL" || typeValue == "HDTV") && unit3d.DolbyVisionOnly(meta) {
+		allowed = append(allowed, "mp4")
+	}
+	if unit3d.ContainsRuleValue([]string{container}, allowed) {
+		return nil, nil
+	}
+	return []api.RuleFailure{trackers.NewRuleFailure(
+		"container",
+		"BLU requires one of the following containers for this release: "+strings.ToUpper(strings.Join(allowed, ", ")),
+		api.RuleDispositionStrict,
+	)}, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/cbr/banned_groups.go b/internal/trackers/impl/unit3d/sites/cbr/banned_groups.go
new file mode 100644
index 00000000..31c92907
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/cbr/banned_groups.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package cbr
+
+// BannedGroups returns CBR's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"4K4U",
+		"afm72",
+		"Alcaide_Kira",
+		"AROMA",
+		"ASM",
+		"Bandi",
+		"BiTOR",
+		"BLUDV",
+		"Bluespots",
+		"BOLS",
+		"CaNNIBal",
+		"Comando", //nolint:misspell // Specific group spelling.
+		"d3g",
+		"DepraveD",
+		"EMBER",
+		"FGT",
+		"FreetheFish",
+		"Garshasp",
+		"Ghost",
+		"Grym",
+		"HDS",
+		"Hi10",
+		"HiQVE",
+		"Hiro360",
+		"ImE",
+		"ION10",
+		"iVy",
+		"Judas",
+		"LAMA",
+		"Langbard",
+		"Lapumia",
+		"LION",
+		"MeGusta",
+		"MONOLITH",
+		"MRCS",
+		"NaNi",
+		"Natty",
+		"nikt0",
+		"OEPlus",
+		"OFT",
+		"OsC",
+		"Panda",
+		"PANDEMONiUM",
+		"PHOCiS",
+		"PiRaTeS",
+		"PYC",
+		"QxR",
+		"r00t",
+		"Ralphy",
+		"RARBG",
+		"RetroPeeps",
+		"RZeroX",
+		"S74Ll10n",
+		"SAMPA",
+		"Sicario",
+		"SiCFoI",
+		"Silence",
+		"SkipTT",
+		"SM737",
+		"SPDVD",
+		"STUTTERSHIT",
+		"SWTYBLZ",
+		"t3nzin",
+		"TAoE",
+		"TEKNO3D",
+		"Telly",
+		"TGx",
+		"Tigole",
+		"TSP",
+		"TSPxL",
+		"TWA",
+		"UnKn0wn",
+		"VXT",
+		"Vyndros",
+		"W32",
+		"Will1869",
+		"x0r",
+		"YIFY",
+		"YTS.MX",
+		"YTS",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/cbr/profile.go b/internal/trackers/impl/unit3d/sites/cbr/profile.go
new file mode 100644
index 00000000..feafc8da
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/cbr/profile.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package cbr
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns CBR's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "CBR",
+		BaseURL:      "https://capybarabr.com",
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			BuildName:         buildName,
+			ResolveCategoryID: categoryID,
+		},
+	}
+}
+func buildName(meta api.UploadSubject, cfg config.TrackerConfig) string {
+	return unit3d.FormatLocalizedName(meta, cfg.TagForCustomRelease)
+}
+func categoryID(meta api.UploadSubject) string {
+	if strings.EqualFold(unit3d.Category(meta), "TV") && meta.Anime {
+		return "4"
+	}
+	return unit3d.DefaultCategoryID(meta)
+}
diff --git a/internal/trackers/impl/unit3d/sites/dp/banned_groups.go b/internal/trackers/impl/unit3d/sites/dp/banned_groups.go
new file mode 100644
index 00000000..dc87af4d
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/dp/banned_groups.go
@@ -0,0 +1,72 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dp
+
+// BannedGroups returns DP's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"ARCADE",
+		"aXXo",
+		"BANDOLEROS",
+		"BONE",
+		"BRrip",
+		"CM8",
+		"CrEwSaDe",
+		"CTFOH",
+		"dAV1nci",
+		"DNL",
+		"eranger2",
+		"FaNGDiNG0",
+		"FGT",
+		"FiSTER",
+		"flower",
+		"GalaxyTV",
+		"HD2DVD",
+		"HDTime",
+		"HorribleSubs",
+		"iHYTECH",
+		"ION10",
+		"iPlanet",
+		"KiNGDOM",
+		"LAMA",
+		"MeGusta",
+		"mHD",
+		"mSD",
+		"NaNi",
+		"NhaNc3",
+		"nHD",
+		"nikt0",
+		"nSD",
+		"OFT",
+		"PiTBULL",
+		"PRODJi",
+		"PSA",
+		"RARBG",
+		"Rifftrax",
+		"ROCKETRACCOON",
+		"SANTi",
+		"SasukeducK",
+		"SEEDSTER",
+		"ShAaNiG",
+		"Sicario",
+		"STUTTERSHIT",
+		"Subsplease",
+		"SyncUp",
+		"TAoE",
+		"TGALAXY",
+		"TGx",
+		"TORRENTGALAXY",
+		"ToVaR",
+		"Trix",
+		"TSP",
+		"TSPxL",
+		"ViSION",
+		"VXT",
+		"WAF",
+		"WKS",
+		"X0r",
+		"YIFY",
+		"YTS",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/dp/profile.go b/internal/trackers/impl/unit3d/sites/dp/profile.go
new file mode 100644
index 00000000..de0ae67d
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/dp/profile.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dp
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns DP's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "DP",
+		BaseURL:      "https://darkpeers.org",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			BuildName: buildName,
+		},
+	}
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := baseName(meta)
+	if label := audioLabel(meta.AudioLanguages); label != "" {
+		name = strings.Replace(name, "Dual-Audio", label, 1)
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
+func baseName(meta api.UploadSubject) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
+func audioLabel(values []string) string {
+	unique := map[string]struct{}{}
+	for _, value := range values {
+		if value = strings.TrimSpace(value); value != "" {
+			unique[strings.ToUpper(value)] = struct{}{}
+		}
+	}
+	switch len(unique) {
+	case 0:
+		return ""
+	case 1:
+		for value := range unique {
+			return value
+		}
+		return ""
+	case 2:
+		return "Dual-Audio"
+	default:
+		return "MULTi"
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/dp/rules.go b/internal/trackers/impl/unit3d/sites/dp/rules.go
new file mode 100644
index 00000000..8d6691a7
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/dp/rules.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package dp
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+var nordic = []string{"english", "norwegian", "norsk", "no", "nb", "nn", "swedish", "sv", "danish", "da", "finnish", "fi", "icelandic", "is"}
+
+// Rules strictly blocks single-file folders and hardcoded subtitles. Its
+// release-group exception remains waivable; its Nordic language requirement is
+// strict.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockSingleFileFolder: true,
+		BlockHardcodedSubs:    true,
+		BlockGroupUnlessType:  map[string][]string{"EVO": {"WEBDL"}},
+		Language: &trackers.LanguageRule{
+			Languages:    nordic,
+			RequireAudio: true,
+			RequireSubs:  true,
+		},
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/emuw/profile.go b/internal/trackers/impl/unit3d/sites/emuw/profile.go
new file mode 100644
index 00000000..243f31de
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/emuw/profile.go
@@ -0,0 +1,50 @@
+package emuw
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns EMUW's type and resolution mappings. Unknown types use the
+// encode ID, while unknown resolutions use the site's Other ID.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "EMUW",
+		BaseURL: "https://emuwarez.com",
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	value := map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"ENCODE": "3",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+	}[unit3d.InferType(meta)]
+	if value == "" {
+		return "3"
+	}
+	return value
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1080p": "3",
+		"1080i": "4",
+		"720p":  "5",
+		"576p":  "6",
+		"540p":  "7",
+		"480p":  "8",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/friki/profile.go b/internal/trackers/impl/unit3d/sites/friki/profile.go
new file mode 100644
index 00000000..06abb76c
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/friki/profile.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package friki
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns FRIKI's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "FRIKI",
+		BaseURL: "https://frikibar.com",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/hhd/banned_groups.go b/internal/trackers/impl/unit3d/sites/hhd/banned_groups.go
new file mode 100644
index 00000000..1d9bd550
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/hhd/banned_groups.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hhd
+
+// BannedGroups returns HHD's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"aXXo",
+		"BONE",
+		"BRrip",
+		"CM8",
+		"CrEwSaDe",
+		"CTFOH",
+		"dAV1nci",
+		"d3g",
+		"DNL",
+		"FaNGDiNG0",
+		"GalaxyTV",
+		"HD2DVD",
+		"HDTime",
+		"iHYTECH",
+		"ION10",
+		"iPlanet",
+		"KiNGDOM",
+		"LAMA",
+		"MeGusta",
+		"mHD",
+		"mSD",
+		"NaNi",
+		"NhaNc3",
+		"nHD",
+		"nikt0",
+		"nSD",
+		"OFT",
+		"PRODJi",
+		"RARBG",
+		"Rifftrax",
+		"SANTi",
+		"SasukeducK",
+		"ShAaNiG",
+		"Sicario",
+		"STUTTERSHIT",
+		"TGALAXY",
+		"TORRENTGALAXY",
+		"TSP",
+		"TSPxL",
+		"ViSION",
+		"VXT",
+		"WAF",
+		"WKS",
+		"x0r",
+		"YAWNiX",
+		"YIFY",
+		"YTS",
+		"PSA",
+		"EVO",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/hhd/profile.go b/internal/trackers/impl/unit3d/sites/hhd/profile.go
new file mode 100644
index 00000000..700f032a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/hhd/profile.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hhd
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns HHD's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "HHD",
+		BaseURL:      "https://homiehelpdesk.net",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/hhd/rules.go b/internal/trackers/impl/unit3d/sites/hhd/rules.go
new file mode 100644
index 00000000..8bf0fc05
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/hhd/rules.go
@@ -0,0 +1,9 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package hhd
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly blocks DVDRip uploads.
+func Rules() *trackers.RuleSet { return &trackers.RuleSet{BlockDVDRip: true} }
diff --git a/internal/trackers/impl/unit3d/sites/ihd/profile.go b/internal/trackers/impl/unit3d/sites/ihd/profile.go
new file mode 100644
index 00000000..eed82072
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ihd/profile.go
@@ -0,0 +1,47 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ihd
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns IHD's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "IHD",
+		BaseURL: "https://infinityhd.net",
+		Site: unit3d.SiteProfile{
+			ResolveResolutionID: resolutionID,
+			ResolveCategoryID:   categoryID,
+		},
+	}
+}
+
+func categoryID(meta api.UploadSubject) string {
+	category := unit3d.Category(meta)
+	if strings.EqualFold(category, "TV") && meta.Anime {
+		return "3"
+	}
+	if strings.EqualFold(category, "MOVIE") && meta.Anime {
+		return "4"
+	}
+	return unit3d.DefaultCategoryID(meta)
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1440p": "3",
+		"1080p": "3",
+		"1080i": "4",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/itt/profile.go b/internal/trackers/impl/unit3d/sites/itt/profile.go
new file mode 100644
index 00000000..6d63d987
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/itt/profile.go
@@ -0,0 +1,45 @@
+package itt
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns ITT's type mapping, preferring recognized release-name type
+// markers before falling back to the inferred Unit3D type.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "ITT",
+		BaseURL: "https://itatorrents.xyz",
+		Site: unit3d.SiteProfile{
+			ResolveTypeID: typeID,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	name := strings.ToUpper(strings.TrimSpace(meta.ReleaseName))
+	for marker, id := range map[string]string{
+		"DLMUX":  "27",
+		"BDMUX":  "29",
+		"WEBMUX": "26",
+		"DVDMUX": "39",
+		"BDRIP":  "25",
+	} {
+		if strings.Contains(name, marker) {
+			return id
+		}
+	}
+	return map[string]string{
+		"DISC":      "1",
+		"REMUX":     "2",
+		"WEBDL":     "4",
+		"WEBRIP":    "5",
+		"HDTV":      "6",
+		"ENCODE":    "3",
+		"DVDRIP":    "24",
+		"CINEMA-MD": "14",
+	}[unit3d.InferType(meta)]
+}
diff --git a/internal/trackers/impl/unit3d/sites/lcd/profile.go b/internal/trackers/impl/unit3d/sites/lcd/profile.go
new file mode 100644
index 00000000..5abeec26
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lcd/profile.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lcd
+
+import (
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns LCD's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "LCD",
+		BaseURL: "https://locadora.cc",
+		Site: unit3d.SiteProfile{
+			BuildName: buildName,
+		},
+	}
+}
+func buildName(meta api.UploadSubject, cfg config.TrackerConfig) string {
+	return unit3d.FormatLocalizedName(meta, cfg.TagForCustomRelease)
+}
diff --git a/internal/trackers/impl/unit3d/sites/ldu/profile.go b/internal/trackers/impl/unit3d/sites/ldu/profile.go
new file mode 100644
index 00000000..23bde6b1
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ldu/profile.go
@@ -0,0 +1,155 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ldu
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns LDU's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "LDU",
+		BaseURL: "https://theldu.to",
+		Site: unit3d.SiteProfile{
+			BuildName:         buildName,
+			ResolveCategoryID: categoryID,
+		},
+	}
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	nonEnglishOriginal := !isEnglish(originalLanguage(meta))
+	audio, nonEnglishAudio := firstAudio(meta.AudioLanguages)
+	subtitle := firstSubtitle(meta.SubtitleLanguages)
+	if categoryID(meta) == "18" && subtitle != "" {
+		return clean(name + " [Subs " + subtitle + "]")
+	}
+	if !nonEnglishOriginal && !nonEnglishAudio {
+		return clean(name)
+	}
+	parts := make([]string, 0, 2)
+	if audio != "" {
+		parts = append(parts, "["+audio+"]")
+	}
+	if subtitle != "" {
+		parts = append(parts, "[Subs "+subtitle+"]")
+	}
+	if len(parts) == 0 {
+		return clean(name)
+	}
+	return clean(name + " " + strings.Join(parts, " "))
+}
+func clean(value string) string { return strings.TrimSpace(strings.Join(strings.Fields(value), " ")) }
+func firstAudio(values []string) (string, bool) {
+	for _, value := range values {
+		if code, english, ok := languageCode(value); ok {
+			return code, !english
+		}
+	}
+	return "", false
+}
+func firstSubtitle(values []string) string {
+	for _, value := range values {
+		if code, _, ok := languageCode(value); ok {
+			return code
+		}
+	}
+	return ""
+}
+func languageCode(value string) (string, bool, bool) {
+	tag, ok := unit3d.ParseLanguageTag(value)
+	if !ok {
+		return "", false, false
+	}
+	base, _ := tag.Base()
+	if base.String() == "und" {
+		return "", false, false
+	}
+	code := base.ISO3()
+	if code == "" {
+		return "", false, false
+	}
+	return strings.ToUpper(code), base.String() == "en", true
+}
+func originalLanguage(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil && strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage) != "" {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage)
+	}
+	if meta.ProviderMetadata.IMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage)
+	}
+	return ""
+}
+func isEnglish(value string) bool {
+	tag, ok := unit3d.ParseLanguageTag(value)
+	if !ok {
+		return false
+	}
+	base, _ := tag.Base()
+	return base.String() == "en"
+}
+
+func categoryID(meta api.UploadSubject) string {
+	category := unit3d.Category(meta)
+	genres := strings.ToLower(
+		strings.TrimSpace(
+			strings.Join([]string{strings.TrimSpace(meta.Release.Genre), unit3d.Keywords(meta), unit3d.TMDBGenres(meta), unit3d.IMDBGenres(meta)}, ","),
+		),
+	)
+	hasEnglishAudio := unit3d.HasEnglishLanguage(meta.AudioLanguages)
+	hasEnglishSubs := unit3d.HasEnglishLanguage(meta.SubtitleLanguages)
+	containsDubbed := strings.Contains(strings.ToLower(strings.TrimSpace(meta.Audio)), "dubbed")
+	edition := strings.ToLower(strings.TrimSpace(meta.Edition))
+
+	if strings.EqualFold(category, "MOVIE") {
+		switch {
+		case meta.Anime || meta.Identity.MALID != 0:
+			return "8"
+		case strings.Contains(edition, "fanedit") || strings.Contains(edition, "fanres"):
+			return "12"
+		case strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D"):
+			return "21"
+		case unit3d.HasAdultToken(genres) && !hasEnglishAudio && !hasEnglishSubs:
+			return "45"
+		case unit3d.HasAdultToken(genres):
+			return "6"
+		case strings.Contains(genres, "documentary"):
+			return "17"
+		case strings.Contains(genres, "musical"):
+			return "25"
+		case !hasEnglishAudio && !hasEnglishSubs:
+			return "22"
+		case containsDubbed:
+			return "27"
+		default:
+			return "1"
+		}
+	}
+	if strings.EqualFold(category, "TV") {
+		switch {
+		case meta.Anime || meta.Identity.MALID != 0:
+			return "9"
+		case strings.Contains(genres, "documentary"):
+			return "40"
+		case !hasEnglishAudio && !hasEnglishSubs:
+			return "29"
+		case meta.TVPack:
+			return "2"
+		case containsDubbed:
+			return "31"
+		default:
+			return "41"
+		}
+	}
+	return unit3d.DefaultCategoryID(meta)
+}
diff --git a/internal/trackers/impl/unit3d/sites/ldu/profile_test.go b/internal/trackers/impl/unit3d/sites/ldu/profile_test.go
new file mode 100644
index 00000000..069d8dc7
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ldu/profile_test.go
@@ -0,0 +1,23 @@
+package ldu
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildNameUsesFirstParseableLanguages(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName:       "Example.Release.2026.1080p.WEB-DL.DD5.1.H264-GRP",
+		Identity:          api.ExternalIdentity{Category: "MOVIE"},
+		AudioLanguages:    []string{"", "Japanese", "English"},
+		SubtitleLanguages: []string{"", "English"},
+		ProviderMetadata:  api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"}},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	if !strings.Contains(got, "[JPN]") || !strings.Contains(got, "[Subs ENG]") {
+		t.Fatalf("name = %q", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lst/profile.go b/internal/trackers/impl/unit3d/sites/lst/profile.go
new file mode 100644
index 00000000..cfbeef25
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lst/profile.go
@@ -0,0 +1,67 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lst
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+)
+
+// Profile returns LST's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "LST",
+		BaseURL: "https://lst.gg",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			ApplyAdditionalPayload: additionalPayload,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			TrackTrumpableID:     true,
+			MatchDVDReleaseGroup: true,
+		},
+		BannedPolicy: &trackers.BannedGroupPolicy{
+			EndpointPath:  "/api/bannedReleaseGroups",
+			RequireAPIKey: true,
+		},
+		ImageHost: &trackers.ImageHostPolicy{
+			ConditionalHost:   "lostimg",
+			OwnedHosts:        []string{"lostimg"},
+			EnableWithLostimg: true,
+		},
+	}
+}
+
+func additionalPayload(req trackers.PreparationInput, data map[string]string) {
+	if req.TrackerConfig.Draft {
+		data["draft_queue_opt_in"] = "1"
+	} else {
+		data["draft_queue_opt_in"] = "0"
+	}
+	if editionID, ok := editionID(req.Meta.Edition); ok {
+		data["edition_id"] = editionID
+	}
+}
+
+func editionID(edition string) (string, bool) {
+	normalized := strings.ReplaceAll(strings.ToLower(strings.TrimSpace(edition)), "’", "'")
+	value, ok := map[string]string{
+		"collector's edition": "1",
+		"director's cut":      "2",
+		"extended cut":        "3",
+		"extended uncut":      "4",
+		"extended unrated":    "5",
+		"limited edition":     "6",
+		"special edition":     "7",
+		"theatrical cut":      "8",
+		"uncut":               "9",
+		"unrated":             "10",
+		"x cut":               "11",
+		"alternative cut":     "12",
+		"other":               "0",
+	}[normalized]
+	return value, ok
+}
diff --git a/internal/trackers/impl/unit3d/sites/lst/rules.go b/internal/trackers/impl/unit3d/sites/lst/rules.go
new file mode 100644
index 00000000..f12c321a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lst/rules.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lst
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly requires valid MediaInfo encode settings and applies a
+// strict non-disc English audio-or-subtitle requirement.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{RequireValidMISetting: true, Language: &trackers.LanguageRule{
+		Languages:      []string{"english", "en", "eng"},
+		RequireAudio:   true,
+		RequireSubs:    true,
+		AllowOriginal:  true,
+		ApplyIfNonDisc: true,
+	}}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lt/banned_groups.go b/internal/trackers/impl/unit3d/sites/lt/banned_groups.go
new file mode 100644
index 00000000..3f5d4afd
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lt/banned_groups.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lt
+
+// BannedGroups returns LT's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"EVO",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lt/name.go b/internal/trackers/impl/unit3d/sites/lt/name.go
new file mode 100644
index 00000000..0b449c73
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lt/name.go
@@ -0,0 +1,260 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lt
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	markerPattern         = regexp.MustCompile(`\b(?:1080p|1080i|720p|2160p|4320p|8640p|mkv|mp4|avi|ts|bluray|blu-ray|web-dl|webdl|webrip|hdtv|dvd|complete|vostfr|multi|subfrench|french|truefrench)\b`)
+	akaPattern            = regexp.MustCompile(`(?i)\baka\b`)
+	multipleDotsPattern   = regexp.MustCompile(`\.+`)
+	multipleSpacesPattern = regexp.MustCompile(`\s+`)
+	trailingSuffixPattern = regexp.MustCompile(`(?i)\b(?:s\d+e\d+|s\d+|e\d+|\d{4})\b.*$`)
+)
+
+var audioLatinoCheck = map[string]bool{
+	"lat": true, "es-419": true, "es-mx": true,
+}
+
+var audioCastilianCheck = map[string]bool{
+	"castilian": true, "es-es": true,
+}
+
+var latinoKeywords = []string{
+	"latino", "lat", "es-419", "mexicano", "argentino", "chileno", "colombiano", "peruano", "venezolano",
+}
+
+var castilianKeywords = []string{
+	"castellano", "castilian", "es-es", "español de españa", "espanol de espana",
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	aka := ""
+	title := ""
+	origTitle := ""
+	origLang := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		aka = meta.ProviderMetadata.TMDB.RetrievedAKA
+		title = meta.ProviderMetadata.TMDB.Title
+		origTitle = meta.ProviderMetadata.TMDB.OriginalTitle
+		origLang = meta.ProviderMetadata.TMDB.OriginalLanguage
+	}
+	if title == "" && meta.ProviderMetadata.IMDB != nil {
+		title = meta.ProviderMetadata.IMDB.Title
+	}
+	if origTitle == "" {
+		origTitle = title
+	}
+
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+
+	// 1. Strip episode title for LT
+	category := unit3d.Category(meta)
+	if category == "TV" && meta.EpisodeTitle != "" {
+		name = removeEpisodeTitle(name, meta.EpisodeTitle)
+	}
+
+	ltName := name
+	ltName = strings.ReplaceAll(ltName, "Dual-Audio", "")
+	ltName = strings.ReplaceAll(ltName, "Dubbed", "")
+
+	// Find the end of the title block (start of year, resolution, source, etc.)
+	titleEndIdx := len(ltName)
+	if loc := markerPattern.FindStringIndex(strings.ToLower(ltName)); loc != nil {
+		titleEndIdx = loc[0]
+	}
+
+	titleBlock := ltName[:titleEndIdx]
+	restOfName := ltName[titleEndIdx:]
+
+	// Preserve trailing season/episode/year in titleBlock
+	cleanTitleBlock := titleBlock
+	var trailingSuffix string
+	if loc := trailingSuffixPattern.FindStringIndex(titleBlock); loc != nil {
+		trailingSuffix = titleBlock[loc[0]:]
+		cleanTitleBlock = titleBlock[:loc[0]]
+	}
+
+	// Determine the correct target title to use
+	targetTitle := title
+	if origLang == "es" {
+		// Use Spanish title for Spanish original series/movies
+		if aka != "" {
+			akaClean := strings.TrimSpace(strings.ReplaceAll(aka, "AKA", ""))
+			if akaClean != "" {
+				targetTitle = akaClean
+			}
+		} else if origTitle != "" {
+			targetTitle = origTitle
+		}
+	}
+
+	if targetTitle != "" {
+		targetTitleDotted := strings.ReplaceAll(targetTitle, " ", ".")
+		cleanTitleBlockNorm := strings.Trim(strings.ReplaceAll(cleanTitleBlock, ".", " "), " ")
+		// If the title block contains AKA, or we need to replace a mismatched title:
+		if akaPattern.MatchString(cleanTitleBlock) || !strings.EqualFold(cleanTitleBlockNorm, targetTitle) {
+			cleanTitleBlock = targetTitleDotted
+		}
+	}
+
+	titleBlock = cleanTitleBlock + "." + trailingSuffix
+	ltName = titleBlock + restOfName
+
+	isDisc := false
+	if unit3d.IsDiscType(meta.DiscType) || unit3d.IsDiscType(meta.Release.Type) || meta.DiscType != "" {
+		isDisc = true
+	}
+
+	if !isDisc {
+		type rawMediaInfoDoc struct {
+			Media struct {
+				Track []map[string]any `json:"track"`
+			} `json:"media"`
+		}
+
+		var tracks []map[string]any
+		if meta.MediaInfoJSONPath != "" {
+			if payload, err := os.ReadFile(meta.MediaInfoJSONPath); err == nil {
+				var doc rawMediaInfoDoc
+				if err := json.Unmarshal(payload, &doc); err == nil {
+					tracks = doc.Media.Track
+				}
+			}
+		}
+
+		hasSpanishAudio := false
+		hasLatino := false
+		hasCastilian := false
+
+		hasTracks := false
+		if len(tracks) > 0 {
+			for _, track := range tracks {
+				trackType := ""
+				if val, ok := track["@type"]; ok {
+					trackType = strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", val)))
+				}
+				if trackType != "audio" {
+					continue
+				}
+				hasTracks = true
+				lang := strings.ToLower(namesTrackString(track, "Language", "Language_String", "Language_String2", "Language_String3"))
+				titleText := strings.ToLower(namesTrackString(track, "Title", "Title_String", "Title_String2", "Title_String3"))
+
+				if strings.Contains(titleText, "commentary") {
+					continue
+				}
+
+				isLatinoTitle := false
+				for _, kw := range latinoKeywords {
+					if strings.Contains(titleText, kw) {
+						isLatinoTitle = true
+						break
+					}
+				}
+				isCastilianTitle := false
+				for _, kw := range castilianKeywords {
+					if strings.Contains(titleText, kw) {
+						isCastilianTitle = true
+						break
+					}
+				}
+
+				if audioLatinoCheck[lang] || (lang == "es" && isLatinoTitle) {
+					hasLatino = true
+					hasSpanishAudio = true
+				} else if (lang == "es" && isCastilianTitle) || audioCastilianCheck[lang] {
+					hasCastilian = true
+					hasSpanishAudio = true
+				}
+			}
+		}
+
+		if !hasTracks {
+			// Fallback to AudioLanguages if MediaInfo JSON wasn't parsed
+			for _, lang := range meta.AudioLanguages {
+				if strings.EqualFold(lang, "Spanish") || strings.EqualFold(lang, "es") {
+					hasSpanishAudio = true
+					hasLatino = true
+					break
+				}
+			}
+		}
+
+		tag := strings.TrimSpace(meta.Tag)
+		// insertTagBracket inserts the label just before "-<tag>" so the result
+		// is "… [LABEL]-TAG" rather than "…- [LABEL]TAG".
+		insertTagBracket := func(s, label string) string {
+			if tag != "" {
+				sep := "-" + tag
+				if idx := strings.LastIndex(s, sep); idx != -1 {
+					return s[:idx] + " [" + label + "]" + s[idx:]
+				}
+			}
+			return s + " [" + label + "]"
+		}
+		if hasSpanishAudio {
+			if !hasLatino && hasCastilian {
+				if !strings.Contains(ltName, "[CAST]") {
+					ltName = insertTagBracket(ltName, "CAST")
+				}
+			}
+		} else {
+			if !strings.Contains(ltName, "[SUBS]") {
+				ltName = insertTagBracket(ltName, "SUBS")
+			}
+		}
+	}
+
+	ltName = multipleDotsPattern.ReplaceAllString(ltName, ".")
+	ltName = multipleSpacesPattern.ReplaceAllString(ltName, " ")
+	return strings.Trim(ltName, ". ")
+}
+
+func removeEpisodeTitle(name string, episodeTitle string) string {
+	cleanedTitle := strings.TrimSpace(episodeTitle)
+	if cleanedTitle == "" {
+		return name
+	}
+
+	// Remove with dots
+	dotted := strings.ReplaceAll(cleanedTitle, " ", ".")
+	name = strings.ReplaceAll(name, dotted, "")
+
+	// Remove with spaces
+	name = strings.ReplaceAll(name, cleanedTitle, "")
+
+	// Clean up any duplicates
+	name = strings.ReplaceAll(name, "..", ".")
+	name = strings.ReplaceAll(name, "  ", " ")
+	name = strings.ReplaceAll(name, " .", ".")
+	name = strings.ReplaceAll(name, ". ", ".")
+
+	return strings.Trim(name, ". ")
+}
+
+func namesTrackString(track map[string]any, keys ...string) string {
+	for _, key := range keys {
+		if value, ok := track[key]; ok {
+			trimmed := strings.TrimSpace(fmt.Sprintf("%v", value))
+			if trimmed != "" {
+				return trimmed
+			}
+		}
+	}
+	return ""
+}
diff --git a/internal/trackers/impl/unit3d/sites/lt/profile.go b/internal/trackers/impl/unit3d/sites/lt/profile.go
new file mode 100644
index 00000000..69f68777
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lt/profile.go
@@ -0,0 +1,85 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lt
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns LT's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "LT",
+		BaseURL:      "https://lat-team.com",
+		BannedGroups: BannedGroups(),
+		Rules:        Rules(),
+		Site: unit3d.SiteProfile{
+			BuildName:         buildName,
+			ResolveCategoryID: resolveCategoryID,
+		},
+	}
+}
+
+var ltAsianCountries = map[string]bool{
+	"AE": true, "AF": true, "AM": true, "AZ": true, "BD": true, "BH": true, "BN": true, "BT": true, "CN": true, "CY": true, "GE": true, "HK": true, "ID": true, "IL": true, "IN": true,
+	"IQ": true, "IR": true, "JO": true, "JP": true, "KG": true, "KH": true, "KP": true, "KR": true, "KW": true, "KZ": true, "LA": true, "LB": true, "LK": true, "MM": true, "MN": true,
+	"MO": true, "MV": true, "MY": true, "NP": true, "OM": true, "PH": true, "PK": true, "PS": true, "QA": true, "SA": true, "SG": true, "SY": true, "TH": true, "TJ": true, "TL": true,
+	"TM": true, "TR": true, "TW": true, "UZ": true, "VN": true, "YE": true,
+}
+
+func resolveCategoryID(meta api.UploadSubject) string {
+	category := unit3d.Category(meta)
+
+	categoryID := "1" // Default MOVIE
+	if category == "TV" {
+		categoryID = "2" // Default TV
+	}
+
+	if category == "TV" {
+		if meta.Anime {
+			return "5"
+		}
+
+		keywords := ""
+		overview := ""
+		genres := ""
+		var originCountries []string
+
+		if meta.ProviderMetadata.TMDB != nil {
+			keywords = strings.ToLower(meta.ProviderMetadata.TMDB.Keywords)
+			overview = strings.ToLower(meta.ProviderMetadata.TMDB.Overview)
+			genres = strings.ToLower(meta.ProviderMetadata.TMDB.Genres)
+			originCountries = meta.ProviderMetadata.TMDB.OriginCountry
+		}
+
+		soapKeywords := []string{"telenovela", "novela", "soap", "culebrón", "culebron"}
+		hasSoap := false
+		for _, kw := range soapKeywords {
+			if strings.Contains(keywords, kw) || strings.Contains(overview, kw) {
+				hasSoap = true
+				break
+			}
+		}
+		if hasSoap {
+			return "8"
+		}
+
+		hasAsianCountry := false
+		for _, c := range originCountries {
+			if ltAsianCountries[strings.ToUpper(c)] {
+				hasAsianCountry = true
+				break
+			}
+		}
+
+		if strings.Contains(genres, "drama") && hasAsianCountry {
+			return "20"
+		}
+	}
+
+	return categoryID
+}
diff --git a/internal/trackers/impl/unit3d/sites/lt/profile_test.go b/internal/trackers/impl/unit3d/sites/lt/profile_test.go
new file mode 100644
index 00000000..a7fe302d
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lt/profile_test.go
@@ -0,0 +1,172 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lt
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestProfileCategoryID(t *testing.T) {
+	profile := Profile().Site
+
+	// Movie
+	if got := profile.ResolveCategoryID(api.UploadSubject{Type: "WEBDL", Identity: api.ExternalIdentity{Category: api.CanonicalCategoryMovie}}); got != "1" {
+		t.Fatalf("expected Movie category ID 1, got %q", got)
+	}
+
+	// TV
+	if got := profile.ResolveCategoryID(api.UploadSubject{Type: "WEBDL", Identity: api.ExternalIdentity{Category: api.CanonicalCategoryTV}}); got != "2" {
+		t.Fatalf("expected TV category ID 2, got %q", got)
+	}
+
+	// Anime
+	if got := profile.ResolveCategoryID(api.UploadSubject{Type: "WEBDL", Identity: api.ExternalIdentity{Category: api.CanonicalCategoryTV}, Anime: true}); got != "5" {
+		t.Fatalf("expected Anime category ID 5, got %q", got)
+	}
+
+	// Soap/Telenovela
+	soapMeta := api.UploadSubject{
+		Type:     "WEBDL",
+		Identity: api.ExternalIdentity{Category: api.CanonicalCategoryTV},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Keywords: "telenovela",
+			},
+		},
+	}
+	if got := profile.ResolveCategoryID(soapMeta); got != "8" {
+		t.Fatalf("expected Soap category ID 8, got %q", got)
+	}
+
+	// Turkish/Asian drama
+	dramaMeta := api.UploadSubject{
+		Type:     "WEBDL",
+		Identity: api.ExternalIdentity{Category: api.CanonicalCategoryTV},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Genres:        "drama",
+				OriginCountry: []string{"TR"},
+			},
+		},
+	}
+	if got := profile.ResolveCategoryID(dramaMeta); got != "20" {
+		t.Fatalf("expected Drama category ID 20, got %q", got)
+	}
+}
+
+func TestProfileName(t *testing.T) {
+	profile := Profile().Site
+
+	// Title stripping and clean dubs
+	meta := api.UploadSubject{
+		ReleaseName:  "The.World.Is.Dancing.S01E04.Differing.Scales.of.Progress.Dual-Audio.1080p.WEB-DL-kotopi",
+		Tag:          "kotopi",
+		Identity:     api.ExternalIdentity{Category: api.CanonicalCategoryTV},
+		EpisodeTitle: "Differing Scales of Progress",
+	}
+	got := profile.BuildName(meta, config.TrackerConfig{})
+	want := "The.World.Is.Dancing.S01E04.1080p.WEB-DL [SUBS]-kotopi"
+	if got != want {
+		t.Fatalf("expected %q, got %q", want, got)
+	}
+
+	// Original Spanish title mapping
+	metaES := api.UploadSubject{
+		ReleaseName: "La.Casa.de.Papel.S01E01.1080p.WEBDL-GRP",
+		Tag:         "GRP",
+		Identity:    api.ExternalIdentity{Category: api.CanonicalCategoryTV},
+		AudioLanguages: []string{"Spanish"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			TMDB: &api.TMDBMetadata{
+				Title:            "Money Heist",
+				OriginalTitle:    "La Casa de Papel",
+				OriginalLanguage: "es",
+			},
+		},
+	}
+	gotES := profile.BuildName(metaES, config.TrackerConfig{})
+	wantES := "La.Casa.de.Papel.S01E01.1080p.WEBDL-GRP" // keeps Spanish
+	if gotES != wantES {
+		t.Fatalf("expected %q, got %q", wantES, gotES)
+	}
+}
+
+func TestRulesSpanishRequirements(t *testing.T) {
+	reg := trackers.NewRegistry()
+	profile := Profile()
+	definition := unit3d.NewWithProfile(profile)
+	if err := reg.Register(definition); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	// Helper to create valid base rule subject that passes default unit3d metadata requirements
+	newRuleSubject := func() api.RuleSubject {
+		return api.RuleSubject{
+			Identity: api.ExternalIdentity{
+				TMDBID:   1,
+				Category: api.CanonicalCategoryTV,
+			},
+			ProviderMetadata: api.SourceScopedMetadata{
+				TMDB: &api.TMDBMetadata{
+					TMDBID: 1,
+					Title:  "Example",
+				},
+			},
+			Assessments: api.ReleaseAssessments{
+				MediaInfoEncodeSettings: api.EncodeSettingsStatusNotApplicable,
+			},
+		}
+	}
+
+	// 1. Spanish Audio - Should Pass
+	metaAudio := newRuleSubject()
+	metaAudio.AudioLanguages = []string{"Spanish"}
+	failures, err := trackers.EvaluateRulesWithRegistry(context.Background(), reg, "LT", metaAudio, nil)
+	if err != nil {
+		t.Fatalf("evaluate: %v", err)
+	}
+	if len(failures) > 0 {
+		t.Fatalf("expected pass, got failures: %+v", failures)
+	}
+
+	// 2. Spanish Subtitles - Should Pass
+	metaSubs := newRuleSubject()
+	metaSubs.SubtitleLanguages = []string{"es"}
+	failures, err = trackers.EvaluateRulesWithRegistry(context.Background(), reg, "LT", metaSubs, nil)
+	if err != nil {
+		t.Fatalf("evaluate: %v", err)
+	}
+	if len(failures) > 0 {
+		t.Fatalf("expected pass, got failures: %+v", failures)
+	}
+
+	// 3. Neither Spanish Audio nor Subtitles - Should Fail
+	metaNeither := newRuleSubject()
+	metaNeither.AudioLanguages = []string{"English"}
+	metaNeither.SubtitleLanguages = []string{"French"}
+	failures, err = trackers.EvaluateRulesWithRegistry(context.Background(), reg, "LT", metaNeither, nil)
+	if err != nil {
+		t.Fatalf("evaluate: %v", err)
+	}
+	if len(failures) == 0 {
+		t.Fatalf("expected failure for neither language")
+	}
+
+	hasLanguageRuleFailure := false
+	for _, f := range failures {
+		if f.Rule == "language_rule" {
+			hasLanguageRuleFailure = true
+			break
+		}
+	}
+	if !hasLanguageRuleFailure {
+		t.Fatalf("expected language_rule failure, got: %+v", failures)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lt/rules.go b/internal/trackers/impl/unit3d/sites/lt/rules.go
new file mode 100644
index 00000000..95241db6
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lt/rules.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lt
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns LT's strict Spanish audio-or-subtitle requirements.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		Language: &trackers.LanguageRule{
+			Languages:    []string{"spanish", "es", "spa"},
+			RequireAudio: true,
+			RequireSubs:  true,
+		},
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lume/profile.go b/internal/trackers/impl/unit3d/sites/lume/profile.go
new file mode 100644
index 00000000..a22624a8
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lume/profile.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lume
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+)
+
+// Profile returns LUME's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "LUME",
+		BaseURL: "https://luminarr.me",
+		Rules:   Rules(),
+		BannedPolicy: &trackers.BannedGroupPolicy{
+			TRaSHGuideURL: "https://raw.githubusercontent.com/TRaSH-Guides/Guides/refs/heads/master/docs/json/radarr/cf/lq.json",
+		},
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/lume/rules.go b/internal/trackers/impl/unit3d/sites/lume/rules.go
new file mode 100644
index 00000000..b5a4644f
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/lume/rules.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package lume
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules strictly requires valid MediaInfo encode settings and enforces LUME's
+// non-disc container, resolution, and language limits. Adult failures remain
+// waivable; language failures are strict.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		RequireValidMISetting: true,
+		BlockAdult:            true,
+		AdultMessage:          "Porn is not allowed on LUME.",
+		Language: &trackers.LanguageRule{
+			Languages:      []string{"english", "en", "eng"},
+			RequireAudio:   true,
+			RequireSubs:    true,
+			AllowOriginal:  true,
+			ApplyIfNonDisc: true,
+		},
+		Check: checkRequirements,
+	}
+}
+
+func checkRequirements(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0, 2)
+	if !unit3d.IsDiscType(meta.DiscType) && !strings.EqualFold(strings.TrimSpace(meta.Container), "mkv") {
+		failures = append(failures, trackers.NewRuleFailure("container", "LUME only allows MKV containers for non-disc uploads.", api.RuleDispositionStrict))
+	}
+	if unit3d.IsDiscType(meta.DiscType) {
+		return failures, nil
+	}
+	resolution := unit3d.RuleResolution(meta)
+	if resolution == "" {
+		failures = append(failures, trackers.NewRuleFailure("resolution_required", "LUME requires a known resolution", api.RuleDispositionStrict))
+		return failures, nil
+	}
+	if unit3d.ResolutionBelow(resolution, "720p") {
+		failures = append(failures, trackers.NewRuleFailure(
+			"min_resolution",
+			"LUME only allows SD releases when the content does not have a higher resolution release.",
+			api.RuleDispositionStrict,
+		))
+	}
+	return failures, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/mns/profile.go b/internal/trackers/impl/unit3d/sites/mns/profile.go
new file mode 100644
index 00000000..e558db98
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/mns/profile.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mns
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns MNS's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "MNS",
+		BaseURL: "https://midnightscene.cc",
+		Rules:   Rules(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/mns/rules.go b/internal/trackers/impl/unit3d/sites/mns/rules.go
new file mode 100644
index 00000000..c6509af1
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/mns/rules.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package mns
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns MNS's waivable adult-content prohibition.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{BlockAdult: true, AdultMessage: "Adult content is not allowed"}
+}
diff --git a/internal/trackers/impl/unit3d/sites/oe/banned_groups.go b/internal/trackers/impl/unit3d/sites/oe/banned_groups.go
new file mode 100644
index 00000000..aeb6e97e
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/oe/banned_groups.go
@@ -0,0 +1,144 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package oe
+
+// BannedGroups returns OE's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"0neshot",
+		"3LT0N",
+		"4K4U",
+		"4yEo",
+		"$andra",
+		"[Oj]",
+		"AFG",
+		"AkihitoSubs",
+		"Alcaide_Kira",
+		"AniHLS",
+		"Anime Time",
+		"AnimeRG",
+		"AniURL",
+		"AOC",
+		"AR",
+		"AROMA",
+		"ASW",
+		"aXXo",
+		"BakedFish",
+		"BiTOR",
+		"BRrip",
+		"bonkai",
+		"Cleo",
+		"CM8",
+		"C4K",
+		"CrEwSaDe",
+		"core",
+		"d3g",
+		"DDR",
+		"DE3PM",
+		"DeadFish",
+		"DeeJayAhmed",
+		"DNL",
+		"ELiTE",
+		"EMBER",
+		"eSc",
+		"EVO",
+		"EZTV",
+		"FaNGDiNG0",
+		"FGT",
+		"fenix",
+		"FUM",
+		"FRDS",
+		"FROZEN",
+		"GalaxyTV",
+		"GalaxyRG",
+		"GalaxyRG265",
+		"GERMini",
+		"Grym",
+		"GrymLegacy",
+		"HAiKU",
+		"HD2DVD",
+		"HDTime",
+		"Hi10",
+		"HiQVE",
+		"ION10",
+		"iPlanet",
+		"iVy",
+		"JacobSwaggedUp",
+		"JIVE",
+		"Judas",
+		"KiNGDOM",
+		"LAMA",
+		"Leffe",
+		"LiGaS",
+		"LOAD",
+		"LycanHD",
+		"MeGusta",
+		"MezRips",
+		"mHD",
+		"Mr.Deadpool",
+		"mSD",
+		"NemDiggers",
+		"neoHEVC",
+		"NeXus",
+		"nHD",
+		"nikt0",
+		"nSD",
+		"NhaNc3",
+		"NOIVTC",
+		"pahe.in",
+		"PlaySD",
+		"playXD",
+		"PRODJi",
+		"ProRes",
+		"project-gxs",
+		"PSA",
+		"QaS",
+		"Ranger",
+		"RAPiDCOWS",
+		"RARBG",
+		"Raze",
+		"RCDiVX",
+		"RDN",
+		"Reaktor",
+		"REsuRRecTioN",
+		"RMTeam",
+		"ROBOTS",
+		"rubix",
+		"SANTi",
+		"SHUTTERSHIT",
+		"SM737",
+		"SpaceFish",
+		"SPASM",
+		"SSA",
+		"TBS",
+		"Telly",
+		"Tenrai-Sensei",
+		"TERMiNAL",
+		"TGx",
+		"TM",
+		"topaz",
+		"ToVaR",
+		"TSP",
+		"TSPxL",
+		"UnKn0wn",
+		"URANiME",
+		"UTR",
+		"VipapkSudios",
+		"ViSION",
+		"WAF",
+		"Wardevil",
+		"x0r",
+		"xRed",
+		"XS",
+		"YakuboEncodes",
+		"YAWNTiC",
+		"YAWNiX",
+		"YIFY",
+		"YTS",
+		"YuiSubs",
+		"ZKBL",
+		"ZmN",
+		"ZMNT",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/oe/profile.go b/internal/trackers/impl/unit3d/sites/oe/profile.go
new file mode 100644
index 00000000..a6c55603
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/oe/profile.go
@@ -0,0 +1,89 @@
+package oe
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns OE's no-group naming, codec-specific encode types, and
+// tracker-owned dupe, image-host, rule, and banned-group policies.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "OE",
+		BaseURL:      "https://onlyencodes.cc",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			BuildName:     buildName,
+			ResolveTypeID: typeID,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			AllowSizeVariance1080: true,
+		},
+		ImageHost: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"imgbox", "imgbb", "onlyimage", "ptscreens", "passtheimage"},
+		},
+	}
+}
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	name = strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+	tag := strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-"))
+	if tag != "" && !strings.EqualFold(tag, "nogrp") && !strings.EqualFold(tag, "nogroup") && !strings.EqualFold(tag, "unknown") &&
+		!strings.EqualFold(tag, "-unk-") {
+		return name
+	}
+	if name == "" || strings.HasSuffix(strings.ToUpper(name), "-NOGRP") {
+		return name
+	}
+	return name + "-NOGRP"
+}
+
+func typeID(meta api.UploadSubject) string {
+	typeValue := unit3d.InferType(meta)
+	if typeValue == "DVDRIP" {
+		typeValue = "ENCODE"
+	}
+	switch typeValue {
+	case "DISC":
+		return "19"
+	case "REMUX":
+		return "20"
+	case "WEBDL":
+		return "21"
+	case "WEBRIP", "ENCODE":
+		switch normalizeCodec(meta.VideoCodec) {
+		case "HEVC":
+			return "10"
+		case "AV1":
+			return "14"
+		case "AVC":
+			return "15"
+		default:
+			return "16"
+		}
+	default:
+		return "16"
+	}
+}
+
+func normalizeCodec(value string) string {
+	codec := strings.ToUpper(strings.TrimSpace(value))
+	switch {
+	case strings.Contains(codec, "AV1"):
+		return "AV1"
+	case strings.Contains(codec, "HEVC") || strings.Contains(codec, "H.265") || strings.Contains(codec, "H265") || strings.Contains(codec, "X265"):
+		return "HEVC"
+	case strings.Contains(codec, "AVC") || strings.Contains(codec, "H.264") || strings.Contains(codec, "H264") || strings.Contains(codec, "X264"):
+		return "AVC"
+	default:
+		return ""
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/oe/rules.go b/internal/trackers/impl/unit3d/sites/oe/rules.go
new file mode 100644
index 00000000..a150deae
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/oe/rules.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package oe
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns OE's waivable adult-content restriction and strict non-disc
+// English-language restriction.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:   true,
+		AdultMessage: "Porn is not allowed",
+		Language: &trackers.LanguageRule{
+			Languages:      []string{"english", "en", "eng"},
+			RequireAudio:   true,
+			RequireSubs:    true,
+			ApplyIfNonDisc: true,
+		},
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/otw/banned_groups.go b/internal/trackers/impl/unit3d/sites/otw/banned_groups.go
new file mode 100644
index 00000000..6766af32
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/otw/banned_groups.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package otw
+
+// BannedGroups returns OTW's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"[Oj]",
+		"3LTON",
+		"4yEo",
+		"ADE",
+		"AFG",
+		"AniHLS",
+		"AnimeRG",
+		"AniURL",
+		"AROMA",
+		"aXXo",
+		"CM8",
+		"CrEwSaDe",
+		"DeadFish",
+		"DNL",
+		"ELiTE",
+		"eSc",
+		"FaNGDiNG0",
+		"FGT",
+		"Flights",
+		"FRDS",
+		"FUM",
+		"GalaxyRG",
+		"HAiKU",
+		"HD2DVD",
+		"HDS",
+		"HDTime",
+		"Hi10",
+		"INFINITY",
+		"ION10",
+		"iPlanet",
+		"JIVE",
+		"KiNGDOM",
+		"LAMA",
+		"Leffe",
+		"LOAD",
+		"mHD",
+		"NhaNc3",
+		"nHD",
+		"NOIVTC",
+		"nSD",
+		"PiRaTeS",
+		"PRODJi",
+		"RAPiDCOWS",
+		"RARBG",
+		"RDN",
+		"REsuRRecTioN",
+		"RMTeam",
+		"SANTi",
+		"SicFoI",
+		"SPASM",
+		"STUTTERSHIT",
+		"Telly",
+		"TM",
+		"UPiNSMOKE",
+		"WAF",
+		"xRed",
+		"XS",
+		"YELLO",
+		"YIFY",
+		"YTS",
+		"ZKBL",
+		"ZmN",
+		"4f8c4100292",
+		"Azkars",
+		"Sync0rdi",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/otw/profile.go b/internal/trackers/impl/unit3d/sites/otw/profile.go
new file mode 100644
index 00000000..8b6302bb
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/otw/profile.go
@@ -0,0 +1,47 @@
+package otw
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns OTW's disc and DVDRip type mapping together with duplicate
+// resolution-mismatch rejection, rules, and banned groups.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "OTW",
+		BaseURL:      "https://oldtoons.world",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID: typeID,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			RejectEpisodeResolutionMismatch: true,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return "1"
+	}
+	if unit3d.IsDiscType(meta.DiscType) {
+		return "7"
+	}
+	typeValue := unit3d.InferType(meta)
+	if typeValue == "DVDRIP" {
+		return "8"
+	}
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+		"ENCODE": "3",
+	}[typeValue]
+}
diff --git a/internal/trackers/impl/unit3d/sites/otw/rules.go b/internal/trackers/impl/unit3d/sites/otw/rules.go
new file mode 100644
index 00000000..5e18a9f1
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/otw/rules.go
@@ -0,0 +1,53 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package otw
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules returns OTW's waivable genre, adult-content, reality-content, and
+// release-group restrictions.
+func Rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkGenres} }
+
+func checkGenres(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0, 3)
+	genres := unit3d.RuleGenres(meta)
+	if !unit3d.ContainsRuleValue(genres, []string{"animation", "family"}) {
+		failures = append(failures, trackers.NewRuleFailure("genre", "Genre does not match Animation or Family for OTW.", api.RuleDispositionWaivable))
+	}
+	if unit3d.AdultContent(meta) {
+		failures = append(failures, trackers.NewRuleFailure("block_adult", "Adult animation not allowed at OTW.", api.RuleDispositionWaivable))
+	}
+	if unit3d.ContainsRuleValue(genres, []string{"reality", "game show", "game-show", "reality tv", "reality television"}) {
+		failures = append(failures, trackers.NewRuleFailure("block_reality", "Reality / Game Show content not allowed at OTW.", api.RuleDispositionWaivable))
+	}
+	typeValue := unit3d.RuleType(meta)
+	group := unit3d.RuleGroup(meta)
+	if group != "" && typeValue != "WEBDL" && !unit3d.IsDiscType(meta.DiscType) {
+		restricted := map[string]bool{
+			"CMRG":     true,
+			"EVO":      true,
+			"TERMINAL": true,
+			"VISION":   true,
+		}
+		if restricted[strings.ToUpper(group)] {
+			failures = append(failures, trackers.NewRuleFailure(
+				"group_type",
+				fmt.Sprintf("Group %s is only allowed for raw type content at OTW", group),
+				api.RuleDispositionWaivable,
+			))
+		}
+	}
+	return failures, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/pt/profile.go b/internal/trackers/impl/unit3d/sites/pt/profile.go
new file mode 100644
index 00000000..d1e8a9cc
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/pt/profile.go
@@ -0,0 +1,82 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package pt
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns PT's type and resolution mappings and adds European
+// Portuguese audio and subtitle flags to the upload payload.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "PT",
+		BaseURL: "https://portugas.org",
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:          typeID,
+			ResolveResolutionID:    resolutionID,
+			ApplyAdditionalPayload: additionalPayload,
+		},
+	}
+}
+
+func additionalPayload(req trackers.PreparationInput, data map[string]string) {
+	data["audio_pt"] = boolString(hasEuropeanPortuguese(req.Meta.AudioLanguages))
+	data["legenda_pt"] = boolString(hasEuropeanPortuguese(req.Meta.SubtitleLanguages))
+}
+
+func boolString(value bool) string {
+	if value {
+		return "1"
+	}
+	return "0"
+}
+
+func hasEuropeanPortuguese(languages []string) bool {
+	for _, language := range languages {
+		lower := strings.ToLower(strings.TrimSpace(language))
+		if lower == "" || strings.Contains(lower, "brazil") || strings.Contains(lower, "brasil") || strings.Contains(lower, "pt-br") ||
+			strings.Contains(lower, "ptbr") {
+			continue
+		}
+		if strings.Contains(lower, "portuguese") || lower == "pt" || strings.Contains(lower, "português") {
+			return true
+		}
+	}
+	return false
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"WEBDL":  "4",
+		"WEBRIP": "39",
+		"HDTV":   "6",
+		"ENCODE": "3",
+	}[unit3d.InferType(meta)]
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1440p": "13",
+		"1080p": "3",
+		"1080i": "4",
+		"720p":  "5",
+		"576p":  "6",
+		"576i":  "7",
+		"540p":  "11",
+		"480p":  "8",
+		"480i":  "9",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/ptt/banned_groups.go b/internal/trackers/impl/unit3d/sites/ptt/banned_groups.go
new file mode 100644
index 00000000..f57c7a71
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ptt/banned_groups.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptt
+
+// BannedGroups returns PTT's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"ViP",
+		"BiRD",
+		"M@RTiNU$",
+		"inTGrity",
+		"CiNEMAET",
+		"MusicET",
+		"TeamET",
+		"R2D2",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ptt/profile.go b/internal/trackers/impl/unit3d/sites/ptt/profile.go
new file mode 100644
index 00000000..21a4a250
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ptt/profile.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ptt
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns PTT's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "PTT",
+		BaseURL:      "https://polishtorrent.top",
+		BannedGroups: BannedGroups(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/r4e/profile.go b/internal/trackers/impl/unit3d/sites/r4e/profile.go
new file mode 100644
index 00000000..e17ab90c
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/r4e/profile.go
@@ -0,0 +1,45 @@
+package r4e
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns R4E's category mapping, which separates movie and TV content
+// and assigns documentary categories from TMDB genre ID 99.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "R4E",
+		BaseURL: "https://racing4everyone.eu",
+		Site: unit3d.SiteProfile{
+			ResolveCategoryID: categoryID,
+		},
+	}
+}
+func categoryID(meta api.UploadSubject) string {
+	genreIDs := ""
+	if meta.ProviderMetadata.TMDB != nil {
+		genreIDs = meta.ProviderMetadata.TMDB.GenreIDs
+	}
+	isDoc := false
+	for value := range strings.SplitSeq(genreIDs, ",") {
+		if strings.TrimSpace(value) == "99" {
+			isDoc = true
+			break
+		}
+	}
+	switch {
+	case strings.EqualFold(unit3d.Category(meta), "MOVIE") && isDoc:
+		return "66"
+	case strings.EqualFold(unit3d.Category(meta), "MOVIE"):
+		return "70"
+	case strings.EqualFold(unit3d.Category(meta), "TV") && isDoc:
+		return "2"
+	case strings.EqualFold(unit3d.Category(meta), "TV"):
+		return "79"
+	default:
+		return "24"
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ras/banned_groups.go b/internal/trackers/impl/unit3d/sites/ras/banned_groups.go
new file mode 100644
index 00000000..c5d67dac
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ras/banned_groups.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ras
+
+// BannedGroups returns RAS's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"YTS",
+		"YiFY",
+		"LAMA",
+		"MeGUSTA",
+		"NAHOM",
+		"GalaxyRG",
+		"RARBG",
+		"INFINITY",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ras/profile.go b/internal/trackers/impl/unit3d/sites/ras/profile.go
new file mode 100644
index 00000000..c3fa3699
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ras/profile.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ras
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns RAS's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "RAS",
+		BaseURL:      "https://rastastugan.org",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ras/rules.go b/internal/trackers/impl/unit3d/sites/ras/rules.go
new file mode 100644
index 00000000..24ff59df
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ras/rules.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ras
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns RAS's strict Nordic-or-English audio-or-subtitle requirement.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{Language: &trackers.LanguageRule{
+		Languages:    []string{"english", "norwegian", "norsk", "no", "nb", "nn", "swedish", "sv", "danish", "da", "finnish", "fi", "icelandic", "is"},
+		RequireAudio: true,
+		RequireSubs:  true,
+	}}
+}
diff --git a/internal/trackers/impl/unit3d/sites/rf/profile.go b/internal/trackers/impl/unit3d/sites/rf/profile.go
new file mode 100644
index 00000000..74b1b92a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rf/profile.go
@@ -0,0 +1,83 @@
+package rf
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns RF's no-group naming, site-specific type and resolution
+// mappings, required release-group dupe policy, and conditional owned image host.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "RF",
+		BaseURL: "https://reelflix.cc",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			BuildName:           buildName,
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			RequireReleaseGroup: true,
+		},
+		ImageHost: &trackers.ImageHostPolicy{
+			ConditionalHost:      "reelflix",
+			OwnedHosts:           []string{"reelflix"},
+			EnableWhenConfigured: true,
+		},
+		TorrentIdentity: &trackers.TorrentIdentityPolicy{
+			TrackerURLPatterns: []string{"https://reelflix.xyz"},
+			CommentURLPatterns: []string{"https://reelflix.xyz"},
+			DetailIDPattern:    `(?i)reelflix\.(?:cc|xyz)/torrents/(\d+)`,
+		},
+	}
+}
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	return addNoGroup(meta, "NoGroup")
+}
+func addNoGroup(meta api.UploadSubject, suffix string) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	name = strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+	tag := strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-"))
+	if tag != "" && !strings.EqualFold(tag, "nogrp") && !strings.EqualFold(tag, "nogroup") && !strings.EqualFold(tag, "unknown") &&
+		!strings.EqualFold(tag, "-unk-") {
+		return name
+	}
+	if name == "" || strings.HasSuffix(strings.ToUpper(name), "-"+strings.ToUpper(suffix)) {
+		return name
+	}
+	return name + "-" + suffix
+}
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "43",
+		"REMUX":  "40",
+		"WEBDL":  "42",
+		"WEBRIP": "45",
+		"ENCODE": "41",
+		"HDTV":   "35",
+	}[unit3d.InferType(meta)]
+}
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1080p": "3",
+		"1080i": "4",
+		"720p":  "5",
+		"576p":  "6",
+		"576i":  "7",
+		"480p":  "8",
+		"480i":  "9",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
diff --git a/internal/trackers/impl/unit3d/sites/rf/rules.go b/internal/trackers/impl/unit3d/sites/rf/rules.go
new file mode 100644
index 00000000..cf91fafb
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rf/rules.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rf
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly rejects known non-movie categories; its adult-content failure
+// remains waivable.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:       true,
+		AdultMessage:     "Porn is not allowed",
+		RequireMovieOnly: true,
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/rhd/banned_groups.go b/internal/trackers/impl/unit3d/sites/rhd/banned_groups.go
new file mode 100644
index 00000000..a9fc05ec
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rhd/banned_groups.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rhd
+
+// BannedGroups returns RHD's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"1XBET",
+		"MEGA",
+		"MTZ",
+		"Whistler",
+		"WOTT",
+		"Taylor.D",
+		"HELD",
+		"FSX",
+		"FuN",
+		"MagicX",
+		"w00t",
+		"PaTroL",
+		"BB",
+		"266ers",
+		"GTF",
+		"JellyfinPlex",
+		"2BA",
+		"FritzBox",
+		"FUNXDTV",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/rhd/profile.go b/internal/trackers/impl/unit3d/sites/rhd/profile.go
new file mode 100644
index 00000000..f44a522b
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rhd/profile.go
@@ -0,0 +1,285 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rhd
+
+import (
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/language"
+	"golang.org/x/text/language/display"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	regradedRegex   = tokenRegex(`regraded`)
+	upscaleRegex    = tokenRegex(`upscaled?`, `upscl`, `upsuhd`)
+	internalRegex   = tokenRegex(`internal`)
+	incompleteRegex = tokenRegex(`incomplete`)
+	dubbedRegex     = tokenRegex(`dubbed`, `synced`, `ac3d`, `ld`, `line`, `mic`, `md`)
+)
+
+// Profile returns RHD's German-oriented release-name construction, resolution
+// mapping, tracker-owned rules, and banned groups.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "RHD",
+		BaseURL:      "https://rocket-hd.cc",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			BuildName:           buildName,
+			ResolveResolutionID: resolutionID,
+		},
+	}
+}
+
+func tokenRegex(tokens ...string) *regexp.Regexp {
+	return regexp.MustCompile(`(?i)(^|[^[:alnum:]])(?:` + strings.Join(tokens, "|") + `)([^[:alnum:]]|$)`)
+}
+
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1080p": "3",
+		"1080i": "4",
+		"720p":  "5",
+		"576p":  "12",
+		"576i":  "13",
+		"480p":  "11",
+		"480i":  "18",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "10"
+}
+
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	parts := make([]string, 0)
+	fullDisc := strings.EqualFold(strings.TrimSpace(meta.Type), "DISC") || unit3d.IsDiscType(meta.DiscType)
+	markers := markerText(meta)
+	title := ""
+	tmdb := meta.ProviderMetadata.TMDB
+	if tmdb != nil && tmdb.LocalizedTitles != nil {
+		title = strings.TrimSpace(tmdb.LocalizedTitles["de"])
+	}
+	if title == "" {
+		title = strings.TrimSpace(meta.Release.Title)
+	}
+	if title == "" && tmdb != nil {
+		title = strings.TrimSpace(tmdb.Title)
+	}
+	if title == "" && tmdb != nil {
+		title = strings.TrimSpace(tmdb.OriginalTitle)
+	}
+	if title != "" {
+		parts = append(parts, title)
+	}
+	year := meta.Release.Year
+	if year == 0 && tmdb != nil {
+		year = tmdb.Year
+	}
+	if year == 0 {
+		parts = append(parts, "0000")
+	} else {
+		parts = append(parts, strconv.Itoa(year))
+	}
+	if meta.SeasonStr != "" || meta.EpisodeStr != "" {
+		parts = append(parts, strings.TrimSpace(meta.SeasonStr+meta.EpisodeStr))
+		if incompleteRegex.MatchString(markers) {
+			parts = append(parts, "iNCOMPLETE")
+		}
+	}
+	if meta.Edition != "" {
+		parts = append(parts, meta.Edition)
+	}
+	if meta.Is3D != "" {
+		parts = append(parts, meta.Is3D)
+	}
+	if !fullDisc {
+		parts = append(parts, resolveLanguage(meta))
+	}
+	if meta.Repack != "" {
+		parts = append(parts, meta.Repack)
+	}
+	if meta.Release.Resolution != "" {
+		parts = append(parts, meta.Release.Resolution)
+		if regradedRegex.MatchString(markers) {
+			parts = append(parts, "REGRADED")
+		}
+		if upscaleRegex.MatchString(markers) {
+			parts = append(parts, "UPSCALE")
+		}
+	}
+	if strings.Contains(strings.ToUpper(meta.Type), "WEB") && meta.Service != "" {
+		parts = append(parts, meta.Service)
+	} else if meta.UHD != "" {
+		parts = append(parts, meta.UHD)
+	}
+	parts = append(parts, typeAndSource(meta)...)
+	if meta.Audio != "" {
+		parts = append(parts, meta.Audio)
+	}
+	if meta.Channels != "" && !strings.Contains(meta.Audio, meta.Channels) {
+		parts = append(parts, meta.Channels)
+	}
+	if meta.HDR != "" {
+		parts = append(parts, meta.HDR)
+	}
+	if meta.BitDepth != "" && meta.BitDepth != "8" && meta.BitDepth != "0" {
+		if strings.Contains(strings.ToLower(meta.BitDepth), "bit") {
+			parts = append(parts, meta.BitDepth)
+		} else {
+			parts = append(parts, meta.BitDepth+"bit")
+		}
+	}
+	codec := meta.VideoEncode
+	if codec == "" {
+		codec = meta.VideoCodec
+	}
+	if codec != "" {
+		parts = append(parts, codec)
+	}
+	if internalRegex.MatchString(markers) {
+		parts = append(parts, "iNTERNAL")
+	}
+	group := meta.Tag
+	if group == "" || unit3d.IsNoGroupTag(group) {
+		group = "NOGRP"
+	} else {
+		group = strings.TrimPrefix(group, "-")
+	}
+	return strings.Join(strings.Fields(strings.Join(parts, " ")), " ") + "-" + group
+}
+
+func typeAndSource(meta api.UploadSubject) []string {
+	parts := []string{}
+	name := strings.TrimSpace(meta.Type)
+	if name == "" && unit3d.IsDiscType(meta.DiscType) {
+		name = "DISC"
+	}
+	if name == "" {
+		return nil
+	}
+	switch strings.ToUpper(name) {
+	case "WEBDL":
+		name = "WEB-DL"
+	case "WEBRIP":
+		name = "WEBRip"
+	case "ENCODE":
+		if meta.Source != "" {
+			parts = append(parts, meta.Source)
+			name = ""
+		}
+	case "REMUX":
+		if meta.Source != "" {
+			parts = append(parts, meta.Source)
+		}
+	case "DISC":
+		parts = append(parts, "COMPLETE")
+		if meta.Region != "" {
+			parts = append(parts, meta.Region)
+		}
+		if meta.Release.Source != "" {
+			parts = append(parts, meta.Release.Source)
+		}
+		if meta.Release.Size != "" {
+			parts = append(parts, meta.Release.Size)
+		}
+		name = ""
+	}
+	if name != "" {
+		parts = append(parts, name)
+	}
+	return parts
+}
+
+func markerText(meta api.UploadSubject) string {
+	value, tag := strings.TrimSpace(meta.ReleaseName), strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
+	if value == "" || tag == "" {
+		return value
+	}
+	for _, suffix := range []string{"-" + tag, "." + tag, "_" + tag, " " + tag} {
+		if strings.HasSuffix(strings.ToLower(value), strings.ToLower(suffix)) {
+			return strings.TrimSpace(value[:len(value)-len(suffix)])
+		}
+	}
+	return value
+}
+
+func resolveLanguage(meta api.UploadSubject) string {
+	languages := normalizedAudioLanguages(meta.AudioLanguages)
+	german := slices.ContainsFunc(languages, isGerman)
+	var base string
+	switch {
+	case german:
+		base = "GERMAN"
+	case slices.ContainsFunc(meta.SubtitleLanguages, isGerman):
+		return "GERMAN SUBBED"
+	case len(languages) > 0:
+		base = languageName(languages[0])
+	default:
+		base = "ENGLISH"
+	}
+	if dubbedRegex.MatchString(markerText(meta)) {
+		base += " DUBBED"
+	}
+	if len(languages) == 2 {
+		return base + " DL"
+	}
+	if len(languages) > 2 {
+		return base + " ML"
+	}
+	return base
+}
+
+func normalizedAudioLanguages(values []string) []string {
+	out := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		tag, ok := unit3d.ParseLanguageTag(value)
+		if !ok {
+			continue
+		}
+		base, _ := tag.Base()
+		key := base.String()
+		if key == "" || key == "und" {
+			continue
+		}
+		if isGerman(key) {
+			key = "de"
+		}
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		out = append(out, key)
+	}
+	return out
+}
+func isGerman(value string) bool {
+	tag, ok := unit3d.ParseLanguageTag(value)
+	if !ok {
+		return slices.Contains([]string{"german", "ger", "de", "deu", "gsw"}, strings.ToLower(strings.TrimSpace(value)))
+	}
+	base, _ := tag.Base()
+	return base.String() == "de" || base.String() == "gsw"
+}
+func languageName(value string) string {
+	tag, ok := unit3d.ParseLanguageTag(value)
+	if !ok {
+		return strings.ToUpper(strings.TrimSpace(value))
+	}
+	name := display.Languages(language.English).Name(tag)
+	if name == "" {
+		return strings.ToUpper(strings.TrimSpace(value))
+	}
+	return strings.ToUpper(name)
+}
diff --git a/internal/trackers/impl/unit3d/sites/rhd/profile_test.go b/internal/trackers/impl/unit3d/sites/rhd/profile_test.go
new file mode 100644
index 00000000..4ff94648
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rhd/profile_test.go
@@ -0,0 +1,127 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rhd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestProfileNameParity(t *testing.T) {
+	build := Profile().Site.BuildName
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+		want string
+	}{
+		{
+			name: "localized web",
+			meta: api.UploadSubject{
+				Type:             "WEBDL",
+				Tag:              "-GRP",
+				Audio:            "DD+ 5.1",
+				VideoEncode:      "H.264",
+				AudioLanguages:   []string{"German"},
+				Release:          api.ReleaseInfo{Resolution: "1080p"},
+				ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Year: 2025, LocalizedTitles: map[string]string{"de": "Beispiel Film"}}},
+			},
+			want: "Beispiel Film 2025 GERMAN 1080p WEB-DL DD+ 5.1 H.264-GRP",
+		},
+		{
+			name: "full disc",
+			meta: api.UploadSubject{
+				Type:           "DISC",
+				Region:         "GER",
+				Tag:            "-GRP",
+				Audio:          "DTS-HD MA 5.1",
+				VideoCodec:     "AVC",
+				AudioLanguages: []string{"German", "English"},
+				Release: api.ReleaseInfo{
+					Title:      "Example Movie",
+					Year:       2024,
+					Resolution: "1080p",
+					Source:     "Blu-ray",
+					Size:       "BD50",
+				},
+			},
+			want: "Example Movie 2024 1080p COMPLETE GER Blu-ray BD50 DTS-HD MA 5.1 AVC-GRP",
+		},
+		{
+			name: "markers",
+			meta: api.UploadSubject{
+				ReleaseName:    "Example.Movie.2024.[INTERNAL].(UPSCALED).1080p.WEB-DL.DDP5.1.H.264-GRP",
+				Type:           "WEBDL",
+				Tag:            "-GRP",
+				Audio:          "DDP5.1",
+				VideoEncode:    "H.264",
+				AudioLanguages: []string{"German"},
+				Release: api.ReleaseInfo{
+					Title:      "Example Movie",
+					Year:       2024,
+					Resolution: "1080p",
+				},
+			},
+			want: "Example Movie 2024 GERMAN 1080p UPSCALE WEB-DL DDP5.1 H.264 iNTERNAL-GRP",
+		},
+		{
+			name: "hdr",
+			meta: api.UploadSubject{
+				Type:           "WEBDL",
+				Tag:            "-GRP",
+				Audio:          "DDP5.1",
+				HDR:            "DV HDR",
+				VideoEncode:    "H.265",
+				AudioLanguages: []string{"German"},
+				Release: api.ReleaseInfo{
+					Title:      "Example Movie",
+					Year:       2026,
+					Resolution: "2160p",
+				},
+			},
+			want: "Example Movie 2026 GERMAN 2160p WEB-DL DDP5.1 DV HDR H.265-GRP",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if got := build(test.meta, config.TrackerConfig{}); got != test.want {
+				t.Fatalf("name = %q, want %q", got, test.want)
+			}
+		})
+	}
+	ignored := build(api.UploadSubject{
+		ReleaseName:    "Example.Movie.2024.Regradedness.Internalized.Lineage.1080p.WEB-DL.DDP5.1.H.264-LD",
+		Type:           "WEBDL",
+		Tag:            "-LD",
+		Audio:          "DDP5.1",
+		VideoEncode:    "H.264",
+		AudioLanguages: []string{"English"},
+		Release: api.ReleaseInfo{
+			Title:      "Example Movie",
+			Year:       2024,
+			Resolution: "1080p",
+		},
+	}, config.TrackerConfig{})
+	for _, marker := range []string{"REGRADED", "UPSCALE", "iNTERNAL", "DUBBED"} {
+		if strings.Contains(ignored, marker) {
+			t.Fatalf("unexpected marker %s in %q", marker, ignored)
+		}
+	}
+}
+
+func TestProfileResolutionAndLanguages(t *testing.T) {
+	if got := Profile().Site.ResolveResolutionID(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "576p"}}); got != "12" {
+		t.Fatalf("resolution = %q", got)
+	}
+	for _, test := range []struct {
+		values []string
+		want   string
+	}{{[]string{"", "French", "   "}, "FRENCH"}, {[]string{"English", "eng", "English"}, "ENGLISH"}, {[]string{"German", "deu", "de-DE"}, "GERMAN"}, {[]string{"English", "French"}, "ENGLISH DL"}} {
+		if got := resolveLanguage(api.UploadSubject{AudioLanguages: test.values}); got != test.want {
+			t.Fatalf("language = %q, want %q", got, test.want)
+		}
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/rhd/rules.go b/internal/trackers/impl/unit3d/sites/rhd/rules.go
new file mode 100644
index 00000000..5a000ec6
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/rhd/rules.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package rhd
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly requires a known resolution of at least 720p and an NFO for
+// scene releases. Adult-content failures remain waivable; German-audio failures
+// are strict.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:      true,
+		MinResolution:   "720p",
+		Language:        &trackers.LanguageRule{Languages: []string{"german", "ger", "de", "deu", "gsw"}, RequireAudio: true},
+		RequireSceneNFO: true,
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/sam/profile.go b/internal/trackers/impl/unit3d/sites/sam/profile.go
new file mode 100644
index 00000000..bc07a2a4
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/sam/profile.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package sam
+
+import (
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns SAM's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "SAM",
+		BaseURL: "https://samaritano.cc",
+		Site: unit3d.SiteProfile{
+			BuildName: buildName,
+		},
+	}
+}
+func buildName(meta api.UploadSubject, cfg config.TrackerConfig) string {
+	return unit3d.FormatLocalizedName(meta, cfg.TagForCustomRelease)
+}
diff --git a/internal/trackers/impl/unit3d/sites/shri/profile.go b/internal/trackers/impl/unit3d/sites/shri/profile.go
new file mode 100644
index 00000000..8c1b3594
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/shri/profile.go
@@ -0,0 +1,85 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package shri
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns SHRI's type mapping, numeric region/distributor payload
+// fields, and idempotent Island-group description footer.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "SHRI",
+		BaseURL: "https://shareisland.org",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:          typeID,
+			ApplyAdditionalPayload: additionalPayload,
+			FinalizeDescription:    finalizeDescription,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "26",
+		"REMUX":  "7",
+		"WEBDL":  "27",
+		"WEBRIP": "15",
+		"HDTV":   "33",
+		"ENCODE": "15",
+		"DVDRIP": "15",
+	}[unit3d.InferType(meta)]
+}
+
+func additionalPayload(req trackers.PreparationInput, data map[string]string) {
+	if value := numericValue(req.Meta.Region); value != "" {
+		data["region_id"] = value
+	}
+	if value := numericValue(req.Meta.Distributor); value != "" {
+		data["distributor_id"] = value
+	}
+}
+
+func finalizeDescription(description string, meta api.UploadSubject) string {
+	if !strings.EqualFold(releaseGroup(meta), "island") {
+		return description
+	}
+	const notes = "Release Shareisland 🏴‍☠️\nFalla girare, condividila e contribuisci a mantenerla viva restando in seed il più possi" + "bile.\nGrazie per il supporto!"
+	trimmed := strings.TrimSpace(description)
+	if strings.Contains(trimmed, notes) {
+		return trimmed
+	}
+	if trimmed == "" {
+		return notes
+	}
+	return trimmed + "\n\n" + notes
+}
+
+func releaseGroup(meta api.UploadSubject) string {
+	for _, value := range []string{meta.Release.Group, meta.ArrReleaseGroup, strings.TrimPrefix(meta.Tag, "-")} {
+		if trimmed := strings.TrimSpace(value); trimmed != "" {
+			return trimmed
+		}
+	}
+	return ""
+}
+
+func numericValue(value string) string {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return ""
+	}
+	for _, r := range trimmed {
+		if r < '0' || r > '9' {
+			return ""
+		}
+	}
+	return trimmed
+}
diff --git a/internal/trackers/impl/unit3d/sites/shri/rules.go b/internal/trackers/impl/unit3d/sites/shri/rules.go
new file mode 100644
index 00000000..e0c6bc4c
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/shri/rules.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package shri
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules strictly requires a region for DVD and HDDVD uploads.
+func Rules() *trackers.RuleSet { return &trackers.RuleSet{Check: checkRegion} }
+
+func checkRegion(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	if !strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") && !strings.EqualFold(strings.TrimSpace(meta.DiscType), "HDDVD") {
+		return nil, nil
+	}
+	if strings.TrimSpace(meta.Region) == "" {
+		return []api.RuleFailure{trackers.NewRuleFailure("region_required", "Region required; skipping SHRI.", api.RuleDispositionStrict)}, nil
+	}
+	return nil, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/sp/profile.go b/internal/trackers/impl/unit3d/sites/sp/profile.go
new file mode 100644
index 00000000..eeccc496
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/sp/profile.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package sp
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns SP's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "SP",
+		BaseURL: "https://seedpool.org",
+		Rules:   Rules(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/sp/rules.go b/internal/trackers/impl/unit3d/sites/sp/rules.go
new file mode 100644
index 00000000..ac6d48a5
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/sp/rules.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package sp
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly requires a known resolution of at least 1080p; its
+// adult-content failure remains waivable.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:    true,
+		AdultMessage:  "Porn is not allowed",
+		MinResolution: "1080p",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/stc/profile.go b/internal/trackers/impl/unit3d/sites/stc/profile.go
new file mode 100644
index 00000000..b414f04a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/stc/profile.go
@@ -0,0 +1,49 @@
+package stc
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns STC's type mapping, including dedicated TV-pack IDs split by
+// web source and SD status, plus its image-host and rule policies.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "STC",
+		BaseURL: "https://skipthecommercials.xyz",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID: typeID,
+		},
+		ImageHost: &trackers.ImageHostPolicy{
+			AllowedHosts: []string{"imgbox", "imgbb"},
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	typeValue := unit3d.InferType(meta)
+	if meta.TVPack {
+		isWeb := typeValue == "WEBDL" || typeValue == "WEBRIP"
+		sd := unit3d.IsSDResolution(unit3d.Resolution(meta))
+		if sd && isWeb {
+			return "14"
+		}
+		if sd {
+			return "17"
+		}
+		if isWeb {
+			return "13"
+		}
+		return "18"
+	}
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+		"ENCODE": "3",
+	}[typeValue]
+}
diff --git a/internal/trackers/impl/unit3d/sites/stc/rules.go b/internal/trackers/impl/unit3d/sites/stc/rules.go
new file mode 100644
index 00000000..fa28a20a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/stc/rules.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package stc
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly rejects known non-TV categories; its adult-content failure
+// remains waivable.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		BlockAdult:    true,
+		AdultMessage:  "Porn is not allowed",
+		RequireTVOnly: true,
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/tik/profile.go b/internal/trackers/impl/unit3d/sites/tik/profile.go
new file mode 100644
index 00000000..1182d90d
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tik/profile.go
@@ -0,0 +1,173 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tik
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns TIK's disc-type and category mappings, honoring explicit
+// tracker-site overrides before metadata-derived classification.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "TIK",
+		BaseURL: "https://cinematik.net",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:     typeID,
+			ResolveCategoryID: categoryID,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"CUSTOM":    "1",
+		"BD100":     "3",
+		"BD66":      "4",
+		"BD50":      "5",
+		"BD25":      "6",
+		"NTSC DVD9": "7",
+		"NTSC DVD5": "8",
+		"PAL DVD9":  "9",
+		"PAL DVD5":  "10",
+		"3D":        "11",
+	}[discType(meta)]
+}
+
+func discType(meta api.UploadSubject) string {
+	if meta.TrackerSiteOverrides.TIK.DiscType != nil {
+		return strings.ToUpper(strings.TrimSpace(*meta.TrackerSiteOverrides.TIK.DiscType))
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
+		return "3D"
+	}
+	releaseName := strings.ToUpper(strings.TrimSpace(meta.ReleaseName))
+	source := strings.ToUpper(strings.TrimSpace(meta.Source))
+	if source == "" {
+		source = strings.ToUpper(strings.TrimSpace(meta.Release.Source))
+	}
+	combined := releaseName + " " + source
+	for _, marker := range []string{"BD100", "BD66", "BD50", "BD25"} {
+		if strings.Contains(combined, marker) {
+			return marker
+		}
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || strings.Contains(combined, "DVD") {
+		if strings.Contains(combined, "PAL") {
+			if strings.Contains(combined, "DVD5") {
+				return "PAL DVD5"
+			}
+			return "PAL DVD9"
+		}
+		if strings.Contains(combined, "NTSC") {
+			if strings.Contains(combined, "DVD5") {
+				return "NTSC DVD5"
+			}
+			return "NTSC DVD9"
+		}
+		if strings.Contains(combined, "DVD5") {
+			return "NTSC DVD5"
+		}
+		return "NTSC DVD9"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
+		return "CUSTOM"
+	}
+	return ""
+}
+
+func categoryID(meta api.UploadSubject) string {
+	category := unit3d.Category(meta)
+	foreign, opera, asian := isForeign(meta), isOpera(meta), isAsian(meta)
+	if strings.EqualFold(category, "MOVIE") {
+		switch {
+		case foreign:
+			return "3"
+		case opera:
+			return "5"
+		case asian:
+			return "6"
+		default:
+			return "1"
+		}
+	}
+	if strings.EqualFold(category, "TV") {
+		switch {
+		case foreign:
+			return "4"
+		case opera:
+			return "5"
+		default:
+			return "2"
+		}
+	}
+	return unit3d.DefaultCategoryID(meta)
+}
+
+func isForeign(meta api.UploadSubject) bool {
+	if meta.TrackerSiteOverrides.TIK.Foreign != nil {
+		return *meta.TrackerSiteOverrides.TIK.Foreign
+	}
+	if meta.ProviderMetadata.TMDB != nil {
+		original := strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage))
+		if original != "" && original != "en" {
+			return true
+		}
+	}
+	return !unit3d.HasEnglishLanguage(meta.AudioLanguages) && !unit3d.HasEnglishLanguage(meta.SubtitleLanguages)
+}
+
+func isOpera(meta api.UploadSubject) bool {
+	if meta.TrackerSiteOverrides.TIK.Opera != nil {
+		return *meta.TrackerSiteOverrides.TIK.Opera
+	}
+	values := strings.ToLower(
+		strings.Join([]string{strings.TrimSpace(meta.Release.Genre), unit3d.TMDBGenres(meta), unit3d.IMDBGenres(meta), unit3d.Keywords(meta)}, ","),
+	)
+	return strings.Contains(values, "opera") || strings.Contains(values, "musical")
+}
+
+func isAsian(meta api.UploadSubject) bool {
+	if meta.TrackerSiteOverrides.TIK.Asian != nil {
+		return *meta.TrackerSiteOverrides.TIK.Asian
+	}
+	if meta.ProviderMetadata.TMDB == nil {
+		return false
+	}
+	for _, country := range meta.ProviderMetadata.TMDB.OriginCountry {
+		if map[string]bool{
+			"JP": true,
+			"KR": true,
+			"CN": true,
+			"HK": true,
+			"TW": true,
+			"TH": true,
+			"VN": true,
+			"IN": true,
+			"ID": true,
+			"MY": true,
+			"PH": true,
+			"SG": true,
+		}[strings.ToUpper(strings.TrimSpace(country))] {
+			return true
+		}
+	}
+	return map[string]bool{
+		"ja": true,
+		"ko": true,
+		"zh": true,
+		"th": true,
+		"vi": true,
+		"hi": true,
+		"ta": true,
+		"te": true,
+		"ml": true,
+		"id": true,
+		"ms": true,
+	}[strings.ToLower(strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage))]
+}
diff --git a/internal/trackers/impl/unit3d/sites/tik/profile_test.go b/internal/trackers/impl/unit3d/sites/tik/profile_test.go
new file mode 100644
index 00000000..877c207a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tik/profile_test.go
@@ -0,0 +1,43 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tik
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestProfileResolvers(t *testing.T) {
+	profile := Profile().Site
+	if got := profile.ResolveTypeID(api.UploadSubject{ReleaseName: "Example.Release.2026.BD50.COMPLETE-GRP", DiscType: "BDMV"}); got != "5" {
+		t.Fatalf("BD50 type = %q", got)
+	}
+	disc := "BD66"
+	if got := profile.ResolveTypeID(api.UploadSubject{TrackerSiteOverrides: api.TrackerSiteOverrides{TIK: api.TIKOverrides{DiscType: &disc}}}); got != "4" {
+		t.Fatalf("override type = %q", got)
+	}
+	foreign := api.UploadSubject{Identity: api.ExternalIdentity{Category: "MOVIE"}, ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{OriginalLanguage: "fr"}}}
+	if got := profile.ResolveCategoryID(foreign); got != "3" {
+		t.Fatalf("foreign category = %q", got)
+	}
+	asian := api.UploadSubject{
+		Identity:          api.ExternalIdentity{Category: "MOVIE"},
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		ProviderMetadata:  api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{OriginalLanguage: "en", OriginCountry: []string{"JP"}}},
+	}
+	if got := profile.ResolveCategoryID(asian); got != "6" {
+		t.Fatalf("Asian category = %q", got)
+	}
+	opera := api.UploadSubject{
+		Identity:          api.ExternalIdentity{Category: "TV"},
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		Release:           api.ReleaseInfo{Genre: "Opera"},
+	}
+	if got := profile.ResolveCategoryID(opera); got != "5" {
+		t.Fatalf("opera category = %q", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/tik/rules.go b/internal/trackers/impl/unit3d/sites/tik/rules.go
new file mode 100644
index 00000000..490cdb9d
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tik/rules.go
@@ -0,0 +1,9 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tik
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly permits disc uploads only.
+func Rules() *trackers.RuleSet { return &trackers.RuleSet{RequireDiscOnly: true} }
diff --git a/internal/trackers/impl/unit3d/sites/tlz/profile.go b/internal/trackers/impl/unit3d/sites/tlz/profile.go
new file mode 100644
index 00000000..bc9807f6
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tlz/profile.go
@@ -0,0 +1,30 @@
+package tlz
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns TLZ's distinct type IDs for movies, packs, and remaining
+// content.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "TLZ",
+		BaseURL: "https://tlzdigital.com",
+		Site: unit3d.SiteProfile{
+			ResolveTypeID: typeID,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	if strings.EqualFold(unit3d.Category(meta), "MOVIE") {
+		return "1"
+	}
+	if meta.TVPack {
+		return "4"
+	}
+	return "3"
+}
diff --git a/internal/trackers/impl/unit3d/sites/tos/banned_groups.go b/internal/trackers/impl/unit3d/sites/tos/banned_groups.go
new file mode 100644
index 00000000..462c56d2
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tos/banned_groups.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tos
+
+// BannedGroups returns TOS's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"FL3ER",
+		"SUNS3T",
+		"WoLFHD",
+		"EXTREME",
+		"Slay3R",
+		"3T3AM",
+		"BARBiE",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/tos/profile.go b/internal/trackers/impl/unit3d/sites/tos/profile.go
new file mode 100644
index 00000000..9e0af311
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tos/profile.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tos
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns TOS's DVD/3D type mapping and French-subtitle-aware movie,
+// episode, and TV-pack category mapping.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "TOS",
+		BaseURL:      "https://theoldschool.cc",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		UploadArtifact: &trackers.UploadArtifactPolicy{
+			Source: "TheOldSchool",
+		},
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:     typeID,
+			ResolveCategoryID: categoryID,
+		},
+	}
+}
+
+func categoryID(meta api.UploadSubject) string {
+	tag := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-")))
+	subFrench := strings.Contains(tag, "vostfr") || strings.Contains(tag, "subfrench")
+	if strings.EqualFold(unit3d.Category(meta), "TV") {
+		if meta.TVPack {
+			if subFrench {
+				return "9"
+			}
+			return "8"
+		}
+		if subFrench {
+			return "7"
+		}
+		return "2"
+	}
+	if subFrench {
+		return "6"
+	}
+	return "1"
+}
+
+func typeID(meta api.UploadSubject) string {
+	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
+		return "7"
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
+		return "8"
+	}
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"ENCODE": "3",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+	}[unit3d.InferType(meta)]
+}
diff --git a/internal/trackers/impl/unit3d/sites/tos/rules.go b/internal/trackers/impl/unit3d/sites/tos/rules.go
new file mode 100644
index 00000000..f6f46dfc
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/tos/rules.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package tos
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules strictly requires an NFO for scene releases and applies a strict
+// French audio-or-subtitle requirement that accepts original-language audio
+// when French subtitles are present.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{Language: &trackers.LanguageRule{
+		Languages:     []string{"french", "fr", "fra", "fre"},
+		RequireAudio:  true,
+		RequireSubs:   true,
+		AllowOriginal: true,
+	}, RequireSceneNFO: true}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ttr/profile.go b/internal/trackers/impl/unit3d/sites/ttr/profile.go
new file mode 100644
index 00000000..eb60cc7a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ttr/profile.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ttr
+
+import "github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+
+// Profile returns TTR's Unit3D site manifest.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "TTR",
+		BaseURL: "https://torrenteros.org",
+		Rules:   Rules(),
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ttr/rules.go b/internal/trackers/impl/unit3d/sites/ttr/rules.go
new file mode 100644
index 00000000..e7b9cf82
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ttr/rules.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ttr
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules returns TTR's strict Spanish audio-or-subtitle requirements.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{Language: &trackers.LanguageRule{
+		Languages:    []string{"spanish", "es", "spa"},
+		RequireAudio: true,
+		RequireSubs:  true,
+	}, Check: checkSubtitleOnly}
+}
+
+func checkSubtitleOnly(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	if !unit3d.ContainsRuleValue(unit3d.NormalizeRuleValues(meta.Release.Language), []string{"spanish", "es", "spa"}) {
+		return []api.RuleFailure{trackers.NewRuleFailure(
+			"spanish_track_required",
+			"TTR requires at least one Spanish audio or subtitle track.",
+			api.RuleDispositionStrict,
+		)}, nil
+	}
+	return nil, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/ulcx/banned_groups.go b/internal/trackers/impl/unit3d/sites/ulcx/banned_groups.go
new file mode 100644
index 00000000..96568bde
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ulcx/banned_groups.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ulcx
+
+// BannedGroups returns ULCX's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"4K4U",
+		"AROMA",
+		"d3g",
+		"EDGE2020",
+		"EMBER",
+		"FGT",
+		"FnP",
+		"FRDS",
+		"Grym",
+		"Hi10",
+		"iAHD",
+		"INFINITY",
+		"ION10",
+		"iVy",
+		"Judas",
+		"LAMA",
+		"MeGusta",
+		"NAHOM",
+		"Niblets",
+		"nikt0",
+		"NuBz",
+		"OFT",
+		"QxR",
+		"Ralphy",
+		"RARBG",
+		"Sicario",
+		"SM737",
+		"SPDVD",
+		"SWTYBLZ",
+		"TAoE",
+		"TGx",
+		"Tigole",
+		"TSP",
+		"TSPxL",
+		"VXT",
+		"Vyndros",
+		"Will1869",
+		"x0r",
+		"YIFY",
+		"Alcaide_Kira",
+		"PHOCiS",
+		"HDT",
+		"SPx",
+		"seedpool",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ulcx/profile.go b/internal/trackers/impl/unit3d/sites/ulcx/profile.go
new file mode 100644
index 00000000..d65c4dc4
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ulcx/profile.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ulcx
+
+import (
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns ULCX's WEB-DL hybrid-name normalization, size-variance dupe
+// policy, tracker-owned rules, and banned groups.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "ULCX",
+		BaseURL:      "https://upload.cx",
+		Rules:        Rules(),
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			BuildName: buildName,
+		},
+		DupePolicy: &trackers.DupePolicy{
+			AllowSizeVariance1080: true,
+		},
+	}
+}
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	if strings.EqualFold(strings.TrimSpace(meta.Type), "WEBDL") &&
+		(strings.Contains(strings.ToLower(strings.TrimSpace(meta.Edition)), "hybrid") || meta.WebDV) {
+		name = strings.Replace(name, "Hybrid ", "", 1)
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
diff --git a/internal/trackers/impl/unit3d/sites/ulcx/profile_test.go b/internal/trackers/impl/unit3d/sites/ulcx/profile_test.go
new file mode 100644
index 00000000..6590c4e6
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ulcx/profile_test.go
@@ -0,0 +1,21 @@
+package ulcx
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildNameRemovesHybridFromWebDV(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "Example Release 2026 Hybrid 1080p WEB-DL DDP5.1 DV H.265-GRP",
+		Type:        "WEBDL",
+		Edition:     "Hybrid",
+		WebDV:       true,
+	}
+	if got := Profile().Site.BuildName(meta, config.TrackerConfig{}); strings.Contains(got, "Hybrid") {
+		t.Fatalf("name = %q", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/ulcx/rules.go b/internal/trackers/impl/unit3d/sites/ulcx/rules.go
new file mode 100644
index 00000000..127dae7a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/ulcx/rules.go
@@ -0,0 +1,61 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package ulcx
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Rules strictly enforces valid MediaInfo settings, the DVDRip prohibition,
+// HEVC eligibility, encode/HDTV resolution, and language requirements. Concert
+// failures remain waivable.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{
+		RequireValidMISetting: true,
+		BlockDVDRip:           true,
+		Language: &trackers.LanguageRule{
+			Languages:      []string{"english", "en", "eng"},
+			RequireAudio:   true,
+			RequireSubs:    true,
+			ApplyIfNonDisc: true,
+		},
+		Check: checkRules,
+	}
+}
+
+func checkRules(ctx context.Context, meta api.RuleSubject, _ api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := make([]api.RuleFailure, 0, 3)
+	if unit3d.ContainsRuleValue(unit3d.RuleKeywords(meta), []string{"concert"}) {
+		failures = append(failures, trackers.NewRuleFailure("block_concert", "Concerts not allowed at ULCX.", api.RuleDispositionWaivable))
+	}
+	resolution := unit3d.RuleResolution(meta)
+	if strings.EqualFold(strings.TrimSpace(meta.VideoCodec), "HEVC") && resolution != "2160p" && !unit3d.Animation(meta) && !unit3d.Anime(meta) {
+		failures = append(failures, trackers.NewRuleFailure(
+			"hevc_resolution_2160p",
+			"This content might not fit HEVC rules for ULCX.",
+			api.RuleDispositionStrict,
+		))
+	}
+	typeValue := unit3d.RuleType(meta)
+	if (typeValue == "ENCODE" || typeValue == "HDTV") && unit3d.ResolutionBelow(resolution, "720p") {
+		failures = append(failures, trackers.NewRuleFailure(
+			"encode_min_resolution",
+			"Encodes must be at least 720p resolution for ULCX.",
+			api.RuleDispositionStrict,
+		))
+	}
+	if typeValue == "DVDRIP" {
+		failures = append(failures, trackers.NewRuleFailure("block_dvdrip", "DVDRIPs are not allowed for ULCX.", api.RuleDispositionWaivable))
+	}
+	return failures, nil
+}
diff --git a/internal/trackers/impl/unit3d/sites/utp/profile.go b/internal/trackers/impl/unit3d/sites/utp/profile.go
new file mode 100644
index 00000000..90391758
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/utp/profile.go
@@ -0,0 +1,44 @@
+package utp
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns UTP's type and resolution mappings, including fallback IDs
+// for unknown values.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "UTP",
+		BaseURL: "https://utp.to",
+		Site: unit3d.SiteProfile{
+			ResolveTypeID:       typeID,
+			ResolveResolutionID: resolutionID,
+		},
+	}
+}
+func typeID(meta api.UploadSubject) string {
+	value := map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"ENCODE": "3",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+	}[unit3d.InferType(meta)]
+	if value == "" {
+		return "3"
+	}
+	return value
+}
+func resolutionID(meta api.UploadSubject) string {
+	if value, ok := map[string]string{
+		"4320p": "1",
+		"2160p": "2",
+		"1080p": "3",
+		"1080i": "4",
+	}[unit3d.Resolution(meta)]; ok {
+		return value
+	}
+	return "11"
+}
diff --git a/internal/trackers/impl/unit3d/sites/yus/banned_groups.go b/internal/trackers/impl/unit3d/sites/yus/banned_groups.go
new file mode 100644
index 00000000..b43553b8
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/yus/banned_groups.go
@@ -0,0 +1,56 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package yus
+
+// BannedGroups returns YUS's static release-group blacklist.
+func BannedGroups() []string {
+	return []string{
+		"ADDICTION",
+		"B3LLUM",
+		"BANDOLEROS",
+		"BigEasy",
+		"CINEMAXIS",
+		"D3US",
+		"d3g",
+		"DUMMESCHWEDEN",
+		"FGT",
+		"GRANiTEN",
+		"KiNGDOM",
+		"Lama",
+		"MeGusta",
+		"MezRips",
+		"mHD",
+		"mRS",
+		"msd",
+		"NeXus",
+		"NhaNc3",
+		"nHD",
+		"NorTekst",
+		"NORViNE",
+		"PANDEMONiUM",
+		"PiTBULL",
+		"RAPiDCOWS",
+		"RARBG",
+		"Radarr",
+		"RCDiVX",
+		"RDN",
+		"ROCKETRACCOON",
+		"SANTi",
+		"SHOWTiME",
+		"SOOSi",
+		"SUXWIC",
+		"TOXVIO",
+		"TWA",
+		"VXT",
+		"Will1869",
+		"x0r",
+		"XS",
+		"YIFY",
+		"YOLAND",
+		"YTS",
+		"ZKBL",
+		"ZmN",
+		"ZMNT",
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/yus/profile.go b/internal/trackers/impl/unit3d/sites/yus/profile.go
new file mode 100644
index 00000000..0c8e6605
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/yus/profile.go
@@ -0,0 +1,28 @@
+package yus
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns YUS's site-specific type mapping and banned groups.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:         "YUS",
+		BaseURL:      "https://yu-scene.net",
+		BannedGroups: BannedGroups(),
+		Site: unit3d.SiteProfile{
+			ResolveTypeID: typeID,
+		},
+	}
+}
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "17",
+		"REMUX":  "2",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+		"ENCODE": "3",
+	}[unit3d.InferType(meta)]
+}
diff --git a/internal/trackers/impl/unit3d/sites/znth/name.go b/internal/trackers/impl/unit3d/sites/znth/name.go
new file mode 100644
index 00000000..941f697a
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/znth/name.go
@@ -0,0 +1,225 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package znth
+
+import (
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// buildZNTHName applies ZNTH release-name policy before upload.
+// TV names drop episode-title text when it appears before the resolution, while
+// non-TV names prefer the IMDb year when it disagrees with the parsed release year.
+func buildName(meta api.UploadSubject, _ config.TrackerConfig) string {
+	name := strings.TrimSpace(meta.ReleaseName)
+	if name == "" {
+		name = strings.TrimSpace(meta.ReleaseNameNoTag)
+	}
+	category := unit3d.Category(meta)
+	if category == "TV" && strings.TrimSpace(meta.EpisodeTitle) != "" {
+		resolution := unit3d.Resolution(meta)
+		if resolution != "" {
+			name = replaceZNTHEpisodeTitle(name, meta.EpisodeTitle, resolution)
+		}
+	}
+
+	if category == "MOVIE" {
+		imdbYear := 0
+		if meta.ProviderMetadata.IMDB != nil {
+			imdbYear = meta.ProviderMetadata.IMDB.Year
+		}
+		year := meta.Release.Year
+		if imdbYear > 0 && year > 0 && imdbYear != year {
+			name = replaceZNTHMovieYear(name, meta, year, imdbYear)
+		}
+	}
+	return strings.TrimSpace(strings.Join(strings.Fields(name), " "))
+}
+
+// replaceZNTHEpisodeTitle removes the episode-title segment only when its
+// normalized text appears immediately before a matching resolution token.
+func replaceZNTHEpisodeTitle(name string, episodeTitle string, resolution string) string {
+	normalizedTitle := normalizeZNTHAlphaNum(episodeTitle)
+	if normalizedTitle == "" {
+		return name
+	}
+
+	for _, resolutionStart := range findZNTHTokenIndexes(name, resolution) {
+		titleStart, ok := findZNTHTitleStartBefore(name[:resolutionStart], normalizedTitle)
+		if !ok {
+			continue
+		}
+		return name[:titleStart] + name[resolutionStart:]
+	}
+	return name
+}
+
+// findZNTHTitleStartBefore returns the byte offset of the trailing segment in
+// prefix whose alphanumeric-normalized text matches normalizedTitle.
+func findZNTHTitleStartBefore(prefix string, normalizedTitle string) (int, bool) {
+	candidates := []int{0}
+	for i, r := range prefix {
+		if !isZNTHAlphaNum(r) {
+			candidates = append(candidates, i+len(string(r)))
+		}
+	}
+
+	for i := len(candidates) - 1; i >= 0; i-- {
+		start := candidates[i]
+		if normalizeZNTHAlphaNum(prefix[start:]) == normalizedTitle {
+			return start, true
+		}
+	}
+	return 0, false
+}
+
+// replaceZNTHMovieYear replaces the parsed release-year token before the first
+// matching resolution token, or before a trailing metadata release-group suffix
+// when no resolution is known.
+func replaceZNTHMovieYear(name string, meta api.UploadSubject, year int, imdbYear int) string {
+	yearToken := strconv.Itoa(year)
+	yearIndexes := findZNTHTokenIndexes(name, yearToken)
+	if len(yearIndexes) == 0 {
+		return name
+	}
+
+	searchEnd := len(name)
+	if resolution := unit3d.Resolution(meta); resolution != "" {
+		resolutionIndexes := findZNTHTokenIndexes(name, resolution)
+		if len(resolutionIndexes) > 0 {
+			searchEnd = resolutionIndexes[0]
+		}
+	} else if groupStart, ok := findZNTHReleaseGroupStart(name, meta.Release.Group); ok {
+		searchEnd = groupStart
+	}
+
+	replaceStart := -1
+	for _, yearStart := range yearIndexes {
+		if yearStart < searchEnd {
+			replaceStart = yearStart
+		}
+	}
+	if replaceStart == -1 {
+		return name
+	}
+
+	replacement := strconv.Itoa(imdbYear)
+	return name[:replaceStart] + replacement + name[replaceStart+len(yearToken):]
+}
+
+// findZNTHTokenIndexes returns original-string byte offsets for
+// case-insensitive token matches bounded by non-alphanumeric ZNTH separators.
+func findZNTHTokenIndexes(value string, token string) []int {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return nil
+	}
+
+	tokenRunes := utf8.RuneCountInString(token)
+	indexes := []int{}
+	for start := range value {
+		end, ok := endAfterZNTHRunes(value, start, tokenRunes)
+		if !ok {
+			break
+		}
+		if strings.EqualFold(value[start:end], token) && hasZNTHTokenBoundaries(value, start, end) {
+			indexes = append(indexes, start)
+		}
+	}
+	return indexes
+}
+
+// findZNTHReleaseGroupStart returns the byte offset of a trailing "-group"
+// suffix only when group is a real parsed release group.
+func findZNTHReleaseGroupStart(name string, group string) (int, bool) {
+	group = strings.TrimSpace(group)
+	if group == "" || unit3d.IsNoGroupTag(group) {
+		return 0, false
+	}
+
+	trimmedName := strings.TrimRightFunc(name, unicode.IsSpace)
+	groupStart, ok := foldSuffixStart(trimmedName, group)
+	if !ok {
+		return 0, false
+	}
+
+	boundary := groupStart
+	for boundary > 0 {
+		r, size := utf8.DecodeLastRuneInString(trimmedName[:boundary])
+		if !unicode.IsSpace(r) {
+			break
+		}
+		boundary -= size
+	}
+	if boundary > 0 && trimmedName[boundary-1] == '-' {
+		return boundary - 1, true
+	}
+	return 0, false
+}
+
+// foldSuffixStart returns the byte offset where suffix starts when value ends
+// with suffix under Unicode case folding.
+func foldSuffixStart(value string, suffix string) (int, bool) {
+	start := len(value)
+	for range suffix {
+		if start == 0 {
+			return 0, false
+		}
+		_, size := utf8.DecodeLastRuneInString(value[:start])
+		start -= size
+	}
+	return start, strings.EqualFold(value[start:], suffix)
+}
+
+// endAfterZNTHRunes returns the byte offset after count runes from start.
+func endAfterZNTHRunes(value string, start int, count int) (int, bool) {
+	end := start
+	for range count {
+		if end >= len(value) {
+			return 0, false
+		}
+		_, size := utf8.DecodeRuneInString(value[end:])
+		end += size
+	}
+	return end, true
+}
+
+// hasZNTHTokenBoundaries reports whether start and end are outside adjacent
+// letters or digits in value.
+func hasZNTHTokenBoundaries(value string, start int, end int) bool {
+	if start > 0 {
+		r, _ := utf8.DecodeLastRuneInString(value[:start])
+		if isZNTHAlphaNum(r) {
+			return false
+		}
+	}
+	if end < len(value) {
+		r, _ := utf8.DecodeRuneInString(value[end:])
+		if isZNTHAlphaNum(r) {
+			return false
+		}
+	}
+	return true
+}
+
+// normalizeZNTHAlphaNum lowercases value and drops every non-alphanumeric rune.
+func normalizeZNTHAlphaNum(value string) string {
+	var b strings.Builder
+	for _, r := range value {
+		if isZNTHAlphaNum(r) {
+			b.WriteRune(unicode.ToLower(r))
+		}
+	}
+	return b.String()
+}
+
+func isZNTHAlphaNum(r rune) bool {
+	return unicode.IsLetter(r) || unicode.IsDigit(r)
+}
diff --git a/internal/trackers/impl/unit3d/sites/znth/name_test.go b/internal/trackers/impl/unit3d/sites/znth/name_test.go
new file mode 100644
index 00000000..f03def17
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/znth/name_test.go
@@ -0,0 +1,235 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package znth
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestBuildZNTHNameTV(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName:  "Show.S01E01.Episode.Title.1080p.WEB-DL-GRP",
+		EpisodeTitle: "Episode Title",
+		Identity:     api.ExternalIdentity{Category: "TV"},
+		Release:      api.ReleaseInfo{Resolution: "1080p"},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Show.S01E01.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameMovieYearMismatch(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "Movie.2024.1080p.WEB-DL-GRP",
+		Release:     api.ReleaseInfo{Year: 2024},
+		Identity:    api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Movie.2025.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameBlankCategoryDoesNotInferTVCategory(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName:  "Show.1x01.Episode.Title.1080p.WEB-DL-GRP",
+		EpisodeTitle: "Episode Title",
+		SeasonInt:    1,
+		EpisodeInt:   1,
+		Release: api.ReleaseInfo{
+			Category:   "TV",
+			Resolution: "1080p",
+		},
+	}
+
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Show.1x01.Episode.Title.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameUnknownCategoryDoesNotInferTVCategory(t *testing.T) {
+	tests := []struct {
+		name string
+		meta api.UploadSubject
+	}{
+		{
+			name: "external unknown",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "animation"},
+			},
+		},
+		{
+			name: "identity absent",
+			meta: api.UploadSubject{},
+		},
+		{
+			name: "external unknown ignores release tv",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "animation"},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		tc.meta.ReleaseName = "Show.S01E01.2024.Episode.Title.1080p.WEB-DL-GRP"
+		tc.meta.EpisodeTitle = "Episode Title"
+		tc.meta.SeasonInt = 1
+		tc.meta.EpisodeInt = 1
+		tc.meta.Release = api.ReleaseInfo{
+			Category:   "TV",
+			Resolution: "1080p",
+			Year:       2024,
+		}
+		tc.meta.ProviderMetadata = api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		}
+
+		got := Profile().Site.BuildName(tc.meta, config.TrackerConfig{})
+		expected := "Show.S01E01.2024.Episode.Title.1080p.WEB-DL-GRP"
+		if got != expected {
+			t.Fatalf("%s: expected %q, got %q", tc.name, expected, got)
+		}
+	}
+}
+
+func TestBuildZNTHNameExplicitMoviePreservesMovieBranchOverParsedTV(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName:  "Show.S01E01.2024.Episode.Title.1080p.WEB-DL-GRP",
+		EpisodeTitle: "Episode Title",
+		Identity:     api.ExternalIdentity{Category: "MOVIE"},
+		SeasonInt:    1,
+		EpisodeInt:   1,
+		Release: api.ReleaseInfo{
+			Category:   "TV",
+			Resolution: "1080p",
+			Year:       2024,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		},
+	}
+
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Show.S01E01.2025.Episode.Title.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameBlankCategoryDoesNotInferMovieCategory(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "Example.Movie.2026.1080p.WEB-DL-GRP",
+		Release: api.ReleaseInfo{
+			Category: "MOVIE",
+			Year:     2026,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2027},
+		},
+	}
+
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Example.Movie.2026.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameMovieYearMismatchNoResolutionHyphenatedTitle(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "Movie - Part One 2024",
+		Release:     api.ReleaseInfo{Year: 2024},
+		Identity:    api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Movie - Part One 2025"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameMovieYearMismatchNoResolutionGroupSuffix(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "Movie.Title.2024-GRP2024",
+		Release:     api.ReleaseInfo{Year: 2024, Group: "GRP2024"},
+		Identity:    api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "Movie.Title.2025-GRP2024"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameTVUnicodePrefix(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName:  "\u212aShow.S01E01.Episode.Title.1080p.WEB-DL-GRP",
+		EpisodeTitle: "Episode Title",
+		Identity:     api.ExternalIdentity{Category: "TV"},
+		Release:      api.ReleaseInfo{Resolution: "1080p"},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "\u212aShow.S01E01.1080p.WEB-DL-GRP"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestBuildZNTHNameMovieYearMismatchUnicodeTitle(t *testing.T) {
+	meta := api.UploadSubject{
+		ReleaseName: "\u212aMovie.2024",
+		Release:     api.ReleaseInfo{Year: 2024},
+		Identity:    api.ExternalIdentity{Category: "MOVIE"},
+		ProviderMetadata: api.SourceScopedMetadata{
+			IMDB: &api.IMDBMetadata{Year: 2025},
+		},
+	}
+	got := Profile().Site.BuildName(meta, config.TrackerConfig{})
+	expected := "\u212aMovie.2025"
+	if got != expected {
+		t.Fatalf("expected %q, got %q", expected, got)
+	}
+}
+
+func TestFindZNTHTokenIndexesUnicodeBoundaries(t *testing.T) {
+	got := findZNTHTokenIndexes("Title.\u212a.1080p.Source", "1080p")
+	expected := len("Title.\u212a.")
+	if len(got) != 1 || got[0] != expected {
+		t.Fatalf("expected index %d, got %#v", expected, got)
+	}
+
+	if got := findZNTHTokenIndexes("Title.\u06611080p.Source", "1080p"); len(got) != 0 {
+		t.Fatalf("expected adjacent Unicode digit prefix to reject token, got %#v", got)
+	}
+	if got := findZNTHTokenIndexes("Title.1080p\u0661.Source", "1080p"); len(got) != 0 {
+		t.Fatalf("expected adjacent Unicode digit suffix to reject token, got %#v", got)
+	}
+}
+
+func TestZNTHEmptyTokenInputs(t *testing.T) {
+	name := "Show.S01E01.1080p.WEB-DL-GRP"
+	if got := replaceZNTHEpisodeTitle(name, "", "1080p"); got != name {
+		t.Fatalf("expected empty episode title to leave name unchanged, got %q", got)
+	}
+	if got := findZNTHTokenIndexes(name, " "); got != nil {
+		t.Fatalf("expected empty token indexes to be nil, got %#v", got)
+	}
+}
diff --git a/internal/trackers/impl/unit3d/sites/znth/profile.go b/internal/trackers/impl/unit3d/sites/znth/profile.go
new file mode 100644
index 00000000..6fd23539
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/znth/profile.go
@@ -0,0 +1,32 @@
+package znth
+
+import (
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// Profile returns ZNTH's tracker-specific name policy and type mapping,
+// including its dedicated DVDRip type ID.
+func Profile() unit3d.Profile {
+	return unit3d.Profile{
+		Name:    "ZNTH",
+		BaseURL: "https://znth.cx",
+		Rules:   Rules(),
+		Site: unit3d.SiteProfile{
+			BuildName:     buildName,
+			ResolveTypeID: typeID,
+		},
+	}
+}
+
+func typeID(meta api.UploadSubject) string {
+	return map[string]string{
+		"DISC":   "1",
+		"REMUX":  "2",
+		"ENCODE": "3",
+		"DVDRIP": "11",
+		"WEBDL":  "4",
+		"WEBRIP": "5",
+		"HDTV":   "6",
+	}[unit3d.InferType(meta)]
+}
diff --git a/internal/trackers/impl/unit3d/sites/znth/rules.go b/internal/trackers/impl/unit3d/sites/znth/rules.go
new file mode 100644
index 00000000..e66dd887
--- /dev/null
+++ b/internal/trackers/impl/unit3d/sites/znth/rules.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package znth
+
+import "github.com/autobrr/upbrr/internal/trackers"
+
+// Rules returns ZNTH's waivable adult-content prohibition.
+func Rules() *trackers.RuleSet {
+	return &trackers.RuleSet{BlockAdult: true, AdultMessage: "Porn/xxx is not allowed at ZNTH."}
+}
diff --git a/internal/trackers/impl/unit3d/stc.go b/internal/trackers/impl/unit3d/stc.go
deleted file mode 100644
index 3a9e0415..00000000
--- a/internal/trackers/impl/unit3d/stc.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteSTCProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DSTCTypeID}
-}
-
-func resolveUnit3DSTCTypeID(meta api.PreparedMetadata) string {
-	typeValue := inferUnit3DType(meta)
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-		"ENCODE": "3",
-	}
-	if meta.TVPack {
-		isWeb := typeValue == "WEBDL" || typeValue == "WEBRIP"
-		sd := isSDResolution(resolveResolution(meta))
-		if sd {
-			if isWeb {
-				return "14"
-			}
-			return "17"
-		}
-		if isWeb {
-			return "13"
-		}
-		return "18"
-	}
-	return mapping[typeValue]
-}
diff --git a/internal/trackers/impl/unit3d/tik.go b/internal/trackers/impl/unit3d/tik.go
deleted file mode 100644
index 529c5b4e..00000000
--- a/internal/trackers/impl/unit3d/tik.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteTIKProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:     resolveUnit3DTIKTypeID,
-		resolveCategoryID: resolveUnit3DTIKCategoryID,
-	}
-}
-
-func resolveUnit3DTIKTypeID(meta api.PreparedMetadata) string {
-	discType := resolveTIKDiscType(meta)
-	mapping := map[string]string{
-		"CUSTOM":    "1",
-		"BD100":     "3",
-		"BD66":      "4",
-		"BD50":      "5",
-		"BD25":      "6",
-		"NTSC DVD9": "7",
-		"NTSC DVD5": "8",
-		"PAL DVD9":  "9",
-		"PAL DVD5":  "10",
-		"3D":        "11",
-	}
-	return mapping[discType]
-}
-
-func resolveTIKDiscType(meta api.PreparedMetadata) string {
-	if meta.TrackerSiteOverrides.TIK.DiscType != nil {
-		return strings.ToUpper(strings.TrimSpace(*meta.TrackerSiteOverrides.TIK.DiscType))
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
-		return "3D"
-	}
-
-	releaseName := strings.ToUpper(strings.TrimSpace(meta.ReleaseName))
-	source := strings.ToUpper(strings.TrimSpace(meta.Source))
-	if source == "" {
-		source = strings.ToUpper(strings.TrimSpace(meta.Release.Source))
-	}
-	combined := releaseName + " " + source
-
-	for _, marker := range []string{"BD100", "BD66", "BD50", "BD25"} {
-		if strings.Contains(combined, marker) {
-			return marker
-		}
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") || strings.Contains(combined, "DVD") {
-		if strings.Contains(combined, "PAL") {
-			if strings.Contains(combined, "DVD5") {
-				return "PAL DVD5"
-			}
-			return "PAL DVD9"
-		}
-		if strings.Contains(combined, "NTSC") {
-			if strings.Contains(combined, "DVD5") {
-				return "NTSC DVD5"
-			}
-			return "NTSC DVD9"
-		}
-		if strings.Contains(combined, "DVD5") {
-			return "NTSC DVD5"
-		}
-		return "NTSC DVD9"
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
-		return "CUSTOM"
-	}
-
-	return ""
-}
-
-func resolveUnit3DTIKCategoryID(meta api.PreparedMetadata) string {
-	category := resolveUnit3DCategory(meta)
-	foreign := isTIKForeign(meta)
-	opera := isTIKOpera(meta)
-	asian := isTIKAsian(meta)
-
-	if strings.EqualFold(category, "MOVIE") {
-		if foreign {
-			return "3"
-		}
-		if opera {
-			return "5"
-		}
-		if asian {
-			return "6"
-		}
-		return "1"
-	}
-
-	if strings.EqualFold(category, "TV") {
-		if foreign {
-			return "4"
-		}
-		if opera {
-			return "5"
-		}
-		return "2"
-	}
-
-	return resolveUnit3DCategoryID(meta)
-}
-
-func isTIKForeign(meta api.PreparedMetadata) bool {
-	if meta.TrackerSiteOverrides.TIK.Foreign != nil {
-		return *meta.TrackerSiteOverrides.TIK.Foreign
-	}
-	if meta.ExternalMetadata.TMDB != nil {
-		original := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage))
-		if original != "" && original != "en" {
-			return true
-		}
-	}
-	return !hasEnglishLanguage(meta.AudioLanguages) && !hasEnglishLanguage(meta.SubtitleLanguages)
-}
-
-func isTIKOpera(meta api.PreparedMetadata) bool {
-	if meta.TrackerSiteOverrides.TIK.Opera != nil {
-		return *meta.TrackerSiteOverrides.TIK.Opera
-	}
-	candidates := strings.ToLower(strings.Join([]string{
-		strings.TrimSpace(meta.Release.Genre),
-		resolveTMDBGenres(meta),
-		resolveIMDBGenres(meta),
-		resolveKeywords(meta),
-	}, ","))
-	return strings.Contains(candidates, "opera") || strings.Contains(candidates, "musical")
-}
-
-func isTIKAsian(meta api.PreparedMetadata) bool {
-	if meta.TrackerSiteOverrides.TIK.Asian != nil {
-		return *meta.TrackerSiteOverrides.TIK.Asian
-	}
-	if meta.ExternalMetadata.TMDB == nil {
-		return false
-	}
-
-	asianCountries := map[string]bool{
-		"JP": true, "KR": true, "CN": true, "HK": true, "TW": true,
-		"TH": true, "VN": true, "IN": true, "ID": true, "MY": true,
-		"PH": true, "SG": true,
-	}
-	for _, country := range meta.ExternalMetadata.TMDB.OriginCountry {
-		if asianCountries[strings.ToUpper(strings.TrimSpace(country))] {
-			return true
-		}
-	}
-
-	asianLanguages := map[string]bool{
-		"ja": true, "ko": true, "zh": true, "th": true, "vi": true,
-		"hi": true, "ta": true, "te": true, "ml": true, "id": true,
-		"ms": true,
-	}
-	original := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage))
-	return asianLanguages[original]
-}
diff --git a/internal/trackers/impl/unit3d/tlz.go b/internal/trackers/impl/unit3d/tlz.go
deleted file mode 100644
index 44aa3862..00000000
--- a/internal/trackers/impl/unit3d/tlz.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteTLZProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DTLZTypeID}
-}
-
-func resolveUnit3DTLZTypeID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(resolveUnit3DCategory(meta), "MOVIE") {
-		return "1"
-	}
-	if meta.TVPack {
-		return "4"
-	}
-	return "3"
-}
diff --git a/internal/trackers/impl/unit3d/tos.go b/internal/trackers/impl/unit3d/tos.go
deleted file mode 100644
index f9a26d70..00000000
--- a/internal/trackers/impl/unit3d/tos.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import (
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func siteTOSProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:     resolveUnit3DTOSTypeID,
-		resolveCategoryID: resolveUnit3DTOSCategoryID,
-	}
-}
-
-func resolveUnit3DTOSCategoryID(meta api.PreparedMetadata) string {
-	tag := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(meta.Tag, "-")))
-	isSubFrench := strings.Contains(tag, "vostfr") || strings.Contains(tag, "subfrench")
-	category := resolveUnit3DCategory(meta)
-	if strings.EqualFold(category, "TV") {
-		if meta.TVPack {
-			if isSubFrench {
-				return "9"
-			}
-			return "8"
-		}
-		if isSubFrench {
-			return "7"
-		}
-		return "2"
-	}
-	if isSubFrench {
-		return "6"
-	}
-	return "1"
-}
-
-func resolveUnit3DTOSTypeID(meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "DVD") {
-		return "7"
-	}
-	if strings.EqualFold(strings.TrimSpace(meta.Is3D), "3D") {
-		return "8"
-	}
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"ENCODE": "3",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
diff --git a/internal/trackers/impl/unit3d/upload.go b/internal/trackers/impl/unit3d/upload.go
index 4fc1a7f3..ba81e59a 100644
--- a/internal/trackers/impl/unit3d/upload.go
+++ b/internal/trackers/impl/unit3d/upload.go
@@ -20,14 +20,13 @@ import (
 	"strings"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/paths"
+	descriptionunit3d "github.com/autobrr/upbrr/internal/description/unit3d"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/redaction"
 	"github.com/autobrr/upbrr/internal/services/db"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
-	"github.com/autobrr/upbrr/internal/trackerdata"
 	"github.com/autobrr/upbrr/internal/trackers"
+	trackerdata "github.com/autobrr/upbrr/internal/trackers/data"
 	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -37,124 +36,27 @@ type unit3dUploadResponse struct {
 	Data    string `json:"data"`
 }
 
-func uploadUnit3D(ctx context.Context, req trackers.UploadRequest) (api.UploadSummary, error) {
-	trackerName := strings.ToUpper(strings.TrimSpace(req.Tracker))
-	logger := req.Logger
-	if logger == nil {
-		logger = api.NopLogger{}
-	}
-
-	logger.Infof("trackers: starting upload to %s for release: %s", trackerName, req.Meta.ReleaseName)
-
-	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
-	if apiKey == "" {
-		err := fmt.Errorf("trackers: %s missing api_key", trackerName)
-		logger.Errorf("trackers: %s upload aborted: %v", trackerName, err)
-		return api.UploadSummary{}, err
-	}
-	if !req.Meta.ValidMediaInfoSettings {
-		err := fmt.Errorf("trackers: %s mediainfo missing required fields", trackerName)
-		logger.Errorf("trackers: %s upload aborted: %v", trackerName, err)
-		return api.UploadSummary{}, err
-	}
-
-	baseURL, uploadURL := resolveUnit3DURLs(trackerName, req.TrackerConfig.URL)
+// submitUnit3DUpload sends an already serialized multipart payload and maps a
+// successful Unit3D response to one upload, with an artifact only when the
+// response identifies a download URL.
+func submitUnit3DUpload(
+	ctx context.Context,
+	trackerName string,
+	releaseName string,
+	apiKey string,
+	baseURL string,
+	uploadURL string,
+	contentType string,
+	payload string,
+	logger api.Logger,
+) (api.UploadSummary, error) {
+	logger.Infof("trackers: starting upload to %s for release: %s", trackerName, releaseName)
 	logger.Debugf("trackers: %s upload URL: %s", trackerName, uploadURL)
 
-	originalName := strings.TrimSpace(req.Meta.ReleaseName)
-	if originalName == "" {
-		originalName = strings.TrimSpace(req.Meta.ReleaseNameNoTag)
-	}
-	name := buildUnit3DName(trackerName, req.Meta, req.TrackerConfig)
-	if name != originalName {
-		logger.Infof("trackers: %s name formatting applied", trackerName)
-		logger.Infof("  Original: %s", originalName)
-		logger.Infof("  Formatted: %s", name)
-	} else {
-		logger.Debugf("trackers: %s using original name: %s", trackerName, name)
-	}
-
-	var err error
-	assets := trackers.DescriptionAssets{}
-	if req.Assets != nil {
-		assets = *req.Assets
-	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, logger)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %w", err)
-			}
-			logger.Warnf("trackers: %s description assets failed: %v", trackerName, err)
-			assets = trackers.DescriptionAssets{}
-		}
-	}
-	description := strings.TrimSpace(assets.Description)
-	if !assets.Final {
-		description, err = buildUnit3DDescription(ctx, trackerName, req.Meta, req.AppConfig, req.TrackerConfig, logger, assets.Description, assets.MenuImages, assets.Screenshots)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return api.UploadSummary{}, err
-			}
-			logger.Warnf("trackers: %s description build failed: %v", trackerName, err)
-			description = ""
-		}
-	}
-	description = ensureUnit3DDVDVOBDescription(description, req.Meta)
-	mediainfo, bdinfo, err := loadUnit3DMedia(req.Meta, req.AppConfig.MainSettings.DBPath, logger)
-	if err != nil {
-		logger.Errorf("trackers: %s failed to load media info: %v", trackerName, err)
-		return api.UploadSummary{}, err
-	}
-
-	data, err := buildUnit3DData(req, name, description, mediainfo, bdinfo)
-	if err != nil {
-		logger.Errorf("trackers: %s failed to build upload data: %v", trackerName, err)
-		return api.UploadSummary{}, err
-	}
-	if message, err := validateUnit3DTVPayloadMetadata(trackerName, req.Meta, data); err != nil {
-		logger.Warnf("trackers: %s %s", trackerName, message)
-		return api.UploadSummary{}, err
-	}
-	category := resolveUnit3DCategory(req.Meta)
-	_, hasTVDB := data["tvdb"]
-	_, hasSeason := data["season_number"]
-	_, hasEpisode := data["episode_number"]
-	logger.Debugf(
-		"trackers: %s payload mapping category=%s category_id=%s type_id=%s meta_type=%q release_type=%q tvdb=%t season_number=%t episode_number=%t",
-		trackerName,
-		category,
-		data["category_id"],
-		data["type_id"],
-		strings.TrimSpace(req.Meta.Type),
-		strings.TrimSpace(req.Meta.Release.Type),
-		hasTVDB,
-		hasSeason,
-		hasEpisode,
-	)
-	data["mod_queue_opt_in"] = boolFlag(req.TrackerConfig.ModQ)
-
-	if req.TrackerConfig.Exclusive {
-		data["exclusive"] = "1"
-		logger.Debugf("trackers: %s marking as exclusive release", trackerName)
-	}
-	if req.TrackerConfig.Anon {
-		logger.Debugf("trackers: %s uploading anonymously", trackerName)
-	}
-	if req.TrackerConfig.ModQ {
-		logger.Debugf("trackers: %s opted into moderation queue", trackerName)
-	}
-
-	logger.Tracef("trackers: %s building multipart form payload", trackerName)
-	payload, contentType, err := buildMultipartPayload(req, data, logger)
-	if err != nil {
-		logger.Errorf("trackers: %s failed to build payload: %v", trackerName, err)
-		return api.UploadSummary{}, err
-	}
-
 	reqCtx, cancel := context.WithTimeout(ctx, 40*time.Second)
 	defer cancel()
 
-	httpReq, err := http.NewRequestWithContext(reqCtx, http.MethodPost, uploadURL, payload)
+	httpReq, err := http.NewRequestWithContext(reqCtx, http.MethodPost, uploadURL, strings.NewReader(payload))
 	if err != nil {
 		logger.Errorf("trackers: %s failed to create HTTP request: %v", trackerName, err)
 		return api.UploadSummary{}, fmt.Errorf("trackers: %s build upload request: %w", trackerName, err)
@@ -174,7 +76,11 @@ func uploadUnit3D(ctx context.Context, req trackers.UploadRequest) (api.UploadSu
 
 	logger.Debugf("trackers: %s received HTTP %d response", trackerName, resp.StatusCode)
 
-	body, bodyPreview, err := commonhttp.ReadUploadResponseBody(resp, resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusMultipleChoices, commonhttp.DefaultResponsePreviewBytes)
+	body, bodyPreview, err := commonhttp.ReadUploadResponseBody(
+		resp,
+		resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusMultipleChoices,
+		commonhttp.DefaultResponsePreviewBytes,
+	)
 	if err != nil {
 		logger.Errorf("trackers: %s failed to read response body: %v", trackerName, err)
 		return api.UploadSummary{}, fmt.Errorf("trackers: %s read response body: %w", trackerName, err)
@@ -229,22 +135,56 @@ func uploadUnit3D(ctx context.Context, req trackers.UploadRequest) (api.UploadSu
 	return summary, nil
 }
 
-func defaultUnit3DBaseURL(tracker string) string {
-	if baseURL, ok := unit3dmeta.BaseURL(tracker); ok {
-		return baseURL
+// prepareUnit3DUpload builds one preview for every intent. Upload intent
+// serializes its files during preparation and captures the payload, endpoint,
+// API key, and logger so submission does not reread mutable prepared inputs.
+func prepareUnit3DUpload(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	configuredBaseURL string,
+	profiles ...SiteProfile,
+) (trackers.PreparedOperation, error) {
+	preview, err := buildUploadDryRunUnit3D(ctx, req, configuredBaseURL, profiles...)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	if req.Intent != trackers.PreparationIntentUpload {
+		return trackers.NewPreparedOperation(preview, nil, nil), nil
+	}
+	if !strings.EqualFold(preview.Status, "ready") {
+		return trackers.PreparedOperation{}, fmt.Errorf("trackers: %s upload blocked: %s", preview.Tracker, preview.Message)
+	}
+
+	logger := req.Logger
+	if logger == nil {
+		logger = api.NopLogger{}
 	}
-	baseURL, ok := unit3dmeta.BaseURL(unit3dmeta.DefaultTracker())
-	if ok {
-		return baseURL
+	torrentPath := preparedFilePath(preview.Files, "torrent")
+	nfoPath := preparedFilePath(preview.Files, "nfo")
+	payload, contentType, err := buildMultipartPayload(preview.Payload, torrentPath, nfoPath, logger)
+	if err != nil {
+		return trackers.PreparedOperation{}, err
+	}
+	baseURL, uploadURL := resolveUnit3DURLs(configuredBaseURL)
+	trackerName := preview.Tracker
+	releaseName := preview.ReleaseName
+	apiKey := strings.TrimSpace(req.TrackerConfig.APIKey)
+	return trackers.NewPreparedOperation(preview, func(submitCtx context.Context) (api.UploadSummary, error) {
+		return submitUnit3DUpload(submitCtx, trackerName, releaseName, apiKey, baseURL, uploadURL, contentType, payload, logger)
+	}, nil), nil
+}
+
+func preparedFilePath(files []api.TrackerDryRunFile, field string) string {
+	for _, file := range files {
+		if file.Field == field && file.Present {
+			return file.Path
+		}
 	}
 	return ""
 }
 
-func resolveUnit3DURLs(tracker string, configuredBaseURL string) (string, string) {
+func resolveUnit3DURLs(configuredBaseURL string) (string, string) {
 	baseURL := strings.TrimSpace(configuredBaseURL)
-	if baseURL == "" {
-		baseURL = defaultUnit3DBaseURL(tracker)
-	}
 	return baseURL, strings.TrimRight(baseURL, "/") + "/api/torrents/upload"
 }
 
@@ -343,7 +283,13 @@ func isNumericID(value string) bool {
 // files, and endpoint that would be used locally. TV payloads with zero-valued
 // canonical season or episode metadata are returned as blocked because the
 // payload no longer satisfies upload prerequisites.
-func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (api.TrackerDryRunEntry, error) {
+func buildUploadDryRunUnit3D(
+	ctx context.Context,
+	req trackers.PreparationInput,
+	configuredBaseURL string,
+	profiles ...SiteProfile,
+) (api.TrackerDryRunEntry, error) {
+	profile := firstSiteProfile(profiles)
 	select {
 	case <-ctx.Done():
 		return api.TrackerDryRunEntry{}, fmt.Errorf("context canceled: %w", ctx.Err())
@@ -360,17 +306,17 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	if apiKey == "" {
 		return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: %s missing api_key", trackerName)
 	}
-	if !req.Meta.ValidMediaInfoSettings {
+	if !req.Meta.Assessments.EncodeSettingsRequirementSatisfied() {
 		return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: %s mediainfo missing required fields", trackerName)
 	}
 
-	_, uploadURL := resolveUnit3DURLs(trackerName, req.TrackerConfig.URL)
+	_, uploadURL := resolveUnit3DURLs(configuredBaseURL)
 
 	originalName := strings.TrimSpace(req.Meta.ReleaseName)
 	if originalName == "" {
 		originalName = strings.TrimSpace(req.Meta.ReleaseNameNoTag)
 	}
-	name := buildUnit3DName(trackerName, req.Meta, req.TrackerConfig)
+	name := buildUnit3DName(trackerName, req.Meta, req.TrackerConfig, profile)
 	if name != originalName {
 		logger.Infof("trackers: %s dry-run name formatting applied", trackerName)
 	}
@@ -380,7 +326,7 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	if req.Assets != nil {
 		assets = *req.Assets
 	} else {
-		assets, err = trackers.ResolveDescriptionAssets(ctx, req.Tracker, req.Meta, req.Repo, logger)
+		assets, err = trackers.PreparedDescriptionAssets(req.Assets)
 		if err != nil {
 			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 				return api.TrackerDryRunEntry{}, fmt.Errorf("trackers: %w", err)
@@ -391,7 +337,18 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	}
 	description := strings.TrimSpace(assets.Description)
 	if !assets.Final {
-		description, err = buildUnit3DDescription(ctx, trackerName, req.Meta, req.AppConfig, req.TrackerConfig, logger, assets.Description, assets.MenuImages, assets.Screenshots)
+		description, err = buildUnit3DDescription(
+			ctx,
+			trackerName,
+			req.Meta,
+			req.Runtime.DescriptionConfig(),
+			req.TrackerConfig,
+			logger,
+			assets.Description,
+			assets.MenuImages,
+			assets.Screenshots,
+			profile,
+		)
 		if err != nil {
 			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 				return api.TrackerDryRunEntry{}, err
@@ -401,12 +358,12 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	}
 	description = ensureUnit3DDVDVOBDescription(description, req.Meta)
 
-	mediainfo, bdinfo, err := loadUnit3DMedia(req.Meta, req.AppConfig.MainSettings.DBPath, logger)
+	mediainfo, bdinfo, err := loadUnit3DMedia(req.Meta, req.Runtime.DBPath, logger)
 	if err != nil {
 		return api.TrackerDryRunEntry{}, err
 	}
 
-	data, err := buildUnit3DData(req, name, description, mediainfo, bdinfo)
+	data, err := buildUnit3DData(req, name, description, mediainfo, bdinfo, profile)
 	if err != nil {
 		return api.TrackerDryRunEntry{}, err
 	}
@@ -415,11 +372,11 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 		data["exclusive"] = "1"
 	}
 
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, logger)
+	torrentPath, err := resolveTorrentPath(req.Meta, req.Runtime.DBPath, logger)
 	if err != nil {
 		return api.TrackerDryRunEntry{}, err
 	}
-	nfoPath := resolveNFOPath(req.Meta, req.AppConfig.MainSettings.DBPath)
+	nfoPath := resolveNFOPath(req.Meta, req.Runtime.DBPath)
 
 	files := []api.TrackerDryRunFile{{
 		Field:   "torrent",
@@ -427,7 +384,11 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 		Present: strings.TrimSpace(torrentPath) != "",
 	}}
 	if strings.TrimSpace(nfoPath) != "" {
-		files = append(files, api.TrackerDryRunFile{Field: "nfo", Path: nfoPath, Present: true})
+		files = append(files, api.TrackerDryRunFile{
+			Field:   "nfo",
+			Path:    nfoPath,
+			Present: true,
+		})
 	}
 
 	message := "dry-run payload generated"
@@ -435,6 +396,9 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	if metadataMessage, err := validateUnit3DTVPayloadMetadata(trackerName, req.Meta, data); err != nil {
 		message += "; " + metadataMessage
 		status = "blocked"
+		if req.Intent == trackers.PreparationIntentUpload {
+			logger.Warnf("trackers: %s %s", trackerName, metadataMessage)
+		}
 	}
 
 	return api.TrackerDryRunEntry{
@@ -450,7 +414,7 @@ func buildUploadDryRunUnit3D(ctx context.Context, req trackers.UploadRequest) (a
 	}, nil
 }
 
-func buildMultipartPayload(req trackers.UploadRequest, data map[string]string, logger api.Logger) (*strings.Reader, string, error) {
+func buildMultipartPayload(data map[string]string, torrentPath string, nfoPath string, logger api.Logger) (string, string, error) {
 	var builder strings.Builder
 	writer := multipart.NewWriter(&builder)
 
@@ -458,38 +422,31 @@ func buildMultipartPayload(req trackers.UploadRequest, data map[string]string, l
 	for key, value := range data {
 		if err := writer.WriteField(key, value); err != nil {
 			_ = writer.Close()
-			return nil, "", fmt.Errorf("trackers: UNIT3D write multipart field %q: %w", key, err)
+			return "", "", fmt.Errorf("trackers: UNIT3D write multipart field %q: %w", key, err)
 		}
 	}
 
-	torrentPath, err := resolveTorrentPath(req.Meta, req.AppConfig.MainSettings.DBPath, logger)
-	if err != nil {
-		_ = writer.Close()
-		logger.Errorf("trackers: failed to resolve torrent path: %v", err)
-		return nil, "", err
-	}
-
 	logger.Debugf("trackers: attaching torrent file: %s", filepath.Base(torrentPath))
 	if err := addFile(writer, "torrent", torrentPath); err != nil {
 		_ = writer.Close()
-		return nil, "", err
+		return "", "", err
 	}
 
-	if nfoPath := resolveNFOPath(req.Meta, req.AppConfig.MainSettings.DBPath); nfoPath != "" {
+	if nfoPath != "" {
 		logger.Debugf("trackers: attaching NFO file: %s", filepath.Base(nfoPath))
 		if err := addFile(writer, "nfo", nfoPath); err != nil {
 			_ = writer.Close()
-			return nil, "", err
+			return "", "", err
 		}
 	} else {
 		logger.Tracef("trackers: no NFO file found")
 	}
 
 	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("trackers: UNIT3D close multipart writer: %w", err)
+		return "", "", fmt.Errorf("trackers: UNIT3D close multipart writer: %w", err)
 	}
 
-	return strings.NewReader(builder.String()), writer.FormDataContentType(), nil
+	return builder.String(), writer.FormDataContentType(), nil
 }
 
 func addFile(writer *multipart.Writer, field, path string) error {
@@ -510,11 +467,11 @@ func addFile(writer *multipart.Writer, field, path string) error {
 	return nil
 }
 
-func ensureUnit3DDVDVOBDescription(description string, meta api.PreparedMetadata) string {
-	return descriptionunit3d.AppendDVDVOBMediaInfoBlock(description, meta)
+func ensureUnit3DDVDVOBDescription(description string, meta api.UploadSubject) string {
+	return descriptionunit3d.AppendDVDVOBMediaInfoBlock(description, api.NewDescriptionSubject(meta))
 }
 
-func loadUnit3DMedia(meta api.PreparedMetadata, dbPath string, logger api.Logger) (string, string, error) {
+func loadUnit3DMedia(meta api.UploadSubject, dbPath string, logger api.Logger) (string, string, error) {
 	bdinfo := ""
 	mediainfo := ""
 
@@ -560,7 +517,7 @@ func readTextFile(path string) (string, error) {
 	return string(payload), nil
 }
 
-func resolveTorrentPath(meta api.PreparedMetadata, dbPath string, logger api.Logger) (string, error) {
+func resolveTorrentPath(meta api.UploadSubject, dbPath string, logger api.Logger) (string, error) {
 	logger.Tracef("trackers: attempting to resolve torrent file path")
 	candidates := []string{
 		strings.TrimSpace(meta.TorrentPath),
@@ -600,15 +557,15 @@ func resolveTorrentPath(meta api.PreparedMetadata, dbPath string, logger api.Log
 	return "", err
 }
 
-func torrentPathFromTemp(tmpRoot string, meta api.PreparedMetadata) (string, error) {
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+func torrentPathFromTemp(tmpRoot string, meta api.UploadSubject) (string, error) {
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
 	return filepath.Join(tmpDir, base+".torrent"), nil
 }
 
-func resolveNFOPath(meta api.PreparedMetadata, dbPath string) string {
+func resolveNFOPath(meta api.UploadSubject, dbPath string) string {
 	if path := strings.TrimSpace(meta.SceneNFOPath); path != "" && existsFile(path) {
 		return path
 	}
@@ -620,7 +577,7 @@ func resolveNFOPath(meta api.PreparedMetadata, dbPath string) string {
 	if err != nil {
 		return ""
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return ""
 	}
@@ -640,31 +597,35 @@ func resolveNFOPath(meta api.PreparedMetadata, dbPath string) string {
 	return ""
 }
 
-func buildUnit3DData(req trackers.UploadRequest, name, description, mediainfo, bdinfo string) (map[string]string, error) {
+func buildUnit3DData(req trackers.PreparationInput, name, description, mediainfo, bdinfo string, profiles ...SiteProfile) (map[string]string, error) {
+	profile := firstSiteProfile(profiles)
 	meta := req.Meta
-	typeID, err := resolveUnit3DTypeIDForTracker(req.Tracker, meta)
+	typeID, err := resolveUnit3DTypeIDForTracker(req.Tracker, meta, profile)
 	if err != nil {
 		return nil, err
 	}
+	if _, err := meta.Identity.RequireCategory(); err != nil {
+		return nil, fmt.Errorf("trackers: Unit3D category: %w", err)
+	}
 	category := resolveUnit3DCategory(meta)
 	data := map[string]string{
 		"name":             name,
 		"description":      description,
 		"mediainfo":        mediainfo,
 		"bdinfo":           bdinfo,
-		"category_id":      resolveUnit3DCategoryIDForTracker(req.Tracker, meta),
+		"category_id":      resolveUnit3DCategoryIDForTracker(req.Tracker, meta, profile),
 		"type_id":          typeID,
-		"resolution_id":    resolveUnit3DResolutionIDForTracker(req.Tracker, meta),
-		"tmdb":             formatOptionalInt(meta.ExternalIDs.TMDBID),
-		"imdb":             formatOptionalInt(meta.ExternalIDs.IMDBID),
-		"mal":              formatOptionalInt(meta.ExternalIDs.MALID),
+		"resolution_id":    resolveUnit3DResolutionIDForTracker(req.Tracker, meta, profile),
+		"tmdb":             formatOptionalInt(meta.Identity.TMDBID),
+		"imdb":             formatOptionalInt(meta.Identity.IMDBID),
+		"mal":              formatOptionalInt(meta.Identity.MALID),
 		"igdb":             "0",
 		"anonymous":        boolFlag(req.TrackerConfig.Anon),
 		"stream":           boolFlag(meta.StreamOptimized != 0),
 		"sd":               boolFlag(isSDResolution(resolveResolution(meta))),
-		"keywords":         resolveKeywordsForTracker(req.Tracker, meta),
+		"keywords":         resolveKeywordsForTracker(req.Tracker, meta, profile),
 		"personal_release": boolFlag(meta.PersonalRelease),
-		"internal":         boolFlag(trackers.IsInternalGroup(req.AppConfig, req.Tracker, meta)),
+		"internal":         boolFlag(req.Runtime.Internal),
 		"featured":         "0",
 		"free":             "0",
 		"doubleup":         "0",
@@ -673,7 +634,7 @@ func buildUnit3DData(req trackers.UploadRequest, name, description, mediainfo, b
 
 	if strings.EqualFold(category, "TV") {
 		if !shouldIncludeUnit3DTVFields(meta, category) {
-			applyUnit3DAdditionalPayload(req, data)
+			applyUnit3DAdditionalPayload(req, data, profile)
 			return data, nil
 		}
 		data["tvdb"] = formatOptionalInt(resolveTVDBID(meta))
@@ -681,26 +642,26 @@ func buildUnit3DData(req trackers.UploadRequest, name, description, mediainfo, b
 		data["episode_number"] = resolveEpisode(meta)
 	}
 
-	applyUnit3DAdditionalPayload(req, data)
+	applyUnit3DAdditionalPayload(req, data, profile)
 
 	return data, nil
 }
 
-func applyUnit3DAdditionalPayload(req trackers.UploadRequest, data map[string]string) {
-	profile, ok := unit3DSiteProfileFor(req.Tracker)
-	if !ok || profile.applyAdditionalPayload == nil {
+func applyUnit3DAdditionalPayload(req trackers.PreparationInput, data map[string]string, profiles ...SiteProfile) {
+	profile := firstSiteProfile(profiles)
+	if profile.ApplyAdditionalPayload == nil {
 		return
 	}
-	profile.applyAdditionalPayload(req, data)
+	profile.ApplyAdditionalPayload(req, data)
 }
 
-func resolveUnit3DTypeIDForTracker(tracker string, meta api.PreparedMetadata) (string, error) {
+func resolveUnit3DTypeIDForTracker(tracker string, meta api.UploadSubject, profiles ...SiteProfile) (string, error) {
 	trackerName := strings.ToUpper(strings.TrimSpace(tracker))
-	profile, ok := unit3DSiteProfileFor(trackerName)
-	if !ok || profile.resolveTypeID == nil {
+	profile := firstSiteProfile(profiles)
+	if profile.ResolveTypeID == nil {
 		return resolveUnit3DTypeID(meta)
 	}
-	typeID := profile.resolveTypeID(meta)
+	typeID := profile.ResolveTypeID(meta)
 	if strings.TrimSpace(typeID) == "" || typeID == "0" {
 		resolvedType := inferUnit3DType(meta)
 		if resolvedType == "" {
@@ -711,97 +672,73 @@ func resolveUnit3DTypeIDForTracker(tracker string, meta api.PreparedMetadata) (s
 	return typeID, nil
 }
 
-func resolveUnit3DResolutionIDForTracker(tracker string, meta api.PreparedMetadata) string {
-	profile, ok := unit3DSiteProfileFor(tracker)
-	if ok && profile.resolveResolutionID != nil {
-		return profile.resolveResolutionID(meta)
+func resolveUnit3DResolutionIDForTracker(_ string, meta api.UploadSubject, profiles ...SiteProfile) string {
+	profile := firstSiteProfile(profiles)
+	if profile.ResolveResolutionID != nil {
+		return profile.ResolveResolutionID(meta)
 	}
 	return resolveUnit3DResolutionID(meta)
 }
 
-func resolveUnit3DCategoryIDForTracker(tracker string, meta api.PreparedMetadata) string {
-	profile, ok := unit3DSiteProfileFor(tracker)
-	if ok && profile.resolveCategoryID != nil {
-		return profile.resolveCategoryID(meta)
+func resolveUnit3DCategoryIDForTracker(_ string, meta api.UploadSubject, profiles ...SiteProfile) string {
+	profile := firstSiteProfile(profiles)
+	if profile.ResolveCategoryID != nil {
+		return profile.ResolveCategoryID(meta)
 	}
 	return resolveUnit3DCategoryID(meta)
 }
 
-func resolveKeywords(meta api.PreparedMetadata) string {
-	if meta.ExternalMetadata.TMDB != nil {
-		return strings.TrimSpace(meta.ExternalMetadata.TMDB.Keywords)
+func resolveKeywords(meta api.UploadSubject) string {
+	if meta.ProviderMetadata.TMDB != nil {
+		return strings.TrimSpace(meta.ProviderMetadata.TMDB.Keywords)
 	}
 	return ""
 }
 
-func resolveKeywordsForTracker(tracker string, meta api.PreparedMetadata) string {
-	if strings.EqualFold(strings.TrimSpace(tracker), "ACM") {
-		return resolveACMKeywords(meta)
+func resolveKeywordsForTracker(_ string, meta api.UploadSubject, profiles ...SiteProfile) string {
+	profile := firstSiteProfile(profiles)
+	if profile.ResolveKeywords != nil {
+		return profile.ResolveKeywords(meta)
 	}
 	return resolveKeywords(meta)
 }
 
-func resolveTVDBID(meta api.PreparedMetadata) int {
+func resolveTVDBID(meta api.UploadSubject) int {
 	if strings.EqualFold(resolveUnit3DCategory(meta), "TV") {
-		if meta.ExternalIDs.TVDBID != 0 {
-			return meta.ExternalIDs.TVDBID
+		if meta.Identity.TVDBID != 0 {
+			return meta.Identity.TVDBID
 		}
 	}
 	return 0
 }
 
-// resolveUnit3DCategory resolves the upload category from recognized explicit
-// tracker metadata, parsed release metadata, structured episode fields, then
-// release-name heuristics.
-func resolveUnit3DCategory(meta api.PreparedMetadata) string {
-	if category := resolveExplicitUnit3DCategory(meta.ExternalIDs.Category); category != "" {
-		return category
-	}
-	if category := resolveExplicitUnit3DCategory(meta.MediaInfoCategory); category != "" {
-		return category
-	}
-	if category := canonicalUnit3DCategory(meta.Release.Category); category != "" {
-		return category
-	}
-	if meta.HasTVSeasonEpisodeSignal() {
-		return "TV"
-	}
-	if hasSeasonEpisode(meta.ReleaseName) {
-		return "TV"
-	}
-	return "MOVIE"
+// resolveUnit3DCategory maps only the canonical prepared identity category.
+func resolveUnit3DCategory(meta api.UploadSubject) string {
+	return resolveExplicitUnit3DCategory(string(meta.Identity.Category))
 }
 
-// resolveExplicitUnit3DCategory treats unrecognized explicit values as absent
-// so parsed release metadata can still determine the category.
+// resolveExplicitUnit3DCategory accepts only finalized canonical values.
 func resolveExplicitUnit3DCategory(value string) string {
-	if strings.TrimSpace(value) == "" {
+	category, err := api.NormalizeCanonicalCategory(value)
+	if err != nil {
 		return ""
 	}
-	if category := canonicalUnit3DCategory(value); category != "" {
-		return category
-	}
-	return ""
-}
-
-func canonicalUnit3DCategory(value string) string {
-	switch api.NormalizeCategory(value) {
-	case api.CategoryMovie:
+	switch category {
+	case api.CanonicalCategoryMovie:
 		return "MOVIE"
-	case api.CategoryTV:
+	case api.CanonicalCategoryTV:
 		return "TV"
-	case api.CategoryUnknown:
-		return ""
-	default:
+	case api.CanonicalCategoryUnknown:
 		return ""
 	}
+	return ""
 }
 
-func resolveUnit3DCategoryID(meta api.PreparedMetadata) string {
+func resolveUnit3DCategoryID(meta api.UploadSubject) string {
 	return trackerdata.CategoryID(resolveUnit3DCategory(meta))
 }
 
-func resolveUnit3DTypeID(meta api.PreparedMetadata) (string, error) {
+func resolveUnit3DTypeID(meta api.UploadSubject) (string, error) {
 	typeValue := inferUnit3DType(meta)
 	if value := trackerdata.TypeID(typeValue); value != "" {
 		return value, nil
@@ -815,7 +752,7 @@ func resolveUnit3DTypeID(meta api.PreparedMetadata) (string, error) {
 	return "", fmt.Errorf("trackers: unit3d unsupported type value %q", typeValue)
 }
 
-func inferUnit3DType(meta api.PreparedMetadata) string {
+func inferUnit3DType(meta api.UploadSubject) string {
 	for _, candidate := range []string{meta.Type, meta.Release.Type} {
 		normalized := normalizeUnit3DTypeCandidate(candidate)
 		if normalized != "" && !isUnit3DCategoryType(normalized) {
@@ -909,41 +846,11 @@ func isUnit3DCategoryType(value string) bool {
 	}
 }
 
-func shouldIncludeUnit3DTVFields(meta api.PreparedMetadata, category string) bool {
-	if !strings.EqualFold(strings.TrimSpace(category), "TV") {
-		return false
-	}
-
-	if hasExplicitMovieSignal(meta) {
-		return false
-	}
-
-	if strings.EqualFold(strings.TrimSpace(meta.MediaInfoCategory), "TV") {
-		return true
-	}
-	if meta.HasTVSeasonEpisodeSignal() {
-		return true
-	}
-
-	releaseType := normalizeUnit3DTypeCandidate(meta.Release.Type)
-	if strings.EqualFold(releaseType, "EPISODE") || strings.EqualFold(releaseType, "SERIES") {
-		return true
-	}
-
-	return hasSeasonEpisode(meta.ReleaseName)
+func shouldIncludeUnit3DTVFields(_ api.UploadSubject, category string) bool {
+	return strings.EqualFold(strings.TrimSpace(category), "TV")
 }
 
-func hasExplicitMovieSignal(meta api.PreparedMetadata) bool {
-	for _, value := range []string{meta.ExternalIDs.Category, meta.MediaInfoCategory, meta.Type, meta.Release.Type} {
-		normalized := normalizeUnit3DTypeCandidate(value)
-		if strings.EqualFold(normalized, "MOVIE") || strings.EqualFold(normalized, "FILM") {
-			return true
-		}
-	}
-	return false
-}
-
-func resolveUnit3DResolutionID(meta api.PreparedMetadata) string {
+func resolveUnit3DResolutionID(meta api.UploadSubject) string {
 	resolution := resolveResolution(meta)
 	if value := trackerdata.ResolutionID(resolution); value != "" {
 		return value
@@ -951,10 +858,14 @@ func resolveUnit3DResolutionID(meta api.PreparedMetadata) string {
 	return "10"
 }
 
-func resolveResolution(meta api.PreparedMetadata) string {
-	resolution := strings.TrimSpace(meta.Release.Resolution)
+func resolveResolution(meta api.UploadSubject) string {
+	return resolveResolutionValues(meta.Release, meta.ReleaseName)
+}
+
+func resolveResolutionValues(release api.ReleaseInfo, releaseName string) string {
+	resolution := strings.TrimSpace(release.Resolution)
 	if resolution == "" {
-		resolution = detectResolution(meta.ReleaseName)
+		resolution = detectResolution(releaseName)
 	}
 	return resolution
 }
@@ -970,7 +881,7 @@ func detectResolution(value string) string {
 }
 
 // resolveSeason returns the Unit3D payload season value from SeasonInt only.
-func resolveSeason(meta api.PreparedMetadata) string {
+func resolveSeason(meta api.UploadSubject) string {
 	if meta.SeasonInt <= 0 {
 		return "0"
 	}
@@ -978,7 +889,7 @@ func resolveSeason(meta api.PreparedMetadata) string {
 }
 
 // resolveEpisode returns the Unit3D payload episode value from EpisodeInt only.
-func resolveEpisode(meta api.PreparedMetadata) string {
+func resolveEpisode(meta api.UploadSubject) string {
 	if meta.EpisodeInt <= 0 {
 		return "0"
 	}
@@ -988,7 +899,7 @@ func resolveEpisode(meta api.PreparedMetadata) string {
 // validateUnit3DTVPayloadMetadata returns the shared Unit3D TV metadata block
 // reason used by live upload and dry-run when canonical season or episode data
 // is missing from payload fields that would otherwise be submitted as zero.
-func validateUnit3DTVPayloadMetadata(trackerName string, meta api.PreparedMetadata, data map[string]string) (string, error) {
+func validateUnit3DTVPayloadMetadata(trackerName string, meta api.UploadSubject, data map[string]string) (string, error) {
 	message := unit3DTVPayloadMetadataMessage(meta, data)
 	if message == "" {
 		return "", nil
@@ -1000,7 +911,7 @@ func validateUnit3DTVPayloadMetadata(trackerName string, meta api.PreparedMetada
 // canonical season or episode metadata is missing. Parsed release and manual
 // naming values are reported only as ignored signals, and the message includes
 // the operator action required by blocked dry-run entries.
-func unit3DTVPayloadMetadataMessage(meta api.PreparedMetadata, data map[string]string) string {
+func unit3DTVPayloadMetadataMessage(meta api.UploadSubject, data map[string]string) string {
 	if _, hasSeason := data["season_number"]; !hasSeason {
 		return ""
 	}
@@ -1033,7 +944,7 @@ func unit3DTVPayloadMetadataMessage(meta api.PreparedMetadata, data map[string]s
 	return message
 }
 
-func hasParsedSeasonSignal(meta api.PreparedMetadata) bool {
+func hasParsedSeasonSignal(meta api.UploadSubject) bool {
 	if meta.Release.Season > 0 {
 		return true
 	}
@@ -1044,7 +955,7 @@ func hasParsedSeasonSignal(meta api.PreparedMetadata) bool {
 	return season > 0
 }
 
-func hasParsedEpisodeSignal(meta api.PreparedMetadata) bool {
+func hasParsedEpisodeSignal(meta api.UploadSubject) bool {
 	if meta.Release.Episode > 0 {
 		return true
 	}
@@ -1070,10 +981,6 @@ func parseSeasonEpisode(name string) (int, int) {
 	return season, episode
 }
 
-func hasSeasonEpisode(name string) bool {
-	return seasonEpisodePattern.MatchString(name)
-}
-
 func isSDResolution(resolution string) bool {
 	switch strings.ToLower(strings.TrimSpace(resolution)) {
 	case "480p", "480i", "576p", "576i":
diff --git a/internal/trackers/impl/unit3d/upload_doc.go b/internal/trackers/impl/unit3d/upload_doc.go
index 4cc4c71d..174a43bb 100644
--- a/internal/trackers/impl/unit3d/upload_doc.go
+++ b/internal/trackers/impl/unit3d/upload_doc.go
@@ -3,5 +3,35 @@
 
 package unit3d
 
-// Unit3D tracker uploads live here, with per-tracker overrides handled in the
-// individual files (Aither is the first).
+// Unit3D upload contract
+//
+// The upstream UNIT3D Torrent API documents uploads as multipart POST requests
+// to /api/torrents/upload. API authentication may be supplied as an api_token
+// query/form value or as a Bearer token. upbrr uses Bearer authentication and
+// never includes credentials in diagnostic payload output; see
+// authentication_doc.go for the local security contract.
+//
+// Upstream request fields are grouped as follows:
+//
+//   - Files: torrent and optional nfo.
+//   - Description data: name, description, mediainfo, and bdinfo.
+//   - Classification IDs: category_id, type_id, resolution_id, region_id, and
+//     distributor_id.
+//   - TV coordinates: season_number and episode_number.
+//   - External IDs: tmdb, imdb, tvdb, mal, and the games-only igdb field.
+//   - Release flags: anonymous, personal_release, and internal.
+//   - Staff/internal controls: refundable, featured, free, fl_until, doubleup,
+//     du_until, sticky, and mod_queue_opt_in.
+//
+// Boolean values are encoded through boolFlag. Category, type, resolution, and
+// external identifiers are resolved by the common Unit3D engine before site
+// profiles apply their overrides. TV-only season and episode fields are omitted
+// for movie uploads. The torrent and NFO fields are attached as multipart files;
+// all remaining values are form fields.
+//
+// Individual UNIT3D deployments may extend the upstream contract. Fields such
+// as internalrip, stream, sd, pack, keywords, modq, and site-specific IDs are
+// compatibility extensions selected by site profiles or tracker configuration;
+// they are not part of the upstream baseline documented above.
+//
+// Source: https://github.com/HDInnovations/UNIT3D/blob/master/book/src/torrent_api.md
diff --git a/internal/trackers/impl/unit3d/upload_test.go b/internal/trackers/impl/unit3d/upload_test.go
index 6f924ce9..232c2294 100644
--- a/internal/trackers/impl/unit3d/upload_test.go
+++ b/internal/trackers/impl/unit3d/upload_test.go
@@ -16,7 +16,6 @@ import (
 	"testing"
 
 	"github.com/autobrr/upbrr/internal/config"
-	descriptionunit3d "github.com/autobrr/upbrr/internal/services/description/unit3d"
 	"github.com/autobrr/upbrr/internal/trackers"
 	"github.com/autobrr/upbrr/pkg/api"
 )
@@ -52,110 +51,137 @@ func (l *captureUnit3DLogger) containsWarning(value string) bool {
 	return false
 }
 
+func TestDefinitionsRetainIndependentSiteProfiles(t *testing.T) {
+	first := NewWithProfile(Profile{
+		Name:         "FIRST",
+		BannedGroups: []string{"GROUP-A"},
+		Site: SiteProfile{
+			ResolveTypeID: func(api.UploadSubject) string { return "1" },
+		},
+	})
+	second := NewWithProfile(Profile{
+		Name: "SECOND",
+		Site: SiteProfile{
+			ResolveTypeID: func(api.UploadSubject) string { return "2" },
+		},
+	})
+
+	if got := first.profile.Site.ResolveTypeID(api.UploadSubject{}); got != "1" {
+		t.Fatalf("first profile type ID = %q, want 1", got)
+	}
+	if got := second.profile.Site.ResolveTypeID(api.UploadSubject{}); got != "2" {
+		t.Fatalf("second profile type ID = %q, want 2", got)
+	}
+	groups := first.BannedGroups()
+	groups[0] = "CHANGED"
+	if got := first.BannedGroups()[0]; got != "GROUP-A" {
+		t.Fatalf("definition exposed mutable banned groups: %q", got)
+	}
+}
+
 func TestResolveUnit3DCategory(t *testing.T) {
 	tests := []struct {
 		name string
-		meta api.PreparedMetadata
+		meta api.UploadSubject
 		want string
 	}{
 		{
 			name: "external movie",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "movie"}},
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{Category: "movie"}},
 			want: "MOVIE",
 		},
 		{
 			name: "external tv",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}},
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{Category: "TV"}},
 			want: "TV",
 		},
 		{
-			name: "external tv alias",
-			meta: api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: " tv-show "}},
-			want: "TV",
+			name: "noncanonical tv alias",
+			meta: api.UploadSubject{Identity: api.ExternalIdentity{Category: " tv-show "}},
+			want: "",
 		},
 		{
-			name: "external movie alias",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: " film "},
-				Release:     api.ReleaseInfo{Category: "TV"},
+			name: "canonical movie",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "movie"},
+				Release:  api.ReleaseInfo{Category: "TV"},
 			},
 			want: "MOVIE",
 		},
 		{
 			name: "external wins over release",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-				Release:     api.ReleaseInfo{Category: "TV"},
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "MOVIE"},
+				Release:  api.ReleaseInfo{Category: "TV"},
 			},
 			want: "MOVIE",
 		},
 		{
-			name: "mediainfo wins over release",
-			meta: api.PreparedMetadata{
-				MediaInfoCategory: "movie",
-				Release:           api.ReleaseInfo{Category: "episode"},
+			name: "canonical identity wins over release",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "movie"},
+				Release:  api.ReleaseInfo{Category: "episode"},
 			},
 			want: "MOVIE",
 		},
 		{
-			name: "unknown external uses mediainfo",
-			meta: api.PreparedMetadata{
-				ExternalIDs:       api.ExternalIDs{Category: "documentary"},
-				MediaInfoCategory: "TV",
+			name: "canonical tv identity",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "TV"},
 			},
 			want: "TV",
 		},
 		{
-			name: "unknown external uses release",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "documentary"},
-				Release:     api.ReleaseInfo{Category: "series"},
+			name: "unknown external ignores release",
+			meta: api.UploadSubject{
+				Identity: api.ExternalIdentity{Category: "documentary"},
+				Release:  api.ReleaseInfo{Category: "series"},
 			},
-			want: "TV",
+			want: "",
 		},
 		{
-			name: "release category tv alias",
-			meta: api.PreparedMetadata{Release: api.ReleaseInfo{Category: " series "}},
-			want: "TV",
+			name: "release category is not canonical identity",
+			meta: api.UploadSubject{Release: api.ReleaseInfo{Category: " series "}},
+			want: "",
 		},
 		{
-			name: "release category movie alias",
-			meta: api.PreparedMetadata{
+			name: "release movie category is not canonical identity",
+			meta: api.UploadSubject{
 				ReleaseName: "Example.Movie.2026.1080p.WEB-DL-GRP",
 				Release:     api.ReleaseInfo{Category: "film"},
 			},
-			want: "MOVIE",
+			want: "",
 		},
 		{
-			name: "structured episode fields",
-			meta: api.PreparedMetadata{
+			name: "structured episode fields are not identity",
+			meta: api.UploadSubject{
 				ReleaseName: "Show.1x01.1080p.WEB-DL-GRP",
 				SeasonInt:   1,
 				EpisodeInt:  1,
 			},
-			want: "TV",
+			want: "",
 		},
 		{
-			name: "unknown mediainfo uses release name fallback",
-			meta: api.PreparedMetadata{
-				MediaInfoCategory: "documentary",
-				ReleaseName:       "Show.S01E01.1080p.WEB-DL-GRP",
+			name: "canonical tv identity ignores release name inference",
+			meta: api.UploadSubject{
+				Identity:    api.ExternalIdentity{Category: "TV"},
+				ReleaseName: "Show.S01E01.1080p.WEB-DL-GRP",
 			},
 			want: "TV",
 		},
 		{
-			name: "whitespace external uses structured episode fields",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: " \t "},
-				SeasonInt:   1,
-				EpisodeInt:  1,
+			name: "whitespace identity remains unknown",
+			meta: api.UploadSubject{
+				Identity:   api.ExternalIdentity{Category: " \t "},
+				SeasonInt:  1,
+				EpisodeInt: 1,
 			},
-			want: "TV",
+			want: "",
 		},
 		{
-			name: "release name fallback",
-			meta: api.PreparedMetadata{ReleaseName: "Show.S01E01.1080p.WEB-DL-GRP"},
-			want: "TV",
+			name: "release name is not canonical identity",
+			meta: api.UploadSubject{ReleaseName: "Show.S01E01.1080p.WEB-DL-GRP"},
+			want: "",
 		},
 	}
 
@@ -167,13 +193,13 @@ func TestResolveUnit3DCategory(t *testing.T) {
 	}
 }
 
-func TestBuildUnit3DDataUsesParsedCategoryWhenExplicitCategoryUnsupported(t *testing.T) {
-	tvReq := trackers.UploadRequest{
+func TestBuildUnit3DDataUsesCanonicalCategory(t *testing.T) {
+	tvReq := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Show.S02E03.Episode.Title.1080p.WEB-DL-GRP",
-			ExternalIDs: api.ExternalIDs{
-				Category: "documentary",
+			Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryTV,
 				TMDBID:   123,
 				IMDBID:   456,
 				TVDBID:   789,
@@ -207,12 +233,12 @@ func TestBuildUnit3DDataUsesParsedCategoryWhenExplicitCategoryUnsupported(t *tes
 		t.Fatalf("expected tvdb=789, got %q", got)
 	}
 
-	movieReq := trackers.UploadRequest{
+	movieReq := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Movie.2025.1080p.WEB-DL-GRP",
-			ExternalIDs: api.ExternalIDs{
-				Category: "documentary",
+			Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryMovie,
 				TVDBID:   789,
 			},
 			Type: "WEBDL",
@@ -241,30 +267,12 @@ func TestBuildUnit3DDataUsesParsedCategoryWhenExplicitCategoryUnsupported(t *tes
 	}
 }
 
-func TestBuildAitherNameDVDRip(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie.2020.DVD.DVDRIP.AAC.XVID-GRP",
-		Release:     api.ReleaseInfo{Year: 2020, Resolution: "480p"},
-		Type:        "DVDRIP",
-		Source:      "DVD",
-		Audio:       "AAC 2.0",
-		VideoEncode: "XVID",
-	}
-	name := BuildAitherName(meta)
-	if name == "" {
-		t.Fatalf("expected aither name")
-	}
-	if name == meta.ReleaseName {
-		t.Fatalf("expected name to be adjusted, got %q", name)
-	}
-}
-
 func TestBuildUnit3DDataMovieOmitsTVOnlyFields(t *testing.T) {
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "MOVIE",
 				TMDBID:   123,
 				IMDBID:   456,
@@ -293,67 +301,12 @@ func TestBuildUnit3DDataMovieOmitsTVOnlyFields(t *testing.T) {
 	}
 }
 
-func TestBuildUnit3DDataAitherHDR10PExcludesHDR(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.2160p.WEB-DL.HDR10+.DV.H265-GRP",
-			HDR:         "HDR10+ DV",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			Release: api.ReleaseInfo{
-				Resolution: "2160p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got := data["hdr10p"]; got != "1" {
-		t.Fatalf("expected hdr10p=1, got %q", got)
-	}
-	if _, ok := data["hdr"]; ok {
-		t.Fatalf("did not expect hdr when hdr10p is set")
-	}
-	if got := data["dv"]; got != "1" {
-		t.Fatalf("expected dv=1, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataAitherHDRWithoutHDR10P(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.2160p.WEB-DL.HDR.H265-GRP",
-			HDR:         "HDR",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			Release: api.ReleaseInfo{
-				Resolution: "2160p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got := data["hdr"]; got != "1" {
-		t.Fatalf("expected hdr=1, got %q", got)
-	}
-	if _, ok := data["hdr10p"]; ok {
-		t.Fatalf("did not expect hdr10p for plain HDR")
-	}
-}
-
 func TestBuildUnit3DDataTVIncludesTVOnlyFields(t *testing.T) {
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Show.S02E03.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 				TMDBID:   123,
 				IMDBID:   456,
@@ -385,11 +338,11 @@ func TestBuildUnit3DDataTVIncludesTVOnlyFields(t *testing.T) {
 }
 
 func TestBuildUnit3DDataTVOmitsParsedReleaseSeasonEpisodeFallback(t *testing.T) {
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Daily.Show.2025.07.01.1080p.WEB-DL-GRP",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 				TVDBID:   789,
 			},
@@ -433,17 +386,17 @@ func TestBuildUnit3DDryRunBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 		t.Fatalf("write torrent: %v", err)
 	}
 
-	entry, err := buildUploadDryRunUnit3D(context.Background(), trackers.UploadRequest{
+	entry, err := buildUploadDryRunUnit3D(context.Background(), trackers.PreparationInput{
 		Tracker: "AITHER",
 		TrackerConfig: config.TrackerConfig{
 			APIKey: "test-key",
 		},
-		Meta: api.PreparedMetadata{
-			ReleaseName:            "Daily.Show.2025.07.01.1080p.WEB-DL-GRP",
-			TorrentPath:            torrentPath,
-			MediaInfoTextPath:      mediaInfoPath,
-			ValidMediaInfoSettings: true,
-			ExternalIDs: api.ExternalIDs{
+		Meta: api.UploadSubject{
+			ReleaseName:       "Daily.Show.2025.07.01.1080p.WEB-DL-GRP",
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Assessments:       api.ReleaseAssessments{MediaInfoEncodeSettings: api.EncodeSettingsStatusPresent},
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 				TVDBID:   789,
 			},
@@ -459,7 +412,7 @@ func TestBuildUnit3DDryRunBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 			Description: "description",
 			Final:       true,
 		},
-	})
+	}, "https://aither.cc")
 	if err != nil {
 		t.Fatalf("build Unit3D dry-run: %v", err)
 	}
@@ -490,19 +443,17 @@ func TestUploadUnit3DBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 	t.Cleanup(server.Close)
 
 	logger := &captureUnit3DLogger{}
-	_, err := uploadUnit3D(context.Background(), trackers.UploadRequest{
-		Tracker: "AITHER",
-		TrackerConfig: config.TrackerConfig{
-			URL:    server.URL,
-			APIKey: "test-key",
-		},
-		Logger: logger,
-		Meta: api.PreparedMetadata{
-			ReleaseName:            "Daily.Show.2025.07.01.1080p.WEB-DL-GRP",
-			TorrentPath:            torrentPath,
-			MediaInfoTextPath:      mediaInfoPath,
-			ValidMediaInfoSettings: true,
-			ExternalIDs: api.ExternalIDs{
+	_, err := prepareUnit3DUpload(context.Background(), trackers.PreparationInput{
+		Intent:        trackers.PreparationIntentUpload,
+		Tracker:       "AITHER",
+		TrackerConfig: config.TrackerConfig{APIKey: "test-key"},
+		Logger:        logger,
+		Meta: api.UploadSubject{
+			ReleaseName:       "Example.Show.2026.S01E01.1080p.WEB-DL-GRP",
+			TorrentPath:       torrentPath,
+			MediaInfoTextPath: mediaInfoPath,
+			Assessments:       api.ReleaseAssessments{MediaInfoEncodeSettings: api.EncodeSettingsStatusPresent},
+			Identity: api.ExternalIdentity{
 				Category: "TV",
 				TVDBID:   789,
 			},
@@ -518,7 +469,7 @@ func TestUploadUnit3DBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 			Description: "description",
 			Final:       true,
 		},
-	})
+	}, server.URL)
 	if err == nil {
 		t.Fatal("expected canonical TV metadata gap to block upload")
 	}
@@ -535,11 +486,11 @@ func TestUploadUnit3DBlocksMissingCanonicalTVSeasonEpisode(t *testing.T) {
 }
 
 func TestBuildUnit3DDataFailsOnUnknownType(t *testing.T) {
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Movie.2025.1080p.UNKNOWN-GRP",
-			ExternalIDs: api.ExternalIDs{
+			Identity: api.ExternalIdentity{
 				Category: "MOVIE",
 			},
 			Type: "",
@@ -560,7 +511,7 @@ func TestBuildUnit3DDataFailsOnUnknownType(t *testing.T) {
 }
 
 func TestResolveUnit3DTypeIDInfersWEBDLFromSourceWhenReleaseTypeIsMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		Type:   "movie",
 		Source: "WEB-DL",
 		Release: api.ReleaseInfo{
@@ -579,7 +530,7 @@ func TestResolveUnit3DTypeIDInfersWEBDLFromSourceWhenReleaseTypeIsMovie(t *testi
 }
 
 func TestResolveUnit3DTypeIDInfersEncodeFromBluraySourceWhenReleaseTypeIsMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		Type:   "movie",
 		Source: "BluRay",
 		Release: api.ReleaseInfo{
@@ -598,7 +549,7 @@ func TestResolveUnit3DTypeIDInfersEncodeFromBluraySourceWhenReleaseTypeIsMovie(t
 }
 
 func TestResolveUnit3DIDsUseSharedTrackerdataMappings(t *testing.T) {
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		Type: "WEB-DL",
 		Release: api.ReleaseInfo{
 			Resolution: "1080P",
@@ -619,18 +570,17 @@ func TestResolveUnit3DIDsUseSharedTrackerdataMappings(t *testing.T) {
 }
 
 func TestBuildUnit3DDataSkipsTVFieldsWhenMovieSignalsExist(t *testing.T) {
-	req := trackers.UploadRequest{
+	req := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Example.Movie.2026.2160p.WEB-DL.DDP5.1.H.265-GRP",
-			ExternalIDs: api.ExternalIDs{
-				Category: "TV",
+			Identity: api.ExternalIdentity{
+				Category: "movie",
 				TMDBID:   765432,
 				IMDBID:   1234567,
 			},
-			MediaInfoCategory: "movie",
-			Type:              "movie",
-			Source:            "WEB-DL",
+			Type:   "movie",
+			Source: "WEB-DL",
 			Release: api.ReleaseInfo{
 				Type:       "movie",
 				Source:     "WEB-DL",
@@ -658,15 +608,18 @@ func TestBuildUnit3DDataSkipsTVFieldsWhenMovieSignalsExist(t *testing.T) {
 	}
 }
 
-func TestBuildUnit3DDataUsesParsedCategoryWhenExplicitCategoriesBlank(t *testing.T) {
-	tvReq := trackers.UploadRequest{
+func TestBuildUnit3DDataUsesCanonicalCategoryWithParsedReleaseFacts(t *testing.T) {
+	tvReq := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Show.1x01.Episode.Title.1080p.WEB-DL-GRP",
-			ExternalIDs: api.ExternalIDs{TVDBID: 789},
-			Type:        "WEBDL",
-			SeasonInt:   1,
-			EpisodeInt:  1,
+			Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryTV,
+				TVDBID:   789,
+			},
+			Type:       "WEBDL",
+			SeasonInt:  1,
+			EpisodeInt: 1,
 			Release: api.ReleaseInfo{
 				Category:   "TV",
 				Season:     1,
@@ -693,12 +646,15 @@ func TestBuildUnit3DDataUsesParsedCategoryWhenExplicitCategoriesBlank(t *testing
 		t.Fatalf("expected tvdb=789, got %q", got)
 	}
 
-	movieReq := trackers.UploadRequest{
+	movieReq := trackers.PreparationInput{
 		Tracker: "AITHER",
-		Meta: api.PreparedMetadata{
+		Meta: api.UploadSubject{
 			ReleaseName: "Example.Movie.2026.1080p.WEB-DL-GRP",
-			ExternalIDs: api.ExternalIDs{TVDBID: 789},
-			Type:        "WEBDL",
+			Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryMovie,
+				TVDBID:   789,
+			},
+			Type: "WEBDL",
 			Release: api.ReleaseInfo{
 				Category:   "MOVIE",
 				Year:       2026,
@@ -755,496 +711,18 @@ func TestParseUnit3DUploadArtifactNumericID(t *testing.T) {
 	}
 }
 
-func TestResolveUnit3DTypeIDForTrackerOE(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "WEBRIP", VideoCodec: "HEVC"}
-	got, err := resolveUnit3DTypeIDForTracker("OE", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "10" {
-		t.Fatalf("expected OE WEBRIP HEVC type_id=10, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerOEFallsBackToOtherUnknown(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "WEBRIP", VideoCodec: "VP9"}
-	got, err := resolveUnit3DTypeIDForTracker("OE", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "16" {
-		t.Fatalf("expected OE WEBRIP unknown codec type_id=16, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerOTWDVD(t *testing.T) {
-	meta := api.PreparedMetadata{DiscType: "DVD", Type: "REMUX"}
-	got, err := resolveUnit3DTypeIDForTracker("OTW", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "7" {
-		t.Fatalf("expected OTW DVD type_id=7, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerRF(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "ENCODE"}
-	got, err := resolveUnit3DTypeIDForTracker("RF", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "41" {
-		t.Fatalf("expected RF ENCODE type_id=41, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerYUS(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "DISC"}
-	got, err := resolveUnit3DTypeIDForTracker("YUS", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "17" {
-		t.Fatalf("expected YUS DISC type_id=17, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerZNTH(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "DVDRIP"}
-	got, err := resolveUnit3DTypeIDForTracker("ZNTH", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "11" {
-		t.Fatalf("expected ZNTH DVDRIP type_id=11, got %q", got)
-	}
-}
-
-func TestBuildZNTHNameTV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName:  "Show.S01E01.Episode.Title.1080p.WEB-DL-GRP",
-		EpisodeTitle: "Episode Title",
-		ExternalIDs:  api.ExternalIDs{Category: "TV"},
-		Release:      api.ReleaseInfo{Resolution: "1080p"},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Show.S01E01.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameMovieYearMismatch(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie.2024.1080p.WEB-DL-GRP",
-		Release:     api.ReleaseInfo{Year: 2024},
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Movie.2025.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameBlankCategoryUsesParsedTVCategory(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName:  "Show.1x01.Episode.Title.1080p.WEB-DL-GRP",
-		EpisodeTitle: "Episode Title",
-		SeasonInt:    1,
-		EpisodeInt:   1,
-		Release: api.ReleaseInfo{
-			Category:   "TV",
-			Resolution: "1080p",
-		},
-	}
-
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Show.1x01.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameUnknownExplicitCategoryUsesParsedTVCategory(t *testing.T) {
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-	}{
-		{
-			name: "external unknown",
-			meta: api.PreparedMetadata{
-				ExternalIDs: api.ExternalIDs{Category: "animation"},
-			},
-		},
-		{
-			name: "mediainfo unknown",
-			meta: api.PreparedMetadata{
-				MediaInfoCategory: "animation",
-			},
-		},
-		{
-			name: "external unknown falls through to mediainfo tv",
-			meta: api.PreparedMetadata{
-				ExternalIDs:       api.ExternalIDs{Category: "animation"},
-				MediaInfoCategory: "TV",
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		tc.meta.ReleaseName = "Show.S01E01.2024.Episode.Title.1080p.WEB-DL-GRP"
-		tc.meta.EpisodeTitle = "Episode Title"
-		tc.meta.SeasonInt = 1
-		tc.meta.EpisodeInt = 1
-		tc.meta.Release = api.ReleaseInfo{
-			Category:   "TV",
-			Resolution: "1080p",
-			Year:       2024,
-		}
-		tc.meta.ExternalMetadata = api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		}
-
-		got := buildUnit3DName("ZNTH", tc.meta, config.TrackerConfig{})
-		expected := "Show.S01E01.2024.1080p.WEB-DL-GRP"
-		if got != expected {
-			t.Fatalf("%s: expected %q, got %q", tc.name, expected, got)
-		}
-	}
-}
-
-func TestBuildZNTHNameExplicitMoviePreservesMovieBranchOverParsedTV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName:  "Show.S01E01.2024.Episode.Title.1080p.WEB-DL-GRP",
-		EpisodeTitle: "Episode Title",
-		ExternalIDs:  api.ExternalIDs{Category: "MOVIE"},
-		SeasonInt:    1,
-		EpisodeInt:   1,
-		Release: api.ReleaseInfo{
-			Category:   "TV",
-			Resolution: "1080p",
-			Year:       2024,
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		},
-	}
-
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Show.S01E01.2025.Episode.Title.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameBlankCategoryUsesParsedMovieCategory(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Example.Movie.2026.1080p.WEB-DL-GRP",
-		Release: api.ReleaseInfo{
-			Category: "MOVIE",
-			Year:     2026,
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2027},
-		},
-	}
-
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Example.Movie.2027.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameMovieYearMismatchNoResolutionHyphenatedTitle(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie - Part One 2024",
-		Release:     api.ReleaseInfo{Year: 2024},
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Movie - Part One 2025"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameMovieYearMismatchNoResolutionGroupSuffix(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie.Title.2024-GRP2024",
-		Release:     api.ReleaseInfo{Year: 2024, Group: "GRP2024"},
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "Movie.Title.2025-GRP2024"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameTVUnicodePrefix(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName:  "\u212aShow.S01E01.Episode.Title.1080p.WEB-DL-GRP",
-		EpisodeTitle: "Episode Title",
-		ExternalIDs:  api.ExternalIDs{Category: "TV"},
-		Release:      api.ReleaseInfo{Resolution: "1080p"},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "\u212aShow.S01E01.1080p.WEB-DL-GRP"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestBuildZNTHNameMovieYearMismatchUnicodeTitle(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "\u212aMovie.2024",
-		Release:     api.ReleaseInfo{Year: 2024},
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			IMDB: &api.IMDBMetadata{Year: 2025},
-		},
-	}
-	got := buildUnit3DName("ZNTH", meta, config.TrackerConfig{})
-	expected := "\u212aMovie.2025"
-	if got != expected {
-		t.Fatalf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestFindZNTHTokenIndexesUnicodeBoundaries(t *testing.T) {
-	got := findZNTHTokenIndexes("Title.\u212a.1080p.Source", "1080p")
-	expected := len("Title.\u212a.")
-	if len(got) != 1 || got[0] != expected {
-		t.Fatalf("expected index %d, got %#v", expected, got)
-	}
-
-	if got := findZNTHTokenIndexes("Title.\u06611080p.Source", "1080p"); len(got) != 0 {
-		t.Fatalf("expected adjacent Unicode digit prefix to reject token, got %#v", got)
-	}
-	if got := findZNTHTokenIndexes("Title.1080p\u0661.Source", "1080p"); len(got) != 0 {
-		t.Fatalf("expected adjacent Unicode digit suffix to reject token, got %#v", got)
-	}
-}
-
-func TestZNTHEmptyTokenInputs(t *testing.T) {
-	name := "Show.S01E01.1080p.WEB-DL-GRP"
-	if got := replaceZNTHEpisodeTitle(name, "", "1080p"); got != name {
-		t.Fatalf("expected empty episode title to leave name unchanged, got %q", got)
-	}
-	if got := findZNTHTokenIndexes(name, " "); got != nil {
-		t.Fatalf("expected empty token indexes to be nil, got %#v", got)
-	}
-}
-
-func TestResolveUnit3DResolutionIDForTrackerRF(t *testing.T) {
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "1440p"}}
-	if got := resolveUnit3DResolutionIDForTracker("RF", meta); got != "10" {
-		t.Fatalf("expected RF 1440p to fall back to 10, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataLSTAdditionalFields(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "LST",
+func TestBuildUnit3DDataOmitsLegacyModQAliasForA4K(t *testing.T) {
+	req := trackers.PreparationInput{
+		Tracker: "A4K",
 		TrackerConfig: config.TrackerConfig{
-			Draft: true,
+			ModQ: true,
 		},
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
+		Meta: api.UploadSubject{
+			ReleaseName: "Movie.2025.2160p.WEB-DL.DD5.1.H264-GRP",
+			Identity:    api.ExternalIdentity{Category: "MOVIE"},
 			Type:        "WEBDL",
-			Edition:     "Director's Cut",
-			Release: api.ReleaseInfo{
-				Resolution: "1080p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if got := data["draft_queue_opt_in"]; got != "1" {
-		t.Fatalf("expected draft_queue_opt_in=1, got %q", got)
-	}
-	if got := data["edition_id"]; got != "2" {
-		t.Fatalf("expected edition_id=2, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerA4K(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "WEBRIP"}
-	_, err := resolveUnit3DTypeIDForTracker("A4K", meta)
-	if err == nil {
-		t.Fatalf("expected unsupported type for A4K WEBRIP")
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerPT(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "WEBRIP"}
-	got, err := resolveUnit3DTypeIDForTracker("PT", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "39" {
-		t.Fatalf("expected PT WEBRIP type_id=39, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataPTAdditionalFields(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "PT",
-		Meta: api.PreparedMetadata{
-			ReleaseName:       "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-			Type:              "WEBDL",
-			AudioLanguages:    []string{"Portuguese"},
-			SubtitleLanguages: []string{"PT-BR", "English"},
 			Release: api.ReleaseInfo{
-				Resolution: "1080p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if got := data["audio_pt"]; got != "1" {
-		t.Fatalf("expected audio_pt=1, got %q", got)
-	}
-	if got := data["legenda_pt"]; got != "0" {
-		t.Fatalf("expected legenda_pt=0 when only BR Portuguese subtitles are present, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerSTCPack(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Type:   "WEBDL",
-		TVPack: true,
-		Release: api.ReleaseInfo{
-			Resolution: "1080p",
-		},
-	}
-	got, err := resolveUnit3DTypeIDForTracker("STC", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "13" {
-		t.Fatalf("expected STC HD web pack type_id=13, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerTLZ(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}, TVPack: true}
-	got, err := resolveUnit3DTypeIDForTracker("TLZ", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "4" {
-		t.Fatalf("expected TLZ TV pack type_id=4, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTOS(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}, TVPack: true, Tag: "-vostfr"}
-	if got := resolveUnit3DCategoryIDForTracker("TOS", meta); got != "9" {
-		t.Fatalf("expected TOS vostfr TV pack category_id=9, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerBLU(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "ENCODE"}
-	got, err := resolveUnit3DTypeIDForTracker("BLU", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "12" {
-		t.Fatalf("expected BLU ENCODE type_id=12, got %q", got)
-	}
-}
-
-func TestResolveUnit3DResolutionIDForTrackerBLU(t *testing.T) {
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "2160p"}}
-	if got := resolveUnit3DResolutionIDForTracker("BLU", meta); got != "1" {
-		t.Fatalf("expected BLU 2160p resolution_id=1, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerITTFromName(t *testing.T) {
-	meta := api.PreparedMetadata{ReleaseName: "Movie.2025.1080p.DLMux-GRP", Type: "WEBDL"}
-	got, err := resolveUnit3DTypeIDForTracker("ITT", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "27" {
-		t.Fatalf("expected ITT DLMux type_id=27, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerSHRI(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "REMUX"}
-	got, err := resolveUnit3DTypeIDForTracker("SHRI", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "7" {
-		t.Fatalf("expected SHRI REMUX type_id=7, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerIHDAnimeMovie(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "MOVIE"}, Anime: true}
-	if got := resolveUnit3DCategoryIDForTracker("IHD", meta); got != "4" {
-		t.Fatalf("expected IHD anime movie category_id=4, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerR4EDocumentaryTV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "TV"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{GenreIDs: "99,18"},
-		},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("R4E", meta); got != "2" {
-		t.Fatalf("expected R4E documentary tv category_id=2, got %q", got)
-	}
-}
-
-func TestResolveUnit3DResolutionIDForTrackerUTPDefaultOther(t *testing.T) {
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "720p"}}
-	if got := resolveUnit3DResolutionIDForTracker("UTP", meta); got != "11" {
-		t.Fatalf("expected UTP 720p resolution fallback=11, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataOmitsLegacyModQAliasForA4K(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "A4K",
-		TrackerConfig: config.TrackerConfig{
-			ModQ: true,
-		},
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.2160p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			Release: api.ReleaseInfo{
-				Resolution: "2160p",
+				Resolution: "2160p",
 			},
 		},
 	}
@@ -1257,633 +735,3 @@ func TestBuildUnit3DDataOmitsLegacyModQAliasForA4K(t *testing.T) {
 		t.Fatalf("did not expect legacy modq alias for A4K")
 	}
 }
-
-func TestResolveUnit3DTypeIDForTrackerTIKDiscMarker(t *testing.T) {
-	meta := api.PreparedMetadata{ReleaseName: "Movie.2025.BD50.COMPLETE-GRP", DiscType: "BDMV"}
-	got, err := resolveUnit3DTypeIDForTracker("TIK", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "5" {
-		t.Fatalf("expected TIK BD50 type_id=5, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerTIKNonDiscFails(t *testing.T) {
-	meta := api.PreparedMetadata{Type: "WEBDL", DiscType: ""}
-	_, err := resolveUnit3DTypeIDForTracker("TIK", meta)
-	if err == nil {
-		t.Fatalf("expected error for TIK when disc type cannot be resolved")
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerLDUAnimeTV(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "TV"}, Anime: true}
-	if got := resolveUnit3DCategoryIDForTracker("LDU", meta); got != "9" {
-		t.Fatalf("expected LDU anime tv category_id=9, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerLDUNonEnglishMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		AudioLanguages:    []string{"Portuguese"},
-		SubtitleLanguages: []string{"Portuguese"},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("LDU", meta); got != "22" {
-		t.Fatalf("expected LDU non-english movie category_id=22, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameLDUUsesFirstParseableLanguages(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName:       "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		AudioLanguages:    []string{"", "Japanese", "English"},
-		SubtitleLanguages: []string{"", "English"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
-		},
-	}
-
-	got := buildUnit3DName("LDU", meta, config.TrackerConfig{})
-	if !strings.Contains(got, "[JPN]") {
-		t.Fatalf("expected first parseable audio language suffix, got %q", got)
-	}
-	if !strings.Contains(got, "[Subs ENG]") {
-		t.Fatalf("expected first parseable subtitle language suffix, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataAddsSHRINumericIDs(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "SHRI",
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			Region:      "3",
-			Distributor: "42",
-			Release: api.ReleaseInfo{
-				Resolution: "1080p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if got := data["region_id"]; got != "3" {
-		t.Fatalf("expected SHRI region_id=3, got %q", got)
-	}
-	if got := data["distributor_id"]; got != "42" {
-		t.Fatalf("expected SHRI distributor_id=42, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerACM(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:   "BDMV",
-		UHD:        "UHD",
-		SourceSize: 60 * (1 << 30),
-	}
-	got, err := resolveUnit3DTypeIDForTracker("ACM", meta)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got != "2" {
-		t.Fatalf("expected ACM UHD 66 type_id=2, got %q", got)
-	}
-}
-
-func TestResolveUnit3DResolutionIDForTrackerACM(t *testing.T) {
-	meta := api.PreparedMetadata{Release: api.ReleaseInfo{Resolution: "1080i"}}
-	if got := resolveUnit3DResolutionIDForTracker("ACM", meta); got != "2" {
-		t.Fatalf("expected ACM 1080i resolution_id=2, got %q", got)
-	}
-}
-
-func TestBuildUnit3DDataACMKeywordsAndNumericIDs(t *testing.T) {
-	req := trackers.UploadRequest{
-		Tracker: "ACM",
-		Meta: api.PreparedMetadata{
-			ReleaseName: "Movie.2025.1080p.WEB-DL.DD5.1.H264-GRP",
-			ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-			Type:        "WEBDL",
-			Region:      "3",
-			Distributor: "42",
-			ExternalMetadata: api.ExternalMetadata{
-				TMDB: &api.TMDBMetadata{Keywords: "one, two words, three,four,five,six,seven,eight,nine,ten,eleven,twelve"},
-			},
-			Release: api.ReleaseInfo{
-				Resolution: "1080p",
-			},
-		},
-	}
-
-	data, err := buildUnit3DData(req, "name", "desc", "mi", "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if got := data["keywords"]; got != "one, three, four, five, six, seven, eight, nine, ten, eleven" {
-		t.Fatalf("unexpected ACM keywords %q", got)
-	}
-	if got := data["region_id"]; got != "3" {
-		t.Fatalf("expected ACM region_id=3, got %q", got)
-	}
-	if got := data["distributor_id"]; got != "42" {
-		t.Fatalf("expected ACM distributor_id=42, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameACM(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie.2024.1080p.BluRay.REMUX.H.265.DD+ 5.1 Atmos-GRP",
-		Audio:       "DD+ 5.1",
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{Title: "Movie", OriginalTitle: "Original Movie"},
-		},
-		SubtitleLanguages: []string{"Japanese"},
-	}
-	got := buildUnit3DName("ACM", meta, config.TrackerConfig{})
-	if !strings.Contains(got, "Movie / Original Movie") {
-		t.Fatalf("expected ACM original title injection, got %q", got)
-	}
-	if strings.Contains(got, "H.265") || strings.Contains(got, " Atmos") {
-		t.Fatalf("expected ACM codec/audio cleanup, got %q", got)
-	}
-	if !strings.Contains(got, "[Jpn subs only]") {
-		t.Fatalf("expected ACM subtitle suffix, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameULCXRemovesHybridFromWebDV(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ReleaseName: "Movie 2026 Hybrid 1080p WEB-DL DDP5.1 DV H.265-GRP",
-		Type:        "WEBDL",
-		Edition:     "Hybrid",
-		WebDV:       true,
-	}
-	got := buildUnit3DName("ULCX", meta, config.TrackerConfig{})
-	if strings.Contains(got, "Hybrid") {
-		t.Fatalf("expected Hybrid removed for ULCX WEB-DL WebDV, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameRHDBuildsFromTMDBWhenBaseNameBlank(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Type:           "WEBDL",
-		Tag:            "-GRP",
-		Audio:          "DD+ 5.1",
-		VideoEncode:    "H.264",
-		AudioLanguages: []string{"German"},
-		Release: api.ReleaseInfo{
-			Resolution: "1080p",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Year:            2025,
-				LocalizedTitles: map[string]string{"de": "Beispiel Film"},
-			},
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	want := "Beispiel Film 2025 GERMAN 1080p WEB-DL DD+ 5.1 H.264-GRP"
-	if got != want {
-		t.Fatalf("expected RHD TMDB-derived name %q, got %q", want, got)
-	}
-}
-
-func TestBuildUnit3DNameRHDUsesTMDBTitleFallback(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Type:           "WEBDL",
-		Tag:            "-GRP",
-		AudioLanguages: []string{"English"},
-		Release: api.ReleaseInfo{
-			Resolution: "720p",
-		},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{
-				Title: "TMDB Title",
-				Year:  2024,
-			},
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	if !strings.HasPrefix(got, "TMDB Title 2024 ENGLISH 720p WEB-DL") {
-		t.Fatalf("expected RHD TMDB title fallback, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameRHDFullDiscOmitsLanguageTag(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ReleaseName:    "Movie 2024 1080p Blu-ray AVC DTS-HD MA 5.1-GRP",
-		Type:           "DISC",
-		Region:         "GER",
-		Tag:            "-GRP",
-		Audio:          "DTS-HD MA 5.1",
-		VideoCodec:     "AVC",
-		AudioLanguages: []string{"German", "English"},
-		Release: api.ReleaseInfo{
-			Title:      "Movie",
-			Year:       2024,
-			Resolution: "1080p",
-			Source:     "Blu-ray",
-			Size:       "BD50",
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	want := "Movie 2024 1080p COMPLETE GER Blu-ray BD50 DTS-HD MA 5.1 AVC-GRP"
-	if got != want {
-		t.Fatalf("expected RHD full-disc name %q, got %q", want, got)
-	}
-	if strings.Contains(got, "GERMAN") || strings.Contains(got, " DL") || strings.Contains(got, " ML") {
-		t.Fatalf("expected RHD full-disc name to omit language tag, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameRHDFullDiscUsesDiscTypeWhenTypeEmpty(t *testing.T) {
-	t.Parallel()
-
-	dir := t.TempDir()
-	mediaInfoPath := filepath.Join(dir, "mediainfo.txt")
-	if err := os.WriteFile(mediaInfoPath, []byte("General\nComplete name: Movie"), 0o600); err != nil {
-		t.Fatalf("write mediainfo fixture: %v", err)
-	}
-	torrentPath := filepath.Join(dir, "movie.torrent")
-	if err := os.WriteFile(torrentPath, []byte("torrent"), 0o600); err != nil {
-		t.Fatalf("write torrent fixture: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		ReleaseName:            "Movie.2024.1080p.COMPLETE.Blu-ray.BD50.DTS-HD.MA.5.1.AVC-GRP",
-		DiscType:               " bdmv ",
-		Region:                 "GER",
-		Tag:                    "-GRP",
-		Audio:                  "DTS-HD MA 5.1",
-		VideoCodec:             "AVC",
-		AudioLanguages:         []string{"German", "English"},
-		ValidMediaInfoSettings: true,
-		MediaInfoTextPath:      mediaInfoPath,
-		TorrentPath:            torrentPath,
-		ExternalIDs:            api.ExternalIDs{Category: "MOVIE"},
-		Release: api.ReleaseInfo{
-			Title:      "Movie",
-			Year:       2024,
-			Resolution: "1080p",
-			Source:     "Blu-ray",
-			Size:       "BD50",
-		},
-	}
-
-	want := "Movie 2024 1080p COMPLETE GER Blu-ray BD50 DTS-HD MA 5.1 AVC-GRP"
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	if got != want {
-		t.Fatalf("expected RHD DiscType-only full-disc name %q, got %q", want, got)
-	}
-	if strings.Contains(got, "GERMAN") || strings.Contains(got, " DL") || strings.Contains(got, " ML") {
-		t.Fatalf("expected RHD DiscType-only full-disc name to omit language tag, got %q", got)
-	}
-
-	entry, err := buildUploadDryRunUnit3D(context.Background(), trackers.UploadRequest{
-		Tracker: "RHD",
-		Meta:    meta,
-		TrackerConfig: config.TrackerConfig{
-			APIKey: "test-key",
-		},
-		Assets: &trackers.DescriptionAssets{
-			Description: "description",
-			Final:       true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("build RHD dry-run: %v", err)
-	}
-	if entry.ReleaseName != want {
-		t.Fatalf("expected RHD dry-run release name %q, got %q", want, entry.ReleaseName)
-	}
-	if entry.Payload["name"] != want {
-		t.Fatalf("expected RHD dry-run payload name %q, got %q", want, entry.Payload["name"])
-	}
-}
-
-func TestResolveRHDTypeAndSourcePreservesExistingTypeOrdering(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		meta api.PreparedMetadata
-		want []string
-	}{
-		{
-			name: "webdl",
-			meta: api.PreparedMetadata{Type: "WEBDL"},
-			want: []string{"WEB-DL"},
-		},
-		{
-			name: "encode",
-			meta: api.PreparedMetadata{Type: "ENCODE", Source: "Blu-ray"},
-			want: []string{"Blu-ray"},
-		},
-		{
-			name: "remux",
-			meta: api.PreparedMetadata{Type: "REMUX", Source: "Blu-ray"},
-			want: []string{"Blu-ray", "REMUX"},
-		},
-		{
-			name: "disc type populated",
-			meta: api.PreparedMetadata{
-				Type:    "DISC",
-				Region:  "GER",
-				Release: api.ReleaseInfo{Source: "Blu-ray", Size: "BD50"},
-			},
-			want: []string{"COMPLETE", "GER", "Blu-ray", "BD50"},
-		},
-		{
-			name: "empty type non disc",
-			meta: api.PreparedMetadata{},
-			want: nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got := resolveRHDTypeAndSource(tt.meta)
-			if strings.Join(got, "|") != strings.Join(tt.want, "|") {
-				t.Fatalf("expected %v, got %v", tt.want, got)
-			}
-		})
-	}
-}
-
-func TestBuildUnit3DNameRHDDetectsMarkerTokensWithBroadDelimiters(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ReleaseName:    "Marker.Movie.2024.[INTERNAL].(UPSCALED).1080p.WEB-DL.DDP5.1.H.264-GRP",
-		Type:           "WEBDL",
-		Tag:            "-GRP",
-		Audio:          "DDP5.1",
-		VideoEncode:    "H.264",
-		AudioLanguages: []string{"German"},
-		Release: api.ReleaseInfo{
-			Title:      "Marker Movie",
-			Year:       2024,
-			Resolution: "1080p",
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	want := "Marker Movie 2024 GERMAN 1080p UPSCALE WEB-DL DDP5.1 H.264 iNTERNAL-GRP"
-	if got != want {
-		t.Fatalf("expected RHD marker tokens with broad delimiters, got %q", got)
-	}
-}
-
-func TestBuildUnit3DNameRHDIgnoresMarkerSubstringsAndGroupTag(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		ReleaseName:    "Marker.Movie.2024.Regradedness.Internalized.Lineage.1080p.WEB-DL.DDP5.1.H.264-LD",
-		Type:           "WEBDL",
-		Tag:            "-LD",
-		Audio:          "DDP5.1",
-		VideoEncode:    "H.264",
-		AudioLanguages: []string{"English"},
-		Release: api.ReleaseInfo{
-			Title:      "Marker Movie",
-			Year:       2024,
-			Resolution: "1080p",
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	for _, marker := range []string{"REGRADED", "UPSCALE", "iNTERNAL", "DUBBED"} {
-		if strings.Contains(got, marker) {
-			t.Fatalf("expected marker substring/group tag not to emit %s, got %q", marker, got)
-		}
-	}
-}
-
-func TestBuildUnit3DNameRHDEmitsPreparedHDR(t *testing.T) {
-	t.Parallel()
-
-	meta := api.PreparedMetadata{
-		Type:           "WEBDL",
-		Tag:            "-GRP",
-		Audio:          "DDP5.1",
-		HDR:            "DV HDR",
-		VideoEncode:    "H.265",
-		AudioLanguages: []string{"German"},
-		Release: api.ReleaseInfo{
-			Title:      "HDR Movie",
-			Year:       2026,
-			Resolution: "2160p",
-		},
-	}
-
-	got := buildUnit3DName("RHD", meta, config.TrackerConfig{})
-	want := "HDR Movie 2026 GERMAN 2160p WEB-DL DDP5.1 DV HDR H.265-GRP"
-	if got != want {
-		t.Fatalf("expected RHD name to include prepared HDR value %q, got %q", want, got)
-	}
-}
-
-func TestResolveRHDLanguageCountsUniqueValidAudioLanguages(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		language []string
-		want     string
-	}{
-		{
-			name:     "blank ignored",
-			language: []string{"", "French", "   "},
-			want:     "FRENCH",
-		},
-		{
-			name:     "duplicate aliases ignored",
-			language: []string{"English", "eng", "English"},
-			want:     "ENGLISH",
-		},
-		{
-			name:     "german aliases ignored",
-			language: []string{"German", "deu", "de-DE"},
-			want:     "GERMAN",
-		},
-		{
-			name:     "dual real languages tagged",
-			language: []string{"English", "French"},
-			want:     "ENGLISH DL",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got := resolveRHDLanguage(api.PreparedMetadata{AudioLanguages: tt.language})
-			if got != tt.want {
-				t.Fatalf("expected %q, got %q", tt.want, got)
-			}
-		})
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTIKForeignMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginalLanguage: "fr"},
-		},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("TIK", meta); got != "3" {
-		t.Fatalf("expected TIK foreign movie category_id=3, got %q", got)
-	}
-}
-
-func TestEnsureUnit3DDVDVOBDescriptionAppendsForOverride(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:            "DVD",
-		DVDVOBMediaInfoText: "VOB_CONTENT",
-	}
-
-	result := ensureUnit3DDVDVOBDescription("override description", meta)
-	if !strings.Contains(result, "override description") {
-		t.Fatalf("expected override description to be kept, got %q", result)
-	}
-	if !strings.Contains(result, "[spoiler=VOB MediaInfo][code]VOB_CONTENT[/code][/spoiler]") {
-		t.Fatalf("expected dvd vob mediainfo block, got %q", result)
-	}
-}
-
-func TestEnsureUnit3DDVDVOBDescriptionAvoidsDuplicate(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:            "DVD",
-		DVDVOBMediaInfoText: "VOB_CONTENT",
-	}
-	block := descriptionunit3d.DVDVOBMediaInfoBlock(meta)
-	description := "override description\n\n" + block
-
-	result := ensureUnit3DDVDVOBDescription(description, meta)
-	if strings.Count(result, "[spoiler=VOB MediaInfo][code]") != 1 {
-		t.Fatalf("expected single dvd vob mediainfo block, got %q", result)
-	}
-}
-
-func TestLoadUnit3DMediaUsesIFOTextPathForDVD(t *testing.T) {
-	root := t.TempDir()
-	miPath := filepath.Join(root, "mediainfo.txt")
-	if err := os.WriteFile(miPath, []byte("IFO_MEDIAINFO"), 0o600); err != nil {
-		t.Fatalf("write mediainfo: %v", err)
-	}
-
-	meta := api.PreparedMetadata{
-		DiscType:            "DVD",
-		MediaInfoTextPath:   miPath,
-		DVDVOBMediaInfoText: "VOB_MEDIAINFO",
-	}
-
-	mediainfo, bdinfo, err := loadUnit3DMedia(meta, "", api.NopLogger{})
-	if err != nil {
-		t.Fatalf("load unit3d media: %v", err)
-	}
-	if mediainfo != "IFO_MEDIAINFO" {
-		t.Fatalf("expected IFO mediainfo from MediaInfoTextPath, got %q", mediainfo)
-	}
-	if bdinfo != "" {
-		t.Fatalf("expected empty bdinfo for DVD fallback path, got %q", bdinfo)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTIKAsianMovie(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		AudioLanguages:    []string{"English"},
-		SubtitleLanguages: []string{"English"},
-		ExternalMetadata: api.ExternalMetadata{
-			TMDB: &api.TMDBMetadata{OriginalLanguage: "en", OriginCountry: []string{"JP"}},
-		},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("TIK", meta); got != "6" {
-		t.Fatalf("expected TIK asian movie category_id=6, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTIKOperaTV(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:       api.ExternalIDs{Category: "TV"},
-		AudioLanguages:    []string{"English"},
-		SubtitleLanguages: []string{"English"},
-		Release:           api.ReleaseInfo{Genre: "Opera"},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("TIK", meta); got != "5" {
-		t.Fatalf("expected TIK opera tv category_id=5, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTIKOverrideForeignMovie(t *testing.T) {
-	forceForeign := true
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "MOVIE"},
-		TrackerSiteOverrides: api.TrackerSiteOverrides{
-			TIK: api.TIKOverrides{
-				Foreign: &forceForeign,
-			},
-		},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("TIK", meta); got != "3" {
-		t.Fatalf("expected TIK foreign override movie category_id=3, got %q", got)
-	}
-}
-
-func TestResolveUnit3DCategoryIDForTrackerTIKOverrideAsianMovie(t *testing.T) {
-	forceAsian := true
-	forceForeign := false
-	meta := api.PreparedMetadata{
-		ExternalIDs:       api.ExternalIDs{Category: "MOVIE"},
-		AudioLanguages:    []string{"English"},
-		SubtitleLanguages: []string{"English"},
-		TrackerSiteOverrides: api.TrackerSiteOverrides{
-			TIK: api.TIKOverrides{
-				Foreign: &forceForeign,
-				Asian:   &forceAsian,
-			},
-		},
-	}
-	if got := resolveUnit3DCategoryIDForTracker("TIK", meta); got != "6" {
-		t.Fatalf("expected TIK asian override movie category_id=6, got %q", got)
-	}
-}
-
-func TestResolveUnit3DTypeIDForTrackerTIKOverrideDiscType(t *testing.T) {
-	discType := "BD66"
-	meta := api.PreparedMetadata{
-		DiscType: "BDMV",
-		TrackerSiteOverrides: api.TrackerSiteOverrides{
-			TIK: api.TIKOverrides{
-				DiscType: &discType,
-			},
-		},
-	}
-	got := resolveUnit3DTIKTypeID(meta)
-	if got != "4" {
-		t.Fatalf("expected TIK BD66 override type_id=4, got %q", got)
-	}
-}
diff --git a/internal/trackers/impl/unit3d/utp.go b/internal/trackers/impl/unit3d/utp.go
deleted file mode 100644
index cf762068..00000000
--- a/internal/trackers/impl/unit3d/utp.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteUTPProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{
-		resolveTypeID:       resolveUnit3DUTPTypeID,
-		resolveResolutionID: resolveUnit3DUTPResolutionID,
-	}
-}
-
-func resolveUnit3DUTPTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"ENCODE": "3",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-	}
-	typeID := mapping[inferUnit3DType(meta)]
-	if typeID == "" {
-		return "3"
-	}
-	return typeID
-}
-
-func resolveUnit3DUTPResolutionID(meta api.PreparedMetadata) string {
-	resolution := resolveResolution(meta)
-	mapping := map[string]string{
-		"4320p": "1",
-		"2160p": "2",
-		"1080p": "3",
-		"1080i": "4",
-	}
-	if value, ok := mapping[resolution]; ok {
-		return value
-	}
-	return "11"
-}
diff --git a/internal/trackers/impl/unit3d/wrap_errors.go b/internal/trackers/impl/unit3d/wrap_errors.go
deleted file mode 100644
index 6ffe8432..00000000
--- a/internal/trackers/impl/unit3d/wrap_errors.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "fmt"
-
-func wrapTrackerResult[T any](value T, err error) (T, error) {
-	if err != nil {
-		return value, fmt.Errorf("trackers: %w", err)
-	}
-	return value, nil
-}
diff --git a/internal/trackers/impl/unit3d/yus.go b/internal/trackers/impl/unit3d/yus.go
deleted file mode 100644
index 4af5ea18..00000000
--- a/internal/trackers/impl/unit3d/yus.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-func siteYUSProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DYUSTypeID}
-}
-
-func resolveUnit3DYUSTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "17",
-		"REMUX":  "2",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-		"ENCODE": "3",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
diff --git a/internal/trackers/impl/unit3d/znth.go b/internal/trackers/impl/unit3d/znth.go
deleted file mode 100644
index 73b83be7..00000000
--- a/internal/trackers/impl/unit3d/znth.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3d
-
-import "github.com/autobrr/upbrr/pkg/api"
-
-// siteZNTHProfile registers ZNTH's custom Unit3D type-id resolver.
-func siteZNTHProfile() unit3DSiteProfile {
-	return unit3DSiteProfile{resolveTypeID: resolveUnit3DZNTHTypeID}
-}
-
-// resolveUnit3DZNTHTypeID maps inferred release types to ZNTH type_id values.
-// Unsupported or unknown types return an empty id for the shared Unit3D resolver
-// to reject.
-func resolveUnit3DZNTHTypeID(meta api.PreparedMetadata) string {
-	mapping := map[string]string{
-		"DISC":   "1",
-		"REMUX":  "2",
-		"ENCODE": "3",
-		"DVDRIP": "11",
-		"WEBDL":  "4",
-		"WEBRIP": "5",
-		"HDTV":   "6",
-	}
-	return mapping[inferUnit3DType(meta)]
-}
diff --git a/internal/trackers/impl/unit3d_profiles_test.go b/internal/trackers/impl/unit3d_profiles_test.go
new file mode 100644
index 00000000..32443300
--- /dev/null
+++ b/internal/trackers/impl/unit3d_profiles_test.go
@@ -0,0 +1,194 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package impl
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/a4k"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/aither"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/blu"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ihd"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/itt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/ldu"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/lst"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/oe"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/otw"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/pt"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/r4e"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/rf"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/shri"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/stc"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/tlz"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/tos"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/utp"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/yus"
+	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/sites/znth"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestExplicitUnit3DProfilesPreserveResolvers(t *testing.T) {
+	tests := []struct {
+		name    string
+		profile unit3d.Profile
+		meta    api.UploadSubject
+		want    string
+	}{
+		{
+			name:    "A4K rejects WEBRIP",
+			profile: a4k.Profile(),
+			meta:    api.UploadSubject{Type: "WEBRIP"},
+			want:    "",
+		},
+		{
+			name:    "ITT DLMux",
+			profile: itt.Profile(),
+			meta:    api.UploadSubject{ReleaseName: "Example.Release.2026.1080p.DLMux-GRP", Type: "WEBDL"},
+			want:    "27",
+		},
+		{
+			name:    "OE HEVC",
+			profile: oe.Profile(),
+			meta:    api.UploadSubject{Type: "WEBRIP", VideoCodec: "HEVC"},
+			want:    "10",
+		},
+		{
+			name:    "OTW DVD",
+			profile: otw.Profile(),
+			meta:    api.UploadSubject{DiscType: "DVD", Type: "REMUX"},
+			want:    "7",
+		},
+		{
+			name:    "STC pack",
+			profile: stc.Profile(),
+			meta: api.UploadSubject{
+				Type:    "WEBDL",
+				TVPack:  true,
+				Release: api.ReleaseInfo{Resolution: "1080p"},
+			},
+			want: "13",
+		},
+		{
+			name:    "TLZ pack",
+			profile: tlz.Profile(),
+			meta:    api.UploadSubject{Identity: api.ExternalIdentity{Category: "TV"}, TVPack: true},
+			want:    "4",
+		},
+		{
+			name:    "ZNTH DVDRIP",
+			profile: znth.Profile(),
+			meta:    api.UploadSubject{Type: "DVDRIP"},
+			want:    "11",
+		},
+		{
+			name:    "RF encode",
+			profile: rf.Profile(),
+			meta:    api.UploadSubject{Type: "ENCODE"},
+			want:    "41",
+		},
+		{
+			name:    "YUS disc",
+			profile: yus.Profile(),
+			meta:    api.UploadSubject{Type: "DISC"},
+			want:    "17",
+		},
+		{
+			name:    "BLU encode",
+			profile: blu.Profile(),
+			meta:    api.UploadSubject{Type: "ENCODE"},
+			want:    "12",
+		},
+		{
+			name:    "PT WEBRIP",
+			profile: pt.Profile(),
+			meta:    api.UploadSubject{Type: "WEBRIP"},
+			want:    "39",
+		},
+		{
+			name:    "SHRI remux",
+			profile: shri.Profile(),
+			meta:    api.UploadSubject{Type: "REMUX"},
+			want:    "7",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if got := test.profile.Site.ResolveTypeID(test.meta); got != test.want {
+				t.Fatalf("type ID = %q, want %q", got, test.want)
+			}
+		})
+	}
+	if got := rf.Profile().Site.ResolveResolutionID(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "1440p"}}); got != "10" {
+		t.Fatalf("RF resolution ID = %q, want 10", got)
+	}
+	if got := utp.Profile().Site.ResolveResolutionID(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "720p"}}); got != "11" {
+		t.Fatalf("UTP resolution ID = %q, want 11", got)
+	}
+	if got := blu.Profile().Site.ResolveResolutionID(api.UploadSubject{Release: api.ReleaseInfo{Resolution: "2160p"}}); got != "1" {
+		t.Fatalf("BLU resolution ID = %q, want 1", got)
+	}
+	if got := ihd.Profile().Site.ResolveCategoryID(api.UploadSubject{Identity: api.ExternalIdentity{Category: "MOVIE"}, Anime: true}); got != "4" {
+		t.Fatalf("IHD category ID = %q, want 4", got)
+	}
+	if got := tos.Profile().Site.ResolveCategoryID(api.UploadSubject{
+		Identity: api.ExternalIdentity{Category: "TV"},
+		TVPack:   true,
+		Tag:      "-vostfr",
+	}); got != "9" {
+		t.Fatalf("TOS category ID = %q, want 9", got)
+	}
+	if got := ldu.Profile().Site.ResolveCategoryID(api.UploadSubject{Identity: api.ExternalIdentity{Category: "TV"}, Anime: true}); got != "9" {
+		t.Fatalf("LDU anime category ID = %q, want 9", got)
+	}
+	if got := ldu.Profile().Site.ResolveCategoryID(api.UploadSubject{
+		Identity:          api.ExternalIdentity{Category: "MOVIE"},
+		AudioLanguages:    []string{"Portuguese"},
+		SubtitleLanguages: []string{"Portuguese"},
+	}); got != "22" {
+		t.Fatalf("LDU non-English category ID = %q, want 22", got)
+	}
+	data := map[string]string{}
+	pt.Profile().Site.ApplyAdditionalPayload(trackers.PreparationInput{Meta: api.UploadSubject{AudioLanguages: []string{"Portuguese"}, SubtitleLanguages: []string{"PT-BR", "English"}}}, data)
+	if data["audio_pt"] != "1" || data["legenda_pt"] != "0" {
+		t.Fatalf("PT language payload = %#v", data)
+	}
+	shriData := map[string]string{}
+	shri.Profile().Site.ApplyAdditionalPayload(trackers.PreparationInput{Meta: api.UploadSubject{Region: "3", Distributor: "42"}}, shriData)
+	if shriData["region_id"] != "3" || shriData["distributor_id"] != "42" {
+		t.Fatalf("SHRI payload = %#v", shriData)
+	}
+	description := shri.Profile().Site.FinalizeDescription("Base description", api.UploadSubject{Release: api.ReleaseInfo{Group: "island"}})
+	if !strings.Contains(description, "Release Shareisland") || !strings.Contains(description, "Base description") {
+		t.Fatalf("SHRI description = %q", description)
+	}
+	lstData := map[string]string{}
+	lst.Profile().Site.ApplyAdditionalPayload(trackers.PreparationInput{TrackerConfig: config.TrackerConfig{Draft: true}, Meta: api.UploadSubject{Edition: "Director's Cut"}}, lstData)
+	if lstData["draft_queue_opt_in"] != "1" || lstData["edition_id"] != "2" {
+		t.Fatalf("LST payload = %#v", lstData)
+	}
+	aitherData := map[string]string{}
+	aither.Profile().Site.ApplyAdditionalPayload(trackers.PreparationInput{Meta: api.UploadSubject{HDR: "HDR10+ DV"}}, aitherData)
+	if aitherData["hdr10p"] != "1" || aitherData["dv"] != "1" {
+		t.Fatalf("AITHER HDR payload = %#v", aitherData)
+	}
+	aitherMeta := api.UploadSubject{
+		ReleaseName: "Example.Release.2020.DVD.DVDRIP.AAC.XVID-GRP",
+		Release:     api.ReleaseInfo{Year: 2020, Resolution: "480p"},
+		Type:        "DVDRIP",
+		Source:      "DVD",
+		Audio:       "AAC 2.0",
+		VideoEncode: "XVID",
+	}
+	if got := aither.Profile().Site.BuildName(aitherMeta, config.TrackerConfig{}); got == "" || got == aitherMeta.ReleaseName {
+		t.Fatalf("AITHER name = %q", got)
+	}
+	r4eMeta := api.UploadSubject{Identity: api.ExternalIdentity{Category: "TV"}, ProviderMetadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{GenreIDs: "99,18"}}}
+	if got := r4e.Profile().Site.ResolveCategoryID(r4eMeta); got != "2" {
+		t.Fatalf("R4E category ID = %q, want 2", got)
+	}
+}
diff --git a/internal/trackers/internal_groups.go b/internal/trackers/internal_groups.go
index 3e7570b8..80e9b81b 100644
--- a/internal/trackers/internal_groups.go
+++ b/internal/trackers/internal_groups.go
@@ -10,7 +10,8 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func IsInternalGroup(cfg config.Config, tracker string, meta api.PreparedMetadata) bool {
+// IsInternalGroup reports whether meta's release group is configured as internal for tracker.
+func IsInternalGroup(cfg config.Config, tracker string, meta api.UploadSubject) bool {
 	if strings.TrimSpace(meta.Tag) == "" {
 		return false
 	}
diff --git a/internal/trackers/internal_groups_test.go b/internal/trackers/internal_groups_test.go
index cb6ce6b5..2d0a6a2f 100644
--- a/internal/trackers/internal_groups_test.go
+++ b/internal/trackers/internal_groups_test.go
@@ -24,13 +24,13 @@ func TestIsInternalGroup(t *testing.T) {
 		},
 	}
 
-	if !IsInternalGroup(cfg, "MTV", api.PreparedMetadata{Tag: "-GroupA"}) {
+	if !IsInternalGroup(cfg, "MTV", api.UploadSubject{Tag: "-GroupA"}) {
 		t.Fatalf("expected group to be internal")
 	}
-	if IsInternalGroup(cfg, "MTV", api.PreparedMetadata{Tag: "-Other"}) {
+	if IsInternalGroup(cfg, "MTV", api.UploadSubject{Tag: "-Other"}) {
 		t.Fatalf("expected group to be non-internal")
 	}
-	if IsInternalGroup(cfg, "BHD", api.PreparedMetadata{Tag: "-GroupA"}) {
+	if IsInternalGroup(cfg, "BHD", api.UploadSubject{Tag: "-GroupA"}) {
 		t.Fatalf("expected missing tracker to be non-internal")
 	}
 }
diff --git a/internal/trackers/media.go b/internal/trackers/media.go
index 69db1399..686a277a 100644
--- a/internal/trackers/media.go
+++ b/internal/trackers/media.go
@@ -9,23 +9,24 @@ import (
 	"strings"
 
 	"github.com/autobrr/upbrr/internal/metadata/metautil"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackers/impl/commonhttp"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-// ReadBDInfo reads the BDInfo from the given path.
-func ReadBDInfo(dbPath string, meta api.PreparedMetadata) (string, error) {
+// ReadBDInfo reads the selected BDMV playlist summary from the release-scoped
+// temporary directory. Missing selections and missing or unstatable artifacts
+// return empty without error; directory-resolution and read failures are returned.
+func ReadBDInfo(dbPath string, meta api.UploadSubject) (string, error) {
 	tmpRoot, err := db.Subdir(dbPath, "tmp")
 	if err != nil {
 		return "", fmt.Errorf("trackers: resolve tmp root: %w", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", fmt.Errorf("trackers: resolve release tmp dir: %w", err)
 	}
-	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylist(meta))
+	path := paths.BDMVSummaryPath(tmpDir, paths.PrimaryBDMVPlaylistFor(meta.SelectedBDMVPlaylists))
 	if strings.TrimSpace(path) == "" {
 		return "", nil
 	}
@@ -35,13 +36,23 @@ func ReadBDInfo(dbPath string, meta api.PreparedMetadata) (string, error) {
 	return readTextFile(path)
 }
 
-// ReadBDinfoOrMediaInfo reads the BDInfo if the disc type is BDMV, otherwise it reads the MediaInfoTextPath.
-func ReadBDinfoOrMediaInfo(dbPath string, meta api.PreparedMetadata) string {
+// ReadBDinfoOrMediaInfo returns BDMV summary text or the first available general
+// or DVD-VOB MediaInfo report. Artifact resolution and read errors are treated
+// as missing text.
+func ReadBDinfoOrMediaInfo(dbPath string, meta api.UploadSubject) string {
 	if strings.EqualFold(strings.TrimSpace(meta.DiscType), "BDMV") {
 		bdinfo, _ := ReadBDInfo(dbPath, meta)
 		return strings.TrimSpace(bdinfo)
 	}
-	return metautil.FirstNonEmptyTrimmed(commonhttp.ReadOptionalFile(meta.MediaInfoTextPath), commonhttp.ReadOptionalFile(meta.DVDVOBMediaInfoText))
+	return metautil.FirstNonEmptyTrimmed(readOptionalTextFile(meta.MediaInfoTextPath), readOptionalTextFile(meta.DVDVOBMediaInfoText))
+}
+
+func readOptionalTextFile(path string) string {
+	payload, err := readTextFile(path)
+	if err != nil {
+		return ""
+	}
+	return payload
 }
 
 // existsFile checks if a file exists.
diff --git a/internal/trackers/metadata_requirements.go b/internal/trackers/metadata_requirements.go
index 6b9d2c49..b9e5023a 100644
--- a/internal/trackers/metadata_requirements.go
+++ b/internal/trackers/metadata_requirements.go
@@ -55,8 +55,8 @@ type MetadataRequirement struct {
 	Scope MetadataScope
 	// AnyOf is satisfied when at least one listed field is present and current.
 	AnyOf []MetadataField
-	// Severity defaults to blocking when empty or unrecognized.
-	Severity api.RuleFailureSeverity
+	// Disposition defaults to waivable for legacy empty values.
+	Disposition api.RuleDisposition
 }
 
 // TrackerMetadataPolicy defines declarative metadata requirements for a tracker.
@@ -67,71 +67,16 @@ type TrackerMetadataPolicy struct {
 	Requirements []MetadataRequirement
 }
 
-// trackerMetadataPolicies maps normalized tracker names to their required
-// provider evidence; requirements within one entry are cumulative.
-var trackerMetadataPolicies = map[string]TrackerMetadataPolicy{
-	"PTP": {Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly}, Severity: api.RuleFailureSeverityWarning}}},
-	"HDB": {RequireKnownCategory: true, Requirements: []MetadataRequirement{
-		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly}},
-		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly, MetadataFieldTVDBIDOnly}},
-	}},
-	"NBL": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTVmaze}}}},
-	"ANT": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDB}}}},
-	"BHD": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldIMDB}}}},
-	"MTV": {RequireKnownCategory: true, Requirements: []MetadataRequirement{
-		{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}},
-		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTVDBTitle}},
-	}},
-	"BTN": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldIMDB, MetadataFieldTVDB}}}},
-	"AR": {RequireKnownCategory: true, Requirements: []MetadataRequirement{
-		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}},
-		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB, MetadataFieldTVDB}},
-		{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldPoster}},
-	}},
-	"SPD": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}}}},
-	"THR": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}}}},
-	"TVC": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}}}},
-	"TL":  {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}}}},
-	"BJS": {RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB}}}},
-	"AZ":  multiIDMetadataPolicy(),
-	"CZ":  multiIDMetadataPolicy(),
-	"PHD": multiIDMetadataPolicy(),
-	"CZT": {Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly}}}},
-}
-
-// multiIDMetadataPolicy returns the shared movie and TV policy for trackers
-// that accept several provider identifiers.
-func multiIDMetadataPolicy() TrackerMetadataPolicy {
-	return TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{
-		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDBIDOnly, MetadataFieldIMDBIDOnly}},
-		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTMDBIDOnly, MetadataFieldIMDBIDOnly, MetadataFieldTVDBIDOnly}},
-	}}
-}
-
-// MetadataPolicyFor returns an independent copy of a tracker's metadata policy.
-// Tracker names are case-insensitive and whitespace-trimmed. Known Unit3D
-// trackers without an explicit policy require a current TMDB ID.
-func MetadataPolicyFor(tracker string) (TrackerMetadataPolicy, bool) {
-	name := strings.ToUpper(strings.TrimSpace(tracker))
-	policy, ok := trackerMetadataPolicies[name]
-	if !ok && IsUnit3DTracker(name) {
-		policy = TrackerMetadataPolicy{Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB}}}}
-		ok = true
-	}
-	if !ok {
-		return TrackerMetadataPolicy{}, false
-	}
+func cloneMetadataPolicy(policy TrackerMetadataPolicy) TrackerMetadataPolicy {
 	policy.Requirements = slices.Clone(policy.Requirements)
 	for i := range policy.Requirements {
 		policy.Requirements[i].AnyOf = slices.Clone(policy.Requirements[i].AnyOf)
 	}
-	return policy, true
+	return policy
 }
 
-// evaluateMetadataRequirements returns policy results and whether the tracker
-// has a metadata policy. An evaluated policy may produce a non-nil empty slice.
-func evaluateMetadataRequirements(tracker string, meta api.PreparedMetadata) ([]api.RuleFailure, bool) {
-	policy, ok := MetadataPolicyFor(tracker)
+func evaluateMetadataRequirementsWithRegistry(registry *Registry, tracker string, meta api.RuleSubject) ([]api.RuleFailure, bool) {
+	policy, ok := registry.LookupMetadataPolicy(tracker)
 	if !ok {
 		return nil, false
 	}
@@ -139,9 +84,9 @@ func evaluateMetadataRequirements(tracker string, meta api.PreparedMetadata) ([]
 	category := MetadataScope(strings.ToLower(strings.TrimSpace(resolveCategory(meta))))
 	if policy.RequireKnownCategory && category != MetadataScopeMovie && category != MetadataScopeTV {
 		return []api.RuleFailure{{
-			Rule:     "require_metadata_category",
-			Reason:   "missing category required to select tracker metadata requirements",
-			Severity: api.RuleFailureSeverityBlocking,
+			Rule:        "require_metadata_category",
+			Reason:      "missing category required to select tracker metadata requirements",
+			Disposition: metadataCategoryDisposition(policy),
 		}}, true
 	}
 
@@ -153,7 +98,7 @@ func evaluateMetadataRequirements(tracker string, meta api.PreparedMetadata) ([]
 		if metadataRequirementPresent(requirement.AnyOf, meta) {
 			continue
 		}
-		severity := api.NormalizeRuleFailureSeverity(requirement.Severity)
+		disposition := api.NormalizeRuleDisposition(requirement.Disposition)
 		rule := "require_metadata_id"
 		reason := "missing required " + metadataFieldList(requirement.AnyOf)
 		switch {
@@ -163,17 +108,40 @@ func evaluateMetadataRequirements(tracker string, meta api.PreparedMetadata) ([]
 		case slices.Contains(requirement.AnyOf, MetadataFieldPoster):
 			rule = "require_metadata_poster"
 			reason = "missing required metadata poster"
-		case severity == api.RuleFailureSeverityWarning:
+		case disposition == api.RuleDispositionAdvisory:
 			reason = "missing recommended IMDb ID; PTP upload remains allowed"
 		}
-		failures = append(failures, api.RuleFailure{Rule: rule, Reason: reason, Severity: severity})
+		failures = append(failures, api.RuleFailure{
+			Rule:        rule,
+			Reason:      reason,
+			Disposition: disposition,
+		})
 	}
 	return failures, true
 }
 
+// metadataCategoryDisposition prevents a waivable missing-category result from
+// bypassing a category-scoped strict metadata requirement.
+func metadataCategoryDisposition(policy TrackerMetadataPolicy) api.RuleDisposition {
+	if len(policy.Requirements) == 0 {
+		return api.RuleDispositionWaivable
+	}
+	disposition := api.RuleDispositionAdvisory
+	for _, requirement := range policy.Requirements {
+		requirementDisposition := api.NormalizeRuleDisposition(requirement.Disposition)
+		if requirementDisposition == api.RuleDispositionStrict {
+			return api.RuleDispositionStrict
+		}
+		if requirementDisposition == api.RuleDispositionWaivable {
+			disposition = api.RuleDispositionWaivable
+		}
+	}
+	return disposition
+}
+
 // metadataRequirementPresent reports whether any alternative field satisfies
 // a requirement.
-func metadataRequirementPresent(fields []MetadataField, meta api.PreparedMetadata) bool {
+func metadataRequirementPresent(fields []MetadataField, meta api.RuleSubject) bool {
 	for _, field := range fields {
 		if metadataFieldPresent(field, meta) {
 			return true
@@ -184,17 +152,17 @@ func metadataRequirementPresent(fields []MetadataField, meta api.PreparedMetadat
 
 // metadataFieldPresent accepts only IDs and provider data scoped to the current
 // source; an empty scope remains compatible with legacy unscoped metadata.
-func metadataFieldPresent(field MetadataField, meta api.PreparedMetadata) bool {
-	idsCurrent := sourceMatches(meta.ExternalIDs.SourcePath, meta.SourcePath)
+func metadataFieldPresent(field MetadataField, meta api.RuleSubject) bool {
+	idsCurrent := sourceMatches(meta.Identity.SourcePath, meta.SourcePath)
 	switch field {
 	case MetadataFieldTMDBIDOnly:
-		return idsCurrent && meta.ExternalIDs.TMDBID > 0
+		return idsCurrent && meta.Identity.TMDBID > 0
 	case MetadataFieldIMDBIDOnly:
-		return idsCurrent && meta.ExternalIDs.IMDBID > 0
+		return idsCurrent && meta.Identity.IMDBID > 0
 	case MetadataFieldTVDBIDOnly:
-		return idsCurrent && meta.ExternalIDs.TVDBID > 0
+		return idsCurrent && meta.Identity.TVDBID > 0
 	case MetadataFieldTVmazeIDOnly:
-		return idsCurrent && meta.ExternalIDs.TVmazeID > 0
+		return idsCurrent && meta.Identity.TVmazeID > 0
 	case MetadataFieldTMDB:
 		return matchingTMDBMetadata(meta)
 	case MetadataFieldIMDB:
@@ -211,57 +179,57 @@ func metadataFieldPresent(field MetadataField, meta api.PreparedMetadata) bool {
 	return false
 }
 
-func matchingTMDBMetadata(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.TMDB
-	return providerMetadataCurrent(meta) && value != nil && meta.ExternalIDs.TMDBID > 0 &&
-		value.TMDBID == meta.ExternalIDs.TMDBID && strings.TrimSpace(value.Title) != ""
+func matchingTMDBMetadata(meta api.RuleSubject) bool {
+	value := meta.ProviderMetadata.TMDB
+	return providerMetadataCurrent(meta) && value != nil && meta.Identity.TMDBID > 0 &&
+		value.TMDBID == meta.Identity.TMDBID && strings.TrimSpace(value.Title) != ""
 }
 
-func matchingIMDBMetadata(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.IMDB
-	return providerMetadataCurrent(meta) && value != nil && meta.ExternalIDs.IMDBID > 0 &&
-		value.IMDBID == meta.ExternalIDs.IMDBID && strings.TrimSpace(value.Title) != ""
+func matchingIMDBMetadata(meta api.RuleSubject) bool {
+	value := meta.ProviderMetadata.IMDB
+	return providerMetadataCurrent(meta) && value != nil && meta.Identity.IMDBID > 0 &&
+		value.IMDBID == meta.Identity.IMDBID && strings.TrimSpace(value.Title) != ""
 }
 
-func matchingTVDBMetadata(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.TVDB
-	return providerMetadataCurrent(meta) && value != nil && meta.ExternalIDs.TVDBID > 0 &&
-		value.TVDBID == meta.ExternalIDs.TVDBID &&
+func matchingTVDBMetadata(meta api.RuleSubject) bool {
+	value := meta.ProviderMetadata.TVDB
+	return providerMetadataCurrent(meta) && value != nil && meta.Identity.TVDBID > 0 &&
+		value.TVDBID == meta.Identity.TVDBID &&
 		(strings.TrimSpace(value.NameEnglish) != "" || strings.TrimSpace(value.Name) != "")
 }
 
-func matchingTVmazeMetadata(meta api.PreparedMetadata) bool {
-	value := meta.ExternalMetadata.TVmaze
-	return providerMetadataCurrent(meta) && value != nil && meta.ExternalIDs.TVmazeID > 0 &&
-		value.TVmazeID == meta.ExternalIDs.TVmazeID && strings.TrimSpace(value.Name) != ""
+func matchingTVmazeMetadata(meta api.RuleSubject) bool {
+	value := meta.ProviderMetadata.TVmaze
+	return providerMetadataCurrent(meta) && value != nil && meta.Identity.TVmazeID > 0 &&
+		value.TVmazeID == meta.Identity.TVmazeID && strings.TrimSpace(value.Name) != ""
 }
 
 // matchingMetadataPoster reports whether any current matching provider snapshot
 // supplies poster artwork, independently of the provider used for identity.
-func matchingMetadataPoster(meta api.PreparedMetadata) bool {
+func matchingMetadataPoster(meta api.RuleSubject) bool {
 	if !providerMetadataCurrent(meta) {
 		return false
 	}
-	if value := meta.ExternalMetadata.TMDB; value != nil && meta.ExternalIDs.TMDBID > 0 &&
-		value.TMDBID == meta.ExternalIDs.TMDBID && strings.TrimSpace(value.Poster) != "" {
+	if value := meta.ProviderMetadata.TMDB; value != nil && meta.Identity.TMDBID > 0 &&
+		value.TMDBID == meta.Identity.TMDBID && strings.TrimSpace(value.Poster) != "" {
 		return true
 	}
-	if value := meta.ExternalMetadata.IMDB; value != nil && meta.ExternalIDs.IMDBID > 0 &&
-		value.IMDBID == meta.ExternalIDs.IMDBID && strings.TrimSpace(value.Cover) != "" {
+	if value := meta.ProviderMetadata.IMDB; value != nil && meta.Identity.IMDBID > 0 &&
+		value.IMDBID == meta.Identity.IMDBID && strings.TrimSpace(value.Cover) != "" {
 		return true
 	}
-	if value := meta.ExternalMetadata.TVDB; value != nil && meta.ExternalIDs.TVDBID > 0 &&
-		value.TVDBID == meta.ExternalIDs.TVDBID && strings.TrimSpace(value.Poster) != "" {
+	if value := meta.ProviderMetadata.TVDB; value != nil && meta.Identity.TVDBID > 0 &&
+		value.TVDBID == meta.Identity.TVDBID && strings.TrimSpace(value.Poster) != "" {
 		return true
 	}
-	value := meta.ExternalMetadata.TVmaze
-	return value != nil && meta.ExternalIDs.TVmazeID > 0 && value.TVmazeID == meta.ExternalIDs.TVmazeID &&
+	value := meta.ProviderMetadata.TVmaze
+	return value != nil && meta.Identity.TVmazeID > 0 && value.TVmazeID == meta.Identity.TVmazeID &&
 		(strings.TrimSpace(value.Poster) != "" || strings.TrimSpace(value.PosterMedium) != "")
 }
 
-func providerMetadataCurrent(meta api.PreparedMetadata) bool {
-	return sourceMatches(meta.ExternalIDs.SourcePath, meta.SourcePath) &&
-		sourceMatches(meta.ExternalMetadata.SourcePath, meta.SourcePath)
+func providerMetadataCurrent(meta api.RuleSubject) bool {
+	return sourceMatches(meta.Identity.SourcePath, meta.SourcePath) &&
+		sourceMatches(meta.ProviderMetadata.SourcePath, meta.SourcePath)
 }
 
 // sourceMatches reports whether data is unscoped or belongs to the current
diff --git a/internal/trackers/metadata_requirements_test.go b/internal/trackers/metadata_requirements_test.go
index b6b9d3bf..a119e649 100644
--- a/internal/trackers/metadata_requirements_test.go
+++ b/internal/trackers/metadata_requirements_test.go
@@ -13,80 +13,411 @@ import (
 
 func TestMetadataRequirementMatrix(t *testing.T) {
 	t.Parallel()
+	registry := newMetadataRegistry(t)
 	tests := []struct {
 		name     string
 		tracker  string
 		category string
-		ids      api.ExternalIDs
-		metadata api.ExternalMetadata
+		ids      api.ExternalIdentity
+		metadata api.SourceScopedMetadata
 		warning  bool
 		fail     bool
 	}{
-		{name: "unit3d tmdb", tracker: "AITHER", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}},
-		{name: "unit3d id only", tracker: "AITHER", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
-		{name: "unit3d missing", tracker: "AITHER", fail: true},
-		{name: "ptp imdb", tracker: "PTP", ids: api.ExternalIDs{IMDBID: 1234567}},
-		{name: "ptp warning", tracker: "PTP", warning: true},
-		{name: "hdb movie imdb", tracker: "HDB", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}},
-		{name: "hdb movie tvdb rejected", tracker: "HDB", category: "movie", ids: api.ExternalIDs{TVDBID: 2}, fail: true},
-		{name: "hdb tv imdb", tracker: "HDB", category: "tv", ids: api.ExternalIDs{IMDBID: 1234567}},
-		{name: "hdb tv tvdb", tracker: "HDB", category: "tv", ids: api.ExternalIDs{TVDBID: 2}},
-		{name: "hdb tv missing", tracker: "HDB", category: "tv", fail: true},
-		{name: "nbl tvmaze", tracker: "NBL", category: "tv", ids: api.ExternalIDs{TVmazeID: 3}, metadata: api.ExternalMetadata{TVmaze: &api.TVmazeMetadata{TVmazeID: 3, Name: "Example Series"}}},
-		{name: "nbl id only", tracker: "NBL", category: "tv", ids: api.ExternalIDs{TVmazeID: 3}, fail: true},
-		{name: "nbl wrong provider", tracker: "NBL", category: "tv", ids: api.ExternalIDs{IMDBID: 1234567}, fail: true},
-		{name: "ant tmdb", tracker: "ANT", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}},
-		{name: "ant imdb rejected", tracker: "ANT", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, fail: true},
-		{name: "bhd imdb", tracker: "BHD", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}},
-		{name: "bhd imdb id only", tracker: "BHD", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, fail: true},
-		{name: "bhd tmdb rejected", tracker: "BHD", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}, fail: true},
-		{name: "mtv movie imdb", tracker: "MTV", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}},
-		{name: "mtv movie tmdb", tracker: "MTV", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}},
-		{name: "mtv movie id only", tracker: "MTV", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
-		{name: "mtv tv complete", tracker: "MTV", category: "tv", ids: api.ExternalIDs{TMDBID: 1, TVDBID: 2}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}, TVDB: &api.TVDBMetadata{TVDBID: 2, NameEnglish: "Example Series"}}},
-		{name: "mtv tv blank title", tracker: "MTV", category: "tv", ids: api.ExternalIDs{TMDBID: 1, TVDBID: 2}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}, TVDB: &api.TVDBMetadata{TVDBID: 2}}, fail: true},
-		{name: "mtv tv mismatched title metadata", tracker: "MTV", category: "tv", ids: api.ExternalIDs{TMDBID: 1, TVDBID: 2}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}, TVDB: &api.TVDBMetadata{TVDBID: 3, Name: "Example Series"}}, fail: true},
-		{name: "mtv tv tvdb identity rejected", tracker: "MTV", category: "tv", ids: api.ExternalIDs{TVDBID: 2}, metadata: api.ExternalMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Series"}}, fail: true},
-		{name: "btn imdb", tracker: "BTN", category: "tv", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"}}},
-		{name: "btn tvdb", tracker: "BTN", category: "tv", ids: api.ExternalIDs{TVDBID: 2}, metadata: api.ExternalMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Series"}}},
-		{name: "btn id only", tracker: "BTN", category: "tv", ids: api.ExternalIDs{TVDBID: 2}, fail: true},
-		{name: "btn tmdb rejected", tracker: "BTN", category: "tv", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
-		{name: "ar movie imdb", tracker: "AR", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release", Cover: "https://img.example/poster.jpg"}}},
-		{name: "ar movie tmdb", tracker: "AR", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release", Poster: "https://img.example/poster.jpg"}}},
-		{name: "ar movie missing poster", tracker: "AR", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}, fail: true},
-		{name: "ar movie tvdb rejected", tracker: "AR", category: "movie", ids: api.ExternalIDs{TVDBID: 2}, fail: true},
-		{name: "ar tv imdb", tracker: "AR", category: "tv", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series", Cover: "https://img.example/poster.jpg"}}},
-		{name: "ar tv tmdb", tracker: "AR", category: "tv", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series", Poster: "https://img.example/poster.jpg"}}},
-		{name: "ar tv tvdb", tracker: "AR", category: "tv", ids: api.ExternalIDs{TVDBID: 2}, metadata: api.ExternalMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Series", Poster: "https://img.example/poster.jpg"}}},
-		{name: "ar tv tvmaze rejected", tracker: "AR", category: "tv", ids: api.ExternalIDs{TVmazeID: 3}, metadata: api.ExternalMetadata{TVmaze: &api.TVmazeMetadata{TVmazeID: 3, Name: "Example Series", Poster: "https://img.example/poster.jpg"}}, fail: true},
-		{name: "ar tv missing", tracker: "AR", category: "tv", fail: true},
-		{name: "spd tmdb", tracker: "SPD", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}},
-		{name: "spd imdb", tracker: "SPD", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}},
-		{name: "spd id only", tracker: "SPD", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
-		{name: "thr imdb", tracker: "THR", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}},
-		{name: "tvc tmdb", tracker: "TVC", category: "tv", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}}},
-		{name: "tl imdb", tracker: "TL", category: "tv", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"}}},
-		{name: "bjs tmdb", tracker: "BJS", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, metadata: api.ExternalMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}}},
-		{name: "bjs imdb rejected", tracker: "BJS", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}, metadata: api.ExternalMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}}, fail: true},
-		{name: "bjs tmdb id only", tracker: "BJS", category: "movie", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
-		{name: "z movie imdb", tracker: "AZ", category: "movie", ids: api.ExternalIDs{IMDBID: 1234567}},
-		{name: "z movie tvdb rejected", tracker: "CZ", category: "movie", ids: api.ExternalIDs{TVDBID: 2}, fail: true},
-		{name: "z tv tvdb", tracker: "PHD", category: "tv", ids: api.ExternalIDs{TVDBID: 2}},
-		{name: "czteam imdb", tracker: "CZT", ids: api.ExternalIDs{IMDBID: 1234567}},
-		{name: "czteam tmdb rejected", tracker: "CZT", ids: api.ExternalIDs{TMDBID: 1}, fail: true},
+		{
+			name:     "unit3d tmdb",
+			tracker:  "AITHER",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+		},
+		{
+			name:    "unit3d id only",
+			tracker: "AITHER",
+			ids:     api.ExternalIdentity{TMDBID: 1},
+			fail:    true,
+		},
+		{
+			name:    "unit3d missing",
+			tracker: "AITHER",
+			fail:    true,
+		},
+		{
+			name:    "ptp imdb",
+			tracker: "PTP",
+			ids:     api.ExternalIdentity{IMDBID: 1234567},
+		},
+		{
+			name:    "ptp warning",
+			tracker: "PTP",
+			warning: true,
+		},
+		{
+			name:     "hdb movie imdb",
+			tracker:  "HDB",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+		},
+		{
+			name:     "hdb movie tvdb rejected",
+			tracker:  "HDB",
+			category: "movie",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			fail:     true,
+		},
+		{
+			name:     "hdb tv imdb",
+			tracker:  "HDB",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+		},
+		{
+			name:     "hdb tv tvdb",
+			tracker:  "HDB",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+		},
+		{
+			name:     "hdb tv missing",
+			tracker:  "HDB",
+			category: "tv",
+			fail:     true,
+		},
+		{
+			name:     "nbl tvmaze",
+			tracker:  "NBL",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVmazeID: 3},
+			metadata: api.SourceScopedMetadata{TVmaze: &api.TVmazeMetadata{TVmazeID: 3, Name: "Example Series"}},
+		},
+		{
+			name:     "nbl id only",
+			tracker:  "NBL",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVmazeID: 3},
+			fail:     true,
+		},
+		{
+			name:     "nbl wrong provider",
+			tracker:  "NBL",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			fail:     true,
+		},
+		{
+			name:     "ant tmdb",
+			tracker:  "ANT",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+		},
+		{
+			name:     "ant imdb rejected",
+			tracker:  "ANT",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			fail:     true,
+		},
+		{
+			name:     "bhd imdb",
+			tracker:  "BHD",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+		},
+		{
+			name:     "bhd imdb id only",
+			tracker:  "BHD",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			fail:     true,
+		},
+		{
+			name:     "bhd tmdb rejected",
+			tracker:  "BHD",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+			fail:     true,
+		},
+		{
+			name:     "mtv movie imdb",
+			tracker:  "MTV",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+		},
+		{
+			name:     "mtv movie tmdb",
+			tracker:  "MTV",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+		},
+		{
+			name:     "mtv movie id only",
+			tracker:  "MTV",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			fail:     true,
+		},
+		{
+			name:     "mtv movie tvdb",
+			tracker:  "MTV",
+			category: "movie",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Release"}},
+		},
+		{
+			name:     "mtv tv tmdb",
+			tracker:  "MTV",
+			category: "tv",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}},
+		},
+		{
+			name:     "mtv tv imdb",
+			tracker:  "MTV",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"}},
+		},
+		{
+			name:     "mtv tv tvdb",
+			tracker:  "MTV",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Series"}},
+		},
+		{
+			name:     "mtv tv mismatched tvdb metadata",
+			tracker:  "MTV",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{TVDBID: 3, Name: "Example Series"}},
+			fail:     true,
+		},
+		{
+			name:     "btn imdb",
+			tracker:  "BTN",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"}},
+		},
+		{
+			name:     "btn tvdb",
+			tracker:  "BTN",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{TVDBID: 2, Name: "Example Series"}},
+		},
+		{
+			name:     "btn id only",
+			tracker:  "BTN",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			fail:     true,
+		},
+		{
+			name:     "btn tmdb rejected",
+			tracker:  "BTN",
+			category: "tv",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			fail:     true,
+		},
+		{
+			name:     "ar movie imdb",
+			tracker:  "AR",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "Example Release",
+				Cover:  "https://img.example/poster.jpg",
+			}},
+		},
+		{
+			name:     "ar movie tmdb",
+			tracker:  "AR",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{
+				TMDBID: 1,
+				Title:  "Example Release",
+				Poster: "https://img.example/poster.jpg",
+			}},
+		},
+		{
+			name:     "ar movie missing poster",
+			tracker:  "AR",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+			fail:     true,
+		},
+		{
+			name:     "ar movie tvdb rejected",
+			tracker:  "AR",
+			category: "movie",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			fail:     true,
+		},
+		{
+			name:     "ar tv imdb",
+			tracker:  "AR",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "Example Series",
+				Cover:  "https://img.example/poster.jpg",
+			}},
+		},
+		{
+			name:     "ar tv tmdb",
+			tracker:  "AR",
+			category: "tv",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{
+				TMDBID: 1,
+				Title:  "Example Series",
+				Poster: "https://img.example/poster.jpg",
+			}},
+		},
+		{
+			name:     "ar tv tvdb",
+			tracker:  "AR",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{
+				TVDBID: 2,
+				Name:   "Example Series",
+				Poster: "https://img.example/poster.jpg",
+			}},
+		},
+		{
+			name:     "ar tv tvmaze rejected",
+			tracker:  "AR",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVmazeID: 3},
+			metadata: api.SourceScopedMetadata{TVmaze: &api.TVmazeMetadata{
+				TVmazeID: 3,
+				Name:     "Example Series",
+				Poster:   "https://img.example/poster.jpg",
+			}},
+			fail: true,
+		},
+		{
+			name:     "ar tv missing",
+			tracker:  "AR",
+			category: "tv",
+			fail:     true,
+		},
+		{
+			name:     "spd tmdb",
+			tracker:  "SPD",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+		},
+		{
+			name:     "spd imdb",
+			tracker:  "SPD",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+		},
+		{
+			name:     "spd id only",
+			tracker:  "SPD",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			fail:     true,
+		},
+		{
+			name:     "thr imdb",
+			tracker:  "THR",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+		},
+		{
+			name:     "tvc tmdb",
+			tracker:  "TVC",
+			category: "tv",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Series"}},
+		},
+		{
+			name:     "tl imdb",
+			tracker:  "TL",
+			category: "tv",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"}},
+		},
+		{
+			name:     "bjs tmdb",
+			tracker:  "BJS",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			metadata: api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{TMDBID: 1, Title: "Example Release"}},
+		},
+		{
+			name:     "bjs imdb rejected",
+			tracker:  "BJS",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+			metadata: api.SourceScopedMetadata{IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"}},
+			fail:     true,
+		},
+		{
+			name:     "bjs tmdb id only",
+			tracker:  "BJS",
+			category: "movie",
+			ids:      api.ExternalIdentity{TMDBID: 1},
+			fail:     true,
+		},
+		{
+			name:     "z movie imdb",
+			tracker:  "AZ",
+			category: "movie",
+			ids:      api.ExternalIdentity{IMDBID: 1234567},
+		},
+		{
+			name:     "z movie tvdb rejected",
+			tracker:  "CZ",
+			category: "movie",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+			fail:     true,
+		},
+		{
+			name:     "z tv tvdb",
+			tracker:  "PHD",
+			category: "tv",
+			ids:      api.ExternalIdentity{TVDBID: 2},
+		},
+		{
+			name:    "czteam imdb",
+			tracker: "CZT",
+			ids:     api.ExternalIdentity{IMDBID: 1234567},
+		},
+		{
+			name:    "czteam tmdb rejected",
+			tracker: "CZT",
+			ids:     api.ExternalIdentity{TMDBID: 1},
+			fail:    true,
+		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			meta := api.PreparedMetadata{ExternalIDs: tc.ids, ExternalMetadata: tc.metadata}
-			meta.ExternalIDs.Category = tc.category
-			failures, evaluated := evaluateMetadataRequirements(tc.tracker, meta)
+			meta := api.RuleSubject{Identity: tc.ids, ProviderMetadata: tc.metadata}
+			meta.Identity.Category, _ = api.NormalizeCanonicalCategory(tc.category)
+			failures, evaluated := evaluateMetadataRequirementsWithRegistry(registry, tc.tracker, meta)
 			if !evaluated {
 				t.Fatal("expected metadata policy evaluation")
 			}
 			if tc.warning {
-				if len(failures) != 1 || failures[0].Severity != api.RuleFailureSeverityWarning {
-					t.Fatalf("expected one warning, got %#v", failures)
+				if len(failures) != 1 || failures[0].Disposition != api.RuleDispositionAdvisory {
+					t.Fatalf("expected one advisory, got %#v", failures)
 				}
 				return
 			}
@@ -99,11 +430,15 @@ func TestMetadataRequirementMatrix(t *testing.T) {
 
 func TestMetadataRequirementRejectsStaleSourceData(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		SourcePath:  "current",
-		ExternalIDs: api.ExternalIDs{SourcePath: "stale", Category: "movie", TMDBID: 1},
+	meta := api.RuleSubject{
+		SourcePath: "current",
+		Identity: api.ExternalIdentity{
+			SourcePath: "stale",
+			Category:   "movie",
+			TMDBID:     1,
+		},
 	}
-	failures, _ := evaluateMetadataRequirements("ANT", meta)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "ANT", meta)
 	if !api.HasBlockingRuleFailures(failures) {
 		t.Fatalf("expected stale ID to fail, got %#v", failures)
 	}
@@ -111,77 +446,159 @@ func TestMetadataRequirementRejectsStaleSourceData(t *testing.T) {
 
 func TestMetadataRequirementRejectsMismatchedProviderSnapshot(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "movie", TMDBID: 1},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		Identity: api.ExternalIdentity{Category: "movie", TMDBID: 1},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{TMDBID: 2, Title: "Example Release"},
 		},
 	}
-	failures, _ := evaluateMetadataRequirements("ANT", meta)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "ANT", meta)
 	if !api.HasBlockingRuleFailures(failures) {
 		t.Fatalf("expected mismatched TMDB snapshot to fail, got %#v", failures)
 	}
 }
 
-func TestMetadataPolicyForReturnsClonedRequirements(t *testing.T) {
+func newMetadataRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	policy := &TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDB}}}}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:       "ANT",
+		Definition: stubDefinition{name: "ANT"},
+		Metadata:   policy,
+	}); err != nil {
+		t.Fatalf("register ANT metadata policy: %v", err)
+	}
+	bhdPolicy := &TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldIMDB}}}}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:       "BHD",
+		Definition: stubDefinition{name: "BHD"},
+		Metadata:   bhdPolicy,
+	}); err != nil {
+		t.Fatalf("register BHD metadata policy: %v", err)
+	}
+	btnPolicy := &TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldIMDB, MetadataFieldTVDB}}}}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:       "BTN",
+		Definition: stubDefinition{name: "BTN"},
+		Metadata:   btnPolicy,
+	}); err != nil {
+		t.Fatalf("register BTN metadata policy: %v", err)
+	}
+	hdbPolicy := &TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{
+		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly}},
+		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly, MetadataFieldTVDBIDOnly}},
+	}}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:       "HDB",
+		Definition: stubDefinition{name: "HDB"},
+		Metadata:   hdbPolicy,
+	}); err != nil {
+		t.Fatalf("register HDB metadata policy: %v", err)
+	}
+	register := func(name string, policy TrackerMetadataPolicy) {
+		t.Helper()
+		if err := registry.RegisterDescriptor(Descriptor{
+			Name:       name,
+			Definition: stubDefinition{name: name},
+			Metadata:   &policy,
+		}); err != nil {
+			t.Fatalf("register %s metadata policy: %v", name, err)
+		}
+	}
+	register("AITHER", TrackerMetadataPolicy{Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB}}}})
+	register("PTP", TrackerMetadataPolicy{Requirements: []MetadataRequirement{{
+		Scope:       MetadataScopeAny,
+		AnyOf:       []MetadataField{MetadataFieldIMDBIDOnly},
+		Disposition: api.RuleDispositionAdvisory,
+	}}})
+	register("NBL", TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTVmaze}}}})
+	register("MTV", TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{
+		Scope:       MetadataScopeAny,
+		AnyOf:       []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB, MetadataFieldTVDB},
+		Disposition: api.RuleDispositionStrict,
+	}}})
+	register("AR", TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{
+		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}},
+		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB, MetadataFieldTVDB}},
+		{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldPoster}},
+	}})
+	for _, name := range []string{"SPD", "THR", "TVC", "TL"} {
+		register(name, TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB, MetadataFieldIMDB}}}})
+	}
+	register("BJS", TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldTMDB}}}})
+	multiID := TrackerMetadataPolicy{RequireKnownCategory: true, Requirements: []MetadataRequirement{
+		{Scope: MetadataScopeMovie, AnyOf: []MetadataField{MetadataFieldTMDBIDOnly, MetadataFieldIMDBIDOnly}},
+		{Scope: MetadataScopeTV, AnyOf: []MetadataField{MetadataFieldTMDBIDOnly, MetadataFieldIMDBIDOnly, MetadataFieldTVDBIDOnly}},
+	}}
+	for _, name := range []string{"AZ", "CZ", "PHD"} {
+		register(name, multiID)
+	}
+	register("CZT", TrackerMetadataPolicy{Requirements: []MetadataRequirement{{Scope: MetadataScopeAny, AnyOf: []MetadataField{MetadataFieldIMDBIDOnly}}}})
+	return registry
+}
+
+func TestRegistryMetadataPolicyReturnsClonedRequirements(t *testing.T) {
 	t.Parallel()
-	first, ok := MetadataPolicyFor("HDB")
+	registry := newMetadataRegistry(t)
+	first, ok := registry.LookupMetadataPolicy("MTV")
 	if !ok {
-		t.Fatal("expected HDB policy")
+		t.Fatal("expected MTV policy")
 	}
-	first.Requirements[0].AnyOf[0] = MetadataFieldTMDBIDOnly
-	second, _ := MetadataPolicyFor("HDB")
-	if second.Requirements[0].AnyOf[0] != MetadataFieldIMDBIDOnly {
+	first.Requirements[0].AnyOf[0] = MetadataFieldPoster
+	second, _ := registry.LookupMetadataPolicy("MTV")
+	if second.Requirements[0].AnyOf[0] != MetadataFieldTMDB {
 		t.Fatalf("policy was mutated: %#v", second)
 	}
 }
 
-func TestMetadataPolicyLookupNormalizationAndExactFamilyMatch(t *testing.T) {
+func TestRegistryMetadataPolicyLookupNormalizationAndExactMatch(t *testing.T) {
 	t.Parallel()
-	if _, ok := MetadataPolicyFor(" aither "); !ok {
+	registry := newMetadataRegistry(t)
+	if _, ok := registry.LookupMetadataPolicy(" aither "); !ok {
 		t.Fatal("expected normalized Unit3D policy lookup")
 	}
-	if _, ok := MetadataPolicyFor("AITHER_EXTRA"); ok {
+	if _, ok := registry.LookupMetadataPolicy("AITHER_EXTRA"); ok {
 		t.Fatal("unexpected prefix match for unknown tracker")
 	}
 }
 
 func TestMetadataRequirementNeedsKnownCategory(t *testing.T) {
 	t.Parallel()
-	failures, evaluated := evaluateMetadataRequirements("HDB", api.PreparedMetadata{ExternalIDs: api.ExternalIDs{IMDBID: 1234567}})
+	failures, evaluated := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "HDB", api.RuleSubject{Identity: api.ExternalIdentity{IMDBID: 1234567}})
 	if !evaluated || len(failures) != 1 || failures[0].Rule != "require_metadata_category" || !api.HasBlockingRuleFailures(failures) {
 		t.Fatalf("expected blocking category result, got %#v", failures)
 	}
 }
 
-func TestTVDBTitleRequirementRejectsStaleProviderMetadata(t *testing.T) {
+func TestMTVMetadataRequirementRejectsStaleTVDBMetadata(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		SourcePath:  "current",
-		ExternalIDs: api.ExternalIDs{SourcePath: "current", Category: "tv", TMDBID: 1, TVDBID: 2},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		SourcePath: "current",
+		Identity: api.ExternalIdentity{
+			SourcePath: "current",
+			Category:   "tv",
+			TVDBID:     2,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "stale",
 			TVDB:       &api.TVDBMetadata{TVDBID: 2, Name: "Example Series"},
 		},
 	}
-	failures, _ := evaluateMetadataRequirements("MTV", meta)
-	found := false
-	for _, failure := range failures {
-		if failure.Rule == "require_tvdb_title" {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Fatalf("expected stale TVDB metadata failure, got %#v", failures)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "MTV", meta)
+	if len(failures) != 1 || failures[0].Rule != "require_metadata_id" || failures[0].Disposition != api.RuleDispositionStrict {
+		t.Fatalf("expected strict stale TVDB metadata failure, got %#v", failures)
 	}
 }
 
-func TestPTPMetadataWarningDoesNotBlock(t *testing.T) {
+func TestPTPMetadataAdvisoryDoesNotBlock(t *testing.T) {
 	t.Parallel()
-	failures := EvaluateRules(context.Background(), "PTP", api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "movie"}}, nil)
-	if len(failures) != 1 || failures[0].Severity != api.RuleFailureSeverityWarning || api.HasBlockingRuleFailures(failures) {
-		t.Fatalf("expected non-blocking PTP warning, got %#v", failures)
+	failures, err := EvaluateRulesWithRegistry(context.Background(), newMetadataRegistry(t), "PTP", api.RuleSubject{Identity: api.ExternalIdentity{Category: "movie"}}, nil)
+	if err != nil {
+		t.Fatalf("evaluate PTP rules: %v", err)
+	}
+	if len(failures) != 1 || failures[0].Disposition != api.RuleDispositionAdvisory || api.HasBlockingRuleFailures(failures) {
+		t.Fatalf("expected non-blocking PTP advisory, got %#v", failures)
 	}
 }
 
@@ -190,8 +607,12 @@ func TestMetadataRequirementTMDBOrIMDbTrackersRejectIDsAlone(t *testing.T) {
 	for _, tracker := range []string{"SPD", "THR", "TVC", "TL"} {
 		t.Run(tracker, func(t *testing.T) {
 			t.Parallel()
-			meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "tv", TMDBID: 1, IMDBID: 1234567}}
-			failures, evaluated := evaluateMetadataRequirements(tracker, meta)
+			meta := api.RuleSubject{Identity: api.ExternalIdentity{
+				Category: "tv",
+				TMDBID:   1,
+				IMDBID:   1234567,
+			}}
+			failures, evaluated := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), tracker, meta)
 			if !evaluated || !api.HasBlockingRuleFailures(failures) {
 				t.Fatalf("expected IDs alone to fail for %s, got %#v", tracker, failures)
 			}
@@ -201,14 +622,18 @@ func TestMetadataRequirementTMDBOrIMDbTrackersRejectIDsAlone(t *testing.T) {
 
 func TestARMetadataPosterMayComeFromDifferentProvider(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "movie", TMDBID: 1, IMDBID: 1234567},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		Identity: api.ExternalIdentity{
+			Category: "movie",
+			TMDBID:   1,
+			IMDBID:   1234567,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{TMDBID: 1, Poster: "https://img.example/poster.jpg"},
 			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"},
 		},
 	}
-	failures, _ := evaluateMetadataRequirements("AR", meta)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "AR", meta)
 	if api.HasBlockingRuleFailures(failures) {
 		t.Fatalf("expected IMDb identity plus TMDB poster to pass, got %#v", failures)
 	}
@@ -216,14 +641,18 @@ func TestARMetadataPosterMayComeFromDifferentProvider(t *testing.T) {
 
 func TestARMetadataPosterRejectsMismatchedSnapshot(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "tv", IMDBID: 1234567, TVmazeID: 3},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		Identity: api.ExternalIdentity{
+			Category: "tv",
+			IMDBID:   1234567,
+			TVmazeID: 3,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
 			IMDB:   &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Series"},
 			TVmaze: &api.TVmazeMetadata{TVmazeID: 4, PosterMedium: "https://img.example/poster.jpg"},
 		},
 	}
-	failures, _ := evaluateMetadataRequirements("AR", meta)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "AR", meta)
 	if len(failures) != 1 || failures[0].Rule != "require_metadata_poster" || !api.HasBlockingRuleFailures(failures) {
 		t.Fatalf("expected blocking poster failure, got %#v", failures)
 	}
@@ -231,17 +660,25 @@ func TestARMetadataPosterRejectsMismatchedSnapshot(t *testing.T) {
 
 func TestARMetadataPosterRejectsStaleSnapshots(t *testing.T) {
 	t.Parallel()
-	meta := api.PreparedMetadata{
-		SourcePath:  "current",
-		ExternalIDs: api.ExternalIDs{SourcePath: "current", Category: "movie", IMDBID: 1234567},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		SourcePath: "current",
+		Identity: api.ExternalIdentity{
+			SourcePath: "current",
+			Category:   "movie",
+			IMDBID:     1234567,
+		},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "stale",
-			IMDB:       &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release", Cover: "https://img.example/poster.jpg"},
+			IMDB: &api.IMDBMetadata{
+				IMDBID: 1234567,
+				Title:  "Example Release",
+				Cover:  "https://img.example/poster.jpg",
+			},
 		},
 	}
-	failures, _ := evaluateMetadataRequirements("AR", meta)
+	failures, _ := evaluateMetadataRequirementsWithRegistry(newMetadataRegistry(t), "AR", meta)
 	for _, failure := range failures {
-		if failure.Rule == "require_metadata_poster" && failure.Severity == api.RuleFailureSeverityBlocking {
+		if failure.Rule == "require_metadata_poster" && api.IsWaivableRuleFailure(failure) {
 			return
 		}
 	}
@@ -250,8 +687,13 @@ func TestARMetadataPosterRejectsStaleSnapshots(t *testing.T) {
 
 func TestOnlyNBLDeclaresTVmazeIdentityRequirement(t *testing.T) {
 	t.Parallel()
+	registry := newMetadataRegistry(t)
 	foundNBL := false
-	for tracker, policy := range trackerMetadataPolicies {
+	for _, tracker := range registry.Names() {
+		policy, ok := registry.LookupMetadataPolicy(tracker)
+		if !ok {
+			continue
+		}
 		for _, requirement := range policy.Requirements {
 			if !containsMetadataField(requirement.AnyOf, MetadataFieldTVmaze) {
 				continue
diff --git a/internal/trackers/modified_release.go b/internal/trackers/modified_release.go
deleted file mode 100644
index 168f4b27..00000000
--- a/internal/trackers/modified_release.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackers
-
-import (
-	"path/filepath"
-	"strings"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-// isRenamedRelease reports whether the source media was renamed away from its
-// original scene/P2P release name. Trackers reject such modified releases
-// ([Modified Release] Renamed), so detecting it lets us skip the upload before it
-// is rejected. Two independent, deliberately high-signal cases are checked:
-//
-//   - *arr id tokens: Radarr/Sonarr inject "{tmdb-…}", "{imdb-…}", "{tvdb-…}",
-//     jellyfin "[tmdb" style, or bracket/paren variants into renamed names
-//     (e.g. "Example Release (2026) {imdb-tt1234567}"). These never occur in an
-//     original scene/P2P name, so their presence alone marks a rename. This is
-//     independent of the release group, which an *arr rename often strips.
-//
-//   - whitespace renames: a grouped release (a trailing "-GROUP" tag, which
-//     scene/P2P releases always dot-delimit) whose on-disk name has had its dots
-//     replaced with spaces — e.g. a library manager rewriting
-//     "Example.Release.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP" to spaces.
-//     This path is deliberately conservative: it only fires on whitespace
-//     (underscore/other separator renames are out of scope), requires the parsed
-//     group to be the actual trailing "-GROUP" suffix so a mis-parsed token (e.g.
-//     an id) cannot trigger it, and skips names with parentheses/brackets/braces
-//     (human/library naming markers) that lack an *arr id token.
-//
-// Personal releases and disc-based sources are excluded from all rename checks.
-// Groups in standardRenameCheckSkippedGroups skip only the heuristic checks;
-// SceneRenamed remains authoritative for those groups.
-//
-// Both the source path (folder) and the primary video file are checked, since the
-// tracker inspects the file (MediaInfo "Complete name") and the in-torrent names.
-func isRenamedRelease(meta api.PreparedMetadata) (bool, string) {
-	if meta.PersonalRelease {
-		return false, ""
-	}
-	if strings.TrimSpace(meta.DiscType) != "" {
-		return false, ""
-	}
-
-	// srrdb scene detection (the imdb: fallback) authoritatively compares the
-	// on-disk basename to the canonical scene media filename and sets this when
-	// they differ. It is the strongest signal (a database match, not a heuristic),
-	// so it is checked first and independent of the release group an *arr rename
-	// may strip.
-	if meta.SceneRenamed {
-		reason := strings.TrimSpace(meta.SceneRenamedReason)
-		if reason == "" {
-			reason = modifiedReleaseReason
-		}
-		return true, reason
-	}
-
-	group := strings.TrimSpace(meta.Release.Group)
-	if skipsStandardRenameCheck(group) {
-		return false, ""
-	}
-
-	names := candidateReleaseNames(meta)
-
-	// *arr id tokens mark a rename on their own, independent of the release group
-	// (which an *arr rename often strips), so check them before the group gate.
-	for _, name := range names {
-		if arrRenameToken(name) != "" {
-			return true, modifiedReleaseReason
-		}
-	}
-
-	if group == "" {
-		return false, ""
-	}
-	for _, name := range names {
-		if isRenamedReleaseName(name, group) {
-			return true, modifiedReleaseReason
-		}
-	}
-	return false, ""
-}
-
-// modifiedReleaseReason is deliberately generic: it discloses neither the
-// on-disk name nor which signal fired, so a modified release cannot be trivially
-// resolved by renaming the file back. The source should be investigated (file
-// hash, provenance) rather than papered over with a rename.
-const modifiedReleaseReason = "source appears renamed or modified from its original release name; verify the file hash and source provenance"
-
-// standardRenameCheckSkippedGroups contains release groups that bypass only the
-// standard heuristic rename checks. SRRDB scene rename matches still apply.
-var standardRenameCheckSkippedGroups = map[string]struct{}{
-	"HIDT": {},
-	"SPHD": {},
-}
-
-// skipsStandardRenameCheck reports whether group is configured to bypass the
-// standard non-scene rename heuristics.
-func skipsStandardRenameCheck(group string) bool {
-	_, ok := standardRenameCheckSkippedGroups[strings.ToUpper(strings.TrimSpace(group))]
-	return ok
-}
-
-// arrReleaseIDTokens are the Radarr/Sonarr id-injection tokens that appear in
-// renamed filenames (e.g. "Example Release (2026) {imdb-tt1234567}") and never
-// in an original scene/P2P release name.
-var arrReleaseIDTokens = []string{
-	"{tmdb-", "{imdb-", "{tvdb-",
-	"[tmdb", "(tmdb",
-	"[imdb", "(imdb",
-	"[tvdb", "(tvdb",
-}
-
-// arrRenameToken returns the first *arr id-injection token present in name
-// (case-insensitive), or "" when none is found.
-func arrRenameToken(name string) string {
-	lower := strings.ToLower(name)
-	for _, token := range arrReleaseIDTokens {
-		if strings.Contains(lower, token) {
-			return token
-		}
-	}
-	return ""
-}
-
-// mediaFileExtensions are the on-disk media file extensions whose suffix is
-// stripped from a candidate release name. A source path is frequently a
-// directory whose dotted name legitimately ends in a token like "H.265-GROUP",
-// so the extension must only be removed for actual media files — otherwise
-// filepath.Ext would strip that trailing token and hide the "-GROUP" tag.
-var mediaFileExtensions = map[string]struct{}{
-	".mkv": {}, ".mp4": {}, ".avi": {}, ".ts": {}, ".m2ts": {}, ".m4v": {},
-	".mov": {}, ".wmv": {}, ".mpg": {}, ".mpeg": {}, ".vob": {}, ".iso": {},
-}
-
-// candidateReleaseNames returns the on-disk base names that should carry the
-// release name (the source path and the primary video file). A recognized media
-// file extension is stripped; a directory basename is kept whole so dotted
-// tokens in a renamed folder name are preserved.
-func candidateReleaseNames(meta api.PreparedMetadata) []string {
-	names := make([]string, 0, 2)
-	seen := make(map[string]struct{}, 2)
-	for _, candidate := range []string{meta.SourcePath, meta.VideoPath} {
-		base := strings.TrimSpace(filepath.Base(strings.TrimSpace(candidate)))
-		if base == "" || base == "." || base == string(filepath.Separator) {
-			continue
-		}
-		if ext := filepath.Ext(base); ext != "" {
-			if _, ok := mediaFileExtensions[strings.ToLower(ext)]; ok {
-				base = strings.TrimSuffix(base, ext)
-			}
-		}
-		if _, ok := seen[base]; ok {
-			continue
-		}
-		seen[base] = struct{}{}
-		names = append(names, base)
-	}
-	return names
-}
-
-// isRenamedReleaseName reports whether a single base name looks like a
-// space-renamed copy of a "-group" scene/P2P release.
-func isRenamedReleaseName(name, group string) bool {
-	if name == "" {
-		return false
-	}
-	if !strings.ContainsAny(name, " \t") {
-		return false
-	}
-	// Parentheses/brackets/braces indicate human/library naming (Plex/Radarr/
-	// Jellyfin), never a scene/P2P release name, so do not treat them as renames.
-	if strings.ContainsAny(name, "()[]{}") {
-		return false
-	}
-	// Require the parsed group to be the actual trailing "-GROUP" tag so a token
-	// the parser mistook for a group (e.g. an id) cannot trigger a false positive.
-	return strings.HasSuffix(strings.ToUpper(name), "-"+strings.ToUpper(group))
-}
diff --git a/internal/trackers/modified_release_test.go b/internal/trackers/modified_release_test.go
deleted file mode 100644
index 632ebec4..00000000
--- a/internal/trackers/modified_release_test.go
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package trackers
-
-import (
-	"testing"
-
-	"github.com/autobrr/upbrr/pkg/api"
-)
-
-func TestIsRenamedRelease(t *testing.T) {
-	t.Parallel()
-
-	grouped := func(sourcePath string) api.PreparedMetadata {
-		return api.PreparedMetadata{
-			SourcePath: sourcePath,
-			Release:    api.ReleaseInfo{Group: "GRP"},
-		}
-	}
-
-	cases := []struct {
-		name string
-		meta api.PreparedMetadata
-		want bool
-	}{
-		{
-			name: "clean dotted folder with group",
-			meta: grouped("/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP"),
-			want: false,
-		},
-		{
-			name: "renamed spaced folder with group",
-			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP"),
-			want: true,
-		},
-		{
-			name: "renamed spaced single file with group",
-			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv"),
-			want: true,
-		},
-		{
-			name: "spaced name without group tag is not flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Some Home Video 2024"},
-			want: false,
-		},
-		{
-			name: "spaced name whose group is not the trailing tag is not flagged",
-			// Guards against a parser mis-extracting a token as the group.
-			meta: grouped("/data/movies/Some Renamed Movie 2024 1080p WEB-DL"),
-			want: false,
-		},
-		{
-			name: "radarr-renamed folder with imdb token is flagged",
-			// *arr injects {imdb-…} when it renames; this is a modified release the
-			// tracker rejects, regardless of how rls parses the group.
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Movie (2026) {imdb-tt1234567}",
-				Release:    api.ReleaseInfo{Group: "tt1234567"},
-			},
-			want: true,
-		},
-		{
-			name: "sonarr-renamed file with tmdb token is flagged",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/tv/Example Show (2026) {tmdb-12345}/Example Show S01E01 {tmdb-12345}.mkv",
-				VideoPath:  "/data/tv/Example Show (2026) {tmdb-12345}/Example Show S01E01 {tmdb-12345}.mkv",
-			},
-			want: true,
-		},
-		{
-			name: "tvdb token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/tv/Show (2020) {tvdb-360893}"},
-			want: true,
-		},
-		{
-			name: "arr token match is case-insensitive",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) {IMDb-tt1234567}"},
-			want: true,
-		},
-		{
-			name: "arr token is flagged even when the group tag was stripped",
-			// *arr renames frequently drop the trailing -GROUP, so the token check
-			// must fire without a parsed group.
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) {tmdb-12345}"},
-			want: true,
-		},
-		{
-			name: "tmdb bracket token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) [tmdb-12345]"},
-			want: true,
-		},
-		{
-			name: "tmdb paren token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) (tmdb-12345)"},
-			want: true,
-		},
-		{
-			name: "imdb bracket token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) [imdb-tt1234567]"},
-			want: true,
-		},
-		{
-			name: "imdb paren token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/movies/Example Movie (2026) (imdb-tt1234567)"},
-			want: true,
-		},
-		{
-			name: "tvdb bracket token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/tv/Example Show (2026) [tvdb-12345]"},
-			want: true,
-		},
-		{
-			name: "tvdb paren token is flagged",
-			meta: api.PreparedMetadata{SourcePath: "/data/tv/Example Show (2026) (tvdb-12345)"},
-			want: true,
-		},
-		{
-			name: "standard rename check skipped for configured group",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Release 2026 2160p MA WEB-DL DDP5 1 HDR H 265-HiDt",
-				Release:    api.ReleaseInfo{Group: "HiDt"},
-			},
-			want: false,
-		},
-		{
-			name: "standard rename check skipped for SPHD",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Release 2026 2160p MA WEB-DL DDP5 1 HDR H 265-SPHD",
-				Release:    api.ReleaseInfo{Group: "SPHD"},
-			},
-			want: false,
-		},
-		{
-			name: "standard arr-token rename check skipped for configured group",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Release (2026) {imdb-tt1234567}-HiDt",
-				Release:    api.ReleaseInfo{Group: "HiDt"},
-			},
-			want: false,
-		},
-		{
-			name: "standard arr-token rename check skipped for SPHD",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Release (2026) {imdb-tt1234567}-SPHD",
-				Release:    api.ReleaseInfo{Group: "SPHD"},
-			},
-			want: false,
-		},
-		{
-			name: "arr-renamed personal release is exempt",
-			meta: api.PreparedMetadata{
-				SourcePath:      "/data/movies/Example Movie (2026) {imdb-tt1234567}",
-				PersonalRelease: true,
-			},
-			want: false,
-		},
-		{
-			name: "arr-renamed disc source is exempt",
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example Movie (2026) {imdb-tt1234567}",
-				DiscType:   "BDMV",
-			},
-			want: false,
-		},
-		{
-			name: "edition-only brace token without an id token is not an arr rename",
-			// Only the {tmdb-/imdb-/tvdb-} id tokens mark an *arr rename; other
-			// braces (e.g. {edition-…}) must not trigger the token signal, and the
-			// spaces heuristic still skips bracketed names.
-			meta: grouped("/data/movies/Example Movie 2026 2160p WEB-DL {edition-Directors Cut}-GRP"),
-			want: false,
-		},
-		{
-			name: "parenthesized spaced library name without an id token is not flagged",
-			// Guards that the bracket marker still suppresses the whitespace
-			// heuristic when no *arr id token is present.
-			meta: grouped("/data/movies/Example Movie (2026) 2160p WEB-DL-GRP"),
-			want: false,
-		},
-		{
-			name: "personal release is exempt",
-			meta: func() api.PreparedMetadata {
-				m := grouped("/data/movies/Example Movie 2026 2160p WEB-DL-GRP")
-				m.PersonalRelease = true
-				return m
-			}(),
-			want: false,
-		},
-		{
-			name: "disc source is exempt",
-			meta: func() api.PreparedMetadata {
-				m := grouped("/data/movies/Example Movie 2026 2160p BluRay-GRP")
-				m.DiscType = "BDMV"
-				return m
-			}(),
-			want: false,
-		},
-		{
-			name: "clean folder containing a spaced video file is flagged",
-			// Finding: the tracker inspects the file, so a spaced file inside a clean
-			// dotted folder must still be detected.
-			meta: api.PreparedMetadata{
-				SourcePath: "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP",
-				VideoPath:  "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv",
-				Release:    api.ReleaseInfo{Group: "GRP"},
-			},
-			want: true,
-		},
-		{
-			name: "falls back to video path when source path is empty",
-			meta: api.PreparedMetadata{
-				SourcePath: "",
-				VideoPath:  "/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP.mkv",
-				Release:    api.ReleaseInfo{Group: "GRP"},
-			},
-			want: true,
-		},
-		{
-			name: "spaced folder retaining dotted tokens is still flagged",
-			// A library rename that converts most separators to spaces but leaves
-			// dotted tokens (DDP5.1, H.265) must not have its trailing "-GROUP" tag
-			// stripped by extension handling on the directory basename (filepath.Ext
-			// would otherwise treat ".265-GRP" as an extension).
-			meta: grouped("/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5.1 HDR H.265-GRP"),
-			want: true,
-		},
-		{
-			name: "srrdb rename signal flags a clean-looking name with no group",
-			// The imdb: fallback authoritatively confirmed a rename that the
-			// heuristics above cannot see (no group tag, no *arr token, no spaces).
-			meta: api.PreparedMetadata{
-				SourcePath:         "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
-				SceneRenamed:       true,
-				SceneRenamedReason: "source appears renamed or modified from its original release name; verify the file hash and source provenance",
-			},
-			want: true,
-		},
-		{
-			name: "srrdb rename signal still flags configured standard-skip group",
-			meta: api.PreparedMetadata{
-				SourcePath:   "/data/movies/Example.Release.2026.1080p.BluRay.x264-HiDt",
-				Release:      api.ReleaseInfo{Group: "HiDt"},
-				SceneRenamed: true,
-			},
-			want: true,
-		},
-		{
-			name: "srrdb rename signal is exempt for personal release",
-			meta: api.PreparedMetadata{
-				SourcePath:      "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
-				PersonalRelease: true,
-				SceneRenamed:    true,
-			},
-			want: false,
-		},
-		{
-			name: "srrdb rename signal is exempt for disc source",
-			meta: api.PreparedMetadata{
-				SourcePath:   "/data/movies/Example.Movie.2026.1080p.BluRay.x264",
-				DiscType:     "BDMV",
-				SceneRenamed: true,
-			},
-			want: false,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			got, reason := isRenamedRelease(tc.meta)
-			if got != tc.want {
-				t.Fatalf("isRenamedRelease = %v (%q), want %v", got, reason, tc.want)
-			}
-			if got && reason == "" {
-				t.Fatal("expected a non-empty reason when renamed")
-			}
-		})
-	}
-}
diff --git a/internal/trackers/orchestration_locality_test.go b/internal/trackers/orchestration_locality_test.go
new file mode 100644
index 00000000..52887464
--- /dev/null
+++ b/internal/trackers/orchestration_locality_test.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestGenericOrchestrationHasNoTrackerNameDispatch(t *testing.T) {
+	t.Parallel()
+
+	trackerName := regexp.MustCompile(`"(?:NBL|BTN|ANT|RTF)"`)
+	for _, dir := range []string{".", filepath.Join("..", "core")} {
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			t.Fatalf("read orchestration directory %s: %v", dir, err)
+		}
+		for _, entry := range entries {
+			name := entry.Name()
+			if entry.IsDir() || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") || name == "e2e_enabled.go" {
+				continue
+			}
+			path := filepath.Join(dir, name)
+			content, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("read orchestration source %s: %v", path, err)
+			}
+			if match := trackerName.Find(content); match != nil {
+				t.Errorf("generic orchestration %s contains tracker-name dispatch %s; move behavior into the tracker profile or adapter", path, match)
+			}
+		}
+	}
+}
diff --git a/internal/trackers/persistence.go b/internal/trackers/persistence.go
new file mode 100644
index 00000000..e71e8055
--- /dev/null
+++ b/internal/trackers/persistence.go
@@ -0,0 +1,27 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// UploadPersistence exposes only persisted state used by tracker preparation,
+// description assets, image-host resolution, and upload-ledger finalization.
+// Implementations preserve canonical query ordering and atomic slot updates.
+type UploadPersistence interface {
+	GetDescriptionOverride(context.Context, string, string) (api.DescriptionOverride, error)
+	ListDescriptionOverridesByPath(context.Context, string) ([]api.DescriptionOverride, error)
+	ListFinalSelections(context.Context, string) ([]api.ScreenshotFinalSelection, error)
+	ListTrackerMetadataByPath(context.Context, string) ([]api.TrackerMetadata, error)
+	ListUploadedImagesByPath(context.Context, string) ([]api.UploadedImageLink, error)
+	ListScreenshotSlotsByPath(context.Context, string) ([]api.ScreenshotSlot, error)
+	ReplaceScreenshotSlots(context.Context, string, []api.ScreenshotSlot) error
+	UpsertScreenshotSlotVariants(context.Context, string, []api.ScreenshotSlotVariant) error
+	DeleteUploadedImage(context.Context, string, string, string) error
+	CreateUploadRecord(context.Context, api.UploadRecord) error
+	UpdateLatestUploadRecordStatus(context.Context, string, string, string) error
+}
diff --git a/internal/trackers/plan.go b/internal/trackers/plan.go
new file mode 100644
index 00000000..235b1211
--- /dev/null
+++ b/internal/trackers/plan.go
@@ -0,0 +1,337 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"strings"
+	"sync"
+
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// PreparationIntent selects how deeply an adapter prepares a tracker operation.
+type PreparationIntent string
+
+const (
+	// PreparationIntentDescriptionPreview resolves description content without upload artifacts or mutation.
+	PreparationIntentDescriptionPreview PreparationIntent = "description_preview"
+	// PreparationIntentDryRun resolves upload artifacts and payload preview without tracker mutation.
+	PreparationIntentDryRun PreparationIntent = "dry_run"
+	// PreparationIntentUploadReview resolves the upload payload needed for
+	// authorization without explicit dry-run diagnostic artifacts.
+	PreparationIntentUploadReview PreparationIntent = "upload_review"
+	// PreparationIntentUpload prepares a single-use plan that may submit to the tracker.
+	PreparationIntentUpload PreparationIntent = "upload"
+)
+
+var (
+	// ErrPlanNotSubmittable indicates that a plan has no upload action.
+	ErrPlanNotSubmittable = errors.New("tracker plan is not submittable")
+	// ErrPlanAlreadyUsed indicates that an upload plan already authorized one submission attempt.
+	ErrPlanAlreadyUsed = errors.New("tracker plan already submitted")
+	// ErrPlanReleased indicates that plan resources were released before submission.
+	ErrPlanReleased = errors.New("tracker plan already released")
+)
+
+// PreparationFailure is a tracker-local, presentation-safe preparation failure.
+//
+//nolint:errname // Failure is the accepted domain outcome term used by the tracker-plan contract.
+type PreparationFailure struct {
+	tracker string
+	code    string
+	message string
+	cause   error
+}
+
+// NewPreparationFailure constructs a safe tracker-local failure.
+func NewPreparationFailure(tracker string, code string, message string, cause error) *PreparationFailure {
+	trimmedMessage := strings.TrimSpace(redaction.RedactValue(message, nil))
+	if trimmedMessage == "" {
+		trimmedMessage = "tracker preparation failed"
+	}
+	return &PreparationFailure{
+		tracker: strings.ToUpper(strings.TrimSpace(tracker)),
+		code:    strings.TrimSpace(code),
+		message: trimmedMessage,
+		cause:   cause,
+	}
+}
+
+// Error returns sanitized tracker-scoped failure text.
+func (f *PreparationFailure) Error() string {
+	if f == nil {
+		return "tracker preparation failed"
+	}
+	if f.tracker == "" {
+		return f.message
+	}
+	return fmt.Sprintf("trackers: %s: %s", f.tracker, f.message)
+}
+
+// Unwrap exposes the diagnostic preparation cause.
+func (f *PreparationFailure) Unwrap() error {
+	if f == nil {
+		return nil
+	}
+	return f.cause
+}
+
+// Tracker returns the normalized tracker identifier attributed to the failure.
+func (f *PreparationFailure) Tracker() string {
+	if f == nil {
+		return ""
+	}
+	return f.tracker
+}
+
+// Code returns the stable preparation failure class.
+func (f *PreparationFailure) Code() string {
+	if f == nil {
+		return ""
+	}
+	return f.code
+}
+
+// Message returns sanitized operator-facing failure detail.
+func (f *PreparationFailure) Message() string {
+	if f == nil {
+		return ""
+	}
+	return f.message
+}
+
+type planState struct {
+	mu       sync.Mutex
+	used     bool
+	released bool
+	submit   func(context.Context) (api.UploadSummary, error)
+	release  func() error
+}
+
+// TrackerPlan is an immutable operation-scoped adapter plan. Its private state
+// authorizes at most one submission and releases owned resources exactly once.
+type TrackerPlan struct {
+	tracker     string
+	intent      PreparationIntent
+	description DescriptionResult
+	dryRun      api.TrackerDryRunEntry
+	state       *planState
+}
+
+// PreparedOperation contains one immutable payload preview and the behavior
+// captured from the same preparation pass.
+type PreparedOperation struct {
+	preview api.TrackerDryRunEntry
+	submit  func(context.Context) (api.UploadSummary, error)
+	release func() error
+}
+
+// UploadPreparer builds canonical upload state once for the requested intent.
+type UploadPreparer func(context.Context, PreparationInput) (PreparedOperation, error)
+
+// NewPreparedOperation captures an upload preview and its optional submission
+// and cleanup behavior. A nil submission creates a preview-only operation.
+func NewPreparedOperation(
+	preview api.TrackerDryRunEntry,
+	submit func(context.Context) (api.UploadSummary, error),
+	release func() error,
+) PreparedOperation {
+	return PreparedOperation{
+		preview: cloneTrackerDryRunEntry(preview),
+		submit:  submit,
+		release: release,
+	}
+}
+
+// NewDescriptionPlan constructs a shallow, non-submittable description plan.
+func NewDescriptionPlan(tracker string, result DescriptionResult) TrackerPlan {
+	return TrackerPlan{
+		tracker:     strings.ToUpper(strings.TrimSpace(tracker)),
+		intent:      PreparationIntentDescriptionPreview,
+		description: result,
+		state:       &planState{},
+	}
+}
+
+// NewDryRunPlan constructs a non-submittable dry-run plan.
+func NewDryRunPlan(tracker string, preview api.TrackerDryRunEntry, release func() error) TrackerPlan {
+	return newPreviewPlan(tracker, PreparationIntentDryRun, preview, release)
+}
+
+func newPreviewPlan(tracker string, intent PreparationIntent, preview api.TrackerDryRunEntry, release func() error) TrackerPlan {
+	return TrackerPlan{
+		tracker: strings.ToUpper(strings.TrimSpace(tracker)),
+		intent:  intent,
+		dryRun:  cloneTrackerDryRunEntry(preview),
+		state:   &planState{release: release},
+	}
+}
+
+// NewUploadPlan constructs a single-use upload plan from already-prepared payload state.
+func NewUploadPlan(
+	tracker string,
+	preview api.TrackerDryRunEntry,
+	submit func(context.Context) (api.UploadSummary, error),
+	release func() error,
+) TrackerPlan {
+	return TrackerPlan{
+		tracker: strings.ToUpper(strings.TrimSpace(tracker)),
+		intent:  PreparationIntentUpload,
+		dryRun:  cloneTrackerDryRunEntry(preview),
+		state:   &planState{submit: submit, release: release},
+	}
+}
+
+// PrepareAdapter dispatches preparation intent through one tracker-owned upload
+// preparer so preview and submission share one canonical state build.
+func PrepareAdapter(
+	ctx context.Context,
+	input PreparationInput,
+	description func(context.Context, PreparationInput) (DescriptionResult, error),
+	prepareUpload UploadPreparer,
+) (TrackerPlan, *PreparationFailure) {
+	input = clonePreparationInput(input)
+	if err := ctx.Err(); err != nil {
+		return TrackerPlan{}, NewPreparationFailure(input.Tracker, "canceled", "preparation canceled", err)
+	}
+	switch input.Intent {
+	case PreparationIntentDescriptionPreview:
+		if description == nil {
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "capability", "tracker does not support shared description preparation", nil)
+		}
+		result, err := description(ctx, input)
+		if err != nil {
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "description", err.Error(), err)
+		}
+		return NewDescriptionPlan(input.Tracker, result), nil
+	case PreparationIntentDryRun:
+		operation, err := prepareUpload(ctx, input)
+		if err != nil {
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "dry_run", err.Error(), err)
+		}
+		return newPreviewPlan(input.Tracker, input.Intent, operation.preview, operation.release), nil
+	case PreparationIntentUploadReview:
+		operation, err := prepareUpload(ctx, input)
+		if err != nil {
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "upload_review", err.Error(), err)
+		}
+		return newPreviewPlan(input.Tracker, input.Intent, operation.preview, operation.release), nil
+	case PreparationIntentUpload:
+		operation, err := prepareUpload(ctx, input)
+		if err != nil {
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "upload", err.Error(), err)
+		}
+		if operation.submit == nil {
+			cleanupErr := error(nil)
+			if operation.release != nil {
+				cleanupErr = operation.release()
+			}
+			cause := errors.New("prepared operation has no submission")
+			if cleanupErr != nil {
+				cause = errors.Join(cause, cleanupErr)
+			}
+			return TrackerPlan{}, NewPreparationFailure(input.Tracker, "upload", "tracker upload preparation is not submittable", cause)
+		}
+		return NewUploadPlan(input.Tracker, operation.preview, operation.submit, operation.release), nil
+	default:
+		return TrackerPlan{}, NewPreparationFailure(input.Tracker, "intent", "unsupported preparation intent", nil)
+	}
+}
+
+func clonePreparationInput(input PreparationInput) PreparationInput {
+	if input.Assets != nil {
+		assets, _ := PreparedDescriptionAssets(input.Assets)
+		input.Assets = &assets
+	}
+	return input
+}
+
+// Tracker returns the normalized tracker identifier bound to the plan.
+func (p TrackerPlan) Tracker() string { return p.tracker }
+
+// Intent returns the preparation depth used to create the plan.
+func (p TrackerPlan) Intent() PreparationIntent { return p.intent }
+
+// Description returns the prepared description result.
+func (p TrackerPlan) Description() DescriptionResult { return p.description }
+
+// DryRun returns a defensive copy of the prepared payload preview.
+func (p TrackerPlan) DryRun() api.TrackerDryRunEntry { return cloneTrackerDryRunEntry(p.dryRun) }
+
+// Submit invokes the upload action at most once. The first accepted call consumes
+// the submission attempt before invoking the callback, even when it returns an
+// error.
+func (p TrackerPlan) Submit(ctx context.Context) (api.UploadSummary, error) {
+	if p.state == nil || p.intent != PreparationIntentUpload {
+		return api.UploadSummary{}, ErrPlanNotSubmittable
+	}
+	p.state.mu.Lock()
+	switch {
+	case p.state.released:
+		p.state.mu.Unlock()
+		return api.UploadSummary{}, ErrPlanReleased
+	case p.state.used:
+		p.state.mu.Unlock()
+		return api.UploadSummary{}, ErrPlanAlreadyUsed
+	case p.state.submit == nil:
+		p.state.mu.Unlock()
+		return api.UploadSummary{}, ErrPlanNotSubmittable
+	}
+	p.state.used = true
+	submit := p.state.submit
+	p.state.mu.Unlock()
+	return submit(ctx)
+}
+
+// Release invokes plan cleanup at most once and prevents later submission.
+// Repeated calls are no-ops and return nil.
+func (p TrackerPlan) Release() error {
+	if p.state == nil {
+		return nil
+	}
+	p.state.mu.Lock()
+	if p.state.released {
+		p.state.mu.Unlock()
+		return nil
+	}
+	p.state.released = true
+	release := p.state.release
+	p.state.mu.Unlock()
+	if release == nil {
+		return nil
+	}
+	return release()
+}
+
+func cloneTrackerDryRunEntry(entry api.TrackerDryRunEntry) api.TrackerDryRunEntry {
+	entry.Payload = maps.Clone(entry.Payload)
+	entry.Files = append([]api.TrackerDryRunFile(nil), entry.Files...)
+	entry.DebugSections = append([]api.TrackerDryRunDebugSection(nil), entry.DebugSections...)
+	entry.Diagnostics.RuleDecisions = append([]api.RuleDecision(nil), entry.Diagnostics.RuleDecisions...)
+	entry.Diagnostics.LiveEligibilityReasons = append([]api.TrackerEligibilityReason(nil), entry.Diagnostics.LiveEligibilityReasons...)
+	for idx := range entry.DebugSections {
+		entry.DebugSections[idx].Payload = maps.Clone(entry.DebugSections[idx].Payload)
+		entry.DebugSections[idx].Files = append([]api.TrackerDryRunFile(nil), entry.DebugSections[idx].Files...)
+	}
+	if entry.Questionnaire != nil {
+		questionnaire := *entry.Questionnaire
+		questionnaire.Fields = append([]api.TrackerQuestionnaireField(nil), questionnaire.Fields...)
+		for idx := range questionnaire.Fields {
+			questionnaire.Fields[idx].Options = append([]string(nil), questionnaire.Fields[idx].Options...)
+		}
+		entry.Questionnaire = &questionnaire
+	}
+	entry.ImageHost.AllowedHosts = append([]string(nil), entry.ImageHost.AllowedHosts...)
+	entry.ImageHost.Warnings = append([]api.ImageHostWarning(nil), entry.ImageHost.Warnings...)
+	if entry.ContentFailure != nil {
+		failure := *entry.ContentFailure
+		entry.ContentFailure = &failure
+	}
+	return entry
+}
diff --git a/internal/trackers/plan_test.go b/internal/trackers/plan_test.go
new file mode 100644
index 00000000..854d04eb
--- /dev/null
+++ b/internal/trackers/plan_test.go
@@ -0,0 +1,201 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestTrackerPlanIsImmutableSingleUseAndExactOnceRelease(t *testing.T) {
+	t.Parallel()
+	preview := api.TrackerDryRunEntry{
+		Tracker: "AITHER",
+		Status:  "ready",
+		Payload: map[string]string{"name": "Example.Release.2026.1080p-GRP"},
+		Files: []api.TrackerDryRunFile{{
+			Field:   "torrent",
+			Path:    "example.torrent",
+			Present: true,
+		}},
+	}
+	var submits atomic.Int32
+	var releases atomic.Int32
+	plan := NewUploadPlan("AITHER", preview, func(context.Context) (api.UploadSummary, error) {
+		submits.Add(1)
+		return api.UploadSummary{Uploaded: 1}, nil
+	}, func() error {
+		releases.Add(1)
+		return nil
+	})
+
+	preview.Payload["name"] = "mutated"
+	preview.Files[0].Path = "mutated"
+	first := plan.DryRun()
+	if first.Payload["name"] != "Example.Release.2026.1080p-GRP" || first.Files[0].Path != "example.torrent" {
+		t.Fatalf("plan retained caller mutation: %#v", first)
+	}
+	first.Payload["name"] = "mutated again"
+	if plan.DryRun().Payload["name"] != "Example.Release.2026.1080p-GRP" {
+		t.Fatal("dry-run accessor exposes mutable plan state")
+	}
+
+	summary, err := plan.Submit(context.Background())
+	if err != nil || summary.Uploaded != 1 {
+		t.Fatalf("submit = %#v, %v", summary, err)
+	}
+	if _, err := plan.Submit(context.Background()); !errors.Is(err, ErrPlanAlreadyUsed) {
+		t.Fatalf("second submit error = %v", err)
+	}
+	if err := plan.Release(); err != nil {
+		t.Fatalf("release: %v", err)
+	}
+	if err := plan.Release(); err != nil {
+		t.Fatalf("second release: %v", err)
+	}
+	if submits.Load() != 1 || releases.Load() != 1 {
+		t.Fatalf("submits=%d releases=%d", submits.Load(), releases.Load())
+	}
+}
+
+func TestTrackerPlanReleaseBeforeSubmitRejectsSubmission(t *testing.T) {
+	t.Parallel()
+	plan := NewUploadPlan("BLU", api.TrackerDryRunEntry{}, func(context.Context) (api.UploadSummary, error) {
+		return api.UploadSummary{Uploaded: 1}, nil
+	}, nil)
+	if err := plan.Release(); err != nil {
+		t.Fatalf("release: %v", err)
+	}
+	if _, err := plan.Submit(context.Background()); !errors.Is(err, ErrPlanReleased) {
+		t.Fatalf("submit after release error = %v", err)
+	}
+}
+
+func TestNonUploadPlansCannotSubmit(t *testing.T) {
+	t.Parallel()
+	for _, plan := range []TrackerPlan{
+		NewDescriptionPlan("AITHER", DescriptionResult{Group: "unit3d", Description: "example"}),
+		NewDryRunPlan("AITHER", api.TrackerDryRunEntry{Tracker: "AITHER"}, nil),
+	} {
+		if _, err := plan.Submit(context.Background()); !errors.Is(err, ErrPlanNotSubmittable) {
+			t.Fatalf("submit error = %v", err)
+		}
+	}
+}
+
+func TestPrepareAdapterBuildsUploadOperationOnce(t *testing.T) {
+	t.Parallel()
+
+	var builds atomic.Int32
+	preparedName := ""
+	input := PreparationInput{
+		Intent:  PreparationIntentUpload,
+		Tracker: "AITHER",
+		Meta:    api.UploadSubject{ReleaseName: "Example.Release.2026.1080p-GRP"},
+	}
+	plan, failure := PrepareAdapter(
+		context.Background(),
+		input,
+		func(context.Context, PreparationInput) (DescriptionResult, error) {
+			return DescriptionResult{}, nil
+		},
+		func(_ context.Context, preparedInput PreparationInput) (PreparedOperation, error) {
+			builds.Add(1)
+			preparedName = preparedInput.Meta.ReleaseName
+			preview := api.TrackerDryRunEntry{Tracker: preparedInput.Tracker, Payload: map[string]string{"name": preparedName}}
+			return NewPreparedOperation(preview, func(context.Context) (api.UploadSummary, error) {
+				if preparedName != "Example.Release.2026.1080p-GRP" {
+					t.Fatalf("captured release name = %q", preparedName)
+				}
+				return api.UploadSummary{Uploaded: 1}, nil
+			}, nil), nil
+		},
+	)
+	if failure != nil {
+		t.Fatalf("prepare upload: %v", failure)
+	}
+	input.Meta.ReleaseName = "mutated"
+	if got := plan.DryRun().Payload["name"]; got != "Example.Release.2026.1080p-GRP" {
+		t.Fatalf("preview name = %q", got)
+	}
+	if _, err := plan.Submit(context.Background()); err != nil {
+		t.Fatalf("submit: %v", err)
+	}
+	if builds.Load() != 1 {
+		t.Fatalf("upload preparation builds = %d", builds.Load())
+	}
+}
+
+func TestPrepareAdapterKeepsPreviewIntentsNonSubmittable(t *testing.T) {
+	t.Parallel()
+
+	for _, intent := range []PreparationIntent{PreparationIntentDryRun, PreparationIntentUploadReview} {
+		t.Run(string(intent), func(t *testing.T) {
+			t.Parallel()
+			var releases atomic.Int32
+			plan, failure := PrepareAdapter(
+				context.Background(),
+				PreparationInput{Intent: intent, Tracker: "BLU"},
+				func(context.Context, PreparationInput) (DescriptionResult, error) {
+					return DescriptionResult{}, nil
+				},
+				func(context.Context, PreparationInput) (PreparedOperation, error) {
+					return NewPreparedOperation(
+						api.TrackerDryRunEntry{Tracker: "BLU"},
+						func(context.Context) (api.UploadSummary, error) {
+							t.Fatal("preview intent reached submission")
+							return api.UploadSummary{}, nil
+						},
+						func() error {
+							releases.Add(1)
+							return nil
+						},
+					), nil
+				},
+			)
+			if failure != nil {
+				t.Fatalf("prepare %s: %v", intent, failure)
+			}
+			if plan.Intent() != intent {
+				t.Fatalf("plan intent = %q, want %q", plan.Intent(), intent)
+			}
+			if _, err := plan.Submit(context.Background()); !errors.Is(err, ErrPlanNotSubmittable) {
+				t.Fatalf("submit error = %v", err)
+			}
+			if err := plan.Release(); err != nil {
+				t.Fatalf("release: %v", err)
+			}
+			if releases.Load() != 1 {
+				t.Fatalf("releases = %d", releases.Load())
+			}
+		})
+	}
+}
+
+func TestPreparationInputExcludesBroadRuntimeDependencies(t *testing.T) {
+	t.Parallel()
+	typeOf := reflect.TypeFor[PreparationInput]()
+	for _, forbidden := range []string{"AppConfig", "Repo", "Registry", "Images"} {
+		if _, ok := typeOf.FieldByName(forbidden); ok {
+			t.Fatalf("PreparationInput retains broad dependency field %s", forbidden)
+		}
+	}
+}
+
+func TestPreparationFailureSanitizesMessage(t *testing.T) {
+	t.Parallel()
+	failure := NewPreparationFailure("AITHER", "auth", "request failed: https://tracker.invalid/upload?api_key=secret-value", errors.New("raw cause"))
+	if strings.Contains(failure.Message(), "secret-value") || strings.Contains(failure.Error(), "secret-value") {
+		t.Fatalf("failure exposed credential: %q", failure.Error())
+	}
+	if !errors.Is(failure, failure.Unwrap()) {
+		t.Fatal("failure did not retain its private diagnostic cause")
+	}
+}
diff --git a/internal/trackers/plan_test_helpers_test.go b/internal/trackers/plan_test_helpers_test.go
new file mode 100644
index 00000000..7986f7f1
--- /dev/null
+++ b/internal/trackers/plan_test_helpers_test.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type testDescriptionPreparer interface {
+	prepareDescription(context.Context, PreparationInput) (DescriptionResult, error)
+}
+
+type testDryRunPreparer interface {
+	prepareDryRun(context.Context, PreparationInput) (api.TrackerDryRunEntry, error)
+}
+
+type testSubmitter interface {
+	submit(context.Context, PreparationInput) (api.UploadSummary, error)
+}
+
+func prepareTestDefinition(ctx context.Context, input PreparationInput, definition any) (TrackerPlan, *PreparationFailure) {
+	description := func(context.Context, PreparationInput) (DescriptionResult, error) {
+		return DescriptionResult{Group: input.Tracker}, nil
+	}
+	if builder, ok := definition.(testDescriptionPreparer); ok {
+		description = builder.prepareDescription
+	}
+	submit := func(context.Context, PreparationInput) (api.UploadSummary, error) {
+		return api.UploadSummary{}, nil
+	}
+	if uploader, ok := definition.(testSubmitter); ok {
+		submit = uploader.submit
+	}
+	prepareUpload := func(ctx context.Context, preparedInput PreparationInput) (PreparedOperation, error) {
+		preview := api.TrackerDryRunEntry{Tracker: input.Tracker, Status: "ready"}
+		if builder, ok := definition.(testDryRunPreparer); ok {
+			var err error
+			preview, err = builder.prepareDryRun(ctx, preparedInput)
+			if err != nil {
+				return PreparedOperation{}, err
+			}
+		}
+		var submitPrepared func(context.Context) (api.UploadSummary, error)
+		if preparedInput.Intent == PreparationIntentUpload {
+			submitPrepared = func(submitCtx context.Context) (api.UploadSummary, error) {
+				return submit(submitCtx, preparedInput)
+			}
+		}
+		return NewPreparedOperation(preview, submitPrepared, nil), nil
+	}
+	return PrepareAdapter(ctx, input, description, prepareUpload)
+}
diff --git a/internal/trackers/prepared_upload_content.go b/internal/trackers/prepared_upload_content.go
new file mode 100644
index 00000000..4893b2ee
--- /dev/null
+++ b/internal/trackers/prepared_upload_content.go
@@ -0,0 +1,134 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type preparedUploadContentState string
+
+const (
+	preparedUploadContentNotRequired preparedUploadContentState = "not_required"
+	preparedUploadContentReady       preparedUploadContentState = "ready"
+	preparedUploadContentFailed      preparedUploadContentState = "failed"
+)
+
+// preparedUploadContent is the sole tracker-scoped result between shared
+// content preparation and tracker adapter invocation.
+type preparedUploadContent struct {
+	Mode      UploadContentMode
+	State     preparedUploadContentState
+	Assets    *DescriptionAssets
+	ImageHost api.ImageHostFeedback
+	Failure   *api.TrackerContentFailure
+}
+
+func (s *Service) prepareUploadContent(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	trackerCfg config.TrackerConfig,
+	preloaded *preloadedDescriptionAssetData,
+	preflight imageHostPreflight,
+) preparedUploadContent {
+	mode, ok := s.registry.LookupUploadContentMode(tracker)
+	if !ok {
+		return failedPreparedUploadContent(tracker, UploadContentModeDescription, errors.New("tracker upload content capability is unavailable"))
+	}
+	if mode == UploadContentModeNone {
+		return preparedUploadContent{Mode: mode, State: preparedUploadContentNotRequired}
+	}
+
+	resolution, found := preflight[normalizeTrackerName(tracker)]
+	var err error
+	if !found {
+		resolution, err = ensureDescriptionImageHostWithDataAndRegistry(
+			ctx,
+			tracker,
+			meta,
+			s.cfg,
+			trackerCfg,
+			s.repo,
+			s.images,
+			logging.FromContext(ctx, s.logger),
+			s.registry,
+			preloaded,
+		)
+	}
+	if err != nil {
+		return failedPreparedUploadContent(tracker, mode, err)
+	}
+	if resolution.blocking {
+		message := strings.TrimSpace(resolution.feedback.Message)
+		if message == "" {
+			message = "image-host requirements could not be met"
+		}
+		failed := failedPreparedUploadContent(tracker, mode, errors.New(message))
+		failed.ImageHost = blockedPreparationImageHostFeedback(resolution.feedback)
+		return failed
+	}
+
+	var assets DescriptionAssets
+	switch mode {
+	case UploadContentModeNone:
+		return preparedUploadContent{Mode: mode, State: preparedUploadContentNotRequired}
+	case UploadContentModeScreenshots:
+		assets, err = resolveScreenshotAssets(ctx, tracker, meta, s.repo, logging.FromContext(ctx, s.logger), preloaded, s.registry)
+	case UploadContentModeDescription:
+		assets, err = resolveDescriptionAssets(ctx, tracker, meta, s.repo, logging.FromContext(ctx, s.logger), preloaded, s.registry)
+	default:
+		err = errors.New("unsupported tracker upload content mode")
+	}
+	if err != nil {
+		return failedPreparedUploadContent(tracker, mode, err)
+	}
+	applyResolvedDescriptionScreenshots(ctx, meta, s.repo, preloaded, &assets, resolution.screenshots)
+	return preparedUploadContent{
+		Mode:      mode,
+		State:     preparedUploadContentReady,
+		Assets:    &assets,
+		ImageHost: resolution.feedback,
+	}
+}
+
+func failedPreparedUploadContent(tracker string, mode UploadContentMode, err error) preparedUploadContent {
+	message := safeTrackerMessage(err)
+	return preparedUploadContent{
+		Mode:  mode,
+		State: preparedUploadContentFailed,
+		Failure: &api.TrackerContentFailure{
+			Tracker: normalizeTrackerName(tracker),
+			Code:    mode.FailureReasonCode(),
+			Message: message,
+		},
+	}
+}
+
+func resolveScreenshotAssets(
+	ctx context.Context,
+	tracker string,
+	meta api.UploadSubject,
+	repo UploadPersistence,
+	logger api.Logger,
+	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
+) (DescriptionAssets, error) {
+	slots, screenshots, err := resolveDescriptionScreenshots(ctx, tracker, meta, repo, logger, preloaded, registry)
+	if err != nil {
+		return DescriptionAssets{}, err
+	}
+	menuImages, normalScreenshots := splitDescriptionScreenshots(ctx, meta, repo, preloaded, screenshots)
+	return DescriptionAssets{
+		Screenshots: normalScreenshots,
+		MenuImages:  menuImages,
+		Slots:       slots,
+	}, nil
+}
diff --git a/internal/trackers/registry.go b/internal/trackers/registry.go
index cc785106..941f043b 100644
--- a/internal/trackers/registry.go
+++ b/internal/trackers/registry.go
@@ -6,32 +6,504 @@ package trackers
 import (
 	"errors"
 	"fmt"
+	"net/url"
+	"regexp"
+	"sort"
 	"strings"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Registry stores construction-time tracker definitions and typed capabilities.
+// Names are normalized for case-insensitive lookup; pointer-valued capabilities
+// exposed through [Registry.LookupDescriptor] remain registry-owned and must be
+// treated as read-only.
 type Registry struct {
-	defs map[string]Definition
+	descriptors map[string]Descriptor
+	priority    []string
+}
+
+// SetPriorityOrder replaces the curated preference order with a lower-case,
+// stable, deduplicated copy.
+func (r *Registry) SetPriorityOrder(names []string) {
+	if r == nil {
+		return
+	}
+	r.priority = normalizeRegistryNames(names)
 }
 
+// Priority returns curated names followed by remaining Unit3D names.
+func (r *Registry) Priority() []string {
+	if r == nil {
+		return nil
+	}
+	ordered := append([]string(nil), r.priority...)
+	seen := make(map[string]struct{}, len(ordered))
+	for _, name := range ordered {
+		seen[name] = struct{}{}
+	}
+	for _, name := range r.NamesByFamily(FamilyUnit3D) {
+		lower := strings.ToLower(name)
+		if _, ok := seen[lower]; ok {
+			continue
+		}
+		seen[lower] = struct{}{}
+		ordered = append(ordered, lower)
+	}
+	return ordered
+}
+
+func normalizeRegistryNames(names []string) []string {
+	normalized := make([]string, 0, len(names))
+	seen := make(map[string]struct{}, len(names))
+	for _, name := range names {
+		lower := strings.ToLower(strings.TrimSpace(name))
+		if lower == "" {
+			continue
+		}
+		if _, ok := seen[lower]; ok {
+			continue
+		}
+		seen[lower] = struct{}{}
+		normalized = append(normalized, lower)
+	}
+	return normalized
+}
+
+// NewRegistry returns an empty tracker registry.
 func NewRegistry() *Registry {
-	return &Registry{defs: make(map[string]Definition)}
+	return &Registry{descriptors: make(map[string]Descriptor)}
 }
 
+// Register discovers the optional capabilities implemented by def and registers
+// the resulting descriptor. It rejects nil, unnamed, mismatched, or duplicate definitions.
 func (r *Registry) Register(def Definition) error {
+	descriptor := Descriptor{Definition: def}
+	if def != nil {
+		descriptor.Name = def.Name()
+		descriptor.Family = FamilyStandalone
+		if provider, ok := def.(BaseURLProvider); ok {
+			descriptor.BaseURL = strings.TrimSpace(provider.DefaultBaseURL())
+		}
+		if provider, ok := def.(FamilyProvider); ok {
+			descriptor.Family = provider.TrackerFamily()
+		}
+		if provider, ok := def.(LocalizedMetadataProvider); ok {
+			descriptor.MetadataLocale = strings.TrimSpace(provider.LocalizedMetadataLocale())
+		}
+		if provider, ok := def.(DescriptionGroupProvider); ok {
+			descriptor.DescriptionGroup = strings.ToLower(strings.TrimSpace(provider.DescriptionGroup()))
+		}
+		if provider, ok := def.(UploadContentModeProvider); ok {
+			descriptor.UploadContentMode = provider.UploadContentMode()
+		}
+		descriptor.DataFactory, _ = def.(DataLookupFactory)
+		descriptor.ClaimFactory, _ = def.(ClaimCheckerFactory)
+		if provider, ok := def.(ClaimPolicyProvider); ok {
+			descriptor.ClaimPolicy = provider.ClaimPolicy()
+		}
+		if provider, ok := def.(RuleProvider); ok {
+			descriptor.Rules = provider.Rules()
+		}
+		if provider, ok := def.(DataLookupPolicyProvider); ok {
+			descriptor.DataPolicy = provider.DataLookupPolicy()
+		}
+		if provider, ok := def.(ArtifactPolicyProvider); ok {
+			descriptor.Artifact = provider.ArtifactPolicy()
+		}
+		if provider, ok := def.(BannedGroupsProvider); ok {
+			descriptor.BannedGroups = append([]string(nil), provider.BannedGroups()...)
+		}
+		if provider, ok := def.(BannedGroupPolicyProvider); ok {
+			descriptor.BannedPolicy = provider.BannedGroupPolicy()
+		}
+		if provider, ok := def.(MetadataPolicyProvider); ok {
+			descriptor.Metadata = provider.MetadataPolicy()
+		}
+		if provider, ok := def.(UploadArtifactPolicyProvider); ok {
+			descriptor.UploadArtifact = provider.UploadArtifactPolicy()
+		}
+		if provider, ok := def.(DupePolicyProvider); ok {
+			descriptor.DupePolicy = provider.DupePolicy()
+		}
+		if provider, ok := def.(AudioPolicyProvider); ok {
+			descriptor.AudioPolicy = provider.AudioPolicy()
+		}
+		if provider, ok := def.(ImageHostPolicyProvider); ok {
+			descriptor.ImageHost = provider.ImageHostPolicy()
+		}
+		if provider, ok := def.(TorrentIdentityPolicyProvider); ok {
+			descriptor.TorrentIdentity = provider.TorrentIdentityPolicy()
+		} else if descriptor.Family == FamilyUnit3D && descriptor.BaseURL != "" {
+			descriptor.TorrentIdentity = &TorrentIdentityPolicy{
+				TrackerURLPatterns: []string{descriptor.BaseURL},
+				CommentURLPatterns: []string{descriptor.BaseURL},
+				DetailIDPattern:    `/(\d+)`,
+			}
+		}
+		if provider, ok := def.(AuthSessionProvider); ok {
+			descriptor.AuthResolver = provider.AuthSessionResolver()
+		}
+		if provider, ok := def.(AuthCapabilityDescriptorProvider); ok {
+			descriptor.AuthCapability = provider.AuthCapabilityDescriptor()
+		} else if provider, ok := def.(AuthCapabilityProvider); ok {
+			capability := provider.AuthCapability()
+			descriptor.AuthCapability = &capability
+		}
+		if provider, ok := def.(AuthPolicyProvider); ok {
+			descriptor.AuthPolicy = provider.AuthPolicy()
+		}
+		if provider, ok := def.(AuthStateManagerProvider); ok {
+			descriptor.AuthStateManager = provider.AuthStateManager()
+		}
+	}
+	return r.RegisterDescriptor(descriptor)
+}
+
+// LookupTorrentIdentityPolicy returns tracker-owned torrent-client identity behavior.
+func (r *Registry) LookupTorrentIdentityPolicy(tracker string) (TorrentIdentityPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.TorrentIdentity == nil {
+		return TorrentIdentityPolicy{}, false
+	}
+	policy := *descriptor.TorrentIdentity
+	policy.TrackerURLPatterns = append([]string(nil), policy.TrackerURLPatterns...)
+	policy.CommentURLPatterns = append([]string(nil), policy.CommentURLPatterns...)
+	return policy, true
+}
+
+// NeedsLocalizedMetadata reports whether any registered tracker consumes locale.
+func (r *Registry) NeedsLocalizedMetadata(names []string, locale string) bool {
+	if r == nil {
+		return false
+	}
+	for _, name := range names {
+		descriptor, ok := r.LookupDescriptor(name)
+		if ok && strings.EqualFold(strings.TrimSpace(descriptor.MetadataLocale), strings.TrimSpace(locale)) {
+			return true
+		}
+	}
+	return false
+}
+
+// LookupClaimPolicy returns tracker-owned generic claim orchestration policy.
+func (r *Registry) LookupClaimPolicy(tracker string) (ClaimPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.ClaimPolicy == nil {
+		return ClaimPolicy{}, false
+	}
+	return *descriptor.ClaimPolicy, true
+}
+
+// LookupAuthCapability returns tracker-owned auth support metadata.
+func (r *Registry) LookupAuthCapability(tracker string) (api.TrackerAuthCapability, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.AuthCapability == nil {
+		return api.TrackerAuthCapability{}, false
+	}
+	capability := *descriptor.AuthCapability
+	capability.Notes = append([]string(nil), capability.Notes...)
+	return capability, true
+}
+
+// LookupAuthSessionResolver returns tracker-owned remote auth behavior.
+func (r *Registry) LookupAuthSessionResolver(tracker string) (AuthSessionResolver, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.AuthResolver, ok && descriptor.AuthResolver != nil
+}
+
+// LookupAuthPolicy returns tracker-owned auth readiness semantics.
+func (r *Registry) LookupAuthPolicy(tracker string) (AuthPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.AuthPolicy == nil {
+		return AuthPolicy{}, false
+	}
+	return *descriptor.AuthPolicy, true
+}
+
+// LookupAuthStateManager returns tracker-owned persisted auth cleanup.
+func (r *Registry) LookupAuthStateManager(tracker string) (AuthStateManager, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.AuthStateManager, ok && descriptor.AuthStateManager != nil
+}
+
+// LookupImageHostPolicy returns tracker-owned accepted image hosts.
+func (r *Registry) LookupImageHostPolicy(tracker string) (ImageHostPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.ImageHost == nil {
+		return ImageHostPolicy{}, false
+	}
+	policy := *descriptor.ImageHost
+	policy.AllowedHosts = append([]string(nil), policy.AllowedHosts...)
+	policy.OwnedHosts = append([]string(nil), policy.OwnedHosts...)
+	return policy, true
+}
+
+// LookupUploadContentMode returns the tracker-owned shared content workflow.
+func (r *Registry) LookupUploadContentMode(tracker string) (UploadContentMode, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.UploadContentMode, ok && descriptor.UploadContentMode.Valid()
+}
+
+// OwnerForImageHost returns the tracker that owns a private image host.
+func (r *Registry) OwnerForImageHost(host string) string {
+	normalized := strings.ToLower(strings.TrimSpace(host))
+	if normalized == "" {
+		return ""
+	}
+	for _, tracker := range r.Names() {
+		policy, ok := r.LookupImageHostPolicy(tracker)
+		if !ok {
+			continue
+		}
+		for _, ownedHost := range policy.OwnedHosts {
+			if strings.EqualFold(strings.TrimSpace(ownedHost), normalized) {
+				return tracker
+			}
+		}
+	}
+	return ""
+}
+
+// LookupDataPolicy returns tracker-owned lookup orchestration policy.
+func (r *Registry) LookupDataPolicy(tracker string) (DataLookupPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.DataPolicy == nil {
+		return DataLookupPolicy{}, false
+	}
+	return *descriptor.DataPolicy, true
+}
+
+// LookupFamily returns the registered tracker protocol family.
+func (r *Registry) LookupFamily(tracker string) (Family, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.Family, ok && descriptor.Family != FamilyUnknown
+}
+
+// NamesByFamily returns registered tracker names of family in deterministic order.
+func (r *Registry) NamesByFamily(family Family) []string {
+	if r == nil {
+		return nil
+	}
+	names := make([]string, 0)
+	for name, descriptor := range r.descriptors {
+		if descriptor.Family == family {
+			names = append(names, name)
+		}
+	}
+	sort.Strings(names)
+	return names
+}
+
+// LookupClaimCheckerFactory returns tracker-owned claim-check construction.
+func (r *Registry) LookupClaimCheckerFactory(tracker string) (ClaimCheckerFactory, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.ClaimFactory, ok && descriptor.ClaimFactory != nil
+}
+
+// LookupAudioPolicy returns tracker-specific multi-language constraints.
+func (r *Registry) LookupAudioPolicy(tracker string) (AudioPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.AudioPolicy == nil {
+		return AudioPolicy{}, false
+	}
+	policy := *descriptor.AudioPolicy
+	policy.AllowedLanguages = append([]string(nil), policy.AllowedLanguages...)
+	return policy, true
+}
+
+// LookupDupePolicy returns tracker-specific duplicate comparison semantics.
+func (r *Registry) LookupDupePolicy(tracker string) (DupePolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.DupePolicy == nil {
+		return DupePolicy{}, false
+	}
+	return *descriptor.DupePolicy, true
+}
+
+// LookupUploadArtifactPolicy returns tracker torrent personalization fields.
+func (r *Registry) LookupUploadArtifactPolicy(tracker string) (UploadArtifactPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.UploadArtifact == nil {
+		return UploadArtifactPolicy{}, false
+	}
+	return *descriptor.UploadArtifact, true
+}
+
+// LookupMetadataPolicy returns tracker-owned metadata requirements.
+func (r *Registry) LookupMetadataPolicy(tracker string) (TrackerMetadataPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.Metadata == nil {
+		return TrackerMetadataPolicy{}, false
+	}
+	return cloneMetadataPolicy(*descriptor.Metadata), true
+}
+
+// LookupBannedGroups returns tracker-owned static banned release groups.
+func (r *Registry) LookupBannedGroups(tracker string) ([]string, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || len(descriptor.BannedGroups) == 0 {
+		return nil, false
+	}
+	return append([]string(nil), descriptor.BannedGroups...), true
+}
+
+// LookupBannedGroupPolicy returns tracker-owned dynamic blacklist behavior.
+func (r *Registry) LookupBannedGroupPolicy(tracker string) (BannedGroupPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.BannedPolicy == nil {
+		return BannedGroupPolicy{}, false
+	}
+	return *descriptor.BannedPolicy, true
+}
+
+// LookupDataFactory returns tracker's runtime metadata lookup factory.
+func (r *Registry) LookupDataFactory(tracker string) (DataLookupFactory, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.DataFactory, ok && descriptor.DataFactory != nil
+}
+
+// DataLookupConfigured reports whether tracker-owned lookup credentials are ready.
+func (r *Registry) DataLookupConfigured(tracker string, cfg config.Config) (bool, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok {
+		return false, false
+	}
+	provider, ok := descriptor.Definition.(DataLookupConfigProvider)
+	if !ok {
+		return false, false
+	}
+	return provider.DataLookupConfigured(cfg), true
+}
+
+// LookupArtifactPolicy returns tracker's torrent artifact constraints.
+func (r *Registry) LookupArtifactPolicy(tracker string) (ArtifactPolicy, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.Artifact == nil {
+		return ArtifactPolicy{}, false
+	}
+	return *descriptor.Artifact, true
+}
+
+// RegisterDescriptor validates and normalizes one construction-time descriptor.
+// It rejects duplicate names, non-HTTPS endpoints, invalid families/content
+// modes, malformed ID patterns, and conflicting private image-host ownership.
+func (r *Registry) RegisterDescriptor(descriptor Descriptor) error {
+	def := descriptor.Definition
 	if def == nil {
 		return errors.New("trackers: definition is nil")
 	}
-	name := strings.ToUpper(strings.TrimSpace(def.Name()))
+	name := strings.ToUpper(strings.TrimSpace(descriptor.Name))
 	if name == "" {
 		return errors.New("trackers: definition has empty name")
 	}
-	if _, exists := r.defs[name]; exists {
+	definitionName := strings.ToUpper(strings.TrimSpace(def.Name()))
+	if definitionName != name {
+		return fmt.Errorf("trackers: descriptor name %s does not match definition name %s", name, definitionName)
+	}
+	if _, exists := r.descriptors[name]; exists {
 		return fmt.Errorf("trackers: definition already registered: %s", name)
 	}
-	r.defs[name] = def
+	if descriptor.AuthCapability != nil {
+		authName := strings.ToUpper(strings.TrimSpace(descriptor.AuthCapability.TrackerID))
+		if authName != name {
+			return fmt.Errorf("trackers: auth capability name %s does not match definition name %s", authName, name)
+		}
+		descriptor.AuthCapability.TrackerID = name
+		descriptor.AuthCapability.Notes = append([]string(nil), descriptor.AuthCapability.Notes...)
+	}
+	descriptor.Name = name
+	if descriptor.Family == FamilyUnknown {
+		descriptor.Family = FamilyStandalone
+		if provider, ok := def.(FamilyProvider); ok {
+			descriptor.Family = provider.TrackerFamily()
+		}
+	}
+	if strings.TrimSpace(descriptor.BaseURL) == "" {
+		if provider, ok := def.(BaseURLProvider); ok {
+			descriptor.BaseURL = provider.DefaultBaseURL()
+		}
+	}
+	descriptor.BaseURL = strings.TrimRight(strings.TrimSpace(descriptor.BaseURL), "/")
+	if descriptor.BaseURL == "" {
+		return fmt.Errorf("trackers: definition %s has empty base URL", name)
+	}
+	endpoint, err := url.Parse(descriptor.BaseURL)
+	if err != nil || !strings.EqualFold(endpoint.Scheme, "https") || endpoint.Host == "" {
+		return fmt.Errorf("trackers: definition %s has invalid HTTPS base URL %q", name, descriptor.BaseURL)
+	}
+	if descriptor.Family != FamilyUnit3D && descriptor.Family != FamilyAZFamily && descriptor.Family != FamilyStandalone {
+		return fmt.Errorf("trackers: definition %s has invalid family %q", name, descriptor.Family)
+	}
+	if !descriptor.UploadContentMode.Valid() {
+		if provider, ok := def.(UploadContentModeProvider); ok {
+			descriptor.UploadContentMode = provider.UploadContentMode()
+		}
+	}
+	if !descriptor.UploadContentMode.Valid() {
+		return fmt.Errorf("trackers: definition %s has invalid upload content mode %q", name, descriptor.UploadContentMode)
+	}
+	if descriptor.TorrentIdentity != nil {
+		policy := *descriptor.TorrentIdentity
+		policy.TrackerURLPatterns = normalizePolicyPatterns(policy.TrackerURLPatterns)
+		policy.CommentURLPatterns = normalizePolicyPatterns(policy.CommentURLPatterns)
+		policy.DetailIDPattern = strings.TrimSpace(policy.DetailIDPattern)
+		if policy.DetailIDPattern != "" {
+			compiled, compileErr := regexp.Compile(policy.DetailIDPattern)
+			if compileErr != nil || compiled.NumSubexp() < 1 {
+				return fmt.Errorf("trackers: definition %s has invalid torrent ID pattern %q", name, policy.DetailIDPattern)
+			}
+		}
+		policy.WorkingTrackerID = strings.TrimSpace(policy.WorkingTrackerID)
+		descriptor.TorrentIdentity = &policy
+	}
+	if descriptor.ImageHost != nil {
+		policy := *descriptor.ImageHost
+		policy.AllowedHosts = normalizePolicyPatterns(policy.AllowedHosts)
+		policy.OwnedHosts = normalizePolicyPatterns(policy.OwnedHosts)
+		for _, ownedHost := range policy.OwnedHosts {
+			for registeredName, registered := range r.descriptors {
+				if registered.ImageHost == nil {
+					continue
+				}
+				for _, existingHost := range registered.ImageHost.OwnedHosts {
+					if strings.EqualFold(existingHost, ownedHost) {
+						return fmt.Errorf("trackers: image host %s is owned by both %s and %s", ownedHost, registeredName, name)
+					}
+				}
+			}
+		}
+		descriptor.ImageHost = &policy
+	}
+	r.descriptors[name] = descriptor
 	return nil
 }
 
+func normalizePolicyPatterns(patterns []string) []string {
+	normalized := make([]string, 0, len(patterns))
+	seen := make(map[string]struct{}, len(patterns))
+	for _, pattern := range patterns {
+		trimmed := strings.ToLower(strings.TrimSpace(pattern))
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		normalized = append(normalized, trimmed)
+	}
+	return normalized
+}
+
+// LookupBaseURL returns tracker's registered default endpoint.
+func (r *Registry) LookupBaseURL(tracker string) (string, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	return descriptor.BaseURL, ok && descriptor.BaseURL != ""
+}
+
+// Lookup returns the definition registered for tracker using a case-insensitive name.
 func (r *Registry) Lookup(tracker string) (Definition, bool) {
 	if r == nil {
 		return nil, false
@@ -40,6 +512,39 @@ func (r *Registry) Lookup(tracker string) (Definition, bool) {
 	if key == "" {
 		return nil, false
 	}
-	def, ok := r.defs[key]
-	return def, ok
+	descriptor, ok := r.descriptors[key]
+	return descriptor.Definition, ok
+}
+
+// LookupDescriptor returns a shallow registry-owned capability snapshot. Callers
+// needing mutable policy data must use the typed lookup methods, which copy
+// mutable slices where required.
+func (r *Registry) LookupDescriptor(tracker string) (Descriptor, bool) {
+	if r == nil {
+		return Descriptor{}, false
+	}
+	descriptor, ok := r.descriptors[strings.ToUpper(strings.TrimSpace(tracker))]
+	return descriptor, ok
+}
+
+// LookupRules returns tracker's registered rule capability.
+func (r *Registry) LookupRules(tracker string) (RuleSet, bool) {
+	descriptor, ok := r.LookupDescriptor(tracker)
+	if !ok || descriptor.Rules == nil {
+		return RuleSet{}, false
+	}
+	return *descriptor.Rules, true
+}
+
+// Names returns normalized tracker names in deterministic order.
+func (r *Registry) Names() []string {
+	if r == nil {
+		return nil
+	}
+	names := make([]string, 0, len(r.descriptors))
+	for name := range r.descriptors {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
 }
diff --git a/internal/trackers/registry_test.go b/internal/trackers/registry_test.go
index c32b5a3d..dd7acc63 100644
--- a/internal/trackers/registry_test.go
+++ b/internal/trackers/registry_test.go
@@ -5,8 +5,11 @@ package trackers
 
 import (
 	"context"
+	"reflect"
+	"strings"
 	"testing"
 
+	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -14,11 +17,70 @@ type stubDefinition struct {
 	name string
 }
 
+type stubAuthDefinition struct{ stubDefinition }
+
+func (stubAuthDefinition) AuthSessionResolver() AuthSessionResolver {
+	return func(context.Context, config.TrackerConfig, string, api.TrackerAuthLoginRequest) error { return nil }
+}
+
 func (s stubDefinition) Name() string {
 	return s.name
 }
 
-func (s stubDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (stubDefinition) UploadContentMode() UploadContentMode { return UploadContentModeDescription }
+
+func (stubDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+
+func testTrackerFamily(name string) Family {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "AITHER", "BLU", "HHD", "LST", "OE", "RF", "RHD", "STC":
+		return FamilyUnit3D
+	default:
+		return FamilyStandalone
+	}
+}
+
+func testImageHostPolicyForTracker(name string) *ImageHostPolicy {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "GPW":
+		return &ImageHostPolicy{AllowedHosts: []string{"kshare", "pixhost", "pterclub", "ilikeshots", "imgbox"}}
+	case "HDB":
+		return &ImageHostPolicy{
+			AllowedHosts:         []string{"hdb"},
+			OwnedHosts:           []string{"hdb"},
+			DisableWithoutRehost: true,
+		}
+	case "LST":
+		return &ImageHostPolicy{
+			ConditionalHost:   "lostimg",
+			OwnedHosts:        []string{"lostimg"},
+			EnableWithLostimg: true,
+		}
+	case "MTV":
+		return &ImageHostPolicy{AllowedHosts: []string{"imgbox", "imgbb"}}
+	case "OE":
+		return &ImageHostPolicy{AllowedHosts: []string{"imgbox", "imgbb", "onlyimage", "ptscreens", "passtheimage"}}
+	case "PTP":
+		return &ImageHostPolicy{AllowedHosts: []string{"pixhost", "imgbb", "onlyimage", "ptscreens", "passtheimage"}}
+	case "RF":
+		return &ImageHostPolicy{
+			ConditionalHost:      "reelflix",
+			OwnedHosts:           []string{"reelflix"},
+			EnableWhenConfigured: true,
+		}
+	case "STC":
+		return &ImageHostPolicy{AllowedHosts: []string{"imgbox", "imgbb"}}
+	default:
+		return nil
+	}
+}
+
+func (s stubDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, s)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (s stubDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{Uploaded: 1}, nil
 }
 
@@ -35,6 +97,16 @@ func TestRegistryRegisterLookup(t *testing.T) {
 	}
 }
 
+func TestRegistryRegistersAuthResolver(t *testing.T) {
+	registry := NewRegistry()
+	if err := registry.Register(stubAuthDefinition{stubDefinition{name: "AUTH"}}); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	if _, ok := registry.LookupAuthSessionResolver("auth"); !ok {
+		t.Fatal("expected auth resolver")
+	}
+}
+
 func TestRegistryRegisterDuplicate(t *testing.T) {
 	registry := NewRegistry()
 	if err := registry.Register(stubDefinition{name: "BLU"}); err != nil {
@@ -44,3 +116,42 @@ func TestRegistryRegisterDuplicate(t *testing.T) {
 		t.Fatalf("expected duplicate register error")
 	}
 }
+
+func TestRegistryRegisterDescriptorRejectsMismatchedName(t *testing.T) {
+	registry := NewRegistry()
+	err := registry.RegisterDescriptor(Descriptor{Name: "BLU", Definition: stubDefinition{name: "AITHER"}})
+	if err == nil {
+		t.Fatal("expected mismatched descriptor name error")
+	}
+}
+
+func TestRegistryDiscoversCapabilitiesAndSortsNames(t *testing.T) {
+	registry := NewRegistry()
+	for _, definition := range []Definition{
+		stubDefinition{name: "ZNTH"},
+		stubDefinition{name: "BLU"},
+	} {
+		if err := registry.Register(definition); err != nil {
+			t.Fatalf("register: %v", err)
+		}
+	}
+	if got, want := registry.Names(), []string{"BLU", "ZNTH"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("names = %v, want %v", got, want)
+	}
+}
+
+func TestRegistryRuleCapability(t *testing.T) {
+	registry := NewRegistry()
+	rules := RuleSet{RequireMovieOnly: true}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:       "BLU",
+		Definition: stubDefinition{name: "BLU"},
+		Rules:      &rules,
+	}); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	got, ok := registry.LookupRules("blu")
+	if !ok || !got.RequireMovieOnly {
+		t.Fatalf("rules = %#v, ok=%t", got, ok)
+	}
+}
diff --git a/internal/trackers/resolve.go b/internal/trackers/resolve.go
index 2d1b7895..8c70a73e 100644
--- a/internal/trackers/resolve.go
+++ b/internal/trackers/resolve.go
@@ -10,25 +10,45 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-// ResolveTrackers returns known trackers from explicit overrides when provided,
-// otherwise configured defaults, after applying removals. Returned names are
-// trimmed and uppercased.
-func ResolveTrackers(cfg config.Config, override []string, remove []string, logger api.Logger) []string {
+// ResolveTrackersWithRegistry uses explicit trackers when supplied, otherwise
+// configured defaults, then applies removals and drops unregistered names while
+// preserving normalized input order.
+func ResolveTrackersWithRegistry(cfg config.Config, override []string, remove []string, logger api.Logger, registry *Registry) []string {
 	resolved := resolveTrackers(cfg, override, remove)
-	resolved = filterKnownTrackers(resolved, logger)
+	resolved = filterKnownTrackersWithRegistry(resolved, logger, registry)
 	for i, tracker := range resolved {
 		resolved[i] = strings.ToUpper(strings.TrimSpace(tracker))
 	}
 	return resolved
 }
 
-// ResolveTrackersWithDefaults returns known configured default trackers plus
-// explicit overrides, after applying removals. Use it for flows where explicit
-// tracker selections augment defaults instead of replacing them. Returned names
-// are trimmed and uppercased.
-func ResolveTrackersWithDefaults(cfg config.Config, override []string, remove []string, logger api.Logger) []string {
+// ResolveExplicitTrackersWithRegistry validates an already-expanded tracker
+// selection without falling back to configured defaults. An explicit empty
+// selection stays empty.
+func ResolveExplicitTrackersWithRegistry(override []string, logger api.Logger, registry *Registry) []string {
+	resolved := filterKnownTrackersWithRegistry(append([]string(nil), override...), logger, registry)
+	seen := make(map[string]struct{}, len(resolved))
+	result := make([]string, 0, len(resolved))
+	for _, tracker := range resolved {
+		name := strings.ToUpper(strings.TrimSpace(tracker))
+		if name == "" {
+			continue
+		}
+		if _, ok := seen[name]; ok {
+			continue
+		}
+		seen[name] = struct{}{}
+		result = append(result, name)
+	}
+	return result
+}
+
+// ResolveTrackersWithDefaultsAndRegistry appends explicit trackers to configured
+// defaults, applies removals, and drops unregistered names while preserving the
+// first occurrence.
+func ResolveTrackersWithDefaultsAndRegistry(cfg config.Config, override []string, remove []string, logger api.Logger, registry *Registry) []string {
 	resolved := resolveTrackersWithDefaults(cfg, override, remove)
-	resolved = filterKnownTrackers(resolved, logger)
+	resolved = filterKnownTrackersWithRegistry(resolved, logger, registry)
 	for i, tracker := range resolved {
 		resolved[i] = strings.ToUpper(strings.TrimSpace(tracker))
 	}
diff --git a/internal/trackers/rule_assessment.go b/internal/trackers/rule_assessment.go
new file mode 100644
index 00000000..ac5e2f13
--- /dev/null
+++ b/internal/trackers/rule_assessment.go
@@ -0,0 +1,131 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// RuleAssessment is the complete live-upload decision for one tracker's rule evidence.
+type RuleAssessment struct {
+	Failures   []api.RuleFailure
+	Decisions  []api.RuleDecision
+	Advisory   []api.RuleFailure
+	Waivable   []api.RuleFailure
+	Strict     []api.RuleFailure
+	Authorized []api.RuleFailure
+	Eligible   bool
+}
+
+// AssessRuleFailures applies exact rule keys while retaining all evidence.
+func AssessRuleFailures(tracker string, failures []api.RuleFailure, authorizedRules []string) (RuleAssessment, error) {
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	known := make(map[string]api.RuleFailure, len(failures))
+	assessment := RuleAssessment{
+		Failures:  append([]api.RuleFailure(nil), failures...),
+		Decisions: make([]api.RuleDecision, 0, len(failures)),
+		Eligible:  true,
+	}
+	for idx, failure := range assessment.Failures {
+		key := strings.TrimSpace(failure.Rule)
+		if key == "" {
+			return RuleAssessment{}, fmt.Errorf("tracker %s contains a rule failure without a key", name)
+		}
+		failure.Rule = key
+		failure.Reason = strings.TrimSpace(failure.Reason)
+		failure.Disposition = api.NormalizeRuleDisposition(failure.Disposition)
+		assessment.Failures[idx] = failure
+		known[key] = failure
+	}
+	authorized := make(map[string]struct{}, len(authorizedRules))
+	for _, raw := range authorizedRules {
+		key := strings.TrimSpace(raw)
+		failure, ok := known[key]
+		if !ok {
+			return RuleAssessment{}, fmt.Errorf("tracker %s rule authorization %q does not match a current failure", name, key)
+		}
+		if !api.IsWaivableRuleFailure(failure) {
+			return RuleAssessment{}, fmt.Errorf("tracker %s rule authorization %q is not waivable", name, key)
+		}
+		authorized[key] = struct{}{}
+	}
+	for _, failure := range assessment.Failures {
+		failure.Disposition = api.NormalizeRuleDisposition(failure.Disposition)
+		_, isAuthorized := authorized[failure.Rule]
+		decision := api.RuleDecision{
+			Rule:        failure.Rule,
+			Reason:      failure.Reason,
+			Disposition: failure.Disposition,
+			Authorized:  isAuthorized,
+		}
+		assessment.Decisions = append(assessment.Decisions, decision)
+		switch failure.Disposition {
+		case api.RuleDispositionAdvisory:
+			assessment.Advisory = append(assessment.Advisory, failure)
+		case api.RuleDispositionWaivable:
+			assessment.Waivable = append(assessment.Waivable, failure)
+			if isAuthorized {
+				assessment.Authorized = append(assessment.Authorized, failure)
+			} else {
+				assessment.Eligible = false
+			}
+		case api.RuleDispositionStrict:
+			assessment.Strict = append(assessment.Strict, failure)
+			assessment.Eligible = false
+		}
+	}
+	return assessment, nil
+}
+
+// AuthorizedRulesForTracker returns exact keys supplied for tracker and rejects
+// duplicate tracker authorization records.
+func AuthorizedRulesForTracker(authorizations []api.RuleAuthorization, tracker string) ([]string, error) {
+	name := strings.ToUpper(strings.TrimSpace(tracker))
+	var rules []string
+	found := false
+	for _, authorization := range authorizations {
+		if strings.ToUpper(strings.TrimSpace(authorization.Tracker)) != name {
+			continue
+		}
+		if found {
+			return nil, fmt.Errorf("tracker %s has duplicate rule authorization records", name)
+		}
+		found = true
+		rules = append([]string(nil), authorization.Rules...)
+	}
+	return rules, nil
+}
+
+// ValidateRuleAuthorizations rejects unknown trackers, unknown keys, and any
+// attempt to authorize advisory or strict failures.
+func ValidateRuleAuthorizations(
+	selected []string,
+	failures map[string][]api.RuleFailure,
+	authorizations []api.RuleAuthorization,
+) error {
+	selectedSet := make(map[string]struct{}, len(selected))
+	for _, tracker := range selected {
+		if name := strings.ToUpper(strings.TrimSpace(tracker)); name != "" {
+			selectedSet[name] = struct{}{}
+		}
+	}
+	seen := make(map[string]struct{}, len(authorizations))
+	for _, authorization := range authorizations {
+		name := strings.ToUpper(strings.TrimSpace(authorization.Tracker))
+		if _, ok := selectedSet[name]; !ok {
+			return fmt.Errorf("rule authorization references unselected tracker %s", name)
+		}
+		if _, ok := seen[name]; ok {
+			return fmt.Errorf("tracker %s has duplicate rule authorization records", name)
+		}
+		seen[name] = struct{}{}
+		if _, err := AssessRuleFailures(name, failures[name], authorization.Rules); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/internal/trackers/rule_assessment_test.go b/internal/trackers/rule_assessment_test.go
new file mode 100644
index 00000000..4fcaa91a
--- /dev/null
+++ b/internal/trackers/rule_assessment_test.go
@@ -0,0 +1,107 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestAssessRuleFailuresRetainsMixedEvidenceAndExactAuthorization(t *testing.T) {
+	t.Parallel()
+	failures := []api.RuleFailure{
+		{
+Rule: "advice",
+ Reason: "recommended",
+ Disposition: api.RuleDispositionAdvisory,
+},
+		{
+Rule: "container",
+ Reason: "container rejected",
+ Disposition: api.RuleDispositionWaivable,
+},
+		{
+Rule: "resolution",
+ Reason: "resolution rejected",
+ Disposition: api.RuleDispositionStrict,
+},
+	}
+	assessment, err := AssessRuleFailures("example", failures, []string{"container"})
+	if err != nil {
+		t.Fatalf("assess: %v", err)
+	}
+	if assessment.Eligible {
+		t.Fatal("strict failure became eligible after waivable authorization")
+	}
+	if len(assessment.Failures) != 3 || len(assessment.Advisory) != 1 || len(assessment.Waivable) != 1 || len(assessment.Strict) != 1 || len(assessment.Authorized) != 1 {
+		t.Fatalf("mixed assessment = %#v", assessment)
+	}
+	if !assessment.Decisions[1].Authorized || assessment.Decisions[2].Authorized {
+		t.Fatalf("authorization projection = %#v", assessment.Decisions)
+	}
+
+	onlyWaivable, err := AssessRuleFailures("EXAMPLE", failures[1:2], []string{"container"})
+	if err != nil || !onlyWaivable.Eligible || len(onlyWaivable.Failures) != 1 {
+		t.Fatalf("authorized waivable assessment = %#v, %v", onlyWaivable, err)
+	}
+}
+
+func TestAssessRuleFailuresRejectsUnknownOrNonWaivableAuthorization(t *testing.T) {
+	t.Parallel()
+	failures := []api.RuleFailure{
+		{Rule: "advice", Disposition: api.RuleDispositionAdvisory},
+		{Rule: "strict", Disposition: api.RuleDispositionStrict},
+		{Rule: "waivable", Disposition: api.RuleDispositionWaivable},
+	}
+	for _, rule := range []string{"missing", "advice", "strict"} {
+		if _, err := AssessRuleFailures("EXAMPLE", failures, []string{rule}); err == nil {
+			t.Fatalf("authorization %q succeeded", rule)
+		}
+	}
+}
+
+func TestValidateRuleAuthorizationsIsTrackerScopedAndRejectsDuplicates(t *testing.T) {
+	t.Parallel()
+	failures := map[string][]api.RuleFailure{
+		"A": {{Rule: "container", Disposition: api.RuleDispositionWaivable}},
+		"B": {{Rule: "language", Disposition: api.RuleDispositionWaivable}},
+	}
+	valid := []api.RuleAuthorization{{Tracker: " a ", Rules: []string{"container"}}}
+	if err := ValidateRuleAuthorizations([]string{"A", "B"}, failures, valid); err != nil {
+		t.Fatalf("valid authorization: %v", err)
+	}
+	rules, err := AuthorizedRulesForTracker(valid, "A")
+	if err != nil || !reflect.DeepEqual(rules, []string{"container"}) {
+		t.Fatalf("authorized rules = %v, %v", rules, err)
+	}
+	if err := ValidateRuleAuthorizations([]string{"A", "B"}, failures, []api.RuleAuthorization{{Tracker: "A", Rules: []string{"language"}}}); err == nil {
+		t.Fatal("cross-tracker rule authorization succeeded")
+	}
+	if err := ValidateRuleAuthorizations([]string{"A"}, failures, []api.RuleAuthorization{{Tracker: "A"}, {Tracker: "a"}}); err == nil {
+		t.Fatal("duplicate tracker authorization records succeeded")
+	}
+	if err := ValidateRuleAuthorizations([]string{"A"}, failures, []api.RuleAuthorization{{Tracker: "B", Rules: []string{"language"}}}); err == nil {
+		t.Fatal("unselected tracker authorization succeeded")
+	}
+}
+
+func TestAssessRuleFailuresNormalizesLegacyAndUnknownDisposition(t *testing.T) {
+	t.Parallel()
+	assessment, err := AssessRuleFailures("EXAMPLE", []api.RuleFailure{
+		{Rule: "legacy_warning", Disposition: "warning"},
+		{Rule: "legacy_blocking", Disposition: "blocking"},
+		{Rule: "unknown", Disposition: "new_value"},
+	}, nil)
+	if err != nil {
+		t.Fatalf("assess: %v", err)
+	}
+	want := []api.RuleDisposition{api.RuleDispositionAdvisory, api.RuleDispositionWaivable, api.RuleDispositionStrict}
+	for idx, failure := range assessment.Failures {
+		if failure.Disposition != want[idx] {
+			t.Fatalf("failure[%d] disposition=%q, want %q", idx, failure.Disposition, want[idx])
+		}
+	}
+}
diff --git a/internal/trackers/rule_contract.go b/internal/trackers/rule_contract.go
new file mode 100644
index 00000000..1800d9c4
--- /dev/null
+++ b/internal/trackers/rule_contract.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"strings"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// RuleCheck returns keyed tracker-specific failures or an operational error.
+// It may return multiple independent failures from one evaluation pass.
+type RuleCheck func(ctx context.Context, meta api.RuleSubject, logger api.Logger) ([]api.RuleFailure, error)
+
+// NewRuleFailure constructs a normalized keyed tracker-rule result.
+func NewRuleFailure(rule string, reason string, disposition api.RuleDisposition) api.RuleFailure {
+	return api.RuleFailure{
+		Rule:        strings.TrimSpace(rule),
+		Reason:      strings.TrimSpace(reason),
+		Disposition: api.NormalizeRuleDisposition(disposition),
+	}
+}
+
+// LanguageRule configures language requirements and the release types to which they apply.
+type LanguageRule struct {
+	// Languages lists normalized languages accepted by the tracker.
+	Languages []string
+	// RequireAudio applies Languages to audio tracks.
+	RequireAudio bool
+	// RequireSubs applies Languages to subtitle tracks.
+	RequireSubs bool
+	// RequireBoth requires both accepted audio and subtitle tracks.
+	RequireBoth bool
+	// AllowOriginal accepts the release's original language independently of Languages.
+	AllowOriginal bool
+	// ApplyIfNonDisc limits the rule to non-disc releases.
+	ApplyIfNonDisc bool
+	// ApplyIfNonBDMV limits the rule to releases other than BDMV.
+	ApplyIfNonBDMV bool
+}
+
+// RuleSet describes generic and tracker-specific validation applied before upload.
+// Zero-valued fields disable their corresponding constraint.
+type RuleSet struct {
+	// RequireUniqueID requires at least one supported external metadata identifier.
+	RequireUniqueID bool
+	// RequireValidMISetting requires a supported MediaInfo configuration.
+	RequireValidMISetting bool
+	// RequireAudioLanguages requires parsed audio-language metadata.
+	RequireAudioLanguages bool
+	// RequireDiscOnly rejects non-disc releases.
+	RequireDiscOnly bool
+	// RequireMovieOnly rejects non-movie releases.
+	RequireMovieOnly bool
+	// RequireMovieUnlessTVPack permits TV only when the release is a pack.
+	RequireMovieUnlessTVPack bool
+	// RequireTVOnly rejects non-TV releases.
+	RequireTVOnly bool
+	// RequireHEVCForTypes lists release types that must use HEVC video.
+	RequireHEVCForTypes []string
+	// MinResolution is the lowest accepted normalized resolution.
+	MinResolution string
+	// BlockAdult rejects metadata classified as adult content.
+	BlockAdult bool
+	// AdultMessage overrides the default adult-content failure text.
+	AdultMessage string
+	// Language configures audio and subtitle language constraints.
+	Language *LanguageRule
+	// BlockDVDRip rejects DVD rip release types.
+	BlockDVDRip bool
+	// BlockExternalSubs rejects releases with external subtitle files.
+	BlockExternalSubs bool
+	// BlockSingleFileFolder rejects a directory containing only one media file.
+	BlockSingleFileFolder bool
+	// BlockHardcodedSubs rejects releases detected with hardcoded subtitles.
+	BlockHardcodedSubs bool
+	// BlockGroups lists release groups rejected unconditionally.
+	BlockGroups []string
+	// BlockGroupUnlessType maps blocked groups to release types that remain allowed.
+	BlockGroupUnlessType map[string][]string
+	// RequireSceneNFO requires an NFO for scene releases.
+	RequireSceneNFO bool
+	// Check evaluates additional tracker-specific rules.
+	Check RuleCheck
+}
diff --git a/internal/trackers/rule_dispositions_test.go b/internal/trackers/rule_dispositions_test.go
new file mode 100644
index 00000000..2c00d36f
--- /dev/null
+++ b/internal/trackers/rule_dispositions_test.go
@@ -0,0 +1,127 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestRequestedTrackerSpecificRulesAreStrict(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		tracker string
+		rule    string
+		subject api.RuleSubject
+	}{
+		{
+			name:    "BHD container",
+			tracker: "BHD",
+			rule:    "container",
+			subject: api.RuleSubject{Type: "REMUX", Container: "avi"},
+		},
+		{
+			name:    "BLU container",
+			tracker: "BLU",
+			rule:    "container",
+			subject: api.RuleSubject{Type: "WEBDL", Container: "avi"},
+		},
+		{
+			name:    "LUME container",
+			tracker: "LUME",
+			rule:    "container",
+			subject: api.RuleSubject{Container: "mp4", Release: api.ReleaseInfo{Resolution: "720p"}},
+		},
+		{
+			name:    "TVC disc",
+			tracker: "TVC",
+			rule:    "disc_forbidden",
+			subject: api.RuleSubject{DiscType: "BDMV", Release: api.ReleaseInfo{Resolution: "1080p"}},
+		},
+		{
+			name:    "TVC remux",
+			tracker: "TVC",
+			rule:    "remux_forbidden",
+			subject: api.RuleSubject{Type: "REMUX", Release: api.ReleaseInfo{Resolution: "1080p"}},
+		},
+		{
+			name:    "SHRI region",
+			tracker: "SHRI",
+			rule:    "region_required",
+			subject: api.RuleSubject{DiscType: "DVD"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			test.subject.Assessments.MediaInfoEncodeSettings = api.EncodeSettingsStatusPresent
+			failures := evaluateNonMetadataRulesForTest(context.Background(), test.tracker, test.subject)
+			failure, found := findRuleFailure(failures, test.rule)
+			if !found {
+				t.Fatalf("missing %s failure: %#v", test.rule, failures)
+			}
+			if failure.Disposition != api.RuleDispositionStrict {
+				t.Fatalf("%s disposition = %q, want strict", test.rule, failure.Disposition)
+			}
+		})
+	}
+}
+
+func TestProductionMetadataIdentityRequirementsAreStrictExceptPTP(t *testing.T) {
+	t.Parallel()
+
+	registry, err := impl.NewRegistry()
+	if err != nil {
+		t.Fatalf("registry: %v", err)
+	}
+	checked := 0
+	for _, tracker := range registry.Names() {
+		policy, ok := registry.LookupMetadataPolicy(tracker)
+		if !ok {
+			continue
+		}
+		for index, requirement := range policy.Requirements {
+			if !containsMetadataIdentityField(requirement.AnyOf) {
+				continue
+			}
+			checked++
+			want := api.RuleDispositionStrict
+			if tracker == "PTP" {
+				want = api.RuleDispositionAdvisory
+			}
+			if requirement.Disposition != want {
+				t.Errorf("%s metadata requirement %d disposition = %q, want %q", tracker, index, requirement.Disposition, want)
+			}
+		}
+	}
+	if checked == 0 {
+		t.Fatal("no metadata identity requirements checked")
+	}
+}
+
+func containsMetadataIdentityField(fields []trackers.MetadataField) bool {
+	for _, field := range fields {
+		switch field {
+		case trackers.MetadataFieldTMDBIDOnly,
+			trackers.MetadataFieldIMDBIDOnly,
+			trackers.MetadataFieldTVDBIDOnly,
+			trackers.MetadataFieldTVmazeIDOnly,
+			trackers.MetadataFieldTMDB,
+			trackers.MetadataFieldIMDB,
+			trackers.MetadataFieldTVDB,
+			trackers.MetadataFieldTVmaze:
+			return true
+		case trackers.MetadataFieldTVDBTitle, trackers.MetadataFieldPoster:
+			continue
+		}
+	}
+	return false
+}
diff --git a/internal/trackers/rules.go b/internal/trackers/rules.go
index a990a713..6564f2b9 100644
--- a/internal/trackers/rules.go
+++ b/internal/trackers/rules.go
@@ -6,14 +6,11 @@ package trackers
 import (
 	"context"
 	"fmt"
-	"strconv"
 	"strings"
-	"time"
 
 	"github.com/autobrr/upbrr/internal/languageutil"
-	"github.com/autobrr/upbrr/internal/pathutil"
-	"github.com/autobrr/upbrr/internal/trackers/impl/unit3d/additional"
-	"github.com/autobrr/upbrr/internal/trackers/unit3dmeta"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	"github.com/autobrr/upbrr/internal/releasepolicy"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -31,81 +28,100 @@ var ruleResolutionOrder = map[string]int{
 	"8640p": 11,
 }
 
-func EvaluateRules(ctx context.Context, tracker string, meta api.PreparedMetadata, logger api.Logger) []api.RuleFailure {
+// EvaluateRules evaluates repository-wide release-modification policy without a
+// tracker registry. Use [EvaluateRulesWithRegistry] for tracker and metadata
+// policy.
+func EvaluateRules(ctx context.Context, tracker string, meta api.RuleSubject, logger api.Logger) ([]api.RuleFailure, error) {
+	return evaluateRules(ctx, nil, tracker, meta, logger)
+}
+
+// EvaluateRulesWithRegistry returns all applicable failures with their
+// tracker-owned dispositions. Scene renames and structural requirements are
+// strict; non-scene rename heuristics and explicitly waivable rules require
+// authorization, while metadata requirements retain their site-specific
+// disposition.
+func EvaluateRulesWithRegistry(ctx context.Context, registry *Registry, tracker string, meta api.RuleSubject, logger api.Logger) ([]api.RuleFailure, error) {
+	return evaluateRules(ctx, registry, tracker, meta, logger)
+}
+
+func evaluateRules(ctx context.Context, registry *Registry, tracker string, meta api.RuleSubject, logger api.Logger) ([]api.RuleFailure, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, fmt.Errorf("trackers: evaluate rules: %w", err)
+	}
 	name := strings.ToUpper(strings.TrimSpace(tracker))
 
 	failures := make([]api.RuleFailure, 0)
-	addFailure := func(rule, reason string) {
+	addFailure := func(rule, reason string, disposition api.RuleDisposition) {
 		trimmed := strings.TrimSpace(reason)
 		if trimmed == "" {
 			trimmed = "rule requirement not met"
 		}
-		failures = append(failures, api.RuleFailure{Rule: rule, Reason: trimmed})
-	}
-
-	// Renamed/modified releases are rejected by trackers regardless of family, so
-	// evaluate this before the family-specific gates below. It is enabled for all
-	// trackers by default (skipsModifiedReleaseCheck exempts special cases) and is
-	// overridable via IgnoreTrackerRuleFailuresFor like any other rule failure.
-	if !skipsModifiedReleaseCheck(name) {
-		if renamed, reason := isRenamedRelease(meta); renamed {
-			addFailure("modified_release", reason)
-		}
-	}
-	metadataFailures, metadataEvaluated := evaluateMetadataRequirements(name, meta)
+		failures = append(failures, api.RuleFailure{
+			Rule:        strings.TrimSpace(rule),
+			Reason:      trimmed,
+			Disposition: api.NormalizeRuleDisposition(disposition),
+		})
+	}
+	addStrict := func(rule, reason string) { addFailure(rule, reason, api.RuleDispositionStrict) }
+	addWaivable := func(rule, reason string) { addFailure(rule, reason, api.RuleDispositionWaivable) }
+
+	// Renamed/modified releases are rejected by every supported tracker. Scene
+	// renames are authoritative and remain strict; heuristic rename detections
+	// may be explicitly authorized as a non-resolution policy exception.
+	if renamed, reason := releasepolicy.DetectModifiedRelease(releasepolicy.ModifiedReleaseSubject{
+		SourcePath:         meta.SourcePath,
+		VideoPath:          meta.VideoPath,
+		DiscType:           meta.DiscType,
+		PersonalRelease:    meta.PersonalRelease,
+		SceneRenamed:       meta.SceneRenamed,
+		SceneRenamedReason: meta.SceneRenamedReason,
+		Release:            meta.Release,
+	}); renamed {
+		disposition := api.RuleDispositionWaivable
+		if meta.SceneRenamed {
+			disposition = api.RuleDispositionStrict
+		}
+		addFailure("modified_release", reason, disposition)
+	}
+	metadataFailures, metadataEvaluated := evaluateMetadataRequirementsWithRegistry(registry, name, meta)
 	failures = append(failures, metadataFailures...)
 
-	switch name {
-	case "AZ", "CZ", "PHD":
-		return append(failures, evaluateAZFamilyRules(name, meta)...)
-	}
-	rules, ok := additional.RulesFor(name)
-	// UNIT3D-known trackers without a tracker-specific RuleSet must still reach
-	// the MediaInfo-settings check below (rules is the zero value for them, which
-	// no-ops every other rule), so don't bail early when the tracker is known.
-	if !ok && name != "PTP" && !unit3dmeta.IsKnown(name) && !metadataEvaluated {
+	rules, ok := registry.LookupRules(name)
+	if !ok && !metadataEvaluated {
 		// Preserve the nil contract for trackers without their own rule set: the
 		// consumer (applyTrackerRules) treats a nil result as "not evaluated, keep
 		// pre-existing failures" but an empty slice as "evaluated, clear failures".
 		// Only return a slice when this rule actually produced a failure.
 		if len(failures) > 0 {
-			return failures
+			return failures, nil
 		}
-		return nil
+		return nil, nil
 	}
 
-	if rules.RequireUniqueID && !meta.ValidMediaInfo {
-		addFailure("require_unique_id", "missing MediaInfo Unique ID")
+	if rules.RequireUniqueID && !meta.Assessments.UniqueIDRequirementSatisfied() {
+		addStrict("require_unique_id", "missing MediaInfo Unique ID")
 	}
-	// Every UNIT3D upload rejects encodes that lack MediaInfo encoding settings
-	// (see internal/trackers/impl/unit3d/upload.go), so enforce it at
-	// metadata-prep time for all UNIT3D trackers instead of relying on each
-	// RuleSet to opt in. This lets the release be skipped before
-	// screenshots/torrent/upload rather than failing at the upload step.
-	// ValidMediaInfoSettings is only false for encodes missing settings, so
-	// remux/web/disc uploads are unaffected. The per-tracker flag still covers
-	// non-UNIT3D trackers (e.g. BHD) that opt in via their RuleSet.
-	if (rules.RequireValidMISetting || unit3dmeta.IsKnown(name)) && !meta.ValidMediaInfoSettings {
-		addFailure("require_valid_mi_setting", "missing MediaInfo encode settings")
+	if rules.RequireValidMISetting && !meta.Assessments.EncodeSettingsRequirementSatisfied() {
+		addStrict("require_valid_mi_setting", "missing MediaInfo encode settings")
 	}
 
 	if rules.RequireDiscOnly && !isDiscType(meta.DiscType) {
-		addFailure("require_disc_only", "requires disc upload")
+		addStrict("require_disc_only", "requires disc upload")
 	}
-	if name == "PTP" && !meta.TVPack {
+	if rules.RequireMovieUnlessTVPack && !meta.TVPack {
 		category := resolveCategory(meta)
 		if category != "" && category != "movie" {
-			addFailure("require_movie_only", fmt.Sprintf("category %s is not movie", category))
+			addStrict("require_movie_only", fmt.Sprintf("category %s is not movie", category))
 		}
 	}
 	if rules.RequireMovieOnly || rules.RequireTVOnly {
 		category := resolveCategory(meta)
 		if category != "" {
 			if rules.RequireMovieOnly && category != "movie" {
-				addFailure("require_movie_only", fmt.Sprintf("category %s is not movie", category))
+				addStrict("require_movie_only", fmt.Sprintf("category %s is not movie", category))
 			}
 			if rules.RequireTVOnly && category != "tv" {
-				addFailure("require_tv_only", fmt.Sprintf("category %s is not tv", category))
+				addStrict("require_tv_only", fmt.Sprintf("category %s is not tv", category))
 			}
 		} else if logger != nil {
 			logger.Debugf("trackers: %s rule category check skipped (missing category)", name)
@@ -115,7 +131,7 @@ func EvaluateRules(ctx context.Context, tracker string, meta api.PreparedMetadat
 	typeValue := resolveType(meta)
 	if len(rules.RequireHEVCForTypes) > 0 {
 		if hasTypeRequirement(typeValue, rules.RequireHEVCForTypes) && !isHEVC(meta) {
-			addFailure("require_hevc", fmt.Sprintf("%s requires HEVC for %s", name, typeValue))
+			addStrict("require_hevc", fmt.Sprintf("%s requires HEVC for %s", name, typeValue))
 		}
 	}
 
@@ -123,9 +139,9 @@ func EvaluateRules(ctx context.Context, tracker string, meta api.PreparedMetadat
 		minResolution := strings.ToLower(strings.TrimSpace(rules.MinResolution))
 		value := resolveResolution(meta)
 		if value == "" {
-			addFailure("min_resolution", "resolution required for "+name)
+			addFailure("min_resolution", "resolution required for "+name, api.RuleDispositionStrict)
 		} else if ruleResolutionOrder[value] < ruleResolutionOrder[minResolution] {
-			addFailure("min_resolution", fmt.Sprintf("resolution %s below %s", value, minResolution))
+			addFailure("min_resolution", fmt.Sprintf("resolution %s below %s", value, minResolution), api.RuleDispositionStrict)
 		}
 	}
 
@@ -134,27 +150,27 @@ func EvaluateRules(ctx context.Context, tracker string, meta api.PreparedMetadat
 		if message == "" {
 			message = "adult content not allowed at " + name
 		}
-		addFailure("block_adult", message)
+		addWaivable("block_adult", message)
 	}
 
 	if rules.BlockDVDRip && strings.EqualFold(typeValue, "DVDRIP") {
-		addFailure("block_dvdrip", "DVDRip not allowed")
+		addStrict("block_dvdrip", "DVDRip not allowed")
 	}
 	if rules.BlockExternalSubs && hasReleaseToken(meta, []string{"extsub", "ext-sub", "external subs", "external subtitles"}) {
-		addFailure("block_external_subs", "external subtitles not allowed")
+		addWaivable("block_external_subs", "external subtitles not allowed")
 	}
 	if rules.BlockHardcodedSubs && hasReleaseToken(meta, []string{"hardsub", "hard-sub", "hardcoded"}) {
-		addFailure("block_hardcoded_subs", "hardcoded subtitles not allowed")
+		addStrict("block_hardcoded_subs", "hardcoded subtitles not allowed")
 	}
 
 	if rules.BlockSingleFileFolder && hasSingleFileFolder(meta) {
-		addFailure("block_single_file_folder", "single-file folders are not allowed")
+		addStrict("block_single_file_folder", "single-file folders are not allowed")
 	}
 
 	if len(rules.BlockGroups) > 0 {
 		group := strings.ToUpper(strings.TrimSpace(resolveGroup(meta)))
 		if group != "" && containsAny([]string{group}, rules.BlockGroups) {
-			addFailure("block_group", fmt.Sprintf("group %s not allowed", group))
+			addWaivable("block_group", fmt.Sprintf("group %s not allowed", group))
 		}
 	}
 
@@ -163,239 +179,61 @@ func EvaluateRules(ctx context.Context, tracker string, meta api.PreparedMetadat
 		if group != "" {
 			if allowedTypes, ok := rules.BlockGroupUnlessType[group]; ok {
 				if !hasTypeRequirement(typeValue, allowedTypes) {
-					addFailure("block_group_unless_type", fmt.Sprintf("group %s only allowed for %s", group, strings.Join(allowedTypes, ", ")))
+					addWaivable("block_group_unless_type", fmt.Sprintf("group %s only allowed for %s", group, strings.Join(allowedTypes, ", ")))
 				}
 			}
 		}
 	}
 
 	if rules.RequireSceneNFO && meta.Scene && strings.TrimSpace(meta.SceneNFOPath) == "" {
-		addFailure("require_scene_nfo", "scene release missing NFO")
+		addStrict("require_scene_nfo", "scene release missing NFO")
 	}
 
 	if rules.RequireAudioLanguages && len(meta.AudioLanguages) == 0 {
-		addFailure("require_audio_languages", "missing audio language data")
+		addStrict("require_audio_languages", "missing audio language data")
 	}
 
 	if rules.Language != nil {
 		if ok, reason := evaluateLanguageRule(meta, rules.Language); !ok {
-			addFailure("language_rule", reason)
+			addStrict("language_rule", reason)
 		}
 	}
 
-	if rules.ExtraCheck != nil {
-		result := rules.ExtraCheck(ctx, meta, logger)
-		if !result.Allowed {
-			addFailure("extra_check", result.Reason)
-		}
-	}
-
-	return failures
-}
-
-func evaluateAZFamilyRules(name string, meta api.PreparedMetadata) []api.RuleFailure {
-	failures := make([]api.RuleFailure, 0)
-	add := func(rule, reason string) {
-		failures = append(failures, api.RuleFailure{Rule: rule, Reason: reason})
-	}
-
-	category := strings.ToUpper(strings.TrimSpace(resolveCategory(meta)))
-	if category != "MOVIE" && category != "TV" {
-		add("content_type", "only movies and TV shows are allowed")
-	}
-	if meta.Anime {
-		add("anime_redirect", "anime should be uploaded to AnimeTorrents instead")
-	}
-
-	origin := originCountries(meta)
-	switch name {
-	case "AZ":
-		if intersects(origin, phdCountries()) {
-			add("country_redirect", "major English-language content belongs on PrivateHD")
-		} else if intersects(origin, cinemaZCountries()) {
-			add("country_redirect", "non-Asian western content belongs on CinemaZ")
-		}
-	case "CZ":
-		switch {
-		case intersects(origin, phdCountries()) && !isOlderThan50Years(meta):
-			add("country_redirect", "recent mainstream English content belongs on PrivateHD")
-		case intersects(origin, azCountries()):
-			add("country_redirect", "Asian content belongs on AvistaZ")
-		case len(origin) > 0 && !intersects(origin, czAllowedCountries()):
-			add("country_block", "content origin is outside CinemaZ allowed regions")
-		}
-	case "PHD":
-		if isOlderThan50Years(meta) {
-			add("age_redirect", "50+ year-old content belongs on CinemaZ")
+	if rules.Check != nil {
+		customFailures, err := rules.Check(ctx, meta, logger)
+		if err != nil {
+			return nil, fmt.Errorf("trackers: %s rule check: %w", name, err)
 		}
-		switch {
-		case intersects(origin, cinemaZCountries()):
-			add("country_redirect", "European, South American, and African content belongs on CinemaZ")
-		case intersects(origin, azCountries()):
-			add("country_redirect", "Asian content belongs on AvistaZ")
-		case len(origin) > 0 && !intersects(origin, phdCountries()):
-			add("country_block", "PrivateHD only allows major English-language territories")
+		for _, failure := range customFailures {
+			addFailure(failure.Rule, failure.Reason, failure.Disposition)
 		}
 	}
 
-	if name == "PHD" {
-		evaluatePHDTechnicalRules(meta, add)
-	}
-
-	return failures
+	return failures, nil
 }
 
-func evaluatePHDTechnicalRules(meta api.PreparedMetadata, add func(string, string)) {
-	if strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "480p") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "576p") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "480i") ||
-		strings.EqualFold(strings.TrimSpace(meta.Release.Resolution), "576i") {
-		add("sd_forbidden", "SD content is forbidden")
-	}
+// ResolveRuleCategory returns the common category used by tracker rules.
+func ResolveRuleCategory(meta api.RuleSubject) string { return resolveCategory(meta) }
 
-	if !isDiscType(meta.DiscType) {
-		container := strings.ToLower(strings.TrimSpace(meta.Container))
-		if container != "" && container != "mkv" && container != "mp4" {
-			add("container", "allowed containers: MKV, MP4")
-		}
-	}
+// ResolveRuleType returns the common release type used by tracker rules.
+func ResolveRuleType(meta api.RuleSubject) string { return resolveType(meta) }
 
-	group := strings.ToUpper(strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-"))
-	switch group {
-	case "RARBG", "FGT", "GRYM", "TBS":
-		add("group_block", "RARBG, FGT, Grym, and TBS are not allowed")
-	}
-	if group == "EVO" && !strings.EqualFold(strings.TrimSpace(meta.Source), "WEB") {
-		add("group_block", "non-web EVO releases are not allowed")
-	}
+// ResolveRuleResolution returns the common resolution used by tracker rules.
+func ResolveRuleResolution(meta api.RuleSubject) string { return resolveResolution(meta) }
 
-	codec := strings.ToLower(strings.TrimSpace(meta.VideoCodec))
-	encode := strings.ToLower(strings.TrimSpace(meta.VideoEncode))
-	releaseType := strings.ToLower(strings.TrimSpace(resolveType(meta)))
-	source := strings.ToLower(strings.TrimSpace(meta.Source))
-	bitDepth := strings.TrimSpace(meta.BitDepth)
+// IsDiscType reports whether value identifies a supported disc source.
+func IsDiscType(value string) bool { return isDiscType(value) }
 
-	if releaseType == "remux" && codec != "" && codec != "mpeg-2" && codec != "vc-1" && codec != "h.264" && codec != "h.265" && codec != "avc" {
-		add("video_codec", "BluRay remuxes require MPEG-2, VC-1, H.264, or H.265")
-	}
-	if releaseType == "encode" && strings.Contains(source, "bluray") && encode != "" && encode != "h.264" && encode != "h.265" && encode != "x264" && encode != "x265" {
-		add("video_encode", "BluRay encodes require H.264/H.265 with x264/x265")
-	}
-	if (releaseType == "webdl" || releaseType == "web-dl") && source == "web" && encode != "" && encode != "h.264" && encode != "h.265" && encode != "vp9" {
-		add("video_encode", "WEB-DL requires H.264, H.265, or VP9")
-	}
-	if releaseType == "encode" && source == "web" && encode != "" && encode != "h.264" && encode != "h.265" && encode != "x264" && encode != "x265" {
-		add("video_encode", "WEB encodes require H.264/H.265 with x264/x265")
-	}
-	if releaseType == "encode" && encode == "x265" && bitDepth != "10" {
-		add("bit_depth", "x265 encodes must be 10-bit")
-	}
-	if res := strings.ToLower(strings.TrimSpace(resolveResolution(meta))); strings.HasSuffix(res, "p") {
-		value := strings.TrimSuffix(res, "p")
-		if height, err := strconv.Atoi(value); err == nil && height > 1080 && (encode == "h.264" || encode == "x264") {
-			add("video_encode", "H.264/x264 is only allowed for 1080p and below")
-		}
-	}
-}
-
-func originCountries(meta api.PreparedMetadata) []string {
-	if meta.ExternalMetadata.TMDB != nil && len(meta.ExternalMetadata.TMDB.OriginCountry) > 0 {
-		return meta.ExternalMetadata.TMDB.OriginCountry
-	}
-	return nil
-}
-
-func isOlderThan50Years(meta api.PreparedMetadata) bool {
-	year := meta.Release.Year
-	if year == 0 && meta.ExternalMetadata.TMDB != nil {
-		year = meta.ExternalMetadata.TMDB.Year
-	}
-	return year > 0 && time.Now().UTC().Year()-year >= 50
-}
-
-func intersects(left []string, right map[string]struct{}) bool {
-	for _, value := range left {
-		if _, ok := right[strings.ToUpper(strings.TrimSpace(value))]; ok {
-			return true
-		}
-	}
-	return false
-}
-
-func azCountries() map[string]struct{} {
-	return countrySet("BD", "BN", "BT", "CN", "HK", "ID", "IN", "JP", "KH", "KP", "KR", "LA", "LK", "MM", "MN", "MO", "MY", "NP", "PH", "PK", "SG", "TH", "TL", "TW", "VN")
-}
-
-func phdCountries() map[string]struct{} {
-	return countrySet("AG", "AI", "AU", "BB", "BM", "BS", "BZ", "CA", "CW", "DM", "GB", "GD", "IE", "JM", "KN", "KY", "LC", "MS", "NZ", "PR", "TC", "TT", "US", "VC", "VG", "VI")
-}
-
-func cinemaZCountries() map[string]struct{} {
-	all := countrySet("AO", "BF", "BI", "BJ", "BW", "CD", "CF", "CG", "CI", "CM", "CV", "DJ", "DZ", "EG", "EH", "ER", "ET", "GA", "GH", "GM", "GN", "GQ", "GW", "IO", "KE", "KM", "LR", "LS", "LY", "MA", "MG", "ML", "MR", "MU", "MW", "MZ", "NA", "NE", "NG", "RE", "RW", "SC", "SD", "SH", "SL", "SN", "SO", "SS", "ST", "SZ", "TD", "TF", "TG", "TN", "TZ", "UG", "YT", "ZA", "ZM", "ZW",
-		"AG", "AI", "AR", "AW", "BB", "BL", "BM", "BO", "BQ", "BR", "BS", "BV", "BZ", "CA", "CL", "CO", "CR", "CU", "CW", "DM", "DO", "EC", "FK", "GD", "GF", "GL", "GP", "GS", "GT", "GY", "HN", "HT", "JM", "KN", "KY", "LC", "MF", "MQ", "MS", "MX", "NI", "PA", "PE", "PM", "PR", "PY", "SR", "SV", "SX", "TC", "TT", "US", "UY", "VC", "VE", "VG", "VI",
-		"AD", "AL", "AT", "AX", "BA", "BE", "BG", "BY", "CH", "CZ", "DE", "DK", "EE", "ES", "FI", "FO", "FR", "GB", "GG", "GI", "GR", "HR", "HU", "IE", "IM", "IS", "IT", "JE", "LI", "LT", "LU", "LV", "MC", "MD", "ME", "MK", "MT", "NL", "NO", "PL", "PT", "RO", "RS", "RU", "SE", "SI", "SJ", "SK", "SM", "SU", "UA", "VA", "XC",
-		"AS", "AU", "CC", "CK", "CX", "FJ", "FM", "GU", "HM", "KI", "MH", "MP", "NC", "NF", "NR", "NU", "NZ", "PF", "PG", "PN", "PW", "SB", "TK", "TO", "TV", "UM", "VU", "WF", "WS")
-	for code := range phdCountries() {
-		delete(all, code)
-	}
-	for code := range azCountries() {
-		delete(all, code)
-	}
-	return all
-}
-
-func czAllowedCountries() map[string]struct{} {
-	return countrySet("AD", "AL", "AT", "AX", "BA", "BE", "BG", "BY", "CH", "CZ", "DE", "DK", "EE", "ES", "FI", "FO", "FR", "GI", "GR", "HR", "HU", "IS", "IT", "LI", "LT", "LU", "LV", "MC", "MD", "ME", "MK", "MT", "NL", "NO", "PL", "PT", "RO", "RS", "RU", "SE", "SI", "SJ", "SK", "SM", "SU", "UA", "VA", "XC",
-		"AG", "AI", "AR", "AW", "BL", "BO", "BQ", "BR", "BV", "CL", "CO", "CU", "DO", "EC", "FK", "GF", "GL", "GP", "GS", "GT", "GY", "HN", "HT", "MF", "MQ", "MX", "NI", "PA", "PE", "PM", "PY", "SR", "SV", "SX", "UY", "VE",
-		"AO", "BF", "BI", "BJ", "BW", "CD", "CF", "CG", "CI", "CM", "CV", "DJ", "DZ", "EG", "EH", "ER", "ET", "GA", "GH", "GM", "GN", "GQ", "GW", "IO", "KE", "KM", "LR", "LS", "LY", "MA", "MG", "ML", "MR", "MU", "MW", "MZ", "NA", "NE", "NG", "RE", "RW", "SC", "SD", "SH", "SL", "SN", "SO", "SS", "ST", "SZ", "TD", "TF", "TG", "TN", "TZ", "UG", "YT", "ZA", "ZM", "ZW",
-		"AE", "BH", "CY", "IR", "IQ", "IL", "JO", "KW", "LB", "OM", "PS", "QA", "SA", "SY", "TR", "YE")
-}
-
-func countrySet(values ...string) map[string]struct{} {
-	out := make(map[string]struct{}, len(values))
-	for _, value := range values {
-		out[value] = struct{}{}
-	}
-	return out
-}
-
-func resolveCategory(meta api.PreparedMetadata) string {
-	if sourceMatches(meta.ExternalIDs.SourcePath, meta.SourcePath) {
-		if value := strings.ToLower(strings.TrimSpace(meta.ExternalIDs.Category)); value != "" {
+func resolveCategory(meta api.RuleSubject) string {
+	if sourceMatches(meta.Identity.SourcePath, meta.SourcePath) {
+		if value := strings.ToLower(strings.TrimSpace(string(meta.Identity.Category))); value != "" && value != string(api.CanonicalCategoryUnknown) {
 			return value
 		}
 	}
-	if value := strings.ToLower(strings.TrimSpace(meta.MediaInfoCategory)); value != "" {
-		return value
-	}
-	if sourceMatches(meta.ExternalMetadata.SourcePath, meta.SourcePath) {
-		if meta.ExternalMetadata.TMDB != nil {
-			if value := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.TMDB.Category)); value != "" {
-				return value
-			}
-		}
-		if (meta.ExternalMetadata.TVDB != nil &&
-			(strings.TrimSpace(meta.ExternalMetadata.TVDB.Name) != "" || strings.TrimSpace(meta.ExternalMetadata.TVDB.NameEnglish) != "")) ||
-			(meta.ExternalMetadata.TVmaze != nil && strings.TrimSpace(meta.ExternalMetadata.TVmaze.Name) != "") {
-			return "tv"
-		}
-		if meta.ExternalMetadata.IMDB != nil {
-			typeValue := strings.ToLower(strings.TrimSpace(meta.ExternalMetadata.IMDB.Type))
-			switch {
-			case strings.Contains(typeValue, "tv"), strings.Contains(typeValue, "series"), strings.Contains(typeValue, "episode"):
-				return "tv"
-			case strings.Contains(typeValue, "movie"), strings.Contains(typeValue, "film"), strings.Contains(typeValue, "feature"):
-				return "movie"
-			}
-		}
-	}
-	if value := strings.ToLower(strings.TrimSpace(meta.Release.Category)); value != "" {
-		return value
-	}
 	return ""
 }
 
-func resolveType(meta api.PreparedMetadata) string {
+func resolveType(meta api.RuleSubject) string {
 	value := strings.ToUpper(strings.TrimSpace(meta.Type))
 	if value == "" {
 		value = strings.ToUpper(strings.TrimSpace(meta.Release.Type))
@@ -403,14 +241,14 @@ func resolveType(meta api.PreparedMetadata) string {
 	return value
 }
 
-func resolveGroup(meta api.PreparedMetadata) string {
+func resolveGroup(meta api.RuleSubject) string {
 	if group := strings.TrimSpace(meta.Release.Group); group != "" {
 		return group
 	}
 	return strings.TrimPrefix(strings.TrimSpace(meta.Tag), "-")
 }
 
-func resolveResolution(meta api.PreparedMetadata) string {
+func resolveResolution(meta api.RuleSubject) string {
 	resolution := strings.TrimSpace(meta.Release.Resolution)
 	if resolution == "" {
 		resolution = detectResolution(meta.ReleaseName)
@@ -437,7 +275,7 @@ func isDiscType(value string) bool {
 	}
 }
 
-func isHEVC(meta api.PreparedMetadata) bool {
+func isHEVC(meta api.RuleSubject) bool {
 	codec := strings.ToUpper(strings.TrimSpace(meta.VideoCodec))
 	if codec == "" {
 		for _, value := range meta.Release.Codec {
@@ -462,7 +300,7 @@ func hasTypeRequirement(value string, allowed []string) bool {
 	return false
 }
 
-func hasSingleFileFolder(meta api.PreparedMetadata) bool {
+func hasSingleFileFolder(meta api.RuleSubject) bool {
 	if isDiscType(meta.DiscType) {
 		return false
 	}
@@ -472,7 +310,7 @@ func hasSingleFileFolder(meta api.PreparedMetadata) bool {
 	return !strings.EqualFold(strings.TrimSpace(meta.FileList[0]), strings.TrimSpace(meta.SourcePath))
 }
 
-func hasReleaseToken(meta api.PreparedMetadata, tokens []string) bool {
+func hasReleaseToken(meta api.RuleSubject, tokens []string) bool {
 	values := make([]string, 0, len(meta.Release.Other)+len(meta.Release.Edition)+2)
 	values = append(values, meta.Release.Other...)
 	values = append(values, meta.Release.Edition...)
@@ -494,14 +332,14 @@ func hasReleaseToken(meta api.PreparedMetadata, tokens []string) bool {
 	return false
 }
 
-func isAdultContent(meta api.PreparedMetadata) bool {
+func isAdultContent(meta api.RuleSubject) bool {
 	candidates := append([]string{}, splitCSV(meta.Release.Genre)...)
-	if meta.ExternalMetadata.TMDB != nil && externalMetadataMatchesCurrentSource(meta) {
-		candidates = append(candidates, splitCSV(meta.ExternalMetadata.TMDB.Genres)...)
-		candidates = append(candidates, splitCSV(meta.ExternalMetadata.TMDB.Keywords)...)
+	if meta.ProviderMetadata.TMDB != nil && externalMetadataMatchesCurrentSource(meta) {
+		candidates = append(candidates, splitCSV(meta.ProviderMetadata.TMDB.Genres)...)
+		candidates = append(candidates, splitCSV(meta.ProviderMetadata.TMDB.Keywords)...)
 	}
-	if meta.ExternalMetadata.IMDB != nil && externalMetadataMatchesCurrentSource(meta) {
-		candidates = append(candidates, splitCSV(meta.ExternalMetadata.IMDB.Genres)...)
+	if meta.ProviderMetadata.IMDB != nil && externalMetadataMatchesCurrentSource(meta) {
+		candidates = append(candidates, splitCSV(meta.ProviderMetadata.IMDB.Genres)...)
 	}
 	normalized := normalizeStrings(candidates)
 	for _, token := range normalized {
@@ -513,8 +351,8 @@ func isAdultContent(meta api.PreparedMetadata) bool {
 	return false
 }
 
-func externalMetadataMatchesCurrentSource(meta api.PreparedMetadata) bool {
-	storedSource := strings.TrimSpace(meta.ExternalMetadata.SourcePath)
+func externalMetadataMatchesCurrentSource(meta api.RuleSubject) bool {
+	storedSource := strings.TrimSpace(meta.ProviderMetadata.SourcePath)
 	return storedSource == "" || pathutil.SamePath(storedSource, strings.TrimSpace(meta.SourcePath))
 }
 
@@ -566,7 +404,7 @@ func containsAny(values []string, targets []string) bool {
 	return false
 }
 
-func evaluateLanguageRule(meta api.PreparedMetadata, rule *additional.LanguageRule) (bool, string) {
+func evaluateLanguageRule(meta api.RuleSubject, rule *LanguageRule) (bool, string) {
 	if rule == nil {
 		return true, ""
 	}
@@ -633,13 +471,13 @@ func evaluateLanguageRule(meta api.PreparedMetadata, rule *additional.LanguageRu
 	return false, "requires audio or subtitles in " + strings.Join(required, ", ")
 }
 
-func resolveOriginalLanguage(meta api.PreparedMetadata) string {
+func resolveOriginalLanguage(meta api.RuleSubject) string {
 	var raw string
-	if meta.ExternalMetadata.TMDB != nil {
-		raw = strings.TrimSpace(meta.ExternalMetadata.TMDB.OriginalLanguage)
+	if meta.ProviderMetadata.TMDB != nil {
+		raw = strings.TrimSpace(meta.ProviderMetadata.TMDB.OriginalLanguage)
 	}
-	if raw == "" && meta.ExternalMetadata.IMDB != nil {
-		raw = strings.TrimSpace(meta.ExternalMetadata.IMDB.OriginalLanguage)
+	if raw == "" && meta.ProviderMetadata.IMDB != nil {
+		raw = strings.TrimSpace(meta.ProviderMetadata.IMDB.OriginalLanguage)
 	}
 	normalized := languageutil.NormalizeLanguageDisplay(raw)
 	if normalized == "" {
diff --git a/internal/trackers/rules_internal_test.go b/internal/trackers/rules_internal_test.go
new file mode 100644
index 00000000..09657bac
--- /dev/null
+++ b/internal/trackers/rules_internal_test.go
@@ -0,0 +1,194 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestResolveCategoryUsesCanonicalIdentityDespiteEmptyTVMetadata(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		metadata api.SourceScopedMetadata
+	}{
+		{name: "TVDB", metadata: api.SourceScopedMetadata{TVDB: &api.TVDBMetadata{}}},
+		{name: "TVmaze", metadata: api.SourceScopedMetadata{TVmaze: &api.TVmazeMetadata{}}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			meta := api.RuleSubject{
+				Identity:         api.ExternalIdentity{Category: api.CanonicalCategoryMovie},
+				ProviderMetadata: tt.metadata,
+			}
+			if got := resolveCategory(meta); got != "movie" {
+				t.Fatalf("expected canonical movie category, got %q", got)
+			}
+		})
+	}
+}
+
+func TestConfiguredStrictRuleDispositions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		rule    string
+		rules   RuleSet
+		subject api.RuleSubject
+	}{
+		{
+			name:  "unique ID",
+			rule:  "require_unique_id",
+			rules: RuleSet{RequireUniqueID: true},
+			subject: api.RuleSubject{Assessments: api.ReleaseAssessments{
+				MediaInfoUniqueID: api.UniqueIDStatusMissing,
+			}},
+		},
+		{
+			name:  "MediaInfo settings",
+			rule:  "require_valid_mi_setting",
+			rules: RuleSet{RequireValidMISetting: true},
+			subject: api.RuleSubject{Assessments: api.ReleaseAssessments{
+				MediaInfoEncodeSettings: api.EncodeSettingsStatusMissing,
+			}},
+		},
+		{
+			name:    "disc only",
+			rule:    "require_disc_only",
+			rules:   RuleSet{RequireDiscOnly: true},
+			subject: api.RuleSubject{},
+		},
+		{
+			name:  "movie only",
+			rule:  "require_movie_only",
+			rules: RuleSet{RequireMovieOnly: true},
+			subject: api.RuleSubject{Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryTV,
+			}},
+		},
+		{
+			name:  "movie unless TV pack",
+			rule:  "require_movie_only",
+			rules: RuleSet{RequireMovieUnlessTVPack: true},
+			subject: api.RuleSubject{Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryTV,
+			}},
+		},
+		{
+			name:  "TV only",
+			rule:  "require_tv_only",
+			rules: RuleSet{RequireTVOnly: true},
+			subject: api.RuleSubject{Identity: api.ExternalIdentity{
+				Category: api.CanonicalCategoryMovie,
+			}},
+		},
+		{
+			name:  "HEVC",
+			rule:  "require_hevc",
+			rules: RuleSet{RequireHEVCForTypes: []string{"ENCODE"}},
+			subject: api.RuleSubject{
+				Type:       "ENCODE",
+				VideoCodec: "AVC",
+			},
+		},
+		{
+			name:    "DVDRip",
+			rule:    "block_dvdrip",
+			rules:   RuleSet{BlockDVDRip: true},
+			subject: api.RuleSubject{Type: "DVDRIP"},
+		},
+		{
+			name:    "hardcoded subtitles",
+			rule:    "block_hardcoded_subs",
+			rules:   RuleSet{BlockHardcodedSubs: true},
+			subject: api.RuleSubject{ReleaseName: "Example.Release.2026.HARDSUB-GRP"},
+		},
+		{
+			name:  "single-file folder",
+			rule:  "block_single_file_folder",
+			rules: RuleSet{BlockSingleFileFolder: true},
+			subject: api.RuleSubject{
+				SourcePath: "Example.Release.2026",
+				FileList:   []string{"Example.Release.2026/video.mkv"},
+			},
+		},
+		{
+			name:  "scene NFO",
+			rule:  "require_scene_nfo",
+			rules: RuleSet{RequireSceneNFO: true},
+			subject: api.RuleSubject{
+				Scene: true,
+			},
+		},
+		{
+			name:    "audio language metadata",
+			rule:    "require_audio_languages",
+			rules:   RuleSet{RequireAudioLanguages: true},
+			subject: api.RuleSubject{},
+		},
+		{
+			name: "language requirement",
+			rule: "language_rule",
+			rules: RuleSet{Language: &LanguageRule{
+				Languages:    []string{"english"},
+				RequireAudio: true,
+			}},
+			subject: api.RuleSubject{AudioLanguages: []string{"french"}},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			registry := NewRegistry()
+			if err := registry.RegisterDescriptor(Descriptor{
+				Name:       "STRICT",
+				Definition: stubDefinition{name: "STRICT"},
+				Rules:      &test.rules,
+			}); err != nil {
+				t.Fatalf("register rule: %v", err)
+			}
+			failures, err := evaluateRules(context.Background(), registry, "STRICT", test.subject, nil)
+			if err != nil {
+				t.Fatalf("evaluate rule: %v", err)
+			}
+			for _, failure := range failures {
+				if failure.Rule == test.rule {
+					if failure.Disposition != api.RuleDispositionStrict {
+						t.Fatalf("%s disposition = %q, want strict", test.rule, failure.Disposition)
+					}
+					return
+				}
+			}
+			t.Fatalf("missing %s failure: %#v", test.rule, failures)
+		})
+	}
+}
+
+func TestMetadataCategoryDispositionUsesStrictestRequirement(t *testing.T) {
+	t.Parallel()
+
+	policy := TrackerMetadataPolicy{Requirements: []MetadataRequirement{
+		{
+			Scope:       MetadataScopeAny,
+			AnyOf:       []MetadataField{MetadataFieldPoster},
+			Disposition: api.RuleDispositionWaivable,
+		},
+		{
+			Scope:       MetadataScopeMovie,
+			AnyOf:       []MetadataField{MetadataFieldTMDB},
+			Disposition: api.RuleDispositionStrict,
+		},
+	}}
+	if got := metadataCategoryDisposition(policy); got != api.RuleDispositionStrict {
+		t.Fatalf("category disposition = %q, want strict", got)
+	}
+}
diff --git a/internal/trackers/rules_test.go b/internal/trackers/rules_test.go
index e34c22cf..886979ee 100644
--- a/internal/trackers/rules_test.go
+++ b/internal/trackers/rules_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package trackers
+package trackers_test
 
 import (
 	"context"
@@ -10,55 +10,77 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/trackers/impl"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func evaluateNonMetadataRulesForTest(ctx context.Context, tracker string, meta api.PreparedMetadata) []api.RuleFailure {
-	if strings.TrimSpace(meta.ExternalIDs.Category) == "" {
+func evaluateNonMetadataRulesForTest(ctx context.Context, tracker string, meta api.RuleSubject) []api.RuleFailure {
+	if strings.TrimSpace(string(meta.Identity.Category)) == "" {
 		switch strings.ToUpper(strings.TrimSpace(tracker)) {
 		case "NBL", "BTN":
-			meta.ExternalIDs.Category = "TV"
+			meta.Identity.Category = api.CanonicalCategoryTV
 		default:
-			meta.ExternalIDs.Category = "MOVIE"
+			meta.Identity.Category = api.CanonicalCategoryMovie
 		}
 	}
-	meta.ExternalIDs.TMDBID = 1
-	meta.ExternalIDs.IMDBID = 1234567
-	meta.ExternalIDs.TVDBID = 1
-	meta.ExternalIDs.TVmazeID = 1
-	if meta.ExternalMetadata.TMDB == nil {
-		meta.ExternalMetadata.TMDB = &api.TMDBMetadata{}
+	meta.Identity.TMDBID = 1
+	meta.Identity.IMDBID = 1234567
+	meta.Identity.TVDBID = 1
+	meta.Identity.TVmazeID = 1
+	if meta.ProviderMetadata.TMDB == nil {
+		meta.ProviderMetadata.TMDB = &api.TMDBMetadata{}
 	}
-	meta.ExternalMetadata.TMDB.TMDBID = 1
-	if strings.TrimSpace(meta.ExternalMetadata.TMDB.Title) == "" {
-		meta.ExternalMetadata.TMDB.Title = "Example Release"
+	meta.ProviderMetadata.TMDB.TMDBID = 1
+	if strings.TrimSpace(meta.ProviderMetadata.TMDB.Title) == "" {
+		meta.ProviderMetadata.TMDB.Title = "Example Release"
 	}
-	if meta.ExternalMetadata.IMDB == nil {
-		meta.ExternalMetadata.IMDB = &api.IMDBMetadata{}
+	if meta.ProviderMetadata.IMDB == nil {
+		meta.ProviderMetadata.IMDB = &api.IMDBMetadata{}
 	}
-	meta.ExternalMetadata.IMDB.IMDBID = 1234567
-	if strings.TrimSpace(meta.ExternalMetadata.IMDB.Title) == "" {
-		meta.ExternalMetadata.IMDB.Title = "Example Release"
+	meta.ProviderMetadata.IMDB.IMDBID = 1234567
+	if strings.TrimSpace(meta.ProviderMetadata.IMDB.Title) == "" {
+		meta.ProviderMetadata.IMDB.Title = "Example Release"
 	}
-	if meta.ExternalMetadata.TVDB == nil {
-		meta.ExternalMetadata.TVDB = &api.TVDBMetadata{}
+	if meta.ProviderMetadata.TVDB == nil {
+		meta.ProviderMetadata.TVDB = &api.TVDBMetadata{}
 	}
-	meta.ExternalMetadata.TVDB.TVDBID = 1
-	if strings.TrimSpace(meta.ExternalMetadata.TVDB.Name) == "" {
-		meta.ExternalMetadata.TVDB.Name = "Example Series"
+	meta.ProviderMetadata.TVDB.TVDBID = 1
+	if strings.TrimSpace(meta.ProviderMetadata.TVDB.Name) == "" {
+		meta.ProviderMetadata.TVDB.Name = "Example Series"
 	}
-	if meta.ExternalMetadata.TVmaze == nil {
-		meta.ExternalMetadata.TVmaze = &api.TVmazeMetadata{}
+	if meta.ProviderMetadata.TVmaze == nil {
+		meta.ProviderMetadata.TVmaze = &api.TVmazeMetadata{}
 	}
-	meta.ExternalMetadata.TVmaze.TVmazeID = 1
-	if strings.TrimSpace(meta.ExternalMetadata.TVmaze.Name) == "" {
-		meta.ExternalMetadata.TVmaze.Name = "Example Series"
+	meta.ProviderMetadata.TVmaze.TVmazeID = 1
+	if strings.TrimSpace(meta.ProviderMetadata.TVmaze.Name) == "" {
+		meta.ProviderMetadata.TVmaze.Name = "Example Series"
 	}
-	return EvaluateRules(ctx, tracker, meta, nil)
+	registry, err := impl.NewRegistry()
+	if err != nil {
+		panic(err)
+	}
+	failures, err := trackers.EvaluateRulesWithRegistry(ctx, registry, tracker, meta, nil)
+	if err != nil {
+		panic(err)
+	}
+	return failures
+}
+
+func evaluateBHDRulesWithRegistryForTest(ctx context.Context, meta api.RuleSubject) []api.RuleFailure {
+	registry, err := impl.NewRegistry()
+	if err != nil {
+		panic(err)
+	}
+	failures, err := trackers.EvaluateRulesWithRegistry(ctx, registry, "BHD", meta, nil)
+	if err != nil {
+		panic(err)
+	}
+	return failures
 }
 
 func TestEvaluateRulesRequiresUniqueID(t *testing.T) {
-	meta := api.PreparedMetadata{ValidMediaInfo: false}
+	meta := api.RuleSubject{Assessments: api.ReleaseAssessments{MediaInfoUniqueID: api.UniqueIDStatusMissing}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "AITHER", meta)
 	if len(failures) == 0 {
 		t.Fatalf("expected rule failure")
@@ -68,31 +90,6 @@ func TestEvaluateRulesRequiresUniqueID(t *testing.T) {
 	}
 }
 
-func TestResolveCategoryIgnoresEmptyTVMetadata(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		metadata api.ExternalMetadata
-	}{
-		{name: "TVDB", metadata: api.ExternalMetadata{TVDB: &api.TVDBMetadata{}}},
-		{name: "TVmaze", metadata: api.ExternalMetadata{TVmaze: &api.TVmazeMetadata{}}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			meta := api.PreparedMetadata{
-				ExternalMetadata: tt.metadata,
-				Release:          api.ReleaseInfo{Category: "movie"},
-			}
-			if got := resolveCategory(meta); got != "movie" {
-				t.Fatalf("expected movie fallback, got %q", got)
-			}
-		})
-	}
-}
-
 func hasMISettingsFailure(failures []api.RuleFailure) bool {
 	for _, failure := range failures {
 		if failure.Rule == "require_valid_mi_setting" {
@@ -102,13 +99,17 @@ func hasMISettingsFailure(failures []api.RuleFailure) bool {
 	return false
 }
 
+func encodeAssessments(status api.EncodeSettingsStatus) api.ReleaseAssessments {
+	return api.ReleaseAssessments{MediaInfoEncodeSettings: status}
+}
+
 func TestEvaluateRulesUnit3DEnforcesMediaInfoSettings(t *testing.T) {
 	// RF is a known UNIT3D tracker but its RuleSet does not opt into
 	// RequireValidMISetting; the UNIT3D upload rejects encodes without encoding
 	// settings, so the rule must fire at prep time regardless.
-	meta := api.PreparedMetadata{
-		ExternalIDs:            api.ExternalIDs{Category: "movie"},
-		ValidMediaInfoSettings: false,
+	meta := api.RuleSubject{
+		Identity:    api.ExternalIdentity{Category: "movie"},
+		Assessments: encodeAssessments(api.EncodeSettingsStatusMissing),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RF", meta)
 	if !hasMISettingsFailure(failures) {
@@ -119,23 +120,23 @@ func TestEvaluateRulesUnit3DEnforcesMediaInfoSettings(t *testing.T) {
 func TestEvaluateRulesUnit3DWithoutRuleSetEnforcesMediaInfoSettings(t *testing.T) {
 	// ACM is a known UNIT3D tracker with no tracker-specific RuleSet. The early
 	// "not found" return must not skip the MediaInfo-settings enforcement.
-	meta := api.PreparedMetadata{ValidMediaInfoSettings: false}
+	meta := api.RuleSubject{Assessments: encodeAssessments(api.EncodeSettingsStatusMissing)}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "ACM", meta)
 	if !hasMISettingsFailure(failures) {
 		t.Fatalf("expected require_valid_mi_setting failure for ACM, got %#v", failures)
 	}
 
-	meta.ValidMediaInfoSettings = true
+	meta.Assessments.MediaInfoEncodeSettings = api.EncodeSettingsStatusPresent
 	failures = evaluateNonMetadataRulesForTest(context.Background(), "ACM", meta)
 	if len(failures) != 0 {
 		t.Fatalf("expected no failures for ACM with valid MI settings, got %#v", failures)
 	}
 }
 
-func TestEvaluateRulesUnit3DAllowsValidMediaInfoSettings(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:            api.ExternalIDs{Category: "movie"},
-		ValidMediaInfoSettings: true,
+func TestEvaluateRulesUnit3DAllowsPresentMediaInfoEncodeSettings(t *testing.T) {
+	meta := api.RuleSubject{
+		Identity:    api.ExternalIdentity{Category: "movie"},
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RF", meta)
 	if hasMISettingsFailure(failures) {
@@ -146,7 +147,7 @@ func TestEvaluateRulesUnit3DAllowsValidMediaInfoSettings(t *testing.T) {
 func TestEvaluateRulesNonUnit3DOptInMediaInfoSettings(t *testing.T) {
 	// BHD is not a UNIT3D-upload tracker but opts in via its RuleSet, so the
 	// per-tracker flag must still be honored.
-	meta := api.PreparedMetadata{ValidMediaInfoSettings: false}
+	meta := api.RuleSubject{Assessments: encodeAssessments(api.EncodeSettingsStatusMissing)}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "BHD", meta)
 	if !hasMISettingsFailure(failures) {
 		t.Fatalf("expected require_valid_mi_setting failure for BHD, got %#v", failures)
@@ -154,10 +155,10 @@ func TestEvaluateRulesNonUnit3DOptInMediaInfoSettings(t *testing.T) {
 }
 
 func TestEvaluateRulesLanguageRulePasses(t *testing.T) {
-	meta := api.PreparedMetadata{
-		AudioLanguages:         []string{"french"},
-		SubtitleLanguages:      nil,
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		AudioLanguages:    []string{"french"},
+		SubtitleLanguages: nil,
+		Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "TOS", meta)
 	if len(failures) != 0 {
@@ -166,7 +167,7 @@ func TestEvaluateRulesLanguageRulePasses(t *testing.T) {
 }
 
 func TestEvaluateRulesLanguageRuleMissingData(t *testing.T) {
-	meta := api.PreparedMetadata{ValidMediaInfoSettings: true}
+	meta := api.RuleSubject{Assessments: encodeAssessments(api.EncodeSettingsStatusPresent)}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "TOS", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
@@ -174,16 +175,19 @@ func TestEvaluateRulesLanguageRuleMissingData(t *testing.T) {
 	if failures[0].Rule != "language_rule" {
 		t.Fatalf("unexpected rule key: %s", failures[0].Rule)
 	}
+	if failures[0].Disposition != api.RuleDispositionStrict {
+		t.Fatalf("language disposition = %q, want strict", failures[0].Disposition)
+	}
 }
 
 func TestEvaluateRulesLanguageRuleOriginalFallback(t *testing.T) {
-	meta := api.PreparedMetadata{
-		AudioLanguages:         []string{"Japanese"},
-		SubtitleLanguages:      []string{"English"},
-		ValidMediaInfoSettings: true,
-		Container:              "mkv",
-		Release:                api.ReleaseInfo{Resolution: "720p"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		AudioLanguages:    []string{"Japanese"},
+		SubtitleLanguages: []string{"English"},
+		Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
+		Container:         "mkv",
+		Release:           api.ReleaseInfo{Resolution: "720p"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -194,32 +198,35 @@ func TestEvaluateRulesLanguageRuleOriginalFallback(t *testing.T) {
 }
 
 func TestEvaluateRulesLUMERequiresMKVForNonDisc(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Container:              "mp4",
-		AudioLanguages:         []string{"English"},
-		SubtitleLanguages:      []string{"English"},
-		ValidMediaInfoSettings: true,
-		Release:                api.ReleaseInfo{Resolution: "720p"},
+	meta := api.RuleSubject{
+		Container:         "mp4",
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:           api.ReleaseInfo{Resolution: "720p"},
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "LUME", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
 	}
-	if failures[0].Rule != "extra_check" {
+	if failures[0].Rule != "container" {
 		t.Fatalf("unexpected rule key: %s", failures[0].Rule)
 	}
+	if failures[0].Disposition != api.RuleDispositionStrict {
+		t.Fatalf("container disposition = %q, want strict", failures[0].Disposition)
+	}
 	if failures[0].Reason != "LUME only allows MKV containers for non-disc uploads." {
 		t.Fatalf("unexpected failure reason: %s", failures[0].Reason)
 	}
 }
 
 func TestEvaluateRulesLUMEAllowsMKVForNonDisc(t *testing.T) {
-	meta := api.PreparedMetadata{
-		Container:              "mkv",
-		AudioLanguages:         []string{"English"},
-		SubtitleLanguages:      []string{"English"},
-		ValidMediaInfoSettings: true,
-		Release:                api.ReleaseInfo{Resolution: "720p"},
+	meta := api.RuleSubject{
+		Container:         "mkv",
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:           api.ReleaseInfo{Resolution: "720p"},
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "LUME", meta)
 	if len(failures) != 0 {
@@ -228,11 +235,11 @@ func TestEvaluateRulesLUMEAllowsMKVForNonDisc(t *testing.T) {
 }
 
 func TestEvaluateRulesLUMESkipsContainerRuleForDisc(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:               "BDMV",
-		Container:              "mp4",
-		ValidMediaInfoSettings: true,
-		Release:                api.ReleaseInfo{Resolution: "480p"},
+	meta := api.RuleSubject{
+		DiscType:    "BDMV",
+		Container:   "mp4",
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:     api.ReleaseInfo{Resolution: "480p"},
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "LUME", meta)
 	if len(failures) != 0 {
@@ -241,7 +248,7 @@ func TestEvaluateRulesLUMESkipsContainerRuleForDisc(t *testing.T) {
 }
 
 func TestEvaluateRulesPTPRequiresMovieForNonPackTV(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "tv"}}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "tv"}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "PTP", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
@@ -252,7 +259,7 @@ func TestEvaluateRulesPTPRequiresMovieForNonPackTV(t *testing.T) {
 }
 
 func TestEvaluateRulesPTPAllowsTVPacks(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "tv"}, TVPack: true}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "tv"}, TVPack: true}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "PTP", meta)
 	if len(failures) != 0 {
 		t.Fatalf("expected no failures, got %#v", failures)
@@ -260,7 +267,7 @@ func TestEvaluateRulesPTPAllowsTVPacks(t *testing.T) {
 }
 
 func TestEvaluateRulesANTRequiresMovie(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "tv"}}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "tv"}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "ANT", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
@@ -271,7 +278,7 @@ func TestEvaluateRulesANTRequiresMovie(t *testing.T) {
 }
 
 func TestEvaluateRulesANTAllowsMovie(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "movie"}}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "movie"}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "ANT", meta)
 	if len(failures) != 0 {
 		t.Fatalf("expected no failures, got %#v", failures)
@@ -279,7 +286,7 @@ func TestEvaluateRulesANTAllowsMovie(t *testing.T) {
 }
 
 func TestEvaluateRulesBHDRequiresValidMISettings(t *testing.T) {
-	meta := api.PreparedMetadata{ValidMediaInfoSettings: false}
+	meta := api.RuleSubject{Assessments: encodeAssessments(api.EncodeSettingsStatusMissing)}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "BHD", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
@@ -288,7 +295,7 @@ func TestEvaluateRulesBHDRequiresValidMISettings(t *testing.T) {
 		t.Fatalf("unexpected rule key: %s", failures[0].Rule)
 	}
 
-	meta.ValidMediaInfoSettings = true
+	meta.Assessments.MediaInfoEncodeSettings = api.EncodeSettingsStatusPresent
 	failures = evaluateNonMetadataRulesForTest(context.Background(), "BHD", meta)
 	if len(failures) != 0 {
 		t.Fatalf("expected no failures, got %#v", failures)
@@ -298,16 +305,16 @@ func TestEvaluateRulesBHDRequiresValidMISettings(t *testing.T) {
 func TestEvaluateRulesBHDBlocksAdultContent(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		ValidMediaInfoSettings: true,
-		ExternalIDs:            api.ExternalIDs{Category: "movie", IMDBID: 1234567},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Identity:    api.ExternalIdentity{Category: "movie", IMDBID: 1234567},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{Keywords: "adult"},
 			IMDB: &api.IMDBMetadata{IMDBID: 1234567, Title: "Example Release"},
 		},
 	}
 
-	failures := EvaluateRules(context.Background(), "BHD", meta, nil)
+	failures := evaluateBHDRulesWithRegistryForTest(context.Background(), meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
 	}
@@ -322,18 +329,18 @@ func TestEvaluateRulesBHDBlocksAdultContent(t *testing.T) {
 func TestEvaluateRulesBHDIgnoresStaleAdultMetadata(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		SourcePath:             "current",
-		ValidMediaInfoSettings: true,
-		Release:                api.ReleaseInfo{Genre: "Drama"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		SourcePath:  "current",
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:     api.ReleaseInfo{Genre: "Drama"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: "other",
 			TMDB:       &api.TMDBMetadata{Keywords: "adult", Genres: "pornography"},
 			IMDB:       &api.IMDBMetadata{Genres: "xxx"},
 		},
 	}
 
-	failures := EvaluateRules(context.Background(), "BHD", meta, nil)
+	failures := evaluateBHDRulesWithRegistryForTest(context.Background(), meta)
 	if hasRuleFailure(failures, "block_adult") {
 		t.Fatalf("expected stale adult metadata to be ignored, got %#v", failures)
 	}
@@ -343,16 +350,16 @@ func TestEvaluateRulesBHDBlocksAdultMetadataForExactSourcePath(t *testing.T) {
 	t.Parallel()
 
 	sourcePath := filepath.Join(t.TempDir(), "Example.Release.2026.1080p-GRP.mkv")
-	meta := api.PreparedMetadata{
-		SourcePath:             sourcePath,
-		ValidMediaInfoSettings: true,
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		SourcePath:  sourcePath,
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: sourcePath,
 			TMDB:       &api.TMDBMetadata{Keywords: "adult"},
 		},
 	}
 
-	failures := EvaluateRules(context.Background(), "BHD", meta, nil)
+	failures := evaluateBHDRulesWithRegistryForTest(context.Background(), meta)
 	if !hasRuleFailure(failures, "block_adult") {
 		t.Fatal("expected exact-source adult metadata to be applied")
 	}
@@ -382,18 +389,18 @@ func TestEvaluateRulesBHDIgnoresCaseOnlyDistinctAdultMetadata(t *testing.T) {
 		t.Skip("filesystem does not distinguish case-only paths")
 	}
 
-	meta := api.PreparedMetadata{
-		SourcePath:             currentPath,
-		ValidMediaInfoSettings: true,
-		Release:                api.ReleaseInfo{Genre: "Drama"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		SourcePath:  currentPath,
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:     api.ReleaseInfo{Genre: "Drama"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			SourcePath: storedPath,
 			TMDB:       &api.TMDBMetadata{Keywords: "adult", Genres: "pornography"},
 			IMDB:       &api.IMDBMetadata{Genres: "xxx"},
 		},
 	}
 
-	failures := EvaluateRules(context.Background(), "BHD", meta, nil)
+	failures := evaluateBHDRulesWithRegistryForTest(context.Background(), meta)
 	if hasRuleFailure(failures, "block_adult") {
 		t.Fatal("expected case-only-distinct adult metadata to be ignored")
 	}
@@ -402,18 +409,21 @@ func TestEvaluateRulesBHDIgnoresCaseOnlyDistinctAdultMetadata(t *testing.T) {
 func TestEvaluateRulesBHDRejectsInvalidContainerForUploadTypes(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		ValidMediaInfoSettings: true,
-		Type:                   "REMUX",
-		Container:              "avi",
+	meta := api.RuleSubject{
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Type:        "REMUX",
+		Container:   "avi",
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "BHD", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure, got %#v", failures)
 	}
-	if failures[0].Rule != "extra_check" {
+	if failures[0].Rule != "container" {
 		t.Fatalf("unexpected rule key: %s", failures[0].Rule)
 	}
+	if failures[0].Disposition != api.RuleDispositionStrict {
+		t.Fatalf("container disposition = %q, want strict", failures[0].Disposition)
+	}
 
 	meta.Container = "mkv"
 	failures = evaluateNonMetadataRulesForTest(context.Background(), "BHD", meta)
@@ -427,27 +437,45 @@ func TestEvaluateRulesBLUContainerRules(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		meta      api.PreparedMetadata
+		meta      api.RuleSubject
 		wantBlock bool
 	}{
 		{
-			name:      "non disc defaults to mkv",
-			meta:      api.PreparedMetadata{Type: "WEBDL", Container: "avi", ValidMediaInfoSettings: true},
+			name: "non disc defaults to mkv",
+			meta: api.RuleSubject{
+				Type:        "WEBDL",
+				Container:   "avi",
+				Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+			},
 			wantBlock: true,
 		},
 		{
-			name:      "hdtv allows ts",
-			meta:      api.PreparedMetadata{Type: "HDTV", Container: "ts", ValidMediaInfoSettings: true},
+			name: "hdtv allows ts",
+			meta: api.RuleSubject{
+				Type:        "HDTV",
+				Container:   "ts",
+				Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+			},
 			wantBlock: false,
 		},
 		{
-			name:      "dolby vision webdl allows mp4",
-			meta:      api.PreparedMetadata{Type: "WEBDL", Container: "mp4", WebDV: true, ValidMediaInfoSettings: true},
+			name: "dolby vision webdl allows mp4",
+			meta: api.RuleSubject{
+				Type:        "WEBDL",
+				Container:   "mp4",
+				WebDV:       true,
+				Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+			},
 			wantBlock: false,
 		},
 		{
-			name:      "disc skips container rule",
-			meta:      api.PreparedMetadata{DiscType: "BDMV", Type: "WEBDL", Container: "avi", ValidMediaInfoSettings: true},
+			name: "disc skips container rule",
+			meta: api.RuleSubject{
+				DiscType:    "BDMV",
+				Type:        "WEBDL",
+				Container:   "avi",
+				Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+			},
 			wantBlock: false,
 		},
 	}
@@ -460,6 +488,9 @@ func TestEvaluateRulesBLUContainerRules(t *testing.T) {
 			if tc.wantBlock && len(failures) == 0 {
 				t.Fatalf("expected BLU container failure")
 			}
+			if tc.wantBlock && failures[0].Disposition != api.RuleDispositionStrict {
+				t.Fatalf("container disposition = %q, want strict", failures[0].Disposition)
+			}
 			if !tc.wantBlock && len(failures) != 0 {
 				t.Fatalf("expected no BLU container failures, got %#v", failures)
 			}
@@ -468,7 +499,7 @@ func TestEvaluateRulesBLUContainerRules(t *testing.T) {
 }
 
 func TestEvaluateRulesNBLRequiresTV(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "movie"}}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "movie"}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "NBL", meta)
 	if len(failures) != 2 {
 		t.Fatalf("expected 2 failures, got %#v", failures)
@@ -479,7 +510,7 @@ func TestEvaluateRulesNBLRequiresTV(t *testing.T) {
 }
 
 func TestEvaluateRulesNBLAllowsTV(t *testing.T) {
-	meta := api.PreparedMetadata{ExternalIDs: api.ExternalIDs{Category: "tv"}}
+	meta := api.RuleSubject{Identity: api.ExternalIdentity{Category: "tv"}}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "NBL", meta)
 	if len(failures) != 1 {
 		t.Fatalf("expected 1 failure because language data is missing, got %#v", failures)
@@ -490,12 +521,12 @@ func TestEvaluateRulesNBLAllowsTV(t *testing.T) {
 }
 
 func TestEvaluateRulesNBLAllowsTVWithOriginalAudioAndEnglishSubs(t *testing.T) {
-	meta := api.PreparedMetadata{
-		ExternalIDs:       api.ExternalIDs{Category: "tv"},
+	meta := api.RuleSubject{
+		Identity:          api.ExternalIdentity{Category: "tv"},
 		DiscType:          "",
 		AudioLanguages:    []string{"Japanese"},
 		SubtitleLanguages: []string{"English"},
-		ExternalMetadata: api.ExternalMetadata{
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -506,17 +537,17 @@ func TestEvaluateRulesNBLAllowsTVWithOriginalAudioAndEnglishSubs(t *testing.T) {
 }
 
 func TestEvaluateRulesNBLSkipsLanguageRuleForBDMVOnly(t *testing.T) {
-	bdmv := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "tv"},
-		DiscType:    "BDMV",
+	bdmv := api.RuleSubject{
+		Identity: api.ExternalIdentity{Category: "tv"},
+		DiscType: "BDMV",
 	}
 	if failures := evaluateNonMetadataRulesForTest(context.Background(), "NBL", bdmv); len(failures) != 0 {
 		t.Fatalf("expected BDMV to skip NBL language rule, got %#v", failures)
 	}
 
-	dvd := api.PreparedMetadata{
-		ExternalIDs: api.ExternalIDs{Category: "tv"},
-		DiscType:    "DVD",
+	dvd := api.RuleSubject{
+		Identity: api.ExternalIdentity{Category: "tv"},
+		DiscType: "DVD",
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "NBL", dvd)
 	if len(failures) != 1 {
@@ -530,7 +561,7 @@ func TestEvaluateRulesNBLSkipsLanguageRuleForBDMVOnly(t *testing.T) {
 func TestEvaluateRulesDPDoesNotSpecialCaseFGTEncodes(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.RuleSubject{
 		Tag:               "-FGT",
 		Type:              "ENCODE",
 		AudioLanguages:    []string{"English"},
@@ -547,10 +578,10 @@ func TestEvaluateRulesDPDoesNotSpecialCaseFGTEncodes(t *testing.T) {
 func TestEvaluateRulesRHDRequiresGermanAudio(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		AudioLanguages:         []string{"English"},
-		Release:                api.ReleaseInfo{Resolution: "1080p"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		AudioLanguages: []string{"English"},
+		Release:        api.ReleaseInfo{Resolution: "1080p"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RHD", meta)
 	if len(failures) != 1 {
@@ -564,10 +595,10 @@ func TestEvaluateRulesRHDRequiresGermanAudio(t *testing.T) {
 func TestEvaluateRulesRHDAllowsGermanAudio(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		AudioLanguages:         []string{"German"},
-		Release:                api.ReleaseInfo{Resolution: "1080p"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		AudioLanguages: []string{"German"},
+		Release:        api.ReleaseInfo{Resolution: "1080p"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RHD", meta)
 	if len(failures) != 0 {
@@ -578,12 +609,12 @@ func TestEvaluateRulesRHDAllowsGermanAudio(t *testing.T) {
 func TestEvaluateRulesRHDRequiresGermanAudioForDisc(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		Type:                   "DISC",
-		DiscType:               "BDMV",
-		AudioLanguages:         []string{"English"},
-		Release:                api.ReleaseInfo{Resolution: "1080p"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		Type:           "DISC",
+		DiscType:       "BDMV",
+		AudioLanguages: []string{"English"},
+		Release:        api.ReleaseInfo{Resolution: "1080p"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RHD", meta)
 	if len(failures) != 1 {
@@ -597,12 +628,12 @@ func TestEvaluateRulesRHDRequiresGermanAudioForDisc(t *testing.T) {
 func TestEvaluateRulesRHDAllowsGermanAudioForDisc(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		Type:                   "DISC",
-		DiscType:               "BDMV",
-		AudioLanguages:         []string{"German"},
-		Release:                api.ReleaseInfo{Resolution: "1080p"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		Type:           "DISC",
+		DiscType:       "BDMV",
+		AudioLanguages: []string{"German"},
+		Release:        api.ReleaseInfo{Resolution: "1080p"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RHD", meta)
 	if len(failures) != 0 {
@@ -613,11 +644,11 @@ func TestEvaluateRulesRHDAllowsGermanAudioForDisc(t *testing.T) {
 func TestEvaluateRulesRHDRequiresSceneNFO(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		Scene:                  true,
-		AudioLanguages:         []string{"German"},
-		Release:                api.ReleaseInfo{Resolution: "1080p"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		Scene:          true,
+		AudioLanguages: []string{"German"},
+		Release:        api.ReleaseInfo{Resolution: "1080p"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "RHD", meta)
 	if len(failures) != 1 {
@@ -631,7 +662,7 @@ func TestEvaluateRulesRHDRequiresSceneNFO(t *testing.T) {
 func TestEvaluateRulesRHDAllowsNonSceneWithoutNFO(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
+	meta := api.RuleSubject{
 		AudioLanguages: []string{"German"},
 		Release:        api.ReleaseInfo{Resolution: "1080p"},
 	}
@@ -646,10 +677,10 @@ func TestEvaluateRulesRHDAllowsNonSceneWithoutNFO(t *testing.T) {
 func TestEvaluateRulesTOSRequiresSceneNFO(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{
-		Scene:                  true,
-		AudioLanguages:         []string{"French"},
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		Scene:          true,
+		AudioLanguages: []string{"French"},
+		Assessments:    encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "TOS", meta)
 	if len(failures) != 1 {
@@ -661,13 +692,15 @@ func TestEvaluateRulesTOSRequiresSceneNFO(t *testing.T) {
 }
 
 func TestEvaluateRulesAitherRequiresLanguageForNonDisc(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:               "",
-		ValidMediaInfo:         true,
-		ValidMediaInfoSettings: true,
-		AudioLanguages:         []string{"Japanese"},
-		SubtitleLanguages:      []string{"German"},
-		ExternalMetadata: api.ExternalMetadata{
+	meta := api.RuleSubject{
+		DiscType: "",
+		Assessments: api.ReleaseAssessments{
+			MediaInfoUniqueID:       api.UniqueIDStatusPresent,
+			MediaInfoEncodeSettings: api.EncodeSettingsStatusPresent,
+		},
+		AudioLanguages:    []string{"Japanese"},
+		SubtitleLanguages: []string{"German"},
+		ProviderMetadata: api.SourceScopedMetadata{
 			TMDB: &api.TMDBMetadata{OriginalLanguage: "ja"},
 		},
 	}
@@ -681,9 +714,9 @@ func TestEvaluateRulesAitherRequiresLanguageForNonDisc(t *testing.T) {
 }
 
 func TestEvaluateRulesA4KSkipsLanguageRuleForDisc(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:               "BDMV",
-		ValidMediaInfoSettings: true,
+	meta := api.RuleSubject{
+		DiscType:    "BDMV",
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "A4K", meta)
 	if len(failures) != 0 {
@@ -691,10 +724,27 @@ func TestEvaluateRulesA4KSkipsLanguageRuleForDisc(t *testing.T) {
 	}
 }
 
+func TestEvaluateRulesTTRLanguageFailuresAreStrict(t *testing.T) {
+	t.Parallel()
+
+	meta := api.RuleSubject{
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		Release:           api.ReleaseInfo{Language: []string{"English"}},
+	}
+	failures := evaluateNonMetadataRulesForTest(context.Background(), "TTR", meta)
+	for _, rule := range []string{"language_rule", "spanish_track_required"} {
+		failure, found := findRuleFailure(failures, rule)
+		if !found || failure.Disposition != api.RuleDispositionStrict {
+			t.Fatalf("%s = %#v, failures=%#v", rule, failure, failures)
+		}
+	}
+}
+
 func TestEvaluateRulesLSTRequiresValidMIAndLanguage(t *testing.T) {
-	meta := api.PreparedMetadata{
-		DiscType:               "",
-		ValidMediaInfoSettings: false,
+	meta := api.RuleSubject{
+		DiscType:    "",
+		Assessments: encodeAssessments(api.EncodeSettingsStatusMissing),
 	}
 	failures := evaluateNonMetadataRulesForTest(context.Background(), "LST", meta)
 	if len(failures) < 2 {
@@ -719,14 +769,17 @@ func hasRuleFailure(failures []api.RuleFailure, rule string) bool {
 func TestEvaluateRulesModifiedReleaseAcrossFamilies(t *testing.T) {
 	t.Parallel()
 
-	renamed := api.PreparedMetadata{
+	heuristicRename := api.RuleSubject{
 		SourcePath: "/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP",
 		Release:    api.ReleaseInfo{Group: "GRP"},
 	}
-	clean := api.PreparedMetadata{
+	clean := api.RuleSubject{
 		SourcePath: "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP",
 		Release:    api.ReleaseInfo{Group: "GRP"},
 	}
+	sceneRename := clean
+	sceneRename.SceneRenamed = true
+	sceneRename.SceneRenamedReason = "source does not match its original scene release name (renamed or modified)"
 
 	// Covers a UNIT3D tracker (LST), a non-UNIT3D tracker (PTP), an AZ-family
 	// tracker (PHD), and a tracker with no rule set of its own (HDB) to prove the
@@ -734,14 +787,26 @@ func TestEvaluateRulesModifiedReleaseAcrossFamilies(t *testing.T) {
 	for _, tracker := range []string{"LST", "PTP", "PHD", "HDB"} {
 		t.Run(tracker, func(t *testing.T) {
 			t.Parallel()
-			got := evaluateNonMetadataRulesForTest(context.Background(), tracker, renamed)
+			got := evaluateNonMetadataRulesForTest(context.Background(), tracker, heuristicRename)
 			failure, ok := findRuleFailure(got, "modified_release")
 			if !ok {
 				t.Fatalf("expected modified_release failure for %s, got %#v", tracker, got)
 			}
+			if failure.Disposition != api.RuleDispositionWaivable {
+				t.Fatalf("heuristic modified_release disposition for %s = %q, want waivable", tracker, failure.Disposition)
+			}
 			if !strings.Contains(failure.Reason, "renamed") {
 				t.Fatalf("expected a meaningful reason mentioning 'renamed' for %s, got %q", tracker, failure.Reason)
 			}
+
+			sceneFailures := evaluateNonMetadataRulesForTest(context.Background(), tracker, sceneRename)
+			sceneFailure, ok := findRuleFailure(sceneFailures, "modified_release")
+			if !ok {
+				t.Fatalf("expected scene modified_release failure for %s, got %#v", tracker, sceneFailures)
+			}
+			if sceneFailure.Disposition != api.RuleDispositionStrict {
+				t.Fatalf("scene modified_release disposition for %s = %q, want strict", tracker, sceneFailure.Disposition)
+			}
 			if clean := evaluateNonMetadataRulesForTest(context.Background(), tracker, clean); hasRuleFailure(clean, "modified_release") {
 				t.Fatalf("did not expect modified_release failure for clean release on %s, got %#v", tracker, clean)
 			}
@@ -755,7 +820,7 @@ func TestEvaluateRulesModifiedReleaseAcrossFamilies(t *testing.T) {
 func TestEvaluateRulesMetadataPolicyReturnsEvaluatedEmpty(t *testing.T) {
 	t.Parallel()
 
-	clean := api.PreparedMetadata{
+	clean := api.RuleSubject{
 		SourcePath: "/data/movies/Example.Movie.2026.2160p.MA.WEB-DL.DDP5.1.HDR.H.265-GRP",
 		Release:    api.ReleaseInfo{Group: "GRP"},
 	}
@@ -764,14 +829,233 @@ func TestEvaluateRulesMetadataPolicyReturnsEvaluatedEmpty(t *testing.T) {
 	}
 }
 
-func TestEvaluateRulesModifiedReleaseExemptsManual(t *testing.T) {
+func TestResolutionDependentRulesAreStrict(t *testing.T) {
 	t.Parallel()
+	base := func(resolution string) api.RuleSubject {
+		return api.RuleSubject{
+			Container:         "mkv",
+			AudioLanguages:    []string{"English", "German"},
+			SubtitleLanguages: []string{"English"},
+			Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
+			Release:           api.ReleaseInfo{Resolution: resolution},
+		}
+	}
+	type ruleTest struct {
+		name    string
+		tracker string
+		meta    api.RuleSubject
+		rule    string
+		want    bool
+	}
+	tests := make([]ruleTest, 0, 20)
+	tests = append(tests, []ruleTest{
+		{
+name: "RHD missing",
+ tracker: "RHD",
+ meta: base(""),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "RHD below",
+ tracker: "RHD",
+ meta: base("576p"),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "RHD boundary",
+ tracker: "RHD",
+ meta: base("720p"),
+ rule: "min_resolution",
+},
+		{
+name: "SP below",
+ tracker: "SP",
+ meta: base("720p"),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "SP boundary",
+ tracker: "SP",
+ meta: base("1080p"),
+ rule: "min_resolution",
+},
+		{
+name: "LUME missing",
+ tracker: "LUME",
+ meta: base(""),
+ rule: "resolution_required",
+ want: true,
+},
+		{
+name: "LUME below",
+ tracker: "LUME",
+ meta: base("576p"),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "LUME boundary",
+ tracker: "LUME",
+ meta: base("720p"),
+ rule: "min_resolution",
+},
+		{
+name: "PHD SD progressive",
+ tracker: "PHD",
+ meta: base("576p"),
+ rule: "sd_forbidden",
+ want: true,
+},
+		{
+name: "PHD SD interlaced",
+ tracker: "PHD",
+ meta: base("480i"),
+ rule: "sd_forbidden",
+ want: true,
+},
+		{
+name: "HDS missing",
+ tracker: "HDS",
+ meta: base(""),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "HDS below",
+ tracker: "HDS",
+ meta: base("576p"),
+ rule: "min_resolution",
+ want: true,
+},
+		{
+name: "HDS boundary",
+ tracker: "HDS",
+ meta: base("720p"),
+ rule: "min_resolution",
+},
+		{
+name: "HDT missing",
+ tracker: "HDT",
+ meta: base(""),
+ rule: "resolution_required",
+ want: true,
+},
+		{
+name: "HDT known SD",
+ tracker: "HDT",
+ meta: base("576p"),
+ rule: "resolution_required",
+},
+		{
+name: "TVC UHD",
+ tracker: "TVC",
+ meta: base("2160p"),
+ rule: "uhd_forbidden",
+ want: true,
+},
+		{
+name: "TVC HD",
+ tracker: "TVC",
+ meta: base("1080p"),
+ rule: "uhd_forbidden",
+},
+	}...)
+
+	ulcxHEVC := base("1080p")
+	ulcxHEVC.VideoCodec = "HEVC"
+	tests = append(tests, ruleTest{
+name: "ULCX HEVC threshold",
+ tracker: "ULCX",
+ meta: ulcxHEVC,
+ rule: "hevc_resolution_2160p",
+ want: true,
+})
+	ulcxEncode := base("576p")
+	ulcxEncode.Type = "ENCODE"
+	tests = append(tests, ruleTest{
+name: "ULCX encode minimum",
+ tracker: "ULCX",
+ meta: ulcxEncode,
+ rule: "encode_min_resolution",
+ want: true,
+})
+	phdCodec := base("2160p")
+	phdCodec.Type = "ENCODE"
+	phdCodec.Source = "BLURAY"
+	phdCodec.VideoEncode = "x264"
+	tests = append(tests, ruleTest{
+name: "PHD H264 threshold",
+ tracker: "PHD",
+ meta: phdCodec,
+ rule: "h264_resolution_limit",
+ want: true,
+})
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			failures := evaluateNonMetadataRulesForTest(context.Background(), test.tracker, test.meta)
+			failure, found := findRuleFailure(failures, test.rule)
+			if found != test.want {
+				t.Fatalf("%s found=%t, want %t; failures=%#v", test.rule, found, test.want, failures)
+			}
+			if found && failure.Disposition != api.RuleDispositionStrict {
+				t.Fatalf("%s disposition=%q, want strict", test.rule, failure.Disposition)
+			}
+		})
+	}
+}
 
-	renamed := api.PreparedMetadata{
-		SourcePath: "/data/movies/Example Movie 2026 2160p MA WEB-DL DDP5 1 HDR H 265-GRP",
-		Release:    api.ReleaseInfo{Group: "GRP"},
+func TestCustomRulesReturnMultipleKeyedDispositions(t *testing.T) {
+	t.Parallel()
+	meta := api.RuleSubject{
+		Container:         "mkv",
+		AudioLanguages:    []string{"English"},
+		SubtitleLanguages: []string{"English"},
+		Assessments:       encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:           api.ReleaseInfo{Resolution: "1080p"},
+		VideoCodec:        "HEVC",
+		ProviderMetadata:  api.SourceScopedMetadata{TMDB: &api.TMDBMetadata{Keywords: "concert"}},
+	}
+	failures := evaluateNonMetadataRulesForTest(context.Background(), "ULCX", meta)
+	concert, hasConcert := findRuleFailure(failures, "block_concert")
+	resolution, hasResolution := findRuleFailure(failures, "hevc_resolution_2160p")
+	if !hasConcert || !hasResolution || concert.Disposition != api.RuleDispositionWaivable || resolution.Disposition != api.RuleDispositionStrict {
+		t.Fatalf("custom failures = %#v", failures)
+	}
+}
+
+func TestTVCNonResolutionUploadRestrictionsAreStrict(t *testing.T) {
+	t.Parallel()
+
+	meta := api.RuleSubject{
+		DiscType:    "BDMV",
+		Type:        "REMUX",
+		Assessments: encodeAssessments(api.EncodeSettingsStatusPresent),
+		Release:     api.ReleaseInfo{Resolution: "1080p"},
+	}
+	failures := evaluateNonMetadataRulesForTest(context.Background(), "TVC", meta)
+	for _, rule := range []string{"disc_forbidden", "remux_forbidden"} {
+		failure, found := findRuleFailure(failures, rule)
+		if !found || failure.Disposition != api.RuleDispositionStrict {
+			t.Fatalf("%s = %#v, failures=%#v", rule, failure, failures)
+		}
+	}
+}
+
+func TestRuleEvaluationCancellationReturnsError(t *testing.T) {
+	t.Parallel()
+	registry, err := impl.NewRegistry()
+	if err != nil {
+		t.Fatalf("registry: %v", err)
 	}
-	if got := evaluateNonMetadataRulesForTest(context.Background(), "MANUAL", renamed); hasRuleFailure(got, "modified_release") {
-		t.Fatalf("expected MANUAL to be exempt from modified_release, got %#v", got)
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	failures, err := trackers.EvaluateRulesWithRegistry(ctx, registry, "ULCX", api.RuleSubject{}, api.NopLogger{})
+	if err == nil || len(failures) != 0 {
+		t.Fatalf("canceled evaluation failures=%#v err=%v", failures, err)
 	}
 }
diff --git a/internal/trackers/screenshot_slots.go b/internal/trackers/screenshot_slots.go
index b399ab82..9b4c6a00 100644
--- a/internal/trackers/screenshot_slots.go
+++ b/internal/trackers/screenshot_slots.go
@@ -15,7 +15,7 @@ import (
 	"strings"
 
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/services/imagehost"
+	imagehost "github.com/autobrr/upbrr/internal/imagehosting/host"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
@@ -38,7 +38,11 @@ var (
 	slotComparisonURL     = regexp.MustCompile(`(?i)https?://[^\s\]]+\.(?:png|jpe?g|gif|webp)`)
 	slotURLImgPattern     = regexp.MustCompile(`(?is)\[url=(https?://[^\]]+)\]\s*\[img[^\]]*\](.*?)\[/img\]\s*\[/url\]`)
 	slotImgPattern        = regexp.MustCompile(`(?is)\[img[^\]]*\](.*?)\[/img\]`)
-	posterLikeSlotHosts   = map[string]struct{}{"image.tmdb.org": {}, "themoviedb.org": {}, "www.themoviedb.org": {}}
+	posterLikeSlotHosts   = map[string]struct{}{
+		"image.tmdb.org":     {},
+		"themoviedb.org":     {},
+		"www.themoviedb.org": {},
+	}
 )
 
 type parsedDescriptionSlot struct {
@@ -49,10 +53,11 @@ type parsedDescriptionSlot struct {
 func screenshotSlotsFromSource(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	logger api.Logger,
 	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
 ) ([]api.ScreenshotSlot, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, fmt.Errorf("trackers: load screenshot slots canceled: %w", err)
@@ -86,7 +91,7 @@ func screenshotSlotsFromSource(
 		return cloneScreenshotSlots(slots), nil
 	}
 
-	slots, err = synthesizeScreenshotSlots(ctx, tracker, meta, repo, logger, preloaded)
+	slots, err = synthesizeScreenshotSlots(ctx, tracker, meta, repo, logger, preloaded, registry)
 	if err != nil {
 		return nil, err
 	}
@@ -101,8 +106,8 @@ func screenshotSlotsFromSource(
 
 func filterStoredSlotsForSelectedImages(
 	ctx context.Context,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	slots []api.ScreenshotSlot,
 	preloaded *preloadedDescriptionAssetData,
 ) ([]api.ScreenshotSlot, error) {
@@ -137,8 +142,8 @@ func filterStoredSlotsForSelectedImages(
 
 func appendStoredSelectionSlots(
 	ctx context.Context,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	slots []api.ScreenshotSlot,
 	preloaded *preloadedDescriptionAssetData,
 ) ([]api.ScreenshotSlot, error) {
@@ -166,12 +171,13 @@ func selectedPathExists(selectedPaths map[string]struct{}, imagePath string) boo
 func synthesizeScreenshotSlots(
 	ctx context.Context,
 	tracker string,
-	meta api.PreparedMetadata,
-	repo api.MetadataRepository,
+	meta api.UploadSubject,
+	repo UploadPersistence,
 	logger api.Logger,
 	preloaded *preloadedDescriptionAssetData,
+	registry *Registry,
 ) ([]api.ScreenshotSlot, error) {
-	description, _, _ := resolveTrackerDescription(ctx, tracker, meta, repo, logger, preloaded)
+	description, _, _ := resolveTrackerDescription(ctx, tracker, meta, repo, logger, preloaded, registry)
 	selections, err := finalSelectionsFromSource(ctx, meta, repo, preloaded)
 	if err != nil && !errorsIsNotFound(err) {
 		return nil, err
@@ -718,12 +724,17 @@ func normalizeSlotOrders(slots []api.ScreenshotSlot) []api.ScreenshotSlot {
 	return slots
 }
 
+// SlotUploadAttachmentResult contains updated screenshot slots and unmatched uploads.
 type SlotUploadAttachmentResult struct {
 	MatchedUploads   int
 	FallbackMatched  int
 	UnmatchedUploads int
 }
 
+// ApplyUploadedVariantsToSlots mutates slots by upserting host/scope variants.
+// Uploads match by local path, then known URL; unmatched uploads use ordered
+// fallback only when their count exactly matches remaining renderable pathless
+// slots. The result reports upload counts, not variant insertions.
 func ApplyUploadedVariantsToSlots(slots []api.ScreenshotSlot, uploads []api.UploadedImageLink) SlotUploadAttachmentResult {
 	if len(slots) == 0 || len(uploads) == 0 {
 		return SlotUploadAttachmentResult{}
@@ -745,7 +756,13 @@ func ApplyUploadedVariantsToSlots(slots []api.ScreenshotSlot, uploads []api.Uplo
 	result := SlotUploadAttachmentResult{}
 	seenUploads := make(map[string]struct{}, len(uploads))
 	for _, upload := range uploads {
-		uploadKey := strings.ToLower(strings.TrimSpace(upload.Host)) + "\x00" + normalizeUsageScope(upload.UsageScope) + "\x00" + strings.TrimSpace(upload.ImagePath)
+		uploadKey := strings.ToLower(
+			strings.TrimSpace(upload.Host),
+		) + "\x00" + normalizeUsageScope(
+			upload.UsageScope,
+		) + "\x00" + strings.TrimSpace(
+			upload.ImagePath,
+		)
 		if _, exists := seenUploads[uploadKey]; exists {
 			continue
 		}
@@ -1035,7 +1052,13 @@ func slotIdentity(slot api.ScreenshotSlot) string {
 	return "unknown"
 }
 
-func upsertScreenshotVariantsFromUploads(ctx context.Context, repo api.MetadataRepository, sourcePath string, slots []api.ScreenshotSlot, uploads []api.UploadedImageLink) error {
+func upsertScreenshotVariantsFromUploads(
+	ctx context.Context,
+	repo UploadPersistence,
+	sourcePath string,
+	slots []api.ScreenshotSlot,
+	uploads []api.UploadedImageLink,
+) error {
 	if repo == nil || len(slots) == 0 || len(uploads) == 0 {
 		return nil
 	}
diff --git a/internal/trackers/service.go b/internal/trackers/service.go
index 9f46bff8..ba44830b 100644
--- a/internal/trackers/service.go
+++ b/internal/trackers/service.go
@@ -13,17 +13,17 @@ import (
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
-	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/description"
+	"github.com/autobrr/upbrr/internal/logging"
 	"github.com/autobrr/upbrr/internal/redaction"
-	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/services/description"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// Service coordinates tracker preparation, dry-run rendering, and uploads.
 type Service struct {
 	cfg      config.Config
 	logger   api.Logger
-	repo     db.MetadataRepository
+	repo     UploadPersistence
 	images   api.ImageHostingService
 	banned   *BannedGroupChecker
 	registry *Registry
@@ -34,473 +34,34 @@ const (
 	uploadRecordFinalizationTimeout    = 5 * time.Second
 )
 
-type trackerUploadResult struct {
-	tracker        string
-	summary        api.UploadSummary
-	err            error
-	notImplemented bool
-}
-
 type imageHostPreflight map[string]descriptionImageHostResolution
 
-func NewService(cfg config.Config, logger api.Logger, repo db.MetadataRepository) *Service {
-	return NewServiceWithRegistryAndImages(cfg, logger, repo, nil, nil)
-}
-
-func NewServiceWithRegistry(cfg config.Config, logger api.Logger, repo db.MetadataRepository, registry *Registry) *Service {
+// NewServiceWithRegistry returns a tracker service backed by registry.
+func NewServiceWithRegistry(cfg config.Config, logger api.Logger, repo UploadPersistence, registry *Registry) *Service {
 	return NewServiceWithRegistryAndImages(cfg, logger, repo, registry, nil)
 }
 
-func NewServiceWithRegistryAndImages(cfg config.Config, logger api.Logger, repo db.MetadataRepository, registry *Registry, images api.ImageHostingService) *Service {
+// NewServiceWithRegistryAndImages substitutes a no-op logger and binds the
+// registry to tracker, banned-group, and image-host preparation. A nil registry
+// is retained so public operations can return their explicit configuration error.
+func NewServiceWithRegistryAndImages(
+	cfg config.Config,
+	logger api.Logger,
+	repo UploadPersistence,
+	registry *Registry,
+	images api.ImageHostingService,
+) *Service {
 	if logger == nil {
 		logger = api.NopLogger{}
 	}
-	return &Service{cfg: cfg, logger: logger, repo: repo, images: images, banned: NewBannedGroupChecker(cfg.MainSettings.DBPath), registry: registry}
-}
-
-// Upload submits prepared metadata to the resolved tracker set.
-// The returned summary includes tracker uploads that completed before a later
-// failure or cancellation, and pending upload records are finalized with a
-// cleanup context when the caller's context has already been canceled.
-// Successful tracker results are treated as terminal for finalization even when
-// persisting that terminal status logs a warning.
-func (s *Service) Upload(ctx context.Context, meta api.PreparedMetadata) (api.UploadSummary, error) {
-	select {
-	case <-ctx.Done():
-		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-	default:
-	}
-
-	trackers := resolveTrackers(s.cfg, meta.Trackers, meta.TrackersRemove)
-	trackers = filterKnownTrackers(trackers, s.logger)
-	trackers = filterTrackersByRuleFailures(trackers, meta.TrackerRuleFailures, meta.IgnoreTrackerRuleFailures, s.logger)
-	trackers = filterTrackersByBlocks(trackers, meta.BlockedTrackers, s.logger)
-	s.logger.Debugf("trackers: resolved %d trackers", len(trackers))
-	if len(trackers) == 0 {
-		s.logger.Infof("trackers: no trackers configured, skipping upload")
-		return api.UploadSummary{Uploaded: 0}, nil
-	}
-
-	group := NormalizeBannedReleaseGroup(meta.Tag)
-	if group != "" {
-		if err := s.banned.RefreshDynamic(ctx, s.cfg, trackers, s.logger); err != nil {
-			return api.UploadSummary{}, fmt.Errorf("trackers: banned groups refresh: %w", err)
-		}
-		for _, tracker := range trackers {
-			select {
-			case <-ctx.Done():
-				return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-			default:
-			}
-			banned, err := s.banned.IsBanned(tracker, group)
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %s banned groups: %w", tracker, err)
-			}
-			if banned {
-				return api.UploadSummary{}, fmt.Errorf("trackers: %s group %s: %w", tracker, group, internalerrors.ErrBannedGroup)
-			}
-		}
-	}
-
-	if s.registry == nil {
-		if s.repo != nil {
-			for _, tracker := range trackers {
-				s.logger.Debugf("trackers: creating pending record for %s", tracker)
-				status := "pending"
-				if IsInternalGroup(s.cfg, tracker, meta) {
-					status = "pending-internal"
-					if s.logger != nil {
-						s.logger.Infof("trackers: marked internal tracker=%s tag=%s", tracker, meta.Tag)
-					}
-				}
-				err := s.repo.CreateUploadRecord(ctx, db.UploadRecord{
-					Tracker:    tracker,
-					Status:     status,
-					CreatedAt:  time.Now().UTC(),
-					SourcePath: meta.SourcePath,
-				})
-				if err != nil {
-					return api.UploadSummary{}, fmt.Errorf("trackers: record %s: %w", tracker, err)
-				}
-				if err := s.repo.UpdateLatestUploadRecordStatus(ctx, meta.SourcePath, tracker, "failed"); err != nil {
-					s.logger.Warnf("trackers: status update failed tracker=%s status=failed err=%s", tracker, redaction.RedactValue(err.Error(), nil))
-				}
-			}
-		}
-		return api.UploadSummary{}, fmt.Errorf("trackers: %s: %w", strings.Join(trackers, ","), internalerrors.ErrNotImplemented)
-	}
-
-	var finalizePending func(context.Context, string) []string
-	if s.repo != nil {
-		type recordStatusState struct {
-			status    string
-			persisted bool
-		}
-
-		recordStatuses := make(map[string]recordStatusState, len(trackers))
-		var recordMu sync.Mutex
-		updateRecordStatus := func(updateCtx context.Context, tracker string, status string) error {
-			trimmedTracker := strings.TrimSpace(tracker)
-			trimmedStatus := strings.TrimSpace(status)
-			if trimmedTracker == "" || trimmedStatus == "" {
-				return nil
-			}
-
-			recordMu.Lock()
-			current, ok := recordStatuses[trimmedTracker]
-			if ok && current.status == trimmedStatus && current.persisted {
-				recordMu.Unlock()
-				return nil
-			}
-			recordMu.Unlock()
-
-			if err := s.repo.UpdateLatestUploadRecordStatus(updateCtx, meta.SourcePath, trimmedTracker, trimmedStatus); err != nil {
-				s.logger.Warnf("trackers: status update failed tracker=%s status=%s err=%s", trimmedTracker, trimmedStatus, redaction.RedactValue(err.Error(), nil))
-				recordMu.Lock()
-				recordStatuses[trimmedTracker] = recordStatusState{status: trimmedStatus}
-				recordMu.Unlock()
-				return fmt.Errorf("trackers: status update %s (%s): %w", trimmedTracker, trimmedStatus, err)
-			}
-			recordMu.Lock()
-			recordStatuses[trimmedTracker] = recordStatusState{status: trimmedStatus, persisted: true}
-			recordMu.Unlock()
-			return nil
-		}
-		finalizePending = func(updateCtx context.Context, status string) []string {
-			recordMu.Lock()
-			targetStatuses := make(map[string]string, len(recordStatuses))
-			for tracker, current := range recordStatuses {
-				switch {
-				case current.status == "pending" || current.status == "pending-internal":
-					targetStatuses[tracker] = status
-				case !current.persisted:
-					targetStatuses[tracker] = current.status
-				}
-			}
-			recordMu.Unlock()
-
-			failures := make([]string, 0)
-			for tracker, targetStatus := range targetStatuses {
-				if err := updateRecordStatus(updateCtx, tracker, targetStatus); err != nil {
-					failures = append(failures, fmt.Sprintf("%s (%s): %v", tracker, targetStatus, err))
-				}
-			}
-			return failures
-		}
-
-		for _, tracker := range trackers {
-			select {
-			case <-ctx.Done():
-				cleanupCtx, cleanupCancel := uploadRecordCleanupContext(ctx)
-				finalizePending(cleanupCtx, "canceled")
-				cleanupCancel()
-				return api.UploadSummary{}, fmt.Errorf("context canceled: %w", ctx.Err())
-			default:
-			}
-			s.logger.Debugf("trackers: creating pending record for %s", tracker)
-			status := "pending"
-			if IsInternalGroup(s.cfg, tracker, meta) {
-				status = "pending-internal"
-				if s.logger != nil {
-					s.logger.Infof("trackers: marked internal tracker=%s tag=%s", tracker, meta.Tag)
-				}
-			}
-			err := s.repo.CreateUploadRecord(ctx, db.UploadRecord{
-				Tracker:    tracker,
-				Status:     status,
-				CreatedAt:  time.Now().UTC(),
-				SourcePath: meta.SourcePath,
-			})
-			if err != nil {
-				return api.UploadSummary{}, fmt.Errorf("trackers: record %s: %w", tracker, err)
-			}
-			recordMu.Lock()
-			recordStatuses[strings.TrimSpace(tracker)] = recordStatusState{status: status, persisted: true}
-			recordMu.Unlock()
-		}
-
-		preflight := s.preflightDescriptionImageHosts(ctx, meta, trackers)
-		results, err := s.uploadTrackersConcurrently(ctx, meta, trackers, preflight)
-		statusCtx, statusCancel := uploadRecordCleanupContext(ctx)
-		defer statusCancel()
-
-		summary := api.UploadSummary{}
-		notImplemented := make([]string, 0)
-		failedTrackers := make([]string, 0)
-		failedMessages := make([]string, 0)
-		retryStatusUpdates := false
-
-		for _, result := range results {
-			if result.notImplemented {
-				notImplemented = append(notImplemented, result.tracker)
-				if updateRecordStatus(statusCtx, result.tracker, "failed") != nil {
-					retryStatusUpdates = true
-				}
-				continue
-			}
-			if result.err != nil {
-				if err != nil && isContextCancellation(result.err) {
-					continue
-				}
-				failedTrackers = append(failedTrackers, result.tracker)
-				failedMessages = append(failedMessages, fmt.Sprintf("%s: %v", result.tracker, result.err))
-				if updateRecordStatus(statusCtx, result.tracker, "failed") != nil {
-					retryStatusUpdates = true
-				}
-				continue
-			}
-
-			if updateRecordStatus(statusCtx, result.tracker, "uploaded") != nil {
-				retryStatusUpdates = true
-			}
-			summary.Uploaded += result.summary.Uploaded
-			if len(result.summary.UploadedTorrents) > 0 {
-				summary.UploadedTorrents = append(summary.UploadedTorrents, result.summary.UploadedTorrents...)
-			}
-		}
-
-		statusFailures := make([]string, 0)
-		if err != nil {
-			statusFailures = append(statusFailures, finalizePending(statusCtx, "canceled")...)
-		} else if retryStatusUpdates {
-			statusFailures = append(statusFailures, finalizePending(statusCtx, "failed")...)
-		}
-		if len(failedMessages) > 0 {
-			s.logger.Warnf("trackers: upload failures: %s", strings.Join(failedMessages, "; "))
-		}
-		if len(notImplemented) > 0 {
-			s.logger.Warnf("trackers: not implemented: %s", strings.Join(notImplemented, ","))
-		}
-
-		if summary.Uploaded > 0 {
-			if err != nil {
-				return summary, err
-			}
-			if len(failedTrackers) > 0 {
-				return summary, fmt.Errorf("trackers: %s", strings.Join(failedMessages, "; "))
-			}
-			if len(statusFailures) > 0 {
-				return summary, fmt.Errorf("trackers: status updates: %s", strings.Join(statusFailures, "; "))
-			}
-			return summary, err
-		}
-		if err != nil {
-			return summary, err
-		}
-		if len(failedTrackers) > 0 {
-			return summary, fmt.Errorf("trackers: %s", strings.Join(failedMessages, "; "))
-		}
-		if len(notImplemented) > 0 {
-			return summary, fmt.Errorf("trackers: %s: %w", strings.Join(notImplemented, ","), internalerrors.ErrNotImplemented)
-		}
-		if len(statusFailures) > 0 {
-			return summary, fmt.Errorf("trackers: status updates: %s", strings.Join(statusFailures, "; "))
-		}
-
-		return summary, nil
-	}
-
-	preflight := s.preflightDescriptionImageHosts(ctx, meta, trackers)
-	results, err := s.uploadTrackersConcurrently(ctx, meta, trackers, preflight)
-
-	summary := api.UploadSummary{}
-	notImplemented := make([]string, 0)
-	failedTrackers := make([]string, 0)
-	failedMessages := make([]string, 0)
-	for _, result := range results {
-		if result.notImplemented {
-			notImplemented = append(notImplemented, result.tracker)
-			continue
-		}
-		if result.err != nil {
-			if err != nil && isContextCancellation(result.err) {
-				continue
-			}
-			failedTrackers = append(failedTrackers, result.tracker)
-			failedMessages = append(failedMessages, fmt.Sprintf("%s: %v", result.tracker, result.err))
-			continue
-		}
-		summary.Uploaded += result.summary.Uploaded
-		if len(result.summary.UploadedTorrents) > 0 {
-			summary.UploadedTorrents = append(summary.UploadedTorrents, result.summary.UploadedTorrents...)
-		}
-	}
-
-	if len(failedMessages) > 0 {
-		s.logger.Warnf("trackers: upload failures: %s", strings.Join(failedMessages, "; "))
-	}
-	if len(notImplemented) > 0 {
-		s.logger.Warnf("trackers: not implemented: %s", strings.Join(notImplemented, ","))
-	}
-
-	if summary.Uploaded > 0 {
-		if err != nil {
-			return summary, err
-		}
-		if len(failedTrackers) > 0 {
-			return summary, fmt.Errorf("trackers: %s", strings.Join(failedMessages, "; "))
-		}
-		return summary, err
-	}
-	if err != nil {
-		return summary, err
-	}
-	if len(failedTrackers) > 0 {
-		return summary, fmt.Errorf("trackers: %s", strings.Join(failedMessages, "; "))
+	return &Service{
+		cfg:      cfg,
+		logger:   logger,
+		repo:     repo,
+		images:   images,
+		banned:   NewBannedGroupCheckerWithRegistry(cfg.MainSettings.DBPath, registry),
+		registry: registry,
 	}
-	if len(notImplemented) > 0 {
-		return summary, fmt.Errorf("trackers: %s: %w", strings.Join(notImplemented, ","), internalerrors.ErrNotImplemented)
-	}
-
-	return summary, nil
-}
-
-func (s *Service) uploadTrackersConcurrently(ctx context.Context, meta api.PreparedMetadata, trackers []string, preflight imageHostPreflight) ([]trackerUploadResult, error) {
-	workerCount := s.maxConcurrentTrackerUploads(len(trackers))
-	results := make([]trackerUploadResult, len(trackers))
-	if workerCount <= 0 {
-		return results, nil
-	}
-
-	trackerConfigs := make([]config.TrackerConfig, len(trackers))
-	trackerMetas := make([]api.PreparedMetadata, len(trackers))
-	prepErrors := make([]error, len(trackers))
-	for idx, tracker := range trackers {
-		trackerCfg := trackerConfigFor(s.cfg, tracker)
-		trackerCfg = applyTrackerConfigOverrides(trackerCfg, meta.TrackerConfigOverrides)
-		trackerConfigs[idx] = trackerCfg
-		if _, ok := s.registry.Lookup(tracker); !ok {
-			continue
-		}
-		trackerMeta, err := PrepareTrackerUploadTorrent(meta, s.cfg.MainSettings.DBPath, tracker, trackerCfg)
-		if err != nil {
-			prepErrors[idx] = fmt.Errorf("trackers: %s upload torrent artifact: %w", tracker, err)
-			continue
-		}
-		trackerMetas[idx] = trackerMeta
-	}
-
-	jobs := make(chan int)
-	var wg sync.WaitGroup
-
-	worker := func() {
-		defer wg.Done()
-		for idx := range jobs {
-			tracker := trackers[idx]
-			result := trackerUploadResult{tracker: tracker}
-
-			if ctx.Err() != nil {
-				result.err = ctx.Err()
-				results[idx] = result
-				continue
-			}
-
-			definition, ok := s.registry.Lookup(tracker)
-			if !ok {
-				result.notImplemented = true
-				results[idx] = result
-				continue
-			}
-
-			trackerCfg := trackerConfigs[idx]
-			trackerMeta := trackerMetas[idx]
-			if prepErrors[idx] != nil {
-				result.err = prepErrors[idx]
-				results[idx] = result
-				continue
-			}
-			resolution, ok := preflight[strings.ToUpper(strings.TrimSpace(tracker))]
-			if !ok {
-				var err error
-				resolution, err = ensureDescriptionImageHost(ctx, tracker, trackerMeta, s.cfg, trackerCfg, s.repo, s.images, s.logger)
-				if err != nil {
-					s.logger.Warnf("trackers: description image host resolution failed for %s: %v", tracker, err)
-					result.err = err
-					results[idx] = result
-					continue
-				}
-			}
-			if resolution.blocking {
-				message := strings.TrimSpace(resolution.feedback.Message)
-				if message == "" {
-					message = "image-host requirements could not be met"
-				}
-				s.logger.Warnf("trackers: skipping %s due to image host failure: %s", tracker, message)
-				result.err = errors.New(message)
-				results[idx] = result
-				continue
-			}
-			assets, err := ResolveDescriptionAssets(ctx, tracker, trackerMeta, s.repo, s.logger)
-			if err != nil {
-				result.err = err
-				results[idx] = result
-				continue
-			}
-			applyResolvedDescriptionScreenshots(ctx, trackerMeta, s.repo, nil, &assets, resolution.screenshots)
-			uploadSummary, err := definition.Upload(ctx, UploadRequest{
-				Tracker:       tracker,
-				Meta:          trackerMeta,
-				TrackerConfig: trackerCfg,
-				AppConfig:     s.cfg,
-				Logger:        s.logger,
-				Repo:          s.repo,
-				Images:        s.images,
-				Assets:        &assets,
-			})
-			if err != nil {
-				if errors.Is(err, internalerrors.ErrNotImplemented) {
-					result.notImplemented = true
-					results[idx] = result
-					continue
-				}
-				result.err = err
-				results[idx] = result
-				continue
-			}
-
-			result.summary = uploadSummary
-			results[idx] = result
-		}
-	}
-
-	for range workerCount {
-		wg.Add(1)
-		go worker()
-	}
-
-	for idx := range trackers {
-		select {
-		case <-ctx.Done():
-			close(jobs)
-			wg.Wait()
-			for canceledIdx := idx; canceledIdx < len(trackers); canceledIdx++ {
-				if results[canceledIdx].tracker == "" {
-					results[canceledIdx] = trackerUploadResult{tracker: trackers[canceledIdx], err: ctx.Err()}
-				}
-			}
-			return results, fmt.Errorf("context canceled: %w", ctx.Err())
-		case jobs <- idx:
-		}
-	}
-
-	close(jobs)
-	wg.Wait()
-
-	if ctx.Err() != nil {
-		return results, fmt.Errorf("context canceled: %w", ctx.Err())
-	}
-
-	return results, nil
-}
-
-func isContextCancellation(err error) bool {
-	return errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)
-}
-
-// uploadRecordCleanupContext keeps terminal upload record updates bounded while
-// allowing them to outlive the caller's canceled context.
-func uploadRecordCleanupContext(ctx context.Context) (context.Context, context.CancelFunc) {
-	return context.WithTimeout(context.WithoutCancel(ctx), uploadRecordFinalizationTimeout)
 }
 
 func (s *Service) maxConcurrentTrackerUploads(total int) int {
@@ -520,14 +81,14 @@ func (s *Service) maxConcurrentTrackerUploads(total int) int {
 // preflightDescriptionImageHosts resolves hosted screenshot URLs before upload
 // workers run, using configured image-host preferences even for trackers without
 // a restricted image-host policy.
-func (s *Service) preflightDescriptionImageHosts(ctx context.Context, meta api.PreparedMetadata, trackers []string) imageHostPreflight {
-	preferredImageHosts := preparationImageHostPreferences(s.cfg, meta, trackers, s.logger)
+func (s *Service) preflightDescriptionImageHosts(ctx context.Context, meta api.UploadSubject, trackers []string) imageHostPreflight {
+	preferredImageHosts := preparationImageHostPreferences(s.cfg, meta, trackers, s.logger, s.registry)
 	return s.preflightDescriptionImageHostsWithPreferences(ctx, meta, trackers, preferredImageHosts, nil, true)
 }
 
 func (s *Service) preflightDescriptionImageHostsWithPreferences(
 	ctx context.Context,
-	meta api.PreparedMetadata,
+	meta api.UploadSubject,
 	trackers []string,
 	preferredImageHosts map[string]string,
 	preloaded *preloadedDescriptionAssetData,
@@ -552,21 +113,22 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 		default:
 		}
 
-		if _, ok := s.registry.Lookup(tracker); !ok {
+		mode, ok := s.registry.LookupUploadContentMode(tracker)
+		if !ok || !mode.UsesImages() {
 			continue
 		}
 		trackerCfg := trackerConfigFor(s.cfg, tracker)
 		trackerCfg = applyTrackerConfigOverrides(trackerCfg, meta.TrackerConfigOverrides)
 		targetKey := ""
-		policy, err := resolveImageHostPolicyForMetadata(tracker, s.cfg, trackerCfg, meta, meta.ImageHostOverrides)
+		policy, err := resolveImageHostPolicyForMetadataWithRegistry(s.registry, tracker, s.cfg, trackerCfg, meta.ImageHostOverrides)
 		if err != nil {
 			s.logger.Warnf("trackers: image host preflight failed for %s: %v", tracker, err)
 			continue
 		}
 		if host := preferredHost(effectiveImageHostSelectionPolicy(policy, preferredImageHosts[strings.ToUpper(strings.TrimSpace(tracker))])); host != "" {
-			targetKey = strings.ToLower(strings.TrimSpace(host)) + "\x00" + normalizeUsageScope(usageScopeForHost(host))
+			targetKey = strings.ToLower(strings.TrimSpace(host)) + "\x00" + normalizeUsageScope(usageScopeForHost(s.registry, host))
 		} else if host := preferredImageHosts[strings.ToUpper(strings.TrimSpace(tracker))]; strings.TrimSpace(host) != "" {
-			targetKey = strings.ToLower(strings.TrimSpace(host)) + "\x00" + normalizeUsageScope(usageScopeForHost(host))
+			targetKey = strings.ToLower(strings.TrimSpace(host)) + "\x00" + normalizeUsageScope(usageScopeForHost(s.registry, host))
 		}
 		entry := preflightEntry{
 			tracker:    tracker,
@@ -583,7 +145,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 
 	if preloaded == nil && (len(representatives) > 0 || resolveAll) {
 		var err error
-		preloaded, err = preloadDescriptionAssetData(ctx, meta, s.repo)
+		preloaded, err = preloadScreenshotAssetData(ctx, meta, s.repo, s.registry)
 		if err != nil {
 			s.logger.Warnf("trackers: image host preflight preload failed for %s: %v", meta.SourcePath, err)
 			preloaded = nil
@@ -604,7 +166,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 			if ctx.Err() != nil {
 				return
 			}
-			resolution, err := ensureDescriptionImageHostWithData(
+			resolution, err := ensureDescriptionImageHostWithDataAndRegistry(
 				ctx,
 				entry.tracker,
 				meta,
@@ -613,6 +175,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 				s.repo,
 				s.images,
 				s.logger,
+				s.registry,
 				preloadedCopy,
 				preferredImageHosts[strings.ToUpper(strings.TrimSpace(entry.tracker))],
 			)
@@ -635,7 +198,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 	}
 
 	if len(representatives) > 0 && reuploaded {
-		refreshed, err := preloadDescriptionAssetData(ctx, meta, s.repo)
+		refreshed, err := preloadScreenshotAssetData(ctx, meta, s.repo, s.registry)
 		if err != nil {
 			s.logger.Warnf("trackers: image host preflight reload failed for %s: %v", meta.SourcePath, err)
 		} else {
@@ -648,7 +211,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 		if _, ok := resolutions[key]; ok {
 			continue
 		}
-		resolution, err := ensureDescriptionImageHostWithData(
+		resolution, err := ensureDescriptionImageHostWithDataAndRegistry(
 			ctx,
 			entry.tracker,
 			meta,
@@ -657,6 +220,7 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 			s.repo,
 			s.images,
 			s.logger,
+			s.registry,
 			preloaded,
 			preferredImageHosts[strings.ToUpper(strings.TrimSpace(entry.tracker))],
 		)
@@ -669,7 +233,43 @@ func (s *Service) preflightDescriptionImageHostsWithPreferences(
 	return resolutions
 }
 
-func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadata, trackersList []string) (api.PreparationPreview, error) {
+func (s *Service) preloadUploadContentData(
+	ctx context.Context,
+	meta api.UploadSubject,
+	trackerNames []string,
+) (*preloadedDescriptionAssetData, error, error) {
+	needsImages := false
+	needsDescription := false
+	for _, tracker := range trackerNames {
+		mode, ok := s.registry.LookupUploadContentMode(tracker)
+		if !ok {
+			continue
+		}
+		needsImages = needsImages || mode.UsesImages()
+		needsDescription = needsDescription || mode.UsesDescription()
+	}
+	if !needsImages {
+		return nil, nil, nil
+	}
+	preloaded, err := preloadScreenshotAssetData(ctx, meta, s.repo, s.registry)
+	if err != nil {
+		return nil, err, err
+	}
+	if !needsDescription {
+		return preloaded, nil, nil
+	}
+	if err := preloadDescriptionFields(ctx, meta, s.repo, preloaded); err != nil {
+		return preloaded, nil, err
+	}
+	return preloaded, nil, nil
+}
+
+// BuildPreparation resolves tracker descriptions and image requirements without
+// tracker submission. It may rehost screenshots and persist reusable slot
+// variants; tracker-local content failures are returned in the preview while
+// cancellation and invalid top-level selection return errors.
+func (s *Service) BuildPreparation(ctx context.Context, subject api.DescriptionSubject, trackersList []string) (api.PreparationPreview, error) {
+	meta := uploadSubjectForDescription(subject)
 	select {
 	case <-ctx.Done():
 		return api.PreparationPreview{}, fmt.Errorf("context canceled: %w", ctx.Err())
@@ -678,9 +278,8 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 
 	resolved := trackersList
 	if len(resolved) == 0 {
-		resolved = ResolveTrackersWithDefaults(s.cfg, meta.Trackers, meta.TrackersRemove, s.logger)
+		resolved = ResolveTrackersWithDefaultsAndRegistry(s.cfg, meta.Trackers, meta.TrackersRemove, s.logger, s.registry)
 	}
-	resolved = filterTrackersByRuleFailures(resolved, meta.TrackerRuleFailures, meta.IgnoreTrackerRuleFailures, s.logger)
 	resolved = filterTrackersByBlocks(resolved, meta.BlockedTrackers, s.logger)
 	if len(resolved) == 0 {
 		return api.PreparationPreview{}, errors.New("trackers: no trackers configured")
@@ -688,15 +287,36 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 	if s.registry == nil {
 		return api.PreparationPreview{}, errors.New("trackers: registry not configured")
 	}
+	contentFailures := make([]api.TrackerContentFailure, 0)
+	descriptionTrackers := make([]string, 0, len(resolved))
+	for _, tracker := range resolved {
+		mode, ok := s.registry.LookupUploadContentMode(tracker)
+		if !ok {
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, errors.New("tracker upload content capability is unavailable"))
+			contentFailures = append(contentFailures, *failed.Failure)
+			continue
+		}
+		if mode.UsesDescription() {
+			descriptionTrackers = append(descriptionTrackers, tracker)
+		}
+	}
+	resolved = descriptionTrackers
+	if len(resolved) == 0 {
+		return api.PreparationPreview{SourcePath: meta.SourcePath, ContentFailures: contentFailures}, nil
+	}
 
 	s.logger.Debugf("trackers: preparation decision=build trackers=%d", len(resolved))
 
-	preloaded, err := preloadDescriptionAssetData(ctx, meta, s.repo)
+	preloaded, err := preloadDescriptionAssetData(ctx, meta, s.repo, s.registry)
 	if err != nil {
 		s.logger.Warnf("trackers: preparation preload failed source=%s err=%s", meta.SourcePath, redaction.RedactValue(err.Error(), nil))
-		preloaded = nil
+		for _, tracker := range resolved {
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, err)
+			contentFailures = append(contentFailures, *failed.Failure)
+		}
+		return api.PreparationPreview{SourcePath: meta.SourcePath, ContentFailures: contentFailures}, nil
 	}
-	preferredImageHosts := preparationImageHostPreferences(s.cfg, meta, resolved, s.logger)
+	preferredImageHosts := preparationImageHostPreferences(s.cfg, meta, resolved, s.logger, s.registry)
 	preflight := s.preflightDescriptionImageHostsWithPreferences(ctx, meta, resolved, preferredImageHosts, preloaded, false)
 	preflightUploaded := false
 	for _, resolution := range preflight {
@@ -706,46 +326,21 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 		}
 	}
 	if preflightUploaded {
-		refreshed, reloadErr := preloadDescriptionAssetData(ctx, meta, s.repo)
+		refreshed, reloadErr := preloadDescriptionAssetData(ctx, meta, s.repo, s.registry)
 		if reloadErr != nil {
 			s.logger.Warnf("trackers: preparation preload reload failed source=%s err=%s", meta.SourcePath, redaction.RedactValue(reloadErr.Error(), nil))
-		} else {
-			preloaded = refreshed
+			for _, tracker := range resolved {
+				failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, reloadErr)
+				contentFailures = append(contentFailures, *failed.Failure)
+			}
+			return api.PreparationPreview{SourcePath: meta.SourcePath, ContentFailures: contentFailures}, nil
 		}
+		preloaded = refreshed
 	}
 
 	grouped := make(map[string]*api.PreparationDescription)
 	order := make([]string, 0, len(resolved))
 	placeholderCount := 0
-	placeholder := func(groupKey, tracker string, note string, imageHost api.ImageHostFeedback) {
-		key := strings.TrimSpace(groupKey)
-		if key == "" {
-			key = tracker
-		}
-		entry, exists := grouped[key]
-		if !exists {
-			entry = &api.PreparationDescription{
-				GroupKey:           key,
-				Trackers:           []string{},
-				RawDescription:     "",
-				RawDescriptionHTML: "",
-				Description:        "",
-				DescriptionHTML:    "",
-				ImageHost:          imageHost,
-			}
-			grouped[key] = entry
-			order = append(order, key)
-		} else {
-			entry.ImageHost = mergePreparationImageHostFeedback(entry.ImageHost, imageHost)
-		}
-		entry.Trackers = append(entry.Trackers, tracker)
-		placeholderCount++
-		if note != "" {
-			s.logger.Warnf("trackers: preparation placeholder tracker=%s note=%s", tracker, note)
-		} else {
-			s.logger.Warnf("trackers: preparation placeholder for %s", tracker)
-		}
-	}
 
 	for _, tracker := range resolved {
 		select {
@@ -756,12 +351,8 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 
 		definition, ok := s.registry.Lookup(tracker)
 		if !ok {
-			placeholder("", tracker, "not registered", api.ImageHostFeedback{})
-			continue
-		}
-		builder, ok := definition.(DescriptionBuilder)
-		if !ok {
-			placeholder("", tracker, "no description builder", api.ImageHostFeedback{})
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, errors.New("tracker is not registered"))
+			contentFailures = append(contentFailures, *failed.Failure)
 			continue
 		}
 		trackerCfg := trackerConfigFor(s.cfg, tracker)
@@ -770,7 +361,7 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 		resolution, ok := preflight[key]
 		if !ok {
 			var err error
-			resolution, err = ensureDescriptionImageHostWithData(
+			resolution, err = ensureDescriptionImageHostWithDataAndRegistry(
 				ctx,
 				tracker,
 				meta,
@@ -779,40 +370,45 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 				s.repo,
 				s.images,
 				s.logger,
+				s.registry,
 				preloaded,
 				preferredImageHosts[key],
 			)
 			if err != nil {
 				s.logger.Warnf("trackers: preparation image host resolution failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
-				placeholder("", tracker, fmt.Sprintf("image host error: %v", err), api.ImageHostFeedback{})
+				failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, err)
+				contentFailures = append(contentFailures, *failed.Failure)
 				continue
 			}
 		}
 		if resolution.blocking {
-			feedback := blockedPreparationImageHostFeedback(resolution.feedback)
-			placeholder(preparationBlockedImageHostGroupKey(tracker), tracker, "image host blocked", feedback)
+			message := strings.TrimSpace(resolution.feedback.Message)
+			if message == "" {
+				message = "image-host requirements could not be met"
+			}
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, errors.New(message))
+			contentFailures = append(contentFailures, *failed.Failure)
 			continue
 		}
 		assets, err := resolveDescriptionAssets(ctx, tracker, meta, s.repo, s.logger, preloaded)
 		if err != nil {
 			s.logger.Warnf("trackers: preparation assets failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
-			assets = DescriptionAssets{}
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, err)
+			contentFailures = append(contentFailures, *failed.Failure)
+			continue
 		}
 		applyResolvedDescriptionScreenshots(ctx, meta, s.repo, preloaded, &assets, resolution.screenshots)
-		result, err := builder.BuildDescription(ctx, DescriptionRequest{
-			Tracker:       tracker,
-			Meta:          meta,
-			TrackerConfig: trackerCfg,
-			AppConfig:     s.cfg,
-			Logger:        s.logger,
-			Repo:          s.repo,
-			Assets:        &assets,
-		})
-		if err != nil {
-			s.logger.Errorf("trackers: preparation failed for %s: %v", tracker, err)
-			placeholder("", tracker, "build error", api.ImageHostFeedback{})
+		plan, failure := definition.Prepare(ctx, s.preparationInput(ctx, PreparationIntentDescriptionPreview, tracker, meta, trackerCfg, &assets))
+		if failure != nil {
+			s.logger.Errorf("trackers: preparation failed for %s: %v", tracker, failure)
+			failed := failedPreparedUploadContent(tracker, UploadContentModeDescription, failure)
+			contentFailures = append(contentFailures, *failed.Failure)
 			continue
 		}
+		result := plan.Description()
+		if err := plan.Release(); err != nil {
+			s.logger.Warnf("trackers: plan release failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
+		}
 
 		descriptionText := strings.TrimSpace(result.Description)
 		if descriptionText == "" {
@@ -859,16 +455,59 @@ func (s *Service) BuildPreparation(ctx context.Context, meta api.PreparedMetadat
 
 	results = stabilizePreparationDescriptionGroupKeys(results)
 
-	return api.PreparationPreview{SourcePath: meta.SourcePath, Descriptions: results}, nil
+	return api.PreparationPreview{
+		SourcePath:      meta.SourcePath,
+		Descriptions:    results,
+		ContentFailures: contentFailures,
+	}, nil
+}
+
+// uploadSubjectForDescription is private tracker implementation plumbing.
+// Callers provide only the description-owned contract.
+func uploadSubjectForDescription(subject api.DescriptionSubject) api.UploadSubject {
+	return api.UploadSubject{
+		SourcePath:             subject.SourcePath,
+		DiscType:               subject.DiscType,
+		MediaInfoTextPath:      subject.MediaInfoTextPath,
+		DVDVOBMediaInfoText:    subject.DVDVOBMediaInfoText,
+		DescriptionTemplate:    subject.DescriptionTemplate,
+		EpisodeOverview:        subject.EpisodeOverview,
+		Options:                subject.Options,
+		Release:                subject.Release,
+		SelectedBDMVPlaylists:  append([]api.PlaylistInfo(nil), subject.SelectedBDMVPlaylists...),
+		Tag:                    subject.Tag,
+		Identity:               subject.Identity,
+		ProviderMetadata:       subject.ProviderMetadata,
+		SeasonInt:              subject.SeasonInt,
+		EpisodeInt:             subject.EpisodeInt,
+		Filename:               subject.Filename,
+		ReleaseName:            subject.ReleaseName,
+		ReleaseNameNoTag:       subject.ReleaseNameNoTag,
+		ServiceLongName:        subject.ServiceLongName,
+		Type:                   subject.Type,
+		HDR:                    subject.HDR,
+		ArrReleaseGroup:        subject.ArrReleaseGroup,
+		Trackers:               append([]string(nil), subject.Trackers...),
+		TrackerConfigOverrides: subject.TrackerConfig,
+		TrackerSiteOverrides:   subject.TrackerSite,
+		ImageHostOverrides:     subject.ImageHost,
+		TrackerData:            append([]api.TrackerMetadata(nil), subject.TrackerData...),
+	}
 }
 
 // preparationImageHostPreferences returns the first upload host each tracker
 // should prefer when generated screenshots need hosted URLs.
-func preparationImageHostPreferences(appCfg config.Config, meta api.PreparedMetadata, trackers []string, logger api.Logger) map[string]string {
+func preparationImageHostPreferences(
+	appCfg config.Config,
+	meta api.UploadSubject,
+	trackers []string,
+	logger api.Logger,
+	registry *Registry,
+) map[string]string {
 	if meta.ImageHostOverrides.PreferredHost != nil {
 		return nil
 	}
-	targets, err := NeededImageUploadTargetsForMetadata(appCfg, trackers, "", meta)
+	targets, err := NeededImageUploadTargetsForMetadataWithRegistry(registry, appCfg, trackers, "", meta)
 	if err != nil {
 		if logger != nil {
 			logger.Warnf("trackers: preparation image host target resolution failed: %v", err)
@@ -908,20 +547,30 @@ func blockedPreparationImageHostFeedback(feedback api.ImageHostFeedback) api.Ima
 	return feedback
 }
 
-func preparationBlockedImageHostGroupKey(tracker string) string {
-	name := strings.ToLower(strings.TrimSpace(tracker))
-	if name == "" {
-		name = "tracker"
-	}
-	return name + "|blocked|image-host"
+// BuildUploadReview builds tracker payloads needed for upload authorization
+// without enabling explicit dry-run diagnostic artifacts or tracker submission.
+// Shared preparation may still write local torrent artifacts, rehost images,
+// and persist reusable image-slot state.
+func (s *Service) BuildUploadReview(ctx context.Context, meta api.UploadSubject, trackersList []string) ([]api.TrackerDryRunEntry, error) {
+	return s.buildUploadPreview(ctx, meta, trackersList, PreparationIntentUploadReview)
+}
+
+// BuildUploadDryRun builds explicit payload previews without tracker submission.
+// Shared preparation may still write local torrent artifacts, rehost images,
+// and persist reusable image-slot state.
+func (s *Service) BuildUploadDryRun(ctx context.Context, meta api.UploadSubject, trackersList []string) ([]api.TrackerDryRunEntry, error) {
+	return s.buildUploadPreview(ctx, meta, trackersList, PreparationIntentDryRun)
 }
 
-// BuildUploadDryRun builds tracker upload payload previews without performing
-// tracker uploads. Dry-run processing still evaluates all resolved tracker
-// builders and banned-group state. It does not apply rule-failure or blocked
-// tracker suppression itself; callers that want suppression must pass an already
-// filtered tracker list.
-func (s *Service) BuildUploadDryRun(ctx context.Context, meta api.PreparedMetadata, trackersList []string) ([]api.TrackerDryRunEntry, error) {
+// buildUploadPreview evaluates every resolved tracker builder and banned-group
+// state. Core owns cross-tracker rule, duplicate, and eligibility decisions.
+func (s *Service) buildUploadPreview(
+	ctx context.Context,
+	meta api.UploadSubject,
+	trackersList []string,
+	intent PreparationIntent,
+) ([]api.TrackerDryRunEntry, error) {
+	logger := logging.FromContext(ctx, s.logger)
 	select {
 	case <-ctx.Done():
 		return nil, fmt.Errorf("context canceled: %w", ctx.Err())
@@ -930,9 +579,9 @@ func (s *Service) BuildUploadDryRun(ctx context.Context, meta api.PreparedMetada
 
 	resolved := trackersList
 	if len(resolved) == 0 {
-		resolved = ResolveTrackersWithDefaults(s.cfg, meta.Trackers, meta.TrackersRemove, s.logger)
+		resolved = ResolveTrackersWithDefaultsAndRegistry(s.cfg, meta.Trackers, meta.TrackersRemove, logger, s.registry)
 	}
-	resolved = filterKnownTrackers(resolved, s.logger)
+	resolved = filterKnownTrackersWithRegistry(resolved, logger, s.registry)
 	if len(resolved) == 0 {
 		return nil, errors.New("trackers: no trackers configured")
 	}
@@ -940,13 +589,30 @@ func (s *Service) BuildUploadDryRun(ctx context.Context, meta api.PreparedMetada
 		return nil, errors.New("trackers: registry not configured")
 	}
 
-	s.logger.Debugf("trackers: dry-run decision=build trackers=%d", len(resolved))
+	logger.Debugf("trackers: payload preview decision=build intent=%s trackers=%d", intent, len(resolved))
 	bannedResults := s.dryRunBannedGroupResults(ctx, meta, resolved)
 
-	preloaded, err := preloadDescriptionAssetData(ctx, meta, s.repo)
-	if err != nil {
-		s.logger.Warnf("trackers: dry-run preload failed source=%s err=%s", meta.SourcePath, redaction.RedactValue(err.Error(), nil))
-		preloaded = nil
+	preloaded, screenshotPreloadErr, descriptionPreloadErr := s.preloadUploadContentData(ctx, meta, resolved)
+	if screenshotPreloadErr != nil {
+		logger.Warnf(
+			"trackers: payload preview screenshot preload failed intent=%s source=%s err=%s",
+			intent,
+			meta.SourcePath,
+			redaction.RedactValue(screenshotPreloadErr.Error(), nil),
+		)
+	}
+	if descriptionPreloadErr != nil && !errors.Is(descriptionPreloadErr, screenshotPreloadErr) {
+		logger.Warnf(
+			"trackers: payload preview description preload failed intent=%s source=%s err=%s",
+			intent,
+			meta.SourcePath,
+			redaction.RedactValue(descriptionPreloadErr.Error(), nil),
+		)
+	}
+	preflight := imageHostPreflight(nil)
+	if screenshotPreloadErr == nil {
+		preferredImageHosts := preparationImageHostPreferences(s.cfg, meta, resolved, logger, s.registry)
+		preflight = s.preflightDescriptionImageHostsWithPreferences(ctx, meta, resolved, preferredImageHosts, preloaded, false)
 	}
 
 	results := make([]api.TrackerDryRunEntry, 0, len(resolved))
@@ -966,75 +632,59 @@ func (s *Service) BuildUploadDryRun(ctx context.Context, meta api.PreparedMetada
 			results = append(results, entry)
 			continue
 		}
-		builder, ok := definition.(UploadDryRunBuilder)
-		if !ok {
-			entry.Status = "not_supported"
-			entry.Message = "dry-run payload preview not implemented"
-			applyDryRunBannedGroupResult(&entry, bannedResults)
-			results = append(results, entry)
-			continue
-		}
-
 		trackerCfg := trackerConfigFor(s.cfg, tracker)
 		trackerCfg = applyTrackerConfigOverrides(trackerCfg, meta.TrackerConfigOverrides)
-		trackerMeta, err := PrepareTrackerUploadTorrent(meta, s.cfg.MainSettings.DBPath, tracker, trackerCfg)
+		trackerMeta, err := PrepareTrackerUploadTorrentWithRegistry(meta, s.cfg.MainSettings.DBPath, tracker, trackerCfg, s.registry)
 		if err != nil {
 			entry.Status = "error"
-			entry.Message = err.Error()
+			entry.Message = safeTrackerMessage(err)
 			applyDryRunBannedGroupResult(&entry, bannedResults)
 			results = append(results, entry)
 			continue
 		}
-		resolution, err := ensureDescriptionImageHostWithData(ctx, tracker, trackerMeta, s.cfg, trackerCfg, s.repo, s.images, s.logger, preloaded)
-		if err != nil {
-			s.logger.Warnf("trackers: dry-run image host resolution failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
-			entry.Status = "error"
-			entry.Message = err.Error()
-			applyDryRunBannedGroupResult(&entry, bannedResults)
-			results = append(results, entry)
-			continue
+		mode, _ := s.registry.LookupUploadContentMode(tracker)
+		contentPreloadErr := screenshotPreloadErr
+		if contentPreloadErr == nil && mode.UsesDescription() {
+			contentPreloadErr = descriptionPreloadErr
 		}
-		if resolution.blocking {
+		if contentPreloadErr != nil && mode.UsesImages() {
+			content := failedPreparedUploadContent(tracker, mode, contentPreloadErr)
 			entry.Status = "blocked"
-			entry.Message = resolution.feedback.Message
-			entry.ImageHost = resolution.feedback
+			entry.Message = content.Failure.Message
+			entry.ContentFailure = content.Failure
 			applyDryRunBannedGroupResult(&entry, bannedResults)
 			results = append(results, entry)
 			continue
 		}
-		assets, err := resolveDescriptionAssets(ctx, tracker, trackerMeta, s.repo, s.logger, preloaded)
-		if err != nil {
-			entry.Status = "error"
-			entry.Message = err.Error()
+		content := s.prepareUploadContent(ctx, tracker, trackerMeta, trackerCfg, preloaded, preflight)
+		if content.State == preparedUploadContentFailed {
+			entry.Status = "blocked"
+			entry.Message = content.Failure.Message
+			entry.ContentFailure = content.Failure
+			entry.ImageHost = content.ImageHost
 			applyDryRunBannedGroupResult(&entry, bannedResults)
 			results = append(results, entry)
 			continue
 		}
-		applyResolvedDescriptionScreenshots(ctx, trackerMeta, s.repo, preloaded, &assets, resolution.screenshots)
-		preview, err := builder.BuildUploadDryRun(ctx, UploadRequest{
-			Tracker:       tracker,
-			Meta:          trackerMeta,
-			TrackerConfig: trackerCfg,
-			AppConfig:     s.cfg,
-			Logger:        s.logger,
-			Repo:          s.repo,
-			Images:        s.images,
-			Assets:        &assets,
-		})
-		if err != nil {
+		plan, failure := definition.Prepare(ctx, s.preparationInput(ctx, intent, tracker, trackerMeta, trackerCfg, content.Assets))
+		if failure != nil {
 			entry.Status = "error"
-			entry.Message = err.Error()
+			entry.Message = failure.Message()
 			applyDryRunBannedGroupResult(&entry, bannedResults)
 			results = append(results, entry)
 			continue
 		}
+		preview := plan.DryRun()
+		if err := plan.Release(); err != nil {
+			logger.Warnf("trackers: plan release failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
+		}
 		if strings.TrimSpace(preview.Tracker) == "" {
 			preview.Tracker = tracker
 		}
 		if strings.TrimSpace(preview.Status) == "" {
 			preview.Status = "ready"
 		}
-		preview.ImageHost = resolution.feedback
+		preview.ImageHost = content.ImageHost
 		applyDryRunBannedGroupResult(&preview, bannedResults)
 		results = append(results, preview)
 	}
@@ -1051,29 +701,23 @@ type dryRunBannedGroupResult struct {
 // dryRunBannedGroupResults refreshes and checks banned groups for dry-run
 // annotations. A banned group marks the entry but does not suppress payload
 // generation; refresh or cache errors are reported per tracker for diagnostics.
-func (s *Service) dryRunBannedGroupResults(ctx context.Context, meta api.PreparedMetadata, trackers []string) map[string]dryRunBannedGroupResult {
+func (s *Service) dryRunBannedGroupResults(ctx context.Context, meta api.UploadSubject, trackers []string) map[string]dryRunBannedGroupResult {
+	logger := logging.FromContext(ctx, s.logger)
 	group := NormalizeBannedReleaseGroup(meta.Tag)
 	if group == "" || len(trackers) == 0 || s.banned == nil {
 		return nil
 	}
 
 	results := make(map[string]dryRunBannedGroupResult, len(trackers))
-	if err := s.banned.RefreshDynamic(ctx, s.cfg, trackers, s.logger); err != nil {
-		message := "banned group check failed: " + redaction.RedactValue(err.Error(), nil)
-		for _, tracker := range trackers {
-			name := strings.ToUpper(strings.TrimSpace(tracker))
-			if name != "" {
-				results[name] = dryRunBannedGroupResult{err: message}
-			}
-		}
-		return results
-	}
-
 	for _, tracker := range trackers {
 		name := strings.ToUpper(strings.TrimSpace(tracker))
 		if name == "" {
 			continue
 		}
+		if err := s.banned.RefreshDynamic(ctx, s.cfg, []string{name}, logger); err != nil {
+			results[name] = dryRunBannedGroupResult{err: "banned group check failed: " + redaction.RedactValue(err.Error(), nil)}
+			continue
+		}
 		banned, err := s.banned.IsBanned(name, group)
 		if err != nil {
 			results[name] = dryRunBannedGroupResult{err: "banned group check failed: " + redaction.RedactValue(err.Error(), nil)}
@@ -1115,32 +759,6 @@ func applyDryRunBannedGroupResult(entry *api.TrackerDryRunEntry, results map[str
 	entry.BannedCheckError = result.err
 }
 
-func filterTrackersByRuleFailures(trackers []string, failures map[string][]api.RuleFailure, ignore bool, logger api.Logger) []string {
-	if ignore || len(trackers) == 0 || len(failures) == 0 {
-		return trackers
-	}
-
-	filtered := make([]string, 0, len(trackers))
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		trackerFailures, ok := failures[name]
-		if ok && api.HasBlockingRuleFailures(trackerFailures) {
-			if logger != nil {
-				for _, failure := range trackerFailures {
-					if !api.IsBlockingRuleFailure(failure) {
-						continue
-					}
-					logger.Warnf("trackers: skipping %s due to rule failure %s (%s)", name, failure.Rule, failure.Reason)
-				}
-			}
-			continue
-		}
-		filtered = append(filtered, tracker)
-	}
-
-	return filtered
-}
-
 func filterTrackersByBlocks(trackers []string, blocked map[string][]api.TrackerBlockReason, logger api.Logger) []string {
 	if len(trackers) == 0 || len(blocked) == 0 {
 		return trackers
@@ -1206,7 +824,7 @@ func applyTrackerConfigOverrides(cfg config.TrackerConfig, overrides api.Tracker
 	return cfg
 }
 
-func filterKnownTrackers(trackers []string, logger api.Logger) []string {
+func filterKnownTrackersWithRegistry(trackers []string, logger api.Logger, registry *Registry) []string {
 	if len(trackers) == 0 {
 		return trackers
 	}
@@ -1217,7 +835,8 @@ func filterKnownTrackers(trackers []string, logger api.Logger) []string {
 		if upper == "" {
 			continue
 		}
-		if !IsKnownTracker(upper) {
+		_, registered := registry.LookupDescriptor(upper)
+		if !registered {
 			if logger != nil {
 				logger.Infof("trackers: unknown tracker %q, skipping", tracker)
 			}
@@ -1321,7 +940,12 @@ func preparationGroupKey(group string, host string, usageScope string) string {
 	return trimmedGroup + "|" + trimmedHost + "|" + trimmedScope
 }
 
-func preparationDescriptionGroup(grouped map[string]*api.PreparationDescription, order *[]string, groupKey string, candidate api.PreparationDescription) *api.PreparationDescription {
+func preparationDescriptionGroup(
+	grouped map[string]*api.PreparationDescription,
+	order *[]string,
+	groupKey string,
+	candidate api.PreparationDescription,
+) *api.PreparationDescription {
 	baseKey := strings.TrimSpace(groupKey)
 	if baseKey == "" {
 		baseKey = "description"
@@ -1348,7 +972,12 @@ func preparationDescriptionGroup(grouped map[string]*api.PreparationDescription,
 	}
 }
 
-func matchingUnit3DPreparationDescriptionGroup(grouped map[string]*api.PreparationDescription, order []string, groupKey string, candidate api.PreparationDescription) *api.PreparationDescription {
+func matchingUnit3DPreparationDescriptionGroup(
+	grouped map[string]*api.PreparationDescription,
+	order []string,
+	groupKey string,
+	candidate api.PreparationDescription,
+) *api.PreparationDescription {
 	if preparationDescriptionBaseGroup(groupKey) != "unit3d" {
 		return nil
 	}
@@ -1373,7 +1002,12 @@ func preparationDescriptionBaseGroup(groupKey string) string {
 	return baseGroup
 }
 
-func addPreparationDescriptionGroup(grouped map[string]*api.PreparationDescription, order *[]string, groupKey string, candidate api.PreparationDescription) *api.PreparationDescription {
+func addPreparationDescriptionGroup(
+	grouped map[string]*api.PreparationDescription,
+	order *[]string,
+	groupKey string,
+	candidate api.PreparationDescription,
+) *api.PreparationDescription {
 	entry := candidate
 	entry.GroupKey = groupKey
 	entry.Trackers = []string{}
diff --git a/internal/trackers/service_plan_test.go b/internal/trackers/service_plan_test.go
new file mode 100644
index 00000000..4cbd2863
--- /dev/null
+++ b/internal/trackers/service_plan_test.go
@@ -0,0 +1,245 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type barrierPlanDefinition struct {
+	name        string
+	started     chan<- string
+	releasePrep <-chan struct{}
+	submitted   chan<- string
+}
+
+func (d barrierPlanDefinition) Name() string { return d.name }
+
+func (barrierPlanDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (barrierPlanDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+
+func (d barrierPlanDefinition) Prepare(ctx context.Context, _ PreparationInput) (TrackerPlan, *PreparationFailure) {
+	d.started <- d.name
+	select {
+	case <-d.releasePrep:
+	case <-ctx.Done():
+		return TrackerPlan{}, NewPreparationFailure(d.name, "canceled", "preparation canceled", ctx.Err())
+	}
+	return NewUploadPlan(d.name, api.TrackerDryRunEntry{Tracker: d.name, Status: "ready"}, func(context.Context) (api.UploadSummary, error) {
+		d.submitted <- d.name
+		return api.UploadSummary{Uploaded: 1}, nil
+	}, nil), nil
+}
+
+func TestUploadPreparationHasBoundedPoolAndFullBarrier(t *testing.T) {
+	t.Parallel()
+	names := []string{"AITHER", "BHD", "BLU", "HDB", "MTV", "PTP"}
+	started := make(chan string, len(names))
+	submitted := make(chan string, len(names))
+	releasePrep := make(chan struct{})
+	registry := NewRegistry()
+	for _, name := range names {
+		if err := registry.Register(barrierPlanDefinition{
+			name:        name,
+			started:     started,
+			releasePrep: releasePrep,
+			submitted:   submitted,
+		}); err != nil {
+			t.Fatalf("register %s: %v", name, err)
+		}
+	}
+	svc := NewServiceWithRegistry(config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList(names)}}, nil, nil, registry)
+	done := make(chan error, 1)
+	go func() {
+		summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "Example.Release.2026"})
+		if err == nil && summary.Uploaded != len(names) {
+			err = fmt.Errorf("uploaded=%d", summary.Uploaded)
+		}
+		done <- err
+	}()
+
+	for range defaultMaxConcurrentTrackerPreparations {
+		select {
+		case <-started:
+		case <-time.After(10 * time.Second):
+			t.Fatal("preparation pool did not fill")
+		}
+	}
+	select {
+	case tracker := <-started:
+		t.Fatalf("preparation exceeded bound: %s", tracker)
+	case tracker := <-submitted:
+		t.Fatalf("submission crossed preparation barrier: %s", tracker)
+	default:
+	}
+	close(releasePrep)
+	for range names {
+		select {
+		case <-submitted:
+		case <-time.After(10 * time.Second):
+			t.Fatal("concurrent submission did not finish")
+		}
+	}
+	if err := <-done; err != nil {
+		t.Fatalf("upload: %v", err)
+	}
+}
+
+type readyReleasePlanDefinition struct {
+	name      string
+	releases  *atomic.Int32
+	submitted *atomic.Int32
+	prepared  chan<- struct{}
+}
+
+func (d readyReleasePlanDefinition) Name() string { return d.name }
+
+func (readyReleasePlanDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (readyReleasePlanDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+
+func (d readyReleasePlanDefinition) Prepare(context.Context, PreparationInput) (TrackerPlan, *PreparationFailure) {
+	if d.prepared != nil {
+		d.prepared <- struct{}{}
+	}
+	return NewUploadPlan(d.name, api.TrackerDryRunEntry{}, func(context.Context) (api.UploadSummary, error) {
+		d.submitted.Add(1)
+		return api.UploadSummary{Uploaded: 1}, nil
+	}, func() error {
+		d.releases.Add(1)
+		return nil
+	}), nil
+}
+
+type canceledPreparationDefinition struct {
+	name    string
+	started chan<- struct{}
+	wait    <-chan struct{}
+}
+
+func (d canceledPreparationDefinition) Name() string { return d.name }
+
+func (canceledPreparationDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (canceledPreparationDefinition) DefaultBaseURL() string {
+	return "https://tracker.example.invalid"
+}
+
+func (d canceledPreparationDefinition) Prepare(ctx context.Context, _ PreparationInput) (TrackerPlan, *PreparationFailure) {
+	if d.wait != nil {
+		<-d.wait
+	}
+	d.started <- struct{}{}
+	<-ctx.Done()
+	return TrackerPlan{}, NewPreparationFailure(d.name, "canceled", "preparation canceled", ctx.Err())
+}
+
+func TestUploadCancellationBeforeBarrierSubmitsNoneAndReleasesReadyPlans(t *testing.T) {
+	t.Parallel()
+	var releases atomic.Int32
+	var submits atomic.Int32
+	started := make(chan struct{}, 1)
+	ready := make(chan struct{}, 1)
+	registry := NewRegistry()
+	if err := registry.Register(readyReleasePlanDefinition{
+		name:      "AITHER",
+		releases:  &releases,
+		submitted: &submits,
+		prepared:  ready,
+	}); err != nil {
+		t.Fatalf("register ready: %v", err)
+	}
+	if err := registry.Register(canceledPreparationDefinition{
+		name:    "BLU",
+		started: started,
+		wait:    ready,
+	}); err != nil {
+		t.Fatalf("register blocking: %v", err)
+	}
+	svc := NewServiceWithRegistry(config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER", "BLU"}}}, nil, nil, registry)
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan error, 1)
+	go func() {
+		_, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "Example.Release.2026"})
+		done <- err
+	}()
+	select {
+	case <-started:
+	case <-time.After(10 * time.Second):
+		t.Fatal("blocking preparation did not start")
+	}
+	cancel()
+	if err := <-done; !errors.Is(err, context.Canceled) {
+		t.Fatalf("upload error = %v", err)
+	}
+	if submits.Load() != 0 || releases.Load() != 1 {
+		t.Fatalf("submits=%d releases=%d", submits.Load(), releases.Load())
+	}
+}
+
+type warningLogger struct {
+	api.NopLogger
+	mu       sync.Mutex
+	warnings []string
+}
+
+func (l *warningLogger) Warnf(format string, args ...any) {
+	l.mu.Lock()
+	l.warnings = append(l.warnings, fmt.Sprintf(format, args...))
+	l.mu.Unlock()
+}
+
+func TestUploadReleaseFailureAfterRemoteSuccessIsSanitizedWarningOnly(t *testing.T) {
+	t.Parallel()
+	logger := &warningLogger{}
+	registry := NewRegistry()
+	definition := readyReleasePlanDefinition{
+		name:      "AITHER",
+		releases:  &atomic.Int32{},
+		submitted: &atomic.Int32{},
+	}
+	if err := registry.Register(releaseErrorDefinition{readyReleasePlanDefinition: definition}); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	svc := NewServiceWithRegistry(config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}, logger, nil, registry)
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "Example.Release.2026"})
+	if err != nil || summary.Uploaded != 1 {
+		t.Fatalf("upload = %#v, %v", summary, err)
+	}
+	logger.mu.Lock()
+	joined := strings.Join(logger.warnings, "\n")
+	logger.mu.Unlock()
+	if !strings.Contains(joined, "plan release failed") || strings.Contains(joined, "secret-value") {
+		t.Fatalf("warnings = %q", joined)
+	}
+}
+
+type releaseErrorDefinition struct{ readyReleasePlanDefinition }
+
+func (d releaseErrorDefinition) Prepare(context.Context, PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return NewUploadPlan(d.name, api.TrackerDryRunEntry{}, func(context.Context) (api.UploadSummary, error) {
+		d.submitted.Add(1)
+		return api.UploadSummary{Uploaded: 1}, nil
+	}, func() error {
+		d.releases.Add(1)
+		return errors.New("token=secret-value cleanup failed")
+	}), nil
+}
diff --git a/internal/trackers/service_test.go b/internal/trackers/service_test.go
index 6d24bc75..681cb754 100644
--- a/internal/trackers/service_test.go
+++ b/internal/trackers/service_test.go
@@ -24,17 +24,16 @@ import (
 
 	"github.com/autobrr/upbrr/internal/config"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	dbsvc "github.com/autobrr/upbrr/internal/services/db"
-	descriptionhdb "github.com/autobrr/upbrr/internal/services/description/hdb"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 func TestUploadNoTrackers(t *testing.T) {
 	t.Parallel()
 
-	svc := NewService(config.Config{}, nil, nil)
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	svc := NewServiceWithRegistry(config.Config{}, nil, nil, NewRegistry())
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -47,10 +46,13 @@ func TestUploadConfiguredTrackers(t *testing.T) {
 	t.Parallel()
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"blU", "bhd"}}}
-	svc := NewService(cfg, nil, nil)
-	_, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
-	if !errors.Is(err, internalerrors.ErrNotImplemented) {
-		t.Fatalf("expected not implemented error, got %v", err)
+	svc := NewServiceWithRegistry(cfg, nil, nil, NewRegistry())
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if summary.Uploaded != 0 {
+		t.Fatalf("expected unsupported configured trackers to remain inert, got %d uploads", summary.Uploaded)
 	}
 }
 
@@ -58,17 +60,20 @@ func TestUploadOverrideTrackers(t *testing.T) {
 	t.Parallel()
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}}}
-	svc := NewService(cfg, nil, nil)
-	_, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file", Trackers: []string{"aither"}})
-	if !errors.Is(err, internalerrors.ErrNotImplemented) {
-		t.Fatalf("expected not implemented error, got %v", err)
+	svc := NewServiceWithRegistry(cfg, nil, nil, NewRegistry())
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file", Trackers: []string{"aither"}})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if summary.Uploaded != 0 {
+		t.Fatalf("expected unsupported override tracker to remain inert, got %d uploads", summary.Uploaded)
 	}
 }
 
 func TestUploadOverrideTrackersReplaceDefaults(t *testing.T) {
 	t.Parallel()
 
-	requests := make(chan UploadRequest, 2)
+	requests := make(chan PreparationInput, 2)
 	registry := NewRegistry()
 	for _, definition := range []Definition{
 		trackingUploadDefinition{name: "BLU", requests: requests},
@@ -81,7 +86,7 @@ func TestUploadOverrideTrackersReplaceDefaults(t *testing.T) {
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU"}}}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/file",
 		Trackers:   []string{"aither"},
 	})
@@ -111,10 +116,13 @@ func TestUploadRemovesTrackers(t *testing.T) {
 	t.Parallel()
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"BLU", "BHD"}}}
-	svc := NewService(cfg, nil, nil)
-	_, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file", TrackersRemove: []string{"bhd"}})
-	if !errors.Is(err, internalerrors.ErrNotImplemented) {
-		t.Fatalf("expected not implemented error, got %v", err)
+	svc := NewServiceWithRegistry(cfg, nil, nil, NewRegistry())
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file", TrackersRemove: []string{"bhd"}})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if summary.Uploaded != 0 {
+		t.Fatalf("expected unsupported configured trackers to remain inert, got %d uploads", summary.Uploaded)
 	}
 }
 
@@ -122,8 +130,8 @@ func TestUploadUnknownTrackers(t *testing.T) {
 	t.Parallel()
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"NOPE"}}}
-	svc := NewService(cfg, nil, nil)
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	svc := NewServiceWithRegistry(cfg, nil, nil, NewRegistry())
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -136,8 +144,16 @@ func TestUploadBannedGroup(t *testing.T) {
 	t.Parallel()
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"TOS"}}}
-	svc := NewService(cfg, nil, nil)
-	_, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file", Tag: "-FL3ER"})
+	registry := NewRegistry()
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:         "TOS",
+		Definition:   trackingUploadDefinition{name: "TOS"},
+		BannedGroups: []string{"FL3ER"},
+	}); err != nil {
+		t.Fatalf("register TOS: %v", err)
+	}
+	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
+	_, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file", Tag: "-FL3ER"})
 	if !errors.Is(err, internalerrors.ErrBannedGroup) {
 		t.Fatalf("expected banned group error, got %v", err)
 	}
@@ -154,7 +170,12 @@ func TestUploadSkipsDynamicBannedRefreshForEmptyEffectiveGroup(t *testing.T) {
 	defer server.Close()
 
 	registry := NewRegistry()
-	if err := registry.Register(trackingUploadDefinition{name: "AITHER"}); err != nil {
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:         "AITHER",
+		BaseURL:      "https://aither.cc",
+		Definition:   trackingUploadDefinition{name: "AITHER"},
+		BannedPolicy: &BannedGroupPolicy{EndpointPath: "/api/blacklists/releasegroups", RequireAPIKey: true},
+	}); err != nil {
 		t.Fatalf("register stub: %v", err)
 	}
 	cfg := config.Config{
@@ -162,14 +183,15 @@ func TestUploadSkipsDynamicBannedRefreshForEmptyEffectiveGroup(t *testing.T) {
 		Trackers: config.TrackersConfig{
 			DefaultTrackers: config.CSVList{"AITHER"},
 			Trackers: map[string]config.TrackerConfig{
-				"AITHER": {APIKey: "aither-key", URL: server.URL},
+				"AITHER": {APIKey: "aither-key"},
 			},
 		},
 	}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
+	svc.banned.client = bannedRewriteClient(t, server)
 
 	for _, tag := range []string{"-", " - ", "   "} {
-		summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file", Tag: tag})
+		summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file", Tag: tag})
 		if err != nil {
 			t.Fatalf("upload tag %q: %v", tag, err)
 		}
@@ -181,7 +203,7 @@ func TestUploadSkipsDynamicBannedRefreshForEmptyEffectiveGroup(t *testing.T) {
 		t.Fatalf("expected no dynamic banned refresh for empty effective group, got %d request(s)", got)
 	}
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file", Tag: "-GRP"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file", Tag: "-GRP"})
 	if err != nil {
 		t.Fatalf("upload real group: %v", err)
 	}
@@ -228,10 +250,16 @@ func TestNormalizeTrackersDedup(t *testing.T) {
 }
 
 type stubDryRunDefinition struct {
-	name      string
-	dryRunErr error
+	name         string
+	mode         UploadContentMode
+	dryRunErr    error
+	bannedGroups []string
+	intents      *[]PreparationIntent
+	inputs       *[]PreparationInput
 }
 
+func (s stubDryRunDefinition) BannedGroups() []string { return s.bannedGroups }
+
 type stubUploadArtifactDefinition struct {
 	name string
 }
@@ -245,7 +273,7 @@ type stubPreparationDefinition struct {
 type trackingUploadDefinition struct {
 	name     string
 	started  chan<- string
-	requests chan<- UploadRequest
+	requests chan<- PreparationInput
 	release  <-chan struct{}
 }
 
@@ -254,6 +282,7 @@ type blockingImageService struct {
 	started chan<- string
 	release <-chan struct{}
 	calls   []string
+	repo    *stubRepo
 }
 
 type blockingUploadDefinition struct {
@@ -273,11 +302,93 @@ type cancelAfterUploadDefinition struct {
 
 type testHDBPreparationDefinition struct{}
 
+func (s stubDryRunDefinition) UploadContentMode() UploadContentMode {
+	if s.mode != "" {
+		return s.mode
+	}
+	return UploadContentModeDescription
+}
+
+func (stubUploadArtifactDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (stubPreparationDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (trackingUploadDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (blockingUploadDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (cancelAfterUploadDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (testHDBPreparationDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
+func (stubDryRunDefinition) DefaultBaseURL() string         { return "https://tracker.example.invalid" }
+func (stubUploadArtifactDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+func (stubPreparationDefinition) DefaultBaseURL() string    { return "https://tracker.example.invalid" }
+func (trackingUploadDefinition) DefaultBaseURL() string     { return "https://tracker.example.invalid" }
+func (blockingUploadDefinition) DefaultBaseURL() string     { return "https://tracker.example.invalid" }
+func (cancelAfterUploadDefinition) DefaultBaseURL() string  { return "https://tracker.example.invalid" }
+func (hostAwareDescriptionDefinition) DefaultBaseURL() string {
+	return "https://tracker.example.invalid"
+}
+func (testHDBPreparationDefinition) DefaultBaseURL() string { return "https://tracker.example.invalid" }
+
+func (s stubDryRunDefinition) TrackerFamily() Family         { return testTrackerFamily(s.name) }
+func (s stubUploadArtifactDefinition) TrackerFamily() Family { return testTrackerFamily(s.name) }
+func (s stubPreparationDefinition) TrackerFamily() Family    { return testTrackerFamily(s.name) }
+func (t trackingUploadDefinition) TrackerFamily() Family     { return testTrackerFamily(t.name) }
+func (b blockingUploadDefinition) TrackerFamily() Family     { return testTrackerFamily(b.name) }
+func (d cancelAfterUploadDefinition) TrackerFamily() Family  { return testTrackerFamily(d.name) }
+func (s hostAwareDescriptionDefinition) TrackerFamily() Family {
+	return testTrackerFamily(s.name)
+}
+func (testHDBPreparationDefinition) TrackerFamily() Family { return FamilyStandalone }
+
+func (s stubDryRunDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(s.name)
+}
+func (s stubUploadArtifactDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(s.name)
+}
+func (s stubPreparationDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(s.name)
+}
+func (t trackingUploadDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(t.name)
+}
+func (b blockingUploadDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(b.name)
+}
+func (d cancelAfterUploadDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(d.name)
+}
+func (s hostAwareDescriptionDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker(s.name)
+}
+func (testHDBPreparationDefinition) ImageHostPolicy() *ImageHostPolicy {
+	return testImageHostPolicyForTracker("HDB")
+}
+
 func (b blockingUploadDefinition) Name() string {
 	return b.name
 }
 
-func (b blockingUploadDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (b blockingUploadDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, b)
+}
+
+func (b blockingUploadDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	if b.started != nil {
 		b.started <- b.name
 	}
@@ -294,7 +405,12 @@ func (d cancelAfterUploadDefinition) Name() string {
 	return d.name
 }
 
-func (d cancelAfterUploadDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (d cancelAfterUploadDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, d)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (d cancelAfterUploadDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	if d.cancel != nil {
 		d.cancel()
 	}
@@ -384,7 +500,12 @@ func (s stubUploadArtifactDefinition) Name() string {
 	return s.name
 }
 
-func (s stubUploadArtifactDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (s stubUploadArtifactDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, s)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (s stubUploadArtifactDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{
 		Uploaded: 1,
 		UploadedTorrents: []api.UploadedTorrent{
@@ -402,19 +523,25 @@ func (s stubPreparationDefinition) Name() string {
 	return s.name
 }
 
-func (s stubPreparationDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (s stubPreparationDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, s)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (s stubPreparationDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{Uploaded: 1}, nil
 }
 
-func (s stubPreparationDefinition) BuildDescription(context.Context, DescriptionRequest) (DescriptionResult, error) {
+//nolint:unparam // Error is required by the adapter description callback contract.
+func (s stubPreparationDefinition) prepareDescription(context.Context, PreparationInput) (DescriptionResult, error) {
 	return DescriptionResult{Group: s.group, Description: s.description}, nil
 }
 
-func (s *blockingImageService) ListCandidates(context.Context, api.PreparedMetadata) ([]api.ScreenshotImage, error) {
+func (s *blockingImageService) ListCandidates(context.Context, api.ImageHostingSubject) ([]api.ScreenshotImage, error) {
 	return nil, nil
 }
 
-func (s *blockingImageService) Upload(ctx context.Context, meta api.PreparedMetadata, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+func (s *blockingImageService) Upload(ctx context.Context, meta api.ImageHostingSubject, host string, usageScope string, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
 	s.mu.Lock()
 	s.calls = append(s.calls, host)
 	s.mu.Unlock()
@@ -444,6 +571,11 @@ func (s *blockingImageService) Upload(ctx context.Context, meta api.PreparedMeta
 			WebURL:     fmt.Sprintf("https://%s/%d", host, idx),
 		})
 	}
+	if s.repo != nil {
+		s.repo.mu.Lock()
+		s.repo.uploads = append(s.repo.uploads, results...)
+		s.repo.mu.Unlock()
+	}
 	return results, nil
 }
 
@@ -458,15 +590,25 @@ type hostAwareDescriptionDefinition struct {
 	group string
 }
 
+func (hostAwareDescriptionDefinition) UploadContentMode() UploadContentMode {
+	return UploadContentModeDescription
+}
+
 func (s hostAwareDescriptionDefinition) Name() string {
 	return s.name
 }
 
-func (s hostAwareDescriptionDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (s hostAwareDescriptionDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, s)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (s hostAwareDescriptionDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{Uploaded: 1}, nil
 }
 
-func (s hostAwareDescriptionDefinition) BuildDescription(_ context.Context, req DescriptionRequest) (DescriptionResult, error) {
+//nolint:unparam // Error is required by the adapter description callback contract.
+func (s hostAwareDescriptionDefinition) prepareDescription(_ context.Context, req PreparationInput) (DescriptionResult, error) {
 	host := "none"
 	if req.Assets != nil && len(req.Assets.Screenshots) > 0 {
 		host = strings.ToLower(strings.TrimSpace(req.Assets.Screenshots[0].Host))
@@ -485,27 +627,54 @@ func (testHDBPreparationDefinition) Name() string {
 	return "HDB"
 }
 
-func (testHDBPreparationDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (d testHDBPreparationDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, d)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (testHDBPreparationDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{Uploaded: 1}, nil
 }
 
-func (testHDBPreparationDefinition) BuildDescription(ctx context.Context, req DescriptionRequest) (DescriptionResult, error) {
+//nolint:unparam // Error is required by the adapter description callback contract.
+func (testHDBPreparationDefinition) prepareDescription(_ context.Context, req PreparationInput) (DescriptionResult, error) {
 	assets := DescriptionAssets{}
 	if req.Assets != nil {
 		assets = *req.Assets
 	}
-	description, err := descriptionhdb.BuildDescription(ctx, req.Meta, req.AppConfig, assets.Description, assets.MenuImages, assets.Screenshots)
-	if err != nil {
-		return DescriptionResult{}, fmt.Errorf("trackers: %w", err)
+	var description strings.Builder
+	description.WriteString(assets.Description)
+	for _, image := range assets.Screenshots {
+		if strings.TrimSpace(image.RawURL) != "" {
+			description.WriteString("\n[img]")
+			description.WriteString(image.RawURL)
+			description.WriteString("[/img]")
+		}
 	}
-	return DescriptionResult{Group: "hdb", Description: description}, nil
+	return DescriptionResult{Group: "hdb", Description: description.String()}, nil
 }
 
 func (t trackingUploadDefinition) Name() string {
 	return t.name
 }
 
-func (t trackingUploadDefinition) Upload(_ context.Context, req UploadRequest) (api.UploadSummary, error) {
+func (t trackingUploadDefinition) UploadArtifactPolicy() *UploadArtifactPolicy {
+	switch t.name {
+	case "HDB":
+		return &UploadArtifactPolicy{Source: "HDBits"}
+	case "PTP":
+		return &UploadArtifactPolicy{Source: "PTP"}
+	default:
+		return nil
+	}
+}
+
+func (t trackingUploadDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	return prepareTestDefinition(ctx, input, t)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (t trackingUploadDefinition) submit(_ context.Context, req PreparationInput) (api.UploadSummary, error) {
 	if t.started != nil {
 		t.started <- t.name
 	}
@@ -522,11 +691,22 @@ func (s stubDryRunDefinition) Name() string {
 	return s.name
 }
 
-func (s stubDryRunDefinition) Upload(context.Context, UploadRequest) (api.UploadSummary, error) {
+func (s stubDryRunDefinition) Prepare(ctx context.Context, input PreparationInput) (TrackerPlan, *PreparationFailure) {
+	if s.intents != nil {
+		*s.intents = append(*s.intents, input.Intent)
+	}
+	if s.inputs != nil {
+		*s.inputs = append(*s.inputs, input)
+	}
+	return prepareTestDefinition(ctx, input, s)
+}
+
+//nolint:unparam // Error is required by the adapter submission callback contract.
+func (s stubDryRunDefinition) submit(context.Context, PreparationInput) (api.UploadSummary, error) {
 	return api.UploadSummary{Uploaded: 1}, nil
 }
 
-func (s stubDryRunDefinition) BuildUploadDryRun(context.Context, UploadRequest) (api.TrackerDryRunEntry, error) {
+func (s stubDryRunDefinition) prepareDryRun(context.Context, PreparationInput) (api.TrackerDryRunEntry, error) {
 	if s.dryRunErr != nil {
 		return api.TrackerDryRunEntry{}, s.dryRunErr
 	}
@@ -546,7 +726,7 @@ func TestBuildUploadDryRunUsesBuilder(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"}, []string{"BLU"})
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"}, []string{"BLU"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -561,6 +741,216 @@ func TestBuildUploadDryRunUsesBuilder(t *testing.T) {
 	}
 }
 
+func TestBuildUploadPreviewUsesTypedReviewAndDryRunIntents(t *testing.T) {
+	t.Parallel()
+
+	intents := make([]PreparationIntent, 0, 2)
+	registry := NewRegistry()
+	if err := registry.Register(stubDryRunDefinition{name: "BLU", intents: &intents}); err != nil {
+		t.Fatalf("register stub: %v", err)
+	}
+	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
+	subject := api.UploadSubject{SourcePath: "/tmp/file"}
+	if _, err := svc.BuildUploadReview(context.Background(), subject, []string{"BLU"}); err != nil {
+		t.Fatalf("build upload review: %v", err)
+	}
+	if _, err := svc.BuildUploadDryRun(context.Background(), subject, []string{"BLU"}); err != nil {
+		t.Fatalf("build explicit dry run: %v", err)
+	}
+	if !slices.Equal(intents, []PreparationIntent{PreparationIntentUploadReview, PreparationIntentDryRun}) {
+		t.Fatalf("preparation intents = %#v", intents)
+	}
+}
+
+func TestBuildPreparationSkipsAllNonDescriptionContent(t *testing.T) {
+	t.Parallel()
+
+	registry := NewRegistry()
+	for _, definition := range []Definition{
+		stubDryRunDefinition{name: "NONE", mode: UploadContentModeNone},
+		stubDryRunDefinition{name: "IMAGES", mode: UploadContentModeScreenshots},
+	} {
+		if err := registry.Register(definition); err != nil {
+			t.Fatalf("register stub: %v", err)
+		}
+	}
+	repo := &stubRepo{
+		trackerRecordsErr:      errors.New("tracker metadata unavailable"),
+		selectionsErr:          errors.New("selections unavailable"),
+		screenshotSlotsErr:     errors.New("slots unavailable"),
+		uploadsErr:             errors.New("uploads unavailable"),
+		descriptionOverrideErr: errors.New("overrides unavailable"),
+	}
+	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
+
+	preview, err := svc.BuildPreparation(
+		context.Background(),
+		api.NewDescriptionSubject(api.UploadSubject{SourcePath: "/tmp/source"}),
+		[]string{"NONE", "IMAGES"},
+	)
+	if err != nil {
+		t.Fatalf("build preparation: %v", err)
+	}
+	if len(preview.Descriptions) != 0 || len(preview.ContentFailures) != 0 {
+		t.Fatalf("expected empty non-description preview, got %#v", preview)
+	}
+	if repo.trackerRecordsCalls != 0 || repo.selectionsCalls != 0 || repo.screenshotSlotCalls != 0 || repo.uploadsCalls != 0 || repo.overrideCalls != 0 {
+		t.Fatalf("expected no content repository reads, got tracker=%d selections=%d slots=%d uploads=%d overrides=%d",
+			repo.trackerRecordsCalls,
+			repo.selectionsCalls,
+			repo.screenshotSlotCalls,
+			repo.uploadsCalls,
+			repo.overrideCalls,
+		)
+	}
+}
+
+func TestBuildUploadDryRunNoneModeSkipsSharedContent(t *testing.T) {
+	t.Parallel()
+
+	inputs := make([]PreparationInput, 0, 1)
+	registry := NewRegistry()
+	if err := registry.Register(stubDryRunDefinition{
+name: "NONE",
+ mode: UploadContentModeNone,
+ inputs: &inputs,
+}); err != nil {
+		t.Fatalf("register stub: %v", err)
+	}
+	repo := &stubRepo{
+		trackerRecordsErr:      errors.New("tracker metadata unavailable"),
+		selectionsErr:          errors.New("selections unavailable"),
+		screenshotSlotsErr:     errors.New("slots unavailable"),
+		uploadsErr:             errors.New("uploads unavailable"),
+		descriptionOverrideErr: errors.New("overrides unavailable"),
+	}
+	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
+
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"}, []string{"NONE"})
+	if err != nil {
+		t.Fatalf("build dry run: %v", err)
+	}
+	if len(entries) != 1 || entries[0].Status != "ready" {
+		t.Fatalf("expected ready none-mode preview, got %#v", entries)
+	}
+	if len(inputs) != 1 || inputs[0].Assets != nil {
+		t.Fatalf("expected adapter invocation without shared assets, got %#v", inputs)
+	}
+	if repo.trackerRecordsCalls != 0 || repo.selectionsCalls != 0 || repo.screenshotSlotCalls != 0 || repo.uploadsCalls != 0 || repo.overrideCalls != 0 {
+		t.Fatalf("expected no content repository reads, got tracker=%d selections=%d slots=%d uploads=%d overrides=%d",
+			repo.trackerRecordsCalls,
+			repo.selectionsCalls,
+			repo.screenshotSlotCalls,
+			repo.uploadsCalls,
+			repo.overrideCalls,
+		)
+	}
+}
+
+func TestBuildUploadDryRunDistinguishesReadyEmptyAndFailedScreenshots(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		repo       *stubRepo
+		wantStatus string
+		wantCalls  int
+	}{
+		{
+name: "ready empty",
+ repo: &stubRepo{},
+ wantStatus: "ready",
+ wantCalls: 1,
+},
+		{
+name: "failed",
+ repo: &stubRepo{selectionsErr: errors.New("selections unavailable")},
+ wantStatus: "blocked",
+ wantCalls: 0,
+},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			inputs := make([]PreparationInput, 0, 1)
+			registry := NewRegistry()
+			if err := registry.Register(stubDryRunDefinition{
+name: "IMAGES",
+ mode: UploadContentModeScreenshots,
+ inputs: &inputs,
+}); err != nil {
+				t.Fatalf("register stub: %v", err)
+			}
+			svc := NewServiceWithRegistry(config.Config{}, nil, test.repo, registry)
+
+			entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"}, []string{"IMAGES"})
+			if err != nil {
+				t.Fatalf("build dry run: %v", err)
+			}
+			if len(entries) != 1 || entries[0].Status != test.wantStatus {
+				t.Fatalf("expected status %q, got %#v", test.wantStatus, entries)
+			}
+			if len(inputs) != test.wantCalls {
+				t.Fatalf("adapter calls = %d, want %d", len(inputs), test.wantCalls)
+			}
+			if test.wantStatus == "ready" {
+				if inputs[0].Assets == nil || len(inputs[0].Assets.Screenshots) != 0 || strings.TrimSpace(inputs[0].Assets.Description) != "" {
+					t.Fatalf("expected ready empty screenshot assets, got %#v", inputs[0].Assets)
+				}
+				if test.repo.overrideCalls != 0 {
+					t.Fatalf("screenshot mode loaded description overrides %d time(s)", test.repo.overrideCalls)
+				}
+			} else if entries[0].ContentFailure == nil || entries[0].ContentFailure.Code != api.TrackerEligibilityScreenshotPreparationFailed {
+				t.Fatalf("expected structured screenshot failure, got %#v", entries[0].ContentFailure)
+			}
+		})
+	}
+}
+
+func TestBuildUploadDryRunScopesDescriptionPreloadFailure(t *testing.T) {
+	t.Parallel()
+
+	screenshotInputs := make([]PreparationInput, 0, 1)
+	descriptionInputs := make([]PreparationInput, 0, 1)
+	registry := NewRegistry()
+	for _, definition := range []Definition{
+		stubDryRunDefinition{
+name: "IMAGES",
+ mode: UploadContentModeScreenshots,
+ inputs: &screenshotInputs,
+},
+		stubDryRunDefinition{
+name: "DESCRIPTION",
+ mode: UploadContentModeDescription,
+ inputs: &descriptionInputs,
+},
+	} {
+		if err := registry.Register(definition); err != nil {
+			t.Fatalf("register stub: %v", err)
+		}
+	}
+	repo := &stubRepo{descriptionOverrideErr: errors.New("description overrides unavailable")}
+	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
+
+	entries, err := svc.BuildUploadDryRun(
+		context.Background(),
+		api.UploadSubject{SourcePath: "/tmp/source"},
+		[]string{"IMAGES", "DESCRIPTION"},
+	)
+	if err != nil {
+		t.Fatalf("build dry run: %v", err)
+	}
+	if len(entries) != 2 || entries[0].Tracker != "IMAGES" || entries[0].Status != "ready" || entries[1].Tracker != "DESCRIPTION" || entries[1].Status != "blocked" {
+		t.Fatalf("unexpected mixed-mode results: %#v", entries)
+	}
+	if len(screenshotInputs) != 1 || len(descriptionInputs) != 0 {
+		t.Fatalf("expected only screenshot adapter invocation, screenshots=%d descriptions=%d", len(screenshotInputs), len(descriptionInputs))
+	}
+	if entries[1].ContentFailure == nil || entries[1].ContentFailure.Code != api.TrackerEligibilityDescriptionPreparationFailed {
+		t.Fatalf("expected structured description failure, got %#v", entries[1].ContentFailure)
+	}
+}
+
 func TestBuildUploadDryRunBlocksWhenImageHostFallbacksFail(t *testing.T) {
 	t.Parallel()
 
@@ -571,8 +961,16 @@ func TestBuildUploadDryRunBlocksWhenImageHostFallbacksFail(t *testing.T) {
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
 	images := &stubImageService{
@@ -582,7 +980,7 @@ func TestBuildUploadDryRunBlocksWhenImageHostFallbacksFail(t *testing.T) {
 	}
 	svc := NewServiceWithRegistryAndImages(config.Config{}, nil, repo, registry, images)
 
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"PTP"})
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"}, []string{"PTP"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -593,8 +991,11 @@ func TestBuildUploadDryRunBlocksWhenImageHostFallbacksFail(t *testing.T) {
 	if entry.Status != "blocked" {
 		t.Fatalf("expected blocked dry run, got %#v", entry)
 	}
-	if entry.ImageHost.Status != "warning" || len(entry.ImageHost.Warnings) != 1 {
-		t.Fatalf("expected image host warnings to be attached, got %#v", entry.ImageHost)
+	if entry.ImageHost.Status != "blocked" || len(entry.ImageHost.Warnings) != 1 {
+		t.Fatalf("expected blocked image host feedback, got %#v", entry.ImageHost)
+	}
+	if entry.ContentFailure == nil || entry.ContentFailure.Code != api.TrackerEligibilityDescriptionPreparationFailed {
+		t.Fatalf("expected structured description failure, got %#v", entry.ContentFailure)
 	}
 }
 
@@ -602,14 +1003,26 @@ func TestBuildPreparationBlocksWhenImageHostFallbacksFail(t *testing.T) {
 	t.Parallel()
 
 	registry := NewRegistry()
-	if err := registry.Register(stubPreparationDefinition{name: "PTP", group: "ptp", description: "saveable description"}); err != nil {
+	if err := registry.Register(stubPreparationDefinition{
+		name:        "PTP",
+		group:       "ptp",
+		description: "saveable description",
+	}); err != nil {
 		t.Fatalf("register stub: %v", err)
 	}
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
 	images := &stubImageService{
@@ -619,31 +1032,22 @@ func TestBuildPreparationBlocksWhenImageHostFallbacksFail(t *testing.T) {
 	}
 	svc := NewServiceWithRegistryAndImages(config.Config{}, nil, repo, registry, images)
 
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"PTP"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: "/tmp/source"}), []string{"PTP"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if len(preview.Descriptions) != 1 {
-		t.Fatalf("expected 1 blocked placeholder, got %d", len(preview.Descriptions))
-	}
-	entry := preview.Descriptions[0]
-	if entry.GroupKey != "ptp|blocked|image-host" {
-		t.Fatalf("expected blocked image-host group key, got %q", entry.GroupKey)
-	}
-	if got := strings.Join(entry.Trackers, ","); got != "PTP" {
-		t.Fatalf("expected PTP tracker to remain visible, got %q", got)
+	if len(preview.Descriptions) != 0 {
+		t.Fatalf("expected no saveable description, got %d", len(preview.Descriptions))
 	}
-	if entry.Description != "" || entry.RawDescription != "" || entry.DescriptionHTML != "" || entry.RawDescriptionHTML != "" {
-		t.Fatalf("expected no saveable prepared description, got %#v", entry)
+	if len(preview.ContentFailures) != 1 {
+		t.Fatalf("expected 1 structured content failure, got %#v", preview.ContentFailures)
 	}
-	if entry.ImageHost.Status != "blocked" {
-		t.Fatalf("expected blocked image host status, got %#v", entry.ImageHost)
+	failure := preview.ContentFailures[0]
+	if failure.Tracker != "PTP" || failure.Code != api.TrackerEligibilityDescriptionPreparationFailed {
+		t.Fatalf("expected PTP description failure, got %#v", failure)
 	}
-	if !strings.Contains(entry.ImageHost.Message, "could not upload screenshots") {
-		t.Fatalf("expected blocking image host message, got %q", entry.ImageHost.Message)
-	}
-	if len(entry.ImageHost.Warnings) != 1 || entry.ImageHost.Warnings[0].Host != "pixhost" {
-		t.Fatalf("expected pixhost failure warning, got %#v", entry.ImageHost.Warnings)
+	if !strings.Contains(failure.Message, "could not upload screenshots") {
+		t.Fatalf("expected blocking image host message, got %q", failure.Message)
 	}
 	if got := strings.Join(images.calls, ","); got != "pixhost" {
 		t.Fatalf("expected one preflight upload attempt, got %q", got)
@@ -654,7 +1058,11 @@ func TestBuildPreparationBlocksWhenUploadedImagesDoNotCoverRHDSlots(t *testing.T
 	t.Parallel()
 
 	registry := NewRegistry()
-	if err := registry.Register(stubPreparationDefinition{name: "RHD", group: "rhd", description: "saveable description"}); err != nil {
+	if err := registry.Register(stubPreparationDefinition{
+		name:        "RHD",
+		group:       "rhd",
+		description: "saveable description",
+	}); err != nil {
 		t.Fatalf("register stub: %v", err)
 	}
 
@@ -693,28 +1101,22 @@ func TestBuildPreparationBlocksWhenUploadedImagesDoNotCoverRHDSlots(t *testing.T
 	}
 	svc := NewServiceWithRegistryAndImages(cfg, nil, repo, registry, images)
 
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, []string{"RHD"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: sourcePath}), []string{"RHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if len(preview.Descriptions) != 1 {
-		t.Fatalf("expected 1 blocked placeholder, got %d", len(preview.Descriptions))
-	}
-	entry := preview.Descriptions[0]
-	if entry.GroupKey != "rhd|blocked|image-host" {
-		t.Fatalf("expected blocked image-host group key, got %q", entry.GroupKey)
+	if len(preview.Descriptions) != 0 {
+		t.Fatalf("expected no saveable description, got %d", len(preview.Descriptions))
 	}
-	if entry.Description != "" || entry.RawDescription != "" || entry.DescriptionHTML != "" || entry.RawDescriptionHTML != "" {
-		t.Fatalf("expected no saveable prepared description, got %#v", entry)
+	if len(preview.ContentFailures) != 1 {
+		t.Fatalf("expected 1 structured content failure, got %#v", preview.ContentFailures)
 	}
-	if entry.ImageHost.Status != "blocked" {
-		t.Fatalf("expected blocked image host status, got %#v", entry.ImageHost)
+	failure := preview.ContentFailures[0]
+	if failure.Tracker != "RHD" || failure.Code != api.TrackerEligibilityDescriptionPreparationFailed {
+		t.Fatalf("expected RHD description failure, got %#v", failure)
 	}
-	if !strings.Contains(entry.ImageHost.Message, "could not upload screenshots") {
-		t.Fatalf("expected blocking image host message, got %q", entry.ImageHost.Message)
-	}
-	if len(entry.ImageHost.Warnings) != 1 || !strings.Contains(entry.ImageHost.Warnings[0].Message, "missing screenshot variant for slot 0") {
-		t.Fatalf("expected slot coverage warning, got %#v", entry.ImageHost.Warnings)
+	if !strings.Contains(failure.Message, "missing screenshot variant for slot 0") {
+		t.Fatalf("expected slot coverage failure, got %#v", failure)
 	}
 	if got := strings.Join(images.calls, ","); got != "imgbb" {
 		t.Fatalf("expected one imgbb upload attempt, got %q", got)
@@ -730,7 +1132,7 @@ func TestBuildUploadDryRunIncludesRuleFailedTrackers(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/file",
 		TrackerRuleFailures: map[string][]api.RuleFailure{
 			"BLU": {{Rule: "require_movie_only", Reason: "movie only"}},
@@ -747,7 +1149,7 @@ func TestBuildUploadDryRunIncludesRuleFailedTrackers(t *testing.T) {
 	}
 }
 
-func TestBuildUploadDryRunNoBuilderMarkedUnsupported(t *testing.T) {
+func TestBuildUploadDryRunUsesRequiredPreparationContract(t *testing.T) {
 	t.Parallel()
 
 	registry := NewRegistry()
@@ -756,15 +1158,15 @@ func TestBuildUploadDryRunNoBuilderMarkedUnsupported(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"}, []string{"BLU"})
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"}, []string{"BLU"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	if len(entries) != 1 {
 		t.Fatalf("expected 1 entry, got %d", len(entries))
 	}
-	if entries[0].Status != "not_supported" {
-		t.Fatalf("expected not_supported status, got %q", entries[0].Status)
+	if entries[0].Status != "ready" {
+		t.Fatalf("expected ready status, got %q", entries[0].Status)
 	}
 }
 
@@ -773,8 +1175,16 @@ func TestBuildPreparationGroupsExactMatchingUnit3DDescriptions(t *testing.T) {
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "AITHER", group: "unit3d", description: "same description"},
-		stubPreparationDefinition{name: "HHD", group: "unit3d", description: "same description"},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "unit3d",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "HHD",
+			group:       "unit3d",
+			description: "same description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -782,7 +1192,7 @@ func TestBuildPreparationGroupsExactMatchingUnit3DDescriptions(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{}, []string{"AITHER", "HHD"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{}), []string{"AITHER", "HHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -803,8 +1213,16 @@ func TestBuildPreparationSplitsSameGroupWhenDescriptionDiffers(t *testing.T) {
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "AITHER", group: "unit3d", description: "aither description"},
-		stubPreparationDefinition{name: "HHD", group: "unit3d", description: "hhd description"},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "unit3d",
+			description: "aither description",
+		},
+		stubPreparationDefinition{
+			name:        "HHD",
+			group:       "unit3d",
+			description: "hhd description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -812,7 +1230,7 @@ func TestBuildPreparationSplitsSameGroupWhenDescriptionDiffers(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{}, []string{"AITHER", "HHD"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{}), []string{"AITHER", "HHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -835,7 +1253,7 @@ func TestBuildPreparationSplitsSameGroupWhenDescriptionDiffers(t *testing.T) {
 		t.Fatalf("expected stable HHD group key, got %q", preview.Descriptions[1].GroupKey)
 	}
 
-	reversed, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{}, []string{"HHD", "AITHER"})
+	reversed, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{}), []string{"HHD", "AITHER"})
 	if err != nil {
 		t.Fatalf("unexpected reversed error: %v", err)
 	}
@@ -858,8 +1276,16 @@ func TestBuildPreparationGroupsSameFinalDescriptionWhenExtractedDescriptionDiffe
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "AITHER", group: "unit3d", description: "same final description"},
-		stubPreparationDefinition{name: "BLU", group: "unit3d", description: "same final description"},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "unit3d",
+			description: "same final description",
+		},
+		stubPreparationDefinition{
+			name:        "BLU",
+			group:       "unit3d",
+			description: "same final description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -875,7 +1301,7 @@ func TestBuildPreparationGroupsSameFinalDescriptionWhenExtractedDescriptionDiffe
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, []string{"AITHER", "BLU"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: sourcePath}), []string{"AITHER", "BLU"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -895,8 +1321,16 @@ func TestBuildPreparationGroupsSameDescriptionWhenImageHostFeedbackDiffers(t *te
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "AITHER", group: "shared", description: "same description"},
-		stubPreparationDefinition{name: "PTP", group: "shared", description: "same description"},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "shared",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "PTP",
+			group:       "shared",
+			description: "same description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -904,7 +1338,7 @@ func TestBuildPreparationGroupsSameDescriptionWhenImageHostFeedbackDiffers(t *te
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{}, []string{"AITHER", "PTP"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{}), []string{"AITHER", "PTP"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -924,8 +1358,16 @@ func TestBuildPreparationGroupsUnit3DWhenImageHostMessageOnlyDiffers(t *testing.
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "AITHER", group: "unit3d", description: "same description"},
-		stubPreparationDefinition{name: "HHD", group: "unit3d", description: "same description"},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "unit3d",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "HHD",
+			group:       "unit3d",
+			description: "same description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -943,7 +1385,7 @@ func TestBuildPreparationGroupsUnit3DWhenImageHostMessageOnlyDiffers(t *testing.
 	repo := &stubRepo{}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 	sourcePath := filepath.Join(t.TempDir(), "source.mkv")
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, []string{"AITHER", "HHD"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: sourcePath}), []string{"AITHER", "HHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1047,7 +1489,7 @@ func TestBuildPreparationUnit3DGroupsOnConfiguredHostPreference(t *testing.T) {
 		},
 	}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: sourcePath}, []string{"HHD", "LUME", "RAS"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: sourcePath}), []string{"HHD", "LUME", "RAS"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1075,10 +1517,18 @@ func TestPreparationDescriptionGroupMergesUnit3DHostVariantsWhenDescriptionMatch
 		RawDescriptionHTML: "<p>raw</p>",
 		Description:        "same description",
 		DescriptionHTML:    "<p>same description</p>",
-		ImageHost:          api.ImageHostFeedback{Status: "reused", SelectedHost: "pixhost", AllowedHosts: []string{"pixhost"}},
+		ImageHost: api.ImageHostFeedback{
+			Status:       "reused",
+			SelectedHost: "pixhost",
+			AllowedHosts: []string{"pixhost"},
+		},
 	}
 	second := first
-	second.ImageHost = api.ImageHostFeedback{Status: "reused", SelectedHost: "imgbb", AllowedHosts: []string{"imgbb"}}
+	second.ImageHost = api.ImageHostFeedback{
+		Status:       "reused",
+		SelectedHost: "imgbb",
+		AllowedHosts: []string{"imgbb"},
+	}
 	second.RawDescriptionHTML = "<div>raw</div>"
 	second.DescriptionHTML = "<div>same description</div>"
 
@@ -1139,7 +1589,7 @@ func TestUploadAggregatesUploadedTorrentArtifacts(t *testing.T) {
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1169,8 +1619,16 @@ func TestUploadPreflightsMultipleConfiguredImageHostsOnce(t *testing.T) {
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
 	images := &stubImageService{repo: repo}
@@ -1185,7 +1643,7 @@ func TestUploadPreflightsMultipleConfiguredImageHostsOnce(t *testing.T) {
 	}
 	svc := NewServiceWithRegistryAndImages(cfg, nil, repo, registry, images)
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"})
 	if err != nil {
 		t.Fatalf("unexpected upload error: %v", err)
 	}
@@ -1198,7 +1656,7 @@ func TestUploadPreflightsMultipleConfiguredImageHostsOnce(t *testing.T) {
 		t.Fatalf("expected one upload per configured host, got %q", got)
 	}
 
-	summary, err = svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"})
+	summary, err = svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"})
 	if err != nil {
 		t.Fatalf("unexpected second upload error: %v", err)
 	}
@@ -1222,18 +1680,26 @@ func TestUploadPreflightsUnrestrictedTrackerToFirstConfiguredImageHost(t *testin
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
-	images := &blockingImageService{}
+	images := &blockingImageService{repo: repo}
 	cfg := config.Config{
 		ImageHosting: config.ImageHostingConfig{Host1: "imgbb", Host2: "pixhost"},
 		Trackers:     config.TrackersConfig{DefaultTrackers: config.CSVList{"RHD"}},
 	}
 	svc := NewServiceWithRegistryAndImages(cfg, nil, repo, registry, images)
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"})
 	if err != nil {
 		t.Fatalf("unexpected upload error: %v", err)
 	}
@@ -1254,12 +1720,20 @@ func TestUploadPreparesDistinctTrackerArtifactsBeforeConcurrentUploads(t *testin
 	torrentPath := filepath.Join(tmp, "release.torrent")
 	createServiceTestTorrent(t, filepath.Join(tmp, "source.bin"), torrentPath)
 
-	requests := make(chan UploadRequest, 2)
+	requests := make(chan PreparationInput, 2)
 	release := make(chan struct{})
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		trackingUploadDefinition{name: "HDB", requests: requests, release: release},
-		trackingUploadDefinition{name: "PTP", requests: requests, release: release},
+		trackingUploadDefinition{
+			name:     "HDB",
+			requests: requests,
+			release:  release,
+		},
+		trackingUploadDefinition{
+			name:     "PTP",
+			requests: requests,
+			release:  release,
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -1282,8 +1756,10 @@ func TestUploadPreparesDistinctTrackerArtifactsBeforeConcurrentUploads(t *testin
 		summary api.UploadSummary
 		err     error
 	}, 1)
+	progress := make(chan api.UploadProgressUpdate, 32)
+	uploadCtx := api.WithUploadProgressReporter(context.Background(), func(update api.UploadProgressUpdate) { progress <- update })
 	go func() {
-		summary, err := svc.Upload(context.Background(), api.PreparedMetadata{
+		summary, err := svc.Upload(uploadCtx, api.UploadSubject{
 			SourcePath:  sourcePath,
 			TorrentPath: torrentPath,
 		})
@@ -1293,14 +1769,19 @@ func TestUploadPreparesDistinctTrackerArtifactsBeforeConcurrentUploads(t *testin
 		}{summary: summary, err: err}
 	}()
 
-	received := make(map[string]UploadRequest, 2)
-	timeout := time.After(2 * time.Second)
+	received := make(map[string]PreparationInput, 2)
+	updates := make([]api.UploadProgressUpdate, 0)
+	timeout := time.After(10 * time.Second)
 	for len(received) < 2 {
 		select {
 		case req := <-requests:
 			received[req.Tracker] = req
+		case result := <-done:
+			t.Fatalf("upload returned before both submissions: summary=%#v err=%v received=%v", result.summary, result.err, received)
+		case update := <-progress:
+			updates = append(updates, update)
 		case <-timeout:
-			t.Fatalf("timed out waiting for upload requests, got %d", len(received))
+			t.Fatalf("timed out waiting for upload requests, got %d updates=%#v", len(received), updates)
 		}
 	}
 
@@ -1338,8 +1819,16 @@ func TestBuildPreparationPreflightsMultipleConfiguredImageHostsConcurrently(t *t
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 	}
 	started := make(chan string, 2)
@@ -1359,7 +1848,7 @@ func TestBuildPreparationPreflightsMultipleConfiguredImageHostsConcurrently(t *t
 
 	done := make(chan error, 1)
 	go func() {
-		_, err := svc.BuildPreparation(ctx, api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"PTP", "STC"})
+		_, err := svc.BuildPreparation(ctx, api.NewDescriptionSubject(api.UploadSubject{SourcePath: "/tmp/source"}), []string{"PTP", "STC"})
 		done <- err
 	}()
 
@@ -1390,31 +1879,6 @@ func TestBuildPreparationPreflightsMultipleConfiguredImageHostsConcurrently(t *t
 	}
 }
 
-func TestUploadIncludesRuleFailedTrackersWhenOverrideEnabled(t *testing.T) {
-	t.Parallel()
-
-	registry := NewRegistry()
-	if err := registry.Register(stubUploadArtifactDefinition{name: "AITHER"}); err != nil {
-		t.Fatalf("register stub: %v", err)
-	}
-
-	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}
-	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{
-		SourcePath:                "/tmp/file",
-		IgnoreTrackerRuleFailures: true,
-		TrackerRuleFailures: map[string][]api.RuleFailure{
-			"AITHER": {{Rule: "require_movie_only", Reason: "movie only"}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if summary.Uploaded != 1 {
-		t.Fatalf("expected 1 upload, got %d", summary.Uploaded)
-	}
-}
-
 func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 	t.Parallel()
 
@@ -1423,9 +1887,24 @@ func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 
 	registry := NewRegistry()
 	definitions := []Definition{
-		blockingUploadDefinition{name: "BLU", started: started, release: release, uploaded: 1},
-		blockingUploadDefinition{name: "BHD", started: started, release: release, uploaded: 1},
-		blockingUploadDefinition{name: "AITHER", started: started, release: release, uploaded: 1},
+		blockingUploadDefinition{
+			name:     "BLU",
+			started:  started,
+			release:  release,
+			uploaded: 1,
+		},
+		blockingUploadDefinition{
+			name:     "BHD",
+			started:  started,
+			release:  release,
+			uploaded: 1,
+		},
+		blockingUploadDefinition{
+			name:     "AITHER",
+			started:  started,
+			release:  release,
+			uploaded: 1,
+		},
 	}
 	for _, definition := range definitions {
 		if err := registry.Register(definition); err != nil {
@@ -1445,7 +1924,7 @@ func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 	}
 	resultCh := make(chan uploadResult, 1)
 	go func() {
-		summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+		summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 		resultCh <- uploadResult{summary: summary, err: err}
 	}()
 
@@ -1454,7 +1933,7 @@ func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 		select {
 		case tracker := <-started:
 			seen[tracker] = struct{}{}
-		case <-time.After(500 * time.Millisecond):
+		case <-time.After(10 * time.Second):
 			t.Fatalf("timed out waiting for initial tracker starts")
 		}
 	}
@@ -1465,14 +1944,14 @@ func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 	select {
 	case tracker := <-started:
 		t.Fatalf("expected third tracker to wait for worker slot, started early: %s", tracker)
-	case <-time.After(120 * time.Millisecond):
+	default:
 	}
 
 	close(release)
 
 	select {
 	case <-started:
-	case <-time.After(500 * time.Millisecond):
+	case <-time.After(10 * time.Second):
 		t.Fatalf("timed out waiting for third tracker to start")
 	}
 
@@ -1484,7 +1963,7 @@ func TestUploadRunsTrackersConcurrentlyWithLimit(t *testing.T) {
 		if result.summary.Uploaded != 3 {
 			t.Fatalf("expected 3 uploads, got %d", result.summary.Uploaded)
 		}
-	case <-time.After(2 * time.Second):
+	case <-time.After(10 * time.Second):
 		t.Fatalf("timed out waiting for upload result")
 	}
 }
@@ -1494,14 +1973,18 @@ func TestUploadReportsCancellationAfterCompletedTrackerUpload(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 	registry := NewRegistry()
-	if err := registry.Register(cancelAfterUploadDefinition{name: "AITHER", cancel: cancel, uploaded: 1}); err != nil {
+	if err := registry.Register(cancelAfterUploadDefinition{
+		name:     "AITHER",
+		cancel:   cancel,
+		uploaded: 1,
+	}); err != nil {
 		t.Fatalf("register AITHER: %v", err)
 	}
 
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation after upload, got %v", err)
 	}
@@ -1524,7 +2007,7 @@ func TestUploadCanceledBeforeStartReturnsZeroUpload(t *testing.T) {
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation, got %v", err)
 	}
@@ -1538,7 +2021,11 @@ func TestUploadCancellationKeepsCompletedTrackerOnly(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 	registry := NewRegistry()
-	if err := registry.Register(cancelAfterUploadDefinition{name: "AITHER", cancel: cancel, uploaded: 1}); err != nil {
+	if err := registry.Register(cancelAfterUploadDefinition{
+		name:     "AITHER",
+		cancel:   cancel,
+		uploaded: 1,
+	}); err != nil {
 		t.Fatalf("register AITHER: %v", err)
 	}
 	if err := registry.Register(blockingUploadDefinition{name: "BLU", uploaded: 1}); err != nil {
@@ -1552,7 +2039,7 @@ func TestUploadCancellationKeepsCompletedTrackerOnly(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation, got %v", err)
 	}
@@ -1582,7 +2069,11 @@ func TestUploadStatusFailureDoesNotCancelCompletedTracker(t *testing.T) {
 		cancel:   cancel,
 		uploaded: 1,
 		uploadedTorrents: []api.UploadedTorrent{
-			{Tracker: "AITHER", TorrentID: "1", DownloadURL: "https://aither.cc/torrent/download/1"},
+			{
+				Tracker:     "AITHER",
+				TorrentID:   "1",
+				DownloadURL: "https://aither.cc/torrent/download/1",
+			},
 		},
 	}); err != nil {
 		t.Fatalf("register AITHER: %v", err)
@@ -1598,7 +2089,7 @@ func TestUploadStatusFailureDoesNotCancelCompletedTracker(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation, got %v", err)
 	}
@@ -1641,7 +2132,11 @@ func TestUploadCancellationFinalizesPendingWithCleanupContext(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 	registry := NewRegistry()
-	if err := registry.Register(cancelAfterUploadDefinition{name: "AITHER", cancel: cancel, uploaded: 1}); err != nil {
+	if err := registry.Register(cancelAfterUploadDefinition{
+		name:     "AITHER",
+		cancel:   cancel,
+		uploaded: 1,
+	}); err != nil {
 		t.Fatalf("register AITHER: %v", err)
 	}
 	if err := registry.Register(blockingUploadDefinition{name: "BLU", uploaded: 1}); err != nil {
@@ -1655,7 +2150,7 @@ func TestUploadCancellationFinalizesPendingWithCleanupContext(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context cancellation, got %v", err)
 	}
@@ -1700,7 +2195,7 @@ func TestUploadLateCancellationUsesCleanupContextForStatusWrites(t *testing.T) {
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"AITHER"}}}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1746,7 +2241,7 @@ func TestUploadBestEffortWithFailures(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err == nil {
 		t.Fatal("expected failed tracker error for best-effort upload")
 	}
@@ -1779,7 +2274,7 @@ func TestUploadBestEffortWithFailuresAndRepoReturnsError(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err == nil {
 		t.Fatal("expected failed tracker error for best-effort upload")
 	}
@@ -1794,7 +2289,11 @@ func TestUploadBestEffortWithFailuresAndRepoReturnsError(t *testing.T) {
 	for _, update := range repo.statusUpdates {
 		finalStatus[update.tracker] = update.status
 	}
-	for tracker, wantStatus := range map[string]string{"BLU": "uploaded", "BHD": "failed", "AITHER": "uploaded"} {
+	for tracker, wantStatus := range map[string]string{
+		"BLU":    "uploaded",
+		"BHD":    "failed",
+		"AITHER": "uploaded",
+	} {
 		if finalStatus[tracker] != wantStatus {
 			t.Fatalf("expected %s status %q, got %q", tracker, wantStatus, finalStatus[tracker])
 		}
@@ -1829,7 +2328,7 @@ func TestUploadRetriesTransientUploadedStatusFailure(t *testing.T) {
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
 	ctx := context.Background()
-	summary, err := svc.Upload(ctx, api.PreparedMetadata{SourcePath: "/tmp/file"})
+	summary, err := svc.Upload(ctx, api.UploadSubject{SourcePath: "/tmp/file"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1870,7 +2369,7 @@ func TestUploadAllFailuresReturnsError(t *testing.T) {
 	}
 	svc := NewServiceWithRegistry(cfg, nil, nil, registry)
 
-	_, err := svc.Upload(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/file"})
+	_, err := svc.Upload(context.Background(), api.UploadSubject{SourcePath: "/tmp/file"})
 	if err == nil {
 		t.Fatalf("expected error when all trackers fail")
 	}
@@ -1881,8 +2380,16 @@ func TestBuildPreparationSeparatesScopedImageHostGroups(t *testing.T) {
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "HDB", group: "shared", description: "same description"},
-		stubPreparationDefinition{name: "AITHER", group: "shared", description: "same description"},
+		stubPreparationDefinition{
+			name:        "HDB",
+			group:       "shared",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "shared",
+			description: "same description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -1891,14 +2398,54 @@ func TestBuildPreparationSeparatesScopedImageHostGroups(t *testing.T) {
 
 	repo := &stubRepo{
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/a.png", RawURL: "https://hdb/a.png", WebURL: "https://hdb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://hdb/b.png", RawURL: "https://hdb/b.png", WebURL: "https://hdb/b"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/a.png",
+				RawURL:     "https://hdb/a.png",
+				WebURL:     "https://hdb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "hdb",
+				UsageScope: "tracker:HDB",
+				ImgURL:     "https://hdb/b.png",
+				RawURL:     "https://hdb/b.png",
+				WebURL:     "https://hdb/b",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
 	cfg := config.Config{
@@ -1910,7 +2457,7 @@ func TestBuildPreparationSeparatesScopedImageHostGroups(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"HDB", "AITHER"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: "/tmp/source"}), []string{"HDB", "AITHER"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -1936,7 +2483,7 @@ func TestBuildPreparationRehostsHDBScreenshotsForURLOnlySlots(t *testing.T) {
 			},
 		},
 	}
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath: `D:\TV\The.Pitt.S02E15.1080p.WEB-DL.mkv`,
 		Options:    api.UploadOptions{KeepImages: true},
 		TrackerData: []api.TrackerMetadata{{
@@ -1948,7 +2495,7 @@ func TestBuildPreparationRehostsHDBScreenshotsForURLOnlySlots(t *testing.T) {
 	if err != nil {
 		t.Fatalf("tmp root: %v", err)
 	}
-	tmpDir, _, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, _, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		t.Fatalf("release temp dir: %v", err)
 	}
@@ -1979,14 +2526,30 @@ func TestBuildPreparationRehostsHDBScreenshotsForURLOnlySlots(t *testing.T) {
 	images := &stubImageService{
 		uploads: map[string][]api.UploadedImageLink{
 			"hdb": {
-				{SourcePath: meta.SourcePath, ImagePath: firstPath, Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/51q8jo2.jpg", RawURL: "https://img.hdbits.org/51q8jo2.jpg", WebURL: "https://img.hdbits.org/51q8jo2"},
-				{SourcePath: meta.SourcePath, ImagePath: secondPath, Host: "hdb", UsageScope: "tracker:HDB", ImgURL: "https://t.hdbits.org/w0S7ltI.jpg", RawURL: "https://img.hdbits.org/w0S7ltI.jpg", WebURL: "https://img.hdbits.org/w0S7ltI"},
+				{
+					SourcePath: meta.SourcePath,
+					ImagePath:  firstPath,
+					Host:       "hdb",
+					UsageScope: "tracker:HDB",
+					ImgURL:     "https://t.hdbits.org/51q8jo2.jpg",
+					RawURL:     "https://img.hdbits.org/51q8jo2.jpg",
+					WebURL:     "https://img.hdbits.org/51q8jo2",
+				},
+				{
+					SourcePath: meta.SourcePath,
+					ImagePath:  secondPath,
+					Host:       "hdb",
+					UsageScope: "tracker:HDB",
+					ImgURL:     "https://t.hdbits.org/w0S7ltI.jpg",
+					RawURL:     "https://img.hdbits.org/w0S7ltI.jpg",
+					WebURL:     "https://img.hdbits.org/w0S7ltI",
+				},
 			},
 		},
 	}
 
 	svc := NewServiceWithRegistryAndImages(cfg, api.NopLogger{}, repo, registry, images)
-	preview, err := svc.BuildPreparation(context.Background(), meta, []string{"HDB"})
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(meta), []string{"HDB"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2010,9 +2573,21 @@ func TestBuildPreparationPreloadsDescriptionAssetQueriesOnce(t *testing.T) {
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "HDB", group: "hdb", description: "same description"},
-		stubPreparationDefinition{name: "AITHER", group: "aither", description: "same description"},
-		stubPreparationDefinition{name: "BHD", group: "bhd", description: "same description"},
+		stubPreparationDefinition{
+			name:        "HDB",
+			group:       "hdb",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "AITHER",
+			group:       "aither",
+			description: "same description",
+		},
+		stubPreparationDefinition{
+			name:        "BHD",
+			group:       "bhd",
+			description: "same description",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -2025,17 +2600,41 @@ func TestBuildPreparationPreloadsDescriptionAssetQueriesOnce(t *testing.T) {
 			ImageURLs: []string{"https://imgbb.com/a.png", "https://imgbb.com/b.png"},
 		}},
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
-	_, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"HDB", "AITHER", "BHD"})
+	_, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{SourcePath: "/tmp/source"}), []string{"HDB", "AITHER", "BHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2053,13 +2652,21 @@ func TestBuildPreparationPreloadsDescriptionAssetQueriesOnce(t *testing.T) {
 	}
 }
 
-func TestBuildPreparationSkipsBlockedTrackers(t *testing.T) {
+func TestBuildPreparationDoesNotImportUploadOutcomeBlocks(t *testing.T) {
 	t.Parallel()
 
 	registry := NewRegistry()
 	for _, definition := range []Definition{
-		stubPreparationDefinition{name: "HDB", group: "hdb", description: "hdb"},
-		stubPreparationDefinition{name: "BHD", group: "bhd", description: "bhd"},
+		stubPreparationDefinition{
+			name:        "HDB",
+			group:       "hdb",
+			description: "hdb",
+		},
+		stubPreparationDefinition{
+			name:        "BHD",
+			group:       "bhd",
+			description: "bhd",
+		},
 	} {
 		if err := registry.Register(definition); err != nil {
 			t.Fatalf("register stub: %v", err)
@@ -2067,20 +2674,20 @@ func TestBuildPreparationSkipsBlockedTrackers(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	preview, err := svc.BuildPreparation(context.Background(), api.PreparedMetadata{
+	preview, err := svc.BuildPreparation(context.Background(), api.NewDescriptionSubject(api.UploadSubject{
 		SourcePath: "/tmp/source",
 		BlockedTrackers: map[string][]api.TrackerBlockReason{
 			"HDB": {api.TrackerBlockReasonDupe},
 		},
-	}, []string{"HDB", "BHD"})
+	}),
+
+		[]string{"HDB", "BHD"})
+
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if len(preview.Descriptions) != 1 {
-		t.Fatalf("expected 1 description, got %d", len(preview.Descriptions))
-	}
-	if len(preview.Descriptions[0].Trackers) != 1 || preview.Descriptions[0].Trackers[0] != "BHD" {
-		t.Fatalf("expected only BHD in preparation preview, got %#v", preview.Descriptions[0].Trackers)
+	if len(preview.Descriptions) != 2 {
+		t.Fatalf("expected both description-owned tracker groups, got %d", len(preview.Descriptions))
 	}
 }
 
@@ -2098,7 +2705,7 @@ func TestBuildUploadDryRunIncludesBlockedTrackers(t *testing.T) {
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/source",
 		BlockedTrackers: map[string][]api.TrackerBlockReason{
 			"HDB": {api.TrackerBlockReasonDupe},
@@ -2119,12 +2726,12 @@ func TestBuildUploadDryRunAnnotatesBannedGroupWithoutBlockingPayload(t *testing.
 	t.Parallel()
 
 	registry := NewRegistry()
-	if err := registry.Register(stubDryRunDefinition{name: "ANT"}); err != nil {
+	if err := registry.Register(stubDryRunDefinition{name: "ANT", bannedGroups: []string{"AFG"}}); err != nil {
 		t.Fatalf("register stub: %v", err)
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/source",
 		Tag:        "-AFG",
 	}, []string{"ANT"})
@@ -2153,12 +2760,16 @@ func TestBuildUploadDryRunAnnotatesBannedGroupOnBuilderError(t *testing.T) {
 	t.Parallel()
 
 	registry := NewRegistry()
-	if err := registry.Register(stubDryRunDefinition{name: "ANT", dryRunErr: errors.New("build failed")}); err != nil {
+	if err := registry.Register(stubDryRunDefinition{
+		name:         "ANT",
+		dryRunErr:    errors.New("build failed"),
+		bannedGroups: []string{"AFG"},
+	}); err != nil {
 		t.Fatalf("register stub: %v", err)
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, nil, registry)
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/source",
 		Tag:        "-AFG",
 	}, []string{"ANT"})
@@ -2208,7 +2819,7 @@ func TestBuildUploadDryRunReportsBannedCheckErrorOnBuilderError(t *testing.T) {
 		t.Fatalf("write invalid banned cache: %v", err)
 	}
 
-	entries, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{
+	entries, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/source",
 		Tag:        "-ExampleGRP",
 	}, []string{"BLU"})
@@ -2248,7 +2859,7 @@ func TestUploadSkipsBlockedTrackersBeforePendingRecords(t *testing.T) {
 	cfg := config.Config{Trackers: config.TrackersConfig{DefaultTrackers: config.CSVList{"HDB", "AITHER"}}}
 	svc := NewServiceWithRegistry(cfg, nil, repo, registry)
 
-	summary, err := svc.Upload(context.Background(), api.PreparedMetadata{
+	summary, err := svc.Upload(context.Background(), api.UploadSubject{
 		SourcePath: "/tmp/source",
 		BlockedTrackers: map[string][]api.TrackerBlockReason{
 			"HDB": {api.TrackerBlockReasonDupe},
@@ -2294,17 +2905,41 @@ func TestBuildUploadDryRunPreloadsDescriptionAssetQueriesOnce(t *testing.T) {
 			ImageURLs: []string{"https://imgbb.com/a.png", "https://imgbb.com/b.png"},
 		}},
 		selections: []api.ScreenshotFinalSelection{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Order: 0},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Order: 1},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Order:      0,
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Order:      1,
+			},
 		},
 		uploads: []api.UploadedImageLink{
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/a.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/a.png", RawURL: "https://imgbb/a.png", WebURL: "https://imgbb/a"},
-			{SourcePath: "/tmp/source", ImagePath: "/tmp/b.png", Host: "imgbb", UsageScope: "global", ImgURL: "https://imgbb/b.png", RawURL: "https://imgbb/b.png", WebURL: "https://imgbb/b"},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/a.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/a.png",
+				RawURL:     "https://imgbb/a.png",
+				WebURL:     "https://imgbb/a",
+			},
+			{
+				SourcePath: "/tmp/source",
+				ImagePath:  "/tmp/b.png",
+				Host:       "imgbb",
+				UsageScope: "global",
+				ImgURL:     "https://imgbb/b.png",
+				RawURL:     "https://imgbb/b.png",
+				WebURL:     "https://imgbb/b",
+			},
 		},
 	}
 
 	svc := NewServiceWithRegistry(config.Config{}, nil, repo, registry)
-	_, err := svc.BuildUploadDryRun(context.Background(), api.PreparedMetadata{SourcePath: "/tmp/source"}, []string{"HDB", "AITHER", "BHD"})
+	_, err := svc.BuildUploadDryRun(context.Background(), api.UploadSubject{SourcePath: "/tmp/source"}, []string{"HDB", "AITHER", "BHD"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -2356,27 +2991,3 @@ func assertTrackerArtifact(t *testing.T, torrentPath string, wantAnnounce string
 		t.Fatalf("expected source %q, got %q", wantSource, info.Source)
 	}
 }
-
-func TestFilterTrackersByRuleFailuresExcludesModifiedReleaseAcrossFamilies(t *testing.T) {
-	t.Parallel()
-
-	failures := map[string][]api.RuleFailure{
-		"PTP": {{Rule: "modified_release", Reason: "source renamed from original release name"}},
-		"LST": {{Rule: "modified_release", Reason: "source renamed from original release name"}},
-		"HDB": {{Rule: "recommended_id", Reason: "recommended ID missing", Severity: api.RuleFailureSeverityWarning}},
-	}
-	trackers := []string{"PTP", "LST", "HDB"}
-
-	got := filterTrackersByRuleFailures(trackers, failures, false, nil)
-	if slices.Contains(got, "PTP") || slices.Contains(got, "LST") {
-		t.Fatalf("expected PTP and LST skipped for modified_release, got %v", got)
-	}
-	if !slices.Contains(got, "HDB") {
-		t.Fatalf("expected warning-only HDB retained, got %v", got)
-	}
-
-	// The override flag must let the user force-upload past the failure.
-	if got := filterTrackersByRuleFailures(trackers, failures, true, nil); !slices.Contains(got, "PTP") || !slices.Contains(got, "LST") {
-		t.Fatalf("expected ignore=true to retain all trackers, got %v", got)
-	}
-}
diff --git a/internal/trackers/service_upload_plan.go b/internal/trackers/service_upload_plan.go
new file mode 100644
index 00000000..56a31ddb
--- /dev/null
+++ b/internal/trackers/service_upload_plan.go
@@ -0,0 +1,501 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	internalerrors "github.com/autobrr/upbrr/internal/errors"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const defaultMaxConcurrentTrackerPreparations = 4
+
+// TrackerFailure is one normalized tracker-local preparation, record, or submission failure.
+type TrackerFailure struct {
+	// Tracker is the normalized tracker attributed to the failure.
+	Tracker string
+	// Code is the stable preparation, record, or submission failure class.
+	Code string
+	// Message contains sanitized operator-facing detail.
+	Message string
+	cause   error
+}
+
+// PartialUploadError reports tracker-local failures without discarding successful outcomes.
+type PartialUploadError struct{ failures []TrackerFailure }
+
+// Error returns a deterministic sanitized summary of tracker-local failures.
+func (e *PartialUploadError) Error() string {
+	if e == nil || len(e.failures) == 0 {
+		return "trackers: partial upload failure"
+	}
+	parts := make([]string, 0, len(e.failures))
+	for _, failure := range e.failures {
+		parts = append(parts, failure.Tracker+": "+failure.Message)
+	}
+	return "trackers: " + strings.Join(parts, "; ")
+}
+
+// Failures returns a defensive copy in resolved tracker order.
+func (e *PartialUploadError) Failures() []TrackerFailure {
+	if e == nil {
+		return nil
+	}
+	return append([]TrackerFailure(nil), e.failures...)
+}
+
+// TrackerLocalUploadFailures implements api.TrackerLocalUploadError without exposing private plan state.
+func (e *PartialUploadError) TrackerLocalUploadFailures() []string {
+	if e == nil {
+		return nil
+	}
+	trackers := make([]string, 0, len(e.failures))
+	for _, failure := range e.failures {
+		trackers = append(trackers, failure.Tracker)
+	}
+	return trackers
+}
+
+// Unwrap returns diagnostic causes for tracker failures that retained one.
+func (e *PartialUploadError) Unwrap() []error {
+	if e == nil {
+		return nil
+	}
+	causes := make([]error, 0, len(e.failures))
+	for _, failure := range e.failures {
+		if failure.cause != nil {
+			causes = append(causes, failure.cause)
+		}
+	}
+	return causes
+}
+
+// IsPartialUploadError reports whether err represents only tracker-local failures.
+func IsPartialUploadError(err error) bool {
+	var partial *PartialUploadError
+	return errors.As(err, &partial)
+}
+
+type trackerPlanSlot struct {
+	tracker                  string
+	plan                     TrackerPlan
+	failure                  *TrackerFailure
+	summary                  api.UploadSummary
+	canceledDuringSubmission bool
+}
+
+// Upload prepares every selected tracker, reaches a full barrier, then submits
+// ready plans concurrently. Tracker-local failures do not stop unrelated work
+// and return a partial summary with [PartialUploadError]; cancellation returns
+// completed uploads with the context error. Pending record finalization uses a
+// bounded context detached from caller cancellation.
+func (s *Service) Upload(ctx context.Context, meta api.UploadSubject) (api.UploadSummary, error) {
+	if err := ctx.Err(); err != nil {
+		return api.UploadSummary{}, fmt.Errorf("context canceled: %w", err)
+	}
+	if strings.TrimSpace(meta.SourcePath) == "" {
+		return api.UploadSummary{}, errors.New("trackers: prepared release source is missing")
+	}
+	resolved := resolveTrackers(s.cfg, meta.Trackers, meta.TrackersRemove)
+	if len(resolved) > 0 && s.registry == nil {
+		return api.UploadSummary{}, errors.New("trackers: registry not configured")
+	}
+	resolved = filterKnownTrackersWithRegistry(resolved, s.logger, s.registry)
+	resolved = filterTrackersByBlocks(resolved, meta.BlockedTrackers, s.logger)
+	if len(resolved) == 0 {
+		s.logger.Infof("trackers: no trackers configured, skipping upload")
+		return api.UploadSummary{}, nil
+	}
+	if baseTorrent, err := ResolveUploadTorrentPath(meta, s.cfg.MainSettings.DBPath); err == nil {
+		meta.TorrentPath = baseTorrent
+	} else if !isUploadTorrentNotFound(err) {
+		return api.UploadSummary{}, fmt.Errorf("trackers: shared upload torrent: %w", err)
+	}
+
+	preflight := s.preflightDescriptionImageHosts(ctx, meta, resolved)
+	banned := s.prepareBannedState(ctx, meta, resolved)
+	slots := s.prepareUploadPlans(ctx, meta, resolved, preflight, banned)
+	if err := ctx.Err(); err != nil {
+		s.releaseTrackerPlans(slots)
+		for idx := range slots {
+			emitTrackerPlanProgress(ctx, meta.SourcePath, slots[idx].tracker, "tracker_upload", "canceled", "Upload canceled before submission")
+		}
+		return summarizeTrackerPlanSlots(slots), fmt.Errorf("context canceled: %w", err)
+	}
+
+	s.createPendingRecords(ctx, meta, slots)
+	s.submitTrackerPlans(ctx, meta, slots)
+	s.releaseTrackerPlans(slots)
+
+	summary := summarizeTrackerPlanSlots(slots)
+	if err := ctx.Err(); err != nil && trackerPlansCanceled(slots) {
+		return summary, fmt.Errorf("context canceled: %w", err)
+	}
+	failures := trackerPlanFailures(slots)
+	if len(failures) > 0 {
+		return summary, &PartialUploadError{failures: failures}
+	}
+	return summary, nil
+}
+
+func (s *Service) prepareBannedState(ctx context.Context, meta api.UploadSubject, resolved []string) map[string]*TrackerFailure {
+	group := NormalizeBannedReleaseGroup(meta.Tag)
+	if group == "" || s.banned == nil {
+		return nil
+	}
+	failures := make(map[string]*TrackerFailure)
+	for _, tracker := range resolved {
+		if err := s.banned.RefreshDynamic(ctx, s.cfg, []string{tracker}, s.logger); err != nil {
+			failures[normalizeTrackerName(tracker)] = &TrackerFailure{
+				Tracker: tracker,
+				Code:    "banned_check",
+				Message: safeTrackerMessage(err),
+				cause:   err,
+			}
+			continue
+		}
+		isBanned, err := s.banned.IsBanned(tracker, group)
+		switch {
+		case err != nil:
+			failures[normalizeTrackerName(tracker)] = &TrackerFailure{
+				Tracker: tracker,
+				Code:    "banned_check",
+				Message: safeTrackerMessage(err),
+				cause:   err,
+			}
+		case isBanned:
+			failures[normalizeTrackerName(tracker)] = &TrackerFailure{
+				Tracker: tracker,
+				Code:    "banned_group",
+				Message: fmt.Sprintf("release group %s is banned", group),
+				cause:   internalerrors.ErrBannedGroup,
+			}
+		}
+	}
+	return failures
+}
+
+func (s *Service) prepareUploadPlans(
+	ctx context.Context,
+	meta api.UploadSubject,
+	resolved []string,
+	preflight imageHostPreflight,
+	banned map[string]*TrackerFailure,
+) []trackerPlanSlot {
+	slots := make([]trackerPlanSlot, len(resolved))
+	workerCount := min(defaultMaxConcurrentTrackerPreparations, len(resolved))
+	jobs := make(chan int)
+	var wg sync.WaitGroup
+	worker := func() {
+		defer wg.Done()
+		for idx := range jobs {
+			tracker := resolved[idx]
+			slot := trackerPlanSlot{tracker: tracker}
+			emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "running", "Preparing tracker plan")
+			if failure := banned[normalizeTrackerName(tracker)]; failure != nil {
+				slot.failure = failure
+				slots[idx] = slot
+				emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "failed", failure.Message)
+				continue
+			}
+			if err := ctx.Err(); err != nil {
+				slot.failure = trackerFailure(tracker, "canceled", err)
+				slots[idx] = slot
+				continue
+			}
+			definition, ok := s.registry.Lookup(tracker)
+			if !ok {
+				slot.failure = trackerFailure(tracker, "not_implemented", internalerrors.ErrNotImplemented)
+				slots[idx] = slot
+				continue
+			}
+			trackerCfg := applyTrackerConfigOverrides(trackerConfigFor(s.cfg, tracker), meta.TrackerConfigOverrides)
+			trackerMeta, err := PrepareTrackerUploadTorrentWithRegistry(meta, s.cfg.MainSettings.DBPath, tracker, trackerCfg, s.registry)
+			if err != nil {
+				slot.failure = trackerFailure(tracker, "artifact", err)
+				slots[idx] = slot
+				emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "failed", slot.failure.Message)
+				continue
+			}
+			content := s.prepareUploadContent(ctx, tracker, trackerMeta, trackerCfg, nil, preflight)
+			if content.State == preparedUploadContentFailed {
+				slot.failure = &TrackerFailure{
+					Tracker: tracker,
+					Code:    string(content.Failure.Code),
+					Message: content.Failure.Message,
+				}
+				slots[idx] = slot
+				emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "failed", slot.failure.Message)
+				continue
+			}
+			plan, failure := definition.Prepare(ctx, s.preparationInput(ctx, PreparationIntentUpload, tracker, trackerMeta, trackerCfg, content.Assets))
+			if failure != nil {
+				slot.failure = &TrackerFailure{
+					Tracker: tracker,
+					Code:    failure.Code(),
+					Message: safeTrackerMessage(failure),
+					cause:   failure,
+				}
+				slots[idx] = slot
+				emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "failed", slot.failure.Message)
+				continue
+			}
+			slot.plan = plan
+			slots[idx] = slot
+			emitTrackerPlanProgress(ctx, meta.SourcePath, tracker, "tracker_preparation", "completed", "Tracker plan ready")
+		}
+	}
+	for range workerCount {
+		wg.Add(1)
+		go worker()
+	}
+	next := 0
+enqueue:
+	for ; next < len(resolved); next++ {
+		select {
+		case jobs <- next:
+		case <-ctx.Done():
+			break enqueue
+		}
+	}
+	close(jobs)
+	wg.Wait()
+	for ; next < len(resolved); next++ {
+		slots[next] = trackerPlanSlot{
+			tracker: resolved[next],
+			failure: trackerFailure(resolved[next], "canceled", ctx.Err()),
+		}
+	}
+	return slots
+}
+
+func (s *Service) preparationInput(
+	ctx context.Context,
+	intent PreparationIntent,
+	tracker string,
+	meta api.UploadSubject,
+	trackerCfg config.TrackerConfig,
+	assets *DescriptionAssets,
+) PreparationInput {
+	logger := logging.FromContext(ctx, s.logger)
+	input := PreparationInput{
+		Intent:        intent,
+		Tracker:       tracker,
+		Meta:          meta,
+		TrackerConfig: trackerCfg,
+		Runtime: PreparationRuntime{
+			DBPath:      s.cfg.MainSettings.DBPath,
+			Description: s.cfg.Description,
+			Internal:    IsInternalGroup(s.cfg, tracker, meta),
+			BTNAPIToken: config.ResolveBTNAPIToken(s.cfg),
+		},
+		Logger: logger,
+		Assets: assets,
+	}
+	selectedHost, err := PreferredImageUploadHostWithRegistry(s.registry, tracker, trackerCfg, meta.ImageHostOverrides)
+	if err != nil {
+		logger.Warnf("trackers: image upload target failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
+		return input
+	}
+	input.SelectedImageHost = strings.ToLower(strings.TrimSpace(selectedHost))
+	if s.images != nil && input.SelectedImageHost != "" {
+		host := input.SelectedImageHost
+		input.UploadImages = func(ctx context.Context, images []api.ScreenshotImage) ([]api.UploadedImageLink, error) {
+			return s.images.Upload(ctx, imageHostingSubject(meta), host, usageScopeForHost(s.registry, host), append([]api.ScreenshotImage(nil), images...))
+		}
+	}
+	return input
+}
+
+func (s *Service) createPendingRecords(ctx context.Context, meta api.UploadSubject, slots []trackerPlanSlot) {
+	if s.repo == nil {
+		return
+	}
+	for idx := range slots {
+		slot := &slots[idx]
+		if slot.failure != nil || slot.plan.Intent() != PreparationIntentUpload {
+			continue
+		}
+		status := "pending"
+		if IsInternalGroup(s.cfg, slot.tracker, meta) {
+			status = "pending-internal"
+		}
+		if err := s.repo.CreateUploadRecord(ctx, api.UploadRecord{
+			Tracker:    slot.tracker,
+			Status:     status,
+			CreatedAt:  time.Now().UTC(),
+			SourcePath: meta.SourcePath,
+		}); err != nil {
+			slot.failure = trackerFailure(slot.tracker, "record", err)
+			if releaseErr := slot.plan.Release(); releaseErr != nil {
+				s.warnPlanRelease(slot.tracker, releaseErr)
+			}
+			emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "failed", slot.failure.Message)
+			continue
+		}
+	}
+}
+
+func (s *Service) submitTrackerPlans(ctx context.Context, meta api.UploadSubject, slots []trackerPlanSlot) {
+	ready := make([]int, 0, len(slots))
+	for idx := range slots {
+		if slots[idx].failure == nil && slots[idx].plan.Intent() == PreparationIntentUpload {
+			ready = append(ready, idx)
+		}
+	}
+	workerCount := s.maxConcurrentTrackerUploads(len(ready))
+	if workerCount == 0 {
+		return
+	}
+	jobs := make(chan int)
+	var wg sync.WaitGroup
+	worker := func() {
+		defer wg.Done()
+		for idx := range jobs {
+			slot := &slots[idx]
+			if err := ctx.Err(); err != nil {
+				slot.failure = trackerFailure(slot.tracker, "canceled", err)
+				s.updateUploadRecord(ctx, meta.SourcePath, slot.tracker, "canceled")
+				emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "canceled", "Upload canceled")
+				if releaseErr := slot.plan.Release(); releaseErr != nil {
+					s.warnPlanRelease(slot.tracker, releaseErr)
+				}
+				continue
+			}
+			emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "running", "Uploading to tracker")
+			summary, err := slot.plan.Submit(ctx)
+			slot.canceledDuringSubmission = ctx.Err() != nil
+			if err != nil {
+				slot.failure = trackerFailure(slot.tracker, "submit", err)
+				s.updateUploadRecord(ctx, meta.SourcePath, slot.tracker, "failed")
+				emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "failed", slot.failure.Message)
+			} else {
+				slot.summary = summary
+				s.updateUploadRecord(ctx, meta.SourcePath, slot.tracker, "uploaded")
+				emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "completed", "Tracker upload complete")
+			}
+			if releaseErr := slot.plan.Release(); releaseErr != nil {
+				s.warnPlanRelease(slot.tracker, releaseErr)
+			}
+		}
+	}
+	for range workerCount {
+		wg.Add(1)
+		go worker()
+	}
+	next := 0
+enqueue:
+	for ; next < len(ready); next++ {
+		select {
+		case jobs <- ready[next]:
+		case <-ctx.Done():
+			break enqueue
+		}
+	}
+	close(jobs)
+	wg.Wait()
+	for ; next < len(ready); next++ {
+		slot := &slots[ready[next]]
+		slot.failure = trackerFailure(slot.tracker, "canceled", ctx.Err())
+		s.updateUploadRecord(ctx, meta.SourcePath, slot.tracker, "canceled")
+		emitTrackerPlanProgress(ctx, meta.SourcePath, slot.tracker, "tracker_upload", "canceled", "Upload canceled")
+	}
+}
+
+func (s *Service) releaseTrackerPlans(slots []trackerPlanSlot) {
+	for idx := range slots {
+		if err := slots[idx].plan.Release(); err != nil {
+			s.warnPlanRelease(slots[idx].tracker, err)
+		}
+	}
+}
+
+func (s *Service) updateUploadRecord(parent context.Context, sourcePath string, tracker string, status string) {
+	if s.repo == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.WithoutCancel(parent), uploadRecordFinalizationTimeout)
+	defer cancel()
+	err := s.repo.UpdateLatestUploadRecordStatus(ctx, sourcePath, tracker, status)
+	if err != nil && ctx.Err() == nil {
+		err = s.repo.UpdateLatestUploadRecordStatus(ctx, sourcePath, tracker, status)
+	}
+	if err != nil {
+		s.logger.Warnf("trackers: status update failed tracker=%s status=%s err=%s", tracker, status, redaction.RedactValue(err.Error(), nil))
+	}
+}
+
+func (s *Service) warnPlanRelease(tracker string, err error) {
+	s.logger.Warnf("trackers: plan release failed tracker=%s err=%s", tracker, redaction.RedactValue(err.Error(), nil))
+}
+
+func summarizeTrackerPlanSlots(slots []trackerPlanSlot) api.UploadSummary {
+	summary := api.UploadSummary{}
+	for _, slot := range slots {
+		summary.Uploaded += slot.summary.Uploaded
+		summary.UploadedTorrents = append(summary.UploadedTorrents, slot.summary.UploadedTorrents...)
+	}
+	return summary
+}
+
+func trackerPlanFailures(slots []trackerPlanSlot) []TrackerFailure {
+	failures := make([]TrackerFailure, 0)
+	for _, slot := range slots {
+		if slot.failure != nil && slot.failure.Code != "canceled" {
+			failures = append(failures, *slot.failure)
+		}
+	}
+	return failures
+}
+
+func trackerFailure(tracker string, code string, err error) *TrackerFailure {
+	return &TrackerFailure{
+		Tracker: tracker,
+		Code:    code,
+		Message: safeTrackerMessage(err),
+		cause:   err,
+	}
+}
+
+func trackerPlansCanceled(slots []trackerPlanSlot) bool {
+	for _, slot := range slots {
+		if slot.canceledDuringSubmission || slot.failure != nil && slot.failure.Code == "canceled" {
+			return true
+		}
+	}
+	return false
+}
+
+func safeTrackerMessage(err error) string {
+	if err == nil {
+		return "tracker operation failed"
+	}
+	message := strings.TrimSpace(redaction.RedactValue(err.Error(), nil))
+	if message == "" {
+		return "tracker operation failed"
+	}
+	return message
+}
+
+func normalizeTrackerName(tracker string) string { return strings.ToUpper(strings.TrimSpace(tracker)) }
+
+func emitTrackerPlanProgress(ctx context.Context, sourcePath string, tracker string, task string, status string, message string) {
+	api.EmitUploadProgress(ctx, api.UploadProgressUpdate{
+		SourcePath: sourcePath,
+		Tracker:    tracker,
+		Task:       task,
+		Status:     status,
+		Message:    message,
+		Timestamp:  time.Now().UTC().Format(time.RFC3339Nano),
+	})
+}
diff --git a/internal/trackers/unit3dmeta/metadata.go b/internal/trackers/unit3dmeta/metadata.go
deleted file mode 100644
index 69eaa8d2..00000000
--- a/internal/trackers/unit3dmeta/metadata.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package unit3dmeta
-
-import (
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/logging"
-)
-
-var (
-	trackerBaseURLs = map[string]string{}
-	initOnce        sync.Once
-)
-
-func initTrackers() {
-	initOnce.Do(func() {
-		cfg, err := config.LoadEmbeddedDefaultConfig()
-		if err != nil || cfg == nil || len(cfg.Trackers.Trackers) == 0 {
-			message := "no trackers configured"
-			if err != nil {
-				message = err.Error()
-			}
-			_, _ = fmt.Fprintf(os.Stderr, "unit3dmeta: error loading embedded default config: %s\n", logging.SanitizeMessage(message))
-			return
-		}
-
-		unit3DTrackers := []string{
-			"A4K", "ACM", "AITHER", "BLU", "CBR", "DP", "EMUW",
-			"FRIKI", "HHD", "IHD", "ITT", "LCD", "LDU", "LST", "LT",
-			"LUME", "MNS", "OE", "OTW", "PT", "PTT", "R4E", "RAS", "RF", "RHD",
-			"SAM", "SHRI", "SP", "STC", "TIK", "TLZ", "TOS", "TTR",
-			"ULCX", "UTP", "YUS", "ZNTH",
-		}
-
-		for _, name := range unit3DTrackers {
-			if trackerCfg, ok := cfg.Trackers.Trackers[name]; ok {
-				if strings.TrimSpace(trackerCfg.URL) != "" {
-					trackerBaseURLs[name] = trackerCfg.URL
-				}
-			}
-		}
-	})
-}
-
-func DefaultTracker() string {
-	return "AITHER"
-}
-
-func Trackers() []string {
-	initTrackers()
-	trackers := make([]string, 0, len(trackerBaseURLs))
-	for tracker := range trackerBaseURLs {
-		trackers = append(trackers, tracker)
-	}
-	sort.Strings(trackers)
-	return trackers
-}
-
-func BaseURL(tracker string) (string, bool) {
-	initTrackers()
-	key := strings.ToUpper(strings.TrimSpace(tracker))
-	if key == "" {
-		return "", false
-	}
-	baseURL, ok := trackerBaseURLs[key]
-	return baseURL, ok
-}
-
-func IsKnown(tracker string) bool {
-	_, ok := BaseURL(tracker)
-	return ok
-}
diff --git a/internal/trackers/upload_artifact.go b/internal/trackers/upload_artifact.go
index 31a81bc7..0680a6fa 100644
--- a/internal/trackers/upload_artifact.go
+++ b/internal/trackers/upload_artifact.go
@@ -14,57 +14,29 @@ import (
 	"github.com/anacrolix/torrent/metainfo"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/paths"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/torrentmeta"
+	torrentmeta "github.com/autobrr/upbrr/internal/torrent/metainfo"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-// trackerUploadTorrentSpec describes how tracker upload torrents are
-// personalized before injection or upload review. requireAnnounce keeps
-// source-only specs inactive until the user configured a personal announce URL.
-type trackerUploadTorrentSpec struct {
-	source          string
-	defaultAnnounce string
-	useMyAnnounce   bool
-	requireAnnounce bool
+// PrepareTrackerUploadTorrent prepares tracker-specific torrent metainfo using the default registry.
+func PrepareTrackerUploadTorrent(meta api.UploadSubject, dbPath string, tracker string, trackerConfig config.TrackerConfig) (api.UploadSubject, error) {
+	return PrepareTrackerUploadTorrentWithRegistry(meta, dbPath, tracker, trackerConfig, nil)
 }
 
-var trackerUploadTorrentSpecs = map[string]trackerUploadTorrentSpec{
-	"ACM":   {source: "AsianCinema"},
-	"ANT":   {source: "ANT"},
-	"AR":    {source: "AlphaRatio"},
-	"ASC":   {source: "ASC"},
-	"AZ":    {source: "AvistaZ", defaultAnnounce: "https://tracker.avistaz.to/announce"},
-	"BHD":   {source: "BHD"},
-	"BHDTV": {source: "BIT-HDTV", useMyAnnounce: true},
-	"BJS":   {source: "BJ"},
-	"BT":    {source: "BT"},
-	"BTN":   {source: "BTN", requireAnnounce: true},
-	"CZ":    {source: "CinemaZ", defaultAnnounce: "https://tracker.cinemaz.to/announce"},
-	"CZT":   {source: "CzT"},
-	"DC":    {source: "DigitalCore.club"},
-	"FF":    {source: "FunFile"},
-	"FL":    {source: "FL"},
-	"GPW":   {source: "GreatPosterWall"},
-	"HDB":   {source: "HDBits"},
-	"HDS":   {source: "HD-Space"},
-	"HDT":   {source: "hd-torrents.org"},
-	"IS":    {source: "https://immortalseed.me"},
-	"MTV":   {source: "MTV"},
-	"NBL":   {source: "NBL"},
-	"PHD":   {source: "PrivateHD", defaultAnnounce: "https://tracker.privatehd.to/announce"},
-	"PTP":   {source: "PTP"},
-	"PTS":   {source: "[www.ptskit.org] PTSKIT"},
-	"RTF":   {source: "sunshine"},
-	"THR":   {source: "[https://www.torrenthr.org] TorrentHR.org"},
-	"TL":    {source: "TorrentLeech.org"},
-	"TOS":   {source: "TheOldSchool"},
-	"TVC":   {source: "TVCHAOS"},
-}
-
-func PrepareTrackerUploadTorrent(meta api.PreparedMetadata, dbPath string, tracker string, trackerConfig config.TrackerConfig) (api.PreparedMetadata, error) {
-	source, announce, ok := trackerUploadTorrentFields(tracker, trackerConfig)
+// PrepareTrackerUploadTorrentWithRegistry writes a release-scoped personalized
+// torrent and returns a copied subject pointing at it. Missing policy, base
+// torrent, or insufficient path context leaves the input unchanged; other
+// artifact failures are returned.
+func PrepareTrackerUploadTorrentWithRegistry(
+	meta api.UploadSubject,
+	dbPath string,
+	tracker string,
+	trackerConfig config.TrackerConfig,
+	registry *Registry,
+) (api.UploadSubject, error) {
+	source, announce, ok := trackerUploadTorrentFieldsWithRegistry(tracker, trackerConfig, registry)
 	if !ok {
 		return meta, nil
 	}
@@ -74,24 +46,58 @@ func PrepareTrackerUploadTorrent(meta api.PreparedMetadata, dbPath string, track
 		if isUploadTorrentNotFound(err) {
 			return meta, nil
 		}
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	artifactPath, err := ResolveTrackerTorrentArtifactPath(meta, dbPath, tracker)
 	if err != nil {
 		if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
 			return meta, nil
 		}
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	if err := WritePersonalizedTorrent(basePath, artifactPath, announce, "", source); err != nil {
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	meta.TorrentPath = artifactPath
 	return meta, nil
 }
 
-func PrepareDryRunInjectionTorrent(meta api.PreparedMetadata, dbPath string, tracker string, trackerConfig config.TrackerConfig) (api.PreparedMetadata, error) {
-	source, announce, ok := trackerUploadTorrentFields(tracker, trackerConfig)
+func trackerUploadTorrentFieldsWithRegistry(tracker string, trackerConfig config.TrackerConfig, registry *Registry) (string, string, bool) {
+	if owned, ok := registry.LookupUploadArtifactPolicy(tracker); ok {
+		return uploadArtifactFields(owned, trackerConfig)
+	}
+	return trackerUploadTorrentFields(tracker, trackerConfig)
+}
+
+func uploadArtifactFields(policy UploadArtifactPolicy, trackerConfig config.TrackerConfig) (string, string, bool) {
+	announce := strings.TrimSpace(trackerConfig.AnnounceURL)
+	if policy.UseMyAnnounce {
+		announce = strings.TrimSpace(trackerConfig.MyAnnounceURL)
+	}
+	if announce == "" {
+		announce = policy.DefaultAnnounce
+	}
+	if policy.RequireAnnounce && announce == "" {
+		return "", "", false
+	}
+	source := strings.TrimSpace(policy.Source)
+	return source, announce, source != "" || announce != ""
+}
+
+// PrepareDryRunInjectionTorrent prepares a dry-run torrent artifact using the default registry.
+func PrepareDryRunInjectionTorrent(meta api.UploadSubject, dbPath string, tracker string, trackerConfig config.TrackerConfig) (api.UploadSubject, error) {
+	return PrepareDryRunInjectionTorrentWithRegistry(meta, dbPath, tracker, trackerConfig, nil)
+}
+
+// PrepareDryRunInjectionTorrentWithRegistry prepares a dry-run torrent artifact using registry policy.
+func PrepareDryRunInjectionTorrentWithRegistry(
+	meta api.UploadSubject,
+	dbPath string,
+	tracker string,
+	trackerConfig config.TrackerConfig,
+	registry *Registry,
+) (api.UploadSubject, error) {
+	source, announce, ok := trackerUploadTorrentFieldsWithRegistry(tracker, trackerConfig, registry)
 	if !ok {
 		source = strings.ToUpper(strings.TrimSpace(tracker))
 		announce = strings.TrimSpace(trackerConfig.AnnounceURL)
@@ -108,17 +114,17 @@ func PrepareDryRunInjectionTorrent(meta api.PreparedMetadata, dbPath string, tra
 		if isUploadTorrentNotFound(err) {
 			return meta, nil
 		}
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	artifactPath, err := ResolveTrackerTorrentArtifactPath(meta, dbPath, tracker)
 	if err != nil {
 		if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
 			return meta, nil
 		}
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	if err := WritePersonalizedTorrent(basePath, artifactPath, announce, "", source); err != nil {
-		return api.PreparedMetadata{}, err
+		return api.UploadSubject{}, err
 	}
 	meta.TorrentPath = artifactPath
 	return meta, nil
@@ -126,28 +132,19 @@ func PrepareDryRunInjectionTorrent(meta api.PreparedMetadata, dbPath string, tra
 
 func trackerUploadTorrentFields(tracker string, trackerConfig config.TrackerConfig) (string, string, bool) {
 	name := strings.ToUpper(strings.TrimSpace(tracker))
-	spec, ok := trackerUploadTorrentSpecs[name]
-	if !ok {
-		return "", "", false
-	}
 	announce := strings.TrimSpace(trackerConfig.AnnounceURL)
-	if spec.useMyAnnounce {
-		announce = strings.TrimSpace(trackerConfig.MyAnnounceURL)
-	}
 	if announce == "" {
-		announce = spec.defaultAnnounce
-	}
-	if spec.requireAnnounce && announce == "" {
-		return "", "", false
+		announce = strings.TrimSpace(trackerConfig.MyAnnounceURL)
 	}
-	source := strings.TrimSpace(spec.source)
+	source := name
 	if source == "" && announce == "" {
 		return "", "", false
 	}
-	return source, announce, true
+	return source, announce, source != "" || announce != ""
 }
 
-func ResolveTrackerTorrentArtifactPath(meta api.PreparedMetadata, dbPath string, tracker string) (string, error) {
+// ResolveTrackerTorrentArtifactPath returns the local torrent artifact path for tracker.
+func ResolveTrackerTorrentArtifactPath(meta api.UploadSubject, dbPath string, tracker string) (string, error) {
 	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
 		return "", errors.New("trackers: tracker torrent path requires db path and source path")
 	}
@@ -156,7 +153,7 @@ func ResolveTrackerTorrentArtifactPath(meta api.PreparedMetadata, dbPath string,
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", fmt.Errorf("trackers: %w", err)
 	}
@@ -169,7 +166,11 @@ func ResolveTrackerTorrentArtifactPath(meta api.PreparedMetadata, dbPath string,
 	return filepath.Join(tmpDir, "["+name+"]."+base+".torrent"), nil
 }
 
-func ResolveUploadTorrentPath(meta api.PreparedMetadata, dbPath string) (string, error) {
+// ResolveUploadTorrentPath selects TorrentPath, ClientTorrentPath, SourcePath,
+// then the release-scoped default. A non-default candidate is copied to the
+// release-scoped path with tracker fields removed when it can be decoded; an
+// existing candidate already at that path is returned as-is.
+func ResolveUploadTorrentPath(meta api.UploadSubject, dbPath string) (string, error) {
 	cleanPath, cleanPathOK := uploadTorrentCleanPath(meta, dbPath)
 	candidates := []string{
 		strings.TrimSpace(meta.TorrentPath),
@@ -182,6 +183,9 @@ func ResolveUploadTorrentPath(meta api.PreparedMetadata, dbPath string) (string,
 		}
 		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
 			if cleanPathOK {
+				if strings.EqualFold(filepath.Clean(candidate), filepath.Clean(cleanPath)) {
+					return cleanPath, nil
+				}
 				err := WriteUploadTorrent(candidate, cleanPath)
 				if err == nil {
 					return cleanPath, nil
@@ -197,7 +201,7 @@ func ResolveUploadTorrentPath(meta api.PreparedMetadata, dbPath string) (string,
 	if strings.TrimSpace(dbPath) != "" && strings.TrimSpace(meta.SourcePath) != "" {
 		tmpRoot, err := db.Subdir(dbPath, "tmp")
 		if err == nil {
-			tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+			tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 			if err == nil {
 				guessed := filepath.Join(tmpDir, base+".torrent")
 				if info, err := os.Stat(guessed); err == nil && !info.IsDir() {
@@ -213,7 +217,7 @@ func ResolveUploadTorrentPath(meta api.PreparedMetadata, dbPath string) (string,
 	return "", fmt.Errorf("trackers: %w", errUploadTorrentNotFound)
 }
 
-func uploadTorrentCleanPath(meta api.PreparedMetadata, dbPath string) (string, bool) {
+func uploadTorrentCleanPath(meta api.UploadSubject, dbPath string) (string, bool) {
 	if strings.TrimSpace(dbPath) == "" || strings.TrimSpace(meta.SourcePath) == "" {
 		return "", false
 	}
@@ -221,7 +225,7 @@ func uploadTorrentCleanPath(meta api.PreparedMetadata, dbPath string) (string, b
 	if err != nil {
 		return "", false
 	}
-	tmpDir, base, err := paths.ReleaseTempDir(tmpRoot, meta, meta.SourcePath)
+	tmpDir, base, err := paths.ReleaseTempDirFor(tmpRoot, meta.SourcePath, meta.Release)
 	if err != nil {
 		return "", false
 	}
@@ -239,6 +243,9 @@ func isUploadTorrentNotFound(err error) bool {
 	return errors.Is(err, errUploadTorrentNotFound)
 }
 
+// WriteUploadTorrent validates sourcePath, removes announce, node, URL-list, and
+// source fields, applies canonical creator/comment values, and atomically writes
+// outputPath with mode 0600.
 func WriteUploadTorrent(sourcePath string, outputPath string) error {
 	torrentMeta, err := metainfo.LoadFromFile(sourcePath)
 	if err != nil {
@@ -251,6 +258,9 @@ func WriteUploadTorrent(sourcePath string, outputPath string) error {
 	return writeTorrentMeta(*torrentMeta, outputPath, "upload torrent")
 }
 
+// WritePersonalizedTorrent strips inherited tracker fields, applies the supplied
+// announce, comment, and source values plus the canonical creator, and atomically
+// writes outputPath with mode 0600.
 func WritePersonalizedTorrent(sourcePath string, outputPath string, announceURL string, comment string, source string) error {
 	torrentMeta, err := metainfo.LoadFromFile(sourcePath)
 	if err != nil {
diff --git a/internal/trackers/upload_artifact_test.go b/internal/trackers/upload_artifact_test.go
index 1d3ada8e..3d6005fb 100644
--- a/internal/trackers/upload_artifact_test.go
+++ b/internal/trackers/upload_artifact_test.go
@@ -39,7 +39,7 @@ func TestResolveUploadTorrentPathWritesCleanBaseCopy(t *testing.T) {
 		InfoBytes:    testInfoBytes(t, "BHD"),
 	})
 
-	got, err := ResolveUploadTorrentPath(api.PreparedMetadata{
+	got, err := ResolveUploadTorrentPath(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: dirtyTorrentPath,
 	}, filepath.Join(tmp, "state", "upbrr.db"))
@@ -95,7 +95,7 @@ func TestResolveUploadTorrentPathSamePathRewriteFailurePreservesGuessedTorrent(t
 		t.Fatalf("write source: %v", err)
 	}
 	dbPath := filepath.Join(tmp, "state", "upbrr.db")
-	meta := api.PreparedMetadata{SourcePath: sourcePath}
+	meta := api.UploadSubject{SourcePath: sourcePath}
 	guessed, ok := uploadTorrentCleanPath(meta, dbPath)
 	if !ok {
 		t.Fatal("expected clean upload torrent path")
@@ -139,7 +139,7 @@ func TestResolveUploadTorrentPathFallsBackToExplicitCandidateWhenCleanCopyInvali
 		t.Fatalf("write invalid torrent: %v", err)
 	}
 
-	got, err := ResolveUploadTorrentPath(api.PreparedMetadata{
+	got, err := ResolveUploadTorrentPath(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: invalidTorrentPath,
 	}, filepath.Join(tmp, "state", "upbrr.db"))
@@ -218,7 +218,7 @@ func TestResolveUploadTorrentPathWithoutCleanTargetLeavesOriginalUnchanged(t *te
 		InfoBytes: testInfoBytes(t, ""),
 	})
 
-	got, err := ResolveUploadTorrentPath(api.PreparedMetadata{TorrentPath: torrentPath}, "")
+	got, err := ResolveUploadTorrentPath(api.UploadSubject{TorrentPath: torrentPath}, "")
 	if err != nil {
 		t.Fatalf("resolve upload torrent: %v", err)
 	}
@@ -293,10 +293,10 @@ func TestPrepareTrackerUploadTorrentCreatesSpecificArtifact(t *testing.T) {
 	})
 
 	dbPath := filepath.Join(tmp, "state", "upbrr.db")
-	meta, err := PrepareTrackerUploadTorrent(api.PreparedMetadata{
+	meta, err := PrepareTrackerUploadTorrentWithRegistry(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: baseTorrentPath,
-	}, dbPath, "HDB", config.TrackerConfig{AnnounceURL: "https://new.example/announce"})
+	}, dbPath, "HDB", config.TrackerConfig{AnnounceURL: "https://new.example/announce"}, hdbArtifactRegistry(t))
 	if err != nil {
 		t.Fatalf("prepare tracker torrent: %v", err)
 	}
@@ -310,7 +310,7 @@ func TestPrepareTrackerUploadTorrentCreatesSpecificArtifact(t *testing.T) {
 	}
 	assertInfoSource(t, artifact, "HDBits")
 
-	cleanBase, ok := uploadTorrentCleanPath(api.PreparedMetadata{SourcePath: sourcePath, TorrentPath: baseTorrentPath}, dbPath)
+	cleanBase, ok := uploadTorrentCleanPath(api.UploadSubject{SourcePath: sourcePath, TorrentPath: baseTorrentPath}, dbPath)
 	if !ok {
 		t.Fatal("expected clean base path")
 	}
@@ -332,10 +332,18 @@ func TestPrepareTrackerUploadTorrentUsesDefaultAnnounce(t *testing.T) {
 	baseTorrentPath := filepath.Join(tmp, "base.torrent")
 	writeTestMetaInfo(t, baseTorrentPath, metainfo.MetaInfo{InfoBytes: testInfoBytes(t, "")})
 
-	meta, err := PrepareTrackerUploadTorrent(api.PreparedMetadata{
+	registry := NewRegistry()
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:           "AZ",
+		Definition:     stubDefinition{name: "AZ"},
+		UploadArtifact: &UploadArtifactPolicy{Source: "AvistaZ", DefaultAnnounce: "https://tracker.avistaz.to/announce"},
+	}); err != nil {
+		t.Fatalf("register AZ artifact policy: %v", err)
+	}
+	meta, err := PrepareTrackerUploadTorrentWithRegistry(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: baseTorrentPath,
-	}, filepath.Join(tmp, "state", "upbrr.db"), "AZ", config.TrackerConfig{})
+	}, filepath.Join(tmp, "state", "upbrr.db"), "AZ", config.TrackerConfig{}, registry)
 	if err != nil {
 		t.Fatalf("prepare tracker torrent: %v", err)
 	}
@@ -357,10 +365,10 @@ func TestPrepareTrackerUploadTorrentUsesBTNAnnounceURL(t *testing.T) {
 	baseTorrentPath := filepath.Join(tmp, "base.torrent")
 	writeTestMetaInfo(t, baseTorrentPath, metainfo.MetaInfo{InfoBytes: testInfoBytes(t, "")})
 
-	meta, err := PrepareTrackerUploadTorrent(api.PreparedMetadata{
+	meta, err := PrepareTrackerUploadTorrentWithRegistry(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: baseTorrentPath,
-	}, filepath.Join(tmp, "state", "upbrr.db"), "BTN", config.TrackerConfig{AnnounceURL: "https://tracker.btn.example/announce/passkey"})
+	}, filepath.Join(tmp, "state", "upbrr.db"), "BTN", config.TrackerConfig{AnnounceURL: "https://tracker.btn.example/announce/passkey"}, btnArtifactRegistry(t))
 	if err != nil {
 		t.Fatalf("prepare tracker torrent: %v", err)
 	}
@@ -386,11 +394,11 @@ func TestPrepareTrackerUploadTorrentSkipsBTNWithoutAnnounceURL(t *testing.T) {
 	writeTestMetaInfo(t, baseTorrentPath, metainfo.MetaInfo{InfoBytes: testInfoBytes(t, "")})
 
 	dbPath := filepath.Join(tmp, "state", "upbrr.db")
-	meta := api.PreparedMetadata{
+	meta := api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: baseTorrentPath,
 	}
-	got, err := PrepareTrackerUploadTorrent(meta, dbPath, "BTN", config.TrackerConfig{})
+	got, err := PrepareTrackerUploadTorrentWithRegistry(meta, dbPath, "BTN", config.TrackerConfig{}, btnArtifactRegistry(t))
 	if err != nil {
 		t.Fatalf("prepare tracker torrent: %v", err)
 	}
@@ -409,8 +417,8 @@ func TestPrepareTrackerUploadTorrentSkipsBTNWithoutAnnounceURL(t *testing.T) {
 func TestPrepareTrackerUploadTorrentNoSpecLeavesMetaUnchanged(t *testing.T) {
 	t.Parallel()
 
-	meta := api.PreparedMetadata{TorrentPath: filepath.Join(t.TempDir(), "base.torrent")}
-	got, err := PrepareTrackerUploadTorrent(meta, "", "BTN", config.TrackerConfig{})
+	meta := api.UploadSubject{TorrentPath: filepath.Join(t.TempDir(), "base.torrent")}
+	got, err := PrepareTrackerUploadTorrent(meta, "", "UNKNOWN", config.TrackerConfig{})
 	if err != nil {
 		t.Fatalf("prepare tracker torrent: %v", err)
 	}
@@ -419,6 +427,34 @@ func TestPrepareTrackerUploadTorrentNoSpecLeavesMetaUnchanged(t *testing.T) {
 	}
 }
 
+func btnArtifactRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	policy := &UploadArtifactPolicy{Source: "BTN", RequireAnnounce: true}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:           "BTN",
+		Definition:     stubDefinition{name: "BTN"},
+		UploadArtifact: policy,
+	}); err != nil {
+		t.Fatalf("register BTN artifact policy: %v", err)
+	}
+	return registry
+}
+
+func hdbArtifactRegistry(t *testing.T) *Registry {
+	t.Helper()
+	registry := NewRegistry()
+	policy := &UploadArtifactPolicy{Source: "HDBits"}
+	if err := registry.RegisterDescriptor(Descriptor{
+		Name:           "HDB",
+		Definition:     stubDefinition{name: "HDB"},
+		UploadArtifact: policy,
+	}); err != nil {
+		t.Fatalf("register HDB artifact policy: %v", err)
+	}
+	return registry
+}
+
 func TestPrepareDryRunInjectionTorrentCreatesGenericTrackerArtifact(t *testing.T) {
 	t.Parallel()
 
@@ -430,7 +466,7 @@ func TestPrepareDryRunInjectionTorrentCreatesGenericTrackerArtifact(t *testing.T
 	baseTorrentPath := filepath.Join(tmp, "base.torrent")
 	writeTestMetaInfo(t, baseTorrentPath, metainfo.MetaInfo{InfoBytes: testInfoBytes(t, "")})
 
-	meta, err := PrepareDryRunInjectionTorrent(api.PreparedMetadata{
+	meta, err := PrepareDryRunInjectionTorrent(api.UploadSubject{
 		SourcePath:  sourcePath,
 		TorrentPath: baseTorrentPath,
 	}, filepath.Join(tmp, "state", "upbrr.db"), "LUME", config.TrackerConfig{AnnounceURL: "https://luminarr.me/announce/passkey"})
@@ -453,7 +489,7 @@ func TestResolveTrackerTorrentArtifactPathPrefixesTrackerName(t *testing.T) {
 
 	tmp := t.TempDir()
 	sourcePath := filepath.Join(tmp, "Example.Movie.2026.BluRay.1080p.DTS.x264-GRP.mkv")
-	got, err := ResolveTrackerTorrentArtifactPath(api.PreparedMetadata{SourcePath: sourcePath}, filepath.Join(tmp, "state", "upbrr.db"), "MTV")
+	got, err := ResolveTrackerTorrentArtifactPath(api.UploadSubject{SourcePath: sourcePath}, filepath.Join(tmp, "state", "upbrr.db"), "MTV")
 	if err != nil {
 		t.Fatalf("resolve tracker torrent artifact: %v", err)
 	}
diff --git a/internal/trackers/upload_content.go b/internal/trackers/upload_content.go
new file mode 100644
index 00000000..dd02ec3d
--- /dev/null
+++ b/internal/trackers/upload_content.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package trackers
+
+import "github.com/autobrr/upbrr/pkg/api"
+
+// UploadContentMode identifies the shared content object a tracker consumes
+// before its tracker-local upload adapter is invoked.
+type UploadContentMode string
+
+const (
+	// UploadContentModeNone bypasses shared description and image preparation.
+	UploadContentModeNone UploadContentMode = "none"
+	// UploadContentModeScreenshots consumes shared screenshot and menu-image assets only.
+	UploadContentModeScreenshots UploadContentMode = "screenshots"
+	// UploadContentModeDescription consumes the aggregate description and image object.
+	UploadContentModeDescription UploadContentMode = "description"
+)
+
+// Valid reports whether mode is one of the supported semantic workflow shapes.
+func (m UploadContentMode) Valid() bool {
+	switch m {
+	case UploadContentModeNone, UploadContentModeScreenshots, UploadContentModeDescription:
+		return true
+	default:
+		return false
+	}
+}
+
+// UsesDescription reports whether shared description construction is required.
+func (m UploadContentMode) UsesDescription() bool { return m == UploadContentModeDescription }
+
+// UsesImages reports whether shared screenshot or menu-image preparation is required.
+func (m UploadContentMode) UsesImages() bool {
+	return m == UploadContentModeScreenshots || m == UploadContentModeDescription
+}
+
+// FailureReasonCode returns the canonical eligibility reason for a failed
+// associated content object.
+func (m UploadContentMode) FailureReasonCode() api.TrackerEligibilityReasonCode {
+	switch m {
+	case UploadContentModeNone:
+		return ""
+	case UploadContentModeScreenshots:
+		return api.TrackerEligibilityScreenshotPreparationFailed
+	case UploadContentModeDescription:
+		return api.TrackerEligibilityDescriptionPreparationFailed
+	default:
+		return ""
+	}
+}
+
+// UploadContentModeProvider declares a tracker's shared upload-content workflow.
+type UploadContentModeProvider interface {
+	// UploadContentMode returns the tracker-owned semantic content mode.
+	UploadContentMode() UploadContentMode
+}
diff --git a/internal/webserver/app_routes.go b/internal/webserver/app_routes.go
index 7c54cc2b..cead2ddd 100644
--- a/internal/webserver/app_routes.go
+++ b/internal/webserver/app_routes.go
@@ -11,17 +11,28 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/internal/services/trackericon"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-// cookieImportRequestEnvelopeMaxBytes leaves JSON envelope headroom while the
-// tracker auth importer enforces the shared raw cookie content limit.
-const cookieImportRequestEnvelopeMaxBytes = trackerauth.MaxCookieImportContentBytes*6 + 64*1024
+const (
+	// JSON can encode one raw byte as a six-byte escape. These route caps leave
+	// fixed field headroom while downstream importers enforce decoded limits.
+	cookieImportRequestEnvelopeMaxBytes = trackerauth.MaxCookieImportContentBytes*6 + 64*1024
+	configImportRequestEnvelopeMaxBytes = configImportMaxBytes*6 + 64*1024
+)
+
+func nonNilAppList[T any](values []T) []T {
+	if values == nil {
+		return []T{}
+	}
+	return values
+}
 
+// registerAppRoutes installs authenticated browser operations and their
+// request-shape adapters on mux.
 func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("/api/app/ListTrackerAuthCapabilities", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		if r.Method != http.MethodPost {
@@ -33,7 +44,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/GetTrackerAuthStatus", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
@@ -155,57 +166,6 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		writeJSON(w, http.StatusOK, value)
 	}))
 
-	mux.HandleFunc("/api/app/BrowseFile", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		if r.Method != http.MethodPost {
-			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
-			return
-		}
-		if !s.nativeBrowseAvailable(r) {
-			writeJSON(w, http.StatusForbidden, map[string]string{"error": "native browse is only available from localhost web sessions"})
-			return
-		}
-		value, err := s.picker.BrowseFile()
-		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
-	mux.HandleFunc("/api/app/BrowseImageFiles", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		if r.Method != http.MethodPost {
-			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
-			return
-		}
-		if !s.nativeBrowseAvailable(r) {
-			writeJSON(w, http.StatusForbidden, map[string]string{"error": "native browse is only available from localhost web sessions"})
-			return
-		}
-		value, err := s.picker.BrowseImageFiles()
-		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
-	mux.HandleFunc("/api/app/BrowseFolder", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		if r.Method != http.MethodPost {
-			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
-			return
-		}
-		if !s.nativeBrowseAvailable(r) {
-			writeJSON(w, http.StatusForbidden, map[string]string{"error": "native browse is only available from localhost web sessions"})
-			return
-		}
-		value, err := s.picker.BrowseFolder()
-		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
 	mux.HandleFunc("/api/app/DetectDiscType", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct{ Path string }
 		if err := decodeJSON(r, &req); err != nil {
@@ -222,18 +182,31 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/FetchMetadata", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
+			CorrelationID     string
 			Path              string
 			SourceLookupURL   string
 			Overrides         api.ExternalIDOverrides
 			NameOverrides     api.ReleaseNameOverrides
-			Trackers          []string
+			Playlist          api.PlaylistInstruction
 			ConfirmBDMVRescan bool
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.FetchMetadata(current.ID, req.Path, req.SourceLookupURL, req.Overrides, req.NameOverrides, req.Trackers, req.ConfirmBDMVRescan)
+		value, err := s.backend.FetchMetadata(
+			r.Context(),
+			current.ID,
+			metadataPreparationRequest{
+				CorrelationID:     req.CorrelationID,
+				Path:              req.Path,
+				SourceLookupURL:   req.SourceLookupURL,
+				Overrides:         req.Overrides,
+				NameOverrides:     req.NameOverrides,
+				Playlist:          req.Playlist,
+				ConfirmBDMVRescan: req.ConfirmBDMVRescan,
+			},
+		)
 		if err != nil {
 			writeAppError(w, err)
 			return
@@ -243,35 +216,31 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/ResetMetadata", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
+			CorrelationID     string
 			Path              string
 			SourceLookupURL   string
 			Overrides         api.ExternalIDOverrides
 			NameOverrides     api.ReleaseNameOverrides
-			Trackers          []string
+			Playlist          api.PlaylistInstruction
 			ConfirmBDMVRescan bool
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.ResetMetadata(current.ID, req.Path, req.SourceLookupURL, req.Overrides, req.NameOverrides, req.Trackers, req.ConfirmBDMVRescan)
-		if err != nil {
-			writeAppError(w, err)
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
-	mux.HandleFunc("/api/app/SelectBlurayCandidate", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		var req struct {
-			Path      string
-			ReleaseID string
-		}
-		if err := decodeJSON(r, &req); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		value, err := s.backend.SelectBlurayCandidate(req.Path, req.ReleaseID)
+		value, err := s.backend.ResetMetadata(
+			r.Context(),
+			current.ID,
+			metadataPreparationRequest{
+				CorrelationID:     req.CorrelationID,
+				Path:              req.Path,
+				SourceLookupURL:   req.SourceLookupURL,
+				Overrides:         req.Overrides,
+				NameOverrides:     req.NameOverrides,
+				Playlist:          req.Playlist,
+				ConfirmBDMVRescan: req.ConfirmBDMVRescan,
+			},
+		)
 		if err != nil {
 			writeAppError(w, err)
 			return
@@ -279,20 +248,23 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		writeJSON(w, http.StatusOK, value)
 	}))
 
-	mux.HandleFunc("/api/app/CheckDupes", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
+	mux.HandleFunc("/api/app/SelectBlurayCandidate", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
+			CorrelationID string
 			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			Trackers      []string
+			ReleaseID     string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.CheckDupes(req.Path, req.Overrides, req.NameOverrides, req.Trackers)
+		value, err := s.backend.SelectBlurayCandidate(r.Context(), current.ID, blurayCandidateSelectionRequest{
+			CorrelationID: req.CorrelationID,
+			Path:          req.Path,
+			ReleaseID:     req.ReleaseID,
+		})
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -312,7 +284,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		}
 		value, err := s.backend.FetchPreparation(current.ID, req.Path, req.Overrides, req.NameOverrides, req.Trackers, req.IgnoreDupesFor)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -320,14 +292,12 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/FetchTrackerDryRun", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
-			Path                 string
-			Overrides            api.ExternalIDOverrides
-			NameOverrides        api.ReleaseNameOverrides
+			DupeJobID            string
+			Release              api.ReleaseRef
 			Trackers             []string
 			IgnoreDupesFor       []string
 			QuestionnaireAnswers map[string]map[string]string
 			DescriptionGroups    []api.DescriptionBuilderGroup
-			Debug                bool
 			NoSeed               bool
 			RunLogLevel          string
 		}
@@ -335,9 +305,20 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.FetchTrackerDryRun(current.ID, req.Path, req.Overrides, req.NameOverrides, req.Trackers, req.IgnoreDupesFor, req.QuestionnaireAnswers, req.DescriptionGroups, req.Debug, req.NoSeed, req.RunLogLevel)
+		value, err := s.backend.FetchTrackerDryRun(
+			r.Context(),
+			current.ID,
+			req.DupeJobID,
+			req.Release,
+			req.Trackers,
+			req.IgnoreDupesFor,
+			req.QuestionnaireAnswers,
+			req.DescriptionGroups,
+			req.NoSeed,
+			req.RunLogLevel,
+		)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -345,19 +326,16 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/FetchDescriptionBuilder", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path           string
-			Overrides      api.ExternalIDOverrides
-			NameOverrides  api.ReleaseNameOverrides
-			Trackers       []string
-			IgnoreDupesFor []string
+			Release  api.ReleaseRef
+			Trackers []string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.FetchDescriptionBuilder(req.Path, req.Overrides, req.NameOverrides, req.Trackers, req.IgnoreDupesFor)
+		value, err := s.backend.FetchDescriptionBuilder(req.Release, req.Trackers)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -371,7 +349,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		}
 		value, err := s.backend.RenderDescription(req.Raw)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -379,20 +357,18 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/SaveDescriptionOverride", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			GroupKey      string
-			Raw           string
-			Trackers      []string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release  api.ReleaseRef
+			GroupKey string
+			Raw      string
+			Trackers []string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.SaveDescriptionOverride(req.Path, req.GroupKey, req.Raw, req.Trackers, req.Overrides, req.NameOverrides)
+		value, err := s.backend.SaveDescriptionOverride(req.Release, req.GroupKey, req.Raw, req.Trackers)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -404,40 +380,9 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.DiscoverPlaylists(req.Path)
+		value, err := s.backend.DiscoverPlaylists(r.Context(), req.Path)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
-	mux.HandleFunc("/api/app/SavePlaylistSelection", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		var req struct {
-			Path      string
-			Playlists []string
-			UseAll    bool
-		}
-		if err := decodeJSON(r, &req); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		if err := s.backend.SavePlaylistSelection(req.Path, req.Playlists, req.UseAll); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
-	}))
-
-	mux.HandleFunc("/api/app/LoadPlaylistSelection", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
-		var req struct{ Path string }
-		if err := decodeJSON(r, &req); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		value, err := s.backend.LoadPlaylistSelection(req.Path)
-		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -472,17 +417,15 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/FetchScreenshotPlan", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release api.ReleaseRef
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.FetchScreenshotPlan(req.Path, req.Overrides, req.NameOverrides)
+		value, err := s.backend.FetchScreenshotPlan(req.Release)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -490,19 +433,17 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/GenerateScreenshots", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			Selections    []api.ScreenshotSelection
-			Purpose       api.ScreenshotPurpose
+			Release    api.ReleaseRef
+			Selections []api.ScreenshotSelection
+			Purpose    api.ScreenshotPurpose
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.GenerateScreenshots(req.Path, req.Overrides, req.NameOverrides, req.Selections, req.Purpose)
+		value, err := s.backend.GenerateScreenshots(req.Release, req.Selections, req.Purpose)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -510,18 +451,16 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/PreviewScreenshotFrame", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path             string
-			Overrides        api.ExternalIDOverrides
-			NameOverrides    api.ReleaseNameOverrides
+			Release          api.ReleaseRef
 			TimestampSeconds float64
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.PreviewScreenshotFrame(req.Path, req.Overrides, req.NameOverrides, req.TimestampSeconds)
+		value, err := s.backend.PreviewScreenshotFrame(req.Release, req.TimestampSeconds)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -529,17 +468,15 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/DeleteScreenshot", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			ImagePath     string
+			Release   api.ReleaseRef
+			ImagePath string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.DeleteScreenshot(req.Path, req.Overrides, req.NameOverrides, req.ImagePath); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.DeleteScreenshot(req.Release, req.ImagePath); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -547,17 +484,15 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/DeleteTrackerImageURL", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			URL           string
+			Release api.ReleaseRef
+			URL     string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.DeleteTrackerImageURL(req.Path, req.Overrides, req.NameOverrides, req.URL); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.DeleteTrackerImageURL(req.Release, req.URL); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -565,17 +500,15 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/SaveFinalScreenshotSelections", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			Images        []api.ScreenshotImage
+			Release api.ReleaseRef
+			Images  []api.ScreenshotImage
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.SaveFinalScreenshotSelections(req.Path, req.Overrides, req.NameOverrides, req.Images); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.SaveFinalScreenshotSelections(req.Release, req.Images); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -583,10 +516,8 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/ImportMenuImages", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			Paths         []string
+			Release api.ReleaseRef
+			Paths   []string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
@@ -606,82 +537,47 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.ImportMenuImages(req.Path, req.Overrides, req.NameOverrides, importPaths); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.ImportMenuImages(req.Release, importPaths); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
 	}))
 
-	mux.HandleFunc("/api/app/StartDVDMenuCapture", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
+	mux.HandleFunc("/api/app/CaptureDVDMenus", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		if r.Method != http.MethodPost {
 			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
 			return
 		}
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release api.ReleaseRef
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.StartDVDMenuCapture(r.Context(), current.ID, req.Path, req.Overrides, req.NameOverrides)
+		value, err := s.backend.CaptureDVDMenus(r.Context(), req.Release)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, value)
-	}))
-
-	mux.HandleFunc("/api/app/GetDVDMenuCaptureSnapshot", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
-		var req struct{ JobID string }
-		if err := decodeJSON(r, &req); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		value, err := s.backend.GetDVDMenuCaptureSnapshot(current.ID, req.JobID)
-		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
 	}))
 
-	mux.HandleFunc("/api/app/CancelDVDMenuCapture", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
-		if r.Method != http.MethodPost {
-			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
-			return
-		}
-		var req struct{ JobID string }
-		if err := decodeJSON(r, &req); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		if err := s.backend.CancelDVDMenuCapture(current.ID, req.JobID); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
-			return
-		}
-		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
-	}))
-
 	mux.HandleFunc("/api/app/ListDVDMenuScreenshots", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release api.ReleaseRef
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.ListDVDMenuScreenshots(req.Path, req.Overrides, req.NameOverrides)
+		value, err := s.backend.ListDVDMenuScreenshots(req.Release)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/DeleteDVDMenuScreenshot", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
@@ -690,17 +586,15 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			return
 		}
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
-			ImagePath     string
+			Release   api.ReleaseRef
+			ImagePath string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.DeleteDVDMenuScreenshot(req.Path, req.Overrides, req.NameOverrides, req.ImagePath); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.DeleteDVDMenuScreenshot(req.Release, req.ImagePath); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -722,45 +616,40 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/ListUploadCandidates", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release api.ReleaseRef
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.ListUploadCandidates(req.Path, req.Overrides, req.NameOverrides)
+		value, err := s.backend.ListUploadCandidates(req.Release)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/ListUploadedImages", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release api.ReleaseRef
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.ListUploadedImages(req.Path, req.Overrides, req.NameOverrides)
+		value, err := s.backend.ListUploadedImages(req.Release)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
-	mux.HandleFunc("/api/app/UploadImages", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
+	mux.HandleFunc("/api/app/UploadImages", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			CorrelationID string
+			Release       api.ReleaseRef
 			Trackers      []string
 			Host          string
 			Images        []api.ScreenshotImage
@@ -769,9 +658,9 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.UploadImages(req.Path, req.Overrides, req.NameOverrides, req.Trackers, req.Host, req.Images)
+		value, err := s.backend.UploadImages(r.Context(), current.ID, req.CorrelationID, req.Release, req.Trackers, req.Host, req.Images)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -779,7 +668,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/DeleteUploadedImage", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		var req struct {
-			Path      string
+			Release   api.ReleaseRef
 			ImagePath string
 			Host      string
 		}
@@ -787,8 +676,8 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		if err := s.backend.DeleteUploadedImage(req.Path, req.ImagePath, req.Host); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		if err := s.backend.DeleteUploadedImage(req.Release, req.ImagePath, req.Host); err != nil {
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -852,9 +741,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
 			return
 		}
-		// Allow extra headroom for JSON wrapping (FileName, escaping)
-		// beyond the raw file-content limit enforced by the importer.
-		r.Body = http.MaxBytesReader(w, r.Body, configImportMaxBytes+1024*1024)
+		r.Body = http.MaxBytesReader(w, r.Body, configImportRequestEnvelopeMaxBytes)
 		var req struct {
 			FileName    string
 			FileContent string
@@ -871,8 +758,8 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		writeJSON(w, http.StatusOK, map[string]any{"result": result, "warnings": warnings})
 	}))
 
-	mux.HandleFunc("/api/app/ListKnownTrackers", s.requireSession(func(w http.ResponseWriter, _ *http.Request, _ session) {
-		value, err := s.backend.ListKnownTrackers()
+	mux.HandleFunc("/api/app/ListTrackerCatalog", s.requireSession(func(w http.ResponseWriter, _ *http.Request, _ session) {
+		value, err := s.backend.ListTrackerCatalog()
 		if err != nil {
 			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 			return
@@ -895,7 +782,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/GetHistoryOverview", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
@@ -945,7 +832,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/StartLogStream", s.requireSession(func(w http.ResponseWriter, _ *http.Request, current session) {
@@ -976,7 +863,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
 			return
 		}
-		writeJSON(w, http.StatusOK, value)
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
 	}))
 
 	mux.HandleFunc("/api/app/UpdateLogExclusions", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
@@ -994,18 +881,19 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 
 	mux.HandleFunc("/api/app/StartDupeCheck", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
-			Path          string
-			Overrides     api.ExternalIDOverrides
-			NameOverrides api.ReleaseNameOverrides
+			Release       api.ReleaseRef
 			Trackers      []string
+			CorrelationID string
 		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.StartDupeCheck(r.Context(), current.ID, req.Path, req.Overrides, req.NameOverrides, req.Trackers)
+		value, err := s.backend.StartDupeCheck(
+			r.Context(), current.ID, req.Release, req.Trackers, req.CorrelationID,
+		)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -1022,7 +910,7 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			return
 		}
 		if err := s.backend.CancelDupeCheck(current.ID, req.JobID); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
@@ -1036,22 +924,20 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		}
 		value, err := s.backend.GetDupeCheckSnapshot(current.ID, req.JobID)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
 	}))
 
-	mux.HandleFunc("/api/app/StartTrackerUpload", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
+	mux.HandleFunc("/api/app/ReviewTrackerUpload", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
 		var req struct {
-			Path                 string
-			Overrides            api.ExternalIDOverrides
-			NameOverrides        api.ReleaseNameOverrides
+			Release              api.ReleaseRef
 			Trackers             []string
 			IgnoreDupesFor       []string
+			RuleAuthorizations   []api.RuleAuthorization
 			QuestionnaireAnswers map[string]map[string]string
 			DescriptionGroups    []api.DescriptionBuilderGroup
-			Debug                bool
 			NoSeed               bool
 			RunLogLevel          string
 		}
@@ -1059,11 +945,39 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.StartTrackerUpload(current.ID, req.Path, req.Overrides, req.NameOverrides, req.Trackers, req.IgnoreDupesFor, req.QuestionnaireAnswers, req.DescriptionGroups, req.Debug, req.NoSeed, req.RunLogLevel)
+		value, err := s.backend.ReviewTrackerUpload(
+			r.Context(),
+			current.ID,
+			req.Release,
+			req.Trackers,
+			req.IgnoreDupesFor,
+			req.RuleAuthorizations,
+			req.QuestionnaireAnswers,
+			req.DescriptionGroups,
+			req.NoSeed,
+			req.RunLogLevel,
+		)
 		if err != nil {
+			writeAppError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, value)
+	}))
+
+	mux.HandleFunc("/api/app/StartReviewedTrackerUpload", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
+		var req struct {
+			Token         string
+			CorrelationID string
+		}
+		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
+		value, err := s.backend.StartReviewedTrackerUpload(current.ID, req.Token, req.CorrelationID)
+		if err != nil {
+			writeAppError(w, err)
+			return
+		}
 		writeJSON(w, http.StatusOK, value)
 	}))
 
@@ -1078,21 +992,24 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 			return
 		}
 		if err := s.backend.CancelTrackerUpload(current.ID, req.JobID); err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
 	}))
 
 	mux.HandleFunc("/api/app/RetryFailedTrackerUpload", s.requireSession(func(w http.ResponseWriter, r *http.Request, current session) {
-		var req struct{ JobID string }
+		var req struct {
+			JobID         string
+			CorrelationID string
+		}
 		if err := decodeJSON(r, &req); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
 			return
 		}
-		value, err := s.backend.RetryFailedTrackerUpload(current.ID, req.JobID)
+		value, err := s.backend.RetryFailedTrackerUpload(current.ID, req.JobID, req.CorrelationID)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
@@ -1106,12 +1023,21 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		}
 		value, err := s.backend.GetTrackerUploadSnapshot(current.ID, req.JobID)
 		if err != nil {
-			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			writeAppError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, value)
 	}))
 
+	mux.HandleFunc("/api/app/ListJobs", s.requireSession(func(w http.ResponseWriter, _ *http.Request, current session) {
+		value, err := s.backend.ListJobs(current.ID)
+		if err != nil {
+			writeAppError(w, err)
+			return
+		}
+		writeJSON(w, http.StatusOK, nonNilAppList(value))
+	}))
+
 	mux.HandleFunc("/api/app/GetTrackerIcon", s.requireSession(func(w http.ResponseWriter, r *http.Request, _ session) {
 		if r.Method != http.MethodPost {
 			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
@@ -1129,10 +1055,10 @@ func (s *Server) registerAppRoutes(mux *http.ServeMux) {
 		if s.backend != nil {
 			cfg = s.backend.currentConfig()
 		}
-		domain, resolvedURL := config.ResolveTrackerDomain(&cfg, req.Domain)
-		urlToUse := req.URL
-		if urlToUse == "" {
-			urlToUse = resolvedURL
+		domain, urlToUse, err := resolveTrackerIconTarget(req.Domain, req.URL)
+		if err != nil {
+			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			return
 		}
 		value, err := trackericon.GetTrackerIcon(r.Context(), cfg.MainSettings.DBPath, domain, urlToUse)
 		if err != nil {
@@ -1252,18 +1178,28 @@ func pathWithinBrowseRoots(candidate string, roots []string) bool {
 	return false
 }
 
+// writeAppError exposes structured operation failures with their safe message
+// and hides all unstructured error detail behind a generic internal failure.
 func writeAppError(w http.ResponseWriter, err error) {
-	var rescanErr *api.BDMVRescanRequiredError
-	if errors.As(err, &rescanErr) {
-		writeJSON(w, http.StatusConflict, map[string]any{
-			"error":              err.Error(),
-			"code":               api.ErrCodeBDMVRescanRequired,
-			"source_path":        rescanErr.SourcePath,
-			"selected_playlists": rescanErr.SelectedPlaylists,
-			"cached_playlists":   rescanErr.CachedPlaylists,
-			"missing_playlists":  rescanErr.MissingPlaylists,
+	if failure, ok := api.AsOperationFailure(err); ok {
+		status := http.StatusConflict
+		if failure.Code == api.OperationFailureInvalidInput || failure.Code == api.OperationFailureInvalidSource {
+			status = http.StatusBadRequest
+		}
+		writeJSON(w, status, map[string]any{
+			"error":   failure.Message,
+			"failure": failure,
 		})
 		return
 	}
-	writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+	failure := api.OperationFailure{
+		Code:      api.OperationFailureInternal,
+		Operation: api.OperationKindUnknown,
+		Message:   "The operation could not be completed.",
+		Recovery:  api.OperationRecoveryRetry,
+	}
+	writeJSON(w, http.StatusInternalServerError, map[string]any{
+		"error":   failure.Message,
+		"failure": failure,
+	})
 }
diff --git a/internal/webserver/app_routes_errors_test.go b/internal/webserver/app_routes_errors_test.go
index fddd5c2e..2200281a 100644
--- a/internal/webserver/app_routes_errors_test.go
+++ b/internal/webserver/app_routes_errors_test.go
@@ -5,22 +5,30 @@ package webserver
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func TestWriteAppErrorBDMVRescanRequired(t *testing.T) {
+func TestWriteAppErrorBDMVRescanRequiredIsStructuredAndPathFree(t *testing.T) {
 	recorder := httptest.NewRecorder()
 
-	writeAppError(recorder, &api.BDMVRescanRequiredError{
+	cause := &api.BDMVRescanRequiredError{
 		SourcePath:        `/disc`,
 		SelectedPlaylists: []string{"00002.MPLS", "00001.MPLS"},
 		CachedPlaylists:   []string{"00001.MPLS"},
 		MissingPlaylists:  []string{"00002.MPLS"},
-	})
+	}
+	writeAppError(recorder, api.NewOperationError(api.OperationFailure{
+		Code:      api.OperationFailureConfirmationRequired,
+		Operation: api.OperationKindPreparation,
+		Message:   "Blu-ray playlist changes require confirmation before rescanning.",
+		Recovery:  api.OperationRecoveryConfirm,
+	}, cause))
 
 	if recorder.Code != http.StatusConflict {
 		t.Fatalf("expected status 409, got %d", recorder.Code)
@@ -30,10 +38,25 @@ func TestWriteAppErrorBDMVRescanRequired(t *testing.T) {
 	if err := json.Unmarshal(recorder.Body.Bytes(), &payload); err != nil {
 		t.Fatalf("unmarshal payload: %v", err)
 	}
-	if got := payload["code"]; got != api.ErrCodeBDMVRescanRequired {
-		t.Fatalf("expected code %q, got %#v", api.ErrCodeBDMVRescanRequired, got)
+	failure, ok := payload["failure"].(map[string]any)
+	if !ok {
+		t.Fatalf("missing failure: %#v", payload)
+	}
+	if got := failure["Code"]; got != string(api.OperationFailureConfirmationRequired) {
+		t.Fatalf("failure code = %#v", got)
+	}
+	if _, exists := payload["source_path"]; exists {
+		t.Fatalf("response exposed source path: %#v", payload)
+	}
+}
+
+func TestWriteAppErrorUntypedFallbackIsStructuredAndSafe(t *testing.T) {
+	recorder := httptest.NewRecorder()
+	writeAppError(recorder, errors.New(`token=secret-value path=C:\private\release`))
+	if recorder.Code != http.StatusInternalServerError {
+		t.Fatalf("status = %d", recorder.Code)
 	}
-	if got := payload["source_path"]; got != "/disc" {
-		t.Fatalf("unexpected source path %#v", got)
+	if strings.Contains(recorder.Body.String(), "secret-value") || strings.Contains(recorder.Body.String(), `C:\private`) {
+		t.Fatalf("unsafe response: %s", recorder.Body.String())
 	}
 }
diff --git a/internal/webserver/app_routes_list_test.go b/internal/webserver/app_routes_list_test.go
new file mode 100644
index 00000000..1c5f0ec1
--- /dev/null
+++ b/internal/webserver/app_routes_list_test.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestNonNilAppListPreservesJSONArrayShape(t *testing.T) {
+	t.Parallel()
+
+	payload, err := json.Marshal(nonNilAppList[string](nil))
+	if err != nil {
+		t.Fatalf("marshal normalized list: %v", err)
+	}
+	if string(payload) != "[]" {
+		t.Fatalf("normalized nil list = %s, want []", payload)
+	}
+
+	values := []string{"one"}
+	if got := nonNilAppList(values); len(got) != 1 || got[0] != "one" {
+		t.Fatalf("normalized populated list = %#v, want %#v", got, values)
+	}
+}
diff --git a/internal/guishared/application_info.go b/internal/webserver/application_info.go
similarity index 94%
rename from internal/guishared/application_info.go
rename to internal/webserver/application_info.go
index 22d206c4..5aa84fd2 100644
--- a/internal/guishared/application_info.go
+++ b/internal/webserver/application_info.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package guishared
+package webserver
 
 import (
 	"context"
@@ -24,12 +24,13 @@ const (
 
 // CurrentApplicationInfo adds path-free DVD menu capability diagnostics to
 // the shared application build/runtime information. It bounds the probe to ten
-// seconds and returns unavailable status when ctx or provider is nil.
+// seconds and returns unavailable status when ctx or provider is nil, including
+// an interface containing a typed nil pointer.
 func CurrentApplicationInfo(ctx context.Context, provider api.DVDMenuCapabilityProvider) api.ApplicationInfo {
 	info := api.CurrentApplicationInfo()
 	info.DVDMenuCapabilityStatus = DVDMenuCapabilityUnavailable
 	info.DVDMenuCapabilityMessage = "DVD menu capture capability could not be checked."
-	if provider == nil {
+	if !CapabilityAvailable(provider) {
 		return info
 	}
 	if ctx == nil {
diff --git a/internal/guishared/application_info_test.go b/internal/webserver/application_info_test.go
similarity index 76%
rename from internal/guishared/application_info_test.go
rename to internal/webserver/application_info_test.go
index 79fd1226..53aaecba 100644
--- a/internal/guishared/application_info_test.go
+++ b/internal/webserver/application_info_test.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package guishared
+package webserver
 
 import (
 	"context"
@@ -17,6 +17,12 @@ type applicationInfoCapabilityProvider struct {
 	err  error
 }
 
+type nilApplicationInfoCapabilityProvider struct{}
+
+func (*nilApplicationInfoCapabilityProvider) DVDMenuCapability(context.Context) (api.DVDMenuEngineInfo, error) {
+	panic("typed-nil provider must not be called")
+}
+
 func (p applicationInfoCapabilityProvider) DVDMenuCapability(context.Context) (api.DVDMenuEngineInfo, error) {
 	return p.info, p.err
 }
@@ -36,6 +42,16 @@ func TestCurrentApplicationInfoIncludesDVDMenuCapability(t *testing.T) {
 	}
 }
 
+func TestCurrentApplicationInfoRejectsTypedNilCapability(t *testing.T) {
+	t.Parallel()
+
+	var provider *nilApplicationInfoCapabilityProvider
+	info := CurrentApplicationInfo(context.Background(), provider)
+	if info.DVDMenuCapabilityStatus != DVDMenuCapabilityUnavailable {
+		t.Fatalf("expected unavailable status, got %q", info.DVDMenuCapabilityStatus)
+	}
+}
+
 func TestCurrentApplicationInfoReportsPathFreeIncompatibleCapability(t *testing.T) {
 	info := CurrentApplicationInfo(context.Background(), applicationInfoCapabilityProvider{
 		info: api.DVDMenuEngineInfo{
diff --git a/internal/webserver/assets.go b/internal/webserver/assets.go
new file mode 100644
index 00000000..f25fef09
--- /dev/null
+++ b/internal/webserver/assets.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+)
+
+// resolveAssets returns an explicit override unchanged. Without one, it selects
+// the first embedded or repo-local filesystem containing index.html.
+func resolveAssets(override fs.FS) (fs.FS, error) {
+	if override != nil {
+		return override, nil
+	}
+	if embeddedRoot, err := fs.Sub(embeddedAssets, "assets"); err == nil {
+		if hasIndex(embeddedRoot) {
+			return embeddedRoot, nil
+		}
+	}
+	if hasIndex(embeddedAssets) {
+		return embeddedAssets, nil
+	}
+	for _, path := range candidateAssetPaths() {
+		diskAssets := os.DirFS(path)
+		if hasIndex(diskAssets) {
+			return diskAssets, nil
+		}
+	}
+	return nil, errors.New("web assets not found: build webui and retry")
+}
+
+func hasIndex(assets fs.FS) bool {
+	if assets == nil {
+		return false
+	}
+	_, err := fs.Stat(assets, "index.html")
+	return err == nil
+}
+
+func candidateAssetPaths() []string {
+	return []string{
+		filepath.Join("webui", "dist"),
+	}
+}
diff --git a/internal/webserver/assets/.keep b/internal/webserver/assets/.keep
new file mode 100644
index 00000000..6eb6a766
--- /dev/null
+++ b/internal/webserver/assets/.keep
@@ -0,0 +1,2 @@
+This placeholder is committed so go:embed all:assets always has at least one match in clean checkouts.
+Generated WebUI build artifacts in this directory remain ignored.
diff --git a/internal/guiapp/assets_embed.go b/internal/webserver/assets_embed.go
similarity index 90%
rename from internal/guiapp/assets_embed.go
rename to internal/webserver/assets_embed.go
index 2a80f4a0..75dc4007 100644
--- a/internal/guiapp/assets_embed.go
+++ b/internal/webserver/assets_embed.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package guiapp
+package webserver
 
 import "embed"
 
diff --git a/internal/webserver/assets_test.go b/internal/webserver/assets_test.go
new file mode 100644
index 00000000..d5fa0b74
--- /dev/null
+++ b/internal/webserver/assets_test.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"path/filepath"
+	"slices"
+	"testing"
+)
+
+func TestCandidateAssetPaths(t *testing.T) {
+	t.Parallel()
+
+	paths := candidateAssetPaths()
+
+	if !slices.Contains(paths, filepath.Join("webui", "dist")) {
+		t.Fatalf("missing repo-root asset path: %v", paths)
+	}
+	if len(paths) != 1 {
+		t.Fatalf("unexpected asset paths: %v", paths)
+	}
+}
diff --git a/internal/webserver/auth.go b/internal/webserver/auth.go
index a2a1413d..30664411 100644
--- a/internal/webserver/auth.go
+++ b/internal/webserver/auth.go
@@ -176,6 +176,8 @@ func syncDir(path string) error {
 	return nil
 }
 
+// sessionManager owns active browser sessions, persists only retained sessions,
+// and reports permanent removals after releasing its state lock.
 type sessionManager struct {
 	ttl          time.Duration
 	cleanupEvery time.Duration
@@ -184,6 +186,7 @@ type sessionManager struct {
 	stopOnce     sync.Once
 	store        *sessionStore
 	logf         func(string, ...any)
+	onRemoved    func(string)
 	mu           sync.Mutex
 	sessions     map[string]session
 }
@@ -218,6 +221,34 @@ func (m *sessionManager) SetLogger(logf func(string, ...any)) {
 	m.logf = logf
 }
 
+// SetRemovedCallback installs a callback invoked after the manager mutex is
+// released whenever a session is permanently removed.
+func (m *sessionManager) SetRemovedCallback(callback func(string)) {
+	if m == nil {
+		return
+	}
+	m.mu.Lock()
+	m.onRemoved = callback
+	m.mu.Unlock()
+}
+
+func (m *sessionManager) notifyRemoved(ids ...string) {
+	if m == nil || len(ids) == 0 {
+		return
+	}
+	m.mu.Lock()
+	callback := m.onRemoved
+	m.mu.Unlock()
+	if callback == nil {
+		return
+	}
+	for _, id := range ids {
+		if strings.TrimSpace(id) != "" {
+			callback(id)
+		}
+	}
+}
+
 func (m *sessionManager) Create(username string, retainLogin bool) (session, error) {
 	id, err := randomString(32)
 	if err != nil {
@@ -269,6 +300,7 @@ func (m *sessionManager) Get(id string) (session, bool) {
 				m.logPersistError("cleanup expired retained session", err)
 			}
 		}
+		m.notifyRemoved(id)
 		return session{}, false
 	}
 	m.mu.Unlock()
@@ -286,12 +318,14 @@ func (m *sessionManager) GetByCSRFToken(token string) (session, bool) {
 
 	now := time.Now().UTC()
 	changedRetained := false
+	removed := make([]string, 0)
 	var matched session
 	matchedOK := false
 	m.mu.Lock()
 	for id, current := range m.sessions {
 		if now.After(current.ExpiresAt) {
 			delete(m.sessions, id)
+			removed = append(removed, id)
 			if current.Retain {
 				changedRetained = true
 			}
@@ -309,6 +343,7 @@ func (m *sessionManager) GetByCSRFToken(token string) (session, bool) {
 			m.logPersistError("cleanup expired retained session", err)
 		}
 	}
+	m.notifyRemoved(removed...)
 	if matchedOK {
 		return matched, true
 	}
@@ -329,6 +364,9 @@ func (m *sessionManager) Delete(id string) error {
 			return err
 		}
 	}
+	if ok {
+		m.notifyRemoved(id)
+	}
 	return nil
 }
 
@@ -362,10 +400,12 @@ func (m *sessionManager) cleanupLoop() {
 func (m *sessionManager) deleteExpired(now time.Time) {
 	m.mu.Lock()
 	changed := false
+	removed := make([]string, 0)
 
 	for id, current := range m.sessions {
 		if now.After(current.ExpiresAt) {
 			delete(m.sessions, id)
+			removed = append(removed, id)
 			if current.Retain {
 				changed = true
 			}
@@ -378,6 +418,7 @@ func (m *sessionManager) deleteExpired(now time.Time) {
 			m.logPersistError("cleanup expired retained sessions", err)
 		}
 	}
+	m.notifyRemoved(removed...)
 }
 
 func (m *sessionManager) loadPersisted() error {
diff --git a/internal/webserver/backend.go b/internal/webserver/backend.go
index c8ea5587..9963a626 100644
--- a/internal/webserver/backend.go
+++ b/internal/webserver/backend.go
@@ -19,53 +19,82 @@ import (
 	"github.com/autobrr/upbrr/internal/authmaterial"
 	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/config/importer"
-	"github.com/autobrr/upbrr/internal/configstore"
-	"github.com/autobrr/upbrr/internal/cookies"
 	"github.com/autobrr/upbrr/internal/core"
 	internalerrors "github.com/autobrr/upbrr/internal/errors"
 	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/guiapp"
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/imagehostpolicy"
+	imagehostpolicy "github.com/autobrr/upbrr/internal/imagehosting/policy"
 	"github.com/autobrr/upbrr/internal/logging"
-	"github.com/autobrr/upbrr/internal/paths"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
+	paths "github.com/autobrr/upbrr/internal/pathing/layout"
 	"github.com/autobrr/upbrr/internal/services/bdinfo"
 	"github.com/autobrr/upbrr/internal/services/db"
-	"github.com/autobrr/upbrr/internal/trackerauth"
-	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/internal/sourcelayout"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
+	sharedjobs "github.com/autobrr/upbrr/internal/webserver/jobs"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 const previewTimeout = 30 * time.Minute
 
+// metadataPreparationRequest is the transport-neutral command shared by prepare
+// and reset routes for one browser-selected source.
+type metadataPreparationRequest struct {
+	// CorrelationID binds emitted progress to the initiating browser command.
+	CorrelationID string
+	// Path is the selected host filesystem source path.
+	Path string
+	// SourceLookupURL optionally supplies tracker or provider lookup evidence.
+	SourceLookupURL string
+	// Overrides contains explicit external identity selections.
+	Overrides api.ExternalIDOverrides
+	// NameOverrides contains explicit release-name selections.
+	NameOverrides api.ReleaseNameOverrides
+	// Playlist carries direct Blu-ray playlist selection state.
+	Playlist api.PlaylistInstruction
+	// ConfirmBDMVRescan permits replacement of a partial cached Blu-ray analysis.
+	ConfirmBDMVRescan bool
+}
+
+// blurayCandidateSelectionRequest selects one candidate within a correlated preparation attempt.
+type blurayCandidateSelectionRequest struct {
+	// CorrelationID binds emitted progress to the initiating browser command.
+	CorrelationID string
+	// Path is the selected host filesystem source path.
+	Path string
+	// ReleaseID identifies the candidate returned by the current preview.
+	ReleaseID string
+}
+
+func newTrackerAuthService(cfg config.Config, logger api.Logger) *trackerauth.Service {
+	return trackerauth.NewServiceWithRegistryAndLogger(cfg, trackerimpl.MustNewRegistry(), logger)
+}
+
 // Backend owns the embedded web API runtime and request-scoped background jobs.
 type Backend struct {
-	runtimeMu   sync.RWMutex
-	cfg         config.Config
-	core        api.Core
-	coreInitErr error
-	logger      *logging.Logger
-	repo        *db.SQLiteRepository
-	hub         *eventHub
+	runtimeMu         sync.RWMutex
+	cfg               config.Config
+	runtimeGeneration uint64
+	capabilities      CoreCapabilities
+	coreOwner         LifecycleOwner
+	coreInitErr       error
+	logger            *logging.Logger
+	repo              *db.SQLiteRepository
+	hub               *eventHub
 
 	streamMu sync.Mutex
 	streams  map[string]*backendLogStream
 	streamWG sync.WaitGroup
 
-	dupeMu sync.Mutex
-	dupes  map[string]*dupeCheckJob
-	dupeWG sync.WaitGroup
-
-	uploadMu sync.Mutex
-	uploads  map[string]*trackerUploadJob
-	uploadWG sync.WaitGroup
-
-	dvdMenuMu sync.Mutex
-	dvdMenus  map[string]*dvdMenuCaptureJob
-	dvdMenuWG sync.WaitGroup
+	// jobEngine owns session-scoped duplicate-check and tracker-upload jobs.
+	jobEngine  *sharedjobs.Engine
+	jobOwnerMu sync.Mutex
+	jobOwners  map[string]*sharedjobs.OwnerHandle
+	reviewMu   sync.Mutex
+	reviews    *UploadReviewRegistry
 
-	sharedCookieMigrator func(context.Context, string, api.Logger) error
+	activationInitMu sync.Mutex
+	activator        *RuntimeActivator
 }
 
 type backendLogStream struct {
@@ -78,11 +107,15 @@ type backendLogStream struct {
 }
 
 type runOptions struct {
-	Debug       bool
 	NoSeed      bool
 	RunLogLevel string
 }
 
+// logExclusions stores muted log patterns for the WebUI.
+type logExclusions struct {
+	Patterns []string `json:"patterns"`
+}
+
 // NewBackend constructs a Backend using a background context.
 func NewBackend(cfg config.Config, hub *eventHub) (*Backend, error) {
 	return NewBackendWithContext(context.Background(), cfg, hub)
@@ -111,50 +144,68 @@ func NewBackendWithContext(ctx context.Context, cfg config.Config, hub *eventHub
 		return nil, fmt.Errorf("web: %w", err)
 	}
 
-	var coreSvc api.Core
+	var capabilities CoreCapabilities
+	var coreOwner LifecycleOwner
 	var coreInitErr error
 	if err := cfg.Validate(); err != nil {
 		coreInitErr = err
 		logger.Warnf("web: config invalid, core disabled until settings are fixed: %v", err)
 	} else {
-		coreSvc, err = core.NewWithContext(ctx, api.CoreDependencies{
+		coreSvc, coreErr := core.NewWithContext(ctx, api.CoreDependencies{
 			Config: cfg,
 			Logger: logger,
 			Services: api.ServiceSet{
 				Filesystem: filesystem.NewValidator(),
 			},
-			Repository: repo,
+			Repository:      repo.RepositoryCapabilities(),
+			RepositoryOwner: repo,
 		})
-		if err != nil {
+		if coreErr != nil {
 			_ = repo.Close()
 			_ = logger.Close()
-			return nil, fmt.Errorf("web: %w", err)
+			return nil, fmt.Errorf("web: %w", coreErr)
+		}
+		capabilities, coreOwner = BindCoreCapabilities(coreSvc)
+	}
+
+	backend := &Backend{
+		cfg:               cfg,
+		runtimeGeneration: AllocateRuntimeGenerationID(),
+		capabilities:      capabilities,
+		coreOwner:         coreOwner,
+		coreInitErr:       coreInitErr,
+		logger:            logger,
+		repo:              repo,
+		hub:               hub,
+		streams:           make(map[string]*backendLogStream),
+		jobOwners:         make(map[string]*sharedjobs.OwnerHandle),
+	}
+	if _, err := backend.runtimeActivator(); err != nil {
+		if coreOwner != nil {
+			_ = coreOwner.Close()
 		}
+		_ = repo.Close()
+		_ = logger.Close()
+		return nil, fmt.Errorf("web: %w", err)
 	}
-
-	return &Backend{
-		cfg:         cfg,
-		core:        coreSvc,
-		coreInitErr: coreInitErr,
-		logger:      logger,
-		repo:        repo,
-		hub:         hub,
-		streams:     make(map[string]*backendLogStream),
-		dupes:       make(map[string]*dupeCheckJob),
-		uploads:     make(map[string]*trackerUploadJob),
-		dvdMenus:    make(map[string]*dvdMenuCaptureJob),
-	}, nil
+	backend.jobEngine = sharedjobs.New(webJobSink{hub: hub, logger: logger}, sharedjobs.Config{
+		UploadProgress: sharedjobs.UploadProgressPolicy{
+			MinInterval:      trackerUploadSnapshotThrottle,
+			HashRateDeltaMiB: trackerUploadHashRateEmitDeltaMiB,
+		},
+	})
+	return backend, nil
 }
 
 // Close stops active background work and releases runtime, repository, and log resources.
 func (b *Backend) Close() error {
 	b.stopAllLogStreams()
-	b.stopAllDupeJobs()
-	b.stopAllUploadJobs()
-	b.stopAllDVDMenuJobs()
+	if b.jobEngine != nil {
+		b.jobEngine.Close()
+	}
 	rt := b.runtimeSnapshot()
-	if rt.core != nil {
-		_ = rt.core.Close()
+	if rt.coreOwner != nil {
+		_ = rt.coreOwner.Close()
 	}
 	if b.repo != nil {
 		_ = b.repo.Close()
@@ -165,119 +216,215 @@ func (b *Backend) Close() error {
 	return nil
 }
 
-func (b *Backend) requireCore() error {
-	_, err := b.requireRuntime()
-	return err
-}
-
-func (b *Backend) requireHistoryRepo() error {
-	if b == nil || b.repo == nil {
-		return errors.New("history repository not initialized")
-	}
-	return nil
-}
-
+// DetectDiscType classifies the selected host filesystem release path.
 func (b *Backend) DetectDiscType(ctx context.Context, path string) (string, error) {
 	if strings.TrimSpace(path) == "" {
 		return "", errors.New("path is required")
 	}
 	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
-	return wrapWebResult(filesystem.DetectDiscType(ctx, path))
+	layout, err := sourcelayout.Resolve(ctx, path)
+	if err != nil {
+		return wrapWebResult("", err)
+	}
+	return layout.DiscType, nil
 }
 
-func (b *Backend) FetchMetadata(sessionID string, path string, sourceLookupURL string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, confirmBDMVRescan bool) (api.MetadataPreview, error) {
+// withPreparationProgress installs the sole WebUI progress boundary. It
+// requires correlation, sanitizes display text, timestamps updates, and emits
+// them only to the initiating session.
+func (b *Backend) withPreparationProgress(ctx context.Context, sessionID string, correlationID string) (context.Context, error) {
+	correlationID = strings.TrimSpace(correlationID)
+	if correlationID == "" {
+		return nil, errors.New("preparation correlation ID is required")
+	}
+	progressCtx := api.WithPreparationProgressReporter(ctx, func(update api.PreparationProgressUpdate) {
+		update.CorrelationID = correlationID
+		update.Label = logging.SanitizeMessage(strings.TrimSpace(update.Label))
+		update.Message = logging.SanitizeMessage(strings.TrimSpace(update.Message))
+		update.Timestamp = time.Now().UTC().Format(time.RFC3339Nano)
+		b.hub.Emit(sessionID, "preparation:progress", update)
+	})
+	progressCtx = bdinfo.WithProgressReporter(progressCtx, func(line string) {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			return
+		}
+		api.EmitPreparationProgress(
+			progressCtx,
+			api.NewPreparationProgressUpdate(api.PreparationPhaseBDInfo, api.PreparationProgressRunning, line),
+		)
+	})
+	return progressCtx, nil
+}
+
+// withImageUploadProgress installs the WebUI image-host progress boundary. It
+// correlates, sanitizes, timestamps, and scopes advisory updates to one session.
+func (b *Backend) withImageUploadProgress(ctx context.Context, sessionID string, correlationID string) (context.Context, error) {
+	correlationID = strings.TrimSpace(correlationID)
+	if correlationID == "" {
+		return nil, errors.New("image upload correlation ID is required")
+	}
+	return api.WithImageUploadProgressReporter(ctx, func(update api.ImageUploadProgressUpdate) {
+		update.CorrelationID = correlationID
+		update.AttemptID = logging.SanitizeMessage(strings.TrimSpace(update.AttemptID))
+		update.Host = logging.SanitizeMessage(strings.TrimSpace(update.Host))
+		update.UsageScope = logging.SanitizeMessage(strings.TrimSpace(update.UsageScope))
+		for index := range update.Trackers {
+			update.Trackers[index] = logging.SanitizeMessage(strings.TrimSpace(update.Trackers[index]))
+		}
+		update.Message = logging.SanitizeMessage(strings.TrimSpace(update.Message))
+		update.Timestamp = time.Now().UTC().Format(time.RFC3339Nano)
+		b.hub.Emit(sessionID, "image-upload:progress", update)
+	}), nil
+}
+
+// FetchMetadata prepares and caches a metadata preview for the selected release
+// path while emitting correlation-scoped progress to sessionID.
+func (b *Backend) FetchMetadata(
+	ctx context.Context,
+	sessionID string,
+	command metadataPreparationRequest,
+) (api.MetadataPreview, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return api.MetadataPreview{}, err
 	}
-	trimmedPath := strings.TrimSpace(path)
+	metadataCore, err := rt.metadataCore()
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	trimmedPath := strings.TrimSpace(command.Path)
 	if trimmedPath == "" {
 		return api.MetadataPreview{}, errors.New("path is required")
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
-	progressCtx := api.WithMetadataProgressReporter(ctx, func(update api.MetadataProgressUpdate) {
-		if strings.TrimSpace(update.Path) == "" {
-			update.Path = trimmedPath
-		}
-		if strings.TrimSpace(update.Timestamp) == "" {
-			update.Timestamp = time.Now().UTC().Format(time.RFC3339)
-		}
-		b.hub.Emit(sessionID, "metadata:progress", update)
-	})
+	progressCtx, err := b.withPreparationProgress(ctx, sessionID, command.CorrelationID)
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
 
 	req := api.Request{
-		Paths:           []string{trimmedPath},
-		Mode:            api.ModeGUI,
-		Trackers:        append([]string{}, trackersList...),
-		SourceLookupURL: strings.TrimSpace(sourceLookupURL),
+		SourcePath:      trimmedPath,
+		SourceLookupURL: strings.TrimSpace(command.SourceLookupURL),
 		Options:         rt.baseUploadOptions(),
 
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-		ConfirmBDMVRescan:    confirmBDMVRescan,
+		ExternalIDOverrides:  command.Overrides,
+		ReleaseNameOverrides: command.NameOverrides,
+		PlaylistInstruction:  command.Playlist,
+		ConfirmBDMVRescan:    command.ConfirmBDMVRescan,
 	}
 
-	return wrapWebResult(rt.core.FetchMetadataPreview(progressCtx, req))
+	preparationCore, err := rt.releasePreparationCore()
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	_, ref, err := PrepareGeneration(progressCtx, preparationCore, req, api.PreparationIntentPreview)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("web: %w", err)
+	}
+	preview, err := metadataCore.FetchAcceptedMetadataPreview(progressCtx, ref)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("web: %w", err)
+	}
+	preview.ReleaseNameOverrides = command.NameOverrides
+	return preview, nil
 }
 
-type blurayCandidateSelector interface {
-	SelectBlurayCandidate(ctx context.Context, sourcePath string, releaseID string) (api.MetadataPreview, error)
+// PrepareRelease creates or reuses one canonical prepared-release generation.
+func (b *Backend) PrepareRelease(input api.PrepareInput) (api.PrepareResult, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.PrepareResult{}, err
+	}
+	preparationCore, err := rt.releasePreparationCore()
+	if err != nil {
+		return api.PrepareResult{}, err
+	}
+	if strings.TrimSpace(input.SourcePath) == "" {
+		return api.PrepareResult{}, errors.New("path is required")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	defer cancel()
+	return wrapWebResult(preparationCore.PrepareRelease(ctx, input))
 }
 
-func (b *Backend) SelectBlurayCandidate(path string, releaseID string) (api.MetadataPreview, error) {
-	if strings.TrimSpace(path) == "" {
+// SelectBlurayCandidate updates the prepared release with the chosen Blu-ray
+// metadata candidate and emits correlation-scoped progress to sessionID.
+func (b *Backend) SelectBlurayCandidate(
+	ctx context.Context,
+	sessionID string,
+	command blurayCandidateSelectionRequest,
+) (api.MetadataPreview, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	selectionCore, err := rt.selectionCore()
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	if strings.TrimSpace(command.Path) == "" {
 		return api.MetadataPreview{}, errors.New("path is required")
 	}
-	if strings.TrimSpace(releaseID) == "" {
+	if strings.TrimSpace(command.ReleaseID) == "" {
 		return api.MetadataPreview{}, errors.New("release ID is required")
 	}
-	if err := b.requireCore(); err != nil {
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
+	defer cancel()
+	progressCtx, err := b.withPreparationProgress(ctx, sessionID, command.CorrelationID)
+	if err != nil {
 		return api.MetadataPreview{}, err
 	}
-	selector, ok := b.currentCore().(blurayCandidateSelector)
-	if !ok {
-		return api.MetadataPreview{}, errors.New("blu-ray candidate selection is unavailable in this build")
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
-	defer cancel()
-	return wrapWebResult(selector.SelectBlurayCandidate(ctx, path, releaseID))
+	finish := api.BeginPreparationProgress(progressCtx, api.PreparationPhaseCandidateSelection, "Applying Blu-ray candidate selection.")
+	preview, err := selectionCore.SelectBlurayCandidate(progressCtx, command.Path, command.ReleaseID)
+	finish(err)
+	return wrapWebResult(preview, err)
 }
 
-func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, confirmBDMVRescan bool) (api.MetadataPreview, error) {
-	if err := b.requireCore(); err != nil {
+// ResetMetadata removes persisted source artifacts, then rebuilds prepared
+// metadata using the supplied overrides and correlation-scoped progress.
+func (b *Backend) ResetMetadata(
+	ctx context.Context,
+	sessionID string,
+	command metadataPreparationRequest,
+) (api.MetadataPreview, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	metadataCore, err := rt.metadataCore()
+	if err != nil {
 		return api.MetadataPreview{}, err
 	}
 	if b.repo == nil {
 		return api.MetadataPreview{}, errors.New("config repository not initialized")
 	}
-	trimmedPath := strings.TrimSpace(path)
+	trimmedPath := strings.TrimSpace(command.Path)
 	if trimmedPath == "" {
 		return api.MetadataPreview{}, errors.New("path is required")
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
-	progressCtx := api.WithMetadataProgressReporter(ctx, func(update api.MetadataProgressUpdate) {
-		if strings.TrimSpace(update.Path) == "" {
-			update.Path = trimmedPath
-		}
-		if strings.TrimSpace(update.Timestamp) == "" {
-			update.Timestamp = time.Now().UTC().Format(time.RFC3339)
-		}
-		b.hub.Emit(sessionID, "metadata:progress", update)
-	})
+	progressCtx, err := b.withPreparationProgress(ctx, sessionID, command.CorrelationID)
+	if err != nil {
+		return api.MetadataPreview{}, err
+	}
+	resetFinish := api.BeginPreparationProgress(progressCtx, api.PreparationPhaseResetCleanup, "Removing previous metadata artifacts.")
 
-	tmpRoot, err := db.Subdir(b.currentConfig().MainSettings.DBPath, "tmp")
+	tmpRoot, err := db.Subdir(rt.cfg.MainSettings.DBPath, "tmp")
 	if err != nil {
+		resetFinish(err)
 		return api.MetadataPreview{}, fmt.Errorf("reset metadata: resolve tmp dir: %w", err)
 	}
 
 	artifactPaths := make([]string, 0)
 	shots, err := b.repo.ListScreenshotsByPath(ctx, trimmedPath)
 	if err != nil {
+		resetFinish(err)
 		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list screenshots: %w", err)
 	}
 	for _, shot := range shots {
@@ -285,6 +432,7 @@ func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL s
 	}
 	uploaded, err := b.repo.ListUploadedImagesByPath(ctx, trimmedPath)
 	if err != nil {
+		resetFinish(err)
 		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list uploaded images: %w", err)
 	}
 	for _, image := range uploaded {
@@ -292,6 +440,7 @@ func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL s
 	}
 	finals, err := b.repo.ListFinalSelections(ctx, trimmedPath)
 	if err != nil {
+		resetFinish(err)
 		return api.MetadataPreview{}, fmt.Errorf("reset metadata: list final selections: %w", err)
 	}
 	for _, image := range finals {
@@ -300,21 +449,19 @@ func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL s
 	artifactPaths = slices.Compact(artifactPaths)
 
 	tmpDirs := make(map[string]struct{})
-	fallbackBase := paths.ReleaseTempBase(api.PreparedMetadata{}, trimmedPath)
+	fallbackBase := paths.ReleaseTempBaseFor(trimmedPath, api.ReleaseInfo{})
 	tmpDirs[filepath.Join(tmpRoot, fallbackBase)] = struct{}{}
 	stored, err := b.repo.GetByPath(ctx, trimmedPath)
 	if err == nil {
-		releaseBase := paths.ReleaseTempBase(api.PreparedMetadata{
-			Release: api.ReleaseInfo{
-				Title:    stored.Title,
-				Alt:      stored.Alt,
-				Year:     stored.Year,
-				Category: string(stored.Category),
-				Source:   stored.Source,
-				Type:     stored.Type,
-				Group:    stored.Group,
-			},
-		}, trimmedPath)
+		releaseBase := paths.ReleaseTempBaseFor(trimmedPath, api.ReleaseInfo{
+			Title:    stored.Title,
+			Alt:      stored.Alt,
+			Year:     stored.Year,
+			Category: string(stored.Category),
+			Source:   stored.Source,
+			Type:     stored.Type,
+			Group:    stored.Group,
+		})
 		tmpDirs[filepath.Join(tmpRoot, releaseBase)] = struct{}{}
 	}
 	for _, filePath := range artifactPaths {
@@ -324,6 +471,7 @@ func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL s
 		}
 	}
 	if err := b.repo.PurgeContentData(ctx, trimmedPath); err != nil {
+		resetFinish(err)
 		return api.MetadataPreview{}, fmt.Errorf("reset metadata: purge sqlite: %w", err)
 	}
 	for _, filePath := range artifactPaths {
@@ -332,52 +480,58 @@ func (b *Backend) ResetMetadata(sessionID string, path string, sourceLookupURL s
 	for dir := range tmpDirs {
 		_ = removeIfWithinRoot(tmpRoot, dir, true)
 	}
+	resetFinish(nil)
 
 	req := api.Request{
-		Paths:           []string{trimmedPath},
-		Mode:            api.ModeGUI,
-		Trackers:        append([]string{}, trackersList...),
-		SourceLookupURL: strings.TrimSpace(sourceLookupURL),
-		Options:         b.baseUploadOptions(),
+		SourcePath:      trimmedPath,
+		SourceLookupURL: strings.TrimSpace(command.SourceLookupURL),
+		Options:         rt.baseUploadOptions(),
 
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-		ConfirmBDMVRescan:    confirmBDMVRescan,
+		ExternalIDOverrides:  command.Overrides,
+		ReleaseNameOverrides: command.NameOverrides,
+		PlaylistInstruction:  command.Playlist,
+		ConfirmBDMVRescan:    command.ConfirmBDMVRescan,
 	}
-	return wrapWebResult(b.currentCore().FetchMetadataPreview(progressCtx, req))
-}
-
-func (b *Backend) CheckDupes(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string) (api.DupeCheckSummary, error) {
-	if err := b.requireCore(); err != nil {
-		return api.DupeCheckSummary{}, err
+	preparationCore, err := rt.releasePreparationCore()
+	if err != nil {
+		return api.MetadataPreview{}, err
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
-	defer cancel()
-	req := api.Request{
-		Paths:    []string{strings.TrimSpace(path)},
-		Mode:     api.ModeGUI,
-		Trackers: append([]string{}, trackersList...),
-		Options:  b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	_, ref, err := PrepareGeneration(progressCtx, preparationCore, req, api.PreparationIntentPreview)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("web: %w", err)
+	}
+	preview, err := metadataCore.FetchAcceptedMetadataPreview(progressCtx, ref)
+	if err != nil {
+		return api.MetadataPreview{}, fmt.Errorf("web: %w", err)
 	}
-	return wrapWebResult(b.currentCore().CheckDupes(ctx, req))
+	preview.ReleaseNameOverrides = command.NameOverrides
+	return preview, nil
 }
 
-func (b *Backend) FetchPreparation(sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, ignoreDupesFor []string) (api.PreparationPreview, error) {
-	if err := b.requireCore(); err != nil {
+// FetchPreparation returns tracker review data prepared from the current release snapshot.
+func (b *Backend) FetchPreparation(
+	sessionID string,
+	path string,
+	overrides api.ExternalIDOverrides,
+	nameOverrides api.ReleaseNameOverrides,
+	trackersList []string,
+	ignoreDupesFor []string,
+) (api.PreparationPreview, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.PreparationPreview{}, err
+	}
+	preparationCore, err := rt.preparationCore()
+	if err != nil {
 		return api.PreparationPreview{}, err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
 	req := api.Request{
-		Paths:          []string{strings.TrimSpace(path)},
-		Mode:           api.ModeGUI,
-		Trackers:       append([]string{}, trackersList...),
-		IgnoreDupesFor: normalizeTrackerList(ignoreDupesFor),
-		Options:        b.baseUploadOptions(),
-
+		SourcePath:           strings.TrimSpace(path),
+		Trackers:             append([]string{}, trackersList...),
+		IgnoreDupesFor:       normalizeTrackerList(ignoreDupesFor),
+		Options:              rt.baseUploadOptions(),
 		ExternalIDOverrides:  overrides,
 		ReleaseNameOverrides: nameOverrides,
 	}
@@ -390,274 +544,427 @@ func (b *Backend) FetchPreparation(sessionID string, path string, overrides api.
 			"line": line,
 		})
 	})
-	return wrapWebResult(b.currentCore().FetchPreparationPreview(progressCtx, req))
+	ref, err := prepareWebReleaseRef(progressCtx, rt, req, api.PreparationIntentDescription)
+	if err != nil {
+		return api.PreparationPreview{}, err
+	}
+	return wrapWebResult(preparationCore.FetchAcceptedPreparationPreview(progressCtx, api.DescriptionInput{
+		Release:  ref,
+		Trackers: append([]string(nil), trackersList...),
+		Options:  req.Options,
+	}))
 }
 
-func (b *Backend) FetchTrackerDryRun(sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string) (api.TrackerDryRunPreview, error) {
+// FetchTrackerDryRun runs prepared payload previews for selected trackers.
+func (b *Backend) FetchTrackerDryRun(
+	ctx context.Context,
+	sessionID string,
+	dupeJobID string,
+	release api.ReleaseRef,
+	trackersList []string,
+	ignoreDupesFor []string,
+	questionnaireAnswers map[string]map[string]string,
+	descriptionGroups []api.DescriptionBuilderGroup,
+	noSeed bool,
+	runLogLevel string,
+) (api.TrackerDryRunPreview, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return api.TrackerDryRunPreview{}, err
 	}
-	runOpts, err := b.buildRunOptions(debug, noSeed, runLogLevel)
+	if !rt.capabilities.PreparedDryRunReady() {
+		return api.TrackerDryRunPreview{}, ErrPreparedDryRunUnavailable
+	}
+	runOpts, err := b.buildRunOptions(noSeed, runLogLevel)
 	if err != nil {
 		return api.TrackerDryRunPreview{}, err
 	}
-	b.logDebugf("web: tracker dry-run request path=%s debug=%t no_seed=%t run_log_level=%s", strings.TrimSpace(path), debug, noSeed, runOpts.RunLogLevel)
-	runCore, runLogger, err := b.buildRunCoreFromSnapshot(rt, runOpts)
+	release, err = normalizeExactRelease(release, api.OperationKindDryRun)
 	if err != nil {
 		return api.TrackerDryRunPreview{}, err
 	}
-	defer func() {
-		_ = runCore.Close()
-		_ = runLogger.Close()
-	}()
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	b.logDebugf("web: tracker dry-run request path=%s no_seed=%t run_log_level=%s", release.SourcePath, noSeed, runOpts.RunLogLevel)
+	resolvedTrackers := normalizeTrackerList(trackersList)
+	duplicateEvidence, err := b.acceptedDryRunDuplicateEvidence(sessionID, dupeJobID, release, rt.generationID, resolvedTrackers)
+	if err != nil {
+		return api.TrackerDryRunPreview{}, err
+	}
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
 	req := api.Request{
-		Paths:                       []string{strings.TrimSpace(path)},
-		Mode:                        api.ModeGUI,
 		DescriptionGroups:           api.CloneDescriptionBuilderGroups(descriptionGroups),
-		Trackers:                    append([]string{}, trackersList...),
+		Trackers:                    append([]string{}, resolvedTrackers...),
 		IgnoreDupesFor:              normalizeTrackerList(ignoreDupesFor),
-		IgnoreTrackerRuleFailures:   false,
 		Options:                     buildRunUploadOptions(rt.cfg, runOpts),
-		ExternalIDOverrides:         overrides,
-		ReleaseNameOverrides:        nameOverrides,
 		TrackerQuestionnaireAnswers: cloneQuestionnaireAnswers(questionnaireAnswers),
 	}
-	req.Options.DryRun = true
-	if err := guishared.SeedRunCorePreparedMeta(ctx, rt.core, runCore, req); err != nil {
-		return api.TrackerDryRunPreview{}, fmt.Errorf("web: %w", err)
-	}
 	progressCtx := api.WithUploadProgressReporter(ctx, func(update api.UploadProgressUpdate) {
 		b.hub.Emit(sessionID, trackerUploadProgressEvent, update)
 	})
+	if rt.logger != nil {
+		operationLogger, scopeErr := logging.NewOperationLogger(rt.logger, runOpts.RunLogLevel)
+		if scopeErr != nil {
+			return api.TrackerDryRunPreview{}, fmt.Errorf("web: scoped dry-run logger: %w", scopeErr)
+		}
+		progressCtx = logging.WithOperationLogger(progressCtx, operationLogger)
+	}
 	progressCtx = bdinfo.WithProgressReporter(progressCtx, func(line string) {
 		if strings.TrimSpace(line) == "" {
 			return
 		}
 		b.hub.Emit(sessionID, "bdinfo:progress", map[string]string{
-			"path": strings.TrimSpace(path),
+			"path": release.SourcePath,
 			"line": line,
 		})
 	})
-	return wrapWebResult(runCore.FetchTrackerDryRunPreview(progressCtx, req))
+	return wrapWebResult(rt.capabilities.DryRun.RunAcceptedTrackerDryRun(progressCtx, api.TrackerDryRunPlan{
+		Input: api.TrackerDryRunInput{
+			Release:                release,
+			Trackers:               append([]string(nil), req.Trackers...),
+			IgnoreDupesFor:         append([]string(nil), req.IgnoreDupesFor...),
+			QuestionnaireAnswers:   cloneQuestionnaireAnswers(req.TrackerQuestionnaireAnswers),
+			DescriptionGroups:      api.CloneDescriptionBuilderGroups(req.DescriptionGroups),
+			TrackerConfigOverrides: req.TrackerConfigOverrides,
+			TrackerSiteOverrides:   req.TrackerSiteOverrides,
+			ImageHostOverrides:     req.ImageHostOverrides,
+			TorrentOverrides:       req.TorrentOverrides,
+			Options:                req.Options,
+		},
+		Duplicate: duplicateEvidence,
+	}))
 }
 
-func (b *Backend) FetchDescriptionBuilder(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, ignoreDupesFor []string) (api.DescriptionBuilderPreview, error) {
-	if err := b.requireCore(); err != nil {
+// acceptedDryRunDuplicateEvidence returns duplicate evidence only when the
+// retained job belongs to the session and matches the exact release, runtime
+// generation, and ordered tracker selection used by the dry run.
+func (b *Backend) acceptedDryRunDuplicateEvidence(
+	sessionID string,
+	jobID string,
+	release api.ReleaseRef,
+	runtimeGeneration uint64,
+	trackers []string,
+) (api.AcceptedDuplicateEvidence, error) {
+	missing := func(message string, cause error) (api.AcceptedDuplicateEvidence, error) {
+		return api.AcceptedDuplicateEvidence{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureMissingPrerequisite,
+			Operation: api.OperationKindDryRun,
+			Message:   message,
+			Recovery:  api.OperationRecoveryCompletePrerequisite,
+		}, cause)
+	}
+	if strings.TrimSpace(jobID) == "" || b == nil || b.jobEngine == nil {
+		return missing("Run duplicate checking before starting a dry run.", errors.New("duplicate job is required"))
+	}
+	snapshot, err := b.jobEngine.DupeSnapshot(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID))
+	if err != nil {
+		return missing("Duplicate-check results are unavailable. Run duplicate checking again.", err)
+	}
+	status := strings.ToLower(strings.TrimSpace(snapshot.Status))
+	if status != sharedjobs.StatusCompleted && status != sharedjobs.StatusCompletedWithErrors {
+		return missing("Duplicate checking must finish before starting a dry run.", fmt.Errorf("duplicate job status is %s", status))
+	}
+	if snapshot.Release != release {
+		return api.AcceptedDuplicateEvidence{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureStaleGeneration,
+			Operation: api.OperationKindDryRun,
+			Message:   "Duplicate-check results are stale. Run duplicate checking again.",
+			Recovery:  api.OperationRecoveryCompletePrerequisite,
+		}, errors.New("duplicate job release does not match dry-run release"))
+	}
+	if snapshot.RuntimeGeneration != runtimeGeneration {
+		return api.AcceptedDuplicateEvidence{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureStaleGeneration,
+			Operation: api.OperationKindDryRun,
+			Message:   "Runtime settings changed. Run duplicate checking again.",
+			Recovery:  api.OperationRecoveryCompletePrerequisite,
+		}, errors.New("duplicate job runtime generation is stale"))
+	}
+	requested := normalizeTrackerList(snapshot.RequestedTrackers)
+	if !slices.Equal(requested, trackers) {
+		return missing(
+			"Duplicate-check results do not match the selected trackers. Run duplicate checking again.",
+			errors.New("duplicate job tracker selection does not match dry-run selection"),
+		)
+	}
+	return api.NewAcceptedDuplicateEvidence(release, requested, snapshot.Summary), nil
+}
+
+// FetchDescriptionBuilder returns editable tracker description groups for the prepared release.
+func (b *Backend) FetchDescriptionBuilder(
+	release api.ReleaseRef,
+	trackersList []string,
+) (api.DescriptionBuilderPreview, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, err
+	}
+	descriptionCore, err := rt.descriptionCore()
+	if err != nil {
 		return api.DescriptionBuilderPreview{}, err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := api.Request{
-		Paths:          []string{strings.TrimSpace(path)},
-		Mode:           api.ModeGUI,
-		Trackers:       append([]string{}, trackersList...),
-		IgnoreDupesFor: normalizeTrackerList(ignoreDupesFor),
-		Options:        b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindDescription)
+	if err != nil {
+		return api.DescriptionBuilderPreview{}, err
 	}
-	return wrapWebResult(b.currentCore().FetchDescriptionBuilderPreview(ctx, req))
+	return wrapWebResult(descriptionCore.FetchAcceptedDescriptionBuilderPreview(ctx, api.DescriptionInput{
+		Release:  ref,
+		Trackers: append([]string(nil), trackersList...),
+		Options:  rt.baseUploadOptions(),
+	}))
 }
 
+// RenderDescription converts tracker markup into sanitized preview HTML.
 func (b *Backend) RenderDescription(raw string) (string, error) {
-	if err := b.requireCore(); err != nil {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return "", err
+	}
+	descriptionCore, err := rt.descriptionCore()
+	if err != nil {
 		return "", err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebResult(b.currentCore().RenderDescription(ctx, raw))
+	return wrapWebResult(descriptionCore.RenderDescription(ctx, raw))
 }
 
-func (b *Backend) SaveDescriptionOverride(path string, groupKey string, raw string, trackers []string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (api.DescriptionBuilderGroup, error) {
-	if err := b.requireCore(); err != nil {
+// SaveDescriptionOverride publishes edited description groups to the prepared release.
+func (b *Backend) SaveDescriptionOverride(
+	release api.ReleaseRef,
+	groupKey string,
+	raw string,
+	trackers []string,
+) (api.DescriptionBuilderGroup, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, err
+	}
+	descriptionCore, err := rt.descriptionCore()
+	if err != nil {
 		return api.DescriptionBuilderGroup{}, err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebResult(b.currentCore().SaveDescriptionOverride(ctx, api.Request{
-		Paths:                    []string{strings.TrimSpace(path)},
-		Mode:                     api.ModeGUI,
-		DescriptionOverrideGroup: strings.TrimSpace(groupKey),
-		Trackers:                 append([]string{}, trackers...),
-		ExternalIDOverrides:      overrides,
-		ReleaseNameOverrides:     nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindDescription)
+	if err != nil {
+		return api.DescriptionBuilderGroup{}, err
+	}
+	return wrapWebResult(descriptionCore.SaveAcceptedDescriptionOverride(ctx, api.DescriptionInput{
+		Release:  ref,
+		Trackers: append([]string(nil), trackers...),
+		GroupKey: strings.TrimSpace(groupKey),
+		Options:  rt.baseUploadOptions(),
 	}, raw))
 }
 
-func (b *Backend) DiscoverPlaylists(path string) ([]api.PlaylistInfo, error) {
-	if err := b.requireCore(); err != nil {
+// DiscoverPlaylists returns Blu-ray playlists available under the selected release path.
+func (b *Backend) DiscoverPlaylists(ctx context.Context, path string) ([]api.PlaylistInfo, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
 		return nil, err
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
-	defer cancel()
-	return wrapWebResult(b.currentCore().DiscoverPlaylists(ctx, path))
-}
-
-func (b *Backend) SavePlaylistSelection(path string, playlists []string, useAll bool) error {
-	if err := b.requireCore(); err != nil {
-		return err
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
-	defer cancel()
-	return wrapWebError(b.currentCore().SavePlaylistSelection(ctx, path, playlists, useAll))
-}
-
-func (b *Backend) LoadPlaylistSelection(path string) (api.PlaylistSelection, error) {
-	if err := b.requireCore(); err != nil {
-		return api.PlaylistSelection{}, err
+	playlistCore, err := rt.playlistCore()
+	if err != nil {
+		return nil, err
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
-	return wrapWebResult(b.currentCore().LoadPlaylistSelection(ctx, path))
+	return wrapWebResult(playlistCore.DiscoverPlaylists(ctx, path))
 }
 
+// BrowseDirectory lists a host filesystem directory for the requested frontend browse mode.
 func (b *Backend) BrowseDirectory(path string, mode string) (api.BrowseDirectoryResponse, error) {
 	if b == nil {
 		return api.BrowseDirectoryResponse{}, errors.New("backend not initialized")
 	}
-	fallback := guishared.BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
-	return wrapWebResult(guishared.BrowseDirectory(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback))
+	fallback := BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
+	return wrapWebResult(BrowseDirectory(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback))
 }
 
+// BrowseDirectoryWithinRoot lists a directory only when it remains within the authorized host root.
 func (b *Backend) BrowseDirectoryWithinRoot(path string, mode string, root string) (api.BrowseDirectoryResponse, error) {
 	if b == nil {
 		return api.BrowseDirectoryResponse{}, errors.New("backend not initialized")
 	}
-	fallback := guishared.BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
-	return wrapWebResult(guishared.BrowseDirectoryWithinRoot(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback, root))
+	fallback := BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
+	return wrapWebResult(BrowseDirectoryWithinRoot(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback, root))
 }
 
+// BrowseDirectoryWithinRoots lists a directory only when it remains within an authorized host root.
 func (b *Backend) BrowseDirectoryWithinRoots(path string, mode string, roots []string) (api.BrowseDirectoryResponse, error) {
 	if b == nil {
 		return api.BrowseDirectoryResponse{}, errors.New("backend not initialized")
 	}
-	fallback := guishared.BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
-	return wrapWebResult(guishared.BrowseDirectoryWithinRoots(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback, roots))
+	fallback := BrowseDirectoryFallback(b.currentConfig().MainSettings.DBPath)
+	return wrapWebResult(BrowseDirectoryWithinRoots(api.BrowseDirectoryRequest{Path: path, Mode: mode}, fallback, roots))
 }
 
-func (b *Backend) FetchScreenshotPlan(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (api.ScreenshotPlan, error) {
-	if err := b.requireCore(); err != nil {
+// FetchScreenshotPlan returns existing images and capture selections for a prepared release.
+func (b *Backend) FetchScreenshotPlan(release api.ReleaseRef) (api.ScreenshotPlan, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.ScreenshotPlan{}, err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return api.ScreenshotPlan{}, err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return api.ScreenshotPlan{}, err
 	}
-	return wrapWebResult(b.currentCore().FetchScreenshotPlan(ctx, req))
+	return wrapWebResult(screenshotCore.FetchAcceptedScreenshotPlan(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   rt.baseUploadOptions().Screens,
+	}))
 }
 
-func (b *Backend) GenerateScreenshots(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, selections []api.ScreenshotSelection, purpose api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	if err := b.requireCore(); err != nil {
+// GenerateScreenshots captures selected frames and persists the resulting managed images.
+func (b *Backend) GenerateScreenshots(
+	release api.ReleaseRef,
+	selections []api.ScreenshotSelection,
+	purpose api.ScreenshotPurpose,
+) (api.ScreenshotResult, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.ScreenshotResult{}, err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return api.ScreenshotResult{}, err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return api.ScreenshotResult{}, err
 	}
-	return wrapWebResult(b.currentCore().GenerateScreenshots(ctx, req, selections, purpose))
+	return wrapWebResult(screenshotCore.GenerateAcceptedScreenshots(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   rt.baseUploadOptions().Screens,
+		Purpose: purpose,
+	}, selections))
 }
 
-func (b *Backend) PreviewScreenshotFrame(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, timestampSeconds float64) (string, error) {
-	if err := b.requireCore(); err != nil {
+// PreviewScreenshotFrame returns an encoded preview for the requested timestamp in seconds.
+func (b *Backend) PreviewScreenshotFrame(
+	release api.ReleaseRef,
+	timestampSeconds float64,
+) (string, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return "", err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return "", err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return "", err
 	}
-	preview, err := b.currentCore().PreviewScreenshotFrame(ctx, req, timestampSeconds)
+	preview, err := screenshotCore.PreviewAcceptedScreenshotFrame(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   rt.baseUploadOptions().Screens,
+	}, timestampSeconds)
 	if err != nil {
 		return "", fmt.Errorf("web: %w", err)
 	}
 	return "data:image/png;base64," + base64.StdEncoding.EncodeToString(preview.ImageBytes), nil
 }
 
-func (b *Backend) DeleteScreenshot(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, imagePath string) error {
-	if err := b.requireCore(); err != nil {
+// DeleteScreenshot removes one managed screenshot and its prepared-release reference.
+func (b *Backend) DeleteScreenshot(release api.ReleaseRef, imagePath string) error {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().DeleteScreenshot(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return err
+	}
+	return wrapWebError(screenshotCore.DeleteAcceptedScreenshot(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   rt.baseUploadOptions().Screens,
 	}, imagePath))
 }
 
-func (b *Backend) DeleteTrackerImageURL(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, imageURL string) error {
-	if err := b.requireCore(); err != nil {
+// DeleteTrackerImageURL removes one tracker image URL from prepared release metadata.
+func (b *Backend) DeleteTrackerImageURL(release api.ReleaseRef, imageURL string) error {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().DeleteTrackerImageURL(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}, imageURL))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return err
+	}
+	return wrapWebError(screenshotCore.DeleteAcceptedTrackerImageURL(ctx, api.ImageHostingInput{Release: ref}, imageURL))
 }
 
-func (b *Backend) SaveFinalScreenshotSelections(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, images []api.ScreenshotImage) error {
-	if err := b.requireCore(); err != nil {
+// SaveFinalScreenshotSelections persists the ordered image set selected for tracker preparation.
+func (b *Backend) SaveFinalScreenshotSelections(
+	release api.ReleaseRef,
+	images []api.ScreenshotImage,
+) error {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().SaveFinalScreenshotSelections(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return err
+	}
+	return wrapWebError(screenshotCore.SaveAcceptedFinalScreenshotSelections(ctx, api.MediaPlanInput{
+		Release: ref,
+		Count:   rt.baseUploadOptions().Screens,
 	}, images))
 }
 
-func (b *Backend) ImportMenuImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, paths []string) error {
-	if err := b.requireCore(); err != nil {
+// ImportMenuImages copies selected host images into managed DVD menu storage.
+func (b *Backend) ImportMenuImages(release api.ReleaseRef, paths []string) error {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	screenshotCore, err := rt.screenshotCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().ImportMenuImages(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: b.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}, paths))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return err
+	}
+	return wrapWebError(screenshotCore.ImportAcceptedMenuImages(ctx, api.MediaPlanInput{Release: ref}, paths))
 }
 
+// ReadScreenshotImage returns a managed screenshot encoded for frontend display.
 func (b *Backend) ReadScreenshotImage(path string) (string, error) {
 	trimmed := strings.TrimSpace(path)
 	if trimmed == "" {
@@ -673,68 +980,130 @@ func (b *Backend) ReadScreenshotImage(path string) (string, error) {
 	return "data:image/png;base64," + base64.StdEncoding.EncodeToString(payload), nil
 }
 
-func (b *Backend) ListUploadCandidates(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.ScreenshotImage, error) {
+// ListUploadCandidates returns managed screenshots eligible for image-host upload.
+func (b *Backend) ListUploadCandidates(release api.ReleaseRef) ([]api.ScreenshotImage, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return nil, err
 	}
+	hostedImageCore, err := rt.hostedImageCore()
+	if err != nil {
+		return nil, err
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebResult(rt.core.ListUploadCandidates(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return nil, err
+	}
+	return wrapWebResult(hostedImageCore.ListAcceptedUploadCandidates(ctx, api.ImageHostingInput{Release: ref}))
 }
 
-func (b *Backend) ListUploadedImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.UploadedImageLink, error) {
+// ListUploadedImages returns persisted image-host links for the prepared release.
+func (b *Backend) ListUploadedImages(release api.ReleaseRef) ([]api.UploadedImageLink, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return nil, err
 	}
+	hostedImageCore, err := rt.hostedImageCore()
+	if err != nil {
+		return nil, err
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebResult(rt.core.ListUploadedImages(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return nil, err
+	}
+	return wrapWebResult(hostedImageCore.ListAcceptedUploadedImages(ctx, api.ImageHostingInput{Release: ref}))
 }
 
-func (b *Backend) UploadImages(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackersList []string, host string, images []api.ScreenshotImage) (api.UploadImagesResult, error) {
+// UploadImages sends selected managed images to the requested configured host and persists returned links.
+func (b *Backend) UploadImages(
+	ctx context.Context,
+	sessionID string,
+	correlationID string,
+	release api.ReleaseRef,
+	trackersList []string,
+	host string,
+	images []api.ScreenshotImage,
+) (api.UploadImagesResult, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return api.UploadImagesResult{}, err
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
+	hostedImageCore, err := rt.hostedImageCore()
+	if err != nil {
+		return api.UploadImagesResult{}, err
+	}
+	ctx, cancel := context.WithTimeout(ctx, previewTimeout)
 	defer cancel()
-	return wrapWebResult(rt.core.UploadImages(ctx, api.Request{
-		Paths:   []string{path},
-		Mode:    api.ModeGUI,
-		Options: rt.baseUploadOptions(),
-
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-		Trackers:             append([]string{}, trackersList...),
-	}, host, images))
+	progressCtx, err := b.withImageUploadProgress(ctx, sessionID, correlationID)
+	if err != nil {
+		return api.UploadImagesResult{}, err
+	}
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return api.UploadImagesResult{}, err
+	}
+	return wrapWebResult(hostedImageCore.UploadAcceptedImages(progressCtx, api.ImageHostingInput{
+		Release:  ref,
+		Trackers: append([]string(nil), trackersList...),
+		Host:     host,
+	}, images))
 }
 
-func (b *Backend) DeleteUploadedImage(path string, imagePath string, host string) error {
-	if err := b.requireCore(); err != nil {
+// DeleteUploadedImage removes one persisted image-host link from release state.
+func (b *Backend) DeleteUploadedImage(release api.ReleaseRef, imagePath string, host string) error {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	hostedImageCore, err := rt.hostedImageCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().DeleteUploadedImage(ctx, api.Request{
-		Paths: []string{path},
-		Mode:  api.ModeGUI,
-	}, imagePath, host))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return err
+	}
+	return wrapWebError(hostedImageCore.DeleteAcceptedUploadedImage(ctx, api.ImageHostingInput{Release: ref}, imagePath, host))
+}
+
+// normalizeExactRelease trims and validates the source path while preserving
+// the caller's exact prepared generation.
+func normalizeExactRelease(release api.ReleaseRef, operation api.OperationKind) (api.ReleaseRef, error) {
+	release.SourcePath = strings.TrimSpace(release.SourcePath)
+	if release.SourcePath == "" || release.Generation == 0 {
+		return api.ReleaseRef{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureInvalidSource,
+			Operation: operation,
+			Message:   "An exact prepared release is required.",
+			Recovery:  api.OperationRecoveryRefreshRelease,
+		}, errors.New("exact release reference is required"))
+	}
+	return release, nil
+}
+
+// prepareWebReleaseRef creates or reuses canonical preparation and returns only
+// the exact reference needed by the requested browser operation.
+func prepareWebReleaseRef(
+	ctx context.Context,
+	rt backendRuntimeSnapshot,
+	request api.Request,
+	intent api.PreparationIntent,
+) (api.ReleaseRef, error) {
+	preparer, err := rt.releasePreparationCore()
+	if err != nil {
+		return api.ReleaseRef{}, err
+	}
+	_, ref, err := PrepareGeneration(ctx, preparer, request, intent)
+	if err != nil {
+		return api.ReleaseRef{}, fmt.Errorf("web: %w", err)
+	}
+	return ref, nil
 }
 
 // GetConfig returns the current exportable config as JSON with encrypted
@@ -751,8 +1120,7 @@ func (b *Backend) GetConfig() (string, error) {
 // DVD menu capability probe for embedded-web diagnostics.
 func (b *Backend) GetApplicationInfo() (api.ApplicationInfo, error) {
 	rt := b.runtimeSnapshot()
-	provider, _ := rt.core.(api.DVDMenuCapabilityProvider)
-	return guishared.CurrentApplicationInfo(context.Background(), provider), nil
+	return CurrentApplicationInfo(context.Background(), rt.capabilities.DiagnosticProbe), nil
 }
 
 // ExportConfig returns the exportable config, using plaintext secrets only
@@ -775,6 +1143,7 @@ func (b *Backend) ExportConfig() (string, error) {
 	return wrapWebResult(config.ExportToJSON(cfg))
 }
 
+// GetDefaultConfig returns the built-in configuration serialized for the settings editor.
 func (b *Backend) GetDefaultConfig() (string, error) {
 	cfg, err := config.LoadEmbeddedDefaultConfig()
 	if err != nil {
@@ -789,7 +1158,7 @@ func (b *Backend) ListTrackerAuthCapabilities() ([]api.TrackerAuthCapability, er
 	if b == nil {
 		return nil, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Capabilities(context.Background()))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Capabilities(context.Background()))
 }
 
 // GetTrackerAuthStatus reports local auth state for tracker from the current
@@ -798,7 +1167,7 @@ func (b *Backend) GetTrackerAuthStatus(tracker string) (api.TrackerAuthStatus, e
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Status(context.Background(), tracker))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Status(context.Background(), tracker))
 }
 
 // ImportTrackerAuthCookieContent imports browser-supplied cookie content with
@@ -807,7 +1176,7 @@ func (b *Backend) ImportTrackerAuthCookieContent(ctx context.Context, tracker st
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).ImportCookies(ctx, tracker, fileName, content))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).ImportCookies(ctx, tracker, fileName, content))
 }
 
 // TestTrackerAuth validates tracker auth with ctx so canceled web requests stop
@@ -816,7 +1185,7 @@ func (b *Backend) TestTrackerAuth(ctx context.Context, tracker string) (api.Trac
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Validate(ctx, tracker))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Validate(ctx, tracker))
 }
 
 // LoginTrackerAuth attempts credential-based tracker auth with ctx and returns
@@ -825,7 +1194,7 @@ func (b *Backend) LoginTrackerAuth(ctx context.Context, tracker string, req api.
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Login(ctx, tracker, req))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Login(ctx, tracker, req))
 }
 
 // SubmitTrackerAuth2FA completes an active manual 2FA challenge with ctx and
@@ -834,7 +1203,7 @@ func (b *Backend) SubmitTrackerAuth2FA(ctx context.Context, challengeID string,
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Submit2FA(ctx, challengeID, code))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Submit2FA(ctx, challengeID, code))
 }
 
 // DeleteTrackerAuth removes stored tracker cookies and tracker-specific auth
@@ -843,7 +1212,7 @@ func (b *Backend) DeleteTrackerAuth(ctx context.Context, tracker string) (api.Tr
 	if b == nil {
 		return api.TrackerAuthStatus{}, errors.New("backend not initialized")
 	}
-	return wrapWebResult(trackerauth.NewServiceWithLogger(b.currentConfig(), b.currentLogger()).Delete(ctx, tracker))
+	return wrapWebResult(newTrackerAuthService(b.currentConfig(), b.currentLogger()).Delete(ctx, tracker))
 }
 
 // exportableConfig returns the normalized config snapshot and the DB path that
@@ -925,11 +1294,8 @@ func (b *Backend) allowUnencryptedExport(dbPath string) (bool, error) {
 	return false, fmt.Errorf("web: %w", err)
 }
 
-// SaveConfig validates encrypted browser settings, builds the replacement
-// runtime, migrates shared cookies, then persists the non-env config before
-// installing the runtime. Runtime build, migration, or save failures leave the
-// persisted config and active runtime unchanged; env overrides apply only to
-// the installed runtime config.
+// SaveConfig decodes encrypted browser settings and delegates the complete
+// config/runtime transition to the shared runtime activator.
 func (b *Backend) SaveConfig(payload string) error {
 	if b.repo == nil {
 		return errors.New("config repository not initialized")
@@ -938,27 +1304,14 @@ func (b *Backend) SaveConfig(payload string) error {
 	if err != nil {
 		return fmt.Errorf("web: %w", err)
 	}
-	if _, err := config.MergeMissingTrackerDefaults(cfg); err != nil {
-		return fmt.Errorf("web: %w", err)
-	}
-	currentCfg := b.currentConfig()
-	if strings.TrimSpace(cfg.MainSettings.DBPath) == "" {
-		cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	}
-	if !pathutil.SamePath(cfg.MainSettings.DBPath, currentCfg.MainSettings.DBPath) {
-		return errors.New("changing main_settings.db_path requires restart")
-	}
-	cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := cfg.Validate(); err != nil {
+	activator, err := b.runtimeActivator()
+	if err != nil {
 		return fmt.Errorf("web: %w", err)
 	}
-	runtimeCfg := *cfg
-	config.ApplyEnvOverrides(&runtimeCfg)
-	runtimeCfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := runtimeCfg.Validate(); err != nil {
+	if err := activator.Activate(context.Background(), *cfg); err != nil {
 		return fmt.Errorf("web: %w", err)
 	}
-	return b.saveAndApplyConfig(context.Background(), cfg, runtimeCfg, cfg.MainSettings.DBPath)
+	return nil
 }
 
 const configImportMaxBytes = importer.MaxFileBytes
@@ -984,21 +1337,12 @@ func (b *Backend) ImportConfig(fileName, fileContent string) (string, []string,
 		return "", nil, fmt.Errorf("web: %w", err)
 	}
 
-	currentCfg := b.currentConfig()
-	cfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-
-	if err := cfg.Validate(); err != nil {
-		return "", nil, fmt.Errorf("validate imported config: %w", err)
-	}
-	runtimeCfg := *cfg
-	config.ApplyEnvOverrides(&runtimeCfg)
-	runtimeCfg.MainSettings.DBPath = currentCfg.MainSettings.DBPath
-	if err := runtimeCfg.Validate(); err != nil {
-		return "", nil, fmt.Errorf("validate imported config: %w", err)
+	activator, err := b.runtimeActivator()
+	if err != nil {
+		return "", nil, fmt.Errorf("web: %w", err)
 	}
-
-	if err := b.saveAndApplyConfig(context.Background(), cfg, runtimeCfg, cfg.MainSettings.DBPath); err != nil {
-		return "", nil, err
+	if err := activator.Activate(context.Background(), *cfg); err != nil {
+		return "", nil, fmt.Errorf("web: %w", err)
 	}
 
 	result := "imported config"
@@ -1008,183 +1352,158 @@ func (b *Backend) ImportConfig(fileName, fileContent string) (string, []string,
 	return result, warnings, nil
 }
 
-// saveAndApplyConfig builds the replacement runtime before any repository
-// writes, then migrates shared cookies, persists cfg, and installs the runtime
-// as one ordered transition. If migration or persistence fails, the built
-// runtime is closed and the active runtime is left untouched.
-func (b *Backend) saveAndApplyConfig(ctx context.Context, cfg *config.Config, runtimeCfg config.Config, dbPath string) error {
-	if err := validateCookieAuthMaterial(dbPath); err != nil {
-		if !errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			return fmt.Errorf("web: validate cookie auth before config save: %w", err)
-		}
-	}
-
-	rt, err := b.buildConfigRuntime(ctx, runtimeCfg)
+// ListTrackerCatalog returns ordered tracker identity, config schemas, and local
+// configured state without exposing current credential values.
+func (b *Backend) ListTrackerCatalog() (api.TrackerCatalog, error) {
+	registry, err := trackerimpl.NewRegistry()
 	if err != nil {
-		return err
-	}
-	if err := b.ensureSharedCookieMigrationForRuntime(ctx, dbPath, rt.Logger); err != nil {
-		closeBuiltRuntime(rt)
-		return fmt.Errorf("web: cookie migration failed: %w", err)
+		return api.TrackerCatalog{}, fmt.Errorf("webserver: tracker registry: %w", err)
 	}
-	if err := b.saveConfigToRepository(ctx, cfg, dbPath); err != nil {
-		closeBuiltRuntime(rt)
-		return err
-	}
-	b.installConfigRuntime(runtimeCfg, rt)
-	return nil
-}
-
-// saveConfigToRepository persists browser config changes through the already-open
-// repository.
-func (b *Backend) saveConfigToRepository(ctx context.Context, cfg *config.Config, dbPath string) error {
-	if err := configstore.SaveToRepository(ctx, cfg, b.repo, dbPath); err != nil {
-		return fmt.Errorf("web: %w", err)
+	schemas, err := config.OrderedTrackerSchemas()
+	if err != nil {
+		return api.TrackerCatalog{}, fmt.Errorf("webserver: tracker config catalog: %w", err)
 	}
-	return nil
-}
 
-// validateCookieAuthMaterial returns ErrAuthHelperUnavailable only when auth
-// material is absent; malformed material remains an error so callers can abort
-// before cookie encryption metadata is initialized.
-func validateCookieAuthMaterial(dbPath string) error {
-	material, err := authmaterial.LoadFromDBPath(dbPath)
-	if err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return cookies.ErrAuthHelperUnavailable
+	cfg := b.currentConfig()
+	entries := make([]api.TrackerCatalogEntry, 0, len(schemas))
+	seen := make(map[string]struct{}, len(schemas))
+	for _, schema := range schemas {
+		descriptor, ok := registry.LookupDescriptor(schema.Name)
+		if !ok {
+			return api.TrackerCatalog{}, fmt.Errorf("webserver: tracker config catalog entry %s has no implementation", schema.Name)
 		}
-		return fmt.Errorf("load auth helper: %w", err)
-	}
-	if _, _, err := material.PrimaryHelper(); err != nil {
-		if errors.Is(err, authmaterial.ErrUnavailable) {
-			return cookies.ErrAuthHelperUnavailable
+		fields := make([]api.TrackerCatalogField, len(schema.Fields))
+		for index, field := range schema.Fields {
+			fields[index] = api.TrackerCatalogField{
+				Key:        field.JSONKey,
+				YAMLKey:    field.YAMLKey,
+				Default:    field.Default,
+				Activation: field.Activation,
+			}
 		}
-		return fmt.Errorf("derive auth helper: %w", err)
-	}
-	return nil
-}
-
-// buildConfigRuntime wraps shared runtime construction with web-specific error
-// context.
-func (b *Backend) buildConfigRuntime(ctx context.Context, cfg config.Config) (guishared.Runtime, error) {
-	rt, err := guishared.BuildRuntime(ctx, cfg, b.repo)
-	if err != nil {
-		return guishared.Runtime{}, fmt.Errorf("web: %w", err)
-	}
-	return rt, nil
-}
-
-// ensureSharedCookieMigration syncs cookie encryption metadata and migrates
-// legacy cookie files against the shared repository before SkipCookieMigration
-// runtimes serve uploads. Missing auth material is logged and treated as
-// retryable on a later settings save.
-func (b *Backend) ensureSharedCookieMigration(ctx context.Context, dbPath string, logger api.Logger) error {
-	if b.repo == nil {
-		return errors.New("repository not initialized")
-	}
-	if logger == nil {
-		logger = api.NopLogger{}
+		trackerCfg, _ := trackerConfigByName(cfg.Trackers.Trackers, schema.Name)
+		entries = append(entries, api.TrackerCatalogEntry{
+			Name:              schema.Name,
+			Family:            string(descriptor.Family),
+			BaseURL:           descriptor.BaseURL,
+			UploadContentMode: string(descriptor.UploadContentMode),
+			Fields:            fields,
+			Configured:        config.TrackerConfigured(trackerCfg, schema),
+		})
+		seen[schema.Name] = struct{}{}
 	}
-	if err := cookies.SyncCookieEncryptionWithAuth(ctx, b.repo.RawDB(), dbPath); err != nil {
-		if errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			logger.Debugf("web: cookie encryption sync skipped: web auth helper unavailable")
-		} else {
-			return fmt.Errorf("cookies encryption sync: %w", err)
+	for _, name := range registry.Names() {
+		if _, ok := seen[name]; !ok {
+			return api.TrackerCatalog{}, fmt.Errorf("webserver: tracker implementation %s has no config catalog entry", name)
 		}
 	}
 
-	cookiesDir, err := db.CookiePath(dbPath, "")
-	if err != nil {
-		logger.Debugf("web: failed to resolve cookies directory: %v", err)
-		return nil
-	}
-	if err := cookies.EnsureCookieMigration(ctx, b.repo.RawDB(), dbPath, cookiesDir, logger); err != nil {
-		if errors.Is(err, cookies.ErrAuthHelperUnavailable) {
-			logger.Debugf("web: cookie migration skipped: web auth helper unavailable")
-			return nil
+	unsupported := make([]string, 0)
+	for name := range cfg.Trackers.Trackers {
+		normalized := strings.ToUpper(strings.TrimSpace(name))
+		if normalized == "" {
+			continue
+		}
+		if _, ok := seen[normalized]; !ok {
+			unsupported = append(unsupported, name)
 		}
-		return fmt.Errorf("cookies migration: %w", err)
-	}
-	return nil
-}
-
-// ensureSharedCookieMigrationForRuntime runs the configured migration hook and
-// returns hard migration errors before the replacement runtime is installed.
-func (b *Backend) ensureSharedCookieMigrationForRuntime(ctx context.Context, dbPath string, logger api.Logger) error {
-	if b.sharedCookieMigrator != nil {
-		return b.sharedCookieMigrator(ctx, dbPath, logger)
 	}
-	return b.ensureSharedCookieMigration(ctx, dbPath, logger)
+	slices.SortFunc(unsupported, func(left, right string) int {
+		return strings.Compare(strings.ToUpper(left), strings.ToUpper(right))
+	})
+	return api.TrackerCatalog{Entries: entries, Unsupported: unsupported}, nil
 }
 
-// installConfigRuntime swaps in a newly built runtime, rebinds event/log
-// streams, and closes the previous core and logger after replacement.
-func (b *Backend) installConfigRuntime(cfg config.Config, rt guishared.Runtime) {
-	oldCore, oldLogger := b.replaceRuntime(cfg, rt.Core, rt.Logger)
-	if b.hub != nil {
-		b.hub.SetLogger(rt.Logger)
-	}
-	b.rebindLogStreams(oldLogger, rt.Logger)
-	if oldCore != nil {
-		_ = oldCore.Close()
+func trackerConfigByName(entries map[string]config.TrackerConfig, name string) (config.TrackerConfig, bool) {
+	if cfg, ok := entries[name]; ok {
+		return cfg, true
 	}
-	if oldLogger != nil {
-		_ = oldLogger.Close()
+	for entryName, cfg := range entries {
+		if strings.EqualFold(strings.TrimSpace(entryName), strings.TrimSpace(name)) {
+			return cfg, true
+		}
 	}
+	return config.TrackerConfig{}, false
 }
 
-// closeBuiltRuntime closes a runtime that was built but not installed.
-func closeBuiltRuntime(rt guishared.Runtime) {
-	if rt.Core != nil {
-		_ = rt.Core.Close()
+// GetImageHostPolicyMetadata returns image-host policy metadata consumed by settings and upload UI.
+func (b *Backend) GetImageHostPolicyMetadata() (imagehostpolicy.Metadata, error) {
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		return imagehostpolicy.Metadata{}, fmt.Errorf("webserver: tracker registry: %w", err)
 	}
-	if rt.Logger != nil {
-		_ = rt.Logger.Close()
+	metadata := imagehostpolicy.Metadata{
+		UploadHosts:        imagehostpolicy.KnownUploadHosts(),
+		TrackerUploadHosts: make(map[string][]string),
+		OwnedHosts:         make(map[string]string),
 	}
+	for _, tracker := range registry.Names() {
+		policy, ok := registry.LookupImageHostPolicy(tracker)
+		if !ok {
+			continue
+		}
+		hosts := append([]string(nil), policy.AllowedHosts...)
+		if host := strings.ToLower(strings.TrimSpace(policy.ConditionalHost)); host != "" {
+			hosts = append(hosts, host)
+		}
+		uploadHosts := make([]string, 0, len(hosts))
+		for _, host := range hosts {
+			normalized := strings.ToLower(strings.TrimSpace(host))
+			if imagehostpolicy.IsUploadHost(normalized) && !slices.Contains(uploadHosts, normalized) {
+				uploadHosts = append(uploadHosts, normalized)
+			}
+		}
+		if len(uploadHosts) > 0 {
+			metadata.TrackerUploadHosts[tracker] = uploadHosts
+		}
+		for _, host := range policy.OwnedHosts {
+			metadata.OwnedHosts[strings.ToLower(strings.TrimSpace(host))] = tracker
+		}
+	}
+	return metadata, nil
 }
 
-func (b *Backend) ListKnownTrackers() ([]string, error) {
-	return trackers.KnownTrackers(), nil
-}
-
-func (b *Backend) GetImageHostPolicyMetadata() (imagehostpolicy.Metadata, error) {
-	return imagehostpolicy.PolicyMetadata(), nil
-}
-
+// ListHistory returns persisted release history in repository-defined order.
 func (b *Backend) ListHistory() ([]api.HistoryEntry, error) {
-	if err := b.requireHistoryRepo(); err != nil {
-		return nil, err
-	}
-	entries, err := b.repo.ListHistoryEntries(context.Background())
+	rt := b.runtimeSnapshot()
+	history, err := rt.historyCore()
 	if err != nil {
-		return nil, fmt.Errorf("web: %w", err)
-	}
-	result := make([]api.HistoryEntry, 0, len(entries))
-	for _, entry := range entries {
-		entryCopy := entry
-		entryCopy.LatestUploadStatus = api.HistoryStatusLabel(entry.LatestUploadStatus, entry.RuleFailureCount)
-		result = append(result, entryCopy)
+		return nil, err
 	}
-	return result, nil
+	return wrapWebResult(history.ListHistory(context.Background()))
 }
 
+// GetHistoryOverview returns persisted upload and asset detail for one source path.
 func (b *Backend) GetHistoryOverview(sourcePath string) (api.HistoryOverview, error) {
-	return historyOverviewFromRepo(b.repo, sourcePath)
+	rt := b.runtimeSnapshot()
+	history, err := rt.historyCore()
+	if err != nil {
+		return api.HistoryOverview{}, err
+	}
+	return wrapWebResult(history.GetHistoryOverview(context.Background(), sourcePath))
 }
 
+// DeleteHistoryRelease purges persisted history and managed artifacts for one source path.
 func (b *Backend) DeleteHistoryRelease(sourcePath string) error {
-	if err := b.requireCore(); err != nil {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return err
+	}
+	historyCore, err := rt.historyCore()
+	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	return wrapWebError(b.currentCore().DeleteHistoryRelease(ctx, strings.TrimSpace(sourcePath)))
+	return wrapWebError(historyCore.DeleteHistoryRelease(ctx, strings.TrimSpace(sourcePath)))
 }
 
+// GetLogPath returns the host filesystem path of the active application log.
 func (b *Backend) GetLogPath() (string, error) {
 	return wrapWebResult(logging.LogPath(b.currentConfig().MainSettings.DBPath))
 }
 
+// GetRecentLogs returns up to limit sanitized recent log entries.
 func (b *Backend) GetRecentLogs(limit int) ([]logging.Entry, error) {
 	logger := b.currentLogger()
 	if logger == nil {
@@ -1193,11 +1512,12 @@ func (b *Backend) GetRecentLogs(limit int) ([]logging.Entry, error) {
 	return logger.Recent(limit), nil
 }
 
+// GetLogExclusions returns persisted frontend log-filter patterns.
 func (b *Backend) GetLogExclusions() ([]string, error) {
 	if b.repo == nil {
 		return nil, errors.New("config repository not initialized")
 	}
-	var exclusions guiapp.LogExclusions
+	var exclusions logExclusions
 	err := config.LoadSectionFromDatabase(context.Background(), "log_exclusions", &exclusions, b.repo)
 	if err != nil {
 		if errorsIsNotFound(err) {
@@ -1208,11 +1528,12 @@ func (b *Backend) GetLogExclusions() ([]string, error) {
 	return normalizePatterns(exclusions.Patterns), nil
 }
 
+// UpdateLogExclusions validates and persists frontend log-filter patterns.
 func (b *Backend) UpdateLogExclusions(patterns []string) error {
 	if b.repo == nil {
 		return errors.New("config repository not initialized")
 	}
-	return wrapWebError(config.SaveSectionToDatabase(context.Background(), "log_exclusions", guiapp.LogExclusions{
+	return wrapWebError(config.SaveSectionToDatabase(context.Background(), "log_exclusions", logExclusions{
 		Patterns: normalizePatterns(patterns),
 	}, b.repo))
 }
@@ -1373,46 +1694,62 @@ func (b *Backend) StopSessionLogStreams(sessionID string) {
 	}
 }
 
-func (b *Backend) buildRunOptions(debug bool, noSeed bool, runLogLevel string) (runOptions, error) {
+func (b *Backend) buildRunOptions(noSeed bool, runLogLevel string) (runOptions, error) {
 	if strings.TrimSpace(runLogLevel) == "" {
-		return runOptions{Debug: debug, NoSeed: noSeed}, nil
+		return runOptions{NoSeed: noSeed}, nil
 	}
 	normalized, err := api.ParseLogLevel(runLogLevel)
 	if err != nil {
 		return runOptions{}, fmt.Errorf("web: %w", err)
 	}
-	return runOptions{Debug: debug, NoSeed: noSeed, RunLogLevel: normalized}, nil
+	return runOptions{
+		NoSeed:      noSeed,
+		RunLogLevel: normalized,
+	}, nil
 }
 
 // buildRunCoreFromSnapshot creates a per-run core and logger from the same
 // runtime snapshot used to build upload options. The transient core skips
 // startup-only legacy cookie migration while sharing the backend repository.
-func (b *Backend) buildRunCoreFromSnapshot(rt backendRuntimeSnapshot, opts runOptions) (api.Core, *logging.Logger, error) {
-	effectiveLogLevel := logging.ResolveEffectiveLevel(rt.cfg.Logging.Level, opts.RunLogLevel, opts.Debug)
+// The capability bundle borrows the core; callers must close the returned
+// owner and logger separately unless they transfer both to a job.
+func (b *Backend) buildRunCoreFromSnapshot(
+	ctx context.Context,
+	rt backendRuntimeSnapshot,
+	opts runOptions,
+) (CoreCapabilities, LifecycleOwner, *logging.Logger, error) {
+	if err := ctx.Err(); err != nil {
+		return CoreCapabilities{}, nil, nil, fmt.Errorf("web: build run core canceled: %w", err)
+	}
+	effectiveLogLevel := logging.ResolveEffectiveLevel(rt.cfg.Logging.Level, opts.RunLogLevel, false)
 	logger, err := logging.NewWithLevel(rt.cfg.Logging, rt.cfg.MainSettings.DBPath, effectiveLogLevel)
 	if err != nil {
-		return nil, nil, fmt.Errorf("web: %w", err)
+		return CoreCapabilities{}, nil, nil, fmt.Errorf("web: %w", err)
+	}
+	if err := ctx.Err(); err != nil {
+		_ = logger.Close()
+		return CoreCapabilities{}, nil, nil, fmt.Errorf("web: build run core canceled: %w", err)
 	}
-	coreSvc, err := core.New(api.CoreDependencies{
+	coreSvc, err := core.NewWithContext(ctx, api.CoreDependencies{
 		Config: rt.cfg,
 		Logger: logger,
 		Services: api.ServiceSet{
 			Filesystem: filesystem.NewValidator(),
 		},
-		Repository:          b.repo,
+		Repository:          b.repo.RepositoryCapabilities(),
+		RepositoryOwner:     b.repo,
 		SkipCookieMigration: true,
 	})
 	if err != nil {
 		_ = logger.Close()
-		return nil, nil, fmt.Errorf("web: %w", err)
+		return CoreCapabilities{}, nil, nil, fmt.Errorf("web: %w", err)
 	}
-	return coreSvc, logger, nil
+	capabilities, owner := BindCoreCapabilities(coreSvc)
+	return capabilities, owner, logger, nil
 }
 
 func buildRunUploadOptions(cfg config.Config, opts runOptions) api.UploadOptions {
 	options := buildBaseMetadataOptions(cfg)
-	options.Debug = opts.Debug
-	options.DryRun = opts.Debug
 	options.NoSeed = opts.NoSeed
 	options.RunLogLevel = opts.RunLogLevel
 	return options
@@ -1427,15 +1764,6 @@ func buildBaseMetadataOptions(cfg config.Config) api.UploadOptions {
 	}
 }
 
-func (b *Backend) applyConfig(cfg config.Config) error {
-	rt, err := b.buildConfigRuntime(context.Background(), cfg)
-	if err != nil {
-		return err
-	}
-	b.installConfigRuntime(cfg, rt)
-	return nil
-}
-
 func (b *Backend) isPathWithinManagedDirs(candidate string) bool {
 	tmpDir, err := db.Subdir(b.currentConfig().MainSettings.DBPath, "tmp")
 	if err == nil && pathutil.IsWithinRoot(tmpDir, candidate) {
@@ -1512,96 +1840,3 @@ func removeIfWithinRoot(root string, target string, recursive bool) error {
 func errorsIsNotFound(err error) bool {
 	return err != nil && strings.Contains(strings.ToLower(err.Error()), "not found")
 }
-
-func preferredHistoryDescriptionOverride(overrides []api.DescriptionOverride) api.DescriptionOverride {
-	if len(overrides) == 0 {
-		return api.DescriptionOverride{}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.GroupKey) == "" {
-			return override
-		}
-	}
-	for _, override := range overrides {
-		if strings.TrimSpace(override.Description) != "" {
-			return override
-		}
-	}
-	return overrides[0]
-}
-
-func historyOverviewFromRepo(repo *db.SQLiteRepository, sourcePath string) (api.HistoryOverview, error) {
-	if repo == nil {
-		return api.HistoryOverview{}, errors.New("history repository not initialized")
-	}
-	trimmed := strings.TrimSpace(sourcePath)
-	if trimmed == "" {
-		return api.HistoryOverview{}, internalerrors.ErrInvalidInput
-	}
-	ctx := context.Background()
-	metadata, err := repo.GetByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview := api.HistoryOverview{
-		SourcePath:        metadata.Path,
-		ReleaseTitle:      metadata.Title,
-		ReleaseSource:     metadata.Source,
-		ReleaseResolution: metadata.Resolution,
-		MetadataUpdatedAt: metadata.UpdatedAt,
-		Metadata:          metadata,
-	}
-	if externalIDs, err := repo.GetExternalIDs(ctx, trimmed); err == nil {
-		overview.ExternalIDs = externalIDs
-	}
-	if externalMetadata, err := repo.GetExternalMetadata(ctx, trimmed); err == nil {
-		overview.ExternalMetadata = externalMetadata
-	}
-	if releaseOverrides, err := repo.GetReleaseNameOverrides(ctx, trimmed); err == nil {
-		overview.ReleaseNameOverrides = releaseOverrides
-	}
-	if descriptionOverrides, err := repo.ListDescriptionOverridesByPath(ctx, trimmed); err == nil {
-		overview.DescriptionOverrides = append([]api.DescriptionOverride(nil), descriptionOverrides...)
-		overview.DescriptionOverride = preferredHistoryDescriptionOverride(descriptionOverrides)
-	}
-	if playlistSelection, err := repo.GetPlaylistSelection(ctx, trimmed); err == nil {
-		overview.PlaylistSelection = playlistSelection
-	}
-	trackerMetadata, err := repo.ListTrackerMetadataByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.TrackerMetadata = trackerMetadata
-	ruleFailures, err := repo.ListTrackerRuleFailuresByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.TrackerRuleFailures = ruleFailures
-	screenshots, err := repo.ListScreenshotsByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.Screenshots = screenshots
-	finalSelections, err := repo.ListFinalSelections(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.FinalSelections = finalSelections
-	uploadedImages, err := repo.ListUploadedImagesByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.UploadedImages = uploadedImages
-	uploadHistory, err := repo.ListUploadHistoryByPath(ctx, trimmed)
-	if err != nil {
-		return api.HistoryOverview{}, fmt.Errorf("web: %w", err)
-	}
-	overview.UploadHistory = uploadHistory
-	if len(uploadHistory) > 0 {
-		overview.LatestUploadStatus = uploadHistory[0].Status
-		overview.LatestUploadAt = uploadHistory[0].CreatedAt
-	}
-	blockingRuleFailures := api.CountBlockingRuleFailures(ruleFailures)
-	overview.StatusLabel = api.HistoryStatusLabel(overview.LatestUploadStatus, blockingRuleFailures)
-	return overview, nil
-}
diff --git a/internal/webserver/backend_dry_run_test.go b/internal/webserver/backend_dry_run_test.go
new file mode 100644
index 00000000..87f1dd7c
--- /dev/null
+++ b/internal/webserver/backend_dry_run_test.go
@@ -0,0 +1,361 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	sharedjobs "github.com/autobrr/upbrr/internal/webserver/jobs"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type dryRunCaptureCapability struct {
+	plan api.TrackerDryRunPlan
+}
+
+func (c *dryRunCaptureCapability) RunAcceptedTrackerDryRun(ctx context.Context, plan api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	if err := ctx.Err(); err != nil {
+		return api.TrackerDryRunPreview{}, fmt.Errorf("captured dry run canceled: %w", err)
+	}
+	c.plan = plan
+	return api.TrackerDryRunPreview{SourcePath: plan.Input.Release.SourcePath}, nil
+}
+
+type completedDryRunDupeRunner struct{}
+
+func (completedDryRunDupeRunner) CheckDupes(_ context.Context, input api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	results := make([]api.DupeCheckResult, 0, len(input.Trackers))
+	for _, tracker := range input.Trackers {
+		results = append(results, api.DupeCheckResult{
+Tracker: tracker,
+ Status: "completed",
+ Notes: []string{"retained"},
+})
+	}
+	return api.DupeCheckSummary{SourcePath: input.Release.SourcePath, Results: results}, nil
+}
+
+type failedDryRunDupeRunner struct{}
+
+func (failedDryRunDupeRunner) CheckDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	return api.DupeCheckSummary{}, errors.New("duplicate service unavailable")
+}
+
+type blockingDryRunDupeRunner struct {
+	started chan struct{}
+	release chan struct{}
+}
+
+func (r blockingDryRunDupeRunner) CheckDupes(ctx context.Context, _ api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	close(r.started)
+	select {
+	case <-ctx.Done():
+		return api.DupeCheckSummary{}, fmt.Errorf("blocking duplicate check canceled: %w", ctx.Err())
+	case <-r.release:
+		return api.DupeCheckSummary{}, nil
+	}
+}
+
+func TestFetchTrackerDryRunUsesActiveCapabilityAndRetainedDupeEvidence(t *testing.T) {
+	t.Parallel()
+
+	capture := &dryRunCaptureCapability{}
+	backend := &Backend{
+		cfg:               config.Config{Logging: config.LoggingConfig{Level: "info"}},
+		capabilities:      CoreCapabilities{DryRun: capture},
+		runtimeGeneration: 41,
+		hub:               newEventHub(),
+		jobEngine:         sharedjobs.New(nil, sharedjobs.Config{}),
+		jobOwners:         make(map[string]*sharedjobs.OwnerHandle),
+	}
+	t.Cleanup(backend.jobEngine.Close)
+
+	release := api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 7}
+	jobID := startCompletedDryRunDupeJob(t, backend, "session-a", release, 41, []string{"AITHER"})
+	preview, err := backend.FetchTrackerDryRun(
+		context.Background(),
+		"session-a",
+		jobID,
+		release,
+		[]string{"AITHER"},
+		nil,
+		nil,
+		nil,
+		true,
+		"trace",
+	)
+	if err != nil {
+		t.Fatalf("fetch tracker dry run: %v", err)
+	}
+	if preview.SourcePath != release.SourcePath || capture.plan.Input.Release != release {
+		t.Fatalf("preview=%#v plan=%#v", preview, capture.plan)
+	}
+	if capture.plan.Input.Options.RunLogLevel != "trace" || !capture.plan.Input.Options.NoSeed {
+		t.Fatalf("run options = %#v", capture.plan.Input.Options)
+	}
+	if capture.plan.Duplicate.Release != release || len(capture.plan.Duplicate.Results) != 1 || capture.plan.Duplicate.Results[0].Tracker != "AITHER" {
+		t.Fatalf("duplicate evidence = %#v", capture.plan.Duplicate)
+	}
+	if backend.capabilities.PreparedGenerationTransfer != nil {
+		t.Fatal("test unexpectedly installed generation transfer")
+	}
+}
+
+func TestFetchTrackerDryRunRejectsInvalidDupeJobLineage(t *testing.T) {
+	t.Parallel()
+
+	release := api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 7}
+	tests := []struct {
+		name              string
+		owner             string
+		requestOwner      string
+		requestJob        string
+		jobRelease        api.ReleaseRef
+		jobRuntime        uint64
+		jobTrackers       []string
+		requestTrackers   []string
+		wantFailure       api.OperationFailureCode
+	}{
+		{
+			name:            "missing job",
+			owner:           "session-a",
+			requestOwner:    "session-a",
+			requestJob:      "missing-job",
+			jobRelease:      release,
+			jobRuntime:      41,
+			jobTrackers:     []string{"AITHER"},
+			requestTrackers: []string{"AITHER"},
+			wantFailure:     api.OperationFailureMissingPrerequisite,
+		},
+		{
+			name:            "foreign owner",
+			owner:           "session-a",
+			requestOwner:    "session-b",
+			jobRelease:      release,
+			jobRuntime:      41,
+			jobTrackers:     []string{"AITHER"},
+			requestTrackers: []string{"AITHER"},
+			wantFailure:     api.OperationFailureMissingPrerequisite,
+		},
+		{
+			name:            "stale release",
+			owner:           "session-a",
+			requestOwner:    "session-a",
+			jobRelease:      api.ReleaseRef{SourcePath: release.SourcePath, Generation: 6},
+			jobRuntime:      41,
+			jobTrackers:     []string{"AITHER"},
+			requestTrackers: []string{"AITHER"},
+			wantFailure:     api.OperationFailureStaleGeneration,
+		},
+		{
+			name:            "stale runtime",
+			owner:           "session-a",
+			requestOwner:    "session-a",
+			jobRelease:      release,
+			jobRuntime:      40,
+			jobTrackers:     []string{"AITHER"},
+			requestTrackers: []string{"AITHER"},
+			wantFailure:     api.OperationFailureStaleGeneration,
+		},
+		{
+			name:            "tracker mismatch",
+			owner:           "session-a",
+			requestOwner:    "session-a",
+			jobRelease:      release,
+			jobRuntime:      41,
+			jobTrackers:     []string{"AITHER"},
+			requestTrackers: []string{"AITHER", "BLU"},
+			wantFailure:     api.OperationFailureMissingPrerequisite,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			capture := &dryRunCaptureCapability{}
+			backend := &Backend{
+				capabilities:      CoreCapabilities{DryRun: capture},
+				runtimeGeneration: 41,
+				hub:               newEventHub(),
+				jobEngine:         sharedjobs.New(nil, sharedjobs.Config{}),
+				jobOwners:         make(map[string]*sharedjobs.OwnerHandle),
+			}
+			t.Cleanup(backend.jobEngine.Close)
+			jobID := startCompletedDryRunDupeJob(t, backend, test.owner, test.jobRelease, test.jobRuntime, test.jobTrackers)
+			if test.requestJob != "" {
+				jobID = test.requestJob
+			}
+			_, err := backend.FetchTrackerDryRun(
+				context.Background(), test.requestOwner, jobID, release, test.requestTrackers, nil, nil, nil, true, "",
+			)
+			failure, ok := api.AsOperationFailure(err)
+			if !ok || failure.Code != test.wantFailure {
+				t.Fatalf("failure = %#v err=%v", failure, err)
+			}
+			if capture.plan.Input.Release.Generation != 0 {
+				t.Fatalf("dry-run capability was invoked: %#v", capture.plan)
+			}
+		})
+	}
+}
+
+func TestFetchTrackerDryRunRejectsRunningAndFailedDupeJobs(t *testing.T) {
+	t.Parallel()
+
+	release := api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 7}
+	tests := []struct {
+		name   string
+		runner sharedjobs.DupeRunner
+		wait   string
+	}{
+		{
+name: "running",
+ runner: blockingDryRunDupeRunner{started: make(chan struct{}), release: make(chan struct{})},
+ wait: sharedjobs.StatusRunning,
+},
+		{
+name: "failed",
+ runner: failedDryRunDupeRunner{},
+ wait: sharedjobs.StatusFailed,
+},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			backend := newDryRunTestBackend(&dryRunCaptureCapability{})
+			t.Cleanup(backend.jobEngine.Close)
+			jobID := startDryRunDupeJob(t, backend, "session-a", release, 41, []string{"AITHER"}, test.runner)
+			waitForDryRunDupeStatus(t, backend, "session-a", jobID, test.wait)
+			_, err := backend.FetchTrackerDryRun(
+				context.Background(), "session-a", jobID, release, []string{"AITHER"}, nil, nil, nil, true, "",
+			)
+			failure, ok := api.AsOperationFailure(err)
+			if !ok || failure.Code != api.OperationFailureMissingPrerequisite {
+				t.Fatalf("failure = %#v err=%v", failure, err)
+			}
+			if runner, ok := test.runner.(blockingDryRunDupeRunner); ok {
+				close(runner.release)
+			}
+		})
+	}
+}
+
+func TestFetchTrackerDryRunDetachesAcceptedEvidenceFromJobSnapshot(t *testing.T) {
+	t.Parallel()
+
+	capture := &dryRunCaptureCapability{}
+	backend := newDryRunTestBackend(capture)
+	t.Cleanup(backend.jobEngine.Close)
+	release := api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 7}
+	jobID := startCompletedDryRunDupeJob(t, backend, "session-a", release, 41, []string{"AITHER"})
+	if _, err := backend.FetchTrackerDryRun(
+		context.Background(), "session-a", jobID, release, []string{"AITHER"}, nil, nil, nil, true, "",
+	); err != nil {
+		t.Fatalf("fetch tracker dry run: %v", err)
+	}
+	capture.plan.Duplicate.Results[0].Notes[0] = "mutated"
+	snapshot, err := backend.jobEngine.DupeSnapshot(backend.lookupJobOwner("session-a"), jobID)
+	if err != nil {
+		t.Fatalf("reload duplicate snapshot: %v", err)
+	}
+	if got := snapshot.Summary.Results[0].Notes[0]; got != "retained" {
+		t.Fatalf("retained duplicate evidence mutated: %q", got)
+	}
+}
+
+func newDryRunTestBackend(capability DryRunCapability) *Backend {
+	return &Backend{
+		capabilities:      CoreCapabilities{DryRun: capability},
+		runtimeGeneration: 41,
+		hub:               newEventHub(),
+		jobEngine:         sharedjobs.New(nil, sharedjobs.Config{}),
+		jobOwners:         make(map[string]*sharedjobs.OwnerHandle),
+	}
+}
+
+func startCompletedDryRunDupeJob(
+	t *testing.T,
+	backend *Backend,
+	ownerID string,
+	release api.ReleaseRef,
+	runtimeGeneration uint64,
+	trackers []string,
+) string {
+	t.Helper()
+	jobID := startDryRunDupeJob(t, backend, ownerID, release, runtimeGeneration, trackers, completedDryRunDupeRunner{})
+	waitForDryRunDupeStatus(t, backend, ownerID, jobID, sharedjobs.StatusCompleted)
+	return jobID
+}
+
+func startDryRunDupeJob(
+	t *testing.T,
+	backend *Backend,
+	ownerID string,
+	release api.ReleaseRef,
+	runtimeGeneration uint64,
+	trackers []string,
+	runner sharedjobs.DupeRunner,
+) string {
+	t.Helper()
+	owner, err := backend.ensureJobOwner(ownerID)
+	if err != nil {
+		t.Fatalf("ensure job owner: %v", err)
+	}
+	jobID, err := backend.jobEngine.StartDupe(context.Background(), owner, sharedjobs.DupeSpec{
+		CorrelationID: "dry-run-prerequisite",
+		Snapshot: sharedjobs.DuplicateExecutionSnapshot{
+			PreparedGeneration: release.Generation,
+			RuntimeGeneration:  runtimeGeneration,
+			Input: api.DuplicateCheckInput{
+				Release:  release,
+				Trackers: append([]string(nil), trackers...),
+			},
+		},
+		Runner: runner,
+	})
+	if err != nil {
+		t.Fatalf("start dupe job: %v", err)
+	}
+	return jobID
+}
+
+func waitForDryRunDupeStatus(t *testing.T, backend *Backend, ownerID string, jobID string, wantStatus string) {
+	t.Helper()
+	deadline := time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		snapshot, snapshotErr := backend.jobEngine.DupeSnapshot(backend.lookupJobOwner(ownerID), jobID)
+		if snapshotErr != nil {
+			t.Fatalf("load dupe snapshot: %v", snapshotErr)
+		}
+		if snapshot.Status == wantStatus {
+			return
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	t.Fatalf("timed out waiting for duplicate job status %q", wantStatus)
+}
+
+func TestFetchTrackerDryRunPropagatesCanceledContext(t *testing.T) {
+	t.Parallel()
+
+	backend := &Backend{
+		capabilities:      CoreCapabilities{DryRun: &dryRunCaptureCapability{}},
+		runtimeGeneration: 41,
+		hub:               newEventHub(),
+		jobEngine:         sharedjobs.New(nil, sharedjobs.Config{}),
+		jobOwners:         make(map[string]*sharedjobs.OwnerHandle),
+	}
+	t.Cleanup(backend.jobEngine.Close)
+	release := api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 7}
+	jobID := startCompletedDryRunDupeJob(t, backend, "session-a", release, 41, []string{"AITHER"})
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	_, err := backend.FetchTrackerDryRun(ctx, "session-a", jobID, release, []string{"AITHER"}, nil, nil, nil, true, "")
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled error = %v", err)
+	}
+}
diff --git a/internal/webserver/backend_repo_test.go b/internal/webserver/backend_repo_test.go
index dbfc5afc..ca96f7fa 100644
--- a/internal/webserver/backend_repo_test.go
+++ b/internal/webserver/backend_repo_test.go
@@ -11,6 +11,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"testing"
@@ -24,60 +25,6 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func TestBackendApplyConfigKeepsSharedRepositoryUsable(t *testing.T) {
-	t.Parallel()
-
-	repoPath := filepath.Join(t.TempDir(), "backend.db")
-	repo, err := db.OpenWithLogger(repoPath, nil)
-	if err != nil {
-		t.Fatalf("open repo: %v", err)
-	}
-	t.Cleanup(func() {
-		_ = repo.Close()
-	})
-	if err := repo.Migrate(); err != nil {
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	cfg := config.Config{
-		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x", DBPath: repoPath},
-		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		Logging:            config.LoggingConfig{Level: "error"},
-	}
-
-	backend := &Backend{
-		cfg:  cfg,
-		repo: repo,
-		hub:  newEventHub(),
-	}
-	t.Cleanup(func() {
-		if backend.core != nil {
-			_ = backend.core.Close()
-		}
-		if backend.logger != nil {
-			_ = backend.logger.Close()
-		}
-	})
-
-	if err := backend.applyConfig(cfg); err != nil {
-		t.Fatalf("apply config: %v", err)
-	}
-	if backend.core == nil {
-		t.Fatal("expected core to be initialized")
-	}
-	if err := backend.core.Close(); err != nil {
-		t.Fatalf("close core: %v", err)
-	}
-
-	if err := repo.Save(context.Background(), db.FileMetadata{
-		Path:      filepath.Join(t.TempDir(), "after-apply.mkv"),
-		Title:     "After Apply",
-		UpdatedAt: time.Now().UTC().Truncate(time.Second),
-	}); err != nil {
-		t.Fatalf("expected shared repo to remain usable after core close: %v", err)
-	}
-}
-
 func TestNewBackendKeepsSharedRepositoryUsableAfterCoreClose(t *testing.T) {
 	t.Parallel()
 
@@ -96,10 +43,10 @@ func TestNewBackendKeepsSharedRepositoryUsableAfterCoreClose(t *testing.T) {
 		_ = backend.Close()
 	})
 
-	if backend.core == nil {
+	if backend.coreOwner == nil {
 		t.Fatal("expected startup core to be initialized")
 	}
-	if err := backend.core.Close(); err != nil {
+	if err := backend.coreOwner.Close(); err != nil {
 		t.Fatalf("close core: %v", err)
 	}
 	if backend.repo == nil {
@@ -288,7 +235,7 @@ func TestBackendGetConfigFallbackUsesSingleRuntimeSnapshot(t *testing.T) {
 	assertExport := func(want config.Config) {
 		t.Helper()
 
-		backend.replaceRuntime(want, nil, nil)
+		backend.replaceRuntime(want, CoreCapabilities{}, nil)
 		payload, err := backend.GetConfig()
 		if err != nil {
 			t.Fatalf("get config: %v", err)
@@ -382,31 +329,280 @@ func TestBackendGetConfigDatabaseConfigUsesSingleRuntimeSnapshotForDBPath(t *tes
 			t.Fatalf("DBPath fallback: got %q want %q", exported.MainSettings.DBPath, wantDBPath)
 		}
 	}
-	backend.replaceRuntime(cfgA, nil, nil)
+	backend.replaceRuntime(cfgA, CoreCapabilities{}, nil)
 	assertExport(pathA)
-	backend.replaceRuntime(cfgB, nil, nil)
+	backend.replaceRuntime(cfgB, CoreCapabilities{}, nil)
 	assertExport(pathB)
 }
 
-func TestBackendFetchMetadataPropagatesSkipAutoTorrentSetting(t *testing.T) {
+func TestBackendFetchMetadataMapsSearchPolicyAndRecoveryControlSeparately(t *testing.T) {
 	t.Parallel()
 
 	coreSvc := &preparedMetaTestCore{}
+	playlist := api.PlaylistInstruction{Set: true, Selected: []string{"00001.mpls"}}
 	backend := &Backend{
 		cfg: config.Config{
 			Metadata:           config.MetadataConfig{SkipAutoTorrent: true},
 			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 3},
 		},
-		core: coreSvc,
-		hub:  newEventHub(),
+		capabilities: webTestCapabilities(coreSvc),
+		coreOwner:    coreSvc,
+		hub:          newEventHub(),
 	}
 
-	_, err := backend.FetchMetadata("session", "C:\\releases\\Example.mkv", "", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, false)
+	_, err := backend.FetchMetadata(context.Background(), "session", metadataPreparationRequest{
+		CorrelationID:     "attempt-1",
+		Path:              "C:\\releases\\Example.mkv",
+		Playlist:          playlist,
+		ConfirmBDMVRescan: true,
+	})
 	if err != nil {
 		t.Fatalf("fetch metadata: %v", err)
 	}
-	if !coreSvc.fetchReq.Options.SkipAutoTorrent {
-		t.Fatalf("expected skip_auto_torrent request option, got %#v", coreSvc.fetchReq.Options)
+	if coreSvc.prepareInput.SourcePath != `C:\releases\Example.mkv` {
+		t.Fatalf("expected canonical prepare input, got %#v", coreSvc.prepareInput)
+	}
+	if !coreSvc.prepareInput.Instructions.Playlist.Set || !slices.Equal(coreSvc.prepareInput.Instructions.Playlist.Selected, []string{"00001.mpls"}) {
+		t.Fatalf("expected direct playlist instruction, got %#v", coreSvc.prepareInput.Instructions.Playlist)
+	}
+	if !coreSvc.prepareInput.Search.Skip {
+		t.Fatalf("expected client-search skip policy, got %#v", coreSvc.prepareInput.Search)
+	}
+	if !coreSvc.prepareInput.Controls.ConfirmBDMVRescan {
+		t.Fatalf("expected explicit BDMV recovery control, got %#v", coreSvc.prepareInput.Controls)
+	}
+	if coreSvc.fetchReq.SourcePath != "" {
+		t.Fatalf("legacy metadata request was invoked: %#v", coreSvc.fetchReq)
+	}
+}
+
+func TestBackendRequestCapabilitiesRejectPartialRuntimeBundles(t *testing.T) {
+	t.Parallel()
+
+	stub := &backendSnapshotGuardCore{}
+	metadataOnly := CoreCapabilities{Metadata: stub}
+	selectionOnly := CoreCapabilities{Selection: stub}
+	path := "C:\\releases\\Example.mkv"
+	tests := []struct {
+		name         string
+		capabilities CoreCapabilities
+		want         string
+		call         func(*Backend) error
+	}{
+		{
+			name:         "metadata",
+			capabilities: selectionOnly,
+			want:         "metadata capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.FetchMetadata(context.Background(), "session", metadataPreparationRequest{CorrelationID: "attempt-1", Path: path})
+				return err
+			},
+		},
+		{
+			name:         "selection",
+			capabilities: metadataOnly,
+			want:         "blu-ray selection capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.SelectBlurayCandidate(context.Background(), "session", blurayCandidateSelectionRequest{
+					CorrelationID: "attempt-1",
+					Path:          path,
+					ReleaseID:     "candidate",
+				})
+				return err
+			},
+		},
+		{
+			name:         "reset metadata",
+			capabilities: selectionOnly,
+			want:         "metadata capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.ResetMetadata(context.Background(), "session", metadataPreparationRequest{CorrelationID: "attempt-1", Path: path})
+				return err
+			},
+		},
+		{
+			name:         "preparation",
+			capabilities: metadataOnly,
+			want:         "preparation capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.FetchPreparation("session", path, api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, nil)
+				return err
+			},
+		},
+		{
+			name:         "description preview",
+			capabilities: metadataOnly,
+			want:         "description capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.FetchDescriptionBuilder(api.ReleaseRef{SourcePath: path, Generation: 1}, nil)
+				return err
+			},
+		},
+		{
+			name:         "description render",
+			capabilities: metadataOnly,
+			want:         "description capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.RenderDescription("text")
+				return err
+			},
+		},
+		{
+			name:         "description save",
+			capabilities: metadataOnly,
+			want:         "description capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.SaveDescriptionOverride(api.ReleaseRef{SourcePath: path, Generation: 1}, "group", "text", nil)
+				return err
+			},
+		},
+		{
+			name:         "playlist discover",
+			capabilities: metadataOnly,
+			want:         "playlist capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.DiscoverPlaylists(context.Background(), path)
+				return err
+			},
+		},
+		{
+			name:         "screenshot plan",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.FetchScreenshotPlan(api.ReleaseRef{SourcePath: path, Generation: 1})
+				return err
+			},
+		},
+		{
+			name:         "screenshot generation",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.GenerateScreenshots(api.ReleaseRef{SourcePath: path, Generation: 1}, nil, api.ScreenshotPurposeFinal)
+				return err
+			},
+		},
+		{
+			name:         "screenshot preview",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.PreviewScreenshotFrame(api.ReleaseRef{SourcePath: path, Generation: 1}, 1)
+				return err
+			},
+		},
+		{
+			name:         "screenshot delete",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.DeleteScreenshot(api.ReleaseRef{SourcePath: path, Generation: 1}, "image.png")
+			},
+		},
+		{
+			name:         "tracker image delete",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.DeleteTrackerImageURL(api.ReleaseRef{SourcePath: path, Generation: 1}, "https://img.example.com/image.png")
+			},
+		},
+		{
+			name:         "screenshot selection save",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.SaveFinalScreenshotSelections(api.ReleaseRef{SourcePath: path, Generation: 1}, nil)
+			},
+		},
+		{
+			name:         "menu image import",
+			capabilities: metadataOnly,
+			want:         "screenshot capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.ImportMenuImages(api.ReleaseRef{SourcePath: path, Generation: 1}, nil)
+			},
+		},
+		{
+			name:         "upload candidates",
+			capabilities: metadataOnly,
+			want:         "hosted image capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.ListUploadCandidates(api.ReleaseRef{SourcePath: path, Generation: 1})
+				return err
+			},
+		},
+		{
+			name:         "uploaded images",
+			capabilities: metadataOnly,
+			want:         "hosted image capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.ListUploadedImages(api.ReleaseRef{SourcePath: path, Generation: 1})
+				return err
+			},
+		},
+		{
+			name:         "image upload",
+			capabilities: metadataOnly,
+			want:         "hosted image capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.UploadImages(
+					context.Background(),
+					"session-1",
+					"image-upload-1",
+					api.ReleaseRef{SourcePath: path, Generation: 1},
+					nil,
+					"host",
+					[]api.ScreenshotImage{{Path: "image.png"}},
+				)
+				return err
+			},
+		},
+		{
+			name:         "uploaded image delete",
+			capabilities: metadataOnly,
+			want:         "hosted image capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.DeleteUploadedImage(api.ReleaseRef{SourcePath: path, Generation: 1}, "image.png", "host")
+			},
+		},
+		{
+			name:         "DVD image list",
+			capabilities: metadataOnly,
+			want:         "DVD menu capability unavailable",
+			call: func(backend *Backend) error {
+				_, err := backend.ListDVDMenuScreenshots(api.ReleaseRef{SourcePath: path, Generation: 1})
+				return err
+			},
+		},
+		{
+			name:         "DVD image delete",
+			capabilities: metadataOnly,
+			want:         "DVD menu capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.DeleteDVDMenuScreenshot(api.ReleaseRef{SourcePath: path, Generation: 1}, "image.png")
+			},
+		},
+		{
+			name:         "history delete",
+			capabilities: metadataOnly,
+			want:         "history capability unavailable",
+			call: func(backend *Backend) error {
+				return backend.DeleteHistoryRelease(path)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			backend := &Backend{capabilities: tt.capabilities, hub: newEventHub()}
+			err := tt.call(backend)
+			if err == nil || !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("error: got %v want containing %q", err, tt.want)
+			}
+		})
 	}
 }
 
@@ -430,6 +626,32 @@ func (c *backendSnapshotGuardCore) FetchMetadataPreview(_ context.Context, req a
 	return api.MetadataPreview{}, nil
 }
 
+func (*backendSnapshotGuardCore) FetchAcceptedMetadataPreview(_ context.Context, ref api.ReleaseRef) (api.MetadataPreview, error) {
+	return api.MetadataPreview{SourcePath: ref.SourcePath}, nil
+}
+
+func (*backendSnapshotGuardCore) CheckAcceptedDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	return api.DupeCheckSummary{}, nil
+}
+
+func (c *backendSnapshotGuardCore) FetchPreparationPreview(_ context.Context, req api.Request) (api.PreparationPreview, error) {
+	c.check(req, "FetchPreparationPreview")
+	return api.PreparationPreview{}, nil
+}
+
+func (c *backendSnapshotGuardCore) FetchAcceptedPreparationPreview(_ context.Context, input api.DescriptionInput) (api.PreparationPreview, error) {
+	c.check(api.Request{Options: input.Options}, "FetchAcceptedPreparationPreview")
+	return api.PreparationPreview{}, nil
+}
+
+func (*backendSnapshotGuardCore) BuildUploadReview(context.Context, api.Request) (api.UploadReview, error) {
+	return api.UploadReview{}, nil
+}
+
+func (*backendSnapshotGuardCore) ReviewAcceptedUpload(context.Context, api.UploadReviewInput) (api.ReviewedUpload, error) {
+	return api.ReviewedUpload{}, nil
+}
+
 func (c *backendSnapshotGuardCore) ListUploadCandidates(_ context.Context, req api.Request) ([]api.ScreenshotImage, error) {
 	c.check(req, "ListUploadCandidates")
 	return nil, nil
@@ -445,14 +667,90 @@ func (c *backendSnapshotGuardCore) UploadImages(_ context.Context, req api.Reque
 	return api.UploadImagesResult{}, nil
 }
 
+func (*backendSnapshotGuardCore) ListAcceptedUploadCandidates(context.Context, api.ImageHostingInput) ([]api.ScreenshotImage, error) {
+	return nil, nil
+}
+
+func (*backendSnapshotGuardCore) ListAcceptedUploadedImages(context.Context, api.ImageHostingInput) ([]api.UploadedImageLink, error) {
+	return nil, nil
+}
+
+func (*backendSnapshotGuardCore) UploadAcceptedImages(context.Context, api.ImageHostingInput, []api.ScreenshotImage) (api.UploadImagesResult, error) {
+	return api.UploadImagesResult{}, nil
+}
+
+func (*backendSnapshotGuardCore) DeleteAcceptedUploadedImage(context.Context, api.ImageHostingInput, string, string) error {
+	return nil
+}
+
+func (*backendSnapshotGuardCore) DeleteUploadedImage(context.Context, api.Request, string, string) error {
+	return nil
+}
+
+func (*backendSnapshotGuardCore) CaptureDVDMenus(context.Context, api.Request) (api.DVDMenuCaptureResult, error) {
+	return api.DVDMenuCaptureResult{}, nil
+}
+
+func (*backendSnapshotGuardCore) CaptureAcceptedDVDMenus(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	return api.DVDMenuCaptureResult{}, nil
+}
+
+func (c *backendSnapshotGuardCore) ListDVDMenuScreenshots(_ context.Context, req api.Request) ([]api.ScreenshotImage, error) {
+	c.check(req, "ListDVDMenuScreenshots")
+	return nil, nil
+}
+
+func (c *backendSnapshotGuardCore) DeleteDVDMenuScreenshot(_ context.Context, req api.Request, _ string) error {
+	c.check(req, "DeleteDVDMenuScreenshot")
+	return nil
+}
+
+func (*backendSnapshotGuardCore) ListAcceptedDVDMenuScreenshots(context.Context, api.MediaPlanInput) ([]api.ScreenshotImage, error) {
+	return nil, nil
+}
+
+func (*backendSnapshotGuardCore) DeleteAcceptedDVDMenuScreenshot(context.Context, api.MediaPlanInput, string) error {
+	return nil
+}
+
+func (c *backendSnapshotGuardCore) FetchDescriptionBuilderPreview(_ context.Context, req api.Request) (api.DescriptionBuilderPreview, error) {
+	c.check(req, "FetchDescriptionBuilderPreview")
+	return api.DescriptionBuilderPreview{}, nil
+}
+
+func (c *backendSnapshotGuardCore) FetchAcceptedDescriptionBuilderPreview(_ context.Context, input api.DescriptionInput) (api.DescriptionBuilderPreview, error) {
+	c.check(api.Request{Options: input.Options}, "FetchAcceptedDescriptionBuilderPreview")
+	return api.DescriptionBuilderPreview{}, nil
+}
+
+func (*backendSnapshotGuardCore) FetchAcceptedDescriptionBuilderGroupPreview(context.Context, api.DescriptionInput) (api.DescriptionBuilderGroup, error) {
+	return api.DescriptionBuilderGroup{}, nil
+}
+
+func (*backendSnapshotGuardCore) SaveAcceptedDescriptionOverride(context.Context, api.DescriptionInput, string) (api.DescriptionBuilderGroup, error) {
+	return api.DescriptionBuilderGroup{}, nil
+}
+
+func (*backendSnapshotGuardCore) FetchDescriptionBuilderGroupPreview(context.Context, api.Request) (api.DescriptionBuilderGroup, error) {
+	return api.DescriptionBuilderGroup{}, nil
+}
+
+func (*backendSnapshotGuardCore) RenderDescription(context.Context, string) (string, error) {
+	return "", nil
+}
+
+func (*backendSnapshotGuardCore) SaveDescriptionOverride(context.Context, api.Request, string) (api.DescriptionBuilderGroup, error) {
+	return api.DescriptionBuilderGroup{}, nil
+}
+
 func (c *backendSnapshotGuardCore) RunUploadPrepared(_ context.Context, req api.Request) (api.Result, error) {
 	c.check(req, "RunUploadPrepared")
 	return api.Result{}, nil
 }
 
-func (c *backendSnapshotGuardCore) ExportGUICachedPreparedMeta(_ context.Context, req api.Request) (api.PreparedMetadata, bool, error) {
-	c.check(req, "ExportGUICachedPreparedMeta")
-	return api.PreparedMetadata{}, false, nil
+func (c *backendSnapshotGuardCore) RunAcceptedUpload(_ context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	c.check(api.Request{Options: plan.Input.Options}, "RunAcceptedUpload")
+	return api.Result{}, nil
 }
 
 func TestBackendRequestsUseSingleRuntimeSnapshot(t *testing.T) {
@@ -465,10 +763,10 @@ func TestBackendRequestsUseSingleRuntimeSnapshot(t *testing.T) {
 	cfgB := cfgA
 	cfgB.ScreenshotHandling.Screens = 2
 	backend := &Backend{
-		cfg:  cfgA,
-		core: &backendSnapshotGuardCore{wantScreens: 1, errs: errs},
-		repo: repo,
-		hub:  newEventHub(),
+		cfg:          cfgA,
+		capabilities: webTestCapabilities(&backendSnapshotGuardCore{wantScreens: 1, errs: errs}),
+		repo:         repo,
+		hub:          newEventHub(),
 	}
 
 	stop := make(chan struct{})
@@ -481,9 +779,9 @@ func TestBackendRequestsUseSingleRuntimeSnapshot(t *testing.T) {
 			default:
 			}
 			if i%2 == 0 {
-				backend.replaceRuntime(cfgB, &backendSnapshotGuardCore{wantScreens: 2, errs: errs}, nil)
+				backend.replaceRuntime(cfgB, webTestCapabilities(&backendSnapshotGuardCore{wantScreens: 2, errs: errs}), nil)
 			} else {
-				backend.replaceRuntime(cfgA, &backendSnapshotGuardCore{wantScreens: 1, errs: errs}, nil)
+				backend.replaceRuntime(cfgA, webTestCapabilities(&backendSnapshotGuardCore{wantScreens: 1, errs: errs}), nil)
 			}
 		}
 	})
@@ -493,19 +791,43 @@ func TestBackendRequestsUseSingleRuntimeSnapshot(t *testing.T) {
 	})
 
 	for range 200 {
-		if _, err := backend.FetchMetadata("session", "C:\\releases\\Example.mkv", "", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, false); err != nil {
+		release := api.ReleaseRef{SourcePath: "C:\\releases\\Example.mkv", Generation: 1}
+		if _, err := backend.FetchMetadata(context.Background(), "session", metadataPreparationRequest{
+			CorrelationID: "attempt-race",
+			Path:          "C:\\releases\\Example.mkv",
+		}); err != nil {
 			t.Fatalf("fetch metadata: %v", err)
 		}
-		if _, err := backend.UploadImages("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, "host", []api.ScreenshotImage{{Path: "image.jpg"}}); err != nil {
+		if _, err := backend.FetchPreparation("session", release.SourcePath, api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, nil); err != nil {
+			t.Fatalf("fetch preparation: %v", err)
+		}
+		if _, err := backend.UploadImages(
+			context.Background(),
+			"session-1",
+			"image-upload-1",
+			release,
+			nil,
+			"host",
+			[]api.ScreenshotImage{{Path: "image.jpg"}},
+		); err != nil {
 			t.Fatalf("upload images: %v", err)
 		}
-		if _, err := backend.ListUploadCandidates("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}); err != nil {
+		if _, err := backend.ListUploadCandidates(release); err != nil {
 			t.Fatalf("list upload candidates: %v", err)
 		}
-		if _, err := backend.ListUploadedImages("C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}); err != nil {
+		if _, err := backend.ListUploadedImages(release); err != nil {
 			t.Fatalf("list uploaded images: %v", err)
 		}
-		_, _ = backend.FetchTrackerDryRun("session", "C:\\releases\\Example.mkv", api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, nil, nil, nil, nil, false, false, "")
+		if _, err := backend.FetchDescriptionBuilder(release, nil); err != nil {
+			t.Fatalf("fetch description builder: %v", err)
+		}
+		if _, err := backend.ListDVDMenuScreenshots(release); err != nil {
+			t.Fatalf("list DVD menu screenshots: %v", err)
+		}
+		if err := backend.DeleteDVDMenuScreenshot(release, "image.png"); err != nil {
+			t.Fatalf("delete DVD menu screenshot: %v", err)
+		}
+		_, _ = backend.FetchTrackerDryRun(context.Background(), "session", "", release, nil, nil, nil, nil, false, "")
 		select {
 		case err := <-errs:
 			t.Fatal(err)
@@ -514,27 +836,27 @@ func TestBackendRequestsUseSingleRuntimeSnapshot(t *testing.T) {
 	}
 }
 
-func TestBackendRunSingleTrackerUploadUsesJobUploadOptionsSnapshot(t *testing.T) {
+func TestWebUploadRunnerUsesRequestUploadOptionsSnapshot(t *testing.T) {
 	t.Parallel()
 
 	errs := make(chan error, 1)
 	repoPath := filepath.Join(t.TempDir(), "web-upload-job.db")
 	jobCfg := backendConfigTestConfig(repoPath)
 	jobCfg.ScreenshotHandling.Screens = 1
-	currentCfg := jobCfg
-	currentCfg.ScreenshotHandling.Screens = 2
-	backend := &Backend{cfg: currentCfg}
-	job := &trackerUploadJob{
-		sourcePath:           "C:\\releases\\Example.mkv",
-		uploadOptions:        buildRunUploadOptions(jobCfg, runOptions{}),
-		runOptions:           runOptions{},
-		core:                 &backendSnapshotGuardCore{wantScreens: 1, errs: errs},
-		descriptionGroups:    nil,
-		trackers:             []string{"BTN"},
-		questionnaireAnswers: map[string]map[string]string{},
-	}
-
-	if _, err := backend.runSingleTrackerUpload(context.Background(), job, "BTN"); err != nil {
+	coreSvc := &backendSnapshotGuardCore{wantScreens: 1, errs: errs}
+	request := api.Request{
+		SourcePath: "C:\\releases\\Example.mkv",
+		Options:    buildRunUploadOptions(jobCfg, runOptions{}),
+		Trackers:   []string{"BTN"},
+	}
+	runner := webUploadRunner{core: coreSvc, generationTarget: coreSvc}
+
+	if _, err := runner.RunUpload(context.Background(), api.UploadExecutionPlan{Input: api.UploadReviewInput{
+		Release:  api.ReleaseRef{SourcePath: request.SourcePath},
+		Trackers: request.Trackers,
+		Options:  request.Options,
+	},
+	}); err != nil {
 		t.Fatalf("run single tracker upload: %v", err)
 	}
 	select {
@@ -555,7 +877,7 @@ func TestBackendSaveConfigAcceptsSameDatabasePathAlias(t *testing.T) {
 		hub:  newEventHub(),
 	}
 	t.Cleanup(func() {
-		if coreSvc := backend.currentCore(); coreSvc != nil {
+		if coreSvc := backend.coreOwner; coreSvc != nil {
 			_ = coreSvc.Close()
 		}
 		if logger := backend.currentLogger(); logger != nil {
@@ -579,7 +901,7 @@ func TestBackendSaveConfigAcceptsSameDatabasePathAlias(t *testing.T) {
 	}
 }
 
-func TestBackendSaveConfigRejectsDifferentDatabasePath(t *testing.T) {
+func TestBackendSaveConfigForcesOpenDatabasePath(t *testing.T) {
 	t.Parallel()
 
 	repo, repoPath := openBackendConfigTestRepo(t, "backend-save-dbpath-change.db")
@@ -589,20 +911,29 @@ func TestBackendSaveConfigRejectsDifferentDatabasePath(t *testing.T) {
 		repo: repo,
 		hub:  newEventHub(),
 	}
+	t.Cleanup(func() {
+		if coreSvc := backend.coreOwner; coreSvc != nil {
+			_ = coreSvc.Close()
+		}
+		if logger := backend.currentLogger(); logger != nil {
+			_ = logger.Close()
+		}
+	})
 
 	updated := initial
 	updated.MainSettings.DBPath = filepath.Join(t.TempDir(), "different.db")
+	updated.Metadata.SkipAutoTorrent = true
 	payload, err := config.ExportToJSON(&updated)
 	if err != nil {
 		t.Fatalf("export config: %v", err)
 	}
 
-	err = backend.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected DBPath change rejection")
+	if err := backend.SaveConfig(payload); err != nil {
+		t.Fatalf("save config: %v", err)
 	}
-	if !strings.Contains(err.Error(), "requires restart") {
-		t.Fatalf("expected restart error, got %v", err)
+	runtimeCfg := backend.currentConfig()
+	if runtimeCfg.MainSettings.DBPath != repoPath || !runtimeCfg.Metadata.SkipAutoTorrent {
+		t.Fatalf("runtime config = %#v", runtimeCfg)
 	}
 }
 
@@ -632,7 +963,7 @@ func TestBackendSaveConfigAppliesRuntimeConfigImmediately(t *testing.T) {
 		hub:  newEventHub(),
 	}
 	t.Cleanup(func() {
-		if coreSvc := backend.currentCore(); coreSvc != nil {
+		if coreSvc := backend.coreOwner; coreSvc != nil {
 			_ = coreSvc.Close()
 		}
 		if logger := backend.currentLogger(); logger != nil {
@@ -660,7 +991,7 @@ func TestBackendSaveConfigAppliesRuntimeConfigImmediately(t *testing.T) {
 	if runtimeCfg.ScreenshotHandling.Screens != 5 {
 		t.Fatalf("expected screenshots=5, got %d", runtimeCfg.ScreenshotHandling.Screens)
 	}
-	if backend.currentCore() == nil {
+	if backend.coreOwner == nil {
 		t.Fatal("expected runtime core to be rebuilt")
 	}
 	options := buildRunUploadOptions(runtimeCfg, runOptions{})
@@ -688,7 +1019,7 @@ func TestBackendSaveConfigAfterInvalidStartupMigratesLegacyCookies(t *testing.T)
 	t.Cleanup(func() {
 		_ = backend.Close()
 	})
-	if backend.currentCore() != nil {
+	if backend.coreOwner != nil {
 		t.Fatal("expected invalid startup to leave core disabled")
 	}
 
@@ -778,7 +1109,7 @@ func TestBackendLogStreamContinuesAcrossSaveConfigRuntimeReplacement(t *testing.
 	}
 	t.Cleanup(func() {
 		backend.stopAllLogStreams()
-		if coreSvc := backend.currentCore(); coreSvc != nil {
+		if coreSvc := backend.coreOwner; coreSvc != nil {
 			_ = coreSvc.Close()
 		}
 		if logger := backend.currentLogger(); logger != nil {
@@ -869,7 +1200,7 @@ func TestBackendLogStreamContinuesAcrossImportConfigRuntimeReplacement(t *testin
 	}
 	t.Cleanup(func() {
 		backend.stopAllLogStreams()
-		if coreSvc := backend.currentCore(); coreSvc != nil {
+		if coreSvc := backend.coreOwner; coreSvc != nil {
 			_ = coreSvc.Close()
 		}
 		if logger := backend.currentLogger(); logger != nil {
@@ -946,7 +1277,7 @@ func TestBackendSaveConfigRejectsInvalidEnvRuntimeConfig(t *testing.T) {
 	if got := backend.currentConfig().ScreenshotHandling.Screens; got != 1 {
 		t.Fatalf("expected runtime config to remain unchanged, got screens=%d", got)
 	}
-	if backend.currentCore() != nil {
+	if backend.coreOwner != nil {
 		t.Fatal("expected runtime core not to be rebuilt")
 	}
 	if _, loadErr := config.LoadFromDatabase(context.Background(), repo); loadErr == nil {
@@ -988,7 +1319,7 @@ func TestBackendSaveConfigBuildRuntimeFailureDoesNotPersist(t *testing.T) {
 	if got := backend.currentConfig().Metadata.SkipAutoTorrent; got {
 		t.Fatal("expected runtime config to remain unchanged")
 	}
-	if backend.currentCore() != nil {
+	if backend.coreOwner != nil {
 		t.Fatal("expected runtime core not to be rebuilt")
 	}
 }
@@ -1024,7 +1355,7 @@ func TestBackendImportConfigBuildRuntimeFailureDoesNotPersist(t *testing.T) {
 	if got := backend.currentConfig().Metadata.SkipAutoTorrent; got {
 		t.Fatal("expected runtime config to remain unchanged")
 	}
-	if backend.currentCore() != nil {
+	if backend.coreOwner != nil {
 		t.Fatal("expected runtime core not to be rebuilt")
 	}
 }
@@ -1118,13 +1449,14 @@ func TestBackendSaveConfigSyncsUsableWebAuthBeforeSave(t *testing.T) {
 	assertCookieAuthStatePresent(t, repo)
 }
 
-func TestBackendSaveConfigLeavesConfigUnchangedWhenRepositorySaveFailsAfterCookieSync(t *testing.T) {
+func TestBackendSaveConfigRollsBackCookieMaintenanceWhenRepositorySaveFails(t *testing.T) {
 	t.Parallel()
 
 	repo, repoPath := openBackendConfigTestRepo(t, "backend-save-cookie-rollback.db")
 	if err := BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
 		t.Fatalf("BootstrapAuthFile: %v", err)
 	}
+	legacyPath := writeBackendLegacyCookieFile(t, repoPath, "EXAMPLE", `{"session":"cookie-value"}`)
 	installBackendFailMainSettingsTrigger(t, repo)
 	initial := backendConfigTestConfig(repoPath)
 	backend := &Backend{
@@ -1145,117 +1477,20 @@ func TestBackendSaveConfigLeavesConfigUnchangedWhenRepositorySaveFailsAfterCooki
 		t.Fatal("expected save config to fail")
 	}
 
-	assertConfigRowsAbsent(t, repo)
-	assertCookieAuthStatePresent(t, repo)
-	if got := backend.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after failed config save")
-	}
-}
-
-func TestBackendSaveConfigHardCookieMigrationErrorDoesNotInstallRuntime(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openBackendConfigTestRepo(t, "backend-save-cookie-migration-hard-error.db")
-	initial := backendConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	backend := &Backend{
-		cfg:  initial,
-		repo: repo,
-		hub:  newEventHub(),
-		sharedCookieMigrator: func(context.Context, string, api.Logger) error {
-			return errors.New("forced migration failure")
-		},
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	payload, err := config.ExportToJSON(&updated)
-	if err != nil {
-		t.Fatalf("export config: %v", err)
+	assertFailedConfigSaveRowsAbsent(t, repo)
+	if _, err := os.Stat(legacyPath); err != nil {
+		t.Fatalf("expected legacy cookie file to remain after failed activation: %v", err)
 	}
-
-	err = backend.SaveConfig(payload)
-	if err == nil {
-		t.Fatal("expected hard cookie migration error")
+	var cookieCount int
+	if err := repo.RawDB().QueryRowContext(context.Background(), `SELECT COUNT(*) FROM tracker_cookies`).Scan(&cookieCount); err != nil {
+		t.Fatalf("count cookies after failed activation: %v", err)
 	}
-	if !strings.Contains(err.Error(), "forced migration failure") {
-		t.Fatalf("expected forced migration failure, got %v", err)
+	if cookieCount != 0 {
+		t.Fatalf("expected cookie writes to roll back, got count=%d", cookieCount)
 	}
-	assertStoredSkipAutoTorrentUnset(t, repo)
 	if got := backend.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after hard migration failure")
-	}
-	if backend.currentCore() != nil {
-		t.Fatal("expected runtime core not to be installed after hard migration failure")
-	}
-}
-
-func TestBackendImportConfigHardCookieMigrationErrorPropagates(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openBackendConfigTestRepo(t, "backend-import-cookie-migration-hard-error.db")
-	initial := backendConfigTestConfig(repoPath)
-	if err := config.SaveToDatabase(context.Background(), &initial, repo); err != nil {
-		t.Fatalf("save initial config: %v", err)
-	}
-	backend := &Backend{
-		cfg:  initial,
-		repo: repo,
-		hub:  newEventHub(),
-		sharedCookieMigrator: func(context.Context, string, api.Logger) error {
-			return errors.New("forced migration failure")
-		},
-	}
-
-	imported := initial
-	imported.Metadata.SkipAutoTorrent = true
-	content := exportConfigYAMLString(t, &imported)
-
-	_, _, err := backend.ImportConfig("config.yaml", content)
-	if err == nil {
-		t.Fatal("expected hard cookie migration error")
-	}
-	if !strings.Contains(err.Error(), "forced migration failure") {
-		t.Fatalf("expected forced migration failure, got %v", err)
-	}
-	assertStoredSkipAutoTorrentUnset(t, repo)
-	if got := backend.currentConfig().Metadata.SkipAutoTorrent; got {
-		t.Fatal("expected runtime config not to be applied after imported hard migration failure")
-	}
-	if backend.currentCore() != nil {
-		t.Fatal("expected runtime core not to be installed after imported hard migration failure")
-	}
-}
-
-func TestBackendSaveConfigRepositoryRejectsAuthChangeAfterValidation(t *testing.T) {
-	t.Parallel()
-
-	repo, repoPath := openBackendConfigTestRepo(t, "backend-save-auth-drift.db")
-	if err := BootstrapAuthFile(repoPath, "tester", "very-secure-password"); err != nil {
-		t.Fatalf("BootstrapAuthFile: %v", err)
-	}
-	if err := validateCookieAuthMaterial(repoPath); err != nil {
-		t.Fatalf("prevalidate auth material: %v", err)
-	}
-	if err := os.WriteFile(AuthFilePath(repoPath), []byte(`{`), 0o600); err != nil {
-		t.Fatalf("replace auth file: %v", err)
-	}
-	initial := backendConfigTestConfig(repoPath)
-	backend := &Backend{
-		cfg:  initial,
-		repo: repo,
-		hub:  newEventHub(),
-	}
-
-	updated := initial
-	updated.Metadata.SkipAutoTorrent = true
-	err := backend.saveConfigToRepository(context.Background(), &updated, repoPath)
-	if err == nil {
-		t.Fatal("expected auth drift to malformed helper to fail")
+		t.Fatal("expected runtime config not to be applied after failed config save")
 	}
-	assertFailedConfigSaveRowsAbsent(t, repo)
 }
 
 func openBackendConfigTestRepo(t *testing.T, name string) (*db.SQLiteRepository, string) {
@@ -1329,19 +1564,6 @@ func assertFailedConfigSaveRowsAbsent(t *testing.T, repo *db.SQLiteRepository) {
 	}
 }
 
-func assertConfigRowsAbsent(t *testing.T, repo *db.SQLiteRepository) {
-	t.Helper()
-
-	var data string
-	err := repo.RawDB().QueryRowContext(context.Background(),
-		`SELECT data FROM config_settings WHERE section = ?`,
-		"MainSettings",
-	).Scan(&data)
-	if !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("expected MainSettings to be absent after failed save, got row=%q err=%v", data, err)
-	}
-}
-
 func expectLogStreamMessage(t *testing.T, events <-chan serverEvent, streamID string, want string) {
 	t.Helper()
 
@@ -1579,7 +1801,7 @@ func TestBackendExportConfigAuthorizesAgainstExportSnapshotDBPath(t *testing.T)
 		t.Fatalf("auth DBPath: got %q want %q", authDBPath, pathB)
 	}
 
-	backend.replaceRuntime(cfgA, nil, nil)
+	backend.replaceRuntime(cfgA, CoreCapabilities{}, nil)
 	allowPlaintext, err := backend.allowUnencryptedExport(authDBPath)
 	if err != nil {
 		t.Fatalf("allow unencrypted export: %v", err)
diff --git a/internal/webserver/base_path_test.go b/internal/webserver/base_path_test.go
index f33c5ef2..29074710 100644
--- a/internal/webserver/base_path_test.go
+++ b/internal/webserver/base_path_test.go
@@ -16,15 +16,51 @@ func TestNormalizeBaseURLAcceptsCanonicalInputs(t *testing.T) {
 		raw  string
 		want string
 	}{
-		{name: "empty", raw: "", want: ""},
-		{name: "root", raw: "/", want: ""},
-		{name: "path without slash", raw: "upbrr", want: "/upbrr"},
-		{name: "path with slash", raw: "/upbrr/", want: "/upbrr"},
-		{name: "path query fragment stripped", raw: "/upbrr/?token=secret#frag", want: "/upbrr"},
-		{name: "absolute https", raw: " https://example.test/upbrr/ ", want: "https://example.test/upbrr/"},
-		{name: "absolute http", raw: "http://example.test/upbrr", want: "http://example.test/upbrr/"},
-		{name: "absolute ipv6", raw: "http://[::1]:7480/upbrr?token=secret#frag", want: "http://[::1]:7480/upbrr/"},
-		{name: "absolute root query stripped", raw: "https://example.test/?token=secret#frag", want: "https://example.test/"},
+		{
+			name: "empty",
+			raw:  "",
+			want: "",
+		},
+		{
+			name: "root",
+			raw:  "/",
+			want: "",
+		},
+		{
+			name: "path without slash",
+			raw:  "upbrr",
+			want: "/upbrr",
+		},
+		{
+			name: "path with slash",
+			raw:  "/upbrr/",
+			want: "/upbrr",
+		},
+		{
+			name: "path query fragment stripped",
+			raw:  "/upbrr/?token=secret#frag",
+			want: "/upbrr",
+		},
+		{
+			name: "absolute https",
+			raw:  " https://example.test/upbrr/ ",
+			want: "https://example.test/upbrr/",
+		},
+		{
+			name: "absolute http",
+			raw:  "http://example.test/upbrr",
+			want: "http://example.test/upbrr/",
+		},
+		{
+			name: "absolute ipv6",
+			raw:  "http://[::1]:7480/upbrr?token=secret#frag",
+			want: "http://[::1]:7480/upbrr/",
+		},
+		{
+			name: "absolute root query stripped",
+			raw:  "https://example.test/?token=secret#frag",
+			want: "https://example.test/",
+		},
 	}
 
 	for _, tc := range cases {
@@ -49,16 +85,56 @@ func TestNormalizeBaseURLRejectsInvalidInputs(t *testing.T) {
 		raw  string
 		want string
 	}{
-		{name: "protocol relative", raw: "//example.test/upbrr", want: "protocol-relative"},
-		{name: "javascript", raw: "javascript:alert(1)", want: "http or https"},
-		{name: "file", raw: "file:///tmp/upbrr", want: "http or https"},
-		{name: "ftp", raw: "ftp://example.test/upbrr", want: "http or https"},
-		{name: "missing host", raw: "https:/upbrr", want: "must include a host"},
-		{name: "userinfo", raw: "https://user@example.test/upbrr", want: "userinfo"},
-		{name: "path traversal", raw: "/upbrr/../admin", want: "path traversal"},
-		{name: "encoded traversal", raw: "/upbrr/%2e%2e/admin", want: "path traversal"},
-		{name: "query only", raw: "?base=/upbrr", want: "must include a path"},
-		{name: "fragment only", raw: "#upbrr", want: "must include a path"},
+		{
+			name: "protocol relative",
+			raw:  "//example.test/upbrr",
+			want: "protocol-relative",
+		},
+		{
+			name: "javascript",
+			raw:  "javascript:alert(1)",
+			want: "http or https",
+		},
+		{
+			name: "file",
+			raw:  "file:///tmp/upbrr",
+			want: "http or https",
+		},
+		{
+			name: "ftp",
+			raw:  "ftp://example.test/upbrr",
+			want: "http or https",
+		},
+		{
+			name: "missing host",
+			raw:  "https:/upbrr",
+			want: "must include a host",
+		},
+		{
+			name: "userinfo",
+			raw:  "https://user@example.test/upbrr",
+			want: "userinfo",
+		},
+		{
+			name: "path traversal",
+			raw:  "/upbrr/../admin",
+			want: "path traversal",
+		},
+		{
+			name: "encoded traversal",
+			raw:  "/upbrr/%2e%2e/admin",
+			want: "path traversal",
+		},
+		{
+			name: "query only",
+			raw:  "?base=/upbrr",
+			want: "must include a path",
+		},
+		{
+			name: "fragment only",
+			raw:  "#upbrr",
+			want: "must include a path",
+		},
 	}
 
 	for _, tc := range cases {
@@ -139,13 +215,41 @@ func TestExternalBasePathNormalizesBaseURL(t *testing.T) {
 		raw  string
 		want string
 	}{
-		{name: "empty", raw: "", want: ""},
-		{name: "root absolute url", raw: "https://example.test/", want: ""},
-		{name: "absolute url path", raw: " https://example.test/upbrr/ ", want: "/upbrr"},
-		{name: "path with slash", raw: "/upbrr/", want: "/upbrr"},
-		{name: "path without slash", raw: "upbrr", want: "/upbrr"},
-		{name: "nested path", raw: "https://example.test/tools/upbrr/?token=ignored", want: "/tools/upbrr"},
-		{name: "query only", raw: "https://example.test?token=ignored", want: ""},
+		{
+			name: "empty",
+			raw:  "",
+			want: "",
+		},
+		{
+			name: "root absolute url",
+			raw:  "https://example.test/",
+			want: "",
+		},
+		{
+			name: "absolute url path",
+			raw:  " https://example.test/upbrr/ ",
+			want: "/upbrr",
+		},
+		{
+			name: "path with slash",
+			raw:  "/upbrr/",
+			want: "/upbrr",
+		},
+		{
+			name: "path without slash",
+			raw:  "upbrr",
+			want: "/upbrr",
+		},
+		{
+			name: "nested path",
+			raw:  "https://example.test/tools/upbrr/?token=ignored",
+			want: "/tools/upbrr",
+		},
+		{
+			name: "query only",
+			raw:  "https://example.test?token=ignored",
+			want: "",
+		},
 	}
 
 	for _, tc := range cases {
@@ -166,10 +270,26 @@ func TestJoinBasePath(t *testing.T) {
 		suffix string
 		want   string
 	}{
-		{base: "", suffix: "/api/events", want: "/api/events"},
-		{base: "/", suffix: "/api/events", want: "/api/events"},
-		{base: "/upbrr", suffix: "/api/events", want: "/upbrr/api/events"},
-		{base: "/upbrr/", suffix: "api/events", want: "/upbrr/api/events"},
+		{
+			base:   "",
+			suffix: "/api/events",
+			want:   "/api/events",
+		},
+		{
+			base:   "/",
+			suffix: "/api/events",
+			want:   "/api/events",
+		},
+		{
+			base:   "/upbrr",
+			suffix: "/api/events",
+			want:   "/upbrr/api/events",
+		},
+		{
+			base:   "/upbrr/",
+			suffix: "api/events",
+			want:   "/upbrr/api/events",
+		},
 	}
 
 	for _, tc := range cases {
diff --git a/internal/guishared/browse_directory.go b/internal/webserver/browse_directory.go
similarity index 90%
rename from internal/guishared/browse_directory.go
rename to internal/webserver/browse_directory.go
index f284904f..672fa477 100644
--- a/internal/guishared/browse_directory.go
+++ b/internal/webserver/browse_directory.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026, Audionut and the autobrr contributors.
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-package guishared
+package webserver
 
 import (
 	"errors"
@@ -14,18 +14,26 @@ import (
 	"time"
 
 	"github.com/autobrr/upbrr/internal/filesystem"
-	"github.com/autobrr/upbrr/internal/pathutil"
+	pathutil "github.com/autobrr/upbrr/internal/pathing"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// BrowseDirectory lists an unrestricted host filesystem location. Folder mode
+// returns directories only; file mode also returns recognized video files.
 func BrowseDirectory(req api.BrowseDirectoryRequest, fallbackPath string) (api.BrowseDirectoryResponse, error) {
 	return browseDirectory(req, fallbackPath, "")
 }
 
+// BrowseDirectoryWithinRoot lists a host filesystem location constrained to
+// rootPath after absolute-path and symlink resolution. An empty root disables
+// the constraint.
 func BrowseDirectoryWithinRoot(req api.BrowseDirectoryRequest, fallbackPath string, rootPath string) (api.BrowseDirectoryResponse, error) {
 	return browseDirectory(req, fallbackPath, rootPath)
 }
 
+// BrowseDirectoryWithinRoots lists a host filesystem location constrained to
+// one of rootPaths. An empty request under multiple roots returns a virtual
+// directory containing those roots; an empty root list disables constraints.
 func BrowseDirectoryWithinRoots(req api.BrowseDirectoryRequest, fallbackPath string, rootPaths []string) (api.BrowseDirectoryResponse, error) {
 	return browseDirectoryWithinRoots(req, fallbackPath, rootPaths)
 }
@@ -288,6 +296,9 @@ func browseWindowsRoots(mode string) api.BrowseDirectoryResponse {
 	}
 }
 
+// BrowseDirectoryFallback returns dbPath when it names an existing directory,
+// otherwise its existing parent directory, or an empty string when neither is
+// usable.
 func BrowseDirectoryFallback(dbPath string) string {
 	trimmed := strings.TrimSpace(dbPath)
 	if trimmed == "" {
@@ -306,6 +317,8 @@ func BrowseDirectoryFallback(dbPath string) string {
 	return ""
 }
 
+// ValidateBrowseSelection requires an existing host path of the requested file
+// or directory kind.
 func ValidateBrowseSelection(path string, wantDir bool) error {
 	trimmed := strings.TrimSpace(path)
 	if trimmed == "" {
diff --git a/internal/webserver/browse_test.go b/internal/webserver/browse_test.go
index 93c7534c..46df8d75 100644
--- a/internal/webserver/browse_test.go
+++ b/internal/webserver/browse_test.go
@@ -22,33 +22,6 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-type stubNativePicker struct {
-	filePath        string
-	imageFilePaths  []string
-	folderPath      string
-	fileErr         error
-	imageFilesErr   error
-	folderErr       error
-	fileCalls       int
-	imageFilesCalls int
-	folderCalls     int
-}
-
-func (s *stubNativePicker) BrowseFile() (string, error) {
-	s.fileCalls++
-	return s.filePath, s.fileErr
-}
-
-func (s *stubNativePicker) BrowseImageFiles() ([]string, error) {
-	s.imageFilesCalls++
-	return s.imageFilePaths, s.imageFilesErr
-}
-
-func (s *stubNativePicker) BrowseFolder() (string, error) {
-	s.folderCalls++
-	return s.folderPath, s.folderErr
-}
-
 func testSessionManager() *sessionManager {
 	return &sessionManager{
 		ttl:      time.Hour,
@@ -58,22 +31,6 @@ func testSessionManager() *sessionManager {
 	}
 }
 
-func testServerWithPicker(picker nativePicker) *Server {
-	manager := testSessionManager()
-	manager.sessions["test-session"] = session{
-		ID:        "test-session",
-		Username:  "tester",
-		CSRFToken: "test-csrf",
-		ExpiresAt: time.Now().UTC().Add(time.Hour),
-	}
-	return &Server{
-		picker:         picker,
-		sessions:       manager,
-		generalLimiter: newFixedWindowLimiter(100, time.Minute),
-		authLimiter:    newFixedWindowLimiter(100, time.Minute),
-	}
-}
-
 func testServerWithBackend(t *testing.T, repo *db.SQLiteRepository, cfg config.Config) *Server {
 	t.Helper()
 	manager := testSessionManager()
@@ -140,12 +97,12 @@ func canonicalBrowseTestPath(t *testing.T, path string) string {
 	return resolved
 }
 
-func newBrowseRequest(path string, host string, remoteAddr string) *http.Request {
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, path, strings.NewReader(`{}`))
-	req.Host = host
-	req.RemoteAddr = remoteAddr
+func newBrowseRequest() *http.Request {
+	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/BrowseDirectory", strings.NewReader(`{}`))
+	req.Host = "example.com:8080"
+	req.RemoteAddr = "192.168.1.25:5050"
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Origin", "http://"+host)
+	req.Header.Set("Origin", "http://example.com:8080")
 	req.Header.Set("X-Csrf-Token", "test-csrf")
 	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "test-session"})
 	return req
@@ -176,168 +133,6 @@ func TestIsLoopbackHostname(t *testing.T) {
 	}
 }
 
-func TestHandleAuthStatusIncludesNativeBrowseCapability(t *testing.T) {
-	store, err := newAuthStore(filepath.Join(t.TempDir(), "state", "db.sqlite"))
-	if err != nil {
-		t.Fatalf("newAuthStore: %v", err)
-	}
-	server := &Server{
-		auth:   store,
-		picker: &stubNativePicker{},
-	}
-
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/auth/status", nil)
-	req.Host = "127.0.0.1:8080"
-	req.RemoteAddr = "127.0.0.1:5050"
-
-	recorder := httptest.NewRecorder()
-	server.handleAuthStatus(recorder, req, session{})
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("handleAuthStatus returned %d", recorder.Code)
-	}
-
-	var payload struct {
-		NativeBrowseEnabled bool `json:"nativeBrowseEnabled"`
-	}
-	if err := json.Unmarshal(recorder.Body.Bytes(), &payload); err != nil {
-		t.Fatalf("unmarshal auth status: %v", err)
-	}
-	if !payload.NativeBrowseEnabled {
-		t.Fatal("expected localhost auth status to advertise native browse support")
-	}
-}
-
-func TestBrowseFileRouteAllowsLocalhostSessions(t *testing.T) {
-	picker := &stubNativePicker{filePath: `C:\Media\movie.mkv`}
-	server := testServerWithPicker(picker)
-	mux := http.NewServeMux()
-	server.registerAppRoutes(mux)
-
-	recorder := httptest.NewRecorder()
-	req := newBrowseRequest("/api/app/BrowseFile", "127.0.0.1:8080", "127.0.0.1:5050")
-	mux.ServeHTTP(recorder, req)
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("browse file route returned %d", recorder.Code)
-	}
-	if picker.fileCalls != 1 {
-		t.Fatalf("expected picker to be called once, got %d", picker.fileCalls)
-	}
-	if got := strings.TrimSpace(recorder.Body.String()); !strings.Contains(got, `C:\\Media\\movie.mkv`) {
-		t.Fatalf("expected response to include selected path, got %q", got)
-	}
-}
-
-func TestBrowseImageFilesRouteAllowsLocalhostSessions(t *testing.T) {
-	picker := &stubNativePicker{imageFilePaths: []string{`C:\Menus\menu1.png`, `C:\Menus\menu2.webp`}}
-	server := testServerWithPicker(picker)
-	mux := http.NewServeMux()
-	server.registerAppRoutes(mux)
-
-	recorder := httptest.NewRecorder()
-	req := newBrowseRequest("/api/app/BrowseImageFiles", "127.0.0.1:8080", "127.0.0.1:5050")
-	mux.ServeHTTP(recorder, req)
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("browse image files route returned %d", recorder.Code)
-	}
-	if picker.imageFilesCalls != 1 {
-		t.Fatalf("expected image picker to be called once, got %d", picker.imageFilesCalls)
-	}
-	if got := strings.TrimSpace(recorder.Body.String()); !strings.Contains(got, `C:\\Menus\\menu1.png`) || !strings.Contains(got, `C:\\Menus\\menu2.webp`) {
-		t.Fatalf("expected response to include selected image paths, got %q", got)
-	}
-}
-
-func TestBrowseFileRouteRejectsRemoteSessions(t *testing.T) {
-	picker := &stubNativePicker{filePath: `C:\Media\movie.mkv`}
-	server := testServerWithPicker(picker)
-	mux := http.NewServeMux()
-	server.registerAppRoutes(mux)
-
-	req := newBrowseRequest("/api/app/BrowseFile", "example.com:8080", "192.168.1.25:5050")
-	recorder := httptest.NewRecorder()
-	mux.ServeHTTP(recorder, req)
-
-	if recorder.Code != http.StatusForbidden {
-		t.Fatalf("expected forbidden status, got %d", recorder.Code)
-	}
-	if picker.fileCalls != 0 {
-		t.Fatalf("expected picker not to be called, got %d calls", picker.fileCalls)
-	}
-	if !strings.Contains(recorder.Body.String(), "localhost web sessions") {
-		t.Fatalf("expected remote browse error message, got %q", recorder.Body.String())
-	}
-}
-
-func TestDevelopmentNoAuthAppRouteAllowsLoopbackWithCSRF(t *testing.T) {
-	picker := &stubNativePicker{filePath: `C:\Media\movie.mkv`}
-	server := &Server{
-		picker:            picker,
-		generalLimiter:    newFixedWindowLimiter(100, time.Minute),
-		developmentNoAuth: true,
-		developmentSession: session{
-			ID:        "dev-no-auth",
-			Username:  "dev",
-			CSRFToken: "dev-csrf",
-			ExpiresAt: time.Now().UTC().Add(time.Hour),
-		},
-	}
-	mux := http.NewServeMux()
-	server.registerAppRoutes(mux)
-
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/BrowseFile", strings.NewReader(`{}`))
-	req.Host = "127.0.0.1:7480"
-	req.RemoteAddr = "127.0.0.1:5050"
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Origin", "http://localhost:5173")
-	req.Header.Set("X-Csrf-Token", "dev-csrf")
-
-	recorder := httptest.NewRecorder()
-	mux.ServeHTTP(recorder, req)
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("browse file route returned %d: %s", recorder.Code, recorder.Body.String())
-	}
-	if picker.fileCalls != 1 {
-		t.Fatalf("expected picker to be called once, got %d", picker.fileCalls)
-	}
-}
-
-func TestDevelopmentNoAuthAppRouteRejectsMissingCSRF(t *testing.T) {
-	picker := &stubNativePicker{filePath: `C:\Media\movie.mkv`}
-	server := &Server{
-		picker:            picker,
-		generalLimiter:    newFixedWindowLimiter(100, time.Minute),
-		developmentNoAuth: true,
-		developmentSession: session{
-			ID:        "dev-no-auth",
-			Username:  "dev",
-			CSRFToken: "dev-csrf",
-			ExpiresAt: time.Now().UTC().Add(time.Hour),
-		},
-	}
-	mux := http.NewServeMux()
-	server.registerAppRoutes(mux)
-
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/BrowseFile", strings.NewReader(`{}`))
-	req.Host = "127.0.0.1:8080"
-	req.RemoteAddr = "127.0.0.1:5050"
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Origin", "http://127.0.0.1:8080")
-
-	recorder := httptest.NewRecorder()
-	mux.ServeHTTP(recorder, req)
-
-	if recorder.Code != http.StatusForbidden {
-		t.Fatalf("expected forbidden status, got %d: %s", recorder.Code, recorder.Body.String())
-	}
-	if picker.fileCalls != 0 {
-		t.Fatalf("expected picker not to be called, got %d calls", picker.fileCalls)
-	}
-}
-
 func TestBrowseDirectoryRouteAllowsRemoteSessionsAndSortsEntries(t *testing.T) {
 	repo, dbPath := openBrowseTestRepo(t)
 	root := canonicalBrowseTestPath(t, t.TempDir())
@@ -357,7 +152,7 @@ func TestBrowseDirectoryRouteAllowsRemoteSessionsAndSortsEntries(t *testing.T) {
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	req := newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req := newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(root) + `,"mode":"file"}`))
 	recorder := httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -401,7 +196,7 @@ func TestBrowseDirectoryRouteRequiresWebBrowsePolicy(t *testing.T) {
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	req := newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req := newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(root) + `,"mode":"folder"}`))
 	recorder := httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -615,7 +410,7 @@ func TestBrowseDirectoryRouteHonorsWebAuthBrowseRoot(t *testing.T) {
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	req := newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req := newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":"","mode":"folder"}`))
 	recorder := httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -633,7 +428,7 @@ func TestBrowseDirectoryRouteHonorsWebAuthBrowseRoot(t *testing.T) {
 		t.Fatalf("expected no parent above constrained root, got %q", payload.ParentPath)
 	}
 
-	req = newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req = newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(outside) + `,"mode":"folder"}`))
 	recorder = httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -665,7 +460,7 @@ func TestBrowseDirectoryRouteHonorsMultipleWebAuthBrowseRoots(t *testing.T) {
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	req := newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req := newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":"","mode":"folder"}`))
 	recorder := httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -683,7 +478,7 @@ func TestBrowseDirectoryRouteHonorsMultipleWebAuthBrowseRoots(t *testing.T) {
 		t.Fatalf("expected both configured roots, got %#v", payload.Entries)
 	}
 
-	req = newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req = newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(second) + `,"mode":"folder"}`))
 	recorder = httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -697,7 +492,7 @@ func TestBrowseDirectoryRouteHonorsMultipleWebAuthBrowseRoots(t *testing.T) {
 		t.Fatalf("expected constrained second root, got %#v", payload)
 	}
 
-	req = newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req = newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(outside) + `,"mode":"folder"}`))
 	recorder = httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
@@ -739,7 +534,7 @@ func TestBrowseDirectoryRouteRejectsInvalidPath(t *testing.T) {
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	req := newBrowseRequest("/api/app/BrowseDirectory", "example.com:8080", "192.168.1.25:5050")
+	req := newBrowseRequest()
 	req.Body = io.NopCloser(strings.NewReader(`{"path":` + strconv.Quote(filepath.Join(t.TempDir(), "missing")) + `,"mode":"folder"}`))
 	recorder := httptest.NewRecorder()
 	mux.ServeHTTP(recorder, req)
diff --git a/internal/webserver/canonical_preparation.go b/internal/webserver/canonical_preparation.go
new file mode 100644
index 00000000..c5d88628
--- /dev/null
+++ b/internal/webserver/canonical_preparation.go
@@ -0,0 +1,70 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+var (
+	// ErrCanonicalPreparationUnavailable reports a runtime bundle missing the
+	// canonical prepare/export/import seam.
+	ErrCanonicalPreparationUnavailable = errors.New("canonical preparation capability unavailable")
+)
+
+// PrepareGeneration creates or reuses one canonical generation for a
+// synchronous operation and returns its exact reference.
+func PrepareGeneration(
+	ctx context.Context,
+	preparer ReleasePreparationCapability,
+	request api.Request,
+	intent api.PreparationIntent,
+) (api.PrepareResult, api.ReleaseRef, error) {
+	if capabilityIsNil(preparer) {
+		return api.PrepareResult{}, api.ReleaseRef{}, ErrCanonicalPreparationUnavailable
+	}
+	input, err := api.MapPreparationRequest(request, intent)
+	if err != nil {
+		return api.PrepareResult{}, api.ReleaseRef{}, fmt.Errorf("map canonical preparation request: %w", err)
+	}
+	result, err := preparer.PrepareRelease(ctx, input)
+	if err != nil {
+		return api.PrepareResult{}, api.ReleaseRef{}, fmt.Errorf("prepare canonical generation: %w", err)
+	}
+	ref := api.ReleaseRef{SourcePath: result.Release.Source.SourcePath, Generation: result.Release.Generation}
+	return result, ref, nil
+}
+
+// PrepareAndExportGeneration creates or reuses canonical facts and exports one
+// exact opaque generation seed before a job is accepted.
+func PrepareAndExportGeneration(
+	ctx context.Context,
+	preparer ReleasePreparationCapability,
+	transfer PreparedGenerationTransfer,
+	request api.Request,
+	intent api.PreparationIntent,
+) (api.PrepareResult, preparedrelease.Seed, error) {
+	if capabilityIsNil(preparer) || capabilityIsNil(transfer) {
+		return api.PrepareResult{}, preparedrelease.Seed{}, ErrCanonicalPreparationUnavailable
+	}
+	input, err := api.MapPreparationRequest(request, intent)
+	if err != nil {
+		return api.PrepareResult{}, preparedrelease.Seed{}, fmt.Errorf("map canonical preparation request: %w", err)
+	}
+	result, err := preparer.PrepareRelease(ctx, input)
+	if err != nil {
+		return api.PrepareResult{}, preparedrelease.Seed{}, fmt.Errorf("prepare canonical generation: %w", err)
+	}
+	ref := api.ReleaseRef{SourcePath: result.Release.Source.SourcePath, Generation: result.Release.Generation}
+	seed, err := transfer.ExportReleaseSeed(ctx, ref)
+	if err != nil {
+		return api.PrepareResult{}, preparedrelease.Seed{}, fmt.Errorf("export canonical generation: %w", err)
+	}
+	return result, seed, nil
+}
diff --git a/internal/webserver/canonical_preparation_test.go b/internal/webserver/canonical_preparation_test.go
new file mode 100644
index 00000000..3f8c481b
--- /dev/null
+++ b/internal/webserver/canonical_preparation_test.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestCanonicalPreparationUsesSharedRequestMapper(t *testing.T) {
+	t.Parallel()
+
+	for _, test := range []struct {
+		name  string
+		value string
+		want  api.CanonicalCategory
+	}{
+		{
+			name:  "value",
+			value: "TV",
+			want:  api.CanonicalCategoryTV,
+		},
+		{
+			name:  "explicit clear",
+			value: "",
+			want:  api.CanonicalCategoryUnknown,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			input, err := api.MapPreparationRequest(api.Request{
+				SourcePath:           "Example.Release.2026.mkv",
+				ReleaseNameOverrides: api.ReleaseNameOverrides{Category: &test.value},
+			}, api.PreparationIntentPreview)
+			if err != nil {
+				t.Fatalf("prepare input: %v", err)
+			}
+			if input.Instructions.Category == nil || *input.Instructions.Category != test.want {
+				t.Fatalf("category = %#v, want %q", input.Instructions.Category, test.want)
+			}
+		})
+	}
+}
+
+func TestCanonicalPreparationRejectsInvalidCategoryInstruction(t *testing.T) {
+	t.Parallel()
+	category := "music"
+	_, err := api.MapPreparationRequest(api.Request{
+		SourcePath:           "Example.Release.2026.mkv",
+		ReleaseNameOverrides: api.ReleaseNameOverrides{Category: &category},
+	}, api.PreparationIntentPreview)
+	if err == nil {
+		t.Fatal("expected invalid category error")
+	}
+}
diff --git a/internal/webserver/capabilities.go b/internal/webserver/capabilities.go
new file mode 100644
index 00000000..d4ba9f8a
--- /dev/null
+++ b/internal/webserver/capabilities.go
@@ -0,0 +1,241 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+
+	"github.com/autobrr/upbrr/internal/core"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// LifecycleOwner is the sole shutdown handle for resources behind a capability bundle.
+// Capability interfaces intentionally omit Close so borrowing one never implies ownership.
+type LifecycleOwner interface{ Close() error }
+
+// MetadataCapability prepares metadata previews for WebUI requests.
+type MetadataCapability interface {
+	FetchAcceptedMetadataPreview(context.Context, api.ReleaseRef) (api.MetadataPreview, error)
+}
+
+// ReleasePreparationCapability creates immutable canonical prepared facts.
+type ReleasePreparationCapability interface {
+	PrepareRelease(context.Context, api.PrepareInput) (api.PrepareResult, error)
+}
+
+// SelectionCapability applies an explicit Blu-ray source selection.
+type SelectionCapability interface {
+	SelectBlurayCandidate(context.Context, string, string) (api.MetadataPreview, error)
+}
+
+// PreparationCapability builds preparation views from prepared state.
+type PreparationCapability interface {
+	FetchAcceptedPreparationPreview(context.Context, api.DescriptionInput) (api.PreparationPreview, error)
+}
+
+// UploadReviewCapability builds one review and its execution-only outcomes.
+type UploadReviewCapability interface {
+	ReviewAcceptedUpload(context.Context, api.UploadReviewInput) (api.ReviewedUpload, error)
+}
+
+// DryRunCapability runs tracker payload previews without tracker submission.
+type DryRunCapability interface {
+	RunAcceptedTrackerDryRun(context.Context, api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error)
+}
+
+// DuplicateExecutionCapability runs one accepted duplicate-check snapshot.
+type DuplicateExecutionCapability interface {
+	CheckAcceptedDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error)
+}
+
+// UploadExecutionCapability runs one accepted reviewed upload snapshot.
+type UploadExecutionCapability interface {
+	RunAcceptedUpload(context.Context, api.UploadExecutionPlan) (api.Result, error)
+}
+
+// ScreenshotCapability owns screenshot planning, generation, selection, and deletion workflows.
+type ScreenshotCapability interface {
+	FetchAcceptedScreenshotPlan(context.Context, api.MediaPlanInput) (api.ScreenshotPlan, error)
+	GenerateAcceptedScreenshots(context.Context, api.MediaPlanInput, []api.ScreenshotSelection) (api.ScreenshotResult, error)
+	PreviewAcceptedScreenshotFrame(context.Context, api.MediaPlanInput, float64) (api.ScreenshotPreview, error)
+	DeleteAcceptedScreenshot(context.Context, api.MediaPlanInput, string) error
+	DeleteAcceptedTrackerImageURL(context.Context, api.ImageHostingInput, string) error
+	SaveAcceptedFinalScreenshotSelections(context.Context, api.MediaPlanInput, []api.ScreenshotImage) error
+	ImportAcceptedMenuImages(context.Context, api.MediaPlanInput, []string) error
+}
+
+// HostedImageCapability owns upload-candidate and hosted-image workflows.
+type HostedImageCapability interface {
+	ListAcceptedUploadCandidates(context.Context, api.ImageHostingInput) ([]api.ScreenshotImage, error)
+	ListAcceptedUploadedImages(context.Context, api.ImageHostingInput) ([]api.UploadedImageLink, error)
+	UploadAcceptedImages(context.Context, api.ImageHostingInput, []api.ScreenshotImage) (api.UploadImagesResult, error)
+	DeleteAcceptedUploadedImage(context.Context, api.ImageHostingInput, string, string) error
+}
+
+// DVDCaptureCapability captures DVD menu images for a prepared request.
+type DVDCaptureCapability interface {
+	CaptureAcceptedDVDMenus(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error)
+}
+
+// DVDCapability owns DVD menu capture and prepared-image maintenance.
+type DVDCapability interface {
+	DVDCaptureCapability
+	ListAcceptedDVDMenuScreenshots(context.Context, api.MediaPlanInput) ([]api.ScreenshotImage, error)
+	DeleteAcceptedDVDMenuScreenshot(context.Context, api.MediaPlanInput, string) error
+}
+
+// DescriptionCapability previews, renders, and persists prepared-release descriptions.
+type DescriptionCapability interface {
+	FetchAcceptedDescriptionBuilderPreview(context.Context, api.DescriptionInput) (api.DescriptionBuilderPreview, error)
+	FetchAcceptedDescriptionBuilderGroupPreview(context.Context, api.DescriptionInput) (api.DescriptionBuilderGroup, error)
+	RenderDescription(context.Context, string) (string, error)
+	SaveAcceptedDescriptionOverride(context.Context, api.DescriptionInput, string) (api.DescriptionBuilderGroup, error)
+}
+
+// PlaylistCapability discovers BDMV playlists for one preparation source.
+type PlaylistCapability interface {
+	DiscoverPlaylists(context.Context, string) ([]api.PlaylistInfo, error)
+}
+
+// HistoryCapability reads and deletes persisted release history.
+type HistoryCapability interface {
+	ListHistory(context.Context) ([]api.HistoryEntry, error)
+	GetHistoryOverview(context.Context, string) (api.HistoryOverview, error)
+	DeleteHistoryRelease(context.Context, string) error
+	DeleteAllHistoryReleases(context.Context) (int, error)
+}
+
+// PreparedGenerationTransfer moves one exact canonical generation without
+// carrying workflow choices or outcomes.
+type PreparedGenerationTransfer interface {
+	ExportReleaseSeed(context.Context, api.ReleaseRef) (preparedrelease.Seed, error)
+	ImportReleaseSeed(context.Context, preparedrelease.Seed) (api.ReleaseRef, error)
+}
+
+// DiagnosticProbeCapability reports availability of optional runtime tooling.
+type DiagnosticProbeCapability interface {
+	DVDMenuCapability(context.Context) (api.DVDMenuEngineInfo, error)
+}
+
+// CoreCapabilities is the explicit WebUI workflow bundle. Each field is a
+// narrow view of one concrete core; lifecycle ownership remains separate.
+// Fields are independently optional so consumers and tests can supply only the
+// workflows they invoke. Production bindings populate every field.
+type CoreCapabilities struct {
+	Metadata                   MetadataCapability
+	ReleasePreparation         ReleasePreparationCapability
+	Selection                  SelectionCapability
+	Preparation                PreparationCapability
+	UploadReview               UploadReviewCapability
+	DryRun                     DryRunCapability
+	DuplicateExecution         DuplicateExecutionCapability
+	UploadExecution            UploadExecutionCapability
+	Screenshots                ScreenshotCapability
+	HostedImages               HostedImageCapability
+	DVD                        DVDCapability
+	Description                DescriptionCapability
+	Playlists                  PlaylistCapability
+	History                    HistoryCapability
+	PreparedGenerationTransfer PreparedGenerationTransfer
+	DiagnosticProbe            DiagnosticProbeCapability
+}
+
+// Available reports whether at least one capability is installed.
+// It does not validate that a bundle contains every capability a caller needs.
+func (c CoreCapabilities) Available() bool {
+	if CapabilityAvailable(c.Metadata) || CapabilityAvailable(c.ReleasePreparation) || CapabilityAvailable(c.Selection) ||
+		CapabilityAvailable(c.Preparation) || CapabilityAvailable(c.UploadReview) || CapabilityAvailable(c.DryRun) ||
+		CapabilityAvailable(c.DuplicateExecution) ||
+		CapabilityAvailable(c.UploadExecution) {
+		return true
+	}
+	if CapabilityAvailable(c.Screenshots) || CapabilityAvailable(c.HostedImages) || CapabilityAvailable(c.DVD) || CapabilityAvailable(c.Description) ||
+		CapabilityAvailable(c.Playlists) || CapabilityAvailable(c.History) {
+		return true
+	}
+	return CapabilityAvailable(c.PreparedGenerationTransfer) || CapabilityAvailable(c.DiagnosticProbe)
+}
+
+// CapabilityAvailable reports whether capability contains a callable value,
+// rejecting both nil interfaces and interfaces holding typed nil values.
+func CapabilityAvailable(capability any) bool {
+	return !capabilityIsNil(capability)
+}
+
+// PreparedGenerationReady reports whether canonical generations can be
+// prepared and transferred through this bundle.
+func (c CoreCapabilities) PreparedGenerationReady() bool {
+	return CapabilityAvailable(c.ReleasePreparation) && CapabilityAvailable(c.PreparedGenerationTransfer)
+}
+
+// PreparedUploadReady reports whether this bundle can receive state and execute an upload.
+func (c CoreCapabilities) PreparedUploadReady() bool {
+	return c.PreparedGenerationReady() && CapabilityAvailable(c.UploadExecution)
+}
+
+// PreparedDupeReady reports whether this bundle can receive state and execute a dupe check.
+func (c CoreCapabilities) PreparedDupeReady() bool {
+	return c.PreparedGenerationReady() && CapabilityAvailable(c.DuplicateExecution)
+}
+
+// PreparedDVDReady reports whether this bundle can receive state and execute DVD capture.
+func (c CoreCapabilities) PreparedDVDReady() bool {
+	return c.PreparedGenerationReady() && CapabilityAvailable(c.DVD)
+}
+
+// PreparedDryRunReady reports whether the active runtime can execute a dry run.
+// Unlike background Jobs, synchronous dry runs already own the prepared
+// generation and do not require generation transfer.
+func (c CoreCapabilities) PreparedDryRunReady() bool {
+	return CapabilityAvailable(c.DryRun)
+}
+
+// BindCoreCapabilities exposes svc through every production capability and
+// returns svc separately as its lifecycle owner. A nil service yields an empty
+// bundle and nil owner; callers must close the returned owner exactly once.
+func BindCoreCapabilities(svc *core.Core) (CoreCapabilities, LifecycleOwner) {
+	if svc == nil {
+		return CoreCapabilities{}, nil
+	}
+	return CoreCapabilities{
+		Metadata:                   svc,
+		ReleasePreparation:         svc,
+		Selection:                  svc,
+		Preparation:                svc,
+		UploadReview:               svc,
+		DryRun:                     svc,
+		DuplicateExecution:         svc,
+		UploadExecution:            svc,
+		Screenshots:                svc,
+		HostedImages:               svc,
+		DVD:                        svc,
+		Description:                svc,
+		Playlists:                  svc,
+		History:                    svc,
+		PreparedGenerationTransfer: svc,
+		DiagnosticProbe:            svc,
+	}, svc
+}
+
+var (
+	_ MetadataCapability           = (*core.Core)(nil)
+	_ ReleasePreparationCapability = (*core.Core)(nil)
+	_ SelectionCapability          = (*core.Core)(nil)
+	_ PreparationCapability        = (*core.Core)(nil)
+	_ UploadReviewCapability       = (*core.Core)(nil)
+	_ DryRunCapability             = (*core.Core)(nil)
+	_ DuplicateExecutionCapability = (*core.Core)(nil)
+	_ UploadExecutionCapability    = (*core.Core)(nil)
+	_ ScreenshotCapability         = (*core.Core)(nil)
+	_ HostedImageCapability        = (*core.Core)(nil)
+	_ DVDCapability                = (*core.Core)(nil)
+	_ DVDCaptureCapability         = (*core.Core)(nil)
+	_ DescriptionCapability        = (*core.Core)(nil)
+	_ PlaylistCapability           = (*core.Core)(nil)
+	_ HistoryCapability            = (*core.Core)(nil)
+	_ PreparedGenerationTransfer   = (*core.Core)(nil)
+	_ DiagnosticProbeCapability    = (*core.Core)(nil)
+	_ LifecycleOwner               = (*core.Core)(nil)
+)
diff --git a/internal/webserver/config_import_test.go b/internal/webserver/config_import_test.go
new file mode 100644
index 00000000..c76378bd
--- /dev/null
+++ b/internal/webserver/config_import_test.go
@@ -0,0 +1,81 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+)
+
+func TestRouteImportConfigAcceptsEscapedEnvelopeAtRawCap(t *testing.T) {
+	t.Parallel()
+
+	repo, dbPath := openBrowseTestRepo(t)
+	if err := authmaterial.BootstrapAuthFile(dbPath, "tester", "long-enough-password"); err != nil {
+		t.Fatalf("BootstrapAuthFile: %v", err)
+	}
+	server := testServerWithBackend(t, repo, config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+	content := "#" + strings.Repeat("<", configImportMaxBytes-1)
+	body, err := json.Marshal(map[string]string{
+		"FileName":    "config.yaml",
+		"FileContent": content,
+	})
+	if err != nil {
+		t.Fatalf("marshal request: %v", err)
+	}
+	if len(body) <= configImportMaxBytes+1024*1024 {
+		t.Fatalf("test envelope did not exceed prior cap: got %d", len(body))
+	}
+
+	mux := http.NewServeMux()
+	server.registerAppRoutes(mux)
+	recorder := httptest.NewRecorder()
+	mux.ServeHTTP(recorder, configImportRouteRequest(body))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("expected escaped envelope import to succeed, got %d: %s", recorder.Code, recorder.Body.String())
+	}
+}
+
+func TestRouteImportConfigRejectsEnvelopeOverRouteCap(t *testing.T) {
+	t.Parallel()
+
+	repo, dbPath := openBrowseTestRepo(t)
+	server := testServerWithBackend(t, repo, config.Config{MainSettings: config.MainSettingsConfig{DBPath: dbPath}})
+	mux := http.NewServeMux()
+	server.registerAppRoutes(mux)
+	body := append(bytes.Repeat([]byte(" "), configImportRequestEnvelopeMaxBytes+1), 'x')
+	recorder := httptest.NewRecorder()
+
+	mux.ServeHTTP(recorder, configImportRouteRequest(body))
+	if recorder.Code != http.StatusBadRequest {
+		t.Fatalf("expected route cap rejection, got %d: %s", recorder.Code, recorder.Body.String())
+	}
+	if !strings.Contains(recorder.Body.String(), "request body too large") {
+		t.Fatalf("expected body-too-large error, got %s", recorder.Body.String())
+	}
+}
+
+func configImportRouteRequest(body []byte) *http.Request {
+	req := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost,
+		"/api/app/ImportConfig",
+		bytes.NewReader(body),
+	)
+	req.Host = "127.0.0.1:8080"
+	req.RemoteAddr = "127.0.0.1:5050"
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Origin", "http://127.0.0.1:8080")
+	req.Header.Set("X-Csrf-Token", "test-csrf")
+	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "test-session"})
+	return req
+}
diff --git a/internal/webserver/dvd_menu_jobs.go b/internal/webserver/dvd_menu_jobs.go
index a8e12c85..175d2f32 100644
--- a/internal/webserver/dvd_menu_jobs.go
+++ b/internal/webserver/dvd_menu_jobs.go
@@ -7,414 +7,124 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sort"
-	"strings"
-	"sync"
-	"time"
 
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/redaction"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-const (
-	errDVDMenuCaptureRequiresMetadataCache = "DVD menu capture requires metadata preview"
-	maxCompletedDVDMenuJobs                = 200
-	dvdMenuSnapshotThrottle                = 150 * time.Millisecond
-)
+type acceptedDVDCapture interface {
+	CaptureAcceptedDVDMenus(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error)
+}
 
-// dvdMenuCaptureJob owns one isolated core/logger snapshot and synchronized
-// session-visible progress state.
-type dvdMenuCaptureJob struct {
-	mu             sync.Mutex
-	cleanupOnce    sync.Once
-	sessionID      string
-	id             string
-	sourcePath     string
-	uploadOptions  api.UploadOptions
-	core           api.Core
-	logger         interface{ Close() error }
-	overrides      api.ExternalIDOverrides
-	nameOverrides  api.ReleaseNameOverrides
-	status         string
-	phase          string
-	message        string
-	discovered     int
-	visitedStates  int
-	visitedButtons int
-	captured       int
-	warnings       int
-	result         api.DVDMenuCaptureResult
-	errorMessage   string
-	startedAt      time.Time
-	finishedAt     time.Time
-	lastEmit       time.Time
-	cancel         context.CancelFunc
+type webDVDRunner struct {
+	core     acceptedDVDCapture
+	target   PreparedGenerationTransfer
+	seed     preparedrelease.Seed
+	expected api.ReleaseRef
 }
 
-// StartDVDMenuCapture starts a session-owned background DVD menu capture job
-// using cached prepared metadata. The returned job continues after the request
-// context ends and emits dvdmenu:job:<jobID> only to the owning session.
-func (b *Backend) StartDVDMenuCapture(ctx context.Context, sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) (string, error) {
-	rt, err := b.requireRuntime()
+func (r webDVDRunner) CaptureAcceptedDVDMenus(ctx context.Context, input api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	ref, err := r.target.ImportReleaseSeed(ctx, r.seed)
 	if err != nil {
-		return "", err
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("import canonical generation: %w", err)
 	}
-	if ctx == nil {
-		return "", errors.New("request context is required")
+	if ref != r.expected {
+		return api.DVDMenuCaptureResult{}, errors.New("import canonical generation: unexpected release reference")
 	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
+	result, err := r.core.CaptureAcceptedDVDMenus(ctx, input)
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("web: capture accepted DVD menus: %w", err)
 	}
-	req := newWebDVDMenuRequest(trimmedPath, overrides, nameOverrides, rt.baseUploadOptions())
+	return result, nil
+}
 
-	var preparedMeta api.PreparedMetadata
-	preparedMetaFound := false
-	if exporter, ok := rt.core.(guishared.PreparedMetaExporter); ok {
-		preparedMeta, preparedMetaFound, err = exporter.ExportGUICachedPreparedMeta(ctx, req)
-		if err != nil {
-			return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
-		}
-		if !preparedMetaFound {
-			return "", errors.New(errDVDMenuCaptureRequiresMetadataCache)
-		}
+// CaptureDVDMenus executes one exact-generation media operation. Request
+// cancellation reaches Core and the operation is not retained as a Job.
+func (b *Backend) CaptureDVDMenus(
+	ctx context.Context,
+	release api.ReleaseRef,
+) (api.DVDMenuCaptureResult, error) {
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, err
 	}
-	if err := ctx.Err(); err != nil {
-		return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
+	if !rt.capabilities.PreparedGenerationReady() {
+		return api.DVDMenuCaptureResult{}, ErrPreparedGenerationUnavailable
 	}
-	//nolint:contextcheck // Per-run core construction has no context-aware API; request context is checked before and after setup.
-	runCore, runLogger, err := b.buildRunCoreFromSnapshot(rt, runOptions{})
-	if err != nil {
-		return "", err
+	if ctx == nil {
+		return api.DVDMenuCaptureResult{}, errors.New("request context is required")
 	}
-	if err := ctx.Err(); err != nil {
-		_ = runCore.Close()
-		_ = runLogger.Close()
-		return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
+	expectedRef, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, err
 	}
-	if preparedMetaFound {
-		importer, ok := runCore.(guishared.PreparedMetaImporter)
-		if !ok {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", errors.New("DVD menu capture metadata preview cache: run core cannot import prepared metadata")
-		}
-		if err := importer.ImportPreparedMetadataForGUI(ctx, req, preparedMeta); err != nil {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", fmt.Errorf("DVD menu capture metadata preview cache: %w", err)
-		}
+	seed, err := rt.capabilities.PreparedGenerationTransfer.ExportReleaseSeed(ctx, expectedRef)
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("DVD menu capture exact generation: %w", err)
 	}
-
-	job := &dvdMenuCaptureJob{
-		sessionID:     strings.TrimSpace(sessionID),
-		id:            randomJobID(),
-		sourcePath:    trimmedPath,
-		uploadOptions: req.Options,
-		core:          runCore,
-		logger:        runLogger,
-		overrides:     overrides,
-		nameOverrides: nameOverrides,
-		status:        "queued",
-		phase:         "queued",
-		message:       "DVD menu capture queued.",
-		startedAt:     time.Now().UTC(),
+	if err := ctx.Err(); err != nil {
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("DVD menu capture canceled before setup: %w", err)
 	}
-	jobCtx, cancel := context.WithCancel(context.WithoutCancel(ctx))
-	job.cancel = cancel
 
-	b.dvdMenuMu.Lock()
-	if b.dvdMenus == nil {
-		b.dvdMenus = make(map[string]*dvdMenuCaptureJob)
+	runCapabilities, runOwner, runLogger, err := b.buildRunCoreFromSnapshot(ctx, rt, runOptions{})
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, err
 	}
-	b.dvdMenus[job.id] = job
-	b.pruneCompletedDVDMenuJobsLocked(maxCompletedDVDMenuJobs)
-	b.dvdMenuWG.Add(1)
-	b.dvdMenuMu.Unlock()
-	b.emitDVDMenuCaptureSnapshot(job, true)
-	go func() {
-		defer cancel()
-		b.runDVDMenuCaptureJob(jobCtx, job)
-	}()
-	return job.id, nil
-}
-
-// GetDVDMenuCaptureSnapshot returns a capture job only to its owning session.
-// Unknown, expired, and foreign-session job IDs return the same not-found error.
-func (b *Backend) GetDVDMenuCaptureSnapshot(sessionID string, jobID string) (api.DVDMenuCaptureSnapshot, error) {
-	job := b.getDVDMenuCaptureJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return api.DVDMenuCaptureSnapshot{}, errors.New("DVD menu capture job not found")
+	defer closeJobResources(runOwner, runLogger)
+	if err := ctx.Err(); err != nil {
+		return api.DVDMenuCaptureResult{}, fmt.Errorf("DVD menu capture canceled after setup: %w", err)
 	}
-	return buildWebDVDMenuCaptureSnapshot(job), nil
-}
-
-// CancelDVDMenuCapture requests cancellation only for an owned capture job.
-// Completion is asynchronous and is reflected in later snapshots.
-func (b *Backend) CancelDVDMenuCapture(sessionID string, jobID string) error {
-	job := b.getDVDMenuCaptureJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return errors.New("DVD menu capture job not found")
+	if !runCapabilities.PreparedDVDReady() {
+		return api.DVDMenuCaptureResult{}, ErrPreparedDVDUnavailable
 	}
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
+	result, err := (webDVDRunner{
+		core:     runCapabilities.DVD,
+		target:   runCapabilities.PreparedGenerationTransfer,
+		seed:     seed,
+		expected: expectedRef,
+	}).CaptureAcceptedDVDMenus(ctx, api.MediaPlanInput{Release: expectedRef})
+	if err != nil {
+		return api.DVDMenuCaptureResult{}, err
 	}
-	return nil
+	return result, nil
 }
 
-// ListDVDMenuScreenshots returns persisted manual and automatic menu images for
-// one host filesystem source path. The call requires prepared GUI metadata.
-func (b *Backend) ListDVDMenuScreenshots(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides) ([]api.ScreenshotImage, error) {
+// ListDVDMenuScreenshots returns persisted manual and automatic menu images for a prepared DVD.
+func (b *Backend) ListDVDMenuScreenshots(
+	release api.ReleaseRef,
+) ([]api.ScreenshotImage, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return nil, err
 	}
+	dvdMenuCore, err := rt.dvdMenuCore()
+	if err != nil {
+		return nil, err
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := newWebDVDMenuRequest(path, overrides, nameOverrides, rt.baseUploadOptions())
-	return wrapWebResult(rt.core.ListDVDMenuScreenshots(ctx, req))
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
+	if err != nil {
+		return nil, err
+	}
+	return wrapWebResult(dvdMenuCore.ListAcceptedDVDMenuScreenshots(ctx, api.MediaPlanInput{Release: ref}))
 }
 
-// DeleteDVDMenuScreenshot removes one persisted image from the prepared
-// release's managed directory and local records. Remote-host assets remain.
-func (b *Backend) DeleteDVDMenuScreenshot(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, imagePath string) error {
+// DeleteDVDMenuScreenshot removes one managed DVD menu image and its prepared-release reference.
+func (b *Backend) DeleteDVDMenuScreenshot(release api.ReleaseRef, imagePath string) error {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return err
 	}
+	dvdMenuCore, err := rt.dvdMenuCore()
+	if err != nil {
+		return err
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), previewTimeout)
 	defer cancel()
-	req := newWebDVDMenuRequest(path, overrides, nameOverrides, rt.baseUploadOptions())
-	return wrapWebError(rt.core.DeleteDVDMenuScreenshot(ctx, req, imagePath))
-}
-
-func newWebDVDMenuRequest(path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, options api.UploadOptions) api.Request {
-	return api.Request{
-		Paths:                []string{strings.TrimSpace(path)},
-		Mode:                 api.ModeGUI,
-		Options:              options,
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-}
-
-// runDVDMenuCaptureJob owns the queued-to-terminal lifecycle, releases its
-// per-run resources, and schedules completed-job retention cleanup.
-func (b *Backend) runDVDMenuCaptureJob(ctx context.Context, job *dvdMenuCaptureJob) {
-	defer b.dvdMenuWG.Done()
-	defer job.closeResources()
-	if job == nil || job.core == nil {
-		return
-	}
-	job.mu.Lock()
-	job.status = "running"
-	job.phase = "preflight"
-	job.message = "Checking DVD menu capture support."
-	job.mu.Unlock()
-	b.emitDVDMenuCaptureSnapshot(job, true)
-
-	progressCtx := api.WithDVDMenuProgressReporter(ctx, func(update api.DVDMenuProgressUpdate) {
-		b.applyDVDMenuCaptureProgress(job, update)
-	})
-	req := newWebDVDMenuRequest(job.sourcePath, job.overrides, job.nameOverrides, job.uploadOptions)
-	result, err := job.core.CaptureDVDMenus(progressCtx, req)
-
-	job.mu.Lock()
-	job.result = result
-	job.finishedAt = time.Now().UTC()
-	job.cancel = nil
-	job.discovered = result.DiscoveredMenus
-	job.visitedStates = result.VisitedStates
-	job.visitedButtons = result.VisitedButtons
-	job.captured = len(result.Images)
-	job.warnings = len(result.Warnings)
+	ref, err := normalizeExactRelease(release, api.OperationKindMedia)
 	if err != nil {
-		if ctx.Err() != nil {
-			job.status = "canceled"
-			job.phase = "canceled"
-			job.message = "DVD menu capture canceled."
-			job.errorMessage = "DVD menu capture canceled"
-		} else {
-			job.status = "failed"
-			job.phase = "failed"
-			job.message = "DVD menu capture failed."
-			job.errorMessage = redaction.RedactValue(err.Error(), nil)
-		}
-	} else {
-		job.status = "completed"
-		job.phase = "complete"
-		job.message = "DVD menu capture finished."
-		job.errorMessage = ""
-	}
-	job.mu.Unlock()
-	b.emitDVDMenuCaptureSnapshot(job, true)
-	b.scheduleDVDMenuJobCleanup(job)
-}
-
-func (b *Backend) applyDVDMenuCaptureProgress(job *dvdMenuCaptureJob, update api.DVDMenuProgressUpdate) {
-	job.mu.Lock()
-	if strings.TrimSpace(update.Phase) != "" {
-		job.phase = strings.TrimSpace(update.Phase)
-	}
-	if strings.TrimSpace(update.Message) != "" {
-		job.message = strings.TrimSpace(update.Message)
-	}
-	job.discovered = update.DiscoveredMenus
-	job.visitedStates = update.VisitedStates
-	job.visitedButtons = update.VisitedButtons
-	job.captured = update.CapturedCount
-	job.warnings = update.WarningCount
-	job.mu.Unlock()
-	b.emitDVDMenuCaptureSnapshot(job, false)
-}
-
-// emitDVDMenuCaptureSnapshot publishes a throttled session event; force
-// bypasses throttling for queued and terminal transitions.
-func (b *Backend) emitDVDMenuCaptureSnapshot(job *dvdMenuCaptureJob, force bool) {
-	if b == nil || b.hub == nil || job == nil {
-		return
-	}
-	job.mu.Lock()
-	if !force && time.Since(job.lastEmit) < dvdMenuSnapshotThrottle {
-		job.mu.Unlock()
-		return
-	}
-	job.lastEmit = time.Now()
-	job.mu.Unlock()
-	b.hub.Emit(job.sessionID, "dvdmenu:job:"+job.id, buildWebDVDMenuCaptureSnapshot(job))
-}
-
-func buildWebDVDMenuCaptureSnapshot(job *dvdMenuCaptureJob) api.DVDMenuCaptureSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	return api.DVDMenuCaptureSnapshot{
-		JobID:           job.id,
-		SourcePath:      job.sourcePath,
-		Status:          job.status,
-		Phase:           job.phase,
-		Message:         job.message,
-		DiscoveredMenus: job.discovered,
-		VisitedStates:   job.visitedStates,
-		VisitedButtons:  job.visitedButtons,
-		CapturedCount:   job.captured,
-		WarningCount:    job.warnings,
-		Result:          job.result,
-		Error:           job.errorMessage,
-		StartedAt:       formatTime(job.startedAt),
-		FinishedAt:      formatTime(job.finishedAt),
-	}
-}
-
-func (b *Backend) getDVDMenuCaptureJob(jobID string) *dvdMenuCaptureJob {
-	if strings.TrimSpace(jobID) == "" {
-		return nil
-	}
-	b.dvdMenuMu.Lock()
-	defer b.dvdMenuMu.Unlock()
-	return b.dvdMenus[jobID]
-}
-
-func (b *Backend) getDVDMenuCaptureJobForSession(sessionID string, jobID string) *dvdMenuCaptureJob {
-	job := b.getDVDMenuCaptureJob(jobID)
-	if job == nil {
-		return nil
-	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	if strings.TrimSpace(job.sessionID) != sessionID {
-		return nil
-	}
-	return job
-}
-
-// closeResources closes the per-run core and logger at most once.
-func (job *dvdMenuCaptureJob) closeResources() {
-	if job == nil {
-		return
-	}
-	job.cleanupOnce.Do(func() {
-		job.mu.Lock()
-		coreSvc := job.core
-		logger := job.logger
-		job.core = nil
-		job.logger = nil
-		job.mu.Unlock()
-		if coreSvc != nil {
-			_ = coreSvc.Close()
-		}
-		if logger != nil {
-			_ = logger.Close()
-		}
-	})
-}
-
-func (b *Backend) scheduleDVDMenuJobCleanup(job *dvdMenuCaptureJob) {
-	b.dvdMenuMu.Lock()
-	b.pruneCompletedDVDMenuJobsLocked(maxCompletedDVDMenuJobs)
-	b.dvdMenuMu.Unlock()
-	time.AfterFunc(completedJobRetention, func() {
-		b.dvdMenuMu.Lock()
-		defer b.dvdMenuMu.Unlock()
-		if current := b.dvdMenus[job.id]; current == job && isDVDMenuJobTerminal(job) {
-			delete(b.dvdMenus, job.id)
-		}
-	})
-}
-
-func (b *Backend) pruneCompletedDVDMenuJobsLocked(maxCompleted int) {
-	if maxCompleted <= 0 {
-		return
-	}
-	completed := make([]*dvdMenuCaptureJob, 0, len(b.dvdMenus))
-	for _, job := range b.dvdMenus {
-		if isDVDMenuJobTerminal(job) {
-			completed = append(completed, job)
-		}
-	}
-	if len(completed) <= maxCompleted {
-		return
-	}
-	sort.Slice(completed, func(i, j int) bool {
-		return completed[i].finishedAt.Before(completed[j].finishedAt)
-	})
-	for _, job := range completed[:len(completed)-maxCompleted] {
-		delete(b.dvdMenus, job.id)
-	}
-}
-
-func isDVDMenuJobTerminal(job *dvdMenuCaptureJob) bool {
-	if job == nil {
-		return false
-	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	return job.status == "completed" || job.status == "failed" || job.status == "canceled"
-}
-
-func (b *Backend) stopAllDVDMenuJobs() {
-	if b == nil {
-		return
-	}
-	b.dvdMenuMu.Lock()
-	jobs := make([]*dvdMenuCaptureJob, 0, len(b.dvdMenus))
-	for _, job := range b.dvdMenus {
-		jobs = append(jobs, job)
-	}
-	b.dvdMenuMu.Unlock()
-	for _, job := range jobs {
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
-	}
-	b.dvdMenuWG.Wait()
-	for _, job := range jobs {
-		job.closeResources()
+		return err
 	}
+	return wrapWebError(dvdMenuCore.DeleteAcceptedDVDMenuScreenshot(ctx, api.MediaPlanInput{Release: ref}, imagePath))
 }
diff --git a/internal/webserver/dvd_menu_jobs_test.go b/internal/webserver/dvd_menu_jobs_test.go
index 8f321905..d9a4d010 100644
--- a/internal/webserver/dvd_menu_jobs_test.go
+++ b/internal/webserver/dvd_menu_jobs_test.go
@@ -6,113 +6,42 @@ package webserver
 import (
 	"context"
 	"errors"
-	"strings"
 	"testing"
-	"time"
 
+	"github.com/autobrr/upbrr/internal/preparedrelease"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-func TestRunDVDMenuCaptureJobPublishesProgressAndResult(t *testing.T) {
-	t.Parallel()
+type acceptedDVDCaptureFunc func(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error)
 
-	coreSvc := &preparedMetaTestCore{
-		dvdMenuCapture: func(ctx context.Context, _ api.Request) (api.DVDMenuCaptureResult, error) {
-			api.ReportDVDMenuProgress(ctx, api.DVDMenuProgressUpdate{
-				Phase:           "capturing",
-				DiscoveredMenus: 2,
-				VisitedStates:   4,
-				VisitedButtons:  3,
-				CapturedCount:   1,
-			})
-			return api.DVDMenuCaptureResult{
-				SourcePath:      "Example.Release.2026.1080p-GRP",
-				DiscoveredMenus: 2,
-				VisitedStates:   4,
-				VisitedButtons:  3,
-				Complete:        true,
-				Images: []api.DVDMenuCaptureImage{{ScreenshotImage: api.ScreenshotImage{
-					Path:    "menu-1.png",
-					Purpose: api.ScreenshotPurposeMenu,
-				}}},
-			}, nil
-		},
-	}
-	job := &dvdMenuCaptureJob{
-		sessionID: "session-a",
-		id:        "dvd-job-1",
-		core:      coreSvc,
-		status:    "queued",
-		startedAt: time.Now().UTC(),
-	}
-	backend := &Backend{dvdMenus: map[string]*dvdMenuCaptureJob{job.id: job}}
-	backend.dvdMenuWG.Add(1)
-
-	backend.runDVDMenuCaptureJob(context.Background(), job)
-	snapshot := buildWebDVDMenuCaptureSnapshot(job)
-	if snapshot.Status != "completed" || snapshot.CapturedCount != 1 || !snapshot.Result.Complete {
-		t.Fatalf("unexpected terminal snapshot: %#v", snapshot)
-	}
-	if coreSvc.dvdMenuCalls != 1 {
-		t.Fatalf("expected one capture call, got %d", coreSvc.dvdMenuCalls)
-	}
-	if coreSvc.closeCalls != 1 {
-		t.Fatalf("expected one core close, got %d", coreSvc.closeCalls)
-	}
+func (fn acceptedDVDCaptureFunc) CaptureAcceptedDVDMenus(ctx context.Context, input api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	return fn(ctx, input)
 }
 
-func TestRunDVDMenuCaptureJobRedactsFailureMessage(t *testing.T) {
-	t.Parallel()
+type dvdGenerationTransfer struct{ release api.ReleaseRef }
 
-	coreSvc := &preparedMetaTestCore{
-		dvdMenuCapture: func(context.Context, api.Request) (api.DVDMenuCaptureResult, error) {
-			return api.DVDMenuCaptureResult{}, errors.New("provider rejected api_key=secret-value")
-		},
-	}
-	job := &dvdMenuCaptureJob{
-		sessionID: "session-a",
-		id:        "dvd-job-1",
-		core:      coreSvc,
-		status:    "queued",
-		startedAt: time.Now().UTC(),
-	}
-	backend := &Backend{dvdMenus: map[string]*dvdMenuCaptureJob{job.id: job}}
-	backend.dvdMenuWG.Add(1)
+func (transfer dvdGenerationTransfer) ExportReleaseSeed(context.Context, api.ReleaseRef) (preparedrelease.Seed, error) {
+	return preparedrelease.Seed{}, nil
+}
 
-	backend.runDVDMenuCaptureJob(context.Background(), job)
-	snapshot := buildWebDVDMenuCaptureSnapshot(job)
-	if snapshot.Status != "failed" {
-		t.Fatal("expected failed snapshot")
-	}
-	if strings.Contains(snapshot.Error, "secret-value") || !strings.Contains(snapshot.Error, "[REDACTED]") {
-		t.Fatal("expected redacted DVD menu capture error")
-	}
+func (transfer dvdGenerationTransfer) ImportReleaseSeed(context.Context, preparedrelease.Seed) (api.ReleaseRef, error) {
+	return transfer.release, nil
 }
 
-func TestDVDMenuCaptureJobAccessRequiresOwningSession(t *testing.T) {
+func TestWebDVDMenuRunnerPropagatesRequestCancellation(t *testing.T) {
 	t.Parallel()
-
-	job := &dvdMenuCaptureJob{
-		sessionID: "session-a",
-		id:        "dvd-job-1",
-		status:    "running",
-		startedAt: time.Now().UTC(),
-	}
-	backend := &Backend{dvdMenus: map[string]*dvdMenuCaptureJob{job.id: job}}
-
-	if _, err := backend.GetDVDMenuCaptureSnapshot("session-b", job.id); err == nil || err.Error() != "DVD menu capture job not found" {
-		t.Fatal("expected foreign session snapshot read to use the not-found privacy response")
-	}
-	if err := backend.CancelDVDMenuCapture("session-b", job.id); err == nil || err.Error() != "DVD menu capture job not found" {
-		t.Fatal("expected foreign session cancellation to use the not-found privacy response")
-	}
-	if _, err := backend.GetDVDMenuCaptureSnapshot("session-b", "missing-job"); err == nil || err.Error() != "DVD menu capture job not found" {
-		t.Fatal("expected unknown snapshot read to use the same not-found privacy response")
-	}
-	if err := backend.CancelDVDMenuCapture("session-b", "missing-job"); err == nil || err.Error() != "DVD menu capture job not found" {
-		t.Fatal("expected unknown cancellation to use the same not-found privacy response")
-	}
-	if _, err := backend.GetDVDMenuCaptureSnapshot("session-a", job.id); err != nil {
-		t.Fatalf("expected owning session snapshot read: %v", err)
+	release := api.ReleaseRef{SourcePath: `C:\Example\Example.Release.2026.1080p-GRP`, Generation: 1}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	runner := webDVDRunner{
+		core: acceptedDVDCaptureFunc(func(ctx context.Context, _ api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+			return api.DVDMenuCaptureResult{}, ctx.Err()
+		}),
+		target: dvdGenerationTransfer{release: release},
+		expected: release,
+	}
+	_, err := runner.CaptureAcceptedDVDMenus(ctx, api.MediaPlanInput{Release: release})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("capture error = %v", err)
 	}
 }
diff --git a/internal/webserver/events.go b/internal/webserver/events.go
index bb6b593f..0ab0c06f 100644
--- a/internal/webserver/events.go
+++ b/internal/webserver/events.go
@@ -9,11 +9,14 @@ import (
 	"time"
 )
 
+// serverEvent is one encoded server-sent event awaiting session delivery.
 type serverEvent struct {
 	Name string
 	Data []byte
 }
 
+// eventHub routes non-blocking, session-scoped events to active subscribers.
+// Slow subscribers lose events instead of blocking producers.
 type eventHub struct {
 	mu          sync.Mutex
 	subscribers map[string]map[chan serverEvent]struct{}
@@ -37,6 +40,8 @@ func (h *eventHub) SetLogger(logger interface {
 	h.mu.Unlock()
 }
 
+// Subscribe creates a buffered event stream for sessionID. The returned cleanup
+// removes the subscriber and closes its channel, and must be called exactly once.
 func (h *eventHub) Subscribe(sessionID string) (<-chan serverEvent, func()) {
 	ch := make(chan serverEvent, 64)
 
@@ -60,6 +65,8 @@ func (h *eventHub) Subscribe(sessionID string) (<-chan serverEvent, func()) {
 	}
 }
 
+// Emit JSON-encodes payload and attempts delivery to every subscriber for
+// sessionID. Invalid payloads and full subscriber buffers are dropped.
 func (h *eventHub) Emit(sessionID string, name string, payload any) {
 	if h == nil || sessionID == "" || name == "" {
 		return
@@ -84,6 +91,7 @@ func (h *eventHub) Emit(sessionID string, name string, payload any) {
 	}
 }
 
+// EmitKeepAlive sends a UTC RFC3339 timestamp on the session's keepalive event.
 func (h *eventHub) EmitKeepAlive(sessionID string) {
 	h.Emit(sessionID, "keepalive", map[string]string{
 		"timestamp": time.Now().UTC().Format(time.RFC3339),
diff --git a/internal/webserver/events_test.go b/internal/webserver/events_test.go
index aed9273c..544736ce 100644
--- a/internal/webserver/events_test.go
+++ b/internal/webserver/events_test.go
@@ -29,7 +29,7 @@ func TestEventHubLogsDroppedEvents(t *testing.T) {
 	hub.subscribers[sessionID] = map[chan serverEvent]struct{}{ch: {}}
 	hub.mu.Unlock()
 
-	hub.Emit(sessionID, "metadata:progress", map[string]string{"status": "running"})
+	hub.Emit(sessionID, "preparation:progress", map[string]string{"status": "running"})
 
 	if len(logger.messages) != 1 {
 		t.Fatalf("expected one dropped-event log message, got %d", len(logger.messages))
diff --git a/internal/webserver/image_upload_progress_test.go b/internal/webserver/image_upload_progress_test.go
new file mode 100644
index 00000000..3a6ccd8f
--- /dev/null
+++ b/internal/webserver/image_upload_progress_test.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestImageUploadProgressBoundaryCorrelatesAndSanitizesEvents(t *testing.T) {
+	hub := newEventHub()
+	backend := &Backend{hub: hub}
+	events, unsubscribe := hub.Subscribe("session-1")
+	t.Cleanup(unsubscribe)
+
+	ctx, err := backend.withImageUploadProgress(context.Background(), "session-1", "image-upload-1")
+	if err != nil {
+		t.Fatalf("create image upload progress context: %v", err)
+	}
+	api.EmitImageUploadProgress(ctx, api.ImageUploadProgressUpdate{
+		AttemptID:  "imgbox|global",
+		Host:       "imgbox",
+		UsageScope: "global",
+		Trackers:   []string{"AITHER"},
+		Completed:  1,
+		Total:      4,
+		Succeeded:  1,
+		Status:     api.ImageUploadProgressRunning,
+		Message:    `source=C:\media\Example.Release.2026.1080p-GRP api_key=synthetic-secret`,
+	})
+
+	select {
+	case event := <-events:
+		if event.Name != "image-upload:progress" {
+			t.Fatalf("event name=%q", event.Name)
+		}
+		var update api.ImageUploadProgressUpdate
+		if err := json.Unmarshal(event.Data, &update); err != nil {
+			t.Fatalf("decode image upload progress: %v", err)
+		}
+		if update.CorrelationID != "image-upload-1" || update.Timestamp == "" {
+			t.Fatal("image upload event is missing correlation or timestamp")
+		}
+		if strings.Contains(update.Message, "synthetic-secret") || strings.Contains(update.Message, `C:\media`) {
+			t.Fatal("image upload event exposed sensitive or local-path detail")
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("timed out waiting for image upload event")
+	}
+}
+
+func TestImageUploadProgressBoundaryRejectsEmptyCorrelation(t *testing.T) {
+	backend := &Backend{hub: newEventHub()}
+	if _, err := backend.withImageUploadProgress(context.Background(), "session-1", " "); err == nil {
+		t.Fatal("empty image upload correlation ID was accepted")
+	}
+}
diff --git a/internal/webserver/jobs.go b/internal/webserver/jobs.go
index ea07d9b9..9362ae7f 100644
--- a/internal/webserver/jobs.go
+++ b/internal/webserver/jobs.go
@@ -5,174 +5,192 @@ package webserver
 
 import (
 	"context"
-	"crypto/rand"
 	"errors"
 	"fmt"
 	"maps"
-	"math/big"
-	"sort"
-	"strconv"
 	"strings"
-	"sync"
 	"time"
 
-	"github.com/autobrr/upbrr/internal/guishared"
 	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/internal/webserver/jobs"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
 const (
-	completedJobRetention      = 24 * time.Hour
-	maxCompletedDupeJobs       = 200
-	maxCompletedUploadJobs     = 200
-	seedPreparedMetaTimeout    = 30 * time.Second
-	trackerUploadProgressEvent = "upload:progress"
+	seedPreparedMetaTimeout             = 30 * time.Second
+	trackerUploadSnapshotThrottle       = 200 * time.Millisecond
+	trackerUploadHashRateEmitDeltaMiB   = 1.0
+	trackerUploadProgressEvent          = "upload:progress"
+	errDupeCheckRequiresMetadataPreview = "dupe check requires metadata preview"
 )
 
-const errDupeCheckRequiresMetadataPreview = "dupe check requires metadata preview"
+type preparedUploadRunner interface {
+	RunAcceptedUpload(context.Context, api.UploadExecutionPlan) (api.Result, error)
+}
 
-// DupeCheckTrackerState reports frontend-visible state for one tracker in a
-// dupe check job.
-type DupeCheckTrackerState struct {
-	Tracker    string              `json:"tracker"`
-	Status     string              `json:"status"`
-	Message    string              `json:"message"`
-	Result     api.DupeCheckResult `json:"result"`
-	StartedAt  string              `json:"startedAt"`
-	FinishedAt string              `json:"finishedAt"`
+type dupeCheckRunner interface {
+	CheckAcceptedDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error)
 }
 
-// DupeCheckSnapshot reports frontend-visible state for a dupe check job.
-type DupeCheckSnapshot struct {
-	JobID          string                  `json:"jobID"`
-	SourcePath     string                  `json:"sourcePath"`
-	Status         string                  `json:"status"`
-	Trackers       []DupeCheckTrackerState `json:"trackers"`
-	CompletedCount int                     `json:"completedCount"`
-	TotalCount     int                     `json:"totalCount"`
-	Summary        api.DupeCheckSummary    `json:"summary"`
-	Error          string                  `json:"error"`
-	StartedAt      string                  `json:"startedAt"`
-	FinishedAt     string                  `json:"finishedAt"`
+// DupeCheckTrackerState aliases the shared frontend-visible state for one duplicate-check tracker.
+type DupeCheckTrackerState = jobs.DupeCheckTrackerState
+
+// DupeCheckSnapshot aliases the shared frontend-visible duplicate-check job snapshot.
+type DupeCheckSnapshot = jobs.DupeCheckSnapshot
+
+// TrackerUploadTrackerState aliases the shared frontend-visible state for one tracker upload.
+type TrackerUploadTrackerState = jobs.TrackerUploadTrackerState
+
+// TrackerUploadSnapshot aliases the shared frontend-visible tracker-upload job snapshot.
+type TrackerUploadSnapshot = jobs.TrackerUploadSnapshot
+
+// webJobSink routes shared snapshots to the authenticated owner's event stream.
+type webJobSink struct {
+	hub    *eventHub
+	logger api.Logger
+}
+
+// EmitDupe emits a duplicate-check snapshot only to the owning session.
+func (s webJobSink) EmitDupe(ownerID string, snapshot jobs.DupeCheckSnapshot) {
+	if s.hub != nil {
+		s.hub.Emit(ownerID, "dupe:job:"+snapshot.JobID, snapshot)
+		s.hub.Emit(ownerID, "jobs:update", jobs.OwnerJobSnapshot{
+			Kind:          jobs.KindDuplicateCheck,
+			JobID:         snapshot.JobID,
+			CorrelationID: snapshot.CorrelationID,
+			Release:       snapshot.Release,
+			Status:        snapshot.Status,
+			StartedAt:     snapshot.StartedAt,
+			FinishedAt:    snapshot.FinishedAt,
+			Dupe:          &snapshot,
+		})
+	}
 }
 
-type dupeCheckJob struct {
-	mu             sync.Mutex
-	cleanupOnce    sync.Once
-	sessionID      string
-	id             string
-	sourcePath     string
-	uploadOptions  api.UploadOptions
-	core           api.Core
-	logger         interface{ Close() error }
-	overrides      api.ExternalIDOverrides
-	nameOverrides  api.ReleaseNameOverrides
-	trackers       []string
-	states         map[string]DupeCheckTrackerState
-	completedCount int
-	totalCount     int
-	summary        api.DupeCheckSummary
-	status         string
-	errorMessage   string
-	startedAt      time.Time
-	finishedAt     time.Time
-	cancel         context.CancelFunc
+// EmitUpload emits a tracker-upload snapshot only to the owning session.
+func (s webJobSink) EmitUpload(ownerID string, snapshot jobs.TrackerUploadSnapshot) {
+	if s.hub != nil {
+		s.hub.Emit(ownerID, "upload:job:"+snapshot.JobID, snapshot)
+		s.hub.Emit(ownerID, "jobs:update", jobs.OwnerJobSnapshot{
+			Kind:          jobs.KindTrackerUpload,
+			JobID:         snapshot.JobID,
+			CorrelationID: snapshot.CorrelationID,
+			RetryOf:       snapshot.RetryOf,
+			Release:       snapshot.Release,
+			Status:        snapshot.Status,
+			StartedAt:     snapshot.StartedAt,
+			FinishedAt:    snapshot.FinishedAt,
+			Upload:        &snapshot,
+		})
+	}
+}
+
+// WarnJob records a sanitized lifecycle warning through the event hub logger.
+func (s webJobSink) WarnJob(message string) {
+	if s.logger != nil {
+		s.logger.Warnf("jobs: %s", message)
+	}
+}
+
+func (b *Backend) ensureJobOwner(sessionID string) (*jobs.OwnerHandle, error) {
+	if b == nil {
+		return nil, jobs.ErrEngineClosed
+	}
+	sessionID = strings.TrimSpace(sessionID)
+	if sessionID == "" {
+		return nil, errors.New("session id is required")
+	}
+	b.jobOwnerMu.Lock()
+	defer b.jobOwnerMu.Unlock()
+	if b.jobEngine == nil {
+		b.jobEngine = jobs.New(webJobSink{hub: b.hub, logger: b.currentLogger()}, jobs.Config{})
+	}
+	if b.jobOwners == nil {
+		b.jobOwners = make(map[string]*jobs.OwnerHandle)
+	}
+	if owner := b.jobOwners[sessionID]; owner != nil {
+		return owner, nil
+	}
+	owner, err := b.jobEngine.RegisterOwner(sessionID)
+	if err != nil {
+		return nil, fmt.Errorf("register job owner: %w", err)
+	}
+	b.jobOwners[sessionID] = owner
+	return owner, nil
 }
 
-// TrackerUploadTrackerState reports frontend-visible state for one tracker in
-// an upload job. UploadedCount includes accepted uploads returned before a later
-// tracker error or cancellation.
-type TrackerUploadTrackerState struct {
-	Tracker         string  `json:"tracker"`
-	Status          string  `json:"status"`
-	Task            string  `json:"task"`
-	TaskStatus      string  `json:"taskStatus"`
-	Message         string  `json:"message"`
-	CompletedPieces int     `json:"completedPieces"`
-	TotalPieces     int     `json:"totalPieces"`
-	Percent         int     `json:"percent"`
-	HashRateMiB     float64 `json:"hashRateMiB"`
-	UploadedCount   int     `json:"uploadedCount"`
-	StartedAt       string  `json:"startedAt"`
-	FinishedAt      string  `json:"finishedAt"`
+func (b *Backend) lookupJobOwner(sessionID string) *jobs.OwnerHandle {
+	if b == nil {
+		return nil
+	}
+	b.jobOwnerMu.Lock()
+	defer b.jobOwnerMu.Unlock()
+	return b.jobOwners[strings.TrimSpace(sessionID)]
 }
 
-// TrackerUploadSnapshot reports frontend-visible state for a tracker upload
-// job. UploadedCount is the sum of per-tracker accepted uploads, including
-// partial counts returned with non-nil errors.
-type TrackerUploadSnapshot struct {
-	JobID                  string                      `json:"jobID"`
-	SourcePath             string                      `json:"sourcePath"`
-	Status                 string                      `json:"status"`
-	CurrentTask            string                      `json:"currentTask"`
-	CurrentTaskStatus      string                      `json:"currentTaskStatus"`
-	CurrentMessage         string                      `json:"currentMessage"`
-	CurrentCompletedPieces int                         `json:"currentCompletedPieces"`
-	CurrentTotalPieces     int                         `json:"currentTotalPieces"`
-	CurrentPercent         int                         `json:"currentPercent"`
-	CurrentHashRateMiB     float64                     `json:"currentHashRateMiB"`
-	Trackers               []TrackerUploadTrackerState `json:"trackers"`
-	FailedTrackers         []string                    `json:"failedTrackers"`
-	UploadedCount          int                         `json:"uploadedCount"`
-	Error                  string                      `json:"error"`
-	StartedAt              string                      `json:"startedAt"`
-	FinishedAt             string                      `json:"finishedAt"`
+func (b *Backend) removeJobOwner(sessionID string) {
+	if b == nil || b.jobEngine == nil {
+		return
+	}
+	sessionID = strings.TrimSpace(sessionID)
+	b.jobOwnerMu.Lock()
+	owner := b.jobOwners[sessionID]
+	delete(b.jobOwners, sessionID)
+	b.jobOwnerMu.Unlock()
+	if owner != nil {
+		_ = b.jobEngine.RemoveOwner(owner)
+	}
+	if b.reviews != nil {
+		b.reviews.PurgeOwner(sessionID)
+	}
 }
 
-type trackerUploadJob struct {
-	mu          sync.Mutex
-	cleanupOnce sync.Once
-	sessionID   string
-	id          string
-	sourcePath  string
-	// uploadOptions is the per-job runtime snapshot needed for upload requests;
-	// the full config may contain secrets and must not be retained in job state.
-	uploadOptions        api.UploadOptions
-	runOptions           runOptions
-	core                 api.Core
-	logger               interface{ Close() error }
-	overrides            api.ExternalIDOverrides
-	nameOverrides        api.ReleaseNameOverrides
-	questionnaireAnswers map[string]map[string]string
-	descriptionGroups    []api.DescriptionBuilderGroup
-	trackers             []string
-	ignoreDupesFor       []string
-	states               map[string]TrackerUploadTrackerState
-	failedTrackers       []string
-	uploadedCount        int
-	status               string
-	currentTask          string
-	currentTaskStatus    string
-	currentMessage       string
-	currentCompleted     int
-	currentTotal         int
-	currentPercent       int
-	currentHashRateMiB   float64
-	lastSnapshotEmit     time.Time
-	snapshotThrottle     time.Duration
-	errorMessage         string
-	startedAt            time.Time
-	finishedAt           time.Time
-	cancel               context.CancelFunc
+// webUploadRunner preserves the embedded-web error prefix around prepared upload execution.
+type webUploadRunner struct {
+	core             preparedUploadRunner
+	generationTarget PreparedGenerationTransfer
+	generationSeed   preparedrelease.Seed
+	expectedRelease  api.ReleaseRef
 }
 
-type trackerUploadRetryRequest struct {
-	sessionID            string
-	sourcePath           string
-	overrides            api.ExternalIDOverrides
-	nameOverrides        api.ReleaseNameOverrides
-	questionnaireAnswers map[string]map[string]string
-	descriptionGroups    []api.DescriptionBuilderGroup
-	failedTrackers       []string
-	ignoreDupesFor       []string
-	runOptions           runOptions
-	uploadOptions        api.UploadOptions
+// RunUpload delegates prepared upload execution and applies the embedded-web error contract.
+func (r webUploadRunner) RunUpload(ctx context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	ref, err := r.generationTarget.ImportReleaseSeed(ctx, r.generationSeed)
+	if err != nil {
+		return api.Result{}, fmt.Errorf("web: import canonical generation: %w", err)
+	}
+	if ref != r.expectedRelease {
+		return api.Result{}, errors.New("web: import canonical generation: unexpected release reference")
+	}
+	return wrapWebResult(r.core.RunAcceptedUpload(ctx, plan))
 }
 
-const trackerUploadSnapshotThrottle = 200 * time.Millisecond
+// webDupeRunner preserves the direct duplicate-check error contract used by both transports.
+type webDupeRunner struct {
+	core             dupeCheckRunner
+	generationTarget PreparedGenerationTransfer
+	generationSeed   preparedrelease.Seed
+	expectedRelease  api.ReleaseRef
+}
 
-const trackerUploadHashRateEmitDeltaMiB = 1.0
+// CheckDupes delegates duplicate checking without changing runner error text.
+func (r webDupeRunner) CheckDupes(ctx context.Context, input api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	ref, err := r.generationTarget.ImportReleaseSeed(ctx, r.generationSeed)
+	if err != nil {
+		return api.DupeCheckSummary{}, fmt.Errorf("import canonical generation: %w", err)
+	}
+	if ref != r.expectedRelease {
+		return api.DupeCheckSummary{}, errors.New("import canonical generation: unexpected release reference")
+	}
+	summary, err := r.core.CheckAcceptedDupes(ctx, input)
+	if err != nil {
+		return api.DupeCheckSummary{}, fmt.Errorf("%w", err)
+	}
+	return summary, nil
+}
 
+// normalizeTrackerList trims, removes blanks, and deduplicates tracker names case-insensitively.
 func normalizeTrackerList(trackers []string) []string {
 	seen := make(map[string]struct{})
 	resolved := make([]string, 0, len(trackers))
@@ -191,6 +209,7 @@ func normalizeTrackerList(trackers []string) []string {
 	return resolved
 }
 
+// cloneQuestionnaireAnswers deep-copies tracker questionnaire maps for request isolation.
 func cloneQuestionnaireAnswers(input map[string]map[string]string) map[string]map[string]string {
 	if len(input) == 0 {
 		return nil
@@ -204,6 +223,7 @@ func cloneQuestionnaireAnswers(input map[string]map[string]string) map[string]ma
 	return cloned
 }
 
+// normalizePatterns trims, removes blanks, and deduplicates log exclusion patterns.
 func normalizePatterns(patterns []string) []string {
 	seen := make(map[string]struct{})
 	result := make([]string, 0, len(patterns))
@@ -221,976 +241,418 @@ func normalizePatterns(patterns []string) []string {
 	return result
 }
 
-func randomJobID() string {
-	value, err := rand.Int(rand.Reader, new(big.Int).SetUint64(^uint64(0)))
+// StartDupeCheck starts a session-owned duplicate-check job for a host filesystem path.
+// Request cancellation applies only to preview-cache preparation; accepted jobs continue until completion or explicit cancellation.
+func (b *Backend) StartDupeCheck(
+	ctx context.Context,
+	sessionID string,
+	release api.ReleaseRef,
+	trackers []string,
+	correlationID string,
+) (string, error) {
+	owner, err := b.ensureJobOwner(sessionID)
 	if err != nil {
-		return strconv.FormatInt(time.Now().UnixNano(), 10)
+		return "", err
 	}
-	return fmt.Sprintf("%d-%x", time.Now().UnixNano(), value.Uint64())
-}
-
-// StartDupeCheck starts a dupe check job owned by sessionID and returns its job
-// ID. The request context controls the pre-job metadata cache export/import
-// work; after the job is accepted, cancellation is detached and callers must use
-// CancelDupeCheck. When the active core exposes the GUI prepared-metadata cache,
-// the matching preview must exist before a durable job is created.
-func (b *Backend) StartDupeCheck(ctx context.Context, sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string) (string, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return "", err
 	}
+	if !rt.capabilities.PreparedGenerationReady() {
+		return "", ErrPreparedGenerationUnavailable
+	}
 	if ctx == nil {
 		return "", errors.New("request context is required")
 	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
+	release.SourcePath = strings.TrimSpace(release.SourcePath)
+	if release.SourcePath == "" || release.Generation == 0 {
+		return "", api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureInvalidSource,
+			Operation: api.OperationKindDuplicateCheck,
+			Message:   "Source path is required.",
+			Recovery:  api.OperationRecoveryEditInput,
+		}, errors.New("path is required"))
 	}
 	resolvedTrackers := normalizeTrackerList(trackers)
 	if len(resolvedTrackers) == 0 {
-		return "", errors.New("at least one tracker must be selected")
+		return "", api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureNoEligibleTrackers,
+			Operation: api.OperationKindDuplicateCheck,
+			Message:   "No trackers are eligible for duplicate checking.",
+			Recovery:  api.OperationRecoverySelectTrackers,
+		}, errors.New("at least one tracker must be selected"))
 	}
 
-	req := api.Request{
-		Paths:                []string{trimmedPath},
-		Mode:                 api.ModeGUI,
-		Trackers:             resolvedTrackers,
-		Options:              rt.baseUploadOptions(),
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-	var preparedMeta api.PreparedMetadata
-	preparedMetaFound := false
-	if exporter, ok := rt.core.(guishared.PreparedMetaExporter); ok {
-		var found bool
-		preparedMeta, found, err = exporter.ExportGUICachedPreparedMeta(ctx, req)
-		if err != nil {
-			return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
-		}
-		if !found {
-			return "", errors.New(errDupeCheckRequiresMetadataPreview)
-		}
-		preparedMetaFound = true
+	generationSeed, err := rt.capabilities.PreparedGenerationTransfer.ExportReleaseSeed(ctx, release)
+	if err != nil {
+		return "", fmt.Errorf("dupe check exact generation: %w", err)
 	}
-
 	if err := ctx.Err(); err != nil {
-		return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
+		return "", fmt.Errorf("dupe check canceled before run setup: %w", err)
 	}
-	//nolint:contextcheck // Per-run core construction has no context-aware API; request context is checked before and after setup.
-	runCore, runLogger, err := b.buildRunCoreFromSnapshot(rt, runOptions{})
+
+	runCapabilities, runOwner, runLogger, err := b.buildRunCoreFromSnapshot(ctx, rt, runOptions{})
 	if err != nil {
 		return "", err
 	}
 	if err := ctx.Err(); err != nil {
-		_ = runCore.Close()
-		_ = runLogger.Close()
+		closeJobResources(runOwner, runLogger)
 		return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
 	}
-	if preparedMetaFound {
-		importer, ok := runCore.(guishared.PreparedMetaImporter)
-		if !ok {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", errors.New("dupe check metadata preview cache: run core cannot import prepared metadata")
-		}
-		if err := importer.ImportPreparedMetadataForGUI(ctx, req, preparedMeta); err != nil {
-			_ = runCore.Close()
-			_ = runLogger.Close()
-			return "", fmt.Errorf("dupe check metadata preview cache: %w", err)
-		}
-	}
-
-	jobID := randomJobID()
-	states := make(map[string]DupeCheckTrackerState, len(resolvedTrackers))
-	for _, tracker := range resolvedTrackers {
-		normalized := strings.ToUpper(strings.TrimSpace(tracker))
-		states[normalized] = DupeCheckTrackerState{Tracker: normalized, Status: "queued", Message: "queued"}
-	}
-	job := &dupeCheckJob{
-		sessionID:     sessionID,
-		id:            jobID,
-		sourcePath:    trimmedPath,
-		uploadOptions: req.Options,
-		core:          runCore,
-		logger:        runLogger,
-		overrides:     overrides,
-		nameOverrides: nameOverrides,
-		trackers:      resolvedTrackers,
-		states:        states,
-		totalCount:    len(states),
-		summary:       api.DupeCheckSummary{SourcePath: trimmedPath},
-		status:        "queued",
-		startedAt:     time.Now().UTC(),
+	if !runCapabilities.PreparedDupeReady() || !runCapabilities.PreparedGenerationReady() {
+		closeJobResources(runOwner, runLogger)
+		return "", ErrPreparedDupeUnavailable
+	}
+	jobID, err := b.jobEngine.StartDupe(context.WithoutCancel(ctx), owner, jobs.DupeSpec{
+		CorrelationID: correlationID,
+		Snapshot: jobs.DuplicateExecutionSnapshot{
+			Seed:               generationSeed,
+			PreparedGeneration: release.Generation,
+			RuntimeGeneration:  rt.generationID,
+			Input: api.DuplicateCheckInput{
+				Release:     release,
+				Trackers:    append([]string(nil), resolvedTrackers...),
+				Interaction: api.InteractionModeInteractive,
+			},
+		},
+		Runner: webDupeRunner{
+			core:             runCapabilities.DuplicateExecution,
+			generationTarget: runCapabilities.PreparedGenerationTransfer,
+			generationSeed:   generationSeed,
+			expectedRelease:  release,
+		},
+		Resources: jobs.Resources{Core: runOwner, Logger: runLogger},
+	})
+	if err != nil {
+		closeJobResources(runOwner, runLogger)
+		return "", fmt.Errorf("web: start dupe job: %w", err)
 	}
-
-	jobCtx, cancel := context.WithCancel(context.WithoutCancel(ctx))
-	job.cancel = cancel
-
-	b.dupeMu.Lock()
-	b.dupes[jobID] = job
-	b.pruneCompletedDupeJobsLocked(maxCompletedDupeJobs)
-	b.dupeMu.Unlock()
-	b.emitDupeCheckSnapshot(job)
-
-	b.dupeWG.Add(1)
-	go func() {
-		defer cancel()
-		b.runDupeCheckJob(jobCtx, job)
-	}()
 	return jobID, nil
 }
 
-// GetDupeCheckSnapshot returns a dupe job snapshot only to the session that
-// started the job.
+// GetDupeCheckSnapshot returns an immutable job snapshot when sessionID owns jobID.
+// Unknown and foreign-owned IDs return the same not-found error.
 func (b *Backend) GetDupeCheckSnapshot(sessionID string, jobID string) (DupeCheckSnapshot, error) {
-	job := b.getDupeCheckJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return DupeCheckSnapshot{}, errors.New("dupe job not found")
+	snapshot, err := b.jobEngine.DupeSnapshot(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID))
+	if err != nil {
+		return DupeCheckSnapshot{}, fmt.Errorf("%w", err)
 	}
-	return buildDupeCheckSnapshot(job), nil
+	return snapshot, nil
 }
 
-// CancelDupeCheck requests cancellation only for a dupe job owned by sessionID.
+// CancelDupeCheck requests cancellation when sessionID owns jobID.
+// Unknown and foreign-owned IDs return the same not-found error.
 func (b *Backend) CancelDupeCheck(sessionID string, jobID string) error {
-	job := b.getDupeCheckJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return errors.New("dupe job not found")
-	}
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
+	if err := b.jobEngine.CancelDupe(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID)); err != nil {
+		return fmt.Errorf("%w", err)
 	}
 	return nil
 }
 
-func (b *Backend) runDupeCheckJob(ctx context.Context, job *dupeCheckJob) {
-	defer b.dupeWG.Done()
-	defer func() {
-		job.closeResources()
-	}()
-
-	job.mu.Lock()
-	job.status = "running"
-	job.mu.Unlock()
-	b.emitDupeCheckSnapshot(job)
-
-	progressCtx := api.WithDupeProgressReporter(ctx, func(update api.DupeProgressUpdate) {
-		b.applyDupeProgress(job, update)
-	})
-
-	req := api.Request{
-		Paths:                []string{job.sourcePath},
-		Mode:                 api.ModeGUI,
-		Trackers:             job.trackers,
-		Options:              job.uploadOptions,
-		ExternalIDOverrides:  job.overrides,
-		ReleaseNameOverrides: job.nameOverrides,
-	}
-
-	if job.core == nil {
-		err := errors.New("core not initialized")
-		job.mu.Lock()
-		job.finishedAt = time.Now().UTC()
-		job.cancel = nil
-		job.status = "failed"
-		job.errorMessage = logging.SanitizeMessage(err.Error())
-		job.mu.Unlock()
-		b.emitDupeCheckSnapshot(job)
-		b.scheduleDupeJobCleanup(job)
-		return
-	}
-
-	summary, err := job.core.CheckDupes(progressCtx, req)
-	job.mu.Lock()
-	job.finishedAt = time.Now().UTC()
-	job.cancel = nil
+// ReviewTrackerUpload stores a session-owned exact execution snapshot and
+// returns the single-use opaque token required to start it.
+func (b *Backend) ReviewTrackerUpload(
+	ctx context.Context,
+	sessionID string,
+	release api.ReleaseRef,
+	trackers []string,
+	ignoreDupesFor []string,
+	ruleAuthorizations []api.RuleAuthorization,
+	questionnaireAnswers map[string]map[string]string,
+	descriptionGroups []api.DescriptionBuilderGroup,
+	noSeed bool,
+	runLogLevel string,
+) (api.UploadReviewResult, error) {
+	runOpts, err := b.buildRunOptions(noSeed, runLogLevel)
 	if err != nil {
-		if ctx.Err() != nil {
-			job.status = "canceled"
-			job.errorMessage = "dupe check canceled"
-		} else {
-			job.status = "failed"
-			job.errorMessage = logging.SanitizeMessage(err.Error())
-		}
-		job.mu.Unlock()
-		b.emitDupeCheckSnapshot(job)
-		b.scheduleDupeJobCleanup(job)
-		return
+		return api.UploadReviewResult{}, err
 	}
-	job.summary = summary
-	for _, result := range summary.Results {
-		for _, tracker := range dupeResultTrackerNames(result) {
-			state := job.states[tracker]
-			if !isDupeTerminalStatus(state.Status) {
-				job.completedCount++
-			}
-			state.Tracker = tracker
-			state.Status = resultStatus(result)
-			state.Message = resultMessage(result)
-			state.Result = result
-			state.Result.Tracker = tracker
-			if state.StartedAt == "" {
-				state.StartedAt = job.startedAt.Format(time.RFC3339)
-			}
-			state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-			job.states[tracker] = state
-		}
-	}
-	if hasFailedDupeState(job.states) {
-		job.status = "completed_with_errors"
-		if strings.TrimSpace(job.errorMessage) == "" {
-			job.errorMessage = "one or more tracker dupe checks failed"
-		}
-	} else {
-		job.status = "completed"
-		job.errorMessage = ""
+	if _, err := b.ensureJobOwner(sessionID); err != nil {
+		return api.UploadReviewResult{}, err
 	}
-	job.mu.Unlock()
-	b.emitDupeCheckSnapshot(job)
-	b.scheduleDupeJobCleanup(job)
-}
-
-// applyDupeProgress merges one tracker update and emits the resulting job
-// snapshot. Trackers discovered after job creation increase the total once only
-// when the producer omitted an explicit total.
-func (b *Backend) applyDupeProgress(job *dupeCheckJob, update api.DupeProgressUpdate) {
-	tracker := strings.ToUpper(strings.TrimSpace(update.Tracker))
-	if tracker == "" {
-		return
-	}
-	job.mu.Lock()
-	state := job.states[tracker]
-	if state.Tracker == "" {
-		state.Tracker = tracker
-		job.trackers = append(job.trackers, tracker)
-		if update.Total <= 0 {
-			job.totalCount++
-		}
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return api.UploadReviewResult{}, err
 	}
-	previousStatus := state.Status
-	if strings.TrimSpace(update.Status) != "" {
-		state.Status = strings.TrimSpace(update.Status)
+	if !rt.capabilities.PreparedGenerationReady() || !CapabilityAvailable(rt.capabilities.UploadReview) {
+		return api.UploadReviewResult{}, ErrPreparedGenerationUnavailable
 	}
-	if strings.TrimSpace(update.Message) != "" {
-		state.Message = strings.TrimSpace(update.Message)
+	reviewCore, err := rt.uploadReviewCore()
+	if err != nil {
+		return api.UploadReviewResult{}, err
 	}
-	if state.Status == "running" && state.StartedAt == "" {
-		state.StartedAt = time.Now().UTC().Format(time.RFC3339)
+	release.SourcePath = strings.TrimSpace(release.SourcePath)
+	if release.SourcePath == "" || release.Generation == 0 {
+		return api.UploadReviewResult{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureInvalidSource,
+			Operation: api.OperationKindUploadReview,
+			Message:   "Source path is required.",
+			Recovery:  api.OperationRecoveryEditInput,
+		}, errors.New("path is required"))
 	}
-	if update.Result.Tracker != "" {
-		state.Result = update.Result
-		upsertDupeSummaryResult(&job.summary, update.Result)
+	resolvedTrackers := normalizeTrackerList(trackers)
+	if len(resolvedTrackers) == 0 {
+		return api.UploadReviewResult{}, api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureNoEligibleTrackers,
+			Operation: api.OperationKindUploadReview,
+			Message:   "No trackers are eligible for upload.",
+			Recovery:  api.OperationRecoverySelectTrackers,
+		}, errors.New("at least one tracker must be selected"))
+	}
+	ignore := normalizeTrackerList(ignoreDupesFor)
+	options := buildRunUploadOptions(rt.cfg, runOpts)
+	if ctx == nil {
+		return api.UploadReviewResult{}, errors.New("request context is required")
 	}
-	if isDupeTerminalStatus(state.Status) && !isDupeTerminalStatus(previousStatus) {
-		job.completedCount++
-		state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
+	generationSeed, err := rt.capabilities.PreparedGenerationTransfer.ExportReleaseSeed(ctx, release)
+	if err != nil {
+		return api.UploadReviewResult{}, fmt.Errorf("web: exact upload generation: %w", err)
+	}
+	reviewInput := api.UploadReviewInput{
+		Release:              release,
+		Trackers:             append([]string(nil), resolvedTrackers...),
+		IgnoreDupesFor:       append([]string(nil), ignore...),
+		RuleAuthorizations:   cloneWebRuleAuthorizations(ruleAuthorizations),
+		QuestionnaireAnswers: cloneQuestionnaireAnswers(questionnaireAnswers),
+		DescriptionGroups:    api.CloneDescriptionBuilderGroups(descriptionGroups),
+		Options:              options,
 	}
-	if update.Total > job.totalCount {
-		job.totalCount = update.Total
+	reviewed, err := reviewCore.ReviewAcceptedUpload(ctx, reviewInput)
+	if err != nil {
+		return api.UploadReviewResult{}, fmt.Errorf("web: %w", err)
+	}
+	token, err := b.uploadReviewRegistry().Issue(sessionID, UploadReviewSnapshot{
+		Execution: jobs.UploadExecutionSnapshot{
+			Seed:               generationSeed,
+			PreparedGeneration: release.Generation,
+			RuntimeGeneration:  rt.generationID,
+			Input:              reviewInput,
+			Outcome:            reviewed.Outcome,
+		},
+		Review: reviewed.Review,
+	})
+	if err != nil {
+		return api.UploadReviewResult{}, fmt.Errorf("web: issue upload review token: %w", err)
 	}
-	job.states[tracker] = state
-	job.mu.Unlock()
-	b.emitDupeCheckSnapshot(job)
+	return api.UploadReviewResult{Review: reviewed.Review, Token: token}, nil
 }
 
-func (j *trackerUploadJob) closeResources() {
-	if j == nil {
-		return
+func cloneWebRuleAuthorizations(values []api.RuleAuthorization) []api.RuleAuthorization {
+	if len(values) == 0 {
+		return nil
 	}
-	j.cleanupOnce.Do(func() {
-		j.mu.Lock()
-		coreSvc := j.core
-		logger := j.logger
-		j.core = nil
-		j.logger = nil
-		j.mu.Unlock()
-		if coreSvc != nil {
-			_ = coreSvc.Close()
-		}
-		if logger != nil {
-			_ = logger.Close()
-		}
-	})
-}
-
-func (j *dupeCheckJob) closeResources() {
-	if j == nil {
-		return
+	cloned := make([]api.RuleAuthorization, len(values))
+	for idx, value := range values {
+		cloned[idx] = api.RuleAuthorization{Tracker: value.Tracker, Rules: append([]string(nil), value.Rules...)}
 	}
-	j.cleanupOnce.Do(func() {
-		j.mu.Lock()
-		coreSvc := j.core
-		logger := j.logger
-		j.core = nil
-		j.logger = nil
-		j.mu.Unlock()
-		if coreSvc != nil {
-			_ = coreSvc.Close()
-		}
-		if logger != nil {
-			_ = logger.Close()
-		}
-	})
+	return cloned
 }
 
-func trackerUploadRetryRequestFromJob(job *trackerUploadJob) (trackerUploadRetryRequest, error) {
-	if job == nil {
-		return trackerUploadRetryRequest{}, errors.New("upload job not found")
+// StartReviewedTrackerUpload consumes one session-owned reviewed snapshot and
+// starts it only while the reviewed runtime generation remains active.
+func (b *Backend) StartReviewedTrackerUpload(sessionID string, token string, correlationID string) (string, error) {
+	owner, err := b.ensureJobOwner(sessionID)
+	if err != nil {
+		return "", err
 	}
-
-	job.mu.Lock()
-	defer job.mu.Unlock()
-
-	if len(job.failedTrackers) == 0 {
-		return trackerUploadRetryRequest{}, errors.New("no failed trackers to retry")
+	reviewed, err := b.uploadReviewRegistry().Consume(sessionID, token)
+	if err != nil {
+		return "", api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureMissingReview,
+			Operation: api.OperationKindUploadExecute,
+			Message:   "Upload review is missing or expired.",
+			Recovery:  api.OperationRecoveryReviewAgain,
+		}, err)
 	}
-
-	return trackerUploadRetryRequest{
-		sessionID:            job.sessionID,
-		sourcePath:           job.sourcePath,
-		overrides:            job.overrides,
-		nameOverrides:        job.nameOverrides,
-		questionnaireAnswers: cloneQuestionnaireAnswers(job.questionnaireAnswers),
-		descriptionGroups:    api.CloneDescriptionBuilderGroups(job.descriptionGroups),
-		failedTrackers:       append([]string(nil), job.failedTrackers...),
-		ignoreDupesFor:       append([]string(nil), job.ignoreDupesFor...),
-		runOptions:           job.runOptions,
-		uploadOptions:        job.uploadOptions,
-	}, nil
-}
-
-// StartTrackerUpload starts an upload job owned by sessionID for selected
-// trackers and returns its job ID. Snapshots preserve partial upload counts
-// returned with later tracker errors or cancellation. The job captures upload
-// options at start time so failed-tracker retries reuse the original option set.
-func (b *Backend) StartTrackerUpload(sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string) (string, error) {
-	return b.startTrackerUpload(sessionID, path, overrides, nameOverrides, trackers, ignoreDupesFor, questionnaireAnswers, descriptionGroups, debug, noSeed, runLogLevel, nil)
-}
-
-func (b *Backend) startTrackerUpload(sessionID string, path string, overrides api.ExternalIDOverrides, nameOverrides api.ReleaseNameOverrides, trackers []string, ignoreDupesFor []string, questionnaireAnswers map[string]map[string]string, descriptionGroups []api.DescriptionBuilderGroup, debug bool, noSeed bool, runLogLevel string, uploadOptions *api.UploadOptions) (string, error) {
 	rt, err := b.requireRuntime()
 	if err != nil {
 		return "", err
 	}
-	trimmedPath := strings.TrimSpace(path)
-	if trimmedPath == "" {
-		return "", errors.New("path is required")
+	if reviewed.Execution.RuntimeGeneration != rt.generationID {
+		return "", api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureStaleReview,
+			Operation: api.OperationKindUploadExecute,
+			Message:   "Upload review is stale after configuration changed.",
+			Recovery:  api.OperationRecoveryReviewAgain,
+		}, errors.New("runtime generation changed"))
 	}
-	resolvedTrackers := normalizeTrackerList(trackers)
-	if len(resolvedTrackers) == 0 {
-		return "", errors.New("at least one tracker must be selected")
+	runOpts := runOptions{
+		NoSeed:      reviewed.Execution.Input.Options.NoSeed,
+		RunLogLevel: reviewed.Execution.Input.Options.RunLogLevel,
 	}
-	runOpts, err := b.buildRunOptions(debug, noSeed, runLogLevel)
+	runCapabilities, runOwner, runLogger, err := b.buildRunCoreFromSnapshot(context.Background(), rt, runOpts)
 	if err != nil {
 		return "", err
 	}
-	runCore, runLogger, err := b.buildRunCoreFromSnapshot(rt, runOpts)
+	if !runCapabilities.PreparedUploadReady() || !runCapabilities.PreparedGenerationReady() {
+		closeJobResources(runOwner, runLogger)
+		return "", ErrPreparedUploadUnavailable
+	}
+	input := reviewed.Execution.Input
+	spec := jobs.UploadSpec{
+		CorrelationID: correlationID,
+		Snapshot:      reviewed.Execution,
+		Runner: webUploadRunner{
+			core:             runCapabilities.UploadExecution,
+			generationTarget: runCapabilities.PreparedGenerationTransfer,
+			generationSeed:   reviewed.Execution.Seed,
+			expectedRelease:  input.Release,
+		},
+		Resources: jobs.Resources{Core: runOwner, Logger: runLogger},
+	}
+	jobID, err := b.jobEngine.StartUpload(context.Background(), owner, spec)
 	if err != nil {
-		return "", err
+		closeJobResources(runOwner, runLogger)
+		return "", fmt.Errorf("web: start upload job: %w", err)
 	}
-	seedReq := api.Request{
-		Paths:                []string{trimmedPath},
-		Mode:                 api.ModeGUI,
-		DescriptionGroups:    api.CloneDescriptionBuilderGroups(descriptionGroups),
-		Trackers:             resolvedTrackers,
-		IgnoreDupesFor:       normalizeTrackerList(ignoreDupesFor),
-		ExternalIDOverrides:  overrides,
-		ReleaseNameOverrides: nameOverrides,
-	}
-	seedCtx, cancel := context.WithTimeout(context.Background(), seedPreparedMetaTimeout)
-	defer cancel()
-	if err := guishared.SeedRunCorePreparedMeta(seedCtx, rt.core, runCore, seedReq); err != nil {
-		_ = runCore.Close()
-		_ = runLogger.Close()
-		return "", fmt.Errorf("web: %w", err)
-	}
-
-	jobID := randomJobID()
-	jobUploadOptions := buildRunUploadOptions(rt.cfg, runOpts)
-	if uploadOptions != nil {
-		jobUploadOptions = *uploadOptions
-	}
-	job := &trackerUploadJob{
-		sessionID:            sessionID,
-		id:                   jobID,
-		sourcePath:           trimmedPath,
-		uploadOptions:        jobUploadOptions,
-		runOptions:           runOpts,
-		core:                 runCore,
-		logger:               runLogger,
-		overrides:            overrides,
-		nameOverrides:        nameOverrides,
-		questionnaireAnswers: cloneQuestionnaireAnswers(questionnaireAnswers),
-		descriptionGroups:    api.CloneDescriptionBuilderGroups(descriptionGroups),
-		trackers:             resolvedTrackers,
-		ignoreDupesFor:       normalizeTrackerList(ignoreDupesFor),
-		states:               make(map[string]TrackerUploadTrackerState, len(resolvedTrackers)),
-		status:               "queued",
-		startedAt:            time.Now().UTC(),
-		snapshotThrottle:     trackerUploadSnapshotThrottle,
-	}
-	for _, tracker := range resolvedTrackers {
-		job.states[tracker] = TrackerUploadTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-	}
-	jobCtx, cancel := context.WithCancel(context.Background())
-	job.cancel = cancel
-
-	b.uploadMu.Lock()
-	b.uploads[jobID] = job
-	b.pruneCompletedUploadJobsLocked(maxCompletedUploadJobs)
-	b.uploadMu.Unlock()
-	b.emitTrackerUploadSnapshot(job)
-
-	b.uploadWG.Add(1)
-	go func() {
-		defer cancel()
-		b.runTrackerUploadJob(jobCtx, job)
-	}()
 	return jobID, nil
 }
 
-// CancelTrackerUpload requests cancellation only for an upload job owned by
-// sessionID.
-func (b *Backend) CancelTrackerUpload(sessionID string, jobID string) error {
-	job := b.getTrackerUploadJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return errors.New("upload job not found")
+func (b *Backend) uploadReviewRegistry() *UploadReviewRegistry {
+	b.reviewMu.Lock()
+	defer b.reviewMu.Unlock()
+	if b.reviews == nil {
+		b.reviews = NewUploadReviewRegistry()
 	}
-	job.mu.Lock()
-	cancel := job.cancel
-	job.mu.Unlock()
-	if cancel != nil {
-		cancel()
-	}
-	return nil
+	return b.reviews
 }
 
-// RetryFailedTrackerUpload starts a retry job for failed trackers only when
-// sessionID owns the original upload job. The retry reuses the original job's
-// run options, upload options, questionnaire answers, description groups, and
-// ignore-dupe list instead of rebuilding them from current settings.
-func (b *Backend) RetryFailedTrackerUpload(sessionID string, jobID string) (string, error) {
-	job := b.getTrackerUploadJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return "", errors.New("upload job not found")
-	}
-	retry, err := trackerUploadRetryRequestFromJob(job)
+// retryTrackerUpload rebuilds per-run resources while preserving the exact
+// reviewed operation and canonical preparation lineage.
+func (b *Backend) retryTrackerUpload(sessionID string, spec jobs.UploadSpec, runOpts runOptions) (string, error) {
+	owner, err := b.ensureJobOwner(sessionID)
 	if err != nil {
 		return "", err
 	}
-	return b.startTrackerUpload(retry.sessionID, retry.sourcePath, retry.overrides, retry.nameOverrides, retry.failedTrackers, retry.ignoreDupesFor, retry.questionnaireAnswers, retry.descriptionGroups, retry.runOptions.Debug, retry.runOptions.NoSeed, retry.runOptions.RunLogLevel, &retry.uploadOptions)
-}
-
-// GetTrackerUploadSnapshot returns an upload job snapshot only to the session
-// that started the job.
-func (b *Backend) GetTrackerUploadSnapshot(sessionID string, jobID string) (TrackerUploadSnapshot, error) {
-	job := b.getTrackerUploadJobForSession(strings.TrimSpace(sessionID), strings.TrimSpace(jobID))
-	if job == nil {
-		return TrackerUploadSnapshot{}, errors.New("upload job not found")
-	}
-	return buildTrackerUploadSnapshot(job), nil
-}
-
-// runTrackerUploadJob records UploadedCount before error handling so partial
-// successes returned with non-nil errors remain visible in snapshots.
-func (b *Backend) runTrackerUploadJob(ctx context.Context, job *trackerUploadJob) {
-	defer b.uploadWG.Done()
-
-	job.mu.Lock()
-	job.status = "running"
-	job.mu.Unlock()
-	b.emitTrackerUploadSnapshot(job)
-
-	for _, tracker := range job.trackers {
-		if ctx.Err() != nil {
-			break
-		}
-		job.mu.Lock()
-		state := job.states[tracker]
-		state.Status = "running"
-		state.Message = "uploading"
-		state.StartedAt = time.Now().UTC().Format(time.RFC3339)
-		job.states[tracker] = state
-		job.mu.Unlock()
-		b.emitTrackerUploadSnapshot(job)
-
-		progressCtx := api.WithUploadProgressReporter(ctx, func(update api.UploadProgressUpdate) {
-			b.applyTrackerUploadProgress(job, update)
-		})
-		result, err := b.runSingleTrackerUpload(progressCtx, job, tracker)
-		if result.UploadedCount > 0 {
-			job.mu.Lock()
-			state = job.states[tracker]
-			state.UploadedCount += result.UploadedCount
-			job.states[tracker] = state
-			job.uploadedCount += result.UploadedCount
-			job.mu.Unlock()
-		}
-		if err != nil {
-			if ctx.Err() != nil {
-				break
-			}
-			job.mu.Lock()
-			message := logging.SanitizeMessage(err.Error())
-			state = job.states[tracker]
-			state.Status = "failed"
-			state.Message = message
-			state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
-			job.states[tracker] = state
-			job.failedTrackers = append(job.failedTrackers, tracker)
-			job.errorMessage = message
-			job.mu.Unlock()
-			b.emitTrackerUploadSnapshot(job)
-			continue
-		}
-
-		job.mu.Lock()
-		state = job.states[tracker]
-		state.Status = "success"
-		state.Message = "uploaded"
-		state.FinishedAt = time.Now().UTC().Format(time.RFC3339)
-		job.states[tracker] = state
-		job.mu.Unlock()
-		b.emitTrackerUploadSnapshot(job)
-	}
-
-	job.mu.Lock()
-	job.finishedAt = time.Now().UTC()
-	switch {
-	case ctx.Err() != nil:
-		job.status = "canceled"
-		job.errorMessage = "upload canceled"
-		for _, tracker := range job.trackers {
-			state := job.states[tracker]
-			if state.Status == "queued" || state.Status == "running" {
-				state.Status = "canceled"
-				state.Message = "canceled"
-				state.FinishedAt = job.finishedAt.Format(time.RFC3339)
-				job.states[tracker] = state
-			}
-		}
-	case len(job.failedTrackers) > 0:
-		job.status = "completed_with_errors"
-	default:
-		job.status = "completed"
-		job.errorMessage = ""
-	}
-	job.cancel = nil
-	job.mu.Unlock()
-	job.closeResources()
-	b.emitTrackerUploadSnapshot(job)
-	b.scheduleTrackerUploadJobCleanup(job)
-}
-
-func (b *Backend) applyTrackerUploadProgress(job *trackerUploadJob, update api.UploadProgressUpdate) {
-	if b == nil || job == nil {
-		return
-	}
-	tracker := strings.TrimSpace(update.Tracker)
-	if tracker == "" && len(job.trackers) == 1 {
-		tracker = job.trackers[0]
-	}
-
-	job.mu.Lock()
-	now := time.Now()
-	previousStatus := job.currentTaskStatus
-	previousPercent := job.currentPercent
-	previousHashRate := job.currentHashRateMiB
-	job.currentTask = strings.TrimSpace(update.Task)
-	job.currentTaskStatus = strings.TrimSpace(update.Status)
-	job.currentMessage = strings.TrimSpace(update.Message)
-	job.currentCompleted = update.CompletedPieces
-	job.currentTotal = update.TotalPieces
-	job.currentPercent = update.Percent
-	job.currentHashRateMiB = update.HashRateMiB
-	throttle := job.snapshotThrottle
-	if throttle <= 0 {
-		throttle = trackerUploadSnapshotThrottle
-	}
-	shouldEmit := job.lastSnapshotEmit.IsZero() ||
-		now.Sub(job.lastSnapshotEmit) >= throttle ||
-		previousPercent != job.currentPercent ||
-		previousStatus != job.currentTaskStatus ||
-		absFloat64(previousHashRate-job.currentHashRateMiB) >= trackerUploadHashRateEmitDeltaMiB
-	if tracker != "" {
-		state := job.states[tracker]
-		state.Tracker = tracker
-		state.Task = job.currentTask
-		state.TaskStatus = job.currentTaskStatus
-		state.CompletedPieces = update.CompletedPieces
-		state.TotalPieces = update.TotalPieces
-		state.Percent = update.Percent
-		state.HashRateMiB = update.HashRateMiB
-		if job.currentMessage != "" {
-			state.Message = job.currentMessage
-		}
-		if state.Status == "queued" && strings.EqualFold(job.currentTaskStatus, "running") {
-			state.Status = "running"
-		}
-		if state.StartedAt == "" && state.Status == "running" {
-			state.StartedAt = time.Now().UTC().Format(time.RFC3339)
-		}
-		job.states[tracker] = state
-	}
-	if shouldEmit {
-		job.lastSnapshotEmit = now
+	rt, err := b.requireRuntime()
+	if err != nil {
+		return "", err
 	}
-	job.mu.Unlock()
-
-	if shouldEmit {
-		b.emitTrackerUploadSnapshot(job)
+	if !rt.capabilities.PreparedGenerationReady() {
+		return "", ErrPreparedGenerationUnavailable
 	}
-}
-
-func absFloat64(value float64) float64 {
-	if value < 0 {
-		return -value
+	input := spec.Snapshot.Input
+	input.Release.SourcePath = strings.TrimSpace(input.Release.SourcePath)
+	if input.Release.SourcePath == "" {
+		return "", errors.New("path is required")
 	}
-	return value
-}
-
-func (b *Backend) runSingleTrackerUpload(ctx context.Context, job *trackerUploadJob, tracker string) (api.Result, error) {
-	req := api.Request{
-		Paths:                       []string{job.sourcePath},
-		Mode:                        api.ModeGUI,
-		DescriptionGroups:           api.CloneDescriptionBuilderGroups(job.descriptionGroups),
-		Trackers:                    []string{tracker},
-		IgnoreDupesFor:              append([]string(nil), job.ignoreDupesFor...),
-		IgnoreTrackerRuleFailures:   false,
-		Options:                     job.uploadOptions,
-		ExternalIDOverrides:         job.overrides,
-		ReleaseNameOverrides:        job.nameOverrides,
-		TrackerQuestionnaireAnswers: cloneQuestionnaireAnswers(job.questionnaireAnswers),
-	}
-	return wrapWebResult(job.core.RunUploadPrepared(ctx, req))
-}
-
-func upsertDupeSummaryResult(summary *api.DupeCheckSummary, result api.DupeCheckResult) {
-	if summary == nil {
-		return
+	input.Trackers = normalizeTrackerList(input.Trackers)
+	if len(input.Trackers) == 0 {
+		return "", errors.New("at least one tracker must be selected")
 	}
-	tracker := strings.ToUpper(strings.TrimSpace(result.Tracker))
-	for idx := range summary.Results {
-		if strings.ToUpper(strings.TrimSpace(summary.Results[idx].Tracker)) == tracker {
-			summary.Results[idx] = result
-			return
-		}
+	input.IgnoreDupesFor = normalizeTrackerList(input.IgnoreDupesFor)
+	spec.Snapshot.Input = input
+	if spec.Snapshot.RuntimeGeneration != rt.generationID {
+		return "", api.NewOperationError(api.OperationFailure{
+			Code:      api.OperationFailureStaleReview,
+			Operation: api.OperationKindUploadExecute,
+			Message:   "Upload retry requires a new review after configuration changed.",
+			Recovery:  api.OperationRecoveryReviewAgain,
+		}, errors.New("runtime generation changed"))
 	}
-	summary.Results = append(summary.Results, result)
-}
 
-// dupeResultTrackerNames expands grouped dupe summary labels into the
-// per-tracker state keys used by frontend snapshots.
-func dupeResultTrackerNames(result api.DupeCheckResult) []string {
-	trackers := strings.Split(result.Tracker, ",")
-	names := make([]string, 0, len(trackers))
-	seen := make(map[string]struct{}, len(trackers))
-	for _, tracker := range trackers {
-		name := strings.ToUpper(strings.TrimSpace(tracker))
-		if name == "" {
-			continue
-		}
-		if _, ok := seen[name]; ok {
-			continue
-		}
-		seen[name] = struct{}{}
-		names = append(names, name)
+	seedCtx, cancel := context.WithTimeout(context.Background(), seedPreparedMetaTimeout)
+	defer cancel()
+	releaseRef := spec.Snapshot.Input.Release
+	if _, err = rt.capabilities.PreparedGenerationTransfer.ExportReleaseSeed(seedCtx, releaseRef); err != nil {
+		return "", fmt.Errorf("web: canonical preparation: %w", err)
 	}
-	return names
-}
-
-func hasFailedDupeState(states map[string]DupeCheckTrackerState) bool {
-	for _, state := range states {
-		if strings.EqualFold(state.Status, "failed") {
-			return true
-		}
+	generationSeed := spec.Snapshot.Seed
+	runCapabilities, runOwner, runLogger, err := b.buildRunCoreFromSnapshot(seedCtx, rt, runOpts)
+	if err != nil {
+		return "", err
 	}
-	return false
-}
-
-func isDupeTerminalStatus(status string) bool {
-	switch strings.ToLower(strings.TrimSpace(status)) {
-	case "completed", "completed_with_errors", "skipped", "failed", "canceled":
-		return true
-	default:
-		return false
+	if !runCapabilities.PreparedUploadReady() || !runCapabilities.PreparedGenerationReady() {
+		closeJobResources(runOwner, runLogger)
+		return "", ErrPreparedUploadUnavailable
 	}
-}
 
-func isDupeJobTerminal(job *dupeCheckJob) bool {
-	if job == nil {
-		return false
+	spec.Runner = webUploadRunner{
+		core:             runCapabilities.UploadExecution,
+		generationTarget: runCapabilities.PreparedGenerationTransfer,
+		generationSeed:   generationSeed,
+		expectedRelease:  releaseRef,
 	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	return isDupeTerminalStatus(job.status) && !job.finishedAt.IsZero()
-}
-
-func isTrackerUploadJobTerminal(job *trackerUploadJob) bool {
-	if job == nil {
-		return false
-	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	switch strings.ToLower(strings.TrimSpace(job.status)) {
-	case "completed", "completed_with_errors", "failed", "canceled":
-		return !job.finishedAt.IsZero()
-	default:
-		return false
+	spec.Resources = jobs.Resources{Core: runOwner, Logger: runLogger}
+	jobID, err := b.jobEngine.StartUpload(context.Background(), owner, spec)
+	if err != nil {
+		closeJobResources(runOwner, runLogger)
+		return "", fmt.Errorf("web: start upload job: %w", err)
 	}
+	return jobID, nil
 }
 
-func resultStatus(result api.DupeCheckResult) string {
-	if strings.TrimSpace(result.Status) != "" {
-		return result.Status
-	}
-	if result.Skipped {
-		return "skipped"
-	}
-	if strings.TrimSpace(result.Error) != "" {
-		return "failed"
+// CancelTrackerUpload requests cancellation when sessionID owns jobID.
+// Unknown and foreign-owned IDs return the same not-found error.
+func (b *Backend) CancelTrackerUpload(sessionID string, jobID string) error {
+	if err := b.jobEngine.CancelUpload(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID)); err != nil {
+		return fmt.Errorf("%w", err)
 	}
-	return "completed"
+	return nil
 }
 
-func resultMessage(result api.DupeCheckResult) string {
-	if strings.TrimSpace(result.Error) != "" {
-		return strings.TrimSpace(result.Error)
-	}
-	if strings.TrimSpace(result.SkipReason) != "" {
-		return strings.TrimSpace(result.SkipReason)
-	}
-	if result.HasDupes {
-		return fmt.Sprintf("%d dupes found", len(result.Filtered))
+// RetryFailedTrackerUpload starts a new session-owned job for only the original failed trackers.
+// It rebuilds per-run resources from the current runtime while preserving the original job input and options.
+func (b *Backend) RetryFailedTrackerUpload(sessionID string, jobID string, correlationID string) (string, error) {
+	retry, err := b.jobEngine.UploadRetry(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID))
+	if err != nil {
+		return "", fmt.Errorf("%w", err)
 	}
-	return "no dupes found"
-}
-
-func (b *Backend) emitDupeCheckSnapshot(job *dupeCheckJob) {
-	b.hub.Emit(job.sessionID, "dupe:job:"+job.id, buildDupeCheckSnapshot(job))
-}
-
-func buildDupeCheckSnapshot(job *dupeCheckJob) DupeCheckSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	trackers := make([]DupeCheckTrackerState, 0, len(job.trackers))
-	for _, tracker := range job.trackers {
-		normalized := strings.ToUpper(strings.TrimSpace(tracker))
-		trackers = append(trackers, job.states[normalized])
-	}
-	return DupeCheckSnapshot{
-		JobID:          job.id,
-		SourcePath:     job.sourcePath,
-		Status:         job.status,
-		Trackers:       trackers,
-		CompletedCount: job.completedCount,
-		TotalCount:     job.totalCount,
-		Summary:        job.summary,
-		Error:          job.errorMessage,
-		StartedAt:      job.startedAt.Format(time.RFC3339),
-		FinishedAt:     formatTime(job.finishedAt),
+	runOpts := runOptions{
+		NoSeed:      retry.Snapshot.Input.Options.NoSeed,
+		RunLogLevel: retry.Snapshot.Input.Options.RunLogLevel,
 	}
+	return b.retryTrackerUpload(sessionID, retry.Spec(correlationID, nil, jobs.Resources{}), runOpts)
 }
 
-func (b *Backend) getDupeCheckJob(jobID string) *dupeCheckJob {
-	b.dupeMu.Lock()
-	defer b.dupeMu.Unlock()
-	return b.dupes[jobID]
-}
-
-func (b *Backend) getDupeCheckJobForSession(sessionID string, jobID string) *dupeCheckJob {
-	job := b.getDupeCheckJob(jobID)
-	if job == nil {
-		return nil
+// ListJobs returns immutable retained duplicate-check and upload Jobs for one authenticated owner.
+func (b *Backend) ListJobs(sessionID string) ([]jobs.OwnerJobSnapshot, error) {
+	owner, err := b.ensureJobOwner(sessionID)
+	if err != nil {
+		return nil, err
 	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	if strings.TrimSpace(job.sessionID) != sessionID {
-		return nil
+	snapshots, err := b.jobEngine.List(owner)
+	if err != nil {
+		return nil, fmt.Errorf("web: list owner jobs: %w", err)
 	}
-	return job
+	return snapshots, nil
 }
 
-func (b *Backend) scheduleDupeJobCleanup(job *dupeCheckJob) {
-	if job == nil {
-		return
+// GetTrackerUploadSnapshot returns an immutable job snapshot when sessionID owns jobID.
+// Unknown and foreign-owned IDs return the same not-found error.
+func (b *Backend) GetTrackerUploadSnapshot(sessionID string, jobID string) (TrackerUploadSnapshot, error) {
+	snapshot, err := b.jobEngine.UploadSnapshot(b.lookupJobOwner(sessionID), strings.TrimSpace(jobID))
+	if err != nil {
+		return TrackerUploadSnapshot{}, fmt.Errorf("%w", err)
 	}
-
-	b.dupeMu.Lock()
-	b.pruneCompletedDupeJobsLocked(maxCompletedDupeJobs)
-	b.dupeMu.Unlock()
-
-	time.AfterFunc(completedJobRetention, func() {
-		b.dupeMu.Lock()
-		defer b.dupeMu.Unlock()
-
-		if current := b.dupes[job.id]; current == job && isDupeJobTerminal(job) {
-			delete(b.dupes, job.id)
-		}
-	})
+	return snapshot, nil
 }
 
-func (b *Backend) pruneCompletedDupeJobsLocked(maxCompleted int) {
-	if maxCompleted <= 0 {
-		return
-	}
-
-	completed := make([]*dupeCheckJob, 0, len(b.dupes))
-	for _, job := range b.dupes {
-		if isDupeJobTerminal(job) {
-			completed = append(completed, job)
-		}
+// closeJobResources releases adapter-owned resources after preparation or engine enrollment fails.
+func closeJobResources(coreSvc jobs.Closer, logger *logging.Logger) {
+	if coreSvc != nil {
+		_ = coreSvc.Close()
 	}
-	if len(completed) <= maxCompleted {
-		return
-	}
-
-	sort.Slice(completed, func(i, j int) bool {
-		return completed[i].finishedAt.Before(completed[j].finishedAt)
-	})
-
-	for _, job := range completed[:len(completed)-maxCompleted] {
-		delete(b.dupes, job.id)
+	if logger != nil {
+		_ = logger.Close()
 	}
 }
 
+// stopAllDupeJobs remains as a compatibility shim for shutdown tests and closes the shared engine.
 func (b *Backend) stopAllDupeJobs() {
-	b.dupeMu.Lock()
-	jobs := make([]*dupeCheckJob, 0, len(b.dupes))
-	for _, job := range b.dupes {
-		jobs = append(jobs, job)
-	}
-	b.dupeMu.Unlock()
-	for _, job := range jobs {
-		if job == nil {
-			continue
-		}
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
-	}
-	b.dupeWG.Wait()
-}
-
-func (b *Backend) emitTrackerUploadSnapshot(job *trackerUploadJob) {
-	b.hub.Emit(job.sessionID, "upload:job:"+job.id, buildTrackerUploadSnapshot(job))
-}
-
-func buildTrackerUploadSnapshot(job *trackerUploadJob) TrackerUploadSnapshot {
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	trackers := make([]TrackerUploadTrackerState, 0, len(job.trackers))
-	for _, tracker := range job.trackers {
-		trackers = append(trackers, job.states[tracker])
-	}
-	return TrackerUploadSnapshot{
-		JobID:                  job.id,
-		SourcePath:             job.sourcePath,
-		Status:                 job.status,
-		CurrentTask:            job.currentTask,
-		CurrentTaskStatus:      job.currentTaskStatus,
-		CurrentMessage:         job.currentMessage,
-		CurrentCompletedPieces: job.currentCompleted,
-		CurrentTotalPieces:     job.currentTotal,
-		CurrentPercent:         job.currentPercent,
-		CurrentHashRateMiB:     job.currentHashRateMiB,
-		Trackers:               trackers,
-		FailedTrackers:         append([]string(nil), job.failedTrackers...),
-		UploadedCount:          job.uploadedCount,
-		Error:                  job.errorMessage,
-		StartedAt:              job.startedAt.Format(time.RFC3339),
-		FinishedAt:             formatTime(job.finishedAt),
-	}
-}
-
-func (b *Backend) getTrackerUploadJob(jobID string) *trackerUploadJob {
-	b.uploadMu.Lock()
-	defer b.uploadMu.Unlock()
-	return b.uploads[jobID]
-}
-
-func (b *Backend) getTrackerUploadJobForSession(sessionID string, jobID string) *trackerUploadJob {
-	job := b.getTrackerUploadJob(jobID)
-	if job == nil {
-		return nil
-	}
-	job.mu.Lock()
-	defer job.mu.Unlock()
-	if strings.TrimSpace(job.sessionID) != sessionID {
-		return nil
-	}
-	return job
-}
-
-func (b *Backend) scheduleTrackerUploadJobCleanup(job *trackerUploadJob) {
-	if job == nil {
-		return
-	}
-
-	b.uploadMu.Lock()
-	b.pruneCompletedUploadJobsLocked(maxCompletedUploadJobs)
-	b.uploadMu.Unlock()
-
-	time.AfterFunc(completedJobRetention, func() {
-		b.uploadMu.Lock()
-		defer b.uploadMu.Unlock()
-
-		if current := b.uploads[job.id]; current == job && isTrackerUploadJobTerminal(job) {
-			delete(b.uploads, job.id)
-		}
-	})
-}
-
-func (b *Backend) pruneCompletedUploadJobsLocked(maxCompleted int) {
-	if maxCompleted <= 0 {
-		return
-	}
-
-	completed := make([]*trackerUploadJob, 0, len(b.uploads))
-	for _, job := range b.uploads {
-		if isTrackerUploadJobTerminal(job) {
-			completed = append(completed, job)
-		}
-	}
-	if len(completed) <= maxCompleted {
-		return
-	}
-
-	sort.Slice(completed, func(i, j int) bool {
-		return completed[i].finishedAt.Before(completed[j].finishedAt)
-	})
-
-	for _, job := range completed[:len(completed)-maxCompleted] {
-		delete(b.uploads, job.id)
+	if b != nil && b.jobEngine != nil {
+		b.jobEngine.Close()
 	}
 }
 
+// stopAllUploadJobs remains as a compatibility shim for shutdown tests and closes the shared engine.
 func (b *Backend) stopAllUploadJobs() {
-	b.uploadMu.Lock()
-	jobs := make([]*trackerUploadJob, 0, len(b.uploads))
-	for _, job := range b.uploads {
-		jobs = append(jobs, job)
-	}
-	b.uploadMu.Unlock()
-	for _, job := range jobs {
-		if job == nil {
-			continue
-		}
-		job.mu.Lock()
-		cancel := job.cancel
-		job.mu.Unlock()
-		if cancel != nil {
-			cancel()
-		}
+	if b != nil && b.jobEngine != nil {
+		b.jobEngine.Close()
 	}
-	b.uploadWG.Wait()
 }
 
+// stopAllLogStreams signals every active stream and waits for its worker to exit.
 func (b *Backend) stopAllLogStreams() {
 	b.streamMu.Lock()
 	streams := make([]*backendLogStream, 0, len(b.streams))
@@ -1205,17 +667,9 @@ func (b *Backend) stopAllLogStreams() {
 	}
 	b.streamMu.Unlock()
 	for _, stream := range streams {
-		if stream == nil {
-			continue
+		if stream != nil {
+			<-stream.done
 		}
-		<-stream.done
 	}
 	b.streamWG.Wait()
 }
-
-func formatTime(value time.Time) string {
-	if value.IsZero() {
-		return ""
-	}
-	return value.Format(time.RFC3339)
-}
diff --git a/internal/webserver/jobs/contract_test.go b/internal/webserver/jobs/contract_test.go
new file mode 100644
index 00000000..36710936
--- /dev/null
+++ b/internal/webserver/jobs/contract_test.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestSnapshotJSONContractAndZeroTimes(t *testing.T) {
+	t.Parallel()
+	upload, err := json.Marshal(TrackerUploadSnapshot{
+		JobID:         "job",
+		Trackers:      []TrackerUploadTrackerState{},
+		FailedTrackers: []string{},
+	})
+	if err != nil {
+		t.Fatalf("marshal upload: %v", err)
+	}
+	for _, field := range []string{`"jobID":"job"`, `"release":{"SourcePath":"","Generation":0}`, `"status":""`, `"currentTask":""`, `"trackers":[]`, `"failedTrackers":[]`, `"startedAt":""`, `"finishedAt":""`} {
+		if !strings.Contains(string(upload), field) {
+			t.Errorf("upload JSON %s missing %s", upload, field)
+		}
+	}
+	dupe, err := json.Marshal(DupeCheckSnapshot{JobID: "job", Trackers: []DupeCheckTrackerState{}})
+	if err != nil {
+		t.Fatalf("marshal dupe: %v", err)
+	}
+	for _, field := range []string{`"jobID":"job"`, `"release":{"SourcePath":"","Generation":0}`, `"status":""`, `"trackers":[]`, `"completedCount":0`, `"totalCount":0`, `"startedAt":""`, `"finishedAt":""`} {
+		if !strings.Contains(string(dupe), field) {
+			t.Errorf("dupe JSON %s missing %s", dupe, field)
+		}
+	}
+}
diff --git a/internal/webserver/jobs/dupe.go b/internal/webserver/jobs/dupe.go
new file mode 100644
index 00000000..ff368648
--- /dev/null
+++ b/internal/webserver/jobs/dupe.go
@@ -0,0 +1,383 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// dupeJob contains mutable state for one owner-scoped duplicate check.
+type dupeJob struct {
+	mu                         sync.Mutex
+	id, correlationID          string
+	release                    api.ReleaseRef
+	spec                       DupeSpec
+	trackers                   []string
+	states                     map[string]DupeCheckTrackerState
+	completedCount, totalCount int
+	explicitTotal              bool
+	summary                    api.DupeCheckSummary
+	status                     string
+	failure, outcomeFailure    *api.OperationFailure
+	outcomeStatus              string
+	startedAt, finishedAt      time.Time
+	outcomeAt                  time.Time
+}
+
+func newDupeJob(id string, spec DupeSpec, now time.Time) *dupeJob {
+	trackers := spec.Snapshot.Input.Trackers
+	states := make(map[string]DupeCheckTrackerState, len(trackers))
+	for _, tracker := range trackers {
+		states[tracker] = DupeCheckTrackerState{
+			Tracker: tracker,
+			Status:  StatusQueued,
+			Message: StatusQueued,
+		}
+	}
+	return &dupeJob{
+		id:            id,
+		correlationID: spec.CorrelationID,
+		release:       spec.Snapshot.Input.Release,
+		spec:          spec,
+		trackers:      append([]string(nil), trackers...),
+		states:        states,
+		totalCount:    len(states),
+		summary:       api.DupeCheckSummary{SourcePath: spec.Snapshot.Input.Release.SourcePath},
+		status:        StatusQueued,
+		startedAt:     now,
+	}
+}
+
+// runDupe executes the runner, merges progress and summary results, and closes resources before terminal emission.
+func (e *Engine) runDupe(ctx context.Context, job *dupeJob) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			e.failDupe(job, "dupe worker panicked: "+sanitizeMessage(fmt.Sprint(recovered)))
+		}
+	}()
+	job.mu.Lock()
+	job.status = StatusRunning
+	job.mu.Unlock()
+	e.emitDupeJob(job)
+	progressCtx := api.WithDupeProgressReporter(ctx, func(update api.DupeProgressUpdate) { e.applyDupeProgress(job, update) })
+	summary, err := job.spec.Runner.CheckDupes(progressCtx, job.input())
+	now := e.deps.now().UTC()
+	job.mu.Lock()
+	job.outcomeAt = now
+	job.summary = cloneSummary(summary)
+	for _, result := range summary.Results {
+		job.mergeResultLocked(result, now)
+	}
+	if err != nil {
+		if ctx.Err() != nil {
+			job.outcomeStatus = StatusCanceled
+			job.outcomeFailure = nil
+			job.cancelActiveLocked()
+		} else {
+			job.outcomeStatus = StatusFailed
+			job.outcomeFailure = failureForError(
+				err,
+				api.OperationKindDuplicateCheck,
+				"Duplicate check failed.",
+				api.OperationRecoveryRetry,
+			)
+			job.failActiveLocked()
+		}
+		job.mu.Unlock()
+		return
+	}
+	if hasFailedDupeState(job.states) {
+		job.outcomeStatus = StatusCompletedWithErrors
+		job.outcomeFailure = genericFailure(
+			api.OperationKindDuplicateCheck,
+			"One or more tracker duplicate checks failed.",
+			api.OperationRecoveryRetry,
+		)
+	} else {
+		job.outcomeStatus = StatusCompleted
+		job.outcomeFailure = nil
+	}
+	job.mu.Unlock()
+}
+
+// failDupe converts a worker failure into a sanitized failed snapshot and terminates active tracker states.
+func (e *Engine) failDupe(job *dupeJob, message string) {
+	e.warn("duplicate-check Job failed: " + sanitizeMessage(message))
+	job.mu.Lock()
+	if job.outcomeAt.IsZero() {
+		job.outcomeAt = e.deps.now().UTC()
+	}
+	job.outcomeStatus = StatusFailed
+	job.outcomeFailure = genericFailure(
+		api.OperationKindDuplicateCheck,
+		"Duplicate check failed.",
+		api.OperationRecoveryRetry,
+	)
+	job.failActiveLocked()
+	job.mu.Unlock()
+}
+
+// finalizeDupe publishes the staged outcome only after per-Job resources close.
+func (e *Engine) finalizeDupe(job *dupeJob) {
+	job.mu.Lock()
+	if job.outcomeStatus == "" {
+		job.outcomeStatus = StatusFailed
+		job.outcomeFailure = genericFailure(
+			api.OperationKindDuplicateCheck,
+			"Duplicate check failed.",
+			api.OperationRecoveryRetry,
+		)
+	}
+	job.status = job.outcomeStatus
+	job.failure = cloneFailure(job.outcomeFailure)
+	job.finishedAt = e.deps.now().UTC()
+	job.mu.Unlock()
+}
+
+// applyDupeProgress merges dynamically discovered trackers without double-counting terminal transitions.
+func (e *Engine) applyDupeProgress(job *dupeJob, update api.DupeProgressUpdate) {
+	tracker := strings.ToUpper(strings.TrimSpace(update.Tracker))
+	if tracker == "" {
+		return
+	}
+	now := e.deps.now().UTC()
+	job.mu.Lock()
+	state, exists := job.states[tracker]
+	if update.Total > 0 {
+		job.explicitTotal = true
+	}
+	if !exists {
+		state.Tracker = tracker
+		job.trackers = append(job.trackers, tracker)
+		if !job.explicitTotal {
+			job.totalCount++
+		}
+	}
+	previousStatus := state.Status
+	if status := strings.TrimSpace(update.Status); status != "" {
+		state.Status = status
+	}
+	if message := strings.TrimSpace(update.Message); message != "" {
+		state.Message = sanitizeMessage(message)
+	}
+	if state.Status == StatusRunning && state.StartedAt == "" {
+		state.StartedAt = formatTime(now)
+	}
+	if strings.TrimSpace(update.Result.Tracker) != "" {
+		result := cloneResult(update.Result)
+		result.Tracker = tracker
+		state.Result = result
+		upsertDupeSummaryResult(&job.summary, result)
+	}
+	if isDupeTerminal(state.Status) {
+		if state.FinishedAt == "" {
+			state.FinishedAt = formatTime(now)
+		}
+		if !isDupeTerminal(previousStatus) {
+			job.completedCount++
+		}
+	}
+	if update.Total > job.totalCount {
+		job.totalCount = update.Total
+	}
+	job.states[tracker] = state
+	job.mu.Unlock()
+	e.emitDupeJob(job)
+}
+
+// mergeResultLocked upserts one canonical tracker result.
+// The caller must hold j.mu.
+func (j *dupeJob) mergeResultLocked(raw api.DupeCheckResult, now time.Time) {
+	tracker := strings.ToUpper(strings.TrimSpace(raw.Tracker))
+	if tracker == "" {
+		return
+	}
+	result := cloneResult(raw)
+	result.Tracker = tracker
+	state, exists := j.states[tracker]
+	if !exists {
+		state.Tracker = tracker
+		j.trackers = append(j.trackers, tracker)
+		if !j.explicitTotal {
+			j.totalCount++
+		}
+	}
+	if !isDupeTerminal(state.Status) {
+		j.completedCount++
+	}
+	state.Status = resultStatus(result)
+	state.Message = sanitizeMessage(resultMessage(result))
+	state.Result = result
+	if state.StartedAt == "" {
+		state.StartedAt = formatTime(j.startedAt)
+	}
+	state.FinishedAt = formatTime(now)
+	j.states[tracker] = state
+}
+
+func (j *dupeJob) input() api.DuplicateCheckInput {
+	input := cloneDuplicateExecutionSnapshot(j.spec.Snapshot).Input
+	input.Trackers = append([]string(nil), j.trackers...)
+	return input
+}
+
+// snapshot copies all mutable duplicate-check state for lock-free sink delivery.
+func (j *dupeJob) snapshot() DupeCheckSnapshot {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	trackers := make([]DupeCheckTrackerState, 0, len(j.trackers))
+	seen := make(map[string]struct{}, len(j.trackers))
+	for _, tracker := range j.trackers {
+		normalized := strings.ToUpper(strings.TrimSpace(tracker))
+		if normalized == "" {
+			continue
+		}
+		trackers = append(trackers, cloneDupeState(j.states[normalized]))
+		seen[normalized] = struct{}{}
+	}
+	for tracker, state := range j.states {
+		if _, ok := seen[tracker]; !ok {
+			trackers = append(trackers, cloneDupeState(state))
+		}
+	}
+	return DupeCheckSnapshot{
+		JobID:             j.id,
+		CorrelationID:     j.correlationID,
+		Release:           j.release,
+		RuntimeGeneration: j.spec.Snapshot.RuntimeGeneration,
+		RequestedTrackers: append([]string(nil), j.spec.Snapshot.Input.Trackers...),
+		Status:            j.status,
+		Trackers:          trackers,
+		CompletedCount:    j.completedCount,
+		TotalCount:        j.totalCount,
+		Summary:           cloneSummary(j.summary),
+		Failure:           cloneFailure(j.failure),
+		StartedAt:         formatTime(j.startedAt),
+		FinishedAt:        formatTime(j.finishedAt),
+	}
+}
+
+func (j *dupeJob) cancelActiveLocked() {
+	for tracker, state := range j.states {
+		if !isDupeTerminal(state.Status) {
+			j.completedCount++
+			state.Status = StatusCanceled
+			state.Message = StatusCanceled
+			state.FinishedAt = formatTime(j.outcomeAt)
+			j.states[tracker] = state
+		}
+	}
+}
+func (j *dupeJob) failActiveLocked() {
+	message := "Duplicate check failed."
+	if j.outcomeFailure != nil && strings.TrimSpace(j.outcomeFailure.Message) != "" {
+		message = j.outcomeFailure.Message
+	}
+	for tracker, state := range j.states {
+		if !isDupeTerminal(state.Status) {
+			j.completedCount++
+			state.Status = StatusFailed
+			state.Message = message
+			state.FinishedAt = formatTime(j.outcomeAt)
+			j.states[tracker] = state
+		}
+	}
+}
+
+func upsertDupeSummaryResult(summary *api.DupeCheckSummary, result api.DupeCheckResult) {
+	tracker := strings.ToUpper(strings.TrimSpace(result.Tracker))
+	if tracker == "" {
+		return
+	}
+	for idx := range summary.Results {
+		if strings.ToUpper(strings.TrimSpace(summary.Results[idx].Tracker)) == tracker {
+			summary.Results[idx] = cloneResult(result)
+			return
+		}
+	}
+	summary.Results = append(summary.Results, cloneResult(result))
+}
+func hasFailedDupeState(states map[string]DupeCheckTrackerState) bool {
+	for _, state := range states {
+		if strings.EqualFold(state.Status, StatusFailed) {
+			return true
+		}
+	}
+	return false
+}
+func isDupeTerminal(status string) bool {
+	switch strings.ToLower(strings.TrimSpace(status)) {
+	case StatusCompleted, "skipped", StatusFailed, StatusCanceled:
+		return true
+	default:
+		return false
+	}
+}
+func isJobTerminal(status string) bool {
+	switch strings.ToLower(strings.TrimSpace(status)) {
+	case StatusCompleted, StatusCompletedWithErrors, StatusFailed, StatusCanceled:
+		return true
+	default:
+		return false
+	}
+}
+func resultStatus(result api.DupeCheckResult) string {
+	if status := strings.TrimSpace(result.Status); status != "" {
+		return status
+	}
+	if result.Skipped {
+		return "skipped"
+	}
+	if strings.TrimSpace(result.Error) != "" {
+		return StatusFailed
+	}
+	return StatusCompleted
+}
+func resultMessage(result api.DupeCheckResult) string {
+	if result.Error != "" {
+		return result.Error
+	}
+	if result.SkipReason != "" {
+		return result.SkipReason
+	}
+	if result.HasDupes {
+		return fmt.Sprintf("%d dupes found", len(result.Filtered))
+	}
+	return "no dupes found"
+}
+func formatTime(value time.Time) string {
+	if value.IsZero() {
+		return ""
+	}
+	return value.UTC().Format(time.RFC3339)
+}
+func cloneSummary(summary api.DupeCheckSummary) api.DupeCheckSummary {
+	cloned := summary
+	cloned.Results = make([]api.DupeCheckResult, len(summary.Results))
+	for idx := range summary.Results {
+		cloned.Results[idx] = cloneResult(summary.Results[idx])
+	}
+	cloned.Notes = append([]string(nil), summary.Notes...)
+	cloned.Eligibility = cloneTrackerEligibility(summary.Eligibility)
+	return cloned
+}
+func cloneResult(result api.DupeCheckResult) api.DupeCheckResult {
+	result.Raw = append([]api.DupeEntry(nil), result.Raw...)
+	result.Filtered = append([]api.DupeEntry(nil), result.Filtered...)
+	result.Notes = append([]string(nil), result.Notes...)
+	if result.Error != "" {
+		result.Error = sanitizeMessage(result.Error)
+	}
+	return result
+}
+func cloneDupeState(state DupeCheckTrackerState) DupeCheckTrackerState {
+	state.Result = cloneResult(state.Result)
+	return state
+}
diff --git a/internal/webserver/jobs/dupe_test.go b/internal/webserver/jobs/dupe_test.go
new file mode 100644
index 00000000..0d163640
--- /dev/null
+++ b/internal/webserver/jobs/dupe_test.go
@@ -0,0 +1,179 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestDupeCanonicalResultsDiscoveryAndRepeatedTerminalProgress(t *testing.T) {
+	t.Parallel()
+	runner := dupeRunnerFunc(func(ctx context.Context, _ api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
+			Tracker: "a",
+			Status:  "running",
+			Total:   3,
+		})
+		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
+			Tracker: "a",
+			Status:  "completed",
+			Total:   2,
+			Result:  api.DupeCheckResult{Tracker: "a"},
+		})
+		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
+			Tracker: "a",
+			Status:  "completed",
+			Total:   1,
+			Result:  api.DupeCheckResult{Tracker: "a"},
+		})
+		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{
+			Tracker: " discovered ",
+			Status:  "skipped",
+			Result:  api.DupeCheckResult{Tracker: "discovered", Skipped: true},
+		})
+		return api.DupeCheckSummary{Results: []api.DupeCheckResult{
+			{
+				Tracker:  "A",
+				HasDupes: true,
+				Filtered: []api.DupeEntry{{}},
+			},
+			{Tracker: "B", Status: "completed"},
+		}}, nil
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartDupe(context.Background(), mustRegisterOwner(t, engine, "owner"), dupeSpec(runner, "a"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if snapshot.Status != StatusCompleted || snapshot.CompletedCount != 3 || snapshot.TotalCount != 3 {
+		t.Fatalf("counts/status = %#v", snapshot)
+	}
+	if len(snapshot.Trackers) != 3 || snapshot.Trackers[0].Tracker != "A" || snapshot.Trackers[1].Tracker != "DISCOVERED" || snapshot.Trackers[2].Tracker != "B" {
+		t.Fatalf("tracker order = %#v", snapshot.Trackers)
+	}
+}
+
+func TestDupeCancellationMarksEveryActiveTracker(t *testing.T) {
+	t.Parallel()
+	started := make(chan struct{})
+	runner := dupeRunnerFunc(func(ctx context.Context, _ api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		api.EmitDupeProgress(ctx, api.DupeProgressUpdate{Tracker: "A", Status: "completed"})
+		close(started)
+		<-ctx.Done()
+		return api.DupeCheckSummary{}, ctx.Err()
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	id, err := engine.StartDupe(context.Background(), owner, dupeSpec(runner, "A", "B"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	<-started
+	if err := engine.CancelDupe(owner, id); err != nil {
+		t.Fatalf("CancelDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if snapshot.Status != StatusCanceled || snapshot.Trackers[0].Status != StatusCompleted || snapshot.Trackers[1].Status != StatusCanceled {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+	for _, state := range snapshot.Trackers {
+		if state.Status == StatusQueued || state.Status == StatusRunning || state.FinishedAt == "" {
+			t.Fatalf("nonterminal state = %#v", state)
+		}
+	}
+}
+
+func TestDupeCoreErrorIsSanitizedAndLeavesNoActiveStates(t *testing.T) {
+	t.Parallel()
+	runner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{}, errors.New("api_key=secret-value")
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartDupe(context.Background(), mustRegisterOwner(t, engine, "owner"), dupeSpec(runner, "A", "B"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if snapshot.Status != StatusFailed || snapshot.Failure == nil || strings.Contains(snapshot.Failure.Message, "secret-value") {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+	for _, state := range snapshot.Trackers {
+		if state.Status != StatusFailed || strings.Contains(state.Message, "secret-value") {
+			t.Fatalf("state = %#v", state)
+		}
+	}
+}
+
+func TestDupeSnapshotPreservesTypedOperationFailure(t *testing.T) {
+	t.Parallel()
+	want := api.OperationFailure{
+		Code:      api.OperationFailureConfirmationRequired,
+		Operation: api.OperationKindDuplicateCheck,
+		Message:   "Blu-ray playlist changes require confirmation before rescanning.",
+		Recovery:  api.OperationRecoveryConfirm,
+	}
+	runner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{}, api.NewOperationError(want, errors.New("private cause"))
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartDupe(context.Background(), mustRegisterOwner(t, engine, "owner"), dupeSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if snapshot.Failure == nil || *snapshot.Failure != want {
+		t.Fatalf("failure = %#v, want %#v", snapshot.Failure, want)
+	}
+}
+
+func TestDupeResultErrorIsSanitizedBeforeSnapshotDelivery(t *testing.T) {
+	t.Parallel()
+	runner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{Results: []api.DupeCheckResult{{
+			Tracker: "A",
+			Status:  StatusFailed,
+			Error:   "token=secret-value",
+		}}}, nil
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartDupe(context.Background(), mustRegisterOwner(t, engine, "owner"), dupeSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if strings.Contains(snapshot.Trackers[0].Result.Error, "secret-value") || strings.Contains(snapshot.Summary.Results[0].Error, "secret-value") {
+		t.Fatalf("secret crossed result snapshot: %#v", snapshot)
+	}
+}
+
+func TestDupeResourceFailureDoesNotChangeOutcome(t *testing.T) {
+	t.Parallel()
+	closer := &closeRecorder{err: errors.New("token=secret-value")}
+	runner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{}, nil
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	spec := dupeSpec(runner, "A")
+	spec.Resources.Core = closer
+	id, err := engine.StartDupe(context.Background(), mustRegisterOwner(t, engine, "owner"), spec)
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	snapshot := waitDupe(t, engine, id)
+	if snapshot.Status != StatusCompleted || snapshot.Failure != nil || closer.count.Load() != 1 {
+		t.Fatalf("snapshot=%#v closes=%d", snapshot, closer.count.Load())
+	}
+}
diff --git a/internal/webserver/jobs/engine.go b/internal/webserver/jobs/engine.go
new file mode 100644
index 00000000..8b6c4ff5
--- /dev/null
+++ b/internal/webserver/jobs/engine.go
@@ -0,0 +1,729 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"math/big"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+const (
+	completedJobRetention = 24 * time.Hour
+	maxCompletedJobs      = 200
+)
+
+var (
+	// ErrEngineClosed indicates that the engine has begun shutdown and rejects new jobs.
+	ErrEngineClosed = errors.New("engine closed")
+	// ErrOwnerClosed indicates that an owner generation is unknown, draining, or closed.
+	ErrOwnerClosed = errors.New("job owner closed")
+	// ErrOwnerDraining indicates that a textual owner ID cannot be reused until blocking removal completes.
+	ErrOwnerDraining = errors.New("job owner draining")
+	// ErrDupeNotFound indicates that no dupe job is visible to the supplied owner.
+	ErrDupeNotFound = errors.New("dupe job not found")
+	// ErrUploadNotFound indicates that no upload job is visible to the supplied owner.
+	ErrUploadNotFound = errors.New("upload job not found")
+)
+
+// SnapshotSink receives copied job snapshots after state locks are released.
+// Implementations route each snapshot within the supplied owner scope.
+type SnapshotSink interface {
+	// EmitDupe publishes the latest dupe-check snapshot for ownerID.
+	EmitDupe(ownerID string, snapshot DupeCheckSnapshot)
+	// EmitUpload publishes the latest tracker-upload snapshot for ownerID.
+	EmitUpload(ownerID string, snapshot TrackerUploadSnapshot)
+}
+
+type diagnosticSink interface {
+	WarnJob(message string)
+}
+
+// UploadProgressPolicy controls how frequently upload progress snapshots are emitted.
+// State is updated for every progress event even when snapshot emission is throttled.
+type UploadProgressPolicy struct {
+	// MinInterval is the minimum delay between ordinary progress emissions; zero disables interval throttling.
+	MinInterval time.Duration
+	// HashRateDeltaMiB emits early when the MiB/s rate changes by at least this amount; zero makes every update qualify.
+	HashRateDeltaMiB float64
+}
+
+// Config controls kind-specific presentation behavior. Lifecycle retention is
+// deliberately fixed module policy: 24 hours and 200 terminal Jobs per owner.
+type Config struct {
+	// UploadProgress controls upload snapshot throttling without dropping state updates.
+	UploadProgress UploadProgressPolicy
+}
+
+type timer interface{ Stop() bool }
+
+// engineDeps supplies deterministic time, timer, ID, retention, and diagnostic seams for package tests.
+type engineDeps struct {
+	now          func() time.Time
+	newTimer     func(time.Duration, func()) timer
+	newID        func() string
+	retentionTTL time.Duration
+	retentionMax int
+}
+
+// OwnerHandle is opaque authority for exactly one live owner generation.
+// Stale handles remain closed even after the same textual owner ID is registered again.
+type OwnerHandle struct {
+	engine     *Engine
+	id         string
+	generation uint64
+	closed     atomic.Bool
+}
+
+// ID returns the normalized textual owner identity used only for scoped event routing.
+func (h *OwnerHandle) ID() string {
+	if h == nil {
+		return ""
+	}
+	return h.id
+}
+
+type jobKind uint8
+
+const (
+	jobKindDupe jobKind = iota + 1
+	jobKindUpload
+)
+
+type ownerState struct {
+	handle   *OwnerHandle
+	draining bool
+	records  map[string]*jobRecord
+	terminal []*jobRecord
+}
+
+// jobRecord contains only lifecycle facts shared by all Job kinds.
+type jobRecord struct {
+	id        string
+	kind      jobKind
+	owner     *OwnerHandle
+	accepted  time.Time
+	finished  time.Time
+	cancel    context.CancelFunc
+	done      chan struct{}
+	resources resourceSet
+	timer     timer
+	terminal  bool
+}
+
+// Engine owns owner-scoped upload and duplicate-check lifecycles.
+// Its exported methods are safe for concurrent use, and the zero value is not usable.
+type Engine struct {
+	mu         sync.Mutex
+	closing    bool
+	closed     bool
+	closedDone chan struct{}
+	wg         sync.WaitGroup
+	sink       SnapshotSink
+	config     Config
+	deps       engineDeps
+	generation uint64
+	owners     map[string]*ownerState
+	records    map[string]*jobRecord
+	dupes      map[string]*dupeJob
+	uploads    map[string]*uploadJob
+}
+
+// New creates a job engine that emits snapshots through sink according to config.
+// A nil sink is allowed and disables snapshot delivery.
+func New(sink SnapshotSink, config Config) *Engine {
+	return newEngine(sink, config, engineDeps{
+		now:          time.Now,
+		newTimer:     func(delay time.Duration, callback func()) timer { return time.AfterFunc(delay, callback) },
+		newID:        randomID,
+		retentionTTL: completedJobRetention,
+		retentionMax: maxCompletedJobs,
+	})
+}
+
+func newEngine(sink SnapshotSink, config Config, deps engineDeps) *Engine {
+	if deps.now == nil {
+		deps.now = time.Now
+	}
+	if deps.newTimer == nil {
+		deps.newTimer = func(delay time.Duration, callback func()) timer { return time.AfterFunc(delay, callback) }
+	}
+	if deps.newID == nil {
+		deps.newID = randomID
+	}
+	if deps.retentionTTL == 0 {
+		deps.retentionTTL = completedJobRetention
+	}
+	if deps.retentionMax == 0 {
+		deps.retentionMax = maxCompletedJobs
+	}
+	return &Engine{
+		sink:       sink,
+		config:     config,
+		deps:       deps,
+		closedDone: make(chan struct{}),
+		owners:     make(map[string]*ownerState),
+		records:    make(map[string]*jobRecord),
+		dupes:      make(map[string]*dupeJob),
+		uploads:    make(map[string]*uploadJob),
+	}
+}
+
+// RegisterOwner returns the live generation for ownerID or creates one. An ID
+// cannot be reused while its prior generation is draining.
+func (e *Engine) RegisterOwner(ownerID string) (*OwnerHandle, error) {
+	if e == nil {
+		return nil, ErrEngineClosed
+	}
+	ownerID = strings.TrimSpace(ownerID)
+	if ownerID == "" {
+		return nil, errors.New("owner id is required")
+	}
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	if e.closing {
+		return nil, ErrEngineClosed
+	}
+	if owner := e.owners[ownerID]; owner != nil {
+		if owner.draining || owner.handle.closed.Load() {
+			return nil, ErrOwnerDraining
+		}
+		return owner.handle, nil
+	}
+	e.generation++
+	handle := &OwnerHandle{
+		engine:     e,
+		id:         ownerID,
+		generation: e.generation,
+	}
+	e.owners[ownerID] = &ownerState{handle: handle, records: make(map[string]*jobRecord)}
+	return handle, nil
+}
+
+func (e *Engine) validateOwnerLocked(handle *OwnerHandle) (*ownerState, error) {
+	if handle == nil || handle.engine != e || handle.closed.Load() {
+		return nil, ErrOwnerClosed
+	}
+	owner := e.owners[handle.id]
+	if owner == nil || owner.handle != handle || owner.handle.generation != handle.generation || owner.draining {
+		return nil, ErrOwnerClosed
+	}
+	return owner, nil
+}
+
+// RemoveOwner blocks new enrollment, cancels and drains only handle's Jobs,
+// releases their resources, and removes all retained snapshots for that generation.
+func (e *Engine) RemoveOwner(handle *OwnerHandle) error {
+	if e == nil || handle == nil || handle.engine != e {
+		return ErrOwnerClosed
+	}
+	e.mu.Lock()
+	owner := e.owners[handle.id]
+	if owner == nil || owner.handle != handle || owner.handle.generation != handle.generation {
+		e.mu.Unlock()
+		return ErrOwnerClosed
+	}
+	if owner.draining {
+		records := append([]*jobRecord(nil), ownerRecords(owner)...)
+		e.mu.Unlock()
+		waitRecords(records)
+		return nil
+	}
+	owner.draining = true
+	handle.closed.Store(true)
+	records := append([]*jobRecord(nil), ownerRecords(owner)...)
+	for _, record := range records {
+		if record.timer != nil {
+			record.timer.Stop()
+			record.timer = nil
+		}
+	}
+	e.mu.Unlock()
+
+	for _, record := range records {
+		if record.cancel != nil {
+			record.cancel()
+		}
+	}
+	waitRecords(records)
+
+	e.mu.Lock()
+	if current := e.owners[handle.id]; current == owner {
+		for _, record := range ownerRecords(owner) {
+			e.deleteRecordLocked(record)
+		}
+		delete(e.owners, handle.id)
+	}
+	e.mu.Unlock()
+	return nil
+}
+
+func ownerRecords(owner *ownerState) []*jobRecord {
+	if owner == nil {
+		return nil
+	}
+	records := make([]*jobRecord, 0, len(owner.records))
+	for _, record := range owner.records {
+		records = append(records, record)
+	}
+	return records
+}
+
+func waitRecords(records []*jobRecord) {
+	for _, record := range records {
+		if record != nil && record.done != nil {
+			<-record.done
+		}
+	}
+}
+
+func (e *Engine) enroll(parent context.Context, handle *OwnerHandle, kind jobKind, resources Resources) (context.Context, *jobRecord, error) {
+	if e == nil {
+		return nil, nil, ErrEngineClosed
+	}
+	if handle == nil || handle.engine != e || handle.closed.Load() {
+		return nil, nil, ErrOwnerClosed
+	}
+	jobCtx, cancel := context.WithCancel(parent)
+	record := &jobRecord{
+		id:        e.deps.newID(),
+		kind:      kind,
+		owner:     handle,
+		accepted:  e.deps.now().UTC(),
+		cancel:    cancel,
+		done:      make(chan struct{}),
+		resources: resourceSet{resources: resources},
+	}
+	e.mu.Lock()
+	if e.closing {
+		e.mu.Unlock()
+		cancel()
+		return nil, nil, ErrEngineClosed
+	}
+	owner, err := e.validateOwnerLocked(handle)
+	if err != nil {
+		e.mu.Unlock()
+		cancel()
+		return nil, nil, err
+	}
+	e.records[record.id] = record
+	owner.records[record.id] = record
+	e.wg.Add(1)
+	e.mu.Unlock()
+	return jobCtx, record, nil
+}
+
+func (e *Engine) start(jobCtx context.Context, record *jobRecord, run func(context.Context), fail func(string), finalize func(), emit func()) {
+	emit()
+	go func() {
+		defer e.wg.Done()
+		defer record.cancel()
+		defer func() {
+			if recovered := recover(); recovered != nil {
+				fail("job worker panicked: " + sanitizeMessage(fmt.Sprint(recovered)))
+			}
+			if err := record.resources.close(); err != nil {
+				e.warn("job resource cleanup failed: " + sanitizeMessage(err.Error()))
+			}
+			finalize()
+			emit()
+			e.complete(record)
+			close(record.done)
+		}()
+		run(jobCtx)
+	}()
+}
+
+// StartUpload validates and clones spec, then enrolls it for asynchronous work.
+// Once accepted, the job is detached from caller cancellation and runs until
+// explicit cancellation, owner removal, or engine shutdown. Resource ownership
+// transfers to the engine only when this method succeeds.
+func (e *Engine) StartUpload(ctx context.Context, owner *OwnerHandle, raw UploadSpec) (string, error) {
+	if ctx == nil {
+		return "", errors.New("context is required")
+	}
+	if err := ctx.Err(); err != nil {
+		return "", fmt.Errorf("start upload: %w", err)
+	}
+	spec, err := normalizeUploadSpec(raw)
+	if err != nil {
+		return "", err
+	}
+	jobCtx, record, err := e.enroll(context.WithoutCancel(ctx), owner, jobKindUpload, spec.Resources)
+	if err != nil {
+		return "", err
+	}
+	job := newUploadJob(record.id, spec, record.accepted, e.config.UploadProgress)
+	e.mu.Lock()
+	e.uploads[record.id] = job
+	e.mu.Unlock()
+	e.start(
+		jobCtx,
+		record,
+		func(runCtx context.Context) { e.runUpload(runCtx, job) },
+		func(message string) { e.failUpload(job, message) },
+		func() { e.finalizeUpload(job) },
+		func() { e.emitUpload(record, job) },
+	)
+	return record.id, nil
+}
+
+// StartDupe validates and clones spec, then enrolls it for asynchronous work.
+// Once accepted, the job is detached from caller cancellation and runs until
+// explicit cancellation, owner removal, or engine shutdown. Resource ownership
+// transfers to the engine only when this method succeeds.
+func (e *Engine) StartDupe(ctx context.Context, owner *OwnerHandle, raw DupeSpec) (string, error) {
+	if ctx == nil {
+		return "", errors.New("context is required")
+	}
+	if err := ctx.Err(); err != nil {
+		return "", fmt.Errorf("start dupe: %w", err)
+	}
+	spec, err := normalizeDupeSpec(raw)
+	if err != nil {
+		return "", err
+	}
+	jobCtx, record, err := e.enroll(context.WithoutCancel(ctx), owner, jobKindDupe, spec.Resources)
+	if err != nil {
+		return "", err
+	}
+	job := newDupeJob(record.id, spec, record.accepted)
+	e.mu.Lock()
+	e.dupes[record.id] = job
+	e.mu.Unlock()
+	e.start(
+		jobCtx,
+		record,
+		func(runCtx context.Context) { e.runDupe(runCtx, job) },
+		func(message string) { e.failDupe(job, message) },
+		func() { e.finalizeDupe(job) },
+		func() { e.emitDupe(record, job) },
+	)
+	return record.id, nil
+}
+
+func (e *Engine) lookupRecord(owner *OwnerHandle, jobID string, kind jobKind) *jobRecord {
+	if e == nil || owner == nil || owner.engine != e || owner.closed.Load() {
+		return nil
+	}
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	current, err := e.validateOwnerLocked(owner)
+	if err != nil {
+		return nil
+	}
+	record := current.records[strings.TrimSpace(jobID)]
+	if record == nil || record.kind != kind || record.owner != owner {
+		return nil
+	}
+	return record
+}
+
+// UploadSnapshot returns a defensive snapshot when jobID belongs to owner.
+func (e *Engine) UploadSnapshot(owner *OwnerHandle, jobID string) (TrackerUploadSnapshot, error) {
+	record := e.lookupRecord(owner, jobID, jobKindUpload)
+	if record == nil {
+		return TrackerUploadSnapshot{}, ErrUploadNotFound
+	}
+	e.mu.Lock()
+	job := e.uploads[record.id]
+	e.mu.Unlock()
+	if job == nil {
+		return TrackerUploadSnapshot{}, ErrUploadNotFound
+	}
+	return job.snapshot(), nil
+}
+
+// DupeSnapshot returns a defensive snapshot when jobID belongs to owner.
+func (e *Engine) DupeSnapshot(owner *OwnerHandle, jobID string) (DupeCheckSnapshot, error) {
+	record := e.lookupRecord(owner, jobID, jobKindDupe)
+	if record == nil {
+		return DupeCheckSnapshot{}, ErrDupeNotFound
+	}
+	e.mu.Lock()
+	job := e.dupes[record.id]
+	e.mu.Unlock()
+	if job == nil {
+		return DupeCheckSnapshot{}, ErrDupeNotFound
+	}
+	return job.snapshot(), nil
+}
+
+// List returns immutable retained Jobs for one owner in acceptance order.
+func (e *Engine) List(owner *OwnerHandle) ([]OwnerJobSnapshot, error) {
+	if e == nil {
+		return nil, ErrEngineClosed
+	}
+	e.mu.Lock()
+	state, err := e.validateOwnerLocked(owner)
+	if err != nil {
+		e.mu.Unlock()
+		return nil, err
+	}
+	records := append([]*jobRecord(nil), ownerRecords(state)...)
+	e.mu.Unlock()
+
+	sort.Slice(records, func(left, right int) bool {
+		if records[left].accepted.Equal(records[right].accepted) {
+			return records[left].id < records[right].id
+		}
+		return records[left].accepted.Before(records[right].accepted)
+	})
+	result := make([]OwnerJobSnapshot, 0, len(records))
+	for _, record := range records {
+		switch record.kind {
+		case jobKindDupe:
+			snapshot, snapshotErr := e.DupeSnapshot(owner, record.id)
+			if snapshotErr != nil {
+				continue
+			}
+			result = append(result, OwnerJobSnapshot{
+				Kind:          KindDuplicateCheck,
+				JobID:         snapshot.JobID,
+				CorrelationID: snapshot.CorrelationID,
+				Release:       snapshot.Release,
+				Status:        snapshot.Status,
+				StartedAt:     snapshot.StartedAt,
+				FinishedAt:    snapshot.FinishedAt,
+				Dupe:          &snapshot,
+			})
+		case jobKindUpload:
+			snapshot, snapshotErr := e.UploadSnapshot(owner, record.id)
+			if snapshotErr != nil {
+				continue
+			}
+			result = append(result, OwnerJobSnapshot{
+				Kind:          KindTrackerUpload,
+				JobID:         snapshot.JobID,
+				CorrelationID: snapshot.CorrelationID,
+				RetryOf:       snapshot.RetryOf,
+				Release:       snapshot.Release,
+				Status:        snapshot.Status,
+				StartedAt:     snapshot.StartedAt,
+				FinishedAt:    snapshot.FinishedAt,
+				Upload:        &snapshot,
+			})
+		}
+	}
+	return result, nil
+}
+
+// CancelUpload requests cancellation of an owner-scoped upload Job.
+func (e *Engine) CancelUpload(owner *OwnerHandle, jobID string) error {
+	record := e.lookupRecord(owner, jobID, jobKindUpload)
+	if record == nil {
+		return ErrUploadNotFound
+	}
+	record.cancel()
+	return nil
+}
+
+// CancelDupe requests cancellation of an owner-scoped duplicate-check Job.
+func (e *Engine) CancelDupe(owner *OwnerHandle, jobID string) error {
+	record := e.lookupRecord(owner, jobID, jobKindDupe)
+	if record == nil {
+		return ErrDupeNotFound
+	}
+	record.cancel()
+	return nil
+}
+
+// UploadRetry returns cloned input for retry-eligible failures without retaining resources or runners.
+func (e *Engine) UploadRetry(owner *OwnerHandle, jobID string) (UploadRetry, error) {
+	record := e.lookupRecord(owner, jobID, jobKindUpload)
+	if record == nil {
+		return UploadRetry{}, ErrUploadNotFound
+	}
+	e.mu.Lock()
+	job := e.uploads[record.id]
+	e.mu.Unlock()
+	if job == nil {
+		return UploadRetry{}, ErrUploadNotFound
+	}
+	return job.retry()
+}
+
+func (e *Engine) emitUpload(record *jobRecord, job *uploadJob) {
+	if e.sink == nil || record == nil || job == nil {
+		return
+	}
+	snapshot := job.snapshot()
+	e.safeSink(func() { e.sink.EmitUpload(record.owner.id, snapshot) })
+}
+
+func (e *Engine) emitUploadJob(job *uploadJob) {
+	if job == nil {
+		return
+	}
+	e.mu.Lock()
+	record := e.records[job.id]
+	e.mu.Unlock()
+	e.emitUpload(record, job)
+}
+
+func (e *Engine) emitDupe(record *jobRecord, job *dupeJob) {
+	if e.sink == nil || record == nil || job == nil {
+		return
+	}
+	snapshot := job.snapshot()
+	e.safeSink(func() { e.sink.EmitDupe(record.owner.id, snapshot) })
+}
+
+func (e *Engine) emitDupeJob(job *dupeJob) {
+	if job == nil {
+		return
+	}
+	e.mu.Lock()
+	record := e.records[job.id]
+	e.mu.Unlock()
+	e.emitDupe(record, job)
+}
+
+func (e *Engine) safeSink(emit func()) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			e.warn("job snapshot sink panicked: " + sanitizeMessage(fmt.Sprint(recovered)))
+		}
+	}()
+	emit()
+}
+
+func (e *Engine) warn(message string) {
+	message = sanitizeMessage(message)
+	if sink, ok := e.sink.(diagnosticSink); ok {
+		defer func() { _ = recover() }()
+		sink.WarnJob(message)
+	}
+}
+
+func (e *Engine) complete(record *jobRecord) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	current := e.records[record.id]
+	if current != record {
+		return
+	}
+	record.terminal = true
+	record.finished = e.deps.now().UTC()
+	owner := e.owners[record.owner.id]
+	if owner == nil || owner.handle != record.owner || owner.draining || e.closing {
+		return
+	}
+	owner.terminal = append(owner.terminal, record)
+	e.pruneOwnerLocked(owner)
+	if e.deps.retentionTTL > 0 {
+		var ownedTimer timer
+		ownedTimer = e.deps.newTimer(e.deps.retentionTTL, func() {
+			e.mu.Lock()
+			defer e.mu.Unlock()
+			if e.closing || e.records[record.id] != record || record.timer != ownedTimer || !record.terminal {
+				return
+			}
+			e.deleteRecordLocked(record)
+		})
+		record.timer = ownedTimer
+	}
+}
+
+func (e *Engine) pruneOwnerLocked(owner *ownerState) {
+	limit := e.deps.retentionMax
+	if owner == nil || limit <= 0 {
+		return
+	}
+	for len(owner.terminal) > limit {
+		oldest := owner.terminal[0]
+		owner.terminal = owner.terminal[1:]
+		e.deleteRecordLocked(oldest)
+	}
+}
+
+func (e *Engine) deleteRecordLocked(record *jobRecord) {
+	if record == nil || e.records[record.id] != record {
+		return
+	}
+	if record.timer != nil {
+		record.timer.Stop()
+		record.timer = nil
+	}
+	delete(e.records, record.id)
+	delete(e.dupes, record.id)
+	delete(e.uploads, record.id)
+	if owner := e.owners[record.owner.id]; owner != nil && owner.handle == record.owner {
+		delete(owner.records, record.id)
+		for idx, terminal := range owner.terminal {
+			if terminal == record {
+				owner.terminal = append(owner.terminal[:idx], owner.terminal[idx+1:]...)
+				break
+			}
+		}
+	}
+}
+
+// Close atomically rejects enrollment, cancels all work, blocks through worker
+// and resource release, and discards all owner generations and snapshots.
+func (e *Engine) Close() {
+	if e == nil {
+		return
+	}
+	e.mu.Lock()
+	if e.closed {
+		done := e.closedDone
+		e.mu.Unlock()
+		<-done
+		return
+	}
+	if e.closing {
+		done := e.closedDone
+		e.mu.Unlock()
+		<-done
+		return
+	}
+	e.closing = true
+	records := make([]*jobRecord, 0, len(e.records))
+	for _, record := range e.records {
+		if record.timer != nil {
+			record.timer.Stop()
+			record.timer = nil
+		}
+		records = append(records, record)
+	}
+	for _, owner := range e.owners {
+		owner.draining = true
+		owner.handle.closed.Store(true)
+	}
+	e.mu.Unlock()
+
+	for _, record := range records {
+		if record.cancel != nil {
+			record.cancel()
+		}
+	}
+	e.wg.Wait()
+	waitRecords(records)
+
+	e.mu.Lock()
+	e.records = make(map[string]*jobRecord)
+	e.dupes = make(map[string]*dupeJob)
+	e.uploads = make(map[string]*uploadJob)
+	e.owners = make(map[string]*ownerState)
+	e.closed = true
+	close(e.closedDone)
+	e.mu.Unlock()
+}
+
+func randomID() string {
+	value, err := rand.Int(rand.Reader, new(big.Int).SetUint64(^uint64(0)))
+	if err != nil {
+		return strconv.FormatInt(time.Now().UnixNano(), 10)
+	}
+	return fmt.Sprintf("%d-%x", time.Now().UnixNano(), value.Uint64())
+}
diff --git a/internal/webserver/jobs/engine_test.go b/internal/webserver/jobs/engine_test.go
new file mode 100644
index 00000000..1cf6405a
--- /dev/null
+++ b/internal/webserver/jobs/engine_test.go
@@ -0,0 +1,455 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type recordingSink struct {
+	mu       sync.Mutex
+	uploads  []TrackerUploadSnapshot
+	dupes    []DupeCheckSnapshot
+	warnings []string
+}
+
+func (s *recordingSink) WarnJob(message string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.warnings = append(s.warnings, message)
+}
+
+func (s *recordingSink) EmitUpload(_ string, snapshot TrackerUploadSnapshot) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.uploads = append(s.uploads, snapshot)
+}
+
+func (s *recordingSink) EmitDupe(_ string, snapshot DupeCheckSnapshot) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.dupes = append(s.dupes, snapshot)
+}
+
+func mustRegisterOwner(t *testing.T, engine *Engine, ownerID string) *OwnerHandle {
+	t.Helper()
+	owner, err := engine.RegisterOwner(ownerID)
+	if err != nil {
+		t.Fatalf("RegisterOwner(%q): %v", ownerID, err)
+	}
+	return owner
+}
+
+type uploadRunnerFunc func(context.Context, api.UploadExecutionPlan) (api.Result, error)
+
+func (f uploadRunnerFunc) RunUpload(ctx context.Context, request api.UploadExecutionPlan) (api.Result, error) {
+	return f(ctx, request)
+}
+
+type dupeRunnerFunc func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error)
+
+func (f dupeRunnerFunc) CheckDupes(ctx context.Context, request api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	return f(ctx, request)
+}
+
+type closeRecorder struct {
+	count      atomic.Int32
+	err        error
+	panicValue any
+	started    chan struct{}
+	release    <-chan struct{}
+}
+
+func (c *closeRecorder) Close() error {
+	c.count.Add(1)
+	if c.started != nil {
+		close(c.started)
+	}
+	if c.release != nil {
+		<-c.release
+	}
+	if c.panicValue != nil {
+		panic(c.panicValue)
+	}
+	return c.err
+}
+
+func TestTerminalStateWaitsForResourceRelease(t *testing.T) {
+	t.Parallel()
+	cleanupStarted := make(chan struct{})
+	cleanupRelease := make(chan struct{})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	id, err := engine.StartUpload(context.Background(), owner, UploadSpec{
+		CorrelationID: "cleanup-correlation",
+		Snapshot: testUploadSnapshot("Example Release 2026"),
+		Runner: uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+			return api.Result{UploadedCount: 1}, nil
+		}),
+		Resources: Resources{Core: &closeRecorder{started: cleanupStarted, release: cleanupRelease}},
+	})
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	<-cleanupStarted
+	snapshot, err := engine.UploadSnapshot(owner, id)
+	if err != nil {
+		t.Fatalf("UploadSnapshot: %v", err)
+	}
+	if isJobTerminal(snapshot.Status) || snapshot.FinishedAt != "" {
+		t.Fatalf("terminal state published before cleanup: %#v", snapshot)
+	}
+	close(cleanupRelease)
+	if snapshot = waitUpload(t, engine, id); snapshot.Status != StatusCompleted {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+}
+
+func uploadSpec(runner UploadRunner, trackers ...string) UploadSpec {
+	sourcePath := `C:\Example\Example.Release.2026.1080p-GRP`
+	snapshot := testUploadSnapshot(sourcePath)
+	snapshot.Input.Trackers = append([]string(nil), trackers...)
+	return UploadSpec{
+CorrelationID: "upload-correlation",
+ Snapshot: snapshot,
+ Runner: runner,
+}
+}
+
+func dupeSpec(runner DupeRunner, trackers ...string) DupeSpec {
+	sourcePath := `C:\Example\Example.Release.2026.1080p-GRP`
+	snapshot := testDupeSnapshot(sourcePath)
+	snapshot.Input.Trackers = append([]string(nil), trackers...)
+	return DupeSpec{
+CorrelationID: "dupe-correlation",
+ Snapshot: snapshot,
+ Runner: runner,
+}
+}
+
+func testUploadSnapshot(sourcePath string) UploadExecutionSnapshot {
+	return UploadExecutionSnapshot{
+		PreparedGeneration: 1,
+		RuntimeGeneration:  1,
+		Input: api.UploadReviewInput{
+			Release:  api.ReleaseRef{SourcePath: sourcePath, Generation: 1},
+			Trackers: []string{"A"},
+		},
+		ReviewToken: "test-review-token",
+	}
+}
+
+func testDupeSnapshot(sourcePath string) DuplicateExecutionSnapshot {
+	return DuplicateExecutionSnapshot{
+		PreparedGeneration: 1,
+		RuntimeGeneration:  1,
+		Input: api.DuplicateCheckInput{
+			Release:  api.ReleaseRef{SourcePath: sourcePath, Generation: 1},
+			Trackers: []string{"A"},
+		},
+	}
+}
+
+func waitUpload(t *testing.T, engine *Engine, id string) TrackerUploadSnapshot {
+	t.Helper()
+	deadline := time.Now().Add(3 * time.Second)
+	for time.Now().Before(deadline) {
+		snapshot, err := engine.UploadSnapshot(mustRegisterOwner(t, engine, "owner"), id)
+		if err == nil && isJobTerminal(snapshot.Status) {
+			return snapshot
+		}
+		time.Sleep(time.Millisecond)
+	}
+	t.Fatal("upload did not become terminal")
+	return TrackerUploadSnapshot{}
+}
+
+func waitDupe(t *testing.T, engine *Engine, id string) DupeCheckSnapshot {
+	t.Helper()
+	deadline := time.Now().Add(3 * time.Second)
+	for time.Now().Before(deadline) {
+		snapshot, err := engine.DupeSnapshot(mustRegisterOwner(t, engine, "owner"), id)
+		if err == nil && isJobTerminal(snapshot.Status) {
+			return snapshot
+		}
+		time.Sleep(time.Millisecond)
+	}
+	t.Fatal("dupe check did not become terminal")
+	return DupeCheckSnapshot{}
+}
+
+func TestEngineValidatesInputsAndIsolatesOwners(t *testing.T) {
+	t.Parallel()
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	runner := uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) { return api.Result{}, nil })
+
+	if _, err := engine.RegisterOwner(""); err == nil {
+		t.Fatal("expected owner validation error")
+	}
+	owner := mustRegisterOwner(t, engine, "owner")
+	if _, err := engine.StartUpload(context.Background(), owner, uploadSpec(runner)); err == nil {
+		t.Fatal("expected tracker validation error")
+	}
+	id, err := engine.StartUpload(context.Background(), owner, uploadSpec(runner, " A ", "a", "B"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	other := mustRegisterOwner(t, engine, "other")
+	if _, err := engine.UploadSnapshot(other, id); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("wrong-owner snapshot error = %v", err)
+	}
+	if err := engine.CancelUpload(other, id); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("wrong-owner cancel error = %v", err)
+	}
+	if _, err := engine.UploadRetry(other, id); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("wrong-owner retry error = %v", err)
+	}
+	snapshot := waitUpload(t, engine, id)
+	if len(snapshot.Trackers) != 2 || snapshot.Trackers[0].Tracker != "A" || snapshot.Trackers[1].Tracker != "B" {
+		t.Fatalf("normalized trackers = %#v", snapshot.Trackers)
+	}
+}
+
+func TestEngineCloseWaitsCancelsAndRejectsStarts(t *testing.T) {
+	t.Parallel()
+	started := make(chan struct{})
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		close(started)
+		<-ctx.Done()
+		return api.Result{}, ctx.Err()
+	})
+	core, logger := &closeRecorder{}, &closeRecorder{}
+	engine := New(nil, Config{})
+	owner := mustRegisterOwner(t, engine, "owner")
+	_, err := engine.StartUpload(context.Background(), owner, UploadSpec{
+		CorrelationID: "rejected-correlation",
+		Snapshot:  testUploadSnapshot("Example Release 2026"),
+		Runner:    runner,
+		Resources: Resources{Core: core, Logger: logger},
+	})
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	<-started
+	engine.Close()
+	if _, err := engine.UploadSnapshot(owner, "discarded"); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("snapshot after close error = %v", err)
+	}
+	if core.count.Load() != 1 || logger.count.Load() != 1 {
+		t.Fatalf("close counts core=%d logger=%d", core.count.Load(), logger.count.Load())
+	}
+	if _, err := engine.RegisterOwner("new-owner"); !errors.Is(err, ErrEngineClosed) {
+		t.Fatalf("register after close error = %v", err)
+	}
+	engine.Close()
+}
+
+func TestOwnerRemovalDrainsAndStaleHandleNeverRevives(t *testing.T) {
+	t.Parallel()
+	started := make(chan struct{})
+	release := make(chan struct{})
+	core := &closeRecorder{}
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "session")
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		close(started)
+		<-ctx.Done()
+		<-release
+		return api.Result{}, ctx.Err()
+	})
+	jobID, err := engine.StartUpload(context.Background(), owner, UploadSpec{
+		CorrelationID: "owner-removal-correlation",
+		Snapshot:  testUploadSnapshot("Example Release 2026"),
+		Runner:    runner,
+		Resources: Resources{Core: core},
+	})
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	<-started
+	done := make(chan error, 1)
+	go func() { done <- engine.RemoveOwner(owner) }()
+
+	deadline := time.Now().Add(3 * time.Second)
+	for !owner.closed.Load() && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	if !owner.closed.Load() {
+		t.Fatal("owner did not enter draining state")
+	}
+	if _, err := engine.RegisterOwner("session"); !errors.Is(err, ErrOwnerDraining) {
+		t.Fatalf("register during drain error = %v", err)
+	}
+	select {
+	case err := <-done:
+		t.Fatalf("RemoveOwner returned before worker release: %v", err)
+	default:
+	}
+	close(release)
+	if err := <-done; err != nil {
+		t.Fatalf("RemoveOwner: %v", err)
+	}
+	if core.count.Load() != 1 {
+		t.Fatalf("core close count = %d", core.count.Load())
+	}
+	if _, err := engine.UploadSnapshot(owner, jobID); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("stale snapshot error = %v", err)
+	}
+	if _, err := engine.StartUpload(context.Background(), owner, uploadSpec(runner, "A")); !errors.Is(err, ErrOwnerClosed) {
+		t.Fatalf("stale start error = %v", err)
+	}
+	reused := mustRegisterOwner(t, engine, "session")
+	if reused == owner || reused.generation == owner.generation {
+		t.Fatal("same textual owner ID revived the stale generation")
+	}
+}
+
+func TestAcceptedJobSurvivesCallerCancellation(t *testing.T) {
+	t.Parallel()
+	started := make(chan struct{})
+	release := make(chan struct{})
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		close(started)
+		select {
+		case <-ctx.Done():
+			return api.Result{}, errors.New("Job context canceled by caller")
+		case <-release:
+			return api.Result{UploadedCount: 1}, nil
+		}
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	requestCtx, cancel := context.WithCancel(context.Background())
+	id, err := engine.StartUpload(requestCtx, owner, uploadSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	<-started
+	cancel()
+	close(release)
+	if snapshot := waitUpload(t, engine, id); snapshot.Status != StatusCompleted {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+}
+
+func TestCleanupFailureWarnsWithoutRewritingOutcome(t *testing.T) {
+	t.Parallel()
+	sink := &recordingSink{}
+	engine := New(sink, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	id, err := engine.StartUpload(context.Background(), owner, UploadSpec{
+		CorrelationID: "panic-correlation",
+		Snapshot: testUploadSnapshot("Example Release 2026"),
+		Runner: uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+			return api.Result{UploadedCount: 1}, nil
+		}),
+		Resources: Resources{Core: &closeRecorder{err: errors.New("token=secret-value")}},
+	})
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	if snapshot := waitUpload(t, engine, id); snapshot.Status != StatusCompleted {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+	sink.mu.Lock()
+	defer sink.mu.Unlock()
+	if len(sink.warnings) != 1 || strings.Contains(sink.warnings[0], "secret-value") {
+		t.Fatalf("warnings = %#v", sink.warnings)
+	}
+}
+
+func TestOwnerChurnLeavesNoIndexEntries(t *testing.T) {
+	t.Parallel()
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	for idx := range 100 {
+		owner := mustRegisterOwner(t, engine, fmt.Sprintf("owner-%d", idx))
+		if err := engine.RemoveOwner(owner); err != nil {
+			t.Fatalf("RemoveOwner(%d): %v", idx, err)
+		}
+	}
+	engine.mu.Lock()
+	defer engine.mu.Unlock()
+	if len(engine.owners) != 0 || len(engine.records) != 0 {
+		t.Fatalf("owner index=%d records=%d", len(engine.owners), len(engine.records))
+	}
+}
+
+func TestListIsOwnerScopedOrderedAndCarriesCorrelationRetryLinkage(t *testing.T) {
+	t.Parallel()
+	var sequence atomic.Int64
+	engine := newEngine(nil, Config{}, engineDeps{
+		now:          func() time.Time { return time.Unix(sequence.Add(1), 0) },
+		newID:        func() string { return fmt.Sprintf("job-%d", sequence.Add(1)) },
+		retentionTTL: time.Hour,
+		retentionMax: 200,
+	})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	other := mustRegisterOwner(t, engine, "owner-b")
+
+	failed := uploadSpec(uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+		return api.Result{}, trackerLocalUploadTestError{message: "failed"}
+	}), "A")
+	failed.CorrelationID = "start-correlation"
+	originalID, err := engine.StartUpload(context.Background(), owner, failed)
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	_ = waitUpload(t, engine, originalID)
+
+	retry, err := engine.UploadRetry(owner, originalID)
+	if err != nil {
+		t.Fatalf("UploadRetry: %v", err)
+	}
+	retryID, err := engine.StartUpload(context.Background(), owner, retry.Spec(
+		"retry-correlation",
+		uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+			return api.Result{UploadedCount: 1}, nil
+		}),
+		Resources{},
+	))
+	if err != nil {
+		t.Fatalf("StartUpload retry: %v", err)
+	}
+	_ = waitUpload(t, engine, retryID)
+
+	listed, err := engine.List(owner)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(listed) != 2 || listed[0].JobID != originalID || listed[1].JobID != retryID {
+		t.Fatalf("acceptance order = %#v", listed)
+	}
+	if listed[0].CorrelationID != "start-correlation" || listed[1].CorrelationID != "retry-correlation" || listed[1].RetryOf != originalID {
+		t.Fatalf("correlation/retry linkage = %#v", listed)
+	}
+	foreign, err := engine.List(other)
+	if err != nil || len(foreign) != 0 {
+		t.Fatalf("foreign owner listing = %#v, %v", foreign, err)
+	}
+
+	listed[0].Upload.Trackers[0].Tracker = "mutated"
+	listedAgain, err := engine.List(owner)
+	if err != nil {
+		t.Fatalf("List again: %v", err)
+	}
+	if listedAgain[0].Upload.Trackers[0].Tracker != "A" {
+		t.Fatal("owner listing exposed mutable retained state")
+	}
+}
diff --git a/internal/webserver/jobs/failure.go b/internal/webserver/jobs/failure.go
new file mode 100644
index 00000000..c8e388cb
--- /dev/null
+++ b/internal/webserver/jobs/failure.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import "github.com/autobrr/upbrr/pkg/api"
+
+// failureForError preserves a structured operation failure as a defensive copy
+// and otherwise creates a frontend-safe generic failure.
+func failureForError(err error, operation api.OperationKind, message string, recovery api.OperationRecovery) *api.OperationFailure {
+	if failure, ok := api.AsOperationFailure(err); ok {
+		cloned := failure
+		return &cloned
+	}
+	return genericFailure(operation, message, recovery)
+}
+
+func genericFailure(operation api.OperationKind, message string, recovery api.OperationRecovery) *api.OperationFailure {
+	return &api.OperationFailure{
+		Code:      api.OperationFailureInternal,
+		Operation: operation,
+		Message:   message,
+		Recovery:  recovery,
+	}
+}
+
+func cloneFailure(failure *api.OperationFailure) *api.OperationFailure {
+	if failure == nil {
+		return nil
+	}
+	cloned := *failure
+	return &cloned
+}
diff --git a/internal/webserver/jobs/input.go b/internal/webserver/jobs/input.go
new file mode 100644
index 00000000..32b21bea
--- /dev/null
+++ b/internal/webserver/jobs/input.go
@@ -0,0 +1,360 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// UploadRunner executes one prepared upload request for the engine.
+type UploadRunner interface {
+	// RunUpload executes one exact reviewed input and reports progress through the context callback.
+	RunUpload(context.Context, api.UploadExecutionPlan) (api.Result, error)
+}
+
+// DupeRunner executes one duplicate-check request for the engine.
+type DupeRunner interface {
+	// CheckDupes executes one exact duplicate-check input and reports progress through the context callback.
+	CheckDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error)
+}
+
+// Closer releases one per-job resource after its worker exits.
+type Closer interface {
+	// Close releases the resource and reports cleanup failure.
+	Close() error
+}
+
+// Resources names the per-job resources whose ownership transfers to the engine after a successful start.
+type Resources struct {
+	// Core is closed before Logger when job execution ends.
+	Core Closer
+	// Logger is closed after Core when job execution ends.
+	Logger Closer
+}
+
+// DuplicateExecutionSnapshot binds accepted duplicate work to one exact
+// preparation and runtime generation. It contains no live runtime pointers.
+type DuplicateExecutionSnapshot struct {
+	Seed               preparedrelease.Seed
+	PreparedGeneration api.PreparedGeneration
+	RuntimeGeneration  uint64
+	Input              api.DuplicateCheckInput
+}
+
+// UploadExecutionSnapshot binds reviewed upload work and required outcomes to
+// one exact preparation/runtime generation.
+type UploadExecutionSnapshot struct {
+	Seed               preparedrelease.Seed
+	PreparedGeneration api.PreparedGeneration
+	RuntimeGeneration  uint64
+	Input              api.UploadReviewInput
+	Outcome            api.UploadReviewOutcome
+	ReviewToken        string
+}
+
+// UploadSpec contains immutable input and execution dependencies for a tracker-upload job.
+// The engine validates and clones mutable fields before accepting the job.
+type UploadSpec struct {
+	// CorrelationID is the caller-generated opaque identity for start reconciliation.
+	CorrelationID string
+	// RetryOf links this Job to the original failed upload Job, when applicable.
+	RetryOf string
+	// Snapshot binds this accepted upload to immutable preparation/runtime state.
+	Snapshot UploadExecutionSnapshot
+	// Runner executes one operation-wide request for all selected trackers.
+	Runner UploadRunner
+	// Resources are closed exactly once after worker exit.
+	Resources Resources
+}
+
+// UploadRetry is a cloned, resource-free description of failed tracker work eligible for a fresh job.
+type UploadRetry struct {
+	// RetryOf identifies the original failed upload Job.
+	RetryOf string
+	// Snapshot preserves the exact reviewed preparation/runtime lineage. A
+	// retry is rejected by its runner if this snapshot is no longer compatible.
+	Snapshot UploadExecutionSnapshot
+}
+
+// Spec builds a fresh upload spec from retained retry input and newly-created
+// per-run resources. Runners/resources from the original job are never reused.
+func (r UploadRetry) Spec(correlationID string, runner UploadRunner, resources Resources) UploadSpec {
+	return UploadSpec{
+		CorrelationID: correlationID,
+		RetryOf:       r.RetryOf,
+		Snapshot:      cloneUploadExecutionSnapshot(r.Snapshot),
+		Runner:        runner,
+		Resources:     resources,
+	}
+}
+
+// DupeSpec contains immutable input and execution dependencies for a duplicate-check job.
+// The engine validates and clones mutable fields before accepting the job.
+type DupeSpec struct {
+	// CorrelationID is the caller-generated opaque identity for start reconciliation.
+	CorrelationID string
+	// Snapshot binds this accepted duplicate check to immutable preparation/runtime state.
+	Snapshot DuplicateExecutionSnapshot
+	// Runner executes the duplicate check.
+	Runner DupeRunner
+	// Resources are closed exactly once after worker exit.
+	Resources Resources
+}
+
+// normalizeUploadSpec validates upload input and deep-copies every mutable caller-owned field.
+func normalizeUploadSpec(spec UploadSpec) (UploadSpec, error) {
+	correlationID, err := normalizeCorrelationID(spec.CorrelationID)
+	if err != nil {
+		return UploadSpec{}, err
+	}
+	spec.CorrelationID = correlationID
+	spec.RetryOf = strings.TrimSpace(spec.RetryOf)
+	sourcePath := strings.TrimSpace(spec.Snapshot.Input.Release.SourcePath)
+	if sourcePath == "" {
+		return UploadSpec{}, errors.New("path is required")
+	}
+	if spec.Runner == nil {
+		return UploadSpec{}, errors.New("upload runner is required")
+	}
+	if err := validateExecutionLineage(
+		sourcePath,
+		spec.Snapshot.PreparedGeneration,
+		spec.Snapshot.RuntimeGeneration,
+		spec.Snapshot.Input.Release,
+	); err != nil {
+		return UploadSpec{}, fmt.Errorf("upload snapshot: %w", err)
+	}
+	if strings.TrimSpace(spec.Snapshot.ReviewToken) == "" {
+		return UploadSpec{}, errors.New("upload snapshot: review token is required")
+	}
+	spec.Snapshot = cloneUploadExecutionSnapshot(spec.Snapshot)
+	spec.Snapshot.Input.Release.SourcePath = sourcePath
+	spec.Snapshot.Input.Trackers = normalizeTrackers(spec.Snapshot.Input.Trackers, false)
+	if len(spec.Snapshot.Input.Trackers) == 0 {
+		return UploadSpec{}, errors.New("at least one tracker must be selected")
+	}
+	spec.Snapshot.Input.IgnoreDupesFor = normalizeTrackers(spec.Snapshot.Input.IgnoreDupesFor, false)
+	spec.Snapshot.Input.RuleAuthorizations = normalizeRuleAuthorizations(spec.Snapshot.Input.RuleAuthorizations)
+	return spec, nil
+}
+
+// normalizeDupeSpec validates duplicate-check input and deep-copies mutable caller-owned fields.
+func normalizeDupeSpec(spec DupeSpec) (DupeSpec, error) {
+	correlationID, err := normalizeCorrelationID(spec.CorrelationID)
+	if err != nil {
+		return DupeSpec{}, err
+	}
+	spec.CorrelationID = correlationID
+	sourcePath := strings.TrimSpace(spec.Snapshot.Input.Release.SourcePath)
+	if sourcePath == "" {
+		return DupeSpec{}, errors.New("path is required")
+	}
+	if spec.Runner == nil {
+		return DupeSpec{}, errors.New("dupe runner is required")
+	}
+	if err := validateExecutionLineage(
+		sourcePath,
+		spec.Snapshot.PreparedGeneration,
+		spec.Snapshot.RuntimeGeneration,
+		spec.Snapshot.Input.Release,
+	); err != nil {
+		return DupeSpec{}, fmt.Errorf("dupe snapshot: %w", err)
+	}
+	spec.Snapshot = cloneDuplicateExecutionSnapshot(spec.Snapshot)
+	spec.Snapshot.Input.Release.SourcePath = sourcePath
+	spec.Snapshot.Input.Trackers = normalizeTrackers(spec.Snapshot.Input.Trackers, true)
+	if len(spec.Snapshot.Input.Trackers) == 0 {
+		return DupeSpec{}, errors.New("at least one tracker must be selected")
+	}
+	spec.Snapshot.Input.IgnoreFor = normalizeTrackers(spec.Snapshot.Input.IgnoreFor, true)
+	return spec, nil
+}
+
+func validateExecutionLineage(
+	sourcePath string,
+	preparedGeneration api.PreparedGeneration,
+	runtimeGeneration uint64,
+	release api.ReleaseRef,
+) error {
+	if preparedGeneration == 0 || runtimeGeneration == 0 || release.Generation == 0 {
+		return errors.New("prepared and runtime generations are required")
+	}
+	if preparedGeneration != release.Generation {
+		return errors.New("prepared generation differs from operation release")
+	}
+	if !strings.EqualFold(filepath.Clean(strings.TrimSpace(sourcePath)), filepath.Clean(strings.TrimSpace(release.SourcePath))) {
+		return errors.New("operation release source differs from job source")
+	}
+	return nil
+}
+
+func cloneDuplicateExecutionSnapshot(value DuplicateExecutionSnapshot) DuplicateExecutionSnapshot {
+	value.Input.Trackers = append([]string(nil), value.Input.Trackers...)
+	value.Input.IgnoreFor = append([]string(nil), value.Input.IgnoreFor...)
+	value.Input.Authorizations = append([]string(nil), value.Input.Authorizations...)
+	return value
+}
+
+func cloneUploadExecutionSnapshot(value UploadExecutionSnapshot) UploadExecutionSnapshot {
+	value.Input.Trackers = append([]string(nil), value.Input.Trackers...)
+	value.Input.IgnoreDupesFor = append([]string(nil), value.Input.IgnoreDupesFor...)
+	value.Input.RuleAuthorizations = cloneRuleAuthorizations(value.Input.RuleAuthorizations)
+	value.Input.QuestionnaireAnswers = cloneAnswers(value.Input.QuestionnaireAnswers)
+	value.Input.DescriptionGroups = api.CloneDescriptionBuilderGroups(value.Input.DescriptionGroups)
+	value.Input.TrackerConfigOverrides = clonePointerStruct(value.Input.TrackerConfigOverrides)
+	value.Input.TrackerSiteOverrides.TIK = clonePointerStruct(value.Input.TrackerSiteOverrides.TIK)
+	value.Input.ClientOverrides = clonePointerStruct(value.Input.ClientOverrides)
+	value.Input.ImageHostOverrides = clonePointerStruct(value.Input.ImageHostOverrides)
+	value.Input.ScreenshotOverrides = cloneScreenshotOverrides(value.Input.ScreenshotOverrides)
+	value.Input.TorrentOverrides = clonePointerStruct(value.Input.TorrentOverrides)
+	value.Outcome.ResolvedTrackers = append([]string(nil), value.Outcome.ResolvedTrackers...)
+	value.Outcome.Eligibility = cloneTrackerEligibility(value.Outcome.Eligibility)
+	value.Outcome.MatchedTrackers = append([]string(nil), value.Outcome.MatchedTrackers...)
+	value.Outcome.BlockedTrackers = cloneBlockedTrackers(value.Outcome.BlockedTrackers)
+	value.Outcome.TrackerRuleFailures = cloneRuleFailures(value.Outcome.TrackerRuleFailures)
+	value.Outcome.CrossSeedTorrents = append([]api.UploadedTorrent(nil), value.Outcome.CrossSeedTorrents...)
+	return value
+}
+
+func cloneTrackerEligibility(value api.TrackerEligibility) api.TrackerEligibility {
+	value.EligibleTrackers = append([]string(nil), value.EligibleTrackers...)
+	value.Trackers = append([]api.TrackerEligibilityState(nil), value.Trackers...)
+	for index := range value.Trackers {
+		value.Trackers[index].Reasons = append([]api.TrackerEligibilityReason(nil), value.Trackers[index].Reasons...)
+		value.Trackers[index].RuleDecisions = append([]api.RuleDecision(nil), value.Trackers[index].RuleDecisions...)
+	}
+	return value
+}
+
+func cloneRuleAuthorizations(values []api.RuleAuthorization) []api.RuleAuthorization {
+	if len(values) == 0 {
+		return nil
+	}
+	cloned := make([]api.RuleAuthorization, len(values))
+	for idx, value := range values {
+		cloned[idx] = api.RuleAuthorization{Tracker: value.Tracker, Rules: append([]string(nil), value.Rules...)}
+	}
+	return cloned
+}
+
+func normalizeRuleAuthorizations(values []api.RuleAuthorization) []api.RuleAuthorization {
+	cloned := cloneRuleAuthorizations(values)
+	for idx := range cloned {
+		cloned[idx].Tracker = strings.ToUpper(strings.TrimSpace(cloned[idx].Tracker))
+		for ruleIdx := range cloned[idx].Rules {
+			cloned[idx].Rules[ruleIdx] = strings.TrimSpace(cloned[idx].Rules[ruleIdx])
+		}
+	}
+	return cloned
+}
+
+func cloneBlockedTrackers(input map[string][]api.TrackerBlockReason) map[string][]api.TrackerBlockReason {
+	if input == nil {
+		return nil
+	}
+	result := make(map[string][]api.TrackerBlockReason, len(input))
+	for tracker, reasons := range input {
+		result[tracker] = append([]api.TrackerBlockReason(nil), reasons...)
+	}
+	return result
+}
+
+func cloneRuleFailures(input map[string][]api.RuleFailure) map[string][]api.RuleFailure {
+	if input == nil {
+		return nil
+	}
+	result := make(map[string][]api.RuleFailure, len(input))
+	for tracker, failures := range input {
+		result[tracker] = append([]api.RuleFailure(nil), failures...)
+	}
+	return result
+}
+
+func cloneScreenshotOverrides(value api.ScreenshotOverrides) api.ScreenshotOverrides {
+	value.ManualFrames = append([]int(nil), value.ManualFrames...)
+	value.ComparisonPaths = append([]string(nil), value.ComparisonPaths...)
+	value.ComparisonPrimaryIndex = cloneIntPointer(value.ComparisonPrimaryIndex)
+	value.MenuPaths = append([]string(nil), value.MenuPaths...)
+	return value
+}
+
+func cloneIntPointer(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+func normalizeCorrelationID(value string) (string, error) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "", errors.New("correlation id is required")
+	}
+	if len(value) > 128 {
+		return "", errors.New("correlation id is too long")
+	}
+	return value, nil
+}
+
+// normalizeTrackers trims, removes blanks, and deduplicates tracker names case-insensitively.
+func normalizeTrackers(input []string, upper bool) []string {
+	seen := make(map[string]struct{}, len(input))
+	result := make([]string, 0, len(input))
+	for _, raw := range input {
+		tracker := strings.TrimSpace(raw)
+		key := strings.ToUpper(tracker)
+		if tracker == "" {
+			continue
+		}
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		if upper {
+			tracker = key
+		}
+		result = append(result, tracker)
+	}
+	return result
+}
+
+// cloneAnswers deep-copies tracker questionnaire maps while preserving explicit empty inner maps.
+func cloneAnswers(input map[string]map[string]string) map[string]map[string]string {
+	if len(input) == 0 {
+		return nil
+	}
+	result := make(map[string]map[string]string, len(input))
+	for tracker, answers := range input {
+		result[tracker] = maps.Clone(answers)
+		if result[tracker] == nil {
+			result[tracker] = map[string]string{}
+		}
+	}
+	return result
+}
+
+// clonePointerStruct deep-copies scalar pointer fields in API override value
+// structs. Those structs intentionally contain no slices, maps, or interfaces.
+func clonePointerStruct[T any](input T) T {
+	value := reflect.ValueOf(&input).Elem()
+	for _, field := range value.Fields() {
+		if field.Kind() != reflect.Pointer || field.IsNil() {
+			continue
+		}
+		pointer := reflect.New(field.Elem().Type())
+		pointer.Elem().Set(field.Elem())
+		field.Set(pointer)
+	}
+	return input
+}
diff --git a/internal/webserver/jobs/resources.go b/internal/webserver/jobs/resources.go
new file mode 100644
index 00000000..df69b6ee
--- /dev/null
+++ b/internal/webserver/jobs/resources.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/autobrr/upbrr/internal/logging"
+)
+
+// resourceSet closes named per-job resources exactly once and retains the combined result.
+type resourceSet struct {
+	once      sync.Once
+	resources Resources
+	err       error
+}
+
+func (r *resourceSet) close() error {
+	if r == nil {
+		return nil
+	}
+	r.once.Do(func() {
+		if r.resources.Core != nil {
+			r.err = errors.Join(r.err, closeResource("core", r.resources.Core))
+		}
+		if r.resources.Logger != nil {
+			r.err = errors.Join(r.err, closeResource("logger", r.resources.Logger))
+		}
+		r.resources = Resources{}
+	})
+	return r.err
+}
+
+// closeResource converts close errors and panics into sanitized job diagnostics.
+func closeResource(name string, resource Closer) (err error) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			err = fmt.Errorf("%s close panicked: %s", name, sanitizeMessage(fmt.Sprint(recovered)))
+		}
+	}()
+	if err := resource.Close(); err != nil {
+		return fmt.Errorf("%s close failed: %s", name, sanitizeMessage(err.Error()))
+	}
+	return nil
+}
+
+// sanitize removes secret and local-path detail before text enters a frontend-visible snapshot.
+func sanitizeMessage(message string) string {
+	message = logging.SanitizeMessage(message)
+	if message == "" {
+		return "operation failed"
+	}
+	return message
+}
diff --git a/internal/webserver/jobs/retention_test.go b/internal/webserver/jobs/retention_test.go
new file mode 100644
index 00000000..6f663915
--- /dev/null
+++ b/internal/webserver/jobs/retention_test.go
@@ -0,0 +1,158 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type retentionTimer struct {
+	stopped  atomic.Bool
+	callback func()
+}
+
+func (owned *retentionTimer) Stop() bool { return !owned.stopped.Swap(true) }
+
+func (owned *retentionTimer) fire() {
+	if !owned.stopped.Load() && owned.callback != nil {
+		owned.callback()
+	}
+}
+
+func TestRetentionPrunesOldestTerminalJobsAcrossKindsPerOwner(t *testing.T) {
+	t.Parallel()
+	var sequence atomic.Int64
+	engine := newEngine(nil, Config{}, engineDeps{
+		now:          func() time.Time { return time.Unix(sequence.Add(1), 0) },
+		newID:        func() string { return fmt.Sprintf("job-%d", sequence.Add(1)) },
+		retentionTTL: -1,
+		retentionMax: 2,
+	})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	uploadRunner := uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) { return api.Result{}, nil })
+	dupeRunner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{}, nil
+	})
+
+	first, err := engine.StartUpload(context.Background(), owner, uploadSpec(uploadRunner, "A"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	_ = waitUpload(t, engine, first)
+	second, err := engine.StartDupe(context.Background(), owner, dupeSpec(dupeRunner, "A"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	_ = waitDupe(t, engine, second)
+	third, err := engine.StartUpload(context.Background(), owner, uploadSpec(uploadRunner, "B"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	_ = waitUpload(t, engine, third)
+
+	if _, err := engine.UploadSnapshot(owner, first); !errors.Is(err, ErrUploadNotFound) {
+		t.Fatalf("oldest mixed-kind lookup error = %v", err)
+	}
+	if _, err := engine.DupeSnapshot(owner, second); err != nil {
+		t.Fatalf("retained dupe %s: %v", second, err)
+	}
+	if _, err := engine.UploadSnapshot(owner, third); err != nil {
+		t.Fatalf("retained upload %s: %v", third, err)
+	}
+
+	other := mustRegisterOwner(t, engine, "other")
+	otherID, err := engine.StartUpload(context.Background(), other, uploadSpec(uploadRunner, "C"))
+	if err != nil {
+		t.Fatalf("StartUpload other: %v", err)
+	}
+	deadline := time.Now().Add(3 * time.Second)
+	for time.Now().Before(deadline) {
+		snapshot, snapshotErr := engine.UploadSnapshot(other, otherID)
+		if snapshotErr == nil && isJobTerminal(snapshot.Status) {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	if _, err := engine.UploadSnapshot(other, otherID); err != nil {
+		t.Fatalf("other owner retention affected: %v", err)
+	}
+}
+
+func TestRetentionTTLDeletesTerminalJob(t *testing.T) {
+	t.Parallel()
+	var timerMu sync.Mutex
+	var created *retentionTimer
+	engine := newEngine(nil, Config{}, engineDeps{
+		retentionTTL: time.Hour,
+		retentionMax: 200,
+		newTimer: func(_ time.Duration, callback func()) timer {
+			timer := &retentionTimer{callback: callback}
+			timerMu.Lock()
+			created = timer
+			timerMu.Unlock()
+			return timer
+		},
+	})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	runner := dupeRunnerFunc(func(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+		return api.DupeCheckSummary{}, nil
+	})
+	id, err := engine.StartDupe(context.Background(), owner, dupeSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartDupe: %v", err)
+	}
+	_ = waitDupe(t, engine, id)
+	timerMu.Lock()
+	owned := created
+	timerMu.Unlock()
+	if owned == nil {
+		t.Fatal("retention timer was not created")
+	}
+	owned.fire()
+	if _, err := engine.DupeSnapshot(owner, id); !errors.Is(err, ErrDupeNotFound) {
+		t.Fatalf("TTL lookup error = %v", err)
+	}
+}
+
+func TestCapPruningStopsEvictedTTLTimer(t *testing.T) {
+	t.Parallel()
+	var mu sync.Mutex
+	created := make([]*retentionTimer, 0, 2)
+	engine := newEngine(nil, Config{}, engineDeps{
+		retentionTTL: time.Hour,
+		retentionMax: 1,
+		newTimer: func(_ time.Duration, callback func()) timer {
+			owned := &retentionTimer{callback: callback}
+			mu.Lock()
+			created = append(created, owned)
+			mu.Unlock()
+			return owned
+		},
+	})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	runner := uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) { return api.Result{}, nil })
+	for range 2 {
+		id, err := engine.StartUpload(context.Background(), owner, uploadSpec(runner, "A"))
+		if err != nil {
+			t.Fatalf("StartUpload: %v", err)
+		}
+		_ = waitUpload(t, engine, id)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(created) != 2 || !created[0].stopped.Load() || created[1].stopped.Load() {
+		t.Fatalf("timer state created=%d firstStopped=%v secondStopped=%v", len(created), created[0].stopped.Load(), created[1].stopped.Load())
+	}
+}
diff --git a/internal/webserver/jobs/types.go b/internal/webserver/jobs/types.go
new file mode 100644
index 00000000..f91439e6
--- /dev/null
+++ b/internal/webserver/jobs/types.go
@@ -0,0 +1,170 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package jobs owns the WebUI background job lifecycle.
+package jobs
+
+import "github.com/autobrr/upbrr/pkg/api"
+
+const (
+	// KindDuplicateCheck identifies retained duplicate-check Jobs.
+	KindDuplicateCheck = "duplicate_check"
+	// KindTrackerUpload identifies retained tracker-upload Jobs.
+	KindTrackerUpload = "tracker_upload"
+)
+
+const (
+	// StatusQueued indicates that a job or tracker is accepted but has not started.
+	StatusQueued = "queued"
+	// StatusRunning indicates that work is in progress.
+	StatusRunning = "running"
+	// StatusCompleted indicates that all requested work succeeded.
+	StatusCompleted = "completed"
+	// StatusCompletedWithErrors indicates that work finished with at least one tracker failure.
+	StatusCompletedWithErrors = "completed_with_errors"
+	// StatusFailed indicates that the job engine or runner could not complete the job.
+	StatusFailed = "failed"
+	// StatusCanceled indicates that cancellation stopped the job or tracker.
+	StatusCanceled = "canceled"
+)
+
+// DupeCheckTrackerState is the frontend-visible state for one tracker in a duplicate-check job.
+type DupeCheckTrackerState struct {
+	// Tracker is the normalized uppercase tracker name.
+	Tracker string `json:"tracker"`
+	// Status is the tracker lifecycle state.
+	Status string `json:"status"`
+	// Message is sanitized progress or outcome detail suitable for WebUI event delivery.
+	Message string `json:"message"`
+	// Result is the latest duplicate-check result for the tracker.
+	Result api.DupeCheckResult `json:"result"`
+	// StartedAt is an RFC3339 timestamp, or empty when work has not started.
+	StartedAt string `json:"startedAt"`
+	// FinishedAt is an RFC3339 timestamp, or empty while work is active.
+	FinishedAt string `json:"finishedAt"`
+}
+
+// DupeCheckSnapshot is an immutable frontend payload describing one duplicate-check job.
+type DupeCheckSnapshot struct {
+	// JobID identifies the job within its owner scope.
+	JobID string `json:"jobID"`
+	// CorrelationID is the caller-generated opaque start identity.
+	CorrelationID string `json:"correlationID"`
+	// Release identifies the exact prepared generation accepted for this Job.
+	Release api.ReleaseRef `json:"release"`
+	// RuntimeGeneration identifies the exact config/resource generation accepted for this job.
+	RuntimeGeneration uint64 `json:"runtimeGeneration"`
+	// RequestedTrackers retains the exact accepted selection for server-side
+	// prerequisite validation and is never serialized to the browser.
+	RequestedTrackers []string `json:"-"`
+	// Status is the job lifecycle state.
+	Status string `json:"status"`
+	// Trackers lists requested trackers first, followed by any dynamically discovered trackers.
+	Trackers []DupeCheckTrackerState `json:"trackers"`
+	// CompletedCount counts trackers that reached a terminal state.
+	CompletedCount int `json:"completedCount"`
+	// TotalCount is the greatest known tracker total, including dynamically discovered trackers.
+	TotalCount int `json:"totalCount"`
+	// Summary contains the accumulated duplicate-check results.
+	Summary api.DupeCheckSummary `json:"summary"`
+	// Failure is the stable safe terminal failure, when one occurred.
+	Failure *api.OperationFailure `json:"failure,omitempty"`
+	// StartedAt is the job start time in RFC3339 format.
+	StartedAt string `json:"startedAt"`
+	// FinishedAt is an RFC3339 timestamp, or empty while the job is active.
+	FinishedAt string `json:"finishedAt"`
+}
+
+// TrackerUploadTrackerState is the frontend-visible state for one tracker upload.
+type TrackerUploadTrackerState struct {
+	// Tracker is the tracker name supplied by the caller.
+	Tracker string `json:"tracker"`
+	// Status is the tracker lifecycle state.
+	Status string `json:"status"`
+	// Task identifies the current upload task.
+	Task string `json:"task"`
+	// TaskStatus describes the current task outcome or progress state.
+	TaskStatus string `json:"taskStatus"`
+	// Message is sanitized progress detail suitable for WebUI event delivery.
+	Message string `json:"message"`
+	// CompletedPieces is the number of completed hashing or processing pieces.
+	CompletedPieces int `json:"completedPieces"`
+	// TotalPieces is the total number of hashing or processing pieces.
+	TotalPieces int `json:"totalPieces"`
+	// Percent is integer completion percentage.
+	Percent int `json:"percent"`
+	// HashRateMiB is the current hashing throughput in MiB/s.
+	HashRateMiB float64 `json:"hashRateMiB"`
+	// UploadedCount is the number of successful uploads attributed to this tracker.
+	UploadedCount int `json:"uploadedCount"`
+	// StartedAt is an RFC3339 timestamp, or empty before tracker work starts.
+	StartedAt string `json:"startedAt"`
+	// FinishedAt is an RFC3339 timestamp, or empty while tracker work is active.
+	FinishedAt string `json:"finishedAt"`
+}
+
+// TrackerUploadSnapshot is an immutable frontend payload describing one tracker-upload job.
+type TrackerUploadSnapshot struct {
+	// JobID identifies the job within its owner scope.
+	JobID string `json:"jobID"`
+	// CorrelationID is the caller-generated opaque start identity.
+	CorrelationID string `json:"correlationID"`
+	// RetryOf identifies the prior upload Job when this Job is a linked retry.
+	RetryOf string `json:"retryOf,omitempty"`
+	// Release identifies the exact prepared generation accepted for this Job.
+	Release api.ReleaseRef `json:"release"`
+	// RuntimeGeneration identifies the exact config/resource generation accepted for this job.
+	RuntimeGeneration uint64 `json:"runtimeGeneration"`
+	// Status is the job lifecycle state.
+	Status string `json:"status"`
+	// CurrentTask is the latest job-wide task label.
+	CurrentTask string `json:"currentTask"`
+	// CurrentTaskStatus is the latest job-wide task state.
+	CurrentTaskStatus string `json:"currentTaskStatus"`
+	// CurrentMessage is sanitized progress detail suitable for WebUI event delivery.
+	CurrentMessage string `json:"currentMessage"`
+	// CurrentCompletedPieces is the latest completed piece count.
+	CurrentCompletedPieces int `json:"currentCompletedPieces"`
+	// CurrentTotalPieces is the latest total piece count.
+	CurrentTotalPieces int `json:"currentTotalPieces"`
+	// CurrentPercent is the latest integer completion percentage.
+	CurrentPercent int `json:"currentPercent"`
+	// CurrentHashRateMiB is the latest hashing throughput in MiB/s.
+	CurrentHashRateMiB float64 `json:"currentHashRateMiB"`
+	// Trackers contains per-tracker states in request order.
+	Trackers []TrackerUploadTrackerState `json:"trackers"`
+	// FailedTrackers contains the tracker names eligible for retry.
+	FailedTrackers []string `json:"failedTrackers"`
+	// UploadedCount is the sum of positive per-tracker upload counts.
+	UploadedCount int `json:"uploadedCount"`
+	// Failure is the stable safe terminal failure, when one occurred.
+	Failure *api.OperationFailure `json:"failure,omitempty"`
+	// StartedAt is the job start time in RFC3339 format.
+	StartedAt string `json:"startedAt"`
+	// FinishedAt is an RFC3339 timestamp, or empty while the job is active.
+	FinishedAt string `json:"finishedAt"`
+}
+
+// OwnerJobSnapshot is the discriminated owner-listing representation of one retained Job.
+type OwnerJobSnapshot struct {
+	// Kind selects which kind-specific snapshot is present.
+	Kind string `json:"kind"`
+	// JobID identifies the retained job within its owner scope.
+	JobID string `json:"jobID"`
+	// CorrelationID reconciles an accepted job with its browser start command.
+	CorrelationID string `json:"correlationID"`
+	// RetryOf identifies the prior upload job when this is a linked retry.
+	RetryOf string `json:"retryOf,omitempty"`
+	// Release identifies the exact prepared generation accepted for the job.
+	Release api.ReleaseRef `json:"release"`
+	// Status is the job lifecycle state.
+	Status string `json:"status"`
+	// StartedAt is the acceptance time in RFC3339 format.
+	StartedAt string `json:"startedAt"`
+	// FinishedAt is an RFC3339 timestamp, or empty while the job is active.
+	FinishedAt string `json:"finishedAt"`
+	// Dupe is present only when Kind is KindDuplicateCheck.
+	Dupe *DupeCheckSnapshot `json:"dupe,omitempty"`
+	// Upload is present only when Kind is KindTrackerUpload.
+	Upload *TrackerUploadSnapshot `json:"upload,omitempty"`
+}
diff --git a/internal/webserver/jobs/upload.go b/internal/webserver/jobs/upload.go
new file mode 100644
index 00000000..d193fe54
--- /dev/null
+++ b/internal/webserver/jobs/upload.go
@@ -0,0 +1,350 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// uploadJob contains mutable state for one owner-scoped multi-tracker upload.
+type uploadJob struct {
+	mu                                                     sync.Mutex
+	id, correlationID, retryOf                             string
+	release                                                api.ReleaseRef
+	spec                                                   UploadSpec
+	trackers                                               []string
+	states                                                 map[string]TrackerUploadTrackerState
+	failedTrackers                                         []string
+	uploadedCount                                          int
+	status, currentTask, currentTaskStatus, currentMessage string
+	failure, outcomeFailure                                *api.OperationFailure
+	outcomeStatus                                          string
+	currentCompleted, currentTotal, currentPercent         int
+	currentHashRateMiB                                     float64
+	startedAt, finishedAt, outcomeAt, lastSnapshotEmit     time.Time
+	progress                                               UploadProgressPolicy
+}
+
+func newUploadJob(id string, spec UploadSpec, now time.Time, progress UploadProgressPolicy) *uploadJob {
+	trackers := spec.Snapshot.Input.Trackers
+	states := make(map[string]TrackerUploadTrackerState, len(trackers))
+	for _, tracker := range trackers {
+		states[tracker] = TrackerUploadTrackerState{
+			Tracker: tracker,
+			Status:  StatusQueued,
+			Message: StatusQueued,
+		}
+	}
+	return &uploadJob{
+		id:            id,
+		correlationID: spec.CorrelationID,
+		retryOf:       spec.RetryOf,
+		release:       spec.Snapshot.Input.Release,
+		spec:          spec,
+		trackers:      append([]string(nil), trackers...),
+		states:        states,
+		status:        StatusQueued,
+		startedAt:     now,
+		progress:      progress,
+	}
+}
+
+// runUpload executes one operation-wide Core call and derives Job state from typed per-tracker progress.
+func (e *Engine) runUpload(ctx context.Context, job *uploadJob) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			e.failUpload(job, "upload worker panicked: "+sanitizeMessage(fmt.Sprint(recovered)))
+		}
+	}()
+	job.mu.Lock()
+	job.status = StatusRunning
+	job.mu.Unlock()
+	e.emitUploadJob(job)
+	progressCtx := api.WithUploadProgressReporter(ctx, func(update api.UploadProgressUpdate) { e.applyUploadProgress(job, update) })
+	result, runErr := job.spec.Runner.RunUpload(progressCtx, job.plan())
+	job.mu.Lock()
+	job.uploadedCount = max(0, result.UploadedCount)
+	job.outcomeAt = e.deps.now().UTC()
+	terminalStatus := StatusCompleted
+	var terminalFailure *api.OperationFailure
+	switch {
+	case ctx.Err() != nil:
+		terminalStatus = StatusCanceled
+		job.cancelActiveLocked()
+	case runErr != nil && api.IsTrackerLocalUploadError(runErr):
+		terminalStatus = StatusCompletedWithErrors
+		terminalFailure = failureForError(
+			runErr,
+			api.OperationKindUploadExecute,
+			"One or more tracker uploads failed.",
+			api.OperationRecoveryRetry,
+		)
+		job.failNamedTrackersLocked(api.TrackerLocalUploadFailureNames(runErr), terminalFailure.Message)
+		job.completeActiveTrackersLocked()
+	case runErr != nil:
+		terminalStatus = StatusFailed
+		terminalFailure = failureForError(
+			runErr,
+			api.OperationKindUploadExecute,
+			"Upload failed.",
+			api.OperationRecoveryRetry,
+		)
+		job.failActiveTrackersLocked(terminalFailure.Message)
+	case len(job.failedTrackers) > 0:
+		terminalStatus = StatusCompletedWithErrors
+		terminalFailure = genericFailure(
+			api.OperationKindUploadExecute,
+			"One or more tracker uploads failed.",
+			api.OperationRecoveryRetry,
+		)
+	default:
+		job.completeActiveTrackersLocked()
+	}
+	job.outcomeStatus = terminalStatus
+	job.outcomeFailure = terminalFailure
+	job.mu.Unlock()
+}
+
+// failUpload converts a worker or cleanup failure into a sanitized failed snapshot without overwriting terminal tracker states.
+func (e *Engine) failUpload(job *uploadJob, message string) {
+	e.warn("tracker-upload Job failed: " + sanitizeMessage(message))
+	now := e.deps.now().UTC()
+	job.mu.Lock()
+	if job.outcomeAt.IsZero() {
+		job.outcomeAt = now
+	}
+	job.outcomeStatus = StatusFailed
+	job.outcomeFailure = genericFailure(
+		api.OperationKindUploadExecute,
+		"Upload failed.",
+		api.OperationRecoveryRetry,
+	)
+	for _, tracker := range job.trackers {
+		state := job.states[tracker]
+		if state.Status == StatusQueued || state.Status == StatusRunning {
+			state.Status = StatusFailed
+			state.Message = job.outcomeFailure.Message
+			state.FinishedAt = formatTime(job.outcomeAt)
+			job.states[tracker] = state
+		}
+	}
+	job.mu.Unlock()
+}
+
+// finalizeUpload publishes the staged outcome only after per-Job resources close.
+func (e *Engine) finalizeUpload(job *uploadJob) {
+	job.mu.Lock()
+	if job.outcomeStatus == "" {
+		job.outcomeStatus = StatusFailed
+		job.outcomeFailure = genericFailure(
+			api.OperationKindUploadExecute,
+			"Upload failed.",
+			api.OperationRecoveryRetry,
+		)
+	}
+	job.status = job.outcomeStatus
+	job.failure = cloneFailure(job.outcomeFailure)
+	job.finishedAt = e.deps.now().UTC()
+	job.mu.Unlock()
+}
+
+// applyUploadProgress updates job and tracker state for every event and applies only emission throttling.
+func (e *Engine) applyUploadProgress(job *uploadJob, update api.UploadProgressUpdate) {
+	tracker := strings.TrimSpace(update.Tracker)
+	job.mu.Lock()
+	if tracker == "" && len(job.trackers) == 1 {
+		tracker = job.trackers[0]
+	}
+	now := e.deps.now().UTC()
+	previousStatus, previousPercent, previousRate := job.currentTaskStatus, job.currentPercent, job.currentHashRateMiB
+	job.currentTask = strings.TrimSpace(update.Task)
+	job.currentTaskStatus = strings.TrimSpace(update.Status)
+	job.currentMessage = strings.TrimSpace(update.Message)
+	if job.currentMessage != "" {
+		job.currentMessage = sanitizeMessage(job.currentMessage)
+	}
+	job.currentCompleted = update.CompletedPieces
+	job.currentTotal = update.TotalPieces
+	job.currentPercent = update.Percent
+	job.currentHashRateMiB = update.HashRateMiB
+	shouldEmit := job.progress.MinInterval <= 0 ||
+		job.lastSnapshotEmit.IsZero() ||
+		now.Sub(job.lastSnapshotEmit) >= job.progress.MinInterval ||
+		previousPercent != job.currentPercent ||
+		previousStatus != job.currentTaskStatus ||
+		abs(previousRate-job.currentHashRateMiB) >= job.progress.HashRateDeltaMiB
+	if tracker != "" {
+		state := job.states[tracker]
+		state.Tracker = tracker
+		state.Task = job.currentTask
+		state.TaskStatus = job.currentTaskStatus
+		state.CompletedPieces = update.CompletedPieces
+		state.TotalPieces = update.TotalPieces
+		state.Percent = update.Percent
+		state.HashRateMiB = update.HashRateMiB
+		if job.currentMessage != "" {
+			state.Message = job.currentMessage
+		}
+		if state.Status == StatusQueued && strings.EqualFold(state.TaskStatus, StatusRunning) {
+			state.Status = StatusRunning
+		}
+		if state.StartedAt == "" && state.Status == StatusRunning {
+			state.StartedAt = formatTime(now)
+		}
+		terminalTask := strings.EqualFold(state.Task, "tracker_upload") || strings.EqualFold(state.Task, "tracker_preparation")
+		if terminalTask {
+			switch strings.ToLower(state.TaskStatus) {
+			case "completed":
+				if strings.EqualFold(state.Task, "tracker_upload") {
+					state.Status = "success"
+					state.UploadedCount = max(1, state.UploadedCount)
+					state.FinishedAt = formatTime(now)
+				}
+			case StatusFailed:
+				state.Status = StatusFailed
+				state.FinishedAt = formatTime(now)
+				job.addFailedTrackerLocked(tracker)
+			case StatusCanceled:
+				state.Status = StatusCanceled
+				state.FinishedAt = formatTime(now)
+			}
+		}
+		job.states[tracker] = state
+	}
+	if shouldEmit {
+		job.lastSnapshotEmit = now
+	}
+	job.mu.Unlock()
+	if shouldEmit {
+		e.emitUploadJob(job)
+	}
+}
+
+func (j *uploadJob) plan() api.UploadExecutionPlan {
+	snapshot := cloneUploadExecutionSnapshot(j.spec.Snapshot)
+	snapshot.Input.Trackers = append([]string(nil), j.trackers...)
+	return api.UploadExecutionPlan{Input: snapshot.Input, Outcome: snapshot.Outcome}
+}
+
+func (j *uploadJob) addFailedTrackerLocked(tracker string) {
+	for _, existing := range j.failedTrackers {
+		if strings.EqualFold(existing, tracker) {
+			return
+		}
+	}
+	j.failedTrackers = append(j.failedTrackers, tracker)
+}
+
+func (j *uploadJob) failActiveTrackersLocked(message string) {
+	for _, tracker := range j.trackers {
+		state := j.states[tracker]
+		if state.Status == StatusQueued || state.Status == StatusRunning {
+			state.Status = StatusFailed
+			state.Message = message
+			state.FinishedAt = formatTime(j.outcomeAt)
+			j.states[tracker] = state
+			j.addFailedTrackerLocked(tracker)
+		}
+	}
+}
+
+func (j *uploadJob) failNamedTrackersLocked(trackers []string, message string) {
+	for _, tracker := range trackers {
+		state, ok := j.states[tracker]
+		if !ok || state.Status == "success" || state.Status == StatusCanceled {
+			continue
+		}
+		state.Status = StatusFailed
+		state.Message = message
+		state.FinishedAt = formatTime(j.outcomeAt)
+		j.states[tracker] = state
+		j.addFailedTrackerLocked(tracker)
+	}
+}
+
+func (j *uploadJob) completeActiveTrackersLocked() {
+	for _, tracker := range j.trackers {
+		state := j.states[tracker]
+		if state.Status == StatusQueued || state.Status == StatusRunning {
+			state.Status = "success"
+			state.Message = "uploaded"
+			state.FinishedAt = formatTime(j.outcomeAt)
+			j.states[tracker] = state
+		}
+	}
+}
+
+// snapshot copies all mutable upload state for lock-free sink delivery.
+func (j *uploadJob) snapshot() TrackerUploadSnapshot {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	trackers := make([]TrackerUploadTrackerState, 0, len(j.trackers))
+	for _, tracker := range j.trackers {
+		trackers = append(trackers, j.states[tracker])
+	}
+	return TrackerUploadSnapshot{
+		JobID:                  j.id,
+		CorrelationID:          j.correlationID,
+		RetryOf:                j.retryOf,
+		Release:                j.release,
+		RuntimeGeneration:      j.spec.Snapshot.RuntimeGeneration,
+		Status:                 j.status,
+		CurrentTask:            j.currentTask,
+		CurrentTaskStatus:      j.currentTaskStatus,
+		CurrentMessage:         j.currentMessage,
+		CurrentCompletedPieces: j.currentCompleted,
+		CurrentTotalPieces:     j.currentTotal,
+		CurrentPercent:         j.currentPercent,
+		CurrentHashRateMiB:     j.currentHashRateMiB,
+		Trackers:               trackers,
+		FailedTrackers:         append([]string{}, j.failedTrackers...),
+		UploadedCount:          j.uploadedCount,
+		Failure:                cloneFailure(j.failure),
+		StartedAt:              formatTime(j.startedAt),
+		FinishedAt:             formatTime(j.finishedAt),
+	}
+}
+
+// retry copies immutable job input and restricts the tracker list to failed trackers.
+func (j *uploadJob) retry() (UploadRetry, error) {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	if len(j.failedTrackers) == 0 {
+		return UploadRetry{}, errors.New("no failed trackers to retry")
+	}
+	return UploadRetry{
+		RetryOf: j.id,
+		Snapshot: func() UploadExecutionSnapshot {
+			snapshot := cloneUploadExecutionSnapshot(j.spec.Snapshot)
+			snapshot.Input.Trackers = append([]string(nil), j.failedTrackers...)
+			return snapshot
+		}(),
+	}, nil
+}
+
+func (j *uploadJob) cancelActiveLocked() {
+	for _, tracker := range j.trackers {
+		state := j.states[tracker]
+		if state.Status == StatusQueued || state.Status == StatusRunning {
+			state.Status = StatusCanceled
+			state.Message = StatusCanceled
+			state.FinishedAt = formatTime(j.outcomeAt)
+			j.states[tracker] = state
+		}
+	}
+}
+
+func abs(value float64) float64 {
+	if value < 0 {
+		return -value
+	}
+	return value
+}
diff --git a/internal/webserver/jobs/upload_test.go b/internal/webserver/jobs/upload_test.go
new file mode 100644
index 00000000..baf8cb69
--- /dev/null
+++ b/internal/webserver/jobs/upload_test.go
@@ -0,0 +1,240 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jobs
+
+import (
+	"context"
+	"slices"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type trackerLocalUploadTestError struct{ message string }
+
+func (e trackerLocalUploadTestError) Error() string { return e.message }
+
+func (trackerLocalUploadTestError) TrackerLocalUploadFailures() []string { return []string{"A"} }
+
+func TestUploadPartialFailureContinuesAndBuildsClonedRetry(t *testing.T) {
+	t.Parallel()
+	var mu sync.Mutex
+	var requests []api.UploadExecutionPlan
+	runner := uploadRunnerFunc(func(_ context.Context, request api.UploadExecutionPlan) (api.Result, error) {
+		mu.Lock()
+		requests = append(requests, request)
+		mu.Unlock()
+		return api.Result{UploadedCount: 2}, trackerLocalUploadTestError{message: "token=secret-value failed"}
+	})
+	answers := map[string]map[string]string{"A": {"edition": "Example"}}
+	ignore := []string{"C"}
+	authorizations := []api.RuleAuthorization{{Tracker: "C", Rules: []string{"source_rule"}}}
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	spec := uploadSpec(runner, "A", "B")
+	spec.Snapshot.Input.QuestionnaireAnswers = answers
+	spec.Snapshot.Input.IgnoreDupesFor = ignore
+	spec.Snapshot.Input.RuleAuthorizations = authorizations
+	owner := mustRegisterOwner(t, engine, "owner")
+	id, err := engine.StartUpload(context.Background(), owner, spec)
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	answers["A"]["edition"] = "mutated"
+	ignore[0] = "mutated"
+	authorizations[0].Rules[0] = "mutated"
+	snapshot := waitUpload(t, engine, id)
+	if snapshot.Status != StatusCompletedWithErrors || snapshot.UploadedCount != 2 {
+		t.Fatalf("terminal snapshot = %#v", snapshot)
+	}
+	if snapshot.Failure == nil || strings.Contains(snapshot.Failure.Message, "secret-value") {
+		t.Fatalf("unsafe or missing snapshot failure: %#v", snapshot.Failure)
+	}
+	if snapshot.Trackers[1].UploadedCount != 0 || snapshot.Trackers[1].Status != "success" {
+		t.Fatalf("second tracker = %#v", snapshot.Trackers[1])
+	}
+	retry, err := engine.UploadRetry(owner, id)
+	if err != nil {
+		t.Fatalf("UploadRetry: %v", err)
+	}
+	if len(retry.Snapshot.Input.Trackers) != 1 || retry.Snapshot.Input.Trackers[0] != "A" || retry.Snapshot.Input.QuestionnaireAnswers["A"]["edition"] != "Example" || retry.Snapshot.Input.IgnoreDupesFor[0] != "C" || retry.Snapshot.Input.RuleAuthorizations[0].Rules[0] != "source_rule" {
+		t.Fatalf("retry = %#v", retry)
+	}
+	retry.Snapshot.Input.Trackers[0] = "mutated"
+	retry2, _ := engine.UploadRetry(owner, id)
+	if retry2.Snapshot.Input.Trackers[0] != "A" {
+		t.Fatal("retry exposes mutable retained trackers")
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(requests) != 1 ||
+		!slices.Equal(requests[0].Input.Trackers, []string{"A", "B"}) ||
+		requests[0].Input.QuestionnaireAnswers["A"]["edition"] != "Example" ||
+		requests[0].Input.IgnoreDupesFor[0] != "C" ||
+		requests[0].Input.RuleAuthorizations[0].Rules[0] != "source_rule" {
+		t.Fatalf("requests = %#v", requests)
+	}
+}
+
+func TestUploadCancellationPreservesPartialCountAndTerminalStates(t *testing.T) {
+	t.Parallel()
+	started := make(chan struct{})
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		close(started)
+		<-ctx.Done()
+		return api.Result{UploadedCount: 1}, ctx.Err()
+	})
+	engine := New(nil, Config{})
+	t.Cleanup(engine.Close)
+	owner := mustRegisterOwner(t, engine, "owner")
+	id, err := engine.StartUpload(context.Background(), owner, uploadSpec(runner, "A", "B"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	<-started
+	if err := engine.CancelUpload(owner, id); err != nil {
+		t.Fatalf("CancelUpload: %v", err)
+	}
+	snapshot := waitUpload(t, engine, id)
+	if snapshot.Status != StatusCanceled || snapshot.UploadedCount != 1 {
+		t.Fatalf("snapshot = %#v", snapshot)
+	}
+	for _, state := range snapshot.Trackers {
+		if state.Status == StatusQueued || state.Status == StatusRunning {
+			t.Fatalf("active terminal tracker = %#v", state)
+		}
+	}
+}
+
+func TestUploadProgressThrottleAndTrackerTargeting(t *testing.T) {
+	t.Parallel()
+	sink := &recordingSink{}
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		api.EmitUploadProgress(ctx, api.UploadProgressUpdate{
+			Tracker:     "A",
+			Task:        "hash",
+			Status:      "running",
+			Percent:     10,
+			HashRateMiB: 1,
+		})
+		api.EmitUploadProgress(ctx, api.UploadProgressUpdate{
+			Tracker:     "A",
+			Task:        "hash",
+			Status:      "running",
+			Percent:     10,
+			HashRateMiB: 1.1,
+		})
+		api.EmitUploadProgress(ctx, api.UploadProgressUpdate{
+			Tracker:     "A",
+			Task:        "hash",
+			Status:      "running",
+			Percent:     11,
+			HashRateMiB: 1.1,
+		})
+		return api.Result{}, nil
+	})
+	engine := New(sink, Config{UploadProgress: UploadProgressPolicy{MinInterval: 60_000_000_000, HashRateDeltaMiB: 1}})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartUpload(context.Background(), mustRegisterOwner(t, engine, "owner"), uploadSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	snapshot := waitUpload(t, engine, id)
+	if snapshot.Trackers[0].Percent != 11 || snapshot.CurrentPercent != 11 {
+		t.Fatalf("progress state = %#v", snapshot)
+	}
+	if snapshot.FailedTrackers == nil {
+		t.Fatal("successful upload snapshot exposed null failedTrackers")
+	}
+	sink.mu.Lock()
+	defer sink.mu.Unlock()
+	// queued, running, first progress, percent change, terminal.
+	if len(sink.uploads) != 5 {
+		t.Fatalf("emission count = %d", len(sink.uploads))
+	}
+}
+
+func TestUploadProgressMessageIsSanitizedBeforeSnapshotDelivery(t *testing.T) {
+	t.Parallel()
+	sink := &recordingSink{}
+	runner := uploadRunnerFunc(func(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+		api.EmitUploadProgress(ctx, api.UploadProgressUpdate{
+			Tracker: "A",
+			Task:    "hash",
+			Status:  "running",
+			Message: "  token=secret-value failed  ",
+		})
+		return api.Result{}, nil
+	})
+	engine := New(sink, Config{})
+	t.Cleanup(engine.Close)
+	id, err := engine.StartUpload(context.Background(), mustRegisterOwner(t, engine, "owner"), uploadSpec(runner, "A"))
+	if err != nil {
+		t.Fatalf("StartUpload: %v", err)
+	}
+	snapshot := waitUpload(t, engine, id)
+	if strings.Contains(snapshot.CurrentMessage, "secret-value") {
+		t.Fatalf("secret crossed current progress field: %q", snapshot.CurrentMessage)
+	}
+	sink.mu.Lock()
+	defer sink.mu.Unlock()
+	for _, emitted := range sink.uploads {
+		if strings.Contains(emitted.CurrentMessage, "secret-value") {
+			t.Fatalf("secret crossed emitted current field: %q", emitted.CurrentMessage)
+		}
+		for _, tracker := range emitted.Trackers {
+			if strings.Contains(tracker.Message, "secret-value") {
+				t.Fatalf("secret crossed emitted tracker field: %q", tracker.Message)
+			}
+		}
+	}
+}
+
+func TestUploadPanicFailsButCloseFailurePreservesOutcome(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name   string
+		runner UploadRunner
+		closer *closeRecorder
+		status string
+	}{
+		{
+			name: "worker panic",
+			runner: uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+				panic("token=secret-value")
+			}),
+			closer: &closeRecorder{},
+			status: StatusFailed,
+		},
+		{
+			name: "close panic",
+			runner: uploadRunnerFunc(func(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+				return api.Result{UploadedCount: 1}, nil
+			}),
+			closer: &closeRecorder{panicValue: "password=secret-value"},
+			status: StatusCompleted,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			engine := New(nil, Config{})
+			t.Cleanup(engine.Close)
+			spec := uploadSpec(test.runner, "A")
+			spec.Resources.Core = test.closer
+			id, err := engine.StartUpload(context.Background(), mustRegisterOwner(t, engine, "owner"), spec)
+			if err != nil {
+				t.Fatalf("StartUpload: %v", err)
+			}
+			snapshot := waitUpload(t, engine, id)
+			if snapshot.Status != test.status || (snapshot.Failure != nil && strings.Contains(snapshot.Failure.Message, "secret-value")) {
+				t.Fatalf("snapshot = %#v", snapshot)
+			}
+			if test.closer.count.Load() != 1 {
+				t.Fatalf("close count = %d", test.closer.count.Load())
+			}
+		})
+	}
+}
diff --git a/internal/webserver/jobs_test.go b/internal/webserver/jobs_test.go
index 742193f3..19008370 100644
--- a/internal/webserver/jobs_test.go
+++ b/internal/webserver/jobs_test.go
@@ -7,1093 +7,522 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
-	"reflect"
 	"strings"
-	"sync"
 	"testing"
 	"time"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/guishared"
-	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	sharedjobs "github.com/autobrr/upbrr/internal/webserver/jobs"
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
-type preparedMetaTestCore struct {
-	exportedMeta      api.PreparedMetadata
-	exportFound       bool
-	exportErr         error
-	exportStarted     chan struct{}
-	exportContinue    chan struct{}
-	exportStartedOnce sync.Once
-	expectedExportReq *api.Request
-	importedMeta      api.PreparedMetadata
-	importedReq       api.Request
-	fetchReq          api.Request
-	dupeSummary       api.DupeCheckSummary
-	dupeCalls         int
-	dvdMenuCapture    func(context.Context, api.Request) (api.DVDMenuCaptureResult, error)
-	dvdMenuCalls      int
-	closeCalls        int
-	uploads           []uploadPreparedResponse
-	uploadCalls       int
-}
-
-type uploadPreparedResponse struct {
-	result       api.Result
-	err          error
-	beforeReturn func()
+type adapterTestCore struct {
+	uploadRequest api.Request
+	uploadInput   api.UploadReviewInput
+	uploadResult  api.Result
+	uploadErr     error
+	dupeRequest   api.Request
+	dupeInput     api.DuplicateCheckInput
+	dupeSummary   api.DupeCheckSummary
+	dupeErr       error
+	exportErr     error
 }
 
-func (c *preparedMetaTestCore) RunUpload(context.Context, api.Request) (api.Result, error) {
-	return api.Result{}, nil
+type preparedMetaTestCore struct {
+	fetchReq     api.Request
+	prepareInput api.PrepareInput
+	closeCalls   int
+}
+
+func webTestUploadSnapshot(sourcePath string) sharedjobs.UploadExecutionSnapshot {
+	return sharedjobs.UploadExecutionSnapshot{
+		PreparedGeneration: 1,
+		RuntimeGeneration:  1,
+		Input: api.UploadReviewInput{
+			Release:  api.ReleaseRef{SourcePath: sourcePath, Generation: 1},
+			Trackers: []string{"EXAMPLE"},
+		},
+		ReviewToken: "test-review-token",
+	}
 }
 
-func (c *preparedMetaTestCore) RunUploadPrepared(context.Context, api.Request) (api.Result, error) {
-	if c.uploadCalls < len(c.uploads) {
-		response := c.uploads[c.uploadCalls]
-		c.uploadCalls++
-		if response.beforeReturn != nil {
-			response.beforeReturn()
-		}
-		return response.result, response.err
+func webTestDupeSnapshot(sourcePath string) sharedjobs.DuplicateExecutionSnapshot {
+	return sharedjobs.DuplicateExecutionSnapshot{
+		PreparedGeneration: 1,
+		RuntimeGeneration:  1,
+		Input: api.DuplicateCheckInput{
+			Release:  api.ReleaseRef{SourcePath: sourcePath, Generation: 1},
+			Trackers: []string{"EXAMPLE"},
+		},
 	}
-	return api.Result{}, nil
 }
 
-func (c *preparedMetaTestCore) FetchMetadataPreview(_ context.Context, req api.Request) (api.MetadataPreview, error) {
-	c.fetchReq = req
+func (c *preparedMetaTestCore) FetchMetadataPreview(_ context.Context, request api.Request) (api.MetadataPreview, error) {
+	c.fetchReq = request
 	return api.MetadataPreview{}, nil
 }
 
-func (c *preparedMetaTestCore) FetchDescriptionBuilderPreview(context.Context, api.Request) (api.DescriptionBuilderPreview, error) {
-	return api.DescriptionBuilderPreview{}, nil
-}
-
-func (c *preparedMetaTestCore) FetchPreparationPreview(context.Context, api.Request) (api.PreparationPreview, error) {
-	return api.PreparationPreview{}, nil
-}
-
-func (c *preparedMetaTestCore) FetchTrackerDryRunPreview(context.Context, api.Request) (api.TrackerDryRunPreview, error) {
-	return api.TrackerDryRunPreview{}, nil
-}
-
-func (c *preparedMetaTestCore) CheckDupes(context.Context, api.Request) (api.DupeCheckSummary, error) {
-	c.dupeCalls++
-	return c.dupeSummary, nil
-}
-
-func (c *preparedMetaTestCore) BuildUploadReview(context.Context, api.Request) (api.UploadReview, error) {
-	return api.UploadReview{}, nil
+func (c *preparedMetaTestCore) FetchAcceptedMetadataPreview(_ context.Context, ref api.ReleaseRef) (api.MetadataPreview, error) {
+	return api.MetadataPreview{SourcePath: ref.SourcePath}, nil
 }
 
-func (c *preparedMetaTestCore) FetchScreenshotPlan(context.Context, api.Request) (api.ScreenshotPlan, error) {
-	return api.ScreenshotPlan{}, nil
+func (c *preparedMetaTestCore) PrepareRelease(_ context.Context, input api.PrepareInput) (api.PrepareResult, error) {
+	c.prepareInput = input
+	return api.PrepareResult{Release: api.PreparedRelease{Generation: 1, Source: api.SourceManifest{SourcePath: input.SourcePath}}}, nil
 }
 
-func (c *preparedMetaTestCore) GenerateScreenshots(context.Context, api.Request, []api.ScreenshotSelection, api.ScreenshotPurpose) (api.ScreenshotResult, error) {
-	return api.ScreenshotResult{}, nil
+func (*preparedMetaTestCore) ExportReleaseSeed(context.Context, api.ReleaseRef) (preparedrelease.Seed, error) {
+	return preparedrelease.Seed{}, nil
 }
 
-func (c *preparedMetaTestCore) PreviewScreenshotFrame(context.Context, api.Request, float64) (api.ScreenshotPreview, error) {
-	return api.ScreenshotPreview{}, nil
-}
-
-func (c *preparedMetaTestCore) DeleteScreenshot(context.Context, api.Request, string) error {
-	return nil
+func (*preparedMetaTestCore) ImportReleaseSeed(context.Context, preparedrelease.Seed) (api.ReleaseRef, error) {
+	return api.ReleaseRef{}, nil
 }
 
-func (c *preparedMetaTestCore) DeleteTrackerImageURL(context.Context, api.Request, string) error {
-	return nil
-}
-
-func (c *preparedMetaTestCore) SaveFinalScreenshotSelections(context.Context, api.Request, []api.ScreenshotImage) error {
-	return nil
+func (*preparedMetaTestCore) SelectBlurayCandidate(context.Context, string, string) (api.MetadataPreview, error) {
+	return api.MetadataPreview{}, nil
 }
 
-func (c *preparedMetaTestCore) ImportMenuImages(context.Context, api.Request, []string) error {
+func (c *preparedMetaTestCore) Close() error {
+	c.closeCalls++
 	return nil
 }
 
-func (c *preparedMetaTestCore) CaptureDVDMenus(ctx context.Context, req api.Request) (api.DVDMenuCaptureResult, error) {
-	c.dvdMenuCalls++
-	if c.dvdMenuCapture != nil {
-		return c.dvdMenuCapture(ctx, req)
+func webTestCapabilities(svc any) CoreCapabilities {
+	return CoreCapabilities{
+		Metadata:                   webCapabilityAs[MetadataCapability](svc),
+		ReleasePreparation:         webCapabilityAs[ReleasePreparationCapability](svc),
+		Selection:                  webCapabilityAs[SelectionCapability](svc),
+		Preparation:                webCapabilityAs[PreparationCapability](svc),
+		UploadReview:               webCapabilityAs[UploadReviewCapability](svc),
+		DryRun:                     webCapabilityAs[DryRunCapability](svc),
+		DuplicateExecution:         webCapabilityAs[DuplicateExecutionCapability](svc),
+		UploadExecution:            webCapabilityAs[UploadExecutionCapability](svc),
+		Screenshots:                webCapabilityAs[ScreenshotCapability](svc),
+		HostedImages:               webCapabilityAs[HostedImageCapability](svc),
+		DVD:                        webCapabilityAs[DVDCapability](svc),
+		Description:                webCapabilityAs[DescriptionCapability](svc),
+		Playlists:                  webCapabilityAs[PlaylistCapability](svc),
+		History:                    webCapabilityAs[HistoryCapability](svc),
+		PreparedGenerationTransfer: webCapabilityAs[PreparedGenerationTransfer](svc),
+		DiagnosticProbe:            webCapabilityAs[DiagnosticProbeCapability](svc),
 	}
-	return api.DVDMenuCaptureResult{}, nil
 }
 
-func (c *preparedMetaTestCore) ListDVDMenuScreenshots(context.Context, api.Request) ([]api.ScreenshotImage, error) {
-	return nil, nil
+func webCapabilityAs[T any](svc any) T {
+	capability, _ := svc.(T)
+	return capability
 }
 
-func (c *preparedMetaTestCore) DeleteDVDMenuScreenshot(context.Context, api.Request, string) error {
-	return nil
+func (c *adapterTestCore) RunUploadPrepared(_ context.Context, request api.Request) (api.Result, error) {
+	c.uploadRequest = request
+	return c.uploadResult, c.uploadErr
 }
 
-func (c *preparedMetaTestCore) ListUploadCandidates(context.Context, api.Request) ([]api.ScreenshotImage, error) {
-	return nil, nil
+func (c *adapterTestCore) RunAcceptedUpload(_ context.Context, plan api.UploadExecutionPlan) (api.Result, error) {
+	c.uploadInput = plan.Input
+	return c.uploadResult, c.uploadErr
 }
 
-func (c *preparedMetaTestCore) ListUploadedImages(context.Context, api.Request) ([]api.UploadedImageLink, error) {
-	return nil, nil
+func (c *adapterTestCore) CheckDupes(_ context.Context, request api.Request) (api.DupeCheckSummary, error) {
+	c.dupeRequest = request
+	return c.dupeSummary, c.dupeErr
 }
 
-func (c *preparedMetaTestCore) UploadImages(context.Context, api.Request, string, []api.ScreenshotImage) (api.UploadImagesResult, error) {
-	return api.UploadImagesResult{}, nil
+func (c *adapterTestCore) CheckAcceptedDupes(_ context.Context, input api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	c.dupeInput = input
+	return c.dupeSummary, c.dupeErr
 }
 
-func (c *preparedMetaTestCore) DeleteUploadedImage(context.Context, api.Request, string, string) error {
-	return nil
+func (*adapterTestCore) FetchPreparationPreview(context.Context, api.Request) (api.PreparationPreview, error) {
+	return api.PreparationPreview{}, nil
 }
 
-func (c *preparedMetaTestCore) DiscoverPlaylists(context.Context, string) ([]api.PlaylistInfo, error) {
-	return nil, nil
+func (*adapterTestCore) RunAcceptedTrackerDryRun(context.Context, api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	return api.TrackerDryRunPreview{}, nil
 }
 
-func (c *preparedMetaTestCore) SavePlaylistSelection(context.Context, string, []string, bool) error {
-	return nil
+func (*adapterTestCore) CaptureDVDMenus(context.Context, api.Request) (api.DVDMenuCaptureResult, error) {
+	return api.DVDMenuCaptureResult{}, nil
 }
 
-func (c *preparedMetaTestCore) LoadPlaylistSelection(context.Context, string) (api.PlaylistSelection, error) {
-	return api.PlaylistSelection{}, nil
+func (*adapterTestCore) CaptureAcceptedDVDMenus(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	return api.DVDMenuCaptureResult{}, nil
 }
 
-func (c *preparedMetaTestCore) ListHistory(context.Context) ([]api.HistoryEntry, error) {
+func (*adapterTestCore) ListDVDMenuScreenshots(context.Context, api.Request) ([]api.ScreenshotImage, error) {
 	return nil, nil
 }
 
-func (c *preparedMetaTestCore) GetHistoryOverview(context.Context, string) (api.HistoryOverview, error) {
-	return api.HistoryOverview{}, nil
-}
-
-func (c *preparedMetaTestCore) DeleteHistoryRelease(context.Context, string) error {
+func (*adapterTestCore) DeleteDVDMenuScreenshot(context.Context, api.Request, string) error {
 	return nil
 }
 
-func (c *preparedMetaTestCore) DeleteAllHistoryReleases(context.Context) (int, error) {
-	return 0, nil
-}
-
-func (c *preparedMetaTestCore) RenderDescription(context.Context, string) (string, error) {
-	return "", nil
-}
-
-func (c *preparedMetaTestCore) FetchDescriptionBuilderGroupPreview(context.Context, api.Request) (api.DescriptionBuilderGroup, error) {
-	return api.DescriptionBuilderGroup{}, nil
+func (*adapterTestCore) BuildUploadReview(context.Context, api.Request) (api.UploadReview, error) {
+	return api.UploadReview{}, nil
 }
 
-func (c *preparedMetaTestCore) SaveDescriptionOverride(context.Context, api.Request, string) (api.DescriptionBuilderGroup, error) {
-	return api.DescriptionBuilderGroup{}, nil
+func (c *adapterTestCore) ReviewAcceptedUpload(context.Context, api.UploadReviewInput) (api.ReviewedUpload, error) {
+	return api.ReviewedUpload{}, c.exportErr
 }
 
-func (c *preparedMetaTestCore) Close() error {
-	c.closeCalls++
-	return nil
+func (*adapterTestCore) PrepareRelease(_ context.Context, input api.PrepareInput) (api.PrepareResult, error) {
+	return api.PrepareResult{Release: api.PreparedRelease{Generation: 1, Source: api.SourceManifest{SourcePath: input.SourcePath}}}, nil
 }
 
-func (c *preparedMetaTestCore) ExportGUICachedPreparedMeta(ctx context.Context, req api.Request) (api.PreparedMetadata, bool, error) {
-	if c.exportStarted != nil {
-		c.exportStartedOnce.Do(func() {
-			close(c.exportStarted)
-		})
-	}
-	if err := assertPreparedMetaExportRequest(req, c.expectedExportReq); err != nil {
-		return api.PreparedMetadata{}, false, err
-	}
-	if c.exportContinue != nil {
-		select {
-		case <-ctx.Done():
-			return api.PreparedMetadata{}, false, fmt.Errorf("export canceled: %w", ctx.Err())
-		case <-c.exportContinue:
-		}
-	}
-	if err := ctx.Err(); err != nil {
-		return api.PreparedMetadata{}, false, fmt.Errorf("export canceled: %w", err)
-	}
-	return c.exportedMeta, c.exportFound, c.exportErr
+func (*adapterTestCore) ExportReleaseSeed(context.Context, api.ReleaseRef) (preparedrelease.Seed, error) {
+	return preparedrelease.Seed{}, nil
 }
 
-func (c *preparedMetaTestCore) ImportPreparedMetadataForGUI(_ context.Context, req api.Request, meta api.PreparedMetadata) error {
-	c.importedReq = req
-	c.importedMeta = meta
-	return nil
+func (*adapterTestCore) ImportReleaseSeed(context.Context, preparedrelease.Seed) (api.ReleaseRef, error) {
+	return api.ReleaseRef{}, nil
 }
 
-func TestPruneCompletedDupeJobsLockedKeepsNewestCompleted(t *testing.T) {
-	backend := &Backend{
-		dupes: make(map[string]*dupeCheckJob),
-	}
-
-	active := &dupeCheckJob{id: "active", status: "running"}
-	backend.dupes[active.id] = active
-
-	now := time.Now().UTC()
-	for idx := range 3 {
-		id := fmt.Sprintf("dupe-%d", idx)
-		backend.dupes[id] = &dupeCheckJob{
-			id:         id,
-			status:     "completed",
-			finishedAt: now.Add(time.Duration(idx) * time.Minute),
-		}
-	}
-
-	backend.pruneCompletedDupeJobsLocked(2)
-
-	if _, ok := backend.dupes["dupe-0"]; ok {
-		t.Fatal("expected oldest completed dupe job to be pruned")
-	}
-	if _, ok := backend.dupes["dupe-1"]; !ok {
-		t.Fatal("expected newer completed dupe job to remain")
-	}
-	if _, ok := backend.dupes["dupe-2"]; !ok {
-		t.Fatal("expected newest completed dupe job to remain")
-	}
-	if _, ok := backend.dupes[active.id]; !ok {
-		t.Fatal("expected active dupe job to remain")
-	}
-}
-
-func TestStartDupeCheckRequiresMetadataPreviewCache(t *testing.T) {
+func TestWebUploadRunnerUsesPreparedUploadAndWebPrefix(t *testing.T) {
 	t.Parallel()
 
-	coreSvc := &preparedMetaTestCore{}
-	backend := &Backend{
-		core:  coreSvc,
-		dupes: make(map[string]*dupeCheckJob),
-	}
-
-	_, err := backend.StartDupeCheck(context.Background(), "session", `C:\Media\Example.mkv`, api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, []string{"AITHER"})
-	if err == nil {
-		t.Fatal("expected missing metadata preview cache to block dupe check start")
-	}
-	if !strings.Contains(err.Error(), "dupe check requires metadata preview") {
-		t.Fatalf("expected metadata preview error, got %v", err)
+	coreSvc := &adapterTestCore{uploadErr: errors.New("upload failed")}
+	request := api.Request{SourcePath: "Example.Release.2026.1080p-GRP", Trackers: []string{"EXAMPLE"}}
+	_, err := (webUploadRunner{
+		core: coreSvc, generationTarget: coreSvc,
+	}).RunUpload(context.Background(), api.UploadExecutionPlan{Input: api.UploadReviewInput{
+		Release:  api.ReleaseRef{SourcePath: request.SourcePath},
+		Trackers: request.Trackers,
+	},
+	})
+	if err == nil || !strings.HasPrefix(err.Error(), "web: ") {
+		t.Fatalf("expected web-prefixed upload error, got %v", err)
 	}
-	if count := dupeJobCount(backend); count != 0 {
-		t.Fatalf("expected no durable dupe job after cache miss, got %d", count)
+	if coreSvc.uploadInput.Release.SourcePath != request.SourcePath || coreSvc.uploadInput.Trackers[0] != request.Trackers[0] {
+		t.Fatalf("prepared upload input mismatch: %#v", coreSvc.uploadInput)
 	}
 }
 
-func TestStartDupeCheckUsesMetadataPreviewCache(t *testing.T) {
+func TestWebDupeRunnerPreservesRequest(t *testing.T) {
 	t.Parallel()
 
-	backend, sourcePath := newDupeCheckStartTestBackend(t)
-	tmdbID := 1234567
-	releaseType := "movie"
-	overrides := api.ExternalIDOverrides{TMDBID: &tmdbID}
-	nameOverrides := api.ReleaseNameOverrides{Type: &releaseType}
-	coreSvc := &preparedMetaTestCore{
-		exportFound:  true,
-		exportedMeta: api.PreparedMetadata{SourcePath: sourcePath},
-		expectedExportReq: &api.Request{
-			Paths:                []string{sourcePath},
-			Mode:                 api.ModeGUI,
-			Trackers:             []string{"AITHER"},
-			ExternalIDOverrides:  overrides,
-			ReleaseNameOverrides: nameOverrides,
-		},
-	}
-	backend.core = coreSvc
-
-	jobID, err := backend.StartDupeCheck(context.Background(), "session", sourcePath, overrides, nameOverrides, []string{"AITHER"})
+	coreSvc := &adapterTestCore{dupeSummary: api.DupeCheckSummary{SourcePath: "Example.Release.2026.1080p-GRP"}}
+	request := api.Request{
+		SourcePath:           "Example.Release.2026.1080p-GRP",
+		Trackers:             []string{"EXAMPLE"},
+		ExternalIDOverrides:  api.ExternalIDOverrides{},
+		ReleaseNameOverrides: api.ReleaseNameOverrides{},
+	}
+	summary, err := (webDupeRunner{
+		core: coreSvc, generationTarget: coreSvc,
+	}).CheckDupes(context.Background(), api.DuplicateCheckInput{
+		Release:  api.ReleaseRef{SourcePath: request.SourcePath},
+		Trackers: request.Trackers,
+	})
 	if err != nil {
-		t.Fatalf("start dupe check: %v", err)
-	}
-	if strings.TrimSpace(jobID) == "" {
-		t.Fatal("expected job id")
+		t.Fatalf("check dupes: %v", err)
 	}
-	if count := dupeJobCount(backend); count != 1 {
-		t.Fatalf("expected durable dupe job, got %d", count)
-	}
-}
-
-func TestStartDupeCheckFailsOnMetadataPreviewCacheRequestMismatch(t *testing.T) {
-	t.Parallel()
-
-	for _, tt := range []struct {
-		name        string
-		expected    func(string) api.Request
-		overrides   api.ExternalIDOverrides
-		wantMessage string
-	}{
-		{
-			name: "path",
-			expected: func(sourcePath string) api.Request {
-				return api.Request{Paths: []string{sourcePath + ".other"}, Mode: api.ModeGUI, Trackers: []string{"AITHER"}}
-			},
-			wantMessage: "metadata preview cache request paths",
-		},
-		{
-			name: "tracker",
-			expected: func(sourcePath string) api.Request {
-				return api.Request{Paths: []string{sourcePath}, Mode: api.ModeGUI, Trackers: []string{"BLU"}}
-			},
-			wantMessage: "metadata preview cache request trackers",
-		},
-		{
-			name: "external id override",
-			expected: func(sourcePath string) api.Request {
-				tmdbID := 7654321
-				return api.Request{
-					Paths:               []string{sourcePath},
-					Mode:                api.ModeGUI,
-					Trackers:            []string{"AITHER"},
-					ExternalIDOverrides: api.ExternalIDOverrides{TMDBID: &tmdbID},
-				}
-			},
-			overrides: func() api.ExternalIDOverrides {
-				tmdbID := 1234567
-				return api.ExternalIDOverrides{TMDBID: &tmdbID}
-			}(),
-			wantMessage: "metadata preview cache request external overrides",
-		},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			backend, sourcePath := newDupeCheckStartTestBackend(t)
-			expected := tt.expected(sourcePath)
-			coreSvc := &preparedMetaTestCore{
-				exportFound:       true,
-				exportedMeta:      api.PreparedMetadata{SourcePath: sourcePath},
-				expectedExportReq: &expected,
-			}
-			backend.core = coreSvc
-
-			_, err := backend.StartDupeCheck(context.Background(), "session", sourcePath, tt.overrides, api.ReleaseNameOverrides{}, []string{"AITHER"})
-			if err == nil {
-				t.Fatal("expected metadata preview cache request mismatch to fail")
-			}
-			if !strings.Contains(err.Error(), tt.wantMessage) {
-				t.Fatalf("expected mismatch error %q, got %v", tt.wantMessage, err)
-			}
-			if count := dupeJobCount(backend); count != 0 {
-				t.Fatalf("expected no durable dupe job after cache request mismatch, got %d", count)
-			}
-		})
+	if summary.SourcePath != coreSvc.dupeInput.Release.SourcePath {
+		t.Fatalf("dupe input mismatch: %#v", coreSvc.dupeInput)
 	}
 }
 
-func TestStartDupeCheckStopsPreJobExportOnRequestCancel(t *testing.T) {
+func TestStartTrackerUploadRejectsPartialCapabilityBundle(t *testing.T) {
 	t.Parallel()
 
-	backend, sourcePath := newDupeCheckStartTestBackend(t)
-	coreSvc := &preparedMetaTestCore{
-		exportFound:    true,
-		exportedMeta:   api.PreparedMetadata{SourcePath: sourcePath},
-		exportStarted:  make(chan struct{}),
-		exportContinue: make(chan struct{}),
-	}
-	backend.core = coreSvc
-
-	ctx, cancel := context.WithCancel(context.Background())
-	errCh := make(chan error, 1)
-	go func() {
-		_, err := backend.StartDupeCheck(ctx, "session", sourcePath, api.ExternalIDOverrides{}, api.ReleaseNameOverrides{}, []string{"AITHER"})
-		errCh <- err
-	}()
-
-	select {
-	case <-coreSvc.exportStarted:
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("expected metadata cache export to start")
-	}
-	cancel()
-
-	select {
-	case err := <-errCh:
-		if !errors.Is(err, context.Canceled) {
-			t.Fatalf("expected canceled export error, got %v", err)
-		}
-	case <-time.After(500 * time.Millisecond):
-		t.Fatal("expected start to return after request cancellation")
-	}
-	if count := dupeJobCount(backend); count != 0 {
-		t.Fatalf("expected no durable dupe job after canceled export, got %d", count)
-	}
-}
-
-func TestPruneCompletedUploadJobsLockedKeepsNewestCompleted(t *testing.T) {
 	backend := &Backend{
-		uploads: make(map[string]*trackerUploadJob),
-	}
-
-	active := &trackerUploadJob{id: "active", status: "running"}
-	backend.uploads[active.id] = active
+		capabilities: CoreCapabilities{UploadExecution: &adapterTestCore{}},
+	}
+	_, err := backend.ReviewTrackerUpload(
+		context.Background(),
+		"session-1",
+		api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 1},
+		[]string{"EXAMPLE"},
+		nil,
+		nil,
+		nil,
+		nil,
+		false,
+		"",
+	)
+	if !errors.Is(err, ErrPreparedGenerationUnavailable) {
+		t.Fatalf("expected missing transfer capability error, got %v", err)
+	}
+}
+
+func TestWebStartTrackerUploadExportsBeforePerRunSetup(t *testing.T) {
+	t.Parallel()
 
-	now := time.Now().UTC()
-	for idx := range 3 {
-		id := fmt.Sprintf("upload-%d", idx)
-		backend.uploads[id] = &trackerUploadJob{
-			id:         id,
-			status:     "completed",
-			finishedAt: now.Add(time.Duration(idx) * time.Minute),
+	exportErr := errors.New("prepared authorization rejected")
+	coreSvc := &adapterTestCore{exportErr: exportErr}
+	backend := &Backend{capabilities: webTestCapabilities(coreSvc)}
+	t.Cleanup(func() {
+		if backend.jobEngine != nil {
+			backend.jobEngine.Close()
 		}
-	}
-
-	backend.pruneCompletedUploadJobsLocked(2)
+	})
+	_, err := backend.ReviewTrackerUpload(
+		context.Background(),
+		"session-1",
+		api.ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 1},
+		[]string{"EXAMPLE"},
+		nil,
+		nil,
+		nil,
+		nil,
+		false,
+		"",
+	)
+	if !errors.Is(err, exportErr) {
+		t.Fatalf("expected export error before per-run setup, got %v", err)
+	}
+}
+
+func TestWebDupeRunnerPreservesCoreErrorText(t *testing.T) {
+	t.Parallel()
 
-	if _, ok := backend.uploads["upload-0"]; ok {
-		t.Fatal("expected oldest completed upload job to be pruned")
-	}
-	if _, ok := backend.uploads["upload-1"]; !ok {
-		t.Fatal("expected newer completed upload job to remain")
-	}
-	if _, ok := backend.uploads["upload-2"]; !ok {
-		t.Fatal("expected newest completed upload job to remain")
-	}
-	if _, ok := backend.uploads[active.id]; !ok {
-		t.Fatal("expected active upload job to remain")
+	want := "provider rejected duplicate check"
+	coreSvc := &adapterTestCore{dupeErr: errors.New(want)}
+	_, err := (webDupeRunner{core: coreSvc, generationTarget: coreSvc}).CheckDupes(
+		context.Background(), api.DuplicateCheckInput{},
+	)
+	if err == nil || err.Error() != want {
+		t.Fatalf("error = %v, want exact %q", err, want)
 	}
 }
 
-func TestDupeJobAccessRequiresOwningSession(t *testing.T) {
-	backend := &Backend{
-		dupes: map[string]*dupeCheckJob{
-			"job-1": {
-				sessionID:  "session-a",
-				id:         "job-1",
-				sourcePath: `C:\Media\Movie.mkv`,
-				status:     "running",
-				states:     map[string]DupeCheckTrackerState{},
-				startedAt:  time.Now().UTC(),
-			},
-		},
-	}
-
-	if _, err := backend.GetDupeCheckSnapshot("session-b", "job-1"); err == nil {
-		t.Fatal("expected foreign session snapshot read to be rejected")
-	}
-	if err := backend.CancelDupeCheck("session-b", "job-1"); err == nil {
-		t.Fatal("expected foreign session cancel to be rejected")
-	}
-	if _, err := backend.GetDupeCheckSnapshot("session-a", "job-1"); err != nil {
-		t.Fatalf("expected owning session snapshot read to succeed: %v", err)
-	}
-}
-
-func TestTrackerUploadJobAccessRequiresOwningSession(t *testing.T) {
-	backend := &Backend{
-		uploads: map[string]*trackerUploadJob{
-			"job-1": {
-				sessionID:  "session-a",
-				id:         "job-1",
-				sourcePath: `C:\Media\Movie.mkv`,
-				status:     "running",
-				states:     map[string]TrackerUploadTrackerState{},
-				startedAt:  time.Now().UTC(),
-			},
-		},
-	}
+func TestBuildRunOptionsKeepsDebugAsLogLevelOnly(t *testing.T) {
+	t.Parallel()
 
-	if _, err := backend.GetTrackerUploadSnapshot("session-b", "job-1"); err == nil {
-		t.Fatal("expected foreign session snapshot read to be rejected")
-	}
-	if err := backend.CancelTrackerUpload("session-b", "job-1"); err == nil {
-		t.Fatal("expected foreign session cancel to be rejected")
-	}
-	if _, err := backend.RetryFailedTrackerUpload("session-b", "job-1"); err == nil {
-		t.Fatal("expected foreign session retry to be rejected")
+	backend := &Backend{}
+	runOpts, err := backend.buildRunOptions(false, "debug")
+	if err != nil {
+		t.Fatalf("build run options: %v", err)
 	}
-	if _, err := backend.GetTrackerUploadSnapshot("session-a", "job-1"); err != nil {
-		t.Fatalf("expected owning session snapshot read to succeed: %v", err)
+	options := buildRunUploadOptions(config.Config{}, runOpts)
+	if options.RunLogLevel != "debug" || options.NoSeed {
+		t.Fatalf("upload options = %#v", options)
 	}
 }
 
-func TestTrackerUploadRetryRequestUsesStoredUploadOptions(t *testing.T) {
-	job := &trackerUploadJob{
-		sessionID:      "session-a",
-		sourcePath:     `C:\Media\Movie.mkv`,
-		uploadOptions:  api.UploadOptions{Screens: 1, SkipAutoTorrent: true},
-		runOptions:     runOptions{Debug: true, NoSeed: true, RunLogLevel: "debug"},
-		failedTrackers: []string{"BLU"},
-		ignoreDupesFor: []string{"AITHER"},
-	}
-
-	retry, err := trackerUploadRetryRequestFromJob(job)
-	if err != nil {
-		t.Fatalf("retry request: %v", err)
-	}
-
-	job.uploadOptions.Screens = 9
-	job.failedTrackers[0] = "MUTATED"
-	job.ignoreDupesFor[0] = "MUTATED"
+type successfulUploadRunner struct{}
 
-	if retry.sessionID != "session-a" {
-		t.Fatalf("expected retry session snapshot, got %q", retry.sessionID)
-	}
-	if retry.uploadOptions.Screens != 1 || !retry.uploadOptions.SkipAutoTorrent {
-		t.Fatalf("expected stored upload options snapshot, got %#v", retry.uploadOptions)
-	}
-	if len(retry.failedTrackers) != 1 || retry.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed trackers snapshot, got %#v", retry.failedTrackers)
-	}
-	if len(retry.ignoreDupesFor) != 1 || retry.ignoreDupesFor[0] != "AITHER" {
-		t.Fatalf("expected ignore dupes snapshot, got %#v", retry.ignoreDupesFor)
-	}
-	if !retry.runOptions.Debug || !retry.runOptions.NoSeed || retry.runOptions.RunLogLevel != "debug" {
-		t.Fatalf("expected run options snapshot, got %#v", retry.runOptions)
-	}
+func (successfulUploadRunner) RunUpload(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+	return api.Result{UploadedCount: 1}, nil
 }
 
-func TestRunTrackerUploadJobCountsPartialErrorAndContinues(t *testing.T) {
-	backend := &Backend{hub: newEventHub()}
-	coreSvc := &preparedMetaTestCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: 1},
-			err:    errors.New("tracker failed after upload"),
-		},
-		{
-			result: api.Result{UploadedCount: 2},
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU", "AITHER"})
+type successfulDupeRunner struct{}
 
-	backend.uploadWG.Add(1)
-	backend.runTrackerUploadJob(context.Background(), job)
-
-	if got := job.uploadedCount; got != 3 {
-		t.Fatalf("expected total uploaded count 3, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 1 {
-		t.Fatalf("expected failed tracker partial count 1, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "failed" {
-		t.Fatalf("expected partial error tracker to remain failed, got %q", got)
-	}
-	if got := job.states["AITHER"].UploadedCount; got != 2 {
-		t.Fatalf("expected success tracker count 2, got %d", got)
-	}
-	if got := job.status; got != "completed_with_errors" {
-		t.Fatalf("expected completed_with_errors status, got %q", got)
-	}
-	if len(job.failedTrackers) != 1 || job.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed tracker BLU, got %#v", job.failedTrackers)
-	}
+func (successfulDupeRunner) CheckDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	return api.DupeCheckSummary{}, nil
 }
 
-func TestRunDupeCheckJobSplitsGroupedPathedResultsIntoTrackerStates(t *testing.T) {
+func TestWebJobFacadesPreserveLegacyOwnershipErrors(t *testing.T) {
 	t.Parallel()
 
-	coreSvc := &preparedMetaTestCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Movie.mkv`,
-		Results: []api.DupeCheckResult{
-			{
-				Tracker:  "AITHER, BLU",
-				HasDupes: true,
-				Status:   "completed",
-				Notes:    []string{"pathed torrent match found; skipping dupe search"},
-			},
-			{Tracker: "RF", Status: "completed"},
-		},
-	}}
-	job := newDupeCheckJobTestJob("session-a", coreSvc.dupeSummary.SourcePath, []string{"AITHER", "BLU", "RF"})
-	job.core = coreSvc
-	backend := &Backend{hub: newEventHub()}
-	backend.dupeWG.Add(1)
-
-	backend.runDupeCheckJob(context.Background(), job)
+	backend := &Backend{jobEngine: sharedjobs.New(nil, sharedjobs.Config{})}
+	t.Cleanup(backend.jobEngine.Close)
 
-	if got := job.completedCount; got != 3 {
-		t.Fatalf("expected all trackers completed, got %d", got)
+	owner, err := backend.ensureJobOwner("owner-a")
+	if err != nil {
+		t.Fatalf("ensure owner: %v", err)
 	}
-	if _, ok := job.states["AITHER, BLU"]; ok {
-		t.Fatal("did not expect grouped tracker state")
+	sourcePath := "Example.Release.2026.1080p-GRP"
+	dupeID, err := backend.jobEngine.StartDupe(context.Background(), owner, sharedjobs.DupeSpec{
+		CorrelationID: "owner-dupe",
+		Snapshot:      webTestDupeSnapshot(sourcePath),
+		Runner:        successfulDupeRunner{},
+	})
+	if err != nil {
+		t.Fatalf("start dupe: %v", err)
 	}
-	for _, tracker := range []string{"AITHER", "BLU"} {
-		state := job.states[tracker]
-		if got := state.Status; got != "completed" {
-			t.Fatalf("expected %s completed, got %q", tracker, got)
+	uploadID, err := backend.jobEngine.StartUpload(context.Background(), owner, sharedjobs.UploadSpec{
+		CorrelationID: "owner-upload",
+		Snapshot:      webTestUploadSnapshot(sourcePath),
+		Runner:        successfulUploadRunner{},
+	})
+	if err != nil {
+		t.Fatalf("start upload: %v", err)
+	}
+
+	assertExactError(t, func() error {
+		_, snapshotErr := backend.GetDupeCheckSnapshot("owner-b", dupeID)
+		return snapshotErr
+	}, "dupe job not found")
+	assertExactError(t, func() error { return backend.CancelDupeCheck("owner-b", dupeID) }, "dupe job not found")
+	assertExactError(t, func() error {
+		_, snapshotErr := backend.GetDupeCheckSnapshot("owner-a", "unknown")
+		return snapshotErr
+	}, "dupe job not found")
+
+	assertExactError(t, func() error {
+		_, snapshotErr := backend.GetTrackerUploadSnapshot("owner-b", uploadID)
+		return snapshotErr
+	}, "upload job not found")
+	assertExactError(t, func() error { return backend.CancelTrackerUpload("owner-b", uploadID) }, "upload job not found")
+	assertExactError(t, func() error {
+		_, retryErr := backend.RetryFailedTrackerUpload("owner-b", uploadID, "foreign-retry")
+		return retryErr
+	}, "upload job not found")
+	assertExactError(t, func() error {
+		_, snapshotErr := backend.GetTrackerUploadSnapshot("owner-a", "unknown")
+		return snapshotErr
+	}, "upload job not found")
+
+	deadline := time.Now().Add(time.Second)
+	for {
+		snapshot, snapshotErr := backend.GetTrackerUploadSnapshot("owner-a", uploadID)
+		if snapshotErr != nil {
+			t.Fatalf("get upload snapshot: %v", snapshotErr)
+		}
+		if snapshot.Status == sharedjobs.StatusCompleted {
+			break
 		}
-		if got := state.Result.Tracker; got != tracker {
-			t.Fatalf("expected %s result tracker, got %q", tracker, got)
+		if time.Now().After(deadline) {
+			t.Fatalf("upload did not complete: %#v", snapshot)
 		}
+		time.Sleep(time.Millisecond)
 	}
+	assertExactError(t, func() error {
+		_, retryErr := backend.RetryFailedTrackerUpload("owner-a", uploadID, "owner-retry")
+		return retryErr
+	}, "no failed trackers to retry")
 }
 
-func TestApplyDupeProgressCountsNewTrackersWithoutInflatingExplicitTotal(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		startTotal  int
-		updateTotal int
-		wantTotal   int
-	}{
-		{name: "explicit total", startTotal: 2, updateTotal: 2, wantTotal: 2},
-		{name: "total omitted", startTotal: 1, wantTotal: 2},
-		{name: "explicit total lower than current", startTotal: 3, updateTotal: 2, wantTotal: 3},
-		{name: "explicit total higher than current", startTotal: 2, updateTotal: 3, wantTotal: 3},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			job := newDupeCheckJobTestJob("session-a", `C:\Media\Example.Release.2026.1080p-GRP.mkv`, []string{"AITHER"})
-			job.totalCount = tt.startTotal
-			backend := &Backend{hub: newEventHub()}
-
-			backend.applyDupeProgress(job, api.DupeProgressUpdate{
-				Tracker: "BLU",
-				Status:  "running",
-				Total:   tt.updateTotal,
-			})
-
-			if job.totalCount != tt.wantTotal {
-				t.Fatalf("expected total count %d, got %d", tt.wantTotal, job.totalCount)
-			}
-			if len(job.trackers) != 2 || job.trackers[1] != "BLU" {
-				t.Fatalf("expected new tracker to be appended once, got %#v", job.trackers)
-			}
-			if got := job.states["BLU"].Status; got != "running" {
-				t.Fatalf("expected BLU running state, got %q", got)
-			}
-		})
+func assertExactError(t *testing.T, call func() error, want string) {
+	t.Helper()
+	if err := call(); err == nil || err.Error() != want {
+		t.Fatalf("error = %v, want exact %q", err, want)
 	}
 }
 
-func TestRunDupeCheckJobUsesJobCoreSnapshot(t *testing.T) {
+func TestWebJobSinkUsesSessionAndExistingTopics(t *testing.T) {
 	t.Parallel()
 
-	jobCore := &preparedMetaTestCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Movie.mkv`,
-		Results:    []api.DupeCheckResult{{Tracker: "AITHER", Status: "completed"}},
-	}}
-	currentCore := &preparedMetaTestCore{dupeSummary: api.DupeCheckSummary{
-		SourcePath: `C:\Media\Other.mkv`,
-		Results:    []api.DupeCheckResult{{Tracker: "AITHER", Status: "failed"}},
-	}}
-	job := newDupeCheckJobTestJob("session-a", jobCore.dupeSummary.SourcePath, []string{"AITHER"})
-	job.core = jobCore
-	job.uploadOptions = api.UploadOptions{Screens: 1}
-	backend := &Backend{core: currentCore, hub: newEventHub()}
-	backend.dupeWG.Add(1)
-
-	backend.runDupeCheckJob(context.Background(), job)
-
-	if got := jobCore.dupeCalls; got != 1 {
-		t.Fatalf("expected job-owned core to run once, got %d", got)
-	}
-	if got := currentCore.dupeCalls; got != 0 {
-		t.Fatalf("expected current runtime core not to run, got %d", got)
-	}
-	if got := job.states["AITHER"].Status; got != "completed" {
-		t.Fatalf("expected result from job-owned core, got %q", got)
-	}
-}
-
-func TestRunTrackerUploadJobIgnoresNegativeUploadedCount(t *testing.T) {
-	backend := &Backend{hub: newEventHub()}
-	coreSvc := &preparedMetaTestCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: -1},
-			err:    errors.New("tracker failed after invalid count"),
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	backend.uploadWG.Add(1)
-	backend.runTrackerUploadJob(context.Background(), job)
-
-	if got := job.uploadedCount; got != 0 {
-		t.Fatalf("expected negative count to leave total unchanged, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 0 {
-		t.Fatalf("expected negative count to leave tracker count unchanged, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "failed" {
-		t.Fatalf("expected tracker error handling to remain failed, got %q", got)
-	}
-	if len(job.failedTrackers) != 1 || job.failedTrackers[0] != "BLU" {
-		t.Fatalf("expected failed tracker BLU, got %#v", job.failedTrackers)
-	}
-}
-
-func TestRunTrackerUploadJobCountsCanceledPartialWithoutFailedTracker(t *testing.T) {
-	backend := &Backend{hub: newEventHub()}
-	ctx, cancel := context.WithCancel(context.Background())
-	coreSvc := &preparedMetaTestCore{uploads: []uploadPreparedResponse{
-		{
-			result:       api.Result{UploadedCount: 1},
-			err:          context.Canceled,
-			beforeReturn: cancel,
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU"})
-
-	backend.uploadWG.Add(1)
-	backend.runTrackerUploadJob(ctx, job)
-
-	if got := job.uploadedCount; got != 1 {
-		t.Fatalf("expected canceled partial count 1, got %d", got)
-	}
-	if got := job.states["BLU"].UploadedCount; got != 1 {
-		t.Fatalf("expected tracker partial count 1, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "canceled" {
-		t.Fatalf("expected canceled tracker status, got %q", got)
-	}
-	if got := job.states["BLU"].Message; got != "canceled" {
-		t.Fatalf("expected canceled tracker message, got %q", got)
-	}
-	if got := job.states["BLU"].FinishedAt; got == "" {
-		t.Fatal("expected canceled tracker finished time")
-	}
-	assertSnapshotHasNoActiveTrackerStates(t, buildTrackerUploadSnapshot(job))
-	if got := job.status; got != "canceled" {
-		t.Fatalf("expected canceled job status, got %q", got)
-	}
-	if len(job.failedTrackers) != 0 {
-		t.Fatalf("expected no failed trackers after cancellation, got %#v", job.failedTrackers)
-	}
-}
-
-func TestRunTrackerUploadJobCancelsQueuedTrackersBeforeFirstUpload(t *testing.T) {
-	backend := &Backend{hub: newEventHub()}
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	coreSvc := &preparedMetaTestCore{}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU", "AITHER"})
+	hub := newEventHub()
+	events, stop := hub.Subscribe("session-a")
+	defer stop()
 
-	backend.uploadWG.Add(1)
-	backend.runTrackerUploadJob(ctx, job)
+	sink := webJobSink{hub: hub}
+	sink.EmitDupe("session-a", sharedjobs.DupeCheckSnapshot{JobID: "dupe-1"})
+	sink.EmitUpload("session-a", sharedjobs.TrackerUploadSnapshot{JobID: "upload-1"})
 
-	if got := coreSvc.uploadCalls; got != 0 {
-		t.Fatalf("expected no upload calls after pre-start cancellation, got %d", got)
-	}
-	if got := job.status; got != "canceled" {
-		t.Fatalf("expected canceled job status, got %q", got)
-	}
-	for _, tracker := range job.trackers {
-		state := job.states[tracker]
-		if state.Status != "canceled" {
-			t.Fatalf("expected %s status canceled, got %q", tracker, state.Status)
-		}
-		if state.Message != "canceled" {
-			t.Fatalf("expected %s message canceled, got %q", tracker, state.Message)
-		}
-		if state.FinishedAt == "" {
-			t.Fatalf("expected %s finished time", tracker)
+	select {
+	case event := <-events:
+		if event.Name != "dupe:job:dupe-1" {
+			t.Fatalf("unexpected dupe topic %q", event.Name)
 		}
+	case <-time.After(time.Second):
+		t.Fatal("expected dupe event on existing topic")
 	}
-	assertSnapshotHasNoActiveTrackerStates(t, buildTrackerUploadSnapshot(job))
-}
-
-func TestRunTrackerUploadJobCancelsRunningAndQueuedTrackersWithoutOverwritingSuccess(t *testing.T) {
-	backend := &Backend{hub: newEventHub()}
-	ctx, cancel := context.WithCancel(context.Background())
-	coreSvc := &preparedMetaTestCore{uploads: []uploadPreparedResponse{
-		{
-			result: api.Result{UploadedCount: 1},
-		},
-		{
-			err:          context.Canceled,
-			beforeReturn: cancel,
-		},
-	}}
-	job := newTrackerUploadJobTestJob(coreSvc, []string{"BLU", "AITHER", "BHD"})
-
-	backend.uploadWG.Add(1)
-	backend.runTrackerUploadJob(ctx, job)
-
-	if got := job.uploadedCount; got != 1 {
-		t.Fatalf("expected total uploaded count 1, got %d", got)
-	}
-	if got := job.states["BLU"].Status; got != "success" {
-		t.Fatalf("expected completed tracker success to remain unchanged, got %q", got)
-	}
-	if got := job.states["AITHER"].Status; got != "canceled" {
-		t.Fatalf("expected running tracker canceled, got %q", got)
-	}
-	if got := job.states["BHD"].Status; got != "canceled" {
-		t.Fatalf("expected queued tracker canceled, got %q", got)
-	}
-	assertSnapshotHasNoActiveTrackerStates(t, buildTrackerUploadSnapshot(job))
-	if got := job.status; got != "canceled" {
-		t.Fatalf("expected canceled job status, got %q", got)
+	select {
+	case event := <-events:
+		if event.Name != "jobs:update" {
+			t.Fatalf("unexpected registry topic %q", event.Name)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("expected dupe registry event")
 	}
-	if len(job.failedTrackers) != 0 {
-		t.Fatalf("expected no failed trackers after cancellation, got %#v", job.failedTrackers)
+	select {
+	case event := <-events:
+		if event.Name != "upload:job:upload-1" {
+			t.Fatalf("unexpected upload topic %q", event.Name)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("expected upload event on existing topic")
 	}
-}
-
-func TestApplyTrackerUploadProgressThrottlesSmallHashRateBurst(t *testing.T) {
-	hub := newEventHub()
-	ch, unsubscribe := hub.Subscribe("session")
-	defer unsubscribe()
-	backend := &Backend{hub: hub}
-	job := newTrackerUploadProgressTestJob()
-	job.lastSnapshotEmit = time.Now()
-	job.snapshotThrottle = time.Hour
-	job.currentTaskStatus = "running"
-	job.currentPercent = 40
-	job.currentHashRateMiB = 10
-
-	backend.applyTrackerUploadProgress(job, api.UploadProgressUpdate{
-		Tracker:     "BLU",
-		Status:      "running",
-		Percent:     40,
-		HashRateMiB: 10.25,
-	})
-
 	select {
-	case event := <-ch:
-		t.Fatalf("expected throttled hash-rate-only update, got event %q", event.Name)
-	default:
+	case event := <-events:
+		if event.Name != "jobs:update" {
+			t.Fatalf("unexpected registry topic %q", event.Name)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("expected upload registry event")
 	}
 }
 
-func TestApplyTrackerUploadProgressEmitsMeaningfulChangeWithinThrottle(t *testing.T) {
-	tests := []struct {
-		name   string
-		update api.UploadProgressUpdate
-	}{
-		{
-			name: "percent changed",
-			update: api.UploadProgressUpdate{
-				Tracker: "BLU",
-				Status:  "running",
-				Percent: 41,
-			},
-		},
-		{
-			name: "status changed",
-			update: api.UploadProgressUpdate{
-				Tracker: "BLU",
-				Status:  "completed",
-				Percent: 40,
-			},
-		},
-		{
-			name: "hash rate changed beyond threshold",
-			update: api.UploadProgressUpdate{
-				Tracker:     "BLU",
-				Status:      "running",
-				Percent:     40,
-				HashRateMiB: 12,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			hub := newEventHub()
-			ch, unsubscribe := hub.Subscribe("session")
-			defer unsubscribe()
-			backend := &Backend{hub: hub}
-			job := newTrackerUploadProgressTestJob()
-			job.lastSnapshotEmit = time.Now()
-			job.snapshotThrottle = time.Hour
-			job.currentTaskStatus = "running"
-			job.currentPercent = 40
-			job.currentHashRateMiB = 10
-
-			backend.applyTrackerUploadProgress(job, tt.update)
-
-			select {
-			case event := <-ch:
-				if event.Name != "upload:job:job" {
-					t.Fatalf("unexpected event name: %q", event.Name)
-				}
-			default:
-				t.Fatal("expected meaningful progress change to emit immediately")
-			}
-		})
-	}
+type blockingUploadRunner struct {
+	started  chan<- struct{}
+	canceled chan<- struct{}
+	release  <-chan struct{}
 }
 
-func TestApplyTrackerUploadProgressUpdatesOnlyNamedTrackerForMultiTrackerJobs(t *testing.T) {
-	hub := newEventHub()
-	backend := &Backend{hub: hub}
-	job := &trackerUploadJob{
-		sessionID: "session",
-		id:        "job",
-		trackers:  []string{"BLU", "AITHER"},
-		states: map[string]TrackerUploadTrackerState{
-			"BLU":    {Tracker: "BLU", Status: "running", Message: "queued"},
-			"AITHER": {Tracker: "AITHER", Status: "running", Message: "queued"},
-		},
-		startedAt: time.Now().UTC(),
-	}
-
-	backend.applyTrackerUploadProgress(job, api.UploadProgressUpdate{
-		Tracker: "BLU",
-		Task:    "tracker_upload",
-		Status:  "running",
-		Message: "Uploading to tracker",
-		Percent: 40,
-	})
-
-	if got := job.states["BLU"].Task; got != "tracker_upload" {
-		t.Fatalf("expected BLU task to update, got %q", got)
-	}
-	if got := job.states["BLU"].Message; got != "Uploading to tracker" {
-		t.Fatalf("expected BLU message to update, got %q", got)
+func (r blockingUploadRunner) RunUpload(ctx context.Context, _ api.UploadExecutionPlan) (api.Result, error) {
+	if r.started != nil {
+		r.started <- struct{}{}
 	}
-	if got := job.states["AITHER"].Task; got != "" {
-		t.Fatalf("expected AITHER task to remain untouched, got %q", got)
-	}
-	if got := job.states["AITHER"].Message; got != "queued" {
-		t.Fatalf("expected AITHER message to remain queued, got %q", got)
-	}
-}
-
-func newTrackerUploadProgressTestJob() *trackerUploadJob {
-	return &trackerUploadJob{
-		sessionID: "session",
-		id:        "job",
-		trackers:  []string{"BLU"},
-		states: map[string]TrackerUploadTrackerState{
-			"BLU": {Tracker: "BLU", Status: "running", Message: "uploading"},
-		},
-		startedAt: time.Now().UTC(),
+	<-ctx.Done()
+	select {
+	case r.canceled <- struct{}{}:
+	default:
 	}
+	<-r.release
+	return api.Result{}, fmt.Errorf("blocking upload: %w", ctx.Err())
 }
 
-func newTrackerUploadJobTestJob(coreSvc api.Core, trackers []string) *trackerUploadJob {
-	job := &trackerUploadJob{
-		sessionID:  "session",
-		id:         "job",
-		sourcePath: `C:\Media\Movie.mkv`,
-		core:       coreSvc,
-		trackers:   trackers,
-		states:     make(map[string]TrackerUploadTrackerState, len(trackers)),
-		status:     "queued",
-		startedAt:  time.Now().UTC(),
-	}
-	for _, tracker := range trackers {
-		job.states[tracker] = TrackerUploadTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
-	}
-	return job
+type blockingDupeRunner struct {
+	started  chan<- struct{}
+	canceled chan<- struct{}
+	release  <-chan struct{}
 }
 
-func newDupeCheckJobTestJob(sessionID string, sourcePath string, trackers []string) *dupeCheckJob {
-	job := &dupeCheckJob{
-		sessionID:  sessionID,
-		id:         "dupe-job",
-		sourcePath: sourcePath,
-		trackers:   trackers,
-		states:     make(map[string]DupeCheckTrackerState, len(trackers)),
-		totalCount: len(trackers),
-		status:     "queued",
-		startedAt:  time.Now().UTC(),
+func (r blockingDupeRunner) CheckDupes(ctx context.Context, _ api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	if r.started != nil {
+		r.started <- struct{}{}
 	}
-	for _, tracker := range trackers {
-		job.states[tracker] = DupeCheckTrackerState{Tracker: tracker, Status: "queued", Message: "queued"}
+	<-ctx.Done()
+	select {
+	case r.canceled <- struct{}{}:
+	default:
 	}
-	return job
+	<-r.release
+	return api.DupeCheckSummary{}, fmt.Errorf("blocking dupe: %w", ctx.Err())
 }
 
-func newDupeCheckStartTestBackend(t *testing.T) (*Backend, string) {
+func installBlockingUploadJob(
+	t *testing.T,
+	backend *Backend,
+	ownerID string,
+	canceled chan<- struct{},
+	release <-chan struct{},
+) string {
 	t.Helper()
-
-	tempDir := t.TempDir()
-	sourcePath := filepath.Join(tempDir, "Example.Release.2026.1080p-GRP.mkv")
-	if err := os.WriteFile(sourcePath, []byte("example"), 0o600); err != nil {
-		t.Fatalf("write source fixture: %v", err)
+	if backend.jobEngine == nil {
+		backend.jobEngine = sharedjobs.New(webJobSink{hub: backend.hub}, sharedjobs.Config{})
 	}
-	repoPath := filepath.Join(tempDir, "upbrr.db")
-	repo, err := db.OpenWithLogger(repoPath, api.NopLogger{})
+	owner, err := backend.ensureJobOwner(ownerID)
 	if err != nil {
-		t.Fatalf("open repo: %v", err)
+		t.Fatalf("ensure owner: %v", err)
 	}
-	if err := repo.Migrate(); err != nil {
-		_ = repo.Close()
-		t.Fatalf("migrate repo: %v", err)
-	}
-
-	backend := &Backend{
-		cfg: config.Config{
-			MainSettings:       config.MainSettingsConfig{DBPath: repoPath, TMDBAPI: "x"},
-			ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
-		},
-		repo:  repo,
-		dupes: make(map[string]*dupeCheckJob),
-		hub:   newEventHub(),
-	}
-	t.Cleanup(func() {
-		backend.stopAllDupeJobs()
-		_ = repo.Close()
+	jobID, err := backend.jobEngine.StartUpload(context.Background(), owner, sharedjobs.UploadSpec{
+		CorrelationID: "blocking-upload",
+		Snapshot:      webTestUploadSnapshot("Example.Release.2026.1080p-GRP"),
+		Runner:        blockingUploadRunner{canceled: canceled, release: release},
 	})
-	return backend, sourcePath
-}
-
-func dupeJobCount(backend *Backend) int {
-	backend.dupeMu.Lock()
-	defer backend.dupeMu.Unlock()
-	return len(backend.dupes)
-}
-
-func assertPreparedMetaExportRequest(req api.Request, expected *api.Request) error {
-	if expected == nil {
-		return nil
-	}
-	if !reflect.DeepEqual(req.Paths, expected.Paths) {
-		return fmt.Errorf("metadata preview cache request paths: got %#v want %#v", req.Paths, expected.Paths)
-	}
-	if req.Mode != expected.Mode {
-		return fmt.Errorf("metadata preview cache request mode: got %q want %q", req.Mode, expected.Mode)
-	}
-	if !reflect.DeepEqual(req.Trackers, expected.Trackers) {
-		return fmt.Errorf("metadata preview cache request trackers: got %#v want %#v", req.Trackers, expected.Trackers)
-	}
-	if !reflect.DeepEqual(req.ExternalIDOverrides, expected.ExternalIDOverrides) {
-		return fmt.Errorf("metadata preview cache request external overrides: got %#v want %#v", req.ExternalIDOverrides, expected.ExternalIDOverrides)
-	}
-	if !reflect.DeepEqual(req.ReleaseNameOverrides, expected.ReleaseNameOverrides) {
-		return fmt.Errorf("metadata preview cache request name overrides: got %#v want %#v", req.ReleaseNameOverrides, expected.ReleaseNameOverrides)
+	if err != nil {
+		t.Fatalf("start blocking upload: %v", err)
 	}
-	return nil
+	return jobID
 }
 
-func assertSnapshotHasNoActiveTrackerStates(t *testing.T, snapshot TrackerUploadSnapshot) {
+func installBlockingDupeJob(
+	t *testing.T,
+	backend *Backend,
+	ownerID string,
+	canceled chan<- struct{},
+	release <-chan struct{},
+) string {
 	t.Helper()
-	if snapshot.Status != "canceled" {
-		t.Fatalf("expected canceled snapshot status, got %q", snapshot.Status)
+	if backend.jobEngine == nil {
+		backend.jobEngine = sharedjobs.New(webJobSink{hub: backend.hub}, sharedjobs.Config{})
 	}
-	for _, tracker := range snapshot.Trackers {
-		if tracker.Status == "queued" || tracker.Status == "running" {
-			t.Fatalf("expected snapshot tracker %s terminal, got %q", tracker.Tracker, tracker.Status)
-		}
-	}
-}
-
-func TestSeedRunCorePreparedMetaCopiesPreparedMetadata(t *testing.T) {
-	source := &preparedMetaTestCore{
-		exportFound:  true,
-		exportedMeta: api.PreparedMetadata{SourcePath: "C:\\releases\\movie.mkv"},
-	}
-	target := &preparedMetaTestCore{}
-	req := api.Request{
-		Paths: []string{"C:\\releases\\movie.mkv"},
-		Mode:  api.ModeGUI,
-	}
-
-	if err := guishared.SeedRunCorePreparedMeta(context.Background(), source, target, req); err != nil {
-		t.Fatalf("seed run core prepared meta: %v", err)
-	}
-	if target.importedMeta.SourcePath != "C:\\releases\\movie.mkv" {
-		t.Fatalf("expected imported source path, got %q", target.importedMeta.SourcePath)
-	}
-	if len(target.importedReq.Paths) != 1 || target.importedReq.Paths[0] != "C:\\releases\\movie.mkv" {
-		t.Fatalf("expected import request paths to be preserved, got %#v", target.importedReq.Paths)
-	}
-}
-
-func TestSeedRunCorePreparedMetaSkipsWhenNoCacheFound(t *testing.T) {
-	source := &preparedMetaTestCore{}
-	target := &preparedMetaTestCore{}
-
-	if err := guishared.SeedRunCorePreparedMeta(context.Background(), source, target, api.Request{
-		Paths: []string{"C:\\releases\\movie.mkv"},
-		Mode:  api.ModeGUI,
-	}); err != nil {
-		t.Fatalf("seed run core prepared meta: %v", err)
+	owner, err := backend.ensureJobOwner(ownerID)
+	if err != nil {
+		t.Fatalf("ensure owner: %v", err)
 	}
-	if target.importedMeta.SourcePath != "" {
-		t.Fatalf("expected no metadata import when cache missing, got %#v", target.importedMeta)
+	jobID, err := backend.jobEngine.StartDupe(context.Background(), owner, sharedjobs.DupeSpec{
+		CorrelationID: "blocking-dupe",
+		Snapshot:      webTestDupeSnapshot("Example.Release.2026.1080p-GRP"),
+		Runner:        blockingDupeRunner{canceled: canceled, release: release},
+	})
+	if err != nil {
+		t.Fatalf("start blocking dupe: %v", err)
 	}
+	return jobID
 }
diff --git a/internal/webserver/native_picker.go b/internal/webserver/native_picker.go
deleted file mode 100644
index 285e16c7..00000000
--- a/internal/webserver/native_picker.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package webserver
-
-type nativePicker interface {
-	BrowseFile() (string, error)
-	BrowseImageFiles() ([]string, error)
-	BrowseFolder() (string, error)
-}
diff --git a/internal/webserver/native_picker_nonwindows.go b/internal/webserver/native_picker_nonwindows.go
deleted file mode 100644
index e9e43bb4..00000000
--- a/internal/webserver/native_picker_nonwindows.go
+++ /dev/null
@@ -1,28 +0,0 @@
-//go:build !windows
-
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package webserver
-
-import "errors"
-
-type unsupportedNativePicker struct{}
-
-var errNativeBrowseWindowsOnly = errors.New("native browse is only available on Windows")
-
-func newNativePicker() nativePicker {
-	return unsupportedNativePicker{}
-}
-
-func (unsupportedNativePicker) BrowseFile() (string, error) {
-	return "", errNativeBrowseWindowsOnly
-}
-
-func (unsupportedNativePicker) BrowseImageFiles() ([]string, error) {
-	return nil, errNativeBrowseWindowsOnly
-}
-
-func (unsupportedNativePicker) BrowseFolder() (string, error) {
-	return "", errNativeBrowseWindowsOnly
-}
diff --git a/internal/webserver/native_picker_windows.go b/internal/webserver/native_picker_windows.go
deleted file mode 100644
index 008d626e..00000000
--- a/internal/webserver/native_picker_windows.go
+++ /dev/null
@@ -1,168 +0,0 @@
-//go:build windows
-
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package webserver
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os/exec"
-	"strings"
-	"unicode/utf16"
-	"unicode/utf8"
-
-	"github.com/autobrr/upbrr/internal/filesystem"
-)
-
-type powershellNativePicker struct{}
-
-func newNativePicker() nativePicker {
-	return powershellNativePicker{}
-}
-
-func (powershellNativePicker) BrowseFile() (string, error) {
-	filterPattern := videoFilePickerFilterPattern()
-	return runPickerScript(fmt.Sprintf(`
-Add-Type -AssemblyName System.Windows.Forms
-$dialog = New-Object System.Windows.Forms.OpenFileDialog
-$dialog.Title = 'Select a file'
-$dialog.Filter = 'Video files (%[1]s)|%[1]s'
-if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
-  [Console]::Out.Write($dialog.FileName)
-}
-`, filterPattern))
-}
-
-func (powershellNativePicker) BrowseImageFiles() ([]string, error) {
-	output, err := runPickerScript(`
-Add-Type -AssemblyName System.Windows.Forms
-$dialog = New-Object System.Windows.Forms.OpenFileDialog
-$dialog.Title = 'Select images'
-$dialog.Filter = 'Image files (*.png;*.jpg;*.jpeg;*.webp)|*.png;*.jpg;*.jpeg;*.webp|All files (*.*)|*.*'
-$dialog.Multiselect = $true
-if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
-  [Console]::Out.Write(($dialog.FileNames -join [Environment]::NewLine))
-}
-`)
-	if err != nil {
-		return nil, err
-	}
-	var paths []string
-	for line := range strings.SplitSeq(output, "\n") {
-		trimmed := strings.TrimSpace(line)
-		if trimmed != "" {
-			paths = append(paths, trimmed)
-		}
-	}
-	return paths, nil
-}
-
-func (powershellNativePicker) BrowseFolder() (string, error) {
-	return runPickerScript(`
-Add-Type -AssemblyName System.Windows.Forms
-$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
-$dialog.Description = 'Select a folder'
-$dialog.ShowNewFolderButton = $false
-if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
-  [Console]::Out.Write($dialog.SelectedPath)
-}
-`)
-}
-
-func runPickerScript(script string) (string, error) {
-	wrapped := strings.TrimSpace(`
-$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
-` + "\n" + script)
-
-	cmd := exec.CommandContext(
-		context.Background(),
-		"powershell",
-		"-NoLogo",
-		"-NoProfile",
-		"-NonInteractive",
-		"-STA",
-		"-Command",
-		wrapped,
-	)
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	if err := cmd.Run(); err != nil {
-		message := strings.TrimSpace(stderr.String())
-		if message == "" {
-			message = err.Error()
-		}
-		return "", fmt.Errorf("native browse failed: %s", message)
-	}
-	return decodePickerOutput(stdout.Bytes()), nil
-}
-
-func videoFilePickerFilterPattern() string {
-	extensions := filesystem.SupportedVideoExtensions()
-	patterns := make([]string, 0, len(extensions))
-	for _, ext := range extensions {
-		patterns = append(patterns, "*"+ext)
-	}
-	return strings.Join(patterns, ";")
-}
-
-func decodePickerOutput(raw []byte) string {
-	trimmed := bytes.TrimSpace(raw)
-	if len(trimmed) == 0 {
-		return ""
-	}
-
-	if utf8.Valid(trimmed) {
-		return strings.TrimSpace(string(trimmed))
-	}
-
-	if len(trimmed) >= 2 {
-		if trimmed[0] == 0xFF && trimmed[1] == 0xFE {
-			if decoded, ok := decodeUTF16(trimmed[2:], true); ok {
-				return decoded
-			}
-		}
-		if trimmed[0] == 0xFE && trimmed[1] == 0xFF {
-			if decoded, ok := decodeUTF16(trimmed[2:], false); ok {
-				return decoded
-			}
-		}
-	}
-
-	if decoded, ok := decodeUTF16(trimmed, true); ok {
-		return decoded
-	}
-	if decoded, ok := decodeUTF16(trimmed, false); ok {
-		return decoded
-	}
-
-	return strings.TrimSpace(string(trimmed))
-}
-
-func decodeUTF16(raw []byte, littleEndian bool) (string, bool) {
-	if len(raw) < 2 || len(raw)%2 != 0 {
-		return "", false
-	}
-
-	u16 := make([]uint16, 0, len(raw)/2)
-	for i := 0; i < len(raw); i += 2 {
-		if littleEndian {
-			u16 = append(u16, uint16(raw[i])|uint16(raw[i+1])<<8)
-		} else {
-			u16 = append(u16, uint16(raw[i])<<8|uint16(raw[i+1]))
-		}
-	}
-
-	decoded := strings.TrimSpace(string(utf16.Decode(u16)))
-	if decoded == "" {
-		return "", false
-	}
-	if strings.ContainsRune(decoded, '\uFFFD') {
-		return "", false
-	}
-	return decoded, true
-}
diff --git a/internal/webserver/native_picker_windows_test.go b/internal/webserver/native_picker_windows_test.go
deleted file mode 100644
index 613ac4a4..00000000
--- a/internal/webserver/native_picker_windows_test.go
+++ /dev/null
@@ -1,31 +0,0 @@
-//go:build windows
-
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package webserver
-
-import "testing"
-
-func TestDecodePickerOutputUTF8(t *testing.T) {
-	input := []byte("D:\\Movies\\Example Movie 2026 2160p AUS UHD Blu-ray DV HDR HEVC DTS-HD MA 5.1-GRP\u2122")
-	got := decodePickerOutput(input)
-	want := "D:\\Movies\\Example Movie 2026 2160p AUS UHD Blu-ray DV HDR HEVC DTS-HD MA 5.1-GRP\u2122"
-	if got != want {
-		t.Fatalf("expected %q, got %q", want, got)
-	}
-}
-
-func TestDecodePickerOutputUTF16LEBOM(t *testing.T) {
-	path := "D:\\Movies\\Example Movie 2026 2160p AUS UHD Blu-ray DV HDR HEVC DTS-HD MA 5.1-GRP\u2122"
-	bytes := []byte{0xFF, 0xFE}
-	for _, r := range path {
-		if r <= 0xFFFF {
-			bytes = append(bytes, byte(r), byte(r>>8))
-		}
-	}
-	got := decodePickerOutput(bytes)
-	if got != path {
-		t.Fatalf("expected %q, got %q", path, got)
-	}
-}
diff --git a/internal/webserver/preparation_progress_test.go b/internal/webserver/preparation_progress_test.go
new file mode 100644
index 00000000..9295ce66
--- /dev/null
+++ b/internal/webserver/preparation_progress_test.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type cancellationAwarePlaylistCapability struct {
+	observed chan error
+}
+
+func (c cancellationAwarePlaylistCapability) DiscoverPlaylists(ctx context.Context, _ string) ([]api.PlaylistInfo, error) {
+	if err := ctx.Err(); err != nil {
+		c.observed <- err
+		return nil, fmt.Errorf("discover playlists canceled: %w", err)
+	}
+	return nil, nil
+}
+
+func TestPreparationProgressBoundaryCorrelatesAndSanitizesEvents(t *testing.T) {
+	hub := newEventHub()
+	backend := &Backend{hub: hub}
+	events, unsubscribe := hub.Subscribe("session-1")
+	t.Cleanup(unsubscribe)
+
+	ctx, err := backend.withPreparationProgress(context.Background(), "session-1", "attempt-1")
+	if err != nil {
+		t.Fatalf("create preparation progress context: %v", err)
+	}
+	api.EmitPreparationProgress(ctx, api.NewPreparationProgressUpdate(
+		api.PreparationPhaseClientDiscovery,
+		api.PreparationProgressRunning,
+		`source=C:\media\Example.Release.2026.1080p-GRP api_key=synthetic-secret`,
+	))
+
+	select {
+	case event := <-events:
+		if event.Name != "preparation:progress" {
+			t.Fatalf("event name=%q", event.Name)
+		}
+		var update api.PreparationProgressUpdate
+		if err := json.Unmarshal(event.Data, &update); err != nil {
+			t.Fatalf("decode preparation progress: %v", err)
+		}
+		if update.CorrelationID != "attempt-1" || update.Timestamp == "" {
+			t.Fatal("preparation event is missing correlation or timestamp")
+		}
+		if strings.Contains(update.Message, "synthetic-secret") || strings.Contains(update.Message, `C:\media`) {
+			t.Fatal("preparation event exposed sensitive or local-path detail")
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("timed out waiting for preparation event")
+	}
+}
+
+func TestPreparationProgressBoundaryRejectsEmptyCorrelation(t *testing.T) {
+	backend := &Backend{hub: newEventHub()}
+	if _, err := backend.withPreparationProgress(context.Background(), "session-1", " "); err == nil {
+		t.Fatal("empty preparation correlation ID was accepted")
+	}
+}
+
+func TestDiscoverPlaylistsPropagatesRequestCancellation(t *testing.T) {
+	observed := make(chan error, 1)
+	backend := &Backend{
+		capabilities: CoreCapabilities{Playlists: cancellationAwarePlaylistCapability{observed: observed}},
+		hub:          newEventHub(),
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	_, _ = backend.DiscoverPlaylists(ctx, "synthetic-source")
+	select {
+	case err := <-observed:
+		if !errors.Is(err, context.Canceled) {
+			t.Fatal("playlist capability did not receive request cancellation")
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("playlist capability did not observe request cancellation")
+	}
+}
diff --git a/internal/webserver/prepared_meta.go b/internal/webserver/prepared_meta.go
new file mode 100644
index 00000000..05daa02d
--- /dev/null
+++ b/internal/webserver/prepared_meta.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"errors"
+	"reflect"
+)
+
+var (
+	// ErrPreparedGenerationUnavailable reports an incomplete canonical generation bundle.
+	ErrPreparedGenerationUnavailable = errors.New("prepared generation capability unavailable")
+	// ErrPreparedUploadUnavailable reports a bundle missing upload execution or transfer support.
+	ErrPreparedUploadUnavailable = errors.New("prepared upload capability unavailable")
+	// ErrPreparedDupeUnavailable reports a bundle missing dupe execution or transfer support.
+	ErrPreparedDupeUnavailable = errors.New("prepared dupe capability unavailable")
+	// ErrPreparedDVDUnavailable reports a bundle missing DVD execution or transfer support.
+	ErrPreparedDVDUnavailable = errors.New("prepared DVD capability unavailable")
+	// ErrPreparedDryRunUnavailable reports a bundle missing dry-run execution or transfer support.
+	ErrPreparedDryRunUnavailable = errors.New("prepared dry-run capability unavailable")
+)
+
+func capabilityIsNil(capability any) bool {
+	if capability == nil {
+		return true
+	}
+	value := reflect.ValueOf(capability)
+	kind := value.Kind()
+	isNilable := kind == reflect.Chan ||
+		kind == reflect.Func ||
+		kind == reflect.Interface ||
+		kind == reflect.Map ||
+		kind == reflect.Pointer ||
+		kind == reflect.Slice
+	return isNilable && value.IsNil()
+}
diff --git a/internal/webserver/prepared_meta_test.go b/internal/webserver/prepared_meta_test.go
new file mode 100644
index 00000000..4dea51f2
--- /dev/null
+++ b/internal/webserver/prepared_meta_test.go
@@ -0,0 +1,212 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/preparedrelease"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type preparedGenerationStub struct{}
+
+func (preparedGenerationStub) PrepareRelease(_ context.Context, input api.PrepareInput) (api.PrepareResult, error) {
+	return api.PrepareResult{Release: api.PreparedRelease{
+		Generation: 1,
+		Source:     api.SourceManifest{SourcePath: input.SourcePath},
+	}}, nil
+}
+
+func (preparedGenerationStub) ExportReleaseSeed(context.Context, api.ReleaseRef) (preparedrelease.Seed, error) {
+	return preparedrelease.Seed{}, nil
+}
+
+func (preparedGenerationStub) ImportReleaseSeed(context.Context, preparedrelease.Seed) (api.ReleaseRef, error) {
+	return api.ReleaseRef{}, nil
+}
+
+type preparedUploadStub struct{}
+
+func (preparedUploadStub) RunAcceptedUpload(context.Context, api.UploadExecutionPlan) (api.Result, error) {
+	return api.Result{}, nil
+}
+
+type preparedDupeStub struct{}
+
+func (preparedDupeStub) CheckAcceptedDupes(context.Context, api.DuplicateCheckInput) (api.DupeCheckSummary, error) {
+	return api.DupeCheckSummary{}, nil
+}
+
+type preparedDryRunStub struct{}
+
+func (preparedDryRunStub) RunAcceptedTrackerDryRun(context.Context, api.TrackerDryRunPlan) (api.TrackerDryRunPreview, error) {
+	return api.TrackerDryRunPreview{}, nil
+}
+
+type preparedDVDStub struct{}
+
+func (preparedDVDStub) CaptureAcceptedDVDMenus(context.Context, api.MediaPlanInput) (api.DVDMenuCaptureResult, error) {
+	return api.DVDMenuCaptureResult{}, nil
+}
+
+func (preparedDVDStub) ListAcceptedDVDMenuScreenshots(context.Context, api.MediaPlanInput) ([]api.ScreenshotImage, error) {
+	return nil, nil
+}
+
+func (preparedDVDStub) DeleteAcceptedDVDMenuScreenshot(context.Context, api.MediaPlanInput, string) error {
+	return nil
+}
+
+func TestCoreCapabilitiesPreparedOperationReadinessRejectsPartialBundles(t *testing.T) {
+	t.Parallel()
+
+	generationOnly := CoreCapabilities{ReleasePreparation: preparedGenerationStub{}, PreparedGenerationTransfer: preparedGenerationStub{}}
+	if !generationOnly.Available() {
+		t.Fatal("expected generation-only test bundle to remain available")
+	}
+	if generationOnly.PreparedUploadReady() || generationOnly.PreparedDupeReady() || generationOnly.PreparedDVDReady() || generationOnly.PreparedDryRunReady() {
+		t.Fatal("expected generation-only bundle to reject prepared operations")
+	}
+
+	withoutGeneration := CoreCapabilities{
+		UploadExecution:    preparedUploadStub{},
+		DuplicateExecution: preparedDupeStub{},
+		DVD:                preparedDVDStub{},
+		DryRun:             preparedDryRunStub{},
+	}
+	if !withoutGeneration.Available() {
+		t.Fatal("expected workflow-only test bundle to remain available")
+	}
+	if withoutGeneration.PreparedUploadReady() || withoutGeneration.PreparedDupeReady() || withoutGeneration.PreparedDVDReady() {
+		t.Fatal("expected background workflows without generation support to reject prepared operations")
+	}
+	if !withoutGeneration.PreparedDryRunReady() {
+		t.Fatal("expected active-runtime dry run to remain available without generation transfer")
+	}
+
+	complete := withoutGeneration
+	complete.ReleasePreparation = preparedGenerationStub{}
+	complete.PreparedGenerationTransfer = preparedGenerationStub{}
+	if !complete.PreparedUploadReady() || !complete.PreparedDupeReady() || !complete.PreparedDVDReady() || !complete.PreparedDryRunReady() {
+		t.Fatal("expected complete prepared-operation bundle to be ready")
+	}
+}
+
+func TestCoreCapabilitiesPreparedOperationReadinessRejectsTypedNilCapabilities(t *testing.T) {
+	t.Parallel()
+
+	var typedNilGeneration *preparedGenerationStub
+	var typedNilUpload *preparedUploadStub
+	var typedNilDupe *preparedDupeStub
+	var typedNilDVD *preparedDVDStub
+	var typedNilDryRun *preparedDryRunStub
+
+	typedNilOnly := CoreCapabilities{
+		ReleasePreparation:         typedNilGeneration,
+		PreparedGenerationTransfer: typedNilGeneration,
+		DryRun:                     typedNilDryRun,
+		DuplicateExecution:         typedNilDupe,
+		UploadExecution:            typedNilUpload,
+		DVD:                        typedNilDVD,
+	}
+	if typedNilOnly.Available() {
+		t.Fatal("expected typed-nil-only bundle to be unavailable")
+	}
+	if typedNilOnly.PreparedGenerationReady() || typedNilOnly.PreparedUploadReady() || typedNilOnly.PreparedDupeReady() ||
+		typedNilOnly.PreparedDVDReady() || typedNilOnly.PreparedDryRunReady() {
+		t.Fatal("expected typed-nil generation to make every prepared operation unavailable")
+	}
+
+	complete := CoreCapabilities{
+		ReleasePreparation:         preparedGenerationStub{},
+		DryRun:                     preparedDryRunStub{},
+		DuplicateExecution:         preparedDupeStub{},
+		UploadExecution:            preparedUploadStub{},
+		DVD:                        preparedDVDStub{},
+		PreparedGenerationTransfer: preparedGenerationStub{},
+	}
+	tests := []struct {
+		name       string
+		bundle     CoreCapabilities
+		ready      func(CoreCapabilities) bool
+		otherReady []func(CoreCapabilities) bool
+	}{
+		{
+			name: "upload",
+			bundle: func() CoreCapabilities {
+				bundle := complete
+				bundle.UploadExecution = typedNilUpload
+				return bundle
+			}(),
+			ready: CoreCapabilities.PreparedUploadReady,
+			otherReady: []func(CoreCapabilities) bool{
+				CoreCapabilities.PreparedDupeReady,
+				CoreCapabilities.PreparedDVDReady,
+				CoreCapabilities.PreparedDryRunReady,
+			},
+		},
+		{
+			name: "dupe",
+			bundle: func() CoreCapabilities {
+				bundle := complete
+				bundle.DuplicateExecution = typedNilDupe
+				return bundle
+			}(),
+			ready: CoreCapabilities.PreparedDupeReady,
+			otherReady: []func(CoreCapabilities) bool{
+				CoreCapabilities.PreparedUploadReady,
+				CoreCapabilities.PreparedDVDReady,
+				CoreCapabilities.PreparedDryRunReady,
+			},
+		},
+		{
+			name: "DVD",
+			bundle: func() CoreCapabilities {
+				bundle := complete
+				bundle.DVD = typedNilDVD
+				return bundle
+			}(),
+			ready: CoreCapabilities.PreparedDVDReady,
+			otherReady: []func(CoreCapabilities) bool{
+				CoreCapabilities.PreparedUploadReady,
+				CoreCapabilities.PreparedDupeReady,
+				CoreCapabilities.PreparedDryRunReady,
+			},
+		},
+		{
+			name: "dry run",
+			bundle: func() CoreCapabilities {
+				bundle := complete
+				bundle.DryRun = typedNilDryRun
+				return bundle
+			}(),
+			ready: CoreCapabilities.PreparedDryRunReady,
+			otherReady: []func(CoreCapabilities) bool{
+				CoreCapabilities.PreparedUploadReady,
+				CoreCapabilities.PreparedDupeReady,
+				CoreCapabilities.PreparedDVDReady,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if tt.ready(tt.bundle) {
+				t.Fatal("expected typed-nil operation capability to be unavailable")
+			}
+			for _, ready := range tt.otherReady {
+				if !ready(tt.bundle) {
+					t.Fatal("expected valid sibling operation capability to remain ready")
+				}
+			}
+			if !tt.bundle.Available() {
+				t.Fatal("expected valid partial bundle capabilities to remain available")
+			}
+		})
+	}
+}
diff --git a/internal/webserver/review_registry.go b/internal/webserver/review_registry.go
new file mode 100644
index 00000000..1803654e
--- /dev/null
+++ b/internal/webserver/review_registry.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/webserver/jobs"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+const uploadReviewLifetime = 30 * time.Minute
+
+var (
+	// ErrUploadReviewNotFound intentionally covers unknown, expired, consumed,
+	// and foreign-owner tokens without revealing token existence.
+	ErrUploadReviewNotFound = errors.New("upload review not found")
+)
+
+// UploadReviewSnapshot is the owner-scoped handoff from review to execution.
+type UploadReviewSnapshot struct {
+	Execution jobs.UploadExecutionSnapshot
+	Review    api.UploadReview
+}
+
+type uploadReviewEntry struct {
+	owner     string
+	expiresAt time.Time
+	snapshot  UploadReviewSnapshot
+}
+
+// UploadReviewRegistry issues opaque, single-use, owner-scoped review tokens.
+type UploadReviewRegistry struct {
+	mu      sync.Mutex
+	entries map[string]uploadReviewEntry
+	now     func() time.Time
+}
+
+// NewUploadReviewRegistry constructs an empty registry.
+func NewUploadReviewRegistry() *UploadReviewRegistry {
+	return &UploadReviewRegistry{
+		entries: make(map[string]uploadReviewEntry),
+		now:     func() time.Time { return time.Now().UTC() },
+	}
+}
+
+// Issue stores an immutable snapshot and returns an unguessable token.
+func (r *UploadReviewRegistry) Issue(owner string, snapshot UploadReviewSnapshot) (string, error) {
+	owner = strings.TrimSpace(owner)
+	if r == nil || owner == "" {
+		return "", errors.New("upload review owner is required")
+	}
+	if err := validateUploadReviewSnapshot(snapshot); err != nil {
+		return "", err
+	}
+	cloned, err := cloneUploadReviewSnapshot(snapshot)
+	if err != nil {
+		return "", err
+	}
+	token, err := newUploadReviewToken()
+	if err != nil {
+		return "", fmt.Errorf("create upload review token: %w", err)
+	}
+	cloned.Execution.ReviewToken = token
+	r.mu.Lock()
+	r.initializeLocked()
+	now := r.now().UTC()
+	r.pruneLocked(now)
+	r.entries[token] = uploadReviewEntry{
+		owner:     owner,
+		expiresAt: now.Add(uploadReviewLifetime),
+		snapshot:  cloned,
+	}
+	r.mu.Unlock()
+	return token, nil
+}
+
+// Consume returns and deletes one snapshot. Foreign-owner, expired, and
+// already-consumed tokens have the same result.
+func (r *UploadReviewRegistry) Consume(owner string, token string) (UploadReviewSnapshot, error) {
+	owner = strings.TrimSpace(owner)
+	token = strings.TrimSpace(token)
+	if r == nil || owner == "" || token == "" {
+		return UploadReviewSnapshot{}, ErrUploadReviewNotFound
+	}
+	r.mu.Lock()
+	r.initializeLocked()
+	now := r.now().UTC()
+	r.pruneLocked(now)
+	entry, ok := r.entries[token]
+	if !ok || entry.owner != owner {
+		r.mu.Unlock()
+		return UploadReviewSnapshot{}, ErrUploadReviewNotFound
+	}
+	delete(r.entries, token)
+	r.mu.Unlock()
+	cloned, err := cloneUploadReviewSnapshot(entry.snapshot)
+	if err != nil {
+		return UploadReviewSnapshot{}, fmt.Errorf("clone upload review snapshot: %w", err)
+	}
+	return cloned, nil
+}
+
+// PurgeOwner removes unconsumed reviews when an owner/session ends.
+func (r *UploadReviewRegistry) PurgeOwner(owner string) {
+	if r == nil {
+		return
+	}
+	owner = strings.TrimSpace(owner)
+	r.mu.Lock()
+	for token, entry := range r.entries {
+		if entry.owner == owner {
+			delete(r.entries, token)
+		}
+	}
+	r.mu.Unlock()
+}
+
+func (r *UploadReviewRegistry) initializeLocked() {
+	if r.entries == nil {
+		r.entries = make(map[string]uploadReviewEntry)
+	}
+	if r.now == nil {
+		r.now = func() time.Time { return time.Now().UTC() }
+	}
+}
+
+func (r *UploadReviewRegistry) pruneLocked(now time.Time) {
+	for token, entry := range r.entries {
+		if !entry.expiresAt.After(now) {
+			delete(r.entries, token)
+		}
+	}
+}
+
+func validateUploadReviewSnapshot(snapshot UploadReviewSnapshot) error {
+	execution := snapshot.Execution
+	if execution.PreparedGeneration == 0 || execution.RuntimeGeneration == 0 || execution.Input.Release.Generation == 0 ||
+		execution.PreparedGeneration != execution.Input.Release.Generation || strings.TrimSpace(execution.Input.Release.SourcePath) == "" {
+		return errors.New("upload review snapshot has invalid generation lineage")
+	}
+	return nil
+}
+
+func cloneUploadReviewSnapshot(snapshot UploadReviewSnapshot) (UploadReviewSnapshot, error) {
+	type clonePayload struct {
+		Input   api.UploadReviewInput
+		Outcome api.UploadReviewOutcome
+		Review  api.UploadReview
+	}
+	payload, err := json.Marshal(clonePayload{
+		Input:   snapshot.Execution.Input,
+		Outcome: snapshot.Execution.Outcome,
+		Review:  snapshot.Review,
+	})
+	if err != nil {
+		return UploadReviewSnapshot{}, fmt.Errorf("clone upload review snapshot: marshal: %w", err)
+	}
+	var cloned clonePayload
+	if err := json.Unmarshal(payload, &cloned); err != nil {
+		return UploadReviewSnapshot{}, fmt.Errorf("clone upload review snapshot: unmarshal: %w", err)
+	}
+	snapshot.Execution.Input = cloned.Input
+	snapshot.Execution.Outcome = cloned.Outcome
+	snapshot.Review = cloned.Review
+	return snapshot, nil
+}
+
+func newUploadReviewToken() (string, error) {
+	var bytes [32]byte
+	if _, err := rand.Read(bytes[:]); err != nil {
+		return "", fmt.Errorf("generate upload review token: %w", err)
+	}
+	return base64.RawURLEncoding.EncodeToString(bytes[:]), nil
+}
diff --git a/internal/webserver/review_registry_test.go b/internal/webserver/review_registry_test.go
new file mode 100644
index 00000000..e100a8e8
--- /dev/null
+++ b/internal/webserver/review_registry_test.go
@@ -0,0 +1,53 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/webserver/jobs"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestUploadReviewRegistryOwnerScopeSingleUseAndCopies(t *testing.T) {
+	t.Parallel()
+	registry := NewUploadReviewRegistry()
+	snapshot := UploadReviewSnapshot{
+		Execution: jobs.UploadExecutionSnapshot{
+			PreparedGeneration: 7,
+			RuntimeGeneration:  11,
+			Input: api.UploadReviewInput{
+				Release:  api.ReleaseRef{SourcePath: `C:\Example\Example.Release.2026.1080p-GRP.mkv`, Generation: 7},
+				Trackers: []string{"EXAMPLE"},
+			},
+		},
+		Review: api.UploadReview{Trackers: []api.TrackerReview{{Tracker: "EXAMPLE"}}},
+	}
+	token, err := registry.Issue("owner-a", snapshot)
+	if err != nil {
+		t.Fatalf("Issue: %v", err)
+	}
+	snapshot.Execution.Input.Trackers[0] = "MUTATED"
+	if _, err := registry.Consume("owner-b", token); !errors.Is(err, ErrUploadReviewNotFound) {
+		t.Fatalf("foreign Consume error = %v", err)
+	}
+	consumed, err := registry.Consume("owner-a", token)
+	if err != nil {
+		t.Fatalf("Consume: %v", err)
+	}
+	if consumed.Execution.Input.Trackers[0] != "EXAMPLE" || consumed.Review.Trackers[0].Tracker != "EXAMPLE" {
+		t.Fatalf("snapshot was not isolated: %#v", consumed)
+	}
+	if _, err := registry.Consume("owner-a", token); !errors.Is(err, ErrUploadReviewNotFound) {
+		t.Fatalf("second Consume error = %v", err)
+	}
+}
+
+func TestUploadReviewRegistryRejectsMissingLineage(t *testing.T) {
+	t.Parallel()
+	if _, err := NewUploadReviewRegistry().Issue("owner", UploadReviewSnapshot{}); err == nil {
+		t.Fatal("expected invalid lineage error")
+	}
+}
diff --git a/internal/webserver/routes.go b/internal/webserver/routes.go
index 53ea457c..be47d593 100644
--- a/internal/webserver/routes.go
+++ b/internal/webserver/routes.go
@@ -307,7 +307,6 @@ func (s *Server) handleAuthStatus(w http.ResponseWriter, r *http.Request, _ sess
 			"needsSetup":              false,
 			"username":                current.Username,
 			"csrfToken":               current.CSRFToken,
-			"nativeBrowseEnabled":     s.nativeBrowseAvailable(r),
 			"caseInsensitivePaths":    runtime.GOOS == "windows",
 			"browseRoot":              "",
 			"allowUnrestrictedBrowse": true,
@@ -322,13 +321,11 @@ func (s *Server) handleAuthStatus(w http.ResponseWriter, r *http.Request, _ sess
 		return
 	}
 	current, ok := s.currentSession(r)
-	browseAvailable := s.nativeBrowseAvailable(r)
 	payload := map[string]any{
 		"authenticated":           ok,
 		"needsSetup":              !exists,
 		"username":                "",
 		"csrfToken":               "",
-		"nativeBrowseEnabled":     browseAvailable,
 		"caseInsensitivePaths":    runtime.GOOS == "windows",
 		"browseRoot":              "",
 		"allowUnrestrictedBrowse": false,
@@ -391,7 +388,6 @@ func (s *Server) handleBootstrap(w http.ResponseWriter, r *http.Request, _ sessi
 		"needsSetup":              false,
 		"username":                current.Username,
 		"csrfToken":               current.CSRFToken,
-		"nativeBrowseEnabled":     s.nativeBrowseAvailable(r),
 		"caseInsensitivePaths":    runtime.GOOS == "windows",
 		"browseRoot":              "",
 		"allowUnrestrictedBrowse": false,
@@ -502,7 +498,6 @@ func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request, _ session)
 		"needsSetup":              false,
 		"username":                current.Username,
 		"csrfToken":               current.CSRFToken,
-		"nativeBrowseEnabled":     s.nativeBrowseAvailable(r),
 		"caseInsensitivePaths":    runtime.GOOS == "windows",
 		"browseRoot":              joinBrowsePolicyRoots(browseRoots),
 		"allowUnrestrictedBrowse": record.AllowUnrestrictedBrowse,
@@ -522,6 +517,7 @@ func (s *Server) handleLogout(w http.ResponseWriter, r *http.Request, current se
 	}
 	if s.backend != nil {
 		s.backend.StopSessionLogStreams(current.ID)
+		s.backend.removeJobOwner(current.ID)
 	}
 	if cookie, err := r.Cookie(sessionCookieName); err == nil && cookie.Value == current.ID {
 		//nolint:gosec // Session clear cookie sets HttpOnly, SameSite, and Secure for HTTPS requests.
@@ -558,7 +554,11 @@ func (s *Server) handleBrowsePolicy(w http.ResponseWriter, r *http.Request, curr
 		return
 	}
 	if !req.AllowUnrestrictedBrowse && len(roots) == 0 {
-		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "at least one browse root is required unless unrestricted browsing is explicitly allowed"})
+		writeJSON(
+			w,
+			http.StatusBadRequest,
+			map[string]string{"error": "at least one browse root is required unless unrestricted browsing is explicitly allowed"},
+		)
 		return
 	}
 
@@ -583,7 +583,6 @@ func (s *Server) handleBrowsePolicy(w http.ResponseWriter, r *http.Request, curr
 		"needsSetup":              false,
 		"username":                current.Username,
 		"csrfToken":               current.CSRFToken,
-		"nativeBrowseEnabled":     s.nativeBrowseAvailable(r),
 		"caseInsensitivePaths":    runtime.GOOS == "windows",
 		"browseRoot":              joinBrowsePolicyRoots(roots),
 		"allowUnrestrictedBrowse": req.AllowUnrestrictedBrowse,
@@ -827,6 +826,12 @@ func (s *Server) requireSession(next func(http.ResponseWriter, *http.Request, se
 			writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "authentication required"})
 			return
 		}
+		if s.backend != nil {
+			if _, err := s.backend.ensureJobOwner(current.ID); err != nil {
+				writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "job runtime unavailable"})
+				return
+			}
+		}
 		if r.Method != http.MethodGet && r.Method != http.MethodHead && r.Method != http.MethodOptions {
 			if !s.verifySameOrigin(r, current) || !s.verifyCSRF(r, current) {
 				writeJSON(w, http.StatusForbidden, map[string]string{"error": "csrf validation failed"})
@@ -934,6 +939,7 @@ func (s *Server) allowGeneralRequest(r *http.Request) bool {
 	return s.generalLimiter.Allow(s.clientIP(r))
 }
 
+// verifyCSRF requires the request header token to match the cookie-bound session.
 func (s *Server) verifyCSRF(r *http.Request, current session) bool {
 	token := strings.TrimSpace(r.Header.Get("X-Csrf-Token"))
 	if token == "" {
@@ -942,6 +948,8 @@ func (s *Server) verifyCSRF(r *http.Request, current session) bool {
 	return token == current.CSRFToken
 }
 
+// verifySameOrigin accepts an exact Origin or Referer host match. Development
+// no-auth sessions additionally permit requests between loopback hosts.
 func (s *Server) verifySameOrigin(r *http.Request, current session) bool {
 	origin := strings.TrimSpace(r.Header.Get("Origin"))
 	if origin == "" {
@@ -971,6 +979,8 @@ func isLoopbackHostPort(host string) bool {
 	return isLoopbackHostname(strings.Trim(trimmed, "[]"))
 }
 
+// clientIP trusts the first X-Forwarded-For value only when RemoteAddr belongs
+// to a configured trusted proxy.
 func (s *Server) clientIP(r *http.Request) string {
 	ip := ipFromAddr(r.RemoteAddr)
 	if !s.isTrustedProxy(net.ParseIP(ip)) {
@@ -983,13 +993,6 @@ func (s *Server) clientIP(r *http.Request) string {
 	return forwarded
 }
 
-func (s *Server) nativeBrowseAvailable(r *http.Request) bool {
-	if s == nil || s.picker == nil || r == nil {
-		return false
-	}
-	return s.isLocalWebUIRequest(r)
-}
-
 func (s *Server) isLocalWebUIRequest(r *http.Request) bool {
 	if r == nil {
 		return false
@@ -1022,6 +1025,8 @@ func isLoopbackHostname(host string) bool {
 	return ip != nil && ip.IsLoopback()
 }
 
+// requestScheme honors an explicit HTTPS request URL, trusts
+// X-Forwarded-Proto only from a configured proxy, then falls back to TLS state.
 func (s *Server) requestScheme(r *http.Request) string {
 	if strings.EqualFold(r.URL.Scheme, "https") {
 		return "https"
diff --git a/internal/webserver/routes_auth_test.go b/internal/webserver/routes_auth_test.go
index 5d7be090..0f0e6a85 100644
--- a/internal/webserver/routes_auth_test.go
+++ b/internal/webserver/routes_auth_test.go
@@ -7,12 +7,12 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -548,7 +548,6 @@ func TestDevelopmentNoAuthStatusBypassesMissingAuthOnLoopback(t *testing.T) {
 			CSRFToken: "dev-csrf",
 			ExpiresAt: time.Now().UTC().Add(time.Hour),
 		},
-		picker: &stubNativePicker{},
 	}
 
 	req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/auth/status", nil)
@@ -791,7 +790,6 @@ func TestLogoutRejectsMismatchedCSRFAndCookieSession(t *testing.T) {
 func TestRetainedSessionCanAccessAppRouteAfterRestart(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "state", "db.sqlite")
 	server := newAuthTestServer(t, dbPath)
-	server.picker = &stubNativePicker{filePath: `C:\Media\movie.mkv`}
 
 	current, err := server.sessions.Create("admin", true)
 	if err != nil {
@@ -800,12 +798,11 @@ func TestRetainedSessionCanAccessAppRouteAfterRestart(t *testing.T) {
 	server.sessions.Close()
 
 	reloaded := newAuthTestServer(t, dbPath)
-	reloaded.picker = &stubNativePicker{filePath: `C:\Media\movie.mkv`}
 
 	mux := http.NewServeMux()
 	reloaded.registerAppRoutes(mux)
 
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/BrowseFile", strings.NewReader(`{}`))
+	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/GetApplicationInfo", strings.NewReader(`{}`))
 	req.Host = "127.0.0.1:7480"
 	req.RemoteAddr = "127.0.0.1:5000"
 	req.Header.Set("Content-Type", "application/json")
@@ -824,20 +821,11 @@ func TestRetainedSessionCanAccessAppRouteAfterRestart(t *testing.T) {
 func TestTrackerAuthBackendUsesRequestContext(t *testing.T) {
 	t.Parallel()
 
-	var requests atomic.Int32
-	trackerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests.Add(1)
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`<input name="token" value="abcdefghijklmnop">authkey=abcdefghijklmnopqrstuvwxyzABCDEF`))
-	}))
-	t.Cleanup(trackerServer.Close)
-
 	backend := &Backend{
 		cfg: config.Config{
 			Trackers: config.TrackersConfig{
 				Trackers: map[string]config.TrackerConfig{
 					"MTV": {
-						URL:      trackerServer.URL,
 						Username: "user",
 						Password: "pass",
 					},
@@ -852,9 +840,6 @@ func TestTrackerAuthBackendUsesRequestContext(t *testing.T) {
 	if err != nil {
 		t.Fatalf("TestTrackerAuth: %v", err)
 	}
-	if requests.Load() != 0 {
-		t.Fatalf("expected canceled context to prevent remote auth request, got %d request(s)", requests.Load())
-	}
 	if !strings.Contains(status.LastError, "context canceled") {
 		t.Fatalf("expected context canceled status, got %#v", status)
 	}
@@ -1072,23 +1057,15 @@ func TestCancelDupeCheckRequiresPost(t *testing.T) {
 	}
 
 	canceled := make(chan struct{}, 1)
-	server.backend.dupes = map[string]*dupeCheckJob{
-		"job-1": {
-			sessionID: current.ID,
-			id:        "job-1",
-			cancel: func() {
-				select {
-				case canceled <- struct{}{}:
-				default:
-				}
-			},
-		},
-	}
+	release := make(chan struct{})
+	jobID := installBlockingDupeJob(t, server.backend, current.ID, canceled, release)
+	t.Cleanup(func() { close(release) })
+	body := fmt.Sprintf(`{"JobID":%q}`, jobID)
 
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	getReq := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/app/CancelDupeCheck", strings.NewReader(`{"JobID":"job-1"}`))
+	getReq := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/app/CancelDupeCheck", strings.NewReader(body))
 	getReq.Header.Set("Content-Type", "application/json")
 	getReq.AddCookie(&http.Cookie{Name: sessionCookieName, Value: current.ID})
 	getRecorder := httptest.NewRecorder()
@@ -1104,7 +1081,7 @@ func TestCancelDupeCheckRequiresPost(t *testing.T) {
 	default:
 	}
 
-	postReq := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/CancelDupeCheck", strings.NewReader(`{"JobID":"job-1"}`))
+	postReq := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/CancelDupeCheck", strings.NewReader(body))
 	postReq.Host = "127.0.0.1:7480"
 	postReq.Header.Set("Content-Type", "application/json")
 	postReq.Header.Set("Origin", "http://127.0.0.1:7480")
@@ -1133,23 +1110,15 @@ func TestCancelTrackerUploadRequiresPost(t *testing.T) {
 	}
 
 	canceled := make(chan struct{}, 1)
-	server.backend.uploads = map[string]*trackerUploadJob{
-		"job-1": {
-			id:        "job-1",
-			sessionID: current.ID,
-			cancel: func() {
-				select {
-				case canceled <- struct{}{}:
-				default:
-				}
-			},
-		},
-	}
+	release := make(chan struct{})
+	jobID := installBlockingUploadJob(t, server.backend, current.ID, canceled, release)
+	t.Cleanup(func() { close(release) })
+	body := fmt.Sprintf(`{"JobID":%q}`, jobID)
 
 	mux := http.NewServeMux()
 	server.registerAppRoutes(mux)
 
-	getReq := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/app/CancelTrackerUpload", strings.NewReader(`{"JobID":"job-1"}`))
+	getReq := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/app/CancelTrackerUpload", strings.NewReader(body))
 	getReq.Header.Set("Content-Type", "application/json")
 	getReq.AddCookie(&http.Cookie{Name: sessionCookieName, Value: current.ID})
 	getRecorder := httptest.NewRecorder()
@@ -1165,7 +1134,7 @@ func TestCancelTrackerUploadRequiresPost(t *testing.T) {
 	default:
 	}
 
-	postReq := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/CancelTrackerUpload", strings.NewReader(`{"JobID":"job-1"}`))
+	postReq := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/CancelTrackerUpload", strings.NewReader(body))
 	postReq.Host = "127.0.0.1:7480"
 	postReq.Header.Set("Content-Type", "application/json")
 	postReq.Header.Set("Origin", "http://127.0.0.1:7480")
diff --git a/internal/webserver/runtime.go b/internal/webserver/runtime.go
new file mode 100644
index 00000000..532fb513
--- /dev/null
+++ b/internal/webserver/runtime.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/core"
+	"github.com/autobrr/upbrr/internal/filesystem"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// RuntimeGeneration groups one activated config generation's workflow bundle,
+// lifecycle owner, and logger. Capabilities borrow the core; the runtime
+// activator transfers Owner and Logger to the installer as one generation.
+type RuntimeGeneration struct {
+	ID           uint64
+	Config       config.Config
+	Capabilities CoreCapabilities
+	Owner        LifecycleOwner
+	Logger       *logging.Logger
+}
+
+var runtimeGenerationIDs atomic.Uint64
+
+// AllocateRuntimeGenerationID returns a process-local monotonic identifier for
+// one coherent runtime resource generation.
+func AllocateRuntimeGenerationID() uint64 {
+	return runtimeGenerationIDs.Add(1)
+}
+
+// buildRuntimeGeneration constructs a fresh generation from cfg using ctx and
+// the shared repository. On failure it closes resources created before the
+// error. Successful ownership transfers to the runtime activator.
+func buildRuntimeGeneration(ctx context.Context, cfg config.Config, repo *db.SQLiteRepository) (RuntimeGeneration, error) {
+	if ctx == nil {
+		return RuntimeGeneration{}, errors.New("webserver: context is required")
+	}
+
+	logger, err := logging.New(cfg.Logging, cfg.MainSettings.DBPath)
+	if err != nil {
+		return RuntimeGeneration{}, fmt.Errorf("web: %w", err)
+	}
+	svc, err := core.NewWithContext(ctx, api.CoreDependencies{
+		Config: cfg,
+		Logger: logger,
+		Services: api.ServiceSet{
+			Filesystem: filesystem.NewValidator(),
+		},
+		Repository:          repo.RepositoryCapabilities(),
+		RepositoryOwner:     repo,
+		SkipCookieMigration: true,
+	})
+	if err != nil {
+		_ = logger.Close()
+		return RuntimeGeneration{}, fmt.Errorf("web: %w", err)
+	}
+	capabilities, owner := BindCoreCapabilities(svc)
+	return RuntimeGeneration{
+		ID:           AllocateRuntimeGenerationID(),
+		Config:       cfg,
+		Capabilities: capabilities,
+		Owner:        owner,
+		Logger:       logger,
+	}, nil
+}
diff --git a/internal/webserver/runtime_activation.go b/internal/webserver/runtime_activation.go
new file mode 100644
index 00000000..b471f044
--- /dev/null
+++ b/internal/webserver/runtime_activation.go
@@ -0,0 +1,292 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/autobrr/upbrr/internal/authmaterial"
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/configstore"
+	"github.com/autobrr/upbrr/internal/cookies"
+	"github.com/autobrr/upbrr/internal/logging"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+// ActivationStage identifies the failed stage of a runtime activation.
+type ActivationStage string
+
+const (
+	ActivationStageNormalize       ActivationStage = "normalize candidate"
+	ActivationStageValidateStored  ActivationStage = "validate stored config"
+	ActivationStageValidateRuntime ActivationStage = "validate runtime config"
+	ActivationStageBuild           ActivationStage = "build runtime generation"
+	ActivationStageCookies         ActivationStage = "maintain cookies"
+	ActivationStagePersist         ActivationStage = "persist stored config"
+)
+
+// ActivationError preserves the failed activation stage and wrapped cause.
+type ActivationError struct {
+	Stage ActivationStage
+	Err   error
+}
+
+func (e *ActivationError) Error() string {
+	if e == nil {
+		return "runtime activation failed"
+	}
+	return fmt.Sprintf("runtime activation: %s: %v", e.Stage, e.Err)
+}
+
+// Unwrap returns the stage cause.
+func (e *ActivationError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.Err
+}
+
+// RetiredRuntime owns the resources replaced by one successful installation.
+type RetiredRuntime struct {
+	Owner  LifecycleOwner
+	Logger *logging.Logger
+}
+
+// Close releases the replaced runtime after its installer has finished all
+// transport-specific rebinding.
+func (r RetiredRuntime) Close() {
+	if r.Owner != nil {
+		_ = r.Owner.Close()
+	}
+	if r.Logger != nil {
+		_ = r.Logger.Close()
+	}
+}
+
+// RuntimeInstaller atomically publishes one complete runtime generation and
+// returns resources that can be retired after transport rebinding completes.
+// Install must not fail.
+type RuntimeInstaller interface {
+	Install(RuntimeGeneration) RetiredRuntime
+}
+
+type runtimeActivationDeps struct {
+	build   func(context.Context, config.Config, *db.SQLiteRepository) (RuntimeGeneration, error)
+	cookies func(context.Context, *db.SQLiteRepository, string, api.Logger) error
+	persist func(context.Context, *config.Config, *db.SQLiteRepository, string, api.Logger) error
+}
+
+type runtimeCookiePersistenceError struct {
+	err error
+}
+
+func (e *runtimeCookiePersistenceError) Error() string {
+	return fmt.Sprintf("runtime cookie persistence: %v", e.err)
+}
+
+func (e *runtimeCookiePersistenceError) Unwrap() error {
+	return e.err
+}
+
+// RuntimeActivator serializes and owns the complete config-candidate to active
+// runtime transition for one WebUI host.
+type RuntimeActivator struct {
+	mu          sync.Mutex
+	repo        *db.SQLiteRepository
+	fixedDBPath string
+	installer   RuntimeInstaller
+	deps        runtimeActivationDeps
+}
+
+// NewRuntimeActivator constructs an activator for one already-open repository
+// and one host-specific runtime installer.
+func NewRuntimeActivator(repo *db.SQLiteRepository, fixedDBPath string, installer RuntimeInstaller) (*RuntimeActivator, error) {
+	if repo == nil {
+		return nil, errors.New("runtime activation: repository is required")
+	}
+	fixedDBPath = strings.TrimSpace(fixedDBPath)
+	if fixedDBPath == "" {
+		return nil, errors.New("runtime activation: fixed database path is required")
+	}
+	if installer == nil {
+		return nil, errors.New("runtime activation: installer is required")
+	}
+	return &RuntimeActivator{
+		repo:        repo,
+		fixedDBPath: fixedDBPath,
+		installer:   installer,
+		deps: runtimeActivationDeps{
+			build:   buildRuntimeGeneration,
+			cookies: validateRuntimeCookies,
+			persist: persistRuntimeConfigAndCookies,
+		},
+	}, nil
+}
+
+// Activate normalizes, validates, builds, maintains, persists, and publishes a
+// config candidate as one serialized runtime transition.
+func (a *RuntimeActivator) Activate(ctx context.Context, candidate config.Config) error {
+	if a == nil {
+		return errors.New("runtime activation: activator is required")
+	}
+	if ctx == nil {
+		return errors.New("runtime activation: context is required")
+	}
+
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	stored, err := cloneConfig(candidate)
+	if err != nil {
+		return activationError(ActivationStageNormalize, err)
+	}
+	if _, err := config.MergeMissingTrackerDefaults(stored); err != nil {
+		return activationError(ActivationStageNormalize, err)
+	}
+	stored.MainSettings.DBPath = a.fixedDBPath
+	if err := stored.Validate(); err != nil {
+		return activationError(ActivationStageValidateStored, err)
+	}
+
+	runtimeCfg, err := cloneConfig(*stored)
+	if err != nil {
+		return activationError(ActivationStageNormalize, err)
+	}
+	config.ApplyEnvOverrides(runtimeCfg)
+	runtimeCfg.MainSettings.DBPath = a.fixedDBPath
+	if err := runtimeCfg.Validate(); err != nil {
+		return activationError(ActivationStageValidateRuntime, err)
+	}
+
+	generation, err := a.deps.build(ctx, *runtimeCfg, a.repo)
+	if err != nil {
+		return activationError(ActivationStageBuild, err)
+	}
+	installed := false
+	defer func() {
+		if !installed {
+			RetiredRuntime{Owner: generation.Owner, Logger: generation.Logger}.Close()
+		}
+	}()
+
+	if err := a.deps.cookies(ctx, a.repo, a.fixedDBPath, generation.Logger); err != nil {
+		return activationError(ActivationStageCookies, err)
+	}
+	if err := a.deps.persist(ctx, stored, a.repo, a.fixedDBPath, generation.Logger); err != nil {
+		var cookieErr *runtimeCookiePersistenceError
+		if errors.As(err, &cookieErr) {
+			return activationError(ActivationStageCookies, err)
+		}
+		return activationError(ActivationStagePersist, err)
+	}
+
+	generation.Config = *runtimeCfg
+	retired := a.installer.Install(generation)
+	installed = true
+	retired.Close()
+	return nil
+}
+
+func activationError(stage ActivationStage, err error) error {
+	return &ActivationError{Stage: stage, Err: err}
+}
+
+func cloneConfig(source config.Config) (*config.Config, error) {
+	payload, err := json.Marshal(source)
+	if err != nil {
+		return nil, fmt.Errorf("clone config: marshal: %w", err)
+	}
+	var cloned config.Config
+	if err := json.Unmarshal(payload, &cloned); err != nil {
+		return nil, fmt.Errorf("clone config: unmarshal: %w", err)
+	}
+	return &cloned, nil
+}
+
+func validateRuntimeCookies(_ context.Context, _ *db.SQLiteRepository, dbPath string, _ api.Logger) error {
+	if err := validateRuntimeCookieAuth(dbPath); err != nil && !errors.Is(err, cookies.ErrAuthHelperUnavailable) {
+		return fmt.Errorf("validate cookie auth: %w", err)
+	}
+	return nil
+}
+
+func persistRuntimeConfigAndCookies(
+	ctx context.Context,
+	cfg *config.Config,
+	repo *db.SQLiteRepository,
+	dbPath string,
+	logger api.Logger,
+) error {
+	if logger == nil {
+		logger = api.NopLogger{}
+	}
+	cookiesDir, err := db.CookiePath(dbPath, "")
+	if err != nil {
+		logger.Debugf("runtime activation: cookie directory unavailable: %v", err)
+		if err := configstore.SaveToRepository(ctx, cfg, repo, dbPath); err != nil {
+			return fmt.Errorf("persist runtime config without cookie directory: %w", err)
+		}
+		return nil
+	}
+	if !cookies.HasLegacyCookieFiles(cookiesDir) {
+		if err := configstore.SaveToRepository(ctx, cfg, repo, dbPath); err != nil {
+			return fmt.Errorf("persist runtime config without legacy cookies: %w", err)
+		}
+		return nil
+	}
+
+	store, err := cookies.NewCookieStore(repo.RawDB())
+	if err != nil {
+		return &runtimeCookiePersistenceError{err: fmt.Errorf("create cookie store: %w", err)}
+	}
+
+	migratedCount := 0
+	failedCookies := make([]cookies.FailedCookie, 0)
+	err = configstore.SaveToRepositoryWithPreSave(ctx, cfg, repo, dbPath, func(ctx context.Context, tx *sql.Tx, key []byte) error {
+		if len(key) == 0 {
+			logger.Debugf("runtime activation: cookie migration skipped: web auth helper unavailable")
+			return nil
+		}
+		var migrateErr error
+		migratedCount, failedCookies, migrateErr = cookies.MigrateFromFilesToDBTx(ctx, cookiesDir, store, tx, key, logger)
+		if migrateErr != nil {
+			return &runtimeCookiePersistenceError{err: fmt.Errorf("migrate cookies: %w", migrateErr)}
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("persist runtime config with cookie migration: %w", err)
+	}
+	if migratedCount == 0 || len(failedCookies) > 0 {
+		return nil
+	}
+	if err := cookies.DeleteMigratedCookieFiles(cookiesDir, logger); err != nil {
+		logger.Warnf("cookies: migration cleanup failed dir=%s migrated=%d: %v", cookiesDir, migratedCount, err)
+	}
+	return nil
+}
+
+func validateRuntimeCookieAuth(dbPath string) error {
+	material, err := authmaterial.LoadFromDBPath(dbPath)
+	if err != nil {
+		if errors.Is(err, authmaterial.ErrUnavailable) {
+			return cookies.ErrAuthHelperUnavailable
+		}
+		return fmt.Errorf("load auth helper: %w", err)
+	}
+	if _, _, err := material.PrimaryHelper(); err != nil {
+		if errors.Is(err, authmaterial.ErrUnavailable) {
+			return cookies.ErrAuthHelperUnavailable
+		}
+		return fmt.Errorf("derive auth helper: %w", err)
+	}
+	return nil
+}
diff --git a/internal/webserver/runtime_activation_test.go b/internal/webserver/runtime_activation_test.go
new file mode 100644
index 00000000..ac6e683f
--- /dev/null
+++ b/internal/webserver/runtime_activation_test.go
@@ -0,0 +1,292 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/services/db"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+type activationTestInstaller struct {
+	mu          sync.Mutex
+	rows        *[]string
+	retired     RetiredRuntime
+	generations []RuntimeGeneration
+}
+
+func (i *activationTestInstaller) Install(generation RuntimeGeneration) RetiredRuntime {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+	if i.rows != nil {
+		*i.rows = append(*i.rows, "install")
+	}
+	i.generations = append(i.generations, generation)
+	return i.retired
+}
+
+type activationTestOwner struct {
+	closed  atomic.Bool
+	onClose func()
+}
+
+func (o *activationTestOwner) Close() error {
+	o.closed.Store(true)
+	if o.onClose != nil {
+		o.onClose()
+	}
+	return nil
+}
+
+func TestRuntimeActivatorOwnsOrderedTransition(t *testing.T) {
+	t.Setenv("UA_DEFAULT_SCREENS", "3")
+	repo := openRuntimeActivationTestRepo(t)
+	rows := make([]string, 0, 5)
+	builtOwner := &activationTestOwner{onClose: func() { rows = append(rows, "built-close") }}
+	retiredOwner := &activationTestOwner{onClose: func() { rows = append(rows, "retired-close") }}
+	installer := &activationTestInstaller{
+		rows:    &rows,
+		retired: RetiredRuntime{Owner: retiredOwner},
+	}
+	activator, err := NewRuntimeActivator(repo, repo.DBPath(), installer)
+	if err != nil {
+		t.Fatalf("new activator: %v", err)
+	}
+
+	var stored config.Config
+	activator.deps = runtimeActivationDeps{
+		build: func(_ context.Context, cfg config.Config, gotRepo *db.SQLiteRepository) (RuntimeGeneration, error) {
+			rows = append(rows, "build")
+			if gotRepo != repo {
+				t.Fatal("build received a different repository")
+			}
+			return RuntimeGeneration{Config: cfg, Owner: builtOwner}, nil
+		},
+		cookies: func(_ context.Context, gotRepo *db.SQLiteRepository, dbPath string, _ api.Logger) error {
+			rows = append(rows, "cookies")
+			if gotRepo != repo || dbPath != repo.DBPath() {
+				t.Fatalf("cookie maintenance scope = (%p, %q), want (%p, %q)", gotRepo, dbPath, repo, repo.DBPath())
+			}
+			return nil
+		},
+		persist: func(_ context.Context, cfg *config.Config, gotRepo *db.SQLiteRepository, dbPath string, _ api.Logger) error {
+			rows = append(rows, "persist")
+			stored = *cfg
+			if gotRepo != repo || dbPath != repo.DBPath() {
+				t.Fatalf("persistence scope = (%p, %q), want (%p, %q)", gotRepo, dbPath, repo, repo.DBPath())
+			}
+			return nil
+		},
+	}
+
+	candidate := validRuntimeActivationConfig()
+	candidate.MainSettings.DBPath = filepath.Join(t.TempDir(), "ignored.db")
+	if err := activator.Activate(context.Background(), candidate); err != nil {
+		t.Fatalf("activate: %v", err)
+	}
+
+	wantRows := []string{"build", "cookies", "persist", "install", "retired-close"}
+	if len(rows) != len(wantRows) {
+		t.Fatalf("transition rows = %v, want %v", rows, wantRows)
+	}
+	for index := range wantRows {
+		if rows[index] != wantRows[index] {
+			t.Fatalf("transition rows = %v, want %v", rows, wantRows)
+		}
+	}
+	if builtOwner.closed.Load() {
+		t.Fatal("installed generation was retired")
+	}
+	if !retiredOwner.closed.Load() {
+		t.Fatal("replaced generation was not retired")
+	}
+	if stored.MainSettings.DBPath != repo.DBPath() || stored.ScreenshotHandling.Screens != 1 {
+		t.Fatalf("stored config = %#v", stored)
+	}
+	if len(installer.generations) != 1 {
+		t.Fatalf("installed generations = %d, want 1", len(installer.generations))
+	}
+	installed := installer.generations[0].Config
+	if installed.MainSettings.DBPath != repo.DBPath() || installed.ScreenshotHandling.Screens != 3 {
+		t.Fatalf("installed runtime config = %#v", installed)
+	}
+	if candidate.MainSettings.DBPath == repo.DBPath() {
+		t.Fatal("activation mutated the caller's config")
+	}
+}
+
+func TestRuntimeActivatorFailureStagesDoNotInstall(t *testing.T) {
+	tests := []struct {
+		name      string
+		stage     ActivationStage
+		configure func(*RuntimeActivator, *activationTestOwner)
+	}{
+		{
+			name:  "build",
+			stage: ActivationStageBuild,
+			configure: func(activator *RuntimeActivator, _ *activationTestOwner) {
+				activator.deps.build = func(context.Context, config.Config, *db.SQLiteRepository) (RuntimeGeneration, error) {
+					return RuntimeGeneration{}, errors.New("build failed")
+				}
+			},
+		},
+		{
+			name:  "cookies",
+			stage: ActivationStageCookies,
+			configure: func(activator *RuntimeActivator, owner *activationTestOwner) {
+				activator.deps.build = activationTestBuild(owner)
+				activator.deps.cookies = func(context.Context, *db.SQLiteRepository, string, api.Logger) error {
+					return errors.New("cookies failed")
+				}
+			},
+		},
+		{
+			name:  "persist",
+			stage: ActivationStagePersist,
+			configure: func(activator *RuntimeActivator, owner *activationTestOwner) {
+				activator.deps.build = activationTestBuild(owner)
+				activator.deps.cookies = activationTestCookies
+				activator.deps.persist = func(context.Context, *config.Config, *db.SQLiteRepository, string, api.Logger) error {
+					return errors.New("persist failed")
+				}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			repo := openRuntimeActivationTestRepo(t)
+			installer := &activationTestInstaller{}
+			activator, err := NewRuntimeActivator(repo, repo.DBPath(), installer)
+			if err != nil {
+				t.Fatalf("new activator: %v", err)
+			}
+			owner := &activationTestOwner{}
+			test.configure(activator, owner)
+
+			err = activator.Activate(context.Background(), validRuntimeActivationConfig())
+			assertActivationStage(t, err, test.stage)
+			if len(installer.generations) != 0 {
+				t.Fatal("failed activation installed a generation")
+			}
+			if test.stage != ActivationStageBuild && !owner.closed.Load() {
+				t.Fatal("failed activation did not close its built generation")
+			}
+		})
+	}
+}
+
+func TestRuntimeActivatorReportsStoredAndRuntimeValidationStages(t *testing.T) {
+	repo := openRuntimeActivationTestRepo(t)
+	installer := &activationTestInstaller{}
+	activator, err := NewRuntimeActivator(repo, repo.DBPath(), installer)
+	if err != nil {
+		t.Fatalf("new activator: %v", err)
+	}
+
+	invalidStored := validRuntimeActivationConfig()
+	invalidStored.ScreenshotHandling.Screens = 0
+	err = activator.Activate(context.Background(), invalidStored)
+	assertActivationStage(t, err, ActivationStageValidateStored)
+
+	t.Setenv("UA_DEFAULT_SCREENS", "0")
+	err = activator.Activate(context.Background(), validRuntimeActivationConfig())
+	assertActivationStage(t, err, ActivationStageValidateRuntime)
+	if len(installer.generations) != 0 {
+		t.Fatal("invalid config installed a generation")
+	}
+}
+
+func TestRuntimeActivatorSerializesCompleteTransition(t *testing.T) {
+	repo := openRuntimeActivationTestRepo(t)
+	installer := &activationTestInstaller{}
+	activator, err := NewRuntimeActivator(repo, repo.DBPath(), installer)
+	if err != nil {
+		t.Fatalf("new activator: %v", err)
+	}
+
+	entered := make(chan int, 2)
+	releaseFirst := make(chan struct{})
+	var builds atomic.Int32
+	activator.deps = runtimeActivationDeps{
+		build: func(_ context.Context, cfg config.Config, _ *db.SQLiteRepository) (RuntimeGeneration, error) {
+			build := int(builds.Add(1))
+			entered <- build
+			if build == 1 {
+				<-releaseFirst
+			}
+			return RuntimeGeneration{Config: cfg}, nil
+		},
+		cookies: activationTestCookies,
+		persist: func(context.Context, *config.Config, *db.SQLiteRepository, string, api.Logger) error { return nil },
+	}
+
+	errs := make(chan error, 2)
+	go func() { errs <- activator.Activate(context.Background(), validRuntimeActivationConfig()) }()
+	if build := <-entered; build != 1 {
+		t.Fatalf("first build = %d", build)
+	}
+	go func() { errs <- activator.Activate(context.Background(), validRuntimeActivationConfig()) }()
+	select {
+	case build := <-entered:
+		t.Fatalf("second activation entered build %d before first transition completed", build)
+	case <-time.After(100 * time.Millisecond):
+	}
+	close(releaseFirst)
+	if build := <-entered; build != 2 {
+		t.Fatalf("second build = %d", build)
+	}
+	for range 2 {
+		if err := <-errs; err != nil {
+			t.Fatalf("activate: %v", err)
+		}
+	}
+}
+
+func activationTestBuild(owner LifecycleOwner) func(context.Context, config.Config, *db.SQLiteRepository) (RuntimeGeneration, error) {
+	return func(_ context.Context, cfg config.Config, _ *db.SQLiteRepository) (RuntimeGeneration, error) {
+		return RuntimeGeneration{Config: cfg, Owner: owner}, nil
+	}
+}
+
+func activationTestCookies(context.Context, *db.SQLiteRepository, string, api.Logger) error {
+	return nil
+}
+
+func assertActivationStage(t *testing.T, err error, want ActivationStage) {
+	t.Helper()
+	var activationErr *ActivationError
+	if !errors.As(err, &activationErr) {
+		t.Fatalf("error = %v, want ActivationError", err)
+	}
+	if activationErr.Stage != want {
+		t.Fatalf("stage = %q, want %q", activationErr.Stage, want)
+	}
+}
+
+func validRuntimeActivationConfig() config.Config {
+	return config.Config{
+		MainSettings:       config.MainSettingsConfig{TMDBAPI: "x"},
+		ScreenshotHandling: config.ScreenshotHandlingConfig{Screens: 1},
+		Logging:            config.LoggingConfig{Level: "error"},
+	}
+}
+
+func openRuntimeActivationTestRepo(t *testing.T) *db.SQLiteRepository {
+	t.Helper()
+	repo, err := db.OpenWithLogger(filepath.Join(t.TempDir(), "runtime-activation.db"), api.NopLogger{})
+	if err != nil {
+		t.Fatalf("open repository: %v", err)
+	}
+	t.Cleanup(func() { _ = repo.Close() })
+	return repo
+}
diff --git a/internal/webserver/runtime_snapshot.go b/internal/webserver/runtime_snapshot.go
index a91e420f..b85922ac 100644
--- a/internal/webserver/runtime_snapshot.go
+++ b/internal/webserver/runtime_snapshot.go
@@ -12,14 +12,20 @@ import (
 	"github.com/autobrr/upbrr/pkg/api"
 )
 
+// backendRuntimeSnapshot is a shallow, single-generation view of config and
+// its bound runtime resources. It preserves request consistency without
+// transferring ownership of the capability bundle, owner, or logger.
 type backendRuntimeSnapshot struct {
-	cfg         config.Config
-	core        api.Core
-	coreInitErr error
-	logger      *logging.Logger
+	generationID uint64
+	cfg          config.Config
+	capabilities CoreCapabilities
+	coreOwner    LifecycleOwner
+	coreInitErr  error
+	logger       *logging.Logger
 }
 
-// runtimeSnapshot returns a consistent copy of runtime fields guarded by runtimeMu.
+// runtimeSnapshot copies all runtime fields under one read lock so callers do
+// not combine config and capabilities from different settings generations.
 func (b *Backend) runtimeSnapshot() backendRuntimeSnapshot {
 	if b == nil {
 		return backendRuntimeSnapshot{}
@@ -27,10 +33,12 @@ func (b *Backend) runtimeSnapshot() backendRuntimeSnapshot {
 	b.runtimeMu.RLock()
 	defer b.runtimeMu.RUnlock()
 	return backendRuntimeSnapshot{
-		cfg:         b.cfg,
-		core:        b.core,
-		coreInitErr: b.coreInitErr,
-		logger:      b.logger,
+		generationID: b.runtimeGeneration,
+		cfg:          b.cfg,
+		capabilities: b.capabilities,
+		coreOwner:    b.coreOwner,
+		coreInitErr:  b.coreInitErr,
+		logger:       b.logger,
 	}
 }
 
@@ -39,7 +47,7 @@ func (b *Backend) requireRuntime() (backendRuntimeSnapshot, error) {
 		return backendRuntimeSnapshot{}, errors.New("backend not initialized")
 	}
 	rt := b.runtimeSnapshot()
-	if rt.core != nil {
+	if rt.capabilities.Available() {
 		return rt, nil
 	}
 	if rt.coreInitErr != nil {
@@ -58,14 +66,56 @@ func (b *Backend) currentConfig() config.Config {
 	return b.cfg
 }
 
-// currentCore returns the active core service under the runtime lock.
-func (b *Backend) currentCore() api.Core {
-	if b == nil {
-		return nil
+func requireBackendCapability[T any](capability T, name string) (T, error) {
+	if !CapabilityAvailable(capability) {
+		var zero T
+		return zero, fmt.Errorf("%s capability unavailable", name)
 	}
-	b.runtimeMu.RLock()
-	defer b.runtimeMu.RUnlock()
-	return b.core
+	return capability, nil
+}
+
+func (rt backendRuntimeSnapshot) metadataCore() (MetadataCapability, error) {
+	return requireBackendCapability(rt.capabilities.Metadata, "metadata")
+}
+
+func (rt backendRuntimeSnapshot) releasePreparationCore() (ReleasePreparationCapability, error) {
+	return requireBackendCapability(rt.capabilities.ReleasePreparation, "release preparation")
+}
+
+func (rt backendRuntimeSnapshot) selectionCore() (SelectionCapability, error) {
+	return requireBackendCapability(rt.capabilities.Selection, "blu-ray selection")
+}
+
+func (rt backendRuntimeSnapshot) preparationCore() (PreparationCapability, error) {
+	return requireBackendCapability(rt.capabilities.Preparation, "preparation")
+}
+
+func (rt backendRuntimeSnapshot) uploadReviewCore() (UploadReviewCapability, error) {
+	return requireBackendCapability(rt.capabilities.UploadReview, "upload review")
+}
+
+func (rt backendRuntimeSnapshot) screenshotCore() (ScreenshotCapability, error) {
+	return requireBackendCapability(rt.capabilities.Screenshots, "screenshot")
+}
+
+func (rt backendRuntimeSnapshot) hostedImageCore() (HostedImageCapability, error) {
+	return requireBackendCapability(rt.capabilities.HostedImages, "hosted image")
+}
+
+func (rt backendRuntimeSnapshot) dvdMenuCore() (DVDCapability, error) {
+	return requireBackendCapability(rt.capabilities.DVD, "DVD menu")
+}
+
+func (rt backendRuntimeSnapshot) descriptionCore() (DescriptionCapability, error) {
+	return requireBackendCapability(rt.capabilities.Description, "description")
+}
+
+func (rt backendRuntimeSnapshot) playlistCore() (PlaylistCapability, error) {
+	return requireBackendCapability(rt.capabilities.Playlists, "playlist")
+}
+
+func (rt backendRuntimeSnapshot) historyCore() (HistoryCapability, error) {
+	return requireBackendCapability(rt.capabilities.History, "history")
 }
 
 // currentLogger returns the active logger under the runtime lock.
@@ -135,28 +185,78 @@ func (s *Server) logErrorf(format string, args ...any) {
 	s.backend.logErrorf(format, args...)
 }
 
-// baseUploadOptions returns upload options from the current runtime config.
-func (b *Backend) baseUploadOptions() api.UploadOptions {
-	return buildBaseMetadataOptions(b.currentConfig())
-}
-
 // baseUploadOptions returns upload options derived from the same runtime
 // snapshot as the core selected for a request.
 func (rt backendRuntimeSnapshot) baseUploadOptions() api.UploadOptions {
 	return buildBaseMetadataOptions(rt.cfg)
 }
 
-// replaceRuntime swaps all runtime-owned fields under one write lock and
-// returns the previous core and logger for shutdown after callers finish
-// follow-up work such as log stream rebinding.
-func (b *Backend) replaceRuntime(cfg config.Config, core api.Core, logger *logging.Logger) (api.Core, *logging.Logger) {
+// replaceRuntime swaps one complete runtime generation and returns the previous
+// lifecycle owner and logger for separate shutdown after follow-up work such as
+// log stream rebinding.
+func (b *Backend) replaceRuntime(
+	cfg config.Config,
+	capabilities CoreCapabilities,
+	logger *logging.Logger,
+) (LifecycleOwner, *logging.Logger) {
+	return b.replaceRuntimeGeneration(AllocateRuntimeGenerationID(), cfg, capabilities, nil, logger)
+}
+
+func (b *Backend) replaceRuntimeGeneration(
+	generationID uint64,
+	cfg config.Config,
+	capabilities CoreCapabilities,
+	owner LifecycleOwner,
+	logger *logging.Logger,
+) (LifecycleOwner, *logging.Logger) {
 	b.runtimeMu.Lock()
 	defer b.runtimeMu.Unlock()
-	oldCore := b.core
+	oldOwner := b.coreOwner
 	oldLogger := b.logger
-	b.core = core
+	b.capabilities = capabilities
+	b.runtimeGeneration = generationID
+	b.coreOwner = owner
 	b.coreInitErr = nil
 	b.logger = logger
 	b.cfg = cfg
-	return oldCore, oldLogger
+	return oldOwner, oldLogger
+}
+
+type backendRuntimeInstaller struct {
+	backend *Backend
+}
+
+func (i backendRuntimeInstaller) Install(generation RuntimeGeneration) RetiredRuntime {
+	oldOwner, oldLogger := i.backend.replaceRuntimeGeneration(
+		generation.ID,
+		generation.Config,
+		generation.Capabilities,
+		generation.Owner,
+		generation.Logger,
+	)
+	if i.backend.hub != nil {
+		i.backend.hub.SetLogger(generation.Logger)
+	}
+	i.backend.rebindLogStreams(oldLogger, generation.Logger)
+	return RetiredRuntime{Owner: oldOwner, Logger: oldLogger}
+}
+
+func (b *Backend) runtimeActivator() (*RuntimeActivator, error) {
+	if b == nil {
+		return nil, errors.New("backend not initialized")
+	}
+	b.activationInitMu.Lock()
+	defer b.activationInitMu.Unlock()
+	if b.activator != nil {
+		return b.activator, nil
+	}
+	if b.repo == nil {
+		return nil, errors.New("config repository not initialized")
+	}
+	activator, err := NewRuntimeActivator(b.repo, b.repo.DBPath(), backendRuntimeInstaller{backend: b})
+	if err != nil {
+		return nil, fmt.Errorf("initialize runtime activator: %w", err)
+	}
+	b.activator = activator
+	return activator, nil
 }
diff --git a/internal/webserver/server.go b/internal/webserver/server.go
index 167760a8..6e01d9bb 100644
--- a/internal/webserver/server.go
+++ b/internal/webserver/server.go
@@ -24,7 +24,6 @@ import (
 	"github.com/pkg/browser"
 
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/guiapp"
 	"github.com/autobrr/upbrr/internal/redaction"
 )
 
@@ -45,7 +44,6 @@ type Server struct {
 	cfg                config.Config
 	cliCfg             CLIConfig
 	backend            *Backend
-	picker             nativePicker
 	auth               *authStore
 	sessions           *sessionManager
 	hub                *eventHub
@@ -101,6 +99,7 @@ func New(opts Options) (*Server, error) {
 	if err != nil {
 		return nil, err
 	}
+	sessions.SetRemovedCallback(backend.removeJobOwner)
 	sessionsClosed := false
 	defer func() {
 		if !sessionsClosed {
@@ -111,7 +110,6 @@ func New(opts Options) (*Server, error) {
 		cfg:            cfg,
 		cliCfg:         cliCfg,
 		backend:        backend,
-		picker:         newNativePicker(),
 		auth:           authStore,
 		sessions:       sessions,
 		hub:            hub,
@@ -387,14 +385,14 @@ func unwrapBrowserIPv6Host(host string) (string, bool) {
 }
 
 func resolveWebAssets() (fs.FS, error) {
-	assets, err := guiapp.ResolveAssets(nil)
+	assets, err := resolveAssets(nil)
 	if err == nil {
 		return assets, nil
 	}
 
-	// Keep the legacy repo-local fallback so local development can still serve
-	// generated assets even if embedding was skipped for some reason.
-	distPath := filepath.Join("gui", "frontend", "dist")
+	// Keep the repo-local fallback so local development can still serve
+	// generated assets when embedding was skipped.
+	distPath := filepath.Join("webui", "dist")
 	if stat, statErr := os.Stat(filepath.Join(distPath, "index.html")); statErr == nil && !stat.IsDir() {
 		return os.DirFS(distPath), nil
 	}
diff --git a/internal/webserver/server_test.go b/internal/webserver/server_test.go
index d913e869..fcf6538f 100644
--- a/internal/webserver/server_test.go
+++ b/internal/webserver/server_test.go
@@ -90,8 +90,8 @@ func TestNewClosesBackendWhenAssetSetupFails(t *testing.T) {
 	closed := false
 	newBackendWithContextForServer = func(_ context.Context, cfg config.Config, _ *eventHub) (*Backend, error) {
 		return &Backend{
-			cfg:  cfg,
-			core: &serverCloseCore{closed: &closed},
+			cfg:       cfg,
+			coreOwner: &serverCloseCore{closed: &closed},
 		}, nil
 	}
 	resolveWebAssetsForServer = func() (fs.FS, error) {
@@ -296,7 +296,7 @@ func TestServerLoggerAccessSynchronizedDuringRuntimeReplacement(t *testing.T) {
 					return
 				}
 				logger.SetConsoleOutput(io.Discard, io.Discard)
-				_, oldLogger := backend.replaceRuntime(config.Config{}, nil, logger)
+				_, oldLogger := backend.replaceRuntime(config.Config{}, CoreCapabilities{}, logger)
 				if oldLogger != nil {
 					_ = oldLogger.Close()
 				}
@@ -340,9 +340,21 @@ func TestBaseURLPreservesExplicitBaseURL(t *testing.T) {
 		baseURL string
 		want    string
 	}{
-		{name: "path trailing slash", baseURL: " https://example.test/upbrr/ ", want: "https://example.test/upbrr/"},
-		{name: "root slash", baseURL: "https://example.test/", want: "https://example.test/"},
-		{name: "query fragment stripped", baseURL: "https://example.test/upbrr/?token=secret#frag", want: "https://example.test/upbrr/"},
+		{
+			name:    "path trailing slash",
+			baseURL: " https://example.test/upbrr/ ",
+			want:    "https://example.test/upbrr/",
+		},
+		{
+			name:    "root slash",
+			baseURL: "https://example.test/",
+			want:    "https://example.test/",
+		},
+		{
+			name:    "query fragment stripped",
+			baseURL: "https://example.test/upbrr/?token=secret#frag",
+			want:    "https://example.test/upbrr/",
+		},
 	}
 
 	for _, tc := range cases {
@@ -372,12 +384,42 @@ func TestBaseURLSynthesizesLocalOriginForPathOnlyBaseURL(t *testing.T) {
 		baseURL string
 		want    string
 	}{
-		{name: "wildcard ipv4", host: "0.0.0.0", baseURL: " /upbrr/ ", want: "http://localhost:49152/upbrr/"},
-		{name: "wildcard ipv6", host: "::", baseURL: "upbrr", want: "http://localhost:49152/upbrr/"},
-		{name: "bracketed wildcard ipv6", host: "[::]", baseURL: "/tools/upbrr", want: "http://localhost:49152/tools/upbrr/"},
-		{name: "scoped ipv6", host: "fe80::1%zone", baseURL: "/upbrr/", want: "http://[fe80::1%25zone]:49152/upbrr/"},
-		{name: "query and fragment dropped", host: "127.0.0.1", baseURL: "/upbrr/?token=secret#frag", want: "http://127.0.0.1:49152/upbrr/"},
-		{name: "root path", host: "127.0.0.1", baseURL: "/", want: "http://127.0.0.1:49152"},
+		{
+			name:    "wildcard ipv4",
+			host:    "0.0.0.0",
+			baseURL: " /upbrr/ ",
+			want:    "http://localhost:49152/upbrr/",
+		},
+		{
+			name:    "wildcard ipv6",
+			host:    "::",
+			baseURL: "upbrr",
+			want:    "http://localhost:49152/upbrr/",
+		},
+		{
+			name:    "bracketed wildcard ipv6",
+			host:    "[::]",
+			baseURL: "/tools/upbrr",
+			want:    "http://localhost:49152/tools/upbrr/",
+		},
+		{
+			name:    "scoped ipv6",
+			host:    "fe80::1%zone",
+			baseURL: "/upbrr/",
+			want:    "http://[fe80::1%25zone]:49152/upbrr/",
+		},
+		{
+			name:    "query and fragment dropped",
+			host:    "127.0.0.1",
+			baseURL: "/upbrr/?token=secret#frag",
+			want:    "http://127.0.0.1:49152/upbrr/",
+		},
+		{
+			name:    "root path",
+			host:    "127.0.0.1",
+			baseURL: "/",
+			want:    "http://127.0.0.1:49152",
+		},
 	}
 
 	for _, tc := range cases {
@@ -446,7 +488,11 @@ func TestBaseURLEscapesScopedIPv6Zone(t *testing.T) {
 					Port: 7480,
 				},
 			}
-			got := server.baseURL(&net.TCPAddr{IP: net.ParseIP("fe80::1"), Port: 49152, Zone: "zone"})
+			got := server.baseURL(&net.TCPAddr{
+				IP:   net.ParseIP("fe80::1"),
+				Port: 49152,
+				Zone: "zone",
+			})
 			if got != tc.want {
 				t.Fatalf("baseURL() = %q, want %q", got, tc.want)
 			}
diff --git a/internal/webserver/shutdown_test.go b/internal/webserver/shutdown_test.go
index d19f1dcb..e06c51d9 100644
--- a/internal/webserver/shutdown_test.go
+++ b/internal/webserver/shutdown_test.go
@@ -11,26 +11,32 @@ import (
 	"net/http/httptest"
 	"testing"
 	"time"
+
+	sharedjobs "github.com/autobrr/upbrr/internal/webserver/jobs"
 )
 
 func TestStopAllDupeJobsWaitsForWorkers(t *testing.T) {
-	backend := &Backend{
-		dupes: make(map[string]*dupeCheckJob),
-	}
-
+	backend := &Backend{jobEngine: sharedjobs.New(nil, sharedjobs.Config{})}
 	released := make(chan struct{})
-	finished := make(chan struct{})
-	backend.dupeWG.Add(1)
-	backend.dupes["job-1"] = &dupeCheckJob{
-		id: "job-1",
-		cancel: func() {
-			go func() {
-				<-released
-				backend.dupeWG.Done()
-				close(finished)
-			}()
+	canceled := make(chan struct{}, 1)
+	started := make(chan struct{}, 1)
+	owner, err := backend.ensureJobOwner("session-a")
+	if err != nil {
+		t.Fatalf("ensure owner: %v", err)
+	}
+	_, err = backend.jobEngine.StartDupe(context.Background(), owner, sharedjobs.DupeSpec{
+		CorrelationID: "shutdown-dupe",
+		Snapshot: webTestDupeSnapshot("Example.Release.2026.1080p-GRP"),
+		Runner: blockingDupeRunner{
+			started:  started,
+			canceled: canceled,
+			release:  released,
 		},
+	})
+	if err != nil {
+		t.Fatalf("start dupe: %v", err)
 	}
+	<-started
 
 	done := make(chan struct{})
 	go func() {
@@ -43,6 +49,11 @@ func TestStopAllDupeJobsWaitsForWorkers(t *testing.T) {
 		t.Fatal("expected stopAllDupeJobs to wait for active workers")
 	case <-time.After(50 * time.Millisecond):
 	}
+	select {
+	case <-canceled:
+	case <-time.After(time.Second):
+		t.Fatal("expected shutdown to cancel dupe worker")
+	}
 
 	close(released)
 
@@ -51,28 +62,30 @@ func TestStopAllDupeJobsWaitsForWorkers(t *testing.T) {
 	case <-time.After(250 * time.Millisecond):
 		t.Fatal("expected stopAllDupeJobs to return after workers finish")
 	}
-
-	<-finished
 }
 
 func TestStopAllUploadJobsWaitsForWorkers(t *testing.T) {
-	backend := &Backend{
-		uploads: make(map[string]*trackerUploadJob),
-	}
-
+	backend := &Backend{jobEngine: sharedjobs.New(nil, sharedjobs.Config{})}
 	released := make(chan struct{})
-	finished := make(chan struct{})
-	backend.uploadWG.Add(1)
-	backend.uploads["job-1"] = &trackerUploadJob{
-		id: "job-1",
-		cancel: func() {
-			go func() {
-				<-released
-				backend.uploadWG.Done()
-				close(finished)
-			}()
+	canceled := make(chan struct{}, 1)
+	started := make(chan struct{}, 1)
+	owner, err := backend.ensureJobOwner("session-a")
+	if err != nil {
+		t.Fatalf("ensure owner: %v", err)
+	}
+	_, err = backend.jobEngine.StartUpload(context.Background(), owner, sharedjobs.UploadSpec{
+		CorrelationID: "shutdown-upload",
+		Snapshot: webTestUploadSnapshot("Example.Release.2026.1080p-GRP"),
+		Runner: blockingUploadRunner{
+			started:  started,
+			canceled: canceled,
+			release:  released,
 		},
+	})
+	if err != nil {
+		t.Fatalf("start upload: %v", err)
 	}
+	<-started
 
 	done := make(chan struct{})
 	go func() {
@@ -85,6 +98,11 @@ func TestStopAllUploadJobsWaitsForWorkers(t *testing.T) {
 		t.Fatal("expected stopAllUploadJobs to wait for active workers")
 	case <-time.After(50 * time.Millisecond):
 	}
+	select {
+	case <-canceled:
+	case <-time.After(time.Second):
+		t.Fatal("expected shutdown to cancel upload worker")
+	}
 
 	close(released)
 
@@ -93,8 +111,6 @@ func TestStopAllUploadJobsWaitsForWorkers(t *testing.T) {
 	case <-time.After(250 * time.Millisecond):
 		t.Fatal("expected stopAllUploadJobs to return after workers finish")
 	}
-
-	<-finished
 }
 
 func TestStopAllLogStreamsWaitsForWorkers(t *testing.T) {
diff --git a/internal/webserver/tracker_auth_import_test.go b/internal/webserver/tracker_auth_import_test.go
index 4c878293..c2a6a6ab 100644
--- a/internal/webserver/tracker_auth_import_test.go
+++ b/internal/webserver/tracker_auth_import_test.go
@@ -13,7 +13,7 @@ import (
 
 	"github.com/autobrr/upbrr/internal/authmaterial"
 	"github.com/autobrr/upbrr/internal/config"
-	"github.com/autobrr/upbrr/internal/trackerauth"
+	trackerauth "github.com/autobrr/upbrr/internal/trackers/auth"
 )
 
 func TestBackendImportTrackerAuthCookieContentRejectsOverCap(t *testing.T) {
diff --git a/internal/webserver/tracker_catalog_test.go b/internal/webserver/tracker_catalog_test.go
new file mode 100644
index 00000000..c132322e
--- /dev/null
+++ b/internal/webserver/tracker_catalog_test.go
@@ -0,0 +1,79 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package webserver
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/autobrr/upbrr/internal/config"
+	"github.com/autobrr/upbrr/internal/trackers"
+	"github.com/autobrr/upbrr/pkg/api"
+)
+
+func TestListTrackerCatalogComposesIdentitySchemaAndConfiguredState(t *testing.T) {
+	t.Parallel()
+
+	backend := &Backend{cfg: config.Config{Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
+		"RHD":     {APIKey: "configured"},
+		"BTN":     {Username: "partial"},
+		"AITHER":  {ImageHost: "imgbox"},
+		"RETIRED": {Unknown: map[string]any{"keep_me": "retained"}},
+	}}}}
+
+	catalog, err := backend.ListTrackerCatalog()
+	if err != nil {
+		t.Fatalf("ListTrackerCatalog: %v", err)
+	}
+	if !slices.Equal(catalog.Unsupported, []string{"RETIRED"}) {
+		t.Fatalf("unsupported = %#v", catalog.Unsupported)
+	}
+
+	rhd := catalogEntryByName(t, catalog.Entries, "RHD")
+	if !rhd.Configured || rhd.Family != string(trackers.FamilyUnit3D) || rhd.BaseURL == "" ||
+		rhd.UploadContentMode != string(trackers.UploadContentModeDescription) {
+		t.Fatalf("RHD catalog entry = %#v", rhd)
+	}
+	if mode := catalogEntryByName(t, catalog.Entries, "BTN").UploadContentMode; mode != string(trackers.UploadContentModeNone) {
+		t.Fatalf("BTN upload content mode = %q", mode)
+	}
+	if mode := catalogEntryByName(t, catalog.Entries, "ANT").UploadContentMode; mode != string(trackers.UploadContentModeScreenshots) {
+		t.Fatalf("ANT upload content mode = %q", mode)
+	}
+	if !catalogEntryByName(t, catalog.Entries, "BTN").Configured {
+		t.Fatal("partial BTN credentials should count as configured")
+	}
+	if catalogEntryByName(t, catalog.Entries, "AITHER").Configured {
+		t.Fatal("optional AITHER image host should not count as configured")
+	}
+
+	schemas, err := config.OrderedTrackerSchemas()
+	if err != nil {
+		t.Fatalf("OrderedTrackerSchemas: %v", err)
+	}
+	rhdSchema := slices.IndexFunc(schemas, func(schema config.TrackerSchema) bool { return schema.Name == "RHD" })
+	if rhdSchema < 0 {
+		t.Fatal("RHD schema missing")
+	}
+	wantKeys := make([]string, len(schemas[rhdSchema].Fields))
+	for index, field := range schemas[rhdSchema].Fields {
+		wantKeys[index] = field.JSONKey
+	}
+	gotKeys := make([]string, len(rhd.Fields))
+	for index, field := range rhd.Fields {
+		gotKeys[index] = field.Key
+	}
+	if !slices.Equal(gotKeys, wantKeys) {
+		t.Fatalf("RHD field order = %#v, want %#v", gotKeys, wantKeys)
+	}
+}
+
+func catalogEntryByName(t *testing.T, entries []api.TrackerCatalogEntry, name string) api.TrackerCatalogEntry {
+	t.Helper()
+	index := slices.IndexFunc(entries, func(entry api.TrackerCatalogEntry) bool { return entry.Name == name })
+	if index < 0 {
+		t.Fatalf("catalog entry %s missing", name)
+	}
+	return entries[index]
+}
diff --git a/internal/webserver/tracker_icons.go b/internal/webserver/tracker_icons.go
index 6d26a504..589cad41 100644
--- a/internal/webserver/tracker_icons.go
+++ b/internal/webserver/tracker_icons.go
@@ -5,13 +5,34 @@ package webserver
 
 import (
 	"encoding/base64"
+	"fmt"
 	"net/http"
 	"strings"
 
-	"github.com/autobrr/upbrr/internal/config"
 	"github.com/autobrr/upbrr/internal/services/trackericon"
+	trackerimpl "github.com/autobrr/upbrr/internal/trackers/impl"
 )
 
+// resolveTrackerIconTarget accepts only registered trackers and falls back to
+// the registry-owned base URL when no explicit favicon URL is supplied.
+func resolveTrackerIconTarget(trackerName string, faviconURL string) (string, string, error) {
+	registry, err := trackerimpl.NewRegistry()
+	if err != nil {
+		return "", "", fmt.Errorf("tracker icon: build registry: %w", err)
+	}
+	descriptor, ok := registry.LookupDescriptor(trackerName)
+	if !ok {
+		return "", "", fmt.Errorf("tracker icon: unsupported tracker %q", strings.TrimSpace(trackerName))
+	}
+	urlToUse := strings.TrimSpace(faviconURL)
+	if urlToUse == "" {
+		urlToUse = descriptor.BaseURL
+	}
+	return descriptor.Name, urlToUse, nil
+}
+
+// handleTrackerIcon serves decoded tracker icon bytes only for an allowlisted
+// image MIME type and disables browser content sniffing.
 func (s *Server) handleTrackerIcon(w http.ResponseWriter, r *http.Request, _ session) {
 	if r.Method != http.MethodPost {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
@@ -31,10 +52,10 @@ func (s *Server) handleTrackerIcon(w http.ResponseWriter, r *http.Request, _ ses
 	if s.backend != nil {
 		cfg = s.backend.currentConfig()
 	}
-	domain, resolvedURL := config.ResolveTrackerDomain(&cfg, strings.TrimSpace(req.Domain))
-	urlToUse := strings.TrimSpace(req.URL)
-	if urlToUse == "" {
-		urlToUse = resolvedURL
+	domain, urlToUse, err := resolveTrackerIconTarget(req.Domain, req.URL)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
 	}
 
 	sanitized := trackericon.SafeDomainFilename(domain)
diff --git a/internal/webserver/tracker_icons_test.go b/internal/webserver/tracker_icons_test.go
index 40aa0cfc..06b4bf8f 100644
--- a/internal/webserver/tracker_icons_test.go
+++ b/internal/webserver/tracker_icons_test.go
@@ -36,22 +36,16 @@ func TestHandleTrackerIconUsesBackendRuntimeConfig(t *testing.T) {
 	newDBPath := filepath.Join(t.TempDir(), "new.sqlite")
 	oldCfg := config.Config{
 		MainSettings: config.MainSettingsConfig{DBPath: oldDBPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"TEST": {URL: "https://old.example"},
-		}},
 	}
 	newCfg := config.Config{
 		MainSettings: config.MainSettingsConfig{DBPath: newDBPath},
-		Trackers: config.TrackersConfig{Trackers: map[string]config.TrackerConfig{
-			"TEST": {URL: "https://new.example"},
-		}},
 	}
 
 	iconDir, err := db.Subdir(newDBPath, "tracker-icons")
 	if err != nil {
 		t.Fatalf("create icon dir: %v", err)
 	}
-	iconPath := filepath.Join(iconDir, customTrackerIconCacheName("new.example", "https://new.example"))
+	iconPath := filepath.Join(iconDir, customTrackerIconCacheName("AITHER", "https://aither.cc"))
 	if err := os.WriteFile(iconPath, trackerIconTestPNG, 0o600); err != nil {
 		t.Fatalf("write cached icon: %v", err)
 	}
@@ -60,7 +54,7 @@ func TestHandleTrackerIconUsesBackendRuntimeConfig(t *testing.T) {
 		cfg:     oldCfg,
 		backend: &Backend{cfg: newCfg},
 	}
-	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/TrackerIcon", strings.NewReader(`{"Domain":"TEST"}`))
+	req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/app/TrackerIcon", strings.NewReader(`{"Domain":"AITHER"}`))
 	recorder := httptest.NewRecorder()
 
 	server.handleTrackerIcon(recorder, req, session{})
diff --git a/lefthook.yml b/lefthook.yml
index d63342ca..7f78a8d2 100644
--- a/lefthook.yml
+++ b/lefthook.yml
@@ -2,7 +2,7 @@ min_version: 2.1.0
 
 # Skip hooks with `git commit --no-verify` or `LEFTHOOK=0 git commit ...`.
 # Go-only contributors: `go install github.com/evilmartians/lefthook/v2@v2.1.0 && lefthook install`.
-# Frontend/full-stack contributors: `pnpm install` in gui/frontend/ plus `lefthook install`.
+# Frontend/full-stack contributors: `pnpm install` in webui/ plus `lefthook install`.
 
 # Execution model:
 # - Top-level jobs (frontend, go) run in parallel — they touch disjoint file sets.
@@ -16,12 +16,15 @@ pre-commit:
     - rebase
   jobs:
     - name: frontend
-      root: "gui/frontend/"
+      root: "webui/"
       group:
         piped: true
         jobs:
           - name: format
             glob: "**/*.{ts,tsx,css,scss,json,md,html,yml,yaml}"
+            exclude:
+              - "webui/CLAUDE.md"
+              - "webui/e2e/CLAUDE.md"
             run: pnpm exec prettier --write --cache --ignore-unknown {staged_files}
             stage_fixed: true
             fail_text: "Prettier failed. Fix the errors above or bypass with --no-verify."
@@ -29,7 +32,7 @@ pre-commit:
           - name: lint
             glob: "**/*.{ts,tsx}"
             run: pnpm exec eslint --cache --no-error-on-unmatched-pattern {staged_files}
-            fail_text: "ESLint failed. Fix errors above, or run `pnpm --dir gui/frontend run lint` locally."
+            fail_text: "ESLint failed. Fix errors above, or run `pnpm --dir webui run lint` locally."
 
     - name: go
       group:
@@ -41,6 +44,11 @@ pre-commit:
             stage_fixed: true
             fail_text: "golangci-lint fmt failed. See output above."
 
+          - name: literalpolicy
+            glob: "**/*.go"
+            run: go run ./cmd/literalpolicy
+            fail_text: "Composite literal layout failed. Run `make fmt-go`."
+
           - name: logpolicy
             glob:
               - "internal/*.go"
@@ -57,10 +65,10 @@ pre-push:
   parallel: true
   jobs:
     - name: frontend-typecheck
-      root: "gui/frontend/"
+      root: "webui/"
       glob: "**/*.{ts,tsx}"
       run: pnpm run typecheck
-      fail_text: "TypeScript typecheck failed. Run `pnpm --dir gui/frontend run typecheck`."
+      fail_text: "TypeScript typecheck failed. Run `pnpm --dir webui run typecheck`."
 
     - name: go-lint
       glob: "**/*.go"
diff --git a/pkg/api/AGENTS.md b/pkg/api/AGENTS.md
index 63691d69..1366333f 100644
--- a/pkg/api/AGENTS.md
+++ b/pkg/api/AGENTS.md
@@ -6,11 +6,10 @@ Scoped rules for shared API contracts under `pkg/api`. Root and `internal/AGENTS
 
 - CLI: `cmd/upbrr`
 - Core orchestration: `internal/core`
-- Wails backend: `internal/guiapp`
-- Embedded web server/API: `internal/webserver`
-- Frontend bridge: `gui/frontend/src`
+- WebUI server/API: `internal/webserver`
+- Browser clients/types: `webui/src`
 
-Preserve CLI, Wails GUI, and embedded web parity unless intentionally changing an entrypoint.
+Preserve CLI and WebUI behavior unless intentionally changing an entrypoint.
 
 ## Contract Changes
 
@@ -18,19 +17,29 @@ Changes to these require entrypoint parity review:
 
 - `Request`
 - `UploadOptions`
-- `PreparedMetadata`
+- `PreparedRelease`, `PrepareResult`, and grouped canonical facts
+- operation-specific inputs and exact `ReleaseRef` generations
 - dry-run/upload review payloads
 - questionnaire answers
 - description groups
 - tracker overrides and retry/skip flags
 - upload status/history rows
+- `PreparationProgressUpdate` and `ImageUploadProgressUpdate`
+- `OperationFailure` codes and recovery metadata
 
-Check CLI builders, Wails methods, web `/api/app/*` routes, frontend bridge request shapes, and TS types.
+Check CLI builders, WebUI `/api/app/*` routes, browser request shapes, and TS types.
+
+## Canonical / Presentation Boundaries
+
+- Canonical request and preparation contracts are single-source and operation inputs reference one exact `ReleaseRef` generation.
+- Keep prepared facts typed and reusable; do not add presentation correlation or workflow state to canonical inputs or facts.
+- WebUI transport injects progress correlation IDs and timestamps. Progress payloads must be frontend-safe; image-host updates are absolute snapshots for one host attempt.
+- Recovery decisions use structured `OperationFailure` codes/metadata, never error-message substring matching.
 
 ## Checks
 
 - CLI/core contracts: `go test -race -v -timeout 20m ./cmd/upbrr ./internal/core ./pkg/api`.
-- Wails/web API contracts: `go test -race -v -timeout 20m ./internal/guiapp ./internal/webserver ./internal/guishared ./pkg/api`.
-- Frontend bridge/types: `pnpm --dir gui/frontend run typecheck` and `pnpm --dir gui/frontend run test:unit`.
+- WebUI API contracts: `go test -race -v -timeout 20m ./internal/webserver/... ./pkg/api`.
+- Browser clients/types: `pnpm --dir webui run typecheck` and `pnpm --dir webui run test:unit`.
 - Embedded runtime/UI behavior: build frontend, sync embedded assets, rebuild CLI, then inspect embedded web on `http://localhost:7480`.
 - Full shared-regression sweep when behavior crosses several entrypoints: `make test-go` plus relevant frontend checks.
diff --git a/pkg/api/application_info.go b/pkg/api/application_info.go
index b3b82a33..3b761228 100644
--- a/pkg/api/application_info.go
+++ b/pkg/api/application_info.go
@@ -13,7 +13,7 @@ import (
 )
 
 // ApplicationInfo describes the running build and optional runtime capability
-// probes returned by Wails and embedded web entrypoints.
+// probes returned by WebUI entrypoints.
 type ApplicationInfo struct {
 	Version         string `json:"version"`
 	BuildIdentifier string `json:"buildIdentifier"`
diff --git a/pkg/api/core.go b/pkg/api/core.go
index 6673582b..d8f5fbcf 100644
--- a/pkg/api/core.go
+++ b/pkg/api/core.go
@@ -3,55 +3,36 @@
 
 package api
 
-import (
-	"context"
-)
-
-// Mode identifies the entrypoint building a core request.
-type Mode string
-
-const (
-	// ModeCLI marks requests started from the command-line entrypoint.
-	ModeCLI Mode = "cli"
-	// ModeGUI marks requests started from GUI or embedded web entrypoints.
-	ModeGUI Mode = "gui"
-)
-
-// Request carries one core operation across CLI, Wails, and embedded web.
-// Paths and path-keyed maps use host filesystem source paths as keys.
+// Request carries one core operation across CLI and WebUI.
 type Request struct {
-	Paths                        []string
-	Mode                         Mode
-	Options                      UploadOptions
-	Execution                    ExecutionOptions
-	DescriptionGroups            []DescriptionBuilderGroup
-	Trackers                     []string
-	TrackersRemove               []string
-	IgnoreTrackerRuleFailures    bool
-	IgnoreTrackerRuleFailuresFor []string
-	IgnoreDupesFor               []string
-	SkipDupeCheck                bool
-	SkipDupeAsActual             bool
-	DoubleDupeCheck              bool
-	SourceLookupURL              string
-	DescriptionOverrideRaw       string
-	DescriptionOverrideURL       string
-	DescriptionOverrideGroup     string
-	MetadataOverrides            MetadataOverrides
-	TrackerConfigOverrides       TrackerConfigOverrides
-	TrackerSiteOverrides         TrackerSiteOverrides
-	ClientOverrides              ClientOverrides
-	ImageHostOverrides           ImageHostOverrides
-	ScreenshotOverrides          ScreenshotOverrides
-	TorrentOverrides             TorrentOverrides
-	TrackerIDOverrides           map[string]string
-	ExternalIDOverrides          ExternalIDOverrides
-	ExternalIDSelections         map[string]ExternalIDSelection // keyed by source path, value is selected external IDs for that path
-	ReleaseNameOverrides         ReleaseNameOverrides
-	TrackerQuestionnaireAnswers  map[string]map[string]string // keyed by tracker, then questionnaire field key
-	PlaylistSelections           map[string][]string          // keyed by source path, value is selected playlist files
-	PlaylistSelectionsUseAll     map[string]bool              // keyed by source path, value is use-all flag
-	ConfirmBDMVRescan            bool
+	SourcePath                  string
+	Options                     UploadOptions
+	Execution                   ExecutionOptions
+	DescriptionGroups           []DescriptionBuilderGroup
+	Trackers                    []string
+	TrackersRemove              []string
+	RuleAuthorizations          []RuleAuthorization
+	IgnoreDupesFor              []string
+	SkipDupeCheck               bool
+	SkipDupeAsActual            bool
+	DoubleDupeCheck             bool
+	SourceLookupURL             string
+	DescriptionOverrideRaw      string
+	DescriptionOverrideURL      string
+	DescriptionOverrideGroup    string
+	MetadataOverrides           MetadataOverrides
+	TrackerConfigOverrides      TrackerConfigOverrides
+	TrackerSiteOverrides        TrackerSiteOverrides
+	ClientOverrides             ClientOverrides
+	ImageHostOverrides          ImageHostOverrides
+	ScreenshotOverrides         ScreenshotOverrides
+	TorrentOverrides            TorrentOverrides
+	TrackerIDOverrides          map[string]string
+	ExternalIDOverrides         ExternalIDOverrides
+	ReleaseNameOverrides        ReleaseNameOverrides
+	TrackerQuestionnaireAnswers map[string]map[string]string // keyed by tracker, then questionnaire field key
+	PlaylistInstruction         PlaylistInstruction
+	ConfirmBDMVRescan           bool
 }
 
 // ExecutionOptions controls queued and site-check execution behavior.
@@ -62,23 +43,9 @@ type ExecutionOptions struct {
 	SiteUploadTracker string
 }
 
-// ExternalIDSelection records per-source-path user ID choices copied across
-// resolved CLI/UI paths. Nil provider fields mean no user choice; non-nil
-// fields follow [ExternalIDOverrides] positive-value and zero-clear semantics.
-type ExternalIDSelection struct {
-	TMDBID   *int
-	IMDBID   *int
-	TVDBID   *int
-	TVmazeID *int
-	// MALID stores user selection for the canonical MAL/AniList-compatible
-	// anime identifier for this source path.
-	MALID *int
-}
-
-// UploadOptions contains per-run upload and preview behavior flags.
+// UploadOptions contains per-run preparation and upload choices. The invoked
+// operation, rather than a mode flag, determines whether trackers are submitted.
 type UploadOptions struct {
-	Debug           bool
-	DryRun          bool
 	RunLogLevel     string
 	Screens         int
 	NoSeed          bool
@@ -117,60 +84,19 @@ type Result struct {
 	UploadedCount int
 }
 
-// Core defines the shared upload, preview, history, screenshot, and description
-// operations used by CLI, Wails, and embedded web entrypoints.
-type Core interface {
-	RunUpload(ctx context.Context, req Request) (Result, error)
-	RunUploadPrepared(ctx context.Context, req Request) (Result, error)
-	FetchMetadataPreview(ctx context.Context, req Request) (MetadataPreview, error)
-	// FetchDescriptionBuilderPreview returns editable description groups for one
-	// source path. Non-empty request trackers limit group generation to that set.
-	FetchDescriptionBuilderPreview(ctx context.Context, req Request) (DescriptionBuilderPreview, error)
-	// FetchDescriptionBuilderGroupPreview rebuilds one editable description group
-	// for the requested source path and selected tracker set.
-	FetchDescriptionBuilderGroupPreview(ctx context.Context, req Request) (DescriptionBuilderGroup, error)
-	// FetchPreparationPreview returns tracker preparation details for one source
-	// path. Non-empty request trackers limit preparation to that set.
-	FetchPreparationPreview(ctx context.Context, req Request) (PreparationPreview, error)
-	FetchTrackerDryRunPreview(ctx context.Context, req Request) (TrackerDryRunPreview, error)
-	CheckDupes(ctx context.Context, req Request) (DupeCheckSummary, error)
-	BuildUploadReview(ctx context.Context, req Request) (UploadReview, error)
-	FetchScreenshotPlan(ctx context.Context, req Request) (ScreenshotPlan, error)
-	GenerateScreenshots(ctx context.Context, req Request, selections []ScreenshotSelection, purpose ScreenshotPurpose) (ScreenshotResult, error)
-	PreviewScreenshotFrame(ctx context.Context, req Request, timestampSeconds float64) (ScreenshotPreview, error)
-	DeleteScreenshot(ctx context.Context, req Request, imagePath string) error
-	DeleteTrackerImageURL(ctx context.Context, req Request, url string) error
-	SaveFinalScreenshotSelections(ctx context.Context, req Request, images []ScreenshotImage) error
-	// CaptureDVDMenus captures and persists bounded automatic menu images for one prepared DVD.
-	CaptureDVDMenus(ctx context.Context, req Request) (DVDMenuCaptureResult, error)
-	// ListDVDMenuScreenshots lists persisted manual and automatic menu images for one prepared source.
-	ListDVDMenuScreenshots(ctx context.Context, req Request) ([]ScreenshotImage, error)
-	// DeleteDVDMenuScreenshot removes one managed menu image and its local references.
-	DeleteDVDMenuScreenshot(ctx context.Context, req Request, imagePath string) error
-	ListUploadCandidates(ctx context.Context, req Request) ([]ScreenshotImage, error)
-	ListUploadedImages(ctx context.Context, req Request) ([]UploadedImageLink, error)
-	UploadImages(ctx context.Context, req Request, host string, images []ScreenshotImage) (UploadImagesResult, error)
-	DeleteUploadedImage(ctx context.Context, req Request, imagePath string, host string) error
-	ImportMenuImages(ctx context.Context, req Request, paths []string) error
-	DiscoverPlaylists(ctx context.Context, sourcePath string) ([]PlaylistInfo, error)
-	SavePlaylistSelection(ctx context.Context, sourcePath string, playlists []string, useAll bool) error
-	LoadPlaylistSelection(ctx context.Context, sourcePath string) (PlaylistSelection, error)
-	ListHistory(ctx context.Context) ([]HistoryEntry, error)
-	GetHistoryOverview(ctx context.Context, sourcePath string) (HistoryOverview, error)
-	DeleteHistoryRelease(ctx context.Context, sourcePath string) error
-	DeleteAllHistoryReleases(ctx context.Context) (int, error)
-	RenderDescription(ctx context.Context, raw string) (string, error)
-	SaveDescriptionOverride(ctx context.Context, req Request, raw string) (DescriptionBuilderGroup, error)
-	Close() error
-}
-
 // Config defines the minimum application configuration contract required by core wiring.
 // Keeping this in pkg/api avoids leaking internal package types into exported APIs.
 type Config interface {
 	Validate() error
 }
 
-// CoreDependencies supplies the externally owned services used to construct a Core.
+// RepositoryOwner owns repository lifecycle separately from borrowed
+// capabilities. Core never closes an externally supplied owner.
+type RepositoryOwner interface {
+	Close() error
+}
+
+// CoreDependencies supplies the externally owned services used to construct the core runtime.
 type CoreDependencies struct {
 	// Config is validated before the core is created.
 	Config Config
@@ -178,15 +104,13 @@ type CoreDependencies struct {
 	Logger Logger
 	// Services supplies optional service overrides; zero values use the core defaults.
 	Services ServiceSet
-	// Repository stores metadata and history. Nil opens and owns a SQLite repository from Config.
-	Repository MetadataRepository
+	// Repository supplies immutable borrowed persistence capabilities. Its zero
+	// value opens and owns a SQLite repository from Config.
+	Repository RepositoryCapabilities
+	// RepositoryOwner identifies the externally owned adapter used to build
+	// Repository. It remains borrowed and is used only for owner-specific setup.
+	RepositoryOwner RepositoryOwner
 	// SkipCookieMigration skips legacy cookie migration for callers that already
 	// synchronize cookie encryption state with the shared repository.
 	SkipCookieMigration bool
 }
-
-// CoreImpl is the exported concrete-core contract used by packages that accept
-// any current core implementation.
-type CoreImpl interface {
-	Core
-}
diff --git a/pkg/api/display.go b/pkg/api/display.go
new file mode 100644
index 00000000..1f2310eb
--- /dev/null
+++ b/pkg/api/display.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+// PreparedReleaseDisplay is the canonical presentation projection for one
+// exact prepared generation.
+type PreparedReleaseDisplay struct {
+	ReleaseName string
+	Providers   []ProviderDisplay
+}
+
+// ProviderDisplay is one provider-local display projection. Details contains
+// exactly one payload matching Provider.
+type ProviderDisplay struct {
+	Provider         IdentityProvider
+	ID               int
+	DisplayID        string
+	URL              string
+	Provenance       IdentityProvenance
+	SummaryAvailable bool
+	Summary          ProviderDisplaySummary
+	Details          ProviderDisplayDetails
+}
+
+// ProviderDisplaySummary is the normalized provider presentation shared by
+// CLI, WebUI preview, and history.
+type ProviderDisplaySummary struct {
+	Title            string
+	OriginalTitle    string
+	Year             int
+	Overview         string
+	PosterURL        string
+	BackdropURL      string
+	Category         string
+	Date             string
+	EndDate          string
+	OriginalLanguage string
+	MediaType        string
+	RuntimeMinutes   int
+	Genres           string
+	Keywords         string
+	TrailerURL       string
+	Rating           float64
+	RatingCount      int
+	Country          string
+}
+
+// ProviderDisplayDetails is a closed typed provider payload union. Projection
+// validation guarantees exactly one non-nil field matching Provider.
+type ProviderDisplayDetails struct {
+	TMDB    *TMDBMetadata    `json:",omitempty"`
+	IMDB    *IMDBMetadata    `json:",omitempty"`
+	TVDB    *TVDBMetadata    `json:",omitempty"`
+	TVmaze  *TVmazeMetadata  `json:",omitempty"`
+	AniList *AniListMetadata `json:",omitempty"`
+}
diff --git a/pkg/api/display_test.go b/pkg/api/display_test.go
new file mode 100644
index 00000000..74c469b8
--- /dev/null
+++ b/pkg/api/display_test.go
@@ -0,0 +1,66 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestPreparedReleaseDisplayFixtureAndFrontendContract(t *testing.T) {
+	t.Parallel()
+
+	data, err := os.ReadFile(filepath.Join("testdata", "prepared_release_display.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var display PreparedReleaseDisplay
+	if err := json.Unmarshal(data, &display); err != nil {
+		t.Fatal(err)
+	}
+	wantOrder := []IdentityProvider{
+		IdentityProviderTMDB,
+		IdentityProviderIMDB,
+		IdentityProviderTVDB,
+		IdentityProviderTVmaze,
+		IdentityProviderMAL,
+	}
+	if len(display.Providers) != len(wantOrder) {
+		t.Fatalf("provider count = %d, want %d", len(display.Providers), len(wantOrder))
+	}
+	for index, provider := range display.Providers {
+		if provider.Provider != wantOrder[index] {
+			t.Fatalf("provider[%d] = %q, want %q", index, provider.Provider, wantOrder[index])
+		}
+		value := reflect.ValueOf(provider.Details)
+		nonNil := 0
+		for _, field := range value.Fields() {
+			if !field.IsNil() {
+				nonNil++
+			}
+		}
+		if nonNil != 1 {
+			t.Fatalf("provider %q detail variants = %d, want 1", provider.Provider, nonNil)
+		}
+	}
+
+	frontendTypes := readRepoFile(t, "webui", "src", "types.ts")
+	for _, required := range []string{
+		"export type PreparedReleaseDisplay = {",
+		"export type ProviderDisplaySummary = {",
+		`Provider: "tmdb"; Details: { TMDB: TMDBMetadata }`,
+		`Provider: "imdb"; Details: { IMDB: IMDBMetadata }`,
+		`Provider: "tvdb"; Details: { TVDB: TVDBMetadata }`,
+		`Provider: "tvmaze"; Details: { TVmaze: TVmazeMetadata }`,
+		`Provider: "mal"; Details: { AniList: AniListMetadata }`,
+	} {
+		if !strings.Contains(frontendTypes, required) {
+			t.Fatalf("frontend display contract missing %q", required)
+		}
+	}
+}
diff --git a/pkg/api/dupes.go b/pkg/api/dupes.go
index 66790e17..26f32e5a 100644
--- a/pkg/api/dupes.go
+++ b/pkg/api/dupes.go
@@ -3,7 +3,10 @@
 
 package api
 
-import "time"
+import (
+	"strings"
+	"time"
+)
 
 // DupeEntry describes one tracker duplicate-search hit before or after local
 // filtering.
@@ -59,8 +62,7 @@ type DupeMatch struct {
 // DupeCheckResult is the duplicate-search outcome for one tracker. Raw contains
 // tracker results before filtering, Filtered contains blocking matches, and
 // skipped or failed checks carry Status plus SkipReason or Error. SkipCode is a
-// stable machine-readable reason, while SkipRules names upload rules that caused
-// rule-failure skips.
+// stable machine-readable reason.
 type DupeCheckResult struct {
 	Tracker     string
 	Raw         []DupeEntry
@@ -72,9 +74,7 @@ type DupeCheckResult struct {
 	Skipped     bool
 	SkipReason  string
 	// SkipCode is a stable machine-readable skip reason.
-	SkipCode string
-	// SkipRules are upload rule keys that produced a rule-failure skip.
-	SkipRules []string
+	SkipCode  string
 	Status    string
 	Error     string
 	CheckedAt time.Time `ts_type:"string"`
@@ -83,7 +83,67 @@ type DupeCheckResult struct {
 // DupeCheckSummary groups duplicate-search results for one prepared source
 // path.
 type DupeCheckSummary struct {
-	SourcePath string
-	Results    []DupeCheckResult
-	Notes      []string
+	SourcePath  string
+	Results     []DupeCheckResult
+	Notes       []string
+	Eligibility TrackerEligibility
+}
+
+// NewAcceptedDuplicateEvidence detaches one completed duplicate summary for
+// transfer into an accepted dry-run plan.
+func NewAcceptedDuplicateEvidence(release ReleaseRef, trackers []string, summary DupeCheckSummary) AcceptedDuplicateEvidence {
+	selected := make(map[string]struct{}, len(trackers))
+	for _, tracker := range trackers {
+		if tracker = strings.ToUpper(strings.TrimSpace(tracker)); tracker != "" {
+			selected[tracker] = struct{}{}
+		}
+	}
+	results := make([]DupeCheckResult, 0, len(selected))
+	for _, result := range summary.Results {
+		if _, ok := selected[strings.ToUpper(strings.TrimSpace(result.Tracker))]; ok {
+			results = append(results, result)
+		}
+	}
+	return AcceptedDuplicateEvidence{
+		Release:  release,
+		Trackers: append([]string(nil), trackers...),
+		Results:  CloneDupeCheckResults(results),
+	}
+}
+
+// Clone returns duplicate evidence detached from caller-owned slices.
+func (e AcceptedDuplicateEvidence) Clone() AcceptedDuplicateEvidence {
+	e.Trackers = append([]string(nil), e.Trackers...)
+	e.Results = CloneDupeCheckResults(e.Results)
+	return e
+}
+
+// CloneDupeCheckResults returns duplicate results with every nested mutable
+// collection detached from its source.
+func CloneDupeCheckResults(results []DupeCheckResult) []DupeCheckResult {
+	if results == nil {
+		return nil
+	}
+	cloned := make([]DupeCheckResult, len(results))
+	for index, result := range results {
+		result.Raw = cloneDupeEntries(result.Raw)
+		result.Filtered = cloneDupeEntries(result.Filtered)
+		result.Match.MatchedEpisodeIDs = append([]DupeEpisodeMatch(nil), result.Match.MatchedEpisodeIDs...)
+		result.Notes = append([]string(nil), result.Notes...)
+		cloned[index] = result
+	}
+	return cloned
+}
+
+func cloneDupeEntries(entries []DupeEntry) []DupeEntry {
+	if entries == nil {
+		return nil
+	}
+	cloned := make([]DupeEntry, len(entries))
+	for index, entry := range entries {
+		entry.Files = append([]string(nil), entry.Files...)
+		entry.Flags = append([]string(nil), entry.Flags...)
+		cloned[index] = entry
+	}
+	return cloned
 }
diff --git a/pkg/api/dupes_test.go b/pkg/api/dupes_test.go
new file mode 100644
index 00000000..686b8690
--- /dev/null
+++ b/pkg/api/dupes_test.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import "testing"
+
+func TestNewAcceptedDuplicateEvidenceFiltersSelectionAndDeepCopiesResults(t *testing.T) {
+	t.Parallel()
+
+	summary := DupeCheckSummary{Results: []DupeCheckResult{
+		{
+			Tracker:   "BLU",
+			Status:    "completed",
+			Raw:       []DupeEntry{{Name: "Example.Release.2026.1080p-GRP", Files: []string{"video.mkv"}}},
+			Match:     DupeMatch{MatchedEpisodeIDs: []DupeEpisodeMatch{{ID: "1"}}},
+		},
+		{Tracker: "AITHER", Status: "completed"},
+	}}
+	evidence := NewAcceptedDuplicateEvidence(
+		ReleaseRef{SourcePath: "Example.Release.2026.1080p-GRP.mkv", Generation: 1},
+		[]string{"blu"},
+		summary,
+	)
+	if len(evidence.Results) != 1 || evidence.Results[0].Tracker != "BLU" {
+		t.Fatalf("accepted results = %#v", evidence.Results)
+	}
+	evidence.Results[0].Raw[0].Files[0] = "mutated.mkv"
+	evidence.Results[0].Match.MatchedEpisodeIDs[0].ID = "mutated"
+	if summary.Results[0].Raw[0].Files[0] != "video.mkv" ||
+		summary.Results[0].Match.MatchedEpisodeIDs[0].ID != "1" {
+		t.Fatalf("summary mutated through evidence: %#v", summary.Results[0])
+	}
+}
diff --git a/pkg/api/dvd_menu_progress.go b/pkg/api/dvd_menu_progress.go
index 8594ae1f..c5800a41 100644
--- a/pkg/api/dvd_menu_progress.go
+++ b/pkg/api/dvd_menu_progress.go
@@ -24,38 +24,6 @@ type DVDMenuProgressUpdate struct {
 	WarningCount int `json:"warningCount"`
 }
 
-// DVDMenuCaptureSnapshot reports frontend-visible state for one capture job.
-type DVDMenuCaptureSnapshot struct {
-	// JobID is the opaque identifier used for polling and cancellation.
-	JobID string `json:"jobID"`
-	// SourcePath is the host filesystem path associated with the prepared metadata.
-	SourcePath string `json:"sourcePath"`
-	// Status is queued, running, completed, failed, or canceled.
-	Status string `json:"status"`
-	// Phase is the current capture stage within Status.
-	Phase string `json:"phase"`
-	// Message is a user-facing progress or terminal summary.
-	Message string `json:"message"`
-	// DiscoveredMenus is the latest structural inventory count.
-	DiscoveredMenus int `json:"discoveredMenus"`
-	// VisitedStates is the latest evaluated VM-state count.
-	VisitedStates int `json:"visitedStates"`
-	// VisitedButtons is the latest evaluated button-command count.
-	VisitedButtons int `json:"visitedButtons"`
-	// CapturedCount is the latest rendered or persisted image count.
-	CapturedCount int `json:"capturedCount"`
-	// WarningCount is the latest distinct coverage-warning count.
-	WarningCount int `json:"warningCount"`
-	// Result is populated with the final or partial engine result when available.
-	Result DVDMenuCaptureResult `json:"result"`
-	// Error contains terminal failure text and is empty for successful jobs.
-	Error string `json:"error"`
-	// StartedAt is an RFC3339 UTC timestamp.
-	StartedAt string `json:"startedAt"`
-	// FinishedAt is an RFC3339 UTC timestamp, or empty while the job is active.
-	FinishedAt string `json:"finishedAt"`
-}
-
 // DVDMenuProgressReporter receives capture progress updates.
 type DVDMenuProgressReporter func(update DVDMenuProgressUpdate)
 
diff --git a/pkg/api/dvd_menus.go b/pkg/api/dvd_menus.go
index 69c893ba..d3c11000 100644
--- a/pkg/api/dvd_menus.go
+++ b/pkg/api/dvd_menus.go
@@ -8,7 +8,7 @@ import "context"
 // DVDMenuDiscovery describes how the navigation engine found a menu screen.
 type DVDMenuDiscovery string
 
-// DVD menu discovery sources serialized across CLI, Wails, and embedded web.
+// DVD menu discovery sources serialized across CLI and WebUI.
 const (
 	// DVDMenuDiscoveryReachable marks a screen reached by deterministic VM navigation.
 	DVDMenuDiscoveryReachable DVDMenuDiscovery = "reachable"
diff --git a/pkg/api/history.go b/pkg/api/history.go
index bb8c91e4..58f61660 100644
--- a/pkg/api/history.go
+++ b/pkg/api/history.go
@@ -17,10 +17,35 @@ type HistoryEntry struct {
 	LatestUploadStatus string
 	LatestUploadAt     time.Time `ts_type:"string"`
 	RuleFailureCount   int
-	// RuleWarningCount excludes blocking, legacy, and unrecognized rule results.
-	RuleWarningCount int
+	// RuleAdvisoryCount contains non-blocking advisory rule results.
+	RuleAdvisoryCount int
 }
 
+// HistoryRecord is the persistence-facing history aggregate. Prepared facts
+// remain behind PreparedReleaseRepository and are referenced only by exact ID.
+type HistoryRecord struct {
+	SourcePath           string
+	ReleaseTitle         string
+	ReleaseSource        string
+	ReleaseResolution    string
+	MetadataUpdatedAt    time.Time `ts_type:"string"`
+	LatestUploadStatus   string
+	LatestUploadAt       time.Time `ts_type:"string"`
+	Metadata             FileMetadata
+	PreparedReleaseRef   *ReleaseRef
+	ReleaseNameOverrides ReleaseNameOverrides
+	DescriptionOverride  DescriptionOverride
+	DescriptionOverrides []DescriptionOverride
+	PlaylistSelection    PlaylistSelection
+	TrackerMetadata      []TrackerMetadata
+	TrackerRuleFailures  []TrackerRuleFailure
+	Screenshots          []Screenshot
+	FinalSelections      []ScreenshotFinalSelection
+	UploadedImages       []UploadedImageLink
+	UploadHistory        []UploadRecord
+}
+
+// HistoryOverview is the transport projection for one stored release.
 type HistoryOverview struct {
 	SourcePath           string
 	ReleaseTitle         string
@@ -31,8 +56,9 @@ type HistoryOverview struct {
 	LatestUploadAt       time.Time `ts_type:"string"`
 	StatusLabel          string
 	Metadata             FileMetadata
-	ExternalIDs          ExternalIDs
-	ExternalMetadata     ExternalMetadata
+	Release              ReleaseRef
+	Identity             ExternalIdentity
+	Display              PreparedReleaseDisplay
 	ReleaseNameOverrides ReleaseNameOverrides
 	DescriptionOverride  DescriptionOverride
 	DescriptionOverrides []DescriptionOverride
diff --git a/pkg/api/image_upload_progress.go b/pkg/api/image_upload_progress.go
new file mode 100644
index 00000000..0e50ffdb
--- /dev/null
+++ b/pkg/api/image_upload_progress.go
@@ -0,0 +1,121 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"context"
+	"strings"
+)
+
+// ImageUploadProgressStatus describes the latest advisory state of one host attempt.
+type ImageUploadProgressStatus string
+
+const (
+	// ImageUploadProgressRunning marks a host attempt that still has pending images.
+	ImageUploadProgressRunning ImageUploadProgressStatus = "running"
+	// ImageUploadProgressCompleted marks a host attempt whose images are all ready.
+	ImageUploadProgressCompleted ImageUploadProgressStatus = "completed"
+	// ImageUploadProgressFailed marks a host attempt with one or more failed images.
+	ImageUploadProgressFailed ImageUploadProgressStatus = "failed"
+)
+
+// ImageUploadProgressTarget identifies one host/scope attempt and its immutable
+// presentation metadata. Total includes reused images as well as network uploads.
+type ImageUploadProgressTarget struct {
+	// AttemptID is stable for the host/scope pair within one command.
+	AttemptID string
+	// Host is the normalized configured image-host name.
+	Host string
+	// UsageScope distinguishes global and tracker-owned upload records.
+	UsageScope string
+	// Trackers lists upload targets served by this host attempt.
+	Trackers []string
+	// Fallback reports whether this attempt follows an earlier host failure.
+	Fallback bool
+	// Total is the number of selected images required on this host.
+	Total int
+	// Reused is the subset already available from persisted host records.
+	Reused int
+}
+
+// ImageUploadProgressUpdate is one frontend-safe absolute snapshot for a host
+// attempt. CorrelationID and Timestamp are injected by the WebUI boundary.
+type ImageUploadProgressUpdate struct {
+	// CorrelationID binds the update to one frontend upload command.
+	CorrelationID string `json:"correlationID"`
+	// AttemptID identifies the host/scope row updated by this snapshot.
+	AttemptID string `json:"attemptID"`
+	// Host is the normalized configured image-host name.
+	Host string `json:"host"`
+	// UsageScope distinguishes global and tracker-owned upload records.
+	UsageScope string `json:"usageScope"`
+	// Trackers lists upload targets served by this host attempt.
+	Trackers []string `json:"trackers"`
+	// Fallback reports whether this attempt follows an earlier host failure.
+	Fallback bool `json:"fallback"`
+	// Completed counts succeeded, failed, and reused images in terminal states.
+	Completed int `json:"completed"`
+	// Total is the number of selected images required on this host.
+	Total int `json:"total"`
+	// Succeeded counts completed network uploads in this attempt.
+	Succeeded int `json:"succeeded"`
+	// Failed counts completed network uploads that did not produce a usable link.
+	Failed int `json:"failed"`
+	// Reused counts images satisfied by existing persisted host records.
+	Reused int `json:"reused"`
+	// Status is the latest advisory state for this host attempt.
+	Status ImageUploadProgressStatus `json:"status"`
+	// Message provides frontend-safe detail about the latest transition.
+	Message string `json:"message"`
+	// Timestamp is an RFC3339 timestamp injected by the WebUI boundary.
+	Timestamp string `json:"timestamp"`
+}
+
+// ImageUploadProgressReporter receives advisory image-host progress snapshots.
+type ImageUploadProgressReporter func(update ImageUploadProgressUpdate)
+
+type imageUploadProgressReporterKey struct{}
+type imageUploadProgressTargetKey struct{}
+
+// WithImageUploadProgressReporter attaches an optional reporter to ctx.
+func WithImageUploadProgressReporter(ctx context.Context, reporter ImageUploadProgressReporter) context.Context {
+	if ctx == nil || reporter == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, imageUploadProgressReporterKey{}, reporter)
+}
+
+// WithImageUploadProgressTarget attaches immutable metadata for one host attempt.
+func WithImageUploadProgressTarget(ctx context.Context, target ImageUploadProgressTarget) context.Context {
+	if ctx == nil {
+		return ctx
+	}
+	target.AttemptID = strings.TrimSpace(target.AttemptID)
+	target.Host = strings.ToLower(strings.TrimSpace(target.Host))
+	target.UsageScope = strings.TrimSpace(target.UsageScope)
+	target.Trackers = append([]string(nil), target.Trackers...)
+	target.Total = max(0, target.Total)
+	target.Reused = max(0, min(target.Reused, target.Total))
+	return context.WithValue(ctx, imageUploadProgressTargetKey{}, target)
+}
+
+// ImageUploadProgressTargetFromContext returns the current host attempt when present.
+func ImageUploadProgressTargetFromContext(ctx context.Context) (ImageUploadProgressTarget, bool) {
+	if ctx == nil {
+		return ImageUploadProgressTarget{}, false
+	}
+	target, ok := ctx.Value(imageUploadProgressTargetKey{}).(ImageUploadProgressTarget)
+	return target, ok
+}
+
+// EmitImageUploadProgress reports one absolute snapshot when a reporter is installed.
+func EmitImageUploadProgress(ctx context.Context, update ImageUploadProgressUpdate) {
+	if ctx == nil {
+		return
+	}
+	reporter, _ := ctx.Value(imageUploadProgressReporterKey{}).(ImageUploadProgressReporter)
+	if reporter != nil {
+		reporter(update)
+	}
+}
diff --git a/pkg/api/image_upload_progress_test.go b/pkg/api/image_upload_progress_test.go
new file mode 100644
index 00000000..b7a4887f
--- /dev/null
+++ b/pkg/api/image_upload_progress_test.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestImageUploadProgressContextAndJSONContract(t *testing.T) {
+	var updates []ImageUploadProgressUpdate
+	ctx := WithImageUploadProgressReporter(context.Background(), func(update ImageUploadProgressUpdate) {
+		updates = append(updates, update)
+	})
+	target := ImageUploadProgressTarget{
+		AttemptID:  "imgbox|global",
+		Host:       "IMGBOX",
+		UsageScope: "global",
+		Trackers:   []string{"AITHER", "ANT"},
+		Total:      4,
+		Reused:     1,
+	}
+	ctx = WithImageUploadProgressTarget(ctx, target)
+	stored, ok := ImageUploadProgressTargetFromContext(ctx)
+	if !ok || stored.Host != "imgbox" || stored.Reused != 1 {
+		t.Fatalf("unexpected stored target: %#v", stored)
+	}
+
+	EmitImageUploadProgress(ctx, ImageUploadProgressUpdate{
+		AttemptID: "imgbox|global",
+		Host:      "imgbox",
+		Completed: 2,
+		Total:     4,
+		Succeeded: 1,
+		Reused:    1,
+		Status:    ImageUploadProgressRunning,
+	})
+	if len(updates) != 1 || updates[0].Completed != 2 {
+		t.Fatalf("unexpected updates: %#v", updates)
+	}
+	encoded, err := json.Marshal(updates[0])
+	if err != nil {
+		t.Fatalf("marshal update: %v", err)
+	}
+	jsonValue := string(encoded)
+	for _, field := range []string{`"attemptID"`, `"completed"`, `"succeeded"`, `"fallback"`} {
+		if !strings.Contains(jsonValue, field) {
+			t.Fatalf("JSON missing %s: %s", field, jsonValue)
+		}
+	}
+}
diff --git a/pkg/api/metadata_errors.go b/pkg/api/metadata_errors.go
index f4649177..71e905d0 100644
--- a/pkg/api/metadata_errors.go
+++ b/pkg/api/metadata_errors.go
@@ -5,15 +5,20 @@ package api
 
 import "strings"
 
-const ErrCodeBDMVRescanRequired = "bdmv_rescan_required"
-
+// BDMVRescanRequiredError reports a partial cached Blu-ray analysis that needs
+// caller confirmation before rescanning the selected playlists.
 type BDMVRescanRequiredError struct {
-	SourcePath        string
+	// SourcePath identifies the requested local Blu-ray source.
+	SourcePath string
+	// SelectedPlaylists contains the complete requested playlist set.
 	SelectedPlaylists []string
-	CachedPlaylists   []string
-	MissingPlaylists  []string
+	// CachedPlaylists contains the playlists already present in the cache.
+	CachedPlaylists []string
+	// MissingPlaylists contains the selected playlists that require a rescan.
+	MissingPlaylists []string
 }
 
+// Error returns a stable confirmation-required message without the source path.
 func (e *BDMVRescanRequiredError) Error() string {
 	if e == nil {
 		return ""
@@ -23,3 +28,34 @@ func (e *BDMVRescanRequiredError) Error() string {
 	}
 	return "BDMV rescan confirmation required for playlist(s): " + strings.Join(e.MissingPlaylists, ", ")
 }
+
+// PlaylistSelectionRequiredError reports a BDMV preparation without a usable
+// direct or remembered playlist selection.
+type PlaylistSelectionRequiredError struct {
+	// SourcePath identifies the requested local Blu-ray source.
+	SourcePath string
+}
+
+// Error returns the stable playlist-selection-required message.
+func (*PlaylistSelectionRequiredError) Error() string {
+	return "Blu-ray playlist selection is required"
+}
+
+// InvalidPlaylistSelectionError reports a selected playlist that cannot be
+// safely resolved from the current BDMV source.
+type InvalidPlaylistSelectionError struct {
+	// SourcePath identifies the requested local Blu-ray source.
+	SourcePath string
+	// Playlist identifies the rejected playlist when one was available.
+	Playlist string
+	// Reason explains the validation failure and is appended to Error's result.
+	Reason string
+}
+
+// Error returns the stable invalid-selection message and any non-empty reason.
+func (e *InvalidPlaylistSelectionError) Error() string {
+	if e == nil || strings.TrimSpace(e.Reason) == "" {
+		return "Blu-ray playlist selection is invalid"
+	}
+	return "Blu-ray playlist selection is invalid: " + strings.TrimSpace(e.Reason)
+}
diff --git a/pkg/api/metadata_progress.go b/pkg/api/metadata_progress.go
deleted file mode 100644
index 91c71af3..00000000
--- a/pkg/api/metadata_progress.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package api
-
-import "context"
-
-type MetadataProgressUpdate struct {
-	Path      string `json:"path"`
-	Phase     string `json:"phase"`
-	Message   string `json:"message"`
-	Status    string `json:"status"`
-	Level     string `json:"level"`
-	Timestamp string `json:"timestamp"`
-}
-
-type MetadataProgressReporter func(update MetadataProgressUpdate)
-
-type metadataProgressReporterKey struct{}
-
-func WithMetadataProgressReporter(ctx context.Context, reporter MetadataProgressReporter) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	if reporter == nil {
-		return ctx
-	}
-	return context.WithValue(ctx, metadataProgressReporterKey{}, reporter)
-}
-
-func EmitMetadataProgress(ctx context.Context, update MetadataProgressUpdate) {
-	if ctx == nil {
-		return
-	}
-	reporter, _ := ctx.Value(metadataProgressReporterKey{}).(MetadataProgressReporter)
-	if reporter == nil {
-		return
-	}
-	reporter(update)
-}
diff --git a/pkg/api/operation_failure.go b/pkg/api/operation_failure.go
new file mode 100644
index 00000000..19678824
--- /dev/null
+++ b/pkg/api/operation_failure.go
@@ -0,0 +1,109 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import "errors"
+
+// OperationKind identifies the domain operation that failed.
+type OperationKind string
+
+const (
+	OperationKindUnknown        OperationKind = "unknown"
+	OperationKindPreparation    OperationKind = "preparation"
+	OperationKindDuplicateCheck OperationKind = "duplicate_check"
+	OperationKindDryRun         OperationKind = "dry_run"
+	OperationKindUploadReview   OperationKind = "upload_review"
+	OperationKindUploadExecute  OperationKind = "upload_execute"
+	OperationKindMedia          OperationKind = "media"
+	OperationKindDescription    OperationKind = "description"
+	OperationKindImageHosting   OperationKind = "image_hosting"
+)
+
+// OperationFailureCode is a stable machine-readable failure classification.
+type OperationFailureCode string
+
+const (
+	OperationFailureInvalidInput           OperationFailureCode = "invalid_input"
+	OperationFailureInvalidSource          OperationFailureCode = "invalid_source"
+	OperationFailureConfirmationRequired   OperationFailureCode = "confirmation_required"
+	OperationFailureStaleGeneration        OperationFailureCode = "stale_generation"
+	OperationFailureIncompatibleGeneration OperationFailureCode = "incompatible_generation"
+	OperationFailureMissingPrerequisite    OperationFailureCode = "missing_prerequisite"
+	OperationFailureTrackerAuthRequired    OperationFailureCode = "tracker_auth_required"
+	OperationFailureNoEligibleTrackers     OperationFailureCode = "no_eligible_trackers"
+	OperationFailureStaleReview            OperationFailureCode = "stale_review"
+	OperationFailureMissingReview          OperationFailureCode = "missing_review"
+	OperationFailureInternal               OperationFailureCode = "internal"
+)
+
+// OperationRecovery is the required caller action for a stable failure.
+type OperationRecovery string
+
+const (
+	OperationRecoveryNone                 OperationRecovery = "none"
+	OperationRecoveryEditInput            OperationRecovery = "edit_input"
+	OperationRecoveryConfirm              OperationRecovery = "confirm"
+	OperationRecoveryRefreshRelease       OperationRecovery = "refresh_release"
+	OperationRecoveryCompletePrerequisite OperationRecovery = "complete_prerequisite"
+	OperationRecoveryAuthenticateTrackers OperationRecovery = "authenticate_trackers"
+	OperationRecoverySelectTrackers       OperationRecovery = "select_trackers"
+	OperationRecoveryReviewAgain          OperationRecovery = "review_again"
+	OperationRecoveryRetry                OperationRecovery = "retry"
+)
+
+// OperationFailure is safe for CLI and browser transport. Raw causes are
+// intentionally excluded.
+type OperationFailure struct {
+	Code      OperationFailureCode
+	Operation OperationKind
+	Message   string
+	Recovery  OperationRecovery
+}
+
+// OperationError preserves one wrapped cause while exposing only its safe
+// failure through Error and Failure.
+type OperationError struct {
+	failure OperationFailure
+	cause   error
+}
+
+// NewOperationError creates a typed safe operation error.
+func NewOperationError(failure OperationFailure, cause error) *OperationError {
+	if cause == nil {
+		cause = errors.New("operation failed")
+	}
+	return &OperationError{failure: failure, cause: cause}
+}
+
+func (e *OperationError) Error() string {
+	if e == nil {
+		return "operation failed"
+	}
+	return e.failure.Message
+}
+
+// Unwrap retains errors.Is/errors.As access to the private cause.
+func (e *OperationError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.cause
+}
+
+// Failure returns the stable safe transport value.
+func (e *OperationError) Failure() OperationFailure {
+	if e == nil {
+		return OperationFailure{}
+	}
+	return e.failure
+}
+
+// AsOperationFailure extracts a stable failure from a wrapped error chain.
+func AsOperationFailure(err error) (OperationFailure, bool) {
+	var operationErr *OperationError
+	if !errors.As(err, &operationErr) {
+		return OperationFailure{}, false
+	}
+	return operationErr.Failure(), true
+}
diff --git a/pkg/api/operation_failure_test.go b/pkg/api/operation_failure_test.go
new file mode 100644
index 00000000..4a60831d
--- /dev/null
+++ b/pkg/api/operation_failure_test.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestOperationErrorExposesSafeFailureAndRetainsCause(t *testing.T) {
+	t.Parallel()
+
+	cause := errors.New("token=secret-value")
+	failure := OperationFailure{
+		Code:      OperationFailureNoEligibleTrackers,
+		Operation: OperationKindUploadReview,
+		Message:   "No selected trackers are eligible.",
+		Recovery:  OperationRecoverySelectTrackers,
+	}
+	err := fmt.Errorf("core boundary: %w", NewOperationError(failure, cause))
+	if err.Error() != "core boundary: No selected trackers are eligible." {
+		t.Fatalf("safe error = %q", err)
+	}
+	if !errors.Is(err, cause) {
+		t.Fatal("wrapped cause was not retained")
+	}
+	actual, ok := AsOperationFailure(err)
+	if !ok || actual != failure {
+		t.Fatalf("failure = %#v, %v", actual, ok)
+	}
+}
diff --git a/pkg/api/operations.go b/pkg/api/operations.go
new file mode 100644
index 00000000..dc06f190
--- /dev/null
+++ b/pkg/api/operations.go
@@ -0,0 +1,144 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+// DuplicateCheckInput contains duplicate-check choices for one exact prepared
+// generation. It does not carry prepared facts.
+type DuplicateCheckInput struct {
+	Release        ReleaseRef
+	Trackers       []string
+	Interaction    InteractionMode
+	IgnoreFor      []string
+	Skip           bool
+	SkipAsActual   bool
+	DoubleCheck    bool
+	Authorizations []string
+	// TrackerIDs contains explicit tracker IDs that override discovered client evidence.
+	TrackerIDs map[string]string
+}
+
+// UploadReviewInput contains review-time workflow choices for one exact
+// prepared generation.
+type UploadReviewInput struct {
+	Release                ReleaseRef
+	Trackers               []string
+	IgnoreDupesFor         []string
+	RuleAuthorizations     []RuleAuthorization
+	SkipDuplicateCheck     bool
+	SkipDuplicateAsActual  bool
+	DoubleDuplicateCheck   bool
+	QuestionnaireAnswers   map[string]map[string]string
+	TrackerIDOverrides     map[string]string
+	DescriptionGroups      []DescriptionBuilderGroup
+	TrackerConfigOverrides TrackerConfigOverrides
+	TrackerSiteOverrides   TrackerSiteOverrides
+	ClientOverrides        ClientOverrides
+	ImageHostOverrides     ImageHostOverrides
+	ScreenshotOverrides    ScreenshotOverrides
+	TorrentOverrides       TorrentOverrides
+	Options                UploadOptions
+}
+
+// UploadReviewOutcome contains tracker-scoped decisions established by one
+// completed review. It excludes prepared facts and mutable runtime state.
+type UploadReviewOutcome struct {
+	ResolvedTrackers    []string
+	Eligibility         TrackerEligibility
+	MatchedTrackers     []string
+	BlockedTrackers     map[string][]TrackerBlockReason
+	TrackerRuleFailures map[string][]RuleFailure
+	CrossSeedTorrents   []UploadedTorrent
+}
+
+// ReviewedUpload is the authoritative review result retained for accepted
+// execution. Review is transport-visible; Outcome is execution-only state.
+type ReviewedUpload struct {
+	Review  UploadReview
+	Outcome UploadReviewOutcome
+}
+
+// UploadExecutionPlan combines operation choices with the exact outcomes
+// authorized by review. Prepared facts remain behind Release and its seed.
+type UploadExecutionPlan struct {
+	Input   UploadReviewInput
+	Outcome UploadReviewOutcome
+}
+
+// UploadExecutionInput consumes one opaque, owner-scoped reviewed execution
+// snapshot. No live preparation or runtime state is accepted.
+type UploadExecutionInput struct {
+	ReviewToken string
+}
+
+// TrackerDryRunInput contains tracker-preview choices for one exact prepared
+// generation.
+type TrackerDryRunInput struct {
+	Release                ReleaseRef
+	Trackers               []string
+	IgnoreDupesFor         []string
+	QuestionnaireAnswers   map[string]map[string]string
+	DescriptionGroups      []DescriptionBuilderGroup
+	TrackerIDOverrides     map[string]string
+	TrackerConfigOverrides TrackerConfigOverrides
+	TrackerSiteOverrides   TrackerSiteOverrides
+	ClientOverrides        ClientOverrides
+	ImageHostOverrides     ImageHostOverrides
+	ScreenshotOverrides    ScreenshotOverrides
+	TorrentOverrides       TorrentOverrides
+	Options                UploadOptions
+}
+
+// AcceptedDuplicateEvidence contains one completed duplicate-check outcome for
+// the exact release and tracker selection consumed by a tracker dry run.
+type AcceptedDuplicateEvidence struct {
+	Release  ReleaseRef
+	Trackers []string
+	Results  []DupeCheckResult
+}
+
+// TrackerDryRunPlan combines dry-run choices with the completed duplicate
+// evidence accepted by the caller. Core validates both parts before building
+// tracker payloads or injecting any torrent.
+type TrackerDryRunPlan struct {
+	Input     TrackerDryRunInput
+	Duplicate AcceptedDuplicateEvidence
+}
+
+// MediaPlanInput contains media planning choices for one exact prepared
+// generation.
+type MediaPlanInput struct {
+	Release ReleaseRef
+	Count   int
+	Purpose ScreenshotPurpose
+	Options ScreenshotOverrides
+}
+
+// DescriptionInput contains description projection choices for one exact
+// prepared generation.
+type DescriptionInput struct {
+	Release           ReleaseRef
+	Trackers          []string
+	GroupKey          string
+	Groups            []DescriptionBuilderGroup
+	ImageHost         ImageHostOverrides
+	QuestionnaireData map[string]map[string]string
+	Options           UploadOptions
+}
+
+// ImageHostingInput contains image-host choices for one exact prepared
+// generation. Selected images are supplied separately to keep the subject
+// contract independent from transport payloads.
+type ImageHostingInput struct {
+	Release  ReleaseRef
+	Trackers []string
+	Host     string
+	Scope    string
+}
+
+// UploadReviewResult returns the review plus the opaque token required for
+// execution. The token identifies one exact preparation/runtime snapshot.
+type UploadReviewResult struct {
+	Review UploadReview
+	Token  string
+}
diff --git a/pkg/api/preparation_progress.go b/pkg/api/preparation_progress.go
new file mode 100644
index 00000000..432b4df0
--- /dev/null
+++ b/pkg/api/preparation_progress.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"context"
+	"strings"
+)
+
+// PreparationProgressPhase identifies one stable stage in canonical release
+// preparation. It is presentation telemetry, not prepared-release evidence.
+type PreparationProgressPhase string
+
+const (
+	// PreparationPhaseSourceInspection validates and classifies the requested source.
+	PreparationPhaseSourceInspection PreparationProgressPhase = "source_inspection"
+	// PreparationPhasePreparedCache checks whether an existing generation can be reused.
+	PreparationPhasePreparedCache PreparationProgressPhase = "prepared_cache"
+	// PreparationPhaseSourceEvidence collects filesystem and media-source facts.
+	PreparationPhaseSourceEvidence PreparationProgressPhase = "source_evidence"
+	// PreparationPhaseBDInfo analyzes selected Blu-ray playlists.
+	PreparationPhaseBDInfo PreparationProgressPhase = "bdinfo"
+	// PreparationPhaseClientDiscovery searches configured torrent clients.
+	PreparationPhaseClientDiscovery PreparationProgressPhase = "client_discovery"
+	// PreparationPhaseTrackerEvidence collects source metadata from trackers.
+	PreparationPhaseTrackerEvidence PreparationProgressPhase = "tracker_evidence"
+	// PreparationPhaseMediaInfoIdentity reads identifiers exposed by MediaInfo.
+	PreparationPhaseMediaInfoIdentity PreparationProgressPhase = "mediainfo_identity"
+	// PreparationPhaseArrIdentity queries configured Sonarr and Radarr services.
+	PreparationPhaseArrIdentity PreparationProgressPhase = "arr_identity"
+	// PreparationPhaseExternalIdentity resolves the canonical provider identity.
+	PreparationPhaseExternalIdentity PreparationProgressPhase = "external_identity"
+	// PreparationPhaseMediaFacts derives normalized release media facts.
+	PreparationPhaseMediaFacts PreparationProgressPhase = "media_facts"
+	// PreparationPhaseCanonicalIdentity finalizes canonical release identity.
+	PreparationPhaseCanonicalIdentity PreparationProgressPhase = "canonical_identity"
+	// PreparationPhaseGenerationCommit persists the prepared generation.
+	PreparationPhaseGenerationCommit PreparationProgressPhase = "generation_commit"
+	// PreparationPhasePreviewProjection builds the transport metadata preview.
+	PreparationPhasePreviewProjection PreparationProgressPhase = "preview_projection"
+	// PreparationPhaseResetCleanup removes reusable metadata before a forced reset.
+	PreparationPhaseResetCleanup PreparationProgressPhase = "reset_cleanup"
+	// PreparationPhaseCandidateSelection applies a selected Blu-ray candidate.
+	PreparationPhaseCandidateSelection PreparationProgressPhase = "candidate_selection"
+)
+
+// PreparationProgressStatus describes the latest advisory state of one stage.
+type PreparationProgressStatus string
+
+const (
+	// PreparationProgressRunning marks a stage that has started but is not terminal.
+	PreparationProgressRunning PreparationProgressStatus = "running"
+	// PreparationProgressCompleted marks a successfully completed stage.
+	PreparationProgressCompleted PreparationProgressStatus = "completed"
+	// PreparationProgressSkipped marks an intentional cache or policy bypass.
+	PreparationProgressSkipped PreparationProgressStatus = "skipped"
+	// PreparationProgressFailed marks a stage whose owning operation failed.
+	PreparationProgressFailed PreparationProgressStatus = "failed"
+)
+
+// PreparationProgressUpdate is one frontend-safe advisory preparation event.
+// CorrelationID and Timestamp are injected by the WebUI transport boundary.
+type PreparationProgressUpdate struct {
+	// CorrelationID binds the update to one frontend preparation command.
+	CorrelationID string `json:"correlationID"`
+	// Phase identifies the stable preparation stage.
+	Phase PreparationProgressPhase `json:"phase"`
+	// Order is the canonical presentation order, not a completion percentage.
+	Order int `json:"order"`
+	// Label is the user-facing stage name.
+	Label string `json:"label"`
+	// Message describes the current stage transition.
+	Message string `json:"message"`
+	// Status is the latest advisory state for Phase.
+	Status PreparationProgressStatus `json:"status"`
+	// Timestamp is an RFC3339 timestamp injected by the WebUI boundary.
+	Timestamp string `json:"timestamp"`
+}
+
+// PreparationProgressReporter receives advisory preparation progress.
+type PreparationProgressReporter func(update PreparationProgressUpdate)
+
+// preparationProgressReporterKey prevents collisions with caller context values.
+type preparationProgressReporterKey struct{}
+
+// WithPreparationProgressReporter attaches an optional reporter to ctx.
+func WithPreparationProgressReporter(ctx context.Context, reporter PreparationProgressReporter) context.Context {
+	if ctx == nil || reporter == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, preparationProgressReporterKey{}, reporter)
+}
+
+// EmitPreparationProgress reports one update when a reporter is installed.
+func EmitPreparationProgress(ctx context.Context, update PreparationProgressUpdate) {
+	if ctx == nil {
+		return
+	}
+	reporter, _ := ctx.Value(preparationProgressReporterKey{}).(PreparationProgressReporter)
+	if reporter != nil {
+		reporter(update)
+	}
+}
+
+// NewPreparationProgressUpdate supplies the canonical order and label for a
+// phase. Unknown phases remain renderable with a normalized fallback label.
+func NewPreparationProgressUpdate(
+	phase PreparationProgressPhase,
+	status PreparationProgressStatus,
+	message string,
+) PreparationProgressUpdate {
+	order, label := preparationProgressPresentation(phase)
+	return PreparationProgressUpdate{
+		Phase:   phase,
+		Order:   order,
+		Label:   label,
+		Message: strings.TrimSpace(message),
+		Status:  status,
+	}
+}
+
+// BeginPreparationProgress emits a running event and returns a completion
+// callback. The callback never replaces or modifies the operation error.
+func BeginPreparationProgress(
+	ctx context.Context,
+	phase PreparationProgressPhase,
+	message string,
+) func(error) {
+	EmitPreparationProgress(ctx, NewPreparationProgressUpdate(phase, PreparationProgressRunning, message))
+	return func(err error) {
+		if err != nil {
+			EmitPreparationProgress(ctx, NewPreparationProgressUpdate(phase, PreparationProgressFailed, "Stage failed."))
+			return
+		}
+		EmitPreparationProgress(ctx, NewPreparationProgressUpdate(phase, PreparationProgressCompleted, "Stage complete."))
+	}
+}
+
+// SkipPreparationProgress records an intentional cache or policy bypass.
+func SkipPreparationProgress(ctx context.Context, phase PreparationProgressPhase, message string) {
+	EmitPreparationProgress(ctx, NewPreparationProgressUpdate(phase, PreparationProgressSkipped, message))
+}
+
+// preparationProgressPresentation returns stable sorting and display metadata
+// while keeping unknown phases visible after mixed-version deployments.
+func preparationProgressPresentation(phase PreparationProgressPhase) (int, string) {
+	switch phase {
+	case PreparationPhaseSourceInspection:
+		return 100, "Inspect source"
+	case PreparationPhasePreparedCache:
+		return 200, "Check prepared cache"
+	case PreparationPhaseResetCleanup:
+		return 250, "Reset previous metadata"
+	case PreparationPhaseCandidateSelection:
+		return 275, "Select Blu-ray candidate"
+	case PreparationPhaseSourceEvidence:
+		return 300, "Collect source evidence"
+	case PreparationPhaseBDInfo:
+		return 350, "Analyze Blu-ray playlists"
+	case PreparationPhaseClientDiscovery:
+		return 400, "Search torrent clients"
+	case PreparationPhaseTrackerEvidence:
+		return 500, "Collect tracker evidence"
+	case PreparationPhaseMediaInfoIdentity:
+		return 600, "Read MediaInfo identity"
+	case PreparationPhaseArrIdentity:
+		return 700, "Query Sonarr and Radarr"
+	case PreparationPhaseExternalIdentity:
+		return 800, "Resolve external identity"
+	case PreparationPhaseMediaFacts:
+		return 900, "Derive media facts"
+	case PreparationPhaseCanonicalIdentity:
+		return 1000, "Resolve canonical identity"
+	case PreparationPhaseGenerationCommit:
+		return 1100, "Commit prepared generation"
+	case PreparationPhasePreviewProjection:
+		return 1200, "Build metadata preview"
+	}
+	label := strings.TrimSpace(strings.ReplaceAll(string(phase), "_", " "))
+	if label == "" {
+		label = "Preparation"
+	}
+	return 10000, label
+}
diff --git a/pkg/api/preparation_progress_test.go b/pkg/api/preparation_progress_test.go
new file mode 100644
index 00000000..38df7f41
--- /dev/null
+++ b/pkg/api/preparation_progress_test.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+)
+
+func TestPreparationProgressUpdateJSONContract(t *testing.T) {
+	update := NewPreparationProgressUpdate(PreparationPhaseBDInfo, PreparationProgressRunning, "Scanning playlist.")
+	update.CorrelationID = "attempt-1"
+	update.Timestamp = "2026-07-16T00:00:00Z"
+	payload, err := json.Marshal(update)
+	if err != nil {
+		t.Fatalf("marshal preparation progress: %v", err)
+	}
+	var decoded map[string]any
+	if err := json.Unmarshal(payload, &decoded); err != nil {
+		t.Fatalf("decode preparation progress: %v", err)
+	}
+	if decoded["correlationID"] != "attempt-1" || decoded["phase"] != "bdinfo" || decoded["status"] != "running" {
+		t.Fatal("preparation progress transport fields changed")
+	}
+	if decoded["order"] != float64(350) || decoded["label"] != "Analyze Blu-ray playlists" {
+		t.Fatal("preparation progress presentation metadata changed")
+	}
+}
+
+func TestPreparationProgressReporterAndUnknownPhase(t *testing.T) {
+	var updates []PreparationProgressUpdate
+	ctx := WithPreparationProgressReporter(context.Background(), func(update PreparationProgressUpdate) {
+		updates = append(updates, update)
+	})
+	finish := BeginPreparationProgress(ctx, PreparationProgressPhase("future_phase"), "Starting.")
+	finish(nil)
+	if len(updates) != 2 {
+		t.Fatalf("updates=%d, want 2", len(updates))
+	}
+	if updates[0].Order != 10000 || updates[0].Label != "future phase" {
+		t.Fatalf("unknown phase presentation=%+v", updates[0])
+	}
+	if updates[1].Status != PreparationProgressCompleted {
+		t.Fatalf("terminal status=%q", updates[1].Status)
+	}
+}
diff --git a/pkg/api/prepare.go b/pkg/api/prepare.go
new file mode 100644
index 00000000..22db0bf4
--- /dev/null
+++ b/pkg/api/prepare.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+// PreparationIntent describes why preparation was requested. It may influence
+// reuse/progress decisions but never the canonical fact set.
+type PreparationIntent string
+
+const (
+	// PreparationIntentPreview prepares a release for metadata preview.
+	PreparationIntentPreview PreparationIntent = "preview"
+	// PreparationIntentDuplicateCheck prepares a release for duplicate checking.
+	PreparationIntentDuplicateCheck PreparationIntent = "duplicate_check"
+	// PreparationIntentMedia prepares a release for media work.
+	PreparationIntentMedia PreparationIntent = "media"
+	// PreparationIntentDescription prepares a release for description work.
+	PreparationIntentDescription PreparationIntent = "description"
+	// PreparationIntentDryRun prepares a release for tracker dry run.
+	PreparationIntentDryRun PreparationIntent = "dry_run"
+	// PreparationIntentUpload prepares a release for upload review or execution.
+	PreparationIntentUpload PreparationIntent = "upload"
+)
+
+// PrepareInput requests one canonical prepared-release generation.
+type PrepareInput struct {
+	SourcePath   string
+	Intent       PreparationIntent
+	Instructions ReleaseFactInstructions
+	Policy       PreparationPolicy
+	// Search contains fact-producing client search choices included in compatibility.
+	Search ClientSearchPolicy
+	// Controls contains one-shot permissions excluded from compatibility.
+	Controls PreparationControls
+	Force    bool
+}
+
+// ReleaseFactInstructions contains caller intent that can change finalized
+// reusable release facts.
+type ReleaseFactInstructions struct {
+	Identity        ExternalIDOverrides
+	Category        *CanonicalCategory
+	ReleaseName     ReleaseNameOverrides
+	Metadata        MetadataOverrides
+	SourceLookup    string
+	BlurayReleaseID string
+	Playlist        PlaylistInstruction
+	// TrackerIDs maps normalized tracker names to caller-supplied source IDs.
+	TrackerIDs map[string]string
+}
+
+// PlaylistInstruction preserves tri-state playlist selection: Set=false means
+// no instruction, while Set=true with an empty selection is an explicit clear.
+type PlaylistInstruction struct {
+	Set      bool
+	Selected []string
+	UseAll   bool
+}
+
+// PreparationPolicy contains non-secret preparation behavior that can affect
+// canonical fact derivation and therefore participates in compatibility.
+type PreparationPolicy struct {
+	KeepFolder bool
+	// KeepImages preserves tracker-sourced images while collecting metadata evidence.
+	KeepImages bool
+	OnlyID     bool
+}
+
+// ClientSearchPolicy contains fact-producing torrent-client search choices.
+// These values participate in preparation compatibility.
+type ClientSearchPolicy struct {
+	// Skip disables torrent-client discovery for this preparation.
+	Skip bool
+	// Client optionally selects one configured client; nil uses normal client selection.
+	Client *string
+}
+
+// PreparationControls contains one-shot permissions and presentation choices.
+// These values never participate in preparation compatibility.
+type PreparationControls struct {
+	// Interaction determines whether preparation may request manual input.
+	Interaction InteractionMode
+	// ConfirmBDMVRescan permits replacing a partial cached Blu-ray analysis.
+	ConfirmBDMVRescan bool
+	// ForceRecheck forwards an explicit torrent-client hash recheck choice.
+	ForceRecheck *bool
+}
diff --git a/pkg/api/prepared_release.go b/pkg/api/prepared_release.go
new file mode 100644
index 00000000..40a370b2
--- /dev/null
+++ b/pkg/api/prepared_release.go
@@ -0,0 +1,550 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// PreparedGeneration identifies one immutable prepared-release generation for
+// a normalized source path.
+type PreparedGeneration uint64
+
+// PreparationCompatibility records the four exact keys that permit reuse of a
+// prepared-release generation.
+type PreparationCompatibility struct {
+	SourceFingerprint          string
+	FactInstructionFingerprint string
+	PolicyFingerprint          string
+	ContractVersion            string
+}
+
+// PreparedRelease is the immutable, source-scoped read model of finalized
+// release facts. Workflow choices, diagnostics, resources, and outcomes are
+// intentionally excluded.
+type PreparedRelease struct {
+	Generation       PreparedGeneration
+	Compatibility    PreparationCompatibility
+	Source           SourceManifest
+	Naming           NamingFacts
+	Episode          EpisodeFacts
+	Media            MediaFacts
+	Disc             DiscFacts
+	Identity         ExternalIdentity
+	ProviderMetadata SourceScopedMetadata
+	Assessments      ReleaseAssessments
+	PreparedAt       time.Time `ts_type:"string"`
+}
+
+// PrepareResult returns one immutable release projection plus non-canonical
+// preparation diagnostics.
+type PrepareResult struct {
+	Release     PreparedRelease
+	Diagnostics []PreparationDiagnostic
+}
+
+// ReleaseRef identifies one exact prepared generation without exposing its
+// facts or private preparation resources.
+type ReleaseRef struct {
+	SourcePath string
+	Generation PreparedGeneration
+}
+
+// SourceEntryType classifies one normalized source-manifest entry.
+type SourceEntryType string
+
+const (
+	// SourceEntryTypeUnknown marks an entry whose type could not be classified.
+	SourceEntryTypeUnknown SourceEntryType = "unknown"
+	// SourceEntryTypeFile marks a regular file.
+	SourceEntryTypeFile SourceEntryType = "file"
+	// SourceEntryTypeDirectory marks a directory.
+	SourceEntryTypeDirectory SourceEntryType = "directory"
+	// SourceEntryTypePlaylist marks a resolved disc playlist.
+	SourceEntryTypePlaylist SourceEntryType = "playlist"
+)
+
+// SourceManifest is the finalized source inventory and measurement set for one
+// prepared release.
+type SourceManifest struct {
+	SourcePath        string
+	Size              int64
+	Entries           []SourceManifestEntry
+	SelectedPlaylists []PlaylistInfo
+	Classification    SourceClassification
+}
+
+// SourceManifestEntry is one stable inventory item used by preparation and
+// source fingerprinting.
+type SourceManifestEntry struct {
+	Path       string
+	Type       SourceEntryType
+	Size       int64
+	ModifiedAt time.Time `ts_type:"string"`
+	Disc       string
+	Playlist   string
+}
+
+// SourceClassification records finalized source structure without exposing
+// preparation-resource paths.
+type SourceClassification struct {
+	DiscType  string
+	Container string
+	MediaType string
+}
+
+// NamingFacts contains finalized reusable naming facts rather than raw parser
+// output or workflow-specific name overrides.
+type NamingFacts struct {
+	Filename       string
+	ReleaseName    string
+	NameWithoutTag string
+	CleanName      string
+	Tag            string
+	Type           string
+	Artist         string
+	Title          string
+	Subtitle       string
+	AlternateTitle string
+	Year           int
+	Month          int
+	Day            int
+	Source         string
+	Resolution     string
+	Codecs         []string
+	Audio          []string
+	HDR            []string
+	Extension      string
+	Languages      []string
+	Site           string
+	Genre          string
+	Channels       string
+	Collection     string
+	Region         string
+	Size           string
+	Group          string
+	Disc           string
+	Editions       []string
+	Other          []string
+	Scene          bool
+	SceneName      string
+	Personal       bool
+}
+
+// EpisodeFacts contains canonical reusable episodic identity and schedule
+// facts, independent of tracker policy.
+type EpisodeFacts struct {
+	Season            int
+	Episode           int
+	SeasonLabel       string
+	EpisodeLabel      string
+	DailyDate         string
+	Pack              bool
+	Title             string
+	Overview          string
+	Year              int
+	AiredDate         string
+	AirDays           []string
+	AirTime           string
+	AirTimezone       string
+	AirTimezoneSource string
+	DateMatched       bool
+}
+
+// MediaFacts contains finalized reusable media characteristics.
+type MediaFacts struct {
+	AudioLanguages    []string
+	SubtitleLanguages []string
+	Container         string
+	Audio             string
+	Channels          string
+	Commentary        bool
+	ThreeD            string
+	Source            string
+	Type              string
+	UHD               string
+	HDR               string
+	Distributor       string
+	Region            string
+	VideoCodec        string
+	VideoEncode       string
+	HasEncodeSettings bool
+	BitDepth          string
+	Edition           string
+	Repack            string
+	WebDV             bool
+	StreamOptimized   int
+	Service           string
+	ServiceLongName   string
+	MediaInfoUniqueID string
+	Anime             bool
+}
+
+// DiscFacts contains typed disc measurements that are safe to publish as
+// reusable facts. Local report and media paths remain preparation resources.
+type DiscFacts struct {
+	Type            string
+	Summary         string
+	DurationSeconds float64
+	PlaylistCount   int
+	DVDVOBSet       string
+}
+
+// UniqueIDStatus records the concrete MediaInfo unique-ID assessment.
+type UniqueIDStatus string
+
+const (
+	// UniqueIDStatusUnknown means preparation has not established the fact.
+	UniqueIDStatusUnknown UniqueIDStatus = "unknown"
+	// UniqueIDStatusNotApplicable means the source does not require this evidence.
+	UniqueIDStatusNotApplicable UniqueIDStatus = "not_applicable"
+	// UniqueIDStatusPresent means required unique-ID evidence is present.
+	UniqueIDStatusPresent UniqueIDStatus = "present"
+	// UniqueIDStatusMissing means required unique-ID evidence is absent.
+	UniqueIDStatusMissing UniqueIDStatus = "missing"
+)
+
+// EncodeSettingsStatus records the concrete MediaInfo encode-settings
+// assessment.
+type EncodeSettingsStatus string
+
+const (
+	// EncodeSettingsStatusUnknown means preparation has not established the fact.
+	EncodeSettingsStatusUnknown EncodeSettingsStatus = "unknown"
+	// EncodeSettingsStatusNotApplicable means the source does not require encode settings.
+	EncodeSettingsStatusNotApplicable EncodeSettingsStatus = "not_applicable"
+	// EncodeSettingsStatusPresent means required encode settings are present.
+	EncodeSettingsStatusPresent EncodeSettingsStatus = "present"
+	// EncodeSettingsStatusMissing means required encode settings are absent.
+	EncodeSettingsStatusMissing EncodeSettingsStatus = "missing"
+)
+
+// NamingStatus records whether finalized naming facts are complete.
+type NamingStatus string
+
+const (
+	// NamingStatusUnknown means preparation has not assessed naming completeness.
+	NamingStatusUnknown NamingStatus = "unknown"
+	// NamingStatusComplete means all required naming facts are present.
+	NamingStatusComplete NamingStatus = "complete"
+	// NamingStatusIncomplete means one or more required naming facts are missing.
+	NamingStatusIncomplete NamingStatus = "incomplete"
+)
+
+// NamingAssessment records concrete naming completeness and typed missing fact
+// labels without turning tracker policy into prepared truth.
+type NamingAssessment struct {
+	Status  NamingStatus
+	Missing []NamingRequirement
+}
+
+// NamingRequirement identifies one missing finalized naming fact.
+type NamingRequirement string
+
+// ReleaseAssessments contains concrete source-derived assessments. Operations
+// decide whether these facts block work.
+type ReleaseAssessments struct {
+	MediaInfoUniqueID       UniqueIDStatus
+	MediaInfoEncodeSettings EncodeSettingsStatus
+	Naming                  NamingAssessment
+}
+
+// UniqueIDRequirementSatisfied reports whether the concrete assessment permits
+// work that requires a MediaInfo unique ID.
+func (a ReleaseAssessments) UniqueIDRequirementSatisfied() bool {
+	return a.MediaInfoUniqueID == UniqueIDStatusPresent || a.MediaInfoUniqueID == UniqueIDStatusNotApplicable
+}
+
+// EncodeSettingsRequirementSatisfied reports whether the concrete assessment
+// permits work that requires MediaInfo encode settings.
+func (a ReleaseAssessments) EncodeSettingsRequirementSatisfied() bool {
+	return a.MediaInfoEncodeSettings == EncodeSettingsStatusPresent ||
+		a.MediaInfoEncodeSettings == EncodeSettingsStatusNotApplicable
+}
+
+// CanonicalCategory is the finalized top-level movie-or-TV classification.
+type CanonicalCategory string
+
+const (
+	// CanonicalCategoryUnknown represents an intentionally or currently unknown category.
+	CanonicalCategoryUnknown CanonicalCategory = "unknown"
+	// CanonicalCategoryMovie identifies movie releases.
+	CanonicalCategoryMovie CanonicalCategory = "movie"
+	// CanonicalCategoryTV identifies television releases.
+	CanonicalCategoryTV CanonicalCategory = "tv"
+)
+
+// IdentityProvider identifies one explicit external-ID provider.
+type IdentityProvider string
+
+const (
+	// IdentityProviderTMDB identifies The Movie Database.
+	IdentityProviderTMDB IdentityProvider = "tmdb"
+	// IdentityProviderIMDB identifies IMDb.
+	IdentityProviderIMDB IdentityProvider = "imdb"
+	// IdentityProviderTVDB identifies TheTVDB.
+	IdentityProviderTVDB IdentityProvider = "tvdb"
+	// IdentityProviderTVmaze identifies TVmaze.
+	IdentityProviderTVmaze IdentityProvider = "tvmaze"
+	// IdentityProviderMAL identifies MyAnimeList/AniList-compatible identity.
+	IdentityProviderMAL IdentityProvider = "mal"
+)
+
+// IdentityProvenance identifies the origin of one canonical identity fact.
+type IdentityProvenance string
+
+const (
+	// IdentityProvenanceUnknown means no canonical fact has been resolved.
+	IdentityProvenanceUnknown IdentityProvenance = "unknown"
+	// IdentityProvenanceExplicit identifies a caller-locked fact.
+	IdentityProvenanceExplicit IdentityProvenance = "explicit"
+	// IdentityProvenancePersisted identifies reusable source-scoped state.
+	IdentityProvenancePersisted IdentityProvenance = "persisted"
+	// IdentityProvenanceMediaInfo identifies embedded MediaInfo evidence.
+	IdentityProvenanceMediaInfo IdentityProvenance = "mediainfo"
+	// IdentityProvenanceScene identifies scene/NFO evidence.
+	IdentityProvenanceScene IdentityProvenance = "scene"
+	// IdentityProvenanceArr identifies Sonarr or Radarr evidence.
+	IdentityProvenanceArr IdentityProvenance = "arr"
+	// IdentityProvenanceTracker identifies tracker evidence.
+	IdentityProvenanceTracker IdentityProvenance = "tracker"
+	// IdentityProvenanceProvider identifies provider-derived evidence.
+	IdentityProvenanceProvider IdentityProvenance = "provider"
+	// IdentityProvenanceLegacy identifies migrated pre-contract evidence.
+	IdentityProvenanceLegacy IdentityProvenance = "legacy"
+)
+
+// IdentityProvenanceSet records provenance for every canonical provider and
+// category fact.
+type IdentityProvenanceSet struct {
+	TMDB     IdentityProvenance
+	IMDB     IdentityProvenance
+	TVDB     IdentityProvenance
+	TVmaze   IdentityProvenance
+	MAL      IdentityProvenance
+	Category IdentityProvenance
+}
+
+// OverrideState records tri-state caller intent.
+type OverrideState string
+
+const (
+	// OverrideStateUnset means automatic resolution may supply a fact.
+	OverrideStateUnset OverrideState = "unset"
+	// OverrideStateValue means a caller locked an explicit non-empty value.
+	OverrideStateValue OverrideState = "value"
+	// OverrideStateClear means a caller locked the fact as unknown.
+	OverrideStateClear OverrideState = "clear"
+)
+
+// IdentityOverrideState records tri-state override intent for every canonical
+// provider and the category.
+type IdentityOverrideState struct {
+	TMDB     OverrideState
+	IMDB     OverrideState
+	TVDB     OverrideState
+	TVmaze   OverrideState
+	MAL      OverrideState
+	Category OverrideState
+}
+
+// IdentityConflictStatus records whether accepted evidence contains an
+// unverified inconsistency. Proven locked conflicts are fatal and unpublished.
+type IdentityConflictStatus string
+
+const (
+	// IdentityConflictNone means no inconsistency was found.
+	IdentityConflictNone IdentityConflictStatus = "none"
+	// IdentityConflictUnverified means evidence may conflict but cannot be proven inconsistent.
+	IdentityConflictUnverified IdentityConflictStatus = "unverified"
+)
+
+// IdentityResolutionKey records non-secret fingerprints controlling canonical
+// identity reuse.
+type IdentityResolutionKey struct {
+	SourceFingerprint string
+	IntentFingerprint string
+	ContractVersion   string
+}
+
+// ExternalIdentity is the only prepared-release source for provider IDs and
+// top-level movie-or-TV classification.
+type ExternalIdentity struct {
+	SourcePath string
+	Generation PreparedGeneration
+	TMDBID     int
+	IMDBID     int
+	TVDBID     int
+	TVmazeID   int
+	MALID      int
+	Category   CanonicalCategory
+	Provenance IdentityProvenanceSet
+	Overrides  IdentityOverrideState
+	Conflict   IdentityConflictStatus
+	Resolution IdentityResolutionKey
+	ResolvedAt time.Time `ts_type:"string"`
+}
+
+// ProviderID returns the canonical ID for provider without applying fallbacks.
+func (i ExternalIdentity) ProviderID(provider IdentityProvider) (int, bool) {
+	var id int
+	switch provider {
+	case IdentityProviderTMDB:
+		id = i.TMDBID
+	case IdentityProviderIMDB:
+		id = i.IMDBID
+	case IdentityProviderTVDB:
+		id = i.TVDBID
+	case IdentityProviderTVmaze:
+		id = i.TVmazeID
+	case IdentityProviderMAL:
+		id = i.MALID
+	default:
+		return 0, false
+	}
+	return id, id > 0
+}
+
+// RequirementKind identifies a canonical prerequisite required by an operation.
+type RequirementKind string
+
+const (
+	// RequirementKindProviderID identifies a missing provider ID.
+	RequirementKindProviderID RequirementKind = "provider_id"
+	// RequirementKindCategory identifies a missing canonical category.
+	RequirementKindCategory RequirementKind = "category"
+)
+
+// MissingRequirementError reports one absent canonical prerequisite.
+type MissingRequirementError struct {
+	Requirement RequirementKind
+	Provider    IdentityProvider
+}
+
+func (e *MissingRequirementError) Error() string {
+	if e == nil {
+		return "missing canonical requirement"
+	}
+	if e.Requirement == RequirementKindProviderID {
+		return fmt.Sprintf("missing canonical %s provider ID", e.Provider)
+	}
+	return "missing canonical category"
+}
+
+// RequireProviderID returns one canonical provider ID or a typed missing
+// requirement error.
+func (i ExternalIdentity) RequireProviderID(provider IdentityProvider) (int, error) {
+	id, ok := i.ProviderID(provider)
+	if !ok {
+		return 0, &MissingRequirementError{Requirement: RequirementKindProviderID, Provider: provider}
+	}
+	return id, nil
+}
+
+// RequireCategory returns the canonical category or a typed missing
+// requirement error.
+func (i ExternalIdentity) RequireCategory() (CanonicalCategory, error) {
+	category, err := NormalizeCanonicalCategory(string(i.Category))
+	if err != nil {
+		return CanonicalCategoryUnknown, &MissingRequirementError{Requirement: RequirementKindCategory}
+	}
+	switch category {
+	case CanonicalCategoryMovie, CanonicalCategoryTV:
+		return category, nil
+	case CanonicalCategoryUnknown:
+		return CanonicalCategoryUnknown, &MissingRequirementError{Requirement: RequirementKindCategory}
+	}
+	return CanonicalCategoryUnknown, &MissingRequirementError{Requirement: RequirementKindCategory}
+}
+
+// SourceScopedMetadata stores optional provider enrichment for one source and
+// prepared generation.
+type SourceScopedMetadata struct {
+	SourcePath string
+	Generation PreparedGeneration
+	TMDB       *TMDBMetadata
+	IMDB       *IMDBMetadata
+	TVDB       *TVDBMetadata
+	TVmaze     *TVmazeMetadata
+	AniList    *AniListMetadata
+	Bluray     *BlurayMetadata
+	UpdatedAt  time.Time `ts_type:"string"`
+}
+
+// DiagnosticSeverity classifies preparation diagnostics without turning them
+// into workflow outcomes.
+type DiagnosticSeverity string
+
+const (
+	// DiagnosticSeverityInfo records explanatory evidence.
+	DiagnosticSeverityInfo DiagnosticSeverity = "info"
+	// DiagnosticSeverityWarning records a non-fatal preparation concern.
+	DiagnosticSeverityWarning DiagnosticSeverity = "warning"
+)
+
+// PreparationDiagnostic is non-canonical evidence or warning returned beside
+// a prepared release.
+type PreparationDiagnostic struct {
+	Code       string
+	Severity   DiagnosticSeverity
+	Message    string
+	Candidates []ExternalIdentityCandidate
+}
+
+// ExternalIdentityCandidate is possible provider evidence exposed for review,
+// never a canonical external-identity fact.
+type ExternalIdentityCandidate struct {
+	Provider      IdentityProvider
+	ID            int
+	Title         string
+	OriginalTitle string
+	Year          int
+	Category      CanonicalCategory
+	MediaType     string
+	Overview      string
+	PosterURL     string
+	Similarity    float64
+}
+
+// Clone returns a detached prepared-release projection.
+func (r PreparedRelease) Clone() (PreparedRelease, error) {
+	return clonePreparedValue(r)
+}
+
+// Clone returns a detached result whose release and diagnostics can be mutated
+// by the caller without affecting module-owned state.
+func (r PrepareResult) Clone() (PrepareResult, error) {
+	return clonePreparedValue(r)
+}
+
+func clonePreparedValue[T any](value T) (T, error) {
+	var cloned T
+	payload, err := json.Marshal(value)
+	if err != nil {
+		return cloned, fmt.Errorf("clone prepared value: marshal: %w", err)
+	}
+	if err := json.Unmarshal(payload, &cloned); err != nil {
+		return cloned, fmt.Errorf("clone prepared value: unmarshal: %w", err)
+	}
+	return cloned, nil
+}
+
+// NormalizeCanonicalCategory maps supported legacy/user labels to a canonical
+// movie, TV, or explicit unknown value.
+func NormalizeCanonicalCategory(value string) (CanonicalCategory, error) {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "", "unknown":
+		return CanonicalCategoryUnknown, nil
+	case "movie", "film":
+		return CanonicalCategoryMovie, nil
+	case "tv", "television", "series", "episode":
+		return CanonicalCategoryTV, nil
+	default:
+		return CanonicalCategoryUnknown, errors.New("unsupported canonical category")
+	}
+}
diff --git a/pkg/api/prepared_release_test.go b/pkg/api/prepared_release_test.go
new file mode 100644
index 00000000..9de7e3eb
--- /dev/null
+++ b/pkg/api/prepared_release_test.go
@@ -0,0 +1,107 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestPreparedReleaseCloneDetachesCollections(t *testing.T) {
+	source := PreparedRelease{
+		Source: SourceManifest{
+			SourcePath: "Example.Release.2026.1080p-GRP.mkv",
+			Entries: []SourceManifestEntry{
+				{
+Path: "Example.Release.2026.1080p-GRP.mkv",
+ Type: SourceEntryTypeFile,
+ Size: 42,
+},
+			},
+		},
+		Naming: NamingFacts{Codecs: []string{"H.264"}},
+		ProviderMetadata: SourceScopedMetadata{
+			TMDB: &TMDBMetadata{LocalizedTitles: map[string]string{"en": "Example Release 2026"}},
+		},
+		Assessments: ReleaseAssessments{
+			Naming: NamingAssessment{Status: NamingStatusIncomplete, Missing: []NamingRequirement{"year"}},
+		},
+	}
+
+	cloned, err := source.Clone()
+	if err != nil {
+		t.Fatalf("clone: %v", err)
+	}
+	cloned.Source.Entries[0].Path = "changed.mkv"
+	cloned.Naming.Codecs[0] = "changed"
+	cloned.ProviderMetadata.TMDB.LocalizedTitles["en"] = "changed"
+	cloned.Assessments.Naming.Missing[0] = "changed"
+
+	if source.Source.Entries[0].Path == cloned.Source.Entries[0].Path {
+		t.Fatal("source entries share storage")
+	}
+	if source.Naming.Codecs[0] == cloned.Naming.Codecs[0] {
+		t.Fatal("naming codecs share storage")
+	}
+	if source.ProviderMetadata.TMDB.LocalizedTitles["en"] == cloned.ProviderMetadata.TMDB.LocalizedTitles["en"] {
+		t.Fatal("provider metadata shares storage")
+	}
+	if source.Assessments.Naming.Missing[0] == cloned.Assessments.Naming.Missing[0] {
+		t.Fatal("naming assessment shares storage")
+	}
+}
+
+func TestExternalIdentityRequirementsUseCanonicalFieldsOnly(t *testing.T) {
+	identity := ExternalIdentity{
+		TMDBID:   123456,
+		Category: CanonicalCategoryMovie,
+	}
+
+	id, err := identity.RequireProviderID(IdentityProviderTMDB)
+	if err != nil || id != 123456 {
+		t.Fatalf("TMDB requirement = (%d, %v)", id, err)
+	}
+	category, err := identity.RequireCategory()
+	if err != nil || category != CanonicalCategoryMovie {
+		t.Fatalf("category requirement = (%q, %v)", category, err)
+	}
+
+	_, err = identity.RequireProviderID(IdentityProviderIMDB)
+	assertMissingRequirement(t, err, RequirementKindProviderID, IdentityProviderIMDB)
+	_, err = (ExternalIdentity{Category: CanonicalCategoryUnknown}).RequireCategory()
+	assertMissingRequirement(t, err, RequirementKindCategory, "")
+	_, err = (ExternalIdentity{Category: "documentary"}).RequireCategory()
+	assertMissingRequirement(t, err, RequirementKindCategory, "")
+}
+
+func TestNormalizeCanonicalCategory(t *testing.T) {
+	tests := map[string]CanonicalCategory{
+		"":        CanonicalCategoryUnknown,
+		"unknown": CanonicalCategoryUnknown,
+		"MOVIE":   CanonicalCategoryMovie,
+		"film":    CanonicalCategoryMovie,
+		"TV":      CanonicalCategoryTV,
+		"episode": CanonicalCategoryTV,
+	}
+	for input, want := range tests {
+		got, err := NormalizeCanonicalCategory(input)
+		if err != nil || got != want {
+			t.Fatalf("NormalizeCanonicalCategory(%q) = (%q, %v), want %q", input, got, err, want)
+		}
+	}
+	if _, err := NormalizeCanonicalCategory("unsupported"); err == nil {
+		t.Fatal("unsupported category succeeded")
+	}
+}
+
+func assertMissingRequirement(t *testing.T, err error, requirement RequirementKind, provider IdentityProvider) {
+	t.Helper()
+	var missing *MissingRequirementError
+	if !errors.As(err, &missing) {
+		t.Fatalf("error = %v, want MissingRequirementError", err)
+	}
+	if missing.Requirement != requirement || missing.Provider != provider {
+		t.Fatalf("missing requirement = %#v", missing)
+	}
+}
diff --git a/pkg/api/preview.go b/pkg/api/preview.go
index 2c69e6eb..d0c20082 100644
--- a/pkg/api/preview.go
+++ b/pkg/api/preview.go
@@ -15,24 +15,22 @@ type MetadataPreview struct {
 	SourcePath           string
 	TrackerName          string
 	ReleaseName          string
-	Warnings             []string
 	ReleaseNameOverrides ReleaseNameOverrides
-	ExternalIDs          ExternalIDs
-	ExternalIDCandidates ExternalIDCandidates
-	// ExternalIDInfo includes resolved IDs even when no metadata was fetched from that provider.
-	ExternalIDInfo []ExternalIDInfo
-	// ExternalPreview includes only providers whose metadata payload was fetched and populated.
-	ExternalPreview []ExternalPreview
-	Bluray          *BlurayMetadata
-	TrackerData     []TrackerPreview
+	Release              ReleaseRef
+	Identity             ExternalIdentity
+	Display              PreparedReleaseDisplay
+	Bluray               *BlurayMetadata
+	Diagnostics          []PreparationDiagnostic
+	TrackerData          []TrackerPreview
 	// TrackerRuleFailures is keyed by normalized tracker code and contains
 	// upload rule failures known at preview time.
 	TrackerRuleFailures map[string][]RuleFailure
 }
 
 type DescriptionBuilderPreview struct {
-	SourcePath string
-	Groups     []DescriptionBuilderGroup
+	SourcePath      string
+	Groups          []DescriptionBuilderGroup
+	ContentFailures []TrackerContentFailure
 }
 
 type DescriptionBuilderGroup struct {
@@ -47,8 +45,9 @@ type DescriptionBuilderGroup struct {
 }
 
 type PreparationPreview struct {
-	SourcePath   string
-	Descriptions []PreparationDescription
+	SourcePath      string
+	Descriptions    []PreparationDescription
+	ContentFailures []TrackerContentFailure
 }
 
 type TrackerDryRunPreview struct {
@@ -57,8 +56,9 @@ type TrackerDryRunPreview struct {
 }
 
 type UploadReview struct {
-	SourcePath string
-	Trackers   []TrackerReview
+	SourcePath  string
+	Trackers    []TrackerReview
+	Eligibility TrackerEligibility
 }
 
 type TrackerReview struct {
@@ -96,9 +96,19 @@ type TrackerDryRunEntry struct {
 	Files                   []TrackerDryRunFile
 	// DebugSections carries optional staged diagnostics for trackers whose dry-run
 	// preview needs to show more than one request or derived payload.
-	DebugSections []TrackerDryRunDebugSection
-	Questionnaire *TrackerQuestionnaire
-	ImageHost     ImageHostFeedback
+	DebugSections  []TrackerDryRunDebugSection
+	Questionnaire  *TrackerQuestionnaire
+	ImageHost      ImageHostFeedback
+	ContentFailure *TrackerContentFailure
+	Diagnostics    TrackerDryRunDiagnostics
+}
+
+// TrackerDryRunDiagnostics describes live-upload findings without changing
+// dry-run payload readiness.
+type TrackerDryRunDiagnostics struct {
+	RuleDecisions          []RuleDecision
+	Duplicate              DupeCheckResult
+	LiveEligibilityReasons []TrackerEligibilityReason
 }
 
 // TrackerDryRunDebugSection describes one named diagnostic payload inside a
@@ -172,41 +182,3 @@ type ExternalIDInfo struct {
 	ID       int
 	Source   string
 }
-
-// ExternalPreview contains fetched metadata for one resolved external provider ID.
-// A resolved ID without provider metadata appears in [MetadataPreview.ExternalIDInfo] only.
-type ExternalPreview struct {
-	Provider         string
-	ID               int
-	Source           string
-	Title            string
-	Year             int
-	Overview         string
-	PosterURL        string
-	BackdropURL      string
-	Category         string
-	OriginalTitle    string
-	ReleaseDate      string
-	FirstAirDate     string
-	LastAirDate      string
-	OriginalLanguage string
-	TMDBType         string
-	Runtime          int
-	Genres           string
-	Keywords         string
-	YouTube          string
-	IMDBType         string
-	Rating           float64
-	RatingCount      int
-	RuntimeMinutes   int
-	Country          string
-	Premiered        string
-	IMDBID           int
-	TVDBID           int
-	TMDB             *TMDBMetadata
-	IMDB             *IMDBMetadata
-	TVDB             *TVDBMetadata
-	TVmaze           *TVmazeMetadata
-	// AniList contains rich preview metadata when Provider is "mal".
-	AniList *AniListMetadata
-}
diff --git a/pkg/api/repository.go b/pkg/api/repository.go
index 394ca9d8..bd8fb0f0 100644
--- a/pkg/api/repository.go
+++ b/pkg/api/repository.go
@@ -8,6 +8,7 @@ import (
 	"database/sql/driver"
 	"errors"
 	"fmt"
+	"reflect"
 	"strings"
 	"time"
 )
@@ -143,10 +144,8 @@ type TrackerMetadata struct {
 	IMDBID     int
 	TVDBID     int
 	MALID      int
-	// Category is the site-reported movie/TV content category from the tracker
-	// API. Supported values take precedence over MediaInfoCategory and
-	// Release.Category when resolving ExternalIDs.Category for upload
-	// classification; unsupported categories are ignored.
+	// Category is site-reported movie/TV evidence consumed only by canonical
+	// external-identity resolution; unsupported values are ignored.
 	Category    Category
 	Description string
 	ImageURLs   []string
@@ -172,9 +171,11 @@ type TrackerRuleFailure struct {
 	Tracker    string
 	Rule       string
 	Reason     string
-	// Severity defaults to blocking for records created before severity was stored.
-	Severity  RuleFailureSeverity
-	CreatedAt time.Time `ts_type:"string"`
+	// Disposition is normalized from legacy severity values during migration/readback.
+	Disposition RuleDisposition
+	// Authorized records whether the exact waivable result was accepted for the stored operation.
+	Authorized bool
+	CreatedAt  time.Time `ts_type:"string"`
 }
 
 type DescriptionOverride struct {
@@ -254,36 +255,92 @@ type DVDMediaInfo struct {
 	UpdatedAt       time.Time `ts_type:"string"`
 }
 
-type MetadataRepository interface {
+// ReleaseStateRepository persists the state used to prepare one release.
+// Implementations preserve path validation, UTC timestamps, and ErrNotFound
+// identity for missing optional records.
+type ReleaseStateRepository interface {
 	GetByPath(ctx context.Context, path string) (FileMetadata, error)
 	Save(ctx context.Context, metadata FileMetadata) error
-	GetExternalIDs(ctx context.Context, path string) (ExternalIDs, error)
-	SaveExternalIDs(ctx context.Context, ids ExternalIDs) error
-	GetExternalMetadata(ctx context.Context, path string) (ExternalMetadata, error)
-	SaveExternalMetadata(ctx context.Context, metadata ExternalMetadata) error
-	GetDVDMediaInfo(ctx context.Context, path string) (DVDMediaInfo, error)
+	GetExternalIdentity(ctx context.Context, path string) (ExternalIdentity, error)
+	SaveExternalIdentity(ctx context.Context, ids ExternalIdentity) error
+	GetExternalMetadata(ctx context.Context, path string) (SourceScopedMetadata, error)
+	SaveExternalMetadata(ctx context.Context, metadata SourceScopedMetadata) error
 	SaveDVDMediaInfo(ctx context.Context, info DVDMediaInfo) error
 	GetReleaseNameOverrides(ctx context.Context, path string) (ReleaseNameOverrides, error)
 	SaveReleaseNameOverrides(ctx context.Context, path string, overrides ReleaseNameOverrides) error
-	DeleteReleaseNameOverrides(ctx context.Context, path string) error
+}
+
+// PreparedReleaseRepository owns whole-generation prepared facts. Commits and
+// purges include canonical identity and source-scoped provider metadata in one
+// transaction.
+type PreparedReleaseRepository interface {
+	LoadPreparedRelease(ctx context.Context, sourcePath string) (PreparedRelease, error)
+	CommitPreparedRelease(ctx context.Context, release PreparedRelease) error
+	PurgePreparedRelease(ctx context.Context, sourcePath string) error
+}
+
+// ReleaseSelectionRepository persists user-selected description and playlist
+// state. Explicit empty selections are distinct from missing records.
+type ReleaseSelectionRepository interface {
 	GetDescriptionOverride(ctx context.Context, path string, groupKey string) (DescriptionOverride, error)
 	ListDescriptionOverridesByPath(ctx context.Context, path string) ([]DescriptionOverride, error)
 	SaveDescriptionOverride(ctx context.Context, override DescriptionOverride) error
 	DeleteDescriptionOverride(ctx context.Context, path string, groupKey string) error
 	GetPlaylistSelection(ctx context.Context, sourcePath string) (PlaylistSelection, error)
 	SavePlaylistSelection(ctx context.Context, sourcePath string, playlists []string, useAll bool) error
-	DeletePlaylistSelection(ctx context.Context, sourcePath string) error
+}
+
+// HistoryCleanupSnapshot contains persisted local paths needed by Core's
+// filesystem cleanup policy. ArtifactPaths is an isolated caller-owned slice.
+type HistoryCleanupSnapshot struct {
+	Metadata      *FileMetadata
+	ArtifactPaths []string
+}
+
+// HistoryRepository owns persisted history projection, cleanup discovery, and
+// atomic release-state purge. Filesystem deletion remains outside this seam.
+type HistoryRepository interface {
 	ListHistoryEntries(ctx context.Context) ([]HistoryEntry, error)
+	LoadHistoryRecord(ctx context.Context, sourcePath string) (HistoryRecord, error)
+	LoadHistoryCleanupSnapshot(ctx context.Context, sourcePath string) (HistoryCleanupSnapshot, error)
+	ListStoredReleasePaths(ctx context.Context) ([]string, error)
+	PurgeContentData(ctx context.Context, path string) error
+}
+
+// UploadLedgerRepository owns upload-attempt creation, latest-record status
+// transitions, and canonical newest-first history queries.
+type UploadLedgerRepository interface {
 	ListUploadHistoryByPath(ctx context.Context, sourcePath string) ([]UploadRecord, error)
-	ListPendingUploads(ctx context.Context) ([]UploadRecord, error)
 	CreateUploadRecord(ctx context.Context, record UploadRecord) error
 	UpdateLatestUploadRecordStatus(ctx context.Context, sourcePath string, tracker string, status string) error
+}
+
+// TrackerStateRepository persists tracker-derived metadata, refresh times, and
+// atomic replacement of rule-failure sets.
+type TrackerStateRepository interface {
 	SaveTrackerRuleFailures(ctx context.Context, sourcePath string, tracker string, failures []TrackerRuleFailure) error
 	ListTrackerRuleFailuresByPath(ctx context.Context, path string) ([]TrackerRuleFailure, error)
 	GetTrackerTimestamp(ctx context.Context, tracker string) (time.Time, error)
 	SaveTrackerTimestamp(ctx context.Context, timestamp TrackerTimestamp) error
 	SaveTrackerMetadata(ctx context.Context, metadata TrackerMetadata) error
 	ListTrackerMetadataByPath(ctx context.Context, path string) ([]TrackerMetadata, error)
+}
+
+// MediaAssetSnapshot is a coherent caller-owned view of persisted media
+// records for one release. Returned slices and nested variant slices may be
+// mutated by callers without changing repository state.
+type MediaAssetSnapshot struct {
+	Screenshots     []Screenshot
+	FinalSelections []ScreenshotFinalSelection
+	ScreenshotSlots []ScreenshotSlot
+	UploadedImages  []UploadedImageLink
+}
+
+// MediaAssetRepository persists screenshot, selection, slot, variant, and
+// uploaded-image records. Screenshot lifecycle mutations are atomic.
+type MediaAssetRepository interface {
+	ScreenshotLifecycleRepository
+	LoadMediaAssetSnapshot(ctx context.Context, path string) (MediaAssetSnapshot, error)
 	SaveScreenshot(ctx context.Context, screenshot Screenshot) error
 	ListScreenshotsByPath(ctx context.Context, path string) ([]Screenshot, error)
 	DeleteScreenshot(ctx context.Context, imagePath string) error
@@ -296,6 +353,125 @@ type MetadataRepository interface {
 	SaveUploadedImages(ctx context.Context, path string, host string, images []UploadedImageLink) error
 	ListUploadedImagesByPath(ctx context.Context, path string) ([]UploadedImageLink, error)
 	DeleteUploadedImage(ctx context.Context, path string, imagePath string, host string) error
-	ListStoredReleasePaths(ctx context.Context) ([]string, error)
-	PurgeContentData(ctx context.Context, path string) error
+}
+
+var (
+	// ErrMissingReleaseStateRepository indicates incomplete repository composition.
+	ErrMissingReleaseStateRepository = errors.New("api: release state repository is required")
+	// ErrMissingPreparedReleaseRepository indicates incomplete prepared-generation persistence.
+	ErrMissingPreparedReleaseRepository = errors.New("api: prepared release repository is required")
+	// ErrMissingReleaseSelectionRepository indicates incomplete repository composition.
+	ErrMissingReleaseSelectionRepository = errors.New("api: release selection repository is required")
+	// ErrMissingHistoryRepository indicates incomplete repository composition.
+	ErrMissingHistoryRepository = errors.New("api: history repository is required")
+	// ErrMissingUploadLedgerRepository indicates incomplete repository composition.
+	ErrMissingUploadLedgerRepository = errors.New("api: upload ledger repository is required")
+	// ErrMissingTrackerStateRepository indicates incomplete repository composition.
+	ErrMissingTrackerStateRepository = errors.New("api: tracker state repository is required")
+	// ErrMissingMediaAssetRepository indicates incomplete repository composition.
+	ErrMissingMediaAssetRepository = errors.New("api: media asset repository is required")
+)
+
+// RepositoryCapabilities is an immutable set of borrowed persistence
+// capabilities. Construct it from one adapter so production capabilities share
+// connection, retry, transaction, and lifecycle ownership.
+type RepositoryCapabilities struct {
+	releaseState ReleaseStateRepository
+	prepared     PreparedReleaseRepository
+	selections   ReleaseSelectionRepository
+	history      HistoryRepository
+	uploads      UploadLedgerRepository
+	trackers     TrackerStateRepository
+	media        MediaAssetRepository
+}
+
+// RepositoryCapabilitiesFrom projects one adapter onto every repository seam.
+// Call [RepositoryCapabilities.Validate] before installing the result.
+func RepositoryCapabilitiesFrom(adapter any) RepositoryCapabilities {
+	releaseState, _ := adapter.(ReleaseStateRepository)
+	prepared, _ := adapter.(PreparedReleaseRepository)
+	selections, _ := adapter.(ReleaseSelectionRepository)
+	history, _ := adapter.(HistoryRepository)
+	uploads, _ := adapter.(UploadLedgerRepository)
+	trackers, _ := adapter.(TrackerStateRepository)
+	media, _ := adapter.(MediaAssetRepository)
+	return RepositoryCapabilities{
+		releaseState: releaseState,
+		prepared:     prepared,
+		selections:   selections,
+		history:      history,
+		uploads:      uploads,
+		trackers:     trackers,
+		media:        media,
+	}
+}
+
+// NewRepositoryCapabilities constructs and validates borrowed capabilities
+// projected from one adapter.
+func NewRepositoryCapabilities(adapter any) (RepositoryCapabilities, error) {
+	capabilities := RepositoryCapabilitiesFrom(adapter)
+	if err := capabilities.Validate(); err != nil {
+		return RepositoryCapabilities{}, err
+	}
+	return capabilities, nil
+}
+
+// Validate rejects missing and typed-nil capabilities before runtime use.
+func (c RepositoryCapabilities) Validate() error {
+	checks := []struct {
+		value any
+		err   error
+	}{
+		{value: c.releaseState, err: ErrMissingReleaseStateRepository},
+		{value: c.prepared, err: ErrMissingPreparedReleaseRepository},
+		{value: c.selections, err: ErrMissingReleaseSelectionRepository},
+		{value: c.history, err: ErrMissingHistoryRepository},
+		{value: c.uploads, err: ErrMissingUploadLedgerRepository},
+		{value: c.trackers, err: ErrMissingTrackerStateRepository},
+		{value: c.media, err: ErrMissingMediaAssetRepository},
+	}
+	for _, check := range checks {
+		if isNilRepositoryCapability(check.value) {
+			return check.err
+		}
+	}
+	return nil
+}
+
+// IsZero reports whether no repository capabilities were supplied.
+func (c RepositoryCapabilities) IsZero() bool {
+	return c.releaseState == nil && c.prepared == nil && c.selections == nil && c.history == nil && c.uploads == nil && c.trackers == nil && c.media == nil
+}
+
+// ReleaseState returns the borrowed release-state capability.
+func (c RepositoryCapabilities) ReleaseState() ReleaseStateRepository { return c.releaseState }
+
+// Prepared returns the borrowed whole-generation prepared-release capability.
+func (c RepositoryCapabilities) Prepared() PreparedReleaseRepository { return c.prepared }
+
+// Selections returns the borrowed release-selection capability.
+func (c RepositoryCapabilities) Selections() ReleaseSelectionRepository { return c.selections }
+
+// History returns the borrowed history capability.
+func (c RepositoryCapabilities) History() HistoryRepository { return c.history }
+
+// Uploads returns the borrowed upload-ledger capability.
+func (c RepositoryCapabilities) Uploads() UploadLedgerRepository { return c.uploads }
+
+// Trackers returns the borrowed tracker-state capability.
+func (c RepositoryCapabilities) Trackers() TrackerStateRepository { return c.trackers }
+
+// Media returns the borrowed media-asset capability.
+func (c RepositoryCapabilities) Media() MediaAssetRepository { return c.media }
+
+func isNilRepositoryCapability(value any) bool {
+	if value == nil {
+		return true
+	}
+	reflected := reflect.ValueOf(value)
+	kind := reflected.Kind()
+	if kind == reflect.Chan || kind == reflect.Func || kind == reflect.Interface || kind == reflect.Map || kind == reflect.Pointer || kind == reflect.Slice {
+		return reflected.IsNil()
+	}
+	return false
 }
diff --git a/pkg/api/repository_capabilities_test.go b/pkg/api/repository_capabilities_test.go
new file mode 100644
index 00000000..caa6f090
--- /dev/null
+++ b/pkg/api/repository_capabilities_test.go
@@ -0,0 +1,82 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type nilReleaseStateRepository struct{}
+
+func (*nilReleaseStateRepository) GetByPath(context.Context, string) (FileMetadata, error) {
+	return FileMetadata{}, nil
+}
+func (*nilReleaseStateRepository) Save(context.Context, FileMetadata) error { return nil }
+func (*nilReleaseStateRepository) GetExternalIdentity(context.Context, string) (ExternalIdentity, error) {
+	return ExternalIdentity{}, nil
+}
+func (*nilReleaseStateRepository) SaveExternalIdentity(context.Context, ExternalIdentity) error {
+	return nil
+}
+func (*nilReleaseStateRepository) GetExternalMetadata(context.Context, string) (SourceScopedMetadata, error) {
+	return SourceScopedMetadata{}, nil
+}
+func (*nilReleaseStateRepository) SaveExternalMetadata(context.Context, SourceScopedMetadata) error {
+	return nil
+}
+func (*nilReleaseStateRepository) GetDVDMediaInfo(context.Context, string) (DVDMediaInfo, error) {
+	return DVDMediaInfo{}, nil
+}
+func (*nilReleaseStateRepository) SaveDVDMediaInfo(context.Context, DVDMediaInfo) error { return nil }
+func (*nilReleaseStateRepository) GetReleaseNameOverrides(context.Context, string) (ReleaseNameOverrides, error) {
+	return ReleaseNameOverrides{}, nil
+}
+func (*nilReleaseStateRepository) SaveReleaseNameOverrides(context.Context, string, ReleaseNameOverrides) error {
+	return nil
+}
+func (*nilReleaseStateRepository) DeleteReleaseNameOverrides(context.Context, string) error {
+	return nil
+}
+
+func TestRepositoryCapabilitiesRejectMissingAndTypedNil(t *testing.T) {
+	t.Parallel()
+
+	if err := (RepositoryCapabilities{}).Validate(); !errors.Is(err, ErrMissingReleaseStateRepository) {
+		t.Fatalf("zero bundle error = %v, want %v", err, ErrMissingReleaseStateRepository)
+	}
+	var typedNil *nilReleaseStateRepository
+	capabilities := RepositoryCapabilities{releaseState: typedNil}
+	if err := capabilities.Validate(); !errors.Is(err, ErrMissingReleaseStateRepository) {
+		t.Fatalf("typed-nil bundle error = %v, want %v", err, ErrMissingReleaseStateRepository)
+	}
+}
+
+func TestRepositoryCapabilityInterfacesDoNotExposeLifecycleOrSQL(t *testing.T) {
+	t.Parallel()
+
+	interfaces := []reflect.Type{
+		reflect.TypeFor[ReleaseStateRepository](),
+		reflect.TypeFor[PreparedReleaseRepository](),
+		reflect.TypeFor[ReleaseSelectionRepository](),
+		reflect.TypeFor[HistoryRepository](),
+		reflect.TypeFor[UploadLedgerRepository](),
+		reflect.TypeFor[TrackerStateRepository](),
+		reflect.TypeFor[MediaAssetRepository](),
+		reflect.TypeFor[ScreenshotLifecycleRepository](),
+	}
+	for _, interfaceType := range interfaces {
+		if _, ok := interfaceType.MethodByName("Close"); ok {
+			t.Errorf("%s exposes Close", interfaceType)
+		}
+		for method := range interfaceType.Methods() {
+			if strings.Contains(method.Type.String(), "database/sql") {
+				t.Errorf("%s.%s exposes SQL type %s", interfaceType, method.Name, method.Type)
+			}
+		}
+	}
+}
diff --git a/pkg/api/repository_test.go b/pkg/api/repository_test.go
index de5b3768..d2981bd5 100644
--- a/pkg/api/repository_test.go
+++ b/pkg/api/repository_test.go
@@ -12,12 +12,42 @@ func TestNormalizeCategory(t *testing.T) {
 		want  Category
 		valid bool
 	}{
-		{name: "movie", input: "movie", want: CategoryMovie, valid: true},
-		{name: "film alias", input: "Film", want: CategoryMovie, valid: true},
-		{name: "tv series alias", input: "tv-show", want: CategoryTV, valid: true},
-		{name: "episode alias", input: "episode", want: CategoryTV, valid: true},
-		{name: "empty", input: "", want: CategoryUnknown, valid: false},
-		{name: "unsupported", input: "Music", want: Category("Music"), valid: false},
+		{
+			name:  "movie",
+			input: "movie",
+			want:  CategoryMovie,
+			valid: true,
+		},
+		{
+			name:  "film alias",
+			input: "Film",
+			want:  CategoryMovie,
+			valid: true,
+		},
+		{
+			name:  "tv series alias",
+			input: "tv-show",
+			want:  CategoryTV,
+			valid: true,
+		},
+		{
+			name:  "episode alias",
+			input: "episode",
+			want:  CategoryTV,
+			valid: true,
+		},
+		{
+			name:  "empty",
+			input: "",
+			want:  CategoryUnknown,
+			valid: false,
+		},
+		{
+			name:  "unsupported",
+			input: "Music",
+			want:  Category("Music"),
+			valid: false,
+		},
 	}
 
 	for _, tc := range tests {
diff --git a/pkg/api/request_mapping.go b/pkg/api/request_mapping.go
new file mode 100644
index 00000000..11051e48
--- /dev/null
+++ b/pkg/api/request_mapping.go
@@ -0,0 +1,146 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"errors"
+	"fmt"
+	"maps"
+	"strings"
+)
+
+// ErrPreparationSourceRequired reports a request without a preparation source.
+var ErrPreparationSourceRequired = errors.New("preparation source path is required")
+
+// MapPreparationRequest maps one shared operation request to detached canonical
+// preparation input. It performs no filesystem access or entrypoint-specific
+// policy.
+func MapPreparationRequest(request Request, intent PreparationIntent) (PrepareInput, error) {
+	sourcePath := strings.TrimSpace(request.SourcePath)
+	if sourcePath == "" {
+		return PrepareInput{}, ErrPreparationSourceRequired
+	}
+
+	input := PrepareInput{
+		SourcePath: sourcePath,
+		Intent:     intent,
+		Instructions: ReleaseFactInstructions{
+			Identity:     cloneExternalIDOverrides(request.ExternalIDOverrides),
+			ReleaseName:  cloneReleaseNameOverrides(request.ReleaseNameOverrides),
+			Metadata:     cloneMetadataOverrides(request.MetadataOverrides),
+			SourceLookup: strings.TrimSpace(request.SourceLookupURL),
+			TrackerIDs:   cloneStringMap(request.TrackerIDOverrides),
+			Playlist: PlaylistInstruction{
+				Set:      request.PlaylistInstruction.Set,
+				Selected: append([]string(nil), request.PlaylistInstruction.Selected...),
+				UseAll:   request.PlaylistInstruction.UseAll,
+			},
+		},
+		Policy: PreparationPolicy{
+			KeepFolder: request.Options.KeepFolder,
+			KeepImages: request.Options.KeepImages,
+			OnlyID:     request.Options.OnlyID,
+		},
+		Search: ClientSearchPolicy{
+			Skip:   request.Options.SkipAutoTorrent,
+			Client: cloneString(request.ClientOverrides.Client),
+		},
+		Controls: PreparationControls{
+			Interaction:       request.Options.InteractionMode,
+			ConfirmBDMVRescan: request.ConfirmBDMVRescan,
+			ForceRecheck:      cloneBool(request.ClientOverrides.ForceRecheck),
+		},
+	}
+	if request.ReleaseNameOverrides.Category != nil {
+		category, err := NormalizeCanonicalCategory(*request.ReleaseNameOverrides.Category)
+		if err != nil {
+			return PrepareInput{}, fmt.Errorf("canonical category instruction: %w", err)
+		}
+		input.Instructions.Category = &category
+	}
+	return input, nil
+}
+
+// cloneStringMap detaches caller-owned map storage before request normalization.
+func cloneStringMap(value map[string]string) map[string]string {
+	if value == nil {
+		return nil
+	}
+	cloned := make(map[string]string, len(value))
+	maps.Copy(cloned, value)
+	return cloned
+}
+
+func cloneExternalIDOverrides(value ExternalIDOverrides) ExternalIDOverrides {
+	return ExternalIDOverrides{
+		TMDBID:   cloneInt(value.TMDBID),
+		IMDBID:   cloneInt(value.IMDBID),
+		TVDBID:   cloneInt(value.TVDBID),
+		TVmazeID: cloneInt(value.TVmazeID),
+		MALID:    cloneInt(value.MALID),
+	}
+}
+
+func cloneReleaseNameOverrides(value ReleaseNameOverrides) ReleaseNameOverrides {
+	return ReleaseNameOverrides{
+		Category:         cloneString(value.Category),
+		Type:             cloneString(value.Type),
+		Source:           cloneString(value.Source),
+		Resolution:       cloneString(value.Resolution),
+		Tag:              cloneString(value.Tag),
+		Service:          cloneString(value.Service),
+		Edition:          cloneString(value.Edition),
+		Season:           cloneString(value.Season),
+		Episode:          cloneString(value.Episode),
+		EpisodeTitle:     cloneString(value.EpisodeTitle),
+		ManualYear:       cloneInt(value.ManualYear),
+		ManualDate:       cloneString(value.ManualDate),
+		UseSeasonEpisode: cloneBool(value.UseSeasonEpisode),
+		NoSeason:         cloneBool(value.NoSeason),
+		NoYear:           cloneBool(value.NoYear),
+		NoAKA:            cloneBool(value.NoAKA),
+		NoTag:            cloneBool(value.NoTag),
+		NoEdition:        cloneBool(value.NoEdition),
+		NoDub:            cloneBool(value.NoDub),
+		NoDual:           cloneBool(value.NoDual),
+		DualAudio:        cloneBool(value.DualAudio),
+		Region:           cloneString(value.Region),
+	}
+}
+
+func cloneMetadataOverrides(value MetadataOverrides) MetadataOverrides {
+	return MetadataOverrides{
+		Distributor:      cloneString(value.Distributor),
+		OriginalLanguage: cloneString(value.OriginalLanguage),
+		PersonalRelease:  cloneBool(value.PersonalRelease),
+		Commentary:       cloneBool(value.Commentary),
+		WebDV:            cloneBool(value.WebDV),
+		StreamOptimized:  cloneBool(value.StreamOptimized),
+		Anime:            cloneBool(value.Anime),
+	}
+}
+
+func cloneInt(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+func cloneString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
+
+func cloneBool(value *bool) *bool {
+	if value == nil {
+		return nil
+	}
+	cloned := *value
+	return &cloned
+}
diff --git a/pkg/api/request_mapping_test.go b/pkg/api/request_mapping_test.go
new file mode 100644
index 00000000..b7beddbb
--- /dev/null
+++ b/pkg/api/request_mapping_test.go
@@ -0,0 +1,139 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+import (
+	"errors"
+	"reflect"
+	"slices"
+	"testing"
+)
+
+func TestMapPreparationRequestPreservesSingleSourceIntent(t *testing.T) {
+	t.Parallel()
+
+	tmdbID := 123456
+	category := "TV"
+	releaseType := "episode"
+	tag := "GRP"
+	distributor := "Example Distributor"
+	personalRelease := false
+	client := "qbit"
+	forceRecheck := false
+	request := Request{
+		SourcePath: "  Example.Release.2026.mkv  ",
+		Options: UploadOptions{
+			KeepFolder:      true,
+			KeepImages:      true,
+			OnlyID:          true,
+			SkipAutoTorrent: true,
+			InteractionMode: InteractionModeInteractive,
+		},
+		ExternalIDOverrides: ExternalIDOverrides{TMDBID: &tmdbID},
+		ReleaseNameOverrides: ReleaseNameOverrides{
+			Category: &category,
+			Type:     &releaseType,
+			Tag:      &tag,
+		},
+		MetadataOverrides: MetadataOverrides{
+			Distributor:     &distributor,
+			PersonalRelease: &personalRelease,
+		},
+		SourceLookupURL:    "  https://example.invalid/source  ",
+		TrackerIDOverrides: map[string]string{"btn": "123"},
+		PlaylistInstruction: PlaylistInstruction{
+			Set:      true,
+			Selected: []string{},
+			UseAll:   false,
+		},
+		ClientOverrides: ClientOverrides{
+			Client:       &client,
+			ForceRecheck: &forceRecheck,
+		},
+		ConfirmBDMVRescan: true,
+	}
+
+	input, err := MapPreparationRequest(request, PreparationIntentUpload)
+	if err != nil {
+		t.Fatalf("map preparation request: %v", err)
+	}
+	canonicalCategory := CanonicalCategoryTV
+	expected := PrepareInput{
+		SourcePath: "Example.Release.2026.mkv",
+		Intent:     PreparationIntentUpload,
+		Instructions: ReleaseFactInstructions{
+			Identity: ExternalIDOverrides{TMDBID: new(123456)},
+			Category: &canonicalCategory,
+			ReleaseName: ReleaseNameOverrides{
+				Category: new("TV"),
+				Type:     new("episode"),
+				Tag:      new("GRP"),
+			},
+			Metadata:     MetadataOverrides{Distributor: new("Example Distributor"), PersonalRelease: new(false)},
+			SourceLookup: "https://example.invalid/source",
+			Playlist: PlaylistInstruction{
+				Set:      true,
+				Selected: nil,
+				UseAll:   false,
+			},
+			TrackerIDs: map[string]string{"btn": "123"},
+		},
+		Policy: PreparationPolicy{
+			KeepFolder: true,
+			KeepImages: true,
+			OnlyID:     true,
+		},
+		Search: ClientSearchPolicy{Skip: true, Client: new("qbit")},
+		Controls: PreparationControls{
+			Interaction:       InteractionModeInteractive,
+			ConfirmBDMVRescan: true,
+			ForceRecheck:      new(false),
+		},
+	}
+	if !reflect.DeepEqual(input, expected) {
+		t.Fatalf("mapped input = %#v, want %#v", input, expected)
+	}
+
+	*request.ExternalIDOverrides.TMDBID = 999999
+	*request.ReleaseNameOverrides.Tag = "CHANGED"
+	*request.MetadataOverrides.Distributor = "CHANGED"
+	*request.ClientOverrides.Client = "changed"
+	request.TrackerIDOverrides["btn"] = "changed"
+	request.PlaylistInstruction.Selected = append(request.PlaylistInstruction.Selected, "00001.mpls")
+	if !reflect.DeepEqual(input, expected) {
+		t.Fatalf("mapped input aliases request state: %#v", input)
+	}
+}
+
+func TestPrepareInputMappingFieldDispositionIsExplicit(t *testing.T) {
+	t.Parallel()
+
+	assertFieldNames(t, reflect.TypeFor[PrepareInput](), []string{"SourcePath", "Intent", "Instructions", "Policy", "Search", "Controls", "Force"})
+	assertFieldNames(t, reflect.TypeFor[ReleaseFactInstructions](), []string{
+		"Identity", "Category", "ReleaseName", "Metadata", "SourceLookup", "BlurayReleaseID", "Playlist", "TrackerIDs",
+	})
+	assertFieldNames(t, reflect.TypeFor[PreparationPolicy](), []string{"KeepFolder", "KeepImages", "OnlyID"})
+	assertFieldNames(t, reflect.TypeFor[ClientSearchPolicy](), []string{"Skip", "Client"})
+	assertFieldNames(t, reflect.TypeFor[PreparationControls](), []string{"Interaction", "ConfirmBDMVRescan", "ForceRecheck"})
+}
+
+func TestMapPreparationRequestRejectsBlankSource(t *testing.T) {
+	t.Parallel()
+
+	_, err := MapPreparationRequest(Request{SourcePath: "  "}, PreparationIntentPreview)
+	if !errors.Is(err, ErrPreparationSourceRequired) {
+		t.Fatalf("error = %v, want ErrPreparationSourceRequired", err)
+	}
+}
+
+func assertFieldNames(t *testing.T, value reflect.Type, want []string) {
+	t.Helper()
+	got := make([]string, 0, value.NumField())
+	for field := range value.Fields() {
+		got = append(got, field.Name)
+	}
+	if !slices.Equal(got, want) {
+		t.Fatalf("%s fields = %v, want %v", value.Name(), got, want)
+	}
+}
diff --git a/pkg/api/screenshots.go b/pkg/api/screenshots.go
index 76fd583b..5d4a1b67 100644
--- a/pkg/api/screenshots.go
+++ b/pkg/api/screenshots.go
@@ -53,6 +53,37 @@ type ScreenshotOverrides struct {
 	MenuPaths              []string
 }
 
+// ScreenshotSubject contains only source facts required to plan and manage
+// screenshots. Workflow modules build it from an exact prepared generation.
+type ScreenshotSubject struct {
+	SourcePath            string
+	DiscType              string
+	VideoPath             string
+	MediaInfoJSONPath     string
+	MediaCategory         string
+	HDR                   string
+	TVPack                bool
+	Episode               int
+	Release               ReleaseInfo
+	SelectedBDMVPlaylists []PlaylistInfo
+	DefaultCount          int
+	ManualFrames          []int
+}
+
+// DVDMenuSubject contains the stable source facts required by DVD-menu
+// capture and lifecycle operations.
+type DVDMenuSubject struct {
+	SourcePath string
+	DiscType   string
+}
+
+// ImageHostingSubject scopes image-host operations to one prepared source.
+// GalleryName is the already-resolved display name used by batch hosts.
+type ImageHostingSubject struct {
+	SourcePath  string
+	GalleryName string
+}
+
 type ScreenshotFinalSelection struct {
 	SourcePath string
 	ImagePath  string
diff --git a/pkg/api/services.go b/pkg/api/services.go
index 0f93e147..48551188 100644
--- a/pkg/api/services.go
+++ b/pkg/api/services.go
@@ -13,7 +13,9 @@ import (
 )
 
 type ServiceSet struct {
-	Metadata   MetadataService
+	// Metadata is an internal preparation collector override. Core validates the
+	// private contract before use; no mutable preparation type is exported here.
+	Metadata   any
 	Trackers   TrackerService
 	Torrents   TorrentService
 	Clients    ClientService
@@ -27,32 +29,20 @@ type ServiceSet struct {
 	Images   ImageHostingService
 }
 
-type MetadataService interface {
-	Prepare(ctx context.Context, req Request) (PreparedMetadata, error)
-	RefreshPreparedMetadata(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	EnrichTrackerData(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	ApplyMediaInfoIDs(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	ApplyArrData(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	ResolveExternalIDs(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	ApplyMediaDetails(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-	// ApplyTrackerClaims applies claim-based tracker blocks using metadata that
-	// has already been enriched with media details and tracker rule state.
-	ApplyTrackerClaims(ctx context.Context, meta PreparedMetadata) (PreparedMetadata, error)
-}
-
 type TrackerService interface {
-	Upload(ctx context.Context, meta PreparedMetadata) (UploadSummary, error)
-	BuildPreparation(ctx context.Context, meta PreparedMetadata, trackers []string) (PreparationPreview, error)
-	BuildUploadDryRun(ctx context.Context, meta PreparedMetadata, trackers []string) ([]TrackerDryRunEntry, error)
+	Upload(ctx context.Context, subject UploadSubject) (UploadSummary, error)
+	BuildPreparation(ctx context.Context, subject DescriptionSubject, trackers []string) (PreparationPreview, error)
+	BuildUploadReview(ctx context.Context, subject UploadSubject, trackers []string) ([]TrackerDryRunEntry, error)
+	BuildUploadDryRun(ctx context.Context, subject UploadSubject, trackers []string) ([]TrackerDryRunEntry, error)
 }
 
 type TorrentService interface {
-	Create(ctx context.Context, meta PreparedMetadata) (TorrentResult, error)
+	Create(ctx context.Context, subject TorrentSubject) (TorrentResult, error)
 }
 
 type ClientService interface {
-	Inject(ctx context.Context, meta PreparedMetadata, torrent TorrentResult) error
-	SearchPathedTorrents(ctx context.Context, meta PreparedMetadata) (ClientSearchResult, error)
+	Inject(ctx context.Context, subject ClientSubject, torrent TorrentResult) error
+	SearchPathedTorrents(ctx context.Context, subject ClientSubject) (ClientSearchResult, error)
 }
 
 type FilesystemService interface {
@@ -60,10 +50,53 @@ type FilesystemService interface {
 }
 
 type DupeService interface {
-	Check(ctx context.Context, meta PreparedMetadata, trackers []string) (DupeCheckSummary, error)
-}
-
-// TrackerAuthService exposes the batch auth operations needed before GUI and
+	Check(ctx context.Context, subject DuplicateSubject, trackers []string) (DupeCheckSummary, error)
+}
+
+// DuplicateSubject is the duplicate module's source-scoped read model. It
+// contains only facts, instructions, and prior workflow outcomes that affect
+// duplicate search or authorization.
+type DuplicateSubject struct {
+	SourcePath           string
+	SourceSize           int64
+	VideoPath            string
+	FileList             []string
+	Filename             string
+	SceneName            string
+	ReleaseName          string
+	Release              ReleaseInfo
+	ReleaseNameOverrides ReleaseNameOverrides
+	Identity             ExternalIdentity
+	ProviderMetadata     SourceScopedMetadata
+	TrackerIDs           map[string]string
+	DiscType             string
+	Type                 string
+	Source               string
+	Tag                  string
+	HDR                  string
+	UHD                  string
+	VideoEncode          string
+	VideoCodec           string
+	HasEncodeSettings    bool
+	SeasonInt            int
+	EpisodeInt           int
+	SeasonStr            string
+	EpisodeStr           string
+	DailyEpisodeDate     string
+	TVPack               bool
+	Anime                bool
+	MatchedTrackers      []string
+	TrackerRuleFailures  map[string][]RuleFailure
+	BlockedTrackers      map[string][]TrackerBlockReason
+	CrossSeedTorrents    []UploadedTorrent
+}
+
+// CanonicalSeasonEpisode returns the prepared TV season and episode.
+func (s DuplicateSubject) CanonicalSeasonEpisode() (int, int) {
+	return s.SeasonInt, s.EpisodeInt
+}
+
+// TrackerAuthService exposes the batch auth operations needed before WebUI and
 // embedded-web duplicate checking.
 type TrackerAuthService interface {
 	// Capabilities returns the configured trackers whose auth workflows the
@@ -75,28 +108,28 @@ type TrackerAuthService interface {
 }
 
 type ScreenshotService interface {
-	Plan(ctx context.Context, meta PreparedMetadata, count int) (ScreenshotPlan, error)
-	Capture(ctx context.Context, meta PreparedMetadata, selections []ScreenshotSelection, purpose ScreenshotPurpose) (ScreenshotResult, error)
-	PreviewFrame(ctx context.Context, meta PreparedMetadata, timestampSeconds float64) (ScreenshotPreview, error)
-	Delete(ctx context.Context, meta PreparedMetadata, imagePath string) error
-	SaveFinalSelections(ctx context.Context, meta PreparedMetadata, images []ScreenshotImage) error
+	Plan(ctx context.Context, subject ScreenshotSubject, count int) (ScreenshotPlan, error)
+	Capture(ctx context.Context, subject ScreenshotSubject, selections []ScreenshotSelection, purpose ScreenshotPurpose) (ScreenshotResult, error)
+	PreviewFrame(ctx context.Context, subject ScreenshotSubject, timestampSeconds float64) (ScreenshotPreview, error)
+	Delete(ctx context.Context, subject ScreenshotSubject, imagePath string) error
+	SaveFinalSelections(ctx context.Context, subject ScreenshotSubject, images []ScreenshotImage) error
 }
 
 // DVDMenuService captures and manages persisted menu images for prepared DVD metadata.
 type DVDMenuService interface {
 	// Capture replaces automatic captures up to maxItems while preserving manual menus.
-	Capture(ctx context.Context, meta PreparedMetadata, maxItems int) (DVDMenuCaptureResult, error)
+	Capture(ctx context.Context, subject DVDMenuSubject, maxItems int) (DVDMenuCaptureResult, error)
 	// List returns persisted manual and automatic menu images in selection order.
-	List(ctx context.Context, meta PreparedMetadata) ([]ScreenshotImage, error)
+	List(ctx context.Context, subject DVDMenuSubject) ([]ScreenshotImage, error)
 	// Delete removes one managed menu image and its local repository references.
-	Delete(ctx context.Context, meta PreparedMetadata, imagePath string) error
+	Delete(ctx context.Context, subject DVDMenuSubject, imagePath string) error
 	// Capability reports path-free engine and FFmpeg dvdvideo support.
 	Capability(ctx context.Context) (DVDMenuEngineInfo, error)
 }
 
 type ImageHostingService interface {
-	ListCandidates(ctx context.Context, meta PreparedMetadata) ([]ScreenshotImage, error)
-	Upload(ctx context.Context, meta PreparedMetadata, host string, usageScope string, images []ScreenshotImage) ([]UploadedImageLink, error)
+	ListCandidates(ctx context.Context, subject ImageHostingSubject) ([]ScreenshotImage, error)
+	Upload(ctx context.Context, subject ImageHostingSubject, host string, usageScope string, images []ScreenshotImage) ([]UploadedImageLink, error)
 }
 
 type TrackerBlockReason string
@@ -107,18 +140,11 @@ const (
 	TrackerBlockReasonAudio TrackerBlockReason = "audio"
 )
 
-// PreparedMetadata contains the shared metadata snapshot used across CLI, GUI,
-// embedded web, and tracker upload flows. Release preserves parsed release-name
-// data; SeasonInt and EpisodeInt carry canonical TV identity after metadata
-// parsing and provider/date remapping.
-type PreparedMetadata struct {
+// TrackerSubject is the tracker module's operation-owned source, resource,
+// instruction, and prerequisite view. It excludes preparation diagnostics,
+// resolver evidence, cache freshness, and client-search implementation state.
+type UploadSubject struct {
 	SourcePath                  string
-	SourceLookupURL             string
-	SourceLookupActive          bool
-	SourceLookupMode            string
-	SourceLookupTracker         string
-	SourceLookupTrackerID       string
-	LookupWarnings              []string
 	Paths                       []string
 	DiscType                    string
 	VideoPath                   string
@@ -126,24 +152,12 @@ type PreparedMetadata struct {
 	SourceSize                  int64
 	MediaInfoJSONPath           string
 	MediaInfoTextPath           string
-	DVDIFOPath                  string
-	DVDVOBPath                  string
-	DVDVOBSet                   string
-	DVDVOBMediaInfoJSON         string
 	DVDVOBMediaInfoText         string
-	MediaInfoUniqueID           string
 	Scene                       bool
 	SceneName                   string
-	SceneTMDBID                 int
-	SceneIMDB                   int
-	SceneTVDBID                 int
-	SceneTVmazeID               int
-	SceneMALID                  int
 	SceneNFOPath                string
-	SceneNFONew                 bool
 	SceneRenamed                bool
 	SceneRenamedReason          string
-	Mode                        Mode
 	DescriptionGroups           []DescriptionBuilderGroup
 	Trackers                    []string
 	Options                     UploadOptions
@@ -151,46 +165,19 @@ type PreparedMetadata struct {
 	MatchedTrackers             []string
 	Tag                         string
 	Release                     ReleaseInfo
-	TagOverride                 *TagOverride
 	DescriptionOverride         string
-	MetadataOverrides           MetadataOverrides
 	TrackerConfigOverrides      TrackerConfigOverrides
 	TrackerSiteOverrides        TrackerSiteOverrides
-	ClientOverrides             ClientOverrides
 	ImageHostOverrides          ImageHostOverrides
-	ScreenshotOverrides         ScreenshotOverrides
-	TorrentOverrides            TorrentOverrides
 	DescriptionTemplate         string
 	PersonalRelease             bool
 	InfoHash                    string
 	TrackerIDs                  map[string]string
-	FoundTrackerMatch           bool
-	TorrentComments             []TorrentMatch
-	PieceSizeConstraint         string
-	FoundPreferredPiece         string
-	StoredInfoHash              string
-	StoredUpdatedAt             time.Time `ts_type:"string"`
-	StoredDataFresh             bool
 	TrackerData                 []TrackerMetadata
 	CrossSeedTorrents           []UploadedTorrent
 	ClientTorrentPath           string
 	TorrentPath                 string
-	MediaInfoCategory           string
-	MediaInfoTMDBID             int
-	MediaInfoIMDBID             int
-	MediaInfoTVDBID             int
-	ArrSource                   string
-	ArrTMDBID                   int
-	ArrIMDBID                   int
-	ArrTVDBID                   int
-	ArrTVmazeID                 int
-	ArrYear                     int
-	ArrGenres                   []string
 	ArrReleaseGroup             string
-	MismatchedMediaInfoTMDBID   int
-	MismatchedMediaInfoIMDBID   int
-	MismatchedMediaInfoTVDBID   int
-	ExternalIDOverrides         ExternalIDOverrides
 	ReleaseNameOverrides        ReleaseNameOverrides
 	TrackerQuestionnaireAnswers map[string]map[string]string
 	SeasonInt                   int
@@ -198,22 +185,17 @@ type PreparedMetadata struct {
 	SeasonStr                   string
 	EpisodeStr                  string
 	TVDBAiredDate               string
-	TVDBAirsDays                []string
 	TVDBAirsTime                string
 	TVDBAirsTimezone            string
-	TVDBAirsTimezoneSource      string
 	TVPack                      bool
 	DailyEpisodeDate            string
-	TMDBDateMatch               bool
 	Anime                       bool
-	MALID                       int
 	EpisodeTitle                string
 	EpisodeOverview             string
-	EpisodeYear                 int
 	SelectedBDMVPlaylists       []PlaylistInfo
-	ExternalIDs                 ExternalIDs
-	ExternalIDCandidates        ExternalIDCandidates
-	ExternalMetadata            ExternalMetadata
+	Identity                    ExternalIdentity
+	ProviderMetadata            SourceScopedMetadata
+	Disc                        DiscFacts
 	AudioLanguages              []string
 	SubtitleLanguages           []string
 	Container                   string
@@ -234,8 +216,7 @@ type PreparedMetadata struct {
 	Edition                     string
 	Repack                      string
 	WebDV                       bool
-	ValidMediaInfo              bool
-	ValidMediaInfoSettings      bool
+	Assessments                 ReleaseAssessments
 	StreamOptimized             int
 	Service                     string
 	ServiceLongName             string
@@ -243,40 +224,154 @@ type PreparedMetadata struct {
 	ReleaseName                 string
 	ReleaseNameNoTag            string
 	ReleaseNameClean            string
-	ReleaseNameMissing          []string
 	BlockedTrackers             map[string][]TrackerBlockReason
-	IgnoreTrackerRuleFailures   bool
 	TrackerRuleFailures         map[string][]RuleFailure
-	BDInfo                      map[string]any
 }
 
-// CanonicalSeasonEpisode returns the provider-resolved TV season/episode used
-// for upload identity and naming.
-func (m PreparedMetadata) CanonicalSeasonEpisode() (int, int) {
-	return m.SeasonInt, m.EpisodeInt
-}
-
-// SeasonEpisodeWithParsedFallback returns canonical season/episode values and
-// falls back to release-name parsed values independently for each missing
-// field. The returned season and episode can come from different sources, so
-// callers must not treat the pair as source-consistent. Use this for TV
-// classification and lookup fallbacks, not for canonical upload naming.
-func (m PreparedMetadata) SeasonEpisodeWithParsedFallback() (int, int) {
-	season, episode := m.CanonicalSeasonEpisode()
-	if season <= 0 {
-		season = m.Release.Season
+// RuleSubject contains only stable facts used by generic and tracker-specific
+// eligibility rules.
+type RuleSubject struct {
+	SourcePath          string
+	VideoPath           string
+	FileList            []string
+	DiscType            string
+	Scene               bool
+	SceneNFOPath        string
+	SceneRenamed        bool
+	SceneRenamedReason  string
+	PersonalRelease     bool
+	Release             ReleaseInfo
+	ReleaseName         string
+	ReleaseNameNoTag    string
+	Tag                 string
+	Identity            ExternalIdentity
+	ProviderMetadata    SourceScopedMetadata
+	AudioLanguages      []string
+	SubtitleLanguages   []string
+	TVPack              bool
+	Type                string
+	Source              string
+	Container           string
+	BitDepth            string
+	VideoCodec          string
+	VideoEncode         string
+	HDR                 string
+	Region              string
+	WebDV               bool
+	Anime               bool
+	Assessments         ReleaseAssessments
+	DescriptionOverride string
+}
+
+// NewRuleSubject projects upload facts into the rule evaluator's read model.
+func NewRuleSubject(subject UploadSubject) RuleSubject {
+	return RuleSubject{
+		SourcePath:          subject.SourcePath,
+		VideoPath:           subject.VideoPath,
+		FileList:            append([]string(nil), subject.FileList...),
+		DiscType:            subject.DiscType,
+		Scene:               subject.Scene,
+		SceneNFOPath:        subject.SceneNFOPath,
+		SceneRenamed:        subject.SceneRenamed,
+		SceneRenamedReason:  subject.SceneRenamedReason,
+		PersonalRelease:     subject.PersonalRelease,
+		Release:             subject.Release,
+		ReleaseName:         subject.ReleaseName,
+		ReleaseNameNoTag:    subject.ReleaseNameNoTag,
+		Tag:                 subject.Tag,
+		Identity:            subject.Identity,
+		ProviderMetadata:    subject.ProviderMetadata,
+		AudioLanguages:      append([]string(nil), subject.AudioLanguages...),
+		SubtitleLanguages:   append([]string(nil), subject.SubtitleLanguages...),
+		TVPack:              subject.TVPack,
+		Type:                subject.Type,
+		Source:              subject.Source,
+		Container:           subject.Container,
+		BitDepth:            subject.BitDepth,
+		VideoCodec:          subject.VideoCodec,
+		VideoEncode:         subject.VideoEncode,
+		HDR:                 subject.HDR,
+		Region:              subject.Region,
+		WebDV:               subject.WebDV,
+		Anime:               subject.Anime,
+		Assessments:         subject.Assessments,
+		DescriptionOverride: subject.DescriptionOverride,
 	}
-	if episode <= 0 {
-		episode = m.Release.Episode
+}
+
+// DescriptionSubject contains only facts, local resources, and rendering
+// instructions consumed by tracker description builders.
+type DescriptionSubject struct {
+	SourcePath            string
+	DiscType              string
+	MediaInfoTextPath     string
+	DVDVOBMediaInfoText   string
+	DescriptionTemplate   string
+	EpisodeOverview       string
+	Options               UploadOptions
+	Release               ReleaseInfo
+	SelectedBDMVPlaylists []PlaylistInfo
+	Tag                   string
+	Identity              ExternalIdentity
+	ProviderMetadata      SourceScopedMetadata
+	SeasonInt             int
+	EpisodeInt            int
+	Filename              string
+	ReleaseName           string
+	ReleaseNameNoTag      string
+	ServiceLongName       string
+	Type                  string
+	HDR                   string
+	ArrReleaseGroup       string
+	Trackers              []string
+	TrackerConfig         TrackerConfigOverrides
+	TrackerSite           TrackerSiteOverrides
+	ImageHost             ImageHostOverrides
+	TrackerData           []TrackerMetadata
+}
+
+// NewDescriptionSubject projects upload state into the description builder's
+// read model and detaches mutable collections.
+func NewDescriptionSubject(subject UploadSubject) DescriptionSubject {
+	projected := DescriptionSubject{
+		SourcePath:            subject.SourcePath,
+		DiscType:              subject.DiscType,
+		MediaInfoTextPath:     subject.MediaInfoTextPath,
+		DVDVOBMediaInfoText:   subject.DVDVOBMediaInfoText,
+		DescriptionTemplate:   subject.DescriptionTemplate,
+		EpisodeOverview:       subject.EpisodeOverview,
+		Options:               subject.Options,
+		Release:               subject.Release,
+		SelectedBDMVPlaylists: append([]PlaylistInfo(nil), subject.SelectedBDMVPlaylists...),
+		Tag:                   subject.Tag,
+		Identity:              subject.Identity,
+		ProviderMetadata:      subject.ProviderMetadata,
+		SeasonInt:             subject.SeasonInt,
+		EpisodeInt:            subject.EpisodeInt,
+		Filename:              subject.Filename,
+		ReleaseName:           subject.ReleaseName,
+		ReleaseNameNoTag:      subject.ReleaseNameNoTag,
+		ServiceLongName:       subject.ServiceLongName,
+		Type:                  subject.Type,
+		HDR:                   subject.HDR,
+		ArrReleaseGroup:       subject.ArrReleaseGroup,
+		Trackers:              append([]string(nil), subject.Trackers...),
+		TrackerConfig:         subject.TrackerConfigOverrides,
+		TrackerSite:           subject.TrackerSiteOverrides,
+		ImageHost:             subject.ImageHostOverrides,
+		TrackerData:           append([]TrackerMetadata(nil), subject.TrackerData...),
 	}
-	return season, episode
+	cloned, err := clonePreparedValue(projected)
+	if err != nil {
+		panic(fmt.Sprintf("clone description subject: %v", err))
+	}
+	return cloned
 }
 
-// HasTVSeasonEpisodeSignal reports whether either canonical metadata or the
-// parsed release name carries a season/episode hint.
-func (m PreparedMetadata) HasTVSeasonEpisodeSignal() bool {
-	season, episode := m.SeasonEpisodeWithParsedFallback()
-	return season > 0 || episode > 0
+// CanonicalSeasonEpisode returns the provider-resolved TV season/episode used
+// by tracker operations.
+func (s UploadSubject) CanonicalSeasonEpisode() (int, int) {
+	return s.SeasonInt, s.EpisodeInt
 }
 
 type MetadataOverrides struct {
@@ -308,69 +403,91 @@ type TorrentOverrides struct {
 	Rehash          *bool
 }
 
-type ExternalIDCandidates struct {
-	TMDB             []ExternalIDCandidate
-	IMDB             []ExternalIDCandidate
-	TMDBAutoSelected bool
-	IMDBAutoSelected bool
+// TorrentSubject contains only facts and instructions required to create or
+// validate a torrent artifact for one prepared source.
+type TorrentSubject struct {
+	SourcePath        string
+	SourceSize        int64
+	FileList          []string
+	DiscType          string
+	ClientTorrentPath string
+	Trackers          []string
+	TorrentOverrides  TorrentOverrides
 }
 
-type ExternalIDCandidate struct {
-	Provider      string
-	ID            int
-	Title         string
-	OriginalTitle string
-	Year          int
-	Category      string
-	MediaType     string
-	Overview      string
-	PosterURL     string
-	Similarity    float64
+// ClientSubject contains only source facts and caller instructions required
+// for torrent-client search, linking, and injection.
+type ClientSubject struct {
+	SourcePath      string
+	FileList        []string
+	DiscType        string
+	ClientOverrides ClientOverrides
 }
 
-// RuleFailureSeverity classifies whether a tracker rule result blocks work.
-// The zero value and unrecognized values are treated as blocking for backward
-// compatibility and fail-closed behavior.
-type RuleFailureSeverity string
+// RuleDisposition identifies how a failed tracker rule affects live upload.
+type RuleDisposition string
 
 const (
-	// RuleFailureSeverityBlocking prevents the affected tracker operation.
-	RuleFailureSeverityBlocking RuleFailureSeverity = "blocking"
-	// RuleFailureSeverityWarning reports advice without preventing the operation.
-	RuleFailureSeverityWarning RuleFailureSeverity = "warning"
+	// RuleDispositionAdvisory reports guidance without blocking live upload.
+	RuleDispositionAdvisory RuleDisposition = "advisory"
+	// RuleDispositionWaivable requires exact user authorization before live upload.
+	RuleDispositionWaivable RuleDisposition = "waivable"
+	// RuleDispositionStrict blocks live upload and cannot be authorized.
+	RuleDispositionStrict RuleDisposition = "strict"
 )
 
-// RuleFailure describes a failed or advisory tracker rule result.
+// RuleFailure describes one stable tracker-rule result.
 type RuleFailure struct {
-	Rule   string
-	Reason string
-	// Severity defaults to blocking when empty or unrecognized.
-	Severity RuleFailureSeverity
+	Rule        string
+	Reason      string
+	Disposition RuleDisposition
 }
 
-// NormalizeRuleFailureSeverity maps the warning value to itself and all other
-// values, including legacy empty values, to blocking.
-func NormalizeRuleFailureSeverity(severity RuleFailureSeverity) RuleFailureSeverity {
-	if severity == RuleFailureSeverityWarning {
-		return RuleFailureSeverityWarning
+// RuleAuthorization binds user consent to exact current rule keys for one tracker.
+type RuleAuthorization struct {
+	Tracker string
+	Rules   []string
+}
+
+// NormalizeRuleDisposition maps legacy persisted values and fails closed for
+// unknown values. Empty and legacy blocking results remain user-waivable;
+// unknown non-empty values become strict.
+func NormalizeRuleDisposition(disposition RuleDisposition) RuleDisposition {
+	switch disposition {
+	case RuleDispositionAdvisory, RuleDispositionWaivable, RuleDispositionStrict:
+		return disposition
+	case "warning":
+		return RuleDispositionAdvisory
+	case "", "blocking":
+		return RuleDispositionWaivable
+	default:
+		return RuleDispositionStrict
 	}
-	return RuleFailureSeverityBlocking
 }
 
 // IsBlockingRuleFailure reports whether a rule result blocks tracker work.
 func IsBlockingRuleFailure(failure RuleFailure) bool {
-	return NormalizeRuleFailureSeverity(failure.Severity) == RuleFailureSeverityBlocking
+	return NormalizeRuleDisposition(failure.Disposition) != RuleDispositionAdvisory
+}
+
+// IsStrictRuleFailure reports whether a rule result can never be authorized.
+func IsStrictRuleFailure(failure RuleFailure) bool {
+	return NormalizeRuleDisposition(failure.Disposition) == RuleDispositionStrict
+}
+
+// IsWaivableRuleFailure reports whether exact authorization may unblock a result.
+func IsWaivableRuleFailure(failure RuleFailure) bool {
+	return NormalizeRuleDisposition(failure.Disposition) == RuleDispositionWaivable
 }
 
 // BlockingRuleFailures returns an independent slice containing only blocking
-// results. Legacy and unrecognized severities are included.
+// results. Legacy and unrecognized dispositions are included.
 func BlockingRuleFailures(failures []RuleFailure) []RuleFailure {
 	return filterRuleFailures(failures, true)
 }
 
-// WarningRuleFailures returns an independent slice containing only results with
-// the explicit warning severity.
-func WarningRuleFailures(failures []RuleFailure) []RuleFailure {
+// AdvisoryRuleFailures returns an independent slice containing only advisory results.
+func AdvisoryRuleFailures(failures []RuleFailure) []RuleFailure {
 	return filterRuleFailures(failures, false)
 }
 
@@ -380,11 +497,11 @@ func HasBlockingRuleFailures(failures []RuleFailure) bool {
 }
 
 // CountBlockingRuleFailures returns the number of rule results that block
-// tracker work. Legacy and unrecognized severities are counted as blocking.
+// tracker work. Legacy and unrecognized dispositions are counted as blocking.
 func CountBlockingRuleFailures(failures []TrackerRuleFailure) int {
 	count := 0
 	for _, failure := range failures {
-		if NormalizeRuleFailureSeverity(failure.Severity) == RuleFailureSeverityBlocking {
+		if NormalizeRuleDisposition(failure.Disposition) != RuleDispositionAdvisory {
 			count++
 		}
 	}
@@ -417,47 +534,6 @@ type ExternalIDOverrides struct {
 	MALID *int
 }
 
-// ExternalIDs contains canonical IDs finalized by metadata resolution.
-// Downstream search, rule, preview, history, and upload code should use these
-// fields instead of re-reading raw resolver fallback inputs.
-type ExternalIDs struct {
-	// SourcePath is the content path these resolved IDs belong to. Empty means
-	// the record is not scoped to a specific source path.
-	SourcePath string
-	TMDBID     int
-	IMDBID     int
-	TVDBID     int
-	TVmazeID   int
-	// MALID is the canonical anime identifier used by MAL/AniList-compatible
-	// tracker fields after metadata resolution.
-	MALID    int
-	Category string
-	// Source* fields record the resolver source labels that produced each
-	// provider ID, for example tracker, mediainfo, tmdb, or scene.
-	SourceTMDB   string
-	SourceIMDB   string
-	SourceTVDB   string
-	SourceTVmaze string
-	// SourceMAL records the resolver source label for MALID.
-	SourceMAL string
-	UpdatedAt time.Time `ts_type:"string"`
-}
-
-// ExternalMetadata stores provider-specific metadata snapshots resolved for one
-// source path. Nil provider fields mean that provider has no stored snapshot.
-type ExternalMetadata struct {
-	// SourcePath scopes the metadata to a prepared source path when set.
-	SourcePath string
-	TMDB       *TMDBMetadata
-	IMDB       *IMDBMetadata
-	TVDB       *TVDBMetadata
-	TVmaze     *TVmazeMetadata
-	// AniList stores rich anime metadata resolved from the canonical MALID.
-	AniList   *AniListMetadata
-	Bluray    *BlurayMetadata
-	UpdatedAt time.Time `ts_type:"string"`
-}
-
 // AniListMetadata is the AniList media snapshot used for MAL/AniList preview.
 //
 // Date fields keep AniList fuzzy-date precision, score fields are percentages
@@ -663,8 +739,8 @@ func (m *BlurayMetadata) SelectCandidate(releaseID string, auto bool, reason str
 	return true
 }
 
-// TMDBMetadata is the shared TMDB metadata snapshot returned to CLI, Wails, and
-// embedded web callers during upload preparation and review.
+// TMDBMetadata is the shared TMDB metadata snapshot returned to CLI and WebUI
+// callers during upload preparation and review.
 type TMDBMetadata struct {
 	TMDBID           int
 	IMDBID           int
@@ -698,7 +774,7 @@ type TMDBMetadata struct {
 	Keywords         string
 	// LocalizedTitles maps lowercase language codes and optional regional tags
 	// such as "de" or "pt-BR" to TMDB translation titles. Nil values marshal as
-	// an empty JSON object for Wails and embedded-web callers.
+	// an empty JSON object for WebUI callers.
 	LocalizedTitles     map[string]string
 	YouTube             string
 	Certification       string
@@ -721,12 +797,12 @@ type TMDBLocalizedData struct {
 	Poster          string
 }
 
-// ExtractLocalizedPTBR returns the pt-BR localized data from the given
-// metadata, or an empty value when none is available.
-func ExtractLocalizedPTBR(meta PreparedMetadata) TMDBLocalizedData {
-	if meta.ExternalMetadata.TMDB != nil && meta.ExternalMetadata.TMDB.Localized != nil {
-		if v, ok := meta.ExternalMetadata.TMDB.Localized["pt-BR"]; ok {
-			return v
+// ExtractTrackerLocalizedPTBR returns pt-BR provider data from a tracker-owned
+// operation subject.
+func ExtractTrackerLocalizedPTBR(subject UploadSubject) TMDBLocalizedData {
+	if subject.ProviderMetadata.TMDB != nil && subject.ProviderMetadata.TMDB.Localized != nil {
+		if value, ok := subject.ProviderMetadata.TMDB.Localized["pt-BR"]; ok {
+			return value
 		}
 	}
 	return TMDBLocalizedData{}
diff --git a/pkg/api/services_test.go b/pkg/api/services_test.go
index 9c5cbd30..e05ccdd2 100644
--- a/pkg/api/services_test.go
+++ b/pkg/api/services_test.go
@@ -8,43 +8,46 @@ import (
 	"testing"
 )
 
-func TestPreparedMetadataSeasonEpisodeHelpers(t *testing.T) {
-	meta := PreparedMetadata{
-		SeasonInt: 9,
-		Release: ReleaseInfo{
-			Season:  1,
-			Episode: 2,
-		},
-	}
+func TestNewDescriptionSubjectDetachesNestedFacts(t *testing.T) {
+	t.Parallel()
 
-	canonicalSeason, canonicalEpisode := meta.CanonicalSeasonEpisode()
-	if canonicalSeason != 9 || canonicalEpisode != 0 {
-		t.Fatalf("canonical season/episode = %d/%d, want 9/0", canonicalSeason, canonicalEpisode)
+	source := UploadSubject{
+		Release: ReleaseInfo{Codec: []string{"H.265"}},
+		ProviderMetadata: SourceScopedMetadata{TMDB: &TMDBMetadata{
+			LocalizedTitles: map[string]string{"en": "Example Release 2026"},
+		}},
+		SelectedBDMVPlaylists: []PlaylistInfo{{File: "00001.mpls"}},
 	}
+	projected := NewDescriptionSubject(source)
+	projected.Release.Codec[0] = "changed"
+	projected.ProviderMetadata.TMDB.LocalizedTitles["en"] = "changed"
+	projected.SelectedBDMVPlaylists[0].File = "changed"
 
-	fallbackSeason, fallbackEpisode := meta.SeasonEpisodeWithParsedFallback()
-	if fallbackSeason != 9 || fallbackEpisode != 2 {
-		t.Fatalf("fallback season/episode = %d/%d, want 9/2", fallbackSeason, fallbackEpisode)
+	if source.Release.Codec[0] != "H.265" {
+		t.Fatal("release facts share storage with description subject")
 	}
-	if !meta.HasTVSeasonEpisodeSignal() {
-		t.Fatalf("expected parsed release episode to provide TV signal")
+	if source.ProviderMetadata.TMDB.LocalizedTitles["en"] != "Example Release 2026" {
+		t.Fatal("provider metadata shares storage with description subject")
+	}
+	if source.SelectedBDMVPlaylists[0].File != "00001.mpls" {
+		t.Fatal("playlist facts share storage with description subject")
 	}
 }
 
-func TestRuleFailureSeverityFailClosed(t *testing.T) {
+func TestRuleFailureDispositionFailClosed(t *testing.T) {
 	t.Parallel()
 	failures := []RuleFailure{
 		{Rule: "legacy"},
-		{Rule: "warning", Severity: RuleFailureSeverityWarning},
-		{Rule: "unknown", Severity: "unexpected"},
+		{Rule: "advisory", Disposition: RuleDispositionAdvisory},
+		{Rule: "unknown", Disposition: "unexpected"},
 	}
 	if !HasBlockingRuleFailures(failures) {
-		t.Fatal("expected legacy and unknown severities to block")
+		t.Fatal("expected legacy and unknown dispositions to block")
 	}
 	storedFailures := []TrackerRuleFailure{
 		{Rule: "legacy"},
-		{Rule: "warning", Severity: RuleFailureSeverityWarning},
-		{Rule: "unknown", Severity: "unexpected"},
+		{Rule: "advisory", Disposition: RuleDispositionAdvisory},
+		{Rule: "unknown", Disposition: "unexpected"},
 	}
 	if got := CountBlockingRuleFailures(storedFailures); got != 2 {
 		t.Fatalf("blocking count = %d, want 2", got)
@@ -52,8 +55,13 @@ func TestRuleFailureSeverityFailClosed(t *testing.T) {
 	if got := BlockingRuleFailures(failures); len(got) != 2 || got[0].Rule != "legacy" || got[1].Rule != "unknown" {
 		t.Fatalf("unexpected blocking subset: %#v", got)
 	}
-	if got := WarningRuleFailures(failures); len(got) != 1 || got[0].Rule != "warning" {
-		t.Fatalf("unexpected warning subset: %#v", got)
+	if got := AdvisoryRuleFailures(failures); len(got) != 1 || got[0].Rule != "advisory" {
+		t.Fatalf("unexpected advisory subset: %#v", got)
+	}
+	if NormalizeRuleDisposition("warning") != RuleDispositionAdvisory ||
+		NormalizeRuleDisposition("blocking") != RuleDispositionWaivable ||
+		NormalizeRuleDisposition("unexpected") != RuleDispositionStrict {
+		t.Fatal("legacy or unknown disposition normalization changed")
 	}
 }
 
diff --git a/pkg/api/testdata/prepared_release_display.json b/pkg/api/testdata/prepared_release_display.json
new file mode 100644
index 00000000..5299fef4
--- /dev/null
+++ b/pkg/api/testdata/prepared_release_display.json
@@ -0,0 +1,235 @@
+{
+  "ReleaseName": "Example.Release.2026.1080p-GRP",
+  "Providers": [
+    {
+      "Provider": "tmdb",
+      "ID": 101,
+      "DisplayID": "101",
+      "URL": "https://www.themoviedb.org/movie/101",
+      "Provenance": "explicit",
+      "SummaryAvailable": true,
+      "Summary": {
+        "Title": "Example TMDB",
+        "OriginalTitle": "Example Original",
+        "Year": 2026,
+        "Overview": "TMDB overview",
+        "PosterURL": "https://img.example/tmdb-poster.jpg",
+        "BackdropURL": "https://img.example/tmdb-backdrop.jpg",
+        "Category": "movie",
+        "Date": "2026-01-02",
+        "EndDate": "2026-02-03",
+        "OriginalLanguage": "en",
+        "MediaType": "movie",
+        "RuntimeMinutes": 123,
+        "Genres": "Drama",
+        "Keywords": "example, release",
+        "TrailerURL": "https://video.example/tmdb",
+        "Rating": 0,
+        "RatingCount": 0,
+        "Country": "AU, NZ"
+      },
+      "Details": {
+        "TMDB": {
+          "TMDBID": 101,
+          "Category": "movie",
+          "Title": "Example TMDB",
+          "OriginalTitle": "Example Original",
+          "Year": 2026,
+          "ReleaseDate": "2026-01-02",
+          "LastAirDate": "2026-02-03",
+          "OriginCountry": ["AU", "NZ"],
+          "OriginalLanguage": "en",
+          "Overview": "TMDB overview",
+          "Poster": "https://img.example/tmdb-poster.jpg",
+          "Backdrop": "https://img.example/tmdb-backdrop.jpg",
+          "TMDBType": "movie",
+          "Runtime": 123,
+          "Genres": "Drama",
+          "Keywords": "example, release",
+          "LocalizedTitles": {},
+          "YouTube": "https://video.example/tmdb"
+        }
+      }
+    },
+    {
+      "Provider": "imdb",
+      "ID": 123456,
+      "DisplayID": "tt0123456",
+      "URL": "https://www.imdb.com/title/tt0123456",
+      "Provenance": "tracker",
+      "SummaryAvailable": true,
+      "Summary": {
+        "Title": "Example IMDb",
+        "OriginalTitle": "",
+        "Year": 2025,
+        "Overview": "IMDb overview",
+        "PosterURL": "https://img.example/imdb-cover.jpg",
+        "BackdropURL": "",
+        "Category": "movie",
+        "Date": "",
+        "EndDate": "",
+        "OriginalLanguage": "en",
+        "MediaType": "movie",
+        "RuntimeMinutes": 119,
+        "Genres": "Mystery",
+        "Keywords": "",
+        "TrailerURL": "",
+        "Rating": 7.4,
+        "RatingCount": 4567,
+        "Country": "Australia"
+      },
+      "Details": {
+        "IMDB": {
+          "IMDBID": 123456,
+          "Title": "Example IMDb",
+          "Year": 2025,
+          "Type": "movie",
+          "Plot": "IMDb overview",
+          "Rating": 7.4,
+          "RatingCount": 4567,
+          "RuntimeMinutes": 119,
+          "Genres": "Mystery",
+          "Country": "Australia",
+          "Cover": "https://img.example/imdb-cover.jpg",
+          "OriginalLanguage": "en"
+        }
+      }
+    },
+    {
+      "Provider": "tvdb",
+      "ID": 303,
+      "DisplayID": "303",
+      "URL": "https://www.thetvdb.com/?id=303&tab=series",
+      "Provenance": "scene",
+      "SummaryAvailable": true,
+      "Summary": {
+        "Title": "Example TVDB",
+        "OriginalTitle": "",
+        "Year": 2024,
+        "Overview": "TVDB overview",
+        "PosterURL": "https://img.example/tvdb-poster.jpg",
+        "BackdropURL": "",
+        "Category": "movie",
+        "Date": "2024-03-04",
+        "EndDate": "",
+        "OriginalLanguage": "fr",
+        "MediaType": "series",
+        "RuntimeMinutes": 0,
+        "Genres": "Comedy",
+        "Keywords": "",
+        "TrailerURL": "",
+        "Rating": 0,
+        "RatingCount": 0,
+        "Country": "FR"
+      },
+      "Details": {
+        "TVDB": {
+          "TVDBID": 303,
+          "Name": "Example TVDB",
+          "Overview": "TVDB overview",
+          "FirstAired": "2024-03-04",
+          "Year": 2024,
+          "Type": "series",
+          "OriginalCountry": "FR",
+          "OriginalLanguage": "fr",
+          "Genres": "Comedy",
+          "Poster": "https://img.example/tvdb-poster.jpg"
+        }
+      }
+    },
+    {
+      "Provider": "tvmaze",
+      "ID": 404,
+      "DisplayID": "404",
+      "URL": "https://www.tvmaze.com/shows/404",
+      "Provenance": "arr",
+      "SummaryAvailable": true,
+      "Summary": {
+        "Title": "Example TVmaze",
+        "OriginalTitle": "",
+        "Year": 0,
+        "Overview": "TVmaze overview",
+        "PosterURL": "https://img.example/tvmaze-poster.jpg",
+        "BackdropURL": "https://img.example/tvmaze-backdrop.jpg",
+        "Category": "movie",
+        "Date": "2023-05-06",
+        "EndDate": "2023-07-08",
+        "OriginalLanguage": "es",
+        "MediaType": "Scripted",
+        "RuntimeMinutes": 47,
+        "Genres": "Thriller",
+        "Keywords": "",
+        "TrailerURL": "",
+        "Rating": 8.1,
+        "RatingCount": 99,
+        "Country": "ES"
+      },
+      "Details": {
+        "TVmaze": {
+          "TVmazeID": 404,
+          "Name": "Example TVmaze",
+          "Premiered": "2023-05-06",
+          "Ended": "2023-07-08",
+          "Summary": "TVmaze overview",
+          "Type": "Scripted",
+          "Language": "es",
+          "Genres": "Thriller",
+          "AverageRuntime": 47,
+          "Rating": 8.1,
+          "Weight": 99,
+          "Country": "ES",
+          "Poster": "https://img.example/tvmaze-poster.jpg",
+          "Backdrop": "https://img.example/tvmaze-backdrop.jpg"
+        }
+      }
+    },
+    {
+      "Provider": "mal",
+      "ID": 505,
+      "DisplayID": "505",
+      "URL": "https://myanimelist.net/anime/505",
+      "Provenance": "provider",
+      "SummaryAvailable": true,
+      "Summary": {
+        "Title": "Example Anime",
+        "OriginalTitle": "Example Anime Romaji",
+        "Year": 2022,
+        "Overview": "AniList overview",
+        "PosterURL": "https://img.example/anilist-cover.jpg",
+        "BackdropURL": "https://img.example/anilist-banner.jpg",
+        "Category": "TV",
+        "Date": "2022-09-10",
+        "EndDate": "2022-12-11",
+        "OriginalLanguage": "jp",
+        "MediaType": "TV",
+        "RuntimeMinutes": 24,
+        "Genres": "Action, Drama",
+        "Keywords": "",
+        "TrailerURL": "",
+        "Rating": 8.2,
+        "RatingCount": 6789,
+        "Country": ""
+      },
+      "Details": {
+        "AniList": {
+          "AniListID": 606,
+          "MALID": 505,
+          "TitleRomaji": "Example Anime Romaji",
+          "TitleEnglish": "Example Anime",
+          "Description": "AniList overview",
+          "Format": "TV",
+          "StartDate": "2022-09-10",
+          "EndDate": "2022-12-11",
+          "SeasonYear": 2022,
+          "Duration": 24,
+          "CountryOfOrigin": "JP",
+          "CoverExtraLarge": "https://img.example/anilist-cover.jpg",
+          "BannerImage": "https://img.example/anilist-banner.jpg",
+          "Genres": ["Action", "Drama"],
+          "AverageScore": 82,
+          "Popularity": 6789
+        }
+      }
+    }
+  ]
+}
diff --git a/pkg/api/tracker_auth.go b/pkg/api/tracker_auth.go
index 34354be9..19f90f9a 100644
--- a/pkg/api/tracker_auth.go
+++ b/pkg/api/tracker_auth.go
@@ -5,27 +5,29 @@ package api
 
 // TrackerAuthCapability describes the auth operations the UI can offer for one tracker.
 type TrackerAuthCapability struct {
-	// TrackerID is the normalized tracker code used in bridge requests.
+	// TrackerID is the normalized tracker code used in WebUI requests.
 	TrackerID   string `json:"trackerID"`
 	DisplayName string `json:"displayName"`
 	// AuthKind is a compact capability label such as "cookies", "credential_login", or "api_key_cookies_login".
-	AuthKind           string   `json:"authKind"`
-	SupportsCookieFile bool     `json:"supportsCookieFile"`
-	SupportsLogin      bool     `json:"supportsLogin"`
-	SupportsAutoLogin  bool     `json:"supportsAutoLogin"`
-	SupportsTOTP       bool     `json:"supportsTOTP"`
-	SupportsManual2FA  bool     `json:"supportsManual2FA"`
-	RequiresAPIKey     bool     `json:"requiresAPIKey"`
-	RequiresPasskey    bool     `json:"requiresPasskey"`
-	Notes              []string `json:"notes"`
+	AuthKind           string `json:"authKind"`
+	SupportsCookieFile bool   `json:"supportsCookieFile"`
+	SupportsLogin      bool   `json:"supportsLogin"`
+	SupportsAutoLogin  bool   `json:"supportsAutoLogin"`
+	SupportsTOTP       bool   `json:"supportsTOTP"`
+	SupportsManual2FA  bool   `json:"supportsManual2FA"`
+	// SupportsRemoteValidation reports whether Check Auth can execute a tracker-owned remote resolver.
+	SupportsRemoteValidation bool     `json:"supportsRemoteValidation"`
+	RequiresAPIKey           bool     `json:"requiresAPIKey"`
+	RequiresPasskey          bool     `json:"requiresPasskey"`
+	Notes                    []string `json:"notes"`
 }
 
 // TrackerAuthStatus reports the current local tracker auth state after a
 // status, import, login, validation, 2FA, or delete action.
 //
-// Wails, embedded web, and frontend consumers must expose the same JSON fields
+// WebUI routes and TypeScript consumers must expose the same JSON fields
 // so status summaries, remediation messages, and Promise-visible errors stay in
-// parity across GUI entrypoints.
+// parity across browser entrypoints.
 type TrackerAuthStatus struct {
 	TrackerID   string `json:"trackerID"`
 	DisplayName string `json:"displayName"`
diff --git a/pkg/api/tracker_auth_test.go b/pkg/api/tracker_auth_test.go
index a366d17c..37548f53 100644
--- a/pkg/api/tracker_auth_test.go
+++ b/pkg/api/tracker_auth_test.go
@@ -5,7 +5,6 @@ package api
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -60,30 +59,37 @@ func TestTrackerAuthStatusConsumerContractsIncludeAPIFields(t *testing.T) {
 	t.Parallel()
 
 	fields := trackerAuthStatusJSONFields(t)
-	frontendTypes := readRepoFile(t, "gui", "frontend", "src", "types.ts")
+	frontendTypes := readRepoFile(t, "webui", "src", "types.ts")
 
 	assertContractBlockFields(t, frontendTypes, "export type TrackerAuthStatus = {", "};", fields)
+}
 
-	wailsModels, ok := readOptionalRepoFile(t, "gui", "frontend", "wailsjs", "go", "models.ts")
-	if !ok {
-		t.Log("skipping generated Wails model contract check; gui/frontend/wailsjs/go/models.ts is ignored and absent in clean checkouts")
-		return
-	}
-	assertContractBlockFields(t, wailsModels, "export class TrackerAuthStatus {", "static createFrom", fields)
+func TestTrackerAuthCapabilityConsumerContractsIncludeAPIFields(t *testing.T) {
+	t.Parallel()
+
+	fields := jsonFieldNames[TrackerAuthCapability](t)
+	frontendTypes := readRepoFile(t, "webui", "src", "types.ts")
+
+	assertContractBlockFields(t, frontendTypes, "export type TrackerAuthCapability = {", "};", fields)
 }
 
 // trackerAuthStatusJSONFields returns the serialized field names that every
 // frontend-facing auth status consumer must keep in its local contract.
 func trackerAuthStatusJSONFields(t *testing.T) []string {
 	t.Helper()
+	return jsonFieldNames[TrackerAuthStatus](t)
+}
+
+func jsonFieldNames[T any](t *testing.T) []string {
+	t.Helper()
 
-	statusType := reflect.TypeFor[TrackerAuthStatus]()
-	fields := make([]string, 0, statusType.NumField())
-	for field := range statusType.Fields() {
+	contractType := reflect.TypeFor[T]()
+	fields := make([]string, 0, contractType.NumField())
+	for field := range contractType.Fields() {
 		tag := field.Tag.Get("json")
 		name, _, _ := strings.Cut(tag, ",")
 		if name == "" || name == "-" {
-			t.Fatalf("TrackerAuthStatus field %s missing JSON contract tag", field.Name)
+			t.Fatalf("%s field %s missing JSON contract tag", contractType.Name(), field.Name)
 		}
 		fields = append(fields, name)
 	}
@@ -123,20 +129,6 @@ func readRepoFile(t *testing.T, parts ...string) string {
 	return string(content)
 }
 
-func readOptionalRepoFile(t *testing.T, parts ...string) (string, bool) {
-	t.Helper()
-
-	content, err := readRepoFileContent(parts...)
-	if err == nil {
-		return string(content), true
-	}
-	if errors.Is(err, os.ErrNotExist) {
-		return "", false
-	}
-	t.Fatalf("read optional repo contract file %v: %v", parts, err)
-	return "", false
-}
-
 func readRepoFileContent(parts ...string) ([]byte, error) {
 	pathParts := append([]string{"..", ".."}, parts...)
 	content, err := os.ReadFile(filepath.Join(pathParts...))
diff --git a/pkg/api/tracker_catalog.go b/pkg/api/tracker_catalog.go
new file mode 100644
index 00000000..a1fc0c96
--- /dev/null
+++ b/pkg/api/tracker_catalog.go
@@ -0,0 +1,29 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+// TrackerCatalogField describes one ordered tracker setting without exposing its current value.
+type TrackerCatalogField struct {
+	Key        string `json:"key"`
+	YAMLKey    string `json:"yamlKey"`
+	Default    any    `json:"default"`
+	Activation bool   `json:"activation"`
+}
+
+// TrackerCatalogEntry combines tracker implementation identity with its config schema.
+type TrackerCatalogEntry struct {
+	Name              string                `json:"name"`
+	Family            string                `json:"family"`
+	BaseURL           string                `json:"baseURL"`
+	UploadContentMode string                `json:"uploadContentMode"`
+	Fields            []TrackerCatalogField `json:"fields"`
+	Configured        bool                  `json:"configured"`
+}
+
+// TrackerCatalog is the complete settings manifest for supported trackers and
+// the names of preserved inert entries that no implementation owns.
+type TrackerCatalog struct {
+	Entries     []TrackerCatalogEntry `json:"entries"`
+	Unsupported []string              `json:"unsupported"`
+}
diff --git a/pkg/api/tracker_eligibility.go b/pkg/api/tracker_eligibility.go
new file mode 100644
index 00000000..8acf8a2c
--- /dev/null
+++ b/pkg/api/tracker_eligibility.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package api
+
+// TrackerEligibilityReasonCode identifies one canonical tracker blocker.
+type TrackerEligibilityReasonCode string
+
+const (
+	TrackerEligibilityDuplicate                    TrackerEligibilityReasonCode = "duplicate"
+	TrackerEligibilityBlockingRule                 TrackerEligibilityReasonCode = "blocking_rule"
+	TrackerEligibilityPolicy                       TrackerEligibilityReasonCode = "policy"
+	TrackerEligibilityAuthRequired                 TrackerEligibilityReasonCode = "auth_required"
+	TrackerEligibilityAssessmentSkipped            TrackerEligibilityReasonCode = "assessment_skipped"
+	TrackerEligibilityAssessmentFailed             TrackerEligibilityReasonCode = "assessment_failed"
+	TrackerEligibilityBannedGroup                  TrackerEligibilityReasonCode = "banned_group"
+	TrackerEligibilityScreenshotPreparationFailed  TrackerEligibilityReasonCode = "screenshot_preparation_failed"
+	TrackerEligibilityDescriptionPreparationFailed TrackerEligibilityReasonCode = "description_preparation_failed"
+)
+
+// TrackerEligibilityReason is safe presentation data for one blocker.
+type TrackerEligibilityReason struct {
+	Code    TrackerEligibilityReasonCode
+	Message string
+}
+
+// TrackerContentFailure is sanitized tracker-scoped evidence that a required
+// shared upload-content object failed before its adapter could run.
+type TrackerContentFailure struct {
+	Tracker string                       `json:"tracker"`
+	Code    TrackerEligibilityReasonCode `json:"code"`
+	Message string                       `json:"message"`
+}
+
+// TrackerReviewChoices records explicit review authorizations for one tracker.
+type TrackerReviewChoices struct {
+	IgnoreDuplicate        bool
+	AuthorizedRuleFailures []string
+}
+
+// TrackerEligibilityAssessment is Core input gathered from current exact-
+// generation policy, duplicate, auth, and dry-run assessment.
+type TrackerEligibilityAssessment struct {
+	Tracker        string
+	Duplicate      DupeCheckResult
+	RuleFailures   []RuleFailure
+	PolicyBlocks   []TrackerBlockReason
+	AuthRequired   bool
+	Banned         bool
+	BannedReason   string
+	ContentFailure *TrackerContentFailure
+	Choices        TrackerReviewChoices
+}
+
+// TrackerEligibilityInput requests ordered eligibility for an exact release.
+type TrackerEligibilityInput struct {
+	Release          ReleaseRef
+	SelectedTrackers []string
+	Assessments      []TrackerEligibilityAssessment
+}
+
+// TrackerEligibilityState is one selected tracker's canonical decision.
+type TrackerEligibilityState struct {
+	Tracker       string
+	Eligible      bool
+	Reasons       []TrackerEligibilityReason
+	RuleDecisions []RuleDecision
+}
+
+// RuleDecision retains one failed rule and whether exact user authorization applies.
+type RuleDecision struct {
+	Rule        string
+	Reason      string
+	Disposition RuleDisposition
+	Authorized  bool
+}
+
+// TrackerEligibility is the ordered canonical decision for one exact release.
+type TrackerEligibility struct {
+	Release          ReleaseRef
+	Trackers         []TrackerEligibilityState
+	EligibleTrackers []string
+}
diff --git a/pkg/api/upload_progress.go b/pkg/api/upload_progress.go
index 9e6ca06e..591493d9 100644
--- a/pkg/api/upload_progress.go
+++ b/pkg/api/upload_progress.go
@@ -3,25 +3,63 @@
 
 package api
 
-import "context"
+import (
+	"context"
+	"errors"
+)
 
+// UploadProgressUpdate describes one source- and tracker-scoped upload progress event.
 type UploadProgressUpdate struct {
-	SourcePath      string  `json:"sourcePath"`
-	Tracker         string  `json:"tracker"`
-	Task            string  `json:"task"`
-	Status          string  `json:"status"`
-	Message         string  `json:"message"`
-	CompletedPieces int     `json:"completedPieces"`
-	TotalPieces     int     `json:"totalPieces"`
-	Percent         int     `json:"percent"`
-	HashRateMiB     float64 `json:"hashRateMiB"`
-	Timestamp       string  `json:"timestamp"`
+	// SourcePath is the host filesystem release path.
+	SourcePath string `json:"sourcePath"`
+	// Tracker identifies the tracker when the task is tracker-specific.
+	Tracker string `json:"tracker"`
+	// Task is the stable progress operation identifier.
+	Task string `json:"task"`
+	// Status is the stable lifecycle state for Task.
+	Status string `json:"status"`
+	// Message contains sanitized user-facing progress detail.
+	Message string `json:"message"`
+	// CompletedPieces is the number of torrent pieces hashed so far.
+	CompletedPieces int `json:"completedPieces"`
+	// TotalPieces is the total number of torrent pieces to hash.
+	TotalPieces int `json:"totalPieces"`
+	// Percent is integer completion percentage from 0 through 100.
+	Percent int `json:"percent"`
+	// HashRateMiB is the current hashing throughput in MiB per second.
+	HashRateMiB float64 `json:"hashRateMiB"`
+	// Timestamp is the event time serialized by the producer.
+	Timestamp string `json:"timestamp"`
 }
 
+// UploadProgressReporter receives synchronous progress notifications from an upload context.
 type UploadProgressReporter func(update UploadProgressUpdate)
 
+// TrackerLocalUploadError distinguishes attributable tracker failures from operation-wide errors.
+type TrackerLocalUploadError interface {
+	error
+	// TrackerLocalUploadFailures returns tracker names whose attributable work failed.
+	TrackerLocalUploadFailures() []string
+}
+
+// IsTrackerLocalUploadError reports whether err contains tracker-local failure classification.
+func IsTrackerLocalUploadError(err error) bool {
+	var local TrackerLocalUploadError
+	return errors.As(err, &local)
+}
+
+// TrackerLocalUploadFailureNames returns a defensive tracker list from a classified error.
+func TrackerLocalUploadFailureNames(err error) []string {
+	var local TrackerLocalUploadError
+	if !errors.As(err, &local) {
+		return nil
+	}
+	return append([]string(nil), local.TrackerLocalUploadFailures()...)
+}
+
 type uploadProgressReporterKey struct{}
 
+// WithUploadProgressReporter returns a context carrying reporter; nil reporters leave the context unchanged.
 func WithUploadProgressReporter(ctx context.Context, reporter UploadProgressReporter) context.Context {
 	if ctx == nil {
 		ctx = context.Background()
@@ -32,6 +70,7 @@ func WithUploadProgressReporter(ctx context.Context, reporter UploadProgressRepo
 	return context.WithValue(ctx, uploadProgressReporterKey{}, reporter)
 }
 
+// EmitUploadProgress synchronously invokes the reporter attached to ctx, when present.
 func EmitUploadProgress(ctx context.Context, update UploadProgressUpdate) {
 	if ctx == nil {
 		return
diff --git a/scripts/build.ps1 b/scripts/build.ps1
index f3b5683c..5dfbbc9c 100644
--- a/scripts/build.ps1
+++ b/scripts/build.ps1
@@ -2,44 +2,21 @@ $ErrorActionPreference = "Stop"
 
 $root = Split-Path -Parent $PSScriptRoot
 Set-Location $root
-$wailsCli = "github.com/wailsapp/wails/v2/cmd/wails@v2.12.0"
-
-Write-Host "Building frontend..."
-Push-Location "gui/frontend"
-pnpm install
+Write-Host "Building WebUI..."
+Push-Location "webui"
+pnpm install --frozen-lockfile
 pnpm run build
 Pop-Location
 
-Write-Host "Syncing embedded GUI assets..."
-$assetsPath = Join-Path $root "internal/guiapp/assets"
-New-Item -ItemType Directory -Force -Path $assetsPath | Out-Null
-Get-ChildItem -Path $assetsPath -Force -ErrorAction SilentlyContinue |
-  Where-Object { $_.Name -ne ".keep" } |
-  Remove-Item -Recurse -Force
-Copy-Item "gui/frontend/dist/*" $assetsPath -Recurse -Force
+Write-Host "Syncing embedded WebUI assets..."
+& (Join-Path $PSScriptRoot "sync-webui-assets.ps1")
 
-Write-Host "Building CLI binary..."
+Write-Host "Building upbrr binary..."
 $distPath = Join-Path $root "dist"
 if (-not (Test-Path $distPath)) {
   New-Item -ItemType Directory -Force -Path $distPath | Out-Null
 }
 $cliOut = Join-Path $distPath "upbrr.exe"
 go build -o $cliOut ./cmd/upbrr
-$sourceBin = Join-Path $root "bin"
-if (Test-Path $sourceBin) {
-  Write-Host "Syncing optional bundled tools to CLI output..."
-  $distBin = Join-Path $distPath "bin"
-  if (Test-Path $distBin) {
-    Remove-Item $distBin -Recurse -Force
-  }
-  Copy-Item $sourceBin $distBin -Recurse -Force
-} else {
-  Write-Host "Skipping optional bundled tools: no top-level bin directory found."
-}
-
-Write-Host "Building GUI binary (portable exe)..."
-Push-Location "gui"
-go run $wailsCli build -platform windows/amd64
-Pop-Location
 
-Write-Host "Done. Binaries: dist/upbrr.exe (CLI) and gui/build/bin/upbrr-gui.exe (GUI)"
+Write-Host "Done. Binary: dist/upbrr.exe"
diff --git a/scripts/build.sh b/scripts/build.sh
index 3c0722a0..c57391ed 100755
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -3,35 +3,18 @@ set -euo pipefail
 
 root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$root"
-wails_cli="github.com/wailsapp/wails/v2/cmd/wails@v2.12.0"
-
-echo "Building frontend..."
+echo "Building WebUI..."
 (
-  cd gui/frontend
-  pnpm install
+  cd webui
+  pnpm install --frozen-lockfile
   pnpm run build
 )
 
-echo "Syncing embedded GUI assets..."
-mkdir -p internal/guiapp/assets
-find internal/guiapp/assets -mindepth 1 ! -name '.keep' -exec rm -rf {} +
-cp -R gui/frontend/dist/* internal/guiapp/assets/
+echo "Syncing embedded WebUI assets..."
+sh scripts/sync-webui-assets.sh
 
-echo "Building CLI binary..."
+echo "Building upbrr binary..."
 mkdir -p dist
 GOOS="" GOARCH="" go build -o dist/upbrr ./cmd/upbrr
-if [[ -d bin ]]; then
-  echo "Syncing optional bundled tools to CLI output..."
-  rm -rf dist/bin
-  cp -R bin dist/bin
-else
-  echo "Skipping optional bundled tools: no top-level bin directory found."
-fi
-
-echo "Building GUI binary..."
-(
-  cd gui
-  go run "$wails_cli" build
-)
 
-echo "Done. Binaries: dist/upbrr (CLI) and gui/build/bin/upbrr-gui (GUI)"
+echo "Done. Binary: dist/upbrr"
diff --git a/scripts/sync-frontend-assets.ps1 b/scripts/sync-frontend-assets.ps1
deleted file mode 100644
index da01fbfd..00000000
--- a/scripts/sync-frontend-assets.ps1
+++ /dev/null
@@ -1,10 +0,0 @@
-$ErrorActionPreference = "Stop"
-
-$root = Split-Path -Parent $PSScriptRoot
-$assetsPath = Join-Path $root "internal/guiapp/assets"
-
-New-Item -ItemType Directory -Force -Path $assetsPath | Out-Null
-Get-ChildItem -Path $assetsPath -Force -ErrorAction SilentlyContinue |
-  Where-Object { $_.Name -ne ".keep" } |
-  Remove-Item -Recurse -Force
-Copy-Item (Join-Path $root "gui/frontend/dist/*") $assetsPath -Recurse -Force
diff --git a/scripts/sync-frontend-assets.sh b/scripts/sync-frontend-assets.sh
deleted file mode 100755
index 2776adaf..00000000
--- a/scripts/sync-frontend-assets.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-root="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
-assets_path="$root/internal/guiapp/assets"
-
-mkdir -p "$assets_path"
-find "$assets_path" -mindepth 1 ! -name ".keep" -exec rm -rf {} +
-cp -R "$root/gui/frontend/dist/." "$assets_path/"
diff --git a/scripts/sync-webui-assets.ps1 b/scripts/sync-webui-assets.ps1
new file mode 100644
index 00000000..04128317
--- /dev/null
+++ b/scripts/sync-webui-assets.ps1
@@ -0,0 +1,13 @@
+$ErrorActionPreference = "Stop"
+
+$root = (Resolve-Path (Split-Path -Parent $PSScriptRoot)).Path
+$assetsPath = [System.IO.Path]::GetFullPath((Join-Path $root "internal/webserver/assets"))
+if (-not $assetsPath.StartsWith($root, [System.StringComparison]::OrdinalIgnoreCase)) {
+  throw "Refusing to sync assets outside repository: $assetsPath"
+}
+
+New-Item -ItemType Directory -Force -Path $assetsPath | Out-Null
+Get-ChildItem -Path $assetsPath -Force -ErrorAction SilentlyContinue |
+  Where-Object { $_.Name -ne ".keep" } |
+  Remove-Item -Recurse -Force
+Copy-Item (Join-Path $root "webui/dist/*") $assetsPath -Recurse -Force
diff --git a/scripts/sync-webui-assets.sh b/scripts/sync-webui-assets.sh
new file mode 100644
index 00000000..c39da04b
--- /dev/null
+++ b/scripts/sync-webui-assets.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+set -eu
+
+root="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
+assets_path="$root/internal/webserver/assets"
+
+mkdir -p "$assets_path"
+find "$assets_path" -mindepth 1 ! -name ".keep" -exec rm -rf {} +
+cp -R "$root/webui/dist/." "$assets_path/"
diff --git a/gui/frontend/.prettierignore b/webui/.prettierignore
similarity index 86%
rename from gui/frontend/.prettierignore
rename to webui/.prettierignore
index 5acacd22..dd87ea92 100644
--- a/gui/frontend/.prettierignore
+++ b/webui/.prettierignore
@@ -6,9 +6,6 @@ build/
 # Dependencies
 node_modules/
 
-# Generated
-wailsjs/
-
 # Lockfiles
 pnpm-lock.yaml
 package-lock.json
@@ -18,6 +15,8 @@ yarn.lock
 coverage/
 .cache/
 .eslintcache
+playwright-report/
+test-results/
 
 # Binary / minified
 *.min.js
diff --git a/gui/frontend/.prettierrc.json b/webui/.prettierrc.json
similarity index 100%
rename from gui/frontend/.prettierrc.json
rename to webui/.prettierrc.json
diff --git a/webui/AGENTS.md b/webui/AGENTS.md
new file mode 100644
index 00000000..b254435a
--- /dev/null
+++ b/webui/AGENTS.md
@@ -0,0 +1,81 @@
+# Frontend Guidelines
+
+Scoped rules for `webui`. Root repo rules still apply.
+
+## Source Of Truth
+
+- Scripts and dependencies: `package.json`, `pnpm-lock.yaml`.
+- TypeScript config: `tsconfig*.json`, `vite.config.ts`, `vitest.config.ts`.
+- Lint/format behavior: ESLint, Prettier, Stylelint config files and Lefthook.
+- API/runtime contracts: `pkg/api`, `internal/webserver`, typed clients under `src/api`, release ownership under `src/releaseSession`, and shared Job coordination under `src/jobRegistry`.
+
+## Commands
+
+```bash
+pnpm --dir webui run typecheck
+pnpm --dir webui run test:unit
+pnpm --dir webui run lint
+pnpm --dir webui run lint:style
+pnpm --dir webui run format:check
+pnpm --dir webui run build
+```
+
+## Check Selection
+
+- TS/TSX changes: `pnpm --dir webui run lint`, `lint:dead`, `typecheck`, `test:unit`, and `format:check`.
+- CSS changes: `pnpm --dir webui run lint:style`; also run `format:check`.
+- Browser client/API changes: frontend `test:unit` + `typecheck`, plus backend/API tests from `internal/AGENTS.md` and `pkg/api/AGENTS.md`.
+- Bundle/import/env changes: `pnpm --dir webui run build`.
+- Visual/embedded behavior changes: rebuild/sync embedded assets and inspect `http://localhost:7480`; avoid Vite `5173` for parity.
+
+`make test-frontend` runs lint, dead-code, typecheck, unit, and format checks, but not Stylelint. Run Stylelint explicitly for CSS.
+
+## React / TypeScript
+
+- Keep TypeScript, ESLint, Stylelint, dead-code clean. Do not weaken rules.
+- `useEffect` only for external sync. Avoid derived state in effects; render or `useMemo` instead.
+- User-driven logic belongs in handlers. Fetch effects need cleanup/abort guards.
+- Preserve CLI and WebUI behavior when changing shared request shapes, upload options, or prepared metadata.
+- Match existing component state patterns before adding new abstraction.
+
+## Release Session / Job Ownership
+
+- Release workflow pages consume `useReleaseSession` facets; they do not import production API clients to coordinate release operations directly.
+- `src/releaseSession` owns active release state, operation intents, and preparation/image-upload progress subscriptions. Views render facet state instead of subscribing independently.
+- `src/jobRegistry` owns `jobs:update` transport and duplicate-check/tracker-upload Job coordination. Active release Job access remains behind `useReleaseSession`.
+- Facets expose declarative state and intent methods, not React setters, dispatch functions, or refs.
+- Use structured failure codes/metadata for recovery. Do not infer recovery from error-message text.
+- Consume backend-provided disc resource paths; do not derive BDMV paths from preparation source strings in the frontend.
+
+## Frontend Output / Logging
+
+- Follow root log-level guidance for browser-visible diagnostics and WebUI event logging.
+- Do not expose credentials, tokens, API keys, passkeys, cookies, 2FA codes, challenge IDs, or secret payloads in console output, UI errors, toasts, test failure text, or debug panels.
+- Avoid permanent `console.*` diagnostics. If a diagnostic is intentionally kept, make it dev-scoped, concise, and redacted.
+- User-facing errors should be stable outcomes or next steps; detailed troubleshooting context belongs in developer diagnostics.
+
+## Styling
+
+- Prefer Tailwind utilities for touched local layout/spacing.
+- Keep CSS for shared/theme/cross-cutting selectors or JSX readability.
+- Do not make repo-wide format/style sweeps unless explicitly requested.
+- Text must fit containers across desktop/mobile; do not rely on viewport-width font scaling.
+
+## Embedded Web Checks
+
+- For embedded visual/runtime checks, rebuild frontend, sync embedded assets, rebuild CLI, then serve the embedded app:
+
+```bash
+pnpm --dir webui run build
+pwsh -NoProfile -File .\scripts\sync-webui-assets.ps1
+go build -o .\dist\upbrr.exe .\cmd\upbrr
+.\dist\upbrr.exe serve --dev-no-auth
+```
+
+- Use `http://localhost:7480`.
+- Avoid Vite `5173` for embedded parity checks.
+- Stop local servers after inspection.
+
+## E2E
+
+For Playwright E2E work, read `e2e/AGENTS.md` first. E2E tests must use the embedded web UI, local fake services, isolated temp config/DB, and no real credentials.
diff --git a/webui/CLAUDE.md b/webui/CLAUDE.md
new file mode 120000
index 00000000..47dc3e3d
--- /dev/null
+++ b/webui/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/webui/e2e/AGENTS.md b/webui/e2e/AGENTS.md
new file mode 100644
index 00000000..6e93ca8c
--- /dev/null
+++ b/webui/e2e/AGENTS.md
@@ -0,0 +1,63 @@
+# E2E Guidelines
+
+Scoped rules for Playwright E2E under `webui/e2e`. Root and frontend rules still apply.
+
+## Commands
+
+```bash
+make e2e
+make e2e-web
+make e2e-cli
+pnpm --dir webui run test:e2e:web
+pnpm --dir webui run test:e2e:full
+```
+
+`make e2e` is the preferred full local command. It installs frontend deps, builds the frontend, syncs embedded assets, builds `dist/upbrr-e2e.exe` with the `e2e` tag, and runs all Playwright projects.
+
+If Playwright browsers are missing:
+
+```bash
+pnpm --dir webui exec playwright install chromium
+```
+
+To open the HTML report from repo root:
+
+```bash
+pnpm --dir webui exec playwright show-report
+```
+
+## Projects
+
+- `web-smoke`: embedded server at `http://localhost:7480`, `--dev-no-auth`; nav/settings/invalid-input smoke coverage.
+- `web-base-path-smoke`: embedded server mounted below a configured base path; asset, navigation, API, and event-stream routing coverage.
+- `web-full-upload`: metadata, screenshot/image upload, tracker dry-run, tracker upload, and history through embedded web UI.
+- `cli-full-upload`: full CLI upload path against local fakes and temp config/DB.
+
+## Harness Rules
+
+- Web UI E2E uses the embedded app as source of truth, not Vite.
+- Use isolated temp workspace per test: config YAML, SQLite DB, media/torrent/screenshot fixtures.
+- Use local fake tracker/image-host/torrent/metadata services only.
+- No real tracker, image host, torrent client, TMDB, or credentials in E2E.
+- Service seams must be test-only or config/test fixture driven; production defaults stay unchanged.
+- Process manager must clean up `dist/upbrr-e2e.exe serve --config <temp>\config.yaml --dev-no-auth`.
+
+## Generated Artifacts
+
+Ignored local outputs:
+
+- `webui/playwright-report/`
+- `webui/test-results/`
+
+Do not commit Playwright traces, videos, screenshots, reports, temp DBs, or `dist/upbrr-e2e.exe`.
+
+## CI
+
+Manual workflow only:
+
+- `.github/workflows/e2e.yml`
+- `workflow_dispatch`
+- Builds frontend + embedded assets + CLI.
+- Installs Playwright Chromium.
+- Runs `make e2e`.
+- Uploads report/traces on failure.
diff --git a/webui/e2e/CLAUDE.md b/webui/e2e/CLAUDE.md
new file mode 120000
index 00000000..47dc3e3d
--- /dev/null
+++ b/webui/e2e/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/gui/frontend/e2e/cli-full-upload.spec.ts b/webui/e2e/cli-full-upload.spec.ts
similarity index 96%
rename from gui/frontend/e2e/cli-full-upload.spec.ts
rename to webui/e2e/cli-full-upload.spec.ts
index 350c0201..5a1d1d43 100644
--- a/gui/frontend/e2e/cli-full-upload.spec.ts
+++ b/webui/e2e/cli-full-upload.spec.ts
@@ -23,6 +23,7 @@ test("CLI full upload uses local fake services and records an upload", async ()
     expect(result.code, result.output).toBe(0);
     expect(result.output).toMatch(/uploaded|complete|Upload/i);
     expect(workspace.fake.counters.trackerUploads).toBe(1);
+    expect(workspace.fake.counters.clientSearches).toBe(1);
   } finally {
     await workspace.cleanup();
   }
diff --git a/gui/frontend/e2e/helpers/e2eHarness.ts b/webui/e2e/helpers/e2eHarness.ts
similarity index 83%
rename from gui/frontend/e2e/helpers/e2eHarness.ts
rename to webui/e2e/helpers/e2eHarness.ts
index c742b399..15e4cd0b 100644
--- a/gui/frontend/e2e/helpers/e2eHarness.ts
+++ b/webui/e2e/helpers/e2eHarness.ts
@@ -10,7 +10,7 @@ import { fileURLToPath } from "node:url";
 import { expect, type Page } from "@playwright/test";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-export const repoRoot = path.resolve(here, "../../../..");
+export const repoRoot = path.resolve(here, "../../..");
 export const e2eBinary = path.join(
   repoRoot,
   "dist",
@@ -28,6 +28,8 @@ const startAppBindAttempts = 5;
 type FakeCounters = {
   trackerUploads: number;
   imageUploads: number;
+  clientSearches: number;
+  clientInjections: number;
 };
 
 type FakeServer = {
@@ -75,6 +77,7 @@ export async function createE2EWorkspace(): Promise<E2EWorkspace> {
     UPBRR_E2E_FAKE_SERVICES: "1",
     UPBRR_E2E_TRACKER_URL: fake.url,
     UPBRR_E2E_IMAGE_URL: fake.url,
+    UPBRR_E2E_CLIENT_URL: fake.url,
     UPBRR_E2E_SCREENSHOT_PATH: screenshotPath,
   };
   return {
@@ -92,6 +95,34 @@ export async function createE2EWorkspace(): Promise<E2EWorkspace> {
   };
 }
 
+/** Adds a minimal parseable BDMV source without invoking any external disc tool. */
+export async function createBluraySourceFixture(workspace: E2EWorkspace): Promise<string> {
+  const discRoot = path.join(workspace.root, "media", "Example Disc");
+  const bdmvRoot = path.join(discRoot, "BDMV");
+  const playlistDir = path.join(bdmvRoot, "PLAYLIST");
+  const streamDir = path.join(bdmvRoot, "STREAM");
+  await mkdir(playlistDir, { recursive: true });
+  await mkdir(streamDir, { recursive: true });
+
+  const playlist = Buffer.alloc(64);
+  playlist.write("MPLS", 0, "ascii");
+  playlist.write("0200", 4, "ascii");
+  playlist.writeUInt32BE(32, 8);
+  playlist.writeUInt32BE(64, 12);
+  playlist.writeUInt32BE(0, 16);
+  playlist.writeUInt32BE(30, 32);
+  playlist.writeUInt16BE(1, 38);
+  playlist.writeUInt16BE(0, 40);
+  playlist.writeUInt16BE(20, 42);
+  playlist.write("00001", 44, "ascii");
+  playlist.write("M2TS", 49, "ascii");
+  playlist.writeUInt32BE(0, 56);
+  playlist.writeUInt32BE(45_000 * 120, 60);
+  await writeFile(path.join(playlistDir, "00001.mpls"), playlist);
+  await writeFile(path.join(streamDir, "00001.m2ts"), "synthetic Blu-ray stream\n");
+  return discRoot;
+}
+
 /**
  * Starts the embedded web server for a workspace and waits for auth status at
  * the configured base path before returning its browser URL. Startup retries
@@ -209,7 +240,7 @@ image_hosting:
   img_host_1: "imgbb"
   imgbb_api: "e2e"
 metadata:
-  skip_auto_torrent: true
+  skip_auto_torrent: false
   keep_images: true
 screenshot_handling:
   screens: 1
@@ -223,19 +254,49 @@ logging:
 trackers:
   default_trackers: ["BTN"]
   preferred_tracker: "BTN"
+  AITHER:
+    api_key: "e2e"
+    image_host: "imgbb"
+  ANT:
+    api_key: "e2e"
+    image_host: "imgbb"
+  FF:
+    username: "e2e"
+    password: "e2e"
+  HDS:
+    announce_url: "http://tracker.invalid/announce"
+    image_host: "imgbb"
   BTN:
     api_key: "e2e"
     username: "e2e"
     password: "e2e"
     url: "http://127.0.0.1"
     image_host: "imgbb"
+  OLD:
+    api_key: "preserved"
+    url: "http://retired.invalid"
 torrent_clients: {}
 `;
 }
 
 async function startFakeServer(): Promise<FakeServer> {
-  const counters: FakeCounters = { trackerUploads: 0, imageUploads: 0 };
+  const counters: FakeCounters = {
+    trackerUploads: 0,
+    imageUploads: 0,
+    clientSearches: 0,
+    clientInjections: 0,
+  };
   const server = createServer(async (req, res) => {
+    if (req.method === "POST" && req.url === "/client-search") {
+      counters.clientSearches++;
+      writeJSON(res, 200, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && req.url === "/client-inject") {
+      counters.clientInjections++;
+      writeJSON(res, 200, { ok: true });
+      return;
+    }
     if (req.method === "POST" && req.url === "/upload") {
       const body = await readBody(req);
       if (body.includes(Buffer.from('name="tracker"'))) {
diff --git a/gui/frontend/e2e/web-base-path-smoke.spec.ts b/webui/e2e/web-base-path-smoke.spec.ts
similarity index 81%
rename from gui/frontend/e2e/web-base-path-smoke.spec.ts
rename to webui/e2e/web-base-path-smoke.spec.ts
index b795a85f..e46d97dc 100644
--- a/gui/frontend/e2e/web-base-path-smoke.spec.ts
+++ b/webui/e2e/web-base-path-smoke.spec.ts
@@ -31,10 +31,15 @@ test("embedded web serves UI, API, assets, manifest, and events under a base pat
     await expect(page.getByRole("heading", { name: "Build Release Name" })).toBeVisible();
     await eventRequest;
 
-    const defaultConfig = await page.evaluate(() =>
-      (globalThis as any).go.guiapp.App.GetDefaultConfig(),
-    );
-    expect(defaultConfig).toBeTruthy();
+    const apiAuthStatus = await request.get(`${origin}/upbrr/api/auth/status`);
+    expect(apiAuthStatus.ok()).toBe(true);
+    const { csrfToken } = (await apiAuthStatus.json()) as { csrfToken: string };
+    const defaultConfig = await request.post(`${origin}/upbrr/api/app/GetDefaultConfig`, {
+      data: {},
+      headers: { Origin: origin, "X-CSRF-Token": csrfToken },
+    });
+    expect(defaultConfig.ok()).toBe(true);
+    expect(await defaultConfig.json()).toBeTruthy();
 
     const manifest = await request.get(`${origin}/upbrr/site.webmanifest`);
     expect(manifest.ok()).toBe(true);
diff --git a/webui/e2e/web-full-upload.spec.ts b/webui/e2e/web-full-upload.spec.ts
new file mode 100644
index 00000000..4daa6ce6
--- /dev/null
+++ b/webui/e2e/web-full-upload.spec.ts
@@ -0,0 +1,226 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { expect, test, type Locator } from "@playwright/test";
+import {
+  createBluraySourceFixture,
+  createE2EWorkspace,
+  fetchMetadata,
+  startApp,
+  type AppServer,
+} from "./helpers/e2eHarness";
+
+const expectEnabledState = async (locator: Locator, enabled: boolean) => {
+  if (enabled) {
+    await expect(locator).toBeEnabled();
+    return;
+  }
+  await expect(locator).toBeDisabled();
+};
+
+for (const scenario of [
+  {
+    name: "none trackers bypass shared content pages",
+    trackers: ["BTN"],
+    screenshots: false,
+    descriptions: false,
+    upload: true,
+  },
+  {
+    name: "screenshot trackers expose image pages without requiring descriptions",
+    trackers: ["ANT"],
+    screenshots: true,
+    descriptions: false,
+    upload: true,
+  },
+  {
+    name: "mixed trackers expose the strictest shared content workflow",
+    trackers: ["BTN", "ANT", "AITHER"],
+    screenshots: true,
+    descriptions: true,
+    upload: false,
+  },
+] as const) {
+  test(`embedded web ${scenario.name}`, async ({ page }) => {
+    const workspace = await createE2EWorkspace();
+    let app: AppServer | undefined;
+    try {
+      app = await startApp(workspace);
+      await fetchMetadata(page, app.url, workspace.sourcePath);
+      await page.getByRole("button", { name: "Dupe Check" }).click();
+      for (const tracker of scenario.trackers) {
+        await page.getByRole("checkbox", { name: tracker }).check();
+      }
+      await page.getByRole("button", { name: "Run dupe check" }).click();
+      await expect(page.getByRole("button", { name: "Run dupe check" })).toBeEnabled();
+
+      await expectEnabledState(
+        page.getByRole("button", { name: "Screenshots" }),
+        scenario.screenshots,
+      );
+      await expectEnabledState(
+        page.getByRole("button", { name: "Upload Images" }),
+        scenario.screenshots,
+      );
+      await expectEnabledState(
+        page.getByRole("button", { name: "Descriptions" }),
+        scenario.descriptions,
+      );
+      await expectEnabledState(
+        page.getByRole("button", { name: "Upload", exact: true }),
+        scenario.upload,
+      );
+      await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+    } finally {
+      await app?.stop();
+      await workspace.cleanup();
+    }
+  });
+}
+
+test("embedded web runs image upload, tracker dry run, tracker upload, and history", async ({
+  page,
+}) => {
+  const workspace = await createE2EWorkspace();
+  let app: AppServer | undefined;
+  try {
+    app = await startApp(workspace);
+    await fetchMetadata(page, app.url, workspace.sourcePath);
+    await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+    await page.getByRole("button", { name: "Dupe Check" }).click();
+    await expect(
+      page.getByText("Select at least one tracker to run duplicate checking."),
+    ).toBeVisible();
+    await page.getByRole("checkbox", { name: "FF" }).check();
+    await page.getByRole("button", { name: "Run dupe check" }).click();
+    await expect(page.getByText("FF").first()).toBeVisible();
+    await expect(page.getByRole("button", { name: "Run dupe check" })).toBeEnabled();
+    await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+
+    await page.getByRole("button", { name: "Screenshots" }).click();
+    const saveFinalResponse = page.waitForResponse((response) =>
+      response.url().includes("/api/app/SaveFinalScreenshotSelections"),
+    );
+    await page.getByRole("button", { name: "Generate screenshots" }).click();
+    await expect((await saveFinalResponse).ok()).toBe(true);
+    await expect(page.getByRole("button", { name: "Screenshot 1" })).toBeVisible();
+    await page.getByRole("button", { name: "Upload Images" }).click();
+    await expect(page.getByText("1 found")).toBeVisible();
+    await page.getByRole("combobox", { name: "Image host" }).selectOption("imgbb");
+    await page.getByRole("button", { name: "Upload selected (1)" }).click();
+    await expect.poll(() => workspace.fake.counters.imageUploads).toBe(1);
+    await expect(page.getByRole("link", { name: /\/image\/1$/ }).first()).toHaveAttribute(
+      "href",
+      /\/image\/1$/,
+    );
+
+    await page.getByRole("button", { name: "Descriptions" }).click();
+    await page.getByRole("button", { name: "Refresh descriptions" }).click();
+    await page.getByRole("button", { name: "Expand" }).click();
+    await expect(page.locator("textarea").first()).toHaveValue(/E2E description fixture\./);
+
+    await page.getByRole("button", { name: "Upload", exact: true }).click();
+    await expect(page.getByRole("heading", { name: "Review & Upload" })).toBeVisible();
+    await page.getByLabel("Log level").selectOption("debug");
+    await page.getByRole("button", { name: "Run dry run" }).click();
+    await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+    await expect.poll(() => workspace.fake.counters.clientInjections).toBe(1);
+    expect(workspace.fake.counters.trackerUploads).toBe(0);
+    const reviewButton = page.getByRole("button", { name: "Review upload" });
+    await expect(reviewButton).toBeEnabled();
+    await expect(page.getByRole("heading", { name: "FF" })).toBeVisible();
+    await expect(page.getByText("E2E.Movie.2026.1080p.WEB-DL").first()).toBeVisible();
+
+    await reviewButton.click();
+    await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+    const startButton = page.getByRole("button", { name: "Start upload" });
+    await expect(startButton).toBeEnabled();
+    await startButton.click();
+    await expect.poll(() => workspace.fake.counters.trackerUploads).toBe(1);
+    await expect(page.getByText(/Uploaded 1/)).toBeVisible();
+
+    await page.getByRole("button", { name: "History" }).click();
+    await expect(page.getByText("E2E.Movie.2026.1080p.WEB-DL").first()).toBeVisible();
+    await expect(page.getByText("FF").first()).toBeVisible();
+  } finally {
+    await app?.stop();
+    await workspace.cleanup();
+  }
+});
+
+test("embedded web keeps strict rules and dupes diagnostic during dry run", async ({ page }) => {
+  const workspace = await createE2EWorkspace();
+  workspace.env.UPBRR_E2E_RESOLUTION = "576p";
+  workspace.env.UPBRR_E2E_DUPLICATE_TRACKERS = "HDS";
+  let app: AppServer | undefined;
+  try {
+    app = await startApp(workspace);
+    await fetchMetadata(page, app.url, workspace.sourcePath);
+    await page.getByRole("button", { name: "Dupe Check" }).click();
+    await page.getByRole("checkbox", { name: "HDS" }).check();
+    await page.getByRole("button", { name: "Run dupe check" }).click();
+    await expect(page.getByText("Example.Release.2026.1080p-GRP")).toBeVisible();
+    await page.getByLabel("Ignore dupes for HDS").check();
+
+    await page.getByRole("button", { name: "Screenshots" }).click();
+    await page.getByRole("button", { name: "Generate screenshots" }).click();
+    await expect(page.getByRole("button", { name: "Screenshot 1" })).toBeVisible();
+    await page.getByRole("button", { name: "Upload Images" }).click();
+    await expect(page.getByText("1 found")).toBeVisible();
+    await page.getByRole("combobox", { name: "Image host" }).selectOption("imgbb");
+    await page.getByRole("button", { name: "Upload selected (1)" }).click();
+    await page.getByRole("button", { name: "Descriptions" }).click();
+    await page.getByRole("button", { name: "Refresh descriptions" }).click();
+
+    await page.getByRole("button", { name: "Upload", exact: true }).click();
+    await page.getByRole("button", { name: "Run dry run" }).click();
+    await expect(page.getByText(/min_resolution.*strict|strict.*min_resolution/)).toBeVisible();
+    await expect(page.getByText("Duplicate diagnostics")).toBeVisible();
+    await expect(page.getByText("Example.Release.2026.1080p-GRP")).toBeVisible();
+    await expect(page.getByLabel("Authorize min_resolution for HDS")).toHaveCount(0);
+    await expect.poll(() => workspace.fake.counters.clientInjections).toBe(1);
+    expect(workspace.fake.counters.trackerUploads).toBe(0);
+
+    await page.getByLabel("Skip client injection").check();
+    await page.getByRole("button", { name: "Run dry run" }).click();
+    await expect.poll(() => workspace.fake.counters.clientInjections).toBe(1);
+    expect(workspace.fake.counters.trackerUploads).toBe(0);
+
+    await page.getByRole("button", { name: "Review upload" }).click();
+    await expect(page.getByRole("alert")).toContainText(/eligible|rule/i);
+    await expect(page.getByRole("button", { name: "Start upload" })).toBeDisabled();
+    expect(workspace.fake.counters.trackerUploads).toBe(0);
+  } finally {
+    await app?.stop();
+    await workspace.cleanup();
+  }
+});
+
+test("embedded web tracks BDMV playlist preparation and opens duplicate checking", async ({
+  page,
+}) => {
+  const workspace = await createE2EWorkspace();
+  let app: AppServer | undefined;
+  try {
+    const sourcePath = await createBluraySourceFixture(workspace);
+    app = await startApp(workspace);
+    await page.goto(app.url);
+    await page.getByLabel("Source path").fill(sourcePath);
+    await page.getByRole("button", { name: "Fetch metadata" }).click();
+
+    await expect(page.getByRole("heading", { name: "Select BDMV Playlists" })).toBeVisible();
+    await expect(page.getByText("Discover Blu-ray playlists")).toBeVisible();
+    await page.getByRole("checkbox", { name: "00001.mpls" }).check();
+    await page.getByRole("button", { name: "Confirm Selection" }).click();
+
+    await expect(page.getByText("E2E.Movie.2026.1080p.WEB-DL")).toBeVisible();
+    await expect(page.getByText("Blu-ray analysis complete.")).toHaveCount(0);
+    await page.getByRole("button", { name: "Dupe Check" }).click();
+    await page.getByRole("checkbox", { name: "AITHER" }).check();
+    await page.getByRole("button", { name: "Run dupe check" }).click();
+    await expect.poll(() => workspace.fake.counters.clientSearches).toBe(1);
+  } finally {
+    await app?.stop();
+    await workspace.cleanup();
+  }
+});
diff --git a/webui/e2e/web-smoke.spec.ts b/webui/e2e/web-smoke.spec.ts
new file mode 100644
index 00000000..1792c055
--- /dev/null
+++ b/webui/e2e/web-smoke.spec.ts
@@ -0,0 +1,102 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { expect, test } from "@playwright/test";
+import { createE2EWorkspace, startApp, type AppServer } from "./helpers/e2eHarness";
+
+test("embedded web boots with dev auth, navigates core pages, and reports invalid paths", async ({
+  page,
+}) => {
+  const workspace = await createE2EWorkspace();
+  let app: AppServer | undefined;
+  try {
+    app = await startApp(workspace);
+    await page.goto(app.url);
+    await expect(page.getByRole("heading", { name: "Build Release Name" })).toBeVisible();
+
+    await page.getByRole("button", { name: "Settings" }).click();
+    await expect(page.getByRole("heading", { name: "Settings" })).toBeVisible();
+    await page.getByRole("button", { name: "Reload" }).click();
+    await expect(page.getByText("Configuration")).toBeVisible();
+
+    await page.getByRole("button", { name: "Logging" }).click();
+    await expect(page.getByRole("heading", { name: "Logging" })).toBeVisible();
+
+    await page.getByRole("button", { name: "History" }).click();
+    await expect(page.getByRole("heading", { name: "History" })).toBeVisible();
+
+    await page.getByRole("button", { name: "Input" }).click();
+    await page.getByLabel("Source path").fill("Z:\\missing\\e2e.mkv");
+    await page.getByRole("button", { name: "Fetch metadata" }).click();
+    const error = page.locator(".error");
+    await expect(error).toContainText("The source path is unavailable.");
+    await expect(error).toContainText("Recovery: edit input.");
+    await expect(error).not.toContainText("Z:\\missing\\e2e.mkv");
+  } finally {
+    await app?.stop();
+    await workspace.cleanup();
+  }
+});
+
+test("embedded tracker settings use the catalog for entries, reset, and unsupported config", async ({
+  page,
+}) => {
+  const workspace = await createE2EWorkspace();
+  let app: AppServer | undefined;
+  try {
+    app = await startApp(workspace);
+    await page.goto(app.url);
+    await page.getByRole("button", { name: "Settings" }).click();
+    await page.getByRole("button", { name: "Trackers", exact: true }).click();
+
+    await expect(
+      page.getByText("BTN", { exact: true }).filter({ visible: true }).first(),
+    ).toBeVisible();
+    await expect(page.getByText("Unsupported tracker entries")).toBeVisible();
+    await expect(page.getByText("OLD", { exact: true })).toBeVisible();
+
+    const entryControls = page.locator(".settings-map__header .settings-map__controls");
+    const trackerSelector = entryControls.locator("select");
+    await expect(trackerSelector.locator('option[value="OLD"]')).toHaveCount(0);
+    await trackerSelector.selectOption("BLU");
+    await entryControls.getByRole("button", { name: "Add entry" }).click();
+
+    let bluCard = page
+      .locator("details.settings-card")
+      .filter({ has: page.locator("summary", { hasText: "BLU" }) });
+    await expect(bluCard).toBeVisible();
+    await expect(
+      bluCard.locator("label.settings-field > span, .settings-switch-row > span"),
+    ).toHaveText(["API key", "Anonymous", "Image host"]);
+    await bluCard.getByLabel("API key").fill("e2e-blu-activation");
+
+    await page.getByRole("button", { name: "Save", exact: true }).click();
+    await expect(page.getByText("Settings saved and applied.")).toBeVisible();
+    await page.getByRole("button", { name: "Reload", exact: true }).click();
+
+    bluCard = page
+      .locator("details.settings-card")
+      .filter({ has: page.locator("summary", { hasText: "BLU" }) });
+    await expect(bluCard).toBeVisible();
+    await bluCard.getByRole("button", { name: "Remove" }).click();
+    await expect(bluCard).toHaveCount(0);
+    await expect(trackerSelector.locator('option[value="BLU"]')).toHaveCount(1);
+
+    await page.getByRole("button", { name: "Save", exact: true }).click();
+    await page.getByRole("button", { name: "Reload", exact: true }).click();
+    await expect(
+      page.locator("details.settings-card").filter({
+        has: page.locator("summary", { hasText: "BLU" }),
+      }),
+    ).toHaveCount(0);
+
+    const unsupportedCard = page
+      .locator(".settings-card")
+      .filter({ has: page.locator(".settings-card__summary-name", { hasText: "OLD" }) });
+    await unsupportedCard.getByRole("button", { name: "Delete" }).click();
+    await expect(page.getByText("OLD", { exact: true })).toHaveCount(0);
+  } finally {
+    await app?.stop();
+    await workspace.cleanup();
+  }
+});
diff --git a/gui/frontend/eslint.config.js b/webui/eslint.config.js
similarity index 97%
rename from gui/frontend/eslint.config.js
rename to webui/eslint.config.js
index a8f139d3..afc5ccd1 100644
--- a/gui/frontend/eslint.config.js
+++ b/webui/eslint.config.js
@@ -6,7 +6,7 @@ import prettier from "eslint-config-prettier";
 
 export default [
   {
-    ignores: ["dist/**", "node_modules/**", "wailsjs/**"],
+    ignores: ["dist/**", "node_modules/**"],
   },
   {
     files: ["src/**/*.{ts,tsx}"],
diff --git a/gui/frontend/index.html b/webui/index.html
similarity index 100%
rename from gui/frontend/index.html
rename to webui/index.html
diff --git a/gui/frontend/knip.ts b/webui/knip.ts
similarity index 100%
rename from gui/frontend/knip.ts
rename to webui/knip.ts
diff --git a/webui/package.json b/webui/package.json
new file mode 100644
index 00000000..fd08438d
--- /dev/null
+++ b/webui/package.json
@@ -0,0 +1,65 @@
+{
+  "name": "upbrr-webui",
+  "private": true,
+  "version": "0.1.0",
+  "packageManager": "pnpm@10.27.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "build:bundle": "vite build",
+    "preview": "vite preview",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:e2e:web": "playwright test --project=web-smoke --project=web-base-path-smoke --project=web-full-upload",
+    "test:e2e:full": "playwright test",
+    "lint": "eslint --cache \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint --cache --fix src --ext .ts,.tsx",
+    "lint:style": "stylelint \"src/**/*.css\"",
+    "lint:style:fix": "stylelint \"src/**/*.css\" --fix",
+    "lint:dead": "knip --include files,exports,dependencies --no-config-hints",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write --cache .",
+    "format:check": "prettier --check --cache ."
+  },
+  "dependencies": {
+    "@radix-ui/react-alert-dialog": "^1.1.15",
+    "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-switch": "^1.2.6",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/parser": "^8.58.2",
+    "@vitejs/plugin-react": "^6.0.2",
+    "autoprefixer": "^10.5.0",
+    "eslint": "^10.2.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "happy-dom": "^20.9.0",
+    "knip": "^6.4.1",
+    "postcss": "^8.5.15",
+    "prettier": "^3.8.2",
+    "stylelint": "^16.26.1",
+    "stylelint-config-recommended": "^17.0.0",
+    "tailwindcss": "^3.4.19",
+    "typescript": "^5.6.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}
diff --git a/gui/frontend/playwright.config.ts b/webui/playwright.config.ts
similarity index 92%
rename from gui/frontend/playwright.config.ts
rename to webui/playwright.config.ts
index 0f98e54f..34619503 100644
--- a/gui/frontend/playwright.config.ts
+++ b/webui/playwright.config.ts
@@ -38,9 +38,5 @@ export default defineConfig({
       name: "cli-full-upload",
       testMatch: /cli-full-upload\.spec\.ts/,
     },
-    {
-      name: "wails-basic",
-      testMatch: /wails-basic\.spec\.ts/,
-    },
   ],
 });
diff --git a/gui/frontend/pnpm-lock.yaml b/webui/pnpm-lock.yaml
similarity index 100%
rename from gui/frontend/pnpm-lock.yaml
rename to webui/pnpm-lock.yaml
diff --git a/gui/frontend/postcss.config.js b/webui/postcss.config.js
similarity index 100%
rename from gui/frontend/postcss.config.js
rename to webui/postcss.config.js
diff --git a/gui/frontend/public/apple-touch-icon.png b/webui/public/apple-touch-icon.png
similarity index 100%
rename from gui/frontend/public/apple-touch-icon.png
rename to webui/public/apple-touch-icon.png
diff --git a/gui/frontend/public/favicon-16x16.png b/webui/public/favicon-16x16.png
similarity index 100%
rename from gui/frontend/public/favicon-16x16.png
rename to webui/public/favicon-16x16.png
diff --git a/gui/frontend/public/favicon-32x32.png b/webui/public/favicon-32x32.png
similarity index 100%
rename from gui/frontend/public/favicon-32x32.png
rename to webui/public/favicon-32x32.png
diff --git a/gui/frontend/public/favicon.ico b/webui/public/favicon.ico
similarity index 100%
rename from gui/frontend/public/favicon.ico
rename to webui/public/favicon.ico
diff --git a/gui/frontend/public/icon-192.png b/webui/public/icon-192.png
similarity index 100%
rename from gui/frontend/public/icon-192.png
rename to webui/public/icon-192.png
diff --git a/gui/frontend/public/icon-512.png b/webui/public/icon-512.png
similarity index 100%
rename from gui/frontend/public/icon-512.png
rename to webui/public/icon-512.png
diff --git a/gui/frontend/public/site.webmanifest b/webui/public/site.webmanifest
similarity index 100%
rename from gui/frontend/public/site.webmanifest
rename to webui/public/site.webmanifest
diff --git a/webui/src/api/app.ts b/webui/src/api/app.ts
new file mode 100644
index 00000000..16de0b19
--- /dev/null
+++ b/webui/src/api/app.ts
@@ -0,0 +1,516 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  ApplicationInfo,
+  BrowseDirectoryResponse,
+  DescriptionBuilderPreview,
+  DVDMenuCaptureResult,
+  DupeCheckSnapshot,
+  ExternalIDOverrides,
+  HistoryEntry,
+  HistoryOverview,
+  ImageHostPolicyMetadata,
+  MetadataPreview,
+  OwnerJobSnapshot,
+  PlaylistInfo,
+  PlaylistInstruction,
+  PreparationPreview,
+  PrepareInput,
+  PrepareResult,
+  ReleaseNameOverrides,
+  ReleaseRef,
+  ScreenshotImage,
+  ScreenshotPlan,
+  ScreenshotPurpose,
+  ScreenshotResult,
+  ScreenshotSelection,
+  TrackerAuthCapability,
+  TrackerAuthLoginRequest,
+  TrackerAuthStatus,
+  TrackerCatalog,
+  TrackerDryRunPreview,
+  RuleAuthorization,
+  TrackerUploadSnapshot,
+  UploadedImageLink,
+  UploadImagesResult,
+  UploadReviewResult,
+} from "../types";
+import { requestApp } from "./client";
+
+type LogEntry = {
+  ID: number;
+  Time: string;
+  Level: string;
+  Message: string;
+};
+
+type ConfigImportResult = { message: string; warnings: string[] };
+
+const maxCookieImportContentBytes = 1024 * 1024;
+const encodedTextByteLength = (value: string) => new TextEncoder().encode(value).length;
+
+const selectTextFile = (accept: string) =>
+  new Promise<{ name: string; content: string }>((resolve, reject) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = accept;
+    input.onchange = () => {
+      const file = input.files?.[0];
+      if (!file) {
+        resolve({ name: "", content: "" });
+        return;
+      }
+      const reader = new FileReader();
+      reader.onload = () => resolve({ name: file.name, content: reader.result as string });
+      reader.onerror = () => reject(reader.error);
+      reader.readAsText(file);
+    };
+    input.addEventListener("cancel", () => resolve({ name: "", content: "" }));
+    input.click();
+  });
+
+/** Host filesystem browsing exposed through the authenticated WebUI route. */
+export const hostBrowser = {
+  list: (path: string, mode: "file" | "folder") =>
+    requestApp<BrowseDirectoryResponse>("BrowseDirectory", { path, mode }),
+};
+
+/** Application build and runtime capability information. */
+export const applicationClient = {
+  getInfo: () => requestApp<ApplicationInfo>("GetApplicationInfo"),
+};
+
+/** Canonical release preparation and metadata preview operations. */
+export const preparationClient = {
+  detectDiscType: (path: string, signal?: AbortSignal) =>
+    requestApp<string>("DetectDiscType", { Path: path }, { signal }),
+  fetchMetadata: (
+    correlationID: string,
+    path: string,
+    sourceLookupURL: string,
+    overrides: ExternalIDOverrides,
+    nameOverrides: ReleaseNameOverrides,
+    playlist: PlaylistInstruction,
+    confirmBDMVRescan: boolean,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<MetadataPreview>(
+      "FetchMetadata",
+      {
+        CorrelationID: correlationID,
+        Path: path,
+        SourceLookupURL: sourceLookupURL,
+        Overrides: overrides,
+        NameOverrides: nameOverrides,
+        Playlist: playlist,
+        ConfirmBDMVRescan: confirmBDMVRescan,
+      },
+      { signal },
+    ),
+  prepareRelease: (input: PrepareInput) =>
+    requestApp<PrepareResult>("PrepareRelease", { Input: input }),
+  resetMetadata: (
+    correlationID: string,
+    path: string,
+    sourceLookupURL: string,
+    overrides: ExternalIDOverrides,
+    nameOverrides: ReleaseNameOverrides,
+    playlist: PlaylistInstruction,
+    confirmBDMVRescan: boolean,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<MetadataPreview>(
+      "ResetMetadata",
+      {
+        CorrelationID: correlationID,
+        Path: path,
+        SourceLookupURL: sourceLookupURL,
+        Overrides: overrides,
+        NameOverrides: nameOverrides,
+        Playlist: playlist,
+        ConfirmBDMVRescan: confirmBDMVRescan,
+      },
+      { signal },
+    ),
+  selectBlurayCandidate: (
+    correlationID: string,
+    path: string,
+    releaseID: string,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<MetadataPreview>(
+      "SelectBlurayCandidate",
+      { CorrelationID: correlationID, Path: path, ReleaseID: releaseID },
+      { signal },
+    ),
+  fetchDescriptionBuilder: (release: ReleaseRef, trackers: string[], signal?: AbortSignal) =>
+    requestApp<DescriptionBuilderPreview>(
+      "FetchDescriptionBuilder",
+      {
+        Release: release,
+        Trackers: trackers,
+      },
+      { signal },
+    ),
+  fetchPreparation: (
+    path: string,
+    overrides: ExternalIDOverrides,
+    nameOverrides: ReleaseNameOverrides,
+    trackers: string[],
+    ignoreDupesFor: string[],
+  ) =>
+    requestApp<PreparationPreview>("FetchPreparation", {
+      Path: path,
+      Overrides: overrides,
+      NameOverrides: nameOverrides,
+      Trackers: trackers,
+      IgnoreDupesFor: ignoreDupesFor,
+    }),
+  fetchTrackerDryRun: (
+    dupeJobID: string,
+    release: ReleaseRef,
+    trackers: string[],
+    ignoreDupesFor: string[],
+    questionnaireAnswers: Record<string, Record<string, string>>,
+    descriptionGroups: DescriptionBuilderPreview["Groups"],
+    noSeed: boolean,
+    runLogLevel: string,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<TrackerDryRunPreview>(
+      "FetchTrackerDryRun",
+      {
+        DupeJobID: dupeJobID,
+        Release: release,
+        Trackers: trackers,
+        IgnoreDupesFor: ignoreDupesFor,
+        QuestionnaireAnswers: questionnaireAnswers,
+        DescriptionGroups: descriptionGroups,
+        NoSeed: noSeed,
+        RunLogLevel: runLogLevel,
+      },
+      { signal },
+    ),
+};
+
+/** BDMV playlist discovery for one selected preparation source. */
+export const playlistClient = {
+  discover: (path: string, signal?: AbortSignal) =>
+    requestApp<PlaylistInfo[]>("DiscoverPlaylists", { Path: path }, { signal }),
+};
+
+/** Session-owned duplicate-check jobs. */
+export const dupeClient = {
+  start: (release: ReleaseRef, trackers: string[], correlationID: string) =>
+    requestApp<string>("StartDupeCheck", {
+      Release: release,
+      Trackers: trackers,
+      CorrelationID: correlationID,
+    }),
+  cancel: (jobID: string) => requestApp<void>("CancelDupeCheck", { JobID: jobID }),
+  getSnapshot: (jobID: string) =>
+    requestApp<DupeCheckSnapshot>("GetDupeCheckSnapshot", { JobID: jobID }),
+};
+
+/** Screenshot planning, rendering, selection, and removal operations. */
+export const screenshotClient = {
+  fetchPlan: (release: ReleaseRef, signal?: AbortSignal) =>
+    requestApp<ScreenshotPlan>("FetchScreenshotPlan", { Release: release }, { signal }),
+  generate: (
+    release: ReleaseRef,
+    selections: ScreenshotSelection[],
+    purpose: ScreenshotPurpose,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<ScreenshotResult>(
+      "GenerateScreenshots",
+      {
+        Release: release,
+        Selections: selections,
+        Purpose: purpose,
+      },
+      { signal },
+    ),
+  previewFrame: (release: ReleaseRef, timestampSeconds: number, signal?: AbortSignal) =>
+    requestApp<string>(
+      "PreviewScreenshotFrame",
+      {
+        Release: release,
+        TimestampSeconds: timestampSeconds,
+      },
+      { signal },
+    ),
+  remove: (release: ReleaseRef, imagePath: string, signal?: AbortSignal) =>
+    requestApp<void>(
+      "DeleteScreenshot",
+      {
+        Release: release,
+        ImagePath: imagePath,
+      },
+      { signal },
+    ),
+  saveFinalSelections: (release: ReleaseRef, images: ScreenshotImage[], signal?: AbortSignal) =>
+    requestApp<void>(
+      "SaveFinalScreenshotSelections",
+      {
+        Release: release,
+        Images: images,
+      },
+      { signal },
+    ),
+  readImage: (path: string, signal?: AbortSignal) =>
+    requestApp<string>("ReadScreenshotImage", { Path: path }, { signal }),
+  deleteTrackerImageURL: (release: ReleaseRef, url: string, signal?: AbortSignal) =>
+    requestApp<void>(
+      "DeleteTrackerImageURL",
+      {
+        Release: release,
+        URL: url,
+      },
+      { signal },
+    ),
+};
+
+/** DVD menu capture and persisted menu-image operations. */
+export const menuImageClient = {
+  importPaths: (release: ReleaseRef, paths: string[], signal?: AbortSignal) =>
+    requestApp<void>(
+      "ImportMenuImages",
+      {
+        Release: release,
+        Paths: paths,
+      },
+      { signal },
+    ),
+  capture: (release: ReleaseRef, signal?: AbortSignal) =>
+    requestApp<DVDMenuCaptureResult>("CaptureDVDMenus", { Release: release }, { signal }),
+  list: (release: ReleaseRef, signal?: AbortSignal) =>
+    requestApp<ScreenshotImage[]>("ListDVDMenuScreenshots", { Release: release }, { signal }),
+  remove: (release: ReleaseRef, imagePath: string, signal?: AbortSignal) =>
+    requestApp<void>(
+      "DeleteDVDMenuScreenshot",
+      {
+        Release: release,
+        ImagePath: imagePath,
+      },
+      { signal },
+    ),
+};
+
+/** Image-host upload state and operations. */
+export const uploadedImageClient = {
+  listCandidates: (release: ReleaseRef, signal?: AbortSignal) =>
+    requestApp<ScreenshotImage[]>("ListUploadCandidates", { Release: release }, { signal }),
+  listUploaded: (release: ReleaseRef, signal?: AbortSignal) =>
+    requestApp<UploadedImageLink[]>("ListUploadedImages", { Release: release }, { signal }),
+  upload: (
+    correlationID: string,
+    release: ReleaseRef,
+    trackers: string[],
+    host: string,
+    images: ScreenshotImage[],
+    signal?: AbortSignal,
+  ) =>
+    requestApp<UploadImagesResult>(
+      "UploadImages",
+      {
+        CorrelationID: correlationID,
+        Release: release,
+        Trackers: trackers,
+        Host: host,
+        Images: images,
+      },
+      { signal },
+    ),
+  remove: (release: ReleaseRef, imagePath: string, host: string, signal?: AbortSignal) =>
+    requestApp<void>(
+      "DeleteUploadedImage",
+      { Release: release, ImagePath: imagePath, Host: host },
+      { signal },
+    ),
+};
+
+/** Description rendering and override persistence. */
+export const descriptionClient = {
+  render: (raw: string, signal?: AbortSignal) =>
+    requestApp<string>("RenderDescription", { Raw: raw }, { signal }),
+  saveOverride: (
+    release: ReleaseRef,
+    groupKey: string,
+    raw: string,
+    trackers: string[],
+    signal?: AbortSignal,
+  ) =>
+    requestApp<DescriptionBuilderPreview["Groups"][number]>(
+      "SaveDescriptionOverride",
+      {
+        Release: release,
+        GroupKey: groupKey,
+        Raw: raw,
+        Trackers: trackers,
+      },
+      { signal },
+    ),
+};
+
+/** Config persistence plus browser-native import and download behavior. */
+export const configClient = {
+  get: () => requestApp<string>("GetConfig"),
+  getDefault: () => requestApp<string>("GetDefaultConfig"),
+  save: (payload: string) => requestApp<void>("SaveConfig", { Payload: payload }),
+  exportDownload: async () => {
+    const payload = await requestApp<string>("ExportConfig");
+    const blob = new Blob([payload], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = "upbrr-config.json";
+    anchor.click();
+    URL.revokeObjectURL(url);
+    return anchor.download;
+  },
+  importFile: async (): Promise<ConfigImportResult> => {
+    const fileData = await selectTextFile(".py,.yaml,.yml,.json");
+    if (!fileData.name) return { message: "", warnings: [] };
+    const response = await requestApp<{ result: string; warnings: string[] }>("ImportConfig", {
+      FileName: fileData.name,
+      FileContent: fileData.content,
+    });
+    return { message: response.result, warnings: response.warnings ?? [] };
+  },
+};
+
+/** Sanitized recent-log and live-log stream operations. */
+export const loggingClient = {
+  getPath: () => requestApp<string>("GetLogPath"),
+  getRecent: (limit: number) => requestApp<LogEntry[]>("GetRecentLogs", { Limit: limit }),
+  startStream: () => requestApp<string>("StartLogStream"),
+  stopStream: (streamID: string) => requestApp<void>("StopLogStream", { StreamID: streamID }),
+  getExclusions: () => requestApp<string[]>("GetLogExclusions"),
+  updateExclusions: (patterns: string[]) =>
+    requestApp<void>("UpdateLogExclusions", { Patterns: patterns }),
+};
+
+/** Tracker catalog and image-host policy metadata. */
+export const trackerCatalogClient = {
+  list: () => requestApp<TrackerCatalog>("ListTrackerCatalog"),
+  getImageHostPolicyMetadata: () =>
+    requestApp<ImageHostPolicyMetadata>("GetImageHostPolicyMetadata"),
+  getIcon: (domain: string, url: string) =>
+    requestApp<string>("GetTrackerIcon", { Domain: domain, URL: url }),
+};
+
+/** Tracker authentication status, browser file import, login, 2FA, and removal. */
+export const trackerAuthClient = {
+  listCapabilities: () => requestApp<TrackerAuthCapability[]>("ListTrackerAuthCapabilities"),
+  getStatus: (tracker: string) =>
+    requestApp<TrackerAuthStatus>("GetTrackerAuthStatus", { Tracker: tracker }),
+  importCookies: async (tracker: string) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = ".txt,.json";
+    const fileData = await new Promise<{ name: string; content: string }>((resolve, reject) => {
+      input.onchange = () => {
+        const file = input.files?.[0];
+        if (!file) {
+          resolve({ name: "", content: "" });
+          return;
+        }
+        if (file.size > maxCookieImportContentBytes) {
+          reject(
+            new Error(
+              `tracker auth: cookie file content exceeds ${maxCookieImportContentBytes} byte limit`,
+            ),
+          );
+          return;
+        }
+        const reader = new FileReader();
+        reader.onload = () => {
+          const content = reader.result as string;
+          if (encodedTextByteLength(content) > maxCookieImportContentBytes) {
+            reject(
+              new Error(
+                `tracker auth: cookie file content exceeds ${maxCookieImportContentBytes} byte limit`,
+              ),
+            );
+            return;
+          }
+          resolve({ name: file.name, content });
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsText(file);
+      };
+      input.addEventListener("cancel", () => resolve({ name: "", content: "" }));
+      input.click();
+    });
+    if (!fileData.name) return trackerAuthClient.getStatus(tracker);
+    return trackerAuthClient.importCookieContent(tracker, fileData.name, fileData.content);
+  },
+  importCookieContent: (tracker: string, fileName: string, content: string) =>
+    requestApp<TrackerAuthStatus>("ImportTrackerAuthCookieContent", {
+      Tracker: tracker,
+      FileName: fileName,
+      Content: content,
+    }),
+  test: (tracker: string) => requestApp<TrackerAuthStatus>("TestTrackerAuth", { Tracker: tracker }),
+  login: (tracker: string, login: TrackerAuthLoginRequest) =>
+    requestApp<TrackerAuthStatus>("LoginTrackerAuth", { Tracker: tracker, Login: login }),
+  submit2FA: (challengeID: string, code: string) =>
+    requestApp<TrackerAuthStatus>("SubmitTrackerAuth2FA", { ChallengeID: challengeID, Code: code }),
+  remove: (tracker: string) =>
+    requestApp<TrackerAuthStatus>("DeleteTrackerAuth", { Tracker: tracker }),
+};
+
+/** Persisted release history operations. */
+export const historyClient = {
+  list: () => requestApp<HistoryEntry[]>("ListHistory"),
+  getOverview: (sourcePath: string) =>
+    requestApp<HistoryOverview>("GetHistoryOverview", { SourcePath: sourcePath }),
+  removeRelease: (sourcePath: string) =>
+    requestApp<void>("DeleteHistoryRelease", { SourcePath: sourcePath }),
+};
+
+/** Reviewed tracker-upload handoff and session-owned job lifecycle. */
+export const uploadClient = {
+  review: (
+    release: ReleaseRef,
+    trackers: string[],
+    ignoreDupesFor: string[],
+    ruleAuthorizations: RuleAuthorization[],
+    questionnaireAnswers: Record<string, Record<string, string>>,
+    descriptionGroups: DescriptionBuilderPreview["Groups"],
+    noSeed: boolean,
+    runLogLevel: string,
+    signal?: AbortSignal,
+  ) =>
+    requestApp<UploadReviewResult>(
+      "ReviewTrackerUpload",
+      {
+        Release: release,
+        Trackers: trackers,
+        IgnoreDupesFor: ignoreDupesFor,
+        RuleAuthorizations: ruleAuthorizations,
+        QuestionnaireAnswers: questionnaireAnswers,
+        DescriptionGroups: descriptionGroups,
+        NoSeed: noSeed,
+        RunLogLevel: runLogLevel,
+      },
+      { signal },
+    ),
+  startReviewed: (token: string, correlationID: string) =>
+    requestApp<string>("StartReviewedTrackerUpload", {
+      Token: token,
+      CorrelationID: correlationID,
+    }),
+  cancel: (jobID: string) => requestApp<void>("CancelTrackerUpload", { JobID: jobID }),
+  retryFailed: (jobID: string, correlationID: string) =>
+    requestApp<string>("RetryFailedTrackerUpload", { JobID: jobID, CorrelationID: correlationID }),
+  getSnapshot: (jobID: string) =>
+    requestApp<TrackerUploadSnapshot>("GetTrackerUploadSnapshot", { JobID: jobID }),
+};
+
+/** Authenticated-owner retained Job listing. */
+export const jobsClient = {
+  list: () => requestApp<OwnerJobSnapshot[]>("ListJobs"),
+};
diff --git a/webui/src/api/client.test.ts b/webui/src/api/client.test.ts
new file mode 100644
index 00000000..67889b5a
--- /dev/null
+++ b/webui/src/api/client.test.ts
@@ -0,0 +1,467 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { TrackerAuthStatus } from "../types";
+
+const jsonResponse = (payload: unknown, init?: ResponseInit) =>
+  new Response(JSON.stringify(payload), {
+    headers: { "Content-Type": "application/json" },
+    ...init,
+  });
+
+const eventStreamResponse = (payload: unknown, onCancel?: () => void) => {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(`event: test:event\ndata: ${JSON.stringify(payload)}\n\n`));
+    },
+    cancel() {
+      onCancel?.();
+    },
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/event-stream" },
+  });
+};
+
+describe("web client", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    delete window.__UPBRR_BASE_URL__;
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("posts app calls with JSON and CSRF headers", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ ok: true }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { screenshotClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    const release = { SourcePath: "C:/media/Example.mkv", Generation: 3 };
+    const result = await screenshotClient.fetchPlan(release);
+
+    expect(result).toEqual({ ok: true });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/app/FetchScreenshotPlan",
+      expect.objectContaining({
+        method: "POST",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+          "X-CSRF-Token": "csrf-token",
+        },
+        body: JSON.stringify({
+          Release: release,
+        }),
+      }),
+    );
+  });
+
+  it("uses the abortable exact DVD menu capture payload", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(jsonResponse({ Images: [], Warnings: [] }))
+      .mockResolvedValueOnce(jsonResponse([]))
+      .mockResolvedValueOnce(jsonResponse({ ok: true }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { menuImageClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    const controller = new AbortController();
+    const release = { SourcePath: "C:/media/Example", Generation: 3 };
+    await menuImageClient.capture(release, controller.signal);
+    await menuImageClient.list(release);
+    await menuImageClient.remove(release, "C:/managed/menu.png");
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "/api/app/CaptureDVDMenus",
+      expect.objectContaining({
+        signal: controller.signal,
+        body: JSON.stringify({
+          Release: release,
+        }),
+      }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "/api/app/ListDVDMenuScreenshots",
+      expect.objectContaining({
+        body: JSON.stringify({
+          Release: release,
+        }),
+      }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      3,
+      "/api/app/DeleteDVDMenuScreenshot",
+      expect.objectContaining({
+        body: JSON.stringify({
+          Release: release,
+          ImagePath: "C:/managed/menu.png",
+        }),
+      }),
+    );
+  });
+
+  it("preserves tracker auth status fields from browser app routes", async () => {
+    const status: TrackerAuthStatus = {
+      trackerID: "MTV",
+      displayName: "MTV",
+      state: "needs_2fa",
+      cookieCount: 2,
+      lastCheckedAt: "2026-07-08T01:02:03Z",
+      lastError: "tracker auth validation failed",
+      encryptedStorage: true,
+      needs2FA: true,
+      challengeID: "challenge-123",
+      message: "enter 2FA code",
+    };
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(status));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { trackerAuthClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    const result = await trackerAuthClient.getStatus("MTV");
+
+    expect(result).toEqual(status);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/app/GetTrackerAuthStatus",
+      expect.objectContaining({
+        body: JSON.stringify({ Tracker: "MTV" }),
+      }),
+    );
+  });
+
+  it("preserves tracker auth app route error messages", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(
+          jsonResponse({ error: "tracker auth: validation failed" }, { status: 400 }),
+        ),
+    );
+
+    const { initializeWebClient } = await import("./client");
+    const { trackerAuthClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    await expect(trackerAuthClient.test("MTV")).rejects.toThrow("tracker auth: validation failed");
+  });
+
+  it("renders structured operation failures with stable recovery guidance", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(
+        jsonResponse(
+          {
+            error: "Prepared release changed.",
+            failure: {
+              Code: "stale_generation",
+              Operation: "media",
+              Message: "Prepared release changed.",
+              Recovery: "refresh_release",
+            },
+          },
+          { status: 409 },
+        ),
+      ),
+    );
+
+    const { initializeWebClient, requestApp } = await import("./client");
+    initializeWebClient("csrf-token", true);
+
+    await expect(requestApp("FetchScreenshotPlan", {})).rejects.toThrow(
+      "Prepared release changed. Recovery: refresh release.",
+    );
+  });
+
+  it("prefixes browser API calls with the injected base URL", async () => {
+    window.__UPBRR_BASE_URL__ = "/upbrr/";
+    const fetchMock = vi.fn().mockImplementation(() => Promise.resolve(jsonResponse({ ok: true })));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { authClient, initializeWebClient, withBasePath } = await import("./client");
+    const { configClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    expect(withBasePath("/api/auth/status")).toBe("/upbrr/api/auth/status");
+
+    await authClient.status();
+    await configClient.get();
+
+    expect(fetchMock).toHaveBeenNthCalledWith(1, "/upbrr/api/auth/status", {
+      credentials: "include",
+    });
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "/upbrr/api/app/GetConfig",
+      expect.objectContaining({
+        method: "POST",
+        credentials: "include",
+      }),
+    );
+  });
+
+  it("throws response errors from browser auth calls", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(jsonResponse({ error: "login required" }, { status: 401 })),
+    );
+
+    const { authClient } = await import("./client");
+
+    await expect(authClient.status()).rejects.toThrow("login required");
+  });
+
+  it("refreshes browser auth state and retries app calls once", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(jsonResponse({ error: "csrf validation failed" }, { status: 403 }))
+      .mockResolvedValueOnce(
+        jsonResponse({
+          authenticated: true,
+          csrfToken: "stale-csrf",
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse("job-1"));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { dupeClient } = await import("./app");
+    initializeWebClient("stale-csrf", false);
+
+    const result = await dupeClient.start(
+      { SourcePath: "C:/media/movie.mkv", Generation: 1 },
+      ["AITHER"],
+      "dupe-correlation",
+    );
+
+    expect(result).toBe("job-1");
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "/api/app/StartDupeCheck",
+      expect.objectContaining({
+        credentials: "include",
+        headers: expect.objectContaining({ "X-CSRF-Token": "stale-csrf" }),
+      }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(2, "/api/auth/status", {
+      credentials: "include",
+    });
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      3,
+      "/api/app/StartDupeCheck",
+      expect.objectContaining({
+        credentials: "include",
+        headers: expect.objectContaining({ "X-CSRF-Token": "stale-csrf" }),
+      }),
+    );
+  });
+
+  it("does not adopt a different browser session during auth refresh", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(jsonResponse({ error: "csrf validation failed" }, { status: 403 }))
+      .mockResolvedValueOnce(
+        jsonResponse({
+          authenticated: true,
+          csrfToken: "other-session-csrf",
+        }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { dupeClient } = await import("./app");
+    initializeWebClient("session-a-csrf", false);
+
+    await expect(
+      dupeClient.start(
+        { SourcePath: "C:/media/movie.mkv", Generation: 1 },
+        ["AITHER"],
+        "dupe-correlation",
+      ),
+    ).rejects.toThrow("Web session changed in another tab");
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("opens browser events with the initialized session token header", async () => {
+    const cancelStream = vi.fn();
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(eventStreamResponse({ jobID: "job-1" }, cancelStream));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { subscribeWebEvent, initializeWebClient } = await import("./client");
+    initializeWebClient("csrf-token", true);
+    const listener = vi.fn();
+    const off = subscribeWebEvent("test:event", listener);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/events",
+      expect.objectContaining({
+        method: "GET",
+        credentials: "include",
+        headers: { "X-CSRF-Token": "csrf-token" },
+      }),
+    );
+    await vi.waitFor(() => expect(listener).toHaveBeenCalledWith({ jobID: "job-1" }));
+    off();
+    await vi.waitFor(() => expect(cancelStream).toHaveBeenCalledOnce());
+  });
+
+  it("stores host path case sensitivity from client initialization", async () => {
+    const { initializeWebClient, isHostPathCaseInsensitive } = await import("./client");
+
+    initializeWebClient("csrf-token", true);
+    expect(isHostPathCaseInsensitive()).toBe(true);
+
+    initializeWebClient("csrf-token", false);
+    expect(isHostPathCaseInsensitive()).toBe(false);
+  });
+
+  it("rejects oversized decoded tracker cookie content before posting", async () => {
+    const originalCreateElement = document.createElement.bind(document);
+    const input = document.createElement("input");
+    Object.defineProperty(input, "files", {
+      configurable: true,
+      value: [new File(["x"], "cookies.txt")],
+    });
+    vi.spyOn(input, "click").mockImplementation(() => {
+      input.dispatchEvent(new Event("change"));
+    });
+    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
+      if (tagName === "input") {
+        return input;
+      }
+      return originalCreateElement(tagName);
+    });
+    const readAsText = vi.fn();
+    vi.stubGlobal(
+      "FileReader",
+      vi.fn().mockImplementation(function (this: any) {
+        this.readAsText = readAsText.mockImplementation(() => {
+          Object.defineProperty(this, "result", {
+            configurable: true,
+            value: "x".repeat(1024 * 1024 + 1),
+          });
+          this.onload?.(new ProgressEvent("load"));
+        });
+      }),
+    );
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { trackerAuthClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    await expect(trackerAuthClient.importCookies("PTP")).rejects.toThrow(
+      "cookie file content exceeds 1048576 byte limit",
+    );
+    expect(readAsText).toHaveBeenCalled();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("rejects oversized raw tracker cookie files before decoding", async () => {
+    const originalCreateElement = document.createElement.bind(document);
+    const input = document.createElement("input");
+    const file = new File(["x"], "cookies.txt");
+    Object.defineProperty(file, "size", { configurable: true, value: 1024 * 1024 + 1 });
+    Object.defineProperty(input, "files", {
+      configurable: true,
+      value: [file],
+    });
+    vi.spyOn(input, "click").mockImplementation(() => {
+      input.dispatchEvent(new Event("change"));
+    });
+    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
+      if (tagName === "input") {
+        return input;
+      }
+      return originalCreateElement(tagName);
+    });
+    const readAsText = vi.fn();
+    vi.stubGlobal(
+      "FileReader",
+      vi.fn().mockImplementation(function (this: any) {
+        this.readAsText = readAsText.mockImplementation(() => {
+          Object.defineProperty(this, "result", { configurable: true, value: "session=abc" });
+          this.onload?.(new ProgressEvent("load"));
+        });
+      }),
+    );
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ trackerID: "PTP" }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { trackerAuthClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    await expect(trackerAuthClient.importCookies("PTP")).rejects.toThrow(
+      "cookie file content exceeds 1048576 byte limit",
+    );
+    expect(readAsText).not.toHaveBeenCalled();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("posts valid tracker cookie files from the browser client", async () => {
+    const originalCreateElement = document.createElement.bind(document);
+    const input = document.createElement("input");
+    Object.defineProperty(input, "files", {
+      configurable: true,
+      value: [new File(["session=abc"], "cookies.txt")],
+    });
+    vi.spyOn(input, "click").mockImplementation(() => {
+      input.dispatchEvent(new Event("change"));
+    });
+    vi.spyOn(document, "createElement").mockImplementation((tagName: string) => {
+      if (tagName === "input") {
+        return input;
+      }
+      return originalCreateElement(tagName);
+    });
+    vi.stubGlobal(
+      "FileReader",
+      vi.fn().mockImplementation(function (this: any) {
+        this.readAsText = vi.fn(() => {
+          Object.defineProperty(this, "result", { configurable: true, value: "session=abc" });
+          this.onload?.(new ProgressEvent("load"));
+        });
+      }),
+    );
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse({ trackerID: "PTP" }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { initializeWebClient } = await import("./client");
+    const { trackerAuthClient } = await import("./app");
+    initializeWebClient("csrf-token", true);
+
+    await expect(trackerAuthClient.importCookies("PTP")).resolves.toEqual({
+      trackerID: "PTP",
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/app/ImportTrackerAuthCookieContent",
+      expect.objectContaining({
+        body: JSON.stringify({
+          Tracker: "PTP",
+          FileName: "cookies.txt",
+          Content: "session=abc",
+        }),
+      }),
+    );
+  });
+});
diff --git a/webui/src/api/client.ts b/webui/src/api/client.ts
new file mode 100644
index 00000000..60ae8f3c
--- /dev/null
+++ b/webui/src/api/client.ts
@@ -0,0 +1,274 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { OperationFailure } from "../types";
+
+type EventCallback = (payload: unknown) => void;
+type AppRequestHandler = (
+  method: string,
+  body?: unknown,
+  options?: { signal?: AbortSignal },
+) => Promise<unknown>;
+
+declare global {
+  interface Window {
+    __UPBRR_BASE_URL__?: string;
+  }
+}
+
+const callbacks = new Map<string, Set<EventCallback>>();
+let eventStreamController: AbortController | null = null;
+let eventStreamReconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let csrfToken = "";
+let caseInsensitivePaths = navigator.platform.toLowerCase().startsWith("win");
+let testAppRequestHandler: AppRequestHandler | null = null;
+
+const sessionChangedMessage =
+  "Web session changed in another tab. Reload this tab to continue with the active login.";
+
+const parseJSONResponse = async <T>(response: Response): Promise<T | null> => {
+  const text = await response.text();
+  if (!text.trim()) return null;
+  return JSON.parse(text) as T;
+};
+
+/** Stable domain failure returned by an accepted application operation. */
+class OperationFailureError extends Error {
+  readonly failure: OperationFailure;
+
+  constructor(failure: OperationFailure) {
+    super(
+      failure.Recovery && failure.Recovery !== "none"
+        ? `${failure.Message} Recovery: ${failure.Recovery.replaceAll("_", " ")}.`
+        : failure.Message,
+    );
+    this.name = "OperationFailureError";
+    this.failure = failure;
+  }
+}
+
+const isAuthFailureStatus = (status: number) => status === 401 || status === 403;
+
+const normalizeBaseURL = (value: unknown) => {
+  if (typeof value !== "string") return "/";
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") return "/";
+  const path = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return path.endsWith("/") ? path : `${path}/`;
+};
+
+/** Prefixes API and event paths with the base URL injected by the WebUI server. */
+export const withBasePath = (path: string) => {
+  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+  return `${normalizeBaseURL(window.__UPBRR_BASE_URL__)}${normalizedPath}`;
+};
+
+const setPathCaseSensitivity = (caseInsensitive: unknown) => {
+  if (typeof caseInsensitive === "boolean") caseInsensitivePaths = caseInsensitive;
+};
+
+const refreshAuthState = async () => {
+  const response = await fetch(withBasePath("/api/auth/status"), { credentials: "include" });
+  const payload = await parseJSONResponse<
+    Record<string, unknown> & {
+      authenticated?: boolean;
+      csrfToken?: string;
+      caseInsensitivePaths?: boolean;
+    }
+  >(response);
+  if (!response.ok || !payload?.authenticated) return false;
+
+  const nextCSRFToken = String(payload.csrfToken || "");
+  if (csrfToken && nextCSRFToken && nextCSRFToken !== csrfToken) {
+    throw new Error(sessionChangedMessage);
+  }
+  csrfToken = nextCSRFToken;
+  setPathCaseSensitivity(payload.caseInsensitivePaths);
+  recreateEventStream();
+  return csrfToken !== "";
+};
+
+const closeEventStream = () => {
+  if (eventStreamReconnectTimer) {
+    clearTimeout(eventStreamReconnectTimer);
+    eventStreamReconnectTimer = null;
+  }
+  if (eventStreamController) {
+    eventStreamController.abort();
+    eventStreamController = null;
+  }
+};
+
+const ensureEventStream = () => {
+  if (eventStreamController || !csrfToken || callbacks.size === 0) return;
+  const controller = new AbortController();
+  eventStreamController = controller;
+  void runEventStream(controller);
+};
+
+const recreateEventStream = () => {
+  closeEventStream();
+  ensureEventStream();
+};
+
+const scheduleEventStreamReconnect = () => {
+  if (!csrfToken || callbacks.size === 0 || eventStreamReconnectTimer) return;
+  eventStreamReconnectTimer = setTimeout(() => {
+    eventStreamReconnectTimer = null;
+    ensureEventStream();
+  }, 1000);
+};
+
+const runEventStream = async (controller: AbortController) => {
+  let reconnect = true;
+  try {
+    const response = await fetch(withBasePath("/api/events"), {
+      method: "GET",
+      credentials: "include",
+      headers: { "X-CSRF-Token": csrfToken },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      if (isAuthFailureStatus(response.status)) {
+        reconnect = await refreshAuthState().catch(() => false);
+      }
+      return;
+    }
+    if (!response.body) throw new Error("Event stream response body is unavailable");
+    await readEventStream(response.body, controller.signal);
+  } catch (_error) {
+    if (!controller.signal.aborted) scheduleEventStreamReconnect();
+  } finally {
+    if (eventStreamController === controller) {
+      eventStreamController = null;
+      if (reconnect && !controller.signal.aborted) scheduleEventStreamReconnect();
+    }
+  }
+};
+
+const readEventStream = async (body: ReadableStream<Uint8Array>, signal: AbortSignal) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const abortRead = () => void reader.cancel();
+  signal.addEventListener("abort", abortRead, { once: true });
+  try {
+    for (;;) {
+      if (signal.aborted) break;
+      const { value, done } = await reader.read();
+      if (done || signal.aborted) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() || "";
+      parts.forEach(dispatchEventBlock);
+    }
+  } finally {
+    signal.removeEventListener("abort", abortRead);
+    reader.releaseLock();
+  }
+};
+
+const dispatchEventBlock = (block: string) => {
+  let eventName = "message";
+  const data: string[] = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith("event:")) eventName = line.slice("event:".length).trim();
+    else if (line.startsWith("data:")) data.push(line.slice("data:".length).trimStart());
+  }
+  if (!callbacks.has(eventName) || data.length === 0) return;
+  const payload = JSON.parse(data.join("\n"));
+  callbacks.get(eventName)?.forEach((callback) => callback(payload));
+};
+
+const postJSON = async <T>(path: string, body?: unknown, signal?: AbortSignal): Promise<T> => {
+  const requestInit = (): RequestInit => ({
+    method: "POST",
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+      ...(csrfToken ? { "X-CSRF-Token": csrfToken } : {}),
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal,
+  });
+  let response = await fetch(withBasePath(path), requestInit());
+  let payload = await parseJSONResponse<T & { error?: string; failure?: OperationFailure }>(
+    response,
+  );
+  if (!response.ok && isAuthFailureStatus(response.status) && (await refreshAuthState())) {
+    response = await fetch(withBasePath(path), requestInit());
+    payload = await parseJSONResponse<T & { error?: string }>(response);
+  }
+  if (!response.ok) {
+    if (payload?.failure) throw new OperationFailureError(payload.failure);
+    throw new Error(String(payload?.error || response.statusText || "Request failed"));
+  }
+  if (payload === null) throw new Error("Request returned an empty response");
+  return payload as T;
+};
+
+/** Initializes cookie-bound WebUI requests and event delivery for one authenticated session. */
+export const initializeWebClient = (token: string, hostCaseInsensitivePaths?: boolean) => {
+  csrfToken = token;
+  setPathCaseSensitivity(hostCaseInsensitivePaths);
+  recreateEventStream();
+};
+
+/** Updates the active session CSRF token and host path comparison semantics. */
+export const updateWebCSRFToken = (token: string, hostCaseInsensitivePaths?: boolean) => {
+  csrfToken = token;
+  setPathCaseSensitivity(hostCaseInsensitivePaths);
+  recreateEventStream();
+};
+
+/** Reports whether the WebUI host compares filesystem paths case-insensitively. */
+export const isHostPathCaseInsensitive = () => caseInsensitivePaths;
+
+/** Subscribes to a cookie-bound WebUI server-sent event. */
+export const subscribeWebEvent = (eventName: string, callback: EventCallback) => {
+  const listeners = callbacks.get(eventName) ?? new Set<EventCallback>();
+  listeners.add(callback);
+  callbacks.set(eventName, listeners);
+  ensureEventStream();
+  return () => {
+    listeners.delete(callback);
+    if (listeners.size === 0) callbacks.delete(eventName);
+    if (callbacks.size === 0) closeEventStream();
+  };
+};
+
+/** Sends one typed application operation to the WebUI server. */
+export const requestApp = <T>(
+  method: string,
+  body?: unknown,
+  options: { signal?: AbortSignal } = {},
+): Promise<T> => {
+  if (testAppRequestHandler) {
+    return testAppRequestHandler(method, body, options).then((result) => result as T);
+  }
+  return postJSON<T>(`/api/app/${method}`, body, options.signal);
+};
+
+/** Installs a request transport for unit tests without creating runtime globals. */
+export const setAppRequestHandlerForTests = (handler: AppRequestHandler | null) => {
+  testAppRequestHandler = handler;
+};
+
+/** Auth operations sharing the WebUI base path, cookies, and CSRF lifecycle. */
+export const authClient = {
+  status: async () => {
+    const response = await fetch(withBasePath("/api/auth/status"), { credentials: "include" });
+    const payload = await parseJSONResponse<Record<string, unknown> & { error?: string }>(response);
+    if (!response.ok) {
+      throw new Error(String(payload?.error || response.statusText || "Request failed"));
+    }
+    return payload || {};
+  },
+  bootstrap: (username: string, password: string, retainLogin: boolean) =>
+    postJSON("/api/auth/bootstrap", { username, password, retainLogin }),
+  login: (username: string, password: string, retainLogin: boolean) =>
+    postJSON("/api/auth/login", { username, password, retainLogin }),
+  saveBrowsePolicy: (browseRoot: string, allowUnrestrictedBrowse: boolean) =>
+    postJSON("/api/auth/browse-policy", { browseRoot, allowUnrestrictedBrowse }),
+  logout: () => postJSON("/api/auth/logout"),
+};
diff --git a/webui/src/app.test.ts b/webui/src/app.test.ts
new file mode 100644
index 00000000..df1c1e8b
--- /dev/null
+++ b/webui/src/app.test.ts
@@ -0,0 +1,158 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { createElement } from "react";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import App from "./app";
+import { setAppRequestHandlerForTests } from "./api/client";
+import type { MetadataPreview, TrackerCatalog } from "./types";
+import { emptyExternalIdentity } from "./utils/canonicalIdentity";
+import { sourcePathHistoryStorageKey } from "./utils/inputHistory";
+
+const storedValues = new Map<string, string>();
+const localStorageStub: Storage = {
+  get length() {
+    return storedValues.size;
+  },
+  clear: () => storedValues.clear(),
+  getItem: (key) => storedValues.get(key) ?? null,
+  key: (index) => Array.from(storedValues.keys())[index] ?? null,
+  removeItem: (key) => storedValues.delete(key),
+  setItem: (key, value) => storedValues.set(key, value),
+};
+
+beforeEach(() => {
+  Object.defineProperty(document.defaultView, "localStorage", {
+    configurable: true,
+    value: localStorageStub,
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  setAppRequestHandlerForTests(null);
+  localStorageStub.clear();
+});
+
+const trackerCatalog = (): TrackerCatalog => ({
+  entries: ["AITHER", "BLU"].map((name) => ({
+    name,
+    family: "unit3d",
+    baseURL: `https://${name.toLowerCase()}.example.invalid`,
+    uploadContentMode: "description",
+    configured: true,
+    fields: [{ key: "APIKey", yamlKey: "api_key", default: "", activation: true }],
+  })),
+  unsupported: [],
+});
+
+const metadataPreview = (sourcePath: string): MetadataPreview => ({
+  SourcePath: sourcePath,
+  TrackerName: "",
+  ReleaseName: "Example.Release.2026.1080p-GRP",
+  ReleaseNameOverrides: {},
+  Release: { SourcePath: sourcePath, Generation: 1 },
+  Identity: { ...emptyExternalIdentity(sourcePath), Generation: 1 },
+  Display: { ReleaseName: "Example.Release.2026.1080p-GRP", Providers: [] },
+  Bluray: null,
+  Diagnostics: [],
+  TrackerData: [],
+  TrackerRuleFailures: {},
+});
+
+describe("App shell", () => {
+  it("composes the release session and renders input routing", async () => {
+    setAppRequestHandlerForTests(async (method) => {
+      if (method === "ListJobs") return [];
+      if (method === "GetConfig" || method === "GetDefaultConfig") return "{}";
+      throw new Error(`unexpected app request: ${method}`);
+    });
+
+    render(createElement(App, { jobOwnerKey: "test-owner" }));
+
+    expect(screen.getByRole("heading", { name: "Build Release Name" })).toBeInTheDocument();
+    await waitFor(() => expect(screen.getByRole("button", { name: "Dupe Check" })).toBeDisabled());
+  });
+
+  it("opens the global host-browser dialog from input presentation", async () => {
+    const browse = vi.fn(async (_path: string) => ({
+      currentPath: "C:\\media",
+      parentPath: "C:\\",
+      mode: "folder",
+      entries: [],
+    }));
+    setAppRequestHandlerForTests(async (method, body) => {
+      if (method === "ListJobs") return [];
+      if (method === "GetConfig" || method === "GetDefaultConfig") return "{}";
+      if (method === "BrowseDirectory") return browse((body as { path: string }).path);
+      throw new Error(`unexpected app request: ${method}`);
+    });
+
+    render(createElement(App));
+    screen.getByRole("button", { name: "Browse folder" }).click();
+
+    expect(await screen.findByRole("dialog", { name: "Select folder" })).toBeInTheDocument();
+    expect(browse).toHaveBeenCalledOnce();
+  });
+
+  it("starts with a blank source draft while retaining source history", async () => {
+    localStorageStub.setItem(
+      sourcePathHistoryStorageKey,
+      JSON.stringify([{ path: "C:\\media\\Previously.Used.mkv", mode: "file" }]),
+    );
+    setAppRequestHandlerForTests(async (method) => {
+      if (method === "ListJobs") return [];
+      if (method === "GetConfig" || method === "GetDefaultConfig") return "{}";
+      throw new Error(`unexpected app request: ${method}`);
+    });
+
+    render(createElement(App));
+
+    const sourceInput = screen.getByLabelText("Source path");
+    fireEvent.focus(sourceInput);
+    expect(await screen.findByText("C:\\media\\Previously.Used.mkv")).toBeInTheDocument();
+    expect(sourceInput).toHaveValue("");
+  });
+
+  it("selects configured default trackers for each fresh release session", async () => {
+    setAppRequestHandlerForTests(async (method, body) => {
+      if (method === "ListJobs") return [];
+      if (method === "ListTrackerCatalog") return trackerCatalog();
+      if (method === "GetDefaultConfig") return "{}";
+      if (method === "GetConfig") {
+        return JSON.stringify({
+          Trackers: {
+            DefaultTrackers: ["AITHER", "BLU"],
+            Trackers: {
+              AITHER: { APIKey: "configured" },
+              BLU: { APIKey: "configured" },
+            },
+          },
+        });
+      }
+      if (method === "DetectDiscType") return "";
+      if (method === "FetchMetadata") {
+        return metadataPreview(String((body as { Path?: string }).Path || ""));
+      }
+      throw new Error(`unexpected app request: ${method}`);
+    });
+
+    render(createElement(App));
+    const sourceInput = screen.getByLabelText("Source path");
+    fireEvent.change(sourceInput, { target: { value: "C:\\media\\Example.Release.2026.mkv" } });
+    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
+
+    expect(await screen.findByText("2/2")).toBeInTheDocument();
+    const aither = screen.getByRole("checkbox", { name: "AITHER" });
+    expect(aither).toBeChecked();
+    expect(screen.getByRole("checkbox", { name: "BLU" })).toBeChecked();
+
+    fireEvent.click(aither);
+    expect(aither).not.toBeChecked();
+
+    fireEvent.change(sourceInput, { target: { value: "C:\\media\\Next.Release.2026.mkv" } });
+    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
+    await waitFor(() => expect(screen.getByRole("checkbox", { name: "AITHER" })).toBeChecked());
+  });
+});
diff --git a/webui/src/app.tsx b/webui/src/app.tsx
new file mode 100644
index 00000000..7305cecd
--- /dev/null
+++ b/webui/src/app.tsx
@@ -0,0 +1,746 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import * as Dialog from "@radix-ui/react-dialog";
+import { configClient, hostBrowser as hostBrowserClient } from "./api/app";
+import { isHostPathCaseInsensitive } from "./api/client";
+import BlurayCandidatesPage from "./pages/bluray_candidates";
+import DescriptionBuilderPage from "./pages/description_builder";
+import DupeCheckPage from "./pages/dupe_check";
+import HistoryPage from "./pages/history";
+import InputPage from "./pages/input";
+import LoggingPage from "./pages/logging";
+import MenuImagesPage from "./pages/menu_images";
+import ScreenshotsPage from "./pages/screenshots";
+import SettingsPage from "./pages/settings";
+import TrackerDataPage from "./pages/tracker_data";
+import TrackerUploadPage from "./pages/tracker_upload";
+import UploadImagesPage from "./pages/upload_images";
+import { useSettingsState } from "./hooks/useSettingsState";
+import { useTrackerIcons } from "./hooks/useTrackerIcons";
+import { JobRegistryProvider, useJobNotifications } from "./jobRegistry";
+import { ReleaseSessionProvider, useReleaseSession } from "./releaseSession";
+import { TrackerCatalogProvider } from "./trackerCatalog";
+import type { ReleaseRoute } from "./releaseSession/types";
+import type { BrowseDirectoryResponse, ConfigMap } from "./types";
+import { cn } from "./utils/cn";
+import {
+  addSourcePathHistoryEntry,
+  defaultInputHistoryLimit,
+  filterBrowseEntries,
+  inferSourcePathMode,
+  normalizeSourcePathHistory,
+  resolveInputHistoryLimit,
+  sourcePathHistoryStorageKey,
+  type SourcePathHistoryEntry,
+  type SourcePathMode,
+} from "./utils/inputHistory";
+import { normalizeDefaultTrackerList } from "./utils/settings";
+
+const appLayoutClass =
+  "relative z-[1] block min-h-screen ml-[204px] max-[960px]:ml-0 max-[960px]:pb-[78px]";
+const sidebarClass =
+  "fixed left-0 top-0 z-[1000] flex h-screen w-[204px] flex-col gap-2.5 border-r border-white/10 bg-[var(--panel)]/95 p-2.5 backdrop-blur max-[960px]:bottom-0 max-[960px]:top-auto max-[960px]:h-auto max-[960px]:w-full max-[960px]:flex-row max-[960px]:items-center max-[960px]:gap-2 max-[960px]:border-r-0 max-[960px]:border-t max-[960px]:p-2";
+const sidebarGroupClass =
+  "grid gap-1 rounded-lg border border-[rgba(148,163,184,0.18)] bg-[rgba(148,163,184,0.08)] p-1.5 max-[960px]:flex max-[960px]:flex-wrap max-[960px]:gap-1 max-[960px]:p-1";
+const navButtonClass = (active: boolean, nested = false) =>
+  cn(
+    "w-full rounded-md border border-transparent bg-transparent px-2 py-1.5 text-left text-[0.84rem] font-semibold leading-tight text-[var(--muted)] transition hover:bg-white/10 hover:text-[var(--text)] disabled:cursor-not-allowed disabled:opacity-45 max-[960px]:w-auto",
+    nested && "pl-4 text-[0.8rem] font-medium max-[960px]:pl-2",
+    active &&
+      "border-[var(--sidebar-active-border)] bg-[var(--sidebar-active-bg)] text-[var(--sidebar-active-text)]",
+  );
+
+type ActiveTab =
+  | "input"
+  | "tracker"
+  | "bluray"
+  | "dupes"
+  | "screenshots"
+  | "menu_images"
+  | "upload_images"
+  | "description_builder"
+  | "upload"
+  | "history"
+  | "settings"
+  | "logging";
+type ThemeMode = "light" | "dark" | "auto";
+type ConfigOpStatus = {
+  type: "success" | "error" | "warning";
+  title: string;
+  message: string;
+  warnings?: string[];
+} | null;
+
+const browserStorage = () => {
+  try {
+    return document.defaultView?.localStorage || null;
+  } catch {
+    return null;
+  }
+};
+
+/** Shell/router around the sole active release-session interface. */
+function AppShell() {
+  const releaseSession = useReleaseSession();
+  const jobNotifications = useJobNotifications();
+  const [activeTab, setActiveTab] = useState<ActiveTab>("input");
+  const [navigationNotice, setNavigationNotice] = useState("");
+  const [lightboxImage, setLightboxImage] = useState("");
+  const [lightboxAlt, setLightboxAlt] = useState("");
+  const [theme, setTheme] = useState<ThemeMode>(
+    () => (browserStorage()?.getItem("theme") as ThemeMode | null) || "auto",
+  );
+  const [sourcePathHistory, setSourcePathHistory] = useState<SourcePathHistoryEntry[]>(() => {
+    try {
+      return normalizeSourcePathHistory(
+        JSON.parse(browserStorage()?.getItem(sourcePathHistoryStorageKey) || "[]"),
+        defaultInputHistoryLimit,
+        isHostPathCaseInsensitive(),
+      );
+    } catch {
+      return [];
+    }
+  });
+  const defaultTrackerSelectionSession = useRef<number | null>(null);
+  const [hostBrowserMode, setHostBrowserMode] = useState<SourcePathMode | null>(null);
+  const [hostBrowser, setHostBrowser] = useState<BrowseDirectoryResponse | null>(null);
+  const [hostBrowserLoading, setHostBrowserLoading] = useState(false);
+  const [hostBrowserError, setHostBrowserError] = useState("");
+  const [hostBrowserSearch, setHostBrowserSearch] = useState("");
+  const [settingsExporting, setSettingsExporting] = useState(false);
+  const [settingsImporting, setSettingsImporting] = useState(false);
+  const [importConfirmOpen, setImportConfirmOpen] = useState(false);
+  const [configOpStatus, setConfigOpStatus] = useState<ConfigOpStatus>(null);
+
+  const settings = useSettingsState({ activeTab });
+  const {
+    configData,
+    settingsLoading,
+    settingsDirty,
+    settingsSaved,
+    settingsError,
+    settingsSection,
+    settingsSections,
+    showAdvancedToggle,
+    advancedOpen,
+    setSettingsSection,
+    setSettingsAdvanced,
+    loadSettings,
+    handleSaveSettings,
+    renderImageHostingSection,
+    renderTrackerSection,
+    renderTorrentClientsSection,
+    renderField,
+    sectionFieldMeta,
+    updateConfigValue,
+    updateScreenshotConfigValue,
+    configuredImageHosts,
+    screenshotConfig,
+    clearSettingsStatus,
+    resolveImageHostLabel,
+    trackerSelectionNames,
+  } = settings;
+
+  const inputHistoryLimit = useMemo(() => {
+    const main = (configData?.MainSettings || null) as ConfigMap | null;
+    return resolveInputHistoryLimit(main?.InputHistoryLimit);
+  }, [configData]);
+  const useFavicons = useMemo(() => {
+    const main = (configData?.MainSettings || null) as ConfigMap | null;
+    return typeof main?.UseFavicons === "boolean" ? main.UseFavicons : true;
+  }, [configData]);
+  const faviconOnly = useMemo(() => {
+    const main = (configData?.MainSettings || null) as ConfigMap | null;
+    return typeof main?.FaviconOnly === "boolean" ? main.FaviconOnly : false;
+  }, [configData]);
+  const trackerUploadItems = useMemo(() => {
+    const root = configData?.Trackers as ConfigMap | undefined;
+    const entriesRoot = root?.Trackers;
+    if (!entriesRoot || typeof entriesRoot !== "object" || Array.isArray(entriesRoot)) return [];
+    const visible = new Set(trackerSelectionNames);
+    return Object.entries(entriesRoot as ConfigMap)
+      .filter(
+        ([name, value]) =>
+          visible.has(name) && value && typeof value === "object" && !Array.isArray(value),
+      )
+      .map(([name, config]) => ({ name, config: config as ConfigMap }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }, [configData, trackerSelectionNames]);
+  const defaultTrackerNames = useMemo(() => {
+    const root = configData?.Trackers;
+    if (!root || typeof root !== "object" || Array.isArray(root)) return [];
+    return normalizeDefaultTrackerList((root as ConfigMap).DefaultTrackers ?? []);
+  }, [configData]);
+  const configuredDefaultTrackers = useMemo(() => {
+    const configuredNames = new Map(
+      trackerUploadItems.map((item) => [item.name.trim().toUpperCase(), item.name]),
+    );
+    return Array.from(
+      new Set(
+        defaultTrackerNames
+          .map((name) => configuredNames.get(name.trim().toUpperCase()) || "")
+          .filter(Boolean),
+      ),
+    );
+  }, [defaultTrackerNames, trackerUploadItems]);
+  const trackerIconSrcByName = useTrackerIcons(trackerUploadItems, useFavicons);
+  const maxMenuItems = useMemo(() => {
+    const value = screenshotConfig?.MaxMenuItems;
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 6;
+  }, [screenshotConfig]);
+
+  const preview = releaseSession.identity.view.preview;
+  const sourcePath = releaseSession.identity.view.sourcePath;
+  const access = releaseSession.navigation.view.access;
+  const hasTrackerData = releaseSession.input.view.trackerData.length > 0;
+  const hasBlurayData = Boolean(preview?.Bluray);
+  const currentDiscType = /(^|[\\/])VIDEO_TS([\\/]|$)/i.test(sourcePath)
+    ? "DVD"
+    : /(^|[\\/])BDMV([\\/]|$)/i.test(sourcePath)
+      ? "BDMV"
+      : "";
+
+  const applyTheme = useCallback((value: ThemeMode) => {
+    const resolved =
+      value === "auto"
+        ? document.defaultView?.matchMedia?.("(prefers-color-scheme: dark)").matches
+          ? "dark"
+          : "light"
+        : value;
+    document.documentElement.classList.remove("light", "dark");
+    document.documentElement.classList.add(resolved);
+  }, []);
+  useEffect(() => applyTheme(theme), [applyTheme, theme]);
+
+  const persistHistory = useCallback((entries: SourcePathHistoryEntry[]) => {
+    setSourcePathHistory(entries);
+    try {
+      if (entries.length)
+        browserStorage()?.setItem(sourcePathHistoryStorageKey, JSON.stringify(entries));
+      else browserStorage()?.removeItem(sourcePathHistoryStorageKey);
+    } catch {
+      // Local storage can be disabled by browser policy.
+    }
+  }, []);
+  const rememberSource = useCallback(
+    (path: string, mode: SourcePathMode) => {
+      setSourcePathHistory((previous) => {
+        const next = addSourcePathHistoryEntry(
+          previous,
+          path,
+          mode,
+          inputHistoryLimit,
+          isHostPathCaseInsensitive(),
+        );
+        try {
+          if (next.length)
+            browserStorage()?.setItem(sourcePathHistoryStorageKey, JSON.stringify(next));
+          else browserStorage()?.removeItem(sourcePathHistoryStorageKey);
+        } catch {
+          // Local storage can be disabled by browser policy.
+        }
+        return next;
+      });
+    },
+    [inputHistoryLimit],
+  );
+  useEffect(() => {
+    const release = releaseSession.identity.view.release;
+    if (release?.SourcePath)
+      rememberSource(release.SourcePath, inferSourcePathMode(release.SourcePath));
+  }, [releaseSession.identity.view.release, rememberSource]);
+  useEffect(() => {
+    const sessionRevision = releaseSession.identity.view.sessionRevision;
+    if (
+      defaultTrackerSelectionSession.current === sessionRevision ||
+      !configData ||
+      (defaultTrackerNames.length > 0 && trackerUploadItems.length === 0)
+    ) {
+      return;
+    }
+    defaultTrackerSelectionSession.current = sessionRevision;
+    const current = new Set(releaseSession.input.view.selectedTrackers);
+    if (
+      current.size !== configuredDefaultTrackers.length ||
+      configuredDefaultTrackers.some((tracker) => !current.has(tracker.trim().toUpperCase()))
+    ) {
+      releaseSession.input.chooseTrackers(configuredDefaultTrackers);
+    }
+  }, [
+    configData,
+    configuredDefaultTrackers,
+    defaultTrackerNames.length,
+    releaseSession.identity.view.sessionRevision,
+    releaseSession.input,
+    trackerUploadItems.length,
+  ]);
+  useEffect(() => {
+    persistHistory(
+      normalizeSourcePathHistory(sourcePathHistory, inputHistoryLimit, isHostPathCaseInsensitive()),
+    );
+    // Re-normalize only when the configured limit changes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [inputHistoryLimit]);
+
+  const openReleaseTab = (tab: ActiveTab, route: ReleaseRoute) => {
+    const routeAccess = access[route];
+    if (!routeAccess.available) {
+      setNavigationNotice(routeAccess.reason);
+      return;
+    }
+    setNavigationNotice("");
+    setActiveTab(tab);
+  };
+
+  const loadHostDirectory = async (path: string, mode: SourcePathMode) => {
+    setHostBrowserLoading(true);
+    setHostBrowserError("");
+    try {
+      setHostBrowser(await hostBrowserClient.list(path, mode));
+    } catch (error) {
+      setHostBrowserError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setHostBrowserLoading(false);
+    }
+  };
+  const openHostBrowser = (mode: SourcePathMode) => {
+    setHostBrowserMode(mode);
+    setHostBrowserSearch("");
+    void loadHostDirectory(releaseSession.input.view.sourceDraft, mode);
+  };
+  const selectHostPath = (path: string, isDir: boolean) => {
+    if (!hostBrowserMode) return;
+    if ((hostBrowserMode === "folder" && !isDir) || (hostBrowserMode === "file" && isDir)) {
+      if (isDir) void loadHostDirectory(path, hostBrowserMode);
+      return;
+    }
+    releaseSession.input.updateSourceDraft(path);
+    releaseSession.input.selectSource(path);
+    rememberSource(path, hostBrowserMode);
+    setHostBrowserMode(null);
+    setActiveTab("input");
+  };
+  const visibleHostEntries = useMemo(
+    () => filterBrowseEntries(hostBrowser?.entries || [], hostBrowserSearch),
+    [hostBrowser?.entries, hostBrowserSearch],
+  );
+
+  const handleExportSettings = async () => {
+    clearSettingsStatus();
+    setConfigOpStatus(null);
+    setSettingsExporting(true);
+    try {
+      const file = await configClient.exportDownload();
+      setConfigOpStatus({ type: "success", title: "Configuration exported", message: file });
+    } catch (error) {
+      setConfigOpStatus({ type: "error", title: "Export failed", message: String(error) });
+    } finally {
+      setSettingsExporting(false);
+    }
+  };
+  const handleImportConfigConfirm = async () => {
+    setSettingsImporting(true);
+    try {
+      const result = await configClient.importFile();
+      if (result.message) {
+        setConfigOpStatus({
+          type: result.warnings.length ? "warning" : "success",
+          title: result.warnings.length ? "Imported with warnings" : "Configuration imported",
+          message: result.message,
+          warnings: result.warnings,
+        });
+        loadSettings();
+      }
+    } catch (error) {
+      setConfigOpStatus({ type: "error", title: "Import failed", message: String(error) });
+    } finally {
+      setSettingsImporting(false);
+      setImportConfirmOpen(false);
+    }
+  };
+
+  return (
+    <div className="app-shell">
+      <div className="gradient-orb orb-a" />
+      <div className="gradient-orb orb-b" />
+      <div className={appLayoutClass}>
+        <aside className={sidebarClass}>
+          <div className={sidebarGroupClass}>
+            <button
+              className={navButtonClass(activeTab === "input")}
+              type="button"
+              onClick={() => setActiveTab("input")}
+            >
+              Input
+            </button>
+            {hasTrackerData ? (
+              <button
+                className={navButtonClass(activeTab === "tracker", true)}
+                type="button"
+                disabled={!access.trackerData.available}
+                title={access.trackerData.reason}
+                onClick={() => openReleaseTab("tracker", "trackerData")}
+              >
+                Tracker Data
+              </button>
+            ) : null}
+            {hasBlurayData ? (
+              <button
+                className={navButtonClass(activeTab === "bluray", true)}
+                type="button"
+                onClick={() => setActiveTab("bluray")}
+              >
+                Blu-ray Candidates
+              </button>
+            ) : null}
+            <button
+              className={navButtonClass(activeTab === "dupes")}
+              type="button"
+              disabled={!access.duplicates.available}
+              title={access.duplicates.reason}
+              onClick={() => openReleaseTab("dupes", "duplicates")}
+            >
+              Dupe Check
+            </button>
+            <button
+              className={navButtonClass(activeTab === "screenshots")}
+              type="button"
+              disabled={!access.screenshots.available}
+              title={access.screenshots.reason}
+              onClick={() => openReleaseTab("screenshots", "screenshots")}
+            >
+              Screenshots
+            </button>
+            <button
+              className={navButtonClass(activeTab === "menu_images", true)}
+              type="button"
+              disabled={!access.menuImages.available}
+              title={access.menuImages.reason}
+              onClick={() => openReleaseTab("menu_images", "menuImages")}
+            >
+              Menu Images
+            </button>
+            <button
+              className={navButtonClass(activeTab === "upload_images", true)}
+              type="button"
+              disabled={!access.uploadedImages.available}
+              title={access.uploadedImages.reason}
+              onClick={() => openReleaseTab("upload_images", "uploadedImages")}
+            >
+              Upload Images
+            </button>
+            <button
+              className={navButtonClass(activeTab === "description_builder")}
+              type="button"
+              disabled={!access.descriptions.available}
+              title={access.descriptions.reason}
+              onClick={() => openReleaseTab("description_builder", "descriptions")}
+            >
+              Descriptions
+            </button>
+            <button
+              className={navButtonClass(activeTab === "upload")}
+              type="button"
+              disabled={!access.upload.available}
+              title={access.upload.reason}
+              onClick={() => openReleaseTab("upload", "upload")}
+            >
+              Upload
+            </button>
+          </div>
+          <div className={`${sidebarGroupClass} mt-auto max-[960px]:mt-0`}>
+            {jobNotifications.pending.length ? (
+              <span className="px-2 text-xs text-[var(--muted)]">
+                Pending jobs: {jobNotifications.pending.length}
+              </span>
+            ) : null}
+            <button
+              className={navButtonClass(activeTab === "history")}
+              type="button"
+              onClick={() => setActiveTab("history")}
+            >
+              History
+            </button>
+            <button
+              className={navButtonClass(activeTab === "settings")}
+              type="button"
+              onClick={() => setActiveTab("settings")}
+            >
+              Settings
+            </button>
+            <button
+              className={navButtonClass(activeTab === "logging")}
+              type="button"
+              onClick={() => setActiveTab("logging")}
+            >
+              Logging
+            </button>
+            <button
+              className={navButtonClass(false)}
+              type="button"
+              onClick={() => {
+                const modes: ThemeMode[] = ["auto", "light", "dark"];
+                const next = modes[(modes.indexOf(theme) + 1) % modes.length];
+                setTheme(next);
+                browserStorage()?.setItem("theme", next);
+              }}
+            >
+              Theme: {theme}
+            </button>
+          </div>
+        </aside>
+
+        <main className="content">
+          {navigationNotice ? (
+            <p className="muted" role="status">
+              {navigationNotice}
+            </p>
+          ) : null}
+          {activeTab === "settings" ? (
+            <SettingsPage
+              configData={configData}
+              settingsLoading={settingsLoading}
+              settingsExporting={settingsExporting}
+              settingsImporting={settingsImporting}
+              settingsDirty={settingsDirty}
+              settingsSaved={settingsSaved}
+              settingsError={settingsError}
+              configOpStatus={configOpStatus}
+              dismissConfigOpStatus={() => setConfigOpStatus(null)}
+              settingsSection={settingsSection}
+              settingsSections={settingsSections}
+              trackerSelectionNames={trackerSelectionNames}
+              showAdvancedToggle={showAdvancedToggle}
+              advancedOpen={advancedOpen}
+              setSettingsSection={setSettingsSection}
+              setSettingsAdvanced={setSettingsAdvanced}
+              loadSettings={loadSettings}
+              handleExportSettings={() => void handleExportSettings()}
+              handleImportConfig={() => setImportConfirmOpen(true)}
+              importConfirmOpen={importConfirmOpen}
+              handleImportConfigConfirm={handleImportConfigConfirm}
+              handleImportConfigCancel={() => !settingsImporting && setImportConfirmOpen(false)}
+              handleSaveSettings={handleSaveSettings}
+              renderImageHostingSection={renderImageHostingSection}
+              renderTrackerSection={renderTrackerSection}
+              renderTorrentClientsSection={renderTorrentClientsSection}
+              renderField={renderField}
+              sectionFieldMeta={sectionFieldMeta}
+            />
+          ) : activeTab === "logging" ? (
+            <LoggingPage
+              configData={configData}
+              settingsLoading={settingsLoading}
+              settingsDirty={settingsDirty}
+              settingsSaved={settingsSaved}
+              settingsError={settingsError}
+              loadSettings={loadSettings}
+              handleSaveSettings={handleSaveSettings}
+              renderField={renderField}
+              updateConfigValue={updateConfigValue}
+              sectionFieldMeta={sectionFieldMeta}
+            />
+          ) : activeTab === "history" ? (
+            <HistoryPage
+              onReleaseDeleted={(deletedPath) => {
+                if (deletedPath === sourcePath) releaseSession.input.selectSource("");
+              }}
+            />
+          ) : activeTab === "dupes" ? (
+            <DupeCheckPage
+              facet={releaseSession.duplicates}
+              sourcePath={sourcePath}
+              trackerUploadItems={trackerUploadItems}
+              useFavicons={useFavicons}
+              faviconOnly={faviconOnly}
+              trackerIconSrcByName={trackerIconSrcByName}
+            />
+          ) : activeTab === "screenshots" ? (
+            <ScreenshotsPage
+              facet={releaseSession.screenshots}
+              screenshotConfig={screenshotConfig}
+              updateScreenshotConfigValue={updateScreenshotConfigValue}
+              loadSettings={loadSettings}
+              settingsLoading={settingsLoading}
+              settingsDirty={settingsDirty}
+              settingsSaved={settingsSaved}
+              settingsError={settingsError}
+              applyScreenshotSettings={() => void handleSaveSettings()}
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+            />
+          ) : activeTab === "menu_images" ? (
+            <MenuImagesPage
+              facet={releaseSession.menuImages}
+              currentDiscType={currentDiscType}
+              maxMenuItems={maxMenuItems}
+              onContinue={() => openReleaseTab("upload_images", "uploadedImages")}
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+            />
+          ) : activeTab === "upload_images" ? (
+            <UploadImagesPage
+              facet={releaseSession.uploadedImages}
+              configuredImageHosts={configuredImageHosts}
+              resolveImageHostLabel={resolveImageHostLabel}
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+            />
+          ) : activeTab === "bluray" ? (
+            <BlurayCandidatesPage
+              facet={releaseSession.input}
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+            />
+          ) : activeTab === "description_builder" ? (
+            <DescriptionBuilderPage
+              facet={releaseSession.descriptions}
+              sourcePath={sourcePath}
+              useFavicons={useFavicons}
+              faviconOnly={faviconOnly}
+              trackerIconSrcByName={trackerIconSrcByName}
+            />
+          ) : activeTab === "upload" ? (
+            <TrackerUploadPage
+              facet={releaseSession.upload}
+              trackerUploadItems={trackerUploadItems}
+              useFavicons={useFavicons}
+              faviconOnly={faviconOnly}
+              trackerIconSrcByName={trackerIconSrcByName}
+            />
+          ) : activeTab === "tracker" ? (
+            <TrackerDataPage
+              facet={releaseSession.input}
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+              useFavicons={useFavicons}
+              faviconOnly={faviconOnly}
+              trackerIconSrcByName={trackerIconSrcByName}
+            />
+          ) : (
+            <InputPage
+              facet={releaseSession.input}
+              sourcePathHistory={sourcePathHistory}
+              handleBrowseFile={() => openHostBrowser("file")}
+              handleBrowseFolder={() => openHostBrowser("folder")}
+              trackerUploadItems={trackerUploadItems}
+              showExternalIDInputUI
+              setLightboxImage={setLightboxImage}
+              setLightboxAlt={setLightboxAlt}
+              useFavicons={useFavicons}
+              faviconOnly={faviconOnly}
+              trackerIconSrcByName={trackerIconSrcByName}
+            />
+          )}
+        </main>
+
+        <Dialog.Root
+          open={Boolean(lightboxImage)}
+          onOpenChange={(open) => {
+            if (!open) {
+              setLightboxImage("");
+              setLightboxAlt("");
+            }
+          }}
+        >
+          <Dialog.Portal>
+            <Dialog.Overlay className="dialog-overlay" />
+            <Dialog.Content className="lightbox-content">
+              <Dialog.Title className="sr-only">{lightboxAlt || "Image preview"}</Dialog.Title>
+              <Dialog.Description className="sr-only">
+                Expanded release image preview.
+              </Dialog.Description>
+              <img src={lightboxImage} alt={lightboxAlt} />
+              <Dialog.Close className="ghost" aria-label="Close image preview">
+                Close
+              </Dialog.Close>
+            </Dialog.Content>
+          </Dialog.Portal>
+        </Dialog.Root>
+
+        <Dialog.Root
+          open={Boolean(hostBrowserMode)}
+          onOpenChange={(open) => {
+            if (!open) setHostBrowserMode(null);
+          }}
+        >
+          <Dialog.Portal>
+            <Dialog.Overlay className="dialog-overlay" />
+            <Dialog.Content className="host-browser-dialog">
+              <Dialog.Title>Select {hostBrowserMode === "file" ? "file" : "folder"}</Dialog.Title>
+              <Dialog.Description className="sr-only">
+                Browse host paths allowed by WebUI policy.
+              </Dialog.Description>
+              <div className="flex flex-wrap gap-2">
+                <button
+                  className="ghost"
+                  type="button"
+                  disabled={!hostBrowser?.parentPath || hostBrowserLoading}
+                  onClick={() => {
+                    if (hostBrowserMode && hostBrowser?.parentPath)
+                      void loadHostDirectory(hostBrowser.parentPath, hostBrowserMode);
+                  }}
+                >
+                  Up
+                </button>
+                <input
+                  aria-label="Filter host paths"
+                  value={hostBrowserSearch}
+                  onChange={(event) => setHostBrowserSearch(event.target.value)}
+                  placeholder="Filter paths"
+                />
+                {hostBrowserMode === "folder" && hostBrowser?.currentPath ? (
+                  <button
+                    className="primary"
+                    type="button"
+                    onClick={() => selectHostPath(hostBrowser.currentPath, true)}
+                  >
+                    Select current folder
+                  </button>
+                ) : null}
+              </div>
+              {hostBrowserError ? (
+                <p className="error" role="alert">
+                  {hostBrowserError}
+                </p>
+              ) : null}
+              <div className="host-browser-list">
+                {hostBrowserLoading ? (
+                  <p className="muted">Loading...</p>
+                ) : (
+                  visibleHostEntries.map((entry) => (
+                    <button
+                      className="host-browser-entry"
+                      type="button"
+                      key={entry.path}
+                      onClick={() => selectHostPath(entry.path, entry.isDir)}
+                    >
+                      <span>{entry.isDir ? "Folder" : "File"}</span>
+                      <span className="mono">{entry.path}</span>
+                    </button>
+                  ))
+                )}
+              </div>
+              <Dialog.Close className="ghost">Cancel</Dialog.Close>
+            </Dialog.Content>
+          </Dialog.Portal>
+        </Dialog.Root>
+      </div>
+    </div>
+  );
+}
+
+/** Composes owner Job registry and active release session around the shell. */
+export default function App({ jobOwnerKey = "standalone" }: Readonly<{ jobOwnerKey?: string }>) {
+  return (
+    <JobRegistryProvider ownerKey={jobOwnerKey}>
+      <TrackerCatalogProvider>
+        <ReleaseSessionProvider>
+          <AppShell />
+        </ReleaseSessionProvider>
+      </TrackerCatalogProvider>
+    </JobRegistryProvider>
+  );
+}
diff --git a/webui/src/components/LogSettingsPanel.test.tsx b/webui/src/components/LogSettingsPanel.test.tsx
new file mode 100644
index 00000000..7d2606f5
--- /dev/null
+++ b/webui/src/components/LogSettingsPanel.test.tsx
@@ -0,0 +1,165 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { screen, waitFor } from "@testing-library/dom";
+import { cleanup, render } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import LogSettingsPanel from "./LogSettingsPanel";
+import { loggingClient } from "../api/app";
+import { subscribeWebEvent } from "../api/client";
+
+vi.mock("../api/app", () => ({
+  loggingClient: {
+    getPath: vi.fn(),
+    getRecent: vi.fn(),
+    getExclusions: vi.fn(),
+    startStream: vi.fn(),
+    stopStream: vi.fn(),
+    updateExclusions: vi.fn(),
+  },
+}));
+
+vi.mock("../api/client", () => ({
+  subscribeWebEvent: vi.fn(() => vi.fn()),
+}));
+
+const installLogAPI = () => {
+  vi.mocked(loggingClient.getPath).mockResolvedValue("C:/logs/upbrr.log");
+  vi.mocked(loggingClient.getRecent).mockResolvedValue([]);
+  vi.mocked(loggingClient.getExclusions).mockResolvedValue([]);
+  vi.mocked(loggingClient.startStream).mockResolvedValue("stream-1");
+  vi.mocked(loggingClient.stopStream).mockResolvedValue(undefined);
+  vi.mocked(loggingClient.updateExclusions).mockResolvedValue(undefined);
+};
+
+describe("LogSettingsPanel", () => {
+  afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+  });
+
+  it("renders log path and updates logging level", async () => {
+    installLogAPI();
+    const updateConfigValue = vi.fn();
+
+    render(
+      <LogSettingsPanel
+        configData={{ Logging: { Level: "info" } }}
+        fieldMeta={{ Level: { label: "Verbosity" } }}
+        renderField={(label) => <div key={label}>{label}</div>}
+        updateConfigValue={updateConfigValue}
+      />,
+    );
+
+    await waitFor(() => expect(screen.getByText("C:/logs/upbrr.log")).toBeInTheDocument());
+
+    await userEvent.selectOptions(screen.getByLabelText("Verbosity"), "debug");
+
+    expect(updateConfigValue).toHaveBeenCalledWith(["Logging", "Level"], "debug");
+  });
+
+  it("keeps distinct rows when a restarted log stream reuses IDs", async () => {
+    installLogAPI();
+    vi.mocked(loggingClient.getRecent).mockResolvedValueOnce([
+      {
+        ID: 1,
+        Time: "2026-06-15T00:00:00.000Z",
+        Level: "info",
+        Message: "before restart",
+      },
+    ]);
+    vi.mocked(loggingClient.getRecent).mockResolvedValueOnce([
+      {
+        ID: 1,
+        Time: "2026-06-15T00:01:00.000Z",
+        Level: "info",
+        Message: "after restart",
+      },
+    ]);
+
+    render(
+      <LogSettingsPanel
+        configData={{ Logging: { Level: "info" } }}
+        fieldMeta={{ Level: { label: "Verbosity" } }}
+        renderField={(label) => <div key={label}>{label}</div>}
+        updateConfigValue={vi.fn()}
+      />,
+    );
+
+    await waitFor(() => expect(screen.getByText("before restart")).toBeInTheDocument());
+    await waitFor(() => expect(screen.getByText("after restart")).toBeInTheDocument());
+  });
+
+  it("dedupes exact recent/live overlap rows", async () => {
+    installLogAPI();
+    const row = {
+      ID: 2,
+      Time: "2026-06-15T00:00:00.000Z",
+      Level: "info",
+      Message: "overlap",
+    };
+    vi.mocked(loggingClient.getRecent).mockResolvedValue([row]);
+    vi.mocked(subscribeWebEvent).mockImplementationOnce((_eventName, callback) => {
+      callback(row);
+      return vi.fn();
+    });
+
+    render(
+      <LogSettingsPanel
+        configData={{ Logging: { Level: "info" } }}
+        fieldMeta={{ Level: { label: "Verbosity" } }}
+        renderField={(label) => <div key={label}>{label}</div>}
+        updateConfigValue={vi.fn()}
+      />,
+    );
+
+    await waitFor(() => expect(subscribeWebEvent).toHaveBeenCalled());
+    await waitFor(() => expect(screen.getAllByText("overlap")).toHaveLength(1));
+  });
+
+  it("does not restart the log stream when auto-scroll changes", async () => {
+    installLogAPI();
+
+    render(
+      <LogSettingsPanel
+        configData={{ Logging: { Level: "info" } }}
+        fieldMeta={{ Level: { label: "Verbosity" } }}
+        renderField={(label) => <div key={label}>{label}</div>}
+        updateConfigValue={vi.fn()}
+      />,
+    );
+
+    await waitFor(() => expect(loggingClient.startStream).toHaveBeenCalledTimes(1));
+
+    await userEvent.click(screen.getByLabelText("Auto-scroll logs"));
+
+    expect(loggingClient.stopStream).not.toHaveBeenCalled();
+    expect(loggingClient.startStream).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops a started stream when event subscription fails", async () => {
+    installLogAPI();
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    vi.mocked(subscribeWebEvent).mockImplementationOnce(() => {
+      throw new Error("subscribe failed");
+    });
+
+    render(
+      <LogSettingsPanel
+        configData={{ Logging: { Level: "info" } }}
+        fieldMeta={{ Level: { label: "Verbosity" } }}
+        renderField={(label) => <div key={label}>{label}</div>}
+        updateConfigValue={vi.fn()}
+      />,
+    );
+
+    try {
+      await waitFor(() => expect(loggingClient.stopStream).toHaveBeenCalledWith("stream-1"));
+      expect(consoleError).toHaveBeenCalledWith("Failed to start log stream", expect.any(Error));
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+});
diff --git a/gui/frontend/src/components/LogSettingsPanel.tsx b/webui/src/components/LogSettingsPanel.tsx
similarity index 95%
rename from gui/frontend/src/components/LogSettingsPanel.tsx
rename to webui/src/components/LogSettingsPanel.tsx
index ed30b567..dad009a6 100644
--- a/gui/frontend/src/components/LogSettingsPanel.tsx
+++ b/webui/src/components/LogSettingsPanel.tsx
@@ -4,8 +4,9 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Checkbox } from "./ui/checkbox";
 import { Switch } from "./ui/switch";
+import { loggingClient } from "../api/app";
+import { subscribeWebEvent } from "../api/client";
 import { cn } from "../utils/cn";
-import { EventsOn } from "../utils/runtime";
 
 type LogEntry = {
   ID: number;
@@ -120,8 +121,7 @@ export default function LogSettingsPanel({
   }, [autoScroll]);
 
   const persistMuted = async (patterns: string[]) => {
-    const updater = globalThis.go?.guiapp?.App?.UpdateLogExclusions;
-    if (!updater) return;
+    const updater = loggingClient.updateExclusions;
     try {
       await updater(patterns);
     } catch (err) {
@@ -157,8 +157,7 @@ export default function LogSettingsPanel({
   /** Backfills buffered log entries only while the caller's effect is still active. */
   const fetchRecentLogs = useCallback(
     async (isActive: () => boolean = () => true) => {
-      const getRecent = globalThis.go?.guiapp?.App?.GetRecentLogs;
-      if (!getRecent) return;
+      const getRecent = loggingClient.getRecent;
       try {
         const payload = await getRecent(LOG_SOFT_CAP);
         if (!isActive()) return;
@@ -175,8 +174,7 @@ export default function LogSettingsPanel({
 
   useEffect(() => {
     const fetchLogPath = async () => {
-      const getLogPath = globalThis.go?.guiapp?.App?.GetLogPath;
-      if (!getLogPath) return;
+      const getLogPath = loggingClient.getPath;
       try {
         const path = await getLogPath();
         setLogPath(path);
@@ -197,8 +195,7 @@ export default function LogSettingsPanel({
 
   useEffect(() => {
     const fetchMuted = async () => {
-      const getter = globalThis.go?.guiapp?.App?.GetLogExclusions;
-      if (!getter) return;
+      const getter = loggingClient.getExclusions;
       try {
         const patterns = await getter();
         if (Array.isArray(patterns)) {
@@ -214,9 +211,8 @@ export default function LogSettingsPanel({
   useEffect(() => {
     let active = true;
     const startStream = async () => {
-      const start = globalThis.go?.guiapp?.App?.StartLogStream;
-      const stop = globalThis.go?.guiapp?.App?.StopLogStream;
-      if (!start) return;
+      const start = loggingClient.startStream;
+      const stop = loggingClient.stopStream;
       // Tracks a stream that exists before event subscription cleanup is installed.
       let pendingStreamID = "";
 
@@ -225,27 +221,25 @@ export default function LogSettingsPanel({
         pendingStreamID = streamID;
         if (!active) {
           pendingStreamID = "";
-          if (stop) await stop(streamID);
+          await stop(streamID);
           return;
         }
         const eventName = `log:stream:${streamID}`;
-        const off = EventsOn(eventName, (payload: any) => {
+        const off = subscribeWebEvent(eventName, (payload: any) => {
           const entry = normalizeEntry(payload);
           if (entry) appendEntries([entry]);
         });
         setConnected(true);
         streamStopRef.current = () => {
           off();
-          if (stop) {
-            stop(streamID).catch(() => undefined);
-          }
+          stop(streamID).catch(() => undefined);
         };
         pendingStreamID = "";
         // Backfill after subscribing to cover entries emitted between
         // StartLogStream resolving and the event listener attaching.
         await fetchRecentLogs(() => active);
       } catch (err) {
-        if (pendingStreamID && stop) {
+        if (pendingStreamID) {
           await stop(pendingStreamID).catch(() => undefined);
         }
         setConnected(false);
diff --git a/webui/src/components/RenderedDescription.test.tsx b/webui/src/components/RenderedDescription.test.tsx
new file mode 100644
index 00000000..7f254edd
--- /dev/null
+++ b/webui/src/components/RenderedDescription.test.tsx
@@ -0,0 +1,59 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import RenderedDescription from "./RenderedDescription";
+
+describe("RenderedDescription external links", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("marks rendered links to open in a new tab", () => {
+    render(<RenderedDescription html='<a href="https://example.com/image">View image</a>' />);
+
+    const link = screen.getByRole("link", { name: "View image" });
+
+    expect(link).toHaveAttribute("target", "_blank");
+    expect(link).toHaveAttribute("rel", "noreferrer");
+  });
+
+  it("opens web UI links in a new tab", () => {
+    const open = vi.spyOn(window, "open").mockImplementation(() => null);
+    render(<RenderedDescription html='<a href="https://example.com/torrent">Torrent</a>' />);
+
+    fireEvent.click(screen.getByRole("link", { name: "Torrent" }));
+
+    expect(open).toHaveBeenCalledWith(
+      "https://example.com/torrent",
+      "_blank",
+      "noopener,noreferrer",
+    );
+  });
+
+  it("routes aux-clicks through the same external-link handling", () => {
+    const open = vi.spyOn(window, "open").mockImplementation(() => null);
+    render(<RenderedDescription html='<a href="https://example.com/raw">Raw URL</a>' />);
+
+    fireEvent(
+      screen.getByRole("link", { name: "Raw URL" }),
+      new MouseEvent("auxclick", { bubbles: true, button: 1 }),
+    );
+
+    expect(open).toHaveBeenCalledWith("https://example.com/raw", "_blank", "noopener,noreferrer");
+  });
+
+  it("blocks relative links instead of opening them against the app origin", () => {
+    const open = vi.spyOn(window, "open").mockImplementation(() => null);
+    render(<RenderedDescription html='<a href="/relative/release">Relative release</a>' />);
+
+    const event = new MouseEvent("click", { bubbles: true, cancelable: true });
+    const dispatched = screen.getByRole("link", { name: "Relative release" }).dispatchEvent(event);
+
+    expect(dispatched).toBe(false);
+    expect(event.defaultPrevented).toBe(true);
+    expect(open).not.toHaveBeenCalled();
+  });
+});
diff --git a/gui/frontend/src/components/RenderedDescription.tsx b/webui/src/components/RenderedDescription.tsx
similarity index 100%
rename from gui/frontend/src/components/RenderedDescription.tsx
rename to webui/src/components/RenderedDescription.tsx
diff --git a/gui/frontend/src/components/ui/badge.tsx b/webui/src/components/ui/badge.tsx
similarity index 100%
rename from gui/frontend/src/components/ui/badge.tsx
rename to webui/src/components/ui/badge.tsx
diff --git a/gui/frontend/src/components/ui/button.tsx b/webui/src/components/ui/button.tsx
similarity index 100%
rename from gui/frontend/src/components/ui/button.tsx
rename to webui/src/components/ui/button.tsx
diff --git a/gui/frontend/src/components/ui/checkbox.tsx b/webui/src/components/ui/checkbox.tsx
similarity index 100%
rename from gui/frontend/src/components/ui/checkbox.tsx
rename to webui/src/components/ui/checkbox.tsx
diff --git a/gui/frontend/src/components/ui/switch.tsx b/webui/src/components/ui/switch.tsx
similarity index 100%
rename from gui/frontend/src/components/ui/switch.tsx
rename to webui/src/components/ui/switch.tsx
diff --git a/gui/frontend/src/components/ui/tracker-icon.tsx b/webui/src/components/ui/tracker-icon.tsx
similarity index 100%
rename from gui/frontend/src/components/ui/tracker-icon.tsx
rename to webui/src/components/ui/tracker-icon.tsx
diff --git a/webui/src/display.contract.test.ts b/webui/src/display.contract.test.ts
new file mode 100644
index 00000000..68bc30c0
--- /dev/null
+++ b/webui/src/display.contract.test.ts
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { describe, expect, it } from "vitest";
+
+import fixture from "../../pkg/api/testdata/prepared_release_display.json";
+import type { PreparedReleaseDisplay } from "./types";
+
+describe("prepared release display contract", () => {
+  it("consumes the canonical five-provider fixture as an exhaustive typed union", () => {
+    const display = fixture as PreparedReleaseDisplay;
+    expect(display.Providers.map((provider) => provider.Provider)).toEqual([
+      "tmdb",
+      "imdb",
+      "tvdb",
+      "tvmaze",
+      "mal",
+    ]);
+    for (const provider of display.Providers) {
+      switch (provider.Provider) {
+        case "tmdb":
+          expect(provider.Details.TMDB.TMDBID).toBe(provider.ID);
+          break;
+        case "imdb":
+          expect(provider.Details.IMDB.IMDBID).toBe(provider.ID);
+          break;
+        case "tvdb":
+          expect(provider.Details.TVDB.TVDBID).toBe(provider.ID);
+          break;
+        case "tvmaze":
+          expect(provider.Details.TVmaze.TVmazeID).toBe(provider.ID);
+          break;
+        case "mal":
+          expect(provider.Details.AniList.MALID).toBe(provider.ID);
+          break;
+      }
+    }
+  });
+});
diff --git a/webui/src/hooks/useSettingsState.test.ts b/webui/src/hooks/useSettingsState.test.ts
new file mode 100644
index 00000000..d78febb0
--- /dev/null
+++ b/webui/src/hooks/useSettingsState.test.ts
@@ -0,0 +1,1467 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { createElement } from "react";
+import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
+import { installAppOperationMocks } from "../test/appRequestMock";
+import type { ConfigValue, TrackerCatalog, TrackerCatalogEntry } from "../types";
+
+import {
+  nextQbitDirectState,
+  normalizeTorrentClientForSave,
+  normalizeTorrentClientsForSave,
+  useSettingsState,
+} from "./useSettingsState";
+
+afterEach(() => {
+  cleanup();
+  latestPayload = "";
+});
+
+describe("normalizeTorrentClientForSave", () => {
+  it("preserves watch client fields", () => {
+    expect(
+      normalizeTorrentClientForSave({
+        Type: "watch",
+        WatchFolder: "/watch",
+        StorageDir: "/storage",
+      }),
+    ).toEqual({
+      Type: "watch",
+      WatchFolder: "/watch",
+      StorageDir: "/storage",
+    });
+  });
+
+  it("migrates legacy qbit fields and removes aliases", () => {
+    expect(
+      normalizeTorrentClientForSave({
+        TorrentClient: "qbit",
+        URL: "http://localhost:8080",
+        Username: "user",
+        Password: "secret",
+        Category: "movies",
+        Tags: ["AITHER", "BLU"],
+      }),
+    ).toEqual({
+      QbitURL: "http://localhost:8080",
+      QbitUser: "user",
+      QbitPass: "secret",
+      QbitCategoryValue: "movies",
+      QbitTag: "AITHER,BLU",
+    });
+  });
+
+  it("maps legacy TLS skip verify to certificate verification before removing aliases", () => {
+    expect(
+      normalizeTorrentClientForSave({
+        TorrentClient: "qbit",
+        TLSSkipVerify: true,
+      }),
+    ).toEqual({
+      VerifyWebUICertificate: false,
+    });
+  });
+});
+
+describe("normalizeTorrentClientsForSave", () => {
+  it("normalizes each configured client without dropping watch-folder config", () => {
+    expect(
+      normalizeTorrentClientsForSave({
+        TorrentClients: {
+          qbit: {
+            Type: "qbit",
+            URL: "http://localhost:8080",
+            Username: "user",
+            Password: "secret",
+          },
+          watch: {
+            Type: "watch",
+            WatchFolder: "/watch",
+            StorageDir: "/storage",
+          },
+        },
+      }),
+    ).toEqual({
+      TorrentClients: {
+        qbit: {
+          QbitURL: "http://localhost:8080",
+          QbitUser: "user",
+          QbitPass: "secret",
+        },
+        watch: {
+          Type: "watch",
+          WatchFolder: "/watch",
+          StorageDir: "/storage",
+        },
+      },
+    });
+  });
+});
+
+describe("nextQbitDirectState", () => {
+  it("clears proxy and direct credentials when qbit direct is disabled", () => {
+    expect(
+      nextQbitDirectState(
+        {
+          QuiProxyURL: "http://proxy.local",
+          QbitURL: "http://localhost:8080",
+          QbitPort: 8080,
+          QbitUser: "user",
+          QbitPass: "secret",
+          URL: "http://legacy.local",
+          Username: "legacy-user",
+          Password: "legacy-pass",
+        },
+        false,
+      ),
+    ).toEqual({
+      QuiProxyURL: "",
+      QbitURL: "",
+      QbitPort: 0,
+      QbitUser: "",
+      QbitPass: "",
+      URL: "",
+      Username: "",
+      Password: "",
+    });
+  });
+});
+
+function TorrentClientsHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+
+  return createElement(
+    "div",
+    null,
+    state.renderTorrentClientsSection(false),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+function ClientSetupHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+  const clientSetup = state.configData?.ClientSetup;
+
+  if (!clientSetup || typeof clientSetup !== "object" || Array.isArray(clientSetup)) {
+    return createElement("div", null);
+  }
+
+  const meta = state.sectionFieldMeta.ClientSetup ?? {};
+
+  return createElement(
+    "div",
+    null,
+    ...Object.entries(clientSetup).map(([key, value]) =>
+      state.renderField(key, value, ["ClientSetup", key], meta[key]),
+    ),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+function TrackerSettingsHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+
+  return createElement(
+    "div",
+    null,
+    state.renderTrackerSection(false),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+function TrackerSettingsAdvancedHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+
+  return createElement(
+    "div",
+    null,
+    state.renderTrackerSection(true),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+function TrackerSettingsErrorHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+  return createElement("div", null, state.settingsError);
+}
+
+function InputTrackerSelectionHarness() {
+  const state = useSettingsState({ activeTab: "input" });
+  return createElement(
+    "div",
+    { "data-testid": "tracker-selection" },
+    state.trackerSelectionNames.join(","),
+  );
+}
+
+function ImageHostingHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+
+  return createElement(
+    "div",
+    null,
+    state.renderImageHostingSection(),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+function ScreenshotSettingsHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+  const config = state.screenshotConfig;
+  if (!config) {
+    return createElement("div");
+  }
+  return createElement(
+    "div",
+    null,
+    state.renderField(
+      "MaxMenuItems",
+      config.MaxMenuItems,
+      ["ScreenshotHandling", "MaxMenuItems"],
+      state.sectionFieldMeta.ScreenshotHandling?.MaxMenuItems,
+    ),
+    createElement(PayloadCapture, { value: state.buildSavePayload() }),
+  );
+}
+
+let latestPayload = "";
+
+type TestTrackerField = [key: string, defaultValue: ConfigValue, activation?: boolean];
+
+/** Builds a typed tracker-catalog fixture without tracker-name logic in the hook. */
+function trackerCatalogEntry(
+  name: string,
+  fields: TestTrackerField[],
+  configured = false,
+  family: TrackerCatalogEntry["family"] = "unit3d",
+): TrackerCatalogEntry {
+  return {
+    name,
+    family,
+    baseURL: `https://${name.toLowerCase()}.example.invalid`,
+    uploadContentMode: "description",
+    configured,
+    fields: fields.map(([key, defaultValue, activation = false]) => ({
+      key,
+      yamlKey: key,
+      default: defaultValue,
+      activation,
+    })),
+  };
+}
+
+/** Wraps catalog entries in the backend response shape. */
+function trackerCatalog(...entries: TrackerCatalogEntry[]): TrackerCatalog {
+  return { entries, unsupported: [] };
+}
+
+/** Captures save payloads without rendering secret-shaped values into DOM snapshots. */
+function PayloadCapture({ value }: { value: string | null }) {
+  latestPayload = value ?? "";
+  return null;
+}
+
+/** Parses the latest captured payload for focused assertions outside matcher output. */
+function readPayload<T>() {
+  return JSON.parse(latestPayload || "{}") as T;
+}
+
+function AdvancedFieldMetaHarness() {
+  const state = useSettingsState({ activeTab: "settings" });
+  const advancedBySection = Object.fromEntries(
+    Object.entries(state.sectionFieldMeta).map(([section, fields]) => [
+      section,
+      Object.values(fields)
+        .filter((field) => field.advanced)
+        .map((field) => field.key)
+        .sort(),
+    ]),
+  );
+
+  return createElement(
+    "pre",
+    { "data-testid": "advanced-fields" },
+    JSON.stringify(advancedBySection),
+  );
+}
+
+describe("settings advanced fields", () => {
+  it("matches the configured per-section advanced allowlist", () => {
+    render(createElement(AdvancedFieldMetaHarness));
+
+    const advancedBySection = JSON.parse(
+      screen.getByTestId("advanced-fields").textContent ?? "{}",
+    ) as Record<string, string[]>;
+
+    expect(advancedBySection.MainSettings).toEqual([]);
+    expect(advancedBySection.Metadata).toEqual([
+      "BTNAPI",
+      "BlurayScore",
+      "BluraySingleScore",
+      "CheckPredb",
+      "SkipAutoTorrent",
+      "SkipTrackerFilenameLookup",
+      "UserOverrides",
+    ]);
+    expect(advancedBySection.ScreenshotHandling).toEqual([
+      "Desat",
+      "FFmpegCompression",
+      "FFmpegLimit",
+      "MaxConcurrentUploads",
+      "ProcessLimit",
+      "TonemapAlgorithm",
+    ]);
+    expect(advancedBySection.Description).toEqual([
+      "CharLimit",
+      "CustomSignature",
+      "FileLimit",
+      "LogoLanguage",
+      "LogoSize",
+      "ProcessLimit",
+    ]);
+    expect(advancedBySection.PostUpload).toEqual(["InjectDelay", "MaxConcurrentTrackers"]);
+    expect(advancedBySection.TorrentCreation).toEqual([]);
+    expect(advancedBySection.TorrentClients).toEqual(["VerifyWebUICertificate"]);
+  });
+});
+
+describe("DVD menu screenshot settings", () => {
+  it("loads the default maximum and preserves edits in the save payload", async () => {
+    installAppOperationMocks({
+      GetConfig: async () => JSON.stringify({ ScreenshotHandling: { MaxMenuItems: 6 } }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(ScreenshotSettingsHarness));
+    const input = await screen.findByLabelText("Maximum DVD menu images");
+    expect(input).toHaveValue(6);
+    fireEvent.change(input, { target: { value: "8" } });
+    await waitFor(() => {
+      const payload = readPayload<{ ScreenshotHandling?: { MaxMenuItems?: number } }>();
+      expect(payload.ScreenshotHandling?.MaxMenuItems).toBe(8);
+    });
+  });
+});
+
+describe("renderTorrentClientsSection", () => {
+  it("renders watch client fields and preserves qbit clients on update", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          TorrentClients: {
+            watcher: {
+              Type: "watch",
+              WatchFolder: "/watch",
+              StorageDir: "/storage",
+            },
+            qbit: {
+              Type: "qbit",
+              QbitURL: "http://localhost:8080",
+              QbitUser: "user",
+              QbitPass: "secret",
+              AutomaticManagementPaths: ["/media"],
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TorrentClientsHarness));
+
+    await waitFor(() => expect(screen.getByText("watcher")).toBeInTheDocument());
+
+    const watchCard = screen.getByText("watcher").closest(".settings-card");
+    const qbitCard = screen.getByText("qbit").closest(".settings-card");
+    expect(watchCard).toBeTruthy();
+    expect(qbitCard).toBeTruthy();
+
+    const watchScope = within(watchCard as HTMLElement);
+    const qbitScope = within(qbitCard as HTMLElement);
+
+    expect(watchScope.getByLabelText("Type")).toHaveValue("watch");
+    expect(watchScope.getByLabelText("Watch folder")).toHaveValue("/watch");
+    expect(watchScope.getByLabelText("Storage directory")).toHaveValue("/storage");
+    expect(qbitScope.getByLabelText("qBit URL")).toHaveValue("http://localhost:8080");
+    expect(qbitScope.getByLabelText("Automatic management paths 1")).toHaveValue("/media");
+    expect(qbitScope.getByRole("button", { name: "Add Linked folder item" })).toBeInTheDocument();
+    expect(qbitScope.getByRole("button", { name: "Add Local path item" })).toBeInTheDocument();
+    expect(qbitScope.getByRole("button", { name: "Add Remote path item" })).toBeInTheDocument();
+    expect(
+      qbitScope.getByRole("button", { name: "Add Automatic management paths item" }),
+    ).toBeInTheDocument();
+    expect(qbitScope.getByLabelText("qBit direct")).toBeChecked();
+
+    fireEvent.change(watchScope.getByLabelText("Watch folder"), {
+      target: { value: "/watch/new" },
+    });
+
+    await waitFor(() =>
+      expect(watchScope.getByLabelText("Watch folder")).toHaveValue("/watch/new"),
+    );
+
+    const payload = readPayload<{
+      TorrentClients?: Record<string, Record<string, unknown>>;
+    }>();
+    expect(payload.TorrentClients?.watcher).toEqual({
+      Type: "watch",
+      WatchFolder: "/watch/new",
+      StorageDir: "/storage",
+    });
+    expect(payload.TorrentClients?.qbit).toMatchObject({
+      QbitURL: "http://localhost:8080",
+      QbitUser: "user",
+      QbitPass: "secret",
+      AutomaticManagementPaths: ["/media"],
+    });
+  });
+});
+
+describe("ClientSetup client selectors", () => {
+  it("renders default client empty option without a none sentinel", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ClientSetup: {
+            DefaultClient: "",
+          },
+          TorrentClients: {
+            qbit: {
+              Type: "qbit",
+              QbitURL: "http://localhost:8080",
+              QbitUser: "user",
+              QbitPass: "secret",
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(ClientSetupHarness));
+
+    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue(""));
+
+    const defaultClientSelect = screen.getByLabelText("Default client") as HTMLSelectElement;
+    expect(Array.from(defaultClientSelect.options).map((option) => option.value)).toEqual([
+      "",
+      "qbit",
+    ]);
+    expect(Array.from(defaultClientSelect.options).map((option) => option.textContent)).toEqual([
+      "",
+      "qbit",
+    ]);
+
+    fireEvent.change(defaultClientSelect, { target: { value: "qbit" } });
+    await waitFor(() => expect(defaultClientSelect).toHaveValue("qbit"));
+
+    fireEvent.change(defaultClientSelect, { target: { value: "" } });
+    await waitFor(() => expect(defaultClientSelect).toHaveValue(""));
+
+    const payload = readPayload<{
+      ClientSetup?: { DefaultClient?: string };
+    }>();
+    expect(payload.ClientSetup?.DefaultClient).toBe("");
+  });
+
+  it("renders default, injected, and searching clients as torrent client dropdowns", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ClientSetup: {
+            DefaultClient: "qbit",
+            InjectClients: ["qbit"],
+            SearchClients: ["watcher"],
+          },
+          TorrentClients: {
+            qbit: {
+              Type: "qbit",
+              QbitURL: "http://localhost:8080",
+              QbitUser: "user",
+              QbitPass: "secret",
+            },
+            watcher: {
+              Type: "watch",
+              WatchFolder: "/watch",
+              StorageDir: "/storage",
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(ClientSetupHarness));
+
+    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue("qbit"));
+
+    expect(screen.getByLabelText("Injected clients 1")).toHaveValue("qbit");
+    expect(screen.getByLabelText("Searching clients 1")).toHaveValue("watcher");
+
+    fireEvent.change(screen.getByLabelText("Default client"), {
+      target: { value: "watcher" },
+    });
+    fireEvent.change(screen.getByLabelText("Injected clients 1"), {
+      target: { value: "watcher" },
+    });
+
+    await waitFor(() => expect(screen.getByLabelText("Default client")).toHaveValue("watcher"));
+
+    const payload = readPayload<{
+      ClientSetup?: {
+        DefaultClient?: string;
+        InjectClients?: string[];
+        SearchClients?: string[];
+      };
+    }>();
+    expect(payload.ClientSetup?.DefaultClient).toBe("watcher");
+    expect(payload.ClientSetup?.InjectClients).toEqual(["watcher"]);
+    expect(payload.ClientSetup?.SearchClients).toEqual(["watcher"]);
+  });
+});
+
+describe("Tracker client selectors", () => {
+  it("renders CZT passkey field without preserving stale URL or API key", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              CZT: {
+                LinkDirName: "",
+                URL: "https://czteam.example",
+                APIKey: "service-token",
+                AnnounceURL: "https://czteam.me/announce.php?passkey=stale",
+                Passkey: "user-passkey",
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("CZT", [
+            ["LinkDirName", ""],
+            ["Passkey", "", true],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("CZT", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("CZT", { selector: ".settings-card__summary-name" }));
+
+    expect(screen.queryByLabelText("URL")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("API key")).not.toBeInTheDocument();
+    expect(screen.getByLabelText("Passkey")).toHaveValue("[REDACTED]");
+
+    const payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.CZT).toMatchObject({
+      Passkey: "user-passkey",
+    });
+    expect(payload.Trackers?.Trackers?.CZT?.URL).toBeUndefined();
+    expect(payload.Trackers?.Trackers?.CZT?.APIKey).toBeUndefined();
+    expect(payload.Trackers?.Trackers?.CZT?.AnnounceURL).toBeUndefined();
+  });
+
+  it("creates CZT entries with passkey defaults", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {},
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("CZT", [
+            ["LinkDirName", ""],
+            ["Passkey", "", true],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() => expect(screen.getAllByRole("combobox").length).toBeGreaterThan(0));
+
+    const trackerSelects = screen.getAllByRole("combobox");
+    const trackerSelect = trackerSelects[trackerSelects.length - 1] as HTMLSelectElement;
+    fireEvent.change(trackerSelect, { target: { value: "CZT" } });
+    fireEvent.click(screen.getByRole("button", { name: "Add entry" }));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("CZT", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+
+    const payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.CZT).toMatchObject({
+      Passkey: "",
+    });
+    expect(payload.Trackers?.Trackers?.CZT?.URL).toBeUndefined();
+    expect(payload.Trackers?.Trackers?.CZT?.APIKey).toBeUndefined();
+  });
+
+  it("renders tracker torrent client as a configured client dropdown", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              AITHER: {
+                LinkDirName: "",
+                APIKey: "tracker-token",
+                ImageHost: "",
+                TorrentClient: "qbit",
+                Anon: false,
+              },
+            },
+          },
+          TorrentClients: {
+            qbit: {
+              Type: "qbit",
+              QbitURL: "http://localhost:8080",
+              QbitUser: "user",
+              QbitPass: "secret",
+            },
+            watcher: {
+              Type: "watch",
+              WatchFolder: "/watch",
+              StorageDir: "/storage",
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("AITHER", [
+            ["LinkDirName", ""],
+            ["APIKey", "", true],
+            ["ImageHost", ""],
+            ["TorrentClient", ""],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsAdvancedHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("AITHER", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("AITHER", { selector: ".settings-card__summary-name" }));
+
+    await waitFor(() => expect(screen.getByLabelText("Torrent client")).toHaveValue("qbit"));
+
+    const torrentClientSelect = screen.getByLabelText("Torrent client") as HTMLSelectElement;
+    expect(Array.from(torrentClientSelect.options).map((option) => option.textContent)).toEqual([
+      "",
+      "qbit",
+      "watcher",
+    ]);
+
+    fireEvent.change(screen.getByLabelText("Torrent client"), {
+      target: { value: "watcher" },
+    });
+
+    await waitFor(() => expect(screen.getByLabelText("Torrent client")).toHaveValue("watcher"));
+
+    const payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.AITHER?.TorrentClient).toBe("watcher");
+  });
+
+  it("does not treat catalog tracker entries or default tracker membership as enabled config", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: ["AITHER", "BLU", "BHD"],
+            PreferredTracker: "",
+            Trackers: {
+              AITHER: {
+                APIKey: "",
+                Anon: false,
+              },
+              BLU: {
+                APIKey: "",
+                Anon: false,
+              },
+              BHD: {
+                APIKey: "tracker-token",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: ["AITHER", "BLU", "BHD"],
+            PreferredTracker: "",
+            Trackers: {
+              AITHER: {
+                APIKey: "",
+                Anon: false,
+              },
+              BLU: {
+                APIKey: "",
+                Anon: false,
+              },
+              BHD: {
+                APIKey: "",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          ...["AITHER", "BLU", "BHD"].map((name) =>
+            trackerCatalogEntry(name, [
+              ["APIKey", "", true],
+              ["Anon", false],
+            ]),
+          ),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("BHD", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+
+    expect(screen.queryByText("AITHER", { selector: ".settings-card__summary-name" })).toBeNull();
+    expect(screen.queryByText("BLU", { selector: ".settings-card__summary-name" })).toBeNull();
+    expect(screen.getByText("1/1")).toBeInTheDocument();
+  });
+
+  it("masks encrypted tracker credentials and preserves them for saves", async () => {
+    const encryptedAPIKey = "upbrr-enc:v1:encrypted-btn-api-key";
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              BTN: {
+                APIKey: encryptedAPIKey,
+                Username: "",
+                Password: "",
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry(
+            "BTN",
+            [
+              ["APIKey", "", true],
+              ["Username", "", true],
+              ["Password", "", true],
+            ],
+            true,
+            "standalone",
+          ),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("BTN", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("BTN", { selector: ".settings-card__summary-name" }));
+
+    expect(screen.getByLabelText("API key")).toHaveValue("[REDACTED]");
+
+    let payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.BTN?.APIKey === encryptedAPIKey).toBe(true);
+
+    fireEvent.change(screen.getByLabelText("API key"), {
+      target: { value: "replacement-api-key" },
+    });
+
+    await waitFor(() =>
+      expect(screen.getByLabelText("API key")).toHaveValue("replacement-api-key"),
+    );
+
+    payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.BTN?.APIKey).toBe("replacement-api-key");
+  });
+
+  it("renders BTN announce URL from tracker schema when stored config lacks the key", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              BTN: {
+                APIKey: "tracker-token",
+                Username: "",
+                Password: "",
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry(
+            "BTN",
+            [
+              ["APIKey", "", true],
+              ["Username", "", true],
+              ["Password", "", true],
+              ["AnnounceURL", "", true],
+            ],
+            false,
+            "standalone",
+          ),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("BTN", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("BTN", { selector: ".settings-card__summary-name" }));
+
+    expect(screen.getByLabelText("Announce URL")).toHaveValue("");
+  });
+
+  it("shows Lostimg as an LST image host only when configured in image hosting", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {
+            LostimgEnabled: true,
+            LostimgAPI: "secret",
+          },
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              LST: {
+                LinkDirName: "",
+                APIKey: "tracker-token",
+                ImageHost: "",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("LST", [
+            ["LinkDirName", ""],
+            ["APIKey", "", true],
+            ["ImageHost", ""],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({
+        TrackerUploadHosts: { LST: ["lostimg"] },
+        OwnedHosts: { lostimg: "LST" },
+      }),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("LST", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("LST", { selector: ".settings-card__summary-name" }));
+
+    const imageHostSelect = screen.getByLabelText("Image host") as HTMLSelectElement;
+    expect(Array.from(imageHostSelect.options).map((option) => option.value)).toContain("lostimg");
+  });
+
+  it("shows configured global hosts for LST when Lostimg is disabled", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {
+            Host1: "imgbb",
+            LostimgEnabled: false,
+            LostimgAPI: "",
+          },
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              LST: {
+                LinkDirName: "",
+                APIKey: "tracker-token",
+                ImageHost: "",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("LST", [
+            ["LinkDirName", ""],
+            ["APIKey", "", true],
+            ["ImageHost", ""],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({
+        TrackerUploadHosts: { LST: ["lostimg"] },
+        OwnedHosts: { lostimg: "LST" },
+      }),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("LST", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("LST", { selector: ".settings-card__summary-name" }));
+
+    const values = Array.from(
+      (screen.getByLabelText("Image host") as HTMLSelectElement).options,
+    ).map((option) => option.value);
+    expect(values).toContain("imgbb");
+    expect(values).not.toContain("lostimg");
+  });
+
+  it("shows Reelflix as an RF image host and exposes RF image API", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {},
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              RF: {
+                LinkDirName: "",
+                APIKey: "tracker-token",
+                ImgAPI: "",
+                ImageHost: "reelflix",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("RF", [
+            ["LinkDirName", ""],
+            ["APIKey", "", true],
+            ["ImgAPI", ""],
+            ["ImageHost", ""],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({
+        TrackerUploadHosts: { RF: ["reelflix"] },
+        OwnedHosts: { reelflix: "RF" },
+      }),
+    });
+
+    render(createElement(TrackerSettingsAdvancedHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("RF", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("RF", { selector: ".settings-card__summary-name" }));
+
+    const imageHostSelect = screen.getByLabelText("Image host") as HTMLSelectElement;
+    expect(Array.from(imageHostSelect.options).map((option) => option.value)).toContain("reelflix");
+
+    fireEvent.change(screen.getByLabelText("Image API"), {
+      target: { value: "secret" },
+    });
+
+    await waitFor(() => expect(screen.getByLabelText("Image API")).toHaveValue("secret"));
+
+    const payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.RF?.ImgAPI).toBe("secret");
+  });
+
+  it("shows configured global hosts for RF when Reelflix is disabled", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {
+            Host1: "imgbb",
+          },
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              RF: {
+                LinkDirName: "",
+                APIKey: "tracker-token",
+                ImgAPI: "",
+                ImageHost: "",
+                Anon: false,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("RF", [
+            ["LinkDirName", ""],
+            ["APIKey", "", true],
+            ["ImgAPI", ""],
+            ["ImageHost", ""],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({
+        TrackerUploadHosts: { RF: ["reelflix"] },
+        OwnedHosts: { reelflix: "RF" },
+      }),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("RF", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("RF", { selector: ".settings-card__summary-name" }));
+
+    const values = Array.from(
+      (screen.getByLabelText("Image host") as HTMLSelectElement).options,
+    ).map((option) => option.value);
+    expect(values).toContain("imgbb");
+    expect(values).not.toContain("reelflix");
+  });
+});
+
+describe("tracker catalog loading", () => {
+  it("loads configured tracker selections outside the settings page", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: { Trackers: { BTN: { APIKey: "configured" } } },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(trackerCatalogEntry("BTN", [["APIKey", "", true]], true, "standalone")),
+    });
+
+    render(createElement(InputTrackerSelectionHarness));
+
+    expect(await screen.findByTestId("tracker-selection")).toHaveTextContent("BTN");
+  });
+});
+
+describe("tracker catalog interactions", () => {
+  it("renders configured RHD without a frontend tracker schema entry", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: { RHD: { APIKey: "tracker-token", Anon: false } },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("RHD", [
+            ["APIKey", "", true],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    expect(
+      await screen.findByText("RHD", { selector: ".settings-card__summary-name" }),
+    ).toBeInTheDocument();
+  });
+
+  it("adds a synthetic Unit3D tracker and preserves catalog field order", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: { DefaultTrackers: [], PreferredTracker: "", Trackers: {} },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("EXAMPLE", [
+            ["UploaderName", ""],
+            ["APIKey", "", true],
+            ["ImageHost", ""],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    const trackerSelect = await screen.findByDisplayValue("Select tracker");
+    fireEvent.change(trackerSelect, { target: { value: "EXAMPLE" } });
+    fireEvent.click(screen.getByRole("button", { name: "Add entry" }));
+
+    const card = (
+      await screen.findByText("EXAMPLE", { selector: ".settings-card__summary-name" })
+    ).closest(".settings-card");
+    expect(card).toBeTruthy();
+    const labels = Array.from(
+      (card as HTMLElement).querySelectorAll<HTMLSpanElement>("label.settings-field > span"),
+    ).map((label) => label.textContent);
+    expect(labels).toEqual(["Uploader name", "API key", "Image host"]);
+  });
+
+  it("shows a tracker as configured when only one required credential is present", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: { BTN: { Username: "user", Password: "" } },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry(
+            "BTN",
+            [
+              ["Username", "", true],
+              ["Password", "", true],
+            ],
+            true,
+            "standalone",
+          ),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    expect(
+      await screen.findByText("BTN", { selector: ".settings-card__summary-name" }),
+    ).toBeInTheDocument();
+  });
+
+  it("removes an entry by resetting defaults and returning it to the selector", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: ["AITHER"],
+            PreferredTracker: "AITHER",
+            Trackers: { AITHER: { APIKey: "tracker-token", Anon: true } },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry("AITHER", [
+            ["APIKey", "", true],
+            ["Anon", false],
+          ]),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    const cardName = await screen.findByText("AITHER", {
+      selector: ".settings-card__summary-name",
+    });
+    const card = cardName.closest(".settings-card");
+    fireEvent.click(within(card as HTMLElement).getByRole("button", { name: "Remove" }));
+
+    await waitFor(() =>
+      expect(
+        screen.queryByText("AITHER", { selector: ".settings-card__summary-name" }),
+      ).not.toBeInTheDocument(),
+    );
+    const availableSelector = screen.getByDisplayValue("Select tracker");
+    expect(within(availableSelector).getByRole("option", { name: "AITHER" })).toBeInTheDocument();
+    const payload = readPayload<{
+      Trackers?: {
+        DefaultTrackers?: string[];
+        PreferredTracker?: string;
+        Trackers?: Record<string, Record<string, unknown>>;
+      };
+    }>();
+    expect(payload.Trackers?.DefaultTrackers).toEqual([]);
+    expect(payload.Trackers?.PreferredTracker).toBe("");
+    expect(payload.Trackers?.Trackers?.AITHER).toEqual({ APIKey: "", Anon: false });
+  });
+
+  it("separates unsupported entries and deletes them without making them selectable", async () => {
+    const catalog = trackerCatalog(trackerCatalogEntry("AITHER", [["APIKey", "", true]]));
+    catalog.unsupported = ["OLD"];
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: { OLD: { APIKey: "preserved" } },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => catalog,
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    const unsupported = await screen.findByText("Unsupported tracker entries");
+    expect(unsupported).toBeInTheDocument();
+    const oldCard = screen
+      .getByText("OLD", { selector: ".settings-card__summary-name" })
+      .closest(".settings-card");
+    expect(screen.queryByRole("option", { name: "OLD" })).not.toBeInTheDocument();
+    fireEvent.click(within(oldCard as HTMLElement).getByRole("button", { name: "Delete" }));
+
+    await waitFor(() =>
+      expect(
+        screen.queryByText("OLD", { selector: ".settings-card__summary-name" }),
+      ).not.toBeInTheDocument(),
+    );
+    const payload = readPayload<{
+      Trackers?: { Trackers?: Record<string, Record<string, unknown>> };
+    }>();
+    expect(payload.Trackers?.Trackers?.OLD).toBeUndefined();
+  });
+
+  it("reports a stable error for an unknown catalog field", async () => {
+    installAppOperationMocks({
+      GetConfig: async () => JSON.stringify({ Trackers: { Trackers: {} } }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(trackerCatalogEntry("BROKEN", [["UnknownField", "", true]])),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsErrorHarness));
+
+    expect(
+      await screen.findByText(/Unsupported tracker config field: UnknownField/),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("tracker advanced fields", () => {
+  it("hides only the tracker advanced allowlist when advanced is closed", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          Trackers: {
+            DefaultTrackers: [],
+            PreferredTracker: "",
+            Trackers: {
+              MTV: {
+                FaviconURL: "https://example.test/favicon.ico",
+                LinkDirName: "mtv",
+                APIKey: "api-key",
+                Username: "user",
+                Password: "pass",
+                AnnounceURL: "https://example.test/announce",
+                Anon: false,
+                OTPURI: "otpauth://totp/example",
+                SkipIfRehash: true,
+                PreferMTV: true,
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () =>
+        trackerCatalog(
+          trackerCatalogEntry(
+            "MTV",
+            [
+              ["FaviconURL", ""],
+              ["LinkDirName", ""],
+              ["APIKey", "", true],
+              ["Username", "", true],
+              ["Password", "", true],
+              ["AnnounceURL", "", true],
+              ["Anon", false],
+              ["OTPURI", ""],
+              ["SkipIfRehash", false],
+              ["PreferMTV", false],
+            ],
+            false,
+            "standalone",
+          ),
+        ),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(TrackerSettingsHarness));
+
+    await waitFor(() =>
+      expect(
+        screen.getByText("MTV", { selector: ".settings-card__summary-name" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByText("MTV", { selector: ".settings-card__summary-name" }));
+
+    expect(screen.queryByLabelText("Favicon URL")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("Link dir name")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("Skip if rehash")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("Prefer MTV torrent")).not.toBeInTheDocument();
+    expect(screen.getByLabelText("Announce URL")).toBeInTheDocument();
+    expect(screen.getByLabelText("OTP URI")).toBeInTheDocument();
+  });
+});
+
+describe("Image hosting settings", () => {
+  it("renders Lostimg config and keeps it out of global host priority", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {
+            Host1: "",
+            Host2: "",
+            Host3: "",
+            Host4: "",
+            Host5: "",
+            Host6: "",
+            LostimgEnabled: false,
+            LostimgAPI: "",
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(ImageHostingHarness));
+
+    await waitFor(() => expect(screen.getByLabelText("Lostimg enabled")).toBeInTheDocument());
+
+    const hostOne = screen.getByLabelText("Host 1") as HTMLSelectElement;
+    expect(Array.from(hostOne.options).map((option) => option.value)).not.toContain("lostimg");
+
+    fireEvent.click(screen.getByLabelText("Lostimg enabled"));
+    fireEvent.change(screen.getByLabelText("API key"), {
+      target: { value: "secret" },
+    });
+
+    await waitFor(() => expect(screen.getByLabelText("Lostimg enabled")).toBeChecked());
+
+    const payload = readPayload<{
+      ImageHosting?: {
+        LostimgEnabled?: boolean;
+        LostimgAPI?: string;
+      };
+    }>();
+    expect(payload.ImageHosting?.LostimgEnabled).toBe(true);
+    expect(payload.ImageHosting?.LostimgAPI).toBe("secret");
+  });
+
+  it("does not hard-code tracker-owned host fields into global image hosting", async () => {
+    installAppOperationMocks({
+      GetConfig: async () =>
+        JSON.stringify({
+          ImageHosting: {
+            Host1: "",
+            Host2: "",
+            Host3: "",
+            Host4: "",
+            Host5: "",
+            Host6: "",
+          },
+          Trackers: {
+            Trackers: {
+              RF: {
+                ImageHost: "",
+                ImgAPI: "",
+              },
+            },
+          },
+        }),
+      GetDefaultConfig: async () => JSON.stringify({}),
+      ListTrackerCatalog: async () => trackerCatalog(),
+      GetImageHostPolicyMetadata: async () => ({}),
+    });
+
+    render(createElement(ImageHostingHarness));
+
+    await waitFor(() => expect(screen.getByLabelText("Host 1")).toBeInTheDocument());
+
+    const hostOne = screen.getByLabelText("Host 1") as HTMLSelectElement;
+    expect(Array.from(hostOne.options).map((option) => option.value)).not.toContain("reelflix");
+
+    expect(screen.queryByLabelText("RF Reelflix")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("Image API")).not.toBeInTheDocument();
+  });
+});
diff --git a/webui/src/hooks/useSettingsState.tsx b/webui/src/hooks/useSettingsState.tsx
new file mode 100644
index 00000000..72404bf5
--- /dev/null
+++ b/webui/src/hooks/useSettingsState.tsx
@@ -0,0 +1,1954 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import { configClient, trackerCatalogClient } from "../api/app";
+import { Button } from "../components/ui/button";
+import { PillCheckbox } from "../components/ui/checkbox";
+import { Switch } from "../components/ui/switch";
+import { trackerFieldPresentation } from "../settings/trackerFields";
+import type {
+  ConfigMap,
+  ConfigValue,
+  FieldMeta,
+  ImageHostPolicyMetadata,
+  TrackerCatalog,
+  TrackerCatalogEntry,
+} from "../types";
+import { useTrackerCatalog } from "../trackerCatalog";
+import { formatLabel, normalizeDefaultTrackerList } from "../utils/settings";
+
+type SettingsSection = { key: string; jsonKey: string; label: string };
+
+const settingsInputClass =
+  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
+
+const settingsSelectClass = `${settingsInputClass} cursor-pointer`;
+type FieldOption = NonNullable<FieldMeta["options"]>[number];
+
+type UseSettingsStateOptions = {
+  activeTab: string;
+};
+
+type UseSettingsStateResult = {
+  configData: ConfigMap | null;
+  settingsLoading: boolean;
+  settingsDirty: boolean;
+  settingsSaved: string;
+  settingsError: string;
+  settingsSection: string;
+  settingsSections: SettingsSection[];
+  showAdvancedToggle: boolean;
+  advancedOpen: boolean;
+  setSettingsSection: Dispatch<SetStateAction<string>>;
+  setSettingsAdvanced: Dispatch<SetStateAction<Record<string, boolean>>>;
+  loadSettings: () => void;
+  handleSaveSettings: () => void;
+  renderImageHostingSection: () => JSX.Element | null;
+  renderTrackerSection: (advancedOpen: boolean) => JSX.Element | null;
+  renderTorrentClientsSection: (advancedOpen: boolean) => JSX.Element | null;
+  renderMapSection: (
+    sectionKey: string,
+    sectionValue: ConfigMap,
+    options?: {
+      entriesKey?: string;
+      defaultKey?: string;
+      fieldMeta?: Record<string, FieldMeta>;
+      advancedOpen?: boolean;
+    },
+  ) => JSX.Element;
+  renderField: (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => JSX.Element;
+  sectionFieldMeta: Record<string, Record<string, FieldMeta>>;
+  updateConfigValue: (path: string[], value: ConfigValue) => void;
+  updateScreenshotConfigValue: (key: string, value: ConfigValue) => void;
+  configuredImageHosts: string[];
+  screenshotConfig: ConfigMap | null;
+  buildSavePayload: () => string | null;
+  clearSettingsStatus: () => void;
+  markSettingsSaved: (message: string) => void;
+  setSettingsSavedMessage: (message: string) => void;
+  setSettingsErrorMessage: (message: string) => void;
+  resolveImageHostLabel: (value: string) => string;
+  knownTrackersLoading: boolean;
+  trackerSelectionNames: string[];
+};
+
+const settingsSections: SettingsSection[] = [
+  { key: "main_settings", jsonKey: "MainSettings", label: "Main" },
+  { key: "image_hosting", jsonKey: "ImageHosting", label: "Image Hosting" },
+  { key: "metadata", jsonKey: "Metadata", label: "Metadata" },
+  { key: "screenshot_handling", jsonKey: "ScreenshotHandling", label: "Screens" },
+  { key: "description_settings", jsonKey: "Description", label: "Description" },
+  { key: "arr_integration", jsonKey: "ArrIntegration", label: "Arr" },
+  { key: "post_upload", jsonKey: "PostUpload", label: "Post Upload" },
+  { key: "trackers", jsonKey: "Trackers", label: "Trackers" },
+  { key: "torrent_clients", jsonKey: "TorrentClients", label: "Torrent Clients" },
+  { key: "client_setup", jsonKey: "ClientSetup", label: "Client Handling" },
+  { key: "torrent_creation", jsonKey: "TorrentCreation", label: "Torrent Specific" },
+];
+
+const imageHostOptions = [
+  { value: "", label: "None" },
+  { value: "imgbb", label: "ImgBB" },
+  { value: "imgbox", label: "ImgBox" },
+  { value: "pixhost", label: "Pixhost" },
+  { value: "lensdump", label: "Lensdump" },
+  { value: "ptscreens", label: "PTScreens" },
+  { value: "onlyimage", label: "OnlyImage" },
+  { value: "dalexni", label: "Dalexni" },
+  { value: "zipline", label: "Zipline" },
+  { value: "passtheimage", label: "PassTheImage" },
+  { value: "seedpool_cdn", label: "Seedpool CDN" },
+  { value: "sharex", label: "ShareX" },
+  { value: "utppm", label: "UTPPM" },
+];
+
+const torrentClientTypeOptions = [
+  { value: "qbit", label: "qBit" },
+  { value: "watch", label: "Watch" },
+];
+const torrentClientLinkingOptions = [
+  { value: "", label: "None" },
+  { value: "hardlink", label: "Hardlink" },
+  { value: "reflink", label: "Reflink" },
+  { value: "symlink", label: "Symlink" },
+];
+const imageHostOptionLabels = new Map(
+  imageHostOptions.map((option) => [option.value, option.label]),
+);
+const normalizeImageHostValue = (value: string) => value.trim().toLowerCase();
+const imageHostOptionFor = (host: string) => {
+  const value = normalizeImageHostValue(host);
+  return { value, label: imageHostOptionLabels.get(value) ?? formatLabel(value) };
+};
+
+const imageHostKeyMap: Record<string, string[]> = {
+  imgbb: ["ImgBBAPI"],
+  lensdump: ["LensdumpAPI"],
+  ptscreens: ["PTScreensAPI"],
+  onlyimage: ["OnlyImageAPI"],
+  dalexni: ["DalexniAPI"],
+  zipline: ["ZiplineURL", "ZiplineAPIKey"],
+  passtheimage: ["PassTheImageAPI"],
+  seedpool_cdn: ["SeedpoolCDNAPI"],
+  sharex: ["ShareXURL", "ShareXAPIKey"],
+  utppm: ["UTPPMAPI"],
+};
+
+const stringField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "string",
+  ...meta,
+});
+const boolField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "boolean",
+  ...meta,
+});
+const numberField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "number",
+  ...meta,
+});
+
+const REDACTED_VALUE = "[REDACTED]";
+const ENCRYPTED_SECRET_PREFIX = "upbrr-enc:v1:";
+
+function hasConfiguredTrackerValue(
+  value: ConfigValue | undefined,
+  baseline: ConfigValue | undefined,
+): boolean {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return false;
+    }
+    return baseline !== value;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && baseline !== value;
+  }
+  if (typeof value === "boolean") {
+    return value && baseline !== value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return false;
+    }
+    if (Array.isArray(baseline) && JSON.stringify(value) === JSON.stringify(baseline)) {
+      return false;
+    }
+    return true;
+  }
+  if (value && typeof value === "object") {
+    if (Object.keys(value).length === 0) {
+      return false;
+    }
+    if (
+      baseline &&
+      typeof baseline === "object" &&
+      JSON.stringify(value) === JSON.stringify(baseline)
+    ) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+const trackerConfigValue = (entries: ConfigMap, name: string): ConfigMap | null => {
+  const exact = entries[name];
+  if (exact && typeof exact === "object" && !Array.isArray(exact)) return exact as ConfigMap;
+  const foldedName = Object.keys(entries).find(
+    (candidate) => candidate.trim().toLowerCase() === name.trim().toLowerCase(),
+  );
+  if (!foldedName) return null;
+  const value = entries[foldedName];
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as ConfigMap) : null;
+};
+const sensitiveKeyHints = [
+  "password",
+  "passkey",
+  "token",
+  "api",
+  "key",
+  "secret",
+  "cookie",
+  "session",
+  "otp",
+  "announce_url",
+  "announceurl",
+];
+
+const sectionFieldMeta: Record<string, Record<string, FieldMeta>> = {
+  ImageHosting: {
+    LostimgAPI: stringField("LostimgAPI", { label: "API key", sensitive: true }),
+  },
+  MainSettings: {
+    InputHistoryLimit: { key: "InputHistoryLimit", label: "Input history limit", type: "number" },
+    UseFavicons: { key: "UseFavicons", label: "Use favicons" },
+    FaviconOnly: { key: "FaviconOnly", label: "Favicon only" },
+    SceneDetection: { key: "SceneDetection", label: "Scene detection (srrdb)" },
+  },
+  Metadata: {
+    BTNAPI: { key: "BTNAPI", advanced: true, sensitive: true },
+    SkipAutoTorrent: { key: "SkipAutoTorrent", advanced: true },
+    SkipTrackerFilenameLookup: { key: "SkipTrackerFilenameLookup", advanced: true },
+    UserOverrides: { key: "UserOverrides", advanced: true },
+    BlurayScore: { key: "BlurayScore", advanced: true },
+    BluraySingleScore: { key: "BluraySingleScore", advanced: true },
+    CheckPredb: { key: "CheckPredb", advanced: true },
+  },
+  ScreenshotHandling: {
+    MaxMenuItems: { key: "MaxMenuItems", label: "Maximum DVD menu images", type: "number" },
+    ProcessLimit: { key: "ProcessLimit", advanced: true },
+    MaxConcurrentUploads: { key: "MaxConcurrentUploads", advanced: true },
+    FFmpegLimit: { key: "FFmpegLimit", advanced: true },
+    FFmpegCompression: { key: "FFmpegCompression", advanced: true },
+    TonemapAlgorithm: { key: "TonemapAlgorithm", advanced: true },
+    Desat: { key: "Desat", advanced: true },
+  },
+  Description: {
+    LogoSize: { key: "LogoSize", advanced: true },
+    LogoLanguage: { key: "LogoLanguage", advanced: true },
+    CharLimit: { key: "CharLimit", advanced: true },
+    FileLimit: { key: "FileLimit", advanced: true },
+    ProcessLimit: { key: "ProcessLimit", advanced: true },
+    CustomSignature: { key: "CustomSignature", advanced: true },
+  },
+  ArrIntegration: {
+    SonarrURL1: { key: "SonarrURL1", advanced: true },
+    SonarrAPIKey1: { key: "SonarrAPIKey1", advanced: true, sensitive: true },
+    SonarrURL2: { key: "SonarrURL2", advanced: true },
+    SonarrAPIKey2: { key: "SonarrAPIKey2", advanced: true, sensitive: true },
+    SonarrURL3: { key: "SonarrURL3", advanced: true },
+    SonarrAPIKey3: { key: "SonarrAPIKey3", advanced: true, sensitive: true },
+    RadarrURL1: { key: "RadarrURL1", advanced: true },
+    RadarrAPIKey1: { key: "RadarrAPIKey1", advanced: true, sensitive: true },
+    RadarrURL2: { key: "RadarrURL2", advanced: true },
+    RadarrAPIKey2: { key: "RadarrAPIKey2", advanced: true, sensitive: true },
+    RadarrURL3: { key: "RadarrURL3", advanced: true },
+    RadarrAPIKey3: { key: "RadarrAPIKey3", advanced: true, sensitive: true },
+    EmbyDir: { key: "EmbyDir", advanced: true },
+    EmbyTVDir: { key: "EmbyTVDir", advanced: true },
+  },
+  TorrentCreation: {},
+  PostUpload: {
+    InjectDelay: { key: "InjectDelay", advanced: true },
+    MaxConcurrentTrackers: { key: "MaxConcurrentTrackers", advanced: true },
+  },
+  Logging: {},
+  TorrentClients: {
+    Type: stringField("Type", { label: "Type", options: torrentClientTypeOptions }),
+    WatchFolder: stringField("WatchFolder", { label: "Watch folder" }),
+    StorageDir: stringField("StorageDir", { label: "Storage directory" }),
+    QuiProxyURL: stringField("QuiProxyURL", { label: "Qui proxy URL", sensitive: true }),
+    QbitURL: stringField("QbitURL", { label: "qBit URL" }),
+    QbitPort: numberField("QbitPort", { label: "qBit port" }),
+    QbitUser: stringField("QbitUser", { label: "qBit user", sensitive: true }),
+    QbitPass: stringField("QbitPass", { label: "qBit pass", sensitive: true }),
+    QbitCategoryValue: stringField("QbitCategoryValue", { label: "qBit category" }),
+    QbitTag: stringField("QbitTag", { label: "qBit tag" }),
+    QbitCrossCategory: stringField("QbitCrossCategory", { label: "qBit cross category" }),
+    QbitCrossTag: stringField("QbitCrossTag", { label: "qBit cross tag" }),
+    UseTrackerAsTag: boolField("UseTrackerAsTag", { label: "Use tracker as tag" }),
+    Linking: stringField("Linking", {
+      label: "Linking",
+      options: torrentClientLinkingOptions,
+    }),
+    AllowFallback: boolField("AllowFallback", { label: "Allow link fallback" }),
+    LinkedFolder: stringField("LinkedFolder", { label: "Linked folder" }),
+    LocalPath: stringField("LocalPath", { label: "Local path" }),
+    RemotePath: stringField("RemotePath", { label: "Remote path" }),
+    AutomaticManagementPaths: stringField("AutomaticManagementPaths", {
+      label: "Automatic management paths",
+    }),
+    VerifyWebUICertificate: boolField("VerifyWebUICertificate", {
+      label: "Verify WebUI certificate",
+      advanced: true,
+    }),
+  },
+};
+
+const isSensitiveKeyName = (key: string) => {
+  const lower = key.toLowerCase();
+  return sensitiveKeyHints.some((hint) => lower.includes(hint));
+};
+
+const buildPathKey = (path: string[]) => path.join(".");
+
+const isEncryptedSecretEnvelope = (value: string) => value.startsWith(ENCRYPTED_SECRET_PREFIX);
+
+/** Masks secret-bearing config strings while retaining originals by config path for save payloads. */
+const maskSensitiveConfig = (input: ConfigMap) => {
+  const originals: Record<string, string> = {};
+  const walk = (value: ConfigValue, path: string[]): ConfigValue => {
+    if (value === null || value === undefined) return value;
+    if (Array.isArray(value)) {
+      return value.map((entry, index) => walk(entry, [...path, String(index)]));
+    }
+    if (typeof value === "object") {
+      const next: ConfigMap = {};
+      Object.entries(value).forEach(([key, child]) => {
+        next[key] = walk(child, [...path, key]);
+      });
+      return next;
+    }
+    if (typeof value === "string") {
+      const key = path[path.length - 1] || "";
+      if (value && (isSensitiveKeyName(key) || isEncryptedSecretEnvelope(value))) {
+        originals[buildPathKey(path)] = value;
+        return REDACTED_VALUE;
+      }
+      return value;
+    }
+    return value;
+  };
+
+  return { masked: walk(input, []) as ConfigMap, originals };
+};
+
+const restoreSensitiveConfig = (input: ConfigMap, originals: Record<string, string>) => {
+  const walk = (value: ConfigValue, path: string[]): ConfigValue => {
+    if (value === null || value === undefined) return value;
+    if (Array.isArray(value)) {
+      return value.map((entry, index) => walk(entry, [...path, String(index)]));
+    }
+    if (typeof value === "object") {
+      const next: ConfigMap = {};
+      Object.entries(value).forEach(([key, child]) => {
+        next[key] = walk(child, [...path, key]);
+      });
+      return next;
+    }
+    if (typeof value === "string") {
+      if (value === REDACTED_VALUE) {
+        const original = originals[buildPathKey(path)];
+        if (original !== undefined) {
+          return original;
+        }
+      }
+      return value;
+    }
+    return value;
+  };
+
+  return walk(input, []) as ConfigMap;
+};
+
+const legacyTorrentClientKeys = [
+  "Type",
+  "TorrentClient",
+  "URL",
+  "WatchFolder",
+  "StorageDir",
+  "Username",
+  "Password",
+  "Category",
+  "Tags",
+  "TLSSkipVerify",
+  "QbitTagsValue",
+];
+
+const qbitDefaultClient = (): ConfigMap => ({
+  Type: "qbit",
+  QuiProxyURL: "",
+  QbitCategoryValue: "",
+  QbitTag: "",
+  QbitCrossCategory: "",
+  QbitCrossTag: "",
+  UseTrackerAsTag: false,
+  Linking: "",
+  AllowFallback: true,
+  LinkedFolder: [],
+  LocalPath: [],
+  RemotePath: [],
+  AutomaticManagementPaths: [],
+  VerifyWebUICertificate: true,
+});
+
+const qbitDirectDisabledValues: Readonly<Record<string, ConfigValue>> = {
+  QbitURL: "",
+  QbitPort: 0,
+  QbitUser: "",
+  QbitPass: "",
+  URL: "",
+  Username: "",
+  Password: "",
+  QuiProxyURL: "",
+};
+
+const normalizeStringArray = (value: ConfigValue) => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+  }
+  return [];
+};
+
+const normalizeTorrentClientType = (client: ConfigMap) => {
+  const directType = typeof client.Type === "string" ? client.Type.trim() : "";
+  if (directType) {
+    return directType.toLowerCase();
+  }
+  const legacyType = typeof client.TorrentClient === "string" ? client.TorrentClient.trim() : "";
+  if (legacyType) {
+    return legacyType.toLowerCase();
+  }
+  return "qbit";
+};
+
+/**
+ * Normalizes a torrent client before save, migrating legacy qBit fields to the
+ * canonical qBit keys while preserving non-qBit client configs.
+ */
+export const normalizeTorrentClientForSave = (client: ConfigMap) => {
+  const next = { ...client };
+  if (normalizeTorrentClientType(next) !== "qbit") {
+    return next;
+  }
+
+  if (!next.QbitURL && typeof next.URL === "string") next.QbitURL = next.URL;
+  if (!next.QbitUser && typeof next.Username === "string") next.QbitUser = next.Username;
+  if (!next.QbitPass && typeof next.Password === "string") next.QbitPass = next.Password;
+  if (!next.QbitCategoryValue && typeof next.Category === "string") {
+    next.QbitCategoryValue = next.Category;
+  }
+  if (!next.QbitTag) {
+    if (Array.isArray(next.Tags)) {
+      next.QbitTag = normalizeStringArray(next.Tags).join(",");
+    } else if (Array.isArray(next.QbitTagsValue)) {
+      next.QbitTag = normalizeStringArray(next.QbitTagsValue).join(",");
+    }
+  }
+  if (next.VerifyWebUICertificate === undefined && typeof next.TLSSkipVerify === "boolean") {
+    next.VerifyWebUICertificate = !next.TLSSkipVerify;
+  }
+
+  legacyTorrentClientKeys.forEach((key) => {
+    delete next[key];
+  });
+
+  return next;
+};
+
+/**
+ * Builds the next qBit direct-connection state for the settings toggle.
+ * Enabling seeds host defaults; disabling clears direct, proxy, and legacy
+ * credential fields so the client no longer attempts a direct qBit connection.
+ */
+export const nextQbitDirectState = (client: ConfigMap, enabled: boolean): ConfigMap => {
+  if (enabled) {
+    return {
+      ...client,
+      QbitURL:
+        typeof client.QbitURL === "string" && client.QbitURL.trim() !== ""
+          ? client.QbitURL
+          : "http://127.0.0.1",
+      QbitPort: typeof client.QbitPort === "number" && client.QbitPort > 0 ? client.QbitPort : 8080,
+    };
+  }
+  return { ...client, ...qbitDirectDisabledValues };
+};
+
+/**
+ * Normalizes all configured torrent client entries in a settings payload before
+ * serializing it for the backend.
+ */
+export const normalizeTorrentClientsForSave = (input: ConfigMap) => {
+  const clients = input.TorrentClients;
+  if (!clients || typeof clients !== "object" || Array.isArray(clients)) {
+    return input;
+  }
+
+  const nextClients: ConfigMap = {};
+  Object.entries(clients as ConfigMap).forEach(([name, value]) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+    nextClients[name] = normalizeTorrentClientForSave(value as ConfigMap);
+  });
+
+  return { ...input, TorrentClients: nextClients };
+};
+
+/** Filters supported trackers to catalog fields and removes all legacy endpoint overrides. */
+const normalizeTrackersForSave = (input: ConfigMap, catalog: TrackerCatalog | null) => {
+  const trackerRoot = input.Trackers;
+  if (!trackerRoot || typeof trackerRoot !== "object" || Array.isArray(trackerRoot)) {
+    return input;
+  }
+  const trackerEntries = (trackerRoot as ConfigMap).Trackers;
+  if (!trackerEntries || typeof trackerEntries !== "object" || Array.isArray(trackerEntries)) {
+    return input;
+  }
+
+  let changed = false;
+  const catalogByName = new Map(
+    (catalog?.entries ?? []).map((entry) => [entry.name.trim().toUpperCase(), entry]),
+  );
+  const nextEntries: ConfigMap = {};
+  Object.entries(trackerEntries as ConfigMap).forEach(([name, value]) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      nextEntries[name] = value;
+      return;
+    }
+    const supported = catalogByName.get(name.trim().toUpperCase());
+    const allowed = supported ? new Set(supported.fields.map((field) => field.key)) : null;
+    const next: ConfigMap = {};
+    Object.entries(value as ConfigMap).forEach(([key, fieldValue]) => {
+      if (key.trim().toLowerCase() === "url") {
+        changed = true;
+        return;
+      }
+      if (allowed && !allowed.has(key)) {
+        changed = true;
+        return;
+      }
+      next[key] = fieldValue;
+    });
+    nextEntries[name] = next;
+  });
+
+  if (!changed) {
+    return input;
+  }
+  return {
+    ...input,
+    Trackers: {
+      ...(trackerRoot as ConfigMap),
+      Trackers: nextEntries,
+    },
+  };
+};
+
+/**
+ * Owns settings-screen state, WebUI config loading, sensitive-value masking,
+ * render helpers, and save payload construction for tabs that need config data.
+ * Save payloads restore masked secrets before serialization.
+ */
+export const useSettingsState = (options: UseSettingsStateOptions): UseSettingsStateResult => {
+  const { activeTab } = options;
+  const [configData, setConfigData] = useState<ConfigMap | null>(null);
+  const {
+    catalog: trackerCatalog,
+    loading: knownTrackersLoading,
+    error: trackerCatalogError,
+    removeUnsupported,
+  } = useTrackerCatalog();
+  const [imageHostPolicyMetadata, setImageHostPolicyMetadata] =
+    useState<ImageHostPolicyMetadata | null>(null);
+  const [trackerAddSelection, setTrackerAddSelection] = useState("");
+  const [draftTrackerEntries, setDraftTrackerEntries] = useState<Record<string, boolean>>({});
+  const [settingsTrackerPanels, setSettingsTrackerPanels] = useState<Record<string, boolean>>({});
+  const [defaultTrackersPanelOpen, setDefaultTrackersPanelOpen] = useState(false);
+  const [settingsLoading, setSettingsLoading] = useState(false);
+  const [settingsError, setSettingsError] = useState("");
+  const [settingsSaved, setSettingsSaved] = useState("");
+  const [settingsDirty, setSettingsDirty] = useState(false);
+  const [settingsSection, setSettingsSection] = useState(settingsSections[0].key);
+  const [settingsAdvanced, setSettingsAdvanced] = useState<Record<string, boolean>>({});
+  const [sensitiveValues, setSensitiveValues] = useState<Record<string, string>>({});
+
+  const configuredImageHosts = useMemo(() => {
+    if (!configData || !configData.ImageHosting || typeof configData.ImageHosting !== "object") {
+      return [] as string[];
+    }
+    if (Array.isArray(configData.ImageHosting)) {
+      return [] as string[];
+    }
+    const imageCfg = configData.ImageHosting as ConfigMap;
+    const hostFields = ["Host1", "Host2", "Host3", "Host4", "Host5", "Host6"];
+    const hosts: string[] = [];
+    hostFields.forEach((field) => {
+      const value = String(imageCfg[field] ?? "").trim();
+      if (!value) return;
+      if (!hosts.includes(value)) {
+        hosts.push(value);
+      }
+    });
+    return hosts;
+  }, [configData]);
+
+  const screenshotConfig = useMemo(() => {
+    if (
+      !configData ||
+      !configData.ScreenshotHandling ||
+      typeof configData.ScreenshotHandling !== "object"
+    ) {
+      return null;
+    }
+    if (Array.isArray(configData.ScreenshotHandling)) {
+      return null;
+    }
+    return configData.ScreenshotHandling as ConfigMap;
+  }, [configData]);
+
+  const torrentClientOptions = useMemo<FieldOption[]>(() => {
+    if (
+      !configData ||
+      !configData.TorrentClients ||
+      typeof configData.TorrentClients !== "object" ||
+      Array.isArray(configData.TorrentClients)
+    ) {
+      return [];
+    }
+
+    return Object.entries(configData.TorrentClients as ConfigMap)
+      .filter(
+        ([name, value]) =>
+          name.trim() !== "" && value && typeof value === "object" && !Array.isArray(value),
+      )
+      .map(([name]) => ({ value: name, label: name }));
+  }, [configData]);
+
+  const effectiveSectionFieldMeta = useMemo<Record<string, Record<string, FieldMeta>>>(() => {
+    const clientOptions = [{ value: "", label: "" }, ...torrentClientOptions];
+    return {
+      ...sectionFieldMeta,
+      ClientSetup: {
+        ...(sectionFieldMeta.ClientSetup ?? {}),
+        DefaultClient: stringField("DefaultClient", {
+          label: "Default client",
+          options: clientOptions,
+        }),
+        InjectClients: stringField("InjectClients", {
+          label: "Injected clients",
+          options: clientOptions,
+        }),
+        SearchClients: stringField("SearchClients", {
+          label: "Searching clients",
+          options: clientOptions,
+        }),
+      },
+    };
+  }, [torrentClientOptions]);
+
+  const setSettingsErrorMessage = (message: string) => {
+    setSettingsError(message);
+  };
+
+  const clearSettingsStatus = useCallback(() => {
+    setSettingsError("");
+    setSettingsSaved("");
+  }, []);
+
+  const markSettingsSaved = (message: string) => {
+    setSettingsSaved(message);
+    setSettingsDirty(false);
+  };
+
+  const setSettingsSavedMessage = (message: string) => {
+    setSettingsSaved(message);
+  };
+
+  const buildSavePayload = () => {
+    if (!configData) {
+      return null;
+    }
+    const restored = normalizeTrackersForSave(
+      normalizeTorrentClientsForSave(restoreSensitiveConfig(configData, sensitiveValues)),
+      trackerCatalog,
+    );
+    return JSON.stringify(restored, null, 2);
+  };
+
+  const resolveImageHostLabel = (value: string) => {
+    return imageHostOptionLabels.get(value) ?? value;
+  };
+
+  const buildImageHostOptions = useCallback((hosts: string[]) => {
+    const allowed = new Set(
+      hosts.map((host) => normalizeImageHostValue(host)).filter((host) => host.length > 0),
+    );
+    const ordered = imageHostOptions.filter(
+      (option) => option.value === "" || allowed.has(option.value),
+    );
+    const known = new Set(ordered.map((option) => option.value));
+    const extras = Array.from(allowed)
+      .filter((host) => !known.has(host))
+      .sort((left, right) => left.localeCompare(right))
+      .map(imageHostOptionFor);
+    return [...ordered, ...extras];
+  }, []);
+
+  const trackerOptionsForImageHost = useCallback(
+    (trackerName: string) => {
+      const trackerKey = trackerName.trim().toUpperCase();
+      if (!imageHostPolicyMetadata) {
+        return imageHostOptions;
+      }
+
+      const policyHosts = imageHostPolicyMetadata.TrackerUploadHosts?.[trackerKey];
+      const fallbackHosts =
+        imageHostPolicyMetadata.UploadHosts?.map((host) => normalizeImageHostValue(host)) ??
+        imageHostOptions.filter((option) => option.value).map((option) => option.value);
+      const ownerByHost = imageHostPolicyMetadata.OwnedHosts ?? {};
+      const imageCfg =
+        configData?.ImageHosting &&
+        typeof configData.ImageHosting === "object" &&
+        !Array.isArray(configData.ImageHosting)
+          ? (configData.ImageHosting as ConfigMap)
+          : null;
+      const trackerRoot =
+        configData?.Trackers &&
+        typeof configData.Trackers === "object" &&
+        !Array.isArray(configData.Trackers)
+          ? (configData.Trackers as ConfigMap)
+          : null;
+      const trackerEntries =
+        trackerRoot?.Trackers &&
+        typeof trackerRoot.Trackers === "object" &&
+        !Array.isArray(trackerRoot.Trackers)
+          ? (trackerRoot.Trackers as ConfigMap)
+          : null;
+      const trackerCfg =
+        trackerEntries?.[trackerKey] &&
+        typeof trackerEntries[trackerKey] === "object" &&
+        !Array.isArray(trackerEntries[trackerKey])
+          ? (trackerEntries[trackerKey] as ConfigMap)
+          : null;
+      const globalFallbackHosts = fallbackHosts.filter((host) => !ownerByHost[host]);
+      const globalHosts = (configuredImageHosts.length ? configuredImageHosts : globalFallbackHosts)
+        .map((host) => normalizeImageHostValue(host))
+        .filter((host) => host.length > 0 && !ownerByHost[host]);
+      const policyHostSet = new Set(
+        (policyHosts ?? []).map((host) => normalizeImageHostValue(host)).filter(Boolean),
+      );
+      const policyHasGlobalHosts = Array.from(policyHostSet).some((host) => !ownerByHost[host]);
+      const policyAllowsGlobalFallback =
+        policyHostSet.size === 0 ||
+        Array.from(policyHostSet).every((host) => host === "lostimg" || host === "reelflix");
+      const hosts = globalHosts.filter(
+        (host) => policyAllowsGlobalFallback || (policyHasGlobalHosts && policyHostSet.has(host)),
+      );
+
+      (policyHosts ?? []).forEach((host) => {
+        const normalizedHost = normalizeImageHostValue(host);
+        const owner = ownerByHost[normalizedHost];
+        if (!owner || owner.trim().toUpperCase() !== trackerKey) {
+          return;
+        }
+        if (normalizedHost === "lostimg" && !Boolean(imageCfg?.LostimgEnabled)) {
+          return;
+        }
+        if (
+          normalizedHost === "reelflix" &&
+          normalizeImageHostValue(String(trackerCfg?.ImageHost ?? "")) !== "reelflix"
+        ) {
+          return;
+        }
+        if (!hosts.includes(normalizedHost)) {
+          hosts.push(normalizedHost);
+        }
+      });
+
+      return buildImageHostOptions(hosts);
+    },
+    [buildImageHostOptions, configData, configuredImageHosts, imageHostPolicyMetadata],
+  );
+
+  const updateConfigValue = (path: string[], value: ConfigValue) => {
+    setConfigData((prev) => {
+      if (!prev) return prev;
+      const clone = structuredClone(prev) as ConfigMap;
+      let cursor: ConfigMap = clone;
+      for (let i = 0; i < path.length - 1; i += 1) {
+        const key = path[i];
+        const next = cursor[key];
+        if (!next || typeof next !== "object" || Array.isArray(next)) {
+          cursor[key] = {};
+        }
+        cursor = cursor[key] as ConfigMap;
+      }
+      cursor[path[path.length - 1]] = value;
+      setSettingsDirty(true);
+      return clone;
+    });
+
+    const key = path[path.length - 1] || "";
+    if (
+      typeof value === "string" &&
+      (isSensitiveKeyName(key) || sensitiveValues[buildPathKey(path)] !== undefined)
+    ) {
+      setSensitiveValues((prev) => {
+        const next = { ...prev };
+        const pathKey = buildPathKey(path);
+        if (value === REDACTED_VALUE) {
+          return prev;
+        }
+        if (!value) {
+          delete next[pathKey];
+          return next;
+        }
+        next[pathKey] = value;
+        return next;
+      });
+    }
+  };
+
+  const updateScreenshotConfigValue = (key: string, value: ConfigValue) => {
+    updateConfigValue(["ScreenshotHandling", key], value);
+  };
+
+  const removeConfigKey = (path: string[], key: string) => {
+    setConfigData((prev) => {
+      if (!prev) return prev;
+      const clone = structuredClone(prev) as ConfigMap;
+      let cursor: ConfigMap = clone;
+      for (let i = 0; i < path.length; i += 1) {
+        cursor = cursor[path[i]] as ConfigMap;
+        if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
+          return prev;
+        }
+      }
+      if (!Object.prototype.hasOwnProperty.call(cursor, key)) {
+        return prev;
+      }
+      delete cursor[key];
+      setSettingsDirty(true);
+      return clone;
+    });
+  };
+
+  const addConfigKey = (path: string[], key: string, value: ConfigValue) => {
+    if (!key.trim()) return;
+    setConfigData((prev) => {
+      if (!prev) return prev;
+      const clone = structuredClone(prev) as ConfigMap;
+      let cursor: ConfigMap = clone;
+      for (let i = 0; i < path.length; i += 1) {
+        const step = path[i];
+        const next = cursor[step];
+        if (!next || typeof next !== "object" || Array.isArray(next)) {
+          cursor[step] = {};
+        }
+        cursor = cursor[step] as ConfigMap;
+      }
+      if (cursor[key] !== undefined) return prev;
+      cursor[key] = value;
+      setSettingsDirty(true);
+      return clone;
+    });
+  };
+
+  const loadSettings = useCallback(async () => {
+    clearSettingsStatus();
+    const getConfig = configClient.get;
+    setSettingsLoading(true);
+    try {
+      const result = await getConfig();
+      const parsed = JSON.parse(result) as ConfigMap;
+      const masked = maskSensitiveConfig(parsed);
+      setConfigData(masked.masked);
+      setSensitiveValues(masked.originals);
+      setDraftTrackerEntries({});
+      setSettingsDirty(false);
+    } catch (err) {
+      setSettingsError(String(err));
+    } finally {
+      setSettingsLoading(false);
+    }
+  }, [clearSettingsStatus]);
+
+  const loadImageHostPolicyMetadata = useCallback(async () => {
+    const getMetadata = trackerCatalogClient.getImageHostPolicyMetadata;
+    try {
+      const result = await getMetadata();
+      if (result && typeof result === "object") {
+        setImageHostPolicyMetadata(result);
+      }
+    } catch (err) {
+      setSettingsError(String(err));
+    }
+  }, []);
+
+  const handleSaveSettings = async () => {
+    clearSettingsStatus();
+    const saveConfig = configClient.save;
+    const payload = buildSavePayload();
+    if (!payload) {
+      setSettingsError("Settings are not loaded.");
+      return;
+    }
+    setSettingsLoading(true);
+    try {
+      await saveConfig(payload);
+      markSettingsSaved("Settings saved and applied.");
+    } catch (err) {
+      setSettingsError(String(err));
+    } finally {
+      setSettingsLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (
+      (activeTab === "input" ||
+        activeTab === "tracker" ||
+        activeTab === "dupes" ||
+        activeTab === "settings" ||
+        activeTab === "logging" ||
+        activeTab === "upload" ||
+        activeTab === "upload_images") &&
+      !configData
+    ) {
+      loadSettings();
+    }
+  }, [activeTab, configData, loadSettings]);
+
+  useEffect(() => {
+    try {
+      trackerCatalog?.entries.forEach((entry) => {
+        entry.fields.forEach((field) => trackerFieldPresentation(field.key));
+      });
+    } catch (error) {
+      setSettingsError(String(error));
+    }
+  }, [trackerCatalog]);
+
+  useEffect(() => {
+    if (trackerCatalogError) setSettingsError(trackerCatalogError);
+  }, [trackerCatalogError]);
+
+  useEffect(() => {
+    if (activeTab === "settings" && !imageHostPolicyMetadata) {
+      loadImageHostPolicyMetadata();
+    }
+  }, [activeTab, imageHostPolicyMetadata, loadImageHostPolicyMetadata]);
+
+  useEffect(() => {
+    if ((activeTab === "screenshots" || activeTab === "upload_images") && !configData) {
+      loadSettings();
+    }
+  }, [activeTab, configData, loadSettings]);
+
+  const advancedOpen = settingsAdvanced[settingsSection] ?? false;
+  const showAdvancedToggle = (() => {
+    if (settingsSection === "trackers") {
+      return (trackerCatalog?.entries ?? []).some((entry) =>
+        entry.fields.some((field) => trackerFieldPresentation(field.key).advanced),
+      );
+    }
+    const section = settingsSections.find((item) => item.key === settingsSection);
+    if (!section) return false;
+    const meta = effectiveSectionFieldMeta[section.jsonKey];
+    if (!meta) return false;
+    return Object.values(meta).some((field) => field.advanced);
+  })();
+
+  const renderArrayEditor = (
+    value: ConfigValue[],
+    path: string[],
+    meta?: FieldMeta,
+    displayLabel?: string,
+  ) => {
+    const options = meta?.options ?? [];
+    const optionValueFor = (entry: ConfigValue) => (entry === null ? "" : String(entry ?? ""));
+    const optionsFor = (entry: ConfigValue) => {
+      const selected = optionValueFor(entry);
+      if (!selected || options.some((option) => option.value === selected)) {
+        return options;
+      }
+      return [...options, { value: selected, label: selected }];
+    };
+    const newItemValue = options.find((option) => option.value !== "")?.value ?? "";
+
+    return (
+      <div className="settings-array">
+        {value.map((entry, index) => (
+          <div className="settings-array-row" key={`${path.join(".")}-${index}`}>
+            {options.length > 0 ? (
+              <select
+                aria-label={displayLabel ? `${displayLabel} ${index + 1}` : undefined}
+                className={settingsSelectClass}
+                value={optionValueFor(entry)}
+                onChange={(event) => {
+                  const updated = [...value];
+                  updated[index] = event.target.value;
+                  updateConfigValue(path, updated);
+                }}
+              >
+                {optionsFor(entry).map((option) => (
+                  <option key={option.value} value={option.value}>
+                    {option.label}
+                  </option>
+                ))}
+              </select>
+            ) : (
+              <input
+                aria-label={displayLabel ? `${displayLabel} ${index + 1}` : undefined}
+                className={settingsInputClass}
+                value={optionValueFor(entry)}
+                onChange={(event) => {
+                  const updated = [...value];
+                  updated[index] = event.target.value;
+                  updateConfigValue(path, updated);
+                }}
+              />
+            )}
+            <Button
+              type="button"
+              onClick={() => {
+                const updated = [...value];
+                updated.splice(index, 1);
+                updateConfigValue(path, updated);
+              }}
+            >
+              Remove
+            </Button>
+          </div>
+        ))}
+        <Button
+          type="button"
+          aria-label={displayLabel ? `Add ${displayLabel} item` : "Add item"}
+          onClick={() => updateConfigValue(path, [...value, newItemValue])}
+        >
+          Add item
+        </Button>
+      </div>
+    );
+  };
+
+  const renderField = (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => {
+    const displayLabel = meta?.label ?? formatLabel(label);
+    const typeHint = meta?.type;
+    if (Array.isArray(value)) {
+      return (
+        <div className="settings-field" key={path.join(".")}>
+          <span>{displayLabel}</span>
+          {renderArrayEditor(value, path, meta, displayLabel)}
+        </div>
+      );
+    }
+    if (meta?.options && meta.options.length > 0) {
+      const selectedValue = value === null ? "" : String(value ?? "");
+      const options = meta.options.some((option) => option.value === selectedValue)
+        ? meta.options
+        : [...meta.options, { value: selectedValue, label: selectedValue }];
+      return (
+        <label className="settings-field" key={path.join(".")}>
+          <span>{displayLabel}</span>
+          <select
+            className={settingsSelectClass}
+            value={selectedValue}
+            onChange={(event) => updateConfigValue(path, event.target.value)}
+          >
+            {options.map((option) => (
+              <option key={option.value} value={option.value}>
+                {option.label}
+              </option>
+            ))}
+          </select>
+        </label>
+      );
+    }
+    if (typeHint === "boolean" || typeof value === "boolean") {
+      return (
+        <div className="settings-switch-row" key={path.join(".")}>
+          <span>{displayLabel}</span>
+          <Switch
+            aria-label={displayLabel}
+            checked={Boolean(value)}
+            onChange={(event) => updateConfigValue(path, event.target.checked)}
+          />
+        </div>
+      );
+    }
+    if (typeHint === "number" || typeof value === "number") {
+      const numericValue = typeof value === "number" && Number.isFinite(value) ? value : 0;
+      return (
+        <label className="settings-field" key={path.join(".")}>
+          <span>{displayLabel}</span>
+          <input
+            className={settingsInputClass}
+            type="number"
+            value={numericValue}
+            onChange={(event) => updateConfigValue(path, Number(event.target.value))}
+          />
+        </label>
+      );
+    }
+    if (value && typeof value === "object") {
+      return (
+        <div className="settings-subgroup" key={path.join(".")}>
+          <div className="settings-subgroup__title">{displayLabel}</div>
+          <div className="settings-grid">
+            {Object.entries(value).map(([childKey, childValue]) =>
+              renderField(childKey, childValue, [...path, childKey]),
+            )}
+          </div>
+        </div>
+      );
+    }
+
+    return (
+      <label className="settings-field" key={path.join(".")}>
+        <span>{displayLabel}</span>
+        <input
+          className={settingsInputClass}
+          value={value === null ? "" : String(value ?? "")}
+          onChange={(event) => updateConfigValue(path, event.target.value)}
+        />
+      </label>
+    );
+  };
+
+  const renderMapSection = (
+    sectionKey: string,
+    sectionValue: ConfigMap,
+    options?: {
+      entriesKey?: string;
+      defaultKey?: string;
+      fieldMeta?: Record<string, FieldMeta>;
+      advancedOpen?: boolean;
+    },
+  ) => {
+    const entriesRoot = options?.entriesKey
+      ? (sectionValue[options.entriesKey] as ConfigMap) || {}
+      : sectionValue;
+    const entries = Object.entries(entriesRoot).filter(
+      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
+    ) as Array<[string, ConfigMap]>;
+    const defaultKey = options?.defaultKey;
+    const fieldMeta = options?.fieldMeta || {};
+    const advancedOpen = options?.advancedOpen ?? false;
+
+    return (
+      <div className="settings-map">
+        {defaultKey ? (
+          <div className="settings-subgroup">
+            <div className="settings-subgroup__title">{formatLabel(defaultKey)}</div>
+            {renderField(defaultKey, sectionValue[defaultKey] as ConfigValue, [
+              sectionKey,
+              defaultKey,
+            ])}
+          </div>
+        ) : null}
+
+        <div className="settings-map__header">
+          <p className="label">Entries</p>
+          <Button
+            type="button"
+            onClick={() => {
+              const name = globalThis.prompt("New entry name");
+              if (!name) return;
+              if (options?.entriesKey) {
+                addConfigKey([sectionKey, options.entriesKey], name, {});
+                return;
+              }
+              addConfigKey([sectionKey], name, {});
+            }}
+          >
+            Add entry
+          </Button>
+        </div>
+
+        <div className="settings-map__grid">
+          {entries.length === 0 ? (
+            <p className="muted">No entries yet.</p>
+          ) : (
+            entries.map(([key, value]) => (
+              <div className="settings-card" key={`${sectionKey}-${key}`}>
+                <div className="settings-card__header">
+                  <p className="value">{key}</p>
+                  <Button
+                    type="button"
+                    onClick={() => {
+                      if (options?.entriesKey) {
+                        removeConfigKey([sectionKey, options.entriesKey], key);
+                        return;
+                      }
+                      removeConfigKey([sectionKey], key);
+                    }}
+                  >
+                    Remove
+                  </Button>
+                </div>
+                <div className="settings-grid">
+                  {Object.entries(value)
+                    .filter(([childKey]) => {
+                      const meta = fieldMeta[childKey];
+                      if (meta?.advanced && !advancedOpen) return false;
+                      return true;
+                    })
+                    .map(([childKey, childValue]) =>
+                      renderField(
+                        childKey,
+                        childValue,
+                        [sectionKey, options?.entriesKey || "", key, childKey].filter(Boolean),
+                        fieldMeta[childKey],
+                      ),
+                    )}
+                </div>
+              </div>
+            ))
+          )}
+        </div>
+      </div>
+    );
+  };
+
+  const renderTorrentClientsSection = (advancedOpen: boolean) => {
+    if (
+      !configData ||
+      !configData.TorrentClients ||
+      typeof configData.TorrentClients !== "object" ||
+      Array.isArray(configData.TorrentClients)
+    ) {
+      return null;
+    }
+
+    const clients = Object.entries(configData.TorrentClients as ConfigMap).filter(
+      ([, value]) => value && typeof value === "object" && !Array.isArray(value),
+    ) as Array<[string, ConfigMap]>;
+    const meta = effectiveSectionFieldMeta.TorrentClients || {};
+    const valueFor = (client: ConfigMap, primary: string, fallback?: string) => {
+      const primaryValue = client[primary];
+      if (primaryValue !== undefined && primaryValue !== null && primaryValue !== "") {
+        return primaryValue;
+      }
+      return fallback ? client[fallback] : primaryValue;
+    };
+    const arrayFor = (client: ConfigMap, key: string) => {
+      const value = client[key];
+      return Array.isArray(value) ? value : [];
+    };
+    const qbitTagFor = (client: ConfigMap) => {
+      const direct = client.QbitTag;
+      if (typeof direct === "string" && direct.trim() !== "") return direct;
+      const qbitTags = normalizeStringArray(client.QbitTagsValue);
+      if (qbitTags.length > 0) return qbitTags.join(",");
+      return normalizeStringArray(client.Tags).join(",");
+    };
+    const hasDirectConfig = (client: ConfigMap) =>
+      ["QbitURL", "QbitPort", "QbitUser", "QbitPass", "URL", "Username", "Password"].some((key) => {
+        const value = client[key];
+        if (typeof value === "number") return value > 0;
+        return typeof value === "string" && value.trim() !== "";
+      });
+    const setQbitDirect = (name: string, enabled: boolean) => {
+      const client = clients.find(([clientName]) => clientName === name)?.[1];
+      if (!client) {
+        return;
+      }
+      const nextClient = nextQbitDirectState(client, enabled);
+      for (const key of [
+        "QbitURL",
+        "QbitPort",
+        "QbitUser",
+        "QbitPass",
+        "URL",
+        "Username",
+        "Password",
+        "QuiProxyURL",
+      ]) {
+        if (client[key] === nextClient[key]) {
+          continue;
+        }
+        updateConfigValue(["TorrentClients", name, key], nextClient[key]);
+      }
+    };
+
+    return (
+      <div className="settings-map">
+        <div className="settings-map__header">
+          <p className="label">Entries</p>
+          <Button
+            type="button"
+            onClick={() => {
+              const name = globalThis.prompt("New entry name");
+              if (!name) return;
+              addConfigKey(["TorrentClients"], name, qbitDefaultClient());
+            }}
+          >
+            Add entry
+          </Button>
+        </div>
+
+        <div className="settings-map__grid">
+          {clients.length === 0 ? (
+            <p className="muted">No entries yet.</p>
+          ) : (
+            clients.map(([name, client]) => {
+              const clientType = normalizeTorrentClientType(client);
+              const watchClient = clientType === "watch";
+              const directEnabled = !watchClient && hasDirectConfig(client);
+              return (
+                <div className="settings-card" key={`TorrentClients-${name}`}>
+                  <div className="settings-card__header">
+                    <p className="value">{name}</p>
+                    <Button type="button" onClick={() => removeConfigKey(["TorrentClients"], name)}>
+                      Remove
+                    </Button>
+                  </div>
+                  <div className="settings-grid">
+                    {renderField(
+                      "Type",
+                      valueFor(client, "Type", "TorrentClient") ?? "qbit",
+                      ["TorrentClients", name, "Type"],
+                      meta.Type,
+                    )}
+                    {watchClient
+                      ? renderField(
+                          "WatchFolder",
+                          client.WatchFolder ?? "",
+                          ["TorrentClients", name, "WatchFolder"],
+                          meta.WatchFolder,
+                        )
+                      : null}
+                    {watchClient
+                      ? renderField(
+                          "StorageDir",
+                          client.StorageDir ?? "",
+                          ["TorrentClients", name, "StorageDir"],
+                          meta.StorageDir,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "QuiProxyURL",
+                          client.QuiProxyURL ?? "",
+                          ["TorrentClients", name, "QuiProxyURL"],
+                          meta.QuiProxyURL,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "QbitCategoryValue",
+                          valueFor(client, "QbitCategoryValue", "Category") ?? "",
+                          ["TorrentClients", name, "QbitCategoryValue"],
+                          meta.QbitCategoryValue,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "QbitTag",
+                          qbitTagFor(client),
+                          ["TorrentClients", name, "QbitTag"],
+                          meta.QbitTag,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "QbitCrossCategory",
+                          client.QbitCrossCategory ?? "",
+                          ["TorrentClients", name, "QbitCrossCategory"],
+                          meta.QbitCrossCategory,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "QbitCrossTag",
+                          client.QbitCrossTag ?? "",
+                          ["TorrentClients", name, "QbitCrossTag"],
+                          meta.QbitCrossTag,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "UseTrackerAsTag",
+                          client.UseTrackerAsTag ?? false,
+                          ["TorrentClients", name, "UseTrackerAsTag"],
+                          meta.UseTrackerAsTag,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "Linking",
+                          client.Linking ?? "",
+                          ["TorrentClients", name, "Linking"],
+                          meta.Linking,
+                        )
+                      : null}
+                    {!watchClient ? (
+                      <div
+                        className="settings-switch-row"
+                        key={`TorrentClients-${name}-AllowFallback`}
+                      >
+                        <span>Allow link fallback</span>
+                        <Switch
+                          aria-label="Allow link fallback"
+                          checked={Boolean(client.AllowFallback ?? true)}
+                          onChange={(event) =>
+                            updateConfigValue(
+                              ["TorrentClients", name, "AllowFallback"],
+                              event.target.checked,
+                            )
+                          }
+                        />
+                      </div>
+                    ) : null}
+                    {!watchClient
+                      ? renderField(
+                          "LinkedFolder",
+                          arrayFor(client, "LinkedFolder"),
+                          ["TorrentClients", name, "LinkedFolder"],
+                          meta.LinkedFolder,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "LocalPath",
+                          arrayFor(client, "LocalPath"),
+                          ["TorrentClients", name, "LocalPath"],
+                          meta.LocalPath,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "RemotePath",
+                          arrayFor(client, "RemotePath"),
+                          ["TorrentClients", name, "RemotePath"],
+                          meta.RemotePath,
+                        )
+                      : null}
+                    {!watchClient
+                      ? renderField(
+                          "AutomaticManagementPaths",
+                          arrayFor(client, "AutomaticManagementPaths"),
+                          ["TorrentClients", name, "AutomaticManagementPaths"],
+                          meta.AutomaticManagementPaths,
+                        )
+                      : null}
+                    {!watchClient && advancedOpen
+                      ? renderField(
+                          "VerifyWebUICertificate",
+                          client.VerifyWebUICertificate ?? true,
+                          ["TorrentClients", name, "VerifyWebUICertificate"],
+                          meta.VerifyWebUICertificate,
+                        )
+                      : null}
+                  </div>
+
+                  {!watchClient ? (
+                    <div className="settings-switch-row">
+                      <span>qBit direct</span>
+                      <Switch
+                        aria-label="qBit direct"
+                        checked={directEnabled}
+                        onChange={(event) => setQbitDirect(name, event.target.checked)}
+                      />
+                    </div>
+                  ) : null}
+
+                  {!watchClient && directEnabled ? (
+                    <div className="settings-grid">
+                      {renderField(
+                        "QbitURL",
+                        valueFor(client, "QbitURL", "URL") ?? "",
+                        ["TorrentClients", name, "QbitURL"],
+                        meta.QbitURL,
+                      )}
+                      {renderField(
+                        "QbitPort",
+                        client.QbitPort ?? 0,
+                        ["TorrentClients", name, "QbitPort"],
+                        meta.QbitPort,
+                      )}
+                      {renderField(
+                        "QbitUser",
+                        valueFor(client, "QbitUser", "Username") ?? "",
+                        ["TorrentClients", name, "QbitUser"],
+                        meta.QbitUser,
+                      )}
+                      {renderField(
+                        "QbitPass",
+                        valueFor(client, "QbitPass", "Password") ?? "",
+                        ["TorrentClients", name, "QbitPass"],
+                        meta.QbitPass,
+                      )}
+                    </div>
+                  ) : null}
+                </div>
+              );
+            })
+          )}
+        </div>
+      </div>
+    );
+  };
+
+  /** Reports configured state from backend-owned activation markers. */
+  const isTrackerConfigured = useCallback(
+    (entry: TrackerCatalogEntry, trackerValue: ConfigMap): boolean =>
+      entry.fields.some(
+        (field) =>
+          field.activation && hasConfiguredTrackerValue(trackerValue[field.key], field.default),
+      ),
+    [],
+  );
+
+  const trackerSelectionNames = useMemo(() => {
+    if (
+      !configData ||
+      !configData.Trackers ||
+      typeof configData.Trackers !== "object" ||
+      Array.isArray(configData.Trackers)
+    ) {
+      return [] as string[];
+    }
+
+    const trackerRoot = configData.Trackers as ConfigMap;
+    const rawEntries = trackerRoot.Trackers;
+    const entriesRoot =
+      rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
+        ? (rawEntries as ConfigMap)
+        : {};
+    const draftTrackerSet = new Set(
+      Object.entries(draftTrackerEntries)
+        .filter(([, enabled]) => enabled)
+        .map(([name]) => name),
+    );
+
+    return (trackerCatalog?.entries ?? [])
+      .filter((entry) => {
+        const value = trackerConfigValue(entriesRoot, entry.name);
+        return (
+          draftTrackerSet.has(entry.name) ||
+          (value ? isTrackerConfigured(entry, value) : entry.configured)
+        );
+      })
+      .map((entry) => entry.name);
+  }, [configData, draftTrackerEntries, isTrackerConfigured, trackerCatalog]);
+
+  const renderTrackerSection = (advancedOpen: boolean) => {
+    try {
+      if (
+        !configData ||
+        !configData.Trackers ||
+        typeof configData.Trackers !== "object" ||
+        Array.isArray(configData.Trackers)
+      ) {
+        return null;
+      }
+
+      const trackerRoot = configData.Trackers as ConfigMap;
+      const defaultTrackers = (trackerRoot.DefaultTrackers as ConfigValue) ?? [];
+      const rawEntries = trackerRoot.Trackers;
+      const entriesRoot =
+        rawEntries && typeof rawEntries === "object" && !Array.isArray(rawEntries)
+          ? (rawEntries as ConfigMap)
+          : {};
+
+      const visibleTrackerSet = new Set(trackerSelectionNames);
+      const catalogEntries = trackerCatalog?.entries ?? [];
+      const visibleEntries = catalogEntries
+        .filter((entry) => visibleTrackerSet.has(entry.name))
+        .map((entry) => ({ entry, value: trackerConfigValue(entriesRoot, entry.name) ?? {} }));
+
+      const normalizedDefaultTrackers = normalizeDefaultTrackerList(defaultTrackers);
+      const preferredTrackerRaw = trackerRoot.PreferredTracker;
+      const preferredTracker =
+        typeof preferredTrackerRaw === "string" ? preferredTrackerRaw.trim() : "";
+      const trackerNames = trackerSelectionNames;
+      const normalizedTrackerNameSet = new Set(trackerNames.map((name) => name.toLowerCase()));
+      const selectedDefaultTrackerCount = normalizedDefaultTrackers.filter((name) =>
+        normalizedTrackerNameSet.has(name.toLowerCase()),
+      ).length;
+      const trackerOptions = catalogEntries.map((entry) => entry.name);
+      const availableTrackers = trackerOptions.filter((name) => !visibleTrackerSet.has(name));
+      const trackerClientOptions = [{ value: "", label: "" }, ...torrentClientOptions];
+
+      const trackerSchemaFor = (entry: TrackerCatalogEntry) => {
+        return entry.fields.map((field) => {
+          const base = trackerFieldPresentation(field.key);
+          if (field.key === "ImageHost") {
+            return { ...base, options: trackerOptionsForImageHost(entry.name) };
+          }
+          if (field.key === "TorrentClient") {
+            return { ...base, options: trackerClientOptions };
+          }
+          return base;
+        });
+      };
+
+      const buildTrackerDefaults = (entry: TrackerCatalogEntry) => {
+        const defaults: ConfigMap = {};
+        entry.fields.forEach((field) => {
+          defaults[field.key] = structuredClone(field.default);
+        });
+        return defaults;
+      };
+
+      const toggleDefaultTracker = (name: string, enabled: boolean) => {
+        const current = normalizeDefaultTrackerList(defaultTrackers);
+        const next = current.filter((entry) => entry !== name);
+        if (enabled) {
+          next.push(name);
+        }
+        updateConfigValue(["Trackers", "DefaultTrackers"], next);
+      };
+
+      const updatePreferredTracker = (value: string) => {
+        updateConfigValue(["Trackers", "PreferredTracker"], value.trim());
+      };
+
+      return (
+        <div className="settings-map">
+          <details
+            className="settings-subgroup settings-subgroup--collapsible"
+            open={defaultTrackersPanelOpen}
+            onToggle={(event) => {
+              const target = event.currentTarget as HTMLDetailsElement;
+              setDefaultTrackersPanelOpen(target.open);
+            }}
+          >
+            <summary className="settings-subgroup__title tracker-summary-heading">
+              <span>Default trackers</span>
+              <span className="tracker-summary-count">
+                {selectedDefaultTrackerCount}/{trackerNames.length}
+              </span>
+            </summary>
+            <div className="tracker-defaults-body">
+              {trackerNames.length === 0 ? (
+                <p className="muted">Add tracker entries to select defaults.</p>
+              ) : (
+                <div className="tracker-selection-container">
+                  <div className="tracker-pills">
+                    {trackerNames.map((tracker) => (
+                      <PillCheckbox
+                        key={tracker}
+                        checked={normalizedDefaultTrackers.includes(tracker)}
+                        onCheckedChange={(checked) => toggleDefaultTracker(tracker, checked)}
+                      >
+                        {tracker}
+                      </PillCheckbox>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+          </details>
+
+          <details className="settings-subgroup settings-subgroup--collapsible">
+            <summary className="settings-subgroup__title">Preferred tracker data source</summary>
+            <div style={{ paddingTop: "0.5rem" }}>
+              <div className="settings-map__controls">
+                <select
+                  className={settingsSelectClass}
+                  value={preferredTracker}
+                  onChange={(event) => updatePreferredTracker(event.target.value)}
+                >
+                  <option value="">None</option>
+                  {trackerOptions.map((name) => (
+                    <option key={name} value={name}>
+                      {name}
+                    </option>
+                  ))}
+                </select>
+                <Button
+                  type="button"
+                  disabled={preferredTracker === ""}
+                  onClick={() => updatePreferredTracker("")}
+                >
+                  Clear
+                </Button>
+              </div>
+              <p className="muted" style={{ marginTop: "0.5rem" }}>
+                Moves the selected tracker to the top of tracker-data lookup and qBit tracker
+                priority when present.
+              </p>
+            </div>
+          </details>
+
+          <div className="settings-map__header">
+            <p className="label">Entries</p>
+            <div className="settings-map__controls">
+              <select
+                className={settingsSelectClass}
+                value={trackerAddSelection}
+                onChange={(event) => setTrackerAddSelection(event.target.value)}
+                disabled={availableTrackers.length === 0}
+              >
+                <option value="">Select tracker</option>
+                {availableTrackers.map((name) => (
+                  <option key={name} value={name}>
+                    {name}
+                  </option>
+                ))}
+              </select>
+              <Button
+                type="button"
+                disabled={!trackerAddSelection}
+                onClick={() => {
+                  const name = trackerAddSelection.trim();
+                  if (!name) return;
+                  const entry = catalogEntries.find((candidate) => candidate.name === name);
+                  if (!entry) return;
+                  if (!trackerConfigValue(entriesRoot, name)) {
+                    addConfigKey(["Trackers", "Trackers"], name, buildTrackerDefaults(entry));
+                  }
+                  setDraftTrackerEntries((prev) => ({ ...prev, [name]: true }));
+                  setTrackerAddSelection("");
+                  setSettingsTrackerPanels((prev) => ({ ...prev, [name]: true }));
+                }}
+              >
+                Add entry
+              </Button>
+            </div>
+          </div>
+
+          <div className="settings-map__grid">
+            {visibleEntries.length === 0 ? (
+              <p className="muted">No configured entries yet.</p>
+            ) : (
+              visibleEntries.map(({ entry, value }) => {
+                const key = entry.name;
+                const schema = trackerSchemaFor(entry);
+                return (
+                  <details
+                    className="settings-card settings-card--collapsible"
+                    key={`Trackers-${key}`}
+                    open={settingsTrackerPanels[key] ?? false}
+                    onToggle={(event) => {
+                      const target = event.currentTarget as HTMLDetailsElement;
+                      setSettingsTrackerPanels((prev) => ({ ...prev, [key]: target.open }));
+                    }}
+                  >
+                    <summary className="settings-card__summary">
+                      <span className="settings-card__summary-name">{key}</span>
+                      <Button
+                        type="button"
+                        onClick={(event) => {
+                          event.preventDefault();
+                          event.stopPropagation();
+                          updateConfigValue(
+                            ["Trackers", "Trackers", key],
+                            buildTrackerDefaults(entry),
+                          );
+                          toggleDefaultTracker(key, false);
+                          if (preferredTracker.toLowerCase() === key.toLowerCase()) {
+                            updatePreferredTracker("");
+                          }
+                          setDraftTrackerEntries((prev) => {
+                            const next = { ...prev };
+                            delete next[key];
+                            return next;
+                          });
+                          setSettingsTrackerPanels((prev) => {
+                            const next = { ...prev };
+                            delete next[key];
+                            return next;
+                          });
+                        }}
+                      >
+                        Remove
+                      </Button>
+                    </summary>
+                    <div className="settings-card__body">
+                      <div className="settings-grid">
+                        {schema
+                          .filter((meta) => !(meta.advanced && !advancedOpen))
+                          .map((meta) =>
+                            renderField(
+                              meta.key,
+                              value[meta.key] ??
+                                entry.fields.find((field) => field.key === meta.key)?.default ??
+                                "",
+                              ["Trackers", "Trackers", key, meta.key],
+                              meta,
+                            ),
+                          )}
+                      </div>
+                    </div>
+                  </details>
+                );
+              })
+            )}
+          </div>
+
+          {(trackerCatalog?.unsupported.length ?? 0) > 0 ? (
+            <div className="settings-subgroup">
+              <div className="settings-subgroup__title">Unsupported tracker entries</div>
+              <p className="muted">
+                Preserved config has no matching tracker implementation and cannot be used.
+              </p>
+              <div className="settings-map__grid">
+                {trackerCatalog?.unsupported.map((name) => (
+                  <div className="settings-card" key={`unsupported-${name}`}>
+                    <div className="settings-card__summary">
+                      <span className="settings-card__summary-name">{name}</span>
+                      <Button
+                        type="button"
+                        onClick={() => {
+                          removeConfigKey(["Trackers", "Trackers"], name);
+                          removeUnsupported(name);
+                        }}
+                      >
+                        Delete
+                      </Button>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          ) : null}
+        </div>
+      );
+    } catch (err) {
+      return <p className="error">Unable to render tracker settings: {String(err)}</p>;
+    }
+  };
+
+  const renderImageHostingSection = () => {
+    if (!configData || !configData.ImageHosting || typeof configData.ImageHosting !== "object") {
+      return null;
+    }
+
+    const imageCfg = configData.ImageHosting as ConfigMap;
+    const hostFields = ["Host1", "Host2", "Host3", "Host4", "Host5", "Host6"];
+    const requiredKeys = new Set<string>();
+    hostFields.forEach((field) => {
+      const selected = String(imageCfg[field] ?? "").trim();
+      if (!selected) return;
+      const keys = imageHostKeyMap[selected];
+      if (keys) {
+        keys.forEach((key) => requiredKeys.add(key));
+      }
+    });
+
+    return (
+      <div className="settings-form">
+        <div className="settings-subgroup">
+          <div className="settings-subgroup__title">Host Priority</div>
+          <div className="settings-grid">
+            {hostFields.map((field, index) => (
+              <label className="settings-field" key={field}>
+                <span>{`Host ${index + 1}`}</span>
+                <select
+                  className={settingsSelectClass}
+                  value={String(imageCfg[field] ?? "")}
+                  onChange={(event) =>
+                    updateConfigValue(["ImageHosting", field], event.target.value)
+                  }
+                >
+                  {imageHostOptions.map((option) => (
+                    <option key={option.value} value={option.value}>
+                      {option.label}
+                    </option>
+                  ))}
+                </select>
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div className="settings-subgroup">
+          <div className="settings-subgroup__title">API Keys</div>
+          {requiredKeys.size === 0 ? (
+            <p className="muted">Select an image host to edit its API keys.</p>
+          ) : (
+            <div className="settings-grid">
+              {Array.from(requiredKeys).map((key) =>
+                renderField(key, imageCfg[key] as ConfigValue, ["ImageHosting", key]),
+              )}
+            </div>
+          )}
+        </div>
+
+        <div className="settings-subgroup">
+          <div className="settings-subgroup__title">Additional Hosts</div>
+          <div className="settings-grid">
+            <div className="settings-switch-row">
+              <span>Lostimg enabled</span>
+              <Switch
+                aria-label="Lostimg enabled"
+                checked={Boolean(imageCfg.LostimgEnabled)}
+                onChange={(event) =>
+                  updateConfigValue(["ImageHosting", "LostimgEnabled"], event.target.checked)
+                }
+              />
+            </div>
+            {renderField(
+              "LostimgAPI",
+              (imageCfg.LostimgAPI as ConfigValue) ?? "",
+              ["ImageHosting", "LostimgAPI"],
+              sectionFieldMeta.ImageHosting.LostimgAPI,
+            )}
+          </div>
+        </div>
+      </div>
+    );
+  };
+
+  return {
+    configData,
+    settingsLoading,
+    settingsDirty,
+    settingsSaved,
+    settingsError,
+    settingsSection,
+    settingsSections,
+    showAdvancedToggle,
+    advancedOpen,
+    setSettingsSection,
+    setSettingsAdvanced,
+    loadSettings,
+    handleSaveSettings,
+    renderImageHostingSection,
+    renderTrackerSection,
+    renderTorrentClientsSection,
+    renderMapSection,
+    renderField,
+    sectionFieldMeta: effectiveSectionFieldMeta,
+    updateConfigValue,
+    updateScreenshotConfigValue,
+    configuredImageHosts,
+    screenshotConfig,
+    buildSavePayload,
+    clearSettingsStatus,
+    markSettingsSaved,
+    setSettingsSavedMessage,
+    setSettingsErrorMessage,
+    resolveImageHostLabel,
+    knownTrackersLoading,
+    trackerSelectionNames,
+  };
+};
diff --git a/gui/frontend/src/hooks/useTrackerIcons.test.ts b/webui/src/hooks/useTrackerIcons.test.ts
similarity index 90%
rename from gui/frontend/src/hooks/useTrackerIcons.test.ts
rename to webui/src/hooks/useTrackerIcons.test.ts
index 01620ac4..87d7c59d 100644
--- a/gui/frontend/src/hooks/useTrackerIcons.test.ts
+++ b/webui/src/hooks/useTrackerIcons.test.ts
@@ -3,6 +3,7 @@
 
 import { cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { installAppOperationMocks } from "../test/appRequestMock";
 import type { TrackerUploadItem } from "../types";
 import { useTrackerIcons } from "./useTrackerIcons";
 
@@ -14,7 +15,7 @@ afterEach(() => {
 describe("useTrackerIcons", () => {
   it("does not fetch when favicons are disabled", () => {
     const getTrackerIcon = vi.fn().mockResolvedValue("data:image/png;base64,a");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
+    installAppOperationMocks({ GetTrackerIcon: getTrackerIcon });
     const trackers: TrackerUploadItem[] = [{ name: "AITHER", config: {} }];
 
     const { result } = renderHook(() => useTrackerIcons(trackers, false));
@@ -25,7 +26,7 @@ describe("useTrackerIcons", () => {
 
   it("fetches configured tracker icons through the app-level cache", async () => {
     const getTrackerIcon = vi.fn().mockResolvedValue("data:image/png;base64,a");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
+    installAppOperationMocks({ GetTrackerIcon: getTrackerIcon });
     const trackers: TrackerUploadItem[] = [
       { name: "AITHER", config: { FaviconURL: "https://icons.example/aither.png" } },
     ];
@@ -43,7 +44,7 @@ describe("useTrackerIcons", () => {
       .fn()
       .mockResolvedValueOnce("data:image/png;base64,a")
       .mockResolvedValueOnce("data:image/png;base64,b");
-    vi.stubGlobal("go", { guiapp: { App: { GetTrackerIcon: getTrackerIcon } } });
+    installAppOperationMocks({ GetTrackerIcon: getTrackerIcon });
     const firstTrackers: TrackerUploadItem[] = [{ name: "AITHER", config: {} }];
     const nextTrackers: TrackerUploadItem[] = [
       { name: "AITHER", config: {} },
diff --git a/gui/frontend/src/hooks/useTrackerIcons.ts b/webui/src/hooks/useTrackerIcons.ts
similarity index 96%
rename from gui/frontend/src/hooks/useTrackerIcons.ts
rename to webui/src/hooks/useTrackerIcons.ts
index dff29905..6e092582 100644
--- a/gui/frontend/src/hooks/useTrackerIcons.ts
+++ b/webui/src/hooks/useTrackerIcons.ts
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 import { useEffect, useRef, useState } from "react";
+import { trackerCatalogClient } from "../api/app";
 import type { TrackerUploadItem } from "../types";
 import { getTrackerDomain } from "../utils/favicon";
 
@@ -49,8 +50,7 @@ export function useTrackerIcons(
       }
     });
 
-    const getTrackerIcon = globalThis.go?.guiapp?.App?.GetTrackerIcon;
-    if (!getTrackerIcon) return;
+    const getTrackerIcon = trackerCatalogClient.getIcon;
 
     let active = true;
     trackerUploadItems.forEach((item) => {
diff --git a/webui/src/jobRegistry/coordinator.test.ts b/webui/src/jobRegistry/coordinator.test.ts
new file mode 100644
index 00000000..29527ca6
--- /dev/null
+++ b/webui/src/jobRegistry/coordinator.test.ts
@@ -0,0 +1,302 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { describe, expect, it, vi } from "vitest";
+import type { OwnerJobSnapshot, ReleaseRef } from "../types";
+import { JobRegistryCoordinator } from "./coordinator";
+import type { JobRegistryClock, JobRegistryTransport } from "./types";
+
+const release: ReleaseRef = { SourcePath: "C:\\media\\Example", Generation: 3 };
+
+const dupeJob = (
+  correlationID = "correlation-1",
+): Extract<OwnerJobSnapshot, { kind: "duplicate_check" }> => {
+  const dupe = {
+    jobID: "dupe-1",
+    correlationID,
+    release,
+    runtimeGeneration: 2,
+    status: "running",
+    trackers: [],
+    completedCount: 0,
+    totalCount: 1,
+    summary: {
+      SourcePath: release.SourcePath,
+      Results: [],
+      Notes: [],
+      Eligibility: { Release: release, Trackers: [], EligibleTrackers: [] },
+    },
+    startedAt: "2026-07-15T00:00:00Z",
+    finishedAt: "",
+  };
+  return {
+    kind: "duplicate_check",
+    jobID: dupe.jobID,
+    correlationID,
+    release,
+    status: dupe.status,
+    startedAt: dupe.startedAt,
+    finishedAt: "",
+    dupe,
+  };
+};
+
+const uploadJob = (
+  jobID = "upload-1",
+  correlationID = "upload-correlation",
+  retryOf?: string,
+): Extract<OwnerJobSnapshot, { kind: "tracker_upload" }> => ({
+  kind: "tracker_upload",
+  jobID,
+  correlationID,
+  retryOf,
+  release,
+  status: "failed",
+  startedAt: "2026-07-15T00:00:01Z",
+  finishedAt: "2026-07-15T00:00:02Z",
+  upload: {
+    jobID,
+    correlationID,
+    retryOf,
+    release,
+    runtimeGeneration: 2,
+    status: "failed",
+    currentTask: "upload",
+    currentTaskStatus: "failed",
+    currentMessage: "Upload failed.",
+    currentCompletedPieces: 0,
+    currentTotalPieces: 1,
+    currentPercent: 0,
+    currentHashRateMiB: 0,
+    trackers: [],
+    failedTrackers: ["GRP"],
+    uploadedCount: 0,
+    startedAt: "2026-07-15T00:00:01Z",
+    finishedAt: "2026-07-15T00:00:02Z",
+  },
+});
+
+class FakeClock implements JobRegistryClock {
+  callback: (() => void) | null = null;
+  cleared = false;
+
+  setInterval(callback: () => void) {
+    this.callback = callback;
+    return "poll";
+  }
+
+  clearInterval() {
+    this.cleared = true;
+    this.callback = null;
+  }
+
+  tick() {
+    this.callback?.();
+  }
+}
+
+const transportHarness = () => {
+  let jobs: OwnerJobSnapshot[] = [];
+  let listener: ((snapshot: OwnerJobSnapshot) => void) | null = null;
+  const transport = {
+    list: vi.fn(async () => jobs),
+    subscribe: vi.fn((next) => {
+      listener = next;
+      return () => {
+        listener = null;
+      };
+    }),
+    startDupe: vi.fn(async (_command, correlationID) => {
+      jobs = [dupeJob(correlationID)];
+      return "dupe-1";
+    }),
+    startUpload: vi.fn(async (_token: string, _correlationID: string) => "upload-1"),
+    retryUpload: vi.fn(async (_jobID: string, _correlationID: string) => "upload-2"),
+    cancelDupe: vi.fn(async () => undefined),
+    cancelUpload: vi.fn(async () => undefined),
+  } satisfies JobRegistryTransport;
+  return {
+    transport,
+    setJobs: (next: OwnerJobSnapshot[]) => {
+      jobs = next;
+    },
+    emit: (snapshot: OwnerJobSnapshot) => listener?.(snapshot),
+    hasListener: () => listener !== null,
+  };
+};
+
+describe("JobRegistryCoordinator", () => {
+  it("bootstraps, consumes one SSE stream, and polls through the owner listing", async () => {
+    const harness = transportHarness();
+    const clock = new FakeClock();
+    harness.setJobs([dupeJob()]);
+    const registry = new JobRegistryCoordinator(
+      "owner-a",
+      harness.transport,
+      clock,
+      10,
+      () => "next-correlation",
+    );
+    registry.start();
+    await vi.waitFor(() => expect(registry.snapshot().bootstrapped).toBe(true));
+    expect(registry.snapshot().jobs).toHaveLength(1);
+    expect(harness.transport.subscribe).toHaveBeenCalledOnce();
+
+    harness.emit({
+      ...dupeJob(),
+      status: "completed",
+      dupe: { ...dupeJob().dupe, status: "completed" },
+    });
+    expect(registry.snapshot().jobs[0].status).toBe("completed");
+    clock.tick();
+    await vi.waitFor(() => expect(harness.transport.list).toHaveBeenCalledTimes(2));
+
+    registry.dispose();
+    expect(clock.cleared).toBe(true);
+    expect(harness.hasListener()).toBe(false);
+  });
+
+  it("registers a pending correlation before awaiting start", async () => {
+    const harness = transportHarness();
+    const registry = new JobRegistryCoordinator(
+      "owner-a",
+      harness.transport,
+      new FakeClock(),
+      10,
+      () => "pending-correlation",
+    );
+    harness.transport.startDupe = vi.fn(async (_command, correlationID) => {
+      expect(registry.snapshot().pending[0]?.correlationID).toBe(correlationID);
+      harness.setJobs([dupeJob(correlationID)]);
+      return "dupe-1";
+    });
+    registry.start();
+    await registry.startDupe({ release, trackers: ["AITHER"] });
+
+    await vi.waitFor(() => expect(registry.snapshot().pending).toEqual([]));
+    expect(registry.snapshot().jobs[0].correlationID).toBe("pending-correlation");
+    registry.dispose();
+  });
+
+  it("does not restore pending state when SSE accepts a start before its response", async () => {
+    const harness = transportHarness();
+    let resolveStart: (jobID: string) => void = () => undefined;
+    const startResponse = new Promise<string>((resolve) => {
+      resolveStart = resolve;
+    });
+    harness.transport.startDupe = vi.fn(() => startResponse);
+    const registry = new JobRegistryCoordinator(
+      "owner-a",
+      harness.transport,
+      new FakeClock(),
+      10,
+      () => "sse-first-correlation",
+    );
+    registry.start();
+    await vi.waitFor(() => expect(registry.snapshot().bootstrapped).toBe(true));
+
+    const starting = registry.startDupe({ release, trackers: ["AITHER"] });
+    expect(registry.snapshot().pending).toHaveLength(1);
+    const accepted = dupeJob("sse-first-correlation");
+    harness.setJobs([accepted]);
+    harness.emit(accepted);
+    expect(registry.snapshot().pending).toEqual([]);
+
+    resolveStart("dupe-1");
+    await expect(starting).resolves.toBe("dupe-1");
+    expect(registry.snapshot().pending).toEqual([]);
+    registry.dispose();
+  });
+
+  it("recovers an accepted start after its response is lost", async () => {
+    const harness = transportHarness();
+    const registry = new JobRegistryCoordinator(
+      "owner-a",
+      harness.transport,
+      new FakeClock(),
+      10,
+      () => "lost-correlation",
+    );
+    harness.transport.startDupe = vi.fn(async (_command, correlationID) => {
+      harness.setJobs([dupeJob(correlationID)]);
+      throw new Error("connection lost");
+    });
+    registry.start();
+
+    await expect(registry.startDupe({ release, trackers: ["AITHER"] })).resolves.toBe("dupe-1");
+    expect(registry.snapshot().pending).toEqual([]);
+    registry.dispose();
+  });
+
+  it("keeps transient listing errors separate from canonical Job state", async () => {
+    const harness = transportHarness();
+    const registry = new JobRegistryCoordinator("owner-a", harness.transport, new FakeClock());
+    harness.setJobs([dupeJob()]);
+    await registry.refresh();
+    harness.transport.list = vi.fn(async () => {
+      throw new Error("poll unavailable");
+    });
+    await registry.refresh();
+
+    expect(registry.snapshot().jobs).toHaveLength(1);
+    expect(registry.snapshot().transientError).toBe("poll unavailable");
+  });
+
+  it("routes explicit cancellation by Job kind", async () => {
+    const harness = transportHarness();
+    const registry = new JobRegistryCoordinator("owner-a", harness.transport, new FakeClock());
+
+    await registry.cancel(dupeJob());
+    await registry.cancel(uploadJob());
+
+    expect(harness.transport.cancelDupe).toHaveBeenCalledWith("dupe-1");
+    expect(harness.transport.cancelUpload).toHaveBeenCalledWith("upload-1");
+  });
+
+  it("registers linked upload retries before awaiting the replacement", async () => {
+    const harness = transportHarness();
+    const registry = new JobRegistryCoordinator(
+      "owner-a",
+      harness.transport,
+      new FakeClock(),
+      10,
+      () => "retry-correlation",
+    );
+    harness.transport.retryUpload = vi.fn(async (jobID, correlationID) => {
+      expect(registry.snapshot().pending).toEqual([
+        expect.objectContaining({
+          correlationID,
+          retryOf: jobID,
+          release,
+        }),
+      ]);
+      return "upload-2";
+    });
+
+    await expect(registry.retryUpload(uploadJob())).resolves.toBe("upload-2");
+    expect(harness.transport.retryUpload).toHaveBeenCalledWith("upload-1", "retry-correlation");
+    expect(registry.snapshot().pending).toEqual([
+      expect.objectContaining({
+        acceptedJobID: "upload-2",
+        retryOf: "upload-1",
+      }),
+    ]);
+    registry.dispose();
+  });
+
+  it("rebuilds immutable retained history from owner listing", async () => {
+    const harness = transportHarness();
+    const retainedUpload = uploadJob();
+    const listed: OwnerJobSnapshot[] = [retainedUpload, dupeJob()];
+    harness.setJobs(listed);
+    const registry = new JobRegistryCoordinator("owner-a", harness.transport, new FakeClock());
+
+    await registry.refresh();
+    expect(registry.snapshot().jobs.map((job) => job.jobID)).toEqual(["dupe-1", "upload-1"]);
+    retainedUpload.upload.failedTrackers[0] = "mutated";
+    expect(
+      (registry.snapshot().jobs[1] as Extract<OwnerJobSnapshot, { kind: "tracker_upload" }>).upload
+        .failedTrackers,
+    ).toEqual(["GRP"]);
+  });
+});
diff --git a/webui/src/jobRegistry/coordinator.ts b/webui/src/jobRegistry/coordinator.ts
new file mode 100644
index 00000000..bc2eea78
--- /dev/null
+++ b/webui/src/jobRegistry/coordinator.ts
@@ -0,0 +1,190 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { OwnerJobSnapshot, ReleaseRef } from "../types";
+import type {
+  DupeStartCommand,
+  JobRegistryClock,
+  JobRegistryState,
+  JobRegistryTransport,
+  PendingJobStart,
+} from "./types";
+
+const defaultClock: JobRegistryClock = {
+  setInterval: (callback, delayMs) => globalThis.setInterval(callback, delayMs),
+  clearInterval: (handle) => globalThis.clearInterval(handle as ReturnType<typeof setInterval>),
+};
+
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;
+
+const compareJobs = (left: OwnerJobSnapshot, right: OwnerJobSnapshot) => {
+  const byTime = left.startedAt.localeCompare(right.startedAt);
+  return byTime !== 0 ? byTime : left.jobID.localeCompare(right.jobID);
+};
+
+const sameRelease = (left: ReleaseRef, right: ReleaseRef) =>
+  left.SourcePath === right.SourcePath && left.Generation === right.Generation;
+
+const safeError = (error: unknown) =>
+  error instanceof Error && error.message ? error.message : String(error);
+
+export class JobRegistryCoordinator {
+  private readonly listeners = new Set<() => void>();
+  private readonly jobs = new Map<string, OwnerJobSnapshot>();
+  private readonly pending = new Map<string, PendingJobStart>();
+  private unsubscribe: (() => void) | null = null;
+  private pollHandle: unknown;
+  private disposed = false;
+  private bootstrapped = false;
+  private transientError = "";
+  private refreshRevision = 0;
+  private currentState: JobRegistryState = {
+    jobs: [],
+    pending: [],
+    bootstrapped: false,
+    transientError: "",
+  };
+
+  constructor(
+    readonly ownerKey: string,
+    private readonly transport: JobRegistryTransport,
+    private readonly clock: JobRegistryClock = defaultClock,
+    private readonly pollIntervalMs = 1500,
+    private readonly newCorrelationID: () => string = () =>
+      globalThis.crypto?.randomUUID?.() ??
+      `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,
+  ) {}
+
+  start() {
+    if (this.disposed || this.unsubscribe) return;
+    this.unsubscribe = this.transport.subscribe((snapshot) => this.applySnapshot(snapshot));
+    this.pollHandle = this.clock.setInterval(() => void this.refresh(), this.pollIntervalMs);
+    void this.refresh();
+  }
+
+  subscribe(listener: () => void) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  snapshot(): JobRegistryState {
+    return this.currentState;
+  }
+
+  async refresh() {
+    const revision = ++this.refreshRevision;
+    try {
+      const listed = await this.transport.list();
+      if (this.disposed || revision !== this.refreshRevision) return;
+      this.jobs.clear();
+      listed.forEach((job) => this.jobs.set(job.jobID, clone(job)));
+      for (const [correlationID] of this.pending) {
+        if (listed.some((job) => job.correlationID === correlationID)) {
+          this.pending.delete(correlationID);
+        }
+      }
+      this.bootstrapped = true;
+      this.transientError = "";
+      this.emit();
+    } catch (error) {
+      if (this.disposed || revision !== this.refreshRevision) return;
+      this.bootstrapped = true;
+      this.transientError = safeError(error);
+      this.emit();
+    }
+  }
+
+  startDupe(command: DupeStartCommand) {
+    return this.startJob("duplicate_check", command.release, (correlationID) =>
+      this.transport.startDupe(command, correlationID),
+    );
+  }
+
+  startUpload(release: ReleaseRef, token: string) {
+    return this.startJob("tracker_upload", release, (correlationID) =>
+      this.transport.startUpload(token, correlationID),
+    );
+  }
+
+  retryUpload(job: OwnerJobSnapshot) {
+    return this.startJob(
+      "tracker_upload",
+      job.release,
+      (correlationID) => this.transport.retryUpload(job.jobID, correlationID),
+      job.jobID,
+    );
+  }
+
+  cancel(job: OwnerJobSnapshot) {
+    return job.kind === "duplicate_check"
+      ? this.transport.cancelDupe(job.jobID)
+      : this.transport.cancelUpload(job.jobID);
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.refreshRevision++;
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    if (this.pollHandle !== undefined) this.clock.clearInterval(this.pollHandle);
+    this.listeners.clear();
+    this.jobs.clear();
+    this.pending.clear();
+  }
+
+  private async startJob(
+    kind: OwnerJobSnapshot["kind"],
+    release: ReleaseRef,
+    start: (correlationID: string) => Promise<string>,
+    retryOf?: string,
+  ) {
+    const correlationID = this.newCorrelationID();
+    this.pending.set(correlationID, { kind, correlationID, release: clone(release), retryOf });
+    this.emit();
+    try {
+      const jobID = await start(correlationID);
+      if (this.disposed) return jobID;
+      if (this.pending.has(correlationID)) {
+        this.pending.set(correlationID, {
+          kind,
+          correlationID,
+          release: clone(release),
+          retryOf,
+          acceptedJobID: jobID,
+        });
+        this.emit();
+      }
+      void this.refresh();
+      return jobID;
+    } catch (error) {
+      await this.refresh();
+      const recovered = Array.from(this.jobs.values()).find(
+        (job) => job.correlationID === correlationID && sameRelease(job.release, release),
+      );
+      this.pending.delete(correlationID);
+      this.emit();
+      if (recovered) return recovered.jobID;
+      throw error;
+    }
+  }
+
+  private applySnapshot(snapshot: OwnerJobSnapshot) {
+    if (this.disposed) return;
+    this.jobs.set(snapshot.jobID, clone(snapshot));
+    this.pending.delete(snapshot.correlationID);
+    this.transientError = "";
+    this.emit();
+  }
+
+  private emit() {
+    if (this.disposed) return;
+    this.currentState = {
+      jobs: clone(Array.from(this.jobs.values()).sort(compareJobs)),
+      pending: clone(Array.from(this.pending.values())),
+      bootstrapped: this.bootstrapped,
+      transientError: this.transientError,
+    };
+    this.listeners.forEach((listener) => listener());
+  }
+}
diff --git a/webui/src/jobRegistry/index.tsx b/webui/src/jobRegistry/index.tsx
new file mode 100644
index 00000000..833bac66
--- /dev/null
+++ b/webui/src/jobRegistry/index.tsx
@@ -0,0 +1,86 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { ReactNode } from "react";
+import { createContext, useContext, useEffect, useMemo, useSyncExternalStore } from "react";
+import type { OwnerJobSnapshot, ReleaseRef } from "../types";
+import { JobRegistryCoordinator } from "./coordinator";
+import { productionJobRegistryTransport } from "./production";
+import type { DupeStartCommand, JobRegistryState, JobRegistryTransport } from "./types";
+
+const RegistryContext = createContext<JobRegistryCoordinator | null>(null);
+
+export function JobRegistryProvider({
+  ownerKey,
+  transport,
+  children,
+}: Readonly<{
+  ownerKey: string;
+  transport?: JobRegistryTransport;
+  children: ReactNode;
+}>) {
+  const coordinator = useMemo(
+    () => new JobRegistryCoordinator(ownerKey, transport ?? productionJobRegistryTransport()),
+    [ownerKey, transport],
+  );
+  useEffect(() => {
+    coordinator.start();
+    return () => coordinator.dispose();
+  }, [coordinator]);
+  return <RegistryContext.Provider value={coordinator}>{children}</RegistryContext.Provider>;
+}
+
+const useCoordinatorState = (): [JobRegistryCoordinator, JobRegistryState] => {
+  const coordinator = useContext(RegistryContext);
+  if (!coordinator) throw new Error("JobRegistryProvider is required");
+  const state = useSyncExternalStore(
+    (listener) => coordinator.subscribe(listener),
+    () => coordinator.snapshot(),
+    () => coordinator.snapshot(),
+  );
+  return [coordinator, state];
+};
+
+const isSameRelease = (left: ReleaseRef, right: ReleaseRef) =>
+  left.SourcePath === right.SourcePath && left.Generation === right.Generation;
+
+/** Current exact-generation duplicate/upload Jobs and narrow lifecycle commands. */
+export const useReleaseJobs = (release: ReleaseRef) => {
+  const [coordinator, state] = useCoordinatorState();
+  const releaseJobs = state.jobs.filter((job) => isSameRelease(job.release, release));
+  const dupeJobs = releaseJobs.filter(
+    (job): job is Extract<OwnerJobSnapshot, { kind: "duplicate_check" }> =>
+      job.kind === "duplicate_check",
+  );
+  const uploadJobs = releaseJobs.filter(
+    (job): job is Extract<OwnerJobSnapshot, { kind: "tracker_upload" }> =>
+      job.kind === "tracker_upload",
+  );
+  const dupe = dupeJobs[dupeJobs.length - 1];
+  const upload = uploadJobs[uploadJobs.length - 1];
+  return {
+    dupe,
+    upload,
+    pending: state.pending.filter((job) => isSameRelease(job.release, release)),
+    bootstrapped: state.bootstrapped,
+    transientError: state.transientError,
+    startDupe: (command: Omit<DupeStartCommand, "release">) =>
+      coordinator.startDupe({ ...command, release }),
+    startUpload: (token: string) => coordinator.startUpload(release, token),
+    retryUpload: (job: OwnerJobSnapshot) => coordinator.retryUpload(job),
+    cancel: (job: OwnerJobSnapshot) => coordinator.cancel(job),
+  } as const;
+};
+
+/** Immutable retained Job history for shell notifications. */
+export const useJobNotifications = () => {
+  const [, state] = useCoordinatorState();
+  return {
+    jobs: state.jobs,
+    pending: state.pending,
+    bootstrapped: state.bootstrapped,
+    transientError: state.transientError,
+  } as const;
+};
+
+export type { JobRegistryTransport } from "./types";
diff --git a/webui/src/jobRegistry/production.ts b/webui/src/jobRegistry/production.ts
new file mode 100644
index 00000000..f6df35b3
--- /dev/null
+++ b/webui/src/jobRegistry/production.ts
@@ -0,0 +1,19 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { dupeClient, jobsClient, uploadClient } from "../api/app";
+import { subscribeWebEvent } from "../api/client";
+import type { OwnerJobSnapshot } from "../types";
+import type { JobRegistryTransport } from "./types";
+
+export const productionJobRegistryTransport = (): JobRegistryTransport => ({
+  list: jobsClient.list,
+  subscribe: (listener) =>
+    subscribeWebEvent("jobs:update", (payload) => listener(payload as OwnerJobSnapshot)),
+  startDupe: (command, correlationID) =>
+    dupeClient.start(command.release, [...command.trackers], correlationID),
+  startUpload: uploadClient.startReviewed,
+  retryUpload: uploadClient.retryFailed,
+  cancelDupe: dupeClient.cancel,
+  cancelUpload: uploadClient.cancel,
+});
diff --git a/webui/src/jobRegistry/types.ts b/webui/src/jobRegistry/types.ts
new file mode 100644
index 00000000..2d64b5db
--- /dev/null
+++ b/webui/src/jobRegistry/types.ts
@@ -0,0 +1,39 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { OwnerJobSnapshot, ReleaseRef } from "../types";
+
+export type DupeStartCommand = Readonly<{
+  release: ReleaseRef;
+  trackers: readonly string[];
+}>;
+
+export type PendingJobStart = Readonly<{
+  kind: OwnerJobSnapshot["kind"];
+  correlationID: string;
+  release: ReleaseRef;
+  retryOf?: string;
+  acceptedJobID?: string;
+}>;
+
+export type JobRegistryState = Readonly<{
+  jobs: readonly OwnerJobSnapshot[];
+  pending: readonly PendingJobStart[];
+  bootstrapped: boolean;
+  transientError: string;
+}>;
+
+export type JobRegistryTransport = Readonly<{
+  list: () => Promise<OwnerJobSnapshot[]>;
+  subscribe: (listener: (snapshot: OwnerJobSnapshot) => void) => () => void;
+  startDupe: (command: DupeStartCommand, correlationID: string) => Promise<string>;
+  startUpload: (token: string, correlationID: string) => Promise<string>;
+  retryUpload: (jobID: string, correlationID: string) => Promise<string>;
+  cancelDupe: (jobID: string) => Promise<void>;
+  cancelUpload: (jobID: string) => Promise<void>;
+}>;
+
+export type JobRegistryClock = Readonly<{
+  setInterval: (callback: () => void, delayMs: number) => unknown;
+  clearInterval: (handle: unknown) => void;
+}>;
diff --git a/gui/frontend/src/main.tsx b/webui/src/main.tsx
similarity index 100%
rename from gui/frontend/src/main.tsx
rename to webui/src/main.tsx
diff --git a/webui/src/pages/bluray_candidates/index.tsx b/webui/src/pages/bluray_candidates/index.tsx
new file mode 100644
index 00000000..a6c5c461
--- /dev/null
+++ b/webui/src/pages/bluray_candidates/index.tsx
@@ -0,0 +1,210 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { InputFacet } from "../../releaseSession/types";
+import type { BlurayReleaseCandidate } from "../../types";
+import { handleExternalLinkClick } from "../../utils/externalLinks";
+
+type Props = {
+  facet: InputFacet;
+  setLightboxImage: (url: string) => void;
+  setLightboxAlt: (alt: string) => void;
+};
+
+const scoreLabel = (candidate: BlurayReleaseCandidate) => `${candidate.Score.toFixed(1)}/100`;
+
+export default function BlurayCandidatesPage(props: Props) {
+  const { facet, setLightboxImage, setLightboxAlt } = props;
+  const selecting = facet.view.status === "running";
+  const error = facet.view.error;
+  const bluray = facet.view.preview?.Bluray;
+  const candidates = bluray?.Candidates || [];
+  const selectedID = bluray?.SelectedReleaseID || "";
+
+  return (
+    <section className="flex flex-col gap-3">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Blu-ray.com</p>
+        <h1>Release Candidates</h1>
+        <p className="subtitle">Best accepted match loads by score; select another release here.</p>
+      </header>
+
+      {error ? <p className="error">{error}</p> : null}
+
+      {!bluray ? (
+        <section className="panel">
+          <p className="muted">No Blu-ray.com lookup data available.</p>
+        </section>
+      ) : (
+        <>
+          <section className="panel grid gap-2 py-3">
+            <div className="grid grid-cols-[repeat(auto-fit,minmax(150px,1fr))] gap-2">
+              <div>
+                <p className="label">Best score</p>
+                <p className="value">{bluray.BestScore.toFixed(1)}</p>
+              </div>
+              <div>
+                <p className="label">Required score</p>
+                <p className="value">{bluray.Threshold.toFixed(1)}</p>
+              </div>
+              <div>
+                <p className="label">Auto-selected</p>
+                <p className="value">{bluray.AutoSelected ? "Yes" : "No"}</p>
+              </div>
+              <div>
+                <p className="label">Candidates</p>
+                <p className="value">{candidates.length}</p>
+              </div>
+            </div>
+            {bluray.SearchURL ? (
+              <a
+                className="tracker-link w-fit"
+                href={bluray.SearchURL}
+                target="_blank"
+                rel="noreferrer"
+                onAuxClick={handleExternalLinkClick}
+                onClick={handleExternalLinkClick}
+              >
+                Open search
+              </a>
+            ) : null}
+            {!selectedID && bluray.SelectionReason ? (
+              <p className="m-0 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100">
+                {bluray.SelectionReason}
+              </p>
+            ) : null}
+          </section>
+
+          {candidates.length === 0 ? (
+            <section className="panel">
+              <p className="muted">No release candidates found.</p>
+            </section>
+          ) : (
+            <div className="grid gap-3">
+              {candidates.map((candidate) => {
+                const selected = candidate.ReleaseID === selectedID || candidate.Accepted;
+                const hasReleaseID = Boolean(candidate.ReleaseID);
+                return (
+                  <section
+                    className={`panel grid gap-3 ${selected ? "border-[var(--sidebar-active-border)]" : ""}`}
+                    key={candidate.ReleaseID || candidate.URL}
+                  >
+                    <div className="flex flex-wrap items-start justify-between gap-3">
+                      <div className="min-w-0">
+                        <h2 className="[overflow-wrap:anywhere]">{candidate.Title || "-"}</h2>
+                        <p className="muted [overflow-wrap:anywhere]">
+                          {[candidate.MovieTitle, candidate.MovieYear].filter(Boolean).join(" ")}
+                        </p>
+                      </div>
+                      <button
+                        className={selected ? "primary" : "ghost"}
+                        type="button"
+                        disabled={selecting || selected || !hasReleaseID}
+                        onClick={() => {
+                          if (hasReleaseID) void facet.selectCandidate(candidate.ReleaseID);
+                        }}
+                      >
+                        {selected ? "Selected" : selecting ? "Selecting..." : "Select"}
+                      </button>
+                    </div>
+
+                    <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,1fr))] gap-2">
+                      <div>
+                        <p className="label">Score</p>
+                        <p className="value">{scoreLabel(candidate)}</p>
+                      </div>
+                      <div>
+                        <p className="label">Country</p>
+                        <p className="value">{candidate.Country || "-"}</p>
+                      </div>
+                      <div>
+                        <p className="label">Region</p>
+                        <p className="value">{candidate.Region || "-"}</p>
+                      </div>
+                      <div>
+                        <p className="label">Publisher</p>
+                        <p className="value">{candidate.Publisher || "-"}</p>
+                      </div>
+                      <div>
+                        <p className="label">Disc</p>
+                        <p className="value">{candidate.Specs?.Discs?.Format || "-"}</p>
+                      </div>
+                    </div>
+
+                    {candidate.URL ? (
+                      <a
+                        className="tracker-link w-fit"
+                        href={candidate.URL}
+                        target="_blank"
+                        rel="noreferrer"
+                        onAuxClick={handleExternalLinkClick}
+                        onClick={handleExternalLinkClick}
+                      >
+                        Open release
+                      </a>
+                    ) : null}
+
+                    <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
+                      <div>
+                        <p className="label">Video</p>
+                        <p className="value">
+                          {[candidate.Specs?.Video?.Codec, candidate.Specs?.Video?.Resolution]
+                            .filter(Boolean)
+                            .join(" ") || "-"}
+                        </p>
+                      </div>
+                      <div>
+                        <p className="label">Audio</p>
+                        <p className="value [overflow-wrap:anywhere]">
+                          {(candidate.Specs?.Audio || []).slice(0, 3).join("; ") || "-"}
+                        </p>
+                      </div>
+                      <div>
+                        <p className="label">Subtitles</p>
+                        <p className="value [overflow-wrap:anywhere]">
+                          {(candidate.Specs?.Subtitles || []).slice(0, 6).join(", ") || "-"}
+                        </p>
+                      </div>
+                    </div>
+
+                    {candidate.MatchNotes?.length ? (
+                      <div>
+                        <p className="label">Score notes</p>
+                        <p className="value [overflow-wrap:anywhere]">
+                          {candidate.MatchNotes.slice(0, 5).join(" | ")}
+                        </p>
+                      </div>
+                    ) : null}
+
+                    {candidate.CoverImages?.length ? (
+                      <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,160px))] gap-2">
+                        {candidate.CoverImages.map((image) => (
+                          <button
+                            className="cursor-pointer border-0 bg-transparent p-0"
+                            type="button"
+                            key={`${candidate.ReleaseID}-${image.Kind}-${image.URL}`}
+                            onClick={() => {
+                              setLightboxImage(image.URL);
+                              setLightboxAlt(`${candidate.Title} ${image.Kind}`);
+                            }}
+                          >
+                            <img
+                              className="w-full rounded-md border border-white/10"
+                              src={image.URL}
+                              alt={image.Kind || "Blu-ray cover"}
+                              loading="lazy"
+                            />
+                          </button>
+                        ))}
+                      </div>
+                    ) : null}
+                  </section>
+                );
+              })}
+            </div>
+          )}
+        </>
+      )}
+    </section>
+  );
+}
diff --git a/webui/src/pages/description_builder/index.test.tsx b/webui/src/pages/description_builder/index.test.tsx
new file mode 100644
index 00000000..0c50cad6
--- /dev/null
+++ b/webui/src/pages/description_builder/index.test.tsx
@@ -0,0 +1,67 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { DescriptionsFacet } from "../../releaseSession/types";
+import DescriptionBuilderPage from "./index";
+
+afterEach(cleanup);
+
+const facet = (): DescriptionsFacet => ({
+  view: {
+    revision: 1,
+    status: "ready",
+    preview: {
+      SourcePath: "C:\\media\\Example",
+      ContentFailures: [],
+      Groups: [
+        {
+          GroupKey: "unit3d",
+          Trackers: ["EXAMPLE"],
+          RawDescription: "raw",
+          RawDescriptionHTML: "<p>raw</p>",
+          Description: "raw",
+          DescriptionHTML: "<p>raw</p>",
+          HasOverride: false,
+          ImageHost: {
+            Status: "ready",
+            SelectedHost: "",
+            AllowedHosts: [],
+            Reuploaded: false,
+            Message: "",
+          },
+        },
+      ],
+    },
+    rawByGroup: { unit3d: "raw" },
+    renderedByGroup: { unit3d: "<p>raw</p>" },
+    dirtyGroups: [],
+    staleReason: "",
+    notice: "",
+    error: "",
+  },
+  load: vi.fn(async () => true),
+  edit: vi.fn(),
+  render: vi.fn(async () => true),
+  save: vi.fn(async () => true),
+  reset: vi.fn(async () => true),
+});
+
+describe("DescriptionBuilderPage", () => {
+  it("forwards edits and explicit save through the facet", () => {
+    const descriptions = facet();
+    render(
+      <DescriptionBuilderPage
+        facet={descriptions}
+        sourcePath="C:\\media\\Example"
+        trackerIconSrcByName={{}}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Expand" }));
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "changed" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save group" }));
+    expect(descriptions.edit).toHaveBeenCalledWith("unit3d", "changed");
+    expect(descriptions.save).toHaveBeenCalledWith("unit3d");
+  });
+});
diff --git a/webui/src/pages/description_builder/index.tsx b/webui/src/pages/description_builder/index.tsx
new file mode 100644
index 00000000..36850143
--- /dev/null
+++ b/webui/src/pages/description_builder/index.tsx
@@ -0,0 +1,225 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useState } from "react";
+import RenderedDescription from "../../components/RenderedDescription";
+import { TrackerIconImage } from "../../components/ui/tracker-icon";
+import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
+import { trackerIconFor } from "../../hooks/useTrackerIcons";
+import type { DescriptionsFacet } from "../../releaseSession/types";
+
+type Props = {
+  facet: DescriptionsFacet;
+  sourcePath: string;
+  useFavicons?: boolean;
+  faviconOnly?: boolean;
+  trackerIconSrcByName?: TrackerIconCache;
+};
+
+const groupLabel = (groupKey: string, trackers: string[]) => {
+  if (trackers.length > 0) return trackers.join(", ");
+  if (groupKey === "unit3d") return "Unit3D";
+  return groupKey || "Description";
+};
+
+export default function DescriptionBuilderPage(props: Props) {
+  const {
+    facet,
+    sourcePath,
+    useFavicons = true,
+    faviconOnly = false,
+    trackerIconSrcByName = {},
+  } = props;
+  const [expandedGroups, setExpandedGroups] = useState<Record<string, boolean>>({});
+  const { view } = facet;
+  const groups = view.preview?.Groups || [];
+  const builderLoading = view.status === "running";
+  const builderError = view.error;
+  const builderSaved = view.notice;
+
+  return (
+    <section className="flex flex-col gap-3">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Description Builder</p>
+        <h1>Customize Description</h1>
+        <p className="subtitle">
+          Edit tracker-group raw descriptions here. Tracker-specific formatting is applied from this
+          builder.
+        </p>
+      </header>
+
+      <section className="panel flex flex-wrap items-center justify-between gap-3 py-3">
+        <div className="min-w-0">
+          <p className="label">Source path</p>
+          <p className="value [overflow-wrap:anywhere] text-sm">
+            {sourcePath || "No path selected"}
+          </p>
+        </div>
+        <button
+          className="ghost"
+          type="button"
+          onClick={() => void facet.load()}
+          disabled={builderLoading || !sourcePath.trim()}
+        >
+          {builderLoading ? "Refreshing..." : "Refresh descriptions"}
+        </button>
+      </section>
+
+      {builderError ? <p className="error">{builderError}</p> : null}
+      {builderSaved ? <p className="success">{builderSaved}</p> : null}
+
+      {builderLoading && groups.length === 0 ? (
+        <section className="panel">
+          <div className="mb-2 flex flex-col gap-1">
+            <h2>Building Descriptions</h2>
+          </div>
+          <p className="muted">
+            Preparing tracker-group descriptions and image-host adjustments...
+          </p>
+        </section>
+      ) : groups.length === 0 ? (
+        <section className="panel">
+          <p className="muted">No tracker descriptions generated yet.</p>
+        </section>
+      ) : (
+        groups.map((group, i) => {
+          const groupKey = group.GroupKey;
+          const reactKey = groupKey || `default-${i}`;
+          const seededRaw = group.RawDescription || "";
+          const raw = view.rawByGroup[groupKey] ?? seededRaw;
+          const seededRendered = group.RawDescriptionHTML || "";
+          const renderedHTML = view.renderedByGroup[groupKey] ?? seededRendered;
+          const expanded = expandedGroups[groupKey] ?? false;
+          const trackers = (group.Trackers || []).map((tracker) => tracker.trim()).filter(Boolean);
+          const label = groupLabel(groupKey, trackers);
+          const hideTrackerNames = faviconOnly && useFavicons && trackers.length > 0;
+          const imageHostWarnings = group.ImageHost?.Warnings || [];
+
+          return (
+            <section className="panel grid gap-3" key={reactKey}>
+              <div className="mb-1 flex flex-wrap items-start justify-between gap-3">
+                <div>
+                  <h2>
+                    <span
+                      aria-label={hideTrackerNames ? label : undefined}
+                      className="inline-flex flex-wrap items-center gap-1.5"
+                    >
+                      {trackers.map((tracker) => (
+                        <TrackerIconImage
+                          tracker={tracker}
+                          iconSrc={trackerIconFor(trackerIconSrcByName, tracker)}
+                          enabled={useFavicons}
+                          key={`${groupKey}-${tracker}`}
+                        />
+                      ))}
+                      {hideTrackerNames ? null : label}
+                    </span>
+                  </h2>
+                  <p className="muted">
+                    {group.HasOverride
+                      ? "Saved override active for this group."
+                      : "Using generated raw description."}
+                  </p>
+                  {group.ImageHost?.Reuploaded && group.ImageHost?.Message ? (
+                    <p className="muted">{group.ImageHost.Message}</p>
+                  ) : null}
+                  {group.ImageHost?.Status === "warning" && group.ImageHost?.Message ? (
+                    <p className="m-0 mt-1 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100 [overflow-wrap:anywhere]">
+                      {group.ImageHost.Message}
+                    </p>
+                  ) : null}
+                  {imageHostWarnings.map((warning, index) => {
+                    const host = String(warning.Host || "").trim();
+                    const message = String(warning.Message || "").trim();
+                    if (!host && !message) return null;
+                    return (
+                      <p
+                        className="m-0 mt-1 rounded-md border border-amber-400/40 bg-amber-400/10 px-2 py-1 text-[0.82rem] text-amber-100 [overflow-wrap:anywhere]"
+                        key={`${host || "host"}-${index}`}
+                      >
+                        {host ? `${host} failed` : "Image host warning"}
+                        {message ? `: ${message}` : ""}
+                      </p>
+                    );
+                  })}
+                </div>
+                <button
+                  className="ghost"
+                  type="button"
+                  onClick={() =>
+                    setExpandedGroups((prev) => ({
+                      ...prev,
+                      [groupKey]: !expanded,
+                    }))
+                  }
+                >
+                  {expanded ? "Collapse" : "Expand"}
+                </button>
+              </div>
+
+              {expanded ? (
+                <>
+                  <div className="flex flex-wrap items-center gap-2">
+                    <button
+                      className="ghost"
+                      type="button"
+                      onClick={() => void facet.reset(groupKey)}
+                      disabled={builderLoading || !sourcePath.trim()}
+                    >
+                      {builderLoading ? "Working..." : "Reset group"}
+                    </button>
+                    <button
+                      className="ghost"
+                      type="button"
+                      onClick={() => void facet.render(groupKey)}
+                      disabled={builderLoading}
+                    >
+                      {builderLoading ? "Working..." : "Render"}
+                    </button>
+                    <button
+                      className="primary"
+                      type="button"
+                      onClick={() => void facet.save(groupKey)}
+                      disabled={builderLoading || !sourcePath.trim()}
+                    >
+                      {builderLoading ? "Working..." : "Save group"}
+                    </button>
+                  </div>
+
+                  <section className="panel">
+                    <div className="mb-2 flex flex-col gap-1">
+                      <h2>Raw Description</h2>
+                      <p className="muted">
+                        This final raw description is the upload source of truth for{" "}
+                        {hideTrackerNames ? "this group" : label}.
+                      </p>
+                    </div>
+                    <textarea
+                      className="min-h-[170px] w-full resize-y rounded-lg border border-white/10 bg-black/25 px-3 py-2 text-[0.95rem] leading-6 text-[var(--text)]"
+                      value={raw}
+                      onChange={(event) => {
+                        const nextValue = event.target.value;
+                        facet.edit(groupKey, nextValue);
+                      }}
+                    />
+                  </section>
+
+                  <section className="panel">
+                    <div className="mb-2 flex flex-col gap-1">
+                      <h2>Rendered Raw Preview</h2>
+                    </div>
+                    {renderedHTML ? (
+                      <RenderedDescription html={renderedHTML} />
+                    ) : (
+                      <p className="muted">No rendered preview yet.</p>
+                    )}
+                  </section>
+                </>
+              ) : null}
+            </section>
+          );
+        })
+      )}
+    </section>
+  );
+}
diff --git a/webui/src/pages/dupe_check/index.test.tsx b/webui/src/pages/dupe_check/index.test.tsx
new file mode 100644
index 00000000..548b4843
--- /dev/null
+++ b/webui/src/pages/dupe_check/index.test.tsx
@@ -0,0 +1,139 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { DuplicatesFacet } from "../../releaseSession/types";
+import DupeCheckPage from "./index";
+
+afterEach(cleanup);
+
+describe("DupeCheckPage", () => {
+  it("forwards duplicate-check intent through the facet", () => {
+    const run = vi.fn(async () => true);
+    const facet: DuplicatesFacet = {
+      view: {
+        status: "idle",
+        snapshot: null,
+        eligibility: null,
+        ignoredTrackers: [],
+        selectedTrackers: ["EXAMPLE"],
+        error: "",
+        transientError: "",
+      },
+      run,
+      cancel: vi.fn(async () => true),
+      chooseTrackers: vi.fn(),
+      setIgnored: vi.fn(),
+    };
+    render(
+      <DupeCheckPage
+        facet={facet}
+        sourcePath="C:\\media\\Example"
+        trackerUploadItems={[{ name: "EXAMPLE", config: {} }]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Run dupe check" }));
+    expect(run).toHaveBeenCalledOnce();
+  });
+
+  it("owns tracker selection and blocks execution while selection is empty", () => {
+    const chooseTrackers = vi.fn();
+    const facet: DuplicatesFacet = {
+      view: {
+        status: "idle",
+        snapshot: null,
+        eligibility: null,
+        ignoredTrackers: [],
+        selectedTrackers: [],
+        error: "",
+        transientError: "",
+      },
+      run: vi.fn(async () => false),
+      cancel: vi.fn(async () => true),
+      chooseTrackers,
+      setIgnored: vi.fn(),
+    };
+    render(
+      <DupeCheckPage
+        facet={facet}
+        sourcePath="C:\\media\\Example"
+        trackerUploadItems={[{ name: "EXAMPLE", config: {} }]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.getByRole("button", { name: "Run dupe check" })).toBeDisabled();
+    fireEvent.click(screen.getByRole("checkbox", { name: "EXAMPLE" }));
+    expect(chooseTrackers).toHaveBeenCalledWith(["EXAMPLE"]);
+  });
+
+  it("shows tracker auth and count progress from a running job snapshot", () => {
+    const facet: DuplicatesFacet = {
+      view: {
+        status: "running",
+        snapshot: {
+          jobID: "dupe-job",
+          correlationID: "dupe-correlation",
+          release: { SourcePath: "C:\\media\\Example", Generation: 1 },
+          runtimeGeneration: 1,
+          status: "running",
+          trackers: [
+            {
+              tracker: "EXAMPLE",
+              status: "running",
+              message: "checking tracker auth",
+              result: {} as never,
+              startedAt: "2026-07-16T00:00:00Z",
+              finishedAt: "",
+            },
+          ],
+          completedCount: 1,
+          totalCount: 3,
+          summary: {
+            SourcePath: "C:\\media\\Example",
+            Results: [],
+            Notes: [],
+            Eligibility: {
+              Release: { SourcePath: "C:\\media\\Example", Generation: 1 },
+              Trackers: [],
+              EligibleTrackers: [],
+            },
+          },
+          startedAt: "2026-07-16T00:00:00Z",
+          finishedAt: "",
+        },
+        eligibility: null,
+        ignoredTrackers: [],
+        selectedTrackers: ["EXAMPLE", "SECOND", "THIRD"],
+        error: "",
+        transientError: "",
+      },
+      run: vi.fn(async () => true),
+      cancel: vi.fn(async () => true),
+      chooseTrackers: vi.fn(),
+      setIgnored: vi.fn(),
+    };
+
+    render(
+      <DupeCheckPage
+        facet={facet}
+        sourcePath="C:\\media\\Example"
+        trackerUploadItems={[
+          { name: "EXAMPLE", config: {} },
+          { name: "SECOND", config: {} },
+          { name: "THIRD", config: {} },
+        ]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.getByText("1/3 trackers complete")).toBeInTheDocument();
+    expect(screen.getByText("checking tracker auth")).toBeInTheDocument();
+    expect(screen.getByRole("progressbar", { name: "Duplicate check progress" })).toHaveAttribute(
+      "aria-valuenow",
+      "1",
+    );
+  });
+});
diff --git a/webui/src/pages/dupe_check/index.tsx b/webui/src/pages/dupe_check/index.tsx
new file mode 100644
index 00000000..eed5777d
--- /dev/null
+++ b/webui/src/pages/dupe_check/index.tsx
@@ -0,0 +1,431 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { Badge } from "../../components/ui/badge";
+import { Button } from "../../components/ui/button";
+import { PillCheckbox } from "../../components/ui/checkbox";
+import { Switch } from "../../components/ui/switch";
+import { TrackerIconImage } from "../../components/ui/tracker-icon";
+import type { DuplicatesFacet } from "../../releaseSession/types";
+import type { DupeCheckResult, DupeCheckTrackerState, TrackerUploadItem } from "../../types";
+import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
+import { trackerIconFor } from "../../hooks/useTrackerIcons";
+import { cn } from "../../utils/cn";
+import { dupeSkipReason } from "../../utils/dupeCheck";
+import { handleExternalLinkClick } from "../../utils/externalLinks";
+
+type Props = {
+  facet: DuplicatesFacet;
+  sourcePath: string;
+  trackerUploadItems: readonly TrackerUploadItem[];
+  useFavicons?: boolean;
+  faviconOnly?: boolean;
+  trackerIconSrcByName: TrackerIconCache;
+};
+
+const isFinishedTrackerStatus = (status: string) => {
+  switch (status.toLowerCase().trim()) {
+    case "complete":
+    case "completed":
+    case "skipped":
+    case "failed":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+};
+
+/**
+ * Converts a finished tracker job state into a displayable dupe result.
+ * Pending states without backend results are skipped so progress snapshots do not
+ * appear as upload-eligible tracker rows.
+ */
+const resultFromTrackerState = (state: DupeCheckTrackerState): DupeCheckResult | null => {
+  const resultTracker = String(state.result?.Tracker || "").trim();
+  const status = String(state.result?.Status || state.status || "").trim();
+  if (!resultTracker && !isFinishedTrackerStatus(status)) return null;
+  const tracker = String(resultTracker || state.tracker || "").trim();
+  if (!tracker) return null;
+  return {
+    ...state.result,
+    Tracker: tracker,
+    Status: status,
+  };
+};
+
+/** Prefers per-tracker snapshot results over summary rows. */
+const displayResultsFor = (
+  summaryResults: DupeCheckResult[],
+  trackerStates: DupeCheckTrackerState[] | undefined,
+) => {
+  const stateResults = (trackerStates || [])
+    .map(resultFromTrackerState)
+    .filter((result): result is DupeCheckResult => Boolean(result));
+  return stateResults.length > 0 ? stateResults : summaryResults;
+};
+
+/** Presents per-tracker duplicate progress, outcomes, and authorization controls. */
+export default function DupeCheckPage(props: Readonly<Props>) {
+  const {
+    facet,
+    sourcePath,
+    trackerUploadItems,
+    useFavicons = true,
+    faviconOnly = false,
+    trackerIconSrcByName,
+  } = props;
+  const { view } = facet;
+  const snapshot = view.snapshot;
+  const dupeLoading = view.status === "running";
+  const dupeSummary = snapshot?.summary;
+  const dupeSummaryNotes = dupeSummary?.Notes || [];
+  const dupeTrackerStates = snapshot?.trackers;
+  const ignoredTrackers = new Set(view.ignoredTrackers);
+  const dupeError = view.error || view.transientError;
+  const dupeProgressStatus = snapshot?.status || view.status;
+  const dupeCompletedCount = snapshot?.completedCount || 0;
+  const dupeTotalCount = snapshot?.totalCount || view.selectedTrackers.length;
+  const activeTrackerStates = (dupeTrackerStates || []).filter(
+    (tracker) => !isFinishedTrackerStatus(tracker.status),
+  );
+
+  const hasDupeNotes = dupeSummaryNotes.length > 0;
+  const displayResults = displayResultsFor(dupeSummary?.Results || [], dupeTrackerStates);
+  const hasDupeResults = displayResults.length > 0;
+  const dupeEmptyMessage = hasDupeNotes ? dupeSummaryNotes.join(" ") : "No dupe results yet.";
+  const showProgress =
+    dupeLoading || dupeProgressStatus === "running" || dupeProgressStatus === "queued";
+  const progressText =
+    dupeTotalCount > 0
+      ? `${Math.min(dupeCompletedCount, dupeTotalCount)}/${dupeTotalCount} trackers complete`
+      : "Preparing tracker search";
+  const progressPercent =
+    dupeTotalCount > 0
+      ? Math.round((Math.min(dupeCompletedCount, dupeTotalCount) / dupeTotalCount) * 100)
+      : 0;
+  const sortedResults = displayResults.slice().sort((left, right) => {
+    const leftCount = left.Filtered?.length ?? 0;
+    const rightCount = right.Filtered?.length ?? 0;
+    const leftInClient = left.Match?.MatchedReason === "in_client";
+    const rightInClient = right.Match?.MatchedReason === "in_client";
+    const leftHasDupes = leftCount > 0;
+    const rightHasDupes = rightCount > 0;
+
+    if (leftHasDupes && rightHasDupes && rightCount !== leftCount) {
+      return rightCount - leftCount;
+    }
+    if (leftHasDupes !== rightHasDupes) {
+      return leftHasDupes ? -1 : 1;
+    }
+    if (leftInClient !== rightInClient) {
+      return leftInClient ? -1 : 1;
+    }
+    return left.Tracker.localeCompare(right.Tracker);
+  });
+  const eligibility = view.eligibility;
+  const availableTrackers = eligibility?.EligibleTrackers || [];
+  const unavailableCount = (eligibility?.Trackers || []).filter(
+    (tracker) => !tracker.Eligible,
+  ).length;
+  const hideTrackerNames = faviconOnly && useFavicons;
+  const selectedTrackers = new Set(view.selectedTrackers);
+  const trackerSelectionRequired = selectedTrackers.size === 0;
+
+  return (
+    <section className="flex flex-col gap-3">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Dupe Checking</p>
+        <h1>Check Trackers</h1>
+        <p className="subtitle">Scan selected trackers for potential dupes before upload.</p>
+      </header>
+
+      <section className="panel flex flex-col gap-2 py-3">
+        <div className="flex flex-wrap items-center justify-between gap-2">
+          <div>
+            <p className="label">Trackers</p>
+            <p className="muted text-sm">Select trackers for this duplicate check.</p>
+          </div>
+          <span className="muted text-xs">
+            {selectedTrackers.size}/{trackerUploadItems.length} selected
+          </span>
+        </div>
+        {trackerUploadItems.length ? (
+          <div className="tracker-pills">
+            {trackerUploadItems.map((tracker) => {
+              const normalized = tracker.name.trim().toUpperCase();
+              return (
+                <PillCheckbox
+                  aria-label={tracker.name}
+                  checked={selectedTrackers.has(normalized)}
+                  key={tracker.name}
+                  onCheckedChange={(checked) => {
+                    const next = new Set(selectedTrackers);
+                    if (checked) next.add(normalized);
+                    else next.delete(normalized);
+                    facet.chooseTrackers([...next]);
+                  }}
+                >
+                  <span className="flex items-center gap-1.5">
+                    <TrackerIconImage
+                      tracker={tracker.name}
+                      iconSrc={trackerIconFor(trackerIconSrcByName, tracker.name)}
+                      enabled={useFavicons}
+                    />
+                    {hideTrackerNames ? null : tracker.name}
+                  </span>
+                </PillCheckbox>
+              );
+            })}
+          </div>
+        ) : (
+          <p className="muted">No configured tracker entries found.</p>
+        )}
+        {trackerSelectionRequired ? (
+          <p className="muted text-sm">Select at least one tracker to run duplicate checking.</p>
+        ) : null}
+      </section>
+
+      <section className="panel flex flex-wrap items-center justify-between gap-3 py-3">
+        <div className="min-w-0">
+          <p className="label">Source path</p>
+          <p className="value break-words text-sm">{sourcePath || "No path selected"}</p>
+          {hasDupeResults ? (
+            <div className="mt-2 flex flex-wrap items-center gap-1.5 text-xs text-[var(--muted)]">
+              <span className="font-semibold text-[var(--text)]">
+                Available for upload: {availableTrackers.length}
+              </span>
+              {availableTrackers.length ? (
+                availableTrackers.map((tracker) => {
+                  const iconSrc = trackerIconFor(trackerIconSrcByName, tracker);
+                  return (
+                    <Badge
+                      aria-label={hideTrackerNames ? tracker : undefined}
+                      className="text-[var(--text)] flex items-center gap-1"
+                      style={{
+                        backgroundColor: "color-mix(in srgb, var(--accent-2) 14%, transparent)",
+                        borderColor: "color-mix(in srgb, var(--accent-2) 42%, transparent)",
+                      }}
+                      key={`available-${tracker}`}
+                    >
+                      <TrackerIconImage tracker={tracker} iconSrc={iconSrc} enabled={useFavicons} />
+                      {hideTrackerNames ? null : tracker}
+                    </Badge>
+                  );
+                })
+              ) : (
+                <span>No trackers passed.</span>
+              )}
+              {unavailableCount > 0 ? <span>{unavailableCount} blocked.</span> : null}
+            </div>
+          ) : null}
+        </div>
+        <Button
+          className="ml-auto"
+          variant="primary"
+          type="button"
+          onClick={() => void facet.run()}
+          disabled={dupeLoading || !sourcePath.trim() || trackerSelectionRequired}
+        >
+          {dupeLoading
+            ? `Checking ${dupeCompletedCount}/${dupeTotalCount || "?"}...`
+            : "Run dupe check"}
+        </Button>
+      </section>
+
+      {showProgress ? (
+        <section className="panel grid gap-2 py-3" role="status" aria-live="polite">
+          <div className="flex flex-wrap items-center justify-between gap-2">
+            <p className="font-semibold text-[var(--text)]">Duplicate check progress</p>
+            <p className="muted text-sm">{progressText}</p>
+          </div>
+          <div
+            aria-label="Duplicate check progress"
+            aria-valuemax={dupeTotalCount || undefined}
+            aria-valuemin={0}
+            aria-valuenow={dupeCompletedCount}
+            className="h-2 w-full overflow-hidden rounded-full bg-white/10"
+            role="progressbar"
+          >
+            <div
+              className="h-full rounded-full bg-[var(--accent-2)] transition-[width]"
+              style={{ width: `${progressPercent}%` }}
+            />
+          </div>
+          {activeTrackerStates.length ? (
+            <div className="grid gap-1 text-sm">
+              {activeTrackerStates.map((tracker) => (
+                <div
+                  className="flex flex-wrap items-center justify-between gap-2 rounded border border-white/10 bg-white/5 px-2 py-1.5"
+                  key={tracker.tracker}
+                >
+                  <span className="font-semibold">{tracker.tracker}</span>
+                  <span className="muted">{tracker.message || tracker.status || "Queued"}</span>
+                </div>
+              ))}
+            </div>
+          ) : null}
+        </section>
+      ) : null}
+
+      {dupeError ? <p className="error">{dupeError}</p> : null}
+
+      {hasDupeNotes ? (
+        <div className="flex flex-wrap gap-1.5">
+          {dupeSummaryNotes.map((note, index) => (
+            <Badge tone="info" key={`${note}-${index}`}>
+              {note}
+            </Badge>
+          ))}
+        </div>
+      ) : null}
+
+      {hasDupeResults ? (
+        <div className="overflow-hidden rounded-lg border border-white/10 bg-[rgba(12,16,26,0.76)]">
+          <div className="hidden grid-cols-[minmax(90px,140px)_58px_minmax(0,1fr)_116px] gap-3 border-b border-white/10 px-3 py-2 text-[11px] font-semibold uppercase tracking-[0.08em] text-[var(--muted)] md:grid">
+            <span>Tracker</span>
+            <span>Dupes</span>
+            <span>Matches</span>
+            <span>Action</span>
+          </div>
+          <div className="divide-y divide-white/10">
+            {sortedResults.map((result) => {
+              const dupeCount = result.Filtered?.length ?? 0;
+              const hasDupes = result.HasDupes ?? false;
+              const inClient = result.Match?.MatchedReason === "in_client";
+              const status = String(result.Status || "")
+                .toLowerCase()
+                .trim();
+              const hasFailure = status === "failed";
+              const skipReason = dupeSkipReason(result);
+              const authRequired =
+                result.SkipCode === "tracker_auth_not_ready" ||
+                result.SkipCode === "auth_not_ready";
+              const skippedReason = result.Skipped && !authRequired ? skipReason : "";
+              const visibleNotes = result.Notes || [];
+              const showIgnoreToggle =
+                !inClient && (hasDupes || Boolean(result.Skipped) || hasFailure);
+              const displayDupeCount = dupeCount;
+
+              return (
+                <article
+                  className="grid grid-cols-[minmax(72px,96px)_44px_minmax(0,1fr)] gap-2 px-2 py-2 text-sm md:grid-cols-[minmax(90px,140px)_58px_minmax(0,1fr)_116px] md:gap-3 md:px-3"
+                  key={result.Tracker}
+                >
+                  <div className="min-w-0 flex items-center gap-2">
+                    <div
+                      className="flex shrink-0 flex-wrap items-center gap-1"
+                      aria-label={hideTrackerNames ? result.Tracker : undefined}
+                    >
+                      <TrackerIconImage
+                        tracker={result.Tracker}
+                        iconSrc={trackerIconFor(trackerIconSrcByName, result.Tracker)}
+                        enabled={useFavicons}
+                      />
+                    </div>
+                    {hideTrackerNames ? null : (
+                      <p className="font-bold text-[var(--text)]">{result.Tracker}</p>
+                    )}
+                  </div>
+
+                  <p
+                    className={cn(
+                      "font-bold tabular-nums",
+                      displayDupeCount > 0 ? "text-[var(--accent)]" : "text-[var(--muted)]",
+                    )}
+                  >
+                    {displayDupeCount}
+                  </p>
+
+                  <div className="min-w-0">
+                    {inClient ||
+                    authRequired ||
+                    skippedReason ||
+                    hasFailure ||
+                    visibleNotes.length ? (
+                      <p className="mb-1 flex flex-wrap items-center gap-1 text-sm leading-5">
+                        {inClient ? <Badge tone="info">In client</Badge> : null}
+
+                        {authRequired ? (
+                          <>
+                            <Badge tone="danger">Auth required</Badge>
+                            <span className="text-[var(--muted)]">{skipReason}</span>
+                          </>
+                        ) : null}
+
+                        {skippedReason ? (
+                          <>
+                            <Badge tone="info">Skipped</Badge>
+                            <span className="text-[var(--muted)]">{skippedReason}</span>
+                          </>
+                        ) : null}
+
+                        {hasFailure ? (
+                          <>
+                            <Badge tone="danger">Error</Badge>
+                            <span className="text-[var(--muted)]">
+                              {result.Error || "Tracker dupe check failed"}
+                            </span>
+                          </>
+                        ) : null}
+
+                        {visibleNotes.map((note, index) => (
+                          <Badge tone="info" key={`${note}-${index}`}>
+                            {note}
+                          </Badge>
+                        ))}
+                      </p>
+                    ) : null}
+
+                    {result.Filtered?.length ? (
+                      <p className="value text-sm leading-5">
+                        {result.Filtered.map((entry, index) => (
+                          <span className="inline" key={`${entry.Name}-${index}`}>
+                            {entry.Link ? (
+                              <a
+                                href={entry.Link}
+                                target="_blank"
+                                rel="noreferrer"
+                                className="tracker-link"
+                                onAuxClick={handleExternalLinkClick}
+                                onClick={handleExternalLinkClick}
+                              >
+                                {entry.Name}
+                              </a>
+                            ) : (
+                              <span>{entry.Name}</span>
+                            )}
+                            {index < result.Filtered.length - 1 ? (
+                              <span className="text-[var(--muted)]">, </span>
+                            ) : null}
+                          </span>
+                        ))}
+                      </p>
+                    ) : null}
+                  </div>
+
+                  <div className="col-span-3 md:col-span-1">
+                    {showIgnoreToggle ? (
+                      <div className="inline-flex items-center gap-2 text-xs font-semibold text-[var(--text)]">
+                        <span>Ignore</span>
+                        <Switch
+                          aria-label={`Ignore dupes for ${result.Tracker}`}
+                          checked={ignoredTrackers.has(result.Tracker)}
+                          onChange={(event) =>
+                            facet.setIgnored(result.Tracker, event.target.checked)
+                          }
+                        />
+                      </div>
+                    ) : null}
+                  </div>
+                </article>
+              );
+            })}
+          </div>
+        </div>
+      ) : (
+        <p className="muted">{dupeEmptyMessage}</p>
+      )}
+    </section>
+  );
+}
diff --git a/webui/src/pages/history/index.tsx b/webui/src/pages/history/index.tsx
new file mode 100644
index 00000000..589c360e
--- /dev/null
+++ b/webui/src/pages/history/index.tsx
@@ -0,0 +1,439 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useEffect, useMemo, useState } from "react";
+import { historyClient } from "../../api/app";
+import type { HistoryEntry, HistoryOverview, HistoryRuleFailure } from "../../types";
+import { cn } from "../../utils/cn";
+
+const formatDate = (value: string) => {
+  if (!value) {
+    return "—";
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date.toLocaleString();
+};
+
+const isUploadedStatus = (value: string) => {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "uploaded" || normalized === "success" || normalized === "completed";
+};
+
+const formatLastUpload = (
+  latestUploadStatus: string,
+  statusLabel: string,
+  latestUploadAt: string,
+) => {
+  if (!isUploadedStatus(latestUploadStatus) && !isUploadedStatus(statusLabel)) {
+    return "never";
+  }
+  if (!latestUploadAt) {
+    return "never";
+  }
+  return formatDate(latestUploadAt);
+};
+
+const releaseLabel = (entry: HistoryEntry) => {
+  const title = entry.ReleaseTitle?.trim() || "Untitled release";
+  const source = entry.ReleaseSource?.trim();
+  const resolution = entry.ReleaseResolution?.trim();
+  const extras = [source, resolution].filter(Boolean).join(" • ");
+  return extras ? `${title} (${extras})` : title;
+};
+
+const releaseLabelFromOverview = (overview: HistoryOverview) => {
+  const title = overview.ReleaseTitle?.trim() || "Untitled release";
+  const source = overview.ReleaseSource?.trim();
+  const resolution = overview.ReleaseResolution?.trim();
+  const extras = [source, resolution].filter(Boolean).join(" • ");
+  return extras ? `${title} (${extras})` : title;
+};
+
+const ruleResultState = (failure: HistoryRuleFailure) => {
+  const disposition = String(failure.Disposition || "strict");
+  if (disposition === "advisory" || disposition === "strict") {
+    return disposition;
+  }
+  return failure.Authorized ? "waived" : "unwaived";
+};
+
+type Props = {
+  onReleaseDeleted?: (sourcePath: string) => void;
+};
+
+export default function HistoryPage({ onReleaseDeleted }: Props) {
+  const [entries, setEntries] = useState<HistoryEntry[]>([]);
+  const [selectedPath, setSelectedPath] = useState("");
+  const [searchQuery, setSearchQuery] = useState("");
+  const [overview, setOverview] = useState<HistoryOverview | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [detailLoading, setDetailLoading] = useState(false);
+  const [deleting, setDeleting] = useState(false);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    const listHistory = historyClient.list;
+    const load = async () => {
+      setLoading(true);
+      setError("");
+      try {
+        const result = await listHistory();
+        setEntries(result || []);
+        if (result?.length) {
+          setSelectedPath((current) => current || result[0].SourcePath);
+        } else {
+          setSelectedPath("");
+          setOverview(null);
+        }
+      } catch (err) {
+        setError(String(err));
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    void load();
+  }, []);
+
+  const filteredEntries = useMemo(() => {
+    const query = searchQuery.trim().toLowerCase();
+    if (!query) {
+      return entries;
+    }
+    return entries.filter((entry) => {
+      const title = entry.ReleaseTitle?.trim().toLowerCase() || "";
+      return title.includes(query);
+    });
+  }, [entries, searchQuery]);
+
+  useEffect(() => {
+    if (!filteredEntries.length) {
+      setSelectedPath("");
+      setOverview(null);
+      return;
+    }
+    const selectionStillVisible = filteredEntries.some(
+      (entry) => entry.SourcePath === selectedPath,
+    );
+    if (!selectionStillVisible) {
+      setSelectedPath(filteredEntries[0].SourcePath);
+    }
+  }, [filteredEntries, selectedPath]);
+
+  useEffect(() => {
+    if (!selectedPath) {
+      setOverview(null);
+      return;
+    }
+    const getHistoryOverview = historyClient.getOverview;
+    const loadDetail = async () => {
+      setDetailLoading(true);
+      setError("");
+      try {
+        const next = await getHistoryOverview(selectedPath);
+        setOverview(next);
+      } catch (err) {
+        setError(String(err));
+      } finally {
+        setDetailLoading(false);
+      }
+    };
+
+    void loadDetail();
+  }, [selectedPath]);
+
+  const selectedEntry = useMemo(
+    () => entries.find((entry) => entry.SourcePath === selectedPath) || null,
+    [entries, selectedPath],
+  );
+
+  const descriptionOverrides = useMemo(() => {
+    if (!overview) {
+      return [];
+    }
+    return Array.isArray(overview.DescriptionOverrides) ? overview.DescriptionOverrides : [];
+  }, [overview]);
+
+  const handleDeleteRelease = async () => {
+    if (!selectedPath) {
+      return;
+    }
+    const deleteHistoryRelease = historyClient.removeRelease;
+    const listHistory = historyClient.list;
+    const confirmed = window.confirm("Remove this stored release and all associated stored files?");
+    if (!confirmed) {
+      return;
+    }
+
+    setDeleting(true);
+    setError("");
+    try {
+      const deletedPath = selectedPath;
+      await deleteHistoryRelease(deletedPath);
+      onReleaseDeleted?.(deletedPath);
+      const refreshed = (await listHistory()) || [];
+      setEntries(refreshed);
+      if (!refreshed.length) {
+        setSelectedPath("");
+        setOverview(null);
+      }
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setDeleting(false);
+    }
+  };
+
+  return (
+    <div className="content-stack">
+      <header className="hero">
+        <p className="eyebrow">upbrr</p>
+        <h1>History</h1>
+        <p className="subtitle">
+          Review previously processed releases stored in SQLite and inspect full stored details.
+        </p>
+      </header>
+
+      <section className="panel grid min-h-[560px] gap-3 lg:grid-cols-[minmax(260px,320px)_minmax(0,1fr)]">
+        <aside className="rounded-lg border border-white/10 bg-white/5 p-3">
+          <div className="mb-2">
+            <p className="label">Stored releases</p>
+            <p className="helper">Most recently updated first</p>
+            <label className="mt-2 grid gap-1.5">
+              <span className="label">Search by title</span>
+              <input
+                type="text"
+                value={searchQuery}
+                onChange={(event) => setSearchQuery(event.target.value)}
+                placeholder="Filter titles"
+              />
+            </label>
+          </div>
+
+          {loading ? <p className="muted">Loading history...</p> : null}
+          {!loading && entries.length === 0 ? (
+            <p className="muted">No stored releases found.</p>
+          ) : null}
+          {!loading && entries.length > 0 && filteredEntries.length === 0 ? (
+            <p className="muted">No releases match the current title filter.</p>
+          ) : null}
+
+          <div className="grid max-h-[520px] gap-1.5 overflow-y-auto">
+            {filteredEntries.map((entry) => (
+              <button
+                key={entry.SourcePath}
+                type="button"
+                className={cn(
+                  "grid w-full gap-1 rounded-md border px-3 py-2 text-left transition",
+                  entry.SourcePath === selectedPath
+                    ? "border-[var(--accent-2)] bg-[rgba(53,194,193,0.16)] text-[var(--text)] shadow-[inset_3px_0_0_var(--accent-2),0_0_16px_rgba(53,194,193,0.16)]"
+                    : "border-white/10 bg-black/15 text-[var(--muted)] hover:border-white/20 hover:bg-white/5 hover:text-[var(--text)]",
+                )}
+                onClick={() => setSelectedPath(entry.SourcePath)}
+              >
+                <span
+                  className={cn(
+                    "font-semibold",
+                    entry.SourcePath === selectedPath ? "text-[var(--text)]" : "text-inherit",
+                  )}
+                >
+                  {releaseLabel(entry)}
+                </span>
+                <span className="text-xs text-[var(--muted)]">
+                  {entry.LatestUploadStatus || "Stored"}
+                </span>
+                <span className="text-xs text-[var(--muted)]">
+                  Updated {formatDate(entry.MetadataUpdatedAt)}
+                </span>
+              </button>
+            ))}
+          </div>
+        </aside>
+
+        <div className="overflow-y-auto rounded-lg border border-white/10 bg-white/5 p-3">
+          {detailLoading ? <p className="muted">Loading overview...</p> : null}
+
+          {!detailLoading && !overview ? (
+            <p className="muted">Select a stored release to view details.</p>
+          ) : null}
+
+          {overview ? (
+            <div className="grid gap-3">
+              <div className="flex justify-end">
+                <button
+                  type="button"
+                  className="ghost border-red-400/45 text-[var(--danger)]"
+                  disabled={deleting || detailLoading || !selectedPath}
+                  onClick={() => {
+                    void handleDeleteRelease();
+                  }}
+                >
+                  {deleting ? "Removing..." : "Remove from database"}
+                </button>
+              </div>
+
+              <div className="summary">
+                <div>
+                  <p className="label">Release</p>
+                  <p className="value">
+                    {selectedEntry
+                      ? releaseLabel(selectedEntry)
+                      : releaseLabelFromOverview(overview)}
+                  </p>
+                </div>
+                <div>
+                  <p className="label">Status</p>
+                  <p className="value">{overview.StatusLabel || "Stored"}</p>
+                </div>
+                <div>
+                  <p className="label">Metadata Updated</p>
+                  <p className="value">{formatDate(overview.MetadataUpdatedAt)}</p>
+                </div>
+                <div>
+                  <p className="label">Last Upload</p>
+                  <p className="value">
+                    {formatLastUpload(
+                      overview.LatestUploadStatus,
+                      overview.StatusLabel,
+                      overview.LatestUploadAt,
+                    )}
+                  </p>
+                </div>
+              </div>
+
+              <div className="grid grid-cols-[repeat(auto-fit,minmax(220px,1fr))] gap-2 [&_h3]:mb-2 [&_h3]:mt-0 [&_h3]:text-sm">
+                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Path</h3>
+                  <p className="mono">{overview.SourcePath}</p>
+                </article>
+
+                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5 [&_p]:mb-1 [&_p]:mt-0">
+                  <h3>External IDs</h3>
+                  <p>TMDB: {overview.Identity?.TMDBID || 0}</p>
+                  <p>IMDb: {overview.Identity?.IMDBID || 0}</p>
+                  <p>TVDB: {overview.Identity?.TVDBID || 0}</p>
+                  <p>TVmaze: {overview.Identity?.TVmazeID || 0}</p>
+                </article>
+
+                <article className="rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5 [&_p]:mb-1 [&_p]:mt-0">
+                  <h3>Counts</h3>
+                  <p>Tracker metadata: {overview.TrackerMetadata?.length || 0}</p>
+                  <p>
+                    Strict rules:{" "}
+                    {overview.TrackerRuleFailures?.filter(
+                      (failure) => ruleResultState(failure) === "strict",
+                    ).length || 0}
+                  </p>
+                  <p>
+                    Unwaived rules:{" "}
+                    {overview.TrackerRuleFailures?.filter(
+                      (failure) => ruleResultState(failure) === "unwaived",
+                    ).length || 0}
+                  </p>
+                  <p>
+                    Waived rules:{" "}
+                    {overview.TrackerRuleFailures?.filter(
+                      (failure) => ruleResultState(failure) === "waived",
+                    ).length || 0}
+                  </p>
+                  <p>
+                    Rule advisories:{" "}
+                    {overview.TrackerRuleFailures?.filter(
+                      (failure) => ruleResultState(failure) === "advisory",
+                    ).length || 0}
+                  </p>
+                  <p>Screenshots: {overview.Screenshots?.length || 0}</p>
+                  <p>Final selections: {overview.FinalSelections?.length || 0}</p>
+                  <p>Uploaded images: {overview.UploadedImages?.length || 0}</p>
+                  <p>Upload history: {overview.UploadHistory?.length || 0}</p>
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Description Overrides</h3>
+                  {descriptionOverrides.length ? (
+                    <ul className="m-0 grid gap-1 pl-4">
+                      {descriptionOverrides.map((override, index) => {
+                        const groupKey = override.GroupKey?.trim() || "default";
+                        return (
+                          <li key={`${groupKey}-${override.UpdatedAt}-${index}`}>
+                            <strong>{groupKey}</strong>
+                            <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
+                              {override.Description?.trim() || "(empty)"}
+                            </pre>
+                          </li>
+                        );
+                      })}
+                    </ul>
+                  ) : (
+                    <p className="muted">(none)</p>
+                  )}
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Upload History</h3>
+                  {overview.UploadHistory?.length ? (
+                    <ul className="m-0 grid gap-1 pl-4">
+                      {overview.UploadHistory.map((row, index) => (
+                        <li key={`${row.Tracker}-${row.CreatedAt}-${index}`}>
+                          <strong>{row.Tracker || "UNKNOWN"}</strong> — {row.Status || "unknown"} —{" "}
+                          {formatDate(row.CreatedAt)}
+                        </li>
+                      ))}
+                    </ul>
+                  ) : (
+                    <p className="muted">No upload records.</p>
+                  )}
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Tracker Rule Results</h3>
+                  {overview.TrackerRuleFailures?.length ? (
+                    <ul className="m-0 grid gap-1 pl-4">
+                      {overview.TrackerRuleFailures.map((failure, index) => (
+                        <li key={`${failure.Tracker}-${failure.Rule}-${index}`}>
+                          <strong>{failure.Tracker || "UNKNOWN"}</strong> [
+                          {failure.Disposition || "strict"}
+                          {ruleResultState(failure) === "waived" ? ", waived" : ""}
+                          {ruleResultState(failure) === "unwaived" ? ", unwaived" : ""}]:{" "}
+                          {failure.Rule} {failure.Reason ? `— ${failure.Reason}` : ""}
+                        </li>
+                      ))}
+                    </ul>
+                  ) : (
+                    <p className="muted">No tracker rule results stored.</p>
+                  )}
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Provider Display (diagnostic)</h3>
+                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
+                    {JSON.stringify(overview.Display || {}, null, 2)}
+                  </pre>
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Release Overrides (raw)</h3>
+                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
+                    {JSON.stringify(overview.ReleaseNameOverrides || {}, null, 2)}
+                  </pre>
+                </article>
+
+                <article className="col-span-full rounded-lg border border-white/10 bg-[var(--panel-light)] p-2.5">
+                  <h3>Metadata (raw)</h3>
+                  <pre className="m-0 max-h-[220px] overflow-auto whitespace-pre-wrap rounded-md bg-black/10 p-2 text-xs [overflow-wrap:anywhere]">
+                    {JSON.stringify(overview.Metadata || {}, null, 2)}
+                  </pre>
+                </article>
+              </div>
+            </div>
+          ) : null}
+
+          {error ? <p className="error">{error}</p> : null}
+        </div>
+      </section>
+    </div>
+  );
+}
diff --git a/webui/src/pages/input/index.test.tsx b/webui/src/pages/input/index.test.tsx
new file mode 100644
index 00000000..a688fc79
--- /dev/null
+++ b/webui/src/pages/input/index.test.tsx
@@ -0,0 +1,341 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { InputFacet } from "../../releaseSession/types";
+import type {
+  IMDBMetadata,
+  MetadataPreview,
+  ProviderDisplay,
+  ProviderDisplaySummary,
+  TMDBMetadata,
+} from "../../types";
+import { emptyExternalIdentity } from "../../utils/canonicalIdentity";
+import InputPage from "./index";
+
+afterEach(cleanup);
+
+const inputFacet = (): InputFacet => ({
+  view: {
+    sourceDraft: "C:\\media\\Example.mkv",
+    selectedSource: "",
+    status: "idle",
+    error: "",
+    failure: null,
+    preparationDirty: false,
+    intent: {
+      sourceLookupURL: "",
+      identity: {},
+      releaseName: {},
+      playlist: { Set: false, Selected: [], UseAll: false },
+    },
+    selectedTrackers: [],
+    progress: { correlationID: "", status: "idle", message: "", steps: [] },
+    preview: null,
+    trackerData: [],
+    playlist: {
+      status: "idle",
+      required: false,
+      candidates: [],
+      selected: [],
+      useAll: false,
+      error: "",
+    },
+  },
+  updateSourceDraft: vi.fn(),
+  selectSource: vi.fn(),
+  changeSourceLookupURL: vi.fn(),
+  changeIdentity: vi.fn(),
+  changeReleaseName: vi.fn(),
+  chooseTrackers: vi.fn(),
+  choosePlaylists: vi.fn(),
+  confirmPlaylists: vi.fn(async () => true),
+  cancelPlaylistSelection: vi.fn(),
+  prepareSource: vi.fn(async () => true),
+  resetSource: vi.fn(async () => true),
+  prepare: vi.fn(async () => true),
+  reset: vi.fn(async () => true),
+  confirmBDMVRescan: vi.fn(async () => true),
+  selectCandidate: vi.fn(async () => true),
+});
+
+const providerSummary = (title: string): ProviderDisplaySummary => ({
+  Title: title,
+  OriginalTitle: "",
+  Year: 2026,
+  Overview: `${title} overview`,
+  PosterURL: "",
+  BackdropURL: "",
+  Category: "movie",
+  Date: "",
+  EndDate: "",
+  OriginalLanguage: "en",
+  MediaType: "movie",
+  RuntimeMinutes: 0,
+  Genres: "",
+  Keywords: "",
+  TrailerURL: "",
+  Rating: 0,
+  RatingCount: 0,
+  Country: "",
+});
+
+const providerDisplays = (generation: number): ProviderDisplay[] => [
+  {
+    Provider: "imdb",
+    ID: 1_234_567,
+    DisplayID: "tt1234567",
+    URL: "",
+    Provenance: "resolver",
+    SummaryAvailable: true,
+    Summary: providerSummary(`IMDB generation ${generation}`),
+    Details: { IMDB: {} as IMDBMetadata },
+  },
+  {
+    Provider: "tmdb",
+    ID: 101,
+    DisplayID: "101",
+    URL: "",
+    Provenance: "resolver",
+    SummaryAvailable: true,
+    Summary: providerSummary(`TMDB generation ${generation}`),
+    Details: { TMDB: {} as TMDBMetadata },
+  },
+];
+
+const metadataPreview = (generation: number): MetadataPreview => {
+  const sourcePath = "C:\\media\\Example.mkv";
+  return {
+    SourcePath: sourcePath,
+    TrackerName: "",
+    ReleaseName: "Example.Release.2026.1080p-GRP",
+    ReleaseNameOverrides: {},
+    Release: { SourcePath: sourcePath, Generation: generation },
+    Identity: {
+      ...emptyExternalIdentity(sourcePath),
+      Generation: generation,
+      TMDBID: 101,
+      IMDBID: 1_234_567,
+      Category: "movie",
+      Provenance: { TMDB: "resolver", IMDB: "resolver" },
+    },
+    Display: {
+      ReleaseName: "Example.Release.2026.1080p-GRP",
+      Providers: providerDisplays(generation),
+    },
+    Bluray: null,
+    Diagnostics: [],
+    TrackerData: [],
+    TrackerRuleFailures: {},
+  };
+};
+
+const readyInputFacet = (generation: number): InputFacet => {
+  const base = inputFacet();
+  return {
+    ...base,
+    view: {
+      ...base.view,
+      selectedSource: "C:\\media\\Example.mkv",
+      status: "ready",
+      progress: {
+        correlationID: `attempt-${generation}`,
+        status: "ready",
+        message: "Metadata preparation complete.",
+        steps: [],
+      },
+      preview: metadataPreview(generation),
+    },
+  };
+};
+
+describe("InputPage", () => {
+  it("keeps typing as a draft and uses explicit preparation intent", () => {
+    const facet = inputFacet();
+    render(
+      <InputPage
+        facet={facet}
+        sourcePathHistory={[]}
+        handleBrowseFile={vi.fn()}
+        handleBrowseFolder={vi.fn()}
+        trackerUploadItems={[]}
+        showExternalIDInputUI={false}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Source path"), {
+      target: { value: "C:\\media\\Other.mkv" },
+    });
+    expect(facet.updateSourceDraft).toHaveBeenCalledWith("C:\\media\\Other.mkv");
+    fireEvent.click(screen.getByRole("button", { name: "Fetch metadata" }));
+    expect(facet.prepareSource).toHaveBeenCalledWith("C:\\media\\Example.mkv", facet.view.intent);
+  });
+
+  it("renders BDMV playlist intent and confirms through the input facet", () => {
+    const base = inputFacet();
+    const facet: InputFacet = {
+      ...base,
+      view: {
+        ...base.view,
+        playlist: {
+          status: "awaiting_selection",
+          required: true,
+          candidates: [{ file: "00001.mpls", duration: 120, items: [], score: 1, edition: "" }],
+          selected: [],
+          useAll: false,
+          error: "",
+        },
+      },
+    };
+    render(
+      <InputPage
+        facet={facet}
+        sourcePathHistory={[]}
+        handleBrowseFile={vi.fn()}
+        handleBrowseFolder={vi.fn()}
+        trackerUploadItems={[]}
+        showExternalIDInputUI={false}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    fireEvent.click(screen.getByLabelText("00001.mpls"));
+    expect(facet.choosePlaylists).toHaveBeenCalledWith(["00001.mpls"], false);
+
+    const selectedFacet: InputFacet = {
+      ...facet,
+      view: { ...facet.view, playlist: { ...facet.view.playlist, selected: ["00001.mpls"] } },
+    };
+    cleanup();
+    render(
+      <InputPage
+        facet={selectedFacet}
+        sourcePathHistory={[]}
+        handleBrowseFile={vi.fn()}
+        handleBrowseFolder={vi.fn()}
+        trackerUploadItems={[]}
+        showExternalIDInputUI={false}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Confirm Selection" }));
+    expect(facet.confirmPlaylists).toHaveBeenCalledOnce();
+  });
+
+  it("renders ordered session progress without a hard-coded phase catalog", () => {
+    const base = inputFacet();
+    const facet: InputFacet = {
+      ...base,
+      view: {
+        ...base.view,
+        status: "running",
+        progress: {
+          correlationID: "attempt-1",
+          status: "running",
+          message: "Future work is active.",
+          steps: [
+            {
+              phase: "future_phase",
+              order: 9999,
+              label: "Future preparation phase",
+              message: "Future phase detail.",
+              status: "running",
+              timestamp: "2026-07-16T00:00:00Z",
+            },
+          ],
+        },
+      },
+    };
+    render(
+      <InputPage
+        facet={facet}
+        sourcePathHistory={[]}
+        handleBrowseFile={vi.fn()}
+        handleBrowseFolder={vi.fn()}
+        trackerUploadItems={[]}
+        showExternalIDInputUI={false}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.getByText("Future preparation phase")).toBeVisible();
+    expect(screen.getByText("Future phase detail.")).toBeVisible();
+  });
+
+  it("hides preparation progress after preparation completes", () => {
+    const base = inputFacet();
+    const facet: InputFacet = {
+      ...base,
+      view: {
+        ...base.view,
+        status: "ready",
+        progress: {
+          correlationID: "attempt-1",
+          status: "ready",
+          message: "Metadata preparation complete.",
+          steps: [
+            {
+              phase: "source_inspection",
+              order: 100,
+              label: "Inspect source",
+              message: "Source inspected.",
+              status: "completed",
+              timestamp: "2026-07-16T00:00:00Z",
+            },
+          ],
+        },
+      },
+    };
+    render(
+      <InputPage
+        facet={facet}
+        sourcePathHistory={[]}
+        handleBrowseFile={vi.fn()}
+        handleBrowseFolder={vi.fn()}
+        trackerUploadItems={[]}
+        showExternalIDInputUI={false}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.queryByText("Preparation progress")).not.toBeInTheDocument();
+    expect(screen.queryByText("Inspect source")).not.toBeInTheDocument();
+  });
+
+  it("selects the highest-priority metadata source for each prepared generation", () => {
+    const firstFacet = readyInputFacet(1);
+    const pageProps = {
+      sourcePathHistory: [],
+      handleBrowseFile: vi.fn(),
+      handleBrowseFolder: vi.fn(),
+      trackerUploadItems: [],
+      showExternalIDInputUI: false,
+      setLightboxImage: vi.fn(),
+      setLightboxAlt: vi.fn(),
+      trackerIconSrcByName: {},
+    };
+    const { rerender } = render(<InputPage facet={firstFacet} {...pageProps} />);
+
+    expect(screen.getByRole("button", { name: /^TMDB/ })).toHaveClass("active");
+    expect(screen.getByText("TMDB generation 1")).toBeVisible();
+
+    fireEvent.click(screen.getByRole("button", { name: /^IMDB/ }));
+    expect(screen.getByRole("button", { name: /^IMDB/ })).toHaveClass("active");
+    expect(screen.getByText("IMDB generation 1")).toBeVisible();
+
+    rerender(<InputPage facet={readyInputFacet(2)} {...pageProps} />);
+    expect(screen.getByRole("button", { name: /^TMDB/ })).toHaveClass("active");
+    expect(screen.getByText("TMDB generation 2")).toBeVisible();
+  });
+});
diff --git a/webui/src/pages/input/index.tsx b/webui/src/pages/input/index.tsx
new file mode 100644
index 00000000..f501c83f
--- /dev/null
+++ b/webui/src/pages/input/index.tsx
@@ -0,0 +1,2231 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import { Button } from "../../components/ui/button";
+import { Checkbox, PillCheckbox } from "../../components/ui/checkbox";
+import { Switch } from "../../components/ui/switch";
+import { TrackerIconImage } from "../../components/ui/tracker-icon";
+import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
+import { trackerIconFor } from "../../hooks/useTrackerIcons";
+import type { InputFacet } from "../../releaseSession/types";
+import type {
+  DetailBlock,
+  DetailItem,
+  ExternalIdentityCandidate,
+  ExternalIDInfo,
+  ExternalIDOverrides,
+  ProviderDisplay,
+  IMDBAKA,
+  IMDBEditionDetail,
+  IMDBEpisode,
+  IMDBPerson,
+  IMDBReleaseDate,
+  IMDBSeasonSummary,
+  MetadataPreview,
+  ReleaseNameOverrides,
+  ReleaseNameEditState,
+  ReleaseNameTouchedState,
+  TMDBCompany,
+  TMDBCountry,
+  TMDBNetwork,
+  TrackerUploadItem,
+} from "../../types";
+import type { SourcePathHistoryEntry } from "../../utils/inputHistory";
+import {
+  candidatesFromDiagnostics,
+  externalIDInfoFromIdentity,
+  externalIdentityDraftFromIdentity,
+} from "../../utils/canonicalIdentity";
+import { emptyExternalIdentity } from "../../utils/canonicalIdentity";
+
+const compactInputClass =
+  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
+
+const formatProvider = (value: string) => value.toUpperCase();
+
+const formatID = (provider: string, id: number) => {
+  if (!id) return "";
+  if (provider === "imdb") return `tt${id.toString().padStart(7, "0")}`;
+  return id.toString();
+};
+
+const providerOrder = ["tmdb", "imdb", "tvdb", "tvmaze", "mal"] as const;
+
+const filterAndOrderIdentityProviders = (info: ExternalIDInfo[]) => {
+  const orderIndex = new Map<string, number>(
+    providerOrder.map((provider, index) => [provider, index]),
+  );
+
+  return [...info].sort((left, right) => {
+    const leftIndex = orderIndex.get(left.Provider) ?? providerOrder.length;
+    const rightIndex = orderIndex.get(right.Provider) ?? providerOrder.length;
+    if (leftIndex !== rightIndex) return leftIndex - rightIndex;
+    return left.Provider.localeCompare(right.Provider);
+  });
+};
+
+const normalizeKey = (value: string) => value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+
+const imdbTypeLabels: Record<string, string> = {
+  movie: "Movie",
+  tvseries: "TV series",
+  tvminiseries: "TV miniseries",
+  tvepisode: "TV episode",
+  tvmovie: "TV movie",
+  short: "Short",
+  video: "Video",
+  videogame: "Video game",
+};
+
+const formatIMDBType = (value: string) => {
+  if (!value) return "";
+  const key = normalizeKey(value);
+  return imdbTypeLabels[key] ?? value;
+};
+
+const formatRuntime = (minutes: number) => {
+  if (!minutes) return "";
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  if (!hours) return `${minutes} min`;
+  if (!remainder) return `${hours}h`;
+  return `${hours}h ${remainder}m`;
+};
+
+const formatRating = (rating: number, count: number) => {
+  if (!rating) return "";
+  const score = rating.toFixed(1);
+  if (count) return `${score} (${count.toLocaleString()} votes)`;
+  return score;
+};
+
+const formatPlaylistDuration = (seconds: number) => {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainder = Math.floor(seconds % 60);
+  if (hours > 0) return `${hours}h ${minutes}m ${remainder}s`;
+  if (minutes > 0) return `${minutes}m ${remainder}s`;
+  return `${remainder}s`;
+};
+
+const formatPlaylistBytes = (bytes: number) => {
+  if (!bytes) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const index = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+  return `${Math.round((bytes / 1024 ** index) * 100) / 100} ${units[index]}`;
+};
+
+const formatNumber = (value: number) => (value ? value.toString() : "");
+
+const formatSimilarity = (value: number) => {
+  if (!value) return "";
+  return `${Math.round(value * 100)}%`;
+};
+
+const formatBoolean = (value: boolean) => (value ? "Yes" : "No");
+
+const tmdbLogoBaseURL = "https://image.tmdb.org/t/p/original/";
+const tmdbLogoSize = 64;
+const malAnimeBaseURL = "https://myanimelist.net/anime/";
+
+const normalizeTMDBLogoURL = (path: string) => {
+  const trimmed = path?.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `${tmdbLogoBaseURL}${trimmed}`;
+};
+
+const formatNameList = (values?: string[] | null) => {
+  if (!values || values.length === 0) return "";
+  const cleaned = values.map((item) => item?.trim()).filter(Boolean);
+  if (cleaned.length === 0) return "";
+  return cleaned.join("\n");
+};
+
+const formatCommaList = (values?: string[] | null) => {
+  if (!values || values.length === 0) return "";
+  const cleaned = values.map((item) => item?.trim()).filter(Boolean);
+  if (cleaned.length === 0) return "";
+  return cleaned.join(", ");
+};
+
+// formatAniListScore renders AniList's 0-100 score fields as percentages.
+const formatAniListScore = (value: number) => {
+  if (!value) return "";
+  return `${value}%`;
+};
+
+// formatAniListTags hides adult and spoiler tags, sorts by AniList relevance,
+// and limits the preview so selected MAL details remain scannable.
+const formatAniListTags = (
+  values?:
+    | {
+        Name: string;
+        Rank: number;
+        IsAdult: boolean;
+        IsGeneralSpoiler: boolean;
+        IsMediaSpoiler: boolean;
+      }[]
+    | null,
+) => {
+  if (!values || values.length === 0) return "";
+  const cleaned = values
+    .filter((item) => item?.Name && !item.IsAdult && !item.IsGeneralSpoiler && !item.IsMediaSpoiler)
+    .sort((left, right) => right.Rank - left.Rank)
+    .slice(0, 10)
+    .map((item) => (item.Rank ? `${item.Name} (${item.Rank}%)` : item.Name));
+  if (cleaned.length === 0) return "";
+  return cleaned.join(", ");
+};
+
+// formatAniListStudios renders named studio nodes and skips empty placeholders.
+const formatAniListStudios = (values?: { Name: string }[] | null) => {
+  if (!values || values.length === 0) return "";
+  const cleaned = values.map((item) => item?.Name?.trim()).filter(Boolean);
+  if (cleaned.length === 0) return "";
+  return cleaned.join(", ");
+};
+
+// formatAniListExternalLinks preserves both provider labels and URLs because
+// AniList links may have one without the other.
+const formatAniListExternalLinks = (values?: { Site: string; URL: string }[] | null) => {
+  if (!values || values.length === 0) return "";
+  const lines = values
+    .map((item) => {
+      const site = item?.Site?.trim() ?? "";
+      const url = item?.URL?.trim() ?? "";
+      if (!site && !url) return "";
+      if (!site) return url;
+      if (!url) return site;
+      return `${site} - ${url}`;
+    })
+    .filter(Boolean)
+    .slice(0, 8);
+  if (lines.length === 0) return "";
+  return lines.join("\n");
+};
+
+// formatUnixSeconds renders AniList airing timestamps, which are Unix seconds.
+const formatUnixSeconds = (value: number) => {
+  if (!value) return "";
+  return new Date(value * 1000).toISOString();
+};
+
+type TVDBDisplayMode = "original" | "english";
+
+const isEnglishLanguageValue = (value: string) => {
+  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
+  if (!normalized) return false;
+  if (normalized === "en" || normalized === "eng" || normalized === "english") return true;
+  return normalized.startsWith("en-");
+};
+
+const hasTVDBEnglishDisplay = (preview: ProviderDisplay) => {
+  if (preview.Provider !== "tvdb") return false;
+  const tvdb = preview.Details.TVDB;
+  const originalLanguage = tvdb.OriginalLanguage || preview.Summary.OriginalLanguage;
+  if (isEnglishLanguageValue(originalLanguage)) return false;
+  if (!tvdb.HasEnglish) return false;
+  return Boolean(
+    tvdb.NameEnglish ||
+    tvdb.OverviewEnglish ||
+    tvdb.EpisodeNameEnglish ||
+    tvdb.EpisodeOverviewEnglish,
+  );
+};
+
+const pickTVDBText = (
+  mode: TVDBDisplayMode,
+  originalValue: string,
+  englishValue: string,
+  fallbackValue = "",
+) => {
+  if (mode === "english") {
+    return englishValue || originalValue || fallbackValue;
+  }
+  return originalValue || fallbackValue || englishValue;
+};
+
+const formatPeopleList = (values?: IMDBPerson[] | null) => {
+  if (!values || values.length === 0) return "";
+  const cleaned = values.map((item) => item?.Name?.trim()).filter(Boolean);
+  if (cleaned.length === 0) return "";
+  return cleaned.join("\n");
+};
+
+const formatIMDBAkas = (values?: IMDBAKA[] | null) => {
+  if (!values || values.length === 0) return "";
+  const lines = values
+    .map((item) => {
+      const title = item?.Title?.trim() ?? "";
+      const country = item?.Country?.trim() ?? "";
+      const language = item?.Language?.trim() ?? "";
+      const attrs = item?.Attributes?.filter(Boolean) ?? [];
+      if (!title && !country && !language) return "";
+      let line = title;
+      if (country) {
+        line = line ? `${line} - ${country}` : country;
+      }
+      if (language) {
+        line = line ? `${line} (${language})` : `(${language})`;
+      }
+      if (attrs.length > 0) {
+        line = `${line} [${attrs.join(", ")}]`;
+      }
+      return line;
+    })
+    .filter(Boolean);
+  if (lines.length === 0) return "";
+  return lines.join("\n");
+};
+
+const formatEditionDetails = (values?: Record<string, IMDBEditionDetail> | null) => {
+  if (!values) return "";
+  const entries = Object.entries(values);
+  if (entries.length === 0) return "";
+  entries.sort((left, right) => Number(left[0]) - Number(right[0]));
+  const lines = entries.map(([, detail]) => {
+    const name = detail.DisplayName?.trim() || "";
+    const minutes = detail.Minutes || 0;
+    const attrs = detail.Attributes?.filter(Boolean) ?? [];
+    let line = name;
+    if (minutes) {
+      line = line ? `${line} (${minutes} min)` : `${minutes} min`;
+    }
+    if (attrs.length > 0) {
+      line = `${line} [${attrs.join(", ")}]`;
+    }
+    return line;
+  });
+  const cleaned = lines.filter(Boolean);
+  if (cleaned.length === 0) return "";
+  return cleaned.join("\n");
+};
+
+const formatReleaseDate = (value?: IMDBReleaseDate) => {
+  if (!value || !value.Year) return "";
+  const month = value.Month ? String(value.Month).padStart(2, "0") : "";
+  const day = value.Day ? String(value.Day).padStart(2, "0") : "";
+  if (month && day) return `${value.Year}-${month}-${day}`;
+  if (month) return `${value.Year}-${month}`;
+  return value.Year.toString();
+};
+
+const formatEpisodes = (values?: IMDBEpisode[] | null) => {
+  if (!values || values.length === 0) return "";
+  const lines = values
+    .map((item) => {
+      const season = item.Season ? `S${item.Season}` : "";
+      const episode = item.EpisodeText ? `E${item.EpisodeText}` : "";
+      const header = `${season}${episode}`.trim();
+      const title = item.Title?.trim() ?? "";
+      const date = formatReleaseDate(item.ReleaseDate);
+      let line = [header, title].filter(Boolean).join(" - ");
+      if (date) {
+        line = line ? `${line} (${date})` : date;
+      }
+      return line;
+    })
+    .filter(Boolean);
+  if (lines.length === 0) return "";
+  return lines.join("\n");
+};
+
+const formatSeasonsSummary = (values?: IMDBSeasonSummary[] | null) => {
+  if (!values || values.length === 0) return "";
+  const lines = values
+    .map((item) => {
+      const year = item.YearRange || formatNumber(item.Year);
+      if (!year) return "";
+      return `Season ${item.Season}: ${year}`;
+    })
+    .filter(Boolean);
+  if (lines.length === 0) return "";
+  return lines.join("\n");
+};
+
+const formatTMDBCountries = (values?: TMDBCountry[] | null) => {
+  if (!values || values.length === 0) return "";
+  const lines = values.map((item) => item?.Name?.trim()).filter(Boolean);
+  if (lines.length === 0) return "";
+  return lines.join("\n");
+};
+
+const buildCompanyBlocks = (values?: TMDBCompany[] | null) => {
+  if (!values || values.length === 0) return [];
+  const blocks: DetailBlock[] = [];
+  for (const item of values) {
+    const name = item?.Name?.trim() ?? "";
+    const country = item?.OriginCountry?.trim() ?? "";
+    const logoURL = normalizeTMDBLogoURL(item?.LogoPath ?? "");
+    let text = name;
+    if (country) {
+      text = text ? `${text} - ${country}` : country;
+    }
+    if (!text && !logoURL) {
+      continue;
+    }
+    if (logoURL) {
+      blocks.push({ imageUrl: logoURL, imageAlt: name || "TMDb logo" });
+    }
+    if (text) {
+      blocks.push({ text });
+    }
+  }
+  return blocks;
+};
+
+const buildNetworkBlocks = (values?: TMDBNetwork[] | null) => {
+  if (!values || values.length === 0) return [];
+  const blocks: DetailBlock[] = [];
+  for (const item of values) {
+    const name = item?.Name?.trim() ?? "";
+    const country = item?.OriginCountry?.trim() ?? "";
+    const logoURL = normalizeTMDBLogoURL(item?.LogoPath ?? "");
+    let text = name;
+    if (country) {
+      text = text ? `${text} - ${country}` : country;
+    }
+    if (!text && !logoURL) {
+      continue;
+    }
+    if (logoURL) {
+      blocks.push({ imageUrl: logoURL, imageAlt: name || "TMDb logo" });
+    }
+    if (text) {
+      blocks.push({ text });
+    }
+  }
+  return blocks;
+};
+
+const buildPreviewDetails = (
+  preview: ProviderDisplay,
+  tvdbDisplayMode: TVDBDisplayMode,
+): DetailItem[] => {
+  const baseID: DetailItem = {
+    label: `${formatProvider(preview.Provider)} ID`,
+    value: formatID(preview.Provider, preview.ID),
+    mono: true,
+  };
+
+  if (preview.Provider === "imdb") {
+    const imdb = preview.Details.IMDB;
+    return [
+      baseID,
+      { label: "IMDb URL", value: imdb?.IMDbURL ?? "", mono: true },
+      { label: "AKA", value: imdb?.AKA ?? "" },
+      { label: "Type", value: formatIMDBType(imdb.Type || preview.Summary.MediaType) },
+      { label: "Year", value: formatNumber(imdb.Year || preview.Summary.Year) },
+      { label: "End year", value: formatNumber(imdb?.EndYear ?? 0) },
+      { label: "TV year", value: formatNumber(imdb?.TVYear ?? 0) },
+      { label: "Original language", value: imdb?.OriginalLanguage ?? "" },
+      { label: "Country", value: imdb.Country || preview.Summary.Country },
+      { label: "Country list", value: imdb?.CountryList ?? "" },
+      {
+        label: "Rating",
+        value: formatRating(
+          imdb.Rating || preview.Summary.Rating,
+          imdb.RatingCount || preview.Summary.RatingCount,
+        ),
+      },
+      { label: "Rating text", value: imdb?.RatingText ?? "" },
+      {
+        label: "Rating count",
+        value: formatNumber(imdb.RatingCount || preview.Summary.RatingCount),
+      },
+      {
+        label: "Runtime",
+        value: formatRuntime(imdb.RuntimeMinutes || preview.Summary.RuntimeMinutes),
+      },
+      { label: "Runtime text", value: imdb?.RuntimeText ?? "" },
+      { label: "Editions", value: formatCommaList(imdb?.Editions) },
+      { label: "Edition details", value: formatEditionDetails(imdb?.EditionDetails) },
+      { label: "Genres", value: imdb.Genres || preview.Summary.Genres },
+      { label: "Sound mixes", value: formatNameList(imdb?.SoundMixes) },
+      { label: "Directors", value: formatPeopleList(imdb?.Directors) },
+      { label: "Creators", value: formatPeopleList(imdb?.Creators) },
+      { label: "Writers", value: formatPeopleList(imdb?.Writers) },
+      { label: "Stars", value: formatPeopleList(imdb?.Stars) },
+      { label: "AKA entries", value: formatIMDBAkas(imdb?.Akas) },
+      { label: "Season summary", value: formatSeasonsSummary(imdb?.SeasonsSummary) },
+      { label: "Episodes", value: formatEpisodes(imdb?.Episodes) },
+      { label: "Cover URL", value: imdb.Cover || preview.Summary.PosterURL, mono: true },
+    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+  }
+
+  if (preview.Provider === "tmdb") {
+    const tmdb = preview.Details.TMDB;
+    return [
+      baseID,
+      { label: "IMDB ID", value: formatID("imdb", tmdb.IMDBID), mono: true },
+      { label: "TVDB ID", value: formatNumber(tmdb.TVDBID), mono: true },
+      { label: "Original title", value: tmdb.OriginalTitle || preview.Summary.OriginalTitle },
+      { label: "Type", value: tmdb.TMDBType || preview.Summary.MediaType },
+      { label: "Category", value: tmdb.Category || preview.Summary.Category },
+      { label: "Year", value: formatNumber(tmdb.Year || preview.Summary.Year) },
+      { label: "Release date", value: tmdb.ReleaseDate || preview.Summary.Date },
+      { label: "First air date", value: tmdb.FirstAirDate || preview.Summary.Date },
+      { label: "Last air date", value: tmdb.LastAirDate || preview.Summary.EndDate },
+      { label: "Runtime", value: formatRuntime(tmdb.Runtime || preview.Summary.RuntimeMinutes) },
+      { label: "Genres", value: tmdb.Genres || preview.Summary.Genres },
+      { label: "Genre IDs", value: tmdb?.GenreIDs ?? "" },
+      { label: "Keywords", value: tmdb.Keywords || preview.Summary.Keywords },
+      { label: "YouTube", value: tmdb.YouTube || preview.Summary.TrailerURL },
+      { label: "Certification", value: tmdb?.Certification ?? "" },
+      { label: "Creators", value: formatNameList(tmdb?.Creators) },
+      { label: "Directors", value: formatNameList(tmdb?.Directors) },
+      { label: "Cast", value: formatNameList(tmdb?.Cast) },
+      { label: "Origin countries", value: formatCommaList(tmdb?.OriginCountry) },
+      {
+        label: "Production companies",
+        value: "",
+        blocks: buildCompanyBlocks(tmdb?.ProductionCompanies),
+      },
+      { label: "Production countries", value: formatTMDBCountries(tmdb?.ProductionCountries) },
+      {
+        label: "Networks",
+        value: "",
+        blocks: buildNetworkBlocks(tmdb?.Networks),
+      },
+      { label: "Poster URL", value: tmdb.Poster || preview.Summary.PosterURL, mono: true },
+      { label: "Poster path", value: tmdb?.TMDBPosterPath ?? "", mono: true },
+      { label: "Backdrop URL", value: tmdb.Backdrop || preview.Summary.BackdropURL, mono: true },
+      { label: "Logo URL", value: tmdb?.Logo ?? "", mono: true },
+      { label: "Logo name", value: tmdb?.TMDBLogo ?? "" },
+      {
+        label: "Original language",
+        value: tmdb.OriginalLanguage || preview.Summary.OriginalLanguage,
+      },
+      { label: "Anime", value: tmdb ? formatBoolean(tmdb.Anime) : "" },
+      { label: "MAL ID", value: formatNumber(tmdb?.MALID ?? 0), mono: true },
+      { label: "Demographic", value: tmdb?.Demographic ?? "" },
+      { label: "Retrieved AKA", value: tmdb?.RetrievedAKA ?? "" },
+      { label: "IMDb mismatch", value: tmdb ? formatBoolean(tmdb.IMDbMismatch) : "" },
+      { label: "Mismatched IMDb ID", value: formatNumber(tmdb?.MismatchedIMDbID ?? 0), mono: true },
+    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+  }
+
+  if (preview.Provider === "tvdb") {
+    const tvdb = preview.Details.TVDB;
+    const displayName = pickTVDBText(
+      tvdbDisplayMode,
+      tvdb.Name || preview.Summary.Title,
+      tvdb.NameEnglish,
+      preview.Summary.Title,
+    );
+    const displayOverview = pickTVDBText(
+      tvdbDisplayMode,
+      tvdb.Overview || preview.Summary.Overview,
+      tvdb.OverviewEnglish,
+      preview.Summary.Overview,
+    );
+    const displayEpisodeName = pickTVDBText(
+      tvdbDisplayMode,
+      tvdb?.EpisodeName ?? "",
+      tvdb?.EpisodeNameEnglish ?? "",
+    );
+    const displayEpisodeOverview = pickTVDBText(
+      tvdbDisplayMode,
+      tvdb?.EpisodeOverview ?? "",
+      tvdb?.EpisodeOverviewEnglish ?? "",
+    );
+    const seasonNumber = tvdb?.EpisodeSeason ?? 0;
+    const episodeNumber = tvdb?.EpisodeNumber ?? 0;
+    const episodeTag =
+      seasonNumber > 0 && episodeNumber > 0
+        ? `S${String(seasonNumber).padStart(2, "0")}E${String(episodeNumber).padStart(2, "0")}`
+        : "";
+    return [
+      baseID,
+      { label: "Name", value: displayName },
+      { label: "Type", value: tvdb.Type || preview.Summary.MediaType },
+      { label: "Status", value: tvdb?.Status ?? "" },
+      { label: "Year", value: formatNumber(tvdb.Year || preview.Summary.Year) },
+      { label: "First aired", value: tvdb.FirstAired || preview.Summary.Date },
+      { label: "Genres", value: tvdb.Genres || preview.Summary.Genres },
+      { label: "Network", value: tvdb?.Network ?? "" },
+      { label: "Origin country", value: tvdb.OriginalCountry || preview.Summary.Country },
+      {
+        label: "Original language",
+        value: tvdb.OriginalLanguage || preview.Summary.OriginalLanguage,
+      },
+      { label: "Aliases", value: formatCommaList(tvdb?.Aliases) },
+      { label: "Episode", value: episodeTag },
+      { label: "Episode name", value: displayEpisodeName },
+      { label: "Episode aired", value: tvdb?.EpisodeAired ?? "" },
+      { label: "Episode overview", value: displayEpisodeOverview },
+      { label: "Overview", value: displayOverview },
+      { label: "Poster URL", value: tvdb.Poster || preview.Summary.PosterURL, mono: true },
+    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+  }
+
+  if (preview.Provider === "tvmaze") {
+    const tvmaze = preview.Details.TVmaze;
+    const network = tvmaze?.Network ?? "";
+    const webChannel = tvmaze?.WebChannel ?? "";
+    const networkText =
+      network && tvmaze?.NetworkCountry ? `${network} - ${tvmaze.NetworkCountry}` : network;
+    const webChannelText =
+      webChannel && tvmaze?.WebCountry ? `${webChannel} - ${tvmaze.WebCountry}` : webChannel;
+    return [
+      baseID,
+      { label: "IMDB ID", value: formatID("imdb", tvmaze.IMDBID), mono: true },
+      { label: "TVDB ID", value: formatNumber(tvmaze.TVDBID), mono: true },
+      { label: "Name", value: tvmaze.Name || preview.Summary.Title },
+      { label: "Type", value: tvmaze.Type || preview.Summary.MediaType },
+      { label: "Status", value: tvmaze?.Status ?? "" },
+      { label: "Year", value: formatNumber(preview.Summary.Year) },
+      { label: "Premiered", value: tvmaze.Premiered || preview.Summary.Date },
+      { label: "Ended", value: tvmaze?.Ended ?? "" },
+      { label: "Genres", value: tvmaze.Genres || preview.Summary.Genres },
+      { label: "Language", value: tvmaze.Language || preview.Summary.OriginalLanguage },
+      { label: "Country", value: tvmaze.Country || preview.Summary.Country },
+      { label: "Runtime", value: formatRuntime(tvmaze.Runtime || preview.Summary.RuntimeMinutes) },
+      { label: "Average runtime", value: formatRuntime(tvmaze?.AverageRuntime ?? 0) },
+      {
+        label: "Rating",
+        value: formatRating(
+          tvmaze.Rating || preview.Summary.Rating,
+          tvmaze.Weight || preview.Summary.RatingCount,
+        ),
+      },
+      { label: "Score", value: formatNumber(tvmaze.Weight || preview.Summary.RatingCount) },
+      { label: "Network", value: networkText },
+      { label: "Web channel", value: webChannelText },
+      { label: "Official site", value: tvmaze?.OfficialSite ?? "", mono: true },
+      { label: "Overview", value: tvmaze.Summary || preview.Summary.Overview },
+      { label: "Poster URL", value: tvmaze.Poster || preview.Summary.PosterURL, mono: true },
+      { label: "Poster medium", value: tvmaze?.PosterMedium ?? "", mono: true },
+      { label: "Backdrop URL", value: tvmaze.Backdrop || preview.Summary.BackdropURL, mono: true },
+      { label: "Backdrop medium", value: tvmaze?.BackdropMedium ?? "", mono: true },
+      { label: "Network logo", value: tvmaze?.NetworkLogo ?? "", mono: true },
+      { label: "Web logo", value: tvmaze?.WebLogo ?? "", mono: true },
+    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+  }
+
+  if (preview.Provider === "mal") {
+    const anilist = preview.Details.AniList;
+    const anilistURL =
+      anilist?.SiteURL ||
+      (anilist?.AniListID ? `https://anilist.co/anime/${anilist.AniListID}` : "");
+    return [
+      baseID,
+      { label: "AniList ID", value: formatNumber(anilist?.AniListID ?? 0), mono: true },
+      { label: "MAL URL", value: `${malAnimeBaseURL}${preview.ID}`, mono: true },
+      { label: "AniList URL", value: anilistURL, mono: true },
+      { label: "English title", value: anilist?.TitleEnglish ?? "" },
+      { label: "Romaji title", value: anilist.TitleRomaji || preview.Summary.OriginalTitle },
+      { label: "Native title", value: anilist?.TitleNative ?? "" },
+      { label: "User preferred title", value: anilist?.TitleUserPreferred ?? "" },
+      { label: "Format", value: anilist.Format || preview.Summary.Category },
+      { label: "Status", value: anilist?.Status ?? "" },
+      { label: "Season", value: anilist?.Season ?? "" },
+      { label: "Season year", value: formatNumber(anilist.SeasonYear || preview.Summary.Year) },
+      { label: "Start date", value: anilist.StartDate || preview.Summary.Date },
+      { label: "End date", value: anilist.EndDate || preview.Summary.EndDate },
+      { label: "Episodes", value: formatNumber(anilist?.Episodes ?? 0) },
+      {
+        label: "Duration",
+        value: formatRuntime(anilist.Duration || preview.Summary.RuntimeMinutes),
+      },
+      {
+        label: "Country of origin",
+        value: anilist.CountryOfOrigin || preview.Summary.OriginalLanguage,
+      },
+      { label: "Source", value: anilist?.Source ?? "" },
+      { label: "Genres", value: formatCommaList(anilist.Genres) || preview.Summary.Genres },
+      { label: "Synonyms", value: formatCommaList(anilist?.Synonyms) },
+      { label: "Average score", value: formatAniListScore(anilist?.AverageScore ?? 0) },
+      { label: "Mean score", value: formatAniListScore(anilist?.MeanScore ?? 0) },
+      {
+        label: "Popularity",
+        value: formatNumber(anilist.Popularity || preview.Summary.RatingCount),
+      },
+      { label: "Favourites", value: formatNumber(anilist?.Favourites ?? 0) },
+      { label: "Tags", value: formatAniListTags(anilist?.Tags) },
+      { label: "Studios", value: formatAniListStudios(anilist?.Studios) },
+      {
+        label: "Trailer",
+        value: anilist?.Trailer?.ID ? `${anilist.Trailer.Site}: ${anilist.Trailer.ID}` : "",
+      },
+      {
+        label: "Next airing",
+        value: anilist?.NextAiringEpisode?.Episode
+          ? `Episode ${anilist.NextAiringEpisode.Episode} - ${formatUnixSeconds(anilist.NextAiringEpisode.AiringAt)}`
+          : "",
+      },
+      {
+        label: "External links",
+        value: formatAniListExternalLinks(anilist?.ExternalLinks),
+        mono: true,
+      },
+      { label: "Cover extra large", value: anilist?.CoverExtraLarge ?? "", mono: true },
+      { label: "Cover large", value: anilist.CoverLarge || preview.Summary.PosterURL, mono: true },
+      { label: "Cover medium", value: anilist?.CoverMedium ?? "", mono: true },
+      { label: "Cover color", value: anilist?.CoverColor ?? "", mono: true },
+      {
+        label: "Banner URL",
+        value: anilist.BannerImage || preview.Summary.BackdropURL,
+        mono: true,
+      },
+      { label: "Adult", value: anilist ? formatBoolean(anilist.IsAdult) : "" },
+      { label: "Resolver source", value: preview.Provenance },
+    ].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+  }
+
+  return [baseID].filter((item) => item.value || (item.blocks && item.blocks.length > 0));
+};
+
+const renderDetailValue = (item: DetailItem) => {
+  if (item.blocks && item.blocks.length > 0) {
+    return (
+      <div>
+        {item.blocks.map((block, index) => (
+          <div key={`${item.label}-${index}`} style={{ marginBottom: "0.35rem" }}>
+            {block.imageUrl ? (
+              <img
+                src={block.imageUrl}
+                alt={block.imageAlt || "Logo"}
+                loading="lazy"
+                style={{
+                  width: tmdbLogoSize,
+                  height: tmdbLogoSize,
+                  objectFit: "contain",
+                  display: "block",
+                }}
+              />
+            ) : null}
+            {block.text ? <span>{block.text}</span> : null}
+          </div>
+        ))}
+      </div>
+    );
+  }
+  const lines = item.value.split("\n");
+  if (lines.length === 1) return item.value;
+  return (
+    <>
+      {lines.map((line, index) => (
+        <span key={`${item.label}-${index}`}>
+          {line}
+          {index < lines.length - 1 ? <br /> : null}
+        </span>
+      ))}
+    </>
+  );
+};
+
+const PreviewDetailsList = ({ items }: { items: DetailItem[] }) => {
+  if (items.length === 0) return null;
+  return (
+    <div className="preview-details">
+      {items.map((item) => (
+        <div className="preview-detail" key={item.label}>
+          <p className="label">{item.label}</p>
+          <p className={`value preview-detail__value ${item.mono ? "mono" : ""}`}>
+            {renderDetailValue(item)}
+          </p>
+        </div>
+      ))}
+    </div>
+  );
+};
+
+type OverrideState<T> = {
+  overrides: T;
+  dirty: boolean;
+  invalid: boolean;
+};
+
+type IDEdits = {
+  tmdb: string;
+  imdb: string;
+  tvdb: string;
+  tvmaze: string;
+  mal: string;
+};
+
+type ProviderSelection = {
+  sourcePath: string;
+  generation: number;
+  provider: string;
+};
+
+const emptyMetadataPreview: MetadataPreview = {
+  SourcePath: "",
+  TrackerName: "",
+  ReleaseName: "",
+  ReleaseNameOverrides: {},
+  Release: { SourcePath: "", Generation: 0 },
+  Identity: emptyExternalIdentity(),
+  Display: { ReleaseName: "", Providers: [] },
+  Bluray: null,
+  Diagnostics: [],
+  TrackerData: [],
+  TrackerRuleFailures: {},
+};
+
+type Props = Readonly<{
+  facet: InputFacet;
+  sourcePathHistory: SourcePathHistoryEntry[];
+  handleBrowseFile: () => void;
+  handleBrowseFolder: () => void;
+  trackerUploadItems: TrackerUploadItem[];
+  showExternalIDInputUI: boolean;
+  setLightboxImage: Dispatch<SetStateAction<string>>;
+  setLightboxAlt: Dispatch<SetStateAction<string>>;
+  useFavicons?: boolean;
+  faviconOnly?: boolean;
+  trackerIconSrcByName: TrackerIconCache;
+}>;
+
+/** Presents source selection, preparation progress, prerequisites, and metadata overrides. */
+export default function InputPage(props: Props) {
+  const {
+    facet,
+    sourcePathHistory,
+    handleBrowseFile,
+    handleBrowseFolder,
+    trackerUploadItems,
+    showExternalIDInputUI,
+    setLightboxImage,
+    setLightboxAlt,
+    useFavicons = true,
+    faviconOnly = false,
+    trackerIconSrcByName,
+  } = props;
+
+  const { view } = facet;
+  const path = view.sourceDraft;
+  const sourceLookupURL = view.intent.sourceLookupURL;
+  const loading = view.status === "running";
+  const metadataResetting = loading;
+  const error = view.error;
+  const preview = view.preview || emptyMetadataPreview;
+  const [providerSelection, setProviderSelection] = useState<ProviderSelection>({
+    sourcePath: "",
+    generation: 0,
+    provider: "",
+  });
+  const [idEdits, setIDEditsState] = useState<IDEdits>({
+    tmdb: "",
+    imdb: "",
+    tvdb: "",
+    tvmaze: "",
+    mal: "",
+  });
+  const [idTouched, setIDTouchedState] = useState<Record<keyof IDEdits, boolean>>({
+    tmdb: false,
+    imdb: false,
+    tvdb: false,
+    tvmaze: false,
+    mal: false,
+  });
+  const [releaseEdits, setReleaseEditsState] = useState<ReleaseNameEditState>({
+    category: "",
+    type: "",
+    source: "",
+    resolution: "",
+    tag: "",
+    service: "",
+    edition: "",
+    season: "",
+    episode: "",
+    episodeTitle: "",
+    manualYear: "",
+    manualDate: "",
+    useSeasonEpisode: false,
+    noSeason: false,
+    noYear: false,
+    noAKA: false,
+    noTag: false,
+    noEdition: false,
+    noDub: false,
+    noDual: false,
+    dualAudio: false,
+    region: "",
+  });
+  const [releaseTouched, setReleaseTouchedState] = useState<ReleaseNameTouchedState>({
+    category: false,
+    type: false,
+    source: false,
+    resolution: false,
+    tag: false,
+    service: false,
+    edition: false,
+    season: false,
+    episode: false,
+    episodeTitle: false,
+    manualYear: false,
+    manualDate: false,
+    useSeasonEpisode: false,
+    noSeason: false,
+    noYear: false,
+    noAKA: false,
+    noTag: false,
+    noEdition: false,
+    noDub: false,
+    noDual: false,
+    dualAudio: false,
+    region: false,
+  });
+  const idEditsRef = useRef(idEdits);
+  const idTouchedRef = useRef(idTouched);
+  const releaseEditsRef = useRef(releaseEdits);
+  const releaseTouchedRef = useRef(releaseTouched);
+
+  const setIdEdits: Dispatch<SetStateAction<IDEdits>> = (action) => {
+    const next = typeof action === "function" ? action(idEditsRef.current) : action;
+    idEditsRef.current = next;
+    setIDEditsState(next);
+  };
+  const setReleaseEdits: Dispatch<SetStateAction<ReleaseNameEditState>> = (action) => {
+    const next = typeof action === "function" ? action(releaseEditsRef.current) : action;
+    releaseEditsRef.current = next;
+    setReleaseEditsState(next);
+  };
+
+  const parseID = (provider: keyof IDEdits, value: string): number | null => {
+    const trimmed = value.trim();
+    if (!trimmed) return 0;
+    const normalized = provider === "imdb" ? trimmed.replace(/^tt/i, "") : trimmed;
+    return /^\d+$/.test(normalized) ? Number(normalized) : null;
+  };
+  const buildIDOverrides = (
+    edits: IDEdits,
+    touched: Record<keyof IDEdits, boolean>,
+  ): OverrideState<ExternalIDOverrides> => {
+    const parsed = {
+      tmdb: parseID("tmdb", edits.tmdb),
+      imdb: parseID("imdb", edits.imdb),
+      tvdb: parseID("tvdb", edits.tvdb),
+      tvmaze: parseID("tvmaze", edits.tvmaze),
+      mal: parseID("mal", edits.mal),
+    };
+    const invalid = Object.values(parsed).includes(null);
+    const overrides: ExternalIDOverrides = {};
+    if (touched.tmdb && parsed.tmdb !== null) overrides.TMDBID = parsed.tmdb;
+    if (touched.imdb && parsed.imdb !== null) overrides.IMDBID = parsed.imdb;
+    if (touched.tvdb && parsed.tvdb !== null) overrides.TVDBID = parsed.tvdb;
+    if (touched.tvmaze && parsed.tvmaze !== null) overrides.TVmazeID = parsed.tvmaze;
+    if (touched.mal && parsed.mal !== null) overrides.MALID = parsed.mal;
+    return { overrides, dirty: Object.keys(overrides).length > 0, invalid };
+  };
+  const normalizedTag = (value: string) => {
+    const trimmed = value.trim();
+    return !trimmed || trimmed.startsWith("-") ? trimmed : `-${trimmed}`;
+  };
+  const buildReleaseOverrides = (
+    edits: ReleaseNameEditState,
+    touched: ReleaseNameTouchedState,
+  ): OverrideState<ReleaseNameOverrides> => {
+    const overrides: ReleaseNameOverrides = {};
+    const assignString = (
+      key: keyof ReleaseNameTouchedState,
+      target: keyof ReleaseNameOverrides,
+      value: string,
+    ) => {
+      if (touched[key]) Object.assign(overrides, { [target]: value.trim() });
+    };
+    assignString("category", "Category", edits.category);
+    assignString("type", "Type", edits.type);
+    assignString("source", "Source", edits.source);
+    assignString("resolution", "Resolution", edits.resolution);
+    if (touched.tag) overrides.Tag = normalizedTag(edits.tag);
+    assignString("service", "Service", edits.service);
+    assignString("edition", "Edition", edits.edition);
+    assignString("season", "Season", edits.season);
+    assignString("episode", "Episode", edits.episode);
+    assignString("episodeTitle", "EpisodeTitle", edits.episodeTitle);
+    assignString("manualDate", "ManualDate", edits.manualDate);
+    assignString("region", "Region", edits.region);
+    let invalid = false;
+    if (touched.manualYear) {
+      const year = edits.manualYear.trim();
+      if (year && !/^\d+$/.test(year)) invalid = true;
+      else overrides.ManualYear = year ? Number(year) : 0;
+    }
+    if (
+      touched.manualDate &&
+      edits.manualDate.trim() &&
+      !/^\d{4}-\d{2}-\d{2}$/.test(edits.manualDate.trim())
+    )
+      invalid = true;
+    const bools: Array<[keyof ReleaseNameTouchedState, keyof ReleaseNameOverrides, boolean]> = [
+      ["useSeasonEpisode", "UseSeasonEpisode", edits.useSeasonEpisode],
+      ["noSeason", "NoSeason", edits.noSeason],
+      ["noYear", "NoYear", edits.noYear],
+      ["noAKA", "NoAKA", edits.noAKA],
+      ["noTag", "NoTag", edits.noTag],
+      ["noEdition", "NoEdition", edits.noEdition],
+      ["noDub", "NoDub", edits.noDub],
+      ["noDual", "NoDual", edits.noDual],
+      ["dualAudio", "DualAudio", edits.dualAudio],
+    ];
+    bools.forEach(([key, target, value]) => {
+      if (touched[key]) Object.assign(overrides, { [target]: value });
+    });
+    return { overrides, dirty: Object.keys(overrides).length > 0, invalid };
+  };
+
+  const idOverrideState = buildIDOverrides(idEdits, idTouched);
+  const releaseOverrideState = buildReleaseOverrides(releaseEdits, releaseTouched);
+  const markIDTouched = (key: keyof IDEdits) => {
+    const touched = { ...idTouchedRef.current, [key]: true };
+    idTouchedRef.current = touched;
+    setIDTouchedState(touched);
+    const next = buildIDOverrides(idEditsRef.current, touched);
+    if (!next.invalid) facet.changeIdentity(next.overrides);
+  };
+  const markReleaseTouched = (key: keyof ReleaseNameTouchedState) => {
+    const touched = { ...releaseTouchedRef.current, [key]: true };
+    releaseTouchedRef.current = touched;
+    setReleaseTouchedState(touched);
+    const next = buildReleaseOverrides(releaseEditsRef.current, touched);
+    if (!next.invalid) facet.changeReleaseName(next.overrides);
+  };
+
+  useEffect(() => {
+    const identity = externalIdentityDraftFromIdentity(preview.Identity);
+    const nextIDs: IDEdits = {
+      tmdb: identity.TMDBID ? String(identity.TMDBID) : "",
+      imdb: identity.IMDBID ? `tt${String(identity.IMDBID).padStart(7, "0")}` : "",
+      tvdb: identity.TVDBID ? String(identity.TVDBID) : "",
+      tvmaze: identity.TVmazeID ? String(identity.TVmazeID) : "",
+      mal: identity.MALID ? String(identity.MALID) : "",
+    };
+    const emptyIDTouched = { tmdb: false, imdb: false, tvdb: false, tvmaze: false, mal: false };
+    idEditsRef.current = nextIDs;
+    idTouchedRef.current = emptyIDTouched;
+    setIDEditsState(nextIDs);
+    setIDTouchedState(emptyIDTouched);
+    const stored = preview.ReleaseNameOverrides || {};
+    const nextRelease: ReleaseNameEditState = {
+      category: stored.Category || "",
+      type: stored.Type || "",
+      source: stored.Source || "",
+      resolution: stored.Resolution || "",
+      tag: stored.Tag || "",
+      service: stored.Service || "",
+      edition: stored.Edition || "",
+      season: stored.Season || "",
+      episode: stored.Episode || "",
+      episodeTitle: stored.EpisodeTitle || "",
+      manualYear: stored.ManualYear ? String(stored.ManualYear) : "",
+      manualDate: stored.ManualDate || "",
+      useSeasonEpisode: Boolean(stored.UseSeasonEpisode),
+      noSeason: Boolean(stored.NoSeason),
+      noYear: Boolean(stored.NoYear),
+      noAKA: Boolean(stored.NoAKA),
+      noTag: Boolean(stored.NoTag),
+      noEdition: Boolean(stored.NoEdition),
+      noDub: Boolean(stored.NoDub),
+      noDual: Boolean(stored.NoDual),
+      dualAudio: Boolean(stored.DualAudio),
+      region: stored.Region || "",
+    };
+    const emptyReleaseTouched = Object.fromEntries(
+      Object.keys(nextRelease).map((key) => [key, false]),
+    ) as ReleaseNameTouchedState;
+    releaseEditsRef.current = nextRelease;
+    releaseTouchedRef.current = emptyReleaseTouched;
+    setReleaseEditsState(nextRelease);
+    setReleaseTouchedState(emptyReleaseTouched);
+  }, [preview.Identity, preview.ReleaseNameOverrides]);
+
+  const releasePageTrackerSelection = useMemo(
+    () =>
+      Object.fromEntries(
+        trackerUploadItems.map((item) => [
+          item.name,
+          view.selectedTrackers.includes(item.name.trim().toUpperCase()),
+        ]),
+      ),
+    [trackerUploadItems, view.selectedTrackers],
+  );
+  const setReleasePageTrackerSelection: Dispatch<SetStateAction<Record<string, boolean>>> = (
+    action,
+  ) => {
+    const next = typeof action === "function" ? action(releasePageTrackerSelection) : action;
+    facet.chooseTrackers(
+      trackerUploadItems.filter((item) => next[item.name]).map((item) => item.name),
+    );
+  };
+  const handleSourcePathChange = facet.updateSourceDraft;
+  const setSourceLookupURL: Dispatch<SetStateAction<string>> = (action) => {
+    facet.changeSourceLookupURL(typeof action === "function" ? action(sourceLookupURL) : action);
+  };
+  const handleFetch = () => {
+    if (!idOverrideState.invalid && !releaseOverrideState.invalid)
+      void facet.prepareSource(path, view.intent);
+  };
+  const handleRefresh = handleFetch;
+  const handleResetMetadata = () => {
+    if (!idOverrideState.invalid && !releaseOverrideState.invalid)
+      void facet.resetSource(path, view.intent);
+  };
+  const refreshDisabled =
+    loading || !path.trim() || idOverrideState.invalid || releaseOverrideState.invalid;
+
+  const [sourcePathHistoryOpen, setSourcePathHistoryOpen] = useState(false);
+  const sourcePathHistoryRef = useRef<HTMLDivElement | null>(null);
+  const sourcePathHistoryAvailable = sourcePathHistory.length > 0;
+
+  useEffect(() => {
+    if (!sourcePathHistoryOpen) {
+      return;
+    }
+    const handlePointerDown = (event: PointerEvent) => {
+      const target = event.target;
+      if (!(target instanceof Node) || sourcePathHistoryRef.current?.contains(target)) {
+        return;
+      }
+      setSourcePathHistoryOpen(false);
+    };
+    document.addEventListener("pointerdown", handlePointerDown);
+    return () => document.removeEventListener("pointerdown", handlePointerDown);
+  }, [sourcePathHistoryOpen]);
+
+  useEffect(() => {
+    if (!sourcePathHistoryAvailable) {
+      setSourcePathHistoryOpen(false);
+    }
+  }, [sourcePathHistoryAvailable]);
+
+  const openSourcePathHistory = () => {
+    if (sourcePathHistoryAvailable) {
+      setSourcePathHistoryOpen(true);
+    }
+  };
+
+  const selectSourcePathHistory = (entry: SourcePathHistoryEntry) => {
+    setSourcePathHistoryOpen(false);
+    facet.selectSource(entry.path);
+  };
+
+  const identityDraft = useMemo(
+    () => externalIdentityDraftFromIdentity(preview.Identity),
+    [preview.Identity],
+  );
+  const externalIDInfo = useMemo(
+    () => externalIDInfoFromIdentity(preview.Identity),
+    [preview.Identity],
+  );
+  const providerDisplays = preview.Display.Providers;
+  const hasPreview = preview.ReleaseName || externalIDInfo.length > 0;
+  const isTVEpisodePreview = (identityDraft.Category || "").trim().toUpperCase() === "TV";
+  const hasResolvedPrimaryExternalID = identityDraft.TMDBID > 0 || identityDraft.IMDBID > 0;
+  const selectedTrackerCount = useMemo(
+    () =>
+      trackerUploadItems.reduce(
+        (count, tracker) => count + (releasePageTrackerSelection[tracker.name] ? 1 : 0),
+        0,
+      ),
+    [trackerUploadItems, releasePageTrackerSelection],
+  );
+  const allTrackersSelected =
+    trackerUploadItems.length > 0 && selectedTrackerCount === trackerUploadItems.length;
+
+  /**
+   * Applies one selection state to every currently configured input tracker.
+   *
+   * Existing selection entries for trackers outside the visible config list are left untouched.
+   */
+  const setAllTrackersSelected = (selected: boolean) => {
+    setReleasePageTrackerSelection((prev) => {
+      const next = { ...prev };
+      trackerUploadItems.forEach((tracker) => {
+        next[tracker.name] = selected;
+      });
+      return next;
+    });
+  };
+
+  const discHint = useMemo(() => {
+    const trimmed = path.trim();
+    if (!trimmed) return "";
+    const normalized = trimmed.replaceAll("\\", "/");
+    const upper = normalized.toUpperCase();
+    if (/(^|\/)BDMV(\/|$)/.test(upper)) {
+      return "Bluray disc folder detected (BDMV).";
+    }
+    if (/(^|\/)VIDEO_TS(\/|$)/.test(upper)) {
+      return "DVD disc folder detected (VIDEO_TS).";
+    }
+    return "";
+  }, [path]);
+
+  const orderedIdentityProviders = useMemo(() => {
+    const fetchedProviders = new Set<string>(providerDisplays.map((item) => item.Provider));
+    return filterAndOrderIdentityProviders(externalIDInfo).filter((item) =>
+      fetchedProviders.has(item.Provider),
+    );
+  }, [externalIDInfo, providerDisplays]);
+
+  const selectedProvider =
+    providerSelection.sourcePath === preview.Release.SourcePath &&
+    providerSelection.generation === preview.Release.Generation &&
+    orderedIdentityProviders.some((item) => item.Provider === providerSelection.provider)
+      ? providerSelection.provider
+      : (orderedIdentityProviders[0]?.Provider ?? "");
+
+  const selectProvider = (provider: string) => {
+    setProviderSelection({
+      sourcePath: preview.Release.SourcePath,
+      generation: preview.Release.Generation,
+      provider,
+    });
+  };
+
+  const tmdbCandidates = useMemo(
+    () => candidatesFromDiagnostics(preview.Diagnostics, "tmdb"),
+    [preview.Diagnostics],
+  );
+  const imdbCandidates = useMemo(
+    () => candidatesFromDiagnostics(preview.Diagnostics, "imdb"),
+    [preview.Diagnostics],
+  );
+  const [candidatePreview, setCandidatePreview] = useState<{
+    provider: "tmdb" | "imdb";
+    candidate: ExternalIdentityCandidate;
+  } | null>(null);
+
+  const selectedCandidateID = (provider: "tmdb" | "imdb") => {
+    if (provider === "tmdb") {
+      const value = idEdits.tmdb.trim();
+      if (!value || !/^\d+$/.test(value)) return 0;
+      return Number(value);
+    }
+    const normalized = idEdits.imdb.trim().replace(/^tt/i, "");
+    if (!normalized || !/^\d+$/.test(normalized)) return 0;
+    return Number(normalized);
+  };
+
+  const applyCandidateID = (provider: "tmdb" | "imdb", candidate: ExternalIdentityCandidate) => {
+    if (!candidate?.ID) return;
+    const currentSelectedID = selectedCandidateID(provider);
+    if (currentSelectedID === candidate.ID) {
+      if (provider === "tmdb") {
+        setIdEdits((prev) => ({ ...prev, tmdb: "" }));
+        markIDTouched("tmdb");
+      } else {
+        setIdEdits((prev) => ({ ...prev, imdb: "" }));
+        markIDTouched("imdb");
+      }
+      if (
+        candidatePreview?.provider === provider &&
+        candidatePreview.candidate.ID === candidate.ID
+      ) {
+        setCandidatePreview(null);
+      }
+      return;
+    }
+    setCandidatePreview({ provider, candidate });
+    if (provider === "tmdb") {
+      setIdEdits((prev) => ({ ...prev, tmdb: candidate.ID.toString() }));
+      markIDTouched("tmdb");
+      return;
+    }
+    setIdEdits((prev) => ({ ...prev, imdb: `tt${candidate.ID.toString().padStart(7, "0")}` }));
+    markIDTouched("imdb");
+  };
+
+  useEffect(() => {
+    if (!showExternalIDInputUI) {
+      setCandidatePreview(null);
+    }
+  }, [showExternalIDInputUI]);
+
+  useEffect(() => {
+    if (!candidatePreview) return;
+    const providerCandidates =
+      candidatePreview.provider === "tmdb" ? tmdbCandidates : imdbCandidates;
+    const stillExists = providerCandidates.some(
+      (candidate) => candidate.ID === candidatePreview.candidate.ID,
+    );
+    if (!stillExists) {
+      setCandidatePreview(null);
+    }
+  }, [candidatePreview, tmdbCandidates, imdbCandidates]);
+
+  const selectedPreview = useMemo(() => {
+    if (!selectedProvider) return null;
+    return providerDisplays.find((item) => item.Provider === selectedProvider) || null;
+  }, [providerDisplays, selectedProvider]);
+
+  const [tvdbDisplayMode, setTVDBDisplayMode] = useState<TVDBDisplayMode>("original");
+
+  const tvdbToggleEnabled = useMemo(() => {
+    if (!selectedPreview) return false;
+    return hasTVDBEnglishDisplay(selectedPreview);
+  }, [selectedPreview]);
+
+  useEffect(() => {
+    if (selectedPreview?.Provider !== "tvdb") {
+      setTVDBDisplayMode("original");
+      return;
+    }
+    setTVDBDisplayMode(tvdbToggleEnabled ? "english" : "original");
+  }, [selectedPreview, tvdbToggleEnabled]);
+
+  const selectedPreviewTitle = useMemo(() => {
+    if (!selectedPreview) return "";
+    if (selectedPreview.Provider !== "tvdb") return selectedPreview.Summary.Title;
+    const tvdb = selectedPreview.Details.TVDB;
+    return pickTVDBText(
+      tvdbDisplayMode,
+      tvdb.Name || selectedPreview.Summary.Title,
+      tvdb.NameEnglish,
+      selectedPreview.Summary.Title,
+    );
+  }, [selectedPreview, tvdbDisplayMode]);
+
+  const selectedPreviewOverview = useMemo(() => {
+    if (!selectedPreview) return "";
+    if (selectedPreview.Provider !== "tvdb") return selectedPreview.Summary.Overview;
+    const tvdb = selectedPreview.Details.TVDB;
+    return pickTVDBText(
+      tvdbDisplayMode,
+      tvdb.Overview || selectedPreview.Summary.Overview,
+      tvdb.OverviewEnglish,
+      selectedPreview.Summary.Overview,
+    );
+  }, [selectedPreview, tvdbDisplayMode]);
+
+  const previewDetails = selectedPreview
+    ? buildPreviewDetails(selectedPreview, tvdbDisplayMode)
+    : [];
+
+  const metadataStatusLabel = (status: string) => {
+    if (status === "running") return "Running";
+    if (status === "completed") return "Done";
+    if (status === "skipped") return "Skipped";
+    if (status === "awaiting_input") return "Waiting";
+    if (status === "failed") return "Failed";
+    return status;
+  };
+
+  const playlist = view.playlist;
+  const togglePlaylist = (file: string) => {
+    const selected = new Set(playlist.selected);
+    if (selected.has(file)) selected.delete(file);
+    else selected.add(file);
+    facet.choosePlaylists([...selected], false);
+  };
+  const toggleAllPlaylists = () => {
+    if (playlist.useAll) {
+      facet.choosePlaylists([], false);
+      return;
+    }
+    facet.choosePlaylists(
+      playlist.candidates.map((candidate) => candidate.file),
+      true,
+    );
+  };
+
+  return (
+    <div className="content-stack">
+      <header className="hero">
+        <p className="eyebrow">upbrr</p>
+        <h1>Build Release Name</h1>
+        <p className="subtitle">
+          Build a release name and preview external metadata before you upload.
+        </p>
+      </header>
+
+      {playlist.required ? (
+        <section className="panel mx-auto grid w-full max-w-2xl gap-3">
+          <div>
+            <h2>Select BDMV Playlists</h2>
+            <p className="muted mt-1 text-sm">
+              Choose playlists for the selected preparation source.
+            </p>
+          </div>
+          {playlist.error ? <p className="error">{playlist.error}</p> : null}
+          {playlist.candidates.length ? (
+            <div className="overflow-hidden rounded-md border border-white/10">
+              {playlist.candidates.map((candidate) => {
+                const totalSize = (candidate.items || []).reduce((sum, item) => sum + item.size, 0);
+                const checkboxID = `playlist-${candidate.file.replaceAll(/[^a-zA-Z0-9_-]/g, "-")}`;
+                return (
+                  <div
+                    key={candidate.file}
+                    className="grid gap-1 border-b border-white/10 px-3 py-2 last:border-b-0 hover:bg-white/5"
+                  >
+                    <div className="flex select-none items-center gap-2">
+                      <Checkbox
+                        id={checkboxID}
+                        checked={playlist.selected.includes(candidate.file)}
+                        onCheckedChange={() => togglePlaylist(candidate.file)}
+                      />
+                      <label className="cursor-pointer font-semibold" htmlFor={checkboxID}>
+                        {candidate.file}
+                      </label>
+                    </div>
+                    <span className="ml-6 text-xs text-[var(--muted)]">
+                      {formatPlaylistDuration(candidate.duration)} • {candidate.items?.length || 0}{" "}
+                      files • {formatPlaylistBytes(totalSize)} • Score: {candidate.score.toFixed(2)}
+                    </span>
+                  </div>
+                );
+              })}
+            </div>
+          ) : null}
+          {playlist.candidates.length > 1 ? (
+            <div className="flex flex-wrap gap-2">
+              <Button type="button" onClick={toggleAllPlaylists}>
+                {playlist.useAll ? "Deselect All" : `Select All Top ${playlist.candidates.length}`}
+              </Button>
+              <Button
+                type="button"
+                onClick={() => facet.choosePlaylists([playlist.candidates[0].file], false)}
+              >
+                Auto-Select Best
+              </Button>
+            </div>
+          ) : null}
+          <div className="flex justify-end gap-2">
+            <Button type="button" onClick={facet.cancelPlaylistSelection}>
+              Back
+            </Button>
+            <Button
+              type="button"
+              variant="primary"
+              disabled={playlist.selected.length === 0 || playlist.status === "processing"}
+              onClick={() => void facet.confirmPlaylists()}
+            >
+              Confirm Selection
+            </Button>
+          </div>
+        </section>
+      ) : null}
+
+      <section
+        className={`panel input-source-panel${
+          sourcePathHistoryOpen ? " input-source-panel--history-open" : ""
+        }`}
+      >
+        <div className="grid gap-3">
+          <div className="grid grid-cols-[minmax(0,1fr)_auto] items-end gap-3 max-[1100px]:grid-cols-1">
+            <div className="grid grid-cols-2 gap-3 max-[900px]:grid-cols-1">
+              <label
+                className="grid gap-1.5 text-sm text-[var(--muted)]"
+                htmlFor="source-lookup-url"
+              >
+                <span>Site URL override</span>
+                <input
+                  id="source-lookup-url"
+                  className={compactInputClass}
+                  value={sourceLookupURL}
+                  onChange={(event) => setSourceLookupURL(event.target.value)}
+                  placeholder="Paste tracker or media URL for ID lookup"
+                />
+                <span className="text-xs leading-tight text-[var(--muted)]">
+                  Metadata ID and tracker description/image lookup.
+                </span>
+              </label>
+
+              <div className="grid gap-1.5 text-sm text-[var(--muted)]" ref={sourcePathHistoryRef}>
+                <label htmlFor="source-path">Source path</label>
+                <div className="source-path-input-shell">
+                  <input
+                    id="source-path"
+                    className={`${compactInputClass} source-path-input`}
+                    value={path}
+                    onChange={(event) => handleSourcePathChange(event.target.value)}
+                    onFocus={openSourcePathHistory}
+                    onClick={openSourcePathHistory}
+                    onKeyDown={(event) => {
+                      if (event.key === "Escape") {
+                        setSourcePathHistoryOpen(false);
+                      }
+                    }}
+                    placeholder="Select a file or folder"
+                    aria-autocomplete="list"
+                    aria-expanded={sourcePathHistoryOpen}
+                    aria-haspopup="listbox"
+                    aria-controls="source-path-history"
+                  />
+                  {sourcePathHistoryOpen ? (
+                    <div
+                      id="source-path-history"
+                      className="source-path-history"
+                      role="listbox"
+                      aria-label="Source path history"
+                    >
+                      {sourcePathHistory.map((entry) => (
+                        <button
+                          key={entry.path}
+                          className="source-path-history__item"
+                          type="button"
+                          role="option"
+                          onMouseDown={(event) => event.preventDefault()}
+                          onClick={() => selectSourcePathHistory(entry)}
+                        >
+                          <span className="mono">{entry.path}</span>
+                        </button>
+                      ))}
+                    </div>
+                  ) : null}
+                </div>
+                <span className="text-xs leading-tight text-[var(--muted)]">
+                  {discHint || "File, disc folder, or Season Pack folder."}
+                </span>
+              </div>
+            </div>
+
+            <div className="flex flex-wrap items-center justify-end gap-2 max-[1100px]:justify-start">
+              <Button type="button" onClick={handleBrowseFile}>
+                Browse file
+              </Button>
+              <Button type="button" onClick={handleBrowseFolder}>
+                Browse folder
+              </Button>
+              <Button variant="primary" type="button" onClick={handleFetch} disabled={loading}>
+                {loading ? "Fetching..." : "Fetch metadata"}
+              </Button>
+            </div>
+          </div>
+        </div>
+        {error ? (
+          <div className="flex flex-wrap items-center gap-2">
+            <p className="error">{error}</p>
+            {view.failure?.Recovery === "confirm" ? (
+              <Button
+                type="button"
+                variant="primary"
+                disabled={loading}
+                onClick={() => void facet.confirmBDMVRescan()}
+              >
+                Confirm Blu-ray rescan
+              </Button>
+            ) : null}
+          </div>
+        ) : null}
+        {(preview.Diagnostics || [])
+          .filter((diagnostic) => diagnostic.Severity === "warning")
+          .map((diagnostic) => (
+            <p key={`${diagnostic.Code}-${diagnostic.Message}`} className="muted">
+              {diagnostic.Message}
+            </p>
+          ))}
+        {view.progress.status !== "ready" &&
+        (view.progress.status !== "idle" || view.progress.steps.length > 0) ? (
+          <div className="metadata-progress">
+            <div className="flex flex-wrap items-center justify-between gap-2">
+              <p className="label">Preparation progress</p>
+              <span className="muted text-xs">{view.progress.message}</span>
+            </div>
+            <div className="metadata-progress__list">
+              {view.progress.steps.map((step) => {
+                const status = step.status;
+                return (
+                  <div
+                    key={step.phase}
+                    className={`metadata-progress__item metadata-progress__item--${status}`}
+                  >
+                    <span className="min-w-0">
+                      <span className="metadata-progress__phase">{step.label}</span>
+                      {step.message ? (
+                        <span className="block truncate text-xs text-[var(--muted)]">
+                          {step.message}
+                        </span>
+                      ) : null}
+                    </span>
+                    <span className="metadata-progress__status">{metadataStatusLabel(status)}</span>
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+        ) : null}
+      </section>
+
+      <section className="results">
+        {hasPreview ? (
+          <div className="summary">
+            <div>
+              <p className="label">Tracker used</p>
+              <p className="value">{preview.TrackerName || "No tracker used"}</p>
+            </div>
+            <div>
+              <p className="label">Release name</p>
+              <p className="value">{preview.ReleaseName || "No release name yet"}</p>
+            </div>
+          </div>
+        ) : null}
+
+        {hasPreview && showExternalIDInputUI && !hasResolvedPrimaryExternalID ? (
+          <div className="panel">
+            <div className="settings-subgroup">
+              <div className="settings-subgroup__title">External ID candidates</div>
+              <p className="muted path-helper">
+                Select a candidate to copy it into ID overrides, then refresh metadata.
+              </p>
+              {tmdbCandidates.length === 0 && imdbCandidates.length === 0 ? (
+                <p className="muted">No TMDB/IMDB candidates available for this search.</p>
+              ) : (
+                <div className="settings-grid">
+                  <div>
+                    <p className="label">TMDB</p>
+                    {tmdbCandidates.length === 0 ? (
+                      <p className="muted">No TMDB candidates</p>
+                    ) : (
+                      <div className="tracker-pills">
+                        {tmdbCandidates.slice(0, 5).map((candidate) => (
+                          <button
+                            key={`tmdb-${candidate.ID}`}
+                            type="button"
+                            className={`ghost candidate-selector ${selectedCandidateID("tmdb") === candidate.ID ? "active" : ""}`}
+                            onClick={() => applyCandidateID("tmdb", candidate)}
+                          >
+                            {candidate.Title || "(Untitled)"}
+                            {candidate.Year ? ` (${candidate.Year})` : ""}
+                            {formatSimilarity(candidate.Similarity)
+                              ? ` • ${formatSimilarity(candidate.Similarity)}`
+                              : ""}
+                          </button>
+                        ))}
+                      </div>
+                    )}
+                    {candidatePreview?.provider === "tmdb" ? (
+                      <div className="settings-subgroup candidate-preview">
+                        <p className="label">Selected TMDB candidate</p>
+                        <div className="candidate-preview__header">
+                          <div className="candidate-preview__text">
+                            <p className="value">
+                              {candidatePreview.candidate.Title || "(Untitled)"}
+                              {candidatePreview.candidate.Year
+                                ? ` (${candidatePreview.candidate.Year})`
+                                : ""}
+                            </p>
+                            <p className="muted">
+                              {candidatePreview.candidate.Category || "Unknown category"}
+                              {formatSimilarity(candidatePreview.candidate.Similarity)
+                                ? ` • ${formatSimilarity(candidatePreview.candidate.Similarity)}`
+                                : ""}
+                            </p>
+                          </div>
+                          {candidatePreview.candidate.PosterURL ? (
+                            <button
+                              className="candidate-preview__poster-button"
+                              type="button"
+                              onClick={() => {
+                                setLightboxImage(candidatePreview.candidate.PosterURL);
+                                setLightboxAlt("TMDB candidate poster");
+                              }}
+                            >
+                              <img
+                                className="candidate-preview__poster"
+                                src={candidatePreview.candidate.PosterURL}
+                                alt="TMDB candidate poster"
+                                loading="lazy"
+                              />
+                            </button>
+                          ) : null}
+                        </div>
+                        <p className="muted">
+                          {candidatePreview.candidate.Overview || "No overview available."}
+                        </p>
+                      </div>
+                    ) : null}
+                  </div>
+                  <div>
+                    <p className="label">IMDB</p>
+                    {imdbCandidates.length === 0 ? (
+                      <p className="muted">No IMDB candidates</p>
+                    ) : (
+                      <div className="tracker-pills">
+                        {imdbCandidates.slice(0, 5).map((candidate) => (
+                          <button
+                            key={`imdb-${candidate.ID}`}
+                            type="button"
+                            className={`ghost candidate-selector ${selectedCandidateID("imdb") === candidate.ID ? "active" : ""}`}
+                            onClick={() => applyCandidateID("imdb", candidate)}
+                          >
+                            {candidate.Title || "(Untitled)"}
+                            {candidate.Year ? ` (${candidate.Year})` : ""}
+                            {formatSimilarity(candidate.Similarity)
+                              ? ` • ${formatSimilarity(candidate.Similarity)}`
+                              : ""}
+                          </button>
+                        ))}
+                      </div>
+                    )}
+                    {candidatePreview?.provider === "imdb" ? (
+                      <div className="settings-subgroup candidate-preview">
+                        <p className="label">Selected IMDB candidate</p>
+                        <div className="candidate-preview__header">
+                          <div className="candidate-preview__text">
+                            <p className="value">
+                              {candidatePreview.candidate.Title || "(Untitled)"}
+                              {candidatePreview.candidate.Year
+                                ? ` (${candidatePreview.candidate.Year})`
+                                : ""}
+                            </p>
+                            <p className="muted">
+                              {candidatePreview.candidate.Category || "Unknown category"}
+                              {formatSimilarity(candidatePreview.candidate.Similarity)
+                                ? ` • ${formatSimilarity(candidatePreview.candidate.Similarity)}`
+                                : ""}
+                            </p>
+                          </div>
+                          {candidatePreview.candidate.PosterURL ? (
+                            <button
+                              className="candidate-preview__poster-button"
+                              type="button"
+                              onClick={() => {
+                                setLightboxImage(candidatePreview.candidate.PosterURL);
+                                setLightboxAlt("IMDB candidate poster");
+                              }}
+                            >
+                              <img
+                                className="candidate-preview__poster"
+                                src={candidatePreview.candidate.PosterURL}
+                                alt="IMDB candidate poster"
+                                loading="lazy"
+                              />
+                            </button>
+                          ) : null}
+                        </div>
+                        <p className="muted">
+                          {candidatePreview.candidate.Overview || "No overview available."}
+                        </p>
+                      </div>
+                    ) : null}
+                  </div>
+                </div>
+              )}
+              <div className="edit-actions">
+                <button
+                  className="primary"
+                  type="button"
+                  onClick={handleRefresh}
+                  disabled={refreshDisabled}
+                >
+                  {loading ? "Refreshing..." : "Refresh metadata"}
+                </button>
+              </div>
+            </div>
+          </div>
+        ) : null}
+
+        <div className="edit-controls">
+          {hasPreview ? (
+            <details className="edit-dropdown tracker-dropdown">
+              <summary>
+                <span>Select Trackers</span>
+                <span className="tracker-summary-count">
+                  {selectedTrackerCount}/{trackerUploadItems.length}
+                </span>
+              </summary>
+              <div className="edit-dropdown__body">
+                <div className="tracker-selection-container">
+                  {trackerUploadItems.length === 0 ? (
+                    <p className="muted">No configured tracker entries found.</p>
+                  ) : (
+                    <>
+                      <div className="mb-2 flex flex-wrap gap-2">
+                        <Button
+                          type="button"
+                          onClick={() => setAllTrackersSelected(true)}
+                          disabled={allTrackersSelected}
+                        >
+                          Select all
+                        </Button>
+                        <Button
+                          type="button"
+                          onClick={() => setAllTrackersSelected(false)}
+                          disabled={selectedTrackerCount === 0}
+                        >
+                          Deselect all
+                        </Button>
+                      </div>
+                      <div className="tracker-pills">
+                        {trackerUploadItems.map((tracker) => {
+                          const iconSrc = trackerIconFor(trackerIconSrcByName, tracker.name);
+                          return (
+                            <PillCheckbox
+                              aria-label={tracker.name}
+                              key={tracker.name}
+                              checked={Boolean(releasePageTrackerSelection[tracker.name])}
+                              onCheckedChange={(checked) =>
+                                setReleasePageTrackerSelection((prev) => ({
+                                  ...prev,
+                                  [tracker.name]: checked,
+                                }))
+                              }
+                            >
+                              <span className="flex items-center gap-1.5">
+                                <TrackerIconImage
+                                  tracker={tracker.name}
+                                  iconSrc={iconSrc}
+                                  enabled={useFavicons}
+                                />
+                                {faviconOnly && useFavicons ? null : tracker.name}
+                              </span>
+                            </PillCheckbox>
+                          );
+                        })}
+                      </div>
+                    </>
+                  )}
+                </div>
+              </div>
+            </details>
+          ) : null}
+          {hasPreview ? (
+            <p className="helper edit-helper">Edit external IDs and Release Name attributes.</p>
+          ) : null}
+          {hasPreview ? (
+            <details className="edit-dropdown">
+              <summary>Edit Release Details</summary>
+              <div className="edit-dropdown__body">
+                <div className="settings-subgroup">
+                  <div className="settings-subgroup__title">External IDs</div>
+                  <div className="id-editor settings-grid">
+                    <div className="settings-field">
+                      <label htmlFor="external-tmdb-id">TMDB ID</label>
+                      <input
+                        id="external-tmdb-id"
+                        value={idEdits.tmdb}
+                        onChange={(event) => {
+                          setIdEdits((prev) => ({ ...prev, tmdb: event.target.value }));
+                          markIDTouched("tmdb");
+                        }}
+                        placeholder="e.g. 550"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="external-imdb-id">IMDB ID</label>
+                      <input
+                        id="external-imdb-id"
+                        value={idEdits.imdb}
+                        onChange={(event) => {
+                          setIdEdits((prev) => ({ ...prev, imdb: event.target.value }));
+                          markIDTouched("imdb");
+                        }}
+                        placeholder="e.g. tt0137523"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="external-tvdb-id">TVDB ID</label>
+                      <input
+                        id="external-tvdb-id"
+                        value={idEdits.tvdb}
+                        onChange={(event) => {
+                          setIdEdits((prev) => ({ ...prev, tvdb: event.target.value }));
+                          markIDTouched("tvdb");
+                        }}
+                        placeholder="e.g. 80379"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="external-tvmaze-id">TVmaze ID</label>
+                      <input
+                        id="external-tvmaze-id"
+                        value={idEdits.tvmaze}
+                        onChange={(event) => {
+                          setIdEdits((prev) => ({ ...prev, tvmaze: event.target.value }));
+                          markIDTouched("tvmaze");
+                        }}
+                        placeholder="e.g. 82"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="external-mal-id">MAL ID</label>
+                      <input
+                        id="external-mal-id"
+                        value={idEdits.mal}
+                        onChange={(event) => {
+                          setIdEdits((prev) => ({ ...prev, mal: event.target.value }));
+                          markIDTouched("mal");
+                        }}
+                        placeholder="e.g. 5114"
+                      />
+                    </div>
+                  </div>
+                </div>
+                <div className="settings-subgroup">
+                  <div className="settings-subgroup__title">Release name overrides</div>
+                  <div className="settings-grid">
+                    <div className="settings-field">
+                      <label htmlFor="release-category">Category</label>
+                      <input
+                        id="release-category"
+                        value={releaseEdits?.category || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, category: event.target.value }));
+                          markReleaseTouched("category");
+                        }}
+                        placeholder="movie or tv"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-type">Type</label>
+                      <input
+                        id="release-type"
+                        value={releaseEdits?.type || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, type: event.target.value }));
+                          markReleaseTouched("type");
+                        }}
+                        placeholder="remux, encode, webdl"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-source">Source</label>
+                      <input
+                        id="release-source"
+                        value={releaseEdits?.source || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, source: event.target.value }));
+                          markReleaseTouched("source");
+                        }}
+                        placeholder="BluRay, WEB, DVD"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-resolution">Resolution</label>
+                      <input
+                        id="release-resolution"
+                        value={releaseEdits?.resolution || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, resolution: event.target.value }));
+                          markReleaseTouched("resolution");
+                        }}
+                        placeholder="2160p"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-tag">Tag</label>
+                      <input
+                        id="release-tag"
+                        value={releaseEdits?.tag || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, tag: event.target.value }));
+                          markReleaseTouched("tag");
+                        }}
+                        placeholder="GROUP"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-service">Service</label>
+                      <input
+                        id="release-service"
+                        value={releaseEdits?.service || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, service: event.target.value }));
+                          markReleaseTouched("service");
+                        }}
+                        placeholder="Netflix"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-edition">Edition</label>
+                      <input
+                        id="release-edition"
+                        value={releaseEdits?.edition || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, edition: event.target.value }));
+                          markReleaseTouched("edition");
+                        }}
+                        placeholder="Director's Cut"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-region">Region</label>
+                      <input
+                        id="release-region"
+                        value={releaseEdits?.region || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, region: event.target.value }));
+                          markReleaseTouched("region");
+                        }}
+                        placeholder="A, B, C"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-season">Season</label>
+                      <input
+                        id="release-season"
+                        value={releaseEdits?.season || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, season: event.target.value }));
+                          markReleaseTouched("season");
+                        }}
+                        placeholder="S01"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-episode">Episode</label>
+                      <input
+                        id="release-episode"
+                        value={releaseEdits?.episode || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, episode: event.target.value }));
+                          markReleaseTouched("episode");
+                        }}
+                        placeholder="E02"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-episode-title">Episode title</label>
+                      <input
+                        id="release-episode-title"
+                        value={releaseEdits?.episodeTitle || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({
+                            ...prev,
+                            episodeTitle: event.target.value,
+                          }));
+                          markReleaseTouched("episodeTitle");
+                        }}
+                        placeholder="Pilot"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-manual-year">Manual year</label>
+                      <input
+                        id="release-manual-year"
+                        type="number"
+                        value={releaseEdits?.manualYear || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, manualYear: event.target.value }));
+                          markReleaseTouched("manualYear");
+                        }}
+                        placeholder="2024"
+                      />
+                    </div>
+                    <div className="settings-field">
+                      <label htmlFor="release-manual-date">Manual date</label>
+                      <input
+                        id="release-manual-date"
+                        value={releaseEdits?.manualDate || ""}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, manualDate: event.target.value }));
+                          markReleaseTouched("manualDate");
+                        }}
+                        placeholder="YYYY-MM-DD"
+                      />
+                    </div>
+                    {isTVEpisodePreview ? (
+                      <div className="settings-toggle">
+                        <span>Use season/episode instead</span>
+                        <Switch
+                          aria-label="Use season/episode instead"
+                          checked={Boolean(releaseEdits?.useSeasonEpisode)}
+                          onChange={(event) => {
+                            setReleaseEdits((prev) => ({
+                              ...prev,
+                              useSeasonEpisode: event.target.checked,
+                            }));
+                            markReleaseTouched("useSeasonEpisode");
+                          }}
+                        />
+                      </div>
+                    ) : null}
+                  </div>
+                </div>
+                <div className="settings-subgroup">
+                  <div className="settings-subgroup__title">Flags</div>
+                  <div className="settings-grid">
+                    <div className="settings-toggle">
+                      <span>No season</span>
+                      <Switch
+                        aria-label="No season"
+                        checked={Boolean(releaseEdits?.noSeason)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noSeason: event.target.checked }));
+                          markReleaseTouched("noSeason");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No year</span>
+                      <Switch
+                        aria-label="No year"
+                        checked={Boolean(releaseEdits?.noYear)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noYear: event.target.checked }));
+                          markReleaseTouched("noYear");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No AKA</span>
+                      <Switch
+                        aria-label="No AKA"
+                        checked={Boolean(releaseEdits?.noAKA)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noAKA: event.target.checked }));
+                          markReleaseTouched("noAKA");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No tag</span>
+                      <Switch
+                        aria-label="No tag"
+                        checked={Boolean(releaseEdits?.noTag)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noTag: event.target.checked }));
+                          markReleaseTouched("noTag");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No edition</span>
+                      <Switch
+                        aria-label="No edition"
+                        checked={Boolean(releaseEdits?.noEdition)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noEdition: event.target.checked }));
+                          markReleaseTouched("noEdition");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No dub</span>
+                      <Switch
+                        aria-label="No dub"
+                        checked={Boolean(releaseEdits?.noDub)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noDub: event.target.checked }));
+                          markReleaseTouched("noDub");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>No dual-audio</span>
+                      <Switch
+                        aria-label="No dual-audio"
+                        checked={Boolean(releaseEdits?.noDual)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, noDual: event.target.checked }));
+                          markReleaseTouched("noDual");
+                        }}
+                      />
+                    </div>
+                    <div className="settings-toggle">
+                      <span>Force dual-audio</span>
+                      <Switch
+                        aria-label="Force dual-audio"
+                        checked={Boolean(releaseEdits?.dualAudio)}
+                        onChange={(event) => {
+                          setReleaseEdits((prev) => ({ ...prev, dualAudio: event.target.checked }));
+                          markReleaseTouched("dualAudio");
+                        }}
+                      />
+                    </div>
+                  </div>
+                </div>
+                {idOverrideState?.invalid ? (
+                  <p className="error">
+                    Enter numeric IDs only. IMDb supports an optional tt prefix.
+                  </p>
+                ) : null}
+                {releaseOverrideState?.invalid ? (
+                  <p className="error">
+                    Manual year must be numeric and manual date must be YYYY-MM-DD.
+                  </p>
+                ) : null}
+                <div className="edit-actions">
+                  <button
+                    className="ghost"
+                    type="button"
+                    onClick={handleResetMetadata}
+                    disabled={loading}
+                  >
+                    {metadataResetting ? "Resetting..." : "Reset data + refresh"}
+                  </button>
+                  <button
+                    className="primary"
+                    type="button"
+                    onClick={handleRefresh}
+                    disabled={refreshDisabled}
+                  >
+                    {loading ? "Refreshing..." : "Refresh metadata"}
+                  </button>
+                </div>
+              </div>
+            </details>
+          ) : null}
+        </div>
+
+        <div className={`details ${hasPreview ? "loaded" : ""}`}>
+          <div className="id-list">
+            <h2>External IDs</h2>
+            {orderedIdentityProviders.length === 0 ? (
+              <p className="muted">No external metadata details found.</p>
+            ) : (
+              orderedIdentityProviders.map((item) => (
+                <button
+                  key={item.Provider}
+                  className={`id-card ${selectedProvider === item.Provider ? "active" : ""}`}
+                  type="button"
+                  onClick={() => selectProvider(item.Provider)}
+                >
+                  <span className="id-label">{formatProvider(item.Provider)}</span>
+                  <span className="id-value">{formatID(item.Provider, item.ID)}</span>
+                  <span className="id-source">Source: {item.Source}</span>
+                </button>
+              ))
+            )}
+          </div>
+
+          <div className="preview-panel">
+            <div className="preview-header">
+              <div>
+                <h2>Preview</h2>
+              </div>
+              {selectedPreview?.Provider === "tvdb" && tvdbToggleEnabled ? (
+                <fieldset className="preview-language-toggle" aria-label="TVDB language display">
+                  <button
+                    className={`ghost ${tvdbDisplayMode === "original" ? "toggle-active" : ""}`}
+                    type="button"
+                    onClick={() => setTVDBDisplayMode("original")}
+                  >
+                    Original
+                  </button>
+                  <button
+                    className={`ghost ${tvdbDisplayMode === "english" ? "toggle-active" : ""}`}
+                    type="button"
+                    onClick={() => setTVDBDisplayMode("english")}
+                  >
+                    English
+                  </button>
+                </fieldset>
+              ) : null}
+            </div>
+            {selectedPreview ? (
+              <div className="preview-content">
+                <div className="preview-text">
+                  <p className="title">{selectedPreviewTitle || "Untitled"}</p>
+                  <p className="meta">
+                    {selectedPreview.Summary.Year ? `${selectedPreview.Summary.Year}` : ""}
+                  </p>
+                  <p className="overview">{selectedPreviewOverview || "No overview available."}</p>
+                  <PreviewDetailsList items={previewDetails} />
+                </div>
+                <div className="preview-images">
+                  {selectedPreview.Summary.PosterURL ? (
+                    <img src={selectedPreview.Summary.PosterURL} alt="Poster" loading="lazy" />
+                  ) : null}
+                  {selectedPreview.Summary.BackdropURL ? (
+                    <img src={selectedPreview.Summary.BackdropURL} alt="Backdrop" loading="lazy" />
+                  ) : null}
+                </div>
+              </div>
+            ) : (
+              <p className="muted">Select an external ID to preview.</p>
+            )}
+          </div>
+        </div>
+      </section>
+    </div>
+  );
+}
diff --git a/gui/frontend/src/pages/logging/index.tsx b/webui/src/pages/logging/index.tsx
similarity index 100%
rename from gui/frontend/src/pages/logging/index.tsx
rename to webui/src/pages/logging/index.tsx
diff --git a/webui/src/pages/menu_images/index.test.tsx b/webui/src/pages/menu_images/index.test.tsx
new file mode 100644
index 00000000..17aaa8b2
--- /dev/null
+++ b/webui/src/pages/menu_images/index.test.tsx
@@ -0,0 +1,127 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { MenuImagesFacet } from "../../releaseSession/types";
+import type { DVDMenuCaptureResult } from "../../types";
+import MenuImagesPage from "./index";
+
+afterEach(cleanup);
+
+const captureResult = (overrides: Partial<DVDMenuCaptureResult> = {}): DVDMenuCaptureResult => ({
+  SourcePath: "C:\\media\\Example",
+  Images: [
+    {
+      Path: "C:\\managed\\menu.png",
+      TimestampSeconds: 0,
+      Index: 0,
+      Purpose: "menu",
+      Width: 1920,
+      Height: 1080,
+      SizeBytes: 1,
+      Discovery: "reachable",
+    },
+  ],
+  SelectedLanguage: "en",
+  Region: 0,
+  DiscoveredMenus: 1,
+  VisitedStates: 2,
+  VisitedButtons: 1,
+  MaxItems: 6,
+  Complete: true,
+  Partial: false,
+  Truncated: false,
+  Warnings: [],
+  Engine: {
+    EngineVersion: "phase0a-1",
+    SchemaVersion: 1,
+    SupportedFeatures: [],
+    FFmpegVersion: "8.0",
+    FFmpegDVDVideo: true,
+    MissingFFmpegOptions: [],
+  },
+  ...overrides,
+});
+
+const facet = (overrides: Partial<MenuImagesFacet> = {}): MenuImagesFacet => ({
+  view: {
+    revision: 1,
+    status: "ready",
+    images: [],
+    capture: null,
+    staleReason: "",
+    error: "",
+  },
+  load: vi.fn(async () => true),
+  importPaths: vi.fn(async () => true),
+  capture: vi.fn(async () => true),
+  cancelCapture: vi.fn(),
+  remove: vi.fn(async () => true),
+  ...overrides,
+});
+
+const renderPage = (menuFacet: MenuImagesFacet) =>
+  render(
+    <MenuImagesPage
+      facet={menuFacet}
+      currentDiscType="DVD"
+      maxMenuItems={6}
+      onContinue={vi.fn()}
+      setLightboxImage={vi.fn()}
+      setLightboxAlt={vi.fn()}
+    />,
+  );
+
+describe("MenuImagesPage", () => {
+  it("forwards capture intent through the facet", async () => {
+    const capture = vi.fn(async () => true);
+    renderPage(facet({ capture }));
+
+    fireEvent.click(screen.getByRole("button", { name: "Capture DVD menus" }));
+
+    await waitFor(() => expect(capture).toHaveBeenCalledOnce());
+  });
+
+  it("forwards explicit capture cancellation", () => {
+    const cancelCapture = vi.fn();
+    renderPage(
+      facet({
+        view: {
+          revision: 2,
+          status: "running",
+          images: [],
+          capture: null,
+          staleReason: "",
+          error: "",
+        },
+        cancelCapture,
+      }),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(cancelCapture).toHaveBeenCalledOnce();
+  });
+
+  it("renders stable capture warnings and truncation from the immutable view", () => {
+    renderPage(
+      facet({
+        view: {
+          revision: 3,
+          status: "ready",
+          images: [],
+          capture: captureResult({
+            Truncated: true,
+            Warnings: [{ Code: "render_partial", Message: "One menu could not be rendered." }],
+          }),
+          staleReason: "",
+          error: "",
+        },
+      }),
+    );
+
+    expect(screen.getByText("Maximum reached")).toBeInTheDocument();
+    expect(screen.getByText("Configured maximum: 6.")).toBeInTheDocument();
+    expect(screen.getByText("One menu could not be rendered.")).toBeInTheDocument();
+  });
+});
diff --git a/webui/src/pages/menu_images/index.tsx b/webui/src/pages/menu_images/index.tsx
new file mode 100644
index 00000000..acadbf32
--- /dev/null
+++ b/webui/src/pages/menu_images/index.tsx
@@ -0,0 +1,257 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { MenuImagesFacet } from "../../releaseSession/types";
+
+type Props = Readonly<{
+  facet: MenuImagesFacet;
+  currentDiscType: string;
+  maxMenuItems: number;
+  onContinue: () => void;
+  setLightboxImage: (value: string) => void;
+  setLightboxAlt: (value: string) => void;
+}>;
+
+const hiddenCaptureWarningCodes = new Set([
+  "unsupported_post_link",
+  "structural_state",
+  "structural_only",
+  "nav_scan_limit",
+  "structural_discovery",
+]);
+
+/** Thin presentation adapter for the exact-generation menu-image facet. */
+export default function MenuImagesPage({
+  facet,
+  currentDiscType,
+  maxMenuItems,
+  onContinue,
+  setLightboxImage,
+  setLightboxAlt,
+}: Props) {
+  const [menuPaths, setMenuPaths] = useState<string[]>([]);
+  const [menuPathDraft, setMenuPathDraft] = useState("");
+  const [notice, setNotice] = useState("");
+  const removeButtonRefs = useRef(new Map<string, HTMLButtonElement>());
+  const captureButtonRef = useRef<HTMLButtonElement>(null);
+  const loadRef = useRef(facet.load);
+  loadRef.current = facet.load;
+  const { view } = facet;
+  const running = view.status === "running";
+  const resolvedMaxMenuItems =
+    Number.isFinite(maxMenuItems) && maxMenuItems > 0 ? Math.trunc(maxMenuItems) : 6;
+  const automaticCaptureAvailable = currentDiscType.toUpperCase() === "DVD";
+
+  useEffect(() => {
+    if (view.status === "idle" && view.staleReason) void loadRef.current();
+  }, [view.staleReason, view.status]);
+
+  const handleAddPath = () => {
+    const selectedPath = menuPathDraft.trim();
+    if (!selectedPath) return;
+    setMenuPaths((previous) => Array.from(new Set([...previous, selectedPath])));
+    setMenuPathDraft("");
+    setNotice("");
+  };
+
+  const handleImport = async () => {
+    if (menuPaths.length === 0) return;
+    setNotice("");
+    if (await facet.importPaths(menuPaths)) {
+      setMenuPaths([]);
+      setNotice("Menu images imported successfully.");
+    }
+  };
+
+  const handleCapture = async () => {
+    setNotice("");
+    await facet.capture();
+  };
+
+  const handleDelete = async (imagePath: string) => {
+    setNotice("");
+    if (await facet.remove(imagePath)) setNotice("Menu image removed.");
+  };
+
+  const completionMessage = useMemo(() => {
+    if (!view.capture) return "";
+    if (view.capture.Truncated) return "Maximum reached";
+    return `Captured ${view.capture.Images.length} DVD menu image${view.capture.Images.length === 1 ? "" : "s"}.`;
+  }, [view.capture]);
+  const visibleCaptureWarnings =
+    view.capture?.Warnings?.filter((warning) => !hiddenCaptureWarningCodes.has(warning.Code)) ?? [];
+
+  return (
+    <section className="grid gap-4">
+      <header>
+        <p className="eyebrow">Disc Menus</p>
+        <h1>Menu Images</h1>
+        <p className="subtitle">
+          Capture DVD menus or import existing disc menu images for upload and descriptions.
+        </p>
+      </header>
+
+      {automaticCaptureAvailable ? (
+        <section className="panel grid gap-3" aria-busy={running}>
+          <div>
+            <h2>Automatic DVD capture</h2>
+            <p className="muted">Capture up to {resolvedMaxMenuItems} distinct DVD menu screens.</p>
+          </div>
+          <div className="flex flex-wrap gap-2">
+            <button
+              ref={captureButtonRef}
+              className="primary"
+              type="button"
+              onClick={handleCapture}
+              disabled={running || Boolean(view.staleReason)}
+            >
+              {running ? "Capturing..." : "Capture DVD menus"}
+            </button>
+            {running ? (
+              <button className="ghost" type="button" onClick={facet.cancelCapture}>
+                Cancel
+              </button>
+            ) : null}
+          </div>
+          {view.capture ? (
+            <div className="grid gap-1" role="status" aria-live="polite">
+              <p className="muted m-0">
+                Menus {view.capture.DiscoveredMenus} · States {view.capture.VisitedStates} · Buttons{" "}
+                {view.capture.VisitedButtons} · Captured {view.capture.Images.length}
+                {visibleCaptureWarnings.length > 0
+                  ? ` · Warnings ${visibleCaptureWarnings.length}`
+                  : ""}
+              </p>
+              {completionMessage ? <p className="success m-0">{completionMessage}</p> : null}
+              {view.capture.Truncated ? (
+                <p className="muted m-0">Configured maximum: {view.capture.MaxItems}.</p>
+              ) : null}
+              {visibleCaptureWarnings.map((warning) => (
+                <p className="muted m-0" key={warning.Code}>
+                  {warning.Message}
+                </p>
+              ))}
+            </div>
+          ) : null}
+        </section>
+      ) : (
+        <section className="panel">
+          <p className="muted">
+            Automatic capture is available for DVD sources. Manual disc menu import remains
+            available for {currentDiscType || "this source"}.
+          </p>
+        </section>
+      )}
+
+      <section className="panel grid gap-3">
+        <div>
+          <h2>Import menu images</h2>
+          <p className="muted">Add PNG, JPEG, or WebP paths visible to the WebUI host.</p>
+        </div>
+        <div className="flex flex-wrap gap-2">
+          <input
+            className="min-w-[18rem] flex-1"
+            aria-label="Menu image path"
+            value={menuPathDraft}
+            onChange={(event) => setMenuPathDraft(event.target.value)}
+            placeholder="D:\\Media\\menu.png"
+          />
+          <button className="ghost" type="button" onClick={handleAddPath} disabled={running}>
+            Add path
+          </button>
+          <button
+            className="primary"
+            type="button"
+            onClick={handleImport}
+            disabled={running || menuPaths.length === 0}
+          >
+            {running ? "Working..." : "Import images"}
+          </button>
+        </div>
+        {menuPaths.length > 0 ? (
+          <ul className="m-0 grid list-none gap-1 p-0">
+            {menuPaths.map((selectedPath) => (
+              <li
+                className="flex items-center justify-between gap-2 rounded border border-white/10 bg-white/5 p-2"
+                key={selectedPath}
+              >
+                <span className="min-w-0 break-all">{selectedPath}</span>
+                <button
+                  className="ghost"
+                  type="button"
+                  onClick={() =>
+                    setMenuPaths((previous) => previous.filter((item) => item !== selectedPath))
+                  }
+                >
+                  Remove
+                </button>
+              </li>
+            ))}
+          </ul>
+        ) : null}
+      </section>
+
+      {view.error ? (
+        <p className="error" role="alert">
+          {view.error}
+        </p>
+      ) : null}
+      {notice ? (
+        <p className="success" role="status" aria-live="polite">
+          {notice}
+        </p>
+      ) : null}
+
+      <section className="panel grid gap-3">
+        <div className="flex flex-wrap items-baseline justify-between gap-2">
+          <h2>Saved menu images</h2>
+          <p className="muted">{running ? "Loading..." : `${view.images.length} saved`}</p>
+        </div>
+        {view.images.length > 0 ? (
+          <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-3">
+            {view.images.map((item, index) => {
+              const itemNumber = index + 1;
+              return (
+                <article className="grid gap-2" key={item.image.Path}>
+                  <button
+                    className="screens-thumb"
+                    type="button"
+                    aria-label={`Preview DVD menu ${itemNumber}`}
+                    onClick={() => {
+                      setLightboxImage(item.dataURI);
+                      setLightboxAlt(`DVD menu ${itemNumber}`);
+                    }}
+                  >
+                    <img src={item.dataURI} alt="" />
+                  </button>
+                  <button
+                    ref={(element) => {
+                      if (element) removeButtonRefs.current.set(item.image.Path, element);
+                      else removeButtonRefs.current.delete(item.image.Path);
+                    }}
+                    className="danger"
+                    type="button"
+                    aria-label={`Remove DVD menu ${itemNumber}`}
+                    disabled={running}
+                    onClick={() => handleDelete(item.image.Path)}
+                  >
+                    Remove
+                  </button>
+                </article>
+              );
+            })}
+          </div>
+        ) : (
+          <p className="muted">No saved menu images yet.</p>
+        )}
+      </section>
+
+      <div className="flex justify-end">
+        <button className="primary" type="button" onClick={onContinue}>
+          Continue to Upload Images
+        </button>
+      </div>
+    </section>
+  );
+}
diff --git a/webui/src/pages/screenshots/index.test.tsx b/webui/src/pages/screenshots/index.test.tsx
new file mode 100644
index 00000000..d16a541a
--- /dev/null
+++ b/webui/src/pages/screenshots/index.test.tsx
@@ -0,0 +1,133 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { ScreenshotsFacet } from "../../releaseSession/types";
+import type { ScreenshotImage, ScreenshotPlan } from "../../types";
+import ScreenshotsPage from ".";
+
+const image = (
+  path: string,
+  index: number,
+  purpose: ScreenshotImage["Purpose"],
+): ScreenshotImage => ({
+  Index: index,
+  TimestampSeconds: index + 1,
+  Path: path,
+  Purpose: purpose,
+  Width: 1920,
+  Height: 1080,
+  SizeBytes: 1024,
+});
+
+const plan = (): ScreenshotPlan => ({
+  SourcePath: "C:\\media\\Example.Release.2026.1080p-GRP.mkv",
+  DiscType: "",
+  DurationSeconds: 120,
+  FrameRate: 24,
+  SuggestedSelections: [{ Index: 0, TimestampSeconds: 12, Frame: 288, Source: "auto" }],
+  ExistingScreenshots: [image("C:\\tmp\\existing.png", 0, "final")],
+  ExistingTrackerScreenshots: [image("C:\\tmp\\tracker.png", 1, "final")],
+  FinalSelections: [image("C:\\tmp\\final.png", 2, "final")],
+  TrackerImageLinks: [
+    {
+      Tracker: "EXAMPLE",
+      URL: "https://images.example/screenshot.png",
+      Path: "C:\\tmp\\tracker.png",
+    },
+  ],
+  PreviewImages: [image("C:\\tmp\\preview.png", 3, "preview")],
+  MetadataTimestamp: "2026-07-16T00:00:00Z",
+  RequiresManualFrames: false,
+});
+
+const facet = (): ScreenshotsFacet => {
+  const screenshotPlan = plan();
+  return {
+    view: {
+      revision: 1,
+      status: "ready",
+      plan: screenshotPlan,
+      result: null,
+      selections: screenshotPlan.SuggestedSelections,
+      finalSelectionPaths: screenshotPlan.FinalSelections.map((entry) => entry.Path),
+      previewImage: "data:image/png;base64,live",
+      staleReason: "",
+      error: "",
+    },
+    load: vi.fn(async () => true),
+    changeSelection: vi.fn(),
+    generate: vi.fn(async () => true),
+    previewFrame: vi.fn(async () => true),
+    remove: vi.fn(async () => true),
+    removeMany: vi.fn(async () => true),
+    removeTrackerURL: vi.fn(async () => true),
+    removeTrackerURLs: vi.fn(async () => true),
+    selectFinal: vi.fn(async () => true),
+    reorderFinal: vi.fn(async () => true),
+    saveFinal: vi.fn(async () => true),
+    readImage: vi.fn(async (path) => `data:image/png;base64,${encodeURIComponent(path)}`),
+  };
+};
+
+describe("ScreenshotsPage", () => {
+  it("restores the main gallery layout while routing actions through the session facet", async () => {
+    const screenshots = facet();
+    const updateScreenshotConfigValue = vi.fn();
+    render(
+      <ScreenshotsPage
+        facet={screenshots}
+        screenshotConfig={{ Screens: 4, ToneMap: false }}
+        updateScreenshotConfigValue={updateScreenshotConfigValue}
+        loadSettings={vi.fn()}
+        settingsLoading={false}
+        settingsDirty
+        settingsSaved=""
+        settingsError=""
+        applyScreenshotSettings={vi.fn()}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+      />,
+    );
+
+    for (const heading of [
+      "Live Preview",
+      "Tracker Images",
+      "Existing Captures",
+      "Tracker Temp Images",
+      "Frame Selection",
+      "Preview Captures",
+      "Final Captures",
+    ]) {
+      expect(screen.getByRole("heading", { name: heading })).toBeVisible();
+    }
+
+    await waitFor(() => expect(screenshots.readImage).toHaveBeenCalledTimes(4));
+    expect(screen.getByAltText("Existing 1")).toHaveAttribute(
+      "src",
+      expect.stringContaining("data:image/png"),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Load suggestions" }));
+    expect(screenshots.load).toHaveBeenCalledOnce();
+
+    fireEvent.click(screen.getByRole("button", { name: "Generate screenshots" }));
+    expect(screenshots.generate).toHaveBeenCalledWith("final");
+
+    const frameSection = screen
+      .getByRole("heading", { name: "Frame Selection" })
+      .closest("section");
+    if (!frameSection) throw new Error("frame selection section missing");
+    fireEvent.click(within(frameSection).getByRole("button", { name: "Preview" }));
+    expect(screenshots.generate).toHaveBeenCalledWith("preview", [
+      { Index: 0, TimestampSeconds: 12, Frame: 288, Source: "auto" },
+    ]);
+
+    fireEvent.click(screen.getAllByRole("button", { name: "Add to final" })[0]);
+    expect(screenshots.selectFinal).toHaveBeenCalledWith("C:\\tmp\\existing.png", true);
+
+    fireEvent.change(screen.getByLabelText("Screenshot count"), { target: { value: "6" } });
+    expect(updateScreenshotConfigValue).toHaveBeenCalledWith("Screens", 6);
+  });
+});
diff --git a/webui/src/pages/screenshots/index.tsx b/webui/src/pages/screenshots/index.tsx
new file mode 100644
index 00000000..4d10e543
--- /dev/null
+++ b/webui/src/pages/screenshots/index.tsx
@@ -0,0 +1,770 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Switch } from "../../components/ui/switch";
+import type { ScreenshotsFacet } from "../../releaseSession/types";
+import type { ConfigMap, ConfigValue, ScreenshotImage, ScreenshotSelection } from "../../types";
+
+type Props = Readonly<{
+  facet: ScreenshotsFacet;
+  screenshotConfig: ConfigMap | null;
+  updateScreenshotConfigValue: (key: string, value: ConfigValue) => void;
+  loadSettings: () => void;
+  settingsLoading: boolean;
+  settingsDirty: boolean;
+  settingsSaved: string;
+  settingsError: string;
+  applyScreenshotSettings: () => void;
+  setLightboxImage: (value: string) => void;
+  setLightboxAlt: (value: string) => void;
+}>;
+
+const uniqueImages = (images: readonly ScreenshotImage[]) => {
+  const paths = new Set<string>();
+  return images.filter((image) => {
+    if (!image.Path || paths.has(image.Path)) return false;
+    paths.add(image.Path);
+    return true;
+  });
+};
+
+/** Presents screenshot planning, generation, ordering, preview, and final selection. */
+export default function ScreenshotsPage({
+  facet,
+  screenshotConfig,
+  updateScreenshotConfigValue,
+  loadSettings,
+  settingsLoading,
+  settingsDirty,
+  settingsSaved,
+  settingsError,
+  applyScreenshotSettings,
+  setLightboxImage,
+  setLightboxAlt,
+}: Props) {
+  const { view } = facet;
+  const loadRef = useRef(facet.load);
+  const readImageRef = useRef(facet.readImage);
+  const imageCacheRef = useRef<Record<string, string>>({});
+  const [imageDataByPath, setImageDataByPath] = useState<Record<string, string>>({});
+  const [livePreviewSeconds, setLivePreviewSeconds] = useState(0);
+  const [finalDragIndex, setFinalDragIndex] = useState<number | null>(null);
+  loadRef.current = facet.load;
+  readImageRef.current = facet.readImage;
+
+  useEffect(() => {
+    if (view.status === "idle" && view.staleReason) void loadRef.current();
+  }, [view.staleReason, view.status]);
+
+  const plan = view.plan;
+  const busy = view.status === "running";
+  const selections = view.selections;
+  const existingImages = uniqueImages(plan?.ExistingScreenshots || []);
+  const existingTrackerImages = uniqueImages(plan?.ExistingTrackerScreenshots || []);
+  const previewImages = uniqueImages([
+    ...(plan?.PreviewImages || []),
+    ...(view.result?.Purpose === "preview" ? view.result.Images || [] : []),
+  ]);
+  const availableImages = uniqueImages([
+    ...existingImages,
+    ...existingTrackerImages,
+    ...(plan?.FinalSelections || []),
+    ...previewImages,
+    ...(view.result?.Images || []),
+  ]);
+  const imageByPath = useMemo(
+    () => new Map(availableImages.map((image) => [image.Path, image])),
+    [availableImages],
+  );
+  const finalImages = view.finalSelectionPaths
+    .map((path) => imageByPath.get(path))
+    .filter((image): image is ScreenshotImage => !!image);
+  const finalPaths = useMemo(() => new Set(view.finalSelectionPaths), [view.finalSelectionPaths]);
+  const localImagePathKey = availableImages
+    .map((image) => image.Path)
+    .filter(Boolean)
+    .join("\u0000");
+
+  useEffect(() => {
+    let canceled = false;
+    const loadImages = async () => {
+      const next = { ...imageCacheRef.current };
+      for (const path of localImagePathKey ? localImagePathKey.split("\u0000") : []) {
+        if (next[path]) continue;
+        try {
+          next[path] = await readImageRef.current(path);
+        } catch {
+          next[path] = "";
+        }
+        if (canceled) return;
+      }
+      imageCacheRef.current = next;
+      setImageDataByPath(next);
+    };
+    void loadImages();
+    return () => {
+      canceled = true;
+    };
+  }, [localImagePathKey]);
+
+  const previewDuration = Math.max(plan?.DurationSeconds || 0, 0);
+  const previewFrameRate = Math.max(plan?.FrameRate || 0, 0);
+  const previewTimingDisabled = previewDuration <= 0 || previewFrameRate <= 0;
+  const clampPreviewSeconds = (value: number) => {
+    if (!Number.isFinite(value)) return 0;
+    return Math.min(Math.max(value, 0), previewDuration);
+  };
+  const livePreviewFrame =
+    previewFrameRate > 0 ? Math.max(0, Math.round(livePreviewSeconds * previewFrameRate)) : 0;
+
+  const runLivePreviewAt = async (value: number) => {
+    const next = clampPreviewSeconds(value);
+    setLivePreviewSeconds(next);
+    await facet.previewFrame(next);
+  };
+
+  const stepLivePreview = (direction: number) => {
+    if (previewTimingDisabled) return;
+    void runLivePreviewAt(livePreviewSeconds + direction / previewFrameRate);
+  };
+
+  const captureLivePreview = () => {
+    if (selections.length === 0) return;
+
+    const closest = selections.reduce<ScreenshotSelection | null>((current, selection) => {
+      if (!current) return selection;
+      return Math.abs(selection.TimestampSeconds - livePreviewSeconds) <
+        Math.abs(current.TimestampSeconds - livePreviewSeconds)
+        ? selection
+        : current;
+    }, null);
+    const selection: ScreenshotSelection = {
+      Index: closest?.Index ?? 0,
+      TimestampSeconds: clampPreviewSeconds(livePreviewSeconds),
+      Frame: livePreviewFrame,
+      Source: "manual",
+    };
+    void facet.generate("preview", [selection]);
+  };
+
+  const openLocalImage = (image: ScreenshotImage, label: string) => {
+    const dataURI = imageDataByPath[image.Path];
+    if (!dataURI) return;
+    setLightboxImage(dataURI);
+    setLightboxAlt(label);
+  };
+
+  const confirmDeleteAll = (label: string, images: readonly ScreenshotImage[]) => {
+    if (!images.length || !globalThis.confirm(`Delete all ${label} images from the temp folder?`))
+      return;
+    void facet.removeMany(images.map((image) => image.Path));
+  };
+
+  const renderLocalThumbnail = (image: ScreenshotImage, alt: string) => {
+    const dataURI = imageDataByPath[image.Path];
+    return dataURI ? (
+      <img src={dataURI} alt={alt} />
+    ) : (
+      <span className="muted block p-4 text-center text-sm">Loading image...</span>
+    );
+  };
+
+  return (
+    <section className="screens-panel">
+      <header className="screens-header">
+        <p className="eyebrow">Screenshots</p>
+        <h1>Plan &amp; Capture</h1>
+        <p className="subtitle">
+          Review tracker images, adjust frame times, and generate screenshots.
+        </p>
+      </header>
+
+      <section className="panel screens-actions" aria-busy={busy}>
+        <div>
+          <p className="label">Source path</p>
+          <p className="value dupe-path">{plan?.SourcePath || "No prepared source"}</p>
+          {plan ? (
+            <div className="screens-meta">
+              <p className="muted">Duration: {plan.DurationSeconds.toFixed(1)}s</p>
+              <p className="muted">Frame rate: {plan.FrameRate.toFixed(3)}</p>
+              {plan.DiscType ? <p className="muted">Disc type: {plan.DiscType}</p> : null}
+            </div>
+          ) : null}
+        </div>
+        <div className="screens-actions__buttons">
+          <button className="ghost" type="button" onClick={() => void facet.load()} disabled={busy}>
+            {busy ? "Loading..." : "Load suggestions"}
+          </button>
+          <button
+            className="primary"
+            type="button"
+            onClick={() => void facet.generate("final")}
+            disabled={busy || selections.length === 0}
+          >
+            {busy ? "Capturing..." : "Generate screenshots"}
+          </button>
+        </div>
+      </section>
+
+      <section className="panel screens-settings">
+        <details>
+          <summary>Screenshot settings</summary>
+          {screenshotConfig ? (
+            <div className="screens-settings__grid">
+              <label className="settings-field">
+                <span>Screenshot count</span>
+                <input
+                  type="number"
+                  value={
+                    typeof screenshotConfig.Screens === "number" ? screenshotConfig.Screens : 0
+                  }
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("Screens", Number(event.target.value))
+                  }
+                />
+              </label>
+              <div className="settings-toggle">
+                <span>Tonemap HDR</span>
+                <Switch
+                  aria-label="Tonemap HDR"
+                  checked={Boolean(screenshotConfig.ToneMap)}
+                  onChange={(event) => updateScreenshotConfigValue("ToneMap", event.target.checked)}
+                />
+              </div>
+              <div className="settings-toggle">
+                <span>Use libplacebo</span>
+                <Switch
+                  aria-label="Use libplacebo"
+                  checked={Boolean(screenshotConfig.UseLibplacebo)}
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("UseLibplacebo", event.target.checked)
+                  }
+                />
+              </div>
+              <div className="settings-toggle">
+                <span>Frame overlay</span>
+                <Switch
+                  aria-label="Frame overlay"
+                  checked={Boolean(screenshotConfig.FrameOverlay)}
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("FrameOverlay", event.target.checked)
+                  }
+                />
+              </div>
+              <label className="settings-field">
+                <span>Overlay text size</span>
+                <input
+                  type="number"
+                  value={
+                    typeof screenshotConfig.OverlayTextSize === "number"
+                      ? screenshotConfig.OverlayTextSize
+                      : 0
+                  }
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("OverlayTextSize", Number(event.target.value))
+                  }
+                />
+              </label>
+              <label className="settings-field">
+                <span>FFmpeg compression</span>
+                <input
+                  type="number"
+                  value={
+                    typeof screenshotConfig.FFmpegCompression === "number"
+                      ? screenshotConfig.FFmpegCompression
+                      : 0
+                  }
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("FFmpegCompression", Number(event.target.value))
+                  }
+                />
+              </label>
+              <label className="settings-field">
+                <span>Tonemap algorithm</span>
+                <input
+                  type="text"
+                  value={
+                    typeof screenshotConfig.TonemapAlgorithm === "string"
+                      ? screenshotConfig.TonemapAlgorithm
+                      : ""
+                  }
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("TonemapAlgorithm", event.target.value)
+                  }
+                />
+              </label>
+              <label className="settings-field">
+                <span>Desat</span>
+                <input
+                  type="number"
+                  step="0.01"
+                  value={typeof screenshotConfig.Desat === "number" ? screenshotConfig.Desat : 0}
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("Desat", Number(event.target.value))
+                  }
+                />
+              </label>
+              <div className="settings-toggle">
+                <span>Limit ffmpeg concurrency</span>
+                <Switch
+                  aria-label="Limit ffmpeg concurrency"
+                  checked={Boolean(screenshotConfig.FFmpegLimit)}
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("FFmpegLimit", event.target.checked)
+                  }
+                />
+              </div>
+              <label className="settings-field">
+                <span>FFmpeg concurrency</span>
+                <input
+                  type="number"
+                  value={
+                    typeof screenshotConfig.ProcessLimit === "number"
+                      ? screenshotConfig.ProcessLimit
+                      : 1
+                  }
+                  onChange={(event) =>
+                    updateScreenshotConfigValue("ProcessLimit", Number(event.target.value))
+                  }
+                />
+              </label>
+            </div>
+          ) : (
+            <p className="muted">Load settings to edit screenshot handling.</p>
+          )}
+          <div className="screens-settings__actions">
+            <button
+              className="ghost"
+              type="button"
+              onClick={loadSettings}
+              disabled={settingsLoading}
+            >
+              {settingsLoading ? "Loading..." : "Reload settings"}
+            </button>
+            <button
+              className="primary"
+              type="button"
+              onClick={applyScreenshotSettings}
+              disabled={settingsLoading || !settingsDirty}
+            >
+              {settingsLoading ? "Applying..." : "Apply settings"}
+            </button>
+          </div>
+          {settingsError ? <p className="error">{settingsError}</p> : null}
+          {settingsSaved ? <p className="success">{settingsSaved}</p> : null}
+        </details>
+      </section>
+
+      {view.error ? (
+        <p className="error" role="alert">
+          {view.error}
+        </p>
+      ) : null}
+      {plan?.RequiresManualFrames ? (
+        <p className="muted">
+          Duration or frame rate is missing. Enter manual frame times before capturing.
+        </p>
+      ) : null}
+
+      <section className="panel screens-preview">
+        <div className="screens-gallery__header">
+          <h2>Live Preview</h2>
+          <p className="muted">Scrub the timeline and capture the current frame.</p>
+        </div>
+        {plan ? (
+          <div className="screens-preview__body">
+            <div className="screens-preview__controls">
+              <label className="screens-field">
+                <span>Seconds</span>
+                <input
+                  type="number"
+                  step="0.1"
+                  value={livePreviewSeconds}
+                  onChange={(event) =>
+                    setLivePreviewSeconds(clampPreviewSeconds(Number(event.target.value)))
+                  }
+                />
+              </label>
+              <label className="screens-field">
+                <span>Frame</span>
+                <input
+                  type="number"
+                  step="1"
+                  value={livePreviewFrame}
+                  onChange={(event) => {
+                    const frame = Number(event.target.value);
+                    setLivePreviewSeconds(
+                      previewFrameRate > 0 ? clampPreviewSeconds(frame / previewFrameRate) : 0,
+                    );
+                  }}
+                />
+              </label>
+              <div className="screens-preview__slider">
+                <input
+                  aria-label="Preview timeline"
+                  type="range"
+                  min={0}
+                  max={previewDuration}
+                  step={previewFrameRate > 0 ? 1 / previewFrameRate : 1}
+                  value={clampPreviewSeconds(livePreviewSeconds)}
+                  onChange={(event) =>
+                    setLivePreviewSeconds(clampPreviewSeconds(Number(event.target.value)))
+                  }
+                  disabled={previewTimingDisabled}
+                />
+                <div className="screens-preview__meta">
+                  <span className="muted">Duration: {previewDuration.toFixed(1)}s</span>
+                  <span className="muted">FPS: {previewFrameRate.toFixed(3)}</span>
+                </div>
+              </div>
+              <div className="screens-preview__buttons">
+                <button
+                  className="ghost"
+                  type="button"
+                  onClick={() => stepLivePreview(-1)}
+                  disabled={previewTimingDisabled || busy}
+                >
+                  Prev frame
+                </button>
+                <button
+                  className="ghost"
+                  type="button"
+                  onClick={() => stepLivePreview(1)}
+                  disabled={previewTimingDisabled || busy}
+                >
+                  Next frame
+                </button>
+                <button
+                  className="ghost"
+                  type="button"
+                  onClick={() => void runLivePreviewAt(livePreviewSeconds)}
+                  disabled={previewTimingDisabled || busy}
+                >
+                  {busy ? "Loading..." : "Run preview"}
+                </button>
+                <button
+                  className="primary"
+                  type="button"
+                  onClick={captureLivePreview}
+                  disabled={previewTimingDisabled || busy || selections.length === 0}
+                >
+                  {busy ? "Capturing..." : "Capture preview"}
+                </button>
+              </div>
+            </div>
+            <div className="screens-preview__image">
+              {view.previewImage ? (
+                <button
+                  className="screens-thumb max-w-md"
+                  type="button"
+                  onClick={() => {
+                    setLightboxImage(view.previewImage);
+                    setLightboxAlt("Live preview");
+                  }}
+                >
+                  <img src={view.previewImage} alt="Live preview" />
+                </button>
+              ) : busy ? (
+                <p className="muted">Loading preview...</p>
+              ) : (
+                <p className="muted">No preview yet.</p>
+              )}
+            </div>
+          </div>
+        ) : (
+          <p className="muted">Load suggestions to enable live preview.</p>
+        )}
+      </section>
+
+      {(plan?.TrackerImageLinks || []).length ? (
+        <section className="panel screens-gallery">
+          <div className="screens-gallery__header">
+            <h2>Tracker Images</h2>
+            <p className="muted">Already available from tracker data.</p>
+            <button
+              className="ghost"
+              type="button"
+              disabled={busy}
+              onClick={() => {
+                const links = plan?.TrackerImageLinks || [];
+                if (globalThis.confirm("Delete all tracker image links?"))
+                  void facet.removeTrackerURLs(links.map((link) => link.URL));
+              }}
+            >
+              Delete all
+            </button>
+          </div>
+          <div className="screens-grid">
+            {plan?.TrackerImageLinks.map((link, index) => (
+              <div className="screens-thumb-card" key={`${link.URL}-${index}`}>
+                <button
+                  className="screens-thumb"
+                  type="button"
+                  onClick={() => {
+                    setLightboxImage(link.URL);
+                    setLightboxAlt("Tracker image");
+                  }}
+                >
+                  <img src={link.URL} alt="Tracker screenshot" loading="lazy" />
+                </button>
+                <button
+                  className="screens-thumb-delete"
+                  type="button"
+                  disabled={busy}
+                  onClick={() => void facet.removeTrackerURL(link.URL)}
+                >
+                  Delete
+                </button>
+              </div>
+            ))}
+          </div>
+        </section>
+      ) : null}
+
+      {existingImages.length ? (
+        <section className="panel screens-gallery">
+          <div className="screens-gallery__header">
+            <h2>Existing Captures</h2>
+            <p className="muted">Previously generated screenshots in the temp folder.</p>
+            <button
+              className="ghost"
+              type="button"
+              disabled={busy}
+              onClick={() => confirmDeleteAll("existing", existingImages)}
+            >
+              Delete all
+            </button>
+          </div>
+          <div className="screens-grid">
+            {existingImages.map((image) => {
+              const selected = finalPaths.has(image.Path);
+              return (
+                <div className="screens-thumb-card" key={`existing-${image.Path}`}>
+                  <button
+                    className="screens-thumb"
+                    type="button"
+                    onClick={() => openLocalImage(image, `Existing ${image.Index + 1}`)}
+                  >
+                    {renderLocalThumbnail(image, `Existing ${image.Index + 1}`)}
+                  </button>
+                  <button
+                    className="ghost"
+                    type="button"
+                    disabled={busy || selected}
+                    onClick={() => void facet.selectFinal(image.Path, true)}
+                  >
+                    {selected ? "Added" : "Add to final"}
+                  </button>
+                  <button
+                    className="screens-thumb-delete"
+                    type="button"
+                    disabled={busy || !selected}
+                    onClick={() => void facet.selectFinal(image.Path, false)}
+                  >
+                    Remove
+                  </button>
+                </div>
+              );
+            })}
+          </div>
+        </section>
+      ) : null}
+
+      {existingTrackerImages.length ? (
+        <section className="panel screens-gallery">
+          <div className="screens-gallery__header">
+            <h2>Tracker Temp Images</h2>
+            <p className="muted">Images stored in tracker temp folders.</p>
+            <button
+              className="ghost"
+              type="button"
+              disabled={busy}
+              onClick={() => confirmDeleteAll("tracker", existingTrackerImages)}
+            >
+              Delete all
+            </button>
+          </div>
+          <div className="screens-grid">
+            {existingTrackerImages.map((image) => {
+              const selected = finalPaths.has(image.Path);
+              return (
+                <div className="screens-thumb-card" key={`tracker-${image.Path}`}>
+                  <button
+                    className="screens-thumb"
+                    type="button"
+                    onClick={() => openLocalImage(image, "Tracker temp image")}
+                  >
+                    {renderLocalThumbnail(image, "Tracker temp screenshot")}
+                  </button>
+                  <button
+                    className="ghost"
+                    type="button"
+                    disabled={busy || selected}
+                    onClick={() => void facet.selectFinal(image.Path, true)}
+                  >
+                    {selected ? "Added" : "Add to final"}
+                  </button>
+                  <button
+                    className="screens-thumb-delete"
+                    type="button"
+                    disabled={busy}
+                    onClick={() => void facet.remove(image.Path)}
+                  >
+                    Delete
+                  </button>
+                </div>
+              );
+            })}
+          </div>
+        </section>
+      ) : null}
+
+      <section className="panel screens-list">
+        <div className="screens-gallery__header">
+          <h2>Frame Selection</h2>
+          <p className="muted">Adjust timestamps or frame numbers, then preview.</p>
+        </div>
+        {!plan ? (
+          <p className="muted">Load suggestions to edit frame selections.</p>
+        ) : selections.length === 0 ? (
+          <p className="muted">No selections available yet.</p>
+        ) : (
+          <div className="screens-rows">
+            {selections.map((selection, index) => (
+              <div className="screens-row" key={`sel-${selection.Index}`}>
+                <div>
+                  <p className="label">Shot {selection.Index + 1}</p>
+                  <p className="muted">Source: {selection.Source || "auto"}</p>
+                </div>
+                <label className="screens-field">
+                  <span>Seconds</span>
+                  <input
+                    type="number"
+                    step="0.1"
+                    value={selection.TimestampSeconds}
+                    onChange={(event) =>
+                      facet.changeSelection(index, {
+                        TimestampSeconds: Number(event.target.value) || 0,
+                      })
+                    }
+                  />
+                </label>
+                <label className="screens-field">
+                  <span>Frame</span>
+                  <input
+                    type="number"
+                    step="1"
+                    value={selection.Frame}
+                    onChange={(event) =>
+                      facet.changeSelection(index, { Frame: Number(event.target.value) || 0 })
+                    }
+                  />
+                </label>
+                <button
+                  className="ghost"
+                  type="button"
+                  disabled={busy}
+                  onClick={() => void facet.generate("preview", [selection])}
+                >
+                  {busy ? "Previewing..." : "Preview"}
+                </button>
+              </div>
+            ))}
+          </div>
+        )}
+      </section>
+
+      {previewImages.length ? (
+        <section className="panel screens-gallery">
+          <div className="screens-gallery__header">
+            <h2>Preview Captures</h2>
+            <p className="muted">Click any image to view full size.</p>
+            <button
+              className="ghost"
+              type="button"
+              disabled={busy}
+              onClick={() => confirmDeleteAll("preview", previewImages)}
+            >
+              Delete all
+            </button>
+          </div>
+          <div className="screens-grid">
+            {previewImages.map((image) => (
+              <button
+                className="screens-thumb"
+                type="button"
+                key={`preview-${image.Path}`}
+                onClick={() => openLocalImage(image, `Preview ${image.Index + 1}`)}
+              >
+                {renderLocalThumbnail(image, `Preview ${image.Index + 1}`)}
+              </button>
+            ))}
+          </div>
+        </section>
+      ) : null}
+
+      {finalImages.length ? (
+        <section className="panel screens-gallery">
+          <div className="screens-gallery__header">
+            <h2>Final Captures</h2>
+            <p className="muted">Generated screenshots ready for upload.</p>
+            <button
+              className="ghost"
+              type="button"
+              disabled={busy}
+              onClick={() => confirmDeleteAll("final", finalImages)}
+            >
+              Delete all
+            </button>
+          </div>
+          <div className="screens-grid">
+            {finalImages.map((image, index) => (
+              <div className="screens-thumb-card" key={`final-${image.Path}`}>
+                <button
+                  className="screens-thumb"
+                  type="button"
+                  draggable
+                  onDragStart={() => setFinalDragIndex(index)}
+                  onDragOver={(event) => event.preventDefault()}
+                  onDrop={(event) => {
+                    event.preventDefault();
+                    if (finalDragIndex !== null) void facet.reorderFinal(finalDragIndex, index);
+                    setFinalDragIndex(null);
+                  }}
+                  onDragEnd={() => setFinalDragIndex(null)}
+                  onClick={() => openLocalImage(image, `Screenshot ${index + 1}`)}
+                >
+                  {renderLocalThumbnail(image, `Screenshot ${index + 1}`)}
+                </button>
+                <button
+                  className="screens-thumb-delete"
+                  type="button"
+                  disabled={busy}
+                  onClick={() => void facet.remove(image.Path)}
+                >
+                  Delete
+                </button>
+              </div>
+            ))}
+          </div>
+        </section>
+      ) : null}
+
+      {view.result?.Errors?.length ? (
+        <section className="panel screens-errors">
+          <div className="screens-gallery__header">
+            <h2>Capture Warnings</h2>
+          </div>
+          <ul>
+            {view.result.Errors.map((entry, index) => (
+              <li key={`err-${entry.Index}-${index}`}>
+                Shot {entry.Index + 1}: {entry.Message}
+              </li>
+            ))}
+          </ul>
+        </section>
+      ) : null}
+    </section>
+  );
+}
diff --git a/webui/src/pages/settings/index.test.tsx b/webui/src/pages/settings/index.test.tsx
new file mode 100644
index 00000000..4d6f7352
--- /dev/null
+++ b/webui/src/pages/settings/index.test.tsx
@@ -0,0 +1,1195 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { screen, within } from "@testing-library/dom";
+import { cleanup, render, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { installAppOperationMocks } from "../../test/appRequestMock";
+
+import SettingsPage from ".";
+import { trackerAuthClient } from "../../api/app";
+import type { ConfigValue } from "../../types";
+
+const baseProps = {
+  configData: { MainSettings: { Instance: "default" }, Trackers: {} },
+  settingsLoading: false,
+  settingsExporting: false,
+  settingsImporting: false,
+  settingsDirty: false,
+  settingsSaved: "",
+  settingsError: "",
+  trackerSelectionNames: [
+    "AR",
+    "BTN",
+    "COOKIE",
+    "FAST",
+    "FF",
+    "FL",
+    "HDB",
+    "MTV",
+    "PTP",
+    "RTF",
+    "THR",
+    "SLOW",
+    "ASC",
+    "PLAINAPI",
+    "PLAINPASS",
+  ],
+  configOpStatus: null,
+  dismissConfigOpStatus: vi.fn(),
+  settingsSection: "main_settings",
+  settingsSections: [
+    { key: "main_settings", jsonKey: "MainSettings", label: "Main" },
+    { key: "trackers", jsonKey: "Trackers", label: "Trackers" },
+  ],
+  showAdvancedToggle: false,
+  advancedOpen: false,
+  setSettingsAdvanced: vi.fn(),
+  loadSettings: vi.fn(),
+  handleExportSettings: vi.fn(),
+  handleImportConfig: vi.fn(),
+  importConfirmOpen: false,
+  handleImportConfigConfirm: vi.fn(),
+  handleImportConfigCancel: vi.fn(),
+  handleSaveSettings: vi.fn(),
+  renderImageHostingSection: vi.fn(() => null),
+  renderTrackerSection: vi.fn(() => null),
+  renderTorrentClientsSection: vi.fn(() => null),
+  renderField: vi.fn((label: string, _value: ConfigValue, path: string[]) => (
+    <div key={path.join(".")}>{label}</div>
+  )),
+  sectionFieldMeta: {},
+};
+
+const trackerAuthCapability = {
+  trackerID: "MTV",
+  displayName: "MTV",
+  authKind: "api_key_cookies_login",
+  supportsCookieFile: true,
+  supportsLogin: true,
+  supportsAutoLogin: true,
+  supportsTOTP: true,
+  supportsManual2FA: true,
+  supportsRemoteValidation: true,
+  requiresAPIKey: true,
+  requiresPasskey: false,
+};
+
+const trackerAuthStatus = (message: string) => ({
+  trackerID: "MTV",
+  displayName: "MTV",
+  state: "configured",
+  cookieCount: 1,
+  lastCheckedAt: "",
+  lastError: "",
+  encryptedStorage: true,
+  needs2FA: false,
+  challengeID: "",
+  message,
+});
+
+const deferred = <T,>() => {
+  let resolve: (value: T) => void = () => undefined;
+  let reject: (reason?: unknown) => void = () => undefined;
+  const promise = new Promise<T>((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+  return { promise, resolve, reject };
+};
+
+describe("SettingsPage", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  it("renders application details as the final tab", async () => {
+    const setSettingsSection = vi.fn();
+    const { container, rerender } = render(
+      <SettingsPage {...baseProps} setSettingsSection={setSettingsSection} />,
+    );
+    const settingsTags = container.querySelector(".settings-tags");
+
+    expect(settingsTags).not.toBeNull();
+    expect(
+      within(settingsTags as HTMLElement)
+        .getAllByRole("button")
+        .map((button) => button.textContent),
+    ).toEqual(["Main", "Trackers", "Application Details", "Tracker Auth"]);
+    expect(screen.queryByText("autobrr/upbrr")).not.toBeInTheDocument();
+
+    await userEvent.click(screen.getByRole("button", { name: "Application Details" }));
+
+    expect(setSettingsSection).toHaveBeenCalledWith("application_details");
+
+    rerender(
+      <SettingsPage
+        {...baseProps}
+        settingsSection="application_details"
+        setSettingsSection={setSettingsSection}
+      />,
+    );
+
+    expect(screen.getByText("autobrr/upbrr")).toBeInTheDocument();
+    expect(screen.queryByText("Copyright")).not.toBeInTheDocument();
+    expect(screen.queryByText("Copyright (c) 2026 autobrr")).not.toBeInTheDocument();
+  });
+
+  it("shows path-free DVD engine and FFmpeg capability diagnostics", async () => {
+    installAppOperationMocks({
+      GetApplicationInfo: vi.fn().mockResolvedValue({
+        version: "dev",
+        buildIdentifier: "example-build",
+        goVersion: "go1.26.4",
+        goos: "windows",
+        goarch: "amd64",
+        uptime: "1s",
+        uptimeSeconds: 1,
+        dvdMenuEngine: {
+          EngineVersion: "phase0a-1",
+          SchemaVersion: 1,
+          SupportedFeatures: ["ifo_inventory"],
+          FFmpegVersion: "ffmpeg version example",
+          FFmpegDVDVideo: true,
+          MissingFFmpegOptions: [],
+        },
+        dvdMenuCapabilityStatus: "available",
+        dvdMenuCapabilityMessage: "Compatible FFmpeg dvdvideo menu support detected.",
+      }),
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsSection="application_details"
+        setSettingsSection={vi.fn()}
+      />,
+    );
+
+    await waitFor(() => expect(screen.getByText("phase0a-1")).toBeInTheDocument());
+    expect(screen.getByText("Available")).toBeInTheDocument();
+    expect(screen.getByText("ffmpeg version example")).toBeInTheDocument();
+    expect(
+      screen.getByText("Compatible FFmpeg dvdvideo menu support detected."),
+    ).toBeInTheDocument();
+  });
+
+  it("renders tracker auth as the bottom tab", async () => {
+    const setSettingsSection = vi.fn();
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([]),
+      GetTrackerAuthStatus: vi.fn(),
+    });
+
+    render(<SettingsPage {...baseProps} setSettingsSection={setSettingsSection} />);
+
+    await userEvent.click(screen.getByRole("button", { name: "Tracker Auth" }));
+
+    expect(setSettingsSection).toHaveBeenCalledWith("tracker_auth");
+  });
+
+  it("reports encrypted cookie storage ready only when every tracker is ready", async () => {
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("MTV ready")),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const badge = await screen.findByText("Encrypted cookie storage ready");
+    expect(badge).toHaveClass("is-ready");
+  });
+
+  it("reports mixed encrypted cookie storage without global ready copy", async () => {
+    const unavailableCapability = {
+      ...trackerAuthCapability,
+      trackerID: "SLOW",
+      displayName: "SLOW",
+    };
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi
+        .fn()
+        .mockResolvedValue([trackerAuthCapability, unavailableCapability]),
+      GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) =>
+        Promise.resolve({
+          ...trackerAuthStatus(`${trackerID} status`),
+          trackerID,
+          displayName: trackerID,
+          encryptedStorage: trackerID === "MTV",
+        }),
+      ),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const badge = await screen.findByText("Encrypted cookie storage partially ready");
+    expect(badge).toHaveClass("is-warning");
+    expect(screen.queryByText("Encrypted cookie storage ready")).not.toBeInTheDocument();
+  });
+
+  it("shows Check Auth only for remote-validation tracker auth", async () => {
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
+        {
+          trackerID: "MTV",
+          displayName: "MTV",
+          authKind: "api_key_cookies_login",
+          supportsCookieFile: true,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: true,
+          supportsManual2FA: true,
+          supportsRemoteValidation: true,
+          requiresAPIKey: true,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "BTN",
+          displayName: "BTN",
+          authKind: "api_key_cookies_login_manual_2fa",
+          supportsCookieFile: true,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: true,
+          supportsManual2FA: true,
+          supportsRemoteValidation: true,
+          requiresAPIKey: true,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "AR",
+          displayName: "AR",
+          authKind: "cookies_login",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "HDB",
+          displayName: "HDB",
+          authKind: "passkey_cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: false,
+          requiresPasskey: true,
+        },
+        {
+          trackerID: "FF",
+          displayName: "FF",
+          authKind: "cookies_login",
+          supportsCookieFile: true,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "FL",
+          displayName: "FL",
+          authKind: "cookies_login",
+          supportsCookieFile: true,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "RTF",
+          displayName: "RTF",
+          authKind: "api_key_credential_refresh",
+          supportsCookieFile: false,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: true,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "THR",
+          displayName: "THR",
+          authKind: "credential_login",
+          supportsCookieFile: false,
+          supportsLogin: true,
+          supportsAutoLogin: true,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: true,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "ASC",
+          displayName: "ASC",
+          authKind: "cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          supportsRemoteValidation: false,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+      ]),
+      GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) =>
+        Promise.resolve({
+          trackerID,
+          displayName: trackerID,
+          state: "configured",
+          cookieCount: 0,
+          lastCheckedAt: "",
+          lastError: "",
+          encryptedStorage: true,
+          needs2FA: false,
+          challengeID: "",
+          message: "required config auth material is present",
+        }),
+      ),
+      TestTrackerAuth: vi.fn(),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const mtvTitle = await screen.findByText("MTV");
+    const btnTitle = await screen.findByText("BTN");
+    const arTitle = await screen.findByText("AR");
+    const hdbTitle = await screen.findByText("HDB");
+    const ffTitle = await screen.findByText("FF");
+    const flTitle = await screen.findByText("FL");
+    const rtfTitle = await screen.findByText("RTF");
+    const thrTitle = await screen.findByText("THR");
+    const ascTitle = await screen.findByText("ASC");
+    const mtvCard = mtvTitle.closest(".tracker-auth-card");
+    const btnCard = btnTitle.closest(".tracker-auth-card");
+    const arCard = arTitle.closest(".tracker-auth-card");
+    const hdbCard = hdbTitle.closest(".tracker-auth-card");
+    const ffCard = ffTitle.closest(".tracker-auth-card");
+    const flCard = flTitle.closest(".tracker-auth-card");
+    const rtfCard = rtfTitle.closest(".tracker-auth-card");
+    const thrCard = thrTitle.closest(".tracker-auth-card");
+    const ascCard = ascTitle.closest(".tracker-auth-card");
+
+    expect(mtvCard).not.toBeNull();
+    expect(btnCard).not.toBeNull();
+    expect(arCard).not.toBeNull();
+    expect(hdbCard).not.toBeNull();
+    expect(ffCard).not.toBeNull();
+    expect(flCard).not.toBeNull();
+    expect(rtfCard).not.toBeNull();
+    expect(thrCard).not.toBeNull();
+    expect(ascCard).not.toBeNull();
+    expect(
+      within(mtvCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(btnCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(arCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(hdbCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(ffCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(flCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(rtfCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(thrCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    ).toBeInTheDocument();
+    expect(
+      within(ascCard as HTMLElement).queryByRole("button", { name: "Check Auth" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("renders tracker auth failure summary with distinct remote detail", async () => {
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue({
+        ...trackerAuthStatus("stored session expired or invalid"),
+        state: "login_required",
+        lastError: "remote auth test failed status=401",
+      }),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const title = await screen.findByText("MTV");
+    const card = title.closest(".tracker-auth-card");
+    expect(card).not.toBeNull();
+    expect(
+      within(card as HTMLElement).getByText("stored session expired or invalid"),
+    ).toBeInTheDocument();
+    expect(
+      within(card as HTMLElement).getByText("remote auth test failed status=401"),
+    ).toBeInTheDocument();
+  });
+
+  it("does not render duplicate tracker auth failure detail", async () => {
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue({
+        ...trackerAuthStatus("stored session expired or invalid"),
+        state: "login_required",
+        lastError: "stored session expired or invalid",
+      }),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const title = await screen.findByText("MTV");
+    const card = title.closest(".tracker-auth-card");
+    expect(card).not.toBeNull();
+    expect(
+      within(card as HTMLElement).getAllByText("stored session expired or invalid"),
+    ).toHaveLength(1);
+  });
+
+  it("renders fast tracker auth statuses before slow statuses resolve", async () => {
+    let resolveSlow: (value: unknown) => void = () => undefined;
+    const slowStatus = new Promise((resolve) => {
+      resolveSlow = resolve;
+    });
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
+        {
+          trackerID: "FAST",
+          displayName: "FAST",
+          authKind: "cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "SLOW",
+          displayName: "SLOW",
+          authKind: "cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+      ]),
+      GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) => {
+        if (trackerID === "SLOW") {
+          return slowStatus;
+        }
+        return Promise.resolve({
+          trackerID,
+          displayName: trackerID,
+          state: "configured",
+          cookieCount: 0,
+          lastCheckedAt: "",
+          lastError: "",
+          encryptedStorage: true,
+          needs2FA: false,
+          challengeID: "",
+          message: "fast ready",
+        });
+      }),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("fast ready")).toBeInTheDocument();
+    expect(screen.queryByText("slow ready")).not.toBeInTheDocument();
+
+    resolveSlow({
+      trackerID: "SLOW",
+      displayName: "SLOW",
+      state: "configured",
+      cookieCount: 0,
+      lastCheckedAt: "",
+      lastError: "",
+      encryptedStorage: true,
+      needs2FA: false,
+      challengeID: "",
+      message: "slow ready",
+    });
+
+    expect(await screen.findByText("slow ready")).toBeInTheDocument();
+  });
+
+  it("hides plain tracker auth capabilities before loading statuses", async () => {
+    const getStatus = vi.fn().mockImplementation((trackerID: string) =>
+      Promise.resolve({
+        trackerID,
+        displayName: trackerID,
+        state: "configured",
+        cookieCount: 0,
+        lastCheckedAt: "",
+        lastError: "",
+        encryptedStorage: true,
+        needs2FA: false,
+        challengeID: "",
+        message: `${trackerID} ready`,
+      }),
+    );
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
+        {
+          trackerID: "PLAINAPI",
+          displayName: "PLAINAPI",
+          authKind: "api_key",
+          supportsCookieFile: false,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: true,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "PLAINPASS",
+          displayName: "PLAINPASS",
+          authKind: "passkey",
+          supportsCookieFile: false,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: false,
+          requiresPasskey: true,
+        },
+        {
+          trackerID: "COOKIE",
+          displayName: "COOKIE",
+          authKind: "cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        {
+          trackerID: "RTF",
+          displayName: "RTF",
+          authKind: "api_key_credential_refresh",
+          supportsCookieFile: false,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: true,
+          requiresPasskey: false,
+        },
+      ]),
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("COOKIE ready")).toBeInTheDocument();
+    expect(await screen.findByText("RTF ready")).toBeInTheDocument();
+    expect(screen.queryByText("PLAINAPI")).not.toBeInTheDocument();
+    expect(screen.queryByText("PLAINPASS")).not.toBeInTheDocument();
+    expect(getStatus).toHaveBeenCalledTimes(2);
+    expect(getStatus).toHaveBeenCalledWith("COOKIE");
+    expect(getStatus).toHaveBeenCalledWith("RTF");
+  });
+
+  it("hides managed tracker auth capabilities for trackers not configured in main trackers", async () => {
+    const getStatus = vi.fn().mockImplementation((trackerID: string) =>
+      Promise.resolve({
+        trackerID,
+        displayName: trackerID,
+        state: "configured",
+        cookieCount: 0,
+        lastCheckedAt: "",
+        lastError: "",
+        encryptedStorage: true,
+        needs2FA: false,
+        challengeID: "",
+        message: `${trackerID} ready`,
+      }),
+    );
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([
+        {
+          trackerID: "ASC",
+          displayName: "ASC",
+          authKind: "cookies",
+          supportsCookieFile: true,
+          supportsLogin: false,
+          supportsAutoLogin: false,
+          supportsTOTP: false,
+          supportsManual2FA: false,
+          requiresAPIKey: false,
+          requiresPasskey: false,
+        },
+        trackerAuthCapability,
+      ]),
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsSection="tracker_auth"
+        trackerSelectionNames={["MTV"]}
+        setSettingsSection={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText("MTV ready")).toBeInTheDocument();
+    expect(screen.queryByText("ASC")).not.toBeInTheDocument();
+    expect(getStatus).toHaveBeenCalledTimes(1);
+    expect(getStatus).toHaveBeenCalledWith("MTV");
+  });
+
+  it.each([
+    ["Import Cookies", "importCookies"],
+    ["Check Auth", "test"],
+    ["Delete Auth", "remove"],
+  ])(
+    "keeps newer %s status when initial status resolves late",
+    async (buttonName, clientMethod) => {
+      const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
+      const action = vi
+        .spyOn(trackerAuthClient, clientMethod as "importCookies" | "test" | "remove")
+        .mockResolvedValue(trackerAuthStatus("action ready"));
+      installAppOperationMocks({
+        ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+        GetTrackerAuthStatus: vi.fn().mockReturnValue(initialStatus.promise),
+      });
+
+      render(
+        <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+      );
+
+      expect(await screen.findByText("MTV")).toBeInTheDocument();
+      await userEvent.click(screen.getByRole("button", { name: buttonName }));
+
+      expect(action).toHaveBeenCalledWith("MTV");
+      expect(await screen.findByText("action ready")).toBeInTheDocument();
+
+      initialStatus.resolve(trackerAuthStatus("initial stale"));
+
+      await waitFor(() => {
+        expect(screen.getByText("action ready")).toBeInTheDocument();
+        expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
+      });
+    },
+  );
+
+  it("stores the post-validation tracker auth status returned by Check Auth", async () => {
+    const testStatus = {
+      ...trackerAuthStatus("fresh validation ready"),
+      cookieCount: 3,
+      lastCheckedAt: "2026-07-08T00:00:00Z",
+      lastError: "",
+      encryptedStorage: true,
+    };
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue({
+        ...trackerAuthStatus("stale before validation"),
+        cookieCount: 1,
+      }),
+      TestTrackerAuth: vi.fn().mockResolvedValue(testStatus),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("stale before validation")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
+
+    await waitFor(() => {
+      expect(screen.getByText("fresh validation ready")).toBeInTheDocument();
+      expect(screen.getByText("Cookies: 3")).toBeInTheDocument();
+      expect(
+        screen.getByText((_content, element) =>
+          Boolean(
+            element?.textContent?.startsWith("Checked: ") &&
+            element.textContent !== "Checked: Never",
+          ),
+        ),
+      ).toBeInTheDocument();
+      expect(screen.queryByText("stale before validation")).not.toBeInTheDocument();
+    });
+  });
+
+  it("clears tracker auth cards when refresh fails after an action", async () => {
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce([trackerAuthCapability])
+      .mockRejectedValueOnce(new Error("refresh failed"));
+    vi.spyOn(trackerAuthClient, "importCookies").mockResolvedValue(
+      trackerAuthStatus("action ready"),
+    );
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("initial ready")),
+    });
+
+    const { rerender } = render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Import Cookies" }));
+    expect(await screen.findByText("action ready")).toBeInTheDocument();
+
+    rerender(
+      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
+    );
+    rerender(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("Error: refresh failed")).toBeInTheDocument();
+    expect(screen.queryByText("MTV")).not.toBeInTheDocument();
+    expect(screen.queryByText("action ready")).not.toBeInTheDocument();
+  });
+
+  it("keeps stale tracker auth status failures from overwriting newer action state", async () => {
+    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
+    vi.spyOn(trackerAuthClient, "importCookies").mockResolvedValue(
+      trackerAuthStatus("action ready"),
+    );
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockReturnValue(initialStatus.promise),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("MTV")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Import Cookies" }));
+    expect(await screen.findByText("action ready")).toBeInTheDocument();
+
+    initialStatus.reject(new Error("stale failure"));
+
+    await waitFor(() => {
+      expect(screen.getByText("action ready")).toBeInTheDocument();
+      expect(screen.queryByText("Error: stale failure")).not.toBeInTheDocument();
+    });
+  });
+
+  it("reports tracker auth action failures only on the originating tracker", async () => {
+    const staleAction = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const newerCapability = { ...trackerAuthCapability, trackerID: "PTP", displayName: "PTP" };
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi
+        .fn()
+        .mockResolvedValue([trackerAuthCapability, newerCapability]),
+      GetTrackerAuthStatus: vi.fn().mockImplementation((trackerID: string) =>
+        Promise.resolve({
+          ...trackerAuthStatus(`${trackerID} initial ready`),
+          trackerID,
+          displayName: trackerID,
+        }),
+      ),
+      TestTrackerAuth: vi.fn().mockImplementation((trackerID: string) => {
+        if (trackerID === "MTV") {
+          return staleAction.promise;
+        }
+        return Promise.resolve({
+          ...trackerAuthStatus("new action ready"),
+          trackerID,
+          displayName: trackerID,
+        });
+      }),
+    });
+
+    render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    const mtvTitle = await screen.findByText("MTV");
+    const ptpTitle = await screen.findByText("PTP");
+    const mtvCard = mtvTitle.closest(".tracker-auth-card");
+    const ptpCard = ptpTitle.closest(".tracker-auth-card");
+
+    expect(mtvCard).not.toBeNull();
+    expect(ptpCard).not.toBeNull();
+    await userEvent.click(
+      within(mtvCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    );
+    await userEvent.click(
+      within(ptpCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    );
+    expect(await screen.findByText("new action ready")).toBeInTheDocument();
+
+    staleAction.reject(new Error("stale failure"));
+
+    await waitFor(() => {
+      expect(within(ptpCard as HTMLElement).getByText("new action ready")).toBeInTheDocument();
+      expect(within(mtvCard as HTMLElement).getByText("Error: stale failure")).toBeInTheDocument();
+      expect(
+        within(ptpCard as HTMLElement).queryByText("Error: stale failure"),
+      ).not.toBeInTheDocument();
+    });
+
+    await userEvent.click(
+      within(ptpCard as HTMLElement).getByRole("button", { name: "Check Auth" }),
+    );
+
+    await waitFor(() => {
+      expect(within(mtvCard as HTMLElement).getByText("Error: stale failure")).toBeInTheDocument();
+      expect(
+        within(ptpCard as HTMLElement).queryByText("Error: stale failure"),
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  it("ignores tracker auth action failures after leaving the tracker auth section", async () => {
+    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("initial ready")),
+      TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
+    });
+
+    const { rerender } = render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
+
+    rerender(
+      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
+    );
+    action.reject(new Error("late failure"));
+
+    await waitFor(() => {
+      expect(screen.queryByText("Error: late failure")).not.toBeInTheDocument();
+    });
+  });
+
+  it("clears tracker auth loading after leaving and reentering with old status pending", async () => {
+    const oldStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const getStatus = vi
+      .fn()
+      .mockReturnValueOnce(oldStatus.promise)
+      .mockResolvedValueOnce(trackerAuthStatus("after reenter"));
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: vi.fn().mockResolvedValue([trackerAuthCapability]),
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    const { rerender } = render(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("MTV")).toBeInTheDocument();
+    expect(screen.getByText("Loading tracker auth...")).toBeInTheDocument();
+
+    rerender(
+      <SettingsPage {...baseProps} settingsSection="main_settings" setSettingsSection={vi.fn()} />,
+    );
+    rerender(
+      <SettingsPage {...baseProps} settingsSection="tracker_auth" setSettingsSection={vi.fn()} />,
+    );
+
+    expect(await screen.findByText("after reenter")).toBeInTheDocument();
+    oldStatus.resolve(trackerAuthStatus("old ready"));
+
+    await waitFor(() => {
+      expect(screen.queryByText("Loading tracker auth...")).not.toBeInTheDocument();
+      expect(screen.getByText("after reenter")).toBeInTheDocument();
+      expect(screen.queryByText("old ready")).not.toBeInTheDocument();
+    });
+  });
+
+  it("refreshes tracker auth after saving settings while tracker auth is selected", async () => {
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
+      .mockResolvedValueOnce(trackerAuthStatus("after save"));
+    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsDirty
+        settingsSection="tracker_auth"
+        setSettingsSection={vi.fn()}
+        handleSaveSettings={handleSaveSettings}
+      />,
+    );
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(handleSaveSettings).toHaveBeenCalledTimes(1);
+      expect(list).toHaveBeenCalledTimes(2);
+      expect(getStatus).toHaveBeenCalledTimes(2);
+      expect(screen.getByText("after save")).toBeInTheDocument();
+    });
+  });
+
+  it("keeps pending old tracker auth status from overwriting save reload status", async () => {
+    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockReturnValueOnce(initialStatus.promise)
+      .mockResolvedValueOnce(trackerAuthStatus("after save"));
+    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsDirty
+        settingsSection="tracker_auth"
+        setSettingsSection={vi.fn()}
+        handleSaveSettings={handleSaveSettings}
+      />,
+    );
+
+    expect(await screen.findByText("MTV")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Save" }));
+    expect(await screen.findByText("after save")).toBeInTheDocument();
+
+    initialStatus.resolve(trackerAuthStatus("initial stale"));
+
+    await waitFor(() => {
+      expect(screen.getByText("after save")).toBeInTheDocument();
+      expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
+      expect(list).toHaveBeenCalledTimes(2);
+      expect(getStatus).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  it("clears pending tracker auth action busy state after save reload", async () => {
+    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
+      .mockResolvedValueOnce(trackerAuthStatus("after save"));
+    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+      TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsDirty
+        settingsSection="tracker_auth"
+        setSettingsSection={vi.fn()}
+        handleSaveSettings={handleSaveSettings}
+      />,
+    );
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
+    expect(screen.getByRole("button", { name: "Checking..." })).toBeDisabled();
+
+    await userEvent.click(screen.getByRole("button", { name: "Save" }));
+    expect(await screen.findByText("after save")).toBeInTheDocument();
+
+    action.resolve(trackerAuthStatus("action stale"));
+
+    await waitFor(() => {
+      expect(screen.getByText("after save")).toBeInTheDocument();
+      expect(screen.queryByText("action stale")).not.toBeInTheDocument();
+      expect(screen.getByRole("button", { name: "Check Auth" })).toBeEnabled();
+    });
+  });
+
+  it("refreshes tracker auth after confirming config import while tracker auth is selected", async () => {
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
+      .mockResolvedValueOnce(trackerAuthStatus("after import"));
+    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsSection="tracker_auth"
+        setSettingsSection={vi.fn()}
+        importConfirmOpen
+        handleImportConfigConfirm={handleImportConfigConfirm}
+      />,
+    );
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
+
+    await waitFor(() => {
+      expect(handleImportConfigConfirm).toHaveBeenCalledTimes(1);
+      expect(list).toHaveBeenCalledTimes(2);
+      expect(getStatus).toHaveBeenCalledTimes(2);
+      expect(screen.getByText("after import")).toBeInTheDocument();
+    });
+  });
+
+  it("keeps pending old tracker auth status from overwriting import reload status", async () => {
+    const initialStatus = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockReturnValueOnce(initialStatus.promise)
+      .mockResolvedValueOnce(trackerAuthStatus("after import"));
+    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsSection="tracker_auth"
+        setSettingsSection={vi.fn()}
+        importConfirmOpen
+        handleImportConfigConfirm={handleImportConfigConfirm}
+      />,
+    );
+
+    expect(await screen.findByText("MTV")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
+    expect(await screen.findByText("after import")).toBeInTheDocument();
+
+    initialStatus.resolve(trackerAuthStatus("initial stale"));
+
+    await waitFor(() => {
+      expect(screen.getByText("after import")).toBeInTheDocument();
+      expect(screen.queryByText("initial stale")).not.toBeInTheDocument();
+      expect(list).toHaveBeenCalledTimes(2);
+      expect(getStatus).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  it("clears pending tracker auth action busy state after import reload", async () => {
+    const action = deferred<ReturnType<typeof trackerAuthStatus>>();
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const getStatus = vi
+      .fn()
+      .mockResolvedValueOnce(trackerAuthStatus("initial ready"))
+      .mockResolvedValueOnce(trackerAuthStatus("after import"));
+    const handleImportConfigConfirm = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: getStatus,
+      TestTrackerAuth: vi.fn().mockReturnValue(action.promise),
+    });
+
+    const props = {
+      ...baseProps,
+      settingsSection: "tracker_auth",
+      setSettingsSection: vi.fn(),
+      handleImportConfigConfirm,
+    };
+    const { rerender } = render(<SettingsPage {...props} />);
+
+    expect(await screen.findByText("initial ready")).toBeInTheDocument();
+    await userEvent.click(screen.getByRole("button", { name: "Check Auth" }));
+    expect(screen.getByRole("button", { name: "Checking..." })).toBeDisabled();
+
+    rerender(<SettingsPage {...props} importConfirmOpen />);
+
+    await userEvent.click(screen.getByRole("button", { name: "Choose file & import" }));
+    expect(await screen.findByText("after import")).toBeInTheDocument();
+
+    rerender(<SettingsPage {...props} />);
+
+    action.resolve(trackerAuthStatus("action stale"));
+
+    await waitFor(() => {
+      expect(screen.getByText("after import")).toBeInTheDocument();
+      expect(screen.queryByText("action stale")).not.toBeInTheDocument();
+      expect(screen.getByRole("button", { name: "Check Auth", hidden: true })).toBeEnabled();
+    });
+  });
+
+  it("keeps config save refresh lazy outside tracker auth", async () => {
+    const list = vi.fn().mockResolvedValue([trackerAuthCapability]);
+    const handleSaveSettings = vi.fn().mockResolvedValue(undefined);
+    installAppOperationMocks({
+      ListTrackerAuthCapabilities: list,
+      GetTrackerAuthStatus: vi.fn().mockResolvedValue(trackerAuthStatus("ready")),
+    });
+
+    render(
+      <SettingsPage
+        {...baseProps}
+        settingsDirty
+        settingsSection="main_settings"
+        setSettingsSection={vi.fn()}
+        handleSaveSettings={handleSaveSettings}
+      />,
+    );
+
+    await userEvent.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(handleSaveSettings).toHaveBeenCalledTimes(1);
+    });
+    expect(list).not.toHaveBeenCalled();
+  });
+});
diff --git a/webui/src/pages/settings/index.tsx b/webui/src/pages/settings/index.tsx
new file mode 100644
index 00000000..a961c146
--- /dev/null
+++ b/webui/src/pages/settings/index.tsx
@@ -0,0 +1,1045 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import * as AlertDialog from "@radix-ui/react-alert-dialog";
+import { Button } from "../../components/ui/button";
+import { Switch } from "../../components/ui/switch";
+import { applicationClient, trackerAuthClient } from "../../api/app";
+import { cn } from "../../utils/cn";
+import { handleExternalLinkClick } from "../../utils/externalLinks";
+import type {
+  ApplicationInfo,
+  ConfigMap,
+  ConfigValue,
+  FieldMeta,
+  TrackerAuthCapability,
+  TrackerAuthStatus,
+} from "../../types";
+
+type SettingsSection = { key: string; jsonKey: string; label: string };
+
+const applicationDetailsSection = {
+  key: "application_details",
+  label: "Application Details",
+};
+
+const trackerAuthSection = {
+  key: "tracker_auth",
+  label: "Tracker Auth",
+};
+
+const settingsInputClass =
+  "h-8 rounded-md border border-white/10 bg-slate-950/45 px-2.5 text-sm text-[var(--text)] outline-none transition placeholder:text-[var(--muted)] focus:border-[var(--accent-2)] focus:ring-2 focus:ring-[rgba(53,194,193,0.18)]";
+// Tracker-supplied auth kinds can be long adapter descriptors; keep chips
+// wrapped inside the auth card on narrow screens.
+const trackerAuthChipClass =
+  "max-w-full whitespace-normal rounded-full border border-slate-400/20 bg-slate-950/35 px-[0.45rem] py-[0.2rem] text-[0.74rem] leading-none text-[var(--muted)] [overflow-wrap:anywhere]";
+const trackerAuthMetaClass = "m-0 text-[0.8rem] text-[var(--muted)]";
+
+/** Builds the case-insensitive key shared by main tracker config and tracker auth rows. */
+const trackerNameKey = (name: string) => name.trim().toLowerCase();
+
+/**
+ * Returns true for tracker auth capabilities that perform stored-cookie,
+ * relogin, refresh, or 2FA handling beyond static API-key/passkey config.
+ */
+const isManagedTrackerAuthCapability = (capability: TrackerAuthCapability) => {
+  const authKind = capability.authKind.toLowerCase();
+  return (
+    capability.supportsCookieFile ||
+    capability.supportsLogin ||
+    capability.supportsAutoLogin ||
+    capability.supportsTOTP ||
+    capability.supportsManual2FA ||
+    authKind.includes("refresh") ||
+    authKind.includes("2fa")
+  );
+};
+
+/** Returns tracker auth summary/detail text using the shared API display contract. */
+const trackerAuthStatusDisplay = (status?: TrackerAuthStatus) => {
+  const message = status?.message.trim() ?? "";
+  const lastError = status?.lastError.trim() ?? "";
+  return {
+    message,
+    lastError: lastError && lastError !== message ? lastError : "",
+  };
+};
+
+type ConfigOpStatus = {
+  type: "success" | "error" | "warning";
+  title: string;
+  message: string;
+  warnings?: string[];
+} | null;
+
+type Props = {
+  configData: ConfigMap | null;
+  settingsLoading: boolean;
+  settingsExporting: boolean;
+  settingsImporting: boolean;
+  settingsDirty: boolean;
+  settingsSaved: string;
+  settingsError: string;
+  configOpStatus: ConfigOpStatus;
+  dismissConfigOpStatus: () => void;
+  settingsSection: string;
+  settingsSections: SettingsSection[];
+  /** Tracker names already enabled by the main tracker settings panel. */
+  trackerSelectionNames: string[];
+  showAdvancedToggle: boolean;
+  advancedOpen: boolean;
+  setSettingsSection: Dispatch<SetStateAction<string>>;
+  setSettingsAdvanced: Dispatch<SetStateAction<Record<string, boolean>>>;
+  loadSettings: () => void;
+  handleExportSettings: () => void;
+  handleImportConfig: () => void;
+  importConfirmOpen: boolean;
+  handleImportConfigConfirm: () => void | Promise<void>;
+  handleImportConfigCancel: () => void;
+  handleSaveSettings: () => void | Promise<void>;
+  renderImageHostingSection: () => JSX.Element | null;
+  renderTrackerSection: (advancedOpen: boolean) => JSX.Element | null;
+  renderTorrentClientsSection: (advancedOpen: boolean) => JSX.Element | null;
+  renderField: (label: string, value: ConfigValue, path: string[], meta?: FieldMeta) => JSX.Element;
+  sectionFieldMeta: Record<string, Record<string, FieldMeta>>;
+};
+
+/**
+ * Renders settings plus tracker auth controls with generation-gated async state
+ * so config saves/imports, section changes, and per-tracker actions ignore
+ * stale tracker auth responses.
+ */
+export default function SettingsPage(props: Props) {
+  const {
+    configData,
+    settingsLoading,
+    settingsExporting,
+    settingsImporting,
+    settingsDirty,
+    settingsSaved,
+    settingsError,
+    configOpStatus,
+    dismissConfigOpStatus,
+    settingsSection,
+    settingsSections,
+    trackerSelectionNames,
+    showAdvancedToggle,
+    advancedOpen,
+    setSettingsSection,
+    setSettingsAdvanced,
+    loadSettings,
+    handleExportSettings,
+    handleImportConfig,
+    importConfirmOpen,
+    handleImportConfigConfirm,
+    handleImportConfigCancel,
+    handleSaveSettings,
+    renderImageHostingSection,
+    renderTrackerSection,
+    renderTorrentClientsSection,
+    renderField,
+    sectionFieldMeta,
+  } = props;
+
+  const [warningsExpanded, setWarningsExpanded] = useState(false);
+  const [applicationInfo, setApplicationInfo] = useState<ApplicationInfo | null>(null);
+  const [applicationInfoError, setApplicationInfoError] = useState("");
+  const [applicationInfoLoading, setApplicationInfoLoading] = useState(false);
+  const [applicationInfoFetchedAt, setApplicationInfoFetchedAt] = useState<number | null>(null);
+  const [uptimeTick, setUptimeTick] = useState(() => Date.now());
+  const [trackerAuthCapabilities, setTrackerAuthCapabilities] = useState<TrackerAuthCapability[]>(
+    [],
+  );
+  const [trackerAuthStatuses, setTrackerAuthStatuses] = useState<Record<string, TrackerAuthStatus>>(
+    {},
+  );
+  const [trackerAuthLoading, setTrackerAuthLoading] = useState(false);
+  const [trackerAuthError, setTrackerAuthError] = useState("");
+  const [trackerAuthActionErrors, setTrackerAuthActionErrors] = useState<Record<string, string>>(
+    {},
+  );
+  const [trackerAuthFilter, setTrackerAuthFilter] = useState("");
+  const [trackerAuthActions, setTrackerAuthActions] = useState<Record<string, string>>({});
+  const [trackerAuthCodes, setTrackerAuthCodes] = useState<Record<string, string>>({});
+  const [trackerAuthReloadRevision, setTrackerAuthReloadRevision] = useState(0);
+  const trackerAuthStatusVersions = useRef<Record<string, number>>({});
+  const trackerAuthActionSequences = useRef<Record<string, number>>({});
+  const trackerAuthLoadGeneration = useRef(0);
+  const trackerAuthSectionActiveRef = useRef(settingsSection === trackerAuthSection.key);
+
+  const invalidateTrackerAuthStatusVersions = useCallback(() => {
+    Object.keys(trackerAuthStatusVersions.current).forEach((trackerID) => {
+      trackerAuthStatusVersions.current[trackerID] =
+        (trackerAuthStatusVersions.current[trackerID] ?? 0) + 1;
+    });
+  }, []);
+
+  useEffect(() => {
+    const active = settingsSection === trackerAuthSection.key;
+    trackerAuthSectionActiveRef.current = active;
+    if (!active) {
+      invalidateTrackerAuthStatusVersions();
+      trackerAuthLoadGeneration.current += 1;
+      setTrackerAuthLoading(false);
+      setTrackerAuthActions({});
+      setTrackerAuthActionErrors({});
+    }
+  }, [invalidateTrackerAuthStatusVersions, settingsSection]);
+
+  useEffect(() => {
+    let cancelled = false;
+    setApplicationInfoLoading(true);
+    setApplicationInfoError("");
+    void applicationClient
+      .getInfo()
+      .then((info) => {
+        if (cancelled) {
+          return;
+        }
+        setApplicationInfo(info);
+        setApplicationInfoFetchedAt(Date.now());
+      })
+      .catch((error) => {
+        if (cancelled) {
+          return;
+        }
+        setApplicationInfoError(String(error));
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setApplicationInfoLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!applicationInfo) {
+      return undefined;
+    }
+    const timer = window.setInterval(() => {
+      setUptimeTick(Date.now());
+    }, 1000);
+    return () => window.clearInterval(timer);
+  }, [applicationInfo]);
+
+  useEffect(() => {
+    if (settingsSection !== trackerAuthSection.key) {
+      return undefined;
+    }
+    let cancelled = false;
+    const loadGeneration = trackerAuthLoadGeneration.current + 1;
+    trackerAuthLoadGeneration.current = loadGeneration;
+    setTrackerAuthLoading(true);
+    setTrackerAuthError("");
+    setTrackerAuthActionErrors({});
+    void trackerAuthClient
+      .listCapabilities()
+      .then((capabilities) => {
+        if (cancelled) {
+          return;
+        }
+        const configuredTrackerNames = new Set(trackerSelectionNames.map(trackerNameKey));
+        const managedCapabilities = capabilities.filter(
+          (capability) =>
+            configuredTrackerNames.has(trackerNameKey(capability.trackerID)) &&
+            isManagedTrackerAuthCapability(capability),
+        );
+        setTrackerAuthCapabilities(managedCapabilities);
+        setTrackerAuthStatuses({});
+        if (managedCapabilities.length === 0) {
+          setTrackerAuthLoading(false);
+          return;
+        }
+        let pendingStatuses = managedCapabilities.length;
+        const markStatusComplete = () => {
+          pendingStatuses -= 1;
+          if (
+            pendingStatuses === 0 &&
+            !cancelled &&
+            trackerAuthLoadGeneration.current === loadGeneration
+          ) {
+            setTrackerAuthLoading(false);
+          }
+        };
+        managedCapabilities.forEach((capability) => {
+          const statusVersion = trackerAuthStatusVersions.current[capability.trackerID] ?? 0;
+          void trackerAuthClient
+            .getStatus(capability.trackerID)
+            .then((status) => {
+              if (
+                !cancelled &&
+                (trackerAuthStatusVersions.current[capability.trackerID] ?? 0) === statusVersion
+              ) {
+                setTrackerAuthStatuses((prev) => ({
+                  ...prev,
+                  [capability.trackerID]: status,
+                }));
+              }
+            })
+            .catch((error) => {
+              if (
+                !cancelled &&
+                (trackerAuthStatusVersions.current[capability.trackerID] ?? 0) === statusVersion
+              ) {
+                setTrackerAuthStatuses((prev) => ({
+                  ...prev,
+                  [capability.trackerID]: {
+                    trackerID: capability.trackerID,
+                    displayName: capability.displayName,
+                    state: "error",
+                    cookieCount: 0,
+                    lastCheckedAt: "",
+                    lastError: String(error),
+                    encryptedStorage: false,
+                    needs2FA: false,
+                    challengeID: "",
+                    message: "",
+                  },
+                }));
+              }
+            })
+            .finally(() => {
+              if (!cancelled) {
+                markStatusComplete();
+              }
+            });
+        });
+      })
+      .catch((error) => {
+        if (!cancelled) {
+          setTrackerAuthCapabilities([]);
+          setTrackerAuthStatuses({});
+          setTrackerAuthError(String(error));
+          setTrackerAuthLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [settingsSection, trackerAuthReloadRevision, trackerSelectionNames]);
+
+  const reloadTrackerAuthAfterConfigChange = useCallback(
+    async (handler: () => void | Promise<void>) => {
+      await handler();
+      invalidateTrackerAuthStatusVersions();
+      setTrackerAuthActions({});
+      setTrackerAuthActionErrors({});
+      setTrackerAuthReloadRevision((revision) => revision + 1);
+    },
+    [invalidateTrackerAuthStatusVersions],
+  );
+
+  const runTrackerAuthAction = async (
+    trackerID: string,
+    action: string,
+    fn: () => Promise<TrackerAuthStatus>,
+  ) => {
+    const actionVersion = (trackerAuthStatusVersions.current[trackerID] ?? 0) + 1;
+    trackerAuthStatusVersions.current[trackerID] = actionVersion;
+    const actionSequence = (trackerAuthActionSequences.current[trackerID] ?? 0) + 1;
+    trackerAuthActionSequences.current[trackerID] = actionSequence;
+    setTrackerAuthActions((prev) => ({ ...prev, [trackerID]: action }));
+    setTrackerAuthActionErrors((prev) => {
+      const next = { ...prev };
+      delete next[trackerID];
+      return next;
+    });
+    try {
+      const status = await fn();
+      if (
+        trackerAuthSectionActiveRef.current &&
+        trackerAuthStatusVersions.current[trackerID] === actionVersion
+      ) {
+        setTrackerAuthStatuses((prev) => ({ ...prev, [trackerID]: status }));
+      }
+    } catch (error) {
+      if (
+        trackerAuthSectionActiveRef.current &&
+        trackerAuthActionSequences.current[trackerID] === actionSequence &&
+        trackerAuthStatusVersions.current[trackerID] === actionVersion
+      ) {
+        setTrackerAuthActionErrors((prev) => ({ ...prev, [trackerID]: String(error) }));
+      }
+    } finally {
+      if (
+        trackerAuthSectionActiveRef.current &&
+        trackerAuthActionSequences.current[trackerID] === actionSequence
+      ) {
+        setTrackerAuthActions((prev) => ({ ...prev, [trackerID]: "" }));
+      }
+    }
+  };
+
+  const trackerAuthPanel = (() => {
+    const filter = trackerAuthFilter.trim().toLowerCase();
+    const capabilities = trackerAuthCapabilities.filter((capability) => {
+      if (!filter) return true;
+      return (
+        capability.trackerID.toLowerCase().includes(filter) ||
+        capability.authKind.toLowerCase().includes(filter)
+      );
+    });
+    const storageStatuses = trackerAuthCapabilities
+      .map((capability) => trackerAuthStatuses[capability.trackerID])
+      .filter((status): status is TrackerAuthStatus => status !== undefined);
+    const storageReady =
+      !trackerAuthLoading &&
+      trackerAuthCapabilities.length > 0 &&
+      storageStatuses.length === trackerAuthCapabilities.length &&
+      storageStatuses.every((status) => status.encryptedStorage);
+    const storagePartiallyReady = storageStatuses.some((status) => status.encryptedStorage);
+    const storageStatusLabel = trackerAuthLoading
+      ? "Checking encrypted cookie storage"
+      : storageReady
+        ? "Encrypted cookie storage ready"
+        : storagePartiallyReady
+          ? "Encrypted cookie storage partially ready"
+          : "Encrypted cookie storage unavailable";
+    return (
+      <div className="settings-form gap-4">
+        <div className="settings-subgroup">
+          <div className="settings-subgroup__title">Tracker Auth</div>
+          <div className="settings-auth-status">
+            <span className={`settings-auth-badge ${storageReady ? "is-ready" : "is-warning"}`}>
+              {storageStatusLabel}
+            </span>
+            <p className="helper">
+              Import Netscape or JSON cookies, check local auth state, and confirm which trackers
+              can relogin automatically during unattended uploads.
+            </p>
+          </div>
+          <label className="settings-field max-w-[360px]">
+            <span>Filter trackers</span>
+            <input
+              className={settingsInputClass}
+              value={trackerAuthFilter}
+              onChange={(event) => setTrackerAuthFilter(event.target.value)}
+              placeholder="MTV, cookies, api"
+            />
+          </label>
+        </div>
+        {trackerAuthLoading ? <p className="muted">Loading tracker auth...</p> : null}
+        {trackerAuthError ? <p className="error">{trackerAuthError}</p> : null}
+        <div className="grid gap-[0.85rem]">
+          {capabilities.map((capability) => {
+            const status = trackerAuthStatuses[capability.trackerID];
+            const busy = trackerAuthActions[capability.trackerID] || "";
+            const actionError = trackerAuthActionErrors[capability.trackerID] || "";
+            const code = trackerAuthCodes[capability.trackerID] || "";
+            const statusDisplay = trackerAuthStatusDisplay(status);
+            const canTestAuth = capability.supportsRemoteValidation === true;
+            return (
+              <div
+                className="settings-card tracker-auth-card grid min-w-0 gap-3"
+                key={capability.trackerID}
+              >
+                <div className="flex min-w-0 flex-wrap items-center justify-between gap-[0.6rem]">
+                  <div className="min-w-0 flex-1">
+                    <p className="settings-detail-card__label">Tracker</p>
+                    <h2 className="m-0 mt-[0.1rem] text-[1.05rem] leading-tight [overflow-wrap:anywhere]">
+                      {capability.displayName || capability.trackerID}
+                    </h2>
+                  </div>
+                  <span className={`settings-auth-badge ${statusBadgeClass(status?.state)}`}>
+                    {formatTrackerAuthState(status?.state)}
+                  </span>
+                </div>
+                <div className="flex min-w-0 flex-wrap items-center gap-[0.6rem]">
+                  <span className={trackerAuthChipClass}>{capability.authKind}</span>
+                  {capability.supportsCookieFile ? (
+                    <span className={trackerAuthChipClass}>cookie import</span>
+                  ) : null}
+                  {capability.supportsLogin ? (
+                    <span className={trackerAuthChipClass}>login</span>
+                  ) : null}
+                  {capability.supportsAutoLogin ? (
+                    <span className={trackerAuthChipClass}>auto relogin</span>
+                  ) : null}
+                  {capability.supportsTOTP ? (
+                    <span className={trackerAuthChipClass}>TOTP</span>
+                  ) : null}
+                  {capability.supportsManual2FA ? (
+                    <span className={trackerAuthChipClass}>manual 2FA</span>
+                  ) : null}
+                  {capability.requiresAPIKey ? (
+                    <span className={trackerAuthChipClass}>API key</span>
+                  ) : null}
+                  {capability.requiresPasskey ? (
+                    <span className={trackerAuthChipClass}>passkey</span>
+                  ) : null}
+                </div>
+                <div className="flex flex-wrap items-center gap-[0.6rem]">
+                  <p className={trackerAuthMetaClass}>Cookies: {status?.cookieCount ?? 0}</p>
+                  <p className={trackerAuthMetaClass}>
+                    Checked: {formatTrackerAuthDate(status?.lastCheckedAt)}
+                  </p>
+                  <p className={trackerAuthMetaClass}>
+                    Storage: {status?.encryptedStorage ? "encrypted" : "unavailable"}
+                  </p>
+                </div>
+                {statusDisplay.message ? (
+                  <p className="helper [overflow-wrap:anywhere]">{statusDisplay.message}</p>
+                ) : null}
+                {statusDisplay.lastError ? (
+                  <p className="error [overflow-wrap:anywhere]">{statusDisplay.lastError}</p>
+                ) : null}
+                {actionError ? <p className="error">{actionError}</p> : null}
+                {(capability.notes ?? []).map((note) => (
+                  <p className="muted [overflow-wrap:anywhere]" key={note}>
+                    {note}
+                  </p>
+                ))}
+                {status?.needs2FA ? (
+                  <div className="flex flex-wrap items-center gap-[0.6rem]">
+                    <input
+                      className={`${settingsInputClass} w-36`}
+                      value={code}
+                      inputMode="numeric"
+                      autoComplete="one-time-code"
+                      onChange={(event) =>
+                        setTrackerAuthCodes((prev) => ({
+                          ...prev,
+                          [capability.trackerID]: event.target.value,
+                        }))
+                      }
+                      placeholder="2FA code"
+                    />
+                    <Button
+                      type="button"
+                      disabled={!status.challengeID || !code.trim()}
+                      onClick={() =>
+                        runTrackerAuthAction(capability.trackerID, "2fa", () =>
+                          trackerAuthClient.submit2FA(status.challengeID, code),
+                        )
+                      }
+                    >
+                      Submit 2FA
+                    </Button>
+                  </div>
+                ) : null}
+                <div className="settings-auth-actions">
+                  {capability.supportsCookieFile ? (
+                    <Button
+                      type="button"
+                      disabled={Boolean(busy)}
+                      onClick={() =>
+                        runTrackerAuthAction(capability.trackerID, "import", () =>
+                          trackerAuthClient.importCookies(capability.trackerID),
+                        )
+                      }
+                    >
+                      {busy === "import" ? "Importing..." : "Import Cookies"}
+                    </Button>
+                  ) : null}
+                  {canTestAuth ? (
+                    <Button
+                      type="button"
+                      disabled={Boolean(busy)}
+                      onClick={() =>
+                        runTrackerAuthAction(capability.trackerID, "test", () =>
+                          trackerAuthClient.test(capability.trackerID),
+                        )
+                      }
+                    >
+                      {busy === "test" ? "Checking..." : "Check Auth"}
+                    </Button>
+                  ) : null}
+                  <Button
+                    type="button"
+                    disabled={Boolean(busy)}
+                    onClick={() =>
+                      runTrackerAuthAction(capability.trackerID, "delete", () =>
+                        trackerAuthClient.remove(capability.trackerID),
+                      )
+                    }
+                  >
+                    {busy === "delete" ? "Deleting..." : "Delete Auth"}
+                  </Button>
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    );
+  })();
+
+  const uptimeSeconds =
+    applicationInfo && applicationInfoFetchedAt !== null
+      ? applicationInfo.uptimeSeconds +
+        Math.max(0, Math.floor((uptimeTick - applicationInfoFetchedAt) / 1000))
+      : 0;
+  const uptimeValue = applicationInfo ? formatApplicationUptime(uptimeSeconds) : "";
+  const applicationDetailsPanel = (
+    <div className="settings-subgroup settings-subgroup--application">
+      <p className="helper">
+        Read-only build and runtime details for this install. Auth, bind, and storage paths are
+        intentionally excluded.
+      </p>
+      <div className="settings-details-grid">
+        <div className="settings-detail-card">
+          <p className="settings-detail-card__label">Project</p>
+          <p className="settings-detail-card__value">
+            <a
+              href="https://github.com/autobrr/upbrr"
+              target="_blank"
+              rel="noreferrer"
+              onAuxClick={handleExternalLinkClick}
+              onClick={handleExternalLinkClick}
+            >
+              autobrr/upbrr
+            </a>
+          </p>
+        </div>
+        {applicationInfo ? (
+          <>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">Version</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.version || "Unavailable"}
+              </p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">Build</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.buildIdentifier || "Unavailable"}
+              </p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">Go Runtime</p>
+              <p className="settings-detail-card__value mono">{applicationInfo.goVersion}</p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">DVD Menu Engine</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.dvdMenuEngine.EngineVersion || "Unavailable"}
+              </p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">FFmpeg DVD Menus</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.dvdMenuCapabilityStatus === "available"
+                  ? "Available"
+                  : applicationInfo.dvdMenuCapabilityStatus === "incompatible"
+                    ? "Incompatible"
+                    : "Unavailable"}
+              </p>
+              <p className="helper">{applicationInfo.dvdMenuCapabilityMessage}</p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">FFmpeg Version</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.dvdMenuEngine.FFmpegVersion || "Unavailable"}
+              </p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">Platform</p>
+              <p className="settings-detail-card__value mono">
+                {applicationInfo.goos}/{applicationInfo.goarch}
+              </p>
+            </div>
+            <div className="settings-detail-card">
+              <p className="settings-detail-card__label">Uptime</p>
+              <p className="settings-detail-card__value mono">
+                {uptimeValue || applicationInfo.uptime}
+              </p>
+            </div>
+          </>
+        ) : null}
+      </div>
+      {applicationInfoLoading ? <p className="muted">Loading application details...</p> : null}
+      {applicationInfoError ? <p className="error">{applicationInfoError}</p> : null}
+    </div>
+  );
+
+  return (
+    <div className="content-stack">
+      <header className="hero">
+        <p className="eyebrow">upbrr</p>
+        <h1>Settings</h1>
+        <p className="subtitle">
+          Edit settings by section. Changes apply immediately and are saved to SQLite.
+        </p>
+      </header>
+
+      <section className="panel">
+        <div className="settings-header">
+          <div className="settings-meta">
+            <p className="label">Configuration</p>
+            <p className="helper">Invalid changes will be rejected with a validation error.</p>
+          </div>
+          <div className="settings-actions">
+            <Button type="button" onClick={loadSettings} disabled={settingsLoading}>
+              Reload
+            </Button>
+            <Button
+              type="button"
+              onClick={handleExportSettings}
+              disabled={settingsLoading || settingsExporting || settingsImporting}
+            >
+              {settingsExporting ? "Exporting..." : "Export"}
+            </Button>
+            <Button
+              type="button"
+              onClick={handleImportConfig}
+              disabled={settingsLoading || settingsExporting || settingsImporting}
+            >
+              {settingsImporting ? "Importing..." : "Import"}
+            </Button>
+            <Button
+              variant="primary"
+              type="button"
+              onClick={() => {
+                void reloadTrackerAuthAfterConfigChange(handleSaveSettings);
+              }}
+              disabled={settingsLoading || settingsExporting || settingsImporting || !settingsDirty}
+            >
+              Save
+            </Button>
+          </div>
+        </div>
+
+        {configOpStatus ? (
+          <div className={`config-status-banner config-status-banner--${configOpStatus.type}`}>
+            <div className="config-status-banner__icon">
+              {configOpStatus.type === "success" ? (
+                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
+                  <path
+                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
+                    fill="currentColor"
+                    opacity=".15"
+                  />
+                  <path
+                    d="M6.5 10.5 8.5 12.5 13.5 7.5"
+                    stroke="currentColor"
+                    strokeWidth="1.5"
+                    strokeLinecap="round"
+                    strokeLinejoin="round"
+                  />
+                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
+                </svg>
+              ) : configOpStatus.type === "warning" ? (
+                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
+                  <path
+                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
+                    fill="currentColor"
+                    opacity=".15"
+                  />
+                  <path d="M10 7v4" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
+                  <circle cx="10" cy="13.5" r=".75" fill="currentColor" />
+                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
+                </svg>
+              ) : (
+                <svg width="20" height="20" viewBox="0 0 20 20" fill="none">
+                  <path
+                    d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"
+                    fill="currentColor"
+                    opacity=".15"
+                  />
+                  <path
+                    d="M12.5 7.5 7.5 12.5M7.5 7.5l5 5"
+                    stroke="currentColor"
+                    strokeWidth="1.5"
+                    strokeLinecap="round"
+                  />
+                  <circle cx="10" cy="10" r="8" stroke="currentColor" strokeWidth="1.5" />
+                </svg>
+              )}
+            </div>
+            <div className="config-status-banner__body">
+              <p className="config-status-banner__title">{configOpStatus.title}</p>
+              <p className="config-status-banner__message">{configOpStatus.message}</p>
+              {configOpStatus.warnings && configOpStatus.warnings.length > 0 ? (
+                <div className="config-status-banner__warnings">
+                  <button
+                    type="button"
+                    className="config-status-banner__toggle"
+                    onClick={() => setWarningsExpanded((prev) => !prev)}
+                  >
+                    {warningsExpanded ? "Hide" : "Show"} {configOpStatus.warnings.length} warning
+                    {configOpStatus.warnings.length !== 1 ? "s" : ""}
+                  </button>
+                  {warningsExpanded ? (
+                    <ul className="config-status-banner__warning-list">
+                      {configOpStatus.warnings.map((w, i) => (
+                        <li key={i}>{w}</li>
+                      ))}
+                    </ul>
+                  ) : null}
+                </div>
+              ) : null}
+            </div>
+            <button
+              type="button"
+              className="config-status-banner__dismiss"
+              onClick={dismissConfigOpStatus}
+              aria-label="Dismiss"
+            >
+              <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
+                <path
+                  d="M10.5 3.5 3.5 10.5M3.5 3.5l7 7"
+                  stroke="currentColor"
+                  strokeWidth="1.5"
+                  strokeLinecap="round"
+                />
+              </svg>
+            </button>
+          </div>
+        ) : null}
+
+        <div className="settings-shell">
+          <div className="settings-tags">
+            {settingsSections.map((section) => (
+              <button
+                key={section.key}
+                type="button"
+                className={cn(
+                  "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
+                  settingsSection === section.key
+                    ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
+                    : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
+                )}
+                onClick={() => setSettingsSection(section.key)}
+              >
+                {section.label}
+              </button>
+            ))}
+            <button
+              key={applicationDetailsSection.key}
+              type="button"
+              className={cn(
+                "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
+                settingsSection === applicationDetailsSection.key
+                  ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
+                  : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
+              )}
+              onClick={() => setSettingsSection(applicationDetailsSection.key)}
+            >
+              {applicationDetailsSection.label}
+            </button>
+            <button
+              key={trackerAuthSection.key}
+              type="button"
+              className={cn(
+                "flex h-8 w-full items-center rounded-md px-3 text-left text-sm font-medium transition",
+                settingsSection === trackerAuthSection.key
+                  ? "bg-[var(--accent)] text-slate-950 shadow-[0_8px_24px_rgba(245,185,66,0.16)]"
+                  : "text-[var(--muted)] hover:bg-white/10 hover:text-[var(--text)]",
+              )}
+              onClick={() => setSettingsSection(trackerAuthSection.key)}
+            >
+              {trackerAuthSection.label}
+            </button>
+          </div>
+
+          <div className="settings-body">
+            {settingsSection === applicationDetailsSection.key ? applicationDetailsPanel : null}
+            {settingsSection === trackerAuthSection.key ? trackerAuthPanel : null}
+            {settingsSection === applicationDetailsSection.key ||
+            settingsSection === trackerAuthSection.key ? null : configData ? (
+              <div className="settings-form">
+                {showAdvancedToggle ? (
+                  <div className="settings-switch-row">
+                    <span>Show advanced</span>
+                    <Switch
+                      aria-label="Show advanced"
+                      checked={advancedOpen}
+                      onChange={(event) =>
+                        setSettingsAdvanced((prev) => ({
+                          ...prev,
+                          [settingsSection]: event.target.checked,
+                        }))
+                      }
+                    />
+                  </div>
+                ) : null}
+                {settingsSection === "image_hosting" ? (
+                  renderImageHostingSection()
+                ) : settingsSection === "trackers" &&
+                  configData.Trackers &&
+                  typeof configData.Trackers === "object" &&
+                  !Array.isArray(configData.Trackers) ? (
+                  renderTrackerSection(advancedOpen)
+                ) : settingsSection === "torrent_clients" &&
+                  configData.TorrentClients &&
+                  typeof configData.TorrentClients === "object" ? (
+                  renderTorrentClientsSection(advancedOpen)
+                ) : (
+                  <div className="settings-grid">
+                    {(() => {
+                      const section = settingsSections.find((item) => item.key === settingsSection);
+                      if (!section) return null;
+                      const sectionData = configData[section.jsonKey];
+                      if (
+                        !sectionData ||
+                        typeof sectionData !== "object" ||
+                        Array.isArray(sectionData)
+                      ) {
+                        return null;
+                      }
+                      const meta = sectionFieldMeta[section.jsonKey] || {};
+                      return Object.entries(sectionData as ConfigMap)
+                        .filter(([key]) => {
+                          const fieldMeta = meta[key];
+                          if (fieldMeta?.advanced && !advancedOpen) return false;
+                          return true;
+                        })
+                        .map(([key, value]) =>
+                          renderField(key, value, [section.jsonKey, key], meta[key]),
+                        );
+                    })()}
+                  </div>
+                )}
+              </div>
+            ) : (
+              <p className="muted">Loading configuration...</p>
+            )}
+          </div>
+        </div>
+
+        {settingsSaved ? <p className="settings-saved">{settingsSaved}</p> : null}
+        {settingsError ? <p className="error">{settingsError}</p> : null}
+      </section>
+
+      <AlertDialog.Root
+        open={importConfirmOpen}
+        onOpenChange={(open) => {
+          if (!open) handleImportConfigCancel();
+        }}
+      >
+        <AlertDialog.Portal>
+          <AlertDialog.Overlay className="import-confirm-overlay" />
+          <AlertDialog.Content className="import-confirm-dialog">
+            <div className="import-confirm-dialog__icon">
+              <svg width="28" height="28" viewBox="0 0 24 24" fill="none">
+                <path d="M12 3 1.5 21h21L12 3Z" fill="currentColor" opacity=".12" />
+                <path
+                  d="M12 3 1.5 21h21L12 3Z"
+                  stroke="currentColor"
+                  strokeWidth="1.6"
+                  strokeLinejoin="round"
+                />
+                <path d="M12 10v5" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
+                <circle cx="12" cy="18" r="1" fill="currentColor" />
+              </svg>
+            </div>
+            <div className="import-confirm-dialog__body">
+              <AlertDialog.Title asChild>
+                <h2 className="import-confirm-dialog__title">Replace current configuration?</h2>
+              </AlertDialog.Title>
+              <AlertDialog.Description asChild>
+                <p className="import-confirm-dialog__message">
+                  Importing a configuration file will overwrite your current settings in the
+                  database. This action cannot be undone.
+                </p>
+              </AlertDialog.Description>
+              <p className="import-confirm-dialog__hint">
+                We strongly recommend exporting your current configuration first so you can restore
+                it if the imported file isn&apos;t what you expected.
+              </p>
+            </div>
+            <div className="import-confirm-dialog__actions">
+              <AlertDialog.Cancel asChild>
+                <Button type="button" disabled={settingsImporting}>
+                  Cancel
+                </Button>
+              </AlertDialog.Cancel>
+              <Button
+                type="button"
+                onClick={handleExportSettings}
+                disabled={settingsExporting || settingsImporting}
+              >
+                {settingsExporting ? "Exporting..." : "Export current config"}
+              </Button>
+              <AlertDialog.Action asChild>
+                <Button
+                  type="button"
+                  variant="primary"
+                  className="import-confirm-dialog__confirm"
+                  onClick={(event) => {
+                    event.preventDefault();
+                    void reloadTrackerAuthAfterConfigChange(handleImportConfigConfirm);
+                  }}
+                  disabled={settingsImporting}
+                >
+                  {settingsImporting ? "Importing..." : "Choose file & import"}
+                </Button>
+              </AlertDialog.Action>
+            </div>
+          </AlertDialog.Content>
+        </AlertDialog.Portal>
+      </AlertDialog.Root>
+    </div>
+  );
+}
+
+function formatApplicationUptime(totalSeconds: number) {
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  const parts: string[] = [];
+  if (days > 0) {
+    parts.push(`${days}d`);
+  }
+  if (hours > 0 || parts.length > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0 || parts.length > 0) {
+    parts.push(`${minutes}m`);
+  }
+  parts.push(`${seconds}s`);
+
+  return parts.join(" ");
+}
+
+function formatTrackerAuthState(state?: string) {
+  switch (state) {
+    case "configured":
+      return "Configured";
+    case "has_cookies":
+      return "Has cookies";
+    case "login_required":
+      return "Login required";
+    case "encrypted_storage_unavailable":
+      return "Storage unavailable";
+    case "error":
+      return "Error";
+    default:
+      return "Not configured";
+  }
+}
+
+function statusBadgeClass(state?: string) {
+  switch (state) {
+    case "configured":
+    case "has_cookies":
+      return "is-ready";
+    case "login_required":
+    case "encrypted_storage_unavailable":
+    case "error":
+      return "is-warning";
+    default:
+      return "is-idle";
+  }
+}
+
+function formatTrackerAuthDate(value?: string) {
+  if (!value) {
+    return "Never";
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date.toLocaleString();
+}
diff --git a/webui/src/pages/tracker_data/index.test.tsx b/webui/src/pages/tracker_data/index.test.tsx
new file mode 100644
index 00000000..297cb163
--- /dev/null
+++ b/webui/src/pages/tracker_data/index.test.tsx
@@ -0,0 +1,35 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { InputFacet } from "../../releaseSession/types";
+import TrackerDataPage from "./index";
+
+afterEach(cleanup);
+
+describe("TrackerDataPage", () => {
+  it("renders the input facet's immutable tracker-data view", () => {
+    const facet = {
+      view: {
+        sourceDraft: "",
+        selectedSource: "",
+        status: "idle",
+        error: "",
+        preparationDirty: false,
+        intent: { sourceLookupURL: "", identity: {}, releaseName: {}, trackers: [] },
+        preview: null,
+        trackerData: [],
+      },
+    } as unknown as InputFacet;
+    render(
+      <TrackerDataPage
+        facet={facet}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+        trackerIconSrcByName={{}}
+      />,
+    );
+    expect(screen.getByText("No tracker data available.")).toBeInTheDocument();
+  });
+});
diff --git a/webui/src/pages/tracker_data/index.tsx b/webui/src/pages/tracker_data/index.tsx
new file mode 100644
index 00000000..a40bf2b8
--- /dev/null
+++ b/webui/src/pages/tracker_data/index.tsx
@@ -0,0 +1,245 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useMemo, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import RenderedDescription from "../../components/RenderedDescription";
+import { Button } from "../../components/ui/button";
+import { TrackerIconImage } from "../../components/ui/tracker-icon";
+import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
+import { trackerIconFor } from "../../hooks/useTrackerIcons";
+import type { InputFacet } from "../../releaseSession/types";
+import type { TrackerPreview } from "../../types";
+import { handleExternalLinkClick } from "../../utils/externalLinks";
+
+type Props = {
+  facet: InputFacet;
+  setLightboxImage: Dispatch<SetStateAction<string>>;
+  setLightboxAlt: Dispatch<SetStateAction<string>>;
+  useFavicons?: boolean;
+  faviconOnly?: boolean;
+  trackerIconSrcByName: TrackerIconCache;
+};
+
+export default function TrackerDataPage(props: Props) {
+  const {
+    facet,
+    setLightboxImage,
+    setLightboxAlt,
+    useFavicons = true,
+    faviconOnly = false,
+    trackerIconSrcByName,
+  } = props;
+  const [renderedDescriptions, setRenderedDescriptions] = useState<Record<string, boolean>>({});
+  const trackerData = facet.view.trackerData;
+
+  const trackerDataOrdered = useMemo(() => {
+    const items = trackerData;
+    if (items.length === 0) {
+      return { items: [], primaryIndex: -1 };
+    }
+    const hasActualData = (item: TrackerPreview) =>
+      Boolean(
+        item.Description ||
+        item.DescriptionHTML ||
+        (item.ImageURLs && item.ImageURLs.length > 0) ||
+        item.TMDBID ||
+        item.IMDBID ||
+        item.TVDBID ||
+        item.MALID ||
+        item.InfoHash ||
+        item.Category ||
+        item.Filename,
+      );
+    const primaryIndex = items.findIndex(hasActualData);
+    if (primaryIndex <= 0) {
+      return { items, primaryIndex };
+    }
+    const primary = items[primaryIndex];
+    const rest = items.filter((_, index) => index !== primaryIndex);
+    return { items: [primary, ...rest], primaryIndex: 0 };
+  }, [trackerData]);
+
+  return (
+    <section className="flex flex-col gap-3">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Tracker Data</p>
+        <h1>Input Metadata</h1>
+        <p className="subtitle">Tracker-provided metadata, descriptions, and images.</p>
+      </header>
+      {trackerData.length === 0 ? (
+        <p className="muted">No tracker data available.</p>
+      ) : (
+        <div className="grid gap-3">
+          {trackerDataOrdered.items.map((item, index) => {
+            const trackerKey = `${item.Tracker}-${index}`;
+            const isRendered =
+              Boolean(renderedDescriptions[trackerKey]) && Boolean(item.DescriptionHTML);
+            const renderedHTML = isRendered ? item.DescriptionHTML : "";
+            const isPrimary = index === trackerDataOrdered.primaryIndex;
+            const iconSrc = trackerIconFor(trackerIconSrcByName, item.Tracker);
+            const hideTrackerName = faviconOnly && useFavicons;
+            return (
+              <details
+                className="overflow-hidden rounded-lg border border-white/10 bg-[rgba(12,16,26,0.78)]"
+                key={trackerKey}
+                open={isPrimary}
+              >
+                <summary className="flex cursor-pointer list-none items-center justify-between gap-3 px-3 py-2 font-semibold marker:content-[''] [&::-webkit-details-marker]:hidden">
+                  <span
+                    aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
+                    className="flex items-center gap-2 min-w-0 overflow-hidden text-ellipsis whitespace-nowrap"
+                  >
+                    <TrackerIconImage
+                      tracker={item.Tracker}
+                      iconSrc={iconSrc}
+                      enabled={useFavicons}
+                    />
+                    {hideTrackerName ? null : item.Tracker || "Unknown"}
+                  </span>
+                  <span className="whitespace-nowrap text-sm font-medium text-[var(--muted)]">
+                    Torrent ID: {item.TrackerID || "-"}
+                  </span>
+                </summary>
+                <div className="grid gap-3 border-t border-white/10 px-3 pb-3 pt-2">
+                  <div className="grid grid-cols-[repeat(auto-fit,minmax(160px,1fr))] gap-2">
+                    <div>
+                      <p className="label">Tracker</p>
+                      {item.TorrentURL ? (
+                        <a
+                          className="tracker-link flex items-center gap-1.5"
+                          href={item.TorrentURL}
+                          aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
+                          target="_blank"
+                          rel="noreferrer"
+                          onAuxClick={handleExternalLinkClick}
+                          onClick={handleExternalLinkClick}
+                        >
+                          <TrackerIconImage
+                            tracker={item.Tracker}
+                            iconSrc={iconSrc}
+                            enabled={useFavicons}
+                          />
+                          {hideTrackerName ? null : item.Tracker || "Unknown"}
+                        </a>
+                      ) : (
+                        <div
+                          aria-label={hideTrackerName ? item.Tracker || "Unknown" : undefined}
+                          className="value flex items-center gap-1.5"
+                        >
+                          <TrackerIconImage
+                            tracker={item.Tracker}
+                            iconSrc={iconSrc}
+                            enabled={useFavicons}
+                          />
+                          {hideTrackerName ? null : <span>{item.Tracker || "Unknown"}</span>}
+                        </div>
+                      )}
+                    </div>
+                    <div>
+                      <p className="label">Matched</p>
+                      <p className="value">{item.Matched ? "Yes" : "No"}</p>
+                    </div>
+                    <div>
+                      <p className="label">Updated</p>
+                      <p className="value">{item.UpdatedAt || "-"}</p>
+                    </div>
+                  </div>
+                  <div className="grid grid-cols-[repeat(auto-fit,minmax(170px,1fr))] gap-2">
+                    <div className="min-w-0">
+                      <p className="label">Torrent ID</p>
+                      <p className="value mono [overflow-wrap:anywhere]">{item.TrackerID || "-"}</p>
+                    </div>
+                    <div className="min-w-0">
+                      <p className="label">Info Hash</p>
+                      <p className="value mono [overflow-wrap:anywhere]">{item.InfoHash || "-"}</p>
+                    </div>
+                    <div className="min-w-0">
+                      <p className="label">Category</p>
+                      <p className="value [overflow-wrap:anywhere]">{item.Category || "-"}</p>
+                    </div>
+                    <div className="min-w-0">
+                      <p className="label">Filename</p>
+                      <p className="value [overflow-wrap:anywhere]">{item.Filename || "-"}</p>
+                    </div>
+                  </div>
+                  <div className="grid grid-cols-[repeat(auto-fit,minmax(120px,1fr))] gap-2">
+                    <div>
+                      <p className="label">TMDB</p>
+                      <p className="value mono">{item.TMDBID || 0}</p>
+                    </div>
+                    <div>
+                      <p className="label">IMDB</p>
+                      <p className="value mono">{item.IMDBID || 0}</p>
+                    </div>
+                    <div>
+                      <p className="label">TVDB</p>
+                      <p className="value mono">{item.TVDBID || 0}</p>
+                    </div>
+                    <div>
+                      <p className="label">MAL</p>
+                      <p className="value mono">{item.MALID || 0}</p>
+                    </div>
+                  </div>
+                  <div>
+                    <div className="flex items-center justify-between gap-2">
+                      <h2>Description</h2>
+                      {item.DescriptionHTML ? (
+                        <Button
+                          className="h-7 rounded-full px-2 text-xs"
+                          type="button"
+                          onClick={() =>
+                            setRenderedDescriptions((prev) => ({
+                              ...prev,
+                              [trackerKey]: !prev[trackerKey],
+                            }))
+                          }
+                        >
+                          {isRendered ? "Show raw" : "Render"}
+                        </Button>
+                      ) : null}
+                    </div>
+                    {isRendered ? (
+                      <RenderedDescription html={renderedHTML} />
+                    ) : (
+                      <p className="tracker-description">
+                        {item.Description || "No description provided."}
+                      </p>
+                    )}
+                  </div>
+                  <div>
+                    <h2>Images</h2>
+                    {item.ImageURLs.length === 0 ? (
+                      <p className="muted">No images provided.</p>
+                    ) : (
+                      <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
+                        {item.ImageURLs.map((url, imageIndex) => (
+                          <button
+                            className="cursor-pointer border-0 bg-transparent p-0"
+                            type="button"
+                            key={`${url}-${imageIndex}`}
+                            onClick={() => {
+                              setLightboxImage(url);
+                              setLightboxAlt(`${item.Tracker || "Tracker"} image`);
+                            }}
+                          >
+                            <img
+                              className="w-full rounded-lg border border-white/10"
+                              src={url}
+                              alt="Tracker"
+                              loading="lazy"
+                            />
+                          </button>
+                        ))}
+                      </div>
+                    )}
+                  </div>
+                </div>
+              </details>
+            );
+          })}
+        </div>
+      )}
+    </section>
+  );
+}
diff --git a/webui/src/pages/tracker_upload/index.test.tsx b/webui/src/pages/tracker_upload/index.test.tsx
new file mode 100644
index 00000000..1ca77dbc
--- /dev/null
+++ b/webui/src/pages/tracker_upload/index.test.tsx
@@ -0,0 +1,295 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { UploadFacet } from "../../releaseSession/types";
+import TrackerUploadPage from "./index";
+
+afterEach(cleanup);
+
+describe("TrackerUploadPage", () => {
+  it("keeps dry run explicit", () => {
+    const runDryRun = vi.fn(async () => true);
+    const facet: UploadFacet = {
+      view: {
+        revision: 1,
+        selectedTrackers: ["EXAMPLE"],
+        eligibility: null,
+        ignoredDupesFor: [],
+        authorizedRulesByTracker: {},
+        questionnaireAnswers: {},
+        options: { noSeed: false, runLogLevel: "info" },
+        dryRunStatus: "idle",
+        dryRun: null,
+        dryRunStaleReason: "Run dry run.",
+        reviewStatus: "idle",
+        review: null,
+        reviewStaleReason: "Run review.",
+        snapshot: null,
+        error: "",
+        transientError: "",
+      },
+      chooseTrackers: vi.fn(),
+      answerQuestionnaire: vi.fn(),
+      changeOptions: vi.fn(),
+      setRuleAuthorized: vi.fn(),
+      runDryRun,
+      review: vi.fn(async () => true),
+      start: vi.fn(async () => true),
+      cancel: vi.fn(async () => true),
+      retry: vi.fn(async () => true),
+    };
+    render(
+      <TrackerUploadPage
+        facet={facet}
+        trackerUploadItems={[{ name: "EXAMPLE", config: {} }]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+    expect(screen.queryByText("Debug logging")).not.toBeInTheDocument();
+    expect(screen.getByLabelText("Log level")).toHaveValue("info");
+    expect(screen.getByRole("option", { name: "debug" })).toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: "Run dry run" }));
+    expect(runDryRun).toHaveBeenCalledOnce();
+  });
+
+  it("renders dry-run entries with nullable Go slice fields", () => {
+    const facet: UploadFacet = {
+      view: {
+        revision: 1,
+        selectedTrackers: ["EXAMPLE"],
+        eligibility: null,
+        ignoredDupesFor: [],
+        authorizedRulesByTracker: {},
+        questionnaireAnswers: {},
+        options: { noSeed: false, runLogLevel: "info" },
+        dryRunStatus: "ready",
+        dryRun: {
+          SourcePath: "C:\\media\\Example",
+          Trackers: [
+            {
+              Tracker: "EXAMPLE",
+              Status: "error",
+              Message: "Preview unavailable.",
+              Files: null,
+              Questionnaire: { Tracker: "EXAMPLE", Fields: null },
+            },
+          ],
+        } as unknown as NonNullable<UploadFacet["view"]["dryRun"]>,
+        dryRunStaleReason: "",
+        reviewStatus: "idle",
+        review: null,
+        reviewStaleReason: "Review required.",
+        snapshot: null,
+        error: "",
+        transientError: "",
+      },
+      chooseTrackers: vi.fn(),
+      answerQuestionnaire: vi.fn(),
+      changeOptions: vi.fn(),
+      setRuleAuthorized: vi.fn(),
+      runDryRun: vi.fn(async () => true),
+      review: vi.fn(async () => true),
+      start: vi.fn(async () => true),
+      cancel: vi.fn(async () => true),
+      retry: vi.fn(async () => true),
+    };
+
+    render(
+      <TrackerUploadPage
+        facet={facet}
+        trackerUploadItems={[{ name: "EXAMPLE", config: {} }]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.getByRole("heading", { name: "EXAMPLE" })).toBeInTheDocument();
+    expect(screen.getByText("0/0")).toBeInTheDocument();
+    expect(screen.getByText("Preview unavailable.")).toBeInTheDocument();
+  });
+
+  it("offers authorization only for waivable rule diagnostics", () => {
+    const setRuleAuthorized = vi.fn();
+    const facet: UploadFacet = {
+      view: {
+        revision: 1,
+        selectedTrackers: ["EXAMPLE"],
+        eligibility: null,
+        ignoredDupesFor: [],
+        authorizedRulesByTracker: {},
+        questionnaireAnswers: {},
+        options: { noSeed: false, runLogLevel: "info" },
+        dryRunStatus: "ready",
+        dryRun: {
+          SourcePath: "C:\\media\\Example",
+          Trackers: [
+            {
+              Tracker: "EXAMPLE",
+              Status: "ready",
+              Files: [],
+              Diagnostics: {
+                Duplicate: {
+                  Tracker: "EXAMPLE",
+                  Status: "completed",
+                  HasDupes: true,
+                  Filtered: [{ ID: "1", Name: "Example.Release.2026.1080p-GRP" }],
+                },
+                LiveEligibilityReasons: [],
+                RuleDecisions: [
+                  {
+                    Rule: "resolution_required",
+                    Reason: "missing resolution",
+                    Disposition: "strict",
+                    Authorized: false,
+                  },
+                  {
+                    Rule: "container",
+                    Reason: "container is not accepted",
+                    Disposition: "waivable",
+                    Authorized: false,
+                  },
+                  {
+                    Rule: "recommended_id",
+                    Reason: "IMDb ID recommended",
+                    Disposition: "advisory",
+                    Authorized: false,
+                  },
+                ],
+              },
+            },
+          ],
+        } as unknown as NonNullable<UploadFacet["view"]["dryRun"]>,
+        dryRunStaleReason: "",
+        reviewStatus: "idle",
+        review: null,
+        reviewStaleReason: "Review required.",
+        snapshot: null,
+        error: "",
+        transientError: "",
+      },
+      chooseTrackers: vi.fn(),
+      answerQuestionnaire: vi.fn(),
+      changeOptions: vi.fn(),
+      setRuleAuthorized,
+      runDryRun: vi.fn(async () => true),
+      review: vi.fn(async () => true),
+      start: vi.fn(async () => true),
+      cancel: vi.fn(async () => true),
+      retry: vi.fn(async () => true),
+    };
+
+    render(
+      <TrackerUploadPage
+        facet={facet}
+        trackerUploadItems={[{ name: "EXAMPLE", config: {} }]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.queryByLabelText("Authorize resolution_required for EXAMPLE")).toBeNull();
+    expect(screen.queryByLabelText("Authorize recommended_id for EXAMPLE")).toBeNull();
+    expect(screen.getByText("Duplicate diagnostics")).toBeInTheDocument();
+    expect(screen.getByText("Example.Release.2026.1080p-GRP")).toBeInTheDocument();
+    fireEvent.click(screen.getByLabelText("Authorize container for EXAMPLE"));
+    expect(setRuleAuthorized).toHaveBeenCalledWith("EXAMPLE", "container", true);
+  });
+
+  it("renders redacted dry-run payloads for every tracker", () => {
+    const facet: UploadFacet = {
+      view: {
+        revision: 1,
+        selectedTrackers: ["FIRST", "SECOND"],
+        eligibility: null,
+        ignoredDupesFor: [],
+        authorizedRulesByTracker: {},
+        questionnaireAnswers: {},
+        options: { noSeed: false, runLogLevel: "debug" },
+        dryRunStatus: "ready",
+        dryRun: {
+          SourcePath: "C:\\media\\Example",
+          Trackers: [
+            {
+              Tracker: "FIRST",
+              Status: "ready",
+              Endpoint:
+                "https://tracker.example/upload?api_key=fixture-secret&name=Example.Release.2026.1080p-GRP",
+              Payload: {
+                api_key: "fixture-secret",
+                name: "first-payload",
+              },
+              Files: [
+                {
+                  Field: "torrent",
+                  Path: "C:\\private\\Example.Release.2026.1080p-GRP.torrent",
+                  Present: true,
+                },
+              ],
+              Diagnostics: {},
+            },
+            {
+              Tracker: "SECOND",
+              Status: "ready",
+              Payload: {
+                name: "second-top-level-payload",
+              },
+              Files: [],
+              DebugSections: [
+                {
+                  Title: "Tracker request",
+                  Endpoint: "https://tracker.example/upload?token=fixture-secret",
+                  Files: [],
+                  Payload: {
+                    description: "line 1\nline 2",
+                    name: "second-debug-payload",
+                  },
+                },
+              ],
+              Diagnostics: {},
+            },
+          ],
+        } as unknown as NonNullable<UploadFacet["view"]["dryRun"]>,
+        dryRunStaleReason: "",
+        reviewStatus: "idle",
+        review: null,
+        reviewStaleReason: "Review required.",
+        snapshot: null,
+        error: "",
+        transientError: "",
+      },
+      chooseTrackers: vi.fn(),
+      answerQuestionnaire: vi.fn(),
+      changeOptions: vi.fn(),
+      setRuleAuthorized: vi.fn(),
+      runDryRun: vi.fn(async () => true),
+      review: vi.fn(async () => true),
+      start: vi.fn(async () => true),
+      cancel: vi.fn(async () => true),
+      retry: vi.fn(async () => true),
+    };
+
+    render(
+      <TrackerUploadPage
+        facet={facet}
+        trackerUploadItems={[
+          { name: "FIRST", config: {} },
+          { name: "SECOND", config: {} },
+        ]}
+        trackerIconSrcByName={{}}
+      />,
+    );
+
+    expect(screen.getByRole("heading", { name: "FIRST" })).toBeInTheDocument();
+    expect(screen.getByRole("heading", { name: "SECOND" })).toBeInTheDocument();
+    expect(screen.getByText("first-payload")).toBeInTheDocument();
+    expect(screen.getByText("second-top-level-payload")).toBeInTheDocument();
+    expect(screen.getByText("second-debug-payload")).toBeInTheDocument();
+    expect(screen.getByText("[13 bytes, 2 lines omitted]")).toBeInTheDocument();
+    expect(screen.getByText("[local path]")).toBeInTheDocument();
+    expect(screen.getAllByText("[REDACTED]").length).toBeGreaterThanOrEqual(1);
+
+    const renderedText = document.body.textContent || "";
+    expect(renderedText.includes("fixture-secret")).toBe(false);
+    expect(renderedText.includes("C:\\private")).toBe(false);
+  });
+});
diff --git a/webui/src/pages/tracker_upload/index.tsx b/webui/src/pages/tracker_upload/index.tsx
new file mode 100644
index 00000000..d5c8b710
--- /dev/null
+++ b/webui/src/pages/tracker_upload/index.tsx
@@ -0,0 +1,510 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useMemo } from "react";
+import { Button } from "../../components/ui/button";
+import { TrackerIconImage } from "../../components/ui/tracker-icon";
+import type { TrackerIconCache } from "../../hooks/useTrackerIcons";
+import { trackerIconFor } from "../../hooks/useTrackerIcons";
+import type { UploadFacet } from "../../releaseSession/types";
+import type { TrackerDryRunFile, TrackerUploadItem } from "../../types";
+
+type Props = Readonly<{
+  facet: UploadFacet;
+  trackerUploadItems: readonly TrackerUploadItem[];
+  useFavicons?: boolean;
+  faviconOnly?: boolean;
+  trackerIconSrcByName: TrackerIconCache;
+}>;
+
+const terminalStatuses = new Set(["completed", "completed_with_errors", "failed", "canceled"]);
+const dryRunPayloadPreviewLimit = 240;
+const dryRunBodyPayloadKeys = new Set([
+  "description",
+  "desc",
+  "descr",
+  "release_desc",
+  "album_desc",
+  "mediainfo",
+  "mediainfo[]",
+  "media_info",
+  "bdinfo",
+  "bd_info",
+  "techinfo",
+  "technical_info",
+  "technicaldetails",
+]);
+const sensitiveDryRunPayloadKeys = new Set([
+  "anticsrftoken",
+  "accesstoken",
+  "apikey",
+  "apitoken",
+  "auth",
+  "authorization",
+  "authkey",
+  "authtoken",
+  "cookie",
+  "csrf",
+  "email",
+  "infohash",
+  "key",
+  "passkey",
+  "password",
+  "passwordconfirm",
+  "passwordconfirmation",
+  "popcron",
+  "refreshtoken",
+  "rsskey",
+  "secret",
+  "secretkey",
+  "sessionkey",
+  "sessiontoken",
+  "token",
+  "torrentpass",
+  "torrentpasskey",
+  "uid",
+  "user",
+  "userid",
+  "username",
+]);
+
+const normalizedDryRunPayloadKey = (key: string) => key.trim().toLowerCase();
+
+const normalizedSensitiveDryRunPayloadKey = (key: string) =>
+  key
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "");
+
+const isSensitiveDryRunPayloadField = (key: string) =>
+  sensitiveDryRunPayloadKeys.has(normalizedSensitiveDryRunPayloadKey(key));
+
+const redactDryRunSecretFragments = (value: string) =>
+  value
+    .replace(/([?&])([^=&#\s]+)=([^&#\s]*)/g, (match, separator, key) =>
+      isSensitiveDryRunPayloadField(String(key)) ? `${separator}${key}=[REDACTED]` : match,
+    )
+    .replace(
+      /(^|[\s,{])([A-Za-z][A-Za-z0-9_-]*(?:key|token|pass|password|cookie|auth|secret|csrf|uid|user))\s*[:=]\s*[^\s,;}]+/gi,
+      (match, prefix, key) =>
+        isSensitiveDryRunPayloadField(String(key)) ? `${prefix}${key}=[REDACTED]` : match,
+    );
+
+const summarizeDryRunBody = (value: string) => {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  const lines = trimmed.split(/\r\n|\r|\n/).length;
+  return `[${trimmed.length} bytes, ${lines} lines omitted]`;
+};
+
+const formatDryRunPayloadValue = (key: string, value: unknown) => {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) return "";
+  if (isSensitiveDryRunPayloadField(key)) return "[REDACTED]";
+
+  const redacted = redactDryRunSecretFragments(trimmed);
+  if (dryRunBodyPayloadKeys.has(normalizedDryRunPayloadKey(key))) {
+    return summarizeDryRunBody(redacted);
+  }
+
+  const compact = redacted.replace(/\s+/g, " ");
+  if (compact.length <= dryRunPayloadPreviewLimit) return compact;
+  return `${compact.slice(0, dryRunPayloadPreviewLimit)}... [${redacted.length} bytes total]`;
+};
+
+const formatDryRunFilePath = (value: string) => {
+  const trimmed = value.trim();
+  if (!trimmed) return "(none)";
+
+  const normalized = trimmed.replaceAll("\\", "/").toLowerCase();
+  const original = trimmed.replaceAll("\\", "/");
+  for (const marker of [".upbrr/tmp/", ".upbrr/cache/", ".upbrr/logs/"]) {
+    if (normalized.startsWith(marker)) return original;
+    const index = normalized.indexOf(`/${marker}`);
+    if (index >= 0) return original.slice(index + 1);
+  }
+  return "[local path]";
+};
+
+const dryRunFileKey = (file: TrackerDryRunFile, index: number) =>
+  `${file.Field}-${file.Path}-${index}`;
+
+/** Thin presentation adapter for dry-run, review, and retained upload-job state. */
+export default function TrackerUploadPage({
+  facet,
+  trackerUploadItems,
+  useFavicons = true,
+  faviconOnly = false,
+  trackerIconSrcByName,
+}: Props) {
+  const { view } = facet;
+  const selected = useMemo(() => new Set(view.selectedTrackers), [view.selectedTrackers]);
+  const eligibilityByTracker = useMemo(
+    () => new Map((view.eligibility?.Trackers || []).map((item) => [item.Tracker, item])),
+    [view.eligibility],
+  );
+  const uploadRunning = Boolean(view.snapshot && !terminalStatuses.has(view.snapshot.status));
+  const failedTrackers = view.snapshot?.failedTrackers || [];
+  const snapshotTrackers = view.snapshot?.trackers || [];
+  const hideTrackerNames = faviconOnly && useFavicons;
+
+  const toggleTracker = (tracker: string, checked: boolean) => {
+    const next = new Set(view.selectedTrackers);
+    if (checked) next.add(tracker);
+    else next.delete(tracker);
+    facet.chooseTrackers([...next]);
+  };
+
+  return (
+    <section className="flex flex-col gap-4">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Tracker Upload</p>
+        <h1>Review &amp; Upload</h1>
+        <p className="subtitle">Select trackers, run an explicit dry run, review, then upload.</p>
+      </header>
+
+      <section className="panel grid gap-3">
+        <h2>Tracker intent</h2>
+        <div className="flex flex-wrap gap-2">
+          {trackerUploadItems.map((item) => {
+            const tracker = item.name.trim().toUpperCase();
+            const eligibility = eligibilityByTracker.get(tracker);
+            const blocked = eligibility ? !eligibility.Eligible : false;
+            return (
+              <label
+                className="flex items-center gap-2 rounded border border-white/10 bg-white/5 px-2 py-1.5"
+                key={tracker}
+              >
+                <input
+                  type="checkbox"
+                  checked={selected.has(tracker)}
+                  onChange={(event) => toggleTracker(tracker, event.target.checked)}
+                />
+                <TrackerIconImage
+                  tracker={tracker}
+                  iconSrc={trackerIconFor(trackerIconSrcByName, tracker)}
+                  enabled={useFavicons}
+                />
+                {hideTrackerNames ? null : <span>{tracker}</span>}
+                {blocked ? <span className="text-xs text-red-300">Blocked</span> : null}
+              </label>
+            );
+          })}
+        </div>
+        {(view.eligibility?.Trackers || [])
+          .filter((item) => !item.Eligible && selected.has(item.Tracker))
+          .map((item) => (
+            <p className="error" key={item.Tracker}>
+              {item.Tracker}: {(item.Reasons || []).map((reason) => reason.Message).join(" ")}
+            </p>
+          ))}
+      </section>
+
+      <section className="panel grid gap-3">
+        <h2>Run options</h2>
+        <div className="flex flex-wrap gap-4">
+          <label className="flex items-center gap-2">
+            <input
+              type="checkbox"
+              checked={view.options.noSeed}
+              onChange={(event) => facet.changeOptions({ noSeed: event.target.checked })}
+            />
+            Skip client injection
+          </label>
+          <label className="grid gap-1">
+            <span className="label">Log level</span>
+            <select
+              value={view.options.runLogLevel}
+              onChange={(event) => facet.changeOptions({ runLogLevel: event.target.value })}
+            >
+              {["trace", "debug", "info", "warn", "error"].map((level) => (
+                <option key={level} value={level}>
+                  {level}
+                </option>
+              ))}
+            </select>
+          </label>
+        </div>
+      </section>
+
+      <section className="panel grid gap-3">
+        <div className="flex flex-wrap items-center gap-2">
+          <Button
+            variant="primary"
+            type="button"
+            disabled={view.dryRunStatus === "running" || view.selectedTrackers.length === 0}
+            onClick={() => void facet.runDryRun()}
+          >
+            {view.dryRunStatus === "running" ? "Running..." : "Run dry run"}
+          </Button>
+          <Button
+            type="button"
+            disabled={view.reviewStatus === "running" || Boolean(view.dryRunStaleReason)}
+            onClick={() => void facet.review()}
+          >
+            {view.reviewStatus === "running" ? "Reviewing..." : "Review upload"}
+          </Button>
+          <Button
+            variant="primary"
+            type="button"
+            disabled={uploadRunning || Boolean(view.reviewStaleReason) || !view.review?.Token}
+            onClick={() => void facet.start()}
+          >
+            {uploadRunning ? "Uploading..." : "Start upload"}
+          </Button>
+          {uploadRunning ? (
+            <button className="danger" type="button" onClick={() => void facet.cancel()}>
+              Cancel upload
+            </button>
+          ) : null}
+          {failedTrackers.length ? (
+            <button className="ghost" type="button" onClick={() => void facet.retry()}>
+              Retry failed
+            </button>
+          ) : null}
+        </div>
+        {view.dryRunStaleReason ? <p className="muted">Dry run: {view.dryRunStaleReason}</p> : null}
+        {view.reviewStaleReason ? <p className="muted">Review: {view.reviewStaleReason}</p> : null}
+        {view.error ? (
+          <p className="error" role="alert">
+            {view.error}
+          </p>
+        ) : null}
+        {view.transientError ? (
+          <p className="muted">Live update interrupted: {view.transientError}</p>
+        ) : null}
+      </section>
+
+      {(view.dryRun?.Trackers || []).map((entry) => {
+        const files = entry.Files || [];
+        const questionnaireFields = entry.Questionnaire?.Fields || [];
+        const ruleDecisions = entry.Diagnostics?.RuleDecisions || [];
+        const duplicate = entry.Diagnostics?.Duplicate;
+        const duplicateMatches = duplicate?.Filtered?.length
+          ? duplicate.Filtered
+          : duplicate?.Raw || [];
+        const liveReasons = entry.Diagnostics?.LiveEligibilityReasons || [];
+        return (
+          <section className="panel grid gap-3" key={entry.Tracker}>
+            <div className="flex flex-wrap items-center justify-between gap-2">
+              <h2>{entry.Tracker}</h2>
+              <span className="muted">{entry.Status || "pending"}</span>
+            </div>
+            {entry.Message ? <p className="muted">{entry.Message}</p> : null}
+            {ruleDecisions.length ? (
+              <div className="grid gap-2">
+                <h3 className="text-sm font-semibold">Rule diagnostics</h3>
+                {ruleDecisions.map((decision) => {
+                  const disposition = String(decision.Disposition || "waivable");
+                  const waivable = disposition === "waivable";
+                  const authorized = Boolean(
+                    view.authorizedRulesByTracker[entry.Tracker]?.includes(decision.Rule),
+                  );
+                  return (
+                    <div
+                      className="flex flex-wrap items-center justify-between gap-2 rounded border border-white/10 bg-white/5 p-2"
+                      key={`${entry.Tracker}-${decision.Rule}`}
+                    >
+                      <span>
+                        <strong>{decision.Rule}</strong> [{disposition}]
+                        {decision.Reason ? ` — ${decision.Reason}` : ""}
+                      </span>
+                      {waivable ? (
+                        <label className="flex items-center gap-2 text-xs font-semibold">
+                          <span>Authorize</span>
+                          <input
+                            aria-label={`Authorize ${decision.Rule} for ${entry.Tracker}`}
+                            type="checkbox"
+                            checked={authorized}
+                            onChange={(event) =>
+                              facet.setRuleAuthorized(
+                                entry.Tracker,
+                                decision.Rule,
+                                event.target.checked,
+                              )
+                            }
+                          />
+                        </label>
+                      ) : null}
+                    </div>
+                  );
+                })}
+              </div>
+            ) : null}
+            {duplicate &&
+            (duplicate.HasDupes || duplicate.Skipped || duplicate.Error || duplicate.Status) ? (
+              <div className="grid gap-1">
+                <h3 className="text-sm font-semibold">Duplicate diagnostics</h3>
+                <p className="muted">
+                  Status: {duplicate.Status || "unknown"} · Potential matches:{" "}
+                  {duplicateMatches.length}
+                </p>
+                {duplicate.SkipReason ? <p className="muted">{duplicate.SkipReason}</p> : null}
+                {duplicate.Error ? <p className="error">{duplicate.Error}</p> : null}
+                {duplicateMatches.length ? (
+                  <ul className="m-0 grid gap-1 pl-4">
+                    {duplicateMatches.map((match, index) => (
+                      <li key={`${match.ID || match.Name}-${index}`}>{match.Name || match.ID}</li>
+                    ))}
+                  </ul>
+                ) : null}
+              </div>
+            ) : null}
+            {liveReasons.length ? (
+              <p className="muted">
+                Live upload: {liveReasons.map((reason) => reason.Message).join(" ")}
+              </p>
+            ) : null}
+            <dl className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-2">
+              <div>
+                <dt className="label">Release name</dt>
+                <dd className="value break-all">
+                  {entry.UploadReleaseName || entry.ReleaseName || "-"}
+                </dd>
+              </div>
+              <div>
+                <dt className="label">Description group</dt>
+                <dd className="value">{entry.DescriptionGroup || "-"}</dd>
+              </div>
+              <div>
+                <dt className="label">Files ready</dt>
+                <dd className="value">
+                  {files.filter((file) => file.Present).length}/{files.length}
+                </dd>
+              </div>
+            </dl>
+            {entry.Endpoint ? (
+              <div className="grid gap-1">
+                <h3 className="text-sm font-semibold">Endpoint</h3>
+                <p className="value break-all">
+                  {formatDryRunPayloadValue("endpoint", entry.Endpoint)}
+                </p>
+              </div>
+            ) : null}
+            {entry.DebugSections?.length ? (
+              <div className="grid gap-2">
+                <h3 className="text-sm font-semibold">Debug sections</h3>
+                {entry.DebugSections.map((section, sectionIndex) => (
+                  <div
+                    className="grid gap-2 rounded border border-white/10 bg-white/5 p-2"
+                    key={`${section.Title || "debug-section"}-${sectionIndex}`}
+                  >
+                    <h4 className="label">{section.Title || "Debug section"}</h4>
+                    {section.Endpoint ? (
+                      <p className="value break-all">
+                        {formatDryRunPayloadValue("endpoint", section.Endpoint)}
+                      </p>
+                    ) : null}
+                    {(section.Files || []).map((file, fileIndex) => (
+                      <div key={dryRunFileKey(file, fileIndex)}>
+                        <p className="label">
+                          File · {file.Field} · {file.Present ? "present" : "missing"}
+                        </p>
+                        <p className="value break-all">{formatDryRunFilePath(file.Path)}</p>
+                      </div>
+                    ))}
+                    {Object.entries(section.Payload || {})
+                      .sort(([left], [right]) => left.localeCompare(right))
+                      .map(([key, value]) => (
+                        <div key={key}>
+                          <p className="label">{key}</p>
+                          <p className="value break-all">{formatDryRunPayloadValue(key, value)}</p>
+                        </div>
+                      ))}
+                  </div>
+                ))}
+              </div>
+            ) : null}
+            {files.length ? (
+              <div className="grid gap-2">
+                <h3 className="text-sm font-semibold">Files</h3>
+                {files.map((file, fileIndex) => (
+                  <div
+                    className="rounded border border-white/10 bg-white/5 p-2"
+                    key={dryRunFileKey(file, fileIndex)}
+                  >
+                    <p className="label">
+                      {file.Field} · {file.Present ? "present" : "missing"}
+                    </p>
+                    <p className="value break-all">{formatDryRunFilePath(file.Path)}</p>
+                  </div>
+                ))}
+              </div>
+            ) : null}
+            {Object.keys(entry.Payload || {}).length ? (
+              <div className="grid gap-2">
+                <h3 className="text-sm font-semibold">Payload</h3>
+                {Object.entries(entry.Payload || {})
+                  .sort(([left], [right]) => left.localeCompare(right))
+                  .map(([key, value]) => (
+                    <div className="rounded border border-white/10 bg-white/5 p-2" key={key}>
+                      <p className="label">{key}</p>
+                      <p className="value break-all">{formatDryRunPayloadValue(key, value)}</p>
+                    </div>
+                  ))}
+              </div>
+            ) : null}
+            {questionnaireFields.map((field) => (
+              <label className="grid gap-1" key={field.Key}>
+                <span className="label">
+                  {field.Label || field.Key}
+                  {field.Required ? " *" : ""}
+                </span>
+                {field.Kind === "select" ? (
+                  <select
+                    value={
+                      view.questionnaireAnswers[entry.Tracker]?.[field.Key] ?? field.Value ?? ""
+                    }
+                    onChange={(event) =>
+                      facet.answerQuestionnaire(entry.Tracker, field.Key, event.target.value)
+                    }
+                  >
+                    <option value="">Select</option>
+                    {(field.Options || []).map((option) => (
+                      <option key={option} value={option}>
+                        {option}
+                      </option>
+                    ))}
+                  </select>
+                ) : (
+                  <input
+                    value={
+                      view.questionnaireAnswers[entry.Tracker]?.[field.Key] ?? field.Value ?? ""
+                    }
+                    placeholder={field.Placeholder}
+                    onChange={(event) =>
+                      facet.answerQuestionnaire(entry.Tracker, field.Key, event.target.value)
+                    }
+                  />
+                )}
+                {field.Help ? <span className="muted text-xs">{field.Help}</span> : null}
+              </label>
+            ))}
+          </section>
+        );
+      })}
+
+      {view.snapshot ? (
+        <section className="panel grid gap-2">
+          <div className="flex flex-wrap items-center justify-between gap-2">
+            <h2>Upload job</h2>
+            <span className="muted">{view.snapshot.status.replaceAll("_", " ")}</span>
+          </div>
+          {view.snapshot.currentMessage ? <p>{view.snapshot.currentMessage}</p> : null}
+          <p className="muted">
+            Uploaded {view.snapshot.uploadedCount} · Failed {failedTrackers.length}
+          </p>
+          {snapshotTrackers.map((tracker) => (
+            <div
+              className="flex items-center justify-between gap-2 rounded border border-white/10 bg-white/5 p-2"
+              key={tracker.tracker}
+            >
+              <span>{tracker.tracker}</span>
+              <span className="muted">{tracker.status}</span>
+            </div>
+          ))}
+        </section>
+      ) : null}
+    </section>
+  );
+}
diff --git a/webui/src/pages/upload_images/index.test.tsx b/webui/src/pages/upload_images/index.test.tsx
new file mode 100644
index 00000000..7092e4b8
--- /dev/null
+++ b/webui/src/pages/upload_images/index.test.tsx
@@ -0,0 +1,139 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { UploadedImagesFacet } from "../../releaseSession/types";
+import UploadImagesPage from "./index";
+
+afterEach(cleanup);
+
+describe("UploadImagesPage", () => {
+  it("forwards explicit upload intent", () => {
+    const upload = vi.fn(async () => true);
+    const facet: UploadedImagesFacet = {
+      view: {
+        revision: 1,
+        status: "ready",
+        candidates: [
+          {
+            image: {
+              Index: 0,
+              TimestampSeconds: 1,
+              Path: "C:\\managed\\shot.png",
+              Purpose: "final",
+              Width: 1920,
+              Height: 1080,
+              SizeBytes: 1,
+            },
+            dataURI: "data:image/png;base64,AA==",
+          },
+        ],
+        uploaded: [],
+        selectedPaths: ["C:\\managed\\shot.png"],
+        host: "example",
+        failures: [],
+        progress: { correlationID: "", attempts: [] },
+        staleReason: "",
+        error: "",
+      },
+      load: vi.fn(async () => true),
+      chooseHost: vi.fn(),
+      select: vi.fn(),
+      selectAll: vi.fn(),
+      upload,
+      remove: vi.fn(async () => true),
+    };
+    render(
+      <UploadImagesPage
+        facet={facet}
+        configuredImageHosts={["example"]}
+        resolveImageHostLabel={(value) => value}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Upload selected (1)" }));
+    expect(upload).toHaveBeenCalledOnce();
+  });
+
+  it("shows live progress for each required image host", () => {
+    const facet: UploadedImagesFacet = {
+      view: {
+        revision: 2,
+        status: "running",
+        candidates: [],
+        uploaded: [],
+        selectedPaths: [],
+        host: "example",
+        failures: [],
+        progress: {
+          correlationID: "image-upload-1",
+          attempts: [
+            {
+              correlationID: "image-upload-1",
+              attemptID: "imgbox|global",
+              host: "imgbox",
+              usageScope: "global",
+              trackers: ["AITHER", "ANT"],
+              fallback: false,
+              completed: 1,
+              total: 3,
+              succeeded: 1,
+              failed: 0,
+              reused: 0,
+              status: "running",
+              message: "Uploading images.",
+              timestamp: "2026-07-16T00:00:00Z",
+            },
+            {
+              correlationID: "image-upload-1",
+              attemptID: "pixhost|tracker:RF",
+              host: "pixhost",
+              usageScope: "tracker:RF",
+              trackers: ["RF"],
+              fallback: true,
+              completed: 2,
+              total: 3,
+              succeeded: 2,
+              failed: 0,
+              reused: 0,
+              status: "running",
+              message: "Uploading images.",
+              timestamp: "2026-07-16T00:00:01Z",
+            },
+          ],
+        },
+        staleReason: "",
+        error: "",
+      },
+      load: vi.fn(async () => true),
+      chooseHost: vi.fn(),
+      select: vi.fn(),
+      selectAll: vi.fn(),
+      upload: vi.fn(async () => true),
+      remove: vi.fn(async () => true),
+    };
+
+    render(
+      <UploadImagesPage
+        facet={facet}
+        configuredImageHosts={["example"]}
+        resolveImageHostLabel={(value) => value}
+        setLightboxImage={vi.fn()}
+        setLightboxAlt={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByRole("progressbar", { name: "Image host upload progress" })).toHaveAttribute(
+      "aria-valuenow",
+      "3",
+    );
+    expect(
+      screen.getByText("3 of 6 image-host uploads processed across 2 hosts."),
+    ).toBeInTheDocument();
+    expect(screen.getByText("imgbox")).toBeInTheDocument();
+    expect(screen.getByText(/2 trackers/)).toBeInTheDocument();
+    expect(screen.getByText(/RF · fallback/)).toBeInTheDocument();
+  });
+});
diff --git a/webui/src/pages/upload_images/index.tsx b/webui/src/pages/upload_images/index.tsx
new file mode 100644
index 00000000..db63b739
--- /dev/null
+++ b/webui/src/pages/upload_images/index.tsx
@@ -0,0 +1,258 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { useEffect, useMemo, useRef } from "react";
+import { Button } from "../../components/ui/button";
+import type { UploadedImagesFacet } from "../../releaseSession/types";
+import type { UploadedImageLink } from "../../types";
+import { handleExternalLinkClick } from "../../utils/externalLinks";
+
+type Props = Readonly<{
+  facet: UploadedImagesFacet;
+  configuredImageHosts: readonly string[];
+  resolveImageHostLabel: (value: string) => string;
+  setLightboxImage: (value: string) => void;
+  setLightboxAlt: (value: string) => void;
+}>;
+
+const linkFor = (item: UploadedImageLink) => item.WebURL || item.ImgURL || item.RawURL;
+
+/** Presents exact-generation image-host candidates, upload progress, and results. */
+export default function UploadImagesPage({
+  facet,
+  configuredImageHosts,
+  resolveImageHostLabel,
+  setLightboxImage,
+  setLightboxAlt,
+}: Props) {
+  const { view } = facet;
+  const loadRef = useRef(facet.load);
+  loadRef.current = facet.load;
+
+  useEffect(() => {
+    if (view.status === "idle" && view.staleReason) void loadRef.current();
+  }, [view.staleReason, view.status]);
+
+  const selected = useMemo(() => new Set(view.selectedPaths), [view.selectedPaths]);
+  const selectedCount = view.candidates.filter((item) => selected.has(item.image.Path)).length;
+  const busy = view.status === "running";
+  const attempts = view.progress.attempts;
+  const progressTotal = attempts.reduce((total, attempt) => total + attempt.total, 0);
+  const progressCurrent = attempts.reduce(
+    (total, attempt) => total + Math.min(attempt.completed, attempt.total),
+    0,
+  );
+  const uploading = busy && Boolean(view.progress.correlationID);
+  const progressPercent =
+    progressTotal > 0 ? Math.round((progressCurrent / progressTotal) * 100) : 0;
+
+  return (
+    <section className="flex flex-col gap-4">
+      <header className="max-w-3xl">
+        <p className="eyebrow">Image Hosting</p>
+        <h1>Upload Images</h1>
+        <p className="subtitle">Choose final images and publish them to a configured host.</p>
+      </header>
+
+      <section className="panel grid gap-3">
+        <div className="flex flex-wrap items-end gap-3">
+          <label className="grid min-w-52 gap-1">
+            <span className="label">Image host</span>
+            <select value={view.host} onChange={(event) => facet.chooseHost(event.target.value)}>
+              <option value="">Select image host</option>
+              {configuredImageHosts.map((host) => (
+                <option key={host} value={host}>
+                  {resolveImageHostLabel(host)}
+                </option>
+              ))}
+            </select>
+          </label>
+          <Button
+            type="button"
+            variant="primary"
+            disabled={busy || !view.host || selectedCount === 0}
+            onClick={() => void facet.upload()}
+          >
+            {uploading
+              ? "Uploading images..."
+              : busy
+                ? "Working..."
+                : `Upload selected (${selectedCount})`}
+          </Button>
+          <button
+            className="ghost"
+            type="button"
+            disabled={busy}
+            onClick={() => facet.selectAll(true)}
+          >
+            Select all
+          </button>
+          <button
+            className="ghost"
+            type="button"
+            disabled={busy}
+            onClick={() => facet.selectAll(false)}
+          >
+            Clear
+          </button>
+        </div>
+        {uploading ? (
+          <div className="grid gap-2" aria-live="polite">
+            {progressTotal > 0 ? (
+              <div
+                aria-label="Image host upload progress"
+                aria-valuemax={progressTotal}
+                aria-valuemin={0}
+                aria-valuenow={progressCurrent}
+                className="h-4 w-full overflow-hidden rounded-full border border-white/10 bg-white/10"
+                role="progressbar"
+              >
+                <div
+                  className="h-full rounded-full bg-[var(--accent-2)] transition-[width]"
+                  style={{ width: `${progressPercent}%` }}
+                />
+              </div>
+            ) : null}
+            <p className="m-0 text-center text-sm text-[var(--muted)]">
+              {progressTotal > 0
+                ? `${progressCurrent} of ${progressTotal} image-host uploads processed across ${attempts.length} ${attempts.length === 1 ? "host" : "hosts"}.`
+                : "Resolving required image hosts..."}
+            </p>
+            {attempts.length ? (
+              <div className="grid gap-2">
+                {attempts.map((attempt) => {
+                  const trackerDetail =
+                    attempt.trackers.length === 1
+                      ? attempt.trackers[0]
+                      : `${attempt.trackers.length} trackers`;
+                  const resultDetail =
+                    attempt.status === "completed"
+                      ? `${attempt.total} ready`
+                      : attempt.status === "failed"
+                        ? `${attempt.succeeded + attempt.reused} ready, ${attempt.failed} failed`
+                        : `${attempt.completed}/${attempt.total} processed`;
+                  return (
+                    <div
+                      className="flex flex-wrap items-center justify-between gap-2 rounded border border-white/10 bg-white/5 px-3 py-2 text-sm"
+                      key={attempt.attemptID}
+                    >
+                      <div>
+                        <span className="font-semibold">{resolveImageHostLabel(attempt.host)}</span>
+                        <span className="muted">
+                          {" · "}
+                          {trackerDetail || attempt.usageScope}
+                          {attempt.fallback ? " · fallback" : ""}
+                        </span>
+                      </div>
+                      <span className={attempt.status === "failed" ? "error" : "muted"}>
+                        {resultDetail}
+                      </span>
+                    </div>
+                  );
+                })}
+              </div>
+            ) : null}
+          </div>
+        ) : null}
+        {view.error ? (
+          <p className="error" role="alert">
+            {view.error}
+          </p>
+        ) : null}
+        {view.failures.map((failure) => (
+          <p className="error" key={`${failure.Host}-${failure.UsageScope}`}>
+            {failure.Host || "Image host"}: {failure.Message}
+          </p>
+        ))}
+      </section>
+
+      <section className="panel grid gap-3">
+        <div className="flex items-baseline justify-between gap-3">
+          <h2>Available images</h2>
+          <span className="muted">{view.candidates.length} found</span>
+        </div>
+        {view.candidates.length ? (
+          <div className="grid grid-cols-[repeat(auto-fit,minmax(180px,1fr))] gap-3">
+            {view.candidates.map((item, index) => {
+              const imagePath = item.image.Path;
+              const checked = selected.has(imagePath);
+              return (
+                <article className="grid gap-2" key={imagePath}>
+                  <button
+                    className="screens-thumb"
+                    type="button"
+                    aria-label={`Preview image ${index + 1}`}
+                    onClick={() => {
+                      setLightboxImage(item.dataURI);
+                      setLightboxAlt(`Upload image ${index + 1}`);
+                    }}
+                  >
+                    <img src={item.dataURI} alt="" />
+                  </button>
+                  <label className="flex items-center gap-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={checked}
+                      onChange={(event) => facet.select(imagePath, event.target.checked)}
+                    />
+                    Include
+                  </label>
+                </article>
+              );
+            })}
+          </div>
+        ) : (
+          <p className="muted">No screenshot candidates available.</p>
+        )}
+      </section>
+
+      <section className="panel grid gap-3">
+        <div className="flex items-baseline justify-between gap-3">
+          <h2>Published images</h2>
+          <span className="muted">{view.uploaded.length} saved</span>
+        </div>
+        {view.uploaded.length ? (
+          <div className="grid gap-2">
+            {view.uploaded.map((item) => {
+              const url = linkFor(item);
+              return (
+                <article
+                  className="flex flex-wrap items-center justify-between gap-2 rounded border border-white/10 bg-white/5 p-2"
+                  key={`${item.Host}-${item.ImagePath}`}
+                >
+                  <div className="min-w-0">
+                    <p className="font-semibold">{resolveImageHostLabel(item.Host)}</p>
+                    {url ? (
+                      <a
+                        className="tracker-link break-all"
+                        href={url}
+                        target="_blank"
+                        rel="noreferrer"
+                        onAuxClick={handleExternalLinkClick}
+                        onClick={handleExternalLinkClick}
+                      >
+                        {url}
+                      </a>
+                    ) : (
+                      <p className="muted break-all">{item.ImagePath}</p>
+                    )}
+                  </div>
+                  <button
+                    className="danger"
+                    type="button"
+                    disabled={busy}
+                    onClick={() => void facet.remove(item.ImagePath, item.Host)}
+                  >
+                    Remove
+                  </button>
+                </article>
+              );
+            })}
+          </div>
+        ) : (
+          <p className="muted">No uploaded images yet.</p>
+        )}
+      </section>
+    </section>
+  );
+}
diff --git a/webui/src/releaseSession/index.test.tsx b/webui/src/releaseSession/index.test.tsx
new file mode 100644
index 00000000..fcab566e
--- /dev/null
+++ b/webui/src/releaseSession/index.test.tsx
@@ -0,0 +1,1091 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { ReactNode } from "react";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { JobRegistryProvider } from "../jobRegistry";
+import type { JobRegistryTransport } from "../jobRegistry";
+import type {
+  DescriptionBuilderPreview,
+  DVDMenuCaptureResult,
+  MetadataPreview,
+  OwnerJobSnapshot,
+  PlaylistInfo,
+  ScreenshotPlan,
+} from "../types";
+import { emptyExternalIdentity } from "../utils/canonicalIdentity";
+import {
+  ReleaseSessionProvider,
+  routeAccess,
+  trackerWorkflowRequirements,
+  useReleaseSession,
+} from ".";
+import type { PreparationCommand, ReleaseSessionPorts } from "./ports";
+
+const preview = (sourcePath: string, generation: number): MetadataPreview => ({
+  SourcePath: sourcePath,
+  TrackerName: "AITHER",
+  ReleaseName: "Example.Release.2026.1080p-GRP",
+  ReleaseNameOverrides: {},
+  Release: { SourcePath: sourcePath, Generation: generation },
+  Identity: { ...emptyExternalIdentity(sourcePath), Generation: generation },
+  Display: { ReleaseName: "Example.Release.2026.1080p-GRP", Providers: [] },
+  Bluray: null,
+  Diagnostics: [],
+  TrackerData: [],
+});
+
+const screenshotPlan = (sourcePath: string): ScreenshotPlan => ({
+  SourcePath: sourcePath,
+  DiscType: "",
+  DurationSeconds: 60,
+  FrameRate: 24,
+  SuggestedSelections: [],
+  ExistingScreenshots: [],
+  ExistingTrackerScreenshots: [],
+  FinalSelections: [],
+  TrackerImageLinks: [],
+  PreviewImages: [],
+  MetadataTimestamp: "",
+  RequiresManualFrames: false,
+});
+
+const dvdCaptureResult = (sourcePath: string): DVDMenuCaptureResult => ({
+  SourcePath: sourcePath,
+  Images: [],
+  SelectedLanguage: "en",
+  Region: 0,
+  DiscoveredMenus: 0,
+  VisitedStates: 0,
+  VisitedButtons: 0,
+  MaxItems: 6,
+  Complete: true,
+  Partial: false,
+  Truncated: false,
+  Warnings: [],
+  Engine: {
+    EngineVersion: "test",
+    SchemaVersion: 1,
+    SupportedFeatures: [],
+    FFmpegVersion: "test",
+    FFmpegDVDVideo: true,
+    MissingFFmpegOptions: [],
+  },
+});
+
+const completedDupeJob = (
+  sourcePath: string,
+  generation: number,
+  trackers: readonly string[] = ["AITHER"],
+): Extract<OwnerJobSnapshot, { kind: "duplicate_check" }> => ({
+  kind: "duplicate_check",
+  jobID: "dupe-job",
+  correlationID: "dupe-correlation",
+  release: { SourcePath: sourcePath, Generation: generation },
+  status: "completed",
+  startedAt: "2026-07-15T00:00:00Z",
+  finishedAt: "2026-07-15T00:00:01Z",
+  dupe: {
+    jobID: "dupe-job",
+    correlationID: "dupe-correlation",
+    release: { SourcePath: sourcePath, Generation: generation },
+    runtimeGeneration: 1,
+    status: "completed",
+    trackers: [],
+    completedCount: trackers.length,
+    totalCount: trackers.length,
+    summary: {
+      SourcePath: sourcePath,
+      Results: [],
+      Notes: [],
+      Eligibility: {
+        Release: { SourcePath: sourcePath, Generation: generation },
+        Trackers: trackers.map((tracker) => ({
+          Tracker: tracker,
+          Eligible: true,
+          Reasons: [],
+          RuleDecisions: [],
+        })),
+        EligibleTrackers: [...trackers],
+      },
+    },
+    startedAt: "2026-07-15T00:00:00Z",
+    finishedAt: "2026-07-15T00:00:01Z",
+  },
+});
+
+const runningDupeJob = (
+  sourcePath: string,
+  generation: number,
+  trackers: readonly string[] = ["AITHER"],
+): Extract<OwnerJobSnapshot, { kind: "duplicate_check" }> => {
+  const completed = completedDupeJob(sourcePath, generation, trackers);
+  return {
+    ...completed,
+    status: "running",
+    finishedAt: "",
+    dupe: {
+      ...completed.dupe,
+      status: "running",
+      trackers: trackers.map((tracker) => ({
+        tracker,
+        status: "running",
+        message: "checking tracker auth",
+        result: {} as never,
+        startedAt: completed.startedAt,
+        finishedAt: "",
+      })),
+      completedCount: 0,
+      summary: {
+        ...completed.dupe.summary,
+        Eligibility: {
+          Release: completed.release,
+          Trackers: [],
+          EligibleTrackers: [],
+        },
+      },
+      finishedAt: "",
+    },
+  };
+};
+
+const createDeferred = <T,>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+};
+
+const defaultJobTransport = (): JobRegistryTransport => ({
+  list: async () => [],
+  subscribe: () => () => undefined,
+  startDupe: async () => "dupe-job",
+  startUpload: async () => "upload-job",
+  retryUpload: async () => "retry-job",
+  cancelDupe: async () => undefined,
+  cancelUpload: async () => undefined,
+});
+
+type PortOverrides = Readonly<{
+  prepare?: ReleaseSessionPorts["preparation"]["execute"];
+  detectDiscType?: ReleaseSessionPorts["preparation"]["detectDiscType"];
+  discoverPlaylists?: ReleaseSessionPorts["preparation"]["discoverPlaylists"];
+  screenshotsLoad?: ReleaseSessionPorts["screenshots"]["load"];
+  screenshotsGenerate?: ReleaseSessionPorts["screenshots"]["generate"];
+  screenshotsSaveFinal?: ReleaseSessionPorts["screenshots"]["saveFinal"];
+  uploadedImagesListCandidates?: ReleaseSessionPorts["uploadedImages"]["listCandidates"];
+  uploadedImagesListUploaded?: ReleaseSessionPorts["uploadedImages"]["listUploaded"];
+  uploadedImagesUpload?: ReleaseSessionPorts["uploadedImages"]["upload"];
+  descriptionsLoad?: ReleaseSessionPorts["descriptions"]["load"];
+  menuCapture?: ReleaseSessionPorts["menuImages"]["capture"];
+  dryRun?: ReleaseSessionPorts["upload"]["dryRun"];
+  review?: ReleaseSessionPorts["upload"]["review"];
+}>;
+
+const portsFor = (overrides: PortOverrides = {}): ReleaseSessionPorts => {
+  const execute = overrides.prepare ?? (async (command) => preview(command.sourcePath, 1));
+  return {
+    preparation: {
+      detectDiscType: overrides.detectDiscType ?? (async () => ""),
+      discoverPlaylists: overrides.discoverPlaylists ?? (async () => []),
+      execute,
+    },
+    screenshots: {
+      load: overrides.screenshotsLoad ?? (async (release) => screenshotPlan(release.SourcePath)),
+      generate:
+        overrides.screenshotsGenerate ??
+        (async (release, _selections, purpose) => ({
+          SourcePath: release.SourcePath,
+          Purpose: purpose,
+          Images: [],
+          Tonemapped: false,
+          UsedLibplacebo: false,
+          Errors: [],
+        })),
+      previewFrame: async () => "data:image/png;base64,example",
+      remove: async () => undefined,
+      removeTrackerURL: async () => undefined,
+      saveFinal: overrides.screenshotsSaveFinal ?? (async () => undefined),
+      readImage: async () => "data:image/png;base64,example",
+    },
+    menuImages: {
+      list: async () => [],
+      readImage: async () => "data:image/png;base64,example",
+      importPaths: async () => undefined,
+      capture: overrides.menuCapture ?? (async (release) => dvdCaptureResult(release.SourcePath)),
+      remove: async () => undefined,
+    },
+    uploadedImages: {
+      listCandidates: overrides.uploadedImagesListCandidates ?? (async () => []),
+      readImage: async () => "",
+      listUploaded: overrides.uploadedImagesListUploaded ?? (async () => []),
+      upload: overrides.uploadedImagesUpload ?? (async () => ({ Links: [], Failures: [] })),
+      remove: async () => undefined,
+    },
+    descriptions: {
+      load:
+        overrides.descriptionsLoad ??
+        (async (release): Promise<DescriptionBuilderPreview> => ({
+          SourcePath: release.SourcePath,
+          Groups: [],
+          ContentFailures: [],
+        })),
+      render: async (raw) => raw,
+      save: async (_release, groupKey, raw, trackers) => ({
+        GroupKey: groupKey,
+        Trackers: [...trackers],
+        Description: raw,
+        DescriptionHTML: raw,
+        RawDescription: raw,
+        RawDescriptionHTML: raw,
+        HasOverride: Boolean(raw),
+        ImageHost: {
+          Status: "",
+          Message: "",
+          Warnings: [],
+          Reuploaded: false,
+          SelectedHost: "",
+          AllowedHosts: [],
+        },
+      }),
+    },
+    upload: {
+      dryRun:
+        overrides.dryRun ??
+        (async (command) => ({ SourcePath: command.release.SourcePath, Trackers: [] })),
+      review:
+        overrides.review ??
+        (async (command) => ({
+          Review: {
+            SourcePath: command.release.SourcePath,
+            Trackers: [],
+            Eligibility: {
+              Release: command.release,
+              Trackers: [],
+              EligibleTrackers: [...command.trackers],
+            },
+          },
+          Token: "review-token",
+        })),
+    },
+  };
+};
+
+const wrapperFor = (
+  ports: ReleaseSessionPorts,
+  jobTransport: JobRegistryTransport = defaultJobTransport(),
+) =>
+  function Wrapper({ children }: Readonly<{ children: ReactNode }>) {
+    return (
+      <JobRegistryProvider ownerKey="test-owner" transport={jobTransport}>
+        <ReleaseSessionProvider ports={ports}>{children}</ReleaseSessionProvider>
+      </JobRegistryProvider>
+    );
+  };
+
+const selectAndPrepare = async (
+  result: { current: ReturnType<typeof useReleaseSession> },
+  sourcePath: string,
+) => {
+  act(() => result.current.input.updateSourceDraft(sourcePath));
+  act(() => result.current.input.selectSource(sourcePath));
+  act(() => result.current.upload.chooseTrackers(["AITHER"]));
+  await act(() => result.current.input.prepare());
+};
+
+describe("tracker workflow capabilities", () => {
+  const catalog = {
+    entries: [
+      {
+        name: "BTN",
+        family: "standalone",
+        baseURL: "https://btn.example.invalid",
+        uploadContentMode: "none" as const,
+        fields: [],
+        configured: true,
+      },
+      {
+        name: "ANT",
+        family: "standalone",
+        baseURL: "https://ant.example.invalid",
+        uploadContentMode: "screenshots" as const,
+        fields: [],
+        configured: true,
+      },
+      {
+        name: "AITHER",
+        family: "unit3d",
+        baseURL: "https://aither.example.invalid",
+        uploadContentMode: "description" as const,
+        fields: [],
+        configured: true,
+      },
+    ],
+    unsupported: [],
+  };
+
+  it("derives none, screenshot, mixed, and conservative unknown requirements", () => {
+    expect(trackerWorkflowRequirements(["BTN"], catalog)).toEqual({
+      needsImages: false,
+      needsDescriptions: false,
+    });
+    expect(trackerWorkflowRequirements(["ANT"], catalog)).toEqual({
+      needsImages: true,
+      needsDescriptions: false,
+    });
+    expect(trackerWorkflowRequirements(["BTN", "AITHER"], catalog)).toEqual({
+      needsImages: true,
+      needsDescriptions: true,
+    });
+    expect(trackerWorkflowRequirements(["UNKNOWN"], catalog)).toEqual({
+      needsImages: true,
+      needsDescriptions: true,
+    });
+  });
+
+  it("opens only applicable pages and blocks retained content failures", () => {
+    const none = routeAccess(
+      true,
+      false,
+      true,
+      trackerWorkflowRequirements(["BTN"], catalog),
+      true,
+      false,
+      false,
+    );
+    expect(none.screenshots.available).toBe(false);
+    expect(none.descriptions.available).toBe(false);
+    expect(none.upload.available).toBe(true);
+
+    const screenshots = routeAccess(
+      true,
+      false,
+      true,
+      trackerWorkflowRequirements(["ANT"], catalog),
+      true,
+      true,
+      false,
+    );
+    expect(screenshots.screenshots.available).toBe(true);
+    expect(screenshots.descriptions.available).toBe(false);
+    expect(screenshots.upload.available).toBe(false);
+    expect(screenshots.upload.reason).toContain("screenshot preparation");
+
+    const description = routeAccess(
+      true,
+      false,
+      true,
+      trackerWorkflowRequirements(["AITHER"], catalog),
+      false,
+      false,
+      true,
+    );
+    expect(description.screenshots.available).toBe(true);
+    expect(description.descriptions.available).toBe(true);
+    expect(description.upload.available).toBe(false);
+    expect(description.upload.reason).toContain("description preparation");
+  });
+});
+
+describe("useReleaseSession", () => {
+  it("keeps manual path typing as an unselected draft", () => {
+    const { result } = renderHook(useReleaseSession, { wrapper: wrapperFor(portsFor()) });
+
+    act(() => result.current.input.updateSourceDraft("C:\\media\\Example"));
+
+    expect(result.current.input.view.sourceDraft).toBe("C:\\media\\Example");
+    expect(result.current.identity.view.sourcePath).toBe("");
+    expect(result.current.identity.view.release).toBeNull();
+  });
+
+  it.each([
+    "C:\\media\\Example.Release.2026.mkv",
+    "C:\\media\\Example Season",
+    "C:\\media\\Example DVD\\VIDEO_TS",
+    "C:\\media\\Example Blu-ray",
+    "C:\\media\\Example Blu-ray\\BDMV",
+  ])("allows duplicate navigation for a prepared source shape: %s", async (sourcePath) => {
+    const { result } = renderHook(useReleaseSession, { wrapper: wrapperFor(portsFor()) });
+    act(() => result.current.input.selectSource(sourcePath));
+    await act(() =>
+      result.current.input.prepareSource(sourcePath, {
+        ...result.current.input.view.intent,
+        playlist: /Blu-ray/.test(sourcePath)
+          ? { Set: true, Selected: ["00001.mpls"], UseAll: false }
+          : result.current.input.view.intent.playlist,
+      }),
+    );
+
+    expect(result.current.navigation.view.access.duplicates).toEqual({
+      available: true,
+      reason: "",
+    });
+  });
+
+  it("discovers BDMV playlists and prepares with one direct playlist instruction", async () => {
+    const candidates: PlaylistInfo[] = [
+      { file: "00001.mpls", duration: 120, items: [], score: 1, edition: "" },
+      { file: "00002.mpls", duration: 240, items: [], score: 2, edition: "" },
+    ];
+    const prepare = vi.fn(async (command: PreparationCommand) => {
+      command.onProgress({
+        correlationID: command.correlationID,
+        phase: "bdinfo",
+        order: 350,
+        label: "Analyze Blu-ray playlists",
+        message: "Blu-ray analysis complete.",
+        status: "completed",
+        timestamp: "2026-07-16T00:00:00Z",
+      });
+      return preview(command.sourcePath, 1);
+    });
+    const discoverPlaylists = vi.fn(async () => candidates);
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({
+          prepare,
+          detectDiscType: async () => "BDMV",
+          discoverPlaylists,
+        }),
+      ),
+    });
+
+    act(() => result.current.input.selectSource("C:\\media\\Example Disc"));
+    act(() => result.current.input.chooseTrackers(["GRP"]));
+    await act(() => result.current.input.prepare());
+
+    expect(prepare).not.toHaveBeenCalled();
+    expect(discoverPlaylists).toHaveBeenCalledWith(
+      "C:\\media\\Example Disc",
+      expect.any(AbortSignal),
+    );
+    expect(result.current.input.view.playlist.required).toBe(true);
+    expect(result.current.input.view.playlist.candidates.map((item) => item.file)).toEqual([
+      "00002.mpls",
+      "00001.mpls",
+    ]);
+    expect(result.current.input.view.status).toBe("awaiting_input");
+    expect(result.current.input.view.playlist.status).toBe("awaiting_selection");
+    expect(
+      result.current.input.view.progress.steps.map((step) => [step.phase, step.status]),
+    ).toEqual([
+      ["disc_detection", "completed"],
+      ["playlist_discovery", "completed"],
+      ["playlist_selection", "awaiting_input"],
+    ]);
+    const correlationID = result.current.input.view.progress.correlationID;
+
+    act(() => result.current.input.choosePlaylists(["00002.mpls"], false));
+    await act(() => result.current.input.confirmPlaylists());
+
+    expect(prepare).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sourcePath: "C:\\media\\Example Disc",
+        operation: "prepare",
+        controls: { confirmBDMVRescan: false },
+        intent: expect.objectContaining({
+          playlist: { Set: true, Selected: ["00002.mpls"], UseAll: false },
+        }),
+      }),
+    );
+    expect(result.current.identity.view.release).toEqual({
+      SourcePath: "C:\\media\\Example Disc",
+      Generation: 1,
+    });
+    expect(result.current.input.view.progress.correlationID).toBe(correlationID);
+    expect(result.current.input.view.progress.status).toBe("ready");
+    expect(result.current.input.view.progress.steps).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ phase: "playlist_selection", status: "completed" }),
+        expect.objectContaining({ phase: "bdinfo", status: "completed" }),
+      ]),
+    );
+    expect(result.current.input.view.playlist).toMatchObject({
+      status: "complete",
+      required: false,
+      selected: ["00002.mpls"],
+    });
+  });
+
+  it("retries the same preparation with explicit BDMV rescan permission", async () => {
+    const prepare = vi.fn(async (command: PreparationCommand) => {
+      if (!command.controls.confirmBDMVRescan) {
+        throw Object.assign(new Error("Confirmation required."), {
+          failure: {
+            Code: "confirmation_required",
+            Operation: "preparation",
+            Message: "Blu-ray playlist changes require confirmation before rescanning.",
+            Recovery: "confirm",
+          },
+        });
+      }
+      return preview(command.sourcePath, 1);
+    });
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor({ prepare })),
+    });
+    const sourcePath = "C:\\media\\Example Disc";
+    const directIntent = {
+      ...result.current.input.view.intent,
+      playlist: { Set: true, Selected: ["00001.mpls"], UseAll: false },
+    };
+
+    act(() => result.current.input.selectSource(sourcePath));
+    await act(() => result.current.input.prepareSource(sourcePath, directIntent));
+
+    expect(result.current.input.view.failure?.Recovery).toBe("confirm");
+    await act(() => result.current.input.confirmBDMVRescan());
+
+    expect(prepare).toHaveBeenCalledTimes(2);
+    expect(prepare.mock.calls.map((call) => call[0].controls)).toEqual([
+      { confirmBDMVRescan: false },
+      { confirmBDMVRescan: true },
+    ]);
+    expect(result.current.identity.view.release).toEqual({ SourcePath: sourcePath, Generation: 1 });
+  });
+
+  it("binds exact generations and invalidates dependent facets on N+1", async () => {
+    let generation = 0;
+    const ports = portsFor({
+      prepare: async (command) => preview(command.sourcePath, ++generation),
+    });
+    const { result } = renderHook(useReleaseSession, { wrapper: wrapperFor(ports) });
+
+    await selectAndPrepare(result, "C:\\media\\Example");
+    expect(result.current.identity.view.release).toEqual({
+      SourcePath: "C:\\media\\Example",
+      Generation: 1,
+    });
+    const firstRevision = result.current.screenshots.view.revision;
+
+    await act(() => result.current.input.prepare());
+    expect(result.current.identity.view.release?.Generation).toBe(2);
+    expect(result.current.screenshots.view.revision).toBeGreaterThan(firstRevision);
+    expect(result.current.screenshots.view.staleReason).toBe("Prepared generation changed.");
+  });
+
+  it("aborts and suppresses stale preparation completion after source replacement", async () => {
+    const first = createDeferred<MetadataPreview>();
+    let firstSignal: AbortSignal | undefined;
+    const prepare = vi.fn(async (command: PreparationCommand) => {
+      if (command.sourcePath.endsWith("First")) {
+        firstSignal = command.signal;
+        return first.promise;
+      }
+      return preview(command.sourcePath, 1);
+    });
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor({ prepare })),
+    });
+
+    act(() => result.current.input.selectSource("C:\\media\\First"));
+    act(() => result.current.upload.chooseTrackers(["AITHER"]));
+    let firstCommand!: Promise<boolean>;
+    act(() => {
+      firstCommand = result.current.input.prepare();
+    });
+    await waitFor(() => expect(prepare).toHaveBeenCalledTimes(1));
+
+    act(() => result.current.input.selectSource("C:\\media\\Second"));
+    expect(firstSignal?.aborted).toBe(true);
+    act(() => result.current.upload.chooseTrackers(["AITHER"]));
+    await act(() => result.current.input.prepare());
+
+    first.resolve(preview("C:\\media\\First", 1));
+    await act(() => firstCommand);
+    expect(result.current.identity.view.sourcePath).toBe("C:\\media\\Second");
+  });
+
+  it("rejects stale progress and completion from an older same-source attempt", async () => {
+    const first = createDeferred<MetadataPreview>();
+    let firstCommand: PreparationCommand | null = null;
+    let calls = 0;
+    const execute = vi.fn(async (command: PreparationCommand) => {
+      calls += 1;
+      if (calls === 1) {
+        firstCommand = command;
+        return first.promise;
+      }
+      command.onProgress({
+        correlationID: command.correlationID,
+        phase: "preview_projection",
+        order: 1200,
+        label: "Build metadata preview",
+        message: "Current attempt.",
+        status: "completed",
+        timestamp: "2026-07-16T00:00:01Z",
+      });
+      return preview(command.sourcePath, 2);
+    });
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor({ prepare: execute })),
+    });
+    const sourcePath = "C:\\media\\Example";
+    act(() => result.current.input.selectSource(sourcePath));
+
+    let firstResult!: Promise<boolean>;
+    act(() => {
+      firstResult = result.current.input.prepare();
+    });
+    await waitFor(() => expect(execute).toHaveBeenCalledTimes(1));
+    await act(() => result.current.input.prepare());
+
+    const staleCommand = firstCommand as PreparationCommand | null;
+    if (!staleCommand) throw new Error("first preparation command was not captured");
+    staleCommand.onProgress({
+      correlationID: staleCommand.correlationID,
+      phase: "stale_phase",
+      order: 1,
+      label: "Stale phase",
+      message: "Stale attempt.",
+      status: "completed",
+      timestamp: "2026-07-16T00:00:00Z",
+    });
+    first.resolve(preview(sourcePath, 1));
+    await act(() => firstResult);
+
+    expect(result.current.identity.view.release).toEqual({ SourcePath: sourcePath, Generation: 2 });
+    expect(
+      result.current.input.view.progress.steps.some((step) => step.phase === "stale_phase"),
+    ).toBe(false);
+  });
+
+  it("carries workflow drafts across same-source generations and clears them for another source", async () => {
+    const { result } = renderHook(useReleaseSession, { wrapper: wrapperFor(portsFor()) });
+    await selectAndPrepare(result, "C:\\media\\Example");
+    act(() => result.current.upload.chooseTrackers(["AITHER", "BLU"]));
+    act(() => result.current.upload.changeOptions({ noSeed: true, runLogLevel: "debug" }));
+    act(() => result.current.upload.answerQuestionnaire("AITHER", "season", "1"));
+
+    await act(() => result.current.input.prepare());
+    expect(result.current.upload.view.selectedTrackers).toEqual(["AITHER", "BLU"]);
+    expect(result.current.upload.view.options.noSeed).toBe(true);
+    expect(result.current.upload.view.options.runLogLevel).toBe("debug");
+    expect(result.current.upload.view.questionnaireAnswers.AITHER).toEqual({ season: "1" });
+
+    act(() => result.current.input.selectSource("C:\\media\\Other"));
+    expect(result.current.upload.view.selectedTrackers).toEqual([]);
+    expect(result.current.upload.view.options.noSeed).toBe(false);
+    expect(result.current.upload.view.options.runLogLevel).toBe("info");
+    expect(result.current.upload.view.questionnaireAnswers).toEqual({});
+  });
+
+  it("keeps independent facets concurrent and suppresses stale media completion", async () => {
+    const screenshot = createDeferred<ScreenshotPlan>();
+    const descriptionsLoad = vi.fn(async (release) => ({
+      SourcePath: release.SourcePath,
+      Groups: [],
+      ContentFailures: [],
+    }));
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob("C:\\media\\Example", 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({
+          screenshotsLoad: async () => screenshot.promise,
+          descriptionsLoad,
+        }),
+        jobTransport,
+      ),
+    });
+    await selectAndPrepare(result, "C:\\media\\Example");
+    await waitFor(() => expect(result.current.duplicates.view.status).toBe("ready"));
+
+    let screenshotCommand!: Promise<boolean>;
+    act(() => {
+      screenshotCommand = result.current.screenshots.load();
+    });
+    await act(() => result.current.descriptions.load());
+    expect(descriptionsLoad).toHaveBeenCalledTimes(1);
+
+    await act(() => result.current.input.prepare());
+    screenshot.resolve(screenshotPlan("C:\\media\\Example"));
+    await act(() => screenshotCommand);
+    expect(result.current.screenshots.view.plan).toBeNull();
+    expect(result.current.screenshots.view.staleReason).toBe("Prepared generation changed.");
+  });
+
+  it("persists generated final screenshots through the canonical session", async () => {
+    const sourcePath = "C:\\media\\Example";
+    const existing = {
+      Index: 0,
+      TimestampSeconds: 5,
+      Path: "C:\\tmp\\existing.png",
+      Purpose: "final" as const,
+      Width: 1920,
+      Height: 1080,
+      SizeBytes: 1024,
+    };
+    const generated = {
+      ...existing,
+      Index: 1,
+      TimestampSeconds: 10,
+      Path: "C:\\tmp\\generated.png",
+    };
+    const loadedPlan: ScreenshotPlan = {
+      ...screenshotPlan(sourcePath),
+      SuggestedSelections: [{ Index: 1, TimestampSeconds: 10, Frame: 240, Source: "auto" }],
+      FinalSelections: [existing],
+    };
+    const saveFinal = vi.fn(async () => undefined);
+    const generate = vi.fn(async () => ({
+      SourcePath: sourcePath,
+      Purpose: "final" as const,
+      Images: [generated],
+      Tonemapped: false,
+      UsedLibplacebo: false,
+      Errors: [],
+    }));
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob(sourcePath, 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({
+          screenshotsLoad: async () => loadedPlan,
+          screenshotsGenerate: generate,
+          screenshotsSaveFinal: saveFinal,
+        }),
+        jobTransport,
+      ),
+    });
+    await selectAndPrepare(result, sourcePath);
+    await waitFor(() =>
+      expect(result.current.navigation.view.access.screenshots.available).toBe(true),
+    );
+    await act(() => result.current.screenshots.load());
+    await act(() => result.current.screenshots.generate("final"));
+
+    expect(generate).toHaveBeenCalledWith(
+      { SourcePath: sourcePath, Generation: 1 },
+      [{ Index: 1, TimestampSeconds: 10, Frame: 240, Source: "auto" }],
+      "final",
+      expect.any(AbortSignal),
+    );
+    expect(saveFinal).toHaveBeenCalledWith(
+      { SourcePath: sourcePath, Generation: 1 },
+      [existing, generated],
+      expect.any(AbortSignal),
+    );
+    expect(result.current.screenshots.view.finalSelectionPaths).toEqual([
+      existing.Path,
+      generated.Path,
+    ]);
+
+    await act(() => result.current.screenshots.reorderFinal(1, 0));
+    expect(saveFinal).toHaveBeenLastCalledWith(
+      { SourcePath: sourcePath, Generation: 1 },
+      [generated, existing],
+      expect.any(AbortSignal),
+    );
+    expect(result.current.screenshots.view.finalSelectionPaths).toEqual([
+      generated.Path,
+      existing.Path,
+    ]);
+  });
+
+  it("cancels DVD menu capture as an abortable session media operation", async () => {
+    const capture = createDeferred<DVDMenuCaptureResult>();
+    let captureSignal: AbortSignal | undefined;
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob("C:\\media\\Example", 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({
+          menuCapture: async (_release, signal) => {
+            captureSignal = signal;
+            return capture.promise;
+          },
+        }),
+        jobTransport,
+      ),
+    });
+    await selectAndPrepare(result, "C:\\media\\Example");
+    await waitFor(() =>
+      expect(result.current.navigation.view.access.menuImages.available).toBe(true),
+    );
+
+    let command!: Promise<boolean>;
+    act(() => {
+      command = result.current.menuImages.capture();
+    });
+    await waitFor(() => expect(captureSignal).toBeDefined());
+    act(() => result.current.menuImages.cancelCapture());
+
+    expect(captureSignal?.aborted).toBe(true);
+    expect(result.current.menuImages.view.status).toBe("idle");
+    expect(result.current.menuImages.view.staleReason).toBe("Operation canceled.");
+    capture.resolve(dvdCaptureResult("C:\\media\\Example"));
+    await act(() => command);
+    expect(result.current.menuImages.view.capture).toBeNull();
+  });
+
+  it("does not hide dry run behind description save and marks authority stale after edits", async () => {
+    const dryRun = vi.fn(async (command) => ({
+      SourcePath: command.release.SourcePath,
+      Trackers: [],
+    }));
+    const descriptionPreview: DescriptionBuilderPreview = {
+      SourcePath: "C:\\media\\Example",
+      ContentFailures: [],
+      Groups: [
+        {
+          GroupKey: "unit3d",
+          Trackers: ["AITHER"],
+          Description: "generated",
+          DescriptionHTML: "generated",
+          RawDescription: "generated",
+          RawDescriptionHTML: "generated",
+          HasOverride: false,
+          ImageHost: {
+            Status: "",
+            Message: "",
+            Warnings: [],
+            Reuploaded: false,
+            SelectedHost: "",
+            AllowedHosts: [],
+          },
+        },
+      ],
+    };
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob("C:\\media\\Example", 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({ descriptionsLoad: async () => descriptionPreview, dryRun }),
+        jobTransport,
+      ),
+    });
+    await selectAndPrepare(result, "C:\\media\\Example");
+    await waitFor(() => expect(result.current.duplicates.view.status).toBe("ready"));
+    await act(() => result.current.descriptions.load());
+
+    act(() => result.current.descriptions.edit("unit3d", "edited"));
+    await act(() => result.current.descriptions.save("unit3d"));
+    expect(dryRun).not.toHaveBeenCalled();
+
+    await act(() => result.current.upload.runDryRun());
+    expect(result.current.upload.view.dryRunStatus).toBe("ready");
+    expect(dryRun).toHaveBeenCalledOnce();
+    expect(dryRun.mock.calls[0]?.[0].dupeJobID).toBe("dupe-job");
+    expect(dryRun.mock.calls[0]?.[0]).not.toHaveProperty("summary");
+    expect(dryRun.mock.calls[0]?.[0]).not.toHaveProperty("results");
+    act(() => result.current.upload.answerQuestionnaire("AITHER", "season", "2"));
+    expect(result.current.upload.view.dryRun).not.toBeNull();
+    expect(result.current.upload.view.dryRunStaleReason).toBe("Questionnaire answers changed.");
+    expect(await result.current.upload.review()).toBe(false);
+
+    act(() => result.current.upload.chooseTrackers(["AITHER", "BLU"]));
+    expect(await result.current.upload.runDryRun()).toBe(false);
+    expect(dryRun).toHaveBeenCalledOnce();
+  });
+
+  it("preserves an accepted Job start when the source session is replaced", async () => {
+    const start = createDeferred<string>();
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob("C:\\media\\Example", 1)],
+      startDupe: vi.fn(async () => start.promise),
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor(), jobTransport),
+    });
+    await selectAndPrepare(result, "C:\\media\\Example");
+
+    let command!: Promise<boolean>;
+    act(() => {
+      command = result.current.duplicates.run();
+    });
+    await waitFor(() => expect(jobTransport.startDupe).toHaveBeenCalledTimes(1));
+    expect(result.current.duplicates.view.status).toBe("running");
+    expect(result.current.duplicates.view.snapshot).toBeNull();
+    act(() => result.current.input.selectSource("C:\\media\\Other"));
+    start.resolve("dupe-job");
+
+    await expect(command).resolves.toBe(true);
+    expect(result.current.identity.view.sourcePath).toBe("C:\\media\\Other");
+  });
+
+  it("exposes running duplicate auth progress before terminal eligibility exists", async () => {
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [runningDupeJob("C:\\media\\Example", 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor(), jobTransport),
+    });
+
+    await selectAndPrepare(result, "C:\\media\\Example");
+    await waitFor(() => expect(result.current.duplicates.view.status).toBe("running"));
+
+    expect(result.current.duplicates.view.snapshot?.totalCount).toBe(1);
+    expect(result.current.duplicates.view.snapshot?.trackers[0]?.message).toBe(
+      "checking tracker auth",
+    );
+    expect(result.current.duplicates.view.eligibility?.Trackers).toEqual([]);
+  });
+
+  it("tracks selected and completed image uploads through the session facet", async () => {
+    const images: Awaited<ReturnType<ReleaseSessionPorts["uploadedImages"]["listCandidates"]>> = [
+      {
+        Index: 0,
+        TimestampSeconds: 1,
+        Path: "C:\\managed\\one.png",
+        Purpose: "final",
+        Width: 1920,
+        Height: 1080,
+        SizeBytes: 1,
+      },
+      {
+        Index: 1,
+        TimestampSeconds: 2,
+        Path: "C:\\managed\\two.png",
+        Purpose: "final",
+        Width: 1920,
+        Height: 1080,
+        SizeBytes: 1,
+      },
+    ];
+    const uploadResult =
+      createDeferred<Awaited<ReturnType<ReleaseSessionPorts["uploadedImages"]["upload"]>>>();
+    let uploaded: Awaited<ReturnType<ReleaseSessionPorts["uploadedImages"]["listUploaded"]>> = [];
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      list: async () => [completedDupeJob("C:\\media\\Example", 1)],
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(
+        portsFor({
+          uploadedImagesListCandidates: async () => images,
+          uploadedImagesListUploaded: async () => uploaded,
+          uploadedImagesUpload: async (uploadCommand) => {
+            uploadCommand.onProgress({
+              correlationID: uploadCommand.correlationID,
+              attemptID: "example|global",
+              host: "example",
+              usageScope: "global",
+              trackers: ["AITHER"],
+              fallback: false,
+              completed: 1,
+              total: 2,
+              succeeded: 1,
+              failed: 0,
+              reused: 0,
+              status: "running",
+              message: "Uploading images.",
+              timestamp: "2026-07-16T00:00:00Z",
+            });
+            const value = await uploadResult.promise;
+            uploadCommand.onProgress({
+              correlationID: uploadCommand.correlationID,
+              attemptID: "example|global",
+              host: "example",
+              usageScope: "global",
+              trackers: ["AITHER"],
+              fallback: false,
+              completed: 2,
+              total: 2,
+              succeeded: 2,
+              failed: 0,
+              reused: 0,
+              status: "completed",
+              message: "Host upload complete.",
+              timestamp: "2026-07-16T00:00:01Z",
+            });
+            uploaded = value.Links;
+            return value;
+          },
+        }),
+        jobTransport,
+      ),
+    });
+    await selectAndPrepare(result, "C:\\media\\Example");
+    await waitFor(() =>
+      expect(result.current.navigation.view.access.uploadedImages.available).toBe(true),
+    );
+    await act(() => result.current.uploadedImages.load());
+    act(() => result.current.uploadedImages.chooseHost("example"));
+
+    let command!: Promise<boolean>;
+    act(() => {
+      command = result.current.uploadedImages.upload();
+    });
+    await waitFor(() => expect(result.current.uploadedImages.view.status).toBe("running"));
+    expect(result.current.uploadedImages.view.progress.attempts).toEqual([
+      expect.objectContaining({ attemptID: "example|global", completed: 1, total: 2 }),
+    ]);
+
+    uploadResult.resolve({
+      Links: images.map((image) => ({
+        SourcePath: "C:\\media\\Example",
+        ImagePath: image.Path,
+        Host: "example",
+        UsageScope: "global",
+        ImgURL: `https://example.invalid/${image.Index}.png`,
+        RawURL: `https://example.invalid/${image.Index}.png`,
+        WebURL: `https://example.invalid/${image.Index}.png`,
+        SizeBytes: image.SizeBytes,
+        UploadedAt: "2026-07-16T00:00:00Z",
+      })),
+      Failures: [],
+    });
+    await act(() => command);
+
+    expect(result.current.uploadedImages.view.progress.attempts).toEqual([
+      expect.objectContaining({
+        attemptID: "example|global",
+        completed: 2,
+        total: 2,
+        status: "completed",
+      }),
+    ]);
+    expect(result.current.uploadedImages.view.status).toBe("ready");
+  });
+
+  it("preserves explicit-empty tracker intent and blocks duplicate start", async () => {
+    const jobTransport: JobRegistryTransport = {
+      ...defaultJobTransport(),
+      startDupe: vi.fn(async () => "dupe-job"),
+    };
+    const { result } = renderHook(useReleaseSession, {
+      wrapper: wrapperFor(portsFor(), jobTransport),
+    });
+    act(() => result.current.input.selectSource("C:\\media\\Example"));
+    await act(() => result.current.input.prepare());
+
+    expect(result.current.navigation.view.access.duplicates.available).toBe(true);
+
+    let started = true;
+    await act(async () => {
+      started = await result.current.duplicates.run();
+    });
+    expect(started).toBe(false);
+    expect(jobTransport.startDupe).not.toHaveBeenCalled();
+    expect(result.current.duplicates.view.error).toBe(
+      "Select at least one tracker to run duplicate checking.",
+    );
+
+    act(() => result.current.duplicates.chooseTrackers(["AITHER"]));
+    expect(result.current.input.view.preparationDirty).toBe(false);
+    await act(async () => {
+      started = await result.current.duplicates.run();
+    });
+    expect(started).toBe(true);
+    expect(jobTransport.startDupe).toHaveBeenCalledWith(
+      {
+        release: { SourcePath: "C:\\media\\Example", Generation: 1 },
+        trackers: ["AITHER"],
+      },
+      expect.any(String),
+    );
+  });
+});
diff --git a/webui/src/releaseSession/index.tsx b/webui/src/releaseSession/index.tsx
new file mode 100644
index 00000000..bb1adb1c
--- /dev/null
+++ b/webui/src/releaseSession/index.tsx
@@ -0,0 +1,1631 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { ReactNode } from "react";
+import { createContext, useContext, useEffect, useMemo, useReducer, useRef } from "react";
+import { useReleaseJobs } from "../jobRegistry";
+import { useTrackerCatalogSnapshot } from "../trackerCatalog";
+import type {
+  DVDMenuCaptureResult,
+  OperationFailure,
+  PreparationProgressUpdate,
+  ReleaseRef,
+  ScreenshotImage,
+  ScreenshotPlan,
+  ScreenshotPurpose,
+  ScreenshotResult,
+  ScreenshotSelection,
+  TrackerCatalog,
+  TrackerContentFailure,
+  UploadImageHostFailure,
+} from "../types";
+import type { DryRunCommand, ReleaseSessionPorts, UploadCommand } from "./ports";
+import { productionReleaseSessionPorts } from "./production";
+import { initialSessionState, sessionReducer } from "./reducer";
+import type {
+  PreparationIntent,
+  PreparationStep,
+  ReleaseRoute,
+  ReleaseSession,
+  RouteAccess,
+  UploadRunOptions,
+} from "./types";
+
+const emptyRelease: ReleaseRef = { SourcePath: "", Generation: 0 };
+const SessionContext = createContext<ReleaseSession | null>(null);
+
+type WorkflowFacet =
+  | "screenshots"
+  | "menuImages"
+  | "uploadedImages"
+  | "descriptions"
+  | "dryRun"
+  | "review";
+type ControllerKey = WorkflowFacet | "preparation" | "screenshotRead";
+type WorkflowCommand = Readonly<{
+  controller: AbortController;
+  release: ReleaseRef;
+  sessionRevision: number;
+  revision: number;
+}>;
+
+const errorText = (error: unknown) =>
+  error instanceof Error && error.message ? error.message : String(error);
+
+const operationFailureFromError = (error: unknown): OperationFailure | null => {
+  if (!error || typeof error !== "object" || !("failure" in error)) return null;
+  const failure = (error as { failure?: unknown }).failure;
+  if (!failure || typeof failure !== "object") return null;
+  const candidate = failure as Partial<OperationFailure>;
+  if (
+    typeof candidate.Code !== "string" ||
+    typeof candidate.Operation !== "string" ||
+    typeof candidate.Message !== "string" ||
+    typeof candidate.Recovery !== "string"
+  ) {
+    return null;
+  }
+  return candidate as OperationFailure;
+};
+
+const normalizedNames = (values: readonly string[]) =>
+  Array.from(new Set(values.map((value) => value.trim().toUpperCase()).filter(Boolean)));
+
+const sameNames = (left: readonly string[], right: readonly string[]) => {
+  const normalizedLeft = normalizedNames(left);
+  const normalizedRight = normalizedNames(right);
+  return (
+    normalizedLeft.length === normalizedRight.length &&
+    normalizedLeft.every((value, index) => value === normalizedRight[index])
+  );
+};
+
+const uniqueScreenshotImages = (images: readonly ScreenshotImage[]) => {
+  const paths = new Set<string>();
+  return images.filter((image) => {
+    const path = image.Path.trim();
+    if (!path || paths.has(path)) return false;
+    paths.add(path);
+    return true;
+  });
+};
+
+const availableScreenshotImages = (plan: ScreenshotPlan | null, result: ScreenshotResult | null) =>
+  uniqueScreenshotImages([
+    ...(plan?.ExistingScreenshots || []),
+    ...(plan?.ExistingTrackerScreenshots || []),
+    ...(plan?.FinalSelections || []),
+    ...(plan?.PreviewImages || []),
+    ...(result?.Images || []),
+  ]);
+
+const orderedScreenshotImages = (paths: readonly string[], images: readonly ScreenshotImage[]) => {
+  const byPath = new Map(images.map((image) => [image.Path, image]));
+  return paths.map((path) => byPath.get(path)).filter((image): image is ScreenshotImage => !!image);
+};
+
+const mergeFinalScreenshotImages = (
+  current: readonly ScreenshotImage[],
+  additions: readonly ScreenshotImage[],
+) => {
+  const merged = uniqueScreenshotImages(current);
+  const indexByPath = new Map(merged.map((image, index) => [image.Path, index]));
+  additions.forEach((image) => {
+    if (!image.Path) return;
+    const existingIndex = indexByPath.get(image.Path);
+    if (existingIndex !== undefined) {
+      merged[existingIndex] = image;
+      return;
+    }
+    const insertAt = merged.findIndex(
+      (entry) => image.TimestampSeconds > 0 && entry.TimestampSeconds > image.TimestampSeconds,
+    );
+    if (insertAt < 0) merged.push(image);
+    else merged.splice(insertAt, 0, image);
+    indexByPath.clear();
+    merged.forEach((entry, index) => indexByPath.set(entry.Path, index));
+  });
+  return merged;
+};
+
+const isCompleted = (status: string) =>
+  ["completed", "completed_with_errors"].includes(status.toLowerCase().trim());
+
+export type TrackerWorkflowRequirements = Readonly<{
+  needsImages: boolean;
+  needsDescriptions: boolean;
+}>;
+
+/** Derives the strictest content workflow required by the selected tracker set. */
+export const trackerWorkflowRequirements = (
+  selectedTrackers: readonly string[],
+  catalog: TrackerCatalog | null,
+): TrackerWorkflowRequirements => {
+  const modes = new Map(
+    (catalog?.entries ?? []).map((entry) => [
+      entry.name.trim().toUpperCase(),
+      entry.uploadContentMode,
+    ]),
+  );
+  let needsImages = false;
+  let needsDescriptions = false;
+  selectedTrackers.forEach((tracker) => {
+    const mode = modes.get(tracker.trim().toUpperCase()) ?? "description";
+    needsImages ||= mode === "screenshots" || mode === "description";
+    needsDescriptions ||= mode === "description";
+  });
+  return { needsImages, needsDescriptions };
+};
+
+const selectedContentFailure = (
+  failures: readonly TrackerContentFailure[] | undefined,
+  selectedTrackers: readonly string[],
+  code: TrackerContentFailure["code"],
+) => {
+  const selected = new Set(normalizedNames(selectedTrackers));
+  return Boolean(
+    failures?.some(
+      (failure) =>
+        failure.code === code &&
+        selected.has(
+          String(failure.tracker || "")
+            .trim()
+            .toUpperCase(),
+        ),
+    ),
+  );
+};
+
+export const routeAccess = (
+  bound: boolean,
+  hasTrackerData: boolean,
+  duplicatesReady: boolean,
+  requirements: TrackerWorkflowRequirements,
+  descriptionsReady: boolean,
+  screenshotFailed: boolean,
+  descriptionFailed: boolean,
+): Readonly<Record<ReleaseRoute, RouteAccess>> => {
+  const preparationReason = "Prepare the selected source first.";
+  const duplicateReason = duplicatesReady ? "" : "Complete duplicate checking first.";
+  const screenshotReason = requirements.needsImages
+    ? duplicateReason
+    : "Selected trackers do not use shared screenshots.";
+  const descriptionReason = requirements.needsDescriptions
+    ? duplicateReason
+    : "Selected trackers do not use shared descriptions.";
+  const uploadBlockedReason = screenshotFailed
+    ? "Retry failed screenshot preparation first."
+    : descriptionFailed
+      ? "Retry failed description preparation first."
+      : requirements.needsDescriptions && !descriptionsReady
+        ? "Prepare descriptions first."
+        : "";
+  return {
+    input: { available: true, reason: "" },
+    trackerData: {
+      available: bound && hasTrackerData,
+      reason: bound ? "No tracker data is available." : preparationReason,
+    },
+    duplicates: {
+      available: bound,
+      reason: bound ? "" : preparationReason,
+    },
+    screenshots: {
+      available: bound && duplicatesReady && requirements.needsImages,
+      reason: bound ? screenshotReason : preparationReason,
+    },
+    menuImages: {
+      available: bound && duplicatesReady,
+      reason: bound ? duplicateReason : preparationReason,
+    },
+    uploadedImages: {
+      available: bound && duplicatesReady && requirements.needsImages,
+      reason: bound ? screenshotReason : preparationReason,
+    },
+    descriptions: {
+      available: bound && duplicatesReady && requirements.needsDescriptions,
+      reason: bound ? descriptionReason : preparationReason,
+    },
+    upload: {
+      available: bound && duplicatesReady && uploadBlockedReason === "",
+      reason: bound ? duplicateReason || uploadBlockedReason : preparationReason,
+    },
+  };
+};
+
+const cloneIntent = (intent: PreparationIntent): PreparationIntent => ({
+  sourceLookupURL: intent.sourceLookupURL,
+  identity: { ...intent.identity },
+  releaseName: { ...intent.releaseName },
+  playlist: {
+    Set: intent.playlist.Set,
+    Selected: [...intent.playlist.Selected],
+    UseAll: intent.playlist.UseAll,
+  },
+});
+
+const inferredDiscType = (sourcePath: string) =>
+  /(^|[\\/])BDMV([\\/]|$)/i.test(sourcePath) ? "BDMV" : "";
+
+const localPreparationStep = (
+  phase: string,
+  order: number,
+  label: string,
+  status: PreparationStep["status"],
+  message: string,
+): PreparationStep => ({
+  phase,
+  order,
+  label,
+  message,
+  status,
+  timestamp: new Date().toISOString(),
+});
+
+const selectedDescriptionGroups = (
+  groups: readonly import("../types").DescriptionBuilderGroup[],
+  rawByGroup: Readonly<Record<string, string>>,
+) =>
+  groups.map((group) => ({
+    ...group,
+    Trackers: [...group.Trackers],
+    RawDescription: rawByGroup[group.GroupKey] ?? group.RawDescription,
+  }));
+
+/** Owns canonical release workflow state, cancellation, correlation, and transport ports. */
+export function ReleaseSessionProvider({
+  ports,
+  children,
+}: Readonly<{ ports?: ReleaseSessionPorts; children: ReactNode }>) {
+  const trackerCatalog = useTrackerCatalogSnapshot();
+  const [state, dispatch] = useReducer(sessionReducer, undefined, initialSessionState);
+  const controllers = useRef<Partial<Record<ControllerKey, AbortController>>>({});
+  const preparationRevision = useRef(0);
+  const lastPreparation = useRef<{
+    operation: "prepare" | "reset";
+    sourcePath: string;
+    intent: PreparationIntent;
+  } | null>(null);
+  const workflowRevisions = useRef<Partial<Record<WorkflowFacet, number>>>({});
+  const activePorts = useMemo(() => ports ?? productionReleaseSessionPorts(), [ports]);
+  const releaseJobs = useReleaseJobs(state.release ?? emptyRelease);
+
+  const abortController = (key: ControllerKey) => {
+    controllers.current[key]?.abort();
+    delete controllers.current[key];
+  };
+
+  const abortAll = () => {
+    Object.values(controllers.current).forEach((controller) => controller?.abort());
+    controllers.current = {};
+  };
+
+  useEffect(() => abortAll, []);
+
+  const selectSource = (value: string) => {
+    abortAll();
+    dispatch({ type: "source_selected", sourcePath: value });
+  };
+
+  const dispatchPreparationStep = (
+    sourcePath: string,
+    commandRevision: number,
+    correlationID: string,
+    step: PreparationStep,
+  ) =>
+    dispatch({
+      type: "preparation_progressed",
+      sourcePath,
+      commandRevision,
+      correlationID,
+      step,
+    });
+
+  const executePreparation = async (
+    operation: "prepare" | "reset" | "candidate",
+    sourcePath: string,
+    intent: PreparationIntent,
+    controls: Readonly<{ confirmBDMVRescan: boolean }>,
+    commandRevision: number,
+    correlationID: string,
+    controller: AbortController,
+    releaseID = "",
+  ): Promise<boolean> => {
+    try {
+      const preview = await activePorts.preparation.execute({
+        operation,
+        correlationID,
+        sourcePath,
+        intent,
+        controls,
+        releaseID,
+        signal: controller.signal,
+        onProgress: (update: PreparationProgressUpdate) =>
+          dispatchPreparationStep(sourcePath, commandRevision, correlationID, {
+            phase: update.phase,
+            order: update.order,
+            label: update.label,
+            message: update.message,
+            status: update.status,
+            timestamp: update.timestamp,
+          }),
+      });
+      dispatch({
+        type: "preparation_succeeded",
+        sourcePath,
+        commandRevision,
+        correlationID,
+        preview,
+      });
+      return !controller.signal.aborted;
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        dispatch({
+          type: "preparation_failed",
+          sourcePath,
+          commandRevision,
+          correlationID,
+          error: errorText(error),
+          failure: operationFailureFromError(error),
+        });
+      }
+      return false;
+    } finally {
+      if (controllers.current.preparation === controller) delete controllers.current.preparation;
+    }
+  };
+
+  const runPreparationFor = async (
+    operation: "prepare" | "reset",
+    requestedSource: string,
+    requestedIntent: PreparationIntent,
+    controls = { confirmBDMVRescan: false },
+  ): Promise<boolean> => {
+    const sourcePath = requestedSource.trim();
+    if (!sourcePath) return false;
+    if (sourcePath !== state.selectedSource) {
+      abortAll();
+      dispatch({ type: "source_selected", sourcePath });
+    }
+    abortController("preparation");
+    const controller = new AbortController();
+    controllers.current.preparation = controller;
+    const commandRevision = Math.max(preparationRevision.current + 1, state.commandRevision + 1);
+    preparationRevision.current = commandRevision;
+    const correlationID = `preparation-${Date.now().toString(36)}-${commandRevision.toString(36)}`;
+    const intent = cloneIntent(requestedIntent);
+    lastPreparation.current = { operation, sourcePath, intent };
+    dispatch({
+      type: "preparation_started",
+      sourcePath,
+      commandRevision,
+      correlationID,
+      intent,
+    });
+
+    if (intent.playlist.Set) {
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "playlist_selection",
+          40,
+          "Accept Blu-ray playlist selection",
+          "completed",
+          "Using the accepted playlist selection.",
+        ),
+      );
+      return executePreparation(
+        operation,
+        sourcePath,
+        intent,
+        controls,
+        commandRevision,
+        correlationID,
+        controller,
+      );
+    }
+
+    dispatchPreparationStep(
+      sourcePath,
+      commandRevision,
+      correlationID,
+      localPreparationStep(
+        "disc_detection",
+        10,
+        "Detect disc type",
+        "running",
+        "Inspecting source.",
+      ),
+    );
+    let discType = "";
+    try {
+      discType = (await activePorts.preparation.detectDiscType(sourcePath, controller.signal))
+        .trim()
+        .toUpperCase();
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "disc_detection",
+          10,
+          "Detect disc type",
+          "completed",
+          "Source inspected.",
+        ),
+      );
+    } catch {
+      if (controller.signal.aborted) {
+        if (controllers.current.preparation === controller) delete controllers.current.preparation;
+        return false;
+      }
+      discType = inferredDiscType(sourcePath);
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "disc_detection",
+          10,
+          "Detect disc type",
+          "completed",
+          "Source inspected using the path hint.",
+        ),
+      );
+    }
+
+    if (controller.signal.aborted) {
+      if (controllers.current.preparation === controller) delete controllers.current.preparation;
+      return false;
+    }
+
+    if (discType !== "BDMV") {
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "playlist_discovery",
+          20,
+          "Discover Blu-ray playlists",
+          "skipped",
+          "Source is not a Blu-ray disc.",
+        ),
+      );
+      return executePreparation(
+        operation,
+        sourcePath,
+        intent,
+        controls,
+        commandRevision,
+        correlationID,
+        controller,
+      );
+    }
+
+    dispatchPreparationStep(
+      sourcePath,
+      commandRevision,
+      correlationID,
+      localPreparationStep(
+        "playlist_discovery",
+        20,
+        "Discover Blu-ray playlists",
+        "running",
+        "Discovering playlists.",
+      ),
+    );
+    try {
+      const discovered = await activePorts.preparation.discoverPlaylists(
+        sourcePath,
+        controller.signal,
+      );
+      if (controller.signal.aborted) return false;
+      const candidates = [...discovered]
+        .sort((left, right) => (right.score || 0) - (left.score || 0))
+        .slice(0, 10);
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "playlist_discovery",
+          20,
+          "Discover Blu-ray playlists",
+          "completed",
+          `${candidates.length} playlist${candidates.length === 1 ? "" : "s"} found.`,
+        ),
+      );
+      dispatchPreparationStep(
+        sourcePath,
+        commandRevision,
+        correlationID,
+        localPreparationStep(
+          "playlist_selection",
+          30,
+          "Select Blu-ray playlists",
+          candidates.length ? "awaiting_input" : "failed",
+          candidates.length ? "Select one or more playlists." : "No Blu-ray playlists were found.",
+        ),
+      );
+      dispatch({
+        type: "playlist_required",
+        sourcePath,
+        commandRevision,
+        correlationID,
+        candidates,
+        error: candidates.length ? "" : "No BDMV playlists were found.",
+      });
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        dispatchPreparationStep(
+          sourcePath,
+          commandRevision,
+          correlationID,
+          localPreparationStep(
+            "playlist_discovery",
+            20,
+            "Discover Blu-ray playlists",
+            "failed",
+            "Playlist discovery failed.",
+          ),
+        );
+        dispatch({
+          type: "playlist_required",
+          sourcePath,
+          commandRevision,
+          correlationID,
+          candidates: [],
+          error: errorText(error),
+        });
+      }
+    } finally {
+      if (controllers.current.preparation === controller) delete controllers.current.preparation;
+    }
+    return false;
+  };
+
+  const runPreparation = (operation: "prepare" | "reset") =>
+    runPreparationFor(operation, state.selectedSource, state.preparationIntent);
+
+  const selectCandidate = async (releaseID: string): Promise<boolean> => {
+    const sourcePath = state.selectedSource.trim();
+    const candidateID = releaseID.trim();
+    if (!sourcePath || !candidateID) return false;
+    abortController("preparation");
+    const controller = new AbortController();
+    controllers.current.preparation = controller;
+    const commandRevision = Math.max(preparationRevision.current + 1, state.commandRevision + 1);
+    preparationRevision.current = commandRevision;
+    const correlationID = `preparation-${Date.now().toString(36)}-${commandRevision.toString(36)}`;
+    const intent = cloneIntent(state.preparationIntent);
+    dispatch({
+      type: "preparation_started",
+      sourcePath,
+      commandRevision,
+      correlationID,
+      intent,
+    });
+    return executePreparation(
+      "candidate",
+      sourcePath,
+      intent,
+      { confirmBDMVRescan: false },
+      commandRevision,
+      correlationID,
+      controller,
+      candidateID,
+    );
+  };
+
+  const beginWorkflow = (facet: WorkflowFacet, unavailableReason = ""): WorkflowCommand | null => {
+    if (controllers.current[facet]) return null;
+    const revision = Math.max(
+      (workflowRevisions.current[facet] || 0) + 1,
+      state[facet].revision + 1,
+    );
+    workflowRevisions.current[facet] = revision;
+    dispatch({ type: "workflow_started", facet, sessionRevision: state.sessionRevision, revision });
+    if (!state.release || unavailableReason) {
+      dispatch({
+        type: "workflow_failed",
+        facet,
+        sessionRevision: state.sessionRevision,
+        revision,
+        error: unavailableReason || "Prepare the selected source first.",
+      });
+      return null;
+    }
+    const controller = new AbortController();
+    controllers.current[facet] = controller;
+    return {
+      controller,
+      release: { ...state.release },
+      sessionRevision: state.sessionRevision,
+      revision,
+    };
+  };
+
+  const failWorkflow = (facet: WorkflowFacet, command: WorkflowCommand, error: unknown) => {
+    if (!command.controller.signal.aborted) {
+      dispatch({
+        type: "workflow_failed",
+        facet,
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        error: errorText(error),
+      });
+    }
+  };
+
+  const finishWorkflow = (facet: WorkflowFacet, command: WorkflowCommand) => {
+    if (controllers.current[facet] === command.controller) delete controllers.current[facet];
+  };
+
+  const loadScreenshotPlan = async (): Promise<boolean> => {
+    const command = beginWorkflow("screenshots", access.screenshots.reason);
+    if (!command) return false;
+    try {
+      const plan = await activePorts.screenshots.load(command.release, command.controller.signal);
+      dispatch({
+        type: "screenshots_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        plan,
+        reseedDrafts: true,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("screenshots", command, error);
+      return false;
+    } finally {
+      finishWorkflow("screenshots", command);
+    }
+  };
+
+  const mutateScreenshots = async (
+    mutate: (command: WorkflowCommand) => Promise<ScreenshotResult | null>,
+  ): Promise<boolean> => {
+    const command = beginWorkflow("screenshots", access.screenshots.reason);
+    if (!command) return false;
+    try {
+      const result = await mutate(command);
+      const plan = await activePorts.screenshots.load(command.release, command.controller.signal);
+      dispatch({
+        type: "screenshots_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        plan,
+        ...(result ? { result } : {}),
+        changed: true,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("screenshots", command, error);
+      return false;
+    } finally {
+      finishWorkflow("screenshots", command);
+    }
+  };
+
+  const generateScreenshots = async (
+    purpose: ScreenshotPurpose,
+    selections?: readonly ScreenshotSelection[],
+  ): Promise<boolean> => {
+    const command = beginWorkflow("screenshots", access.screenshots.reason);
+    if (!command) return false;
+    try {
+      const requested = [...(selections ?? state.screenshots.selections)];
+      const existingIndices = new Set(
+        [
+          ...(state.screenshots.value?.ExistingScreenshots || []),
+          ...(state.screenshots.value?.FinalSelections || []),
+          ...(state.screenshots.result?.Purpose === "final"
+            ? state.screenshots.result.Images || []
+            : []),
+        ].map((image) => image.Index),
+      );
+      const captureSelections =
+        purpose === "final"
+          ? requested.filter((selection) => !existingIndices.has(selection.Index))
+          : requested;
+      if (captureSelections.length === 0) {
+        throw new Error(
+          purpose === "final"
+            ? "All requested screenshots already exist."
+            : "No screenshot selections available.",
+        );
+      }
+      const result = await activePorts.screenshots.generate(
+        command.release,
+        captureSelections,
+        purpose,
+        command.controller.signal,
+      );
+      let finalSelectionPaths: readonly string[] | undefined;
+      if (purpose === "final") {
+        const available = availableScreenshotImages(
+          state.screenshots.value,
+          state.screenshots.result,
+        );
+        const current = orderedScreenshotImages(state.screenshots.finalSelectionPaths, available);
+        const finalImages = mergeFinalScreenshotImages(current, result.Images || []);
+        await activePorts.screenshots.saveFinal(
+          command.release,
+          finalImages,
+          command.controller.signal,
+        );
+        finalSelectionPaths = finalImages.map((image) => image.Path);
+      }
+      const plan = await activePorts.screenshots.load(command.release, command.controller.signal);
+      dispatch({
+        type: "screenshots_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        plan,
+        result,
+        changed: true,
+        ...(finalSelectionPaths ? { finalSelectionPaths } : {}),
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("screenshots", command, error);
+      return false;
+    } finally {
+      finishWorkflow("screenshots", command);
+    }
+  };
+
+  const persistFinalScreenshotPaths = async (imagePaths: readonly string[]) => {
+    const normalizedPaths = Array.from(
+      new Set(imagePaths.map((path) => path.trim()).filter(Boolean)),
+    );
+    const images = orderedScreenshotImages(
+      normalizedPaths,
+      availableScreenshotImages(state.screenshots.value, state.screenshots.result),
+    );
+    dispatch({ type: "screenshot_final_paths_changed", imagePaths: normalizedPaths });
+    return mutateScreenshots(async (command) => {
+      await activePorts.screenshots.saveFinal(command.release, images, command.controller.signal);
+      return null;
+    });
+  };
+
+  const removeScreenshots = async (imagePaths: readonly string[]) => {
+    const paths = Array.from(new Set(imagePaths.map((path) => path.trim()).filter(Boolean)));
+    if (paths.length === 0) return false;
+    const deletedPaths = new Set(paths);
+    const linkedURLs = (state.screenshots.value?.TrackerImageLinks || [])
+      .filter((link) => deletedPaths.has(link.Path))
+      .map((link) => link.URL)
+      .filter(Boolean);
+    const remainingFinalPaths = state.screenshots.finalSelectionPaths.filter(
+      (path) => !deletedPaths.has(path),
+    );
+    const remainingFinalImages = orderedScreenshotImages(
+      remainingFinalPaths,
+      availableScreenshotImages(state.screenshots.value, state.screenshots.result),
+    );
+    dispatch({ type: "screenshot_final_paths_changed", imagePaths: remainingFinalPaths });
+    return mutateScreenshots(async (command) => {
+      for (const path of paths) {
+        await activePorts.screenshots.remove(command.release, path, command.controller.signal);
+      }
+      for (const url of linkedURLs) {
+        await activePorts.screenshots.removeTrackerURL(
+          command.release,
+          url,
+          command.controller.signal,
+        );
+      }
+      if (remainingFinalPaths.length !== state.screenshots.finalSelectionPaths.length) {
+        await activePorts.screenshots.saveFinal(
+          command.release,
+          remainingFinalImages,
+          command.controller.signal,
+        );
+      }
+      return null;
+    });
+  };
+
+  const removeTrackerURLs = async (urls: readonly string[]) => {
+    const normalizedURLs = Array.from(new Set(urls.map((url) => url.trim()).filter(Boolean)));
+    if (normalizedURLs.length === 0) return false;
+    return mutateScreenshots(async (command) => {
+      for (const url of normalizedURLs) {
+        await activePorts.screenshots.removeTrackerURL(
+          command.release,
+          url,
+          command.controller.signal,
+        );
+      }
+      return null;
+    });
+  };
+
+  const loadMenuImages = async (
+    mutate?: (command: WorkflowCommand) => Promise<DVDMenuCaptureResult | null>,
+  ): Promise<boolean> => {
+    const command = beginWorkflow("menuImages", access.menuImages.reason);
+    if (!command) return false;
+    try {
+      const capture = mutate ? await mutate(command) : null;
+      const images = await activePorts.menuImages.list(command.release, command.controller.signal);
+      const previews = await Promise.all(
+        images.map(async (image) => ({
+          image,
+          dataURI: image.Path
+            ? await activePorts.menuImages.readImage(image.Path, command.controller.signal)
+            : "",
+        })),
+      );
+      dispatch({
+        type: "menu_images_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        images: previews,
+        ...(capture ? { capture } : {}),
+        changed: Boolean(mutate),
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("menuImages", command, error);
+      return false;
+    } finally {
+      finishWorkflow("menuImages", command);
+    }
+  };
+
+  const loadUploadedImages = async (
+    mutate?: (
+      command: WorkflowCommand,
+    ) => Promise<Readonly<{ failures: readonly UploadImageHostFailure[] }>>,
+    correlationID = "",
+  ): Promise<boolean> => {
+    const command = beginWorkflow("uploadedImages", access.uploadedImages.reason);
+    if (!command) return false;
+    dispatch({
+      type: "uploaded_images_progress_reset",
+      sessionRevision: command.sessionRevision,
+      revision: command.revision,
+      correlationID,
+    });
+    try {
+      const mutation = mutate
+        ? await mutate(command)
+        : { failures: [] as readonly UploadImageHostFailure[] };
+      const [candidateImages, uploaded] = await Promise.all([
+        activePorts.uploadedImages.listCandidates(command.release, command.controller.signal),
+        activePorts.uploadedImages.listUploaded(command.release, command.controller.signal),
+      ]);
+      const candidates = await Promise.all(
+        candidateImages.map(async (image) => ({
+          image,
+          dataURI: image.Path
+            ? await activePorts.uploadedImages.readImage(image.Path, command.controller.signal)
+            : "",
+        })),
+      );
+      dispatch({
+        type: "uploaded_images_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        candidates,
+        uploaded,
+        failures: mutation.failures,
+        changed: Boolean(mutate),
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("uploadedImages", command, error);
+      return false;
+    } finally {
+      finishWorkflow("uploadedImages", command);
+    }
+  };
+
+  const loadDescriptions = async (): Promise<boolean> => {
+    const command = beginWorkflow("descriptions", access.descriptions.reason);
+    if (!command) return false;
+    try {
+      const preview = await activePorts.descriptions.load(
+        command.release,
+        state.selectedTrackers,
+        command.controller.signal,
+      );
+      dispatch({
+        type: "descriptions_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        preview,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("descriptions", command, error);
+      return false;
+    } finally {
+      finishWorkflow("descriptions", command);
+    }
+  };
+
+  const renderDescription = async (groupKey: string): Promise<boolean> => {
+    const command = beginWorkflow("descriptions", access.descriptions.reason);
+    if (!command) return false;
+    const key = groupKey.trim();
+    const inputRevision = state.descriptions.inputRevision;
+    try {
+      const html = await activePorts.descriptions.render(
+        state.descriptions.rawByGroup[key] || "",
+        command.controller.signal,
+      );
+      dispatch({
+        type: "description_rendered",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        inputRevision,
+        groupKey: key,
+        html,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("descriptions", command, error);
+      return false;
+    } finally {
+      finishWorkflow("descriptions", command);
+    }
+  };
+
+  const saveDescription = async (groupKey: string, reset: boolean): Promise<boolean> => {
+    const command = beginWorkflow("descriptions", access.descriptions.reason);
+    if (!command) return false;
+    const key = groupKey.trim();
+    const group = state.descriptions.value?.Groups.find((item) => item.GroupKey === key);
+    const inputRevision = state.descriptions.inputRevision;
+    if (!group) {
+      failWorkflow("descriptions", command, new Error("Description group not found."));
+      finishWorkflow("descriptions", command);
+      return false;
+    }
+    try {
+      const updated = await activePorts.descriptions.save(
+        command.release,
+        key,
+        reset ? "" : state.descriptions.rawByGroup[key] || "",
+        group.Trackers,
+        command.controller.signal,
+      );
+      dispatch({
+        type: "description_saved",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        inputRevision,
+        group: updated,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("descriptions", command, error);
+      return false;
+    } finally {
+      finishWorkflow("descriptions", command);
+    }
+  };
+
+  const buildUploadCommand = (release: ReleaseRef): UploadCommand => ({
+    release,
+    trackers: [...state.selectedTrackers],
+    ignoreDupesFor: [...state.ignoredDupesFor],
+    ruleAuthorizations: Object.entries(state.authorizedRulesByTracker).map(([tracker, rules]) => ({
+      Tracker: tracker,
+      Rules: [...rules],
+    })),
+    questionnaireAnswers: Object.fromEntries(
+      Object.entries(state.questionnaireAnswers).map(([tracker, answers]) => [
+        tracker,
+        { ...answers },
+      ]),
+    ),
+    descriptionGroups: selectedDescriptionGroups(
+      state.descriptions.value?.Groups || [],
+      state.descriptions.rawByGroup,
+    ),
+    options: { ...state.uploadOptions },
+  });
+
+  const buildDryRunCommand = (release: ReleaseRef, dupeJobID: string): DryRunCommand => {
+    const command = buildUploadCommand(release);
+    return {
+      dupeJobID,
+      release: command.release,
+      trackers: command.trackers,
+      ignoreDupesFor: command.ignoreDupesFor,
+      questionnaireAnswers: command.questionnaireAnswers,
+      descriptionGroups: command.descriptionGroups,
+      options: command.options,
+    };
+  };
+
+  const runDryRun = async (): Promise<boolean> => {
+    const command = beginWorkflow("dryRun", access.upload.reason);
+    if (!command) return false;
+    const inputRevision = state.uploadInputRevision;
+    try {
+      const dupeJobID = releaseJobs.dupe?.dupe?.jobID?.trim() || "";
+      if (!duplicatesReady || !dupeJobID) {
+        throw new Error("Complete duplicate checking before running a dry run.");
+      }
+      const preview = await activePorts.upload.dryRun(
+        buildDryRunCommand(command.release, dupeJobID),
+        command.controller.signal,
+      );
+      dispatch({
+        type: "dry_run_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        inputRevision,
+        preview,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("dryRun", command, error);
+      return false;
+    } finally {
+      finishWorkflow("dryRun", command);
+    }
+  };
+
+  const reviewUpload = async (): Promise<boolean> => {
+    const staleReason =
+      state.dryRun.status === "ready" && !state.dryRun.staleReason
+        ? access.upload.reason
+        : state.dryRun.staleReason || "Run the current dry run first.";
+    const command = beginWorkflow("review", staleReason);
+    if (!command) return false;
+    const inputRevision = state.uploadInputRevision;
+    try {
+      const review = await activePorts.upload.review(
+        buildUploadCommand(command.release),
+        command.controller.signal,
+      );
+      dispatch({
+        type: "review_loaded",
+        sessionRevision: command.sessionRevision,
+        revision: command.revision,
+        inputRevision,
+        review,
+      });
+      return !command.controller.signal.aborted;
+    } catch (error) {
+      failWorkflow("review", command, error);
+      return false;
+    } finally {
+      finishWorkflow("review", command);
+    }
+  };
+
+  const currentDupeSnapshot = releaseJobs.dupe?.dupe ?? null;
+  const assessedDupeSelection =
+    currentDupeSnapshot?.summary?.Eligibility?.Trackers?.map((tracker) => tracker.Tracker) || [];
+  const runningDupeSelection =
+    currentDupeSnapshot?.trackers?.map((tracker) => tracker.tracker) || [];
+  const dupeSelection = assessedDupeSelection.length ? assessedDupeSelection : runningDupeSelection;
+  const duplicateAssessmentCurrent = sameNames(dupeSelection, state.selectedTrackers);
+  const duplicateStartPending = releaseJobs.pending.some(
+    (pending) => pending.kind === "duplicate_check",
+  );
+  const duplicatesReady =
+    !duplicateStartPending &&
+    duplicateAssessmentCurrent &&
+    isCompleted(String(currentDupeSnapshot?.status || ""));
+  const uploadSnapshot = releaseJobs.upload?.upload ?? null;
+  const bound = Boolean(state.release) && !state.preparationDirty;
+  const requirements = trackerWorkflowRequirements(
+    state.selectedTrackers,
+    trackerCatalog?.catalog ?? null,
+  );
+  const currentDryRunFailures =
+    state.dryRun.status === "ready" && !state.dryRun.staleReason
+      ? (state.dryRun.value?.Trackers ?? [])
+          .map((entry) => entry.ContentFailure)
+          .filter((failure): failure is TrackerContentFailure => Boolean(failure))
+      : [];
+  const screenshotFailed =
+    (requirements.needsImages &&
+      state.screenshots.status === "error" &&
+      !state.screenshots.staleReason) ||
+    selectedContentFailure(
+      currentDryRunFailures,
+      state.selectedTrackers,
+      "screenshot_preparation_failed",
+    );
+  const descriptionFailed =
+    selectedContentFailure(
+      state.descriptions.value?.ContentFailures,
+      state.selectedTrackers,
+      "description_preparation_failed",
+    ) ||
+    selectedContentFailure(
+      currentDryRunFailures,
+      state.selectedTrackers,
+      "description_preparation_failed",
+    );
+  const descriptionsReady =
+    !requirements.needsDescriptions ||
+    (state.descriptions.status === "ready" &&
+      !state.descriptions.staleReason &&
+      !descriptionFailed);
+  const access = routeAccess(
+    bound,
+    Boolean(state.preview?.TrackerData?.length),
+    duplicatesReady,
+    requirements,
+    descriptionsReady,
+    screenshotFailed,
+    descriptionFailed,
+  );
+
+  const session: ReleaseSession = {
+    identity: {
+      view: {
+        sessionRevision: state.sessionRevision,
+        sourcePath: state.selectedSource,
+        release: state.release,
+        preview: state.preview,
+      },
+    },
+    navigation: { view: { access }, open: (route) => access[route].available },
+    input: {
+      view: {
+        sourceDraft: state.sourceDraft,
+        selectedSource: state.selectedSource,
+        status: state.preparation.status,
+        error: state.preparation.error,
+        failure: state.preparation.failure,
+        preparationDirty: state.preparationDirty,
+        intent: state.preparationIntent,
+        selectedTrackers: state.selectedTrackers,
+        progress: {
+          correlationID: state.preparation.correlationID,
+          status: state.preparation.status,
+          message: state.preparation.message,
+          steps: state.preparation.steps,
+        },
+        preview: state.preview,
+        trackerData: state.preview?.TrackerData || [],
+        playlist: state.playlist,
+      },
+      updateSourceDraft: (value) => dispatch({ type: "draft_changed", value }),
+      selectSource,
+      changeSourceLookupURL: (value) => dispatch({ type: "source_lookup_changed", value }),
+      changeIdentity: (value) => dispatch({ type: "identity_changed", value }),
+      changeReleaseName: (value) => dispatch({ type: "release_name_changed", value }),
+      chooseTrackers: (trackers) => dispatch({ type: "trackers_chosen", trackers }),
+      choosePlaylists: (playlists, useAll) =>
+        dispatch({ type: "playlist_draft_changed", playlists, useAll }),
+      confirmPlaylists: () => {
+        if (
+          !state.playlist.required ||
+          state.playlist.selected.length === 0 ||
+          !state.preparation.correlationID
+        ) {
+          return Promise.resolve(false);
+        }
+        abortController("preparation");
+        const controller = new AbortController();
+        controllers.current.preparation = controller;
+        const intent = cloneIntent({
+          ...state.preparationIntent,
+          playlist: {
+            Set: true,
+            Selected: [...state.playlist.selected],
+            UseAll: state.playlist.useAll,
+          },
+        });
+        const sourcePath = state.selectedSource;
+        const commandRevision = state.commandRevision;
+        const correlationID = state.preparation.correlationID;
+        const operation = lastPreparation.current?.operation || "prepare";
+        lastPreparation.current = { operation, sourcePath, intent };
+        dispatch({
+          type: "playlist_resumed",
+          sourcePath,
+          commandRevision,
+          correlationID,
+          intent,
+        });
+        dispatchPreparationStep(
+          sourcePath,
+          commandRevision,
+          correlationID,
+          localPreparationStep(
+            "playlist_selection",
+            30,
+            "Select Blu-ray playlists",
+            "completed",
+            "Playlist selection accepted.",
+          ),
+        );
+        return executePreparation(
+          operation,
+          sourcePath,
+          intent,
+          { confirmBDMVRescan: false },
+          commandRevision,
+          correlationID,
+          controller,
+        );
+      },
+      cancelPlaylistSelection: () => {
+        abortController("preparation");
+        dispatch({ type: "playlist_dismissed" });
+      },
+      prepareSource: (sourcePath, intent) => runPreparationFor("prepare", sourcePath, intent),
+      resetSource: (sourcePath, intent) => runPreparationFor("reset", sourcePath, intent),
+      prepare: () => runPreparation("prepare"),
+      reset: () => runPreparation("reset"),
+      confirmBDMVRescan: () => {
+        const retry = lastPreparation.current;
+        if (!retry || state.preparation.failure?.Recovery !== "confirm")
+          return Promise.resolve(false);
+        return runPreparationFor(retry.operation, retry.sourcePath, retry.intent, {
+          confirmBDMVRescan: true,
+        });
+      },
+      selectCandidate,
+    },
+    duplicates: {
+      view: {
+        status: duplicateStartPending
+          ? "running"
+          : currentDupeSnapshot
+            ? duplicatesReady
+              ? "ready"
+              : isCompleted(currentDupeSnapshot.status)
+                ? "idle"
+                : "running"
+            : "idle",
+        snapshot: !duplicateStartPending && duplicateAssessmentCurrent ? currentDupeSnapshot : null,
+        eligibility:
+          !duplicateStartPending && duplicateAssessmentCurrent
+            ? currentDupeSnapshot?.summary?.Eligibility || null
+            : null,
+        ignoredTrackers: state.ignoredDupesFor,
+        selectedTrackers: state.selectedTrackers,
+        error: state.duplicatesError || currentDupeSnapshot?.failure?.Message || "",
+        transientError: releaseJobs.transientError,
+      },
+      run: async () => {
+        dispatch({ type: "job_command_started", kind: "duplicates" });
+        if (!state.release || !access.duplicates.available || state.selectedTrackers.length === 0) {
+          dispatch({
+            type: "job_command_failed",
+            kind: "duplicates",
+            error:
+              access.duplicates.reason || "Select at least one tracker to run duplicate checking.",
+          });
+          return false;
+        }
+        try {
+          await releaseJobs.startDupe({ trackers: [...state.selectedTrackers] });
+          return true;
+        } catch (error) {
+          dispatch({ type: "job_command_failed", kind: "duplicates", error: errorText(error) });
+          return false;
+        }
+      },
+      chooseTrackers: (trackers) => dispatch({ type: "trackers_chosen", trackers }),
+      cancel: async () => {
+        if (!releaseJobs.dupe) return false;
+        try {
+          await releaseJobs.cancel(releaseJobs.dupe);
+          return true;
+        } catch (error) {
+          dispatch({ type: "job_command_failed", kind: "duplicates", error: errorText(error) });
+          return false;
+        }
+      },
+      setIgnored: (tracker, ignored) => dispatch({ type: "dupe_ignore_changed", tracker, ignored }),
+    },
+    screenshots: {
+      view: {
+        revision: state.screenshots.revision,
+        status: state.screenshots.status,
+        plan: state.screenshots.value,
+        result: state.screenshots.result,
+        selections: state.screenshots.selections,
+        finalSelectionPaths: state.screenshots.finalSelectionPaths,
+        previewImage: state.screenshots.previewImage,
+        staleReason: state.screenshots.staleReason,
+        error: state.screenshots.error,
+      },
+      load: loadScreenshotPlan,
+      changeSelection: (index, value) =>
+        dispatch({ type: "screenshot_selection_changed", index, value }),
+      generate: generateScreenshots,
+      previewFrame: async (timestampSeconds) => {
+        const command = beginWorkflow("screenshots", access.screenshots.reason);
+        if (!command) return false;
+        try {
+          const image = await activePorts.screenshots.previewFrame(
+            command.release,
+            timestampSeconds,
+            command.controller.signal,
+          );
+          dispatch({
+            type: "screenshot_previewed",
+            sessionRevision: command.sessionRevision,
+            revision: command.revision,
+            image,
+          });
+          return !command.controller.signal.aborted;
+        } catch (error) {
+          failWorkflow("screenshots", command, error);
+          return false;
+        } finally {
+          finishWorkflow("screenshots", command);
+        }
+      },
+      remove: (imagePath) => removeScreenshots([imagePath]),
+      removeMany: removeScreenshots,
+      removeTrackerURL: (url) => removeTrackerURLs([url]),
+      removeTrackerURLs,
+      selectFinal: (imagePath, selected) => {
+        const paths = new Set(state.screenshots.finalSelectionPaths);
+        if (selected) paths.add(imagePath);
+        else paths.delete(imagePath);
+        return persistFinalScreenshotPaths([...paths]);
+      },
+      reorderFinal: (fromIndex, toIndex) => {
+        const paths = [...state.screenshots.finalSelectionPaths];
+        if (
+          fromIndex === toIndex ||
+          fromIndex < 0 ||
+          toIndex < 0 ||
+          fromIndex >= paths.length ||
+          toIndex >= paths.length
+        ) {
+          return Promise.resolve(false);
+        }
+        const [moved] = paths.splice(fromIndex, 1);
+        paths.splice(toIndex, 0, moved);
+        return persistFinalScreenshotPaths(paths);
+      },
+      saveFinal: () => persistFinalScreenshotPaths(state.screenshots.finalSelectionPaths),
+      readImage: async (path) => {
+        if (controllers.current.screenshotRead)
+          throw new Error("An image read is already running.");
+        const controller = new AbortController();
+        controllers.current.screenshotRead = controller;
+        try {
+          return await activePorts.screenshots.readImage(path, controller.signal);
+        } finally {
+          if (controllers.current.screenshotRead === controller) {
+            delete controllers.current.screenshotRead;
+          }
+        }
+      },
+    },
+    menuImages: {
+      view: {
+        revision: state.menuImages.revision,
+        status: state.menuImages.status,
+        images: state.menuImages.value || [],
+        capture: state.menuImages.capture,
+        staleReason: state.menuImages.staleReason,
+        error: state.menuImages.error,
+      },
+      load: () => loadMenuImages(),
+      importPaths: (paths) =>
+        loadMenuImages(async (command) => {
+          await activePorts.menuImages.importPaths(
+            command.release,
+            paths,
+            command.controller.signal,
+          );
+          return null;
+        }),
+      capture: () =>
+        loadMenuImages((command) =>
+          activePorts.menuImages.capture(command.release, command.controller.signal),
+        ),
+      cancelCapture: () => {
+        const controller = controllers.current.menuImages;
+        if (!controller) return;
+        controller.abort();
+        delete controllers.current.menuImages;
+        dispatch({
+          type: "workflow_canceled",
+          facet: "menuImages",
+          sessionRevision: state.sessionRevision,
+          revision: state.menuImages.revision,
+        });
+      },
+      remove: (imagePath) =>
+        loadMenuImages(async (command) => {
+          await activePorts.menuImages.remove(
+            command.release,
+            imagePath,
+            command.controller.signal,
+          );
+          return null;
+        }),
+    },
+    uploadedImages: {
+      view: {
+        revision: state.uploadedImages.revision,
+        status: state.uploadedImages.status,
+        candidates: state.uploadedImages.value?.candidates || [],
+        uploaded: state.uploadedImages.value?.uploaded || [],
+        selectedPaths: state.uploadedImages.selectedPaths,
+        host: state.uploadedImages.host,
+        failures: state.uploadedImages.failures,
+        progress: state.uploadedImages.progress,
+        staleReason: state.uploadedImages.staleReason,
+        error: state.uploadedImages.error,
+      },
+      load: () => loadUploadedImages(),
+      chooseHost: (host) => dispatch({ type: "upload_host_changed", host }),
+      select: (imagePath, selected) =>
+        dispatch({ type: "upload_image_selected", imagePath, selected }),
+      selectAll: (selected) => dispatch({ type: "upload_images_selected_all", selected }),
+      upload: () => {
+        const selectedPaths = new Set(state.uploadedImages.selectedPaths);
+        const images = (state.uploadedImages.value?.candidates || [])
+          .filter((item) => selectedPaths.has(item.image.Path))
+          .map((item) => item.image);
+        const correlationID = `image-upload-${Date.now().toString(36)}-${(
+          state.uploadedImages.revision + 1
+        ).toString(36)}`;
+        return loadUploadedImages(async (command) => {
+          const result = await activePorts.uploadedImages.upload({
+            correlationID,
+            release: command.release,
+            trackers: state.selectedTrackers,
+            host: state.uploadedImages.host,
+            images,
+            signal: command.controller.signal,
+            onProgress: (update) =>
+              dispatch({
+                type: "uploaded_images_progressed",
+                sessionRevision: command.sessionRevision,
+                revision: command.revision,
+                update,
+              }),
+          });
+          return {
+            failures: result.Failures || [],
+          };
+        }, correlationID);
+      },
+      remove: (imagePath, host) =>
+        loadUploadedImages(async (command) => {
+          await activePorts.uploadedImages.remove(
+            command.release,
+            imagePath,
+            host,
+            command.controller.signal,
+          );
+          return { failures: [] };
+        }),
+    },
+    descriptions: {
+      view: {
+        revision: state.descriptions.revision,
+        status: state.descriptions.status,
+        preview: state.descriptions.value,
+        rawByGroup: state.descriptions.rawByGroup,
+        renderedByGroup: state.descriptions.renderedByGroup,
+        dirtyGroups: state.descriptions.dirtyGroups,
+        staleReason: state.descriptions.staleReason,
+        notice: state.descriptions.notice,
+        error: state.descriptions.error,
+      },
+      load: loadDescriptions,
+      edit: (groupKey, raw) => dispatch({ type: "description_edited", groupKey, raw }),
+      render: renderDescription,
+      save: (groupKey) => saveDescription(groupKey, false),
+      reset: (groupKey) => saveDescription(groupKey, true),
+    },
+    upload: {
+      view: {
+        revision: Math.max(state.dryRun.revision, state.review.revision),
+        selectedTrackers: state.selectedTrackers,
+        eligibility: duplicateAssessmentCurrent
+          ? currentDupeSnapshot?.summary?.Eligibility || null
+          : null,
+        ignoredDupesFor: state.ignoredDupesFor,
+        authorizedRulesByTracker: state.authorizedRulesByTracker,
+        questionnaireAnswers: state.questionnaireAnswers,
+        options: state.uploadOptions,
+        dryRunStatus: state.dryRun.status,
+        dryRun: state.dryRun.value,
+        dryRunStaleReason: state.dryRun.staleReason,
+        reviewStatus: state.review.status,
+        review: state.review.value,
+        reviewStaleReason: state.review.staleReason,
+        snapshot: uploadSnapshot,
+        error:
+          state.uploadError ||
+          state.review.error ||
+          state.dryRun.error ||
+          uploadSnapshot?.failure?.Message ||
+          "",
+        transientError: releaseJobs.transientError,
+      },
+      chooseTrackers: (trackers) => dispatch({ type: "trackers_chosen", trackers }),
+      answerQuestionnaire: (tracker, key, value) =>
+        dispatch({ type: "questionnaire_answered", tracker, key, value }),
+      changeOptions: (options: Partial<UploadRunOptions>) =>
+        dispatch({ type: "upload_options_changed", value: options }),
+      setRuleAuthorized: (tracker, rule, authorized) =>
+        dispatch({ type: "rule_authorization_changed", tracker, rule, authorized }),
+      runDryRun,
+      review: reviewUpload,
+      start: async () => {
+        dispatch({ type: "job_command_started", kind: "upload" });
+        const review = state.review;
+        if (
+          !state.release ||
+          review.status !== "ready" ||
+          review.staleReason ||
+          !review.value?.Token
+        ) {
+          dispatch({
+            type: "job_command_failed",
+            kind: "upload",
+            error: review.staleReason || "Complete the current upload review first.",
+          });
+          return false;
+        }
+        try {
+          await releaseJobs.startUpload(review.value.Token);
+          return true;
+        } catch (error) {
+          dispatch({ type: "job_command_failed", kind: "upload", error: errorText(error) });
+          return false;
+        }
+      },
+      cancel: async () => {
+        if (!releaseJobs.upload) return false;
+        try {
+          await releaseJobs.cancel(releaseJobs.upload);
+          return true;
+        } catch (error) {
+          dispatch({ type: "job_command_failed", kind: "upload", error: errorText(error) });
+          return false;
+        }
+      },
+      retry: async () => {
+        if (!releaseJobs.upload) {
+          dispatch({
+            type: "job_command_failed",
+            kind: "upload",
+            error: "No retained upload job is available.",
+          });
+          return false;
+        }
+        try {
+          await releaseJobs.retryUpload(releaseJobs.upload);
+          return true;
+        } catch (error) {
+          dispatch({ type: "job_command_failed", kind: "upload", error: errorText(error) });
+          return false;
+        }
+      },
+    },
+  };
+
+  return <SessionContext.Provider value={session}>{children}</SessionContext.Provider>;
+}
+
+/** Returns the sole active-release workflow interface. */
+export const useReleaseSession = (): ReleaseSession => {
+  const session = useContext(SessionContext);
+  if (!session) throw new Error("ReleaseSessionProvider is required");
+  return session;
+};
+
+export type { ReleaseSessionPorts } from "./ports";
+export type { ReleaseSession } from "./types";
diff --git a/webui/src/releaseSession/ports.ts b/webui/src/releaseSession/ports.ts
new file mode 100644
index 00000000..61d63c1d
--- /dev/null
+++ b/webui/src/releaseSession/ports.ts
@@ -0,0 +1,146 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  DescriptionBuilderGroup,
+  RuleAuthorization,
+  DescriptionBuilderPreview,
+  DVDMenuCaptureResult,
+  ImageUploadProgressUpdate,
+  MetadataPreview,
+  PlaylistInfo,
+  PreparationProgressUpdate,
+  ReleaseRef,
+  ScreenshotImage,
+  ScreenshotPlan,
+  ScreenshotPurpose,
+  ScreenshotResult,
+  ScreenshotSelection,
+  TrackerDryRunPreview,
+  UploadedImageLink,
+  UploadImagesResult,
+  UploadReviewResult,
+} from "../types";
+import type { PreparationIntent, UploadRunOptions } from "./types";
+
+/** One-shot permissions for a preparation command; never reusable release facts. */
+export type PreparationControls = Readonly<{ confirmBDMVRescan: boolean }>;
+
+/** Preparation mutations coordinated by the release-session owner. */
+export type PreparationOperation = "prepare" | "reset" | "candidate";
+
+/** Correlated, cancellable preparation command delivered to one transport adapter. */
+export type PreparationCommand = Readonly<{
+  /** Mutation requested by the release-session owner. */
+  operation: PreparationOperation;
+  /** Unique attempt identifier used to reject stale progress and completion. */
+  correlationID: string;
+  /** Selected host filesystem source path. */
+  sourcePath: string;
+  /** Fact-producing input owned by this preparation attempt. */
+  intent: PreparationIntent;
+  /** One-shot permissions excluded from reusable preparation facts. */
+  controls: PreparationControls;
+  /** Candidate ID required only by the candidate operation. */
+  releaseID?: string;
+  /** Aborts transport work when the attempt is replaced or the provider unmounts. */
+  signal: AbortSignal;
+  /** Receives only progress correlated by the transport to this command. */
+  onProgress(update: PreparationProgressUpdate): void;
+}>;
+
+/** Host operations used to classify a source and execute canonical preparation. */
+export type ReleasePreparationPorts = Readonly<{
+  detectDiscType(sourcePath: string, signal: AbortSignal): Promise<string>;
+  discoverPlaylists(sourcePath: string, signal: AbortSignal): Promise<PlaylistInfo[]>;
+  execute(command: PreparationCommand): Promise<MetadataPreview>;
+}>;
+
+export type ScreenshotPorts = Readonly<{
+  load(release: ReleaseRef, signal: AbortSignal): Promise<ScreenshotPlan>;
+  generate(
+    release: ReleaseRef,
+    selections: readonly ScreenshotSelection[],
+    purpose: ScreenshotPurpose,
+    signal: AbortSignal,
+  ): Promise<ScreenshotResult>;
+  previewFrame(release: ReleaseRef, timestampSeconds: number, signal: AbortSignal): Promise<string>;
+  remove(release: ReleaseRef, imagePath: string, signal: AbortSignal): Promise<void>;
+  removeTrackerURL(release: ReleaseRef, url: string, signal: AbortSignal): Promise<void>;
+  saveFinal(
+    release: ReleaseRef,
+    images: readonly ScreenshotImage[],
+    signal: AbortSignal,
+  ): Promise<void>;
+  readImage(path: string, signal: AbortSignal): Promise<string>;
+}>;
+
+export type MenuImagePorts = Readonly<{
+  list(release: ReleaseRef, signal: AbortSignal): Promise<ScreenshotImage[]>;
+  readImage(path: string, signal: AbortSignal): Promise<string>;
+  importPaths(release: ReleaseRef, paths: readonly string[], signal: AbortSignal): Promise<void>;
+  capture(release: ReleaseRef, signal: AbortSignal): Promise<DVDMenuCaptureResult>;
+  remove(release: ReleaseRef, imagePath: string, signal: AbortSignal): Promise<void>;
+}>;
+
+export type UploadedImagePorts = Readonly<{
+  listCandidates(release: ReleaseRef, signal: AbortSignal): Promise<ScreenshotImage[]>;
+  readImage(path: string, signal: AbortSignal): Promise<string>;
+  listUploaded(release: ReleaseRef, signal: AbortSignal): Promise<UploadedImageLink[]>;
+  upload(
+    command: Readonly<{
+      correlationID: string;
+      release: ReleaseRef;
+      trackers: readonly string[];
+      host: string;
+      images: readonly ScreenshotImage[];
+      signal: AbortSignal;
+      onProgress(update: ImageUploadProgressUpdate): void;
+    }>,
+  ): Promise<UploadImagesResult>;
+  remove(release: ReleaseRef, imagePath: string, host: string, signal: AbortSignal): Promise<void>;
+}>;
+
+export type DescriptionPorts = Readonly<{
+  load(
+    release: ReleaseRef,
+    trackers: readonly string[],
+    signal: AbortSignal,
+  ): Promise<DescriptionBuilderPreview>;
+  render(raw: string, signal: AbortSignal): Promise<string>;
+  save(
+    release: ReleaseRef,
+    groupKey: string,
+    raw: string,
+    trackers: readonly string[],
+    signal: AbortSignal,
+  ): Promise<DescriptionBuilderGroup>;
+}>;
+
+export type UploadCommand = Readonly<{
+  release: ReleaseRef;
+  trackers: readonly string[];
+  ignoreDupesFor: readonly string[];
+  ruleAuthorizations: readonly RuleAuthorization[];
+  questionnaireAnswers: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  descriptionGroups: readonly DescriptionBuilderGroup[];
+  options: UploadRunOptions;
+}>;
+
+/** Dry-run command bound to duplicate evidence; live rule authorizations are intentionally absent. */
+export type DryRunCommand = Omit<UploadCommand, "ruleAuthorizations"> &
+  Readonly<{ dupeJobID: string }>;
+
+export type UploadPorts = Readonly<{
+  dryRun(command: DryRunCommand, signal: AbortSignal): Promise<TrackerDryRunPreview>;
+  review(command: UploadCommand, signal: AbortSignal): Promise<UploadReviewResult>;
+}>;
+
+export type ReleaseSessionPorts = Readonly<{
+  preparation: ReleasePreparationPorts;
+  screenshots: ScreenshotPorts;
+  menuImages: MenuImagePorts;
+  uploadedImages: UploadedImagePorts;
+  descriptions: DescriptionPorts;
+  upload: UploadPorts;
+}>;
diff --git a/webui/src/releaseSession/production.test.ts b/webui/src/releaseSession/production.test.ts
new file mode 100644
index 00000000..ac559e6e
--- /dev/null
+++ b/webui/src/releaseSession/production.test.ts
@@ -0,0 +1,148 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { afterEach, describe, expect, it } from "vitest";
+import { setAppRequestHandlerForTests } from "../api/client";
+import { productionReleaseSessionPorts } from "./production";
+import type { PreparationIntent } from "./types";
+
+afterEach(() => setAppRequestHandlerForTests(null));
+
+const intent = (): PreparationIntent => ({
+  sourceLookupURL: "https://example.invalid/source",
+  identity: {},
+  releaseName: {},
+  playlist: { Set: true, Selected: ["00001.mpls"], UseAll: false },
+});
+
+describe("productionReleaseSessionPorts", () => {
+  it("keeps the original source and carries direct playlist intent without persistence", async () => {
+    const requests: Array<{ method: string; body: unknown }> = [];
+    setAppRequestHandlerForTests(async (method, body) => {
+      requests.push({ method, body });
+      return {};
+    });
+    const ports = productionReleaseSessionPorts();
+    const signal = new AbortController().signal;
+    const sourcePath = "C:\\media\\Example Disc";
+
+    await ports.preparation.discoverPlaylists(sourcePath, signal);
+    await ports.preparation.execute({
+      operation: "prepare",
+      correlationID: "attempt-1",
+      sourcePath,
+      intent: intent(),
+      controls: { confirmBDMVRescan: false },
+      signal,
+      onProgress: () => undefined,
+    });
+
+    expect(requests.map((request) => request.method)).toEqual([
+      "DiscoverPlaylists",
+      "FetchMetadata",
+    ]);
+    expect(requests[0].body).toEqual({ Path: sourcePath });
+    expect(requests[1].body).toMatchObject({
+      Path: sourcePath,
+      CorrelationID: "attempt-1",
+      Playlist: { Set: true, Selected: ["00001.mpls"], UseAll: false },
+      ConfirmBDMVRescan: false,
+    });
+    expect(requests[1].body).not.toHaveProperty("Trackers");
+  });
+
+  it("sends rescan confirmation only on an explicit retry", async () => {
+    const requests: Array<{ method: string; body: unknown }> = [];
+    setAppRequestHandlerForTests(async (method, body) => {
+      requests.push({ method, body });
+      return {};
+    });
+    const ports = productionReleaseSessionPorts();
+    const sourcePath = "C:\\media\\Example Disc\\BDMV";
+
+    await ports.preparation.execute({
+      operation: "reset",
+      correlationID: "attempt-2",
+      sourcePath,
+      intent: intent(),
+      controls: { confirmBDMVRescan: true },
+      signal: new AbortController().signal,
+      onProgress: () => undefined,
+    });
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]).toMatchObject({
+      method: "ResetMetadata",
+      body: { CorrelationID: "attempt-2", Path: sourcePath, ConfirmBDMVRescan: true },
+    });
+  });
+
+  it("sends image-upload correlation with the host request", async () => {
+    const requests: Array<{ method: string; body: unknown }> = [];
+    setAppRequestHandlerForTests(async (method, body) => {
+      requests.push({ method, body });
+      return { Links: [], Failures: [] };
+    });
+    const ports = productionReleaseSessionPorts();
+
+    await ports.uploadedImages.upload({
+      correlationID: "image-upload-1",
+      release: { SourcePath: "C:\\media\\Example", Generation: 1 },
+      trackers: ["AITHER"],
+      host: "imgbox",
+      images: [],
+      signal: new AbortController().signal,
+      onProgress: () => undefined,
+    });
+
+    expect(requests).toEqual([
+      expect.objectContaining({
+        method: "UploadImages",
+        body: expect.objectContaining({
+          CorrelationID: "image-upload-1",
+          Host: "imgbox",
+        }),
+      }),
+    ]);
+  });
+
+  it("transports duplicate ignores and live rule authorizations independently", async () => {
+    const requests: Array<{ method: string; body: unknown }> = [];
+    setAppRequestHandlerForTests(async (method, body) => {
+      requests.push({ method, body });
+      return {};
+    });
+    const ports = productionReleaseSessionPorts();
+    const signal = new AbortController().signal;
+    const common = {
+      release: { SourcePath: "C:\\media\\Example", Generation: 1 },
+      trackers: ["AITHER"],
+      ignoreDupesFor: ["AITHER"],
+      questionnaireAnswers: {},
+      descriptionGroups: [],
+      options: { noSeed: false, runLogLevel: "info" },
+    } as const;
+
+    await ports.upload.dryRun({ ...common, dupeJobID: "dupe-job" }, signal);
+    await ports.upload.review(
+      {
+        ...common,
+        ruleAuthorizations: [{ Tracker: "AITHER", Rules: ["container"] }],
+      },
+      signal,
+    );
+
+    expect(requests[0]).toMatchObject({
+      method: "FetchTrackerDryRun",
+      body: { IgnoreDupesFor: ["AITHER"], NoSeed: false },
+    });
+    expect(requests[0].body).not.toHaveProperty("RuleAuthorizations");
+    expect(requests[1]).toMatchObject({
+      method: "ReviewTrackerUpload",
+      body: {
+        IgnoreDupesFor: ["AITHER"],
+        RuleAuthorizations: [{ Tracker: "AITHER", Rules: ["container"] }],
+      },
+    });
+  });
+});
diff --git a/webui/src/releaseSession/production.ts b/webui/src/releaseSession/production.ts
new file mode 100644
index 00000000..34d60af0
--- /dev/null
+++ b/webui/src/releaseSession/production.ts
@@ -0,0 +1,163 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import {
+  descriptionClient,
+  menuImageClient,
+  playlistClient,
+  preparationClient,
+  screenshotClient,
+  uploadedImageClient,
+  uploadClient,
+} from "../api/app";
+import { subscribeWebEvent } from "../api/client";
+import type { ImageUploadProgressUpdate, PreparationProgressUpdate } from "../types";
+import type { ReleaseSessionPorts } from "./ports";
+
+const preparationProgressEvent = "preparation:progress";
+const imageUploadProgressEvent = "image-upload:progress";
+
+const executePreparation: ReleaseSessionPorts["preparation"]["execute"] = async (command) => {
+  const off = subscribeWebEvent(preparationProgressEvent, (payload: unknown) => {
+    const update = payload as PreparationProgressUpdate;
+    if (update?.correlationID === command.correlationID) command.onProgress(update);
+  });
+  try {
+    switch (command.operation) {
+      case "prepare":
+        return await preparationClient.fetchMetadata(
+          command.correlationID,
+          command.sourcePath,
+          command.intent.sourceLookupURL,
+          command.intent.identity,
+          command.intent.releaseName,
+          { ...command.intent.playlist, Selected: [...command.intent.playlist.Selected] },
+          command.controls.confirmBDMVRescan,
+          command.signal,
+        );
+      case "reset":
+        return await preparationClient.resetMetadata(
+          command.correlationID,
+          command.sourcePath,
+          command.intent.sourceLookupURL,
+          command.intent.identity,
+          command.intent.releaseName,
+          { ...command.intent.playlist, Selected: [...command.intent.playlist.Selected] },
+          command.controls.confirmBDMVRescan,
+          command.signal,
+        );
+      case "candidate":
+        return await preparationClient.selectBlurayCandidate(
+          command.correlationID,
+          command.sourcePath,
+          command.releaseID || "",
+          command.signal,
+        );
+    }
+  } finally {
+    off();
+  }
+};
+
+const uploadImages: ReleaseSessionPorts["uploadedImages"]["upload"] = async (command) => {
+  const off = subscribeWebEvent(imageUploadProgressEvent, (payload: unknown) => {
+    const update = payload as ImageUploadProgressUpdate;
+    if (update?.correlationID === command.correlationID) command.onProgress(update);
+  });
+  try {
+    return await uploadedImageClient.upload(
+      command.correlationID,
+      command.release,
+      [...command.trackers],
+      command.host,
+      [...command.images],
+      command.signal,
+    );
+  } finally {
+    off();
+  }
+};
+
+/** Composes production transports once at the application boundary. */
+export const productionReleaseSessionPorts = (): ReleaseSessionPorts => ({
+  preparation: {
+    detectDiscType: (sourcePath, signal) => preparationClient.detectDiscType(sourcePath, signal),
+    discoverPlaylists: (sourcePath, signal) => playlistClient.discover(sourcePath, signal),
+    execute: executePreparation,
+  },
+  screenshots: {
+    load: (release, signal) => screenshotClient.fetchPlan(release, signal),
+    generate: (release, selections, purpose, signal) =>
+      screenshotClient.generate(release, [...selections], purpose, signal),
+    previewFrame: (release, timestampSeconds, signal) =>
+      screenshotClient.previewFrame(release, timestampSeconds, signal),
+    remove: (release, imagePath, signal) => screenshotClient.remove(release, imagePath, signal),
+    removeTrackerURL: (release, url, signal) =>
+      screenshotClient.deleteTrackerImageURL(release, url, signal),
+    saveFinal: (release, images, signal) =>
+      screenshotClient.saveFinalSelections(release, [...images], signal),
+    readImage: (path, signal) => screenshotClient.readImage(path, signal),
+  },
+  menuImages: {
+    list: (release, signal) => menuImageClient.list(release, signal),
+    readImage: (path, signal) => screenshotClient.readImage(path, signal),
+    importPaths: (release, paths, signal) =>
+      menuImageClient.importPaths(release, [...paths], signal),
+    capture: (release, signal) => menuImageClient.capture(release, signal),
+    remove: (release, imagePath, signal) => menuImageClient.remove(release, imagePath, signal),
+  },
+  uploadedImages: {
+    listCandidates: (release, signal) => uploadedImageClient.listCandidates(release, signal),
+    readImage: (path, signal) => screenshotClient.readImage(path, signal),
+    listUploaded: (release, signal) => uploadedImageClient.listUploaded(release, signal),
+    upload: uploadImages,
+    remove: (release, imagePath, host, signal) =>
+      uploadedImageClient.remove(release, imagePath, host, signal),
+  },
+  descriptions: {
+    load: (release, trackers, signal) =>
+      preparationClient.fetchDescriptionBuilder(release, [...trackers], signal),
+    render: (raw, signal) => descriptionClient.render(raw, signal),
+    save: (release, groupKey, raw, trackers, signal) =>
+      descriptionClient.saveOverride(release, groupKey, raw, [...trackers], signal),
+  },
+  upload: {
+    dryRun: (command, signal) =>
+      preparationClient.fetchTrackerDryRun(
+        command.dupeJobID,
+        command.release,
+        [...command.trackers],
+        [...command.ignoreDupesFor],
+        Object.fromEntries(
+          Object.entries(command.questionnaireAnswers).map(([tracker, values]) => [
+            tracker,
+            { ...values },
+          ]),
+        ),
+        [...command.descriptionGroups],
+        command.options.noSeed,
+        command.options.runLogLevel,
+        signal,
+      ),
+    review: (command, signal) =>
+      uploadClient.review(
+        command.release,
+        [...command.trackers],
+        [...command.ignoreDupesFor],
+        command.ruleAuthorizations.map((authorization) => ({
+          Tracker: authorization.Tracker,
+          Rules: [...authorization.Rules],
+        })),
+        Object.fromEntries(
+          Object.entries(command.questionnaireAnswers).map(([tracker, values]) => [
+            tracker,
+            { ...values },
+          ]),
+        ),
+        [...command.descriptionGroups],
+        command.options.noSeed,
+        command.options.runLogLevel,
+        signal,
+      ),
+  },
+});
diff --git a/webui/src/releaseSession/reducer.test.ts b/webui/src/releaseSession/reducer.test.ts
new file mode 100644
index 00000000..551bb359
--- /dev/null
+++ b/webui/src/releaseSession/reducer.test.ts
@@ -0,0 +1,40 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import { describe, expect, it } from "vitest";
+import { initialSessionState, sessionReducer } from "./reducer";
+
+describe("sessionReducer rule authorization", () => {
+  it("keeps duplicate ignores and exact rule authorizations independent across upload retry state", () => {
+    let state = initialSessionState();
+    state = sessionReducer(state, {
+      type: "rule_authorization_changed",
+      tracker: " aither ",
+      rule: "container",
+      authorized: true,
+    });
+    state = sessionReducer(state, {
+      type: "dupe_ignore_changed",
+      tracker: "AITHER",
+      ignored: true,
+    });
+    state = sessionReducer(state, { type: "job_command_started", kind: "upload" });
+    state = sessionReducer(state, {
+      type: "job_command_failed",
+      kind: "upload",
+      error: "retryable failure",
+    });
+
+    expect(state.ignoredDupesFor).toEqual(["AITHER"]);
+    expect(state.authorizedRulesByTracker).toEqual({ AITHER: ["container"] });
+
+    state = sessionReducer(state, {
+      type: "rule_authorization_changed",
+      tracker: "AITHER",
+      rule: "container",
+      authorized: false,
+    });
+    expect(state.ignoredDupesFor).toEqual(["AITHER"]);
+    expect(state.authorizedRulesByTracker).toEqual({});
+  });
+});
diff --git a/webui/src/releaseSession/reducer.ts b/webui/src/releaseSession/reducer.ts
new file mode 100644
index 00000000..e7e22774
--- /dev/null
+++ b/webui/src/releaseSession/reducer.ts
@@ -0,0 +1,1146 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  DescriptionBuilderGroup,
+  DescriptionBuilderPreview,
+  DVDMenuCaptureResult,
+  ExternalIDOverrides,
+  ImageUploadProgressUpdate,
+  MetadataPreview,
+  OperationFailure,
+  PlaylistInfo,
+  ReleaseNameOverrides,
+  ReleaseRef,
+  ScreenshotPlan,
+  ScreenshotResult,
+  ScreenshotSelection,
+  TrackerDryRunPreview,
+  UploadedImageLink,
+  UploadImageHostFailure,
+  UploadReviewResult,
+} from "../types";
+import type {
+  FacetStatus,
+  MenuImagePreview,
+  PreparationIntent,
+  PreparationStatus,
+  PreparationStep,
+  PlaylistStatus,
+  UploadedImageCandidate,
+  UploadRunOptions,
+} from "./types";
+
+export type WorkflowState<T> = Readonly<{
+  revision: number;
+  status: FacetStatus;
+  value: T | null;
+  staleReason: string;
+  error: string;
+}>;
+
+type ScreenshotState = WorkflowState<ScreenshotPlan> &
+  Readonly<{
+    result: ScreenshotResult | null;
+    previewImage: string;
+    selections: readonly ScreenshotSelection[];
+    finalSelectionPaths: readonly string[];
+  }>;
+type MenuImageState = WorkflowState<readonly MenuImagePreview[]> &
+  Readonly<{ capture: DVDMenuCaptureResult | null }>;
+type UploadedImageState = WorkflowState<{
+  candidates: readonly UploadedImageCandidate[];
+  uploaded: readonly UploadedImageLink[];
+}> &
+  Readonly<{
+    host: string;
+    selectedPaths: readonly string[];
+    failures: readonly UploadImageHostFailure[];
+    progress: Readonly<{
+      correlationID: string;
+      attempts: readonly ImageUploadProgressUpdate[];
+    }>;
+  }>;
+type DescriptionState = WorkflowState<DescriptionBuilderPreview> &
+  Readonly<{
+    inputRevision: number;
+    rawByGroup: Readonly<Record<string, string>>;
+    renderedByGroup: Readonly<Record<string, string>>;
+    dirtyGroups: readonly string[];
+    notice: string;
+  }>;
+type PlaylistState = Readonly<{
+  status: PlaylistStatus;
+  required: boolean;
+  candidates: readonly PlaylistInfo[];
+  selected: readonly string[];
+  useAll: boolean;
+  error: string;
+}>;
+
+type PreparationAttemptState = Readonly<{
+  correlationID: string;
+  sourcePath: string;
+  commandRevision: number;
+  status: PreparationStatus;
+  message: string;
+  steps: readonly PreparationStep[];
+  error: string;
+  failure: OperationFailure | null;
+}>;
+
+/** Canonical release-session state; revisions and correlation reject stale async results. */
+export type SessionState = Readonly<{
+  sessionRevision: number;
+  commandRevision: number;
+  sourceDraft: string;
+  selectedSource: string;
+  preparation: PreparationAttemptState;
+  preparationDirty: boolean;
+  preparationIntent: PreparationIntent;
+  playlist: PlaylistState;
+  release: ReleaseRef | null;
+  preview: MetadataPreview | null;
+  selectedTrackers: readonly string[];
+  ignoredDupesFor: readonly string[];
+  authorizedRulesByTracker: Readonly<Record<string, readonly string[]>>;
+  questionnaireAnswers: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  uploadOptions: UploadRunOptions;
+  uploadInputRevision: number;
+  duplicatesError: string;
+  uploadError: string;
+  screenshots: ScreenshotState;
+  menuImages: MenuImageState;
+  uploadedImages: UploadedImageState;
+  descriptions: DescriptionState;
+  dryRun: WorkflowState<TrackerDryRunPreview>;
+  review: WorkflowState<UploadReviewResult>;
+}>;
+
+type FacetName =
+  | "screenshots"
+  | "menuImages"
+  | "uploadedImages"
+  | "descriptions"
+  | "dryRun"
+  | "review";
+
+/** Closed set of source, preparation, asset, review, and Job state transitions. */
+export type SessionAction =
+  | Readonly<{ type: "draft_changed"; value: string }>
+  | Readonly<{ type: "source_selected"; sourcePath: string }>
+  | Readonly<{ type: "source_lookup_changed"; value: string }>
+  | Readonly<{ type: "identity_changed"; value: Readonly<ExternalIDOverrides> }>
+  | Readonly<{ type: "release_name_changed"; value: Readonly<ReleaseNameOverrides> }>
+  | Readonly<{
+      type: "playlist_required";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      candidates: readonly PlaylistInfo[];
+      error: string;
+    }>
+  | Readonly<{ type: "playlist_draft_changed"; playlists: readonly string[]; useAll: boolean }>
+  | Readonly<{ type: "playlist_dismissed" }>
+  | Readonly<{
+      type: "playlist_resumed";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      intent: PreparationIntent;
+    }>
+  | Readonly<{
+      type: "preparation_started";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      intent: PreparationIntent;
+    }>
+  | Readonly<{
+      type: "preparation_progressed";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      step: PreparationStep;
+    }>
+  | Readonly<{
+      type: "preparation_succeeded";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      preview: MetadataPreview;
+    }>
+  | Readonly<{
+      type: "preparation_failed";
+      sourcePath: string;
+      commandRevision: number;
+      correlationID: string;
+      error: string;
+      failure: OperationFailure | null;
+    }>
+  | Readonly<{ type: "trackers_chosen"; trackers: readonly string[] }>
+  | Readonly<{ type: "dupe_ignore_changed"; tracker: string; ignored: boolean }>
+  | Readonly<{
+      type: "rule_authorization_changed";
+      tracker: string;
+      rule: string;
+      authorized: boolean;
+    }>
+  | Readonly<{ type: "questionnaire_answered"; tracker: string; key: string; value: string }>
+  | Readonly<{ type: "upload_options_changed"; value: Partial<UploadRunOptions> }>
+  | Readonly<{
+      type: "screenshot_selection_changed";
+      index: number;
+      value: Partial<Pick<ScreenshotSelection, "TimestampSeconds" | "Frame">>;
+    }>
+  | Readonly<{ type: "screenshot_final_paths_changed"; imagePaths: readonly string[] }>
+  | Readonly<{ type: "job_command_started"; kind: "duplicates" | "upload" }>
+  | Readonly<{ type: "job_command_failed"; kind: "duplicates" | "upload"; error: string }>
+  | Readonly<{
+      type: "workflow_started";
+      facet: FacetName;
+      sessionRevision: number;
+      revision: number;
+    }>
+  | Readonly<{
+      type: "workflow_failed";
+      facet: FacetName;
+      sessionRevision: number;
+      revision: number;
+      error: string;
+    }>
+  | Readonly<{
+      type: "workflow_canceled";
+      facet: FacetName;
+      sessionRevision: number;
+      revision: number;
+    }>
+  | Readonly<{
+      type: "screenshots_loaded";
+      sessionRevision: number;
+      revision: number;
+      plan: ScreenshotPlan;
+      result?: ScreenshotResult;
+      changed?: boolean;
+      reseedDrafts?: boolean;
+      finalSelectionPaths?: readonly string[];
+    }>
+  | Readonly<{
+      type: "screenshot_previewed";
+      sessionRevision: number;
+      revision: number;
+      image: string;
+    }>
+  | Readonly<{
+      type: "menu_images_loaded";
+      sessionRevision: number;
+      revision: number;
+      images: readonly MenuImagePreview[];
+      capture?: DVDMenuCaptureResult;
+      changed?: boolean;
+    }>
+  | Readonly<{
+      type: "uploaded_images_loaded";
+      sessionRevision: number;
+      revision: number;
+      candidates: readonly UploadedImageCandidate[];
+      uploaded: readonly UploadedImageLink[];
+      failures?: readonly UploadImageHostFailure[];
+      changed?: boolean;
+    }>
+  | Readonly<{
+      type: "uploaded_images_progress_reset";
+      sessionRevision: number;
+      revision: number;
+      correlationID: string;
+    }>
+  | Readonly<{
+      type: "uploaded_images_progressed";
+      sessionRevision: number;
+      revision: number;
+      update: ImageUploadProgressUpdate;
+    }>
+  | Readonly<{ type: "upload_host_changed"; host: string }>
+  | Readonly<{ type: "upload_image_selected"; imagePath: string; selected: boolean }>
+  | Readonly<{ type: "upload_images_selected_all"; selected: boolean }>
+  | Readonly<{ type: "description_edited"; groupKey: string; raw: string }>
+  | Readonly<{
+      type: "descriptions_loaded";
+      sessionRevision: number;
+      revision: number;
+      preview: DescriptionBuilderPreview;
+    }>
+  | Readonly<{
+      type: "description_rendered";
+      sessionRevision: number;
+      revision: number;
+      inputRevision: number;
+      groupKey: string;
+      html: string;
+    }>
+  | Readonly<{
+      type: "description_saved";
+      sessionRevision: number;
+      revision: number;
+      inputRevision: number;
+      group: DescriptionBuilderGroup;
+    }>
+  | Readonly<{
+      type: "dry_run_loaded";
+      sessionRevision: number;
+      revision: number;
+      inputRevision: number;
+      preview: TrackerDryRunPreview;
+    }>
+  | Readonly<{
+      type: "review_loaded";
+      sessionRevision: number;
+      revision: number;
+      inputRevision: number;
+      review: UploadReviewResult;
+    }>;
+
+const emptyIntent = (): PreparationIntent => ({
+  sourceLookupURL: "",
+  identity: {},
+  releaseName: {},
+  playlist: { Set: false, Selected: [], UseAll: false },
+});
+
+const clonePreparationIntent = (intent: PreparationIntent): PreparationIntent => ({
+  sourceLookupURL: intent.sourceLookupURL,
+  identity: { ...intent.identity },
+  releaseName: { ...intent.releaseName },
+  playlist: {
+    Set: intent.playlist.Set,
+    Selected: [...intent.playlist.Selected],
+    UseAll: intent.playlist.UseAll,
+  },
+});
+
+const emptyOptions = (): UploadRunOptions => ({ noSeed: false, runLogLevel: "info" });
+
+const emptyWorkflow = <T>(): WorkflowState<T> => ({
+  revision: 0,
+  status: "idle",
+  value: null,
+  staleReason: "Preparation required.",
+  error: "",
+});
+
+/** Creates detached initial state for one release-session provider instance. */
+export const initialSessionState = (): SessionState => ({
+  sessionRevision: 0,
+  commandRevision: 0,
+  sourceDraft: "",
+  selectedSource: "",
+  preparation: {
+    correlationID: "",
+    sourcePath: "",
+    commandRevision: 0,
+    status: "idle",
+    message: "",
+    steps: [],
+    error: "",
+    failure: null,
+  },
+  preparationDirty: false,
+  preparationIntent: emptyIntent(),
+  playlist: {
+    status: "idle",
+    required: false,
+    candidates: [],
+    selected: [],
+    useAll: false,
+    error: "",
+  },
+  release: null,
+  preview: null,
+  selectedTrackers: [],
+  ignoredDupesFor: [],
+  authorizedRulesByTracker: {},
+  questionnaireAnswers: {},
+  uploadOptions: emptyOptions(),
+  uploadInputRevision: 0,
+  duplicatesError: "",
+  uploadError: "",
+  screenshots: {
+    ...emptyWorkflow<ScreenshotPlan>(),
+    result: null,
+    previewImage: "",
+    selections: [],
+    finalSelectionPaths: [],
+  },
+  menuImages: { ...emptyWorkflow<readonly MenuImagePreview[]>(), capture: null },
+  uploadedImages: {
+    ...emptyWorkflow<{
+      candidates: readonly UploadedImageCandidate[];
+      uploaded: readonly UploadedImageLink[];
+    }>(),
+    host: "",
+    selectedPaths: [],
+    failures: [],
+    progress: { correlationID: "", attempts: [] },
+  },
+  descriptions: {
+    ...emptyWorkflow<DescriptionBuilderPreview>(),
+    inputRevision: 0,
+    rawByGroup: {},
+    renderedByGroup: {},
+    dirtyGroups: [],
+    notice: "",
+  },
+  dryRun: emptyWorkflow(),
+  review: emptyWorkflow(),
+});
+
+const normalizeNames = (values: readonly string[]) =>
+  Array.from(new Set(values.map((value) => value.trim().toUpperCase()).filter(Boolean)));
+
+const preparationMatches = (
+  state: SessionState,
+  sourcePath: string,
+  commandRevision: number,
+  correlationID: string,
+) =>
+  sourcePath === state.selectedSource &&
+  commandRevision === state.commandRevision &&
+  correlationID === state.preparation.correlationID;
+
+const upsertPreparationStep = (
+  steps: readonly PreparationStep[],
+  step: PreparationStep,
+): readonly PreparationStep[] =>
+  [...steps.filter((current) => current.phase !== step.phase), { ...step }].sort(
+    (left, right) => left.order - right.order || left.phase.localeCompare(right.phase),
+  );
+
+const completeRunningPreparationSteps = (steps: readonly PreparationStep[]) =>
+  steps.map((step) =>
+    step.status === "running" ? { ...step, status: "completed" as const } : step,
+  );
+
+const failCurrentPreparationStep = (steps: readonly PreparationStep[]) => {
+  const next = [...steps];
+  for (let index = next.length - 1; index >= 0; index -= 1) {
+    if (next[index].status !== "running") continue;
+    next[index] = { ...next[index], status: "failed" };
+    break;
+  }
+  return next;
+};
+
+const invalidate = <T>(
+  previous: WorkflowState<T>,
+  reason: string,
+  clear: boolean,
+): WorkflowState<T> => ({
+  revision: previous.revision + 1,
+  status: "idle",
+  value: clear ? null : previous.value,
+  staleReason: reason,
+  error: "",
+});
+
+const invalidateAuthority = (state: SessionState, reason: string, clear: boolean) => ({
+  dryRun: invalidate(state.dryRun, reason, clear),
+  review: invalidate(state.review, reason, true),
+});
+
+const invalidateAssetConsumers = (state: SessionState) => ({
+  descriptions: {
+    ...invalidate(state.descriptions, "Image assets changed.", false),
+    inputRevision: state.descriptions.inputRevision + 1,
+    rawByGroup: state.descriptions.rawByGroup,
+    renderedByGroup: state.descriptions.renderedByGroup,
+    dirtyGroups: state.descriptions.dirtyGroups,
+    notice: "",
+  },
+  ...invalidateAuthority(state, "Image assets changed.", false),
+  uploadInputRevision: state.uploadInputRevision + 1,
+});
+
+const invalidateReleaseWork = (state: SessionState, reason: string) => ({
+  screenshots: {
+    ...invalidate(state.screenshots, reason, true),
+    result: null,
+    previewImage: "",
+    selections: [],
+    finalSelectionPaths: [],
+  },
+  menuImages: { ...invalidate(state.menuImages, reason, true), capture: null },
+  uploadedImages: {
+    ...invalidate(state.uploadedImages, reason, true),
+    host: state.uploadedImages.host,
+    selectedPaths: [],
+    failures: [],
+    progress: { correlationID: "", attempts: [] },
+  },
+  descriptions: {
+    ...invalidate(state.descriptions, reason, true),
+    inputRevision: state.descriptions.inputRevision + 1,
+    rawByGroup: {},
+    renderedByGroup: {},
+    dirtyGroups: [],
+    notice: "",
+  },
+  ...invalidateAuthority(state, reason, true),
+});
+
+const workflowFor = (state: SessionState, facet: FacetName): WorkflowState<unknown> => state[facet];
+
+const workflowMatches = (
+  state: SessionState,
+  facet: FacetName,
+  sessionRevision: number,
+  revision: number,
+) => state.sessionRevision === sessionRevision && workflowFor(state, facet).revision === revision;
+
+const startWorkflow = <T extends WorkflowState<unknown>>(value: T, revision: number): T =>
+  ({
+    ...value,
+    revision,
+    status: "running",
+    error: "",
+  }) as T;
+
+const failWorkflow = <T extends WorkflowState<unknown>>(value: T, error: string): T =>
+  ({
+    ...value,
+    status: "error",
+    error,
+  }) as T;
+
+const readyWorkflow = <T extends WorkflowState<unknown>>(value: T): T =>
+  ({
+    ...value,
+    status: "ready",
+    staleReason: "",
+    error: "",
+  }) as T;
+
+const preparationIntentChanged = (
+  state: SessionState,
+  intent: PreparationIntent,
+): SessionState => ({
+  ...state,
+  ...invalidateAuthority(state, "Preparation input changed.", false),
+  preparationIntent: intent,
+  preparationDirty: Boolean(state.release),
+  uploadInputRevision: state.uploadInputRevision + 1,
+});
+
+const upsertDescriptionGroup = (
+  preview: DescriptionBuilderPreview | null,
+  group: DescriptionBuilderGroup,
+): DescriptionBuilderPreview => {
+  const groups = [...(preview?.Groups || [])];
+  const index = groups.findIndex((current) => current.GroupKey === group.GroupKey);
+  if (index >= 0) groups[index] = group;
+  else groups.push(group);
+  return {
+    SourcePath: preview?.SourcePath || "",
+    Groups: groups,
+    ContentFailures: [...(preview?.ContentFailures || [])],
+  };
+};
+
+/** Applies one transition, ignoring stale revision- or correlation-scoped completions. */
+export const sessionReducer = (state: SessionState, action: SessionAction): SessionState => {
+  switch (action.type) {
+    case "draft_changed":
+      return { ...state, sourceDraft: action.value };
+    case "source_selected": {
+      const sourcePath = action.sourcePath.trim();
+      if (sourcePath === state.selectedSource) return { ...state, sourceDraft: sourcePath };
+      return {
+        ...state,
+        ...invalidateReleaseWork(state, "Source changed."),
+        sessionRevision: state.sessionRevision + 1,
+        commandRevision: state.commandRevision + 1,
+        sourceDraft: sourcePath,
+        selectedSource: sourcePath,
+        preparation: {
+          correlationID: "",
+          sourcePath,
+          commandRevision: state.commandRevision + 1,
+          status: "idle",
+          message: "",
+          steps: [],
+          error: "",
+          failure: null,
+        },
+        preparationDirty: false,
+        preparationIntent: emptyIntent(),
+        playlist: {
+          status: "idle",
+          required: false,
+          candidates: [],
+          selected: [],
+          useAll: false,
+          error: "",
+        },
+        release: null,
+        preview: null,
+        selectedTrackers: [],
+        ignoredDupesFor: [],
+        authorizedRulesByTracker: {},
+        questionnaireAnswers: {},
+        uploadOptions: emptyOptions(),
+        uploadInputRevision: state.uploadInputRevision + 1,
+        duplicatesError: "",
+        uploadError: "",
+      };
+    }
+    case "source_lookup_changed":
+      return preparationIntentChanged(state, {
+        ...state.preparationIntent,
+        sourceLookupURL: action.value,
+      });
+    case "identity_changed":
+      return preparationIntentChanged(state, {
+        ...state.preparationIntent,
+        identity: { ...action.value },
+      });
+    case "release_name_changed":
+      return preparationIntentChanged(state, {
+        ...state.preparationIntent,
+        releaseName: { ...action.value },
+      });
+    case "playlist_required": {
+      if (
+        !preparationMatches(state, action.sourcePath, action.commandRevision, action.correlationID)
+      ) {
+        return state;
+      }
+      const candidates = action.candidates.map((candidate) => ({
+        ...candidate,
+        items: (candidate.items || []).map((item) => ({ ...item })),
+      }));
+      return {
+        ...state,
+        preparation: {
+          ...state.preparation,
+          status: action.error ? "error" : "awaiting_input",
+          message: action.error || "Select one or more Blu-ray playlists.",
+          error: action.error,
+          failure: null,
+        },
+        playlist: {
+          status: action.error ? "error" : "awaiting_selection",
+          required: true,
+          candidates,
+          selected: candidates.length === 1 ? [candidates[0].file] : [],
+          useAll: false,
+          error: action.error,
+        },
+      };
+    }
+    case "playlist_draft_changed":
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Playlist selection changed.", false),
+        preparationDirty: Boolean(state.release),
+        playlist: {
+          ...state.playlist,
+          selected: [...action.playlists],
+          useAll: action.useAll,
+          error: "",
+        },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    case "playlist_dismissed":
+      return {
+        ...state,
+        preparation: {
+          ...state.preparation,
+          status: "cancelled",
+          message: "Playlist selection cancelled.",
+        },
+        playlist: { ...state.playlist, status: "cancelled", required: false, error: "" },
+      };
+    case "playlist_resumed":
+      if (
+        !preparationMatches(state, action.sourcePath, action.commandRevision, action.correlationID)
+      ) {
+        return state;
+      }
+      return {
+        ...state,
+        preparationIntent: clonePreparationIntent(action.intent),
+        preparation: {
+          ...state.preparation,
+          status: "running",
+          message: "Processing selected Blu-ray playlists.",
+          error: "",
+          failure: null,
+        },
+        playlist: { ...state.playlist, status: "processing", required: false, error: "" },
+      };
+    case "preparation_started":
+      if (action.sourcePath !== state.selectedSource) return state;
+      return {
+        ...state,
+        commandRevision: action.commandRevision,
+        preparationIntent: clonePreparationIntent(action.intent),
+        preparation: {
+          correlationID: action.correlationID,
+          sourcePath: action.sourcePath,
+          commandRevision: action.commandRevision,
+          status: "running",
+          message: "Preparing release metadata.",
+          steps: [],
+          error: "",
+          failure: null,
+        },
+        playlist: {
+          ...state.playlist,
+          status: action.intent.playlist.Set ? "processing" : "idle",
+          required: false,
+          selected: action.intent.playlist.Set
+            ? [...action.intent.playlist.Selected]
+            : state.playlist.selected,
+          useAll: action.intent.playlist.Set
+            ? action.intent.playlist.UseAll
+            : state.playlist.useAll,
+          error: "",
+        },
+      };
+    case "preparation_progressed":
+      if (
+        !preparationMatches(state, action.sourcePath, action.commandRevision, action.correlationID)
+      ) {
+        return state;
+      }
+      return {
+        ...state,
+        preparation: {
+          ...state.preparation,
+          message: action.step.message || state.preparation.message,
+          steps: upsertPreparationStep(state.preparation.steps, action.step),
+        },
+        playlist:
+          action.step.phase === "playlist_discovery" && action.step.status === "running"
+            ? { ...state.playlist, status: "discovering", error: "" }
+            : state.playlist,
+      };
+    case "preparation_succeeded": {
+      if (
+        !preparationMatches(state, action.sourcePath, action.commandRevision, action.correlationID)
+      ) {
+        return state;
+      }
+      const release = action.preview.Release;
+      const acceptedSource = release?.SourcePath?.trim() || action.preview.SourcePath.trim();
+      if (!acceptedSource || !release?.Generation || acceptedSource !== action.sourcePath) {
+        return {
+          ...state,
+          preparation: {
+            ...state.preparation,
+            status: "error",
+            message: "Preparation returned a different source.",
+            error: "Preparation returned a different source.",
+            failure: null,
+          },
+        };
+      }
+      return {
+        ...state,
+        ...invalidateReleaseWork(state, "Prepared generation changed."),
+        sessionRevision: state.sessionRevision + 1,
+        sourceDraft: acceptedSource,
+        selectedSource: acceptedSource,
+        preparation: {
+          ...state.preparation,
+          status: "ready",
+          message: "Metadata preparation complete.",
+          steps: completeRunningPreparationSteps(state.preparation.steps),
+          error: "",
+          failure: null,
+        },
+        preparationDirty: false,
+        release: { SourcePath: acceptedSource, Generation: release.Generation },
+        preview: action.preview,
+        playlist: {
+          ...state.playlist,
+          status:
+            state.playlist.status === "processing" || state.playlist.status === "complete"
+              ? "complete"
+              : state.playlist.status,
+          required: false,
+          error: "",
+        },
+        duplicatesError: "",
+        uploadError: "",
+      };
+    }
+    case "preparation_failed":
+      if (
+        !preparationMatches(state, action.sourcePath, action.commandRevision, action.correlationID)
+      ) {
+        return state;
+      }
+      return {
+        ...state,
+        preparation: {
+          ...state.preparation,
+          status: "error",
+          message: action.error,
+          steps: failCurrentPreparationStep(state.preparation.steps),
+          error: action.error,
+          failure: action.failure ? { ...action.failure } : null,
+        },
+        playlist:
+          state.playlist.status === "processing"
+            ? { ...state.playlist, status: "error", error: action.error }
+            : state.playlist,
+      };
+    case "trackers_chosen": {
+      const trackers = normalizeNames(action.trackers);
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Tracker selection changed.", false),
+        screenshots:
+          state.screenshots.status === "error"
+            ? {
+                ...state.screenshots,
+                status: "idle",
+                error: "",
+              }
+            : state.screenshots,
+        descriptions: {
+          ...invalidate(state.descriptions, "Tracker selection changed.", true),
+          inputRevision: state.descriptions.inputRevision + 1,
+          rawByGroup: {},
+          renderedByGroup: {},
+          dirtyGroups: [],
+          notice: "",
+        },
+        selectedTrackers: trackers,
+        authorizedRulesByTracker: {},
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    }
+    case "dupe_ignore_changed": {
+      const tracker = action.tracker.trim().toUpperCase();
+      if (!tracker) return state;
+      const ignored = new Set(state.ignoredDupesFor);
+      if (action.ignored) ignored.add(tracker);
+      else ignored.delete(tracker);
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Duplicate override changed.", false),
+        ignoredDupesFor: [...ignored],
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    }
+    case "rule_authorization_changed": {
+      const tracker = action.tracker.trim().toUpperCase();
+      const rule = action.rule.trim();
+      if (!tracker || !rule) return state;
+      const rules = new Set(state.authorizedRulesByTracker[tracker] || []);
+      if (action.authorized) rules.add(rule);
+      else rules.delete(rule);
+      const authorizedRulesByTracker = { ...state.authorizedRulesByTracker };
+      if (rules.size > 0) authorizedRulesByTracker[tracker] = [...rules];
+      else delete authorizedRulesByTracker[tracker];
+      return {
+        ...state,
+        review: invalidate(state.review, "Rule authorization changed.", true),
+        authorizedRulesByTracker,
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    }
+    case "questionnaire_answered": {
+      const tracker = action.tracker.trim().toUpperCase();
+      const key = action.key.trim();
+      if (!tracker || !key) return state;
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Questionnaire answers changed.", false),
+        questionnaireAnswers: {
+          ...state.questionnaireAnswers,
+          [tracker]: { ...state.questionnaireAnswers[tracker], [key]: action.value },
+        },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    }
+    case "upload_options_changed":
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Upload options changed.", false),
+        uploadOptions: { ...state.uploadOptions, ...action.value },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    case "screenshot_selection_changed":
+      return {
+        ...state,
+        screenshots: {
+          ...state.screenshots,
+          selections: state.screenshots.selections.map((selection, index) =>
+            index === action.index ? { ...selection, ...action.value } : selection,
+          ),
+        },
+      };
+    case "screenshot_final_paths_changed":
+      return {
+        ...state,
+        screenshots: {
+          ...state.screenshots,
+          finalSelectionPaths: Array.from(
+            new Set(action.imagePaths.map((path) => path.trim()).filter(Boolean)),
+          ),
+        },
+      };
+    case "job_command_started":
+      return action.kind === "duplicates"
+        ? { ...state, duplicatesError: "" }
+        : { ...state, uploadError: "" };
+    case "job_command_failed":
+      return action.kind === "duplicates"
+        ? { ...state, duplicatesError: action.error }
+        : { ...state, uploadError: action.error };
+    case "workflow_started":
+      if (action.sessionRevision !== state.sessionRevision) return state;
+      return { ...state, [action.facet]: startWorkflow(state[action.facet], action.revision) };
+    case "workflow_failed":
+      if (!workflowMatches(state, action.facet, action.sessionRevision, action.revision))
+        return state;
+      return { ...state, [action.facet]: failWorkflow(state[action.facet], action.error) };
+    case "workflow_canceled":
+      if (!workflowMatches(state, action.facet, action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        [action.facet]: {
+          ...state[action.facet],
+          revision: state[action.facet].revision + 1,
+          status: "idle",
+          staleReason: "Operation canceled.",
+          error: "",
+        },
+      };
+    case "screenshots_loaded":
+      if (!workflowMatches(state, "screenshots", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        ...(action.changed ? invalidateAssetConsumers(state) : {}),
+        screenshots: {
+          ...readyWorkflow(state.screenshots),
+          value: action.plan,
+          result: action.result ?? state.screenshots.result,
+          selections: action.reseedDrafts
+            ? action.plan.SuggestedSelections || []
+            : state.screenshots.selections,
+          finalSelectionPaths:
+            action.finalSelectionPaths ??
+            (action.reseedDrafts
+              ? (action.plan.FinalSelections || []).map((image) => image.Path).filter(Boolean)
+              : state.screenshots.finalSelectionPaths),
+        },
+      };
+    case "screenshot_previewed":
+      if (!workflowMatches(state, "screenshots", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        screenshots: { ...readyWorkflow(state.screenshots), previewImage: action.image },
+      };
+    case "menu_images_loaded":
+      if (!workflowMatches(state, "menuImages", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        ...(action.changed ? invalidateAssetConsumers(state) : {}),
+        menuImages: {
+          ...readyWorkflow(state.menuImages),
+          value: action.images,
+          capture: action.capture ?? state.menuImages.capture,
+        },
+      };
+    case "uploaded_images_loaded":
+      if (!workflowMatches(state, "uploadedImages", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        ...(action.changed ? invalidateAssetConsumers(state) : {}),
+        uploadedImages: {
+          ...readyWorkflow(state.uploadedImages),
+          value: { candidates: action.candidates, uploaded: action.uploaded },
+          selectedPaths: action.candidates.map((item) => item.image.Path).filter(Boolean),
+          failures: action.failures ?? [],
+        },
+      };
+    case "uploaded_images_progress_reset":
+      if (!workflowMatches(state, "uploadedImages", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        uploadedImages: {
+          ...state.uploadedImages,
+          progress: { correlationID: action.correlationID, attempts: [] },
+        },
+      };
+    case "uploaded_images_progressed": {
+      if (!workflowMatches(state, "uploadedImages", action.sessionRevision, action.revision))
+        return state;
+      if (state.uploadedImages.progress.correlationID !== action.update.correlationID) return state;
+      const total = Math.max(0, action.update.total);
+      const attemptID = action.update.attemptID.trim();
+      if (!attemptID) return state;
+      const update: ImageUploadProgressUpdate = {
+        ...action.update,
+        attemptID,
+        completed: Math.max(0, Math.min(action.update.completed, total)),
+        total,
+        succeeded: Math.max(0, action.update.succeeded),
+        failed: Math.max(0, action.update.failed),
+        reused: Math.max(0, action.update.reused),
+        trackers: [...action.update.trackers],
+      };
+      const attempts = state.uploadedImages.progress.attempts.some(
+        (current) => current.attemptID === attemptID,
+      )
+        ? state.uploadedImages.progress.attempts.map((current) =>
+            current.attemptID === attemptID ? update : current,
+          )
+        : [...state.uploadedImages.progress.attempts, update];
+      return {
+        ...state,
+        uploadedImages: {
+          ...state.uploadedImages,
+          progress: { ...state.uploadedImages.progress, attempts },
+        },
+      };
+    }
+    case "upload_host_changed":
+      return { ...state, uploadedImages: { ...state.uploadedImages, host: action.host } };
+    case "upload_image_selected": {
+      const selected = new Set(state.uploadedImages.selectedPaths);
+      if (action.selected) selected.add(action.imagePath);
+      else selected.delete(action.imagePath);
+      return {
+        ...state,
+        uploadedImages: { ...state.uploadedImages, selectedPaths: [...selected] },
+      };
+    }
+    case "upload_images_selected_all":
+      return {
+        ...state,
+        uploadedImages: {
+          ...state.uploadedImages,
+          selectedPaths: action.selected
+            ? (state.uploadedImages.value?.candidates || [])
+                .map((item) => item.image.Path)
+                .filter(Boolean)
+            : [],
+        },
+      };
+    case "description_edited": {
+      const groupKey = action.groupKey.trim();
+      if (!groupKey) return state;
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Description changed.", false),
+        descriptions: {
+          ...state.descriptions,
+          inputRevision: state.descriptions.inputRevision + 1,
+          rawByGroup: { ...state.descriptions.rawByGroup, [groupKey]: action.raw },
+          dirtyGroups: Array.from(new Set([...state.descriptions.dirtyGroups, groupKey])),
+          notice: "",
+        },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    }
+    case "descriptions_loaded":
+      if (!workflowMatches(state, "descriptions", action.sessionRevision, action.revision))
+        return state;
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Descriptions regenerated.", false),
+        descriptions: {
+          ...readyWorkflow(state.descriptions),
+          inputRevision: state.descriptions.inputRevision + 1,
+          value: action.preview,
+          rawByGroup: Object.fromEntries(
+            (action.preview.Groups || []).map((group) => [
+              group.GroupKey,
+              group.RawDescription || "",
+            ]),
+          ),
+          renderedByGroup: Object.fromEntries(
+            (action.preview.Groups || []).map((group) => [
+              group.GroupKey,
+              group.RawDescriptionHTML || "",
+            ]),
+          ),
+          dirtyGroups: [],
+          notice: "",
+        },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    case "description_rendered":
+      if (
+        !workflowMatches(state, "descriptions", action.sessionRevision, action.revision) ||
+        action.inputRevision !== state.descriptions.inputRevision
+      ) {
+        return state;
+      }
+      return {
+        ...state,
+        descriptions: {
+          ...readyWorkflow(state.descriptions),
+          renderedByGroup: {
+            ...state.descriptions.renderedByGroup,
+            [action.groupKey]: action.html,
+          },
+        },
+      };
+    case "description_saved":
+      if (
+        !workflowMatches(state, "descriptions", action.sessionRevision, action.revision) ||
+        action.inputRevision !== state.descriptions.inputRevision
+      ) {
+        return state;
+      }
+      return {
+        ...state,
+        ...invalidateAuthority(state, "Description saved; run dry run again.", false),
+        descriptions: {
+          ...readyWorkflow(state.descriptions),
+          inputRevision: state.descriptions.inputRevision + 1,
+          value: upsertDescriptionGroup(state.descriptions.value, action.group),
+          rawByGroup: {
+            ...state.descriptions.rawByGroup,
+            [action.group.GroupKey]: action.group.RawDescription || "",
+          },
+          renderedByGroup: {
+            ...state.descriptions.renderedByGroup,
+            [action.group.GroupKey]: action.group.RawDescriptionHTML || "",
+          },
+          dirtyGroups: state.descriptions.dirtyGroups.filter(
+            (groupKey) => groupKey !== action.group.GroupKey,
+          ),
+          notice: "Description saved.",
+        },
+        uploadInputRevision: state.uploadInputRevision + 1,
+      };
+    case "dry_run_loaded":
+      if (
+        !workflowMatches(state, "dryRun", action.sessionRevision, action.revision) ||
+        action.inputRevision !== state.uploadInputRevision
+      ) {
+        return state;
+      }
+      return { ...state, dryRun: { ...readyWorkflow(state.dryRun), value: action.preview } };
+    case "review_loaded":
+      if (
+        !workflowMatches(state, "review", action.sessionRevision, action.revision) ||
+        action.inputRevision !== state.uploadInputRevision
+      ) {
+        return state;
+      }
+      return { ...state, review: { ...readyWorkflow(state.review), value: action.review } };
+  }
+};
diff --git a/webui/src/releaseSession/types.ts b/webui/src/releaseSession/types.ts
new file mode 100644
index 00000000..3f6ac0be
--- /dev/null
+++ b/webui/src/releaseSession/types.ts
@@ -0,0 +1,297 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  DescriptionBuilderPreview,
+  DVDMenuCaptureResult,
+  DupeCheckSnapshot,
+  ExternalIDOverrides,
+  ImageUploadProgressUpdate,
+  MetadataPreview,
+  OperationFailure,
+  PlaylistInfo,
+  PreparationProgressUpdate,
+  ReleaseNameOverrides,
+  ReleaseRef,
+  ScreenshotImage,
+  ScreenshotPlan,
+  ScreenshotPurpose,
+  ScreenshotResult,
+  ScreenshotSelection,
+  TrackerDryRunPreview,
+  TrackerEligibility,
+  TrackerPreview,
+  TrackerUploadSnapshot,
+  UploadedImageLink,
+  UploadImageHostFailure,
+  UploadReviewResult,
+} from "../types";
+
+export type ReleaseRoute =
+  | "input"
+  | "trackerData"
+  | "duplicates"
+  | "screenshots"
+  | "menuImages"
+  | "uploadedImages"
+  | "descriptions"
+  | "upload";
+
+export type RouteAccess = Readonly<{ available: boolean; reason: string }>;
+export type FacetStatus = "idle" | "running" | "ready" | "error";
+
+/** Lifecycle of one correlation-scoped canonical preparation attempt. */
+export type PreparationStatus =
+  | "idle"
+  | "running"
+  | "awaiting_input"
+  | "ready"
+  | "error"
+  | "cancelled";
+
+/** Blu-ray playlist discovery and selection lifecycle within preparation. */
+export type PlaylistStatus =
+  | "idle"
+  | "discovering"
+  | "awaiting_selection"
+  | "processing"
+  | "complete"
+  | "error"
+  | "cancelled";
+
+/** Ordered advisory preparation stage retained after transport correlation is validated. */
+export type PreparationStep = Readonly<
+  Omit<PreparationProgressUpdate, "correlationID" | "status"> & {
+    status: PreparationProgressUpdate["status"] | "awaiting_input";
+  }
+>;
+
+export type PreparationIntent = Readonly<{
+  sourceLookupURL: string;
+  identity: Readonly<ExternalIDOverrides>;
+  releaseName: Readonly<ReleaseNameOverrides>;
+  playlist: Readonly<{ Set: boolean; Selected: readonly string[]; UseAll: boolean }>;
+}>;
+
+export type UploadRunOptions = Readonly<{
+  noSeed: boolean;
+  runLogLevel: string;
+}>;
+
+export type IdentityFacet = Readonly<{
+  view: Readonly<{
+    sessionRevision: number;
+    sourcePath: string;
+    release: ReleaseRef | null;
+    preview: MetadataPreview | null;
+  }>;
+}>;
+
+export type NavigationFacet = Readonly<{
+  view: Readonly<{ access: Readonly<Record<ReleaseRoute, RouteAccess>> }>;
+  open(route: ReleaseRoute): boolean;
+}>;
+
+/** Source selection, canonical preparation, progress, and prerequisite controls. */
+export type InputFacet = Readonly<{
+  view: Readonly<{
+    sourceDraft: string;
+    selectedSource: string;
+    status: PreparationStatus;
+    error: string;
+    failure: OperationFailure | null;
+    preparationDirty: boolean;
+    intent: PreparationIntent;
+    selectedTrackers: readonly string[];
+    progress: Readonly<{
+      correlationID: string;
+      status: PreparationStatus;
+      message: string;
+      steps: readonly PreparationStep[];
+    }>;
+    preview: MetadataPreview | null;
+    trackerData: readonly TrackerPreview[];
+    playlist: Readonly<{
+      status: PlaylistStatus;
+      required: boolean;
+      candidates: readonly PlaylistInfo[];
+      selected: readonly string[];
+      useAll: boolean;
+      error: string;
+    }>;
+  }>;
+  updateSourceDraft(value: string): void;
+  selectSource(value: string): void;
+  changeSourceLookupURL(value: string): void;
+  changeIdentity(value: Readonly<ExternalIDOverrides>): void;
+  changeReleaseName(value: Readonly<ReleaseNameOverrides>): void;
+  chooseTrackers(trackers: readonly string[]): void;
+  choosePlaylists(playlists: readonly string[], useAll: boolean): void;
+  confirmPlaylists(): Promise<boolean>;
+  cancelPlaylistSelection(): void;
+  prepareSource(sourcePath: string, intent: PreparationIntent): Promise<boolean>;
+  resetSource(sourcePath: string, intent: PreparationIntent): Promise<boolean>;
+  prepare(): Promise<boolean>;
+  reset(): Promise<boolean>;
+  confirmBDMVRescan(): Promise<boolean>;
+  selectCandidate(releaseID: string): Promise<boolean>;
+}>;
+
+/** Duplicate-check commands and retained per-tracker Job progress for the active generation. */
+export type DuplicatesFacet = Readonly<{
+  view: Readonly<{
+    status: FacetStatus;
+    snapshot: DupeCheckSnapshot | null;
+    eligibility: TrackerEligibility | null;
+    ignoredTrackers: readonly string[];
+    selectedTrackers: readonly string[];
+    error: string;
+    transientError: string;
+  }>;
+  run(): Promise<boolean>;
+  cancel(): Promise<boolean>;
+  chooseTrackers(trackers: readonly string[]): void;
+  setIgnored(tracker: string, ignored: boolean): void;
+}>;
+
+/** Screenshot planning, generation, preview, removal, ordering, and final selection state. */
+export type ScreenshotsFacet = Readonly<{
+  view: Readonly<{
+    revision: number;
+    status: FacetStatus;
+    plan: ScreenshotPlan | null;
+    result: ScreenshotResult | null;
+    selections: readonly ScreenshotSelection[];
+    finalSelectionPaths: readonly string[];
+    previewImage: string;
+    staleReason: string;
+    error: string;
+  }>;
+  load(): Promise<boolean>;
+  changeSelection(
+    index: number,
+    value: Partial<Pick<ScreenshotSelection, "TimestampSeconds" | "Frame">>,
+  ): void;
+  generate(
+    purpose: ScreenshotPurpose,
+    selections?: readonly ScreenshotSelection[],
+  ): Promise<boolean>;
+  previewFrame(timestampSeconds: number): Promise<boolean>;
+  remove(imagePath: string): Promise<boolean>;
+  removeMany(imagePaths: readonly string[]): Promise<boolean>;
+  removeTrackerURL(url: string): Promise<boolean>;
+  removeTrackerURLs(urls: readonly string[]): Promise<boolean>;
+  selectFinal(imagePath: string, selected: boolean): Promise<boolean>;
+  reorderFinal(fromIndex: number, toIndex: number): Promise<boolean>;
+  saveFinal(): Promise<boolean>;
+  readImage(path: string): Promise<string>;
+}>;
+
+export type MenuImagePreview = Readonly<{ image: ScreenshotImage; dataURI: string }>;
+export type UploadedImageCandidate = Readonly<{ image: ScreenshotImage; dataURI: string }>;
+
+export type MenuImagesFacet = Readonly<{
+  view: Readonly<{
+    revision: number;
+    status: FacetStatus;
+    images: readonly MenuImagePreview[];
+    capture: DVDMenuCaptureResult | null;
+    staleReason: string;
+    error: string;
+  }>;
+  load(): Promise<boolean>;
+  importPaths(paths: readonly string[]): Promise<boolean>;
+  capture(): Promise<boolean>;
+  cancelCapture(): void;
+  remove(imagePath: string): Promise<boolean>;
+}>;
+
+/** Correlated absolute host-attempt snapshots for one image upload command. */
+export type ImageUploadProgress = Readonly<{
+  correlationID: string;
+  attempts: readonly ImageUploadProgressUpdate[];
+}>;
+
+/** Image-host candidate selection, upload progress, results, and removal state. */
+export type UploadedImagesFacet = Readonly<{
+  view: Readonly<{
+    revision: number;
+    status: FacetStatus;
+    candidates: readonly UploadedImageCandidate[];
+    uploaded: readonly UploadedImageLink[];
+    selectedPaths: readonly string[];
+    host: string;
+    failures: readonly UploadImageHostFailure[];
+    progress: ImageUploadProgress;
+    staleReason: string;
+    error: string;
+  }>;
+  load(): Promise<boolean>;
+  chooseHost(host: string): void;
+  select(imagePath: string, selected: boolean): void;
+  selectAll(selected: boolean): void;
+  upload(): Promise<boolean>;
+  remove(imagePath: string, host: string): Promise<boolean>;
+}>;
+
+export type DescriptionsFacet = Readonly<{
+  view: Readonly<{
+    revision: number;
+    status: FacetStatus;
+    preview: DescriptionBuilderPreview | null;
+    rawByGroup: Readonly<Record<string, string>>;
+    renderedByGroup: Readonly<Record<string, string>>;
+    dirtyGroups: readonly string[];
+    staleReason: string;
+    notice: string;
+    error: string;
+  }>;
+  load(): Promise<boolean>;
+  edit(groupKey: string, raw: string): void;
+  render(groupKey: string): Promise<boolean>;
+  save(groupKey: string): Promise<boolean>;
+  reset(groupKey: string): Promise<boolean>;
+}>;
+
+export type UploadFacet = Readonly<{
+  view: Readonly<{
+    revision: number;
+    selectedTrackers: readonly string[];
+    eligibility: TrackerEligibility | null;
+    ignoredDupesFor: readonly string[];
+    authorizedRulesByTracker: Readonly<Record<string, readonly string[]>>;
+    questionnaireAnswers: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    options: UploadRunOptions;
+    dryRunStatus: FacetStatus;
+    dryRun: TrackerDryRunPreview | null;
+    dryRunStaleReason: string;
+    reviewStatus: FacetStatus;
+    review: UploadReviewResult | null;
+    reviewStaleReason: string;
+    snapshot: TrackerUploadSnapshot | null;
+    error: string;
+    transientError: string;
+  }>;
+  chooseTrackers(trackers: readonly string[]): void;
+  answerQuestionnaire(tracker: string, key: string, value: string): void;
+  changeOptions(options: Partial<UploadRunOptions>): void;
+  setRuleAuthorized(tracker: string, rule: string, authorized: boolean): void;
+  runDryRun(): Promise<boolean>;
+  review(): Promise<boolean>;
+  start(): Promise<boolean>;
+  cancel(): Promise<boolean>;
+  retry(): Promise<boolean>;
+}>;
+
+/** Sole public active-release workflow interface. */
+export type ReleaseSession = Readonly<{
+  identity: IdentityFacet;
+  navigation: NavigationFacet;
+  input: InputFacet;
+  duplicates: DuplicatesFacet;
+  screenshots: ScreenshotsFacet;
+  menuImages: MenuImagesFacet;
+  uploadedImages: UploadedImagesFacet;
+  descriptions: DescriptionsFacet;
+  upload: UploadFacet;
+}>;
diff --git a/webui/src/settings/trackerFields.ts b/webui/src/settings/trackerFields.ts
new file mode 100644
index 00000000..0079e038
--- /dev/null
+++ b/webui/src/settings/trackerFields.ts
@@ -0,0 +1,84 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { FieldMeta } from "../types";
+
+const stringField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "string",
+  ...meta,
+});
+
+const boolField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "boolean",
+  ...meta,
+});
+
+const numberField = (key: string, meta: Omit<FieldMeta, "key" | "type"> = {}): FieldMeta => ({
+  key,
+  type: "number",
+  ...meta,
+});
+
+/** Generic presentation metadata for config-catalog tracker fields. */
+const trackerFieldMeta: Record<string, FieldMeta> = {
+  LinkDirName: stringField("LinkDirName", { label: "Link dir name", advanced: true }),
+  APIKey: stringField("APIKey", { label: "API key", sensitive: true }),
+  ApiKey: stringField("ApiKey", { label: "API key", sensitive: true }),
+  ApiUser: stringField("ApiUser", { label: "API user", sensitive: true }),
+  Username: stringField("Username", { label: "Username" }),
+  Password: stringField("Password", { label: "Password", sensitive: true }),
+  Passkey: stringField("Passkey", { label: "Passkey", sensitive: true }),
+  AnnounceURL: stringField("AnnounceURL", { label: "Announce URL", sensitive: true }),
+  MyAnnounceURL: stringField("MyAnnounceURL", {
+    label: "My announce URL",
+    sensitive: true,
+  }),
+  FaviconURL: stringField("FaviconURL", { label: "Favicon URL", advanced: true }),
+  UploaderName: stringField("UploaderName", { label: "Uploader name" }),
+  UploaderStatus: boolField("UploaderStatus", { label: "Uploader status" }),
+  CustomLayout: stringField("CustomLayout", { label: "Custom layout" }),
+  TagForCustomRelease: stringField("TagForCustomRelease", { label: "Tag for custom release" }),
+  CheckForRules: boolField("CheckForRules", { label: "Check for rules" }),
+  ModQ: boolField("ModQ", { label: "Mod queue" }),
+  Draft: boolField("Draft", { label: "Draft" }),
+  DraftDefault: boolField("DraftDefault", { label: "Draft default" }),
+  Anon: boolField("Anon", { label: "Anonymous" }),
+  ShowGroupIfAnon: boolField("ShowGroupIfAnon", { label: "Show group if anon" }),
+  BhdRSSKey: stringField("BhdRSSKey", { label: "BHD RSS key", sensitive: true }),
+  CheckRequests: boolField("CheckRequests", { label: "Check requests" }),
+  FullMediainfo: boolField("FullMediainfo", { label: "Full mediainfo" }),
+  ImgRehost: boolField("ImgRehost", { label: "Image rehost" }),
+  ImageHost: stringField("ImageHost", { label: "Image host" }),
+  TorrentClient: stringField("TorrentClient", { label: "Torrent client", advanced: true }),
+  UseSpanishTitle: boolField("UseSpanishTitle", { label: "Use Spanish title" }),
+  UseItalianTitle: boolField("UseItalianTitle", { label: "Use Italian title" }),
+  OTPURI: stringField("OTPURI", { label: "OTP URI", sensitive: true }),
+  SkipIfRehash: boolField("SkipIfRehash", { label: "Skip if rehash", advanced: true }),
+  PreferMTV: boolField("PreferMTV", { label: "Prefer MTV torrent", advanced: true }),
+  PTGenAPI: stringField("PTGenAPI", { label: "PTGen API", sensitive: true }),
+  AddWebSourceToDesc: boolField("AddWebSourceToDesc", { label: "Add web source to desc" }),
+  UseMetadataName: boolField("UseMetadataName", { label: "Use metadata name" }),
+  InjectDelay: numberField("InjectDelay", { label: "Inject delay", advanced: true }),
+  ImageCount: numberField("ImageCount", { label: "Image count" }),
+  Channel: stringField("Channel", { label: "Channel" }),
+  ImgAPI: stringField("ImgAPI", { label: "Image API", sensitive: true }),
+  PronfoAPIKey: stringField("PronfoAPIKey", { label: "Pronfo API key", sensitive: true }),
+  PronfoTheme: stringField("PronfoTheme", { label: "Pronfo theme" }),
+  PronfoRAPIID: stringField("PronfoRAPIID", { label: "Pronfo RAPI ID" }),
+  APIUpload: boolField("APIUpload", { label: "API upload" }),
+  Exclusive: boolField("Exclusive", { label: "Exclusive" }),
+  LoginQuestion: stringField("LoginQuestion", { label: "Login question", sensitive: true }),
+  LoginAnswer: stringField("LoginAnswer", { label: "Login answer", sensitive: true }),
+  UserID: stringField("UserID", { label: "User ID", sensitive: true }),
+  Internal: boolField("Internal", { label: "Internal" }),
+  InternalGroups: stringField("InternalGroups", { label: "Internal groups" }),
+};
+
+/** Resolves a catalog field to renderer metadata and rejects schema drift. */
+export const trackerFieldPresentation = (key: string): FieldMeta => {
+  const field = trackerFieldMeta[key];
+  if (!field) throw new Error(`Unsupported tracker config field: ${key}`);
+  return field;
+};
diff --git a/gui/frontend/src/styles.css b/webui/src/styles.css
similarity index 98%
rename from gui/frontend/src/styles.css
rename to webui/src/styles.css
index d3cab8e0..011945ad 100644
--- a/gui/frontend/src/styles.css
+++ b/webui/src/styles.css
@@ -728,6 +728,14 @@ button:hover:not(:disabled) {
   color: var(--success);
 }
 
+.metadata-progress__item--awaiting_input .metadata-progress__status {
+  color: var(--accent);
+}
+
+.metadata-progress__item--skipped .metadata-progress__status {
+  color: var(--muted);
+}
+
 .metadata-progress__item--failed .metadata-progress__status {
   color: var(--danger);
 }
@@ -1720,29 +1728,10 @@ h2 {
   z-index: 40;
 }
 
-.source-path-input-shell--drop-target {
-  --wails-drop-target: drop;
-}
-
 .source-path-input {
   width: 100%;
 }
 
-.source-path-input-shell--drop-target.wails-drop-target-active .source-path-input,
-.source-path-input-shell--drop-target .source-path-input.wails-drop-target-active {
-  border-color: var(--accent);
-  box-shadow:
-    0 0 0 1px rgba(245, 185, 66, 0.55),
-    0 0 0 4px rgba(245, 185, 66, 0.18);
-}
-
-:root.light .source-path-input-shell--drop-target.wails-drop-target-active .source-path-input,
-:root.light .source-path-input-shell--drop-target .source-path-input.wails-drop-target-active {
-  box-shadow:
-    0 0 0 1px rgba(217, 119, 6, 0.5),
-    0 0 0 4px rgba(217, 119, 6, 0.16);
-}
-
 .source-path-history {
   position: absolute;
   z-index: 30;
diff --git a/webui/src/test/appRequestMock.ts b/webui/src/test/appRequestMock.ts
new file mode 100644
index 00000000..02da724a
--- /dev/null
+++ b/webui/src/test/appRequestMock.ts
@@ -0,0 +1,122 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+type Operation = (...args: any[]) => unknown;
+export type AppOperationMocks = Record<string, Operation | undefined>;
+
+let currentOperations: AppOperationMocks | undefined;
+
+export const installAppOperationMocks = (operations: AppOperationMocks) => {
+  currentOperations = operations;
+  return operations;
+};
+
+export const getAppOperationMocks = () => currentOperations;
+
+export const clearAppOperationMocks = () => {
+  currentOperations = undefined;
+};
+
+/** Adapts typed request bodies to positional operation mocks used by component tests. */
+export const invokeAppRequestMock = async (
+  operations: AppOperationMocks,
+  method: string,
+  body?: unknown,
+  options: { signal?: AbortSignal } = {},
+) => {
+  const operation = operations[method];
+  if (!operation) throw new Error(`unexpected app request: ${method}`);
+
+  const payload = (body || {}) as Record<string, any>;
+  const argsByMethod: Record<string, unknown[]> = {
+    BrowseDirectory: [payload.path, payload.mode],
+    DetectDiscType: [payload.Path],
+    FetchMetadata: [
+      payload.Path,
+      payload.SourceLookupURL,
+      payload.Overrides,
+      payload.NameOverrides,
+      payload.Trackers,
+      payload.Playlist,
+      payload.ConfirmBDMVRescan,
+    ],
+    PrepareRelease: [payload.Input],
+    ResetMetadata: [
+      payload.Path,
+      payload.SourceLookupURL,
+      payload.Overrides,
+      payload.NameOverrides,
+      payload.Trackers,
+      payload.Playlist,
+      payload.ConfirmBDMVRescan,
+    ],
+    SelectBlurayCandidate: [payload.Path, payload.ReleaseID],
+    FetchDescriptionBuilder: [payload.Release, payload.Trackers, payload.IgnoreDupesFor],
+    FetchPreparation: [
+      payload.Path,
+      payload.Overrides,
+      payload.NameOverrides,
+      payload.Trackers,
+      payload.IgnoreDupesFor,
+    ],
+    FetchTrackerDryRun: [
+      payload.DupeJobID,
+      payload.Release,
+      payload.Trackers,
+      payload.IgnoreDupesFor,
+      payload.QuestionnaireAnswers,
+      payload.DescriptionGroups,
+      payload.NoSeed,
+      payload.RunLogLevel,
+    ],
+    StartDupeCheck: [payload.Release, payload.Trackers, payload.CorrelationID],
+    CancelDupeCheck: [payload.JobID],
+    GetDupeCheckSnapshot: [payload.JobID],
+    FetchScreenshotPlan: [payload.Release],
+    GenerateScreenshots: [payload.Release, payload.Selections, payload.Purpose],
+    PreviewScreenshotFrame: [payload.Release, payload.TimestampSeconds],
+    DeleteScreenshot: [payload.Release, payload.ImagePath],
+    SaveFinalScreenshotSelections: [payload.Release, payload.Images],
+    ImportMenuImages: [payload.Release, payload.Paths],
+    CaptureDVDMenus: [payload.Release, options.signal],
+    ListDVDMenuScreenshots: [payload.Release],
+    DeleteDVDMenuScreenshot: [payload.Release, payload.ImagePath],
+    ReadScreenshotImage: [payload.Path],
+    ListUploadCandidates: [payload.Release],
+    ListUploadedImages: [payload.Release],
+    UploadImages: [payload.Release, payload.Trackers, payload.Host, payload.Images],
+    DeleteUploadedImage: [payload.Release, payload.ImagePath, payload.Host],
+    DeleteTrackerImageURL: [payload.Release, payload.URL],
+    RenderDescription: [payload.Raw],
+    SaveDescriptionOverride: [payload.Release, payload.GroupKey, payload.Raw, payload.Trackers],
+    DiscoverPlaylists: [payload.Path],
+    SaveConfig: [payload.Payload],
+    GetRecentLogs: [payload.Limit],
+    StopLogStream: [payload.StreamID],
+    UpdateLogExclusions: [payload.Patterns],
+    GetTrackerAuthStatus: [payload.Tracker],
+    ImportTrackerAuthCookieContent: [payload.Tracker, payload.FileName, payload.Content],
+    TestTrackerAuth: [payload.Tracker],
+    LoginTrackerAuth: [payload.Tracker, payload.Login],
+    SubmitTrackerAuth2FA: [payload.ChallengeID, payload.Code],
+    DeleteTrackerAuth: [payload.Tracker],
+    GetHistoryOverview: [payload.SourcePath],
+    DeleteHistoryRelease: [payload.SourcePath],
+    ReviewTrackerUpload: [
+      payload.Release,
+      payload.Trackers,
+      payload.IgnoreDupesFor,
+      payload.QuestionnaireAnswers,
+      payload.DescriptionGroups,
+      payload.NoSeed,
+      payload.RunLogLevel,
+    ],
+    StartReviewedTrackerUpload: [payload.Token, payload.CorrelationID],
+    CancelTrackerUpload: [payload.JobID],
+    RetryFailedTrackerUpload: [payload.JobID, payload.CorrelationID],
+    ListJobs: [],
+    GetTrackerUploadSnapshot: [payload.JobID],
+    GetTrackerIcon: [payload.Domain, payload.URL],
+  };
+  return operation(...(argsByMethod[method] || []));
+};
diff --git a/webui/src/test/setup.ts b/webui/src/test/setup.ts
new file mode 100644
index 00000000..b84d0f69
--- /dev/null
+++ b/webui/src/test/setup.ts
@@ -0,0 +1,24 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import "@testing-library/jest-dom/vitest";
+import { afterEach, beforeEach } from "vitest";
+import { setAppRequestHandlerForTests } from "../api/client";
+import {
+  clearAppOperationMocks,
+  getAppOperationMocks,
+  invokeAppRequestMock,
+} from "./appRequestMock";
+
+beforeEach(() => {
+  setAppRequestHandlerForTests(async (method, body, options) => {
+    const operations = getAppOperationMocks();
+    if (!operations) throw new Error(`missing app request mock for ${method}`);
+    return invokeAppRequestMock(operations, method, body, options);
+  });
+});
+
+afterEach(() => {
+  setAppRequestHandlerForTests(null);
+  clearAppOperationMocks();
+});
diff --git a/webui/src/trackerCatalog/index.test.tsx b/webui/src/trackerCatalog/index.test.tsx
new file mode 100644
index 00000000..81b6b065
--- /dev/null
+++ b/webui/src/trackerCatalog/index.test.tsx
@@ -0,0 +1,42 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { ReactNode } from "react";
+import { renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { clearAppOperationMocks, installAppOperationMocks } from "../test/appRequestMock";
+import { TrackerCatalogProvider, useTrackerCatalog } from ".";
+
+afterEach(clearAppOperationMocks);
+
+describe("TrackerCatalogProvider", () => {
+  it("shares one catalog request across consumers", async () => {
+    const list = vi.fn(async () => ({
+      entries: [
+        {
+          name: "BTN",
+          family: "standalone",
+          baseURL: "https://btn.example.invalid",
+          uploadContentMode: "none",
+          fields: [],
+          configured: true,
+        },
+      ],
+      unsupported: [],
+    }));
+    installAppOperationMocks({ ListTrackerCatalog: list });
+    const wrapper = ({ children }: Readonly<{ children: ReactNode }>) => (
+      <TrackerCatalogProvider>{children}</TrackerCatalogProvider>
+    );
+
+    const { result } = renderHook(
+      () => ({ first: useTrackerCatalog(), second: useTrackerCatalog() }),
+      { wrapper },
+    );
+
+    await waitFor(() => expect(result.current.first.loaded).toBe(true));
+    expect(list).toHaveBeenCalledTimes(1);
+    expect(result.current.first.catalog).toBe(result.current.second.catalog);
+    expect(result.current.first.catalog?.entries[0]?.uploadContentMode).toBe("none");
+  });
+});
diff --git a/webui/src/trackerCatalog/index.tsx b/webui/src/trackerCatalog/index.tsx
new file mode 100644
index 00000000..d4cf5a2f
--- /dev/null
+++ b/webui/src/trackerCatalog/index.tsx
@@ -0,0 +1,85 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { ReactNode } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { trackerCatalogClient } from "../api/app";
+import type { TrackerCatalog } from "../types";
+
+type TrackerCatalogState = Readonly<{
+  catalog: TrackerCatalog | null;
+  loading: boolean;
+  loaded: boolean;
+  error: string;
+  removeUnsupported(name: string): void;
+}>;
+
+const TrackerCatalogContext = createContext<TrackerCatalogState | null>(null);
+
+const useTrackerCatalogOwner = (enabled: boolean): TrackerCatalogState => {
+  const [catalog, setCatalog] = useState<TrackerCatalog | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [loaded, setLoaded] = useState(false);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    if (!enabled || loaded) return;
+    let active = true;
+    setLoading(true);
+    void trackerCatalogClient
+      .list()
+      .then((result) => {
+        if (!active) return;
+        if (!result || !Array.isArray(result.entries) || !Array.isArray(result.unsupported)) {
+          throw new Error("Tracker catalog response is invalid.");
+        }
+        setCatalog(result);
+        setError("");
+      })
+      .catch((reason: unknown) => {
+        if (active) setError(String(reason));
+      })
+      .finally(() => {
+        if (!active) return;
+        setLoading(false);
+        setLoaded(true);
+      });
+    return () => {
+      active = false;
+    };
+  }, [enabled, loaded]);
+
+  const removeUnsupported = useCallback((name: string) => {
+    setCatalog((current) =>
+      current
+        ? {
+            ...current,
+            unsupported: current.unsupported.filter((entry) => entry !== name),
+          }
+        : current,
+    );
+  }, []);
+
+  return useMemo(
+    () => ({ catalog, loading, loaded, error, removeUnsupported }),
+    [catalog, error, loaded, loading, removeUnsupported],
+  );
+};
+
+/** Owns the single production tracker-catalog request shared across app workflows. */
+export function TrackerCatalogProvider({ children }: Readonly<{ children: ReactNode }>) {
+  const state = useTrackerCatalogOwner(true);
+  return <TrackerCatalogContext.Provider value={state}>{children}</TrackerCatalogContext.Provider>;
+}
+
+/** Returns the shared catalog, with an isolated owner for standalone hook tests. */
+export function useTrackerCatalog(): TrackerCatalogState {
+  const shared = useContext(TrackerCatalogContext);
+  const standalone = useTrackerCatalogOwner(shared === null);
+  return shared ?? standalone;
+}
+
+/** Returns the app-owned snapshot without starting a request outside the app provider. */
+export function useTrackerCatalogSnapshot(): TrackerCatalogState | null {
+  return useContext(TrackerCatalogContext);
+}
diff --git a/webui/src/types.ts b/webui/src/types.ts
new file mode 100644
index 00000000..26648001
--- /dev/null
+++ b/webui/src/types.ts
@@ -0,0 +1,1527 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/** Editable identity projection derived from the canonical prepared release. */
+export type ExternalIdentityDraft = {
+  TMDBID: number;
+  IMDBID: number;
+  TVDBID: number;
+  TVmazeID: number;
+  /** Canonical anime identifier used for MAL and MAL/AniList-compatible tracker fields. */
+  MALID: number;
+  Category: string;
+  /** Resolver source labels for each provider ID, such as tracker, mediainfo, tmdb, or scene. */
+  SourceTMDB: string;
+  SourceIMDB: string;
+  SourceTVDB: string;
+  SourceTVmaze: string;
+  /** Resolver source label for MALID. */
+  SourceMAL: string;
+};
+
+export type ExternalIdentity = {
+  SourcePath: string;
+  Generation: number;
+  TMDBID: number;
+  IMDBID: number;
+  TVDBID: number;
+  TVmazeID: number;
+  MALID: number;
+  Category: "unknown" | "movie" | "tv" | string;
+  Provenance: Record<string, string>;
+  Overrides: Record<string, string>;
+  Conflict: "none" | "unverified" | string;
+  Resolution: {
+    SourceFingerprint: string;
+    IntentFingerprint: string;
+    ContractVersion: string;
+  };
+  ResolvedAt: string;
+};
+
+/** Exact identity for one immutable prepared-release generation. */
+export type ReleaseRef = {
+  SourcePath: string;
+  Generation: number;
+};
+
+export type OperationKind =
+  | "unknown"
+  | "preparation"
+  | "duplicate_check"
+  | "dry_run"
+  | "upload_review"
+  | "upload_execute"
+  | "media"
+  | "description"
+  | "image_hosting";
+
+export type OperationFailure = {
+  Code: string;
+  Operation: OperationKind;
+  Message: string;
+  Recovery: string;
+};
+
+export type TrackerEligibilityReason = {
+  Code: string;
+  Message: string;
+};
+
+export type TrackerEligibilityState = {
+  Tracker: string;
+  Eligible: boolean;
+  Reasons: TrackerEligibilityReason[];
+  RuleDecisions: RuleDecision[];
+};
+
+export type TrackerEligibility = {
+  Release: ReleaseRef;
+  Trackers: TrackerEligibilityState[];
+  EligibleTrackers: string[];
+};
+
+export type SourceScopedMetadata = {
+  SourcePath: string;
+  Generation: number;
+  TMDB?: TMDBMetadata | null;
+  IMDB?: IMDBMetadata | null;
+  TVDB?: TVDBMetadata | null;
+  TVmaze?: TVmazeMetadata | null;
+  AniList?: AniListMetadata | null;
+  Bluray?: BlurayMetadata | null;
+  UpdatedAt: string;
+};
+
+export type PreparedRelease = {
+  Generation: number;
+  Compatibility: {
+    SourceFingerprint: string;
+    FactInstructionFingerprint: string;
+    PolicyFingerprint: string;
+    ContractVersion: string;
+  };
+  Source: Record<string, unknown> & { SourcePath?: string };
+  Naming: Record<string, unknown> & { ReleaseName?: string };
+  Episode: Record<string, unknown>;
+  Media: Record<string, unknown>;
+  Disc: Record<string, unknown>;
+  Identity: ExternalIdentity;
+  ProviderMetadata: SourceScopedMetadata;
+  Assessments: {
+    MediaInfoUniqueID: "unknown" | "not_applicable" | "present" | "missing" | string;
+    MediaInfoEncodeSettings: "unknown" | "not_applicable" | "present" | "missing" | string;
+    Naming: {
+      Status: "unknown" | "complete" | "incomplete" | string;
+      Missing: string[];
+    };
+  };
+  PreparedAt: string;
+};
+
+export type PrepareInput = {
+  SourcePath: string;
+  Intent: "preview" | "duplicate_check" | "media" | "description" | "dry_run" | "upload" | string;
+  Instructions: {
+    Identity: ExternalIDOverrides;
+    Category?: string | null;
+    ReleaseName: ReleaseNameOverrides;
+    SourceLookup: string;
+    Playlist: PlaylistInstruction;
+  };
+  Policy: {
+    KeepFolder: boolean;
+    OnlyID: boolean;
+  };
+  Force: boolean;
+};
+
+export type PlaylistInstruction = {
+  Set: boolean;
+  Selected: string[];
+  UseAll: boolean;
+};
+
+export type PrepareResult = {
+  Release: PreparedRelease;
+  Diagnostics: PreparationDiagnostic[];
+};
+
+export type PreparationDiagnostic = {
+  Code: string;
+  Severity: "info" | "warning" | string;
+  Message: string;
+  Candidates: ExternalIdentityCandidate[];
+};
+
+export type UploadReview = {
+  SourcePath: string;
+  Trackers: unknown[];
+  Eligibility: TrackerEligibility;
+};
+
+export type UploadReviewResult = {
+  Review: UploadReview;
+  Token: string;
+};
+
+/** External ID overrides use null/undefined for untouched fields and 0 for an explicit clear. */
+export type ExternalIDOverrides = {
+  TMDBID?: number | null;
+  IMDBID?: number | null;
+  TVDBID?: number | null;
+  TVmazeID?: number | null;
+  /** Canonical MAL/AniList-compatible anime identifier override. */
+  MALID?: number | null;
+};
+
+export type ReleaseNameOverrides = {
+  Category?: string | null;
+  Type?: string | null;
+  Source?: string | null;
+  Resolution?: string | null;
+  Tag?: string | null;
+  Service?: string | null;
+  Edition?: string | null;
+  Season?: string | null;
+  Episode?: string | null;
+  EpisodeTitle?: string | null;
+  ManualYear?: number | null;
+  ManualDate?: string | null;
+  UseSeasonEpisode?: boolean | null;
+  NoSeason?: boolean | null;
+  NoYear?: boolean | null;
+  NoAKA?: boolean | null;
+  NoTag?: boolean | null;
+  NoEdition?: boolean | null;
+  NoDub?: boolean | null;
+  NoDual?: boolean | null;
+  DualAudio?: boolean | null;
+  Region?: string | null;
+};
+
+export type ExternalIDInfo = {
+  Provider: string;
+  ID: number;
+  Source: string;
+};
+
+export type ExternalIdentityCandidate = {
+  Provider: string;
+  ID: number;
+  Title: string;
+  OriginalTitle: string;
+  Year: number;
+  Category: string;
+  MediaType: string;
+  Overview: string;
+  PosterURL: string;
+  Similarity: number;
+};
+
+export type TMDBCompany = {
+  ID: number;
+  Name: string;
+  LogoPath: string;
+  OriginCountry: string;
+};
+
+export type TMDBCountry = {
+  ISO3166: string;
+  Name: string;
+};
+
+export type TMDBNetwork = {
+  ID: number;
+  Name: string;
+  LogoPath: string;
+  OriginCountry: string;
+};
+
+export type TMDBMetadata = {
+  TMDBID: number;
+  IMDBID: number;
+  TVDBID: number;
+  Category: string;
+  Title: string;
+  OriginalTitle: string;
+  Year: number;
+  ReleaseDate: string;
+  FirstAirDate: string;
+  LastAirDate: string;
+  OriginCountry: string[];
+  OriginalLanguage: string;
+  Overview: string;
+  Poster: string;
+  TMDBPosterPath: string;
+  Logo: string;
+  TMDBLogo: string;
+  Backdrop: string;
+  TMDBType: string;
+  Runtime: number;
+  Genres: string;
+  GenreIDs: string;
+  Creators: string[];
+  Directors: string[];
+  Cast: string[];
+  MALID: number;
+  Anime: boolean;
+  Demographic: string;
+  RetrievedAKA: string;
+  Keywords: string;
+  /** Maps TMDB translation language keys, such as "de" or "pt-BR", to localized titles. */
+  LocalizedTitles: Record<string, string>;
+  YouTube: string;
+  Certification: string;
+  ProductionCompanies: TMDBCompany[];
+  ProductionCountries: TMDBCountry[];
+  Networks: TMDBNetwork[];
+  IMDbMismatch: boolean;
+  MismatchedIMDbID: number;
+};
+
+export type IMDBPerson = {
+  ID: string;
+  Name: string;
+};
+
+export type IMDBEditionDetail = {
+  DisplayName: string;
+  Seconds: number;
+  Minutes: number;
+  Attributes: string[];
+};
+
+export type IMDBAKA = {
+  Title: string;
+  Country: string;
+  Language: string;
+  Attributes: string[];
+};
+
+export type IMDBReleaseDate = {
+  Year: number;
+  Month: number;
+  Day: number;
+};
+
+export type IMDBEpisode = {
+  ID: string;
+  Title: string;
+  ReleaseYear: number;
+  ReleaseDate: IMDBReleaseDate;
+  Season: number;
+  EpisodeText: string;
+};
+
+export type IMDBSeasonSummary = {
+  Season: number;
+  Year: number;
+  YearRange: string;
+};
+
+export type IMDBMetadata = {
+  IMDBID: number;
+  IMDbIDText: string;
+  IMDbURL: string;
+  Title: string;
+  Year: number;
+  EndYear: number;
+  AKA: string;
+  Type: string;
+  Plot: string;
+  Rating: number;
+  RatingCount: number;
+  RatingText: string;
+  RuntimeMinutes: number;
+  RuntimeText: string;
+  Genres: string;
+  Country: string;
+  CountryList: string;
+  Cover: string;
+  Directors: IMDBPerson[];
+  Creators: IMDBPerson[];
+  Writers: IMDBPerson[];
+  Stars: IMDBPerson[];
+  Editions: string[];
+  EditionDetails: Record<string, IMDBEditionDetail>;
+  Akas: IMDBAKA[];
+  Episodes: IMDBEpisode[];
+  SeasonsSummary: IMDBSeasonSummary[];
+  SoundMixes: string[];
+  TVYear: number;
+  OriginalLanguage: string;
+};
+
+export type TVDBMetadata = {
+  TVDBID: number;
+  Name: string;
+  NameEnglish: string;
+  Overview: string;
+  OverviewEnglish: string;
+  FirstAired: string;
+  Year: number;
+  /** True when Year is naming-eligible for TV release names. */
+  YearFromAlias: boolean;
+  /** TVDB source used for Year, such as first_aired, translation_name, translation_alias, extended_alias, or slug. */
+  YearSource: string;
+  /** "high" for explicit title or alias years; "low" for guarded slug-derived naming years. */
+  YearConfidence: string;
+  Type: string;
+  Status: string;
+  Network: string;
+  OriginalCountry: string;
+  OriginalLanguage: string;
+  HasEnglish: boolean;
+  Genres: string;
+  Poster: string;
+  Aliases: string[];
+  EpisodeSeason: number;
+  EpisodeNumber: number;
+  EpisodeName: string;
+  EpisodeNameEnglish: string;
+  EpisodeOverview: string;
+  EpisodeOverviewEnglish: string;
+  EpisodeAired: string;
+  /** Selected episode image URL when TVDB returned one. */
+  EpisodeImage: string;
+  /** Fetched TVDB episode entries, usually for the selected season. */
+  Episodes: TVDBEpisodeMetadata[];
+};
+
+/** One TVDB episode entry used by tracker descriptions. */
+export type TVDBEpisodeMetadata = {
+  ID: number;
+  SeasonNumber: number;
+  EpisodeNumber: number;
+  EpisodeName: string;
+  EpisodeNameEnglish: string;
+  EpisodeOverview: string;
+  EpisodeOverviewEnglish: string;
+  /** TVDB air date string used in tracker descriptions. */
+  EpisodeAired: string;
+  /** Episode image URL when TVDB returned one. */
+  EpisodeImage: string;
+};
+
+export type TVmazeMetadata = {
+  TVmazeID: number;
+  Name: string;
+  Premiered: string;
+  Ended: string;
+  Summary: string;
+  Status: string;
+  Type: string;
+  Language: string;
+  Genres: string;
+  Runtime: number;
+  AverageRuntime: number;
+  Rating: number;
+  Weight: number;
+  OfficialSite: string;
+  Country: string;
+  Network: string;
+  NetworkCountry: string;
+  NetworkLogo: string;
+  WebChannel: string;
+  WebCountry: string;
+  WebLogo: string;
+  Poster: string;
+  PosterMedium: string;
+  Backdrop: string;
+  BackdropMedium: string;
+  IMDBID: number;
+  TVDBID: number;
+};
+
+/** AniList media tag shown in the MAL/AniList preview. */
+export type AniListTag = {
+  Name: string;
+  /** AniList tag relevance percentage from 0 to 100. */
+  Rank: number;
+  Category: string;
+  /** Adult/spoiler markers used to hide sensitive tag labels in preview UI. */
+  IsAdult: boolean;
+  IsGeneralSpoiler: boolean;
+  IsMediaSpoiler: boolean;
+};
+
+/** Studio attached to an AniList media entry. */
+export type AniListStudio = {
+  ID: number;
+  Name: string;
+  /** AniList studio page URL. */
+  SiteURL: string;
+};
+
+/** Trailer reference returned by AniList. */
+export type AniListTrailer = {
+  ID: string;
+  Site: string;
+  /** Provider thumbnail URL when AniList supplies one. */
+  Thumbnail: string;
+};
+
+/** Next scheduled episode for an airing AniList media entry. */
+export type AniListAiringEpisode = {
+  /** Unix timestamp in seconds. */
+  AiringAt: number;
+  /** Seconds from AniList's response time until AiringAt. */
+  TimeUntilAiring: number;
+  Episode: number;
+};
+
+/** Public provider or official link attached to AniList media. */
+export type AniListExternalLink = {
+  Site: string;
+  /** Public provider or official URL. */
+  URL: string;
+  Type: string;
+  Language: string;
+};
+
+/**
+ * AniList media snapshot used by the MAL/AniList metadata preview.
+ *
+ * Mirrors the shared Go API contract: date strings preserve AniList
+ * fuzzy-date precision, score fields are 0-100 percentages, and airing
+ * timestamps are Unix seconds.
+ */
+export type AniListMetadata = {
+  /** AniList media ID used in AniList URLs. */
+  AniListID: number;
+  /** MyAnimeList media ID used as upbrr's canonical anime ID. */
+  MALID: number;
+  /** Canonical AniList media page URL. */
+  SiteURL: string;
+  /** Localized AniList title variants. */
+  TitleRomaji: string;
+  TitleEnglish: string;
+  TitleNative: string;
+  TitleUserPreferred: string;
+  /** Plain-text media description from AniList. */
+  Description: string;
+  /** AniList enum value such as TV, MOVIE, or OVA. */
+  Format: string;
+  /** AniList enum value such as FINISHED or RELEASING. */
+  Status: string;
+  /** YYYY, YYYY-MM, or YYYY-MM-DD depending on AniList precision. */
+  StartDate: string;
+  /** YYYY, YYYY-MM, or YYYY-MM-DD depending on AniList precision. */
+  EndDate: string;
+  /** AniList season enum such as WINTER or SPRING. */
+  Season: string;
+  SeasonYear: number;
+  Episodes: number;
+  /** Average episode duration in minutes. */
+  Duration: number;
+  CountryOfOrigin: string;
+  /** AniList source enum such as MANGA, ORIGINAL, or LIGHT_NOVEL. */
+  Source: string;
+  /** AniList image URLs and dominant cover color. */
+  CoverExtraLarge: string;
+  CoverLarge: string;
+  CoverMedium: string;
+  CoverColor: string;
+  BannerImage: string;
+  Genres: string[];
+  Synonyms: string[];
+  /** AniList percentage score from 0 to 100. */
+  AverageScore: number;
+  /** AniList percentage score from 0 to 100. */
+  MeanScore: number;
+  Popularity: number;
+  Favourites: number;
+  IsAdult: boolean;
+  /** Includes adult/spoiler markers so the UI can filter sensitive tags. */
+  Tags: AniListTag[];
+  Studios: AniListStudio[];
+  Trailer: AniListTrailer;
+  NextAiringEpisode: AniListAiringEpisode;
+  ExternalLinks: AniListExternalLink[];
+};
+
+export type WebAuthStatus = {
+  path: string;
+  exists: boolean;
+  usable: boolean;
+  canCreate: boolean;
+  username: string;
+  allowUnencryptedExport: boolean;
+  browseRoot: string;
+  allowUnrestrictedBrowse: boolean;
+  encryptionEnabled: boolean;
+  message: string;
+};
+
+/** Running build metadata plus path-free DVD menu capability diagnostics. */
+export type ApplicationInfo = {
+  version: string;
+  buildIdentifier: string;
+  goVersion: string;
+  goos: string;
+  goarch: string;
+  uptime: string;
+  uptimeSeconds: number;
+  /** Pure-Go engine and FFmpeg dvdvideo probe metadata. */
+  dvdMenuEngine: DVDMenuEngineInfo;
+  /** Stable capability state shown by settings diagnostics. */
+  dvdMenuCapabilityStatus: "available" | "incompatible" | "unavailable";
+  /** User-facing reason for dvdMenuCapabilityStatus. */
+  dvdMenuCapabilityMessage: string;
+};
+
+/** Tracker auth support metadata returned by the WebUI API. */
+export type TrackerAuthCapability = {
+  /** Normalized tracker code used in tracker auth API calls. */
+  trackerID: string;
+  displayName: string;
+  /** Compact capability label such as "cookies", "credential_login", or "api_key_cookies_login". */
+  authKind: string;
+  supportsCookieFile: boolean;
+  supportsLogin: boolean;
+  supportsAutoLogin: boolean;
+  supportsTOTP: boolean;
+  supportsManual2FA: boolean;
+  /** Whether Check Auth can execute a tracker-owned remote resolver. */
+  supportsRemoteValidation: boolean;
+  requiresAPIKey: boolean;
+  requiresPasskey: boolean;
+  /** Optional tracker-specific UI notes; the Go API may serialize a nil slice as null. */
+  notes?: string[] | null;
+};
+
+/**
+ * Current tracker auth state returned after status, import, login, validation,
+ * 2FA, or delete actions.
+ *
+ * Mirrors the shared Go API contract; browser routes should
+ * preserve every field so WebUI surfaces show the same status and remediation.
+ */
+export type TrackerAuthStatus = {
+  trackerID: string;
+  displayName: string;
+  /** Backend state string such as "configured", "has_cookies", or "login_required". */
+  state: string;
+  cookieCount: number;
+  /** RFC3339 UTC timestamp generated when the backend evaluated the status. */
+  lastCheckedAt: string;
+  /** Redacted failure detail from the most recent local or remote auth check. */
+  lastError: string;
+  encryptedStorage: boolean;
+  needs2FA: boolean;
+  /** Opaque manual-2FA continuation token; empty unless needs2FA is true. */
+  challengeID: string;
+  /** Stable user-facing status summary or next step. */
+  message: string;
+};
+
+/** Optional login data for tracker auth flows. */
+export type TrackerAuthLoginRequest = {
+  /** One-time 2FA code for adapters that accept it during login. */
+  code?: string;
+};
+
+export type IdentityProvider = "tmdb" | "imdb" | "tvdb" | "tvmaze" | "mal";
+
+export type ProviderDisplaySummary = {
+  Title: string;
+  OriginalTitle: string;
+  Year: number;
+  Overview: string;
+  PosterURL: string;
+  BackdropURL: string;
+  Category: string;
+  Date: string;
+  EndDate: string;
+  OriginalLanguage: string;
+  MediaType: string;
+  RuntimeMinutes: number;
+  Genres: string;
+  Keywords: string;
+  TrailerURL: string;
+  Rating: number;
+  RatingCount: number;
+  Country: string;
+};
+
+type ProviderDisplayBase = {
+  ID: number;
+  DisplayID: string;
+  URL: string;
+  Provenance: string;
+  SummaryAvailable: boolean;
+  Summary: ProviderDisplaySummary;
+};
+
+/** Canonical prepared-release display entry with one provider-matched detail payload. */
+export type ProviderDisplay =
+  | (ProviderDisplayBase & { Provider: "tmdb"; Details: { TMDB: TMDBMetadata } })
+  | (ProviderDisplayBase & { Provider: "imdb"; Details: { IMDB: IMDBMetadata } })
+  | (ProviderDisplayBase & { Provider: "tvdb"; Details: { TVDB: TVDBMetadata } })
+  | (ProviderDisplayBase & { Provider: "tvmaze"; Details: { TVmaze: TVmazeMetadata } })
+  | (ProviderDisplayBase & { Provider: "mal"; Details: { AniList: AniListMetadata } });
+
+export type PreparedReleaseDisplay = {
+  ReleaseName: string;
+  Providers: ProviderDisplay[];
+};
+
+export type BlurayImage = {
+  Kind: string;
+  URL: string;
+};
+
+export type BluraySpecs = {
+  Video: {
+    Codec: string;
+    Resolution: string;
+  };
+  Audio: string[];
+  Subtitles: string[];
+  Discs: {
+    Type: string;
+    Count: number;
+    Format: string;
+  };
+  Playback: {
+    Region: string;
+    RegionNotes: string;
+  };
+};
+
+export type BlurayReleaseCandidate = {
+  ReleaseID: string;
+  ProductID: string;
+  MovieTitle: string;
+  MovieYear: string;
+  Title: string;
+  URL: string;
+  Price: string;
+  Publisher: string;
+  Country: string;
+  Region: string;
+  Score: number;
+  Accepted: boolean;
+  Warnings: string[];
+  MatchNotes: string[];
+  Specs: BluraySpecs;
+  CoverImages: BlurayImage[];
+  GenericDisc: boolean;
+  SpecsMissing: boolean;
+};
+
+export type BlurayMetadata = {
+  SourcePath: string;
+  IMDBID: number;
+  SearchURL: string;
+  SelectedReleaseID: string;
+  SelectedURL: string;
+  AutoSelected: boolean;
+  SelectionReason: string;
+  BestScore: number;
+  Threshold: number;
+  Candidates: BlurayReleaseCandidate[];
+  UpdatedAt: string;
+};
+
+export type TrackerPreview = {
+  Tracker: string;
+  TrackerID: string;
+  TorrentURL: string;
+  InfoHash: string;
+  TMDBID: number;
+  IMDBID: number;
+  TVDBID: number;
+  MALID: number;
+  Category: string;
+  Description: string;
+  DescriptionHTML: string;
+  ImageURLs: string[];
+  Filename: string;
+  Matched: boolean;
+  UpdatedAt: string;
+};
+
+/** Upload rule failure attached to a tracker before dupe checking or upload. */
+export type RuleFailure = {
+  Rule: string;
+  Reason: string;
+  /** Empty legacy values are waivable; unknown non-empty values fail closed. */
+  Disposition?: "advisory" | "waivable" | "strict" | string;
+};
+
+export type RuleDecision = RuleFailure & {
+  Authorized: boolean;
+};
+
+export type RuleAuthorization = {
+  Tracker: string;
+  Rules: string[];
+};
+
+export type DupeEntry = {
+  Name: string;
+  SizeBytes: number;
+  SizeKnown: boolean;
+  SizeText: string;
+  Files: string[];
+  FileCount: number;
+  Trumpable: boolean;
+  Link: string;
+  Download: string;
+  Flags: string[];
+  ID: string;
+  Type: string;
+  Res: string;
+  Internal: boolean;
+  BDInfo: string;
+  Description: string;
+};
+
+export type DupeEpisodeMatch = {
+  ID: string;
+  Name: string;
+  Link: string;
+  Tracker: string;
+  Internal: boolean;
+};
+
+export type DupeMatch = {
+  FilenameMatch: string;
+  FileCountMatch: number;
+  SizeMatch: string;
+  TrumpableID: string;
+  MatchedID: string;
+  MatchedName: string;
+  MatchedLink: string;
+  MatchedDownload: string;
+  MatchedReason: string;
+  SeasonPackExists: boolean;
+  SeasonPackName: string;
+  SeasonPackLink: string;
+  SeasonPackID: string;
+  SeasonPackContainsEpisode: boolean;
+  MatchedEpisodeIDs: DupeEpisodeMatch[];
+};
+
+/**
+ * Duplicate-search outcome for one tracker. Raw contains tracker results before
+ * filtering, Filtered contains blocking matches, and skipped or failed checks
+ * carry Status plus SkipReason or Error. SkipCode exposes a stable
+ * backend skip metadata for typed UI callers.
+ */
+export type DupeCheckResult = {
+  Tracker: string;
+  Raw: DupeEntry[];
+  Filtered: DupeEntry[];
+  HasDupes: boolean;
+  ContentFail: boolean;
+  Match: DupeMatch;
+  Notes: string[];
+  Skipped: boolean;
+  SkipReason: string;
+  /** Stable machine-readable skip reason emitted by the backend. */
+  SkipCode: string;
+  /** Upload rule keys that produced a rule-failure skip. */
+  Status: string;
+  Error: string;
+  CheckedAt: string;
+};
+
+export type DupeCheckSummary = {
+  SourcePath: string;
+  Results: DupeCheckResult[];
+  Notes: string[];
+  Eligibility: TrackerEligibility;
+};
+
+export type DupeCheckTrackerState = {
+  tracker: string;
+  status: string;
+  message: string;
+  result: DupeCheckResult;
+  startedAt: string;
+  finishedAt: string;
+};
+
+export type DupeCheckSnapshot = {
+  jobID: string;
+  correlationID: string;
+  release: ReleaseRef;
+  runtimeGeneration: number;
+  status: string;
+  trackers: DupeCheckTrackerState[];
+  completedCount: number;
+  totalCount: number;
+  summary: DupeCheckSummary;
+  failure?: OperationFailure;
+  startedAt: string;
+  finishedAt: string;
+};
+
+export type MetadataPreview = {
+  SourcePath: string;
+  TrackerName: string;
+  ReleaseName: string;
+  ReleaseNameOverrides: ReleaseNameOverrides;
+  Release: ReleaseRef;
+  Identity: ExternalIdentity;
+  Display: PreparedReleaseDisplay;
+  Bluray?: BlurayMetadata | null;
+  Diagnostics: PreparationDiagnostic[];
+  TrackerData: TrackerPreview[];
+  /** Preview-time upload rule failures keyed by normalized tracker code. */
+  TrackerRuleFailures?: Record<string, RuleFailure[]>;
+};
+
+/** Advisory terminal and non-terminal states emitted by canonical preparation stages. */
+export type PreparationProgressStatus = "running" | "completed" | "skipped" | "failed";
+
+/** Frontend-safe preparation progress event correlated to one active command. */
+export type PreparationProgressUpdate = {
+  /** Binds the update to the initiating release-session command. */
+  correlationID: string;
+  /** Stable machine-readable preparation phase. */
+  phase: string;
+  /** Stable presentation order, not a completion percentage. */
+  order: number;
+  /** User-facing canonical stage name. */
+  label: string;
+  /** User-facing detail for the latest phase transition. */
+  message: string;
+  /** Latest advisory state of the phase. */
+  status: PreparationProgressStatus;
+  /** UTC RFC3339 timestamp assigned by the WebUI transport boundary. */
+  timestamp: string;
+};
+
+export type PreparationDescription = {
+  GroupKey: string;
+  Trackers: string[];
+  RawDescription: string;
+  RawDescriptionHTML: string;
+  Description: string;
+  DescriptionHTML: string;
+  HasOverride: boolean;
+  ImageHost: ImageHostFeedback;
+};
+
+export type PreparationPreview = {
+  SourcePath: string;
+  Descriptions: PreparationDescription[];
+  ContentFailures: TrackerContentFailure[];
+};
+
+export type ImageHostFeedback = {
+  Status: string;
+  SelectedHost: string;
+  AllowedHosts: string[];
+  Warnings?: ImageHostWarning[];
+  Reuploaded: boolean;
+  Message: string;
+};
+
+export type ImageHostWarning = {
+  Host: string;
+  Message: string;
+};
+
+export type DescriptionBuilderGroup = {
+  GroupKey: string;
+  Trackers: string[];
+  Description: string;
+  DescriptionHTML: string;
+  RawDescription: string;
+  RawDescriptionHTML: string;
+  HasOverride: boolean;
+  ImageHost: ImageHostFeedback;
+};
+
+export type DescriptionBuilderPreview = {
+  SourcePath: string;
+  Groups: DescriptionBuilderGroup[];
+  ContentFailures: TrackerContentFailure[];
+};
+
+/** Image category shared by capture, selection, upload, and menu workflows. */
+export type ScreenshotPurpose = "preview" | "final" | "menu";
+
+export type ScreenshotSelection = {
+  Index: number;
+  TimestampSeconds: number;
+  Frame: number;
+  Source: string;
+};
+
+export type ScreenshotImage = {
+  Index: number;
+  TimestampSeconds: number;
+  Path: string;
+  /** Distinguishes preview, normal final, and disc-menu images. */
+  Purpose: ScreenshotPurpose;
+  Width: number;
+  Height: number;
+  SizeBytes: number;
+  Host?: string;
+  ImgURL?: string;
+  RawURL?: string;
+  WebURL?: string;
+  UploadedAt?: string;
+};
+
+/** How the DVD navigation engine found a selected menu screen. */
+export type DVDMenuDiscovery = "reachable" | "structural";
+
+/** Stable, redacted diagnostic for incomplete DVD menu coverage. */
+export type DVDMenuCaptureWarning = {
+  /** Machine-readable warning identifier. */
+  Code: string;
+  /** User-facing path-free warning text. */
+  Message: string;
+};
+
+/** Path-free pure-Go engine and FFmpeg dvdvideo capability metadata. */
+export type DVDMenuEngineInfo = {
+  /** Bundled pure-Go engine implementation version. */
+  EngineVersion: string;
+  /** Capture metadata contract version. */
+  SchemaVersion: number;
+  /** Engine stages available in this build. */
+  SupportedFeatures: string[];
+  /** Bounded first line of FFmpeg version output. */
+  FFmpegVersion: string;
+  /** Whether FFmpeg exposes the required dvdvideo menu options. */
+  FFmpegDVDVideo: boolean;
+  /** Required dvdvideo options absent from the capability probe. */
+  MissingFFmpegOptions: string[];
+};
+
+/** Persisted menu image plus its navigation discovery source. */
+export type DVDMenuCaptureImage = ScreenshotImage & {
+  /** Whether navigation or structural inventory found the screen. */
+  Discovery: DVDMenuDiscovery;
+};
+
+/** Final or partial result of one bounded automatic DVD menu capture. */
+export type DVDMenuCaptureResult = {
+  /** Host filesystem path of the prepared DVD source. */
+  SourcePath: string;
+  /** Persisted automatic captures in display order. */
+  Images: DVDMenuCaptureImage[];
+  /** Menu language requested from the engine. */
+  SelectedLanguage: string;
+  /** DVD region override; zero means none. */
+  Region: number;
+  /** Number of structurally inventoried menu programs. */
+  DiscoveredMenus: number;
+  /** Number of distinct VM states evaluated. */
+  VisitedStates: number;
+  /** Number of authored button commands evaluated. */
+  VisitedButtons: number;
+  /** Configured upper bound on automatic captures. */
+  MaxItems: number;
+  /** True when every selected screen was captured without coverage warnings. */
+  Complete: boolean;
+  /** True when warnings prevented complete navigation or rendering coverage. */
+  Partial: boolean;
+  /** True when MaxItems excluded eligible screens. */
+  Truncated: boolean;
+  /** Deduplicated coverage diagnostics. */
+  Warnings: DVDMenuCaptureWarning[];
+  /** Engine and FFmpeg capability used for capture. */
+  Engine: DVDMenuEngineInfo;
+};
+
+export type ScreenshotError = {
+  Index: number;
+  Message: string;
+};
+
+export type ScreenshotResult = {
+  SourcePath: string;
+  Purpose: ScreenshotPurpose;
+  Images: ScreenshotImage[];
+  Tonemapped: boolean;
+  UsedLibplacebo: boolean;
+  Errors: ScreenshotError[];
+};
+
+export type ScreenshotPlan = {
+  SourcePath: string;
+  DiscType: string;
+  DurationSeconds: number;
+  FrameRate: number;
+  SuggestedSelections: ScreenshotSelection[];
+  ExistingScreenshots: ScreenshotImage[];
+  ExistingTrackerScreenshots: ScreenshotImage[];
+  FinalSelections: ScreenshotImage[];
+  TrackerImageLinks: ScreenshotLinkedImage[];
+  PreviewImages: ScreenshotImage[];
+  MetadataTimestamp: string;
+  RequiresManualFrames: boolean;
+};
+
+export type ScreenshotLinkedImage = {
+  Tracker: string;
+  URL: string;
+  Path: string;
+  Host?: string;
+};
+
+export type UploadedImageLink = {
+  SourcePath: string;
+  ImagePath: string;
+  Host: string;
+  UsageScope: string;
+  ImgURL: string;
+  RawURL: string;
+  WebURL: string;
+  SizeBytes: number;
+  UploadedAt: string;
+};
+
+export type UploadImageHostFailure = {
+  Host: string;
+  UsageScope: string;
+  Trackers: string[];
+  Message: string;
+};
+
+/** Advisory terminal and non-terminal states for one image-host attempt. */
+export type ImageUploadProgressStatus = "running" | "completed" | "failed";
+
+/** Absolute image-host progress snapshot correlated to one upload command. */
+export type ImageUploadProgressUpdate = {
+  /** Binds the update to one image-upload command. */
+  correlationID: string;
+  /** Stable host/scope row identifier within the command. */
+  attemptID: string;
+  /** Normalized configured image-host name. */
+  host: string;
+  /** Global or tracker-owned persistence scope. */
+  usageScope: string;
+  /** Trackers served by this host attempt. */
+  trackers: string[];
+  /** Whether this attempt follows an earlier host failure. */
+  fallback: boolean;
+  /** Succeeded, failed, and reused images in terminal states. */
+  completed: number;
+  /** Selected images required on this host. */
+  total: number;
+  /** Successful network uploads in this attempt. */
+  succeeded: number;
+  /** Network uploads that did not produce a usable link. */
+  failed: number;
+  /** Images satisfied by existing persisted host records. */
+  reused: number;
+  /** Latest advisory state for this host attempt. */
+  status: ImageUploadProgressStatus;
+  /** Frontend-safe detail for the latest transition. */
+  message: string;
+  /** UTC RFC3339 timestamp assigned by the WebUI boundary. */
+  timestamp: string;
+};
+
+export type UploadImagesResult = {
+  Links: UploadedImageLink[];
+  Failures: UploadImageHostFailure[];
+};
+
+export type HistoryEntry = {
+  SourcePath: string;
+  ReleaseTitle: string;
+  ReleaseSource: string;
+  ReleaseResolution: string;
+  MetadataUpdatedAt: string;
+  LatestUploadStatus: string;
+  LatestUploadAt: string;
+  RuleFailureCount: number;
+  /** Number of explicitly advisory rule results; absent on older API responses. */
+  RuleAdvisoryCount?: number;
+};
+
+export type HistoryUploadRecord = {
+  Tracker: string;
+  Status: string;
+  CreatedAt: string;
+  SourcePath: string;
+};
+
+export type HistoryTrackerMetadata = {
+  SourcePath: string;
+  Tracker: string;
+  TrackerID: string;
+  InfoHash: string;
+  TMDBID: number;
+  IMDBID: number;
+  TVDBID: number;
+  MALID: number;
+  Category: string;
+  Description: string;
+  ImageURLs: string[];
+  Filename: string;
+  Matched: boolean;
+  UpdatedAt: string;
+};
+
+export type HistoryRuleFailure = {
+  SourcePath: string;
+  Tracker: string;
+  Rule: string;
+  Reason: string;
+  Disposition?: "advisory" | "waivable" | "strict" | string;
+  Authorized: boolean;
+  CreatedAt: string;
+};
+
+export type HistoryOverview = {
+  SourcePath: string;
+  ReleaseTitle: string;
+  ReleaseSource: string;
+  ReleaseResolution: string;
+  MetadataUpdatedAt: string;
+  LatestUploadStatus: string;
+  LatestUploadAt: string;
+  StatusLabel: string;
+  Metadata: Record<string, unknown>;
+  Release: ReleaseRef;
+  Identity: ExternalIdentity;
+  Display: PreparedReleaseDisplay;
+  ReleaseNameOverrides: ReleaseNameOverrides;
+  DescriptionOverride: {
+    SourcePath: string;
+    GroupKey: string;
+    Description: string;
+    UpdatedAt: string;
+  };
+  DescriptionOverrides: Array<{
+    SourcePath: string;
+    GroupKey: string;
+    Description: string;
+    UpdatedAt: string;
+  }>;
+  PlaylistSelection: {
+    SourcePath: string;
+    SelectedPlaylists: string[];
+    UseAll: boolean;
+    UpdatedAt: string;
+  };
+  TrackerMetadata: HistoryTrackerMetadata[];
+  TrackerRuleFailures: HistoryRuleFailure[];
+  Screenshots: Array<{
+    SourcePath: string;
+    ImagePath: string;
+    Purpose: string;
+    CapturedAt: string;
+  }>;
+  FinalSelections: Array<{
+    SourcePath: string;
+    ImagePath: string;
+    Order: number;
+    Source: string;
+    SelectedAt: string;
+  }>;
+  UploadedImages: UploadedImageLink[];
+  UploadHistory: HistoryUploadRecord[];
+};
+
+export type ScreenshotPreviewImage = {
+  image: ScreenshotImage;
+  dataUri: string;
+};
+
+export type TrackerUploadItem = {
+  name: string;
+  config: ConfigMap;
+};
+
+export type TrackerUploadTrackerState = {
+  tracker: string;
+  status: string;
+  task: string;
+  taskStatus: string;
+  message: string;
+  completedPieces: number;
+  totalPieces: number;
+  percent: number;
+  hashRateMiB: number;
+  uploadedCount: number;
+  startedAt: string;
+  finishedAt: string;
+};
+
+export type UploadProgressUpdate = {
+  sourcePath: string;
+  tracker: string;
+  task: string;
+  status: string;
+  message: string;
+  completedPieces: number;
+  totalPieces: number;
+  percent: number;
+  hashRateMiB: number;
+  timestamp: string;
+};
+
+export type TrackerUploadSnapshot = {
+  jobID: string;
+  correlationID: string;
+  retryOf?: string;
+  release: ReleaseRef;
+  runtimeGeneration: number;
+  status: string;
+  currentTask: string;
+  currentTaskStatus: string;
+  currentMessage: string;
+  currentCompletedPieces: number;
+  currentTotalPieces: number;
+  currentPercent: number;
+  currentHashRateMiB: number;
+  trackers: TrackerUploadTrackerState[];
+  failedTrackers: string[];
+  uploadedCount: number;
+  failure?: OperationFailure;
+  startedAt: string;
+  finishedAt: string;
+};
+
+export type OwnerJobSnapshot =
+  | {
+      kind: "duplicate_check";
+      jobID: string;
+      correlationID: string;
+      release: ReleaseRef;
+      status: string;
+      startedAt: string;
+      finishedAt: string;
+      dupe: DupeCheckSnapshot;
+    }
+  | {
+      kind: "tracker_upload";
+      jobID: string;
+      correlationID: string;
+      retryOf?: string;
+      release: ReleaseRef;
+      status: string;
+      startedAt: string;
+      finishedAt: string;
+      upload: TrackerUploadSnapshot;
+    };
+
+export type TrackerDryRunFile = {
+  Field: string;
+  Path: string;
+  Present: boolean;
+};
+
+export type TrackerQuestionnaireField = {
+  Key: string;
+  Label: string;
+  Kind: string;
+  Options?: string[];
+  Value: string;
+  Placeholder: string;
+  Help: string;
+  Required: boolean;
+};
+
+export type TrackerQuestionnaire = {
+  Tracker: string;
+  Fields: TrackerQuestionnaireField[];
+};
+
+export type TrackerDryRunEntry = {
+  Tracker: string;
+  Status: string;
+  Message: string;
+  Banned: boolean;
+  BannedReason: string;
+  BannedCheckError: string;
+  ReleaseName: string;
+  OriginalReleaseName: string;
+  UploadReleaseName: string;
+  ReleaseNameChanged: boolean;
+  ReleaseNameChangeReason: string;
+  DescriptionGroup: string;
+  Description: string;
+  Endpoint: string;
+  Payload: Record<string, string>;
+  Files: TrackerDryRunFile[];
+  /** Optional staged diagnostics for trackers that expose intermediate dry-run payloads. */
+  DebugSections?: TrackerDryRunDebugSection[] | null;
+  Questionnaire?: TrackerQuestionnaire | null;
+  ImageHost: ImageHostFeedback;
+  ContentFailure?: TrackerContentFailure | null;
+  Diagnostics: TrackerDryRunDiagnostics;
+};
+
+export type TrackerDryRunDiagnostics = {
+  RuleDecisions: RuleDecision[];
+  Duplicate: DupeCheckResult;
+  LiveEligibilityReasons: TrackerEligibilityReason[];
+};
+
+export type TrackerContentFailure = {
+  tracker: string;
+  code: "screenshot_preparation_failed" | "description_preparation_failed";
+  message: string;
+};
+
+/** One named diagnostic payload rendered inside a tracker dry-run preview. */
+export type TrackerDryRunDebugSection = {
+  Title: string;
+  Endpoint: string;
+  Payload: Record<string, string>;
+  Files: TrackerDryRunFile[];
+};
+
+export type TrackerDryRunPreview = {
+  SourcePath: string;
+  Trackers: TrackerDryRunEntry[];
+};
+
+export type ConfigValue = string | number | boolean | null | ConfigMap | ConfigValue[];
+export type ConfigMap = { [key: string]: ConfigValue };
+export type TrackerCatalogField = {
+  key: string;
+  yamlKey: string;
+  default: ConfigValue;
+  activation: boolean;
+};
+export type TrackerCatalogEntry = {
+  name: string;
+  family: "unit3d" | "azfamily" | "standalone" | string;
+  baseURL: string;
+  uploadContentMode: "none" | "screenshots" | "description";
+  fields: TrackerCatalogField[];
+  configured: boolean;
+};
+export type TrackerCatalog = {
+  entries: TrackerCatalogEntry[];
+  unsupported: string[];
+};
+export type ImageHostPolicyMetadata = {
+  UploadHosts?: string[];
+  TrackerUploadHosts?: Record<string, string[]>;
+  OwnedHosts?: Record<string, string>;
+};
+export type FieldType = "string" | "number" | "boolean";
+export type FieldMeta = {
+  key: string;
+  label?: string;
+  type?: FieldType;
+  advanced?: boolean;
+  sensitive?: boolean;
+  options?: Array<{ value: string; label: string }>;
+};
+
+export type ReleaseNameEditState = {
+  category: string;
+  type: string;
+  source: string;
+  resolution: string;
+  tag: string;
+  service: string;
+  edition: string;
+  season: string;
+  episode: string;
+  episodeTitle: string;
+  manualYear: string;
+  manualDate: string;
+  useSeasonEpisode: boolean;
+  noSeason: boolean;
+  noYear: boolean;
+  noAKA: boolean;
+  noTag: boolean;
+  noEdition: boolean;
+  noDub: boolean;
+  noDual: boolean;
+  dualAudio: boolean;
+  region: string;
+};
+
+export type ReleaseNameTouchedState = {
+  category: boolean;
+  type: boolean;
+  source: boolean;
+  resolution: boolean;
+  tag: boolean;
+  service: boolean;
+  edition: boolean;
+  season: boolean;
+  episode: boolean;
+  episodeTitle: boolean;
+  manualYear: boolean;
+  manualDate: boolean;
+  useSeasonEpisode: boolean;
+  noSeason: boolean;
+  noYear: boolean;
+  noAKA: boolean;
+  noTag: boolean;
+  noEdition: boolean;
+  noDub: boolean;
+  noDual: boolean;
+  dualAudio: boolean;
+  region: boolean;
+};
+
+export type ReleaseNameIDEditState = {
+  tmdb: string;
+  imdb: string;
+  tvdb: string;
+  tvmaze: string;
+};
+
+export type DetailItem = {
+  label: string;
+  value: string;
+  mono?: boolean;
+  blocks?: DetailBlock[];
+};
+
+export type DetailBlock = {
+  text?: string;
+  imageUrl?: string;
+  imageAlt?: string;
+};
+
+export type PlaylistItem = {
+  file: string;
+  size: number;
+};
+
+export type PlaylistInfo = {
+  file: string;
+  duration: number;
+  items: PlaylistItem[];
+  score: number;
+  edition: string;
+};
+
+export type PlaylistSelection = {
+  SourcePath: string;
+  SelectedPlaylists: string[];
+  UseAll: boolean;
+  UpdatedAt: string;
+};
+
+export type BrowseDirectoryEntry = {
+  name: string;
+  path: string;
+  isDir: boolean;
+  size: number;
+  modifiedAt: string;
+};
+
+export type BrowseDirectoryResponse = {
+  currentPath: string;
+  parentPath: string;
+  mode: "file" | "folder";
+  entries: BrowseDirectoryEntry[];
+};
+
+export type BrowseDirectoryRequest = {
+  path: string;
+  mode: "file" | "folder";
+};
diff --git a/webui/src/utils/canonicalIdentity.ts b/webui/src/utils/canonicalIdentity.ts
new file mode 100644
index 00000000..636450b7
--- /dev/null
+++ b/webui/src/utils/canonicalIdentity.ts
@@ -0,0 +1,68 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type {
+  ExternalIdentity,
+  ExternalIdentityCandidate,
+  ExternalIDInfo,
+  ExternalIdentityDraft,
+  PreparationDiagnostic,
+} from "../types";
+
+export const emptyExternalIdentity = (sourcePath = ""): ExternalIdentity => ({
+  SourcePath: sourcePath,
+  Generation: 0,
+  TMDBID: 0,
+  IMDBID: 0,
+  TVDBID: 0,
+  TVmazeID: 0,
+  MALID: 0,
+  Category: "unknown",
+  Provenance: {},
+  Overrides: {},
+  Conflict: "none",
+  Resolution: {
+    SourceFingerprint: "",
+    IntentFingerprint: "",
+    ContractVersion: "",
+  },
+  ResolvedAt: "",
+});
+
+const provenance = (identity: ExternalIdentity, key: string) =>
+  String(identity.Provenance?.[key] || "");
+
+export const externalIdentityDraftFromIdentity = (
+  identity: ExternalIdentity,
+): ExternalIdentityDraft => ({
+  TMDBID: Number(identity.TMDBID || 0),
+  IMDBID: Number(identity.IMDBID || 0),
+  TVDBID: Number(identity.TVDBID || 0),
+  TVmazeID: Number(identity.TVmazeID || 0),
+  MALID: Number(identity.MALID || 0),
+  Category: String(identity.Category || "unknown"),
+  SourceTMDB: provenance(identity, "TMDB"),
+  SourceIMDB: provenance(identity, "IMDB"),
+  SourceTVDB: provenance(identity, "TVDB"),
+  SourceTVmaze: provenance(identity, "TVmaze"),
+  SourceMAL: provenance(identity, "MAL"),
+});
+
+export const externalIDInfoFromIdentity = (identity: ExternalIdentity): ExternalIDInfo[] => {
+  const ids = externalIdentityDraftFromIdentity(identity);
+  return [
+    { Provider: "tmdb", ID: ids.TMDBID, Source: ids.SourceTMDB },
+    { Provider: "imdb", ID: ids.IMDBID, Source: ids.SourceIMDB },
+    { Provider: "tvdb", ID: ids.TVDBID, Source: ids.SourceTVDB },
+    { Provider: "tvmaze", ID: ids.TVmazeID, Source: ids.SourceTVmaze },
+    { Provider: "mal", ID: ids.MALID, Source: ids.SourceMAL },
+  ].filter((item) => item.ID > 0);
+};
+
+export const candidatesFromDiagnostics = (
+  diagnostics: PreparationDiagnostic[],
+  provider: "tmdb" | "imdb",
+): ExternalIdentityCandidate[] =>
+  (diagnostics || [])
+    .flatMap((diagnostic) => diagnostic.Candidates || [])
+    .filter((candidate) => String(candidate.Provider).toLowerCase() === provider);
diff --git a/gui/frontend/src/utils/cn.ts b/webui/src/utils/cn.ts
similarity index 100%
rename from gui/frontend/src/utils/cn.ts
rename to webui/src/utils/cn.ts
diff --git a/webui/src/utils/dupeCheck.ts b/webui/src/utils/dupeCheck.ts
new file mode 100644
index 00000000..70dd2496
--- /dev/null
+++ b/webui/src/utils/dupeCheck.ts
@@ -0,0 +1,10 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { DupeCheckResult } from "../types";
+
+type DupeSkipReasonSource = Pick<Partial<DupeCheckResult>, "SkipReason">;
+
+/** Returns the displayable skip reason carried by a duplicate-check result. */
+export const dupeSkipReason = (result: DupeSkipReasonSource) =>
+  String(result.SkipReason || "").trim();
diff --git a/webui/src/utils/externalLinks.ts b/webui/src/utils/externalLinks.ts
new file mode 100644
index 00000000..f1d69a3f
--- /dev/null
+++ b/webui/src/utils/externalLinks.ts
@@ -0,0 +1,52 @@
+// Copyright (c) 2025-2026, Audionut and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import type { MouseEvent } from "react";
+
+const normalizeExternalHTTPURL = (value: string): string | null => {
+  const href = value.trim();
+  if (!href) return null;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(href);
+  } catch {
+    return null;
+  }
+
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return null;
+  }
+
+  return parsed.toString();
+};
+
+const openExternalURL = async (url: string) => {
+  window.open(url, "_blank", "noopener,noreferrer");
+};
+
+export const handleExternalLinkClick = (event: MouseEvent<HTMLElement>) => {
+  const target = event.target;
+  if (!(target instanceof Element)) {
+    return;
+  }
+
+  const anchor = target.closest("a[href]");
+  if (!(anchor instanceof HTMLAnchorElement)) {
+    return;
+  }
+
+  const href = anchor.getAttribute("href");
+  if (!href) {
+    return;
+  }
+
+  const normalized = normalizeExternalHTTPURL(href);
+  if (!normalized) {
+    return;
+  }
+
+  event.preventDefault();
+  event.stopPropagation();
+  void openExternalURL(normalized);
+};
diff --git a/gui/frontend/src/utils/favicon.ts b/webui/src/utils/favicon.ts
similarity index 100%
rename from gui/frontend/src/utils/favicon.ts
rename to webui/src/utils/favicon.ts
diff --git a/gui/frontend/src/utils/helpers.test.ts b/webui/src/utils/helpers.test.ts
similarity index 100%
rename from gui/frontend/src/utils/helpers.test.ts
rename to webui/src/utils/helpers.test.ts
diff --git a/gui/frontend/src/utils/helpers.ts b/webui/src/utils/helpers.ts
similarity index 100%
rename from gui/frontend/src/utils/helpers.ts
rename to webui/src/utils/helpers.ts
diff --git a/gui/frontend/src/utils/inputHistory.test.ts b/webui/src/utils/inputHistory.test.ts
similarity index 100%
rename from gui/frontend/src/utils/inputHistory.test.ts
rename to webui/src/utils/inputHistory.test.ts
diff --git a/gui/frontend/src/utils/inputHistory.ts b/webui/src/utils/inputHistory.ts
similarity index 100%
rename from gui/frontend/src/utils/inputHistory.ts
rename to webui/src/utils/inputHistory.ts
diff --git a/gui/frontend/src/utils/jobStatus.test.ts b/webui/src/utils/jobStatus.test.ts
similarity index 100%
rename from gui/frontend/src/utils/jobStatus.test.ts
rename to webui/src/utils/jobStatus.test.ts
diff --git a/gui/frontend/src/utils/jobStatus.ts b/webui/src/utils/jobStatus.ts
similarity index 100%
rename from gui/frontend/src/utils/jobStatus.ts
rename to webui/src/utils/jobStatus.ts
diff --git a/gui/frontend/src/utils/settings.test.ts b/webui/src/utils/settings.test.ts
similarity index 100%
rename from gui/frontend/src/utils/settings.test.ts
rename to webui/src/utils/settings.test.ts
diff --git a/gui/frontend/src/utils/settings.ts b/webui/src/utils/settings.ts
similarity index 100%
rename from gui/frontend/src/utils/settings.ts
rename to webui/src/utils/settings.ts
diff --git a/gui/frontend/src/vite-env.d.ts b/webui/src/vite-env.d.ts
similarity index 100%
rename from gui/frontend/src/vite-env.d.ts
rename to webui/src/vite-env.d.ts
diff --git a/gui/frontend/src/webRoot.tsx b/webui/src/webRoot.tsx
similarity index 82%
rename from gui/frontend/src/webRoot.tsx
rename to webui/src/webRoot.tsx
index d2934563..f1274bcc 100644
--- a/gui/frontend/src/webRoot.tsx
+++ b/webui/src/webRoot.tsx
@@ -5,19 +5,13 @@ import type { FormEvent } from "react";
 import { useEffect, useState } from "react";
 import App from "./app";
 import { Checkbox } from "./components/ui/checkbox";
-import {
-  browserAuth,
-  initializeBrowserBridge,
-  isBrowserMode,
-  updateBrowserCSRFToken,
-} from "./utils/runtime";
+import { authClient, initializeWebClient, updateWebCSRFToken } from "./api/client";
 
 type AuthStatus = {
   authenticated: boolean;
   needsSetup: boolean;
   username: string;
   csrfToken: string;
-  nativeBrowseEnabled: boolean;
   caseInsensitivePaths: boolean;
   browseRoot: string;
   allowUnrestrictedBrowse: boolean;
@@ -29,7 +23,6 @@ const initialStatus: AuthStatus = {
   needsSetup: false,
   username: "",
   csrfToken: "",
-  nativeBrowseEnabled: false,
   caseInsensitivePaths: false,
   browseRoot: "",
   allowUnrestrictedBrowse: false,
@@ -37,7 +30,6 @@ const initialStatus: AuthStatus = {
 };
 
 export default function WebRoot() {
-  const browserMode = isBrowserMode();
   const [status, setStatus] = useState<AuthStatus | null>(null);
   const [username, setUsername] = useState("");
   const [password, setPassword] = useState("");
@@ -48,29 +40,21 @@ export default function WebRoot() {
   const [submitting, setSubmitting] = useState(false);
 
   useEffect(() => {
-    if (!browserMode) {
-      setStatus({ ...initialStatus, authenticated: true });
-      return;
-    }
-    browserAuth
+    authClient
       .status()
       .then((payload) => {
         const next = { ...initialStatus, ...payload };
         setStatus(next);
         setBrowseRoot(next.browseRoot || "");
         setAllowUnrestrictedBrowse(!!next.allowUnrestrictedBrowse);
-        initializeBrowserBridge(
-          next.csrfToken || "",
-          !!next.nativeBrowseEnabled,
-          !!next.caseInsensitivePaths,
-        );
+        initializeWebClient(next.csrfToken || "", !!next.caseInsensitivePaths);
       })
       .catch((err) => {
         setError(String(err));
         setStatus(initialStatus);
-        initializeBrowserBridge("", false);
+        initializeWebClient("");
       });
-  }, [browserMode]);
+  }, []);
 
   if (status === null) {
     return (
@@ -80,10 +64,6 @@ export default function WebRoot() {
     );
   }
 
-  if (!browserMode) {
-    return <App />;
-  }
-
   if (status.authenticated) {
     const submitBrowsePolicy = async (event?: FormEvent<HTMLFormElement>) => {
       event?.preventDefault();
@@ -93,17 +73,12 @@ export default function WebRoot() {
       setSubmitting(true);
       setError("");
       try {
-        const payload = await browserAuth.saveBrowsePolicy(browseRoot, allowUnrestrictedBrowse);
+        const payload = await authClient.saveBrowsePolicy(browseRoot, allowUnrestrictedBrowse);
         const next = { ...initialStatus, ...(payload as Partial<AuthStatus>) };
         setStatus(next);
         setBrowseRoot(next.browseRoot || "");
         setAllowUnrestrictedBrowse(!!next.allowUnrestrictedBrowse);
-        updateBrowserCSRFToken(next.csrfToken || "", !!next.caseInsensitivePaths);
-        initializeBrowserBridge(
-          next.csrfToken || "",
-          !!next.nativeBrowseEnabled,
-          !!next.caseInsensitivePaths,
-        );
+        updateWebCSRFToken(next.csrfToken || "", !!next.caseInsensitivePaths);
       } catch (err) {
         setError(String(err));
       } finally {
@@ -160,15 +135,15 @@ export default function WebRoot() {
             type="button"
             className="auth-logout"
             onClick={async () => {
-              await browserAuth.logout();
-              updateBrowserCSRFToken("");
+              await authClient.logout();
+              updateWebCSRFToken("");
               window.location.reload();
             }}
           >
             Logout
           </button>
         </div>
-        <App />
+        <App jobOwnerKey={status.username} />
       </div>
     );
   }
@@ -182,18 +157,13 @@ export default function WebRoot() {
     setError("");
     try {
       const payload = status.needsSetup
-        ? await browserAuth.bootstrap(username, password, retainLogin)
-        : await browserAuth.login(username, password, retainLogin);
+        ? await authClient.bootstrap(username, password, retainLogin)
+        : await authClient.login(username, password, retainLogin);
       const next = { ...initialStatus, ...(payload as Partial<AuthStatus>) };
       setStatus(next);
       setBrowseRoot(next.browseRoot || "");
       setAllowUnrestrictedBrowse(!!next.allowUnrestrictedBrowse);
-      updateBrowserCSRFToken(next.csrfToken || "", !!next.caseInsensitivePaths);
-      initializeBrowserBridge(
-        next.csrfToken || "",
-        !!next.nativeBrowseEnabled,
-        !!next.caseInsensitivePaths,
-      );
+      updateWebCSRFToken(next.csrfToken || "", !!next.caseInsensitivePaths);
     } catch (err) {
       setError(String(err));
     } finally {
diff --git a/gui/frontend/stylelint.config.mjs b/webui/stylelint.config.mjs
similarity index 79%
rename from gui/frontend/stylelint.config.mjs
rename to webui/stylelint.config.mjs
index c9672636..f2890fad 100644
--- a/gui/frontend/stylelint.config.mjs
+++ b/webui/stylelint.config.mjs
@@ -1,6 +1,6 @@
 export default {
   extends: ["stylelint-config-recommended"],
-  ignoreFiles: ["dist/**", "src/wailsjs/**"],
+  ignoreFiles: ["dist/**"],
   rules: {
     "at-rule-no-unknown": [
       true,
diff --git a/gui/frontend/tailwind.config.js b/webui/tailwind.config.js
similarity index 100%
rename from gui/frontend/tailwind.config.js
rename to webui/tailwind.config.js
diff --git a/gui/frontend/tsconfig.json b/webui/tsconfig.json
similarity index 100%
rename from gui/frontend/tsconfig.json
rename to webui/tsconfig.json
diff --git a/gui/frontend/tsconfig.node.json b/webui/tsconfig.node.json
similarity index 100%
rename from gui/frontend/tsconfig.node.json
rename to webui/tsconfig.node.json
diff --git a/gui/frontend/vite.config.ts b/webui/vite.config.ts
similarity index 100%
rename from gui/frontend/vite.config.ts
rename to webui/vite.config.ts
diff --git a/gui/frontend/vitest.config.ts b/webui/vitest.config.ts
similarity index 100%
rename from gui/frontend/vitest.config.ts
rename to webui/vitest.config.ts